/**
*	@brief 		Control API function of Linux driver
*	@since		2009/01/08
*	@note		None
*	@attention	None
*	<B><I>COPYRIGHT FUJITSU LIMITED 2009</I></B>
*/

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */

#include <stdlib.h>
#include <unistd.h>
#include "FmbCmn.h"

#define FMB_MAX_ARG_NUM 20
#define FMB_MAX_STRING_LEN 256
#define PROG_NAME		"fmb_ioctl_apl"

#define BANK_SIZE (512 * 1024)
#define FMB_LSIBIN_PUT 1
#define FMB_LSIBIN_GET 2
#define SWAPW(x)	(((x>>8)&0x00ff) | ((x<<8)&0xff00))

static unsigned short s_vmsg_mode = 0xFFFF;
static unsigned short s_vmsg_seqend = 0xFFFF;
static unsigned short s_smsg_body = 0xFFFF;
static unsigned int vudata_cnt = 0;
static unsigned long internal_info_data = 0;

static enum FMBStremModeEnum	s_Strmmode = FMBEnmNothing;

extern const struct jump_head_table g_internal_jump_table[];

static void usage_print(struct ioctl_private_inf* pri_inf_p);
static void result_print(struct ioctl_private_inf* pri_inf_p);
static void api_ditail_err_print(struct ioctl_private_inf* pri_inf_p);
static void api_timeout_print(struct ioctl_private_inf* pri_inf_p);
static void error_print(struct ioctl_private_inf* pri_inf_p , int err);
static int check_unsigned_string(const char* string);
static struct param_check param_check_unsignlong(char* input_param);
static struct param_check param_check_unsignshort(char* input_param);
static struct param_check param_check_signlong(char* input_param);
static void data_dump(unsigned short max_num, unsigned short* msg);

static BOOL setCmdtable(char* lineString,struct SceTableType* cmdScenariop);

static 	unsigned short			vdatabuf[141] = {
						0x0000,		/* mode value (default) */
						0x0000,		/* inter_gop_gap value (default) */
						0x0002,		/* tfrff value (default) */
						0x0000,		/* extra_info_bit value (default) */
						0x000a,		/* vdisptime value (default) */
						0x0000,		/* sub_mode value (default) */
						0x0000		/* vudata_length value (default) */
						};
static	unsigned long			vidbuf[141] = {
						0x00060001,	/* parameter id for mode */
						0x00060002,	/* parameter id for inter_gop_gap */
						0x00060004,	/* parameter id for tfrff */
						0x00060005,	/* parameter id for extra_info_bit */
						0x00060006,	/* parameter id for vdisptime */
						0x00060008,	/* parameter id for sub_mode */
						0x00060009	/* parameter id for vudata_length */
						};

static	unsigned short			adatabuf[11] = {
						0x0000,		/* a_mute value (default) */
						0x0000,		/* a_ch value (default) */
						0x8000,		/* lch_scale value (default) */
						0x8000,		/* rch_scale value (default) */
						0x0002,		/* d_ac3_compression value (default) */
						0x0080,		/* d_ac3_dynrng_cut value (default) */
						0x0080,		/* d_ac3_dynrng_boost value (default) */
						0x8000,		/* lsch_scale value (default) */
						0x8000,		/* rsch_scale value (default) */
						0x8000,		/* cch_scale value (default) */
						0x8000,		/* lfech_scale value (default) */
						};
static	unsigned long			aidbuf[11] = {
						0x00070001,	/* parameter id for a_mute */
						0x00070002,	/* parameter id for a_ch */
						0x00070003,	/* parameter id for lch_scale */
						0x00070004,	/* parameter id for rch_scale */
						0x00070005,	/* parameter id for d_ac3_compression */
						0x00070006,	/* parameter id for d_ac3_dynrng_boost */
						0x00070007,	/* parameter id for d_ac3_dynrng_cut */
						0x00070008,	/* parameter id for lsch_scale */
						0x00070009,	/* parameter id for rsch_scale */
						0x0007000a,	/* parameter id for cch_scale */
						0x0007000b	/* parameter id for lfech_scale */
						};


/**
 *  @brief	Get the video message mode.
 *
 *  @param[in]	none
 *  @return	mode	video message mode
 *  @note	None
 *  @attention	None
 */
unsigned short FmbgetVmode( void )
{
	unsigned short mode;

	mode = s_vmsg_mode;
	s_vmsg_mode = 0xFFFF;

	return mode;
}
/**
 *  @brief	Get the video message seq end.
 *
 *  @param[in]	none
 *  @return	mode	video message seq end
 *  @note	None
 *  @attention	None
 */
unsigned short FmbgetVseqend( void )
{
	unsigned short seqend;

	seqend = s_vmsg_seqend;
	s_vmsg_seqend = 0xFFFF;

	return seqend;
}
/**
 *  @brief	Get the system message body.
 *
 *  @param[in]	none
 *  @return	mode	system message body
 *  @note	None
 *  @attention	None
 */
unsigned short FmbgetSbody( void )
{
	unsigned short body;

	body = s_smsg_body;
	s_smsg_body = 0xFFFF;

	return body;
}

/**
 *  @brief	Get the argument.
 *
 *  @param[in]	srchchar 		Serch character code
 *  @param[in]	argc			input character code counter
 *  @param[in,out]	argv		input character codes
 *  @return	index	argument index
 *  @note	None
 *  @attention	None
 */
int FmbgetArg(char* sarchchar , int argc, char** argv)
{
	int i;
	for (i=1 ; i < argc ; i++){
		if ((strcmp(argv[i], sarchchar) == 0)) {
			if ( (i+1) < argc ){
				return (i+1);
			}
		}
	}
	return 0;

}
/**
 *  @brief	Get the argument.
 *
 *  @param[in]	srchchar 		Serch character code
 *  @param[in]	argc			input character code counter
 *  @param[in,out]	argv		input character codes
 *  @return	index	argument index
 *  @note	None
 *  @attention	None
 */
int FmbgetArgOwn(char* sarchchar , int argc, char** argv)
{
	int i;
	for (i=1 ; i < argc ; i++){
		if ((strcmp(argv[i], sarchchar) == 0)) {
				return i;
		}
	}
	return 0;

}
/**
 *  @brief	Create the argument.
 *
 *  @param[in]	keybuff 		buffer
 *  @param[out]	argvStr			argument messages
 *  @return	argument count
 *  @note	None
 *  @attention	None
 */

int FmbCreateArgment(char* keybuff,char** argvStr)
{
	int argc;
	int search_flg;
	int i,j;
	int len;

	FMB_FUNC(TRUE);

	len = strlen(keybuff);
	argc=0;
	search_flg = ON;
	j = 0;
	for(i=0;i<(len+1);i++){
		if ( keybuff[i]=='\n' || keybuff[i]=='\r' || keybuff[i]=='\0'){
			if (search_flg==OFF){
				argvStr[argc][j]=0x00;
			}
			argc++;
			break;
		}
		if (keybuff[i] != ' '){
			if (search_flg==ON){
				search_flg = OFF;
				argc++;
				argvStr[argc][j]=keybuff[i];
				j++;
			}
			else{
				argvStr[argc][j]=keybuff[i];
				j++;
			}
		}
		else{
			if (search_flg==OFF){
				argvStr[argc][j]=0x00;
				search_flg = ON;
				j=0;
			}
		}
	}

	LogFmb("argc :%d",argc);
	for (i=1;i<argc;i++) {
		LogFmb("argv[%d]:%s ",i,argvStr[i]);
	}

	FMB_FUNC(FALSE);

	return argc;


}
/**
 *  @brief	Create the scenario of script.
 *
 *  @param[in]	cmdbuff 		buffer
 *  @return	    pointer on the scenario of script
 *  @note	    None
 *  @attention	None
 */

struct SceTableType* FmbCeateCommandScenario(char* cmdbuff)
{
	int i;
	int ret;
	char		argvStr[FMB_MAX_ARG_NUM][FMB_MAX_STRING_LEN];
	char*		argv[FMB_MAX_ARG_NUM];
	int			argc=1;
	FILE *fp;
	char s[FMB_KEYBUFF_MAX_CHAR];
	int lCnt=0;
	struct SceTableType* cmdTablep=NULL;

    for (i=1;i<FMB_MAX_ARG_NUM;i++){
        argv[i] = argvStr[i];
    }
	argc=FmbCreateArgment((char*)cmdbuff,argv);

	if( argc < 3 ){
		fprintOut(stdout, "scrpt filename\n");
		FmbErrPrintUsr("Illegal parameter.",__FILE__,__LINE__);
		free(cmdbuff);
		return NULL;
	}

	if((FmbCheckSenario()) == FALSE) {
		fprintOut(stdout, "error: script is still being executed.\n");
		return NULL;
	}

	if( (fp = fopen(argv[2],"r")) == NULL){
		FmbErrPrint("Illegal filepath.",__FILE__,__LINE__);
		free(cmdbuff);
		return NULL;
	}

	while (fgets(s, FMB_KEYBUFF_MAX_CHAR, fp) != NULL) {
		if ( s[0] == ' ' || s[0] == '/' || s[0] == '#' || s[0] == '\n' || s[0] == '\r'){
			continue;
		}
		lCnt++;
	}
	if(lCnt!=0){
		cmdTablep = malloc( (sizeof(struct SceTableType)) * (lCnt+1) );
		if(cmdTablep==NULL){
			FmbErrPrint("Command Buffer malloc NG.",__FILE__,__LINE__);
			fclose(fp);
			free(cmdbuff);
			return NULL;
		}
		memset(cmdTablep,0,(sizeof(struct SceTableType)) * (lCnt+1));
		rewind(fp);

		lCnt=0;
		i=0;
		while (fgets(s, FMB_KEYBUFF_MAX_CHAR, fp) != NULL) {
			i++;
			if ( s[0] == ' ' || s[0] == '/' || s[0] == '#' || s[0] == '\n' || s[0] == '\r'){
				continue;
			}
			s[FMB_KEYBUFF_MAX_CHAR-1]='\0'; 
			ret = setCmdtable(s,&cmdTablep[lCnt]);
			if (ret != TRUE){
				FmbErrPrintUsr("Illegal command.",s,i);
				fclose(fp);
				free(cmdbuff);
				free(cmdTablep);
				return NULL;
			}
			lCnt++;
		}
	}


	fclose(fp);
	free(cmdbuff);
	return cmdTablep;
}

