queue.c

MTK手机平台的MMI部分的源代码

    }
#ifdef __MMI_FILE_MANAGER__    
    else if (oslMessage->oslSrcId == MOD_MMI &&
             oslMessage->oslDestId == MOD_FMT)
    {
        oslMessage->sap_id = MMI_FMT_SAP;
    }
#endif
    else if (oslMessage->oslSrcId == MOD_MMI &&
             oslMessage->oslDestId == MOD_ABM)
    {
        oslMessage->sap_id = MMI_ABM_SAP;
    }
    else if (oslMessage->oslSrcId == MOD_MMI &&
             oslMessage->oslDestId == MOD_J2ME)
    {
        oslMessage->sap_id = MMI_J2ME_SAP;
    }
    else if (oslMessage->oslSrcId == MOD_MMI &&
             oslMessage->oslDestId == MOD_JASYN)
    {
        oslMessage->sap_id = MMI_JASYN_SAP;
    }
    else if (oslMessage->oslSrcId == MOD_MMI &&
             oslMessage->oslDestId == MOD_SYNCML)
    {
        oslMessage->sap_id = MMI_SYNCML_SAP;
    }
    else if (oslMessage->oslSrcId == MOD_MMI &&
             oslMessage->oslDestId == MOD_POC)
    {
        oslMessage->sap_id = MMI_POC_SAP;
    }
    else if (oslMessage->oslSrcId == MOD_MMI &&
             oslMessage->oslDestId == MOD_WAP)
    {
        oslMessage->sap_id = MMI_WAP_SAP;
    }
    else if (oslMessage->oslSrcId == MOD_WAP &&
             oslMessage->oslDestId == MOD_MMI)
    {
        oslMessage->sap_id = WAP_MMI_SAP;
    }
    else
    {
        oslMessage->sap_id = INVALID_SAP;
    }
    msg_send_ext_queue(oslMessage);
    CheckAndPrintMsgId((U16) (Message->msg_id));
#else /* MMI_ON_WIN32 */ 
    if (Message->oslDestId == MOD_MMI)
    {
        Message->oslDestId = MOD_PRT;
    }
    if (Message->oslSrcId == MOD_MMI)
    {
        Message->oslSrcId = MOD_PRT;
    }
    if (Message->oslDestId == MOD_WAP)
    {
        Message->oslDestId = MOD_PRT;
    }
    
    /* make sure destination module exists */
    MMI_ASSERT( Message->oslDestId < TOTAL_TASKS );
    
    OslIntWriteMsgQ(task_info_g1[Message->oslDestId].task_ext_qid, Message, sizeof(MYQUEUE), OSL_INFINITE_WAIT);
#endif /* MMI_ON_WIN32 */ 
}


/*****************************************************************************
 * FUNCTION
 *  OslIntConstructDataPtr
 * DESCRIPTION
 *  Constructs Data Ptr
 *  
 *  Not used now
 * PARAMETERS
 *  size        [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
void *OslIntConstructDataPtr(U32 size)
{
#ifndef MMI_ON_WIN32
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    return (construct_local_para((kal_uint16) size, TD_CTRL));
#else /* MMI_ON_WIN32 */ 
    void *ptr;
    TSIZE *temp, tempdata;

    temp = OslMalloc(size + sizeof(tempdata));
    assert(temp != NULL);

    tempdata.s = size;
    memcpy(temp, &tempdata, sizeof(tempdata));
    ptr = (void*)((char*)temp + sizeof(tempdata));
    return ptr;
#endif /* MMI_ON_WIN32 */ 

}


/*****************************************************************************
 * FUNCTION
 *  OslIntFreeDataPtr
 * DESCRIPTION
 *  Frees Data Ptr
 *  
 *  Not used now
 * PARAMETERS
 *  ptr     [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void OslIntFreeDataPtr(void *ptr)
{
#ifndef MMI_ON_WIN32
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    free_local_para(ptr);
#else /* MMI_ON_WIN32 */ 
    TSIZE *temp;

    temp = (void*)((char*)ptr - sizeof(TSIZE));
    OslMfree(temp);
#endif /* MMI_ON_WIN32 */ 
}


/*****************************************************************************
 * FUNCTION
 *  OslIntSizeofDataPtr
 * DESCRIPTION
 *  Returns Size of Data Ptr
 *  
 *  Not used now
 * PARAMETERS
 *  ptr     [?]     
 * RETURNS
 *  void
 *****************************************************************************/
U32 OslIntSizeofDataPtr(void *ptr)
{
#ifndef MMI_ON_WIN32
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    struct tsize
    {
        U8 ref_count;
        U16 size;

        /*----------------------------------------------------------------*/
        /* Code Body                                                      */
        /*----------------------------------------------------------------*/
    };

    return 0;
#else /* MMI_ON_WIN32 */ 
    typedef struct tsize
    {
        U32 size;
    } TSIZE;
    TSIZE *temp;

    if (ptr == NULL)
    {
        return 0;
    }
    temp = (void*)((char*)ptr - sizeof(TSIZE));
    return (U32) temp->size;
#endif /* MMI_ON_WIN32 */ 
}


