sysalib.s

mtx604在vxworks下的bsp源代码

* sysOutByte - writes a byte to an address.
*
* This function writes a byte to a specified address.
*
* From a C point of view, the routine is defined as follows:
*
* RETURNS: N/A
*
* From a C point of view, the routine is defined as follows:

void sysOutByte
    (
    ULONG * addr  /@ address to write data to @/
    UCHAR   data  /@ 8-bit data to write @/
    )

*/

sysOutByte:


	/*	Write a byte to given address */

	stbx	r4,r0,r3

	/*	Sync I/O operation */

	eieio

	/*	Return to caller */

	bclr	20,0

/*****************************************************************************
*
* sysIn16 - reads a 16-bit unsigned value from an address.
*
* This function reads a 16-bit unsigned value from a specified address.
*
* RETURNS: 16-bit unsigned value from address.
*
* From a C point of view, the routine is defined as follows:

UINT16 sysIn16
    (
    UINT16 * addr  /@  address of data @/
    )

*/

sysIn16:

	lhz	3,0(3)
	eieio
	bclr	20,0

/******************************************************************************
*
* sysOut16 - writes a 16-bit unsigned value to an address.
*
* This function writes a 16-bit unsigned value to a specified address.
*
* RETURNS: N/A
*
* From a C point of view, the routine is defined as follows:

void sysOut16
    (
    UINT16 * addr  /@ address to write data to @/
    UINT16   data  /@ 8-bit data @/
    )

*/

sysOut16:

	sth	4,0(3)
	eieio
	bclr	20,0

/*****************************************************************************
*
* sysIn32 - reads a 32-bit unsigned value from an address.
*
* This function reads a 32-bit unsigned value from a specified address.
*
* RETURNS: 32-bit unsigned value from address.
*
* From a C point of view, the routine is defined as follows:
*
UINT32 sysIn32
    (
    UINT32 * addr;  /@ address of data @/
    )

*/

sysIn32:

	lwz	3,0(3)
	eieio
	bclr	20,0

/******************************************************************************
*
* sysOut32 - writes a 32-bit unsigned value to an address.
*
* This function writes a 32-bit unsigned value to a specified address.
*
* RETURNS: N/A
*
* From a C point of view, the routine is defined as follows:

void sysOut32
    (
    UINT32 * addr  /@ address to write data to @/
    UINT32   data  /@ 32-bit data @/
    )

*/

sysOut32:

	stw	4,0(3)
	eieio
	bclr	20,0


/******************************************************************************
*
* sysPciRead32 - read 32 bit PCI data
*
* This routine will read a 32-bit data item from PCI ( I/O or
* memory ) space.
*
* RETURNS: 32-bit big endian data read from PCI space
*
* From a C point of view, the routine is defined as follows:

UINT32 sysPciRead32
    (
    UINT32 * addr  /@ address of data in PCI space @/
    )

*/

sysPciRead32:
        lwbrx   r3,r0,r3        /* get the data and swap the bytes */

	/*	Sync I/O operation */

	eieio
        stw     r3,0(r4)        /* store into address ptd. to by r4 */
        bclr    20,0


/******************************************************************************
*
* sysPciWrite32 - write a 32 bit data item to PCI space
*
* This routine will store a 32-bit data item ( input as big-endian )
* into PCI ( I/O or memory ) space in little-endian mode.  
*
* RETURNS: N/A
*
* From a C point of view, the routine is defined as follows:

void sysPciWrite32
    (
    UINT32 * addr  /@ address to write data to @/
    UINT32   data  /@ 32-bit big-endian data @/
    )

*/

sysPciWrite32:
        stwbrx  r4,r0,r3        /* store data as little-endian */

	/*	Sync I/O operation */

	eieio
        bclr    20,0


/*****************************************************************************
*
* sysPciInByte - reads a byte from PCI Config Space.
*
* This function reads a byte from a specified PCI Config Space address.
*
* RETURNS: byte read from address
*
* From a C point of view, the routine is defined as follows:

UINT8 sysPciInByte
    (
    UINT8 * addr	/@ PCI config space address @/
    )

*/

