home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / ddkx86v5.zip / DDKX86 / SRC / PEN / PENTKT / UTIL / PENTL / PENTL.C < prev    next >
C/C++ Source or Header  |  1995-04-14  |  35KB  |  1,135 lines
  1. /*DDK*************************************************************************/
  2. /*                                                                           */
  3. /* COPYRIGHT    Copyright (C) 1995 IBM Corporation                           */
  4. /*                                                                           */
  5. /*    The following IBM OS/2 WARP source code is provided to you solely for  */
  6. /*    the purpose of assisting you in your development of OS/2 WARP device   */
  7. /*    drivers. You may use this code in accordance with the IBM License      */
  8. /*    Agreement provided in the IBM Device Driver Source Kit for OS/2. This  */
  9. /*    Copyright statement may not be removed.                                */
  10. /*                                                                           */
  11. /*****************************************************************************/
  12. /*************************************************************************/
  13. /*                                                                       */
  14. /*                                                                       */
  15. /*************************************************************************/
  16. /******************* START OF SPECIFICATIONS *****************************/
  17. /*                                                                       */
  18. /*  SOURCE FILE NAME: PENTL.C                                            */
  19. /*                                                                       */
  20. /*  DESCRIPTIVE NAME: Pen driver test program                            */
  21. /*                                                                       */
  22. /*                                                                       */
  23. /*  STATUS:  Version 1.0                                                 */
  24. /*                                                                       */
  25. /*  NOTES: Exercises all IOCTL interfaces. Can be run as interactive     */
  26. /*         program, or can pipe a file or commands into program.         */
  27. /*                                                                       */
  28. /*                                                                       */
  29. /*  ENTRY POINTS:                                                        */
  30. /*      See public statements                                            */
  31. /*  EXTERNAL REFERENCES:                                                 */
  32. /*      See extrn statements                                             */
  33. /*                                                                       */
  34. /******************* END  OF  SPECIFICATIONS *****************************/
  35. #define INCL_DOSFILEMGR   /* File Manager values */
  36. #define INCL_DOSDEVICES   /* Device values */
  37. #include <os2.h>
  38. #include <stdio.h>
  39. #include <string.h>
  40. #include <stdlib.h>
  41. #include "penei.h"
  42. #include "penioctl.h"
  43.  
  44. #define FILE_SIZE   0L
  45. #define EABUF 0L
  46.  
  47. #define TXL 80
  48. #define NTXL 9
  49. #define MAXPARMS 6
  50.  
  51.  
  52. typedef struct _EMIUSD {
  53.    ULONG length;
  54.    char  emidrv[2][10];
  55. } EMIUSD;
  56. EMIUSD emiusd;
  57.  
  58. char    fileName[TXL]  = "\\dev\\PENDD$";
  59. char *  EBC = "-error-> Unknown command";
  60. char    sztext[TXL];
  61. char    dquc[100];
  62. char    p[MAXPARMS][TXL];
  63. HFILE   FileHandle   = 0;
  64. APIRET  rc           = 0;
  65. LONG *  traceBuf;
  66. LONG    traceBufSize = 0;
  67.  
  68. LONG    locUnit=1;
  69. LONG    butUnit=2;
  70. LONG    dspUnit=3;
  71.  
  72. int     inact=1;
  73. int     echo=1;
  74.  
  75. int     showInt = 1;
  76. int     showAbs = 1;
  77. int     showData= 1;
  78. int     showTick= 1;
  79. int     showErr= 1;
  80. int     showDD = 1;
  81. int     showSys= 1;
  82.  
  83. int     pageInt = 1;
  84. int     pageAbs = 0;
  85. int     pageData= 0;
  86. int     pageTick= 0;
  87. int     pageErr= 0;
  88. int     pageDD = 0;
  89. int     pageSys = 0;
  90.  
  91. void doHelp(void);
  92. void chkLevel(void);
  93. void doSetShow(int showVal);
  94. void doSetPage(int pageVal);
  95. void doSetName(void);
  96. void doDump(void);
  97. void usage(void);
  98. void doTrcCmd(void);
  99. void doAssCmd(void);
  100. void doLocCmd(void);
  101. void doButCmd(void);
  102. void doDspCmd(void);
  103. void doUntCmd(void);
  104. void doXXXCmd(void);
  105. void doDrvCap(DDCAP * ddcap);
  106. void doLocCap(LCAP * lcap);
  107. void doButCap(BCAP * bcap);
  108. void doDspCap(DCAP * dcap);
  109. void doCCap(CCAP * ccap);
  110. void initAD(void);
  111.  
  112. void doOPEN(ULONG drvNumber);
  113. APIRET doIOCTL(ULONG category, ULONG function,
  114.              PVOID pParams, LONG pcbParmLen,
  115.              PVOID pData, LONG pcbDataLen);
  116.  
  117. /***************************************************************************\
  118. *
  119. *  VOID main (argc, argv)
  120. *
  121. *  DESCRIPTION:
  122. *    Program mainline.
  123. *
  124. *  INPUTS:
  125. *    argc       - number of parameters
  126. *    argv       - pointer to start of parameter list
  127. *
  128. \***************************************************************************/
  129.  
  130. int main(int argc,char * argv[])
  131. {
  132. //   ULONG   rc;
  133.    ULONG   i         = 0;
  134.    ULONG   parmcnt   = 0;
  135.    FILE *  kludge    = NULL;
  136.  
  137.    initAD();
  138.  
  139.    for (i=1;i<argc;i++) {
  140.       if (argv[i][0]=='-') {
  141.          switch (argv[i][1]) {
  142.          case 'f':
  143.             inact = 0;
  144.             break;
  145.          case 'q':
  146.             echo  = 0;
  147.             break;
  148.          case 'd':
  149.             strcpy(&(emiusd.emidrv[1][0]),argv[i+1]);
  150.             printf("fileName=%s \n",emiusd.emidrv[1]);
  151.             i++;
  152.             break;
  153.          case '?':
  154.          default:
  155.             usage();
  156.             exit(0);
  157.          } /* endswitch */
  158.       } else {
  159.          if (argv[i][0]=='?') {
  160.             usage();
  161.             exit(0);
  162.          } /* endif */
  163.       } /* endif */
  164.    } /* endfor */
  165.  
  166.    doOPEN(1);
  167.    chkLevel();
  168.  
  169.    kludge = NULL;
  170.    if (inact) {printf(".");fflush(kludge);}
  171.    while (gets(sztext)) {
  172.  
  173.       if (sztext[0] != 0) {
  174.          for (i=0;i<MAXPARMS;p[i++][0]=0);
  175.          parmcnt = (ULONG) sscanf(sztext,"%s %s %s %s %s %s",
  176.                        p[0],p[1],p[2],p[3],p[4],p[5]);
  177.       } else {
  178.          printf(".%s %s %s %s %s %s\n", p[0],p[1],p[2],p[3],p[4],p[5]);
  179.          fflush(kludge);
  180.       } /* endif */
  181.  
  182.       if ((inact==0)&&(echo)) {
  183.          printf(".%s %s %s %s %s %s\n", p[0],p[1],p[2],p[3],p[4],p[5]);
  184.       }
  185.  
  186.       if (parmcnt == 0) exit(0);
  187.  
  188.       if ((p[0][0]=='h')&&(p[0][1]==0)) {
  189.          doHelp();
  190.       } else if (p[0][0]=='?') {
  191.          doHelp();
  192.       } else if ((p[0][0]=='q')&&(p[0][1]=='u')&&(p[0][2]=='i')&&(p[0][3]=='t')) {
  193.          exit(0);
  194.       } else {
  195.          switch (p[0][0]) {
  196.          case 'd':
  197.             doSetShow(1);  //set display
  198.             break;
  199.          case 'h':
  200.             doSetShow(0);  //set hide
  201.             break;
  202.          case 'p':
  203.             doSetPage(1);  //set to page
  204.             break;
  205.          case 'c':
  206.             doSetPage(0);  //set not to page
  207.             break;
  208.          case 'a':
  209.             doAssCmd();    //do assignment commands
  210.             break;
  211.          case 'x':
  212.             doXXXCmd();    //do special development stuff
  213.             break;
  214.          default:
  215.             switch (p[0][1]) {
  216.             case 't':
  217.                doTrcCmd();   //trace command
  218.                break;
  219.             case 'l':
  220.                doLocCmd();   //locator commands
  221.                break;
  222.             case 'b':
  223.                doButCmd();   //button  commands
  224.                break;
  225.             case 'd':
  226.                doDspCmd();   //display commands
  227.                break;
  228.             case 'u':
  229.                doUntCmd();   //unit  commands
  230.                break;
  231.             default:
  232.                printf("%s\n",EBC);
  233.             } /* endswitch */
  234.          } /* endswitch */
  235.       } /* endif */
  236.  
  237.       if (inact) {printf(".");fflush(kludge);}
  238.  
  239.    } /* endwhile */
  240.    return 0;
  241. }
  242.  
  243. void doSetShow(int showVal)
  244. {
  245.    switch (p[0][1]) {
  246.    case 'i':
  247.       showInt = showVal;
  248.       break;
  249.    case 'a':
  250.       showAbs = showVal;
  251.       break;
  252.    case 't':
  253.       showTick = showVal;
  254.       break;
  255.    case 'd':
  256.       showData = showVal;
  257.       break;
  258.    case 'e':
  259.       showErr = showVal;
  260.       break;
  261.    case 'x':
  262.       showDD  = showVal;
  263.       break;
  264.    case 's':
  265.       showSys = showVal;
  266.       break;
  267.    default:
  268.       printf("%s\n",EBC);
  269.    } /* endswitch */
  270. }
  271.  
  272.  
  273. void doSetPage(int pageVal)
  274. {
  275.    switch (p[0][1]) {
  276.    case 'i':
  277.       pageInt = pageVal;
  278.       break;
  279.    case 'a':
  280.       pageAbs = pageVal;
  281.       break;
  282.    case 't':
  283.       pageTick = pageVal;
  284.       break;
  285.    case 'd':
  286.       pageData = pageVal;
  287.       break;
  288.    case 'e':
  289.       pageErr = pageVal;
  290.       break;
  291.    case 'x':
  292.       pageDD  = pageVal;
  293.       break;
  294.    case 's':
  295.       pageSys = pageVal;
  296.       break;
  297.    default:
  298.       printf("%s\n",EBC);
  299.    } /* endswitch */
  300. }
  301.  
  302. void doTrcCmd(void)
  303. {
  304.  
  305.    if (p[0][0]=='r') {
  306.      if (p[0][2]=='t') {            // reset trace buffer
  307.          rc=doIOCTL(PEN_CAT_DRIVER,PEN_FUNC_RTT,     // reset trace table
  308.                  NULL,0,
  309.                  NULL,0);
  310.       } else {
  311.          printf("%s\n",EBC);
  312.       } /* endif */
  313.    } else if (p[0][0]=='q') {
  314.       if (p[0][2]=='t') {
  315.         if (p[0][3]=='s') {     // query trace table size
  316.             DQTTS dqtts;
  317.             rc=doIOCTL(PEN_CAT_DRIVER,PEN_FUNC_QTTS,
  318.                     NULL,0,
  319.                     &dqtts, sizeof(DQTTS));
  320.             if (rc) return ;
  321.             printf("size=%d \n",dqtts.size);
  322.         } else {                // query trace table
  323.             DQTTS dqtts;
  324.             PQTT  pqtt;
  325.  
  326.             dqtts.size = 0;
  327.             rc=doIOCTL(PEN_CAT_DRIVER,PEN_FUNC_QTTS,     //query trace table size
  328.                     NULL,0,
  329.                     &dqtts, sizeof (DQTTS));
  330.             if (rc) return ;
  331.             if (dqtts.size==0) {
  332.               printf("Trace buffer not allocated\n");
  333.               return;
  334.             }
  335.             if (traceBufSize != dqtts.size) {
  336.                if (traceBufSize) {
  337.                   free(traceBuf);
  338.                } /* endif */
  339.                traceBufSize=(LONG) dqtts.size;
  340.                if ((traceBuf = (LONG *)malloc((ULONG)traceBufSize * sizeof(LONG))) == NULL) {
  341.                   printf ("malloc failed\n");
  342.                   return;
  343.                } /* endif */
  344.             } /* endif */
  345.             pqtt.size = (ULONG) traceBufSize;
  346.             rc=doIOCTL(PEN_CAT_DRIVER,PEN_FUNC_QTT,     //query trace table
  347.                     &pqtt, sizeof(PQTT),
  348.                     traceBuf, (LONG) (pqtt.size * sizeof(LONG)));
  349.             if (rc) return ;
  350.             doDump();
  351.         } /* endif */
  352.       } else {
  353.          printf("%s\n",EBC);
  354.       } /* endif */
  355.  
  356.    } else if (p[0][0]=='s') {
  357.  
  358.       switch (p[0][2]) {
  359.       case 't':             //set trace table size
  360.          {
  361.             PSTTS pstts;
  362.             pstts.size = (ULONG) atol(p[1]);
  363.             rc=doIOCTL(PEN_CAT_DRIVER,PEN_FUNC_STTS,
  364.                     &pstts, sizeof(PSTTS),
  365.                     NULL,0);
  366.          }
  367.          break;
  368.       default:
  369.          printf("%s\n",EBC);
  370.       } /* endswitch */
  371.    } else {
  372.       printf("%s\n",EBC);
  373.    } /* endif */
  374.  
  375. }
  376.  
  377. void doAssCmd(void)
  378. {
  379.   PQUC  pquc;
  380.   char * pdquc    = NULL;
  381.   ULONG drvNumber = 0;
  382.  
  383.   if (p[0][1] == 'n') {
  384.       drvNumber = (ULONG) atol(p[1]);
  385.       if (drvNumber < 3) {
  386.          doOPEN(drvNumber);
  387.          chkLevel();
  388.       } else {
  389.          printf("Driver number out of range\n");
  390.       } /* endif */
  391.   } else {
  392.       pdquc = dquc;
  393.       pquc.unit  = (ULONG) atol(p[1]);
  394.       pquc.byteCount = 100;
  395.       rc=doIOCTL(PEN_CAT_DRIVER,PEN_FUNC_QUC,
  396.               &pquc, sizeof(PQUC),
  397.               &dquc, 100);
  398.       if (rc) return ;
  399.  
  400.       switch (p[0][1]) {
  401.       case 'l':
  402.          if ((((CCAP*)pdquc)->device_type)==DT_LOCATOR) {
  403.             locUnit = (LONG) pquc.unit;
  404.          } else {
  405.             printf("wrong device type\n");
  406.          }
  407.          break;
  408.       case 'd':
  409.          if ((((CCAP*)pdquc)->device_type)==DT_DISPLAY) {
  410.             dspUnit = (LONG) pquc.unit;
  411.          } else {
  412.             printf("wrong device type\n");
  413.          }
  414.          break;
  415.       case 'b':
  416.          if ((((CCAP*)pdquc)->device_type)==DT_BUTTON) {
  417.             butUnit = (LONG) pquc.unit;
  418.          } else {
  419.             printf("wrong device type\n");
  420.          }
  421.          break;
  422.       default:
  423.          printf("%s\n",EBC);
  424.       } /* endswitch */
  425.    }
  426. }
  427.  
  428. void doLocCmd(void)
  429. {
  430.    if (locUnit ==0) {
  431.       printf("Drive does not have a locator device\n");
  432.       return;
  433.    } /* endif */
  434.    if (p[0][0]=='s') {
  435.       switch (p[0][2]) {
  436.       case 'a':             //set locator unit
  437.          {
  438.             PQUC  pquc;
  439.             char * pdquc;
  440.  
  441.             pdquc = dquc;
  442.             pquc.unit  = (ULONG) atol(p[1]);
  443.             pquc.byteCount = 100;
  444.             rc=doIOCTL(PEN_CAT_DRIVER,PEN_FUNC_QUC,
  445.                     &pquc, sizeof(PQUC),
  446.                     &dquc, 100);
  447.             if (rc) return ;
  448.             if ((((CCAP*)pdquc)->device_type)==DT_LOCATOR) {
  449.                locUnit = (LONG) pquc.unit;
  450.             } else {
  451.                printf("wrong device type\n");
  452.             }
  453.          }
  454.          break;
  455.       case 'o':             //set locator offset
  456.          {
  457.             PSLO pslo;
  458.             pslo.unit = (ULONG) locUnit;
  459.             pslo.command=PSLO_SET_X|PSLO_SET_Y;
  460.             pslo.xOffset = atol(p[1]);
  461.             pslo.yOffset = atol(p[2]);
  462.             rc=doIOCTL(PEN_CAT_LOCATOR,PEN_FUNC_SLO,
  463.                     &pslo, sizeof(PSLO),
  464.                     NULL,0);
  465.          }
  466.          break;
  467.       case 'p':             //set locator pass rate
  468.          {
  469.             PSLPR pslpr;
  470.             pslpr.unit = (ULONG) locUnit;
  471.             pslpr.passRate = (ULONG) atol(p[1]);
  472.             rc=doIOCTL(PEN_CAT_LOCATOR,PEN_FUNC_SLPR,
  473.                     &pslpr, sizeof(PSLPR),
  474.                     NULL,0);
  475.          }
  476.          break;
  477.       case 's':             //set locator sample rate
  478.          {
  479.             PSLSR pslsr;
  480.             pslsr.unit = (ULONG) locUnit;
  481.             pslsr.sampleRate = (ULONG) atol(p[1]);
  482.             rc=doIOCTL(PEN_CAT_LOCATOR,PEN_FUNC_SLSR,
  483.                     &pslsr, sizeof(PSLSR),
  484.                     NULL,0);
  485.          }
  486.          break;
  487.       default:
  488.          printf("%s\n",EBC);
  489.       } /* endswitch */
  490.    } else if (p[0][0]=='q') {
  491.       switch (p[0][2]) {
  492.       case 'v':             //query locator variables
  493.          {
  494.             PQLV pqlv;
  495.             DQLV dqlv;
  496.             pqlv.unit = (ULONG) locUnit;
  497.             rc=doIOCTL(PEN_CAT_LOCATOR,PEN_FUNC_QLV,
  498.                     &pqlv, sizeof(PQLV),
  499.                     &dqlv, sizeof(DQLV));
  500.             if (rc) return ;
  501.             printf("xOffset=%d yOffset=%d sampleRate=%d passRate=%d\n",
  502.             dqlv.xOffset, dqlv.yOffset, dqlv.sampleRate, dqlv.passRate);
  503.          }
  504.          break;
  505.       case 'r':             //query locator raw coordinate
  506.          {
  507.             PQLRC pqlrc;
  508.             DQLRC dqlrc;
  509.             pqlrc.unit = (ULONG) locUnit;
  510.             pqlrc.timeout = (ULONG) atol(p[1]);
  511.             rc=doIOCTL(PEN_CAT_LOCATOR,PEN_FUNC_QLRC,
  512.                     &pqlrc, sizeof(PQLRC),
  513.                     &dqlrc, sizeof(DQLRC));
  514.             if (rc) return ;
  515.             printf("x=%d y=%d rc=%d\n",
  516.             dqlrc.xRaw, dqlrc.yRaw, dqlrc.rc);
  517.          }
  518.          break;
  519.       default:
  520.          printf("%s\n",EBC);
  521.       } /* endswitch */
  522.    } else {
  523.       printf("%s\n",EBC);
  524.    } /* endif */
  525.  
  526. }
  527.  
  528. void doButCmd(void)
  529. {
  530.    if (butUnit ==0) {
  531.       printf("Drive does not have a button device\n");
  532.       return;
  533.    } /* endif */
  534.    if (p[0][0]=='s') {
  535.       switch (p[0][2]) {
  536.       case 'a':             //set button assignment
  537.          {
  538.             PSBA psba;
  539.             psba.unit = (ULONG) butUnit;
  540.             psba.buttonIndex = (ULONG) atol(p[1]);
  541.             psba.action  = (ULONG) atol(p[2]);
  542.             psba.value   = (ULONG) atol(p[3]);
  543.             rc=doIOCTL(PEN_CAT_BUTTON,PEN_FUNC_SBA,
  544.                     &psba, sizeof(PSBA),
  545.                     NULL,0);
  546.          }
  547.          break;
  548.       default:
  549.          printf("%s\n",EBC);
  550.       } /* endswitch */
  551.    } else if (p[0][0]=='q') {
  552.       switch (p[0][2]) {
  553.       case 'a':             //query button assignment
  554.          {
  555.             PQBA pqba;
  556.             DQBA dqba;
  557.             pqba.unit = (ULONG) butUnit;
  558.             pqba.buttonIndex = (ULONG) atol(p[1]);
  559.             rc=doIOCTL(PEN_CAT_BUTTON,PEN_FUNC_QBA,
  560.                     &pqba, sizeof(PQBA),
  561.                     &dqba, sizeof(DQBA));
  562.             if (rc) return ;
  563.             printf("action=%d value=%d\n", dqba.action, dqba.value);
  564.          }
  565.          break;
  566.       default:
  567.          printf("%s\n",EBC);
  568.       } /* endswitch */
  569.    } else {
  570.       printf("%s\n",EBC);
  571.    } /* endif */
  572.  
  573. }
  574.  
  575. void doDspCmd(void)
  576. {
  577.    if (dspUnit ==0) {
  578.       printf("Drive does not have a display device\n");
  579.       return;
  580.    } /* endif */
  581.    if (p[0][0]=='s') {
  582.       switch (p[0][2]) {
  583.       case 's':             //set display state
  584.          {
  585.             PSDS psds;
  586.             psds.unit = (ULONG) dspUnit;
  587.             psds.command = (ULONG) atol(p[1]);
  588.             rc=doIOCTL(PEN_CAT_DISPLAY,PEN_FUNC_SDS,
  589.                     &psds, sizeof(PSDS),
  590.                     NULL,0);
  591.          }
  592.          break;
  593.       case 'i':             //set display inactive period
  594.          {
  595.             PSDIP psdip;
  596.             psdip.unit =    (ULONG) dspUnit;
  597.             psdip.command = (ULONG) atol(p[1]);
  598.             psdip.period =  (ULONG) atol(p[2]);
  599.             rc=doIOCTL(PEN_CAT_DISPLAY,PEN_FUNC_SDIP,
  600.                     &psdip, sizeof(PSDIP),
  601.                     NULL,0);
  602.          }
  603.          break;
  604.       default:
  605.          printf("%s\n",EBC);
  606.       } /* endswitch */
  607.    } else if (p[0][0]=='q') {
  608.       switch (p[0][2]) {
  609.       case 's':             //query display state
  610.          {
  611.             PQDS pqds;
  612.             DQDS dqds;
  613.             pqds.unit = (ULONG) dspUnit;
  614.             rc=doIOCTL(PEN_CAT_DISPLAY,PEN_FUNC_QDS,
  615.                     &pqds, sizeof(PQDS),
  616.                     &dqds, sizeof(DQDS));
  617.             if (rc) return ;
  618.             printf("state=%d auto=%x period=%d \n",
  619.             dqds.state,dqds.automatic,dqds.period);
  620.          }
  621.          break;
  622.       default:
  623.          printf("%s\n",EBC);
  624.       } /* endswitch */
  625.    } else {
  626.       printf("%s\n",EBC);
  627.    } /* endif */
  628.  
  629. }
  630.  
  631. void doUntCmd(void)
  632. {
  633.    if (p[0][0]=='s') {
  634.       switch (p[0][2]) {
  635.       case 's':             //set unit specific data
  636.          {
  637.             PSUSD psusd;
  638.             SLUSD slusd;
  639.  
  640.             psusd.unit  = (ULONG) atol(p[1]);
  641.             psusd.byteCount=sizeof(SLUSD);
  642.  
  643.             slusd.length = sizeof(SLUSD);
  644.             slusd.Xorigin        = (ULONG) atol(p[2]);
  645.             slusd.XmeasuredExtent= (ULONG) atol(p[3]);
  646.             slusd.Yorigin        = (ULONG) atol(p[4]);
  647.             slusd.YmeasuredExtent= (ULONG) atol(p[5]);
  648.             rc=doIOCTL(PEN_CAT_DRIVER,PEN_FUNC_SUSD,
  649.                     &psusd, sizeof(PSUSD),
  650.                     &slusd, sizeof(SLUSD));
  651.          }
  652.          break;
  653.       case 'v':             //set unit variable
  654.          {
  655.             PSUV  psuv;
  656.  
  657.             psuv.unit  = (ULONG) atol(p[1]);
  658.             psuv.index = (ULONG) atol(p[2]);
  659.             psuv.value = atol(p[3]);
  660.             rc=doIOCTL(PEN_CAT_DRIVER,PEN_FUNC_SUV,
  661.                     &psuv, sizeof(PSUV),
  662.                     NULL,0);
  663.          }
  664.          break;
  665.       default:
  666.          printf("%s\n",EBC);
  667.       } /* endswitch */
  668.    } else if (p[0][0]=='q') {
  669.       switch (p[0][2]) {
  670.       case 's':             //query unit specific data
  671.          {
  672.             PQUSD pqusd;
  673.             SLUSD slusd;
  674.             PQUC  pquc;
  675.             char * pdquc;
  676.  
  677.  
  678.             pqusd.unit  = (ULONG) atol(p[1]);
  679.             pqusd.byteCount=sizeof(SLUSD);
  680.             rc=doIOCTL(PEN_CAT_DRIVER,PEN_FUNC_QUSD,
  681.                     &pqusd,sizeof(PQUSD),
  682.                     &slusd,sizeof(SLUSD));
  683.             if (rc) return ;
  684.  
  685.             pdquc = dquc;
  686.             pquc.unit  = (ULONG) atol(p[1]);
  687.             pquc.byteCount = 100;
  688.             rc=doIOCTL(PEN_CAT_DRIVER,PEN_FUNC_QUC,
  689.                     &pquc, sizeof(PQUC),
  690.                     &dquc, 100);
  691.             if (rc) return ;
  692.  
  693.             if   ( (((CCAP*)pdquc)->device_type==DT_LOCATOR) &&
  694.                  ((pqusd.rc==QUSD_OK)||(pqusd.rc==QUSD_TRUNC)) &&
  695.                  (pqusd.capabilities & QUSD_STANDARD) ) {
  696.                printf("XoriginDefault=%d XoriginAdj=%d Xmeasured=%d\n",
  697.                slusd.XoriginDefault,slusd.Xorigin, slusd.XmeasuredExtent);
  698.                printf("YoriginDefault=%d YoriginAdj=%d Ymeasured=%d\n",
  699.                slusd.YoriginDefault,slusd.Yorigin, slusd.YmeasuredExtent);
  700.             } else{
  701.                printf("locator standard specific data is not available\n");
  702.             } /* endif */
  703.          }
  704.          break;
  705.       case 'v':             //query unit variable
  706.          {
  707.             PQUV  pquv;
  708.             DQUV  dquv;
  709.  
  710.             pquv.unit  = (ULONG) atol(p[1]);
  711.  
  712.             pquv.index = (ULONG) atol(p[2]);
  713.  
  714.             rc=doIOCTL(PEN_CAT_DRIVER,PEN_FUNC_QUV,
  715.                     &pquv, sizeof(PQUV),
  716.                     &dquv, sizeof(DQUV));
  717.             if (rc) return ;
  718.             printf("value = %d hex=%x\n",dquv.value,dquv.value);
  719.          }
  720.          break;
  721.       case 'c':             //query unit capabilities
  722.          {
  723.             PQUC  pquc;
  724.             char * pdquc;
  725.  
  726.             pdquc = dquc;
  727.             pquc.unit  = (ULONG) atol(p[1]);
  728.             pquc.byteCount = 100;
  729.             rc=doIOCTL(PEN_CAT_DRIVER,PEN_FUNC_QUC,
  730.                     &pquc, sizeof(PQUC),
  731.                     &dquc, 100);
  732.             if (rc) return ;
  733.             switch (((CCAP*)pdquc)->device_type) {
  734.             case DT_DRIVER:
  735.                doDrvCap(((DDCAP*)pdquc));
  736.                break;
  737.             case DT_LOCATOR:
  738.                doLocCap(((LCAP*)pdquc));
  739.                break;
  740.             case DT_BUTTON:
  741.                doButCap(((BCAP*)pdquc));
  742.                break;
  743.             case DT_DISPLAY:
  744.                doDspCap(((DCAP*)pdquc));
  745.                break;
  746.             default:
  747.                printf("unknown device type\n",dquc[0]);
  748.             } /* endswitch */
  749.          }
  750.          break;
  751.       default:
  752.          printf("%s\n",EBC);
  753.       } /* endswitch */
  754.    } else {
  755.       printf("%s\n",EBC);
  756.    } /* endif */
  757.  
  758. }
  759.  
  760. void showbut(void)
  761. {
  762. printf("button commands\n");
  763. printf("  sba    i a v set button assignment(Index,Action,Value\n");
  764. printf("         a - 0=null 1=hotKey 2=Shift 3=Appl 4=AugKey 5=GestureMode\n");
  765. printf("         v - 4=button1 16=button2 64=button3\n");
  766. printf("             1=KBD HotKey Ctrl+Esc  2=KBD HotKey Alt+Esc  \n");
  767. printf("                                                          \n");
  768. printf("  qba    i     query button assignment\n");
  769. }
  770.  
  771. void showdsp(void)
  772. {
  773. printf("display commands\n");
  774. printf("  sds    s     set display state s={1=on,0=off}\n");
  775. printf("  sdip   c p   set display inactive period p=seconds\n");
  776. printf("               c = 1  (0x01) set period\n");
  777. printf("                   2  (0x02) enable auto\n");
  778. printf("                   4  (0x04) disable auto\n");
  779. printf("                   8  (0x08) enable opaque\n");
  780. printf("                  16  (0x10) disable opaque\n");
  781. printf("                  32  (0x20) enable suppress\n");
  782. printf("                  64  (0x40) disable suppress\n");
  783. printf("  qds          query display state\n");
  784. }
  785.  
  786. void showloc(void)
  787. {
  788. printf("locator commands\n");
  789. printf("  slo    x y   set locator offset\n");
  790. printf("  slpr   #     set locator pass rate\n");
  791. printf("  slsr   #     set locator sample rate\n");
  792. printf("  qlv          query locator variables\n");
  793. printf("  qlrc         query locator raw coordinate\n");
  794. }
  795.  
  796. void showgen(void)
  797. {
  798. printf("general commands\n");
  799. printf("  al     u     assign locator unit\n");
  800. printf("  ab     u     assign button  unit\n");
  801. printf("  ad     u     assign display unit\n");
  802. printf("  an     d     assign driver name(0=emi,d=pen driver number)\n");
  803. printf("  d{i,t,a,d,e,x,s} display int,tick,abs,data,error,dev dep,sys\n");
  804. printf("  h{i,t,a,d,e,x,s} hide int,tick,abs,data,error,dev dep,sys\n");
  805. printf("  p{i,t,a,d,e,x,s} page at int,tick,abs,data,error,dev dep,sys\n");
  806. printf("  c{i,t,a,d,e,x,s} no page at int,tick,abs,data,error,dev dep,sys\n");
  807. printf("  ? {u,b,l,d,g}  help \n");
  808. printf("  h {u,b,l,d,g}  help \n");
  809. printf("  quit                 quit \n");
  810. }
  811.  
  812. void showunt(void)
  813. {
  814. printf("unit commands\n");
  815. printf("  susd u xo xm yo ym set unit specific data \n");
  816. printf("  suv  u v #   set unit varible \n");
  817. printf("  rtt          reset trace table \n");
  818. printf("  stts u s     set trace table size\n");
  819. printf("  qusd u       query unit specific data \n");
  820. printf("  quv  u v     query unit varible \n");
  821. printf("  quc  u       query unit capabilities \n");
  822. printf("  qtt          query trace table\n");
  823. printf("  qtts         query trace table size\n");
  824. }
  825.  
  826. void doHelp(void)
  827. {
  828.    switch (p[1][0]) {
  829.    case 'b':
  830.       showbut();
  831.       break;
  832.    case 'd':
  833.       showdsp();
  834.       break;
  835.    case 'l':
  836.       showloc();
  837.       break;
  838.    case 'g':
  839.       showgen();
  840.       break;
  841.    case 'u':
  842.       showunt();
  843.       break;
  844.    default:
  845.       showunt();
  846.       showdsp();
  847.       showbut();
  848.       showloc();
  849.       showgen();
  850.    } /* endswitch */
  851. }
  852.  
  853. void usage(void)
  854. {
  855. printf("USAGE:    -q -f  -d name  -? \n");
  856. printf("  where:  -f        not interactive\n");
  857. printf("          -q        don't echo cmds\n");
  858. printf("          -d  name  set driver name \n");
  859. printf("          -?        print help\n");
  860. printf("\n");
  861. }
  862.  
  863. void doOPEN(ULONG drvNumber)
  864. {
  865.    ULONG   Action;
  866.  
  867.    strcpy(&(fileName[5]),emiusd.emidrv[drvNumber]);
  868.  
  869.    /* Close if already open */
  870.    if (FileHandle) {
  871.       rc=DosClose(FileHandle);
  872.       if (rc != 0)
  873.       {
  874.           printf("DOSCLOSE return code = %d\n", rc);
  875.       }
  876.    } /* endif */
  877.  
  878.    /* Get a nect handle to use with DOSDEVIOCTL */
  879.  
  880.    Action = 2;
  881.    rc = DosOpen(fileName,                   /* File path name */
  882.                 &FileHandle,                /* File handle */
  883.                 &Action,                    /* Action taken */
  884.                 FILE_SIZE,                  /* File primary allocation */
  885.                 FILE_NORMAL,                /* File attribute */
  886.                 OPEN_ACTION_OPEN_IF_EXISTS, /* Open function type */
  887.                 OPEN_SHARE_DENYNONE |       /* Open mode of the file */
  888.                 OPEN_ACCESS_READWRITE,
  889.                 EABUF);                     /* No extended attributes */
  890.  
  891.    if (rc != 0)
  892.    {
  893.        printf("Cannot open device driver\n");
  894.        printf("DOSOPEN return code = %d\n", rc);
  895.        FileHandle=0;
  896.    }
  897. }
  898.  
  899. APIRET doIOCTL(ULONG category, ULONG function,
  900.              PVOID pParams, LONG pcbParmLen,
  901.              PVOID pData, LONG pcbDataLen)
  902. {
  903.    ULONG   ParmLengthInOut;
  904.    ULONG   DataLengthInOut;
  905. //   APIRET  rc;
  906.  
  907.    ParmLengthInOut = (ULONG) pcbParmLen;
  908.    DataLengthInOut = (ULONG) pcbDataLen;
  909.    rc = DosDevIOCtl(FileHandle, category, function,
  910.                     pParams, (ULONG) pcbParmLen,&ParmLengthInOut,
  911.                     pData, (ULONG) pcbDataLen,&DataLengthInOut);
  912.    if (rc != 0)
  913.    {
  914.        printf("IOCTL failed, return code = %d\n", (SHORT)rc);
  915.    }
  916.    return(rc);
  917. }
  918.  
  919. void doDump(void)
  920. {
  921.    LONG i   = 0;
  922.  
  923.    if (traceBuf[0] == 0) {
  924.       printf("Trace buffer is empty\n");
  925.    } else {
  926.       for (i=traceBuf[0]; i >= 1;i--) {
  927.          switch (traceBuf[i] & TRACE_MASK_SUB) {
  928.          case TRACE_INT:
  929.             if (showInt) {
  930.                if (pageInt ) printf("\n");
  931.                printf("INT ");
  932.             } /* endif */
  933.             break;
  934.          case TRACE_TICK:
  935.             if (showTick) {
  936.                if (pageTick) printf("\n");
  937.                printf("(tick %d) ",traceBuf[i]&~TRACE_MASK);
  938.             } /* endif */
  939.             break;
  940.          case TRACE_SYS:
  941.             if (showSys) {
  942.                if (pageSys) printf("\n");
  943.                printf("(Sys %2.2x) ",traceBuf[i]&~TRACE_MASK);
  944.             } /* endif */
  945.             break;
  946.          case TRACE_DATA:
  947.             if (showData) {
  948.                if ((pageData)&&
  949.                   ((traceBuf[i]&TRACE_MASK)==TRACE_DATA_1)) printf("\n");
  950.                printf("%2.2x ",traceBuf[i]&~TRACE_MASK);
  951.             } /* endif */
  952.             break;
  953.          case TRACE_ERROR:
  954.             if (showErr) {
  955.                printf("ERROR %d ",traceBuf[i]&~TRACE_MASK);
  956.             } /* endif */
  957.             break;
  958.          case TRACE_ABS:
  959.             if (showAbs) {
  960.                switch (traceBuf[i] & TRACE_MASK) {
  961.                case TRACE_ABS_E:
  962.                   if (pageAbs ) printf("\n");
  963.                   printf("(abs %4.4x ",traceBuf[i]&~TRACE_MASK);
  964.                   break;
  965.                case TRACE_ABS_C:
  966.                   if (pageAbs ) printf("\n");
  967.                   printf("(eiq %4.4x ",traceBuf[i]&~TRACE_MASK);
  968.                   break;
  969.                case TRACE_ABS_D:
  970.                   printf("%4.4x ",traceBuf[i]&~TRACE_MASK);
  971.                   break;
  972.                case TRACE_ABS_X:
  973.                   printf("%d ",traceBuf[i]&~TRACE_MASK);
  974.                   break;
  975.                case TRACE_ABS_Y:
  976.                   printf("%d ",traceBuf[i]&~TRACE_MASK);
  977.                   break;
  978.                case TRACE_ABS_Z:
  979.                   printf("%d)",traceBuf[i]&~TRACE_MASK);
  980.                   break;
  981.                default:
  982.                   printf("(invalid %x)",traceBuf[i]);
  983.                } /* endswitch */
  984.             } /* endif */
  985.             break;
  986.          case TRACE_DD:
  987.             if (showDD ) {
  988.                if ( (pageDD) &&
  989.                     (((traceBuf[i]&0x0FF0000)>>16)==0) ) printf("\n");
  990.                printf("DD%d=%x ",
  991.                (traceBuf[i]&0x0FF0000)>>16,traceBuf[i]&0x0FFFF);
  992.             } /* endif */
  993.             break;
  994.          default:
  995.             printf("(invalid %x)",traceBuf[i]);
  996.          } /* endswitch */
  997.       } /* endfor */
  998.       printf("\n");
  999.    } /* endif */
  1000. }
  1001.  
  1002. void doDrvCap(DDCAP * ddcap)
  1003. {
  1004.    doCCap(((CCAP*)ddcap));
  1005.    printf("unit count=%d\n",ddcap->unitCount);
  1006.    printf("capabilites=%x\n",ddcap->capabilites);
  1007.    printf("driver major level=%d\n",ddcap->rev_major);
  1008.    printf("driver minor level=%d\n",ddcap->rev_minor);
  1009.    printf("IOCTL interface major level=%d\n",ddcap->ioc_major);
  1010.    printf("IOCTL interface minor level=%d\n",ddcap->ioc_minor);
  1011.    printf("Extended interface major level=%d\n",ddcap->eif_major);
  1012.    printf("Extended interfcae minor level=%d\n",ddcap->eif_minor);
  1013.    printf("DDS IDC interface major level=%d\n",ddcap->idc_major);
  1014.    printf("DDS IDC interfcae minor level=%d\n",ddcap->idc_minor);
  1015. }
  1016. void doLocCap(LCAP * lcap)
  1017. {
  1018.    doCCap(((CCAP*)lcap));
  1019.    printf("type=%x caps=%x num_mouse_but=%d barrel_num=%d barrel_mask=%x\n",
  1020.            lcap->type, lcap->caps, lcap->num_mouse_but,
  1021.            lcap->barrel_num, lcap->barrel_mask);
  1022.    printf("sample_rate=%d pass_rate=%d max_sample_rate=%d\n",
  1023.            lcap->sample_rate, lcap->pass_rate, lcap->max_sample_rate);
  1024.    printf("dev_x_extent=%d dev_y_extent=%d std_x_extent=%d std_y_extent=%d\n",
  1025.            lcap->dev_x_extent, lcap->dev_y_extent,lcap->std_x_extent, lcap->std_y_extent );
  1026.    printf("dev_z_p_extent=%d dev_z_h_extent=%d\n",
  1027.            lcap->dev_z_p_extent, lcap->dev_z_h_extent);
  1028.    printf("dev_x_res=%d dev_y_res=%d std_res=%d dev_timestampRes=%d\n",
  1029.            lcap->dev_x_res, lcap->dev_y_res, lcap->std_res,
  1030.            lcap->dev_timestampRes);
  1031. }
  1032. void doButCap(BCAP * bcap)
  1033. {
  1034.    doCCap(((CCAP*)bcap));
  1035.    printf("num=%d\n",bcap->num);
  1036.    printf("typeMask   =%4.4x\n",bcap->typeMask);
  1037.    printf("nullMask   =%4.4x\n",bcap->nullMask);
  1038.    printf("barrel     =%4.4x\n",bcap->barrel);
  1039.    printf("nonBarrel  =%4.4x\n",bcap->nonBarrel);
  1040.    printf("hotKeyMask =%4.4x\n",bcap->hotKeyMask);
  1041.    printf("shiftMask  =%4.4x\n",bcap->shiftMask);
  1042.    printf("appKeyMask =%4.4x\n",bcap->appKeyMask);
  1043.    printf("augKeyMask =%4.4x\n",bcap->augKeyMask);
  1044.    printf("gesKeyMask =%4.4x\n",bcap->gesKeyMask);
  1045. }
  1046. void doDspCap(DCAP * dcap)
  1047. {
  1048.    doCCap(((CCAP*)dcap));
  1049.    printf("type=%x\n",dcap->type);
  1050.    printf("autoflag=%d\n",dcap->auto_flag);
  1051.    printf("height=%d width=%d\n",dcap->height,dcap->width);
  1052. }
  1053. void doCCap(CCAP * ccap)
  1054. {
  1055.    char pbuf1[9];
  1056.    char pbuf2[SIZEOF_DEVICE_NAME+1];
  1057.    int  i;
  1058.  
  1059.    for (i=0; i<9; i++) {pbuf1[i]=0;}
  1060.    strncpy (pbuf1,ccap->driver_name,8);
  1061.  
  1062.    for (i=0; i< SIZEOF_DEVICE_NAME+1; i++) {pbuf2[i]=0;}
  1063.    strncpy (pbuf2,ccap->device_name, SIZEOF_DEVICE_NAME);
  1064.  
  1065.  
  1066.  
  1067.    printf("--- common capabilities -----------------------------------------\n");
  1068.    printf("driver_name=%s device_name=%s\n",pbuf1,pbuf2);
  1069.    printf("length=%d device_type=%d device_id=%d unit=%d\n",
  1070.    ccap->length,ccap->device_type,ccap->device_id,ccap->unit);
  1071.    printf("--- device type specific capabilities ---------------------------\n");
  1072. }
  1073.  
  1074. void chkLevel(void)
  1075. {
  1076.   PQUC  pquc;
  1077.   DDCAP ddcap;
  1078.   char * pdquc;
  1079.  
  1080.   pdquc = dquc;
  1081.   pquc.unit  = 0;
  1082.   pquc.byteCount = sizeof(DDCAP);
  1083.   rc=doIOCTL(PEN_CAT_DRIVER,PEN_FUNC_QUC,
  1084.           &pquc, sizeof(PQUC),
  1085.           &ddcap,sizeof(DDCAP));
  1086.   if (rc) {
  1087.      printf("ERROR reading driver capabilities\n");
  1088.      return ;
  1089.   }
  1090.  
  1091.   if (ddcap.ioc_major != PEN_IOCTL_LEV_MAJOR) {
  1092.       printf("WARNING IOCTL major level mismatch, driver = %d, mine = %d\n",
  1093.       ddcap.ioc_major,PEN_IOCTL_LEV_MAJOR);
  1094.   } /* endif */
  1095.  
  1096.   if (ddcap.ioc_minor != PEN_IOCTL_LEV_MINOR) {
  1097.       printf("WARNING IOCTL minor level mismatch, driver = %d, mine = %d\n",
  1098.       ddcap.ioc_minor,PEN_IOCTL_LEV_MINOR);
  1099.   } /* endif */
  1100.  
  1101.   if (ddcap.eif_major != PEN_EI_LEV_MAJOR) {
  1102.       printf("WARNING EI major level mismatch, driver = %d, mine = %d\n",
  1103.       ddcap.eif_major,PEN_EI_LEV_MAJOR);
  1104.   } /* endif */
  1105.  
  1106.   if (ddcap.eif_minor != PEN_EI_LEV_MINOR) {
  1107.       printf("WARNING EI  minor level mismatch, driver = %d, mine = %d\n",
  1108.       ddcap.eif_minor,PEN_EI_LEV_MINOR);
  1109.   } /* endif */
  1110.  
  1111.  
  1112. }
  1113.  
  1114. void initAD(void)
  1115. {
  1116.    PQUSD pqusd;
  1117.  
  1118.    strcpy(emiusd.emidrv[0],"EMI$");
  1119.    doOPEN(0);
  1120.  
  1121.    pqusd.unit  = 0;
  1122.    emiusd.length=pqusd.byteCount=sizeof(EMIUSD);
  1123.    rc=doIOCTL(PEN_CAT_DRIVER,PEN_FUNC_QUSD,
  1124.            &pqusd,sizeof(PQUSD),
  1125.            &emiusd,sizeof(EMIUSD));
  1126.    if (rc) return ;
  1127.  
  1128. }
  1129.  
  1130.  
  1131. void doXXXCmd(void)
  1132. {
  1133.  
  1134. }
  1135.