Example #1
0
Int32 encodeReclaim(AUDENC1_Handle enc, int in, int out)
{
    Int32 status;

    GT_4trace(curMask, GT_1CLASS, "App-> inBuf[%d]=%#x, outBuf[%d]=%#x\n",
              in, inBufDesc[in].descs[0].buf,
              out, encodedBufDesc[out].descs[0].buf);

    status = AUDENC1_processWait(enc, &inBufDesc[in],
                                 &encodedBufDesc[out],
                                 &encInArgs[in],
                                 &encOutArgs[out],
                                 AUDENC1_FOREVER);

#ifdef CACHE_ENABLED
    /*
     * Since encodedBuf is an inBuf to the next process call, we
     * must invalidate it, to clean buffer lines.
     */
    Memory_cacheWbInv(encodedBuf[out], EFRAMESIZE);
#endif

    GT_1trace(curMask, GT_2CLASS,
              "App-> Encoder processWait returned 0x%x\n", status);
    if (status != AUDENC1_EOK) {
        GT_1trace(curMask, GT_7CLASS,
                  "App-> Encodcer processing FAILED, extendedError = 0x%x\n",
                  encOutArgs[out].extendedError);
    }

    return status;
}
Example #2
0
/* Function to write back invalidate the Cache module */
Void Cache_wbInv(Ptr blockPtr, UInt32 byteCnt, Bits16 type, Bool wait) {
    GT_4trace (curTrace, GT_ENTER, "Cache_wbInv", blockPtr, byteCnt, type, wait);
#if 0

/*
 * It appears that this #if 0'ed code doesn't actually perform the
 * invalidate part of the wbInv, and it appears that Cache_wb() and Cache_inv()
 * work properly, so for now we implement wbInv as a combination of the two
 * individual functions.
*/

#ifdef USE_CACHE_VOID_ARG
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34)
                dmac_map_area(blockPtr, (size_t)byteCnt, DMA_BIDIRECTIONAL);
                outer_flush_range(__pa((UInt32)blockPtr),
                                  __pa((UInt32)(blockPtr+byteCnt)) );
#else
                dmac_flush_range(blockPtr, (blockPtr+byteCnt) );
#endif
#else
                dmac_flush_range( (UInt32)blockPtr, (UInt32)(blockPtr + byteCnt) );
#endif

#else

    Cache_wb(blockPtr, byteCnt, type, wait);
    Cache_inv(blockPtr, byteCnt, type, wait);

#endif

    GT_0trace (curTrace, GT_LEAVE, "Cache_wbInv");
}
Example #3
0
/*
 *  ======== STRM_Issue ========
 *  Purpose:
 *      Issues a buffer on a stream
 */
DSP_STATUS STRM_Issue(struct STRM_OBJECT *hStrm, IN u8 *pBuf, u32 ulBytes,
		     u32 ulBufSize, u32 dwArg)
{
	struct WMD_DRV_INTERFACE *pIntfFxns;
	DSP_STATUS status = DSP_SOK;
	void *pTmpBuf = NULL;

	DBC_Require(cRefs > 0);
	DBC_Require(pBuf != NULL);

	GT_4trace(STRM_debugMask, GT_ENTER, "STRM_Issue: hStrm: 0x%x\tpBuf: "
		 "0x%x\tulBytes: 0x%x\tdwArg: 0x%x\n", hStrm, pBuf, ulBytes,
		 dwArg);

	pIntfFxns = hStrm->hStrmMgr->pIntfFxns;

	if (hStrm->uSegment != 0) {
		pTmpBuf = CMM_XlatorTranslate(hStrm->hXlator,
				(void *)pBuf, CMM_VA2DSPPA);
		if (pTmpBuf == NULL)
			status = DSP_ETRANSLATE;

	}
	if (DSP_SUCCEEDED(status)) {
		status = (*pIntfFxns->pfnChnlAddIOReq)
			 (hStrm->hChnl, pBuf, ulBytes, ulBufSize,
			 (u32) pTmpBuf, dwArg);
	}
	if (status == CHNL_E_NOIORPS)
		status = DSP_ESTREAMFULL;

	return status;
}
Example #4
0
/*
 *  ======== COD_ReadSection ========
 *  Purpose:
 *      Retrieve the content of a code section given the section name.
 */
DSP_STATUS COD_ReadSection(struct COD_LIBRARYOBJ *lib, IN char *pstrSect,
			   OUT char *pstrContent, IN u32 cContentSize)
{
	DSP_STATUS status = DSP_SOK;

	DBC_Require(cRefs > 0);
	DBC_Require(lib != NULL);
	DBC_Require(IsValid(lib->hCodMgr));
	DBC_Require(pstrSect != NULL);
	DBC_Require(pstrContent != NULL);

	GT_4trace(COD_debugMask, GT_ENTER, "Entered COD_ReadSection Args: 0x%x,"
		 " 0x%x, 0x%x, 0x%x\n", lib, pstrSect, pstrContent,
		 cContentSize);

	if (lib != NULL) {
		status = lib->hCodMgr->fxns.readSectFxn(lib->dbllLib, pstrSect,
							pstrContent,
							cContentSize);
		if (DSP_FAILED(status)) {
			GT_1trace(COD_debugMask, GT_7CLASS,
				 "COD_ReadSection failed: 0x%lx\n", status);
		}
	} else {
		status = COD_E_NOSYMBOLSLOADED;
		GT_0trace(COD_debugMask, GT_7CLASS,
			  "COD_ReadSection: No Symbols loaded\n");
	}
	return status;
}
Example #5
0
/*
 * ======== PROCWRAP_EnumResources ========
 */
u32 PROCWRAP_EnumResources(union Trapped_Args *args, void *pr_ctxt)
{
	DSP_STATUS status = DSP_SOK;
	struct DSP_RESOURCEINFO pResourceInfo;

	if (DSP_FAILED(status))
		goto func_end;

	GT_4trace(WCD_debugMask, GT_ENTER,
		 "PROCWRAP_EnumResources: entered args:\n"
		 "0x%x hProcessor: 0x%x\tuResourceMask: 0x%x\tpResourceInfo"
		 " 0x%x\tuResourceInfoSixe \n",
		 args->ARGS_PROC_ENUMRESOURCES.hProcessor,
		 args->ARGS_PROC_ENUMRESOURCES.uResourceType,
		 args->ARGS_PROC_ENUMRESOURCES.pResourceInfo,
		 args->ARGS_PROC_ENUMRESOURCES.uResourceInfoSize);
	status = PROC_GetResourceInfo(args->ARGS_PROC_ENUMRESOURCES.hProcessor,
			args->ARGS_PROC_ENUMRESOURCES.uResourceType,
			&pResourceInfo,
			args->ARGS_PROC_ENUMRESOURCES.uResourceInfoSize);
	if (DSP_FAILED(status))
		goto func_end;
	cp_to_usr(args->ARGS_PROC_ENUMRESOURCES.pResourceInfo, &pResourceInfo,
						status, 1);
func_end:
	return status;

}
Example #6
0
/* Function to write configuration information to Ipc module */
Int
Ipc_writeConfig (UInt16 remoteProcId, UInt32 tag, Ptr cfg, SizeT size)
{
    Int             status    = Ipc_S_SUCCESS;
    IpcDrv_CmdArgs cmdArgs;

    GT_4trace (curTrace, GT_ENTER, "Ipc_writeConfig",
               remoteProcId, tag, cfg, size);

    cmdArgs.args.writeConfig.remoteProcId = remoteProcId;
    cmdArgs.args.writeConfig.tag          = tag;
    cmdArgs.args.writeConfig.cfg          = cfg;
    cmdArgs.args.writeConfig.size         = size;
    status = IpcDrv_ioctl (CMD_IPC_WRITECONFIG, &cmdArgs);
#if !defined(SYSLINK_BUILD_OPTIMIZE)
    if (status < 0) {
        GT_setFailureReason (curTrace,
                             GT_4CLASS,
                             "Ipc_writeConfig",
                             status,
                             "API (through IOCTL) failed on kernel-side!");
    }
#endif /* if !defined(SYSLINK_BUILD_OPTIMIZE) */

    GT_1trace (curTrace, GT_LEAVE, "Ipc_writeConfig", status);

    /*! @retval Ipc_S_SUCCESS Operation was successful */
    return status;
}
Example #7
0
/*
 * ======== MGRWRAP_EnumProc_Info ========
 */