sysPciInByte:


        /*      Read byte from PCI space */

        lbzx    r3,r0,r3

        /*      Sync I/O operation */

	eieio

        /*      Return to caller */

        bclr    20,0

/*****************************************************************************
*
* sysPciInWord - reads a word (16-bit big-endian) from PCI Config Space.
*
* This function reads a word from a specified PCI Config Space (little-endian)
* address.
*
* RETURNS: word (16-bit big-endian) from address
*
* From a C point of view, the routine is defined as follows:

UINT16 sysPciInWord
    (
    UINT16 * addr        /@ PCI config space address @/
    )

*/

sysPciInWord:


        /*      Read big-endian word from little-endian PCI space */

        lhbrx   r3,r0,r3

        /*      Sync I/O operation */

	eieio

        /*      Return to caller */

        bclr    20,0

/*****************************************************************************
*
* sysPciInLong - reads a long (32-bit big-endian) from PCI Config Space.
*
* This function reads a long from a specified PCI Config Space (little-endian)
* address.
*
* RETURNS: long (32-bit big-endian) read from address
*
* From a C point of view, the routine is defined as follows:

UINT32 sysPciLong
    (
    UINT32 * pPciAddr,          /@ Config Space address @/
    )

*/

sysPciInLong:

        /* Read big-endian long from little-endian PCI space */

        lwbrx   r3,r0,r3

        /* Sync I/O operation */

	eieio

        /* Return to caller */

        bclr    20,0

/******************************************************************************
*
* sysPciOutByte - writes a byte to PCI Config Space.
*
* This function writes a byte to a specified PCI Config Space address.
*
* RETURNS: N/A
*
* From a C point of view, the routine is defined as follows:

void sysPciOutByte
    (
    UINT8 * pPciAddr,          /@ Config Space address @/
    UINT8 dataOut              /@ byte to write @/
    )

*/

sysPciOutByte:

        /*      Write a byte to PCI space */

        stbx    r4,r0,r3

        /*      Sync I/O operation */

	eieio

        /*      Return to caller */

        bclr    20,0

/******************************************************************************
*
* sysPciOutWord - writes a word (16-bit big-endian) to PCI Config Space.
*
* This function writes a word to a specified PCI Config Space (little-endian)
* address.
*
* RETURNS: N/A
*
* From a C point of view, the routine is defined as follows:

void sysPciOutWord
    (
    UINT16 * pPciAddr,          /@ Config Space address @/
    UINT16 dataOut              /@ word (16-bit big-endian) to write @/
    )

*/

sysPciOutWord:


        /*      Write a big-endian word to little-endian PCI space */

        sthbrx  r4,r0,r3

        /*      Sync I/O operation */

	eieio

        /*      Return to caller */

        bclr    20,0

/******************************************************************************
*
* sysPciOutLong - writes a long (32-bit big-endian) to PCI Config Space.
*
* This function writes a long to a specified PCI Config Space (little-endian)
* address.
*
* RETURNS: N/A
*
* From a C point of view, the routine is defined as follows:

void sysPciOutLong
    (
    UINT32 * pPciAddr,		/@ Config Space address @/
    UINT32 dataOut		/@ long (32-bit big-endian) to write @/

*/

sysPciOutLong:


        /*      Write a big-endian long to little-endian PCI space */

        stwbrx  r4,r0,r3

        /*      Sync I/O operation */

        mr      r3,r4
	eieio

        /*      Return to caller */

        bclr    20,0

/*******************************************************************************
*
* sysMemProbeSup - sysBusProbe support routine
*
* This routine is called to try to read byte, word, or long, as specified
* by length, from the specified source to the specified destination.
*
* RETURNS: OK if successful probe, else ERROR
*
* From a C point of view, the routine is defined as follows:

STATUS sysMemProbeSup (length, src, dest)
    (
    int         length, /@ length of cell to test (1, 2, 4, 8, 16) @/
    char *      src,    /@ address to read @/
    char *      dest    /@ address to write @/
    )

*/

