tmvi.c

用于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              : tmVI.c    1.89
 *
 *  Last update              : 19:47:02 - 00/11/09
 *
 *  Description              :
 *      Trimedia Video In library header file.
 *
 *  Revision                 :
 *
 */

/* normally, these come from the Makefile */
#ifndef MAJOR_VERSION
#define MAJOR_VERSION   3
#endif
#ifndef MINOR_VERSION
#define MINOR_VERSION   1
#endif
#ifndef BUILD_VERSION
#define BUILD_VERSION   0
#endif

#include <tm1/tmBoard.h>
 
/*----------------------------- includes ------------------------------------*/

#include <string.h>

#include <tm1/tmVI.h>
#include <tm1/tmVImmio.h>
#include <tm1/mmio.h>
#include <tm1/tmAssert.h>
#include <tmlib/AppModel.h>
#include <tm1/tsaReg.h>
#include <tm1/tmAvFormats.h>
#include <ops/custom_defs.h>
#include <tm1/tmPCSW.h>
#include <tmlib/dprintf.h>  /* for debugging with DP(()) */
#include <tm1/tsaComponent.h>
#include <tm1/tmGPIO.h>

/*------------------------- local definitions -------------------------------*/


#define NROF_VIS                  1

#define VI_MAGIC              0x75289377

#define IS_VALID(instance) \
{\
tmAssert(instance, TMLIBDEV_ERR_NOT_OWNER);\
tmAssert(((pviInstVars_t)instance)->boardVIConfig != Null, TMLIBDEV_ERR_NULL_PARAMETER);\
tmAssert(((pviInstVars_t)instance)->magic == VI_MAGIC, TMLIBDEV_ERR_NOT_OWNER);\
} ;


typedef enum {
    viNoSetupCalled = 0,
    viYUVSetupCalled = 1,
    viRawSetupCalled = 2
} viSetupCalled_t;


typedef struct 
{
    UInt32                  magic;
    viInstanceSetup_t       setup;
    viSetupCalled_t         setupCalled;
    unitSelect_t            unitName;
    Int                     unitIndex;
    boardVIConfig_t        *boardVIConfig;
    Int                     gpioInstance;
    tmVideoAnalogStandard_t standard;
} viInstVars_t, *pviInstVars_t;


typedef struct
{
    UInt32            numberOfUnits;
    unitSelect_t     *unitNumbers;
    pviCapabilities_t unitCapabilities;
} viCapabilitiesList_t;

static viCapabilitiesList_t capabilities = 
{
    0,            /* number of units */
    Null,         /* unitNumbers     */
    Null          /* array of unit descriptors */
};


/*--------------------- generic functions ----------------------*/
static tmLibdevErr_t
prepareCapabilities(void);
static tmLibdevErr_t
getUnitIndex(unitSelect_t unitName, Int *unitIndex);

static tmLibdevErr_t getUnitIndex(unitSelect_t unitName, Int *unitIndex)
{
    Int i;
    
    for (i = 0; i < capabilities.numberOfUnits; i++)
    {
        if (capabilities.unitNumbers[i] == unitName)
        {
            *unitIndex = i;
            return TMLIBDEV_OK;
        }
    }
    return TMLIBDEV_ERR_NOT_AVAILABLE_IN_HW;
}


static tmLibdevErr_t
setup_board(pviInstVars_t pinst,
            pboardVIParam_t param)
{
    tmLibdevErr_t   err;
    
    err = tsaBoardGetVI(pinst->unitName, &pinst->boardVIConfig);
    if (err != TMLIBDEV_OK)
        return TMLIBDEV_ERR_NOT_AVAILABLE_IN_HW;

    if (pinst->boardVIConfig->init_func == Null)
        return VI_ERR_INVALID_DECODER_INIT;
    
    if (err = pinst->boardVIConfig->init_func(param))
        return err;

    return TMLIBDEV_OK;
}