u32 MGRWRAP_EnumProc_Info(union Trapped_Args *args, void *pr_ctxt)
{
	u8 *pProcessorInfo;
	u32 uNumProcs;
	DSP_STATUS status = DSP_SOK;
	u32 size = args->ARGS_MGR_ENUMPROC_INFO.uProcessorInfoSize;

	GT_4trace(WCD_debugMask, GT_ENTER,
		 "MGRWRAP_EnumProc_Info: entered args:\n"
		 "0x%x uProcessor: 0x%x\tpProcessorInfo: 0x%x\t"
		 "uProcessorInfoSize: 0x%x\tpuNumProcs \n",
		 args->ARGS_MGR_ENUMPROC_INFO.uProcessor,
		 args->ARGS_MGR_ENUMPROC_INFO.pProcessorInfo,
		 args->ARGS_MGR_ENUMPROC_INFO.uProcessorInfoSize,
		 args->ARGS_MGR_ENUMPROC_INFO.puNumProcs);
	pProcessorInfo = MEM_Alloc(size, MEM_NONPAGED);
	if (pProcessorInfo == NULL)
		status = DSP_EMEMORY;

	if (DSP_SUCCEEDED(status)) {
		status = MGR_EnumProcessorInfo(args->
				ARGS_MGR_ENUMPROC_INFO.uProcessor,
				(struct DSP_PROCESSORINFO *)pProcessorInfo,
				size, &uNumProcs);
	}
	cp_to_usr(args->ARGS_MGR_ENUMPROC_INFO.pProcessorInfo, pProcessorInfo,
		 status, size);
	cp_to_usr(args->ARGS_MGR_ENUMPROC_INFO.puNumProcs, &uNumProcs,
		 status, 1);
	if (pProcessorInfo)
		MEM_Free(pProcessorInfo);

	return status;
}
Example #8
0
/*
 * ======== MGRWRAP_EnumNode_Info ========
 */
u32 MGRWRAP_EnumNode_Info(union Trapped_Args *args, void *pr_ctxt)
{
	u8 *pNDBProps;
	u32 uNumNodes;
	DSP_STATUS status = DSP_SOK;
	u32 size = args->ARGS_MGR_ENUMNODE_INFO.uNDBPropsSize;

	GT_4trace(WCD_debugMask, GT_ENTER,
		 "MGR_EnumNodeInfo: entered args:\n0x%x"
		 " uNode: 0x%x\tpNDBProps: 0x%x\tuNDBPropsSize: "
		 "0x%x\tpuNumNodes\n", args->ARGS_MGR_ENUMNODE_INFO.uNode,
		 args->ARGS_MGR_ENUMNODE_INFO.pNDBProps,
		 args->ARGS_MGR_ENUMNODE_INFO.uNDBPropsSize,
		 args->ARGS_MGR_ENUMNODE_INFO.puNumNodes);
	pNDBProps = MEM_Alloc(size, MEM_NONPAGED);
	if (pNDBProps == NULL)
		status = DSP_EMEMORY;

	if (DSP_SUCCEEDED(status)) {
		status = MGR_EnumNodeInfo(args->ARGS_MGR_ENUMNODE_INFO.uNode,
					 (struct DSP_NDBPROPS *)pNDBProps,
					 size, &uNumNodes);
	}
	cp_to_usr(args->ARGS_MGR_ENUMNODE_INFO.pNDBProps, pNDBProps, status,
		 size);
	cp_to_usr(args->ARGS_MGR_ENUMNODE_INFO.puNumNodes, &uNumNodes, status,
		 1);
	if (pNDBProps)
		MEM_Free(pNDBProps);

	return status;
}
Example #9
0
Int32 decodeReclaim(AUDDEC1_Handle dec, int in, int out)
{
    Int32 status;

    GT_4trace(curMask, GT_1CLASS, "App-> inBuf[%d]=%#x, outBuf[%d]=%#x\n",
              in, encodedBufDesc[in].descs[0].buf,
              out, outBufDesc[out].descs[0].buf);

    status = AUDDEC1_processWait(dec, &encodedBufDesc[in],
                                 &outBufDesc[out],
                                 &decInArgs[in],
                                 &decOutArgs[out],
                                 AUDDEC1_FOREVER);

#ifdef CACHE_ENABLED
    /* Writeback the outBuf. */
    Memory_cacheWb(outBuf[out], OFRAMESIZE);
#endif

    GT_1trace(curMask, GT_2CLASS,
              "App-> Decoder processWait returned 0x%x\n", status);
    if (status != AUDDEC1_EOK) {
        GT_1trace(curMask, GT_7CLASS,
                  "App-> Decoder processing FAILED, extendedError = 0x%x\n",
                  decOutArgs[out].extendedError);
    }

    return status;
}
Example #10
0
Int32 decodeIssue(AUDDEC1_Handle dec, int in, int out)
{
    Int32 status;

#ifdef CACHE_ENABLED
    /* Per DMA Rule 7, our output buffer cache lines must be cleaned */
    Memory_cacheInv(outBuf[out], OFRAMESIZE);
#endif

    /* decode the frame */
    decInArgs[in].numBytes = EFRAMESIZE;

    GT_4trace(curMask, GT_1CLASS, "App-> inBuf[%d]=%#x, outBuf[%d]=%#x\n",
              in, encodedBufDesc[in].descs[0].buf,
              out, outBufDesc[out].descs[0].buf);

    status = AUDDEC1_processAsync(dec, &encodedBufDesc[in],
                                  &outBufDesc[out],
                                  &decInArgs[in],
                                  &decOutArgs[out]);

    GT_1trace(curMask, GT_2CLASS,
              "App-> Decoder processAsync returned 0x%x\n", status);
    if (status != AUDDEC1_EOK) {
        GT_0trace(curMask, GT_7CLASS, "App-> Decoder processing FAILED\n");
    }

    return status;
}
Example #11
0
/* Function to allocate the specified number of bytes and memory is set to
 * the specified value.
 */
