| /* |
| * Copyright © 2016 Intel Corporation |
| * Copyright © 2017 Broadcom |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| * and/or sell copies of the Software, and to permit persons to whom the |
| * Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| * IN THE SOFTWARE. |
| */ |
| |
| #include "v3d_decoder.h" |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <stdbool.h> |
| #include <stdint.h> |
| #include <stdarg.h> |
| #include <string.h> |
| #ifdef WITH_LIBEXPAT |
| #include <expat.h> |
| #endif |
| #include <inttypes.h> |
| #include <zlib.h> |
| |
| #include <util/macros.h> |
| #include <util/ralloc.h> |
| #include <util/u_debug.h> |
| |
| #include "v3d_packet_helpers.h" |
| #include "v3d_xml.h" |
| #include "broadcom/clif/clif_private.h" |
| |
| struct v3d_spec { |
| uint32_t ver; |
| |
| int ncommands; |
| struct v3d_group *commands[256]; |
| int nstructs; |
| struct v3d_group *structs[256]; |
| int nregisters; |
| struct v3d_group *registers[256]; |
| int nenums; |
| struct v3d_enum *enums[256]; |
| }; |
| |
| #ifdef WITH_LIBEXPAT |
| |
| struct location { |
| const char *filename; |
| int line_number; |
| }; |
| |
| struct parser_context { |
| XML_Parser parser; |
| const struct v3d_device_info *devinfo; |
| int foo; |
| struct location loc; |
| |
| struct v3d_group *group; |
| struct v3d_enum *enoom; |
| |
| int nvalues; |
| struct v3d_value *values[256]; |
| |
| struct v3d_spec *spec; |
| |
| int parse_depth; |
| int parse_skip_depth; |
| }; |
| |
| #endif /* WITH_LIBEXPAT */ |
| |
| const char * |
| v3d_group_get_name(struct v3d_group *group) |
| { |
| return group->name; |
| } |
| |
| uint8_t |
| v3d_group_get_opcode(struct v3d_group *group) |
| { |
| return group->opcode; |
| } |
| |
| struct v3d_group * |
| v3d_spec_find_struct(struct v3d_spec *spec, const char *name) |
| { |
| for (int i = 0; i < spec->nstructs; i++) |
| if (strcmp(spec->structs[i]->name, name) == 0) |
| return spec->structs[i]; |
| |
| return NULL; |
| } |
| |
| struct v3d_group * |
| v3d_spec_find_register(struct v3d_spec *spec, uint32_t offset) |
| { |
| for (int i = 0; i < spec->nregisters; i++) |
| if (spec->registers[i]->register_offset == offset) |
| return spec->registers[i]; |
| |
| return NULL; |
| } |
| |
| struct v3d_group * |
| v3d_spec_find_register_by_name(struct v3d_spec *spec, const char *name) |
| { |
| for (int i = 0; i < spec->nregisters; i++) { |
| if (strcmp(spec->registers[i]->name, name) == 0) |
| return spec->registers[i]; |
| } |
| |
| return NULL; |
| } |
| |
| struct v3d_enum * |
| v3d_spec_find_enum(struct v3d_spec *spec, const char *name) |
| { |
| for (int i = 0; i < spec->nenums; i++) |
| if (strcmp(spec->enums[i]->name, name) == 0) |
| return spec->enums[i]; |
| |
| return NULL; |
| } |
| |
| #ifdef WITH_LIBEXPAT |
| |
| static void __attribute__((noreturn)) |
| fail(struct location *loc, const char *msg, ...) |
| { |
| va_list ap; |
| |
| va_start(ap, msg); |
| fprintf(stderr, "%s:%d: error: ", |
| loc->filename, loc->line_number); |
| vfprintf(stderr, msg, ap); |
| fprintf(stderr, "\n"); |
| va_end(ap); |
| exit(EXIT_FAILURE); |
| } |
| |
| static void * |
| fail_on_null(void *p) |
| { |
| if (p == NULL) { |
| fprintf(stderr, "aubinator: out of memory\n"); |
| exit(EXIT_FAILURE); |
| } |
| |
| return p; |
| } |
| |
| static char * |
| xstrdup(const char *s) |
| { |
| return fail_on_null(strdup(s)); |
| } |
| |
| static void * |
| zalloc(size_t s) |
| { |
| return calloc(s, 1); |
| } |
| |
| static void * |
| xzalloc(size_t s) |
| { |
| return fail_on_null(zalloc(s)); |
| } |
| |
| /* We allow fields to have either a bit index, or append "b" for a byte index. |
| */ |
| static bool |
| is_byte_offset(const char *value) |
| { |
| return value[strlen(value) - 1] == 'b'; |
| } |
| |
| static void |
| get_group_offset_count(const char **atts, uint32_t *offset, uint32_t *count, |
| uint32_t *size, bool *variable) |
| { |
| char *p; |
| int i; |
| |
| for (i = 0; atts[i]; i += 2) { |
| if (strcmp(atts[i], "count") == 0) { |
| *count = strtoul(atts[i + 1], &p, 0); |
| if (*count == 0) |
| *variable = true; |
| } else if (strcmp(atts[i], "start") == 0) { |
| *offset = strtoul(atts[i + 1], &p, 0); |
| } else if (strcmp(atts[i], "size") == 0) { |
| *size = strtoul(atts[i + 1], &p, 0); |
| } |
| } |
| return; |
| } |
| |
| static struct v3d_group * |
| create_group(struct parser_context *ctx, |
| const char *name, |
| const char **atts, |
| struct v3d_group *parent) |
| { |
| struct v3d_group *group; |
| |
| group = xzalloc(sizeof(*group)); |
| if (name) |
| group->name = xstrdup(name); |
| |
| group->spec = ctx->spec; |
| group->group_offset = 0; |
| group->group_count = 0; |
| group->variable = false; |
| |
| if (parent) { |
| group->parent = parent; |
| get_group_offset_count(atts, |
| &group->group_offset, |
| &group->group_count, |
| &group->group_size, |
| &group->variable); |
| } |
| |
| return group; |
| } |
| |
| static struct v3d_enum * |
| create_enum(struct parser_context *ctx, const char *name, const char **atts) |
| { |
| struct v3d_enum *e; |
| |
| e = xzalloc(sizeof(*e)); |
| if (name) |
| e->name = xstrdup(name); |
| |
| e->nvalues = 0; |
| |
| return e; |
| } |
| |
| static void |
| get_register_offset(const char **atts, uint32_t *offset) |
| { |
| char *p; |
| int i; |
| |
| for (i = 0; atts[i]; i += 2) { |
| if (strcmp(atts[i], "num") == 0) |
| *offset = strtoul(atts[i + 1], &p, 0); |
| } |
| return; |
| } |
| |
| static struct v3d_type |
| string_to_type(struct parser_context *ctx, const char *s) |
| { |
| int i, f; |
| struct v3d_group *g; |
| struct v3d_enum *e; |
| |
| if (strcmp(s, "int") == 0) |
| return (struct v3d_type) { .kind = V3D_TYPE_INT }; |
| else if (strcmp(s, "uint") == 0) |
| return (struct v3d_type) { .kind = V3D_TYPE_UINT }; |
| else if (strcmp(s, "bool") == 0) |
| return (struct v3d_type) { .kind = V3D_TYPE_BOOL }; |
| else if (strcmp(s, "float") == 0) |
| return (struct v3d_type) { .kind = V3D_TYPE_FLOAT }; |
| else if (strcmp(s, "f187") == 0) |
| return (struct v3d_type) { .kind = V3D_TYPE_F187 }; |
| else if (strcmp(s, "address") == 0) |
| return (struct v3d_type) { .kind = V3D_TYPE_ADDRESS }; |
| else if (strcmp(s, "offset") == 0) |
| return (struct v3d_type) { .kind = V3D_TYPE_OFFSET }; |
| else if (sscanf(s, "u%d.%d", &i, &f) == 2) |
| return (struct v3d_type) { .kind = V3D_TYPE_UFIXED, .i = i, .f = f }; |
| else if (sscanf(s, "s%d.%d", &i, &f) == 2) |
| return (struct v3d_type) { .kind = V3D_TYPE_SFIXED, .i = i, .f = f }; |
| else if (g = v3d_spec_find_struct(ctx->spec, s), g != NULL) |
| return (struct v3d_type) { .kind = V3D_TYPE_STRUCT, .v3d_struct = g }; |
| else if (e = v3d_spec_find_enum(ctx->spec, s), e != NULL) |
| return (struct v3d_type) { .kind = V3D_TYPE_ENUM, .v3d_enum = e }; |
| else if (strcmp(s, "mbo") == 0) |
| return (struct v3d_type) { .kind = V3D_TYPE_MBO }; |
| else |
| fail(&ctx->loc, "invalid type: %s", s); |
| } |
| |
| static struct v3d_field * |
| create_field(struct parser_context *ctx, const char **atts) |
| { |
| struct v3d_field *field; |
| char *p; |
| int i; |
| uint32_t size = 0; |
| |
| field = xzalloc(sizeof(*field)); |
| |
| for (i = 0; atts[i]; i += 2) { |
| if (strcmp(atts[i], "name") == 0) |
| field->name = xstrdup(atts[i + 1]); |
| else if (strcmp(atts[i], "start") == 0) { |
| field->start = strtoul(atts[i + 1], &p, 0); |
| if (is_byte_offset(atts[i + 1])) |
| field->start *= 8; |
| } else if (strcmp(atts[i], "end") == 0) { |
| field->end = strtoul(atts[i + 1], &p, 0) - 1; |
| if (is_byte_offset(atts[i + 1])) |
| field->end *= 8; |
| } else if (strcmp(atts[i], "size") == 0) { |
| size = strtoul(atts[i + 1], &p, 0); |
| if (is_byte_offset(atts[i + 1])) |
| size *= 8; |
| } else if (strcmp(atts[i], "type") == 0) |
| field->type = string_to_type(ctx, atts[i + 1]); |
| else if (strcmp(atts[i], "default") == 0) { |
| field->has_default = true; |
| field->default_value = strtoul(atts[i + 1], &p, 0); |
| } else if (strcmp(atts[i], "minus_one") == 0) { |
| assert(strcmp(atts[i + 1], "true") == 0); |
| field->minus_one = true; |
| } |
| } |
| |
| if (size) |
| field->end = field->start + size - 1; |
| |
| return field; |
| } |
| |
| static struct v3d_value * |
| create_value(struct parser_context *ctx, const char **atts) |
| { |
| struct v3d_value *value = xzalloc(sizeof(*value)); |
| |
| for (int i = 0; atts[i]; i += 2) { |
| if (strcmp(atts[i], "name") == 0) |
| value->name = xstrdup(atts[i + 1]); |
| else if (strcmp(atts[i], "value") == 0) |
| value->value = strtoul(atts[i + 1], NULL, 0); |
| } |
| |
| return value; |
| } |
| |
| static void |
| create_and_append_field(struct parser_context *ctx, |
| const char **atts) |
| { |
| if (ctx->group->nfields == ctx->group->fields_size) { |
| ctx->group->fields_size = MAX2(ctx->group->fields_size * 2, 2); |
| ctx->group->fields = |
| (struct v3d_field **) realloc(ctx->group->fields, |
| sizeof(ctx->group->fields[0]) * |
| ctx->group->fields_size); |
| } |
| |
| ctx->group->fields[ctx->group->nfields++] = create_field(ctx, atts); |
| } |
| |
| static void |
| set_group_opcode(struct v3d_group *group, const char **atts) |
| { |
| char *p; |
| int i; |
| |
| for (i = 0; atts[i]; i += 2) { |
| if (strcmp(atts[i], "code") == 0) |
| group->opcode = strtoul(atts[i + 1], &p, 0); |
| } |
| return; |
| } |
| |
| static bool |
| ver_in_range(int ver, int min_ver, int max_ver) |
| { |
| return ((min_ver == 0 || ver >= min_ver) && |
| (max_ver == 0 || ver <= max_ver)); |
| } |
| |
| static bool |
| skip_if_ver_mismatch(struct parser_context *ctx, int min_ver, int max_ver) |
| { |
| if (!ctx->parse_skip_depth && !ver_in_range(ctx->devinfo->ver, |
| min_ver, max_ver)) { |
| assert(ctx->parse_depth != 0); |
| ctx->parse_skip_depth = ctx->parse_depth; |
| } |
| |
| return ctx->parse_skip_depth; |
| } |
| |
| static void |
| start_element(void *data, const char *element_name, const char **atts) |
| { |
| struct parser_context *ctx = data; |
| int i; |
| const char *name = NULL; |
| const char *ver = NULL; |
| int min_ver = 0; |
| int max_ver = 0; |
| |
| ctx->loc.line_number = XML_GetCurrentLineNumber(ctx->parser); |
| |
| for (i = 0; atts[i]; i += 2) { |
| if (strcmp(atts[i], "shortname") == 0) |
| name = atts[i + 1]; |
| else if (strcmp(atts[i], "name") == 0 && !name) |
| name = atts[i + 1]; |
| else if (strcmp(atts[i], "gen") == 0) |
| ver = atts[i + 1]; |
| else if (strcmp(atts[i], "min_ver") == 0) |
| min_ver = strtoul(atts[i + 1], NULL, 0); |
| else if (strcmp(atts[i], "max_ver") == 0) |
| max_ver = strtoul(atts[i + 1], NULL, 0); |
| } |
| |
| if (skip_if_ver_mismatch(ctx, min_ver, max_ver)) |
| goto skip; |
| |
| if (strcmp(element_name, "vcxml") == 0) { |
| if (ver == NULL) |
| fail(&ctx->loc, "no ver given"); |
| |
| /* Make sure that we picked an XML that matched our version. |
| */ |
| assert(ver_in_range(ctx->devinfo->ver, min_ver, max_ver)); |
| |
| int major, minor; |
| int n = sscanf(ver, "%d.%d", &major, &minor); |
| if (n == 0) |
| fail(&ctx->loc, "invalid ver given: %s", ver); |
| if (n == 1) |
| minor = 0; |
| |
| ctx->spec->ver = major * 10 + minor; |
| } else if (strcmp(element_name, "packet") == 0 || |
| strcmp(element_name, "struct") == 0) { |
| ctx->group = create_group(ctx, name, atts, NULL); |
| |
| if (strcmp(element_name, "packet") == 0) |
| set_group_opcode(ctx->group, atts); |
| } else if (strcmp(element_name, "register") == 0) { |
| ctx->group = create_group(ctx, name, atts, NULL); |
| get_register_offset(atts, &ctx->group->register_offset); |
| } else if (strcmp(element_name, "group") == 0) { |
| struct v3d_group *previous_group = ctx->group; |
| while (previous_group->next) |
| previous_group = previous_group->next; |
| |
| struct v3d_group *group = create_group(ctx, "", atts, |
| ctx->group); |
| previous_group->next = group; |
| ctx->group = group; |
| } else if (strcmp(element_name, "field") == 0) { |
| create_and_append_field(ctx, atts); |
| } else if (strcmp(element_name, "enum") == 0) { |
| ctx->enoom = create_enum(ctx, name, atts); |
| } else if (strcmp(element_name, "value") == 0) { |
| ctx->values[ctx->nvalues++] = create_value(ctx, atts); |
| assert(ctx->nvalues < ARRAY_SIZE(ctx->values)); |
| } |
| |
| skip: |
| ctx->parse_depth++; |
| } |
| |
| static int |
| field_offset_compare(const void *a, const void *b) |
| { |
| return ((*(const struct v3d_field **)a)->start - |
| (*(const struct v3d_field **)b)->start); |
| } |
| |
| static void |
| end_element(void *data, const char *name) |
| { |
| struct parser_context *ctx = data; |
| struct v3d_spec *spec = ctx->spec; |
| |
| ctx->parse_depth--; |
| |
| if (ctx->parse_skip_depth) { |
| if (ctx->parse_skip_depth == ctx->parse_depth) |
| ctx->parse_skip_depth = 0; |
| return; |
| } |
| |
| if (strcmp(name, "packet") == 0 || |
| strcmp(name, "struct") == 0 || |
| strcmp(name, "register") == 0) { |
| struct v3d_group *group = ctx->group; |
| |
| ctx->group = ctx->group->parent; |
| |
| if (strcmp(name, "packet") == 0) { |
| spec->commands[spec->ncommands++] = group; |
| |
| /* V3D packet XML has the packet contents with offsets |
| * starting from the first bit after the opcode, to |
| * match the spec. Shift the fields up now. |
| */ |
| for (int i = 0; i < group->nfields; i++) { |
| group->fields[i]->start += 8; |
| group->fields[i]->end += 8; |
| } |
| } |
| else if (strcmp(name, "struct") == 0) |
| spec->structs[spec->nstructs++] = group; |
| else if (strcmp(name, "register") == 0) |
| spec->registers[spec->nregisters++] = group; |
| |
| /* Sort the fields in increasing offset order. The XML might |
| * be specified in any order, but we'll want to iterate from |
| * the bottom. |
| */ |
| qsort(group->fields, group->nfields, sizeof(*group->fields), |
| field_offset_compare); |
| |
| assert(spec->ncommands < ARRAY_SIZE(spec->commands)); |
| assert(spec->nstructs < ARRAY_SIZE(spec->structs)); |
| assert(spec->nregisters < ARRAY_SIZE(spec->registers)); |
| } else if (strcmp(name, "group") == 0) { |
| ctx->group = ctx->group->parent; |
| } else if (strcmp(name, "field") == 0) { |
| assert(ctx->group->nfields > 0); |
| struct v3d_field *field = ctx->group->fields[ctx->group->nfields - 1]; |
| size_t size = ctx->nvalues * sizeof(ctx->values[0]); |
| field->inline_enum.values = xzalloc(size); |
| field->inline_enum.nvalues = ctx->nvalues; |
| memcpy(field->inline_enum.values, ctx->values, size); |
| ctx->nvalues = 0; |
| } else if (strcmp(name, "enum") == 0) { |
| struct v3d_enum *e = ctx->enoom; |
| size_t size = ctx->nvalues * sizeof(ctx->values[0]); |
| e->values = xzalloc(size); |
| e->nvalues = ctx->nvalues; |
| memcpy(e->values, ctx->values, size); |
| ctx->nvalues = 0; |
| ctx->enoom = NULL; |
| spec->enums[spec->nenums++] = e; |
| } |
| } |
| |
| static void |
| character_data(void *data, const XML_Char *s, int len) |
| { |
| } |
| |
| static uint32_t zlib_inflate(const void *compressed_data, |
| uint32_t compressed_len, |
| void **out_ptr) |
| { |
| struct z_stream_s zstream; |
| void *out; |
| |
| memset(&zstream, 0, sizeof(zstream)); |
| |
| zstream.next_in = (unsigned char *)compressed_data; |
| zstream.avail_in = compressed_len; |
| |
| if (inflateInit(&zstream) != Z_OK) |
| return 0; |
| |
| out = malloc(4096); |
| zstream.next_out = out; |
| zstream.avail_out = 4096; |
| |
| do { |
| switch (inflate(&zstream, Z_SYNC_FLUSH)) { |
| case Z_STREAM_END: |
| goto end; |
| case Z_OK: |
| break; |
| default: |
| inflateEnd(&zstream); |
| return 0; |
| } |
| |
| if (zstream.avail_out) |
| break; |
| |
| out = realloc(out, 2*zstream.total_out); |
| if (out == NULL) { |
| inflateEnd(&zstream); |
| return 0; |
| } |
| |
| zstream.next_out = (unsigned char *)out + zstream.total_out; |
| zstream.avail_out = zstream.total_out; |
| } while (1); |
| end: |
| inflateEnd(&zstream); |
| *out_ptr = out; |
| return zstream.total_out; |
| } |
| |
| #endif /* WITH_LIBEXPAT */ |
| |
| struct v3d_spec * |
| v3d_spec_load(const struct v3d_device_info *devinfo) |
| { |
| struct v3d_spec *spec = calloc(1, sizeof(struct v3d_spec)); |
| if (!spec) |
| return NULL; |
| |
| #ifdef WITH_LIBEXPAT |
| struct parser_context ctx; |
| void *buf; |
| uint8_t *text_data = NULL; |
| uint32_t text_offset = 0, text_length = 0; |
| ASSERTED uint32_t total_length; |
| |
| for (int i = 0; i < ARRAY_SIZE(genxml_files_table); i++) { |
| if (i != 0) { |
| assert(genxml_files_table[i - 1].ver_10 < |
| genxml_files_table[i].ver_10); |
| } |
| |
| if (genxml_files_table[i].ver_10 <= devinfo->ver) { |
| text_offset = genxml_files_table[i].offset; |
| text_length = genxml_files_table[i].length; |
| } |
| } |
| |
| if (text_length == 0) { |
| fprintf(stderr, "unable to find gen (%u) data\n", devinfo->ver); |
| free(spec); |
| return NULL; |
| } |
| |
| memset(&ctx, 0, sizeof ctx); |
| ctx.parser = XML_ParserCreate(NULL); |
| ctx.devinfo = devinfo; |
| XML_SetUserData(ctx.parser, &ctx); |
| if (ctx.parser == NULL) { |
| fprintf(stderr, "failed to create parser\n"); |
| free(spec); |
| return NULL; |
| } |
| |
| XML_SetElementHandler(ctx.parser, start_element, end_element); |
| XML_SetCharacterDataHandler(ctx.parser, character_data); |
| |
| ctx.spec = spec; |
| |
| total_length = zlib_inflate(compress_genxmls, |
| sizeof(compress_genxmls), |
| (void **) &text_data); |
| assert(text_offset + text_length <= total_length); |
| |
| buf = XML_GetBuffer(ctx.parser, text_length); |
| memcpy(buf, &text_data[text_offset], text_length); |
| |
| if (XML_ParseBuffer(ctx.parser, text_length, true) == 0) { |
| fprintf(stderr, |
| "Error parsing XML at line %ld col %ld byte %ld/%u: %s\n", |
| XML_GetCurrentLineNumber(ctx.parser), |
| XML_GetCurrentColumnNumber(ctx.parser), |
| XML_GetCurrentByteIndex(ctx.parser), text_length, |
| XML_ErrorString(XML_GetErrorCode(ctx.parser))); |
| XML_ParserFree(ctx.parser); |
| free(text_data); |
| free(spec); |
| return NULL; |
| } |
| |
| XML_ParserFree(ctx.parser); |
| free(text_data); |
| |
| return ctx.spec; |
| #else /* !WITH_LIBEXPAT */ |
| debug_warn_once("CLIF dumping not supported due to missing libexpat"); |
| return spec; |
| #endif /* !WITH_LIBEXPAT */ |
| } |
| |
| struct v3d_group * |
| v3d_spec_find_instruction(struct v3d_spec *spec, const uint8_t *p) |
| { |
| uint8_t opcode = *p; |
| |
| for (int i = 0; i < spec->ncommands; i++) { |
| struct v3d_group *group = spec->commands[i]; |
| |
| if (opcode != group->opcode) |
| continue; |
| |
| /* If there's a "sub-id" field, make sure that it matches the |
| * instruction being decoded. |
| */ |
| struct v3d_field *subid = NULL; |
| for (int j = 0; j < group->nfields; j++) { |
| struct v3d_field *field = group->fields[j]; |
| if (strcmp(field->name, "sub-id") == 0) { |
| subid = field; |
| break; |
| } |
| } |
| |
| if (subid && (__gen_unpack_uint(p, subid->start, subid->end) != |
| subid->default_value)) { |
| continue; |
| } |
| |
| return group; |
| } |
| |
| return NULL; |
| } |
| |
| /** Returns the size of a V3D packet. */ |
| int |
| v3d_group_get_length(struct v3d_group *group) |
| { |
| int last_bit = 0; |
| for (int i = 0; i < group->nfields; i++) { |
| struct v3d_field *field = group->fields[i]; |
| |
| last_bit = MAX2(last_bit, field->end); |
| } |
| return last_bit / 8 + 1; |
| } |
| |
| void |
| v3d_field_iterator_init(struct v3d_field_iterator *iter, |
| struct v3d_group *group, |
| const uint8_t *p) |
| { |
| memset(iter, 0, sizeof(*iter)); |
| |
| iter->group = group; |
| iter->p = p; |
| } |
| |
| static const char * |
| v3d_get_enum_name(struct v3d_enum *e, uint64_t value) |
| { |
| for (int i = 0; i < e->nvalues; i++) { |
| if (e->values[i]->value == value) { |
| return e->values[i]->name; |
| } |
| } |
| return NULL; |
| } |
| |
| static bool |
| iter_more_fields(const struct v3d_field_iterator *iter) |
| { |
| return iter->field_iter < iter->group->nfields; |
| } |
| |
| static uint32_t |
| iter_group_offset_bits(const struct v3d_field_iterator *iter, |
| uint32_t group_iter) |
| { |
| return iter->group->group_offset + (group_iter * |
| iter->group->group_size); |
| } |
| |
| static bool |
| iter_more_groups(const struct v3d_field_iterator *iter) |
| { |
| if (iter->group->variable) { |
| return iter_group_offset_bits(iter, iter->group_iter + 1) < |
| (v3d_group_get_length(iter->group) * 8); |
| } else { |
| return (iter->group_iter + 1) < iter->group->group_count || |
| iter->group->next != NULL; |
| } |
| } |
| |
| static void |
| iter_advance_group(struct v3d_field_iterator *iter) |
| { |
| if (iter->group->variable) |
| iter->group_iter++; |
| else { |
| if ((iter->group_iter + 1) < iter->group->group_count) { |
| iter->group_iter++; |
| } else { |
| iter->group = iter->group->next; |
| iter->group_iter = 0; |
| } |
| } |
| |
| iter->field_iter = 0; |
| } |
| |
| static bool |
| iter_advance_field(struct v3d_field_iterator *iter) |
| { |
| while (!iter_more_fields(iter)) { |
| if (!iter_more_groups(iter)) |
| return false; |
| |
| iter_advance_group(iter); |
| } |
| |
| iter->field = iter->group->fields[iter->field_iter++]; |
| if (iter->field->name) |
| snprintf(iter->name, sizeof(iter->name), "%s", iter->field->name); |
| else |
| memset(iter->name, 0, sizeof(iter->name)); |
| iter->offset = iter_group_offset_bits(iter, iter->group_iter) / 8 + |
| iter->field->start / 8; |
| iter->struct_desc = NULL; |
| |
| return true; |
| } |
| |
| bool |
| v3d_field_iterator_next(struct clif_dump *clif, struct v3d_field_iterator *iter) |
| { |
| if (!iter_advance_field(iter)) |
| return false; |
| |
| const char *enum_name = NULL; |
| |
| int group_member_offset = |
| iter_group_offset_bits(iter, iter->group_iter); |
| int s = group_member_offset + iter->field->start; |
| int e = group_member_offset + iter->field->end; |
| |
| assert(!iter->field->minus_one || |
| iter->field->type.kind == V3D_TYPE_INT || |
| iter->field->type.kind == V3D_TYPE_UINT); |
| |
| switch (iter->field->type.kind) { |
| case V3D_TYPE_UNKNOWN: |
| case V3D_TYPE_INT: { |
| uint32_t value = __gen_unpack_sint(iter->p, s, e); |
| if (iter->field->minus_one) |
| value++; |
| snprintf(iter->value, sizeof(iter->value), "%d", value); |
| enum_name = v3d_get_enum_name(&iter->field->inline_enum, value); |
| break; |
| } |
| case V3D_TYPE_UINT: { |
| uint32_t value = __gen_unpack_uint(iter->p, s, e); |
| if (iter->field->minus_one) |
| value++; |
| if (strcmp(iter->field->name, "Vec size") == 0 && value == 0) |
| value = 1 << (e - s + 1); |
| snprintf(iter->value, sizeof(iter->value), "%u", value); |
| enum_name = v3d_get_enum_name(&iter->field->inline_enum, value); |
| break; |
| } |
| case V3D_TYPE_BOOL: |
| snprintf(iter->value, sizeof(iter->value), "%s", |
| __gen_unpack_uint(iter->p, s, e) ? |
| "1 /* true */" : "0 /* false */"); |
| break; |
| case V3D_TYPE_FLOAT: |
| snprintf(iter->value, sizeof(iter->value), "%f", |
| __gen_unpack_float(iter->p, s, e)); |
| break; |
| |
| case V3D_TYPE_F187: |
| snprintf(iter->value, sizeof(iter->value), "%f", |
| __gen_unpack_f187(iter->p, s, e)); |
| break; |
| |
| case V3D_TYPE_ADDRESS: { |
| uint32_t addr = |
| __gen_unpack_uint(iter->p, s, e) << (31 - (e - s)); |
| struct clif_bo *bo = clif_lookup_bo(clif, addr); |
| if (bo) { |
| snprintf(iter->value, sizeof(iter->value), |
| "[%s+0x%08x] /* 0x%08x */", |
| bo->name, addr - bo->offset, addr); |
| } else if (addr) { |
| snprintf(iter->value, sizeof(iter->value), |
| "/* XXX: BO unknown */ 0x%08x", addr); |
| } else { |
| snprintf(iter->value, sizeof(iter->value), |
| "[null]"); |
| } |
| |
| break; |
| } |
| |
| case V3D_TYPE_OFFSET: |
| snprintf(iter->value, sizeof(iter->value), "0x%08"PRIx64, |
| __gen_unpack_uint(iter->p, s, e) << (31 - (e - s))); |
| break; |
| case V3D_TYPE_STRUCT: |
| snprintf(iter->value, sizeof(iter->value), "<struct %s>", |
| iter->field->type.v3d_struct->name); |
| iter->struct_desc = |
| v3d_spec_find_struct(iter->group->spec, |
| iter->field->type.v3d_struct->name); |
| break; |
| case V3D_TYPE_SFIXED: |
| if (clif->pretty) { |
| snprintf(iter->value, sizeof(iter->value), "%f", |
| __gen_unpack_sfixed(iter->p, s, e, |
| iter->field->type.f)); |
| } else { |
| snprintf(iter->value, sizeof(iter->value), "%u", |
| (unsigned)__gen_unpack_uint(iter->p, s, e)); |
| } |
| break; |
| case V3D_TYPE_UFIXED: |
| if (clif->pretty) { |
| snprintf(iter->value, sizeof(iter->value), "%f", |
| __gen_unpack_ufixed(iter->p, s, e, |
| iter->field->type.f)); |
| } else { |
| snprintf(iter->value, sizeof(iter->value), "%u", |
| (unsigned)__gen_unpack_uint(iter->p, s, e)); |
| } |
| break; |
| case V3D_TYPE_MBO: |
| break; |
| case V3D_TYPE_ENUM: { |
| uint32_t value = __gen_unpack_uint(iter->p, s, e); |
| snprintf(iter->value, sizeof(iter->value), "%d", value); |
| enum_name = v3d_get_enum_name(iter->field->type.v3d_enum, value); |
| break; |
| } |
| } |
| |
| if (strlen(iter->group->name) == 0) { |
| int length = strlen(iter->name); |
| snprintf(iter->name + length, sizeof(iter->name) - length, |
| "[%i]", iter->group_iter); |
| } |
| |
| if (enum_name) { |
| int length = strlen(iter->value); |
| snprintf(iter->value + length, sizeof(iter->value) - length, |
| " /* %s */", enum_name); |
| } |
| |
| return true; |
| } |
| |
| void |
| v3d_print_group(struct clif_dump *clif, struct v3d_group *group, |
| uint64_t offset, const uint8_t *p) |
| { |
| struct v3d_field_iterator iter; |
| |
| v3d_field_iterator_init(&iter, group, p); |
| while (v3d_field_iterator_next(clif, &iter)) { |
| /* Clif parsing uses the packet name, and expects no |
| * sub-id. |
| */ |
| if (strcmp(iter.field->name, "sub-id") == 0 || |
| strcmp(iter.field->name, "unused") == 0 || |
| strcmp(iter.field->name, "Pad") == 0) |
| continue; |
| |
| if (clif->pretty) { |
| fprintf(clif->out, " %s: %s\n", |
| iter.name, iter.value); |
| } else { |
| fprintf(clif->out, " /* %30s: */ %s\n", |
| iter.name, iter.value); |
| } |
| if (iter.struct_desc) { |
| uint64_t struct_offset = offset + iter.offset; |
| v3d_print_group(clif, iter.struct_desc, |
| struct_offset, |
| &p[iter.offset]); |
| } |
| } |
| } |
