aboutsummaryrefslogtreecommitdiff
path: root/keymaps/onekey/stm32f411
diff options
context:
space:
mode:
Diffstat (limited to 'keymaps/onekey/stm32f411')
-rw-r--r--keymaps/onekey/stm32f411/config.h12
-rw-r--r--keymaps/onekey/stm32f411/keymap.c6
-rw-r--r--keymaps/onekey/stm32f411/qfplib/qfplib.h26
-rw-r--r--keymaps/onekey/stm32f411/qfplib/qfplib.s832
-rw-r--r--keymaps/onekey/stm32f411/rules.mk3
5 files changed, 0 insertions, 879 deletions
diff --git a/keymaps/onekey/stm32f411/config.h b/keymaps/onekey/stm32f411/config.h
deleted file mode 100644
index 668ebfb..0000000
--- a/keymaps/onekey/stm32f411/config.h
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright 2025 [email protected]
-// SPDX-License-Identifier: GPL-2.0-or-later
-#pragma once
-
-#undef ADC_PIN
-#undef BACKLIGHT_PIN
-#undef MATRIX_ROW_PINS
-#undef MATRIX_COL_PINS
-#define DIRECT_PINS \
- { \
- { A0 } \
- }
diff --git a/keymaps/onekey/stm32f411/keymap.c b/keymaps/onekey/stm32f411/keymap.c
deleted file mode 100644
index 36202c2..0000000
--- a/keymaps/onekey/stm32f411/keymap.c
+++ /dev/null
@@ -1,6 +0,0 @@
-// Copyright 2025 [email protected]
-// SPDX-License-Identifier: GPL-2.0-or-later
-#include QMK_KEYBOARD_H
-
-const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
- LAYOUT_ortho_1x1(KC_A)};
diff --git a/keymaps/onekey/stm32f411/qfplib/qfplib.h b/keymaps/onekey/stm32f411/qfplib/qfplib.h
deleted file mode 100644
index d172da8..0000000
--- a/keymaps/onekey/stm32f411/qfplib/qfplib.h
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright 2015 Mark Owen ([email protected])
-// SPDX-License-Identifier: GPL-2.0-or-later
-#pragma once
-
-extern float qfp_fadd(float x, float y);
-extern float qfp_fsub(float x, float y);
-extern float qfp_fmul(float x, float y);
-extern float qfp_fdiv(float x, float y);
-extern float qfp_fdiv_fast(float x, float y);
-extern int qfp_float2int(float x);
-extern int qfp_float2fix(float x, int y);
-extern unsigned int qfp_float2uint(float x);
-extern unsigned int qfp_float2ufix(float x, int y);
-extern float qfp_int2float(int x);
-extern float qfp_fix2float(int x, int y);
-extern float qfp_uint2float(unsigned int x);
-extern float qfp_ufix2float(unsigned int x, int y);
-extern int qfp_fcmp(float x, float y);
-extern float qfp_fcos(float x);
-extern float qfp_fsin(float x);
-extern float qfp_ftan(float x);
-extern float qfp_fatan2(float y, float x);
-extern float qfp_fexp(float x);
-extern float qfp_fln(float x);
-extern float qfp_fsqrt(float x);
-extern float qfp_fsqrt_fast(float x);
diff --git a/keymaps/onekey/stm32f411/qfplib/qfplib.s b/keymaps/onekey/stm32f411/qfplib/qfplib.s
deleted file mode 100644
index e035472..0000000
--- a/keymaps/onekey/stm32f411/qfplib/qfplib.s
+++ /dev/null
@@ -1,832 +0,0 @@
-// Copyright 2015 Mark Owen ([email protected])
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-.ifndef include_faster
-.equ include_faster,1
-.endif
-
-.ifndef include_conversions
-.equ include_conversions,1
-.endif
-
-.ifndef include_scientific
-.equ include_scientific,1
-.endif
-
-.if include_scientific
-.equ include_conversions,1
-.endif
-
-.syntax unified
-.cpu cortex-m0
-.thumb
-
-.global qfp_fadd
-.global qfp_fsub
-.global qfp_fmul
-.global qfp_fdiv
-.global qfp_fcmp
-.if include_conversions
-.global qfp_float2int
-.global qfp_float2fix
-.global qfp_float2uint
-.global qfp_float2ufix
-.global qfp_int2float
-.global qfp_fix2float
-.global qfp_uint2float
-.global qfp_ufix2float
-.endif
-.if include_scientific
-.global qfp_fcos
-.global qfp_fsin
-.global qfp_ftan
-.global qfp_fatan2
-.global qfp_fexp
-.global qfp_fln
-.global qfp_fsqrt
-.endif
-
-.if include_faster
-.global qfp_fdiv_fast
-.global qfp_fsqrt_fast
-.endif
-
-// exchange r0<->r1, r2<->r3
-xchxy:
- push {r0,r2,r14}
- mov r0,r1
- mov r2,r3
- pop {r1,r3,r15}
-
-// IEEE single precision floats in r0,r1-> mantissae in r1,r0 exponents in r3,r2 *respectively*
-// trashes r4
-unpackxy:
- push {r14}
- bl unpackx
- bl xchxy
- pop {r4}
- mov r14,r4
-
-// IEEE single in r0-> signed (two's complemennt) mantissa in r0 9Q23 (24 significant bits), signed exponent (bias removed) in r2
-// trashes r4; zero, denormal -> mantissa=+/-1, exponent=-380; Inf, NaN -> mantissa=+/-1, exponent=+640
-unpackx:
- lsrs r2,r0,#23 // save exponent and sign
- lsls r0,#9 // extract mantissa
- lsrs r0,#9
- movs r4,#1
- lsls r4,#23
- orrs r0,r4 // reinstate implied leading 1
- cmp r2,#255 // test sign bit
- uxtb r2,r2 // clear it
- bls 1f // branch on positive
- rsbs r0,#0 // negate mantissa
-1:
- subs r2,#1
- cmp r2,#254 // zero/denormal/Inf/NaN?
- bhs 2f
- subs r2,#126 // remove exponent bias: can now be -126..+127
- bx r14
-
-2: // here with special-case values
- cmp r0,#0
- mov r0,r4 // set mantissa to +1
- bpl 3f
- rsbs r0,#0 // zero/denormal/Inf/NaN: mantissa=+/-1
-3:
- subs r2,#126 // zero/denormal: exponent -> -127; Inf, NaN: exponent -> 128
- lsls r2,#2 // zero/denormal: exponent -> -508; Inf, NaN: exponent -> 512
- adds r2,#128 // zero/denormal: exponent -> -380; Inf, NaN: exponent -> 640
- bx r14
-
-// normalise and pack signed mantissa in r0 nominally 3Q29, signed exponent in r2-> IEEE single in r0
-// trashes r4, preserves r1,r3
-// r5: "sticky bits", must be zero iff all result bits below r0 are zero for correct rounding
-packx:
- lsrs r4,r0,#31 // save sign bit
- lsls r4,r4,#31 // sign now in b31
- bpl 2f // skip if positive
- cmp r5,#0
- beq 11f
- adds r0,#1 // fiddle carry in to following rsb if sticky bits are non-zero
-11:
- rsbs r0,#0 // can now treat r0 as unsigned
-packx0:
- bmi 3f // catch r0=0x80000000 case
-2:
- subs r2,#1 // normalisation loop
- adds r0,r0
- beq 1f // zero? special case
- bpl 2b // normalise so leading "1" in bit 31
-3:
- adds r2,#129 // (mis-)offset exponent
- bne 12f // special case: highest denormal can round to lowest normal
- adds r0,#0x80 // in special case, need to add 256 to r0 for rounding
- bcs 4f // tripped carry? then have leading 1 in C as required
-12:
- adds r0,#0x80 // rounding
- bcs 4f // tripped carry? then have leading 1 in C as required (and result is even so can ignore sticky bits)
- cmp r5,#0
- beq 7f // sticky bits zero?
-8:
- lsls r0,#1 // remove leading 1
-9:
- subs r2,#1 // compensate exponent on this path
-4:
- cmp r2,#254
- bge 5f // overflow?
- adds r2,#1 // correct exponent offset
- ble 10f // denormal/underflow?
- lsrs r0,#9 // align mantissa
- lsls r2,#23 // align exponent
- orrs r0,r2 // assemble exponent and mantissa
-6:
- orrs r0,r4 // apply sign
-1:
- bx r14
-
-5:
- movs r0,#0xff // create infinity
- lsls r0,#23
- b 6b
-
-10:
- movs r0,#0 // create zero
- bx r14
-
-7: // sticky bit rounding case
- lsls r5,r0,#24 // check bottom 8 bits of r0
- bne 8b // in rounding-tie case?
- lsrs r0,#9 // ensure even result
- lsls r0,#10
- b 9b
-
-// unpack two arguments (r0,r1) and shift one down to have common exponent, returned in r2; note that arguments are exchanged
-// sticky bits shifted off bottom of smaller argument in r5
-// following code is unnecessarily general for fadd, but is shared with atan2
-unpackxyalign:
- push {r14}
- bl unpackxy
- lsls r0,r0,#6 // Q29
- lsls r1,r1,#6 // Q29
- subs r4,r2,r3 // calculate shift
- bge 1f // x>=y?
- mov r2,r3 // no: take common exponent from y
- mov r5,r0 // potential sticky bits from x
- rsbs r4,#0 // make shift positive
- asrs r0,r4
- cmp r4,#32
- blo 2f
- movs r0,#0 // large shift, so all bits are sticky and result is zero
- pop {r15}
-1:
- mov r5,r1 // common exponent from x; potential sticky bits from y
- asrs r1,r4
- cmp r4,#32
- blo 2f
- movs r1,#0 // large shift, so all bits are sticky and result is zero
- pop {r15}
-2:
- rsbs r4,#0
- adds r4,#32
- lsls r5,r4 // extract sticky bits
- pop {r15}
-
-.thumb_func
-qfp_fsub:
- movs r2,#1 // subtract: flip sign bit of second argument and fall through to fadd
- lsls r2,#31
- eors r1,r2
-.thumb_func
-qfp_fadd:
- push {r4,r5,r14}
- bl unpackxyalign
- adds r0,r1 // do addition
- bne 2f // not in Inf-Inf case?
- cmp r2,#200
- blt 2f
- movs r0,#1
- lsls r0,#29 // for Inf-Inf, set mantissa to +1 to prevent zero result
-2:
-packret: // common return point: "pack and return"
- bl packx
- pop {r4,r5,r15}
-
-// signed multiply r0 1Q23 by r1 4Q23, result in r0 7Q25, sticky bits in r5
-// trashes r3,r4
-mul0:
- uxth r3,r0 // Q23
- asrs r4,r1,#16 // Q7
- muls r3,r4 // L*H, Q30 signed
- asrs r4,r0,#16 // Q7
- uxth r5,r1 // Q23
- muls r4,r5 // H*L, Q30 signed
- adds r3,r4 // sum of middle partial products
- uxth r4,r0
- muls r4,r5 // L*L, Q46 unsigned
- lsls r5,r4,#16 // initialise sticky bits from low half of low partial product
- lsrs r4,#16 // Q25
- adds r3,r4 // add high half of low partial product to sum of middle partial products
- // (cannot generate carry by limits on input arguments)
- asrs r0,#16 // Q7
- asrs r1,#16 // Q7
- muls r0,r1 // H*H, Q14 signed
- lsls r0,#11 // high partial product Q25
- lsls r1,r3,#27 // sticky
- orrs r5,r1 // collect further sticky bits
- asrs r1,r3,#5 // middle partial products Q25
- adds r0,r1 // final result
- bx r14
-
-.thumb_func
-qfp_fcmp:
- movs r2,#1 // initialise result
- lsls r3,r2,#31 // r3=0x80000000
- tst r0,r3 // check sign of first argument
- beq 1f
- subs r0,r3,r0 // convert to 2's complement form for direct comparison
-1:
- tst r1,r3 // repeat for second argument
- beq 2f
- subs r1,r3,r1
-2:
- subs r0,r1 // perform comparison
- beq 4f // equal? return 0
- bgt 3f // r0>r1? return +1
- rsbs r2,#0 // r0<r1: return -1
-3:
- mov r0,r2
-4:
- bx r14
-
-.thumb_func
-qfp_fmul:
- push {r4,r5,r14}
- bl unpackxy
- add r2,r3 // sum exponents
- adds r2,#4 // adjust exponent for pack which expects Q29
-fmul0:
- bl mul0
- b packret
-
-.thumb_func
-qfp_fdiv:
- push {r4,r5,r14}
-fdiv_n:
- bl unpackxy
- movs r5,#1 // result cannot fall exactly half-way between two representable numbers (exercise for reader - note that
- // we do not handle denormals) so there will always be sticky bits
- cmp r0,#0 // check divisor sign
- bpl 1f
- rsbs r0,#0 // ensure divisor positive
- rsbs r1,#0 // preserve sign of result
-1:
- movs r4,#0
- cmp r1,#0 // check sign of dividend
- bpl 2f
- rsbs r1,#0 // result will be negative
- mvns r4,r4 // save sign as 0x00000000 or 0xffffffff
-2: // now do unsigned division on unpacked values {r1,r3}/{r0,r2}
- cmp r3,#200 // dividend is an infinity? return it
- bge 3f
- rsbs r2,#0
- cmp r2,#200 // divisor is zero? return infinity
- bge 3f
- adds r2,r3 // difference of exponents
- movs r3,#0x40 // termination marker (calculate enough bits to do rounding correctly)
-2: // division loop
- subs r1,r0 // trial subtraction
- bcs 1f
- add r1,r0 // restore if failed
-1:
- adcs r3,r3 // shift in result bit
- add r1,r1 // shift up dividend
- bcc 2b // loop until marker appears in carry
- lsls r0,r3,#4 // align for packing
-4:
- eors r0,r4 // apply sign
- b packret
-infret:
- movs r4,#0
-3:
- mov r0,r1
- movs r2,#255 // return infinity
- b 4b
-
-.if include_faster
-
-// The fast divide routine uses an initial approximation to the reciprocal of the divisor based on the top four bits of the mantissa
-// followed by three Newton-Raphson iterations, resulting in about 27 bits of accuracy. This reciprocal is then multiplied by
-// the dividend.
-// The (fixed-point) reciprocal calculation is carefully implemented to preserve the necessary accuracy throughout. In places
-// the implied binary point is not within the stored value. For example where "Q47" is shown below it means that the least
-// significant bit of the value has significance 2^-47 and hence the most significant bit has significance 2^-16. In these
-// cases the value is known to be very close to an integer (usually 1) and so the bits of greater significance do not need
-// to be stored.
-// The reciprocal calculation has been tested for all possible input mantissa values.
-.thumb_func
-qfp_fdiv_fast:
- push {r4,r5,r14}
-fdiv_fast_n:
- bl unpackxy
- cmp r0,#0
- bpl 1f
- rsbs r0,#0
- rsbs r1,#0 // ensure divisor positive
-1:
- cmp r3,#200
- bge infret // dividend is an infinity? return it
- rsbs r2,#0
- cmp r2,#200 // divisor is zero?
- bge infret // return infinity
- adds r2,r3 // difference of exponents
- adr r4,rcpapp-8 // the first 8 elements of the table are never accessed because of the mantissa's leading 1
- lsrs r3,r0,#20 // y Q23; y>>20 Q7
- ldrb r4,[r4,r3] // m=rcpapp[(y>>20)&7]; // Q8, .5<m<1
-
- lsls r3,r4,#2 // m<<2 // Q10 first Newton-Raphson iteration
- muls r3,r0 // s=y*(m<<2); // Q33
- lsls r4,#8 // m<<=8; // Q16
- asrs r3,#21 // s>>=21; // Q12
- muls r3,r4 // s*=m; // Q28
- asrs r3,#12 // s>>=12; // Q16
- subs r4,r3 // m=m-s; // Q16
-
- mov r3,r4 // s=y*m // Q39 second Newton-Raphson iteration
- muls r4,r0 // ...
- asrs r4,#16 // s>>=16; // Q23
- muls r4,r3 // s*=m; // Q39
- lsls r3,#8 // m<<=8; // Q24
- asrs r4,#15 // s>>=15; // Q24
- subs r3,r4 // m=m-s; // Q24
-
- lsls r4,r3,#7 // \/ s=y*m; // Q47 third Newton-Raphson iteration
- muls r3,r0 // /\ m<<=7; // Q31
- asrs r3,#15 // s>>=15; // Q32
- lsrs r0,r4,#16 // s*=(m>>16); // Q47
- muls r3,r0 // ...
- asrs r3,#16 // s>>=16; // Q31
- subs r0,r4,r3 // m=m-s; // Q31
-div0:
- adds r0,#7 // rounding; reduce systematic error
- lsrs r0,#4 // Q27
- b fmul0 // drop into multiplication code to calculate result
-
-// The fast square root routine uses an initial approximation to the reciprocal of the square root of the argument based
-// on the top four bits of the mantissa (possibly shifted one place to make the exponent even). It then performs three
-// Newton-Raphson iterations, resulting in about 28-29 bits of accuracy. This reciprocal is then multiplied by
-// the original argument to produce the result.
-// Again, the fixed-point calculation is carefully implemented to preserve accuracy, and similar comments to those
-// made above on the fast division routine apply.
-// The reciprocal square root calculation has been tested for all possible (possibly shifted) input mantissa values.
-.thumb_func
-qfp_fsqrt_fast:
- push {r4,r5,r14}
- bl unpackx
- movs r1,r0
- bmi infret // negative? return -Inf
- asrs r0,r2,#1 // check LSB of exponent
- bcc 1f
- lsls r1,#1 // was odd: double mantissa; mantissa y now 1..4 Q23
-1:
- adds r2,#4 // correction for packing
- adr r4,rsqrtapp-4// first four table entries are never accessed because of the mantissa's leading 1
- lsrs r3,r1,#21 // y>>21 Q2
- ldrb r4,[r4,r3] // initial approximation to reciprocal square root m Q8
-
- lsrs r0,r1,#7 // y>>7 // Q16 first Newton-Raphson iteration
- muls r0,r4 // m*y
- muls r0,r4 // s=m*y*y // Q32
- asrs r0,#12 // s>>12
- muls r0,r4 // m*s // Q28
- asrs r0,#13 // m*s // Q15
- lsls r4,#8 // m // Q16
- subs r4,r0 // m=(m<<8)-(s>>13) // Q16-Q15/2 -> Q16
-
- mov r0,r4 // // second Newton-Raphson iteration
- muls r0,r0 // u=m*m // Q32
- lsrs r0,#16 // u>>16 // Q16
- lsrs r3,r1,#7 // y>>7 // Q16
- muls r0,r3 // s=u*(y>>7) // Q32
- asrs r0,#12 // s>>12 // Q20
- muls r0,r4 // s*m // Q36
- asrs r0,#21 // s*m // Q15
- subs r4,r0 // m=m-s // Q16-Q15/2
-
- mov r0,r4 // // third Newton-Raphson iteration
- muls r0,r0 // u=m*m // Q32
- lsrs r3,r0,#12 // now multiply u and y in two parts: u>>12
- muls r3,r1 // first partial product (u>>12)*y Q43
- lsls r0,#20
- lsrs r0,#20 // u&0xfff
- lsrs r5,r1,#12 // y>>12
- muls r0,r5 // second partial product (u&0xfff)*(y>>12) Q43
- add r0,r3 // s=u*y // Q43
- asrs r0,#15 // s>>15 // Q28
- muls r0,r4 // (s>>15)*m // Q44
- lsls r4,#13 // m<<13 // Q29
- asrs r0,#16 // s>>16 // Q28
- subs r0,r4,r0 // // Q29-Q28/2
-
- asrs r2,#1 // halve exponent
- bcc div0 // was y shifted?
- lsrs r0,#1
- lsls r1,#1 // shift y back
- b div0 // round and complete with multiplication
-
-.align 2
-
-// round(2^15./[136:16:248])
-rcpapp:
-.byte 0xf1,0xd8,0xc3,0xb2, 0xa4,0x98,0x8d,0x84
-
-// round(sqrt(2^22./[72:16:248]))
-rsqrtapp:
-.byte 0xf1,0xda,0xc9,0xbb, 0xb0,0xa6,0x9e,0x97, 0x91,0x8b,0x86,0x82
-
-.endif
-
-.if include_conversions
-
-// convert float to signed int, rounding towards -Inf, clamping
-.thumb_func
-qfp_float2int:
- movs r1,#0 // fall through
-
-// convert float in r0 to signed fixed point in r0, clamping
-.thumb_func
-qfp_float2fix:
- push {r4,r14}
- bl unpackx
- add r2,r1 // incorporate binary point position into exponent
- subs r2,#23 // r2 is now amount of left shift required
- blt 1f // requires right shift?
- cmp r2,#7 // overflow?
- ble 4f
-3: // overflow
- asrs r1,r0,#31 // +ve:0 -ve:0xffffffff
- mvns r1,r1 // +ve:0xffffffff -ve:0
- movs r0,#1
- lsls r0,#31
-5:
- eors r0,r1 // +ve:0x7fffffff -ve:0x80000000 (unsigned path: 0xffffffff)
- pop {r4,r15}
-1:
- rsbs r2,#0 // right shift for r0, >0
- cmp r2,#32
- blt 2f // more than 32 bits of right shift?
- movs r2,#32
-2:
- asrs r0,r0,r2
- pop {r4,r15}
-
-// unsigned version
-.thumb_func
-qfp_float2uint:
- movs r1,#0 // fall through
-.thumb_func
-qfp_float2ufix:
- push {r4,r14}
- bl unpackx
- add r2,r1 // incorporate binary point position into exponent
- movs r1,r0
- bmi 5b // negative? return zero
- subs r2,#23 // r2 is now amount of left shift required
- blt 1b // requires right shift?
- mvns r1,r0 // ready to return 0xffffffff
- cmp r2,#8 // overflow?
- bgt 5b
-4:
- lsls r0,r0,r2 // result fits, left shifted
- pop {r4,r15}
-
-// convert signed int to float, rounding
-.thumb_func
-qfp_int2float:
- movs r1,#0 // fall through
-
-// convert signed fix to float, rounding; number of r0 bits after point in r1
-.thumb_func
-qfp_fix2float:
- push {r4,r5,r14}
-1:
- movs r2,#29
- subs r2,r1 // fix exponent
-packretns: // pack and return, sticky bits=0
- movs r5,#0
- b packret
-
-// unsigned version
-.thumb_func
-qfp_uint2float:
- movs r1,#0 // fall through
-.thumb_func
-qfp_ufix2float:
- push {r4,r5,r14}
- cmp r0,#0
- bge 1b // treat <2^31 as signed
- movs r2,#30
- subs r2,r1 // fix exponent
- lsls r5,r0,#31 // one sticky bit
- lsrs r0,#1
- b packret
-
-.endif
-
-.if include_scientific
-
-// All the scientific functions are implemented using the CORDIC algorithm. For notation,
-// details not explained in the comments below, and a good overall survey see
-// "50 Years of CORDIC: Algorithms, Architectures, and Applications" by Meher et al.,
-// IEEE Transactions on Circuits and Systems Part I, Volume 56 Issue 9.
-
-// Register use:
-// r0: x
-// r1: y
-// r2: z/omega
-// r3: coefficient pointer
-// r4,r12: m
-// r5: i (shift)
-
-cordic_start: // initialisation
- movs r5,#0 // initial shift=0
- mov r12,r4
- b 5f
-
-cordic_vstep: // one step of algorithm in vector mode
- cmp r1,#0 // check sign of y
- bgt 4f
- b 1f
-cordic_rstep: // one step of algorithm in rotation mode
- cmp r2,#0 // check sign of angle
- bge 1f
-4:
- subs r1,r6 // negative rotation: y=y-(x>>i)
- rsbs r7,#0
- adds r2,r4 // accumulate angle
- b 2f
-1:
- adds r1,r6 // positive rotation: y=y+(x>>i)
- subs r2,r4 // accumulate angle
-2:
- mov r4,r12
- muls r7,r4 // apply sign from m
- subs r0,r7 // finish rotation: x=x{+/-}(y>>i)
-5:
- ldmia r3!,{r4} // fetch next angle from table and bump pointer
- lsrs r4,#1 // repeated angle?
- bcs 3f
- adds r5,#1 // adjust shift if not
-3:
- mov r6,r0
- asrs r6,r5 // x>>i
- mov r7,r1
- asrs r7,r5 // y>>i
- lsrs r4,#1 // shift end flag into carry
- bx r14
-
-// CORDIC rotation mode
-cordic_rot:
- push {r6,r7,r14}
- bl cordic_start // initialise
-1:
- bl cordic_rstep
- bcc 1b // step until table finished
- asrs r6,r0,#14 // remaining small rotations can be linearised: see IV.B of paper referenced above
- asrs r7,r1,#14
- asrs r2,#3
- muls r6,r2 // all remaining CORDIC steps in a multiplication
- muls r7,r2
- mov r4,r12
- muls r7,r4
- asrs r6,#12
- asrs r7,#12
- subs r0,r7 // x=x{+/-}(yz>>k)
- adds r1,r6 // y=y+(xz>>k)
-cordic_exit:
- pop {r6,r7,r15}
-
-// CORDIC vector mode
-cordic_vec:
- push {r6,r7,r14}
- bl cordic_start // initialise
-1:
- bl cordic_vstep
- bcc 1b // step until table finished
-4:
- cmp r1,#0 // continue as in cordic_vstep but without using table; x is not affected as y is small
- bgt 2f // check sign of y
- adds r1,r6 // positive rotation: y=y+(x>>i)
- subs r2,r4 // accumulate angle
- b 3f
-2:
- subs r1,r6 // negative rotation: y=y-(x>>i)
- adds r2,r4 // accumulate angle
-3:
- asrs r6,#1
- asrs r4,#1 // next "table entry"
- bne 4b
- b cordic_exit
-
-.thumb_func
-qfp_fsin: // calculate sin and cos using CORDIC rotation method
- push {r4,r5,r14}
- movs r1,#24
- bl qfp_float2fix // range reduction by repeated subtraction/addition in fixed point
- ldr r4,pi_q29
- lsrs r4,#4 // 2pi Q24
-1:
- subs r0,r4
- bge 1b
-1:
- adds r0,r4
- bmi 1b // now in range 0..2pi
- lsls r2,r0,#2 // z Q26
- lsls r5,r4,#1 // pi Q26 (r4=pi/2 Q26)
- ldr r0,=#0x136e9db4 // initialise CORDIC x,y with scaling
- movs r1,#0
-1:
- cmp r2,r4 // >pi/2?
- blt 2f
- subs r2,r5 // reduce range to -pi/2..pi/2
- rsbs r0,#0 // rotate vector by pi
- b 1b
-2:
- lsls r2,#3 // Q29
- adr r3,tab_cc // circular coefficients
- movs r4,#1 // m=1
- bl cordic_rot
- adds r1,#9 // fiddle factor to make sin(0)==0
- movs r2,#0 // exponents to zero
- movs r3,#0
- movs r5,#0 // no sticky bits
- bl packx // pack cosine
- bl xchxy
- b packretns // pack sine
-
-.thumb_func
-qfp_fcos:
- push {r14}
- bl qfp_fsin
- mov r0,r1 // extract cosine result
- pop {r15}
-
-
-.thumb_func
-qfp_ftan:
- push {r4,r5,r14}
- bl qfp_fsin // sine in r0/r2, cosine in r1/r3
-.if include_faster
- b fdiv_fast_n // sin/cos
-.else
- b fdiv_n
-
-.endif
-
-.thumb_func
-qfp_fexp: // calculate cosh and sinh using rotation method; add to obtain exp
- push {r4,r5,r14}
- movs r1,#24
- bl qfp_float2fix // Q24: covers entire valid input range
- asrs r1,r0,#16 // Q8
- ldr r2,=#5909 // log_2(e) Q12
- muls r1,r2 // estimate exponent of result Q20
- asrs r1,#19 // Q1
- adds r1,#1 // rounding
- asrs r1,#1 // rounded estimate of exponent of result
- push {r1} // save for later
- lsls r2,r0,#5 // Q29
- ldr r0,=#0x162e42ff // ln(2) Q29
- muls r1,r0 // accurate contribution of estimated exponent
- subs r2,r1 // residual to be exponentiated, approximately -.5..+.5 Q29
- ldr r0,=#0x2c9e15ca // initialise CORDIC x,y with scaling
- movs r1,#0
- adr r3,tab_ch // hyperbolic coefficients
- mvns r4,r1 // m=-1
- bl cordic_rot // calculate cosh and sinh
- add r0,r1 // exp=cosh+sinh
- pop {r2} // recover exponent
- b packretns // pack result
-
-.thumb_func
-qfp_fsqrt: // calculate sqrt and ln using vector method
- push {r4,r5,r14}
- bl unpackx
- movs r1,r0 // -ve argument?
- bmi 3f // return -Inf, -Inf
- ldr r1,=#0x0593C2B9 // scale factor for CORDIC
- bl mul0 // Q29
- asrs r1,r2,#1 // halve exponent
- bcc 1f
- adds r1,#1 // was odd: add 1 and shift mantissa
- asrs r0,#1
-1:
- push {r1} // save exponent/2 for later
- mov r1,r0
- ldr r3,=#0x0593C2B9 // re-use constant
- lsls r3,#2
- adds r0,r3 // "a+1"
- subs r1,r3 // "a-1"
- movs r2,#0
- adr r3,tab_ch // hyperbolic coefficients
- mvns r4,r2 // m=-1
- bl cordic_vec
- mov r1,r2 // keep ln result
- pop {r2} // retrieve exponent/2
-2:
- movs r3,r2
- b packretns // pack sqrt result
-
-3:
- movs r2,#255
- b 2b
-
-.thumb_func
-qfp_fln:
- push {r4,r5,r14}
- bl qfp_fsqrt // get unpacked ln in r1/r3; exponent has been halved
- cmp r3,#70 // ln(Inf)?
- bgt 3b // return Inf
- rsbs r3,#0
- cmp r3,#70
- bgt 1f // ln(0)? return -Inf
- ldr r0,=#0x0162e430 // ln(4) Q24
- muls r0,r3 // contribution from negated, halved exponent
- adds r1,#8 // round result of ln
- asrs r1,#4 // Q24
- subs r0,r1,r0 // add in contribution from (negated) exponent
- movs r2,#5 // pack expects Q29
- b packretns
-1:
- mvns r0,r0 // make result -Inf
- b 3b
-
-.thumb_func
-qfp_fatan2:
- push {r4,r5,r14}
- bl unpackxyalign // convert to fixed point (ensure common exponent, which is discarded)
- asrs r0,#1
- asrs r1,#1
- movs r2,#0 // initial angle
- cmp r0,#0 // x negative
- bge 5f
- rsbs r0,#0 // rotate to 1st/4th quadrants
- rsbs r1,#0
- ldr r2,pi_q29 // pi Q29
-5:
- adr r3,tab_cc // circular coefficients
- movs r4,#1 // m=1
- bl cordic_vec // also produces magnitude (with scaling factor 1.646760119), which is discarded
- mov r0,r2 // result here is -pi/2..3pi/2 Q29
- ldr r2,pi_q29 // pi Q29
- adds r4,r0,r2 // attempt to fix -3pi/2..-pi case
- bcs 6f // -pi/2..0? leave result as is
- subs r4,r0,r2 // <pi? leave as is
- bmi 6f
- subs r0,r4,r2 // >pi: take off 2pi
-6:
- subs r0,#1 // fiddle factor so atan2(0,1)==0
- movs r2,#0 // exponent for pack
- b packretns
-
-.align 2
-.ltorg
-
-// first entry in following table is pi Q29
-pi_q29:
-// circular CORDIC coefficients: atan(2^-i), b0=flag for preventing shift, b1=flag for end of table
-tab_cc:
-.word 0x1921fb54*4+1 // no shift before first iteration
-.word 0x0ed63383*4+0
-.word 0x07d6dd7e*4+0
-.word 0x03fab753*4+0
-.word 0x01ff55bb*4+0
-.word 0x00ffeaae*4+0
-.word 0x007ffd55*4+0
-.word 0x003fffab*4+0
-.word 0x001ffff5*4+0
-.word 0x000fffff*4+0
-.word 0x0007ffff*4+0
-.word 0x00040000*4+0
-.word 0x00020000*4+0+2 // +2 marks end
-
-// hyperbolic CORDIC coefficients: atanh(2^-i), flags as above
-tab_ch:
-.word 0x1193ea7b*4+0
-.word 0x1193ea7b*4+1 // repeat i=1
-.word 0x082c577d*4+0
-.word 0x04056247*4+0
-.word 0x0200ab11*4+0
-.word 0x0200ab11*4+1 // repeat i=4
-.word 0x01001559*4+0
-.word 0x008002ab*4+0
-.word 0x00400055*4+0
-.word 0x0020000b*4+0
-.word 0x00100001*4+0
-.word 0x00080001*4+0
-.word 0x00040000*4+0
-.word 0x00020000*4+0
-.word 0x00020000*4+1+2 // repeat i=12
-
-.endif
-
-qfp_lib_end:
diff --git a/keymaps/onekey/stm32f411/rules.mk b/keymaps/onekey/stm32f411/rules.mk
deleted file mode 100644
index 8b12a3d..0000000
--- a/keymaps/onekey/stm32f411/rules.mk
+++ /dev/null
@@ -1,3 +0,0 @@
-CONSOLE_ENABLE = yes
-
-SRC += $(KEYMAP_PATH)/qfplib/*.s