BOOL setCmdtable(char* lineString,struct SceTableType* cmdScenariop)
{
	int			i;
	char		argvStr[FMB_MAX_ARG_NUM][FMB_MAX_STRING_LEN];
	char*		argv[FMB_MAX_ARG_NUM];
	int			argc=1;
	int len;
	char*		cmdbuf;
	struct param_check	param_check_out;

    for (i=1;i<FMB_MAX_ARG_NUM;i++){
        argv[i] = argvStr[i];
    }
	argc=FmbCreateArgment((char*)lineString,argv);
	if(argc<2) return FALSE;

	if ( strcmp("pause",argv[1])==0 ) {
		cmdScenariop->scenarioFunc = WaitCmdInputKeyFor;
		cmdScenariop->arg1 = SCE_IGNORE;
		cmdScenariop->arg2 = SCE_IGNORE;
		cmdScenariop->arg3 = SCE_IGNORE;
	}
	else if( strcmp("wait",argv[1])==0) {
		if (argc<3)	return FALSE;
		if ( strcmp("mode",argv[2])==0) {
			if (argc<4)	return FALSE;
			param_check_out = param_check_unsignshort(argv[3]);
			if (param_check_out.result != OK) {
				return FALSE;
			}
			cmdScenariop->scenarioFunc = WaitCmdVideoMsgFor;
			cmdScenariop->arg1 = param_check_out.short_cnvdata;
			cmdScenariop->arg2 = SCE_IGNORE;
			cmdScenariop->arg3 = SCE_IGNORE;

		}else if ( strcmp("seqend",argv[2])==0) {
			if (argc<4)	return FALSE;
			param_check_out = param_check_unsignshort(argv[3]);
			if (param_check_out.result != OK) {
				return FALSE;
			}
			cmdScenariop->scenarioFunc = WaitCmdVideoMsgFor;
			cmdScenariop->arg1 = SCE_IGNORE;
			cmdScenariop->arg2 = SCE_IGNORE;
			cmdScenariop->arg3 = param_check_out.short_cnvdata;

		}else if ( strcmp("symsg",argv[2])==0) {
			cmdScenariop->scenarioFunc = WaitCmdSysMsgFor;
			cmdScenariop->arg1 = SCE_IGNORE;
			cmdScenariop->arg2 = SCE_IGNORE;
			cmdScenariop->arg3 = SCE_IGNORE;
			if (argc>3){
				param_check_out = param_check_unsignshort(argv[3]);
				if (param_check_out.result != OK) {
					return FALSE;
				}
				cmdScenariop->arg1 = param_check_out.short_cnvdata;
			}
			if (argc>4){
				param_check_out = param_check_unsignshort(argv[4]);
				if (param_check_out.result != OK) {
					return FALSE;
				}
				cmdScenariop->arg2 = param_check_out.short_cnvdata;
			}
			if (argc>5){
				param_check_out = param_check_unsignshort(argv[5]);
				if (param_check_out.result != OK) {
					return FALSE;
				}
				cmdScenariop->arg3 = param_check_out.short_cnvdata;
			}

		}else if ( strcmp("syack",argv[2])==0) {
			cmdScenariop->scenarioFunc = WaitCmdSysAckFor;
			cmdScenariop->arg1 = SCE_IGNORE;
			cmdScenariop->arg2 = SCE_IGNORE;
			cmdScenariop->arg3 = SCE_IGNORE;
			if (argc>3){
				param_check_out = param_check_unsignshort(argv[3]);
				if (param_check_out.result != OK) {
					return FALSE;
				}
				cmdScenariop->arg1 = param_check_out.short_cnvdata;
			}

		}else if ( strcmp("strm",argv[2])==0) {
			if (argc<4)	return FALSE;
			if ( strcmp("snd",argv[3])==0) {
				cmdScenariop->scenarioFunc = WaitCmdThreadEndFor;
				cmdScenariop->arg1 = (int)FMBEnmStreamSend;
				cmdScenariop->arg2 = SCE_IGNORE;
				cmdScenariop->arg3 = SCE_IGNORE;

			}else if ( strcmp("rcv",argv[3])==0) {
				cmdScenariop->scenarioFunc = WaitCmdThreadEndFor;
				cmdScenariop->arg1 = (int)FMBEnmStreamRcv;
				cmdScenariop->arg2 = SCE_IGNORE;
				cmdScenariop->arg3 = SCE_IGNORE;

			}else{
				return FALSE;
			}
		}else{
			return FALSE;
		}
	}
	else{
		len = strlen(lineString);
		if (len==0) return FALSE;
		cmdbuf = malloc(len);
		if (cmdbuf==NULL) return FALSE;
		memcpy(cmdbuf,lineString,len);
		cmdScenariop->scenarioFunc = FmbCommandSend;
		cmdScenariop->arg1 = (int)cmdbuf;
		cmdScenariop->arg2 = SCE_IGNORE;
		cmdScenariop->arg3 = SCE_IGNORE;

	}

	return TRUE; /* pgr0524 */
}
/**
 *  @brief	Print the error message.
 *
 *  @param[in]	lib_inf 		Fmb Lib information
 *  @param[in]	comment			error messages
 *  @param[in]	file			__FILE__
 *  @param[in]	line			__LINE__
 *  @return	None
 *  @note	None
 *  @attention	None
 */
void FmbErrPrint( char* comment , char* file , int line)
{
	char*		err_cause;

	err_cause = strerror(errno);
	fprintOut(stdout, "%s at :%s(%d) : %s \n", comment, file , line , err_cause);
	return;
}

/**
 *  @brief	Print the error message user.
 *
 *  @param[in]	lib_inf 		Fmb Lib information
 *  @param[in]	comment			error messages
 *  @param[in]	file			__FILE__
 *  @param[in]	line			__LINE__
 *  @return	None
 *  @note	None
 *  @attention	None
 */
void FmbErrPrintUsr(char* comment , char* file , int line)
{

	fprintOut(stdout, "%s at :%s(%d) \n", comment, file , line );
	return;
}

/**
 *  @brief	main of the dirver control application.
 *
 *  @param[in]	argc		input character code counter
 *  @param[in]	argv		input character code
 *				argv[1]		option
 *  @return	0		Normal end
 *  @return	-1		Abnormal end
 *  @note	None
 *  @attention	None
 */
enum SceResultEnum FmbCommandSend(HANDLE sceHandle, unsigned long cmdBuf, unsigned long dummy1, unsigned long dummy2)
//int FmbIoctlmain(struct fmb_lib_inf lib_inf, int argc, char** argv)
{
	int i;
	int		res;
	struct ioctl_private_inf private_inf;
	FUNCTION	prgFunc=NULL;
	char		argvStr[FMB_MAX_ARG_NUM][FMB_MAX_STRING_LEN];
	char*		argv[FMB_MAX_ARG_NUM];
	int			argc=1;

	/* 0 Clear */
	memset (&private_inf , 0 , sizeof(private_inf));

    for (i=1;i<FMB_MAX_ARG_NUM;i++){
        argv[i] = argvStr[i];
    }
	argc=FmbCreateArgment((char*)cmdBuf,argv);

	fprintOut(stdout, ">");
	for( i=0 ; i<(argc-1) ; i++){
		/* printing */
		fprintOut(stdout, "%s ",argv[i+1]);
	}
	fprintOut(stdout, "\n");

	/* serch function table */
	i=0;
	while (g_internal_jump_table[i].function_addr != NULL) {
		if(strcmp(argv[1], g_internal_jump_table[i].option_parameter) == 0) {
			prgFunc = g_internal_jump_table[i].function_addr;
			break;
		} else {
			i++;	/* next */
		}
	}

	private_inf.cmd_id = i;
	private_inf.fd = SceGetDevHandle(sceHandle);

	if (prgFunc != NULL) {
		res = prgFunc( &private_inf, argc, argv );	/* call function */
	}else{
		res = NG_OPTION_ERROR;
	}

	switch (res){
	case OK:
		result_print(&private_inf);
		break;
	case NG_USAGE:
		usage_print(&private_inf);
		break;
	default:
		error_print(&private_inf,res);
		break;
	}

	if (private_inf.private_buf != NULL){
		free(private_inf.private_buf);
	}

	free((char*)cmdBuf);
	return SceEnmResultSyncEnd;


}
/**
 *  @brief	Print the usage message.
 *
 *  @param[in]	pri_inf_p		private information
 *  @return	    None
 *  @note	None
 *  @attension	None
 */

void FmbUsageMainPrint()
{
	char* comment;

	/* USAGE Format */
	comment = "    gparam  id \n"
			"    sparam  id  value                                           \n"
			"    scmd    cmd  sub_cmd  body [sync]                           \n"
			"    svparam id  value                                           \n"
			"    vcmd                                                        \n"
			"    saparam id  value                                           \n"
			"    acmd                                                        \n"
			"    sack    [timeout]                                           \n"
			"    rcbuf   [type]                                              \n"
			"    smsg    [timeout]                                           \n"
			"    vmsg    [timeout]                                           \n"
			"    amsg    [timeout]                                           \n"
			"    gfact   [timeout]                                           \n"
			"    rfact   [factor]                                            \n"
			"    async   type [timeout]                                      \n"
			"    glsi    offset                                              \n"
			"    slsi    offset  value [mask_bit]                            \n"
			"    dlsi    offset  size [filename]                             \n"
			"    gpci    type offset                                         \n"
			"    spci    type offset  value                                  \n"
			"    gdata   type                                                \n"
			"    sdata   type  [value]                                       \n"
			"    ver                                                         \n"
			"    strm    set [-fin filename] [-fout filename] [-st start_postion] [-ed end_postion] \n"
			"    strm    start                                               \n"
			"    strm    stop                                                \n"
			"    sleep   value                                             \n"
			"    boot    filename                                            \n"
			"    logstr  filename                                            \n"
			"    logstp                                                      \n"
			"    gopstr  filename                                            \n"
			"    gopstp                                                      \n"
			"    scrpt   filename                                            \n";

	/* printing */
	fprintOut(stdout, comment );

	return ;
}
/**
 *  @brief	Print the start command message.
 *
 *  @param[in]	pri_inf_p		private information
 *  @return	    None
 *  @note	None
 *  @attension	None
 */
void FmbStartCommandPrint(enum FMBCmdEnm   command_id)
{
	char* comment;

	/* USAGE Format */
	switch(command_id){
	case FMB_CMD_WAIT_MODE:
		comment = "[wait mode] : Waiting for the video message mode\n";
		break;
	case FMB_CMD_WAIT_SEQEND:
		comment = "[wait seqend] : Waiting for the video message seqend\n";
		break;
	case FMB_CMD_WAIT_SYMSG:
		comment = "[wait symsg] : Waiting for the system message\n";
		break;
	case FMB_CMD_WAIT_SYACK:
		comment = "[wait syAck] : Waiting for the system ack\n";
		break;
	case FMB_CMD_WAIT_STRM_SEND:
		comment = "[wait strm snd] :Waiting for the stream sending\n";
		break;
	case FMB_CMD_WAIT_STRM_RCV:
		comment = "[wait strm rcv] :Waiting for the stream receiving\n";
		break;
	case FMB_CMD_PAUSE:
		comment = "[pause] :Waiting for the key input\n";
		break;
	default:
		return;
	}

	/* printing */
	fprintOut(stdout, comment );

	return ;
}
/**
 *  @brief	Print the end command message.
 *
 *  @param[in]	command_id		command id
 *  @return	    None
 *  @note	None
 *  @attension	None
 */
void FmbEndCommandPrint(enum FMBCmdEnm   command_id)
{
	char* comment;

	/* USAGE Format */
	switch(command_id){
	case FMB_CMD_WAIT_MODE:
		comment = "[wait mode] : End.\n";
		break;
	case FMB_CMD_WAIT_SEQEND:
		comment = "[wait seqend] : End.\n";
		break;
	case FMB_CMD_WAIT_SYMSG:
		comment = "[wait symsg] : End.\n";
		break;
	case FMB_CMD_WAIT_SYACK:
		comment = "[wait syAck] : End.\n";
		break;
	case FMB_CMD_WAIT_STRM_SEND:
		comment = "[wait strm snd] : End.\n";
		break;
	case FMB_CMD_WAIT_STRM_RCV:
		comment = "[wait strm rcv] : End.\n";
		break;
	case FMB_CMD_PAUSE:
		comment = "[pause] : End.\n";
		break;
	default:
		return;
	}

	/* printing */
	fprintOut(stdout, comment );

	return ;
}

/**
 *  @brief	Print the usage message.
 *
 *  @param[in]	pri_inf_p		private information
 *  @return	    None
 *  @note	None
 *  @attension	None
 */

static void usage_print(struct ioctl_private_inf* pri_inf_p)
{
	char* comment;

	/* USAGE Format */
	switch(pri_inf_p->cmd_id ){
	case FMB_CMD_GPARAM:
		comment = "%s  id \n\n";
		break;
	case FMB_CMD_SPARAM:
		comment = "%s  id  value \n\n";
		break;
	case FMB_CMD_SCMD:
		comment = "%s  cmd  sub_cmd  body [sync] \n\n";
		break;
	case FMB_CMD_SVPARAM:
		comment = "%s  id  value \n\n";
		break;
	case FMB_CMD_VCMD:
		comment = "%s  \n\n";
		break;
	case FMB_CMD_SAPARAM:
		comment = "%s  id  value \n\n";
		break;
	case FMB_CMD_ACMD:
		comment = "%s  \n\n";
		break;
	case FMB_CMD_SACK:
	case FMB_CMD_SMSG:
	case FMB_CMD_VMSG:
	case FMB_CMD_AMSG:
	case FMB_CMD_GFACT:
		comment = "%s  [timeout] \n\n";
		break;
	case FMB_CMD_RCBUF:
		comment = "%s  [type] \n\n"
			"<type>  : type of buffer for reset command \n"
			"           0x0001(bit:00000001) system-group command \n"
			"           0x0002(bit:00000010) video-group command \n"
			"           0x0004(bit:00000100) audio-group command \n\n";
		break;
	case FMB_CMD_RFACT:
		comment = "%s  [factor] \n\n";
		break;
	case FMB_CMD_ASYNC:
		comment = "%s  type [timeout] \n\n"
			"<type>  : type of internal data \n"
			"           0x0000 xerror \n"
			"           0x0001 vudata \n\n";
		break;
	case FMB_CMD_GLSI:
		comment = "%s  offset \n\n";
		break;
	case FMB_CMD_SLSI:
		comment = "%s  offset  value [mask_bit]\n\n";
		break;
	case FMB_CMD_DLSI:
		comment = "%s  offset  size [filename] \n\n";
		break;
	case FMB_CMD_GPCI:
		comment = "%s  type  offset \n"
			"<type>  : type of internal data \n"
			"           0x0000 Base Address0 \n"
			"           0x0001 Base Address1 \n\n";
		break;
	case FMB_CMD_SPCI:
		comment = "%s  type  offset  value \n"
			"<type>  : type of internal data \n"
			"           0x0000 Base Address0 \n"
			"           0x0001 Base Address1 \n\n";
		break;
	case FMB_CMD_GDATA:
		comment = "%s    type \n\n"
			"<type>  : type of internal data \n"
			"           0x0001 encode operation \n"
			"           0x0002 asynchronous notification mask \n"
			"           0x0003 read DMA timer flag\n"
			"           0x0004 write DMA timer flag\n"
			"           0x0005 IRQ Status clear flag\n"
			"           0x0006 VSYNC control\n\n";
		break;
	case FMB_CMD_SDATA:
		comment = "%s    type  [value] \n\n"
			"<type>  : type of internal data \n"
			"           0x0001 encode operation \n"
			"           0x0002 asynchronous notification mask \n"
			"           0x0003 read DMA timer flag\n"
			"           0x0004 write DMA timer flag\n"
			"           0x0005 IRQ Status clear flag\n"
			"           0x0006 VSYNC control \n"
			"<value> : in case of type=0x0001 \n"
			"           0x0000 top field \n"
			"           0x0001 bottom field \n"
			"          in case of type=0x0002 \n"
			"           0x0001 system-group message \n"
			"           0x0002 vedio-group message \n"
			"           0x0004 audio-group message \n"
			"           0x0008 vudata \n"
			"          in case of type=0x0003 or 0x0004 \n"
			"           0x0000 timer off \n"
			"           0x0001 timer on  \n"
			"          in case of type=0x0005 \n"
			"           0x0000 clear \n"
			"           0x0001 not clear \n"
			"          in case of type=0x0006 \n"
			"           0x0000 top/bottom field \n"
			"           0x0001 top field \n"
			"           0x0002 bottom field \n\n";
		break;
	case FMB_CMD_VER:
		comment = "%s  \n\n";
		break;
	case FMB_CMD_STRM:
		comment = "%s directive \n\n"
			"<directive> : directive of stream control\n"
			"               set [-fin filename] [-fout filename] [-st start_postion] [-ed end_postion]\n"
			"               start\n"
			"               stop \n\n";
		break;
	case FMB_CMD_SLEEP:
		comment = "%s  value \n\n";
		break;
	case FMB_CMD_BOOT:
		comment = "%s filename \n\n";
		break;
	case FMB_CMD_LOGSTART:
		comment = "%s filename \n\n";
		break;
	case FMB_CMD_LOGSTOP:
		comment = "%s  \n\n";
		break;
	case FMB_CMD_GOPSTART:
		comment = "%s filename \n\n";
		break;
	case FMB_CMD_GOPSTOP:
		comment = "%s  \n\n";
		break;
	case FMB_CMD_HELP:
		comment = "%s  \n\n";
		break;
	default:
		return;
	}

	/* printing */
	fprintOut(stdout, comment , g_internal_jump_table[pri_inf_p->cmd_id].option_parameter);

	return ;
}

