Line data    Source code

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