tmvo.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              : tmVO.c    1.74
 *
 *  Last update              : 19:48:22 - 00/11/09
 *
 *  Description              :
 *      Trimedia Video Out library file.
 *
 *  Revision                 :
 *
 */

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

#include <tm1/tmBoard.h>


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

#include <string.h>

#include <tmlib/tmtypes.h>
#include <tm1/tmIIC.h>
#include <tm1/tmVO.h>
#include <tm1/mmio.h>
#include <tm1/tmAssert.h>
#include <tmlib/AppModel.h>
#include <tm1/tmProcessor.h>
#include <tm1/tmPCSW.h>
#include <ops/custom_defs.h>
#include <tmlib/dprintf.h>
#include <tm1/tmLibdevErr.h>
#include <tm1/tsaComponent.h>
#include <tm1/tmGPIO.h>


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

#define VO_MAGIC                  0x75289367

#define IS_VALID(instance) \
{\
tmAssert(instance, TMLIBDEV_ERR_NOT_OWNER); \
tmAssert( ((pvoInstVars_t)instance)->magic == VO_MAGIC, TMLIBDEV_ERR_NOT_OWNER);\
} ;

#define VO_CTL_ACK_ALL 	          0x00000E0C;

extern puts_vo();

typedef enum {
    voNoSetupCalled = 0,
    voYUVSetupCalled = 1,
    voRawSetupCalled = 2
} voSetupCalled_t;

typedef struct 
{
    UInt32            magic;
    voInstanceSetup_t setup;
    voSetupCalled_t   setupCalled;
    unitSelect_t      unitName;
    boardVOConfig_t  *boardVOConfig;
    Int               gpioInstance; 
} voInstVars_t, *pvoInstVars_t;

typedef struct 
{
    UInt32 numberOfUnits;
    voCapabilities_t *unitCapabilities;
} voCapabilitiesList_t;


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

/*--------------------- generic functions ----------------------*/

static tmLibdevErr_t prepareCapabilities(void);

static tmLibdevErr_t
VOsetup_board(pvoInstVars_t pinst, pboardVOParam_t param)
{
    tmLibdevErr_t   err;
    err = tsaBoardGetVO(pinst->unitName, &(pinst->boardVOConfig));
    if (err != TMLIBDEV_OK)
        return TMLIBDEV_ERR_NOT_AVAILABLE_IN_HW;
    
    if (pinst->boardVOConfig->init_func == Null)
        return (VO_ERR_INVALID_ENCODER_INIT);

    if (err = pinst->boardVOConfig->init_func(param))
        return (err);
    return TMLIBDEV_OK;
}

