自学教程：C++ DSP_FAILED函数代码示例

/** ============================================================================ *  @func   LIST_Create * *  @desc   Allocates and initializes a circular list. * *  @modif  None *  ============================================================================ */EXPORT_APIDSP_STATUSLIST_Create (OUT List ** list){    DSP_STATUS  status  = DSP_SOK ;    List *      myList = NULL    ;    TRC_1ENTER ("LIST_Create", list) ;    DBC_Require (list != NULL) ;    if (list == NULL) {        status = DSP_EINVALIDARG ;        SET_FAILURE_REASON ;    }    else {        status = MEM_Calloc ((Void **) &myList,                             sizeof(List),                             MEM_DEFAULT) ;        if (DSP_FAILED (status)) {            status = DSP_EMEMORY ;            SET_FAILURE_REASON ;        }        else {            DBC_Assert (myList != NULL) ;            myList->head.next = &(myList->head) ;            myList->head.prev = &(myList->head) ;            *list = myList ;        }    }    DBC_Ensure (   (DSP_SUCCEEDED (status) && (*list != NULL))                || (DSP_FAILED (status))) ;    TRC_1LEAVE ("LIST_Create", status) ;    return status ;}

/* * ======== NODEWRAP_Allocate ======== */u32 NODEWRAP_Allocate(union Trapped_Args *args, void *pr_ctxt){	DSP_STATUS status = DSP_SOK;	struct DSP_UUID nodeId;	u32 cbDataSize = 0;	u32 __user *pSize = (u32 __user *)args->ARGS_NODE_ALLOCATE.pArgs;	u8 *pArgs = NULL;	struct DSP_NODEATTRIN attrIn, *pAttrIn = NULL;	struct NODE_OBJECT *hNode;	GT_0trace(WCD_debugMask, GT_ENTER, "NODEWRAP_Allocate: entered/n");	/* Optional argument */	if (pSize) {		if (get_user(cbDataSize, pSize))			status = DSP_EFAIL;		cbDataSize += sizeof(u32);		if (DSP_SUCCEEDED(status)) {			pArgs = MEM_Alloc(cbDataSize, MEM_NONPAGED);			if (pArgs == NULL)				status = DSP_EMEMORY;		}		cp_fm_usr(pArgs, args->ARGS_NODE_ALLOCATE.pArgs, status,			 cbDataSize);	}	cp_fm_usr(&nodeId, args->ARGS_NODE_ALLOCATE.pNodeID, status, 1);	if (DSP_FAILED(status))		goto func_cont;	/* Optional argument */	if (args->ARGS_NODE_ALLOCATE.pAttrIn) {		cp_fm_usr(&attrIn, args->ARGS_NODE_ALLOCATE.pAttrIn, status, 1);		if (DSP_SUCCEEDED(status))			pAttrIn = &attrIn;		else			status = DSP_EMEMORY;	}	if (DSP_SUCCEEDED(status)) {		mutex_lock(&((struct PROCESS_CONTEXT *)pr_ctxt)->node_lock);		status = NODE_Allocate(args->ARGS_NODE_ALLOCATE.hProcessor,				      &nodeId, (struct DSP_CBDATA *)pArgs,				      pAttrIn, &hNode, pr_ctxt);		mutex_unlock(&((struct PROCESS_CONTEXT *)pr_ctxt)->node_lock);	}	cp_to_usr(args->ARGS_NODE_ALLOCATE.phNode, &hNode, status, 1);func_cont:	if (pArgs)		MEM_Free(pArgs);	return status;}

static int BRIDGE_SUSPEND(struct platform_device *pdev, pm_message_t state){	u32 status;	u32 command = PWR_EMERGENCYDEEPSLEEP;	status = pwr_sleep_dsp(command, time_out);	if (DSP_FAILED(status))		return -1;	bridge_suspend_data.suspended = 1;	return 0;}

static int bridge_resume(struct platform_device *pdev){	u32 status;	status = PWR_WakeDSP(timeOut);	if (DSP_FAILED(status))		return -1;	bridge_suspend_data.suspended = 0;	wake_up(&bridge_suspend_data.suspend_wq);	return 0;}