/*****************************************************************************
 * FUNCTION
 *  OslIntFreeInterTaskMsg
 * DESCRIPTION
 *  Frees InterTask Mesg
 *  
 *  Not used now
 * PARAMETERS
 *  Message     [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void OslIntFreeInterTaskMsg(void *Message)
{
#ifndef MMI_ON_WIN32
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    free_ilm(Message);
#else /* MMI_ON_WIN32 */ 

    MYQUEUE *ptr;

    ptr = Message;
    if (ptr->oslSrcId == MOD_L4C)
    {
        ptr->oslSrcId = MOD_MMI;
        ptr->oslDestId = MOD_L4C;

        ptr->oslMsgId = 0;
        OslMsgSendExtQueue(ptr);
    }
    else
    {
        if (ptr->oslDataPtr != NULL)
        {
            OslIntFreeDataPtr(ptr->oslDataPtr);
        }
    }
#endif /* MMI_ON_WIN32 */ 
}

#ifdef MMI_ON_WIN32


/*****************************************************************************
 * FUNCTION
 *  OslNumOfQMsgs
 * DESCRIPTION
 *  Get the message number in MMI queue
 * PARAMETERS
 *  void
 * RETURNS
 *  message number
 *****************************************************************************/
U8 OslNumOfQMsgs(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U8 num;
    oslMsgqid msgqid = task_info_g1[MOD_PRT].task_ext_qid;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    EnterCriticalSection(&msgqid->q_cs);
    num = (U8) (msgqid->q_messages);
    LeaveCriticalSection(&msgqid->q_cs);
    return num;
}

#endif /* MMI_ON_WIN32 */ 
#define CIRCQ_NODE_SIZE sizeof(MYQUEUE)

/* 
 * Because MMI task will receive extQ message into circular queue,
 * we increase the circular queue size from 30 to 50
 */
#define CIRCQ_NO_OF_NODES 65

__align(4)
     U8 circq_array[CIRCQ_NODE_SIZE * CIRCQ_NO_OF_NODES];
     U8 circq_read = 0, circq_write = 0, circq_messages = 0, max_circq_messages = 0;


/*****************************************************************************
 * FUNCTION
 *  OslReadCircularQ
 * DESCRIPTION
 *  Reads from Circ Queue
 *  
 *  Not used now
 * PARAMETERS
 *  msgPtr      [?]     
 * RETURNS
 *  void
 *****************************************************************************/
     U8 OslReadCircularQ(void *msgPtr)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    PRINT_INFORMATION_2((MMI_TRACE_G1_FRM, "OslReadCircularQ: <#[%d], read:[%d], write:[%d]>", circq_messages,
                         circq_read, circq_write));
    if (circq_messages == 0)
    {
        return 0;
    }
    memcpy(msgPtr, circq_array + (circq_read * CIRCQ_NODE_SIZE), CIRCQ_NODE_SIZE);
    if (++circq_read == CIRCQ_NO_OF_NODES)
    {
        circq_read = 0;
    }
    --circq_messages;
    return 1;
}


/*****************************************************************************
 * FUNCTION
 *  OslLookUpLastCircularQMsg
 * DESCRIPTION
 *  Look up the last message in Circ Queue
 *  
 *  Not used now
 * PARAMETERS
 *  msgPtr      [?]     
 * RETURNS
 *  void
 *****************************************************************************/
U8 OslLookUpLastCircularQMsg(void *msgPtr)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U16 last_read_index;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (circq_messages > 0)
    {
        if (circq_write == 0)
        {
            last_read_index = CIRCQ_NO_OF_NODES;
        }
        else
        {
            last_read_index = circq_write - 1;
        }
        memcpy(msgPtr, circq_array + (last_read_index * CIRCQ_NODE_SIZE), CIRCQ_NODE_SIZE);
        return 1;
    }
    else
    {
        memset(msgPtr, 0, CIRCQ_NODE_SIZE);
        return 0;
    }
}


/*****************************************************************************
 * FUNCTION
 *  OslWriteCircularQ
 * DESCRIPTION
 *  Writes to Circ Queue
 *  
 *  Not used now
 * PARAMETERS
 *  msgPtr      [?]     
 * RETURNS
 *  void
 *****************************************************************************/
U8 OslWriteCircularQ(void *msgPtr)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    PRINT_INFORMATION_2((MMI_TRACE_G1_FRM, "OslWriteCircularQ: <#[%d], read:[%d], write:[%d]>", circq_messages,
                         circq_read, circq_write));
    if (circq_messages == CIRCQ_NO_OF_NODES)
    {
        MMI_ASSERT(0);
        return 0;
    }
    memcpy(circq_array + (circq_write * CIRCQ_NODE_SIZE), msgPtr, CIRCQ_NODE_SIZE);
    if (++circq_write == CIRCQ_NO_OF_NODES)
    {
        circq_write = 0;
    }
    ++circq_messages;
    if (max_circq_messages < circq_messages)
    {
        max_circq_messages = circq_messages;
    }
    return 1;
}


/*****************************************************************************
 * FUNCTION
 *  OslNumOfCircularQMsgs
 * DESCRIPTION
 *  Get the message number
 *  
 *  Not used now
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
U8 OslNumOfCircularQMsgs(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    return circq_messages;
}


/*****************************************************************************
 * FUNCTION
 *  OslIsCircularQFull
 * DESCRIPTION
 *  Check if Circ Queue is full
 *  
 *  Not used now
 * PARAMETERS
 *  void
 * RETURNS
 *  void
 *****************************************************************************/
U8 OslIsCircularQFull(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    return (circq_messages == CIRCQ_NO_OF_NODES);
}