/**
 *  @brief	Print the result message.
 *
 *  @param[in]	pri_inf_p		private information
 *  @return	    None
 *  @note	None
 *  @attension	None
 */

static void result_print(struct ioctl_private_inf* pri_inf_p)
{
	char* comment;
	struct utsname			system_info;
	unsigned int			i = 0;
	unsigned int			num = 0;
	unsigned int			vudata_id = 0;

	/* USAGE Format */
	switch(pri_inf_p->cmd_id ){
	case FMB_CMD_GPARAM:
	case FMB_CMD_SPARAM:
		comment = "[%s]   : id:0x%08lx  value:0x%04x \n";
		printOut (comment , g_internal_jump_table[pri_inf_p->cmd_id].option_parameter,
				pri_inf_p->private_ldata , pri_inf_p->private_data);
		break;
	case FMB_CMD_SCMD:
		if (pri_inf_p->cmd_str.lib_cmd_sys_info.cmd_sys_info.sync == FMB_MODE_SYNC) {
			comment = "[%s]     : cmd:0x%04x  sub_cmd:0x%04x  body:0x%04x  \n"
					  "             cack:0x%04x  sub_cack:0x%04x \n";
			printOut (comment , g_internal_jump_table[pri_inf_p->cmd_id].option_parameter,
						pri_inf_p->cmd_str.lib_cmd_sys_info.id ,
						pri_inf_p->cmd_str.lib_cmd_sys_info.sub_id,
						pri_inf_p->cmd_str.lib_cmd_sys_info.cmd_sys_info.body,
						pri_inf_p->cmd_str.lib_cmd_sys_info.cmd_sys_info.id ,
						pri_inf_p->cmd_str.lib_cmd_sys_info.cmd_sys_info.sub_id);
		} else {
			comment = "[%s]     : cmd:0x%04x  sub_cmd:0x%04x  body:0x%04x  distinct:0x%08x \n";
			printOut (comment , g_internal_jump_table[pri_inf_p->cmd_id].option_parameter,
						pri_inf_p->cmd_str.lib_cmd_sys_info.id ,
						pri_inf_p->cmd_str.lib_cmd_sys_info.sub_id,
						pri_inf_p->cmd_str.lib_cmd_sys_info.cmd_sys_info.body,
						(unsigned int)pri_inf_p->cmd_str.lib_cmd_sys_info.cmd_sys_info.distinct);
		}
		break;
	case FMB_CMD_VCMD:
		comment = "[%s]     : mode:0x%04x  sub_mode:0x%04x \n"
				  "             extra_info_bit:0x%04x  vdisptime:0x%04x \n"
				  "             inter_gop_gap:0x%04x  tfrff:0x%04x  vudata_length:0x%04x \n";
		printOut (comment , g_internal_jump_table[pri_inf_p->cmd_id].option_parameter,
				pri_inf_p->private_buf[0], pri_inf_p->private_buf[5], pri_inf_p->private_buf[3],
				pri_inf_p->private_buf[4], pri_inf_p->private_buf[1], pri_inf_p->private_buf[2],
				pri_inf_p->private_buf[6]);
		for (i = 0; i < vudata_cnt; i += 1) {
			vudata_id = vidbuf[7 + i];
			num = (vudata_id * 2) - 0xC001C;
			if ( i%4 == 0 ){
				if (i+1 == vudata_cnt){
					printOut ("             vudata[%02x]:0x%04x\n", num, pri_inf_p->private_buf[7+i]);
				}
				else {
					printOut ("             vudata[%02x]:0x%04x", num, pri_inf_p->private_buf[7+i]);
				}
			}
			else if (i+1 == vudata_cnt){
				printOut("  vudata[%02x]:0x%04x\n",num, pri_inf_p->private_buf[7+i]);
			}
			else if (i%4 == 3){
				printOut("  vudata[%02x]:0x%04x\n",num, pri_inf_p->private_buf[7+i]);
			}
			else {
				printOut("  vudata[%02x]:0x%04x",num, pri_inf_p->private_buf[7+i]);
			}
		}
		vudata_cnt = 0;
		break;
	case FMB_CMD_SVPARAM:
		comment = "[%s]   : id:0x%08lx  value:0x%04x \n";
		printOut (comment , g_internal_jump_table[pri_inf_p->cmd_id].option_parameter,
				pri_inf_p->private_ldata , pri_inf_p->private_data);
		break;
	case FMB_CMD_ACMD:
		comment = "[%s]     : a_mute:0x%04x  a_ch:0x%04x\n"
				  "             lch_scale:0x%04x  rch_scale:0x%04x  lsch_scale:0x%04x \n"
				  "             rsch_scale:0x%04x  cch_scale:0x%04x  lfech_scale:0x%04x \n"
				  "             d_ac3_compression:0x%04x  d_ac3_dynrng_cut:0x%04x \n"
				  "             d_ac3_dynrng_boost:0x%04x \n";
		printOut (comment , g_internal_jump_table[pri_inf_p->cmd_id].option_parameter,
				pri_inf_p->private_buf[0], pri_inf_p->private_buf[1], pri_inf_p->private_buf[2], pri_inf_p->private_buf[3], pri_inf_p->private_buf[7],
				pri_inf_p->private_buf[8], pri_inf_p->private_buf[9], pri_inf_p->private_buf[10], pri_inf_p->private_buf[4], pri_inf_p->private_buf[6],
				pri_inf_p->private_buf[5]);
		break;
	case FMB_CMD_SAPARAM:
		comment = "[%s]   : id:0x%08lx  value:0x%04x \n";
		printOut (comment , g_internal_jump_table[pri_inf_p->cmd_id].option_parameter,
				pri_inf_p->private_ldata , pri_inf_p->private_data);
		break;
	case FMB_CMD_SACK:
		comment = "[%s]     : cack:0x%04x  sub_cack:0x%04x  distinct:0x%08x \n";
		printOut (comment , g_internal_jump_table[pri_inf_p->cmd_id].option_parameter,
				pri_inf_p->cmd_str.cmd_ack_sys_info.id,
				pri_inf_p->cmd_str.cmd_ack_sys_info.sub_id,
				(unsigned int)pri_inf_p->cmd_str.cmd_ack_sys_info.distinct);
		break;
	case FMB_CMD_RCBUF:
		comment = "[%s]    : type:0x%08lx \n";
		printOut (comment , g_internal_jump_table[pri_inf_p->cmd_id].option_parameter,
				pri_inf_p->cmd_str.cmd_info_reset.type);
		break;
	case FMB_CMD_SMSG:
		comment = "[%s]     : msg:0x%04x  sub_msg:0x%04x  body:0x%04x \n";
		printOut (comment , g_internal_jump_table[pri_inf_p->cmd_id].option_parameter,
				pri_inf_p->cmd_str.msg_sys_info.id,
				pri_inf_p->cmd_str.msg_sys_info.sub_id,
				pri_inf_p->cmd_str.msg_sys_info.body);
		break;
	case FMB_CMD_VMSG:
		comment = "[%s]     : mode:0x%02x  sub_mode:0x%02x \n"
				  "             cmd_invalid:0x%02x  v_error_level_h:0x%04x  v_error_level_l:0x%04x \n"
				  "             Hex dump \n";
		printOut (comment , g_internal_jump_table[pri_inf_p->cmd_id].option_parameter,
				(pri_inf_p->private_buf[1] & 0xFF), (pri_inf_p->private_buf[41] & 0x03),
				(pri_inf_p->private_buf[1] & 0x4000)>>14, (pri_inf_p->private_buf[4] & 0xffff), (pri_inf_p->private_buf[5] & 0xffff));
		data_dump((FMB_VIDEO_MSG_REG_SIZE / 2), pri_inf_p->private_buf);
		break;
	case FMB_CMD_AMSG:
		comment = "[%s]     : a_mute:0x%02x  a_ch:0x%02x  a_mute_st:0x%02x  av_sync:0x%02x \n"
				  "             Hex dump \n";
		printOut (comment , g_internal_jump_table[pri_inf_p->cmd_id].option_parameter,
				(pri_inf_p->private_buf[2] & 0x01), (pri_inf_p->private_buf[1] & 0x03), (pri_inf_p->private_buf[2] & 0x8000)>>15, (pri_inf_p->private_buf[3] & 0x03));
		data_dump((FMB_AUDIO_MSG_REG_SIZE / 2), pri_inf_p->private_buf);
		break;
	case FMB_CMD_GFACT:
		comment = "[%s]    : factor:0x%08lx \n";
		printOut (comment , g_internal_jump_table[pri_inf_p->cmd_id].option_parameter,
				pri_inf_p->cmd_str.factor_info.factor);
		break;
	case FMB_CMD_RFACT:
		comment = "[%s]    : factor:0x%08lx \n";
		printOut (comment , g_internal_jump_table[pri_inf_p->cmd_id].option_parameter,
				pri_inf_p->cmd_str.factor_reset.factor);
		break;
	case FMB_CMD_ASYNC:
		comment = "[%s]    : type:0x%08lx \n";
		printOut (comment , g_internal_jump_table[pri_inf_p->cmd_id].option_parameter,
				pri_inf_p->cmd_str.async_info.type);
		if (pri_inf_p->cmd_str.async_info.type == FMB_TYPE_ASYNC_XERROR) {
			comment = "             xerror : %04x%04x %04x%04x %04x%04x %04x%04x \n";
			printOut (comment ,pri_inf_p->private_buf[0], pri_inf_p->private_buf[1], pri_inf_p->private_buf[2], pri_inf_p->private_buf[3],
					pri_inf_p->private_buf[4], pri_inf_p->private_buf[5], pri_inf_p->private_buf[6], pri_inf_p->private_buf[7]);
		} else {
			comment = "             vudata \n"
					  "             Hex dump\n";
			printOut (comment );
			data_dump((FMB_VUDATA_INFO_REG_SIZE / 2), pri_inf_p->private_buf);
		}
		break;
	case FMB_CMD_GLSI:
	case FMB_CMD_SLSI:
		comment = "[%s]     : offset:0x%08lx  value:0x%04x \n";
		printOut (comment , g_internal_jump_table[pri_inf_p->cmd_id].option_parameter,
				pri_inf_p->cmd_str.reg_info.offset , pri_inf_p->private_data);
		break;
	case FMB_CMD_GPCI:
	case FMB_CMD_SPCI:
		comment = "[%s]    : type:0x%08lx  offset:0x%08lx  value:0x%08lx \n";
		printOut (comment , g_internal_jump_table[pri_inf_p->cmd_id].option_parameter,
				pri_inf_p->cmd_str.pci_reg_info.reg_type , pri_inf_p->cmd_str.pci_reg_info.offset , pri_inf_p->private_ldata);
		break;
	case FMB_CMD_GDATA:
	case FMB_CMD_SDATA:
		comment = "[%s]    : type:0x%08lx  value:0x%08lx \n";
		printOut (comment , g_internal_jump_table[pri_inf_p->cmd_id].option_parameter,
				pri_inf_p->cmd_str.internal_info.type , pri_inf_p->cmd_str.internal_info.data);
		break;
	case FMB_CMD_VER:
		uname(&system_info);
		comment = "[%s]      : firm    : %04x-%04x-%04x-%04x \n"
			      "             driver  : %s \n"
			      "             kernel  : %s \n";
		printOut (comment , g_internal_jump_table[pri_inf_p->cmd_id].option_parameter,
				pri_inf_p->cmd_str.lib_version_info.firm_ver[0],
				pri_inf_p->cmd_str.lib_version_info.firm_ver[1],
				pri_inf_p->cmd_str.lib_version_info.firm_ver[2],
				pri_inf_p->cmd_str.lib_version_info.firm_ver[3],
				pri_inf_p->cmd_str.lib_version_info.driver_ver,
				system_info.release);
		break;
	default:
		break;
	}

	return ;
}

