/*
 *  ======== ti_sdo_ipc_Notify_Instance_finalize ========
 */
Void ti_sdo_ipc_Notify_Instance_finalize(ti_sdo_ipc_Notify_Object *obj,
        Int status)
{
    UInt    i;
    UInt16  clusterId = ti_sdo_utils_MultiProc_getClusterId(obj->remoteProcId);

    switch (status) {
    case 0:
        /* Unregister the notify instance from the Notify module */
        Notify_module->notifyHandles[clusterId][obj->lineId] = NULL;

        /* Destruct the event lists */
        for (i = 0; i < ti_sdo_ipc_Notify_numEvents; i++) {
            List_destruct(List_struct(List_Object_get(obj->eventList, i)));
        }

        /* Free memory used for the List.Objects */
        Memory_free(ti_sdo_ipc_Notify_Object_heap(), obj->eventList,
                    sizeof(List_Struct) * ti_sdo_ipc_Notify_numEvents);

    /* OK to fall through */

    case 1:
        /* Free memory used for callbacks array */
        Memory_free(ti_sdo_ipc_Notify_Object_heap(), obj->callbacks,
                    sizeof(ti_sdo_ipc_Notify_EventCallback) *
                    ti_sdo_ipc_Notify_numEvents);
    }
}

NORET Darray_destroy(Darray dyn_ary)
    {
    Darray_rep *temp = dlower(dyn_ary);
    
    Memory_free((VOIDP)temp->storage);
    Memory_free((VOIDP)temp);
    }

Void appTaskFxn(UArg arg0, UArg arg1)
{
	char* args[8];
	//arg[0] is 2 chars for dev type
	args[0] = Memory_alloc(NULL, 2 * sizeof(char), 0, NULL);
	//arg[1] is 3 chars for channel num
	args[1] = Memory_alloc(NULL, 3 * sizeof(char), 0, NULL);

	//init the RPC queue
	rpcInitMq();

	//init the application thread to register the callbacks
	appInit();

	consolePrint(
	        "Enter device type c: Coordinator, r: Router, e: End Device:\n");
	consoleGetLine(args[0], 8);

	consolePrint("Enter channel 11-26:\n");
	consoleGetLine(args[1], 8);

	while (1)
	{
		appProcess(args);
		Task_sleep(10);
	}

	Memory_free(NULL, args[0], 2 * sizeof(char));
	Memory_free(NULL, args[1], 3 * sizeof(char));
}

/*
 *  ======== LoggerBuf_Instance_finalize ========
 */
Void LoggerBuf_Instance_finalize(LoggerBuf_Object *obj, Int status)
{
    if (obj->entryArr != NULL) {
        Memory_free(obj->bufHeap, obj->entryArr,
                    obj->numEntries * sizeof (LoggerBuf_Entry));
    }
}

static int do_memoryAlloc(CodecEngine* _ce, size_t _srcBufferSize, size_t _dstBufferSize)
{
  memset(&_ce->m_allocParams, 0, sizeof(_ce->m_allocParams));
  _ce->m_allocParams.type = Memory_CONTIGPOOL;
  _ce->m_allocParams.flags = Memory_CACHED;
  _ce->m_allocParams.align = BUFALIGN;
  _ce->m_allocParams.seg = 0;

  _ce->m_srcBufferSize = ALIGN_UP(_srcBufferSize, BUFALIGN);
  if ((_ce->m_srcBuffer = Memory_alloc(_ce->m_srcBufferSize, &_ce->m_allocParams)) == NULL)
  {
    fprintf(stderr, "Memory_alloc(src, %zu) failed\n", _ce->m_srcBufferSize);
    _ce->m_srcBufferSize = 0;
    return ENOMEM;
  }

  _ce->m_dstBufferSize = ALIGN_UP(_dstBufferSize, BUFALIGN);
  if ((_ce->m_dstBuffer = Memory_alloc(_ce->m_dstBufferSize, &_ce->m_allocParams)) == NULL)
  {
    fprintf(stderr, "Memory_alloc(dst, %zu) failed\n", _ce->m_dstBufferSize);
    _ce->m_dstBufferSize = 0;
    Memory_free(_ce->m_srcBuffer, _ce->m_srcBufferSize, &_ce->m_allocParams);
    _ce->m_srcBuffer = NULL;
    _ce->m_srcBufferSize = 0;
    return ENOMEM;
  }

  return 0;
}

