lkml.org 
[lkml]   [2008]   [Mar]   [20]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Subject[PATCH] kernel: create linux/unaligned.h
    From
    Date
    Add helpers for the following two patterns currently found in the
    kernel:

    le32_to_cpu(get_unaligned((__le32 *)p));
    put_unaligned(cpu_to_le32(x), (__le32 *)p);

    Becomes:
    le32_to_cpu_unaligned(p);
    cpu_to_le32_unaligned(x, p);

    There are also some hand-rolled functions implementing this
    with byte-shifts that can be replaced. To avoid new indirect
    includes of asm/unaligned.h, create linux/unaligned.h to make
    it opt in for new code that wants to use these helpers.

    Signed-off-by: Harvey Harrison <harvey.harrison@gmail.com>
    ---
    This is a rollup of all the previous ones, added kerneldocs and
    have CC'd Randy.
    include/linux/unaligned.h | 138 +++++++++++++++++++++++++++++++++++++++++++++
    1 files changed, 138 insertions(+), 0 deletions(-)
    diff --git a/include/linux/unaligned.h b/include/linux/unaligned.h
    new file mode 100644
    index 0000000..035c1c7
    --- /dev/null
    +++ b/include/linux/unaligned.h
    @@ -0,0 +1,138 @@
    +#ifndef _LINUX_UNALIGNED_H_
    +#define _LINUX_UNALIGNED_H_
    +
    +#include <linux/types.h>
    +#include <asm/byteorder.h>
    +#include <asm/unaligned.h>
    +
    +#ifdef __KERNEL__
    +
    +/**
    + * le64_to_cpu_unaligned - read a le64 from a possibly unaligned pointer
    + * @p: pointer to read from
    + *
    + * Returns a u64 in cpu byteorder
    + */
    +static inline u64 le64_to_cpu_unaligned(void *p)
    +{
    + return le64_to_cpu(get_unaligned((__le64 *)p));
    +}
    +
    +/**
    + * le32_to_cpu_unaligned - read a le32 from a possibly unaligned pointer
    + * @p: pointer to read from
    + *
    + * Returns a u32 in cpu byteorder
    + */
    +static inline u32 le32_to_cpu_unaligned(void *p)
    +{
    + return le32_to_cpu(get_unaligned((__le32 *)p));
    +}
    +
    +/**
    + * le16_to_cpu_unaligned - read a le16 from a possibly unaligned pointer
    + * @p: pointer to read from
    + *
    + * Returns a u16 in cpu byteorder
    + */
    +static inline u16 le16_to_cpu_unaligned(void *p)
    +{
    + return le16_to_cpu(get_unaligned((__le16 *)p));
    +}
    +
    +/**
    + * be64_to_cpu_unaligned - read a be64 from a possibly unaligned pointer
    + * @p: pointer to read from
    + *
    + * Returns a u64 in cpu byteorder
    + */
    +static inline u64 be64_to_cpu_unaligned(void *p)
    +{
    + return be64_to_cpu(get_unaligned((__be64 *)p));
    +}
    +
    +/**
    + * be32_to_cpu_unaligned - read a be32 from a possibly unaligned pointer
    + * @p: pointer to read from
    + *
    + * Returns a u32 in cpu byteorder
    + */
    +static inline u32 be32_to_cpu_unaligned(void *p)
    +{
    + return be32_to_cpu(get_unaligned((__be32 *)p));
    +}
    +
    +/**
    + * be16_to_cpu_unaligned - read a be16 from a possibly unaligned pointer
    + * @p: pointer to read from
    + *
    + * Returns a u16 in cpu byteorder
    + */
    +static inline u16 be16_to_cpu_unaligned(void *p)
    +{
    + return be16_to_cpu(get_unaligned((__be16 *)p));
    +}
    +
    +/**
    + * le64_to_cpu_unaligned - write a u64 in le-byteorder to a possibly unaligned pointer
    + * @val: value to be written
    + * @p: pointer to write to
    + */
    +static inline void cpu_to_le64_unaligned(u64 val, void *p)
    +{
    + put_unaligned(cpu_to_le64(val), (__le64 *)p);
    +}
    +
    +/**
    + * le32_to_cpu_unaligned - write a u32 in le-byteorder to a possibly unaligned pointer
    + * @val: value to be written
    + * @p: pointer to write to
    + */
    +static inline void cpu_to_le32_unaligned(u32 val, void *p)
    +{
    + put_unaligned(cpu_to_le32(val), (__le32 *)p);
    +}
    +
    +/**
    + * le16_to_cpu_unaligned - write a u16 in le-byteorder to a possibly unaligned pointer
    + * @val: value to be written
    + * @p: pointer to write to
    + */
    +static inline void cpu_to_le16_unaligned(u16 val, void *p)
    +{
    + put_unaligned(cpu_to_le16(val), (__le16 *)p);
    +}
    +
    +/**
    + * be64_to_cpu_unaligned - write a u64 in be-byteorder to a possibly unaligned pointer
    + * @val: value to be written
    + * @p: pointer to write to
    + */
    +static inline void cpu_to_be64_unaligned(u64 val, void *p)
    +{
    + put_unaligned(cpu_to_be64(val), (__be64 *)p);
    +}
    +
    +/**
    + * be32_to_cpu_unaligned - write a u32 in be-byteorder to a possibly unaligned pointer
    + * @val: value to be written
    + * @p: pointer to write to
    + */
    +static inline void cpu_to_be32_unaligned(u32 val, void *p)
    +{
    + put_unaligned(cpu_to_be32(val), (__be32 *)p);
    +}
    +
    +/**
    + * be16_to_cpu_unaligned - write a u16 in be-byteorder to a possibly unaligned pointer
    + * @val: value to be written
    + * @p: pointer to write to
    + */
    +static inline void cpu_to_be16_unaligned(u16 val, void *p)
    +{
    + put_unaligned(cpu_to_be16(val), (__be16 *)p);
    +}
    +
    +#endif /* KERNEL */
    +
    +#endif /* _LINUX_UNALIGNED_H */
    --
    1.5.4.4.684.g0e08




    \
     
     \ /
      Last update: 2008-03-20 21:19    [from the cache]
    ©2003-2014 Jasper Spaans. hosted at Digital Ocean