gpon_onu_drv/src/drv_onu_cli_dump.c

/* attention, this file was automatically generated by swig and Perl scripts */
#include "drv_onu_std_defs.h"
#include "drv_onu_error.h"
#include "drv_onu_interface.h"
#include "drv_onu_api.h"
#include "drv_onu_common_interface.h"
#include "drv_onu_ploam_interface.h"
#include "drv_onu_ploam_api.h"
#include "drv_onu_gtc_interface.h"
#include "drv_onu_gtc_api.h"
#include "drv_onu_gpe_interface.h"
#include "drv_onu_gpe_api.h"
#include "drv_onu_gpe_tables_interface.h"
#include "drv_onu_gpe_tables_api.h"
#include "drv_onu_lan_interface.h"
#include "drv_onu_lan_api.h"
#include "drv_onu_event_interface.h"
#include "drv_onu_event_api.h"

#ifdef INCLUDE_CLI_DUMP_SUPPORT

/** \addtogroup ONU_CLI_DUMP_COMMANDS
   @{
*/

int dump_gtc_init(char *p_out, const void *p_data_in)
{
	struct gtc_init_data *param;

	param = (struct gtc_init_data *)p_data_in;
	return sprintf(p_out, "gtc_init %u %u %u %u %u %u %u %u" ONU_CRLF, param->dlos.dlos_enable, param->dlos.dlos_inversion, param->dlos.dlos_window_size, param->dlos.dlos_trigger_threshold, param->laser_gap, param->laser_offset, param->laser_en_end_ext, param->laser_en_start_ext);
}

int dump_gtc_cfg_set(char *p_out, const void *p_data_in)
{
	struct gtc_cfg *param;

	param = (struct gtc_cfg *)p_data_in;
	return sprintf(p_out, "gtc_cfg_set %u %u %u %u %u %u %u %u %u %u %u \"%u %u %u %u %u %u %u %u %u %u\"" ONU_CRLF, param->bip_error_interval, param->sf_threshold, param->sd_threshold, param->onu_response_time, param->serial_number_request_threshold, param->rogue_msg_id, param->rogue_msg_rpt, param->rogue_msg_enable, param->ploam_timeout_1, param->ploam_timeout_2, param->emergency_stop_state, param->password[0], param->password[1], param->password[2], param->password[3], param->password[4], param->password[5], param->password[6], param->password[7], param->password[8], param->password[9]);
}

int dump_gtc_cfg_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gtc_cfg_get" ONU_CRLF);
}

int dump_gtc_counter_threshold_set(char *p_out, const void *p_data_in)
{
	struct gtc_cnt_value *param;

	param = (struct gtc_cnt_value *)p_data_in;
	return sprintf(p_out, "gtc_counter_threshold_set %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu" ONU_CRLF, param->bip, param->hec_error_corr, param->hec_error_uncorr, param->bwmap_error_corr, param->bwmap_error_uncorr, param->fec_error_corr, param->fec_words_corr, param->fec_words_uncorr, param->fec_words_total, param->tx_gem_frames_total, param->tx_gem_bytes_total, param->tx_gem_idle_frames_total, param->rx_gem_frames_total, param->rx_gem_bytes_total, param->rx_gem_frames_dropped, param->omci_drop, param->drop, param->rx_oversized_frames, param->allocations_total, param->allocations_lost);
}

int dump_gtc_counter_threshold_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gtc_counter_threshold_get" ONU_CRLF);
}

int dump_gtc_tca_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gtc_tca_get" ONU_CRLF);
}

int dump_gtc_us_header_cfg_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gtc_us_header_cfg_get" ONU_CRLF);
}

int dump_gtc_counter_get(char *p_out, const void *p_data_in)
{
	struct gtc_cnt_interval *in;

	in = (struct gtc_cnt_interval *)p_data_in;
	return sprintf(p_out, "gtc_counter_get %u %u" ONU_CRLF, in->reset_mask, in->curr);
}

int dump_gtc_counter_reset(char *p_out, const void *p_data_in)
{
	struct gtc_cnt_interval *param;

	param = (struct gtc_cnt_interval *)p_data_in;
	return sprintf(p_out, "gtc_counter_reset %u %u" ONU_CRLF, param->reset_mask, param->curr);
}

int dump_gtc_status_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gtc_status_get" ONU_CRLF);
}

int dump_gtc_alarm_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gtc_alarm_get" ONU_CRLF);
}

int dump_gtc_ranging_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gtc_ranging_get" ONU_CRLF);
}

int dump_gtc_dying_gasp_cfg_set(char *p_out, const void *p_data_in)
{
	struct gtc_dgasp_msg *param;

	param = (struct gtc_dgasp_msg *)p_data_in;
	return sprintf(p_out, "gtc_dying_gasp_cfg_set \"%u %u %u %u %u %u %u %u %u %u %u %u\" %u" ONU_CRLF, param->dying_gasp_msg[0], param->dying_gasp_msg[1], param->dying_gasp_msg[2], param->dying_gasp_msg[3], param->dying_gasp_msg[4], param->dying_gasp_msg[5], param->dying_gasp_msg[6], param->dying_gasp_msg[7], param->dying_gasp_msg[8], param->dying_gasp_msg[9], param->dying_gasp_msg[10], param->dying_gasp_msg[11], param->dying_gasp_auto);
}

int dump_gtc_dying_gasp_cfg_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gtc_dying_gasp_cfg_get" ONU_CRLF);
}

int dump_gtc_no_message_cfg_set(char *p_out, const void *p_data_in)
{
	struct gtc_no_msg_msg *param;

	param = (struct gtc_no_msg_msg *)p_data_in;
	return sprintf(p_out, "gtc_no_message_cfg_set %u \"%u %u %u %u %u %u %u %u %u %u %u %u\"" ONU_CRLF, param->no_msg_is_scrambled, param->no_msg[0], param->no_msg[1], param->no_msg[2], param->no_msg[3], param->no_msg[4], param->no_msg[5], param->no_msg[6], param->no_msg[7], param->no_msg[8], param->no_msg[9], param->no_msg[10], param->no_msg[11]);
}

int dump_gtc_no_message_cfg_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gtc_no_message_cfg_get" ONU_CRLF);
}

int dump_gtc_power_saving_mode_set(char *p_out, const void *p_data_in)
{
	struct gtc_op_mode *param;

	param = (struct gtc_op_mode *)p_data_in;
	return sprintf(p_out, "gtc_power_saving_mode_set %u" ONU_CRLF, param->gpon_op_mode);
}

int dump_gtc_power_saving_mode_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gtc_power_saving_mode_get" ONU_CRLF);
}

int dump_gtc_ploam_send(char *p_out, const void *p_data_in)
{
	struct gtc_ploamu *param;

	param = (struct gtc_ploamu *)p_data_in;
	return sprintf(p_out, "gtc_ploam_send %u %u \"%u %u %u %u %u %u %u %u %u %u\" %u" ONU_CRLF, param->onu_id, param->msg_id, param->data[0], param->data[1], param->data[2], param->data[3], param->data[4], param->data[5], param->data[6], param->data[7], param->data[8], param->data[9], param->repeat);
}

int dump_gtc_ploam_receive(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gtc_ploam_receive" ONU_CRLF);
}

int dump_gtc_serial_number_set(char *p_out, const void *p_data_in)
{
	struct gtc_serial_num *param;

	param = (struct gtc_serial_num *)p_data_in;
	return sprintf(p_out, "gtc_serial_number_set \"%u %u %u %u %u %u %u %u\"" ONU_CRLF, param->serial_number[0], param->serial_number[1], param->serial_number[2], param->serial_number[3], param->serial_number[4], param->serial_number[5], param->serial_number[6], param->serial_number[7]);
}

int dump_gtc_serial_number_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gtc_serial_number_get" ONU_CRLF);
}

int dump_gtc_password_set(char *p_out, const void *p_data_in)
{
	struct gtc_password *param;

	param = (struct gtc_password *)p_data_in;
	return sprintf(p_out, "gtc_password_set \"%u %u %u %u %u %u %u %u %u %u\"" ONU_CRLF, param->password[0], param->password[1], param->password[2], param->password[3], param->password[4], param->password[5], param->password[6], param->password[7], param->password[8], param->password[9]);
}

int dump_gtc_password_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gtc_password_get" ONU_CRLF);
}

int dump_gtc_forced_alloc_set(char *p_out, const void *p_data_in)
{
	struct gtc_forced_alloc *param;

	param = (struct gtc_forced_alloc *)p_data_in;
	return sprintf(p_out, "gtc_forced_alloc_set %u %u %u %u %u" ONU_CRLF, param->enable, param->start_time, param->stop_time, param->alloc_id, param->flags);
}

int dump_gtc_forced_alloc_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gtc_forced_alloc_get" ONU_CRLF);
}

int dump_gtc_bwmt_cfg_set(char *p_out, const void *p_data_in)
{
	struct gtc_bwmt_cfg *param;

	param = (struct gtc_bwmt_cfg *)p_data_in;
	return sprintf(p_out, "gtc_bwmt_cfg_set %u %u %u %u %u %u %u %u %u %u %u" ONU_CRLF, param->trace_enable, param->overhead_size_enable, param->data_size_enable, param->parity_size_enable, param->start_time_enable, param->stop_time_enable, param->start_stop_enable, param->plou_enable, param->overlap_enable, param->no_gem_enable, param->sw_trigger);
}

