arch/i386-pc/exec/memoryrawio.c

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