tmboard.c

用于TM1300/PNX1300系列DSP（主要用于视频处理）的设备库的源码

extern tmLibdevErr_t tsaBoardRegisterHDVO(UInt32 unitNumber, boardHDVOConfig_t *HDVOConfig)
{
    return registerInterface(HDVO_REG_PATH, unitNumber, HDVOConfig);
}

extern tmLibdevErr_t tsaBoardRegisterMP(UInt32 unitNumber, boardMPConfig_t *mpConfig)
{
  return registerInterface(MP_REG_PATH, unitNumber, mpConfig);
}

extern tmLibdevErr_t tsaBoardRegisterGPIO(UInt32 unitNumber, boardGPIOConfig_t *GPIOConfig)
{
    return registerInterface(GPIO_REG_PATH, unitNumber, GPIOConfig);
}

extern tmLibdevErr_t tsaBoardRegisterFlash(UInt32 unitNumber, boardFlashConfig_t *flashConfig)
{
    return registerInterface(FLASH_REG_PATH, unitNumber, flashConfig);
}

extern tmLibdevErr_t tsaBoardRegisterPIC(UInt32 unitNumber, boardPICConfig_t *picConfig)
{
    return registerInterface(PIC_REG_PATH, unitNumber, picConfig);
}

extern tmLibdevErr_t tsaBoardRegisterIR(UInt32 unitNumber, boardIRConfig_t *irConfig)
{
    return registerInterface(IR_REG_PATH, unitNumber, irConfig);
}

extern tmLibdevErr_t tsaBoardRegisterUart(UInt32 unitNumber, boardUartConfig_t *uartConfig)
{
    return registerInterface(UART_REG_PATH, unitNumber, uartConfig);
}
extern tmLibdevErr_t tsaBoardRegisterTvTuner(UInt32 unitNumber, boardTvTunerConfig_t *tunerConfig)
{
    return registerInterface(TVTUNER_REG_PATH, unitNumber, tunerConfig);
}

extern tmLibdevErr_t tsaBoardRegisterP1394(UInt32 unitNumber, boardP1394Config_t *p1394Config)
{
   if (p1394Config->intNumber == 0)
	return	TMLIBDEV_ERR_NULL_PARAMETER;
   if (p1394Config->avBase == 0)
	return  TMLIBDEV_ERR_NULL_PARAMETER;

   return registerInterface (P1394_REG_PATH, unitNumber, p1394Config);
}

extern tmLibdevErr_t tsaBoardRegisterTvDigDem(UInt32 unitNumber, boardTvDigDemConfig_t *digDemConfig)
{
    return registerInterface(TVDIGDEM_REG_PATH, unitNumber, digDemConfig);
}

extern tmLibdevErr_t tsaBoardRegisterTvAudDem(UInt32 unitNumber, boardTvAudDemConfig_t *audDemConfig)
{
    return registerInterface(TVAUDDEM_REG_PATH, unitNumber, audDemConfig);
}


/* Get functions */

static tmLibdevErr_t getInterface(Char *path, UInt32 unitNumber, Pointer *config)
{
    Char tmpBuff[MAX_REG_PATH_LENGTH +      /* the path : bsp/device     */
                MAX_REG_UNIT_LENGTH +       /* the unit number : 1 .. 99 */
                1 +                     /* the '/' path delimiter    */
                sizeof(DEVICE_REG_DEFAULT_NAME)];  /* the name of the key       */
    tsaRegEntryClass_t entryType;
    ptsaRegDataEntry_t entry;
    tmLibdevErr_t err;
    
    if (unitNumber > MAX_REG_UNIT_NUMBER)
        return TSA_BOARD_ERR_INVALID_UNIT_NUMBER;
    if (config == Null)
        return TMLIBDEV_ERR_NULL_PARAMETER;

    sprintf(tmpBuff, "%s%.*d/%s", path, MAX_REG_UNIT_LENGTH, 
            unitNumber, DEVICE_REG_DEFAULT_NAME);

    err = tsaRegQuery(tmpBuff, &entryType, (Pointer *)&entry);
    if (err != TMLIBDEV_OK)
        return TSA_BOARD_ERR_INVALID_UNIT_NUMBER;
    *config = ((Pointer *)entry->data)[0];
    return TMLIBDEV_OK;
}

