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