//-------------------------------------------------------------------------------------------
// pcivme_ni.c - shared library for ARW pcivme interface (libpcivme.so)
//
// Copyright (C) 2002-2004 ARW Elektronik Germany
//
// this source code is published under LGPL (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: pcivme_ni.c,v $
// Revision 1.8 2004/08/13 19:23:45 klaus
// conversion to kernel-version 2.6, released version 3.0
//
// Revision 1.7 2002/10/20 18:07:18 klaus
// changed error handling
//
// Revision 1.6 2002/10/18 21:56:28 klaus
// completed functional features, untested
//
// Revision 1.5 2002/10/18 21:56:28 klaus
// completed functional features, untested
//
// Revision 1.4 2002/10/17 21:16:03 klaus
// filled function bodies
//
// Revision 1.3 2002/10/17 21:16:03 klaus
// filled function bodies
//
// Revision 1.2 2002/10/17 19:05:03 klaus
// VME access is working through test to lib to driver
//
// Revision 1.1 2002/10/12 22:04:30 klaus
// first work done
//
//-------------------------------------------------------------------------------------------
// INCLUDES
//
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <linux/types.h>
#include <sys/ioctl.h>
#include <errno.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <../driver/pcivme.h>
#include <../driver/vic.h>
#include <pcivme_ni.h>
//-------------------------------------------------------------------------------------------
// DEFINES
//
#define LOCAL_STRING_LEN 40
//-------------------------------------------------------------------------------------------
// TYPEDEFS
//
// storage for path specific data
typedef struct
{
int nFileNo
; // file number to f
__u8 cAddressModifier
; // associated VME address modifier
__u8 cAccessWidth
; // current access width
int nLastError
; // != 0 if a previous error occurred
} VMEMM_DEVICE
;
//-------------------------------------------------------------------------------------------
// FUNCTIONS
//
// construct a device file name
static char *szDeviceName
(const char *cszBaseName
, int nVMEMM
)
{
static char path
[LOCAL_STRING_LEN
];
int i
= LOCAL_STRING_LEN
- 1;
path
[0] = 0;
memset(path
, 0, LOCAL_STRING_LEN
);
if (strlen(cszBaseName
) >= (LOCAL_STRING_LEN
- 3))
return "";
if (nVMEMM
> 15)
return "";
strncpy(path
, cszBaseName
, LOCAL_STRING_LEN
- 3);
while ((i
--) && (path
[i
] != '_')); // search for '_'
if (i
)
{
i
++; // go after '_'
if (nVMEMM
>= 10)
{
path
[i
] = '1';
nVMEMM
-= 10;
i
++;
}
path
[i
] = '0' + nVMEMM
;
i
++;
path
[i
] = 0; // trailing 0
}
else
return "";
return path
;
}
static int initHardware
(VMEMM_DEVICE
*dev
)
{
PCIVME_INIT_COMMAND init
;
init.
sVie[0].
bDestination = STOP
;
init.
sVie[0].
bAccessType =
init.
sVie[0].
dwValue =
init.
sVie[0].
wOffset = 0;
if (ioctl
(dev
->nFileNo
, PCIVME_INIT_HARDWARE
, &init
) < 0)
{
dev
->nLastError
= errno
;
return errno
;
}
return 0;
}
static int deInitHardware
(VMEMM_DEVICE
*dev
)
{
PCIVME_INIT_COMMAND deinit
;
deinit.
sVie[0].
bDestination = STOP
;
deinit.
sVie[0].
bAccessType =
deinit.
sVie[0].
dwValue =
deinit.
sVie[0].
wOffset = 0;
if (ioctl
(dev
->nFileNo
, PCIVME_DEINIT_HARDWARE
, &deinit
) < 0)
{
dev
->nLastError
= errno
;
return errno
;
}
return 0;
}
int VMEopen
(const char *cszDeviceName
, unsigned char ubAddressModifier
, int *pnHandle
)
{
VMEMM_DEVICE
*dev
= (VMEMM_DEVICE
*)NULL
;
int error
;
*pnHandle
= 0;
dev
= (VMEMM_DEVICE
*)malloc(sizeof(*dev
));
if (!dev
)
return errno
;
dev
->nFileNo
= open
(cszDeviceName
, O_RDWR
);
if (dev
->nFileNo
== -1)
{
error
= errno
;
free(dev
);
return error
;
}
dev
->cAddressModifier
= ubAddressModifier
;
*pnHandle
= (int)dev
;
error
= initHardware
(dev
);
if (error
)
return error
;
dev
->nLastError
= 0;
return setAccessProperties
(*pnHandle
, dev
->cAddressModifier
, BYTE_ACCESS
); // set access properties to default
}
int VMEinit
(const char *cszDeviceName
, unsigned short nVMEMM
, unsigned char ubAddressModifier
, int *pnHandle
)
{
char *szLocalDeviceName
= szDeviceName
(cszDeviceName
, nVMEMM
);
return VMEopen
(szLocalDeviceName
, ubAddressModifier
, pnHandle
);
}
int setAccessProperties
(int nHandle
, unsigned char bModifier
, unsigned char bAccessType
)
{
VMEMM_DEVICE
*dev
= (VMEMM_DEVICE
*)nHandle
;
PCIVME_ACCESS_COMMAND access_command
;
access_command.
bAccessType =
access_command.
bIncrement = bAccessType
; // increment and accessType are the same
access_command.
bModifier = bModifier
;
if (ioctl
(dev
->nFileNo
, PCIVME_SET_ACCESS_PARA
, &access_command
) < 0)
{
dev
->nLastError
= errno
;
return errno
;
}
dev
->cAddressModifier
= bModifier
;
dev
->cAccessWidth
= bAccessType
;
return 0;
}
int VMEread
(int nHandle
, unsigned long ulAddress
, unsigned char ubAccessWidth
, unsigned long ulElementCount
, void *pvBuffer
)
{
VMEMM_DEVICE
*dev
= (VMEMM_DEVICE
*)nHandle
;
size_t count
= (size_t)(ulElementCount
* ubAccessWidth
);
ssize_t result
;
int error
;
if (dev
->cAccessWidth
!= ubAccessWidth
)
{
if ((error
= setAccessProperties
(nHandle
, dev
->cAddressModifier
, ubAccessWidth
)))
return error
;
}
if (lseek
(dev
->nFileNo
, ulAddress
, SEEK_SET
) < 0)
return errno
;
result
= read
(dev
->nFileNo
, pvBuffer
, count
);
if (result
!= count
)
{
if (result
< 0)
{
dev
->nLastError
= errno
;
return errno
;
}
else
return EFAULT
;
}
return 0;
}
int VMEwrite
(int nHandle
, unsigned long ulAddress
, unsigned char ubAccessWidth
, unsigned long ulElementCount
, void *pvBuffer
)
{
VMEMM_DEVICE
*dev
= (VMEMM_DEVICE
*)nHandle
;
size_t count
= (size_t)(ulElementCount
* ubAccessWidth
);
ssize_t result
;
int error
;
if (dev
->cAccessWidth
!= ubAccessWidth
)
{
if ((error
= setAccessProperties
(nHandle
, dev
->cAddressModifier
, ubAccessWidth
)))
return error
;
}
if (lseek
(dev
->nFileNo
, ulAddress
, SEEK_SET
) < 0)
return errno
;
result
= write
(dev
->nFileNo
, pvBuffer
, count
);
if (result
!= count
)
{
if (result
< 0)
{
dev
->nLastError
= errno
;
return errno
;
}
else
return EFAULT
;
}
return 0;
}
int VMEaccessVIC
(int nHandle
, unsigned char ubAccessMode
, unsigned short uwAddress
, unsigned char *ubContent
)
{
VMEMM_DEVICE
*dev
= (VMEMM_DEVICE
*)nHandle
;
PCIVME_VIC68A_ACTION vic68a_action
;
vic68a_action.
bAccessMode = ubAccessMode
;
vic68a_action.
bContent = *ubContent
;
vic68a_action.
wRegisterAddress = uwAddress
;
if (ioctl
(dev
->nFileNo
, PCIVME_ACCESS_VIC68A
, &vic68a_action
) < 0)
{
dev
->nLastError
= errno
;
return errno
;
}
*ubContent
= vic68a_action.
bContent;
return 0;
}
int VMEreset
(int nHandle
)
{
VMEMM_DEVICE
*dev
= (VMEMM_DEVICE
*)nHandle
;
PCIVME_RESET_COMMAND reset_command
;
int i
= 10;
reset_command.
bCommand = GLOBAL_RESET_CMD
;
reset_command.
bResult = 0xff;
if (ioctl
(dev
->nFileNo
, PCIVME_RESET
, &reset_command
) < 0)
{
dev
->nLastError
= errno
;
return errno
;
}
do
{
usleep
(100);
reset_command.
bCommand = POLL_RESET_CMD
;
reset_command.
bResult = 0xff;
if (ioctl
(dev
->nFileNo
, PCIVME_RESET
, &reset_command
) < 0)
{
dev
->nLastError
= errno
;
return errno
;
}
} while ((reset_command.
bResult) && (i
--));
if (!i
)
return ETIME
;
dev
->nLastError
= 0;
return 0;
}
int VMETAS
(int nHandle
, unsigned long ulAddress
, unsigned char *ubResult
)
{
VMEMM_DEVICE
*dev
= (VMEMM_DEVICE
*)nHandle
;
PCIVME_TAS_STRUCT tas
;
tas.
bContent = *ubResult
;
tas.
bModifier = dev
->cAddressModifier
;
tas.
dwAddress = ulAddress
;
if (ioctl
(dev
->nFileNo
, PCIVME_TAS
, &tas
) < 0)
{
dev
->nLastError
= errno
;
return errno
;
}
*ubResult
= tas.
bContent;
return 0;
}
int VMEinterrupt
(int nHandle
, unsigned char *ubVector
)
{
VMEMM_DEVICE
*dev
= (VMEMM_DEVICE
*)nHandle
;
PCIVME_VECTOR_LEVEL ubLocalVector
;
if (ioctl
(dev
->nFileNo
, PCIVME_READ_VECTOR_POLL
, &ubLocalVector
) < 0)
{
dev
->nLastError
= errno
;
return errno
;
}
*ubVector
= (__u8
)ubLocalVector.
dwStatusID;
return 0;
}
int VMEsysfailGet
(int nHandle
, BOOLEAN
*bResult
)
{
VMEMM_DEVICE
*dev
= (VMEMM_DEVICE
*)nHandle
;
PCIVME_VIC68A_ACTION sAction
; // structure to access vic chip
sAction.
wRegisterAddress = EGICR
;
sAction.
bAccessMode = VIC68A_READ
;
sAction.
bContent = 0;
if (ioctl
(dev
->nFileNo
, PCIVME_ACCESS_VIC68A
, &sAction
) < 0)
{
dev
->nLastError
= errno
;
return errno
;
}
*bResult
= (sAction.
bContent & 0x08) ? FALSE
: TRUE
;
return 0;
}
int VMEsysfailSet
(int nHandle
, BOOLEAN bForce
)
{
VMEMM_DEVICE
*dev
= (VMEMM_DEVICE
*)nHandle
;
PCIVME_VIC68A_ACTION sAction
; // structure to access vic chip
sAction.
wRegisterAddress = ICR7
;
sAction.
bAccessMode = (bForce
== TRUE
) ? VIC68A_AND
: VIC68A_OR
;
sAction.
bContent = (bForce
== TRUE
) ? 0x3F : 0x80;
if (ioctl
(dev
->nFileNo
, PCIVME_ACCESS_VIC68A
, &sAction
) < 0)
{
dev
->nLastError
= errno
;
return errno
;
}
return 0;
}
int VMEerror
(int nHandle
)
{
__u8 ubVector
;
VMEinterrupt
(nHandle
, &ubVector
);
if (ubVector
== 7)
return EFAULT
; // it's a bus error
else
return 0;
}
int VMEclose
(int nHandle
)
{
int error
= 0;
VMEMM_DEVICE
*dev
= (VMEMM_DEVICE
*)nHandle
;
if (dev
!= (VMEMM_DEVICE
*)NULL
)
{
deInitHardware
(dev
);
if (dev
->nFileNo
!= -1)
close
(dev
->nFileNo
);
else
error
= -EINVAL
;
free(dev
);
}
return error
;
}
int VMEcontrolInterrupt
(int nHandle
, BOOLEAN
*bEnable
)
{
VMEMM_DEVICE
*dev
= (VMEMM_DEVICE
*)nHandle
;
PCIVME_IRQ_CONTROL control
;
control.
bEnable = *bEnable
;
if (ioctl
(dev
->nFileNo
, PCIVME_CONTROL_INTERRUPTS
, &control
) < 0)
{
dev
->nLastError
= errno
;
return errno
;
}
// status of interrupt enable before set
*bEnable
= control.
bEnable;
return 0;
}
int GetLastError
(int nHandle
)
{
VMEMM_DEVICE
*dev
= (VMEMM_DEVICE
*)nHandle
;
int nLocalError
;
nLocalError
= dev
->nLastError
;
dev
->nLastError
= 0;
return nLocalError
;
}