Ptr
Memory_valloc (IHeap_Handle heap, SizeT size, SizeT align, Char value, Ptr eb)
{
    Ptr buffer = NULL;

    GT_4trace (curTrace, GT_ENTER, "Memory_valloc", heap, size, align, eb);

    /* Check whether the right paramaters are passed or not.*/
    GT_assert (curTrace, (size > 0));
    (Void) eb; /* Not used. */

    if (heap == NULL) {
        buffer = MemoryOS_alloc (size, align, 0);
#if !defined(SYSLINK_BUILD_OPTIMIZE)
        if (buffer == NULL) {
            /*! @retval NULL Failed to allocate memory */
            GT_setFailureReason (curTrace,
                                 GT_4CLASS,
                                 "Memory_valloc",
                                 Memory_E_MEMORY,
                                 "Failed to allocate memory!");
        }
#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */
    }
    else {
        buffer = IHeap_alloc (heap, size, align);
#if !defined(SYSLINK_BUILD_OPTIMIZE)
        if (buffer == NULL) {
            /*! @retval NULL Heap_alloc failed */
            GT_setFailureReason (curTrace,
                                 GT_4CLASS,
                                 "Memory_valloc",
                                 Memory_E_MEMORY,
                                 "IHeap_alloc failed!");
        }
#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */
    }

#if !defined(SYSLINK_BUILD_OPTIMIZE)
    if (buffer != NULL) {
#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */
        buffer = Memory_set (buffer, value, size);
#if !defined(SYSLINK_BUILD_OPTIMIZE)
        if (buffer == NULL) {
            /*! @retval NULL Memory_set to 0 failed */
            GT_setFailureReason (curTrace,
                                 GT_4CLASS,
                                 "Memory_valloc",
                                 Memory_E_MEMORY,
                                 "Memory_set to 0 failed!");
        }
    }
#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */

    GT_0trace (curTrace, GT_LEAVE, "Memory_valloc");

    /*! @retval Pointer Success: Pointer to allocated buffer */
    return buffer;
}
Example #12
0
Int32 encodeIssue(AUDENC1_Handle enc, int in, int out)
{
    Int32 status;

#if USE_ANCDATA
    /* we send the same data as inBuf as ancillory data */
    memcpy(ancBuf[in], inBuf[in], ENCANCBUFSIZE);
#endif

    /* Deal with cache issues, if necessary */
#ifdef CACHE_ENABLED
#ifdef xdc_target__isaCompatible_64P
    /*
     *  fread() on this processor is implemented using CCS's stdio, which
     *  is known to write into the cache, not physical memory.  To meet
     *  xDAIS DMA Rule 7, we must writeback the cache into physical
     *  memory.  Also, per DMA Rule 7, we must invalidate the buffer's
     *  cache before providing it to any xDAIS algorithm.
     */
    Memory_cacheWbInv(inBuf[in], IFRAMESIZE);
#else
#error Unvalidated config - add appropriate fread-related cache maintenance
#endif

#if USE_ANCDATA
    /* ancBuf is an inBuf, filled via memcpy (i.e. CPU writes) */
    Memory_cacheWbInv(ancBuf[in], ENCANCBUFSIZE);
#endif

    /* Per DMA Rule 7, our output buffer cache lines must be cleaned */
    Memory_cacheInv(encodedBuf[out], EFRAMESIZE);
#endif

    GT_4trace(curMask, GT_1CLASS, "App-> inBuf[%d]=%#x, outBuf[%d]=%#x\n",
              in, inBufDesc[in].descs[0].buf,
              out, encodedBufDesc[out].descs[0].buf);

    /*
     * Encode the frame.  Note that .numInSamples is the number of
     * _samples_ not bytes.  IFRAMESIZE is in 8-bit bytes, so there's a
     * little math here to get .numInSamples right.
     */
    encInArgs[in].numInSamples =
        (IFRAMESIZE / (ENCBITSPERSAMPLE / (8 /* bits per byte */)));

    status = AUDENC1_processAsync(enc, &inBufDesc[in],
                                  &encodedBufDesc[out],
                                  &encInArgs[in],
                                  &encOutArgs[out]);

    GT_1trace(curMask, GT_2CLASS,
              "App-> Encoder processAsync returned 0x%x\n", status);
    if (status != AUDENC1_EOK) {
        GT_0trace(curMask, GT_7CLASS, "App-> Encodcer processing FAILED\n");
    }

    return status;
}
Example #13
0
/*
 *  ======== VIDDECCOPY_TI_control ========
 */
XDAS_Int32 VIDDECCOPY_TI_control(IVIDDEC_Handle handle, IVIDDEC_Cmd id,
    IVIDDEC_DynamicParams *params, IVIDDEC_Status *status)
{
    XDAS_Int32 retVal;

    GT_4trace(curTrace, GT_ENTER, "VIDDECCOPY_TI_control(0x%lx, 0x%lx, 0x%lx, "
        "0x%lx)\n", handle, id, params, status);

    /* validate arguments - this codec only supports "base" xDM. */
    if ((params->size != sizeof(*params)) ||
        (status->size != sizeof(*status))) {

        GT_2trace(curTrace, GT_ENTER, "VIDDECCOPY_TI_control, unsupported size "
            "(0x%lx, 0x%lx)\n", params->size, status->size);

        return (IVIDDEC_EFAIL);
    }

    switch (id) {
        case XDM_GETSTATUS:
            status->extendedError = 0;
            status->outputHeight = 0;  /* TODO */
            status->outputWidth = 0;  /* TODO */
            status->frameRate = 0;  /* TODO */
            status->bitRate = 0;  /* TODO */
            status->contentType = 0;  /* TODO */
            status->outputChromaFormat = 0;  /* TODO */

            /* Note, intentionally no break here so we fill in bufInfo, too */

        case XDM_GETBUFINFO:
            status->bufInfo.minNumInBufs = MININBUFS;
            status->bufInfo.minNumOutBufs = MINOUTBUFS;
            status->bufInfo.minInBufSize[0] = MININBUFSIZE;
            status->bufInfo.minOutBufSize[0] = MINOUTBUFSIZE;

            retVal = IVIDDEC_EOK;

            break;

        case XDM_SETPARAMS:
        case XDM_SETDEFAULT:
        case XDM_RESET:
        case XDM_FLUSH:
            /* TODO - for now just return success. */

            retVal = IVIDDEC_EOK;
            break;

        default:
            /* unsupported cmd */
            retVal = IVIDDEC_EFAIL;

            break;
    }

    return (retVal);
}
Example #14
0
/*
 *  ======== VIDDECCOPY_TI_initObj ========
 */
Int VIDDECCOPY_TI_initObj(IALG_Handle handle,
    const IALG_MemRec memTab[], IALG_Handle p,
    const IALG_Params *algParams)
{
    GT_4trace(curTrace, GT_ENTER, "VIDDECCOPY_TI_initObj(0x%lx, 0x%lx, 0x%lx, "
        "0x%lx)\n", handle, memTab, p, algParams);

    return (IALG_EOK);
}
Example #15
0
/*
 *  ======== DBLL_getSect ========
 *  Get the base address and size (in bytes) of a COFF section.
 */
DSP_STATUS DBLL_getSect(struct DBLL_LibraryObj *lib, char *name, u32 *pAddr,
			u32 *pSize)
{
	u32 uByteSize;
	bool fOpenedDoff = false;
	const struct LDR_SECTION_INFO *sect = NULL;
	struct DBLL_LibraryObj *zlLib = (struct DBLL_LibraryObj *)lib;
	DSP_STATUS status = DSP_SOK;

	DBC_Require(cRefs > 0);
	DBC_Require(name != NULL);
	DBC_Require(pAddr != NULL);
	DBC_Require(pSize != NULL);
	DBC_Require(MEM_IsValidHandle(zlLib, DBLL_LIBSIGNATURE));

	GT_4trace(DBLL_debugMask, GT_ENTER,
		 "DBLL_getSect: lib: 0x%x name: %s pAddr:"
		 " 0x%x pSize: 0x%x\n", lib, name, pAddr, pSize);
	/* If DOFF file is not open, we open it. */
	if (zlLib != NULL) {
		if (zlLib->fp == NULL) {
			status = dofOpen(zlLib);
			if (DSP_SUCCEEDED(status))
				fOpenedDoff = true;

		} else {
			(*(zlLib->pTarget->attrs.fseek))(zlLib->fp,
			 zlLib->ulPos, SEEK_SET);
		}
	} else {
		status = DSP_EHANDLE;
	}
	if (DSP_SUCCEEDED(status)) {
		uByteSize = 1;
		if (DLOAD_GetSectionInfo(zlLib->desc, name, &sect)) {
			*pAddr = sect->load_addr;
			*pSize = sect->size * uByteSize;
			/* Make sure size is even for good swap */
			if (*pSize % 2)
				(*pSize)++;

			/* Align size */
			*pSize = DOFF_ALIGN(*pSize);
		} else {
			status = DSP_ENOSECT;
		}
	}
	if (fOpenedDoff) {
		dofClose(zlLib);
		fOpenedDoff = false;
	}

	return status;
}
Example #16
0
/*
 *  ======== VIDDECCOPY_TI_initObj ========
 */
Int VIDDECCOPY_TI_initObj(IALG_Handle handle,
    const IALG_MemRec memTab[], IALG_Handle p,
    const IALG_Params *algParams)
{
    GT_4trace(curTrace, GT_ENTER, "VIDDECCOPY_TI_initObj(0x%lx, 0x%lx, 0x%lx, "
        "0x%lx)\n", handle, memTab, p, algParams);

    // VIDENCCOPY_TI_Obj *VIDENC_COPY = (Void *)handle;

   // ((VIDDECCOPY_TI_Obj *)handle)->pGray  = memTab[1].base;

    return (IALG_EOK);
}
/*
 *  ======== VIDENCCOPY_TI_control ========
 */
