Subversion Repositories f9daq

//-------------------------------------------------------------------------------------------
// pcilib.c - interface hardware dependend functions to interface to the pvmon
//
// (c) 1999-2002 ARW Elektronik
//
// this source code is published under GPL (Open Source). You can use, redistrubute and
// modify it unless this header  is  not modified or deleted. No warranty is given that
// this software will work like expected.
// This product is not authorized for use as critical component in life support systems
// wihout the express written approval of ARW Elektronik Germany.
//
// Please announce changes and hints to ARW Elektronik
//
// $Log: pcilibLx.c,v $
// Revision 1.4  2002/10/20 18:07:48  klaus
// mostly working alpha version
//
// Revision 1.3  2002/10/20 11:49:33  klaus
// first parts working
//
// Revision 1.2  2002/10/19 09:44:36  klaus
// first success compiling project
//
// Revision 1.1.1.1  2002/10/18 22:14:29  klaus
//

//-------------------------------------------------------------------------------------------
// INCLUDES
//
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>

#include <../driver/pcivme.h>
#include <../driver/vic.h>
#include <../driver/vme.h>
#include <../lib/pcivme_ni.h>
#include <pcilibLx.h>
#include <mbuffer.h>

//-------------------------------------------------------------------------------------------
// DEFINES
//

//-------------------------------------------------------------------------------------------
// TYPEDEFS
//

//-------------------------------------------------------------------------------------------
// GLOBALS
//
static int  storedError    = 0;
static int  nLocalWordMode = 0;   // initial 32 bit mode

//--------------------------------------------------------------------------
// LOCALS
//

//-------------------------------------------------------------------------------------------
// FUNCTIONS
//

//-------------------------------------------------------------------------------------------
// set word mode
//
int setWordMode(int nMode)
{
    nLocalWordMode = nMode;

    return nLocalWordMode;
}

//-------------------------------------------------------------------------------------------
// set interface special registers - VIC68A
//
unsigned long _SetRegister(int nIfcHandle, unsigned long Address, unsigned long Value)
{
    __u8 ubContent = (__u8)Value;

    VMEaccessVIC(nIfcHandle, VIC68A_WRITE, Address, &ubContent);

    return ubContent;
}


//-------------------------------------------------------------------------------------------
// function to get special interface registers - VIC68A
//
unsigned long _GetRegister(int nIfcHandle, unsigned long Address)
{
    __u8 ubContent;

    VMEaccessVIC(nIfcHandle, VIC68A_READ, Address, &ubContent);

    return ubContent;
}


//-------------------------------------------------------------------------------------------
// init the interface with the current properties
//
int Init_Interface(char *szDevicePath, char AdrMode, int *nIfcHandle)
{
    return  VMEopen(szDevicePath, AdrMode, nIfcHandle);
}


//-------------------------------------------------------------------------------------------
// deinit the current interface
//
void  DeInit_Interface(int nIfcHandle)
{
    VMEclose(nIfcHandle);
}


//-------------------------------------------------------------------------------------------
// check if an error occured
//
int GetError(int nIfcHandle)
{
    int error;

    if ((error = GetLastError(nIfcHandle)))
        storedError = error;
    else
        storedError = VMEerror(nIfcHandle);

    return storedError;
}


//-------------------------------------------------------------------------------------------
// clear a pending error
//
void ClearError(int nIfcHandle)
{
    storedError = 0;
}

//-------------------------------------------------------------------------------------------
// read elements and split a long access into 2 word accesses if word data path
//
char  ReadByte(int nIfcHandle, unsigned long adr, unsigned short modifier)
{
    __u8 c;

    setAccessProperties(nIfcHandle, (__u8)modifier, BYTE_ACCESS);

    storedError = VMEread(nIfcHandle, adr, BYTE_ACCESS, 1, &c);
   
    return c;
}

short ReadWord(int nIfcHandle, unsigned long adr, unsigned short modifier)
{
    __u16 w;

    setAccessProperties(nIfcHandle, (__u8)modifier, WORD_ACCESS);

    storedError = VMEread(nIfcHandle, adr, WORD_ACCESS, 1, &w);
   
    return w;
}

