m803xxvoip.c

m80320 VoIP DSP驱动源码

    #if 0
    if(FrameNumInOneRTPPacket == 0)
        return 0x1400 | VADOption; /* default 20ms */
    #endif
    switch(PortPtr->pt_value)
    {
        case  0x0880:  /* G711Alaw */
        #if 0
        case  0x0F80:  /* G728 */
        #endif
        case  0x0080:  /* G711Ulaw */
        #if 0
            opt_value = (((FrameNumInOneRTPPacket*5) << 8) | VADOption);
        #else
            opt_value = (0x1400 | VADOption);
        #endif
            break;

        /* modify g.7231 packet len 30ms by caowm 2003/06/25 */
        case 0x0480:   /* G723.1*/
        #if 0
            opt_value = (((FrameNumInOneRTPPacket*30) << 8) | VADOption);
        #else
            opt_value = (0x1E00 | VADOption);
        #endif
            break;

        case 0x1280:   /* G729 */
        #if 0
            opt_value = (((FrameNumInOneRTPPacket*10) << 8) | VADOption);
        #else
            opt_value = (0x1400 | VADOption);
        #endif
            break;

        default:
            opt_value = 0x1400 | VADOption; /* 0x1470; 20ms */
            break;
    }
    return opt_value;
}

/*************************************************************************/
/* Function name: Send_VCEOPT_Cmd                                        */
/* Description  : Send VCEOPT Cmd of VoP API to M803xx                   */
/* Return type  : void                                                   */
/* Argument     : PinNo -- No. of Port Num                               */
/* Author/Date  :                                                        */
/* Note:                                                                 */
/*                                                                       */
/*************************************************************************/
void Send_VCEOPT_Cmd(UINT8 PortNo, UINT16 FIFO1, UINT16 FIFO2)
{
    UINT16 InCmd;
    M803xx_PORT_STATE *PortPtr;
    UINT8 send_ok_flag = 0;

    PortPtr = (M803xx_PORT_STATE *)&m_port[PortNo];
    
    semTake(M803xxQueueSem[PortNo/8], WAIT_FOREVER);
    if (OK== M80320_checkOpenChanQueue(PortNo, 4, FUN_VCEOPT))
    {
        InCmd = PortPtr->InCmd;

        PortPtr->tx_cmd_fifo[InCmd] = FIFO1;
        if( ++InCmd >= MAX_LEN_OF_CMD_FIFO)  
            InCmd = 0;

        PortPtr->tx_cmd_fifo[InCmd] = FIFO2; /*0x0040;*/
        if( ++InCmd >= MAX_LEN_OF_CMD_FIFO)  
            InCmd = 0;

        PortPtr->InCmd = InCmd;

        RemainedTxCmdNum[PortNo]+= 2;

        #if SendOpenChannelMsgFirst
        send_ok_flag = SendMsgToOpenChannelQueue(CMD_CMDDAT, 0xfd04, 0x0200, FUN_VCEOPT, PortNo);
        #else
        QueueTxBoxMsg(CMD_CMDDAT, 0xfd04, 0x0200, FUN_VCEOPT, PortNo);
        #endif
    }
    semGive(M803xxQueueSem[PortNo/8]);
}

#if 1
/*************************************************************************/
/* Function name: Send_PTCHNG_Cmd                                        */
/* Description  : Send PTCHNG Cmd of VoP API to M803xx                   */
/* Return type  : void                                                   */
/* Argument     : PortNo -- No. of Port Num                               */
/* Author/Date  :                                                        */
/* Note:                                                                 */
/*                                                                       */
/*************************************************************************/
void Send_PTCHNG_Cmd(UINT8 PortNo)
{
    UINT8  name, send_ok_flag = 0;
    UINT16 InCmd, Type;
    M803xx_PORT_STATE *PortPtr;

    PortPtr = (M803xx_PORT_STATE *)&m_port[PortNo];

    /*2006-3-28 Added by ZhengQishan, 传真和语音的参数不一样*/
    if (m_port[PortNo].ExpectServiceType == Fax)
        name = (UINT8)(gpT38FaxParameter[PortNo]->bearerInformation);
    else
        name = (UINT8)(Parameter[PortNo].bearerInformation);

    switch(name)
    {
        case  CODER_TYPE_G711Alaw:
            Type = G711Alaw;  /* G711Alaw = 8 */
            break;

        case  CODER_TYPE_G711Ulaw:
            Type = G711ulaw;  /* G711Ulaw = 0 */
            break;

        case  6:
        case  CODER_TYPE_G723:
            Type = G723;  /* G7231 = 4 */
            break;

        #if 0
        case 10:
            Type = G728; /* G728 = 0xF */
            break;
        #endif
        case  CODER_TYPE_G729:           /* G729 */
        case  CODER_TYPE_G729a:          /* G729a */ 
        case  CODER_TYPE_G729wb:         /* G729wb */
        case  CODER_TYPE_G729awb:        /* G729awb */
            Type = G729;  /* G729 = 0x12 */
            break;

        case  CODER_TYPE_T38:
            Type = IFP; /* T38 fax = 0x62 (98) */
            break;

        default:
            Type = G729;  /* G729 = 0x12 */
            break;
    }
    semTake(M803xxQueueSem[PortNo/8], WAIT_FOREVER);
    if (OK == M80320_checkOpenChanQueue(PortNo, 2, FUN_PTCHNG))
    {
        InCmd = PortPtr->InCmd;

        PortPtr->tx_cmd_fifo[InCmd] = Type;
        if( ++InCmd >= MAX_LEN_OF_CMD_FIFO)  InCmd = 0;

        PortPtr->InCmd = InCmd;

        RemainedTxCmdNum[PortNo]++;
        
        #if SendOpenChannelMsgFirst
        send_ok_flag = SendMsgToOpenChannelQueue(CMD_CMDDAT, 0xfd02, 0x0200, FUN_PTCHNG, PortNo);
        #else
        QueueTxBoxMsg(CMD_CMDDAT, 0xfd02, 0x0200, FUN_PTCHNG, PortNo);
        #endif
    }
    semGive(M803xxQueueSem[PortNo/8]);
}
#endif

