path: root/lib/epson-usb.c

/*___________________________________  epson-usb.c   ___________________________________*/

/*       1         2         3         4         5         6         7         8        */
/*34567890123456789012345678901234567890123456789012345678901234567890123456789012345678*/
/*******************************************|********************************************/
/*
 *   Copyright (c) 2009  Seiko Epson Corporation   All rights reserved.
 *
 *   Copyright protection claimed includes all forms and matters of copyrightable
 *   material and information now allowed by statutory or judicial law or hereinafter
 *   granted, including without limitation, material generated from the software
 *   programs which are displayed on the screen such as icons, screen display looks,
 *   etc.
 */
/*******************************************|********************************************/
/*                                                                                      */
/*                                   Epson USB Module                                   */
/*                                                                                      */
/*                                Public Function Calls                                 */
/*                              --------------------------                              */
/*		EPS_ERR_CODE usbFind            (protocol                                    );	*/
/*	    EPS_ERR_CODE usbProbePrinterByID(modelNameTgt, protocol, printer             );	*/
/*	    EPS_ERR_CODE usbStartJob		(printer                                     );	*/
/*	    EPS_ERR_CODE usbStartPage		(                                            );	*/
/*	    EPS_ERR_CODE usbEndJob          (printer                                     );	*/
/*	    EPS_ERR_CODE usbGetPMString     (printer, pString, bufSize	                 );	*/
/*      EPS_ERR_CODE usbGetStatus       (printer, status, ioStatus                   );	*/
/*      EPS_ERR_CODE usbGetJobStatus    (pstInfo							         );	*/
/*	    EPS_ERR_CODE usbWritePrintData  (Buffer, BuffLen, sentSize                   );	*/
/*	    EPS_ERR_CODE usbResetPrinter    (void                                        );	*/
/*	    EPS_ERR_CODE usbMechCommand     (Command                                     );	*/
/*                                                                                      */
/*******************************************|********************************************/

/*------------------------------------  Includes   -------------------------------------*/
/*******************************************|********************************************/
#include "epson-escpr-pvt.h"
#include "epson-escpr-err.h"
#include "epson-escpr-services.h"
#include "epson-escpr-mem.h"
#include "epson-protocol.h"
#include "epson-cbt.h"
#include "epson-usb.h"

/*--------------------------------  Local Definition   ---------------------------------*/
/*******************************************|********************************************/
#ifdef EPS_LOG_MODULE_USB
#define EPS_LOG_MODULE	EPS_LOG_MODULE_USB
#else
#define EPS_LOG_MODULE	0
#endif

/*---------------------------  Data Structure Declarations   ---------------------------*/
/*******************************************|********************************************/
typedef struct _tagEPS_USB_PRINTER_INFO_ {
	EPS_USB_DEVICE	dev;
	EPS_BOOL		bCheckDataChannel;
}EPS_USB_PRINTER_INFO;

typedef struct _tagEPS_PRINT_JOB_USB_ {
	EPS_FILEDSC	fd;							/* usb file descriptor                      */
	EPS_BOOL    resetRequest;				/* recv reset request & yet not reset       */
} EPS_PRINT_JOB_USB;


/*--------------------------  ESC/P-R USB Lib Global Variables  ------------------------*/
/*******************************************|********************************************/

	/*** Extern Function                                                                */
	/*** -------------------------------------------------------------------------------*/
extern EPS_USB_FUNC    epsUsbFnc;
extern EPS_CMN_FUNC    epsCmnFnc;

    /*** Print Job Structure                                                            */
    /*** -------------------------------------------------------------------------------*/
extern EPS_PRINT_JOB   printJob;

	/*** Find                                                                           */
	/*** -------------------------------------------------------------------------------*/
extern EPS_BOOL     g_FindBreak;							/* Find printer end flag    */

    /*** I/O Channel                                                                    */
    /*** -------------------------------------------------------------------------------*/
extern EPS_BOOL    ioOpenState;             /* Open state of I/O port (Bi-Directional)  */
extern EPS_BOOL    ioDataChState;           /* Open state of Data Channel               */
extern EPS_BOOL    ioControlChState;        /* Open state of Control Channel            */
extern EPS_BOOL    ioOpenUniDirect;         /* Open state of I/O port (Uni-Directional) */

/*--------------------------------  Local Functions   ----------------------------------*/
/*******************************************|********************************************/
static EPS_ERR_CODE ProbePrinterByName	(const EPS_INT8*, EPS_BOOL, EPS_UINT32,
										 EPS_USB_DEVICE*, EPS_INT8*, EPS_INT8*, EPS_INT32*);
static EPS_ERR_CODE ProbeESCPR			(const EPS_USB_DEVICE*, EPS_INT8*, EPS_INT8*, 
										 EPS_INT32*                                     );
static EPS_ERR_CODE CreatePrinterInfo	(const EPS_USB_DEVICE*, const EPS_INT8*, 
										 const EPS_INT8*, EPS_INT32, EPS_PRINTER_INN**  );
static EPS_ERR_CODE PortResolution		(const EPS_PRINTER_INN*, EPS_FILEDSC*           );
static EPS_ERR_CODE GetBinaryStatus		(EPS_FILEDSC, EPS_STATUS_INFO*					);
static EPS_ERR_CODE InfoCommand			(EPS_FILEDSC, EPS_INT32, EPS_UINT8*, EPS_INT32* );


/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/
/*--------------------              Public Functions               ---------------------*/
/*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

/*******************************************|********************************************/
/*                                                                                      */
/* Function name:     usbFind()	        	                                            */
/*                                                                                      */
/* Arguments                                                                            */
/* ---------                                                                            */
/* Name:        Type:               Description:                                        */
/* timeout      EPS_UINT32          I: find timeout                                     */
/* protocol	    EPS_INT32           I: communication mode                               */
/*                                                                                      */
/* Return value:                                                                        */
/*      EPS_ERR_NONE                - Success Printer found                             */
/*      EPS_ERR_PRINTER_NOT_FOUND	- Printer not found (or error occur)		        */
/*      EPS_ERR_MEMORY_ALLOCATION   - memory allocation failed                          */
/*      EPS_ERR_NOT_OPEN_IO             - Cannot Open I/O Portal                        */
/*                                                                                      */
/* Description:                                                                         */
/*      find all USB printer.                                                           */
/*                                                                                      */
/*******************************************|********************************************/
EPS_ERR_CODE usbFind (

        EPS_UINT32*         timeout,
		EPS_INT32           protocol
		
){
/*** Declare Variable Local to Routine                                                  */
    EPS_ERR_CODE		ret = EPS_ERR_NONE;			 /* Return status of internal calls */
	EPS_FILEDSC			fd = EPS_INVALID_FILEDSC;
	EPS_PRINTER_INN*	printer = NULL;
	EPS_USB_DEVICE		dev;
	EPS_INT8			manufacturer[EPS_NAME_BUFFSIZE];    /* Manufacturer name        */
	EPS_INT8			modelName[EPS_NAME_BUFFSIZE];       /* Printer model name       */
	EPS_UINT32			tmStart, tmNow, tmSpan;
    EPS_INT32           cmdLevel = 0;

	EPS_LOG_FUNCIN;

	memset(&dev, 0, sizeof(dev));
	memset(manufacturer, 0, EPS_NAME_BUFFSIZE);
	memset(modelName, 0, EPS_NAME_BUFFSIZE);

/***------------------------------------------------------------------------------------*/
/*** Bi-Directional Communication Mode                                                  */
/***------------------------------------------------------------------------------------*/
    if ( EPS_IS_BI_PROTOCOL(protocol) ) {
		fd = epsUsbFnc.findFirst( &dev );
		if(EPS_INVALID_FILEDSC != fd){
			if(epsCmnFnc.getTime){
				tmStart = epsCmnFnc.getTime();
			} else{
				*timeout = tmStart = tmNow = tmSpan = 0;
			}

			do{
			/*** Validate this is an Epson ESC/PR Printer                                   */
				ret = ProbeESCPR(&dev, manufacturer, modelName, &cmdLevel);

				if(EPS_ERR_NONE == ret){
					ret = CreatePrinterInfo(&dev, manufacturer, modelName, cmdLevel, &printer);
					if( EPS_ERR_NONE == ret ){
						ret = prtRegPrinter( printer, TRUE );
					} 

					if( EPS_ERR_NONE != ret ){
						break;
					}

					if(*timeout > 0){
						tmNow = epsCmnFnc.getTime();
						tmSpan = (EPS_UINT32)(tmNow - tmStart);
						EPS_DBGPRINT( ("TM %u - %u <> %u\n", tmNow, tmStart, tmSpan) )
						if( tmSpan >= *timeout ){
							break;
						}
					}
					if( epsCmnFnc.lockSync && epsCmnFnc.unlockSync ){
						if( 0 == epsCmnFnc.lockSync() ){
							if( g_FindBreak ){
								epsCmnFnc.unlockSync();
								break;
							}
							epsCmnFnc.unlockSync();
						}
					}
				}
			}while( epsUsbFnc.findNext( fd, &dev ) );

			epsUsbFnc.findClose(fd);

			if(*timeout > 0){
				/* calculate elapsed time */
				tmNow = epsCmnFnc.getTime();
				tmSpan = (EPS_UINT32)(tmNow - tmStart);
				if(tmSpan < *timeout){
					*timeout -= tmSpan;
				} else{
					*timeout = 1;
				}
			}

		} else{
			ret = EPS_ERR_PRINTER_NOT_FOUND;
		}

/***------------------------------------------------------------------------------------*/
/*** Uni-Directional Communication Mode                                                 */
/***------------------------------------------------------------------------------------*/
	} else{
    /*** Open Portal check                                                              */
        fd = epsUsbFnc.openPortal(NULL);
		if(EPS_INVALID_FILEDSC != fd){
			epsUsbFnc.closePortal(fd);

			/*** Create printer info structure                                          */
			ret = CreatePrinterInfo(&dev, "", "", 0, &printer);
			if( EPS_ERR_NONE == ret ){
				ret = prtRegPrinter( printer, TRUE );
			} 
		} else{
            ret = EPS_ERR_PRINTER_NOT_FOUND;
        }
	}

	EPS_RETURN( ret );
}


