tmtp.c

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

/*
 * Copyright (c) 1995 - 1998 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              : tmTP.c    1.13
 *
 *  Last update              : 19:43:28 - 00/11/09
 *
 *  Description              :
 *      Trimedia Transport Stream In library file.
 *
 *  Revision                 :
 *
 */


#include <tm1/mmio.h>
#include <tm1/tmAssert.h>
#include <tm1/tmBoard.h>
#include <tm1/tmAvFormats.h>
#include <tm1/tmPCSW.h>
#include <ops/custom_defs.h>
#include <tmlib/AppModel.h>
#include <tmlib/dprintf.h>  /* for debugging with DP(()) */
#include <tm1/tmTPboard.h>

#include <tm1/tmTP.h>
#include <tm1/tmTPmmio.h>
#include <tm1/tsaComponent.h>
#include <tm1/tmGPIO.h>

#define TP_MAJOR_VERSION         1
#define TP_MINOR_VERSION         1
#define __TP_MAGIC               0x752894F7 


#define tpCheck(pinst, err) \
do { \
tmAssert(pinst, err); \
if (pinst->magic != __TP_MAGIC) \
   return err; \
} \
while (0)


typedef struct
{
    UInt32 numberOfUnits;
    tpCapabilities_t *unitCapabilities;
} tpCapabilitiesList_t;


static tpCapabilitiesList_t caps = 
{
    0,
    Null
};


typedef struct {
    UInt32           magic;
    Bool             instanceSetupCalled;
    Int              pidFilterInitial;
    Bool             filterInUse[TP_NROF_FILTERED_PIDS];
    UInt16           filterPids[TP_NROF_FILTERED_PIDS];
    unitSelect_t     unitName;
    boardTPConfig_t *boardTPConfig;
    Int              gpioInstance;
} tpInstVars_t, *ptpInstVars_t;

static tmLibdevErr_t prepareCapabilities();

extern tmLibdevErr_t tpGetNumberOfUnits(UInt32 *pNumberOfUnits)
{
    UInt32 i = 0;
    boardTPConfig_t *dummyConfig;

    tmAssert(pNumberOfUnits, TMLIBDEV_ERR_NULL_PARAMETER);

    while (tsaBoardGetTP(i, &dummyConfig) == TMLIBDEV_OK)
        i++;
    *pNumberOfUnits = i;
    return TMLIBDEV_OK;
}

extern tmLibdevErr_t tpGetCapabilities(ptpCapabilities_t *pCap)
{
    return tpGetCapabilitiesM(pCap, unit0);
}

extern tmLibdevErr_t tpGetCapabilitiesM(ptpCapabilities_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 tpGetCapabilitiesMExit;
    if (unitName >= caps.numberOfUnits)
    {
        err = TMLIBDEV_ERR_NOT_AVAILABLE_IN_HW;
        goto tpGetCapabilitiesMExit;
    }
    *pCap = &caps.unitCapabilities[unitName];

tpGetCapabilitiesMExit:
    AppModel_resume_scheduling();
    return err;
}

static tmLibdevErr_t
prepareCapabilities()
{
    tmLibdevErr_t    err;
    UInt32           numberOfUnits, i;
    boardTPConfig_t *TPConfig;
    
    if (caps.unitCapabilities == Null)
    {
        if ((err = tpGetNumberOfUnits(&numberOfUnits)) != TMLIBDEV_OK)
            return err;
        if (numberOfUnits == 0)
            return TMLIBDEV_ERR_NOT_AVAILABLE_IN_HW;
    

        caps.numberOfUnits = numberOfUnits;
        caps.unitCapabilities = (ptpCapabilities_t)calloc (caps.numberOfUnits, sizeof(tpCapabilities_t));
        if (caps.unitCapabilities == Null)
            return TMLIBDEV_ERR_MEMALLOC_FAILED;
        
        
        for (i = 0; i < caps.numberOfUnits ; i++)
        {
            if (TMLIBDEV_OK != tsaBoardGetTP(i, &TPConfig))
            {
                /* this cannot happen, but ... */
                return TMLIBDEV_ERR_NOT_AVAILABLE_IN_HW;
            }
            caps.unitCapabilities[i].version.majorVersion = TP_MAJOR_VERSION;
            caps.unitCapabilities[i].version.majorVersion = TP_MINOR_VERSION;
            caps.unitCapabilities[i].version.buildVersion = BUILD_VERSION;
            caps.unitCapabilities[i].numSupportedInstances = 1;
            caps.unitCapabilities[i].numCurrentInstances = 0;
            
            if ((TPConfig->codecName != Null))
            {
                strncpy(caps.unitCapabilities[i].codecName,
                        TPConfig->codecName, DEVICE_NAME_LENGTH);
            }
        }
    }
    return TMLIBDEV_OK;
}