XDAS_Int32 VIDENCCOPY_TI_control(IVIDENC_Handle handle, IVIDENC_Cmd id,
    IVIDENC_DynamicParams *params, IVIDENC_Status *status)
{
    XDAS_Int32 retVal;

    GT_4trace(curTrace, GT_ENTER, "VIDENCCOPY_TI_control(0x%x, 0x%x, 0x%x, "
        "0x%x)\n", handle, id, params, status);

    /* validate arguments - this codec only supports "base" xDM. */
    if ((params->size != sizeof(*params)) ||
        (status->size != sizeof(*status))) {

        GT_2trace(curTrace, GT_ENTER,
            "VIDENCCOPY_TI_control, unsupported size "
            "(0x%x, 0x%x)\n", params->size, status->size);

        return (IVIDENC_EFAIL);
    }

    switch (id) {
        case XDM_GETSTATUS:
        case XDM_GETBUFINFO:
            status->extendedError = 0;

            status->bufInfo.minNumInBufs = MININBUFS;
            status->bufInfo.minNumOutBufs = MINOUTBUFS;
            status->bufInfo.minInBufSize[0] = MININBUFSIZE;
            status->bufInfo.minOutBufSize[0] = MINOUTBUFSIZE;

            retVal = IVIDENC_EOK;

            break;

        case XDM_SETPARAMS:
        case XDM_SETDEFAULT:
        case XDM_RESET:
        case XDM_FLUSH:
            /* TODO - for now just return success. */

            retVal = IVIDENC_EOK;
            break;

        default:
            /* unsupported cmd */
            retVal = IVIDENC_EFAIL;

            break;
    }

    return (retVal);
}
Example #18
0
/*
 *  ======== KFILE_Read ========
 *  Purpose:
 *      Reads a specified number of bytes into a buffer.
 */
s32
KFILE_Read(void __user*pBuffer, s32 cSize, s32 cCount,
			struct KFILE_FileObj *hFile)
{
	u32 dwBytesRead = 0;
	s32 cRetVal = 0;
	mm_segment_t fs;

	DBC_Require(pBuffer != NULL);

	GT_4trace(KFILE_debugMask, GT_4CLASS,
		  "KFILE_Read: buffer 0x%x, cSize 0x%x,"
		  "cCount 0x%x, hFile 0x%x\n", pBuffer, cSize, cCount, hFile);

	/* check for valid file handle */
	if (MEM_IsValidHandle(hFile, SIGNATURE)) {
		if ((cSize > 0) && (cCount > 0) && pBuffer) {
			/* read from file */
			fs = get_fs();
			set_fs(get_ds());
			dwBytesRead = hFile->fileDesc->f_op->read(hFile->
				      fileDesc, pBuffer, cSize *cCount,
				      &(hFile->fileDesc->f_pos));
			set_fs(fs);
			if (dwBytesRead) {
				cRetVal = dwBytesRead / cSize;
				hFile->curPos += dwBytesRead;
				DBC_Assert((dwBytesRead / cSize) <= \
					  (u32)cCount);
			} else {
				cRetVal = E_KFILE_ERROR;
				GT_0trace(KFILE_debugMask, GT_6CLASS,
					  "KFILE_Read: sys_read() failed\n");
			}
		} else {
			cRetVal = DSP_EINVALIDARG;
			GT_0trace(KFILE_debugMask, GT_6CLASS,
				  "KFILE_Read: Invalid argument(s)\n");
		}
	} else {
		cRetVal = E_KFILE_INVALIDHANDLE;
		GT_0trace(KFILE_debugMask, GT_6CLASS,
			  "KFILE_Read: invalid file handle\n");
	}

	return cRetVal;
}
Example #19
0
/* Allocates the specified number of bytes. */
Ptr
Memory_alloc (IHeap_Handle heap, SizeT size, SizeT align, Ptr eb)
{
    Ptr buffer = NULL;

    GT_4trace (curTrace, GT_ENTER, "Memory_alloc", heap, size, align, eb);

    /* check whether the right paramaters are passed or not.*/
    GT_assert (curTrace, (size > 0));
    (Void) eb; /* Not used. */

    if (heap == NULL) {
        /* Call the kernel API for memory allocation */
        buffer = MemoryOS_alloc (size, align, 0);
#if !defined(SYSLINK_BUILD_OPTIMIZE)
        if (buffer == NULL) {
            GT_setFailureReason (curTrace,
                                 GT_4CLASS,
                                 "Memory_alloc",
                                 Memory_E_MEMORY,
                                 "Failed to allocate memory!");
        }
#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */
    }
    else {
        /* if align == 0, use default alignment */
        if (align == 0) {
            align = Memory_getMaxDefaultTypeAlign ();
        }

        buffer = IHeap_alloc (heap, size, align);
#if !defined(SYSLINK_BUILD_OPTIMIZE)
        if (buffer == NULL) {
            /*! @retval NULL Heap_alloc failed */
            GT_setFailureReason (curTrace,
                                 GT_4CLASS,
                                 "Memory_alloc",
                                 Memory_E_MEMORY,
                                 "IHeap_alloc failed!");
        }
#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */
    }

    GT_1trace (curTrace, GT_LEAVE, "Memory_alloc", buffer);

    return buffer;
}
Example #20
0
/* Function to invalidate the Cache module */
Void Cache_inv(Ptr blockPtr, UInt32 byteCnt, Bits16 type, Bool wait) {
    GT_4trace (curTrace, GT_ENTER, "Cache_inv", blockPtr, byteCnt, type, wait);

#ifdef USE_CACHE_VOID_ARG
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34))
    dmac_map_area(blockPtr, (size_t)byteCnt, DMA_FROM_DEVICE);
    outer_inv_range(__pa((UInt32)blockPtr),
                    __pa((UInt32)(blockPtr + byteCnt)) );
#else
    dmac_inv_range(blockPtr, (blockPtr + byteCnt) );
#endif
#else
    dmac_inv_range( (UInt32)blockPtr, (UInt32)(blockPtr + byteCnt) );
#endif

    GT_0trace (curTrace, GT_LEAVE, "Cache_inv");
}
/*
 *  ======== ACPY3_deInitEnv ========
 */
static Bool ACPY3_deInitEnv(IDMA3_Handle handle)
{
    Void   *scratchEnv;

    GT_1trace(ti_sdo_fc_acpy3_GTMask, GT_ENTER, 
            "ACPY3_deInitEnv > Enter (handle=0x%x)\n", handle);

    DBC_require(handle->protocol == &ACPY3_PROTOCOL);

    scratchEnv = ((ACPY3_MoreEnv *)(handle->env))->scratchEnv;

    if (scratchEnv != NULL) {
        scratchEnv = (Void *)((Uns)scratchEnv - handle->numPaRams * PARAMSIZE);
        

        GT_1trace(ti_sdo_fc_acpy3_GTMask, GT_2CLASS, "ACPY3_deInitEnv> "
                "ScratchEnv is 0x%x\n", scratchEnv);
    }

    /*
     *  Restore original values of numTccs and numPaRams, since
     *  ACPY3_setFinal() may have changed them.
     */
    handle->numTccs = ((ACPY3_MoreEnv *)(handle->env))->numTccs;
    handle->numPaRams = ((ACPY3_MoreEnv *)(handle->env))->numPaRams;

    /* Restore env pointer */
    handle->env = (Void *)((Uns)handle->env - handle->numPaRams * PARAMSIZE);

    /* Restore scratch env pointer */
    *((unsigned *)(handle->env)) = (unsigned)scratchEnv;


    GT_4trace(ti_sdo_fc_acpy3_GTMask, GT_2CLASS, "ACPY3_deInitEnv> Restoring "
            "original values in IDMA3 handle back to %d Tccs %d PaRams, "
            "env 0x%x scratch env 0x%x\n", handle->numTccs, handle->numPaRams, 
            handle->env, scratchEnv);

    _ACPY3_exit();

    GT_0trace(ti_sdo_fc_acpy3_GTMask, GT_ENTER, "ACPY3_deInitEnv > Enter "
            "(status=TRUE)\n");

    return (TRUE);
}
/*
 *  ======== ACPY3_fastConfigure32b ========
 */
