freemaster_protocol.c

freescale最新的16位单片机

#if FMSTR_USE_EX_CMDS
        case FMSTR_CMD_GETSTRLEN_EX:
            FMSTR_SetExAddr(1);
#endif
#if FMSTR_USE_NOEX_CMDS
        case FMSTR_CMD_GETSTRLEN:
#endif
            pResponseEnd = FMSTR_GetStringLen(pMessageIO);
            break;

#endif

#if FMSTR_USE_BRIEFINFO
        // retrieve a subset of board information structure
        case FMSTR_CMD_GETINFOBRIEF:
#else   
        // retrieve board information structure
        case FMSTR_CMD_GETINFO: 
#endif
            pResponseEnd = FMSTR_GetBoardInfo(pMessageIO);
            break;

        // unknown command
        default:
            pResponseEnd = FMSTR_ConstToBuffer8(pMessageIO, FMSTR_STC_INVCMD);
            break;          
    }
    
    // anything to send back?
    if(pResponseEnd != pMessageIO)
        FMSTR_SendResponse(pMessageIO, (FMSTR_SIZE8) (pResponseEnd - pMessageIO));
}


/**************************************************************************//*!
*
* @brief    Handling GETINFO or GETINFO_BRIEF
*
* @param    pMessageIO - original command (in) and response buffer (out) 
*
* @return   As all command handlers, the return value should be the buffer 
*           pointer where the response output finished (except checksum)
*
******************************************************************************/

FMSTR_BPTR FMSTR_GetBoardInfo(FMSTR_BPTR pMessageIO)
{
    FMSTR_BPTR pResponse = pMessageIO;
    FMSTR_U16 wTmp;
    char* pStr;

    pResponse = FMSTR_ConstToBuffer8(pResponse, FMSTR_STS_OK);              
    pResponse = FMSTR_ConstToBuffer8(pResponse, FMSTR_PROT_VER);            // protVer
    pResponse = FMSTR_ConstToBuffer8(pResponse, FMSTR_CFG_FLAGS);           // cfgFlags
    pResponse = FMSTR_ConstToBuffer8(pResponse, FMSTR_CFG_BUS_WIDTH);       // dataBusWdt
    pResponse = FMSTR_ConstToBuffer8(pResponse, FMSTR_GLOB_VERSION_MAJOR);  // globVerMajor
    pResponse = FMSTR_ConstToBuffer8(pResponse, FMSTR_GLOB_VERSION_MINOR);  // globVerMinor
    pResponse = FMSTR_ConstToBuffer8(pResponse, FMSTR_COMM_BUFFER_SIZE);    // cmdBuffSize 
    
    // that is all for brief info
#if !FMSTR_USE_BRIEFINFO

#if FMSTR_USE_RECORDER

    // recorder buffer size is always mesured in bytes
    wTmp = FMSTR_GetRecBuffSize();
    wTmp *= FMSTR_CFG_BUS_WIDTH;

    // send size and timebase   
    pResponse = FMSTR_ValueToBuffer16(pResponse, wTmp);
    pResponse = FMSTR_ConstToBuffer16(pResponse, FMSTR_REC_TIMEBASE);
#else

    // recorder info zeroed
    pResponse = FMSTR_ConstToBuffer16(pResponse, 0);
    pResponse = FMSTR_ConstToBuffer16(pResponse, 0);
#endif

    // description string
    pStr = FMSTR_IDT_STRING;
    for(wTmp = 0; wTmp < FMSTR_DESCR_SIZE; wTmp++)
    {
        pResponse = FMSTR_ValueToBuffer8(pResponse, *pStr);
        
        if(*pStr)
            pStr ++;
    }
#endif

    return pResponse;   
}

/**************************************************************************//*!
*
* @brief    Handling READMEM and READMEM_EX commands
*
* @param    pMessageIO - original command (in) and response buffer (out) 
*
* @return   As all command handlers, the return value should be the buffer 
*           pointer where the response output finished (except checksum)
*
******************************************************************************/

