home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / usbd0906.zip / usb_20020906.zip / usbcalls / usbrexx.cpp < prev   
C/C++ Source or Header  |  2001-11-24  |  75KB  |  1,729 lines
  1. #include <os2.h>
  2. #include "usbcalls.h"
  3. #define  INCL_REXXSAA
  4. #include <rexxsaa.h>
  5. #include <ctype.h>
  6. #include <stdio.h>
  7. #include <string.h>
  8. #include <stdlib.h>
  9.  
  10. #if 0
  11. #ifdef __cplusplus
  12.   extern "C" {
  13. #endif
  14. RexxFunctionHandler RxUsbQueryNumberDevices;
  15. RexxFunctionHandler RxUsbQueryDeviceReport;
  16. RexxFunctionHandler RxUsbRegisterChangeNotification;
  17. RexxFunctionHandler RxUsbRegisterDeviceNotification;
  18. RexxFunctionHandler RxUsbDeregisterNotification;
  19. RexxFunctionHandler RxUsbOpen;
  20. RexxFunctionHandler RxUsbClose;
  21. RexxFunctionHandler RxUsbCtrlMessage;
  22. RexxFunctionHandler RxUsbBulkRead;
  23. RexxFunctionHandler RxUsbBulkWrite;
  24. RexxFunctionHandler RxUsbIrqStart;
  25. RexxFunctionHandler RxUsbIrqStop;
  26. RexxFunctionHandler RxUsbIsoStart;
  27. RexxFunctionHandler RxUsbIsoStop;
  28. RexxFunctionHandler RxUsbIsoDequeue;
  29. RexxFunctionHandler RxUsbIsoPeekQueue;
  30. RexxFunctionHandler RxUsbIsoEnqueue;
  31. RexxFunctionHandler RxUsbIsoGetLength;
  32. RexxFunctionHandler RxUsbDeviceGetConfiguration;
  33. RexxFunctionHandler RxUsbDeviceGetDescriptor;
  34. RexxFunctionHandler RxUsbInterfaceGetDescriptor;
  35. RexxFunctionHandler RxUsbEndpointGetDescriptor;
  36. RexxFunctionHandler RxUsbConfigurationGetDescriptor;
  37. RexxFunctionHandler RxUsbStringGetDescriptor;
  38. RexxFunctionHandler RxUsbInterfaceGetAltSetting;
  39. RexxFunctionHandler RxUsbDeviceGetStatus;
  40. RexxFunctionHandler RxUsbInterfaceGetStatus;
  41. RexxFunctionHandler RxUsbEndpointGetStatus;
  42. RexxFunctionHandler RxUsbDeviceSetAddress;
  43. RexxFunctionHandler RxUsbDeviceSetConfiguration;
  44. RexxFunctionHandler RxUsbDeviceSetDescriptor;
  45. RexxFunctionHandler RxUsbInterfaceSetDescriptor;
  46. RexxFunctionHandler RxUsbEndpointSetDescriptor;
  47. RexxFunctionHandler RxUsbConfigurationSetDescriptor;
  48. RexxFunctionHandler RxUsbStringSetDescriptor;
  49. RexxFunctionHandler RxUsbDeviceSetFeature;
  50. RexxFunctionHandler RxUsbInterfaceSetFeature;
  51. RexxFunctionHandler RxUsbEndpointSetFeature;
  52. RexxFunctionHandler RxUsbInterfaceSetAltSetting;
  53. RexxFunctionHandler RxUsbEndpointSynchFrame;
  54.  
  55. #ifdef __cplusplus
  56. }//  extern "C" {
  57. #endif
  58. #endif
  59.  
  60. /*********************************************************************/
  61. /*  Various definitions used by various functions.                   */
  62. /*********************************************************************/
  63.  
  64. #define  MAX_DIGITS     9          /* maximum digits in numeric arg  */
  65. #define  MAX            256        /* temporary buffer length        */
  66. #define  IBUF_LEN       4096       /* Input buffer length            */
  67. #define  AllocFlag      PAG_COMMIT | PAG_WRITE  /* for DosAllocMem   */
  68.  
  69. static PSZ  RxFncTable[] =
  70. {
  71.   "RxUsbQueryNumberDevices",
  72.   "RxUsbQueryDeviceReport",
  73.   "RxUsbRegisterChangeNotification",
  74.   "RxUsbRegisterDeviceNotification",
  75.   "RxUsbDeregisterNotification",
  76.   "RxUsbOpen",
  77.   "RxUsbClose",
  78.   "RxUsbCtrlMessage",
  79.   "RxUsbBulkRead",
  80.   "RxUsbBulkWrite",
  81.   "RxUsbIrqStart",
  82.   "RxUsbIrqStop",
  83.   "RxUsbIsoStart",
  84.   "RxUsbIsoStop",
  85.   "RxUsbIsoDequeue",
  86.   "RxUsbIsoPeekQueue",
  87.   "RxUsbIsoEnqueue",
  88.   "RxUsbIsoGetLength",
  89.   "RxUsbDeviceGetConfiguration",
  90.   "RxUsbDeviceGetDescriptor",
  91.   "RxUsbInterfaceGetDescriptor",
  92.   "RxUsbEndpointGetDescriptor",
  93.   "RxUsbConfigurationGetDescriptor",
  94.   "RxUsbStringGetDescriptor",
  95.   "RxUsbInterfaceGetAltSetting",
  96.   "RxUsbDeviceGetStatus",
  97.   "RxUsbInterfaceGetStatus",
  98.   "RxUsbEndpointGetStatus",
  99.   "RxUsbDeviceSetAddress",
  100.   "RxUsbDeviceSetConfiguration",
  101.   "RxUsbDeviceSetDescriptor",
  102.   "RxUsbInterfaceSetDescriptor",
  103.   "RxUsbEndpointSetDescriptor",
  104.   "RxUsbConfigurationSetDescriptor",
  105.   "RxUsbStringSetDescriptor",
  106.   "RxUsbDeviceSetFeature",
  107.   "RxUsbInterfaceSetFeature",
  108.   "RxUsbEndpointSetFeature",
  109.   "RxUsbInterfaceSetAltSetting",
  110.   "RxUsbEndpointSynchFrame",
  111. };
  112.  
  113. /*********************************************************************/
  114. /* Numeric Error Return Strings                                      */
  115. /*********************************************************************/
  116.  
  117. #define  NO_UTIL_ERROR    "0"          /* No error whatsoever        */
  118. #define  ERROR_NOMEM      "2"          /* Insufficient memory        */
  119.  
  120. /*********************************************************************/
  121. /* Alpha Numeric Return Strings                                      */
  122. /*********************************************************************/
  123.  
  124. #define  ERROR_RETSTR   "ERROR:"
  125.  
  126. /*********************************************************************/
  127. /* Numeric Return calls                                              */
  128. /*********************************************************************/
  129.  
  130. #define  INVALID_ROUTINE 40            /* Raise Rexx error           */
  131. #define  VALID_ROUTINE    0            /* Successful completion      */
  132.  
  133. /*********************************************************************/
  134. /* Some useful macros                                                */
  135. /*********************************************************************/
  136.  
  137. #define BUILDRXSTRING(t, s) { \
  138.   strcpy((t)->strptr,(s));\
  139.   (t)->strlength = strlen((s)); \
  140. }
  141.  
  142. /*********************************************************************/
  143. /* RxStemData                                                        */
  144. /*   Structure which describes as generic                            */
  145. /*   stem variable.                                                  */
  146. /*********************************************************************/
  147.  
  148. typedef struct RxStemData {
  149.     SHVBLOCK shvb;                     /* Request block for RxVar    */
  150.     CHAR ibuf[IBUF_LEN];               /* Input buffer               */
  151.     CHAR varname[MAX];                 /* Buffer for the variable    */
  152.                                        /* name                       */
  153.     CHAR stemname[MAX];                /* Buffer for the variable    */
  154.                                        /* name                       */
  155.     ULONG stemlen;                     /* Length of stem.            */
  156.     ULONG vlen;                        /* Length of variable value   */
  157.     ULONG j;                           /* Temp counter               */
  158.     ULONG tlong;                       /* Temp counter               */
  159.     ULONG count;                       /* Number of elements         */
  160.                                        /* processed                  */
  161. } RXSTEMDATA;
  162.  
  163. /********************************************************************
  164. * Function:  string2long(string, number)                            *
  165. *                                                                   *
  166. * Purpose:   Validates and converts an ASCII-Z string from string   *
  167. *            form to an unsigned long.  Returns FALSE if the number *
  168. *            is not valid, TRUE if the number was successfully      *
  169. *            converted.                                             *
  170. *                                                                   *
  171. * RC:        TRUE - Good number converted                           *
  172. *            FALSE - Invalid number supplied.                       *
  173. *********************************************************************/
  174.  
  175. BOOL string2long(PSZ string, LONG *number)
  176. {
  177.   ULONG    accumulator;                /* converted number           */
  178.   INT      length;                     /* length of number           */
  179.   INT      sign;                       /* sign of number             */
  180.  
  181.   sign = 1;                            /* set default sign           */
  182.   if (*string == '-') {                /* negative?                  */
  183.     sign = -1;                         /* change sign                */
  184.     string++;                          /* step past sign             */
  185.   }
  186.  
  187.   length = strlen(string);             /* get length of string       */
  188.   if (length == 0 ||                   /* if null string             */
  189.       length > MAX_DIGITS)             /* or too long                */
  190.     return FALSE;                      /* not valid                  */
  191.  
  192.   accumulator = 0;                     /* start with zero            */
  193.  
  194.   while (length) {                     /* while more digits          */
  195.     if (!isdigit(*string))             /* not a digit?               */
  196.       return FALSE;                    /* tell caller                */
  197.                                        /* add to accumulator         */
  198.     accumulator = accumulator *10 + (*string - '0');
  199.     length--;                          /* reduce length              */
  200.     string++;                          /* step pointer               */
  201.   }
  202.   *number = accumulator * sign;        /* return the value           */
  203.   return TRUE;                         /* good number                */
  204. }
  205.  
  206. /********************************************************************
  207. * Function:  string2ulong(string, number)                           *
  208. *                                                                   *
  209. * Purpose:   Validates and converts an ASCII-Z string from string   *
  210. *            form to an unsigned long.  Returns FALSE if the number *
  211. *            is not valid, TRUE if the number was successfully      *
  212. *            converted.                                             *
  213. *                                                                   *
  214. * RC:        TRUE - Good number converted                           *
  215. *            FALSE - Invalid number supplied.                       *
  216. *********************************************************************/
  217.  
  218. BOOL string2ulong(PSZ string, ULONG *number)
  219. {
  220.   ULONG    accumulator;                /* converted number           */
  221.   INT      length;                     /* length of number           */
  222.  
  223.   length = strlen(string);             /* get length of string       */
  224.   if (length == 0 ||                   /* if null string             */
  225.       length > MAX_DIGITS)             /* or too long                */
  226.     return FALSE;                      /* not valid                  */
  227.  
  228.   accumulator = 0;                     /* start with zero            */
  229.  
  230.   while (length) {                     /* while more digits          */
  231.     if (!isdigit(*string))             /* not a digit?               */
  232.       return FALSE;                    /* tell caller                */
  233.                                        /* add to accumulator         */
  234.     accumulator = accumulator *10 + (*string - '0');
  235.     length--;                          /* reduce length              */
  236.     string++;                          /* step pointer               */
  237.   }
  238.   *number = accumulator;               /* return the value           */
  239.   return TRUE;                         /* good number                */
  240. }
  241.  
  242. /********************************************************************
  243. * Function:  string2ushort(string, number)                           *
  244. *                                                                   *
  245. * Purpose:   Validates and converts an ASCII-Z string from string   *
  246. *            form to an unsigned long.  Returns FALSE if the number *
  247. *            is not valid, TRUE if the number was successfully      *
  248. *            converted.                                             *
  249. *                                                                   *
  250. * RC:        TRUE - Good number converted                           *
  251. *            FALSE - Invalid number supplied.                       *
  252. *********************************************************************/
  253.  
  254. BOOL string2ushort(PSZ string, USHORT *number)
  255. {
  256.   ULONG    accumulator;                /* converted number           */
  257.   INT      length;                     /* length of number           */
  258.  
  259.   length = strlen(string);             /* get length of string       */
  260.   if (length == 0 ||                   /* if null string             */
  261.       length > 5)                      /* or too long                */
  262.     return FALSE;                      /* not valid                  */
  263.  
  264.   accumulator = 0;                     /* start with zero            */
  265.  
  266.   while (length) {                     /* while more digits          */
  267.     if (!isdigit(*string))             /* not a digit?               */
  268.       return FALSE;                    /* tell caller                */
  269.                                        /* add to accumulator         */
  270.     accumulator = accumulator *10 + (*string - '0');
  271.     length--;                          /* reduce length              */
  272.     string++;                          /* step pointer               */
  273.   }
  274.   if(accumulator > 1024*64)
  275.     return FALSE;
  276.   *number = accumulator;               /* return the value           */
  277.   return TRUE;                         /* good number                */
  278. }
  279.  
  280. /********************************************************************
  281. * Function:  string2ushort(string, number)                           *
  282. *                                                                   *
  283. * Purpose:   Validates and converts an ASCII-Z string from string   *
  284. *            form to an unsigned long.  Returns FALSE if the number *
  285. *            is not valid, TRUE if the number was successfully      *
  286. *            converted.                                             *
  287. *                                                                   *
  288. * RC:        TRUE - Good number converted                           *
  289. *            FALSE - Invalid number supplied.                       *
  290. *********************************************************************/
  291.  
  292. BOOL string2uchar(PSZ string, UCHAR *number)
  293. {
  294.   USHORT   accumulator;                /* converted number           */
  295.   INT      length;                     /* length of number           */
  296.  
  297.   length = strlen(string);             /* get length of string       */
  298.   if (length == 0 ||                   /* if null string             */
  299.       length > 3)                      /* or too long                */
  300.     return FALSE;                      /* not valid                  */
  301.  
  302.   accumulator = 0;                     /* start with zero            */
  303.  
  304.   while (length) {                     /* while more digits          */
  305.     if (!isdigit(*string))             /* not a digit?               */
  306.       return FALSE;                    /* tell caller                */
  307.                                        /* add to accumulator         */
  308.     accumulator = accumulator *10 + (*string - '0');
  309.     length--;                          /* reduce length              */
  310.     string++;                          /* step pointer               */
  311.   }
  312.   if(accumulator > 255)
  313.    return FALSE;
  314.   *number = accumulator;               /* return the value           */
  315.   return TRUE;                         /* good number                */
  316. }
  317.  
  318.  
  319.  /*********************************************************************/
  320.  /*                                                                   */
  321.  /* SetRexxVariable - Set the value of a REXX variable                */
  322.  /*                                                                   */
  323.  /*********************************************************************/
  324.  
  325. INT SetRexxVariable( PSZ        name,  /* REXX variable to set       */
  326.                      PSZ        value) /* value to assign            */
  327. {
  328.   SHVBLOCK   block;                    /* variable pool control block*/
  329.  
  330.   block.shvcode = RXSHV_SYSET;         /* do a symbolic set operation*/
  331.   block.shvret=(UCHAR)0;               /* clear return code field    */
  332.   block.shvnext=(PSHVBLOCK)0;          /* no next block              */
  333.                                       /* set variable name string   */
  334.   MAKERXSTRING(block.shvname, name, strlen(name));
  335.                                       /* set value string           */
  336.   MAKERXSTRING(block.shvvalue, value, strlen(value));
  337.   block.shvvaluelen=strlen(value);     /* set value length           */
  338.   return RexxVariablePool(&block);     /* set the variable           */
  339. }
  340.  
  341. /********************************************************************
  342. * Function:  SetRexxVariableToUSHORT(string, number)                  *
  343. *                                                                   *
  344. * Purpose:   Sets a Value of the passed in Variable to the long     *
  345. *                                                                   *
  346. * RC:        TRUE - Good number converted                           *
  347. *            FALSE - Invalid number supplied.                       *
  348. *********************************************************************/
  349. INT SetRexxVariableToUSHORT(PSZ Name, USHORT Value)
  350. {
  351.   char szValue[40];
  352.   sprintf(szValue,"%d",Value);
  353.   return SetRexxVariable(Name,szValue);
  354. }
  355.  
  356. /********************************************************************
  357. * Function:  SetRexxVariableToLong(string, number)                  *
  358. *                                                                   *
  359. * Purpose:   Sets a Value of the passed in Variable to the long     *
  360. *                                                                   *
  361. * RC:        TRUE - Good number converted                           *
  362. *            FALSE - Invalid number supplied.                       *
  363. *********************************************************************/
  364. INT SetRexxVariableToLong(PSZ Name, LONG Value)
  365. {
  366.   char szValue[40];
  367.   sprintf(szValue,"%d",Value);
  368.   return SetRexxVariable(Name,szValue);
  369. }
  370.  
  371. /********************************************************************
  372. * Function:  SetRexxVariableToBuffer(string, ULONG, *UCHAR)         *
  373. *                                                                   *
  374. * Purpose:   Creates a HEX-String outof th data in the buffer and   *
  375. *            sets it as the value of the passed in variable         *
  376. *                                                                   *
  377. * RC:        TRUE - Hex String assigned                             *
  378. *            FALSE - Error.                                         *
  379. *********************************************************************/
  380. INT SetRexxVariableToBuffer(PSZ Name, ULONG ulBuffersize, UCHAR *Data)
  381. {
  382.   INT rc;
  383.   ULONG i;
  384.   char *pszValue = (char*)malloc(ulBuffersize*2+1);
  385.   if(NULL==pszValue)
  386.     return 0;
  387.   pszValue[0] = 0;
  388.   for(i=0;i<ulBuffersize;i++)
  389.     sprintf(pszValue+i*2,"%02X",Data[i]);
  390.   rc = SetRexxVariable(Name,pszValue);
  391.   free(pszValue);
  392.   return rc;
  393. }
  394.  
  395. #ifdef __cplusplus
  396.   extern "C" {
  397. #endif
  398.  
  399.  
  400. /*************************************************************************
  401. * Function:  UsbLoadFuncs                                                *
  402. *                                                                        *
  403. * Syntax:    call UsbLoadFuncs                                           *
  404. *                                                                        *
  405. * Return:    NO_UTIL_ERROR - Successful.                                 *
  406. *************************************************************************/
  407. ULONG APIENTRY UsbLoadFuncs( PSZ name,
  408.                              ULONG numargs,
  409.                              RXSTRING args[],
  410.                              PSZ queuename,
  411.                              RXSTRING *retstr)
  412. {
  413.   INT    entries;                      /* Num of entries             */
  414.   INT    j;                            /* Counter                    */
  415.  
  416.   retstr->strlength = 0;               /* set return value           */
  417.                                        /* check arguments            */
  418.   if (numargs > 0)
  419.     return INVALID_ROUTINE;
  420.  
  421.   entries = sizeof(RxFncTable)/sizeof(PSZ);
  422.  
  423.   for (j = 0; j < entries; j++)
  424.   {
  425.     RexxRegisterFunctionDll( RxFncTable[j],
  426.                              "USBCALLS",
  427.                              RxFncTable[j]);
  428.   }
  429.   return VALID_ROUTINE;
  430. }
  431.  
  432. /*************************************************************************
  433. * Function:  UsbDropFuncs                                                *
  434. *                                                                        *
  435. * Syntax:    call UsbDropFuncs                                           *
  436. *                                                                        *
  437. * Return:    NO_UTIL_ERROR - Successful.                                 *
  438. *************************************************************************/
  439.  
  440. ULONG APIENTRY UsbDropFuncs( PSZ name,
  441.                              ULONG numargs,
  442.                              RXSTRING args[],
  443.                              PSZ queuename,
  444.                              RXSTRING *retstr)
  445. {
  446.   INT     entries;                     /* Num of entries             */
  447.   INT     j;                           /* Counter                    */
  448.  
  449.   if (numargs != 0)                    /* no arguments for this      */
  450.     return INVALID_ROUTINE;            /* raise an error             */
  451.  
  452.   retstr->strlength = 0;               /* return a null string result*/
  453.  
  454.   entries = sizeof(RxFncTable)/sizeof(PSZ);
  455.  
  456.   for (j = 0; j < entries; j++)
  457.     RexxDeregisterFunction(RxFncTable[j]);
  458.  
  459.   return VALID_ROUTINE;                /* no error on call           */
  460. }
  461.  
  462. /*************************************************************************
  463. * Function:  RxUsbQueryNumberDevices                                     *
  464. *                                                                        *
  465. * Syntax:    call RxUsbQueryNumberDevices NumDevices                     *
  466. *                                                                        *
  467. * Return:    NO_UTIL_ERROR - Successful.                                 *
  468. *************************************************************************/
  469.  
  470. ULONG APIENTRY RxUsbQueryNumberDevices( PSZ       Name,                   /* name of the function       */
  471.                                         LONG      Argc,                   /* number of arguments        */
  472.                                         RXSTRING  Argv[],                 /* list of argument strings   */
  473.                                         PSZ       Queuename,              /* current queue name         */
  474.                                         PRXSTRING Retstr)                 /* returned result string     */
  475. {
  476.   APIRET rc;
  477.   ULONG ulNumDev;
  478.   if( Argc!=1 ||
  479.      !RXVALIDSTRING(Argv[0]) )
  480.     return INVALID_ROUTINE;
  481.  
  482.   rc = UsbQueryNumberDevices( &ulNumDev);
  483.  
  484.   sprintf(Retstr->strptr, "%d", rc);
  485.   Retstr->strlength = strlen(Retstr->strptr);
  486.   if(!rc && SetRexxVariableToLong(Argv[0].strptr, ulNumDev) == RXSHV_BADN )
  487.     return INVALID_ROUTINE;            /* error on non-zero          */
  488.  
  489.   return VALID_ROUTINE;                /* no error on call           */
  490. }
  491.  
  492. /*************************************************************************
  493. * Function:  RxUsbQueryDeviceReport                                      *
  494. *                                                                        *
  495. * Syntax:    call RxUsbQueryDeviceReport DeviceNum, Report               *
  496. *                                                                        *
  497. * Return:    NO_UTIL_ERROR - Successful.                                 *
  498. *************************************************************************/
  499.  
  500. ULONG APIENTRY RxUsbQueryDeviceReport( PSZ       Name,                   /* name of the function       */
  501.                                        LONG      Argc,                   /* number of arguments        */
  502.                                        RXSTRING  Argv[],                 /* list of argument strings   */
  503.                                        PSZ       Queuename,              /* current queue name         */
  504.                                        PRXSTRING Retstr)                 /* returned result string     */
  505. {
  506.   APIRET rc;
  507.   ULONG ulDevNumber;
  508.   ULONG ulBufLen;
  509.   CHAR  Data[4096];
  510.  
  511.   if( Argc!=2||
  512.       !string2ulong(Argv[0].strptr, &ulDevNumber) ||
  513.       !RXVALIDSTRING(Argv[1]) )
  514.     return INVALID_ROUTINE;
  515.  
  516.   ulBufLen = sizeof(Data);
  517.   rc =  UsbQueryDeviceReport( ulDevNumber,
  518.                               &ulBufLen,
  519.                               (CHAR*)&Data);
  520.   if(!rc)
  521.   {
  522.     if(SetRexxVariableToBuffer(Argv[1].strptr,ulBufLen, (UCHAR*)&Data))
  523.       return INVALID_ROUTINE;            /* error on non-zero          */
  524.   }
  525.  
  526.   sprintf(Retstr->strptr, "%d", rc);
  527.   Retstr->strlength = strlen(Retstr->strptr);
  528.   return VALID_ROUTINE;
  529.  
  530. }
  531.  
  532. /***************************************************************************
  533. * Function:  RxUsbRegisterChangeNotification                               *
  534. *                                                                          *
  535. * Syntax:    call RxUsbRegisterChangeNotification NotifyID hDevAdd hDevRem *
  536. *                                                                          *
  537. * Return:    NO_UTIL_ERROR - Successful.                                   *
  538. ***************************************************************************/
  539.  
  540. ULONG APIENTRY RxUsbRegisterChangeNotification( PSZ       Name,      /* name of the function       */
  541.                                                 LONG      Argc,      /* number of arguments        */
  542.                                                 RXSTRING  Argv[],    /* list of argument strings   */
  543.                                                 PSZ       Queuename, /* current queue name         */
  544.                                                 PRXSTRING Retstr)    /* returned result string     */
  545. {
  546.   APIRET rc;
  547.   USBNOTIFY NotifyID;
  548.   HEV hDeviceAdded;
  549.   HEV hDeviceRemoved;
  550.   if( Argc!=3 ||
  551.       !RXVALIDSTRING(Argv[0]) ||
  552.       !string2ulong(Argv[1].strptr, &hDeviceAdded) ||
  553.       !string2ulong(Argv[2].strptr, &hDeviceRemoved) )
  554.     return INVALID_ROUTINE;
  555.  
  556.   rc = UsbRegisterChangeNotification( &NotifyID,
  557.                                       hDeviceAdded,
  558.                                       hDeviceRemoved);
  559.  
  560.   sprintf(Retstr->strptr, "%d", rc);
  561.   Retstr->strlength = strlen(Retstr->strptr);
  562.  
  563.   if(!rc && SetRexxVariableToLong(Argv[0].strptr, NotifyID) == RXSHV_BADN )
  564.     return INVALID_ROUTINE;            /* error on non-zero          */
  565.  
  566.   return VALID_ROUTINE;
  567. }
  568.  
  569. /******************************************************************************
  570. * Function:  RxUsbRegisterDeviceNotification                                  *
  571. *                                                                             *
  572. * Syntax:    call RxUsbRegisterDeviceNotification NotifyID, hDevAdd, hDevRem, *
  573. *                 VendorId, ProductID, Version                                *
  574. *                                                                             *
  575. *                                                                             *
  576. * Return:    NO_UTIL_ERROR - Successful.                                      *
  577. ******************************************************************************/
  578.  
  579. ULONG APIENTRY RxUsbRegisterDeviceNotification( PSZ       Name,                   /* name of the function       */
  580.                                                 LONG      Argc,                   /* number of arguments        */
  581.                                                 RXSTRING  Argv[],                 /* list of argument strings   */
  582.                                                 PSZ       Queuename,              /* current queue name         */
  583.                                                 PRXSTRING Retstr)                 /* returned result string     */
  584. {
  585.   APIRET rc;
  586.   USBNOTIFY NotifyID;
  587.   HEV hDeviceAdded;
  588.   HEV hDeviceRemoved;
  589.   USHORT usVendor;
  590.   USHORT usProduct;
  591.   USHORT usBCDVersion;
  592.  
  593.   if( Argc==6)
  594.   {
  595.     if( !RXVALIDSTRING(Argv[0]) ||
  596.         !string2ulong(Argv[1].strptr, &hDeviceAdded)    ||
  597.         !string2ulong(Argv[2].strptr, &hDeviceRemoved)  ||
  598.         !string2ushort(Argv[3].strptr, &usVendor) ||
  599.         !string2ushort(Argv[4].strptr, &usProduct) ||
  600.         !string2ushort(Argv[5].strptr, &usBCDVersion) )
  601.       return INVALID_ROUTINE;
  602.   }
  603.   else
  604.     if(Argc==5)
  605.     {
  606.       if( !RXVALIDSTRING(Argv[0]) ||
  607.           !string2ulong(Argv[1].strptr, &hDeviceAdded)    ||
  608.           !string2ulong(Argv[2].strptr, &hDeviceRemoved)  ||
  609.           !string2ushort(Argv[3].strptr, &usVendor) ||
  610.           !string2ushort(Argv[4].strptr, &usProduct))
  611.         return INVALID_ROUTINE;
  612.       usBCDVersion = USB_ANY_PRODUCTVERSION;
  613.     }
  614.     else
  615.       return INVALID_ROUTINE;
  616.  
  617.   rc = UsbRegisterDeviceNotification( &NotifyID,
  618.                                       hDeviceAdded,
  619.                                       hDeviceRemoved,
  620.                                       usVendor,
  621.                                       usProduct,
  622.                                       usBCDVersion);
  623.   sprintf(Retstr->strptr, "%d", rc);
  624.   Retstr->strlength = strlen(Retstr->strptr);
  625.  
  626.   if(!rc && SetRexxVariableToLong(Argv[0].strptr, NotifyID) == RXSHV_BADN )
  627.     return INVALID_ROUTINE;            /* error on non-zero          */
  628.  
  629.   return VALID_ROUTINE;
  630. }
  631. /******************************************************************************
  632. * Function:  RxUsbDeregisterNotification                                      *
  633. *                                                                             *
  634. * Syntax:    call RxUsbDeregisterNotification NotifyID                        *
  635. *                                                                             *
  636. *                                                                             *
  637. * Return:    VALID_ROUTINE - Successful.                                      *
  638. ******************************************************************************/
  639.  
  640. ULONG APIENTRY RxUsbDeregisterNotification( PSZ       Name,                   /* name of the function       */
  641.                                             LONG      Argc,                   /* number of arguments        */
  642.                                             RXSTRING  Argv[],                 /* list of argument strings   */
  643.                                             PSZ       Queuename,              /* current queue name         */
  644.                                             PRXSTRING Retstr)                 /* returned result string     */
  645. {
  646.   APIRET rc;
  647.   USBNOTIFY NotifyID;
  648.   if( Argc!=1 ||
  649.       !string2ulong(Argv[0].strptr, &NotifyID) )
  650.     return INVALID_ROUTINE;
  651.  
  652.   rc = UsbDeregisterNotification(NotifyID);
  653.  
  654.   sprintf(Retstr->strptr, "%d", rc);
  655.   Retstr->strlength = strlen(Retstr->strptr);
  656.   return VALID_ROUTINE;
  657. }
  658. /******************************************************************************
  659. * Function:  RxUsbOpen                                                        *
  660. *                                                                             *
  661. * Syntax:    call RxUsbOpen USBHandle EnumDevice VendorId, ProductID, Version *
  662. *                                                                             *
  663. *                                                                             *
  664. * Return:    VALID_ROUTINE - Successful.                                      *
  665. ******************************************************************************/
  666.  
  667. ULONG APIENTRY RxUsbOpen( PSZ       Name,      /* name of the function       */
  668.                           LONG      Argc,      /* number of arguments        */
  669.                           RXSTRING  Argv[],    /* list of argument strings   */
  670.                           PSZ       Queuename, /* current queue name         */
  671.                           PRXSTRING Retstr)    /* returned result string     */
  672. {
  673.   APIRET rc;
  674.   USBHANDLE Handle;
  675.   USHORT usVendor;
  676.   USHORT usProduct;
  677.   USHORT usBCDVersion;
  678.   USHORT usEnumDevice;
  679.  
  680.   if( Argc==5)
  681.   {
  682.     if( !RXVALIDSTRING(Argv[0]) ||
  683.         !string2ushort(Argv[1].strptr, &usEnumDevice) ||
  684.         !string2ushort(Argv[2].strptr, &usVendor) ||
  685.         !string2ushort(Argv[3].strptr, &usProduct) ||
  686.         !string2ushort(Argv[4].strptr, &usBCDVersion) )
  687.       return INVALID_ROUTINE;
  688.   }
  689.   else
  690.     if(Argc==4)
  691.     {
  692.       if( !RXVALIDSTRING(Argv[0]) ||
  693.           !string2ushort(Argv[1].strptr, &usEnumDevice) ||
  694.           !string2ushort(Argv[2].strptr, &usVendor) ||
  695.           !string2ushort(Argv[3].strptr, &usProduct) )
  696.         return INVALID_ROUTINE;
  697.       usBCDVersion = USB_ANY_PRODUCTVERSION;
  698.     }
  699.     else
  700.       return INVALID_ROUTINE;
  701.  
  702.   rc = UsbOpen( &Handle,
  703.                 usVendor,
  704.                 usProduct,
  705.                 usBCDVersion,
  706.                 usEnumDevice);
  707.  
  708.   sprintf(Retstr->strptr, "%d", rc);
  709.   Retstr->strlength = strlen(Retstr->strptr);
  710.  
  711.   if(!rc && SetRexxVariableToLong(Argv[0].strptr, Handle) == RXSHV_BADN )
  712.     return INVALID_ROUTINE;            /* error on non-zero          */
  713.  
  714.   return VALID_ROUTINE;
  715. }
  716.  
  717. /******************************************************************************
  718. * Function:  RxUsbClose                                                       *
  719. *                                                                             *
  720. * Syntax:    call RxUsbClose USBHandle                                        *
  721. *                                                                             *
  722. *                                                                             *
  723. * Return:    NO_UTIL_ERROR - Successful.                                      *
  724. ******************************************************************************/
  725.  
  726. ULONG APIENTRY RxUsbClose( PSZ       Name,                   /* name of the function       */
  727.                            LONG      Argc,                   /* number of arguments        */
  728.                            RXSTRING  Argv[],                 /* list of argument strings   */
  729.                            PSZ       Queuename,              /* current queue name         */
  730.                            PRXSTRING Retstr)                 /* returned result string     */
  731. {
  732.   APIRET rc;
  733.   USBHANDLE Handle;
  734.  
  735.   if( Argc!=1 ||
  736.       !string2ulong(Argv[0].strptr, &Handle) )
  737.     return INVALID_ROUTINE;
  738.  
  739.   rc = UsbClose(Handle);
  740.  
  741.   sprintf(Retstr->strptr, "%d", rc);
  742.   Retstr->strlength = strlen(Retstr->strptr);
  743.   return VALID_ROUTINE;
  744. }
  745.  
  746. /******************************************************************************
  747. * Function:  RxUsbCtrlMessage                                                 *
  748. *                                                                             *
  749. * Syntax:    call RxUsbCtrlMessage USBHandle, RequestType, Request, Value,    *
  750. *                                  Length, Data, Timeout                      *
  751. *                                                                             *
  752. *                                                                             *
  753. * Return:    NO_UTIL_ERROR - Successful.                                      *
  754. ******************************************************************************/
  755.  
  756. ULONG APIENTRY RxUsbCtrlMessage( PSZ       Name,                   /* name of the function       */
  757.                                  LONG      Argc,                   /* number of arguments        */
  758.                                  RXSTRING  Argv[],                 /* list of argument strings   */
  759.                                  PSZ       Queuename,              /* current queue name         */
  760.                                  PRXSTRING Retstr)                 /* returned result string     */
  761. {
  762.   APIRET rc;
  763.   USBHANDLE Handle;
  764.   UCHAR  ucRequestType;
  765.   UCHAR  ucRequest;
  766.   USHORT usValue;
  767.   USHORT usIndex;
  768.   USHORT usLength;
  769.   UCHAR  *pData;
  770.   ULONG  ulTimeout;
  771.  
  772.   if(Argc!=8)
  773.     return INVALID_ROUTINE;
  774.  
  775.   if( !string2ulong(Argv[0].strptr, &Handle)  ||
  776.       !string2uchar(Argv[1].strptr, &ucRequestType) ||
  777.       !string2uchar(Argv[2].strptr, &ucRequest) ||
  778.       !string2ushort(Argv[3].strptr, &usValue) ||
  779.       !string2ushort(Argv[4].strptr, &usLength) ||
  780.       !RXVALIDSTRING(Argv[5]) ||
  781.       !string2ulong(Argv[6].strptr, &ulTimeout) )
  782.     return INVALID_ROUTINE;
  783.  
  784.   if(usLength)
  785.     pData = (UCHAR*)Argv[6].strptr; // ToDo @@ maybe do Hex->Bin conversion?
  786.   else
  787.     pData = NULL;
  788.  
  789.   rc = UsbCtrlMessage( Handle,
  790.                        ucRequestType,
  791.                        ucRequest,
  792.                        usValue,
  793.                        usIndex,
  794.                        usLength,
  795.                        pData,
  796.                        ulTimeout);
  797.  
  798.    // @@@ ToDo Handle pData for returned data
  799.   sprintf(Retstr->strptr, "%d", rc);
  800.   Retstr->strlength = strlen(Retstr->strptr);
  801.   return VALID_ROUTINE;
  802. }
  803.  
  804. /******************************************************************************
  805. * Function:  RxUsbBulkRead                                                    *
  806. *                                                                             *
  807. * Syntax:    call RxUsbBulkRead USBHandle, NotifyID, hDevAdd, hDevRem, *
  808. *                 VendorId, ProductID, Version                                *
  809. *                                                                             *
  810. *                                                                             *
  811. * Return:    NO_UTIL_ERROR - Successful.                                      *
  812. ******************************************************************************/
  813.  
  814. ULONG APIENTRY RxUsbBulkRead( PSZ       Name,                   /* name of the function       */
  815.                               LONG      Argc,                   /* number of arguments        */
  816.                               RXSTRING  Argv[],                 /* list of argument strings   */
  817.                               PSZ       Queuename,              /* current queue name         */
  818.                               PRXSTRING Retstr)                 /* returned result string     */
  819. {
  820.   APIRET rc;
  821.   USBHANDLE Handle;
  822.   UCHAR  ucEndpoint;
  823.   UCHAR  ucInterface;
  824.   USHORT usNumBytes;
  825.   UCHAR  *pData;
  826.   ULONG  ulTimeout;
  827.  
  828.   if(Argc!=6)
  829.     return INVALID_ROUTINE;
  830.  
  831.   if( !string2ulong(Argv[0].strptr, &Handle)  ||
  832.       !string2uchar(Argv[1].strptr, &ucEndpoint) ||
  833.       !string2uchar(Argv[2].strptr, &ucInterface) ||
  834.       !string2ushort(Argv[3].strptr, &usNumBytes) ||
  835.       !RXVALIDSTRING(Argv[4]) ||
  836.       !string2ulong(Argv[5].strptr, &ulTimeout) )
  837.     return INVALID_ROUTINE;
  838.  
  839.   if(usNumBytes)
  840.   {
  841.     pData = (UCHAR*) malloc(usNumBytes);
  842.  
  843.     if(pData==NULL)
  844.       return INVALID_ROUTINE;
  845.  
  846.     rc = UsbBulkRead( Handle,
  847.                       ucEndpoint,
  848.                       ucInterface,
  849.                       &usNumBytes,
  850.                       pData,
  851.                       ulTimeout);
  852.     if(!rc)
  853.     {
  854.       if(SetRexxVariableToBuffer(Argv[4].strptr,usNumBytes, pData))
  855.       {
  856.         free(pData);
  857.         return INVALID_ROUTINE;            /* error on non-zero          */
  858.       }
  859.     }
  860.     free(pData);
  861.     SetRexxVariableToUSHORT(Argv[3].strptr, usNumBytes);
  862.   }
  863.   else
  864.     rc = 0;
  865.   sprintf(Retstr->strptr, "%d", rc);
  866.   Retstr->strlength = strlen(Retstr->strptr);
  867.   return VALID_ROUTINE;
  868. }
  869.  
  870. /******************************************************************************
  871. * Function:  RxUsbRegisterDeviceNotification                                  *
  872. *                                                                             *
  873. * Syntax:    call RxUsbRegisterDeviceNotification NotifyID, hDevAdd, hDevRem, *
  874. *                 VendorId, ProductID, Version                                *
  875. *                                                                             *
  876. *                                                                             *
  877. * Return:    NO_UTIL_ERROR - Successful.                                      *
  878. ******************************************************************************/
  879.  
  880. ULONG APIENTRY RxUsbBulkWrite( PSZ       Name,                   /* name of the function       */
  881.                                LONG      Argc,                   /* number of arguments        */
  882.                                RXSTRING  Argv[],                 /* list of argument strings   */
  883.                                PSZ       Queuename,              /* current queue name         */
  884.                                PRXSTRING Retstr)                 /* returned result string     */
  885. {
  886.   APIRET rc;
  887.   USBHANDLE Handle;
  888.   UCHAR  ucEndpoint;
  889.   UCHAR  ucInterface;
  890.   USHORT usNumBytes;
  891.   UCHAR  *pData;
  892.   ULONG  ulTimeout;
  893.  
  894.   if(Argc!=6)
  895.     return INVALID_ROUTINE;
  896.  
  897.   if( !string2ulong(Argv[0].strptr, &Handle)  ||
  898.       !string2uchar(Argv[1].strptr, &ucEndpoint) ||
  899.       !string2uchar(Argv[2].strptr, &ucInterface) ||
  900.       !string2ushort(Argv[3].strptr, &usNumBytes) ||
  901.       !RXVALIDSTRING(Argv[4]) ||
  902.       !string2ulong(Argv[5].strptr, &ulTimeout) )
  903.     return INVALID_ROUTINE;
  904.  
  905.   if(usNumBytes)
  906.   {
  907.     pData = (UCHAR*) Argv[3].strptr; // ToDo @@ maybe do Hex->Bin conversion?
  908.  
  909.     if(pData==NULL)
  910.       return INVALID_ROUTINE;
  911.  
  912.     rc = UsbBulkWrite( Handle,
  913.                        ucEndpoint,
  914.                        ucInterface,
  915.                        usNumBytes,
  916.                        pData,
  917.                        ulTimeout);
  918.   }
  919.   else
  920.     rc = 0;
  921.   sprintf(Retstr->strptr, "%d", rc);
  922.   Retstr->strlength = strlen(Retstr->strptr);
  923.   return VALID_ROUTINE;
  924. }
  925.  
  926. ULONG APIENTRY RxUsbIrqStart( PSZ       Name,                   /* name of the function       */
  927.                               LONG      Argc,                   /* number of arguments        */
  928.                               RXSTRING  Argv[],                 /* list of argument strings   */
  929.                               PSZ       Queuename,              /* current queue name         */
  930.                               PRXSTRING Retstr)                 /* returned result string     */
  931. {
  932.   APIRET rc;
  933.   if(Argc!=8)
  934.     return INVALID_ROUTINE;
  935.   sprintf(Retstr->strptr, "%d", rc);
  936.   Retstr->strlength = strlen(Retstr->strptr);
  937.   return VALID_ROUTINE;
  938. }
  939.  
  940. ULONG APIENTRY RxUsbIrqStop( PSZ       Name,                   /* name of the function       */
  941.                              LONG      Argc,                   /* number of arguments        */
  942.                              RXSTRING  Argv[],                 /* list of argument strings   */
  943.                              PSZ       Queuename,              /* current queue name         */
  944.                              PRXSTRING Retstr)                 /* returned result string     */
  945. {
  946.   APIRET rc;
  947.   if(Argc!=8)
  948.     return INVALID_ROUTINE;
  949.   sprintf(Retstr->strptr, "%d", rc);
  950.   Retstr->strlength = strlen(Retstr->strptr);
  951.   return VALID_ROUTINE;
  952. }
  953.  
  954. ULONG APIENTRY RxUsbIsoStart( PSZ       Name,                   /* name of the function       */
  955.                               LONG      Argc,                   /* number of arguments        */
  956.                               RXSTRING  Argv[],                 /* list of argument strings   */
  957.                               PSZ       Queuename,              /* current queue name         */
  958.                               PRXSTRING Retstr)                 /* returned result string     */
  959. {
  960.   APIRET rc;
  961.   if(Argc!=8)
  962.     return INVALID_ROUTINE;
  963.   sprintf(Retstr->strptr, "%d", rc);
  964.   Retstr->strlength = strlen(Retstr->strptr);
  965.   return VALID_ROUTINE;
  966. }
  967.  
  968. ULONG APIENTRY RxUsbIsoStop( PSZ       Name,                   /* name of the function       */
  969.                              LONG      Argc,                   /* number of arguments        */
  970.                              RXSTRING  Argv[],                 /* list of argument strings   */
  971.                              PSZ       Queuename,              /* current queue name         */
  972.                              PRXSTRING Retstr)                 /* returned result string     */
  973. {
  974.   APIRET rc;
  975.   if(Argc!=8)
  976.     return INVALID_ROUTINE;
  977.   sprintf(Retstr->strptr, "%d", rc);
  978.   Retstr->strlength = strlen(Retstr->strptr);
  979.   return VALID_ROUTINE;
  980. }
  981.  
  982. ULONG APIENTRY RxUsbIsoDequeue( PSZ       Name,                   /* name of the function       */
  983.                                 LONG      Argc,                   /* number of arguments        */
  984.                                 RXSTRING  Argv[],                 /* list of argument strings   */
  985.                                 PSZ       Queuename,              /* current queue name         */
  986.                                 PRXSTRING Retstr)                 /* returned result string     */
  987. {
  988.   APIRET rc;
  989.   if(Argc!=8)
  990.     return INVALID_ROUTINE;
  991.   sprintf(Retstr->strptr, "%d", rc);
  992.   Retstr->strlength = strlen(Retstr->strptr);
  993.   return VALID_ROUTINE;
  994. }
  995.  
  996. ULONG APIENTRY RxUsbIsoPeekQueue( PSZ       Name,                   /* name of the function       */
  997.                                   LONG      Argc,                   /* number of arguments        */
  998.                                   RXSTRING  Argv[],                 /* list of argument strings   */
  999.                                   PSZ       Queuename,              /* current queue name         */
  1000.                                   PRXSTRING Retstr)                 /* returned result string     */
  1001. {
  1002.   APIRET rc;
  1003.   if(Argc!=8)
  1004.     return INVALID_ROUTINE;
  1005.   sprintf(Retstr->strptr, "%d", rc);
  1006.   Retstr->strlength = strlen(Retstr->strptr);
  1007.   return VALID_ROUTINE;
  1008. }
  1009.  
  1010. ULONG APIENTRY RxUsbIsoEnqueue( PSZ       Name,                   /* name of the function       */
  1011.                                 LONG      Argc,                   /* number of arguments        */
  1012.                                 RXSTRING  Argv[],                 /* list of argument strings   */
  1013.                                 PSZ       Queuename,              /* current queue name         */
  1014.                                 PRXSTRING Retstr)                 /* returned result string     */
  1015. {
  1016.   APIRET rc;
  1017.   if(Argc!=8)
  1018.     return INVALID_ROUTINE;
  1019.   sprintf(Retstr->strptr, "%d", rc);
  1020.   Retstr->strlength = strlen(Retstr->strptr);
  1021.   return VALID_ROUTINE;
  1022. }
  1023.  
  1024. ULONG APIENTRY RxUsbIsoGetLength( PSZ       Name,                   /* name of the function       */
  1025.                                   LONG      Argc,                   /* number of arguments        */
  1026.                                   RXSTRING  Argv[],                 /* list of argument strings   */
  1027.                                   PSZ       Queuename,              /* current queue name         */
  1028.                                   PRXSTRING Retstr)                 /* returned result string     */
  1029. {
  1030.   APIRET rc;
  1031.   if(Argc!=8)
  1032.     return INVALID_ROUTINE;
  1033.   sprintf(Retstr->strptr, "%d", rc);
  1034.   Retstr->strlength = strlen(Retstr->strptr);
  1035.   return VALID_ROUTINE;
  1036. }
  1037.  
  1038. /******************************************************************************
  1039. * Function:  RxUsbRegisterDeviceNotification                                  *
  1040. *                                                                             *
  1041. * Syntax:    call RxUsbRegisterDeviceNotification NotifyID, hDevAdd, hDevRem, *
  1042. *                 VendorId, ProductID, Version                                *
  1043. *                                                                             *
  1044. *                                                                             *
  1045. * Return:    NO_UTIL_ERROR - Successful.                                      *
  1046. ******************************************************************************/
  1047.  
  1048. ULONG APIENTRY RxUsbDeviceClearFeature( PSZ       Name,                   /* name of the function       */
  1049.                                         LONG      Argc,                   /* number of arguments        */
  1050.                                         RXSTRING  Argv[],                 /* list of argument strings   */
  1051.                                         PSZ       Queuename,              /* current queue name         */
  1052.                                         PRXSTRING Retstr)                 /* returned result string     */
  1053. {
  1054.   APIRET rc;
  1055.   USBHANDLE Handle;
  1056.   USHORT usFeat;
  1057.  
  1058.   if(Argc!=2)
  1059.     return INVALID_ROUTINE;
  1060.   if( !string2ulong(Argv[0].strptr, &Handle)  ||
  1061.       !string2ushort(Argv[2].strptr ,&usFeat ) )
  1062.     return INVALID_ROUTINE;
  1063.  
  1064.   rc = UsbDeviceClearFeature( Handle,
  1065.                               usFeat);
  1066.  
  1067.   sprintf(Retstr->strptr, "%d", rc);
  1068.   Retstr->strlength = strlen(Retstr->strptr);
  1069.   return VALID_ROUTINE;
  1070. }
  1071.  
  1072. ULONG APIENTRY RxUsbInterfaceClearFeature( PSZ       Name,                   /* name of the function       */
  1073.                                            LONG      Argc,                   /* number of arguments        */
  1074.                                            RXSTRING  Argv[],                 /* list of argument strings   */
  1075.                                            PSZ       Queuename,              /* current queue name         */
  1076.                                            PRXSTRING Retstr)                 /* returned result string     */
  1077. {
  1078.   APIRET rc;
  1079.   USBHANDLE Handle;
  1080.   USHORT usInterface;
  1081.   USHORT usFeat;
  1082.  
  1083.   if(Argc!=3)
  1084.     return INVALID_ROUTINE;
  1085.   if( !string2ulong(Argv[0].strptr, &Handle)  ||
  1086.       !string2ushort(Argv[1].strptr ,&usInterface) ||
  1087.       !string2ushort(Argv[2].strptr ,&usFeat ) )
  1088.     return INVALID_ROUTINE;
  1089.  
  1090.   rc = UsbInterfaceClearFeature( Handle,
  1091.                                  usInterface,
  1092.                                  usFeat);
  1093.  
  1094.   sprintf(Retstr->strptr, "%d", rc);
  1095.   Retstr->strlength = strlen(Retstr->strptr);
  1096.   return VALID_ROUTINE;
  1097. }
  1098.  
  1099. ULONG APIENTRY RxUsbEndpointClearFeature( PSZ       Name,                   /* name of the function       */
  1100.                                           LONG      Argc,                   /* number of arguments        */
  1101.                                           RXSTRING  Argv[],                 /* list of argument strings   */
  1102.                                           PSZ       Queuename,              /* current queue name         */
  1103.                                           PRXSTRING Retstr)                 /* returned result string     */
  1104. {
  1105.   APIRET rc;
  1106.   USBHANDLE Handle;
  1107.   USHORT usEndpoint;
  1108.   USHORT usFeat;
  1109.  
  1110.   if(Argc!=3)
  1111.     return INVALID_ROUTINE;
  1112.   if( !string2ulong(Argv[0].strptr, &Handle)  ||
  1113.       !string2ushort(Argv[1].strptr ,&usEndpoint) ||
  1114.       !string2ushort(Argv[2].strptr ,&usFeat ) )
  1115.     return INVALID_ROUTINE;
  1116.  
  1117.   rc = UsbEndpointClearFeature( Handle,
  1118.                                 usEndpoint,
  1119.                                 usFeat);
  1120.  
  1121.   sprintf(Retstr->strptr, "%d", rc);
  1122.   Retstr->strlength = strlen(Retstr->strptr);
  1123.   return VALID_ROUTINE;
  1124. }
  1125.  
  1126. ULONG APIENTRY RxUsbEndpointClearHalt( PSZ       Name,                   /* name of the function       */
  1127.                                        LONG      Argc,                   /* number of arguments        */
  1128.                                        RXSTRING  Argv[],                 /* list of argument strings   */
  1129.                                        PSZ       Queuename,              /* current queue name         */
  1130.                                        PRXSTRING Retstr)                 /* returned result string     */
  1131. {
  1132.   APIRET rc;
  1133.   USBHANDLE Handle;
  1134.   USHORT usEndpoint;
  1135.  
  1136.   if(Argc!=2)
  1137.       return INVALID_ROUTINE;
  1138.   if( !string2ulong(Argv[0].strptr, &Handle)  ||
  1139.       !string2ushort(Argv[1].strptr ,&usEndpoint ) )
  1140.     return INVALID_ROUTINE;
  1141.  
  1142.   rc = UsbEndpointClearHalt( Handle,
  1143.                              usEndpoint);
  1144.  
  1145.   sprintf(Retstr->strptr, "%d", rc);
  1146.   Retstr->strlength = strlen(Retstr->strptr);
  1147.   return VALID_ROUTINE;
  1148. }
  1149.  
  1150. ULONG APIENTRY RxUsbDeviceGetConfiguration( PSZ       Name,                   /* name of the function       */
  1151.                                             LONG      Argc,                   /* number of arguments        */
  1152.                                             RXSTRING  Argv[],                 /* list of argument strings   */
  1153.                                             PSZ       Queuename,              /* current queue name         */
  1154.                                             PRXSTRING Retstr)                 /* returned result string     */
  1155. {
  1156.   APIRET rc;
  1157.   USBHANDLE Handle;
  1158.   UCHAR  ucConfig;
  1159.  
  1160.   if(Argc!=2)
  1161.       return INVALID_ROUTINE;
  1162.   if( !string2ulong(Argv[0].strptr, &Handle)  ||
  1163.       !RXVALIDSTRING(Argv[1]) )
  1164.     return INVALID_ROUTINE;
  1165.  
  1166.   rc = UsbDeviceGetConfiguration( Handle,
  1167.                                  (UCHAR*)&ucConfig);
  1168.   if(!rc)
  1169.   {
  1170.     SetRexxVariableToUSHORT(Argv[2].strptr, ucConfig);
  1171.   }
  1172.   sprintf(Retstr->strptr, "%d", rc);
  1173.   Retstr->strlength = strlen(Retstr->strptr);
  1174.   return VALID_ROUTINE;
  1175. }
  1176.  
  1177. ULONG APIENTRY RxUsbDeviceGetDescriptor( PSZ       Name,                   /* name of the function       */
  1178.                                          LONG      Argc,                   /* number of arguments        */
  1179.                                          RXSTRING  Argv[],                 /* list of argument strings   */
  1180.                                          PSZ       Queuename,              /* current queue name         */
  1181.                                          PRXSTRING Retstr)                 /* returned result string     */
  1182. {
  1183.   APIRET rc;
  1184.   if(Argc!=8)
  1185.     return INVALID_ROUTINE;
  1186.   sprintf(Retstr->strptr, "%d", rc);
  1187.   Retstr->strlength = strlen(Retstr->strptr);
  1188.   return VALID_ROUTINE;
  1189. }
  1190.  
  1191. ULONG APIENTRY RxUsbInterfaceGetDescriptor( PSZ       Name,                   /* name of the function       */
  1192.                                             LONG      Argc,                   /* number of arguments        */
  1193.                                             RXSTRING  Argv[],                 /* list of argument strings   */
  1194.                                             PSZ       Queuename,              /* current queue name         */
  1195.                                             PRXSTRING Retstr)                 /* returned result string     */
  1196. {
  1197.   APIRET rc;
  1198.   if(Argc!=5)
  1199.     return INVALID_ROUTINE;
  1200.   sprintf(Retstr->strptr, "%d", rc);
  1201.   Retstr->strlength = strlen(Retstr->strptr);
  1202.   return VALID_ROUTINE;
  1203. }
  1204.  
  1205. ULONG APIENTRY RxUsbEndpointGetDescriptor( PSZ       Name,                   /* name of the function       */
  1206.                                            LONG      Argc,                   /* number of arguments        */
  1207.                                            RXSTRING  Argv[],                 /* list of argument strings   */
  1208.                                            PSZ       Queuename,              /* current queue name         */
  1209.                                            PRXSTRING Retstr)                 /* returned result string     */
  1210. {
  1211.   APIRET rc;
  1212.   if(Argc!=5)
  1213.     return INVALID_ROUTINE;
  1214.   sprintf(Retstr->strptr, "%d", rc);
  1215.   Retstr->strlength = strlen(Retstr->strptr);
  1216.   return VALID_ROUTINE;
  1217. }
  1218.  
  1219. ULONG APIENTRY RxUsbConfigurationGetDescriptor( PSZ       Name,                   /* name of the function       */
  1220.                                                 LONG      Argc,                   /* number of arguments        */
  1221.                                                 RXSTRING  Argv[],                 /* list of argument strings   */
  1222.                                                 PSZ       Queuename,              /* current queue name         */
  1223.                                                 PRXSTRING Retstr)                 /* returned result string     */
  1224. {
  1225.   APIRET rc;
  1226.   if(Argc!=5)
  1227.     return INVALID_ROUTINE;
  1228.   sprintf(Retstr->strptr, "%d", rc);
  1229.   Retstr->strlength = strlen(Retstr->strptr);
  1230.   return VALID_ROUTINE;
  1231. }
  1232.  
  1233. ULONG APIENTRY RxUsbStringGetDescriptor( PSZ       Name,                   /* name of the function       */
  1234.                                          LONG      Argc,                   /* number of arguments        */
  1235.                                          RXSTRING  Argv[],                 /* list of argument strings   */
  1236.                                          PSZ       Queuename,              /* current queue name         */
  1237.                                          PRXSTRING Retstr)                 /* returned result string     */
  1238. {
  1239.   APIRET rc;
  1240.   if(Argc!=5)
  1241.     return INVALID_ROUTINE;
  1242.   sprintf(Retstr->strptr, "%d", rc);
  1243.   Retstr->strlength = strlen(Retstr->strptr);
  1244.   return VALID_ROUTINE;
  1245. }
  1246.  
  1247. ULONG APIENTRY RxUsbInterfaceGetAltSetting( PSZ       Name,                   /* name of the function       */
  1248.                                             LONG      Argc,                   /* number of arguments        */
  1249.                                             RXSTRING  Argv[],                 /* list of argument strings   */
  1250.                                             PSZ       Queuename,              /* current queue name         */
  1251.                                             PRXSTRING Retstr)                 /* returned result string     */
  1252. {
  1253.   APIRET rc;
  1254.   USBHANDLE Handle;
  1255.   USHORT usInterface;
  1256.   UCHAR  ucSetting;
  1257.  
  1258.   if(Argc!=3)
  1259.     return INVALID_ROUTINE;
  1260.   if( !string2ulong(Argv[0].strptr, &Handle)  ||
  1261.       !string2ushort(Argv[1].strptr, &usInterface) ||
  1262.       !RXVALIDSTRING(Argv[2]) )
  1263.     return INVALID_ROUTINE;
  1264.  
  1265.   rc = UsbInterfaceGetAltSetting( Handle,
  1266.                                   usInterface,
  1267.                                   (UCHAR*)&ucSetting);
  1268.   if(!rc)
  1269.   {
  1270.     SetRexxVariableToUSHORT(Argv[2].strptr, ucSetting);
  1271.   }
  1272.   sprintf(Retstr->strptr, "%d", rc);
  1273.   Retstr->strlength = strlen(Retstr->strptr);
  1274.   return VALID_ROUTINE;
  1275. }
  1276.  
  1277. ULONG APIENTRY RxUsbDeviceGetStatus( PSZ       Name,                   /* name of the function       */
  1278.                                      LONG      Argc,                   /* number of arguments        */
  1279.                                      RXSTRING  Argv[],                 /* list of argument strings   */
  1280.                                      PSZ       Queuename,              /* current queue name         */
  1281.                                      PRXSTRING Retstr)                 /* returned result string     */
  1282. {
  1283.   APIRET rc;
  1284.   USBHANDLE Handle;
  1285.   USHORT usStatus;
  1286.  
  1287.   if(Argc!=2)
  1288.       return INVALID_ROUTINE;
  1289.   if( !string2ulong(Argv[0].strptr, &Handle)  ||
  1290.       !RXVALIDSTRING(Argv[1]) )
  1291.     return INVALID_ROUTINE;
  1292.  
  1293.   rc = UsbDeviceGetStatus( Handle,
  1294.                            (UCHAR*)&usStatus);
  1295.   if(!rc)
  1296.   {
  1297.     SetRexxVariableToUSHORT(Argv[2].strptr, usStatus);
  1298.   }
  1299.   sprintf(Retstr->strptr, "%d", rc);
  1300.   Retstr->strlength = strlen(Retstr->strptr);
  1301.   return VALID_ROUTINE;
  1302. }
  1303.  
  1304. ULONG APIENTRY RxUsbInterfaceGetStatus( PSZ       Name,                   /* name of the function       */
  1305.                                         LONG      Argc,                   /* number of arguments        */
  1306.                                         RXSTRING  Argv[],                 /* list of argument strings   */
  1307.                                         PSZ       Queuename,              /* current queue name         */
  1308.                                         PRXSTRING Retstr)                 /* returned result string     */
  1309. {
  1310.   APIRET rc;
  1311.   USBHANDLE Handle;
  1312.   USHORT usInterface;
  1313.   USHORT usStatus;
  1314.  
  1315.   if(Argc!=3)
  1316.     return INVALID_ROUTINE;
  1317.   if( !string2ulong(Argv[0].strptr, &Handle)  ||
  1318.       !string2ushort(Argv[1].strptr, &usInterface) ||
  1319.       !RXVALIDSTRING(Argv[2]) )
  1320.     return INVALID_ROUTINE;
  1321.  
  1322.   rc = UsbInterfaceGetStatus( Handle,
  1323.                               usInterface,
  1324.                               (UCHAR*)&usStatus);
  1325.   if(!rc)
  1326.   {
  1327.     SetRexxVariableToUSHORT(Argv[2].strptr, usStatus);
  1328.   }
  1329.   sprintf(Retstr->strptr, "%d", rc);
  1330.   Retstr->strlength = strlen(Retstr->strptr);
  1331.   return VALID_ROUTINE;
  1332. }
  1333.  
  1334. ULONG APIENTRY RxUsbEndpointGetStatus( PSZ       Name,                   /* name of the function       */
  1335.                                        LONG      Argc,                   /* number of arguments        */
  1336.                                        RXSTRING  Argv[],                 /* list of argument strings   */
  1337.                                        PSZ       Queuename,              /* current queue name         */
  1338.                                        PRXSTRING Retstr)                 /* returned result string     */
  1339. {
  1340.   APIRET rc;
  1341.   USBHANDLE Handle;
  1342.   USHORT usEndpoint;
  1343.   USHORT usStatus;
  1344.  
  1345.   if(Argc==4)
  1346.   {
  1347.     if(!RXVALIDSTRING(Argv[3]) )
  1348.       return INVALID_ROUTINE;
  1349.   }
  1350.   else
  1351.   {
  1352.     if(Argc!=3)
  1353.       return INVALID_ROUTINE;
  1354.   }
  1355.   if( !string2ulong(Argv[0].strptr, &Handle)  ||
  1356.       !string2ushort(Argv[1].strptr, &usEndpoint) ||
  1357.       !RXVALIDSTRING(Argv[2]) )
  1358.     return INVALID_ROUTINE;
  1359.  
  1360.   rc = UsbEndpointGetStatus( Handle,
  1361.                              usEndpoint,
  1362.                              (UCHAR*)&usStatus);
  1363.   if(!rc)
  1364.   {
  1365.     SetRexxVariableToUSHORT(Argv[2].strptr, usStatus);
  1366.     if(Argc==4)
  1367.     {
  1368.       if(usStatus ==1)
  1369.         SetRexxVariable(Argv[4].strptr, "STATUS_ENDPOINT_HALT");
  1370.       else
  1371.         SetRexxVariable(Argv[4].strptr, "STATUS_ENDPOINT_OK");
  1372.     }
  1373.   }
  1374.   sprintf(Retstr->strptr, "%d", rc);
  1375.   Retstr->strlength = strlen(Retstr->strptr);
  1376.   return VALID_ROUTINE;
  1377. }
  1378.  
  1379. ULONG APIENTRY RxUsbDeviceSetAddress( PSZ       Name,                   /* name of the function       */
  1380.                                       LONG      Argc,                   /* number of arguments        */
  1381.                                       RXSTRING  Argv[],                 /* list of argument strings   */
  1382.                                       PSZ       Queuename,              /* current queue name         */
  1383.                                       PRXSTRING Retstr)                 /* returned result string     */
  1384. {
  1385.   APIRET rc;
  1386.   USBHANDLE Handle;
  1387.   USHORT usAddr;
  1388.  
  1389.   if(Argc!=2)
  1390.     return INVALID_ROUTINE;
  1391.  
  1392.   if( !string2ulong(Argv[0].strptr, &Handle)  ||
  1393.       !string2ushort(Argv[1].strptr, &usAddr) )
  1394.     return INVALID_ROUTINE;
  1395.  
  1396.   rc = UsbDeviceSetAddress( Handle,
  1397.                             usAddr);
  1398.  
  1399.   sprintf(Retstr->strptr, "%d", rc);
  1400.   Retstr->strlength = strlen(Retstr->strptr);
  1401.   return VALID_ROUTINE;
  1402. }
  1403.  
  1404. ULONG APIENTRY RxUsbDeviceSetConfiguration( PSZ       Name,                   /* name of the function       */
  1405.                                             LONG      Argc,                   /* number of arguments        */
  1406.                                             RXSTRING  Argv[],                 /* list of argument strings   */
  1407.                                             PSZ       Queuename,              /* current queue name         */
  1408.                                             PRXSTRING Retstr)                 /* returned result string     */
  1409. {
  1410.   APIRET rc;
  1411.   USBHANDLE Handle;
  1412.   USHORT usConfig;
  1413.  
  1414.   if(Argc!=2)
  1415.     return INVALID_ROUTINE;
  1416.  
  1417.   if( !string2ulong(Argv[0].strptr, &Handle)  ||
  1418.       !string2ushort(Argv[1].strptr, &usConfig) )
  1419.     return INVALID_ROUTINE;
  1420.  
  1421.   rc = UsbDeviceSetConfiguration( Handle,
  1422.                                   usConfig);
  1423.  
  1424.   sprintf(Retstr->strptr, "%d", rc);
  1425.   Retstr->strlength = strlen(Retstr->strptr);
  1426.   return VALID_ROUTINE;
  1427. }
  1428.  
  1429. ULONG APIENTRY RxUsbDeviceSetDescriptor( PSZ       Name,                   /* name of the function       */
  1430.                                          LONG      Argc,                   /* number of arguments        */
  1431.                                          RXSTRING  Argv[],                 /* list of argument strings   */
  1432.                                          PSZ       Queuename,              /* current queue name         */
  1433.                                          PRXSTRING Retstr)                 /* returned result string     */
  1434. {
  1435.   APIRET rc;
  1436.   USBHANDLE Handle;
  1437.   USHORT usIndex;
  1438.   USHORT usLID;
  1439.   USHORT usLength;
  1440.   UCHAR  *pData;
  1441.  
  1442.   if(Argc!=5)
  1443.     return INVALID_ROUTINE;
  1444.  
  1445.   if( !string2ulong(Argv[0].strptr, &Handle)  ||
  1446.       !string2ushort(Argv[1].strptr, &usIndex) ||
  1447.       !string2ushort(Argv[2].strptr, &usLID) ||
  1448.       !string2ushort(Argv[3].strptr, &usLength) ||
  1449.       !RXVALIDSTRING(Argv[4]) )
  1450.     return INVALID_ROUTINE;
  1451.  
  1452.   pData = (UCHAR*) Argv[4].strptr;
  1453.  
  1454.   rc = UsbDeviceSetDescriptor( Handle,
  1455.                                usIndex,
  1456.                                usLID,
  1457.                                usLength,
  1458.                                pData);
  1459.  
  1460.   sprintf(Retstr->strptr, "%d", rc);
  1461.   Retstr->strlength = strlen(Retstr->strptr);
  1462.   return VALID_ROUTINE;
  1463. }
  1464.  
  1465. ULONG APIENTRY RxUsbInterfaceSetDescriptor( PSZ       Name,                   /* name of the function       */
  1466.                                             LONG      Argc,                   /* number of arguments        */
  1467.                                             RXSTRING  Argv[],                 /* list of argument strings   */
  1468.                                             PSZ       Queuename,              /* current queue name         */
  1469.                                             PRXSTRING Retstr)                 /* returned result string     */
  1470. {
  1471.   APIRET rc;
  1472.   USBHANDLE Handle;
  1473.   USHORT usIndex;
  1474.   USHORT usLID;
  1475.   USHORT usLength;
  1476.   UCHAR  *pData;
  1477.  
  1478.   if(Argc!=5)
  1479.     return INVALID_ROUTINE;
  1480.  
  1481.   if( !string2ulong(Argv[0].strptr, &Handle)  ||
  1482.       !string2ushort(Argv[1].strptr, &usIndex) ||
  1483.       !string2ushort(Argv[2].strptr, &usLID) ||
  1484.       !string2ushort(Argv[3].strptr, &usLength) ||
  1485.       !RXVALIDSTRING(Argv[4]) )
  1486.     return INVALID_ROUTINE;
  1487.  
  1488.   pData = (UCHAR*) Argv[4].strptr;
  1489.  
  1490.   rc = UsbInterfaceSetDescriptor( Handle,
  1491.                                   usIndex,
  1492.                                   usLID,
  1493.                                   usLength,
  1494.                                   pData);
  1495.  
  1496.   sprintf(Retstr->strptr, "%d", rc);
  1497.   Retstr->strlength = strlen(Retstr->strptr);
  1498.   return VALID_ROUTINE;
  1499. }
  1500.  
  1501. ULONG APIENTRY RxUsbEndpointSetDescriptor( PSZ       Name,                   /* name of the function       */
  1502.                                            LONG      Argc,                   /* number of arguments        */
  1503.                                            RXSTRING  Argv[],                 /* list of argument strings   */
  1504.                                            PSZ       Queuename,              /* current queue name         */
  1505.                                            PRXSTRING Retstr)                 /* returned result string     */
  1506. {
  1507.   APIRET rc;
  1508.   USBHANDLE Handle;
  1509.   USHORT usIndex;
  1510.   USHORT usLID;
  1511.   USHORT usLength;
  1512.   UCHAR  *pData;
  1513.  
  1514.   if(Argc!=5)
  1515.     return INVALID_ROUTINE;
  1516.  
  1517.   if( !string2ulong(Argv[0].strptr, &Handle)  ||
  1518.       !string2ushort(Argv[1].strptr, &usIndex) ||
  1519.       !string2ushort(Argv[2].strptr, &usLID) ||
  1520.       !string2ushort(Argv[3].strptr, &usLength) ||
  1521.       !RXVALIDSTRING(Argv[4]) )
  1522.     return INVALID_ROUTINE;
  1523.  
  1524.   pData = (UCHAR*) Argv[4].strptr;
  1525.  
  1526.   rc = UsbEndpointSetDescriptor( Handle,
  1527.                                  usIndex,
  1528.                                  usLID,
  1529.                                  usLength,
  1530.                                  pData);
  1531.  
  1532.   sprintf(Retstr->strptr, "%d", rc);
  1533.   Retstr->strlength = strlen(Retstr->strptr);
  1534.   return VALID_ROUTINE;
  1535. }
  1536.  
  1537. ULONG APIENTRY RxUsbConfigurationSetDescriptor( PSZ       Name,                   /* name of the function       */
  1538.                                                 LONG      Argc,                   /* number of arguments        */
  1539.                                                 RXSTRING  Argv[],                 /* list of argument strings   */
  1540.                                                 PSZ       Queuename,              /* current queue name         */
  1541.                                                 PRXSTRING Retstr)                 /* returned result string     */
  1542. {
  1543.   APIRET rc;
  1544.   USBHANDLE Handle;
  1545.   USHORT usIndex;
  1546.   USHORT usLID;
  1547.   USHORT usLength;
  1548.   UCHAR  *pData;
  1549.  
  1550.   if(Argc!=5)
  1551.     return INVALID_ROUTINE;
  1552.  
  1553.   if( !string2ulong(Argv[0].strptr, &Handle)  ||
  1554.       !string2ushort(Argv[1].strptr, &usIndex) ||
  1555.       !string2ushort(Argv[2].strptr, &usLID) ||
  1556.       !string2ushort(Argv[3].strptr, &usLength) ||
  1557.       !RXVALIDSTRING(Argv[4]) )
  1558.     return INVALID_ROUTINE;
  1559.  
  1560.   pData = (UCHAR*) Argv[4].strptr;
  1561.  
  1562.   rc = UsbConfigurationSetDescriptor( Handle,
  1563.                                       usIndex,
  1564.                                       usLID,
  1565.                                       usLength,
  1566.                                       pData);
  1567.  
  1568.   sprintf(Retstr->strptr, "%d", rc);
  1569.   Retstr->strlength = strlen(Retstr->strptr);
  1570.   return VALID_ROUTINE;
  1571. }
  1572.  
  1573. ULONG APIENTRY RxUsbStringSetDescriptor( PSZ       Name,                   /* name of the function       */
  1574.                                          LONG      Argc,                   /* number of arguments        */
  1575.                                          RXSTRING  Argv[],                 /* list of argument strings   */
  1576.                                          PSZ       Queuename,              /* current queue name         */
  1577.                                          PRXSTRING Retstr)                 /* returned result string     */
  1578. {
  1579.   APIRET rc;
  1580.   USBHANDLE Handle;
  1581.   USHORT usIndex;
  1582.   USHORT usLID;
  1583.   USHORT usLength;
  1584.   UCHAR  *pData;
  1585.  
  1586.   if(Argc!=5)
  1587.     return INVALID_ROUTINE;
  1588.  
  1589.   if( !string2ulong(Argv[0].strptr, &Handle)  ||
  1590.       !string2ushort(Argv[1].strptr, &usIndex) ||
  1591.       !string2ushort(Argv[2].strptr, &usLID) ||
  1592.       !string2ushort(Argv[3].strptr, &usLength) ||
  1593.       !RXVALIDSTRING(Argv[4]) )
  1594.     return INVALID_ROUTINE;
  1595.  
  1596.   pData = (UCHAR*) Argv[4].strptr;
  1597.  
  1598.   rc = UsbStringSetDescriptor( Handle,
  1599.                                usIndex,
  1600.                                usLID,
  1601.                                usLength,
  1602.                                pData);
  1603.  
  1604.   sprintf(Retstr->strptr, "%d", rc);
  1605.   Retstr->strlength = strlen(Retstr->strptr);
  1606.   return VALID_ROUTINE;
  1607. }
  1608.  
  1609. ULONG APIENTRY RxUsbDeviceSetFeature( PSZ       Name,                   /* name of the function       */
  1610.                                       LONG      Argc,                   /* number of arguments        */
  1611.                                       RXSTRING  Argv[],                 /* list of argument strings   */
  1612.                                       PSZ       Queuename,              /* current queue name         */
  1613.                                       PRXSTRING Retstr)                 /* returned result string     */
  1614. {
  1615.   APIRET rc;
  1616.   USBHANDLE Handle;
  1617.   USHORT    usFeature;
  1618.   if(Argc!=2)
  1619.     return INVALID_ROUTINE;
  1620.   if( !string2ulong(Argv[0].strptr, &Handle)  ||
  1621.       !string2ushort(Argv[1].strptr, &usFeature))
  1622.     return INVALID_ROUTINE;
  1623.   rc = UsbDeviceSetFeature(Handle, usFeature);
  1624.  
  1625.   sprintf(Retstr->strptr, "%d", rc);
  1626.   Retstr->strlength = strlen(Retstr->strptr);
  1627.   return VALID_ROUTINE;
  1628. }
  1629.  
  1630. ULONG APIENTRY RxUsbInterfaceSetFeature( PSZ       Name,                   /* name of the function       */
  1631.                                          LONG      Argc,                   /* number of arguments        */
  1632.                                          RXSTRING  Argv[],                 /* list of argument strings   */
  1633.                                          PSZ       Queuename,              /* current queue name         */
  1634.                                          PRXSTRING Retstr)                 /* returned result string     */
  1635. {
  1636.   APIRET rc;
  1637.   USBHANDLE Handle;
  1638.   USHORT    usInterface;
  1639.   USHORT    usFeature;
  1640.   if(Argc!=3)
  1641.     return INVALID_ROUTINE;
  1642.   if( !string2ulong(Argv[0].strptr, &Handle)  ||
  1643.       !string2ushort(Argv[1].strptr, &usInterface) ||
  1644.       !string2ushort(Argv[2].strptr, &usFeature))
  1645.     return INVALID_ROUTINE;
  1646.   rc = UsbInterfaceSetFeature(Handle, usInterface, usFeature);
  1647.  
  1648.   sprintf(Retstr->strptr, "%d", rc);
  1649.   Retstr->strlength = strlen(Retstr->strptr);
  1650.   return VALID_ROUTINE;
  1651. }
  1652.  
  1653. ULONG APIENTRY RxUsbEndpointSetFeature( PSZ       Name,                   /* name of the function       */
  1654.                                         LONG      Argc,                   /* number of arguments        */
  1655.                                         RXSTRING  Argv[],                 /* list of argument strings   */
  1656.                                         PSZ       Queuename,              /* current queue name         */
  1657.                                         PRXSTRING Retstr)                 /* returned result string     */
  1658. {
  1659.   APIRET rc;
  1660.   USBHANDLE Handle;
  1661.   USHORT    usEndpoint;
  1662.   USHORT    usFeature;
  1663.   if(Argc!=3)
  1664.     return INVALID_ROUTINE;
  1665.   if( !string2ulong(Argv[0].strptr, &Handle)  ||
  1666.       !string2ushort(Argv[1].strptr, &usEndpoint) ||
  1667.       !string2ushort(Argv[2].strptr, &usFeature))
  1668.  
  1669.   rc = UsbEndpointSetFeature(Handle, usEndpoint, usFeature);
  1670.  
  1671.   sprintf(Retstr->strptr, "%d", rc);
  1672.   Retstr->strlength = strlen(Retstr->strptr);
  1673.   return VALID_ROUTINE;
  1674. }
  1675.  
  1676. ULONG APIENTRY RxUsbInterfaceSetAltSetting( PSZ       Name,                   /* name of the function       */
  1677.                                             LONG      Argc,                   /* number of arguments        */
  1678.                                             RXSTRING  Argv[],                 /* list of argument strings   */
  1679.                                             PSZ       Queuename,              /* current queue name         */
  1680.                                             PRXSTRING Retstr)                 /* returned result string     */
  1681. {
  1682.   APIRET rc;
  1683.   USBHANDLE Handle;
  1684.   USHORT    usInterface, usAltSetting;
  1685.  
  1686.   if(Argc!=3)
  1687.     return INVALID_ROUTINE;
  1688.  
  1689.   if( !string2ulong(Argv[0].strptr, &Handle)  ||
  1690.       !string2ushort(Argv[1].strptr, &usInterface) ||
  1691.       !string2ushort(Argv[2].strptr, &usAltSetting))
  1692.     return INVALID_ROUTINE;
  1693.  
  1694.  
  1695.   rc = UsbInterfaceSetAltSetting(Handle, usInterface, usAltSetting);
  1696.  
  1697.   sprintf(Retstr->strptr, "%d", rc);
  1698.   Retstr->strlength = strlen(Retstr->strptr);
  1699.   return VALID_ROUTINE;
  1700. }
  1701.  
  1702. ULONG APIENTRY RxUsbEndpointSynchFrame( PSZ       Name,                   /* name of the function       */
  1703.                                         LONG      Argc,                   /* number of arguments        */
  1704.                                         RXSTRING  Argv[],                 /* list of argument strings   */
  1705.                                         PCSZ       Queuename,              /* current queue name         */
  1706.                                         PRXSTRING Retstr)                 /* returned result string     */
  1707. {
  1708.   APIRET rc;
  1709.   USBHANDLE Handle;
  1710.   USHORT    usEndpoint;
  1711.   USHORT    usFrameNumber;
  1712.  
  1713.   if(Argc!=2)
  1714.     return INVALID_ROUTINE;
  1715.   if(!string2ulong(Argv[0].strptr, &Handle) )
  1716.     return INVALID_ROUTINE;
  1717.  
  1718.   rc = UsbEndpointSynchFrame(Handle, usEndpoint, (UCHAR*)&usFrameNumber);
  1719.  
  1720.   sprintf(Retstr->strptr, "%d", rc);
  1721.   Retstr->strlength = strlen(Retstr->strptr);
  1722.   return VALID_ROUTINE;
  1723. }
  1724.  
  1725. #ifdef __cplusplus
  1726. }  //extern "C"
  1727. #endif
  1728.  
  1729.