int dump_gtc_bwmt_cfg_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gtc_bwmt_cfg_get" ONU_CRLF);
}

int dump_gtc_bwmt_next(char *p_out, const void *p_data_in)
{
	struct gtc_bwmt_next_data *param;

	param = (struct gtc_bwmt_next_data *)p_data_in;
	return sprintf(p_out, "gtc_bwmt_next %u" ONU_CRLF, param->trace_start);
}

int dump_gtc_bwmt_status_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gtc_bwmt_status_get" ONU_CRLF);
}

int dump_gtc_last_change_time_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gtc_last_change_time_get" ONU_CRLF);
}

int dump_gtc_pon_id_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gtc_pon_id_get" ONU_CRLF);
}

int dump_gpe_init(char *p_out, const void *p_data_in)
{
	struct gpe_init_data *param;

	param = (struct gpe_init_data *)p_data_in;
	return sprintf(p_out, "gpe_init \"%s\" %u %u %u \"%u %u %u %u\" \"%u %u %u %u\" %u %u %u %u" ONU_CRLF, param->fw_name, param->ll_mod_sel.fsqm, param->ll_mod_sel.iqm, param->ll_mod_sel.tmu, param->ll_mod_sel.ictrll[0], param->ll_mod_sel.ictrll[1], param->ll_mod_sel.ictrll[2], param->ll_mod_sel.ictrll[3], param->ll_mod_sel.octrll[0], param->ll_mod_sel.octrll[1], param->ll_mod_sel.octrll[2], param->ll_mod_sel.octrll[3], param->ll_mod_sel.ictrlg, param->ll_mod_sel.octrlg, param->arb_mode, param->num_pe);
}

int dump_gpe_debug_init(char *p_out, const void *p_data_in)
{
	struct gpe_init_data *param;

	param = (struct gpe_init_data *)p_data_in;
	return sprintf(p_out, "gpe_debug_init \"%s\" %u %u %u \"%u %u %u %u\" \"%u %u %u %u\" %u %u %u %u" ONU_CRLF, param->fw_name, param->ll_mod_sel.fsqm, param->ll_mod_sel.iqm, param->ll_mod_sel.tmu, param->ll_mod_sel.ictrll[0], param->ll_mod_sel.ictrll[1], param->ll_mod_sel.ictrll[2], param->ll_mod_sel.ictrll[3], param->ll_mod_sel.octrll[0], param->ll_mod_sel.octrll[1], param->ll_mod_sel.octrll[2], param->ll_mod_sel.octrll[3], param->ll_mod_sel.ictrlg, param->ll_mod_sel.octrlg, param->arb_mode, param->num_pe);
}

int dump_gpe_low_level_modules_enable(char *p_out, const void *p_data_in)
{
	struct gpe_ll_mod_sel *param;

	param = (struct gpe_ll_mod_sel *)p_data_in;
	return sprintf(p_out, "gpe_low_level_modules_enable %u %u %u \"%u %u %u %u\" \"%u %u %u %u\" %u %u" ONU_CRLF, param->fsqm, param->iqm, param->tmu, param->ictrll[0], param->ictrll[1], param->ictrll[2], param->ictrll[3], param->octrll[0], param->octrll[1], param->octrll[2], param->octrll[3], param->ictrlg, param->octrlg);
}

int dump_gpe_cfg_set(char *p_out, const void *p_data_in)
{
	struct gpe_cfg *param;

	param = (struct gpe_cfg *)p_data_in;
	return sprintf(p_out, "gpe_cfg_set %u %u %u %u %u %u %u %u" ONU_CRLF, param->gem_blk_len, param->gem_payload_size_max, param->pdu_size_max_eth, param->pdu_size_max_omci, param->pdu_size_max_ip, param->pdu_size_max_mpls, param->dbru_dbg_mode, param->aging_time);
}

int dump_gpe_cfg_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gpe_cfg_get" ONU_CRLF);
}

int dump_gpe_status_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gpe_status_get" ONU_CRLF);
}

int dump_gpe_gem_port_add(char *p_out, const void *p_data_in)
{
	struct gpe_gem_port *in;

	in = (struct gpe_gem_port *)p_data_in;
	return sprintf(p_out, "gpe_gem_port_add %u %u %u %u %u %u %u" ONU_CRLF, in->gem_port_id, in->gem_port_index, in->gem_port_is_omci, in->gem_port_is_mc, in->data_direction, in->gem_port_enable, in->encryption_enable);
}

int dump_gpe_gem_port_delete(char *p_out, const void *p_data_in)
{
	struct gem_port_id *param;

	param = (struct gem_port_id *)p_data_in;
	return sprintf(p_out, "gpe_gem_port_delete %u" ONU_CRLF, param->val);
}

int dump_gpe_gem_port_get(char *p_out, const void *p_data_in)
{
	struct gem_port_id *in;

	in = (struct gem_port_id *)p_data_in;
	return sprintf(p_out, "gpe_gem_port_get %u" ONU_CRLF, in->val);
}

int dump_gpe_gem_port_set(char *p_out, const void *p_data_in)
{
	struct gpe_gem_port *in;

	in = (struct gpe_gem_port *)p_data_in;
	return sprintf(p_out, "gpe_gem_port_set %u %u %u %u %u %u %u" ONU_CRLF, in->gem_port_id, in->gem_port_index, in->gem_port_is_omci, in->gem_port_is_mc, in->data_direction, in->gem_port_enable, in->encryption_enable);
}

int dump_gpe_tcont_create(char *p_out, const void *p_data_in)
{
	struct gpe_tcont_cfg *param;

	param = (struct gpe_tcont_cfg *)p_data_in;
	return sprintf(p_out, "gpe_tcont_create %u %u" ONU_CRLF, param->epn, param->policy);
}

int dump_gpe_tcont_set(char *p_out, const void *p_data_in)
{
	struct gpe_tcont *param;

	param = (struct gpe_tcont *)p_data_in;
	return sprintf(p_out, "gpe_tcont_set %u %u %u %u" ONU_CRLF, param->tcont_idx, param->alloc_id, param->reg_egress_port, param->pre_egress_port);
}

int dump_gpe_tcont_get(char *p_out, const void *p_data_in)
{
	struct tcont_index *in;

	in = (struct tcont_index *)p_data_in;
	return sprintf(p_out, "gpe_tcont_get %u" ONU_CRLF, in->tcont_idx);
}

int dump_gpe_tcont_delete(char *p_out, const void *p_data_in)
{
	struct tcont_index *param;

	param = (struct tcont_index *)p_data_in;
	return sprintf(p_out, "gpe_tcont_delete %u" ONU_CRLF, param->tcont_idx);
}

int dump_gpe_egress_port_create(char *p_out, const void *p_data_in)
{
	struct gpe_eport_create *param;

	param = (struct gpe_eport_create *)p_data_in;
	return sprintf(p_out, "gpe_egress_port_create %u %u %u %u %u %u" ONU_CRLF, param->index, param->is_uni, param->regular_epn, param->regular_sbid, param->preempting_epn, param->preempting_sbid);
}

int dump_gpe_egress_port_get(char *p_out, const void *p_data_in)
{
	struct gpe_epn *in;

	in = (struct gpe_epn *)p_data_in;
	return sprintf(p_out, "gpe_egress_port_get %u" ONU_CRLF, in->epn);
}

int dump_gpe_port_index_get(char *p_out, const void *p_data_in)
{
	struct gpe_egress_port *in;

	in = (struct gpe_egress_port *)p_data_in;
	return sprintf(p_out, "gpe_port_index_get %u %u" ONU_CRLF, in->index, in->is_uni);
}

int dump_gpe_egress_port_delete(char *p_out, const void *p_data_in)
{
	struct gpe_egress_port *param;

	param = (struct gpe_egress_port *)p_data_in;
	return sprintf(p_out, "gpe_egress_port_delete %u %u" ONU_CRLF, param->index, param->is_uni);
}

int dump_gpe_egress_port_cfg_set(char *p_out, const void *p_data_in)
{
	struct gpe_egress_port_cfg *param;

	param = (struct gpe_egress_port_cfg *)p_data_in;
	return sprintf(p_out, "gpe_egress_port_cfg_set %u %u %u %u %u %u" ONU_CRLF, param->epn, param->enable, param->egress_port_threshold_max, param->egress_port_threshold_green, param->egress_port_threshold_yellow, param->egress_port_threshold_red);
}

int dump_gpe_egress_port_cfg_get(char *p_out, const void *p_data_in)
{
	struct gpe_epn *in;

	in = (struct gpe_epn *)p_data_in;
	return sprintf(p_out, "gpe_egress_port_cfg_get %u" ONU_CRLF, in->epn);
}

int dump_gpe_egress_port_status_get(char *p_out, const void *p_data_in)
{
	struct gpe_epn *in;

	in = (struct gpe_epn *)p_data_in;
	return sprintf(p_out, "gpe_egress_port_status_get %u" ONU_CRLF, in->epn);
}

