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