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