int dump_gpe_backpressure_cfg_set(char *p_out, const void *p_data_in)
{
	struct gpe_backpressure_cfg *param;

	param = (struct gpe_backpressure_cfg *)p_data_in;
	return sprintf(p_out, "gpe_backpressure_cfg_set \"%u %u %u %u %u\" \"%u %u %u %u\" \"%u %u %u %u\"" ONU_CRLF, param->free_segment_threshold[0], param->free_segment_threshold[1], param->free_segment_threshold[2], param->free_segment_threshold[3], param->free_segment_threshold[4], param->lan_queue_backpressure_high[0], param->lan_queue_backpressure_high[1], param->lan_queue_backpressure_high[2], param->lan_queue_backpressure_high[3], param->lan_queue_backpressure_low[0], param->lan_queue_backpressure_low[1], param->lan_queue_backpressure_low[2], param->lan_queue_backpressure_low[3]);
}

int dump_gpe_backpressure_cfg_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gpe_backpressure_cfg_get" ONU_CRLF);
}

int dump_gpe_ingress_queue_cfg_set(char *p_out, const void *p_data_in)
{
	struct gpe_iqueue_cfg *param;

	param = (struct gpe_iqueue_cfg *)p_data_in;
	return sprintf(p_out, "gpe_ingress_queue_cfg_set %u %u %u %u %u %u %u %u" ONU_CRLF, param->index, param->qe, param->qdth, param->qrth, param->qb, param->qbth, param->qbtl, param->tmask);
}

int dump_gpe_ingress_queue_cfg_get(char *p_out, const void *p_data_in)
{
	struct gpe_iqueue *in;

	in = (struct gpe_iqueue *)p_data_in;
	return sprintf(p_out, "gpe_ingress_queue_cfg_get %u" ONU_CRLF, in->index);
}

int dump_gpe_ingress_queue_status_get(char *p_out, const void *p_data_in)
{
	struct gpe_iqueue *in;

	in = (struct gpe_iqueue *)p_data_in;
	return sprintf(p_out, "gpe_ingress_queue_status_get %u" ONU_CRLF, in->index);
}

int dump_gpe_egress_queue_create(char *p_out, const void *p_data_in)
{
	struct gpe_equeue_create *param;

	param = (struct gpe_equeue_create *)p_data_in;
	return sprintf(p_out, "gpe_egress_queue_create %u %u %u" ONU_CRLF, param->index, param->egress_port_number, param->scheduler_input);
}

int dump_gpe_egress_queue_delete(char *p_out, const void *p_data_in)
{
	struct gpe_equeue *param;

	param = (struct gpe_equeue *)p_data_in;
	return sprintf(p_out, "gpe_egress_queue_delete %u" ONU_CRLF, param->index);
}

int dump_gpe_egress_queue_get(char *p_out, const void *p_data_in)
{
	struct gpe_equeue *in;

	in = (struct gpe_equeue *)p_data_in;
	return sprintf(p_out, "gpe_egress_queue_get %u" ONU_CRLF, in->index);
}

int dump_gpe_egress_queue_cfg_set(char *p_out, const void *p_data_in)
{
	struct gpe_equeue_cfg *param;

	param = (struct gpe_equeue_cfg *)p_data_in;
	return sprintf(p_out, "gpe_egress_queue_cfg_set %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u" ONU_CRLF, param->index, param->enable, param->sbin_enable, param->weight, param->wred_enable, param->avg_weight, param->size, param->reservation_threshold, param->drop_threshold_red, param->drop_threshold_green_max, param->drop_threshold_green_min, param->drop_threshold_yellow_max, param->drop_threshold_yellow_min, param->drop_probability_green, param->drop_probability_yellow, param->coloring_mode);
}

int dump_gpe_egress_queue_cfg_get(char *p_out, const void *p_data_in)
{
	struct gpe_equeue *in;

	in = (struct gpe_equeue *)p_data_in;
	return sprintf(p_out, "gpe_egress_queue_cfg_get %u" ONU_CRLF, in->index);
}

int dump_gpe_egress_queue_status_get(char *p_out, const void *p_data_in)
{
	struct gpe_equeue *in;

	in = (struct gpe_equeue *)p_data_in;
	return sprintf(p_out, "gpe_egress_queue_status_get %u" ONU_CRLF, in->index);
}

int dump_gpe_egress_queue_path_get(char *p_out, const void *p_data_in)
{
	struct gpe_equeue *in;

	in = (struct gpe_equeue *)p_data_in;
	return sprintf(p_out, "gpe_egress_queue_path_get %u" ONU_CRLF, in->index);
}

int dump_gpe_scheduler_create(char *p_out, const void *p_data_in)
{
	struct gpe_sched_create *param;

	param = (struct gpe_sched_create *)p_data_in;
	return sprintf(p_out, "gpe_scheduler_create %u %u %u %u %u %u %u %u %u" ONU_CRLF, param->index, param->use_tcont, param->level, param->scheduler_id, param->port_idx, param->connected_scheduler_index, param->use_regular, param->scheduler_policy, param->priority_weight);
}

int dump_gpe_scheduler_delete(char *p_out, const void *p_data_in)
{
	struct gpe_scheduler_idx *param;

	param = (struct gpe_scheduler_idx *)p_data_in;
	return sprintf(p_out, "gpe_scheduler_delete %u" ONU_CRLF, param->index);
}

int dump_gpe_scheduler_get(char *p_out, const void *p_data_in)
{
	struct gpe_scheduler_idx *in;

	in = (struct gpe_scheduler_idx *)p_data_in;
	return sprintf(p_out, "gpe_scheduler_get %u" ONU_CRLF, in->index);
}

int dump_gpe_scheduler_cfg_set(char *p_out, const void *p_data_in)
{
	struct gpe_scheduler_cfg *param;

	param = (struct gpe_scheduler_cfg *)p_data_in;
	return sprintf(p_out, "gpe_scheduler_cfg_set %u %u %u" ONU_CRLF, param->index, param->output_enable, param->weight);
}

int dump_gpe_scheduler_cfg_get(char *p_out, const void *p_data_in)
{
	struct gpe_scheduler_idx *in;

	in = (struct gpe_scheduler_idx *)p_data_in;
	return sprintf(p_out, "gpe_scheduler_cfg_get %u" ONU_CRLF, in->index);
}

int dump_gpe_scheduler_status_get(char *p_out, const void *p_data_in)
{
	struct gpe_scheduler_idx *in;

	in = (struct gpe_scheduler_idx *)p_data_in;
	return sprintf(p_out, "gpe_scheduler_status_get %u" ONU_CRLF, in->index);
}

int dump_gpe_token_bucket_shaper_create(char *p_out, const void *p_data_in)
{
	struct gpe_token_bucket_shaper *param;

	param = (struct gpe_token_bucket_shaper *)p_data_in;
	return sprintf(p_out, "gpe_token_bucket_shaper_create %u %u" ONU_CRLF, param->index, param->tbs_scheduler_block_input);
}

int dump_gpe_token_bucket_shaper_delete(char *p_out, const void *p_data_in)
{
	struct gpe_token_bucket_shaper *param;

	param = (struct gpe_token_bucket_shaper *)p_data_in;
	return sprintf(p_out, "gpe_token_bucket_shaper_delete %u %u" ONU_CRLF, param->index, param->tbs_scheduler_block_input);
}

int dump_gpe_token_bucket_shaper_get(char *p_out, const void *p_data_in)
{
	struct gpe_token_bucket_shaper_idx *in;

	in = (struct gpe_token_bucket_shaper_idx *)p_data_in;
	return sprintf(p_out, "gpe_token_bucket_shaper_get %u" ONU_CRLF, in->index);
}

int dump_gpe_token_bucket_shaper_cfg_set(char *p_out, const void *p_data_in)
{
	struct gpe_token_bucket_shaper_cfg *param;

	param = (struct gpe_token_bucket_shaper_cfg *)p_data_in;
	return sprintf(p_out, "gpe_token_bucket_shaper_cfg_set %u %u %u %u %u %u %u" ONU_CRLF, param->index, param->enable, param->mode, param->cir, param->pir, param->cbs, param->pbs);
}

int dump_gpe_token_bucket_shaper_cfg_get(char *p_out, const void *p_data_in)
{
	struct gpe_token_bucket_shaper_idx *in;

	in = (struct gpe_token_bucket_shaper_idx *)p_data_in;
	return sprintf(p_out, "gpe_token_bucket_shaper_cfg_get %u" ONU_CRLF, in->index);
}

int dump_gpe_token_bucket_shaper_status_get(char *p_out, const void *p_data_in)
{
	struct gpe_token_bucket_shaper_idx *in;

	in = (struct gpe_token_bucket_shaper_idx *)p_data_in;
	return sprintf(p_out, "gpe_token_bucket_shaper_status_get %u" ONU_CRLF, in->index);
}

int dump_gpe_meter_create(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gpe_meter_create" ONU_CRLF);
}

int dump_gpe_meter_delete(char *p_out, const void *p_data_in)
{
	struct gpe_meter *param;

	param = (struct gpe_meter *)p_data_in;
	return sprintf(p_out, "gpe_meter_delete %u" ONU_CRLF, param->index);
}

int dump_gpe_meter_cfg_set(char *p_out, const void *p_data_in)
{
	struct gpe_meter_cfg *param;

	param = (struct gpe_meter_cfg *)p_data_in;
	return sprintf(p_out, "gpe_meter_cfg_set %u %u %u %u %u %u %u" ONU_CRLF, param->index, param->cir, param->pir, param->cbs, param->pbs, param->color_aware, param->mode);
}