/*******************************************|********************************************/
/*                                                                                      */
/* Function name:   usbProbePrinterByID()                                               */
/*                                                                                      */
/* Arguments                                                                            */
/* ---------                                                                            */
/* Name:        Type:               Description:                                        */
/* printerUUID EPS_INT8*            I: ID String of probe target                        */
/* timeout      EPS_UINT32          I: find timeout                                     */
/* printer		EPS_PRINTER_INN**   O: pointer for found printer structure              */
/*                                                                                      */
/* Return value:                                                                        */
/*      EPS_ERR_NONE                    - Success (printer found)                       */
/*      EPS_ERR_PRINTER_NOT_FOUND       - printer not found                             */
/*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */
/*      EPS_ERR_NOT_OPEN_IO             - Cannot Open I/O Portal                        */
/*                                                                                      */
/* Description:                                                                         */
/*     looks for specified printer.                                                     */
/*                                                                                      */
/*******************************************|********************************************/
EPS_ERR_CODE   usbProbePrinterByID (

		EPS_INT8*			printerUUID,
        EPS_UINT32			timeout,
		EPS_PRINTER_INN**   printer

){
/*** Declare Variable Local to Routine                                                  */
    EPS_ERR_CODE	ret = EPS_ERR_NONE;				 /* Return status of internal calls */
	EPS_FILEDSC		fd = EPS_INVALID_FILEDSC;
	EPS_USB_DEVICE	dev;
	EPS_INT8		manufacturer[EPS_NAME_BUFFSIZE];    /* Manufacturer name            */
	EPS_INT8		modelName[EPS_NAME_BUFFSIZE];       /* Printer model name           */
    EPS_INT8*       pPos = NULL;
    EPS_INT32       nSegCnt = 0;
    EPS_UINT32      nTmp = 0;
	EPS_INT8		modelNameTgt[EPS_NAME_BUFFSIZE];    /* target printer model name    */
	EPS_BOOL		enableBreak = FALSE;
	EPS_INT32       cmdLevel = 0;

	EPS_LOG_FUNCIN;

/*** Parse definition String                                                        */
	pPos = strtok(printerUUID, EPS_USBID_SEP);
    for(nSegCnt = 0; pPos != NULL && nSegCnt < EPS_USBID_SEGNUM; nSegCnt++){
		switch(nSegCnt){
		case 0:			/* Get VID */
		case 1:			/* Get PID */
			sscanf(pPos, "%x", &nTmp);
			if(nTmp == 0){
				EPS_RETURN( EPS_ERR_INV_ARG_PRINTER_ID );
			}
			/* lib do not use VID, PID */
			break;

		case 2:			/* Get model name */
			strcpy(modelNameTgt, pPos);
			break;
		}

		pPos = strtok(NULL, EPS_USBID_SEP);
    }
	if(nSegCnt < EPS_USBID_SEGNUM){
		EPS_RETURN( EPS_ERR_INV_ARG_PRINTER_ID );
	}

	memset(&dev, 0, sizeof(dev));

/***------------------------------------------------------------------------------------*/
/*** Bi-Directional Communication Mode                                                  */
/***------------------------------------------------------------------------------------*/
    if ( EPS_IS_BI_PROTOCOL(printJob.commMode) ) {
		enableBreak = (epsCmnFnc.lockSync && epsCmnFnc.unlockSync );
		memset(manufacturer, 0, sizeof(manufacturer));
		memset(modelName, 0, sizeof(modelName));
		ret = ProbePrinterByName(modelNameTgt, enableBreak, timeout, 
			                     &dev, manufacturer, modelName, &cmdLevel);
		if(EPS_ERR_NONE == ret){
			/*** Create printer info structure                                          */
			ret = CreatePrinterInfo(&dev, manufacturer, modelName, cmdLevel, printer);
		}
/***------------------------------------------------------------------------------------*/
/*** Uni-Directional Communication Mode                                                 */
/***------------------------------------------------------------------------------------*/
    } else{
    /*** Open Portal check                                                              */
        fd = epsUsbFnc.openPortal(NULL);
		if(EPS_INVALID_FILEDSC != fd){
			epsUsbFnc.closePortal(fd);

			/*** Create printer info structure                                          */
			ret = CreatePrinterInfo(&dev, "", "", 0, printer);

		} else{
            ret = EPS_ERR_PRINTER_NOT_FOUND;
        }
    }

/*** Return to Caller                                                                   */
    EPS_RETURN( ret );
}


/*******************************************|********************************************/
/*                                                                                      */
/* Function name:     usbStartJob()                                                     */
/*                                                                                      */
/* Arguments                                                                            */
/* ---------                                                                            */
/* Name:            Type:                   Description:                                */
/* printer          EPS_PRINTER_INN*        I: Pointer to a PrinterInfo                 */
/*                                                                                      */
/* Return value:                                                                        */
/*      << Normal >>                                                                    */
/*      EPS_ERR_NONE                    - Success                                       */
/*      << Error >>                                                                     */
/*      (Uni/Bi-Directional)                                                            */
/*      EPS_ERR_LIB_NOT_INITIALIZED     - ESC/P-R Lib is NOT initialized                */
/*      EPS_ERR_NOT_OPEN_IO             - Failed to open I/O                            */
/*      (Bi-Directional Only)                                                           */
/*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */
/*                                                                                      */
/* Description:                                                                         */
/*      Creates a new print job.                                                        */
/*                                                                                      */
/*******************************************|********************************************/
EPS_ERR_CODE    usbStartJob (

        void

){
/*** Declare Variable Local to Routine                                                  */
	EPS_ERR_CODE		retStatus = EPS_ERR_NONE;   /* Return status of internal calls  */
	const EPS_PRINTER_INN* printer = printJob.printer;
	EPS_PRINT_JOB_USB	*usbPrintJob = NULL;

	EPS_LOG_FUNCIN;

/*** Create USB Job data                                                                */
	usbPrintJob = (EPS_PRINT_JOB_USB*)EPS_ALLOC( sizeof(EPS_PRINT_JOB_USB) );
	if( NULL == usbPrintJob ){
		EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION );
	}
	memset(usbPrintJob, 0, sizeof(EPS_PRINT_JOB_USB));
	usbPrintJob->fd = EPS_INVALID_FILEDSC;
	usbPrintJob->resetRequest = FALSE;

/***------------------------------------------------------------------------------------*/
/*** Bi-Directional Communication Mode                                                  */
/***------------------------------------------------------------------------------------*/
	if( EPS_IS_BI_PROTOCOL(printer->protocol) ){
	/*** Resolve present port number. And Open the I/O Port for communication           */
		retStatus = PortResolution(printer, &usbPrintJob->fd);
        if (retStatus != EPS_ERR_NONE) {
 			cbtCommClose(usbPrintJob->fd);
			retStatus = (EPS_ERR_CODE)EPS_ERR_NOT_OPEN_IO;
            goto epsStartJob_END;
        }

    /*** Open the command channel                                                       */
        retStatus = cbtCommChannelOpen(usbPrintJob->fd, EPS_CBTCHANNEL_CTRL, TRUE);
        if (retStatus != EPS_ERR_NONE) {
			retStatus = cbtCommClose(usbPrintJob->fd);
            retStatus = (EPS_ERR_CODE)EPS_ERR_NOT_OPEN_IO;
            goto epsStartJob_END;
        }

    /*** Open Data Channel                                                              */
        retStatus = cbtCommChannelOpen(usbPrintJob->fd, EPS_CBTCHANNEL_DATA, TRUE);
        if (retStatus != EPS_ERR_NONE) {
			retStatus = cbtCommChannelClose(usbPrintJob->fd, EPS_CBTCHANNEL_CTRL);
			retStatus = cbtCommClose(usbPrintJob->fd);
            retStatus = (EPS_ERR_CODE)EPS_ERR_PRINTER_ERR_OCCUR/*EPS_ERR_CANNOT_PRINT*/;
            goto epsStartJob_END;
        }
		((EPS_USB_PRINTER_INFO*)printer->protocolInfo)->bCheckDataChannel = FALSE;

/***------------------------------------------------------------------------------------*/
/*** Uni-Directional Communication Mode                                                 */
/***------------------------------------------------------------------------------------*/
    } else{
    /*** Open Portal                                                                    */
        if (ioOpenUniDirect == EPS_IO_OPEN) {
            retStatus = EPS_ERR_2ND_OPEN_IO;
			goto epsStartJob_END;
        } else {
            usbPrintJob->fd = epsUsbFnc.openPortal( NULL );
            if (EPS_INVALID_FILEDSC == usbPrintJob->fd) {
                retStatus = EPS_ERR_NOT_OPEN_IO;
				goto epsStartJob_END;
            }
            ioOpenUniDirect = EPS_IO_OPEN;
        }
    }

	printJob.hProtInfo = (EPS_HANDLE)usbPrintJob;

