pspandrv.c

powerspan pci slave device driver

/* Copyright 1990-1994, PEP Modular Computers */
/* Copyright 1984-1994, Wind River Systems, Inc. */

 
/* includes */

#include "vxWorks.h"
#include "stdio.h"
#include "types.h"
#include "iosLib.h"
#include "errnoLib.h"
#include "dosFsLib.h"

// for plxdrv internal use
//#include "plxdrv.h"
#include "../../../include/windrvr.h"
#include "../../../samples/shared/pci_regs.h"
#include "../../../samples/shared/bits.h"


#define DEBUG_PSPANDRV

#undef  DEBUG_PSPANDRV

#ifdef DEBUG_PSPANDRV
    #define pspandrv_printf printf
#else    
    #define pspandrv_printf
#endif  


typedef struct
{
    WD_INTERRUPT Int;
    HANDLE hThread;
    WD_TRANSFER Trans[2];
    PVOID funcIntHandler;
} PSPAN_INTERRUPT_MY;

typedef struct
{
    DWORD dwLocalBase;
    DWORD dwMask;
    DWORD dwBytes;
    DWORD dwAddr;
    DWORD dwAddrDirect;
    BOOL  fIsMemory;
} PSPAN_ADDR_DESC_MY;

typedef struct PSPAN_STRUCT_MY
{
    HANDLE hWD;
    WD_CARD cardLock;
    WD_PCI_SLOT pciSlot;
    WD_CARD_REGISTER cardReg;
    PSPAN_ADDR_DESC_MY addrDesc[AD_PCI_BARS];
    PSPAN_INTERRUPT_MY Int;
} PSPAN_STRUCT_MY;

// for plxdrv internal use
#if !defined(IVEC_TO_INUM)
#define IVEC_TO_INUM(intVec)	((int) (intVec) >> 3)
#endif

#if !defined(INUM_TO_IVEC)
#define INUM_TO_IVEC(intNum)	((VOIDFUNCPTR *) ((intNum) << 3))
#endif

#if !defined(INT_NUM_IRQ0)
#define INT_NUM_IRQ0    0x20       /* vector number for IRQ0 */
#endif

/* typedefs */

typedef struct              /* PSPAN_DEV */
    {
    DEV_HDR ioDev;
    BOOL created;
    } PSPAN_DEV;


/* defines */

#define PSPAN_DEVICE "/Pspan"


/* locals */

LOCAL PSPAN_DEV pspanDv =       /* device descriptor */
    {
    {{NULL}},
    FALSE
    };

LOCAL int pspanDrvNum;        /* driver number assigned to this driver */


/* forward declarations */
LOCAL int pspanDelete(void);
LOCAL int pspanOpen (PSPAN_DEV *pPspanDv);
LOCAL int pspanClose (PSPAN_DEV *pPspanDv);
LOCAL int pspanWrite(PSPAN_DEV *pPspanDv,unsigned char *pBuffer,int size);
LOCAL int pspanRead(PSPAN_DEV *pPspanDv,unsigned char *pBuffer,int size);
LOCAL STATUS pspanIoctl (PSPAN_DEV *pPspanDv, int request, void *pParam);


LOCAL void PciScanCards_pspan (WD_PCI_SCAN_CARDS *pciScan);
LOCAL void Version_pspan(WD_VERSION *ver);
LOCAL void PciGetCardInfo_pspan (WD_PCI_CARD_INFO *pciCardInfo);
LOCAL void CardRegister_pspan(PSPAN_STRUCT_MY *hPlx);
LOCAL void CardUnregister_pspan(PSPAN_STRUCT_MY *hPlx);
LOCAL void PciConfigDump_pspan(WD_PCI_CONFIG_DUMP *pciCnf);
LOCAL void Sleep_pspan( WD_SLEEP *pParam );
LOCAL void Transfer_pspan(WD_TRANSFER *trans);
LOCAL int IntEnable_pspan( WD_INT *PSPAN_IntHandler );
LOCAL int IntDisable_pspan( WD_INT *PSPAN_IntHandler );


/*******************************************************************************
*
* rtcDrv - adding the driver to the driver system
*
* This routine must be called in supervisor state.
*
* RETURNS: OK or ERROR
*/

STATUS pspanDrv (void)

    {
    if (pspanDrvNum > 0)
        return (OK);

    pspanDrvNum = iosDrvInstall (pspanOpen, pspanDelete, pspanOpen,		//(FUNCPTR) NULL
                               pspanClose, pspanRead, pspanWrite,
                               pspanIoctl);

    return (pspanDrvNum == ERROR ? ERROR : OK);
    }

/*******************************************************************************
*
* rtcDevCreate - create a device for the real time clock
*
* RETURN: OK or ERROR, if already created.
*/

STATUS pspanDevCreate (void)

    {
    /* test if driver already installed */

    if (pspanDrvNum <= 0)
        {
        (void) errnoSet (S_ioLib_NO_DRIVER);
        return (ERROR);
        }

    /* if there is a device already created, don't do it */

    if (pspanDv.created)
        return (ERROR);


    /*
     * mark the device as having been created
     * and add it to the I/O system
     */

    pspanDv.created = TRUE;

    return (iosDevAdd ((DEV_HDR *) &pspanDv, PSPAN_DEVICE, pspanDrvNum));
}


