Don't include linux/config.h from anywhere else in include/
[linux-2.6.git] / include / asm-frv / unaligned.h
1 /* unaligned.h: unaligned access handler
2  *
3  * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.
4  * Written by David Howells (dhowells@redhat.com)
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version
9  * 2 of the License, or (at your option) any later version.
10  */
11
12 #ifndef _ASM_UNALIGNED_H
13 #define _ASM_UNALIGNED_H
14
15
16 /*
17  * Unaligned accesses on uClinux can't be performed in a fault handler - the
18  * CPU detects them as imprecise exceptions making this impossible.
19  *
20  * With the FR451, however, they are precise, and so we used to fix them up in
21  * the memory access fault handler.  However, instruction bundling make this
22  * impractical.  So, now we fall back to using memcpy.
23  */
24 #ifdef CONFIG_MMU
25
26 /*
27  * The asm statement in the macros below is a way to get GCC to copy a
28  * value from one variable to another without having any clue it's
29  * actually doing so, so that it won't have any idea that the values
30  * in the two variables are related.
31  */
32
33 #define get_unaligned(ptr) ({                           \
34         typeof((*(ptr))) __x;                           \
35         void *__ptrcopy;                                \
36         asm("" : "=r" (__ptrcopy) : "0" (ptr));         \
37         memcpy(&__x, __ptrcopy, sizeof(*(ptr)));        \
38         __x;                                            \
39 })
40
41 #define put_unaligned(val, ptr) ({                      \
42         typeof((*(ptr))) __x = (val);                   \
43         void *__ptrcopy;                                \
44         asm("" : "=r" (__ptrcopy) : "0" (ptr));         \
45         memcpy(__ptrcopy, &__x, sizeof(*(ptr)));        \
46 })
47
48 extern int handle_misalignment(unsigned long esr0, unsigned long ear0, unsigned long epcr0);
49
50 #else
51
52 #define get_unaligned(ptr)                                                      \
53 ({                                                                              \
54         typeof(*(ptr)) x;                                                       \
55         const char *__p = (const char *) (ptr);                                 \
56                                                                                 \
57         switch (sizeof(x)) {                                                    \
58         case 1:                                                                 \
59                 x = *(ptr);                                                     \
60                 break;                                                          \
61         case 2:                                                                 \
62         {                                                                       \
63                 uint8_t a;                                                      \
64                 asm("   ldub%I2         %M2,%0          \n"                     \
65                     "   ldub%I3.p       %M3,%1          \n"                     \
66                     "   slli            %0,#8,%0        \n"                     \
67                     "   or              %0,%1,%0        \n"                     \
68                     : "=&r"(x), "=&r"(a)                                        \
69                     : "m"(__p[0]),  "m"(__p[1])                                 \
70                     );                                                          \
71                 break;                                                          \
72         }                                                                       \
73                                                                                 \
74         case 4:                                                                 \
75         {                                                                       \
76                 uint8_t a;                                                      \
77                 asm("   ldub%I2         %M2,%0          \n"                     \
78                     "   ldub%I3.p       %M3,%1          \n"                     \
79                     "   slli            %0,#8,%0        \n"                     \
80                     "   or              %0,%1,%0        \n"                     \
81                     "   ldub%I4.p       %M4,%1          \n"                     \
82                     "   slli            %0,#8,%0        \n"                     \
83                     "   or              %0,%1,%0        \n"                     \
84                     "   ldub%I5.p       %M5,%1          \n"                     \
85                     "   slli            %0,#8,%0        \n"                     \
86                     "   or              %0,%1,%0        \n"                     \
87                     : "=&r"(x), "=&r"(a)                                        \
88                     : "m"(__p[0]),  "m"(__p[1]), "m"(__p[2]), "m"(__p[3])       \
89                     );                                                          \
90                 break;                                                          \
91         }                                                                       \
92                                                                                 \
93         case 8:                                                                 \
94         {                                                                       \
95                 union { uint64_t x; u32 y[2]; } z;                              \
96                 uint8_t a;                                                      \
97                 asm("   ldub%I3         %M3,%0          \n"                     \
98                     "   ldub%I4.p       %M4,%2          \n"                     \
99                     "   slli            %0,#8,%0        \n"                     \
100                     "   or              %0,%2,%0        \n"                     \
101                     "   ldub%I5.p       %M5,%2          \n"                     \
102                     "   slli            %0,#8,%0        \n"                     \
103                     "   or              %0,%2,%0        \n"                     \
104                     "   ldub%I6.p       %M6,%2          \n"                     \
105                     "   slli            %0,#8,%0        \n"                     \
106                     "   or              %0,%2,%0        \n"                     \
107                     "   ldub%I7         %M7,%1          \n"                     \
108                     "   ldub%I8.p       %M8,%2          \n"                     \
109                     "   slli            %1,#8,%1        \n"                     \
110                     "   or              %1,%2,%1        \n"                     \
111                     "   ldub%I9.p       %M9,%2          \n"                     \
112                     "   slli            %1,#8,%1        \n"                     \
113                     "   or              %1,%2,%1        \n"                     \
114                     "   ldub%I10.p      %M10,%2         \n"                     \
115                     "   slli            %1,#8,%1        \n"                     \
116                     "   or              %1,%2,%1        \n"                     \
117                     : "=&r"(z.y[0]), "=&r"(z.y[1]), "=&r"(a)                    \
118                     : "m"(__p[0]), "m"(__p[1]), "m"(__p[2]), "m"(__p[3]),       \
119                       "m"(__p[4]), "m"(__p[5]), "m"(__p[6]), "m"(__p[7])        \
120                     );                                                          \
121                 x = z.x;                                                        \
122                 break;                                                          \
123         }                                                                       \
124                                                                                 \
125         default:                                                                \
126                 x = 0;                                                          \
127                 BUG();                                                          \
128                 break;                                                          \
129         }                                                                       \
130                                                                                 \
131         x;                                                                      \
132 })
133
134 #define put_unaligned(val, ptr)                                                         \
135 do {                                                                                    \
136         char *__p = (char *) (ptr);                                                     \
137         int x;                                                                          \
138                                                                                         \
139         switch (sizeof(*ptr)) {                                                         \
140         case 2:                                                                         \
141         {                                                                               \
142                 asm("   stb%I1.p        %0,%M1          \n"                             \
143                     "   srli            %0,#8,%0        \n"                             \
144                     "   stb%I2          %0,%M2          \n"                             \
145                     : "=r"(x), "=m"(__p[1]),  "=m"(__p[0])                              \
146                     : "0"(val)                                                          \
147                     );                                                                  \
148                 break;                                                                  \
149         }                                                                               \
150                                                                                         \
151         case 4:                                                                         \
152         {                                                                               \
153                 asm("   stb%I1.p        %0,%M1          \n"                             \
154                     "   srli            %0,#8,%0        \n"                             \
155                     "   stb%I2.p        %0,%M2          \n"                             \
156                     "   srli            %0,#8,%0        \n"                             \
157                     "   stb%I3.p        %0,%M3          \n"                             \
158                     "   srli            %0,#8,%0        \n"                             \
159                     "   stb%I4          %0,%M4          \n"                             \
160                     : "=r"(x), "=m"(__p[3]),  "=m"(__p[2]), "=m"(__p[1]), "=m"(__p[0])  \
161                     : "0"(val)                                                          \
162                     );                                                                  \
163                 break;                                                                  \
164         }                                                                               \
165                                                                                         \
166         case 8:                                                                         \
167         {                                                                               \
168                 uint32_t __high, __low;                                                 \
169                 __high = (uint64_t)val >> 32;                                           \
170                 __low = val & 0xffffffff;                                               \
171                 asm("   stb%I2.p        %0,%M2          \n"                             \
172                     "   srli            %0,#8,%0        \n"                             \
173                     "   stb%I3.p        %0,%M3          \n"                             \
174                     "   srli            %0,#8,%0        \n"                             \
175                     "   stb%I4.p        %0,%M4          \n"                             \
176                     "   srli            %0,#8,%0        \n"                             \
177                     "   stb%I5.p        %0,%M5          \n"                             \
178                     "   srli            %0,#8,%0        \n"                             \
179                     "   stb%I6.p        %1,%M6          \n"                             \
180                     "   srli            %1,#8,%1        \n"                             \
181                     "   stb%I7.p        %1,%M7          \n"                             \
182                     "   srli            %1,#8,%1        \n"                             \
183                     "   stb%I8.p        %1,%M8          \n"                             \
184                     "   srli            %1,#8,%1        \n"                             \
185                     "   stb%I9          %1,%M9          \n"                             \
186                     : "=&r"(__low), "=&r"(__high), "=m"(__p[7]), "=m"(__p[6]),          \
187                       "=m"(__p[5]), "=m"(__p[4]), "=m"(__p[3]), "=m"(__p[2]),           \
188                       "=m"(__p[1]), "=m"(__p[0])                                        \
189                     : "0"(__low), "1"(__high)                                           \
190                     );                                                                  \
191                 break;                                                                  \
192         }                                                                               \
193                                                                                         \
194         default:                                                                        \
195                 *(ptr) = (val);                                                         \
196                 break;                                                                  \
197         }                                                                               \
198 } while(0)
199
200 #endif
201
202 #endif