syslib.c

vxworks MPC8541 BSP

    _func_speProbeRtn = sysSpeProbe;
#endif  /* INCLUDE_SPE */

    }

/******************************************************************************
*
* 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: NA
*
* 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 the 8260Ads
*
* 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 the 8260Ads
*
* 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 the 8260Ads.
*
* 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: NA
*/

void sysBusClearTas
    (
    volatile char * address	/* address to be tested-and-cleared */
    )
    {
    } 
#ifdef INCLUDE_MOT_TSEC_END
/*******************************************************************************
*
* sysFccEnetAddrGet - get the hardware Ethernet address
*
* This routine provides the six byte Ethernet hardware address that will be
* used by each individual FCC device unit.  This routine must copy
* the six byte address to the space provided by <addr>.
*
* RETURNS: OK, or ERROR if the Ethernet address cannot be returned.
*/
 
STATUS sysTsecEnetAddrGet
    (
    int         unit,      	/* base address of the on-chip RAM */
    UCHAR *     addr            /* where to copy the Ethernet address */
    )
    {
    if(unit == 0)
    {
        if (OK != bspoutBandMac(addr))
            bcopy ((char *) &sysoutbandmacAddr, (char *) addr, 6);
        else
            bcopy ((char *) addr,(char *) &sysoutbandmacAddr,6);

        bcopy (sysoutbandmacAddr,(char *) &sysTsecEnetAddr[0],6);
   }
    else if(unit == 1)
    {
        bcopy ((char *) &sysTsecEnetAddr[1][0], (char *) addr, 6);
    }

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

#ifdef INCLUDE_MOT_FCC_END
/*******************************************************************************
*
* sysFccEnetAddrGet - get the hardware Ethernet address
*
* This routine provides the six byte Ethernet hardware address that will be
* used by each individual FCC device unit.  This routine must copy
* the six byte address to the space provided by <addr>.
*
* RETURNS: OK, or ERROR if the Ethernet address cannot be returned.
*/
 
STATUS sysFccEnetAddrGet
    (
    int         unit,      	/* base address of the on-chip RAM */
    UCHAR *     addr            /* where to copy the Ethernet address */
    )
    {
#if 0
    /*fm modify on 2006-8-22 11:54*/
    if(unit == 1)
    {
    	sysFccEnetAddr[unit][5] = physSlotNumber();
    }
    /*fm modify end on 2006-8-22 11:55*/
    bcopy ((char *) &sysFccEnetAddr[unit][0], (char *) addr, 6);
 
    bcopy ((char *) &sysFccEnetAddr[0][0], (char *) sysEnetMacAddr, 6);
    bcopy ((char *) &sysFccEnetAddr[1][0], (char *) sysMBEnetMacAddr, 6);
#else
    if(unit == 0)
    {
        bspBbMac(sysFccEnetAddr[0]);
        bcopy ((char *) &sysFccEnetAddr[0][0], (char *) sysEnetMacAddr, 6);
    }
    else if(unit == 1)
    {
        bspMbMac(sysFccEnetAddr[1]);
        bcopy ((char *) &sysFccEnetAddr[1][0], (char *) sysMBEnetMacAddr, 6);
    }
    bcopy ((char *) &sysFccEnetAddr[unit][0], (char *) addr, 6);

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


#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 configuratation
*  
* RETURN: N/A
*/

void sysPciConfigEnable 
    (
    int pciHost
    )
    {
    int level;

    level = intLock ();

    if (pciHost == 2)
        {
        sysPciConfAddr = PCI2_CFG_ADR_REG;   /* PCI Configuration Address */
        sysPciConfData = PCI2_CFG_DATA_REG;  /* PCI Configuration Data */
        }
    else /* default is for PCI 1 host */
        {
        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;

    pciRegWrite ((UINT32 *)sysPciConfAddr,
		 (UINT32)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 == 0x1f) /* simulator doesn't like this device being used */)
        return (ERROR);

    switch (width)
        {
        case 1:	/* byte */
            pciRegWrite ((UINT32 *)sysPciConfAddr,
			 (UINT32)pciConfigBdfPack (busNo, deviceNo, funcNo) |
			 (offset & 0xfc) | 0x80000000);
            
            retValByte = PCI_IN_BYTE (sysPciConfData + (offset & 0x3));
            *((UINT8 *)pData) = retValByte;
	    retStat = OK;
            break;

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

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

        case 4: /* long */
	    pciRegWrite ((UINT32 *)sysPciConfAddr,
			 (UINT32)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 == 0x1f))
        return (ERROR);

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

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

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

        default:
            return (ERROR);
            
        }
    return (OK);
    }
#endif /* INCLUDE_PCI */

/* 060701 lyf add */
/*******************************************************************************
*
* dbgSerInit - prepare the string out by  polling mode
*
* This routine prepares the dbgSerChan handler for the fucntion dbgSerOutstr
*
* RETURNS: N/A
* zhaokai 2004-4-16
*/

void dbgSerInit (void)
    {
    dbgSerChan = sysSerialChanGet(0);
#if 1
    /*sioIoctl(dbgSerChan, SIO_MODE_SET, (void *)SIO_MODE_POLL);*/
    sioIoctl(dbgSerChan, SIO_BAUD_SET, (void *)9600);
#endif
    }

/*******************************************************************************
*
* dbgSerOutstr - Send a string out the serial port using polled I/O
*
* This routine sends the specified string out the serial port using
* polled I/O. Note that for proper display on terminals, lines of
* text should be terminated with a carriage return as well as a line feed.
*
* RETURNS: N/A
* zhaokai 2004-4-16
*/

void dbgSerOutstr
    (
    char *str             /* String to be output */
    )
    {
    int ii;
    while (*str)
        {
        while (sioPollOutput(dbgSerChan, *str) == EAGAIN)
            continue;
        for (ii=0; ii < 900; ii++)
            ;
        str++;
        }
    }
/* end lyf add */

/******************************************************************************
*
* sysUsDelay - delay at least the specified amount of time (in microseconds)
*
* This routine will delay for at least the specified amount of time using the
* lower 32 bit "word" of the Time Base register as the timer.  
*
* NOTE:  This routine will not relinquish the CPU; it is meant to perform a
* busy loop delay.  The minimum delay that this routine will provide is
* approximately 10 microseconds.  The maximum delay is approximately the
* size of UINT32; however, there is no roll-over compensation for the total
* delay time, so it is necessary to back off two times the system tick rate
* from the maximum.
*
* RETURNS: N/A
*/

void sysUsDelay
    (
    UINT32    delay        /* length of time in microsec to delay */
    )
    {
    register UINT baselineTickCount;
    register UINT curTickCount;
    register UINT terminalTickCount;
    register int actualRollover = 0;
    register int calcRollover = 0;
    UINT ticksToWait;
    UINT requestedDelay;
    UINT oneUsDelay;

    /* Exit if no delay count */

    if ((requestedDelay = delay) == 0)
        return;

    /*
     * Get the Time Base Lower register tick count, this will be used
     * as the baseline.
     */

    baselineTickCount = sysTimeBaseLGet();

    /*
     * Calculate number of ticks equal to 1 microsecond
     *
     * The Time Base register and the Decrementer count at the same rate:
     * once per 8 System Bus cycles.
     *
     * e.g., 199999999 cycles     1 tick      1 second            25 ticks
     *       ----------------  *  ------   *  --------         ~  --------
     *       second               8 cycles    1000000 microsec    microsec
     */

    /* add to round up before div to provide "at least" */
    oneUsDelay = ((sysTimerClkFreq + 1000000) / 1000000);

    /* Convert delay time into ticks */

    ticksToWait = requestedDelay * oneUsDelay;

    /* Compute when to stop */

    terminalTickCount = baselineTickCount + ticksToWait;

    /* Check for expected rollover */

    if (terminalTickCount < baselineTickCount)
        {
        calcRollover = 1;
        }

    do
        {

        /*
         * Get current Time Base Lower register count.
         * The Time Base counts UP from 0 to
         * all F's.
         */

        curTickCount = sysTimeBaseLGet();

        /* Check for actual rollover */

        if (curTickCount < baselineTickCount)
            {
            actualRollover = 1;
            }

        if (((curTickCount >= terminalTickCount)
	     && (actualRollover == calcRollover)) ||
            ((curTickCount < terminalTickCount)
	     && (actualRollover > calcRollover)))
            {

            /* Delay time met */