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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [include/] [asm-generic/] [xor.h] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 1276 phoenix 
/*
2 
 * include/asm-generic/xor.h
3 
 *
4 
 * Generic optimized RAID-5 checksumming functions.
5 
 *
6 
 * This program is free software; you can redistribute it and/or modify
7 
 * it under the terms of the GNU General Public License as published by
8 
 * the Free Software Foundation; either version 2, or (at your option)
9 
 * any later version.
10 
 *
11 
 * You should have received a copy of the GNU General Public License
12 
 * (for example /usr/src/linux/COPYING); if not, write to the Free
13 
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
14 
 */
15 
 
16 
static void
17 
xor_8regs_2(unsigned long bytes, unsigned long *p1, unsigned long *p2)
18 
{
19 
        long lines = bytes / (sizeof (long)) / 8;
20 
 
21 
        do {
22 
                p1[0] ^= p2[0];
23 
                p1[1] ^= p2[1];
24 
                p1[2] ^= p2[2];
25 
                p1[3] ^= p2[3];
26 
                p1[4] ^= p2[4];
27 
                p1[5] ^= p2[5];
28 
                p1[6] ^= p2[6];
29 
                p1[7] ^= p2[7];
30 
                p1 += 8;
31 
                p2 += 8;
32 
        } while (--lines > 0);
33 
}
34 
 
35 
static void
36 
xor_8regs_3(unsigned long bytes, unsigned long *p1, unsigned long *p2,
37 
            unsigned long *p3)
38 
{
39 
        long lines = bytes / (sizeof (long)) / 8;
40 
 
41 
        do {
42 
                p1[0] ^= p2[0] ^ p3[0];
43 
                p1[1] ^= p2[1] ^ p3[1];
44 
                p1[2] ^= p2[2] ^ p3[2];
45 
                p1[3] ^= p2[3] ^ p3[3];
46 
                p1[4] ^= p2[4] ^ p3[4];
47 
                p1[5] ^= p2[5] ^ p3[5];
48 
                p1[6] ^= p2[6] ^ p3[6];
49 
                p1[7] ^= p2[7] ^ p3[7];
50 
                p1 += 8;
51 
                p2 += 8;
52 
                p3 += 8;
53 
        } while (--lines > 0);
54 
}
55 
 
56 
static void
57 
xor_8regs_4(unsigned long bytes, unsigned long *p1, unsigned long *p2,
58 
            unsigned long *p3, unsigned long *p4)
59 
{
60 
        long lines = bytes / (sizeof (long)) / 8;
61 
 
62 
        do {
63 
                p1[0] ^= p2[0] ^ p3[0] ^ p4[0];
64 
                p1[1] ^= p2[1] ^ p3[1] ^ p4[1];
65 
                p1[2] ^= p2[2] ^ p3[2] ^ p4[2];
66 
                p1[3] ^= p2[3] ^ p3[3] ^ p4[3];
67 
                p1[4] ^= p2[4] ^ p3[4] ^ p4[4];
68 
                p1[5] ^= p2[5] ^ p3[5] ^ p4[5];
69 
                p1[6] ^= p2[6] ^ p3[6] ^ p4[6];
70 
                p1[7] ^= p2[7] ^ p3[7] ^ p4[7];
71 
                p1 += 8;
72 
                p2 += 8;
73 
                p3 += 8;
74 
                p4 += 8;
75 
        } while (--lines > 0);
76 
}
77 
 
78 
static void
79 
xor_8regs_5(unsigned long bytes, unsigned long *p1, unsigned long *p2,
80 
            unsigned long *p3, unsigned long *p4, unsigned long *p5)
81 
{
82 
        long lines = bytes / (sizeof (long)) / 8;
83 
 
84 
        do {
85 
                p1[0] ^= p2[0] ^ p3[0] ^ p4[0] ^ p5[0];
86 
                p1[1] ^= p2[1] ^ p3[1] ^ p4[1] ^ p5[1];
87 
                p1[2] ^= p2[2] ^ p3[2] ^ p4[2] ^ p5[2];
88 
                p1[3] ^= p2[3] ^ p3[3] ^ p4[3] ^ p5[3];
89 
                p1[4] ^= p2[4] ^ p3[4] ^ p4[4] ^ p5[4];
90 
                p1[5] ^= p2[5] ^ p3[5] ^ p4[5] ^ p5[5];
91 
                p1[6] ^= p2[6] ^ p3[6] ^ p4[6] ^ p5[6];
92 
                p1[7] ^= p2[7] ^ p3[7] ^ p4[7] ^ p5[7];
93 
                p1 += 8;
94 
                p2 += 8;
95 
                p3 += 8;
96 
                p4 += 8;
97 
                p5 += 8;
98 
        } while (--lines > 0);
99 
}
100 
 