static tmLibdevErr_t
setup_isr(intInterrupt_t int_instance,
      void (*isr) (void),
      intPriority_t priority)
{
    intInstanceSetup_t int_setup;

    int_setup.handler = isr;
    int_setup.priority = priority;
    int_setup.level_triggered = True;
    int_setup.enabled = True;
    return intInstanceSetup(int_instance, &int_setup);
}

extern tmLibdevErr_t
viGetNumberOfUnits(UInt32 *pNumberOfUnits)
{
    UInt32        i            = 0;
    Char         *searchString = "/bsp/VI/*";
    tsaRegFind_t  findInfo;
    tmLibdevErr_t err;

    tmAssert(pNumberOfUnits, TMLIBDEV_ERR_NULL_PARAMETER); 
    
    err = tsaRegFindFirstEntry(searchString, &findInfo);
    if (err)
    {
        *pNumberOfUnits = 0;
        return TMLIBDEV_OK;
    }
    i++;
    while (tsaRegFindNextEntry(searchString, &findInfo) == TMLIBDEV_OK)
    {
        i++;
    }
    
    *pNumberOfUnits = i;
    return TMLIBDEV_OK;
}



/*--------------------- capability/parameter functions ----------------------*/

/*
 * Function         : Retrieve global capabilities.
 * Parameters       : cap  (O)  pointer to buffer receiving
 *                              returned capabilities
 * Function Result  : resulting error condition
 */

extern tmLibdevErr_t
viGetCapabilities(pviCapabilities_t * pCap)
{
    return viGetCapabilitiesM(pCap, unit0);
}

extern tmLibdevErr_t
viGetCapabilitiesM(pviCapabilities_t * pCap, unitSelect_t unitName)
{
    tmLibdevErr_t    err = TMLIBDEV_OK;
    Int              unitIndex;
    boardVIConfig_t *VIConfig;

    tmAssert(pCap != Null, TMLIBDEV_ERR_NULL_PARAMETER);

    AppModel_suspend_scheduling();
    err = prepareCapabilities();
    if (err != TMLIBDEV_OK)
        goto viGetCapabilitiesMExit;

    if (getUnitIndex(unitName, &unitIndex))
    {
        err = TMLIBDEV_ERR_NOT_AVAILABLE_IN_HW;
        goto viGetCapabilitiesMExit;
    }
    
    if (TMLIBDEV_OK != tsaBoardGetVI(unitName, &VIConfig))
    {
        err = TMLIBDEV_ERR_NOT_AVAILABLE_IN_HW;
        goto viGetCapabilitiesMExit;
    }

    *pCap = &capabilities.unitCapabilities[unitIndex];
viGetCapabilitiesMExit:
    AppModel_resume_scheduling();
    return err;
}