extern tmLibdevErr_t tsaBoardGetBoard(UInt32 *pID, Char **pboardName)
{
    Char tmpBuff[sizeof(BOARD_REG_PATH) +     /* the path */
                sizeof(BOARD_NAME_REG_NAME) + /* this is the max of BOARD_ID
                                                 and BOARD_NAME */
                1];                           /* the / separator */
    tsaRegEntryClass_t entryType;
    ptsaRegDataEntry_t entry;
    tmLibdevErr_t err;

    tmAssert(pID, TMLIBDEV_ERR_NULL_PARAMETER);
    if (pID ==Null)
        return TMLIBDEV_ERR_NULL_PARAMETER;

    /* the Board Name */
    sprintf(tmpBuff, "%s/%s", BOARD_REG_PATH, BOARD_NAME_REG_NAME);
    
    err = tsaRegQuery(tmpBuff, &entryType, (Pointer *)&entry);
    if (err != TMLIBDEV_OK || 
        entryType != recData || 
        entry->dataType != redtChar ||
        entry->dataLength > BOARD_NAME_LENGTH) 
    {
        *pID = 0;
        if (pboardName)
            *pboardName = "Unknown board";
        return TSA_BOARD_ERR_GETBOARDCONFIG_FAILED;
    }
    if (pboardName)
        *pboardName = entry->data;
    

    /* the Board ID */
    sprintf(tmpBuff,"%s/%s", BOARD_REG_PATH, BOARD_ID_REG_NAME);
    err = tsaRegQuery(tmpBuff, &entryType, (Pointer *)&entry);
    if (err != TMLIBDEV_OK || 
        entryType != recData ||
        entry->dataType != redtUInt ||
        entry->dataLength != 1)
    {
        *pID = 0; /* only pid, since boardName was found */
        return TSA_BOARD_ERR_GETBOARDCONFIG_FAILED;
    }
    
    *pID = ((UInt32 *) entry->data)[0];
    
    return TMLIBDEV_OK;
}


extern tmLibdevErr_t tsaBoardGetAO(UInt32 unitNumber, boardAOConfig_t **AOConfig)
{
    return getInterface(AO_REG_PATH, unitNumber, (Pointer *)AOConfig);
}

extern tmLibdevErr_t tsaBoardGetSPDO(UInt32 unitNumber, boardSPDOConfig_t **SPDOConfig)
{
    return getInterface(SPDO_REG_PATH, unitNumber, (Pointer *)SPDOConfig);
}

extern tmLibdevErr_t tsaBoardGetAI(UInt32 unitNumber, boardAIConfig_t **AIConfig)
{
    return getInterface(AI_REG_PATH, unitNumber, (Pointer *)AIConfig);
}

extern tmLibdevErr_t tsaBoardGetVO(UInt32 unitNumber, boardVOConfig_t **VOConfig)
{
    return getInterface(VO_REG_PATH, unitNumber, (Pointer *)VOConfig);
}

extern tmLibdevErr_t tsaBoardGetVI(UInt32 unitNumber, boardVIConfig_t **VIConfig)
{
    return getInterface(VI_REG_PATH, unitNumber, (Pointer *)VIConfig);
}

extern tmLibdevErr_t tsaBoardGetSSI(UInt32 unitNumber, boardSSIConfig_t **SSIConfig)
{
    return getInterface(SSI_REG_PATH, unitNumber, (Pointer *)SSIConfig);
}

extern tmLibdevErr_t tsaBoardGetTP(UInt32 unitNumber, boardTPConfig_t **TPConfig)
{
    return getInterface(TP_REG_PATH, unitNumber, (Pointer *)TPConfig);
}

extern tmLibdevErr_t tsaBoardGetHDVO(UInt32 unitNumber, boardHDVOConfig_t **HDVOConfig)
{
    return getInterface(HDVO_REG_PATH, unitNumber, (Pointer *)HDVOConfig);
}

extern tmLibdevErr_t tsaBoardGetMP(UInt32 unitNumber, boardMPConfig_t **MPConfig)
{
    return getInterface(MP_REG_PATH, unitNumber, (Pointer *)MPConfig);
}

extern tmLibdevErr_t tsaBoardGetGPIO(UInt32 unitNumber, boardGPIOConfig_t **GPIOConfig)
{
    return getInterface(GPIO_REG_PATH, unitNumber, (Pointer *)GPIOConfig);
}

extern tmLibdevErr_t tsaBoardGetFlash(UInt32 unitNumber, boardFlashConfig_t **flashConfig)
{
    return getInterface(FLASH_REG_PATH, unitNumber, (Pointer *)flashConfig);
}

