Subversion Repositories f9daq

Rev

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