static tmLibdevErr_t
VOsetup_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 
voGetNumberOfUnits(UInt32 *pNumberOfUnits)
{
    UInt32 i = 0;
    boardVOConfig_t *dummyConfig;

    tmAssert(pNumberOfUnits, TMLIBDEV_ERR_NULL_PARAMETER);
    
    while (tsaBoardGetVO(i, &dummyConfig) == 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
voGetCapabilities(pvoCapabilities_t *pCap)
{
    return voGetCapabilitiesM(pCap, unit0);
}

extern tmLibdevErr_t
voGetCapabilitiesM(pvoCapabilities_t *pCap, unitSelect_t unitName)
{
    tmLibdevErr_t err = TMLIBDEV_OK;
    tmAssert(pCap, TMLIBDEV_ERR_NULL_PARAMETER);

    AppModel_suspend_scheduling();
    
    err = prepareCapabilities();
    if (err != TMLIBDEV_OK)
        goto voGetCapabilitiesMExit;
    
    if (unitName >= capabilities.numberOfUnits)
    {
        err = TMLIBDEV_ERR_NOT_AVAILABLE_IN_HW;
        goto voGetCapabilitiesMExit;
    }
    *pCap = &capabilities.unitCapabilities[unitName];
    
voGetCapabilitiesMExit:
    AppModel_resume_scheduling();
    return err;
}



static tmLibdevErr_t
prepareCapabilities(void)
{
    UInt32           numberOfUnits, i;
    boardVOConfig_t *VOConfig;
    tmLibdevErr_t    err;
    
    if (capabilities.unitCapabilities == Null)
    {
        if (TMLIBDEV_OK != (err = voGetNumberOfUnits(&numberOfUnits)))
            return err;
        
        if (numberOfUnits == 0)
        {
            return TMLIBDEV_ERR_NOT_AVAILABLE_IN_HW;
        }
        
        capabilities.numberOfUnits = numberOfUnits;
        
        capabilities.unitCapabilities = (pvoCapabilities_t) 
            malloc(capabilities.numberOfUnits * sizeof(voCapabilities_t));
        if (capabilities.unitCapabilities == Null)
            return TMLIBDEV_ERR_MEMALLOC_FAILED;

        for (i = 0; i < capabilities.numberOfUnits; i++)
        {
            if (TMLIBDEV_OK != tsaBoardGetVO(i, &VOConfig))
            {
                /* this should never happen, since we already checked before */
                /* FIXME : the error code is not appropriate */
                return TMLIBDEV_ERR_NOT_AVAILABLE_IN_HW;
            }
            
            capabilities.unitCapabilities[i].version.majorVersion = MAJOR_VERSION;
            capabilities.unitCapabilities[i].version.minorVersion = MINOR_VERSION;
            capabilities.unitCapabilities[i].version.buildVersion = BUILD_VERSION;

            capabilities.unitCapabilities[i].numCurrentInstances = 0;
            capabilities.unitCapabilities[i].numSupportedInstances = 1;
            capabilities.unitCapabilities[i].videoStandards = VOConfig->standards;
            capabilities.unitCapabilities[i].adapterTypes   = VOConfig->adapters;
            if (VOConfig->codecName != Null)
            {
                strncpy(capabilities.unitCapabilities[i].codecName, 
                        VOConfig->codecName, DEVICE_NAME_LENGTH);
            }
        }
    }
    return TMLIBDEV_OK;
}


/*
 * Function         : Set/change instance parameters.
 * Parameters       : instance (I)  instance to set parameters for
 *                    setup    (I)  pointer to buffer
 *                                  holding new parameters
 * Function Result  : resulting error condition
 */

extern tmLibdevErr_t
voInstanceSetup(Int instance, voInstanceSetup_t * setup)
{
	printf("---------------------\nvoInstanceSetup------------------\n");
    tmLibdevErr_t       err;
    Bool                endianess;
    pprocCapabilities_t procCap;
    pvoInstVars_t       pinst = (pvoInstVars_t)instance;
    boardVOConfig_t    *boardVOConfig = pinst->boardVOConfig;
    boardVOParam_t      param;

    IS_VALID(instance);
    tmAssert(setup != Null, TMLIBDEV_ERR_NULL_PARAMETER);

    err = procGetCapabilities(&procCap);
    if (err) return err;

    MMIO(VO_CTL) = 0x02400000;

    param.videoStandard = setup->videoStandard;
    param.adapterType   = setup->adapterType;
    param.mmioBase      = VO_STATUS;
    param.ddsFrequency  = setup->ddsFrequency;
    
    printf("------------------------\nBefore VOsetup_board\n------------------------\n");
    if (err = VOsetup_board(pinst, &param))
        return err;
    printf("------------------------\nAfter VOsetup_board\n------------------------\n");
        

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

    MMIO(VO_CTL) |= VO_CTL_ACK_ALL;

    if (err = VOsetup_isr(boardVOConfig->intNumber, setup->isr, setup->interruptPriority))
        return err;

    pinst->setup = *setup; /* copy to the instance descriptor */

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

    voSetLITTLE_ENDIAN__CHECK(endianess);
    voSetHBE_IEN__CHECK(setup->hbeEnable);
    voSetURUN_IEN__CHECK(setup->underrunEnable);

	printf("--------------------------\nEnd voInstanceSetup\n----------------------\n");
    return TMLIBDEV_OK;
}

/*--------------------- open/close functions ---------------------------------*/

/*
 * Function         : Assigns a unique video out instance for the caller.
 * Parameters       : instance  (O)  pointer to result variable
 * Function Result  : resulting error condition
 *                         (TMLIBDEV_ERR_NO_MORE_INSTANCES)
 */


extern tmLibdevErr_t
voOpen(Int *instance)
{
    return voOpenM(instance, unit0);
}

extern tmLibdevErr_t
voOpenM(Int * instance, unitSelect_t unitName)
{
	
    gpioInstanceSetup_t gpioSetup;
    tmLibdevErr_t       rVal = TMLIBDEV_OK;
    boardVOConfig_t    *voBoardConfig;
    pvoInstVars_t       pinst;
    UInt32              i;
    

	printf("---------------------\nvoOpenM\n------------------\n");
    tmAssert(instance != Null, TMLIBDEV_ERR_NULL_PARAMETER);

    rVal = tsaBoardGetVO(unitName, &voBoardConfig);
    if (rVal != TMLIBDEV_OK)
        return TMLIBDEV_ERR_NOT_AVAILABLE_IN_HW;
    
    AppModel_suspend_scheduling();

    /* Make sure that the capabilities are valid */
    rVal = prepareCapabilities();
    if (rVal != TMLIBDEV_OK)
        goto voOpenExit;

    if (capabilities.unitCapabilities[unitName].numCurrentInstances >= 
        capabilities.unitCapabilities[unitName].numSupportedInstances)
    {
        rVal = TMLIBDEV_ERR_NO_MORE_INSTANCES;
        goto voOpenExit;
    }

    pinst = (pvoInstVars_t) malloc(sizeof(voInstVars_t));
    if (pinst == Null)
    {
        rVal = TMLIBDEV_ERR_MEMALLOC_FAILED;
        goto voOpenExit;
    }
    
    if (rVal = intOpen(voBoardConfig->intNumber)) 
    {
        free(pinst);
        goto voOpenExit;
    }

    if (rVal = VOsetup_isr(voBoardConfig->intNumber, Null, intPRIO_0))
    {
        free(pinst);
        intClose(voBoardConfig->intNumber);
        goto voOpenExit;
    }
    
    pinst->magic         = VO_MAGIC;
    pinst->setupCalled   = voNoSetupCalled;
    pinst->unitName      = unitName;
    pinst->boardVOConfig = voBoardConfig;
    pinst->gpioInstance  = 0;
    
    rVal = gpioOpen(&(pinst->gpioInstance));
    
    if (rVal == TMLIBDEV_OK)
    {
        /* Get the default instance setup */
        gpioGetInstanceSetup(pinst->gpioInstance, &gpioSetup);
        for (i = voBoardConfig->gpioFirstPin; i <= voBoardConfig->gpioLastPin; i++)
        {
            gpioInsertMode(gpioSetup.pinMode[i >> 4], i - (voBoardConfig->gpioFirstPin & 0xfffffff0), gpioRegularMode);
            gpioInsertPin(gpioSetup.pinMask[i >> 5], i - (voBoardConfig->gpioFirstPin & 0xffffffe0), 1);
        }
        rVal = gpioInstanceSetup(pinst->gpioInstance, &gpioSetup);
        if (rVal != TMLIBDEV_OK)
        {
            gpioClose(pinst->gpioInstance);
            intClose(voBoardConfig->intNumber);
            free(pinst);
            goto voOpenExit;
        }
    }
    else
    {
        /* if there is no gpio, no worry, let s go on */
        rVal = TMLIBDEV_OK;
    }
    
    *instance = (Int) pinst;
    capabilities.unitCapabilities[unitName].numCurrentInstances++;
    
voOpenExit:
    AppModel_resume_scheduling();

    return rVal;
}

/*
 * Function         : Deallocates the video out instance,
 *                    and uninstall its handler when it has one.
 * Parameters       : instance  (I)  instance to give up
 * Function Result  : resulting error condition
 */

extern tmLibdevErr_t 
voClose(Int instance)
{
    tmLibdevErr_t   err = TMLIBDEV_OK, err2;
    pvoInstVars_t   pinst = (pvoInstVars_t)instance;

    IS_VALID(instance);

    AppModel_suspend_scheduling();

    err = intClose(pinst->boardVOConfig->intNumber);
    
    if (pinst->gpioInstance != 0)
    {
        gpioClose(pinst->gpioInstance);
    }

    voAckRESET();

    if (pinst->boardVOConfig->term_func) 
    {
        err2 = pinst->boardVOConfig->term_func();
        if (err == TMLIBDEV_OK) err = err2;
    }
    
    capabilities.unitCapabilities[pinst->unitName].numCurrentInstances--;
    pinst->magic = 0;

    AppModel_resume_scheduling();
    if (pinst)
        free(pinst);