universe_dy4.c

Curtiss-Wright Controls Embedded Computing公司的cw183板bsp源代码

        return (ERROR);
    }


    /* Check VME Register slave window first */
    if ((vmeData->sysVmeSlaveRegDesc.attributes & mask) == value)
    {
        if (((UINT32)localAdrs >=  (UINT32)vmeData->sysVmeSlaveRegDesc.localAdrs) &&
            ((UINT32)localAdrs <  ((UINT32)vmeData->sysVmeSlaveRegDesc.localAdrs + vmeData->sysVmeSlaveRegDesc.size)))
        {
            *pBusAdrs = (char*) ((UINT32)vmeData->sysVmeSlaveRegDesc.vmeBase + 
                                 ((UINT32)localAdrs-(UINT32)vmeData->sysVmeSlaveRegDesc.localAdrs));
            return (OK);
        }
    }

    /* Check the other slave image*/
    for (image=0; image<UNIVERSE_VME_SLAVE_IMAGES;image++)
    {

        if (((UINT32)vmeData->sysVmeSlaveDesc[image].attributes & mask) == value)
        {
            if (((UINT32)localAdrs >=  (UINT32)vmeData->sysVmeSlaveDesc[image].localAdrs) &&
                ((UINT32)localAdrs <  (UINT32)vmeData->sysVmeSlaveDesc[image].localAdrs+(UINT32)vmeData->sysVmeSlaveDesc[image].size))
            {
                *pBusAdrs = (char*) ((UINT32)vmeData->sysVmeSlaveDesc[image].vmeBase + 
                                     ((UINT32)localAdrs-(UINT32)vmeData->sysVmeSlaveDesc[image].localAdrs));
                return (OK);
    
            }
        }
    }
    *pBusAdrs = NULL;
    return (ERROR);

}


/******************************************************************************
*
* sysLocalToBusAdrs - convert a local address to a bus address
*
* This routine returns a VMEbus address as it would be seen on the bus.
* The local address that is passed into this routine is the address of
* the local resource as seen by the CPU.
*
* Notes: 
*
*
* RETURNS: OK, or ERROR if the address space is unknown or the mapping is not
* possible.
*
* SEE ALSO: sysBusToLocalAdrs()
*/

