drivers/gpu/drm/amd/display/dc/calcs/custom_float.c

   1 /*
   2  * Copyright 2017 Advanced Micro Devices, Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20  * OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  * Authors: AMD
  23  *
  24  */
  25 #include "dm_services.h"
  26 #include "custom_float.h"
  27
  28
  29 static bool build_custom_float(
  30         struct fixed31_32 value,
  31         const struct custom_float_format *format,
  32         bool *negative,
  33         uint32_t *mantissa,
  34         uint32_t *exponenta)
  35 {
  36         uint32_t exp_offset = (1 << (format->exponenta_bits - 1)) - 1;
  37
  38         const struct fixed31_32 mantissa_constant_plus_max_fraction =
  39                 dal_fixed31_32_from_fraction(
  40                         (1LL << (format->mantissa_bits + 1)) - 1,
  41                         1LL << format->mantissa_bits);
  42
  43         struct fixed31_32 mantiss;
  44
  45         if (dal_fixed31_32_eq(
  46                 value,
  47                 dal_fixed31_32_zero)) {
  48                 *negative = false;
  49                 *mantissa = 0;
  50                 *exponenta = 0;
  51                 return true;
  52         }
  53
  54         if (dal_fixed31_32_lt(
  55                 value,
  56                 dal_fixed31_32_zero)) {
  57                 *negative = format->sign;
  58                 value = dal_fixed31_32_neg(value);
  59         } else {
  60                 *negative = false;
  61         }
  62
  63         if (dal_fixed31_32_lt(
  64                 value,
  65                 dal_fixed31_32_one)) {
  66                 uint32_t i = 1;
  67
  68                 do {
  69                         value = dal_fixed31_32_shl(value, 1);
  70                         ++i;
  71                 } while (dal_fixed31_32_lt(
  72                         value,
  73                         dal_fixed31_32_one));
  74
  75                 --i;
  76
  77                 if (exp_offset <= i) {
  78                         *mantissa = 0;
  79                         *exponenta = 0;
  80                         return true;
  81                 }
  82
  83                 *exponenta = exp_offset - i;
  84         } else if (dal_fixed31_32_le(
  85                 mantissa_constant_plus_max_fraction,
  86                 value)) {
  87                 uint32_t i = 1;
  88
  89                 do {
  90                         value = dal_fixed31_32_shr(value, 1);
  91                         ++i;
  92                 } while (dal_fixed31_32_lt(
  93                         mantissa_constant_plus_max_fraction,
  94                         value));
  95
  96                 *exponenta = exp_offset + i - 1;
  97         } else {
  98                 *exponenta = exp_offset;
  99         }
 100
 101         mantiss = dal_fixed31_32_sub(
 102                 value,
 103                 dal_fixed31_32_one);
 104
 105         if (dal_fixed31_32_lt(
 106                         mantiss,
 107                         dal_fixed31_32_zero) ||
 108                 dal_fixed31_32_lt(
 109                         dal_fixed31_32_one,
 110                         mantiss))
 111                 mantiss = dal_fixed31_32_zero;
 112         else
 113                 mantiss = dal_fixed31_32_shl(
 114                         mantiss,
 115                         format->mantissa_bits);
 116
 117         *mantissa = dal_fixed31_32_floor(mantiss);
 118
 119         return true;
 120 }
 121
 122 static bool setup_custom_float(
 123         const struct custom_float_format *format,
 124         bool negative,
 125         uint32_t mantissa,
 126         uint32_t exponenta,
 127         uint32_t *result)
 128 {
 129         uint32_t i = 0;
 130         uint32_t j = 0;
 131
 132         uint32_t value = 0;
 133
 134         /* verification code:
 135          * once calculation is ok we can remove it
 136          */
 137
 138         const uint32_t mantissa_mask =
 139                 (1 << (format->mantissa_bits + 1)) - 1;
 140
 141         const uint32_t exponenta_mask =
 142                 (1 << (format->exponenta_bits + 1)) - 1;
 143
 144         if (mantissa & ~mantissa_mask) {
 145                 BREAK_TO_DEBUGGER();
 146                 mantissa = mantissa_mask;
 147         }
 148
 149         if (exponenta & ~exponenta_mask) {
 150                 BREAK_TO_DEBUGGER();
 151                 exponenta = exponenta_mask;
 152         }
 153
 154         /* end of verification code */
 155
 156         while (i < format->mantissa_bits) {
 157                 uint32_t mask = 1 << i;
 158
 159                 if (mantissa & mask)
 160                         value |= mask;
 161
 162                 ++i;
 163         }
 164
 165         while (j < format->exponenta_bits) {
 166                 uint32_t mask = 1 << j;
 167
 168                 if (exponenta & mask)
 169                         value |= mask << i;
 170
 171                 ++j;
 172         }
 173
 174         if (negative && format->sign)
 175                 value |= 1 << (i + j);
 176
 177         *result = value;
 178
 179         return true;
 180 }
 181
 182 bool convert_to_custom_float_format(
 183         struct fixed31_32 value,
 184         const struct custom_float_format *format,
 185         uint32_t *result)
 186 {
 187         uint32_t mantissa;
 188         uint32_t exponenta;
 189         bool negative;
 190
 191         return build_custom_float(
 192                 value, format, &negative, &mantissa, &exponenta) &&
 193         setup_custom_float(
 194                 format, negative, mantissa, exponenta, result);
 195 }
 196
 197