FMSTR_BPTR FMSTR_ReadMem(FMSTR_BPTR pMessageIO)
{
    FMSTR_BPTR pResponse = pMessageIO;
    FMSTR_ADDR nAddr;
    FMSTR_U8 nSize;

    pMessageIO = FMSTR_SkipInBuffer(pMessageIO, 2);
    pMessageIO = FMSTR_ValueFromBuffer8(&nSize, pMessageIO);
    pMessageIO = FMSTR_AddressFromBuffer(&nAddr, pMessageIO);

#if FMSTR_USE_TSA && FMSTR_USE_TSA_SAFETY
    if(!FMSTR_CheckTsaSpace(nAddr, nSize, 0))
        return FMSTR_ConstToBuffer8(pResponse, FMSTR_STC_EACCESS);
#endif

    // check the response will safely fit into comm buffer
    if(nSize > FMSTR_COMM_BUFFER_SIZE)
        return FMSTR_ConstToBuffer8(pResponse, FMSTR_STC_RSPBUFFOVF);
 
    // success 
    pResponse = FMSTR_ConstToBuffer8(pResponse, FMSTR_STS_OK);
    return FMSTR_CopyToBuffer(pResponse, nAddr, nSize);
}   

/**************************************************************************//*!
*
* @brief    Handling READVAR and READVAR_EX commands (for all sizes 1,2,4)
*
* @param    pMessageIO - original command (in) and response buffer (out) 
*
* @return   As all command handlers, the return value should be the buffer 
*           pointer where the response output finished (except checksum)
*
******************************************************************************/

FMSTR_BPTR FMSTR_ReadVar(FMSTR_BPTR pMessageIO, FMSTR_SIZE8 nSize)
{
    FMSTR_BPTR pResponse = pMessageIO;
    FMSTR_ADDR nAddr;

    pMessageIO = FMSTR_SkipInBuffer(pMessageIO, 1);
    pMessageIO = FMSTR_AddressFromBuffer(&nAddr, pMessageIO);

#if FMSTR_USE_TSA && FMSTR_USE_TSA_SAFETY
    if(!FMSTR_CheckTsaSpace(nAddr, nSize, 0))
        return FMSTR_ConstToBuffer8(pResponse, FMSTR_STC_EACCESS);
#endif

    // success 
    pResponse = FMSTR_ConstToBuffer8(pResponse, FMSTR_STS_OK);
    return FMSTR_CopyToBuffer(pResponse, nAddr, nSize);
}   

/**************************************************************************//*!
*
* @brief    Handling WRITEMEM and WRITEMEM_EX commands
*
* @param    pMessageIO - original command (in) and response buffer (out) 
*
* @return   As all command handlers, the return value should be the buffer 
*           pointer where the response output finished (except checksum)
*
******************************************************************************/

FMSTR_BPTR FMSTR_WriteMem(FMSTR_BPTR pMessageIO)
{
    FMSTR_BPTR pResponse = pMessageIO;
    FMSTR_ADDR nAddr;
    FMSTR_U8 nSize;

    pMessageIO = FMSTR_SkipInBuffer(pMessageIO, 2);
    pMessageIO = FMSTR_ValueFromBuffer8(&nSize, pMessageIO);
    pMessageIO = FMSTR_AddressFromBuffer(&nAddr, pMessageIO);

#if FMSTR_USE_TSA && FMSTR_USE_TSA_SAFETY
    if(!FMSTR_CheckTsaSpace(nAddr, nSize, 1))
        return FMSTR_ConstToBuffer8(pResponse, FMSTR_STC_EACCESS);
#endif

    FMSTR_CopyFromBuffer(nAddr, pMessageIO, nSize);
    
    return FMSTR_ConstToBuffer8(pResponse, FMSTR_STS_OK);
}

