arch/i386-pc/exec/memoryrawio.c

   1 /*
   2     Copyright © 2009-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: functions for memory-stored RawIOInit/RawPutChar
   6     Lang: English
   7 */
   8
   9 #include <proto/exec.h>
  10 #include <proto/kernel.h>
  11
  12 #include <string.h>
  13
  14 #include "exec_intern.h"
  15
  16 #define BLOCK_SIZE (256 * 1024)
  17 #define TASK_PRIORITY 0
  18 #define STACK_SIZE 4096
  19
  20
  21 static const TEXT name[] = "bifteck";
  22 static const TEXT data_missed_msg[] = "<*** GAP IN DATA ***>\n";
  23
  24 struct LogBlock
  25 {
  26     struct MinNode node;
  27     ULONG length;            /* number of data bytes that follow */
  28 };
  29
  30 struct LogData
  31 {
  32     struct SignalSemaphore lock;
  33     struct MinList buffers;
  34     struct LogBlock *block;
  35     ULONG block_pos;
  36     APTR pool;
  37 };
  38
  39 void Putc(char);
  40 static void LogTask();
  41
  42 static struct LogData *data;
  43 static struct Task *task;
  44 static BOOL data_missed = FALSE;
  45 static struct LogBlock *next_block = NULL;
  46
  47
  48 /*****i***********************************************************************
  49
  50     NAME */
  51         AROS_LH0(void, MemoryRawIOInit,
  52
  53 /*  LOCATION */
  54         struct ExecBase *, SysBase, 84, Exec)
  55
  56 /*  FUNCTION
  57         This is a private function. It initializes raw IO. After you
  58         have called this function, you can use (!RawMayGetChar()) and
  59         RawPutChar().
  60
  61     INPUTS
  62         None.
  63
  64     RESULT
  65         None.
  66
  67     NOTES
  68         This function is for very low level debugging only.
  69
  70     EXAMPLE
  71
  72     BUGS
  73
  74     SEE ALSO
  75         RawPutChar(), RawMayGetChar()
  76
  77     INTERNALS
  78
  79 *****************************************************************************/
  80 {
  81     AROS_LIBFUNC_INIT
  82
  83     BOOL success = TRUE;
  84     APTR stack;
  85
  86     /* Initialise data struct, memory pool and semaphore */
  87
  88     data = AllocMem(sizeof(struct LogData), MEMF_PUBLIC | MEMF_CLEAR);
  89     if (data == NULL)
  90         success = FALSE;
  91
  92     if (success)
  93     {
  94         data->pool = CreatePool(MEMF_PUBLIC, BLOCK_SIZE, BLOCK_SIZE);
  95         NEWLIST(&data->buffers);
  96         InitSemaphore(&data->lock);
  97         data->lock.ss_Link.ln_Name = (char *)name;
  98         if (data->pool == NULL)
  99             success = FALSE;
 100     }
 101
 102
 103     if (success)
 104     {
 105        /* Allocate initial buffer */
 106
 107         data->block = (struct LogBlock *)AllocPooled(data->pool, BLOCK_SIZE);
 108         data->block->length = BLOCK_SIZE - sizeof(struct LogBlock);
 109         if (data->block == NULL)
 110             success = FALSE;
 111     }
 112
 113     if (success)
 114     {
 115        /* Add semaphore/data to public list along with initial buffer */
 116
 117         AddTail((struct List *)&data->buffers, (struct Node *)data->block);
 118         AddSemaphore(&data->lock);
 119     }
 120
 121     if (success)
 122     {
 123         /* Create a task that will allocate buffers as needed */
 124
 125         task =
 126             AllocMem(sizeof(struct Task), MEMF_PUBLIC | MEMF_CLEAR);
 127         stack = AllocMem(STACK_SIZE, MEMF_PUBLIC);
 128         if (task == NULL || stack == NULL)
 129             success = FALSE;
 130     }
 131
 132     if (success)
 133     {
 134         /* Initialise and start task */
 135
 136         task->tc_Node.ln_Type = NT_TASK;
 137         task->tc_Node.ln_Pri = TASK_PRIORITY;
 138         task->tc_Node.ln_Name = (char *)name;
 139         task->tc_SPUpper = stack + STACK_SIZE;
 140         task->tc_SPLower = stack;
 141         task->tc_SPReg = stack + STACK_SIZE;
 142         NEWLIST(&task->tc_MemEntry);
 143         task->tc_UserData = data;
 144
 145         if (AddTask(task, LogTask, NULL) == NULL)
 146             success = FALSE;
 147     }
 148
 149     if (success)
 150     {
 151         /* Signal task to allocate the second buffer */
 152
 153         Signal(task, SIGF_SINGLE);
 154     }
 155
 156     if (!success)
 157     {
 158     }
 159
 160     AROS_LIBFUNC_EXIT
 161 }
 162
 163
 164 /*****i***********************************************************************
 165
 166     NAME */
 167         AROS_LH1(void, MemoryRawPutChar,
 168
 169 /*  SYNOPSIS */
 170         AROS_LHA(UBYTE, chr, D0),
 171
 172 /*  LOCATION */
 173         struct ExecBase *, SysBase, 86, Exec)
 174
 175 /*  FUNCTION
 176         Emits a single character.
 177
 178     INPUTS
 179         chr - The character to emit
 180
 181     RESULT
 182         None.
 183
 184     NOTES
 185         This function is for very low level debugging only.
 186
 187     EXAMPLE
 188
 189     BUGS
 190
 191     SEE ALSO
 192         RawIOInit(), RawPutChar(), RawMayGetChar()
 193
 194     INTERNALS
 195
 196 *****************************************************************************/
 197 {
 198     AROS_LIBFUNC_INIT
 199
 200     struct LogBlock *new_block;
 201
 202     /* Write to screen/serial as well */
 203     KrnPutChar(chr);
 204
 205     /* Check if we need to move on to a new block */
 206
 207     if (data->block_pos == data->block->length)
 208     {
 209         /* Move on to the next block if it exists */
 210
 211         Disable();
 212         if ((new_block = next_block) != NULL)
 213             next_block = NULL;
 214         Enable();
 215
 216         if (new_block != NULL)
 217         {
 218             data->block = new_block;
 219             data->block_pos = 0;
 220
 221             /* If data was missed, add a warning to the log */
 222
 223             if (data_missed)
 224             {
 225                 CopyMem(data_missed_msg,
 226                     (UBYTE *)data->block + sizeof(struct LogBlock),
 227                     strlen(data_missed_msg));
 228                 data->block_pos += strlen(data_missed_msg);
 229                 data_missed = FALSE;
 230             }
 231
 232             /* Ask for another new block, which will hopefully be allocated
 233              * by the time we need it */
 234
 235             Signal(task, SIGF_SINGLE);
 236         }
 237     }
 238
 239     /* Store character in buffer if there's space */
 240
 241     if (data->block_pos != data->block->length)
 242     {
 243         if (chr && (chr != '\03'))
 244         {
 245             ((UBYTE *)data->block)[sizeof(struct LogBlock) + data->block_pos++] = chr;
 246         }
 247     }
 248     else
 249         data_missed = TRUE;
 250
 251     AROS_LIBFUNC_EXIT
 252 }
 253
 254
 255 static void LogTask()
 256 {
 257     struct LogBlock *block;
 258
 259     /* Add a new buffer block to the list each time we're signalled */
 260
 261     while (Wait(SIGF_SINGLE))
 262     {
 263         block = (struct LogBlock *)AllocPooled(data->pool, BLOCK_SIZE);
 264         if (block != NULL)
 265         {
 266             block->length = BLOCK_SIZE - sizeof(struct LogBlock);
 267
 268             Disable();
 269             next_block = block;
 270             Enable();
 271
 272             ObtainSemaphore(&data->lock);
 273             AddTail((struct List *)&data->buffers, (struct Node *)block);
 274             ReleaseSemaphore(&data->lock);
 275         }
 276     }
 277 }
 278