int dump_gpe_meter_cfg_get(char *p_out, const void *p_data_in)
{
	struct gpe_meter *in;

	in = (struct gpe_meter *)p_data_in;
	return sprintf(p_out, "gpe_meter_cfg_get %u" ONU_CRLF, in->index);
}

int dump_gpe_meter_status_get(char *p_out, const void *p_data_in)
{
	struct gpe_meter *in;

	in = (struct gpe_meter *)p_data_in;
	return sprintf(p_out, "gpe_meter_status_get %u" ONU_CRLF, in->index);
}

int dump_gpe_shared_buffer_cfg_set(char *p_out, const void *p_data_in)
{
	struct gpe_shared_buffer_cfg *param;

	param = (struct gpe_shared_buffer_cfg *)p_data_in;
	return sprintf(p_out, "gpe_shared_buffer_cfg_set %u %u %u %u %u" ONU_CRLF, param->iqm_global_segments_max, param->tmu_global_segments_max, param->tmu_global_segments_green, param->tmu_global_segments_yellow, param->tmu_global_segments_red);
}

int dump_gpe_shared_buffer_cfg_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gpe_shared_buffer_cfg_get" ONU_CRLF);
}

int dump_gpe_bridge_counter_get(char *p_out, const void *p_data_in)
{
	struct gpe_bridge_cnt_interval *in;

	in = (struct gpe_bridge_cnt_interval *)p_data_in;
	return sprintf(p_out, "gpe_bridge_counter_get %u %u %u" ONU_CRLF, in->bridge_index, in->reset_mask, in->curr);
}

int dump_gpe_bridge_port_counter_get(char *p_out, const void *p_data_in)
{
	struct gpe_bridge_port_cnt_interval *in;

	in = (struct gpe_bridge_port_cnt_interval *)p_data_in;
	return sprintf(p_out, "gpe_bridge_port_counter_get %u %u %u" ONU_CRLF, in->index, in->reset_mask, in->curr);
}

int dump_gpe_bridge_counter_threshold_set(char *p_out, const void *p_data_in)
{
	struct gpe_cnt_bridge_threshold *param;

	param = (struct gpe_cnt_bridge_threshold *)p_data_in;
	return sprintf(p_out, "gpe_bridge_counter_threshold_set %u %llu" ONU_CRLF, param->bridge_index, param->threshold.learning_discard);
}

int dump_gpe_bridge_port_counter_threshold_set(char *p_out, const void *p_data_in)
{
	struct gpe_cnt_bridge_port_threshold *param;

	param = (struct gpe_cnt_bridge_port_threshold *)p_data_in;
	return sprintf(p_out, "gpe_bridge_port_counter_threshold_set %u %llu %llu %llu %llu %llu" ONU_CRLF, param->index, param->threshold.learning_discard, param->threshold.ibp_good, param->threshold.ibp_discard, param->threshold.ebp_good, param->threshold.ebp_discard);
}

int dump_gpe_bridge_counter_threshold_get(char *p_out, const void *p_data_in)
{
	struct gpe_bridge *in;

	in = (struct gpe_bridge *)p_data_in;
	return sprintf(p_out, "gpe_bridge_counter_threshold_get %u" ONU_CRLF, in->bridge_index);
}

int dump_gpe_bridge_port_counter_threshold_get(char *p_out, const void *p_data_in)
{
	struct gpe_bridge_port_index *in;

	in = (struct gpe_bridge_port_index *)p_data_in;
	return sprintf(p_out, "gpe_bridge_port_counter_threshold_get %u" ONU_CRLF, in->index);
}

int dump_gpe_bridge_tca_get(char *p_out, const void *p_data_in)
{
	struct gpe_bridge *in;

	in = (struct gpe_bridge *)p_data_in;
	return sprintf(p_out, "gpe_bridge_tca_get %u" ONU_CRLF, in->bridge_index);
}

int dump_gpe_bridge_port_tca_get(char *p_out, const void *p_data_in)
{
	struct gpe_bridge_port_index *in;

	in = (struct gpe_bridge_port_index *)p_data_in;
	return sprintf(p_out, "gpe_bridge_port_tca_get %u" ONU_CRLF, in->index);
}

int dump_gpe_bridge_counter_reset(char *p_out, const void *p_data_in)
{
	struct gpe_bridge_cnt_interval *param;

	param = (struct gpe_bridge_cnt_interval *)p_data_in;
	return sprintf(p_out, "gpe_bridge_counter_reset %u %u %u" ONU_CRLF, param->bridge_index, param->reset_mask, param->curr);
}

int dump_gpe_bridge_port_counter_reset(char *p_out, const void *p_data_in)
{
	struct gpe_bridge_port_cnt_interval *param;

	param = (struct gpe_bridge_port_cnt_interval *)p_data_in;
	return sprintf(p_out, "gpe_bridge_port_counter_reset %u %u %u" ONU_CRLF, param->index, param->reset_mask, param->curr);
}

int dump_gpe_parser_cfg_set(char *p_out, const void *p_data_in)
{
	struct gpe_parser_cfg *param;

	param = (struct gpe_parser_cfg *)p_data_in;
	return sprintf(p_out, "gpe_parser_cfg_set \"%u %u %u %u\" %u" ONU_CRLF, param->tpid[0], param->tpid[1], param->tpid[2], param->tpid[3], param->special_tag);
}

int dump_gpe_parser_cfg_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gpe_parser_cfg_get" ONU_CRLF);
}

int dump_gpe_ethertype_filter_cfg_set(char *p_out, const void *p_data_in)
{
	struct gpe_ethertype_filter_cfg *param;

	param = (struct gpe_ethertype_filter_cfg *)p_data_in;
	return sprintf(p_out, "gpe_ethertype_filter_cfg_set %u %u \"%u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u\" %u %u" ONU_CRLF, param->lanport_index, param->ethertype_filter_pointer, param->ethertype[0], param->ethertype[1], param->ethertype[2], param->ethertype[3], param->ethertype[4], param->ethertype[5], param->ethertype[6], param->ethertype[7], param->ethertype[8], param->ethertype[9], param->ethertype[10], param->ethertype[11], param->ethertype[12], param->ethertype[13], param->ethertype[14], param->ethertype[15], param->ethertype[16], param->ethertype[17], param->ethertype[18], param->ethertype[19], param->ethertype[20], param->ethertype[21], param->ethertype[22], param->ethertype[23], param->ethertype[24], param->ethertype[25], param->ethertype[26], param->ethertype[27], param->ethertype[28], param->ethertype[29], param->ethertype[30], param->ethertype[31], param->num_valid_ethertypes, param->whitelist_mode);
}

int dump_gpe_ethertype_filter_cfg_get(char *p_out, const void *p_data_in)
{
	struct gpe_ethertype_filter_index *in;

	in = (struct gpe_ethertype_filter_index *)p_data_in;
	return sprintf(p_out, "gpe_ethertype_filter_cfg_get %u" ONU_CRLF, in->lanport_index);
}

int dump_gpe_omci_send(char *p_out, const void *p_data_in)
{
	struct gpe_omci_msg *param;

	param = (struct gpe_omci_msg *)p_data_in;
	return sprintf(p_out, "gpe_omci_send %u \"%u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u\"" ONU_CRLF, param->length, param->message[0], param->message[1], param->message[2], param->message[3], param->message[4], param->message[5], param->message[6], param->message[7], param->message[8], param->message[9], param->message[10], param->message[11], param->message[12], param->message[13], param->message[14], param->message[15], param->message[16], param->message[17], param->message[18], param->message[19], param->message[20], param->message[21], param->message[22], param->message[23], param->message[24], param->message[25], param->message[26], param->message[27], param->message[28], param->message[29], param->message[30], param->message[31], param->message[32], param->message[33], param->message[34], param->message[35], param->message[36], param->message[37], param->message[38], param->message[39], param->message[40], param->message[41], param->message[42], param->message[43], param->message[44], param->message[45], param->message[46], param->message[47], param->message[48], param->message[49], param->message[50], param->message[51], param->message[52], param->message[53], param->message[54], param->message[55], param->message[56], param->message[57], param->message[58], param->message[59], param->message[60], param->message[61], param->message[62], param->message[63]);
}

int dump_gpe_tod_init(char *p_out, const void *p_data_in)
{
	struct gpe_tod_init_data *param;

	param = (struct gpe_tod_init_data *)p_data_in;
	return sprintf(p_out, "gpe_tod_init %u %u" ONU_CRLF, param->pps_pulse_width, param->interrupt_delay);
}

int dump_gpe_tod_sync_set(char *p_out, const void *p_data_in)
{
	struct gpe_tod_sync *param;

	param = (struct gpe_tod_sync *)p_data_in;
	return sprintf(p_out, "gpe_tod_sync_set %u %u %u %u" ONU_CRLF, param->multiframe_count, param->tod_seconds, param->tod_extended_seconds, param->tod_nano_seconds);
}

int dump_gpe_tod_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gpe_tod_get" ONU_CRLF);
}

int dump_gpe_tod_sync_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gpe_tod_sync_get" ONU_CRLF);
}

