Subversion Repositories f9daq

Rev

Rev 136 | Rev 139 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
100 f9daq 1 
#ifdef LINUX
2 
#include <dlfcn.h>
3 
#define LoadLibrary(x) dlopen( (x), RTLD_NOW );
4 
#define GetProcAddress(x,y) dlsym((x),(y))
5 
#define __stdcall
6 
#define UCHAR unsigned char
7 
#define HINSTANCE void *
8 
#define  _VI_FUNC
9 
#include <stdlib.h>
10 
#include <stdio.h>
11 
#include <stdint.h>
12 
#include <string.h>
13 
#endif
14 
 
61 f9daq 15 
#include "wusbvme_dll.h"
16 
 
82 f9daq 17 
usb_dev_handle *WUSB_udev;
18 
 
61 f9daq 19 
static HINSTANCE DLLHandle;
20 
 
100 f9daq 21 
 
22 
short __stdcall WIENER_VMUSB_VME_R( uint16_t AM, uint16_t DW,  uint32_t VME_Address, uint32_t *Data);
23 
 
24 
short __stdcall WIENER_VMUSB_VME_W( uint16_t AM, uint16_t DW, uint32_t VME_Address, uint32_t Data);
25 
 
26 
short __stdcall WIENER_VMUSB_VME_MW( uint16_t AM, uint16_t DW, uint32_t VME_Address, uint32_t Data);
27 
short __stdcall WIENER_VMUSB_VME_MWRST( void );
28 
short __stdcall WIENER_VMUSB_VME_MWEXEC( void );
29 
 
30 
short __stdcall WIENER_VMUSB_VME_MR( uint16_t AM, uint16_t DW, uint32_t VME_Address, uint32_t *Data);
31 
short __stdcall WIENER_VMUSB_VME_MRRST( void );
32 
short __stdcall WIENER_VMUSB_VME_MREXEC(  uint32_t *Data  );
33 
 
34 
 
138 f9daq 35 
#ifdef XXDLL
36 
 
100 f9daq 37 
short __stdcall xxusb_register_read(usb_dev_handle *hDev, short RegAddr, long *RegData);
38 
short __stdcall xxusb_stack_read(usb_dev_handle *hDev, short StackAddr, long *StackData);
39 
short __stdcall xxusb_stack_write(usb_dev_handle *hDev, short StackAddr, long *StackData);
40 
short __stdcall xxusb_stack_execute(usb_dev_handle *hDev, long *StackData);
41 
short __stdcall xxusb_longstack_execute(usb_dev_handle *hDev, void *DataBuffer, int lDataLen, int timeout);
42 
short __stdcall xxusb_register_write(usb_dev_handle *hDev, short RegAddr, long RegData);
43 
short __stdcall xxusb_usbfifo_read(usb_dev_handle *hDev, long *DataBuffer, short lDataLen, int timeout);
44 
short __stdcall xxusb_bulk_read(usb_dev_handle *hDev, char *DataBuffer, short lDataLen, int timeout);
45 
short __stdcall xxusb_bulk_write(usb_dev_handle *hDev, char *DataBuffer, short lDataLen, int timeout);
46 
short __stdcall xxusb_reset_toggle(usb_dev_handle *hDev);
47 
 
48 
short __stdcall xxusb_devices_find(xxusb_device_type *xxusbDev);
49 
short __stdcall xxusb_device_close(usb_dev_handle *hDev);
50 
usb_dev_handle* __stdcall xxusb_device_open(struct usb_device *dev);
51 
short __stdcall xxusb_flash_program(usb_dev_handle *hDev, char *config, short nsect);
52 
short __stdcall xxusb_flashblock_program(usb_dev_handle *hDev, UCHAR *config);
53 
usb_dev_handle* __stdcall xxusb_serial_open(char *SerialString);
54 
 
55 
short __stdcall VME_register_write(usb_dev_handle *hdev, long VME_Address, long Data);
56 
short __stdcall VME_register_read(usb_dev_handle *hdev, long VME_Address, long *Data);
57 
short __stdcall VME_LED_settings(usb_dev_handle *hdev, int LED, int code, int invert, int latch);
58 
 
59 
short __stdcall VME_DGG(usb_dev_handle *hdev, unsigned short channel, unsigned short trigger,unsigned short output, long delay, unsigned short gate, unsigned short invert, unsigned short latch);
60 
 
61 
short __stdcall VME_Output_settings(usb_dev_handle *hdev, int Channel, int code, int invert, int latch);
62 
 
