[mirror_ubuntu-eoan-kernel.git] / arch / x86 / um / checksum_32.S

/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * INET		An implementation of the TCP/IP protocol suite for the LINUX
 *		operating system.  INET is implemented using the  BSD Socket
 *		interface as the means of communication with the user level.
 *
 *		IP/TCP/UDP checksumming routines
 *
 * Authors:	Jorge Cwik, <jorge@laser.satlink.net>
 *		Arnt Gulbrandsen, <agulbra@nvg.unit.no>
 *		Tom May, <ftom@netcom.com>
 *              Pentium Pro/II routines:
 *              Alexander Kjeldaas <astor@guardian.no>
 *              Finn Arne Gangstad <finnag@guardian.no>
 *		Lots of code moved from tcp.c and ip.c; see those files
 *		for more names.
 *
 * Changes:     Ingo Molnar, converted csum_partial_copy() to 2.1 exception
 *			     handling.
 *		Andi Kleen,  add zeroing on error
 *                   converted to pure assembler
 */

#include <asm/errno.h>
#include <asm/asm.h>
#include <asm/export.h>
				
/*
 * computes a partial checksum, e.g. for TCP/UDP fragments
 */

/*	
unsigned int csum_partial(const unsigned char * buff, int len, unsigned int sum)
 */
		
.text
.align 4
.globl csum_partial
		
#ifndef CONFIG_X86_USE_PPRO_CHECKSUM

	  /*		
	   * Experiments with Ethernet and SLIP connections show that buff
	   * is aligned on either a 2-byte or 4-byte boundary.  We get at
	   * least a twofold speedup on 486 and Pentium if it is 4-byte aligned.
	   * Fortunately, it is easy to convert 2-byte alignment to 4-byte
	   * alignment for the unrolled loop.
	   */		
csum_partial:
	pushl %esi
	pushl %ebx
	movl 20(%esp),%eax	# Function arg: unsigned int sum
	movl 16(%esp),%ecx	# Function arg: int len
	movl 12(%esp),%esi	# Function arg: unsigned char *buff
	testl $2, %esi		# Check alignment.
	jz 2f			# Jump if alignment is ok.
	subl $2, %ecx		# Alignment uses up two bytes.
	jae 1f			# Jump if we had at least two bytes.
	addl $2, %ecx		# ecx was < 2.  Deal with it.
	jmp 4f
1:	movw (%esi), %bx
	addl $2, %esi
	addw %bx, %ax
	adcl $0, %eax
2:
	movl %ecx, %edx
	shrl $5, %ecx
	jz 2f
	testl %esi, %esi
1:	movl (%esi), %ebx
	adcl %ebx, %eax
	movl 4(%esi), %ebx
	adcl %ebx, %eax
	movl 8(%esi), %ebx
	adcl %ebx, %eax
	movl 12(%esi), %ebx
	adcl %ebx, %eax
	movl 16(%esi), %ebx
	adcl %ebx, %eax
	movl 20(%esi), %ebx
	adcl %ebx, %eax
	movl 24(%esi), %ebx
	adcl %ebx, %eax
	movl 28(%esi), %ebx
	adcl %ebx, %eax
	lea 32(%esi), %esi
	dec %ecx
	jne 1b
	adcl $0, %eax
2:	movl %edx, %ecx
	andl $0x1c, %edx
	je 4f
	shrl $2, %edx		# This clears CF
3:	adcl (%esi), %eax
	lea 4(%esi), %esi
	dec %edx
	jne 3b
	adcl $0, %eax
4:	andl $3, %ecx
	jz 7f
	cmpl $2, %ecx
	jb 5f
	movw (%esi),%cx
	leal 2(%esi),%esi
	je 6f
	shll $16,%ecx
5:	movb (%esi),%cl
6:	addl %ecx,%eax
	adcl $0, %eax 
7:	
	popl %ebx
	popl %esi
	ret

#else

/* Version for PentiumII/PPro */

csum_partial:
	pushl %esi
	pushl %ebx
	movl 20(%esp),%eax	# Function arg: unsigned int sum
	movl 16(%esp),%ecx	# Function arg: int len
	movl 12(%esp),%esi	# Function arg:	const unsigned char *buf

	testl $2, %esi         
	jnz 30f                 
10:
	movl %ecx, %edx
	movl %ecx, %ebx
	andl $0x7c, %ebx
	shrl $7, %ecx
	addl %ebx,%esi
	shrl $2, %ebx  
	negl %ebx
	lea 45f(%ebx,%ebx,2), %ebx
	testl %esi, %esi
	jmp *%ebx

	# Handle 2-byte-aligned regions
20:	addw (%esi), %ax
	lea 2(%esi), %esi
	adcl $0, %eax
	jmp 10b

30:	subl $2, %ecx          
	ja 20b                 
	je 32f
	movzbl (%esi),%ebx	# csumming 1 byte, 2-aligned
	addl %ebx, %eax
	adcl $0, %eax
	jmp 80f