int dump_gpe_iqm_global_cfg_set(char *p_out, const void *p_data_in)
{
	struct gpe_iqm_global_cfg *param;

	param = (struct gpe_iqm_global_cfg *)p_data_in;
	return sprintf(p_out, "gpe_iqm_global_cfg_set %u %u \"%u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u\"" ONU_CRLF, param->goth, param->wrrper, param->wrrq[0], param->wrrq[1], param->wrrq[2], param->wrrq[3], param->wrrq[4], param->wrrq[5], param->wrrq[6], param->wrrq[7], param->wrrq[8], param->wrrq[9], param->wrrq[10], param->wrrq[11], param->wrrq[12], param->wrrq[13], param->wrrq[14], param->wrrq[15], param->wrrq[16], param->wrrq[17], param->wrrq[18], param->wrrq[19], param->wrrq[20], param->wrrq[21], param->wrrq[22], param->wrrq[23], param->wrrq[24], param->wrrq[25], param->wrrq[26], param->wrrq[27], param->wrrq[28], param->wrrq[29], param->wrrq[30], param->wrrq[31], param->wrrq[32], param->wrrq[33], param->wrrq[34], param->wrrq[35]);
}

int dump_gpe_iqm_global_cfg_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gpe_iqm_global_cfg_get" ONU_CRLF);
}

int dump_gpe_iqm_global_status_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gpe_iqm_global_status_get" ONU_CRLF);
}

int dump_gpe_tmu_global_cfg_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gpe_tmu_global_cfg_get" ONU_CRLF);
}

int dump_gpe_tmu_global_status_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gpe_tmu_global_status_get" ONU_CRLF);
}

int dump_gpe_tmu_counter_get(char *p_out, const void *p_data_in)
{
	struct gpe_cnt_tmu_sel *in;

	in = (struct gpe_cnt_tmu_sel *)p_data_in;
	return sprintf(p_out, "gpe_tmu_counter_get %u %u" ONU_CRLF, in->cnt_type, in->index);
}

int dump_gpe_tmu_counter_reset(char *p_out, const void *p_data_in)
{
	struct gpe_cnt_tmu_reset *param;

	param = (struct gpe_cnt_tmu_reset *)p_data_in;
	return sprintf(p_out, "gpe_tmu_counter_reset %u" ONU_CRLF, param->dummy);
}

int dump_gpe_sce_counter_get(char *p_out, const void *p_data_in)
{
	struct gpe_cnt_sce_sel *in;

	in = (struct gpe_cnt_sce_sel *)p_data_in;
	return sprintf(p_out, "gpe_sce_counter_get %u %u" ONU_CRLF, in->cnt_type, in->index);
}

int dump_gpe_sce_counter_reset(char *p_out, const void *p_data_in)
{
	struct gpe_cnt_sce_reset *param;

	param = (struct gpe_cnt_sce_reset *)p_data_in;
	return sprintf(p_out, "gpe_sce_counter_reset %u" ONU_CRLF, param->dummy);
}

int dump_gpe_gem_counter_get(char *p_out, const void *p_data_in)
{
	struct gpe_gem_cnt_interval *in;

	in = (struct gpe_gem_cnt_interval *)p_data_in;
	return sprintf(p_out, "gpe_gem_counter_get %u %u %u" ONU_CRLF, in->gem_port_index, in->reset_mask, in->curr);
}

int dump_gpe_gem_counter_threshold_set(char *p_out, const void *p_data_in)
{
	struct gpe_cnt_gem_threshold *param;

	param = (struct gpe_cnt_gem_threshold *)p_data_in;
	return sprintf(p_out, "gpe_gem_counter_threshold_set %u %llu %llu %llu %llu" ONU_CRLF, param->gem_port_index, param->threshold.rx.rx_frames, param->threshold.rx.rx_bytes, param->threshold.tx.tx_frames, param->threshold.tx.tx_bytes);
}

int dump_gpe_gem_counter_threshold_get(char *p_out, const void *p_data_in)
{
	struct gem_port_index *in;

	in = (struct gem_port_index *)p_data_in;
	return sprintf(p_out, "gpe_gem_counter_threshold_get %u" ONU_CRLF, in->val);
}

int dump_gpe_gem_tca_get(char *p_out, const void *p_data_in)
{
	struct gem_port_index *in;

	in = (struct gem_port_index *)p_data_in;
	return sprintf(p_out, "gpe_gem_tca_get %u" ONU_CRLF, in->val);
}

int dump_gpe_gem_counter_reset(char *p_out, const void *p_data_in)
{
	struct gpe_gem_cnt_interval *param;

	param = (struct gpe_gem_cnt_interval *)p_data_in;
	return sprintf(p_out, "gpe_gem_counter_reset %u %u %u" ONU_CRLF, param->gem_port_index, param->reset_mask, param->curr);
}

#if defined(INCLUDE_SCE_DEBUG)
int dump_sce_break_set(char *p_out, const void *p_data_in)
{
	struct sce_break_point *param;

	param = (struct sce_break_point *)p_data_in;
	return sprintf(p_out, "sce_break_set %u %u" ONU_CRLF, param->tid, param->addr);
}

int dump_sce_break_autocheck_enable(char *p_out, const void *p_data_in)
{
	bool *enable;

	enable = (bool *)p_data_in;
	return sprintf(p_out, "sce_break_autocheck_enable %u" ONU_CRLF, *enable);
}

int dump_sce_break_get(char *p_out, const void *p_data_in)
{
	struct sce_break_index *in;

	in = (struct sce_break_index *)p_data_in;
	return sprintf(p_out, "sce_break_get %u %u" ONU_CRLF, in->tid, in->idx);
}

int dump_sce_break_remove(char *p_out, const void *p_data_in)
{
	struct sce_break_point *param;

	param = (struct sce_break_point *)p_data_in;
	return sprintf(p_out, "sce_break_remove %u %u" ONU_CRLF, param->tid, param->addr);
}

int dump_sce_break(char *p_out, const void *p_data_in)
{
	struct sce_thread *in;

	in = (struct sce_thread *)p_data_in;
	return sprintf(p_out, "sce_break %u" ONU_CRLF, in->tid);
}

int dump_sce_single_step(char *p_out, const void *p_data_in)
{
	struct sce_thread *in;

	in = (struct sce_thread *)p_data_in;
	return sprintf(p_out, "sce_single_step %u" ONU_CRLF, in->tid);
}

int dump_sce_run(char *p_out, const void *p_data_in)
{
	struct sce_thread *param;

	param = (struct sce_thread *)p_data_in;
	return sprintf(p_out, "sce_run %u" ONU_CRLF, param->tid);
}

int dump_sce_restart_vm(char *p_out, const void *p_data_in)
{
	struct sce_restart_cfg *param;

	param = (struct sce_restart_cfg *)p_data_in;
	return sprintf(p_out, "sce_restart_vm %u" ONU_CRLF, param->pid);
}

int dump_sce_run_mask(char *p_out, const void *p_data_in)
{
	struct sce_thread_mask *param;

	param = (struct sce_thread_mask *)p_data_in;
	return sprintf(p_out, "sce_run_mask %u" ONU_CRLF, param->mask);
}

int dump_sce_break_mask(char *p_out, const void *p_data_in)
{
	struct sce_thread_mask *param;

	param = (struct sce_thread_mask *)p_data_in;
	return sprintf(p_out, "sce_break_mask %u" ONU_CRLF, param->mask);
}

int dump_sce_status_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "sce_status_get" ONU_CRLF);
}

int dump_sce_reg_set(char *p_out, const void *p_data_in)
{
	struct sce_register_val *param;

	param = (struct sce_register_val *)p_data_in;
	return sprintf(p_out, "sce_reg_set %u %u %u" ONU_CRLF, param->tid, param->reg, param->val);
}

int dump_sce_reg_get(char *p_out, const void *p_data_in)
{
	struct sce_register *in;

	in = (struct sce_register *)p_data_in;
	return sprintf(p_out, "sce_reg_get %u %u" ONU_CRLF, in->tid, in->reg);
}

int dump_sce_mem_set(char *p_out, const void *p_data_in)
{
	struct sce_memory_val *param;

	param = (struct sce_memory_val *)p_data_in;
	return sprintf(p_out, "sce_mem_set %u %u %u" ONU_CRLF, param->tid, param->addr, param->val);
}

int dump_sce_mem_get(char *p_out, const void *p_data_in)
{
	struct sce_memory *in;

	in = (struct sce_memory *)p_data_in;
	return sprintf(p_out, "sce_mem_get %u %u" ONU_CRLF, in->tid, in->addr);
}

#endif /* defined(INCLUDE_SCE_DEBUG) */
int dump_gpe_sce_download(char *p_out, const void *p_data_in)
{
	struct sce_download_cfg *param;

	param = (struct sce_download_cfg *)p_data_in;
	return sprintf(p_out, "gpe_sce_download %u \"%s\"" ONU_CRLF, param->pid, param->fw_name);
}

int dump_gpe_sce_version_get(char *p_out, const void *p_data_in)
{
	struct sce_pe_index *in;

	in = (struct sce_pe_index *)p_data_in;
	return sprintf(p_out, "gpe_sce_version_get %u" ONU_CRLF, in->pid);
}