63 
short __stdcall VME_read_16(usb_dev_handle *hdev,short Address_Modifier, long VME_Address, long *Data);
64 
short __stdcall VME_read_32(usb_dev_handle *hdev, short Address_Modifier, long VME_Address, long *Data);
65 
short __stdcall VME_BLT_read_32(usb_dev_handle *hdev, short Address_Modifier, int count, long VME_Address, long Data[]);
66 
short __stdcall VME_write_16(usb_dev_handle *hdev, short Address_Modifier, long VME_Address, long Data);
67 
short __stdcall VME_write_32(usb_dev_handle *hdev, short Address_Modifier, long VME_Address, long Data);
68 
 
69 
 
125 f9daq 70 
void _VI_FUNC WIENER_VMUSB_load (const char* module_path) {
100 f9daq 71 
  if (module_path == NULL) {
138 f9daq 72 
    DLLHandle = LoadLibrary("c:\\Windows\\system32\\libxxusb.dll");
100 f9daq 73 
  } else {
61 f9daq 74 
    DLLHandle = LoadLibrary(module_path);
100 f9daq 75 
  }
88 f9daq 76 
  if (!DLLHandle) {
125 f9daq 77 
    printf ("\n\nFailed to Open libxxusb.dll  \n");
138 f9daq 78 
    printf("LastError 0x%x\n",GetLastError() );
125 f9daq 79 
    return;
88 f9daq 80 
  }
100 f9daq 81 
  if (!(xxusb_register_read_Ptr = (void *) GetProcAddress(DLLHandle,"xxusb_register_read"))) exit(1);
61 f9daq 82 
  if (!(xxusb_stack_read_Ptr = (void*) GetProcAddress(DLLHandle,"xxusb_stack_read"))) exit(1);
83 
  if (!(xxusb_stack_write_Ptr = (void*) GetProcAddress(DLLHandle,"xxusb_stack_write"))) exit(1);
84 
  if (!(xxusb_stack_execute_Ptr = (void*) GetProcAddress(DLLHandle,"xxusb_stack_execute"))) exit(1);
82 f9daq 85 
  if (!(xxusb_longstack_execute_Ptr = (void*) GetProcAddress(DLLHandle,"xxusb_longstack_execute"))) exit(1);
61 f9daq 86 
  if (!(xxusb_register_write_Ptr = (void*) GetProcAddress(DLLHandle,"xxusb_register_write"))) exit(1);
87 
  if (!(xxusb_usbfifo_read_Ptr = (void*) GetProcAddress(DLLHandle,"xxusb_usbfifo_read"))) exit(1);
88 
  if (!(xxusb_bulk_read_Ptr = (void*) GetProcAddress(DLLHandle,"xxusb_bulk_read"))) exit(1);
89 
  if (!(xxusb_bulk_write_Ptr = (void*) GetProcAddress(DLLHandle,"xxusb_bulk_write"))) exit(1);
90 
  if (!(xxusb_reset_toggle_Ptr = (void*) GetProcAddress(DLLHandle,"xxusb_reset_toggle"))) exit(1);
91 
 
92 
  if (!(xxusb_devices_find_Ptr = (void*) GetProcAddress(DLLHandle,"xxusb_devices_find"))) exit(1);
93 
  if (!(xxusb_device_close_Ptr = (void*) GetProcAddress(DLLHandle,"xxusb_device_close"))) exit(1);
94 
  if (!(xxusb_device_open_Ptr = (void*) GetProcAddress(DLLHandle,"xxusb_device_open"))) exit(1);
95 
  if (!(xxusb_flash_program_Ptr = (void*) GetProcAddress(DLLHandle,"xxusb_flash_program"))) exit(1);
96 
  if (!(xxusb_flashblock_program_Ptr = (void*) GetProcAddress(DLLHandle,"xxusb_flashblock_program"))) exit(1);
97 
  if (!(xxusb_serial_open_Ptr = (void*) GetProcAddress(DLLHandle,"xxusb_serial_open"))) exit(1);
98 
  if (!(VME_register_write_Ptr = (void*) GetProcAddress(DLLHandle,"VME_register_write"))) exit(1);
99 
  if (!(VME_register_read_Ptr = (void*) GetProcAddress(DLLHandle,"VME_register_read"))) exit(1);
100 
  if (!(VME_LED_settings_Ptr = (void*) GetProcAddress(DLLHandle,"VME_LED_settings"))) exit(1);
101 
  if (!(VME_DGG_Ptr = (void*) GetProcAddress(DLLHandle,"VME_DGG"))) exit(1);
102 
  if (!(VME_Output_settings_Ptr = (void*) GetProcAddress(DLLHandle,"VME_Output_settings"))) exit(1);
103 
  if (!(VME_read_16_Ptr = (void*) GetProcAddress(DLLHandle,"VME_read_16"))) exit(1);
104 
  if (!(VME_read_32_Ptr = (void*) GetProcAddress(DLLHandle,"VME_read_32"))) exit(1);
105 
  if (!(VME_BLT_read_32_Ptr = (void*) GetProcAddress(DLLHandle,"VME_BLT_read_32"))) exit(1);
106 
  if (!(VME_write_16_Ptr = (void*) GetProcAddress(DLLHandle,"VME_write_16"))) exit(1);
107 
  if (!(VME_write_32_Ptr = (void*) GetProcAddress(DLLHandle,"VME_write_32"))) exit(1);
108 
}
109 
 
