You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2465 lines
50 KiB
2465 lines
50 KiB
/*
|
|
* Copyright (c) Hisilicon Technologies Co., Ltd. 2017-2021. All rights reserved.
|
|
* Description: demux drv func impl.
|
|
* Author: Hisilicon
|
|
* Create: 2017-05-31
|
|
*/
|
|
|
|
#include "drv_demux_adp.h"
|
|
#include "drv_demux_ext.h"
|
|
|
|
td_s32 ext_drv_dmx_init_rm(td_void)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_init_rm();
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_init_rm failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_init_rm);
|
|
|
|
td_s32 ext_drv_dmx_deinit_rm(td_void)
|
|
{
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_adp_deinit_rm();
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_deinit_rm);
|
|
|
|
td_s32 ext_drv_dmx_init_proc(td_void)
|
|
{
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_adp_init_proc();
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_init_proc);
|
|
|
|
td_s32 ext_drv_dmx_deinit_proc(td_void)
|
|
{
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_adp_deinit_proc();
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_deinit_proc);
|
|
|
|
td_s32 ext_drv_dmx_get_capability(dmx_capability *cap)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(cap, out);
|
|
|
|
ret = dmx_adp_get_capability(cap);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_get_capability failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_get_capability);
|
|
|
|
td_s32 ext_drv_dmx_create_session(struct dmx_session **new_session)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(new_session, out);
|
|
|
|
ret = dmx_adp_create_session(new_session);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_create_session failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_create_session);
|
|
|
|
td_s32 ext_drv_dmx_destroy_session(struct dmx_session *session)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(session, out);
|
|
|
|
ret = dmx_adp_destroy_session(session);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_destroy_session failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_destroy_session);
|
|
|
|
td_s32 ext_drv_dmx_tsi_get_port_attrs(dmx_port port, dmx_port_attr *attrs)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(attrs, out);
|
|
dmx_invalid_port_goto(port, out);
|
|
|
|
ret = dmx_adp_tsi_get_port_attrs(port, attrs);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_tsi_get_port_attrs failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_tsi_get_port_attrs);
|
|
|
|
td_s32 ext_drv_dmx_tsi_set_port_attrs(dmx_port port, const dmx_port_attr *attrs)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(attrs, out);
|
|
dmx_invalid_port_goto(port, out);
|
|
|
|
ret = dmx_adp_tsi_set_port_attrs(port, attrs);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_tsi_set_port_attrs failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_tsi_set_port_attrs);
|
|
|
|
td_s32 ext_drv_dmx_if_get_port_attrs(dmx_port port, dmx_port_attr *attrs)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(attrs, out);
|
|
dmx_invalid_port_goto(port, out);
|
|
|
|
ret = dmx_adp_if_get_port_attrs(port, attrs);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_if_get_port_attrs failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_if_get_port_attrs);
|
|
|
|
td_s32 ext_drv_dmx_if_set_port_attrs(dmx_port port, const dmx_port_attr *attrs)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(attrs, out);
|
|
dmx_invalid_port_goto(port, out);
|
|
|
|
ret = dmx_adp_if_set_port_attrs(port, attrs);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_if_set_port_attrs failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_if_set_port_attrs);
|
|
|
|
td_s32 ext_drv_dmx_tso_get_port_attrs(dmx_port port, dmx_tso_port_attr *attrs)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(attrs, out);
|
|
dmx_invalid_port_goto(port, out);
|
|
|
|
ret = dmx_adp_tso_get_port_attrs(port, attrs);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_tso_get_port_attrs failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_tso_get_port_attrs);
|
|
|
|
td_s32 ext_drv_dmx_tso_set_port_attrs(dmx_port port, const dmx_tso_port_attr *attrs)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(attrs, out);
|
|
dmx_invalid_port_goto(port, out);
|
|
|
|
ret = dmx_adp_tso_set_port_attrs(port, attrs);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_tso_set_port_attrs failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_tso_set_port_attrs);
|
|
|
|
td_s32 ext_drv_dmx_tag_get_port_attrs(dmx_port port, dmx_tag_port_attr *attrs)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(attrs, out);
|
|
dmx_invalid_tag_port_goto(port, out);
|
|
|
|
ret = dmx_adp_tag_get_port_attrs(port, attrs);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_tag_get_port_attrs failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_tag_get_port_attrs);
|
|
|
|
td_s32 ext_drv_dmx_tag_set_port_attrs(dmx_port port, const dmx_tag_port_attr *attrs)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(attrs, out);
|
|
dmx_invalid_tag_port_goto(port, out);
|
|
|
|
ret = dmx_adp_tag_set_port_attrs(port, attrs);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_tag_set_port_attrs failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_tag_set_port_attrs);
|
|
|
|
td_s32 ext_drv_dmx_ram_open_port(dmx_port port, const dmx_ram_port_attr *attrs, td_handle *handle,
|
|
struct dmx_session *session)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(attrs, out);
|
|
dmx_null_pointer_goto(handle, out);
|
|
|
|
ret = dmx_adp_ram_open_port(port, attrs, handle, session);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_ram_open_port failed! port: 0x%x, ret: 0x%x\n", port, ret);
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_ram_open_port);
|
|
|
|
td_s32 ext_drv_dmx_ram_get_port_attrs(td_handle handle, dmx_port_attr *attrs)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(attrs, out);
|
|
|
|
ret = dmx_adp_ram_get_port_attrs(handle, attrs);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_ram_get_port_attrs failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_ram_get_port_attrs);
|
|
|
|
td_s32 ext_drv_dmx_ram_set_port_attrs(td_handle handle, const dmx_port_attr *attrs)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(attrs, out);
|
|
|
|
ret = dmx_adp_ram_set_port_attrs(handle, attrs);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_ram_set_port_attrs failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_ram_set_port_attrs);
|
|
|
|
td_s32 ext_drv_dmx_ram_get_port_status(td_handle handle, dmx_ram_port_status *status)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(status, out);
|
|
|
|
ret = dmx_adp_ram_get_port_status(handle, status);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_ram_get_port_status failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_ram_get_port_status);
|
|
|
|
td_s32 ext_drv_dmx_ram_get_buffer(td_handle handle, td_u32 req_len, dmx_ram_buffer *buf, td_u32 time_out)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(buf, out);
|
|
dmx_fatal_con_goto(req_len == 0, SOC_ERR_DMX_INVALID_PARA, out);
|
|
dmx_correct_time_out(time_out);
|
|
|
|
ret = dmx_adp_ram_get_buffer(handle, req_len, buf, time_out);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_info("dmx_adp_ram_get_buffer failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_ram_get_buffer);
|
|
|
|
td_s32 ext_drv_dmx_ram_push_buffer(td_handle handle, dmx_ram_buffer *buf)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(buf, out);
|
|
|
|
ret = dmx_adp_ram_push_buffer(handle, buf);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_ram_push_buffer failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_ram_push_buffer);
|
|
|
|
td_s32 ext_drv_dmx_ram_put_buffer(td_handle handle, td_u32 valid_datalen, td_u32 start_pos)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_ram_put_buffer(handle, valid_datalen, start_pos);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_ram_put_buffer failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_ram_put_buffer);
|
|
|
|
td_s32 ext_drv_dmx_ram_release_buffer(td_handle handle, dmx_ram_buffer *buf)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(buf, out);
|
|
|
|
ret = dmx_adp_ram_release_buffer(handle, buf);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_ram_release_buffer failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_ram_release_buffer);
|
|
|
|
td_s32 ext_drv_dmx_ram_flush_buffer(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_ram_flush_buffer(handle);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_ram_flush_buffer failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_ram_flush_buffer);
|
|
|
|
td_s32 ext_drv_dmx_ram_reset_buffer(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_ram_reset_buffer(handle);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_ram_reset_buffer failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_ram_reset_buffer);
|
|
|
|
td_s32 ext_drv_dmx_ram_close_port(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_ram_close_port(handle);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_ram_close_port failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_ram_close_port);
|
|
|
|
td_s32 ext_drv_dmx_ram_pre_mmap(td_handle handle, td_s64 *buf_handle, td_u32 *buf_size, td_void **buf_usr_addr)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(buf_handle, out);
|
|
dmx_null_pointer_goto(buf_size, out);
|
|
dmx_null_pointer_goto(buf_usr_addr, out);
|
|
|
|
ret = dmx_adp_ram_pre_mmap(handle, buf_handle, buf_size, buf_usr_addr);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_ram_pre_mmap failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_ram_pre_mmap);
|
|
|
|
td_s32 ext_drv_dmx_ram_pst_mmap(td_handle handle, td_void *buf_usr_addr)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(buf_usr_addr, out);
|
|
|
|
ret = dmx_adp_ram_pst_mmap(handle, buf_usr_addr);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_ram_pst_mmap failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_ram_pst_mmap);
|
|
|
|
td_s32 ext_drv_dmx_ram_get_portid(td_handle handle, dmx_port *port)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(port, out);
|
|
|
|
ret = dmx_adp_ram_get_portid(handle, port);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_ram_get_portid failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_ram_get_portid);
|
|
|
|
td_s32 ext_drv_dmx_ram_get_porthandle(dmx_port port, td_handle *handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(handle, out);
|
|
|
|
ret = dmx_adp_ram_get_porthandle(port, handle);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_ram_get_porthandle failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_ram_get_porthandle);
|
|
|
|
td_s32 ext_drv_dmx_port_get_packet_num(dmx_port port, dmx_port_packet_num *port_stat)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(port_stat, out);
|
|
|
|
if (!((port >= DMX_IF_PORT_0 && port < DMX_IF_PORT_MAX) ||
|
|
(port >= DMX_TSI_PORT_0 && port < DMX_TSI_PORT_MAX) ||
|
|
(port >= DMX_RAM_PORT_0 && port < DMX_ANY_RAM_PORT))) {
|
|
soc_log_err("invalid port(%u).\n", port);
|
|
ret = SOC_ERR_DMX_INVALID_PARA;
|
|
goto out;
|
|
}
|
|
|
|
ret = dmx_adp_port_get_packet_num(port, port_stat);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_port_get_packet_num failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_port_get_packet_num);
|
|
|
|
td_s32 ext_drv_dmx_attach_demod(td_u8 demod_id)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_attach_demod(demod_id);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_attach_demod failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_attach_demod);
|
|
|
|
td_s32 ext_drv_dmx_ram_get_bufhandle(td_handle handle,
|
|
td_mem_handle_t *buf_handle, td_mem_handle_t *dsc_buf_handle, td_mem_handle_t *flush_buf_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_ram_get_bufhandle(handle, buf_handle, dsc_buf_handle, flush_buf_handle);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_ram_get_bufhandle failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_ram_get_bufhandle);
|
|
|
|
td_s32 ext_drv_dmx_rmx_create(const dmx_rmx_attrs *attrs, td_handle *rmx_handle, struct dmx_session *session)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_rmx_create(attrs, rmx_handle, session);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_rmx_create failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rmx_create);
|
|
|
|
td_s32 ext_drv_dmx_rmx_open(td_handle rmx_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_rmx_open(rmx_handle);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_rmx_open failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rmx_open);
|
|
|
|
td_s32 ext_drv_dmx_rmx_get_attrs(td_handle rmx_handle, dmx_rmx_attrs *attrs)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(attrs, out);
|
|
|
|
ret = dmx_adp_rmx_get_attrs(rmx_handle, attrs);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_rmx_get_attrs failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rmx_get_attrs);
|
|
|
|
td_s32 ext_drv_dmx_rmx_set_attrs(td_handle rmx_handle, const dmx_rmx_attrs *attrs)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(attrs, out);
|
|
|
|
ret = dmx_adp_rmx_set_attrs(rmx_handle, attrs);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_rmx_set_attrs failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rmx_set_attrs);
|
|
|
|
td_s32 ext_drv_dmx_rmx_get_status(td_handle rmx_handle, dmx_rmx_status *status)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(status, out);
|
|
|
|
ret = dmx_adp_rmx_get_status(rmx_handle, status);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_rmx_get_status failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rmx_get_status);
|
|
|
|
td_s32 ext_drv_dmx_rmx_add_pump(td_handle rmx_handle, dmx_rmx_pump_attrs *pump_attrs, td_handle *rmx_pump_handle,
|
|
struct dmx_session *session)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_rmx_add_pump(rmx_handle, pump_attrs, rmx_pump_handle, session);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_rmx_add_pump failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rmx_add_pump);
|
|
|
|
td_s32 ext_drv_dmx_rmx_del_pump(td_handle rmx_pump_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_rmx_del_pump(rmx_pump_handle);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_rmx_del_pump failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rmx_del_pump);
|
|
|
|
td_s32 ext_drv_dmx_rmx_del_all_pump(td_handle rmx_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_rmx_del_all_pump(rmx_handle);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_rmx_del_all_pump failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rmx_del_all_pump);
|
|
|
|
td_s32 ext_drv_dmx_rmx_get_pump_attrs(td_handle rmx_pump_handle, dmx_rmx_pump_attrs *pump_attrs)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(pump_attrs, out);
|
|
|
|
ret = dmx_adp_rmx_get_pump_attrs(rmx_pump_handle, pump_attrs);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_rmx_get_pump_attrs failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rmx_get_pump_attrs);
|
|
|
|
td_s32 ext_drv_dmx_rmx_set_pump_attrs(td_handle rmx_pump_handle, const dmx_rmx_pump_attrs *pump_attrs)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_rmx_set_pump_attrs(rmx_pump_handle, pump_attrs);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_rmx_set_pump_attrs failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rmx_set_pump_attrs);
|
|
|
|
td_s32 ext_drv_dmx_rmx_close(td_handle rmx_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_rmx_close(rmx_handle);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_rmx_close failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rmx_close);
|
|
|
|
td_s32 ext_drv_dmx_rmx_destroy(td_handle rmx_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_rmx_destroy(rmx_handle);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("ext_drv_dmx_rmx_destroy failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rmx_destroy);
|
|
|
|
td_s32 ext_drv_dmx_band_open(dmx_band band, const dmx_band_attr *attrs, td_handle *handle, struct dmx_session *session)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(handle, out);
|
|
|
|
ret = dmx_adp_band_open(band, attrs, handle, session);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_band_open failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_band_open);
|
|
|
|
td_s32 ext_drv_dmx_band_ref_inc(dmx_band band, const dmx_band_attr *attrs, td_handle *handle,
|
|
struct dmx_session *session)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_band_ref_inc(band, attrs, handle, session);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_band_ref_inc failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_band_ref_inc);
|
|
|
|
td_s32 ext_drv_dmx_band_attach_port(td_handle handle, dmx_port port)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_fatal_con_goto(port >= DMX_TSO_PORT_MAX, SOC_ERR_DMX_INVALID_PARA, out);
|
|
|
|
ret = dmx_adp_band_attach_port(handle, port);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_band_attach_port failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_band_attach_port);
|
|
|
|
td_s32 ext_drv_dmx_band_detach_port(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_band_detach_port(handle);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_band_detach_port failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_band_detach_port);
|
|
|
|
td_s32 ext_drv_dmx_band_get_attrs(td_handle handle, dmx_band_attr *attrs)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_band_get_attrs(handle, attrs);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_band_get_attrs failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_band_get_attrs);
|
|
|
|
td_s32 ext_drv_dmx_band_set_attrs(td_handle handle, const dmx_band_attr *attrs)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_band_set_attrs(handle, attrs);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_band_set_attrs failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_band_set_attrs);
|
|
|
|
td_s32 ext_drv_dmx_band_get_status(td_handle handle, dmx_band_status *status)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_band_get_status(handle, status);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_band_get_status failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_band_get_status);
|
|
|
|
td_s32 ext_drv_dmx_band_close(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_band_close(handle);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_band_close failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_band_close);
|
|
|
|
td_s32 ext_drv_dmx_band_ref_dec(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_band_ref_dec(handle);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_band_ref_dec failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_band_ref_dec);
|
|
|
|
td_s32 ext_drv_dmx_band_tei_set(td_handle handle, td_bool tei)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_band_tei_set(handle, tei);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_band_tei_set failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_band_tei_set);
|
|
|
|
td_s32 ext_drv_dmx_pid_ch_create(td_handle band_handle, td_u32 pid, td_handle *handle, struct dmx_session *session)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(handle, out);
|
|
dmx_fatal_con_goto(pid > DMX_MAX_PID, SOC_ERR_DMX_INVALID_PARA, out);
|
|
|
|
ret = dmx_adp_pid_ch_create(band_handle, pid, handle, session);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_pid_ch_create failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_pid_ch_create);
|
|
|
|
td_s32 ext_drv_dmx_pid_ch_ref_inc(td_handle band_handle, td_u32 pid, td_handle *handle, struct dmx_session *session)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_pid_ch_ref_inc(band_handle, pid, handle, session);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_pid_ch_ref_inc failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_pid_ch_ref_inc);
|
|
|
|
td_s32 ext_drv_dmx_pid_ch_get_handle(td_handle band_handle, td_u32 pid, td_handle *handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_pid_ch_get_handle(band_handle, pid, handle);
|
|
if (ret != TD_SUCCESS) {
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_pid_ch_get_handle);
|
|
|
|
td_s32 ext_drv_dmx_pid_ch_get_status(td_handle handle, dmx_pidch_status *status)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_pid_ch_get_status(handle, status);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_pid_ch_get_status failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_pid_ch_get_status);
|
|
|
|
td_s32 ext_drv_dmx_pid_ch_lock_out(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_pid_ch_lock_out(handle);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_pid_ch_lock_out failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_pid_ch_lock_out);
|
|
|
|
td_s32 ext_drv_dmx_pid_ch_un_lock_out(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_pid_ch_un_lock_out(handle);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_pid_ch_un_lock_out failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_pid_ch_un_lock_out);
|
|
|
|
td_s32 ext_drv_dmx_pid_ch_destroy(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_pid_ch_destroy(handle);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_pid_ch_destroy failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_pid_ch_destroy);
|
|
|
|
td_s32 ext_drv_dmx_pid_ch_ref_dec(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_pid_ch_ref_dec(handle);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_pid_ch_ref_dec failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_pid_ch_ref_dec);
|
|
|
|
td_s32 ext_drv_dmx_pid_ch_get_free_cnt(td_u32 *free_cnt)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_pid_ch_get_free_cnt(free_cnt);
|
|
if (ret != TD_SUCCESS) {
|
|
soc_log_err("dmx_adp_pid_ch_get_free_cnt failed!\n");
|
|
goto out;
|
|
}
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_pid_ch_get_free_cnt);
|
|
|
|
|
|
/* play_fct begin */
|
|
td_s32 ext_drv_dmx_play_create(const dmx_play_attrs *attrs, td_handle *handle, struct dmx_session *session)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(attrs, out);
|
|
dmx_null_pointer_goto(handle, out);
|
|
|
|
ret = dmx_adp_play_create(attrs, handle, session);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_create);
|
|
|
|
td_s32 ext_drv_dmx_play_open(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_play_open(handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_open);
|
|
|
|
td_s32 ext_drv_dmx_play_get_attrs(td_handle handle, dmx_play_attrs *attrs)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(attrs, out);
|
|
|
|
ret = dmx_adp_play_get_attrs(handle, attrs);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_get_attrs);
|
|
|
|
td_s32 ext_drv_dmx_play_set_attrs(td_handle handle, const dmx_play_attrs *attrs)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(attrs, out);
|
|
|
|
ret = dmx_adp_play_set_attrs(handle, attrs);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_set_attrs);
|
|
|
|
td_s32 ext_drv_dmx_play_get_status(td_handle handle, dmx_play_status *status)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(status, out);
|
|
|
|
ret = dmx_adp_play_get_status(handle, status);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_get_status);
|
|
|
|
td_s32 ext_drv_dmx_play_get_scrambled_flag(td_handle handle, ext_dmx_scrambled_flag *scramble_flag)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(scramble_flag, out);
|
|
|
|
ret = dmx_adp_play_get_scrambled_flag(handle, scramble_flag);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_get_scrambled_flag);
|
|
|
|
td_s32 ext_drv_dmx_play_get_packet_num(td_handle handle, dmx_chan_packet_num *chn_stat)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(chn_stat, out);
|
|
|
|
ret = dmx_adp_play_get_packet_num(handle, chn_stat);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_get_packet_num);
|
|
|
|
td_s32 ext_drv_dmx_play_get_pid_ch(td_handle handle, td_handle *pid_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(pid_handle, out);
|
|
|
|
ret = dmx_adp_play_get_pid_ch(handle, pid_handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_get_pid_ch);
|
|
|
|
td_s32 ext_drv_dmx_play_attach_pid_ch(td_handle handle, td_handle pid_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_play_attach_pid_ch(handle, pid_handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_attach_pid_ch);
|
|
|
|
td_s32 ext_drv_dmx_play_detach_pid_ch(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_play_detach_pid_ch(handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_detach_pid_ch);
|
|
|
|
td_s32 ext_drv_dmx_play_create_filter(const dmx_filter_attrs *attrs, td_handle *flt_handle, struct dmx_session *session)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(attrs, out);
|
|
dmx_null_pointer_goto(flt_handle, out);
|
|
|
|
ret = dmx_adp_play_create_filter(attrs, flt_handle, session);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_create_filter);
|
|
|
|
|
|
td_s32 ext_drv_dmx_play_add_filter(td_handle handle, td_handle flt_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_play_add_filter(handle, flt_handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_add_filter);
|
|
|
|
td_s32 ext_drv_dmx_play_del_filter(td_handle handle, td_handle flt_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_play_del_filter(handle, flt_handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_del_filter);
|
|
|
|
td_s32 ext_drv_dmx_play_del_all_filter(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_play_del_all_filter(handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_del_all_filter);
|
|
|
|
td_s32 ext_drv_dmx_play_update_filter(td_handle flt_handle, const dmx_filter_attrs *attrs)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(attrs, out);
|
|
|
|
ret = dmx_adp_play_update_filter(flt_handle, attrs);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_update_filter);
|
|
|
|
td_s32 ext_drv_dmx_play_get_filter(td_handle flt_handle, dmx_filter_attrs *attrs)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(attrs, out);
|
|
|
|
ret = dmx_adp_play_get_filter(flt_handle, attrs);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_get_filter);
|
|
|
|
td_s32 ext_drv_dmx_play_get_handle_by_filter(td_handle flt_handle, td_handle *play_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(play_handle, out);
|
|
|
|
ret = dmx_adp_play_get_handle_by_filter(flt_handle, play_handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_get_handle_by_filter);
|
|
|
|
td_s32 ext_drv_dmx_play_get_free_filter_cnt(td_u32 *free_flt_cnt)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(free_flt_cnt, out);
|
|
|
|
ret = dmx_adp_play_get_free_filter_cnt(free_flt_cnt);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_get_free_filter_cnt);
|
|
|
|
td_s32 ext_drv_dmx_play_destroy_filter(td_handle flt_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_play_destroy_filter(flt_handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_destroy_filter);
|
|
|
|
td_s32 ext_drv_dmx_play_acquire_buf(td_handle handle, td_u32 acq_num, td_u32 time_out, td_u32 *acqed_num,
|
|
dmx_buffer *play_fct_buf)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(acqed_num, out);
|
|
dmx_null_pointer_goto(play_fct_buf, out);
|
|
dmx_correct_time_out(time_out);
|
|
|
|
ret = dmx_adp_play_acquire_buf(handle, acq_num, time_out, acqed_num, play_fct_buf);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_acquire_buf);
|
|
|
|
td_s32 ext_drv_dmx_play_peek_buf(td_handle handle, td_u32 peek_num, td_u32 time_out, td_u32 *peeked_num,
|
|
dmx_buffer *play_fct_buf)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
dmx_null_pointer_goto(peeked_num, out);
|
|
dmx_null_pointer_goto(play_fct_buf, out);
|
|
dmx_correct_time_out(time_out);
|
|
|
|
ret = dmx_adp_play_peek_buf(handle, peek_num, time_out, peeked_num, play_fct_buf);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_peek_buf);
|
|
|
|
td_s32 ext_drv_dmx_play_release_buf(td_handle handle, td_u32 rel_num, dmx_buffer *play_fct_buf)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(play_fct_buf, out);
|
|
|
|
ret = dmx_adp_play_release_buf(handle, rel_num, play_fct_buf);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_release_buf);
|
|
|
|
td_s32 ext_drv_dmx_play_reset_buf(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_play_reset_buf(handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_reset_buf);
|
|
|
|
td_s32 ext_drv_dmx_play_start_idx(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_play_start_idx(handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_start_idx);
|
|
|
|
td_s32 ext_drv_dmx_play_recv_idx(td_handle handle, td_u32 req_num, td_u32 time_out, td_u32 *reqed_num,
|
|
dmx_index_data *index)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(reqed_num, out);
|
|
dmx_null_pointer_goto(index, out);
|
|
dmx_correct_time_out(time_out);
|
|
|
|
ret = dmx_adp_play_recv_idx(handle, req_num, time_out, reqed_num, index);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_recv_idx);
|
|
|
|
td_s32 ext_drv_dmx_play_stop_idx(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_play_stop_idx(handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_stop_idx);
|
|
|
|
td_s32 ext_drv_dmx_play_close(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_play_close(handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_close);
|
|
|
|
td_s32 ext_drv_dmx_play_destroy(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_play_destroy(handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_destroy);
|
|
|
|
td_s32 ext_drv_dmx_play_pre_mmap(td_handle handle, td_s64 *buf_handle, td_u32 *buf_size, td_void **buf_usr_addr)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(buf_handle, out);
|
|
dmx_null_pointer_goto(buf_size, out);
|
|
dmx_null_pointer_goto(buf_usr_addr, out);
|
|
|
|
ret = dmx_adp_play_pre_mmap(handle, buf_handle, buf_size, buf_usr_addr);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_pre_mmap);
|
|
|
|
td_s32 ext_drv_dmx_play_pst_mmap(td_handle handle, td_void *buf_usr_addr)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(buf_usr_addr, out);
|
|
|
|
ret = dmx_adp_play_pst_mmap(handle, buf_usr_addr);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_pst_mmap);
|
|
|
|
td_s32 ext_drv_dmx_play_get_data_handle(td_handle *valid_array, td_u32 *valid_num, td_u32 watch_num,
|
|
td_u32 time_out_ms)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(valid_array, out);
|
|
dmx_null_pointer_goto(valid_num, out);
|
|
dmx_correct_time_out(time_out_ms);
|
|
|
|
ret = dmx_adp_play_get_data_handle(valid_array, valid_num, watch_num, time_out_ms);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_get_data_handle);
|
|
|
|
td_s32 ext_drv_dmx_play_select_data_handle(td_handle *watch_array, td_u32 watch_num, td_handle *valid_array,
|
|
td_u32 *valid_num, td_u32 time_out_ms)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(valid_array, out);
|
|
dmx_null_pointer_goto(valid_num, out);
|
|
dmx_null_pointer_goto(watch_array, out);
|
|
dmx_correct_time_out(time_out_ms);
|
|
|
|
ret = dmx_adp_play_select_data_handle(watch_array, watch_num, valid_array, valid_num, time_out_ms);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_select_data_handle);
|
|
|
|
td_s32 ext_drv_dmx_play_set_eos_flag(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_play_set_eos_flag(handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_set_eos_flag);
|
|
|
|
td_s32 ext_drv_dmx_play_get_bufhandle(td_handle handle, td_handle *buf_handle, dmx_play_type *type)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(buf_handle, out);
|
|
dmx_null_pointer_goto(type, out);
|
|
|
|
ret = dmx_adp_play_get_bufhandle(handle, buf_handle, type);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_get_bufhandle);
|
|
|
|
td_s32 ext_drv_dmx_play_cc_repeat_set(td_handle handle, dmx_chan_cc_repeat_mode mode)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_play_cc_repeat_set(handle, mode);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_cc_repeat_set);
|
|
|
|
td_s32 ext_drv_dmx_play_pusi_set(td_bool no_pusi)
|
|
{
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_adp_play_pusi_set(no_pusi);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_play_pusi_set);
|
|
|
|
/* rec_fct begin */
|
|
td_s32 ext_drv_dmx_rec_create(const dmx_rec_attrs *attrs, td_handle *handle, struct dmx_session *session)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(attrs, out);
|
|
dmx_null_pointer_goto(handle, out);
|
|
|
|
ret = dmx_adp_rec_create(attrs, handle, session);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rec_create);
|
|
|
|
td_s32 ext_drv_dmx_rec_open(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_rec_open(handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rec_open);
|
|
|
|
td_s32 ext_drv_dmx_rec_get_attrs(td_handle handle, dmx_rec_attrs *attrs)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(attrs, out);
|
|
|
|
ret = dmx_adp_rec_get_attrs(handle, attrs);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rec_get_attrs);
|
|
|
|
td_s32 ext_drv_dmx_rec_set_attrs(td_handle handle, const dmx_rec_attrs *attrs)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(attrs, out);
|
|
|
|
ret = dmx_adp_rec_set_attrs(handle, attrs);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rec_set_attrs);
|
|
|
|
td_s32 ext_drv_dmx_rec_set_eos_flag(td_handle handle, td_bool eos_flag)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_rec_set_eos_flag(handle, eos_flag);
|
|
|
|
dmx_glb_trace_exit();
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rec_set_eos_flag);
|
|
|
|
td_s32 ext_drv_dmx_rec_get_status(td_handle handle, dmx_rec_status *status)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(status, out);
|
|
|
|
ret = dmx_adp_rec_get_status(handle, status);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rec_get_status);
|
|
|
|
td_s32 ext_drv_dmx_rec_add_ch(td_handle handle, td_handle ch_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_rec_add_ch(handle, ch_handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rec_add_ch);
|
|
|
|
td_s32 ext_drv_dmx_rec_del_ch(td_handle handle, td_handle ch_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_rec_del_ch(handle, ch_handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rec_del_ch);
|
|
|
|
td_s32 ext_drv_dmx_rec_del_all_ch(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_rec_del_all_ch(handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rec_del_all_ch);
|
|
|
|
td_s32 ext_drv_dmx_rec_acquire_buf(td_handle handle, td_u32 req_len, td_u32 time_out, dmx_buffer *rec_fct_buf)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(rec_fct_buf, out);
|
|
dmx_correct_time_out(time_out);
|
|
|
|
ret = dmx_adp_rec_acquire_buf(handle, req_len, time_out, rec_fct_buf);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rec_acquire_buf);
|
|
|
|
td_s32 ext_drv_dmx_rec_release_buf(td_handle handle, dmx_buffer *rec_fct_buf)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(rec_fct_buf, out);
|
|
|
|
ret = dmx_adp_rec_release_buf(handle, rec_fct_buf);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rec_release_buf);
|
|
|
|
td_s32 ext_drv_dmx_rec_recv_idx(td_handle handle, td_u32 req_num, td_u32 time_out, td_u32 *reqed_num,
|
|
dmx_index_data *index)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(reqed_num, out);
|
|
dmx_null_pointer_goto(index, out);
|
|
dmx_correct_time_out(time_out);
|
|
|
|
ret = dmx_adp_rec_recv_idx(handle, req_num, time_out, reqed_num, index);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rec_recv_idx);
|
|
|
|
td_s32 ext_drv_dmx_rec_peek_idx_and_buf(td_handle handle, td_u32 time_out, td_u32 *index_num, td_u32 *rec_data_len)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(index_num, out);
|
|
dmx_null_pointer_goto(rec_data_len, out);
|
|
dmx_correct_time_out(time_out);
|
|
|
|
ret = dmx_adp_rec_peek_idx_and_buf(handle, time_out, index_num, rec_data_len);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rec_peek_idx_and_buf);
|
|
|
|
td_s32 ext_drv_dmx_rec_close(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_rec_close(handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rec_close);
|
|
|
|
td_s32 ext_drv_dmx_rec_destroy(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_rec_destroy(handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rec_destroy);
|
|
|
|
td_s32 ext_drv_dmx_rec_pre_mmap(td_handle handle, td_s64 *buf_handle, td_u32 *buf_size, td_void **buf_user_addr)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(buf_handle, out);
|
|
dmx_null_pointer_goto(buf_size, out);
|
|
dmx_null_pointer_goto(buf_user_addr, out);
|
|
|
|
ret = dmx_adp_rec_pre_mmap(handle, buf_handle, buf_size, buf_user_addr);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rec_pre_mmap);
|
|
|
|
td_s32 ext_drv_dmx_rec_pst_mmap(td_handle handle, td_void *buf_usr_addr)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(buf_usr_addr, out);
|
|
|
|
ret = dmx_adp_rec_pst_mmap(handle, buf_usr_addr);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rec_pst_mmap);
|
|
|
|
td_s32 ext_drv_dmx_rec_get_bufhandle(td_handle handle, td_handle *buf_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(buf_handle, out);
|
|
|
|
ret = dmx_adp_rec_get_bufhandle(handle, buf_handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_rec_get_bufhandle);
|
|
|
|
/*********dsc_fct begin************/
|
|
td_s32 ext_drv_dmx_dsc_create(const dmx_dsc_attrs *attrs, td_handle *handle, struct dmx_session *session)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(attrs, out);
|
|
dmx_null_pointer_goto(handle, out);
|
|
dmx_null_pointer_goto(session, out);
|
|
|
|
ret = dmx_adp_dsc_create(attrs, handle, session);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_dsc_create);
|
|
|
|
td_s32 ext_drv_dmx_dsc_get_attrs(td_handle handle, dmx_dsc_attrs *attrs)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
dmx_null_pointer_goto(attrs, out);
|
|
|
|
ret = dmx_adp_dsc_get_attrs(handle, attrs);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_dsc_get_attrs);
|
|
|
|
td_s32 ext_drv_dmx_dsc_set_attrs(td_handle handle, const dmx_dsc_attrs *attrs)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_dsc_set_attrs(handle, attrs);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_dsc_set_attrs);
|
|
|
|
td_s32 ext_drv_dmx_dsc_attach(td_handle handle, td_handle ch_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_dsc_attach(handle, ch_handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_dsc_attach);
|
|
|
|
td_s32 ext_drv_dmx_dsc_detach(td_handle handle, td_handle ch_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_dsc_detach(handle, ch_handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_dsc_detach);
|
|
|
|
td_s32 ext_drv_dmx_dsc_attach_keyslot(td_handle handle, td_handle ks_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_dsc_attach_keyslot(handle, ks_handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_dsc_attach_keyslot);
|
|
|
|
td_s32 ext_drv_dmx_dsc_detach_keyslot(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_dsc_detach_keyslot(handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_dsc_detach_keyslot);
|
|
|
|
td_s32 ext_drv_dmx_dsc_get_keyslot_handle(td_handle handle, td_handle *ks_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_dsc_get_keyslot_handle(handle, ks_handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_dsc_get_keyslot_handle);
|
|
|
|
td_s32 ext_drv_dmx_dsc_set_even_key(td_handle handle, const td_u8 *key, td_u32 len)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_dsc_set_even_key(handle, key, len);
|
|
|
|
dmx_glb_trace_exit();
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_dsc_set_even_key);
|
|
|
|
td_s32 ext_drv_dmx_dsc_set_odd_key(td_handle handle, const td_u8 *key, td_u32 len)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_dsc_set_odd_key(handle, key, len);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_dsc_set_odd_key);
|
|
|
|
td_s32 ext_drv_dmx_dsc_set_sys_key(td_handle handle, const td_u8 *key, td_u32 len)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_dsc_set_sys_key(handle, key, len);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_dsc_set_sys_key);
|
|
|
|
td_s32 ext_drv_dmx_dsc_set_even_iv(td_handle handle, const td_u8 *iv, td_u32 len)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_dsc_set_even_iv(handle, iv, len);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_dsc_set_even_iv);
|
|
|
|
td_s32 ext_drv_dmx_dsc_set_odd_iv(td_handle handle, const td_u8 *iv, td_u32 len)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_dsc_set_odd_iv(handle, iv, len);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_dsc_set_odd_iv);
|
|
|
|
td_s32 ext_drv_dmx_dsc_destroy(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_dsc_destroy(handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_dsc_destroy);
|
|
|
|
td_s32 ext_drv_dmx_dsc_get_dsc_key_handle(td_handle pid_ch_handle, td_handle *dsc_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_dsc_get_dsc_key_handle(pid_ch_handle, dsc_handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_dsc_get_dsc_key_handle);
|
|
|
|
td_s32 ext_drv_dmx_dsc_get_free_cnt(td_u32 *free_cnt)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_dsc_get_free_cnt(free_cnt);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_dsc_get_free_cnt);
|
|
|
|
/*********pcr_fct begin************/
|
|
td_s32 ext_drv_dmx_pcr_create(td_handle band_handle, td_u32 pid, td_handle *handle, struct dmx_session *session)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_pcr_create(band_handle, pid, handle, session);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_pcr_create);
|
|
|
|
td_s32 ext_drv_dmx_pcr_attach(td_handle handle, td_handle sync_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_pcr_attach(handle, sync_handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_pcr_attach);
|
|
|
|
td_s32 ext_drv_dmx_pcr_detach(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_pcr_detach(handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_pcr_detach);
|
|
|
|
td_s32 ext_drv_dmx_pcr_get_status(td_handle handle, dmx_pcr_status *status)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_pcr_get_status(handle, status);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_pcr_get_status);
|
|
|
|
td_s32 ext_drv_dmx_pcr_get_pcr_scr(td_handle handle, td_u64 *pcr_ms, td_u64 *scr_ms)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_pcr_get_pcr_scr(handle, pcr_ms, scr_ms);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_pcr_get_pcr_scr);
|
|
|
|
td_s32 ext_drv_dmx_pcr_destroy(td_handle handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_pcr_destroy(handle);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_pcr_destroy);
|
|
|
|
/* callback begin */
|
|
td_s32 ext_drv_dmx_set_callback(td_handle handle, td_handle user_handle, drv_dmx_callback cb)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_set_callback(handle, user_handle, cb);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_set_callback);
|
|
|
|
td_s32 ext_drv_dmx_set_play_index_callback(td_handle handle, td_handle user_handle,
|
|
drv_dmx_play_index_callback cb)
|
|
{
|
|
td_s32 ret;
|
|
|
|
dmx_glb_trace_enter();
|
|
|
|
ret = dmx_adp_set_play_index_callback(handle, user_handle, cb);
|
|
|
|
dmx_glb_trace_exit();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_set_play_index_callback);
|
|
|
|
td_s32 ext_drv_dmx_suspend(td_void)
|
|
{
|
|
return dmx_adp_suspend();
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_suspend);
|
|
|
|
td_s32 ext_drv_dmx_resume(td_void)
|
|
{
|
|
return dmx_adp_resume();
|
|
}
|
|
EXPORT_SYMBOL(ext_drv_dmx_resume);
|