URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [include/] [asm-ia64/] [unaligned.h] - Blame information for rev 1774

Go to most recent revision | Details | Compare with Previous | View Log


#ifndef _ASM_IA64_UNALIGNED_H
#define _ASM_IA64_UNALIGNED_H
 
#include <linux/types.h>
 
/*
 * The main single-value unaligned transfer routines.
 *
 * Based on <asm-alpha/unaligned.h>.
 *
 * Copyright (C) 1998, 1999, 2003 Hewlett-Packard Co
 *      David Mosberger-Tang <davidm@hpl.hp.com>
 */
#define get_unaligned(ptr) \
        ((__typeof__(*(ptr)))ia64_get_unaligned((ptr), sizeof(*(ptr))))
 
#define put_unaligned(x,ptr) \
        ia64_put_unaligned((unsigned long)(x), (ptr), sizeof(*(ptr)))
 
struct __una_u64 { __u64 x __attribute__((packed)); };
struct __una_u32 { __u32 x __attribute__((packed)); };
struct __una_u16 { __u16 x __attribute__((packed)); };
 
static inline unsigned long
__uld8 (const unsigned long * addr)
{
        const struct __una_u64 *ptr = (const struct __una_u64 *) addr;
        return ptr->x;
}
 
static inline unsigned long
__uld4 (const unsigned int * addr)
{
        const struct __una_u32 *ptr = (const struct __una_u32 *) addr;
        return ptr->x;
}
 
static inline unsigned long
__uld2 (const unsigned short * addr)
{
        const struct __una_u16 *ptr = (const struct __una_u16 *) addr;
        return ptr->x;
}
 
static inline void
__ust8 (unsigned long val, unsigned long * addr)
{
        struct __una_u64 *ptr = (struct __una_u64 *) addr;
        ptr->x = val;
}
 
static inline void
__ust4 (unsigned long val, unsigned int * addr)
{
        struct __una_u32 *ptr = (struct __una_u32 *) addr;
        ptr->x = val;
}
 
static inline void
__ust2 (unsigned long val, unsigned short * addr)
{
        struct __una_u16 *ptr = (struct __una_u16 *) addr;
        ptr->x = val;
}
 
 
/*
 * This function doesn't actually exist.  The idea is that when someone uses the macros
 * below with an unsupported size (datatype), the linker will alert us to the problem via
 * an unresolved reference error.
 */
extern unsigned long ia64_bad_unaligned_access_length (void);
 
#define ia64_get_unaligned(_ptr,size)                                           \
({                                                                              \
        const void *__ia64_ptr = (_ptr);                                        \
        unsigned long __ia64_val;                                               \
                                                                                \
        switch (size) {                                                         \
              case 1:                                                           \
                __ia64_val = *(const unsigned char *) __ia64_ptr;               \
                break;                                                          \
              case 2:                                                           \
                __ia64_val = __uld2((const unsigned short *)__ia64_ptr);        \
                break;                                                          \
              case 4:                                                           \
                __ia64_val = __uld4((const unsigned int *)__ia64_ptr);          \
                break;                                                          \
              case 8:                                                           \
                __ia64_val = __uld8((const unsigned long *)__ia64_ptr);         \
                break;                                                          \
              default:                                                          \
                __ia64_val = ia64_bad_unaligned_access_length();                \
        }                                                                       \
        __ia64_val;                                                             \
})
 
#define ia64_put_unaligned(_val,_ptr,size)                              \
do {                                                                    \
        const void *__ia64_ptr = (_ptr);                                \
        unsigned long __ia64_val = (_val);                              \
                                                                        \
        switch (size) {                                                 \
              case 1:                                                   \
                *(unsigned char *)__ia64_ptr = (__ia64_val);            \
                break;                                                  \
              case 2:                                                   \
                __ust2(__ia64_val, (unsigned short *)__ia64_ptr);       \
                break;                                                  \
              case 4:                                                   \
                __ust4(__ia64_val, (unsigned int *)__ia64_ptr);         \
                break;                                                  \
              case 8:                                                   \
                __ust8(__ia64_val, (unsigned long *)__ia64_ptr);        \
                break;                                                  \
              default:                                                  \
                ia64_bad_unaligned_access_length();                     \
        }                                                               \
} while (0)
 
#endif /* _ASM_IA64_UNALIGNED_H */

