workbench/devs/serial/serial_interrupthandlers.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <aros/asmcall.h>
   7 #include <aros/libcall.h>
   8 #include <stdio.h>
   9 #include <proto/exec.h>
  10 #include <proto/dos.h>
  11 #include <exec/types.h>
  12 #include <exec/interrupts.h>
  13 #include <hidd/serial.h>
  14 #include <devices/serial.h>
  15 #include <string.h>
  16 #include "serial_intern.h"
  17
  18 #define DEBUG 0
  19 #include <aros/debug.h>
  20
  21 extern struct serialbase * pubSerialBase;
  22
  23 ULONG RBF_InterruptHandler(UBYTE * data, ULONG length, ULONG unitnum, APTR userdata)
  24 {
  25         struct SerialUnit * SU = NULL;
  26         ULONG index = 0;
  27
  28         D(bug("!Received %d bytes on unit %d\n",length,unitnum));
  29
  30         SU = findUnit(pubSerialBase, unitnum);
  31
  32         if (NULL != SU) {
  33                 if (0 != (SU->su_Status & STATUS_READS_PENDING)) {
  34                         struct IOStdReq * ioreq;
  35                         ioreq = (struct IOStdReq *)SU->su_ActiveRead;
  36
  37                         if (NULL == ioreq) {
  38                                 D(bug("\t\tpre  lh_Head: %p\n",SU->su_QReadCommandPort.mp_MsgList.lh_Head));
  39                                 ioreq = (struct IOStdReq *)GetMsg(&SU->su_QReadCommandPort);
  40                                 D(bug("\t\tpost lh_Head: %p\n",SU->su_QReadCommandPort.mp_MsgList.lh_Head));
  41                                 SU->su_ActiveRead = (struct Message *)ioreq;
  42                         }
  43
  44                         while (NULL != ioreq) {
  45                                 /*
  46                                 ** Copy the remaining data into a request buffer.
  47                                 ** This loop woll possibly execute several times
  48                                 */
  49                                 UBYTE * destBuf;
  50                                 UWORD indexDestBuf;
  51                                 D(bug("Have a IORequest (%p) for Serial device!\n",ioreq));
  52
  53                                 destBuf = ioreq->io_Data;
  54                                 indexDestBuf = ioreq->io_Actual;
  55                                 /*
  56                                 ** I copy as many bytes as I can into this request
  57                                 */
  58                                 while (index < length) {
  59                                         destBuf[indexDestBuf] = data[index];
  60
  61                                         index++;
  62                                         indexDestBuf++;
  63
  64                                         D(bug("io_Length %d:  io_Actual: %d\n",ioreq->io_Length,indexDestBuf));
  65
  66                                         if ((-1 == ioreq->io_Length && 0 == destBuf[indexDestBuf-1]) ||
  67                                             (indexDestBuf >= ioreq->io_Length)) {
  68                                                 /*
  69                                                 ** this request is done, I answer the message
  70                                                 */
  71                                                 ioreq->io_Actual = indexDestBuf;
  72                                                 ReplyMsg((struct Message *)ioreq);
  73
  74                                                 /*
  75                                                 ** Get the next request ...
  76                                                 */
  77                                                 D(bug("\t\tpre  lh_Head: %p\n",SU->su_QReadCommandPort.mp_MsgList.lh_Head));
  78                                                 ioreq = (struct IOStdReq *)GetMsg(&SU->su_QReadCommandPort);
  79                                                 D(bug("\t\tpost lh_Head: %p\n",SU->su_QReadCommandPort.mp_MsgList.lh_Head));
  80                                                 D(bug("\t\tGot new ioreq (%p) from queue\n",ioreq));
  81                                                 SU->su_ActiveRead = (struct Message *)ioreq;
  82                                                 break;
  83                                         }
  84                                 }
  85
  86                                 if (index == length && NULL != ioreq) {
  87                                         ioreq->io_Actual = indexDestBuf;
  88                                         break;
  89                                 }
  90                         }
  91                         if (NULL == ioreq)
  92                                 SU->su_Status &= ~STATUS_READS_PENDING;
  93
  94                 }
  95         } /* if (NULL != su) */
  96
  97         if (index < length) {
  98                 /*
  99                 ** there's no more IORequest, so I have to copy into the
 100                 ** genearal buffer
 101                 */
 102
 103                 D(bug("Copying data into general buffer\n"));
 104
 105                 SU->su_Status &= ~STATUS_READS_PENDING;
 106                 while (index < length) {
 107                         if (0 == (SU->su_Status & STATUS_BUFFEROVERFLOW)) {
 108                                 UWORD tmp = (SU->su_InputNextPos + 1) % SU->su_InBufLength;
 109                                 SU->su_InputBuffer[SU->su_InputNextPos] = data[index];
 110                                 index++;
 111
 112                                 /*
 113                                 ** I am advancing the circular index su_InputNextPos
 114                                 */
 115                                 if (tmp != SU->su_InputFirst) {
 116                                         SU->su_InputNextPos = tmp;
 117 D(bug("%d %d %d\n",SU->su_InputNextPos,SU->su_InBufLength,tmp));
 118                                 } else {
 119                                         SU->su_Status |= STATUS_BUFFEROVERFLOW;
 120                                         break;
 121                                 }
 122
 123                         } else
 124                                 break;
 125                 }
 126         }
 127         return length;
 128 }
 129
 130 /*
 131  * The write buffer empty interrupt handler
 132  */
 133 ULONG WBE_InterruptHandler( ULONG unitnum, APTR userdata)
 134 {
 135         ULONG total = 0;
 136         struct SerialUnit * SU;
 137
 138         SU = findUnit(pubSerialBase, unitnum);
 139
 140         if (NULL != SU) {
 141                 /*
 142                  * First get any active write
 143                  */
 144                 struct IOExtSer * ioserreq = (struct IOExtSer *)SU->su_ActiveWrite;
 145
 146                 while (1) {
 147                         /*
 148                          * Try to transmit the active write request
 149                          */
 150                         if (NULL != ioserreq) {
 151                                 ULONG writtenbytes;
 152                                 writtenbytes = HIDD_SerialUnit_Write(SU->su_Unit,
 153                                                                      &((char *)ioserreq->IOSer.io_Data)[SU->su_NextToWrite],
 154                                                                      SU->su_WriteLength);
 155                                 /*
 156                                  * Check whether this was written completely.
 157                                  */
 158                                 total += writtenbytes;
 159                                 if (writtenbytes >= SU->su_WriteLength) {
 160                                         /* This one is done */
 161                                         ReplyMsg(&ioserreq->IOSer.io_Message);
 162                                 } else {
 163                                         /*
 164                                          * Not completed, yet.
 165                                          */
 166                                         SU->su_WriteLength -= writtenbytes;
 167                                         SU->su_NextToWrite += writtenbytes;
 168                                         /*
 169                                          * Get out of the loop
 170                                          */
 171                                         break;
 172                                 }
 173                         }
 174                         /*
 175                          * Get the next request from the queue.
 176                          */
 177                         ioserreq = (struct IOExtSer *)GetMsg(&SU->su_QWriteCommandPort);
 178                         SU->su_ActiveWrite = (struct Message *)ioserreq;
 179                         if (NULL == ioserreq) {
 180                                 /*
 181                                  * No more request left. Done.
 182                                  */
 183                                 SU->su_Status &= ~STATUS_WRITES_PENDING;
 184                                 break;
 185                         }
 186
 187                         /*
 188                          * There is a new request.
 189                          */
 190                         SU->su_NextToWrite = 0;
 191                         if (-1 == ioserreq->IOSer.io_Length) {
 192                                 SU->su_WriteLength = strlen(ioserreq->IOSer.io_Data);
 193                         } else {
 194                                 SU->su_WriteLength = ioserreq->IOSer.io_Length;
 195                         }
 196                         /*
 197                          * And repeat the loop with this request
 198                          */
 199                 }
 200         }
 201         return total;
 202 }