/**
 *  @brief	Print the detail error message.
 *
 *  @param[in]	pri_inf_p		private information
 *  @return	    None
 *  @note	None
 *  @attension	None
 */

static void api_ditail_err_print(struct ioctl_private_inf* pri_inf_p)
{
	char* comment;

	/* API Detail error Format */
	switch(pri_inf_p->cmd_id ){
	case FMB_CMD_SVPARAM:
		switch (pri_inf_p->cmd_str.cmd_video_info.cprm_num) {
		case 1:
			comment = "Can't set mode parameter \n";
			break;
		case 2:
			comment = "Can't set inter_gop_gap parameter \n";
			break;
		case 3:
			comment = "Can't set tfrff parameter \n";
			break;
		case 4:
			comment = "Can't set extra_info_bit parameter \n";
			break;
		case 5:
			comment = "Can't set vdisptime parameter \n";
			break;
		case 6:
			comment = "Can't set sub_mode parameter \n";
			break;
		case 7:
			comment = "Can't set vudata_length parameter \n";
			break;
		default:
			comment = "internal error \n";
			break;
		}
		break;
	case FMB_CMD_SAPARAM:
		switch (pri_inf_p->cmd_str.cmd_audio_info.cprm_num) {
		case 1:
			comment = "Can't set a_mute parameter \n";
			break;
		case 2:
			comment = "Can't set a_ch parameter \n";
			break;
		case 3:
			comment = "Can't set lch_scale parameter \n";
			break;
		case 4:
			comment = "Can't set rch_scale parameter \n";
			break;
		case 5:
			comment = "Can't set d_ac3_compression parameter \n";
			break;
		case 6:
			comment = "Can't set d_ac3_dynrng_cut parameter \n";
			break;
		case 7:
			comment = "Can't set d_ac3_dynrng_boost parameter \n";
			break;
		case 8:
			comment = "Can't set lsch_scale parameter \n";
			break;
		case 9:
			comment = "Can't set rsch_scale parameter \n";
			break;
		case 10:
			comment = "Can't set cch_scale parameter \n";
			break;
		case 11:
			comment = "Can't set lfech_scale parameter \n";
			break;
		default:
			comment = "internal error \n";
			break;
		}
		break;
	default:
		return;
	}

	/* printing */
	printOut (comment);

	return ;
}

/**
 *  @brief	Print the timeout message.
 *
 *  @param[in]	pri_inf_p		private information
 *  @return	    None
 *  @note	None
 *  @attension	None
 */

static void api_timeout_print(struct ioctl_private_inf* pri_inf_p)
{
	char* comment;
	int timeout;

	/* timeout Format */
	switch(pri_inf_p->cmd_id ){
	case FMB_CMD_SACK:
		timeout = pri_inf_p->cmd_str.cmd_ack_sys_info.timeout;
		break;
	case FMB_CMD_SMSG:
		timeout = pri_inf_p->cmd_str.msg_sys_info.timeout;
		break;
	case FMB_CMD_VMSG:
		timeout = pri_inf_p->cmd_str.msg_video_info.timeout;
		break;
	case FMB_CMD_AMSG:
		timeout = pri_inf_p->cmd_str.msg_audio_info.timeout;
		break;
	case FMB_CMD_GFACT:
		timeout = pri_inf_p->cmd_str.factor_info.timeout;
		break;
	case FMB_CMD_ASYNC:
		timeout = pri_inf_p->cmd_str.async_info.timeout;
		break;
	default:
		comment = "[%s]     : timeout \n";
		/* printing */
		printOut (comment , g_internal_jump_table[pri_inf_p->cmd_id].option_parameter );
		return;
	}
	comment = "[%s]     : none  (timeout:%ldms) \n";
	/* printing */
	printOut (comment , g_internal_jump_table[pri_inf_p->cmd_id].option_parameter, timeout );

	return ;
}

/**
 *  @brief	Print the errro message.
 *
 *  @param[in]	pri_inf_p		private information
 *  @return	    None
 *  @note	None
 *  @attension	None
 */

static void error_print(struct ioctl_private_inf* pri_inf_p , int err)
{
	char* comment;

	/* Format */
	switch(err ){
	case NG_PARAM_ERROR:
		comment = "error: parameter is abnormal \n";
		break;
	case NG_OPTION_ERROR:
		comment = "error: option parameter is abnormal \n";
		break;
	case NG_VERIFY_ERROR:
		switch(pri_inf_p->cmd_id){
		case FMB_CMD_SLSI:
			comment = "error: no verification. offset:0x%08lx  reg:0x%04x \n";
			printOut (comment ,
					pri_inf_p->cmd_str.reg_info.offset , pri_inf_p->private_data);
			return;
		case FMB_CMD_SPCI:
			comment = "error: no verification. offset:0x%08lx  value:0x%08lx \n";
			printOut (comment ,
					pri_inf_p->cmd_str.pci_reg_info.offset , pri_inf_p->private_ldata);
			return;
		default:
			return;
		}
		return;
	case NG_ERR_IOCTL:
		switch (errno) {
		case EOPNOTSUPP:
			comment =  "error: no support function \n";
			break;
		case EINVAL:
			api_ditail_err_print(pri_inf_p);
			comment = "error: parameter is abnormal \n";
			break;
		case ETIMEDOUT:
			api_timeout_print(pri_inf_p);
			return ;
		case EAGAIN:
			comment = "[%s]     : none \n";
			printOut (comment , g_internal_jump_table[pri_inf_p->cmd_id].option_parameter);
			return ;
		default:
			FmbErrPrint( MSG_ERR_IOCTL,__FILE__, __LINE__);
			return;
		}
		break;
	case NG_ERR_MALLOC:
		FmbErrPrint( MSG_ERR_IOCTL,__FILE__, __LINE__);
		return;
	default:
		return;
	}

	fprintOut(stderr, comment);

	return ;
}

/**
 *  @brief	To check whether include the character which does not allow in the character string.
 *
 *  @param[in]	string		input character string
 *  @return	0		Normal end
 *  @return	-1		Abnormal end
 *  @note	None
 *  @attension	None
 */

static int check_unsigned_string(const char* string)
{
	int	rc;

	if (strspn(string, HEXDEC_CHAR) == strlen(string)) {
		rc=0;
	} else {
		rc=-1;
	}

	return rc;
}


/**
 *  @brief	Convert and check of input parameter (type of unsigned long)
 *
 *  @param[in]	input_param	input parameter of argv
 *  @return	struct param_check convert data and convert result
 *  @note	None
 *  @attention	None
 */

static struct param_check param_check_unsignlong(char* input_param)
{
	char*			err_val;
	struct param_check	param_check_out={0};

	if (check_unsigned_string(input_param) != 0) {
		param_check_out.result = NG;
		return param_check_out;
	}
	errno = 0;
	param_check_out.short_cnvdata = 0;
	param_check_out.long_cnvdata = strtoul(input_param, &err_val, 0);
	if (errno != 0) {
		param_check_out.result = NG;
		return param_check_out;
	}
	if (*err_val != '\0') {
		param_check_out.result = NG;
		return param_check_out;
	}
	param_check_out.result = OK;
	return param_check_out;
}

/**
 *  @brief	convert and check of input parameter (type of unsigned short)
 *
 *  @param[in]	input_param	input parameter of argv
 *  @return	struct param_check convert data and convert result
 *  @note	None
 *  @attention	None
 */

static struct param_check param_check_unsignshort(char* input_param)
{
	char*			err_val;
	struct param_check	param_check_out={0};

	if (check_unsigned_string(input_param) != 0) {
		param_check_out.result = NG;
		return param_check_out;
	}
	errno = 0;
	param_check_out.short_cnvdata = 0;
	param_check_out.long_cnvdata = strtoul(input_param, &err_val, 0);
	if (errno != 0) {
		param_check_out.result = NG;
		return param_check_out;
	}
	if (*err_val != '\0') {
		param_check_out.result = NG;
		return param_check_out;
	}
	/* overflow check */
	if (((param_check_out.long_cnvdata >> 16) & 0xffff) != 0 ) { /* pgr0539 */
		param_check_out.result = NG;
		return param_check_out;
	}
	param_check_out.short_cnvdata = (unsigned short)param_check_out.long_cnvdata;
	param_check_out.result = OK;
	return param_check_out;
}
/**
 *  @brief	Convert and check of input parameter (type of signed long)
 *
 *  @param[in]	input_param	input parameter of argv
 *  @return	struct param_check convert data and convert result
 *  @note	None
 *  @attention	None
 */

static struct param_check param_check_signlong(char* input_param)
{
	char*			err_val;
	struct param_check	param_check_out;

	errno = 0;
	param_check_out.short_cnvdata = 0;
	param_check_out.long_cnvdata = strtol(input_param, &err_val, 0);
	if (errno != 0) {
		param_check_out.result = NG;
		return param_check_out;
	}
	if (*err_val != '\0') {
		param_check_out.result = NG;
		return param_check_out;
	}
	param_check_out.result = OK;
	return param_check_out;
}

/**
 *  @brief	Retrieves parameters of the MB86-LSI.
 *
 *  @param[in]	fd		file descriptor
 *  @param[in]	argc		input character code counter
 *  @param[in]	argv		input character code
 *				argv[2]		id
 *  @return	0		Normal end
 *  @return	-1		Abnormal end
 *  @note	None
 *  @attention	None
 */

int get_field_param(struct ioctl_private_inf* pri_inf_p, int argc, char** argv)
{
	struct param_check	param_check_out;

	if (argc != 3) {
		return NG_USAGE;
	}

	/* check 1st parameter of id */
	param_check_out = param_check_unsignlong(argv[2]);
	if (param_check_out.result != OK) {
		return NG_PARAM_ERROR;
	}
	pri_inf_p->private_ldata = param_check_out.long_cnvdata;

	pri_inf_p->cmd_str.param_info.prm_id = &pri_inf_p->private_ldata;
	pri_inf_p->cmd_str.param_info.prm_data = &pri_inf_p->private_data;
	pri_inf_p->cmd_str.param_info.prm_num = 1;

	/* call API function of retrieves the parameters from the LSI. */
	if (DrvIoctlCmd(pri_inf_p->fd,
			g_internal_jump_table[pri_inf_p->cmd_id].ioctl_cmd,
			&pri_inf_p->cmd_str.param_info) != OK) {
		return NG_ERR_IOCTL;
	}

	return OK;
}

/**
 *  @brief	Sets parameters of the the MB86-LSI.
 *
 *  @param[in]	fd		file descriptor
 *  @param[in]	argc		input character code counter
 *  @param[in]	argv		input character code
 *				argv[2]		id
 *				argv[3]		value
 *  @return	0		Normal end
 *  @return	-1		Abnormal end
 *  @note	None
 *  @attention	None
 */

