]> git.ipfire.org Git - people/ms/u-boot.git/blob - drivers/bcm570x_queue.h
Files include/linux/byteorder/{big,little}_endian.h define
[people/ms/u-boot.git] / drivers / bcm570x_queue.h
1
2 /******************************************************************************/
3 /* */
4 /* Broadcom BCM5700 Linux Network Driver, Copyright (c) 2000 Broadcom */
5 /* Corporation. */
6 /* All rights reserved. */
7 /* */
8 /* This program is free software; you can redistribute it and/or modify */
9 /* it under the terms of the GNU General Public License as published by */
10 /* the Free Software Foundation, located in the file LICENSE. */
11 /* */
12 /* Queue functions. */
13 /* void QQ_InitQueue(PQQ_CONTAINER pQueue) */
14 /* char QQ_Full(PQQ_CONTAINER pQueue) */
15 /* char QQ_Empty(PQQ_CONTAINER pQueue) */
16 /* unsigned int QQ_GetSize(PQQ_CONTAINER pQueue) */
17 /* unsigned int QQ_GetEntryCnt(PQQ_CONTAINER pQueue) */
18 /* char QQ_PushHead(PQQ_CONTAINER pQueue, PQQ_ENTRY pEntry) */
19 /* char QQ_PushTail(PQQ_CONTAINER pQueue, PQQ_ENTRY pEntry) */
20 /* PQQ_ENTRY QQ_PopHead(PQQ_CONTAINER pQueue) */
21 /* PQQ_ENTRY QQ_PopTail(PQQ_CONTAINER pQueue) */
22 /* PQQ_ENTRY QQ_GetHead(PQQ_CONTAINER pQueue, unsigned int Idx) */
23 /* PQQ_ENTRY QQ_GetTail(PQQ_CONTAINER pQueue, unsigned int Idx) */
24 /* */
25 /* */
26 /* History: */
27 /* 02/25/00 Hav Khauv Initial version. */
28 /******************************************************************************/
29
30 #ifndef BCM_QUEUE_H
31 #define BCM_QUEUE_H
32 #ifndef EMBEDDED
33 #define EMBEDDED 1
34 #endif
35
36 /******************************************************************************/
37 /* Queue definitions. */
38 /******************************************************************************/
39
40 /* Entry for queueing. */
41 typedef void *PQQ_ENTRY;
42
43 /* Linux Atomic Ops support */
44 typedef struct { int counter; } atomic_t;
45
46
47 /*
48 * This combination of `inline' and `extern' has almost the effect of a
49 * macro. The way to use it is to put a function definition in a header
50 * file with these keywords, and put another copy of the definition
51 * (lacking `inline' and `extern') in a library file. The definition in
52 * the header file will cause most calls to the function to be inlined.
53 * If any uses of the function remain, they will refer to the single copy
54 * in the library.
55 */
56 extern __inline void
57 atomic_set(atomic_t* entry, int val)
58 {
59 entry->counter = val;
60 }
61 extern __inline int
62 atomic_read(atomic_t* entry)
63 {
64 return entry->counter;
65 }
66 extern __inline void
67 atomic_inc(atomic_t* entry)
68 {
69 if(entry)
70 entry->counter++;
71 }
72
73 extern __inline void
74 atomic_dec(atomic_t* entry)
75 {
76 if(entry)
77 entry->counter--;
78 }
79
80 extern __inline void
81 atomic_sub(int a, atomic_t* entry)
82 {
83 if(entry)
84 entry->counter -= a;
85 }
86 extern __inline void
87 atomic_add(int a, atomic_t* entry)
88 {
89 if(entry)
90 entry->counter += a;
91 }
92
93
94 /* Queue header -- base type. */
95 typedef struct {
96 unsigned int Head;
97 unsigned int Tail;
98 unsigned int Size;
99 atomic_t EntryCnt;
100 PQQ_ENTRY Array[1];
101 } QQ_CONTAINER, *PQQ_CONTAINER;
102
103
104 /* Declare queue type macro. */
105 #define DECLARE_QUEUE_TYPE(_QUEUE_TYPE, _QUEUE_SIZE) \
106 \
107 typedef struct { \
108 QQ_CONTAINER Container; \
109 PQQ_ENTRY EntryBuffer[_QUEUE_SIZE]; \
110 } _QUEUE_TYPE, *P##_QUEUE_TYPE
111
112
113 /******************************************************************************/
114 /* Compilation switches. */
115 /******************************************************************************/
116
117 #if DBG
118 #undef QQ_NO_OVERFLOW_CHECK
119 #undef QQ_NO_UNDERFLOW_CHECK
120 #endif /* DBG */
121
122 #ifdef QQ_USE_MACROS
123 /* notdone */
124 #else
125
126 #ifdef QQ_NO_INLINE
127 #define __inline
128 #endif /* QQ_NO_INLINE */
129
130 /******************************************************************************/
131 /* Description: */
132 /* */
133 /* Return: */
134 /******************************************************************************/
135 extern __inline void
136 QQ_InitQueue(
137 PQQ_CONTAINER pQueue,
138 unsigned int QueueSize) {
139 pQueue->Head = 0;
140 pQueue->Tail = 0;
141 pQueue->Size = QueueSize+1;
142 atomic_set(&pQueue->EntryCnt, 0);
143 } /* QQ_InitQueue */
144
145
146 /******************************************************************************/
147 /* Description: */
148 /* */
149 /* Return: */
150 /******************************************************************************/
151 extern __inline char
152 QQ_Full(
153 PQQ_CONTAINER pQueue) {
154 unsigned int NewHead;
155
156 NewHead = (pQueue->Head + 1) % pQueue->Size;
157
158 return(NewHead == pQueue->Tail);
159 } /* QQ_Full */
160
161
162 /******************************************************************************/
163 /* Description: */
164 /* */
165 /* Return: */
166 /******************************************************************************/
167 extern __inline char
168 QQ_Empty(
169 PQQ_CONTAINER pQueue) {
170 return(pQueue->Head == pQueue->Tail);
171 } /* QQ_Empty */
172
173
174 /******************************************************************************/
175 /* Description: */
176 /* */
177 /* Return: */
178 /******************************************************************************/
179 extern __inline unsigned int
180 QQ_GetSize(
181 PQQ_CONTAINER pQueue) {
182 return pQueue->Size;
183 } /* QQ_GetSize */
184
185
186 /******************************************************************************/
187 /* Description: */
188 /* */
189 /* Return: */
190 /******************************************************************************/
191 extern __inline unsigned int
192 QQ_GetEntryCnt(
193 PQQ_CONTAINER pQueue) {
194 return atomic_read(&pQueue->EntryCnt);
195 } /* QQ_GetEntryCnt */
196
197
198 /******************************************************************************/
199 /* Description: */
200 /* */
201 /* Return: */
202 /* TRUE entry was added successfully. */
203 /* FALSE queue is full. */
204 /******************************************************************************/
205 extern __inline char
206 QQ_PushHead(
207 PQQ_CONTAINER pQueue,
208 PQQ_ENTRY pEntry) {
209 unsigned int Head;
210
211 Head = (pQueue->Head + 1) % pQueue->Size;
212
213 #if !defined(QQ_NO_OVERFLOW_CHECK)
214 if(Head == pQueue->Tail) {
215 return 0;
216 } /* if */
217 #endif /* QQ_NO_OVERFLOW_CHECK */
218
219 pQueue->Array[pQueue->Head] = pEntry;
220 wmb();
221 pQueue->Head = Head;
222 atomic_inc(&pQueue->EntryCnt);
223
224 return -1;
225 } /* QQ_PushHead */
226
227
228 /******************************************************************************/
229 /* Description: */
230 /* */
231 /* Return: */
232 /* TRUE entry was added successfully. */
233 /* FALSE queue is full. */
234 /******************************************************************************/
235 extern __inline char
236 QQ_PushTail(
237 PQQ_CONTAINER pQueue,
238 PQQ_ENTRY pEntry) {
239 unsigned int Tail;
240
241 Tail = pQueue->Tail;
242 if(Tail == 0) {
243 Tail = pQueue->Size;
244 } /* if */
245 Tail--;
246
247 #if !defined(QQ_NO_OVERFLOW_CHECK)
248 if(Tail == pQueue->Head) {
249 return 0;
250 } /* if */
251 #endif /* QQ_NO_OVERFLOW_CHECK */
252
253 pQueue->Array[Tail] = pEntry;
254 wmb();
255 pQueue->Tail = Tail;
256 atomic_inc(&pQueue->EntryCnt);
257
258 return -1;
259 } /* QQ_PushTail */
260
261
262 /******************************************************************************/
263 /* Description: */
264 /* */
265 /* Return: */
266 /******************************************************************************/
267 extern __inline PQQ_ENTRY
268 QQ_PopHead(
269 PQQ_CONTAINER pQueue) {
270 unsigned int Head;
271 PQQ_ENTRY Entry;
272
273 Head = pQueue->Head;
274
275 #if !defined(QQ_NO_UNDERFLOW_CHECK)
276 if(Head == pQueue->Tail) {
277 return (PQQ_ENTRY) 0;
278 } /* if */
279 #endif /* QQ_NO_UNDERFLOW_CHECK */
280
281 if(Head == 0) {
282 Head = pQueue->Size;
283 } /* if */
284 Head--;
285
286 Entry = pQueue->Array[Head];
287 #ifdef EMBEDDED
288 membar();
289 #else
290 mb();
291 #endif
292 pQueue->Head = Head;
293 atomic_dec(&pQueue->EntryCnt);
294
295 return Entry;
296 } /* QQ_PopHead */
297
298
299 /******************************************************************************/
300 /* Description: */
301 /* */
302 /* Return: */
303 /******************************************************************************/
304 extern __inline PQQ_ENTRY
305 QQ_PopTail(
306 PQQ_CONTAINER pQueue) {
307 unsigned int Tail;
308 PQQ_ENTRY Entry;
309
310 Tail = pQueue->Tail;
311
312 #if !defined(QQ_NO_UNDERFLOW_CHECK)
313 if(Tail == pQueue->Head) {
314 return (PQQ_ENTRY) 0;
315 } /* if */
316 #endif /* QQ_NO_UNDERFLOW_CHECK */
317
318 Entry = pQueue->Array[Tail];
319 #ifdef EMBEDDED
320 membar();
321 #else
322 mb();
323 #endif
324 pQueue->Tail = (Tail + 1) % pQueue->Size;
325 atomic_dec(&pQueue->EntryCnt);
326
327 return Entry;
328 } /* QQ_PopTail */
329
330
331 /******************************************************************************/
332 /* Description: */
333 /* */
334 /* Return: */
335 /******************************************************************************/
336 extern __inline PQQ_ENTRY
337 QQ_GetHead(
338 PQQ_CONTAINER pQueue,
339 unsigned int Idx)
340 {
341 if(Idx >= atomic_read(&pQueue->EntryCnt))
342 {
343 return (PQQ_ENTRY) 0;
344 }
345
346 if(pQueue->Head > Idx)
347 {
348 Idx = pQueue->Head - Idx;
349 }
350 else
351 {
352 Idx = pQueue->Size - (Idx - pQueue->Head);
353 }
354 Idx--;
355
356 return pQueue->Array[Idx];
357 }
358
359
360 /******************************************************************************/
361 /* Description: */
362 /* */
363 /* Return: */
364 /******************************************************************************/
365 extern __inline PQQ_ENTRY
366 QQ_GetTail(
367 PQQ_CONTAINER pQueue,
368 unsigned int Idx)
369 {
370 if(Idx >= atomic_read(&pQueue->EntryCnt))
371 {
372 return (PQQ_ENTRY) 0;
373 }
374
375 Idx += pQueue->Tail;
376 if(Idx >= pQueue->Size)
377 {
378 Idx = Idx - pQueue->Size;
379 }
380
381 return pQueue->Array[Idx];
382 }
383
384 #endif /* QQ_USE_MACROS */
385
386
387 #endif /* QUEUE_H */