1 /* SPDX-License-Identifier: GPL-2.0-or-later */ 2 /* 3 * INET An implementation of the TCP/IP protocol suite for the LINUX 4 * operating system. INET is implemented using the BSD Socket 5 * interface as the means of communication with the user level. 6 * 7 * IP/TCP/UDP checksumming routines 8 * 9 * Xtensa version: Copyright (C) 2001 Tensilica, Inc. by Kevin Chea 10 * Optimized by Joe Taylor 11 */ 12 13 #include <linux/errno.h> 14 #include <linux/linkage.h> 15 #include <asm/asmmacro.h> 16 #include <asm/core.h> 17 18 /* 19 * computes a partial checksum, e.g. for TCP/UDP fragments 20 */ 21 22 /* 23 * unsigned int csum_partial(const unsigned char *buf, int len, 24 * unsigned int sum); 25 * a2 = buf 26 * a3 = len 27 * a4 = sum 28 * 29 * This function assumes 2- or 4-byte alignment. Other alignments will fail! 30 */ 31 32 /* ONES_ADD converts twos-complement math to ones-complement. */ 33 #define ONES_ADD(sum, val) \ 34 add sum, sum, val ; \ 35 bgeu sum, val, 99f ; \ 36 addi sum, sum, 1 ; \ 37 99: ; 38 39 .text 40 ENTRY(csum_partial) 41 42 /* 43 * Experiments with Ethernet and SLIP connections show that buf 44 * is aligned on either a 2-byte or 4-byte boundary. 45 */ 46 abi_entry_default 47 extui a5, a2, 0, 2 48 bnez a5, 8f /* branch if 2-byte aligned */ 49 /* Fall-through on common case, 4-byte alignment */ 50 1: 51 srli a5, a3, 5 /* 32-byte chunks */ 52 #if XCHAL_HAVE_LOOPS 53 loopgtz a5, 2f 54 #else 55 beqz a5, 2f 56 slli a5, a5, 5 57 add a5, a5, a2 /* a5 = end of last 32-byte chunk */ 58 .Loop1: 59 #endif 60 l32i a6, a2, 0 61 l32i a7, a2, 4 62 ONES_ADD(a4, a6) 63 ONES_ADD(a4, a7) 64 l32i a6, a2, 8 65 l32i a7, a2, 12 66 ONES_ADD(a4, a6) 67 ONES_ADD(a4, a7) 68 l32i a6, a2, 16 69 l32i a7, a2, 20 70 ONES_ADD(a4, a6) 71 ONES_ADD(a4, a7) 72 l32i a6, a2, 24 73 l32i a7, a2, 28 74 ONES_ADD(a4, a6) 75 ONES_ADD(a4, a7) 76 addi a2, a2, 4*8 77 #if !XCHAL_HAVE_LOOPS 78 blt a2, a5, .Loop1 79 #endif 80 2: 81 extui a5, a3, 2, 3 /* remaining 4-byte chunks */ 82 #if XCHAL_HAVE_LOOPS 83 loopgtz a5, 3f 84 #else 85 beqz a5, 3f 86 slli a5, a5, 2 87 add a5, a5, a2 /* a5 = end of last 4-byte chunk */ 88 .Loop2: 89 #endif 90 l32i a6, a2, 0 91 ONES_ADD(a4, a6) 92 addi a2, a2, 4 93 #if !XCHAL_HAVE_LOOPS 94 blt a2, a5, .Loop2 95 #endif 96 3: 97 _bbci.l a3, 1, 5f /* remaining 2-byte chunk */ 98 l16ui a6, a2, 0 99 ONES_ADD(a4, a6) 100 addi a2, a2, 2 101 5: 102 _bbci.l a3, 0, 7f /* remaining 1-byte chunk */ 103 6: l8ui a6, a2, 0 104 #ifdef __XTENSA_EB__ 105 slli a6, a6, 8 /* load byte into bits 8..15 */ 106 #endif 107 ONES_ADD(a4, a6) 108 7: 109 mov a2, a4 110 abi_ret_default 111 112 /* uncommon case, buf is 2-byte aligned */ 113 8: 114 beqz a3, 7b /* branch if len == 0 */ 115 beqi a3, 1, 6b /* branch if len == 1 */ 116 117 extui a5, a2, 0, 1 118 bnez a5, 8f /* branch if 1-byte aligned */ 119 120 l16ui a6, a2, 0 /* common case, len >= 2 */ 121 ONES_ADD(a4, a6) 122 addi a2, a2, 2 /* adjust buf */ 123 addi a3, a3, -2 /* adjust len */ 124 j 1b /* now buf is 4-byte aligned */ 125 126 /* case: odd-byte aligned, len > 1 127 * This case is dog slow, so don't give us an odd address. 128 * (I don't think this ever happens, but just in case.) 129 */ 130 8: 131 srli a5, a3, 2 /* 4-byte chunks */ 132 #if XCHAL_HAVE_LOOPS 133 loopgtz a5, 2f 134 #else 135 beqz a5, 2f 136 slli a5, a5, 2 137 add a5, a5, a2 /* a5 = end of last 4-byte chunk */ 138 .Loop3: 139 #endif 140 l8ui a6, a2, 0 /* bits 24..31 */ 141 l16ui a7, a2, 1 /* bits 8..23 */ 142 l8ui a8, a2, 3 /* bits 0.. 8 */ 143 #ifdef __XTENSA_EB__ 144 slli a6, a6, 24 145 #else 146 slli a8, a8, 24 147 #endif 148 slli a7, a7, 8 149 or a7, a7, a6 150 or a7, a7, a8 151 ONES_ADD(a4, a7) 152 addi a2, a2, 4 153 #if !XCHAL_HAVE_LOOPS 154 blt a2, a5, .Loop3 155 #endif 156 2: 157 _bbci.l a3, 1, 3f /* remaining 2-byte chunk, still odd addr */ 158 l8ui a6, a2, 0 159 l8ui a7, a2, 1 160 #ifdef __XTENSA_EB__ 161 slli a6, a6, 8 162 #else 163 slli a7, a7, 8 164 #endif 165 or a7, a7, a6 166 ONES_ADD(a4, a7) 167 addi a2, a2, 2 168 3: 169 j 5b /* branch to handle the remaining byte */ 170 171 ENDPROC(csum_partial) 172 EXPORT_SYMBOL(csum_partial) 173 174 /* 175 * Copy from ds while checksumming, otherwise like csum_partial 176 */ 177 178 /* 179 unsigned int csum_partial_copy_generic (const char *src, char *dst, int len) 180 a2 = src 181 a3 = dst 182 a4 = len 183 a5 = sum 184 a8 = temp 185 a9 = temp 186 a10 = temp 187 188 This function is optimized for 4-byte aligned addresses. Other 189 alignments work, but not nearly as efficiently. 190 */ 191 192 ENTRY(csum_partial_copy_generic) 193 194 abi_entry_default 195 movi a5, -1 196 or a10, a2, a3 197 198 /* We optimize the following alignment tests for the 4-byte 199 aligned case. Two bbsi.l instructions might seem more optimal 200 (commented out below). However, both labels 5: and 3: are out 201 of the imm8 range, so the assembler relaxes them into 202 equivalent bbci.l, j combinations, which is actually 203 slower. */ 204 205 extui a9, a10, 0, 2 206 beqz a9, 1f /* branch if both are 4-byte aligned */ 207 bbsi.l a10, 0, 5f /* branch if one address is odd */ 208 j 3f /* one address is 2-byte aligned */ 209 210 /* _bbsi.l a10, 0, 5f */ /* branch if odd address */ 211 /* _bbsi.l a10, 1, 3f */ /* branch if 2-byte-aligned address */ 212 213 1: 214 /* src and dst are both 4-byte aligned */ 215 srli a10, a4, 5 /* 32-byte chunks */ 216 #if XCHAL_HAVE_LOOPS 217 loopgtz a10, 2f 218 #else 219 beqz a10, 2f 220 slli a10, a10, 5 221 add a10, a10, a2 /* a10 = end of last 32-byte src chunk */ 222 .Loop5: 223 #endif 224 EX(10f) l32i a9, a2, 0 225 EX(10f) l32i a8, a2, 4 226 EX(10f) s32i a9, a3, 0 227 EX(10f) s32i a8, a3, 4 228 ONES_ADD(a5, a9) 229 ONES_ADD(a5, a8) 230 EX(10f) l32i a9, a2, 8 231 EX(10f) l32i a8, a2, 12 232 EX(10f) s32i a9, a3, 8 233 EX(10f) s32i a8, a3, 12 234 ONES_ADD(a5, a9) 235 ONES_ADD(a5, a8) 236 EX(10f) l32i a9, a2, 16 237 EX(10f) l32i a8, a2, 20 238 EX(10f) s32i a9, a3, 16 239 EX(10f) s32i a8, a3, 20 240 ONES_ADD(a5, a9) 241 ONES_ADD(a5, a8) 242 EX(10f) l32i a9, a2, 24 243 EX(10f) l32i a8, a2, 28 244 EX(10f) s32i a9, a3, 24 245 EX(10f) s32i a8, a3, 28 246 ONES_ADD(a5, a9) 247 ONES_ADD(a5, a8) 248 addi a2, a2, 32 249 addi a3, a3, 32 250 #if !XCHAL_HAVE_LOOPS 251 blt a2, a10, .Loop5 252 #endif 253 2: 254 extui a10, a4, 2, 3 /* remaining 4-byte chunks */ 255 extui a4, a4, 0, 2 /* reset len for general-case, 2-byte chunks */ 256 #if XCHAL_HAVE_LOOPS 257 loopgtz a10, 3f 258 #else 259 beqz a10, 3f 260 slli a10, a10, 2 261 add a10, a10, a2 /* a10 = end of last 4-byte src chunk */ 262 .Loop6: 263 #endif 264 EX(10f) l32i a9, a2, 0 265 EX(10f) s32i a9, a3, 0 266 ONES_ADD(a5, a9) 267 addi a2, a2, 4 268 addi a3, a3, 4 269 #if !XCHAL_HAVE_LOOPS 270 blt a2, a10, .Loop6 271 #endif 272 3: 273 /* 274 Control comes to here in two cases: (1) It may fall through 275 to here from the 4-byte alignment case to process, at most, 276 one 2-byte chunk. (2) It branches to here from above if 277 either src or dst is 2-byte aligned, and we process all bytes 278 here, except for perhaps a trailing odd byte. It's 279 inefficient, so align your addresses to 4-byte boundaries. 280 281 a2 = src 282 a3 = dst 283 a4 = len 284 a5 = sum 285 */ 286 srli a10, a4, 1 /* 2-byte chunks */ 287 #if XCHAL_HAVE_LOOPS 288 loopgtz a10, 4f 289 #else 290 beqz a10, 4f 291 slli a10, a10, 1 292 add a10, a10, a2 /* a10 = end of last 2-byte src chunk */ 293 .Loop7: 294 #endif 295 EX(10f) l16ui a9, a2, 0 296 EX(10f) s16i a9, a3, 0 297 ONES_ADD(a5, a9) 298 addi a2, a2, 2 299 addi a3, a3, 2 300 #if !XCHAL_HAVE_LOOPS 301 blt a2, a10, .Loop7 302 #endif 303 4: 304 /* This section processes a possible trailing odd byte. */ 305 _bbci.l a4, 0, 8f /* 1-byte chunk */ 306 EX(10f) l8ui a9, a2, 0 307 EX(10f) s8i a9, a3, 0 308 #ifdef __XTENSA_EB__ 309 slli a9, a9, 8 /* shift byte to bits 8..15 */ 310 #endif 311 ONES_ADD(a5, a9) 312 8: 313 mov a2, a5 314 abi_ret_default 315 316 5: 317 /* Control branch to here when either src or dst is odd. We 318 process all bytes using 8-bit accesses. Grossly inefficient, 319 so don't feed us an odd address. */ 320 321 srli a10, a4, 1 /* handle in pairs for 16-bit csum */ 322 #if XCHAL_HAVE_LOOPS 323 loopgtz a10, 6f 324 #else 325 beqz a10, 6f 326 slli a10, a10, 1 327 add a10, a10, a2 /* a10 = end of last odd-aligned, 2-byte src chunk */ 328 .Loop8: 329 #endif 330 EX(10f) l8ui a9, a2, 0 331 EX(10f) l8ui a8, a2, 1 332 EX(10f) s8i a9, a3, 0 333 EX(10f) s8i a8, a3, 1 334 #ifdef __XTENSA_EB__ 335 slli a9, a9, 8 /* combine into a single 16-bit value */ 336 #else /* for checksum computation */ 337 slli a8, a8, 8 338 #endif 339 or a9, a9, a8 340 ONES_ADD(a5, a9) 341 addi a2, a2, 2 342 addi a3, a3, 2 343 #if !XCHAL_HAVE_LOOPS 344 blt a2, a10, .Loop8 345 #endif 346 6: 347 j 4b /* process the possible trailing odd byte */ 348 349 ENDPROC(csum_partial_copy_generic) 350 EXPORT_SYMBOL(csum_partial_copy_generic) 351 352 353 # Exception handler: 354 .section .fixup, "ax" 355 10: 356 movi a2, 0 357 abi_ret_default 358 359 .previous
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.