static tmLibdevErr_t
setup_isr(
    intInterrupt_t interrupt,
    void (*isr) (void),
    intPriority_t priority)
{
    intInstanceSetup_t intSetup;

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

extern tmLibdevErr_t
tpOpenM(Int *instance, unitSelect_t unitName)
{
    gpioInstanceSetup_t gpioSetup;
    tmLibdevErr_t       rVal = TMLIBDEV_OK;
    ptpInstVars_t       instVars;
    boardTPConfig_t    *tpBoardConfig;
    UInt32              i;
    
    tmAssert(instance, TMLIBDEV_ERR_NULL_PARAMETER);
    rVal = tsaBoardGetTP(unitName, &tpBoardConfig);
    if (rVal != TMLIBDEV_OK)
        return TMLIBDEV_ERR_NOT_AVAILABLE_IN_HW;

    AppModel_suspend_scheduling();

    rVal = prepareCapabilities();
    if (rVal != TMLIBDEV_OK)
        goto tpOpenExit;

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

    instVars = (ptpInstVars_t) calloc(1, sizeof(tpInstVars_t));
    if (instVars == Null)
    {
        rVal = TMLIBDEV_ERR_MEMALLOC_FAILED;
        goto tpOpenExit;
    }

    if (rVal = intOpen(tpBoardConfig->intNumber))
    {
        free(instVars);
        goto tpOpenExit;
    }

    if (rVal = setup_isr(tpBoardConfig->intNumber, Null, intPRIO_0))
    {
        free(instVars);
        intClose(tpBoardConfig->intNumber);
        goto tpOpenExit;
    }

    /* this call will only fail if there is no GPIO capabilities */
    if (gpioOpen(&(instVars->gpioInstance)) == TMLIBDEV_OK)
    {
        /* Get the default instance setup */
        gpioGetInstanceSetup(instVars->gpioInstance, &gpioSetup);
        for (i = tpBoardConfig->gpioFirstPin; i <= tpBoardConfig->gpioLastPin; i++)
        {
          gpioInsertMode(gpioSetup.pinMode[i >> 4], 
                         i - (tpBoardConfig->gpioFirstPin & 0xfffffff0), 
                         gpioRegularMode);
            gpioInsertPin(gpioSetup.pinMask[i >> 5], 
                          i - (tpBoardConfig->gpioFirstPin & 0xffffffe0), 1);
        }
        rVal = gpioInstanceSetup(instVars->gpioInstance, &gpioSetup);
        if (rVal != TMLIBDEV_OK)
        {
            gpioClose(instVars->gpioInstance);
            free(instVars);
            intClose(tpBoardConfig->intNumber);
            goto tpOpenExit;
        }
    }
    else
    {
        instVars->gpioInstance = 0;
    }

    caps.unitCapabilities[unitName].numCurrentInstances++;
    
    instVars->magic    = __TP_MAGIC;
    instVars->unitName = unitName;
    instVars->boardTPConfig = tpBoardConfig;
    *instance = (Int) instVars;
    instVars->instanceSetupCalled = False;

    tpAckRESET(instVars->boardTPConfig->mmioBase);
tpOpenExit:
    AppModel_resume_scheduling();

    return rVal;
}

extern tmLibdevErr_t
tpInstanceSetup(Int instance, ptpInstanceSetup_t setup)
{
    ptpInstVars_t    pinst = (ptpInstVars_t)instance;
    tmLibdevErr_t    err = TMLIBDEV_OK;
    UInt32           ctl, i;
    boardTPConfig_t *boardTPConfig = pinst->boardTPConfig;
    
    tpCheck(pinst, TMLIBDEV_ERR_NOT_OWNER);
    tmAssert(setup->isr != Null, TP_ERR_NULL_ISR);
    tmAssert((setup->size % (3 * 64)) == 0, TP_ERR_BASE_SIZE);
    tmAssert(((UInt32)setup->base1 % 64) == 0, TP_ERR_BASE_ALIGNMENT);
    tmAssert(((UInt32)setup->base2 % 64) == 0, TP_ERR_BASE_ALIGNMENT);