usbpcistub.c

WINDRIVER MCP750 BSP

/* usbPciStub.c - System-specific PCI Functions */

/* Copyright 1999-2002 Wind River Systems, Inc. */

/*
Modification history
--------------------
01k,20mar02,mil  Changed prototypes that cause USB attach failure. (SPR #74545)
01j,04dec01,mil  Added support for mcpn750 and cleaned up compiler warnings.
01i,17jul01,wef  moved pci stubs from comps/src into the bsp and changed name 
		 from stub<arch>UsbPciLib.c to usbPciStub.c
01h,17may00,wef  created for ppc bsps from usbPciStub.c in T3
01g,17apr00,wef  in executing 01f, some lines were left out.  replaced them
01f,10apr00,wef  change usrUsbPciLib.c to bsp specific stubs to 
		 remove bsp dependency
01e,08mar00,rcb  Correct prototype for usbPciMemioOffset()...
		 was incorrectly called usbPciMemOffset().
01d,07mar00,rcb  Add support for MIPS R5000 platform.
01c,10dec99,rcb  Add definition for usbPciMemioOffset().  Add conditional
		 code to differentiate mcp750 and mtx604.
01b,05dec99,rcb  Add code in usbPciIntConnect() and usbPciIntRestore() to
		 maintain usage counts for each interrupt number.  This allows
		 multiple callers to share a single interrupt.
01a,31may99,rcb  First.
*/

/*
DESCRIPTION

This file defines platform-independent functions accessing PCI bus 
capabilities.  These functions allow PCI device drivers to be written 
independent of the underlying O/S's PCI access mechanisms.

The name of each function in this group begins with "usb" to represent
"Device Driver Services."
*/

/* Includes */

#include "vxWorks.h"
#include "string.h"
#include "sysLib.h"
#include "cacheLib.h"
#include "iv.h"
#include "intLib.h"
#include "drv/pci/pciConfigLib.h"       /* VxWorks PCI funcs */
#include "usb/usbPlatform.h"            /* Basic definitions */
#include "usb/usbPciLib.h"              /* Our API */


/* Power PC 604 (mcp750/mcpn750 & mtx604) */

/* Mappings for I/O and memory address translation (values from [bsp].h) */

#define PCI_IO_OFFSET           ISA_MSTR_IO_LOCAL
#define PCI_MEM_OFFSET          PCI2DRAM_BASE_ADRS
#define PCI_MEMIO_OFFSET        PCI_MSTR_MEMIO_LOCAL -  PCI_MSTR_MEMIO_BUS


/* The mcp750 doesn't define sysInWord, sysInLong, sysOutWord, and
 * sysOutLong.	It includes the following entry points instead for which
 * there is no vxWorks function prototype.  We include the following
 * definitions in order to suppress compiler warnings.
 */

IMPORT UINT16 sysIn16  (UINT16 *);
IMPORT UINT32 sysIn32  (UINT32 *);
IMPORT void   sysOut16 (UINT16 *, UINT16);
IMPORT void   sysOut32 (UINT32 *, UINT32);


/* Map the "standard" vxworks I/O functions to the mcp750 equivalents */

#define sysInWord(p)	 (USHORT)sysIn16(  (UINT16 *) (p) )
#define sysInLong(p)	 (UINT32)sysIn32(  (UINT32 *) (p) )
#define sysOutWord(p,d)          sysOut16( (UINT16 *) (p), (UINT16) (d) )
#define sysOutLong(p,d)          sysOut32( (UINT32 *) (p), (UINT32) (d) )


/* Interrupt enable/disable */

#if defined(MCP750) || defined(MCPN750)
#define INTERRUPT_BASE	ISA_INTERRUPT_BASE
#else	
#define INTERRUPT_BASE	EXT_INTERRUPT_BASE
#endif  /* MCP750 || MCPN750 */

#define IVEC(i)	 INUM_TO_IVEC ((int) ((i) + INTERRUPT_BASE))

#define INT_CONNECT(intNo, func, param) \
    intConnect (IVEC (intNo), (VOIDFUNCPTR) func, (int) param)

#define INT_DISCONNECT(intNo, func, param)

#define INT_ENABLE(i)	intEnable ((i) + INTERRUPT_BASE)
#define INT_DISABLE(i)	intDisable ((i) + INTERRUPT_BASE)


/* Map I/O functions to underlying system functions. */