/*
 *  ======== MessageQ_free ========
 */
Int MessageQ_free(MessageQ_Msg msg)
{
    IHeap_Handle heap;

    /* make sure msg is not NULL */
    Assert_isTrue((msg != NULL), ti_sdo_ipc_MessageQ_A_invalidMsg);
    
    /* Cannot free a message that was initialized via MessageQ_staticMsgInit */
    Assert_isTrue((msg->heapId != ti_sdo_ipc_MessageQ_STATICMSG), 
                  ti_sdo_ipc_MessageQ_A_cannotFreeStaticMsg);
    
    Assert_isTrue((msg->heapId < MessageQ_module->numHeaps),
                  ti_sdo_ipc_MessageQ_A_heapIdInvalid);

    Assert_isTrue((MessageQ_module->heaps[msg->heapId] != NULL),
                  ti_sdo_ipc_MessageQ_A_heapIdInvalid);

    if ((ti_sdo_ipc_MessageQ_traceFlag == TRUE) ||
        (msg->flags & ti_sdo_ipc_MessageQ_TRACEMASK) != 0) {                    
        Log_write3(ti_sdo_ipc_MessageQ_LM_free, (UArg)(msg), 
            (UArg)(msg->seqNum), (UArg)(msg->srcProc));
    }
    
    heap = MessageQ_module->heaps[msg->heapId];
    
    if (heap != NULL) {
        Memory_free(heap, msg, msg->msgSize);
    }
    else {
        return (MessageQ_E_FAIL);
    }

    return (MessageQ_S_SUCCESS);
}

/*
 *  ======== Power_unregisterConstraint ========
 *  Unregister for a power notification.
 *
 */
Power_Status Power_unregisterConstraint(Power_ConstraintHandle handle)
{
    Power_Status status = Power_SOK;
    Power_Constraint type;
    UInt key;

    /* check for NULL constraintHandle */
    if (handle == NULL) {
        status = Power_EINVALIDHANDLE;
    }

    /* else, remove and delete constraint object, update aggregate constraint */
    else {
        key = Hwi_disable();
        Queue_remove((Queue_Elem *)handle);
        Hwi_restore(key);

        /* recompute aggregate constraint w/absence of removed constraint */
        type = ((Power_ConstraintObj *) handle)->type;
        Power_rebuildConstraint(type);

        /* free the constraint object */
        Memory_free(Power_Object_heap(), handle, sizeof(Power_ConstraintObj));
    }

    return (status);
}

/*
 *  ======== Algorithm_delete ========
 */
Void Algorithm_delete(Algorithm_Handle alg)
{
    Algorithm_Obj *pObject = (Algorithm_Obj *)alg;
    IRES_Status status;

    Log_print1(Diags_ENTRY, "[+E] Algorithm_delete> Enter(alg=0x%x)",
            (IArg)alg);

    if (pObject != NULL) {
        if (pObject->iresFxns) {
            /* Call RMAN fuction to free resources */
            status = RMAN_freeResources(pObject->alg, pObject->iresFxns,
                    pObject->groupId);
            if (status != IRES_OK) {
                Log_print1(Diags_USER7, "[+7] Algorithm_delete> Freeing "
                        "of alg resources through RMAN FAILED (0x%x)",
                        (IArg)status);
            }
        }

        if (pObject->alg) {
            DSKT2_freeAlg(pObject->groupId, pObject->alg);
        }

        Memory_free(pObject, sizeof (*pObject), NULL);
    }

    Log_print0(Diags_EXIT, "[+X] Algorithm_delete> Exit");
}