32:
	addw (%esi), %ax	# csumming 2 bytes, 2-aligned
	adcl $0, %eax
	jmp 80f

40: 
	addl -128(%esi), %eax
	adcl -124(%esi), %eax
	adcl -120(%esi), %eax
	adcl -116(%esi), %eax   
	adcl -112(%esi), %eax   
	adcl -108(%esi), %eax
	adcl -104(%esi), %eax
	adcl -100(%esi), %eax
	adcl -96(%esi), %eax
	adcl -92(%esi), %eax
	adcl -88(%esi), %eax
	adcl -84(%esi), %eax
	adcl -80(%esi), %eax
	adcl -76(%esi), %eax
	adcl -72(%esi), %eax
	adcl -68(%esi), %eax
	adcl -64(%esi), %eax     
	adcl -60(%esi), %eax     
	adcl -56(%esi), %eax     
	adcl -52(%esi), %eax   
	adcl -48(%esi), %eax   
	adcl -44(%esi), %eax
	adcl -40(%esi), %eax
	adcl -36(%esi), %eax
	adcl -32(%esi), %eax
	adcl -28(%esi), %eax
	adcl -24(%esi), %eax
	adcl -20(%esi), %eax
	adcl -16(%esi), %eax
	adcl -12(%esi), %eax
	adcl -8(%esi), %eax
	adcl -4(%esi), %eax
45:
	lea 128(%esi), %esi
	adcl $0, %eax
	dec %ecx
	jge 40b
	movl %edx, %ecx
50:	andl $3, %ecx
	jz 80f

	# Handle the last 1-3 bytes without jumping
	notl %ecx		# 1->2, 2->1, 3->0, higher bits are masked
	movl $0xffffff,%ebx	# by the shll and shrl instructions
	shll $3,%ecx
	shrl %cl,%ebx
	andl -128(%esi),%ebx	# esi is 4-aligned so should be ok
	addl %ebx,%eax
	adcl $0,%eax
80: 
	popl %ebx
	popl %esi
	ret
				
#endif
	EXPORT_SYMBOL(csum_partial)
Commit	Line	Data
2874c5fd	1	/* SPDX-License-Identifier: GPL-2.0-or-later */
1da177e4 LT	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	* Authors: Jorge Cwik, <jorge@laser.satlink.net>
	10	* Arnt Gulbrandsen, <agulbra@nvg.unit.no>
	11	* Tom May, <ftom@netcom.com>
	12	* Pentium Pro/II routines:
	13	* Alexander Kjeldaas <astor@guardian.no>
	14	* Finn Arne Gangstad <finnag@guardian.no>
	15	* Lots of code moved from tcp.c and ip.c; see those files
	16	* for more names.
	17	*
	18	* Changes: Ingo Molnar, converted csum_partial_copy() to 2.1 exception
	19	* handling.
	20	* Andi Kleen, add zeroing on error
	21	* converted to pure assembler
1da177e4 LT	22	*/
1da177e4 LT	23
1da177e4	24	#include <asm/errno.h>
f542c5d6	25	#include <asm/asm.h>
784d5699	26	#include <asm/export.h>
1da177e4 LT	27
	28	/*
	29	* computes a partial checksum, e.g. for TCP/UDP fragments
	30	*/
	31
	32	/*
	33	unsigned int csum_partial(const unsigned char * buff, int len, unsigned int sum)
	34	*/
	35
	36	.text
	37	.align 4
7d37c6d5	38	.globl csum_partial
1da177e4 LT	39
	40	#ifndef CONFIG_X86_USE_PPRO_CHECKSUM
	41
	42	/*
	43	* Experiments with Ethernet and SLIP connections show that buff
	44	* is aligned on either a 2-byte or 4-byte boundary. We get at
	45	* least a twofold speedup on 486 and Pentium if it is 4-byte aligned.
	46	* Fortunately, it is easy to convert 2-byte alignment to 4-byte
	47	* alignment for the unrolled loop.
	48	*/
