syswindml.c

Vxworks下BSP源码

/* sysWindML.c - WindML BSP specific routines  */

/* Copyright 2001 Wind River Systems, Inc. */

#include "copyright_wrs.h"
/*
modification history
--------------------
01a,07aug01,m_h  created
*/

#include <vxWorks.h>
#include <ugl/sysWindML.h>
#include <config.h>
#include <pciClass.h>


/* defines */



#ifdef INCLUDE_WINDML_PS2_POINTER
#ifndef INCLUDE_WINDML_PS2_KEYBOARD /* If pointer, tehn we must have keyboard */
#define INCLUDE_WINDML_PS2_KEYBOARD
#endif /* INCLUDE_WINDML_PS2_KEYBOARD */
#ifndef WINDML_POINTER_DEV_NAME
#define WINDML_POINTER_DEV_NAME		"/pointer/0"
#endif /* WINDML_POINTER_DEV_NAME */
#endif /* INCLUDE_WINDML_PS2_POINTER */

#ifdef INCLUDE_WINDML_PS2_KEYBOARD
#ifndef WINDML_KEYBOARD_DEV_NAME
#define WINDML_KEYBOARD_DEV_NAME	"/keyboard/0"
#endif /* WINDML_KEYBOARD_DEV_NAME */
#endif /* INCLUDE_WINDML_PS2_KEYBOARD */

/*
DESCRIPTION

This library provides board-specific routines to support WindML.  This file is 
included at the end of sysLib.c when WindML functionality is to be included.

This API is designed in a general fashion, such that it is applicable to all
processor types and is bus independent.  It provides the support equally for
graphics devices that are integral to a processor (such as with the PPC821) 
and graphics devices that are present on a PCI bus.

The API provides support for configurations where a system has multiple graphics
devices and input devices.

A data structure allocated within the BSP provides information describing the 
graphics, input (keyboard and pointer), and audio devices.  A serial pointer
that connects to a standard serial port (such as, /tyCo/0) is not covered by
this API.  Those devices use the standard serial drivers.

The data structure to define the graphics device is as follows:

 typedef struct windml_device
   {
    UINT32  vendorID,                   /@ vendor ID @/
    UINT32  deviceID,                   /@ device ID @/
    UINT32  instance,                   /@ instance of device @/
    UINT32  devType,                    /@ type of input device @/
    UINT32  busType;                    /@ bus type @/
    UINT32  regDelta;                   /@ distance between adjacent registers @/
    UINT32  intLevel;                   /@ interrupt level to be used @/
    VOIDFUNCPTR * intVector;            /@ interrupt vector to be used @/
    void    * pPhysBaseAdrs0;           /@ first base address @/
    void    * pPhysBaseAdrs1;           /@ second base address @/
    void    * pPhysBaseAdrs2;           /@ third base address @/
    void    * pPhysBaseAdrs3;           /@ fourth base address @/
    void    * pPhysBaseAdrs4;           /@ fifth base address @/
    void    * pPhysBaseAdrs5;           /@ sixth base address @/
    void    *pRegBase;                  /@ base address of register space @/
   } WINDML_DEVICE;


 The <vendorID> and the <deviceID> are based upon the PCI bus identifiers.  In
 this case, these identifiers are extended to include the mapping for non-PCI
 devices.  The file sysWindML.h provides the identifier for supported vendor
 and device identifiers.
 
 The above structure supports devices with up to six base addresses used
 to access the device (for example, one base address for the frame buffer
 and another for the memory mapped registers).  Typically, a device 
 will only have a base address.  The <pPhysBaseAdrsX> may need to be interpreted
 based upon the busType (for example, the <pPhysBaseAdrsX> value is directly
 obtained from the PCI header which includes flag bits unrelated to the address
 value).

 The <pRegBase> field identifies the base address to use to access the I/O ports.
 This is typically the base of the ISA space.  For X86 type processors, this
 field would be set to 0.  For powerPC processors, this field would be set 
 according to the memory model used (PRep or CHRP).

INCLUDE FILES: ugl/sysWindML.h
*/

/******************************************************************************
*
* sysWindMLDevGet - configures the device
*
* This routine will determine the presence of the device and perform any device 
* configuration required.  The behaviour of this function varies depending on the 
* type of device configuration (such as a PCI device, integral, device 
* controller, etc.).  A device configuration data structure is created for the 
* specified device.  This configuration data defines the access mechanism for 
* the device.    
*
* The <vendorID> and <deviceID> identify the vendor and device identifiers in
* the PCI environment.  If these values are set to zero, then the <instance> 
* occurrence of a device will be returned.  For example, if the <instance> and 
* <vendorID> were set to zero, then the routine will return the first occurrence 
* of a device.
* 
* The returned data structure provides miscellaneous data items that describe 
* the manner in which to access the device.  
*
* RETURNS: When device has been successfully configured, the address of the
*          device data structure; otherwise NULL
*
*/