int dump_gpe_flat_egress_path_create(char *p_out, const void *p_data_in)
{
	struct gpe_flat_egress_path *param;

	param = (struct gpe_flat_egress_path *)p_data_in;
	return sprintf(p_out, "gpe_flat_egress_path_create %u %u %u %u %u" ONU_CRLF, param->num_ports, param->base_epn, param->base_sbid, param->base_qid, param->qid_per_sb);
}

int dump_gpe_fsqm_check(char *p_out, const void *p_data_in)
{
	uint16_t *len;

	len = (uint16_t *)p_data_in;
	return sprintf(p_out, "gpe_fsqm_check %hu" ONU_CRLF, *len);
}

int dump_gpe_cop_download(char *p_out, const void *p_data_in)
{
	struct cop_download_cfg *param;

	param = (struct cop_download_cfg *)p_data_in;
	return sprintf(p_out, "gpe_cop_download %u \"%s\"" ONU_CRLF, param->cop_id, param->mc_name);
}

int dump_gpe_lan_exception_cfg_set(char *p_out, const void *p_data_in)
{
	struct gpe_lan_exception_cfg *param;

	param = (struct gpe_lan_exception_cfg *)p_data_in;
	return sprintf(p_out, "gpe_lan_exception_cfg_set %u %u %u %u %u %u" ONU_CRLF, param->lan_port_index, param->exception_profile, param->uni_except_meter_id, param->uni_except_meter_enable, param->igmp_except_meter_id, param->igmp_except_meter_enable);
}

int dump_gpe_lan_exception_cfg_get(char *p_out, const void *p_data_in)
{
	struct gpe_lan_exception_idx *in;

	in = (struct gpe_lan_exception_idx *)p_data_in;
	return sprintf(p_out, "gpe_lan_exception_cfg_get %u" ONU_CRLF, in->lan_port_index);
}

int dump_gpe_ani_exception_cfg_set(char *p_out, const void *p_data_in)
{
	struct gpe_ani_exception_cfg *param;

	param = (struct gpe_ani_exception_cfg *)p_data_in;
	return sprintf(p_out, "gpe_ani_exception_cfg_set %u %u %u" ONU_CRLF, param->gem_port_index, param->ds_exception_profile, param->us_exception_profile);
}

int dump_gpe_ani_exception_cfg_get(char *p_out, const void *p_data_in)
{
	struct gpe_ani_exception_idx *in;

	in = (struct gpe_ani_exception_idx *)p_data_in;
	return sprintf(p_out, "gpe_ani_exception_cfg_get %u" ONU_CRLF, in->gem_port_index);
}

int dump_gpe_exception_queue_cfg_set(char *p_out, const void *p_data_in)
{
	struct gpe_exception_queue_cfg *param;

	param = (struct gpe_exception_queue_cfg *)p_data_in;
	return sprintf(p_out, "gpe_exception_queue_cfg_set %u %u %u" ONU_CRLF, param->exception_index, param->exception_queue, param->snooping_enable);
}

int dump_gpe_exception_queue_cfg_get(char *p_out, const void *p_data_in)
{
	struct gpe_exception_queue_idx *in;

	in = (struct gpe_exception_queue_idx *)p_data_in;
	return sprintf(p_out, "gpe_exception_queue_cfg_get %u" ONU_CRLF, in->exception_index);
}

int dump_gpe_capability_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gpe_capability_get" ONU_CRLF);
}

int dump_gpe_exception_profile_cfg_set(char *p_out, const void *p_data_in)
{
	struct gpe_exception_profile_cfg *param;

	param = (struct gpe_exception_profile_cfg *)p_data_in;
	return sprintf(p_out, "gpe_exception_profile_cfg_set %u %u %u" ONU_CRLF, param->exception_profile, param->ingress_exception_mask, param->egress_exception_mask);
}

int dump_gpe_exception_profile_cfg_get(char *p_out, const void *p_data_in)
{
	struct gpe_exception_profile_idx *in;

	in = (struct gpe_exception_profile_idx *)p_data_in;
	return sprintf(p_out, "gpe_exception_profile_cfg_get %u" ONU_CRLF, in->exception_profile);
}

int dump_gpe_egress_port_enable(char *p_out, const void *p_data_in)
{
	struct gpe_epn *param;

	param = (struct gpe_epn *)p_data_in;
	return sprintf(p_out, "gpe_egress_port_enable %u" ONU_CRLF, param->epn);
}

int dump_gpe_egress_port_disable(char *p_out, const void *p_data_in)
{
	struct gpe_epn *param;

	param = (struct gpe_epn *)p_data_in;
	return sprintf(p_out, "gpe_egress_port_disable %u" ONU_CRLF, param->epn);
}

int dump_gpe_short_fwd_mac_mc_port_add(char *p_out, const void *p_data_in)
{
	struct gpe_mac_mc_port *in;

	in = (struct gpe_mac_mc_port *)p_data_in;
	return sprintf(p_out, "gpe_short_fwd_mac_mc_port_add %u %u %u \"%u %u %u %u %u %u\"" ONU_CRLF, in->fid, in->lan_port_index, in->igmp, in->mc_mac[0], in->mc_mac[1], in->mc_mac[2], in->mc_mac[3], in->mc_mac[4], in->mc_mac[5]);
}

int dump_gpe_short_fwd_mac_mc_port_delete(char *p_out, const void *p_data_in)
{
	struct gpe_mac_mc_port *in;

	in = (struct gpe_mac_mc_port *)p_data_in;
	return sprintf(p_out, "gpe_short_fwd_mac_mc_port_delete %u %u %u \"%u %u %u %u %u %u\"" ONU_CRLF, in->fid, in->lan_port_index, in->igmp, in->mc_mac[0], in->mc_mac[1], in->mc_mac[2], in->mc_mac[3], in->mc_mac[4], in->mc_mac[5]);
}

int dump_gpe_short_fwd_mac_mc_port_modify(char *p_out, const void *p_data_in)
{
	struct gpe_mac_mc_port_modify *in;

	in = (struct gpe_mac_mc_port_modify *)p_data_in;
	return sprintf(p_out, "gpe_short_fwd_mac_mc_port_modify %u %u %u %u \"%u %u %u %u %u %u\"" ONU_CRLF, in->bridge_index, in->port_map_index, in->fid, in->igmp, in->mc_mac[0], in->mc_mac[1], in->mc_mac[2], in->mc_mac[3], in->mc_mac[4], in->mc_mac[5]);
}

int dump_gpe_short_fwd_ipv4_mc_port_add(char *p_out, const void *p_data_in)
{
	struct gpe_ipv4_mc_port *in;

	in = (struct gpe_ipv4_mc_port *)p_data_in;
	return sprintf(p_out, "gpe_short_fwd_ipv4_mc_port_add %u %u %u \"%u %u %u %u\"" ONU_CRLF, in->fid, in->lan_port_index, in->igmp, in->ip[0], in->ip[1], in->ip[2], in->ip[3]);
}

int dump_gpe_short_fwd_ipv4_mc_port_delete(char *p_out, const void *p_data_in)
{
	struct gpe_ipv4_mc_port *in;

	in = (struct gpe_ipv4_mc_port *)p_data_in;
	return sprintf(p_out, "gpe_short_fwd_ipv4_mc_port_delete %u %u %u \"%u %u %u %u\"" ONU_CRLF, in->fid, in->lan_port_index, in->igmp, in->ip[0], in->ip[1], in->ip[2], in->ip[3]);
}

int dump_gpe_short_fwd_ipv4_mc_port_modify(char *p_out, const void *p_data_in)
{
	struct gpe_ipv4_mc_port_modify *in;

	in = (struct gpe_ipv4_mc_port_modify *)p_data_in;
	return sprintf(p_out, "gpe_short_fwd_ipv4_mc_port_modify %u %u %u %u \"%u %u %u %u\"" ONU_CRLF, in->bridge_index, in->port_map_index, in->fid, in->igmp, in->ip[0], in->ip[1], in->ip[2], in->ip[3]);
}

int dump_gpe_aging_time_set(char *p_out, const void *p_data_in)
{
	struct sce_aging_time *in;

	in = (struct sce_aging_time *)p_data_in;
	return sprintf(p_out, "gpe_aging_time_set %u" ONU_CRLF, in->aging_time);
}

int dump_gpe_aging_time_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gpe_aging_time_get" ONU_CRLF);
}

int dump_gpe_aging_time_set_debug(char *p_out, const void *p_data_in)
{
	struct sce_aging_time *in;

	in = (struct sce_aging_time *)p_data_in;
	return sprintf(p_out, "gpe_aging_time_set_debug %u" ONU_CRLF, in->aging_time);
}

int dump_gpe_sce_constants_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gpe_sce_constants_get" ONU_CRLF);
}

int dump_gpe_sce_constants_set(char *p_out, const void *p_data_in)
{
	struct gpe_sce_constants *param;

	param = (struct gpe_sce_constants *)p_data_in;
	return sprintf(p_out, "gpe_sce_constants_set %u %u %hu %hu %u %u %u %hu %hu %hu %hu %u %u %u \"%u %u %u %u %u %u\" %u %u %u %u %u %u" ONU_CRLF, param->packet_processing_enable, param->default_fid, param->default_outer_vid, param->default_inner_vid, param->default_dscp, param->unused0, param->fwd_table_size, param->tpid_a, param->tpid_b, param->tpid_c, param->tpid_d, param->unused, param->added_latency, param->unused1, param->local_cpu_mac[0], param->local_cpu_mac[1], param->local_cpu_mac[2], param->local_cpu_mac[3], param->local_cpu_mac[4], param->local_cpu_mac[5], param->ani_exception_meter_id, param->ani_exception_enable, param->ani_except_policer_threshold, param->uni_except_policer_threshold, param->igmp_except_policer_threshold, param->meter_l2_only_enable);
}