long  ReadLong(int nIfcHandle, unsigned long adr, unsigned short modifier)
{
    __u32 l;
 
    if (nLocalWordMode)
    {
        __u16 partl, parth;

        // lese high anteil von adresse +0
        parth = ReadWord(nIfcHandle, adr, modifier);

        // lese low anteil von adresse +2
        partl = ReadWord(nIfcHandle, adr + sizeof(__u16), modifier);

        l = (parth << 16) | partl;
    }
    else
    {
        setAccessProperties(nIfcHandle, (__u8)modifier, LONG_ACCESS);
   
        storedError = VMEread(nIfcHandle, adr, LONG_ACCESS, 1, &l);
    }
   
    return l;
}

//-------------------------------------------------------------------------------------------
// write a byte/word/long and split a long access into 2 word accesses if word data path
//
void  WriteByte(int nIfcHandle, unsigned long adr, char value, unsigned short modifier)
{
    setAccessProperties(nIfcHandle, (__u8)modifier, BYTE_ACCESS);

    storedError = VMEwrite(nIfcHandle, adr, BYTE_ACCESS, 1, &value);
}

void  WriteWord(int nIfcHandle, unsigned long adr, short value, unsigned short modifier)
{
    setAccessProperties(nIfcHandle, (__u8)modifier, WORD_ACCESS);

    storedError = VMEwrite(nIfcHandle, adr, WORD_ACCESS, 1, &value);
}

void  WriteLong(int nIfcHandle, unsigned long adr, long value, unsigned short modifier)
{
    if (nLocalWordMode)
    {
        __u16 part;

        // high anteil auf adresse +0
        part = (value >> 16) & 0xffff;
        WriteWord(nIfcHandle, adr, part, modifier);

        // low anteil auf adresse +2
        part = value & 0xffff;
        WriteWord(nIfcHandle, adr + sizeof(__u16), part, modifier);
    }
    else
    {
        setAccessProperties(nIfcHandle, (__u8)modifier, LONG_ACCESS);
   
        storedError = VMEwrite(nIfcHandle, adr, LONG_ACCESS, 1, &value);
    }
}

//-------------------------------------------------------------------------------------------
// check for a pending SYSFAIL
//
unsigned short PollSfail(int nIfcHandle)
{
    BOOLEAN bResult;

    VMEsysfailGet(nIfcHandle, &bResult);

    return (unsigned short)bResult;
}

//-------------------------------------------------------------------------------------------
// clear a interface set SYSFAIL
//
void  ClrSfail(int nIfcHandle)
{
    VMEsysfailSet(nIfcHandle, 0);
}

//-------------------------------------------------------------------------------------------
// set a SYSFAIL
//
void  SetSfail(int nIfcHandle)
{
    VMEsysfailSet(nIfcHandle, 1);
}

//-------------------------------------------------------------------------------------------
// read a interrupt vector as byte/word/long (if supported)
//
char  ReadVectorByte(int nIfcHandle)
{
    __u8 ubVector;

    VMEinterrupt(nIfcHandle, &ubVector);

    return ubVector;
}

short ReadVectorWord(int nIfcHandle)
{
    printf("Word read of a vector not available!\n");
    return 0;
}

long  ReadVectorLong(int nIfcHandle)
{
    printf("Longword read of a vector not available!\n");
    return 0;
}

//-------------------------------------------------------------------------------------------
// emulate a 68K TAS (read/modify/write) instruction
//
char  TAS(int nIfcHandle, unsigned long adr, unsigned short modifier)
{
    __u8 ubResult = 0x80;

    VMETAS(nIfcHandle, adr, &ubResult);

    return ubResult;  // check if a read reads a lock
}

//-------------------------------------------------------------------------------------------
// generate a SYSRESET on the vmebus and re-init the interface
//
void  Reset_VME(int nIfcHandle)
{
    VMEreset(nIfcHandle);
}


//-------------------------------------------------------------------------------------------
// print out some interface special info
//
void GetInterfaceInfo(int nIfcHandle, char type)
{
    switch (type)
    {
    }
}

//-------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------