WINDML_DEVICE * sysWindMLDevGet 
    (
    UINT32 devType,     /* Device Type */
    UINT32 instance,	/* The instance of the device */
    UINT32 vendorID,	/* The identifier for the device manufacturer */
    UINT32 deviceID	/* The identifier for the device */
    )
    {
    WINDML_DEVICE * pDev = NULL;
    UINT16 data;


    switch (devType) {
	case WINDML_GRAPHICS_DEVICE :
	    {
	    pDev = (WINDML_DEVICE *)calloc(1, sizeof(WINDML_DEVICE));

	    if (pDev == NULL)
		{
		return (pDev);
		}

    /* extract base address from config space */

	    pDev->vendorID = vendorID;
	    pDev->deviceID = deviceID;
	    pDev->instance = instance;
	    pDev->devType = devType;
            pDev->busType = BUS_TYPE_PCI;

	    pDev->pPhysBaseAdrs0 = (void *) 0;
	    pDev->pPhysBaseAdrs1 = 0;
	    pDev->pPhysBaseAdrs2 = 0;
	    pDev->pPhysBaseAdrs3 = 0;
	    pDev->pPhysBaseAdrs4 = 0;
	    pDev->pPhysBaseAdrs5 = 0;
	    pDev->regDelta = 0;
	    pDev->intLevel = 0;
	    pDev->intVector = NULL;
	    pDev->pRegBase = 0;

	    break;
	    }

	case WINDML_KEYBOARD_DEVICE :
	    {
	    pDev = (WINDML_DEVICE *)calloc(1, sizeof(WINDML_DEVICE));

	    if (pDev == NULL)
		{
		return (pDev);
		}

	    pDev->devType = devType;
	    pDev->instance = 0;
	    pDev->regDelta = 4;
/*	    pDev->intLevel = INT_LVL_KEYBOARD;
	    pDev->intVector = (VOIDFUNCPTR *)INT_VEC_KEYBOARD; */
	    pDev->intLevel = 0;
	    pDev->intVector = 0;
	    	    
	    pDev->pRegBase =0;

	    break;
	    }

	case WINDML_POINTER_DEVICE :
	    {
	    pDev = (WINDML_DEVICE *)calloc(1, sizeof(WINDML_DEVICE));

	    if (pDev == NULL)
		{
		return (pDev);
		}

	    pDev->devType = devType;
	    pDev->instance = 0;
	    pDev->regDelta = 4;
/*	    pDev->intLevel = INT_LVL_MOUSE;
	    pDev->intVector = (VOIDFUNCPTR *)INT_VEC_MOUSE; */
	    pDev->intLevel = 0;
	    pDev->intVector = 0;
	    pDev->pRegBase = 0;

	    break;
	    }

	case WINDML_AUDIO_DEVICE :
            {
            /* not implemented yet */
	    break;
	    }

	default:
	    {
	    break;
	    }
	}
    return (pDev);
    }



/*******************************************************************************
*
* sysWindMLDevCreate - Performs initialization of the mouse and keyboard at 
* VxWorks startup.
*
* This routine is a hook used to call the mouse and keyboard device create 
* functions.  If INCLUDE_WINDML_PS2_KEYBOARD is defined the keyboard is 
* initialized.  If INCLUDE_WINDML_PS2_POINTER is defined the mouse is 
* initialized.  WINDML_KEYBOARD_DEV_NAME and WINDML_POINTER_DEV_NAME must be 
* defined.  They are defined as /keyboard/0 and /pointer/0 by default.
*
* For this function to be called INCLUDE_WINDML_BSP_INPUT_DEVICES must be 
* defined in config.h.
*
* RETURNS: OK or ERROR
*/

STATUS sysWindMLDevCreate()
{
#ifdef INCLUDE_WINDML_PS2_KEYBOARD
    /* Initialize the keyboard. */
    at91cKbdDevCreate (WINDML_KEYBOARD_DEV_NAME);
#ifdef  INCLUDE_WINDML_PS2_POINTER
    /* Initialize the mouse. */
 printf("syswindmldevcreate\n");
    at91cPs2DevCreate (WINDML_POINTER_DEV_NAME);
#endif /* INCLUDE_WINDML_PS2_POINTER */
#endif /* INCLUDE_WINDML_PS2_KEYBOARD */
    
    return (OK);
}