epsStartJob_END:
	if(EPS_ERR_NONE != retStatus){
		EPS_SAFE_RELEASE(usbPrintJob);
	}

/*** Return to Caller                                                                   */
    EPS_RETURN( retStatus );
}


/*******************************************|********************************************/
/*                                                                                      */
/* Function name:     usbRestartJob()                                                   */
/*                                                                                      */
/* Arguments                                                                            */
/* ---------                                                                            */
/* Name:            Type:                   Description:                                */
/* N/A                                                                                  */
/*                                                                                      */
/* Return value:                                                                        */
/*      << Normal >>                                                                    */
/*      EPS_ERR_NONE                    - Success                                       */
/*      << Error >>                                                                     */
/*      (Uni/Bi-Directional)                                                            */
/*      EPS_ERR_JOB_NOT_INITIALIZED     - JOB is NOT initialized						*/
/*      EPS_ERR_NOT_OPEN_IO             - Failed to open I/O                            */
/*      (Bi-Directional Only)                                                           */
/*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */
/*                                                                                      */
/* Description:                                                                         */
/*      The port shut by usbResetPrinter() is opened again.                             */
/*                                                                                      */
/*******************************************|********************************************/
EPS_ERR_CODE    usbRestartJob (

        void

){

/*** Declare Variable Local to Routine                                                  */
	EPS_ERR_CODE		retStatus = EPS_ERR_NONE;   /* Return status of internal calls  */
	const EPS_PRINTER_INN* printer = printJob.printer;
	EPS_PRINT_JOB_USB* usbPrintJob = (EPS_PRINT_JOB_USB*)printJob.hProtInfo;

	EPS_LOG_FUNCIN;

 	if( !usbPrintJob ){
		EPS_RETURN( EPS_ERR_JOB_NOT_INITIALIZED );
	}

/***------------------------------------------------------------------------------------*/
/*** Bi-Directional Communication Mode                                                  */
/***------------------------------------------------------------------------------------*/
	if( EPS_IS_BI_PROTOCOL(printer->protocol) ){
		if(EPS_IO_NOT_OPEN == ioDataChState){
		/*if( EPS_RESET_SENT == printJob.resetSent ){*/
		/* If pre page canceled, Re open data channel */
			retStatus = cbtCommChannelOpen(usbPrintJob->fd, EPS_CBTCHANNEL_DATA, TRUE);
			if (retStatus == EPS_ERR_NONE) {
				((EPS_USB_PRINTER_INFO*)printer->protocolInfo)->bCheckDataChannel = FALSE;
			} else{
				retStatus = (EPS_ERR_CODE)EPS_ERR_PRINTER_ERR_OCCUR/*EPS_ERR_CANNOT_PRINT*/;
			}
		}
/***------------------------------------------------------------------------------------*/
/*** Uni-Directional Communication Mode                                                 */
/***------------------------------------------------------------------------------------*/
/*   } else{ 
		no operation*/
    }

/*** Return to Caller                                                                   */
    EPS_RETURN( retStatus );
}


/*******************************************|********************************************/
/*                                                                                      */
/* Function name:   usbEndJob()                                                         */
/*                                                                                      */
/* Arguments                                                                            */
/* ---------                                                                            */
/* Name:            Type:                   Description:                                */
/* N/A                                                                                  */
/*                                                                                      */
/* Return value:                                                                        */
/*      << Normal >>                                                                    */
/*      EPS_ERR_NONE                    - Success                                       */
/*      << Error >>                                                                     */
/*      EPS_ERR_JOB_NOT_INITIALIZED     - JOB is NOT initialized                        */
/*      EPS_ERR_NOT_CLOSE_IO            - Cannot close I/O portal                       */
/*                                                                                      */
/* Description:                                                                         */
/*      Ends the current print job.                                                     */
/*                                                                                      */
/*******************************************|********************************************/
EPS_ERR_CODE    usbEndJob (

        void

){
    EPS_ERR_CODE    retStatus = EPS_ERR_NONE;       /* Return status of internal calls  */
	EPS_PRINT_JOB_USB* usbPrintJob = (EPS_PRINT_JOB_USB*)printJob.hProtInfo;

EPS_LOG_FUNCIN;

	if( !usbPrintJob ){
		EPS_RETURN( EPS_ERR_JOB_NOT_INITIALIZED );
	}

	switch(printJob.printer->protocol){
	case EPS_COMM_USB_BID:
/***------------------------------------------------------------------------------------*/
/*** Bi-Directional Communication Mode                                                  */
/***------------------------------------------------------------------------------------*/
    /*** Close communication                                                            */
		retStatus = cbtCommChannelClose(usbPrintJob->fd, EPS_CBTCHANNEL_DATA);
		retStatus = cbtCommChannelClose(usbPrintJob->fd, EPS_CBTCHANNEL_CTRL);
		retStatus = cbtCommClose(usbPrintJob->fd);
		if (retStatus != EPS_ERR_NONE) {
			retStatus = EPS_ERR_NOT_CLOSE_IO;
		}
		break;

	case EPS_COMM_USB_UNID:
/***------------------------------------------------------------------------------------*/
/*** Uni-Directional Communication Mode                                                 */
/***------------------------------------------------------------------------------------*/
		/*** Close Portal                                                               */
		if (ioOpenUniDirect == EPS_IO_OPEN) {
			retStatus = epsUsbFnc.closePortal(usbPrintJob->fd);
			if (retStatus != 0) {
				EPS_RETURN( EPS_ERR_NOT_CLOSE_IO );
			}
			ioOpenUniDirect = EPS_IO_NOT_OPEN;
		}
		break;

	default:
		retStatus = EPS_ERR_OPR_FAIL;
    }

	EPS_SAFE_RELEASE( printJob.hProtInfo );

	EPS_RETURN( retStatus );
}



/*******************************************|********************************************/
/*                                                                                      */
/* Function name:   usbWritePrintData()                                                 */
/*                                                                                      */
/* Arguments                                                                            */
/* ---------                                                                            */
/* Name:        Type:               Description:                                        */
/* Buffer       const EPS_UINT8*    I: Buffer Pointer for Write Data                    */
/* BuffLen      EPS_UINT32          I: Write Data Buffer Length (bytes)                 */
/* sentSize     EPS_UINT32*         O: Actuall Write Size                               */
/*                                                                                      */
/* Return value:                                                                        */
/*      EPCBT_ERR_NONE                  - Success                                       */
/*      EPS_ERR_JOB_NOT_INITIALIZED     - JOB is NOT initialized						*/
/*      EPS_ERR_COMM_ERROR              - Communication Error                           */
/*                                                                                      */
/* Description:                                                                         */
/*      Write the data to printer Data Channel.                                         */
/*                                                                                      */
/*******************************************|********************************************/
EPS_ERR_CODE   usbWritePrintData (

		const EPS_UINT8*    Buffer,
        EPS_UINT32          BuffLen,
        EPS_UINT32*         sentSize

){
    EPS_INT32		   retCom;
	EPS_PRINT_JOB_USB* usbPrintJob = (EPS_PRINT_JOB_USB*)printJob.hProtInfo;

EPS_LOG_FUNCIN;

	if( !usbPrintJob ){
		EPS_RETURN( EPS_ERR_JOB_NOT_INITIALIZED );
	}

	if( EPS_IS_BI_PROTOCOL(printJob.printer->protocol) ){
		retCom = cbtCommWriteData(usbPrintJob->fd, EPS_CBTCHANNEL_DATA, Buffer, (EPS_INT32)BuffLen, (EPS_INT32*)sentSize);
		if(EPCBT_ERR_NONE == retCom){
			EPS_RETURN( EPS_ERR_NONE );
		} else if(EPSCBT_ERR_FNCDISABLE == retCom){
			EPS_RETURN( EPS_COM_TINEOUT );
		}else{
			EPS_RETURN( EPS_ERR_COMM_ERROR );
		}
	} else{
		retCom = epsUsbFnc.writePortal(usbPrintJob->fd, Buffer, (EPS_INT32)BuffLen, (EPS_INT32*)sentSize);
		if(0 == retCom){
			EPS_RETURN( EPS_ERR_NONE );
		} else{
			EPS_RETURN( EPS_ERR_COMM_ERROR );
		}
	}
}