/*
 *  ======== Algorithm_delete ========
 */
Void Algorithm_delete(Algorithm_Handle alg)
{
    Algorithm_Obj *pObject = (Algorithm_Obj *)alg;
    IRES_Status status;

    Log_print1(Diags_ENTRY, "[+E] Algorithm_delete> Enter(alg=0x%x)",
            (IArg)alg);

    if (pObject != NULL) {
        if (pObject->iresFxns) {
            /* Call RMAN fuction to free resources */
            status = RMAN_freeResources(pObject->alg, pObject->iresFxns,
                    pObject->groupId);
            if (status != IRES_OK) {
                Log_print1(Diags_USER7, "[+7] Algorithm_delete> Freeing "
                        "of alg resources through RMAN FAILED (0x%x)",
                        (IArg)status);
            }
        }

        if (pObject->idma3Fxns) {
            Log_print0(Diags_USER4, "[+4] Algorithm_delete> releasing "
                    "DMA resources");
            DMAN3_releaseDmaChannels(&(pObject->alg), &(pObject->idma3Fxns),1);
        }

        if (pObject->alg) {
            ALG_delete(pObject->groupId, pObject->alg, pObject->useCachedMem);
        }

        Memory_free(pObject, sizeof (*pObject), NULL);
    }

    Log_print0(Diags_EXIT, "[+X] Algorithm_delete> Exit");
}

void _XdmServer_freeXdaisAlgMemory(IALG_MemRec memTab[], Int numRecs)
{
    Int idx;
    uint8_t                 *handle;
    uint8_t                 *RPE_dspIramHeapHandle = globaL2heap;
    
    for (idx = 0; idx < numRecs; idx++) 
    {
        if (memTab[idx].base != NULL) 
        {
            if ( memTab[idx].space > IALG_SARAM2 ) 
            { 
                handle = RPE_dspAlgHeapHandle;
            }
            else
            {
                handle = RPE_dspIramHeapHandle;
            }

            /* Freeing a buffer of size 0 is not possible, so we allocate     */
            /* 8 bytes during creation. This is taken care during deletion    */
            if (memTab[idx].size == 0)
            {
                memTab[idx].size = 8;
            }
            
            Memory_free ((IHeap_Handle) handle, memTab[idx].base, memTab[idx].size);
        }
    }
    return;
}

/*
 *  ======== MEM_increaseTableSize ========
 */
Int MEM_increaseTableSize(Uns numEntries)
{
    IArg                key;
    IHeap_Handle       *tmpTable;
    Error_Block         eb;
    
    Error_init(&eb);

    /* Use HeapMem's gate for thread-safety */
    key = HeapMem_enter();

    tmpTable = Memory_calloc(MEM_table[0],
        (MEM_tabSize + numEntries) * sizeof(IHeap_Handle), 0, NULL);
    
    if (tmpTable == NULL) {
        HeapMem_leave(key);
        return (SYS_EALLOC);
    }

    memcpy(tmpTable, MEM_table, MEM_tabSize * sizeof(IHeap_Handle));

    if ((MEM_tabSize != 0) && (staticTable != TRUE)) {
        Memory_free(MEM_table[0], MEM_table, MEM_tabSize * sizeof(IHeap_Handle));
    }

    staticTable = FALSE;
    MEM_table = tmpTable;
    MEM_tabSize += numEntries;

    HeapMem_leave(key);

    return (SYS_OK);
}

/******************************************************************************
 * Buffer_copy
 ******************************************************************************/
