Rev 125 | Rev 138 | 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 | |
| 136 | f9daq | 264 | return (short)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 | |
| 136 | f9daq | 283 | return (short)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 ) { |
| 136 | f9daq | 302 | return (short) 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 ) { |
| 136 | f9daq | 321 | return (short) WUSBXX_stack_execute (WUSB_udev,(char *) Data); |
| 82 | f9daq | 322 | } |