/** ============================================================================
* @func LIST_Create
*
* @desc Allocates and initializes a circular list.
*
* @modif None
* ============================================================================
*/
EXPORT_API
DSP_STATUS
LIST_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;
}
/*
* ======== KFILE_Open ========
* Purpose:
* Open a file for reading ONLY
*/
struct KFILE_FileObj *KFILE_Open(CONST char *pszFileName, CONST char *pszMode)
{
struct KFILE_FileObj *hFile; /* file handle */
DSP_STATUS status;
mm_segment_t fs;
struct file*fileDesc = NULL;
DBC_Require(pszMode != NULL);
DBC_Require(pszFileName != NULL);
GT_2trace(KFILE_debugMask, GT_ENTER,
"KFILE_Open: pszFileName %s, pszMode "
"%s\n", pszFileName, pszMode);
/* create a KFILE object */
MEM_AllocObject(hFile, struct KFILE_FileObj, SIGNATURE);
if (hFile) {
fs = get_fs();
set_fs(get_ds());
/* Third argument is mode (permissions). Ignored unless creating file */
fileDesc = filp_open(pszFileName, O_RDONLY, 0);
if ((IS_ERR(fileDesc)) || (fileDesc == NULL) ||
(fileDesc->f_op == NULL) || (fileDesc->f_op->read == NULL)
|| (fileDesc->f_op->llseek == NULL)) {
status = DSP_EFILE;
} else {
hFile->fileDesc = fileDesc;
hFile->fileName = (char *)pszFileName;
hFile->isOpen = true;
hFile->curPos = 0;
hFile->size = fileDesc->f_op->llseek(fileDesc, 0,
SEEK_END);
fileDesc->f_op->llseek(fileDesc, 0, SEEK_SET);
/* Return PID instead of process handle */
hFile->owner_pid = current->pid;
status = DSP_SOK;
}
set_fs(fs);
if (DSP_FAILED(status)) {
/* free memory, and clear handle */
MEM_FreeObject(hFile);
hFile = NULL;
}
} else {
GT_0trace(KFILE_debugMask, GT_6CLASS,
"KFILE_Open: MEM_AllocObject failed\n");
status = DSP_EMEMORY;
}
return hFile;
}
/*
* ======== 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_API
DSP_STATUS
LDRV_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_API
DSP_STATUS
PRCS_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_API
Int
RING_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_API
DSP_STATUS
ISR_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_API
DSP_STATUS
ISR_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_API
DSP_STATUS
MEM_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 ;
}
/*
* ======== DPC_Create ========
* Purpose:
* Create a DPC object, allowing a client's own DPC procedure to be
* scheduled for a call with client reference data.
*/
DSP_STATUS DPC_Create(OUT struct DPC_OBJECT **phDPC, DPC_PROC pfnDPC,
void *pRefData)
{
DSP_STATUS status = DSP_SOK;
struct DPC_OBJECT *pDPCObject = NULL;
if ((phDPC != NULL) && (pfnDPC != NULL)) {
/*
* Allocate a DPC object to store information allowing our DPC
* callback to dispatch to the client's DPC.
*/
MEM_AllocObject(pDPCObject, struct DPC_OBJECT, SIGNATURE);
if (pDPCObject != NULL) {
tasklet_init(&pDPCObject->dpc_tasklet,
DPC_DeferredProcedure,
(u32) pDPCObject);
/* Fill out our DPC Object: */
pDPCObject->pRefData = pRefData;
pDPCObject->pfnDPC = pfnDPC;
pDPCObject->numRequested = 0;
pDPCObject->numScheduled = 0;
#ifdef DEBUG
pDPCObject->numRequestedMax = 0;
pDPCObject->cEntryCount = 0;
#endif
pDPCObject->dpc_lock =
__SPIN_LOCK_UNLOCKED(pDPCObject.dpc_lock);
*phDPC = pDPCObject;
} else {
GT_0trace(DPC_DebugMask, GT_6CLASS,
"DPC_Create: DSP_EMEMORY\n");
status = DSP_EMEMORY;
}
} else {
GT_0trace(DPC_DebugMask, GT_6CLASS,
"DPC_Create: DSP_EPOINTER\n");
status = DSP_EPOINTER;
}
DBC_Ensure((DSP_FAILED(status) && (!phDPC || (phDPC && *phDPC == NULL)))
|| DSP_SUCCEEDED(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;
}