int dump_gpe_sce_mac_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "gpe_sce_mac_get" ONU_CRLF);
}

int dump_gpe_sce_mac_set(char *p_out, const void *p_data_in)
{
	struct gpe_sce_mac *param;

	param = (struct gpe_sce_mac *)p_data_in;
	return sprintf(p_out, "gpe_sce_mac_set \"%u %u %u %u %u %u\"" ONU_CRLF, param->local_cpu_mac[0], param->local_cpu_mac[1], param->local_cpu_mac[2], param->local_cpu_mac[3], param->local_cpu_mac[4], param->local_cpu_mac[5]);
}

int dump_gpe_vlan_fid_add(char *p_out, const void *p_data_in)
{
	struct gpe_vlan_fid_in *in;

	in = (struct gpe_vlan_fid_in *)p_data_in;
	return sprintf(p_out, "gpe_vlan_fid_add %u %u" ONU_CRLF, in->vlan_1, in->vlan_2);
}

int dump_gpe_vlan_fid_get(char *p_out, const void *p_data_in)
{
	struct gpe_vlan_fid_in *in;

	in = (struct gpe_vlan_fid_in *)p_data_in;
	return sprintf(p_out, "gpe_vlan_fid_get %u %u" ONU_CRLF, in->vlan_1, in->vlan_2);
}

int dump_gpe_vlan_fid_delete(char *p_out, const void *p_data_in)
{
	struct gpe_vlan_fid_in *in;

	in = (struct gpe_vlan_fid_in *)p_data_in;
	return sprintf(p_out, "gpe_vlan_fid_delete %u %u" ONU_CRLF, in->vlan_1, in->vlan_2);
}

int dump_gpe_bridge_port_cfg_get(char *p_out, const void *p_data_in)
{
	struct gpe_bridge_port_index *in;

	in = (struct gpe_bridge_port_index *)p_data_in;
	return sprintf(p_out, "gpe_bridge_port_cfg_get %u" ONU_CRLF, in->index);
}

int dump_gpe_cop_debug_set(char *p_out, const void *p_data_in)
{
	struct gpe_cop_tracing *in;

	in = (struct gpe_cop_tracing *)p_data_in;
	return sprintf(p_out, "gpe_cop_debug_set %u %u" ONU_CRLF, in->cop_idx, in->trace_enable);
}

int dump_gpe_cop_debug_server(char *p_out, const void *p_data_in)
{
	struct gpe_cop_debug *in;

	in = (struct gpe_cop_debug *)p_data_in;
	return sprintf(p_out, "gpe_cop_debug_server %u %u" ONU_CRLF, in->copmsk, in->stepcnt);
}

int dump_gpe_acl_table_entry_set(char *p_out, const void *p_data_in)
{
	struct gpe_acl_table_entry *param;

	param = (struct gpe_acl_table_entry *)p_data_in;
	return sprintf(p_out, "gpe_acl_table_entry_set %u %u \"%u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u\" \"%u %u %u %u %u %u\" %u %u %u %u %u %u" ONU_CRLF, param->acl_filter_index, param->last_entry, param->param1[0], param->param1[1], param->param1[2], param->param1[3], param->param1[4], param->param1[5], param->param1[6], param->param1[7], param->param1[8], param->param1[9], param->param1[10], param->param1[11], param->param1[12], param->param1[13], param->param1[14], param->param1[15], param->param2[0], param->param2[1], param->param2[2], param->param2[3], param->param2[4], param->param2[5], param->param1_mask, param->param1_type, param->param2_type, param->fid, param->fid_en, param->ingress_port_enable);
}

int dump_gpe_acl_table_entry_get(char *p_out, const void *p_data_in)
{
	struct gpe_acl_table_entry_idx *in;

	in = (struct gpe_acl_table_entry_idx *)p_data_in;
	return sprintf(p_out, "gpe_acl_table_entry_get %u" ONU_CRLF, in->acl_filter_index);
}

int dump_gpe_acl_table_entry_delete(char *p_out, const void *p_data_in)
{
	struct gpe_acl_table_entry_idx *param;

	param = (struct gpe_acl_table_entry_idx *)p_data_in;
	return sprintf(p_out, "gpe_acl_table_entry_delete %u" ONU_CRLF, param->acl_filter_index);
}

int dump_lan_gphy_firmware_download(char *p_out, const void *p_data_in)
{
	struct lan_gphy_fw *param;

	param = (struct lan_gphy_fw *)p_data_in;
	return sprintf(p_out, "lan_gphy_firmware_download \"%s\"" ONU_CRLF, param->fw_name);
}

int dump_lan_init(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "lan_init" ONU_CRLF);
}

int dump_lan_cfg_set(char *p_out, const void *p_data_in)
{
	struct lan_cfg *param;

	param = (struct lan_cfg *)p_data_in;
	return sprintf(p_out, "lan_cfg_set %u \"%d %d %d %d\" %u %u %u" ONU_CRLF, param->mux_mode, param->mdio_dev_addr[0], param->mdio_dev_addr[1], param->mdio_dev_addr[2], param->mdio_dev_addr[3], param->mdio_data_rate, param->mdio_short_preamble_en, param->mdio_en);
}

int dump_lan_cfg_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "lan_cfg_get" ONU_CRLF);
}

int dump_lan_port_cfg_set(char *p_out, const void *p_data_in)
{
	struct lan_port_cfg *param;

	param = (struct lan_port_cfg *)p_data_in;
	return sprintf(p_out, "lan_port_cfg_set %u %u %u %u %u %u %u %u %hu %u %u" ONU_CRLF, param->index, param->uni_port_en, param->mode, param->duplex_mode, param->flow_control_mode, param->speed_mode, param->tx_clk_dly, param->rx_clk_dly, param->max_frame_size, param->lpi_enable, param->autoneg_mode);
}

int dump_lan_port_cfg_get(char *p_out, const void *p_data_in)
{
	struct lan_port_index *in;

	in = (struct lan_port_index *)p_data_in;
	return sprintf(p_out, "lan_port_cfg_get %u" ONU_CRLF, in->index);
}

int dump_lan_port_enable(char *p_out, const void *p_data_in)
{
	struct lan_port_index *param;

	param = (struct lan_port_index *)p_data_in;
	return sprintf(p_out, "lan_port_enable %u" ONU_CRLF, param->index);
}

int dump_lan_port_disable(char *p_out, const void *p_data_in)
{
	struct lan_port_index *param;

	param = (struct lan_port_index *)p_data_in;
	return sprintf(p_out, "lan_port_disable %u" ONU_CRLF, param->index);
}

int dump_lan_loop_cfg_set(char *p_out, const void *p_data_in)
{
	struct lan_loop_cfg *param;

	param = (struct lan_loop_cfg *)p_data_in;
	return sprintf(p_out, "lan_loop_cfg_set %u %u %u %u %u %u" ONU_CRLF, param->index, param->mac_egress_loop_en, param->mii_ingress_loop_en, param->sgmii_ingress_loop_en, param->phy_ingress_loop_en, param->phy_egress_loop_en);
}

int dump_lan_loop_cfg_get(char *p_out, const void *p_data_in)
{
	struct lan_port_index *in;

	in = (struct lan_port_index *)p_data_in;
	return sprintf(p_out, "lan_loop_cfg_get %u" ONU_CRLF, in->index);
}

int dump_lan_port_status_get(char *p_out, const void *p_data_in)
{
	struct lan_port_index *in;

	in = (struct lan_port_index *)p_data_in;
	return sprintf(p_out, "lan_port_status_get %u" ONU_CRLF, in->index);
}

int dump_lan_counter_get(char *p_out, const void *p_data_in)
{
	struct lan_cnt_interval *in;

	in = (struct lan_cnt_interval *)p_data_in;
	return sprintf(p_out, "lan_counter_get %u %llu %u" ONU_CRLF, in->index, in->reset_mask, in->curr);
}

int dump_lan_counter_reset(char *p_out, const void *p_data_in)
{
	struct lan_cnt_interval *param;

	param = (struct lan_cnt_interval *)p_data_in;
	return sprintf(p_out, "lan_counter_reset %u %llu %u" ONU_CRLF, param->index, param->reset_mask, param->curr);
}

