msm: vidc: initial hfi packetization changes

Initial HFI packetization changes.

Change-Id: If09b93acf6aef55acc32b03b369989896d59f5e8
Signed-off-by: Darshana Patil <darshana@codeaurora.org>

driver/vidc/inc/hfi_command.h

@@ -0,0 +1,151 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (c) 2012-2021, The Linux Foundation. All rights reserved.
+ */
+
+#ifndef __H_HFI_COMMAND_H__
+#define __H_HFI_COMMAND_H__
+
+#define HFI_VIDEO_ARCH_OX               0x1
+
+struct hfi_header {
+	u32 size;
+	u32 session_id;
+	u32 header_id;
+	u32 reserved[4];
+	u32 num_packets;
+};
+
+struct hfi_packet {
+	u32 size;
+	u32 type;
+	u32 flags;
+	u32 payload_info;
+	u32 port;
+	u32 packet_id;
+	u32 reserved[2];
+};
+
+struct hfi_buffer {
+	u32 type;
+	u32 index;
+	u64 base_address;
+	u32 addr_offset;
+	u32 buffer_size;
+	u32 data_offset;
+	u32 data_size;
+	u32 flags;
+	u64 timestamp;
+	u32 reserved[5];
+};
+
+enum hfi_packet_host_flags {
+	HFI_HOST_FLAGS_NONE              = 0,
+	HFI_HOST_FLAGS_INTR_REQUIRED     = BIT(0),
+	HFI_HOST_FLAGS_RESPONSE_REQUIRED = BIT(1),
+	HFI_HOST_FLAGS_NON_DISCARDABLE   = BIT(2),
+	HFI_HOST_FLAGS_GET_PROPERTY      = BIT(3),
+};
+
+enum hfi_packet_firmware_flags {
+	HFI_FW_FLAGS_NONE          = 0,
+	HFI_FW_FLAGS_SUCCESS       = BIT(0),
+	HFI_FW_FLAGS_INFORMATION   = BIT(1),
+	HFI_FW_FLAGS_SESSION_ERROR = BIT(2),
+	HFI_FW_FLAGS_SYSTEM_ERROR  = BIT(3),
+};
+
+enum hfi_packet_payload_info {
+	HFI_PAYLOAD_NONE      = 0x00000000,
+	HFI_PAYLOAD_U32       = 0x00000001,
+	HFI_PAYLOAD_S32       = 0x00000002,
+	HFI_PAYLOAD_U64       = 0x00000003,
+	HFI_PAYLOAD_S64       = 0x00000004,
+	HFI_PAYLOAD_STRUCTURE = 0x00000005,
+	HFI_PAYLOAD_BLOB      = 0x00000006,
+	HFI_PAYLOAD_STRING    = 0x00000007,
+	HFI_PAYLOAD_Q16       = 0x00000008,
+	HFI_PAYLOAD_U32_ENUM  = 0x00000009,
+	HFI_PAYLOAD_32_PACKED = 0x0000000a,
+	HFI_PAYLOAD_U32_ARRAY = 0x0000000b,
+	HFI_PAYLOAD_S32_ARRAY = 0x0000000c,
+};
+
+enum hfi_packet_port_type {
+	HFI_PORT_NONE      = 0,
+	HFI_PORT_BITSTREAM = BIT(0),
+	HFI_PORT_RAW       = BIT(1),
+};
+
+enum hfi_buffer_type {
+	HFI_BUFFER_BITSTREAM  = 0x00000001,
+	HFI_BUFFER_RAW        = 0x00000002,
+	HFI_BUFFER_METADATA   = 0x00000003,
+	HFI_BUFFER_DPB        = 0x00000010,
+	HFI_BUFFER_BIN        = 0x00000011,
+	HFI_BUFFER_LINE       = 0x00000012,
+	HFI_BUFFER_ARP        = 0x00000013,
+	HFI_BUFFER_COMV       = 0x00000014,
+	HFI_BUFFER_NON_COMV   = 0x00000015,
+	HFI_BUFFER_SUBCACHE   = 0x00000020,
+	HFI_BUFFER_SFR        = 0x00000021,
+};
+
+enum hfi_buffer_host_flags {
+	HFI_BUF_HOST_FLAG_NONE           = 0,
+	HFI_BUF_HOST_FLAG_RELEASE        = BIT(0),
+	HFI_BUF_HOST_FLAG_READONLY       = BIT(1),
+	HFI_BUF_HOST_FLAG_CODEC_CONFIG   = BIT(2),
+};
+
+enum hfi_buffer_firmware_flags {
+	HFI_BUF_FW_FLAG_NONE           = 0,
+	HFI_BUF_FW_FLAG_LAST           = BIT(0),
+	HFI_BUF_FW_FLAG_READONLY       = BIT(1),
+	HFI_BUF_FW_FLAG_CODEC_CONFIG   = BIT(2),
+};
+
+enum hfi_metapayload_header_flags {
+	HFI_METADATA_FLAGS_NONE           = 0,
+	HFI_METADATA_FLAGS_TOP_FIELD      = BIT(0),
+	HFI_METADATA_FLAGS_BOTTOM_FIELDS  = BIT(1),
+};
+
+struct metabuf_header {
+	u32 count;
+	u32 size;
+	u32 version;
+	u32 reserved[5];
+};
+
+struct metapayload_header {
+	u32 type;
+	u32 size;
+	u32 version;
+	u32 offset;
+	u32 flags;
+	u32 reserved[3];
+};
+
+enum hfi_property_mode_type {
+	HFI_MODE_NONE = 0,
+	HFI_MODE_PORT_SETTINGS_CHANGE = BIT(0),
+	HFI_MODE_PROPERTY = BIT(1),
+	HFI_MODE_METADATA = BIT(2),
+};
+
+#define HFI_CMD_INIT                                            0x1
+#define HFI_CMD_POWER_COLLAPSE                                  0x2
+#define HFI_CMD_OPEN                                            0x3
+#define HFI_CMD_CLOSE                                           0x4
+#define HFI_CMD_START                                           0x5
+#define HFI_CMD_STOP                                            0x6
+#define HFI_CMD_DRAIN                                           0x7
+#define HFI_CMD_RESUME                                          0x8
+#define HFI_CMD_BUFFER                                          0x9
+#define HFI_CMD_DELIVERY_MODE                                   0xA
+#define HFI_CMD_SUBSCRIBE_MODE                                  0xB
+#define HFI_CMD_SETTINGS_CHANGE                                 0xC
+
+
+#endif //__H_HFI_COMMAND_H__

driver/vidc/inc/hfi_definition.h