#if 0
/*************************************************************************/
/* Function name: Send_FAXOPT_Cmd                                        */
/* Description  : Send FAXOPT Cmd of VoP API to M803xx                   */
/* Return type  : void                                                   */
/* Argument     : PortNo -- No. of Port Num                               */
/* Author/Date  :                                                        */
/* Note:                                                                 */
/*                                                                       */
/*************************************************************************/
void Send_FAXOPT_Cmd(UINT8 PortNo)
{
    UINT16 InCmd;
    M803xx_PORT_STATE *PortPtr;
    UINT16 opt_value=0x9720;
    UINT8 send_ok_flag = 0;

    PortPtr = (M803xx_PORT_STATE *)&m_port[PortNo];

    semTake(M803xxQueueSem[PortNo/8], WAIT_FOREVER);
    if (OK == M80320_checkOpenChanQueue(PortNo, 2, FUN_FAXOPT))
    {
        InCmd = PortPtr->InCmd;

        PortPtr->tx_cmd_fifo[InCmd] = opt_value;
        if( ++InCmd >= MAX_LEN_OF_CMD_FIFO)  InCmd = 0;
    
        PortPtr->InCmd = InCmd;
    
        RemainedTxCmdNum[PortNo]++;

        #if SendOpenChannelMsgFirst
        send_ok_flag = SendMsgToOpenChannelQueue(CMD_CMDDAT, 0xfd02, 0x0200, FUN_FAXOPT, PortNo);
        #else
        QueueTxBoxMsg(CMD_CMDDAT, 0xfd02, 0x0200, 0X8003, PortNo);
        #endif
    }
    semGive(M803xxQueueSem[PortNo/8]);
}
#endif

/*************************************************************************/
/* Function name: Send_ECHOCAN_Cmd                                       */
/* Description  : Send ECHOCAN Command to M803xx                         */
/* Return type  : void                                                   */
/* Argument     : PortNo -- No. of Port Num                              */
/* Author/Date  :                                                        */
/* Note:                                                                 */
/*                                                                       */
/*************************************************************************/
UINT8 Send_ECHOCAN_Cmd(UINT8 PortNo)
{
    UINT16 InCmd;
    M803xx_PORT_STATE *PortPtr;
    UINT16 echo_value;
    UINT8 Return_Flag = SENDTOM803xxOK;

    if(Parameter[PortNo].echoCancell > 0)
        echo_value = 0x8000|(((UINT16)(Parameter[PortNo].echoCancell)/8)-1); /* 8 - 128 ms */
    else
        echo_value = 0x8005;/* 48ms */

    PortPtr = (M803xx_PORT_STATE *)&m_port[PortNo];

    semTake(M803xxQueueSem[PortNo/8], WAIT_FOREVER);
    if (OK == M80320_checkOpenChanQueue(PortNo, 2, FUN_ECHOCAN))
    {
        InCmd = PortPtr->InCmd;

        PortPtr->tx_cmd_fifo[InCmd] = echo_value;
        if( ++InCmd >= MAX_LEN_OF_CMD_FIFO)  InCmd = 0;

        PortPtr->InCmd = InCmd;

        RemainedTxCmdNum[PortNo]++;

        #if SendOpenChannelMsgFirst
        Return_Flag = SendMsgToOpenChannelQueue(CMD_CMDDAT, 0xfd02, 0x0200, FUN_ECHOCAN, PortNo);
        #else
        Return_Flag = QueueTxBoxMsg(CMD_CMDDAT, 0xfd02, 0x0200, FUN_ECHOCAN, PortNo);
        #endif
    }
    semGive(M803xxQueueSem[PortNo/8]);
    return Return_Flag;
}

