mi32/ports.h

Go to the documentation of this file.

/****************************************************************************
 * \file mi32/ports.h
 * \brief MicroImages Port library
 *
 *===========================================================================
 *
 * \if NODOC
 * $Id: ports.h_v 1.58 2012/01/06 18:01:36 mju Exp $
 *
 * $Log: ports.h_v $
 * Revision 1.58  2012/01/06 18:01:36  mju
 * Remove redundant hdr.
 *
 * Revision 1.57  2007/03/22 22:13:52  dwilliss
 * Added optional parm to PORT::Open
 *
 * Revision 1.56  2007/03/22 21:39:05  dwilliss
 * Moved all the mserial stuff to a private include file.  Only used
 * internally
 *
 * Revision 1.55  2007/03/22 21:06:53  dwilliss
 * return type of v_Write didn't match base class when compiled for Unix
 *
 * Revision 1.52  2007/03/22 17:36:07  dwilliss
 * deleted unused functions and change Mp functions to C++ linkage
 * Added an MpOpen that takes MISTRING
 * Created PORT class derived from GENERICRW
 *
 * Revision 1.51  2007/03/05 20:47:09  bcolombe
 * Changed MPORTTYPE scan back to previous version
 * Changing libmi/portcom.c scan_port to always scan
 *
 * Revision 1.49  2006/09/25 13:30:51  mju
 * Remove scsi stuff.
 *
 * Revision 1.48  2006/04/05 13:15:23  mju
 * Use ptrint for port handles so works on win64.
 *
 * Revision 1.47  2006/02/16 16:37:18  dwilliss
 * changed an ifdef to use a new define instead of a deprecated one
 *
 * Revision 1.43  2002/08/01 22:17:59  dwilliss
 * Added PORTMODE_NonBlocking
 *
 * Revision 1.42  2002/07/19 14:26:29  scowan
 * Made port name a fixed string.
 *
 * Revision 1.37  1999/08/17 22:29:51  dwilliss
 * Added a port type code
 *
 * Revision 1.35  1999/04/02  20:52:39  mju
 * Add MxPortGetSettings() prototype.
 *
 * Revision 1.13  1994/08/30  21:44:17  mju
 * Add InputQueueSize and OutputQueueSize to Port structure.
 *
 * Revision 1.1  1992/12/11  23:49:53  mju
 * Initial revision
 * \endif
****************************************************************************/

#ifndef INC_MI32_PORTS_H
#define INC_MI32_PORTS_H

#ifndef  INC_STDIO_H
   #include <stdio.h>
   #define  INC_STDIO_H
#endif

#ifndef  INC_MI32_FIXEDSTR_H
   #include <mi32/fixedstr.h>
#endif

#ifndef  INC_MI32_GENERICRW_H
   #include <mi32/genericrw.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
struct _PortSpecific {
   FIXEDSTRING<80> name;
   int num;
   };

struct _PortOption {
   char *name;                         
   int  value;
   };

struct _PortOptionType {
   char *name;                         
   short num;
   short radio;                        
   char  *dft;
   _PortOption *list;
   };
#endif 

struct MPORT;                          

struct MPORTTYPE {
   char name[20];
   int type_num;
   int (*init)(MPORT *, MPORTTYPE *, char *);
   int (*get_status)(MPORT *, char **);
   int (*read_data)(MPORT *, UINT8 *, int);
   int (*write_data)(MPORT *, const UINT8 *, int);
   int (*xxinterface_cmd)(MPORT *, const UINT8 *, int);
   int (*xxset_mode)(MPORT *, short);
   int (*set_parms)(MPORT *, char **);
   int (*xxreset)(MPORT *);
   int (*xxabort)(MPORT *);
   int (*close)(MPORT *);
   int (*scan)(MPORTTYPE *);           /* code to fill in Stuff below */
   int (*flush)(MPORT *);
/*-------------------------------------Filled in later (by scan function)---*/
   short NumPorts;                     
   short NumOptionTypes;
   _PortSpecific *specific;   
   _PortOptionType *options;
   };