/********************************************************
*	Initialize the device "/Pspan"
*
*
*/
void pspan(void)
{
	pspanDrv ();
	pspanDevCreate();
	
	
}


/*******************************************************************************
*
* pspanDelete - delete PSPAN_DEVICE
*/

LOCAL int pspanDelete
    (
    void
    )

    {
    	iosDevDelete((DEV_HDR *) &pspanDv);
    	iosDrvRemove(pspanDrvNum,TRUE);

     	return OK;
    }



/*******************************************************************************
*
* pspanOpen - open file to PSPAN_DEVICE
*/

LOCAL int pspanOpen
    (
    PSPAN_DEV *pPspanDv
    )

    {
    	//pspandrv_printf("/Pspan is opened!\n");

     	return ((int) pPspanDv);
    }


/*******************************************************************************
*
* pspanClose - close file to PSPAN_DEVICE
*/

LOCAL int pspanClose
    (
    PSPAN_DEV *pPspanDv
    )

    {
    	//pspandrv_printf("/Pspan is closed!\n");
    	return (OK);
    }
    

/*******************************************************************************
*
* pspanWrite - read data from PSPAN_DEVICE
*/

LOCAL int pspanRead
    (
    PSPAN_DEV *pPspanDv,
    unsigned char *pBuffer,
    int size
    )

    {
    	pspandrv_printf("/Pspan read has run!\n");
    	pspandrv_printf("%s",pBuffer);
    	return size;
    }



/*******************************************************************************
*
* pspanWrite - write data to PSPAN_DEVICE
*/

LOCAL int pspanWrite
    (
    PSPAN_DEV *pPspanDv,
    unsigned char *pBuffer,
    int size
    )

    {
    	pspandrv_printf("/Pspan write has run!\n");
    	pspandrv_printf("%s",pBuffer);
    	return size;
    }




/*******************************************************************************
*
* pspanIoctl - special device control
*
* This driver responds to the ioctl calls described in the header.
*/

LOCAL STATUS pspanIoctl
    (
    PSPAN_DEV *pPspanDv,   	/* device to control */
    int     request,       	/* request code 	 */
    void    *pParam        	/* print if TRUE, else only set structure */
    )

    {
    STATUS state = OK;      /* state of the ioctl calls */

    switch (request)
    {
        case 1:
            pspandrv_printf( "function 1 has run! print is 0x%s .\n",(char *)pParam );
            break;
           
        case IOCTL_WD_PCI_SCAN_CARDS:
            pspandrv_printf( "function IOCTL_WD_PCI_SCAN_CARDS has run! \n");
            PciScanCards_pspan ( (WD_PCI_SCAN_CARDS *)pParam );
            break;
 
        case IOCTL_WD_VERSION:
            pspandrv_printf( "function IOCTL_WD_VERSION has run! \n");
            Version_pspan( (WD_VERSION *)pParam);
            break;

        case IOCTL_WD_PCI_GET_CARD_INFO:
            pspandrv_printf( "function IOCTL_WD_PCI_GET_CARD_INFO has run! \n");
            PciGetCardInfo_pspan( (WD_PCI_CARD_INFO *)pParam );
            break;   
            
        case IOCTL_WD_CARD_REGISTER:
            pspandrv_printf( "function IOCTL_WD_CARD_REGISTER has run! \n");
            CardRegister_pspan( (PSPAN_STRUCT_MY *)pParam );
            break;            
            
        case IOCTL_WD_CARD_UNREGISTER:
            pspandrv_printf( "function IOCTL_WD_CARD_UNREGISTER has run! \n");
            CardUnregister_pspan( (PSPAN_STRUCT_MY *)pParam );
            break;   
            
        case IOCTL_WD_PCI_CONFIG_DUMP:
           // pspandrv_printf( "function IOCTL_WD_PCI_CONFIG_DUMP has run! \n");
            PciConfigDump_pspan( (WD_PCI_CONFIG_DUMP *)pParam );
            break;  
            
        case IOCTL_WD_TRANSFER:
           // pspandrv_printf( "function IOCTL_WD_TRANSFER has run! \n");
            Transfer_pspan( (WD_TRANSFER *)pParam );
            break;     
            
        case IOCTL_WD_SLEEP:
           // pspandrv_printf( "function IOCTL_WD_TRANSFER has run! \n");
            Sleep_pspan( (WD_SLEEP *)pParam );
            break;   
            
        case IOCTL_WD_INT_ENABLE:
           // pspandrv_printf( "function IOCTL_WD_TRANSFER has run! \n");
            IntEnable_pspan( (WD_INT *)pParam );
            break;              

        case IOCTL_WD_INT_DISABLE:
           // pspandrv_printf( "function IOCTL_WD_TRANSFER has run! \n");
            IntDisable_pspan( (WD_INT *)pParam );
            break;                                                                                                                                                                                                                                                                                                                                                                 
            
        default:
            pspandrv_printf("No such functions!\n");
            break;
     }

    return (state);
    
}


/////////////////////////////////////////////////////////////////////////////////
//									       //
//	The following is the functions of implement low level pci operations   //	
//									       //
/////////////////////////////////////////////////////////////////////////////////



/*******************************************************************************
* 	scan the pci card
*/
LOCAL void PciScanCards_pspan (WD_PCI_SCAN_CARDS *pciScan)
{
    int li;
    
    int   pBusNo;
    int   pDeviceNo;
    int   pFuncNo;