101 
static void
102 
xor_32regs_2(unsigned long bytes, unsigned long *p1, unsigned long *p2)
103 
{
104 
        long lines = bytes / (sizeof (long)) / 8;
105 
 
106 
        do {
107 
                register long d0, d1, d2, d3, d4, d5, d6, d7;
108 
                d0 = p1[0];      /* Pull the stuff into registers        */
109 
                d1 = p1[1];     /*  ... in bursts, if possible.         */
110 
                d2 = p1[2];
111 
                d3 = p1[3];
112 
                d4 = p1[4];
113 
                d5 = p1[5];
114 
                d6 = p1[6];
115 
                d7 = p1[7];
116 
                d0 ^= p2[0];
117 
                d1 ^= p2[1];
118 
                d2 ^= p2[2];
119 
                d3 ^= p2[3];
120 
                d4 ^= p2[4];
121 
                d5 ^= p2[5];
122 
                d6 ^= p2[6];
123 
                d7 ^= p2[7];
124 
                p1[0] = d0;      /* Store the result (in burts)          */
125 
                p1[1] = d1;
126 
                p1[2] = d2;
127 
                p1[3] = d3;
128 
                p1[4] = d4;
129 
                p1[5] = d5;
130 
                p1[6] = d6;
131 
                p1[7] = d7;
132 
                p1 += 8;
133 
                p2 += 8;
134 
        } while (--lines > 0);
135 
}
136 
 
137 
static void
138 
xor_32regs_3(unsigned long bytes, unsigned long *p1, unsigned long *p2,
139 
            unsigned long *p3)
140 
{
141 
        long lines = bytes / (sizeof (long)) / 8;
142 
 
143 
        do {
144 
                register long d0, d1, d2, d3, d4, d5, d6, d7;
145 
                d0 = p1[0];      /* Pull the stuff into registers        */
146 
                d1 = p1[1];     /*  ... in bursts, if possible.         */
147 
                d2 = p1[2];
148 
                d3 = p1[3];
149 
                d4 = p1[4];
150 
                d5 = p1[5];
151 
                d6 = p1[6];
152 
                d7 = p1[7];
153 
                d0 ^= p2[0];
154 
                d1 ^= p2[1];
155 
                d2 ^= p2[2];
156 
                d3 ^= p2[3];
157 
                d4 ^= p2[4];
158 
                d5 ^= p2[5];
159 
                d6 ^= p2[6];
160 
                d7 ^= p2[7];
161 
                d0 ^= p3[0];
162 
                d1 ^= p3[1];
163 
                d2 ^= p3[2];
164 
                d3 ^= p3[3];
165 
                d4 ^= p3[4];
166 
                d5 ^= p3[5];
167 
                d6 ^= p3[6];
168 
                d7 ^= p3[7];
169 
                p1[0] = d0;      /* Store the result (in burts)          */
170 
                p1[1] = d1;
171 
                p1[2] = d2;
172 
                p1[3] = d3;
173 
                p1[4] = d4;
174 
                p1[5] = d5;
175 
                p1[6] = d6;
176 
                p1[7] = d7;
177 
                p1 += 8;
178 
                p2 += 8;
179 
                p3 += 8;
180 
        } while (--lines > 0);
181 
}
182 
 
183 
static void
184 
xor_32regs_4(unsigned long bytes, unsigned long *p1, unsigned long *p2,
185 
            unsigned long *p3, unsigned long *p4)
