Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : #ifndef _LINUX_VIRTIO_BYTEORDER_H
       3                 :            : #define _LINUX_VIRTIO_BYTEORDER_H
       4                 :            : #include <linux/types.h>
       5                 :            : #include <uapi/linux/virtio_types.h>
       6                 :            : 
       7                 :          0 : static inline bool virtio_legacy_is_little_endian(void)
       8                 :            : {
       9                 :            : #ifdef __LITTLE_ENDIAN
      10                 :          0 :         return true;
      11                 :            : #else
      12                 :            :         return false;
      13                 :            : #endif
      14                 :            : }
      15                 :            : 
      16                 :          0 : static inline u16 __virtio16_to_cpu(bool little_endian, __virtio16 val)
      17                 :            : {
      18   [ #  #  #  #  :          0 :         if (little_endian)
          #  #  #  #  #  
             #  #  #  #  
                      # ]
      19                 :            :                 return le16_to_cpu((__force __le16)val);
      20                 :            :         else
      21                 :          0 :                 return be16_to_cpu((__force __be16)val);
      22                 :            : }
      23                 :            : 
      24                 :          0 : static inline __virtio16 __cpu_to_virtio16(bool little_endian, u16 val)
      25                 :            : {
      26   [ #  #  #  #  :          0 :         if (little_endian)
          #  #  #  #  #  
             #  #  #  #  
                      # ]
      27                 :            :                 return (__force __virtio16)cpu_to_le16(val);
      28                 :            :         else
      29                 :          0 :                 return (__force __virtio16)cpu_to_be16(val);
      30                 :            : }
      31                 :            : 
      32                 :          0 : static inline u32 __virtio32_to_cpu(bool little_endian, __virtio32 val)
      33                 :            : {
      34   [ #  #  #  #  :          0 :         if (little_endian)
          #  #  #  #  #  
             #  #  #  # ]
      35                 :            :                 return le32_to_cpu((__force __le32)val);
      36                 :            :         else
      37                 :            :                 return be32_to_cpu((__force __be32)val);
      38                 :            : }
      39                 :            : 
      40                 :          0 : static inline __virtio32 __cpu_to_virtio32(bool little_endian, u32 val)
      41                 :            : {
      42   [ #  #  #  # ]:          0 :         if (little_endian)
      43                 :            :                 return (__force __virtio32)cpu_to_le32(val);
      44                 :            :         else
      45                 :            :                 return (__force __virtio32)cpu_to_be32(val);
      46                 :            : }
      47                 :            : 
      48                 :          0 : static inline u64 __virtio64_to_cpu(bool little_endian, __virtio64 val)
      49                 :            : {
      50                 :          0 :         if (little_endian)
      51                 :            :                 return le64_to_cpu((__force __le64)val);
      52                 :            :         else
      53                 :            :                 return be64_to_cpu((__force __be64)val);
      54                 :            : }
      55                 :            : 
      56                 :          0 : static inline __virtio64 __cpu_to_virtio64(bool little_endian, u64 val)
      57                 :            : {
      58                 :          0 :         if (little_endian)
      59                 :            :                 return (__force __virtio64)cpu_to_le64(val);
      60                 :            :         else
      61                 :            :                 return (__force __virtio64)cpu_to_be64(val);
      62                 :            : }
      63                 :            : 
      64                 :            : #endif /* _LINUX_VIRTIO_BYTEORDER */