struct PortChannel {
   char *buf;
   unsigned short len;
   unsigned short received;
   int allocsize;
   int spare;
   };

#define MAXPORTCHANNEL 2               

struct MPORT {
   MIUNICODE *name;
   const MPORTTYPE *type;
   int unit_num;                       
   unsigned short mode;                
   short bogus1;
   void *data;                         
   int addr;                           
   short word_dma;
   unsigned char intnum;   
   unsigned char dmanum;
   PTRINT out_port;                       
   PTRINT in_port;                        
   PTRINT secondary_out;
   PTRINT secondary_in;
   FILE *stream;                       
   unsigned short status;              
   UINT8 channel_num;
   UINT8 state;
   PortChannel channels[MAXPORTCHANNEL + 1];
   PortChannel *cp;
   void (*oldintfunc)();
   unsigned char *buf[2], *bufp;
   const unsigned char *busy_data;     
   int busy_len;
   int buflen;
   int bufleft;
   int curpos;
   int curbuf; 
   int lasterr;
   unsigned char out_mask;             
   unsigned char in_mask;              
   int InputQueueSize;                 
   int OutputQueueSize;                
   MIUNICODE *message;                    
   int   NoWait;                       
   };

/* The "data" field may be used by the module for the given port type */
/* to store any data it needs which is not already in the structure */
/* It is automatically free()d by MpClose just before it frees the */
/* whole Port structure */

#define PORTTYPE_LPT          0x0001
#define PORTTYPE_COM          0x0002
#define PORTTYPE_FILE         0x0008   
#define PORTTYPE_PIPE         0x0080   
#define PORTTYPE_SPOOLER      0x0100   
#define PORTTYPE_WINPRINT     0x0400   
#define PORTTYPE_MACBACK      0x0800   


#define PORTSTAT_Error        0x0008
#define PORTSTAT_OffLine      0x0010
#define PORTSTAT_OutOfPaper   0x0020
#define PORTSTAT_NotReady     0x0080
#define PORTSTAT_TimeOut      0x0001
#define PORTSTAT_Abort        0x8000
#define PORTSTAT_DiskFull     0x0100   


//#define PORTMODE_DoubleBuf     0x0001
//#define PORTMODE_SingleBuf     0x0002
//#define PORTMODE_Buffered      0x0003   //!<  Single or double 
//#define PORTMODE_HighSpeed     0x0004   //!<  else via DOS (obsolete)
//#define PORTMODE_SingleStream 0x0020 //!<  Single stream has command/data 
#define PORTMODE_UnicodeName  0x0100   
#define PORTMODE_NonBlocking  0x0200   
#define PORTMODE_NOT          0x8000   


#define MSERIALFLOW_Hardware  0
#define MSERIALFLOW_XonXoff   1
#define MSERIALFLOW_None      2
#define MSERIALFLOW_NoCTSDSR  3

#define MSERIALPARITY_None    0
#define MSERIALPARITY_Odd     1
#define MSERIALPARITY_Even    2

#define MSERIALBAUD_300       300
#define MSERIALBAUD_600       600
#define MSERIALBAUD_1200      1200
#define MSERIALBAUD_2400      2400
#define MSERIALBAUD_4800      4800
#define MSERIALBAUD_9600      9600
#define MSERIALBAUD_19_2K     19200
#define MSERIALBAUD_38_4K     28400
#define MSERIALBAUD_57_6K     57600

#define MSERIALDATABITS_7        7
#define MSERIALDATABITS_8        8

#define MSERIALSTOPBITS_1        1
#define MSERIALSTOPBITS_2        2
#define MSERIALSTOPBITS_1_5      3


class PORT : public GENERICRW {
   public:

      enum STATUS {
         STATUS_OK            = 0,
         STATUS_Error         = 0x0008,
         STATUS_OffLine       = 0x0010,
         STATUS_OutOfPaper    = 0x0020,
         STATUS_NotReady      = 0x0080,
         STATUS_TimeOut       = 0x0001,
         STATUS_Abort         = 0x8000,
         STATUS_DiskFull      = 0x0100 
         };

      enum TYPE {
         TYPE_Automatic          = 0,        
         TYPE_Parallel           = 0x0001,
         TYPE_Serial             = 0x0002,
         TYPE_File               = 0x0008,   
         TYPE_Pipe               = 0x0080,   
         TYPE_WindowPrinter      = 0x0400,   
         };

      PORT (
         TYPE type = TYPE_Automatic
         );

      PORT(const char* PortType);

      PORT(const MPORTTYPE* PortType);

      virtual ~PORT();

      ERRVALUE Flush (
         );

      STATUS GetStatus (
         ) const;

      bool HasDataAvailable (
         ) const;

      ERRVALUE Open (
         const MISTRING& portname,
         const char* parameters = 0,
         bool bNonBlocking = false
         );

      void SetParms (
         const char*
         );

   public:
      const MPORTTYPE* m_PortType;
      MPORT* m_priv;

      virtual CAPABILITIES v_GetCapabilities () const;
      virtual INT64 v_GetSize () const;
      virtual INT64 v_GetSizeLimit () const;
      virtual INT32 v_Read (void* buffer, INT32 numbytes, bool AllowPartial);
      virtual ERRVALUE v_Resize (INT64 newsize);
      virtual INT64 v_Seek (INT64 offset, SEEKFROM from);
      virtual INT64 v_Tell () const;
      virtual ERRVALUE v_Write (const void* buffer, INT32 numbytes);
   };


/*-------------------------------------------------------------------------*/
/*    Function Prototypes                                                  */
/*-------------------------------------------------------------------------*/

int MpClose (
   MPORT *port                         
   );

int MpComHasDataAvail (
   MPORT *port                         
   );

void MpComSetQueueSize (
   int InputSize, 
   int OutputSize
   );

int MpFlush (
   MPORT *port                         
   );

int MpGetLastError (
   MPORT *port                         
   );

MPORTTYPE * MpGetPortTypeByName (
   const char *name                    
   );

MPORTTYPE * MpGetPortTypeByNumber (
   int num                             
   );

int MpInit (void);

int MpIsFile (
   const char *type, 
   const char *name
   );

int MpIsFileUC (
   const char *type, 
   const MIUNICODE *name
   );

int MpLastStatus (
   MPORT *port                         
   );

DEPRECATED_MSG("There's a version that takes MISTRING for the name now") MPORT * MpOpen (
   const char *name,                   
   const MPORTTYPE *type,                    
   const char *parms = 0,              
   UINT32 mode = 0                     
   );

MPORT * MpOpen (
   const MISTRING& name,               
   const MPORTTYPE *type,              
   const char *parms = 0,              
   UINT32 mode = 0                     
   );

int MpRead (
   MPORT *port,                        
   void *buf,                          
   int maxlen,                         
   char *term = 0                         
   );


#ifndef GENERATING_DOXYGEN_OUTPUT 
int MpScan (
   MPORTTYPE *porttype
   );
#endif 


int MpSetParms (
   MPORT *port,                        
   const char *parms                   
   );

int MpStatus (
   MPORT *port,                        
   char **status                       
   );

int MpWrite (
   MPORT *port,                        
   const void *buf,                    
   int len                             
   );

int MpWriteExt (
   MPORT *port, 
   const void *buffer, 
   int len, 
   UINT32 flags = 0
   );

int MxpWrite (
   MPORT *port,                        
   const void *buf,                    
   int numbytes,                       
   void *status,                       
   int line                            
   );

#ifndef PORTS_C
extern MPORTTYPE *MpPortTypeList[];
#endif

int MxPortGetSettings (
   Widget pwidget, 
   MPORTTYPE *porttype, 
   char *portoptions
   );


#endif   

---