/*******************************************|********************************************/
/*                                                                                      */
/* Function name:   usbResetPrinter()                                                   */
/*                                                                                      */
/* Arguments                                                                            */
/* ---------                                                                            */
/* Name:        Type:               Description:                                        */
/* void         -                   -                                                   */
/*                                                                                      */
/* Return value:                                                                        */
/*      EPS_ERR_NONE                    - Success                                       */
/*      EPS_ERR_JOB_NOT_INITIALIZED     - JOB is NOT initialized						*/
/*      EPS_ERR_COMM_ERROR              - Failed to send command                        */
/*      EPS_ERR_CAN_NOT_RESET           - Failed to reset printer                       */
/*      EPS_ERR_NOT_CLOSE_IO            - Cannot Close I/O Portal                       */
/*                                                                                      */
/* Description:                                                                         */
/*      Send "rj" command and reset printer.                                            */
/*                                                                                      */
/*******************************************|********************************************/
EPS_ERR_CODE   usbResetPrinter (

        void

){
/*** Declare Variable Local to Routine                                                  */
#define EPS_RSREPLY_SIZE	(32)
    EPS_ERR_CODE    Ret;
    EPS_INT32       ComSize = 0;
    EPS_INT32       retBufSize;                         /* Size of buffer written       */
    EPS_INT32       retryComm;
    EPS_INT32       retryReset;
    EPS_INT32       Size = EPS_RSREPLY_SIZE;
    EPS_INT32       lSize;
    EPS_UINT8       pResult[EPS_RSREPLY_SIZE];
	EPS_PRINT_JOB_USB* usbPrintJob = (EPS_PRINT_JOB_USB*)printJob.hProtInfo;
    
    EPS_UINT8 CBTcmd_rj[] = { 'r',   'j', 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                         /* E   , S   , C   , P   , R   , L   , i   , b    */
                            0x45, 0x53, 0x43, 0x50, 0x52, 0x4c, 0x69, 0x62 };
#if 0  /* Not use "rs" command */
    EPS_UINT8 CBTcmd_rs[] = {'r', 's', 0x01, 0x00, 0x01};
#endif


EPS_LOG_FUNCIN;

/*** Initialize Local Variables                                                         */
    retBufSize = 0;
    memset(pResult, 0, 32);

	if( !usbPrintJob ){
		EPS_RETURN( EPS_ERR_JOB_NOT_INITIALIZED );
	}

/*** If we already successfully called this function once for a given print job,        */
    if( printJob.resetSent == EPS_RESET_SENT 
		|| FALSE == printJob.transmittable
		|| FALSE == printJob.sendJS ){
        EPS_RETURN( EPS_ERR_NONE );/*  no need to send an "rj" command again. Therefore,   */
                                   /*  return EPS_ERR_NONE and exit gracefully.            */
    }

	EPS_DBGPRINT((">>>> Send Printer Reset Command.\r\n"));
	serDelayThread(500, &epsCmnFnc);				/* wait printer 500ms */  

    retryReset = 5;  /* 5 times time out */
    do{
/*** Send "rj" command                                                                  */
        retryComm = 5;
        do{
            Ret = cbtCommWriteData(usbPrintJob->fd, EPS_CBTCHANNEL_CTRL, (const EPS_UINT8*)CBTcmd_rj, sizeof(CBTcmd_rj), &ComSize);
            
            if ( Ret != EPCBT_ERR_NONE){
                if (Ret != EPSCBT_ERR_FNCDISABLE){
                    EPS_DBGPRINT(("CBT Command Write Failed [%d]\r\n",Ret));
                    EPS_RETURN( EPS_ERR_COMM_ERROR );
                }
                retryComm--;
                if (!retryComm) {
                    EPS_DBGPRINT(("CBT Command Write Retry Failed \r\n"));
                    EPS_RETURN( EPS_ERR_COMM_ERROR );
                }        
                serDelayThread(1*_SECOND_, &epsCmnFnc);        /* retry command after 1 seconds*/
            }
        }while (Ret == EPSCBT_ERR_FNCDISABLE);
        
/*** Read "rj" Reply                                                                    */
        retryComm = 5;
        lSize = Size-1;
        do{
            if ((Ret = cbtCommReadData(usbPrintJob->fd, EPS_CBTCHANNEL_CTRL, pResult, lSize, &Size)) != EPCBT_ERR_NONE){
                if (Ret != EPSCBT_ERR_FNCDISABLE){
                    EPS_DBGPRINT(("CBT Command Write Reply Failed [%d]\r\n",Ret));
                    EPS_RETURN( EPS_ERR_COMM_ERROR );
                }    
            }else if (Size != 0){
                break;
            }

            retryComm--;
            if (!retryComm){
                EPS_DBGPRINT(("CBT Command Write Reply Retry Failed \r\n"));
                EPS_RETURN( EPS_ERR_COMM_ERROR );
            }
            serDelayThread(1*_SECOND_, &epsCmnFnc);        /* retry command after 1 seconds*/
        }while(retryComm > 0);
        
/*** Make sure we received a correct reply in response to the reset command we sent.    */
		pResult[EPS_RSREPLY_SIZE-1] = '\0';
		EPS_DUMP(pResult, Size);
		if (strstr((EPS_INT8*)pResult, "rj:OK;") == NULL) {
            retryReset--;
            if (!retryReset) {
                EPS_DBGPRINT(("Failed to <rj> reset \r\n"));
                EPS_RETURN( EPS_ERR_CAN_NOT_RESET );
            }
            serDelayThread(500, &epsCmnFnc);        /* retry command after 500m seconds*/
        } else{
            break;
        }

    }while(retryReset > 0);

	/*** Close Data Channel after sent "rj" command                                     */
	Ret = cbtCommChannelClose(usbPrintJob->fd, EPS_CBTCHANNEL_DATA);
    if (Ret != EPS_ERR_NONE) {
        EPS_RETURN( EPS_ERR_NOT_CLOSE_IO );
    }
	if(printJob.printer && printJob.printer->protocolInfo){
		((EPS_USB_PRINTER_INFO*)printJob.printer->protocolInfo)->bCheckDataChannel = TRUE;
	}

	usbPrintJob->resetRequest = FALSE;

/*** Return to Caller                                                                   */
    EPS_RETURN( EPS_ERR_NONE );
}


/*******************************************|********************************************/
/*                                                                                      */
/* Function name:   usbGetPMString()                                                    */
/*                                                                                      */
/* Arguments                                                                            */
/* ---------                                                                            */
/* Name:            Type:                   Description:                                */
/* printer          EPS_PRINTER_INN*        I: Pointer to a PrinterInfo                 */
/* type 			EPS_INT32				I: PM kind 1 or 2                           */
/* pString			EPS_UINT8*				O: Pointer to PM String                     */
/* bufSize			EPS_INT32				I: pString buffer size                      */
/*                                                                                      */
/* Return value:                                                                        */
/*      EPS_ERR_NONE                    - Success                                       */
/*      EPS_ERR_JOB_NOT_INITIALIZED     - JOB is NOT initialized						*/
/*      EPS_ERR_OPR_FAIL                - Internal Error                                */
/*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */
/*      EPS_ERR_NOT_OPEN_IO             - Cannot Open I/O Portal                        */
/*      EPS_ERR_COMM_ERROR              - Info command execution error                  */
/*                                                                                      */
/* Description:                                                                         */
/*      Get PM string from usb printer.                                                 */
/*                                                                                      */
/*******************************************|********************************************/
EPS_ERR_CODE     usbGetPMString (

		const EPS_PRINTER_INN*	printer,
		EPS_INT32               type,
		EPS_UINT8*              pString,
		EPS_INT32*              bufSize

){
/*** Declare Variable Local to Routine                                                  */
    EPS_ERR_CODE		ret = EPS_ERR_NONE;     /* Return status of internal calls      */
	EPS_FILEDSC			fd = EPS_INVALID_FILEDSC;
	EPS_PRINT_JOB_USB*	usbPrintJob = (EPS_PRINT_JOB_USB*)printJob.hProtInfo;

EPS_LOG_FUNCIN;

	if (ioOpenState == EPS_IO_NOT_OPEN) {
	/*** Resolve present port number. And Open the I/O Port for communication           */
		ret = PortResolution(printer, &fd);
        if (ret != EPS_ERR_NONE) {
			cbtCommClose(fd);
			EPS_RETURN( EPS_ERR_NOT_OPEN_IO );
		}

		/*** Open the control channel                                                   */
		ret = cbtCommChannelOpen(fd, EPS_CBTCHANNEL_CTRL, TRUE);
		if (ret != EPS_ERR_NONE) {
			cbtCommChannelClose(fd, EPS_CBTCHANNEL_CTRL);
			cbtCommClose(fd);
			EPS_RETURN( EPS_ERR_NOT_OPEN_IO );
		}

/*** Get PM from Printer                                                                */
 		if(1 == type){
			ret = InfoCommand(fd, EPS_CBTCOM_PM, pString, bufSize);
		} else if(2 == type){
			ret = InfoCommand(fd, EPS_CBTCOM_PM2, pString, bufSize);
		} else{
			ret = EPS_ERR_OPR_FAIL;
		}
       
		/* Close Port */
		cbtCommChannelClose(fd, EPS_CBTCHANNEL_CTRL);
		cbtCommClose(fd);
	} else{

		if( !usbPrintJob ){
			EPS_RETURN( EPS_ERR_JOB_NOT_INITIALIZED );
		}

/*** Get PM from Printer                                                                */
		if(1 == type){
			ret = InfoCommand(usbPrintJob->fd, EPS_CBTCOM_PM, pString, bufSize);
		} else if(2 == type){
			ret = InfoCommand(usbPrintJob->fd, EPS_CBTCOM_PM2, pString, bufSize);
		} else{
			ret = EPS_ERR_OPR_FAIL;
		}
	}

/*** Return to Caller                                                                   */
    EPS_RETURN( ret );
}


