| 1,19 → 1,23 |
|---|
| #include "wusbvme_dll.h" |
| |
| usb_dev_handle *udev; |
| |
| usb_dev_handle *WUSB_udev; |
| |
| static HINSTANCE DLLHandle; |
| |
| void _VI_FUNC WUSBVME_load (char* module_path) |
| void _VI_FUNC WIENER_VMUSB_load (char* module_path) |
| { |
| if (module_path == NULL) |
| DLLHandle = LoadLibrary("libxxusb.dll"); |
| else |
| DLLHandle = LoadLibrary(module_path); |
| |
| if (!DLLHandle) return; |
| |
| if (!(xxusb_register_read_Ptr = (void*) GetProcAddress(DLLHandle,"xxusb_register_read"))) exit(1); |
| if (!(xxusb_stack_read_Ptr = (void*) GetProcAddress(DLLHandle,"xxusb_stack_read"))) exit(1); |
| if (!(xxusb_stack_write_Ptr = (void*) GetProcAddress(DLLHandle,"xxusb_stack_write"))) exit(1); |
| if (!(xxusb_stack_execute_Ptr = (void*) GetProcAddress(DLLHandle,"xxusb_stack_execute"))) exit(1); |
| if (!(xxusb_longstack_execute_Ptr = (void*) GetProcAddress(DLLHandle,"xxusb_longstack_execute"))) exit(1); |
| if (!(xxusb_register_write_Ptr = (void*) GetProcAddress(DLLHandle,"xxusb_register_write"))) exit(1); |
| if (!(xxusb_usbfifo_read_Ptr = (void*) GetProcAddress(DLLHandle,"xxusb_usbfifo_read"))) exit(1); |
| if (!(xxusb_bulk_read_Ptr = (void*) GetProcAddress(DLLHandle,"xxusb_bulk_read"))) exit(1); |
| 38,13 → 42,203 |
|---|
| if (!(VME_write_32_Ptr = (void*) GetProcAddress(DLLHandle,"VME_write_32"))) exit(1); |
| } |
| |
| void _VI_FUNC WUSBVME_open (char *serial) |
| void _VI_FUNC WIENER_VMUSB_open (char *serial) |
| { |
| |
| xxusb_device_type devices[100]; |
| struct usb_device *dev; |
| if (serial != NULL) |
| udev = xxusb_serial_open(serial); |
| WUSB_udev = xxusb_serial_open(serial); |
| else { |
| //Find XX_USB devices and open the first one found |
| xxusb_devices_find(devices); |
| dev = devices[0].usbdev; |
| WUSB_udev = xxusb_device_open(dev); |
| } |
| // Make sure VM_USB opened OK |
| if(!WUSB_udev) { |
| printf ("\n\nFailed to Open VM_USB \n\n"); |
| return ; |
| } else { |
| printf("VM-USB Device open.!\n"); |
| } |
| |
| |
| } |
| |
| void _VI_FUNC WUSBVME_close (void) |
| void _VI_FUNC WIENER_VMUSB_close (void) |
| { |
| if (udev) xxusb_device_close(udev); |
| if (WUSB_udev) xxusb_device_close(WUSB_udev); |
| } |
| |
| |
| uint16_t fStack[MAXSTACKSIZE]; |
| |
| |
| int WIENER_VMUSB_StackInit(){ |
| fStack[0]=1; |
| fStack[1]=0; |
| return fStack[0]; |
| } |
| |
| void WIENER_VMUSB_StackClear(){ |
| WIENER_VMUSB_StackInit(); |
| } |
| |
| int WIENER_VMUSB_StackGetUInt16(int maxn, uint16_t *stack){ |
| int i; |
| for (i=0;i< fStack[0]+1;i++){ |
| if (i<maxn) stack[i]=fStack[i]; else return -1; |
| } |
| return fStack[0]+1; |
| } |
| |
| int WIENER_VMUSB_StackGetUInt32(int maxn, uint32_t *stack){ |
| int i; |
| for (i=0;i< fStack[0]+1;i++){ |
| if (i<maxn) stack[i]=fStack[i]; else return -1; |
| } |
| return fStack[0]+1; |
| } |
| |
| |
| int WIENER_VMUSB_StackAppend(int cmd, uint32_t addr ){ |
| int i= fStack[0]+1; |
| if (i+4 >= MAXSTACKSIZE) { |
| fprintf(stderr,"WIENER_VMUSB_StackAppend Maximum stack size reached! Increase....%d\n", i+4); |
| return -1; |
| } |
| fStack[i] = (cmd & 0xFFFF); |
| fStack[i+1] = (cmd >> 16); |
| fStack[i+2] = addr&0xFFFF; |
| fStack[i+3] = (addr >> 16)& 0xFFFF; |
| fStack[0]+=4; |
| return fStack[0]; |
| } |
| |
| int WIENER_VMUSB_StackAppendData(int cmd,uint32_t addr ,uint32_t data){ |
| int i=0; |
| WIENER_VMUSB_StackAppend( cmd, addr ); |
| i = fStack[0]+1; |
| if (i+2 >= MAXSTACKSIZE) { |
| fprintf(stderr,"WIENER_VMUSB_StackAppendData Maximum stack size reached! Increase....%d\n", i+4); |
| return -1; |
| } |
| fStack[i] = data & 0xFFFF; |
| fStack[i+1] = (data >> 16)&0xFFFF; |
| fStack[0]+=2; |
| return fStack[0]; |
| } |
| |
| void WIENER_VMUSB_StackConditionalRead(int adr_mod,int d16d32, uint32_t addr,uint32_t bmask){ |
| WIENER_VMUSB_StackAppend(CMD_READ| CMD_HD | adr_mod ,addr); |
| WIENER_VMUSB_StackAppendData(CMD_READ| CMD_HD | CMD_HM |adr_mod, d16d32 |addr,bmask); |
| } |
| |
| void WIENER_VMUSB_StackMultiRead(int adr_mod,int d16d32,uint32_t baseaddr, int n, uint32_t increment){ |
| int i; |
| for (i=0;i<n;i++) WIENER_VMUSB_StackAppend( adr_mod | CMD_READ, d16d32 +baseaddr + i*increment); |
| } |
| void WIENER_VMUSB_StackMultiWrite(int adr_mod,int d16d32,uint32_t baseaddr, int n, uint32_t increment, uint32_t data){ |
| int i; |
| for (i=0;i<n;i++) WIENER_VMUSB_StackAppendData( adr_mod | CMD_WRITE,d16d32 + baseaddr+i*increment, data); |
| } |
| |
| void WIENER_VMUSB_StackPrint(){ |
| uint32_t i; |
| for (i=0; i < fStack[0]+1;i++) printf("0x%04x\n",fStack[i]); |
| printf("size of stack %d __________________________________\n",fStack[0]+1); |
| } |
| |
| |
| char wusbcc_stack[MAXSTACKSIZE*4]; |
| |
| |
| int _VI_FUNC WUSBXX_stack_execute (usb_dev_handle * dev, char * stack){ |
| int i, nb=0; |
| if (!dev) return -1; |
| uint16_t * exstack = (uint16_t *) wusbcc_stack; |
| exstack[0]=0; |
| nb = WIENER_VMUSB_StackGetUInt16(MAXSTACKSIZE, &exstack[1] ); |
| //printf("WUSBXX_stack_execute stack size %d ", nb); |
| //WIENER_VMUSB_StackPrint(); |
| nb = xxusb_longstack_execute (dev, exstack, nb, 1000); |
| |
| |
| if (nb<0 ) printf("%s line:%d err=%d %s\n",__FILE__,__LINE__,nb, strerror(-nb) ); |
| if (stack!=NULL) for ( i=0;i<nb;i++) stack[i]=wusbcc_stack[i]; |
| return nb/sizeof(uint32_t); |
| } |
| |
| |
| |
| #ifndef VME_D32 |
| |
| #define VME_D8 0x1 |
| #define VME_D16 0x2 |
| #define VME_D32 0x4 |
| #endif |
| |
| |
| short __stdcall WIENER_VMUSB_VME_R( uint16_t AM, uint16_t DW, uint32_t VME_Address, uint32_t *Data){ |
| int nb=0; |
| if (!WUSB_udev) return -222; |
| |
| switch (DW){ |
| case VME_D16: nb= VME_read_16(WUSB_udev, AM,VME_Address,Data); break; |
| case VME_D32: nb= VME_read_32(WUSB_udev, AM,VME_Address,Data); break; |
| default: return 0; |
| } |
| //printf("R 0x%02x 0x%02x 0x%08x %x\n", AM , DW, VME_Address, *Data); |
| if (nb<0) printf("%s %d %d %s\n",__FILE__,__LINE__,nb, strerror(-nb) ); |
| |
| return nb; |
| } |
| |
| short __stdcall WIENER_VMUSB_VME_W( uint16_t AM, uint16_t DW, uint32_t VME_Address, uint32_t Data){ |
| int nb=0; |
| if (!WUSB_udev) return -222; |
| // printf("W 0x%02x 0x%02x 0x%08x %x\n", AM , DW, VME_Address, Data); |
| switch (DW){ |
| case VME_D16: nb= VME_write_16(WUSB_udev, AM,VME_Address,Data); break; |
| case VME_D32: nb= VME_write_32(WUSB_udev, AM,VME_Address,Data); break; |
| default: return 0; |
| } |
| if (nb<0) printf("%s %d %d %s\n",__FILE__,__LINE__,nb, strerror(-nb) ); |
| |
| return nb; |
| } |
| |
| short __stdcall WIENER_VMUSB_VME_MW( uint16_t AM, uint16_t DW, uint32_t VME_Address, uint32_t Data){ |
| switch (DW){ |
| case VME_D16: return (short) WIENER_VMUSB_StackAppendData(CMD_WRITE | AM , VME_Address | CMD_D16 , Data); |
| case VME_D32: return (short) WIENER_VMUSB_StackAppendData(CMD_WRITE | AM , VME_Address | CMD_D32 , Data); |
| default: return 0; |
| } |
| return 0; |
| } |
| short __stdcall WIENER_VMUSB_VME_MWRST( void ){ |
| WIENER_VMUSB_StackInit(); |
| return 0; |
| } |
| short __stdcall WIENER_VMUSB_VME_MWEXEC( void ){ |
| WUSBXX_stack_execute (WUSB_udev, NULL); |
| return 0; |
| } |
| |
| short __stdcall WIENER_VMUSB_VME_MR( uint16_t AM, uint16_t DW, uint32_t VME_Address, uint32_t *Data){ |
| switch (DW){ |
| case VME_D16: return (short) WIENER_VMUSB_StackAppendData(CMD_READ | AM , VME_Address | CMD_D16 , *Data); |
| case VME_D32: return (short) WIENER_VMUSB_StackAppendData(CMD_READ | AM , VME_Address | CMD_D32 , *Data); |
| default: return 0; |
| } |
| return 0; |
| } |
| short __stdcall WIENER_VMUSB_VME_MRRST( void ){ |
| WIENER_VMUSB_StackInit(); |
| return 0; |
| } |
| short __stdcall WIENER_VMUSB_VME_MREXEC( uint32_t *Data ){ |
| WUSBXX_stack_execute (WUSB_udev,(char *) Data); |
| return 0; |
| } |