Subversion Repositories f9daq

Rev

Rev 92 | Rev 125 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

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