Int Buffer_copy(Buffer_Handle hSrcBuf, Buffer_Handle hDstBuf)
{
    assert(hSrcBuf);
    assert(hDstBuf);
    assert(hSrcBuf->type == Buffer_Type_BASIC ||
           hSrcBuf->type == Buffer_Type_GRAPHICS);

    if(hSrcBuf->type != hDstBuf->type) {
        Dmai_err1("Cannot copy to Buffer type (%d)\n", hDstBuf->type);
        return Dmai_EFAIL;
    }

    if (!hDstBuf->reference && hDstBuf->userPtr) {
        Dmai_dbg3("Free Buffer of size %u at 0x%x (0x%x phys)\n",
                  (Uns) hDstBuf->origState.numBytes,
                  (Uns) hDstBuf->userPtr,
                  (Uns) hDstBuf->physPtr);

        if (!Memory_free(hDstBuf->userPtr, hDstBuf->origState.numBytes,
                         &hDstBuf->memParams)) {
            return Dmai_EFAIL;
        }
    }

    if(hSrcBuf->type == Buffer_Type_GRAPHICS) {
        *(_BufferGfx_Object *) hDstBuf = *(_BufferGfx_Object *) hSrcBuf;
    } else {
        *(_Buffer_Object *) hDstBuf = *(_Buffer_Object *) hSrcBuf;
    }

    hDstBuf->reference = TRUE;

    return Dmai_EOK;
}

/*
 *  ======== NODE_delete ========
 */
Int NODE_delete(NODE_Handle node)
{
    Void   *handle;

    /* Should be a DBC_requires */
    Assert_isTrue(node != NULL, (Assert_Id)NULL);
    Assert_isTrue(node->skelFxns != NULL, (Assert_Id)NULL);
    Assert_isTrue(node->skelFxns->apiDestroy != NULL, (Assert_Id)NULL);

    /* delete thread *before* destroying node to ensure thread has no access
     * to node as we are freeing it
     */
    if (node->self) {
        Log_print1(Diags_ENTRY, "[+E] NODE_delete(0x%x)", (IArg)node);

        Thread_delete(&(node->self));
    }

    handle = NODE_getEnv(node);

    if (handle) {
        node->skelFxns->apiDestroy(handle);
    }

    if (node->recv != Comm_INVALIDHANDLE) {
        Comm_delete(node->recv);
    }

    Memory_free(NULL, node, sizeof(NODE_Obj));

    return (NODE_EOK);
}

Int SystemCfg_deleteResources(SystemCfg_Object *obj)
{
    IHeap_Handle        heapH;
    Int                 status = 0;


    Log_print1(Diags_ENTRY | Diags_INFO, "--> "FXNN": (obj=0x%x)",(IArg)obj);

    /* delete opencl buffer heap */
//  HeapBufMP_delete(&obj->openclHeapH);

    /* unregister rcm message heap with MessageQ */
    MessageQ_unregisterHeap(SystemCfg_RcmMsgHeapId_CompDev);

    /* delete rcm message heap instance */
    HeapBuf_delete(&obj->rcmHeapH);

    /* free the rcm message heap storage */
    heapH = (IHeap_Handle)SharedRegion_getHeap(0);
    Memory_free(heapH, obj->rcmHeapBufBase, obj->rcmHeapBufSize);
    obj->rcmHeapBufBase = NULL;
    obj->rcmHeapBufSize = 0;

    Log_print1(Diags_EXIT, "<-- "FXNN": %d", (IArg)status);
    return(status);
}

/*!
 *  @brief      Function to finalize the HAL object
 *
 *  @param      halObj      Pointer to the HAL object
 *
 *  @sa         OMAPL1XX_halInit
 *              OMAPL1XX_phyShmemExit
 */
Int
OMAPL1XX_halExit (Ptr halObj)
{
    Int                  status    = PROCESSOR_SUCCESS;
    OMAPL1XX_HalObject * halObject = NULL;

    GT_1trace (curTrace, GT_ENTER, "OMAPL1XX_halExit", halObj);

    GT_assert (curTrace, (halObj != NULL));

    halObject = (OMAPL1XX_HalObject *) halObj ;
    status = OMAPL1XX_phyShmemExit (halObj);
#if !defined(SYSLINK_BUILD_OPTIMIZE)
    if (status < 0) {
        GT_setFailureReason (curTrace,
                             GT_4CLASS,
                             "OMAPL1XX_halExit",
                             status,
                             "OMAPL1XX_phyShmemExit failed!");
    }
#endif /* if !defined(SYSLINK_BUILD_OPTIMIZE) */

    if (halObj != NULL) {
        /* Free the memory for the HAL object. */
        Memory_free (NULL, halObj, sizeof (OMAPL1XX_HalObject));
    }

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

    /*! @retval PROCESSOR_SUCCESS Operation successful */
    return status;
}

