OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [freertos-6.1.1/] [Demo/] [Common/] [ethernet/] [FreeRTOS-uIP/] [pt.h] - Blame information for rev 606

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 606 jeremybenn 
/*
2 
 * Copyright (c) 2004-2005, Swedish Institute of Computer Science.
3 
 * All rights reserved.
4 
 *
5 
 * Redistribution and use in source and binary forms, with or without
6 
 * modification, are permitted provided that the following conditions
7 
 * are met:
8 
 * 1. Redistributions of source code must retain the above copyright
9 
 *    notice, this list of conditions and the following disclaimer.
10 
 * 2. Redistributions in binary form must reproduce the above copyright
11 
 *    notice, this list of conditions and the following disclaimer in the
12 
 *    documentation and/or other materials provided with the distribution.
13 
 * 3. Neither the name of the Institute nor the names of its contributors
14 
 *    may be used to endorse or promote products derived from this software
15 
 *    without specific prior written permission.
16 
 *
17 
 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
18 
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
21 
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 
 * SUCH DAMAGE.
28 
 *
29 
 * This file is part of the uIP TCP/IP stack
30 
 *
31 
 * Author: Adam Dunkels <adam@sics.se>
32 
 *
33 
 * $Id: pt.h 2 2011-07-17 20:13:17Z filepang@gmail.com $
34 
 */
35 
 
36 
/**
37 
 * \addtogroup pt
38 
 * @{
39 
 */
40 
 
41 
/**
42 
 * \file
43 
 * Protothreads implementation.
44 
 * \author
45 
 * Adam Dunkels <adam@sics.se>
46 
 *
47 
 */
48 
 
49 
#ifndef __PT_H__
50 
#define __PT_H__
51 
 
52 
#include "lc.h"
53 
 
54 
struct pt {
55 
  lc_t lc;
56 
};
57 
 
58 
#define PT_WAITING 0
59 
#define PT_EXITED  1
60 
#define PT_ENDED   2
61 
#define PT_YIELDED 3
62 
 
63 
/**
64 
 * \name Initialization
65 
 * @{
66 
 */
67 
 
68 
/**
69 
 * Initialize a protothread.
70 
 *
71 
 * Initializes a protothread. Initialization must be done prior to
72 
 * starting to execute the protothread.
73 
 *
74 
 * \param pt A pointer to the protothread control structure.
75 
 *
76 
 * \sa PT_SPAWN()
77 
 *
78 
 * \hideinitializer
79 
 */
80 
#define PT_INIT(pt)   LC_INIT((pt)->lc)
81 
 
82 
/** @} */
83 
 
84 
/**
85 
 * \name Declaration and definition
86 
 * @{
87 
 */
88 
 
89 
/**
90 
 * Declaration of a protothread.
91 
 *
92 
 * This macro is used to declare a protothread. All protothreads must
93 
 * be declared with this macro.
94 
 *
95 
 * \param name_args The name and arguments of the C function
96 
 * implementing the protothread.
97 
 *
98 
 * \hideinitializer
99 
 */
100 
#define PT_THREAD(name_args) char name_args
101 
 
102 
/**
103 
 * Declare the start of a protothread inside the C function
104 
 * implementing the protothread.
105 
 *
106 
 * This macro is used to declare the starting point of a
107 
 * protothread. It should be placed at the start of the function in
108 
 * which the protothread runs. All C statements above the PT_BEGIN()
109 
 * invokation will be executed each time the protothread is scheduled.
110 
 *
111 
 * \param pt A pointer to the protothread control structure.
112 
 *
113 
 * \hideinitializer
114 
 */
115 
#define PT_BEGIN(pt) { char PT_YIELD_FLAG = 1; LC_RESUME((pt)->lc)
116 
 
117 
/**
118 
 * Declare the end of a protothread.
119 
 *
120 
 * This macro is used for declaring that a protothread ends. It must
121 
 * always be used together with a matching PT_BEGIN() macro.
122 
 *
123 
 * \param pt A pointer to the protothread control structure.
124 
 *
125 
 * \hideinitializer
126 
 */
127 
#define PT_END(pt) LC_END((pt)->lc); PT_YIELD_FLAG = 0; \
128 
                   PT_INIT(pt); return PT_ENDED; }
129 
 
130 
/** @} */
131 
 
132 
/**
133 
 * \name Blocked wait
134 
 * @{
135 
 */
136 
 
137 
/**
138 
 * Block and wait until condition is true.
139 
 *
140 
 * This macro blocks the protothread until the specified condition is
141 
 * true.
142 
 *
143 
 * \param pt A pointer to the protothread control structure.
144 
 * \param condition The condition.
145 
 *
146 
 * \hideinitializer
147 
 */
148 
#define PT_WAIT_UNTIL(pt, condition)            \
149 
  do {                                          \
150 
    LC_SET((pt)->lc);                           \
151 
    if(!(condition)) {                          \
152 
      return PT_WAITING;                        \
153 
    }                                           \
154 
  } while(0)
155 
 
156 
/**
157 
 * Block and wait while condition is true.
158 
 *
159 
 * This function blocks and waits while condition is true. See
160 
 * PT_WAIT_UNTIL().
161 
 *
162 
 * \param pt A pointer to the protothread control structure.
163 
 * \param cond The condition.
164 
 *
165 
 * \hideinitializer
166 
 */