@@ -0,0 +1,30 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (c) 2012-2021, The Linux Foundation. All rights reserved.
+ */
+
+#ifndef __H_HFI_DEFINITION_H__
+#define __H_HFI_DEFINITION_H__
+
+typedef u8 HFI_U8;
+typedef s8 HFI_S8;
+typedef u16 HFI_U16;
+typedef s16 HFI_S16;
+typedef u32 HFI_U32;
+typedef s32 HFI_S32;
+typedef u64 HFI_U64;
+
+typedef HFI_U32 HFI_BOOL;
+#define  HFI_FALSE      0
+#define  HFI_TRUE       (!HFI_FALSE)
+
+typedef HFI_U32 HFI_STATUS;
+#define  HFI_FAIL       0
+#define  HFI_SUCCESS    1
+
+#define HFI_ALIGN(a, b) (((b) & ((b) - 1)) ? \
+	(((a) + (b) - 1) / (b) * (b)) : \
+	(((a) + (b) - 1) & (~((b) - 1))))
+
+#endif // __H_HFI_DEFINITION_H__
+

driver/vidc/inc/hfi_packet.h

@@ -9,48 +9,31 @@
 #include "msm_vidc_internal.h"
 #include "msm_vidc_inst.h"
 #include "msm_vidc_core.h"
+#include "hfi_command.h"
+#include "hfi_property.h"
+#include "hfi_definition.h"
 
-struct hfi_header {
+int hfi_create_header(u8 *pkt, u32 session_id,
-	u32 size;
+	u32 header_id, u32 num_packets, u32 total_size);
-	u32 session_id;
+int hfi_create_packet(u8 *packet, u32 packet_size, u32 *offset,
-	u32 header_id;
+	u32 pkt_type, u32 pkt_flags, u32 payload_type, u32 port,
-	u32 reserved[4];
+	u32 packet_id, void *payload, u32 payload_size);
-	u32 num_packets;
+int hfi_create_buffer(u8 *packet, u32 packet_size, u32 *offset,
-};
+	enum msm_vidc_domain_type domain, struct msm_vidc_buffer *data);
-
-struct hfi_packet {
-	u32 size;
-	u32 type;
-	u32 flags;
-	u32 payload_info;
-	u32 port;
-	u32 packet_id;
-	u32 reserved[2];
-};
-
-struct hfi_buffer {
-	u32 type;
-	u32 index;
-	u64 base_address;
-	u32 addr_offset;
-	u32 buffer_size;
-	u32 data_offset;
-	u32 data_size;
-	u32 flags;
-	u64 timestamp;
-	u32 reserved[5];
-};
 
 int hfi_packet_sys_init(struct msm_vidc_core *core,
-		void *packet, u32 packet_size);
+	u8 *pkt, u32 pkt_size);
 int hfi_packet_image_version(struct msm_vidc_core *core,
-		void *packet, u32 packet_size);
+	u8 *pkt, u32 pkt_size);
-int hfi_packet_sys_debug_config(struct msm_vidc_core *core,
-		void *packet, u32 packet_size, u32 mode);
 int hfi_packet_sys_pc_prep(struct msm_vidc_core *core,
-		void *packet, u32 packet_size);
+	u8 *pkt, u32 pkt_size);
-int hfi_packet_session_open(struct msm_vidc_inst *inst,
+int hfi_packet_sys_debug_config(struct msm_vidc_core *core,
-		void *packet, u32 pkt_size);
+	u8 *pkt, u32 pkt_size, u32 debug_config);
-int hfi_packet_session_close(struct msm_vidc_inst *inst,
+int hfi_packet_session_command(struct msm_vidc_inst *inst,
-		void *packet, u32 pkt_size);
+	u32 pkt_type, u32 flags, u32 port, u32 session_id,
+	u32 payload_type, void *payload, u32 payload_size);
+int hfi_packet_create_property(struct msm_vidc_inst *inst,
+	void *pkt, u32 pkt_size, u32 pkt_type, u32 flags,
+	u32 port, u32 payload, u32 payload_type, u32 payload_size);
 #endif // _HFI_PACKET_H_
+

driver/vidc/inc/hfi_property.h