/* *  ======== cfg_get_object ======== *  Purpose: *      Retrieve the Object handle from the Registry */dsp_status cfg_get_object(OUT u32 *pdwValue, u8 dw_type){	dsp_status status = -EINVAL;	struct drv_data *drv_datap = dev_get_drvdata(bridge);	DBC_REQUIRE(pdwValue != NULL);	if (!drv_datap)		return -EPERM;	switch (dw_type) {	case (REG_DRV_OBJECT):		if (drv_datap->drv_object) {			*pdwValue = (u32)drv_datap->drv_object;			status = DSP_SOK;		} else {			status = -ENODATA;		}		break;	case (REG_MGR_OBJECT):		if (drv_datap->mgr_object) {			*pdwValue = (u32)drv_datap->mgr_object;			status = DSP_SOK;		} else {			status = -ENODATA;		}		break;	default:		break;	}	if (DSP_FAILED(status)) {		*pdwValue = 0;		pr_err("%s: Failed, status 0x%x/n", __func__, status);	}	DBC_ENSURE((DSP_SUCCEEDED(status) && *pdwValue != 0) ||		   (DSP_FAILED(status) && *pdwValue == 0));	return status;}

/* *  ======== dev_start_device ======== *  Purpose: *      Initializes the new device with the BRIDGE environment. */int dev_start_device(struct cfg_devnode *dev_node_obj){	struct dev_object *hdev_obj = NULL;	/* handle to 'Bridge Device */	/* wmd filename */	char sz_wmd_file_name[CFG_MAXSEARCHPATHLEN] = "UMA";	int status;	struct mgr_object *hmgr_obj = NULL;	DBC_REQUIRE(refs > 0);		/* Given all resources, create a device object. */		status =	    dev_create_device(&hdev_obj, sz_wmd_file_name,				      dev_node_obj);		if (DSP_SUCCEEDED(status)) {			/* Store away the hdev_obj with the DEVNODE */			status =			    cfg_set_dev_object(dev_node_obj, (u32) hdev_obj);			if (DSP_FAILED(status)) {				/* Clean up */				dev_destroy_device(hdev_obj);				hdev_obj = NULL;			}		}	if (DSP_SUCCEEDED(status)) {		/* Create the Manager Object */		status = mgr_create(&hmgr_obj, dev_node_obj);	}	if (DSP_FAILED(status)) {		if (hdev_obj)			dev_destroy_device(hdev_obj);		/* Ensure the device extension is NULL */		cfg_set_dev_object(dev_node_obj, 0L);	}	return status;}

static int bridge_suspend(struct platform_device *pdev, pm_message_t state){	u32 status;	u32 command = PWR_EMERGENCYDEEPSLEEP;	bridge_suspend_data.suspended = 1;	status = PWR_SleepDSP(command, timeOut);	if (DSP_FAILED(status)) {		bridge_suspend_data.suspended = 0;		return -1;	}	return 0;}

/** ============================================================================ *  @func   LDRV_freeLinkCfg * *  @desc   Frees any memory allocated for the kernel-side APUDRV configuration *          structure. * *  @modif  None *  ============================================================================ */NORMAL_APIDSP_STATUSLDRV_freeLinkGppCfg (IN  LINKCFG_Object *  knlLinkCfg){    DSP_STATUS status    = DSP_SOK ;    DSP_STATUS tmpStatus = DSP_SOK ;    TRC_1ENTER ("LDRV_freeLinkGppCfg", knlLinkCfg) ;    if (knlLinkCfg != NULL) {        /*  --------------------------------------------------------------------         *  Free memory allocated for the GPP object         *  --------------------------------------------------------------------         */        if (knlLinkCfg->gppObject != NULL) {            tmpStatus = FREE_PTR (knlLinkCfg->gppObject) ;            if (DSP_FAILED (tmpStatus) && DSP_SUCCEEDED (status)) {                status = tmpStatus ;                SET_FAILURE_REASON ;            }        }        /*  --------------------------------------------------------------------         *  Free memory allocated for the global LINKCFG object.         *  --------------------------------------------------------------------         */        tmpStatus = FREE_PTR (knlLinkCfg) ;        if (DSP_FAILED (tmpStatus) && DSP_SUCCEEDED (status)) {            status = tmpStatus ;            SET_FAILURE_REASON ;        }    }    TRC_1LEAVE ("LDRV_freeLinkGppCfg", status) ;    return status ;}