#define	OUR_PCI_IN_BYTE(a)		sysInByte ((a) + PCI_IO_OFFSET)
#define	OUR_PCI_IN_WORD(a)		sysInWord ((a) + PCI_IO_OFFSET)
#define	OUR_PCI_IN_DWORD(a)		sysInLong ((a) + PCI_IO_OFFSET)
#define	OUR_PCI_OUT_BYTE(a,v)	sysOutByte ((a) + PCI_IO_OFFSET, (v))
#define	OUR_PCI_OUT_WORD(a,v)	sysOutWord ((a) + PCI_IO_OFFSET, (v))
#define	OUR_PCI_OUT_DWORD(a,v)	sysOutLong ((a) + PCI_IO_OFFSET, (v))


/* code tracks usage count for interrupts 0..MAX_INT_NO-1. */

#define MAX_INT_NO		16


/* locals */

LOCAL UINT16 intUsage [MAX_INT_NO] = {0};


/***************************************************************************
*
* usbPciClassFind - Locates PCI devices by class.
*
* A caller uses this function to locate a PCI device by its PCI class.
* The caller must specify the <pciClass>, <subClass>, and <pgmIf> for the
* device being sought.	The function returns the first matching device
* for <index> = 0, the second for <index> = 1, and so forth.  The
* bus number, device number, and function number for the matching device 
* are returned in the <pBusNo>, <pDeviceNo>, and <pFuncNo> buffers provided 
* by the caller. 
*
*
* RETURNS: TRUE if matching device found
*	   FALSE if device not found
*/

BOOL usbPciClassFind
    (
    UINT8 pciClass,		/* PCI device class */
    UINT8 subClass,		/* PCI device sub-class */
    UINT8 pgmIf,		/* Programming interface */
    UINT16 index,		/* Caller wants nth matching dev */
    pUINT8 pBusNo,		/* Bus number of matching dev */
    pUINT8 pDeviceNo,		/* Device number of matching dev */
    pUINT8 pFuncNo		/* Function number of matching dev */
    )
    {
    int intBusNo;		/* VxWorks returns "int" values */
    int intDeviceNo;
    int intFuncNo;

    
    /* Use the VxWorks PCI config. library to find a device within the
    specified class. */

    if (pciFindClass ((pciClass << 16) | (subClass << 8) | pgmIf, index,
	&intBusNo, &intDeviceNo, &intFuncNo) != OK)
	{
	return FALSE;
	}
    else
	{
	if (pBusNo) *pBusNo = (UINT8) intBusNo;
	if (pDeviceNo) *pDeviceNo = (UINT8) intDeviceNo;
	if (pFuncNo) *pFuncNo = (UINT8) intFuncNo;
	}

    return TRUE;
    }


/***************************************************************************
*
* usbPciByteGet - Returns a UINT8 configuration value
*
* This function returns the UINT8 value at offset <regOffset> from 
* the PCI configuration space of the device identified by <busNo>, 
* <deviceNo>, and <funcNo>.
*
* RETURNS: UINT8 value read from device configuration space
*/

UINT8 usbPciByteGet 
    (
    UINT8 busNo,		/* Bus number of device */
    UINT8 deviceNo,		/* Device number of device */
    UINT8 funcNo,		/* Function number of device */
    UINT16 regOffset		/* Offset into PCI config space */
    )
    {
    UINT8 value;

    if (pciConfigInByte (busNo, deviceNo, funcNo, regOffset, &value) != OK)
	return 0;

    return value;
    }


/***************************************************************************
*
* usbPciWordGet - Returns a UINT16 configuration value
*
* This function returns the UINT16 value at offset <regOffset> from 
* the PCI configuration space of the device identified by <busNo>, 
* <deviceNo>, and <funcNo>.
*
* NOTE: This function adjusts for big vs. little endian environments.
*
* RETURNS: UINT16 value read from device configuration space
*/

UINT32 usbPciWordGet
    (
    UINT8 busNo,		/* Bus number of device */
    UINT8 deviceNo,		/* Device number of device */
    UINT8 funcNo,		/* Function number of device */
    UINT16 regOffset		/* Offset into PCI config space */
    )
    {
    UINT16 value;

    if (pciConfigInWord (busNo, deviceNo, funcNo, regOffset, &value) != OK)
	return 0;

    return value;
    }


/***************************************************************************
*
* usbPciDwordGet - Returns a UINT32 configuration value
*
* This function returns the UINT32 value at offset <regOffset> from 
* the PCI configuration space of the device identified by <busNo>, 
* <deviceNo>, and <funcNo>.
*
* NOTE: This function adjusts for big vs. little endian environments.
*
* RETURNS: UINT32 value read from device configuration space
*/