Void ACPY3_fastConfigure32b(IDMA3_Handle restrict handle,
    ACPY3_ParamField32b fieldId, Uns value, short transferNo)
{
    ACPY3_PaRamRegs * paRamCache;
#ifndef _ACPY3_CPUCOPY_
    UInt32            physVal;
    Int               size;
#endif

    GT_assert(CURTRACE, handle != NULL);
    GT_assert(CURTRACE, handle->protocol == &ACPY3_PROTOCOL);
    GT_assert(CURTRACE, transferNo >= 0);
    GT_assert(CURTRACE,
            transferNo < ((ACPY3_MoreEnv *)(handle->env))->numPaRams);
    GT_assert(CURTRACE, !handle->transferPending);

    GT_4trace(CURTRACE, GT_ENTER, "ACPY3_fastConfigure32b> "
            "Enter (handle=0x%x, fieldId=0x%x, value=0x%x, transferNo=%d)\n",
            handle, fieldId, value, transferNo);

    paRamCache = (ACPY3_PaRamRegs *)ACPY3_getPaRamCache(handle, transferNo);

#ifndef _ACPY3_CPUCOPY_
    /* Address fields must be converted to physical address */
    size = 4; /* Otherwise we have to read the registers */
    if ((fieldId == ACPY3_PARAMFIELD_SRCADDR) ||
            (fieldId == ACPY3_PARAMFIELD_DSTADDR)) {
        physVal = (UInt32)MEMUTILS_getPhysicalAddr((Ptr)value);
        *((Uns *)((Uns)paRamCache + fieldId)) = physVal;
    }
    else {
        /* Non-address field */
        *((Uns *)((Uns)paRamCache + fieldId)) = value;
    }
#else
    *((Uns *)((Uns)paRamCache + fieldId)) = value;
#endif

    GT_0trace(CURTRACE, GT_ENTER, "ACPY3_fastConfigure32b> Exit\n");

}
Example #23
0
/*
 *  ======== COD_Open ========
 *      Open library for reading sections.
 */
DSP_STATUS COD_Open(struct COD_MANAGER *hMgr, IN char *pszCoffPath,
		    COD_FLAGS flags, struct COD_LIBRARYOBJ **pLib)
{
	DSP_STATUS status = DSP_SOK;
	struct COD_LIBRARYOBJ *lib = NULL;

	DBC_Require(cRefs > 0);
	DBC_Require(IsValid(hMgr));
	DBC_Require(pszCoffPath != NULL);
	DBC_Require(flags == COD_NOLOAD || flags == COD_SYMB);
	DBC_Require(pLib != NULL);

	GT_4trace(COD_debugMask, GT_ENTER, "Entered COD_Open, hMgr: 0x%x\n\t "
		  "pszCoffPath:  0x%x\tflags: 0x%x\tlib: 0x%x\n", hMgr,
		  pszCoffPath, flags, pLib);

	*pLib = NULL;

	lib = MEM_Calloc(sizeof(struct COD_LIBRARYOBJ), MEM_NONPAGED);
	if (lib == NULL) {
		GT_0trace(COD_debugMask, GT_7CLASS,
			 "COD_Open: Out Of Memory\n");
		status = DSP_EMEMORY;
	}

	if (DSP_SUCCEEDED(status)) {
		lib->hCodMgr = hMgr;
		status = hMgr->fxns.openFxn(hMgr->target, pszCoffPath, flags,
					   &lib->dbllLib);
		if (DSP_FAILED(status)) {
			GT_1trace(COD_debugMask, GT_7CLASS,
				 "COD_Open failed: 0x%x\n", status);
		} else {
			*pLib = lib;
		}
	}

	return status;
}
Example #24
0
/*
 *  ======== COD_GetSection ========
 *  Purpose:
 *      Retrieve the starting address and length of a section in the COFF file
 *      given the section name.
 */
DSP_STATUS COD_GetSection(struct COD_LIBRARYOBJ *lib, IN char *pstrSect,
			  OUT u32 *puAddr, OUT u32 *puLen)
{
	struct COD_MANAGER *hManager;
	DSP_STATUS status = DSP_SOK;

	DBC_Require(cRefs > 0);
	DBC_Require(lib != NULL);
	DBC_Require(IsValid(lib->hCodMgr));
	DBC_Require(pstrSect != NULL);
	DBC_Require(puAddr != NULL);
	DBC_Require(puLen != NULL);

	GT_4trace(COD_debugMask, GT_ENTER,
		  "Entered COD_GetSection Args \t\n lib: "
		  "0x%x\t\npstrsect: 0x%x\t\npuAddr: 0x%x\t\npuLen: 0x%x\n",
		  lib, pstrSect, puAddr, puLen);
	*puAddr = 0;
	*puLen = 0;
	if (lib != NULL) {
		hManager = lib->hCodMgr;
		status = hManager->fxns.getSectFxn(lib->dbllLib, pstrSect,
						   puAddr, puLen);
		if (DSP_FAILED(status)) {
			GT_1trace(COD_debugMask, GT_7CLASS,
				 "COD_GetSection: Section %s not"
				 "found\n", pstrSect);
		}
	} else {
		status = COD_E_NOSYMBOLSLOADED;
		GT_0trace(COD_debugMask, GT_7CLASS,
			  "COD_GetSection:No Symbols loaded\n");
	}

	DBC_Ensure(DSP_SUCCEEDED(status) || ((*puAddr == 0) && (*puLen == 0)));

	return status;
}
Example #25
0
/*
 *  ======== STRM_RegisterNotify ========
 *  Purpose:
 *      Register to be notified on specific events for this stream.
 */
DSP_STATUS STRM_RegisterNotify(struct STRM_OBJECT *hStrm, u32 uEventMask,
			      u32 uNotifyType, struct DSP_NOTIFICATION
			      *hNotification)
{
	struct WMD_DRV_INTERFACE *pIntfFxns;
	DSP_STATUS status = DSP_SOK;

	DBC_Require(cRefs > 0);
	DBC_Require(hNotification != NULL);

	GT_4trace(STRM_debugMask, GT_ENTER,
		 "STRM_RegisterNotify: hStrm: 0x%x\t"
		 "uEventMask: 0x%x\tuNotifyType: 0x%x\thNotification: 0x%x\n",
		 hStrm, uEventMask, uNotifyType, hNotification);
	if (!MEM_IsValidHandle(hStrm, STRM_SIGNATURE)) {
		status = DSP_EHANDLE;
	} else if ((uEventMask & ~((DSP_STREAMIOCOMPLETION) |
		 DSP_STREAMDONE)) != 0) {
		status = DSP_EVALUE;
	} else {
		if (uNotifyType != DSP_SIGNALEVENT)
			status = DSP_ENOTIMPL;

	}
	if (DSP_SUCCEEDED(status)) {
		pIntfFxns = hStrm->hStrmMgr->pIntfFxns;

		status = (*pIntfFxns->pfnChnlRegisterNotify)(hStrm->hChnl,
			 uEventMask, uNotifyType, hNotification);
	}
	/* ensure we return a documented return code */
	DBC_Ensure(DSP_SUCCEEDED(status) || status == DSP_EHANDLE ||
		  status == DSP_ETIMEOUT || status == DSP_ETRANSLATE ||
		  status == DSP_ENOTIMPL || status == DSP_EFAIL);
	return status;
}
Example #26
0
/*
 *  ======== STRM_Select ========
 *  Purpose:
 *      Selects a ready stream.
 */
