avr/buffer.h

   1 /*
   2  * Copyright (C) 2007 Anton Blad
   3  * Copyright (C) 2007 Fredrik Kuivinen
   4  * Copyright (C) 2007 Jakob Rosén
   5  *
   6  * This file is licensed under GPL v2.
   7  */
   8
   9 #ifndef BUFFER_H
  10 #define BUFFER_H
  11
  12 #include <stdint.h>
  13 #include <avr/io.h>
  14 #include <avr/interrupt.h>
  15
  16 // Defines the buffer size in words.
  17 #if HWBOARD==DEVTRUT
  18 #  define BUFFER_CAPACITY 128
  19 #else
  20 #  define BUFFER_CAPACITY 1024
  21 #endif
  22
  23 #if BUFFER_CAPACITY >= 256
  24 typedef uint16_t buf_t;
  25 #else
  26 typedef uint8_t buf_t;
  27 #endif
  28
  29 enum buffer_status {BUFFER_OK = 0, BUFFER_UNDERFLOW = 1, BUFFER_OVERFLOW = 2};
  30 volatile extern enum buffer_status buffer_flags;
  31 volatile extern uint16_t buffer[BUFFER_CAPACITY];
  32 volatile extern buf_t buffer_start;
  33 volatile extern buf_t buffer_size;
  34
  35 volatile extern uint16_t buffer_crc;
  36 volatile extern uint32_t buffer_crc_len;
  37 void update_crc(uint16_t w);
  38
  39 static inline void buffer_init() { }
  40
  41 static inline void buffer_clear()
  42 {
  43         buffer_flags = BUFFER_OK;
  44         buffer_start = 0;
  45         buffer_size = 0;
  46         buffer_crc_len = 0;
  47         buffer_crc = 0xffff;
  48 }
  49
  50 static inline uint8_t buffer_isempty()
  51 {
  52         return buffer_size == 0;
  53 }
  54
  55 static inline uint8_t buffer_isfull()
  56 {
  57         return buffer_size == BUFFER_CAPACITY;
  58 }
  59
  60 static inline buf_t buffer_numfree()
  61 {
  62         return BUFFER_CAPACITY - buffer_size;
  63 }
  64
  65 static inline buf_t buffer_numused()
  66 {
  67         return buffer_size;
  68 }
  69
  70 static inline uint8_t buffer_isok()
  71 {
  72         return buffer_flags == BUFFER_OK;
  73 }
  74
  75 static inline uint8_t buffer_hadunderflow()
  76 {
  77         if(buffer_flags & BUFFER_UNDERFLOW)
  78         {
  79                 buffer_flags &= (uint8_t) ~BUFFER_UNDERFLOW;
  80                 return 1;
  81         }
  82         else
  83                 return 0;
  84 }
  85
  86 static inline uint8_t buffer_hadoverflow()
  87 {
  88         if(buffer_flags & BUFFER_OVERFLOW)
  89         {
  90                 buffer_flags &= (uint8_t) ~BUFFER_OVERFLOW;
  91                 return 1;
  92         }
  93         else
  94                 return 0;
  95 }
  96
  97 // Add one word to buffer.
  98 static inline void buffer_addword(uint16_t a)
  99 {
 100         uint8_t interrupts_enabled = (SREG & _BV(SREG_I));
 101         buf_t idx;
 102
 103         cli();
 104
 105         // The CRC computations are disabled for now due to latency
 106         // problems when dumping.
 107         // update_crc(a);
 108
 109         if(buffer_size >= BUFFER_CAPACITY)
 110         {
 111                 buffer_flags |= BUFFER_OVERFLOW;
 112         }
 113         else
 114         {
 115                 idx = buffer_start+buffer_size;
 116                 if(idx >= BUFFER_CAPACITY)
 117                         idx -= BUFFER_CAPACITY;
 118
 119                 buffer[idx] = a;
 120                 buffer_size++;
 121         }
 122
 123         if(interrupts_enabled)
 124                 sei();
 125 }
 126
 127 // Reads one word from buffer.
 128 static inline uint16_t buffer_getword()
 129 {
 130         uint8_t interrupts_enabled = (SREG & _BV(SREG_I));
 131         uint16_t a;
 132
 133         cli();
 134
 135         if(buffer_size == 0)
 136         {
 137                 buffer_flags |= BUFFER_UNDERFLOW;
 138                 a = 0xffff;
 139         }
 140         else
 141         {
 142                 a = buffer[buffer_start];
 143
 144                 buffer_size--;
 145                 buffer_start++;
 146                 if(buffer_start >= BUFFER_CAPACITY)
 147                         buffer_start = 0;
 148         }
 149
 150         if(interrupts_enabled)
 151                 sei();
 152
 153         return a;
 154 }
 155
 156 #endif