/**************************************************************************//*!
*
* @brief    Handling WRITEVAR command
*
* @param    pMessageIO - original command (in) and response buffer (out) 
* @param    nSize - variable size
*
* @return   As all command handlers, the return value should be the buffer 
*           pointer where the response output finished (except checksum)
*
******************************************************************************/

FMSTR_BPTR FMSTR_WriteVar(FMSTR_BPTR pMessageIO, FMSTR_SIZE8 nSize)
{
    FMSTR_BPTR pResponse = pMessageIO;
    FMSTR_ADDR nAddr;

    pMessageIO = FMSTR_SkipInBuffer(pMessageIO, 1);
    pMessageIO = FMSTR_AddressFromBuffer(&nAddr, pMessageIO);

#if FMSTR_USE_TSA && FMSTR_USE_TSA_SAFETY
    if(!FMSTR_CheckTsaSpace(nAddr, nSize, 1))
        return FMSTR_ConstToBuffer8(pResponse, FMSTR_STC_EACCESS);
#endif

    FMSTR_CopyFromBuffer(nAddr, pMessageIO, nSize);
    
    return FMSTR_ConstToBuffer8(pResponse, FMSTR_STS_OK);
}


/**************************************************************************//*!
*
* @brief    Handling WRITEMEMMASK and WRITEMEMMASK_EX commands
*
* @param    pMessageIO - original command (in) and response buffer (out) 
*
* @return   As all command handlers, the return value should be the buffer 
*           pointer where the response output finished (except checksum)
*
******************************************************************************/

FMSTR_BPTR FMSTR_WriteMemMask(FMSTR_BPTR pMessageIO)
{
    FMSTR_BPTR pResponse = pMessageIO;
    FMSTR_ADDR nAddr;
    FMSTR_U8 nSize;

    pMessageIO = FMSTR_SkipInBuffer(pMessageIO, 2);
    pMessageIO = FMSTR_ValueFromBuffer8(&nSize, pMessageIO);
    pMessageIO = FMSTR_AddressFromBuffer(&nAddr, pMessageIO);

#if FMSTR_USE_TSA && FMSTR_USE_TSA_SAFETY
    if(!FMSTR_CheckTsaSpace(nAddr, nSize, 1))
        return FMSTR_ConstToBuffer8(pResponse, FMSTR_STC_EACCESS);
#endif

#if FMSTR_CFG_BUS_WIDTH > 1
    // size must be divisible by bus width (mask must not begin in half of memory word)
    if(nSize % FMSTR_CFG_BUS_WIDTH)
        return FMSTR_ConstToBuffer8(pResponse, FMSTR_STC_INVSIZE);
#endif

    // put the data
    FMSTR_CopyFromBufferWithMask(nAddr, pMessageIO, nSize);         
    
    return FMSTR_ConstToBuffer8(pResponse, FMSTR_STS_OK);
}

/**************************************************************************//*!
*
* @brief    Handling WRITEVARMASK command
*
* @param    pMessageIO - original command (in) and response buffer (out) 
* @param    nSize - variable size
*
* @return   As all command handlers, the return value should be the buffer 
*           pointer where the response output finished (except checksum)
*
******************************************************************************/

FMSTR_BPTR FMSTR_WriteVarMask(FMSTR_BPTR pMessageIO, FMSTR_SIZE8 nSize)
{
    FMSTR_BPTR pResponse = pMessageIO;
    FMSTR_ADDR nAddr;
    
    pMessageIO = FMSTR_SkipInBuffer(pMessageIO, 1);
    pMessageIO = FMSTR_AddressFromBuffer(&nAddr, pMessageIO);

#if FMSTR_USE_TSA && FMSTR_USE_TSA_SAFETY
    if(!FMSTR_CheckTsaSpace(nAddr, nSize, 1))
        return FMSTR_ConstToBuffer8(pResponse, FMSTR_STC_EACCESS);
#endif

    // put the data
    FMSTR_CopyFromBufferWithMask(nAddr, pMessageIO, nSize);         
    
    return FMSTR_ConstToBuffer8(pResponse, FMSTR_STS_OK);
}