[DAPL2] sync with WinOF 2.1 branch
[mirror/winof/.git] / inc / complib / cl_byteswap.h
1 /*\r
2  * Copyright (c) 2005 SilverStorm Technologies.  All rights reserved.\r
3  * Copyright (c) 1996-2003 Intel Corporation. All rights reserved. \r
4  *\r
5  * This software is available to you under the OpenIB.org BSD license\r
6  * below:\r
7  *\r
8  *     Redistribution and use in source and binary forms, with or\r
9  *     without modification, are permitted provided that the following\r
10  *     conditions are met:\r
11  *\r
12  *      - Redistributions of source code must retain the above\r
13  *        copyright notice, this list of conditions and the following\r
14  *        disclaimer.\r
15  *\r
16  *      - Redistributions in binary form must reproduce the above\r
17  *        copyright notice, this list of conditions and the following\r
18  *        disclaimer in the documentation and/or other materials\r
19  *        provided with the distribution.\r
20  *\r
21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
22  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
23  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
24  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
25  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
26  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
27  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
28  * SOFTWARE.\r
29  *\r
30  * $Id$\r
31  */\r
32 \r
33 \r
34 /*\r
35  * Abstract:\r
36  *      provides byteswapping utilities. Basic fuctions are obtained from platform\r
37  *  specific implementations from ibyteswap_osd.h.\r
38  *\r
39  * Environment:\r
40  *      All\r
41  */\r
42 \r
43 \r
44 #ifndef _CL_BYTESWAP_H_\r
45 #define _CL_BYTESWAP_H_\r
46 \r
47 \r
48 #include <complib/cl_memory.h>\r
49 #include <complib/cl_byteswap_osd.h>\r
50 \r
51 \r
52 /****h* Component Library/Byte Swapping\r
53 * NAME\r
54 *       Byte Swapping\r
55 *\r
56 * DESCRIPTION\r
57 *       The byte swapping functions and macros allow swapping bytes from network\r
58 *       byte order to host byte order.\r
59 *\r
60 *       All data transmitted between systems should be in network byte order.\r
61 *       In order to utilize such data, it must be converted to host byte order\r
62 *       before use.\r
63 *\r
64 * SEE ALSO\r
65 *       Functions:\r
66 *               cl_ntoh16, cl_hton16, cl_ntoh32, cl_hton32, cl_ntoh64, cl_hton64,\r
67 *               cl_ntoh\r
68 *\r
69 *       Macros:\r
70 *               CL_NTOH16, CL_HTON16, CL_NTOH32, CL_HTON32, CL_NTOH64, CL_HTON64\r
71 *********/\r
72 \r
73 \r
74 /*\r
75  * The ibyteswap_osd.h provides the following macros.\r
76  *              __LITTLE_ENDIAN\r
77  *              __BIG_ENDIAN\r
78  *              __BYTE_ORDER\r
79  *\r
80  * If the platform provides byte swapping functions, ibyteswap_osd.h also\r
81  * provides the following macros.\r
82  *              ntoh16, hton16\r
83  *              ntoh32, hton32\r
84  *              ntoh64, hton64\r
85  */\r
86 \r
87 #ifdef __cplusplus\r
88 extern "C"\r
89 {\r
90 #endif\r
91 \r
92 \r
93 /****d* Component Library: Byte Swapping/CL_NTOH16\r
94 * NAME\r
95 *       CL_NTOH16\r
96 *\r
97 * DESCRIPTION\r
98 *       The CL_NTOH16 macro converts a 16-bit value from network byte order to\r
99 *       host byte order.  The CL_NTOH16 macro will cause constant values to be\r
100 *       swapped by the pre-processor.  For variables, CL_NTOH16 is less efficient\r
101 *       than the cl_ntoh16 function.\r
102 *\r
103 * SYNOPSIS\r
104 *       CL_NTOH16( val );\r
105 *\r
106 * PARAMETERS\r
107 *       val\r
108 *               [in] 16-bit value to swap from network byte order to host byte order.\r
109 *\r
110 * RESULT\r
111 *       Value of val converted to host byte order.\r
112 *\r
113 * NOTES\r
114 *       This macro is analogous to CL_HTON16.\r
115 *\r
116 * SEE ALSO\r
117 *       Byte Swapping, CL_HTON16, CL_NTOH32, CL_NTOH64,\r
118 *       cl_ntoh16, cl_ntoh32, cl_ntoh64, cl_ntoh\r
119 *********/\r
120 /****d* Component Library: Byte Swapping/CL_HTON16\r
121 * NAME\r
122 *       CL_HTON16\r
123 *\r
124 * DESCRIPTION\r
125 *       The CL_HTON16 macro converts a 16-bit value from host byte order to\r
126 *       network byte order.  The CL_HTON16 macro will cause constant values to be\r
127 *       swapped by the pre-processor.  For variables, CL_HTON16 is less efficient\r
128 *       than the cl_hton16 function.\r
129 *\r
130 * SYNOPSIS\r
131 *       CL_HTON16( val );\r
132 *\r
133 * PARAMETERS\r
134 *       val\r
135 *               [in] 16-bit value to swap from host byte order to network byte order.\r
136 *\r
137 * RESULT\r
138 *       Value of val converted to network byte order.\r
139 *\r
140 * NOTES\r
141 *       This macro is analogous to CL_NTOH16.\r
142 *\r
143 * SEE ALSO\r
144 *       Byte Swapping, CL_NTOH16, CL_HTON32, CL_HTON64,\r
145 *       cl_hton16, cl_hton32, cl_hton64, cl_ntoh\r
146 *********/\r
147 #if CPU_LE\r
148         #define CL_NTOH16( x )          (uint16_t)(             \\r
149                         (((uint16_t)(x) & 0x00FF) << 8) |       \\r
150                         (((uint16_t)(x) & 0xFF00) >> 8) )\r
151 #else\r
152         #define CL_NTOH16( x )          (x)\r
153 #endif\r
154 #define CL_HTON16                               CL_NTOH16\r
155 \r
156 \r
157 /****f* Component Library: Byte Swapping/cl_ntoh16\r
158 * NAME\r
159 *       cl_ntoh16\r
160 *\r
161 * DESCRIPTION\r
162 *       The cl_ntoh16 function converts a 16-bit value from network byte order to\r
163 *       host byte order.\r
164 *\r
165 * SYNOPSIS\r
166 *       uint16_t\r
167 *       cl_ntoh16(\r
168 *               IN      const uint16_t  val );\r
169 *\r
170 * PARAMETERS\r
171 *       val\r
172 *               [in] Value to swap from network byte order to host byte order.\r
173 *\r
174 * RETURN VALUE\r
175 *       Value of val converted to host byte order.\r
176 *\r
177 * NOTES\r
178 *       This function is analogous to cl_hton16.\r
179 *\r
180 * SEE ALSO\r
181 *       Byte Swapping, cl_hton16, cl_ntoh32, cl_ntoh64, cl_ntoh\r
182 *********/\r
183 /****f* Component Library: Byte Swapping/cl_hton16\r
184 * NAME\r
185 *       cl_hton16\r
186 *\r
187 * DESCRIPTION\r
188 *       The cl_hton16 function converts a 16-bit value from host byte order to\r
189 *       network byte order.\r
190 *\r
191 * SYNOPSIS\r
192 *       uint16_t\r
193 *       cl_hton16(\r
194 *               IN      const uint16_t  val );\r
195 *\r
196 * PARAMETERS\r
197 *       val\r
198 *               [in] Value to swap from host byte order to network byte order .\r
199 *\r
200 * RETURN VALUE\r
201 *       Value of val converted to network byte order.\r
202 *\r
203 * NOTES\r
204 *       This function is analogous to cl_ntoh16.\r
205 *\r
206 * SEE ALSO\r
207 *       Byte Swapping, cl_ntoh16, cl_hton32, cl_hton64, cl_ntoh\r
208 *********/\r
209 #ifndef cl_ntoh16\r
210         #define cl_ntoh16       CL_NTOH16\r
211         #define cl_hton16       CL_HTON16\r
212 #endif\r
213 \r
214 \r
215 /****d* Component Library: Byte Swapping/CL_NTOH32\r
216 * NAME\r
217 *       CL_NTOH32\r
218 *\r
219 * DESCRIPTION\r
220 *       The CL_NTOH32 macro converts a 32-bit value from network byte order to\r
221 *       host byte order.  The CL_NTOH32 macro will cause constant values to be\r
222 *       swapped by the pre-processor.  For variables, CL_NTOH32 is less efficient\r
223 *       than the cl_ntoh32 function.\r
224 *\r
225 * SYNOPSIS\r
226 *       CL_NTOH32( val );\r
227 *\r
228 * PARAMETERS\r
229 *       val\r
230 *               [in] 32-bit value to swap from network byte order to host byte order.\r
231 *\r
232 * RESULT\r
233 *       Value of val converted to host byte order.\r
234 *\r
235 * NOTES\r
236 *       This macro is analogous to CL_HTON32.\r
237 *\r
238 * SEE ALSO\r
239 *       Byte Swapping, CL_HTON32, CL_NTOH16, CL_NTOH64,\r
240 *       cl_ntoh16, cl_ntoh32, cl_ntoh64, cl_ntoh\r
241 *********/\r
242 /****d* Component Library: Byte Swapping/CL_HTON32\r
243 * NAME\r
244 *       CL_HTON32\r
245 *\r
246 * DESCRIPTION\r
247 *       The CL_HTON32 macro converts a 32-bit value from host byte order to\r
248 *       network byte order.  The CL_HTON32 macro will cause constant values to be\r
249 *       swapped by the pre-processor.  For variables, CL_HTON32 is less efficient\r
250 *       than the cl_hton32 function.\r
251 *\r
252 * SYNOPSIS\r
253 *       CL_HTON32( val );\r
254 *\r
255 * PARAMETERS\r
256 *       val\r
257 *               [in] 32-bit value to swap from host byte order to network byte order.\r
258 *\r
259 * RESULT\r
260 *       Value of val converted to network byte order.\r
261 *\r
262 * NOTES\r
263 *       This macro is analogous to CL_NTOH32.\r
264 *\r
265 * SEE ALSO\r
266 *       Byte Swapping, CL_NTOH32, CL_HTON16, CL_HTON64,\r
267 *       cl_hton16, cl_hton32, cl_hton64, cl_ntoh\r
268 *********/\r
269 #if CPU_LE\r
270         #define CL_NTOH32( x )          (uint32_t)(                     \\r
271                         (((uint32_t)(x) & 0x000000FF) << 24) |  \\r
272                         (((uint32_t)(x) & 0x0000FF00) << 8) |   \\r
273                         (((uint32_t)(x) & 0x00FF0000) >> 8) |   \\r
274                         (((uint32_t)(x) & 0xFF000000) >> 24) )\r
275 #else\r
276         #define CL_NTOH32( x )          (x)\r
277 #endif\r
278 #define CL_HTON32                               CL_NTOH32\r
279 \r
280 \r
281 /****f* Component Library: Byte Swapping/cl_ntoh32\r
282 * NAME\r
283 *       cl_ntoh32\r
284 *\r
285 * DESCRIPTION\r
286 *       The cl_ntoh32 function converts a 32-bit value from network byte order to\r
287 *       host byte order.\r
288 *\r
289 * SYNOPSIS\r
290 *       uint32_t\r
291 *       cl_ntoh32(\r
292 *               IN      const uint32_t  val );\r
293 *\r
294 * PARAMETERS\r
295 *       val\r
296 *               [in] Value to swap from network byte order to host byte order.\r
297 *\r
298 * RETURN VALUE\r
299 *       Value of val converted in host byte order.\r
300 *\r
301 * NOTES\r
302 *       This function is analogous to cl_hton32.\r
303 *\r
304 * SEE ALSO\r
305 *       Byte Swapping, cl_hton32, cl_ntoh16, cl_ntoh64, cl_ntoh\r
306 *********/\r
307 /****f* Component Library: Byte Swapping/cl_hton32\r
308 * NAME\r
309 *       cl_hton32\r
310 *\r
311 * DESCRIPTION\r
312 *       The cl_hton32 function converts a 32-bit value from host byte order to\r
313 *       network byte order.\r
314 *\r
315 * SYNOPSIS\r
316 *       uint32_t\r
317 *       cl_hton32(\r
318 *               IN      const uint32_t  val );\r
319 *\r
320 * PARAMETERS\r
321 *       val\r
322 *               [in] Value to swap from host byte order to network byte order .\r
323 *\r
324 * RETURN VALUE\r
325 *       Value of val converted to network byte order.\r
326 *\r
327 * NOTES\r
328 *       This function is analogous to cl_ntoh32.\r
329 *\r
330 * SEE ALSO\r
331 *       Byte Swapping, cl_ntoh32, cl_hton16, cl_hton64, cl_ntoh\r
332 *********/\r
333 #ifndef cl_ntoh32\r
334         #define cl_ntoh32       CL_NTOH32\r
335         #define cl_hton32       CL_HTON32\r
336 #endif\r
337 \r
338 \r
339 /****d* Component Library: Byte Swapping/CL_NTOH64\r
340 * NAME\r
341 *       CL_NTOH64\r
342 *\r
343 * DESCRIPTION\r
344 *       The CL_NTOH64 macro converts a 64-bit value from network byte order to\r
345 *       host byte order.  The CL_NTOH64 macro will cause constant values to be\r
346 *       swapped by the pre-processor.  For variables, CL_NTOH64 is less efficient\r
347 *       than the cl_ntoh64 function.\r
348 *\r
349 * SYNOPSIS\r
350 *       CL_NTOH64( val );\r
351 *\r
352 * PARAMETERS\r
353 *       val\r
354 *               [in] 64-bit value to swap from network byte order to host byte order.\r
355 *\r
356 * RESULT\r
357 *       Value of val converted to host byte order.\r
358 *\r
359 * NOTES\r
360 *       This macro is analogous to CL_HTON64.\r
361 *\r
362 * SEE ALSO\r
363 *       Byte Swapping, CL_HTON64, CL_NTOH16, CL_NTOH32,\r
364 *       cl_ntoh16, cl_ntoh32, cl_ntoh64, cl_ntoh\r
365 *********/\r
366 /****d* Component Library: Byte Swapping/CL_HTON64\r
367 * NAME\r
368 *       CL_HTON64\r
369 *\r
370 * DESCRIPTION\r
371 *       The CL_HTON64 macro converts a 64-bit value from host byte order to\r
372 *       network byte order.  The CL_HTON64 macro will cause constant values to be\r
373 *       swapped by the pre-processor.  For variables, CL_HTON64 is less efficient\r
374 *       than the cl_hton64 function.\r
375 *\r
376 * SYNOPSIS\r
377 *       CL_HTON64( val );\r
378 *\r
379 * PARAMETERS\r
380 *       val\r
381 *               [in] 64-bit value to swap from host byte order to network byte order.\r
382 *\r
383 * RESULT\r
384 *       Value of val converted to network byte order.\r
385 *\r
386 * NOTES\r
387 *       This macro is analogous to CL_NTOH64.\r
388 *\r
389 * SEE ALSO\r
390 *       Byte Swapping, CL_NTOH64, CL_HTON16, CL_HTON32,\r
391 *       cl_hton16, cl_hton32, cl_hton64, cl_ntoh\r
392 *********/\r
393 #if CPU_LE\r
394         #define CL_NTOH64( x )          (uint64_t)(                                     \\r
395                         (((uint64_t)(x) & CL_CONST64(0x00000000000000FF)) << 56) |      \\r
396                         (((uint64_t)(x) & CL_CONST64(0x000000000000FF00)) << 40) |      \\r
397                         (((uint64_t)(x) & CL_CONST64(0x0000000000FF0000)) << 24) |      \\r
398                         (((uint64_t)(x) & CL_CONST64(0x00000000FF000000)) << 8 ) |      \\r
399                         (((uint64_t)(x) & CL_CONST64(0x000000FF00000000)) >> 8 ) |      \\r
400                         (((uint64_t)(x) & CL_CONST64(0x0000FF0000000000)) >> 24) |      \\r
401                         (((uint64_t)(x) & CL_CONST64(0x00FF000000000000)) >> 40) |      \\r
402                         (((uint64_t)(x) & CL_CONST64(0xFF00000000000000)) >> 56) )\r
403 #else\r
404         #define CL_NTOH64( x )          (x)\r
405 #endif\r
406 #define CL_HTON64                               CL_NTOH64\r
407 \r
408 \r
409 /****f* Component Library: Byte Swapping/cl_ntoh64\r
410 * NAME\r
411 *       cl_ntoh64\r
412 *\r
413 * DESCRIPTION\r
414 *       The cl_ntoh64 function converts a 64-bit value from network byte order to\r
415 *       host byte order.\r
416 *\r
417 * SYNOPSIS\r
418 *       uint64_t\r
419 *       cl_ntoh64(\r
420 *               IN      const uint64_t  val );\r
421 *\r
422 * PARAMETERS\r
423 *       val\r
424 *               [in] Value to swap from network byte order to host byte order.\r
425 *\r
426 * RETURN VALUE\r
427 *       Value of val converted in host byte order.\r
428 *\r
429 * NOTES\r
430 *       This function is analogous to cl_hton64.\r
431 *\r
432 * SEE ALSO\r
433 *       Byte Swapping, cl_hton64, cl_ntoh16, cl_ntoh32, cl_ntoh\r
434 *********/\r
435 /****f* Component Library: Byte Swapping/cl_hton64\r
436 * NAME\r
437 *       cl_hton64\r
438 *\r
439 * DESCRIPTION\r
440 *       The cl_hton64 function converts a 64-bit value from host byte order to\r
441 *       network byte order.\r
442 *\r
443 * SYNOPSIS\r
444 *       uint64_t\r
445 *       cl_hton64(\r
446 *               IN      const uint64_t  val );\r
447 *\r
448 * PARAMETERS\r
449 *       val\r
450 *               [in] Value to swap from host byte order to network byte order .\r
451 *\r
452 * RETURN VALUE\r
453 *       Value of val converted to network byte order.\r
454 *\r
455 * NOTES\r
456 *       This function is analogous to cl_ntoh64.\r
457 *\r
458 * SEE ALSO\r
459 *       Byte Swapping, cl_ntoh64, cl_hton16, cl_hton32, cl_ntoh\r
460 *********/\r
461 #ifndef cl_ntoh64\r
462         #define cl_ntoh64       CL_NTOH64\r
463         #define cl_hton64       CL_HTON64\r
464 #endif\r
465 \r
466 \r
467 /****f* Component Library: Byte Swapping/cl_ntoh\r
468 * NAME\r
469 *       cl_ntoh\r
470 *\r
471 * DESCRIPTION\r
472 *       The cl_ntoh function converts a value from network byte order to\r
473 *       host byte order.\r
474 *\r
475 * SYNOPSIS\r
476 */\r
477 CL_INLINE void CL_API\r
478 cl_ntoh(\r
479         OUT     char* const                     p_dest,\r
480         IN      const char* const       p_src,\r
481         IN      const uint8_t           size )\r
482 {\r
483 #if CPU_LE\r
484         uint8_t i;\r
485         char    temp;\r
486 \r
487         if( p_src == p_dest )\r
488         {\r
489                 /* Swap in place if source and destination are the same. */\r
490                 for( i = 0; i < size / 2; i++ )\r
491                 {\r
492                         temp = p_dest[i];\r
493                         p_dest[i] = p_src[size - 1 - i];\r
494                         p_dest[size - 1 - i] = temp;\r
495                 }\r
496         }\r
497         else\r
498         {\r
499                 for( i = 0; i < size; i++ )\r
500                         p_dest[i] = p_src[size - 1 - i];\r
501         }\r
502 #else\r
503         /*\r
504          * If the source and destination are not the same, copy the source to\r
505          * the destination.\r
506          */\r
507         if( p_src != p_dest )\r
508                 cl_memcpy( p_dest, p_src, size );\r
509 #endif\r
510 }\r
511 /*\r
512 * PARAMETERS\r
513 *       p_dest\r
514 *               [in] Pointer to a byte array to contain the converted value of p_src.\r
515 *\r
516 *       p_src\r
517 *               [in] Pointer to a byte array to be converted from network byte\r
518 *               ordering.\r
519 *\r
520 *       size\r
521 *               [in] Number of bytes to swap.p_dest\r
522 *\r
523 * RETURN VALUE\r
524 *       This function does not return a value.\r
525 *\r
526 * NOTES\r
527 *       cl_ntoh can perform in place swapping if both p_src and p_dest point to\r
528 *       the same buffer.\r
529 *\r
530 * SEE ALSO\r
531 *       Byte Swapping, cl_ntoh16, cl_ntoh32, cl_ntoh64\r
532 *********/\r
533 \r
534 \r
535 #ifdef __cplusplus\r
536 }       /* extern "C" */\r
537 #endif\r
538 \r
539 #endif /* _CL_BYTESWAP_H_ */\r