home *** CD-ROM | disk | FTP | other *** search
/ back2roots/padua / padua.7z / padua / uucp / uupoll068.lha / misc / uupoll067.lha / src / serio.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-07-16  |  3.2 KB  |  153 lines
  1.  
  2. /*
  3.                         serio.c -- serial I/O support
  4.           ___  _______
  5.           /__)(_  /_       Genesis     : Sat Oct 12 22:48:22 1991
  6.          / \____)(___      Last Change : Mon Jan 27 18:00:58 1992
  7.         /                  Class       : Amiga dependend
  8.  
  9.       Copyright (c) Ralf S. Engelschall, All Rights Reserved.
  10.                                                                             */
  11.  
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <proto/exec.h>
  15. #include <devices/serial.h>
  16. #include <exec/execbase.h>
  17. #include "serio.h"
  18. #include "cus.h"
  19.  
  20. extern struct ExecBase    *SysBase;
  21.  
  22.  
  23. struct SerialHandle *CreateSerialHandle(LONG Unit, UBYTE Flags)
  24. {
  25.     struct SerialHandle *Handle;
  26.     struct Serialhandle *rc;
  27.  
  28.     if ((Handle = (struct SerialHandle *)malloc(sizeof(struct SerialHandle))) == NULL) {
  29.         DeleteSerialHandle(Handle);
  30.         CU(NULL);
  31.     }
  32.     if((Handle->sh_Port = (struct MsgPort *)CreatePort(NULL, 0)) == NULL) {
  33.         DeleteSerialHandle(Handle);
  34.         CU(NULL);
  35.     }
  36.     if((Handle->sh_SerialIO = (struct IOExtSer *)CreateExtIO(Handle->sh_Port, sizeof(struct IOExtSer))) == NULL) {
  37.         DeleteSerialHandle(Handle);
  38.         CU(NULL);
  39.     }
  40.     Handle->sh_SerialIO->io_SerFlags = Flags;
  41.     Handle->sh_Status = 0L;
  42.  
  43.     if(OpenDevice(SERIALNAME, Unit, Handle->sh_SerialIO, 0L) != 0)
  44.         CU(NULL);
  45.     rc = Handle;
  46.  
  47. CUS:
  48.     return rc;
  49. }
  50.  
  51.  
  52. void DeleteSerialHandle(struct SerialHandle *Handle)
  53. {
  54.     if(Handle) {
  55.         if(Handle->sh_SerialIO) {
  56.             if(Handle->sh_SerialIO->IOSer.io_Device) {
  57.                 AbortIO(Handle->sh_SerialIO);
  58.                 WaitIO(Handle->sh_SerialIO);
  59.                 CloseDevice(Handle->sh_SerialIO);
  60.             }
  61.             DeleteExtIO(Handle->sh_SerialIO);
  62.         }
  63.         if(Handle->sh_Port)
  64.             DeletePort(Handle->sh_Port);
  65.         free(Handle);
  66.     }
  67.     return;
  68. }
  69.  
  70.  
  71. ULONG GetSerialStatus(struct SerialHandle *Handle)
  72. {
  73.     ULONG rc;
  74.  
  75.     if(Handle) {
  76.         Handle->sh_SerialIO->IOSer.io_Command = SDCMD_QUERY;
  77.         DoIO(Handle->sh_SerialIO);
  78.         Handle->sh_Status = Handle->sh_SerialIO->io_Status;
  79.         CU(Handle->sh_SerialIO->IOSer.io_Actual);
  80.     }
  81.     rc = 0L;
  82.  
  83. CUS:
  84.     return rc;
  85. }
  86.  
  87.  
  88. int SetSerialParameters(struct SerialHandle *Handle, ULONG Baud, UBYTE Flags)
  89. {
  90.     if(Handle) {
  91.         Handle->sh_SerialIO->IOSer.io_Command = SDCMD_SETPARAMS;
  92.         Handle->sh_SerialIO->io_Baud = Baud;
  93.         Handle->sh_SerialIO->io_SerFlags = Flags;
  94.         if(!DoIO(Handle->sh_SerialIO))
  95.             return(TRUE);
  96.     }
  97.     return(FALSE);
  98. }
  99.  
  100.  
  101. ULONG ReadSerial(struct SerialHandle *Handle, unsigned char *Buffer, ULONG Size)
  102. {
  103.     if(Handle) {
  104.         Handle->sh_SerialIO->IOSer.io_Command    = CMD_READ;
  105.         Handle->sh_SerialIO->IOSer.io_Length = Size;
  106.         Handle->sh_SerialIO->IOSer.io_Data = (APTR)Buffer;
  107.         DoIO(Handle->sh_SerialIO);
  108.         return(Handle->sh_SerialIO->IOSer.io_Actual);
  109.     }
  110.     return(0L);
  111. }
  112.  
  113.  
  114. ULONG WriteSerial(struct SerialHandle *Handle, unsigned char *Buffer, ULONG Size)
  115. {
  116.     if(Handle) {
  117.         Handle->sh_SerialIO->IOSer.io_Command    = CMD_WRITE;
  118.         Handle->sh_SerialIO->IOSer.io_Length = Size;
  119.         Handle->sh_SerialIO->IOSer.io_Data = (APTR)Buffer;
  120.         DoIO(Handle->sh_SerialIO);
  121.         return(Handle->sh_SerialIO->IOSer.io_Actual);
  122.     }
  123.     return(0);
  124. }
  125.  
  126.  
  127. ULONG GetSerial(struct SerialHandle *Handle)
  128. {
  129.     unsigned char Data;
  130.  
  131.     if(Handle) {
  132.         if(GetSerialStatus(Handle)) {
  133.             if(ReadSerial(Handle, &Data, 1) == 1)
  134.                 return((ULONG)Data);
  135.         }
  136.     }
  137.     return(-1);
  138. }
  139.  
  140.  
  141. ULONG PutSerial(unsigned char c, struct SerialHandle *Handle)
  142. {
  143.     unsigned char Data = c;
  144.  
  145.     if(Handle) {
  146.         if(WriteSerial(Handle, &Data, 1) == 1)
  147.             return((ULONG)Data);
  148.     }
  149.     return(-1);
  150. }
  151.  
  152.  
  153.