syslib.c

Freescale mpc834x 的VxWorks平台的BSP源代码。

*
*/

void sysMsDelay
    (
    uint32_t        delay                   /* length of time in MS to delay */
    )
    {
    register UINT oldval;               /* decrementer value */
    register UINT newval;               /* decrementer value */
    register UINT totalDelta;           /* Dec. delta for entire delay period */
    register UINT decElapsed;           /* cumulative decrementer ticks */

    /*
     * Calculate delta of decrementer ticks for desired elapsed time.
     */

    totalDelta = (sysBaudClkFreq() / 1000) * delay;

    /*
     * Now keep grabbing decrementer value and incrementing "decElapsed" until
     * we hit the desired delay value.  Compensate for the fact that we may
     * read the decrementer at 0xffffffff before the interrupt service
     * routine has a chance to set in the rollover value.
     */

    decElapsed = 0;

    oldval = vxDecGet ();

    while (decElapsed < totalDelta)
        {
        newval = vxDecGet ();

        if ( DELTA(oldval,newval) < 1000 )
            decElapsed += DELTA(oldval,newval);  /* no rollover */
        else
            if (newval > oldval)
                decElapsed += abs((int)oldval);  /* rollover */

        oldval = newval;
        }
    }


/*********************************************************************
*
* sysDelay - fixed 1ms delay
*
* This routine calls sysMsDelay.
*
* RETURNS: N/A
*
*/

void sysDelay (void)
    {
    sysMsDelay (1);
    }

/******************************************************************************
*
* sysProcNumGet - get the processor number
*
* This routine returns the processor number for the CPU board, which is
* set with sysProcNumSet().
*
* RETURNS: The processor number for the CPU board.
*
* SEE ALSO: sysProcNumSet()
*/

int sysProcNumGet (void)
    {
    return (sysProcNum);
    }

/******************************************************************************
*
* sysProcNumSet - set the processor number
*
* This routine sets the processor number for the CPU board.  Processor numbers
* should be unique on a single backplane.
*
* Not applicable for the busless 8260Ads.
*
* RETURNS: N/A
*
* SEE ALSO: sysProcNumGet()
*
*/

void sysProcNumSet
    (
    int     procNum         /* processor number */
    )
    {
    sysProcNum = procNum;
    }

/******************************************************************************
*
* sysLocalToBusAdrs - convert a local address to a bus address
*
* This routine gets the VMEbus address that accesses a specified local
* memory address.
*
* Not applicable for this BSP.
*
* RETURNS: ERROR, always.
*
* 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 */
    )
    {
    return (ERROR);
    }

/******************************************************************************
*
* sysBusToLocalAdrs - convert a bus address to a local address
*
* This routine gets the local address that accesses a specified VMEbus
* physical memory address.
*
* Not applicable for this BSP.
*
* RETURNS: ERROR, always.
*
* 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 */
    )
    {
    return (ERROR);
    }

/******************************************************************************
*
* sysBusTas - test and set a location across the bus
*
* This routine does an atomic test-and-set operation across the backplane.
*
* Not applicable for this BSP.
*
* RETURNS: FALSE, always.
*
* SEE ALSO: vxTas()
*/

BOOL sysBusTas
    (
     char * adrs        /* address to be tested-and-set */
    )
    {
    return (FALSE);
    }

/******************************************************************************
*
* sysBusClearTas - test and clear
*
* This routine is a null function.
*
* RETURNS: N/A
*/

void sysBusClearTas
    (
     volatile char * address    /* address to be tested-and-cleared */
    )
    {
    }

#ifdef INCLUDE_SYSLED

/***********************************************************************
*
* sysLedClkRoutine - shows clock activity on LED
*
* This routine blinks the dot on the Hex LED
*
* RETURNS: N/A
*
* ERRNO
*/

void sysLedClkRoutine
    (
    int arg
    )
    {
    static int clkIntCount = 0;
    static INT8 clkCount = 0;

    if((clkIntCount++ % 60) == 0)
        {
        (clkCount++ & 0x1) ?
            sysLedSet(LED_POINT, LED_POINT) : sysLedSet(LED_POINT, 0);
        }
    }

#endif /* INCLUDE_SYSLED */

/*******************************************************************************
*
* sysSwitchRead - read the status of one of the four user switches
*
*
* \NOMANUAL
*
* RETURNS: OK
*/

STATUS sysSwitchRead
    (
    int switchNo
    )
    {
    int switchStatus;


    switch (switchNo)
        {
        case 1:
            switchStatus = ((*M83XX_GP1DAT(CCSBAR) & 0x80000000) >> 31);
            break;

        case 2:
            switchStatus = ((*M83XX_GP1DAT(CCSBAR) & 0x40000000) >> 30);
            break;

        case 3:
            switchStatus = ((*M83XX_GP1DAT(CCSBAR) & 0x20000000) >> 29);
            break;

        case 4:
            switchStatus = ((*M83XX_GP1DAT(CCSBAR) & 0x10000000) >> 28);
            break;

        default:
            printf("Invalid user switch number: %d. Only switches 1-4 are available.\n", switchNo);
            return(ERROR);

        }

    if (switchStatus == 1)
       printf("User switch %d is ON\n", switchNo);
    else
       printf("User switch %d is OFF\n", switchNo);

    return(switchStatus);

    }


