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