lib/epson-usb.c

   1 /*___________________________________  epson-usb.c   ___________________________________*/\r
   2 \r
   3 /*       1         2         3         4         5         6         7         8        */\r
   4 /*34567890123456789012345678901234567890123456789012345678901234567890123456789012345678*/\r
   5 /*******************************************|********************************************/\r
   6 /*\r
   7  *   Copyright (c) 2009  Seiko Epson Corporation   All rights reserved.\r
   8  *\r
   9  *   Copyright protection claimed includes all forms and matters of copyrightable\r
  10  *   material and information now allowed by statutory or judicial law or hereinafter\r
  11  *   granted, including without limitation, material generated from the software\r
  12  *   programs which are displayed on the screen such as icons, screen display looks,\r
  13  *   etc.\r
  14  */\r
  15 /*******************************************|********************************************/\r
  16 /*                                                                                      */\r
  17 /*                                   Epson USB Module                                   */\r
  18 /*                                                                                      */\r
  19 /*                                Public Function Calls                                 */\r
  20 /*                              --------------------------                              */\r
  21 /*              EPS_ERR_CODE usbFind            (protocol                                    ); */\r
  22 /*          EPS_ERR_CODE usbProbePrinterByID(modelNameTgt, protocol, printer             );     */\r
  23 /*          EPS_ERR_CODE usbStartJob            (printer                                     ); */\r
  24 /*          EPS_ERR_CODE usbStartPage           (                                            ); */\r
  25 /*          EPS_ERR_CODE usbEndJob          (printer                                     );     */\r
  26 /*          EPS_ERR_CODE usbGetPMString     (printer, pString, bufSize                   );     */\r
  27 /*      EPS_ERR_CODE usbGetStatus       (printer, status, ioStatus                   ); */\r
  28 /*      EPS_ERR_CODE usbGetJobStatus    (pstInfo                                                                 );     */\r
  29 /*          EPS_ERR_CODE usbWritePrintData  (Buffer, BuffLen, sentSize                   );     */\r
  30 /*          EPS_ERR_CODE usbResetPrinter    (void                                        );     */\r
  31 /*          EPS_ERR_CODE usbMechCommand     (Command                                     );     */\r
  32 /*                                                                                      */\r
  33 /*******************************************|********************************************/\r
  34 \r
  35 /*------------------------------------  Includes   -------------------------------------*/\r
  36 /*******************************************|********************************************/\r
  37 #include "epson-escpr-pvt.h"\r
  38 #include "epson-escpr-err.h"\r
  39 #include "epson-escpr-services.h"\r
  40 #include "epson-escpr-mem.h"\r
  41 #include "epson-protocol.h"\r
  42 #include "epson-cbt.h"\r
  43 #include "epson-usb.h"\r
  44 \r
  45 /*--------------------------------  Local Definition   ---------------------------------*/\r
  46 /*******************************************|********************************************/\r
  47 #ifdef EPS_LOG_MODULE_USB\r
  48 #define EPS_LOG_MODULE  EPS_LOG_MODULE_USB\r
  49 #else\r
  50 #define EPS_LOG_MODULE  0\r
  51 #endif\r
  52 \r
  53 /*---------------------------  Data Structure Declarations   ---------------------------*/\r
  54 /*******************************************|********************************************/\r
  55 typedef struct _tagEPS_USB_PRINTER_INFO_ {\r
  56         EPS_USB_DEVICE  dev;\r
  57         EPS_BOOL                bCheckDataChannel;\r
  58 }EPS_USB_PRINTER_INFO;\r
  59 \r
  60 typedef struct _tagEPS_PRINT_JOB_USB_ {\r
  61         EPS_FILEDSC     fd;                                                     /* usb file descriptor                      */\r
  62         EPS_BOOL    resetRequest;                               /* recv reset request & yet not reset       */\r
  63 } EPS_PRINT_JOB_USB;\r
  64 \r
  65 \r
  66 /*--------------------------  ESC/P-R USB Lib Global Variables  ------------------------*/\r
  67 /*******************************************|********************************************/\r
  68 \r
  69         /*** Extern Function                                                                */\r
  70         /*** -------------------------------------------------------------------------------*/\r
  71 extern EPS_USB_FUNC    epsUsbFnc;\r
  72 extern EPS_CMN_FUNC    epsCmnFnc;\r
  73 \r
  74     /*** Print Job Structure                                                            */\r
  75     /*** -------------------------------------------------------------------------------*/\r
  76 extern EPS_PRINT_JOB   printJob;\r
  77 \r
  78         /*** Find                                                                           */\r
  79         /*** -------------------------------------------------------------------------------*/\r
  80 extern EPS_BOOL     g_FindBreak;                                                        /* Find printer end flag    */\r
  81 \r
  82     /*** I/O Channel                                                                    */\r
  83     /*** -------------------------------------------------------------------------------*/\r
  84 extern EPS_BOOL    ioOpenState;             /* Open state of I/O port (Bi-Directional)  */\r
  85 extern EPS_BOOL    ioDataChState;           /* Open state of Data Channel               */\r
  86 extern EPS_BOOL    ioControlChState;        /* Open state of Control Channel            */\r
  87 extern EPS_BOOL    ioOpenUniDirect;         /* Open state of I/O port (Uni-Directional) */\r
  88 \r
  89 /*--------------------------------  Local Functions   ----------------------------------*/\r
  90 /*******************************************|********************************************/\r
  91 static EPS_ERR_CODE ProbePrinterByName  (const EPS_INT8*, EPS_BOOL, EPS_UINT32,\r
  92                                                                                  EPS_USB_DEVICE*, EPS_INT8*, EPS_INT8*, EPS_INT32*);\r
  93 static EPS_ERR_CODE ProbeESCPR                  (const EPS_USB_DEVICE*, EPS_INT8*, EPS_INT8*, \r
  94                                                                                  EPS_INT32*                                     );\r
  95 static EPS_ERR_CODE CreatePrinterInfo   (const EPS_USB_DEVICE*, const EPS_INT8*, \r
  96                                                                                  const EPS_INT8*, EPS_INT32, EPS_PRINTER_INN**  );\r
  97 static EPS_ERR_CODE PortResolution              (const EPS_PRINTER_INN*, EPS_FILEDSC*           );\r
  98 static EPS_ERR_CODE GetBinaryStatus             (EPS_FILEDSC, EPS_STATUS_INFO*                                  );\r
  99 static EPS_ERR_CODE InfoCommand                 (EPS_FILEDSC, EPS_INT32, EPS_UINT8*, EPS_INT32* );\r
 100 \r
 101 \r
 102 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 103 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 104 /*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/\r
 105 /*--------------------              Public Functions               ---------------------*/\r
 106 /*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/\r
 107 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 108 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 109 \r
 110 /*******************************************|********************************************/\r
 111 /*                                                                                      */\r
 112 /* Function name:     usbFind()                                                             */\r
 113 /*                                                                                      */\r
 114 /* Arguments                                                                            */\r
 115 /* ---------                                                                            */\r
 116 /* Name:        Type:               Description:                                        */\r
 117 /* timeout      EPS_UINT32          I: find timeout                                     */\r
 118 /* protocol         EPS_INT32           I: communication mode                               */\r
 119 /*                                                                                      */\r
 120 /* Return value:                                                                        */\r
 121 /*      EPS_ERR_NONE                - Success Printer found                             */\r
 122 /*      EPS_ERR_PRINTER_NOT_FOUND       - Printer not found (or error occur)                    */\r
 123 /*      EPS_ERR_MEMORY_ALLOCATION   - memory allocation failed                          */\r
 124 /*      EPS_ERR_NOT_OPEN_IO             - Cannot Open I/O Portal                        */\r
 125 /*                                                                                      */\r
 126 /* Description:                                                                         */\r
 127 /*      find all USB printer.                                                           */\r
 128 /*                                                                                      */\r
 129 /*******************************************|********************************************/\r
 130 EPS_ERR_CODE usbFind (\r
 131 \r
 132         EPS_UINT32*         timeout,\r
 133                 EPS_INT32           protocol\r
 134                 \r
 135 ){\r
 136 /*** Declare Variable Local to Routine                                                  */\r
 137     EPS_ERR_CODE                ret = EPS_ERR_NONE;                      /* Return status of internal calls */\r
 138         EPS_FILEDSC                     fd = EPS_INVALID_FILEDSC;\r
 139         EPS_PRINTER_INN*        printer = NULL;\r
 140         EPS_USB_DEVICE          dev;\r
 141         EPS_INT8                        manufacturer[EPS_NAME_BUFFSIZE];    /* Manufacturer name        */\r
 142         EPS_INT8                        modelName[EPS_NAME_BUFFSIZE];       /* Printer model name       */\r
 143         EPS_UINT32                      tmStart, tmNow, tmSpan;\r
 144     EPS_INT32           cmdLevel = 0;\r
 145 \r
 146         EPS_LOG_FUNCIN;\r
 147 \r
 148         memset(&dev, 0, sizeof(dev));\r
 149         memset(manufacturer, 0, EPS_NAME_BUFFSIZE);\r
 150         memset(modelName, 0, EPS_NAME_BUFFSIZE);\r
 151 \r
 152 /***------------------------------------------------------------------------------------*/\r
 153 /*** Bi-Directional Communication Mode                                                  */\r
 154 /***------------------------------------------------------------------------------------*/\r
 155     if ( EPS_IS_BI_PROTOCOL(protocol) ) {\r
 156                 fd = epsUsbFnc.findFirst( &dev );\r
 157                 if(EPS_INVALID_FILEDSC != fd){\r
 158                         if(epsCmnFnc.getTime){\r
 159                                 tmStart = epsCmnFnc.getTime();\r
 160                         } else{\r
 161                                 *timeout = tmStart = tmNow = tmSpan = 0;\r
 162                         }\r
 163 \r
 164                         do{\r
 165                         /*** Validate this is an Epson ESC/PR Printer                                   */\r
 166                                 ret = ProbeESCPR(&dev, manufacturer, modelName, &cmdLevel);\r
 167 \r
 168                                 if(EPS_ERR_NONE == ret){\r
 169                                         ret = CreatePrinterInfo(&dev, manufacturer, modelName, cmdLevel, &printer);\r
 170                                         if( EPS_ERR_NONE == ret ){\r
 171                                                 ret = prtRegPrinter( printer, TRUE );\r
 172                                         } \r
 173 \r
 174                                         if( EPS_ERR_NONE != ret ){\r
 175                                                 break;\r
 176                                         }\r
 177 \r
 178                                         if(*timeout > 0){\r
 179                                                 tmNow = epsCmnFnc.getTime();\r
 180                                                 tmSpan = (EPS_UINT32)(tmNow - tmStart);\r
 181                                                 EPS_DBGPRINT( ("TM %u - %u <> %u\n", tmNow, tmStart, tmSpan) )\r
 182                                                 if( tmSpan >= *timeout ){\r
 183                                                         break;\r
 184                                                 }\r
 185                                         }\r
 186                                         if( epsCmnFnc.lockSync && epsCmnFnc.unlockSync ){\r
 187                                                 if( 0 == epsCmnFnc.lockSync() ){\r
 188                                                         if( g_FindBreak ){\r
 189                                                                 epsCmnFnc.unlockSync();\r
 190                                                                 break;\r
 191                                                         }\r
 192                                                         epsCmnFnc.unlockSync();\r
 193                                                 }\r
 194                                         }\r
 195                                 }\r
 196                         }while( epsUsbFnc.findNext( fd, &dev ) );\r
 197 \r
 198                         epsUsbFnc.findClose(fd);\r
 199 \r
 200                         if(*timeout > 0){\r
 201                                 /* calculate elapsed time */\r
 202                                 tmNow = epsCmnFnc.getTime();\r
 203                                 tmSpan = (EPS_UINT32)(tmNow - tmStart);\r
 204                                 if(tmSpan < *timeout){\r
 205                                         *timeout -= tmSpan;\r
 206                                 } else{\r
 207                                         *timeout = 1;\r
 208                                 }\r
 209                         }\r
 210 \r
 211                 } else{\r
 212                         ret = EPS_ERR_PRINTER_NOT_FOUND;\r
 213                 }\r
 214 \r
 215 /***------------------------------------------------------------------------------------*/\r
 216 /*** Uni-Directional Communication Mode                                                 */\r
 217 /***------------------------------------------------------------------------------------*/\r
 218         } else{\r
 219     /*** Open Portal check                                                              */\r
 220         fd = epsUsbFnc.openPortal(NULL);\r
 221                 if(EPS_INVALID_FILEDSC != fd){\r
 222                         epsUsbFnc.closePortal(fd);\r
 223 \r
 224                         /*** Create printer info structure                                          */\r
 225                         ret = CreatePrinterInfo(&dev, "", "", 0, &printer);\r
 226                         if( EPS_ERR_NONE == ret ){\r
 227                                 ret = prtRegPrinter( printer, TRUE );\r
 228                         } \r
 229                 } else{\r
 230             ret = EPS_ERR_PRINTER_NOT_FOUND;\r
 231         }\r
 232         }\r
 233 \r
 234         EPS_RETURN( ret );\r
 235 }\r
 236 \r
 237 \r
 238 /*******************************************|********************************************/\r
 239 /*                                                                                      */\r
 240 /* Function name:   usbProbePrinterByID()                                               */\r
 241 /*                                                                                      */\r
 242 /* Arguments                                                                            */\r
 243 /* ---------                                                                            */\r
 244 /* Name:        Type:               Description:                                        */\r
 245 /* printerUUID EPS_INT8*            I: ID String of probe target                        */\r
 246 /* timeout      EPS_UINT32          I: find timeout                                     */\r
 247 /* printer              EPS_PRINTER_INN**   O: pointer for found printer structure              */\r
 248 /*                                                                                      */\r
 249 /* Return value:                                                                        */\r
 250 /*      EPS_ERR_NONE                    - Success (printer found)                       */\r
 251 /*      EPS_ERR_PRINTER_NOT_FOUND       - printer not found                             */\r
 252 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
 253 /*      EPS_ERR_NOT_OPEN_IO             - Cannot Open I/O Portal                        */\r
 254 /*                                                                                      */\r
 255 /* Description:                                                                         */\r
 256 /*     looks for specified printer.                                                     */\r
 257 /*                                                                                      */\r
 258 /*******************************************|********************************************/\r
 259 EPS_ERR_CODE   usbProbePrinterByID (\r
 260 \r
 261                 EPS_INT8*                       printerUUID,\r
 262         EPS_UINT32                      timeout,\r
 263                 EPS_PRINTER_INN**   printer\r
 264 \r
 265 ){\r
 266 /*** Declare Variable Local to Routine                                                  */\r
 267     EPS_ERR_CODE        ret = EPS_ERR_NONE;                              /* Return status of internal calls */\r
 268         EPS_FILEDSC             fd = EPS_INVALID_FILEDSC;\r
 269         EPS_USB_DEVICE  dev;\r
 270         EPS_INT8                manufacturer[EPS_NAME_BUFFSIZE];    /* Manufacturer name            */\r
 271         EPS_INT8                modelName[EPS_NAME_BUFFSIZE];       /* Printer model name           */\r
 272     EPS_INT8*       pPos = NULL;\r
 273     EPS_INT32       nSegCnt = 0;\r
 274     EPS_UINT32      nTmp = 0;\r
 275         EPS_INT8                modelNameTgt[EPS_NAME_BUFFSIZE];    /* target printer model name    */\r
 276         EPS_BOOL                enableBreak = FALSE;\r
 277         EPS_INT32       cmdLevel = 0;\r
 278 \r
 279         EPS_LOG_FUNCIN;\r
 280 \r
 281 /*** Parse definition String                                                        */\r
 282         pPos = strtok(printerUUID, EPS_USBID_SEP);\r
 283     for(nSegCnt = 0; pPos != NULL && nSegCnt < EPS_USBID_SEGNUM; nSegCnt++){\r
 284                 switch(nSegCnt){\r
 285                 case 0:                 /* Get VID */\r
 286                 case 1:                 /* Get PID */\r
 287                         sscanf(pPos, "%x", &nTmp);\r
 288                         if(nTmp == 0){\r
 289                                 EPS_RETURN( EPS_ERR_INV_ARG_PRINTER_ID );\r
 290                         }\r
 291                         /* lib do not use VID, PID */\r
 292                         break;\r
 293 \r
 294                 case 2:                 /* Get model name */\r
 295                         strcpy(modelNameTgt, pPos);\r
 296                         break;\r
 297                 }\r
 298 \r
 299                 pPos = strtok(NULL, EPS_USBID_SEP);\r
 300     }\r
 301         if(nSegCnt < EPS_USBID_SEGNUM){\r
 302                 EPS_RETURN( EPS_ERR_INV_ARG_PRINTER_ID );\r
 303         }\r
 304 \r
 305         memset(&dev, 0, sizeof(dev));\r
 306 \r
 307 /***------------------------------------------------------------------------------------*/\r
 308 /*** Bi-Directional Communication Mode                                                  */\r
 309 /***------------------------------------------------------------------------------------*/\r
 310     if ( EPS_IS_BI_PROTOCOL(printJob.commMode) ) {\r
 311                 enableBreak = (epsCmnFnc.lockSync && epsCmnFnc.unlockSync );\r
 312                 memset(manufacturer, 0, sizeof(manufacturer));\r
 313                 memset(modelName, 0, sizeof(modelName));\r
 314                 ret = ProbePrinterByName(modelNameTgt, enableBreak, timeout, \r
 315                                              &dev, manufacturer, modelName, &cmdLevel);\r
 316                 if(EPS_ERR_NONE == ret){\r
 317                         /*** Create printer info structure                                          */\r
 318                         ret = CreatePrinterInfo(&dev, manufacturer, modelName, cmdLevel, printer);\r
 319                 }\r
 320 /***------------------------------------------------------------------------------------*/\r
 321 /*** Uni-Directional Communication Mode                                                 */\r
 322 /***------------------------------------------------------------------------------------*/\r
 323     } else{\r
 324     /*** Open Portal check                                                              */\r
 325         fd = epsUsbFnc.openPortal(NULL);\r
 326                 if(EPS_INVALID_FILEDSC != fd){\r
 327                         epsUsbFnc.closePortal(fd);\r
 328 \r
 329                         /*** Create printer info structure                                          */\r
 330                         ret = CreatePrinterInfo(&dev, "", "", 0, printer);\r
 331 \r
 332                 } else{\r
 333             ret = EPS_ERR_PRINTER_NOT_FOUND;\r
 334         }\r
 335     }\r
 336 \r
 337 /*** Return to Caller                                                                   */\r
 338     EPS_RETURN( ret );\r
 339 }\r
 340 \r
 341 \r
 342 /*******************************************|********************************************/\r
 343 /*                                                                                      */\r
 344 /* Function name:     usbStartJob()                                                     */\r
 345 /*                                                                                      */\r
 346 /* Arguments                                                                            */\r
 347 /* ---------                                                                            */\r
 348 /* Name:            Type:                   Description:                                */\r
 349 /* printer          EPS_PRINTER_INN*        I: Pointer to a PrinterInfo                 */\r
 350 /*                                                                                      */\r
 351 /* Return value:                                                                        */\r
 352 /*      << Normal >>                                                                    */\r
 353 /*      EPS_ERR_NONE                    - Success                                       */\r
 354 /*      << Error >>                                                                     */\r
 355 /*      (Uni/Bi-Directional)                                                            */\r
 356 /*      EPS_ERR_LIB_NOT_INITIALIZED     - ESC/P-R Lib is NOT initialized                */\r
 357 /*      EPS_ERR_NOT_OPEN_IO             - Failed to open I/O                            */\r
 358 /*      (Bi-Directional Only)                                                           */\r
 359 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */\r
 360 /*                                                                                      */\r
 361 /* Description:                                                                         */\r
 362 /*      Creates a new print job.                                                        */\r
 363 /*                                                                                      */\r
 364 /*******************************************|********************************************/\r
 365 EPS_ERR_CODE    usbStartJob (\r
 366 \r
 367         void\r
 368 \r
 369 ){\r
 370 /*** Declare Variable Local to Routine                                                  */\r
 371         EPS_ERR_CODE            retStatus = EPS_ERR_NONE;   /* Return status of internal calls  */\r
 372         const EPS_PRINTER_INN* printer = printJob.printer;\r
 373         EPS_PRINT_JOB_USB       *usbPrintJob = NULL;\r
 374 \r
 375         EPS_LOG_FUNCIN;\r
 376 \r
 377 /*** Create USB Job data                                                                */\r
 378         usbPrintJob = (EPS_PRINT_JOB_USB*)EPS_ALLOC( sizeof(EPS_PRINT_JOB_USB) );\r
 379         if( NULL == usbPrintJob ){\r
 380                 EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION );\r
 381         }\r
 382         memset(usbPrintJob, 0, sizeof(EPS_PRINT_JOB_USB));\r
 383         usbPrintJob->fd = EPS_INVALID_FILEDSC;\r
 384         usbPrintJob->resetRequest = FALSE;\r
 385 \r
 386 /***------------------------------------------------------------------------------------*/\r
 387 /*** Bi-Directional Communication Mode                                                  */\r
 388 /***------------------------------------------------------------------------------------*/\r
 389         if( EPS_IS_BI_PROTOCOL(printer->protocol) ){\r
 390         /*** Resolve present port number. And Open the I/O Port for communication           */\r
 391                 retStatus = PortResolution(printer, &usbPrintJob->fd);\r
 392         if (retStatus != EPS_ERR_NONE) {\r
 393                         cbtCommClose(usbPrintJob->fd);\r
 394                         retStatus = (EPS_ERR_CODE)EPS_ERR_NOT_OPEN_IO;\r
 395             goto epsStartJob_END;\r
 396         }\r
 397 \r
 398     /*** Open the command channel                                                       */\r
 399         retStatus = cbtCommChannelOpen(usbPrintJob->fd, EPS_CBTCHANNEL_CTRL, TRUE);\r
 400         if (retStatus != EPS_ERR_NONE) {\r
 401                         retStatus = cbtCommClose(usbPrintJob->fd);\r
 402             retStatus = (EPS_ERR_CODE)EPS_ERR_NOT_OPEN_IO;\r
 403             goto epsStartJob_END;\r
 404         }\r
 405 \r
 406     /*** Open Data Channel                                                              */\r
 407         retStatus = cbtCommChannelOpen(usbPrintJob->fd, EPS_CBTCHANNEL_DATA, TRUE);\r
 408         if (retStatus != EPS_ERR_NONE) {\r
 409                         retStatus = cbtCommChannelClose(usbPrintJob->fd, EPS_CBTCHANNEL_CTRL);\r
 410                         retStatus = cbtCommClose(usbPrintJob->fd);\r
 411             retStatus = (EPS_ERR_CODE)EPS_ERR_PRINTER_ERR_OCCUR/*EPS_ERR_CANNOT_PRINT*/;\r
 412             goto epsStartJob_END;\r
 413         }\r
 414                 ((EPS_USB_PRINTER_INFO*)printer->protocolInfo)->bCheckDataChannel = FALSE;\r
 415 \r
 416 /***------------------------------------------------------------------------------------*/\r
 417 /*** Uni-Directional Communication Mode                                                 */\r
 418 /***------------------------------------------------------------------------------------*/\r
 419     } else{\r
 420     /*** Open Portal                                                                    */\r
 421         if (ioOpenUniDirect == EPS_IO_OPEN) {\r
 422             retStatus = EPS_ERR_2ND_OPEN_IO;\r
 423                         goto epsStartJob_END;\r
 424         } else {\r
 425             usbPrintJob->fd = epsUsbFnc.openPortal( NULL );\r
 426             if (EPS_INVALID_FILEDSC == usbPrintJob->fd) {\r
 427                 retStatus = EPS_ERR_NOT_OPEN_IO;\r
 428                                 goto epsStartJob_END;\r
 429             }\r
 430             ioOpenUniDirect = EPS_IO_OPEN;\r
 431         }\r
 432     }\r
 433 \r
 434         printJob.hProtInfo = (EPS_HANDLE)usbPrintJob;\r
 435 \r
 436 epsStartJob_END:\r
 437         if(EPS_ERR_NONE != retStatus){\r
 438                 EPS_SAFE_RELEASE(usbPrintJob);\r
 439         }\r
 440 \r
 441 /*** Return to Caller                                                                   */\r
 442     EPS_RETURN( retStatus );\r
 443 }\r
 444 \r
 445 \r
 446 /*******************************************|********************************************/\r
 447 /*                                                                                      */\r
 448 /* Function name:     usbRestartJob()                                                   */\r
 449 /*                                                                                      */\r
 450 /* Arguments                                                                            */\r
 451 /* ---------                                                                            */\r
 452 /* Name:            Type:                   Description:                                */\r
 453 /* N/A                                                                                  */\r
 454 /*                                                                                      */\r
 455 /* Return value:                                                                        */\r
 456 /*      << Normal >>                                                                    */\r
 457 /*      EPS_ERR_NONE                    - Success                                       */\r
 458 /*      << Error >>                                                                     */\r
 459 /*      (Uni/Bi-Directional)                                                            */\r
 460 /*      EPS_ERR_JOB_NOT_INITIALIZED     - JOB is NOT initialized                                                */\r
 461 /*      EPS_ERR_NOT_OPEN_IO             - Failed to open I/O                            */\r
 462 /*      (Bi-Directional Only)                                                           */\r
 463 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */\r
 464 /*                                                                                      */\r
 465 /* Description:                                                                         */\r
 466 /*      The port shut by usbResetPrinter() is opened again.                             */\r
 467 /*                                                                                      */\r
 468 /*******************************************|********************************************/\r
 469 EPS_ERR_CODE    usbRestartJob (\r
 470 \r
 471         void\r
 472 \r
 473 ){\r
 474 \r
 475 /*** Declare Variable Local to Routine                                                  */\r
 476         EPS_ERR_CODE            retStatus = EPS_ERR_NONE;   /* Return status of internal calls  */\r
 477         const EPS_PRINTER_INN* printer = printJob.printer;\r
 478         EPS_PRINT_JOB_USB* usbPrintJob = (EPS_PRINT_JOB_USB*)printJob.hProtInfo;\r
 479 \r
 480         EPS_LOG_FUNCIN;\r
 481 \r
 482         if( !usbPrintJob ){\r
 483                 EPS_RETURN( EPS_ERR_JOB_NOT_INITIALIZED );\r
 484         }\r
 485 \r
 486 /***------------------------------------------------------------------------------------*/\r
 487 /*** Bi-Directional Communication Mode                                                  */\r
 488 /***------------------------------------------------------------------------------------*/\r
 489         if( EPS_IS_BI_PROTOCOL(printer->protocol) ){\r
 490                 if(EPS_IO_NOT_OPEN == ioDataChState){\r
 491                 /*if( EPS_RESET_SENT == printJob.resetSent ){*/\r
 492                 /* If pre page canceled, Re open data channel */\r
 493                         retStatus = cbtCommChannelOpen(usbPrintJob->fd, EPS_CBTCHANNEL_DATA, TRUE);\r
 494                         if (retStatus == EPS_ERR_NONE) {\r
 495                                 ((EPS_USB_PRINTER_INFO*)printer->protocolInfo)->bCheckDataChannel = FALSE;\r
 496                         } else{\r
 497                                 retStatus = (EPS_ERR_CODE)EPS_ERR_PRINTER_ERR_OCCUR/*EPS_ERR_CANNOT_PRINT*/;\r
 498                         }\r
 499                 }\r
 500 /***------------------------------------------------------------------------------------*/\r
 501 /*** Uni-Directional Communication Mode                                                 */\r
 502 /***------------------------------------------------------------------------------------*/\r
 503 /*   } else{ \r
 504                 no operation*/\r
 505     }\r
 506 \r
 507 /*** Return to Caller                                                                   */\r
 508     EPS_RETURN( retStatus );\r
 509 }\r
 510 \r
 511 \r
 512 /*******************************************|********************************************/\r
 513 /*                                                                                      */\r
 514 /* Function name:   usbEndJob()                                                         */\r
 515 /*                                                                                      */\r
 516 /* Arguments                                                                            */\r
 517 /* ---------                                                                            */\r
 518 /* Name:            Type:                   Description:                                */\r
 519 /* N/A                                                                                  */\r
 520 /*                                                                                      */\r
 521 /* Return value:                                                                        */\r
 522 /*      << Normal >>                                                                    */\r
 523 /*      EPS_ERR_NONE                    - Success                                       */\r
 524 /*      << Error >>                                                                     */\r
 525 /*      EPS_ERR_JOB_NOT_INITIALIZED     - JOB is NOT initialized                        */\r
 526 /*      EPS_ERR_NOT_CLOSE_IO            - Cannot close I/O portal                       */\r
 527 /*                                                                                      */\r
 528 /* Description:                                                                         */\r
 529 /*      Ends the current print job.                                                     */\r
 530 /*                                                                                      */\r
 531 /*******************************************|********************************************/\r
 532 EPS_ERR_CODE    usbEndJob (\r
 533 \r
 534         void\r
 535 \r
 536 ){\r
 537     EPS_ERR_CODE    retStatus = EPS_ERR_NONE;       /* Return status of internal calls  */\r
 538         EPS_PRINT_JOB_USB* usbPrintJob = (EPS_PRINT_JOB_USB*)printJob.hProtInfo;\r
 539 \r
 540 EPS_LOG_FUNCIN;\r
 541 \r
 542         if( !usbPrintJob ){\r
 543                 EPS_RETURN( EPS_ERR_JOB_NOT_INITIALIZED );\r
 544         }\r
 545 \r
 546         switch(printJob.printer->protocol){\r
 547         case EPS_COMM_USB_BID:\r
 548 /***------------------------------------------------------------------------------------*/\r
 549 /*** Bi-Directional Communication Mode                                                  */\r
 550 /***------------------------------------------------------------------------------------*/\r
 551     /*** Close communication                                                            */\r
 552                 retStatus = cbtCommChannelClose(usbPrintJob->fd, EPS_CBTCHANNEL_DATA);\r
 553                 retStatus = cbtCommChannelClose(usbPrintJob->fd, EPS_CBTCHANNEL_CTRL);\r
 554                 retStatus = cbtCommClose(usbPrintJob->fd);\r
 555                 if (retStatus != EPS_ERR_NONE) {\r
 556                         retStatus = EPS_ERR_NOT_CLOSE_IO;\r
 557                 }\r
 558                 break;\r
 559 \r
 560         case EPS_COMM_USB_UNID:\r
 561 /***------------------------------------------------------------------------------------*/\r
 562 /*** Uni-Directional Communication Mode                                                 */\r
 563 /***------------------------------------------------------------------------------------*/\r
 564                 /*** Close Portal                                                               */\r
 565                 if (ioOpenUniDirect == EPS_IO_OPEN) {\r
 566                         retStatus = epsUsbFnc.closePortal(usbPrintJob->fd);\r
 567                         if (retStatus != 0) {\r
 568                                 EPS_RETURN( EPS_ERR_NOT_CLOSE_IO );\r
 569                         }\r
 570                         ioOpenUniDirect = EPS_IO_NOT_OPEN;\r
 571                 }\r
 572                 break;\r
 573 \r
 574         default:\r
 575                 retStatus = EPS_ERR_OPR_FAIL;\r
 576     }\r
 577 \r
 578         EPS_SAFE_RELEASE( printJob.hProtInfo );\r
 579 \r
 580         EPS_RETURN( retStatus );\r
 581 }\r
 582 \r
 583 \r
 584 \r
 585 /*******************************************|********************************************/\r
 586 /*                                                                                      */\r
 587 /* Function name:   usbWritePrintData()                                                 */\r
 588 /*                                                                                      */\r
 589 /* Arguments                                                                            */\r
 590 /* ---------                                                                            */\r
 591 /* Name:        Type:               Description:                                        */\r
 592 /* Buffer       const EPS_UINT8*    I: Buffer Pointer for Write Data                    */\r
 593 /* BuffLen      EPS_UINT32          I: Write Data Buffer Length (bytes)                 */\r
 594 /* sentSize     EPS_UINT32*         O: Actuall Write Size                               */\r
 595 /*                                                                                      */\r
 596 /* Return value:                                                                        */\r
 597 /*      EPCBT_ERR_NONE                  - Success                                       */\r
 598 /*      EPS_ERR_JOB_NOT_INITIALIZED     - JOB is NOT initialized                                                */\r
 599 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
 600 /*                                                                                      */\r
 601 /* Description:                                                                         */\r
 602 /*      Write the data to printer Data Channel.                                         */\r
 603 /*                                                                                      */\r
 604 /*******************************************|********************************************/\r
 605 EPS_ERR_CODE   usbWritePrintData (\r
 606 \r
 607                 const EPS_UINT8*    Buffer,\r
 608         EPS_UINT32          BuffLen,\r
 609         EPS_UINT32*         sentSize\r
 610 \r
 611 ){\r
 612     EPS_INT32              retCom;\r
 613         EPS_PRINT_JOB_USB* usbPrintJob = (EPS_PRINT_JOB_USB*)printJob.hProtInfo;\r
 614 \r
 615 EPS_LOG_FUNCIN;\r
 616 \r
 617         if( !usbPrintJob ){\r
 618                 EPS_RETURN( EPS_ERR_JOB_NOT_INITIALIZED );\r
 619         }\r
 620 \r
 621         if( EPS_IS_BI_PROTOCOL(printJob.printer->protocol) ){\r
 622                 retCom = cbtCommWriteData(usbPrintJob->fd, EPS_CBTCHANNEL_DATA, Buffer, (EPS_INT32)BuffLen, (EPS_INT32*)sentSize);\r
 623                 if(EPCBT_ERR_NONE == retCom){\r
 624                         EPS_RETURN( EPS_ERR_NONE );\r
 625                 } else if(EPSCBT_ERR_FNCDISABLE == retCom){\r
 626                         EPS_RETURN( EPS_COM_TINEOUT );\r
 627                 }else{\r
 628                         EPS_RETURN( EPS_ERR_COMM_ERROR );\r
 629                 }\r
 630         } else{\r
 631                 retCom = epsUsbFnc.writePortal(usbPrintJob->fd, Buffer, (EPS_INT32)BuffLen, (EPS_INT32*)sentSize);\r
 632                 if(0 == retCom){\r
 633                         EPS_RETURN( EPS_ERR_NONE );\r
 634                 } else{\r
 635                         EPS_RETURN( EPS_ERR_COMM_ERROR );\r
 636                 }\r
 637         }\r
 638 }\r
 639 \r
 640 \r
 641 /*******************************************|********************************************/\r
 642 /*                                                                                      */\r
 643 /* Function name:   usbResetPrinter()                                                   */\r
 644 /*                                                                                      */\r
 645 /* Arguments                                                                            */\r
 646 /* ---------                                                                            */\r
 647 /* Name:        Type:               Description:                                        */\r
 648 /* void         -                   -                                                   */\r
 649 /*                                                                                      */\r
 650 /* Return value:                                                                        */\r
 651 /*      EPS_ERR_NONE                    - Success                                       */\r
 652 /*      EPS_ERR_JOB_NOT_INITIALIZED     - JOB is NOT initialized                                                */\r
 653 /*      EPS_ERR_COMM_ERROR              - Failed to send command                        */\r
 654 /*      EPS_ERR_CAN_NOT_RESET           - Failed to reset printer                       */\r
 655 /*      EPS_ERR_NOT_CLOSE_IO            - Cannot Close I/O Portal                       */\r
 656 /*                                                                                      */\r
 657 /* Description:                                                                         */\r
 658 /*      Send "rj" command and reset printer.                                            */\r
 659 /*                                                                                      */\r
 660 /*******************************************|********************************************/\r
 661 EPS_ERR_CODE   usbResetPrinter (\r
 662 \r
 663         void\r
 664 \r
 665 ){\r
 666 /*** Declare Variable Local to Routine                                                  */\r
 667 #define EPS_RSREPLY_SIZE        (32)\r
 668     EPS_ERR_CODE    Ret;\r
 669     EPS_INT32       ComSize = 0;\r
 670     EPS_INT32       retBufSize;                         /* Size of buffer written       */\r
 671     EPS_INT32       retryComm;\r
 672     EPS_INT32       retryReset;\r
 673     EPS_INT32       Size = EPS_RSREPLY_SIZE;\r
 674     EPS_INT32       lSize;\r
 675     EPS_UINT8       pResult[EPS_RSREPLY_SIZE];\r
 676         EPS_PRINT_JOB_USB* usbPrintJob = (EPS_PRINT_JOB_USB*)printJob.hProtInfo;\r
 677     \r
 678     EPS_UINT8 CBTcmd_rj[] = { 'r',   'j', 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\r
 679                          /* E   , S   , C   , P   , R   , L   , i   , b    */\r
 680                             0x45, 0x53, 0x43, 0x50, 0x52, 0x4c, 0x69, 0x62 };\r
 681 #if 0  /* Not use "rs" command */\r
 682     EPS_UINT8 CBTcmd_rs[] = {'r', 's', 0x01, 0x00, 0x01};\r
 683 #endif\r
 684 \r
 685 \r
 686 EPS_LOG_FUNCIN;\r
 687 \r
 688 /*** Initialize Local Variables                                                         */\r
 689     retBufSize = 0;\r
 690     memset(pResult, 0, 32);\r
 691 \r
 692         if( !usbPrintJob ){\r
 693                 EPS_RETURN( EPS_ERR_JOB_NOT_INITIALIZED );\r
 694         }\r
 695 \r
 696 /*** If we already successfully called this function once for a given print job,        */\r
 697     if( printJob.resetSent == EPS_RESET_SENT \r
 698                 || FALSE == printJob.transmittable\r
 699                 || FALSE == printJob.sendJS ){\r
 700         EPS_RETURN( EPS_ERR_NONE );/*  no need to send an "rj" command again. Therefore,   */\r
 701                                    /*  return EPS_ERR_NONE and exit gracefully.            */\r
 702     }\r
 703 \r
 704         EPS_DBGPRINT((">>>> Send Printer Reset Command.\r\n"));\r
 705         serDelayThread(500, &epsCmnFnc);                                /* wait printer 500ms */  \r
 706 \r
 707     retryReset = 5;  /* 5 times time out */\r
 708     do{\r
 709 /*** Send "rj" command                                                                  */\r
 710         retryComm = 5;\r
 711         do{\r
 712             Ret = cbtCommWriteData(usbPrintJob->fd, EPS_CBTCHANNEL_CTRL, (const EPS_UINT8*)CBTcmd_rj, sizeof(CBTcmd_rj), &ComSize);\r
 713             \r
 714             if ( Ret != EPCBT_ERR_NONE){\r
 715                 if (Ret != EPSCBT_ERR_FNCDISABLE){\r
 716                     EPS_DBGPRINT(("CBT Command Write Failed [%d]\r\n",Ret));\r
 717                     EPS_RETURN( EPS_ERR_COMM_ERROR );\r
 718                 }\r
 719                 retryComm--;\r
 720                 if (!retryComm) {\r
 721                     EPS_DBGPRINT(("CBT Command Write Retry Failed \r\n"));\r
 722                     EPS_RETURN( EPS_ERR_COMM_ERROR );\r
 723                 }        \r
 724                 serDelayThread(1*_SECOND_, &epsCmnFnc);        /* retry command after 1 seconds*/\r
 725             }\r
 726         }while (Ret == EPSCBT_ERR_FNCDISABLE);\r
 727         \r
 728 /*** Read "rj" Reply                                                                    */\r
 729         retryComm = 5;\r
 730         lSize = Size-1;\r
 731         do{\r
 732             if ((Ret = cbtCommReadData(usbPrintJob->fd, EPS_CBTCHANNEL_CTRL, pResult, lSize, &Size)) != EPCBT_ERR_NONE){\r
 733                 if (Ret != EPSCBT_ERR_FNCDISABLE){\r
 734                     EPS_DBGPRINT(("CBT Command Write Reply Failed [%d]\r\n",Ret));\r
 735                     EPS_RETURN( EPS_ERR_COMM_ERROR );\r
 736                 }    \r
 737             }else if (Size != 0){\r
 738                 break;\r
 739             }\r
 740 \r
 741             retryComm--;\r
 742             if (!retryComm){\r
 743                 EPS_DBGPRINT(("CBT Command Write Reply Retry Failed \r\n"));\r
 744                 EPS_RETURN( EPS_ERR_COMM_ERROR );\r
 745             }\r
 746             serDelayThread(1*_SECOND_, &epsCmnFnc);        /* retry command after 1 seconds*/\r
 747         }while(retryComm > 0);\r
 748         \r
 749 /*** Make sure we received a correct reply in response to the reset command we sent.    */\r
 750                 pResult[EPS_RSREPLY_SIZE-1] = '\0';\r
 751                 EPS_DUMP(pResult, Size);\r
 752                 if (strstr((EPS_INT8*)pResult, "rj:OK;") == NULL) {\r
 753             retryReset--;\r
 754             if (!retryReset) {\r
 755                 EPS_DBGPRINT(("Failed to <rj> reset \r\n"));\r
 756                 EPS_RETURN( EPS_ERR_CAN_NOT_RESET );\r
 757             }\r
 758             serDelayThread(500, &epsCmnFnc);        /* retry command after 500m seconds*/\r
 759         } else{\r
 760             break;\r
 761         }\r
 762 \r
 763     }while(retryReset > 0);\r
 764 \r
 765         /*** Close Data Channel after sent "rj" command                                     */\r
 766         Ret = cbtCommChannelClose(usbPrintJob->fd, EPS_CBTCHANNEL_DATA);\r
 767     if (Ret != EPS_ERR_NONE) {\r
 768         EPS_RETURN( EPS_ERR_NOT_CLOSE_IO );\r
 769     }\r
 770         if(printJob.printer && printJob.printer->protocolInfo){\r
 771                 ((EPS_USB_PRINTER_INFO*)printJob.printer->protocolInfo)->bCheckDataChannel = TRUE;\r
 772         }\r
 773 \r
 774         usbPrintJob->resetRequest = FALSE;\r
 775 \r
 776 /*** Return to Caller                                                                   */\r
 777     EPS_RETURN( EPS_ERR_NONE );\r
 778 }\r
 779 \r
 780 \r
 781 /*******************************************|********************************************/\r
 782 /*                                                                                      */\r
 783 /* Function name:   usbGetPMString()                                                    */\r
 784 /*                                                                                      */\r
 785 /* Arguments                                                                            */\r
 786 /* ---------                                                                            */\r
 787 /* Name:            Type:                   Description:                                */\r
 788 /* printer          EPS_PRINTER_INN*        I: Pointer to a PrinterInfo                 */\r
 789 /* type                         EPS_INT32                               I: PM kind 1 or 2                           */\r
 790 /* pString                      EPS_UINT8*                              O: Pointer to PM String                     */\r
 791 /* bufSize                      EPS_INT32                               I: pString buffer size                      */\r
 792 /*                                                                                      */\r
 793 /* Return value:                                                                        */\r
 794 /*      EPS_ERR_NONE                    - Success                                       */\r
 795 /*      EPS_ERR_JOB_NOT_INITIALIZED     - JOB is NOT initialized                                                */\r
 796 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
 797 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
 798 /*      EPS_ERR_NOT_OPEN_IO             - Cannot Open I/O Portal                        */\r
 799 /*      EPS_ERR_COMM_ERROR              - Info command execution error                  */\r
 800 /*                                                                                      */\r
 801 /* Description:                                                                         */\r
 802 /*      Get PM string from usb printer.                                                 */\r
 803 /*                                                                                      */\r
 804 /*******************************************|********************************************/\r
 805 EPS_ERR_CODE     usbGetPMString (\r
 806 \r
 807                 const EPS_PRINTER_INN*  printer,\r
 808                 EPS_INT32               type,\r
 809                 EPS_UINT8*              pString,\r
 810                 EPS_INT32*              bufSize\r
 811 \r
 812 ){\r
 813 /*** Declare Variable Local to Routine                                                  */\r
 814     EPS_ERR_CODE                ret = EPS_ERR_NONE;     /* Return status of internal calls      */\r
 815         EPS_FILEDSC                     fd = EPS_INVALID_FILEDSC;\r
 816         EPS_PRINT_JOB_USB*      usbPrintJob = (EPS_PRINT_JOB_USB*)printJob.hProtInfo;\r
 817 \r
 818 EPS_LOG_FUNCIN;\r
 819 \r
 820         if (ioOpenState == EPS_IO_NOT_OPEN) {\r
 821         /*** Resolve present port number. And Open the I/O Port for communication           */\r
 822                 ret = PortResolution(printer, &fd);\r
 823         if (ret != EPS_ERR_NONE) {\r
 824                         cbtCommClose(fd);\r
 825                         EPS_RETURN( EPS_ERR_NOT_OPEN_IO );\r
 826                 }\r
 827 \r
 828                 /*** Open the control channel                                                   */\r
 829                 ret = cbtCommChannelOpen(fd, EPS_CBTCHANNEL_CTRL, TRUE);\r
 830                 if (ret != EPS_ERR_NONE) {\r
 831                         cbtCommChannelClose(fd, EPS_CBTCHANNEL_CTRL);\r
 832                         cbtCommClose(fd);\r
 833                         EPS_RETURN( EPS_ERR_NOT_OPEN_IO );\r
 834                 }\r
 835 \r
 836 /*** Get PM from Printer                                                                */\r
 837                 if(1 == type){\r
 838                         ret = InfoCommand(fd, EPS_CBTCOM_PM, pString, bufSize);\r
 839                 } else if(2 == type){\r
 840                         ret = InfoCommand(fd, EPS_CBTCOM_PM2, pString, bufSize);\r
 841                 } else{\r
 842                         ret = EPS_ERR_OPR_FAIL;\r
 843                 }\r
 844        \r
 845                 /* Close Port */\r
 846                 cbtCommChannelClose(fd, EPS_CBTCHANNEL_CTRL);\r
 847                 cbtCommClose(fd);\r
 848         } else{\r
 849 \r
 850                 if( !usbPrintJob ){\r
 851                         EPS_RETURN( EPS_ERR_JOB_NOT_INITIALIZED );\r
 852                 }\r
 853 \r
 854 /*** Get PM from Printer                                                                */\r
 855                 if(1 == type){\r
 856                         ret = InfoCommand(usbPrintJob->fd, EPS_CBTCOM_PM, pString, bufSize);\r
 857                 } else if(2 == type){\r
 858                         ret = InfoCommand(usbPrintJob->fd, EPS_CBTCOM_PM2, pString, bufSize);\r
 859                 } else{\r
 860                         ret = EPS_ERR_OPR_FAIL;\r
 861                 }\r
 862         }\r
 863 \r
 864 /*** Return to Caller                                                                   */\r
 865     EPS_RETURN( ret );\r
 866 }\r
 867 \r
 868 \r
 869 /*******************************************|********************************************/\r
 870 /*                                                                                      */\r
 871 /* Function name:   usbGetStatus()                                                      */\r
 872 /*                                                                                      */\r
 873 /* Arguments                                                                            */\r
 874 /* ---------                                                                            */\r
 875 /* Name:        Type:               Description:                                        */\r
 876 /* printer              EPS_PRINTER_INN*    I: Pointer to a PrinterInfo                         */\r
 877 /* status       EPS_STATUS_INFO*    O: Pointer to the printer status.                   */\r
 878 /* ioStatus             EPS_INT32*              O: It is possible to communicate                                    */\r
 879 /* canceling    EPS_BOOL*               O: Cancel processing                                                */\r
 880 /*                                                                                      */\r
 881 /* Return value:                                                                        */\r
 882 /*      << Normal >>                                                                    */\r
 883 /*      EPS_ERR_NONE                    - Success                                       */\r
 884 /*      << Error >>                                                                     */\r
 885 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
 886 /*      EPS_ERR_COMM_ERROR              - Info command execution error                  */\r
 887 /*      EPS_ERR_NOT_OPEN_IO             - Cannot Open I/O Portal                        */\r
 888 /*      EPS_ERR_NOT_CLOSE_IO            - Cannot Close I/O Portal                       */\r
 889 /*                                                                                      */\r
 890 /* Description:                                                                         */\r
 891 /*      Gets the printer status.                                                        */\r
 892 /*                                                                                      */\r
 893 /*******************************************|********************************************/\r
 894 EPS_ERR_CODE    usbGetStatus (\r
 895 \r
 896                 EPS_STATUS_INFO*                pstInfo,\r
 897                 EPS_BOOL*                               pIoStatus,\r
 898                 EPS_BOOL*                               pCancelling\r
 899 \r
 900 ){\r
 901 \r
 902 /*** Declare Variable Local to Routine                                                  */\r
 903         EPS_ERR_CODE            ret;                    /* Return status of internal calls      */\r
 904         EPS_FILEDSC                     fd = EPS_INVALID_FILEDSC;\r
 905         EPS_PRINTER_INN*        printer = printJob.printer;\r
 906         EPS_PRINT_JOB_USB*      usbPrintJob = (EPS_PRINT_JOB_USB*)printJob.hProtInfo;\r
 907 \r
 908 EPS_LOG_FUNCIN;\r
 909 \r
 910 /*** Initialize Local Variables                                                         */\r
 911     ret           = EPS_ERR_NONE;\r
 912     memset(pstInfo, -1, sizeof(EPS_STATUS_INFO));\r
 913 \r
 914 /*** Get Status Data                                                                    */\r
 915     if (ioOpenState == EPS_IO_NOT_OPEN) {\r
 916                 /*** Resolve present port number. And Open the I/O Port for communication       */\r
 917                 ret = PortResolution(printer, &fd);\r
 918         if (ret != EPS_ERR_NONE) {\r
 919             cbtCommClose(fd);\r
 920             EPS_RETURN( EPS_ERR_NOT_OPEN_IO );\r
 921         }\r
 922 \r
 923         /*** Open the control channel                                                   */\r
 924         ret = cbtCommChannelOpen(fd, EPS_CBTCHANNEL_CTRL, TRUE);\r
 925         if (ret != EPS_ERR_NONE) {\r
 926             cbtCommChannelClose(fd, EPS_CBTCHANNEL_CTRL);\r
 927             cbtCommClose(fd);\r
 928             EPS_RETURN( EPS_ERR_NOT_OPEN_IO );\r
 929         }\r
 930 \r
 931         /*** Get Printer Status                                                         */\r
 932         ret = GetBinaryStatus(fd, pstInfo);\r
 933         if (ret != EPS_ERR_NONE) {\r
 934             cbtCommChannelClose(fd, EPS_CBTCHANNEL_CTRL);\r
 935             cbtCommClose(fd);\r
 936             EPS_RETURN( ret );\r
 937         }\r
 938 \r
 939                 if(NULL != pIoStatus && NULL != pCancelling){\r
 940                         /*** Check I/O status                                                           */\r
 941                         *pCancelling = FALSE;\r
 942                         if(EPS_CAREQ_CANCEL == pstInfo->nCancel\r
 943                                 || (usbPrintJob && TRUE == usbPrintJob->resetRequest)){\r
 944                                 *pIoStatus = FALSE;\r
 945                                 *pCancelling = TRUE;\r
 946                                 if(usbPrintJob){\r
 947                                         /* Because EPS_CAREQ_CANCEL can be acquired only once, it memorizes. */\r
 948                                         usbPrintJob->resetRequest = TRUE;\r
 949                                 }\r
 950                         } else if(EPS_ST_IDLE == pstInfo->nState){\r
 951                                 if( ((EPS_USB_PRINTER_INFO*)printer->protocolInfo)->bCheckDataChannel ){\r
 952                                         /*** Open Data Channel                                                  */\r
 953                                         if (cbtCommChannelOpen(fd, EPS_CBTCHANNEL_DATA, FALSE) == EPS_ERR_NONE) {\r
 954                                                 ((EPS_USB_PRINTER_INFO*)printer->protocolInfo)->bCheckDataChannel = FALSE;\r
 955                                                 *pIoStatus = TRUE;\r
 956                                         } else{\r
 957                                                 *pIoStatus = FALSE;\r
 958                                                 *pCancelling = TRUE;\r
 959                                         }\r
 960                                         cbtCommChannelClose(fd, EPS_CBTCHANNEL_DATA);\r
 961                                 } else{\r
 962                                         *pIoStatus = TRUE;\r
 963                                 }\r
 964                         } else{\r
 965                                 *pIoStatus = FALSE;\r
 966                                 if( ((EPS_USB_PRINTER_INFO*)printer->protocolInfo)->bCheckDataChannel ){\r
 967                                         *pCancelling = TRUE;\r
 968                                 }\r
 969                         }\r
 970                 }\r
 971 \r
 972                 /* Close Port */\r
 973         ret = cbtCommChannelClose(fd, EPS_CBTCHANNEL_CTRL);\r
 974         ret = cbtCommClose(fd);\r
 975         if (ret != EPS_ERR_NONE) {\r
 976             EPS_RETURN( EPS_ERR_NOT_CLOSE_IO );\r
 977         }\r
 978 \r
 979     } else{ /* Job running now */\r
 980 \r
 981                 if( !usbPrintJob ){\r
 982                         EPS_RETURN( EPS_ERR_OPR_FAIL );\r
 983                 }\r
 984 \r
 985                 /*** Get Printer Status                                                         */\r
 986         ret = GetBinaryStatus(usbPrintJob->fd, pstInfo);\r
 987         if (ret != EPS_ERR_NONE) {\r
 988             EPS_RETURN( ret );\r
 989         }\r
 990 \r
 991                 if(NULL != pIoStatus && NULL != pCancelling){\r
 992                         /*** Check I/O status                                                       */\r
 993                         *pCancelling = FALSE;\r
 994                         if(EPS_CAREQ_CANCEL == pstInfo->nCancel\r
 995                                 || (usbPrintJob && TRUE == usbPrintJob->resetRequest)){\r
 996                                 *pIoStatus = FALSE;\r
 997                                 *pCancelling = TRUE;\r
 998                                 if(usbPrintJob){\r
 999                                         /* Because EPS_CAREQ_CANCEL can be acquired only once, it memorizes. */\r
1000                                         usbPrintJob->resetRequest = TRUE;\r
1001                                 }\r
1002                         } else if(EPS_IO_OPEN == ioDataChState){\r
1003                                 *pIoStatus = TRUE;      /* Evidence */\r
1004                         } else if(EPS_ST_IDLE == pstInfo->nState){\r
1005                                 if( ((EPS_USB_PRINTER_INFO*)printer->protocolInfo)->bCheckDataChannel ){\r
1006                                         /*** Open Data Channel                                              */\r
1007                                         if (cbtCommChannelOpen(usbPrintJob->fd, EPS_CBTCHANNEL_DATA, FALSE) == EPS_ERR_NONE) {\r
1008                                                 ((EPS_USB_PRINTER_INFO*)printer->protocolInfo)->bCheckDataChannel = FALSE;\r
1009                                                 *pIoStatus = TRUE;\r
1010                                         } else{\r
1011                                                 *pIoStatus = FALSE;\r
1012                                                 *pCancelling = TRUE;\r
1013                                         }\r
1014                                         cbtCommChannelClose(usbPrintJob->fd, EPS_CBTCHANNEL_DATA);\r
1015                                 } else{\r
1016                                         *pIoStatus = TRUE;\r
1017                                 }\r
1018                         } else{\r
1019                                 *pIoStatus = FALSE;\r
1020                                 if( ((EPS_USB_PRINTER_INFO*)printer->protocolInfo)->bCheckDataChannel ){\r
1021                                         *pCancelling = TRUE;\r
1022                                 }\r
1023                         }\r
1024                 }\r
1025     }\r
1026         \r
1027 /*** Return to Caller                                                                   */\r
1028     EPS_RETURN( ret );\r
1029 }\r
1030 \r
1031 \r
1032 /*******************************************|********************************************/\r
1033 /*                                                                                      */\r
1034 /* Function name:   usbGetJobStatus()                                                   */\r
1035 /*                                                                                      */\r
1036 /* Arguments                                                                            */\r
1037 /* ---------                                                                            */\r
1038 /* Name:        Type:               Description:                                        */\r
1039 /* pstInfo      EPS_STATUS_INFO*    O: Printer Status information                       */\r
1040 /*                                                                                      */\r
1041 /* Return value:                                                                        */\r
1042 /*      EPS_ERR_NONE                    - Success                                       */\r
1043 /*      EPS_ERR_JOB_NOT_INITIALIZED     - JOB is NOT initialized                                                */\r
1044 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
1045 /*                                                                                      */\r
1046 /* Description:                                                                         */\r
1047 /*      Get the printer status and analyze the status string.                           */\r
1048 /*                                                                                      */\r
1049 /*******************************************|********************************************/\r
1050 EPS_ERR_CODE    usbGetJobStatus (\r
1051 \r
1052         EPS_STATUS_INFO*    pstInfo\r
1053 \r
1054 ){\r
1055         EPS_ERR_CODE            ret = EPS_ERR_NONE;\r
1056         EPS_PRINT_JOB_USB*      usbPrintJob = (EPS_PRINT_JOB_USB*)printJob.hProtInfo;\r
1057 \r
1058 EPS_LOG_FUNCIN;\r
1059 \r
1060         if( !usbPrintJob ){\r
1061                 EPS_RETURN( EPS_ERR_JOB_NOT_INITIALIZED );\r
1062         }\r
1063 \r
1064         ret = GetBinaryStatus(usbPrintJob->fd, pstInfo);\r
1065         if(EPS_ERR_NONE == ret\r
1066                 && EPS_CAREQ_CANCEL == pstInfo->nCancel){\r
1067                 usbPrintJob->resetRequest = TRUE;\r
1068         }\r
1069 \r
1070         EPS_RETURN( ret ); \r
1071 }\r
1072 \r
1073 \r
1074 /*******************************************|********************************************/\r
1075 /*                                                                                      */\r
1076 /* Function name:   usbMechCommand()                                                    */\r
1077 /*                                                                                      */\r
1078 /* Arguments                                                                            */\r
1079 /* ---------                                                                            */\r
1080 /* Name:        Type:               Description:                                        */\r
1081 /* Command      EPS_INT32           I: Command Code                                     */\r
1082 /*                                                                                      */\r
1083 /* Return value:                                                                        */\r
1084 /*      EPS_ERR_NONE                    - Mech command executed successfully            */\r
1085 /*      EPS_ERR_JOB_NOT_INITIALIZED     - JOB is NOT initialized                                                */\r
1086 /*      EPS_ERR_COMM_ERROR              - Mech command execution error                  */\r
1087 /*                                                                                      */\r
1088 /* Description:                                                                         */\r
1089 /*      Sends mechanincal commands to the printer.                                      */\r
1090 /*                                                                                      */\r
1091 /*******************************************|********************************************/\r
1092 EPS_ERR_CODE    usbMechCommand (\r
1093 \r
1094         EPS_INT32   Command\r
1095         \r
1096 ){\r
1097 /*** Declare Variable Local to Routine                                                  */\r
1098     static EPS_UINT8 stCom[] = {'x', 'x', 0x01, 0x00, 0x01};\r
1099     EPS_INT8        Reply[32];\r
1100     EPS_INT32       Size = 32;\r
1101     EPS_INT32       Retry;\r
1102     EPS_INT32       ComSize = 0;\r
1103     EPS_INT32       Ret;\r
1104     EPS_UINT8*      Com;\r
1105     EPS_INT32       cSize;\r
1106         EPS_PRINT_JOB_USB* usbPrintJob = (EPS_PRINT_JOB_USB*)printJob.hProtInfo;\r
1107 \r
1108 EPS_LOG_FUNCIN;\r
1109 \r
1110         if( !usbPrintJob ){\r
1111                 EPS_RETURN( EPS_ERR_JOB_NOT_INITIALIZED );\r
1112         }\r
1113 \r
1114 /*** Initialize Local Variables                                                         */\r
1115     memset(Reply, 0, 32);\r
1116 \r
1117 /*** Select Command                                                                     */\r
1118     switch(Command){\r
1119     case EPS_CBTCOM_XIA:\r
1120         stCom[0] = 'x'; stCom[1] = 'i';\r
1121         break;\r
1122     case EPS_CBTCOM_XIA2:\r
1123         stCom[0] = 'x'; stCom[1] = 'i'; stCom[4] = 0x03;\r
1124         break;\r
1125     case EPS_CBTCOM_XIA3:\r
1126         stCom[0] = 'x'; stCom[1] = 'i'; stCom[4] = 0x04;\r
1127         break;\r
1128     case EPS_CBTCOM_XIB:\r
1129         stCom[0] = 'x'; stCom[1] = 'i';stCom[4] = 0x80;\r
1130         break;\r
1131     case EPS_CBTCOM_CH:\r
1132         stCom[0] = 'c'; stCom[1] = 'h';\r
1133         break;\r
1134     case EPS_CBTCOM_NC:\r
1135         stCom[0] = 'n'; stCom[1] = 'c'; stCom[4] = 0x00;\r
1136         break;\r
1137     case EPS_CBTCOM_EI:\r
1138         stCom[0] = 'e'; stCom[1] = 'i'; stCom[4] = 0x00;\r
1139         break;\r
1140     case EPS_CBTCOM_PE:\r
1141         stCom[0] = 'p'; stCom[1] = 'e';\r
1142         break;\r
1143     case EPS_CBTCOM_PJ:\r
1144         stCom[0] = 'p'; stCom[1] = 'j';\r
1145         break;\r
1146     }\r
1147     \r
1148 /*** Send Command                                                                       */\r
1149     Retry = 5;\r
1150     do{\r
1151         Com   = stCom;\r
1152         cSize = 5;\r
1153         \r
1154         EPS_DBGPRINT(("EPS SER : Sending CHANNEL_COMMAND %c%c\r\n", Com[0], Com[1]));\r
1155                 if ((Ret = cbtCommWriteData(usbPrintJob->fd, EPS_CBTCHANNEL_CTRL, Com, cSize, &ComSize)) != EPCBT_ERR_NONE){\r
1156             if (Ret != EPSCBT_ERR_FNCDISABLE){\r
1157                 EPS_RETURN( EPS_ERR_COMM_ERROR );\r
1158             }\r
1159             Retry--;\r
1160             if (!Retry) {\r
1161                 EPS_RETURN( EPS_ERR_COMM_ERROR );\r
1162             }        \r
1163             serDelayThread(2*_SECOND_, &epsCmnFnc);        /* retry command after 2 seconds */\r
1164         }\r
1165     }while (Ret == EPSCBT_ERR_FNCDISABLE);\r
1166 \r
1167 /*** Read Reply                                                                         */\r
1168     Retry = 5;\r
1169     do{\r
1170         if ((Ret = cbtCommReadData(usbPrintJob->fd, EPS_CBTCHANNEL_CTRL, (EPS_UINT8 *)Reply, 32, &Size)) != EPCBT_ERR_NONE){\r
1171             if (Ret != EPSCBT_ERR_FNCDISABLE){\r
1172                 EPS_DBGPRINT(("EPS SER : CBT Command Write Reply Failed [%d]\r\n",Ret));\r
1173                 EPS_RETURN( EPS_ERR_COMM_ERROR );\r
1174             }    \r
1175         }else if (Size != 0){\r
1176             break;\r
1177         }\r
1178 \r
1179         Retry--;\r
1180         if (!Retry){\r
1181             EPS_DBGPRINT(("EPS SER : CBT Command Write Reply Retry Failed \r\n"));\r
1182             EPS_RETURN( EPS_ERR_COMM_ERROR );\r
1183         }\r
1184         serDelayThread(2*_SECOND_, &epsCmnFnc);        /* retry command after 2 seconds*/\r
1185     }while(Retry > 0);\r
1186 \r
1187 /*** Check Reply                                                                        */\r
1188     EPS_DBGPRINT(("EPS SER : Mech Command reply -> %s\r\n", Reply));\r
1189     if (strstr(Reply,"OK") == NULL){\r
1190         EPS_RETURN( EPS_ERR_COMM_ERROR );\r
1191     }\r
1192     \r
1193 /*** Return to Caller                                                                   */\r
1194     EPS_RETURN( EPS_ERR_NONE );\r
1195 }\r
1196 \r
1197 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
1198 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
1199 /*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/\r
1200 /*--------------------               Local Functions               ---------------------*/\r
1201 /*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/\r
1202 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
1203 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
1204 \r
1205 /*******************************************|********************************************/\r
1206 /*                                                                                      */\r
1207 /* Function name:   GetBinaryStatus()                                                   */\r
1208 /*                                                                                      */\r
1209 /* Arguments                                                                            */\r
1210 /* ---------                                                                            */\r
1211 /* Name:        Type:               Description:                                        */\r
1212 /* fd                   EPS_FILEDSC                 I: file discripter                                  */\r
1213 /* pstInfo      EPS_STATUS_INFO*    O: Printer Status information                       */\r
1214 /*                                                                                      */\r
1215 /* Return value:                                                                        */\r
1216 /*      EPS_ERR_NONE                    - Success                                       */\r
1217 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
1218 /*                                                                                      */\r
1219 /* Description:                                                                         */\r
1220 /*      Get the printer status and analyze the status string.                           */\r
1221 /*                                                                                      */\r
1222 /*******************************************|********************************************/\r
1223 static EPS_ERR_CODE    GetBinaryStatus (\r
1224 \r
1225                 EPS_FILEDSC                     fd,\r
1226         EPS_STATUS_INFO*    pstInfo\r
1227 \r
1228 ){\r
1229     EPS_INT8    Status[_STATUS_REPLY_BUF];\r
1230         EPS_INT32       Size = _STATUS_REPLY_BUF;\r
1231 \r
1232 EPS_LOG_FUNCIN;\r
1233 \r
1234         memset(Status, 0x00, _STATUS_REPLY_BUF);\r
1235 \r
1236     if (InfoCommand(fd, EPS_CBTCOM_ST, (EPS_UINT8*)Status, &Size) != EPS_ERR_NONE){\r
1237         EPS_DBGPRINT(("EPS SER: Get Stat -> CBT Com Failed\r\n"));\r
1238         EPS_RETURN( EPS_ERR_COMM_ERROR );\r
1239     }\r
1240 \r
1241     EPS_RETURN( serAnalyzeStatus(Status, pstInfo) );\r
1242 }\r
1243 \r
1244 \r
1245 /*******************************************|********************************************/\r
1246 /*                                                                                      */\r
1247 /* Function name:   ProbeESCPR()                                                        */\r
1248 /*                                                                                      */\r
1249 /* Arguments                                                                            */\r
1250 /* ---------                                                                            */\r
1251 /* Name:        Type:               Description:                                        */\r
1252 /* dev                  EPS_USB_DEVICE*     I: Pointer to a usb device infomatio                */\r
1253 /* manufacturer EPS_INT8*           O: Pointer to a 64-byte buffer for the manufacturer */\r
1254 /*                                     name.                                            */\r
1255 /* modelName    EPS_INT8*           O: Pointer to a 64-byte buffer for the printer      */\r
1256 /*                                     model name.                                      */\r
1257 /*                                                                                      */\r
1258 /* Return value:                                                                        */\r
1259 /*      EPS_ERR_NONE                    - Success                                       */\r
1260 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
1261 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
1262 /*      EPS_ERR_NOT_OPEN_IO             - Cannot Open I/O Portal                        */\r
1263 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
1264 /*      EPS_ERR_PRINTER_NOT_FOUND       - Connected printer is not supported            */\r
1265 /*                                                                                      */\r
1266 /* Description:                                                                         */\r
1267 /*      Opens the portal, gets the printer's PM reply, parses it, and stores the data   */\r
1268 /*      in the capabilities structure.                                                  */\r
1269 /*                                                                                      */\r
1270 /*******************************************|********************************************/\r
1271 static EPS_ERR_CODE     ProbeESCPR (\r
1272 \r
1273                 const EPS_USB_DEVICE*   dev,\r
1274         EPS_INT8*                               manufacturer,\r
1275         EPS_INT8*                               modelName,\r
1276                 EPS_INT32*              cmdLevel\r
1277 \r
1278 ){\r
1279 /*** Declare Variable Local to Routine                                                  */\r
1280     EPS_ERR_CODE    retStatus;\r
1281         EPS_FILEDSC             fd;\r
1282     EPS_INT8*       tmpDeviceIdBuf;\r
1283         EPS_INT32               bufSize;\r
1284     EPS_BOOL        found_dev;\r
1285     \r
1286 EPS_LOG_FUNCIN;\r
1287 \r
1288 /*** Initialize Local Variables                                                         */\r
1289     retStatus = EPS_ERR_NONE;\r
1290     found_dev = FALSE;\r
1291 \r
1292         EPS_DBGPRINT(("PROT=%d / PID=%04X / VID=%04X\n", dev->port, dev->pid, dev->vid))\r
1293 \r
1294     /* Allocate temp buffer */\r
1295     tmpDeviceIdBuf = (EPS_INT8*)EPS_ALLOC(EPS_DI_MAXSIZE);\r
1296     if (tmpDeviceIdBuf == NULL) {\r
1297         EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION );\r
1298     }\r
1299     memset(tmpDeviceIdBuf, 0, EPS_DI_MAXSIZE);\r
1300         bufSize = EPS_DI_MAXSIZE;\r
1301 \r
1302         /*** Get device ID                                                                  */\r
1303         retStatus = cbtCommOpen( dev, &fd );\r
1304     if(EPS_ERR_NONE == retStatus ){\r
1305                 retStatus = cbtCommChannelOpen(fd, EPS_CBTCHANNEL_CTRL, TRUE);\r
1306                 if (retStatus == EPS_ERR_NONE) {\r
1307                         retStatus = InfoCommand(fd, EPS_CBTCOM_DI, (EPS_UINT8*)tmpDeviceIdBuf, &bufSize);\r
1308                 } else{\r
1309                         retStatus = (EPS_ERR_CODE)EPS_ERR_NOT_OPEN_IO;\r
1310                 }\r
1311                 cbtCommChannelClose(fd, EPS_CBTCHANNEL_CTRL);\r
1312         } else{\r
1313                 retStatus = (EPS_ERR_CODE)EPS_ERR_NOT_OPEN_IO;\r
1314         }\r
1315         cbtCommClose(fd);\r
1316 \r
1317         if (EPS_ERR_NONE == retStatus ) {\r
1318                 found_dev = serParseDeviceID(tmpDeviceIdBuf, manufacturer, modelName, cmdLevel, NULL);\r
1319                 if(found_dev == FALSE) {\r
1320                         retStatus = EPS_ERR_PRINTER_NOT_FOUND;\r
1321                 }\r
1322         }\r
1323 \r
1324     EPS_SAFE_RELEASE(tmpDeviceIdBuf);\r
1325 \r
1326     EPS_RETURN( retStatus );\r
1327 }\r
1328 \r
1329 \r
1330 /*******************************************|********************************************/\r
1331 /*                                                                                      */\r
1332 /* Function name:   CreatePrinterInfo()                                                 */\r
1333 /*                                                                                      */\r
1334 /* Arguments                                                                            */\r
1335 /* ---------                                                                            */\r
1336 /* Name:        Type:               Description:                                        */\r
1337 /* dev                  EPS_USB_DEVICE*     I: Pointer to a usb device infomatio                */\r
1338 /* manufacturer EPS_INT8*           I: Pointer to a 64-byte buffer for the manufacturer */\r
1339 /*                                     name.                                            */\r
1340 /* modelName    EPS_INT8*           I: Pointer to a 64-byte buffer for the printer      */\r
1341 /*                                     model name.                                      */\r
1342 /* printer              EPS_PRINTER_INN**   O: pointer for found printer structure              */\r
1343 /*                                                                                      */\r
1344 /* Return value:                                                                        */\r
1345 /*      EPS_ERR_NONE                    - Success                                       */\r
1346 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
1347 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
1348 /*                                                                                      */\r
1349 /* Description:                                                                         */\r
1350 /*      Create Printer info structure and setup data.                                   */\r
1351 /*                                                                                      */\r
1352 /*******************************************|********************************************/\r
1353 static EPS_ERR_CODE     CreatePrinterInfo (\r
1354 \r
1355                 const EPS_USB_DEVICE*   dev,\r
1356         const EPS_INT8*                 manufacturer,\r
1357         const EPS_INT8*                 modelName,\r
1358                 EPS_INT32               cmdLevel,\r
1359                 EPS_PRINTER_INN**               printer\r
1360 \r
1361 ){\r
1362 /*** Declare Variable Local to Routine                                                  */\r
1363     EPS_ERR_CODE    retStatus;\r
1364     EPS_INT8            usbIDString[EPS_NAME_BUFFSIZE];\r
1365         EPS_USB_PRINTER_INFO*   pUsbPrinter = NULL;\r
1366 \r
1367 EPS_LOG_FUNCIN;\r
1368    \r
1369 /*** Initialize Local Variables                                                         */\r
1370     retStatus = EPS_ERR_NONE;\r
1371     \r
1372 /*** Create printer info structure                                                      */\r
1373         *printer = (EPS_PRINTER_INN*)EPS_ALLOC( sizeof(EPS_PRINTER_INN) );\r
1374         if(NULL == *printer){\r
1375                 retStatus = EPS_ERR_MEMORY_ALLOCATION;\r
1376                 goto CreatePrinterInfo_ERROR;\r
1377         }\r
1378         memset( *printer, 0, sizeof(EPS_PRINTER_INN) );\r
1379 \r
1380         pUsbPrinter = (EPS_USB_PRINTER_INFO*)EPS_ALLOC( sizeof(EPS_USB_PRINTER_INFO) );\r
1381         if(NULL == pUsbPrinter){\r
1382                 retStatus = EPS_ERR_MEMORY_ALLOCATION;\r
1383                 goto CreatePrinterInfo_ERROR;\r
1384         }\r
1385         memcpy(&pUsbPrinter->dev, dev, sizeof(pUsbPrinter->dev));\r
1386         pUsbPrinter->bCheckDataChannel = FALSE;\r
1387         (*printer)->protocolInfo = pUsbPrinter;\r
1388 \r
1389     strcpy( (*printer)->location, EPS_USB_NAME );\r
1390         strcpy( (*printer)->manufacturerName, manufacturer );\r
1391         strcpy( (*printer)->modelName, modelName );\r
1392         (*printer)->protocol = EPS_PROTOCOL_USB;\r
1393         (*printer)->protocol |= EPS_PRT_DIRECTION(printJob.commMode);\r
1394         (*printer)->language = EPS_LANG_ESCPR; /* ESC/P-R only via USB */\r
1395         switch(cmdLevel){\r
1396         case 0: /* Support all. For Uin communication  */\r
1397         case 2:\r
1398                 (*printer)->supportFunc |= EPS_SPF_JPGPRINT; /* Jpeg print */\r
1399         case 1:\r
1400                 (*printer)->supportFunc |= EPS_SPF_RGBPRINT; /* RGB print */\r
1401         }\r
1402 \r
1403         sprintf(usbIDString, EPS_USB_IDPRM_STR, dev->vid, dev->pid, modelName);\r
1404         prtSetIdStr(*printer, usbIDString);\r
1405 \r
1406 CreatePrinterInfo_ERROR:\r
1407         if(EPS_ERR_NONE != retStatus){\r
1408                 EPS_SAFE_RELEASE( pUsbPrinter );\r
1409                 EPS_SAFE_RELEASE( *printer );\r
1410         }\r
1411 \r
1412     EPS_RETURN( retStatus );\r
1413 }\r
1414 \r
1415 \r
1416 /*******************************************|********************************************/\r
1417 /*                                                                                      */\r
1418 /* Function name:   PortResolution()                                                    */\r
1419 /*                                                                                      */\r
1420 /* Arguments                                                                            */\r
1421 /* ---------                                                                            */\r
1422 /* Name:        Type:               Description:                                        */\r
1423 /* printer              EPS_PRINTER_INN*    I: pointer for found printer structure              */\r
1424 /*                                                                                      */\r
1425 /* Return value:                                                                        */\r
1426 /*      EPS_ERR_NONE                    - Success                                       */\r
1427 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
1428 /*      EPS_ERR_NOT_OPEN_IO             - Cannot Open I/O Portal                        */\r
1429 /*      EPS_ERR_PRINTER_NOT_FOUND           - Printer not found (or error occur)                */\r
1430 /*                                                                                      */\r
1431 /* Description:                                                                         */\r
1432 /*      Resolve present port number.                                                    */\r
1433 /*                                                                                      */\r
1434 /*******************************************|********************************************/\r
1435 static EPS_ERR_CODE   PortResolution(\r
1436         \r
1437                 const EPS_PRINTER_INN*          printer,\r
1438                 EPS_FILEDSC*                            pFd\r
1439 \r
1440 ){\r
1441 \r
1442 /*** Declare Variable Local to Routine                                                  */\r
1443     EPS_ERR_CODE        ret = EPS_ERR_NONE;                      /* Return status of internal calls */\r
1444     EPS_BOOL            bNeedResolve = TRUE;\r
1445         EPS_USB_DEVICE  dev;\r
1446         EPS_FILEDSC             fdInt = EPS_INVALID_FILEDSC;\r
1447     EPS_INT8*       tmpDeviceIdBuf;\r
1448         EPS_INT32               bufSize;\r
1449         EPS_INT8                modelName[EPS_NAME_BUFFSIZE];       /* Printer model name       */\r
1450         EPS_INT8                manufacturer[EPS_NAME_BUFFSIZE];    /* Manufacturer name        */\r
1451 \r
1452 EPS_LOG_FUNCIN;\r
1453 \r
1454         *pFd = EPS_INVALID_FILEDSC;\r
1455 \r
1456     if( !EPS_IS_BI_PROTOCOL(printer->protocol) ){\r
1457                 EPS_RETURN( EPS_ERR_NEED_BIDIRECT );\r
1458         }\r
1459 \r
1460         /* Allocate temp buffer */\r
1461     tmpDeviceIdBuf = (EPS_INT8*)EPS_ALLOC(EPS_DI_MAXSIZE);\r
1462     if (tmpDeviceIdBuf == NULL) {\r
1463         EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION );\r
1464     }\r
1465     memset(tmpDeviceIdBuf, 0, EPS_DI_MAXSIZE);\r
1466         bufSize = EPS_DI_MAXSIZE;\r
1467 \r
1468         memset(&dev, 0, sizeof(dev));\r
1469 \r
1470         /*** Get device ID                                                                  */\r
1471         ret = cbtCommOpen( (EPS_USB_DEVICE*)printer->protocolInfo, &fdInt );\r
1472         if( EPS_ERR_NONE == ret ){\r
1473                 ret = cbtCommChannelOpen(fdInt, EPS_CBTCHANNEL_CTRL, TRUE);\r
1474                 if( EPS_ERR_NONE == ret ){\r
1475                         ret = InfoCommand(fdInt, EPS_CBTCOM_DI, (EPS_UINT8*)tmpDeviceIdBuf, &bufSize);\r
1476                         cbtCommChannelClose(fdInt, EPS_CBTCHANNEL_CTRL);\r
1477                         if( EPS_ERR_NONE == ret ){\r
1478                                 /*** Get Printer name                                                   */\r
1479                                 memset(manufacturer, 0, sizeof(manufacturer));\r
1480                                 memset(modelName, 0, sizeof(modelName));\r
1481                                 if( serParseDeviceID(tmpDeviceIdBuf, manufacturer, modelName, NULL, NULL) ){\r
1482                                         /*** Printer names compare.                                         */\r
1483                                         if( 0 == strcmp(modelName, printer->modelName) ){\r
1484                                                 bNeedResolve = FALSE;\r
1485                                         }\r
1486                                 }\r
1487                         }\r
1488                 }\r
1489         }\r
1490         \r
1491         if(bNeedResolve){\r
1492                 if(EPS_INVALID_FILEDSC != fdInt){\r
1493                         cbtCommClose(fdInt);\r
1494                         fdInt = EPS_INVALID_FILEDSC;\r
1495                 }\r
1496 \r
1497                 /* Probe other port */\r
1498                 ret = ProbePrinterByName(printer->modelName, FALSE, 0, &dev, manufacturer, modelName, NULL);\r
1499                 if(EPS_ERR_NONE == ret){\r
1500                         /* Reset printer port */\r
1501                         memcpy(&((EPS_USB_PRINTER_INFO*)printer->protocolInfo)->dev, &dev,\r
1502                                 sizeof(((EPS_USB_PRINTER_INFO*)printer->protocolInfo)->dev));\r
1503 \r
1504                         ret = cbtCommOpen( (EPS_USB_DEVICE*)printer->protocolInfo, &fdInt );\r
1505                 }\r
1506         }\r
1507 \r
1508     EPS_SAFE_RELEASE(tmpDeviceIdBuf);\r
1509 \r
1510         if( EPS_ERR_NONE == ret ){\r
1511                 *pFd = fdInt;\r
1512         } else{\r
1513                 if(EPS_INVALID_FILEDSC != fdInt){\r
1514                         cbtCommClose(fdInt);\r
1515                 }\r
1516         } \r
1517 \r
1518         EPS_RETURN( ret );\r
1519 }\r
1520 \r
1521 \r
1522 /*******************************************|********************************************/\r
1523 /*                                                                                      */\r
1524 /* Function name:   ProbePrinterByName()                                                */\r
1525 /*                                                                                      */\r
1526 /* Arguments                                                                            */\r
1527 /* ---------                                                                            */\r
1528 /* Name:        Type:               Description:                                        */\r
1529 /* modelNameTgt EPS_INT8*           I: target printer modelname                         */\r
1530 /* enableBreak  EPS_BOOL            I: enable break                                     */\r
1531 /* timeout      EPS_UINT32          I: find timeout                                     */\r
1532 /* dev                  EPS_USB_DEVICE*     O: Pointer to a usb device infomatio                */\r
1533 /* manufacturer EPS_INT8*           O: Pointer to a 64-byte buffer for the manufacturer */\r
1534 /*                                     name.                                            */\r
1535 /* modelName    EPS_INT8*           O: Pointer to a 64-byte buffer for the printer      */\r
1536 /*                                     model name.                                      */\r
1537 /*                                                                                      */\r
1538 /* Return value:                                                                        */\r
1539 /*      EPS_ERR_NONE                    - Success (printer found)                       */\r
1540 /*      EPS_ERR_PRINTER_NOT_FOUND       - printer not found                             */\r
1541 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
1542 /*      EPS_ERR_NOT_OPEN_IO             - Cannot Open I/O Portal                        */\r
1543 /*                                                                                      */\r
1544 /* Description:                                                                         */\r
1545 /*     looks for specified printer.                                                     */\r
1546 /*                                                                                      */\r
1547 /*******************************************|********************************************/\r
1548 static EPS_ERR_CODE   ProbePrinterByName (\r
1549 \r
1550                 const EPS_INT8* modelNameTgt,\r
1551                 EPS_BOOL                enableBreak,\r
1552         EPS_UINT32      timeout,\r
1553                 EPS_USB_DEVICE* dev,\r
1554                 EPS_INT8*               manufacturer,\r
1555                 EPS_INT8*               modelName,\r
1556                 EPS_INT32*      cmdLevel\r
1557 \r
1558 ){\r
1559 /*** Declare Variable Local to Routine                                                  */\r
1560     EPS_ERR_CODE        ret = EPS_ERR_NONE;                      /* Return status of internal calls     */\r
1561     EPS_BOOL            found = FALSE;\r
1562         EPS_FILEDSC             fd = EPS_INVALID_FILEDSC;\r
1563         EPS_UINT32              tmStart, tmNow, tmSpan;\r
1564     \r
1565 EPS_LOG_FUNCIN;\r
1566 \r
1567         *modelName = '\0';\r
1568         *manufacturer = '\0';\r
1569 \r
1570         fd = epsUsbFnc.findFirst( dev );\r
1571         if(EPS_INVALID_FILEDSC != fd){\r
1572                 if(epsCmnFnc.getTime){\r
1573                         tmStart = epsCmnFnc.getTime();\r
1574                 } else{\r
1575                         timeout = tmStart = tmNow = tmSpan = 0;\r
1576                 }\r
1577 \r
1578                 do{\r
1579                         /*** Validate this is an Epson ESC/PR Printer                               */\r
1580                         ret = ProbeESCPR(dev, manufacturer, modelName, cmdLevel);\r
1581 \r
1582                         if(EPS_ERR_NONE == ret){\r
1583                                 if( 0 == strcmp(modelNameTgt, modelName) ){\r
1584                                         /* Found target printer */\r
1585                                         found = TRUE;\r
1586                                         break;\r
1587                                 }\r
1588                         } else if(EPS_ERR_PRINTER_NOT_FOUND != ret){\r
1589                                 break;\r
1590                         }\r
1591 \r
1592                         if(timeout > 0){\r
1593                                 tmNow = epsCmnFnc.getTime();\r
1594                                 tmSpan = (EPS_UINT32)(tmNow - tmStart);\r
1595                                 EPS_DBGPRINT( ("TM %u - %u <> %u\n", tmNow, tmStart, tmSpan) )\r
1596                                 if( tmSpan >= timeout ){\r
1597                                         break;\r
1598                                 }\r
1599                         }\r
1600                         if( enableBreak ){\r
1601                                 if( 0 == epsCmnFnc.lockSync() ){\r
1602                                         if( g_FindBreak ){\r
1603                                                 epsCmnFnc.unlockSync();\r
1604                                                 break;\r
1605                                         }\r
1606                                         epsCmnFnc.unlockSync();\r
1607                                 }\r
1608                         }\r
1609                 }while( epsUsbFnc.findNext( fd, dev ) );\r
1610 \r
1611                 epsUsbFnc.findClose(fd);\r
1612         }\r
1613 \r
1614         if(EPS_ERR_NONE == ret){\r
1615                 ret = (found?EPS_ERR_NONE:EPS_ERR_PRINTER_NOT_FOUND);\r
1616         }\r
1617 \r
1618         EPS_RETURN( ret );\r
1619 }\r
1620 \r
1621 \r
1622 /*******************************************|********************************************/\r
1623 /*                                                                                      */\r
1624 /* Function name:   InfoCommand()                                                       */\r
1625 /*                                                                                      */\r
1626 /* Arguments                                                                            */\r
1627 /* ---------                                                                            */\r
1628 /* Name:        Type:               Description:                                        */\r
1629 /* Command      EPS_INT32           I: Command Code                                     */\r
1630 /* pResult      EPS_UINT8*          O: Result of Info command                           */\r
1631 /* Size         EPS_INT32*          I/O: size of buffer                                 */\r
1632 /*                                                                                      */\r
1633 /* Return value:                                                                        */\r
1634 /*      EPS_ERR_NONE                    - Info command executed successfully            */\r
1635 /*      EPS_ERR_COMM_ERROR              - Info command execution error                  */\r
1636 /*                                                                                      */\r
1637 /* Description:                                                                         */\r
1638 /*      Sends Information commands to the printer.                                      */\r
1639 /*                                                                                      */\r
1640 /*******************************************|********************************************/\r
1641 static EPS_ERR_CODE   InfoCommand (\r
1642 \r
1643                 EPS_FILEDSC     fd,\r
1644         EPS_INT32   Command,\r
1645         EPS_UINT8*  pResult,\r
1646         EPS_INT32*  Size\r
1647         \r
1648 ){\r
1649     static EPS_UINT8 stCom[5] = {'x', 'x', 0x01,0x00,0x01};\r
1650     EPS_INT32        ComSize  = 0;\r
1651     EPS_INT32        Retry;\r
1652     EPS_INT32        Ret;\r
1653     EPS_INT32        lSize;\r
1654 \r
1655         EPS_LOG_FUNCIN;\r
1656 \r
1657         switch(Command){\r
1658     case EPS_CBTCOM_DI:\r
1659         stCom[0] = 'd'; stCom[1] = 'i'; stCom[4] = 0x01;\r
1660         break;\r
1661     case EPS_CBTCOM_ST:\r
1662         stCom[0] = 's'; stCom[1] = 't'; stCom[4] = 0x01;\r
1663         break;\r
1664     case EPS_CBTCOM_CX:\r
1665         stCom[0] = 'c'; stCom[1] = 'x'; stCom[4] = 0x01;\r
1666         break;\r
1667     case EPS_CBTCOM_CSA:\r
1668         stCom[0] = 'c'; stCom[1] = 's'; stCom[4] = 0x00;\r
1669         break;\r
1670     case EPS_CBTCOM_CSB:\r
1671         stCom[0] = 'c'; stCom[1] = 's'; stCom[4] = 0x01;\r
1672         break;\r
1673     case EPS_CBTCOM_PM:\r
1674         stCom[0] = 'p'; stCom[1] = 'm'; stCom[4] = 0x01;\r
1675         break;\r
1676     case EPS_CBTCOM_PM2:\r
1677         stCom[0] = 'p'; stCom[1] = 'm'; stCom[4] = 0x02;\r
1678         break;\r
1679     }\r
1680 \r
1681     Retry = 5;\r
1682     do{\r
1683         if ((Ret = cbtCommWriteData(fd, EPS_CBTCHANNEL_CTRL, stCom, 5, &ComSize)) != EPCBT_ERR_NONE){\r
1684             EPS_DBGPRINT(("EPS SER : CBT Command Write Failed [%d]\r\n",Ret));\r
1685             if (Ret != EPSCBT_ERR_FNCDISABLE && Ret != EPSCBT_ERR_WRITEERROR){\r
1686                 EPS_RETURN( EPS_ERR_COMM_ERROR );\r
1687             }\r
1688 \r
1689             Retry--;\r
1690             if (!Retry) {\r
1691                 EPS_DBGPRINT(("EPS SER : CBT Command Write Retry Failed \r\n"));\r
1692                 EPS_RETURN( EPS_ERR_COMM_ERROR );\r
1693             }        \r
1694             serDelayThread(2*_SECOND_, &epsCmnFnc);       /* retry command after 2 seconds*/\r
1695         }\r
1696     }while (Ret == EPSCBT_ERR_FNCDISABLE);\r
1697 \r
1698     Retry = 5;\r
1699     lSize = *Size;\r
1700     do{\r
1701         if ((Ret = cbtCommReadData(fd, EPS_CBTCHANNEL_CTRL, (EPS_UINT8 *)pResult, lSize, Size)) != EPCBT_ERR_NONE){\r
1702             EPS_DBGPRINT(("EPS SER : CBT Command Read Reply Failed [%d]\r\n",Ret));\r
1703             if (Ret != EPSCBT_ERR_FNCDISABLE && Ret != EPSCBT_ERR_READERROR){\r
1704                 EPS_RETURN( EPS_ERR_COMM_ERROR );\r
1705             }    \r
1706         }else if (*Size != 0){\r
1707             break;\r
1708         }\r
1709 \r
1710         Retry--;\r
1711         if (!Retry){\r
1712             EPS_DBGPRINT(("EPS SER : CBT Command Read Reply Retry Failed \r\n"));\r
1713             EPS_RETURN( EPS_ERR_COMM_ERROR );\r
1714         }\r
1715         serDelayThread(2*_SECOND_, &epsCmnFnc);       /* retry command after 2 seconds*/\r
1716     }while(Retry > 0);\r
1717     \r
1718     pResult[*Size] = '\0';\r
1719 \r
1720     EPS_RETURN( EPS_ERR_NONE );\r
1721 }\r
1722 \r
1723 \r
1724 \r
1725 /*___________________________________  epson-usb.c  ____________________________________*/\r
1726   \r
1727 /*34567890123456789012345678901234567890123456789012345678901234567890123456789012345678*/\r
1728 /*       1         2         3         4         5         6         7         8        */\r
1729 /*******************************************|********************************************/\r
1730 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
1731 /***** End of File *** End of File *** End of File *** End of File *** End of File ******/\r
1732 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r