Int32 Utils_memFree(Ptr addr, UInt32 size)
{
    UInt32 heapId = UTILS_MEM_VID_FRAME_BUF_HEAP;
    SharedRegion_Entry srEntry;

   SharedRegion_getEntry(SYSTEM_IPC_SR_VIDEO_FRAME, &srEntry);

    /* if address falls in tiler buffer then free from that heap */
    if((UInt32)addr >= (UInt32)srEntry.base && (UInt32)addr < ((UInt32)srEntry.base + srEntry.len) )
    {
        #ifdef UTILS_MEM_DEBUG
        Vps_printf(" UTILS: MEM: FRAME FREE, addr = 0x%08x, size = %d bytes, heap = %d\n", addr, size, heapId);
        #endif

        /* free previously allocated memory */
        Memory_free(gUtils_heapMemHandle[heapId], addr, size);
    }
    else
    {
        Int32 status;

        status = SystemTiler_freeRaw(addr,size);
        UTILS_assert(status == 0);
    }

    return 0;
}

/*!
 *  @brief      Remove and delete entry from the Translation Table
 *
 *  @param      da      Device address
 *
 *  @sa         _SysLinkMemUtils_insertMapElement
 */
static Ptr
_SysLinkMemUtils_removeMapElement (Ptr da)
{
    AddrNode  * node;
    Ptr         addr = NULL;

    GT_1trace (curTrace, GT_ENTER, "_SysLinkMemUtils_removeMapElement", da);

    OsalSemaphore_pend (SysLinkMemUtils_module->semList,
                        OSALSEMAPHORE_WAIT_FOREVER);
    node = _SysLinkMemUtils_findNode (da);
    if (!node || node->da != da) {
#if !defined(SYSLINK_BUILD_OPTIMIZE)
        GT_setFailureReason (curTrace,
                             GT_4CLASS,
                             (Char *)__func__,
                             PROCMGR_E_FAIL,
                             "Entry not found!");
#endif /* if !defined(SYSLINK_BUILD_OPTIMIZE) */
    }
    else {
        addr = node->ua;
        List_remove (SysLinkMemUtils_module->addrTable, &node->elem);
        Memory_free (NULL, node, sizeof (AddrNode));
    }
    OsalSemaphore_post (SysLinkMemUtils_module->semList);

    GT_1trace (curTrace, GT_LEAVE, "_SysLinkMemUtils_removeMapElement", addr);

    return addr;
}

Int IpcResource_disconnect(IpcResource_Handle handle)
{
    Int status;
    IpcResource_Req req;

    if (!handle) {
        System_printf("IpcResource_disconnect: handle is NULL\n");
    }

    req.resType = 0;
    req.reqType = IpcResource_REQ_TYPE_DISCONN;

    status = MessageQCopy_send(MultiProc_getId("HOST"), IpcResource_server,
                        handle->endPoint, &req, sizeof(req));
    if (status) {
        System_printf("IpcResource_disconnect: MessageQCopy_send "
                      "failed status %d\n", status);
        return status;
    }

    status = MessageQCopy_delete(&handle->msgq);
    if (status) {
        System_printf("IpcResource_disconnect: MessageQCopy_delete "
                      "failed status %d\n", status);
        return status;
    }

    Memory_free(NULL, handle, sizeof(*handle));

    return 0;
}

/*
 *  ======== HeapMultiBuf_Instance_finalize ========
 *  Deletes the managed HeapBuf instances and frees the memory for the 
 *  sorted buffer arrays.
 */
