WebSVN – f9daq – Diff – /pcivme-3.2/lib/pcivme_ni.c


//-------------------------------------------------------------------------------------------
// 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;
        printf("initHardware:err=%d %s\n" , errno,  strerror(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;
        printf("deInitHardware:err=%d %s\n" , errno,  strerror(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);
 
    printf("VMEopen: dev->nFileNo %d size=%d %s\n" , dev->nFileNo,sizeof(*dev),  cszDeviceName );
    if (dev->nFileNo == -1)
    {
        error = errno;
        printf("VMEopen:err=%d %s\n" , error,  strerror(error) );
        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;
        printf("setAccessProperties:err=%d %s\n" , errno,  strerror(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;
    long pos;
 
    printf("VMEread:  AW 0x%0x 0x%0x  , AM 0x%0x \n", dev->cAccessWidth, ubAccessWidth, dev->cAddressModifier);
    if (dev->cAccessWidth != ubAccessWidth)
    {
        if ((error = setAccessProperties(nHandle, dev->cAddressModifier, ubAccessWidth)))
            return error;
    }
    pos = lseek(dev->nFileNo, ulAddress, SEEK_SET);
   
    if ( pos < 0){
        printf("VMEread: pos=0x%08lx dev->nFileNo=%d ADDR=0x%08lx %s\n",pos, dev->nFileNo, ulAddress, strerror(errno));
        switch (errno){
          case EBADF:printf("errno =EBADF\n");break;
          case EINVAL:printf("errno =EINVAL\n");break;
          case EOVERFLOW:printf("errno =EOVERFLOW\n");break;
          case ESPIPE:printf("errno =ESPIPE\n");break;
          case ENXIO:printf("errno =ENXIO\n");break;
        }
        //return errno;
    }
 
 
   
    result = read(dev->nFileNo, pvBuffer, count);
    printf("VMEread: read %d dev->nFileNo=%d err=%d %s\n",count, dev->nFileNo, errno, strerror(errno));
    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;
    long pos;
 
    printf("VMEwrite:  AW 0x%0x 0x%0x  , AM 0x%0x \n", dev->cAccessWidth, ubAccessWidth, dev->cAddressModifier);
    if (dev->cAccessWidth != ubAccessWidth)
    {
        if ((error = setAccessProperties(nHandle, dev->cAddressModifier, ubAccessWidth)))
            return error;
    }
 
    pos = lseek(dev->nFileNo, ulAddress, SEEK_SET);
    if (pos < 0){
        printf("VMEwrite: pos=0x%08lx  dev->nFileNo=%d ADDR=0x%08lx %s\n",pos, dev->nFileNo, ulAddress, strerror(errno));
        switch (errno){
          case EBADF:printf("errno =EBADF\n");break;
          case EINVAL:printf("errno =EINVAL\n");break;
          case EOVERFLOW:printf("errno =EOVERFLOW\n");break;
          case ESPIPE:printf("errno =ESPIPE\n");break;
          case ENXIO:printf("errno =ENXIO\n");break;
        }
        //return errno;
    }
    result = write(dev->nFileNo, pvBuffer, count);
 
    printf("VMEwrite: write %d dev->nFileNo=%d err=%d %s\n",count, dev->nFileNo,errno, strerror(errno));
    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;
}
 
 
 

Rev 9	Rev 11
1	//-------------------------------------------------------------------------------------------	1	//-------------------------------------------------------------------------------------------
2	// pcivme_ni.c - shared library for ARW pcivme interface (libpcivme.so)	2	// pcivme_ni.c - shared library for ARW pcivme interface (libpcivme.so)
3	//	3	//
4	// Copyright (C) 2002-2004 ARW Elektronik Germany	4	// Copyright (C) 2002-2004 ARW Elektronik Germany
5	//	5	//
6	// this source code is published under LGPL (Open Source). You can use, redistrubute and	6	// this source code is published under LGPL (Open Source). You can use, redistrubute and
7	// modify it unless this header is not modified or deleted. No warranty is given that	7	// modify it unless this header is not modified or deleted. No warranty is given that
8	// this software will work like expected.	8	// this software will work like expected.
9	// This product is not authorized for use as critical component in life support systems	9	// This product is not authorized for use as critical component in life support systems
10	// wihout the express written approval of ARW Elektronik Germany.	10	// wihout the express written approval of ARW Elektronik Germany.
11	//	11	//
12	// Please announce changes and hints to ARW Elektronik	12	// Please announce changes and hints to ARW Elektronik
13	//	13	//
14	// $Log: pcivme_ni.c,v $	14	// $Log: pcivme_ni.c,v $
15	// Revision 1.8 2004/08/13 19:23:45 klaus	15	// Revision 1.8 2004/08/13 19:23:45 klaus
16	// conversion to kernel-version 2.6, released version 3.0	16	// conversion to kernel-version 2.6, released version 3.0
17	//	17	//
18	// Revision 1.7 2002/10/20 18:07:18 klaus	18	// Revision 1.7 2002/10/20 18:07:18 klaus
19	// changed error handling	19	// changed error handling
20	//	20	//
21	// Revision 1.6 2002/10/18 21:56:28 klaus	21	// Revision 1.6 2002/10/18 21:56:28 klaus
22	// completed functional features, untested	22	// completed functional features, untested
23	//	23	//
24	// Revision 1.5 2002/10/18 21:56:28 klaus	24	// Revision 1.5 2002/10/18 21:56:28 klaus
25	// completed functional features, untested	25	// completed functional features, untested
26	//	26	//
27	// Revision 1.4 2002/10/17 21:16:03 klaus	27	// Revision 1.4 2002/10/17 21:16:03 klaus
28	// filled function bodies	28	// filled function bodies
29	//	29	//
30	// Revision 1.3 2002/10/17 21:16:03 klaus	30	// Revision 1.3 2002/10/17 21:16:03 klaus
31	// filled function bodies	31	// filled function bodies
32	//	32	//
33	// Revision 1.2 2002/10/17 19:05:03 klaus	33	// Revision 1.2 2002/10/17 19:05:03 klaus
34	// VME access is working through test to lib to driver	34	// VME access is working through test to lib to driver
35	//	35	//
36	// Revision 1.1 2002/10/12 22:04:30 klaus	36	// Revision 1.1 2002/10/12 22:04:30 klaus
37	// first work done	37	// first work done
38	//	38	//
39		39
40	//-------------------------------------------------------------------------------------------	40	//-------------------------------------------------------------------------------------------
41	// INCLUDES	41	// INCLUDES
42	//	42	//
43	#include <stdio.h>	43	#include <stdio.h>
44	#include <stdlib.h>	44	#include <stdlib.h>
45	#include <string.h>	45	#include <string.h>
46	#include <unistd.h>	46	#include <unistd.h>
47	#include <linux/types.h>	47	#include <linux/types.h>
48	#include <sys/ioctl.h>	48	#include <sys/ioctl.h>
49	#include <errno.h>	49	#include <errno.h>
50	#include <ctype.h>	50	#include <ctype.h>
51	#include <sys/types.h>	51	#include <sys/types.h>
52	#include <sys/stat.h>	52	#include <sys/stat.h>
53	#include <fcntl.h>	53	#include <fcntl.h>
54		54
55	#include <../driver/pcivme.h>	55	#include <../driver/pcivme.h>
56	#include <../driver/vic.h>	56	#include <../driver/vic.h>
57	#include <pcivme_ni.h>	57	#include <pcivme_ni.h>
58		58
59	//-------------------------------------------------------------------------------------------	59	//-------------------------------------------------------------------------------------------
60	// DEFINES	60	// DEFINES
61	//	61	//
62	#define LOCAL_STRING_LEN 40	62	#define LOCAL_STRING_LEN 40
63		63
64	//-------------------------------------------------------------------------------------------	64	//-------------------------------------------------------------------------------------------
65	// TYPEDEFS	65	// TYPEDEFS
66	//	66	//
67		67
68	// storage for path specific data	68	// storage for path specific data
69	typedef struct	69	typedef struct
70	{	70	{
71	int nFileNo; // file number to f	71	int nFileNo; // file number to f
72	__u8 cAddressModifier; // associated VME address modifier	72	__u8 cAddressModifier; // associated VME address modifier
73	__u8 cAccessWidth; // current access width	73	__u8 cAccessWidth; // current access width
74	int nLastError; // != 0 if a previous error occurred	74	int nLastError; // != 0 if a previous error occurred
75	} VMEMM_DEVICE;	75	} VMEMM_DEVICE;
76		76
77	//-------------------------------------------------------------------------------------------	77	//-------------------------------------------------------------------------------------------
78	// FUNCTIONS	78	// FUNCTIONS
79	//	79	//
80		80
81	// construct a device file name	81	// construct a device file name
82	static char szDeviceName(const char cszBaseName, int nVMEMM)	82	static char szDeviceName(const char cszBaseName, int nVMEMM)
83	{	83	{
84	static char path[LOCAL_STRING_LEN];	84	static char path[LOCAL_STRING_LEN];
85	int i = LOCAL_STRING_LEN - 1;	85	int i = LOCAL_STRING_LEN - 1;
86		86
87	path[0] = 0;	87	path[0] = 0;
88		88
89	memset(path, 0, LOCAL_STRING_LEN);	89	memset(path, 0, LOCAL_STRING_LEN);
90		90
91	if (strlen(cszBaseName) >= (LOCAL_STRING_LEN - 3))	91	if (strlen(cszBaseName) >= (LOCAL_STRING_LEN - 3))
92	return "";	92	return "";
93		93
94	if (nVMEMM > 15)	94	if (nVMEMM > 15)
95	return "";	95	return "";
96		96
97	strncpy(path, cszBaseName, LOCAL_STRING_LEN - 3);	97	strncpy(path, cszBaseName, LOCAL_STRING_LEN - 3);
98		98
99	while ((i--) && (path[i] != '_')); // search for '_'	99	while ((i--) && (path[i] != '_')); // search for '_'
100		100
101	if (i)	101	if (i)
102	{	102	{
103	i++; // go after '_'	103	i++; // go after '_'
104	if (nVMEMM >= 10)	104	if (nVMEMM >= 10)
105	{	105	{
106	path[i] = '1';	106	path[i] = '1';
107	nVMEMM -= 10;	107	nVMEMM -= 10;
108	i++;	108	i++;
109	}	109	}
110	path[i] = '0' + nVMEMM;	110	path[i] = '0' + nVMEMM;
111	i++;	111	i++;
112	path[i] = 0; // trailing 0	112	path[i] = 0; // trailing 0
113	}	113	}
114	else	114	else
115	return "";	115	return "";
116		116
117	return path;	117	return path;
118	}	118	}
119		119
120	static int initHardware(VMEMM_DEVICE *dev)	120	static int initHardware(VMEMM_DEVICE *dev)
121	{	121	{
122	PCIVME_INIT_COMMAND init;	122	PCIVME_INIT_COMMAND init;
123		123
124	init.sVie[0].bDestination = STOP;	124	init.sVie[0].bDestination = STOP;
125	init.sVie[0].bAccessType =	125	init.sVie[0].bAccessType =
126	init.sVie[0].dwValue =	126	init.sVie[0].dwValue =
127	init.sVie[0].wOffset = 0;	127	init.sVie[0].wOffset = 0;
128		128
129	if (ioctl(dev->nFileNo, PCIVME_INIT_HARDWARE, &init) < 0)	129	if (ioctl(dev->nFileNo, PCIVME_INIT_HARDWARE, &init) < 0)
130	{	130	{
131	dev->nLastError = errno;	131	dev->nLastError = errno;
-		132	printf("initHardware:err=%d %s\n" , errno, strerror(errno) );
132	return errno;	133	return errno;
133	}	134	}
134		135
135	return 0;	136	return 0;
136	}	137	}
137		138
138	static int deInitHardware(VMEMM_DEVICE *dev)	139	static int deInitHardware(VMEMM_DEVICE *dev)
139	{	140	{
140	PCIVME_INIT_COMMAND deinit;	141	PCIVME_INIT_COMMAND deinit;
141		142
142	deinit.sVie[0].bDestination = STOP;	143	deinit.sVie[0].bDestination = STOP;
143	deinit.sVie[0].bAccessType =	144	deinit.sVie[0].bAccessType =
144	deinit.sVie[0].dwValue =	145	deinit.sVie[0].dwValue =
145	deinit.sVie[0].wOffset = 0;	146	deinit.sVie[0].wOffset = 0;
146		147
147	if (ioctl(dev->nFileNo, PCIVME_DEINIT_HARDWARE, &deinit) < 0)	148	if (ioctl(dev->nFileNo, PCIVME_DEINIT_HARDWARE, &deinit) < 0)
148	{	149	{
149	dev->nLastError = errno;	150	dev->nLastError = errno;
-		151	printf("deInitHardware:err=%d %s\n" , errno, strerror(errno) );
150	return errno;	152	return errno;
151	}	153	}
152		154
153	return 0;	155	return 0;
154	}	156	}
155		157
156	int VMEopen(const char cszDeviceName, unsigned char ubAddressModifier, int pnHandle)	158	int VMEopen(const char cszDeviceName, unsigned char ubAddressModifier, int pnHandle)
157	{	159	{
158	VMEMM_DEVICE dev = (VMEMM_DEVICE )NULL;	160	VMEMM_DEVICE dev = (VMEMM_DEVICE )NULL;
159	int error;	161	int error;
160		162
161	*pnHandle = 0;	163	*pnHandle = 0;
162		164
163	dev = (VMEMM_DEVICE )malloc(sizeof(dev));	165	dev = (VMEMM_DEVICE )malloc(sizeof(dev));
164	if (!dev)	166	if (!dev)
165	return errno;	167	return errno;
166		168
167	dev->nFileNo = open(cszDeviceName, O_RDWR);	169	dev->nFileNo = open(cszDeviceName, O_RDWR);
168		-
-		170	printf("VMEopen: dev->nFileNo %d size=%d %s\n" , dev->nFileNo,sizeof(*dev), cszDeviceName );
169	if (dev->nFileNo == -1)	171	if (dev->nFileNo == -1)
170	{	172	{
171	error = errno;	173	error = errno;
-		174	printf("VMEopen:err=%d %s\n" , error, strerror(error) );
172	free(dev);	175	free(dev);
173	return error;	176	return error;
174	}	177	}
175		178
176	dev->cAddressModifier = ubAddressModifier;	179	dev->cAddressModifier = ubAddressModifier;
177	*pnHandle = (int)dev;	180	*pnHandle = (int)dev;
178		181
179	error = initHardware(dev);	182	error = initHardware(dev);
180	if (error)	183	if (error)
181	return error;	184	return error;
182		185
183	dev->nLastError = 0;	186	dev->nLastError = 0;
184		187
185	return setAccessProperties(*pnHandle, dev->cAddressModifier, BYTE_ACCESS); // set access properties to default	188	return setAccessProperties(*pnHandle, dev->cAddressModifier, BYTE_ACCESS); // set access properties to default
186	}	189	}
187		190
188	int VMEinit(const char cszDeviceName, unsigned short nVMEMM, unsigned char ubAddressModifier, int pnHandle)	191	int VMEinit(const char cszDeviceName, unsigned short nVMEMM, unsigned char ubAddressModifier, int pnHandle)
189	{	192	{
190	char *szLocalDeviceName = szDeviceName(cszDeviceName, nVMEMM);	193	char *szLocalDeviceName = szDeviceName(cszDeviceName, nVMEMM);
191		194
192	return VMEopen(szLocalDeviceName, ubAddressModifier, pnHandle);	195	return VMEopen(szLocalDeviceName, ubAddressModifier, pnHandle);
193	}	196	}
194		197
195	int setAccessProperties(int nHandle, unsigned char bModifier, unsigned char bAccessType)	198	int setAccessProperties(int nHandle, unsigned char bModifier, unsigned char bAccessType)
196	{	199	{
197	VMEMM_DEVICE dev = (VMEMM_DEVICE )nHandle;	200	VMEMM_DEVICE dev = (VMEMM_DEVICE )nHandle;
198		201
199	PCIVME_ACCESS_COMMAND access_command;	202	PCIVME_ACCESS_COMMAND access_command;
200		203
201	access_command.bAccessType =	204	access_command.bAccessType =
202	access_command.bIncrement = bAccessType; // increment and accessType are the same	205	access_command.bIncrement = bAccessType; // increment and accessType are the same
203	access_command.bModifier = bModifier;	206	access_command.bModifier = bModifier;
204		207
205	if (ioctl(dev->nFileNo, PCIVME_SET_ACCESS_PARA, &access_command) < 0)	208	if (ioctl(dev->nFileNo, PCIVME_SET_ACCESS_PARA, &access_command) < 0)
206	{	209	{
207	dev->nLastError = errno;	210	dev->nLastError = errno;
-		211	printf("setAccessProperties:err=%d %s\n" , errno, strerror(errno) );
208	return errno;	212	return errno;
209	}	213	}
210		214
211	dev->cAddressModifier = bModifier;	215	dev->cAddressModifier = bModifier;
212	dev->cAccessWidth = bAccessType;	216	dev->cAccessWidth = bAccessType;
213		217
214	return 0;	218	return 0;
215	}	219	}
216		220
217	int VMEread(int nHandle, unsigned long ulAddress, unsigned char ubAccessWidth, unsigned long ulElementCount, void *pvBuffer)	221	int VMEread(int nHandle, unsigned long ulAddress, unsigned char ubAccessWidth, unsigned long ulElementCount, void *pvBuffer)
218	{	222	{
219	VMEMM_DEVICE dev = (VMEMM_DEVICE )nHandle;	223	VMEMM_DEVICE dev = (VMEMM_DEVICE )nHandle;
220	size_t count = (size_t)(ulElementCount * ubAccessWidth);	224	size_t count = (size_t)(ulElementCount * ubAccessWidth);
221	ssize_t result;	225	ssize_t result;
222	int error;	226	int error;
-		227	long pos;
223		228
-		229	printf("VMEread: AW 0x%0x 0x%0x , AM 0x%0x \n", dev->cAccessWidth, ubAccessWidth, dev->cAddressModifier);
224	if (dev->cAccessWidth != ubAccessWidth)	230	if (dev->cAccessWidth != ubAccessWidth)
225	{	231	{
226	if ((error = setAccessProperties(nHandle, dev->cAddressModifier, ubAccessWidth)))	232	if ((error = setAccessProperties(nHandle, dev->cAddressModifier, ubAccessWidth)))
227	return error;	233	return error;
228	}	234	}
-		235	pos = lseek(dev->nFileNo, ulAddress, SEEK_SET);
229		236
-		237	if ( pos < 0){
-		238	printf("VMEread: pos=0x%08lx dev->nFileNo=%d ADDR=0x%08lx %s\n",pos, dev->nFileNo, ulAddress, strerror(errno));
-		239	switch (errno){
-		240	case EBADF:printf("errno =EBADF\n");break;
-		241	case EINVAL:printf("errno =EINVAL\n");break;
-		242	case EOVERFLOW:printf("errno =EOVERFLOW\n");break;
230	if ~~(lseek(dev->nFileNo, ulAddress, SEEK_SET) <~~ 0)	243	case ESPIPE:printf("errno =ESPIPE\n");break;
-		244	case ENXIO:printf("errno =ENXIO\n");break;
-		245	}
231	return errno;	246	//return errno;
-		247	}
232		248
233	result = read(dev->nFileNo, pvBuffer, count);	-
234		249
-		250	result = read(dev->nFileNo, pvBuffer, count);
-		251	printf("VMEread: read %d dev->nFileNo=%d err=%d %s\n",count, dev->nFileNo, errno, strerror(errno));
235	if (result != count)	252	if (result != count)
236	{	253	{
237	if (result < 0)	254	if (result < 0)
238	{	255	{
239	dev->nLastError = errno;	256	dev->nLastError = errno;
240	return errno;	257	return errno;
241	}	258	}
242	else	259	else
243	return EFAULT;	260	return EFAULT;
244	}	261	}
245		262
246	return 0;	263	return 0;
247	}	264	}
248		265
249	int VMEwrite(int nHandle, unsigned long ulAddress, unsigned char ubAccessWidth, unsigned long ulElementCount, void *pvBuffer)	266	int VMEwrite(int nHandle, unsigned long ulAddress, unsigned char ubAccessWidth, unsigned long ulElementCount, void *pvBuffer)
250	{	267	{
251	VMEMM_DEVICE dev = (VMEMM_DEVICE )nHandle;	268	VMEMM_DEVICE dev = (VMEMM_DEVICE )nHandle;
252	size_t count = (size_t)(ulElementCount * ubAccessWidth);	269	size_t count = (size_t)(ulElementCount * ubAccessWidth);
253	ssize_t result;	270	ssize_t result;
254	int error;	271	int error;
-		272	long pos;
255		273
-		274	printf("VMEwrite: AW 0x%0x 0x%0x , AM 0x%0x \n", dev->cAccessWidth, ubAccessWidth, dev->cAddressModifier);
256	if (dev->cAccessWidth != ubAccessWidth)	275	if (dev->cAccessWidth != ubAccessWidth)
257	{	276	{
258	if ((error = setAccessProperties(nHandle, dev->cAddressModifier, ubAccessWidth)))	277	if ((error = setAccessProperties(nHandle, dev->cAddressModifier, ubAccessWidth)))
259	return error;	278	return error;
260	}	279	}
261		280
262	if (lseek(dev->nFileNo, ulAddress, SEEK_SET) < 0)	281	pos = lseek(dev->nFileNo, ulAddress, SEEK_SET);
-		282	if (pos < 0){
-		283	printf("VMEwrite: pos=0x%08lx dev->nFileNo=%d ADDR=0x%08lx %s\n",pos, dev->nFileNo, ulAddress, strerror(errno));
-		284	switch (errno){
-		285	case EBADF:printf("errno =EBADF\n");break;
-		286	case EINVAL:printf("errno =EINVAL\n");break;
-		287	case EOVERFLOW:printf("errno =EOVERFLOW\n");break;
-		288	case ESPIPE:printf("errno =ESPIPE\n");break;
-		289	case ENXIO:printf("errno =ENXIO\n");break;
-		290	}
263	return errno;	291	//return errno;
264		292	}
265	result = write(dev->nFileNo, pvBuffer, count);	293	result = write(dev->nFileNo, pvBuffer, count);
266		-
-		294	printf("VMEwrite: write %d dev->nFileNo=%d err=%d %s\n",count, dev->nFileNo,errno, strerror(errno));
267	if (result != count)	295	if (result != count)
268	{	296	{
269	if (result < 0)	297	if (result < 0)
270	{	298	{
271	dev->nLastError = errno;	299	dev->nLastError = errno;
-		300
272	return errno;	301	return errno;
273	}	302	}
274	else	303	else
275	return EFAULT;	304	return EFAULT;
276	}	305	}
277		306
278	return 0;	307	return 0;
279	}	308	}
280		309
281	int VMEaccessVIC(int nHandle, unsigned char ubAccessMode, unsigned short uwAddress, unsigned char *ubContent)	310	int VMEaccessVIC(int nHandle, unsigned char ubAccessMode, unsigned short uwAddress, unsigned char *ubContent)
282	{	311	{
283	VMEMM_DEVICE dev = (VMEMM_DEVICE )nHandle;	312	VMEMM_DEVICE dev = (VMEMM_DEVICE )nHandle;
284	PCIVME_VIC68A_ACTION vic68a_action;	313	PCIVME_VIC68A_ACTION vic68a_action;
285		314
286	vic68a_action.bAccessMode = ubAccessMode;	315	vic68a_action.bAccessMode = ubAccessMode;
287	vic68a_action.bContent = *ubContent;	316	vic68a_action.bContent = *ubContent;
288	vic68a_action.wRegisterAddress = uwAddress;	317	vic68a_action.wRegisterAddress = uwAddress;
289		318
290	if (ioctl(dev->nFileNo, PCIVME_ACCESS_VIC68A, &vic68a_action) < 0)	319	if (ioctl(dev->nFileNo, PCIVME_ACCESS_VIC68A, &vic68a_action) < 0)
291	{	320	{
292	dev->nLastError = errno;	321	dev->nLastError = errno;
293	return errno;	322	return errno;
294	}	323	}
295		324
296	*ubContent = vic68a_action.bContent;	325	*ubContent = vic68a_action.bContent;
297		326
298	return 0;	327	return 0;
299	}	328	}
300		329
301	int VMEreset(int nHandle)	330	int VMEreset(int nHandle)
302	{	331	{
303	VMEMM_DEVICE dev = (VMEMM_DEVICE )nHandle;	332	VMEMM_DEVICE dev = (VMEMM_DEVICE )nHandle;
304	PCIVME_RESET_COMMAND reset_command;	333	PCIVME_RESET_COMMAND reset_command;
305	int i = 10;	334	int i = 10;
306		335
307	reset_command.bCommand = GLOBAL_RESET_CMD;	336	reset_command.bCommand = GLOBAL_RESET_CMD;
308	reset_command.bResult = 0xff;	337	reset_command.bResult = 0xff;
309		338
310	if (ioctl(dev->nFileNo, PCIVME_RESET, &reset_command) < 0)	339	if (ioctl(dev->nFileNo, PCIVME_RESET, &reset_command) < 0)
311	{	340	{
312	dev->nLastError = errno;	341	dev->nLastError = errno;
313	return errno;	342	return errno;
314	}	343	}
315		344
316	do	345	do
317	{	346	{
318	usleep(100);	347	usleep(100);
319	reset_command.bCommand = POLL_RESET_CMD;	348	reset_command.bCommand = POLL_RESET_CMD;
320	reset_command.bResult = 0xff;	349	reset_command.bResult = 0xff;
321		350
322	if (ioctl(dev->nFileNo, PCIVME_RESET, &reset_command) < 0)	351	if (ioctl(dev->nFileNo, PCIVME_RESET, &reset_command) < 0)
323	{	352	{
324	dev->nLastError = errno;	353	dev->nLastError = errno;
325	return errno;	354	return errno;
326	}	355	}
327	} while ((reset_command.bResult) && (i--));	356	} while ((reset_command.bResult) && (i--));
328		357
329	if (!i)	358	if (!i)
330	return ETIME;	359	return ETIME;
331		360
332	dev->nLastError = 0;	361	dev->nLastError = 0;
333		362
334	return 0;	363	return 0;
335	}	364	}
336		365
337	int VMETAS(int nHandle, unsigned long ulAddress, unsigned char *ubResult)	366	int VMETAS(int nHandle, unsigned long ulAddress, unsigned char *ubResult)
338	{	367	{
339	VMEMM_DEVICE dev = (VMEMM_DEVICE )nHandle;	368	VMEMM_DEVICE dev = (VMEMM_DEVICE )nHandle;
340	PCIVME_TAS_STRUCT tas;	369	PCIVME_TAS_STRUCT tas;
341		370
342	tas.bContent = *ubResult;	371	tas.bContent = *ubResult;
343	tas.bModifier = dev->cAddressModifier;	372	tas.bModifier = dev->cAddressModifier;
344	tas.dwAddress = ulAddress;	373	tas.dwAddress = ulAddress;
345		374
346	if (ioctl(dev->nFileNo, PCIVME_TAS, &tas) < 0)	375	if (ioctl(dev->nFileNo, PCIVME_TAS, &tas) < 0)
347	{	376	{
348	dev->nLastError = errno;	377	dev->nLastError = errno;
349	return errno;	378	return errno;
350	}	379	}
351		380
352	*ubResult = tas.bContent;	381	*ubResult = tas.bContent;
353		382
354	return 0;	383	return 0;
355	}	384	}
356		385
357	int VMEinterrupt(int nHandle, unsigned char *ubVector)	386	int VMEinterrupt(int nHandle, unsigned char *ubVector)
358	{	387	{
359	VMEMM_DEVICE dev = (VMEMM_DEVICE )nHandle;	388	VMEMM_DEVICE dev = (VMEMM_DEVICE )nHandle;
360	PCIVME_VECTOR_LEVEL ubLocalVector;	389	PCIVME_VECTOR_LEVEL ubLocalVector;
361		390
362	if (ioctl(dev->nFileNo, PCIVME_READ_VECTOR_POLL, &ubLocalVector) < 0)	391	if (ioctl(dev->nFileNo, PCIVME_READ_VECTOR_POLL, &ubLocalVector) < 0)
363	{	392	{
364	dev->nLastError = errno;	393	dev->nLastError = errno;
365	return errno;	394	return errno;
366	}	395	}
367		396
368	*ubVector = (__u8)ubLocalVector.dwStatusID;	397	*ubVector = (__u8)ubLocalVector.dwStatusID;
369		398
370	return 0;	399	return 0;
371	}	400	}
372		401
373	int VMEsysfailGet(int nHandle, BOOLEAN *bResult)	402	int VMEsysfailGet(int nHandle, BOOLEAN *bResult)
374	{	403	{
375	VMEMM_DEVICE dev = (VMEMM_DEVICE )nHandle;	404	VMEMM_DEVICE dev = (VMEMM_DEVICE )nHandle;
376	PCIVME_VIC68A_ACTION sAction; // structure to access vic chip	405	PCIVME_VIC68A_ACTION sAction; // structure to access vic chip
377		406
378	sAction.wRegisterAddress = EGICR;	407	sAction.wRegisterAddress = EGICR;
379	sAction.bAccessMode = VIC68A_READ;	408	sAction.bAccessMode = VIC68A_READ;
380	sAction.bContent = 0;	409	sAction.bContent = 0;
381		410
382	if (ioctl(dev->nFileNo, PCIVME_ACCESS_VIC68A, &sAction) < 0)	411	if (ioctl(dev->nFileNo, PCIVME_ACCESS_VIC68A, &sAction) < 0)
383	{	412	{
384	dev->nLastError = errno;	413	dev->nLastError = errno;
385	return errno;	414	return errno;
386	}	415	}
387		416
388	*bResult = (sAction.bContent & 0x08) ? FALSE : TRUE;	417	*bResult = (sAction.bContent & 0x08) ? FALSE : TRUE;
389		418
390	return 0;	419	return 0;
391	}	420	}
392		421
393	int VMEsysfailSet(int nHandle, BOOLEAN bForce)	422	int VMEsysfailSet(int nHandle, BOOLEAN bForce)
394	{	423	{
395	VMEMM_DEVICE dev = (VMEMM_DEVICE )nHandle;	424	VMEMM_DEVICE dev = (VMEMM_DEVICE )nHandle;
396	PCIVME_VIC68A_ACTION sAction; // structure to access vic chip	425	PCIVME_VIC68A_ACTION sAction; // structure to access vic chip
397		426
398	sAction.wRegisterAddress = ICR7;	427	sAction.wRegisterAddress = ICR7;
399	sAction.bAccessMode = (bForce == TRUE) ? VIC68A_AND : VIC68A_OR;	428	sAction.bAccessMode = (bForce == TRUE) ? VIC68A_AND : VIC68A_OR;
400	sAction.bContent = (bForce == TRUE) ? 0x3F : 0x80;	429	sAction.bContent = (bForce == TRUE) ? 0x3F : 0x80;
401		430
402	if (ioctl(dev->nFileNo, PCIVME_ACCESS_VIC68A, &sAction) < 0)	431	if (ioctl(dev->nFileNo, PCIVME_ACCESS_VIC68A, &sAction) < 0)
403	{	432	{
404	dev->nLastError = errno;	433	dev->nLastError = errno;
405	return errno;	434	return errno;
406	}	435	}
407		436
408	return 0;	437	return 0;
409	}	438	}
410		439
411	int VMEerror(int nHandle)	440	int VMEerror(int nHandle)
412	{	441	{
413	__u8 ubVector;	442	__u8 ubVector;
414		443
415	VMEinterrupt(nHandle, &ubVector);	444	VMEinterrupt(nHandle, &ubVector);
416		445
417	if (ubVector == 7)	446	if (ubVector == 7)
418	return EFAULT; // it's a bus error	447	return EFAULT; // it's a bus error
419	else	448	else
420	return 0;	449	return 0;
421	}	450	}
422		451
423	int VMEclose(int nHandle)	452	int VMEclose(int nHandle)
424	{	453	{
425	int error = 0;	454	int error = 0;
426	VMEMM_DEVICE dev = (VMEMM_DEVICE )nHandle;	455	VMEMM_DEVICE dev = (VMEMM_DEVICE )nHandle;
427		456
428	if (dev != (VMEMM_DEVICE *)NULL)	457	if (dev != (VMEMM_DEVICE *)NULL)
429	{	458	{
430	deInitHardware(dev);	459	deInitHardware(dev);
431		460
432	if (dev->nFileNo != -1)	461	if (dev->nFileNo != -1)
433	close(dev->nFileNo);	462	close(dev->nFileNo);
434	else	463	else
435	error = -EINVAL;	464	error = -EINVAL;
436		465
437	free(dev);	466	free(dev);
438	}	467	}
439		468
440	return error;	469	return error;
441	}	470	}
442		471
443	int VMEcontrolInterrupt(int nHandle, BOOLEAN *bEnable)	472	int VMEcontrolInterrupt(int nHandle, BOOLEAN *bEnable)
444	{	473	{
445	VMEMM_DEVICE dev = (VMEMM_DEVICE )nHandle;	474	VMEMM_DEVICE dev = (VMEMM_DEVICE )nHandle;
446	PCIVME_IRQ_CONTROL control;	475	PCIVME_IRQ_CONTROL control;
447		476
448	control.bEnable = *bEnable;	477	control.bEnable = *bEnable;
449		478
450	if (ioctl(dev->nFileNo, PCIVME_CONTROL_INTERRUPTS, &control) < 0)	479	if (ioctl(dev->nFileNo, PCIVME_CONTROL_INTERRUPTS, &control) < 0)
451	{	480	{
452	dev->nLastError = errno;	481	dev->nLastError = errno;
453	return errno;	482	return errno;
454	}	483	}
455		484
456	// status of interrupt enable before set	485	// status of interrupt enable before set
457	*bEnable = control.bEnable;	486	*bEnable = control.bEnable;
458		487
459	return 0;	488	return 0;
460	}	489	}
461		490
462	int GetLastError(int nHandle)	491	int GetLastError(int nHandle)
463	{	492	{
464	VMEMM_DEVICE dev = (VMEMM_DEVICE )nHandle;	493	VMEMM_DEVICE dev = (VMEMM_DEVICE )nHandle;
465	int nLocalError;	494	int nLocalError;
466		495
467	nLocalError = dev->nLastError;	496	nLocalError = dev->nLastError;
468	dev->nLastError = 0;	497	dev->nLastError = 0;

Subversion Repositories f9daq

(root)/pcivme-3.2/lib/pcivme_ni.c @ 9 – Rev 9 → 11