/* * ======== NODEWRAP_Connect ======== */u32 NODEWRAP_Connect(union Trapped_Args *args, void *pr_ctxt){	DSP_STATUS status = DSP_SOK;	struct DSP_STRMATTR attrs;	struct DSP_STRMATTR *pAttrs = NULL;	u32 cbDataSize;	u32 __user *pSize = (u32 __user *)args->ARGS_NODE_CONNECT.pConnParam;	u8 *pArgs = NULL;	GT_0trace(WCD_debugMask, GT_ENTER, "NODEWRAP_Connect: entered/n");	/* Optional argument */	if (pSize) {		if (get_user(cbDataSize, pSize))			status = DSP_EFAIL;		cbDataSize += sizeof(u32);		if (DSP_SUCCEEDED(status)) {			pArgs = MEM_Alloc(cbDataSize, MEM_NONPAGED);			if (pArgs == NULL) {				status = DSP_EMEMORY;				goto func_cont;			}		}		cp_fm_usr(pArgs, args->ARGS_NODE_CONNECT.pConnParam, status,			 cbDataSize);		if (DSP_FAILED(status))			goto func_cont;	}	if (args->ARGS_NODE_CONNECT.pAttrs) {	/* Optional argument */		cp_fm_usr(&attrs, args->ARGS_NODE_CONNECT.pAttrs, status, 1);		if (DSP_SUCCEEDED(status))			pAttrs = &attrs;	}	if (DSP_SUCCEEDED(status)) {		status = NODE_Connect(args->ARGS_NODE_CONNECT.hNode,				     args->ARGS_NODE_CONNECT.uStream,				     args->ARGS_NODE_CONNECT.hOtherNode,				     args->ARGS_NODE_CONNECT.uOtherStream,				     pAttrs, (struct DSP_CBDATA *)pArgs);	}func_cont:	if (pArgs)		MEM_Free(pArgs);	return status;}

/* *  ======== WCD_InitComplete2 ======== *  Purpose: *      Perform any required WCD, and WMD initialization which *      cannot not be performed in WCD_Init() or DEV_StartDevice() due *      to the fact that some services are not yet *      completely initialized. *  Parameters: *  Returns: *      DSP_SOK:	Allow this device to load *      DSP_EFAIL:      Failure. *  Requires: *      WCD initialized. *  Ensures: */DSP_STATUS WCD_InitComplete2(void){	DSP_STATUS status = DSP_SOK;	struct CFG_DEVNODE *DevNode;	struct DEV_OBJECT *hDevObject;	u32 devType;	DBC_Require(WCD_cRefs > 0);	GT_0trace(WCD_debugMask, GT_ENTER, "Entered WCD_InitComplete/n");	 /*  Walk the list of DevObjects, get each devnode, and attempting to	 *  autostart the board. Note that this requires COF loading, which	 *  requires KFILE.  */	for (hDevObject = DEV_GetFirst(); hDevObject != NULL;	     hDevObject = DEV_GetNext(hDevObject)) {		if (DSP_FAILED(DEV_GetDevNode(hDevObject, &DevNode)))			continue;		if (DSP_FAILED(DEV_GetDevType(hDevObject, &devType)))			continue;		if ((devType == DSP_UNIT) || (devType == IVA_UNIT)) {			if (DSP_FAILED(PROC_AutoStart(DevNode, hDevObject))) {				GT_0trace(WCD_debugMask, GT_1CLASS,					 "WCD_InitComplete2 Failed/n");				status = DSP_EFAIL;				/* break; */			}		} else			GT_1trace(WCD_debugMask, GT_ENTER,				 "Ignoring PROC_AutoStart "				 "for Device Type = 0x%x /n", devType);	}			/* End For Loop */	GT_1trace(WCD_debugMask, GT_ENTER,		 "Exiting WCD_InitComplete status 0x%x/n", status);	return status;}

/* *  ========= MGR_Create ========= *  Purpose: *      MGR Object gets created only once during driver Loading. */DSP_STATUS MGR_Create(OUT struct MGR_OBJECT **phMgrObject,		     struct CFG_DEVNODE *hDevNode){	DSP_STATUS status = DSP_SOK;	struct MGR_OBJECT *pMgrObject = NULL;	DBC_Require(phMgrObject != NULL);	DBC_Require(cRefs > 0);	GT_1trace(MGR_DebugMask, GT_ENTER,		 "Entering MGR_Create phMgrObject 0x%x/n ",		 phMgrObject);	MEM_AllocObject(pMgrObject, struct MGR_OBJECT, SIGNATURE);	if (pMgrObject) {		if (DSP_SUCCEEDED(DCD_CreateManager(ZLDLLNAME,		   &pMgrObject->hDcdMgr))) {			/* If succeeded store the handle in the MGR Object */			if (DSP_SUCCEEDED(CFG_SetObject((u32)pMgrObject,			   REG_MGR_OBJECT))) {				*phMgrObject = pMgrObject;				GT_0trace(MGR_DebugMask, GT_1CLASS,					 "MGR_Create:MGR Created/r/n");			} else {				status = DSP_EFAIL;				GT_0trace(MGR_DebugMask, GT_7CLASS,					 "MGR_Create:CFG_SetObject "					 "Failed/r/n");				DCD_DestroyManager(pMgrObject->hDcdMgr);				MEM_FreeObject(pMgrObject);			}		} else {			/* failed to Create DCD Manager */			status = DSP_EFAIL;			GT_0trace(MGR_DebugMask, GT_7CLASS,				 "MGR_Create:DCD_ManagerCreate Failed/r/n");			MEM_FreeObject(pMgrObject);		}	} else {		status = DSP_EMEMORY;		GT_0trace(MGR_DebugMask, GT_7CLASS,			 "MGR_Create DSP_FAILED to allocate memory /n");	}	GT_2trace(MGR_DebugMask, GT_ENTER,		 "Exiting MGR_Create: phMgrObject: 0x%x/t"		 "status: 0x%x/n", phMgrObject, status);	DBC_Ensure(DSP_FAILED(status) ||		  MEM_IsValidHandle(pMgrObject, SIGNATURE));	return status;}

