Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: GPL-2.0-or-later */
       2                 :            : #ifndef _FIXP_ARITH_H
       3                 :            : #define _FIXP_ARITH_H
       4                 :            : 
       5                 :            : #include <linux/math64.h>
       6                 :            : 
       7                 :            : /*
       8                 :            :  * Simplistic fixed-point arithmetics.
       9                 :            :  * Hmm, I'm probably duplicating some code :(
      10                 :            :  *
      11                 :            :  * Copyright (c) 2002 Johann Deneux
      12                 :            :  */
      13                 :            : 
      14                 :            : /*
      15                 :            :  *
      16                 :            :  * Should you need to contact me, the author, you can do so by
      17                 :            :  * e-mail - mail your message to <johann.deneux@gmail.com>
      18                 :            :  */
      19                 :            : 
      20                 :            : #include <linux/types.h>
      21                 :            : 
      22                 :            : static const s32 sin_table[] = {
      23                 :            :         0x00000000, 0x023be165, 0x04779632, 0x06b2f1d2, 0x08edc7b6, 0x0b27eb5c,
      24                 :            :         0x0d61304d, 0x0f996a26, 0x11d06c96, 0x14060b67, 0x163a1a7d, 0x186c6ddd,
      25                 :            :         0x1a9cd9ac, 0x1ccb3236, 0x1ef74bf2, 0x2120fb82, 0x234815ba, 0x256c6f9e,
      26                 :            :         0x278dde6e, 0x29ac379f, 0x2bc750e8, 0x2ddf003f, 0x2ff31bdd, 0x32037a44,
      27                 :            :         0x340ff241, 0x36185aee, 0x381c8bb5, 0x3a1c5c56, 0x3c17a4e7, 0x3e0e3ddb,
      28                 :            :         0x3fffffff, 0x41ecc483, 0x43d464fa, 0x45b6bb5d, 0x4793a20f, 0x496af3e1,
      29                 :            :         0x4b3c8c11, 0x4d084650, 0x4ecdfec6, 0x508d9210, 0x5246dd48, 0x53f9be04,
      30                 :            :         0x55a6125a, 0x574bb8e5, 0x58ea90c2, 0x5a827999, 0x5c135399, 0x5d9cff82,
      31                 :            :         0x5f1f5ea0, 0x609a52d1, 0x620dbe8a, 0x637984d3, 0x64dd894f, 0x6639b039,
      32                 :            :         0x678dde6d, 0x68d9f963, 0x6a1de735, 0x6b598ea1, 0x6c8cd70a, 0x6db7a879,
      33                 :            :         0x6ed9eba0, 0x6ff389de, 0x71046d3c, 0x720c8074, 0x730baeec, 0x7401e4bf,
      34                 :            :         0x74ef0ebb, 0x75d31a5f, 0x76adf5e5, 0x777f903b, 0x7847d908, 0x7906c0af,
      35                 :            :         0x79bc384c, 0x7a6831b8, 0x7b0a9f8c, 0x7ba3751c, 0x7c32a67c, 0x7cb82884,
      36                 :            :         0x7d33f0c8, 0x7da5f5a3, 0x7e0e2e31, 0x7e6c924f, 0x7ec11aa3, 0x7f0bc095,
      37                 :            :         0x7f4c7e52, 0x7f834ecf, 0x7fb02dc4, 0x7fd317b3, 0x7fec09e1, 0x7ffb025e,
      38                 :            :         0x7fffffff
      39                 :            : };
      40                 :            : 
      41                 :            : /**
      42                 :            :  * __fixp_sin32() returns the sin of an angle in degrees
      43                 :            :  *
      44                 :            :  * @degrees: angle, in degrees, from 0 to 360.
      45                 :            :  *
      46                 :            :  * The returned value ranges from -0x7fffffff to +0x7fffffff.
      47                 :            :  */
      48                 :          0 : static inline s32 __fixp_sin32(int degrees)
      49                 :            : {
      50                 :          0 :         s32 ret;
      51                 :          0 :         bool negative = false;
      52                 :            : 
      53                 :          0 :         if (degrees > 180) {
      54                 :          0 :                 negative = true;
      55                 :          0 :                 degrees -= 180;
      56                 :            :         }
      57   [ #  #  #  # ]:          0 :         if (degrees > 90)
      58                 :          0 :                 degrees = 180 - degrees;
      59                 :            : 
      60                 :          0 :         ret = sin_table[degrees];
      61                 :            : 
      62   [ #  #  #  # ]:          0 :         return negative ? -ret : ret;
      63                 :            : }
      64                 :            : 
      65                 :            : /**
      66                 :            :  * fixp_sin32() returns the sin of an angle in degrees
      67                 :            :  *
      68                 :            :  * @degrees: angle, in degrees. The angle can be positive or negative
      69                 :            :  *
      70                 :            :  * The returned value ranges from -0x7fffffff to +0x7fffffff.
      71                 :            :  */
      72                 :          0 : static inline s32 fixp_sin32(int degrees)
      73                 :            : {
      74                 :          0 :         degrees = (degrees % 360 + 360) % 360;
      75                 :            : 
      76   [ #  #  #  # ]:          0 :         return __fixp_sin32(degrees);
      77                 :            : }
      78                 :            : 
      79                 :            : /* cos(x) = sin(x + 90 degrees) */
      80                 :            : #define fixp_cos32(v) fixp_sin32((v) + 90)
      81                 :            : 
      82                 :            : /*
      83                 :            :  * 16 bits variants
      84                 :            :  *
      85                 :            :  * The returned value ranges from -0x7fff to 0x7fff
      86                 :            :  */
      87                 :            : 
      88                 :            : #define fixp_sin16(v) (fixp_sin32(v) >> 16)
      89                 :            : #define fixp_cos16(v) (fixp_cos32(v) >> 16)
      90                 :            : 
      91                 :            : /**
      92                 :            :  * fixp_sin32_rad() - calculates the sin of an angle in radians
      93                 :            :  *
      94                 :            :  * @radians: angle, in radians
      95                 :            :  * @twopi: value to be used for 2*pi
      96                 :            :  *
      97                 :            :  * Provides a variant for the cases where just 360
      98                 :            :  * values is not enough. This function uses linear
      99                 :            :  * interpolation to a wider range of values given by
     100                 :            :  * twopi var.
     101                 :            :  *
     102                 :            :  * Experimental tests gave a maximum difference of
     103                 :            :  * 0.000038 between the value calculated by sin() and
     104                 :            :  * the one produced by this function, when twopi is
     105                 :            :  * equal to 360000. That seems to be enough precision
     106                 :            :  * for practical purposes.
     107                 :            :  *
     108                 :            :  * Please notice that two high numbers for twopi could cause
     109                 :            :  * overflows, so the routine will not allow values of twopi
     110                 :            :  * bigger than 1^18.
     111                 :            :  */
     112                 :            : static inline s32 fixp_sin32_rad(u32 radians, u32 twopi)
     113                 :            : {
     114                 :            :         int degrees;
     115                 :            :         s32 v1, v2, dx, dy;
     116                 :            :         s64 tmp;
     117                 :            : 
     118                 :            :         /*
     119                 :            :          * Avoid too large values for twopi, as we don't want overflows.
     120                 :            :          */
     121                 :            :         BUG_ON(twopi > 1 << 18);
     122                 :            : 
     123                 :            :         degrees = (radians * 360) / twopi;
     124                 :            :         tmp = radians - (degrees * twopi) / 360;
     125                 :            : 
     126                 :            :         degrees = (degrees % 360 + 360) % 360;
     127                 :            :         v1 = __fixp_sin32(degrees);
     128                 :            : 
     129                 :            :         v2 = fixp_sin32(degrees + 1);
     130                 :            : 
     131                 :            :         dx = twopi / 360;
     132                 :            :         dy = v2 - v1;
     133                 :            : 
     134                 :            :         tmp *= dy;
     135                 :            : 
     136                 :            :         return v1 +  div_s64(tmp, dx);
     137                 :            : }
     138                 :            : 
     139                 :            : /* cos(x) = sin(x + pi/2 radians) */
     140                 :            : 
     141                 :            : #define fixp_cos32_rad(rad, twopi)      \
     142                 :            :         fixp_sin32_rad(rad + twopi / 4, twopi)
     143                 :            : 
     144                 :            : #endif