/*
 * 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);