extern tmLibdevErr_t tsaBoardGetPIC(UInt32 unitNumber, boardPICConfig_t **picConfig)
{
    return getInterface(PIC_REG_PATH, unitNumber, (Pointer *)picConfig);
}

extern tmLibdevErr_t tsaBoardGetIR(UInt32 unitNumber, boardIRConfig_t **irConfig)
{
    return getInterface(IR_REG_PATH, unitNumber, (Pointer *)irConfig);
}

extern tmLibdevErr_t tsaBoardGetUart(UInt32 unitNumber, boardUartConfig_t **uartConfig)
{
    return getInterface(UART_REG_PATH, unitNumber, (Pointer *)uartConfig);
}

extern tmLibdevErr_t tsaBoardGetTvTuner(UInt32 unitNumber, boardTvTunerConfig_t **tunerConfig)
{
    return getInterface(TVTUNER_REG_PATH, unitNumber, (Pointer *)tunerConfig);
}

extern tmLibdevErr_t tsaBoardGetP1394(UInt32 unitNumber, boardP1394Config_t **p1394Config)
{
    return getInterface(P1394_REG_PATH, unitNumber, (Pointer *)p1394Config);
}

extern tmLibdevErr_t tsaBoardGetTvDigDem(UInt32 unitNumber, boardTvDigDemConfig_t **digDemConfig)
{
    return getInterface(TVDIGDEM_REG_PATH, unitNumber, (Pointer *)digDemConfig);
}

extern tmLibdevErr_t tsaBoardGetTvAudDem(UInt32 unitNumber, boardTvAudDemConfig_t **audDemConfig)
{
    return getInterface(TVAUDDEM_REG_PATH, unitNumber, (Pointer *)audDemConfig);
}

/* old interface. Maintained when possible for compatibility */



/*
 * Function         : boardGetConfig
 * Parameters       : bc (O)  pointer to board config structure to be filled in.
 * Function Result  : TMLIBDEV_OK if success,
 *                    BOARD_ERR_UNKNOWN_BOARD if a valid BSP can't be found.
 * Side Effects     : if the board has not yet been initialized, perform board
 *                    detection and initialize the board.
 */
 
extern tmLibdevErr_t 
boardGetConfig(boardConfig_t * bc)
{
    tmLibdevErr_t err = TMLIBDEV_OK;

    if (tsaBoardGetAI(unit0, &(bc->aibc)) != TMLIBDEV_OK)
        bc->aibc = Null;
    if (tsaBoardGetAO(unit0, &(bc->aobc)) != TMLIBDEV_OK)
        bc->aobc = Null;
    if (tsaBoardGetVI(unit0, &(bc->vibc)) != TMLIBDEV_OK)
        bc->vibc = Null;
    if (tsaBoardGetVO(unit0, &(bc->vobc)) != TMLIBDEV_OK)
        bc->vobc = Null;
    if (tsaBoardGetSSI(unit0, &(bc->ssibc)) != TMLIBDEV_OK)
        bc->ssibc = Null;
    err = boardGetID(&(bc->ID));
    
    /* fill the remaining fields. These fields cannot be filled
     * in a appropriate manner, then we assume they equal Null 
     */
    bc->board_init_func   = Null;
    bc->board_detect_func = Null;
    bc->reserved          = Null;

    if (err != TMLIBDEV_OK)
        err = BOARD_ERR_NULL_FUNCTION;
    return err;
}


/*
 * Function         : boardGetID
 * Parameters       : ID (O)  pointer to UInt to be filled with ID value
 * Function Result  : TMLIBDEV_OK if success,
 *                    BOARD_ERR_NULL_DETECT_FUNCTION if one 
 *                    of the boards defined
 *                    in boardcfg.c did not have a detect function.
 * Side Effects     : if the board has not yet been initialized, perform board
 *                    detection and initialize the board
 */
extern tmLibdevErr_t 
boardGetID(UInt * ID)
{
    tsaRegEntryClass_t entryType;
    ptsaRegDataEntry_t entryP;
    tmLibdevErr_t err;
    
    err = tsaRegQuery("bsp/boardID", &entryType, (Pointer *) &entryP);
    if (err == TMLIBDEV_OK)
    {
        *ID = ((UInt*) entryP->data)[0];
    }
    else
    {
         err = BOARD_ERR_NULL_DETECT_FUNCTION;
    }
    return err;
}