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 */
15 /**********************************************************************
16 ************************** Local Structures **************************
17 **********************************************************************/
18 #include "types.h"
19 #include "iblcfg.h"
20 #include <string.h>
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;
37 /**
38 * @brief This is the *internal* stream buffer.
39 */
40 Uint8 buffer[MAX_SIZE_STREAM_BUFFER];
42 /**
43 * @brief This is the read index from where data is read.
44 */
45 Int32 read_idx;
47 /**
48 * @brief This is the write index to which data is written.
49 */
50 Int32 write_idx;
52 /**
53 * @brief This is the free size available in the internal buffer.
54 */
55 Int32 free_size;
56 }STREAM_MCB;
58 /**********************************************************************
59 ************************** Global Variables **************************
60 **********************************************************************/
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;
68 /**********************************************************************
69 ************************** Stream Functions **************************
70 **********************************************************************/
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;
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;
99 /* Module has been initialized. */
100 return 0;
101 }
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;
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 }
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);
143 /* Increment the read index. */
144 stream_mcb.read_idx = (stream_mcb.read_idx + 1) % MAX_SIZE_STREAM_BUFFER;
145 }
147 /* Once data has been copied; increment the free size accordingly */
148 stream_mcb.free_size = stream_mcb.free_size + num_bytes_to_read;
150 /* Return the number of bytes read. */
151 return num_bytes_to_read;
152 }
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;
174 /* Basic Validations: Ensure there is sufficient space to copy the data. */
175 if (num_bytes > stream_mcb.free_size)
176 return -1;
178 /* Basic Validations: Make sure the pointers are valid. */
179 if (ptr_data == NULL)
180 return -1;
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);
189 /* Increment the write index. */
190 stream_mcb.write_idx = (stream_mcb.write_idx + 1) % MAX_SIZE_STREAM_BUFFER;
191 }
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 }
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;
215 /* There is data in the stream buffer; so its not empty. */
216 return FALSE;
217 }
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 }
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));
247 /* Make sure we initialize the free size correctly. */
248 stream_mcb.free_size = MAX_SIZE_STREAM_BUFFER;
249 return;
250 }