cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

polynomial.c (3687B)

      1// SPDX-License-Identifier: GPL-2.0-only
      2/*
      3 * Generic polynomial calculation using integer coefficients.
      4 *
      5 * Copyright (C) 2020 BAIKAL ELECTRONICS, JSC
      6 *
      7 * Authors:
      8 *   Maxim Kaurkin <maxim.kaurkin@baikalelectronics.ru>
      9 *   Serge Semin <Sergey.Semin@baikalelectronics.ru>
     10 *
     11 */
     12
     13#include <linux/kernel.h>
     14#include <linux/module.h>
     15#include <linux/polynomial.h>
     16
     17/*
     18 * Originally this was part of drivers/hwmon/bt1-pvt.c.
     19 * There the following conversion is used and should serve as an example here:
     20 *
     21 * The original translation formulae of the temperature (in degrees of Celsius)
     22 * to PVT data and vice-versa are following:
     23 *
     24 * N = 1.8322e-8*(T^4) + 2.343e-5*(T^3) + 8.7018e-3*(T^2) + 3.9269*(T^1) +
     25 *     1.7204e2
     26 * T = -1.6743e-11*(N^4) + 8.1542e-8*(N^3) + -1.8201e-4*(N^2) +
     27 *     3.1020e-1*(N^1) - 4.838e1
     28 *
     29 * where T = [-48.380, 147.438]C and N = [0, 1023].
     30 *
     31 * They must be accordingly altered to be suitable for the integer arithmetics.
     32 * The technique is called 'factor redistribution', which just makes sure the
     33 * multiplications and divisions are made so to have a result of the operations
     34 * within the integer numbers limit. In addition we need to translate the
     35 * formulae to accept millidegrees of Celsius. Here what they look like after
     36 * the alterations:
     37 *
     38 * N = (18322e-20*(T^4) + 2343e-13*(T^3) + 87018e-9*(T^2) + 39269e-3*T +
     39 *     17204e2) / 1e4
     40 * T = -16743e-12*(D^4) + 81542e-9*(D^3) - 182010e-6*(D^2) + 310200e-3*D -
     41 *     48380
     42 * where T = [-48380, 147438] mC and N = [0, 1023].
     43 *
     44 * static const struct polynomial poly_temp_to_N = {
     45 *         .total_divider = 10000,
     46 *         .terms = {
     47 *                 {4, 18322, 10000, 10000},
     48 *                 {3, 2343, 10000, 10},
     49 *                 {2, 87018, 10000, 10},
     50 *                 {1, 39269, 1000, 1},
     51 *                 {0, 1720400, 1, 1}
     52 *         }
     53 * };
     54 *
     55 * static const struct polynomial poly_N_to_temp = {
     56 *         .total_divider = 1,
     57 *         .terms = {
     58 *                 {4, -16743, 1000, 1},
     59 *                 {3, 81542, 1000, 1},
     60 *                 {2, -182010, 1000, 1},
     61 *                 {1, 310200, 1000, 1},
     62 *                 {0, -48380, 1, 1}
     63 *         }
     64 * };
     65 */
     66
     67/**
     68 * polynomial_calc - calculate a polynomial using integer arithmetic
     69 *
     70 * @poly: pointer to the descriptor of the polynomial
     71 * @data: input value of the polynimal
     72 *
     73 * Calculate the result of a polynomial using only integer arithmetic. For
     74 * this to work without too much loss of precision the coefficients has to
     75 * be altered. This is called factor redistribution.
     76 *
     77 * Returns the result of the polynomial calculation.
     78 */
     79long polynomial_calc(const struct polynomial *poly, long data)
     80{
     81	const struct polynomial_term *term = poly->terms;
     82	long total_divider = poly->total_divider ?: 1;
     83	long tmp, ret = 0;
     84	int deg;
     85
     86	/*
     87	 * Here is the polynomial calculation function, which performs the
     88	 * redistributed terms calculations. It's pretty straightforward.
     89	 * We walk over each degree term up to the free one, and perform
     90	 * the redistributed multiplication of the term coefficient, its
     91	 * divider (as for the rationale fraction representation), data
     92	 * power and the rational fraction divider leftover. Then all of
     93	 * this is collected in a total sum variable, which value is
     94	 * normalized by the total divider before being returned.
     95	 */
     96	do {
     97		tmp = term->coef;
     98		for (deg = 0; deg < term->deg; ++deg)
     99			tmp = mult_frac(tmp, data, term->divider);
    100		ret += tmp / term->divider_leftover;
    101	} while ((term++)->deg);
    102
    103	return ret / total_divider;
    104}
    105EXPORT_SYMBOL_GPL(polynomial_calc);
    106
    107MODULE_DESCRIPTION("Generic polynomial calculations");
    108MODULE_LICENSE("GPL");