/** ============================================================================
* @func DSP_Execute
*
* @desc This function implements the execute phase for this application.
*
* @modif None
* ============================================================================
*/
NORMAL_API
DSP_STATUS
DSP_Execute ()
{
DSP_STATUS status = DSP_SOK ;
LOOP_0Print ("Entered DSP_Execute ()\n") ;
status = PROC_start (0) ;
if (DSP_SUCCEEDED (status)) {
LOOP_0Print ("PROC_start succeeded!\n") ;
}
else {
LOOP_1Print ("PROC_start failed. Status = [0x%x]\n", status) ;
}
LOOP_0Print ("Leaving DSP_Execute ()\n") ;
return status ;
}
/** ============================================================================
* @func helloDSP_Create
*
* @desc This function allocates and initializes resources used by
* this application.
*
* @modif helloDSP_InpBufs , helloDSP_OutBufs
* ============================================================================
*/
NORMAL_API DSP_STATUS helloDSP_Create(IN Char8* dspExecutable, IN Char8* strNumIterations, IN Uint8 processorId)
{
DSP_STATUS status = DSP_SOK;
Uint32 numArgs = NUM_ARGS;
MSGQ_LocateAttrs syncLocateAttrs;
Char8* args[NUM_ARGS];
SYSTEM_0Print("Entered helloDSP_Create ()\n");
/* Create and initialize the proc object. */
status = PROC_setup(NULL);
/* Attach the Dsp with which the transfers have to be done. */
if (DSP_SUCCEEDED(status))
{
status = PROC_attach(processorId, NULL);
if (DSP_FAILED(status))
{
SYSTEM_1Print("PROC_attach () failed. Status = [0x%x]\n", status);
}
}
/* Open the pool. */
if (DSP_SUCCEEDED(status))
{
status = POOL_open(POOL_makePoolId(processorId, SAMPLE_POOL_ID), &SamplePoolAttrs);
if (DSP_FAILED(status))
{
SYSTEM_1Print("POOL_open () failed. Status = [0x%x]\n", status);
}
}
else
{
SYSTEM_1Print("PROC_setup () failed. Status = [0x%x]\n", status);
}
/* Open the GPP's message queue */
if (DSP_SUCCEEDED(status))
{
status = MSGQ_open(SampleGppMsgqName, &SampleGppMsgq, NULL);
if (DSP_FAILED(status))
{
SYSTEM_1Print("MSGQ_open () failed. Status = [0x%x]\n", status);
}
}
/* Set the message queue that will receive any async. errors */
if (DSP_SUCCEEDED(status))
{
status = MSGQ_setErrorHandler(SampleGppMsgq, POOL_makePoolId(processorId, SAMPLE_POOL_ID));
if (DSP_FAILED(status))
{
SYSTEM_1Print("MSGQ_setErrorHandler () failed. Status = [0x%x]\n", status);
}
}
/* Load the executable on the DSP. */
if (DSP_SUCCEEDED(status))
{
args [0] = strNumIterations;
{
status = PROC_load(processorId, dspExecutable, numArgs, args);
}
if (DSP_FAILED(status))
{
SYSTEM_1Print("PROC_load () failed. Status = [0x%x]\n", status);
}
}
/* Start execution on DSP. */
if (DSP_SUCCEEDED(status))
{
status = PROC_start(processorId);
if (DSP_FAILED(status))
{
SYSTEM_1Print("PROC_start () failed. Status = [0x%x]\n", status);
}
}
/* Open the remote transport. */
if (DSP_SUCCEEDED(status))
{
mqtAttrs.poolId = POOL_makePoolId(processorId, SAMPLE_POOL_ID);
status = MSGQ_transportOpen(processorId, &mqtAttrs);
if (DSP_FAILED(status))
{
SYSTEM_1Print("MSGQ_transportOpen () failed. Status = [0x%x]\n", status);
}
}
/* Locate the DSP's message queue */
/* At this point the DSP must open a message queue named "DSPMSGQ" */
if (DSP_SUCCEEDED(status))
{
syncLocateAttrs.timeout = WAIT_FOREVER;
status = DSP_ENOTFOUND;
SYSTEM_2Sprint(dspMsgqName, "%s%d", (Uint32) SampleDspMsgqName, processorId);
while ((status == DSP_ENOTFOUND) || (status == DSP_ENOTREADY))
{
status = MSGQ_locate(dspMsgqName, &SampleDspMsgq, &syncLocateAttrs);
if ((status == DSP_ENOTFOUND) || (status == DSP_ENOTREADY))
{
SYSTEM_Sleep(100000);
}
else if (DSP_FAILED(status))
{
SYSTEM_1Print("MSGQ_locate () failed. Status = [0x%x]\n", status);
}
}
}
SYSTEM_0Print("Leaving helloDSP_Create ()\n");
return status;
}
/** ============================================================================
* @func LOOP_Execute
*
* @desc This function implements the execute phase for this application.
*
* @modif None
* ============================================================================
*/
NORMAL_API
DSP_STATUS
LOOP_Execute (IN Uint32 numIterations, Uint8 processorId)
{
DSP_STATUS status = DSP_SOK ;
Uint32 i ;
LOOP_0Print ("Entered LOOP_Execute ()\n") ;
/*
* Start execution on DSP.
*/
status = PROC_start (processorId) ;
/*
* Fill the IO Request structure
* It gives Information for adding or reclaiming an input request.
*/
if (DSP_SUCCEEDED (status)) {
LOOP_IOReq.buffer = LOOP_Buffers [0] ;
LOOP_IOReq.size = LOOP_BufferSize ;
}
else {
LOOP_1Print ("PROC_start failed. Status = [0x%x]\n", status) ;
}
for (i = 1 ;
( (LOOP_NumIterations == 0) || (i <= LOOP_NumIterations))
&& (DSP_SUCCEEDED (status)) ;
i++) {
/*
* Initialize data
*/
status = LOOP_InitData(LOOP_IOReq.buffer);
if (DSP_FAILED (status)) {
LOOP_0Print ("Init data failed.\n") ;
status = DSP_EFAIL;
}
/*
* Send data to DSP.
* Issue 'filled' buffer to the channel.
*/
if (DSP_SUCCEEDED (status)) {
status = CHNL_issue (processorId, CHNL_ID_OUTPUT, &LOOP_IOReq) ;
if (DSP_FAILED (status)) {
LOOP_1Print ("CHNL_issue failed (output). Status = [0x%x]\n",
status) ;
}
}
/*
* Reclaim 'empty' buffer from the channel
*/
if (DSP_SUCCEEDED (status)) {
status = CHNL_reclaim (processorId,
CHNL_ID_OUTPUT,
WAIT_FOREVER,
&LOOP_IOReq) ;
if (DSP_FAILED (status)) {
LOOP_1Print ("CHNL_reclaim failed (output). Status = [0x%x]\n",
status) ;
}
}
/*
* Receive data from DSP
* Issue 'empty' buffer to the channel.
*/
if (DSP_SUCCEEDED (status)) {
status = CHNL_issue (processorId, CHNL_ID_INPUT, &LOOP_IOReq) ;
if (DSP_FAILED (status)) {
LOOP_1Print ("CHNL_issue failed (input). Status = [0x%x]\n",
status) ;
}
}
/*
* Reclaim 'filled' buffer from the channel
*/
if (DSP_SUCCEEDED (status)) {
status = CHNL_reclaim (processorId,
CHNL_ID_INPUT,
WAIT_FOREVER,
&LOOP_IOReq) ;
if (DSP_FAILED (status)) {
LOOP_1Print ("CHNL_reclaim failed (input). Status = [0x%x]\n",
status) ;
}
}
/*
* Verify correctness of data received.
*/
if (DSP_SUCCEEDED (status)) {
status = LOOP_HandleResultData (LOOP_IOReq.buffer) ;
if (DSP_FAILED (status)) {
LOOP_0Print ("Data integrity failed\n") ;
}
}
if (DSP_SUCCEEDED (status) && (i % 1000) == 0) {
LOOP_1Print ("Transferred %ld buffers\n", i) ;
}
}
LOOP_0Print ("Leaving LOOP_Execute ()\n") ;
return status ;
}
/** ============================================================================
* @func pool_notify_Create
*
* @desc This function allocates and initializes resources used by
* this application.
*
* @modif None
* ============================================================================
*/
NORMAL_API
DSP_STATUS
pool_notify_Create (IN Char8 * dspExecutable,
IN Char8 * strBufferSize,
IN Uint8 processorId)
{
DSP_STATUS status = DSP_SOK ;
Uint32 numArgs = NUM_ARGS ;
Void * dspDataBuf = NULL ;
Uint32 numBufs [NUM_BUF_SIZES] = {NUM_BUF_POOL0,
} ;
Uint32 size [NUM_BUF_SIZES] ;
SMAPOOL_Attrs poolAttrs ;
Char8 * args [NUM_ARGS] ;
#ifdef DEBUG
printf ("Entered pool_notify_Create ()\n") ;
#endif
sem_init(&sem,0,0);
/*
* Create and initialize the proc object.
*/
status = PROC_setup (NULL) ;
/*
* Attach the Dsp with which the transfers have to be done.
*/
if (DSP_SUCCEEDED (status)) {
status = PROC_attach (processorId, NULL) ;
if (DSP_FAILED (status)) {
printf ("PROC_attach () failed. Status = [0x%x]\n",
(int)status) ;
}
}
else {
printf ("PROC_setup () failed. Status = [0x%x]\n", (int)status) ;
}
/*
* Open the pool.
*/
if (DSP_SUCCEEDED (status)) {
size [0] = pool_notify_BufferSize ;
poolAttrs.bufSizes = (Uint32 *) &size ;
poolAttrs.numBuffers = (Uint32 *) &numBufs ;
poolAttrs.numBufPools = NUM_BUF_SIZES ;
poolAttrs.exactMatchReq = TRUE ;
status = POOL_open (POOL_makePoolId(processorId, SAMPLE_POOL_ID),
&poolAttrs) ;
if (DSP_FAILED (status)) {
printf ("POOL_open () failed. Status = [0x%x]\n",
(int)status) ;
}
}
/*
* Allocate the data buffer to be used for the application.
*/
if (DSP_SUCCEEDED (status)) {
status = POOL_alloc (POOL_makePoolId(processorId, SAMPLE_POOL_ID),
(Void **) &pool_notify_DataBuf,
pool_notify_BufferSize) ;
/* Get the translated DSP address to be sent to the DSP. */
if (DSP_SUCCEEDED (status)) {
status = POOL_translateAddr (
POOL_makePoolId(processorId, SAMPLE_POOL_ID),
&dspDataBuf,
AddrType_Dsp,
(Void *) pool_notify_DataBuf,
AddrType_Usr) ;
if (DSP_FAILED (status)) {
printf ("POOL_translateAddr () DataBuf failed."
" Status = [0x%x]\n",
(int)status) ;
}
}
else {
printf ("POOL_alloc () DataBuf failed. Status = [0x%x]\n",
(int)status) ;
}
}
/*
* Register for notification that the DSP-side application setup is
* complete.
*/
if (DSP_SUCCEEDED (status)) {
status = NOTIFY_register (processorId,
pool_notify_IPS_ID,
pool_notify_IPS_EVENTNO,
(FnNotifyCbck) pool_notify_Notify,
0/* vladms XFER_SemPtr*/) ;
if (DSP_FAILED (status)) {
printf ("NOTIFY_register () failed Status = [0x%x]\n",
(int)status) ;
}
}
/*
* Load the executable on the DSP.
*/
if (DSP_SUCCEEDED (status)) {
args [0] = strBufferSize ;
{
status = PROC_load (processorId, dspExecutable, numArgs, args) ;
}
if (DSP_FAILED (status)) {
printf ("PROC_load () failed. Status = [0x%x]\n", (int)status) ;
}
}
/*
* Start execution on DSP.
*/
if (DSP_SUCCEEDED (status)) {
status = PROC_start (processorId) ;
if (DSP_FAILED (status)) {
printf ("PROC_start () failed. Status = [0x%x]\n",
(int)status) ;
}
}
/*
* Wait for the DSP-side application to indicate that it has completed its
* setup. The DSP-side application sends notification of the IPS event
* when it is ready to proceed with further execution of the application.
*/
if (DSP_SUCCEEDED (status)) {
// wait for initialization
sem_wait(&sem);
}
/*
* Send notifications to the DSP with information about the address of the
* control structure and data buffer to be used by the application.
*
*/
status = NOTIFY_notify (processorId,
pool_notify_IPS_ID,
pool_notify_IPS_EVENTNO,
(Uint32) dspDataBuf);
if (DSP_FAILED (status)) {
printf ("NOTIFY_notify () DataBuf failed."
" Status = [0x%x]\n",
(int)status) ;
}
status = NOTIFY_notify (processorId,
pool_notify_IPS_ID,
pool_notify_IPS_EVENTNO,
(Uint32) pool_notify_BufferSize);
if (DSP_FAILED (status)) {
printf ("NOTIFY_notify () DataBuf failed."
" Status = [0x%x]\n",
(int)status) ;
}
#ifdef DEBUG
printf ("Leaving pool_notify_Create ()\n") ;
#endif
return status ;
}