STATUS sysLocalToBusAdrs
    (
    int     adrsSpace,  /* bus address space where busAdrs resides */
    char *  localAdrs,  /* local address to convert */
    char ** pBusAdrs    /* where to return bus address */
    )
    {
    UINT32 mask;
    UINT32 value;

    if (vmeData->signature != VME_SHARED_DATA_SIG)
    {
        return (ERROR);
    }

    /* return bus address variable should not point to NULL */
    if (pBusAdrs == NULL)
    {
        return (ERROR);
    }


    switch (adrsSpace)
        {
        case VME_AM_EXT_USR_DATA:
            mask  =  (VME_SLV_CTL_VAS_MSK |  VME_SLV_CTL_EN |  VME_SLV_CTL_AM_DATA |  VME_SLV_CTL_AM_USR);
            value =  ( VME_SLV_CTL_A32 |  VME_SLV_CTL_EN |  VME_SLV_CTL_AM_DATA |  VME_SLV_CTL_AM_USR);
        break;

        case VME_AM_EXT_USR_PGM:
            mask  =  ( VME_SLV_CTL_VAS_MSK |  VME_SLV_CTL_EN |  VME_SLV_CTL_AM_PGM |  VME_SLV_CTL_AM_USR);
            value =  ( VME_SLV_CTL_A32 |  VME_SLV_CTL_EN |  VME_SLV_CTL_AM_PGM |  VME_SLV_CTL_AM_USR);
        break;

        case VME_AM_EXT_SUP_DATA:
            mask  =  ( VME_SLV_CTL_VAS_MSK |  VME_SLV_CTL_EN |  VME_SLV_CTL_AM_DATA |  VME_SLV_CTL_AM_SUP);
            value =  ( VME_SLV_CTL_A32 |  VME_SLV_CTL_EN |  VME_SLV_CTL_AM_DATA |  VME_SLV_CTL_AM_SUP);
        break;

        case VME_AM_EXT_SUP_PGM:
            mask  =  ( VME_SLV_CTL_VAS_MSK |  VME_SLV_CTL_EN |  VME_SLV_CTL_AM_PGM |  VME_SLV_CTL_AM_SUP);
            value =  ( VME_SLV_CTL_A32 |  VME_SLV_CTL_EN |  VME_SLV_CTL_AM_PGM |  VME_SLV_CTL_AM_SUP);
        break;

        case VME_AM_STD_USR_DATA:
            mask  =  ( VME_SLV_CTL_VAS_MSK |  VME_SLV_CTL_EN |  VME_SLV_CTL_AM_DATA |  VME_SLV_CTL_AM_USR);
            value =  ( VME_SLV_CTL_A24 |  VME_SLV_CTL_EN |  VME_SLV_CTL_AM_DATA |  VME_SLV_CTL_AM_USR);
        break;

        case VME_AM_STD_USR_PGM:
            mask  =  ( VME_SLV_CTL_VAS_MSK |  VME_SLV_CTL_EN |  VME_SLV_CTL_AM_PGM |  VME_SLV_CTL_AM_USR);
            value =  ( VME_SLV_CTL_A24 |  VME_SLV_CTL_EN |  VME_SLV_CTL_AM_PGM |  VME_SLV_CTL_AM_USR);
        break;

        case VME_AM_STD_SUP_DATA:
            mask  =  ( VME_SLV_CTL_VAS_MSK |  VME_SLV_CTL_EN |  VME_SLV_CTL_AM_DATA |  VME_SLV_CTL_AM_SUP);
            value =  ( VME_SLV_CTL_A24 |  VME_SLV_CTL_EN |  VME_SLV_CTL_AM_DATA |  VME_SLV_CTL_AM_SUP);
        break;

        case VME_AM_STD_SUP_PGM:
            mask  =  ( VME_SLV_CTL_VAS_MSK |  VME_SLV_CTL_EN |  VME_SLV_CTL_AM_PGM |  VME_SLV_CTL_AM_SUP);
            value =  ( VME_SLV_CTL_A24 |  VME_SLV_CTL_EN |  VME_SLV_CTL_AM_PGM |  VME_SLV_CTL_AM_SUP);
        break;

        case VME_AM_USR_SHORT_IO:
            mask  =  ( VME_SLV_CTL_VAS_MSK |  VME_SLV_CTL_EN |  VME_SLV_CTL_AM_USR);
            value =  ( VME_SLV_CTL_A16 |  VME_SLV_CTL_EN |  VME_SLV_CTL_AM_USR);
        break;

        case VME_AM_SUP_SHORT_IO:
            mask  =  ( VME_SLV_CTL_VAS_MSK |  VME_SLV_CTL_EN |  VME_SLV_CTL_AM_SUP);
            value =  ( VME_SLV_CTL_A16 |  VME_SLV_CTL_EN |  VME_SLV_CTL_AM_SUP);
        break;

        default:
            *pBusAdrs = NULL;
            return (ERROR);
        }

        return (vmeFindBusAdrs(mask,value,localAdrs,pBusAdrs));
    }


/******************************************************************************
*
* vmeFindLocalAdrs - determine the local address corresponding to a vme adrs
*
* This private routine searches a local address corresponding to the vme address
* in the regular PCI Slave images.
*
*
* RETURNS: OK, or ERROR if the address space is unknown or the mapping is not
* possible.
*
* SEE ALSO: sysBusToLocalAdrs()
*/

LOCAL STATUS vmeFindLocalAdrs(
                                UINT32  mask,       /* Control register mask */
                                UINT32  value,      /* Control register expected value */
                                char *  vmeAdrs,    /* vme address to convert */
                                char ** pLocalAdrs  /* where to return local address */
                            )
{
    UINT32 image;
    /* return local address variable should not point to NULL */
    if (pLocalAdrs == NULL)
    {
        return (ERROR);
    }

    /* Check regular PCI slave window */

    for (image=0; image<UNIVERSE_PCI_SLAVE_IMAGES;image++)
    {
        if (((UINT32)vmeData->sysPciSlaveDesc[image].attributes & mask) == value)
        {
            if (((UINT32)vmeAdrs >=  (UINT32)vmeData->sysPciSlaveDesc[image].vmeBase) &&
                ((UINT32)vmeAdrs <  (UINT32)vmeData->sysPciSlaveDesc[image].vmeBase+(UINT32)vmeData->sysPciSlaveDesc[image].size))
            {
                *pLocalAdrs = (char*) ((UINT32)vmeData->sysPciSlaveDesc[image].localAdrs + 
                                     ((UINT32)vmeAdrs-(UINT32)vmeData->sysPciSlaveDesc[image].vmeBase));
                return (OK);
            }
        }
    }

    *pLocalAdrs = NULL;
    return (ERROR);

}
/******************************************************************************
*
* vmeFindLocalAdrsSpecial - determine the local address corresponding to a vme adrs
*
* This private routine searches a local address corresponding to the vme address
* in the special PCI Slave images. Only A16 and A24 address mode are supported
* by this window.
*
*
* RETURNS: OK, or ERROR if the address space is unknown or the mapping is not
* possible.
*
* SEE ALSO: sysBusToLocalAdrs()
*/
LOCAL STATUS vmeFindLocalAdrsSpecial(UINT32 admode, UINT32 mask, UINT32 value, char* busAdrs, char** pLocalAdrs)
{

    UINT32 image;

    if ((vmeData->sysPciSlaveSpeDesc.attributes & VME_CTL_EN) != VME_CTL_EN)
    {
        *pLocalAdrs=(char*)NULL;
        return (ERROR);
    }

    for (image=0; image<UNIVERSE_SPECIAL_PCI_SLAVE_IMAGES; image++)
    {
        if ((vmeData->sysPciSlaveSpeDesc.attributes & (mask << image)) == (value << image))
        {
            if (admode == VME_SPE_A16)
            {
                *pLocalAdrs=(char*)((vmeData->sysPciSlaveSpeDesc.localAdrs)+(UINT32)busAdrs
                            +((image+1)*A24ADRSRANGE)-A16ADRSRANGE);
                return(OK);
            }
            else if (admode == VME_SPE_A24)
            {
                if ((UINT32)busAdrs>=(A24ADRSRANGE-A16ADRSRANGE))
                {
                    *pLocalAdrs=(char*)NULL;
                    return (ERROR);
                }
                *pLocalAdrs=(char*)((vmeData->sysPciSlaveSpeDesc.localAdrs)+(UINT32)busAdrs
                            +(image)*A24ADRSRANGE);
                return(OK);
            }
        }
    }
    *pLocalAdrs=(char*)NULL;
    return (ERROR);
}

