tclcmd.c

vt6528芯片交换机API函数和文档运行程序

            return FALSE;   
        }
    }
    return TRUE;
}

/************************************************************************
 * Parsing each argument into aszArgus array
 ************************************************************************/
static void 
s_vParseArgus(char* pszCmdBuf, char aszArgus[][ARGU_SIZE])
{
    char *      pszCmd;
    UINT32      u32Argc;
    UINT32      uu;
    
    u32Argc = 0;
    pszCmd  = pszCmdBuf;
    STR_pvMemset(aszArgus, 0, (ARGU_CNT * ARGU_SIZE));
    
    while (*pszCmd != 0)
    {
        
        /*
         * Skip Space, Tab
         */
        while (((*pszCmd == ' ') || (*pszCmd == '\t')) &&
               (*pszCmd != 0)) 
        {
            pszCmd++; 
        }
        
        uu = 0;
        /*
         * Copy pszCmd to aszArgus
         */
        while ((*pszCmd != ' ') && (*pszCmd != '\t') && (*pszCmd != '\0'))
        {
            aszArgus[u32Argc][uu] = *pszCmd;
            pszCmd++;
            uu++;
        }
        aszArgus[u32Argc][uu] = 0;
        u32Argc++;
    }
} /* end s_vParseArgus */


// TCL command engine
void TCLCMD_vEngine(void)
{
    char   aszCmdBuf[MAX_BUF_SIZE];
    char   aszArgus[ARGU_CNT][ARGU_SIZE];
    BOOL   bCmdFound = FALSE;
    UINT8  uu;


    while (1) {
#ifdef __TEST_API
        TTY_vGetStr(aszCmdBuf, MAX_BUF_SIZE, 0);
#else
        TTY_vGetStr(aszCmdBuf, MAX_BUF_SIZE, 2);
#endif

#ifdef __TCL_UART1
        if (!aszCmdBuf[0]) //means empty
            return;
#endif

        s_vParseArgus(aszCmdBuf, aszArgus);
        
        // quit TCL command engine
        if (0 == STR_iStrcmp(aszArgus[0], "quit"))
            break;

        // Search command table
        for (uu = 0; s_aSCmdTbl[uu].szCmd; uu++) {
            if (0 == STR_iStrcmp(aszArgus[0], s_aSCmdTbl[uu].szCmd)) {
                s_aSCmdTbl[uu].pfnCmd(aszArgus);
                bCmdFound = TRUE;
                break;
            }
        }

        // command not recognized
        if (!bCmdFound)
            TTY_vPutStr("fail: command not found.\r");
#ifdef __TCL_UART1
#else
        else
            bCmdFound = FALSE;
#endif
    }
}


/************************************************************************
 * Version Command
 *  Argv[0] =   "ver" command
 * Return:
 *  XXXX(AnalyzerVer)  XXXX(SWAPI)
 * Eg.  Analyzer 1.25, SWAPI 1.13
 *      0124 0112
 ************************************************************************/
static void 
s_vVerGet (char aszArgus[][ARGU_SIZE])
{
#if 0    
    char        aszOutBuf[MAX_BUF_SIZE];
    PRNT_iSprintf(aszOutBuf, "%02u%02u %02u%02u\r",
            ANALYZER_VER_MAJOR, ANALYZER_VER_MINOR,
            SWAPI_VER_MAJOR, SWAPI_VER_MINOR);
    TTY_vPutStr(aszOutBuf);
#endif    
    
} /* end s_VerGet */