@@ -0,0 +1,477 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (c) 2012-2021, The Linux Foundation. All rights reserved.
+ */
+
+#ifndef __H_HFI_PROPERTY_H__
+#define __H_HFI_PROPERTY_H__
+
+#define HFI_PROP_BEGIN                                          0x03000000
+#define HFI_PROP_IMAGE_VERSION                                  0x03000001
+#define HFI_PROP_INTRA_FRAME_POWER_COLLAPSE                     0x03000002
+#define HFI_PROP_UBWC_MAX_CHANNELS                              0x03000003
+#define HFI_PROP_UBWC_MAL_LENGTH                                0x03000004
+#define HFI_PROP_UBWC_HBB                                       0x03000005
+#define HFI_PROP_UBWC_BANK_SWZL_LEVEL1                          0x03000006
+#define HFI_PROP_UBWC_BANK_SWZL_LEVEL2                          0x03000007
+#define HFI_PROP_UBWC_BANK_SWZL_LEVEL3                          0x03000008
+#define HFI_PROP_UBWC_BANK_SPREADING                            0x03000009
+
+enum hfi_debug_config {
+    HFI_DEBUG_CONFIG_DEFAULT    = 0,
+    HFI_DEBUG_CONFIG_CLRDBGQ    = BIT(0),
+    HFI_DEBUG_CONFIG_WFI        = BIT(1),
+    HFI_DEBUG_CONFIG_ARM9WD     = BIT(2),
+};
+#define HFI_PROP_DEBUG_CONFIG                                   0x0300000a
+
+enum hfi_debug_log_level {
+    HFI_DEBUG_LOG_NONE      = 0,
+    HFI_DEBUG_LOG_ERROR     = BIT(0),
+    HFI_DEBUG_LOG_FATAL     = BIT(1),
+    HFI_DEBUG_LOG_PERF      = BIT(2),
+    HFI_DEBUG_LOG_HIGH      = BIT(3),
+    HFI_DEBUG_LOG_MEDIUM    = BIT(4),
+    HFI_DEBUG_LOG_LOW       = BIT(5),
+};
+#define HFI_PROP_DEBUG_LOG_LEVEL                                0x0300000b
+
+enum hfi_codec_type {
+    HFI_CODEC_DECODE_AVC   = 1,
+    HFI_CODEC_ENCODE_AVC   = 2,
+    HFI_CODEC_DECODE_HEVC  = 3,
+    HFI_CODEC_ENCODE_HEVC  = 4,
+    HFI_CODEC_DECODE_VP9   = 5,
+    HFI_CODEC_DECODE_MPEG2 = 6,
+};
+#define HFI_PROP_CODEC                                          0x03000100
+
+enum hfi_color_format {
+    HFI_COLOR_FMT_OPAQUE        = 0,
+    HFI_COLOR_FMT_NV12          = 1,
+    HFI_COLOR_FMT_NV12_UBWC     = 2,
+    HFI_COLOR_FMT_P010          = 3,
+    HFI_COLOR_FMT_TP10_UBWC     = 4,
+    HFI_COLOR_FMT_RGBA8888      = 5,
+    HFI_COLOR_FMT_RGBA8888_UBWC = 6,
+    HFI_COLOR_FMT_NV21          = 7,
+};
+#define HFI_PROP_COLOR_FORMAT                                   0x03000101
+
+#define HFI_PROP_SECURE                                         0x03000102
+
+#define HFI_BITMASK_ALIGN_WIDTH      0xffff0000
+#define HFI_BITMASK_ALIGN_HEIGHT     0x0000ffff
+#define HFI_PROP_ALIGN_RESOLUTION                               0x03000103
+
+#define HFI_BITMASK_CROP_WIDTH       0xffff0000
+#define HFI_BITMASK_CROP_HEIGHT      0x0000ffff
+#define HFI_PROP_CROP_RESOLUTION                                0x03000104
+
+#define HFI_BITMASK_FRAME_COORDINATE_TOP   0xffff0000
+#define HFI_BITMASK_FRAME_COORDINATE_LEFT  0x0000ffff
+#define HFI_PROP_CROP_COORDINATE_TOP_LEFT                       0x03000105
+
+#define HFI_PROP_REALTIME                                       0x03000106
+
+enum hfi_avc_profile_type {
+    HFI_AVC_PROFILE_BASELINE             = 0,
+    HFI_AVC_PROFILE_CONSTRAINED_BASELINE = 1,
+    HFI_AVC_PROFILE_MAIN                 = 2,
+    HFI_AVC_PROFILE_HIGH                 = 4,
+    HFI_AVC_PROFILE_CONSTRAINED_HIGH     = 17
+};
+
+enum hfi_hevc_profile_type {
+    HFI_HEVC_HEVC_PROFILE_MAIN          = 0,
+    HFI_HEVC_PROFILE_MAIN_STILL_PICTURE = 1,
+    HFI_HEVC_PROFILE_MAIN_10            = 2,
+};
+
+enum hfi_vp9_profile_type {
+    HFI_VP9_PROFILE_0 = 0,
+    HFI_VP9_PROFILE_1 = 1,
+    HFI_VP9_PROFILE_2 = 2,
+    HFI_VP9_PROFILE_3 = 3,
+};
+
+enum hfi_mpeg2_profile_type {
+    HFI_MPEG2_PROFILE_SIMPLE = 0,
+    HFI_MPEG2_PROFILE_MAIN   = 1,
+};
+
+#define HFI_PROP_PROFILE                                        0x03000107
+
+enum hfi_avc_level_type {
+    HFI_AVC_LEVEL_1_0 = 0,
+    HFI_AVC_LEVEL_1B  = 1,
+    HFI_AVC_LEVEL_1_1 = 2,
+    HFI_AVC_LEVEL_1_2 = 3,
+    HFI_AVC_LEVEL_1_3 = 4,
+    HFI_AVC_LEVEL_2_0 = 5,
+    HFI_AVC_LEVEL_2_1 = 6,
+    HFI_AVC_LEVEL_2_2 = 7,
+    HFI_AVC_LEVEL_3_0 = 8,
+    HFI_AVC_LEVEL_3_1 = 9,
+    HFI_AVC_LEVEL_3_2 = 10,
+    HFI_AVC_LEVEL_4_0 = 11,
+    HFI_AVC_LEVEL_4_1 = 12,
+    HFI_AVC_LEVEL_4_2 = 13,
+    HFI_AVC_LEVEL_5_0 = 14,
+    HFI_AVC_LEVEL_5_1 = 15,
+    HFI_AVC_LEVEL_5_2 = 16,
+    HFI_AVC_LEVEL_6_0 = 17,
+    HFI_AVC_LEVEL_6_1 = 18,
+    HFI_AVC_LEVEL_6_2 = 19,
+};
+
+enum hfi_hevc_level_type {
+    HFI_HEVC_LEVEL_1   = 0,
+    HFI_HEVC_LEVEL_2   = 1,
+    HFI_HEVC_LEVEL_2_1 = 2,
+    HFI_HEVC_LEVEL_3   = 3,
+    HFI_HEVC_LEVEL_3_1 = 4,
+    HFI_HEVC_LEVEL_4   = 5,
+    HFI_HEVC_LEVEL_4_1 = 6,
+    HFI_HEVC_LEVEL_5   = 7,
+    HFI_HEVC_LEVEL_5_1 = 8,
+    HFI_HEVC_LEVEL_5_2 = 9,
+    HFI_HEVC_LEVEL_6   = 10,
+    HFI_HEVC_LEVEL_6_1 = 11,
+    HFI_HEVC_LEVEL_6_2 = 12,
+};
+
+enum hfi_vp9_level_type {
+    HFI_VP9_LEVEL_1  = 0,
+    HFI_VP9_LEVEL_11 = 1,
+    HFI_VP9_LEVEL_2  = 2,
+    HFI_VP9_LEVEL_21 = 3,
+    HFI_VP9_LEVEL_3  = 4,
+    HFI_VP9_LEVEL_31 = 5,
+    HFI_VP9_LEVEL_4  = 6,
+    HFI_VP9_LEVEL_41 = 7,
+    HFI_VP9_LEVEL_5  = 8,
+    HFI_VP9_LEVEL_51 = 9,
+    HFI_VP9_LEVEL_6  = 10,
+    HFI_VP9_LEVEL_61 = 11,
+};
+
+enum hfi_mpeg2_level_type {
+    HFI_MPEG2_LEVEL_LOW       = 0,
+    HFI_MPEG2_LEVEL_MAIN      = 1,
+    HFI_MPEG2_LEVEL_HIGH_1440 = 2,
+    HFI_MPEG2_LEVEL_HIGH      = 3,
+};
+
+enum hfi_codec_level_type {
+    HFI_LEVEL_UNKNOWN = 0xFFFFFFFF,
+};
+
+#define HFI_PROP_LEVEL                                          0x03000108
+
+
+enum hfi_hevc_tier_type {
+    HFI_HEVC_TIER_MAIN = 0,
+    HFI_HEVC_TIER_HIGH = 1,
+};
+#define HFI_PROP_TIER                                           0x03000109
+
+#define HFI_PROP_STAGE                                          0x0300010a
+
+#define HFI_PROP_PIPE                                           0x0300010b
+
+#define HFI_PROP_FRAME_RATE                                     0x0300010c
+
+#define HFI_BITMASK_CONCEAL_LUMA       0x000003ff
+#define HFI_BITMASK_CONCEAL_CB         0x000ffC00
+#define HFI_BITMASK_CONCEAL_CR         0x3ff00000
+#define HFI_PROP_CONCEAL_COLOR_8BIT                             0x0300010d
+
+#define HFI_BITMASK_CONCEAL_LUMA       0x000003ff
+#define HFI_BITMASK_CONCEAL_CB         0x000ffC00
+#define HFI_BITMASK_CONCEAL_CR         0x3ff00000
+#define HFI_PROP_CONCEAL_COLOR_10BIT                            0x0300010e
+
+#define HFI_BITMASK_LUMA_BIT_DEPTH     0xffff0000
+#define HFI_BITMASK_CHROMA_BIT_DEPTH   0x0000ffff
+#define HFI_PROP_LUMA_CHROMA_BIT_DEPTH                          0x0300010f
+
+#define HFI_BITMASK_FRAME_MBS_ONLY_FLAG           0x00000001
+#define HFI_BITMASK_MB_ADAPTIVE_FRAME_FIELD_FLAG  0x00000002
+#define HFI_PROP_CODED_FRAMES                                   0x03000120
+
+#define HFI_PROP_CABAC_SESSION                                  0x03000121
+
+#define HFI_PROP_8X8_TRANSFORM                                  0x03000122
+
+#define HFI_PROP_BUFFER_HOST_MAX_COUNT                          0x03000123
+
+#define HFI_PROP_BUFFER_FW_MIN_OUTPUT_COUNT                     0x03000124
+
+#define HFI_PROP_BUFFER_MAXDPB_COUNT                            0x03000125
+
+#define HFI_PROP_BUFFER_MAX_NUM_REFERENCE                       0x03000126
+
+#define HFI_PROP_BUFFER_VUI_RESTRICTION                         0x03000127
+
+#define HFI_PROP_PIC_ORDER_CNT_TYPE                             0x03000128
+
+enum hfi_deblock_mode {
+    HFI_DB_MODE_DISABLE             = 0,
+    HFI_DB_MODE_SKIP_SLICE_BOUNDARY = BIT(0),
+    HFI_DB_MODE_ALL_BOUNDARY        = BIT(1),
+};
+#define HFI_PROP_DEBLOCKING_MODE                                0x03000129
+
+enum hfi_rate_control {
+    HFI_RC_OFF      = 0x00000000,
+    HFI_RC_VBR_CFR  = 0x00000001,
+    HFI_RC_CBR_CFR  = 0x00000002,
+    HFI_RC_CBR_VFR  = 0x00000003,
+    HFI_RC_CQ       = 0x00000004,
+    HFI_RC_LOSSLESS = 0x00000005,
+};
+#define HFI_PROP_RATE_CONTROL                                   0x0300012a
+
+#define HFI_PROP_FRAMERATE_BASED_RATE_CONTROL                   0x0300012b
+
+#define HFI_PROP_CONTENT_ADAPTIVE_CODING                        0x0300012c
+
+#define HFI_PROP_CONST_QUALITY_BITRATE_BOOST                    0x0300012d
+
+#define HFI_BITMASK_QP_I          0x000000ff
+#define HFI_BITMASK_QP_P          0x0000ff00
+#define HFI_BITMASK_QP_B          0x00ff0000
+#define HFI_BITMASK_QP_ENABLE     0x0f000000
+#define HFI_BITMASK_QP_LAYERS     0xf0000000
+#define HFI_PROP_QP_PACKED                                      0x0300012e
+
+#define HFI_PROP_MIN_QP_PACKED                                  0x0300012f
+
+#define HFI_PROP_MAX_QP_PACKED                                  0x03000130
+
+#define HFI_PROP_IR_RANDOM_PERIOD                               0x03000131
+
+#define HFI_PROP_MULTI_SLICE_MB_COUNT                           0x03000132
+
+#define HFI_PROP_MULTI_SLICE_BYTES_COUNT                        0x03000133
+
+#define HFI_PROP_LTR_COUNT                                      0x03000134
+
+#define HFI_PROP_LTR_MARK                                       0x03000135
+
+#define HFI_PROP_LTR_USE                                        0x03000136
+
+#define HFI_PROP_LTR_MARK_USE_DETAILS                           0x03000137
+
+enum hfi_layer_encoding_type {
+    HFI_HIER_P_SLIDING_WINDOW = 0x1,
+    HFI_HIER_P_HYBRID_LTR     = 0x2,
+    HFI_HIER_B                = 0x4,
+};
+#define HFI_PROP_LAYER_ENCODING_TYPE                            0x03000138
+
+#define HFI_PROP_LAYER_COUNT                                    0x03000139
+
+#define HFI_BITMASK_CHROMA_CB_OFFSET     0x0000ffff
+#define HFI_BITMASK_CHROMA_CR_OFFSET     0xffff0000
+#define HFI_PROP_CHROMA_QP_OFFSET                               0x0300013a
+
+#define HFI_PROP_TOTAL_BITRATE                                  0x0300013b
+
+#define HFI_PROP_BITRATE_LAYER1                                 0x0300013c
+
+#define HFI_PROP_BITRATE_LAYER2                                 0x0300013d
+
+#define HFI_PROP_BITRATE_LAYER3                                 0x0300013e
+
+#define HFI_PROP_BITRATE_LAYER4                                 0x0300013f
+
+#define HFI_PROP_BITRATE_LAYER5                                 0x03000140
+
+#define HFI_PROP_BITRATE_LAYER6                                 0x03000141
+
+#define HFI_PROP_BASELAYER_PRIORITYID                           0x03000142
+
+#define HFI_PROP_CONSTANT_QUALITY                               0x03000143
+
+#define HFI_PROP_HEIC_GRID_ENABLE                               0x03000144
+
+#define HFI_PROP_REQUEST_SYNC_FRAME                             0x03000145
+
+#define HFI_PROP_MAX_GOP_FRAMES                                 0x03000146
+
+#define HFI_PROP_MAX_B_FRAMES                                   0x03000147
+
+enum hfi_quality_mode {
+    HFI_MODE_MAX_QUALITY = BIT(0),
+    HFI_MODE_POWER_SAVE  = BIT(1),
+};
+#define HFI_PROP_QUALITY_MODE                                   0x03000148
+
+enum hfi_seq_header_mode {
+    HFI_SEQ_HEADER_SEPERATE_FRAME          = BIT(0),
+    HFI_SEQ_HEADER_JOINED_WITH_1ST_FRAME   = BIT(1),
+    HFI_SEQ_HEADER_PREFIX_WITH_SYNC_FRAME  = BIT(2),
+    HFI_SEQ_HEADER_METADATA                = BIT(3),
+};
+#define HFI_PROP_SEQ_HEADER_MODE                                0x03000149
+
+#define HFI_PROP_METADATA_SEQ_HEADER_NAL                        0x0300014a
+
+enum hfi_rotation {
+    HFI_ROTATION_NONE = 0x00000000,
+    HFI_ROTATION_90   = 0x00000001,
+    HFI_ROTATION_180  = 0x00000002,
+    HFI_ROTATION_270  = 0x00000003,
+};
+#define HFI_PROP_ROTATION                                       0x0300014b
+
+enum hfi_flip {
+    HFI_FLIP_NONE       = 0,
+    HFI_FLIP_HORIZONTAL = BIT(0),
+    HFI_FLIP_VERTICAL   = BIT(1),
+};
+#define HFI_PROP_FLIP                                           0x0300014c
+
+#define HFI_PROP_SCALAR                                         0x0300014d
+
+enum hfi_blur_types {
+    HFI_BLUR_NONE     = 0,
+    HFI_BLUR_EXTERNAL = BIT(0),
+    HFI_BLUR_ADAPTIVE = BIT(1),
+};
+#define HFI_PROP_BLUR_TYPES                                     0x0300014e
+
+#define HFI_BITMASK_BLUR_WIDTH        0xffff0000
+#define HFI_BITMASK_BLUR_HEIGHT       0x0000ffff
+#define HFI_PROP_BLUR_RESOLUTION                                0x0300014f
+
+#define HFI_BITMASK_SPS_ID            0x000000ff
+#define HFI_BITMASK_PPS_ID            0x0000ff00
+#define HFI_BITMASK_VPS_ID            0x00ff0000
+#define HFI_PROP_SEQUENCE_HEADER_IDS                            0x03000150
+
+#define HFI_PROP_AUD                                            0x03000151
+
+#define HFI_PROP_VUI_TIMING_INFO                                0x03000152
+
+#define HFI_PROP_DPB_LUMA_CHROMA_MISR                           0x03000153
+
+#define HFI_PROP_OPB_LUMA_CHROMA_MISR                           0x03000154
+
+#define HFI_BITMASK_QP_I               0x000000ff
+#define HFI_BITMASK_QP_P               0x0000ff00
+#define HFI_BITMASK_QP_B               0x00ff0000
+#define HFI_BITMASK_QP_ENABLE          0x0f000000
+#define HFI_BITMASK_QP_LAYERS          0xf0000000
+#define HFI_PROP_SIGNAL_COLOR_INFO                              0x03000155
+
+enum hfi_interlace_info {
+    HFI_INTERLACE_INFO_NONE                 = 0,
+    HFI_FRAME_PROGRESSIVE                   = BIT(0),
+    HFI_FRAME_MBAFF                         = BIT(1),
+    HFI_FRAME_INTERLEAVE_TOPFIELD_FIRST     = BIT(2),
+    HFI_FRAME_INTERLEAVE_BOTTOMFIELD_FIRST  = BIT(3),
+    HFI_FRAME_INTERLACE_TOPFIELD_FIRST      = BIT(4),
+    HFI_FRAME_INTERLACE_BOTTOMFIELD_FIRST   = BIT(5),
+};
+#define HFI_PROP_INTERLACE_INFO                                 0x03000156
+
+#define HFI_PROP_CSC                                            0x03000157
+
+#define HFI_PROP_CSC_MATRIX                                     0x03000158
+
+#define HFI_PROP_CSC_BIAS                                       0x03000159
+
+#define HFI_PROP_CSC_LIMIT                                      0x0300015a
+
+#define HFI_PROP_DECODE_ORDER_OUTPUT                            0x0300015b
+
+#define HFI_PROP_TIMESTAMP                                      0x0300015c
+
+#define HFI_PROP_FRAMERATE_FROM_BITSTREAM                       0x0300015d
+
+#define HFI_PROP_SEI_RECOVERY_POINT                             0x0300015e
+
+#define HFI_PROP_CONEALED_MB_COUNT                              0x0300015f
+
+#define HFI_BITMASK_SAR_WIDTH        0xffff0000
+#define HFI_BITMASK_SAR_HEIGHT       0x0000ffff
+#define HFI_PROP_SAR_RESOLUTION                                 0x03000160
+
+#define HFI_PROP_HISTOGRAM_INFO                                 0x03000161
+
+enum hfi_picture_type {
+    HFI_PICTURE_TYPE_IDR = BIT(0),
+    HFI_PICTURE_TYPE_P   = BIT(1),
+    HFI_PICTURE_TYPE_B   = BIT(2),
+    HFI_PICTURE_TYPE_I   = BIT(3),
+    HFI_PICTURE_TYPE_CRA = BIT(4),
+    HFI_PICTURE_TYPE_BLA = BIT(5),
+};
+#define HFI_PROP_PICTURE_TYPE                                   0x03000162
+
+#define HFI_PROP_SEI_MASTERING_DISPLAY_COLOUR                   0x03000163
+
+#define HFI_PROP_SEI_CONTENT_LIGHT_LEVEL                        0x03000164
+
+#define HFI_PROP_SEI_HDR10PLUS_USERDATA                         0x03000165
+
+#define HFI_PROP_SEI_STREAM_USERDATA                            0x03000166
+
+#define HFI_PROP_CVP_STAT_INFO                                  0x03000167
+
+#define HFI_PROP_DEC_DEFAULT_HEADER                             0x03000168
+
+#define HFI_PROP_DEC_START_FROM_RAP_FRAME                       0x03000169
+
+#define HFI_PROP_TAG_NOT_PROPAGATED_TO_OUTPUT                   0x0300016a
+
+#define HFI_PROP_BUFFER_TAG                                     0x0300016b
+
+#define HFI_PROP_BUFFER_MARK                                    0x0300016c
+
+#define HFI_PROP_SUBFRAME_OUTPUT                                0x0300016d
+
+#define HFI_PROP_ENC_QP_METADATA                                0x0300016e
+
+#define HFI_PROP_DEC_QP_METADATA                                0x0300016f
+
+#define HFI_PROP_SEI_FRAME_PACKING_ARRANGEMENT                  0x03000170
+
+#define HFI_PROP_SEI_PAN_SCAN_RECT                              0x03000171
+
+#define HFI_PROP_THUMBNAIL_MODE                                 0x03000172
+
+#define HFI_PROP_ROI_INFO                                       0x03000173
+
+#define HFI_PROP_END                                            0x03FFFFFF
+
+#define HFI_SESSION_ERROR_BEGIN                                 0x04000000
+
+#define HFI_ERROR_UNKNOWN_SESSION                               0x04000001
+
+#define HFI_ERROR_MAX_SESSIONS                                  0x04000002
+
+#define HFI_ERROR_UNSUPPORTED                                   0x04000003
+
+#define HFI_SESSION_ERROR_END                                   0x04FFFFFF
+
+#define HFI_SYSTEM_ERROR_BEGIN                                  0x05000000
+
+#define HFI_SYS_ERROR_WD_TIMEOUT                                0x05000001
+
+#define HFI_SYS_ERROR_NOC                                       0x05000002
+
+#define HFI_SYSTEM_ERROR_END                                    0x05FFFFFF
+
+#define HFI_INFORMATION_BEGIN                                   0x06000000
+
+#define HFI_INFO_UNSUPPORTED                                    0x06000001
+
+#define HFI_INFO_BITSTREAM_CORRUPT                              0x06000002
+
+#define HFI_INFORMATION_END                                     0x06FFFFFF
+
+#endif //__H_HFI_PROPERTY_H__

