| // SPDX-License-Identifier: GPL-2.0 | |
| /* | |
| * Copyright (C) 2018 Linaro Ltd. | |
| * | |
| * Author: Stanimir Varbanov <stanimir.varbanov@linaro.org> | |
| */ | |
| #include <linux/bitops.h> | |
| #include <linux/kernel.h> | |
| #include "core.h" | |
| #include "hfi_helper.h" | |
| #include "hfi_parser.h" | |
| typedef void (*func)(struct hfi_plat_caps *cap, const void *data, | |
| unsigned int size); | |
| static void init_codecs(struct venus_core *core) | |
| { | |
| struct hfi_plat_caps *caps = core->caps, *cap; | |
| unsigned long bit; | |
| core->codecs_count = 0; | |
| if (hweight_long(core->dec_codecs) + hweight_long(core->enc_codecs) > MAX_CODEC_NUM) | |
| return; | |
| for_each_set_bit(bit, &core->dec_codecs, MAX_CODEC_NUM) { | |
| cap = &caps[core->codecs_count++]; | |
| cap->codec = BIT(bit); | |
| cap->domain = VIDC_SESSION_TYPE_DEC; | |
| cap->valid = false; | |
| } | |
| for_each_set_bit(bit, &core->enc_codecs, MAX_CODEC_NUM) { | |
| cap = &caps[core->codecs_count++]; | |
| cap->codec = BIT(bit); | |
| cap->domain = VIDC_SESSION_TYPE_ENC; | |
| cap->valid = false; | |
| } | |
| } | |
| static void for_each_codec(struct hfi_plat_caps *caps, unsigned int caps_num, | |
| u32 codecs, u32 domain, func cb, void *data, | |
| unsigned int size) | |
| { | |
| struct hfi_plat_caps *cap; | |
| unsigned int i; | |
| for (i = 0; i < caps_num; i++) { | |
| cap = &caps[i]; | |
| if (cap->valid && cap->domain == domain) | |
| continue; | |
| if (cap->codec & codecs && cap->domain == domain) | |
| cb(cap, data, size); | |
| } | |
| } | |
| static void | |
| fill_buf_mode(struct hfi_plat_caps *cap, const void *data, unsigned int num) | |
| { | |
| const u32 *type = data; | |
| if (*type == HFI_BUFFER_MODE_DYNAMIC) | |
| cap->cap_bufs_mode_dynamic = true; | |
| } | |
| static int | |
| parse_alloc_mode(struct venus_core *core, u32 codecs, u32 domain, void *data) | |
| { | |
| struct hfi_buffer_alloc_mode_supported *mode = data; | |
| u32 num_entries = mode->num_entries; | |
| u32 *type; | |
| if (num_entries > MAX_ALLOC_MODE_ENTRIES) | |
| return -EINVAL; | |
| type = mode->data; | |
| while (num_entries--) { | |
| if (mode->buffer_type == HFI_BUFFER_OUTPUT || | |
| mode->buffer_type == HFI_BUFFER_OUTPUT2) | |
| for_each_codec(core->caps, ARRAY_SIZE(core->caps), | |
| codecs, domain, fill_buf_mode, type, 1); | |
| type++; | |
| } | |
| return mode->num_entries * sizeof(u32) + sizeof(*mode); | |
| } | |
| static void fill_profile_level(struct hfi_plat_caps *cap, const void *data, | |
| unsigned int num) | |
| { | |
| const struct hfi_profile_level *pl = data; | |
| if (cap->num_pl + num >= HFI_MAX_PROFILE_COUNT) | |
| return; | |
| memcpy(&cap->pl[cap->num_pl], pl, num * sizeof(*pl)); | |
| cap->num_pl += num; | |
| } | |
| static int | |
| parse_profile_level(struct venus_core *core, u32 codecs, u32 domain, void *data) | |
| { | |
| struct hfi_profile_level_supported *pl = data; | |
| struct hfi_profile_level *proflevel = pl->profile_level; | |
| struct hfi_profile_level pl_arr[HFI_MAX_PROFILE_COUNT] = {}; | |
| if (pl->profile_count > HFI_MAX_PROFILE_COUNT) | |
| return -EINVAL; | |
| memcpy(pl_arr, proflevel, pl->profile_count * sizeof(*proflevel)); | |
| for_each_codec(core->caps, ARRAY_SIZE(core->caps), codecs, domain, | |
| fill_profile_level, pl_arr, pl->profile_count); | |
| return pl->profile_count * sizeof(*proflevel) + sizeof(u32); | |
| } | |
| static void | |
| fill_caps(struct hfi_plat_caps *cap, const void *data, unsigned int num) | |
| { | |
| const struct hfi_capability *caps = data; | |
| if (cap->num_caps + num >= MAX_CAP_ENTRIES) | |
| return; | |
| memcpy(&cap->caps[cap->num_caps], caps, num * sizeof(*caps)); | |
| cap->num_caps += num; | |
| } | |
| static int | |
| parse_caps(struct venus_core *core, u32 codecs, u32 domain, void *data) | |
| { | |
| struct hfi_capabilities *caps = data; | |
| struct hfi_capability *cap = caps->data; | |
| u32 num_caps = caps->num_capabilities; | |
| struct hfi_capability caps_arr[MAX_CAP_ENTRIES] = {}; | |
| if (num_caps > MAX_CAP_ENTRIES) | |
| return -EINVAL; | |
| memcpy(caps_arr, cap, num_caps * sizeof(*cap)); | |
| for_each_codec(core->caps, ARRAY_SIZE(core->caps), codecs, domain, | |
| fill_caps, caps_arr, num_caps); | |
| return num_caps * sizeof(*cap) + sizeof(u32); | |
| } | |
| static void fill_raw_fmts(struct hfi_plat_caps *cap, const void *fmts, | |
| unsigned int num_fmts) | |
| { | |
| const struct raw_formats *formats = fmts; | |
| if (cap->num_fmts + num_fmts >= MAX_FMT_ENTRIES) | |
| return; | |
| memcpy(&cap->fmts[cap->num_fmts], formats, num_fmts * sizeof(*formats)); | |
| cap->num_fmts += num_fmts; | |
| } | |
| static int | |
| parse_raw_formats(struct venus_core *core, u32 codecs, u32 domain, void *data) | |
| { | |
| struct hfi_uncompressed_format_supported *fmt = data; | |
| struct hfi_uncompressed_plane_info *pinfo = &fmt->plane_info; | |
| struct hfi_uncompressed_plane_constraints *constr; | |
| struct raw_formats rawfmts[MAX_FMT_ENTRIES] = {}; | |
| u32 entries = fmt->format_entries; | |
| unsigned int i = 0; | |
| u32 num_planes = 0; | |
| u32 size = 2 * sizeof(u32); | |
| while (entries) { | |
| num_planes = pinfo->num_planes; | |
| rawfmts[i].fmt = pinfo->format; | |
| rawfmts[i].buftype = fmt->buffer_type; | |
| i++; | |
| if (i >= MAX_FMT_ENTRIES) | |
| return -EINVAL; | |
| if (pinfo->num_planes > MAX_PLANES) | |
| break; | |
| size += sizeof(*constr) * num_planes + 2 * sizeof(u32); | |
| pinfo = (void *)pinfo + sizeof(*constr) * num_planes + | |
| 2 * sizeof(u32); | |
| entries--; | |
| } | |
| for_each_codec(core->caps, ARRAY_SIZE(core->caps), codecs, domain, | |
| fill_raw_fmts, rawfmts, i); | |
| return size; | |
| } | |
| static int parse_codecs(struct venus_core *core, void *data) | |
| { | |
| struct hfi_codec_supported *codecs = data; | |
| core->dec_codecs = codecs->dec_codecs; | |
| core->enc_codecs = codecs->enc_codecs; | |
| if (core->res->dec_codec_blacklist) | |
| core->dec_codecs &= ~core->res->dec_codec_blacklist; | |
| if (core->res->enc_codec_blacklist) | |
| core->enc_codecs &= ~core->res->enc_codec_blacklist; | |
| return sizeof(*codecs); | |
| } | |
| static int parse_max_sessions(struct venus_core *core, const void *data) | |
| { | |
| const struct hfi_max_sessions_supported *sessions = data; | |
| core->max_sessions_supported = sessions->max_sessions; | |
| return sizeof(*sessions); | |
| } | |
| static int parse_codecs_mask(u32 *codecs, u32 *domain, void *data) | |
| { | |
| struct hfi_codec_mask_supported *mask = data; | |
| *codecs = mask->codecs; | |
| *domain = mask->video_domains; | |
| return sizeof(*mask); | |
| } | |
| static void parser_init(struct venus_inst *inst, u32 *codecs, u32 *domain) | |
| { | |
| if (!inst || !IS_V1(inst->core)) | |
| return; | |
| *codecs = inst->hfi_codec; | |
| *domain = inst->session_type; | |
| } | |
| static void parser_fini(struct venus_inst *inst, u32 codecs, u32 domain) | |
| { | |
| struct hfi_plat_caps *caps, *cap; | |
| unsigned int i; | |
| u32 dom; | |
| if (!inst || !IS_V1(inst->core)) | |
| return; | |
| caps = inst->core->caps; | |
| dom = inst->session_type; | |
| for (i = 0; i < MAX_CODEC_NUM; i++) { | |
| cap = &caps[i]; | |
| if (cap->codec & codecs && cap->domain == dom) | |
| cap->valid = true; | |
| } | |
| } | |
| static int hfi_platform_parser(struct venus_core *core, struct venus_inst *inst) | |
| { | |
| const struct hfi_platform *plat; | |
| const struct hfi_plat_caps *caps = NULL; | |
| u32 enc_codecs, dec_codecs, count = 0; | |
| unsigned int entries; | |
| plat = hfi_platform_get(core->res->hfi_version); | |
| if (!plat) | |
| return -EINVAL; | |
| if (inst) | |
| return 0; | |
| if (plat->codecs) | |
| plat->codecs(core, &enc_codecs, &dec_codecs, &count); | |
| if (plat->capabilities) | |
| caps = plat->capabilities(core, &entries); | |
| if (!caps || !entries || !count) | |
| return -EINVAL; | |
| core->enc_codecs = enc_codecs; | |
| core->dec_codecs = dec_codecs; | |
| core->codecs_count = count; | |
| core->max_sessions_supported = MAX_SESSIONS; | |
| memset(core->caps, 0, sizeof(*caps) * MAX_CODEC_NUM); | |
| memcpy(core->caps, caps, sizeof(*caps) * entries); | |
| return 0; | |
| } | |
| u32 hfi_parser(struct venus_core *core, struct venus_inst *inst, void *buf, | |
| u32 size) | |
| { | |
| u32 *words = buf, *payload, codecs = 0, domain = 0; | |
| u32 *frame_size = buf + size; | |
| u32 rem_bytes = size; | |
| int ret; | |
| ret = hfi_platform_parser(core, inst); | |
| if (!ret) | |
| return HFI_ERR_NONE; | |
| if (size % 4) | |
| return HFI_ERR_SYS_INSUFFICIENT_RESOURCES; | |
| parser_init(inst, &codecs, &domain); | |
| if (core->res->hfi_version > HFI_VERSION_1XX) { | |
| core->codecs_count = 0; | |
| memset(core->caps, 0, sizeof(core->caps)); | |
| } | |
| while (words < frame_size) { | |
| payload = words + 1; | |
| switch (*words) { | |
| case HFI_PROPERTY_PARAM_CODEC_SUPPORTED: | |
| if (rem_bytes <= sizeof(struct hfi_codec_supported)) | |
| return HFI_ERR_SYS_INSUFFICIENT_RESOURCES; | |
| ret = parse_codecs(core, payload); | |
| if (ret < 0) | |
| return HFI_ERR_SYS_INSUFFICIENT_RESOURCES; | |
| init_codecs(core); | |
| break; | |
| case HFI_PROPERTY_PARAM_MAX_SESSIONS_SUPPORTED: | |
| if (rem_bytes <= sizeof(struct hfi_max_sessions_supported)) | |
| return HFI_ERR_SYS_INSUFFICIENT_RESOURCES; | |
| ret = parse_max_sessions(core, payload); | |
| break; | |
| case HFI_PROPERTY_PARAM_CODEC_MASK_SUPPORTED: | |
| if (rem_bytes <= sizeof(struct hfi_codec_mask_supported)) | |
| return HFI_ERR_SYS_INSUFFICIENT_RESOURCES; | |
| ret = parse_codecs_mask(&codecs, &domain, payload); | |
| break; | |
| case HFI_PROPERTY_PARAM_UNCOMPRESSED_FORMAT_SUPPORTED: | |
| if (rem_bytes <= sizeof(struct hfi_uncompressed_format_supported)) | |
| return HFI_ERR_SYS_INSUFFICIENT_RESOURCES; | |
| ret = parse_raw_formats(core, codecs, domain, payload); | |
| break; | |
| case HFI_PROPERTY_PARAM_CAPABILITY_SUPPORTED: | |
| if (rem_bytes <= sizeof(struct hfi_capabilities)) | |
| return HFI_ERR_SYS_INSUFFICIENT_RESOURCES; | |
| ret = parse_caps(core, codecs, domain, payload); | |
| break; | |
| case HFI_PROPERTY_PARAM_PROFILE_LEVEL_SUPPORTED: | |
| if (rem_bytes <= sizeof(struct hfi_profile_level_supported)) | |
| return HFI_ERR_SYS_INSUFFICIENT_RESOURCES; | |
| ret = parse_profile_level(core, codecs, domain, payload); | |
| break; | |
| case HFI_PROPERTY_PARAM_BUFFER_ALLOC_MODE_SUPPORTED: | |
| if (rem_bytes <= sizeof(struct hfi_buffer_alloc_mode_supported)) | |
| return HFI_ERR_SYS_INSUFFICIENT_RESOURCES; | |
| ret = parse_alloc_mode(core, codecs, domain, payload); | |
| break; | |
| default: | |
| ret = sizeof(u32); | |
| break; | |
| } | |
| if (ret < 0) | |
| return HFI_ERR_SYS_INSUFFICIENT_RESOURCES; | |
| words += ret / sizeof(u32); | |
| rem_bytes -= ret; | |
| } | |
| if (!core->max_sessions_supported) | |
| core->max_sessions_supported = MAX_SESSIONS; | |
| parser_fini(inst, codecs, domain); | |
| return HFI_ERR_NONE; | |
| } |