static tmLibdevErr_t
prepareCapabilities(void)
{
    UInt32           numberOfUnits, i, j;
    boardVIConfig_t *VIConfig;
    tmLibdevErr_t    err;
    unitSelect_t     unitNumber = unit0;

    if (capabilities.unitCapabilities == Null) 
    {
        /* this means that the capabilities variable does not contain accurate data */
        if (TMLIBDEV_OK != (err = viGetNumberOfUnits(&numberOfUnits)))
            return err;
        
        if (numberOfUnits == 0)
        {
            return TMLIBDEV_ERR_NOT_AVAILABLE_IN_HW;
        }
        
        capabilities.numberOfUnits = numberOfUnits;
        
        capabilities.unitNumbers = (unitSelect_t *)
            malloc(capabilities.numberOfUnits * sizeof(unitSelect_t));
        if (capabilities.unitNumbers == Null) 
        {
            return TMLIBDEV_ERR_MEMALLOC_FAILED;
        }
        capabilities.unitCapabilities = (pviCapabilities_t)
            malloc(capabilities.numberOfUnits * sizeof(viCapabilities_t));
        if (capabilities.unitCapabilities == Null)
        {
            free(capabilities.unitNumbers);
            capabilities.unitNumbers = Null;
            return TMLIBDEV_ERR_MEMALLOC_FAILED;
        }

        i = 0;
        while (i < capabilities.numberOfUnits)
        {
            if (TMLIBDEV_OK != tsaBoardGetVI(unitNumber, &VIConfig))
            {
                /* this unit is not supported, check next */
                unitNumber++;
                continue;
            }

            capabilities.unitNumbers[i] = unitNumber;

            capabilities.unitCapabilities[i].version.majorVersion = MAJOR_VERSION;
            capabilities.unitCapabilities[i].version.minorVersion = MINOR_VERSION;
            capabilities.unitCapabilities[i].version.buildVersion = BUILD_VERSION;

            /* init # instances */
            capabilities.unitCapabilities[i].numCurrentInstances = 0;
            capabilities.unitCapabilities[i].numSupportedInstances = 1;

            /* name */
            if (VIConfig->codecName != Null)
            {
                strncpy(capabilities.unitCapabilities[i].codecName,
                        VIConfig->codecName, DEVICE_NAME_LENGTH);
            }

            capabilities.unitCapabilities[i].videoStandards     = VIConfig->standards;
            capabilities.unitCapabilities[i].adapterTypes       = VIConfig->adapters;
            capabilities.unitCapabilities[i].numSvideoApapters  = 0;
            capabilities.unitCapabilities[i].numCvbsAdapters    = 0;
            for (j = 0; j < VIConfig->vDec.numAdapters; j++)
            {
                if (VIConfig->vDec.adapterTable[j].adapterType == vaaCVBS)
                    capabilities.unitCapabilities[i].numCvbsAdapters++;
                else if (VIConfig->vDec.adapterTable[j].adapterType == vaaSvideo)
                    capabilities.unitCapabilities[i].numSvideoApapters++;
            }
            unitNumber ++;
            i++;
        }
    }        
    return TMLIBDEV_OK;
}


/*
 * Function         : Set/change instance setup parameters.
 *                    Initializes the decoder on the board.
 *                    Perpare for either data streaming mode or video mode
 * Parameters       : instance (I)  instance to set parameters for
 *                    setup    (I)  pointer to buffer
 *                                  holding new parameters
 * Function Result  : resulting error condition
 */

extern tmLibdevErr_t
viInstanceSetup(Int instance, viInstanceSetup_t * setup)
{
    Int              vi_ctl;
    tmLibdevErr_t    err;
    Bool             endianess;
    pviInstVars_t    pinst = (pviInstVars_t) instance;
    boardVIConfig_t *boardVIConfig = pinst->boardVIConfig;
    boardVIParam_t   boardParam;

    IS_VALID(instance);
    tmAssert(setup != Null, TMLIBDEV_ERR_NULL_PARAMETER);
    
    boardParam.videoStandard = setup->videoStandard;
    boardParam.adapterType   = setup->adapterType;
    boardParam.mmioBase      = boardVIConfig->mmioBase;
    boardParam.adapterInstance = setup->adapterInstance;

    if (err = setup_board(pinst, &boardParam))
        return err;

    pinst->standard          = setup->videoStandard;
    tmAssert((setup->videoStandard == vasNone)
         || ((setup->videoStandard & boardVIConfig->standards) != 0),
         BOARD_ERR_UNSUPPORTED_STANDARD);
    tmAssert((setup->adapterType == vasNone)
         || (((UInt32) setup->adapterType & boardVIConfig->adapters) != 0),
         BOARD_ERR_UNSUPPORTED_ADAPTER);

    if (err = setup_isr(boardVIConfig->intNumber, setup->isr, setup->interruptPriority))
        return err;

    vi_ctl = MMIO(boardVIConfig->mmioBase + VI_CTL_OFFSET);

    endianess = ((readpcsw() & tmPCSW_BSX) != 0);

    viInsertHBE_IEN__CHECK(vi_ctl, setup->hbeEnable);
    viInsertLITTLE_ENDIAN__CHECK(vi_ctl, endianess);

    MMIO(boardVIConfig->mmioBase + VI_CTL_OFFSET) = vi_ctl;

    return TMLIBDEV_OK;
}


