rom/devs/console/console.c

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