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