sysMemProbeSup:
        addi    p7, p0, 0       /* save length to p7 */
        xor     p0, p0, p0      /* set return status */
        cmpwi   p7, 1           /* check for byte access */
        bne     sbpShort        /* no, go check for short word access */
        lbz     p6, 0(p1)       /* load byte from source */
        eieio
        sync
        stb     p6, 0(p2)       /* store byte to destination */
        eieio
        sync
        isync                   /* enforce for immediate exception handling */
        blr
sbpShort:
        cmpwi   p7, 2           /* check for short word access */
        bne     sbpWord         /* no, check for word access */
        lhz     p6, 0(p1)       /* load half word from source */
        eieio
        sync
        sth     p6, 0(p2)       /* store half word to destination */
        eieio
        sync
        isync                   /* enforce for immediate exception handling */
        blr
sbpWord:
        cmpwi   p7, 4           /* check for short word access */
        bne     sysProbeExc     /* no, check for double word access */
        lwz     p6, 0(p1)       /* load half word from source */
        eieio
        sync
        stw     p6, 0(p2)       /* store half word to destination */
        eieio
        sync
        isync                   /* enforce for immediate exception handling */
        blr
sysProbeExc:
        li      p0, -1          /* shouldn't ever get here, but... */
        blr

/*******************************************************************************
*
* sysL2crPut - write to L2CR register of Arthur CPU (SPR1017)
*
* This routine will write the contents of r3 to the L2CR (SPR 1017)
* register.
*
* RETURNS: N/A
*
* From a C point of view, the routine is defined as follows:

void sysL2crPut
    (
    ULONG dataOut      /@ value to write @/
    )

*/

sysL2crPut:
	mtspr	1017,r3
	bclr	20,0

/*******************************************************************************
*
* sysL2crGet - read from L2CR register of Arthur CPU (SPR1017)
*
* This routine will read the contents the L2CR (SPR 1017) register.
*
* RETURNS: value of SPR1017 (in r3)
*
* From a C point of view, the routine is defined as follows:

UINT sysL2crGet (void)

*/

sysL2crGet:
	mfspr	r3,1017
	bclr	20,0

/*******************************************************************************
*
* sysHid1Get - read from HID1 register SPR1009.
*
* This routine will read the contents the HID1 (SPR1009)
*
* RETURNS: value of SPR1009 (in r3)
*
* From a C point of view, the routine is defined as follows:

UINT sysHid1Get (void)

*/

sysHid1Get:
	mfspr	r3,1009
	bclr	20,0

/*******************************************************************************
*
* sysSioRead - this function reads a register from the UIO chip
*
* In order to read data from the desired Super IO register, the index register
* must be written to with the offset of the of the register to be read.  The 
* desired byte of data is then read from the data register.
*
* RETURNS: byte read from data register
*
* From a C point of view, the routine is defined as follows:

UINT8 sysSioRead
    ( 
    UINT8 * pSioIndexReg, 	/@ pointer to SIO index register base addr @/
    UINT8 sioRegOffset		/@ offset of register to read from @/
    )

*/

sysSioRead:
        stb     r4,0(r3)        /* write index register with register offset */
        eieio
        sync
        lbz     r3,1(r3)        /* retrieve specified reg offset contents */
        eieio
        sync
        bclr    20,0            /* return to caller */

/*******************************************************************************
*
* sysSioWrite - this function writes a register to the UIO chip
*
* In order to write data to the desired Super IO register, the index
* register must be written to with the offset of the of the register to be
* modified.  The desired byte of data can then be written via the data
* register.
*
* RETURNS: N/A
*
* From a C point of view, the routine is defined as follows:

void sysSioWrite
    ( 
    UINT8 * pSioIndexReg, 	/@ pointer to SIO index register base addr @/
    UINT8 sioRegOffset, 	/@ offset of register to write to @/
    UINT8 data			/@ 8-bit data to be written @/
    )

*/

sysSioWrite:
        stb     r4,0(r3)        /* write index register with register offset */
        eieio
        sync
        stb     r5,1(r3)        /* 1st write */
        eieio
        sync
        stb     r5,1(r3)        /* 2nd write */
        eieio
        sync
        bclr    20,0            /* return to caller */