McpBtsSpStatus _MCP_BTS_SP_MemReadScript(McpBtsSpContext *context, void *buf, McpUint len)
{
    MCP_HAL_MEMORY_MemCopy(buf, context->locationData.memoryPos, len);

    context->locationData.memoryPos += len;

    /* Update position in file */
    context->scriptProcessingPos += len;

    return MCP_BTS_SP_STATUS_SUCCESS;
}
void _CCM_VAC_AllocationEngine_SetResourceProperties (TCCM_VAC_AllocationEngine *ptAllocEngine,
                                                      ECAL_Resource eResource,
                                                      TCAL_ResourceProperties *pProperties)
{
    MCP_FUNC_START ("_CCM_VAC_AESetResourceProperties");

    /* copy resource properties */
    MCP_HAL_MEMORY_MemCopy ((void *)&(ptAllocEngine->tResources[ eResource ].tProperties),
                            (void *)pProperties, sizeof (TCAL_ResourceProperties));

    MCP_FUNC_END ();
}
 /*FM-VAC*/
BtHciIfStatus MCP_HciSeq_RunSequence (MCP_HciSeq_Context *pContext, 
                                      const McpU32 uCommandCount,
                                      const McpHciSeqCmd *pCommands,
                                      McpBool bCallCbOnlyAfterLastCmd)
{
    /* sanity cehck */
    if (HCI_SEQ_MAX_CMDS_PER_SEQUENCE < uCommandCount)
    {
        return BT_HCI_IF_STATUS_FAILED;
    }
    pContext->bCallCBOnlyForLastCmd = bCallCbOnlyAfterLastCmd;

    /* copy commands */
    MCP_HAL_MEMORY_MemCopy ((McpU8 *)pContext->commandsSequence, 
                            (McpU8 *)pCommands,
                            uCommandCount*sizeof(McpHciSeqCmd));

    /* initialize new sequence */
    pContext->uCommandCount = uCommandCount;
    pContext->uCurrentCommandIdx = 0;
    pContext->uSequenceId++;

    /* if a command is pending */
    if (MCP_TRUE == pContext->bPendingCommand)
    {
        return BT_HCI_IF_STATUS_PENDING;
    }
    else
    {
        /* prepare first command (by calling the CB) */
        pContext->commandsSequence[ pContext->uCurrentCommandIdx ].fCommandPrepCB( 
            &(pContext->command),
            pContext->commandsSequence[ pContext->uCurrentCommandIdx ].pUserData );

        /* execute first command */
        return(_MCP_HciSeq_SendCommand(pContext));
    }
}
ECCM_VAC_Status _CCM_VAC_MappingEngine_Configure (TCCM_VAC_MappingEngine *ptMappEngine, 
                                                  TCAL_ResourceSupport *ptAvailResources,
                                                  TCAL_OperationSupport *ptAvailOperations)
{
    McpU32                      uOperationNum, uOperationIndex, uOptResourceNum, uOptResourceIndex, uIndex;
    McpConfigParserStatus       eCPStatus;
    McpU8                       *pTempValue;
    ECAL_Operation              eOperation;
    ECAL_Resource               eResource;
    TCAL_OptionalResource       tTempOptResource;
    ECCM_VAC_Status             status;

    /*
     * The configuration process involves reading chip capabilities and ini file settings 
     * (host capabilities). Chip capabilities are read by the configuration engine and are 
     * set in advance to the mapping engine configuration. This function than read the 
     * mapping section of the ini file. For every operation it read the possible optional 
     * resources and arrange them accordingly. It also read the default resource to be used
     * and set it.
     */

    MCP_FUNC_START ("_CCM_VAC_MappingEngine_Configure");

    MCP_UNUSED_PARAMETER (ptAvailOperations);
    MCP_UNUSED_PARAMETER (ptAvailResources);

    /* read number of operations from ini file */
    eCPStatus = MCP_CONFIG_PARSER_GetIntegerKey (ptMappEngine->pConfigParser, 
                                                 (McpU8 *)CCM_VAC_CONFIG_INI_OPERATIONS_SECTION_NAME,
                                                 (McpU8 *)CCM_VAC_CONFIG_INI_OPERATIONS_NUMBER_KEY_NAME,
                                                 (McpS32 *)&uOperationNum);
    MCP_VERIFY_FATAL (((eCPStatus == MCP_CONFIG_PARSER_STATUS_SUCCESS) && (0 < uOperationNum)),
                        CCM_VAC_STATUS_FAILURE_INVALID_CONFIGURATION,
                        ("_CCM_VAC_MappingEngine_Configure: error reading number of operations "
                         "from file, number: %d, status: %d", uOperationNum, eCPStatus));

    /* for every operation */
    for (uOperationIndex = 0; uOperationIndex < uOperationNum; uOperationIndex++)
    {
        /* read operation */
        eCPStatus = MCP_CONFIG_PARSER_GetAsciiKey (ptMappEngine->pConfigParser,
                                                   (McpU8 *)CCM_VAC_CONFIG_INI_MAPPING_SECTION_NAME,
                                                   (McpU8 *)CCM_VAC_CONFIG_INI_MAPPING_OP_KEY_NAME,
                                                   &pTempValue);
        MCP_VERIFY_FATAL ((eCPStatus == MCP_CONFIG_PARSER_STATUS_SUCCESS),
                          CCM_VAC_STATUS_FAILURE_INVALID_CONFIGURATION,
                          ("_CCM_VAC_MappingEngine_Configure: error reading operation name, status: %d",
                           eCPStatus));

        /* convert operation name to enum value */
        eOperation = StringtoOperation ((const McpU8*)pTempValue);
        MCP_VERIFY_FATAL ((CAL_OPERATION_INVALID != eOperation),
                          CCM_VAC_STATUS_FAILURE_INVALID_CONFIGURATION,
                          ("_CCM_VAC_MappingEngine_Configure: erro converting string %s to operation",
                           pTempValue));

        /* read number of optional resources */
        eCPStatus = MCP_CONFIG_PARSER_GetIntegerKey (ptMappEngine->pConfigParser, 
                                                     (McpU8 *)CCM_VAC_CONFIG_INI_MAPPING_SECTION_NAME,
                                                     (McpU8 *)CCM_VAC_CONFIG_INI_MAPPING_CONFIG_NUM_KEY_NAME,
                                                     (McpS32*)&uOptResourceNum);
        MCP_VERIFY_FATAL ((eCPStatus == MCP_CONFIG_PARSER_STATUS_SUCCESS),
                          CCM_VAC_STATUS_FAILURE_INVALID_CONFIGURATION,
                          ("_CCM_VAC_MappingEngine_Configure: error reading number of optional resources for "
                           "operation %s, status %d",  _CCM_VAC_DebugOperationStr(eOperation), eCPStatus));

        /* for each optional resource */
        for (uOptResourceIndex = 0; uOptResourceIndex < uOptResourceNum; uOptResourceIndex++)
        {
            /* read resource name */
            eCPStatus = MCP_CONFIG_PARSER_GetAsciiKey (ptMappEngine->pConfigParser,
                                                       (McpU8 *)CCM_VAC_CONFIG_INI_MAPPING_SECTION_NAME,
                                                       (McpU8 *)CCM_VAC_CONFIG_INI_MAPPING_RESOURCE_KEY_NAME,
                                                       &pTempValue);
            MCP_VERIFY_FATAL ((eCPStatus == MCP_CONFIG_PARSER_STATUS_SUCCESS),
                              CCM_VAC_STATUS_FAILURE_INVALID_CONFIGURATION,
                              ("_CCM_VAC_MappingEngine_Configure: error reading resource name (index %d) "
                               "for operation %s, status: %d", uOptResourceIndex, 
                               _CCM_VAC_DebugOperationStr(eOperation), eCPStatus));

            /* convert resource name to enum value */
            eResource = StringtoResource ((const McpU8 *)pTempValue);
            MCP_VERIFY_FATAL ((CAL_RESOURCE_INVALID != eResource),
                              CCM_VAC_STATUS_FAILURE_INVALID_CONFIGURATION,
                              ("_CCM_VAC_MappingEngine_Configure: error converting string %s to resource",
                               pTempValue));

            /* find the resource entry in the optional resources list */
            for (uIndex = 0; 
                 uIndex < ptMappEngine->tConfig.tOpToResMap[ eOperation ].tOptionalResources.uNumOfResourceLists;
                 uIndex++)
            {
                if (eResource == ptMappEngine->tConfig.tOpToResMap[ eOperation ].tOptionalResources.tOptionalResourceLists[ uIndex ].eOptionalResource)
                {
                    break;
                }
            }

            /* verify resource was found */
            MCP_VERIFY_FATAL ((uIndex < ptMappEngine->tConfig.tOpToResMap[ eOperation ].tOptionalResources.uNumOfResourceLists),
                              CCM_VAC_STATUS_FAILURE_INVALID_CONFIGURATION,
                              ("_CCM_VAC_MappingEngine_Configure: optional resource %s for operation %s in "
                               "ini file is not within chip capabilities", 
                               _CCM_VAC_DebugResourceStr(eResource), _CCM_VAC_DebugOperationStr(eOperation)));

            /* if needed, move it to the beginning of the list */
            if (uIndex > uOptResourceIndex)
            {
                /* copy resource at the list beginning to temp storage */
                MCP_HAL_MEMORY_MemCopy (&tTempOptResource, 
                                        &(ptMappEngine->tConfig.tOpToResMap[ eOperation ].tOptionalResources.tOptionalResourceLists[ uOptResourceIndex ]), 
                                        sizeof (TCAL_OptionalResource));

                /* copy found resource to list beginning */
                MCP_HAL_MEMORY_MemCopy (&(ptMappEngine->tConfig.tOpToResMap[ eOperation ].tOptionalResources.tOptionalResourceLists[ uOptResourceIndex ]), 
                                        &(ptMappEngine->tConfig.tOpToResMap[ eOperation ].tOptionalResources.tOptionalResourceLists[ uIndex ]), 
                                        sizeof (TCAL_OptionalResource));

                /* finally, copy back temp storage to found resource */
                MCP_HAL_MEMORY_MemCopy (&(ptMappEngine->tConfig.tOpToResMap[ eOperation ].tOptionalResources.tOptionalResourceLists[ uIndex ]),
                                        &tTempOptResource,
                                        sizeof (TCAL_OptionalResource));
            }

            /* mark the resource as unused */
            ptMappEngine->tConfig.tOpToResMap[ eOperation ].tOptionalResources.tOptionalResourceLists[ uOptResourceIndex ].bIsUsed = MCP_FALSE;
        }

        /* set number of possible optional resources */
        ptMappEngine->tConfig.tOpToResMap[ eOperation ].tOptionalResources.uNumOfResourceLists = uOptResourceNum;

        /* if there are optional resources, read and indicate the default optional resource */
        if (0 < uOptResourceNum)
        {
            /* read the default resource */
            eCPStatus = MCP_CONFIG_PARSER_GetAsciiKey (ptMappEngine->pConfigParser,
                                                       (McpU8 *)CCM_VAC_CONFIG_INI_MAPPING_SECTION_NAME,
                                                       (McpU8 *)CCM_VAC_CONFIG_INI_MAPPING_DEF_RESOURCE_KEY_NAME,
                                                       &pTempValue);
            MCP_VERIFY_FATAL ((eCPStatus == MCP_CONFIG_PARSER_STATUS_SUCCESS),
                              CCM_VAC_STATUS_FAILURE_INVALID_CONFIGURATION,
                              ("_CCM_VAC_MappingEngine_Configure: error reading default resource name "
                               "for operation %s, status: %d", uOptResourceIndex, 
                               _CCM_VAC_DebugOperationStr(eOperation), eCPStatus));

            /* convert default resource name to enum value */
            eResource = StringtoResource ((const McpU8 *)pTempValue);
            MCP_VERIFY_FATAL ((CAL_RESOURCE_INVALID != eResource),
                              CCM_VAC_STATUS_FAILURE_INVALID_CONFIGURATION,
                              ("_CCM_VAC_MappingEngine_Configure: error converting string %s to resource",
                               pTempValue));

            /* search default resource within optional resources */
            for (uIndex = 0; 
                 uIndex < ptMappEngine->tConfig.tOpToResMap[ eOperation ].tOptionalResources.uNumOfResourceLists;
                 uIndex++)
            {
                /* if this is the default resource */
                if (eResource == ptMappEngine->tConfig.tOpToResMap[ eOperation ].tOptionalResources.tOptionalResourceLists[ uIndex ].eOptionalResource)
                {
                    /* mark it as current mapping for this operation */
                    ptMappEngine->tConfig.tOpToResMap[ eOperation ].tOptionalResources.tOptionalResourceLists[ uIndex ].bIsUsed = MCP_TRUE;
                }
            } 
        }
    }

    MCP_FUNC_END ();

    return CCM_VAC_STATUS_SUCCESS;
}