driver/vidc/inc/msm_vidc_core.h

@@ -101,6 +101,8 @@ struct msm_vidc_core {
 	struct msm_vidc_venus_ops             *venus_ops;
 	struct msm_vidc_session_ops           *session_ops;
 	struct msm_vidc_memory_ops            *mem_ops;
+	u32                                    header_id;
+	u32                                    packet_id;
 };
 
 #endif // _MSM_VIDC_CORE_H_

driver/vidc/inc/msm_vidc_platform.h

@@ -45,6 +45,8 @@ struct msm_vidc_ubwc_config_data {
 		u32 mal_length_override : 1;
 		u32 hb_override : 1;
 		u32 bank_swzl_level_override : 1;
+		u32 bank_swz2_level_override : 1;
+		u32 bank_swz3_level_override : 1;
 		u32 bank_spreading_override : 1;
 		u32 reserved : 27;
 	} override_bit_info;
@@ -53,6 +55,8 @@ struct msm_vidc_ubwc_config_data {
 	u32 mal_length;
 	u32 highest_bank_bit;
 	u32 bank_swzl_level;
+	u32 bank_swz2_level;
+	u32 bank_swz3_level;
 	u32 bank_spreading;
 };
 

driver/vidc/src/hfi_packet.c

@@ -7,45 +7,512 @@
 #include "msm_vidc_core.h"
 #include "msm_vidc_inst.h"
 #include "msm_vidc_debug.h"