/*******************************************|********************************************/
/*                                                                                      */
/* Function name:   usbGetStatus()                                                      */
/*                                                                                      */
/* Arguments                                                                            */
/* ---------                                                                            */
/* Name:        Type:               Description:                                        */
/* printer		EPS_PRINTER_INN*    I: Pointer to a PrinterInfo                         */
/* status       EPS_STATUS_INFO*    O: Pointer to the printer status.                   */
/* ioStatus		EPS_INT32*      	O: It is possible to communicate				    */
/* canceling	EPS_BOOL*      		O: Cancel processing            				    */
/*                                                                                      */
/* Return value:                                                                        */
/*      << Normal >>                                                                    */
/*      EPS_ERR_NONE                    - Success                                       */
/*      << Error >>                                                                     */
/*      EPS_ERR_OPR_FAIL                - Internal Error                                */
/*      EPS_ERR_COMM_ERROR              - Info command execution error                  */
/*      EPS_ERR_NOT_OPEN_IO             - Cannot Open I/O Portal                        */
/*      EPS_ERR_NOT_CLOSE_IO            - Cannot Close I/O Portal                       */
/*                                                                                      */
/* Description:                                                                         */
/*      Gets the printer status.                                                        */
/*                                                                                      */
/*******************************************|********************************************/
EPS_ERR_CODE    usbGetStatus (

		EPS_STATUS_INFO*		pstInfo,
		EPS_BOOL*				pIoStatus,
		EPS_BOOL*				pCancelling

){

/*** Declare Variable Local to Routine                                                  */
	EPS_ERR_CODE		ret;                    /* Return status of internal calls      */
	EPS_FILEDSC			fd = EPS_INVALID_FILEDSC;
	EPS_PRINTER_INN*	printer = printJob.printer;
	EPS_PRINT_JOB_USB*	usbPrintJob = (EPS_PRINT_JOB_USB*)printJob.hProtInfo;

EPS_LOG_FUNCIN;

/*** Initialize Local Variables                                                         */
    ret           = EPS_ERR_NONE;
    memset(pstInfo, -1, sizeof(EPS_STATUS_INFO));

/*** Get Status Data                                                                    */
    if (ioOpenState == EPS_IO_NOT_OPEN) {
		/*** Resolve present port number. And Open the I/O Port for communication       */
		ret = PortResolution(printer, &fd);
        if (ret != EPS_ERR_NONE) {
            cbtCommClose(fd);
            EPS_RETURN( EPS_ERR_NOT_OPEN_IO );
        }

        /*** Open the control channel                                                   */
        ret = cbtCommChannelOpen(fd, EPS_CBTCHANNEL_CTRL, TRUE);
        if (ret != EPS_ERR_NONE) {
            cbtCommChannelClose(fd, EPS_CBTCHANNEL_CTRL);
            cbtCommClose(fd);
            EPS_RETURN( EPS_ERR_NOT_OPEN_IO );
        }

        /*** Get Printer Status                                                         */
        ret = GetBinaryStatus(fd, pstInfo);
        if (ret != EPS_ERR_NONE) {
            cbtCommChannelClose(fd, EPS_CBTCHANNEL_CTRL);
            cbtCommClose(fd);
            EPS_RETURN( ret );
        }

		if(NULL != pIoStatus && NULL != pCancelling){
			/*** Check I/O status                                                           */
			*pCancelling = FALSE;
			if(EPS_CAREQ_CANCEL == pstInfo->nCancel
				|| (usbPrintJob && TRUE == usbPrintJob->resetRequest)){
				*pIoStatus = FALSE;
				*pCancelling = TRUE;
				if(usbPrintJob){
					/* Because EPS_CAREQ_CANCEL can be acquired only once, it memorizes. */
					usbPrintJob->resetRequest = TRUE;
				}
			} else if(EPS_ST_IDLE == pstInfo->nState){
				if( ((EPS_USB_PRINTER_INFO*)printer->protocolInfo)->bCheckDataChannel ){
					/*** Open Data Channel                                                  */
					if (cbtCommChannelOpen(fd, EPS_CBTCHANNEL_DATA, FALSE) == EPS_ERR_NONE) {
						((EPS_USB_PRINTER_INFO*)printer->protocolInfo)->bCheckDataChannel = FALSE;
						*pIoStatus = TRUE;
					} else{
						*pIoStatus = FALSE;
						*pCancelling = TRUE;
					}
					cbtCommChannelClose(fd, EPS_CBTCHANNEL_DATA);
				} else{
					*pIoStatus = TRUE;
				}
			} else{
				*pIoStatus = FALSE;
				if( ((EPS_USB_PRINTER_INFO*)printer->protocolInfo)->bCheckDataChannel ){
					*pCancelling = TRUE;
				}
			}
		}

		/* Close Port */
        ret = cbtCommChannelClose(fd, EPS_CBTCHANNEL_CTRL);
        ret = cbtCommClose(fd);
        if (ret != EPS_ERR_NONE) {
            EPS_RETURN( EPS_ERR_NOT_CLOSE_IO );
        }

    } else{ /* Job running now */

 		if( !usbPrintJob ){
			EPS_RETURN( EPS_ERR_OPR_FAIL );
		}

		/*** Get Printer Status                                                         */
        ret = GetBinaryStatus(usbPrintJob->fd, pstInfo);
        if (ret != EPS_ERR_NONE) {
            EPS_RETURN( ret );
        }

		if(NULL != pIoStatus && NULL != pCancelling){
			/*** Check I/O status                                                       */
			*pCancelling = FALSE;
			if(EPS_CAREQ_CANCEL == pstInfo->nCancel
				|| (usbPrintJob && TRUE == usbPrintJob->resetRequest)){
				*pIoStatus = FALSE;
				*pCancelling = TRUE;
				if(usbPrintJob){
					/* Because EPS_CAREQ_CANCEL can be acquired only once, it memorizes. */
					usbPrintJob->resetRequest = TRUE;
				}
			} else if(EPS_IO_OPEN == ioDataChState){
				*pIoStatus = TRUE;	/* Evidence */
			} else if(EPS_ST_IDLE == pstInfo->nState){
				if( ((EPS_USB_PRINTER_INFO*)printer->protocolInfo)->bCheckDataChannel ){
					/*** Open Data Channel                                              */
					if (cbtCommChannelOpen(usbPrintJob->fd, EPS_CBTCHANNEL_DATA, FALSE) == EPS_ERR_NONE) {
						((EPS_USB_PRINTER_INFO*)printer->protocolInfo)->bCheckDataChannel = FALSE;
						*pIoStatus = TRUE;
					} else{
						*pIoStatus = FALSE;
						*pCancelling = TRUE;
					}
					cbtCommChannelClose(usbPrintJob->fd, EPS_CBTCHANNEL_DATA);
				} else{
					*pIoStatus = TRUE;
				}
			} else{
				*pIoStatus = FALSE;
				if( ((EPS_USB_PRINTER_INFO*)printer->protocolInfo)->bCheckDataChannel ){
					*pCancelling = TRUE;
				}
			}
		}
    }
	
/*** Return to Caller                                                                   */
    EPS_RETURN( ret );
}


/*******************************************|********************************************/
/*                                                                                      */
/* Function name:   usbGetJobStatus()                                                   */
/*                                                                                      */
/* Arguments                                                                            */
/* ---------                                                                            */
/* Name:        Type:               Description:                                        */
/* pstInfo      EPS_STATUS_INFO*    O: Printer Status information                       */
/*                                                                                      */
/* Return value:                                                                        */
/*      EPS_ERR_NONE                    - Success                                       */
/*      EPS_ERR_JOB_NOT_INITIALIZED     - JOB is NOT initialized						*/
/*      EPS_ERR_COMM_ERROR              - Communication Error                           */
/*                                                                                      */
/* Description:                                                                         */
/*      Get the printer status and analyze the status string.                           */
/*                                                                                      */
/*******************************************|********************************************/
EPS_ERR_CODE    usbGetJobStatus (

        EPS_STATUS_INFO*    pstInfo

){
	EPS_ERR_CODE		ret = EPS_ERR_NONE;
 	EPS_PRINT_JOB_USB*	usbPrintJob = (EPS_PRINT_JOB_USB*)printJob.hProtInfo;

EPS_LOG_FUNCIN;

	if( !usbPrintJob ){
		EPS_RETURN( EPS_ERR_JOB_NOT_INITIALIZED );
	}

	ret = GetBinaryStatus(usbPrintJob->fd, pstInfo);
	if(EPS_ERR_NONE == ret
		&& EPS_CAREQ_CANCEL == pstInfo->nCancel){
		usbPrintJob->resetRequest = TRUE;
	}

	EPS_RETURN( ret ); 
}


