Orange Pi5 kernel

/* SPDX-License-Identifier: GPL-2.0-only */
/*
 *  linux/arch/arm/lib/div64.S
 *
 *  Optimized computation of 64-bit dividend / 32-bit divisor
 *
 *  Author:	Nicolas Pitre
 *  Created:	Oct 5, 2003
 *  Copyright:	Monta Vista Software, Inc.
 */
 
#include <linux/linkage.h>
#include <asm/assembler.h>
#include <asm/unwind.h>
 
#ifdef __ARMEB__
#define xh r0
#define xl r1
#define yh r2
#define yl r3
#else
#define xl r0
#define xh r1
#define yl r2
#define yh r3
#endif
 
/*
 * __do_div64: perform a division with 64-bit dividend and 32-bit divisor.
 *
 * Note: Calling convention is totally non standard for optimal code.
 *       This is meant to be used by do_div() from include/asm/div64.h only.
 *
 * Input parameters:
 * 	xh-xl	= dividend (clobbered)
 * 	r4	= divisor (preserved)
 *
 * Output values:
 * 	yh-yl	= result
 * 	xh	= remainder
 *
 * Clobbered regs: xl, ip
 */
 
ENTRY(__do_div64)
UNWIND(.fnstart)
 
<------>@ Test for easy paths first.
<------>subs	ip, r4, #1
<------>bls	9f			@ divisor is 0 or 1
<------>tst	ip, r4
<------>beq	8f			@ divisor is power of 2
 
<------>@ See if we need to handle upper 32-bit result.
<------>cmp	xh, r4
<------>mov	yh, #0
<------>blo	3f
 
<------>@ Align divisor with upper part of dividend.
<------>@ The aligned divisor is stored in yl preserving the original.
<------>@ The bit position is stored in ip.
 
#if __LINUX_ARM_ARCH__ >= 5
 
<------>clz	yl, r4
<------>clz	ip, xh
<------>sub	yl, yl, ip
<------>mov	ip, #1
<------>mov	ip, ip, lsl yl
<------>mov	yl, r4, lsl yl
 
#else
 
<------>mov	yl, r4
<------>mov	ip, #1
1:	cmp	yl, #0x80000000
<------>cmpcc	yl, xh
<------>movcc	yl, yl, lsl #1
<------>movcc	ip, ip, lsl #1
<------>bcc	1b
 
#endif
 
<------>@ The division loop for needed upper bit positions.
 	@ Break out early if dividend reaches 0.
2:	cmp	xh, yl
<------>orrcs	yh, yh, ip
<------>subscs	xh, xh, yl
<------>movsne	ip, ip, lsr #1
<------>mov	yl, yl, lsr #1
<------>bne	2b
 
<------>@ See if we need to handle lower 32-bit result.
3:	cmp	xh, #0
<------>mov	yl, #0
<------>cmpeq	xl, r4
<------>movlo	xh, xl
<------>retlo	lr
 
<------>@ The division loop for lower bit positions.
<------>@ Here we shift remainer bits leftwards rather than moving the
<------>@ divisor for comparisons, considering the carry-out bit as well.
<------>mov	ip, #0x80000000
4:	movs	xl, xl, lsl #1
<------>adcs	xh, xh, xh
<------>beq	6f
<------>cmpcc	xh, r4
5:	orrcs	yl, yl, ip
<------>subcs	xh, xh, r4
<------>movs	ip, ip, lsr #1
<------>bne	4b
<------>ret	lr
 
<------>@ The top part of remainder became zero.  If carry is set
<------>@ (the 33th bit) this is a false positive so resume the loop.
<------>@ Otherwise, if lower part is also null then we are done.
6:	bcs	5b
<------>cmp	xl, #0
<------>reteq	lr
 
<------>@ We still have remainer bits in the low part.  Bring them up.
 
#if __LINUX_ARM_ARCH__ >= 5
 
<------>clz	xh, xl			@ we know xh is zero here so...
<------>add	xh, xh, #1
<------>mov	xl, xl, lsl xh
<------>mov	ip, ip, lsr xh
 
#else
 
7:	movs	xl, xl, lsl #1
<------>mov	ip, ip, lsr #1
<------>bcc	7b
 
#endif
 
<------>@ Current remainder is now 1.  It is worthless to compare with
<------>@ divisor at this point since divisor can not be smaller than 3 here.
<------>@ If possible, branch for another shift in the division loop.
<------>@ If no bit position left then we are done.
<------>movs	ip, ip, lsr #1
<------>mov	xh, #1
<------>bne	4b
<------>ret	lr
 
8:	@ Division by a power of 2: determine what that divisor order is
<------>@ then simply shift values around
 
#if __LINUX_ARM_ARCH__ >= 5
 
<------>clz	ip, r4
<------>rsb	ip, ip, #31
 
#else
 
<------>mov	yl, r4
<------>cmp	r4, #(1 << 16)
<------>mov	ip, #0
<------>movhs	yl, yl, lsr #16
<------>movhs	ip, #16
 
<------>cmp	yl, #(1 << 8)
<------>movhs	yl, yl, lsr #8
<------>addhs	ip, ip, #8
 
<------>cmp	yl, #(1 << 4)
<------>movhs	yl, yl, lsr #4
<------>addhs	ip, ip, #4
 
<------>cmp	yl, #(1 << 2)
<------>addhi	ip, ip, #3
<------>addls	ip, ip, yl, lsr #1
 
#endif
 
<------>mov	yh, xh, lsr ip
<------>mov	yl, xl, lsr ip
<------>rsb	ip, ip, #32
 ARM(	orr	yl, yl, xh, lsl ip	)
 THUMB(	lsl	xh, xh, ip		)
 THUMB(	orr	yl, yl, xh		)
<------>mov	xh, xl, lsl ip
<------>mov	xh, xh, lsr ip
<------>ret	lr
 
<------>@ eq -> division by 1: obvious enough...
9:	moveq	yl, xl
<------>moveq	yh, xh
<------>moveq	xh, #0
<------>reteq	lr
UNWIND(.fnend)
 
UNWIND(.fnstart)
UNWIND(.pad #4)
UNWIND(.save {lr})
Ldiv0_64:
<------>@ Division by 0:
<------>str	lr, [sp, #-8]!
<------>bl	__div0
 
<------>@ as wrong as it could be...
<------>mov	yl, #0
<------>mov	yh, #0
<------>mov	xh, #0
<------>ldr	pc, [sp], #8
 
UNWIND(.fnend)
ENDPROC(__do_div64)