/* *  ======== dev_set_chnl_mgr ======== *  Purpose: *      Set the channel manager for this device. */int dev_set_chnl_mgr(struct dev_object *hdev_obj,			    struct chnl_mgr *hmgr){	int status = 0;	struct dev_object *dev_obj = hdev_obj;	DBC_REQUIRE(refs > 0);	if (hdev_obj)		dev_obj->hchnl_mgr = hmgr;	else		status = -EFAULT;	DBC_ENSURE(DSP_FAILED(status) || (dev_obj->hchnl_mgr == hmgr));	return status;}

static int __devexit omap34_xx_bridge_remove(struct platform_device *pdev){	dev_t devno;	bool ret;	int status = 0;	bhandle hdrv_obj = NULL;	status = cfg_get_object((u32 *) &hdrv_obj, REG_DRV_OBJECT);	if (DSP_FAILED(status))		goto func_cont;#ifdef CONFIG_BRIDGE_DVFS	if (cpufreq_unregister_notifier(&iva_clk_notifier,					CPUFREQ_TRANSITION_NOTIFIER))		pr_err("%s: clk_notifier_unregister failed for iva2_ck/n",		       __func__);#endif /* #ifdef CONFIG_BRIDGE_DVFS */	if (driver_context) {		/* Put the DSP in reset state */		ret = dsp_deinit(driver_context);		driver_context = 0;		DBC_ASSERT(ret == true);	}#ifdef CONFIG_BRIDGE_DVFS	clk_put(clk_handle);	clk_handle = NULL;#endif /* #ifdef CONFIG_BRIDGE_DVFS */func_cont:	mem_ext_phys_pool_release();	services_exit();	bridge_destroy_sysfs();	devno = MKDEV(driver_major, 0);	cdev_del(&bridge_cdev);	unregister_chrdev_region(devno, 1);	if (bridge_class) {		/* remove the device from sysfs */		device_destroy(bridge_class, MKDEV(driver_major, 0));		class_destroy(bridge_class);	}	return 0;}

/* *  ======== STRM_Create ======== *  Purpose: *      Create a STRM manager object. */DSP_STATUS STRM_Create(OUT struct STRM_MGR **phStrmMgr, struct DEV_OBJECT *hDev){	struct STRM_MGR *pStrmMgr;	DSP_STATUS status = DSP_SOK;	DBC_Require(cRefs > 0);	DBC_Require(phStrmMgr != NULL);	DBC_Require(hDev != NULL);	GT_2trace(STRM_debugMask, GT_ENTER, "STRM_Create: phStrmMgr: "		 "0x%x/thDev: 0x%x/n", phStrmMgr, hDev);	*phStrmMgr = NULL;	/* Allocate STRM manager object */	MEM_AllocObject(pStrmMgr, struct STRM_MGR, STRMMGR_SIGNATURE);	if (pStrmMgr == NULL) {		status = DSP_EMEMORY;		GT_0trace(STRM_debugMask, GT_6CLASS, "STRM_Create: "			 "MEM_AllocObject() failed!/n ");	} else {		pStrmMgr->hDev = hDev;	}	/* Get Channel manager and WMD function interface */	if (DSP_SUCCEEDED(status)) {		status = DEV_GetChnlMgr(hDev, &(pStrmMgr->hChnlMgr));		if (DSP_SUCCEEDED(status)) {			(void) DEV_GetIntfFxns(hDev, &(pStrmMgr->pIntfFxns));			DBC_Assert(pStrmMgr->pIntfFxns != NULL);		} else {			GT_1trace(STRM_debugMask, GT_6CLASS, "STRM_Create: "				 "Failed to get channel manager! status = "				 "0x%x/n", status);		}	}	if (DSP_SUCCEEDED(status))		status = SYNC_InitializeCS(&pStrmMgr->hSync);	if (DSP_SUCCEEDED(status))		*phStrmMgr = pStrmMgr;	else		DeleteStrmMgr(pStrmMgr);	DBC_Ensure(DSP_SUCCEEDED(status) &&		  (MEM_IsValidHandle((*phStrmMgr), STRMMGR_SIGNATURE) ||		  (DSP_FAILED(status) && *phStrmMgr == NULL)));	return status;}

static inline void __cp_to_usr(void __user *to, const void *from,			       DSP_STATUS *err, unsigned long bytes){	if (DSP_FAILED(*err))		return;	if (unlikely(!to)) {		*err = DSP_EPOINTER;		return;	}	if (unlikely(copy_to_user(to, from, bytes))) {		GT_2trace(WCD_debugMask, GT_7CLASS,			  "%s failed, to=0x%08x/n", __func__, to);		*err = DSP_EPOINTER;	}}

/** ============================================================================ *  @func   PRCS_Create * *  @desc   Creates a PrcsObject and populates it with information to identify *          the client. * *  @modif  None *  ============================================================================ */EXPORT_APIDSP_STATUSPRCS_Create (OUT PrcsObject ** prcsObj, IN     Void * optArgs){    DSP_STATUS     status                  = DSP_SOK    ;    TRC_1ENTER ("PRCS_Create", prcsObj) ;    DBC_Require (PRCS_IsInitialized == TRUE) ;    DBC_Require (prcsObj != NULL) ;	(Void) optArgs ;    if (prcsObj == NULL) {        status = DSP_EINVALIDARG ;        SET_FAILURE_REASON ;    }    else {        *prcsObj = NULL ;        status = MEM_Alloc ((Void **) prcsObj,                            sizeof (PrcsObject),                            MEM_DEFAULT) ;        if (DSP_SUCCEEDED (status)) {            (*prcsObj)->signature         = SIGN_PRCS            ;            (*prcsObj)->handleToThread    = (Pvoid) current->pid   ;            (*prcsObj)->handleToProcess   = (Pvoid) current->mm  ;            (*prcsObj)->priorityOfThread  = 0                    ;            (*prcsObj)->priorityOfProcess = current->prio        ;        }        else {            SET_FAILURE_REASON ;        }    }    DBC_Ensure (   (   DSP_SUCCEEDED (status)                    && (prcsObj != NULL)                    && IS_OBJECT_VALID(*prcsObj, SIGN_PRCS))                || DSP_FAILED (status)) ;    TRC_1LEAVE ("PRCS_Create", status) ;    return status ;}

/** ============================================================================ *  @func   RING_IO_getLinkAccess * *  @desc   Function  that allows the child  process to  use the link *          components. * *  @modif  None *  ============================================================================ */NORMAL_APIIntRING_IO_getLinkAccess(Uint8 processorId){	DSP_STATUS status = DSP_SOK;	/* Call the Link APIs that allows child process to be able to use the	 * Link components	 */	status = PROC_Attach (processorId, NULL);	if (DSP_FAILED (status)) {		RING_IO_1Print ("Attach Failed. Status = [0x%x]", status);	}	return (status);}

static void bridge_recover(struct work_struct *work){	struct dev_object *dev;	struct cfg_devnode *dev_node;	if (atomic_read(&bridge_cref)) {		INIT_COMPLETION(bridge_comp);		while (!wait_for_completion_timeout(&bridge_comp,						msecs_to_jiffies(REC_TIMEOUT)))			pr_info("%s:%d handle(s) still opened/n",					__func__, atomic_read(&bridge_cref));	}	dev = dev_get_first();	dev_get_dev_node(dev, &dev_node);	if (!dev_node || DSP_FAILED(proc_auto_start(dev_node, dev)))		pr_err("DSP could not be restarted/n");	recover = false;	complete_all(&bridge_open_comp);}

/** ============================================================================ *  @func   ISR_Uninstall * *  @desc   Uninstalls an ISR. * *  @modif  ISR_InstalledIsrs *  ============================================================================ */EXPORT_APIDSP_STATUSISR_Uninstall (IN IsrObject * isrObj){    DSP_STATUS      status   = DSP_SOK ;    TRC_1ENTER ("ISR_Uninstall", isrObj) ;    DBC_Require (ISR_IsInitialized == TRUE) ;    DBC_Require (isrObj != NULL) ;    DBC_Require (IS_OBJECT_VALID (isrObj, SIGN_ISR)) ;    DBC_Require (   (isrObj!= NULL)                 && (ISR_InstalledIsrs [isrObj->dspId][isrObj->irq] == isrObj)) ;    if (IS_OBJECT_VALID (isrObj, SIGN_ISR) == FALSE) {        status = DSP_EPOINTER ;        SET_FAILURE_REASON ;    }    else if (ISR_InstalledIsrs [isrObj->dspId][isrObj->irq] != isrObj) {            status = DSP_EACCESSDENIED ;            SET_FAILURE_REASON ;    }    else {        if (isrObj->enabled == TRUE) {            status = ISR_Disable (isrObj) ;        }        if (DSP_SUCCEEDED (status)) {            free_irq (isrObj->irq, isrObj) ;            ISR_InstalledIsrs [isrObj->dspId][isrObj->irq] = NULL ;        }        else {            SET_FAILURE_REASON ;        }    }    DBC_Ensure (   (   (DSP_SUCCEEDED (status))                    && (ISR_InstalledIsrs [isrObj->dspId][isrObj->irq] == NULL))                || DSP_FAILED (status)) ;    TRC_1LEAVE ("ISR_Uninstall", status) ;    return status ;}

/* *  ======== MGR_GetDCDHandle ======== *      Retrieves the MGR handle. Accessor Function. */DSP_STATUS MGR_GetDCDHandle(struct MGR_OBJECT *hMGRHandle,			   OUT u32 *phDCDHandle){	DSP_STATUS status = DSP_EFAIL;	struct MGR_OBJECT *pMgrObject = (struct MGR_OBJECT *)hMGRHandle;	DBC_Require(cRefs > 0);	DBC_Require(phDCDHandle != NULL);	*phDCDHandle = (u32)NULL;	if (MEM_IsValidHandle(pMgrObject, SIGNATURE)) {		*phDCDHandle = (u32) pMgrObject->hDcdMgr;		status = DSP_SOK;	}	DBC_Ensure((DSP_SUCCEEDED(status) && *phDCDHandle != (u32)NULL) ||		  (DSP_FAILED(status) && *phDCDHandle == (u32)NULL));	return status;}

/** ============================================================================ *  @func   ISR_Delete * *  @desc   Delete the isrObject. * *  @modif  None *  ============================================================================ */EXPORT_APIDSP_STATUSISR_Delete (IN IsrObject * isrObj){    DSP_STATUS status = DSP_SOK ;    TRC_1ENTER ("ISR_Delete", isrObj) ;    DBC_Require (ISR_IsInitialized == TRUE)          ;    DBC_Require (isrObj != NULL)                     ;    DBC_Require (IS_OBJECT_VALID (isrObj, SIGN_ISR)) ;    if (IS_OBJECT_VALID (isrObj, SIGN_ISR) == FALSE) {        status = DSP_EPOINTER ;        SET_FAILURE_REASON ;    }    else {        /*  --------------------------------------------------------------------         *  Verify that the ISR is not installed before deleting the object         *  --------------------------------------------------------------------         */        if (ISR_InstalledIsrs [isrObj->dspId][isrObj->irq] != isrObj) {            /* Delete the multiple entry savor lock */            SYNC_SpinLockDelete (isrObj->lock) ;            DPC_Cancel (isrObj->bhObj) ;            DPC_Delete (isrObj->bhObj) ;            isrObj->signature = SIGN_NULL ;            status = FREE_PTR (isrObj) ;            if (DSP_FAILED (status)) {                SET_FAILURE_REASON ;            }        }        else {            status = DSP_EACCESSDENIED ;            SET_FAILURE_REASON ;        }    }    TRC_1LEAVE ("ISR_Delete", status) ;    return status ;}

/* *  ======== regsupEnumValue ======== *  Purpose: *      Returns registry "values" and their "data" under a (sub)key. */DSP_STATUS regsupEnumValue(IN u32 dwIndex, IN CONST char *pstrKey,			   IN OUT char *pstrValue, IN OUT u32 *pdwValueSize,			   IN OUT char *pstrData, IN OUT u32 *pdwDataSize){	DSP_STATUS retVal = REG_E_INVALIDSUBKEY;	u32 i;       u32 dwKeyLen;	u32 count = 0;       DBC_Require(pstrKey);       dwKeyLen = strlen(pstrKey);	/*  Need to search through the entries looking for the right one.  */	for (i = 0; i < pRegKey->numValueEntries; i++) {		/*  See if the name matches.  */               if ((strncmp(pRegKey->values[i].name, pstrKey,		    dwKeyLen) == 0) && count++ == dwIndex) {			/*  We have a match!  Copy out the data.  */			memcpy(pstrData, pRegKey->values[i].pData,				pRegKey->values[i].dataSize);			/*  Get the size for the caller.  */			*pdwDataSize = pRegKey->values[i].dataSize;                       *pdwValueSize = strlen(&(pRegKey->						values[i].name[dwKeyLen]));                       strncpy(pstrValue,				    &(pRegKey->values[i].name[dwKeyLen]),				    *pdwValueSize + 1);			GT_3trace(REG_debugMask, GT_2CLASS,				  "E Key %s, Value %s, Data %x ",				  pstrKey, pstrValue, *(u32 *)pstrData);			printS((u8 *)pstrData);			/*  Set our status to good and exit.  */			retVal = DSP_SOK;			break;		}	}	if (count && DSP_FAILED(retVal))		retVal = REG_E_NOMOREITEMS;	return retVal;}

/** ============================================================================ *  @func   MEM_Map * *  @desc   Maps a memory area into virtual space. * *  @modif  None. *  ============================================================================ */EXPORT_APIDSP_STATUSMEM_Map (IN OUT MemMapInfo * mapInfo){    DSP_STATUS status = DSP_SOK ;    TRC_3ENTER ("MEM_Map", mapInfo, mapInfo->src, mapInfo->size) ;    DBC_Require (mapInfo != NULL) ;        if (mapInfo != NULL) {        mapInfo->dst = 0 ;        if (mapInfo->memAttrs == MEM_UNCACHED) {        mapInfo->dst = (Uint32) ioremap_nocache ((dma_addr_t) (mapInfo->src),                                                  mapInfo->size) ;        }        else if (mapInfo->memAttrs == MEM_CACHED) {            mapInfo->dst = (Uint32) ioremap ((dma_addr_t) (mapInfo->src),                                             mapInfo->size) ;        }        else {            status = DSP_EINVALIDARG ;            SET_FAILURE_REASON ;        }        if (mapInfo->dst == 0) {            status = DSP_EMEMORY ;            SET_FAILURE_REASON ;        }    }    else {        status = DSP_EINVALIDARG ;        SET_FAILURE_REASON ;    }    DBC_Ensure (  (DSP_SUCCEEDED (status) && (mapInfo->dst != 0))               || (DSP_FAILED (status)    && (mapInfo->dst == 0))) ;    TRC_1LEAVE ("MEM_Map", status) ;    return status ;}

/* *  ======== COD_OpenBase ======== *  Purpose: *      Open base image for reading sections. */DSP_STATUS COD_OpenBase(struct COD_MANAGER *hMgr, IN char *pszCoffPath,			DBLL_Flags flags){	DSP_STATUS status = DSP_SOK;	struct DBLL_LibraryObj *lib;	DBC_Require(cRefs > 0);	DBC_Require(IsValid(hMgr));	DBC_Require(pszCoffPath != NULL);	GT_2trace(COD_debugMask, GT_ENTER,		  "Entered COD_OpenBase, hMgr:  0x%x/n/t"		  "pszCoffPath:  0x%x/n", hMgr, pszCoffPath);	/* if we previously opened a base image, close it now */	if (hMgr->baseLib) {		if (hMgr->fLoaded) {			GT_0trace(COD_debugMask, GT_7CLASS,				 "Base Image is already loaded. "				 "Unloading it.../n");			hMgr->fxns.unloadFxn(hMgr->baseLib, &hMgr->attrs);			hMgr->fLoaded = false;		}		hMgr->fxns.closeFxn(hMgr->baseLib);		hMgr->baseLib = NULL;	} else {		GT_0trace(COD_debugMask, GT_1CLASS,			 "COD_OpenBase: Opening the base image .../n");	}	status = hMgr->fxns.openFxn(hMgr->target, pszCoffPath, flags, &lib);	if (DSP_FAILED(status)) {		GT_0trace(COD_debugMask, GT_7CLASS,			 "COD_OpenBase: COD Open failed/n");	} else {		/* hang onto the library for subsequent sym table usage */		hMgr->baseLib = lib;		strncpy(hMgr->szZLFile, pszCoffPath, COD_MAXPATHLENGTH - 1);		hMgr->szZLFile[COD_MAXPATHLENGTH - 1] = '/0';	}	return status;}

/* *  ======== WriteDspData ======== *  purpose: *      Copies buffers to the DSP internal/external memory. */DSP_STATUS WriteDspData(struct WMD_DEV_CONTEXT *hDevContext, IN u8 *pbHostBuf,			u32 dwDSPAddr, u32 ulNumBytes, u32 ulMemType){	u32 offset;	u32 dwBaseAddr = hDevContext->dwDspBaseAddr;	struct CFG_HOSTRES resources;	DSP_STATUS status;	u32 base1, base2, base3;	base1 = OMAP_DSP_MEM1_SIZE;	base2 = OMAP_DSP_MEM2_BASE - OMAP_DSP_MEM1_BASE;	base3 = OMAP_DSP_MEM3_BASE - OMAP_DSP_MEM1_BASE;	status =  CFG_GetHostResources(		 (struct CFG_DEVNODE *)DRV_GetFirstDevExtension(), &resources);	if (DSP_FAILED(status))		return status;	offset = dwDSPAddr - hDevContext->dwDSPStartAdd;	if (offset < base1) {		dwBaseAddr = MEM_LinearAddress(resources.dwMemBase[2],						resources.dwMemLength[2]);	} else if (offset > base1 && offset < base2+OMAP_DSP_MEM2_SIZE) {		dwBaseAddr = MEM_LinearAddress(resources.dwMemBase[3],						resources.dwMemLength[3]);		offset = offset - base2;	} else if (offset >= base2+OMAP_DSP_MEM2_SIZE &&		offset < base3 + OMAP_DSP_MEM3_SIZE) {		dwBaseAddr = MEM_LinearAddress(resources.dwMemBase[4],						resources.dwMemLength[4]);		offset = offset - base3;	} else{		return DSP_EFAIL;	}	if (ulNumBytes)		memcpy((u8 *) (dwBaseAddr+offset), pbHostBuf, ulNumBytes);	else		*((u32 *) pbHostBuf) = dwBaseAddr+offset;	return status;}

/* *  ======== 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);	if (!MEM_IsValidHandle(hStrm, STRM_SIGNATURE)) {		status = DSP_EHANDLE;	} else {		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 (DSP_FAILED(status)) {			if (status == CHNL_E_NOIORPS)				status = DSP_ESTREAMFULL;			else				status = DSP_EFAIL;		}	}	return status;}

/* *  ======== STRM_Create ======== *  Purpose: *      Create a STRM manager object. */DSP_STATUS STRM_Create(OUT struct STRM_MGR **phStrmMgr, struct DEV_OBJECT *hDev){	struct STRM_MGR *pStrmMgr;	DSP_STATUS status = DSP_SOK;	DBC_Require(cRefs > 0);	DBC_Require(phStrmMgr != NULL);	DBC_Require(hDev != NULL);	*phStrmMgr = NULL;	/* Allocate STRM manager object */	MEM_AllocObject(pStrmMgr, struct STRM_MGR, STRMMGR_SIGNATURE);	if (pStrmMgr == NULL)		status = DSP_EMEMORY;	else		pStrmMgr->hDev = hDev;	/* Get Channel manager and WMD function interface */	if (DSP_SUCCEEDED(status)) {		status = DEV_GetChnlMgr(hDev, &(pStrmMgr->hChnlMgr));		if (DSP_SUCCEEDED(status)) {			(void) DEV_GetIntfFxns(hDev, &(pStrmMgr->pIntfFxns));			DBC_Assert(pStrmMgr->pIntfFxns != NULL);		}	}	if (DSP_SUCCEEDED(status))		status = SYNC_InitializeCS(&pStrmMgr->hSync);	if (DSP_SUCCEEDED(status))		*phStrmMgr = pStrmMgr;	else		DeleteStrmMgr(pStrmMgr);	DBC_Ensure(DSP_SUCCEEDED(status) &&		  (MEM_IsValidHandle((*phStrmMgr), STRMMGR_SIGNATURE) ||		  (DSP_FAILED(status) && *phStrmMgr == NULL)));	return status;}

/* *  ======== DSPNode_FreeMsgBuf ======== */DBAPI DSPNode_FreeMsgBuf(DSP_HNODE hNode, IN BYTE *pBuffer,				IN OPTIONAL struct DSP_BUFFERATTR *pAttr){	DSP_STATUS status = DSP_SOK;	Trapped_Args tempStruct;	DEBUGMSG(DSPAPI_ZONE_FUNCTION, (TEXT("NODE: DSPNode_FreeMsgBuf:/r/n")));	if (hNode) {		if (pBuffer) {			/* Set up the structure */			/* Call DSP Trap */			tempStruct.ARGS_NODE_FREEMSGBUF.hNode = hNode;			tempStruct.ARGS_NODE_FREEMSGBUF.pBuffer = pBuffer;			tempStruct.ARGS_NODE_FREEMSGBUF.pAttr = pAttr;			status = DSPTRAP_Trap(&tempStruct,				CMD_NODE_FREEMSGBUF_OFFSET);			if (DSP_FAILED(status)) {				DEBUGMSG(DSPAPI_ZONE_FUNCTION, (TEXT("NODE: "						"DSPNode_FreeMsgBuf:"						"Failed to Free SM buf/r/n")));			}		} else {			/* Invalid parameter */			status = DSP_EPOINTER;			DEBUGMSG(DSPAPI_ZONE_ERROR,				(TEXT("NODE: DSPNode_FreeMsgBuf: "				"Invalid pointer in the Input/r/n")));		}	} else {		/* Invalid pointer */		status = DSP_EHANDLE;		DEBUGMSG(DSPAPI_ZONE_ERROR,				(TEXT("NODE: DSPNode_FreeMsgBuf: "				"hNode is Invalid /r/n")));	}	return status;}