Void HeapMultiBuf_Instance_finalize(HeapMultiBuf_Object *obj, int status)
{
    Int i;
    
    /* If a create failed, handle the finalize based on the status. */
    switch (status) {
        /* Alloc of bufsByAddr failed. */
        case 1:
            return;
        /* Alloc of bufsBySize failed. */
        case 2:
            /* bufsByAddr succeeded, so free bufsByAddr. */
            Memory_free(NULL, obj->bufsByAddr, obj->numBufs * sizeof(HeapMultiBuf_AddrPair));
            return;
        case 3:
            /* Delete any heapBufs that were successfully created. */
            for (i = 0; i < obj->numBufs; i++) {
                /* 
                 * bufsBySize was calloc'd, so we can check for NULL to find
                 * the end of the created HeapBufs.
                 */
                if (&(obj->bufsBySize[i]) == NULL) {
                    break;
                }
                
                HeapBuf_delete(&(obj->bufsBySize[i]));
            }
            /* Free both the bufsByAddr and bufsBySize arrays. */
            Memory_free(NULL, obj->bufsByAddr, obj->numBufs * sizeof(HeapMultiBuf_AddrPair));
            Memory_free(NULL, obj->bufsBySize, obj->numBufs * sizeof(HeapBuf_Object*));
            return;
    }
    
    /* 
     * If finalize is being called through a normal delete, rather than
     * through a failed create...
     */
     
    /* Delete all of the created HeapBufs */
    for (i = 0; i < obj->numBufs; i++) {
        HeapBuf_delete(&(obj->bufsBySize[i]));
    }
    
    /* Free the bufsByAddr and bufsBySize arrays. */
    Memory_free(NULL, obj->bufsByAddr, obj->numBufs * sizeof(HeapMultiBuf_AddrPair));
    Memory_free(NULL, obj->bufsBySize, obj->numBufs * sizeof(HeapBuf_Object*));
}

/*
 *  ======== Comm_create ========
 */
Comm_Handle Comm_create(String queueName, Comm_Attrs *attrs)
{
    Comm_Obj   *comm;
    UInt32      commId;
    Char        commName[ MAXCOMMNAMELEN ];
    key_t       key;

    Assert_isTrue(curInit > 0, (Assert_Id)NULL);

    Log_print2(Diags_ENTRY, "[+E] Comm_create> "
            "Enter(queueName='%s', attrs=0x%x)", (IArg)queueName, (IArg)attrs);

    if (attrs == NULL) {
        attrs = &Comm_ATTRS;
    }

    if (queueName == NULL) {
        /* Generate a name to use */
        // TODO: Increment curCommId atomically
        commId = curCommId++;
        sprintf(commName, "queue_%lu_%u", Global_getProcessId(), (Uns)commId);
        key = nameToId(commName);
    }
    else {
        key = nameToId(queueName);
    }

    comm = (Comm_Obj *)Memory_alloc(NULL, sizeof(Comm_Obj), 0, NULL);
    if (comm == NULL) {
        return (NULL);
    }

    comm->type = attrs->type;

    if (comm->type == Comm_PEND) {
        ;
    }
    else if (comm->type == Comm_CALL) {
        comm->callHandle = attrs->callHandle;
        comm->callFxn    = attrs->callFxn;
    }
    else {
        Assert_isTrue(FALSE, (Assert_Id)NULL);  /* unknown Comm type */
    }

    /*
     * Create a new message queue id for the "name" key
     */
    if ((comm->id = msgget(key, IPC_CREAT | 0644)) < 0) {
        fprintf(stderr, "msgget key = 0x%x\n", key);
        perror("Comm_create:msgget");
        Memory_free(NULL, comm, sizeof(Comm_Obj));
        return (NULL);
    }

    Log_print1(Diags_EXIT, "[+X] Comm_create> return (0x%x)", (IArg)comm);

    return (comm);
}