DSP_STATUS STRM_Select(IN struct STRM_OBJECT **aStrmTab, u32 nStrms,
		      OUT u32 *pMask, u32 uTimeout)
{
	u32 uIndex;
	struct CHNL_INFO chnlInfo;
	struct WMD_DRV_INTERFACE *pIntfFxns;
	struct SYNC_OBJECT **hSyncEvents = NULL;
	u32 i;
	DSP_STATUS status = DSP_SOK;

	DBC_Require(cRefs > 0);
	DBC_Require(aStrmTab != NULL);
	DBC_Require(pMask != NULL);
	DBC_Require(nStrms > 0);

	GT_4trace(STRM_debugMask, GT_ENTER,
		 "STRM_Select: aStrmTab: 0x%x \tnStrms: "
		 "0x%x\tpMask: 0x%x\tuTimeout: 0x%x\n", aStrmTab,
		 nStrms, pMask, uTimeout);
	*pMask = 0;
	for (i = 0; i < nStrms; i++) {
		if (!MEM_IsValidHandle(aStrmTab[i], STRM_SIGNATURE)) {
			status = DSP_EHANDLE;
			break;
		}
	}
	if (DSP_FAILED(status))
		goto func_end;

	/* Determine which channels have IO ready */
	for (i = 0; i < nStrms; i++) {
		pIntfFxns = aStrmTab[i]->hStrmMgr->pIntfFxns;
		status = (*pIntfFxns->pfnChnlGetInfo)(aStrmTab[i]->hChnl,
			 &chnlInfo);
		if (DSP_FAILED(status)) {
			break;
		} else {
			if (chnlInfo.cIOCs > 0)
				*pMask |= (1 << i);

		}
	}
	if (DSP_SUCCEEDED(status) && uTimeout > 0 && *pMask == 0) {
		/* Non-zero timeout */
		hSyncEvents = (struct SYNC_OBJECT **)MEM_Alloc(nStrms *
			      sizeof(struct SYNC_OBJECT *), MEM_PAGED);
		if (hSyncEvents == NULL) {
			status = DSP_EMEMORY;
		} else {
			for (i = 0; i < nStrms; i++) {
				pIntfFxns = aStrmTab[i]->hStrmMgr->pIntfFxns;
				status = (*pIntfFxns->pfnChnlGetInfo)
					 (aStrmTab[i]->hChnl, &chnlInfo);
				if (DSP_FAILED(status))
					break;
				else
					hSyncEvents[i] = chnlInfo.hSyncEvent;

			}
		}
		if (DSP_SUCCEEDED(status)) {
			status = SYNC_WaitOnMultipleEvents(hSyncEvents, nStrms,
				uTimeout, &uIndex);
			if (DSP_SUCCEEDED(status)) {
				/* Since we waited on the event, we have to
				 * reset it */
				SYNC_SetEvent(hSyncEvents[uIndex]);
				*pMask = 1 << uIndex;
			}
		}
	}
func_end:
	if (hSyncEvents)
		MEM_Free(hSyncEvents);

	DBC_Ensure((DSP_SUCCEEDED(status) && (*pMask != 0 || uTimeout == 0)) ||
		  (DSP_FAILED(status) && *pMask == 0));

	return status;
}
Example #27
0
/*
 *  ======== STRM_Reclaim ========
 *  Purpose:
 *      Relcaims a buffer from a stream.
 */
DSP_STATUS STRM_Reclaim(struct STRM_OBJECT *hStrm, OUT u8 **pBufPtr,
			u32 *pulBytes, u32 *pulBufSize, u32 *pdwArg)
{
	struct WMD_DRV_INTERFACE *pIntfFxns;
	struct CHNL_IOC chnlIOC;
	DSP_STATUS status = DSP_SOK;
	void *pTmpBuf = NULL;

	DBC_Require(cRefs > 0);
	DBC_Require(pBufPtr != NULL);
	DBC_Require(pulBytes != NULL);
	DBC_Require(pdwArg != NULL);

	GT_4trace(STRM_debugMask, GT_ENTER,
		 "STRM_Reclaim: hStrm: 0x%x\tpBufPtr: 0x%x"
		 "\tpulBytes: 0x%x\tpdwArg: 0x%x\n", hStrm, pBufPtr, pulBytes,
		 pdwArg);

	if (!MEM_IsValidHandle(hStrm, STRM_SIGNATURE)) {
		status = DSP_EHANDLE;
		goto func_end;
	}
	pIntfFxns = hStrm->hStrmMgr->pIntfFxns;

	status = (*pIntfFxns->pfnChnlGetIOC)(hStrm->hChnl, hStrm->uTimeout,
		 &chnlIOC);
	if (DSP_FAILED(status)) {
		GT_1trace(STRM_debugMask, GT_6CLASS,
			 "STRM_Reclaim: GetIOC failed! "
			 "Status = 0x%x\n", status);
	} else {
		*pulBytes = chnlIOC.cBytes;
		if (pulBufSize)
			*pulBufSize = chnlIOC.cBufSize;

		*pdwArg = chnlIOC.dwArg;
		if (!CHNL_IsIOComplete(chnlIOC)) {
			if (CHNL_IsTimedOut(chnlIOC)) {
				status = DSP_ETIMEOUT;
			} else {
				/* Allow reclaims after idle to succeed */
				if (!CHNL_IsIOCancelled(chnlIOC))
					status = DSP_EFAIL;

			}
		}
		/* Translate zerocopy buffer if channel not canceled. */
		if (DSP_SUCCEEDED(status) && (!CHNL_IsIOCancelled(chnlIOC)) &&
		   (hStrm->lMode == STRMMODE_ZEROCOPY)) {
			/*
			 *  This is a zero-copy channel so chnlIOC.pBuf
			 *  contains the DSP address of SM. We need to
			 *  translate it to a virtual address for the user
			 *  thread to access.
			 *  Note: Could add CMM_DSPPA2VA to CMM in the future.
			 */
			pTmpBuf = CMM_XlatorTranslate(hStrm->hXlator,
					chnlIOC.pBuf, CMM_DSPPA2PA);
			if (pTmpBuf != NULL) {
				/* now convert this GPP Pa to Va */
				pTmpBuf = CMM_XlatorTranslate(hStrm->hXlator,
					  pTmpBuf, CMM_PA2VA);
			}
			if (pTmpBuf == NULL) {
				GT_0trace(STRM_debugMask, GT_7CLASS,
					 "STRM_Reclaim: Failed "
					 "SM translation!\n");
				status = DSP_ETRANSLATE;
			}
			chnlIOC.pBuf = pTmpBuf;
		}
		*pBufPtr = chnlIOC.pBuf;
	}
func_end:
	/* ensure we return a documented return code */
	DBC_Ensure(DSP_SUCCEEDED(status) || status == DSP_EHANDLE ||
		  status == DSP_ETIMEOUT || status == DSP_ETRANSLATE ||
		  status == DSP_EFAIL);
	return status;
}
Example #28
0
/*
 *  ======== STRM_AllocateBuffer ========
 *  Purpose:
 *      Allocates buffers for a stream.
 */
DSP_STATUS STRM_AllocateBuffer(struct STRM_OBJECT *hStrm, u32 uSize,
				OUT u8 **apBuffer, u32 uNumBufs)
{
	DSP_STATUS status = DSP_SOK;
	u32 uAllocated = 0;
	u32 i;
	#ifndef RES_CLEANUP_DISABLE
	DSP_STATUS res_status = DSP_SOK;
       u32                  hProcess;
	HANDLE	     pCtxt = NULL;
	HANDLE	     hDrvObject;
	HANDLE hSTRMRes;
	#endif
	DBC_Require(cRefs > 0);
	DBC_Require(apBuffer != NULL);

	GT_4trace(STRM_debugMask, GT_ENTER, "STRM_AllocateBuffer: hStrm: 0x%x\t"
		 "uSize: 0x%x\tapBuffer: 0x%x\tuNumBufs: 0x%x\n",
		 hStrm, uSize, apBuffer, uNumBufs);
	if (MEM_IsValidHandle(hStrm, STRM_SIGNATURE)) {
		/*
		 * Allocate from segment specified at time of stream open.
		 */
		if (uSize == 0)
			status = DSP_ESIZE;

	}
	if (DSP_FAILED(status)) {
		status = DSP_EHANDLE;
		goto func_end;
	}
	for (i = 0; i < uNumBufs; i++) {
		DBC_Assert(hStrm->hXlator != NULL);
		(void)CMM_XlatorAllocBuf(hStrm->hXlator, &apBuffer[i], uSize);
		if (apBuffer[i] == NULL) {
			GT_0trace(STRM_debugMask, GT_7CLASS,
				 "STRM_AllocateBuffer: "
				 "DSP_FAILED to alloc shared memory.\n");
			status = DSP_EMEMORY;
			uAllocated = i;
			break;
		}
	}
	if (DSP_FAILED(status))
		STRM_FreeBuffer(hStrm, apBuffer, uAllocated);

#ifndef RES_CLEANUP_DISABLE
	if (DSP_FAILED(status))
		goto func_end;

       /* Return PID instead of process handle */
       hProcess = current->pid;

	res_status = CFG_GetObject((u32 *)&hDrvObject, REG_DRV_OBJECT);
	if (DSP_FAILED(res_status))
		goto func_end;

       DRV_GetProcContext(hProcess, (struct DRV_OBJECT *)hDrvObject,
			 &pCtxt, NULL, 0);
	if (pCtxt != NULL) {
		if (DRV_GetSTRMResElement(hStrm, &hSTRMRes, pCtxt) !=
		   DSP_ENOTFOUND) {
			DRV_ProcUpdateSTRMRes(uNumBufs, hSTRMRes, pCtxt);
		}
	}
#endif
func_end:
	return status;
}
Example #29
0
/*
 *  ======== procCreate ========
 */