UINT32 usbPciDwordGet
    (
    UINT8 busNo,		/* Bus number of device */
    UINT8 deviceNo,		/* Device number of device */
    UINT8 funcNo,		/* Function number of device */
    UINT16 regOffset		/* Offset into PCI config space */
    )
    {
    UINT32 value;

    if (pciConfigInLong (busNo, deviceNo, funcNo, regOffset, &value) != OK)
	return 0;

    return value;
    }


/***************************************************************************
*
* usbPciConfigHeaderGet - Reads a device's PCI configuration header
*
* This function reads the PCI configuration header for the device
* identified by <busNo>, <deviceNo>, and <funcNo>.  The configuration
* header is stored in the <pCfgHdr> buffer provided by the caller.
*
* This function initializes the <pCfgHdr> structure to zeros.  Any 
* fields which cannot be read from the device's configuration header 
* will remain zero upon return.  This function does not attempt to read
* fields defined as "reserved" in the PCI configuration header.
*
* RETURNS: N/A
*/

VOID usbPciConfigHeaderGet
    (
    UINT8 busNo,		/* Bus number of device */
    UINT8 deviceNo,		/* Device number of device */
    UINT8 funcNo,		/* Function number of device */
    pPCI_CFG_HEADER pCfgHdr	/* Buffer provided by caller */
    )
    {
    int i;

    /* Do nothing if CfgHdr is NULL */

    if (pCfgHdr == NULL)
	return;


    /* Initialize the buffer to zeros. */

    memset (pCfgHdr, 0, sizeof (*pCfgHdr));


    /* Read and store each field in the PCI configuration header. */

    pCfgHdr->vendorId	= usbPciWordGet (busNo, deviceNo, funcNo, PCI_CFG_VENDOR_ID);
    pCfgHdr->deviceId	= usbPciWordGet (busNo, deviceNo, funcNo, PCI_CFG_DEVICE_ID);
    pCfgHdr->command	= usbPciWordGet (busNo, deviceNo, funcNo, PCI_CFG_COMMAND);
    pCfgHdr->status	= usbPciWordGet (busNo, deviceNo, funcNo, PCI_CFG_STATUS);
    pCfgHdr->revisionId = usbPciByteGet (busNo, deviceNo, funcNo, PCI_CFG_REVISION);
    pCfgHdr->pgmIf	= usbPciByteGet (busNo, deviceNo, funcNo, PCI_CFG_PROGRAMMING_IF);
    pCfgHdr->subClass	= usbPciByteGet (busNo, deviceNo, funcNo, PCI_CFG_SUBCLASS);
    pCfgHdr->pciClass	= usbPciByteGet (busNo, deviceNo, funcNo, PCI_CFG_CLASS);
    pCfgHdr->cacheLineSize = usbPciByteGet (busNo, deviceNo, funcNo, PCI_CFG_CACHE_LINE_SIZE);
    pCfgHdr->latencyTimer = usbPciByteGet (busNo, deviceNo, funcNo, PCI_CFG_LATENCY_TIMER);
    pCfgHdr->headerType = usbPciByteGet (busNo, deviceNo, funcNo, PCI_CFG_HEADER_TYPE);
    pCfgHdr->bist	= usbPciByteGet (busNo, deviceNo, funcNo, PCI_CFG_BIST);

    for (i = 0; i < PCI_CFG_NUM_BASE_REG; i++)
	pCfgHdr->baseReg [i] = usbPciDwordGet (busNo, deviceNo, funcNo, 
	    PCI_CFG_BASE_ADDRESS_0 + i * sizeof (UINT32));

    pCfgHdr->romBase	= usbPciDwordGet (busNo, deviceNo, funcNo, PCI_CFG_EXPANSION_ROM);
    pCfgHdr->intLine	= usbPciByteGet (busNo, deviceNo, funcNo, PCI_CFG_DEV_INT_LINE);
    pCfgHdr->intPin	= usbPciByteGet (busNo, deviceNo, funcNo, PCI_CFG_DEV_INT_PIN);
    pCfgHdr->minGrant	= usbPciByteGet (busNo, deviceNo, funcNo, PCI_CFG_MIN_GRANT);
    pCfgHdr->maxLatency = usbPciByteGet (busNo, deviceNo, funcNo, PCI_CFG_MAX_LATENCY);
    }