138 f9daq 110 
#else
111 
 
112 
void _VI_FUNC WIENER_VMUSB_load (const char* module_path) {
113 
 
114 
}
115 
#endif
116 
 
125 f9daq 117 
void _VI_FUNC WIENER_VMUSB_open (const char *serial) {
118 
 
82 f9daq 119 
  xxusb_device_type devices[100];
120 
  struct usb_device *dev;
61 f9daq 121 
  if (serial != NULL)
125 f9daq 122 
    WUSB_udev = xxusb_serial_open((char *) serial);
82 f9daq 123 
  else  {
125 f9daq 124 
    //Find XX_USB devices and open the first one found
82 f9daq 125 
    xxusb_devices_find(devices);
126 
    dev = devices[0].usbdev;
125 f9daq 127 
    WUSB_udev = xxusb_device_open(dev);
128 
  }
82 f9daq 129 
  // Make sure VM_USB opened OK
130 
  if(!WUSB_udev) {
131 
    printf ("\n\nFailed to Open VM_USB \n\n");
132 
    return ;
133 
  } else {
134 
    printf("VM-USB Device open.!\n");
125 f9daq 135 
  }
136 
 
137 
 
61 f9daq 138 
}
139 
 
125 f9daq 140 
void _VI_FUNC WIENER_VMUSB_close (void) {
82 f9daq 141 
  if (WUSB_udev) xxusb_device_close(WUSB_udev);
61 f9daq 142 
}
82 f9daq 143 
 
144 
 
92 f9daq 145 
uint32_t fStack[MAXSTACKSIZE];
125 f9daq 146 
uint32_t fStackSize;
82 f9daq 147 
 
125 f9daq 148 
int WIENER_VMUSB_StackInit() {
149 
  fStack[0]=1;
150 
  fStackSize=1;
151 
  return fStack[0];
82 f9daq 152 
}
153 
 
125 f9daq 154 
void WIENER_VMUSB_StackClear() {
155 
  WIENER_VMUSB_StackInit();
82 f9daq 156 
}
157 
 
125 f9daq 158 
int WIENER_VMUSB_StackGetUInt16(int maxn, uint16_t *stack) {
82 f9daq 159 
  int i;
125 f9daq 160 
  uint16_t * u16Stack = (uint16_t *) fStack;
161 
  for (i=0; i< fStackSize*2; i++) {
162 
    if (i<maxn) stack[i]=u16Stack[i];
163 
    else return -1;
82 f9daq 164 
  }
92 f9daq 165 
  return fStackSize*2;
82 f9daq 166 
}
167 
 
125 f9daq 168 
int WIENER_VMUSB_StackGetUInt32(int maxn, uint32_t *stack) {
82 f9daq 169 
  int i;
92 f9daq 170 
  uint16_t * u16Stack = (uint16_t *) fStack;
125 f9daq 171 
  for (i=0; i< fStackSize*2; i++) {
172 
    if (i<maxn) stack[i]=u16Stack[i];
173 
    else return -1;
82 f9daq 174 
  }
92 f9daq 175 
  return fStackSize*2;
82 f9daq 176 
}
177 
 
178 
 
