src/panfrost/pandecode/pan_pretty_print.c

   1 /*
   2  * © Copyright 2017-2098 The Panfrost Communiy
   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 (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21  * SOFTWARE.
  22  */
  23
  24 #include "pan_pretty_print.h"
  25
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <assert.h>
  29
  30 /* Some self-contained prettyprinting functions shared between pandecode and
  31  * the main driver */
  32
  33 #define DEFINE_CASE(name) case MALI_## name: return "MALI_" #name
  34 char *pandecode_format(enum mali_format format)
  35 {
  36         static char unk_format_str[10];
  37
  38         switch (format) {
  39                 DEFINE_CASE(ETC2_RGB8);
  40                 DEFINE_CASE(ETC2_R11_UNORM);
  41                 DEFINE_CASE(ETC2_RGBA8);
  42                 DEFINE_CASE(ETC2_RG11_UNORM);
  43                 DEFINE_CASE(ETC2_R11_SNORM);
  44                 DEFINE_CASE(ETC2_RG11_SNORM);
  45                 DEFINE_CASE(ETC2_RGB8A1);
  46                 DEFINE_CASE(NXR);
  47                 DEFINE_CASE(BC1_UNORM);
  48                 DEFINE_CASE(BC2_UNORM);
  49                 DEFINE_CASE(BC3_UNORM);
  50                 DEFINE_CASE(BC4_UNORM);
  51                 DEFINE_CASE(BC4_SNORM);
  52                 DEFINE_CASE(BC5_UNORM);
  53                 DEFINE_CASE(BC5_SNORM);
  54                 DEFINE_CASE(BC6H_UF16);
  55                 DEFINE_CASE(BC6H_SF16);
  56                 DEFINE_CASE(BC7_UNORM);
  57                 DEFINE_CASE(ASTC_3D_LDR);
  58                 DEFINE_CASE(ASTC_3D_HDR);
  59                 DEFINE_CASE(ASTC_2D_LDR);
  60                 DEFINE_CASE(ASTC_2D_HDR);
  61                 DEFINE_CASE(RGB565);
  62                 DEFINE_CASE(RGB5_X1_UNORM);
  63                 DEFINE_CASE(RGB5_A1_UNORM);
  64                 DEFINE_CASE(RGB10_A2_UNORM);
  65                 DEFINE_CASE(RGB10_A2_SNORM);
  66                 DEFINE_CASE(RGB10_A2UI);
  67                 DEFINE_CASE(RGB10_A2I);
  68                 DEFINE_CASE(RGB332_UNORM);
  69                 DEFINE_CASE(RGB233_UNORM);
  70                 DEFINE_CASE(Z24X8_UNORM);
  71                 DEFINE_CASE(R32_FIXED);
  72                 DEFINE_CASE(RG32_FIXED);
  73                 DEFINE_CASE(RGB32_FIXED);
  74                 DEFINE_CASE(RGBA32_FIXED);
  75                 DEFINE_CASE(R11F_G11F_B10F);
  76                 DEFINE_CASE(R9F_G9F_B9F_E5F);
  77                 DEFINE_CASE(VARYING_POS);
  78                 DEFINE_CASE(VARYING_DISCARD);
  79
  80                 DEFINE_CASE(R8_SNORM);
  81                 DEFINE_CASE(R16_SNORM);
  82                 DEFINE_CASE(R32_SNORM);
  83                 DEFINE_CASE(RG8_SNORM);
  84                 DEFINE_CASE(RG16_SNORM);
  85                 DEFINE_CASE(RG32_SNORM);
  86                 DEFINE_CASE(RGB8_SNORM);
  87                 DEFINE_CASE(RGB16_SNORM);
  88                 DEFINE_CASE(RGB32_SNORM);
  89                 DEFINE_CASE(RGBA8_SNORM);
  90                 DEFINE_CASE(RGBA16_SNORM);
  91                 DEFINE_CASE(RGBA32_SNORM);
  92
  93                 DEFINE_CASE(R8UI);
  94                 DEFINE_CASE(R16UI);
  95                 DEFINE_CASE(R32UI);
  96                 DEFINE_CASE(RG8UI);
  97                 DEFINE_CASE(RG16UI);
  98                 DEFINE_CASE(RG32UI);
  99                 DEFINE_CASE(RGB8UI);
 100                 DEFINE_CASE(RGB16UI);
 101                 DEFINE_CASE(RGB32UI);
 102                 DEFINE_CASE(RGBA8UI);
 103                 DEFINE_CASE(RGBA16UI);
 104                 DEFINE_CASE(RGBA32UI);
 105
 106                 DEFINE_CASE(R8_UNORM);
 107                 DEFINE_CASE(R16_UNORM);
 108                 DEFINE_CASE(R32_UNORM);
 109                 DEFINE_CASE(R32F);
 110                 DEFINE_CASE(RG8_UNORM);
 111                 DEFINE_CASE(RG16_UNORM);
 112                 DEFINE_CASE(RG32_UNORM);
 113                 DEFINE_CASE(RG32F);
 114                 DEFINE_CASE(RGB8_UNORM);
 115                 DEFINE_CASE(RGB16_UNORM);
 116                 DEFINE_CASE(RGB32_UNORM);
 117                 DEFINE_CASE(RGB32F);
 118                 DEFINE_CASE(RGBA4_UNORM);
 119                 DEFINE_CASE(RGBA8_UNORM);
 120                 DEFINE_CASE(RGBA16_UNORM);
 121                 DEFINE_CASE(RGBA32_UNORM);
 122                 DEFINE_CASE(RGBA32F);
 123
 124                 DEFINE_CASE(R8I);
 125                 DEFINE_CASE(R16I);
 126                 DEFINE_CASE(R32I);
 127                 DEFINE_CASE(RG8I);
 128                 DEFINE_CASE(R16F);
 129                 DEFINE_CASE(RG16I);
 130                 DEFINE_CASE(RG32I);
 131                 DEFINE_CASE(RG16F);
 132                 DEFINE_CASE(RGB8I);
 133                 DEFINE_CASE(RGB16I);
 134                 DEFINE_CASE(RGB32I);
 135                 DEFINE_CASE(RGB16F);
 136                 DEFINE_CASE(RGBA8I);
 137                 DEFINE_CASE(RGBA16I);
 138                 DEFINE_CASE(RGBA32I);
 139                 DEFINE_CASE(RGBA16F);
 140
 141                 DEFINE_CASE(RGBA4);
 142                 DEFINE_CASE(RGBA8_2);
 143                 DEFINE_CASE(RGB10_A2_2);
 144         default:
 145                 snprintf(unk_format_str, sizeof(unk_format_str), "MALI_0x%02x", format);
 146                 return unk_format_str;
 147         }
 148 }
 149
 150 #undef DEFINE_CASE
 151
 152 /* Helper to dump fixed-function blend part for debugging */
 153
 154 static const char *
 155 panfrost_factor_name(enum mali_dominant_factor factor)
 156 {
 157         switch (factor) {
 158         case MALI_DOMINANT_UNK0:
 159                 return "unk0";
 160
 161         case MALI_DOMINANT_ZERO:
 162                 return "zero";
 163
 164         case MALI_DOMINANT_SRC_COLOR:
 165                 return "source color";
 166
 167         case MALI_DOMINANT_DST_COLOR:
 168                 return "dest color";
 169
 170         case MALI_DOMINANT_UNK4:
 171                 return "unk4";
 172
 173         case MALI_DOMINANT_SRC_ALPHA:
 174                 return "source alpha";
 175
 176         case MALI_DOMINANT_DST_ALPHA:
 177                 return "dest alpha";
 178
 179         case MALI_DOMINANT_CONSTANT:
 180                 return "constant";
 181         }
 182
 183         return "unreachable";
 184 }
 185
 186 static const char *
 187 panfrost_modifier_name(enum mali_blend_modifier mod)
 188 {
 189         switch (mod) {
 190         case MALI_BLEND_MOD_UNK0:
 191                 return "unk0";
 192
 193         case MALI_BLEND_MOD_NORMAL:
 194                 return "normal";
 195
 196         case MALI_BLEND_MOD_SOURCE_ONE:
 197                 return "source one";
 198
 199         case MALI_BLEND_MOD_DEST_ONE:
 200                 return "dest one";
 201         }
 202
 203         return "unreachable";
 204 }
 205
 206 static void
 207 panfrost_print_fixed_part(const char *name, unsigned u)
 208 {
 209         struct mali_blend_mode part;
 210         memcpy(&part, &u, sizeof(part));
 211
 212         printf("%s blend mode (%X):\n", name, u);
 213
 214         printf(" %s dominant:\n",
 215                (part.dominant == MALI_BLEND_DOM_SOURCE) ? "source" : "destination");
 216
 217         printf("   %s\n", panfrost_factor_name(part.dominant_factor));
 218
 219         if (part.complement_dominant)
 220                 printf("   complement\n");
 221
 222
 223         printf(" nondominant %s\n",
 224                (part.nondominant_mode == MALI_BLEND_NON_MIRROR) ? "mirror" : "zero");
 225
 226
 227         printf(" mode: %s\n", panfrost_modifier_name(part.clip_modifier));
 228
 229         if (part.negate_source) printf(" negate source\n");
 230
 231         if (part.negate_dest) printf(" negate dest\n");
 232
 233         assert(!(part.unused_0 || part.unused_1));
 234 }
 235
 236 void
 237 panfrost_print_blend_equation(struct mali_blend_equation eq)
 238 {
 239         printf("\n");
 240         panfrost_print_fixed_part("RGB", eq.rgb_mode);
 241         panfrost_print_fixed_part("Alpha", eq.alpha_mode);
 242
 243         assert(!eq.zero1);
 244
 245         printf("Mask: %s%s%s%s\n",
 246                (eq.color_mask & MALI_MASK_R) ? "R" : "",
 247                (eq.color_mask & MALI_MASK_G) ? "G" : "",
 248                (eq.color_mask & MALI_MASK_B) ? "B" : "",
 249                (eq.color_mask & MALI_MASK_A) ? "A" : "");
 250 }