src/freedreno/decode/rnnutil.c

   1 /* -*- mode: C; c-file-style: "k&r"; tab-width 4; indent-tabs-mode: t; -*- */
   2
   3 /*
   4  * Copyright (C) 2014 Rob Clark <robclark@freedesktop.org>
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the next
  14  * paragraph) shall be included in all copies or substantial portions of the
  15  * Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23  * SOFTWARE.
  24  *
  25  * Authors:
  26  *    Rob Clark <robclark@freedesktop.org>
  27  */
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <stdint.h>
  32 #include <string.h>
  33 #include <assert.h>
  34
  35 #include "rnnutil.h"
  36
  37 static struct rnndomain *finddom(struct rnn *rnn, uint32_t regbase)
  38 {
  39         if (rnndec_checkaddr(rnn->vc, rnn->dom[0], regbase, 0))
  40                 return rnn->dom[0];
  41         return rnn->dom[1];
  42 }
  43
  44 void _rnn_init(struct rnn *rnn, int nocolor)
  45 {
  46         rnn_init();
  47
  48         rnn->db = rnn_newdb();
  49         rnn->vc_nocolor = rnndec_newcontext(rnn->db);
  50         rnn->vc_nocolor->colors = &envy_null_colors;
  51         if (nocolor) {
  52                 rnn->vc = rnn->vc_nocolor;
  53         } else {
  54                 rnn->vc = rnndec_newcontext(rnn->db);
  55                 rnn->vc->colors = &envy_def_colors;
  56         }
  57 }
  58
  59 struct rnn *rnn_new(int nocolor)
  60 {
  61         struct rnn *rnn = calloc(sizeof(*rnn), 1);
  62
  63         if (!rnn)
  64                 return NULL;
  65
  66         _rnn_init(rnn, nocolor);
  67
  68         return rnn;
  69 }
  70
  71 static void init(struct rnn *rnn, char *file, char *domain)
  72 {
  73         /* prepare rnn stuff for lookup */
  74         rnn_parsefile(rnn->db, file);
  75         rnn_prepdb(rnn->db);
  76         rnn->dom[0] = rnn_finddomain(rnn->db, domain);
  77         if ((strcmp(domain, "A2XX") == 0) || (strcmp(domain, "A3XX") == 0)) {
  78                 rnn->dom[1] = rnn_finddomain(rnn->db, "AXXX");
  79         } else {
  80                 rnn->dom[1] = rnn->dom[0];
  81         }
  82         if (!rnn->dom[0] && rnn->dom[1]) {
  83                 fprintf(stderr, "Could not find domain %s in %s\n", domain, file);
  84         }
  85         rnn->variant = domain;
  86
  87         rnndec_varadd(rnn->vc, "chip", domain);
  88         if (rnn->vc != rnn->vc_nocolor)
  89                 rnndec_varadd(rnn->vc_nocolor, "chip", domain);
  90 }
  91
  92 void rnn_load_file(struct rnn *rnn, char *file, char *domain)
  93 {
  94         init(rnn, file, domain);
  95 }
  96
  97 void rnn_load(struct rnn *rnn, const char *gpuname)
  98 {
  99         if (strstr(gpuname, "a2")) {
 100                 init(rnn, "adreno/a2xx.xml", "A2XX");
 101         } else if (strstr(gpuname, "a3")) {
 102                 init(rnn, "adreno/a3xx.xml", "A3XX");
 103         } else if (strstr(gpuname, "a4")) {
 104                 init(rnn, "adreno/a4xx.xml", "A4XX");
 105         } else if (strstr(gpuname, "a5")) {
 106                 init(rnn, "adreno/a5xx.xml", "A5XX");
 107         } else if (strstr(gpuname, "a6")) {
 108                 init(rnn, "adreno/a6xx.xml", "A6XX");
 109         }
 110 }
 111
 112 uint32_t rnn_regbase(struct rnn *rnn, const char *name)
 113 {
 114         uint32_t regbase = rnndec_decodereg(rnn->vc_nocolor, rnn->dom[0], name);
 115         if (!regbase)
 116                 regbase = rnndec_decodereg(rnn->vc_nocolor, rnn->dom[1], name);
 117         return regbase;
 118 }
 119
 120 const char *rnn_regname(struct rnn *rnn, uint32_t regbase, int color)
 121 {
 122         static char buf[128];
 123         struct rnndecaddrinfo *info;
 124
 125         info = rnndec_decodeaddr(color ? rnn->vc : rnn->vc_nocolor,
 126                         finddom(rnn, regbase), regbase, 0);
 127         if (info) {
 128                 strcpy(buf, info->name);
 129                 free(info->name);
 130                 free(info);
 131                 return buf;
 132         }
 133         return NULL;
 134 }
 135
 136 struct rnndecaddrinfo *rnn_reginfo(struct rnn *rnn, uint32_t regbase)
 137 {
 138         return rnndec_decodeaddr(rnn->vc, finddom(rnn, regbase), regbase, 0);
 139 }
 140
 141 const char *rnn_enumname(struct rnn *rnn, const char *name, uint32_t val)
 142 {
 143         struct rnndeccontext *ctx = rnn->vc;
 144         struct rnnenum *en = rnn_findenum(ctx->db, name);
 145         if (en) {
 146                 int i;
 147                 for (i = 0; i < en->valsnum; i++) {
 148                         struct rnnvalue *eval = en->vals[i];
 149                         if (eval->valvalid && eval->value == val &&
 150                                         rnndec_varmatch(ctx, &eval->varinfo)) {
 151                                 return en->vals[i]->name;
 152                         }
 153                 }
 154         }
 155         return NULL;
 156 }
 157
 158 static struct rnndelem *regelem(struct rnndomain *domain, const char *name)
 159 {
 160         int i;
 161         for (i = 0; i < domain->subelemsnum; i++) {
 162                 struct rnndelem *elem = domain->subelems[i];
 163                 if (!strcmp(elem->name, name))
 164                         return elem;
 165         }
 166         return NULL;
 167 }
 168
 169 /* Lookup rnndelem by name: */
 170 struct rnndelem *rnn_regelem(struct rnn *rnn, const char *name)
 171 {
 172         struct rnndelem *elem = regelem(rnn->dom[0], name);
 173         if (elem)
 174                 return elem;
 175         return regelem(rnn->dom[1], name);
 176 }
 177
 178 static struct rnndelem *regoff(struct rnndomain *domain, uint32_t offset)
 179 {
 180         int i;
 181         for (i = 0; i < domain->subelemsnum; i++) {
 182                 struct rnndelem *elem = domain->subelems[i];
 183                 if (elem->offset == offset)
 184                         return elem;
 185         }
 186         return NULL;
 187 }
 188
 189 /* Lookup rnndelem by offset: */
 190 struct rnndelem *rnn_regoff(struct rnn *rnn, uint32_t offset)
 191 {
 192         struct rnndelem *elem = regoff(rnn->dom[0], offset);
 193         if (elem)
 194                 return elem;
 195         return regoff(rnn->dom[1], offset);
 196 }
 197
 198 enum rnnttype rnn_decodelem(struct rnn *rnn, struct rnntypeinfo *info,
 199                 uint32_t regval, union rnndecval *val)
 200 {
 201         val->u = regval;
 202         switch (info->type) {
 203         case RNN_TTYPE_INLINE_ENUM:
 204         case RNN_TTYPE_ENUM:
 205         case RNN_TTYPE_HEX:
 206         case RNN_TTYPE_INT:
 207         case RNN_TTYPE_UINT:
 208         case RNN_TTYPE_FLOAT:
 209         case RNN_TTYPE_BOOLEAN:
 210                 return info->type;
 211         case RNN_TTYPE_FIXED:
 212         case RNN_TTYPE_UFIXED:
 213                 /* TODO */
 214         default:
 215                 return RNN_TTYPE_INVALID;
 216         }
 217 }