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