int set_field_param(struct ioctl_private_inf* pri_inf_p, int argc, char** argv)
{
	struct param_check	param_check_out;

	if (argc != 4) {
		return NG_USAGE;
	}

	/* check 1st parameter of id */
	param_check_out = param_check_unsignlong(argv[2]);
	if (param_check_out.result != OK) {
		return NG_PARAM_ERROR;
	}
	pri_inf_p->private_ldata = param_check_out.long_cnvdata;

	/* check 2nd parameter of value */
	param_check_out = param_check_unsignshort(argv[3]);
	if (param_check_out.result != OK) {
		return NG_PARAM_ERROR;
	}
	pri_inf_p->private_data = param_check_out.short_cnvdata;

	pri_inf_p->cmd_str.param_info.prm_id = &pri_inf_p->private_ldata;
	pri_inf_p->cmd_str.param_info.prm_data = &pri_inf_p->private_data;
	pri_inf_p->cmd_str.param_info.prm_num = 1;

	/* call API function of sets the parameters of the LSI. */
	if (DrvIoctlCmd(pri_inf_p->fd,
			g_internal_jump_table[pri_inf_p->cmd_id].ioctl_cmd,
			&pri_inf_p->cmd_str.param_info) != OK) {
		return NG_ERR_IOCTL;
	}

	return OK;
}

/**
 *  @brief	Sends a system-group command to the MB86-LSI.
 *
 *  @param[in]	fd		file descriptor
 *  @param[in]	argc		input character code counter
 *  @param[in]	argv		input character code
 *				argv[2]		cmd
 *				argv[3]		sub_cmd
 *				argv[4]		body
 *				argv[5]		[sync]
 *  @return	0		Normal end
 *  @return	-1		Abnormal end
 *  @note	None
 *  @attention	None
 */

int send_cmd_sys(struct ioctl_private_inf* pri_inf_p, int argc, char** argv)
{
	struct param_check		param_check_out;

	if (argc != 5 && argc != 6) {
		return NG_USAGE;
	}

	/* check 1st parameter of cmd */
	param_check_out = param_check_unsignshort(argv[2]);
	if (param_check_out.result != OK) {
		return NG_PARAM_ERROR;
	}
	pri_inf_p->cmd_str.lib_cmd_sys_info.cmd_sys_info.id = param_check_out.short_cnvdata;
	pri_inf_p->cmd_str.lib_cmd_sys_info.id = pri_inf_p->cmd_str.lib_cmd_sys_info.cmd_sys_info.id;

	/* check 2nd parameter of sub_cmd */
	param_check_out = param_check_unsignshort(argv[3]);
	if (param_check_out.result != OK) {
		return NG_PARAM_ERROR;
	}
	pri_inf_p->cmd_str.lib_cmd_sys_info.cmd_sys_info.sub_id = param_check_out.short_cnvdata;
	pri_inf_p->cmd_str.lib_cmd_sys_info.sub_id = pri_inf_p->cmd_str.lib_cmd_sys_info.cmd_sys_info.sub_id;

	/* check 3rd parameter of body */
	param_check_out = param_check_unsignshort(argv[4]);
	if (param_check_out.result != OK) {
		return NG_PARAM_ERROR;
	}
	pri_inf_p->cmd_str.lib_cmd_sys_info.cmd_sys_info.body = param_check_out.short_cnvdata;

	/* check 4st parameter of sync [omit is possible] */
	if (argc == 5) {
		pri_inf_p->cmd_str.lib_cmd_sys_info.cmd_sys_info.sync = FMB_MODE_SYNC;
	} else {
		pri_inf_p->cmd_str.lib_cmd_sys_info.cmd_sys_info.sync = FMB_MODE_ASYNC;
		param_check_out = param_check_unsignlong(argv[5]);
		if (param_check_out.result != OK) {
			return NG_PARAM_ERROR;
		}
		pri_inf_p->cmd_str.lib_cmd_sys_info.cmd_sys_info.distinct = (void*)param_check_out.long_cnvdata;
	}

	/* call API function of sends a system-group command to the LSI. */
	if (DrvIoctlCmd(pri_inf_p->fd,
			g_internal_jump_table[pri_inf_p->cmd_id].ioctl_cmd,
			&pri_inf_p->cmd_str.lib_cmd_sys_info.cmd_sys_info) != OK) {
		return NG_ERR_IOCTL;
	}

	return OK;
}

//MB86H55 add start
/**
 *  @brief	Sends a video-group command to the MB86-LSI.
 *
 *  @param[in]	fd		file descriptor
 *  @param[in]	argc		input character code counter
 *  @param[in]	argv		input character code
 *				argv[2]		mode
 *				argv[3]		sub_mode
 *				argv[4]		[tfrff]
 *				argv[5]		[extra_info_bit]
 *				argv[6]		[vdisptime]
 *  @return	0		Normal end
 *  @return	-1		Abnormal end
 *  @note	None
 *  @attention	None
 */

int set_video_param(struct ioctl_private_inf* pri_inf_p, int argc, char** argv)
{
	struct param_check		param_check_out;

	if (argc != 4) {
		return NG_USAGE;
	}

	/* check 1st parameter of id */
	param_check_out = param_check_unsignlong(argv[2]);
	if (param_check_out.result != OK) {
		return NG_PARAM_ERROR;
	}
	pri_inf_p->private_ldata = param_check_out.long_cnvdata;

	/* check 2nd parameter of value */
	param_check_out = param_check_unsignshort(argv[3]);
	if (param_check_out.result != OK) {
		return NG_PARAM_ERROR;
	}
	pri_inf_p->private_data = param_check_out.short_cnvdata;

	if (pri_inf_p->private_ldata < 0x00060000 || pri_inf_p->private_ldata > 0x0006008e) {
		return NG_PARAM_ERROR;
	}

	if (pri_inf_p->private_ldata == 0x00060001) {
		vdatabuf[0] = pri_inf_p->private_data;
	}
	else if (pri_inf_p->private_ldata == 0x00060002) {
		vdatabuf[1] = pri_inf_p->private_data;
	}
	else if (pri_inf_p->private_ldata == 0x00060004) {
		vdatabuf[2] = pri_inf_p->private_data;
	}
	else if (pri_inf_p->private_ldata == 0x00060005) {
		vdatabuf[3] = pri_inf_p->private_data;
	}
	else if (pri_inf_p->private_ldata == 0x00060006) {
		vdatabuf[4] = pri_inf_p->private_data;
	}
	else if (pri_inf_p->private_ldata == 0x00060008) {
		vdatabuf[5] = pri_inf_p->private_data;
	}
	else if (pri_inf_p->private_ldata == 0x00060009) {
		vdatabuf[6] = pri_inf_p->private_data;
	}

	if (pri_inf_p->private_ldata > 0x0006000d) {
		vdatabuf[7 + vudata_cnt] = pri_inf_p->private_data;
		vidbuf[7 + vudata_cnt] = pri_inf_p->private_ldata;
		vudata_cnt++;
	}

	return OK;
}
//MB86H55 add end

/**
 *  @brief	Sends a video-group command to the MB86-LSI.
 *
 *  @param[in]	fd		file descriptor
 *  @param[in]	argc		input character code counter
 *  @param[in]	argv		input character code
 *				argv[2]		mode
 *				argv[3]		sub_mode
 *				argv[4]		[tfrff]
 *				argv[5]		[extra_info_bit]
 *				argv[6]		[vdisptime]
 *  @return	0		Normal end
 *  @return	-1		Abnormal end
 *  @note	None
 *  @attention	None
 */

int send_cmd_video(struct ioctl_private_inf* pri_inf_p, int argc, char** argv)
{
	int i;

	if (argc != 2) {
		return NG_USAGE;
	}

	pri_inf_p->private_buf = malloc(sizeof(unsigned short) * 141);
	if (pri_inf_p->private_buf == NULL) {
		return NG_ERR_MALLOC;
	}

	memcpy(pri_inf_p->private_buf,vdatabuf,sizeof(unsigned short) * 141);

	pri_inf_p->cmd_str.cmd_video_info.cprm_num = 141;
	pri_inf_p->cmd_str.cmd_video_info.cprm_id = vidbuf;
	pri_inf_p->cmd_str.cmd_video_info.cprm_data = vdatabuf;

	/* call API function of sends a video-group command to the LSI. */
	if (DrvIoctlCmd(pri_inf_p->fd,
			g_internal_jump_table[pri_inf_p->cmd_id].ioctl_cmd,
			&pri_inf_p->cmd_str.cmd_video_info) != OK) {
		return NG_ERR_IOCTL;
	}

	vdatabuf[0] = 0x0000;
	vdatabuf[1] = 0x0000;
	vdatabuf[2] = 0x0002;
	vdatabuf[3] = 0x0000;
	vdatabuf[4] = 0x000a;
    for (i = 5; i < 141 ; i += 1) {
		vdatabuf[i] = 0x0000;
	}

	return OK;
}

/**
 *  @briefSends an audio-group command to the MB86-LSI.
 *
 *  @param[in]	fd		file descriptor
 *  @param[in]	argc		input character code counter
 *  @param[in]	argv		input character code
 *				argv[2]		a_mute
 *				argv[3]		[a_ch]
 *				argv[4]		[lch_scale]
 *				argv[5]		[rch_scale]
 *				argv[6]		[lsch_scale]
 *				argv[7]		[rsch_scale]
 *				argv[8]		[cch_scale]
 *				argv[9]		[lfech_scale]
 *				argv[10]	[d_ac3_compression]
 *				argv[11]	[d_ac3_dynrng_cut]
 *				argv[12]	[d_ac3_dynrng_boost]
 *  @return	0		Normal end
 *  @return	-1		Abnormal end
 *  @note	None
 *  @attention	None
 */

int set_audio_param(struct ioctl_private_inf* pri_inf_p, int argc, char** argv)
{
	struct param_check		param_check_out;

	if (argc != 4) {
		return NG_USAGE;
	}

	/* check 1st parameter of id */
	param_check_out = param_check_unsignlong(argv[2]);
	if (param_check_out.result != OK) {
		return NG_PARAM_ERROR;
	}
	pri_inf_p->private_ldata = param_check_out.long_cnvdata;

	/* check 2nd parameter of value */
	param_check_out = param_check_unsignshort(argv[3]);
	if (param_check_out.result != OK) {
		return NG_PARAM_ERROR;
	}
	pri_inf_p->private_data = param_check_out.short_cnvdata;

	if (pri_inf_p->private_ldata < 0x00070000 || pri_inf_p->private_ldata > 0x0007000c) {
		return NG_PARAM_ERROR;
	}

	if (pri_inf_p->private_ldata == 0x00070001) {
		adatabuf[0] = pri_inf_p->private_data;
	}
	else if (pri_inf_p->private_ldata == 0x00070002) {
		adatabuf[1] = pri_inf_p->private_data;
	}
	else if (pri_inf_p->private_ldata == 0x00070003) {
		adatabuf[2] = pri_inf_p->private_data;
	}
	else if (pri_inf_p->private_ldata == 0x00070004) {
		adatabuf[3] = pri_inf_p->private_data;
	}
	else if (pri_inf_p->private_ldata == 0x00070005) {
		adatabuf[4] = pri_inf_p->private_data;
	}
	else if (pri_inf_p->private_ldata == 0x00070006) {
		adatabuf[5] = pri_inf_p->private_data;
	}
	else if (pri_inf_p->private_ldata == 0x00070007) {
		adatabuf[6] = pri_inf_p->private_data;
	}
	else if (pri_inf_p->private_ldata == 0x00070008) {
		adatabuf[7] = pri_inf_p->private_data;
	}
	else if (pri_inf_p->private_ldata == 0x00070009) {
		adatabuf[8] = pri_inf_p->private_data;
	}
	else if (pri_inf_p->private_ldata == 0x0007000a) {
		adatabuf[9] = pri_inf_p->private_data;
	}
	else if (pri_inf_p->private_ldata == 0x0007000b) {
		adatabuf[10] = pri_inf_p->private_data;
	}

	return OK;
}

/**
 *  @briefSends an audio-group command to the MB86-LSI.
 *
 *  @param[in]	fd		file descriptor
 *  @param[in]	argc		input character code counter
 *  @param[in]	argv		input character code
 *				argv[2]		a_mute
 *				argv[3]		[a_ch]
 *				argv[4]		[lch_scale]
 *				argv[5]		[rch_scale]
 *				argv[6]		[lsch_scale]
 *				argv[7]		[rsch_scale]
 *				argv[8]		[cch_scale]
 *				argv[9]		[lfech_scale]
 *				argv[10]	[d_ac3_compression]
 *				argv[11]	[d_ac3_dynrng_cut]
 *				argv[12]	[d_ac3_dynrng_boost]
 *  @return	0		Normal end
 *  @return	-1		Abnormal end
 *  @note	None
 *  @attention	None
 */

