文件
android_kernel_samsung_sm86…/driver/vidc/src/hfi_packet.c
Sebastian Dang 5220f1f7f2 video: driver: Convert debug messages
Add new print format using msm_vidc_inst.
    Convert existing sid print statements.

Change-Id: Iba6774c31ff92997b4f8598e6a705f58bfa1b03c
2021-02-02 10:21:34 -08:00

639 行
15 KiB
C

// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2020, The Linux Foundation. All rights reserved.
*/
#include "hfi_packet.h"
#include "msm_vidc_core.h"
#include "msm_vidc_inst.h"
#include "msm_vidc_driver.h"
#include "msm_vidc_debug.h"
#include "msm_vidc_platform.h"
u32 get_hfi_port(struct msm_vidc_inst *inst,
enum msm_vidc_port_type port)
{
u32 hfi_port = HFI_PORT_NONE;
if (is_decode_session(inst)) {
switch(port) {
case INPUT_PORT:
case INPUT_META_PORT:
hfi_port = HFI_PORT_BITSTREAM;
break;
case OUTPUT_PORT:
case OUTPUT_META_PORT:
hfi_port = HFI_PORT_RAW;
break;
default:
i_vpr_e(inst, "%s: invalid port type %d\n",
__func__, port);
break;
}
} else if (is_encode_session(inst)) {
switch (port) {
case INPUT_PORT:
case INPUT_META_PORT:
hfi_port = HFI_PORT_RAW;
break;
case OUTPUT_PORT:
case OUTPUT_META_PORT:
hfi_port = HFI_PORT_BITSTREAM;
break;
default:
i_vpr_e(inst, "%s: invalid port type %d\n",
__func__, port);
break;
}
} else {
i_vpr_e(inst, "%s: invalid domain %#x\n",
__func__, inst->domain);
}
return hfi_port;
}
u32 get_hfi_port_from_buffer_type(struct msm_vidc_inst *inst,
enum msm_vidc_buffer_type buffer_type)
{
u32 hfi_port = HFI_PORT_NONE;
if (is_decode_session(inst)) {
switch(buffer_type) {
case MSM_VIDC_BUF_INPUT:
case MSM_VIDC_BUF_INPUT_META:
case MSM_VIDC_BUF_BIN:
case MSM_VIDC_BUF_COMV:
case MSM_VIDC_BUF_NON_COMV:
case MSM_VIDC_BUF_LINE:
hfi_port = HFI_PORT_BITSTREAM;
break;
case MSM_VIDC_BUF_PERSIST:
/* TODO: change to HFI_PORT_NONE */
hfi_port = HFI_PORT_BITSTREAM | HFI_PORT_RAW;
break;
case MSM_VIDC_BUF_OUTPUT:
case MSM_VIDC_BUF_OUTPUT_META:
case MSM_VIDC_BUF_DPB:
hfi_port = HFI_PORT_RAW;
break;
default:
i_vpr_e(inst, "%s: invalid buffer type %d\n",
__func__, buffer_type);
break;
}
} else if (is_encode_session(inst)) {
switch (buffer_type) {
case MSM_VIDC_BUF_INPUT:
case MSM_VIDC_BUF_INPUT_META:
case MSM_VIDC_BUF_VPSS:
hfi_port = HFI_PORT_RAW;
break;
case MSM_VIDC_BUF_OUTPUT:
case MSM_VIDC_BUF_OUTPUT_META:
case MSM_VIDC_BUF_BIN:
case MSM_VIDC_BUF_COMV:
case MSM_VIDC_BUF_NON_COMV:
case MSM_VIDC_BUF_LINE:
case MSM_VIDC_BUF_DPB:
hfi_port = HFI_PORT_BITSTREAM;
break;
case MSM_VIDC_BUF_ARP:
hfi_port = HFI_PORT_NONE;
break;
default:
i_vpr_e(inst, "%s: invalid buffer type %d\n",
__func__, buffer_type);
break;
}
} else {
i_vpr_e(inst, "%s: invalid domain %#x\n",
__func__, inst->domain);
}
return hfi_port;
}
u32 get_hfi_buffer_type(enum msm_vidc_domain_type domain,
enum msm_vidc_buffer_type buffer_type)
{
switch (buffer_type) {
case MSM_VIDC_BUF_INPUT:
if (domain == MSM_VIDC_DECODER)
return HFI_BUFFER_BITSTREAM;
else
return HFI_BUFFER_RAW;
case MSM_VIDC_BUF_OUTPUT:
if (domain == MSM_VIDC_DECODER)
return HFI_BUFFER_RAW;
else
return HFI_BUFFER_BITSTREAM;
case MSM_VIDC_BUF_INPUT_META:
case MSM_VIDC_BUF_OUTPUT_META:
return HFI_BUFFER_METADATA;
case MSM_VIDC_BUF_BIN:
return HFI_BUFFER_BIN;
case MSM_VIDC_BUF_ARP:
return HFI_BUFFER_ARP;
case MSM_VIDC_BUF_COMV:
return HFI_BUFFER_COMV;
case MSM_VIDC_BUF_NON_COMV:
return HFI_BUFFER_NON_COMV;
case MSM_VIDC_BUF_LINE:
return HFI_BUFFER_LINE;
case MSM_VIDC_BUF_DPB:
return HFI_BUFFER_DPB;
case MSM_VIDC_BUF_PERSIST:
return HFI_BUFFER_PERSIST;
default:
d_vpr_e("invalid buffer type %d\n",
buffer_type);
return 0;
}
}
u32 get_hfi_codec(struct msm_vidc_inst *inst)
{
switch (inst->codec) {
case MSM_VIDC_H264:
if (inst->domain == MSM_VIDC_ENCODER)
return HFI_CODEC_ENCODE_AVC;
else
return HFI_CODEC_DECODE_AVC;
case MSM_VIDC_HEVC:
if (inst->domain == MSM_VIDC_ENCODER)
return HFI_CODEC_ENCODE_HEVC;
else
return HFI_CODEC_DECODE_HEVC;
case MSM_VIDC_VP9:
return HFI_CODEC_DECODE_VP9;
default:
d_vpr_e("invalid codec %d, domain %d\n",
inst->codec, inst->domain);
return 0;
}
}
u32 get_hfi_colorformat(struct msm_vidc_inst *inst,
enum msm_vidc_colorformat_type colorformat)
{
u32 hfi_colorformat = HFI_COLOR_FMT_NV12_UBWC;
switch(colorformat) {
case MSM_VIDC_FMT_NV12:
hfi_colorformat = HFI_COLOR_FMT_NV12;
break;
case MSM_VIDC_FMT_NV12C:
hfi_colorformat = HFI_COLOR_FMT_NV12_UBWC;
break;
case MSM_VIDC_FMT_P010:
hfi_colorformat = HFI_COLOR_FMT_P010;
break;
case MSM_VIDC_FMT_TP10C:
hfi_colorformat = HFI_COLOR_FMT_TP10_UBWC;
break;
case MSM_VIDC_FMT_RGBA8888:
hfi_colorformat = HFI_COLOR_FMT_RGBA8888;
break;
case MSM_VIDC_FMT_RGBA8888C:
hfi_colorformat = HFI_COLOR_FMT_RGBA8888_UBWC;
break;
case MSM_VIDC_FMT_NV21:
hfi_colorformat = HFI_COLOR_FMT_NV21;
break;
default:
i_vpr_e(inst, "%s: invalid colorformat %d\n",
__func__, colorformat);
break;
}
return hfi_colorformat;
}
u32 get_hfi_quality_mode(struct msm_vidc_inst *inst)
{
u32 hfi_mode = HFI_MODE_POWER_SAVE;
if (!inst || !inst->capabilities) {
d_vpr_e("%s: invalid params\n", __func__);
goto exit;
}
switch(inst->capabilities->cap[QUALITY_MODE].value) {
case MSM_VIDC_MAX_QUALITY_MODE:
hfi_mode = HFI_MODE_MAX_QUALITY;
break;
case MSM_VIDC_POWER_SAVE_MODE:
hfi_mode = HFI_MODE_POWER_SAVE;
break;
default:
i_vpr_e(inst, "%s: invalid qulity mode %d\n", __func__,
inst->capabilities->cap[QUALITY_MODE].value);
break;
}
exit:
return hfi_mode;
}
int get_hfi_buffer(struct msm_vidc_inst *inst,
struct msm_vidc_buffer *buffer, struct hfi_buffer *buf)
{
if (!inst || !buffer || !buf) {
d_vpr_e("%s: invalid params\n", __func__);
return -EINVAL;
}
memset(buf, 0, sizeof(struct hfi_buffer));
buf->type = get_hfi_buffer_type(inst->domain, buffer->type);
buf->index = buffer->index;
buf->base_address = buffer->device_addr;
buf->addr_offset = 0;
buf->buffer_size = buffer->buffer_size;
buf->data_offset = buffer->data_offset;
buf->data_size = buffer->data_size;
if (buffer->attr & MSM_VIDC_ATTR_READ_ONLY)
buf->flags |= HFI_BUF_HOST_FLAG_READONLY;
if (buffer->attr & MSM_VIDC_ATTR_PENDING_RELEASE)
buf->flags |= HFI_BUF_HOST_FLAG_RELEASE;
if (buffer->flags & MSM_VIDC_BUF_FLAG_CODECCONFIG)
buf->flags |= HFI_BUF_HOST_FLAG_CODEC_CONFIG;
buf->timestamp = buffer->timestamp;
return 0;
}
int hfi_create_header(u8 *packet, u32 packet_size, u32 session_id,
u32 header_id)
{
struct hfi_header *hdr = (struct hfi_header *)packet;
if (!packet || packet_size < sizeof(struct hfi_header)) {
d_vpr_e("%s: invalid params\n", __func__);
return -EINVAL;
}
memset(hdr, 0, sizeof(struct hfi_header));
hdr->size = sizeof(struct hfi_header);
hdr->session_id = session_id;
hdr->header_id = header_id;
hdr->num_packets = 0;
return 0;
}
int hfi_create_packet(u8 *packet, u32 packet_size,
u32 pkt_type, u32 pkt_flags, u32 payload_type, u32 port,
u32 packet_id, void *payload, u32 payload_size)
{
struct hfi_header *hdr;
struct hfi_packet *pkt;
u32 pkt_size;
if (!packet) {
d_vpr_e("%s: invalid params\n", __func__);
return -EINVAL;
}
hdr = (struct hfi_header *)packet;
if (hdr->size < sizeof(struct hfi_header)) {
d_vpr_e("%s: invalid hdr size %d\n", __func__, hdr->size);
return -EINVAL;
}
pkt = (struct hfi_packet *)(packet + hdr->size);
pkt_size = sizeof(struct hfi_packet) + payload_size;
if (packet_size < hdr->size + pkt_size) {
d_vpr_e("%s: invalid packet_size %d, %d %d\n",
__func__, packet_size, hdr->size, pkt_size);
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);
hdr->num_packets++;
hdr->size += pkt->size;
return 0;
}
int hfi_packet_sys_init(struct msm_vidc_core *core,
u8 *pkt, u32 pkt_size)
{
int rc = 0;
u32 payload = 0;
if (!core || !pkt) {
d_vpr_e("%s: Invalid params\n", __func__);
return -EINVAL;
}
rc = hfi_create_header(pkt, pkt_size,
0 /*session_id*/,
core->header_id++);
if (rc)
goto err_sys_init;
/* HFI_CMD_SYSTEM_INIT */
payload = HFI_VIDEO_ARCH_LX;
d_vpr_h("%s: arch %d\n", __func__, payload);
rc = hfi_create_packet(pkt, pkt_size,
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;
/* HFI_PROP_INTRA_FRAME_POWER_COLLAPSE */
payload = 0;
d_vpr_h("%s: intra frame power collapse %d\n", __func__, payload);
rc = hfi_create_packet(pkt, pkt_size,
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;
/* HFI_PROP_UBWC_MAX_CHANNELS */
payload = core->platform->data.ubwc_config->max_channels;
d_vpr_h("%s: ubwc max channels %d\n", __func__, payload);
rc = hfi_create_packet(pkt, pkt_size,
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;
/* HFI_PROP_UBWC_MAL_LENGTH */
payload = core->platform->data.ubwc_config->mal_length;
d_vpr_h("%s: ubwc mal length %d\n", __func__, payload);
rc = hfi_create_packet(pkt, pkt_size,
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;
/* HFI_PROP_UBWC_HBB */
payload = core->platform->data.ubwc_config->highest_bank_bit;
d_vpr_h("%s: ubwc hbb %d\n", __func__, payload);
rc = hfi_create_packet(pkt, pkt_size,
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;
/* HFI_PROP_UBWC_BANK_SWZL_LEVEL1 */
payload = core->platform->data.ubwc_config->bank_swzl_level;
d_vpr_h("%s: ubwc swzl1 %d\n", __func__, payload);
rc = hfi_create_packet(pkt, pkt_size,
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;
/* HFI_PROP_UBWC_BANK_SWZL_LEVEL2 */
payload = core->platform->data.ubwc_config->bank_swz2_level;
d_vpr_h("%s: ubwc swzl2 %d\n", __func__, payload);
rc = hfi_create_packet(pkt, pkt_size,
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;
/* HFI_PROP_UBWC_BANK_SWZL_LEVEL3 */
payload = core->platform->data.ubwc_config->bank_swz3_level;
d_vpr_h("%s: ubwc swzl3 %d\n", __func__, payload);
rc = hfi_create_packet(pkt, pkt_size,
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;
/* HFI_PROP_UBWC_BANK_SPREADING */
payload = core->platform->data.ubwc_config->bank_spreading;
d_vpr_h("%s: ubwc bank spreading %d\n", __func__, payload);
rc = hfi_create_packet(pkt, pkt_size,
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;
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,
u8 *pkt, u32 pkt_size)
{
int rc = 0;
if (!core || !pkt) {
d_vpr_e("%s: Invalid params\n", __func__);
return -EINVAL;
}
rc = hfi_create_header(pkt, pkt_size,
0 /*session_id*/,
core->header_id++);
if (rc)
goto err_img_version;
/* HFI_PROP_IMAGE_VERSION */
rc = hfi_create_packet(pkt, pkt_size,
HFI_PROP_IMAGE_VERSION,
(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;
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_sys_pc_prep(struct msm_vidc_core *core,
u8 *pkt, u32 pkt_size)
{
int rc = 0;
if (!core || !pkt) {
d_vpr_e("%s: Invalid params\n", __func__);
return -EINVAL;
}
rc = hfi_create_header(pkt, pkt_size,
0 /*session_id*/,
core->header_id++);
if (rc)
goto err_sys_pc;
/* HFI_CMD_POWER_COLLAPSE */
rc = hfi_create_packet(pkt, pkt_size,
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;
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 payload = 0;
if (!core || !pkt) {
d_vpr_e("%s: Invalid params\n", __func__);
return -EINVAL;
}
rc = hfi_create_header(pkt, pkt_size,
0 /*session_id*/,
core->header_id++);
if (rc)
goto err_debug;
/* HFI_PROP_DEBUG_CONFIG */
payload = 0; /*TODO:Change later*/
rc = hfi_create_packet(pkt, pkt_size,
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;
/* HFI_PROP_DEBUG_LOG_LEVEL */
payload = debug_config; /*TODO:Change later*/
rc = hfi_create_packet(pkt, pkt_size,
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;
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;
struct msm_vidc_core *core;
if (!inst || !inst->core) {
d_vpr_e("%s: Invalid params\n", __func__);
return -EINVAL;
}
core = inst->core;
rc = hfi_create_header(inst->packet, inst->packet_size,
session_id,
core->header_id++);
if (rc)
goto err_cmd;
rc = hfi_create_packet(inst->packet,
inst->packet_size,
pkt_type,
flags,
payload_type,
port,
core->packet_id++,
payload,
payload_size);
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;
}