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