#ifdef INCLUDE_PCI  /* board level PCI routines */
/*******************************************************************************
* sysPciConfigEnable -  enable PCI 1 or PCI 2 bus configuration
*
* This function enables PCI 1 or PCI 2 bus configuration
*
* RETURNS: N/A
*/

void sysPciConfigEnable
    (
    int pciHost
    )
    {
    int level;

    level = intLock ();

    sysPciConfAddr = PCI_CFG_ADR_REG;   /* PCI Configuration Address */
    sysPciConfData = PCI_CFG_DATA_REG;  /* PCI Configuration Data */

    WRS_ASM("sync;eieio");
    
   intUnlock (level);
   }	
	
/*******************************************************************************
*
* sysPciSpecialCycle - generate a special cycle with a message
*
* This routine generates a special cycle with a message.
*
* \NOMANUAL
*
* RETURNS: OK
*/

STATUS sysPciSpecialCycle
    (
    int     busNo,
    UINT32  message
    )
    {
    int deviceNo    = 0x0000001f;
    int funcNo      = 0x00000007;

    PCI_OUT_LONG (sysPciConfAddr,
                  pciConfigBdfPack (busNo, deviceNo, funcNo) |
                  0x80000000);

    PCI_OUT_LONG (sysPciConfData, message);

    return (OK);
    }

/*******************************************************************************
*
* sysPciConfigRead - read from the PCI configuration space
*
* This routine reads either a byte, word or a long word specified by
* the argument <width>, from the PCI configuration space
* This routine works around a problem in the hardware which hangs
* PCI bus if device no 12 is accessed from the PCI configuration space.
*
* \NOMANUAL
*
* RETURNS: OK, or ERROR if this library is not initialized
*/

STATUS sysPciConfigRead
    (
    int busNo,    /* bus number */
    int deviceNo, /* device number */
    int funcNo,   /* function number */
    int offset,   /* offset into the configuration space */
    int width,    /* width to be read */
    void * pData /* data read from the offset */
    )
    {
    UINT8  retValByte = 0;
    UINT16 retValWord = 0;
    UINT32 retValLong = 0;
    STATUS retStat = ERROR;

    if ((busNo == 0) && (deviceNo == 12))
        return (ERROR);

    switch (width)
        {
        case 1: /* byte */
            PCI_OUT_LONG (sysPciConfAddr,
                          pciConfigBdfPack (busNo, deviceNo, funcNo) |
                          (offset & 0xfc) | 0x80000000);

            retValByte = PCI_IN_BYTE (sysPciConfData + (offset & 0x3));
            *((UINT8 *)pData) = retValByte;
        retStat = OK;
            break;

        case 2: /* word */
            PCI_OUT_LONG (sysPciConfAddr,
                          pciConfigBdfPack (busNo, deviceNo, funcNo) |
                          (offset & 0xfc) | 0x80000000);

        retValWord = PCI_IN_WORD (sysPciConfData + (offset & 0x2));
            *((UINT16 *)pData) = retValWord;
        retStat = OK;
        break;

        case 4: /* long */
        PCI_OUT_LONG (sysPciConfAddr,
                  pciConfigBdfPack (busNo, deviceNo, funcNo) |
                  (offset & 0xfc) | 0x80000000);
        retValLong = PCI_IN_LONG (sysPciConfData);
            *((UINT32 *)pData) = retValLong;
        retStat = OK;
            break;

        default:
            retStat = ERROR;
            break;
        }

    return (retStat);
    }

/*******************************************************************************
*
* sysPciConfigWrite - write to the PCI configuration space
*
* This routine writes either a byte, word or a long word specified by
* the argument <width>, to the PCI configuration space
* This routine works around a problem in the hardware which hangs
* PCI bus if device no 12 is accessed from the PCI configuration space.
*
* \NOMANUAL
*
* RETURNS: OK, or ERROR if this library is not initialized
*/

STATUS sysPciConfigWrite
    (
    int busNo,    /* bus number */
    int deviceNo, /* device number */
    int funcNo,   /* function number */
    int offset,   /* offset into the configuration space */
    int width,    /* width to write */
    ULONG data    /* data to write */
    )
    {
    if ((busNo == 0) && (deviceNo == 12))
        return (ERROR);

    switch (width)
        {
        case 1: /* byte */
            PCI_OUT_LONG (sysPciConfAddr,
                          pciConfigBdfPack (busNo, deviceNo, funcNo) |
                          (offset & 0xfc) | 0x80000000);
        PCI_OUT_BYTE ((sysPciConfData + (offset & 0x3)), data);
            break;

        case 2: /* word */
            PCI_OUT_LONG (sysPciConfAddr,
                          pciConfigBdfPack (busNo, deviceNo, funcNo) |
                          (offset & 0xfc) | 0x80000000);
        PCI_OUT_WORD ((sysPciConfData + (offset & 0x2)), data);
        break;

        case 4: /* long */
        PCI_OUT_LONG (sysPciConfAddr,
                  pciConfigBdfPack (busNo, deviceNo, funcNo) |
                  (offset & 0xfc) | 0x80000000);
        PCI_OUT_LONG (sysPciConfData, data);
            break;

        default:
            return (ERROR);

        }
    return (OK);
    }
#endif /* INCLUDE_PCI */