drivers/media/platform/qcom/venus/hfi_cmds.c

   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 void 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
  70 int 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) - sizeof(u32);
  87                 break;
  88         }
  89         case VIDC_RESOURCE_NONE:
  90         default:
  91                 return -ENOTSUPP;
  92         }
  93
  94         return 0;
  95 }
  96
  97 int 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
 118 void 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
 125 void 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
 136 int 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
 154 void 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[0] = HFI_PROPERTY_SYS_IMAGE_VERSION;
 160 }
 161
 162 int 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
 177 void 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
 184 int 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) - sizeof(u32) +
 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 = sizeof(*pkt) +
 213                         ((bd->num_buffers - 1) * sizeof(u32));
 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
 223 int 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                                 sizeof(u32) + (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                                 sizeof(struct hfi_session_set_buffers_pkt) +
 255                                 ((bd->num_buffers - 1) * sizeof(u32));
 256         }
 257
 258         pkt->response_req = bd->response_required;
 259         pkt->buffer_type = bd->buffer_type;
 260
 261         return 0;
 262 }
 263
 264 int 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
 287 int 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
 313 int 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[0] = out_frame->extradata_size;
 335
 336         return 0;
 337 }
 338
 339 int 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
 355 int 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
 370 int 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
 390 static 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[0] = ptype;
 406
 407         return 0;
 408 }
 409
 410 static 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_CONFIG_VDEC_POST_LOOP_DEBLOCKER: {
 525                 struct hfi_enable *in = pdata;
 526                 struct hfi_enable *en = prop_data;
 527
 528                 en->enable = in->enable;
 529                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
 530                 break;
 531         }
 532         case HFI_PROPERTY_PARAM_VDEC_MULTI_STREAM: {
 533                 struct hfi_multi_stream *in = pdata, *multi = prop_data;
 534
 535                 multi->buffer_type = in->buffer_type;
 536                 multi->enable = in->enable;
 537                 multi->width = in->width;
 538                 multi->height = in->height;
 539                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*multi);
 540                 break;
 541         }
 542         case HFI_PROPERTY_PARAM_VDEC_DISPLAY_PICTURE_BUFFER_COUNT: {
 543                 struct hfi_display_picture_buffer_count *in = pdata;
 544                 struct hfi_display_picture_buffer_count *count = prop_data;
 545
 546                 count->count = in->count;
 547                 count->enable = in->enable;
 548                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*count);
 549                 break;
 550         }
 551         case HFI_PROPERTY_PARAM_DIVX_FORMAT: {
 552                 u32 *in = pdata;
 553
 554                 switch (*in) {
 555                 case HFI_DIVX_FORMAT_4:
 556                 case HFI_DIVX_FORMAT_5:
 557                 case HFI_DIVX_FORMAT_6:
 558                         break;
 559                 default:
 560                         ret = -EINVAL;
 561                         break;
 562                 }
 563
 564                 pkt->data[1] = *in;
 565                 pkt->shdr.hdr.size += sizeof(u32) * 2;
 566                 break;
 567         }
 568         case HFI_PROPERTY_CONFIG_VDEC_MB_ERROR_MAP_REPORTING: {
 569                 struct hfi_enable *in = pdata, *en = prop_data;
 570
 571                 en->enable = in->enable;
 572                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
 573                 break;
 574         }
 575         case HFI_PROPERTY_PARAM_VDEC_CONTINUE_DATA_TRANSFER: {
 576                 struct hfi_enable *in = pdata, *en = prop_data;
 577
 578                 en->enable = in->enable;
 579                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
 580                 break;
 581         }
 582         case HFI_PROPERTY_PARAM_VDEC_THUMBNAIL_MODE: {
 583                 struct hfi_enable *in = pdata, *en = prop_data;
 584
 585                 en->enable = in->enable;
 586                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
 587                 break;
 588         }
 589         case HFI_PROPERTY_CONFIG_VENC_SYNC_FRAME_SEQUENCE_HEADER: {
 590                 struct hfi_enable *in = pdata, *en = prop_data;
 591
 592                 en->enable = in->enable;
 593                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
 594                 break;
 595         }
 596         case HFI_PROPERTY_CONFIG_VENC_REQUEST_SYNC_FRAME:
 597                 pkt->shdr.hdr.size += sizeof(u32);
 598                 break;
 599         case HFI_PROPERTY_PARAM_VENC_MPEG4_SHORT_HEADER:
 600                 break;
 601         case HFI_PROPERTY_PARAM_VENC_MPEG4_AC_PREDICTION:
 602                 break;
 603         case HFI_PROPERTY_CONFIG_VENC_TARGET_BITRATE: {
 604                 struct hfi_bitrate *in = pdata, *brate = prop_data;
 605
 606                 brate->bitrate = in->bitrate;
 607                 brate->layer_id = in->layer_id;
 608                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*brate);
 609                 break;
 610         }
 611         case HFI_PROPERTY_CONFIG_VENC_MAX_BITRATE: {
 612                 struct hfi_bitrate *in = pdata, *hfi = prop_data;
 613
 614                 hfi->bitrate = in->bitrate;
 615                 hfi->layer_id = in->layer_id;
 616                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*hfi);
 617                 break;
 618         }
 619         case HFI_PROPERTY_PARAM_PROFILE_LEVEL_CURRENT: {
 620                 struct hfi_profile_level *in = pdata, *pl = prop_data;
 621
 622                 pl->level = in->level;
 623                 pl->profile = in->profile;
 624                 if (pl->profile <= 0)
 625                         /* Profile not supported, falling back to high */
 626                         pl->profile = HFI_H264_PROFILE_HIGH;
 627
 628                 if (!pl->level)
 629                         /* Level not supported, falling back to 1 */
 630                         pl->level = 1;
 631
 632                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*pl);
 633                 break;
 634         }
 635         case HFI_PROPERTY_PARAM_VENC_H264_ENTROPY_CONTROL: {
 636                 struct hfi_h264_entropy_control *in = pdata, *hfi = prop_data;
 637
 638                 hfi->entropy_mode = in->entropy_mode;
 639                 if (hfi->entropy_mode == HFI_H264_ENTROPY_CABAC)
 640                         hfi->cabac_model = in->cabac_model;
 641                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*hfi);
 642                 break;
 643         }
 644         case HFI_PROPERTY_PARAM_VENC_RATE_CONTROL: {
 645                 u32 *in = pdata;
 646
 647                 switch (*in) {
 648                 case HFI_RATE_CONTROL_OFF:
 649                 case HFI_RATE_CONTROL_CBR_CFR:
 650                 case HFI_RATE_CONTROL_CBR_VFR:
 651                 case HFI_RATE_CONTROL_VBR_CFR:
 652                 case HFI_RATE_CONTROL_VBR_VFR:
 653                 case HFI_RATE_CONTROL_CQ:
 654                         break;
 655                 default:
 656                         ret = -EINVAL;
 657                         break;
 658                 }
 659
 660                 pkt->data[1] = *in;
 661                 pkt->shdr.hdr.size += sizeof(u32) * 2;
 662                 break;
 663         }
 664         case HFI_PROPERTY_PARAM_VENC_MPEG4_TIME_RESOLUTION: {
 665                 struct hfi_mpeg4_time_resolution *in = pdata, *res = prop_data;
 666
 667                 res->time_increment_resolution = in->time_increment_resolution;
 668                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*res);
 669                 break;
 670         }
 671         case HFI_PROPERTY_PARAM_VENC_MPEG4_HEADER_EXTENSION: {
 672                 struct hfi_mpeg4_header_extension *in = pdata, *ext = prop_data;
 673
 674                 ext->header_extension = in->header_extension;
 675                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*ext);
 676                 break;
 677         }
 678         case HFI_PROPERTY_PARAM_VENC_H264_DEBLOCK_CONTROL: {
 679                 struct hfi_h264_db_control *in = pdata, *db = prop_data;
 680
 681                 switch (in->mode) {
 682                 case HFI_H264_DB_MODE_DISABLE:
 683                 case HFI_H264_DB_MODE_SKIP_SLICE_BOUNDARY:
 684                 case HFI_H264_DB_MODE_ALL_BOUNDARY:
 685                         break;
 686                 default:
 687                         ret = -EINVAL;
 688                         break;
 689                 }
 690
 691                 db->mode = in->mode;
 692                 db->slice_alpha_offset = in->slice_alpha_offset;
 693                 db->slice_beta_offset = in->slice_beta_offset;
 694                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*db);
 695                 break;
 696         }
 697         case HFI_PROPERTY_PARAM_VENC_SESSION_QP: {
 698                 struct hfi_quantization *in = pdata, *quant = prop_data;
 699
 700                 quant->qp_i = in->qp_i;
 701                 quant->qp_p = in->qp_p;
 702                 quant->qp_b = in->qp_b;
 703                 quant->layer_id = in->layer_id;
 704                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*quant);
 705                 break;
 706         }
 707         case HFI_PROPERTY_PARAM_VENC_SESSION_QP_RANGE: {
 708                 struct hfi_quantization_range *in = pdata, *range = prop_data;
 709                 u32 min_qp, max_qp;
 710
 711                 min_qp = in->min_qp;
 712                 max_qp = in->max_qp;
 713
 714                 /* We'll be packing in the qp, so make sure we
 715                  * won't be losing data when masking
 716                  */
 717                 if (min_qp > 0xff || max_qp > 0xff) {
 718                         ret = -ERANGE;
 719                         break;
 720                 }
 721
 722                 /* When creating the packet, pack the qp value as
 723                  * 0xiippbb, where ii = qp range for I-frames,
 724                  * pp = qp range for P-frames, etc.
 725                  */
 726                 range->min_qp = min_qp | min_qp << 8 | min_qp << 16;
 727                 range->max_qp = max_qp | max_qp << 8 | max_qp << 16;
 728                 range->layer_id = in->layer_id;
 729
 730                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*range);
 731                 break;
 732         }
 733         case HFI_PROPERTY_PARAM_VENC_VC1_PERF_CFG: {
 734                 struct hfi_vc1e_perf_cfg_type *in = pdata, *perf = prop_data;
 735
 736                 memcpy(perf->search_range_x_subsampled,
 737                        in->search_range_x_subsampled,
 738                        sizeof(perf->search_range_x_subsampled));
 739                 memcpy(perf->search_range_y_subsampled,
 740                        in->search_range_y_subsampled,
 741                        sizeof(perf->search_range_y_subsampled));
 742
 743                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*perf);
 744                 break;
 745         }
 746         case HFI_PROPERTY_PARAM_VENC_MAX_NUM_B_FRAMES: {
 747                 struct hfi_max_num_b_frames *bframes = prop_data;
 748                 u32 *in = pdata;
 749
 750                 bframes->max_num_b_frames = *in;
 751                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*bframes);
 752                 break;
 753         }
 754         case HFI_PROPERTY_CONFIG_VENC_INTRA_PERIOD: {
 755                 struct hfi_intra_period *in = pdata, *intra = prop_data;
 756
 757                 intra->pframes = in->pframes;
 758                 intra->bframes = in->bframes;
 759                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*intra);
 760                 break;
 761         }
 762         case HFI_PROPERTY_CONFIG_VENC_IDR_PERIOD: {
 763                 struct hfi_idr_period *in = pdata, *idr = prop_data;
 764
 765                 idr->idr_period = in->idr_period;
 766                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*idr);
 767                 break;
 768         }
 769         case HFI_PROPERTY_PARAM_VDEC_CONCEAL_COLOR: {
 770                 struct hfi_conceal_color *color = prop_data;
 771                 u32 *in = pdata;
 772
 773                 color->conceal_color = *in & 0xff;
 774                 color->conceal_color |= ((*in >> 10) & 0xff) << 8;
 775                 color->conceal_color |= ((*in >> 20) & 0xff) << 16;
 776                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*color);
 777                 break;
 778         }
 779         case HFI_PROPERTY_CONFIG_VPE_OPERATIONS: {
 780                 struct hfi_operations_type *in = pdata, *ops = prop_data;
 781
 782                 switch (in->rotation) {
 783                 case HFI_ROTATE_NONE:
 784                 case HFI_ROTATE_90:
 785                 case HFI_ROTATE_180:
 786                 case HFI_ROTATE_270:
 787                         break;
 788                 default:
 789                         ret = -EINVAL;
 790                         break;
 791                 }
 792
 793                 switch (in->flip) {
 794                 case HFI_FLIP_NONE:
 795                 case HFI_FLIP_HORIZONTAL:
 796                 case HFI_FLIP_VERTICAL:
 797                         break;
 798                 default:
 799                         ret = -EINVAL;
 800                         break;
 801                 }
 802
 803                 ops->rotation = in->rotation;
 804                 ops->flip = in->flip;
 805                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*ops);
 806                 break;
 807         }
 808         case HFI_PROPERTY_PARAM_VENC_INTRA_REFRESH: {
 809                 struct hfi_intra_refresh *in = pdata, *intra = prop_data;
 810
 811                 switch (in->mode) {
 812                 case HFI_INTRA_REFRESH_NONE:
 813                 case HFI_INTRA_REFRESH_ADAPTIVE:
 814                 case HFI_INTRA_REFRESH_CYCLIC:
 815                 case HFI_INTRA_REFRESH_CYCLIC_ADAPTIVE:
 816                 case HFI_INTRA_REFRESH_RANDOM:
 817                         break;
 818                 default:
 819                         ret = -EINVAL;
 820                         break;
 821                 }
 822
 823                 intra->mode = in->mode;
 824                 intra->air_mbs = in->air_mbs;
 825                 intra->air_ref = in->air_ref;
 826                 intra->cir_mbs = in->cir_mbs;
 827                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*intra);
 828                 break;
 829         }
 830         case HFI_PROPERTY_PARAM_VENC_MULTI_SLICE_CONTROL: {
 831                 struct hfi_multi_slice_control *in = pdata, *multi = prop_data;
 832
 833                 switch (in->multi_slice) {
 834                 case HFI_MULTI_SLICE_OFF:
 835                 case HFI_MULTI_SLICE_GOB:
 836                 case HFI_MULTI_SLICE_BY_MB_COUNT:
 837                 case HFI_MULTI_SLICE_BY_BYTE_COUNT:
 838                         break;
 839                 default:
 840                         ret = -EINVAL;
 841                         break;
 842                 }
 843
 844                 multi->multi_slice = in->multi_slice;
 845                 multi->slice_size = in->slice_size;
 846                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*multi);
 847                 break;
 848         }
 849         case HFI_PROPERTY_PARAM_VENC_SLICE_DELIVERY_MODE: {
 850                 struct hfi_enable *in = pdata, *en = prop_data;
 851
 852                 en->enable = in->enable;
 853                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
 854                 break;
 855         }
 856         case HFI_PROPERTY_PARAM_VENC_H264_VUI_TIMING_INFO: {
 857                 struct hfi_h264_vui_timing_info *in = pdata, *vui = prop_data;
 858
 859                 vui->enable = in->enable;
 860                 vui->fixed_framerate = in->fixed_framerate;
 861                 vui->time_scale = in->time_scale;
 862                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*vui);
 863                 break;
 864         }
 865         case HFI_PROPERTY_CONFIG_VPE_DEINTERLACE: {
 866                 struct hfi_enable *in = pdata, *en = prop_data;
 867
 868                 en->enable = in->enable;
 869                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
 870                 break;
 871         }
 872         case HFI_PROPERTY_PARAM_VENC_H264_GENERATE_AUDNAL: {
 873                 struct hfi_enable *in = pdata, *en = prop_data;
 874
 875                 en->enable = in->enable;
 876                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
 877                 break;
 878         }
 879         case HFI_PROPERTY_PARAM_BUFFER_ALLOC_MODE: {
 880                 struct hfi_buffer_alloc_mode *in = pdata, *mode = prop_data;
 881
 882                 mode->type = in->type;
 883                 mode->mode = in->mode;
 884                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*mode);
 885                 break;
 886         }
 887         case HFI_PROPERTY_PARAM_VDEC_FRAME_ASSEMBLY: {
 888                 struct hfi_enable *in = pdata, *en = prop_data;
 889
 890                 en->enable = in->enable;
 891                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
 892                 break;
 893         }
 894         case HFI_PROPERTY_PARAM_VENC_H264_VUI_BITSTREAM_RESTRC: {
 895                 struct hfi_enable *in = pdata, *en = prop_data;
 896
 897                 en->enable = in->enable;
 898                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
 899                 break;
 900         }
 901         case HFI_PROPERTY_PARAM_VENC_PRESERVE_TEXT_QUALITY: {
 902                 struct hfi_enable *in = pdata, *en = prop_data;
 903
 904                 en->enable = in->enable;
 905                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
 906                 break;
 907         }
 908         case HFI_PROPERTY_PARAM_VDEC_SCS_THRESHOLD: {
 909                 struct hfi_scs_threshold *thres = prop_data;
 910                 u32 *in = pdata;
 911
 912                 thres->threshold_value = *in;
 913                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*thres);
 914                 break;
 915         }
 916         case HFI_PROPERTY_PARAM_MVC_BUFFER_LAYOUT: {
 917                 struct hfi_mvc_buffer_layout_descp_type *in = pdata;
 918                 struct hfi_mvc_buffer_layout_descp_type *mvc = prop_data;
 919
 920                 switch (in->layout_type) {
 921                 case HFI_MVC_BUFFER_LAYOUT_TOP_BOTTOM:
 922                 case HFI_MVC_BUFFER_LAYOUT_SEQ:
 923                         break;
 924                 default:
 925                         ret = -EINVAL;
 926                         break;
 927                 }
 928
 929                 mvc->layout_type = in->layout_type;
 930                 mvc->bright_view_first = in->bright_view_first;
 931                 mvc->ngap = in->ngap;
 932                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*mvc);
 933                 break;
 934         }
 935         case HFI_PROPERTY_PARAM_VENC_LTRMODE: {
 936                 struct hfi_ltr_mode *in = pdata, *ltr = prop_data;
 937
 938                 switch (in->ltr_mode) {
 939                 case HFI_LTR_MODE_DISABLE:
 940                 case HFI_LTR_MODE_MANUAL:
 941                 case HFI_LTR_MODE_PERIODIC:
 942                         break;
 943                 default:
 944                         ret = -EINVAL;
 945                         break;
 946                 }
 947
 948                 ltr->ltr_mode = in->ltr_mode;
 949                 ltr->ltr_count = in->ltr_count;
 950                 ltr->trust_mode = in->trust_mode;
 951                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*ltr);
 952                 break;
 953         }
 954         case HFI_PROPERTY_CONFIG_VENC_USELTRFRAME: {
 955                 struct hfi_ltr_use *in = pdata, *ltr_use = prop_data;
 956
 957                 ltr_use->frames = in->frames;
 958                 ltr_use->ref_ltr = in->ref_ltr;
 959                 ltr_use->use_constrnt = in->use_constrnt;
 960                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*ltr_use);
 961                 break;
 962         }
 963         case HFI_PROPERTY_CONFIG_VENC_MARKLTRFRAME: {
 964                 struct hfi_ltr_mark *in = pdata, *ltr_mark = prop_data;
 965
 966                 ltr_mark->mark_frame = in->mark_frame;
 967                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*ltr_mark);
 968                 break;
 969         }
 970         case HFI_PROPERTY_PARAM_VENC_HIER_P_MAX_NUM_ENH_LAYER: {
 971                 u32 *in = pdata;
 972
 973                 pkt->data[1] = *in;
 974                 pkt->shdr.hdr.size += sizeof(u32) * 2;
 975                 break;
 976         }
 977         case HFI_PROPERTY_CONFIG_VENC_HIER_P_ENH_LAYER: {
 978                 u32 *in = pdata;
 979
 980                 pkt->data[1] = *in;
 981                 pkt->shdr.hdr.size += sizeof(u32) * 2;
 982                 break;
 983         }
 984         case HFI_PROPERTY_PARAM_VENC_DISABLE_RC_TIMESTAMP: {
 985                 struct hfi_enable *in = pdata, *en = prop_data;
 986
 987                 en->enable = in->enable;
 988                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
 989                 break;
 990         }
 991         case HFI_PROPERTY_PARAM_VENC_INITIAL_QP: {
 992                 struct hfi_initial_quantization *in = pdata, *quant = prop_data;
 993
 994                 quant->init_qp_enable = in->init_qp_enable;
 995                 quant->qp_i = in->qp_i;
 996                 quant->qp_p = in->qp_p;
 997                 quant->qp_b = in->qp_b;
 998                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*quant);
 999                 break;
