include/qemu/fifo32.h

   1 /*
   2  * Generic FIFO32 component, based on FIFO8.
   3  *
   4  * Copyright (c) 2016 Jean-Christophe Dubois
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version
   9  * 2 of the License, or (at your option) any later version.
  10  *
  11  * You should have received a copy of the GNU General Public License along
  12  * with this program; if not, see <http://www.gnu.org/licenses/>.
  13  */
  14
  15 #ifndef FIFO32_H
  16 #define FIFO32_H
  17
  18 #include "qemu/fifo8.h"
  19
  20 typedef struct {
  21     Fifo8 fifo;
  22 } Fifo32;
  23
  24 /**
  25  * fifo32_create:
  26  * @fifo: struct Fifo32 to initialise with new FIFO
  27  * @capacity: capacity of the newly created FIFO expressed in 32 bit words
  28  *
  29  * Create a FIFO of the specified size. Clients should call fifo32_destroy()
  30  * when finished using the fifo. The FIFO is initially empty.
  31  */
  32
  33 static inline void fifo32_create(Fifo32 *fifo, uint32_t capacity)
  34 {
  35     fifo8_create(&fifo->fifo, capacity * sizeof(uint32_t));
  36 }
  37
  38 /**
  39  * fifo32_destroy:
  40  * @fifo: FIFO to cleanup
  41  *
  42  * Cleanup a FIFO created with fifo32_create(). Frees memory created for FIFO
  43  * storage. The FIFO is no longer usable after this has been called.
  44  */
  45
  46 static inline void fifo32_destroy(Fifo32 *fifo)
  47 {
  48     fifo8_destroy(&fifo->fifo);
  49 }
  50
  51 /**
  52  * fifo32_num_free:
  53  * @fifo: FIFO to check
  54  *
  55  * Return the number of free uint32_t slots in the FIFO.
  56  *
  57  * Returns: Number of free 32 bit words.
  58  */
  59
  60 static inline uint32_t fifo32_num_free(Fifo32 *fifo)
  61 {
  62     return DIV_ROUND_UP(fifo8_num_free(&fifo->fifo), sizeof(uint32_t));
  63 }
  64
  65 /**
  66  * fifo32_num_used:
  67  * @fifo: FIFO to check
  68  *
  69  * Return the number of used uint32_t slots in the FIFO.
  70  *
  71  * Returns: Number of used 32 bit words.
  72  */
  73
  74 static inline uint32_t fifo32_num_used(Fifo32 *fifo)
  75 {
  76     return DIV_ROUND_UP(fifo8_num_used(&fifo->fifo), sizeof(uint32_t));
  77 }
  78
  79 /**
  80  * fifo32_push:
  81  * @fifo: FIFO to push to
  82  * @data: 32 bits data word to push
  83  *
  84  * Push a 32 bits data word to the FIFO. Behaviour is undefined if the FIFO
  85  * is full. Clients are responsible for checking for fullness using
  86  * fifo32_is_full().
  87  */
  88
  89 static inline void fifo32_push(Fifo32 *fifo, uint32_t data)
  90 {
  91     int i;
  92
  93     for (i = 0; i < sizeof(data); i++) {
  94         fifo8_push(&fifo->fifo, data & 0xff);
  95         data >>= 8;
  96     }
  97 }
  98
  99 /**
 100  * fifo32_push_all:
 101  * @fifo: FIFO to push to
 102  * @data: data to push
 103  * @size: number of 32 bit words to push
 104  *
 105  * Push a 32 bit word array to the FIFO. Behaviour is undefined if the FIFO
 106  * is full. Clients are responsible for checking the space left in the FIFO
 107  * using fifo32_num_free().
 108  */
 109
 110 static inline void fifo32_push_all(Fifo32 *fifo, const uint32_t *data,
 111                                    uint32_t num)
 112 {
 113     int i;
 114
 115     for (i = 0; i < num; i++) {
 116         fifo32_push(fifo, data[i]);
 117     }
 118 }
 119
 120 /**
 121  * fifo32_pop:
 122  * @fifo: fifo to pop from
 123  *
 124  * Pop a 32 bits data word from the FIFO. Behaviour is undefined if the FIFO
 125  * is empty. Clients are responsible for checking for emptiness using
 126  * fifo32_is_empty().
 127  *
 128  * Returns: The popped 32 bits data word.
 129  */
 130
 131 static inline uint32_t fifo32_pop(Fifo32 *fifo)
 132 {
 133     uint32_t ret = 0;
 134     int i;
 135
 136     for (i = 0; i < sizeof(uint32_t); i++) {
 137         ret |= (fifo8_pop(&fifo->fifo) << (i * 8));
 138     }
 139
 140     return ret;
 141 }
 142
 143 /**
 144  * There is no fifo32_pop_buf() because the data is not stored in the buffer
 145  * as a set of native-order words.
 146  */
 147
 148 /**
 149  * fifo32_reset:
 150  * @fifo: FIFO to reset
 151  *
 152  * Reset a FIFO. All data is discarded and the FIFO is emptied.
 153  */
 154
 155 static inline void fifo32_reset(Fifo32 *fifo)
 156 {
 157     fifo8_reset(&fifo->fifo);
 158 }
 159
 160 /**
 161  * fifo32_is_empty:
 162  * @fifo: FIFO to check
 163  *
 164  * Check if a FIFO is empty.
 165  *
 166  * Returns: True if the fifo is empty, false otherwise.
 167  */
 168
 169 static inline bool fifo32_is_empty(Fifo32 *fifo)
 170 {
 171     return fifo8_is_empty(&fifo->fifo);
 172 }
 173
 174 /**
 175  * fifo32_is_full:
 176  * @fifo: FIFO to check
 177  *
 178  * Check if a FIFO is full.
 179  *
 180  * Returns: True if the fifo is full, false otherwise.
 181  */
 182
 183 static inline bool fifo32_is_full(Fifo32 *fifo)
 184 {
 185     return fifo8_num_free(&fifo->fifo) < sizeof(uint32_t);
 186 }
 187
 188 #define VMSTATE_FIFO32(_field, _state) VMSTATE_FIFO8(_field.fifo, _state)
 189
 190 #endif /* FIFO32_H */