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