1379 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.4 * Copyright (C) 2017 Linaro Ltd.5 */6#include <linux/overflow.h>7#include <linux/errno.h>8#include <linux/hash.h>9 10#include "hfi_cmds.h"11 12static enum hfi_version hfi_ver;13 14void pkt_sys_init(struct hfi_sys_init_pkt *pkt, u32 arch_type)15{16 pkt->hdr.size = sizeof(*pkt);17 pkt->hdr.pkt_type = HFI_CMD_SYS_INIT;18 pkt->arch_type = arch_type;19}20 21void pkt_sys_pc_prep(struct hfi_sys_pc_prep_pkt *pkt)22{23 pkt->hdr.size = sizeof(*pkt);24 pkt->hdr.pkt_type = HFI_CMD_SYS_PC_PREP;25}26 27void pkt_sys_idle_indicator(struct hfi_sys_set_property_pkt *pkt, u32 enable)28{29 struct hfi_enable *hfi = (struct hfi_enable *)&pkt->data[1];30 31 pkt->hdr.size = struct_size(pkt, data, 1) + sizeof(*hfi);32 pkt->hdr.pkt_type = HFI_CMD_SYS_SET_PROPERTY;33 pkt->num_properties = 1;34 pkt->data[0] = HFI_PROPERTY_SYS_IDLE_INDICATOR;35 hfi->enable = enable;36}37 38void pkt_sys_debug_config(struct hfi_sys_set_property_pkt *pkt, u32 mode,39 u32 config)40{41 struct hfi_debug_config *hfi;42 43 pkt->hdr.size = struct_size(pkt, data, 1) + sizeof(*hfi);44 pkt->hdr.pkt_type = HFI_CMD_SYS_SET_PROPERTY;45 pkt->num_properties = 1;46 pkt->data[0] = HFI_PROPERTY_SYS_DEBUG_CONFIG;47 hfi = (struct hfi_debug_config *)&pkt->data[1];48 hfi->config = config;49 hfi->mode = mode;50}51 52void pkt_sys_coverage_config(struct hfi_sys_set_property_pkt *pkt, u32 mode)53{54 pkt->hdr.size = struct_size(pkt, data, 2);55 pkt->hdr.pkt_type = HFI_CMD_SYS_SET_PROPERTY;56 pkt->num_properties = 1;57 pkt->data[0] = HFI_PROPERTY_SYS_CONFIG_COVERAGE;58 pkt->data[1] = mode;59}60 61void pkt_sys_ubwc_config(struct hfi_sys_set_property_pkt *pkt, const struct hfi_ubwc_config *hfi)62{63 pkt->hdr.size = struct_size(pkt, data, 1) + sizeof(*hfi);64 pkt->hdr.pkt_type = HFI_CMD_SYS_SET_PROPERTY;65 pkt->num_properties = 1;66 pkt->data[0] = HFI_PROPERTY_SYS_UBWC_CONFIG;67 memcpy(&pkt->data[1], hfi, sizeof(*hfi));68}69 70int pkt_sys_set_resource(struct hfi_sys_set_resource_pkt *pkt, u32 id, u32 size,71 u32 addr, void *cookie)72{73 pkt->hdr.size = sizeof(*pkt);74 pkt->hdr.pkt_type = HFI_CMD_SYS_SET_RESOURCE;75 pkt->resource_handle = hash32_ptr(cookie);76 77 switch (id) {78 case VIDC_RESOURCE_OCMEM:79 case VIDC_RESOURCE_VMEM: {80 struct hfi_resource_ocmem *res =81 (struct hfi_resource_ocmem *)&pkt->resource_data[0];82 83 res->size = size;84 res->mem = addr;85 pkt->resource_type = HFI_RESOURCE_OCMEM;86 pkt->hdr.size += sizeof(*res);87 break;88 }89 case VIDC_RESOURCE_NONE:90 default:91 return -ENOTSUPP;92 }93 94 return 0;95}96 97int pkt_sys_unset_resource(struct hfi_sys_release_resource_pkt *pkt, u32 id,98 u32 size, void *cookie)99{100 pkt->hdr.size = sizeof(*pkt);101 pkt->hdr.pkt_type = HFI_CMD_SYS_RELEASE_RESOURCE;102 pkt->resource_handle = hash32_ptr(cookie);103 104 switch (id) {105 case VIDC_RESOURCE_OCMEM:106 case VIDC_RESOURCE_VMEM:107 pkt->resource_type = HFI_RESOURCE_OCMEM;108 break;109 case VIDC_RESOURCE_NONE:110 break;111 default:112 return -ENOTSUPP;113 }114 115 return 0;116}117 118void pkt_sys_ping(struct hfi_sys_ping_pkt *pkt, u32 cookie)119{120 pkt->hdr.size = sizeof(*pkt);121 pkt->hdr.pkt_type = HFI_CMD_SYS_PING;122 pkt->client_data = cookie;123}124 125void pkt_sys_power_control(struct hfi_sys_set_property_pkt *pkt, u32 enable)126{127 struct hfi_enable *hfi = (struct hfi_enable *)&pkt->data[1];128 129 pkt->hdr.size = struct_size(pkt, data, 1) + sizeof(*hfi);130 pkt->hdr.pkt_type = HFI_CMD_SYS_SET_PROPERTY;131 pkt->num_properties = 1;132 pkt->data[0] = HFI_PROPERTY_SYS_CODEC_POWER_PLANE_CTRL;133 hfi->enable = enable;134}135 136int pkt_sys_ssr_cmd(struct hfi_sys_test_ssr_pkt *pkt, u32 trigger_type)137{138 switch (trigger_type) {139 case HFI_TEST_SSR_SW_ERR_FATAL:140 case HFI_TEST_SSR_SW_DIV_BY_ZERO:141 case HFI_TEST_SSR_HW_WDOG_IRQ:142 break;143 default:144 return -EINVAL;145 }146 147 pkt->hdr.size = sizeof(*pkt);148 pkt->hdr.pkt_type = HFI_CMD_SYS_TEST_SSR;149 pkt->trigger_type = trigger_type;150 151 return 0;152}153 154void pkt_sys_image_version(struct hfi_sys_get_property_pkt *pkt)155{156 pkt->hdr.size = sizeof(*pkt);157 pkt->hdr.pkt_type = HFI_CMD_SYS_GET_PROPERTY;158 pkt->num_properties = 1;159 pkt->data = HFI_PROPERTY_SYS_IMAGE_VERSION;160}161 162int pkt_session_init(struct hfi_session_init_pkt *pkt, void *cookie,163 u32 session_type, u32 codec)164{165 if (!pkt || !cookie || !codec)166 return -EINVAL;167 168 pkt->shdr.hdr.size = sizeof(*pkt);169 pkt->shdr.hdr.pkt_type = HFI_CMD_SYS_SESSION_INIT;170 pkt->shdr.session_id = hash32_ptr(cookie);171 pkt->session_domain = session_type;172 pkt->session_codec = codec;173 174 return 0;175}176 177void pkt_session_cmd(struct hfi_session_pkt *pkt, u32 pkt_type, void *cookie)178{179 pkt->shdr.hdr.size = sizeof(*pkt);180 pkt->shdr.hdr.pkt_type = pkt_type;181 pkt->shdr.session_id = hash32_ptr(cookie);182}183 184int pkt_session_set_buffers(struct hfi_session_set_buffers_pkt *pkt,185 void *cookie, struct hfi_buffer_desc *bd)186{187 unsigned int i;188 189 if (!cookie || !pkt || !bd)190 return -EINVAL;191 192 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_SET_BUFFERS;193 pkt->shdr.session_id = hash32_ptr(cookie);194 pkt->buffer_size = bd->buffer_size;195 pkt->min_buffer_size = bd->buffer_size;196 pkt->num_buffers = bd->num_buffers;197 198 if (bd->buffer_type == HFI_BUFFER_OUTPUT ||199 bd->buffer_type == HFI_BUFFER_OUTPUT2) {200 struct hfi_buffer_info *bi;201 202 pkt->extradata_size = bd->extradata_size;203 pkt->shdr.hdr.size = sizeof(*pkt) +204 bd->num_buffers * sizeof(*bi);205 bi = (struct hfi_buffer_info *)pkt->buffer_info;206 for (i = 0; i < pkt->num_buffers; i++) {207 bi->buffer_addr = bd->device_addr;208 bi->extradata_addr = bd->extradata_addr;209 }210 } else {211 pkt->extradata_size = 0;212 pkt->shdr.hdr.size = struct_size(pkt, buffer_info,213 bd->num_buffers);214 for (i = 0; i < pkt->num_buffers; i++)215 pkt->buffer_info[i] = bd->device_addr;216 }217 218 pkt->buffer_type = bd->buffer_type;219 220 return 0;221}222 223int pkt_session_unset_buffers(struct hfi_session_release_buffer_pkt *pkt,224 void *cookie, struct hfi_buffer_desc *bd)225{226 unsigned int i;227 228 if (!cookie || !pkt || !bd)229 return -EINVAL;230 231 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_RELEASE_BUFFERS;232 pkt->shdr.session_id = hash32_ptr(cookie);233 pkt->buffer_size = bd->buffer_size;234 pkt->num_buffers = bd->num_buffers;235 236 if (bd->buffer_type == HFI_BUFFER_OUTPUT ||237 bd->buffer_type == HFI_BUFFER_OUTPUT2) {238 struct hfi_buffer_info *bi;239 240 bi = (struct hfi_buffer_info *)pkt->buffer_info;241 for (i = 0; i < pkt->num_buffers; i++) {242 bi->buffer_addr = bd->device_addr;243 bi->extradata_addr = bd->extradata_addr;244 }245 pkt->shdr.hdr.size =246 sizeof(struct hfi_session_set_buffers_pkt) +247 bd->num_buffers * sizeof(*bi);248 } else {249 for (i = 0; i < pkt->num_buffers; i++)250 pkt->buffer_info[i] = bd->device_addr;251 252 pkt->extradata_size = 0;253 pkt->shdr.hdr.size =254 struct_size_t(struct hfi_session_set_buffers_pkt,255 buffer_info, bd->num_buffers);256 }257 258 pkt->response_req = bd->response_required;259 pkt->buffer_type = bd->buffer_type;260 261 return 0;262}263 264int pkt_session_etb_decoder(struct hfi_session_empty_buffer_compressed_pkt *pkt,265 void *cookie, struct hfi_frame_data *in_frame)266{267 if (!cookie)268 return -EINVAL;269 270 pkt->shdr.hdr.size = sizeof(*pkt);271 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_EMPTY_BUFFER;272 pkt->shdr.session_id = hash32_ptr(cookie);273 pkt->time_stamp_hi = upper_32_bits(in_frame->timestamp);274 pkt->time_stamp_lo = lower_32_bits(in_frame->timestamp);275 pkt->flags = in_frame->flags;276 pkt->mark_target = in_frame->mark_target;277 pkt->mark_data = in_frame->mark_data;278 pkt->offset = in_frame->offset;279 pkt->alloc_len = in_frame->alloc_len;280 pkt->filled_len = in_frame->filled_len;281 pkt->input_tag = in_frame->clnt_data;282 pkt->packet_buffer = in_frame->device_addr;283 284 return 0;285}286 287int pkt_session_etb_encoder(288 struct hfi_session_empty_buffer_uncompressed_plane0_pkt *pkt,289 void *cookie, struct hfi_frame_data *in_frame)290{291 if (!cookie || !in_frame->device_addr)292 return -EINVAL;293 294 pkt->shdr.hdr.size = sizeof(*pkt);295 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_EMPTY_BUFFER;296 pkt->shdr.session_id = hash32_ptr(cookie);297 pkt->view_id = 0;298 pkt->time_stamp_hi = upper_32_bits(in_frame->timestamp);299 pkt->time_stamp_lo = lower_32_bits(in_frame->timestamp);300 pkt->flags = in_frame->flags;301 pkt->mark_target = in_frame->mark_target;302 pkt->mark_data = in_frame->mark_data;303 pkt->offset = in_frame->offset;304 pkt->alloc_len = in_frame->alloc_len;305 pkt->filled_len = in_frame->filled_len;306 pkt->input_tag = in_frame->clnt_data;307 pkt->packet_buffer = in_frame->device_addr;308 pkt->extradata_buffer = in_frame->extradata_addr;309 310 return 0;311}312 313int pkt_session_ftb(struct hfi_session_fill_buffer_pkt *pkt, void *cookie,314 struct hfi_frame_data *out_frame)315{316 if (!cookie || !out_frame || !out_frame->device_addr)317 return -EINVAL;318 319 pkt->shdr.hdr.size = sizeof(*pkt);320 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_FILL_BUFFER;321 pkt->shdr.session_id = hash32_ptr(cookie);322 323 if (out_frame->buffer_type == HFI_BUFFER_OUTPUT)324 pkt->stream_id = 0;325 else if (out_frame->buffer_type == HFI_BUFFER_OUTPUT2)326 pkt->stream_id = 1;327 328 pkt->output_tag = out_frame->clnt_data;329 pkt->packet_buffer = out_frame->device_addr;330 pkt->extradata_buffer = out_frame->extradata_addr;331 pkt->alloc_len = out_frame->alloc_len;332 pkt->filled_len = out_frame->filled_len;333 pkt->offset = out_frame->offset;334 pkt->data = out_frame->extradata_size;335 336 return 0;337}338 339int pkt_session_parse_seq_header(340 struct hfi_session_parse_sequence_header_pkt *pkt,341 void *cookie, u32 seq_hdr, u32 seq_hdr_len)342{343 if (!cookie || !seq_hdr || !seq_hdr_len)344 return -EINVAL;345 346 pkt->shdr.hdr.size = sizeof(*pkt);347 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_PARSE_SEQUENCE_HEADER;348 pkt->shdr.session_id = hash32_ptr(cookie);349 pkt->header_len = seq_hdr_len;350 pkt->packet_buffer = seq_hdr;351 352 return 0;353}354 355int pkt_session_get_seq_hdr(struct hfi_session_get_sequence_header_pkt *pkt,356 void *cookie, u32 seq_hdr, u32 seq_hdr_len)357{358 if (!cookie || !seq_hdr || !seq_hdr_len)359 return -EINVAL;360 361 pkt->shdr.hdr.size = sizeof(*pkt);362 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_GET_SEQUENCE_HEADER;363 pkt->shdr.session_id = hash32_ptr(cookie);364 pkt->buffer_len = seq_hdr_len;365 pkt->packet_buffer = seq_hdr;366 367 return 0;368}369 370int pkt_session_flush(struct hfi_session_flush_pkt *pkt, void *cookie, u32 type)371{372 switch (type) {373 case HFI_FLUSH_INPUT:374 case HFI_FLUSH_OUTPUT:375 case HFI_FLUSH_OUTPUT2:376 case HFI_FLUSH_ALL:377 break;378 default:379 return -EINVAL;380 }381 382 pkt->shdr.hdr.size = sizeof(*pkt);383 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_FLUSH;384 pkt->shdr.session_id = hash32_ptr(cookie);385 pkt->flush_type = type;386 387 return 0;388}389 390static int pkt_session_get_property_1x(struct hfi_session_get_property_pkt *pkt,391 void *cookie, u32 ptype)392{393 switch (ptype) {394 case HFI_PROPERTY_PARAM_PROFILE_LEVEL_CURRENT:395 case HFI_PROPERTY_CONFIG_BUFFER_REQUIREMENTS:396 break;397 default:398 return -EINVAL;399 }400 401 pkt->shdr.hdr.size = sizeof(*pkt);402 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_GET_PROPERTY;403 pkt->shdr.session_id = hash32_ptr(cookie);404 pkt->num_properties = 1;405 pkt->data = ptype;406 407 return 0;408}409 410static int pkt_session_set_property_1x(struct hfi_session_set_property_pkt *pkt,411 void *cookie, u32 ptype, void *pdata)412{413 void *prop_data;414 int ret = 0;415 416 if (!pkt || !cookie || !pdata)417 return -EINVAL;418 419 prop_data = &pkt->data[1];420 421 pkt->shdr.hdr.size = sizeof(*pkt);422 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_SET_PROPERTY;423 pkt->shdr.session_id = hash32_ptr(cookie);424 pkt->num_properties = 1;425 pkt->data[0] = ptype;426 427 switch (ptype) {428 case HFI_PROPERTY_CONFIG_FRAME_RATE: {429 struct hfi_framerate *in = pdata, *frate = prop_data;430 431 frate->buffer_type = in->buffer_type;432 frate->framerate = in->framerate;433 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*frate);434 break;435 }436 case HFI_PROPERTY_PARAM_UNCOMPRESSED_FORMAT_SELECT: {437 struct hfi_uncompressed_format_select *in = pdata;438 struct hfi_uncompressed_format_select *hfi = prop_data;439 440 hfi->buffer_type = in->buffer_type;441 hfi->format = in->format;442 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*hfi);443 break;444 }445 case HFI_PROPERTY_PARAM_FRAME_SIZE: {446 struct hfi_framesize *in = pdata, *fsize = prop_data;447 448 fsize->buffer_type = in->buffer_type;449 fsize->height = in->height;450 fsize->width = in->width;451 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*fsize);452 break;453 }454 case HFI_PROPERTY_CONFIG_REALTIME: {455 struct hfi_enable *in = pdata, *en = prop_data;456 457 en->enable = in->enable;458 pkt->shdr.hdr.size += sizeof(u32) * 2;459 break;460 }461 case HFI_PROPERTY_PARAM_BUFFER_COUNT_ACTUAL: {462 struct hfi_buffer_count_actual *in = pdata, *count = prop_data;463 464 count->count_actual = in->count_actual;465 count->type = in->type;466 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*count);467 break;468 }469 case HFI_PROPERTY_PARAM_BUFFER_SIZE_ACTUAL: {470 struct hfi_buffer_size_actual *in = pdata, *sz = prop_data;471 472 sz->size = in->size;473 sz->type = in->type;474 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*sz);475 break;476 }477 case HFI_PROPERTY_PARAM_BUFFER_DISPLAY_HOLD_COUNT_ACTUAL: {478 struct hfi_buffer_display_hold_count_actual *in = pdata;479 struct hfi_buffer_display_hold_count_actual *count = prop_data;480 481 count->hold_count = in->hold_count;482 count->type = in->type;483 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*count);484 break;485 }486 case HFI_PROPERTY_PARAM_NAL_STREAM_FORMAT_SELECT: {487 struct hfi_nal_stream_format_select *in = pdata;488 struct hfi_nal_stream_format_select *fmt = prop_data;489 490 fmt->format = in->format;491 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*fmt);492 break;493 }494 case HFI_PROPERTY_PARAM_VDEC_OUTPUT_ORDER: {495 u32 *in = pdata;496 497 switch (*in) {498 case HFI_OUTPUT_ORDER_DECODE:499 case HFI_OUTPUT_ORDER_DISPLAY:500 break;501 default:502 ret = -EINVAL;503 break;504 }505 506 pkt->data[1] = *in;507 pkt->shdr.hdr.size += sizeof(u32) * 2;508 break;509 }510 case HFI_PROPERTY_PARAM_VDEC_PICTURE_TYPE_DECODE: {511 struct hfi_enable_picture *in = pdata, *en = prop_data;512 513 en->picture_type = in->picture_type;514 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);515 break;516 }517 case HFI_PROPERTY_PARAM_VDEC_OUTPUT2_KEEP_ASPECT_RATIO: {518 struct hfi_enable *in = pdata, *en = prop_data;519 520 en->enable = in->enable;521 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);522 break;523 }524 case HFI_PROPERTY_PARAM_VDEC_ENABLE_SUFFICIENT_SEQCHANGE_EVENT:525 case HFI_PROPERTY_CONFIG_VDEC_POST_LOOP_DEBLOCKER: {526 struct hfi_enable *in = pdata;527 struct hfi_enable *en = prop_data;528 529 en->enable = in->enable;530 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);531 break;532 }533 case HFI_PROPERTY_PARAM_VDEC_MULTI_STREAM: {534 struct hfi_multi_stream *in = pdata, *multi = prop_data;535 536 multi->buffer_type = in->buffer_type;537 multi->enable = in->enable;538 multi->width = in->width;539 multi->height = in->height;540 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*multi);541 break;542 }543 case HFI_PROPERTY_PARAM_VDEC_DISPLAY_PICTURE_BUFFER_COUNT: {544 struct hfi_display_picture_buffer_count *in = pdata;545 struct hfi_display_picture_buffer_count *count = prop_data;546 547 count->count = in->count;548 count->enable = in->enable;549 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*count);550 break;551 }552 case HFI_PROPERTY_PARAM_DIVX_FORMAT: {553 u32 *in = pdata;554 555 switch (*in) {556 case HFI_DIVX_FORMAT_4:557 case HFI_DIVX_FORMAT_5:558 case HFI_DIVX_FORMAT_6:559 break;560 default:561 ret = -EINVAL;562 break;563 }564 565 pkt->data[1] = *in;566 pkt->shdr.hdr.size += sizeof(u32) * 2;567 break;568 }569 case HFI_PROPERTY_CONFIG_VDEC_MB_ERROR_MAP_REPORTING: {570 struct hfi_enable *in = pdata, *en = prop_data;571 572 en->enable = in->enable;573 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);574 break;575 }576 case HFI_PROPERTY_PARAM_VDEC_CONTINUE_DATA_TRANSFER: {577 struct hfi_enable *in = pdata, *en = prop_data;578 579 en->enable = in->enable;580 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);581 break;582 }583 case HFI_PROPERTY_PARAM_VDEC_THUMBNAIL_MODE: {584 struct hfi_enable *in = pdata, *en = prop_data;585 586 en->enable = in->enable;587 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);588 break;589 }590 case HFI_PROPERTY_CONFIG_VENC_SYNC_FRAME_SEQUENCE_HEADER: {591 struct hfi_enable *in = pdata, *en = prop_data;592 593 en->enable = in->enable;594 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);595 break;596 }597 case HFI_PROPERTY_CONFIG_VENC_REQUEST_SYNC_FRAME:598 pkt->shdr.hdr.size += sizeof(u32);599 break;600 case HFI_PROPERTY_PARAM_VENC_MPEG4_SHORT_HEADER:601 break;602 case HFI_PROPERTY_PARAM_VENC_MPEG4_AC_PREDICTION:603 break;604 case HFI_PROPERTY_CONFIG_VENC_TARGET_BITRATE: {605 struct hfi_bitrate *in = pdata, *brate = prop_data;606 607 brate->bitrate = in->bitrate;608 brate->layer_id = in->layer_id;609 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*brate);610 break;611 }612 case HFI_PROPERTY_CONFIG_VENC_MAX_BITRATE: {613 struct hfi_bitrate *in = pdata, *hfi = prop_data;614 615 hfi->bitrate = in->bitrate;616 hfi->layer_id = in->layer_id;617 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*hfi);618 break;619 }620 case HFI_PROPERTY_PARAM_PROFILE_LEVEL_CURRENT: {621 struct hfi_profile_level *in = pdata, *pl = prop_data;622 623 pl->level = in->level;624 pl->profile = in->profile;625 if (pl->profile <= 0)626 /* Profile not supported, falling back to high */627 pl->profile = HFI_H264_PROFILE_HIGH;628 629 if (!pl->level)630 /* Level not supported, falling back to 1 */631 pl->level = 1;632 633 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*pl);634 break;635 }636 case HFI_PROPERTY_PARAM_VENC_H264_ENTROPY_CONTROL: {637 struct hfi_h264_entropy_control *in = pdata, *hfi = prop_data;638 639 hfi->entropy_mode = in->entropy_mode;640 if (hfi->entropy_mode == HFI_H264_ENTROPY_CABAC)641 hfi->cabac_model = in->cabac_model;642 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*hfi);643 break;644 }645 case HFI_PROPERTY_PARAM_VENC_RATE_CONTROL: {646 u32 *in = pdata;647 648 switch (*in) {649 case HFI_RATE_CONTROL_OFF:650 case HFI_RATE_CONTROL_CBR_CFR:651 case HFI_RATE_CONTROL_CBR_VFR:652 case HFI_RATE_CONTROL_VBR_CFR:653 case HFI_RATE_CONTROL_VBR_VFR:654 case HFI_RATE_CONTROL_CQ:655 break;656 default:657 ret = -EINVAL;658 break;659 }660 661 pkt->data[1] = *in;662 pkt->shdr.hdr.size += sizeof(u32) * 2;663 break;664 }665 case HFI_PROPERTY_PARAM_VENC_MPEG4_TIME_RESOLUTION: {666 struct hfi_mpeg4_time_resolution *in = pdata, *res = prop_data;667 668 res->time_increment_resolution = in->time_increment_resolution;669 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*res);670 break;671 }672 case HFI_PROPERTY_PARAM_VENC_MPEG4_HEADER_EXTENSION: {673 struct hfi_mpeg4_header_extension *in = pdata, *ext = prop_data;674 675 ext->header_extension = in->header_extension;676 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*ext);677 break;678 }679 case HFI_PROPERTY_PARAM_VENC_H264_DEBLOCK_CONTROL: {680 struct hfi_h264_db_control *in = pdata, *db = prop_data;681 682 switch (in->mode) {683 case HFI_H264_DB_MODE_DISABLE:684 case HFI_H264_DB_MODE_SKIP_SLICE_BOUNDARY:685 case HFI_H264_DB_MODE_ALL_BOUNDARY:686 break;687 default:688 ret = -EINVAL;689 break;690 }691 692 db->mode = in->mode;693 db->slice_alpha_offset = in->slice_alpha_offset;694 db->slice_beta_offset = in->slice_beta_offset;695 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*db);696 break;697 }698 case HFI_PROPERTY_PARAM_VENC_SESSION_QP: {699 struct hfi_quantization *in = pdata, *quant = prop_data;700 701 quant->qp_i = in->qp_i;702 quant->qp_p = in->qp_p;703 quant->qp_b = in->qp_b;704 quant->layer_id = in->layer_id;705 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*quant);706 break;707 }708 case HFI_PROPERTY_PARAM_VENC_SESSION_QP_RANGE: {709 struct hfi_quantization_range *in = pdata, *range = prop_data;710 u32 min_qp, max_qp;711 712 min_qp = in->min_qp;713 max_qp = in->max_qp;714 715 /* We'll be packing in the qp, so make sure we716 * won't be losing data when masking717 */718 if (min_qp > 0xff || max_qp > 0xff) {719 ret = -ERANGE;720 break;721 }722 723 /* When creating the packet, pack the qp value as724 * 0xiippbb, where ii = qp range for I-frames,725 * pp = qp range for P-frames, etc.726 */727 range->min_qp = min_qp | min_qp << 8 | min_qp << 16;728 range->max_qp = max_qp | max_qp << 8 | max_qp << 16;729 range->layer_id = in->layer_id;730 731 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*range);732 break;733 }734 case HFI_PROPERTY_PARAM_VENC_VC1_PERF_CFG: {735 struct hfi_vc1e_perf_cfg_type *in = pdata, *perf = prop_data;736 737 memcpy(perf->search_range_x_subsampled,738 in->search_range_x_subsampled,739 sizeof(perf->search_range_x_subsampled));740 memcpy(perf->search_range_y_subsampled,741 in->search_range_y_subsampled,742 sizeof(perf->search_range_y_subsampled));743 744 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*perf);745 break;746 }747 case HFI_PROPERTY_PARAM_VENC_MAX_NUM_B_FRAMES: {748 struct hfi_max_num_b_frames *bframes = prop_data;749 u32 *in = pdata;750 751 bframes->max_num_b_frames = *in;752 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*bframes);753 break;754 }755 case HFI_PROPERTY_CONFIG_VENC_INTRA_PERIOD: {756 struct hfi_intra_period *in = pdata, *intra = prop_data;757 758 intra->pframes = in->pframes;759 intra->bframes = in->bframes;760 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*intra);761 break;762 }763 case HFI_PROPERTY_CONFIG_VENC_IDR_PERIOD: {764 struct hfi_idr_period *in = pdata, *idr = prop_data;765 766 idr->idr_period = in->idr_period;767 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*idr);768 break;769 }770 case HFI_PROPERTY_PARAM_VDEC_CONCEAL_COLOR: {771 struct hfi_conceal_color *color = prop_data;772 u32 *in = pdata;773 774 color->conceal_color = *in & 0xff;775 color->conceal_color |= ((*in >> 10) & 0xff) << 8;776 color->conceal_color |= ((*in >> 20) & 0xff) << 16;777 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*color);778 break;779 }780 case HFI_PROPERTY_CONFIG_VPE_OPERATIONS: {781 struct hfi_operations_type *in = pdata, *ops = prop_data;782 783 switch (in->rotation) {784 case HFI_ROTATE_NONE:785 case HFI_ROTATE_90:786 case HFI_ROTATE_180:787 case HFI_ROTATE_270:788 break;789 default:790 ret = -EINVAL;791 break;792 }793 794 switch (in->flip) {795 case HFI_FLIP_NONE:796 case HFI_FLIP_HORIZONTAL:797 case HFI_FLIP_VERTICAL:798 break;799 default:800 ret = -EINVAL;801 break;802 }803 804 ops->rotation = in->rotation;805 ops->flip = in->flip;806 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*ops);807 break;808 }809 case HFI_PROPERTY_PARAM_VENC_INTRA_REFRESH: {810 struct hfi_intra_refresh *in = pdata, *intra = prop_data;811 812 switch (in->mode) {813 case HFI_INTRA_REFRESH_NONE:814 case HFI_INTRA_REFRESH_ADAPTIVE:815 case HFI_INTRA_REFRESH_CYCLIC:816 case HFI_INTRA_REFRESH_CYCLIC_ADAPTIVE:817 case HFI_INTRA_REFRESH_RANDOM:818 break;819 default:820 ret = -EINVAL;821 break;822 }823 824 intra->mode = in->mode;825 intra->air_mbs = in->air_mbs;826 intra->air_ref = in->air_ref;827 intra->cir_mbs = in->cir_mbs;828 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*intra);829 break;830 }831 case HFI_PROPERTY_PARAM_VENC_MULTI_SLICE_CONTROL: {832 struct hfi_multi_slice_control *in = pdata, *multi = prop_data;833 834 switch (in->multi_slice) {835 case HFI_MULTI_SLICE_OFF:836 case HFI_MULTI_SLICE_GOB:837 case HFI_MULTI_SLICE_BY_MB_COUNT:838 case HFI_MULTI_SLICE_BY_BYTE_COUNT:839 break;840 default:841 ret = -EINVAL;842 break;843 }844 845 multi->multi_slice = in->multi_slice;846 multi->slice_size = in->slice_size;847 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*multi);848 break;849 }850 case HFI_PROPERTY_PARAM_VENC_SLICE_DELIVERY_MODE: {851 struct hfi_enable *in = pdata, *en = prop_data;852 853 en->enable = in->enable;854 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);855 break;856 }857 case HFI_PROPERTY_PARAM_VENC_H264_VUI_TIMING_INFO: {858 struct hfi_h264_vui_timing_info *in = pdata, *vui = prop_data;859 860 vui->enable = in->enable;861 vui->fixed_framerate = in->fixed_framerate;862 vui->time_scale = in->time_scale;863 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*vui);864 break;865 }866 case HFI_PROPERTY_CONFIG_VPE_DEINTERLACE: {867 struct hfi_enable *in = pdata, *en = prop_data;868 869 en->enable = in->enable;870 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);871 break;872 }873 case HFI_PROPERTY_PARAM_VENC_H264_GENERATE_AUDNAL: {874 struct hfi_enable *in = pdata, *en = prop_data;875 876 en->enable = in->enable;877 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);878 break;879 }880 case HFI_PROPERTY_PARAM_BUFFER_ALLOC_MODE: {881 struct hfi_buffer_alloc_mode *in = pdata, *mode = prop_data;882 883 mode->type = in->type;884 mode->mode = in->mode;885 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*mode);886 break;887 }888 case HFI_PROPERTY_PARAM_VDEC_FRAME_ASSEMBLY: {889 struct hfi_enable *in = pdata, *en = prop_data;890 891 en->enable = in->enable;892 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);893 break;894 }895 case HFI_PROPERTY_PARAM_VENC_H264_VUI_BITSTREAM_RESTRC: {896 struct hfi_enable *in = pdata, *en = prop_data;897 898 en->enable = in->enable;899 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);900 break;901 }902 case HFI_PROPERTY_PARAM_VENC_PRESERVE_TEXT_QUALITY: {903 struct hfi_enable *in = pdata, *en = prop_data;904 905 en->enable = in->enable;906 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);907 break;908 }909 case HFI_PROPERTY_PARAM_VDEC_SCS_THRESHOLD: {910 struct hfi_scs_threshold *thres = prop_data;911 u32 *in = pdata;912 913 thres->threshold_value = *in;914 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*thres);915 break;916 }917 case HFI_PROPERTY_PARAM_MVC_BUFFER_LAYOUT: {918 struct hfi_mvc_buffer_layout_descp_type *in = pdata;919 struct hfi_mvc_buffer_layout_descp_type *mvc = prop_data;920 921 switch (in->layout_type) {922 case HFI_MVC_BUFFER_LAYOUT_TOP_BOTTOM:923 case HFI_MVC_BUFFER_LAYOUT_SEQ:924 break;925 default:926 ret = -EINVAL;927 break;928 }929 930 mvc->layout_type = in->layout_type;931 mvc->bright_view_first = in->bright_view_first;932 mvc->ngap = in->ngap;933 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*mvc);934 break;935 }936 case HFI_PROPERTY_PARAM_VENC_LTRMODE: {937 struct hfi_ltr_mode *in = pdata, *ltr = prop_data;938 939 switch (in->ltr_mode) {940 case HFI_LTR_MODE_DISABLE:941 case HFI_LTR_MODE_MANUAL:942 case HFI_LTR_MODE_PERIODIC:943 break;944 default:945 ret = -EINVAL;946 break;947 }948 949 ltr->ltr_mode = in->ltr_mode;950 ltr->ltr_count = in->ltr_count;951 ltr->trust_mode = in->trust_mode;952 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*ltr);953 break;954 }955 case HFI_PROPERTY_CONFIG_VENC_USELTRFRAME: {956 struct hfi_ltr_use *in = pdata, *ltr_use = prop_data;957 958 ltr_use->frames = in->frames;959 ltr_use->ref_ltr = in->ref_ltr;960 ltr_use->use_constrnt = in->use_constrnt;961 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*ltr_use);962 break;963 }964 case HFI_PROPERTY_CONFIG_VENC_MARKLTRFRAME: {965 struct hfi_ltr_mark *in = pdata, *ltr_mark = prop_data;966 967 ltr_mark->mark_frame = in->mark_frame;968 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*ltr_mark);969 break;970 }971 case HFI_PROPERTY_PARAM_VENC_HIER_P_MAX_NUM_ENH_LAYER: {972 u32 *in = pdata;973 974 pkt->data[1] = *in;975 pkt->shdr.hdr.size += sizeof(u32) * 2;976 break;977 }978 case HFI_PROPERTY_CONFIG_VENC_HIER_P_ENH_LAYER: {979 u32 *in = pdata;980 981 pkt->data[1] = *in;982 pkt->shdr.hdr.size += sizeof(u32) * 2;983 break;984 }985 case HFI_PROPERTY_PARAM_VENC_DISABLE_RC_TIMESTAMP: {986 struct hfi_enable *in = pdata, *en = prop_data;987 988 en->enable = in->enable;989 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);990 break;991 }992 case HFI_PROPERTY_PARAM_VENC_INITIAL_QP: {993 struct hfi_initial_quantization *in = pdata, *quant = prop_data;994 995 quant->init_qp_enable = in->init_qp_enable;996 quant->qp_i = in->qp_i;997 quant->qp_p = in->qp_p;998 quant->qp_b = in->qp_b;999 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*quant);1000 break;1001 }1002 case HFI_PROPERTY_PARAM_VPE_COLOR_SPACE_CONVERSION: {1003 struct hfi_vpe_color_space_conversion *in = pdata;1004 struct hfi_vpe_color_space_conversion *csc = prop_data;1005 1006 memcpy(csc->csc_matrix, in->csc_matrix,1007 sizeof(csc->csc_matrix));1008 memcpy(csc->csc_bias, in->csc_bias, sizeof(csc->csc_bias));1009 memcpy(csc->csc_limit, in->csc_limit, sizeof(csc->csc_limit));1010 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*csc);1011 break;1012 }1013 case HFI_PROPERTY_PARAM_VENC_VPX_ERROR_RESILIENCE_MODE: {1014 struct hfi_enable *in = pdata, *en = prop_data;1015 1016 en->enable = in->enable;1017 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);1018 break;1019 }1020 case HFI_PROPERTY_PARAM_VENC_H264_NAL_SVC_EXT: {1021 struct hfi_enable *in = pdata, *en = prop_data;1022 1023 en->enable = in->enable;1024 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);1025 break;1026 }1027 case HFI_PROPERTY_CONFIG_VENC_PERF_MODE: {1028 u32 *in = pdata;1029 1030 pkt->data[1] = *in;1031 pkt->shdr.hdr.size += sizeof(u32) * 2;1032 break;1033 }1034 case HFI_PROPERTY_PARAM_VENC_HIER_B_MAX_NUM_ENH_LAYER: {1035 u32 *in = pdata;1036 1037 pkt->data[1] = *in;1038 pkt->shdr.hdr.size += sizeof(u32) * 2;1039 break;1040 }1041 case HFI_PROPERTY_PARAM_VDEC_NONCP_OUTPUT2: {1042 struct hfi_enable *in = pdata, *en = prop_data;1043 1044 en->enable = in->enable;1045 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);1046 break;1047 }1048 case HFI_PROPERTY_PARAM_VENC_HIER_P_HYBRID_MODE: {1049 struct hfi_hybrid_hierp *in = pdata, *hierp = prop_data;1050 1051 hierp->layers = in->layers;1052 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*hierp);1053 break;1054 }1055 case HFI_PROPERTY_PARAM_UNCOMPRESSED_PLANE_ACTUAL_INFO: {1056 struct hfi_uncompressed_plane_actual_info *in = pdata;1057 struct hfi_uncompressed_plane_actual_info *info = prop_data;1058 1059 info->buffer_type = in->buffer_type;1060 info->num_planes = in->num_planes;1061 info->plane_format[0] = in->plane_format[0];1062 if (in->num_planes > 1)1063 info->plane_format[1] = in->plane_format[1];1064 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*info);1065 break;1066 }1067 case HFI_PROPERTY_PARAM_VENC_HDR10_PQ_SEI:1068 return -ENOTSUPP;1069 1070 /* FOLLOWING PROPERTIES ARE NOT IMPLEMENTED IN CORE YET */1071 case HFI_PROPERTY_CONFIG_BUFFER_REQUIREMENTS:1072 case HFI_PROPERTY_CONFIG_PRIORITY:1073 case HFI_PROPERTY_CONFIG_BATCH_INFO:1074 case HFI_PROPERTY_SYS_IDLE_INDICATOR:1075 case HFI_PROPERTY_PARAM_UNCOMPRESSED_FORMAT_SUPPORTED:1076 case HFI_PROPERTY_PARAM_INTERLACE_FORMAT_SUPPORTED:1077 case HFI_PROPERTY_PARAM_CHROMA_SITE:1078 case HFI_PROPERTY_PARAM_PROPERTIES_SUPPORTED:1079 case HFI_PROPERTY_PARAM_PROFILE_LEVEL_SUPPORTED:1080 case HFI_PROPERTY_PARAM_CAPABILITY_SUPPORTED:1081 case HFI_PROPERTY_PARAM_NAL_STREAM_FORMAT_SUPPORTED:1082 case HFI_PROPERTY_PARAM_MULTI_VIEW_FORMAT:1083 case HFI_PROPERTY_PARAM_MAX_SEQUENCE_HEADER_SIZE:1084 case HFI_PROPERTY_PARAM_CODEC_SUPPORTED:1085 case HFI_PROPERTY_PARAM_VDEC_MULTI_VIEW_SELECT:1086 case HFI_PROPERTY_PARAM_VDEC_MB_QUANTIZATION:1087 case HFI_PROPERTY_PARAM_VDEC_NUM_CONCEALED_MB:1088 case HFI_PROPERTY_PARAM_VDEC_H264_ENTROPY_SWITCHING:1089 case HFI_PROPERTY_PARAM_VENC_MULTI_SLICE_INFO:1090 default:1091 return -EINVAL;1092 }1093 1094 return ret;1095}1096 1097static int1098pkt_session_get_property_3xx(struct hfi_session_get_property_pkt *pkt,1099 void *cookie, u32 ptype)1100{1101 int ret = 0;1102 1103 if (!pkt || !cookie)1104 return -EINVAL;1105 1106 pkt->shdr.hdr.size = sizeof(struct hfi_session_get_property_pkt);1107 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_GET_PROPERTY;1108 pkt->shdr.session_id = hash32_ptr(cookie);1109 pkt->num_properties = 1;1110 1111 switch (ptype) {1112 case HFI_PROPERTY_CONFIG_VDEC_ENTROPY:1113 pkt->data = HFI_PROPERTY_CONFIG_VDEC_ENTROPY;1114 break;1115 default:1116 ret = pkt_session_get_property_1x(pkt, cookie, ptype);1117 break;1118 }1119 1120 return ret;1121}1122 1123static int1124pkt_session_set_property_3xx(struct hfi_session_set_property_pkt *pkt,1125 void *cookie, u32 ptype, void *pdata)1126{1127 void *prop_data;1128 int ret = 0;1129 1130 if (!pkt || !cookie || !pdata)1131 return -EINVAL;1132 1133 prop_data = &pkt->data[1];1134 1135 pkt->shdr.hdr.size = sizeof(*pkt);1136 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_SET_PROPERTY;1137 pkt->shdr.session_id = hash32_ptr(cookie);1138 pkt->num_properties = 1;1139 pkt->data[0] = ptype;1140 1141 /*1142 * Any session set property which is different in 3XX packetization1143 * should be added as a new case below. All unchanged session set1144 * properties will be handled in the default case.1145 */1146 switch (ptype) {1147 case HFI_PROPERTY_PARAM_VDEC_MULTI_STREAM: {1148 struct hfi_multi_stream *in = pdata;1149 struct hfi_multi_stream_3x *multi = prop_data;1150 1151 multi->buffer_type = in->buffer_type;1152 multi->enable = in->enable;1153 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*multi);1154 break;1155 }1156 case HFI_PROPERTY_PARAM_VENC_INTRA_REFRESH: {1157 struct hfi_intra_refresh *in = pdata;1158 struct hfi_intra_refresh_3x *intra = prop_data;1159 1160 switch (in->mode) {1161 case HFI_INTRA_REFRESH_NONE:1162 case HFI_INTRA_REFRESH_ADAPTIVE:1163 case HFI_INTRA_REFRESH_CYCLIC:1164 case HFI_INTRA_REFRESH_CYCLIC_ADAPTIVE:1165 case HFI_INTRA_REFRESH_RANDOM:1166 break;1167 default:1168 ret = -EINVAL;1169 break;1170 }1171 1172 intra->mode = in->mode;1173 intra->mbs = in->cir_mbs;1174 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*intra);1175 break;1176 }1177 case HFI_PROPERTY_PARAM_VDEC_CONTINUE_DATA_TRANSFER:1178 /* for 3xx fw version session_continue is used */1179 break;1180 default:1181 ret = pkt_session_set_property_1x(pkt, cookie, ptype, pdata);1182 break;1183 }1184 1185 return ret;1186}1187 1188static int1189pkt_session_set_property_4xx(struct hfi_session_set_property_pkt *pkt,1190 void *cookie, u32 ptype, void *pdata)1191{1192 void *prop_data;1193 1194 if (!pkt || !cookie || !pdata)1195 return -EINVAL;1196 1197 prop_data = &pkt->data[1];1198 1199 pkt->shdr.hdr.size = sizeof(*pkt);1200 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_SET_PROPERTY;1201 pkt->shdr.session_id = hash32_ptr(cookie);1202 pkt->num_properties = 1;1203 pkt->data[0] = ptype;1204 1205 /*1206 * Any session set property which is different in 3XX packetization1207 * should be added as a new case below. All unchanged session set1208 * properties will be handled in the default case.1209 */1210 switch (ptype) {1211 case HFI_PROPERTY_PARAM_BUFFER_COUNT_ACTUAL: {1212 struct hfi_buffer_count_actual *in = pdata;1213 struct hfi_buffer_count_actual_4xx *count = prop_data;1214 1215 count->count_actual = in->count_actual;1216 count->type = in->type;1217 count->count_min_host = in->count_actual;1218 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*count);1219 break;1220 }1221 case HFI_PROPERTY_PARAM_WORK_MODE: {1222 struct hfi_video_work_mode *in = pdata, *wm = prop_data;1223 1224 wm->video_work_mode = in->video_work_mode;1225 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*wm);1226 break;1227 }1228 case HFI_PROPERTY_CONFIG_VIDEOCORES_USAGE: {1229 struct hfi_videocores_usage_type *in = pdata, *cu = prop_data;1230 1231 cu->video_core_enable_mask = in->video_core_enable_mask;1232 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*cu);1233 break;1234 }1235 case HFI_PROPERTY_PARAM_VENC_HDR10_PQ_SEI: {1236 struct hfi_hdr10_pq_sei *in = pdata, *hdr10 = prop_data;1237 1238 memcpy(hdr10, in, sizeof(*hdr10));1239 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*hdr10);1240 break;1241 }1242 case HFI_PROPERTY_PARAM_VDEC_CONCEAL_COLOR: {1243 struct hfi_conceal_color_v4 *color = prop_data;1244 u32 *in = pdata;1245 1246 color->conceal_color_8bit = *in & 0xff;1247 color->conceal_color_8bit |= ((*in >> 10) & 0xff) << 8;1248 color->conceal_color_8bit |= ((*in >> 20) & 0xff) << 16;1249 color->conceal_color_10bit = *in;1250 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*color);1251 break;1252 }1253 1254 case HFI_PROPERTY_PARAM_VENC_H264_TRANSFORM_8X8: {1255 struct hfi_h264_8x8_transform *in = pdata, *tm = prop_data;1256 1257 tm->enable_type = in->enable_type;1258 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*tm);1259 break;1260 }1261 case HFI_PROPERTY_PARAM_VENC_SESSION_QP_RANGE_V2: {1262 struct hfi_quantization_range_v2 *in = pdata, *range = prop_data;1263 u32 min_qp, max_qp;1264 1265 min_qp = in->min_qp.qp_packed;1266 max_qp = in->max_qp.qp_packed;1267 1268 /* We'll be packing in the qp, so make sure we1269 * won't be losing data when masking1270 */1271 if (min_qp > 0xff || max_qp > 0xff)1272 return -ERANGE;1273 1274 range->min_qp.layer_id = 0xFF;1275 range->max_qp.layer_id = 0xFF;1276 range->min_qp.qp_packed = (min_qp & 0xFF) | ((min_qp & 0xFF) << 8) |1277 ((min_qp & 0xFF) << 16);1278 range->max_qp.qp_packed = (max_qp & 0xFF) | ((max_qp & 0xFF) << 8) |1279 ((max_qp & 0xFF) << 16);1280 range->min_qp.enable = 7;1281 range->max_qp.enable = 7;1282 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*range);1283 break;1284 }1285 case HFI_PROPERTY_CONFIG_VENC_MAX_BITRATE:1286 case HFI_PROPERTY_CONFIG_VDEC_POST_LOOP_DEBLOCKER:1287 case HFI_PROPERTY_PARAM_BUFFER_ALLOC_MODE:1288 case HFI_PROPERTY_PARAM_VENC_SESSION_QP:1289 case HFI_PROPERTY_PARAM_VENC_SESSION_QP_RANGE:1290 /* not implemented on Venus 4xx */1291 return -ENOTSUPP;1292 default:1293 return pkt_session_set_property_3xx(pkt, cookie, ptype, pdata);1294 }1295 1296 return 0;1297}1298 1299static int1300pkt_session_set_property_6xx(struct hfi_session_set_property_pkt *pkt,1301 void *cookie, u32 ptype, void *pdata)1302{1303 void *prop_data;1304 1305 if (!pkt || !cookie || !pdata)1306 return -EINVAL;1307 1308 prop_data = &pkt->data[1];1309 1310 pkt->shdr.hdr.size = sizeof(*pkt);1311 pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_SET_PROPERTY;1312 pkt->shdr.session_id = hash32_ptr(cookie);1313 pkt->num_properties = 1;1314 pkt->data[0] = ptype;1315 1316 switch (ptype) {1317 case HFI_PROPERTY_PARAM_UNCOMPRESSED_PLANE_ACTUAL_CONSTRAINTS_INFO: {1318 struct hfi_uncompressed_plane_actual_constraints_info *in = pdata;1319 struct hfi_uncompressed_plane_actual_constraints_info *info = prop_data;1320 1321 info->buffer_type = in->buffer_type;1322 info->num_planes = in->num_planes;1323 info->plane_format[0] = in->plane_format[0];1324 if (in->num_planes > 1)1325 info->plane_format[1] = in->plane_format[1];1326 1327 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*info);1328 break;1329 }1330 case HFI_PROPERTY_CONFIG_HEIC_FRAME_QUALITY: {1331 struct hfi_heic_frame_quality *in = pdata, *cq = prop_data;1332 1333 cq->frame_quality = in->frame_quality;1334 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*cq);1335 break;1336 }1337 case HFI_PROPERTY_PARAM_WORK_ROUTE: {1338 struct hfi_video_work_route *in = pdata, *wr = prop_data;1339 1340 wr->video_work_route = in->video_work_route;1341 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*wr);1342 break;1343 }1344 default:1345 return pkt_session_set_property_4xx(pkt, cookie, ptype, pdata);1346 }1347 1348 return 0;1349}1350 1351int pkt_session_get_property(struct hfi_session_get_property_pkt *pkt,1352 void *cookie, u32 ptype)1353{1354 if (hfi_ver == HFI_VERSION_1XX)1355 return pkt_session_get_property_1x(pkt, cookie, ptype);1356 1357 return pkt_session_get_property_3xx(pkt, cookie, ptype);1358}1359 1360int pkt_session_set_property(struct hfi_session_set_property_pkt *pkt,1361 void *cookie, u32 ptype, void *pdata)1362{1363 if (hfi_ver == HFI_VERSION_1XX)1364 return pkt_session_set_property_1x(pkt, cookie, ptype, pdata);1365 1366 if (hfi_ver == HFI_VERSION_3XX)1367 return pkt_session_set_property_3xx(pkt, cookie, ptype, pdata);1368 1369 if (hfi_ver == HFI_VERSION_4XX)1370 return pkt_session_set_property_4xx(pkt, cookie, ptype, pdata);1371 1372 return pkt_session_set_property_6xx(pkt, cookie, ptype, pdata);1373}1374 1375void pkt_set_version(enum hfi_version version)1376{1377 hfi_ver = version;1378}1379