/******************************************************************************
*
* sysBusToLocalAdrs - convert a bus address to a local address
*
* This routine returns a local address that is used to access the VMEbus.
* The bus address that is passed into this routine is the VMEbus address
* as it would be seen on the bus.
* Notes:
* -If the passed busadrs is A24 or A16, this function will use PCI Special image 0 
* -If the passed busAdrs exsists in Reg Access window, this function will return 
*  in pLocalAdrs the Universe IO Base address
* -This function supports only the default BSP VME/PCI slave images 
* -No distinction on SUP/USR and PGM/DATA AM codes
* RETURNS: OK, or ERROR if the address space is unknown or the mapping is not
* possible.
*
* SEE ALSO: sysLocalToBusAdrs()
*/


STATUS sysBusToLocalAdrs
    (
    int     adrsSpace,  /* bus address space where busAdrs resides */
    char *  busAdrs,    /* bus address to convert */
    char ** pLocalAdrs  /* where to return local address */
    )
    {
    UINT32 mask;
    UINT32 value;

    if (vmeData->signature != VME_SHARED_DATA_SIG)
    {
        return (ERROR);
    }

    /* return bus address variable should not point to NULL */
    if (pLocalAdrs == (char**)NULL)
    {
        return (ERROR);
    }
    /* validate VME address for A16 and A24*/
    switch (adrsSpace)
        {
        case VME_AM_STD_USR_DATA:
        case VME_AM_STD_USR_PGM:
        case VME_AM_STD_SUP_DATA:
        case VME_AM_STD_SUP_PGM:
            /* Only first 24 bits of address is valid (2^24) */
            if ((UINT32)busAdrs >= A24ADRSRANGE)
            {
                /* Adress out of range */
                *pLocalAdrs=(char*)NULL;
                return (ERROR);
            }
        break;

        case VME_AM_USR_SHORT_IO:
        case VME_AM_SUP_SHORT_IO:
        /* Only first 16 bits of address is valid (2^16) */
        if ((UINT32)busAdrs >= A16ADRSRANGE)
        {
            /* Adress out of range */
            *pLocalAdrs=(char*)NULL;
            return (ERROR);
        }
        break;

        default:
        break;
        }

    /* Prepare to compute the LocalAdrs */
    switch (adrsSpace)
        {
        case VME_AM_EXT_USR_DATA:
            mask  =  (VME_CTL_VAS_MSK | VME_CTL_EN | VME_CTL_PGM | VME_CTL_SUP);
            value =  (VME_CTL_A32 | VME_CTL_EN | VME_CTL_DATA | VME_CTL_USR);
            /* Find the local Adrs and return */
            return (vmeFindLocalAdrs(mask,value,busAdrs,pLocalAdrs));
        break;

        case VME_AM_EXT_USR_PGM:
            mask  =  (VME_CTL_VAS_MSK | VME_CTL_EN | VME_CTL_PGM | VME_CTL_SUP);
            value =  (VME_CTL_A32 | VME_CTL_EN | VME_CTL_PGM | VME_CTL_USR);
            /* Find the local Adrs and return */
            return (vmeFindLocalAdrs(mask,value,busAdrs,pLocalAdrs));
        break;

        case VME_AM_EXT_SUP_DATA:
            mask  =  (VME_CTL_VAS_MSK | VME_CTL_EN | VME_CTL_PGM | VME_CTL_SUP);
            value =  (VME_CTL_A32 | VME_CTL_EN | VME_CTL_DATA | VME_CTL_SUP);
            /* Find the local Adrs and return */
            return (vmeFindLocalAdrs(mask,value,busAdrs,pLocalAdrs));
        break;

        case VME_AM_EXT_SUP_PGM:
            mask  =  (VME_CTL_VAS_MSK | VME_CTL_EN | VME_CTL_PGM | VME_CTL_SUP);
            value =  (VME_CTL_A32 | VME_CTL_EN | VME_CTL_PGM | VME_CTL_SUP);
            /* Find the local Adrs and return */
            return (vmeFindLocalAdrs(mask,value,busAdrs,pLocalAdrs));
        break;

        case VME_AM_STD_USR_DATA:
            mask  =  (VME_CTL_VAS_MSK | VME_CTL_EN | VME_CTL_PGM | VME_CTL_SUP);
            value =  (VME_CTL_A24 | VME_CTL_EN | VME_CTL_DATA | VME_CTL_USR);
            if (vmeFindLocalAdrs(mask,value,busAdrs,pLocalAdrs)==OK)
            {
                return (OK);
            }
            mask  =  (VME_SPE_CTL_PGM | VME_SPE_CTL_SUP);
            value =  (VME_SPE_CTL_DTA | VME_SPE_CTL_USR);
            return (vmeFindLocalAdrsSpecial(VME_SPE_A24,mask,value,busAdrs,pLocalAdrs));
        break;

        case VME_AM_STD_USR_PGM:
            mask  =  (VME_CTL_VAS_MSK | VME_CTL_EN | VME_CTL_PGM | VME_CTL_SUP);
            value =  (VME_CTL_A24 | VME_CTL_EN | VME_CTL_PGM | VME_CTL_USR);
            if (vmeFindLocalAdrs(mask,value,busAdrs,pLocalAdrs)==OK)
            {
                return (OK);
            }
            mask  =  (VME_SPE_CTL_PGM | VME_SPE_CTL_SUP);
            value =  (VME_SPE_CTL_PGM | VME_SPE_CTL_USR);
            return (vmeFindLocalAdrsSpecial(VME_SPE_A24,mask,value,busAdrs,pLocalAdrs));
        break;

        case VME_AM_STD_SUP_DATA:
            mask  =  (VME_CTL_VAS_MSK | VME_CTL_EN | VME_CTL_PGM | VME_CTL_SUP);
            value =  (VME_CTL_A24 | VME_CTL_EN | VME_CTL_DATA | VME_CTL_SUP);
            if (vmeFindLocalAdrs(mask,value,busAdrs,pLocalAdrs)==OK)
            {
                return (OK);
            }
            mask  =  (VME_SPE_CTL_PGM | VME_SPE_CTL_SUP);
            value =  (VME_SPE_CTL_DTA | VME_SPE_CTL_SUP);
            return (vmeFindLocalAdrsSpecial(VME_SPE_A24,mask,value,busAdrs,pLocalAdrs));
        break;

        case VME_AM_STD_SUP_PGM:
            mask  =  (VME_CTL_VAS_MSK | VME_CTL_EN | VME_CTL_PGM | VME_CTL_SUP);
            value =  (VME_CTL_A24 | VME_CTL_EN | VME_CTL_PGM | VME_CTL_SUP);
            if (vmeFindLocalAdrs(mask,value,busAdrs,pLocalAdrs)==OK)
            {
                return (OK);
            }
            mask  =  (VME_SPE_CTL_PGM | VME_SPE_CTL_SUP);
            value =  (VME_SPE_CTL_PGM | VME_SPE_CTL_SUP);
            return (vmeFindLocalAdrsSpecial(VME_SPE_A24,mask,value,busAdrs,pLocalAdrs));
        break;

        case VME_AM_USR_SHORT_IO:
            mask  =  (VME_CTL_VAS_MSK | VME_CTL_EN | VME_CTL_SUP);
            value =  (VME_CTL_A16 | VME_CTL_EN | VME_CTL_USR);
            if (vmeFindLocalAdrs(mask,value,busAdrs,pLocalAdrs)==OK)
            {
                return (OK);
            }
            mask  =  (VME_SPE_CTL_SUP);
            value =  (VME_SPE_CTL_USR);
            return (vmeFindLocalAdrsSpecial(VME_SPE_A16,mask,value,busAdrs,pLocalAdrs));
        break;

        case VME_AM_SUP_SHORT_IO:
            mask  =  (VME_CTL_VAS_MSK | VME_CTL_EN | VME_CTL_SUP);
            value =  (VME_CTL_A16 | VME_CTL_EN | VME_CTL_SUP);