int send_cmd_audio(struct ioctl_private_inf* pri_inf_p, int argc, char** argv)
{

	if (argc != 2 ) {
		return NG_USAGE;
	}

	pri_inf_p->private_buf = malloc(sizeof(unsigned short) * 11);
	if (pri_inf_p->private_buf == NULL) {
		return NG_ERR_MALLOC;
	}
	memcpy(pri_inf_p->private_buf,adatabuf,sizeof(unsigned short) * 11);

	pri_inf_p->cmd_str.cmd_audio_info.cprm_num = 11;
	pri_inf_p->cmd_str.cmd_audio_info.cprm_id = aidbuf;
	pri_inf_p->cmd_str.cmd_audio_info.cprm_data = adatabuf;

	/* call API function of sends an audio-group command to the LSI. */
	if (DrvIoctlCmd(pri_inf_p->fd,
			g_internal_jump_table[pri_inf_p->cmd_id].ioctl_cmd,
			&pri_inf_p->cmd_str.cmd_audio_info) != OK) {
		return NG_ERR_IOCTL;
	}

	adatabuf[0] = 0x0000;
	adatabuf[1] = 0x0000;
	adatabuf[2] = 0x8000;
	adatabuf[3] = 0x8000;
	adatabuf[4] = 0x0002;
	adatabuf[5] = 0x0080;
	adatabuf[6] = 0x0080;
	adatabuf[7] = 0x8000;
	adatabuf[8] = 0x8000;
	adatabuf[9] = 0x8000;
	adatabuf[10] = 0x8000;

	return OK;
}

/**
 *  @brief	It retrieves a system-group command acknowledge from the MB86-LSI.
 *
 *  @param[in]	fd		file descriptor
 *  @param[in]	argc		input character code counter
 *  @param[in]	argv		input character code
 *				argv[2]		[timeout]
 *  @return	0		Normal end
 *  @return	-1		Abnormal end
 *  @note	None
 *  @attention	None
 */

int get_sys_cmd_ack(struct ioctl_private_inf* pri_inf_p, int argc, char** argv)
{
	struct param_check		param_check_out;

	if (argc != 2 && argc != 3) {
		return NG_USAGE;
	}


	/* check 1st parameter of timeout [omit is possible] */
	if (argc == 2) {
		pri_inf_p->cmd_str.cmd_ack_sys_info.timeout = 0;
	} else {
		param_check_out = param_check_signlong(argv[2]);
		if (param_check_out.result != OK) {
			return NG_PARAM_ERROR;
		}
		pri_inf_p->cmd_str.cmd_ack_sys_info.timeout = param_check_out.long_cnvdata;
	}

	/* call API function of retrieves the acknowledge to a system-group command from the LSI. */
	if (DrvIoctlCmd(pri_inf_p->fd,
			g_internal_jump_table[pri_inf_p->cmd_id].ioctl_cmd,
			&pri_inf_p->cmd_str.cmd_ack_sys_info) != OK) {
		return NG_ERR_IOCTL;
	}

	return OK;
}

/**
 *  @brief	Clear the internal buffer for command.
 *
 *  @param[in]	fd		file descriptor
 *  @param[in]	argc		input character code counter
 *  @param[in]	argv		input character code
 *				argv[2]		[type]
 *  @return	0		Normal end
 *  @return	-1		Abnormal end
 *  @note	None
 *  @attention	None
 */

int reset_cmd_info(struct ioctl_private_inf* pri_inf_p, int argc, char** argv)
{
	struct param_check		param_check_out;

	if (argc != 2 && argc != 3) {
		return NG_USAGE;
	}

	/* check 1st parameter of type [omit is possible] */
	if (argc == 2) {
		pri_inf_p->cmd_str.cmd_info_reset.type = FMB_CMD_INFO_ALL;
	} else {
		param_check_out = param_check_unsignlong(argv[2]);
		if (param_check_out.result != OK) {
			return NG_PARAM_ERROR;
		}
		pri_inf_p->cmd_str.cmd_info_reset.type = param_check_out.long_cnvdata;
	}

	/* call API function of reset the internal buffer for command. */
	if (DrvIoctlCmd(pri_inf_p->fd,
			g_internal_jump_table[pri_inf_p->cmd_id].ioctl_cmd,
			&pri_inf_p->cmd_str.cmd_info_reset) != OK) {
		return NG_ERR_IOCTL;
	}

	return OK;
}

/**
 *  @brief	Retrieves a system-group message from the MB86-LSI.
 *
 *  @param[in]	fd		file descriptor
 *  @param[in]	argc		input character code counter
 *  @param[in]	argv		input character code
 *				argv[2]		[timeout]
 *  @return	0		Normal end
 *  @return	-1		Abnormal end
 *  @note	None
 *  @attention	None
 */

int get_msg_sys(struct ioctl_private_inf* pri_inf_p, int argc, char** argv)
{
	struct param_check		param_check_out;

	if (argc !=2 && argc !=3) {
		return NG_USAGE;
	}

	/* check 1st parameter of timeout [omit is possible] */
	if (argc == 2) {
		pri_inf_p->cmd_str.msg_sys_info.timeout = 0;
	} else {
		param_check_out = param_check_signlong(argv[2]);
		if (param_check_out.result != OK) {
			return NG_PARAM_ERROR;
		}
		pri_inf_p->cmd_str.msg_sys_info.timeout = param_check_out.long_cnvdata;
	}

	s_smsg_body = 0xFFFF;

	/* call API function of retrieves a system-group message command from the LSI. */
	if (DrvIoctlCmd(pri_inf_p->fd,
			g_internal_jump_table[pri_inf_p->cmd_id].ioctl_cmd,
			&pri_inf_p->cmd_str.msg_sys_info) != OK) {
		return NG_ERR_IOCTL;
	}

	s_smsg_body = pri_inf_p->cmd_str.msg_sys_info.body;

	return OK;
}

/**
 *  @brief	Retrieves a video-group message from the MB86-LSI.
 *
 *  @param[in]	fd		file descriptor
 *  @param[in]	argc		input character code counter
 *  @param[in]	argv		input character code
 *				argv[2]		[timeout]
 *  @return	0		Normal end
 *  @return	-1		Abnormal end
 *  @note	None
 *  @attention	None
 */

int get_msg_video(struct ioctl_private_inf* pri_inf_p, int argc, char** argv)
{
	struct param_check		param_check_out;

	if (argc != 2 && argc != 3) {
		return NG_USAGE;
	}

	/* check 1st parameter of timeout [omit is possible] */
	if (argc == 2) {
		pri_inf_p->cmd_str.msg_video_info.timeout = 0;
	} else {
		param_check_out = param_check_signlong(argv[2]);
		if (param_check_out.result != OK) {
			return NG_PARAM_ERROR;
		}
		pri_inf_p->cmd_str.msg_video_info.timeout = param_check_out.long_cnvdata;
	}

	/** memory allocation */
	pri_inf_p->private_buf = malloc(sizeof(unsigned char) * FMB_VIDEO_MSG_REG_SIZE);

	if (pri_inf_p->private_buf == NULL) {
		return NG_ERR_MALLOC;
	}

	pri_inf_p->cmd_str.msg_video_info.msg = pri_inf_p->private_buf;

	s_vmsg_mode = 0xFFFF;
	s_vmsg_seqend = 0xFFFF;

	/* call API function of retrieves a video-group message command from the LSI. */
	if (DrvIoctlCmd(pri_inf_p->fd,
			g_internal_jump_table[pri_inf_p->cmd_id].ioctl_cmd,
			&pri_inf_p->cmd_str.msg_video_info) != OK) {
		return NG_ERR_IOCTL;
	}

	s_vmsg_mode = pri_inf_p->private_buf[1] & 0xFF ;
	s_vmsg_seqend = ( (pri_inf_p->private_buf[2] & 0x4)>>2 );

	return OK;
}

/**
 *  @brief	Retrieves an audio-group message from the MB86-LSI.
 *
 *  @param[in]	fd		file descriptor
 *  @param[in]	argc		input character code counter
 *  @param[in]	argv		input character code
 *				argv[2]		[timeout]
 *  @return	0		Normal end
 *  @return	-1		Abnormal end
 *  @note	None
 *  @attention	None
 */

int get_msg_audio(struct ioctl_private_inf* pri_inf_p, int argc, char** argv)
{
	struct param_check		param_check_out;

	if (argc != 2 && argc != 3 ) {
		return NG_USAGE;
	}

	/* check 1st parameter of timeout [omit is possible] */
	if (argc == 2) {
		pri_inf_p->cmd_str.msg_audio_info.timeout = 0;
	} else {
		param_check_out = param_check_signlong(argv[2]);
		if (param_check_out.result != OK) {
			return NG_PARAM_ERROR;
		}
		pri_inf_p->cmd_str.msg_audio_info.timeout = param_check_out.long_cnvdata;
	}

	/** memory allocation */
	pri_inf_p->private_buf = malloc(sizeof(unsigned char) * FMB_AUDIO_MSG_REG_SIZE);

	if (pri_inf_p->private_buf == NULL) {
		return NG_ERR_MALLOC;
	}

	pri_inf_p->cmd_str.msg_audio_info.msg = pri_inf_p->private_buf;

	/* call API function of retrieves an audio-group message command from the LSI. */
	if (DrvIoctlCmd(pri_inf_p->fd,
			g_internal_jump_table[pri_inf_p->cmd_id].ioctl_cmd,
			&pri_inf_p->cmd_str.msg_audio_info) != OK) {
		return NG_ERR_IOCTL;
	}

	return OK;
}

/**
 *  @brief	Retrieves the asynchronous notification factor received from the MB86-LSI.
 *
 *  @param[in]	fd		file descriptor
 *  @param[in]	argc		input character code counter
 *  @param[in]	argv		input character code
 *				argv[2]		[timeout]
 *  @return	0		Normal end
 *  @return	-1		Abnormal end
 *  @note	None
 *  @attention	None
 */

int get_factor(struct ioctl_private_inf* pri_inf_p, int argc, char** argv)
{
	struct param_check	param_check_out;

	if (argc != 2 && argc != 3 ) {
		return NG_USAGE;
	}

	/* check 1st parameter of timeout [omit is possible] */
	if (argc == 2) {
		pri_inf_p->cmd_str.factor_info.timeout = 0;
	} else {
		param_check_out = param_check_signlong(argv[2]);
		if (param_check_out.result != OK) {
			return NG_PARAM_ERROR;
		}
		pri_inf_p->cmd_str.factor_info.timeout = param_check_out.long_cnvdata;
	}

	/* call API function of retrieves the asynchronous notification factor from the LSI. */
	if (DrvIoctlCmd(pri_inf_p->fd,
			g_internal_jump_table[pri_inf_p->cmd_id].ioctl_cmd,
			&pri_inf_p->cmd_str.factor_info) != OK) {
		return NG_ERR_IOCTL;
	}

	return OK;
}

/**
 *  @brief	Resets the asynchronous notification factor received from the MB86-LSI
 *              and asynchronous notification information.
 *
 *  @param[in]	fd		file descriptor
 *  @param[in]	argc		input character code counter
 *  @param[in]	argv		input character code
 *				argv[2]		[factor]
 *  @return	0		Normal end
 *  @return	-1		Abnormal end
 *  @note	None
 *  @attention	None
 */

int reset_factor(struct ioctl_private_inf* pri_inf_p, int argc, char** argv)
{
	struct param_check		param_check_out;

	if (argc != 2 && argc != 3) {
		return NG_USAGE;
	}

	/* check 1st parameter of timeout [omit is possible] */
	if (argc == 2) {
		pri_inf_p->cmd_str.factor_reset.factor = FMB_FACTOR_ASYNC_ALL;
	} else {
		param_check_out = param_check_unsignlong(argv[2]);
		if (param_check_out.result != OK) {
			return NG_PARAM_ERROR;
		}
		pri_inf_p->cmd_str.factor_reset.factor = param_check_out.long_cnvdata;
	}

	/* call API function of retrieves the asynchronous notification factor
				 and resets the nonnotification information buffer. */
	if (DrvIoctlCmd(pri_inf_p->fd,
			g_internal_jump_table[pri_inf_p->cmd_id].ioctl_cmd,
			&pri_inf_p->cmd_str.factor_reset) != OK) {
		return NG_ERR_IOCTL;
	}

	return OK;
}

/**
 *  @brief	Retrieves the asynchronous notification factor of exclude
 *              received message from the MB86-LSI.
 *
 *  @param[in]	fd		file descriptor
 *  @param[in]	argc		input character code counter
 *  @param[in]	argv		input character code
 *				argv[2]		type
 *				argv[3]		[timeout]
 *  @return	0		Normal end
 *  @return	-1		Abnormal end
 *  @note	None
 *  @attention	None
 */

