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