/******************************************************************************
*
* sysWindMLDevCtrl - special control of the device mode
*
* This routine provides special control features for the device.  This
* function is essentially a catch all to provide control of the device
* where the functionality is provided within a PCI configuration header or
* by board specific registers which may be shared by other functions implemented
* on the target board.
*
* The <function> argument defines the type of function that is to be performed
* and the <pArg> parameter provides the details relating to the function. 
*
* The values for <function> and the interpretation of the <pArg> parameters are:
*
*\is
*\i WINDML_ACCESS_MODE_SET
*       Sets the device's access mode as to whether it is to respond to I/O
*       cycles of memory mapped cycles or both.  The accessibility is provided
*       by the <pArg> parameter which is bit mapped containing the flags
*       WINDML_MEM_ENABLE (enable memory mapped access) and WINDML_IO_ENABLE 
*	(enable I/O access).
*\i WINDML_LCD_MODE_SET
*       Sets the control mode for an LCD that is controllable by an on board
*       register rather than a graphics device register. The mode information
*	is passed through <pArg>. The flags available are WINDML_LCD_ON
*	WINDML_LCD_OFF, WINDML_BACKLIGHT_ON, WINDML_BACKLIGHT_OFF.
*\i WINDML_BUSWIDTH_SET
*	Some boards allow the LCD bus width to be changed dynamically via
*	an FPGA or other configurable logic. This can be done in a board
* 	specific manner. The actual bus width will be passed through <pArg>.
*\ie
*
* RETURNS: OK when control operation was success; otherwise ERROR
*
*/

STATUS sysWindMLDevCtrl 
    (
    WINDML_DEVICE *pDev,	/* Device to control */
    int function,		/* Type of operation to perform */
    int *pArg			/* Control mode */
    )
    {
return OK;
	
/*    STATUS status = ERROR;

    if (pDev == NULL)
	{
	return(status);
	}

    switch (function)
	{
	case WINDML_ACCESS_MODE_SET:
	    {
	    int busno, slotno, funcno;

	    if (pciFindDevice (pDev->vendorID, 
			       pDev->deviceID, 
			       pDev->instance, 
			       &busno, &slotno, &funcno) != OK) 
		{
		return (ERROR);
		}

	    status = pciConfigOutWord(busno, slotno, funcno, 
				      PCI_CFG_COMMAND, *pArg);
	    break;
	    }

	default:
	    {
	    break;
	    }
	}
    return(status);*/
    }

/******************************************************************************
*
* sysWindMLDevRelease - release a device configuration
*
* This routine will release any resources that were allocated when a  
* device was configured using the <sysWindMLDevGet()> function.  This 
* function will free the memory that was allocated for the WINDML_DEVICE 
* data structure is it were dynamically allocated.  If the data structure was not 
* dynamically allocated, this function will usually be simply a stub.
*
* RETURNS: OK when  operation was success; otherwise ERROR
*
*/

STATUS sysWindMLDevRelease 
    (
    WINDML_DEVICE *pDev	/* Device to release */
    )
    {
    if(pDev != NULL)
	free(pDev);

    return(OK);
    }

/******************************************************************************
*
* sysWindMLIntConnect - Connect the device interrupt.
*
* This routine connects a routine to the interrupt.
*
* RETURNS: OK or ERROR
*/

STATUS sysWindMLIntConnect
    (
    WINDML_DEVICE *pDev,	/* Graphics device to control */
    VOIDFUNCPTR   routine,      /* routine to be called */
    int           parameter     /* parameter to be passed */
    )
    {
    STATUS status = ERROR;

    if (pDev != NULL && pDev->intVector != NULL && routine != NULL)
	{
	    {
	    status = intConnect (pDev->intVector, routine, parameter);
	    }
	}
    return (status);
    }

/******************************************************************************
*
* sysWindMLIntEnable - Enable interrupts.
*
* This routine enables the interrupt.
*
* RETURNS: OK or ERROR
*/

STATUS sysWindMLIntEnable
    (
    WINDML_DEVICE *pDev	/* Device to control */
    )
    {
    STATUS status = ERROR;

    if (pDev != NULL && pDev->intLevel != 0)
	{
	if (pDev->devType != WINDML_AUDIO_DEVICE)
	    {
	    status = intEnable (pDev->intLevel);
	    }
	else
	    {
	    status = OK;
	    }
	}

    return (status);
    }

/******************************************************************************
*
* sysWindMLIntDisable - Disable interrupts.
*
* This routine disables the interrupt.
*
* RETURNS: OK or ERROR
*/

STATUS sysWindMLIntDisable
    (
    WINDML_DEVICE *pDev	/* Device to control */
    )
    {
    STATUS status = ERROR;

    if(pDev != NULL && pDev->intLevel != 0)
	{
	if (pDev->devType != WINDML_AUDIO_DEVICE)
	    {
	    status = intDisable (pDev->intLevel);
	    }
	else
	    {
	    status = OK;
	    }
	}

    return (status);
    }

/*******************************************************************************
*
* sysWindMLHwInit - Perform any necessary hardware initialization in sysHwInit()
*
* RETURNS: OK or ERROR
*/
STATUS sysWindMLHwInit
    (
    void
    )
    {
    return(OK);
    }