tmssi.c

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

/*
 *  +-------------------------------------------------------------------+
 *  | Copyright (c) 1995,1996,1997 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              : tmSSI.c    1.32
 *
 *  Last update              : 19:42:51 - 00/11/09
 *
 *  Description              :
 *
 *      This module contains code for the public interface to the SSI portion 
 *      of the TriMedia device library.
 *
 *      The SSI library allows users access to the TriMedia's telecom features.
 *      The most important entry points are:
 *
 *
 *      This API is frozen and will be supported on future chips as appropriate.
 *
 *      The SSI library depends on the SSI component of the board support 
 *      package.
 *      That includes dependencies on IIC, hal and MMIO.h
 *
 *
 *
 *  Revision                 :
 *      Constructed for TCS 2.0b
 */

/* 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 <tmlib/dprintf.h>
#include <stdio.h>
#include <string.h>

#include <tmlib/tmtypes.h>
#include <tm1/mmio.h>
#include <ops/custom_defs.h>
#include <tm1/tmInterrupts.h>
#include <tm1/tmSSI.h>
#include <tm1/tmAssert.h>
#include <tmlib/AppModel.h>
#include <tm1/tmGPIO.h>

/*-----------------------------defines---------------------------------------*/

#define __SSI_MAGIC         0x75289399

#define check(instance) \
do {\
tmAssert(instance, TMLIBDEV_ERR_NOT_OWNER); \
tmAssert(((pssiInstVars_t)instance)->magic == __SSI_MAGIC, TMLIBDEV_ERR_NOT_OWNER); \
} while (0)

/*-------------------------------types----------------------------------------*/


typedef struct 
{
    UInt32             magic;
    unitSelect_t       unitName;
    ssiInstanceSetup_t ssiSetup;
    boardSSIConfig_t  *boardSSIConfig;
    Int                gpioInstance;
} ssiInstVars_t, *pssiInstVars_t;

typedef struct
{
    UInt32 numberOfUnits;
    ssiCapabilities_t *unitCapabilities;
} ssiCapabilitiesList_t;


/*------------------------local, static variables----------------------------*/

/*
 * Function         : ssiGetCapabilities
 * Parameters       : Pointer to a capabilities structure.
 * Function Result  : TMLIBDEV_OK on success,
 * Side Effects     : Fills in the contents of the ssiCapabilities_t
 *                      structure to describe the capabilities
 */
static ssiCapabilitiesList_t ssiCaps =
{
    0, /* number of units */
    Null /* array of capabilities */
};

/*---------------------- static functions -----------------------------*/
static tmLibdevErr_t prepareCapabilities(void);


/*--------------------- external functions ----------------------------*/

extern tmLibdevErr_t ssiGetNumberOfUnits(UInt32 *pNumberOfUnits)
{
    UInt32 i= 0;
    boardSSIConfig_t *dummyConfig;

    tmAssert(pNumberOfUnits, TMLIBDEV_ERR_NULL_PARAMETER); 
    
    while (tsaBoardGetSSI(i, &dummyConfig) == TMLIBDEV_OK)
        i++;
    *pNumberOfUnits = i;
    return TMLIBDEV_OK;
}

extern tmLibdevErr_t
ssiGetCapabilities(pssiCapabilities_t *pCap)
{
    return ssiGetCapabilitiesM(pCap, unit0);
}

extern tmLibdevErr_t
ssiGetCapabilitiesM(pssiCapabilities_t *pCap, unitSelect_t unitName)
{
    tmLibdevErr_t err;

    tmAssert(pCap, TMLIBDEV_ERR_NULL_PARAMETER);

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

    if (unitName >= ssiCaps.numberOfUnits)
    {
        err = TMLIBDEV_ERR_NOT_AVAILABLE_IN_HW;
        goto ssiGetCapabilitiesMExit;
    }
    *pCap = &ssiCaps.unitCapabilities[unitName];

ssiGetCapabilitiesMExit:
    AppModel_resume_scheduling();
    return err;
}

