2 * Checksum functions for Hexagon
4 * Copyright (c) 2010-2011, The Linux Foundation. All rights reserved.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 and
8 * only version 2 as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
21 /* This was derived from arch/alpha/lib/checksum.c */
24 #include <linux/module.h>
25 #include <linux/string.h>
27 #include <asm/byteorder.h>
28 #include <net/checksum.h>
29 #include <linux/uaccess.h>
30 #include <asm/intrinsics.h>
33 /* Vector value operations */
34 #define SIGN(x, y) ((0x8000ULL*x)<<y)
35 #define CARRY(x, y) ((0x0002ULL*x)<<y)
36 #define SELECT(x, y) ((0x0001ULL*x)<<y)
38 #define VR_NEGATE(a, b, c, d) (SIGN(a, 48) + SIGN(b, 32) + SIGN(c, 16) \
40 #define VR_CARRY(a, b, c, d) (CARRY(a, 48) + CARRY(b, 32) + CARRY(c, 16) \
42 #define VR_SELECT(a, b, c, d) (SELECT(a, 48) + SELECT(b, 32) + SELECT(c, 16) \
46 /* optimized HEXAGON V3 intrinsic version */
47 static inline unsigned short from64to16(u64 x
)
51 sum
= HEXAGON_P_vrmpyh_PP(x
^VR_NEGATE(1, 1, 1, 1),
52 VR_SELECT(1, 1, 1, 1));
53 sum
+= VR_CARRY(0, 0, 1, 0);
54 sum
= HEXAGON_P_vrmpyh_PP(sum
, VR_SELECT(0, 0, 1, 1));
60 * computes the checksum of the TCP/UDP pseudo-header
61 * returns a 16-bit checksum, already complemented.
63 __sum16
csum_tcpudp_magic(__be32 saddr
, __be32 daddr
,
64 __u32 len
, __u8 proto
, __wsum sum
)
66 return (__force __sum16
)~from64to16(
67 (__force u64
)saddr
+ (__force u64
)daddr
+
68 (__force u64
)sum
+ ((len
+ proto
) << 8));
71 __wsum
csum_tcpudp_nofold(__be32 saddr
, __be32 daddr
,
72 __u32 len
, __u8 proto
, __wsum sum
)
76 result
= (__force u64
)saddr
+ (__force u64
)daddr
+
77 (__force u64
)sum
+ ((len
+ proto
) << 8);
79 /* Fold down to 32-bits so we don't lose in the typedef-less
82 result
= (result
& 0xffffffffUL
) + (result
>> 32);
84 result
= (result
& 0xffffffffUL
) + (result
>> 32);
85 return (__force __wsum
)result
;
87 EXPORT_SYMBOL(csum_tcpudp_nofold
);
90 * Do a 64-bit checksum on an arbitrary memory area..
92 * This isn't a great routine, but it's not _horrible_ either. The
93 * inner loop could be unrolled a bit further, and there are better
94 * ways to do the carry, but this is reasonable.
97 /* optimized HEXAGON intrinsic version, with over read fixed */
98 unsigned int do_csum(const void *voidptr
, int len
)
100 u64 sum0
, sum1
, x0
, x1
, *ptr8_o
, *ptr8_e
, *ptr8
;
101 int i
, start
, mid
, end
, mask
;
102 const char *ptr
= voidptr
;
103 unsigned short *ptr2
;
109 start
= 0xF & (16-(((int) ptr
) & 0xF)) ;
110 mask
= 0x7fffffffUL
>> HEXAGON_R_cl0_R(len
);
111 start
= start
& mask
;
120 sum0
+= (u64
) (ptr
[0] << 8);
121 ptr2
= (unsigned short *) &ptr
[start
& 1];
123 sum1
+= (u64
) ptr2
[0];
124 ptr4
= (unsigned int *) &ptr
[start
& 3];
126 sum0
= HEXAGON_P_vrmpyhacc_PP(sum0
,
127 VR_NEGATE(0, 0, 1, 1)^((u64
)ptr4
[0]),
128 VR_SELECT(0, 0, 1, 1));
129 sum0
+= VR_SELECT(0, 0, 1, 0);
131 ptr8
= (u64
*) &ptr
[start
& 7];
133 sum1
= HEXAGON_P_vrmpyhacc_PP(sum1
,
134 VR_NEGATE(1, 1, 1, 1)^(ptr8
[0]),
135 VR_SELECT(1, 1, 1, 1));
136 sum1
+= VR_CARRY(0, 0, 1, 0);
138 ptr8_o
= (u64
*) (ptr
+ start
);
139 ptr8_e
= (u64
*) (ptr
+ start
+ 8);
142 x0
= *ptr8_e
; ptr8_e
+= 2;
143 x1
= *ptr8_o
; ptr8_o
+= 2;
145 for (i
= 0; i
< mid
-1; i
++) {
146 sum0
= HEXAGON_P_vrmpyhacc_PP(sum0
,
147 x0
^VR_NEGATE(1, 1, 1, 1),
148 VR_SELECT(1, 1, 1, 1));
149 sum1
= HEXAGON_P_vrmpyhacc_PP(sum1
,
150 x1
^VR_NEGATE(1, 1, 1, 1),
151 VR_SELECT(1, 1, 1, 1));
152 x0
= *ptr8_e
; ptr8_e
+= 2;
153 x1
= *ptr8_o
; ptr8_o
+= 2;
155 sum0
= HEXAGON_P_vrmpyhacc_PP(sum0
, x0
^VR_NEGATE(1, 1, 1, 1),
156 VR_SELECT(1, 1, 1, 1));
157 sum1
= HEXAGON_P_vrmpyhacc_PP(sum1
, x1
^VR_NEGATE(1, 1, 1, 1),
158 VR_SELECT(1, 1, 1, 1));
161 ptr4
= (unsigned int *) &ptr
[start
+ (mid
* 16) + (end
& 8)];
163 sum1
= HEXAGON_P_vrmpyhacc_PP(sum1
,
164 VR_NEGATE(0, 0, 1, 1)^((u64
)ptr4
[0]),
165 VR_SELECT(0, 0, 1, 1));
166 sum1
+= VR_SELECT(0, 0, 1, 0);
168 ptr2
= (unsigned short *) &ptr
[start
+ (mid
* 16) + (end
& 12)];
170 sum0
+= (u64
) ptr2
[0];
173 sum1
+= (u64
) ptr
[start
+ (mid
* 16) + (end
& 14)];
175 ptr8
= (u64
*) &ptr
[start
+ (mid
* 16)];
177 sum0
= HEXAGON_P_vrmpyhacc_PP(sum0
,
178 VR_NEGATE(1, 1, 1, 1)^(ptr8
[0]),
179 VR_SELECT(1, 1, 1, 1));
180 sum0
+= VR_CARRY(0, 0, 1, 0);
182 sum0
= HEXAGON_P_vrmpyh_PP((sum0
+sum1
)^VR_NEGATE(0, 0, 0, 1),
183 VR_SELECT(0, 0, 1, 1));
184 sum0
+= VR_NEGATE(0, 0, 0, 1);
185 sum0
= HEXAGON_P_vrmpyh_PP(sum0
, VR_SELECT(0, 0, 1, 1));
188 sum0
= (sum0
<< 8) | (0xFF & (sum0
>> 8));
190 return 0xFFFF & sum0
;
194 * copy from ds while checksumming, otherwise like csum_partial
197 csum_partial_copy_nocheck(const void *src
, void *dst
, int len
, __wsum sum
)
199 memcpy(dst
, src
, len
);
200 return csum_partial(dst
, len
, sum
);