125 f9daq 179 
int WIENER_VMUSB_StackAppend(int cmd, uint32_t addr ) {
92 f9daq 180 
  if (fStackSize+2 >= MAXSTACKSIZE) {
181 
    fprintf(stderr,"WIENER_VMUSB_StackAppend Maximum stack size reached! Increase....%d\n", fStackSize+2);
82 f9daq 182 
    return -1;
183 
  }
92 f9daq 184 
  fStack[fStackSize ++]   = cmd;
185 
  fStack[fStackSize ++]   = addr;
82 f9daq 186 
  fStack[0]+=4;
187 
  return fStack[0];
188 
}
189 
 
125 f9daq 190 
int WIENER_VMUSB_StackAppendData(int cmd,uint32_t addr ,uint32_t data) {
191 
 
82 f9daq 192 
  WIENER_VMUSB_StackAppend( cmd, addr );
125 f9daq 193 
 
92 f9daq 194 
  if (fStackSize+1 >= MAXSTACKSIZE) {
195 
    fprintf(stderr,"WIENER_VMUSB_StackAppendData Maximum stack size reached! Increase....%d\n", fStackSize+1);
82 f9daq 196 
    return -1;
197 
  }
92 f9daq 198 
  fStack[fStackSize++]  =  data;
82 f9daq 199 
  fStack[0]+=2;
200 
  return fStack[0];
201 
}
202 
 
125 f9daq 203 
void WIENER_VMUSB_StackConditionalRead(int adr_mod,int d16d32, uint32_t addr,uint32_t bmask) {
204 
  WIENER_VMUSB_StackAppend(CMD_READ| CMD_HD | adr_mod ,addr);
205 
  WIENER_VMUSB_StackAppendData(CMD_READ| CMD_HD | CMD_HM |adr_mod, d16d32 |addr,bmask);
82 f9daq 206 
}
207 
 
125 f9daq 208 
void WIENER_VMUSB_StackMultiRead(int adr_mod,int d16d32,uint32_t baseaddr, int n, uint32_t increment) {
209 
  int i;
210 
  for (i=0; i<n; i++) WIENER_VMUSB_StackAppend( adr_mod | CMD_READ, d16d32 +baseaddr + i*increment);
82 f9daq 211 
}
125 f9daq 212 
void WIENER_VMUSB_StackMultiWrite(int adr_mod,int d16d32,uint32_t baseaddr, int n, uint32_t increment, uint32_t data) {
213 
  int i;
214 
  for (i=0; i<n; i++)  WIENER_VMUSB_StackAppendData( adr_mod | CMD_WRITE,d16d32 + baseaddr+i*increment, data);
82 f9daq 215 
}
216 
 
125 f9daq 217 
void WIENER_VMUSB_StackPrint() {
218 
  uint16_t * u16Stack = (uint16_t *) fStack;
219 
  uint32_t i;
220 
  for (i=0; i < fStackSize*2; i++) printf("0x%04x\n",u16Stack[i]);
221 
  printf("size of stack %d __________________________________\n",fStackSize*2-1);
82 f9daq 222 
}
223 
 
224 
 
225 
char wusbcc_stack[MAXSTACKSIZE*4];
226 
 
227 
 
125 f9daq 228 
int _VI_FUNC WUSBXX_stack_execute (usb_dev_handle * dev, char * stack) {
82 f9daq 229 
  int i, nb=0;
92 f9daq 230 
  if (!dev) {
125 f9daq 231 
    printf("WUSBXX_stack_execute device not open\n");
92 f9daq 232 
    return -1;
125 f9daq 233 
  }
82 f9daq 234 
  uint16_t * exstack = (uint16_t *) wusbcc_stack;
235 
  exstack[0]=0;
236 
  nb = WIENER_VMUSB_StackGetUInt16(MAXSTACKSIZE, &exstack[1] );
92 f9daq 237 
  //printf("WUSBXX_stack_execute stack size %d\n", nb);
82 f9daq 238 
  //WIENER_VMUSB_StackPrint();
239 
  nb = xxusb_longstack_execute (dev,  exstack, nb, 1000);
92 f9daq 240 
  //DataBuffer(0 - (ReturnValue/2-1)) - (unsigned short)array of returned data when ReturnValue>0
125 f9daq 241 
  //printf("WUSBXX_stack_execute return size %d\n", nb);
92 f9daq 242 
  if (nb<0 ) printf("xxusb_longstack_execute %s line:%d err=%d %s\n",__FILE__,__LINE__,nb, strerror(-nb) );
125 f9daq 243 
  if (stack!=NULL) for ( i=0; i<nb; i++) stack[i]=wusbcc_stack[i];
82 f9daq 244 
  return nb/sizeof(uint32_t);
245 
}
246 
 
247 
 
248 
 