static tmLibdevErr_t prepareCapabilities(void)
{
    UInt32            numberOfUnits, i;
    boardSSIConfig_t *SSIConfig;
    tmLibdevErr_t     err;
    
    if (ssiCaps.unitCapabilities == Null)
    {
        if (err = ssiGetNumberOfUnits(&numberOfUnits) != TMLIBDEV_OK)
            return err;
        
        if (numberOfUnits == 0)
        {
            return TMLIBDEV_ERR_NOT_AVAILABLE_IN_HW;
        }
        
        ssiCaps.numberOfUnits = numberOfUnits;
        ssiCaps.unitCapabilities = (pssiCapabilities_t) malloc(ssiCaps.numberOfUnits * sizeof(ssiCapabilities_t));
        if (ssiCaps.unitCapabilities == Null)
            return TMLIBDEV_ERR_MEMALLOC_FAILED;
        for (i = 0; i < ssiCaps.numberOfUnits; i++)
        {
            if (TMLIBDEV_OK != tsaBoardGetSSI(i, &SSIConfig))
            {
                /* this should never happen */
                /* FIXME. PANIC !!! */
                return TMLIBDEV_ERR_NOT_AVAILABLE_IN_HW;
            }
            ssiCaps.unitCapabilities[i].version.majorVersion = MAJOR_VERSION;
            ssiCaps.unitCapabilities[i].version.minorVersion = MINOR_VERSION;
            ssiCaps.unitCapabilities[i].version.buildVersion = BUILD_VERSION;
            
            ssiCaps.unitCapabilities[i].numSupportedInstances = 1;
            ssiCaps.unitCapabilities[i].numCurrentInstances   = 0;
            
            ssiCaps.unitCapabilities[i].connectionFlags = SSIConfig->connectionFlags;
            if (SSIConfig->afeName != Null)
            {
                strncpy(ssiCaps.unitCapabilities[i].afeName,
                        SSIConfig->afeName, DEVICE_NAME_LENGTH);
            }
            else
            {
                strncpy(ssiCaps.unitCapabilities[i].afeName,
                        "Unknown AFE", DEVICE_NAME_LENGTH);
            }
        }
    }
    return TMLIBDEV_OK;
}

extern tmLibdevErr_t ssiOpen(Int *instance)
{
    return ssiOpenM(instance, unit0);
}


/*
 * Function         : ssiOpenM
 * Parameters       : instance (O):  pointer to instance value to be filled in.
 * Function Result  : TMLIBDEV_OK on success,
 *                    TMLIBDEV_ERR_NOT_OWNER if SSI is already open.
 * Precondition     : instance must be a valid pointer to Int.
 */
extern tmLibdevErr_t 
ssiOpenM(Int * instance, unitSelect_t unitName)
{
    gpioInstanceSetup_t gpioSetup;
    UInt                ien;
    tmLibdevErr_t       err;
    boardSSIConfig_t   *ssiBoardConfig;
    pssiInstVars_t      instVars;
    UInt32              i;
    
    tmAssert(instance, TMLIBDEV_ERR_NULL_PARAMETER);
    
    err = tsaBoardGetSSI(unitName, &ssiBoardConfig);
        
    if (err != TMLIBDEV_OK)
        return TMLIBDEV_ERR_NOT_AVAILABLE_IN_HW;

    ien = intCLEAR_IEN(); /* no calls here do no need for AppModel overhead */
                          /* ?? so who cares, it's just an open function ?? */

    err = prepareCapabilities();
    if (err != TMLIBDEV_OK)
    {
        goto ssiOpenExit;
    }

    if (ssiCaps.unitCapabilities[unitName].numCurrentInstances >=
        ssiCaps.unitCapabilities[unitName].numSupportedInstances)
    {
        err = TMLIBDEV_ERR_NO_MORE_INSTANCES;
        goto ssiOpenExit;
    }

    ssiCaps.unitCapabilities[unitName].numCurrentInstances++;

    instVars = (pssiInstVars_t) malloc(sizeof(ssiInstVars_t));
    if (instVars == Null)
    {
        err = TMLIBDEV_ERR_MEMALLOC_FAILED;
        goto ssiOpenExit;
    }
        
    /* 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 = ssiBoardConfig->gpioFirstPin; i <= ssiBoardConfig->gpioLastPin; i++)
        {
            gpioInsertMode(gpioSetup.pinMode[i >> 4], 
                           i - (ssiBoardConfig->gpioFirstPin & 0xfffffff0), 
                           gpioRegularMode);
            gpioInsertPin(gpioSetup.pinMask[i >> 5], 
                          i - (ssiBoardConfig->gpioFirstPin & 0xffffffe0), 1);
        }
        err = gpioInstanceSetup(instVars->gpioInstance, &gpioSetup);