+#include "msm_vidc_platform.h"
+
+static u32 get_hfi_buffer_type(enum msm_vidc_domain_type domain,
+	enum msm_vidc_buffer_type buf_type)
+{
+	switch (buf_type) {
+	case MSM_VIDC_QUEUE:
+		return 0; /* TODO */
+	case MSM_VIDC_INPUT:
+		if (domain == MSM_VIDC_DECODER)
+			return HFI_PORT_BITSTREAM;
+		else
+			return HFI_PORT_RAW;
+	case MSM_VIDC_OUTPUT:
+		if (domain == MSM_VIDC_DECODER)
+			return HFI_PORT_RAW;
+		else
+			return HFI_PORT_BITSTREAM;
+	case MSM_VIDC_INPUT_META:
+	case MSM_VIDC_OUTPUT_META:
+		return HFI_BUFFER_METADATA;
+	case MSM_VIDC_DPB:
+		return HFI_BUFFER_DPB;
+	case MSM_VIDC_ARP:
+		return HFI_BUFFER_ARP;
+	case MSM_VIDC_LINE:
+		return HFI_BUFFER_LINE;
+	case MSM_VIDC_BIN:
+		return HFI_BUFFER_BIN;
+	default:
+		d_vpr_e("%s: Invalid buffer type %d\n",
+			__func__, buf_type);
+		return 0;
+	}
+}
+
+static u32 get_hfi_buffer_flags(enum msm_vidc_buffer_attributes attr)
+{
+	switch (attr) {
+	case MSM_VIDC_DEFERRED_SUBMISSION:
+		return 0; /*not sure what it should be mapped to??*/
+	case MSM_VIDC_READ_ONLY:
+		return HFI_BUF_HOST_FLAG_READONLY;
+	case MSM_VIDC_PENDING_RELEASE:
+		return HFI_BUF_HOST_FLAG_RELEASE;
+	default:
+		d_vpr_e("%s: Invalid buffer attribute %d\n",
+			__func__, attr);
+		return 0;
+	}
+}
+
+int hfi_create_header(u8 *pkt, u32 session_id,
+	u32 header_id, u32 num_packets, u32 total_size)
+{
+	struct hfi_header *hdr = (struct hfi_header *)pkt;
+
+	memset(hdr, 0, sizeof(struct hfi_header));
+
+	hdr->size = total_size;
+	hdr->session_id = session_id;
+	hdr->header_id = header_id;
+	hdr->num_packets = num_packets;
+	return 0;
+}
+
+int hfi_create_packet(u8 *packet, u32 packet_size, u32 *offset,
+	u32 pkt_type, u32 pkt_flags, u32 payload_type, u32 port,
+	u32 packet_id, void *payload, u32 payload_size)
+{
+	u32 available_size = packet_size - *offset;
+	u32 pkt_size = sizeof(struct hfi_packet) + payload_size;
+	struct hfi_packet *pkt = (struct hfi_packet *)(packet + *offset);
+
+	if (available_size < pkt_size) {
+		d_vpr_e("%s: Bad packet Size for packet type %d\n",
+			__func__, pkt_type);
+		return -EINVAL;
+	}
+
+	memset(pkt, 0, pkt_size);
+
+	pkt->size = pkt_size;
+	pkt->type = pkt_type;
+	pkt->flags = pkt_flags;
+	pkt->payload_info = payload_type;
+	pkt->port = port;
+	pkt->packet_id = packet_id;
+	if (payload_size)
+		memcpy((u8 *)pkt + sizeof(struct hfi_packet),
+			payload, payload_size);
+	*offset = *offset + pkt->size;
+	return 0;
+}
+
+int hfi_create_buffer(u8 *packet, u32 packet_size, u32 *offset,
+	enum msm_vidc_domain_type domain, struct msm_vidc_buffer *data)
+{
+	u32 available_size = packet_size - *offset;
+	u32 buf_size = sizeof(struct hfi_buffer);
+	struct hfi_buffer *buf = (struct hfi_buffer *)packet;
+
+	if (available_size < sizeof(struct hfi_buffer)) {
+		d_vpr_e("%s: Bad buffer Size for buffer type %d\n",
+			__func__, data->type);
+		return -EINVAL;
+	}
+
+	memset(buf, 0, buf_size);
+
+	buf->type = get_hfi_buffer_type(domain, data->type);
+	buf->index = data->index;
+	buf->base_address = data->device_addr;
+	buf->addr_offset = 0;
+	buf->buffer_size = data->buffer_size;
+	buf->data_offset = data->data_offset;
+	buf->data_size = data->data_size;
+	buf->flags = get_hfi_buffer_flags(data->attr);
+	buf->timestamp = data->timestamp;
+	*offset = *offset + buf_size;
+	return 0;
+}
 
 int hfi_packet_sys_init(struct msm_vidc_core *core,
-		void *packet, u32 pkt_size)
+	u8 *pkt, u32 pkt_size)
 {
-	d_vpr_h("%s()\n", __func__);
+	int rc = 0;
-	return 0;
+	u32 offset = 0, payload = 0, num_packets = 0;
+
+	if (!core || !pkt) {
+		d_vpr_e("%s: Invalid params\n", __func__);
+		return -EINVAL;
 	}
 
-int hfi_packet_sys_pc_prep(struct msm_vidc_core *core,
+	if (pkt_size < sizeof(struct hfi_header)) {
-		void *packet, u32 pkt_size)
+		d_vpr_e("%s: Invalid packet size\n", __func__);
-{
+		return -EINVAL;
-	d_vpr_h("%s()\n", __func__);
-	return 0;
 	}
 
-int hfi_packet_sys_debug_config(struct msm_vidc_core *core,
+	/* HFI_CMD_SYSTEM_INIT */
-		void *packet, u32 pkt_size, u32 config)
+	offset = sizeof(struct hfi_header);
-{
+	payload = HFI_VIDEO_ARCH_OX;
-	d_vpr_h("%s()\n", __func__);
+	rc = hfi_create_packet(pkt, pkt_size, &offset,
-	return 0;
+				   HFI_CMD_INIT,
+				   (HFI_HOST_FLAGS_RESPONSE_REQUIRED |
+				   HFI_HOST_FLAGS_INTR_REQUIRED |
+				   HFI_HOST_FLAGS_NON_DISCARDABLE),
+				   HFI_PAYLOAD_U32,
+				   HFI_PORT_NONE,
+				   core->packet_id++,
+				   &payload,
+				   sizeof(u32));
+	if (rc)
+		goto err_sys_init;
+	num_packets++;
+
+	/* HFI_PROP_INTRA_FRAME_POWER_COLLAPSE */
+	payload = 0;
+	rc = hfi_create_packet(pkt, pkt_size, &offset,
+				   HFI_PROP_INTRA_FRAME_POWER_COLLAPSE,
+				   HFI_HOST_FLAGS_NONE,
+				   HFI_PAYLOAD_U32,
+				   HFI_PORT_NONE,
+				   core->packet_id++,
+				   &payload,
+				   sizeof(u32));
+	if (rc)
+		goto err_sys_init;
+	num_packets++;
+
+	/* HFI_PROP_UBWC_MAX_CHANNELS */
+	payload = core->platform->data.ubwc_config->max_channels;
+	rc = hfi_create_packet(pkt, pkt_size, &offset,
+				   HFI_PROP_UBWC_MAX_CHANNELS,
+				   HFI_HOST_FLAGS_NONE,
+				   HFI_PAYLOAD_U32,
+				   HFI_PORT_NONE,
+				   core->packet_id++,
+				   &payload,
+				   sizeof(u32));
+	if (rc)
+		goto err_sys_init;
+	num_packets++;
+
+	/* HFI_PROP_UBWC_MAL_LENGTH */
+	payload = core->platform->data.ubwc_config->mal_length;
+	rc = hfi_create_packet(pkt, pkt_size, &offset,
+				   HFI_PROP_UBWC_MAL_LENGTH,
+				   HFI_HOST_FLAGS_NONE,
+				   HFI_PAYLOAD_U32,
+				   HFI_PORT_NONE,
+				   core->packet_id++,
+				   &payload,
+				   sizeof(u32));
+	if (rc)
+		goto err_sys_init;
+	num_packets++;
+
+	/* HFI_PROP_UBWC_HBB */
+	payload = core->platform->data.ubwc_config->highest_bank_bit;
+	rc = hfi_create_packet(pkt, pkt_size, &offset,
+				   HFI_PROP_UBWC_HBB,
+				   HFI_HOST_FLAGS_NONE,
+				   HFI_PAYLOAD_U32,
+				   HFI_PORT_NONE,
+				   core->packet_id++,
+				   &payload,
+				   sizeof(u32));
+	if (rc)
+		goto err_sys_init;
+	num_packets++;
+
+	/* HFI_PROP_UBWC_BANK_SWZL_LEVEL1 */
+	payload = core->platform->data.ubwc_config->bank_swzl_level;
+	rc = hfi_create_packet(pkt, pkt_size, &offset,
+				   HFI_PROP_UBWC_BANK_SWZL_LEVEL1,
+				   HFI_HOST_FLAGS_NONE,
+				   HFI_PAYLOAD_U32,
+				   HFI_PORT_NONE,
+				   core->packet_id++,
+				   &payload,
+				   sizeof(u32));
+	if (rc)
+		goto err_sys_init;
+	num_packets++;
+
+	/* HFI_PROP_UBWC_BANK_SWZL_LEVEL2 */
+	payload = core->platform->data.ubwc_config->bank_swz2_level;
+	rc = hfi_create_packet(pkt, pkt_size, &offset,
+				   HFI_PROP_UBWC_BANK_SWZL_LEVEL2,
+				   HFI_HOST_FLAGS_NONE,
+				   HFI_PAYLOAD_U32,
+				   HFI_PORT_NONE,
+				   core->packet_id++,
+				   &payload,
+				   sizeof(u32));
+	if (rc)
+		goto err_sys_init;
+	num_packets++;
+
+	/* HFI_PROP_UBWC_BANK_SWZL_LEVEL3 */
+	payload = core->platform->data.ubwc_config->bank_swz3_level;
+	rc = hfi_create_packet(pkt, pkt_size, &offset,
+				   HFI_PROP_UBWC_BANK_SWZL_LEVEL3,
+				   HFI_HOST_FLAGS_NONE,
+				   HFI_PAYLOAD_U32,
+				   HFI_PORT_NONE,
+				   core->packet_id++,
+				   &payload,
+				   sizeof(u32));
+	if (rc)
+		goto err_sys_init;
+	num_packets++;
+
+	/* HFI_PROP_UBWC_BANK_SPREADING */
+	payload = core->platform->data.ubwc_config->bank_spreading;
+	rc = hfi_create_packet(pkt, pkt_size, &offset,
+				   HFI_PROP_UBWC_BANK_SPREADING,
+				   HFI_HOST_FLAGS_NONE,
+				   HFI_PAYLOAD_U32,
+				   HFI_PORT_NONE,
+				   core->packet_id++,
+				   &payload,
+				   sizeof(u32));
+	if (rc)
+		goto err_sys_init;
+	num_packets++;
+
+	rc = hfi_create_header(pkt, 0 /*session_id*/,
+				   core->header_id++,
+				   num_packets,
+				   offset);
+
+	if (rc)
+		goto err_sys_init;
+
+	d_vpr_h("System init packet created\n");
+	return rc;
+
+err_sys_init:
+	d_vpr_e("%s: create packet failed\n", __func__);
+	return rc;
 }
 
 int hfi_packet_image_version(struct msm_vidc_core *core,
-		void *packet, u32 pkt_size)
+	u8 *pkt, u32 pkt_size)
 {
-	d_vpr_h("%s()\n", __func__);
+	int rc = 0;
-	return 0;
+	u32 num_packets = 0, offset = 0;
+
+	if (!core || !pkt) {
+		d_vpr_e("%s: Invalid params\n", __func__);
+		return -EINVAL;
 	}
 
-int hfi_packet_session_open(struct msm_vidc_inst *inst,
+	/* HFI_PROP_IMAGE_VERSION */
-		void *packet, u32 pkt_size)
+	offset = sizeof(struct hfi_header);
-{
+	rc = hfi_create_packet(pkt, pkt_size, &offset,
-	d_vpr_h("%s()\n", __func__);
+				   HFI_PROP_IMAGE_VERSION,
-	return 0;
+				   (HFI_HOST_FLAGS_RESPONSE_REQUIRED |
+				   HFI_HOST_FLAGS_INTR_REQUIRED |
+				   HFI_HOST_FLAGS_GET_PROPERTY),
+				   HFI_PAYLOAD_NONE,
+				   HFI_PORT_NONE,
+				   core->packet_id++,
+				   NULL, 0);
+	if (rc)
+		goto err_img_version;
+	num_packets++;
+
+	rc = hfi_create_header(pkt, 0 /*session_id*/,
+				   core->header_id++,
+				   num_packets,
+				   offset);
+
+	if (rc)
+		goto err_img_version;
+
+	d_vpr_h("Image version packet created\n");
+	return rc;
+
+err_img_version:
+	d_vpr_e("%s: create packet failed\n", __func__);
+	return rc;
 }
 
-int hfi_packet_session_close(struct msm_vidc_inst *inst,
+int hfi_packet_sys_pc_prep(struct msm_vidc_core *core,
-		void *packet, u32 pkt_size)
+	u8 *pkt, u32 pkt_size)
 {
-	d_vpr_h("%s()\n", __func__);
+	int rc = 0;
-	return 0;
+	u32 num_packets = 0, offset = 0;
+
+	if (!core || !pkt) {
+		d_vpr_e("%s: Invalid params\n", __func__);
+		return -EINVAL;
+	}
+
+	/* HFI_CMD_POWER_COLLAPSE */
+	offset = sizeof(struct hfi_header);
+	rc = hfi_create_packet(pkt, pkt_size, &offset,
+				   HFI_CMD_POWER_COLLAPSE,
+				   HFI_HOST_FLAGS_NONE,
+				   HFI_PAYLOAD_NONE,
+				   HFI_PORT_NONE,
+				   core->packet_id++,
+				   NULL, 0);
+	if (rc)
+		goto err_sys_pc;
+	num_packets++;
+
+	rc = hfi_create_header(pkt, 0 /*session_id*/,
+				   core->header_id++,
+				   num_packets,
+				   offset);
+
+	if (rc)
+		goto err_sys_pc;
+
+	d_vpr_h("Power collapse packet created\n");
+	return rc;
+
+err_sys_pc:
+	d_vpr_e("%s: create packet failed\n", __func__);
+	return rc;
+}
+
+int hfi_packet_sys_debug_config(struct msm_vidc_core *core,
+	u8 *pkt, u32 pkt_size, u32 debug_config)
+{
+	int rc = 0;
+	u32 num_packets = 0, offset = 0, payload = 0;
+
+	if (!core || !pkt) {
+		d_vpr_e("%s: Invalid params\n", __func__);
+		return -EINVAL;
+	}
+
+	/* HFI_PROP_DEBUG_CONFIG */
+	offset = sizeof(struct hfi_header);
+	payload = debug_config; /*TODO:Change later*/
+	rc = hfi_create_packet(pkt, pkt_size, &offset,
+				   HFI_PROP_DEBUG_CONFIG,
+				   HFI_HOST_FLAGS_NONE,
+				   HFI_PAYLOAD_U32_ENUM,
+				   HFI_PORT_NONE,
+				   core->packet_id++,
+				   &payload,
+				   sizeof(u32));
+	if (rc)
+		goto err_debug;
+	num_packets++;
+
+	/* HFI_PROP_DEBUG_LOG_LEVEL */
+	payload = debug_config; /*TODO:Change later*/
+	rc = hfi_create_packet(pkt, pkt_size, &offset,
+				   HFI_PROP_DEBUG_LOG_LEVEL,
+				   HFI_HOST_FLAGS_NONE,
+				   HFI_PAYLOAD_U32_ENUM,
+				   HFI_PORT_NONE,
+				   core->packet_id++,
+				   &payload,
+				   sizeof(u32));
+	if (rc)
+		goto err_debug;
+	num_packets++;
+
+	rc = hfi_create_header(pkt, 0 /*session_id*/,
+				   core->header_id++,
+				   num_packets,
+				   offset);
+
+	if (rc)
+		goto err_debug;
+
+	d_vpr_h("Debug packet created\n");
+	return rc;
+
+err_debug:
+	d_vpr_e("%s: create packet failed\n", __func__);
+	return rc;
+}
+
+int hfi_packet_session_command(struct msm_vidc_inst *inst,
+	u32 pkt_type, u32 flags, u32 port, u32 session_id,
+	u32 payload_type, void *payload, u32 payload_size)
+{
+	int rc = 0;
+	u32 num_packets = 0, offset = 0;
+	struct msm_vidc_core *core;
+
+	if (!inst || !inst->core) {
+		d_vpr_e("%s: Invalid params\n", __func__);
+		return -EINVAL;
+	}
+
+	core = inst->core;
+	offset = sizeof(struct hfi_header);
+	rc = hfi_create_packet(inst->packet,
+				inst->packet_size,
+				&offset,
+				pkt_type,
+				flags,
+				payload_type,
+				port,
+				core->packet_id++,
+				payload,
+				payload_size);
+	if (rc)
+		goto err_cmd;
+	num_packets++;
+
+	rc = hfi_create_header(inst->packet, session_id,
+				   core->header_id++,
+				   num_packets,
+				   offset);
+
+	if (rc)
+		goto err_cmd;
+
+	d_vpr_h("Command packet 0x%x created\n", pkt_type);
+	return rc;
+
+err_cmd:
+	d_vpr_e("%s: create packet failed\n", __func__);
+	return rc;
+}
+
+int hfi_packet_create_property(struct msm_vidc_inst *inst,
+	void *pkt, u32 pkt_size, u32 pkt_type, u32 flags,
+	u32 port, u32 payload, u32 payload_type, u32 payload_size)
+{
+	int rc = 0;
+	u32 num_packets = 0, offset = 0;
+	struct msm_vidc_core *core;
+
+	if (!inst || !inst->core || !pkt) {
+		d_vpr_e("%s: Invalid params\n", __func__);
+		return -EINVAL;
+	}
+
+	core = inst->core;
+	offset = sizeof(struct hfi_header);
+	rc = hfi_create_packet(pkt, pkt_size, &offset,
+				pkt_type,
+				flags,
+				payload_type,
+				port,
+				core->packet_id++,
+				&payload,
+				payload_size);
+	if (rc)
+		goto err_prop;
+	num_packets++;
+
+	rc = hfi_create_header(pkt, inst->session_id,
+				   core->header_id++,
+				   num_packets,
+				   offset);
+
+	if (rc)
+		goto err_prop;
+
+	d_vpr_h("Property packet 0x%x created\n", pkt_type);
+	return rc;
+
+err_prop:
+	d_vpr_e("%s: create packet failed\n", __func__);
+	return rc;
 }

driver/vidc/src/venus_hfi.c

@@ -2339,7 +2339,8 @@ int venus_hfi_suspend(struct msm_vidc_core *core)
 	return rc;
 }
 
-int venus_hfi_session_open(struct msm_vidc_core *core, struct msm_vidc_inst *inst)
+int venus_hfi_session_open(struct msm_vidc_core *core,
+	struct msm_vidc_inst *inst)
 {
 	int rc = 0;
 
@@ -2357,10 +2358,17 @@ int venus_hfi_session_open(struct msm_vidc_core *core, struct msm_vidc_inst *ins
 		d_vpr_e("%s(): inst packet allocation failed\n", __func__);
 		return -ENOMEM;
 	}
-	rc = hfi_packet_session_open(inst, inst->packet, inst->packet_size);
+	rc = hfi_packet_session_command(inst,
+					HFI_CMD_OPEN,
+					(HFI_HOST_FLAGS_RESPONSE_REQUIRED |
+					HFI_HOST_FLAGS_INTR_REQUIRED),
+					HFI_PORT_NONE,
+					0 /* session_id */,
+					HFI_PAYLOAD_U32,
+					&inst->session_id /*payload*/,
+					sizeof(u32));
 	if (rc)
 		return rc;
 
 	return rc;
 }
-