static Bool procCreate(Processor_Handle proc)
{
    DSP_STATUS      status = DSP_SOK;
    ZcpyMqtAttrs    mqtAttrs;
    Bool            retVal;

    GT_1trace(curTrace, GT_ENTER, "Processor_create_d> Enter(proc=0x%x)\n",
            proc);

    /* TODO:L ignoring cpuId string, using 0 for cpuId */
    proc->cpuId = 0;

    /* call power on function -- either the real one, or the empty
     * stub defined by Global.xdt if power is not used.
     */
    if (Power_on(&proc->powerHandle) == Power_EFAIL) {
        retVal = FALSE;
        GT_0trace(curTrace, GT_6CLASS,
            "Processor_create_d> Power_on failed.\n");
        goto procCreate_return;
    }

    /* if using LAD: connect to LAD, startup DSP, attach with Link */
    if (Global_useLinkArbiter) {

        /* connect to LAD */
        ladStatus = LAD_connect(&handle);
        GT_2trace(curTrace, GT_2CLASS, "Processor_create_d> "
            "LAD_connect status = %x, handle = %x\n", ladStatus, handle);

        if (ladStatus != LAD_SUCCESS) {
            GT_1trace(curTrace, GT_7CLASS, "Processor_create_d> "
               "LAD_connect FAILED, status = [0x%x]\n", ladStatus);
            goto ladfail;
        }

        /* startup the DSP (if it isn't already started) */
        GT_2trace(curTrace, GT_2CLASS, "Processor_create_d> "
            "Loading %s on DSP, linkConfigName= %s ...\n", proc->imageName,
            proc->linkConfigName);
        ladStatus = LAD_startupDsp(handle, proc->cpuId, proc->linkConfigName,
            proc->imageName);
        GT_1trace(curTrace, GT_2CLASS, "Processor_create_d> "
            "LAD_startupDsp status = %x\n", ladStatus);

        /* on success, continue */
        if ((ladStatus == LAD_SUCCESS) || (ladStatus == LAD_ALREADYRUNNING)) {
#ifndef WIN32
            /*
             *  Must still call PROC_Attach from this app's process. (For
             *  WinCE, LAD runs in the same process, so PROC_Attach() returns
             *  an error.)
             */
            status = PROC_Attach(proc->cpuId, NULL);
            if (!DSP_SUCCEEDED(status)) {
                GT_1trace(curTrace, GT_7CLASS, "Processor_create_d> "
                    "PROC_Attach following LAD_startupDsp FAILED, "
                    "status=[0x%x]\n", (Uns) status);
                goto ladfail;
            }

            /* must still call POOL_Open from this app (NULL attributes) */
            status = POOL_Open (Global_cePoolId, NULL) ;
            if (!DSP_SUCCEEDED(status)) {
                GT_1trace(curTrace, GT_7CLASS, "Processor_create_d> "
                    "POOL_Open following LAD_startupDsp FAILED, "
                    "status=[0x%x]\n", (Uns) status);
            }
#endif
        }
        /* else, on fail, abort */
        else {
            GT_1trace(curTrace, GT_7CLASS, "Processor_create_d> "
                "LAD_startupDsp FAILED, status = [0x%x]\n", ladStatus);
            goto ladfail;
        }
    } /* end of 'if using LAD' */

    /* else, if no LAD, call Link's startup APIs directly */
    else {

        /*
         *  Create and initialize the PROC object.
         */
        GT_0trace(curTrace, GT_2CLASS, "Processor_create_d> "
            "Initializing DSP PROC...\n");

        modifyDefaultLinkCfgObjectForCENeeds();
        modifyDefaultLinkCfgObjectBasedOnUserCfgData(proc->imageName);

    dumpLinkCfgObj(&ti_sdo_ce_ipc_Processor_linkcfg);

        status = PROC_setup( &ti_sdo_ce_ipc_Processor_linkcfg );

        if (!DSP_SUCCEEDED(status)) {
            goto fail;
        }

        /*
         *  Attach the Dsp.
         */
        GT_0trace(curTrace, GT_2CLASS, "Processor_create_d> "
            "Attaching to DSP PROC...\n");

        status = PROC_Attach(proc->cpuId, NULL);
        if (!DSP_SUCCEEDED(status)) {
            goto fail;
        }

        /*
         *  Open a pool with buffers for both the control messages use by the
         *  transport and the application.
         */
        GT_0trace(curTrace, GT_2CLASS, "Processor_create_d> "
            "Opening MSGQ pool...\n");

        status = POOL_Open(Global_cePoolId, &Global_cePoolAttrs);
        if (!DSP_SUCCEEDED(status)) {
            goto fail;
        }

        /*
         *  Load the executable on the DSP.
         */
        GT_2trace(curTrace, GT_2CLASS, "Processor_create_d> "
            "Loading %s on DSP (%d args)...\n", proc->imageName,
            proc->attrs.argc);

        status = PROC_Load(proc->cpuId, proc->imageName,
            proc->attrs.argc, proc->attrs.argv);
        if (!DSP_SUCCEEDED(status)) {
            goto fail;
        }

        /*
         *  Start execution on DSP.
         */
        GT_0trace(curTrace, GT_2CLASS, "Processor_create_d> "
            "Starting DSP PROC...\n");

        status = PROC_Start(proc->cpuId);
        if (!DSP_SUCCEEDED(status)) {
            goto fail;
        }

        /*
         *  Open the remote transport to the DSP.
         */
        GT_0trace(curTrace, GT_2CLASS, "Processor_create_d> "
            "Opening remote transport...\n");
        /* tell the transport which open pool id to use for ctrl messages */
        mqtAttrs.poolId = Global_cePoolId;

        status = MSGQ_TransportOpen(proc->cpuId, &mqtAttrs);
        if (!DSP_SUCCEEDED(status)) {
            goto fail;
        }

    }  /* end of else to using LAD */

    /*
     *  Connect to the Power on the DSP
     */
    if (Power_connect(proc->powerHandle) == Power_EFAIL) {
        goto fail;
    }

    proc->connected = TRUE;

    if (Global_getenv("CE_DSPDEBUG") != NULL) {
        printf("Codec Engine system message (b/c CE_DSPDEBUG=1) : DSP image "
                "loaded and started, press Enter to continue: ");
        getchar();
    }

    retVal = TRUE;
    goto procCreate_return;

    /* TODO:[4] should try those asyncErrorHandlers that link supports?
     * (MSGQ_SetErrorHandler)
     */

fail:
    GT_4trace(curTrace, GT_7CLASS, "Processor_create_d> "
        "Loading and starting DSP server '%s' FAILED, status=[0x%x] "
        "(look for error code 'DSP_EBASE + 0x%x' in "
        "dsplink*/packages/dsplink/gpp/inc/usr/errbase.h) %s\n",
        proc->imageName, status,
        status & 0x7fff, status == DSP_ERANGE ?
            "This error code typically indicates a problem with the DSP memory "
            "map, i.e. it is different from what the Arm side specified; check "
            "the DSP server's memory map in your Arm application .cfg script, "
            "and make sure you have set 'armDspLinkConfig' "
            "configuration variable correctly (for details, refer to the "
            "documentation for ti.sdo.ce.Engine.xdc). Also, verify that "
            "the DSPLINKMEM segment on the DSP is large enough. "
            : ""
         );

ladfail:

    procDelete(proc);

    retVal = FALSE;

procCreate_return:

    GT_1trace(curTrace, GT_2CLASS, "Processor_create_d> return (%d)\n", retVal);

    return retVal;
}
Example #30
0
/*
 *  ======== modifyDefaultLinkCfgObjectBasedOnUserCfgData ========
 */
