tmboard.c.bak

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

/*
 * Copyright (c) 1995 - 1999 by TriMedia Technologies. 
 *
 * +------------------------------------------------------------------+
 * | This software is furnished under a license and may only be used  |
 * | and copied in accordance with the terms and conditions of  such  |
 * | a license and with the inclusion of this copyright notice. This  |
 * | software or any other copies of this software may not be provided|
 * | or otherwise made available to any other person.  The ownership  |
 * | and title of this software is not transferred.                   |
 * |                                                                  |
 * | The information in this software is subject  to change without   |
 * | any  prior notice and should not be construed as a commitment by |
 * | TriMedia Technologies.                                           |
 * |                                                                  |
 * | this code and information is provided "as is" without any        |
 * | warranty of any kind, either expressed or implied, including but |
 * | not limited to the implied warranties of merchantability and/or  |
 * | fitness for any particular purpose.                              |
 * +------------------------------------------------------------------+
 *
 *  Module name              : tmBoard.c    1.49
 *
 *  Last update              : 18:23:05 - 00/11/09
 *
 *  Description              :
 *
 *      Board Support Package for Trimedia peripherals.
 *      Generic portion. Contains a lot of helper function to access the 
 *      registry.
 *
 *  Revision                 :
 *        Built for the TCS 2.0 release
 *
 *
 */

/* implementation details :
 * Contrary to many libdev libraries, asserts are not used in this library
 * The functions described by this library are commonly called from 
 * components (in the component manager) and therefore are launched before
 * main. If the program exits before the component manager can finish, the
 * component manager cannot print its report that contains important 
 * debugging information.
 * Therefore, all exits (and tmAssert's) are removed from this library.
 */




#include <tmlib/tmtypes.h>
#include <tm1/tmLibdevErr.h>
#include <tmlib/dprintf.h>      /* for debugging with DP(()) */
#include <tm1/tmBoard.h>
#include <tm1/tmAssert.h>

/*-----------------------------includes-------------------------------------*/

#include <tm1/tsaReg.h>
#include <tm1/tsaComponent.h>

#define DEBUG_LEVEL 0

#if (DEBUG_LEVEL & 1)
#define L1_DP(x) DP(x)
#endif

#if (DEBUG_LEVEL & 2)
#define L2_DP(x) DP(x)
#endif

#ifndef L1_DP
#define L1_DP(x) 
#endif

#ifndef L2_DP
#define L2_DP(x)
#endif

#define AO_REG_PATH       "bsp/AO/"
#define SPDO_REG_PATH     "bsp/SPDO/"
#define AI_REG_PATH       "bsp/AI/"
#define VI_REG_PATH       "bsp/VI/"
#define VO_REG_PATH       "bsp/VO/"
#define TP_REG_PATH       "bsp/TP/"
#define SSI_REG_PATH      "bsp/SSI/"
#define GPIO_REG_PATH     "bsp/GPIO/"
#define FLASH_REG_PATH    "bsp/flash/"
#define PIC_REG_PATH      "bsp/pic/"
#define IR_REG_PATH       "bsp/ir/"
#define UART_REG_PATH     "bsp/uart/"
#define TVTUNER_REG_PATH  "bsp/TvTuner/"
#define TVDIGDEM_REG_PATH "bsp/TvDigDem/"
#define TVAUDDEM_REG_PATH "bsp/TvAudDem/"
#define HDVO_REG_PATH     "bsp/HDVO/"
#define P1394_REG_PATH    "bsp/P1394/"
#define MP_REG_PATH       "bsp/MP/"

#define MAX_REG_PATH_LENGTH sizeof(TVDIGDEM_REG_PATH)

#define DEVICE_REG_DEFAULT_NAME "Default"
#define BOARD_NAME_LENGTH       32

/* maximum number of characters for an interface : */
/* if MAX_INTERFACE_LENGTH is 2, then valid numbers go from 0 to 99 */
/* warning : 01 is different from 1. and 1, 2, ... are not valid unit */
/* names.  */