/*******************************************|********************************************/
/*                                                                                      */
/* Function name:   usbMechCommand()                                                    */
/*                                                                                      */
/* Arguments                                                                            */
/* ---------                                                                            */
/* Name:        Type:               Description:                                        */
/* Command      EPS_INT32           I: Command Code                                     */
/*                                                                                      */
/* Return value:                                                                        */
/*      EPS_ERR_NONE                    - Mech command executed successfully            */
/*      EPS_ERR_JOB_NOT_INITIALIZED     - JOB is NOT initialized						*/
/*      EPS_ERR_COMM_ERROR              - Mech command execution error                  */
/*                                                                                      */
/* Description:                                                                         */
/*      Sends mechanincal commands to the printer.                                      */
/*                                                                                      */
/*******************************************|********************************************/
EPS_ERR_CODE    usbMechCommand (

        EPS_INT32   Command
        
){
/*** Declare Variable Local to Routine                                                  */
    static EPS_UINT8 stCom[] = {'x', 'x', 0x01, 0x00, 0x01};
    EPS_INT8        Reply[32];
    EPS_INT32       Size = 32;
    EPS_INT32       Retry;
    EPS_INT32       ComSize = 0;
    EPS_INT32       Ret;
    EPS_UINT8*      Com;
    EPS_INT32       cSize;
	EPS_PRINT_JOB_USB* usbPrintJob = (EPS_PRINT_JOB_USB*)printJob.hProtInfo;

EPS_LOG_FUNCIN;

	if( !usbPrintJob ){
		EPS_RETURN( EPS_ERR_JOB_NOT_INITIALIZED );
	}

/*** Initialize Local Variables                                                         */
    memset(Reply, 0, 32);

/*** Select Command                                                                     */
    switch(Command){
    case EPS_CBTCOM_XIA:
        stCom[0] = 'x'; stCom[1] = 'i';
        break;
    case EPS_CBTCOM_XIA2:
        stCom[0] = 'x'; stCom[1] = 'i'; stCom[4] = 0x03;
        break;
    case EPS_CBTCOM_XIA3:
        stCom[0] = 'x'; stCom[1] = 'i'; stCom[4] = 0x04;
        break;
    case EPS_CBTCOM_XIB:
        stCom[0] = 'x'; stCom[1] = 'i';stCom[4] = 0x80;
        break;
    case EPS_CBTCOM_CH:
        stCom[0] = 'c'; stCom[1] = 'h';
        break;
    case EPS_CBTCOM_NC:
        stCom[0] = 'n'; stCom[1] = 'c'; stCom[4] = 0x00;
        break;
    case EPS_CBTCOM_EI:
        stCom[0] = 'e'; stCom[1] = 'i'; stCom[4] = 0x00;
        break;
    case EPS_CBTCOM_PE:
        stCom[0] = 'p'; stCom[1] = 'e';
        break;
    case EPS_CBTCOM_PJ:
        stCom[0] = 'p'; stCom[1] = 'j';
        break;
    }
    
/*** Send Command                                                                       */
    Retry = 5;
    do{
        Com   = stCom;
        cSize = 5;
        
        EPS_DBGPRINT(("EPS SER : Sending CHANNEL_COMMAND %c%c\r\n", Com[0], Com[1]));
		if ((Ret = cbtCommWriteData(usbPrintJob->fd, EPS_CBTCHANNEL_CTRL, Com, cSize, &ComSize)) != EPCBT_ERR_NONE){
            if (Ret != EPSCBT_ERR_FNCDISABLE){
                EPS_RETURN( EPS_ERR_COMM_ERROR );
            }
            Retry--;
            if (!Retry) {
                EPS_RETURN( EPS_ERR_COMM_ERROR );
            }        
            serDelayThread(2*_SECOND_, &epsCmnFnc);        /* retry command after 2 seconds */
        }
    }while (Ret == EPSCBT_ERR_FNCDISABLE);

/*** Read Reply                                                                         */
    Retry = 5;
    do{
        if ((Ret = cbtCommReadData(usbPrintJob->fd, EPS_CBTCHANNEL_CTRL, (EPS_UINT8 *)Reply, 32, &Size)) != EPCBT_ERR_NONE){
            if (Ret != EPSCBT_ERR_FNCDISABLE){
                EPS_DBGPRINT(("EPS SER : CBT Command Write Reply Failed [%d]\r\n",Ret));
                EPS_RETURN( EPS_ERR_COMM_ERROR );
            }    
        }else if (Size != 0){
            break;
        }

        Retry--;
        if (!Retry){
            EPS_DBGPRINT(("EPS SER : CBT Command Write Reply Retry Failed \r\n"));
            EPS_RETURN( EPS_ERR_COMM_ERROR );
        }
        serDelayThread(2*_SECOND_, &epsCmnFnc);        /* retry command after 2 seconds*/
    }while(Retry > 0);

/*** Check Reply                                                                        */
    EPS_DBGPRINT(("EPS SER : Mech Command reply -> %s\r\n", Reply));
    if (strstr(Reply,"OK") == NULL){
        EPS_RETURN( EPS_ERR_COMM_ERROR );
    }
    
/*** Return to Caller                                                                   */
    EPS_RETURN( EPS_ERR_NONE );
}

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/
/*--------------------               Local Functions               ---------------------*/
/*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

/*******************************************|********************************************/
/*                                                                                      */
/* Function name:   GetBinaryStatus()                                                   */
/*                                                                                      */
/* Arguments                                                                            */
/* ---------                                                                            */
/* Name:        Type:               Description:                                        */
/* fd			EPS_FILEDSC		    I: file discripter                                  */
/* pstInfo      EPS_STATUS_INFO*    O: Printer Status information                       */
/*                                                                                      */
/* Return value:                                                                        */
/*      EPS_ERR_NONE                    - Success                                       */
/*      EPS_ERR_COMM_ERROR              - Communication Error                           */
/*                                                                                      */
/* Description:                                                                         */
/*      Get the printer status and analyze the status string.                           */
/*                                                                                      */
/*******************************************|********************************************/
static EPS_ERR_CODE    GetBinaryStatus (

		EPS_FILEDSC			fd,
        EPS_STATUS_INFO*    pstInfo

){
    EPS_INT8    Status[_STATUS_REPLY_BUF];
	EPS_INT32	Size = _STATUS_REPLY_BUF;

EPS_LOG_FUNCIN;

	memset(Status, 0x00, _STATUS_REPLY_BUF);

    if (InfoCommand(fd, EPS_CBTCOM_ST, (EPS_UINT8*)Status, &Size) != EPS_ERR_NONE){
        EPS_DBGPRINT(("EPS SER: Get Stat -> CBT Com Failed\r\n"));
        EPS_RETURN( EPS_ERR_COMM_ERROR );
    }

    EPS_RETURN( serAnalyzeStatus(Status, pstInfo) );
}


/*******************************************|********************************************/
/*                                                                                      */
/* Function name:   ProbeESCPR()                                                        */
/*                                                                                      */
/* Arguments                                                                            */
/* ---------                                                                            */
/* Name:        Type:               Description:                                        */
/* dev			EPS_USB_DEVICE*     I: Pointer to a usb device infomatio                */
/* manufacturer EPS_INT8*           O: Pointer to a 64-byte buffer for the manufacturer */
/*                                     name.                                            */
/* modelName    EPS_INT8*           O: Pointer to a 64-byte buffer for the printer      */
/*                                     model name.                                      */
/*                                                                                      */
/* Return value:                                                                        */
/*      EPS_ERR_NONE                    - Success                                       */
/*      EPS_ERR_OPR_FAIL                - Internal Error                                */
/*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */
/*      EPS_ERR_NOT_OPEN_IO             - Cannot Open I/O Portal                        */
/*      EPS_ERR_COMM_ERROR              - Communication Error                           */
/*      EPS_ERR_PRINTER_NOT_FOUND       - Connected printer is not supported            */
/*                                                                                      */
/* Description:                                                                         */
/*      Opens the portal, gets the printer's PM reply, parses it, and stores the data   */
/*      in the capabilities structure.                                                  */
/*                                                                                      */
/*******************************************|********************************************/
static EPS_ERR_CODE     ProbeESCPR (

		const EPS_USB_DEVICE*	dev,
        EPS_INT8*				manufacturer,
        EPS_INT8*				modelName,
		EPS_INT32*              cmdLevel

){
/*** Declare Variable Local to Routine                                                  */
    EPS_ERR_CODE    retStatus;
	EPS_FILEDSC		fd;
    EPS_INT8*       tmpDeviceIdBuf;
	EPS_INT32		bufSize;
    EPS_BOOL        found_dev;
    
EPS_LOG_FUNCIN;

/*** Initialize Local Variables                                                         */
    retStatus = EPS_ERR_NONE;
    found_dev = FALSE;

	EPS_DBGPRINT(("PROT=%d / PID=%04X / VID=%04X\n", dev->port, dev->pid, dev->vid))

    /* Allocate temp buffer */
    tmpDeviceIdBuf = (EPS_INT8*)EPS_ALLOC(EPS_DI_MAXSIZE);
    if (tmpDeviceIdBuf == NULL) {
        EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION );
    }
    memset(tmpDeviceIdBuf, 0, EPS_DI_MAXSIZE);
	bufSize = EPS_DI_MAXSIZE;

	/*** Get device ID                                                                  */
	retStatus = cbtCommOpen( dev, &fd );
    if(EPS_ERR_NONE == retStatus ){
		retStatus = cbtCommChannelOpen(fd, EPS_CBTCHANNEL_CTRL, TRUE);
		if (retStatus == EPS_ERR_NONE) {
			retStatus = InfoCommand(fd, EPS_CBTCOM_DI, (EPS_UINT8*)tmpDeviceIdBuf, &bufSize);
		} else{
			retStatus = (EPS_ERR_CODE)EPS_ERR_NOT_OPEN_IO;
		}
		cbtCommChannelClose(fd, EPS_CBTCHANNEL_CTRL);
	} else{
		retStatus = (EPS_ERR_CODE)EPS_ERR_NOT_OPEN_IO;
	}
	cbtCommClose(fd);

	if (EPS_ERR_NONE == retStatus ) {
		found_dev = serParseDeviceID(tmpDeviceIdBuf, manufacturer, modelName, cmdLevel, NULL);
		if(found_dev == FALSE) {
			retStatus = EPS_ERR_PRINTER_NOT_FOUND;
		}
	}

    EPS_SAFE_RELEASE(tmpDeviceIdBuf);

    EPS_RETURN( retStatus );
}


