rom/devs/console/consoletask.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Code executed by the console.device task.
   6     Lang: english
   7 */
   8
   9
  10
  11 #include <exec/lists.h>
  12
  13 #include <proto/exec.h>
  14 #include <proto/intuition.h>
  15 #include <proto/console.h>
  16 #include <exec/io.h>
  17 #include <exec/alerts.h>
  18 #include <dos/dos.h>
  19
  20
  21 #include <devices/input.h>
  22
  23 #include "console_gcc.h"
  24 #include "consoleif.h"
  25
  26 /* #define DEBUG 1 */
  27 #include <aros/debug.h>
  28
  29 /* Protos */
  30 static BOOL checkconunit(Object *unit, struct ConsoleBase *ConsoleDevice);
  31 static void answer_read_request(struct IOStdReq *req, struct ConsoleBase *ConsoleDevice);
  32
  33 VOID consoleTaskEntry(struct ConsoleBase *ConsoleDevice)
  34 {
  35     BOOL success = FALSE;
  36     LONG waitsigs = 0L, wakeupsig, commandsig, inputsig;
  37
  38
  39     /* CD input handler puts data into this port */
  40     struct MsgPort *inputport;
  41
  42
  43     /* Used for input.device */
  44     struct MsgPort *inputmp;
  45
  46     /* Add the CDInputHandler to input.device's list of input handlers */
  47     inputmp = CreateMsgPort();
  48     if (inputmp)
  49     {
  50         struct IOStdReq *inputio;
  51         inputio = (struct IOStdReq *)CreateIORequest(inputmp, sizeof (struct IOStdReq));
  52         if (inputio)
  53         {
  54             /* Open the input.device */
  55             if (!OpenDevice("input.device", -1, (struct IORequest *)inputio, 0UL))
  56             {
  57                 /* Initialize the inputhandler itself */
  58                 ConsoleDevice->inputHandler = initCDIH(ConsoleDevice);
  59                 if (ConsoleDevice->inputHandler)
  60                 {
  61                     inputio->io_Data = ConsoleDevice->inputHandler;
  62                     inputio->io_Command = IND_ADDHANDLER;
  63
  64                     DoIO((struct IORequest *)inputio);
  65                     success = TRUE;
  66                 }
  67                 CloseDevice((struct IORequest *)inputio);
  68
  69             }
  70
  71             DeleteIORequest((struct IORequest *)inputio);
  72         }
  73
  74         DeleteMsgPort(inputmp);
  75     }
  76
  77     NEWLIST(&ConsoleDevice->readRequests);
  78
  79     /* if not successfull,  throw an alert */
  80     if (!success)
  81     {
  82         Alert(AT_DeadEnd | AN_ConsoleDev | AG_OpenDev | AO_Unknown);
  83     }
  84
  85     D(bug("Console task initialized\n"));
  86
  87
  88     /* Get console.device input handler's port */
  89     inputport = ((struct cdihData *)ConsoleDevice->inputHandler->is_Data)->inputPort;
  90
  91     inputsig    = 1 << inputport->mp_SigBit;
  92     commandsig  = 1 << ConsoleDevice->commandPort.mp_SigBit;
  93
  94     waitsigs = inputsig|commandsig|SIGBREAKF_CTRL_C;
  95
  96     for (;;)
  97     {
  98         wakeupsig = Wait(waitsigs);
  99
 100         /* Anyone wanting to kill us ? */
 101         if (wakeupsig & SIGBREAKF_CTRL_C)
 102         {
 103             break;
 104         }
 105
 106         ObtainSemaphore(&ConsoleDevice->consoleTaskLock);
 107
 108         if (wakeupsig & inputsig)
 109         {
 110             /* A message from the console device input handler */
 111             struct cdihMessage *cdihmsg;
 112
 113             while ( (cdihmsg = (struct cdihMessage *)GetMsg(inputport)) )
 114             {
 115
 116                 D(bug("GOT MESSAGE FROM CONSOLE INPUT HANDLER: "));
 117                 /* Check that the ConUnit has not been disposed,
 118                    while the message was passed
 119                 */
 120                 if (checkconunit(cdihmsg->unit, ConsoleDevice))
 121                 {
 122                     switch(cdihmsg->ie.ie_Class)
 123                     {
 124                         case IECLASS_CLOSEWINDOW:
 125                         #warning this is a hack. It would actually be up to the
 126                         #warning console.device user (CON: handler for example) to
 127                         #warning activate CLOSEWINDOW raw events (SET RAW EVENTS cmd)
 128                         #warning and then look out for this in the input stream (CMD_READ)
 129                             /* fall through */
 130
 131                         case IECLASS_RAWKEY:
 132                         {
 133                             #define MAPRAWKEY_BUFSIZE 80
 134
 135                             struct IOStdReq *req, *nextreq;
 136                             UBYTE  inputBuf[MAPRAWKEY_BUFSIZE + 1];
 137                             LONG actual;
 138                             ULONG tocopy;
 139
 140                             /* Convert it to ANSI chars */
 141
 142                             if (cdihmsg->ie.ie_Class == IECLASS_CLOSEWINDOW)
 143                             {
 144                                 /* HACK */
 145                                 inputBuf[0] = 28; /* CTRL-\ */
 146                                 actual = 1;
 147                                 /* HACK */
 148                             }
 149                             else
 150                             {
 151                                 actual = RawKeyConvert(&cdihmsg->ie
 152                                                        ,inputBuf
 153                                                        ,MAPRAWKEY_BUFSIZE
 154                                                        ,NULL);
 155                             }
 156
 157                             D(bug("RawKeyConvert returned %ld\n", actual));
 158
 159
 160                             if (actual > 0)
 161                             {
 162                                 /* Copy received characters to the console unit input buffer.
 163                                    If the buffer is full, then console input will be lost
 164                                 */
 165                                 tocopy = MIN(actual, CON_INPUTBUF_SIZE - ICU(cdihmsg->unit)->numStoredChars);
 166                                 /* Copy the input over to the unit's buffer */
 167                                 CopyMem(inputBuf
 168                                         , ICU(cdihmsg->unit)->inputBuf + ICU(cdihmsg->unit)->numStoredChars
 169                                         , tocopy
 170                                 );
 171
 172                                 ICU(cdihmsg->unit)->numStoredChars += tocopy;
 173
 174                                 /* See if there are any queued io read requests that wants to be replied */
 175                                 ForeachNodeSafe(&ConsoleDevice->readRequests, req, nextreq)
 176                                 {
 177
 178                                     if ((APTR)req->io_Unit == (APTR)cdihmsg->unit)
 179                                     {
 180                                         /* Paranoia */
 181                                         if (0 != ICU(req->io_Unit)->numStoredChars)
 182                                         {
 183                                             Remove((struct Node *)req);
 184                                             answer_read_request(req, ConsoleDevice);
 185                                         }
 186                                     }
 187                                 }
 188                             } /* if (actual > 0) */
 189
 190                         } /* IECLASS_RAWKEY */
 191                         break;
 192
 193                         case IECLASS_SIZEWINDOW:
 194                         {
 195                             Console_NewWindowSize(cdihmsg->unit);
 196                         } /* IECLASS_NEWSIZE */
 197                         break;
 198
 199                     } /* switch(cdihmsg->ie.ie_Class) */
 200
 201
 202                 } /* if (checkconunit(cdihmsg->unit, ConsoleDevice)) */
 203
 204                 /* Tell the input handler we're done */
 205                 ReplyMsg((struct Message *)cdihmsg);
 206
 207             } /* while ( (cdihmsg = (struct cdihMessage *)GetMsg(inputport)) ) */
 208
 209         } /* if (wakeupsig & inputsig) */
 210
 211         if (wakeupsig & commandsig)
 212         {
 213             /* We got a command from the outside. Investigate it */
 214             struct IOStdReq *req;
 215
 216
 217             while ((req = (struct IOStdReq *)GetMsg(&ConsoleDevice->commandPort)))
 218             {
 219                 switch (req->io_Command)
 220                 {
 221                     case CMD_READ:
 222                         if (0 != ICU(req->io_Unit)->numStoredChars)
 223                         {
 224                             answer_read_request(req, ConsoleDevice);
 225                         }
 226                         else
 227                         {
 228                             /* Not enough bytes in the buffer to fill the request, put it on hold */
 229
 230                             /* ioReq allready removed from the queue qith GetMsg() */
 231
 232                             AddTail((struct List *)&ConsoleDevice->readRequests, (struct Node *)req);
 233                         }
 234                         break;
 235
 236                 default:
 237                         kprintf("!!! UNKNOWN COMMAND RECEIVED BY CONSOLE TASK !!!\n");
 238                         kprintf("!!! THIS SHOULD NEVER HAPPEN !!!\n");
 239                         break;
 240                 }
 241
 242             } /* while ((req = (struct IOStdReq *)GetMsg(ConsoleDevice->commandPort))) */
 243
 244         } /* if (wakeupsig & commandsig) */
 245
 246         ReleaseSemaphore(&ConsoleDevice->consoleTaskLock);
 247
 248     } /* forever */
 249
 250 #warning FIXME: Do cleanup here
 251
 252 }
 253
 254 /********** checkconunit()  *******************************/
 255
 256 /* Checks that the supplied unit has not been disposed */
 257 static BOOL checkconunit(Object *unit, struct ConsoleBase *ConsoleDevice)
 258 {
 259     Object *o, *ostate;
 260     BOOL found = FALSE;
 261
 262     ObtainSemaphoreShared(&ConsoleDevice->unitListLock);
 263
 264     ostate = (Object *)ConsoleDevice->unitList.mlh_Head;
 265     while ( (o = NextObject(&ostate)) && (!found) )
 266     {
 267         if (o == unit)
 268         {
 269             found = TRUE;
 270         }
 271     }
 272
 273     ReleaseSemaphore(&ConsoleDevice->unitListLock);
 274     return found;
 275 }
 276
 277 /******** answer_read_request() ***************************/
 278
 279 static void answer_read_request(struct IOStdReq *req, struct ConsoleBase *ConsoleDevice)
 280 {
 281     Object *unit;
 282
 283     D(bug("answer_read_request\n"));
 284     /* This function assumes that there are at least one character
 285        available in the unitsinput buffer
 286     */
 287
 288     unit = (Object *)req->io_Unit;
 289
 290     req->io_Actual = MIN(ICU(unit)->numStoredChars, req->io_Length);
 291
 292     /* Copy characters from the buffer into the request */
 293     CopyMem( (APTR)ICU(unit)->inputBuf
 294             , req->io_Data
 295             , req->io_Actual
 296     );
 297
 298     if (ICU(unit)->numStoredChars > req->io_Length)
 299     {
 300         ULONG i;
 301
 302         ICU(unit)->numStoredChars -= req->io_Actual;
 303
 304         /* We have to move the rest of the bytes to the start
 305            of the buffer.
 306
 307            NOTE: we could alternatively use a circular buffer
 308         */
 309
 310         for (i = 0; i < ICU(unit)->numStoredChars; i ++)
 311         {
 312             ICU(unit)->inputBuf[i] = ICU(unit)->inputBuf[i + req->io_Actual];
 313         }
 314     }
 315     else
 316     {
 317         /* No more unread characters in the buffer */
 318         ICU(unit)->numStoredChars = 0;
 319
 320     }
 321
 322     req->io_Error = 0;
 323     /* All done. Just reply the request */
 324
 325     /* stegerg: the caller of answer_read_request is responsible for the Remove,
 326                 because the Remove must be used only if the req was in
 327                 the readrequests list
 328       Remove((struct Node *)req);
 329
 330     */
 331
 332
 333 /* kprintf("receiving task=%s, sigbit=%d\n, mode=%d"
 334         , ((struct Task *)req->io_Message.mn_ReplyPort->mp_SigTask)->tc_Node.ln_Name
 335         , req->io_Message.mn_ReplyPort->mp_SigBit
 336         , req->io_Message.mn_ReplyPort->mp_Flags
 337 );
 338 */
 339     ReplyMsg((struct Message *)req);
 340
 341     return;
 342 }