src/driver/stream/stream_orig.c

   1 /**
   2  *   @file  stream.c
   3  *
   4  *   @brief
   5  *      The file implements the STREAM module.
   6  *
   7  *  \par
   8  *  NOTE:
   9  *      (C) Copyright 2008, Texas Instruments, Inc.
  10  *
  11  *  \par
  12  */
  13
  14
  15 /**********************************************************************
  16  ************************** Local Structures **************************
  17  **********************************************************************/
  18 #include "types.h"
  19 #include "iblcfg.h"
  20 #include <string.h>
  21
  22 /**
  23  * @brief
  24  *  The structure describes the Stream Master Control block.
  25  *
  26  * @details
  27  *  The structure stores information about the stream module
  28  *  internal buffers and state information.
  29  */
  30 typedef struct STREAM_MCB
  31 {
  32     /**
  33      * @brief   Flag which indicates if the stream buffer is open or not?
  34      */
  35     Bool       is_open;
  36
  37     /**
  38      * @brief   This is the *internal* stream buffer.
  39      */
  40     Uint8      buffer[MAX_SIZE_STREAM_BUFFER];
  41
  42     /**
  43      * @brief   This is the read index from where data is read.
  44      */
  45     Int32      read_idx;
  46
  47     /**
  48      * @brief   This is the write index to which data is written.
  49      */
  50     Int32      write_idx;
  51
  52     /**
  53      * @brief   This is the free size available in the internal buffer.
  54      */
  55     Int32      free_size;
  56 }STREAM_MCB;
  57
  58 /**********************************************************************
  59  ************************** Global Variables **************************
  60  **********************************************************************/
  61
  62 /**
  63  * @brief   This is the STREAM Master control block which keeps track
  64  * of all the stream module information.
  65  */
  66 STREAM_MCB  stream_mcb;
  67
  68 /**********************************************************************
  69  ************************** Stream Functions **************************
  70  **********************************************************************/
  71
  72 /**
  73  *  @b Description
  74  *  @n
  75  *      The function is called to open the stream module
  76  *
  77  *  @param[in]  chunk_size
  78  *      Maximum amount of data that can be received at any
  79  *      instant by the boot module.
  80  *
  81  *  @retval
  82  *      Success -   0
  83  *  @retval
  84  *      Error   -   <0
  85  */
  86 Int32 stream_open (Uint32 chunk_size)
  87 {
  88     /* Basic Validations: Ensure that the chunk size is not greater
  89      * than the internal buffer size. */
  90     if (chunk_size > MAX_SIZE_STREAM_BUFFER)
  91         return -1;
  92
  93     /* Initialize the Master control block. */
  94     stream_mcb.is_open   = TRUE;
  95     stream_mcb.read_idx  = 0;
  96     stream_mcb.write_idx = 0;
  97     stream_mcb.free_size = MAX_SIZE_STREAM_BUFFER;
  98
  99     /* Module has been initialized. */
 100     return 0;
 101 }
 102
 103 /**
 104  *  @b Description
 105  *  @n
 106  *      The function is called to read data from the stream module.
 107  *
 108  *  @param[in]  ptr_data
 109  *      Pointer to the data buffer where the data will be copied to.
 110  *  @param[in]  num_bytes
 111  *      Number of bytes to be read.
 112  *
 113  *  @retval
 114  *      Success -   Number of bytes actually read
 115  *  @retval
 116  *      Error   -   <0
 117  */
 118 Int32 stream_read (Uint8* ptr_data, Int32 num_bytes)
 119 {
 120     Int32 index;
 121     Int32 num_bytes_to_read;
 122
 123     /* Determine the number of bytes which can be read. */
 124     if (num_bytes > (MAX_SIZE_STREAM_BUFFER - stream_mcb.free_size))
 125     {
 126         /* User has requested more data than what is available. In this case we
 127          * can return only what we have. */
 128         num_bytes_to_read = (MAX_SIZE_STREAM_BUFFER - stream_mcb.free_size);
 129     }
 130     else
 131     {
 132         /* User has requested less data than what is available. In this case we
 133          * return only what the user wants. */
 134         num_bytes_to_read = num_bytes;
 135     }
 136
 137     /* There is data available copy it from the internal to the user supplied buffer.  */
 138     for (index = 0; index < num_bytes_to_read; index++)
 139     {
 140         /* Copy the data to the "write" index. */
 141         *(ptr_data + index) = *(stream_mcb.buffer + stream_mcb.read_idx);
 142
 143         /* Increment the read index. */
 144         stream_mcb.read_idx = (stream_mcb.read_idx + 1) % MAX_SIZE_STREAM_BUFFER;
 145     }
 146
 147     /* Once data has been copied; increment the free size accordingly */
 148     stream_mcb.free_size = stream_mcb.free_size + num_bytes_to_read;
 149
 150     /* Return the number of bytes read. */
 151     return num_bytes_to_read;
 152 }
 153
 154 /**
 155  *  @b Description
 156  *  @n
 157  *      The function is called to write data to the stream
 158  *      module.
 159  *
 160  *  @param[in]  ptr_data
 161  *      Pointer to the data buffer which contains the data to be copied.
 162  *  @param[in]  num_bytes
 163  *      Number of bytes being written
 164  *
 165  *  @retval
 166  *      Success -   0
 167  *  @retval
 168  *      Error   -   <0
 169  */
 170 Int32 stream_write (Uint8* ptr_data, Int32 num_bytes)
 171 {
 172     Int32 index;
 173
 174     /* Basic Validations: Ensure there is sufficient space to copy the data. */
 175     if (num_bytes > stream_mcb.free_size)
 176         return -1;
 177
 178     /* Basic Validations: Make sure the pointers are valid. */
 179     if (ptr_data == NULL)
 180         return -1;
 181
 182     /* There was sufficient space to copy the data lets do so but we copy byte by byte
 183      * since the internal buffer is circular and we can wrap around... */
 184     for (index = 0; index < num_bytes; index++)
 185     {
 186         /* Copy the data to the "write" index. */
 187         *(stream_mcb.buffer + stream_mcb.write_idx) = *(ptr_data + index);
 188
 189         /* Increment the write index. */
 190         stream_mcb.write_idx = (stream_mcb.write_idx + 1) % MAX_SIZE_STREAM_BUFFER;
 191     }
 192
 193     /* Once data has been copied; decrement the free size accordingly */
 194     stream_mcb.free_size = stream_mcb.free_size - num_bytes;
 195     return 0;
 196 }
 197
 198 /**
 199  *  @b Description
 200  *  @n
 201  *      The function is used to check if the stream buffers are empty or
 202  *      not?
 203  *
 204  *  @retval
 205  *      Empty       -   TRUE
 206  *  @retval
 207  *      Not Empty   -   FALSE
 208  */
 209 Bool stream_isempty (void)
 210 {
 211     /* Check the number of free bytes available? */
 212     if (stream_mcb.free_size == MAX_SIZE_STREAM_BUFFER)
 213         return TRUE;
 214
 215     /* There is data in the stream buffer; so its not empty. */
 216     return FALSE;
 217 }
 218
 219 /**
 220  *  @b Description
 221  *  @n
 222  *      The function closes the stream module.
 223  *
 224  *  @retval
 225  *      Not Applicable.
 226  */
 227 void stream_close (void)
 228 {
 229     /* The stream module is no longer open... */
 230     stream_mcb.is_open = FALSE;
 231     return;
 232 }
 233
 234 /**
 235  *  @b Description
 236  *  @n
 237  *      The function initializes the stream module.
 238  *
 239  *  @retval
 240  *      Not Applicable.
 241  */
 242 void stream_init (void)
 243 {
 244     /* Reset the memory contents. */
 245     memset ((void *)&stream_mcb, 0, sizeof(STREAM_MCB));
 246
 247     /* Make sure we initialize the free size correctly. */
 248     stream_mcb.free_size = MAX_SIZE_STREAM_BUFFER;
 249     return;
 250 }
 251