linux/drivers/media/platform/qcom/venus/hfi_cmds.c
<<
>>
Prefs
   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
  12static enum hfi_version hfi_ver;
  13
  14void 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
  21void 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
  27void 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
  38void 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
  52void 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
  61int 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
  88int 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
 109void 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
 116void 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
 127int 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
 145void 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
 153int 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
 168void 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
 175int 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
 214int 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
 255int 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
 278int 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
 304int 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
 330int 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
 346int 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
 361int 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
 381static 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
 401static 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
1058        /* FOLLOWING PROPERTIES ARE NOT IMPLEMENTED IN CORE YET */
1059        case HFI_PROPERTY_CONFIG_BUFFER_REQUIREMENTS:
1060        case HFI_PROPERTY_CONFIG_PRIORITY:
1061        case HFI_PROPERTY_CONFIG_BATCH_INFO:
1062        case HFI_PROPERTY_SYS_IDLE_INDICATOR:
1063        case HFI_PROPERTY_PARAM_UNCOMPRESSED_FORMAT_SUPPORTED:
1064        case HFI_PROPERTY_PARAM_INTERLACE_FORMAT_SUPPORTED:
1065        case HFI_PROPERTY_PARAM_CHROMA_SITE:
1066        case HFI_PROPERTY_PARAM_PROPERTIES_SUPPORTED:
1067        case HFI_PROPERTY_PARAM_PROFILE_LEVEL_SUPPORTED:
1068        case HFI_PROPERTY_PARAM_CAPABILITY_SUPPORTED:
1069        case HFI_PROPERTY_PARAM_NAL_STREAM_FORMAT_SUPPORTED:
1070        case HFI_PROPERTY_PARAM_MULTI_VIEW_FORMAT:
1071        case HFI_PROPERTY_PARAM_MAX_SEQUENCE_HEADER_SIZE:
1072        case HFI_PROPERTY_PARAM_CODEC_SUPPORTED:
1073        case HFI_PROPERTY_PARAM_VDEC_MULTI_VIEW_SELECT:
1074        case HFI_PROPERTY_PARAM_VDEC_MB_QUANTIZATION:
1075        case HFI_PROPERTY_PARAM_VDEC_NUM_CONCEALED_MB:
1076        case HFI_PROPERTY_PARAM_VDEC_H264_ENTROPY_SWITCHING:
1077        case HFI_PROPERTY_PARAM_VENC_MULTI_SLICE_INFO:
1078        default:
1079                return -EINVAL;
1080        }
1081
1082        return ret;
1083}
1084
1085static int
1086pkt_session_get_property_3xx(struct hfi_session_get_property_pkt *pkt,
1087                             void *cookie, u32 ptype)
1088{
1089        int ret = 0;
1090
1091        if (!pkt || !cookie)
1092                return -EINVAL;
1093
1094        pkt->shdr.hdr.size = sizeof(struct hfi_session_get_property_pkt);
1095        pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_GET_PROPERTY;
1096        pkt->shdr.session_id = hash32_ptr(cookie);
1097        pkt->num_properties = 1;
1098
1099        switch (ptype) {
1100        case HFI_PROPERTY_CONFIG_VDEC_ENTROPY:
1101                pkt->data[0] = HFI_PROPERTY_CONFIG_VDEC_ENTROPY;
1102                break;
1103        default:
1104                ret = pkt_session_get_property_1x(pkt, cookie, ptype);
1105                break;
1106        }
1107
1108        return ret;
1109}
1110
1111static int
1112pkt_session_set_property_3xx(struct hfi_session_set_property_pkt *pkt,
1113                             void *cookie, u32 ptype, void *pdata)
1114{
1115        void *prop_data;
1116        int ret = 0;
1117
1118        if (!pkt || !cookie || !pdata)
1119                return -EINVAL;
1120
1121        prop_data = &pkt->data[1];
1122
1123        pkt->shdr.hdr.size = sizeof(*pkt);
1124        pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_SET_PROPERTY;
1125        pkt->shdr.session_id = hash32_ptr(cookie);
1126        pkt->num_properties = 1;
1127        pkt->data[0] = ptype;
1128
1129        /*
1130         * Any session set property which is different in 3XX packetization
1131         * should be added as a new case below. All unchanged session set
1132         * properties will be handled in the default case.
1133         */
1134        switch (ptype) {
1135        case HFI_PROPERTY_PARAM_VDEC_MULTI_STREAM: {
1136                struct hfi_multi_stream *in = pdata;
1137                struct hfi_multi_stream_3x *multi = prop_data;
1138
1139                multi->buffer_type = in->buffer_type;
1140                multi->enable = in->enable;
1141                pkt->shdr.hdr.size += sizeof(u32) + sizeof(*multi);
1142                break;
1143        }
1144        case HFI_PROPERTY_PARAM_VENC_INTRA_REFRESH: {
1145                struct hfi_intra_refresh *in = pdata;
1146                struct hfi_intra_refresh_3x *intra = prop_data;
1147
1148                switch (in->mode) {
1149                case HFI_INTRA_REFRESH_NONE:
1150                case HFI_INTRA_REFRESH_ADAPTIVE:
1151                case HFI_INTRA_REFRESH_CYCLIC:
1152                case HFI_INTRA_REFRESH_CYCLIC_ADAPTIVE:
1153                case HFI_INTRA_REFRESH_RANDOM:
1154                        break;
1155                default:
1156                        ret = -EINVAL;
1157                        break;
1158                }
1159
1160                intra->mode = in->mode;
1161                intra->mbs = in->cir_mbs;
1162                pkt->shdr.hdr.size += sizeof(u32) + sizeof(*intra);
1163                break;
1164        }
1165        case HFI_PROPERTY_PARAM_VDEC_CONTINUE_DATA_TRANSFER:
1166                /* for 3xx fw version session_continue is used */
1167                break;
1168        default:
1169                ret = pkt_session_set_property_1x(pkt, cookie, ptype, pdata);
1170                break;
1171        }
1172
1173        return ret;
1174}
1175
1176static int
1177pkt_session_set_property_4xx(struct hfi_session_set_property_pkt *pkt,
1178                             void *cookie, u32 ptype, void *pdata)
1179{
1180        void *prop_data;
1181
1182        if (!pkt || !cookie || !pdata)
1183                return -EINVAL;
1184
1185        prop_data = &pkt->data[1];
1186
1187        pkt->shdr.hdr.size = sizeof(*pkt);
1188        pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_SET_PROPERTY;
1189        pkt->shdr.session_id = hash32_ptr(cookie);
1190        pkt->num_properties = 1;
1191        pkt->data[0] = ptype;
1192
1193        /*
1194         * Any session set property which is different in 3XX packetization
1195         * should be added as a new case below. All unchanged session set
1196         * properties will be handled in the default case.
1197         */
1198        switch (ptype) {
1199        case HFI_PROPERTY_PARAM_BUFFER_COUNT_ACTUAL: {
1200                struct hfi_buffer_count_actual *in = pdata;
1201                struct hfi_buffer_count_actual_4xx *count = prop_data;
1202
1203                count->count_actual = in->count_actual;
1204                count->type = in->type;
1205                count->count_min_host = in->count_actual;
1206                pkt->shdr.hdr.size += sizeof(u32) + sizeof(*count);
1207                break;
1208        }
1209        case HFI_PROPERTY_PARAM_WORK_MODE: {
1210                struct hfi_video_work_mode *in = pdata, *wm = prop_data;
1211
1212                wm->video_work_mode = in->video_work_mode;
1213                pkt->shdr.hdr.size += sizeof(u32) + sizeof(*wm);
1214                break;
1215        }
1216        case HFI_PROPERTY_CONFIG_VIDEOCORES_USAGE: {
1217                struct hfi_videocores_usage_type *in = pdata, *cu = prop_data;
1218
1219                cu->video_core_enable_mask = in->video_core_enable_mask;
1220                pkt->shdr.hdr.size += sizeof(u32) + sizeof(*cu);
1221                break;
1222        }
1223        case HFI_PROPERTY_PARAM_VENC_HDR10_PQ_SEI: {
1224                struct hfi_hdr10_pq_sei *in = pdata, *hdr10 = prop_data;
1225
1226                memcpy(hdr10, in, sizeof(*hdr10));
1227                pkt->shdr.hdr.size += sizeof(u32) + sizeof(*hdr10);
1228                break;
1229        }
1230        case HFI_PROPERTY_PARAM_VDEC_CONCEAL_COLOR: {
1231                struct hfi_conceal_color_v4 *color = prop_data;
1232                u32 *in = pdata;
1233
1234                color->conceal_color_8bit = *in & 0xff;
1235                color->conceal_color_8bit |= ((*in >> 10) & 0xff) << 8;
1236                color->conceal_color_8bit |= ((*in >> 20) & 0xff) << 16;
1237                color->conceal_color_10bit = *in;
1238                pkt->shdr.hdr.size += sizeof(u32) + sizeof(*color);
1239                break;
1240        }
1241
1242        case HFI_PROPERTY_CONFIG_VENC_MAX_BITRATE:
1243        case HFI_PROPERTY_CONFIG_VDEC_POST_LOOP_DEBLOCKER:
1244        case HFI_PROPERTY_PARAM_BUFFER_ALLOC_MODE:
1245        case HFI_PROPERTY_PARAM_VENC_SESSION_QP:
1246        case HFI_PROPERTY_PARAM_VENC_SESSION_QP_RANGE:
1247                /* not implemented on Venus 4xx */
1248                return -ENOTSUPP;
1249        default:
1250                return pkt_session_set_property_3xx(pkt, cookie, ptype, pdata);
1251        }
1252
1253        return 0;
1254}
1255
1256static int
1257pkt_session_set_property_6xx(struct hfi_session_set_property_pkt *pkt,
1258                             void *cookie, u32 ptype, void *pdata)
1259{
1260        void *prop_data;
1261
1262        if (!pkt || !cookie || !pdata)
1263                return -EINVAL;
1264
1265        prop_data = &pkt->data[1];
1266
1267        pkt->shdr.hdr.size = sizeof(*pkt);
1268        pkt->shdr.hdr.pkt_type = HFI_CMD_SESSION_SET_PROPERTY;
1269        pkt->shdr.session_id = hash32_ptr(cookie);
1270        pkt->num_properties = 1;
1271        pkt->data[0] = ptype;
1272
1273        switch (ptype) {
1274        case HFI_PROPERTY_PARAM_UNCOMPRESSED_PLANE_ACTUAL_CONSTRAINTS_INFO: {
1275                struct hfi_uncompressed_plane_actual_constraints_info *in = pdata;
1276                struct hfi_uncompressed_plane_actual_constraints_info *info = prop_data;
1277
1278                info->buffer_type = in->buffer_type;
1279                info->num_planes = in->num_planes;
1280                info->plane_format[0] = in->plane_format[0];
1281                if (in->num_planes > 1)
1282                        info->plane_format[1] = in->plane_format[1];
1283
1284                pkt->shdr.hdr.size += sizeof(u32) + sizeof(*info);
1285                break;
1286        }
1287        case HFI_PROPERTY_CONFIG_HEIC_FRAME_QUALITY: {
1288                struct hfi_heic_frame_quality *in = pdata, *cq = prop_data;
1289
1290                cq->frame_quality = in->frame_quality;
1291                pkt->shdr.hdr.size += sizeof(u32) + sizeof(*cq);
1292                break;
1293        }
1294        default:
1295                return pkt_session_set_property_4xx(pkt, cookie, ptype, pdata);
1296        }
1297
1298        return 0;
1299}
1300
1301int pkt_session_get_property(struct hfi_session_get_property_pkt *pkt,
1302                             void *cookie, u32 ptype)
1303{
1304        if (hfi_ver == HFI_VERSION_1XX)
1305                return pkt_session_get_property_1x(pkt, cookie, ptype);
1306
1307        return pkt_session_get_property_3xx(pkt, cookie, ptype);
1308}
1309
1310int pkt_session_set_property(struct hfi_session_set_property_pkt *pkt,
1311                             void *cookie, u32 ptype, void *pdata)
1312{
1313        if (hfi_ver == HFI_VERSION_1XX)
1314                return pkt_session_set_property_1x(pkt, cookie, ptype, pdata);
1315
1316        if (hfi_ver == HFI_VERSION_3XX)
1317                return pkt_session_set_property_3xx(pkt, cookie, ptype, pdata);
1318
1319        if (hfi_ver == HFI_VERSION_4XX)
1320                return pkt_session_set_property_4xx(pkt, cookie, ptype, pdata);
1321
1322        return pkt_session_set_property_6xx(pkt, cookie, ptype, pdata);
1323}
1324
1325void pkt_set_version(enum hfi_version version)
1326{
1327        hfi_ver = version;
1328}
1329