int get_async_info(struct ioctl_private_inf* pri_inf_p, int argc, char** argv)
{
	struct param_check	param_check_out;

	if (argc != 3 && argc != 4) {
		return NG_USAGE;
	}

	/* check 1st parameter of type */
	param_check_out = param_check_unsignlong(argv[2]);
	if (param_check_out.result != OK) {
		return NG_PARAM_ERROR;
	}
	pri_inf_p->cmd_str.async_info.type = param_check_out.long_cnvdata;

	/* check 2nd parameter of timeout [omit is possible] */
	if (argc == 3) {
		pri_inf_p->cmd_str.async_info.timeout = 0;
	} else {
		param_check_out = param_check_signlong(argv[3]);
		if (param_check_out.result != OK) {
			return NG_PARAM_ERROR;
		}
		pri_inf_p->cmd_str.async_info.timeout = param_check_out.long_cnvdata;
	}

	if (pri_inf_p->cmd_str.async_info.type == FMB_TYPE_ASYNC_VUDATA) {
		/** memory allocation */
		pri_inf_p->private_buf = malloc(sizeof(unsigned char) * FMB_VUDATA_INFO_REG_SIZE);
	} else {
		pri_inf_p->private_buf = malloc(sizeof(unsigned short) * (FMB_XERROR_INFO_REG_SIZE / 2) );
	}
	if (pri_inf_p->private_buf == NULL) {
		return NG_ERR_MALLOC;
	}
	pri_inf_p->cmd_str.async_info.data = pri_inf_p->private_buf;

	/* call API function of retrieves the asynchronous notification information from the LSI. */
	if (DrvIoctlCmd(pri_inf_p->fd,
			g_internal_jump_table[pri_inf_p->cmd_id].ioctl_cmd,
			&pri_inf_p->cmd_str.async_info) != OK) {
		return NG_ERR_IOCTL;
	}

	return OK;
}

/**
 *  @brief	Reads the register of the MB86-LSI.
 *
 *  @param[in]	fd		file descriptor
 *  @param[in]	argc		input character code counter
 *  @param[in]	argv		input character code
 *				argv[2]		offset
 *  @return	0		Normal end
 *  @return	-1		Abnormal end
 *  @note	None
 *  @attention	None
 */

int get_lsi_reg(struct ioctl_private_inf* pri_inf_p, int argc, char** argv)
{
	struct param_check	param_check_out;

	if (argc != 3) {
		return NG_USAGE;
	}

	/* check 1st parameter of offset */
	param_check_out = param_check_unsignlong(argv[2]);
	if (param_check_out.result != OK) {
		return NG_PARAM_ERROR;
	}
	pri_inf_p->cmd_str.reg_info.offset = param_check_out.long_cnvdata;

	pri_inf_p->cmd_str.reg_info.prm_data = &pri_inf_p->private_data;
	pri_inf_p->cmd_str.reg_info.reg_num = 1;

	/* call API function of reads a register of the LSI. */
	if (DrvIoctlCmd(pri_inf_p->fd,
			g_internal_jump_table[pri_inf_p->cmd_id].ioctl_cmd,
			&pri_inf_p->cmd_str.reg_info) != OK) {
		return NG_ERR_IOCTL;
	}

	return OK;
}

/**
 *  @brief	Sets the register of the MB86-LSI.
 *
 *  @param[in]	fd		file descriptor
 *  @param[in]	argc		input character code counter
 *  @param[in]	argv		input character code
 *				argv[2]		offset
 *				argv[3]		value
 *  @return	0		Normal end
 *  @return	-1		Abnormal end
 *  @note	None
 *  @attention	None
 */

int set_lsi_reg(struct ioctl_private_inf* pri_inf_p, int argc, char** argv)
{
	struct param_check	param_check_out;
	unsigned short mask_data;
	unsigned short value_data;

	if (argc != 4 && argc != 5 ) {
		return NG_USAGE;
	}


	/* check 1st parameter of offset */
	param_check_out = param_check_unsignlong(argv[2]);
	if (param_check_out.result != OK) {
		return NG_PARAM_ERROR;
	}
	pri_inf_p->cmd_str.reg_info.offset = param_check_out.long_cnvdata;

	/* check 2nd parameter of value */
	param_check_out = param_check_unsignshort(argv[3]);
	if (param_check_out.result != OK) {
		return NG_PARAM_ERROR;
	}
	pri_inf_p->private_data = param_check_out.short_cnvdata;
	value_data = param_check_out.short_cnvdata;

	pri_inf_p->cmd_str.reg_info.prm_data = &pri_inf_p->private_data;
	pri_inf_p->cmd_str.reg_info.reg_num = 1;

    /* mask_bit */
	if (argc > 4 ){
		param_check_out = param_check_unsignshort(argv[4]);
		if (param_check_out.result != OK) {
			return NG_PARAM_ERROR;
		}
		mask_data = param_check_out.short_cnvdata;
		if (DrvIoctlCmd(pri_inf_p->fd,
				FMB_API_GET_LSI_REG,
				&pri_inf_p->cmd_str.reg_info) != OK) {
			return NG_ERR_IOCTL;
		}
        pri_inf_p->private_data = pri_inf_p->private_data & ~mask_data;
        pri_inf_p->private_data = pri_inf_p->private_data | value_data;
	}

	/* call API function of writes to a register of the LSI. */
	if (DrvIoctlCmd(pri_inf_p->fd,
			g_internal_jump_table[pri_inf_p->cmd_id].ioctl_cmd,
			&pri_inf_p->cmd_str.reg_info) != OK) {
		return NG_ERR_IOCTL;
	}

	return OK;
}

/**
 *  @brief	Dump the register of the MB86.
 *
 *  @param[in]	fd		file descriptor
 *  @param[in]	argc		input character code counter
 *  @param[in]	argv		input character code
 *				argv[2]		offset
 *				argv[3]		value
 *  @return	0		Normal end
 *  @return	-1		Abnormal end
 *  @note	None
 *  @attention	None
 */

int dump_lsi_reg(struct ioctl_private_inf* pri_inf_p, int argc, char** argv)
{
	FILE*	_fp = NULL;
	struct param_check	param_check_out;
	struct fmb_reg_info reg_info;
	unsigned short	private_data;
	unsigned long	offset = 0x80000;
	unsigned int	size= 512;
	unsigned long	do_size;
	char*			err_cause;

	if (argc != 4 && argc != 5) {
		return NG_USAGE;
	}
	/* offset */
	param_check_out = param_check_unsignlong(argv[2]);
	if (param_check_out.result != OK) {
		return NG_PARAM_ERROR;
	}
	offset = param_check_out.long_cnvdata;

	/* dumpsize */
	param_check_out = param_check_unsignlong(argv[3]);
	if (param_check_out.result != OK) {
		return NG_PARAM_ERROR;
	}
	size = param_check_out.long_cnvdata;

	if (argc > 4 ){
		if(_fp != NULL){
			fclose(_fp);
			_fp = NULL;
		}
		_fp = fopen(argv[4] , "w");

		if(_fp == NULL){
			err_cause = strerror(errno);
			LogFmb("%s stat info:(%d)-%s",argv[4] ,errno, err_cause);
			FMB_FUNC(FALSE);
			return FALSE;
		}
	}

	size = param_check_out.long_cnvdata;

	reg_info.offset = offset;
	reg_info.prm_data = &private_data;
	reg_info.reg_num = 1;

	do_size = 0;

	printOut("[dlsi]     : offset:0x%08lx  size:0x%04x \n", reg_info.offset, size);
	if(_fp != NULL ){
		fprintf(_fp, "[dlsi]     : offset:0x%08lx  size:0x%04x \n", reg_info.offset, size );
	}

	while (do_size < size) {

		if (DrvIoctlCmd(pri_inf_p->fd, FMB_API_GET_LSI_REG , &reg_info) != OK) {
			LogFmb("FMB_API_GET_LSI_REG NG!!");
			if(_fp != NULL){
				fclose(_fp);
				_fp = NULL;
			}
			return NG_ERR_IOCTL;
		}

		if ( do_size%8 ==0 ){
			if (_fp == NULL){
				printOut("\n0x%08lx :   0x%04x",reg_info.offset,private_data);
			}
			else if(_fp != NULL){
				fprintf(_fp, "\n0x%08lx :   0x%04x",reg_info.offset,private_data );
			}
		}
		else {
			if (_fp == NULL){
				printOut("  0x%04x",private_data);
			}
			else if(_fp != NULL){
				fprintf(_fp, "  0x%04x",private_data );
			}
		}
	    do_size += sizeof(unsigned short);
		reg_info.offset += sizeof(unsigned short);
	}
	if (_fp == NULL){
		fprintOut(stdout, "\n");
	}
	else if( _fp != NULL ){
		fprintf(_fp, "  \n");
	}

	if (argc > 4 ){
		if(_fp != NULL){
			fclose(_fp);
			_fp = NULL;
		}
	}

	return OK;  /* pgr0524 */
}

/**
 *  @brief	Reads an PCI register of the MB86-RB.
 *
 *  @param[in]	fd		file descriptor
 *  @param[in]	argc		input character code counter
 *  @param[in]	argv		input character code
 *				argv[2]		type
 *				argv[3]		offset
 *  @return	0		Normal end
 *  @note	None
 *  @attention	None
 */

int get_pci_reg(struct ioctl_private_inf* pri_inf_p, int argc, char** argv)
{
	struct param_check		param_check_out;

	if (argc != 4) {
		return NG_USAGE;
	}

	/* check 1st parameter of type */
	param_check_out = param_check_unsignlong(argv[2]);
	if (param_check_out.result != OK) {
		return NG_PARAM_ERROR;
	}
	pri_inf_p->cmd_str.pci_reg_info.reg_type = param_check_out.long_cnvdata;

	/* check 2nd parameter of type */
	param_check_out = param_check_unsignlong(argv[3]);
	if (param_check_out.result != OK) {
		return NG_PARAM_ERROR;
	}
	pri_inf_p->cmd_str.pci_reg_info.offset = param_check_out.long_cnvdata;

	pri_inf_p->cmd_str.pci_reg_info.prm_data = &pri_inf_p->private_ldata;
	pri_inf_p->cmd_str.pci_reg_info.reg_num = 1;

	/* call API function of reads the PCI register of MB86-RB. */
	if (DrvIoctlCmd(pri_inf_p->fd,
			g_internal_jump_table[pri_inf_p->cmd_id].ioctl_cmd,
			&pri_inf_p->cmd_str.pci_reg_info) != OK) {
		return NG_ERR_IOCTL;
	}

	return OK;
}

/**
 *  @brief	Sets an PCI register of the MB86-RB.
 *
 *  @param[in]	fd		file descriptor
 *  @param[in]	argc		input character code counter
 *  @param[in]	argv		input character code
 *				argv[2]		type
 *				argv[3]		offset
 *				argv[4]		value
 *  @return	0		Normal end
 *  @return	-1		Abnormal end
 *  @note	None
 *  @attention	None
 */

int set_pci_reg(struct ioctl_private_inf* pri_inf_p, int argc, char** argv)
{
	struct param_check		param_check_out;

	if (argc != 5 ) {
		return NG_USAGE;
	}

	/* check 1st parameter of offset */
	param_check_out = param_check_unsignlong(argv[2]);
	if (param_check_out.result != OK) {
		return NG_PARAM_ERROR;
	}
	pri_inf_p->cmd_str.pci_reg_info.reg_type = param_check_out.long_cnvdata;

	/* check 2nd parameter of offset */
	param_check_out = param_check_unsignlong(argv[3]);
	if (param_check_out.result != OK) {
		return NG_PARAM_ERROR;
	}
	pri_inf_p->cmd_str.pci_reg_info.offset = param_check_out.long_cnvdata;

	/* check 3rd parameter of value */
	param_check_out = param_check_unsignlong(argv[4]);
	if (param_check_out.result != OK) {
		return NG_PARAM_ERROR;
	}
	pri_inf_p->private_ldata = param_check_out.long_cnvdata;

	pri_inf_p->cmd_str.pci_reg_info.prm_data = &pri_inf_p->private_ldata;
	pri_inf_p->cmd_str.pci_reg_info.reg_num = 1;

	/* call API function of writes to the PCI register of MB86-RB. */
	if (DrvIoctlCmd(pri_inf_p->fd,
			g_internal_jump_table[pri_inf_p->cmd_id].ioctl_cmd,
			&pri_inf_p->cmd_str.pci_reg_info) != OK) {
		return NG_ERR_IOCTL;
	}


	return OK;
}

/**
 *  @brief	Retrieves the internal information for driver
 *
 *  @param[in]	fd		file descriptor
 *  @param[in]	argc		input character code counter
 *  @param[in]	argv		input character code
 *				argv[2]		type
 *  @return	0		Normal end
 *  @return	-1		Abnormal end
 *  @note	None
 *  @attention	None
 */

int get_drv_internal_info(struct ioctl_private_inf* pri_inf_p, int argc, char** argv)
{
	struct param_check		param_check_out;

	if (argc != 3) {
		return NG_USAGE;
	}

	/* check 1st parameter of type */
	param_check_out = param_check_unsignlong(argv[2]);
	if (param_check_out.result != OK) {
		return NG_PARAM_ERROR;
	}
	pri_inf_p->cmd_str.internal_info.type = param_check_out.long_cnvdata;

	/* call API function of retrieves the internal information for driver. */
	if (DrvIoctlCmd(pri_inf_p->fd,
			g_internal_jump_table[pri_inf_p->cmd_id].ioctl_cmd,
			&pri_inf_p->cmd_str.internal_info) != OK) {
		return NG_ERR_IOCTL;
	}

	return OK;
}