167 
#define PT_WAIT_WHILE(pt, cond)  PT_WAIT_UNTIL((pt), !(cond))
168 
 
169 
/** @} */
170 
 
171 
/**
172 
 * \name Hierarchical protothreads
173 
 * @{
174 
 */
175 
 
176 
/**
177 
 * Block and wait until a child protothread completes.
178 
 *
179 
 * This macro schedules a child protothread. The current protothread
180 
 * will block until the child protothread completes.
181 
 *
182 
 * \note The child protothread must be manually initialized with the
183 
 * PT_INIT() function before this function is used.
184 
 *
185 
 * \param pt A pointer to the protothread control structure.
186 
 * \param thread The child protothread with arguments
187 
 *
188 
 * \sa PT_SPAWN()
189 
 *
190 
 * \hideinitializer
191 
 */
192 
#define PT_WAIT_THREAD(pt, thread) PT_WAIT_WHILE((pt), PT_SCHEDULE(thread))
193 
 
194 
/**
195 
 * Spawn a child protothread and wait until it exits.
196 
 *
197 
 * This macro spawns a child protothread and waits until it exits. The
198 
 * macro can only be used within a protothread.
199 
 *
200 
 * \param pt A pointer to the protothread control structure.
201 
 * \param child A pointer to the child protothread's control structure.
202 
 * \param thread The child protothread with arguments
203 
 *
204 
 * \hideinitializer
205 
 */
206 
#define PT_SPAWN(pt, child, thread)             \
207 
  do {                                          \
208 
    PT_INIT((child));                           \
209 
    PT_WAIT_THREAD((pt), (thread));             \
210 
  } while(0)
211 
 
212 
/** @} */
213 
 
214 
/**
215 
 * \name Exiting and restarting
216 
 * @{
217 
 */
218 
 
219 
/**
220 
 * Restart the protothread.
221 
 *
222 
 * This macro will block and cause the running protothread to restart
223 
 * its execution at the place of the PT_BEGIN() call.
224 
 *
225 
 * \param pt A pointer to the protothread control structure.
226 
 *
227 
 * \hideinitializer
228 
 */
229 
#define PT_RESTART(pt)                          \
230 
  do {                                          \
231 
    PT_INIT(pt);                                \
232 
    return PT_WAITING;                  \
233 
  } while(0)
234 
 
235 
/**
236 
 * Exit the protothread.
237 
 *
238 
 * This macro causes the protothread to exit. If the protothread was
239 
 * spawned by another protothread, the parent protothread will become
240 
 * unblocked and can continue to run.
241 
 *
242 
 * \param pt A pointer to the protothread control structure.
243 
 *
244 
 * \hideinitializer
245 
 */
246 
#define PT_EXIT(pt)                             \
247 
  do {                                          \
248 
    PT_INIT(pt);                                \
249 
    return PT_EXITED;                   \
250 
  } while(0)
251 
 
252 
/** @} */
253 
 
254 
/**
255 
 * \name Calling a protothread
256 
 * @{
257 
 */
258 
 
259 
/**
260 
 * Schedule a protothread.
261 
 *
262 
 * This function shedules a protothread. The return value of the
263 
 * function is non-zero if the protothread is running or zero if the
264 
 * protothread has exited.
265 
 *
266 
 * \param f The call to the C function implementing the protothread to
267 
 * be scheduled
268 
 *
269 
 * \hideinitializer
270 
 */
271 
#define PT_SCHEDULE(f) ((f) == PT_WAITING)
272 
 
273 
/** @} */
274 
 
275 
/**
276 
 * \name Yielding from a protothread
277 
 * @{
278 
 */
279 
 
280 
/**
281 
 * Yield from the current protothread.
282 
 *
283 
 * This function will yield the protothread, thereby allowing other
284 
 * processing to take place in the system.
285 
 *
286 
 * \param pt A pointer to the protothread control structure.
287 
 *
288 
 * \hideinitializer
289 
 */
290 
#define PT_YIELD(pt)                            \
291 
  do {                                          \
292 
    PT_YIELD_FLAG = 0;                           \
293 
    LC_SET((pt)->lc);                           \
294 
    if(PT_YIELD_FLAG == 0) {                     \
295 
      return PT_YIELDED;                        \
296 
    }                                           \
297 
  } while(0)
298 
 
299 
/**
300 
 * \brief      Yield from the protothread until a condition occurs.
301 
 * \param pt   A pointer to the protothread control structure.
302 
 * \param cond The condition.
303 
 *
304 
 *             This function will yield the protothread, until the
305 
 *             specified condition evaluates to true.
306 
 *
307 
 *
308 
 * \hideinitializer
309 
 */
310 
#define PT_YIELD_UNTIL(pt, cond)                \
311 
  do {                                          \
312 
    PT_YIELD_FLAG = 0;                           \
313 
    LC_SET((pt)->lc);                           \
314 
    if((PT_YIELD_FLAG == 0) || !(cond)) {        \
315 
      return PT_YIELDED;                        \
316 
    }                                           \
317 
  } while(0)
318 
 
319 
/** @} */
320 
 
321 
#endif /* __PT_H__ */
322 
 
323 
/** @} */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.