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;
dprintk(VIDC_DBG, "RECEIVED: SESSION_FLUSH_DONE[%u]\n",
pkt->session_id);
if (sizeof(struct hfi_msg_session_flush_done_packet) != pkt->size) {
dprintk(VIDC_ERR, "hal_process_session_flush_done: "
"bad packet size: %d", pkt->size);
return;
}
memset(&cmd_done, 0, sizeof(struct msm_vidc_cb_cmd_done));
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);
callback(SESSION_FLUSH_DONE, &cmd_done);
}
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;
u32 pkt_size;
memset(&cmd_done, 0, sizeof(struct msm_vidc_cb_cmd_done));
dprintk(VIDC_DBG, "RECEIVED:SYS_RELEASE_RESOURCE_DONE");
pkt_size = sizeof(struct hfi_msg_sys_release_resource_done_packet);
if (pkt_size > pkt->size) {
dprintk(VIDC_ERR,
"hal_process_sys_rel_resource_done:bad size:%d",
pkt->size);
return;
}
status = hfi_map_err_status((u32)pkt->error_type);
cmd_done.device_id = device_id;
cmd_done.session_id = 0;
cmd_done.status = (u32) status;
cmd_done.size = 0;
cmd_done.data = NULL;
callback(RELEASE_RESOURCE_DONE, &cmd_done);
}
static void hfi_process_session_abort_done(
msm_vidc_callback callback, u32 device_id,
struct hfi_msg_sys_session_abort_done_packet *pkt)
{
struct msm_vidc_cb_cmd_done cmd_done;
dprintk(VIDC_DBG, "RECEIVED: SESSION_ABORT_DONE[%u]\n",
pkt->session_id);
if (!pkt || pkt->size !=
sizeof(struct hfi_msg_sys_session_abort_done_packet)) {
dprintk(VIDC_ERR, "%s: bad packet/packet size: %d",
__func__, pkt ? pkt->size : 0);
return;
}
memset(&cmd_done, 0, sizeof(struct msm_vidc_cb_cmd_done));
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;
callback(SESSION_ABORT_DONE, &cmd_done);
}
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");
if (sizeof(struct hfi_msg_session_load_resources_done_packet) !=
pkt->size) {
dprintk(VIDC_ERR, "hal_process_session_load_res_done:"
" bad packet size: %d", pkt->size);
return;
}
memset(&cmd_done, 0, sizeof(struct msm_vidc_cb_cmd_done));
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;
callback(SESSION_LOAD_RESOURCE_DONE, &cmd_done);
}
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 =
(struct hfi_msg_session_fill_buffer_done_compressed_packet *) msg_hdr;
u32 is_decoder = ((struct hal_session *)pack->session_id)->is_decoder;
struct hal_session *session;
if (!msg_hdr) {
dprintk(VIDC_ERR, "Invalid Params");
return;
}
session = (struct hal_session *)
((struct hal_session *) pack->session_id)->session_id;
dprintk(VIDC_DBG, "RECEIVED: SESSION_FTB_DONE[%u]\n",
pack->session_id);
memset(&data_done, 0, sizeof(struct msm_vidc_cb_data_done));
if (is_decoder == 0) {
struct hfi_msg_session_fill_buffer_done_compressed_packet *pkt =
(struct hfi_msg_session_fill_buffer_done_compressed_packet *)
msg_hdr;
if (sizeof(struct
hfi_msg_session_fill_buffer_done_compressed_packet)
> pkt->size) {
dprintk(VIDC_ERR,
"hal_process_session_ftb_done: bad_pkt_size");
return;
} else if (pkt->error_type != HFI_ERR_NONE) {
dprintk(VIDC_ERR,
"got buffer back with error %x",
pkt->error_type);
/* Proceed with the FBD */
}
data_done.device_id = device_id;
data_done.session_id = (u32) session;
data_done.status = hfi_map_err_status((u32)
pkt->error_type);
data_done.size = sizeof(struct msm_vidc_cb_data_done);
data_done.clnt_data = (void *) pkt->input_tag;
data_done.output_done.timestamp_hi = pkt->time_stamp_hi;
data_done.output_done.timestamp_lo = pkt->time_stamp_lo;
data_done.output_done.flags1 = pkt->flags;
data_done.output_done.mark_target = pkt->mark_target;
data_done.output_done.mark_data = pkt->mark_data;
data_done.output_done.stats = pkt->stats;
data_done.output_done.offset1 = pkt->offset;
data_done.output_done.alloc_len1 = pkt->alloc_len;
data_done.output_done.filled_len1 = pkt->filled_len;
data_done.output_done.picture_type = pkt->picture_type;
data_done.output_done.packet_buffer1 = pkt->packet_buffer;
data_done.output_done.extra_data_buffer =
pkt->extra_data_buffer;
data_done.output_done.buffer_type = HAL_BUFFER_OUTPUT;
dprintk(VIDC_DBG, "FBD: Received buf: %p, of len: %d\n",
pkt->packet_buffer, pkt->filled_len);
} else if (is_decoder == 1) {
struct hfi_msg_session_fbd_uncompressed_plane0_packet *pkt =
(struct hfi_msg_session_fbd_uncompressed_plane0_packet *)
msg_hdr;
if (sizeof(struct
hfi_msg_session_fbd_uncompressed_plane0_packet)
> pkt->size) {
dprintk(VIDC_ERR, "hal_process_session_ftb_done:"
"bad_pkt_size");
return;
}
data_done.device_id = device_id;
data_done.session_id = (u32) session;
data_done.status = hfi_map_err_status((u32)
pkt->error_type);
data_done.size = sizeof(struct msm_vidc_cb_data_done);
data_done.clnt_data = (void *)pkt->input_tag;
data_done.output_done.stream_id = pkt->stream_id;
data_done.output_done.view_id = pkt->view_id;
data_done.output_done.timestamp_hi = pkt->time_stamp_hi;
data_done.output_done.timestamp_lo = pkt->time_stamp_lo;
data_done.output_done.flags1 = pkt->flags;
data_done.output_done.mark_target = pkt->mark_target;
data_done.output_done.mark_data = pkt->mark_data;
data_done.output_done.stats = pkt->stats;
data_done.output_done.alloc_len1 = pkt->alloc_len;
data_done.output_done.filled_len1 = pkt->filled_len;
data_done.output_done.offset1 = pkt->offset;
data_done.output_done.frame_width = pkt->frame_width;
data_done.output_done.frame_height = pkt->frame_height;
data_done.output_done.start_x_coord = pkt->start_x_coord;
data_done.output_done.start_y_coord = pkt->start_y_coord;
data_done.output_done.input_tag1 = pkt->input_tag;
data_done.output_done.picture_type = pkt->picture_type;
data_done.output_done.packet_buffer1 = pkt->packet_buffer;
data_done.output_done.extra_data_buffer =
pkt->extra_data_buffer;
if (pkt->stream_id == 0)
data_done.output_done.buffer_type = HAL_BUFFER_OUTPUT;
else if (pkt->stream_id == 1)
data_done.output_done.buffer_type = HAL_BUFFER_OUTPUT2;
}
callback(SESSION_FTB_DONE, &data_done);
}
enum vidc_status hfi_process_sess_init_done_prop_read(
struct hfi_msg_sys_session_init_done_packet *pkt,
struct vidc_hal_session_init_done *sess_init_done)
{
u32 rem_bytes, num_properties;
u8 *data_ptr;
u32 status = VIDC_ERR_NONE;
u32 prop_id, next_offset = 0;
rem_bytes = pkt->size - sizeof(struct
hfi_msg_sys_session_init_done_packet) + sizeof(u32);
if (rem_bytes == 0) {
dprintk(VIDC_ERR,
"hfi_msg_sys_session_init_done:missing_prop_info");
return VIDC_ERR_FAIL;
}
status = hfi_map_err_status((u32)pkt->error_type);
if (status)
return status;
data_ptr = (u8 *) &pkt->rg_property_data[0];
num_properties = pkt->num_properties;
while ((status == VIDC_ERR_NONE) && num_properties &&
(rem_bytes >= sizeof(u32))) {
prop_id = *((u32 *)data_ptr);
next_offset = sizeof(u32);
switch (prop_id) {
case HFI_PROPERTY_PARAM_CAPABILITY_SUPPORTED:
{
struct hfi_capability_supported_info *prop =
(struct hfi_capability_supported_info *)
(data_ptr + next_offset);
u32 num_capabilities;
struct hfi_capability_supported *cap_ptr;
if ((rem_bytes - next_offset) < sizeof(*cap_ptr)) {
status = VIDC_ERR_BAD_PARAM;
break;
}
num_capabilities = prop->num_capabilities;
cap_ptr = &prop->rg_data[0];
next_offset += sizeof(u32);
while (num_capabilities &&
((rem_bytes - next_offset) >= sizeof(u32))) {
copy_cap_prop(cap_ptr, sess_init_done);
cap_ptr++;
next_offset += sizeof(*cap_ptr);
num_capabilities--;
}
num_properties--;
break;
}
case HFI_PROPERTY_PARAM_UNCOMPRESSED_FORMAT_SUPPORTED:
{
struct hfi_uncompressed_format_supported *prop =
(struct hfi_uncompressed_format_supported *)
(data_ptr + next_offset);
u32 num_format_entries;
char *fmt_ptr;
struct hfi_uncompressed_plane_info *plane_info;
if ((rem_bytes - next_offset) < sizeof(*prop)) {
status = VIDC_ERR_BAD_PARAM;
break;
}
num_format_entries = prop->format_entries;
next_offset = sizeof(*prop) - sizeof(u32);
fmt_ptr = (char *)&prop->rg_format_info[0];
while (num_format_entries) {
u32 bytes_to_skip;
plane_info =
(struct hfi_uncompressed_plane_info *) fmt_ptr;
if ((rem_bytes - next_offset) <
sizeof(*plane_info)) {
status = VIDC_ERR_BAD_PARAM;
break;
}
bytes_to_skip = sizeof(*plane_info) -
sizeof(struct
hfi_uncompressed_plane_constraints) +
plane_info->num_planes *
sizeof(struct
hfi_uncompressed_plane_constraints);
fmt_ptr += bytes_to_skip;
next_offset += bytes_to_skip;
num_format_entries--;
}
num_properties--;
break;
}
case HFI_PROPERTY_PARAM_PROPERTIES_SUPPORTED:
{
struct hfi_properties_supported *prop =
(struct hfi_properties_supported *)
(data_ptr + next_offset);
next_offset += sizeof(*prop) - sizeof(u32)
+ prop->num_properties * sizeof(u32);
num_properties--;
break;
}
case HFI_PROPERTY_PARAM_PROFILE_LEVEL_SUPPORTED:
{
struct hfi_profile_level_supported *prop =
(struct hfi_profile_level_supported *)
(data_ptr + next_offset);
next_offset += sizeof(*prop) -
sizeof(struct hfi_profile_level) +
prop->profile_count *
sizeof(struct hfi_profile_level);
num_properties--;
break;
}
case HFI_PROPERTY_PARAM_NAL_STREAM_FORMAT_SUPPORTED:
{
next_offset +=
sizeof(struct hfi_nal_stream_format_supported);
num_properties--;
break;
}
case HFI_PROPERTY_PARAM_NAL_STREAM_FORMAT_SELECT:
{
next_offset += sizeof(u32);
num_properties--;
break;
}
case HFI_PROPERTY_PARAM_MAX_SEQUENCE_HEADER_SIZE:
{
next_offset += sizeof(u32);
num_properties--;
break;
}
case HFI_PROPERTY_PARAM_VENC_INTRA_REFRESH:
{
next_offset +=
sizeof(struct hfi_intra_refresh);
num_properties--;
break;
}
case HFI_PROPERTY_PARAM_BUFFER_ALLOC_MODE_SUPPORTED:
{
struct hfi_buffer_alloc_mode_supported *prop =
(struct hfi_buffer_alloc_mode_supported *)
(data_ptr + next_offset);
int i;
if (prop->buffer_type == HFI_BUFFER_OUTPUT ||
prop->buffer_type == HFI_BUFFER_OUTPUT2) {
sess_init_done->alloc_mode_out = 0;
for (i = 0; i < prop->num_entries; i++) {
switch (prop->rg_data[i]) {
case HFI_BUFFER_MODE_STATIC:
sess_init_done->alloc_mode_out
|= HAL_BUFFER_MODE_STATIC;
break;
case HFI_BUFFER_MODE_DYNAMIC:
sess_init_done->alloc_mode_out
|= HAL_BUFFER_MODE_DYNAMIC;
break;
}
if (i >= 32) {
dprintk(VIDC_ERR,
"%s - num_entries: %d from f/w seems suspect\n",
__func__, prop->num_entries);
break;
}
}
}
next_offset += sizeof(*prop) -
sizeof(u32) + prop->num_entries * sizeof(u32);
num_properties--;
break;
}
default:
dprintk(VIDC_DBG,
"%s default case - 0x%x", __func__, prop_id);
}
rem_bytes -= next_offset;
data_ptr += next_offset;
}
return status;
}
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;
struct vidc_hal_sys_init_done sys_init_done;
u32 rem_bytes, bytes_read = 0, num_properties;
u8 *data_ptr;
int prop_id;
enum vidc_status status = VIDC_ERR_NONE;
#ifdef REDUCE_KERNEL_ERROR_LOG
debug_kernel_count=0;
#endif
dprintk(VIDC_DBG, "RECEIVED:SYS_INIT_DONE");
if (sizeof(struct hfi_msg_sys_init_done_packet) > pkt->size) {
dprintk(VIDC_ERR, "hal_process_sys_init_done:bad_pkt_size: %d",
pkt->size);
return;
}
status = hfi_map_err_status((u32)pkt->error_type);
if (!status) {
if (pkt->num_properties == 0) {
dprintk(VIDC_ERR, "hal_process_sys_init_done:"
"no_properties");
status = VIDC_ERR_FAIL;
goto err_no_prop;
}
rem_bytes = pkt->size - sizeof(struct
hfi_msg_sys_init_done_packet) + sizeof(u32);
if (rem_bytes == 0) {
dprintk(VIDC_ERR, "hal_process_sys_init_done:"
"missing_prop_info");
status = VIDC_ERR_FAIL;
goto err_no_prop;
}
memset(&cmd_done, 0, sizeof(struct msm_vidc_cb_cmd_done));
memset(&sys_init_done, 0, sizeof(struct
vidc_hal_sys_init_done));
data_ptr = (u8 *) &pkt->rg_property_data[0];
num_properties = pkt->num_properties;
while ((num_properties != 0) && (rem_bytes >= sizeof(u32))) {
prop_id = *((u32 *)data_ptr);
data_ptr = data_ptr + 4;
switch (prop_id) {
case HFI_PROPERTY_PARAM_CODEC_SUPPORTED:
{
struct hfi_codec_supported *prop =
(struct hfi_codec_supported *) data_ptr;
if (rem_bytes < sizeof(struct
hfi_codec_supported)) {
status = VIDC_ERR_BAD_PARAM;
break;
}
sys_init_done.dec_codec_supported =
prop->decoder_codec_supported;
sys_init_done.enc_codec_supported =
prop->encoder_codec_supported;
break;
}
default:
dprintk(VIDC_ERR, "hal_process_sys_init_done:"
"bad_prop_id");
status = VIDC_ERR_BAD_PARAM;
break;
}
if (!status) {
rem_bytes -= bytes_read;
data_ptr += bytes_read;
num_properties--;
}
}
}
err_no_prop:
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;
callback(SYS_INIT_DONE, &cmd_done);
}
