m803xxvoip.c

m80320 VoIP DSP驱动源码

void Send_VINFOTMR_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_VINFOTMR))
    {
        InCmd = PortPtr->InCmd;
        PortPtr->tx_cmd_fifo[InCmd] = 0X0005;
        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_VINFOTMR, PortNo);
        #else
        QueueTxBoxMsg(CMD_CMDDAT, 0xfd02, 0x0200, FUN_VINFOTMR, PortNo);
        #endif
    }
    semGive(M803xxQueueSem[PortNo/8]);
}

/*************************************************************************/
/* Function name: Send_DTMF_Cmd                                          */
/* Description  : Send DTMF Command to M803xx                            */
/* Return type  : void                                                   */
/* Argument     : PortNo -- No. of Port Num                              */
/* Author/Date  :                                                        */
/* Note:                                                                 */
/*                                                                       */
/*************************************************************************/
void Send_DTMF_Cmd(UINT8 PortNo, UINT16 Dtmf_Detect_Mode)
{
    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_DTMFOPT))
    {
        InCmd = PortPtr->InCmd;
        PortPtr->tx_cmd_fifo[InCmd] = Dtmf_Detect_Mode;
        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_DTMFOPT, PortNo);
        #else
        QueueTxBoxMsg(CMD_CMDDAT, 0xfd02, 0x0200, FUN_DTMFOPT, PortNo);
        #endif

    }
    semGive(M803xxQueueSem[PortNo/8]);
}

/*************************************************************************/
/* Function name: Enable_RTP_Encapsulation                               */
/* Description  : Enable RTP Encapsulation                               */
/* Return type  : void                                                   */
/* Argument     : PortNo -- No. of Port Num                              */
/* Author/Date  :                                                        */
/* Note:                                                                 */
/*                                                                       */
/*************************************************************************/
void Enable_RTP_Encapsulation(UINT8 PortNo)
{
    UINT16 InCmd;
    M803xx_PORT_STATE *PortPtr;
    UINT32 SSRC;
    UINT8 send_ok_flag = 0;

    InitRtpSessionValue(PortNo);

    SSRC = (UINT32)(((UINT32)(rand()))<<16) + (UINT32)rand();
    RtpValue[PortNo].Sender_SSRC = SSRC;
    RtpValue[PortNo].Rcvr_SSRC   = SSRC;
    RTCPInfo[PortNo].RTPSSRC     = SSRC;

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

    if (PortPtr->tx_data_requested != 1)
    {
        printf("Port %d OpenChannel tx_data_requested = %d\n", PortNo, PortPtr->tx_data_requested);
#if 0
    PortPtr->tx_data_requested = 1;
#endif
    }
    semTake(M803xxQueueSem[PortNo/8], WAIT_FOREVER);
    if (OK == M80320_checkOpenChanQueue(PortNo, 0x0e, FUN_VOPENA))
    {
        InCmd = PortPtr->InCmd;
        PortPtr->tx_cmd_fifo[InCmd] = 0x0001;
        if( ++InCmd >= MAX_LEN_OF_CMD_FIFO)  InCmd = 0;

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

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

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

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

        PortPtr->tx_cmd_fifo[InCmd] = (UINT16)((SSRC>>16)&0xffff);
        if( ++InCmd >= MAX_LEN_OF_CMD_FIFO)  InCmd = 0;

        PortPtr->tx_cmd_fifo[InCmd] = (UINT16)(SSRC&0xffff);
        if( ++InCmd >= MAX_LEN_OF_CMD_FIFO)  InCmd = 0;
        /* end of modification */

        PortPtr->InCmd = InCmd;

        RemainedTxCmdNum[PortNo] += 7;

        PortPtr->ExpectServiceType = Voice; /* Voice mode */
        PortPtr->Active = BUSY; /* channel busy */
        PortPtr->ExpectActiveStatus = LFXS_UP;
        PortPtr->ReOpenNum++;

        #if SendOpenChannelMsgFirst
        send_ok_flag = SendMsgToOpenChannelQueue(CMD_CMDDAT, 0xfe0e, 0x0200, FUN_VOPENA, PortNo);
        #else
        QueueTxBoxMsg(CMD_CMDDAT, 0xfe0e, 0x0200, FUN_VOPENA, PortNo);
        #endif

    }
    semGive(M803xxQueueSem[PortNo/8]);

#if 0
    ChannelOperateCount[PortNo].SelfEnablechannelCount++;
#endif
}