#define MAX_REG_UNIT_NUMBER 99
#define MAX_REG_UNIT_LENGTH 2

#define BOARD_REG_PATH      "bsp"
#define BOARD_ID_REG_NAME   "boardID"
#define BOARD_NAME_REG_NAME "boardName"

/*------------------------------variables------------------------------------*/


/*-----------------------------static functions------------------------------*/

static Int32 strnlen(Char *p, UInt32 n)
{
    Int32 i=0;
    
    while (*p++ != '\0')
    {
        if (i++ == n) {
            i = -1;
            break;
        }
    }
    return i;
}

static tmLibdevErr_t registerInterface(Char *path, UInt32 unitNumber, Pointer config)
{
    Char tmpBuff[MAX_REG_PATH_LENGTH + MAX_REG_UNIT_LENGTH];
    tsaRegDataEntry_t dataEntry = {redtUInt, 1, 0 };
    tsaRegEntryAdd_t regEntry;
    tsaRegEntryClass_t entryType;
    Pointer entry;
    tmLibdevErr_t err;
    
    /* safety checks */
    if (config == Null)
        return TMLIBDEV_ERR_NULL_PARAMETER;
    if (unitNumber > MAX_REG_UNIT_NUMBER) 
        return TSA_BOARD_ERR_INVALID_UNIT_NUMBER;

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

    err = tsaRegQuery(tmpBuff, &entryType, &entry);
    if (err == TMLIBDEV_OK) /* then this interface already exists */
        return TSA_BOARD_ERR_UNIT_EXISTS;

    regEntry.path      = tmpBuff;
    strcpy(regEntry.keyString, DEVICE_REG_DEFAULT_NAME);
    regEntry.entryType = recData;
    regEntry.entrySize = 0; 
    regEntry.entry = &dataEntry;
    regEntry.flags     = TSA_REG_CREATE_ALWAYS;

    dataEntry.data = &config;
    
    err = tsaRegAddEntry(&regEntry);
    return err;
}

/* This function is used by components who have to register their */
/* names, but do not need all the facilities provided by the      */
/* registry : they do not need to associate a value to a key      */
/* this function registers all the names that have not previously */
/* registered by this component */
extern tmLibdevErr_t tsaBoardRegisterNames(pcomponent_t comp)
{
    pdataProperties_t *l = (Pointer)comp->outputs;
    while (*l != Null) 
    {
        if (tsaRegAddDirectory((*l)->name) == TMLIBDEV_OK) 
        {
            l++;
        } 
        else 
        {
            L2_DP(("An error was detected while creating %s\n", (*l)->name));
            l++;
        }
    }
    return TMLIBDEV_OK;
}


/* register functions */

extern tmLibdevErr_t tsaBoardRegisterBoard(UInt32 ID, Char *boardName)
{
    tsaRegEntryAdd_t regEntry;
    tsaRegDataEntry_t dataEntry = {redtChar, 0, Null };
    Int32 boardNameLength;
    tmLibdevErr_t err;
    
    L1_DP(("tsaBoardRegisterBoard\n"));
    if (boardName == Null)
        return TMLIBDEV_ERR_NULL_PARAMETER;
    
    /* register the BoardName */
    
    if ((boardNameLength = strnlen(boardName, BOARD_NAME_LENGTH)) == -1)
        return TSA_BOARD_ERR_BOARD_NAME_TOO_LONG;

    dataEntry.data = boardName;
    dataEntry.dataLength = boardNameLength + 1; /* for '/0' */

    regEntry.path      = BOARD_REG_PATH;
    strcpy(regEntry.keyString, BOARD_NAME_REG_NAME);
    regEntry.entryType = recData;
    regEntry.entrySize = 0; /* not necessary, since this recData */
    regEntry.entry     = &dataEntry;
    regEntry.flags     = TSA_REG_CREATE_ALWAYS;

    err = tsaRegAddEntry(&regEntry);
    if (err != TMLIBDEV_OK)
    {
        return err;
    }

    /* register the Board ID */
    dataEntry.dataLength = 1;
    dataEntry.dataType   = redtUInt;
    dataEntry.data       = &ID;
    strcpy(regEntry.keyString, BOARD_ID_REG_NAME);
    /* Note that this is not necessary to modify any other member of these */
    /* two structs, since these have already been set earlier */

    err = tsaRegAddEntry(&regEntry);
    if (err != TMLIBDEV_OK)
    {
        /* FIXME : some clean up might be necessary in this case. See note */
        /* in the implementation notes */
        return err;
    }

    return TMLIBDEV_OK;
}

