rom/devs/console/console.c

   1 /*
   2     Copyright © 1995-2006, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Console.device
   6     Lang: English
   7 */
   8
   9 /****************************************************************************************/
  10
  11
  12 #include <string.h>
  13
  14 #include <proto/exec.h>
  15 #include <proto/console.h>
  16 #include <proto/intuition.h>
  17 #include <exec/resident.h>
  18 #include <exec/errors.h>
  19 #include <exec/memory.h>
  20 #include <exec/initializers.h>
  21 #include <devices/inputevent.h>
  22 #include <devices/conunit.h>
  23 #include <devices/newstyle.h>
  24 #include <intuition/intuition.h>
  25 #include <intuition/screens.h>
  26 #include <intuition/classusr.h>
  27 #include <graphics/rastport.h>
  28 #include <aros/libcall.h>
  29 #include <aros/symbolsets.h>
  30
  31 #include <graphics/rastport.h>
  32
  33 #if defined(__GNUC__) || defined(__INTEL_COMPILER)
  34 #    include "console_gcc.h"
  35 #endif
  36
  37 #include "consoleif.h"
  38
  39 #include LC_LIBDEFS_FILE
  40
  41 #define SDEBUG 0
  42 #define DEBUG 0
  43 #include <aros/debug.h>
  44
  45 /****************************************************************************************/
  46
  47 #define NEWSTYLE_DEVICE 1
  48
  49 /****************************************************************************************/
  50
  51
  52 /****************************************************************************************/
  53
  54 #if NEWSTYLE_DEVICE
  55
  56 static const UWORD SupportedCommands[] =
  57 {
  58     CMD_READ,
  59     CMD_WRITE,
  60     NSCMD_DEVICEQUERY,
  61     0
  62 };
  63
  64 #endif
  65
  66 /****************************************************************************************/
  67
  68 static int GM_UNIQUENAME(Init)(LIBBASETYPEPTR ConsoleDevice)
  69 {
  70     NEWLIST(&ConsoleDevice->unitList);
  71     InitSemaphore(&ConsoleDevice->unitListLock);
  72     InitSemaphore(&ConsoleDevice->consoleTaskLock);
  73
  74     /* Create the console classes */
  75     CONSOLECLASSPTR = makeConsoleClass(ConsoleDevice);
  76     STDCONCLASSPTR = makeStdConClass(ConsoleDevice);
  77     if (!CONSOLECLASSPTR || !STDCONCLASSPTR)
  78         Alert(AT_DeadEnd | AN_ConsoleDev | AG_NoMemory);
  79
  80     /* Create the console.device task. */
  81     ConsoleDevice->consoleTask = AllocMem(sizeof(struct Task), MEMF_CLEAR|MEMF_PUBLIC);
  82     if(ConsoleDevice->consoleTask)
  83     {
  84         struct Task * const task = ConsoleDevice->consoleTask;
  85         APTR stack;
  86
  87         /* Initialise the task */
  88         NEWLIST(&task->tc_MemEntry);
  89         task->tc_Node.ln_Type = NT_TASK;
  90         task->tc_Node.ln_Name = "console.device";
  91         task->tc_Node.ln_Pri = COTASK_PRIORITY;
  92
  93         /* Initialise Command Port now we have the task */
  94         ConsoleDevice->commandPort.mp_Node.ln_Type = NT_MSGPORT;
  95         ConsoleDevice->commandPort.mp_SigTask = task;
  96         ConsoleDevice->commandPort.mp_Flags = PA_SIGNAL;
  97         ConsoleDevice->commandPort.mp_SigBit = 16;
  98         NEWLIST(&ConsoleDevice->commandPort.mp_MsgList);
  99
 100         task->tc_SigAlloc = 1L<<16 | SysBase->TaskSigAlloc;
 101
 102         stack = AllocMem(COTASK_STACKSIZE, MEMF_PUBLIC);
 103         if(stack != NULL)
 104         {
 105 #if 1
 106             struct TagItem tags[] =
 107             {
 108                 {TASKTAG_ARG1, (IPTR)ConsoleDevice  },
 109                 {TAG_DONE                           }
 110             };
 111
 112             task->tc_SPLower = stack;
 113             task->tc_SPUpper = (UBYTE *)stack + COTASK_STACKSIZE;
 114         #if AROS_STACK_GROWS_DOWNWARDS
 115             task->tc_SPReg = (UBYTE *)task->tc_SPUpper - SP_OFFSET;
 116         #else
 117             task->tc_SPReg = (UBYTE *)task->tc_SPLower + SP_OFFSET;
 118         #endif
 119
 120             if(NewAddTask(task, consoleTaskEntry, NULL, tags) != NULL)
 121             {
 122                 return ConsoleDevice;
 123                 /* ALL OK */
 124             }
 125
 126 #else
 127             task->tc_SPLower = stack;
 128             task->tc_SPUpper = (UBYTE *)stack + COTASK_STACKSIZE;
 129
 130         #if AROS_STACK_GROWS_DOWNWARDS
 131             task->tc_SPReg = (UBYTE *)task->tc_SPUpper - SP_OFFSET - sizeof(APTR);
 132             ((APTR *)task->tc_SPUpper)[-1] = ConsoleDevice;
 133         #else
 134             task->tc_SPReg = (UBYTE *)task->tc_SPLower + SP_OFFSET + sizeof(APTR);
 135             ((APTR *)(task->tc_SPLower + SP_OFFSET))[0] = ConsoleDevice;
 136         #endif
 137
 138             if(AddTask(task, consoleTaskEntry, NULL) != NULL)
 139             {
 140                 return TRUE;
 141                 /* ALL OK */
 142             }
 143
 144 #endif
 145
 146             FreeMem(stack, COTASK_STACKSIZE);
 147         }
 148         FreeMem(task, sizeof(struct Task));
 149     }
 150
 151     Alert(AT_DeadEnd | AN_ConsoleDev | AG_NoMemory);
 152     return FALSE;
 153 }
 154
 155 /****************************************************************************************/
 156
 157 static int GM_UNIQUENAME(Open)
 158 (
 159     LIBBASETYPEPTR ConsoleDevice,
 160     struct IOStdReq *ioreq,
 161     ULONG unitnum,
 162     ULONG flags
 163 )
 164 {
 165     BOOL success = FALSE;
 166
 167     /* Keep compiler happy */
 168     flags=0;
 169
 170     EnterFunc(bug("OpenConsole()\n"));
 171
 172     if (ioreq->io_Message.mn_Length < sizeof(struct IOStdReq))
 173     {
 174         D(bug("console.device/open: IORequest structure passed to OpenDevice is too small!\n"));
 175         goto open_fail;
 176     }
 177
 178     if (((LONG)unitnum) == CONU_LIBRARY) /* unitnum is ULONG while CONU_LIBRARY is -1 :-(   */
 179     {
 180         D(bug("Opening CONU_LIBRARY unit\n"));
 181         ioreq->io_Device = (struct Device *)ConsoleDevice;
 182
 183         /* Set io_Unit to NULL, so that CloseDevice knows this is a CONU_LIBRARY unit */
 184         ioreq->io_Unit = NULL;
 185         success = TRUE;
 186     }
 187     else
 188     {
 189         Class *classptr = NULL; /* Keep compiler happy */
 190
 191         struct TagItem conunit_tags[] =
 192         {
 193             {A_Console_Window,  0},
 194             {TAG_DONE, 0}
 195         };
 196
 197         /* Init tags */
 198
 199         conunit_tags[0].ti_Data = (IPTR)ioreq->io_Data; /* Window */
 200
 201
 202         /* Select class of which to create console object */
 203         switch (unitnum)
 204         {
 205             case CONU_STANDARD:
 206                 D(bug("Opening CONU_STANDARD console\n"));
 207                 classptr = STDCONCLASSPTR;
 208                 break;
 209
 210             case CONU_CHARMAP:
 211                 classptr = CHARMAPCLASSPTR;
 212                 break;
 213
 214             case CONU_SNIPMAP:
 215                 classptr = SNIPMAPCLASSPTR;
 216                 break;
 217
 218             default:
 219                 goto open_fail;
 220
 221
 222         }
 223         /* Create console object */
 224         ioreq->io_Unit = (struct Unit *)NewObjectA(classptr, NULL, conunit_tags);
 225         if (ioreq->io_Unit)
 226         {
 227             struct opAddTail add_msg;
 228             success = TRUE;
 229
 230             /* Add the newly created unit to console's list of units */
 231             ObtainSemaphore(&ConsoleDevice->unitListLock);
 232
 233             add_msg.MethodID = OM_ADDTAIL;
 234             add_msg.opat_List = (struct List *)&ConsoleDevice->unitList;
 235             DoMethodA((Object *)ioreq->io_Unit, (Msg)&add_msg);
 236
 237             ReleaseSemaphore(&ConsoleDevice->unitListLock);
 238         } /* if (console unit created) */
 239
 240     } /* if (not CONU_LIBRARY) */
 241
 242     if (!success)
 243         goto open_fail;
 244
 245     return TRUE;
 246
 247 open_fail:
 248
 249     ioreq->io_Error = IOERR_OPENFAIL;
 250
 251     return FALSE;
 252 }
 253
 254 /****************************************************************************************/
 255
 256 static int GM_UNIQUENAME(Close)
 257 (
 258     LIBBASETYPEPTR ConsoleDevice,
 259     struct IORequest *ioreq
 260 )
 261 {
 262     if (ioreq->io_Unit)
 263     {
 264         ULONG mid = OM_REMOVE;
 265
 266         /* Remove the consoe from the console list */
 267         ObtainSemaphore(&ConsoleDevice->unitListLock);
 268         DoMethodA((Object *)ioreq->io_Unit, (Msg)&mid);
 269         ReleaseSemaphore(&ConsoleDevice->unitListLock);
 270
 271         DisposeObject((Object *)ioreq->io_Unit);
 272     }
 273
 274     return TRUE;
 275 }
 276
 277 /****************************************************************************************/
 278
 279 ADD2INITLIB(GM_UNIQUENAME(Init),0)
 280 ADD2OPENDEV(GM_UNIQUENAME(Open),0)
 281 ADD2CLOSEDEV(GM_UNIQUENAME(Close),0)
 282
 283 /****************************************************************************************/
 284
 285 AROS_LH1(void, beginio,
 286  AROS_LHA(struct IOStdReq *, ioreq, A1),
 287            struct ConsoleBase *, ConsoleDevice, 5, Console)
 288 {
 289     AROS_LIBFUNC_INIT
 290     LONG error=0;
 291
 292     BOOL done_quick = TRUE;
 293
 294     /* WaitIO will look into this */
 295     ioreq->io_Message.mn_Node.ln_Type=NT_MESSAGE;
 296
 297     EnterFunc(bug("BeginIO(ioreq=%p)\n", ioreq));
 298
 299     switch (ioreq->io_Command)
 300     {
 301 #if NEWSTYLE_DEVICE
 302         case NSCMD_DEVICEQUERY:
 303             if(ioreq->io_Length < ((LONG)OFFSET(NSDeviceQueryResult, SupportedCommands)) + sizeof(UWORD *))
 304             {
 305                 ioreq->io_Error = IOERR_BADLENGTH;
 306             }
 307             else
 308             {
 309                 struct NSDeviceQueryResult *d;
 310
 311                 d = (struct NSDeviceQueryResult *)ioreq->io_Data;
 312
 313                 d->DevQueryFormat        = 0;
 314                 d->SizeAvailable         = sizeof(struct NSDeviceQueryResult);
 315                 d->DeviceType            = NSDEVTYPE_CONSOLE;
 316                 d->DeviceSubType         = 0;
 317                 d->SupportedCommands     = (UWORD *)SupportedCommands;
 318
 319                 ioreq->io_Actual = sizeof(struct NSDeviceQueryResult);
 320             }
 321             break;
 322 #endif
 323
 324
 325         case CMD_WRITE: {
 326             ULONG towrite;
 327
 328 #if DEBUG
 329             {
 330                 char *str;
 331                 int i;
 332                 str = ioreq->io_Data;
 333                 for (i = 0; i < ioreq->io_Length; i ++)
 334                 {
 335                     kprintf("%c\n", *str ++);
 336                 }
 337             }
 338 #endif
 339             if (ioreq->io_Length == -1) {
 340                 towrite = strlen((STRPTR)ioreq->io_Data);
 341             } else {
 342                 towrite = ioreq->io_Length;
 343             }
 344
 345
 346             ioreq->io_Actual = writeToConsole((struct ConUnit *)ioreq->io_Unit
 347                 , ioreq->io_Data
 348                 , towrite
 349                 , ConsoleDevice
 350             );
 351
 352             break; }
 353
 354         case CMD_READ:
 355             done_quick = FALSE;
 356
 357             break;
 358
 359         default:
 360             error = IOERR_NOCMD;
 361             break;
 362
 363     } /* switch (ioreq->io_Command) */
 364
 365     if (!done_quick)
 366     {
 367         /* Mark IO request to be done non-quick */
 368         ioreq->io_Flags &= ~IOF_QUICK;
 369         /* Send to input device task */
 370         PutMsg(&ConsoleDevice->commandPort, (struct Message *)ioreq);
 371     }
 372     else
 373     {
 374
 375         /* If the quick bit is not set but the IO request was done quick,
 376         ** reply the message to tell we're throgh
 377         */
 378         ioreq->io_Error = error;
 379         if (!(ioreq->io_Flags & IOF_QUICK))
 380             ReplyMsg (&ioreq->io_Message);
 381     }
 382
 383     ReturnVoid("BeginIO");
 384     AROS_LIBFUNC_EXIT
 385 }
 386
 387 /****************************************************************************************/
 388
 389 AROS_LH1(LONG, abortio,
 390  AROS_LHA(struct IORequest *, ioreq, A1),
 391            struct ConsoleBase *, ConsoleDevice, 6, Console)
 392 {
 393     AROS_LIBFUNC_INIT
 394
 395     LONG ret = -1;
 396
 397     ObtainSemaphore(&ConsoleDevice->consoleTaskLock);
 398
 399     /* The ioreq can either be in the ConsoleDevice->commandPort MsgPort,
 400        or be in the ConsoleDevice->readRequests List, or be already done.
 401
 402        In the first two cases ln_Type will be NT_MESSAGE (= it can be
 403        aborted), in the last case ln_Type will be NT_REPLYMSG (cannot
 404        abort, because already done)
 405
 406        The consoleTaskLock Semaphore hopefully makes sure that there are no
 407        other/"in-between" cases.
 408
 409     */
 410
 411     if (ioreq->io_Message.mn_Node.ln_Type != NT_REPLYMSG)
 412     {
 413         ioreq->io_Error = IOERR_ABORTED;
 414         Remove(&ioreq->io_Message.mn_Node);
 415         ReplyMsg(&ioreq->io_Message);
 416
 417         ret = 0;
 418     }
 419
 420     ReleaseSemaphore(&ConsoleDevice->consoleTaskLock);
 421
 422     return ret;
 423
 424     AROS_LIBFUNC_EXIT
 425 }
 426
 427 /****************************************************************************************/
 428