/*************************************************************************/
/* Function name: Enable_UDPTL_Encapsulation                             */
/* Description  : Enable UDPTL Encapsulation, also is opening fax channel*/
/* Return type  : void                                                   */
/* Argument     : PortNo -- No. of Port Num                              */
/* Author/Date  :                                                        */
/* Note:                                                                 */
/*                                                                       */
/*************************************************************************/
void Enable_UDPTL_Encapsulation(UINT8 PortNo)
{
    UINT16 InCmd;
    M803xx_PORT_STATE *PortPtr;
    UINT8 send_ok_flag = 0;

    InitFaxSessionValue(PortNo);

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

    /* change the channel to fax handling status */
    semTake(M803xxQueueSem[PortNo/8], WAIT_FOREVER);
    if (OK == M80320_checkOpenChanQueue(PortNo, 0x02, FUN_VOPENA))
    {
        InCmd = PortPtr->InCmd;
        PortPtr->tx_cmd_fifo[InCmd] = 0x0002; /* UDPTL Encapsulation */
        if( ++InCmd >= MAX_LEN_OF_CMD_FIFO)  InCmd = 0;
    
        PortPtr->InCmd = InCmd;
    
        RemainedTxCmdNum[PortNo] += 1;
    
        PortPtr->ExpectServiceType = Fax;  /* fax mode */
        PortPtr->Active = BUSY; /* channel busy */
        PortPtr->ExpectActiveStatus = LFXS_UP;
        PortPtr->ReOpenNum++;
        
        #if SendOpenChannelMsgFirst
        send_ok_flag = SendMsgToOpenChannelQueue(CMD_CMDDAT, 0xfd02, 0x0200, FUN_VOPENA, PortNo);
        #else
        QueueTxBoxMsg(CMD_CMDDAT, 0xfd02, 0x0200, FUN_VOPENA, PortNo);
        #endif
    }
    semGive(M803xxQueueSem[PortNo/8]);
}

