1 /* circularbytebuffer-asm.S */
3 This file is part of the AVR-circularbytebuffer.
4 Copyright (C) 2009 Daniel Otte (daniel.otte@rub.de)
6 This program is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
20 * \file circularbytebuffer-asm.S
21 * \email daniel.otte@rub.de
24 * \license GPLv3 or later
25 * \ingroup circularbytebuffer
26 * \brief declaration for circular byte buffer
36 } circularbytebuffer_t;
41 #define BUFFER_SIZE_OFFSET 0
42 #define FILLCOUNT_OFFSET 1
43 #define BUFFER_OFFSET 2
48 #ifndef CIRCULARBYTEBUFFER_NO_MALLOC
49 # define CIRCULARBYTEBUFFER_NO_MALLOC 0
52 #ifndef CIRCULARBYTEBUFFER_NO_INIT2
53 # define CIRCULARBYTEBUFFER_NO_INIT2 0
56 #if CIRCULARBYTEBUFFER_NO_MALLOC==0
58 /******************************************************************************/
60 * uint8_t circularbytebuffer_init(uint8_t buffersize, circularbytebuffer_t *cb){
61 * cb->buffer_size = buffersize;
62 * cb->buffer = malloc(buffersize);
63 * cb->head = cb->tail = cb->buffer;
64 * cb->top = cb->buffer + cb->buffer_size;
67 * return 1; / * success * /
68 * return 0; / * malloc failed * /
71 * param buffersize: r24
74 .global circularbytebuffer_init
75 circularbytebuffer_init:
79 std Y+0, r24 /* set buffer_size */
80 std Y+1, r1 /* set fillcount to 0 */
106 /******************************************************************************/
108 * void circularbytebuffer_free(circularbytebuffer_t *cb){
114 .global circularbytebuffer_free
115 circularbytebuffer_free:
117 ldd r24, Z+BUFFER_OFFSET
118 ldd r25, Z+BUFFER_OFFSET+1
121 #endif /* CIRCULARBYTEBUFFER_NO_MALLOC==0 */
123 #if CIRCULARBYTEBUFFER_NO_INIT2==0
125 /******************************************************************************/
127 * void circularbytebuffer_init2(uint8_t buffersize, circularbytebuffer_t *cb, void *buffer){
128 * cb->buffer_size = buffersize;
129 * cb->buffer = buffer
130 * cb->head = cb->tail = cb->buffer;
131 * cb->top = cb->buffer + cb->buffer_size;
135 * param buffersize: r24
137 * param buffer: r20:r21
139 .global circularbytebuffer_init2
140 circularbytebuffer_init2:
142 std Z+0, r24 /* set buffer_size */
143 std Z+1, r1 /* set fillcount to 0 */
156 #endif /* CIRCULARBYTEBUFFER_NO_INIT2==0 */
158 /******************************************************************************/
160 * uint8_t circularbytebuffer_cnt(circularbytebuffer_t *cb){
161 * return (cb->fillcount);
166 .global circularbytebuffer_cnt
167 circularbytebuffer_cnt:
169 ldd r24, Z+FILLCOUNT_OFFSET
173 /******************************************************************************/
175 * uint16_t circularbytebuffer_get_lifo(circularbytebuffer_t *cb){
177 * if(cb->fillcount==0)
181 * cb->tail = (uint8_t*)(cb->tail) + 1;
182 * if(cb->tail>=cb->top)
183 * cb->tail = (uint8_t*)(cb->tail) - cb->buffer_size;
188 .global circularbytebuffer_get_lifo
189 circularbytebuffer_get_lifo:
191 ldd r23, Z+FILLCOUNT_OFFSET
199 std Z+FILLCOUNT_OFFSET, r23
200 ldd r26, Z+TAIL_OFFSET
201 ldd r27, Z+TAIL_OFFSET+1
204 ldd r22, Z+TOP_OFFSET
205 ldd r23, Z+TOP_OFFSET+1
209 ldd r22, Z+BUFFER_SIZE_OFFSET
213 std Z+TAIL_OFFSET, r26
214 std Z+TAIL_OFFSET+1, r27
217 /******************************************************************************/
219 * uint16_t circularbytebuffer_get_fifo(circularbytebuffer_t *cb){
221 * if(cb->fillcount==0)
225 * cb->head = (uint8_t*)(cb->head) - 1;
226 * if(cb->head<cb->buffer)
227 * cb->head = (uint8_t*)(cb->head) + cb->buffer_size;
233 * modifys: r22-r27,r30,r31
235 .global circularbytebuffer_get_fifo
236 circularbytebuffer_get_fifo:
238 ldd r23, Z+FILLCOUNT_OFFSET
246 std Z+FILLCOUNT_OFFSET, r23
247 ldd r26, Z+HEAD_OFFSET
248 ldd r27, Z+HEAD_OFFSET+1
252 ldd r22, Z+BUFFER_OFFSET
253 ldd r23, Z+BUFFER_OFFSET+1
257 ldd r22, Z+BUFFER_SIZE_OFFSET
261 std Z+HEAD_OFFSET, r26
262 std Z+HEAD_OFFSET+1, r27
265 /******************************************************************************/
267 * uint8_t circularbytebuffer_append(uint8_t elem, circularbytebuffer_t *cb){
268 * if(cb->fillcount==cb->buffer_size)
271 * cb->tail = cb->tail - 1;
272 * if(cb->tail<cb->buffer)
273 * cb->tail = (uint8_t*)(cb->tail) + cb->buffer_size;
274 * if(cb->fillcount==1)
275 * cb->head = cb->tail;
276 * *(cb->tail) = elem;
283 .global circularbytebuffer_append
284 circularbytebuffer_append:
286 ldd r22, Z+FILLCOUNT_OFFSET
287 ldd r23, Z+BUFFER_SIZE_OFFSET
300 std Z+FILLCOUNT_OFFSET, r22
301 ldd r26, Z+TAIL_OFFSET
302 ldd r27, Z+TAIL_OFFSET+1
304 ldd r22, Z+BUFFER_OFFSET
305 ldd r23, Z+BUFFER_OFFSET+1
309 ldd r22, Z+BUFFER_SIZE_OFFSET
313 std Z+TAIL_OFFSET, r26
314 std Z+TAIL_OFFSET+1, r27
316 std Z+HEAD_OFFSET, r26
317 std Z+HEAD_OFFSET+1, r27
323 /******************************************************************************/
325 * uint8_t circularbytebuffer_push(uint8_t elem, circularbytebuffer_t *cb){
326 * if(cb->fillcount==cb->buffer_size)
329 * cb->head = cb->head + 1;
330 * if(cb->head>=cb->top)
331 * cb->head = (uint8_t*)(cb->head) - cb->buffer_size;
332 * if(cb->fillcount==1)
333 * cb->tail = cb->head;
334 * *(cb->head) = elem;
341 .global circularbytebuffer_push
342 circularbytebuffer_push:
344 ldd r22, Z+FILLCOUNT_OFFSET
345 ldd r23, Z+BUFFER_SIZE_OFFSET
358 std Z+FILLCOUNT_OFFSET, r22
359 ldd r26, Z+HEAD_OFFSET
360 ldd r27, Z+HEAD_OFFSET+1
362 ldd r22, Z+TOP_OFFSET
363 ldd r23, Z+TOP_OFFSET+1
367 ldd r22, Z+BUFFER_SIZE_OFFSET
371 std Z+HEAD_OFFSET, r26
372 std Z+HEAD_OFFSET+1, r27
374 ; std Z+TAIL_OFFSET, r26
375 ; std Z+TAIL_OFFSET+1, r27