249 
#ifndef VME_D32
250 
 
251 
#define VME_D8  0x1
252 
#define VME_D16 0x2
253 
#define VME_D32 0x4
254 
#endif
255 
 
256 
 
125 f9daq 257 
short __stdcall WIENER_VMUSB_VME_R( uint16_t AM, uint16_t DW,  uint32_t VME_Address, uint32_t *Data) {
258 
  int nb=0;
259 
  if (!WUSB_udev) return -222;
260 
 
261 
  switch (DW) {
262 
    case VME_D16:
263 
      nb=  VME_read_16(WUSB_udev, AM,VME_Address,(long int *) Data);
264 
      break;
265 
    case VME_D32:
266 
      nb=  VME_read_32(WUSB_udev, AM,VME_Address,(long int *)Data);
267 
      break;
268 
    default:
269 
      return 0;
270 
  }
82 f9daq 271 
//printf("R 0x%02x 0x%02x 0x%08x %x\n", AM , DW, VME_Address, *Data);
125 f9daq 272 
  if (nb<0)  printf("%s %d %d %s\n",__FILE__,__LINE__,nb, strerror(-nb) );
82 f9daq 273 
 
136 f9daq 274 
  return (short)nb;
82 f9daq 275 
}
276 
 
125 f9daq 277 
short __stdcall WIENER_VMUSB_VME_W( uint16_t AM, uint16_t DW, uint32_t VME_Address, uint32_t Data) {
278 
  int nb=0;
279 
  if (!WUSB_udev) return -222;
280 
//  printf("W 0x%02x 0x%02x 0x%08x %x\n", AM , DW, VME_Address, Data);
281 
  switch (DW) {
282 
    case VME_D16:
283 
      nb=    VME_write_16(WUSB_udev, AM,VME_Address,Data);
284 
      break;
285 
    case VME_D32:
286 
      nb=    VME_write_32(WUSB_udev, AM,VME_Address,Data);
287 
      break;
288 
    default:
289 
      return 0;
290 
  }
291 
  if (nb<0)  printf("%s %d %d %s\n",__FILE__,__LINE__,nb, strerror(-nb) );
82 f9daq 292 
 
136 f9daq 293 
  return (short)nb;
82 f9daq 294 
}
295 
 
125 f9daq 296 
short __stdcall WIENER_VMUSB_VME_MW( uint16_t AM, uint16_t DW, uint32_t VME_Address, uint32_t Data) {
297 
  switch (DW) {
298 
    case VME_D16:
299 
      return  (short) WIENER_VMUSB_StackAppendData(CMD_WRITE | AM , VME_Address | CMD_D16 , Data);
300 
    case VME_D32:
301 
      return  (short) WIENER_VMUSB_StackAppendData(CMD_WRITE | AM , VME_Address | CMD_D32 , Data);
302 
    default:
303 
      return 0;
304 
  }
305 
  return 0;
82 f9daq 306 
}
125 f9daq 307 
short __stdcall WIENER_VMUSB_VME_MWRST( void ) {
308 
  WIENER_VMUSB_StackInit();
309 
  return 0;
82 f9daq 310 
}
125 f9daq 311 
short __stdcall WIENER_VMUSB_VME_MWEXEC( void ) {
136 f9daq 312 
  return (short) WUSBXX_stack_execute (WUSB_udev, NULL);
82 f9daq 313 
}
314 
 
125 f9daq 315 
short __stdcall WIENER_VMUSB_VME_MR( uint16_t AM, uint16_t DW, uint32_t VME_Address, uint32_t *Data) {
316 
  switch (DW) {
317 
    case VME_D16:
318 
      return  (short) WIENER_VMUSB_StackAppend(CMD_READ | AM , VME_Address | CMD_D16 );
319 
    case VME_D32:
320 
      return  (short) WIENER_VMUSB_StackAppend(CMD_READ | AM , VME_Address | CMD_D32 );
321 
    default:
322 
      return 0;
323 
  }
324 
  return 0;
82 f9daq 325 
}
125 f9daq 326 
short __stdcall WIENER_VMUSB_VME_MRRST( void ) {
327 
  WIENER_VMUSB_StackInit();
328 
  return 0;
82 f9daq 329 
}
125 f9daq 330 
short __stdcall WIENER_VMUSB_VME_MREXEC(  uint32_t *Data  ) {
136 f9daq 331 
  return (short) WUSBXX_stack_execute (WUSB_udev,(char *) Data);
82 f9daq 332 
}