UINT16 Packet2PcmGain = 0xffc4; /* default value is -6 db */
UINT16 Pcm2PacketGain = 0x0; /* default value is 0 db */
/*************************************************************************/
/* Function name: Send_DGAIN_Cmd                                         */
/* Description  : Send DGAIN Command to M803xx                           */
/* Return type  : void                                                   */
/* Argument     : PortNo -- No. Of Port Num                              */
/*                Value  -- Gain Value                                   */
/*                Flag   -- 0:In、1:Out、2:All                           */
/* Author/Date  : Cao WanMing/2003-1-26                                  */
/* Note:                                                                 */
/*                                                                       */
/*************************************************************************/
UINT8 Send_DGAIN_Cmd(UINT8 PortNo, UINT16 Value, UINT8 Flag)
{
    UINT16 InCmd;
    M803xx_PORT_STATE *PortPtr;
    UINT8 Return_Flag = SENDTOM803xxOK;

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

    semTake(M803xxQueueSem[PortNo/8], WAIT_FOREVER);
    if (OK == M80320_checkOpenChanQueue(PortNo, 0x04, FUN_DGAIN))
    {
        if(Flag == 0)
        {
            Parameter[PortNo].InGainValue = Value;
        }
        else
        {
            if(Flag == 1)
                Parameter[PortNo].OutAttenuationValue = Value;
        }
        InCmd = PortPtr->InCmd;
        PortPtr->tx_cmd_fifo[InCmd] = (UINT16)(Parameter[PortNo].OutAttenuationValue);
        if( ++InCmd >= MAX_LEN_OF_CMD_FIFO)  InCmd = 0;
        PortPtr->tx_cmd_fifo[InCmd] = (UINT16)(Parameter[PortNo].InGainValue);
        if( ++InCmd >= MAX_LEN_OF_CMD_FIFO)  InCmd = 0;

        PortPtr->InCmd = InCmd;

        RemainedTxCmdNum[PortNo] += 2;

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

/*************************************************************************/
/* Function name: Send_SSRCFILT_Cmd                                      */
/* Description  : Send SSRCFILT(SSRC Filter) Command to M803xx           */
/* Return type  : void                                                   */
/* Argument     : PortNo -- No. Of Port Num                              */
/*                Value  -- SSRC Value                                   */
/* Author/Date  :                                                        */
/* Note:                                                                 */
/*                                                                       */
/*************************************************************************/
UINT8 Send_SSRCFILT_Cmd(UINT8 PortNo, UINT32 Value)
{
    UINT16 InCmd;
    M803xx_PORT_STATE *PortPtr;
    UINT8 Return_Flag = SENDTOM803xxOK;

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

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

        PortPtr->tx_cmd_fifo[InCmd] = (UINT16)(Value&0xffff);
        if( ++InCmd >= MAX_LEN_OF_CMD_FIFO)  InCmd = 0;

        PortPtr->tx_cmd_fifo[InCmd] = (UINT16)((Value>>16)&0xffff);
        if( ++InCmd >= MAX_LEN_OF_CMD_FIFO)  InCmd = 0;
        
        PortPtr->InCmd = InCmd;

        RemainedTxCmdNum[PortNo] += 2;

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

/*************************************************************************/
/* Function name: Send_SSRCCHG_Cmd                                       */
/* Description  : Send SSRCCHG(SSRC Change) Command to host              */
/* Return type  : void                                                   */
/* Argument     : PortNo -- No. Of Port Num                              */
/*                Value  -- SSRC Value                                   */
/* Author/Date  :                                                        */
/* Note:                                                                 */
/*                                                                       */
/*************************************************************************/
UINT8 Send_SSRCCHG_Cmd(UINT8 PortNo)
{
   /* M803xx_PORT_STATE *PortPtr;*/
    UINT8 Return_Flag = SENDTOM803xxOK;

    /*PortPtr = (M803xx_PORT_STATE *)&m_port[PortNo];*/
    semTake(M803xxQueueSem[PortNo/8], WAIT_FOREVER);
    #if SendOpenChannelMsgFirst
        if (OK == M80320_checkOpenChanQueue(PortNo, 0x0, FUN_SSRCCHG))
            Return_Flag = SendMsgToOpenChannelQueue(CMD_CMDDAT, 0xfd00, 0x0200, FUN_SSRCCHG, PortNo);
    #else
        Return_Flag = QueueTxBoxMsg(CMD_CMDDAT, 0xfd00, 0x0200, FUN_SSRCCHG, PortNo);
    #endif
    semGive(M803xxQueueSem[PortNo/8]);
    
    return Return_Flag;
}

UINT16 Select_Dtmf_Detect_Mode(UINT8 PortNo)
{
    UINT16 Dtmf_Detect_mode;

    switch(Parameter[PortNo].DTMFSendMode)
    {
        case 0: /* not to detect dtmf */
        case 2: /* out of band transfer */
            Dtmf_Detect_mode = DTMF_OUT_BAND_TRANSFER;
            break;

        case 1: /* in band transfer */
            Dtmf_Detect_mode = DTMF_IN_BAND_TRANSFER;
            break;

        default:
            Dtmf_Detect_mode = DTMF_IN_BAND_TRANSFER;
            break;
    }
    return Dtmf_Detect_mode;
}

void Set_PTMNG_Cmd(UINT8 PortNo)
{
    UINT16   InCmd;
    M803xx_PORT_STATE     *PortPtr;
     /*UINT16  Codec_Type[3], i;*/
    UINT8  /*name,*/ send_ok_flag = 0;

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