/**
 *  @brief	Sets the internal information for driver
 *
 *  @param[in]	fd		file descriptor
 *  @param[in]	argc		input character code counter
 *  @param[in]	argv		input character code
 *				argv[2]		type
 *				argv[3]		value
 *  @return	0		Normal end
 *  @return	-1		Abnormal end
 *  @note	None
 *  @attention	None
 */

int set_drv_internal_info(struct ioctl_private_inf* pri_inf_p, int argc, char** argv)
{
	struct param_check		param_check_out;

	if (argc != 3 && argc != 4) {
		return NG_USAGE;
	}

	/* check 1st parameter of type */
	param_check_out = param_check_unsignlong(argv[2]);
	if (param_check_out.result != OK) {
		return NG_PARAM_ERROR;
	}
	pri_inf_p->cmd_str.internal_info.type = param_check_out.long_cnvdata;

	/* check 2nd parameter of value */
	if (argc == 3) {
		if (pri_inf_p->cmd_str.internal_info.type != FMB_DATA_TYPE_NOTIFY) {
			return NG_USAGE;
		}
		pri_inf_p->cmd_str.internal_info.data = FMB_DATA_NOTIFY_ALL;
	} else {
		param_check_out = param_check_unsignlong(argv[3]);
		if (param_check_out.result != OK) {
			return NG_PARAM_ERROR;
		}
		pri_inf_p->cmd_str.internal_info.data = param_check_out.long_cnvdata;
	}

	/* call API function of sets the internal information for driver. */
	if (DrvIoctlCmd(pri_inf_p->fd,
			g_internal_jump_table[pri_inf_p->cmd_id].ioctl_cmd,
			&pri_inf_p->cmd_str.internal_info) != OK) {
		return NG_ERR_IOCTL;
	}

	return OK;
}
/**
 *  @brief	Get each version information
 *               1)the MB86-LSI firmware version
 *               2)PCI version
 *               3)Linux driver version
 *               4)Linux kernel version
 *
 *  @param[in]	fd		file descriptor
 *  @param[in]	argc		input character code counter
 *  @param[in]	argv		input character code
 *  @return	0		Normal end
 *  @return	-1		Abnormal end
 *  @note	None
 *  @attention	None
 */

int get_version_info(struct ioctl_private_inf* pri_inf_p, int argc, char** argv)
{

	if (argc != 2) {
		return NG_USAGE;
	}

	pri_inf_p->cmd_str.lib_version_info.version_info.firm_ver = pri_inf_p->cmd_str.lib_version_info.firm_ver;
	pri_inf_p->cmd_str.lib_version_info.version_info.driver_ver = pri_inf_p->cmd_str.lib_version_info.driver_ver;

	/* call API function of retrieves each version information. */
	if (DrvIoctlCmd(pri_inf_p->fd,
			g_internal_jump_table[pri_inf_p->cmd_id].ioctl_cmd,
			&pri_inf_p->cmd_str.lib_version_info.version_info) != OK) {
		return NG_ERR_IOCTL;
	}

	return OK;
}
/**
 *  @brief	Dump the data
 *  @param[in]	max_num		number of data
 *  @param[in]	msg		    16bit datas
 *  @return	0		Normal end
 *  @return	-1		Abnormal end
 *  @note	None
 *  @attention	None
 */

static void data_dump(unsigned short max_num, unsigned short* msg)
{
	int	i;

	for (i = 0; i < max_num; i += 8) {
		printOut("             %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x \n",
					(msg[i+0] & 0xFF00)>>8 ,  (msg[i+0] & 0x00FF) , (msg[i+1] & 0xFF00)>>8 ,  (msg[i+1] & 0x00FF) ,
					(msg[i+2] & 0xFF00)>>8 ,  (msg[i+2] & 0x00FF) , (msg[i+3] & 0xFF00)>>8 ,  (msg[i+3] & 0x00FF) ,
					(msg[i+4] & 0xFF00)>>8 ,  (msg[i+4] & 0x00FF) , (msg[i+5] & 0xFF00)>>8 ,  (msg[i+5] & 0x00FF) ,
					(msg[i+6] & 0xFF00)>>8 ,  (msg[i+6] & 0x00FF) , (msg[i+7] & 0xFF00)>>8 ,  (msg[i+7] & 0x00FF) );
	}
}

/**
 *  @brief	main of the dirver control application.
 *
 *  @param[in]	pri_inf 	primitive infomations
 *  @param[in]	argc		input character code counter
 *  @param[in]	argv		input character code
 *				argv[1]		option
 *  @return	0		Normal end
 *  @return	-1		Abnormal end
 *  @note	None
 *  @attention	None
 */
int strm_command(struct ioctl_private_inf* pri_inf, int argc, char** argv)
{
	int index;
	BOOL res;
	enum FMBFileResultEnum  fresult;
	int		errPacketCnt;
	int startPos=0;
	int endPos=0;
	HANDLE hScet;


	FMB_FUNC(TRUE);
	hScet = gp_FmbComProperty->hEmptyScet;
	if (argc < 3 || argc > 9) {
		FMB_FUNC(FALSE);
		return NG_USAGE;
	}

	if ( strcmp("set",argv[2])==0 ) {
		s_Strmmode = FMBEnmNothing;

		/* -fin */
		index = FmbgetArg("-fin", argc , argv);
		if (index!=0){
			fresult = FmbFileOpen(FMBEnmInFile,argv[index],&errPacketCnt);
			if (fresult != FMBEnmFileNormal){
				FmbErrPrintUsr("File Open error",__FILE__, __LINE__);
				FMB_FUNC(FALSE);
				return NG_OPTION_ERROR;
			}
			s_Strmmode = FMBEnmSend;
		}

		/* -fout */
		index = FmbgetArg("-fout", argc , argv);
		if (index!=0){
			fresult = FmbFileOpen(FMBEnmOutFile,argv[index],&errPacketCnt);
			if (fresult != FMBEnmFileNormal){
				FmbErrPrintUsr("File Open error",__FILE__, __LINE__);
				FMB_FUNC(FALSE);
				return NG_OPTION_ERROR;
			}
			if (s_Strmmode == FMBEnmSend){
				s_Strmmode = FMBEnmRcvSend;
				FmbErrPrintUsr("File Combination error",__FILE__, __LINE__);
				FMB_FUNC(FALSE);
				return NG_OPTION_ERROR;
			}
			else{
				s_Strmmode = FMBEnmRcv;
			}
		}

		if (s_Strmmode == FMBEnmNothing){
			FMB_FUNC(FALSE);
			return NG_USAGE;
		}


		startPos=0;
		index = FmbgetArg("-st", argc , argv);
		if (index!=0){

			startPos = StrToUnsignedInt(argv[index]);
			if ( startPos == -1 ){
				FmbErrPrintUsr("Illegal start_position." ,__FILE__, __LINE__);
				FMB_FUNC(FALSE);
				return NG_OPTION_ERROR;
			}
		}
		endPos=0;
		index = FmbgetArg("-ed", argc , argv);
		if (index!=0){

			endPos = StrToUnsignedInt(argv[index]);
			if ( endPos == -1 ){
				FmbErrPrintUsr("Illegal end_position." ,__FILE__, __LINE__);
				FMB_FUNC(FALSE);
				return NG_OPTION_ERROR;
			}
		}
		FmbSetStrmFilePos(FMBEnmStartPos, startPos);
		FmbSetStrmFilePos(FMBEnmEndPos, endPos);
	}

	else if ( strcmp("start",argv[2])==0 ) {

		res = FmbStreamBegin( s_Strmmode, hScet );
		if ( res == FALSE ){
			FmbErrPrintUsr("Cannot start.",__FILE__, __LINE__);
			FMB_FUNC(FALSE);
			return NG_OPTION_ERROR;
		}

	}

	else if ( strcmp("stop",argv[2])==0 ) {

		FmbStreamRest(hScet);

	}
	else{
		FMB_FUNC(FALSE);
		return NG_USAGE;
	}

	FMB_FUNC(FALSE);
	return OK;

}
int sleep_command(struct ioctl_private_inf* pri_inf, int argc, char** argv)
{
	int slptime=0;

	FMB_FUNC(TRUE);
	if (argc != 3) {
		FMB_FUNC(FALSE);
		return NG_USAGE;
	}

    slptime = StrToUnsignedInt(argv[2]);
	if ( slptime < 0 ){
		FmbErrPrintUsr("sleep time error",__FILE__, __LINE__);
		FMB_FUNC(FALSE);
		return NG_PARAM_ERROR;
	}

	usleep(slptime * 1000);

	FMB_FUNC(FALSE);
	return OK;

}

int logstart_command(struct ioctl_private_inf* pri_inf, int argc, char** argv)
{

	FMB_FUNC(TRUE);
	if (argc != 3) {
		FMB_FUNC(FALSE);
		return NG_USAGE;
	}

	if(!StartLogFile(argv[2],"w")){
		FmbErrPrintUsr("File open error",__FILE__, __LINE__);
		FMB_FUNC(FALSE);
		return NG_PARAM_ERROR;
	}

	FMB_FUNC(FALSE);
	return OK;

}

int logstop_command(struct ioctl_private_inf* pri_inf, int argc, char** argv)
{

	FMB_FUNC(TRUE);
	if (argc != 2) {
		FMB_FUNC(FALSE);
		return NG_USAGE;
	}

	if(!StopLogFile()){
		FmbErrPrintUsr("File close error",__FILE__, __LINE__);
		FMB_FUNC(FALSE);
		return NG_PARAM_ERROR;
	}

	FMB_FUNC(FALSE);
	return OK;

}

int gopstart_command(struct ioctl_private_inf* pri_inf_p, int argc, char** argv)
{

	FMB_FUNC(TRUE);
	if (argc != 3) {
		FMB_FUNC(FALSE);
		return NG_USAGE;
	}

	pri_inf_p->cmd_str.internal_info.type = 0x00000002;

	if (DrvIoctlCmd(pri_inf_p->fd, FMB_API_GET_INTERNAL_DATA, &pri_inf_p->cmd_str.internal_info) != OK) {
		return NG_ERR_IOCTL;
	}

	internal_info_data = pri_inf_p->cmd_str.internal_info.data;
	pri_inf_p->cmd_str.internal_info.type = 0x00000002;
	pri_inf_p->cmd_str.internal_info.data = pri_inf_p->cmd_str.internal_info.data & 0x0000000E;

	if (DrvIoctlCmd(pri_inf_p->fd, FMB_API_SET_INTERNAL_DATA, &pri_inf_p->cmd_str.internal_info) != OK) {
		return NG_ERR_IOCTL;
	}


	if(!StartGopFile(argv[2],"w")){
		FmbErrPrintUsr("File open error",__FILE__, __LINE__);
		FMB_FUNC(FALSE);
		return NG_PARAM_ERROR;
	}

	FMB_FUNC(FALSE);
	return OK;

}

int gopstop_command(struct ioctl_private_inf* pri_inf_p, int argc, char** argv)
{

	FMB_FUNC(TRUE);
	if (argc != 2) {
		FMB_FUNC(FALSE);
		return NG_USAGE;
	}

	pri_inf_p->cmd_str.internal_info.type = 0x00000002;
	pri_inf_p->cmd_str.internal_info.data = internal_info_data;

	if (DrvIoctlCmd(pri_inf_p->fd, FMB_API_SET_INTERNAL_DATA, &pri_inf_p->cmd_str.internal_info) != OK) {
		return NG_ERR_IOCTL;
	}

	if(!StopGopFile()){
		FmbErrPrintUsr("File close error",__FILE__, __LINE__);
		FMB_FUNC(FALSE);
		return NG_PARAM_ERROR;
	}

	FMB_FUNC(FALSE);
	return OK;

}

int boot_command(struct ioctl_private_inf* pri_inf, int argc, char** argv)
{
	char* firmPath;
	enum  SceResultEnum sceResult;
	HANDLE hScet;

	FMB_FUNC(TRUE);
	if (argc != 3) {
		FMB_FUNC(FALSE);
		return NG_USAGE;
	}

    firmPath = argv[2];
	hScet = gp_FmbComProperty->hEmptyScet;
	sceResult = DrvBootUp(hScet, firmPath, 0, 0);
	if( sceResult != SceEnmResultSyncEnd){
		fprintOut(stdout,"Error:Failed in the firm boot.\n");
		return 0;
	}

	FMB_FUNC(FALSE);
	return OK;

}

int help_command(struct ioctl_private_inf* pri_inf, int argc, char** argv)
{

	FMB_FUNC(TRUE);
	if (argc != 2) {
		FMB_FUNC(FALSE);
		return NG_USAGE;
	}

    FmbUsageMainPrint();

	FMB_FUNC(FALSE);
	return OK;

}