Line No.	Rev	Author	Line
1	1275	phoenix	`#ifndef _ASM_IA64_UNALIGNED_H`
2			`#define _ASM_IA64_UNALIGNED_H`
3
4			`#include <linux/types.h>`
5
6			`/*`
7			`* The main single-value unaligned transfer routines.`
8			`*`
9			`* Based on <asm-alpha/unaligned.h>.`
10			`*`
11			`* Copyright (C) 1998, 1999, 2003 Hewlett-Packard Co`
12			`* David Mosberger-Tang <davidm@hpl.hp.com>`
13			`*/`
14			`#define get_unaligned(ptr) \`
15			`((__typeof__((ptr)))ia64_get_unaligned((ptr), sizeof((ptr))))`
16
17			`#define put_unaligned(x,ptr) \`
18			`ia64_put_unaligned((unsigned long)(x), (ptr), sizeof(*(ptr)))`
19
20			`struct __una_u64 { __u64 x __attribute__((packed)); };`
21			`struct __una_u32 { __u32 x __attribute__((packed)); };`
22			`struct __una_u16 { __u16 x __attribute__((packed)); };`
23
24			`static inline unsigned long`
25			`__uld8 (const unsigned long * addr)`
26			`{`
27			`const struct __una_u64 ptr = (const struct __una_u64 ) addr;`
28			`return ptr->x;`
29			`}`
30
31			`static inline unsigned long`
32			`__uld4 (const unsigned int * addr)`
33			`{`
34			`const struct __una_u32 ptr = (const struct __una_u32 ) addr;`
35			`return ptr->x;`
36			`}`
37
38			`static inline unsigned long`
39			`__uld2 (const unsigned short * addr)`
40			`{`
41			`const struct __una_u16 ptr = (const struct __una_u16 ) addr;`
42			`return ptr->x;`
43			`}`
44
45			`static inline void`
46			`__ust8 (unsigned long val, unsigned long * addr)`
47			`{`
48			`struct __una_u64 ptr = (struct __una_u64 ) addr;`
49			`ptr->x = val;`
50			`}`
51
52			`static inline void`
53			`__ust4 (unsigned long val, unsigned int * addr)`
54			`{`
55			`struct __una_u32 ptr = (struct __una_u32 ) addr;`
56			`ptr->x = val;`
57			`}`
58
59			`static inline void`
60			`__ust2 (unsigned long val, unsigned short * addr)`
61			`{`
62			`struct __una_u16 ptr = (struct __una_u16 ) addr;`
63			`ptr->x = val;`
64			`}`
65
66
67			`/*`
68			`* This function doesn't actually exist. The idea is that when someone uses the macros`
69			`* below with an unsupported size (datatype), the linker will alert us to the problem via`
70			`* an unresolved reference error.`
71			`*/`
72			`extern unsigned long ia64_bad_unaligned_access_length (void);`
73
74			`#define ia64_get_unaligned(_ptr,size) \`
75			`({ \`
76			`const void *__ia64_ptr = (_ptr); \`
77			`unsigned long __ia64_val; \`
78			`\`
79			`switch (size) { \`
80			`case 1: \`
81			`__ia64_val = (const unsigned char ) __ia64_ptr; \`
82			`break; \`
83			`case 2: \`
84			`__ia64_val = __uld2((const unsigned short *)__ia64_ptr); \`
85			`break; \`
86			`case 4: \`
87			`__ia64_val = __uld4((const unsigned int *)__ia64_ptr); \`
88			`break; \`
89			`case 8: \`
90			`__ia64_val = __uld8((const unsigned long *)__ia64_ptr); \`
91			`break; \`
92			`default: \`
93			`__ia64_val = ia64_bad_unaligned_access_length(); \`
94			`} \`
95			`__ia64_val; \`
96			`})`
97
98			`#define ia64_put_unaligned(_val,_ptr,size) \`
99			`do { \`
100			`const void *__ia64_ptr = (_ptr); \`
101			`unsigned long __ia64_val = (_val); \`
102			`\`
103			`switch (size) { \`
104			`case 1: \`
105			`(unsigned char )__ia64_ptr = (__ia64_val); \`
106			`break; \`
107			`case 2: \`
108			`__ust2(__ia64_val, (unsigned short *)__ia64_ptr); \`
109			`break; \`
110			`case 4: \`
111			`__ust4(__ia64_val, (unsigned int *)__ia64_ptr); \`
112			`break; \`
113			`case 8: \`
114			`__ust8(__ia64_val, (unsigned long *)__ia64_ptr); \`
115			`break; \`
116			`default: \`
117			`ia64_bad_unaligned_access_length(); \`
118			`} \`
119			`} while (0)`
120
121			`#endif /* _ASM_IA64_UNALIGNED_H */`

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [include/] [asm-ia64/] [unaligned.h] - Blame information for rev 1774