1 /* 2 * Checksum functions for Hexagon 3 * 4 * Copyright (c) 2010-2011, The Linux Foundation. All rights reserved. 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 version 2 and 8 * only version 2 as published by the Free Software Foundation. 9 * 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. 14 * 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 18 * 02110-1301, USA. 19 */ 20 21 /* This was derived from arch/alpha/lib/checksum.c */ 22 23 24 #include <linux/module.h> 25 #include <linux/string.h> 26 27 #include <asm/byteorder.h> 28 #include <net/checksum.h> 29 #include <linux/uaccess.h> 30 #include <asm/intrinsics.h> 31 32 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) 37 38 #define VR_NEGATE(a, b, c, d) (SIGN(a, 48) + SIGN(b, 32) + SIGN(c, 16) \ 39 + SIGN(d, 0)) 40 #define VR_CARRY(a, b, c, d) (CARRY(a, 48) + CARRY(b, 32) + CARRY(c, 16) \ 41 + CARRY(d, 0)) 42 #define VR_SELECT(a, b, c, d) (SELECT(a, 48) + SELECT(b, 32) + SELECT(c, 16) \ 43 + SELECT(d, 0)) 44 45 46 /* optimized HEXAGON V3 intrinsic version */ 47 static inline unsigned short from64to16(u64 x) 48 { 49 u64 sum; 50 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)); 55 56 return 0xFFFF & sum; 57 } 58 59 /* 60 * computes the checksum of the TCP/UDP pseudo-header 61 * returns a 16-bit checksum, already complemented. 62 */ 63 __sum16 csum_tcpudp_magic(__be32 saddr, __be32 daddr, 64 __u32 len, __u8 proto, __wsum sum) 65 { 66 return (__force __sum16)~from64to16( 67 (__force u64)saddr + (__force u64)daddr + 68 (__force u64)sum + ((len + proto) << 8)); 69 } 70 71 __wsum csum_tcpudp_nofold(__be32 saddr, __be32 daddr, 72 __u32 len, __u8 proto, __wsum sum) 73 { 74 u64 result; 75 76 result = (__force u64)saddr + (__force u64)daddr + 77 (__force u64)sum + ((len + proto) << 8); 78 79 /* Fold down to 32-bits so we don't lose in the typedef-less 80 network stack. */ 81 /* 64 to 33 */ 82 result = (result & 0xffffffffUL) + (result >> 32); 83 /* 33 to 32 */ 84 result = (result & 0xffffffffUL) + (result >> 32); 85 return (__force __wsum)result; 86 } 87 EXPORT_SYMBOL(csum_tcpudp_nofold); 88 89 /* 90 * Do a 64-bit checksum on an arbitrary memory area.. 91 * 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. 95 */ 96 97 /* optimized HEXAGON intrinsic version, with over read fixed */ 98 unsigned int do_csum(const void *voidptr, int len) 99 { 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; 104 unsigned int *ptr4; 105 106 if (len <= 0) 107 return 0; 108 109 start = 0xF & (16-(((int) ptr) & 0xF)) ; 110 mask = 0x7fffffffUL >> HEXAGON_R_cl0_R(len); 111 start = start & mask ; 112 113 mid = len - start; 114 end = mid & 0xF; 115 mid = mid>>4; 116 sum0 = mid << 18; 117 sum1 = 0; 118 119 if (start & 1) 120 sum0 += (u64) (ptr[0] << 8); 121 ptr2 = (unsigned short *) &ptr[start & 1]; 122 if (start & 2) 123 sum1 += (u64) ptr2[0]; 124 ptr4 = (unsigned int *) &ptr[start & 3]; 125 if (start & 4) { 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); 130 } 131 ptr8 = (u64 *) &ptr[start & 7]; 132 if (start & 8) { 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); 137 } 138 ptr8_o = (u64 *) (ptr + start); 139 ptr8_e = (u64 *) (ptr + start + 8); 140 141 if (mid) { 142 x0 = *ptr8_e; ptr8_e += 2; 143 x1 = *ptr8_o; ptr8_o += 2; 144 if (mid > 1) 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; 154 } 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)); 159 } 160 161 ptr4 = (unsigned int *) &ptr[start + (mid * 16) + (end & 8)]; 162 if (end & 4) { 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); 167 } 168 ptr2 = (unsigned short *) &ptr[start + (mid * 16) + (end & 12)]; 169 if (end & 2) 170 sum0 += (u64) ptr2[0]; 171 172 if (end & 1) 173 sum1 += (u64) ptr[start + (mid * 16) + (end & 14)]; 174 175 ptr8 = (u64 *) &ptr[start + (mid * 16)]; 176 if (end & 8) { 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); 181 } 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)); 186 187 if (start & 1) 188 sum0 = (sum0 << 8) | (0xFF & (sum0 >> 8)); 189 190 return 0xFFFF & sum0; 191 } 192 193 /* 194 * copy from ds while checksumming, otherwise like csum_partial 195 */ 196 __wsum 197 csum_partial_copy_nocheck(const void *src, void *dst, int len, __wsum sum) 198 { 199 memcpy(dst, src, len); 200 return csum_partial(dst, len, sum); 201 } 202 EXPORT_SYMBOL(csum_partial_copy_nocheck); 203