Line data    Source code

       1             : /* SPDX-License-Identifier: GPL-2.0 */
       2             : #ifndef _LINUX_UNALIGNED_ACCESS_OK_H
       3             : #define _LINUX_UNALIGNED_ACCESS_OK_H
       4             : 
       5             : #include <linux/kernel.h>
       6             : #include <asm/byteorder.h>
       7             : 
       8           0 : static __always_inline u16 get_unaligned_le16(const void *p)
       9             : {
      10           0 :         return le16_to_cpup((__le16 *)p);
      11             : }
      12             : 
      13           8 : static __always_inline u32 get_unaligned_le32(const void *p)
      14             : {
      15           8 :         return le32_to_cpup((__le32 *)p);
      16             : }
      17             : 
      18         129 : static __always_inline u64 get_unaligned_le64(const void *p)
      19             : {
      20         129 :         return le64_to_cpup((__le64 *)p);
      21             : }
      22             : 
      23          19 : static __always_inline u16 get_unaligned_be16(const void *p)
      24             : {
      25          19 :         return be16_to_cpup((__be16 *)p);
      26             : }
      27             : 
      28          40 : static __always_inline u32 get_unaligned_be32(const void *p)
      29             : {
      30          40 :         return be32_to_cpup((__be32 *)p);
      31             : }
      32             : 
      33           0 : static __always_inline u64 get_unaligned_be64(const void *p)
      34             : {
      35           0 :         return be64_to_cpup((__be64 *)p);
      36             : }
      37             : 
      38             : static __always_inline void put_unaligned_le16(u16 val, void *p)
      39             : {
      40             :         *((__le16 *)p) = cpu_to_le16(val);
      41             : }
      42             : 
      43       61804 : static __always_inline void put_unaligned_le32(u32 val, void *p)
      44             : {
      45       61804 :         *((__le32 *)p) = cpu_to_le32(val);
      46             : }
      47             : 
      48           0 : static __always_inline void put_unaligned_le64(u64 val, void *p)
      49             : {
      50           0 :         *((__le64 *)p) = cpu_to_le64(val);
      51             : }
      52             : 
      53           0 : static __always_inline void put_unaligned_be16(u16 val, void *p)
      54             : {
      55           0 :         *((__be16 *)p) = cpu_to_be16(val);
      56           0 : }
      57             : 
      58           0 : static __always_inline void put_unaligned_be32(u32 val, void *p)
      59             : {
      60           0 :         *((__be32 *)p) = cpu_to_be32(val);
      61           0 : }
      62             : 
      63           0 : static __always_inline void put_unaligned_be64(u64 val, void *p)
      64             : {
      65           0 :         *((__be64 *)p) = cpu_to_be64(val);
      66           0 : }
      67             : 
      68             : #endif /* _LINUX_UNALIGNED_ACCESS_OK_H */