7d37c6d5	49	csum_partial:
1da177e4 LT	50	pushl %esi
	51	pushl %ebx
	52	movl 20(%esp),%eax # Function arg: unsigned int sum
	53	movl 16(%esp),%ecx # Function arg: int len
	54	movl 12(%esp),%esi # Function arg: unsigned char *buff
	55	testl $2, %esi # Check alignment.
	56	jz 2f # Jump if alignment is ok.
	57	subl $2, %ecx # Alignment uses up two bytes.
	58	jae 1f # Jump if we had at least two bytes.
	59	addl $2, %ecx # ecx was < 2. Deal with it.
	60	jmp 4f
	61	1: movw (%esi), %bx
	62	addl $2, %esi
	63	addw %bx, %ax
	64	adcl $0, %eax
	65	2:
	66	movl %ecx, %edx
	67	shrl $5, %ecx
	68	jz 2f
	69	testl %esi, %esi
	70	1: movl (%esi), %ebx
	71	adcl %ebx, %eax
	72	movl 4(%esi), %ebx
	73	adcl %ebx, %eax
	74	movl 8(%esi), %ebx
	75	adcl %ebx, %eax
	76	movl 12(%esi), %ebx
	77	adcl %ebx, %eax
	78	movl 16(%esi), %ebx
	79	adcl %ebx, %eax
	80	movl 20(%esi), %ebx
	81	adcl %ebx, %eax
	82	movl 24(%esi), %ebx
	83	adcl %ebx, %eax
	84	movl 28(%esi), %ebx
	85	adcl %ebx, %eax
	86	lea 32(%esi), %esi
	87	dec %ecx
	88	jne 1b
	89	adcl $0, %eax
	90	2: movl %edx, %ecx
	91	andl $0x1c, %edx
	92	je 4f
	93	shrl $2, %edx # This clears CF
	94	3: adcl (%esi), %eax
	95	lea 4(%esi), %esi
	96	dec %edx
	97	jne 3b
	98	adcl $0, %eax
	99	4: andl $3, %ecx
	100	jz 7f
	101	cmpl $2, %ecx
	102	jb 5f
	103	movw (%esi),%cx
	104	leal 2(%esi),%esi
	105	je 6f
	106	shll $16,%ecx
	107	5: movb (%esi),%cl
	108	6: addl %ecx,%eax
	109	adcl $0, %eax
	110	7:
	111	popl %ebx
	112	popl %esi
	113	ret
114
115	#else
116
117	/* Version for PentiumII/PPro */
118
7d37c6d5	119	csum_partial:
1da177e4 LT	120	pushl %esi
	121	pushl %ebx
	122	movl 20(%esp),%eax # Function arg: unsigned int sum
	123	movl 16(%esp),%ecx # Function arg: int len
	124	movl 12(%esp),%esi # Function arg: const unsigned char *buf
	125
	126	testl $2, %esi
	127	jnz 30f
	128	10:
	129	movl %ecx, %edx
	130	movl %ecx, %ebx
	131	andl $0x7c, %ebx
	132	shrl $7, %ecx
	133	addl %ebx,%esi
	134	shrl $2, %ebx
	135	negl %ebx
	136	lea 45f(%ebx,%ebx,2), %ebx
	137	testl %esi, %esi
	138	jmp *%ebx
	139
	140	# Handle 2-byte-aligned regions
	141	20: addw (%esi), %ax
	142	lea 2(%esi), %esi
	143	adcl $0, %eax
	144	jmp 10b
	145
	146	30: subl $2, %ecx
	147	ja 20b
	148	je 32f
	149	movzbl (%esi),%ebx # csumming 1 byte, 2-aligned
	150	addl %ebx, %eax
	151	adcl $0, %eax
	152	jmp 80f
	153	32:
	154	addw (%esi), %ax # csumming 2 bytes, 2-aligned
	155	adcl $0, %eax
	156	jmp 80f
	157
	158	40:
	159	addl -128(%esi), %eax
	160	adcl -124(%esi), %eax
	161	adcl -120(%esi), %eax
	162	adcl -116(%esi), %eax
	163	adcl -112(%esi), %eax
	164	adcl -108(%esi), %eax
	165	adcl -104(%esi), %eax
	166	adcl -100(%esi), %eax
	167	adcl -96(%esi), %eax
	168	adcl -92(%esi), %eax
	169	adcl -88(%esi), %eax
	170	adcl -84(%esi), %eax
	171	adcl -80(%esi), %eax
	172	adcl -76(%esi), %eax
	173	adcl -72(%esi), %eax
	174	adcl -68(%esi), %eax
	175	adcl -64(%esi), %eax
	176	adcl -60(%esi), %eax
	177	adcl -56(%esi), %eax
	178	adcl -52(%esi), %eax
	179	adcl -48(%esi), %eax
	180	adcl -44(%esi), %eax
	181	adcl -40(%esi), %eax
	182	adcl -36(%esi), %eax
	183	adcl -32(%esi), %eax
184	adcl -28(%esi), %eax
185	adcl -24(%esi), %eax
186	adcl -20(%esi), %eax
187	adcl -16(%esi), %eax
188	adcl -12(%esi), %eax
189	adcl -8(%esi), %eax
190	adcl -4(%esi), %eax
191	45:
192	lea 128(%esi), %esi
193	adcl $0, %eax
194	dec %ecx
195	jge 40b
196	movl %edx, %ecx
197	50: andl $3, %ecx
198	jz 80f
199
200	# Handle the last 1-3 bytes without jumping
201	notl %ecx # 1->2, 2->1, 3->0, higher bits are masked
202	movl $0xffffff,%ebx # by the shll and shrl instructions
203	shll $3,%ecx
204	shrl %cl,%ebx
205	andl -128(%esi),%ebx # esi is 4-aligned so should be ok
206	addl %ebx,%eax
207	adcl $0,%eax
208	80:
209	popl %ebx
210	popl %esi
211	ret
212
213	#endif
784d5699	214	EXPORT_SYMBOL(csum_partial)