/*************************************************************************/
/* Function name: Send_RPPH_Cmd                                          */
/* Description  : Send RPPH Command to M803xx                            */
/* Return type  : void                                                   */
/* Argument     : PortNo -- No. of Port Num                              */
/* Author/Date  :                                                        */
/* Note:                                                                 */
/*                                                                       */
/*************************************************************************/
void Send_RPPH_Cmd(UINT8 PortNo)
{
    UINT16 InCmd;
    M803xx_PORT_STATE   *PortPtr;
    UINT8  PinNo, send_ok_flag = 0;

    PortPtr = (M803xx_PORT_STATE *)&m_port[PortNo];
    PinNo = CON_TO_DP[m_port[PortNo].Channel].chip;
    
    semTake(M803xxQueueSem[PortNo/8], WAIT_FOREVER);
    if (OK == M80320_checkOpenChanQueue(PortNo, 0x0a, FUN_RPPH))
    {
        InCmd = PortPtr->InCmd;

        PortPtr->tx_cmd_fifo[InCmd] = (UINT16)(RPPH_value[PinNo].LPWmax<<8) + RPPH_value[PinNo].LPWmin;
        if( ++InCmd >= MAX_LEN_OF_CMD_FIFO)  InCmd = 0;

        PortPtr->tx_cmd_fifo[InCmd] = (UINT16)(RPPH_value[PinNo].LPR<<8) + RPPH_value[PinNo].LPWinitial;
        if( ++InCmd >= MAX_LEN_OF_CMD_FIFO)  InCmd = 0;

        PortPtr->tx_cmd_fifo[InCmd] = RPPH_value[PinNo].HardSoftmode;
        if( ++InCmd >= MAX_LEN_OF_CMD_FIFO)  InCmd = 0;

        PortPtr->tx_cmd_fifo[InCmd] = RPPH_value[PinNo].MAT;
        if( ++InCmd >= MAX_LEN_OF_CMD_FIFO)  InCmd = 0;

        PortPtr->tx_cmd_fifo[InCmd] = RPPH_value[PinNo].DT;
        if( ++InCmd >= MAX_LEN_OF_CMD_FIFO)  InCmd = 0;

        PortPtr->InCmd = InCmd;

        RemainedTxCmdNum[PortNo] += 5;

        #if SendOpenChannelMsgFirst
        send_ok_flag = SendMsgToOpenChannelQueue(CMD_CMDDAT, 0xfd0a, 0x0200, FUN_RPPH, PortNo);
        #else
        QueueTxBoxMsg(CMD_CMDDAT, 0xfd0a, 0x0200, FUN_RPPH, PortNo);
        #endif
    }
    semGive(M803xxQueueSem[PortNo/8]);
}

/*************************************************************************/
/* Function name: Send_FINFOTMR_Cmd                                      */
/* Description  : Send FINFOTMR(T.38 Info Timer) Command to M803xx       */
/* Return type  : void                                                   */
/* Argument     : PortNo -- No. of Port Num                              */
/* Author/Date  :                                                        */
/* Note:                                                                 */
/*                                                                       */
/*************************************************************************/
void Send_FINFOTMR_Cmd(UINT8 PortNo)
{
    UINT16 InCmd;
    M803xx_PORT_STATE *PortPtr;
    UINT8 send_ok_flag = 0;

    PortPtr = (M803xx_PORT_STATE *)&m_port[PortNo];
    
    semTake(M803xxQueueSem[PortNo/8], WAIT_FOREVER);
    if (OK == M80320_checkOpenChanQueue(PortNo, 0x02, FUN_FINFOTMR))
    {
        InCmd = PortPtr->InCmd;

        PortPtr->tx_cmd_fifo[InCmd] = 0X0002;
        if( ++InCmd >= MAX_LEN_OF_CMD_FIFO)  InCmd = 0;

        PortPtr->InCmd = InCmd;

        RemainedTxCmdNum[PortNo] += 1;

        #if SendOpenChannelMsgFirst
        send_ok_flag = SendMsgToOpenChannelQueue(CMD_CMDDAT, 0xfd02, 0x0200, FUN_FINFOTMR, PortNo);
        #else
        QueueTxBoxMsg(CMD_CMDDAT, 0xfd02, 0x0200, FUN_FINFOTMR, PortNo);
        #endif
    }
    semGive(M803xxQueueSem[PortNo/8]);
}

/*************************************************************************/
/* Function name: Send_VINFOTMR_Cmd                                      */
/* Description  : Send VINFOTMR(Voice Info Timer) Command to M803xx       */
/* Return type  : void                                                   */
/* Argument     : PortNo -- No. of Port Num                              */
/* Author/Date  :                                                        */
/* Note:                                                                 */
/*                                                                       */
/*************************************************************************/