2
* Copyright © 2016 Intel Corporation
3
* Copyright © 2017 Broadcom
5
* Permission is hereby granted, free of charge, to any person obtaining a
6
* copy of this software and associated documentation files (the "Software"),
7
* to deal in the Software without restriction, including without limitation
8
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
9
* and/or sell copies of the Software, and to permit persons to whom the
10
* Software is furnished to do so, subject to the following conditions:
12
* The above copyright notice and this permission notice (including the next
13
* paragraph) shall be included in all copies or substantial portions of the
16
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
25
#include "v3d_decoder.h"
39
#include <util/macros.h>
40
#include <util/ralloc.h>
41
#include <util/u_debug.h>
43
#include "v3d_packet_helpers.h"
45
#include "broadcom/clif/clif_private.h"
51
struct v3d_group *commands[256];
53
struct v3d_group *structs[256];
55
struct v3d_group *registers[256];
57
struct v3d_enum *enums[256];
67
struct parser_context {
69
const struct v3d_device_info *devinfo;
73
struct v3d_group *group;
74
struct v3d_enum *enoom;
77
struct v3d_value *values[256];
79
struct v3d_spec *spec;
85
#endif /* WITH_LIBEXPAT */
88
v3d_group_get_name(struct v3d_group *group)
94
v3d_group_get_opcode(struct v3d_group *group)
100
v3d_spec_find_struct(struct v3d_spec *spec, const char *name)
102
for (int i = 0; i < spec->nstructs; i++)
103
if (strcmp(spec->structs[i]->name, name) == 0)
104
return spec->structs[i];
110
v3d_spec_find_register(struct v3d_spec *spec, uint32_t offset)
112
for (int i = 0; i < spec->nregisters; i++)
113
if (spec->registers[i]->register_offset == offset)
114
return spec->registers[i];
120
v3d_spec_find_register_by_name(struct v3d_spec *spec, const char *name)
122
for (int i = 0; i < spec->nregisters; i++) {
123
if (strcmp(spec->registers[i]->name, name) == 0)
124
return spec->registers[i];
131
v3d_spec_find_enum(struct v3d_spec *spec, const char *name)
133
for (int i = 0; i < spec->nenums; i++)
134
if (strcmp(spec->enums[i]->name, name) == 0)
135
return spec->enums[i];
142
static void __attribute__((noreturn))
143
fail(struct location *loc, const char *msg, ...)
148
fprintf(stderr, "%s:%d: error: ",
149
loc->filename, loc->line_number);
150
vfprintf(stderr, msg, ap);
151
fprintf(stderr, "\n");
157
fail_on_null(void *p)
160
fprintf(stderr, "aubinator: out of memory\n");
168
xstrdup(const char *s)
170
return fail_on_null(strdup(s));
182
return fail_on_null(zalloc(s));
185
/* We allow fields to have either a bit index, or append "b" for a byte index.
188
is_byte_offset(const char *value)
190
return value[strlen(value) - 1] == 'b';
194
get_group_offset_count(const char **atts, uint32_t *offset, uint32_t *count,
195
uint32_t *size, bool *variable)
200
for (i = 0; atts[i]; i += 2) {
201
if (strcmp(atts[i], "count") == 0) {
202
*count = strtoul(atts[i + 1], &p, 0);
205
} else if (strcmp(atts[i], "start") == 0) {
206
*offset = strtoul(atts[i + 1], &p, 0);
207
} else if (strcmp(atts[i], "size") == 0) {
208
*size = strtoul(atts[i + 1], &p, 0);
214
static struct v3d_group *
215
create_group(struct parser_context *ctx,
218
struct v3d_group *parent)
220
struct v3d_group *group;
222
group = xzalloc(sizeof(*group));
224
group->name = xstrdup(name);
226
group->spec = ctx->spec;
227
group->group_offset = 0;
228
group->group_count = 0;
229
group->variable = false;
232
group->parent = parent;
233
get_group_offset_count(atts,
234
&group->group_offset,
243
static struct v3d_enum *
244
create_enum(struct parser_context *ctx, const char *name, const char **atts)
248
e = xzalloc(sizeof(*e));
250
e->name = xstrdup(name);
258
get_register_offset(const char **atts, uint32_t *offset)
263
for (i = 0; atts[i]; i += 2) {
264
if (strcmp(atts[i], "num") == 0)
265
*offset = strtoul(atts[i + 1], &p, 0);
270
static struct v3d_type
271
string_to_type(struct parser_context *ctx, const char *s)
277
if (strcmp(s, "int") == 0)
278
return (struct v3d_type) { .kind = V3D_TYPE_INT };
279
else if (strcmp(s, "uint") == 0)
280
return (struct v3d_type) { .kind = V3D_TYPE_UINT };
281
else if (strcmp(s, "bool") == 0)
282
return (struct v3d_type) { .kind = V3D_TYPE_BOOL };
283
else if (strcmp(s, "float") == 0)
284
return (struct v3d_type) { .kind = V3D_TYPE_FLOAT };
285
else if (strcmp(s, "f187") == 0)
286
return (struct v3d_type) { .kind = V3D_TYPE_F187 };
287
else if (strcmp(s, "address") == 0)
288
return (struct v3d_type) { .kind = V3D_TYPE_ADDRESS };
289
else if (strcmp(s, "offset") == 0)
290
return (struct v3d_type) { .kind = V3D_TYPE_OFFSET };
291
else if (sscanf(s, "u%d.%d", &i, &f) == 2)
292
return (struct v3d_type) { .kind = V3D_TYPE_UFIXED, .i = i, .f = f };
293
else if (sscanf(s, "s%d.%d", &i, &f) == 2)
294
return (struct v3d_type) { .kind = V3D_TYPE_SFIXED, .i = i, .f = f };
295
else if (g = v3d_spec_find_struct(ctx->spec, s), g != NULL)
296
return (struct v3d_type) { .kind = V3D_TYPE_STRUCT, .v3d_struct = g };
297
else if (e = v3d_spec_find_enum(ctx->spec, s), e != NULL)
298
return (struct v3d_type) { .kind = V3D_TYPE_ENUM, .v3d_enum = e };
299
else if (strcmp(s, "mbo") == 0)
300
return (struct v3d_type) { .kind = V3D_TYPE_MBO };
302
fail(&ctx->loc, "invalid type: %s", s);
305
static struct v3d_field *
306
create_field(struct parser_context *ctx, const char **atts)
308
struct v3d_field *field;
313
field = xzalloc(sizeof(*field));
315
for (i = 0; atts[i]; i += 2) {
316
if (strcmp(atts[i], "name") == 0)
317
field->name = xstrdup(atts[i + 1]);
318
else if (strcmp(atts[i], "start") == 0) {
319
field->start = strtoul(atts[i + 1], &p, 0);
320
if (is_byte_offset(atts[i + 1]))
322
} else if (strcmp(atts[i], "end") == 0) {
323
field->end = strtoul(atts[i + 1], &p, 0) - 1;
324
if (is_byte_offset(atts[i + 1]))
326
} else if (strcmp(atts[i], "size") == 0) {
327
size = strtoul(atts[i + 1], &p, 0);
328
if (is_byte_offset(atts[i + 1]))
330
} else if (strcmp(atts[i], "type") == 0)
331
field->type = string_to_type(ctx, atts[i + 1]);
332
else if (strcmp(atts[i], "default") == 0) {
333
field->has_default = true;
334
field->default_value = strtoul(atts[i + 1], &p, 0);
335
} else if (strcmp(atts[i], "minus_one") == 0) {
336
assert(strcmp(atts[i + 1], "true") == 0);
337
field->minus_one = true;
342
field->end = field->start + size - 1;
347
static struct v3d_value *
348
create_value(struct parser_context *ctx, const char **atts)
350
struct v3d_value *value = xzalloc(sizeof(*value));
352
for (int i = 0; atts[i]; i += 2) {
353
if (strcmp(atts[i], "name") == 0)
354
value->name = xstrdup(atts[i + 1]);
355
else if (strcmp(atts[i], "value") == 0)
356
value->value = strtoul(atts[i + 1], NULL, 0);
363
create_and_append_field(struct parser_context *ctx,
366
if (ctx->group->nfields == ctx->group->fields_size) {
367
ctx->group->fields_size = MAX2(ctx->group->fields_size * 2, 2);
369
(struct v3d_field **) realloc(ctx->group->fields,
370
sizeof(ctx->group->fields[0]) *
371
ctx->group->fields_size);
374
ctx->group->fields[ctx->group->nfields++] = create_field(ctx, atts);
378
set_group_opcode(struct v3d_group *group, const char **atts)
383
for (i = 0; atts[i]; i += 2) {
384
if (strcmp(atts[i], "code") == 0)
385
group->opcode = strtoul(atts[i + 1], &p, 0);
391
ver_in_range(int ver, int min_ver, int max_ver)
393
return ((min_ver == 0 || ver >= min_ver) &&
394
(max_ver == 0 || ver <= max_ver));
398
skip_if_ver_mismatch(struct parser_context *ctx, int min_ver, int max_ver)
400
if (!ctx->parse_skip_depth && !ver_in_range(ctx->devinfo->ver,
402
assert(ctx->parse_depth != 0);
403
ctx->parse_skip_depth = ctx->parse_depth;
406
return ctx->parse_skip_depth;
410
start_element(void *data, const char *element_name, const char **atts)
412
struct parser_context *ctx = data;
414
const char *name = NULL;
415
const char *ver = NULL;
419
ctx->loc.line_number = XML_GetCurrentLineNumber(ctx->parser);
421
for (i = 0; atts[i]; i += 2) {
422
if (strcmp(atts[i], "shortname") == 0)
424
else if (strcmp(atts[i], "name") == 0 && !name)
426
else if (strcmp(atts[i], "gen") == 0)
428
else if (strcmp(atts[i], "min_ver") == 0)
429
min_ver = strtoul(atts[i + 1], NULL, 0);
430
else if (strcmp(atts[i], "max_ver") == 0)
431
max_ver = strtoul(atts[i + 1], NULL, 0);
434
if (skip_if_ver_mismatch(ctx, min_ver, max_ver))
437
if (strcmp(element_name, "vcxml") == 0) {
439
fail(&ctx->loc, "no ver given");
441
/* Make sure that we picked an XML that matched our version.
443
assert(ver_in_range(ctx->devinfo->ver, min_ver, max_ver));
446
int n = sscanf(ver, "%d.%d", &major, &minor);
448
fail(&ctx->loc, "invalid ver given: %s", ver);
452
ctx->spec->ver = major * 10 + minor;
453
} else if (strcmp(element_name, "packet") == 0 ||
454
strcmp(element_name, "struct") == 0) {
455
ctx->group = create_group(ctx, name, atts, NULL);
457
if (strcmp(element_name, "packet") == 0)
458
set_group_opcode(ctx->group, atts);
459
} else if (strcmp(element_name, "register") == 0) {
460
ctx->group = create_group(ctx, name, atts, NULL);
461
get_register_offset(atts, &ctx->group->register_offset);
462
} else if (strcmp(element_name, "group") == 0) {
463
struct v3d_group *previous_group = ctx->group;
464
while (previous_group->next)
465
previous_group = previous_group->next;
467
struct v3d_group *group = create_group(ctx, "", atts,
469
previous_group->next = group;
471
} else if (strcmp(element_name, "field") == 0) {
472
create_and_append_field(ctx, atts);
473
} else if (strcmp(element_name, "enum") == 0) {
474
ctx->enoom = create_enum(ctx, name, atts);
475
} else if (strcmp(element_name, "value") == 0) {
476
ctx->values[ctx->nvalues++] = create_value(ctx, atts);
477
assert(ctx->nvalues < ARRAY_SIZE(ctx->values));
485
field_offset_compare(const void *a, const void *b)
487
return ((*(const struct v3d_field **)a)->start -
488
(*(const struct v3d_field **)b)->start);
492
end_element(void *data, const char *name)
494
struct parser_context *ctx = data;
495
struct v3d_spec *spec = ctx->spec;
499
if (ctx->parse_skip_depth) {
500
if (ctx->parse_skip_depth == ctx->parse_depth)
501
ctx->parse_skip_depth = 0;
505
if (strcmp(name, "packet") == 0 ||
506
strcmp(name, "struct") == 0 ||
507
strcmp(name, "register") == 0) {
508
struct v3d_group *group = ctx->group;
510
ctx->group = ctx->group->parent;
512
if (strcmp(name, "packet") == 0) {
513
spec->commands[spec->ncommands++] = group;
515
/* V3D packet XML has the packet contents with offsets
516
* starting from the first bit after the opcode, to
517
* match the spec. Shift the fields up now.
519
for (int i = 0; i < group->nfields; i++) {
520
group->fields[i]->start += 8;
521
group->fields[i]->end += 8;
524
else if (strcmp(name, "struct") == 0)
525
spec->structs[spec->nstructs++] = group;
526
else if (strcmp(name, "register") == 0)
527
spec->registers[spec->nregisters++] = group;
529
/* Sort the fields in increasing offset order. The XML might
530
* be specified in any order, but we'll want to iterate from
533
qsort(group->fields, group->nfields, sizeof(*group->fields),
534
field_offset_compare);
536
assert(spec->ncommands < ARRAY_SIZE(spec->commands));
537
assert(spec->nstructs < ARRAY_SIZE(spec->structs));
538
assert(spec->nregisters < ARRAY_SIZE(spec->registers));
539
} else if (strcmp(name, "group") == 0) {
540
ctx->group = ctx->group->parent;
541
} else if (strcmp(name, "field") == 0) {
542
assert(ctx->group->nfields > 0);
543
struct v3d_field *field = ctx->group->fields[ctx->group->nfields - 1];
544
size_t size = ctx->nvalues * sizeof(ctx->values[0]);
545
field->inline_enum.values = xzalloc(size);
546
field->inline_enum.nvalues = ctx->nvalues;
547
memcpy(field->inline_enum.values, ctx->values, size);
549
} else if (strcmp(name, "enum") == 0) {
550
struct v3d_enum *e = ctx->enoom;
551
size_t size = ctx->nvalues * sizeof(ctx->values[0]);
552
e->values = xzalloc(size);
553
e->nvalues = ctx->nvalues;
554
memcpy(e->values, ctx->values, size);
557
spec->enums[spec->nenums++] = e;
562
character_data(void *data, const XML_Char *s, int len)
566
static uint32_t zlib_inflate(const void *compressed_data,
567
uint32_t compressed_len,
570
struct z_stream_s zstream;
573
memset(&zstream, 0, sizeof(zstream));
575
zstream.next_in = (unsigned char *)compressed_data;
576
zstream.avail_in = compressed_len;
578
if (inflateInit(&zstream) != Z_OK)
582
zstream.next_out = out;
583
zstream.avail_out = 4096;
586
switch (inflate(&zstream, Z_SYNC_FLUSH)) {
592
inflateEnd(&zstream);
596
if (zstream.avail_out)
599
out = realloc(out, 2*zstream.total_out);
601
inflateEnd(&zstream);
605
zstream.next_out = (unsigned char *)out + zstream.total_out;
606
zstream.avail_out = zstream.total_out;
609
inflateEnd(&zstream);
611
return zstream.total_out;
614
#endif /* WITH_LIBEXPAT */
617
v3d_spec_load(const struct v3d_device_info *devinfo)
619
struct v3d_spec *spec = calloc(1, sizeof(struct v3d_spec));
624
struct parser_context ctx;
626
uint8_t *text_data = NULL;
627
uint32_t text_offset = 0, text_length = 0;
628
ASSERTED uint32_t total_length;
630
for (int i = 0; i < ARRAY_SIZE(genxml_files_table); i++) {
632
assert(genxml_files_table[i - 1].ver_10 <
633
genxml_files_table[i].ver_10);
636
if (genxml_files_table[i].ver_10 <= devinfo->ver) {
637
text_offset = genxml_files_table[i].offset;
638
text_length = genxml_files_table[i].length;
642
if (text_length == 0) {
643
fprintf(stderr, "unable to find gen (%u) data\n", devinfo->ver);
648
memset(&ctx, 0, sizeof ctx);
649
ctx.parser = XML_ParserCreate(NULL);
650
ctx.devinfo = devinfo;
651
XML_SetUserData(ctx.parser, &ctx);
652
if (ctx.parser == NULL) {
653
fprintf(stderr, "failed to create parser\n");
658
XML_SetElementHandler(ctx.parser, start_element, end_element);
659
XML_SetCharacterDataHandler(ctx.parser, character_data);
663
total_length = zlib_inflate(compress_genxmls,
664
sizeof(compress_genxmls),
665
(void **) &text_data);
666
assert(text_offset + text_length <= total_length);
668
buf = XML_GetBuffer(ctx.parser, text_length);
669
memcpy(buf, &text_data[text_offset], text_length);
671
if (XML_ParseBuffer(ctx.parser, text_length, true) == 0) {
673
"Error parsing XML at line %ld col %ld byte %ld/%u: %s\n",
674
XML_GetCurrentLineNumber(ctx.parser),
675
XML_GetCurrentColumnNumber(ctx.parser),
676
XML_GetCurrentByteIndex(ctx.parser), text_length,
677
XML_ErrorString(XML_GetErrorCode(ctx.parser)));
678
XML_ParserFree(ctx.parser);
684
XML_ParserFree(ctx.parser);
688
#else /* !WITH_LIBEXPAT */
689
debug_warn_once("CLIF dumping not supported due to missing libexpat");
691
#endif /* !WITH_LIBEXPAT */
695
v3d_spec_find_instruction(struct v3d_spec *spec, const uint8_t *p)
699
for (int i = 0; i < spec->ncommands; i++) {
700
struct v3d_group *group = spec->commands[i];
702
if (opcode != group->opcode)
705
/* If there's a "sub-id" field, make sure that it matches the
706
* instruction being decoded.
708
struct v3d_field *subid = NULL;
709
for (int j = 0; j < group->nfields; j++) {
710
struct v3d_field *field = group->fields[j];
711
if (strcmp(field->name, "sub-id") == 0) {
717
if (subid && (__gen_unpack_uint(p, subid->start, subid->end) !=
718
subid->default_value)) {
728
/** Returns the size of a V3D packet. */
730
v3d_group_get_length(struct v3d_group *group)
733
for (int i = 0; i < group->nfields; i++) {
734
struct v3d_field *field = group->fields[i];
736
last_bit = MAX2(last_bit, field->end);
738
return last_bit / 8 + 1;
742
v3d_field_iterator_init(struct v3d_field_iterator *iter,
743
struct v3d_group *group,
746
memset(iter, 0, sizeof(*iter));
753
v3d_get_enum_name(struct v3d_enum *e, uint64_t value)
755
for (int i = 0; i < e->nvalues; i++) {
756
if (e->values[i]->value == value) {
757
return e->values[i]->name;
764
iter_more_fields(const struct v3d_field_iterator *iter)
766
return iter->field_iter < iter->group->nfields;
770
iter_group_offset_bits(const struct v3d_field_iterator *iter,
773
return iter->group->group_offset + (group_iter *
774
iter->group->group_size);
778
iter_more_groups(const struct v3d_field_iterator *iter)
780
if (iter->group->variable) {
781
return iter_group_offset_bits(iter, iter->group_iter + 1) <
782
(v3d_group_get_length(iter->group) * 8);
784
return (iter->group_iter + 1) < iter->group->group_count ||
785
iter->group->next != NULL;
790
iter_advance_group(struct v3d_field_iterator *iter)
792
if (iter->group->variable)
795
if ((iter->group_iter + 1) < iter->group->group_count) {
798
iter->group = iter->group->next;
799
iter->group_iter = 0;
803
iter->field_iter = 0;
807
iter_advance_field(struct v3d_field_iterator *iter)
809
while (!iter_more_fields(iter)) {
810
if (!iter_more_groups(iter))
813
iter_advance_group(iter);
816
iter->field = iter->group->fields[iter->field_iter++];
817
if (iter->field->name)
818
snprintf(iter->name, sizeof(iter->name), "%s", iter->field->name);
820
memset(iter->name, 0, sizeof(iter->name));
821
iter->offset = iter_group_offset_bits(iter, iter->group_iter) / 8 +
822
iter->field->start / 8;
823
iter->struct_desc = NULL;
829
v3d_field_iterator_next(struct clif_dump *clif, struct v3d_field_iterator *iter)
831
if (!iter_advance_field(iter))
834
const char *enum_name = NULL;
836
int group_member_offset =
837
iter_group_offset_bits(iter, iter->group_iter);
838
int s = group_member_offset + iter->field->start;
839
int e = group_member_offset + iter->field->end;
841
assert(!iter->field->minus_one ||
842
iter->field->type.kind == V3D_TYPE_INT ||
843
iter->field->type.kind == V3D_TYPE_UINT);
845
switch (iter->field->type.kind) {
846
case V3D_TYPE_UNKNOWN:
848
uint32_t value = __gen_unpack_sint(iter->p, s, e);
849
if (iter->field->minus_one)
851
snprintf(iter->value, sizeof(iter->value), "%d", value);
852
enum_name = v3d_get_enum_name(&iter->field->inline_enum, value);
855
case V3D_TYPE_UINT: {
856
uint32_t value = __gen_unpack_uint(iter->p, s, e);
857
if (iter->field->minus_one)
859
if (strcmp(iter->field->name, "Vec size") == 0 && value == 0)
860
value = 1 << (e - s + 1);
861
snprintf(iter->value, sizeof(iter->value), "%u", value);
862
enum_name = v3d_get_enum_name(&iter->field->inline_enum, value);
866
snprintf(iter->value, sizeof(iter->value), "%s",
867
__gen_unpack_uint(iter->p, s, e) ?
868
"1 /* true */" : "0 /* false */");
871
snprintf(iter->value, sizeof(iter->value), "%f",
872
__gen_unpack_float(iter->p, s, e));
876
snprintf(iter->value, sizeof(iter->value), "%f",
877
__gen_unpack_f187(iter->p, s, e));
880
case V3D_TYPE_ADDRESS: {
882
__gen_unpack_uint(iter->p, s, e) << (31 - (e - s));
883
struct clif_bo *bo = clif_lookup_bo(clif, addr);
885
snprintf(iter->value, sizeof(iter->value),
886
"[%s+0x%08x] /* 0x%08x */",
887
bo->name, addr - bo->offset, addr);
889
snprintf(iter->value, sizeof(iter->value),
890
"/* XXX: BO unknown */ 0x%08x", addr);
892
snprintf(iter->value, sizeof(iter->value),
899
case V3D_TYPE_OFFSET:
900
snprintf(iter->value, sizeof(iter->value), "0x%08"PRIx64,
901
__gen_unpack_uint(iter->p, s, e) << (31 - (e - s)));
903
case V3D_TYPE_STRUCT:
904
snprintf(iter->value, sizeof(iter->value), "<struct %s>",
905
iter->field->type.v3d_struct->name);
907
v3d_spec_find_struct(iter->group->spec,
908
iter->field->type.v3d_struct->name);
910
case V3D_TYPE_SFIXED:
912
snprintf(iter->value, sizeof(iter->value), "%f",
913
__gen_unpack_sfixed(iter->p, s, e,
914
iter->field->type.f));
916
snprintf(iter->value, sizeof(iter->value), "%u",
917
(unsigned)__gen_unpack_uint(iter->p, s, e));
920
case V3D_TYPE_UFIXED:
922
snprintf(iter->value, sizeof(iter->value), "%f",
923
__gen_unpack_ufixed(iter->p, s, e,
924
iter->field->type.f));
926
snprintf(iter->value, sizeof(iter->value), "%u",
927
(unsigned)__gen_unpack_uint(iter->p, s, e));
932
case V3D_TYPE_ENUM: {
933
uint32_t value = __gen_unpack_uint(iter->p, s, e);
934
snprintf(iter->value, sizeof(iter->value), "%d", value);
935
enum_name = v3d_get_enum_name(iter->field->type.v3d_enum, value);
940
if (strlen(iter->group->name) == 0) {
941
int length = strlen(iter->name);
942
snprintf(iter->name + length, sizeof(iter->name) - length,
943
"[%i]", iter->group_iter);
947
int length = strlen(iter->value);
948
snprintf(iter->value + length, sizeof(iter->value) - length,
949
" /* %s */", enum_name);
956
v3d_print_group(struct clif_dump *clif, struct v3d_group *group,
957
uint64_t offset, const uint8_t *p)
959
struct v3d_field_iterator iter;
961
v3d_field_iterator_init(&iter, group, p);
962
while (v3d_field_iterator_next(clif, &iter)) {
963
/* Clif parsing uses the packet name, and expects no
966
if (strcmp(iter.field->name, "sub-id") == 0 ||
967
strcmp(iter.field->name, "unused") == 0 ||
968
strcmp(iter.field->name, "Pad") == 0)
972
fprintf(clif->out, " %s: %s\n",
973
iter.name, iter.value);
975
fprintf(clif->out, " /* %30s: */ %s\n",
976
iter.name, iter.value);
978
if (iter.struct_desc) {
979
uint64_t struct_offset = offset + iter.offset;
980
v3d_print_group(clif, iter.struct_desc,