/*******************************************|********************************************/
/*                                                                                      */
/* Function name:   CreatePrinterInfo()                                                 */
/*                                                                                      */
/* Arguments                                                                            */
/* ---------                                                                            */
/* Name:        Type:               Description:                                        */
/* dev			EPS_USB_DEVICE*     I: Pointer to a usb device infomatio                */
/* manufacturer EPS_INT8*           I: Pointer to a 64-byte buffer for the manufacturer */
/*                                     name.                                            */
/* modelName    EPS_INT8*           I: Pointer to a 64-byte buffer for the printer      */
/*                                     model name.                                      */
/* printer		EPS_PRINTER_INN**   O: pointer for found printer structure              */
/*                                                                                      */
/* Return value:                                                                        */
/*      EPS_ERR_NONE                    - Success                                       */
/*      EPS_ERR_OPR_FAIL                - Internal Error                                */
/*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */
/*                                                                                      */
/* Description:                                                                         */
/*      Create Printer info structure and setup data.                                   */
/*                                                                                      */
/*******************************************|********************************************/
static EPS_ERR_CODE     CreatePrinterInfo (

		const EPS_USB_DEVICE*	dev,
        const EPS_INT8*			manufacturer,
        const EPS_INT8*			modelName,
		EPS_INT32               cmdLevel,
		EPS_PRINTER_INN**		printer

){
/*** Declare Variable Local to Routine                                                  */
    EPS_ERR_CODE    retStatus;
    EPS_INT8		usbIDString[EPS_NAME_BUFFSIZE];
	EPS_USB_PRINTER_INFO*	pUsbPrinter = NULL;

EPS_LOG_FUNCIN;
   
/*** Initialize Local Variables                                                         */
    retStatus = EPS_ERR_NONE;
    
/*** Create printer info structure                                                      */
	*printer = (EPS_PRINTER_INN*)EPS_ALLOC( sizeof(EPS_PRINTER_INN) );
	if(NULL == *printer){
		retStatus = EPS_ERR_MEMORY_ALLOCATION;
		goto CreatePrinterInfo_ERROR;
	}
	memset( *printer, 0, sizeof(EPS_PRINTER_INN) );

	pUsbPrinter = (EPS_USB_PRINTER_INFO*)EPS_ALLOC( sizeof(EPS_USB_PRINTER_INFO) );
	if(NULL == pUsbPrinter){
		retStatus = EPS_ERR_MEMORY_ALLOCATION;
		goto CreatePrinterInfo_ERROR;
	}
	memcpy(&pUsbPrinter->dev, dev, sizeof(pUsbPrinter->dev));
	pUsbPrinter->bCheckDataChannel = FALSE;
	(*printer)->protocolInfo = pUsbPrinter;

    strcpy( (*printer)->location, EPS_USB_NAME );
	strcpy( (*printer)->manufacturerName, manufacturer );
	strcpy( (*printer)->modelName, modelName );
	(*printer)->protocol = EPS_PROTOCOL_USB;
	(*printer)->protocol |= EPS_PRT_DIRECTION(printJob.commMode);
	(*printer)->language = EPS_LANG_ESCPR; /* ESC/P-R only via USB */
	switch(cmdLevel){
	case 0: /* Support all. For Uin communication  */
	case 2:
		(*printer)->supportFunc |= EPS_SPF_JPGPRINT; /* Jpeg print */
	case 1:
		(*printer)->supportFunc |= EPS_SPF_RGBPRINT; /* RGB print */
	}

	sprintf(usbIDString, EPS_USB_IDPRM_STR, dev->vid, dev->pid, modelName);
	prtSetIdStr(*printer, usbIDString);

CreatePrinterInfo_ERROR:
	if(EPS_ERR_NONE != retStatus){
		EPS_SAFE_RELEASE( pUsbPrinter );
		EPS_SAFE_RELEASE( *printer );
	}

    EPS_RETURN( retStatus );
}


/*******************************************|********************************************/
/*                                                                                      */
/* Function name:   PortResolution()                                                    */
/*                                                                                      */
/* Arguments                                                                            */
/* ---------                                                                            */
/* Name:        Type:               Description:                                        */
/* printer		EPS_PRINTER_INN*    I: pointer for found printer structure              */
/*                                                                                      */
/* Return value:                                                                        */
/*      EPS_ERR_NONE                    - Success                                       */
/*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */
/*      EPS_ERR_NOT_OPEN_IO             - Cannot Open I/O Portal                        */
/*      EPS_ERR_PRINTER_NOT_FOUND	    - Printer not found (or error occur)	        */
/*                                                                                      */
/* Description:                                                                         */
/*      Resolve present port number.                                                    */
/*                                                                                      */
/*******************************************|********************************************/
static EPS_ERR_CODE   PortResolution(
	
		const EPS_PRINTER_INN*		printer,
		EPS_FILEDSC*				pFd

){

/*** Declare Variable Local to Routine                                                  */
    EPS_ERR_CODE	ret = EPS_ERR_NONE;			 /* Return status of internal calls */
    EPS_BOOL		bNeedResolve = TRUE;
	EPS_USB_DEVICE	dev;
	EPS_FILEDSC		fdInt = EPS_INVALID_FILEDSC;
    EPS_INT8*       tmpDeviceIdBuf;
	EPS_INT32		bufSize;
	EPS_INT8		modelName[EPS_NAME_BUFFSIZE];       /* Printer model name       */
	EPS_INT8		manufacturer[EPS_NAME_BUFFSIZE];    /* Manufacturer name        */

EPS_LOG_FUNCIN;

	*pFd = EPS_INVALID_FILEDSC;

    if( !EPS_IS_BI_PROTOCOL(printer->protocol) ){
		EPS_RETURN( EPS_ERR_NEED_BIDIRECT );
	}

	/* Allocate temp buffer */
    tmpDeviceIdBuf = (EPS_INT8*)EPS_ALLOC(EPS_DI_MAXSIZE);
    if (tmpDeviceIdBuf == NULL) {
        EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION );
    }
    memset(tmpDeviceIdBuf, 0, EPS_DI_MAXSIZE);
	bufSize = EPS_DI_MAXSIZE;

	memset(&dev, 0, sizeof(dev));

	/*** Get device ID                                                                  */
	ret = cbtCommOpen( (EPS_USB_DEVICE*)printer->protocolInfo, &fdInt );
	if( EPS_ERR_NONE == ret ){
		ret = cbtCommChannelOpen(fdInt, EPS_CBTCHANNEL_CTRL, TRUE);
		if( EPS_ERR_NONE == ret ){
			ret = InfoCommand(fdInt, EPS_CBTCOM_DI, (EPS_UINT8*)tmpDeviceIdBuf, &bufSize);
			cbtCommChannelClose(fdInt, EPS_CBTCHANNEL_CTRL);
			if( EPS_ERR_NONE == ret ){
				/*** Get Printer name                                                   */
				memset(manufacturer, 0, sizeof(manufacturer));
				memset(modelName, 0, sizeof(modelName));
				if( serParseDeviceID(tmpDeviceIdBuf, manufacturer, modelName, NULL, NULL) ){
					/*** Printer names compare.                                         */
					if( 0 == strcmp(modelName, printer->modelName) ){
						bNeedResolve = FALSE;
					}
				}
			}
		}
	}
	
	if(bNeedResolve){
		if(EPS_INVALID_FILEDSC != fdInt){
			cbtCommClose(fdInt);
			fdInt = EPS_INVALID_FILEDSC;
		}

		/* Probe other port */
		ret = ProbePrinterByName(printer->modelName, FALSE, 0, &dev, manufacturer, modelName, NULL);
		if(EPS_ERR_NONE == ret){
			/* Reset printer port */
			memcpy(&((EPS_USB_PRINTER_INFO*)printer->protocolInfo)->dev, &dev,
				sizeof(((EPS_USB_PRINTER_INFO*)printer->protocolInfo)->dev));

			ret = cbtCommOpen( (EPS_USB_DEVICE*)printer->protocolInfo, &fdInt );
		}
	}

    EPS_SAFE_RELEASE(tmpDeviceIdBuf);

	if( EPS_ERR_NONE == ret ){
		*pFd = fdInt;
	} else{
		if(EPS_INVALID_FILEDSC != fdInt){
			cbtCommClose(fdInt);
		}
	} 

	EPS_RETURN( ret );
}


