diff --git a/drivers/media/video/msm_vidc/Makefile b/drivers/media/video/msm_vidc/Makefile index c8e7076cf83..da829cc19f0 100644 --- a/drivers/media/video/msm_vidc/Makefile +++ b/drivers/media/video/msm_vidc/Makefile @@ -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 \ diff --git a/drivers/media/video/msm_vidc/hfi_packetization.h b/drivers/media/video/msm_vidc/hfi_packetization.h index 541654f64af..a3edc7c9daa 100644 --- a/drivers/media/video/msm_vidc/hfi_packetization.h +++ b/drivers/media/video/msm_vidc/hfi_packetization.h @@ -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 #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); diff --git a/drivers/media/video/msm_vidc/hfi_response_handler.c b/drivers/media/video/msm_vidc/hfi_response_handler.c index 50970cb3c1e..23829e5953d 100644 --- a/drivers/media/video/msm_vidc/hfi_response_handler.c +++ b/drivers/media/video/msm_vidc/hfi_response_handler.c @@ -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 #include #include -#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"); - } -} diff --git a/drivers/media/video/msm_vidc/msm_v4l2_vidc.c b/drivers/media/video/msm_vidc/msm_v4l2_vidc.c index a30d6051065..4f39357e709 100644 --- a/drivers/media/video/msm_vidc/msm_v4l2_vidc.c +++ b/drivers/media/video/msm_vidc/msm_v4l2_vidc.c @@ -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); diff --git a/drivers/media/video/msm_vidc/msm_vdec.c b/drivers/media/video/msm_vidc/msm_vdec.c index 525bad8f653..24407dd08ea 100644 --- a/drivers/media/video/msm_vidc/msm_vdec.c +++ b/drivers/media/video/msm_vidc/msm_vdec.c @@ -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); } diff --git a/drivers/media/video/msm_vidc/msm_venc.c b/drivers/media/video/msm_vidc/msm_venc.c index 341e06f2790..080f4c49a8e 100644 --- a/drivers/media/video/msm_vidc/msm_venc.c +++ b/drivers/media/video/msm_vidc/msm_venc.c @@ -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, diff --git a/drivers/media/video/msm_vidc/msm_vidc.c b/drivers/media/video/msm_vidc/msm_vidc.c index b9f15080194..73c98606a37 100644 --- a/drivers/media/video/msm_vidc/msm_vidc.c +++ b/drivers/media/video/msm_vidc/msm_vidc.c @@ -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 -#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) diff --git a/drivers/media/video/msm_vidc/msm_vidc_common.c b/drivers/media/video/msm_vidc/msm_vidc_common.c index eac715ff211..955f4caa906 100644 --- a/drivers/media/video/msm_vidc/msm_vidc_common.c +++ b/drivers/media/video/msm_vidc/msm_vidc_common.c @@ -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); diff --git a/drivers/media/video/msm_vidc/msm_vidc_debug.c b/drivers/media/video/msm_vidc/msm_vidc_debug.c index bdf146e5b77..ff829d73e6e 100644 --- a/drivers/media/video/msm_vidc/msm_vidc_debug.c +++ b/drivers/media/video/msm_vidc/msm_vidc_debug.c @@ -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)]) ? diff --git a/drivers/media/video/msm_vidc/msm_vidc_internal.h b/drivers/media/video/msm_vidc/msm_vidc_internal.h index a2c3d01c9cc..52c1de8afdf 100644 --- a/drivers/media/video/msm_vidc/msm_vidc_internal.h +++ b/drivers/media/video/msm_vidc/msm_vidc_internal.h @@ -31,6 +31,7 @@ #include #include +#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 diff --git a/drivers/media/video/msm_vidc/venus_hfi.c b/drivers/media/video/msm_vidc/venus_hfi.c index 8f0902fc75c..015ed115e09 100644 --- a/drivers/media/video/msm_vidc/venus_hfi.c +++ b/drivers/media/video/msm_vidc/venus_hfi.c @@ -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; +} + diff --git a/drivers/media/video/msm_vidc/venus_hfi.h b/drivers/media/video/msm_vidc/venus_hfi.h index 93b9ae359ee..f825c208edb 100644 --- a/drivers/media/video/msm_vidc/venus_hfi.h +++ b/drivers/media/video/msm_vidc/venus_hfi.h @@ -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 #include #include -#include + #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 diff --git a/drivers/media/video/msm_vidc/vidc_hfi.c b/drivers/media/video/msm_vidc/vidc_hfi.c new file mode 100644 index 00000000000..f09d3d5f2ed --- /dev/null +++ b/drivers/media/video/msm_vidc/vidc_hfi.c @@ -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 +#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); +} + diff --git a/drivers/media/video/msm_vidc/vidc_hfi.h b/drivers/media/video/msm_vidc/vidc_hfi.h new file mode 100644 index 00000000000..6ff09212c92 --- /dev/null +++ b/drivers/media/video/msm_vidc/vidc_hfi.h @@ -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 + diff --git a/drivers/media/video/msm_vidc/vidc_hfi_api.h b/drivers/media/video/msm_vidc/vidc_hfi_api.h index 79fee90cadf..9366e0a2e14 100644 --- a/drivers/media/video/msm_vidc/vidc_hfi_api.h +++ b/drivers/media/video/msm_vidc/vidc_hfi_api.h @@ -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 #include +#include #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__ */