int dump_lan_counter_threshold_set(char *p_out, const void *p_data_in)
{
	struct lan_cnt_threshold *param;

	param = (struct lan_cnt_threshold *)p_data_in;
	return sprintf(p_out, "lan_counter_threshold_set %u %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu %llu" ONU_CRLF, param->index, param->threshold.rx.rx_frames, param->threshold.rx.rx_bytes, param->threshold.rx.rx_undersized_frames, param->threshold.rx.rx_oversized_frames, param->threshold.rx.rx64, param->threshold.rx.rx65, param->threshold.rx.rx128, param->threshold.rx.rx256, param->threshold.rx.rx512, param->threshold.rx.rx1024, param->threshold.rx.rx1519, param->threshold.rx.buffer_overflow, param->threshold.rx.dma_write_error, param->threshold.rx.mac_error, param->threshold.sce.rx_bc_frames, param->threshold.sce.rx_mc_frames, param->threshold.sce.rx_uc_frames, param->threshold.sce.rx_non_pppoe_frames, param->threshold.tx.tx_frames, param->threshold.tx.tx_bytes, param->threshold.tx.tx64, param->threshold.tx.tx65, param->threshold.tx.tx128, param->threshold.tx.tx256, param->threshold.tx.tx512, param->threshold.tx.tx1024, param->threshold.tx.tx1519, param->threshold.mac.rx_fcs_err, param->threshold.mac.algn_err, param->threshold.mac.rx_frag, param->threshold.mac.rx_buff_overflow_events, param->threshold.mac.tx_frag, param->threshold.mac.tx_jabber_frames, param->threshold.mac.tx_drop_events, param->threshold.mac.tx_buff_overflow_events, param->threshold.mac.tx_mac_err, param->threshold.mac.delay_exceeded, param->threshold.mac.exc_col, param->threshold.mac.late_col, param->threshold.mac.sgl_col, param->threshold.mac.mul_col, param->threshold.mac.def_trans, param->threshold.mac.carrier_sense_err, param->threshold.mac.sqe_test);
}

int dump_lan_counter_threshold_get(char *p_out, const void *p_data_in)
{
	struct lan_port_index *in;

	in = (struct lan_port_index *)p_data_in;
	return sprintf(p_out, "lan_counter_threshold_get %u" ONU_CRLF, in->index);
}

int dump_lan_tca_get(char *p_out, const void *p_data_in)
{
	struct uni_port_id *in;

	in = (struct uni_port_id *)p_data_in;
	return sprintf(p_out, "lan_tca_get %u" ONU_CRLF, in->uni_port_id);
}

int dump_wol_cfg_set(char *p_out, const void *p_data_in)
{
	struct wol_cfg *param;

	param = (struct wol_cfg *)p_data_in;
	return sprintf(p_out, "wol_cfg_set %u \"%u %u %u %u %u %u\" \"%u %u %u %u %u %u\" %u %u" ONU_CRLF, param->index, param->wol_addr[0], param->wol_addr[1], param->wol_addr[2], param->wol_addr[3], param->wol_addr[4], param->wol_addr[5], param->wol_password[0], param->wol_password[1], param->wol_password[2], param->wol_password[3], param->wol_password[4], param->wol_password[5], param->wol_password_en, param->wol_interrupt_en);
}

int dump_wol_cfg_get(char *p_out, const void *p_data_in)
{
	struct lan_port_index *in;

	in = (struct lan_port_index *)p_data_in;
	return sprintf(p_out, "wol_cfg_get %u" ONU_CRLF, in->index);
}

int dump_wol_status_get(char *p_out, const void *p_data_in)
{
	struct lan_port_index *in;

	in = (struct lan_port_index *)p_data_in;
	return sprintf(p_out, "wol_status_get %u" ONU_CRLF, in->index);
}

int dump_mdio_data_read(char *p_out, const void *p_data_in)
{
	struct mdio *in;

	in = (struct mdio *)p_data_in;
	return sprintf(p_out, "mdio_data_read %u %u" ONU_CRLF, in->addr_dev, in->addr_reg);
}

int dump_mdio_data_write(char *p_out, const void *p_data_in)
{
	struct mdio_write *param;

	param = (struct mdio_write *)p_data_in;
	return sprintf(p_out, "mdio_data_write %u %u %hu" ONU_CRLF, param->addr_dev, param->addr_reg, param->data);
}

int dump_mdio_enable(char *p_out, const void *p_data_in)
{
	struct mdio_en *param;

	param = (struct mdio_en *)p_data_in;
	return sprintf(p_out, "mdio_enable %u" ONU_CRLF, param->mode);
}

int dump_mdio_disable(char *p_out, const void *p_data_in)
{
	struct mdio_dis *param;

	param = (struct mdio_dis *)p_data_in;
	return sprintf(p_out, "mdio_disable %u" ONU_CRLF, param->mode);
}

int dump_mmd_data_read(char *p_out, const void *p_data_in)
{
	struct mmd *in;

	in = (struct mmd *)p_data_in;
	return sprintf(p_out, "mmd_data_read %u %u %hu" ONU_CRLF, in->addr_dev, in->mmd_sel, in->mmd_addr);
}

int dump_mmd_data_write(char *p_out, const void *p_data_in)
{
	struct mmd_write *param;

	param = (struct mmd_write *)p_data_in;
	return sprintf(p_out, "mmd_data_write %u %u %hu %hu" ONU_CRLF, param->addr_dev, param->mmd_sel, param->mmd_addr, param->data);
}

int dump_lan_port_capability_cfg_set(char *p_out, const void *p_data_in)
{
	struct lan_port_capability_cfg *param;

	param = (struct lan_port_capability_cfg *)p_data_in;
	return sprintf(p_out, "lan_port_capability_cfg_set %u %u %u %u %u %u %u %u %u" ONU_CRLF, param->index, param->full_duplex, param->half_duplex, param->mbit_10, param->mbit_100, param->mbit_1000, param->sym_pause, param->asym_pause, param->eee);
}

int dump_lan_port_capability_cfg_get(char *p_out, const void *p_data_in)
{
	struct lan_port_index *in;

	in = (struct lan_port_index *)p_data_in;
	return sprintf(p_out, "lan_port_capability_cfg_get %u" ONU_CRLF, in->index);
}

int dump_ploam_init(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "ploam_init" ONU_CRLF);
}

int dump_ploam_state_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "ploam_state_get" ONU_CRLF);
}

int dump_ploam_state_set(char *p_out, const void *p_data_in)
{
	struct ploam_state_data_set *param;

	param = (struct ploam_state_data_set *)p_data_in;
	return sprintf(p_out, "ploam_state_set %u" ONU_CRLF, param->state);
}

int dump_onu_event_enable_set(char *p_out, const void *p_data_in)
{
	struct onu_event_mask *param;

	param = (struct onu_event_mask *)p_data_in;
	return sprintf(p_out, "onu_event_enable_set %u" ONU_CRLF, param->val);
}

int dump_onu_event_enable_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "onu_event_enable_get" ONU_CRLF);
}

#if defined(INCLUDE_DEBUG_SUPPORT)
int dump_onu_debug_level_set(char *p_out, const void *p_data_in)
{
	struct onu_dbg_level *param;

	param = (struct onu_dbg_level *)p_data_in;
	return sprintf(p_out, "onu_debug_level_set %u" ONU_CRLF, param->level);
}

int dump_onu_debug_level_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "onu_debug_level_get" ONU_CRLF);
}

#endif /* defined(INCLUDE_DEBUG_SUPPORT) */
int dump_onu_version_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "onu_version_get" ONU_CRLF);
}

int dump_onu_register_set(char *p_out, const void *p_data_in)
{
	struct onu_reg_addr_val *param;

	param = (struct onu_reg_addr_val *)p_data_in;
	return sprintf(p_out, "onu_register_set %u %lu %u" ONU_CRLF, param->form, param->address, param->value);
}

int dump_onu_register_get(char *p_out, const void *p_data_in)
{
	struct onu_reg_addr *param_in;

	param_in = (struct onu_reg_addr *)p_data_in;
	return sprintf(p_out, "onu_register_get %u %lu" ONU_CRLF, param_in->form, param_in->address);
}

int dump_onu_test_mode_set(char *p_out, const void *p_data_in)
{
	struct onu_test_mode *param;

	param = (struct onu_test_mode *)p_data_in;
	return sprintf(p_out, "onu_test_mode_set \"%s\"" ONU_CRLF, param->mode);
}

int dump_onu_line_enable_set(char *p_out, const void *p_data_in)
{
	struct onu_enable *param;

	param = (struct onu_enable *)p_data_in;
	return sprintf(p_out, "onu_line_enable_set %u" ONU_CRLF, param->enable);
}

int dump_onu_line_enable_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "onu_line_enable_get" ONU_CRLF);
}

int dump_onu_sync_time_set(char *p_out, const void *p_data_in)
{
	struct onu_sync_time *param;

	param = (struct onu_sync_time *)p_data_in;
	return sprintf(p_out, "onu_sync_time_set %u %u" ONU_CRLF, param->interval_enable, param->interval_supervision_ext);
}

int dump_onu_sync_time_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "onu_sync_time_get" ONU_CRLF);
}

int dump_onu_counters_cfg_set(char *p_out, const void *p_data_in)
{
	struct onu_cnt_cfg *param;

	param = (struct onu_cnt_cfg *)p_data_in;
	return sprintf(p_out, "onu_counters_cfg_set %u" ONU_CRLF, param->disable_update);
}

int dump_onu_counters_cfg_get(char *p_out, const void *p_data_in)
{

	return sprintf(p_out, "onu_counters_cfg_get" ONU_CRLF);
}

int dump_onu_counters_reset(char *p_out, const void *p_data_in)
{
	struct onu_cnt_reset *param;

	param = (struct onu_cnt_reset *)p_data_in;
	return sprintf(p_out, "onu_counters_reset %u" ONU_CRLF, param->curr);
}


/*! @} */

#endif