contrib/ofed/management/opensm/include/complib/cl_byteswap.h

   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
 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_ */