// register read/write command.
// first param  :  read/write
// second param :  address
// third param  :  byte count
// fourth param :  (write) value
static void s_vRegOp (char aszArgus[][ARGU_SIZE])
{
    char   aszOutBuf[MAX_BUF_SIZE];
    char   *pszOp, *pszValue;
    UINT8  uu, u8ByteCnt, u8Data;
    UINT16 u16Addr = 0;

    
    // check arguments
    if (!s_bCheckArgus(&aszArgus[1], 3)) {
        return;
    }    

    pszOp     = aszArgus[1];
    u16Addr   = STR_u32StrHexToU32(aszArgus[2]);
    u8ByteCnt = STR_u32StrDecToU32(aszArgus[3]);
    pszValue  = aszArgus[4];

    // reg. read
    if (0 == STR_iStrcmp("read", pszOp)) {
        for (uu = 0; uu < u8ByteCnt; uu++) {
            SWREG_vReadU8(u16Addr + uu, &u8Data);
            STR_iU32ToStrHexPad(aszOutBuf + (uu * 2), u8Data, 2);
        }
        
        TTY_vPutStr(STR_pszStrcatchr(aszOutBuf, '\r'));
    }
    // reg. write
    else if (0 == STR_iStrcmp("write", pszOp)) {        
        if (NULL == pszValue) {
            TTY_vPutStr("fail: params error.\r");
            return;
        }

        STR_pvMemset(aszOutBuf, 0, 3);
        for (uu = 0; ((uu < u8ByteCnt) && (*pszValue != 0)); uu++) {
            STR_pvMemcpy(aszOutBuf, pszValue, 2);
            u8Data = (UINT8) STR_u32StrHexToU32(aszOutBuf);
            SWREG_vWriteU8(u16Addr + uu, u8Data);
            pszValue += 2;
        }
        
        TTY_vPutStr("success.\r");
    }
}


// phy. read/write command.
// first param  :  read/write
// second param :  phy address
// third param  :  phy id
// four param   :  (write) value
static void s_vPhyOp (char aszArgus[][ARGU_SIZE])
{
    char   aszOutBuf[MAX_BUF_SIZE];
    char   *pszOp, *pszValue;
    UINT8  u8PortId = 0, u8Addr = 0;
    UINT16 u16Data = 0;


    // check arguments
    if (!s_bCheckArgus(&aszArgus[1], 3)) {
        return;
    }    

    pszOp    = aszArgus[1];
    u8Addr   = STR_u32StrHexToU32(aszArgus[2]);
    u8PortId = STR_u32StrHexToU32(aszArgus[3]);
    pszValue = aszArgus[4];

    // phy. read
    if (0 == STR_iStrcmp("read", pszOp)) {
        SWMII_bReadU16(u8PortId, u8Addr, &u16Data);
        STR_iU32ToStrHexPad(aszOutBuf, u16Data, 4);
        
        TTY_vPutStr(STR_pszStrcatchr(aszOutBuf, '\r'));
    }
    // phy. write
    else if (0 == STR_iStrcmp("write", pszOp)) {
        if (NULL == pszValue) {
            TTY_vPutStr("fail: params error.\r");
            return;
        }
        u16Data = STR_u32StrHexToU32(pszValue);
        SWMII_bWriteU16(u8PortId, u8Addr, u16Data);
        
        TTY_vPutStr("success.\r");
    }
}


// sram read/write command.
// first param  :  read/write
// second param :  address
// third parm   : (write) value
static void s_vSramOp (char aszArgus[][ARGU_SIZE])
{
    char    aszOutBuf[MAX_BUF_SIZE];
    char    *pszOp, *pszValue, *pszBuf = aszOutBuf;
    UINT8   au8Data[16], uu;
    UINT32  u32Addr;


    // check arguments
    if (!s_bCheckArgus(&aszArgus[1], 2)) {
        return;
    }    

    pszOp    = aszArgus[1];
    u32Addr  = STR_u32StrHexToU32(aszArgus[2]);
    pszValue = aszArgus[3];

    STR_pvMemset(aszOutBuf, 0, MAX_BUF_SIZE);
    // sram read
    if (0 == STR_iStrcmp("read", pszOp)) {
        SWSRAM_bReadEntry(u32Addr, au8Data);                
        for (uu = 0; uu < 16; uu++)
            pszBuf += STR_iU32ToStrHexPad(pszBuf, au8Data[uu], 2);
                                
        TTY_vPutStr(STR_pszStrcatchr(aszOutBuf, '\r'));
    }
    // sram write
    else if (0 == STR_iStrcmp("write", pszOp)) {
        if (NULL == pszValue) {
            TTY_vPutStr("fail: params error.\r");
            return;
        }
        
        STR_pvMemset(au8Data, 0, 16);
        for (uu = 0; uu < 16; uu++) {
            STR_pvMemcpy(aszOutBuf, pszValue, 2);
            au8Data[uu] = STR_u32StrHexToU32(aszOutBuf);
            pszValue += 2;
        }
        SWSRAM_bWriteEntry(u32Addr, au8Data);

        TTY_vPutStr("success.\r");
    }
}