extern tmLibdevErr_t tsaBoardRegisterAO(UInt32 unitNumber, boardAOConfig_t *AOConfig)
{
    if (AOConfig->intNumber == 0)
        return TMLIBDEV_ERR_NULL_PARAMETER;
    if (AOConfig->mmioBase == 0)
        return TMLIBDEV_ERR_NULL_PARAMETER;
    return registerInterface(AO_REG_PATH, unitNumber, AOConfig);
}

extern tmLibdevErr_t tsaBoardRegisterSPDO(UInt32 unitNumber, boardSPDOConfig_t *SPDOConfig)
{
    return registerInterface(SPDO_REG_PATH, unitNumber, SPDOConfig);
}

extern tmLibdevErr_t tsaBoardRegisterAI(UInt32 unitNumber, boardAIConfig_t *AIConfig)
{
    if (AIConfig->intNumber == 0)
        return TMLIBDEV_ERR_NULL_PARAMETER;
    if (AIConfig->mmioBase == 0)
        return TMLIBDEV_ERR_NULL_PARAMETER;
    return registerInterface(AI_REG_PATH, unitNumber, AIConfig);
}

extern tmLibdevErr_t tsaBoardRegisterVO(UInt32 unitNumber, boardVOConfig_t *VOConfig)
{
    if (VOConfig->intNumber == 0)
        return (TMLIBDEV_ERR_NULL_PARAMETER);
    if (VOConfig->mmioBase == 0)
        return TMLIBDEV_ERR_NULL_PARAMETER;
    return registerInterface(VO_REG_PATH, unitNumber, VOConfig);
}

extern tmLibdevErr_t tsaBoardRegisterVI(UInt32 unitNumber, boardVIConfig_t *VIConfig)
{
    if (VIConfig->intNumber == 0)
        return TMLIBDEV_ERR_NULL_PARAMETER;
    if (VIConfig->mmioBase == 0)
        return TMLIBDEV_ERR_NULL_PARAMETER;
    return registerInterface(VI_REG_PATH, unitNumber, VIConfig);
}

extern tmLibdevErr_t tsaBoardRegisterSSI(UInt32 unitNumber, boardSSIConfig_t *SSIConfig)
{
    if (SSIConfig->intNumber == 0)
        return TMLIBDEV_ERR_NULL_PARAMETER;
    /* if (SSIConfig->mmioBase  == 0)
       return TMLIBDEV_ERR_NULL_PARAMETER; */
    return registerInterface(SSI_REG_PATH, unitNumber, SSIConfig);
}

extern tmLibdevErr_t tsaBoardRegisterTP(UInt32 unitNumber, boardTPConfig_t *TPConfig)
{
    if (TPConfig->intNumber == 0)
        return TMLIBDEV_ERR_NULL_PARAMETER;
    if (TPConfig->mmioBase == 0)
        return TMLIBDEV_ERR_NULL_PARAMETER;
    return registerInterface(TP_REG_PATH, unitNumber, TPConfig);
}

extern tmLibdevErr_t tsaBoardRegisterHDVO(UInt32 unitNumber, boardHDVOConfig_t *HDVOConfig)