/*******************************************|********************************************/
/*                                                                                      */
/* Function name:   ProbePrinterByName()                                                */
/*                                                                                      */
/* Arguments                                                                            */
/* ---------                                                                            */
/* Name:        Type:               Description:                                        */
/* modelNameTgt EPS_INT8*           I: target printer modelname                         */
/* enableBreak	EPS_BOOL            I: enable break                                     */
/* timeout      EPS_UINT32          I: find timeout                                     */
/* dev			EPS_USB_DEVICE*     O: Pointer to a usb device infomatio                */
/* manufacturer EPS_INT8*           O: Pointer to a 64-byte buffer for the manufacturer */
/*                                     name.                                            */
/* modelName    EPS_INT8*           O: Pointer to a 64-byte buffer for the printer      */
/*                                     model name.                                      */
/*                                                                                      */
/* Return value:                                                                        */
/*      EPS_ERR_NONE                    - Success (printer found)                       */
/*      EPS_ERR_PRINTER_NOT_FOUND       - printer not found                             */
/*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */
/*      EPS_ERR_NOT_OPEN_IO             - Cannot Open I/O Portal                        */
/*                                                                                      */
/* Description:                                                                         */
/*     looks for specified printer.                                                     */
/*                                                                                      */
/*******************************************|********************************************/
static EPS_ERR_CODE   ProbePrinterByName (

		const EPS_INT8*	modelNameTgt,
		EPS_BOOL		enableBreak,
        EPS_UINT32      timeout,
		EPS_USB_DEVICE*	dev,
		EPS_INT8*		manufacturer,
		EPS_INT8*		modelName,
		EPS_INT32*      cmdLevel

){
/*** Declare Variable Local to Routine                                                  */
    EPS_ERR_CODE	ret = EPS_ERR_NONE;			 /* Return status of internal calls     */
    EPS_BOOL		found = FALSE;
	EPS_FILEDSC		fd = EPS_INVALID_FILEDSC;
	EPS_UINT32		tmStart, tmNow, tmSpan;
    
EPS_LOG_FUNCIN;

	*modelName = '\0';
	*manufacturer = '\0';

	fd = epsUsbFnc.findFirst( dev );
	if(EPS_INVALID_FILEDSC != fd){
		if(epsCmnFnc.getTime){
			tmStart = epsCmnFnc.getTime();
		} else{
			timeout = tmStart = tmNow = tmSpan = 0;
		}

		do{
			/*** Validate this is an Epson ESC/PR Printer                               */
			ret = ProbeESCPR(dev, manufacturer, modelName, cmdLevel);

			if(EPS_ERR_NONE == ret){
				if( 0 == strcmp(modelNameTgt, modelName) ){
					/* Found target printer */
					found = TRUE;
					break;
				}
			} else if(EPS_ERR_PRINTER_NOT_FOUND != ret){
				break;
			}

			if(timeout > 0){
				tmNow = epsCmnFnc.getTime();
				tmSpan = (EPS_UINT32)(tmNow - tmStart);
				EPS_DBGPRINT( ("TM %u - %u <> %u\n", tmNow, tmStart, tmSpan) )
				if( tmSpan >= timeout ){
					break;
				}
			}
			if( enableBreak ){
				if( 0 == epsCmnFnc.lockSync() ){
					if( g_FindBreak ){
						epsCmnFnc.unlockSync();
						break;
					}
					epsCmnFnc.unlockSync();
				}
			}
		}while( epsUsbFnc.findNext( fd, dev ) );

		epsUsbFnc.findClose(fd);
	}

	if(EPS_ERR_NONE == ret){
		ret = (found?EPS_ERR_NONE:EPS_ERR_PRINTER_NOT_FOUND);
	}

	EPS_RETURN( ret );
}


/*******************************************|********************************************/
/*                                                                                      */
/* Function name:   InfoCommand()                                                       */
/*                                                                                      */
/* Arguments                                                                            */
/* ---------                                                                            */
/* Name:        Type:               Description:                                        */
/* Command      EPS_INT32           I: Command Code                                     */
/* pResult      EPS_UINT8*          O: Result of Info command                           */
/* Size         EPS_INT32*          I/O: size of buffer                                 */
/*                                                                                      */
/* Return value:                                                                        */
/*      EPS_ERR_NONE                    - Info command executed successfully            */
/*      EPS_ERR_COMM_ERROR              - Info command execution error                  */
/*                                                                                      */
/* Description:                                                                         */
/*      Sends Information commands to the printer.                                      */
/*                                                                                      */
/*******************************************|********************************************/
static EPS_ERR_CODE   InfoCommand (

		EPS_FILEDSC	fd,
        EPS_INT32   Command,
        EPS_UINT8*  pResult,
        EPS_INT32*  Size
        
){
    static EPS_UINT8 stCom[5] = {'x', 'x', 0x01,0x00,0x01};
    EPS_INT32        ComSize  = 0;
    EPS_INT32        Retry;
    EPS_INT32        Ret;
    EPS_INT32        lSize;

	EPS_LOG_FUNCIN;

	switch(Command){
    case EPS_CBTCOM_DI:
        stCom[0] = 'd'; stCom[1] = 'i'; stCom[4] = 0x01;
        break;
    case EPS_CBTCOM_ST:
        stCom[0] = 's'; stCom[1] = 't'; stCom[4] = 0x01;
        break;
    case EPS_CBTCOM_CX:
        stCom[0] = 'c'; stCom[1] = 'x'; stCom[4] = 0x01;
        break;
    case EPS_CBTCOM_CSA:
        stCom[0] = 'c'; stCom[1] = 's'; stCom[4] = 0x00;
        break;
    case EPS_CBTCOM_CSB:
        stCom[0] = 'c'; stCom[1] = 's'; stCom[4] = 0x01;
        break;
    case EPS_CBTCOM_PM:
        stCom[0] = 'p'; stCom[1] = 'm'; stCom[4] = 0x01;
        break;
    case EPS_CBTCOM_PM2:
        stCom[0] = 'p'; stCom[1] = 'm'; stCom[4] = 0x02;
        break;
    }

    Retry = 5;
    do{
        if ((Ret = cbtCommWriteData(fd, EPS_CBTCHANNEL_CTRL, stCom, 5, &ComSize)) != EPCBT_ERR_NONE){
            EPS_DBGPRINT(("EPS SER : CBT Command Write Failed [%d]\r\n",Ret));
            if (Ret != EPSCBT_ERR_FNCDISABLE && Ret != EPSCBT_ERR_WRITEERROR){
                EPS_RETURN( EPS_ERR_COMM_ERROR );
            }

            Retry--;
            if (!Retry) {
                EPS_DBGPRINT(("EPS SER : CBT Command Write Retry Failed \r\n"));
                EPS_RETURN( EPS_ERR_COMM_ERROR );
            }        
            serDelayThread(2*_SECOND_, &epsCmnFnc);       /* retry command after 2 seconds*/
        }
    }while (Ret == EPSCBT_ERR_FNCDISABLE);

    Retry = 5;
    lSize = *Size;
    do{
        if ((Ret = cbtCommReadData(fd, EPS_CBTCHANNEL_CTRL, (EPS_UINT8 *)pResult, lSize, Size)) != EPCBT_ERR_NONE){
            EPS_DBGPRINT(("EPS SER : CBT Command Read Reply Failed [%d]\r\n",Ret));
            if (Ret != EPSCBT_ERR_FNCDISABLE && Ret != EPSCBT_ERR_READERROR){
                EPS_RETURN( EPS_ERR_COMM_ERROR );
            }    
        }else if (*Size != 0){
            break;
        }

        Retry--;
        if (!Retry){
            EPS_DBGPRINT(("EPS SER : CBT Command Read Reply Retry Failed \r\n"));
            EPS_RETURN( EPS_ERR_COMM_ERROR );
        }
        serDelayThread(2*_SECOND_, &epsCmnFnc);       /* retry command after 2 seconds*/
    }while(Retry > 0);
    
    pResult[*Size] = '\0';

    EPS_RETURN( EPS_ERR_NONE );
}



/*___________________________________  epson-usb.c  ____________________________________*/
  
/*34567890123456789012345678901234567890123456789012345678901234567890123456789012345678*/
/*       1         2         3         4         5         6         7         8        */
/*******************************************|********************************************/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
/***** End of File *** End of File *** End of File *** End of File *** End of File ******/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/