rubenslte/android_kernel_samsung_msm8226
1
Fork 1
mirror of https://github.com/LineageOS/android_kernel_samsung_msm8226.git synced 2026-09-29 00:00:25 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge "msm: vidc: support hfi callbacks in V4L2 video driver"

Browse Source
This commit is contained in:
Linux Build Service Account
2013-01-08 07:19:37 -08:00
committed by Gerrit - the friendly Code Review server
parent d0778c41c8 53107f77ef
commit aa12e9cfd6
15 changed files with 1694 additions and 1208 deletions
Download Patch File Download Diff File Expand all files Collapse all files
drivers/media/video/msm_vidc/Makefile
+1
View File
@@ -8,3 +8,4 @@ obj-$(CONFIG_MSM_VIDC_V4L2) := msm_v4l2_vidc.o \
venus_hfi.o \
hfi_response_handler.o \
hfi_packetization.o \
vidc_hfi.o \
drivers/media/video/msm_vidc/hfi_packetization.h
+2 -2
View File
@@ -1,4 +1,4 @@
/* Copyright (c) 2012, The Linux Foundation. All rights reserved.
/* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
@@ -15,8 +15,8 @@
#include <linux/types.h>
#include "vidc_hfi_helper.h"
#include "vidc_hfi.h"
#include "vidc_hfi_api.h"
#include "venus_hfi.h"
int create_pkt_cmd_sys_init(struct hfi_cmd_sys_init_packet *pkt,
u32 arch_type);
drivers/media/video/msm_vidc/hfi_response_handler.c
+118 -129
View File
@@ -1,4 +1,4 @@
/* Copyright (c) 2012, The Linux Foundation. All rights reserved.
/* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
@@ -14,9 +14,10 @@
#include <linux/slab.h>
#include <linux/list.h>
#include <linux/interrupt.h>
#include "venus_hfi.h"
#include "vidc_hfi_helper.h"
#include "vidc_hfi_io.h"
#include "msm_vidc_debug.h"
#include "vidc_hfi.h"
static enum vidc_status hfi_map_err_status(int hfi_err)
{
@@ -75,8 +76,9 @@ static enum vidc_status hfi_map_err_status(int hfi_err)
return vidc_err;
}
static void hfi_process_sess_evt_seq_changed(struct venus_hfi_device *device,
struct hfi_msg_event_notify_packet *pkt)
static void hfi_process_sess_evt_seq_changed(
msm_vidc_callback callback, u32 device_id,
struct hfi_msg_event_notify_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
struct msm_vidc_cb_event event_notify;
@@ -95,7 +97,7 @@ static void hfi_process_sess_evt_seq_changed(struct venus_hfi_device *device,
memset(&event_notify, 0, sizeof(struct
msm_vidc_cb_event));
cmd_done.device_id = device->device_id;
cmd_done.device_id = device_id;
cmd_done.session_id = ((struct hal_session *) pkt->session_id)->
session_id;
cmd_done.status = VIDC_ERR_NONE;
@@ -136,39 +138,35 @@ static void hfi_process_sess_evt_seq_changed(struct venus_hfi_device *device,
} while (num_properties_changed > 0);
}
cmd_done.data = &event_notify;
device->callback(VIDC_EVENT_CHANGE, &cmd_done);
callback(VIDC_EVENT_CHANGE, &cmd_done);
}
static void hfi_process_sys_watchdog_timeout(struct venus_hfi_device *device)
{
struct msm_vidc_cb_cmd_done cmd_done;
device->intr_status &= ~VIDC_WRAPPER_INTR_STATUS_A2HWD_BMSK;
memset(&cmd_done, 0, sizeof(struct msm_vidc_cb_cmd_done));
cmd_done.device_id = device->device_id;
device->callback(SYS_WATCHDOG_TIMEOUT, &cmd_done);
}
static void hfi_process_sys_error(struct venus_hfi_device *device)
static void hfi_process_sys_error(
msm_vidc_callback callback, u32 device_id)
{
struct msm_vidc_cb_cmd_done cmd_done;
memset(&cmd_done, 0, sizeof(struct msm_vidc_cb_cmd_done));
cmd_done.device_id = device->device_id;
device->callback(SYS_ERROR, &cmd_done);
cmd_done.device_id = device_id;
callback(SYS_ERROR, &cmd_done);
}
static void hfi_process_session_error(struct venus_hfi_device *device,
static void hfi_process_session_error(
msm_vidc_callback callback, u32 device_id,
struct hfi_msg_event_notify_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
memset(&cmd_done, 0, sizeof(struct msm_vidc_cb_cmd_done));
cmd_done.device_id = device->device_id;
cmd_done.device_id = device_id;
cmd_done.session_id = ((struct hal_session *) pkt->session_id)->
session_id;
device->callback(SESSION_ERROR, &cmd_done);
callback(SESSION_ERROR, &cmd_done);
}
static void hfi_process_event_notify(struct venus_hfi_device *device,
struct hfi_msg_event_notify_packet *pkt)
static void hfi_process_event_notify(
msm_vidc_callback callback, u32 device_id,
struct hfi_msg_event_notify_packet *pkt)
{
dprintk(VIDC_DBG, "RECVD:EVENT_NOTIFY");
if (!device || !pkt ||
if (!callback || !pkt ||
pkt->size < sizeof(struct hfi_msg_event_notify_packet)) {
dprintk(VIDC_ERR, "Invalid Params");
return;
@@ -178,15 +176,15 @@ static void hfi_process_event_notify(struct venus_hfi_device *device,
case HFI_EVENT_SYS_ERROR:
dprintk(VIDC_ERR, "HFI_EVENT_SYS_ERROR: %d\n",
pkt->event_data1);
hfi_process_sys_error(device);
hfi_process_sys_error(callback, device_id);
break;
case HFI_EVENT_SESSION_ERROR:
dprintk(VIDC_ERR, "HFI_EVENT_SESSION_ERROR");
hfi_process_session_error(device, pkt);
hfi_process_session_error(callback, device_id, pkt);
break;
case HFI_EVENT_SESSION_SEQUENCE_CHANGED:
dprintk(VIDC_INFO, "HFI_EVENT_SESSION_SEQUENCE_CHANGED");
hfi_process_sess_evt_seq_changed(device, pkt);
hfi_process_sess_evt_seq_changed(callback, device_id, pkt);
break;
case HFI_EVENT_SESSION_PROPERTY_CHANGED:
dprintk(VIDC_INFO, "HFI_EVENT_SESSION_PROPERTY_CHANGED");
@@ -196,7 +194,8 @@ static void hfi_process_event_notify(struct venus_hfi_device *device,
break;
}
}
static void hfi_process_sys_init_done(struct venus_hfi_device *device,
static void hfi_process_sys_init_done(
msm_vidc_callback callback, u32 device_id,
struct hfi_msg_sys_init_done_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
@@ -273,16 +272,17 @@ static void hfi_process_sys_init_done(struct venus_hfi_device *device,
}
}
err_no_prop:
cmd_done.device_id = device->device_id;
cmd_done.device_id = device_id;
cmd_done.session_id = 0;
cmd_done.status = (u32) status;
cmd_done.size = sizeof(struct vidc_hal_sys_init_done);
cmd_done.data = (void *) &sys_init_done;
device->callback(SYS_INIT_DONE, &cmd_done);
callback(SYS_INIT_DONE, &cmd_done);
}
static void hfi_process_sys_rel_resource_done(struct venus_hfi_device *device,
struct hfi_msg_sys_release_resource_done_packet *pkt)
static void hfi_process_sys_rel_resource_done(
msm_vidc_callback callback, u32 device_id,
struct hfi_msg_sys_release_resource_done_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
enum vidc_status status = VIDC_ERR_NONE;
@@ -297,12 +297,12 @@ static void hfi_process_sys_rel_resource_done(struct venus_hfi_device *device,
return;
}
status = hfi_map_err_status((u32)pkt->error_type);
cmd_done.device_id = device->device_id;
cmd_done.device_id = device_id;
cmd_done.session_id = 0;
cmd_done.status = (u32) status;
cmd_done.size = 0;
cmd_done.data = NULL;
device->callback(RELEASE_RESOURCE_DONE, &cmd_done);
callback(RELEASE_RESOURCE_DONE, &cmd_done);
}
enum vidc_status hfi_process_sess_init_done_prop_read(
@@ -408,8 +408,9 @@ static void hfi_process_sess_get_prop_buf_req(
}
}
static void hfi_process_session_prop_info(struct venus_hfi_device *device,
struct hfi_msg_session_property_info_packet *pkt)
static void hfi_process_session_prop_info(
msm_vidc_callback callback, u32 device_id,
struct hfi_msg_session_property_info_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
struct buffer_requirements buff_req;
@@ -433,13 +434,13 @@ static void hfi_process_session_prop_info(struct venus_hfi_device *device,
switch (pkt->rg_property_data[0]) {
case HFI_PROPERTY_CONFIG_BUFFER_REQUIREMENTS:
hfi_process_sess_get_prop_buf_req(pkt, &buff_req);
cmd_done.device_id = device->device_id;
cmd_done.device_id = device_id;
cmd_done.session_id =
((struct hal_session *) pkt->session_id)->session_id;
cmd_done.status = VIDC_ERR_NONE;
cmd_done.data = &buff_req;
cmd_done.size = sizeof(struct buffer_requirements);
device->callback(SESSION_PROPERTY_INFO, &cmd_done);
callback(SESSION_PROPERTY_INFO, &cmd_done);
break;
default:
dprintk(VIDC_ERR, "hal_process_session_prop_info:"
@@ -449,8 +450,9 @@ static void hfi_process_session_prop_info(struct venus_hfi_device *device,
}
}
static void hfi_process_session_init_done(struct venus_hfi_device *device,
struct hfi_msg_sys_session_init_done_packet *pkt)
static void hfi_process_session_init_done(
msm_vidc_callback callback, u32 device_id,
struct hfi_msg_sys_session_init_done_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
struct vidc_hal_session_init_done session_init_done;
@@ -466,7 +468,7 @@ static void hfi_process_session_init_done(struct venus_hfi_device *device,
memset(&session_init_done, 0, sizeof(struct
vidc_hal_session_init_done));
cmd_done.device_id = device->device_id;
cmd_done.device_id = device_id;
cmd_done.session_id =
((struct hal_session *) pkt->session_id)->session_id;
cmd_done.status = hfi_map_err_status((u32)pkt->error_type);
@@ -476,11 +478,12 @@ static void hfi_process_session_init_done(struct venus_hfi_device *device,
pkt, &cmd_done);
}
cmd_done.size = sizeof(struct vidc_hal_session_init_done);
device->callback(SESSION_INIT_DONE, &cmd_done);
callback(SESSION_INIT_DONE, &cmd_done);
}
static void hfi_process_session_load_res_done(struct venus_hfi_device *device,
struct hfi_msg_session_load_resources_done_packet *pkt)
static void hfi_process_session_load_res_done(
msm_vidc_callback callback, u32 device_id,
struct hfi_msg_session_load_resources_done_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
dprintk(VIDC_DBG, "RECEIVED:SESSION_LOAD_RESOURCES_DONE");
@@ -494,17 +497,18 @@ static void hfi_process_session_load_res_done(struct venus_hfi_device *device,
memset(&cmd_done, 0, sizeof(struct msm_vidc_cb_cmd_done));
cmd_done.device_id = device->device_id;
cmd_done.device_id = device_id;
cmd_done.session_id =
((struct hal_session *) pkt->session_id)->session_id;
cmd_done.status = hfi_map_err_status((u32)pkt->error_type);
cmd_done.data = NULL;
cmd_done.size = 0;
device->callback(SESSION_LOAD_RESOURCE_DONE, &cmd_done);
callback(SESSION_LOAD_RESOURCE_DONE, &cmd_done);
}
static void hfi_process_session_flush_done(struct venus_hfi_device *device,
struct hfi_msg_session_flush_done_packet *pkt)
static void hfi_process_session_flush_done(
msm_vidc_callback callback, u32 device_id,
struct hfi_msg_session_flush_done_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
@@ -517,17 +521,18 @@ static void hfi_process_session_flush_done(struct venus_hfi_device *device,
}
memset(&cmd_done, 0, sizeof(struct msm_vidc_cb_cmd_done));
cmd_done.device_id = device->device_id;
cmd_done.device_id = device_id;
cmd_done.session_id =
((struct hal_session *) pkt->session_id)->session_id;
cmd_done.status = hfi_map_err_status((u32)pkt->error_type);
cmd_done.data = (void *) pkt->flush_type;
cmd_done.size = sizeof(u32);
device->callback(SESSION_FLUSH_DONE, &cmd_done);
callback(SESSION_FLUSH_DONE, &cmd_done);
}
static void hfi_process_session_etb_done(struct venus_hfi_device *device,
struct hfi_msg_session_empty_buffer_done_packet *pkt)
static void hfi_process_session_etb_done(
msm_vidc_callback callback, u32 device_id,
struct hfi_msg_session_empty_buffer_done_packet *pkt)
{
struct msm_vidc_cb_data_done data_done;
@@ -541,7 +546,7 @@ static void hfi_process_session_etb_done(struct venus_hfi_device *device,
memset(&data_done, 0, sizeof(struct msm_vidc_cb_data_done));
data_done.device_id = device->device_id;
data_done.device_id = device_id;
data_done.session_id =
((struct hal_session *) pkt->session_id)->session_id;
data_done.status = hfi_map_err_status((u32) pkt->error_type);
@@ -550,11 +555,12 @@ static void hfi_process_session_etb_done(struct venus_hfi_device *device,
data_done.input_done.offset = pkt->offset;
data_done.input_done.filled_len = pkt->filled_len;
data_done.input_done.packet_buffer = pkt->packet_buffer;
device->callback(SESSION_ETB_DONE, &data_done);
callback(SESSION_ETB_DONE, &data_done);
}
static void hfi_process_session_ftb_done(struct venus_hfi_device *device,
void *msg_hdr)
static void hfi_process_session_ftb_done(
msm_vidc_callback callback, u32 device_id,
void *msg_hdr)
{
struct msm_vidc_cb_data_done data_done;
struct hfi_msg_session_fill_buffer_done_compressed_packet *pack =
@@ -590,7 +596,7 @@ static void hfi_process_session_ftb_done(struct venus_hfi_device *device,
/* Proceed with the FBD */
}
data_done.device_id = device->device_id;
data_done.device_id = device_id;
data_done.session_id = (u32) session;
data_done.status = hfi_map_err_status((u32)
pkt->error_type);
@@ -624,7 +630,7 @@ static void hfi_process_session_ftb_done(struct venus_hfi_device *device,
return;
}
data_done.device_id = device->device_id;
data_done.device_id = device_id;
data_done.session_id = (u32) session;
data_done.status = hfi_map_err_status((u32)
pkt->error_type);
@@ -657,11 +663,12 @@ static void hfi_process_session_ftb_done(struct venus_hfi_device *device,
else if (pkt->stream_id == 1)
data_done.output_done.buffer_type = HAL_BUFFER_OUTPUT2;
}
device->callback(SESSION_FTB_DONE, &data_done);
callback(SESSION_FTB_DONE, &data_done);
}
static void hfi_process_session_start_done(struct venus_hfi_device *device,
struct hfi_msg_session_start_done_packet *pkt)
static void hfi_process_session_start_done(
msm_vidc_callback callback, u32 device_id,
struct hfi_msg_session_start_done_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
@@ -675,17 +682,18 @@ static void hfi_process_session_start_done(struct venus_hfi_device *device,
}
memset(&cmd_done, 0, sizeof(struct msm_vidc_cb_cmd_done));
cmd_done.device_id = device->device_id;
cmd_done.device_id = device_id;
cmd_done.session_id =
((struct hal_session *) pkt->session_id)->session_id;
cmd_done.status = hfi_map_err_status((u32)pkt->error_type);
cmd_done.data = NULL;
cmd_done.size = 0;
device->callback(SESSION_START_DONE, &cmd_done);
callback(SESSION_START_DONE, &cmd_done);
}
static void hfi_process_session_stop_done(struct venus_hfi_device *device,
struct hfi_msg_session_stop_done_packet *pkt)
static void hfi_process_session_stop_done(
msm_vidc_callback callback, u32 device_id,
struct hfi_msg_session_stop_done_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
@@ -699,17 +707,18 @@ static void hfi_process_session_stop_done(struct venus_hfi_device *device,
}
memset(&cmd_done, 0, sizeof(struct msm_vidc_cb_cmd_done));
cmd_done.device_id = device->device_id;
cmd_done.device_id = device_id;
cmd_done.session_id =
((struct hal_session *) pkt->session_id)->session_id;
cmd_done.status = hfi_map_err_status((u32)pkt->error_type);
cmd_done.data = NULL;
cmd_done.size = 0;
device->callback(SESSION_STOP_DONE, &cmd_done);
callback(SESSION_STOP_DONE, &cmd_done);
}
static void hfi_process_session_rel_res_done(struct venus_hfi_device *device,
struct hfi_msg_session_release_resources_done_packet *pkt)
static void hfi_process_session_rel_res_done(
msm_vidc_callback callback, u32 device_id,
struct hfi_msg_session_release_resources_done_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
@@ -723,17 +732,18 @@ static void hfi_process_session_rel_res_done(struct venus_hfi_device *device,
}
memset(&cmd_done, 0, sizeof(struct msm_vidc_cb_cmd_done));
cmd_done.device_id = device->device_id;
cmd_done.device_id = device_id;
cmd_done.session_id =
((struct hal_session *) pkt->session_id)->session_id;
cmd_done.status = hfi_map_err_status((u32)pkt->error_type);
cmd_done.data = NULL;
cmd_done.size = 0;
device->callback(SESSION_RELEASE_RESOURCE_DONE, &cmd_done);
callback(SESSION_RELEASE_RESOURCE_DONE, &cmd_done);
}
static void hfi_process_session_rel_buf_done(struct venus_hfi_device *device,
struct hfi_msg_session_release_buffers_done_packet *pkt)
static void hfi_process_session_rel_buf_done(
msm_vidc_callback callback, u32 device_id,
struct hfi_msg_session_release_buffers_done_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
if (!pkt || pkt->size !=
@@ -743,7 +753,7 @@ static void hfi_process_session_rel_buf_done(struct venus_hfi_device *device,
return;
}
memset(&cmd_done, 0, sizeof(struct msm_vidc_cb_cmd_done));
cmd_done.device_id = device->device_id;
cmd_done.device_id = device_id;
cmd_done.size = sizeof(struct msm_vidc_cb_cmd_done);
cmd_done.session_id =
((struct hal_session *) pkt->session_id)->session_id;
@@ -754,11 +764,12 @@ static void hfi_process_session_rel_buf_done(struct venus_hfi_device *device,
} else {
dprintk(VIDC_ERR, "invalid payload in rel_buff_done\n");
}
device->callback(SESSION_RELEASE_BUFFER_DONE, &cmd_done);
callback(SESSION_RELEASE_BUFFER_DONE, &cmd_done);
}
static void hfi_process_session_end_done(struct venus_hfi_device *device,
struct hfi_msg_sys_session_end_done_packet *pkt)
static void hfi_process_session_end_done(
msm_vidc_callback callback, u32 device_id,
struct hfi_msg_sys_session_end_done_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
struct hal_session *sess_close;
@@ -779,17 +790,17 @@ static void hfi_process_session_end_done(struct venus_hfi_device *device,
kfree(sess_close);
memset(&cmd_done, 0, sizeof(struct msm_vidc_cb_cmd_done));
cmd_done.device_id = device->device_id;
cmd_done.device_id = device_id;
cmd_done.session_id =
((struct hal_session *) pkt->session_id)->session_id;
cmd_done.status = hfi_map_err_status((u32)pkt->error_type);
cmd_done.data = NULL;
cmd_done.size = 0;
device->callback(SESSION_END_DONE, &cmd_done);
callback(SESSION_END_DONE, &cmd_done);
}
static void hfi_process_session_get_seq_hdr_done(
struct venus_hfi_device *device,
msm_vidc_callback callback, u32 device_id,
struct hfi_msg_session_get_sequence_header_done_packet *pkt)
{
struct msm_vidc_cb_data_done data_done;
@@ -800,7 +811,7 @@ static void hfi_process_session_get_seq_hdr_done(
return;
}
memset(&data_done, 0, sizeof(struct msm_vidc_cb_data_done));
data_done.device_id = device->device_id;
data_done.device_id = device_id;
data_done.size = sizeof(struct msm_vidc_cb_data_done);
data_done.session_id =
((struct hal_session *) pkt->session_id)->session_id;
@@ -809,121 +820,99 @@ static void hfi_process_session_get_seq_hdr_done(
data_done.output_done.filled_len1 = pkt->header_len;
dprintk(VIDC_INFO, "seq_hdr: %p, Length: %d",
pkt->sequence_header, pkt->header_len);
device->callback(SESSION_GET_SEQ_HDR_DONE, &data_done);
callback(SESSION_GET_SEQ_HDR_DONE, &data_done);
}
static void hfi_process_msg_packet(struct venus_hfi_device *device,
struct vidc_hal_msg_pkt_hdr *msg_hdr)
void hfi_process_msg_packet(
msm_vidc_callback callback, u32 device_id,
struct vidc_hal_msg_pkt_hdr *msg_hdr)
{
if (!device || !msg_hdr || msg_hdr->size <
VIDC_IFACEQ_MIN_PKT_SIZE) {
if (!callback || !msg_hdr || msg_hdr->size <
HFI_MIN_PKT_SIZE) {
dprintk(VIDC_ERR, "hal_process_msg_packet:bad"
"packet/packet size: %d", msg_hdr->size);
return;
}
dprintk(VIDC_INFO, "Received: 0x%x in ", msg_hdr->packet);
if ((device->intr_status & VIDC_WRAPPER_INTR_CLEAR_A2HWD_BMSK)) {
dprintk(VIDC_ERR, "Received: Watchdog timeout %s", __func__);
hfi_process_sys_watchdog_timeout(device);
return;
}
switch (msg_hdr->packet) {
case HFI_MSG_EVENT_NOTIFY:
hfi_process_event_notify(device,
hfi_process_event_notify(callback, device_id,
(struct hfi_msg_event_notify_packet *) msg_hdr);
break;
case HFI_MSG_SYS_INIT_DONE:
hfi_process_sys_init_done(device,
hfi_process_sys_init_done(callback, device_id,
(struct hfi_msg_sys_init_done_packet *)
msg_hdr);
break;
case HFI_MSG_SYS_SESSION_INIT_DONE:
hfi_process_session_init_done(device,
hfi_process_session_init_done(callback, device_id,
(struct hfi_msg_sys_session_init_done_packet *)
msg_hdr);
break;
case HFI_MSG_SYS_SESSION_END_DONE:
hfi_process_session_end_done(device,
hfi_process_session_end_done(callback, device_id,
(struct hfi_msg_sys_session_end_done_packet *)
msg_hdr);
break;
case HFI_MSG_SESSION_LOAD_RESOURCES_DONE:
hfi_process_session_load_res_done(device,
hfi_process_session_load_res_done(callback, device_id,
(struct hfi_msg_session_load_resources_done_packet *)
msg_hdr);
break;
case HFI_MSG_SESSION_START_DONE:
hfi_process_session_start_done(device,
hfi_process_session_start_done(callback, device_id,
(struct hfi_msg_session_start_done_packet *)
msg_hdr);
break;
case HFI_MSG_SESSION_STOP_DONE:
hfi_process_session_stop_done(device,
hfi_process_session_stop_done(callback, device_id,
(struct hfi_msg_session_stop_done_packet *)
msg_hdr);
break;
case HFI_MSG_SESSION_EMPTY_BUFFER_DONE:
hfi_process_session_etb_done(device,
hfi_process_session_etb_done(callback, device_id,
(struct hfi_msg_session_empty_buffer_done_packet *)
msg_hdr);
break;
case HFI_MSG_SESSION_FILL_BUFFER_DONE:
hfi_process_session_ftb_done(device, msg_hdr);
hfi_process_session_ftb_done(callback, device_id, msg_hdr);
break;
case HFI_MSG_SESSION_FLUSH_DONE:
hfi_process_session_flush_done(device,
hfi_process_session_flush_done(callback, device_id,
(struct hfi_msg_session_flush_done_packet *)
msg_hdr);
break;
case HFI_MSG_SESSION_PROPERTY_INFO:
hfi_process_session_prop_info(device,
hfi_process_session_prop_info(callback, device_id,
(struct hfi_msg_session_property_info_packet *)
msg_hdr);
break;
case HFI_MSG_SESSION_RELEASE_RESOURCES_DONE:
hfi_process_session_rel_res_done(device,
hfi_process_session_rel_res_done(callback, device_id,
(struct hfi_msg_session_release_resources_done_packet *)
msg_hdr);
break;
case HFI_MSG_SYS_RELEASE_RESOURCE:
hfi_process_sys_rel_resource_done(device,
hfi_process_sys_rel_resource_done(callback, device_id,
(struct hfi_msg_sys_release_resource_done_packet *)
msg_hdr);
break;
case HFI_MSG_SESSION_GET_SEQUENCE_HEADER_DONE:
hfi_process_session_get_seq_hdr_done(device, (struct
hfi_msg_session_get_sequence_header_done_packet
*) msg_hdr);
hfi_process_session_get_seq_hdr_done(
callback, device_id, (struct
hfi_msg_session_get_sequence_header_done_packet*)
msg_hdr);
break;
case HFI_MSG_SESSION_RELEASE_BUFFERS_DONE:
hfi_process_session_rel_buf_done(device, (struct
hfi_msg_session_release_buffers_done_packet
*) msg_hdr);
hfi_process_session_rel_buf_done(
callback, device_id, (struct
hfi_msg_session_release_buffers_done_packet*)
msg_hdr);
break;
default:
dprintk(VIDC_ERR, "UNKNOWN_MSG_TYPE : %d", msg_hdr->packet);
break;
}
}
void hfi_response_handler(struct venus_hfi_device *device)
{
u8 packet[VIDC_IFACEQ_MED_PKT_SIZE];
dprintk(VIDC_INFO, "#####vidc_hal_response_handler#####\n");
if (device) {
while (!venus_hfi_iface_msgq_read(device, packet)) {
hfi_process_msg_packet(device,
(struct vidc_hal_msg_pkt_hdr *) packet);
}
while (!venus_hfi_iface_dbgq_read(device, packet)) {
struct hfi_msg_sys_debug_packet *pkt =
(struct hfi_msg_sys_debug_packet *) packet;
dprintk(VIDC_FW, "FW-SAYS: %s", pkt->rg_msg_data);
}
} else {
dprintk(VIDC_ERR, "SPURIOUS_INTERRUPT");
}
}
drivers/media/video/msm_vidc/msm_v4l2_vidc.c
+24 -9
View File
@@ -29,7 +29,7 @@
#include "msm_vidc_debug.h"
#include "vidc_hfi_api.h"
#include "msm_smem.h"
#include "venus_hfi.h"
#include "vidc_hfi_api.h"
#define BASE_DEVICE_NUMBER 32
@@ -355,7 +355,8 @@ int msm_v4l2_prepare_buf(struct file *file, void *fh,
int i, rc = 0;
int smem_flags = 0;
int domain;
struct venus_hfi_device *device;
struct hfi_device *hdev;
vidc_inst = get_vidc_inst(file, fh);
v4l2_inst = get_v4l2_inst(file, fh);
if (!v4l2_inst || !vidc_inst || !vidc_inst->core
@@ -364,7 +365,8 @@ int msm_v4l2_prepare_buf(struct file *file, void *fh,
goto exit;
}
device = vidc_inst->core->device;
hdev = vidc_inst->core->device;
if (!v4l2_inst->mem_client) {
dprintk(VIDC_ERR, "Failed to get memory client\n");
rc = -ENOMEM;
@@ -404,9 +406,11 @@ int msm_v4l2_prepare_buf(struct file *file, void *fh,
&& (!EXTRADATA_IDX(b->length)
|| (i != EXTRADATA_IDX(b->length)))) {
smem_flags |= SMEM_SECURE;
domain = venus_hfi_get_domain(device, CP_MAP);
domain = hdev->get_domain(hdev->hfi_device_data,
CP_MAP);
} else
domain = venus_hfi_get_domain(device, NS_MAP);
domain = hdev->get_domain(hdev->hfi_device_data,
NS_MAP);
if (b->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
smem_flags |= SMEM_INPUT;
@@ -765,8 +769,8 @@ static int __devinit msm_vidc_probe(struct platform_device *pdev)
}
video_set_drvdata(&core->vdev[MSM_VIDC_ENCODER].vdev, core);
core->device =
venus_hfi_get_device(core->id, pdev, &handle_cmd_response);
core->device = vidc_hfi_initialize(core->hfi_type, core->id,
pdev, &handle_cmd_response);
if (!core->device) {
dprintk(VIDC_ERR, "Failed to create HFI device\n");
goto err_cores_exceeded;
@@ -803,9 +807,20 @@ err_no_mem:
static int __devexit msm_vidc_remove(struct platform_device *pdev)
{
int rc = 0;
struct msm_vidc_core *core = pdev->dev.platform_data;
struct msm_vidc_core *core;
venus_hfi_delete_device(core->device);
if (!pdev) {
dprintk(VIDC_ERR, "%s invalid input %p", __func__, pdev);
return -EINVAL;
}
core = pdev->dev.platform_data;
if (!core) {
dprintk(VIDC_ERR, "%s invalid core", __func__);
return -EINVAL;
}
vidc_hfi_deinitialize(core->hfi_type, core->device);
video_unregister_device(&core->vdev[MSM_VIDC_ENCODER].vdev);
video_unregister_device(&core->vdev[MSM_VIDC_DECODER].vdev);
v4l2_device_unregister(&core->v4l2_dev);
drivers/media/video/msm_vidc/msm_vdec.c
+38 -5
View File
@@ -1,4 +1,4 @@
/* Copyright (c) 2012, The Linux Foundation. All rights reserved.
/* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
@@ -377,6 +377,14 @@ int msm_vdec_prepare_buf(struct msm_vidc_inst *inst,
struct vidc_buffer_addr_info buffer_info;
int extra_idx = 0;
int i;
struct hfi_device *hdev;
if (!inst || !inst->core || !inst->core->device) {
dprintk(VIDC_ERR, "%s invalid parameters", __func__);
return -EINVAL;
}
hdev = inst->core->device;
switch (b->type) {
case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
break;
@@ -415,7 +423,7 @@ int msm_vdec_prepare_buf(struct msm_vidc_inst *inst,
buffer_info.extradata_addr = 0;
buffer_info.extradata_size = 0;
}
rc = venus_hfi_session_set_buffers(
rc = hdev->session_set_buffers(
(void *)inst->session, &buffer_info);
if (rc)
dprintk(VIDC_ERR,
@@ -436,6 +444,15 @@ int msm_vdec_release_buf(struct msm_vidc_inst *inst,
struct msm_vidc_core *core = inst->core;
int extra_idx = 0;
int i;
struct hfi_device *hdev;
if (!inst || !inst->core || !inst->core->device) {
dprintk(VIDC_ERR, "%s invalid parameters", __func__);
return -EINVAL;
}
hdev = inst->core->device;
if (inst->state == MSM_VIDC_CORE_INVALID ||
core->state == VIDC_CORE_INVALID) {
dprintk(VIDC_ERR,
@@ -484,7 +501,7 @@ int msm_vdec_release_buf(struct msm_vidc_inst *inst,
else
buffer_info.extradata_addr = 0;
buffer_info.response_required = false;
rc = venus_hfi_session_release_buffers(
rc = hdev->session_release_buffers(
(void *)inst->session, &buffer_info);
if (rc)
dprintk(VIDC_ERR,
@@ -809,6 +826,7 @@ static int msm_vdec_queue_setup(struct vb2_queue *q,
unsigned long flags;
struct hal_buffer_requirements *bufreq;
int extra_idx = 0;
struct hfi_device *hdev;
if (!q || !num_buffers || !num_planes
|| !sizes || !q->drv_priv) {
dprintk(VIDC_ERR, "Invalid input, q = %p, %p, %p\n",
@@ -816,6 +834,14 @@ static int msm_vdec_queue_setup(struct vb2_queue *q,
return -EINVAL;
}
inst = q->drv_priv;
if (!inst || !inst->core || !inst->core->device) {
dprintk(VIDC_ERR, "%s invalid parameters", __func__);
return -EINVAL;
}
hdev = inst->core->device;
switch (q->type) {
case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
*num_planes = inst->fmts[OUTPUT_PORT]->num_planes;
@@ -851,7 +877,7 @@ static int msm_vdec_queue_setup(struct vb2_queue *q,
new_buf_count.buffer_type = HAL_BUFFER_OUTPUT;
new_buf_count.buffer_count_actual = *num_buffers;
rc = venus_hfi_session_set_property(inst->session,
rc = hdev->session_set_property(inst->session,
property_id, &new_buf_count);
}
@@ -1088,6 +1114,13 @@ static int try_set_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl)
enum hal_property property_id = 0;
u32 property_val = 0;
void *pdata;
struct hfi_device *hdev;
if (!inst || !inst->core || !inst->core->device) {
dprintk(VIDC_ERR, "%s invalid parameters", __func__);
return -EINVAL;
}
hdev = inst->core->device;
switch (ctrl->id) {
case V4L2_CID_MPEG_VIDC_VIDEO_STREAM_FORMAT:
@@ -1166,7 +1199,7 @@ static int try_set_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl)
property_id,
msm_vdec_ctrls[control_idx].id,
control.value);
rc = venus_hfi_session_set_property((void *)
rc = hdev->session_set_property((void *)
inst->session, property_id,
pdata);
}
drivers/media/video/msm_vidc/msm_venc.c
+56 -8
View File
@@ -1,4 +1,4 @@
/* Copyright (c) 2012, The Linux Foundation. All rights reserved.
/* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
@@ -611,11 +611,19 @@ static int msm_venc_queue_setup(struct vb2_queue *q,
struct hal_buffer_count_actual new_buf_count;
enum hal_property property_id;
unsigned long flags;
struct hfi_device *hdev;
if (!q || !q->drv_priv) {
dprintk(VIDC_ERR, "Invalid input, q = %p\n", q);
return -EINVAL;
}
inst = q->drv_priv;
if (!inst || !inst->core || !inst->core->device) {
dprintk(VIDC_ERR, "%s invalid parameters", __func__);
return -EINVAL;
}
hdev = inst->core->device;
switch (q->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
*num_planes = 1;
@@ -648,7 +656,7 @@ static int msm_venc_queue_setup(struct vb2_queue *q,
property_id = HAL_PARAM_BUFFER_COUNT_ACTUAL;
new_buf_count.buffer_type = HAL_BUFFER_INPUT;
new_buf_count.buffer_count_actual = *num_buffers;
rc = venus_hfi_session_set_property(inst->session,
rc = hdev->session_set_property(inst->session,
property_id, &new_buf_count);
dprintk(VIDC_DBG, "size = %d, alignment = %d, count = %d\n",
inst->buff_req.buffer[0].buffer_size,
@@ -966,6 +974,13 @@ static int try_set_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl)
u32 property_id = 0, property_val = 0;
void *pdata;
struct v4l2_ctrl *temp_ctrl = NULL;
struct hfi_device *hdev;
if (!inst || !inst->core || !inst->core->device) {
dprintk(VIDC_ERR, "%s invalid parameters", __func__);
return -EINVAL;
}
hdev = inst->core->device;
/* Small helper macro for quickly getting a control and err checking */
#define TRY_GET_CTRL(__ctrl_id) ({ \
@@ -1405,7 +1420,7 @@ static int try_set_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl)
dprintk(VIDC_DBG, "Control: HAL property=%d,ctrl_value=%d\n",
property_id,
ctrl->val);
rc = venus_hfi_session_set_property((void *)inst->session,
rc = hdev->session_set_property((void *)inst->session,
property_id, pdata);
}
@@ -1570,6 +1585,14 @@ int msm_venc_s_parm(struct msm_vidc_inst *inst, struct v4l2_streamparm *a)
void *pdata;
int rc = 0;
struct hal_frame_rate frame_rate;
struct hfi_device *hdev;
if (!inst || !inst->core || !inst->core->device) {
dprintk(VIDC_ERR, "%s invalid parameters", __func__);
return -EINVAL;
}
hdev = inst->core->device;
property_id = HAL_CONFIG_FRAME_RATE;
if (a->parm.output.timeperframe.denominator) {
switch (a->type) {
@@ -1597,7 +1620,7 @@ int msm_venc_s_parm(struct msm_vidc_inst *inst, struct v4l2_streamparm *a)
frame_rate.frame_rate = inst->prop.fps * (0x1<<16);
frame_rate.buffer_type = HAL_BUFFER_OUTPUT;
pdata = &frame_rate;
rc = venus_hfi_session_set_property((void *)inst->session,
rc = hdev->session_set_property((void *)inst->session,
property_id, pdata);
if (rc) {
dprintk(VIDC_WARN,
@@ -1614,11 +1637,19 @@ int msm_venc_s_fmt(struct msm_vidc_inst *inst, struct v4l2_format *f)
struct hal_frame_size frame_sz;
int rc = 0;
int i;
struct hfi_device *hdev;
if (!inst || !f) {
dprintk(VIDC_ERR,
"Invalid input, inst = %p, format = %p\n", inst, f);
return -EINVAL;
}
if (!inst->core || !inst->core->device) {
dprintk(VIDC_ERR, "%s invalid parameters", __func__);
return -EINVAL;
}
hdev = inst->core->device;
if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
fmt = msm_comm_get_pixel_fmt_fourcc(venc_formats,
ARRAY_SIZE(venc_formats), f->fmt.pix_mp.pixelformat,
@@ -1638,7 +1669,7 @@ int msm_venc_s_fmt(struct msm_vidc_inst *inst, struct v4l2_format *f)
frame_sz.height = inst->prop.height;
dprintk(VIDC_DBG, "width = %d, height = %d\n",
frame_sz.width, frame_sz.height);
rc = venus_hfi_session_set_property((void *)inst->session,
rc = hdev->session_set_property((void *)inst->session,
HAL_PARAM_FRAME_SIZE, &frame_sz);
if (rc) {
dprintk(VIDC_ERR,
@@ -1646,7 +1677,7 @@ int msm_venc_s_fmt(struct msm_vidc_inst *inst, struct v4l2_format *f)
goto exit;
}
frame_sz.buffer_type = HAL_BUFFER_OUTPUT;
rc = venus_hfi_session_set_property((void *)inst->session,
rc = hdev->session_set_property((void *)inst->session,
HAL_PARAM_FRAME_SIZE, &frame_sz);
if (rc) {
dprintk(VIDC_ERR,
@@ -1752,6 +1783,14 @@ int msm_venc_prepare_buf(struct msm_vidc_inst *inst,
int rc = 0;
int i;
struct vidc_buffer_addr_info buffer_info;
struct hfi_device *hdev;
if (!inst || !inst->core || !inst->core->device) {
dprintk(VIDC_ERR, "%s invalid parameters", __func__);
return -EINVAL;
}
hdev = inst->core->device;
switch (b->type) {
case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
@@ -1769,7 +1808,7 @@ int msm_venc_prepare_buf(struct msm_vidc_inst *inst,
b->m.planes[i].m.userptr;
buffer_info.extradata_size = 0;
buffer_info.extradata_addr = 0;
rc = venus_hfi_session_set_buffers(
rc = hdev->session_set_buffers(
(void *)inst->session, &buffer_info);
if (rc)
dprintk(VIDC_ERR,
@@ -1790,6 +1829,15 @@ int msm_venc_release_buf(struct msm_vidc_inst *inst,
int rc = 0;
int i;
struct vidc_buffer_addr_info buffer_info;
struct hfi_device *hdev;
if (!inst || !inst->core || !inst->core->device) {
dprintk(VIDC_ERR, "%s invalid parameters", __func__);
return -EINVAL;
}
hdev = inst->core->device;
rc = msm_comm_try_state(inst, MSM_VIDC_RELEASE_RESOURCES_DONE);
if (rc) {
dprintk(VIDC_ERR,
@@ -1814,7 +1862,7 @@ int msm_venc_release_buf(struct msm_vidc_inst *inst,
buffer_info.extradata_size = 0;
buffer_info.extradata_addr = 0;
buffer_info.response_required = false;
rc = venus_hfi_session_release_buffers(
rc = hdev->session_release_buffers(
(void *)inst->session, &buffer_info);
if (rc)
dprintk(VIDC_ERR,
drivers/media/video/msm_vidc/msm_vidc.c
+7 -4
View File
@@ -1,4 +1,4 @@
/* Copyright (c) 2012, The Linux Foundation. All rights reserved.
/* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
@@ -21,7 +21,7 @@
#include "msm_vidc_common.h"
#include "msm_smem.h"
#include <linux/delay.h>
#include "venus_hfi.h"
#include "vidc_hfi_api.h"
#define MAX_EVENTS 30
@@ -86,11 +86,14 @@ int msm_vidc_get_iommu_maps(void *instance,
struct msm_vidc_iommu_info maps[MAX_MAP])
{
struct msm_vidc_inst *inst = instance;
struct hfi_device *hdev;
if (!inst || !maps || !inst->core)
if (!inst || !maps || !inst->core || !inst->core->device)
return -EINVAL;
return venus_hfi_iommu_get_map(inst->core->device, maps);
hdev = inst->core->device;
return hdev->iommu_get_map(hdev->hfi_device_data, maps);
}
int msm_vidc_querycap(void *instance, struct v4l2_capability *cap)
drivers/media/video/msm_vidc/msm_vidc_common.c
+190 -83
View File
@@ -1,4 +1,4 @@
/* Copyright (c) 2012, The Linux Foundation. All rights reserved.
/* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
@@ -20,7 +20,6 @@
#include "vidc_hfi_api.h"
#include "msm_smem.h"
#include "msm_vidc_debug.h"
#include "venus_hfi.h"
#define HW_RESPONSE_TIMEOUT (5 * 60 * 1000)
@@ -77,14 +76,22 @@ static int msm_comm_scale_bus(struct msm_vidc_core *core,
{
int load;
int rc = 0;
struct hfi_device *hdev;
if (!core || type >= MSM_VIDC_MAX_DEVICES) {
dprintk(VIDC_ERR, "Invalid args: %p, %d\n", core, type);
return -EINVAL;
}
hdev = core->device;
if (!hdev) {
dprintk(VIDC_ERR, "Invalid device handle %p\n", hdev);
return -EINVAL;
}
load = msm_comm_get_load(core, type);
rc = venus_hfi_scale_bus(core->device, load, type, mtype);
rc = hdev->scale_bus(hdev->hfi_device_data, load, type, mtype);
if (rc)
dprintk(VIDC_ERR, "Failed to scale bus: %d\n", rc);
@@ -95,14 +102,23 @@ static void msm_comm_unvote_buses(struct msm_vidc_core *core,
enum mem_type mtype)
{
int i;
struct hfi_device *hdev;
if (!core || !core->device) {
dprintk(VIDC_ERR, "%s invalid parameters", __func__);
return;
}
hdev = core->device;
for (i = 0; i < MSM_VIDC_MAX_DEVICES; i++) {
if ((mtype & DDR_MEM) &&
venus_hfi_scale_bus(core->device, 0, i, DDR_MEM)) {
hdev->scale_bus(hdev->hfi_device_data, 0, i, DDR_MEM)) {
dprintk(VIDC_WARN,
"Failed to unvote for DDR accesses\n");
}
if ((mtype & OCMEM_MEM) &&
venus_hfi_scale_bus(core->device, 0, i, OCMEM_MEM)) {
hdev->scale_bus(hdev->hfi_device_data, 0, i,
OCMEM_MEM)) {
dprintk(VIDC_WARN,
"Failed to unvote for OCMEM accesses\n");
}
@@ -876,15 +892,23 @@ static int msm_comm_scale_clocks(struct msm_vidc_core *core)
{
int num_mbs_per_sec;
int rc = 0;
struct hfi_device *hdev;
if (!core) {
dprintk(VIDC_ERR, "Invalid args: %p\n", core);
dprintk(VIDC_ERR, "%s Invalid args: %p\n", __func__, core);
return -EINVAL;
}
hdev = core->device;
if (!hdev) {
dprintk(VIDC_ERR, "%s Invalid device handle: %p\n",
__func__, hdev);
return -EINVAL;
}
num_mbs_per_sec = msm_comm_get_load(core, MSM_VIDC_ENCODER);
num_mbs_per_sec += msm_comm_get_load(core, MSM_VIDC_DECODER);
dprintk(VIDC_INFO, "num_mbs_per_sec = %d\n", num_mbs_per_sec);
rc = venus_hfi_scale_clocks(core->device, num_mbs_per_sec);
rc = hdev->scale_clocks(hdev->hfi_device_data, num_mbs_per_sec);
if (rc)
dprintk(VIDC_ERR, "Failed to set clock rate: %d\n", rc);
return rc;
@@ -892,12 +916,16 @@ static int msm_comm_scale_clocks(struct msm_vidc_core *core)
void msm_comm_scale_clocks_and_bus(struct msm_vidc_inst *inst)
{
struct msm_vidc_core *core = inst->core;
struct msm_vidc_core *core;
struct hfi_device *hdev;
if (!inst) {
dprintk(VIDC_WARN, "Invalid params\n");
if (!inst || !inst->core || !inst->core->device) {
dprintk(VIDC_ERR, "%s Invalid params\n", __func__);
return;
}
core = inst->core;
hdev = core->device;
if (msm_comm_scale_clocks(core)) {
dprintk(VIDC_WARN,
"Failed to scale clocks. Performance might be impacted\n");
@@ -906,7 +934,7 @@ void msm_comm_scale_clocks_and_bus(struct msm_vidc_inst *inst)
dprintk(VIDC_WARN,
"Failed to scale DDR bus. Performance might be impacted\n");
}
if (venus_hfi_is_ocmem_present(core->device)) {
if (hdev->is_ocmem_present(hdev->hfi_device_data)) {
if (msm_comm_scale_bus(core, inst->session_type,
OCMEM_MEM))
dprintk(VIDC_WARN,
@@ -926,6 +954,14 @@ static inline unsigned long get_ocmem_requirement(u32 height, u32 width)
static int msm_comm_unset_ocmem(struct msm_vidc_core *core)
{
int rc = 0;
struct hfi_device *hdev;
if (!core || !core->device) {
dprintk(VIDC_ERR, "%s invalid parameters", __func__);
return -EINVAL;
}
hdev = core->device;
if (core->state == VIDC_CORE_INVALID) {
dprintk(VIDC_ERR,
"Core is in bad state. Cannot unset ocmem\n");
@@ -935,7 +971,7 @@ static int msm_comm_unset_ocmem(struct msm_vidc_core *core)
init_completion(
&core->completions[SYS_MSG_INDEX(RELEASE_RESOURCE_DONE)]);
rc = venus_hfi_unset_ocmem(core->device);
rc = hdev->unset_ocmem(hdev->hfi_device_data);
if (rc) {
dprintk(VIDC_ERR, "Failed to set OCMEM on driver\n");
goto release_ocmem_failed;
@@ -951,39 +987,6 @@ release_ocmem_failed:
return rc;
}
int msm_vidc_ocmem_notify_handler(struct notifier_block *this,
unsigned long event, void *data)
{
struct ocmem_buf *buff = data;
struct msm_vidc_core *core;
struct venus_hfi_device *device;
struct venus_resources *resources;
struct on_chip_mem *ocmem;
int rc = NOTIFY_DONE;
if (event == OCMEM_ALLOC_GROW) {
ocmem = container_of(this, struct on_chip_mem, vidc_ocmem_nb);
if (!ocmem) {
dprintk(VIDC_ERR, "Wrong handler passed\n");
rc = NOTIFY_BAD;
goto bad_notfier;
}
resources = container_of(ocmem,
struct venus_resources, ocmem);
device = container_of(resources,
struct venus_hfi_device, resources);
core = container_of((void *)device,
struct msm_vidc_core, device);
if (venus_hfi_set_ocmem(core->device, buff)) {
dprintk(VIDC_ERR, "Failed to set ocmem: %d\n", rc);
goto ocmem_set_failed;
}
rc = NOTIFY_OK;
}
ocmem_set_failed:
bad_notfier:
return rc;
}
static int msm_comm_init_core_done(struct msm_vidc_inst *inst)
{
struct msm_vidc_core *core = inst->core;
@@ -1022,11 +1025,11 @@ static int msm_comm_init_core(struct msm_vidc_inst *inst)
int rc = 0;
struct msm_vidc_core *core = inst->core;
unsigned long flags;
struct venus_hfi_device *device;
struct hfi_device *hdev;
if (!core || !core->device)
return -EINVAL;
device = core->device;
hdev = core->device;
mutex_lock(&core->sync_lock);
if (core->state >= VIDC_CORE_INIT) {
@@ -1041,7 +1044,7 @@ static int msm_comm_init_core(struct msm_vidc_inst *inst)
goto fail_scale_bus;
}
rc = venus_hfi_load_fw(core->device);
rc = hdev->load_fw(hdev->hfi_device_data);
if (rc) {
dprintk(VIDC_ERR, "Failed to load video firmware\n");
goto fail_load_fw;
@@ -1053,7 +1056,7 @@ static int msm_comm_init_core(struct msm_vidc_inst *inst)
}
init_completion(&core->completions[SYS_MSG_INDEX(SYS_INIT_DONE)]);
rc = venus_hfi_core_init(core->device);
rc = hdev->core_init(hdev->hfi_device_data);
if (rc) {
dprintk(VIDC_ERR, "Failed to init core, id = %d\n", core->id);
goto fail_core_init;
@@ -1066,7 +1069,7 @@ core_already_inited:
mutex_unlock(&core->sync_lock);
return rc;
fail_core_init:
venus_hfi_unload_fw(core->device);
hdev->unload_fw(hdev->hfi_device_data);
fail_load_fw:
msm_comm_unvote_buses(core, DDR_MEM);
fail_scale_bus:
@@ -1077,8 +1080,18 @@ fail_scale_bus:
static int msm_vidc_deinit_core(struct msm_vidc_inst *inst)
{
int rc = 0;
struct msm_vidc_core *core = inst->core;
struct msm_vidc_core *core;
struct hfi_device *hdev;
unsigned long flags;
if (!inst || !inst->core || !inst->core->device) {
dprintk(VIDC_ERR, "%s invalid parameters", __func__);
return -EINVAL;
}
core = inst->core;
hdev = core->device;
mutex_lock(&core->sync_lock);
if (core->state == VIDC_CORE_UNINIT) {
dprintk(VIDC_INFO, "Video core: %d is already in state: %d\n",
@@ -1088,9 +1101,9 @@ static int msm_vidc_deinit_core(struct msm_vidc_inst *inst)
msm_comm_scale_clocks_and_bus(inst);
if (list_empty(&core->instances)) {
msm_comm_unset_ocmem(core);
venus_hfi_free_ocmem(core->device);
hdev->free_ocmem(hdev->hfi_device_data);
dprintk(VIDC_DBG, "Calling vidc_hal_core_release\n");
rc = venus_hfi_core_release(core->device);
rc = hdev->core_release(hdev->hfi_device_data);
if (rc) {
dprintk(VIDC_ERR, "Failed to release core, id = %d\n",
core->id);
@@ -1099,7 +1112,7 @@ static int msm_vidc_deinit_core(struct msm_vidc_inst *inst)
spin_lock_irqsave(&core->lock, flags);
core->state = VIDC_CORE_UNINIT;
spin_unlock_irqrestore(&core->lock, flags);
venus_hfi_unload_fw(core->device);
hdev->unload_fw(hdev->hfi_device_data);
msm_comm_unvote_buses(core, DDR_MEM|OCMEM_MEM);
}
core_already_uninited:
@@ -1182,6 +1195,14 @@ static int msm_comm_session_init(int flipped_state,
{
int rc = 0;
int fourcc = 0;
struct hfi_device *hdev;
if (!inst || !inst->core || !inst->core->device) {
dprintk(VIDC_ERR, "%s invalid parameters", __func__);
return -EINVAL;
}
hdev = inst->core->device;
if (IS_ALREADY_IN_STATE(flipped_state, MSM_VIDC_OPEN)) {
dprintk(VIDC_INFO, "inst: %p is already in state: %d\n",
inst, inst->state);
@@ -1197,7 +1218,7 @@ static int msm_comm_session_init(int flipped_state,
}
init_completion(
&inst->completions[SESSION_MSG_INDEX(SESSION_INIT_DONE)]);
inst->session = venus_hfi_session_init(inst->core->device, (u32) inst,
inst->session = hdev->session_init(hdev->hfi_device_data, (u32) inst,
get_hal_domain(inst->session_type),
get_hal_codec_type(fourcc));
if (!inst->session) {
@@ -1218,6 +1239,14 @@ static int msm_vidc_load_resources(int flipped_state,
{
int rc = 0;
u32 ocmem_sz = 0;
struct hfi_device *hdev;
if (!inst || !inst->core || !inst->core->device) {
dprintk(VIDC_ERR, "%s invalid parameters", __func__);
return -EINVAL;
}
hdev = inst->core->device;
if (IS_ALREADY_IN_STATE(flipped_state, MSM_VIDC_LOAD_RESOURCES)) {
dprintk(VIDC_INFO, "inst: %p is already in state: %d\n",
inst, inst->state);
@@ -1227,7 +1256,7 @@ static int msm_vidc_load_resources(int flipped_state,
rc = msm_comm_scale_bus(inst->core, inst->session_type, OCMEM_MEM);
if (!rc) {
mutex_lock(&inst->core->sync_lock);
rc = venus_hfi_alloc_ocmem(inst->core->device, ocmem_sz);
rc = hdev->alloc_ocmem(hdev->hfi_device_data, ocmem_sz);
mutex_unlock(&inst->core->sync_lock);
if (rc) {
dprintk(VIDC_WARN,
@@ -1238,7 +1267,7 @@ static int msm_vidc_load_resources(int flipped_state,
dprintk(VIDC_WARN,
"Failed to vote for OCMEM BW. Performance will be impacted\n");
}
rc = venus_hfi_session_load_res((void *) inst->session);
rc = hdev->session_load_res((void *) inst->session);
if (rc) {
dprintk(VIDC_ERR,
"Failed to send load resources\n");
@@ -1252,6 +1281,15 @@ exit:
static int msm_vidc_start(int flipped_state, struct msm_vidc_inst *inst)
{
int rc = 0;
struct hfi_device *hdev;
if (!inst || !inst->core || !inst->core->device) {
dprintk(VIDC_ERR, "%s invalid parameters", __func__);
return -EINVAL;
}
hdev = inst->core->device;
if (IS_ALREADY_IN_STATE(flipped_state, MSM_VIDC_START)) {
dprintk(VIDC_INFO,
"inst: %p is already in state: %d\n",
@@ -1260,7 +1298,7 @@ static int msm_vidc_start(int flipped_state, struct msm_vidc_inst *inst)
}
init_completion(
&inst->completions[SESSION_MSG_INDEX(SESSION_START_DONE)]);
rc = venus_hfi_session_start((void *) inst->session);
rc = hdev->session_start((void *) inst->session);
if (rc) {
dprintk(VIDC_ERR,
"Failed to send start\n");
@@ -1274,6 +1312,14 @@ exit:
static int msm_vidc_stop(int flipped_state, struct msm_vidc_inst *inst)
{
int rc = 0;
struct hfi_device *hdev;
if (!inst || !inst->core || !inst->core->device) {
dprintk(VIDC_ERR, "%s invalid parameters", __func__);
return -EINVAL;
}
hdev = inst->core->device;
if (IS_ALREADY_IN_STATE(flipped_state, MSM_VIDC_STOP)) {
dprintk(VIDC_INFO,
"inst: %p is already in state: %d\n",
@@ -1283,7 +1329,7 @@ static int msm_vidc_stop(int flipped_state, struct msm_vidc_inst *inst)
dprintk(VIDC_DBG, "Send Stop to hal\n");
init_completion(
&inst->completions[SESSION_MSG_INDEX(SESSION_STOP_DONE)]);
rc = venus_hfi_session_stop((void *) inst->session);
rc = hdev->session_stop((void *) inst->session);
if (rc) {
dprintk(VIDC_ERR, "Failed to send stop\n");
goto exit;
@@ -1296,6 +1342,14 @@ exit:
static int msm_vidc_release_res(int flipped_state, struct msm_vidc_inst *inst)
{
int rc = 0;
struct hfi_device *hdev;
if (!inst || !inst->core || !inst->core->device) {
dprintk(VIDC_ERR, "%s invalid parameters", __func__);
return -EINVAL;
}
hdev = inst->core->device;
if (IS_ALREADY_IN_STATE(flipped_state, MSM_VIDC_RELEASE_RESOURCES)) {
dprintk(VIDC_INFO,
"inst: %p is already in state: %d\n",
@@ -1306,7 +1360,7 @@ static int msm_vidc_release_res(int flipped_state, struct msm_vidc_inst *inst)
"Send release res to hal\n");
init_completion(
&inst->completions[SESSION_MSG_INDEX(SESSION_RELEASE_RESOURCE_DONE)]);
rc = venus_hfi_session_release_res((void *) inst->session);
rc = hdev->session_release_res((void *) inst->session);
if (rc) {
dprintk(VIDC_ERR,
"Failed to send release resources\n");
@@ -1317,9 +1371,17 @@ exit:
return rc;
}
static int msm_comm_session_close(int flipped_state, struct msm_vidc_inst *inst)
static int msm_comm_session_close(int flipped_state,
struct msm_vidc_inst *inst)
{
int rc = 0;
struct hfi_device *hdev;
if (!inst || !inst->core || !inst->core->device) {
dprintk(VIDC_ERR, "%s invalid params", __func__);
return -EINVAL;
}
hdev = inst->core->device;
if (IS_ALREADY_IN_STATE(flipped_state, MSM_VIDC_CLOSE)) {
dprintk(VIDC_INFO,
"inst: %p is already in state: %d\n",
@@ -1330,7 +1392,7 @@ static int msm_comm_session_close(int flipped_state, struct msm_vidc_inst *inst)
"Send session close to hal\n");
init_completion(
&inst->completions[SESSION_MSG_INDEX(SESSION_END_DONE)]);
rc = venus_hfi_session_end((void *) inst->session);
rc = hdev->session_end((void *) inst->session);
if (rc) {
dprintk(VIDC_ERR,
"Failed to send close\n");
@@ -1479,6 +1541,7 @@ int msm_comm_qbuf(struct vb2_buffer *vb)
struct vb2_buf_entry *entry;
struct vidc_frame_data frame_data;
struct msm_vidc_core *core;
struct hfi_device *hdev;
q = vb->vb2_queue;
inst = q->drv_priv;
if (!inst || !vb) {
@@ -1491,6 +1554,11 @@ int msm_comm_qbuf(struct vb2_buffer *vb)
"Invalid input: %p, %p, %p\n", inst, core, vb);
return -EINVAL;
}
hdev = core->device;
if (!hdev) {
dprintk(VIDC_ERR, "Invalid input: %p", hdev);
return -EINVAL;
}
if (inst->state == MSM_VIDC_CORE_INVALID ||
core->state == VIDC_CORE_INVALID) {
@@ -1534,7 +1602,7 @@ int msm_comm_qbuf(struct vb2_buffer *vb)
dprintk(VIDC_DBG,
"Sending etb to hal: Alloc: %d :filled: %d\n",
frame_data.alloc_len, frame_data.filled_len);
rc = venus_hfi_session_etb((void *) inst->session,
rc = hdev->session_etb((void *) inst->session,
&frame_data);
if (!rc)
msm_vidc_debugfs_update(inst,
@@ -1564,7 +1632,7 @@ int msm_comm_qbuf(struct vb2_buffer *vb)
seq_hdr.seq_hdr = (u8 *) vb->v4l2_planes[0].
m.userptr;
seq_hdr.seq_hdr_len = vb->v4l2_planes[0].length;
rc = venus_hfi_session_get_seq_hdr((void *)
rc = hdev->session_get_seq_hdr((void *)
inst->session, &seq_hdr);
if (!rc) {
inst->vb2_seq_hdr = vb;
@@ -1572,7 +1640,7 @@ int msm_comm_qbuf(struct vb2_buffer *vb)
inst->vb2_seq_hdr);
}
} else {
rc = venus_hfi_session_ftb((void *)
rc = hdev->session_ftb((void *)
inst->session, &frame_data);
if (!rc)
msm_vidc_debugfs_update(inst,
@@ -1595,6 +1663,14 @@ err_no_mem:
int msm_comm_try_get_bufreqs(struct msm_vidc_inst *inst)
{
int rc = 0;
struct hfi_device *hdev;
if (!inst || !inst->core || !inst->core->device) {
dprintk(VIDC_ERR, "%s invalid parameters", __func__);
return -EINVAL;
}
hdev = inst->core->device;
mutex_lock(&inst->sync_lock);
if (inst->state < MSM_VIDC_OPEN_DONE || inst->state >= MSM_VIDC_CLOSE) {
dprintk(VIDC_ERR,
@@ -1604,7 +1680,7 @@ int msm_comm_try_get_bufreqs(struct msm_vidc_inst *inst)
}
init_completion(
&inst->completions[SESSION_MSG_INDEX(SESSION_PROPERTY_INFO)]);
rc = venus_hfi_session_get_buf_req((void *) inst->session);
rc = hdev->session_get_buf_req((void *) inst->session);
if (rc) {
dprintk(VIDC_ERR, "Failed to get property\n");
goto exit;
@@ -1632,6 +1708,7 @@ int msm_comm_release_scratch_buffers(struct msm_vidc_inst *inst)
int rc = 0;
unsigned long flags;
struct msm_vidc_core *core;
struct hfi_device *hdev;
if (!inst) {
dprintk(VIDC_ERR,
"Invalid instance pointer = %p\n", inst);
@@ -1643,6 +1720,11 @@ int msm_comm_release_scratch_buffers(struct msm_vidc_inst *inst)
"Invalid core pointer = %p\n", core);
return -EINVAL;
}
hdev = core->device;
if (!hdev) {
dprintk(VIDC_ERR, "Invalid device pointer = %p\n", hdev);
return -EINVAL;
}
spin_lock_irqsave(&inst->lock, flags);
if (!list_empty(&inst->internalbufs)) {
list_for_each_safe(ptr, next, &inst->internalbufs) {
@@ -1659,7 +1741,7 @@ int msm_comm_release_scratch_buffers(struct msm_vidc_inst *inst)
init_completion(
&inst->completions[SESSION_MSG_INDEX
(SESSION_RELEASE_BUFFER_DONE)]);
rc = venus_hfi_session_release_buffers(
rc = hdev->session_release_buffers(
(void *) inst->session,
&buffer_info);
if (rc)
@@ -1692,6 +1774,7 @@ int msm_comm_release_persist_buffers(struct msm_vidc_inst *inst)
int rc = 0;
unsigned long flags;
struct msm_vidc_core *core;
struct hfi_device *hdev;
if (!inst) {
dprintk(VIDC_ERR,
"Invalid instance pointer = %p\n", inst);
@@ -1703,6 +1786,11 @@ int msm_comm_release_persist_buffers(struct msm_vidc_inst *inst)
"Invalid core pointer = %p\n", core);
return -EINVAL;
}
hdev = core->device;
if (!hdev) {
dprintk(VIDC_ERR, "Invalid device pointer = %p\n", hdev);
return -EINVAL;
}
spin_lock_irqsave(&inst->lock, flags);
if (!list_empty(&inst->persistbufs)) {
list_for_each_safe(ptr, next, &inst->persistbufs) {
@@ -1719,7 +1807,7 @@ int msm_comm_release_persist_buffers(struct msm_vidc_inst *inst)
init_completion(
&inst->completions[SESSION_MSG_INDEX
(SESSION_RELEASE_BUFFER_DONE)]);
rc = venus_hfi_session_release_buffers(
rc = hdev->session_release_buffers(
(void *) inst->session,
&buffer_info);
if (rc)
@@ -1747,17 +1835,25 @@ int msm_comm_try_set_prop(struct msm_vidc_inst *inst,
enum hal_property ptype, void *pdata)
{
int rc = 0;
struct hfi_device *hdev;
if (!inst) {
dprintk(VIDC_ERR, "Invalid input: %p\n", inst);
return -EINVAL;
}
if (!inst->core || !inst->core->device) {
dprintk(VIDC_ERR, "%s invalid parameters", __func__);
return -EINVAL;
}
hdev = inst->core->device;
mutex_lock(&inst->sync_lock);
if (inst->state < MSM_VIDC_OPEN_DONE || inst->state >= MSM_VIDC_CLOSE) {
dprintk(VIDC_ERR, "Not in proper state to set property\n");
rc = -EAGAIN;
goto exit;
}
rc = venus_hfi_session_set_property((void *)inst->session,
rc = hdev->session_set_property((void *)inst->session,
ptype, pdata);
if (rc)
dprintk(VIDC_ERR, "Failed to set hal property for framesize\n");
@@ -1777,12 +1873,15 @@ int msm_comm_set_scratch_buffers(struct msm_vidc_inst *inst)
unsigned long smem_flags = 0;
struct hal_buffer_requirements *scratch_buf;
int i;
struct venus_hfi_device *device;
struct hfi_device *hdev;
if (!inst || !inst->core || !inst->core->device)
if (!inst || !inst->core || !inst->core->device) {
dprintk(VIDC_ERR, "%s invalid parameters", __func__);
return -EINVAL;
}
hdev = inst->core->device;
device = inst->core->device;
scratch_buf =
&inst->buff_req.buffer[HAL_BUFFER_INTERNAL_SCRATCH];
dprintk(VIDC_DBG,
@@ -1792,10 +1891,10 @@ int msm_comm_set_scratch_buffers(struct msm_vidc_inst *inst)
if (msm_comm_release_scratch_buffers(inst))
dprintk(VIDC_WARN, "Failed to release scratch buffers\n");
if (inst->mode == VIDC_SECURE) {
domain = venus_hfi_get_domain(device, CP_MAP);
domain = hdev->get_domain(hdev->hfi_device_data, CP_MAP);
smem_flags |= SMEM_SECURE;
} else
domain = venus_hfi_get_domain(device, NS_MAP);
domain = hdev->get_domain(hdev->hfi_device_data, NS_MAP);
if (scratch_buf->buffer_size) {
for (i = 0; i < scratch_buf->buffer_count_actual;
@@ -1822,7 +1921,7 @@ int msm_comm_set_scratch_buffers(struct msm_vidc_inst *inst)
buffer_info.align_device_addr = handle->device_addr;
dprintk(VIDC_DBG, "Scratch buffer address: %x",
buffer_info.align_device_addr);
rc = venus_hfi_session_set_buffers(
rc = hdev->session_set_buffers(
(void *) inst->session, &buffer_info);
if (rc) {
dprintk(VIDC_ERR,
@@ -1854,12 +1953,14 @@ int msm_comm_set_persist_buffers(struct msm_vidc_inst *inst)
int domain;
struct hal_buffer_requirements *persist_buf;
int i;
struct venus_hfi_device *device;
struct hfi_device *hdev;
if (!inst || !inst->core || !inst->core->device)
if (!inst || !inst->core || !inst->core->device) {
dprintk(VIDC_ERR, "%s invalid parameters", __func__);
return -EINVAL;
}
device = inst->core->device;
hdev = inst->core->device;
persist_buf =
&inst->buff_req.buffer[HAL_BUFFER_INTERNAL_PERSIST];
@@ -1874,10 +1975,10 @@ int msm_comm_set_persist_buffers(struct msm_vidc_inst *inst)
}
if (inst->mode == VIDC_SECURE) {
domain = venus_hfi_get_domain(device, CP_MAP);
domain = hdev->get_domain(hdev->hfi_device_data, CP_MAP);
flags |= SMEM_SECURE;
} else
domain = venus_hfi_get_domain(device, NS_MAP);
domain = hdev->get_domain(hdev->hfi_device_data, NS_MAP);
if (persist_buf->buffer_size) {
for (i = 0; i < persist_buf->buffer_count_actual; i++) {
@@ -1903,7 +2004,7 @@ int msm_comm_set_persist_buffers(struct msm_vidc_inst *inst)
buffer_info.align_device_addr = handle->device_addr;
dprintk(VIDC_DBG, "Persist buffer address: %x",
buffer_info.align_device_addr);
rc = venus_hfi_session_set_buffers(
rc = hdev->session_set_buffers(
(void *) inst->session, &buffer_info);
if (rc) {
dprintk(VIDC_ERR,
@@ -1977,6 +2078,7 @@ int msm_comm_flush(struct msm_vidc_inst *inst, u32 flags)
struct vb2_buf_entry *temp;
struct mutex *lock;
struct msm_vidc_core *core;
struct hfi_device *hdev;
if (!inst) {
dprintk(VIDC_ERR,
"Invalid instance pointer = %p\n", inst);
@@ -1988,6 +2090,11 @@ int msm_comm_flush(struct msm_vidc_inst *inst, u32 flags)
"Invalid core pointer = %p\n", core);
return -EINVAL;
}
hdev = core->device;
if (!hdev) {
dprintk(VIDC_ERR, "Invalid device pointer = %p", hdev);
return -EINVAL;
}
ip_flush = flags & V4L2_QCOM_CMD_FLUSH_OUTPUT;
op_flush = flags & V4L2_QCOM_CMD_FLUSH_CAPTURE;
@@ -2014,7 +2121,7 @@ int msm_comm_flush(struct msm_vidc_inst *inst, u32 flags)
dprintk(VIDC_WARN,
"FLUSH BUG: Pending q not empty! It should be empty\n");
}
rc = venus_hfi_session_flush(inst->session,
rc = hdev->session_flush(inst->session,
HAL_FLUSH_OUTPUT);
} else {
if (!list_empty(&inst->pendingq)) {
@@ -2035,7 +2142,7 @@ int msm_comm_flush(struct msm_vidc_inst *inst, u32 flags)
kfree(temp);
}
}
rc = venus_hfi_session_flush(inst->session,
rc = hdev->session_flush(inst->session,
HAL_FLUSH_ALL);
}
mutex_unlock(&inst->sync_lock);
drivers/media/video/msm_vidc/msm_vidc_debug.c
+12 -8
View File
@@ -1,4 +1,4 @@
/* Copyright (c) 2012, The Linux Foundation. All rights reserved.
/* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
@@ -12,7 +12,7 @@
*/
#include "msm_vidc_debug.h"
#include "venus_hfi.h"
#include "vidc_hfi_api.h"
#define MAX_DBG_BUF_SIZE 4096
int msm_vidc_debug = 0x3;
@@ -53,22 +53,26 @@ static ssize_t core_info_read(struct file *file, char __user *buf,
size_t count, loff_t *ppos)
{
struct msm_vidc_core *core = file->private_data;
struct venus_hfi_device *device;
struct hfi_device *hdev;
int i = 0;
if (!core || !core->device) {
dprintk(VIDC_ERR, "Invalid params, core: %p\n", core);
return 0;
}
device = core->device;
hdev = core->device;
INIT_DBG_BUF(dbg_buf);
write_str(&dbg_buf, "===============================\n");
write_str(&dbg_buf, "CORE %d: 0x%p\n", core->id, core);
write_str(&dbg_buf, "===============================\n");
write_str(&dbg_buf, "state: %d\n", core->state);
write_str(&dbg_buf, "base addr: 0x%x\n", device->base_addr);
write_str(&dbg_buf, "register_base: 0x%x\n", device->register_base);
write_str(&dbg_buf, "register_size: %u\n", device->register_size);
write_str(&dbg_buf, "irq: %u\n", device->irq);
write_str(&dbg_buf, "base addr: 0x%x\n",
hdev->get_fw_info(hdev->hfi_device_data, FW_BASE_ADDRESS));
write_str(&dbg_buf, "register_base: 0x%x\n",
hdev->get_fw_info(hdev->hfi_device_data, FW_REGISTER_BASE));
write_str(&dbg_buf, "register_size: %u\n",
hdev->get_fw_info(hdev->hfi_device_data, FW_REGISTER_SIZE));
write_str(&dbg_buf, "irq: %u\n",
hdev->get_fw_info(hdev->hfi_device_data, FW_IRQ));
for (i = SYS_MSG_START; i < SYS_MSG_END; i++) {
write_str(&dbg_buf, "completions[%d]: %s\n", i,
completion_done(&core->completions[SYS_MSG_INDEX(i)]) ?
drivers/media/video/msm_vidc/msm_vidc_internal.h
+1 -7
View File
@@ -31,6 +31,7 @@
#include <media/msm_vidc.h>
#include <media/msm_media_info.h>
#include "vidc_hfi_api.h"
#include "vidc_hfi_api.h"
#define MSM_VIDC_DRV_NAME "msm_vidc_driver"
@@ -165,11 +166,6 @@ enum msm_vidc_mode {
VIDC_SECURE,
};
enum msm_vidc_hfi_type {
VIDC_HFI_VENUS,
VIDC_HFI_Q6,
};
struct msm_vidc_core {
struct list_head list;
struct mutex sync_lock;
@@ -241,6 +237,4 @@ struct msm_vidc_ctrl {
};
void handle_cmd_response(enum command_response cmd, void *data);
int msm_vidc_ocmem_notify_handler(struct notifier_block *this,
unsigned long event, void *data);
#endif
drivers/media/video/msm_vidc/venus_hfi.c
+263 -75
View File
@@ -1,4 +1,4 @@
/* Copyright (c) 2012, The Linux Foundation. All rights reserved.
/* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
@@ -37,8 +37,6 @@
#define SHARED_QSIZE 0x1000000
struct hal_device_data hal_ctxt;
static struct msm_bus_vectors enc_ocmem_init_vectors[] = {
{
.src = MSM_BUS_MASTER_VIDEO_P0_OCMEM,
@@ -840,7 +838,7 @@ err_q_write:
return result;
}
int venus_hfi_iface_msgq_read(struct venus_hfi_device *device, void *pkt)
static int venus_hfi_iface_msgq_read(struct venus_hfi_device *device, void *pkt)
{
u32 tx_req_is_set = 0;
int rc = 0;
@@ -875,7 +873,7 @@ read_error:
return rc;
}
int venus_hfi_iface_dbgq_read(struct venus_hfi_device *device, void *pkt)
static int venus_hfi_iface_dbgq_read(struct venus_hfi_device *device, void *pkt)
{
u32 tx_req_is_set = 0;
int rc = 0;
@@ -1146,7 +1144,7 @@ static int venus_hfi_sys_set_debug(struct venus_hfi_device *device, int debug)
return 0;
}
int venus_hfi_core_init(void *device)
static int venus_hfi_core_init(void *device)
{
struct hfi_cmd_sys_init_packet pkt;
int rc = 0;
@@ -1214,7 +1212,7 @@ err_core_init:
return rc;
}
int venus_hfi_core_release(void *device)
static int venus_hfi_core_release(void *device)
{
struct venus_hfi_device *dev;
if (device) {
@@ -1288,7 +1286,7 @@ static void venus_hfi_core_clear_interrupt(struct venus_hfi_device *device)
dprintk(VIDC_DBG, "Cleared WRAPPER/A2H interrupt");
}
int venus_hfi_core_set_resource(void *device,
static int venus_hfi_core_set_resource(void *device,
struct vidc_resource_hdr *resource_hdr, void *resource_value)
{
struct hfi_cmd_sys_set_resource_packet *pkt;
@@ -1318,7 +1316,7 @@ err_create_pkt:
return rc;
}
int venus_hfi_core_release_resource(void *device,
static int venus_hfi_core_release_resource(void *device,
struct vidc_resource_hdr *resource_hdr)
{
struct hfi_cmd_sys_release_resource_packet pkt;
@@ -1345,7 +1343,7 @@ err_create_pkt:
return rc;
}
int venus_hfi_core_ping(void *device)
static int venus_hfi_core_ping(void *device)
{
struct hfi_cmd_sys_ping_packet pkt;
int rc = 0;
@@ -1371,8 +1369,8 @@ err_create_pkt:
return rc;
}
int venus_hfi_session_set_property(void *sess,
enum hal_property ptype, void *pdata)
static int venus_hfi_session_set_property(void *sess,
enum hal_property ptype, void *pdata)
{
u8 packet[VIDC_IFACEQ_VAR_LARGE_PKT_SIZE];
struct hfi_cmd_session_set_property_packet *pkt =
@@ -1401,8 +1399,8 @@ int venus_hfi_session_set_property(void *sess,
return rc;
}
int venus_hfi_session_get_property(void *sess,
enum hal_property ptype, void *pdata)
static int venus_hfi_session_get_property(void *sess,
enum hal_property ptype, void *pdata)
{
struct hal_session *session;
@@ -1524,8 +1522,8 @@ int venus_hfi_session_get_property(void *sess,
return 0;
}
void *venus_hfi_session_init(void *device, u32 session_id,
enum hal_domain session_type, enum hal_video_codec codec_type)
static void *venus_hfi_session_init(void *device, u32 session_id,
enum hal_domain session_type, enum hal_video_codec codec_type)
{
struct hfi_cmd_sys_session_init_packet pkt;
struct hal_session *new_session;
@@ -1592,20 +1590,20 @@ err_create_pkt:
return rc;
}
int venus_hfi_session_end(void *session)
static int venus_hfi_session_end(void *session)
{
return venus_hfi_send_session_cmd(session,
HFI_CMD_SYS_SESSION_END);
}
int venus_hfi_session_abort(void *session)
static int venus_hfi_session_abort(void *session)
{
return venus_hfi_send_session_cmd(session,
HFI_CMD_SYS_SESSION_ABORT);
}
int venus_hfi_session_set_buffers(void *sess,
struct vidc_buffer_addr_info *buffer_info)
static int venus_hfi_session_set_buffers(void *sess,
struct vidc_buffer_addr_info *buffer_info)
{
struct hfi_cmd_session_set_buffers_packet *pkt;
u8 packet[VIDC_IFACEQ_VAR_LARGE_PKT_SIZE];
@@ -1638,8 +1636,8 @@ err_create_pkt:
return rc;
}
int venus_hfi_session_release_buffers(void *sess,
struct vidc_buffer_addr_info *buffer_info)
static int venus_hfi_session_release_buffers(void *sess,
struct vidc_buffer_addr_info *buffer_info)
{
struct hfi_cmd_session_release_buffer_packet *pkt;
u8 packet[VIDC_IFACEQ_VAR_LARGE_PKT_SIZE];
@@ -1672,43 +1670,44 @@ err_create_pkt:
return rc;
}
int venus_hfi_session_load_res(void *sess)
static int venus_hfi_session_load_res(void *sess)
{
return venus_hfi_send_session_cmd(sess,
HFI_CMD_SESSION_LOAD_RESOURCES);
}
int venus_hfi_session_release_res(void *sess)
static int venus_hfi_session_release_res(void *sess)
{
return venus_hfi_send_session_cmd(sess,
HFI_CMD_SESSION_RELEASE_RESOURCES);
}
int venus_hfi_session_start(void *sess)
static int venus_hfi_session_start(void *sess)
{
return venus_hfi_send_session_cmd(sess,
HFI_CMD_SESSION_START);
}
int venus_hfi_session_stop(void *sess)
static int venus_hfi_session_stop(void *sess)
{
return venus_hfi_send_session_cmd(sess,
HFI_CMD_SESSION_STOP);
}
int venus_hfi_session_suspend(void *sess)
static int venus_hfi_session_suspend(void *sess)
{
return venus_hfi_send_session_cmd(sess,
HFI_CMD_SESSION_SUSPEND);
}
int venus_hfi_session_resume(void *sess)
static int venus_hfi_session_resume(void *sess)
{
return venus_hfi_send_session_cmd(sess,
HFI_CMD_SESSION_RESUME);
}
int venus_hfi_session_etb(void *sess, struct vidc_frame_data *input_frame)
static int venus_hfi_session_etb(void *sess,
struct vidc_frame_data *input_frame)
{
int rc = 0;
struct hal_session *session;
@@ -1752,8 +1751,8 @@ err_create_pkt:
return rc;
}
int venus_hfi_session_ftb(void *sess,
struct vidc_frame_data *output_frame)
static int venus_hfi_session_ftb(void *sess,
struct vidc_frame_data *output_frame)
{
struct hfi_cmd_session_fill_buffer_packet pkt;
int rc = 0;
@@ -1778,8 +1777,8 @@ err_create_pkt:
return rc;
}
int venus_hfi_session_parse_seq_hdr(void *sess,
struct vidc_seq_hdr *seq_hdr)
static int venus_hfi_session_parse_seq_hdr(void *sess,
struct vidc_seq_hdr *seq_hdr)
{
struct hfi_cmd_session_parse_sequence_header_packet *pkt;
int rc = 0;
@@ -1809,8 +1808,8 @@ err_create_pkt:
return rc;
}
int venus_hfi_session_get_seq_hdr(void *sess,
struct vidc_seq_hdr *seq_hdr)
static int venus_hfi_session_get_seq_hdr(void *sess,
struct vidc_seq_hdr *seq_hdr)
{
struct hfi_cmd_session_get_sequence_header_packet *pkt;
int rc = 0;
@@ -1837,7 +1836,7 @@ err_create_pkt:
return rc;
}
int venus_hfi_session_get_buf_req(void *sess)
static int venus_hfi_session_get_buf_req(void *sess)
{
struct hfi_cmd_session_get_property_packet pkt;
int rc = 0;
@@ -1862,7 +1861,7 @@ err_create_pkt:
return rc;
}
int venus_hfi_session_flush(void *sess, enum hal_flush flush_mode)
static int venus_hfi_session_flush(void *sess, enum hal_flush flush_mode)
{
struct hfi_cmd_session_flush_packet pkt;
int rc = 0;
@@ -1937,6 +1936,44 @@ static int venus_hfi_check_core_registered(
return -EINVAL;
}
static void venus_hfi_process_sys_watchdog_timeout(
struct venus_hfi_device *device)
{
struct msm_vidc_cb_cmd_done cmd_done;
device->intr_status &= ~VIDC_WRAPPER_INTR_STATUS_A2HWD_BMSK;
memset(&cmd_done, 0, sizeof(struct msm_vidc_cb_cmd_done));
cmd_done.device_id = device->device_id;
device->callback(SYS_WATCHDOG_TIMEOUT, &cmd_done);
}
static void venus_hfi_response_handler(struct venus_hfi_device *device)
{
u8 packet[VIDC_IFACEQ_MED_PKT_SIZE];
dprintk(VIDC_INFO, "#####venus_hfi_response_handler#####\n");
if (device) {
if ((device->intr_status &
VIDC_WRAPPER_INTR_CLEAR_A2HWD_BMSK)) {
dprintk(VIDC_ERR, "Received: Watchdog timeout %s",
__func__);
venus_hfi_process_sys_watchdog_timeout(device);
}
while (!venus_hfi_iface_msgq_read(device, packet)) {
hfi_process_msg_packet(device->callback,
device->device_id,
(struct vidc_hal_msg_pkt_hdr *) packet);
}
while (!venus_hfi_iface_dbgq_read(device, packet)) {
struct hfi_msg_sys_debug_packet *pkt =
(struct hfi_msg_sys_debug_packet *) packet;
dprintk(VIDC_FW, "FW-SAYS: %s", pkt->rg_msg_data);
}
} else {
dprintk(VIDC_ERR, "SPURIOUS_INTERRUPT");
}
}
static void venus_hfi_core_work_handler(struct work_struct *work)
{
struct venus_hfi_device *device = list_first_entry(
@@ -1949,7 +1986,7 @@ static void venus_hfi_core_work_handler(struct work_struct *work)
return;
}
venus_hfi_core_clear_interrupt(device);
hfi_response_handler(device);
venus_hfi_response_handler(device);
enable_irq(device->hal_data->irq);
}
static DECLARE_WORK(venus_hfi_work, venus_hfi_core_work_handler);
@@ -2157,9 +2194,10 @@ static unsigned long venus_hfi_get_clock_rate(struct venus_core_clock *clock,
return ret;
}
int venus_hfi_scale_clocks(struct venus_hfi_device *device, int load)
static int venus_hfi_scale_clocks(void *dev, int load)
{
int rc = 0;
struct venus_hfi_device *device = dev;
if (!device) {
dprintk(VIDC_ERR, "Invalid args: %p\n", device);
return -EINVAL;
@@ -2374,11 +2412,18 @@ static int venus_hfi_get_bus_vector(int load)
return i;
}
int venus_hfi_scale_bus(struct venus_hfi_device *device, int load,
static int venus_hfi_scale_bus(void *dev, int load,
enum session_type type, enum mem_type mtype)
{
int rc = 0;
u32 handle = 0;
struct venus_hfi_device *device = dev;
if (!device) {
dprintk(VIDC_ERR, "%s invalid device handle %p",
__func__, device);
return -EINVAL;
}
if (mtype & DDR_MEM)
handle = device->resources.bus_info.ddr_handle[type];
@@ -2399,24 +2444,10 @@ int venus_hfi_scale_bus(struct venus_hfi_device *device, int load,
return rc;
}
static void venus_hfi_ocmem_init(struct venus_hfi_device *device)
{
struct on_chip_mem *ocmem;
ocmem = &device->resources.ocmem;
ocmem->vidc_ocmem_nb.notifier_call = msm_vidc_ocmem_notify_handler;
ocmem->handle =
ocmem_notifier_register(OCMEM_VIDEO, &ocmem->vidc_ocmem_nb);
if (!ocmem->handle) {
dprintk(VIDC_WARN, "Failed to register OCMEM notifier.");
dprintk(VIDC_INFO, " Performance will be impacted\n");
}
}
int venus_hfi_set_ocmem(struct venus_hfi_device *device,
struct ocmem_buf *ocmem)
static int venus_hfi_set_ocmem(void *dev, struct ocmem_buf *ocmem)
{
struct vidc_resource_hdr rhdr;
struct venus_hfi_device *device = dev;
int rc = 0;
if (!device || !ocmem) {
dprintk(VIDC_ERR, "Invalid params, core:%p, ocmem: %p\n",
@@ -2437,12 +2468,14 @@ ocmem_set_failed:
return rc;
}
int venus_hfi_unset_ocmem(struct venus_hfi_device *device)
static int venus_hfi_unset_ocmem(void *dev)
{
struct vidc_resource_hdr rhdr;
struct venus_hfi_device *device = dev;
int rc = 0;
if (!device || !device->resources.ocmem.buf) {
dprintk(VIDC_ERR, "Invalid params, device:%p\n", device);
dprintk(VIDC_ERR, "%s Invalid params, device:%p\n",
__func__, device);
return -EINVAL;
}
rhdr.resource_id = VIDC_RESOURCE_OCMEM;
@@ -2454,15 +2487,59 @@ int venus_hfi_unset_ocmem(struct venus_hfi_device *device)
return rc;
}
int venus_hfi_alloc_ocmem(struct venus_hfi_device *device,
unsigned long size)
static int venus_hfi_ocmem_notify_handler(struct notifier_block *this,
unsigned long event, void *data)
{
struct ocmem_buf *buff = data;
struct venus_hfi_device *device;
struct venus_resources *resources;
struct on_chip_mem *ocmem;
int rc = NOTIFY_DONE;
if (event == OCMEM_ALLOC_GROW) {
ocmem = container_of(this, struct on_chip_mem, vidc_ocmem_nb);
if (!ocmem) {
dprintk(VIDC_ERR, "Wrong handler passed\n");
rc = NOTIFY_BAD;
goto err_ocmem_notify;
}
resources = container_of(ocmem,
struct venus_resources, ocmem);
device = container_of(resources,
struct venus_hfi_device, resources);
if (venus_hfi_set_ocmem(device, buff)) {
dprintk(VIDC_ERR, "Failed to set ocmem: %d\n", rc);
goto err_ocmem_notify;
}
rc = NOTIFY_OK;
}
err_ocmem_notify:
return rc;
}
static void venus_hfi_ocmem_init(struct venus_hfi_device *device)
{
struct on_chip_mem *ocmem;
ocmem = &device->resources.ocmem;
ocmem->vidc_ocmem_nb.notifier_call = venus_hfi_ocmem_notify_handler;
ocmem->handle =
ocmem_notifier_register(OCMEM_VIDEO, &ocmem->vidc_ocmem_nb);
if (!ocmem->handle) {
dprintk(VIDC_WARN, "Failed to register OCMEM notifier.");
dprintk(VIDC_INFO, " Performance will be impacted\n");
}
}
static int venus_hfi_alloc_ocmem(void *dev, unsigned long size)
{
int rc = 0;
struct ocmem_buf *ocmem_buffer;
struct venus_hfi_device *device = dev;
if (!device || !size) {
dprintk(VIDC_ERR,
"Invalid param, core: %p, size: %lu\n", device, size);
dprintk(VIDC_ERR, "%s Invalid param, core: %p, size: %lu\n",
__func__, device, size);
return -EINVAL;
}
ocmem_buffer = device->resources.ocmem.buf;
@@ -2490,21 +2567,35 @@ ocmem_set_failed:
return rc;
}
int venus_hfi_free_ocmem(struct venus_hfi_device *device)
static int venus_hfi_free_ocmem(void *dev)
{
struct venus_hfi_device *device = dev;
int rc = 0;
if (!device) {
dprintk(VIDC_ERR, "%s invalid device handle %p",
__func__, device);
return -EINVAL;
}
if (device->resources.ocmem.buf) {
rc = ocmem_free(OCMEM_VIDEO, device->resources.ocmem.buf);
if (rc)
dprintk(VIDC_ERR, "Failed to free ocmem\n");
device->resources.ocmem.buf = NULL;
}
device->resources.ocmem.buf = NULL;
return rc;
}
int venus_hfi_is_ocmem_present(struct venus_hfi_device *device)
static int venus_hfi_is_ocmem_present(void *dev)
{
struct venus_hfi_device *device = dev;
if (!device) {
dprintk(VIDC_ERR, "%s invalid device handle %p",
__func__, device);
return -EINVAL;
}
return device->resources.ocmem.buf ? 1 : 0;
}
@@ -2515,6 +2606,7 @@ static void venus_hfi_deinit_ocmem(struct venus_hfi_device *device)
&device->resources.ocmem.vidc_ocmem_nb);
}
static int venus_hfi_init_resources(struct venus_hfi_device *device,
struct platform_device *pdev)
{
@@ -2619,9 +2711,9 @@ static void venus_hfi_iommu_detach(struct venus_hfi_device *device)
}
}
int venus_hfi_get_domain(struct venus_hfi_device *device,
enum msm_vidc_io_maps iomap)
static int venus_hfi_get_domain(void *dev, enum msm_vidc_io_maps iomap)
{
struct venus_hfi_device *device = dev;
if (!device || iomap < CP_MAP || iomap >= MAX_MAP) {
dprintk(VIDC_ERR, "%s: Invalid parameter: %p iomap: %d\n",
__func__, device, iomap);
@@ -2630,10 +2722,11 @@ int venus_hfi_get_domain(struct venus_hfi_device *device,
return device->resources.io_map[iomap].domain;
}
int venus_hfi_iommu_get_map(struct venus_hfi_device *device,
static int venus_hfi_iommu_get_map(void *dev,
struct msm_vidc_iommu_info maps[MAX_MAP])
{
int i = 0;
struct venus_hfi_device *device = dev;
if (!device || !maps) {
dprintk(VIDC_ERR, "%s: Invalid param device: %p maps: %p\n",
@@ -2677,12 +2770,14 @@ static int protect_cp_mem(struct venus_hfi_device *device)
return rc;
}
int venus_hfi_load_fw(struct venus_hfi_device *device)
static int venus_hfi_load_fw(void *dev)
{
int rc = 0;
struct venus_hfi_device *device = dev;
if (!device) {
dprintk(VIDC_ERR, "Invalid paramter: %p\n", device);
dprintk(VIDC_ERR, "%s Invalid paramter: %p\n",
__func__, device);
return -EINVAL;
}
@@ -2723,10 +2818,12 @@ fail_load_fw:
return rc;
}
void venus_hfi_unload_fw(struct venus_hfi_device *device)
static void venus_hfi_unload_fw(void *dev)
{
struct venus_hfi_device *device = dev;
if (!device) {
dprintk(VIDC_ERR, "Invalid paramter: %p\n", device);
dprintk(VIDC_ERR, "%s Invalid paramter: %p\n",
__func__, device);
return;
}
if (device->resources.fw.cookie) {
@@ -2737,6 +2834,40 @@ void venus_hfi_unload_fw(struct venus_hfi_device *device)
}
}
static int venus_hfi_get_fw_info(void *dev, enum fw_info info)
{
int rc = 0;
struct venus_hfi_device *device = dev;
if (!device) {
dprintk(VIDC_ERR, "%s Invalid paramter: %p\n",
__func__, device);
return -EINVAL;
}
switch (info) {
case FW_BASE_ADDRESS:
rc = device->base_addr;
break;
case FW_REGISTER_BASE:
rc = device->register_base;
break;
case FW_REGISTER_SIZE:
rc = device->register_size;
break;
case FW_IRQ:
rc = device->irq;
break;
default:
dprintk(VIDC_ERR, "Invalid fw info requested");
}
return rc;
}
static void *venus_hfi_add_device(u32 device_id, struct platform_device *pdev,
void (*callback) (enum command_response cmd, void *data))
{
@@ -2786,9 +2917,9 @@ err_alloc:
return NULL;
}
void *venus_hfi_get_device(u32 device_id,
struct platform_device *pdev,
void (*callback) (enum command_response cmd, void *data))
static void *venus_hfi_get_device(u32 device_id,
struct platform_device *pdev,
hfi_cmd_response_callback callback)
{
struct venus_hfi_device *device;
int rc = 0;
@@ -2837,3 +2968,60 @@ void venus_hfi_delete_device(void *device)
}
}
static void venus_init_hfi_callbacks(struct hfi_device *hdev)
{
hdev->core_init = venus_hfi_core_init;
hdev->core_release = venus_hfi_core_release;
hdev->core_pc_prep = venus_hfi_core_pc_prep;
hdev->core_ping = venus_hfi_core_ping;
hdev->session_init = venus_hfi_session_init;
hdev->session_end = venus_hfi_session_end;
hdev->session_abort = venus_hfi_session_abort;
hdev->session_set_buffers = venus_hfi_session_set_buffers;
hdev->session_release_buffers = venus_hfi_session_release_buffers;
hdev->session_load_res = venus_hfi_session_load_res;
hdev->session_release_res = venus_hfi_session_release_res;
hdev->session_start = venus_hfi_session_start;
hdev->session_stop = venus_hfi_session_stop;
hdev->session_suspend = venus_hfi_session_suspend;
hdev->session_resume = venus_hfi_session_resume;
hdev->session_etb = venus_hfi_session_etb;
hdev->session_ftb = venus_hfi_session_ftb;
hdev->session_parse_seq_hdr = venus_hfi_session_parse_seq_hdr;
hdev->session_get_seq_hdr = venus_hfi_session_get_seq_hdr;
hdev->session_get_buf_req = venus_hfi_session_get_buf_req;
hdev->session_flush = venus_hfi_session_flush;
hdev->session_set_property = venus_hfi_session_set_property;
hdev->session_get_property = venus_hfi_session_get_property;
hdev->scale_clocks = venus_hfi_scale_clocks;
hdev->scale_bus = venus_hfi_scale_bus;
hdev->unset_ocmem = venus_hfi_unset_ocmem;
hdev->alloc_ocmem = venus_hfi_alloc_ocmem;
hdev->free_ocmem = venus_hfi_free_ocmem;
hdev->is_ocmem_present = venus_hfi_is_ocmem_present;
hdev->get_domain = venus_hfi_get_domain;
hdev->iommu_get_map = venus_hfi_iommu_get_map;
hdev->load_fw = venus_hfi_load_fw;
hdev->unload_fw = venus_hfi_unload_fw;
hdev->get_fw_info = venus_hfi_get_fw_info;
}
int venus_hfi_initialize(struct hfi_device *hdev, u32 device_id,
struct platform_device *pdev, hfi_cmd_response_callback callback)
{
int rc = 0;
if (!hdev || !callback) {
dprintk(VIDC_ERR, "Invalid params: %p %p\n", pdev, callback);
rc = -EINVAL;
goto err_venus_hfi_init;
}
hdev->hfi_device_data = venus_hfi_get_device(device_id, pdev, callback);
venus_init_hfi_callbacks(hdev);
err_venus_hfi_init:
return rc;
}
drivers/media/video/msm_vidc/venus_hfi.h
+7 -839
View File
@@ -1,4 +1,4 @@
/* Copyright (c) 2012, The Linux Foundation. All rights reserved.
/* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
@@ -19,10 +19,12 @@
#include <linux/platform_device.h>
#include <linux/spinlock.h>
#include <mach/ocmem.h>
#include <media/msm_vidc.h>
#include "vidc_hfi_api.h"
#include "msm_smem.h"
#include "vidc_hfi_helper.h"
#include "vidc_hfi_api.h"
#include "vidc_hfi.h"
#define HFI_MASK_QHDR_TX_TYPE 0xFF000000
#define HFI_MASK_QHDR_RX_TYPE 0x00FF0000
@@ -106,793 +108,6 @@ enum vidc_hw_reg {
VIDC_HWREG_HVI_SOFTINTEN = 0xA,
};
#define HFI_EVENT_SESSION_SEQUENCE_CHANGED (HFI_OX_BASE + 0x3)
#define HFI_EVENT_SESSION_PROPERTY_CHANGED (HFI_OX_BASE + 0x4)
#define HFI_EVENT_DATA_SEQUENCE_CHANGED_SUFFICIENT_BUFFER_RESOURCES \
(HFI_OX_BASE + 0x1)
#define HFI_EVENT_DATA_SEQUENCE_CHANGED_INSUFFICIENT_BUFFER_RESOURCES \
(HFI_OX_BASE + 0x2)
#define HFI_BUFFERFLAG_EOS 0x00000001
#define HFI_BUFFERFLAG_STARTTIME 0x00000002
#define HFI_BUFFERFLAG_DECODEONLY 0x00000004
#define HFI_BUFFERFLAG_DATACORRUPT 0x00000008
#define HFI_BUFFERFLAG_ENDOFFRAME 0x00000010
#define HFI_BUFFERFLAG_SYNCFRAME 0x00000020
#define HFI_BUFFERFLAG_EXTRADATA 0x00000040
#define HFI_BUFFERFLAG_CODECCONFIG 0x00000080
#define HFI_BUFFERFLAG_TIMESTAMPINVALID 0x00000100
#define HFI_BUFFERFLAG_READONLY 0x00000200
#define HFI_BUFFERFLAG_ENDOFSUBFRAME 0x00000400
#define HFI_BUFFERFLAG_EOSEQ 0x00200000
#define HFI_BUFFERFLAG_DISCONTINUITY 0x80000000
#define HFI_BUFFERFLAG_TEI 0x40000000
#define HFI_ERR_SESSION_EMPTY_BUFFER_DONE_OUTPUT_PENDING \
(HFI_OX_BASE + 0x1001)
#define HFI_ERR_SESSION_SAME_STATE_OPERATION \
(HFI_OX_BASE + 0x1002)
#define HFI_ERR_SESSION_SYNC_FRAME_NOT_DETECTED \
(HFI_OX_BASE + 0x1003)
#define HFI_ERR_SESSION_START_CODE_NOT_FOUND \
(HFI_OX_BASE + 0x1004)
#define HFI_BUFFER_INTERNAL_SCRATCH (HFI_OX_BASE + 0x1)
#define HFI_BUFFER_EXTRADATA_INPUT (HFI_OX_BASE + 0x2)
#define HFI_BUFFER_EXTRADATA_OUTPUT (HFI_OX_BASE + 0x3)
#define HFI_BUFFER_EXTRADATA_OUTPUT2 (HFI_OX_BASE + 0x4)
#define HFI_BUFFER_MODE_STATIC (HFI_OX_BASE + 0x1)
#define HFI_BUFFER_MODE_RING (HFI_OX_BASE + 0x2)
struct hfi_buffer_alloc_mode {
u32 buffer_type;
u32 buffer_mode;
};
#define HFI_FLUSH_INPUT (HFI_OX_BASE + 0x1)
#define HFI_FLUSH_OUTPUT (HFI_OX_BASE + 0x2)
#define HFI_FLUSH_OUTPUT2 (HFI_OX_BASE + 0x3)
#define HFI_FLUSH_ALL (HFI_OX_BASE + 0x4)
#define HFI_EXTRADATA_NONE 0x00000000
#define HFI_EXTRADATA_MB_QUANTIZATION 0x00000001
#define HFI_EXTRADATA_INTERLACE_VIDEO 0x00000002
#define HFI_EXTRADATA_VC1_FRAMEDISP 0x00000003
#define HFI_EXTRADATA_VC1_SEQDISP 0x00000004
#define HFI_EXTRADATA_TIMESTAMP 0x00000005
#define HFI_EXTRADATA_S3D_FRAME_PACKING 0x00000006
#define HFI_EXTRADATA_FRAME_RATE 0x00000007
#define HFI_EXTRADATA_PANSCAN_WINDOW 0x00000008
#define HFI_EXTRADATA_RECOVERY_POINT_SEI 0x00000009
#define HFI_EXTRADATA_CLOSED_CAPTION_UD 0x0000000A
#define HFI_EXTRADATA_AFD_UD 0x0000000B
#define HFI_EXTRADATA_MULTISLICE_INFO 0x7F100000
#define HFI_EXTRADATA_NUM_CONCEALED_MB 0x7F100001
#define HFI_EXTRADATA_INDEX 0x7F100002
#define HFI_EXTRADATA_METADATA_FILLER 0x7FE00002
#define HFI_INDEX_EXTRADATA_INPUT_CROP 0x0700000E
#define HFI_INDEX_EXTRADATA_DIGITAL_ZOOM 0x07000010
#define HFI_INDEX_EXTRADATA_ASPECT_RATIO 0x7F100003
struct hfi_index_extradata_config {
int enable;
u32 index_extra_data_id;
};
struct hfi_extradata_header {
u32 size;
u32 version;
u32 port_index;
u32 type;
u32 data_size;
u8 rg_data[1];
};
#define HFI_INTERLACE_FRAME_PROGRESSIVE 0x01
#define HFI_INTERLACE_INTERLEAVE_FRAME_TOPFIELDFIRST 0x02
#define HFI_INTERLACE_INTERLEAVE_FRAME_BOTTOMFIELDFIRST 0x04
#define HFI_INTERLACE_FRAME_TOPFIELDFIRST 0x08
#define HFI_INTERLACE_FRAME_BOTTOMFIELDFIRST 0x10
#define HFI_PROPERTY_SYS_OX_START \
(HFI_DOMAIN_BASE_COMMON + HFI_ARCH_OX_OFFSET + 0x0000)
#define HFI_PROPERTY_SYS_IDLE_INDICATOR \
(HFI_PROPERTY_SYS_OX_START + 0x001)
#define HFI_PROPERTY_PARAM_OX_START \
(HFI_DOMAIN_BASE_COMMON + HFI_ARCH_OX_OFFSET + 0x1000)
#define HFI_PROPERTY_PARAM_BUFFER_COUNT_ACTUAL \
(HFI_PROPERTY_PARAM_OX_START + 0x001)
#define HFI_PROPERTY_PARAM_UNCOMPRESSED_PLANE_ACTUAL_CONSTRAINTS_INFO \
(HFI_PROPERTY_PARAM_OX_START + 0x002)
#define HFI_PROPERTY_PARAM_INTERLACE_FORMAT_SUPPORTED \
(HFI_PROPERTY_PARAM_OX_START + 0x003)
#define HFI_PROPERTY_PARAM_CHROMA_SITE \
(HFI_PROPERTY_PARAM_OX_START + 0x004)
#define HFI_PROPERTY_PARAM_EXTRA_DATA_HEADER_CONFIG \
(HFI_PROPERTY_PARAM_OX_START + 0x005)
#define HFI_PROPERTY_PARAM_INDEX_EXTRADATA \
(HFI_PROPERTY_PARAM_OX_START + 0x006)
#define HFI_PROPERTY_PARAM_DIVX_FORMAT \
(HFI_PROPERTY_PARAM_OX_START + 0x007)
#define HFI_PROPERTY_PARAM_BUFFER_ALLOC_MODE \
(HFI_PROPERTY_PARAM_OX_START + 0x008)
#define HFI_PROPERTY_PARAM_S3D_FRAME_PACKING_EXTRADATA \
(HFI_PROPERTY_PARAM_OX_START + 0x009)
#define HFI_PROPERTY_CONFIG_OX_START \
(HFI_DOMAIN_BASE_COMMON + HFI_ARCH_OX_OFFSET + 0x02000)
#define HFI_PROPERTY_CONFIG_BUFFER_REQUIREMENTS \
(HFI_PROPERTY_CONFIG_OX_START + 0x001)
#define HFI_PROPERTY_CONFIG_REALTIME \
(HFI_PROPERTY_CONFIG_OX_START + 0x002)
#define HFI_PROPERTY_CONFIG_PRIORITY \
(HFI_PROPERTY_CONFIG_OX_START + 0x003)
#define HFI_PROPERTY_CONFIG_BATCH_INFO \
(HFI_PROPERTY_CONFIG_OX_START + 0x004)
#define HFI_PROPERTY_PARAM_VDEC_OX_START \
(HFI_DOMAIN_BASE_VDEC + HFI_ARCH_OX_OFFSET + 0x3000)
#define HFI_PROPERTY_PARAM_VDEC_CONTINUE_DATA_TRANSFER \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x001)
#define HFI_PROPERTY_PARAM_VDEC_DISPLAY_PICTURE_BUFFER_COUNT\
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x002)
#define HFI_PROPERTY_PARAM_VDEC_MULTI_VIEW_SELECT \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x003)
#define HFI_PROPERTY_PARAM_VDEC_PICTURE_TYPE_DECODE \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x004)
#define HFI_PROPERTY_PARAM_VDEC_OUTPUT_ORDER \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x005)
#define HFI_PROPERTY_PARAM_VDEC_MB_QUANTIZATION \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x006)
#define HFI_PROPERTY_PARAM_VDEC_NUM_CONCEALED_MB \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x007)
#define HFI_PROPERTY_PARAM_VDEC_H264_ENTROPY_SWITCHING \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x008)
#define HFI_PROPERTY_PARAM_VDEC_OUTPUT2_KEEP_ASPECT_RATIO\
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x009)
#define HFI_PROPERTY_PARAM_VDEC_FRAME_RATE_EXTRADATA \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x00A)
#define HFI_PROPERTY_PARAM_VDEC_PANSCAN_WNDW_EXTRADATA \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x00B)
#define HFI_PROPERTY_PARAM_VDEC_RECOVERY_POINT_SEI_EXTRADATA \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x00C)
#define HFI_PROPERTY_PARAM_VDEC_THUMBNAIL_MODE \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x00D)
#define HFI_PROPERTY_PARAM_VDEC_FRAME_ASSEMBLY \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x00E)
#define HFI_PROPERTY_PARAM_VDEC_CLOSED_CAPTION_EXTRADATA \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x00F)
#define HFI_PROPERTY_PARAM_VDEC_AFD_EXTRADATA \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x010)
#define HFI_PROPERTY_PARAM_VDEC_VC1_FRAMEDISP_EXTRADATA \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x011)
#define HFI_PROPERTY_PARAM_VDEC_VC1_SEQDISP_EXTRADATA \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x012)
#define HFI_PROPERTY_PARAM_VDEC_TIMESTAMP_EXTRADATA \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x013)
#define HFI_PROPERTY_PARAM_VDEC_INTERLACE_VIDEO_EXTRADATA \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x014)
#define HFI_PROPERTY_PARAM_VDEC_AVC_SESSION_SELECT \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x015)
#define HFI_PROPERTY_CONFIG_VDEC_OX_START \
(HFI_DOMAIN_BASE_VDEC + HFI_ARCH_OX_OFFSET + 0x0000)
#define HFI_PROPERTY_CONFIG_VDEC_POST_LOOP_DEBLOCKER \
(HFI_PROPERTY_CONFIG_VDEC_OX_START + 0x001)
#define HFI_PROPERTY_CONFIG_VDEC_MB_ERROR_MAP_REPORTING \
(HFI_PROPERTY_CONFIG_VDEC_OX_START + 0x002)
#define HFI_PROPERTY_CONFIG_VDEC_MB_ERROR_MAP \
(HFI_PROPERTY_CONFIG_VDEC_OX_START + 0x003)
#define HFI_PROPERTY_PARAM_VENC_OX_START \
(HFI_DOMAIN_BASE_VENC + HFI_ARCH_OX_OFFSET + 0x5000)
#define HFI_PROPERTY_PARAM_VENC_MULTI_SLICE_INFO \
(HFI_PROPERTY_PARAM_VENC_OX_START + 0x001)
#define HFI_PROPERTY_PARAM_VENC_H264_IDR_S3D_FRAME_PACKING_NAL \
(HFI_PROPERTY_PARAM_VENC_OX_START + 0x002)
#define HFI_PROPERTY_CONFIG_VENC_OX_START \
(HFI_DOMAIN_BASE_VENC + HFI_ARCH_OX_OFFSET + 0x6000)
#define HFI_PROPERTY_CONFIG_VENC_FRAME_QP \
(HFI_PROPERTY_CONFIG_VENC_OX_START + 0x001)
#define HFI_PROPERTY_PARAM_VPE_OX_START \
(HFI_DOMAIN_BASE_VPE + HFI_ARCH_OX_OFFSET + 0x7000)
#define HFI_PROPERTY_CONFIG_VPE_OX_START \
(HFI_DOMAIN_BASE_VPE + HFI_ARCH_OX_OFFSET + 0x8000)
struct hfi_batch_info {
u32 input_batch_count;
u32 output_batch_count;
};
struct hfi_buffer_count_actual {
u32 buffer_type;
u32 buffer_count_actual;
};
struct hfi_buffer_requirements {
u32 buffer_type;
u32 buffer_size;
u32 buffer_region_size;
u32 buffer_hold_count;
u32 buffer_count_min;
u32 buffer_count_actual;
u32 contiguous;
u32 buffer_alignment;
};
#define HFI_CHROMA_SITE_0 (HFI_OX_BASE + 0x1)
#define HFI_CHROMA_SITE_1 (HFI_OX_BASE + 0x2)
#define HFI_CHROMA_SITE_2 (HFI_OX_BASE + 0x3)
#define HFI_CHROMA_SITE_3 (HFI_OX_BASE + 0x4)
#define HFI_CHROMA_SITE_4 (HFI_OX_BASE + 0x5)
#define HFI_CHROMA_SITE_5 (HFI_OX_BASE + 0x6)
struct hfi_data_payload {
u32 size;
u8 rg_data[1];
};
struct hfi_enable_picture {
u32 picture_type;
};
struct hfi_display_picture_buffer_count {
int enable;
u32 count;
};
struct hfi_extra_data_header_config {
u32 type;
u32 buffer_type;
u32 version;
u32 port_index;
u32 client_extra_data_id;
};
struct hfi_interlace_format_supported {
u32 buffer_type;
u32 format;
};
struct hfi_mb_error_map {
u32 error_map_size;
u8 rg_error_map[1];
};
struct hfi_metadata_pass_through {
int enable;
u32 size;
};
struct hfi_multi_view_select {
u32 view_index;
};
#define HFI_PRIORITY_LOW 10
#define HFI_PRIOIRTY_MEDIUM 20
#define HFI_PRIORITY_HIGH 30
#define HFI_OUTPUT_ORDER_DISPLAY (HFI_OX_BASE + 0x1)
#define HFI_OUTPUT_ORDER_DECODE (HFI_OX_BASE + 0x2)
#define HFI_RATE_CONTROL_OFF (HFI_OX_BASE + 0x1)
#define HFI_RATE_CONTROL_VBR_VFR (HFI_OX_BASE + 0x2)
#define HFI_RATE_CONTROL_VBR_CFR (HFI_OX_BASE + 0x3)
#define HFI_RATE_CONTROL_CBR_VFR (HFI_OX_BASE + 0x4)
#define HFI_RATE_CONTROL_CBR_CFR (HFI_OX_BASE + 0x5)
struct hfi_uncompressed_plane_actual_constraints_info {
u32 buffer_type;
u32 num_planes;
struct hfi_uncompressed_plane_constraints rg_plane_format[1];
};
#define HFI_CMD_SYS_OX_START \
(HFI_DOMAIN_BASE_COMMON + HFI_ARCH_OX_OFFSET + HFI_CMD_START_OFFSET + 0x0000)
#define HFI_CMD_SYS_SESSION_ABORT (HFI_CMD_SYS_OX_START + 0x001)
#define HFI_CMD_SYS_PING (HFI_CMD_SYS_OX_START + 0x002)
#define HFI_CMD_SESSION_OX_START \
(HFI_DOMAIN_BASE_COMMON + HFI_ARCH_OX_OFFSET + HFI_CMD_START_OFFSET + 0x1000)
#define HFI_CMD_SESSION_LOAD_RESOURCES (HFI_CMD_SESSION_OX_START + 0x001)
#define HFI_CMD_SESSION_START (HFI_CMD_SESSION_OX_START + 0x002)
#define HFI_CMD_SESSION_STOP (HFI_CMD_SESSION_OX_START + 0x003)
#define HFI_CMD_SESSION_EMPTY_BUFFER (HFI_CMD_SESSION_OX_START + 0x004)
#define HFI_CMD_SESSION_FILL_BUFFER (HFI_CMD_SESSION_OX_START + 0x005)
#define HFI_CMD_SESSION_SUSPEND (HFI_CMD_SESSION_OX_START + 0x006)
#define HFI_CMD_SESSION_RESUME (HFI_CMD_SESSION_OX_START + 0x007)
#define HFI_CMD_SESSION_FLUSH (HFI_CMD_SESSION_OX_START + 0x008)
#define HFI_CMD_SESSION_GET_PROPERTY (HFI_CMD_SESSION_OX_START + 0x009)
#define HFI_CMD_SESSION_PARSE_SEQUENCE_HEADER \
(HFI_CMD_SESSION_OX_START + 0x00A)
#define HFI_CMD_SESSION_RELEASE_BUFFERS \
(HFI_CMD_SESSION_OX_START + 0x00B)
#define HFI_CMD_SESSION_RELEASE_RESOURCES \
(HFI_CMD_SESSION_OX_START + 0x00C)
#define HFI_MSG_SYS_OX_START \
(HFI_DOMAIN_BASE_COMMON + HFI_ARCH_OX_OFFSET + HFI_MSG_START_OFFSET + 0x0000)
#define HFI_MSG_SYS_IDLE (HFI_MSG_SYS_OX_START + 0x1)
#define HFI_MSG_SYS_PING_ACK (HFI_MSG_SYS_OX_START + 0x2)
#define HFI_MSG_SYS_PROPERTY_INFO (HFI_MSG_SYS_OX_START + 0x3)
#define HFI_MSG_SYS_SESSION_ABORT_DONE (HFI_MSG_SYS_OX_START + 0x4)
#define HFI_MSG_SESSION_OX_START \
(HFI_DOMAIN_BASE_COMMON + HFI_ARCH_OX_OFFSET + HFI_MSG_START_OFFSET + 0x1000)
#define HFI_MSG_SESSION_LOAD_RESOURCES_DONE (HFI_MSG_SESSION_OX_START + 0x1)
#define HFI_MSG_SESSION_START_DONE (HFI_MSG_SESSION_OX_START + 0x2)
#define HFI_MSG_SESSION_STOP_DONE (HFI_MSG_SESSION_OX_START + 0x3)
#define HFI_MSG_SESSION_SUSPEND_DONE (HFI_MSG_SESSION_OX_START + 0x4)
#define HFI_MSG_SESSION_RESUME_DONE (HFI_MSG_SESSION_OX_START + 0x5)
#define HFI_MSG_SESSION_FLUSH_DONE (HFI_MSG_SESSION_OX_START + 0x6)
#define HFI_MSG_SESSION_EMPTY_BUFFER_DONE (HFI_MSG_SESSION_OX_START + 0x7)
#define HFI_MSG_SESSION_FILL_BUFFER_DONE (HFI_MSG_SESSION_OX_START + 0x8)
#define HFI_MSG_SESSION_PROPERTY_INFO (HFI_MSG_SESSION_OX_START + 0x9)
#define HFI_MSG_SESSION_RELEASE_RESOURCES_DONE \
(HFI_MSG_SESSION_OX_START + 0xA)
#define HFI_MSG_SESSION_PARSE_SEQUENCE_HEADER_DONE \
(HFI_MSG_SESSION_OX_START + 0xB)
#define HFI_MSG_SESSION_RELEASE_BUFFERS_DONE \
(HFI_MSG_SESSION_OX_START + 0xC)
struct hfi_cmd_sys_session_abort_packet {
u32 size;
u32 packet_type;
u32 session_id;
};
struct hfi_cmd_sys_ping_packet {
u32 size;
u32 packet_type;
u32 client_data;
};
struct hfi_cmd_session_load_resources_packet {
u32 size;
u32 packet_type;
u32 session_id;
};
struct hfi_cmd_session_start_packet {
u32 size;
u32 packet_type;
u32 session_id;
};
struct hfi_cmd_session_stop_packet {
u32 size;
u32 packet_type;
u32 session_id;
};
struct hfi_cmd_session_empty_buffer_compressed_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 time_stamp_hi;
u32 time_stamp_lo;
u32 flags;
u32 mark_target;
u32 mark_data;
u32 offset;
u32 alloc_len;
u32 filled_len;
u32 input_tag;
u8 *packet_buffer;
u8 *extra_data_buffer;
u32 rgData[0];
};
struct hfi_cmd_session_empty_buffer_uncompressed_plane0_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 view_id;
u32 time_stamp_hi;
u32 time_stamp_lo;
u32 flags;
u32 mark_target;
u32 mark_data;
u32 alloc_len;
u32 filled_len;
u32 offset;
u32 input_tag;
u8 *packet_buffer;
u8 *extra_data_buffer;
u32 rgData[0];
};
struct hfi_cmd_session_empty_buffer_uncompressed_plane1_packet {
u32 flags;
u32 alloc_len;
u32 filled_len;
u32 offset;
u8 *packet_buffer2;
u32 rgData[0];
};
struct hfi_cmd_session_empty_buffer_uncompressed_plane2_packet {
u32 flags;
u32 alloc_len;
u32 filled_len;
u32 offset;
u8 *packet_buffer3;
u32 rgData[0];
};
struct hfi_cmd_session_fill_buffer_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 stream_id;
u32 offset;
u32 alloc_len;
u32 filled_len;
u32 output_tag;
u8 *packet_buffer;
u8 *extra_data_buffer;
u32 rgData[0];
};
struct hfi_cmd_session_flush_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 flush_type;
};
struct hfi_cmd_session_suspend_packet {
u32 size;
u32 packet_type;
u32 session_id;
};
struct hfi_cmd_session_resume_packet {
u32 size;
u32 packet_type;
u32 session_id;
};
struct hfi_cmd_session_get_property_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 num_properties;
u32 rg_property_data[1];
};
struct hfi_cmd_session_release_buffer_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 buffer_type;
u32 buffer_size;
u32 extra_data_size;
int response_req;
u32 num_buffers;
u32 rg_buffer_info[1];
};
struct hfi_cmd_session_release_resources_packet {
u32 size;
u32 packet_type;
u32 session_id;
};
struct hfi_cmd_session_parse_sequence_header_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 header_len;
u8 *packet_buffer;
};
struct hfi_msg_sys_session_abort_done_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 error_type;
};
struct hfi_msg_sys_idle_packet {
u32 size;
u32 packet_type;
};
struct hfi_msg_sys_ping_ack_packet {
u32 size;
u32 packet_type;
u32 client_data;
};
struct hfi_msg_sys_property_info_packet {
u32 size;
u32 packet_type;
u32 num_properties;
u32 rg_property_data[1];
};
struct hfi_msg_session_load_resources_done_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 error_type;
};
struct hfi_msg_session_start_done_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 error_type;
};
struct hfi_msg_session_stop_done_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 error_type;
};
struct hfi_msg_session_suspend_done_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 error_type;
};
struct hfi_msg_session_resume_done_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 error_type;
};
struct hfi_msg_session_flush_done_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 error_type;
u32 flush_type;
};
struct hfi_msg_session_empty_buffer_done_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 error_type;
u32 offset;
u32 filled_len;
u32 input_tag;
u8 *packet_buffer;
u8 *extra_data_buffer;
u32 rgData[0];
};
struct hfi_msg_session_fill_buffer_done_compressed_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 time_stamp_hi;
u32 time_stamp_lo;
u32 error_type;
u32 flags;
u32 mark_target;
u32 mark_data;
u32 stats;
u32 offset;
u32 alloc_len;
u32 filled_len;
u32 input_tag;
u32 output_tag;
u32 picture_type;
u8 *packet_buffer;
u8 *extra_data_buffer;
u32 rgData[0];
};
struct hfi_msg_session_fbd_uncompressed_plane0_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 stream_id;
u32 view_id;
u32 error_type;
u32 time_stamp_hi;
u32 time_stamp_lo;
u32 flags;
u32 mark_target;
u32 mark_data;
u32 stats;
u32 alloc_len;
u32 filled_len;
u32 offset;
u32 frame_width;
u32 frame_height;
u32 start_x_coord;
u32 start_y_coord;
u32 input_tag;
u32 input_tag2;
u32 output_tag;
u32 picture_type;
u8 *packet_buffer;
u8 *extra_data_buffer;
u32 rgData[0];
};
struct hfi_msg_session_fill_buffer_done_uncompressed_plane1_packet {
u32 flags;
u32 alloc_len;
u32 filled_len;
u32 offset;
u8 *packet_buffer2;
u32 rgData[0];
};
struct hfi_msg_session_fill_buffer_done_uncompressed_plane2_packet {
u32 flags;
u32 alloc_len;
u32 filled_len;
u32 offset;
u8 *packet_buffer3;
u32 rgData[0];
};
struct hfi_msg_session_parse_sequence_header_done_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 error_type;
u32 num_properties;
u32 rg_property_data[1];
};
struct hfi_msg_session_property_info_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 num_properties;
u32 rg_property_data[1];
};
struct hfi_msg_session_release_resources_done_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 error_type;
};
struct hfi_msg_session_release_buffers_done_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 error_type;
u32 num_buffers;
u32 rg_buffer_info[1];
};
struct hfi_extradata_mb_quantization_payload {
u8 rg_mb_qp[1];
};
struct hfi_extradata_vc1_pswnd {
u32 ps_wnd_h_offset;
u32 ps_wnd_v_offset;
u32 ps_wnd_width;
u32 ps_wnd_height;
};
struct hfi_extradata_vc1_framedisp_payload {
u32 res_pic;
u32 ref;
u32 range_map_present;
u32 range_map_y;
u32 range_map_uv;
u32 num_pan_scan_wnds;
struct hfi_extradata_vc1_pswnd rg_ps_wnd[1];
};
struct hfi_extradata_vc1_seqdisp_payload {
u32 prog_seg_frm;
u32 uv_sampling_fmt;
u32 color_fmt_flag;
u32 color_primaries;
u32 transfer_char;
u32 mat_coeff;
u32 aspect_ratio;
u32 aspect_horiz;
u32 aspect_vert;
};
struct hfi_extradata_timestamp_payload {
u32 time_stamp_low;
u32 time_stamp_high;
};
struct hfi_extradata_s3d_frame_packing_payload {
u32 fpa_id;
int cancel_flag;
u32 fpa_type;
int quin_cunx_flag;
u32 content_interprtation_type;
int spatial_flipping_flag;
int frame0_flipped_flag;
int field_views_flag;
int current_frame_isFrame0_flag;
int frame0_self_contained_flag;
int frame1_self_contained_flag;
u32 frame0_graid_pos_x;
u32 frame0_graid_pos_y;
u32 frame1_graid_pos_x;
u32 frame1_graid_pos_y;
u32 fpa_reserved_byte;
u32 fpa_repetition_period;
int fpa_extension_flag;
};
struct hfi_extradata_interlace_video_payload {
u32 format;
};
struct hfi_extradata_num_concealed_mb_payload {
u32 num_mb_concealed;
};
struct hfi_extradata_sliceinfo {
u32 offset_in_stream;
u32 slice_length;
};
struct hfi_extradata_multislice_info_payload {
u32 num_slices;
struct hfi_extradata_sliceinfo rg_slice_info[1];
};
struct hfi_index_extradata_input_crop_payload {
u32 size;
u32 version;
u32 port_index;
u32 left;
u32 top;
u32 width;
u32 height;
};
struct hfi_index_extradata_digital_zoom_payload {
u32 size;
u32 version;
u32 port_index;
int width;
int height;
};
struct hfi_index_extradata_aspect_ratio_payload {
u32 size;
u32 version;
u32 port_index;
u32 aspect_width;
u32 aspect_height;
};
struct hfi_extradata_panscan_wndw_payload {
u32 num_window;
struct hfi_extradata_vc1_pswnd wnd[1];
};
struct hfi_extradata_frame_type_payload {
u32 frame_rate;
};
struct hfi_extradata_recovery_point_sei_payload {
u32 flag;
};
struct vidc_mem_addr {
u8 *align_device_addr;
u8 *align_virtual_addr;
@@ -921,11 +136,6 @@ enum vidc_clocks {
VCODEC_MAX_CLKS
};
enum mem_type {
DDR_MEM = 0x1,
OCMEM_MEM = 0x2,
};
struct load_freq_table {
u32 load;
u32 freq;
@@ -968,7 +178,7 @@ struct venus_hfi_device {
u32 device_id;
spinlock_t read_lock;
spinlock_t write_lock;
void (*callback) (u32 response, void *callback);
msm_vidc_callback callback;
struct vidc_mem_addr iface_q_table;
struct vidc_mem_addr qdss;
struct vidc_mem_addr sfr;
@@ -986,49 +196,7 @@ struct venus_hfi_device {
struct venus_resources resources;
};
struct hal_session {
struct list_head list;
u32 session_id;
u32 is_decoder;
struct venus_hfi_device *device;
};
struct hal_device_data {
struct list_head dev_head;
int dev_count;
};
extern struct hal_device_data hal_ctxt;
int venus_hfi_iface_msgq_read(struct venus_hfi_device *device, void *pkt);
int venus_hfi_iface_dbgq_read(struct venus_hfi_device *device, void *pkt);
/* Interrupt Processing:*/
void hfi_response_handler(struct venus_hfi_device *device);
void venus_hfi_delete_device(void *device);
int venus_hfi_scale_clocks(struct venus_hfi_device *device, int load);
void *venus_hfi_get_device(u32 device_id,
struct platform_device *pdev,
void (*callback) (enum command_response cmd, void *data));
int venus_hfi_scale_bus(struct venus_hfi_device *device, int load,
enum session_type type, enum mem_type mtype);
int venus_hfi_set_ocmem(struct venus_hfi_device *device,
struct ocmem_buf *ocmem);
int venus_hfi_unset_ocmem(struct venus_hfi_device *device);
int venus_hfi_alloc_ocmem(struct venus_hfi_device *device,
unsigned long size);
int venus_hfi_free_ocmem(struct venus_hfi_device *device);
int venus_hfi_is_ocmem_present(struct venus_hfi_device *device);
int venus_hfi_get_domain(struct venus_hfi_device *device,
enum msm_vidc_io_maps iomap);
int venus_hfi_iommu_get_map(struct venus_hfi_device *device,
struct msm_vidc_iommu_info maps[MAX_MAP]);
int venus_hfi_load_fw(struct venus_hfi_device *device);
void venus_hfi_unload_fw(struct venus_hfi_device *device);
int venus_hfi_initialize(struct hfi_device *hdev, u32 device_id,
struct platform_device *pdev, hfi_cmd_response_callback callback);
#endif
drivers/media/video/msm_vidc/vidc_hfi.c
+68
View File
@@ -0,0 +1,68 @@
/* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
*/
#include <linux/slab.h>
#include "msm_vidc_debug.h"
#include "vidc_hfi_api.h"
#include "venus_hfi.h"
struct hal_device_data hal_ctxt;
void *vidc_hfi_initialize(enum msm_vidc_hfi_type hfi_type, u32 device_id,
struct platform_device *pdev,
hfi_cmd_response_callback callback)
{
struct hfi_device *hdev = NULL;
hdev = (struct hfi_device *)
kzalloc(sizeof(struct hfi_device), GFP_KERNEL);
if (!hdev) {
dprintk(VIDC_ERR, "%s: failed to allocate hdev\n", __func__);
return NULL;
}
switch (hfi_type) {
case VIDC_HFI_VENUS:
venus_hfi_initialize(hdev, device_id, pdev, callback);
break;
case VIDC_HFI_Q6:
default:
dprintk(VIDC_ERR, "Unsupported host-firmware interface\n");
goto err_hfi_init;
}
return hdev;
err_hfi_init:
kfree(hdev);
return NULL;
}
void vidc_hfi_deinitialize(enum msm_vidc_hfi_type hfi_type,
struct hfi_device *hdev)
{
if (!hdev) {
dprintk(VIDC_ERR, "%s invalid device %p", __func__, hdev);
return;
}
switch (hfi_type) {
case VIDC_HFI_VENUS:
venus_hfi_delete_device(hdev->hfi_device_data);
break;
case VIDC_HFI_Q6:
default:
dprintk(VIDC_ERR, "Unsupported host-firmware interface\n");
}
kfree(hdev);
}
drivers/media/video/msm_vidc/vidc_hfi.h
+826
View File
@@ -0,0 +1,826 @@
/* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
*/
#ifndef __H_VIDC_HFI_H__
#define __H_VIDC_HFI_H__
#include "vidc_hfi_helper.h"
#include "vidc_hfi_api.h"
#define HFI_EVENT_SESSION_SEQUENCE_CHANGED (HFI_OX_BASE + 0x3)
#define HFI_EVENT_SESSION_PROPERTY_CHANGED (HFI_OX_BASE + 0x4)
#define HFI_EVENT_DATA_SEQUENCE_CHANGED_SUFFICIENT_BUFFER_RESOURCES \
(HFI_OX_BASE + 0x1)
#define HFI_EVENT_DATA_SEQUENCE_CHANGED_INSUFFICIENT_BUFFER_RESOURCES \
(HFI_OX_BASE + 0x2)
#define HFI_BUFFERFLAG_EOS 0x00000001
#define HFI_BUFFERFLAG_STARTTIME 0x00000002
#define HFI_BUFFERFLAG_DECODEONLY 0x00000004
#define HFI_BUFFERFLAG_DATACORRUPT 0x00000008
#define HFI_BUFFERFLAG_ENDOFFRAME 0x00000010
#define HFI_BUFFERFLAG_SYNCFRAME 0x00000020
#define HFI_BUFFERFLAG_EXTRADATA 0x00000040
#define HFI_BUFFERFLAG_CODECCONFIG 0x00000080
#define HFI_BUFFERFLAG_TIMESTAMPINVALID 0x00000100
#define HFI_BUFFERFLAG_READONLY 0x00000200
#define HFI_BUFFERFLAG_ENDOFSUBFRAME 0x00000400
#define HFI_BUFFERFLAG_EOSEQ 0x00200000
#define HFI_BUFFERFLAG_DISCONTINUITY 0x80000000
#define HFI_BUFFERFLAG_TEI 0x40000000
#define HFI_ERR_SESSION_EMPTY_BUFFER_DONE_OUTPUT_PENDING \
(HFI_OX_BASE + 0x1001)
#define HFI_ERR_SESSION_SAME_STATE_OPERATION \
(HFI_OX_BASE + 0x1002)
#define HFI_ERR_SESSION_SYNC_FRAME_NOT_DETECTED \
(HFI_OX_BASE + 0x1003)
#define HFI_ERR_SESSION_START_CODE_NOT_FOUND \
(HFI_OX_BASE + 0x1004)
#define HFI_BUFFER_INTERNAL_SCRATCH (HFI_OX_BASE + 0x1)
#define HFI_BUFFER_EXTRADATA_INPUT (HFI_OX_BASE + 0x2)
#define HFI_BUFFER_EXTRADATA_OUTPUT (HFI_OX_BASE + 0x3)
#define HFI_BUFFER_EXTRADATA_OUTPUT2 (HFI_OX_BASE + 0x4)
#define HFI_BUFFER_MODE_STATIC (HFI_OX_BASE + 0x1)
#define HFI_BUFFER_MODE_RING (HFI_OX_BASE + 0x2)
#define HFI_FLUSH_INPUT (HFI_OX_BASE + 0x1)
#define HFI_FLUSH_OUTPUT (HFI_OX_BASE + 0x2)
#define HFI_FLUSH_OUTPUT2 (HFI_OX_BASE + 0x3)
#define HFI_FLUSH_ALL (HFI_OX_BASE + 0x4)
#define HFI_EXTRADATA_NONE 0x00000000
#define HFI_EXTRADATA_MB_QUANTIZATION 0x00000001
#define HFI_EXTRADATA_INTERLACE_VIDEO 0x00000002
#define HFI_EXTRADATA_VC1_FRAMEDISP 0x00000003
#define HFI_EXTRADATA_VC1_SEQDISP 0x00000004
#define HFI_EXTRADATA_TIMESTAMP 0x00000005
#define HFI_EXTRADATA_S3D_FRAME_PACKING 0x00000006
#define HFI_EXTRADATA_FRAME_RATE 0x00000007
#define HFI_EXTRADATA_PANSCAN_WINDOW 0x00000008
#define HFI_EXTRADATA_RECOVERY_POINT_SEI 0x00000009
#define HFI_EXTRADATA_CLOSED_CAPTION_UD 0x0000000A
#define HFI_EXTRADATA_AFD_UD 0x0000000B
#define HFI_EXTRADATA_MULTISLICE_INFO 0x7F100000
#define HFI_EXTRADATA_NUM_CONCEALED_MB 0x7F100001
#define HFI_EXTRADATA_INDEX 0x7F100002
#define HFI_EXTRADATA_METADATA_FILLER 0x7FE00002
#define HFI_INDEX_EXTRADATA_INPUT_CROP 0x0700000E
#define HFI_INDEX_EXTRADATA_DIGITAL_ZOOM 0x07000010
#define HFI_INDEX_EXTRADATA_ASPECT_RATIO 0x7F100003
struct hfi_buffer_alloc_mode {
u32 buffer_type;
u32 buffer_mode;
};
struct hfi_index_extradata_config {
int enable;
u32 index_extra_data_id;
};
struct hfi_extradata_header {
u32 size;
u32 version;
u32 port_index;
u32 type;
u32 data_size;
u8 rg_data[1];
};
#define HFI_INTERLACE_FRAME_PROGRESSIVE 0x01
#define HFI_INTERLACE_INTERLEAVE_FRAME_TOPFIELDFIRST 0x02
#define HFI_INTERLACE_INTERLEAVE_FRAME_BOTTOMFIELDFIRST 0x04
#define HFI_INTERLACE_FRAME_TOPFIELDFIRST 0x08
#define HFI_INTERLACE_FRAME_BOTTOMFIELDFIRST 0x10
#define HFI_PROPERTY_SYS_OX_START \
(HFI_DOMAIN_BASE_COMMON + HFI_ARCH_OX_OFFSET + 0x0000)
#define HFI_PROPERTY_SYS_IDLE_INDICATOR \
(HFI_PROPERTY_SYS_OX_START + 0x001)
#define HFI_PROPERTY_PARAM_OX_START \
(HFI_DOMAIN_BASE_COMMON + HFI_ARCH_OX_OFFSET + 0x1000)
#define HFI_PROPERTY_PARAM_BUFFER_COUNT_ACTUAL \
(HFI_PROPERTY_PARAM_OX_START + 0x001)
#define HFI_PROPERTY_PARAM_UNCOMPRESSED_PLANE_ACTUAL_CONSTRAINTS_INFO \
(HFI_PROPERTY_PARAM_OX_START + 0x002)
#define HFI_PROPERTY_PARAM_INTERLACE_FORMAT_SUPPORTED \
(HFI_PROPERTY_PARAM_OX_START + 0x003)
#define HFI_PROPERTY_PARAM_CHROMA_SITE \
(HFI_PROPERTY_PARAM_OX_START + 0x004)
#define HFI_PROPERTY_PARAM_EXTRA_DATA_HEADER_CONFIG \
(HFI_PROPERTY_PARAM_OX_START + 0x005)
#define HFI_PROPERTY_PARAM_INDEX_EXTRADATA \
(HFI_PROPERTY_PARAM_OX_START + 0x006)
#define HFI_PROPERTY_PARAM_DIVX_FORMAT \
(HFI_PROPERTY_PARAM_OX_START + 0x007)
#define HFI_PROPERTY_PARAM_BUFFER_ALLOC_MODE \
(HFI_PROPERTY_PARAM_OX_START + 0x008)
#define HFI_PROPERTY_PARAM_S3D_FRAME_PACKING_EXTRADATA \
(HFI_PROPERTY_PARAM_OX_START + 0x009)
#define HFI_PROPERTY_CONFIG_OX_START \
(HFI_DOMAIN_BASE_COMMON + HFI_ARCH_OX_OFFSET + 0x02000)
#define HFI_PROPERTY_CONFIG_BUFFER_REQUIREMENTS \
(HFI_PROPERTY_CONFIG_OX_START + 0x001)
#define HFI_PROPERTY_CONFIG_REALTIME \
(HFI_PROPERTY_CONFIG_OX_START + 0x002)
#define HFI_PROPERTY_CONFIG_PRIORITY \
(HFI_PROPERTY_CONFIG_OX_START + 0x003)
#define HFI_PROPERTY_CONFIG_BATCH_INFO \
(HFI_PROPERTY_CONFIG_OX_START + 0x004)
#define HFI_PROPERTY_PARAM_VDEC_OX_START \
(HFI_DOMAIN_BASE_VDEC + HFI_ARCH_OX_OFFSET + 0x3000)
#define HFI_PROPERTY_PARAM_VDEC_CONTINUE_DATA_TRANSFER \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x001)
#define HFI_PROPERTY_PARAM_VDEC_DISPLAY_PICTURE_BUFFER_COUNT\
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x002)
#define HFI_PROPERTY_PARAM_VDEC_MULTI_VIEW_SELECT \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x003)
#define HFI_PROPERTY_PARAM_VDEC_PICTURE_TYPE_DECODE \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x004)
#define HFI_PROPERTY_PARAM_VDEC_OUTPUT_ORDER \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x005)
#define HFI_PROPERTY_PARAM_VDEC_MB_QUANTIZATION \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x006)
#define HFI_PROPERTY_PARAM_VDEC_NUM_CONCEALED_MB \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x007)
#define HFI_PROPERTY_PARAM_VDEC_H264_ENTROPY_SWITCHING \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x008)
#define HFI_PROPERTY_PARAM_VDEC_OUTPUT2_KEEP_ASPECT_RATIO\
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x009)
#define HFI_PROPERTY_PARAM_VDEC_FRAME_RATE_EXTRADATA \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x00A)
#define HFI_PROPERTY_PARAM_VDEC_PANSCAN_WNDW_EXTRADATA \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x00B)
#define HFI_PROPERTY_PARAM_VDEC_RECOVERY_POINT_SEI_EXTRADATA \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x00C)
#define HFI_PROPERTY_PARAM_VDEC_THUMBNAIL_MODE \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x00D)
#define HFI_PROPERTY_PARAM_VDEC_FRAME_ASSEMBLY \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x00E)
#define HFI_PROPERTY_PARAM_VDEC_CLOSED_CAPTION_EXTRADATA \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x00F)
#define HFI_PROPERTY_PARAM_VDEC_AFD_EXTRADATA \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x010)
#define HFI_PROPERTY_PARAM_VDEC_VC1_FRAMEDISP_EXTRADATA \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x011)
#define HFI_PROPERTY_PARAM_VDEC_VC1_SEQDISP_EXTRADATA \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x012)
#define HFI_PROPERTY_PARAM_VDEC_TIMESTAMP_EXTRADATA \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x013)
#define HFI_PROPERTY_PARAM_VDEC_INTERLACE_VIDEO_EXTRADATA \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x014)
#define HFI_PROPERTY_PARAM_VDEC_AVC_SESSION_SELECT \
(HFI_PROPERTY_PARAM_VDEC_OX_START + 0x015)
#define HFI_PROPERTY_CONFIG_VDEC_OX_START \
(HFI_DOMAIN_BASE_VDEC + HFI_ARCH_OX_OFFSET + 0x0000)
#define HFI_PROPERTY_CONFIG_VDEC_POST_LOOP_DEBLOCKER \
(HFI_PROPERTY_CONFIG_VDEC_OX_START + 0x001)
#define HFI_PROPERTY_CONFIG_VDEC_MB_ERROR_MAP_REPORTING \
(HFI_PROPERTY_CONFIG_VDEC_OX_START + 0x002)
#define HFI_PROPERTY_CONFIG_VDEC_MB_ERROR_MAP \
(HFI_PROPERTY_CONFIG_VDEC_OX_START + 0x003)
#define HFI_PROPERTY_PARAM_VENC_OX_START \
(HFI_DOMAIN_BASE_VENC + HFI_ARCH_OX_OFFSET + 0x5000)
#define HFI_PROPERTY_PARAM_VENC_MULTI_SLICE_INFO \
(HFI_PROPERTY_PARAM_VENC_OX_START + 0x001)
#define HFI_PROPERTY_PARAM_VENC_H264_IDR_S3D_FRAME_PACKING_NAL \
(HFI_PROPERTY_PARAM_VENC_OX_START + 0x002)
#define HFI_PROPERTY_CONFIG_VENC_OX_START \
(HFI_DOMAIN_BASE_VENC + HFI_ARCH_OX_OFFSET + 0x6000)
#define HFI_PROPERTY_CONFIG_VENC_FRAME_QP \
(HFI_PROPERTY_CONFIG_VENC_OX_START + 0x001)
#define HFI_PROPERTY_PARAM_VPE_OX_START \
(HFI_DOMAIN_BASE_VPE + HFI_ARCH_OX_OFFSET + 0x7000)
#define HFI_PROPERTY_CONFIG_VPE_OX_START \
(HFI_DOMAIN_BASE_VPE + HFI_ARCH_OX_OFFSET + 0x8000)
struct hfi_batch_info {
u32 input_batch_count;
u32 output_batch_count;
};
struct hfi_buffer_count_actual {
u32 buffer_type;
u32 buffer_count_actual;
};
struct hfi_buffer_requirements {
u32 buffer_type;
u32 buffer_size;
u32 buffer_region_size;
u32 buffer_hold_count;
u32 buffer_count_min;
u32 buffer_count_actual;
u32 contiguous;
u32 buffer_alignment;
};
#define HFI_CHROMA_SITE_0 (HFI_OX_BASE + 0x1)
#define HFI_CHROMA_SITE_1 (HFI_OX_BASE + 0x2)
#define HFI_CHROMA_SITE_2 (HFI_OX_BASE + 0x3)
#define HFI_CHROMA_SITE_3 (HFI_OX_BASE + 0x4)
#define HFI_CHROMA_SITE_4 (HFI_OX_BASE + 0x5)
#define HFI_CHROMA_SITE_5 (HFI_OX_BASE + 0x6)
struct hfi_data_payload {
u32 size;
u8 rg_data[1];
};
struct hfi_enable_picture {
u32 picture_type;
};
struct hfi_display_picture_buffer_count {
int enable;
u32 count;
};
struct hfi_extra_data_header_config {
u32 type;
u32 buffer_type;
u32 version;
u32 port_index;
u32 client_extra_data_id;
};
struct hfi_interlace_format_supported {
u32 buffer_type;
u32 format;
};
struct hfi_mb_error_map {
u32 error_map_size;
u8 rg_error_map[1];
};
struct hfi_metadata_pass_through {
int enable;
u32 size;
};
struct hfi_multi_view_select {
u32 view_index;
};
#define HFI_PRIORITY_LOW 10
#define HFI_PRIOIRTY_MEDIUM 20
#define HFI_PRIORITY_HIGH 30
#define HFI_OUTPUT_ORDER_DISPLAY (HFI_OX_BASE + 0x1)
#define HFI_OUTPUT_ORDER_DECODE (HFI_OX_BASE + 0x2)
#define HFI_RATE_CONTROL_OFF (HFI_OX_BASE + 0x1)
#define HFI_RATE_CONTROL_VBR_VFR (HFI_OX_BASE + 0x2)
#define HFI_RATE_CONTROL_VBR_CFR (HFI_OX_BASE + 0x3)
#define HFI_RATE_CONTROL_CBR_VFR (HFI_OX_BASE + 0x4)
#define HFI_RATE_CONTROL_CBR_CFR (HFI_OX_BASE + 0x5)
struct hfi_uncompressed_plane_actual_constraints_info {
u32 buffer_type;
u32 num_planes;
struct hfi_uncompressed_plane_constraints rg_plane_format[1];
};
#define HFI_CMD_SYS_OX_START \
(HFI_DOMAIN_BASE_COMMON + HFI_ARCH_OX_OFFSET + HFI_CMD_START_OFFSET + 0x0000)
#define HFI_CMD_SYS_SESSION_ABORT (HFI_CMD_SYS_OX_START + 0x001)
#define HFI_CMD_SYS_PING (HFI_CMD_SYS_OX_START + 0x002)
#define HFI_CMD_SESSION_OX_START \
(HFI_DOMAIN_BASE_COMMON + HFI_ARCH_OX_OFFSET + HFI_CMD_START_OFFSET + 0x1000)
#define HFI_CMD_SESSION_LOAD_RESOURCES (HFI_CMD_SESSION_OX_START + 0x001)
#define HFI_CMD_SESSION_START (HFI_CMD_SESSION_OX_START + 0x002)
#define HFI_CMD_SESSION_STOP (HFI_CMD_SESSION_OX_START + 0x003)
#define HFI_CMD_SESSION_EMPTY_BUFFER (HFI_CMD_SESSION_OX_START + 0x004)
#define HFI_CMD_SESSION_FILL_BUFFER (HFI_CMD_SESSION_OX_START + 0x005)
#define HFI_CMD_SESSION_SUSPEND (HFI_CMD_SESSION_OX_START + 0x006)
#define HFI_CMD_SESSION_RESUME (HFI_CMD_SESSION_OX_START + 0x007)
#define HFI_CMD_SESSION_FLUSH (HFI_CMD_SESSION_OX_START + 0x008)
#define HFI_CMD_SESSION_GET_PROPERTY (HFI_CMD_SESSION_OX_START + 0x009)
#define HFI_CMD_SESSION_PARSE_SEQUENCE_HEADER \
(HFI_CMD_SESSION_OX_START + 0x00A)
#define HFI_CMD_SESSION_RELEASE_BUFFERS \
(HFI_CMD_SESSION_OX_START + 0x00B)
#define HFI_CMD_SESSION_RELEASE_RESOURCES \
(HFI_CMD_SESSION_OX_START + 0x00C)
#define HFI_MSG_SYS_OX_START \
(HFI_DOMAIN_BASE_COMMON + HFI_ARCH_OX_OFFSET + HFI_MSG_START_OFFSET + 0x0000)
#define HFI_MSG_SYS_IDLE (HFI_MSG_SYS_OX_START + 0x1)
#define HFI_MSG_SYS_PING_ACK (HFI_MSG_SYS_OX_START + 0x2)
#define HFI_MSG_SYS_PROPERTY_INFO (HFI_MSG_SYS_OX_START + 0x3)
#define HFI_MSG_SYS_SESSION_ABORT_DONE (HFI_MSG_SYS_OX_START + 0x4)
#define HFI_MSG_SESSION_OX_START \
(HFI_DOMAIN_BASE_COMMON + HFI_ARCH_OX_OFFSET + HFI_MSG_START_OFFSET + 0x1000)
#define HFI_MSG_SESSION_LOAD_RESOURCES_DONE (HFI_MSG_SESSION_OX_START + 0x1)
#define HFI_MSG_SESSION_START_DONE (HFI_MSG_SESSION_OX_START + 0x2)
#define HFI_MSG_SESSION_STOP_DONE (HFI_MSG_SESSION_OX_START + 0x3)
#define HFI_MSG_SESSION_SUSPEND_DONE (HFI_MSG_SESSION_OX_START + 0x4)
#define HFI_MSG_SESSION_RESUME_DONE (HFI_MSG_SESSION_OX_START + 0x5)
#define HFI_MSG_SESSION_FLUSH_DONE (HFI_MSG_SESSION_OX_START + 0x6)
#define HFI_MSG_SESSION_EMPTY_BUFFER_DONE (HFI_MSG_SESSION_OX_START + 0x7)
#define HFI_MSG_SESSION_FILL_BUFFER_DONE (HFI_MSG_SESSION_OX_START + 0x8)
#define HFI_MSG_SESSION_PROPERTY_INFO (HFI_MSG_SESSION_OX_START + 0x9)
#define HFI_MSG_SESSION_RELEASE_RESOURCES_DONE \
(HFI_MSG_SESSION_OX_START + 0xA)
#define HFI_MSG_SESSION_PARSE_SEQUENCE_HEADER_DONE \
(HFI_MSG_SESSION_OX_START + 0xB)
#define HFI_MSG_SESSION_RELEASE_BUFFERS_DONE \
(HFI_MSG_SESSION_OX_START + 0xC)
#define HFI_MIN_PKT_SIZE 8
struct hfi_cmd_sys_session_abort_packet {
u32 size;
u32 packet_type;
u32 session_id;
};
struct hfi_cmd_sys_ping_packet {
u32 size;
u32 packet_type;
u32 client_data;
};
struct hfi_cmd_session_load_resources_packet {
u32 size;
u32 packet_type;
u32 session_id;
};
struct hfi_cmd_session_start_packet {
u32 size;
u32 packet_type;
u32 session_id;
};
struct hfi_cmd_session_stop_packet {
u32 size;
u32 packet_type;
u32 session_id;
};
struct hfi_cmd_session_empty_buffer_compressed_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 time_stamp_hi;
u32 time_stamp_lo;
u32 flags;
u32 mark_target;
u32 mark_data;
u32 offset;
u32 alloc_len;
u32 filled_len;
u32 input_tag;
u8 *packet_buffer;
u8 *extra_data_buffer;
u32 rgData[0];
};
struct hfi_cmd_session_empty_buffer_uncompressed_plane0_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 view_id;
u32 time_stamp_hi;
u32 time_stamp_lo;
u32 flags;
u32 mark_target;
u32 mark_data;
u32 alloc_len;
u32 filled_len;
u32 offset;
u32 input_tag;
u8 *packet_buffer;
u8 *extra_data_buffer;
u32 rgData[0];
};
struct hfi_cmd_session_empty_buffer_uncompressed_plane1_packet {
u32 flags;
u32 alloc_len;
u32 filled_len;
u32 offset;
u8 *packet_buffer2;
u32 rgData[0];
};
struct hfi_cmd_session_empty_buffer_uncompressed_plane2_packet {
u32 flags;
u32 alloc_len;
u32 filled_len;
u32 offset;
u8 *packet_buffer3;
u32 rgData[0];
};
struct hfi_cmd_session_fill_buffer_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 stream_id;
u32 offset;
u32 alloc_len;
u32 filled_len;
u32 output_tag;
u8 *packet_buffer;
u8 *extra_data_buffer;
u32 rgData[0];
};
struct hfi_cmd_session_flush_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 flush_type;
};
struct hfi_cmd_session_suspend_packet {
u32 size;
u32 packet_type;
u32 session_id;
};
struct hfi_cmd_session_resume_packet {
u32 size;
u32 packet_type;
u32 session_id;
};
struct hfi_cmd_session_get_property_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 num_properties;
u32 rg_property_data[1];
};
struct hfi_cmd_session_release_buffer_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 buffer_type;
u32 buffer_size;
u32 extra_data_size;
int response_req;
u32 num_buffers;
u32 rg_buffer_info[1];
};
struct hfi_cmd_session_release_resources_packet {
u32 size;
u32 packet_type;
u32 session_id;
};
struct hfi_cmd_session_parse_sequence_header_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 header_len;
u8 *packet_buffer;
};
struct hfi_msg_sys_session_abort_done_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 error_type;
};
struct hfi_msg_sys_idle_packet {
u32 size;
u32 packet_type;
};
struct hfi_msg_sys_ping_ack_packet {
u32 size;
u32 packet_type;
u32 client_data;
};
struct hfi_msg_sys_property_info_packet {
u32 size;
u32 packet_type;
u32 num_properties;
u32 rg_property_data[1];
};
struct hfi_msg_session_load_resources_done_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 error_type;
};
struct hfi_msg_session_start_done_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 error_type;
};
struct hfi_msg_session_stop_done_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 error_type;
};
struct hfi_msg_session_suspend_done_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 error_type;
};
struct hfi_msg_session_resume_done_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 error_type;
};
struct hfi_msg_session_flush_done_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 error_type;
u32 flush_type;
};
struct hfi_msg_session_empty_buffer_done_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 error_type;
u32 offset;
u32 filled_len;
u32 input_tag;
u8 *packet_buffer;
u8 *extra_data_buffer;
u32 rgData[0];
};
struct hfi_msg_session_fill_buffer_done_compressed_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 time_stamp_hi;
u32 time_stamp_lo;
u32 error_type;
u32 flags;
u32 mark_target;
u32 mark_data;
u32 stats;
u32 offset;
u32 alloc_len;
u32 filled_len;
u32 input_tag;
u32 output_tag;
u32 picture_type;
u8 *packet_buffer;
u8 *extra_data_buffer;
u32 rgData[0];
};
struct hfi_msg_session_fbd_uncompressed_plane0_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 stream_id;
u32 view_id;
u32 error_type;
u32 time_stamp_hi;
u32 time_stamp_lo;
u32 flags;
u32 mark_target;
u32 mark_data;
u32 stats;
u32 alloc_len;
u32 filled_len;
u32 offset;
u32 frame_width;
u32 frame_height;
u32 start_x_coord;
u32 start_y_coord;
u32 input_tag;
u32 input_tag2;
u32 output_tag;
u32 picture_type;
u8 *packet_buffer;
u8 *extra_data_buffer;
u32 rgData[0];
};
struct hfi_msg_session_fill_buffer_done_uncompressed_plane1_packet {
u32 flags;
u32 alloc_len;
u32 filled_len;
u32 offset;
u8 *packet_buffer2;
u32 rgData[0];
};
struct hfi_msg_session_fill_buffer_done_uncompressed_plane2_packet {
u32 flags;
u32 alloc_len;
u32 filled_len;
u32 offset;
u8 *packet_buffer3;
u32 rgData[0];
};
struct hfi_msg_session_parse_sequence_header_done_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 error_type;
u32 num_properties;
u32 rg_property_data[1];
};
struct hfi_msg_session_property_info_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 num_properties;
u32 rg_property_data[1];
};
struct hfi_msg_session_release_resources_done_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 error_type;
};
struct hfi_msg_session_release_buffers_done_packet {
u32 size;
u32 packet_type;
u32 session_id;
u32 error_type;
u32 num_buffers;
u32 rg_buffer_info[1];
};
struct hfi_extradata_mb_quantization_payload {
u8 rg_mb_qp[1];
};
struct hfi_extradata_vc1_pswnd {
u32 ps_wnd_h_offset;
u32 ps_wnd_v_offset;
u32 ps_wnd_width;
u32 ps_wnd_height;
};
struct hfi_extradata_vc1_framedisp_payload {
u32 res_pic;
u32 ref;
u32 range_map_present;
u32 range_map_y;
u32 range_map_uv;
u32 num_pan_scan_wnds;
struct hfi_extradata_vc1_pswnd rg_ps_wnd[1];
};
struct hfi_extradata_vc1_seqdisp_payload {
u32 prog_seg_frm;
u32 uv_sampling_fmt;
u32 color_fmt_flag;
u32 color_primaries;
u32 transfer_char;
u32 mat_coeff;
u32 aspect_ratio;
u32 aspect_horiz;
u32 aspect_vert;
};
struct hfi_extradata_timestamp_payload {
u32 time_stamp_low;
u32 time_stamp_high;
};
struct hfi_extradata_s3d_frame_packing_payload {
u32 fpa_id;
int cancel_flag;
u32 fpa_type;
int quin_cunx_flag;
u32 content_interprtation_type;
int spatial_flipping_flag;
int frame0_flipped_flag;
int field_views_flag;
int current_frame_isFrame0_flag;
int frame0_self_contained_flag;
int frame1_self_contained_flag;
u32 frame0_graid_pos_x;
u32 frame0_graid_pos_y;
u32 frame1_graid_pos_x;
u32 frame1_graid_pos_y;
u32 fpa_reserved_byte;
u32 fpa_repetition_period;
int fpa_extension_flag;
};
struct hfi_extradata_interlace_video_payload {
u32 format;
};
struct hfi_extradata_num_concealed_mb_payload {
u32 num_mb_concealed;
};
struct hfi_extradata_sliceinfo {
u32 offset_in_stream;
u32 slice_length;
};
struct hfi_extradata_multislice_info_payload {
u32 num_slices;
struct hfi_extradata_sliceinfo rg_slice_info[1];
};
struct hfi_index_extradata_input_crop_payload {
u32 size;
u32 version;
u32 port_index;
u32 left;
u32 top;
u32 width;
u32 height;
};
struct hfi_index_extradata_digital_zoom_payload {
u32 size;
u32 version;
u32 port_index;
int width;
int height;
};
struct hfi_index_extradata_aspect_ratio_payload {
u32 size;
u32 version;
u32 port_index;
u32 aspect_width;
u32 aspect_height;
};
struct hfi_extradata_panscan_wndw_payload {
u32 num_window;
struct hfi_extradata_vc1_pswnd wnd[1];
};
struct hfi_extradata_frame_type_payload {
u32 frame_rate;
};
struct hfi_extradata_recovery_point_sei_payload {
u32 flag;
};
struct hal_session {
struct list_head list;
u32 session_id;
u32 is_decoder;
void *device;
};
struct hal_device_data {
struct list_head dev_head;
int dev_count;
};
extern struct hal_device_data hal_ctxt;
void hfi_process_msg_packet(msm_vidc_callback callback,
u32 device_id, struct vidc_hal_msg_pkt_hdr *msg_hdr);
#endif
drivers/media/video/msm_vidc/vidc_hfi_api.h
+81 -39
View File
@@ -1,4 +1,4 @@
/* Copyright (c) 2012, The Linux Foundation. All rights reserved.
/* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
@@ -14,7 +14,9 @@
#ifndef __VIDC_HFI_API_H__
#define __VIDC_HFI_API_H__
#include <linux/platform_device.h>
#include <linux/types.h>
#include <media/msm_vidc.h>
#define CONTAINS(__a, __sz, __t) ({\
int __rc = __t >= __a && \
@@ -979,44 +981,84 @@ struct buffer_requirements {
struct hal_buffer_requirements buffer[HAL_BUFFER_MAX];
};
/* VIDC_HAL CORE API's */
int venus_hfi_core_init(void *device);
int venus_hfi_core_release(void *device);
int venus_hfi_core_pc_prep(void *device);
int venus_hfi_core_set_resource(void *device,
struct vidc_resource_hdr *resource_hdr, void *resource_value);
int venus_hfi_core_release_resource(void *device,
struct vidc_resource_hdr *resource_hdr);
int venus_hfi_core_ping(void *device);
enum msm_vidc_hfi_type {
VIDC_HFI_VENUS,
VIDC_HFI_Q6,
};
enum mem_type {
DDR_MEM = 0x1,
OCMEM_MEM = 0x2,
};
enum fw_info {
FW_BASE_ADDRESS,
FW_REGISTER_BASE,
FW_REGISTER_SIZE,
FW_IRQ,
FW_INFO_MAX,
};
struct hfi_device {
void *hfi_device_data;
/*Add function pointers for all the hfi functions below*/
int (*core_init)(void *device);
int (*core_release)(void *device);
int (*core_pc_prep)(void *device);
int (*core_ping)(void *device);
void *(*session_init)(void *device, u32 session_id,
enum hal_domain session_type, enum hal_video_codec codec_type);
int (*session_end)(void *session);
int (*session_abort)(void *session);
int (*session_set_buffers)(void *sess,
struct vidc_buffer_addr_info *buffer_info);
int (*session_release_buffers)(void *sess,
struct vidc_buffer_addr_info *buffer_info);
int (*session_load_res)(void *sess);
int (*session_release_res)(void *sess);
int (*session_start)(void *sess);
int (*session_stop)(void *sess);
int (*session_suspend)(void *sess);
int (*session_resume)(void *sess);
int (*session_etb)(void *sess,
struct vidc_frame_data *input_frame);
int (*session_ftb)(void *sess,
struct vidc_frame_data *output_frame);
int (*session_parse_seq_hdr)(void *sess,
struct vidc_seq_hdr *seq_hdr);
int (*session_get_seq_hdr)(void *sess,
struct vidc_seq_hdr *seq_hdr);
int (*session_get_buf_req)(void *sess);
int (*session_flush)(void *sess, enum hal_flush flush_mode);
int (*session_set_property)(void *sess, enum hal_property ptype,
void *pdata);
int (*session_get_property)(void *sess, enum hal_property ptype,
void *pdata);
int (*scale_clocks)(void *dev, int load);
int (*scale_bus)(void *dev, int load,
enum session_type type, enum mem_type mtype);
int (*unset_ocmem)(void *dev);
int (*alloc_ocmem)(void *dev, unsigned long size);
int (*free_ocmem)(void *dev);
int (*is_ocmem_present)(void *dev);
int (*get_domain)(void *dev, enum msm_vidc_io_maps iomap);
int (*iommu_get_map)(void *dev,
struct msm_vidc_iommu_info maps[MAX_MAP]);
int (*load_fw)(void *dev);
void (*unload_fw)(void *dev);
int (*get_fw_info)(void *dev, enum fw_info info);
};
typedef void (*hfi_cmd_response_callback) (enum command_response cmd,
void *data);
typedef void (*msm_vidc_callback) (u32 response, void *callback);
void *vidc_hfi_initialize(enum msm_vidc_hfi_type hfi_type, u32 device_id,
struct platform_device *pdev,
hfi_cmd_response_callback callback);
void vidc_hfi_deinitialize(enum msm_vidc_hfi_type hfi_type,
struct hfi_device *hdev);
/* VIDC_HAL SESSION API's */
void *venus_hfi_session_init(void *device, u32 session_id,
enum hal_domain session_type, enum hal_video_codec codec_type);
int venus_hfi_session_end(void *session);
int venus_hfi_session_abort(void *session);
int venus_hfi_session_set_buffers(void *sess,
struct vidc_buffer_addr_info *buffer_info);
int venus_hfi_session_release_buffers(void *sess,
struct vidc_buffer_addr_info *buffer_info);
int venus_hfi_session_load_res(void *sess);
int venus_hfi_session_release_res(void *sess);
int venus_hfi_session_start(void *sess);
int venus_hfi_session_stop(void *sess);
int venus_hfi_session_suspend(void *sess);
int venus_hfi_session_resume(void *sess);
int venus_hfi_session_etb(void *sess,
struct vidc_frame_data *input_frame);
int venus_hfi_session_ftb(void *sess,
struct vidc_frame_data *output_frame);
int venus_hfi_session_parse_seq_hdr(void *sess,
struct vidc_seq_hdr *seq_hdr);
int venus_hfi_session_get_seq_hdr(void *sess,
struct vidc_seq_hdr *seq_hdr);
int venus_hfi_session_get_buf_req(void *sess);
int venus_hfi_session_flush(void *sess, enum hal_flush flush_mode);
int venus_hfi_session_set_property(void *sess, enum hal_property ptype,
void *pdata);
int venus_hfi_session_get_property(void *sess, enum hal_property ptype,
void *pdata);
#endif /*__VIDC_HFI_API_H__ */