git.oblomov.eu Git - linux-2.6/blob - arch/um/sys-i386/checksum.S

   1 /*
   2  * INET         An implementation of the TCP/IP protocol suite for the LINUX
   3  *              operating system.  INET is implemented using the  BSD Socket
   4  *              interface as the means of communication with the user level.
   5  *
   6  *              IP/TCP/UDP checksumming routines
   7  *
   8  * Authors:     Jorge Cwik, <jorge@laser.satlink.net>
   9  *              Arnt Gulbrandsen, <agulbra@nvg.unit.no>
  10  *              Tom May, <ftom@netcom.com>
  11  *              Pentium Pro/II routines:
  12  *              Alexander Kjeldaas <astor@guardian.no>
  13  *              Finn Arne Gangstad <finnag@guardian.no>
  14  *              Lots of code moved from tcp.c and ip.c; see those files
  15  *              for more names.
  16  *
  17  * Changes:     Ingo Molnar, converted csum_partial_copy() to 2.1 exception
  18  *                           handling.
  19  *              Andi Kleen,  add zeroing on error
  20  *                   converted to pure assembler
  21  *
  22  *              This program is free software; you can redistribute it and/or
  23  *              modify it under the terms of the GNU General Public License
  24  *              as published by the Free Software Foundation; either version
  25  *              2 of the License, or (at your option) any later version.
  26  */
  27
  28 #include <asm/errno.h>
  29
  30 /*
  31  * computes a partial checksum, e.g. for TCP/UDP fragments
  32  */
  33
  34 /*
  35 unsigned int csum_partial(const unsigned char * buff, int len, unsigned int sum)
  36  */
  37
  38 .text
  39 .align 4
  40 .globl csum_partial
  41
  42 #ifndef CONFIG_X86_USE_PPRO_CHECKSUM
  43
  44           /*
  45            * Experiments with Ethernet and SLIP connections show that buff
  46            * is aligned on either a 2-byte or 4-byte boundary.  We get at
  47            * least a twofold speedup on 486 and Pentium if it is 4-byte aligned.
  48            * Fortunately, it is easy to convert 2-byte alignment to 4-byte
  49            * alignment for the unrolled loop.
  50            */
  51 csum_partial:
  52         pushl %esi
  53         pushl %ebx
  54         movl 20(%esp),%eax      # Function arg: unsigned int sum
  55         movl 16(%esp),%ecx      # Function arg: int len
  56         movl 12(%esp),%esi      # Function arg: unsigned char *buff
  57         testl $2, %esi          # Check alignment.
  58         jz 2f                   # Jump if alignment is ok.
  59         subl $2, %ecx           # Alignment uses up two bytes.
  60         jae 1f                  # Jump if we had at least two bytes.
  61         addl $2, %ecx           # ecx was < 2.  Deal with it.
  62         jmp 4f
  63 1:      movw (%esi), %bx
  64         addl $2, %esi
  65         addw %bx, %ax
  66         adcl $0, %eax
  67 2:
  68         movl %ecx, %edx
  69         shrl $5, %ecx
  70         jz 2f
  71         testl %esi, %esi
  72 1:      movl (%esi), %ebx
  73         adcl %ebx, %eax
  74         movl 4(%esi), %ebx
  75         adcl %ebx, %eax
  76         movl 8(%esi), %ebx
  77         adcl %ebx, %eax
  78         movl 12(%esi), %ebx
  79         adcl %ebx, %eax
  80         movl 16(%esi), %ebx
  81         adcl %ebx, %eax
  82         movl 20(%esi), %ebx
  83         adcl %ebx, %eax
  84         movl 24(%esi), %ebx
  85         adcl %ebx, %eax
  86         movl 28(%esi), %ebx
  87         adcl %ebx, %eax
  88         lea 32(%esi), %esi
  89         dec %ecx
  90         jne 1b
  91         adcl $0, %eax
  92 2:      movl %edx, %ecx
  93         andl $0x1c, %edx
  94         je 4f
  95         shrl $2, %edx           # This clears CF
  96 3:      adcl (%esi), %eax
  97         lea 4(%esi), %esi
  98         dec %edx
  99         jne 3b
 100         adcl $0, %eax
 101 4:      andl $3, %ecx
 102         jz 7f
 103         cmpl $2, %ecx
 104         jb 5f
 105         movw (%esi),%cx
 106         leal 2(%esi),%esi
 107         je 6f
 108         shll $16,%ecx
 109 5:      movb (%esi),%cl
 110 6:      addl %ecx,%eax
 111         adcl $0, %eax
 112 7:
 113         popl %ebx
 114         popl %esi
 115         ret
 116
 117 #else
 118
 119 /* Version for PentiumII/PPro */
 120
 121 csum_partial:
 122         pushl %esi
 123         pushl %ebx
 124         movl 20(%esp),%eax      # Function arg: unsigned int sum
 125         movl 16(%esp),%ecx      # Function arg: int len
 126         movl 12(%esp),%esi      # Function arg: const unsigned char *buf
 127
 128         testl $2, %esi
 129         jnz 30f
 130 10:
 131         movl %ecx, %edx
 132         movl %ecx, %ebx
 133         andl $0x7c, %ebx
 134         shrl $7, %ecx
 135         addl %ebx,%esi
 136         shrl $2, %ebx
 137         negl %ebx
 138         lea 45f(%ebx,%ebx,2), %ebx
 139         testl %esi, %esi
 140         jmp *%ebx
 141
 142         # Handle 2-byte-aligned regions
 143 20:     addw (%esi), %ax
 144         lea 2(%esi), %esi
 145         adcl $0, %eax
 146         jmp 10b
 147
 148 30:     subl $2, %ecx
 149         ja 20b
 150         je 32f
 151         movzbl (%esi),%ebx      # csumming 1 byte, 2-aligned
 152         addl %ebx, %eax
 153         adcl $0, %eax
 154         jmp 80f
 155 32:
 156         addw (%esi), %ax        # csumming 2 bytes, 2-aligned
 157         adcl $0, %eax
 158         jmp 80f
 159
 160 40:
 161         addl -128(%esi), %eax
 162         adcl -124(%esi), %eax
 163         adcl -120(%esi), %eax
 164         adcl -116(%esi), %eax
 165         adcl -112(%esi), %eax
 166         adcl -108(%esi), %eax
 167         adcl -104(%esi), %eax
 168         adcl -100(%esi), %eax
 169         adcl -96(%esi), %eax
 170         adcl -92(%esi), %eax
 171         adcl -88(%esi), %eax
 172         adcl -84(%esi), %eax
 173         adcl -80(%esi), %eax
 174         adcl -76(%esi), %eax
 175         adcl -72(%esi), %eax
 176         adcl -68(%esi), %eax
 177         adcl -64(%esi), %eax
 178         adcl -60(%esi), %eax
 179         adcl -56(%esi), %eax
 180         adcl -52(%esi), %eax
 181         adcl -48(%esi), %eax
 182         adcl -44(%esi), %eax
 183         adcl -40(%esi), %eax
 184         adcl -36(%esi), %eax
 185         adcl -32(%esi), %eax
 186         adcl -28(%esi), %eax
 187         adcl -24(%esi), %eax
 188         adcl -20(%esi), %eax
 189         adcl -16(%esi), %eax
 190         adcl -12(%esi), %eax
 191         adcl -8(%esi), %eax
 192         adcl -4(%esi), %eax
 193 45:
 194         lea 128(%esi), %esi
 195         adcl $0, %eax
 196         dec %ecx
 197         jge 40b
 198         movl %edx, %ecx
 199 50:     andl $3, %ecx
 200         jz 80f
 201
 202         # Handle the last 1-3 bytes without jumping
 203         notl %ecx               # 1->2, 2->1, 3->0, higher bits are masked
 204         movl $0xffffff,%ebx     # by the shll and shrl instructions
 205         shll $3,%ecx
 206         shrl %cl,%ebx
 207         andl -128(%esi),%ebx    # esi is 4-aligned so should be ok
 208         addl %ebx,%eax
 209         adcl $0,%eax
 210 80:
 211         popl %ebx
 212         popl %esi
 213         ret
 214
 215 #endif
 216
 217 /*
 218 unsigned int csum_partial_copy_generic (const char *src, char *dst,
 219                                   int len, int sum, int *src_err_ptr, int *dst_err_ptr)
 220  */
 221
 222 /*
 223  * Copy from ds while checksumming, otherwise like csum_partial
 224  *
 225  * The macros SRC and DST specify the type of access for the instruction.
 226  * thus we can call a custom exception handler for all access types.
 227  *
 228  * FIXME: could someone double-check whether I haven't mixed up some SRC and
 229  *        DST definitions? It's damn hard to trigger all cases.  I hope I got
 230  *        them all but there's no guarantee.
 231  */
 232
 233 #define SRC(y...)                       \
 234         9999: y;                        \
 235         .section __ex_table, "a";       \
 236         .long 9999b, 6001f      ;       \
 237         .previous
 238
 239 #define DST(y...)                       \
 240         9999: y;                        \
 241         .section __ex_table, "a";       \
 242         .long 9999b, 6002f      ;       \
 243         .previous
 244
 245 .align 4
 246 .globl csum_partial_copy_generic_i386
 247
 248 #ifndef CONFIG_X86_USE_PPRO_CHECKSUM
 249
 250 #define ARGBASE 16
 251 #define FP              12
 252
 253 csum_partial_copy_generic_i386:
 254         subl  $4,%esp
 255         pushl %edi
 256         pushl %esi
 257         pushl %ebx
 258         movl ARGBASE+16(%esp),%eax      # sum
 259         movl ARGBASE+12(%esp),%ecx      # len
 260         movl ARGBASE+4(%esp),%esi       # src
 261         movl ARGBASE+8(%esp),%edi       # dst
 262
 263         testl $2, %edi                  # Check alignment.
 264         jz 2f                           # Jump if alignment is ok.
 265         subl $2, %ecx                   # Alignment uses up two bytes.
 266         jae 1f                          # Jump if we had at least two bytes.
 267         addl $2, %ecx                   # ecx was < 2.  Deal with it.
 268         jmp 4f
 269 SRC(1:  movw (%esi), %bx        )
 270         addl $2, %esi
 271 DST(    movw %bx, (%edi)        )
 272         addl $2, %edi
 273         addw %bx, %ax
 274         adcl $0, %eax
 275 2:
 276         movl %ecx, FP(%esp)
 277         shrl $5, %ecx
 278         jz 2f
 279         testl %esi, %esi
 280 SRC(1:  movl (%esi), %ebx       )
 281 SRC(    movl 4(%esi), %edx      )
 282         adcl %ebx, %eax
 283 DST(    movl %ebx, (%edi)       )
 284         adcl %edx, %eax
 285 DST(    movl %edx, 4(%edi)      )
 286
 287 SRC(    movl 8(%esi), %ebx      )
 288 SRC(    movl 12(%esi), %edx     )
 289         adcl %ebx, %eax
 290 DST(    movl %ebx, 8(%edi)      )
 291         adcl %edx, %eax
 292 DST(    movl %edx, 12(%edi)     )
 293
 294 SRC(    movl 16(%esi), %ebx     )
 295 SRC(    movl 20(%esi), %edx     )
 296         adcl %ebx, %eax
 297 DST(    movl %ebx, 16(%edi)     )
 298         adcl %edx, %eax
 299 DST(    movl %edx, 20(%edi)     )
 300
 301 SRC(    movl 24(%esi), %ebx     )
 302 SRC(    movl 28(%esi), %edx     )
 303         adcl %ebx, %eax
 304 DST(    movl %ebx, 24(%edi)     )
 305         adcl %edx, %eax
 306 DST(    movl %edx, 28(%edi)     )
 307
 308         lea 32(%esi), %esi
 309         lea 32(%edi), %edi
 310         dec %ecx
 311         jne 1b
 312         adcl $0, %eax
 313 2:      movl FP(%esp), %edx
 314         movl %edx, %ecx
 315         andl $0x1c, %edx
 316         je 4f
 317         shrl $2, %edx                   # This clears CF
 318 SRC(3:  movl (%esi), %ebx       )
 319         adcl %ebx, %eax
 320 DST(    movl %ebx, (%edi)       )
 321         lea 4(%esi), %esi
 322         lea 4(%edi), %edi
 323         dec %edx
 324         jne 3b
 325         adcl $0, %eax
 326 4:      andl $3, %ecx
 327         jz 7f
 328         cmpl $2, %ecx
 329         jb 5f
 330 SRC(    movw (%esi), %cx        )
 331         leal 2(%esi), %esi
 332 DST(    movw %cx, (%edi)        )
 333         leal 2(%edi), %edi
 334         je 6f
 335         shll $16,%ecx
 336 SRC(5:  movb (%esi), %cl        )
 337 DST(    movb %cl, (%edi)        )
 338 6:      addl %ecx, %eax
 339         adcl $0, %eax
 340 7:
 341 5000:
 342
 343 # Exception handler:
 344 .section .fixup, "ax"
 345
 346 6001:
 347         movl ARGBASE+20(%esp), %ebx     # src_err_ptr
 348         movl $-EFAULT, (%ebx)
 349
 350         # zero the complete destination - computing the rest
 351         # is too much work
 352         movl ARGBASE+8(%esp), %edi      # dst
 353         movl ARGBASE+12(%esp), %ecx     # len
 354         xorl %eax,%eax
 355         rep ; stosb
 356
 357         jmp 5000b
 358
 359 6002:
 360         movl ARGBASE+24(%esp), %ebx     # dst_err_ptr
 361         movl $-EFAULT,(%ebx)
 362         jmp 5000b
 363
 364 .previous
 365
 366         popl %ebx
 367         popl %esi
 368         popl %edi
 369         popl %ecx                       # equivalent to addl $4,%esp
 370         ret
 371
 372 #else
 373
 374 /* Version for PentiumII/PPro */
 375
 376 #define ROUND1(x) \
 377         SRC(movl x(%esi), %ebx  )       ;       \
 378         addl %ebx, %eax                 ;       \
 379         DST(movl %ebx, x(%edi)  )       ;
 380
 381 #define ROUND(x) \
 382         SRC(movl x(%esi), %ebx  )       ;       \
 383         adcl %ebx, %eax                 ;       \
 384         DST(movl %ebx, x(%edi)  )       ;
 385
 386 #define ARGBASE 12
 387
 388 csum_partial_copy_generic_i386:
 389         pushl %ebx
 390         pushl %edi
 391         pushl %esi
 392         movl ARGBASE+4(%esp),%esi       #src
 393         movl ARGBASE+8(%esp),%edi       #dst
 394         movl ARGBASE+12(%esp),%ecx      #len
 395         movl ARGBASE+16(%esp),%eax      #sum
 396 #       movl %ecx, %edx
 397         movl %ecx, %ebx
 398         movl %esi, %edx
 399         shrl $6, %ecx
 400         andl $0x3c, %ebx
 401         negl %ebx
 402         subl %ebx, %esi
 403         subl %ebx, %edi
 404         lea  -1(%esi),%edx
 405         andl $-32,%edx
 406         lea 3f(%ebx,%ebx), %ebx
 407         testl %esi, %esi
 408         jmp *%ebx
 409 1:      addl $64,%esi
 410         addl $64,%edi
 411         SRC(movb -32(%edx),%bl) ; SRC(movb (%edx),%bl)
 412         ROUND1(-64) ROUND(-60) ROUND(-56) ROUND(-52)
 413         ROUND (-48) ROUND(-44) ROUND(-40) ROUND(-36)
 414         ROUND (-32) ROUND(-28) ROUND(-24) ROUND(-20)
 415         ROUND (-16) ROUND(-12) ROUND(-8)  ROUND(-4)
 416 3:      adcl $0,%eax
 417         addl $64, %edx
 418         dec %ecx
 419         jge 1b
 420 4:      movl ARGBASE+12(%esp),%edx      #len
 421         andl $3, %edx
 422         jz 7f
 423         cmpl $2, %edx
 424         jb 5f
 425 SRC(    movw (%esi), %dx         )
 426         leal 2(%esi), %esi
 427 DST(    movw %dx, (%edi)         )
 428         leal 2(%edi), %edi
 429         je 6f
 430         shll $16,%edx
 431 5:
 432 SRC(    movb (%esi), %dl         )
 433 DST(    movb %dl, (%edi)         )
 434 6:      addl %edx, %eax
 435         adcl $0, %eax
 436 7:
 437 .section .fixup, "ax"
 438 6001:   movl    ARGBASE+20(%esp), %ebx  # src_err_ptr
 439         movl $-EFAULT, (%ebx)
 440         # zero the complete destination (computing the rest is too much work)
 441         movl ARGBASE+8(%esp),%edi       # dst
 442         movl ARGBASE+12(%esp),%ecx      # len
 443         xorl %eax,%eax
 444         rep; stosb
 445         jmp 7b
 446 6002:   movl ARGBASE+24(%esp), %ebx     # dst_err_ptr
 447         movl $-EFAULT, (%ebx)
 448         jmp  7b
 449 .previous
 450
 451         popl %esi
 452         popl %edi
 453         popl %ebx
 454         ret
 455
 456 #undef ROUND
 457 #undef ROUND1
 458
 459 #endif