LoongArch: Add some library functions

/* SPDX-License-Identifier: GPL-2.0 */

/*

 * Copyright (C) 2020-2022 Loongson Technology Corporation Limited

 */

#ifndef _ASM_DELAY_H

#define _ASM_DELAY_H

#include <linux/param.h>

extern void __delay(unsigned long cycles);

extern void __ndelay(unsigned long ns);

extern void __udelay(unsigned long us);

#define ndelay(ns) __ndelay(ns)

#define udelay(us) __udelay(us)

/* make sure "usecs *= ..." in udelay do not overflow. */

#if HZ >= 1000

#define MAX_UDELAY_MS	1

#elif HZ <= 200

#define MAX_UDELAY_MS	5

#else

#define MAX_UDELAY_MS	(1000 / HZ)

#endif

#endif /* _ASM_DELAY_H */

/* SPDX-License-Identifier: GPL-2.0 */

/*

 * Copyright (C) 2020-2022 Loongson Technology Corporation Limited

 */

#ifndef _ASM_STRING_H

#define _ASM_STRING_H

extern void *memset(void *__s, int __c, size_t __count);

extern void *memcpy(void *__to, __const__ void *__from, size_t __n);

extern void *memmove(void *__dest, __const__ void *__src, size_t __n);

#endif /* _ASM_STRING_H */

/* SPDX-License-Identifier: GPL-2.0 */

/*

 * Copyright (C) 2020-2022 Loongson Technology Corporation Limited

 */

#include <asm/asm.h>

#include <asm/asmmacro.h>

#include <asm/export.h>

#include <asm/regdef.h>

.macro fixup_ex from, to, offset, fix

.if \fix

	.section .fixup, "ax"

\to:	addi.d	a0, a1, \offset

	jr	ra

	.previous

.endif

	.section __ex_table, "a"

	PTR	\from\()b, \to\()b

	.previous

.endm

/*

 * unsigned long __clear_user(void *addr, size_t size)

 *

 * a0: addr

 * a1: size

 */

SYM_FUNC_START(__clear_user)

	beqz	a1, 2f

1:	st.b	zero, a0, 0

	addi.d	a0, a0, 1

	addi.d	a1, a1, -1

	bgt	a1, zero, 1b

2:	move	a0, a1

	jr	ra

	fixup_ex 1, 3, 0, 1

SYM_FUNC_END(__clear_user)

EXPORT_SYMBOL(__clear_user)

/* SPDX-License-Identifier: GPL-2.0 */

/*

 * Copyright (C) 2020-2022 Loongson Technology Corporation Limited

 */

#include <asm/asm.h>

#include <asm/asmmacro.h>

#include <asm/export.h>

#include <asm/regdef.h>

.macro fixup_ex from, to, offset, fix

.if \fix

	.section .fixup, "ax"

\to:	addi.d	a0, a2, \offset

	jr	ra

	.previous

.endif

	.section __ex_table, "a"

	PTR	\from\()b, \to\()b

	.previous

.endm

/*

 * unsigned long __copy_user(void *to, const void *from, size_t n)

 *

 * a0: to

 * a1: from

 * a2: n

 */

SYM_FUNC_START(__copy_user)

	beqz	a2, 3f

1:	ld.b	t0, a1, 0

2:	st.b	t0, a0, 0

	addi.d	a0, a0, 1

	addi.d	a1, a1, 1

	addi.d	a2, a2, -1

	bgt	a2, zero, 1b

3:	move	a0, a2

	jr	ra

	fixup_ex 1, 4, 0, 1

	fixup_ex 2, 4, 0, 0

SYM_FUNC_END(__copy_user)

EXPORT_SYMBOL(__copy_user)

// SPDX-License-Identifier: GPL-2.0

/*

 * Copyright (C) 2020-2022 Loongson Technology Corporation Limited

 */

#include <linux/delay.h>

#include <linux/export.h>

#include <linux/smp.h>

#include <linux/timex.h>

#include <asm/compiler.h>

#include <asm/processor.h>

void __delay(unsigned long cycles)

{

	u64 t0 = get_cycles();

	while ((unsigned long)(get_cycles() - t0) < cycles)

		cpu_relax();

}

EXPORT_SYMBOL(__delay);

/*

 * Division by multiplication: you don't have to worry about

 * loss of precision.

 *

 * Use only for very small delays ( < 1 msec).	Should probably use a

 * lookup table, really, as the multiplications take much too long with

 * short delays.  This is a "reasonable" implementation, though (and the

 * first constant multiplications gets optimized away if the delay is

 * a constant)

 */

void __udelay(unsigned long us)

{

	__delay((us * 0x000010c7ull * HZ * lpj_fine) >> 32);

}

EXPORT_SYMBOL(__udelay);

void __ndelay(unsigned long ns)

{

	__delay((ns * 0x00000005ull * HZ * lpj_fine) >> 32);

}

EXPORT_SYMBOL(__ndelay);