1000         }
1001         case HFI_PROPERTY_PARAM_VPE_COLOR_SPACE_CONVERSION: {
1002                 struct hfi_vpe_color_space_conversion *in = pdata;
1003                 struct hfi_vpe_color_space_conversion *csc = prop_data;
1004
1005                 memcpy(csc->csc_matrix, in->csc_matrix,
1006                        sizeof(csc->csc_matrix));
1007                 memcpy(csc->csc_bias, in->csc_bias, sizeof(csc->csc_bias));
1008                 memcpy(csc->csc_limit, in->csc_limit, sizeof(csc->csc_limit));
1009                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*csc);
1010                 break;
1011         }
1012         case HFI_PROPERTY_PARAM_VENC_VPX_ERROR_RESILIENCE_MODE: {
1013                 struct hfi_enable *in = pdata, *en = prop_data;
1014
1015                 en->enable = in->enable;
1016                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
1017                 break;
1018         }
1019         case HFI_PROPERTY_PARAM_VENC_H264_NAL_SVC_EXT: {
1020                 struct hfi_enable *in = pdata, *en = prop_data;
1021
1022                 en->enable = in->enable;
1023                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
1024                 break;
1025         }
1026         case HFI_PROPERTY_CONFIG_VENC_PERF_MODE: {
1027                 u32 *in = pdata;
1028
1029                 pkt->data[1] = *in;
1030                 pkt->shdr.hdr.size += sizeof(u32) * 2;
1031                 break;
1032         }
1033         case HFI_PROPERTY_PARAM_VENC_HIER_B_MAX_NUM_ENH_LAYER: {
1034                 u32 *in = pdata;
1035
1036                 pkt->data[1] = *in;
1037                 pkt->shdr.hdr.size += sizeof(u32) * 2;
1038                 break;
1039         }
1040         case HFI_PROPERTY_PARAM_VDEC_NONCP_OUTPUT2: {
1041                 struct hfi_enable *in = pdata, *en = prop_data;
1042
1043                 en->enable = in->enable;
1044                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*en);
1045                 break;
1046         }
1047         case HFI_PROPERTY_PARAM_VENC_HIER_P_HYBRID_MODE: {
1048                 struct hfi_hybrid_hierp *in = pdata, *hierp = prop_data;
1049
1050                 hierp->layers = in->layers;
1051                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*hierp);
1052                 break;
1053         }
1054         case HFI_PROPERTY_PARAM_UNCOMPRESSED_PLANE_ACTUAL_INFO: {
1055                 struct hfi_uncompressed_plane_actual_info *in = pdata;
1056                 struct hfi_uncompressed_plane_actual_info *info = prop_data;
1057
1058                 info->buffer_type = in->buffer_type;
1059                 info->num_planes = in->num_planes;
1060                 info->plane_format[0] = in->plane_format[0];
1061                 if (in->num_planes > 1)
1062                         info->plane_format[1] = in->plane_format[1];
1063                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*info);
1064                 break;
1065         }
1066         case HFI_PROPERTY_PARAM_VENC_HDR10_PQ_SEI:
1067                 return -ENOTSUPP;
1068
1069         /* FOLLOWING PROPERTIES ARE NOT IMPLEMENTED IN CORE YET */
1070         case HFI_PROPERTY_CONFIG_BUFFER_REQUIREMENTS:
1071         case HFI_PROPERTY_CONFIG_PRIORITY:
1072         case HFI_PROPERTY_CONFIG_BATCH_INFO:
1073         case HFI_PROPERTY_SYS_IDLE_INDICATOR:
1074         case HFI_PROPERTY_PARAM_UNCOMPRESSED_FORMAT_SUPPORTED:
1075         case HFI_PROPERTY_PARAM_INTERLACE_FORMAT_SUPPORTED:
1076         case HFI_PROPERTY_PARAM_CHROMA_SITE:
1077         case HFI_PROPERTY_PARAM_PROPERTIES_SUPPORTED:
1078         case HFI_PROPERTY_PARAM_PROFILE_LEVEL_SUPPORTED:
1079         case HFI_PROPERTY_PARAM_CAPABILITY_SUPPORTED:
1080         case HFI_PROPERTY_PARAM_NAL_STREAM_FORMAT_SUPPORTED:
1081         case HFI_PROPERTY_PARAM_MULTI_VIEW_FORMAT:
1082         case HFI_PROPERTY_PARAM_MAX_SEQUENCE_HEADER_SIZE:
1083         case HFI_PROPERTY_PARAM_CODEC_SUPPORTED:
1084         case HFI_PROPERTY_PARAM_VDEC_MULTI_VIEW_SELECT:
1085         case HFI_PROPERTY_PARAM_VDEC_MB_QUANTIZATION:
1086         case HFI_PROPERTY_PARAM_VDEC_NUM_CONCEALED_MB:
1087         case HFI_PROPERTY_PARAM_VDEC_H264_ENTROPY_SWITCHING:
1088         case HFI_PROPERTY_PARAM_VENC_MULTI_SLICE_INFO:
1089         default:
1090                 return -EINVAL;
1091         }
1092
1093         return ret;
1094 }
1095
1096 static int
1097 pkt_session_get_property_3xx(struct hfi_session_get_property_pkt *pkt,
1098                              void *cookie, u32 ptype)
1099 {
1100         int ret = 0;
1101
1102         if (!pkt || !cookie)
1103                 return -EINVAL;
1104
1105         pkt->shdr.hdr.size = sizeof(struct hfi_session_get_property_pkt);
1106         pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_GET_PROPERTY;
1107         pkt->shdr.session_id = hash32_ptr(cookie);
1108         pkt->num_properties = 1;
1109
1110         switch (ptype) {
1111         case HFI_PROPERTY_CONFIG_VDEC_ENTROPY:
1112                 pkt->data[0] = HFI_PROPERTY_CONFIG_VDEC_ENTROPY;
1113                 break;
1114         default:
1115                 ret = pkt_session_get_property_1x(pkt, cookie, ptype);
1116                 break;
1117         }
1118
1119         return ret;
1120 }
1121
1122 static int
1123 pkt_session_set_property_3xx(struct hfi_session_set_property_pkt *pkt,
1124                              void *cookie, u32 ptype, void *pdata)
1125 {
1126         void *prop_data;
1127         int ret = 0;
1128
1129         if (!pkt || !cookie || !pdata)
1130                 return -EINVAL;
1131
1132         prop_data = &pkt->data[1];
1133
1134         pkt->shdr.hdr.size = sizeof(*pkt);
1135         pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_SET_PROPERTY;
1136         pkt->shdr.session_id = hash32_ptr(cookie);
1137         pkt->num_properties = 1;
1138         pkt->data[0] = ptype;
1139
1140         /*
1141          * Any session set property which is different in 3XX packetization
1142          * should be added as a new case below. All unchanged session set
1143          * properties will be handled in the default case.
1144          */
1145         switch (ptype) {
1146         case HFI_PROPERTY_PARAM_VDEC_MULTI_STREAM: {
1147                 struct hfi_multi_stream *in = pdata;
1148                 struct hfi_multi_stream_3x *multi = prop_data;
1149
1150                 multi->buffer_type = in->buffer_type;
1151                 multi->enable = in->enable;
1152                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*multi);
1153                 break;
1154         }
1155         case HFI_PROPERTY_PARAM_VENC_INTRA_REFRESH: {
1156                 struct hfi_intra_refresh *in = pdata;
1157                 struct hfi_intra_refresh_3x *intra = prop_data;
1158
1159                 switch (in->mode) {
1160                 case HFI_INTRA_REFRESH_NONE:
1161                 case HFI_INTRA_REFRESH_ADAPTIVE:
1162                 case HFI_INTRA_REFRESH_CYCLIC:
1163                 case HFI_INTRA_REFRESH_CYCLIC_ADAPTIVE:
1164                 case HFI_INTRA_REFRESH_RANDOM:
1165                         break;
1166                 default:
1167                         ret = -EINVAL;
1168                         break;
1169                 }
1170
1171                 intra->mode = in->mode;
1172                 intra->mbs = in->cir_mbs;
1173                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*intra);
1174                 break;
1175         }
1176         case HFI_PROPERTY_PARAM_VDEC_CONTINUE_DATA_TRANSFER:
1177                 /* for 3xx fw version session_continue is used */
1178                 break;
1179         default:
1180                 ret = pkt_session_set_property_1x(pkt, cookie, ptype, pdata);
1181                 break;
1182         }
1183
1184         return ret;
1185 }
1186
1187 static int
1188 pkt_session_set_property_4xx(struct hfi_session_set_property_pkt *pkt,
1189                              void *cookie, u32 ptype, void *pdata)
1190 {
1191         void *prop_data;
1192
1193         if (!pkt || !cookie || !pdata)
1194                 return -EINVAL;
1195
1196         prop_data = &pkt->data[1];
1197
1198         pkt->shdr.hdr.size = sizeof(*pkt);
1199         pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_SET_PROPERTY;
1200         pkt->shdr.session_id = hash32_ptr(cookie);
1201         pkt->num_properties = 1;
1202         pkt->data[0] = ptype;
1203
1204         /*
1205          * Any session set property which is different in 3XX packetization
1206          * should be added as a new case below. All unchanged session set
1207          * properties will be handled in the default case.
1208          */
1209         switch (ptype) {
1210         case HFI_PROPERTY_PARAM_BUFFER_COUNT_ACTUAL: {
1211                 struct hfi_buffer_count_actual *in = pdata;
1212                 struct hfi_buffer_count_actual_4xx *count = prop_data;
1213
1214                 count->count_actual = in->count_actual;
1215                 count->type = in->type;
1216                 count->count_min_host = in->count_actual;
1217                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*count);
1218                 break;
1219         }
1220         case HFI_PROPERTY_PARAM_WORK_MODE: {
1221                 struct hfi_video_work_mode *in = pdata, *wm = prop_data;
1222
1223                 wm->video_work_mode = in->video_work_mode;
1224                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*wm);
1225                 break;
1226         }
1227         case HFI_PROPERTY_CONFIG_VIDEOCORES_USAGE: {
1228                 struct hfi_videocores_usage_type *in = pdata, *cu = prop_data;
1229
1230                 cu->video_core_enable_mask = in->video_core_enable_mask;
1231                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*cu);
1232                 break;
1233         }
1234         case HFI_PROPERTY_PARAM_VENC_HDR10_PQ_SEI: {
1235                 struct hfi_hdr10_pq_sei *in = pdata, *hdr10 = prop_data;
1236
1237                 memcpy(hdr10, in, sizeof(*hdr10));
1238                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*hdr10);
1239                 break;
1240         }
1241         case HFI_PROPERTY_PARAM_VDEC_CONCEAL_COLOR: {
1242                 struct hfi_conceal_color_v4 *color = prop_data;
1243                 u32 *in = pdata;
1244
1245                 color->conceal_color_8bit = *in & 0xff;
1246                 color->conceal_color_8bit |= ((*in >> 10) & 0xff) << 8;
1247                 color->conceal_color_8bit |= ((*in >> 20) & 0xff) << 16;
1248                 color->conceal_color_10bit = *in;
1249                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*color);
1250                 break;
1251         }
1252
1253         case HFI_PROPERTY_PARAM_VENC_H264_TRANSFORM_8X8: {
1254                 struct hfi_h264_8x8_transform *in = pdata, *tm = prop_data;
1255
1256                 tm->enable_type = in->enable_type;
1257                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*tm);
1258                 break;
1259         }
1260         case HFI_PROPERTY_PARAM_VENC_SESSION_QP_RANGE_V2: {
1261                 struct hfi_quantization_range_v2 *in = pdata, *range = prop_data;
1262                 u32 min_qp, max_qp;
1263
1264                 min_qp = in->min_qp.qp_packed;
1265                 max_qp = in->max_qp.qp_packed;
1266
1267                 /* We'll be packing in the qp, so make sure we
1268                  * won't be losing data when masking
1269                  */
1270                 if (min_qp > 0xff || max_qp > 0xff)
1271                         return -ERANGE;
1272
1273                 range->min_qp.layer_id = 0xFF;
1274                 range->max_qp.layer_id = 0xFF;
1275                 range->min_qp.qp_packed = (min_qp & 0xFF) | ((min_qp & 0xFF) << 8) |
1276                         ((min_qp & 0xFF) << 16);
1277                 range->max_qp.qp_packed = (max_qp & 0xFF) | ((max_qp & 0xFF) << 8) |
1278                         ((max_qp & 0xFF) << 16);
1279                 range->min_qp.enable = 7;
1280                 range->max_qp.enable = 7;
1281                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*range);
1282                 break;
1283         }
1284         case HFI_PROPERTY_CONFIG_VENC_MAX_BITRATE:
1285         case HFI_PROPERTY_CONFIG_VDEC_POST_LOOP_DEBLOCKER:
1286         case HFI_PROPERTY_PARAM_BUFFER_ALLOC_MODE:
1287         case HFI_PROPERTY_PARAM_VENC_SESSION_QP:
1288         case HFI_PROPERTY_PARAM_VENC_SESSION_QP_RANGE:
1289                 /* not implemented on Venus 4xx */
1290                 return -ENOTSUPP;
1291         default:
1292                 return pkt_session_set_property_3xx(pkt, cookie, ptype, pdata);
1293         }
1294
1295         return 0;
1296 }
1297
1298 static int
1299 pkt_session_set_property_6xx(struct hfi_session_set_property_pkt *pkt,
1300                              void *cookie, u32 ptype, void *pdata)
1301 {
1302         void *prop_data;
1303
1304         if (!pkt || !cookie || !pdata)
1305                 return -EINVAL;
1306
1307         prop_data = &pkt->data[1];
1308
1309         pkt->shdr.hdr.size = sizeof(*pkt);
1310         pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_SET_PROPERTY;
1311         pkt->shdr.session_id = hash32_ptr(cookie);
1312         pkt->num_properties = 1;
1313         pkt->data[0] = ptype;
1314
1315         switch (ptype) {
1316         case HFI_PROPERTY_PARAM_UNCOMPRESSED_PLANE_ACTUAL_CONSTRAINTS_INFO: {
1317                 struct hfi_uncompressed_plane_actual_constraints_info *in = pdata;
1318                 struct hfi_uncompressed_plane_actual_constraints_info *info = prop_data;
1319
1320                 info->buffer_type = in->buffer_type;
1321                 info->num_planes = in->num_planes;
1322                 info->plane_format[0] = in->plane_format[0];
1323                 if (in->num_planes > 1)
1324                         info->plane_format[1] = in->plane_format[1];
1325
1326                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*info);
1327                 break;
1328         }
1329         case HFI_PROPERTY_CONFIG_HEIC_FRAME_QUALITY: {
1330                 struct hfi_heic_frame_quality *in = pdata, *cq = prop_data;
1331
1332                 cq->frame_quality = in->frame_quality;
1333                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*cq);
1334                 break;
1335         }
1336         case HFI_PROPERTY_PARAM_WORK_ROUTE: {
1337                 struct hfi_video_work_route *in = pdata, *wr = prop_data;
1338
1339                 wr->video_work_route = in->video_work_route;
1340                 pkt->shdr.hdr.size += sizeof(u32) + sizeof(*wr);
1341                 break;
1342         }
1343         default:
1344                 return pkt_session_set_property_4xx(pkt, cookie, ptype, pdata);
1345         }
1346
1347         return 0;
1348 }
1349
1350 int pkt_session_get_property(struct hfi_session_get_property_pkt *pkt,
1351                              void *cookie, u32 ptype)
1352 {
1353         if (hfi_ver == HFI_VERSION_1XX)
1354                 return pkt_session_get_property_1x(pkt, cookie, ptype);
1355
1356         return pkt_session_get_property_3xx(pkt, cookie, ptype);
1357 }
1358
1359 int pkt_session_set_property(struct hfi_session_set_property_pkt *pkt,
1360                              void *cookie, u32 ptype, void *pdata)
1361 {
1362         if (hfi_ver == HFI_VERSION_1XX)
1363                 return pkt_session_set_property_1x(pkt, cookie, ptype, pdata);
1364
1365         if (hfi_ver == HFI_VERSION_3XX)
1366                 return pkt_session_set_property_3xx(pkt, cookie, ptype, pdata);
1367
1368         if (hfi_ver == HFI_VERSION_4XX)
1369                 return pkt_session_set_property_4xx(pkt, cookie, ptype, pdata);
1370
1371         return pkt_session_set_property_6xx(pkt, cookie, ptype, pdata);
1372 }
1373
1374 void pkt_set_version(enum hfi_version version)
1375 {
1376         hfi_ver = version;
1377 }