static Void modifyDefaultLinkCfgObjectBasedOnUserCfgData( String serverName )
{
    LINKCFG_MemEntry *  linkcfgMemTable;
    LINKCFG_MemEntry *  e;
    static LINKCFG_MemEntry * linkcfgMemTables[] = { NULL /* to be set */ };
    Global_ArmDspLinkConfig * armDspLinkConfig = NULL;
    Global_ArmDspLinkConfigMemTableEntry *mte;
    DSP_BootMode    staticCfgDspCtl;
    DSP_BootMode    newCfgDspCtl;
    Int    serverNameIndex;
    UInt32 cmemPhysBase;
    size_t cmemSize;
    Int    status;

    /* MODIFY MEMORY CONFIGURATION */
    CMEM_BlockAttrs   blockAttrs;
    Int    numMemTableEntries, i = 0;
    Int    numMemEntries = 0;
    Int    memEntryIdx;
    Int    numCmemBlocks = 0;
    Bool   addCmemBlocks = FALSE;

    /* first locate our server in the list of server names */
    for (serverNameIndex = 0;;serverNameIndex++) {
        if (!strcmp(ti_sdo_ce_ipc_armDspLinkConfigServerNames[serverNameIndex],
            serverName)) {
                break;
        }
        if (ti_sdo_ce_ipc_armDspLinkConfigServerNames[serverNameIndex] ==
            NULL ) {
            GT_1trace(curTrace, GT_7CLASS, "Processor_create_d> "
                "ERROR: Cannot find DspLink configuration data for the server "
                "named '%s' -- verify that the name was specified correctly in "
                "the application configuration file.\n", serverName);
            return;
        }
    }

    GT_2trace(curTrace, GT_2CLASS, "Processor_create_d> "
        "Using DspLink config data for entry #%d [server '%s']\n",
        serverNameIndex, serverName );

    armDspLinkConfig = ti_sdo_ce_ipc_armDspLinkConfigs[ serverNameIndex ];

    ti_sdo_ce_ipc_Processor_linkcfg.dspConfigs[0]->memTables = linkcfgMemTables;
    ti_sdo_ce_ipc_Processor_linkcfg.dspConfigs[0]->memTables[0] = NULL;

    /*
     *  Count the number of CMEM blocks, so we can add entries for these,
     *  if needed.
     */
    status = CMEM_getNumBlocks(&numCmemBlocks);
    if (status != 0) {
        /* TODO: Is this always an error? */
        GT_0trace(curTrace, GT_6CLASS, "Processor_create_d> "
                "CMEM_getNumBlocks() failed!");
        numCmemBlocks = 0;
    }
    else {
        GT_1trace(curTrace, GT_2CLASS, "Processor_create_d> Number of CMEM "
                "blocks: %d\n", numCmemBlocks);
    }

    for (;armDspLinkConfig->memTable[i].segmentName != NULL; i++);

    /*
     *  Add a few extra entries in case we need to map CMEM blocks. The
     *  app's config will have at most one CMEM entry with base and length
     *  set to 0. We'll use CMEM_getBlockAttrs to get the base and length
     *  of all CMEM blocks. (Note: We will allocate at least one more entry
     *  then is actually needed, but this is easier than checking the
     *  memTable for "CMEM", and subtracting '1' from the nuber to allocate
     *  if "CMEM" is found.)
     */
    numMemEntries = i;
    numMemTableEntries = numMemEntries + numCmemBlocks;

    /* anything allocated here must be deallocated in procDelete */
    linkcfgMemTable = (LINKCFG_MemEntry *) Memory_alloc(
            sizeof(LINKCFG_MemEntry) * numMemTableEntries, NULL);

    if (linkcfgMemTable == NULL) {
        GT_0trace(curTrace, GT_7CLASS, "Processor_create_d> "
            "ERROR: Memory_alloc failed\n");
        return;
    }

    /* point link config memTables only entry to our list of memTable entries */
    ti_sdo_ce_ipc_Processor_linkcfg.dspConfigs[0]->memTables[0] = linkcfgMemTable;

    for (i = 0, memEntryIdx = 0; i < numMemEntries; i++) {
        e   = &linkcfgMemTable[memEntryIdx];
        mte = &armDspLinkConfig->memTable[i];
        GT_4trace(curTrace, GT_2CLASS, "Processor_create_d> Adding memTable "
                "entry for %s, physAddr = 0x%x, dspAddr = 0x%x, size = 0x%x\n",
                mte->segmentName, mte->gppAddress, mte->startAddress,
                mte->sizeInBytes);

        if (!strcmp("CMEM", mte->segmentName)) {
            /* Skip CMEM entry, we'll add CMEM blocks later */
            addCmemBlocks = TRUE;
            continue;
        }

        e->entry        = memEntryIdx; //i;
        strncpy( e->name, mte->segmentName, DSP_MAX_STRLEN );
        e->physAddr     = mte->gppAddress; // gpp physical address
        e->dspVirtAddr  = mte->startAddress; // dsp view (physical or virtual)
        e->gppVirtAddr  = (UInt32)-1;
        e->size         = mte->sizeInBytes;
        e->shared       = mte->shared;
        e->syncd        = mte->syncd;

        memEntryIdx++;

        GT_6trace(curTrace, GT_2CLASS, "Processor_create_d> "
            "Adding DSP segment #%d to Link configuration: "
            "name='%s', startAddress=0x%x, sizeInBytes=0x%x, shared=%d, "
            "syncd=%d\n",
            i, e->name, e->physAddr, e->size, e->shared, e->syncd);
    }

    /* Now add the CMEM blocks if needed */
    if (addCmemBlocks) {
        for (i = 0; i < numCmemBlocks; i++) {
            e = &linkcfgMemTable[memEntryIdx];
            status = CMEM_getBlockAttrs(i, &blockAttrs);
            if (status != 0) {
                GT_1trace(curTrace, GT_7CLASS, "Processor_create_d> "
                        "ERROR: failed to get CMEM attrs of block %d\n", i);
                break;
            }
            sprintf(e->name, "CMEM_BLOCK%d", i);
            e->physAddr = blockAttrs.phys_base;
            e->dspVirtAddr = blockAttrs.phys_base;
            e->size = blockAttrs.size;
            memEntryIdx++;
        }
    }

    /* set number of memTable entries */
    ti_sdo_ce_ipc_Processor_linkcfg.dspConfigs[0]->dspObject[0].memEntries =
        memEntryIdx; //numMemTableEntries;

    /* RESET vector is always #3 in the list (that's how Global.xdt arranges it;
     * read its start address and size and adjust some other params in the
     * dsplink config object. (Note: third in the list is index [2].
     */
    ti_sdo_ce_ipc_Processor_linkcfg.dspConfigs[0]->dspObject[0].resumeAddr =
        armDspLinkConfig->memTable[2].startAddress + 0x20;
    ti_sdo_ce_ipc_Processor_linkcfg.dspConfigs[0]->dspObject[0].resetVector =
        armDspLinkConfig->memTable[2].startAddress;
    ti_sdo_ce_ipc_Processor_linkcfg.dspConfigs[0]->dspObject[0].resetCodeSize =
        armDspLinkConfig->memTable[2].sizeInBytes;

    /* SET DOPOWERCONTROL PER CE CONFIGURATION */
    staticCfgDspCtl =
        ti_sdo_ce_ipc_Processor_linkcfg.dspConfigs[0]->dspObject[0].doDspCtrl;

    if (armDspLinkConfig->doDspCtrl == BootNoPwr) {
        newCfgDspCtl = DSP_BootMode_Boot_NoPwr;
    }
    else if (armDspLinkConfig->doDspCtrl == BootPwr) {
        newCfgDspCtl = DSP_BootMode_Boot_Pwr;
    }
    else if (armDspLinkConfig->doDspCtrl == NoLoadNoPwr) {
        newCfgDspCtl = DSP_BootMode_NoLoad_NoPwr;
    }
    else if (armDspLinkConfig->doDspCtrl == NoLoadPwr) {
        newCfgDspCtl = DSP_BootMode_NoLoad_Pwr;
    }
    else { /* NoBoot */
        newCfgDspCtl = DSP_BootMode_NoBoot;
    }

    ti_sdo_ce_ipc_Processor_linkcfg.dspConfigs[0]->dspObject[0].doDspCtrl =
        newCfgDspCtl;
    GT_2trace(curTrace, GT_2CLASS, "Processor_create_d> "
            "DODSPCTRL was=%d; now=%d\n", staticCfgDspCtl, newCfgDspCtl);
}