186 
{
187 
        long lines = bytes / (sizeof (long)) / 8;
188 
 
189 
        do {
190 
                register long d0, d1, d2, d3, d4, d5, d6, d7;
191 
                d0 = p1[0];      /* Pull the stuff into registers        */
192 
                d1 = p1[1];     /*  ... in bursts, if possible.         */
193 
                d2 = p1[2];
194 
                d3 = p1[3];
195 
                d4 = p1[4];
196 
                d5 = p1[5];
197 
                d6 = p1[6];
198 
                d7 = p1[7];
199 
                d0 ^= p2[0];
200 
                d1 ^= p2[1];
201 
                d2 ^= p2[2];
202 
                d3 ^= p2[3];
203 
                d4 ^= p2[4];
204 
                d5 ^= p2[5];
205 
                d6 ^= p2[6];
206 
                d7 ^= p2[7];
207 
                d0 ^= p3[0];
208 
                d1 ^= p3[1];
209 
                d2 ^= p3[2];
210 
                d3 ^= p3[3];
211 
                d4 ^= p3[4];
212 
                d5 ^= p3[5];
213 
                d6 ^= p3[6];
214 
                d7 ^= p3[7];
215 
                d0 ^= p4[0];
216 
                d1 ^= p4[1];
217 
                d2 ^= p4[2];
218 
                d3 ^= p4[3];
219 
                d4 ^= p4[4];
220 
                d5 ^= p4[5];
221 
                d6 ^= p4[6];
222 
                d7 ^= p4[7];
223 
                p1[0] = d0;      /* Store the result (in burts)          */
224 
                p1[1] = d1;
225 
                p1[2] = d2;
226 
                p1[3] = d3;
227 
                p1[4] = d4;
228 
                p1[5] = d5;
229 
                p1[6] = d6;
230 
                p1[7] = d7;
231 
                p1 += 8;
232 
                p2 += 8;
233 
                p3 += 8;
234 
                p4 += 8;
235 
        } while (--lines > 0);
236 
}
237 
 
238 
static void
239 
xor_32regs_5(unsigned long bytes, unsigned long *p1, unsigned long *p2,
240 
            unsigned long *p3, unsigned long *p4, unsigned long *p5)
241 
{
242 
        long lines = bytes / (sizeof (long)) / 8;
243 
 
244 
        do {
245 
                register long d0, d1, d2, d3, d4, d5, d6, d7;
246 
                d0 = p1[0];      /* Pull the stuff into registers        */
247 
                d1 = p1[1];     /*  ... in bursts, if possible.         */
248 
                d2 = p1[2];
249 
                d3 = p1[3];
250 
                d4 = p1[4];
251 
                d5 = p1[5];
252 
                d6 = p1[6];
253 
                d7 = p1[7];
254 
                d0 ^= p2[0];
255 
                d1 ^= p2[1];
256 
                d2 ^= p2[2];
257 
                d3 ^= p2[3];
258 
                d4 ^= p2[4];
259 
                d5 ^= p2[5];
260 
                d6 ^= p2[6];
261 
                d7 ^= p2[7];
262 
                d0 ^= p3[0];
263 
                d1 ^= p3[1];
264 
                d2 ^= p3[2];
265 
                d3 ^= p3[3];
266 
                d4 ^= p3[4];
267 
                d5 ^= p3[5];
268 
                d6 ^= p3[6];
269 
                d7 ^= p3[7];
270 
                d0 ^= p4[0];
271 
                d1 ^= p4[1];
272 
                d2 ^= p4[2];
273 
                d3 ^= p4[3];
274 
                d4 ^= p4[4];
275 
                d5 ^= p4[5];
276 
                d6 ^= p4[6];
277 
                d7 ^= p4[7];
278 
                d0 ^= p5[0];
279 
                d1 ^= p5[1];
280 
                d2 ^= p5[2];
281 
                d3 ^= p5[3];
282 
                d4 ^= p5[4];
283 
                d5 ^= p5[5];
284 
                d6 ^= p5[6];
285 
                d7 ^= p5[7];
286 
                p1[0] = d0;      /* Store the result (in burts)          */
287 
                p1[1] = d1;
288 
                p1[2] = d2;
289 
                p1[3] = d3;
290 
                p1[4] = d4;
291 
                p1[5] = d5;
292 
                p1[6] = d6;
293 
                p1[7] = d7;
294 
                p1 += 8;
295 
                p2 += 8;
296 
                p3 += 8;
297 
                p4 += 8;
298 
                p5 += 8;
299 
        } while (--lines > 0);
300 
}
301 
 
302 
static struct xor_block_template xor_block_8regs = {
303 
        name: "8regs",
304 
        do_2: xor_8regs_2,
305 
        do_3: xor_8regs_3,
306 
        do_4: xor_8regs_4,
307 
        do_5: xor_8regs_5,
308 
};
309 
 
310 
static struct xor_block_template xor_block_32regs = {
311 
        name: "32regs",
312 
        do_2: xor_32regs_2,
313 
        do_3: xor_32regs_3,
314 
        do_4: xor_32regs_4,
315 
        do_5: xor_32regs_5,
316 
};
317 
 
318 
#define XOR_TRY_TEMPLATES                       \
319 
        do {                                    \
320 
                xor_speed(&xor_block_8regs);    \
321 
                xor_speed(&xor_block_32regs);   \
322 
        } while (0)

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.