// mac adress change log table command.
// 1st param    :  read
// 2nd param    :  entry index
static void s_vLogTb (char aszArgus[][ARGU_SIZE])
{
    char       aszOutBuf[MAX_BUF_SIZE];
    char       *pszOp, *pszBuf = aszOutBuf;
    UINT32     u32EntryAddr;
    SLogEntry  SEntry;
    char       szMacStr[20];


    // check arguments
    if (!s_bCheckArgus(&aszArgus[1], 2)) {
        return;
    }    
    
    pszOp = aszArgus[1];
    u32EntryAddr = SRAM_MAC_LOG_TBL_BASE_ADDR + STR_u32StrHexToU32(aszArgus[2])*0x10;

    if (0 == STR_iStrcmp("read", pszOp)) {
        //TTY_vPutStr("0,00CD,01,0,0,0,0,000E,000F,1122334455FF,0\r");
        SWLOGTB_bGetEntryByIndx(MACLOG_SA_TO_INDEX(u32EntryAddr), &SEntry);
        pszBuf += STR_iU32ToStrDec(pszBuf, SEntry.bTypeMcst); APPEND_SPACE(pszBuf);        // bit 114
        if (FALSE == SEntry.bTypeMcst) { // unicast                                                    
            pszBuf += STR_iU32ToStrDec(pszBuf, SEntry.bFltrSmac);                      // bit 113
            pszBuf += STR_iU32ToStrDec(pszBuf, SEntry.bNotRedirSmac);                  // bit 112
            pszBuf += STR_iU32ToStrDec(pszBuf, SEntry.bTrkGrp); APPEND_SPACE(pszBuf);  // bit 109     
            
            pszBuf += STR_iU32ToStrDec(pszBuf, SEntry.u8SrcId);                        // bit 108~104
        }
        else { // multicast
            pszBuf += STR_iU32ToStrHexPad(pszBuf, SEntry.u16McstIdx, 4);               // bit 113~104
        }
        APPEND_SPACE(pszBuf);                                                                   
        
        pszBuf += STR_iU32ToStrHexPad(pszBuf, SEntry.u8SecuVio, 2); APPEND_SPACE(pszBuf); // bit 103~96
        pszBuf += STR_iU32ToStrDec(pszBuf, SEntry.bLearning);       APPEND_SPACE(pszBuf); // bit 103~96
        pszBuf += STR_iU32ToStrDec(pszBuf, SEntry.u8Scan);          APPEND_SPACE(pszBuf); // bit 103~96
        pszBuf += STR_iU32ToStrDec(pszBuf, SEntry.bAgeOut);         APPEND_SPACE(pszBuf); // bit 103~96
        pszBuf += STR_iU32ToStrDec(pszBuf, SEntry.bLocChg);         APPEND_SPACE(pszBuf); // bit 103~96
                                            
        pszBuf += STR_iU32ToStrHexPad(pszBuf, SEntry.u16ExtraEntryId, 4); APPEND_SPACE(pszBuf); // bit 95~80
        pszBuf += STR_iU32ToStrHexPad(pszBuf, SEntry.u16EntryId, 4);      APPEND_SPACE(pszBuf); // bit 79~64
        s_vCvtMacValtoStr (szMacStr, (char*)SEntry.abyMacAddr);
        pszBuf += STR_iStrcpy(pszBuf, szMacStr);                APPEND_SPACE(pszBuf);   // bit 63~16
        pszBuf += STR_iU32ToStrDec(pszBuf, SEntry.u16Fid);                                      // bit 12~0

        TTY_vPutStr(STR_pszStrcatchr(aszOutBuf, '\r'));
    }
}


// primary mac table command.
// 1st param            : read/write/del
// 2nd param            : mac address     (hex)
// 3rd param            : fid             (hex, Bit[12:0])
// 4th param  (write)   : static          (dec, Bit[27])
// 5th param  (write)   : cast type       (dec, Bit[26])
// 6th param  (write)   : port index      (hex, Bit[25:16])
// 7th param  (write)   : option          (hex, Bit[15:13])
// 8th param  (write)   : overwrite       (hex, 1:overwrite entry if exist; 0:don't overwrite entry)
static void s_vPMacTb (char aszArgus[][ARGU_SIZE])
{
    char       aszOutBuf[MAX_BUF_SIZE], szMacStr[20];
    char       *pszOp, *pszMac, *pszBuf = aszOutBuf;
    UINT8      au8MacAddr[MAC_ADDR_SIZE];