/*
 * Function         : Set/change instance setup parameters YUV operation mode.
 *                    Assumes viInstanceSetup is already called.
 * Parameters       : instance (I)  instance to set parameters for
 *                    setup    (I)  pointer to buffer
 *                                  holding new parameters
 * Function Result  : resulting error condition
 */

extern tmLibdevErr_t
viYUVSetup(Int instance, viYUVSetup_t * setup)
{
    Int             vi_ctl;
    pviInstVars_t   pinst = (pviInstVars_t)instance;
    boardVIConfig_t *boardVIConfig = pinst->boardVIConfig;
    tmVideoAnalogStandard_t videoStandard = vasNone;
    
    IS_VALID(instance);
    tmAssert(setup != Null, TMLIBDEV_ERR_NULL_PARAMETER);

    viSetY_DELTA__CHECKM(boardVIConfig->mmioBase, setup->yDelta);
    viSetU_DELTA__CHECKM(boardVIConfig->mmioBase, setup->uDelta);
    viSetV_DELTA__CHECKM(boardVIConfig->mmioBase, setup->vDelta);
    viSetY_BASE_ADR__CHECKM(boardVIConfig->mmioBase, (UInt) setup->yBase);
    viSetU_BASE_ADR__CHECKM(boardVIConfig->mmioBase, (UInt) setup->uBase);
    viSetV_BASE_ADR__CHECKM(boardVIConfig->mmioBase, (UInt) setup->vBase);
    viSetHEIGHT__CHECKM(boardVIConfig->mmioBase, setup->height);
    viSetSTART_X__CHECKM(boardVIConfig->mmioBase, setup->startX);
    viSetSTART_Y__CHECKM(boardVIConfig->mmioBase, setup->startY);

    if (pinst->standard == vasNone)
        viGetVideoStandard(instance, &videoStandard);
    if (videoStandard == vasNTSC) {
    	tmAssert((setup->startX + ((setup->mode == viFULLRES) ? 1 : 2) * setup->width) < 856, VI_ERR_START_X_SIZE);
    } else if (videoStandard == vasPAL) {
    	tmAssert((setup->startX + ((setup->mode == viFULLRES) ? 1 : 2) * setup->width) < 862, VI_ERR_START_X_SIZE);
    }
    if (setup->mode == viFULLRES) {
        tmAssert((setup->startX & 0x1) == 0, VI_ERR_START_X_ALIGNMENT);
        viSetWIDTH__CHECKM(boardVIConfig->mmioBase, setup->width);
    }
    else {
        tmAssert((setup->startX & 0x3) == 0, VI_ERR_START_X_ALIGNMENT);
        tmAssert(((2 * setup->width) & 0x3) == 0, VI_ERR_WIDTH_ALIGNMENT);
        viSetWIDTH__CHECKM(boardVIConfig->mmioBase, 2 * setup->width);
    }
    tmAssert(((setup->yDelta + setup->width) & 0x3f) == 1, VI_ERR_Y_DELTA_SIZE);
    tmAssert(((setup->uDelta + setup->width/2) & 0x3f) == 1, VI_ERR_U_DELTA_SIZE);
    tmAssert(((setup->vDelta + setup->width/2) & 0x3f) == 1, VI_ERR_V_DELTA_SIZE);

    vi_ctl = MMIO(boardVIConfig->mmioBase + VI_CTL_OFFSET);

    viInsertY_THRESHOLD__CHECK(vi_ctl, setup->yThreshold);
    viInsertCOSITE__CHECK(vi_ctl, !setup->cositedSampling);
    viInsertTRSH_IEN__CHECK(vi_ctl, setup->thresholdReachedEnable);
    viInsertCAP_IEN__CHECK(vi_ctl, setup->captureCompleteEnable);
    viInsertMODE__CHECK(vi_ctl, setup->mode);

    MMIO(boardVIConfig->mmioBase + VI_CTL_OFFSET) = vi_ctl;

    pinst->setupCalled = viYUVSetupCalled;