cst_exts.c

是一个手机功能的模拟程序

  return ( cl );
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)               MODULE  : CST_EXTS           |
| STATE   : code                        ROUTINE : percentDBG         |
+--------------------------------------------------------------------+

  PURPOSE : %RST command (simulates pressing the reset button
            of the ASample)
*/

#ifndef TRACE_PORT_TIMING
  #ifdef _TMS470
    #if (CHIPSET == 0)
      EXTERN void l1s_set_debug_pin ( UBYTE, UBYTE );
    #endif
  #endif
#endif

GLOBAL CHAR* percentDBG ( CHAR* cl )
{
  SHORT line      = 1;
  SHORT polarity  = 1;
  SHORT delay     = 650;

  TRACE_FUNCTION ( "atPercentDBG()" );

  switch ( *cl )
  {
    case( '\0' ):
    {
      break;
    }

    case('='):
    {
      cl++;

      cl = parse ( cl, "rrr", &line, &polarity, &delay );

      if( !cl                          OR
          polarity < 0 OR polarity > 1 OR
          line     < 0 OR line     > 7 OR
          delay    < 0                    )
      {
        return ( NULL );
      }

      break;
    }

    default:
    {
      return ( NULL );
    }
  }

#ifndef TRACE_PORT_TIMING
  #ifdef _TMS470
    #if (CHIPSET == 0)
#if defined (NEW_FRAME)
  vsi_t_sleep ( VSI_CALLER ( T_TIME ) delay );
#else
      vsi_t_sleep ( VSI_CALLER ( T_VSI_TVALUE ) delay );
#endif

      l1s_set_debug_pin ( ( UBYTE ) line, ( UBYTE ) polarity );
    #endif
  #endif
#endif

  return ( cl );
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)         MODULE  : CMH_EXTS                 |
| STATE   : code                  ROUTINE : rAT_ACP                  |
+--------------------------------------------------------------------+

  PURPOSE : This function is called by the interpreter part of the
            ACI in case of aborting a pending extension command.

            <out>     : this parameter can be used to display some
                        strings at the AT command interface.
                        The first char of one string must contain
                        the length of the following string. The
                        special length 0xff must be used to define
                        the end of the string list.
            <outLen>  : maximum length of output buffer referenced
                        by parameter <out>.

*/

GLOBAL T_ACI_RETURN rAT_ACP (
                              CHAR*   out,
                              USHORT  outLen
                            )
{
  T_ACI_RETURN rslt = AT_CMPL;

  /* call the abort function if necessary */
  if ( currExtCmd NEQ AT_CMD_NONE )
    rslt = sAT_Abort (CMD_SRC_LCL, currExtCmd );

  switch ( rslt )
  {
    case ( AT_CMPL ):
    {
      currExtCmd = AT_CMD_NONE;

      ext_LeaveEXT ( TRUE );
    }
    break;

    case ( AT_EXCT ):
    {
      currExtCmd = AT_CMD_ABRT;
    }
    break;

    default:
    {
      /* do nothing */
    }
    break;
  }

  return rslt;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)         MODULE  : CMH_EXTS                 |
| STATE   : code                  ROUTINE : ext_OK                   |
+--------------------------------------------------------------------+

  PURPOSE : This function is called by the MMI in case the positive
            result of the asynchronous command handling is available.

            <cmdId>: command identity

*/
GLOBAL void ext_OK ( T_ACI_AT_CMD cmdId )
{
  T_ACI_RETURN rslt;

  if ( cmdId EQ AT_CMD_CFUN AND currAbrtCmd EQ AT_CMD_NONE )
  {
    rslt = sAT_PlusCOPS ( CMD_SRC_LCL,
                          COPS_MOD_Auto,
                          COPS_FRMT_NotPresent,
                          NULL );

    if ( rslt EQ AT_EXCT )
    {
      /*
       * generate some output at the AT interface
       */
      ext_CreatePString ( extBuffer, EXT_ATCOPS_START );

      sAT_URC ( extBuffer );

      /*
       * indicating that an extended AT command is still in progress
       */
      currExtCmd = AT_CMD_COPS;
    }
    else
    {
      ext_LeaveEXT ( TRUE );
      rCI_PlusCME ( AT_CMD_EXT, CME_ERR_Unknown );
    }
  }
  else if ( cmdId EQ AT_CMD_COPS AND currAbrtCmd EQ AT_CMD_NONE )
  {
    currExtCmd = AT_CMD_NONE;

    /*
     * generate some output at the AT interface
     */
    ext_CreatePString ( extBuffer, EXT_ATCOPS_STOP );

    sAT_URC ( extBuffer );

#ifndef WIN32
    ext_ContinueTest ( EXT_DIAL_VOICE_PASS );
#endif
  }
  else if ( cmdId EQ AT_CMD_D AND currAbrtCmd EQ AT_CMD_NONE )
  {
    extCallId = 1;

    ext_LeaveEXT ( TRUE );
    rCI_OK ( AT_CMD_EXT );
  }
  else if ( currAbrtCmd NEQ AT_CMD_NONE )
  {
    currAbrtCmd = AT_CMD_NONE;

    ext_LeaveEXT ( TRUE );
    rCI_OK ( AT_CMD_EXT );
  }
  else
  {
    /*
     * generate some output at the AT interface
     */
    ext_CreatePString ( extBuffer, EXT_UNEXPCTD );

    sAT_URC ( extBuffer );
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)         MODULE  : CMH_EXTS                 |
| STATE   : code                  ROUTINE : ext_LeaveExtension       |
+--------------------------------------------------------------------+

  PURPOSE : This function is called in case the extensin mechansim
            should be left finally.

            <final>: indicates whether final result code should be
                     sent explicitly

*/
LOCAL void ext_LeaveEXT ( BOOL final )
{
  /*
   * generate some output at the AT interface
   */
  ext_CreatePString ( extBuffer, EXT_LEAVE );

  /*
   * indicating that no extended AT command is still in progress
   */
  currExtCmd = AT_CMD_NONE;

  /*
   * indicate end of extended command handling to the AT interpreter
   */
  sAT_URC ( extBuffer );

  if ( final )
  {
    sAT_FRI ( extCmdLen );
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)         MODULE  : CMH_EXTS                 |
| STATE   : code                  ROUTINE : ext_ContinueTest         |
+--------------------------------------------------------------------+

  PURPOSE : This function is called in case the AT extension
            procedure should be continued.

            <id>: identifies the specific procedure to be continued

*/
GLOBAL void ext_ContinueTest ( CHAR* id )
{
  T_ACI_RETURN rslt;

  if ( strcmp ( id, EXT_DIAL_VOICE_PASS ) EQ 0 )
  {
    T_ACI_D_TOC callType = D_TOC_Data;

    if ( extDialNum [strlen ( extDialNum ) - 1] EQ EXT_VOICE_DELIMITER )
      callType = D_TOC_Voice;

    extDialNum[strlen ( extDialNum ) - 1] = '\0';

    rslt = sAT_Dn ( CMD_SRC_LCL,
                    extDialNum,
                    D_CLIR_OVRD_Default,
                    D_CUG_CTRL_NotPresent,
                    callType );

    if ( rslt EQ AT_EXCT )
    {
      /*
       * generate some output at the AT interface
       */
      ext_CreatePString ( extBuffer, EXT_ATD );

      sAT_URC ( extBuffer );

      /*
       * indicating that an extended AT command is still in progress
       */
      currExtCmd = AT_CMD_D;
    }
    else
    {
      ext_LeaveEXT ( TRUE );
      rCI_PlusCME ( AT_CMD_EXT, CME_ERR_Unknown );
    }
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)         MODULE  : CMH_EXTS                 |
| STATE   : code                  ROUTINE : ext_CreatePString        |
+--------------------------------------------------------------------+

  PURPOSE :

*/
LOCAL void ext_CreatePString ( CHAR* buffer, CHAR* text )
{
  buffer[0] = strlen (text);
  memcpy (&buffer[1], text, buffer[0]);
  buffer [buffer[0]+1] = (CHAR) 0xff;
}

LOCAL T_ACI_RETURN rAT_EXT_MI(CHAR*   cmd,
							  USHORT* cmdLen,
							  CHAR*   out,
							  USHORT  outLen
			   				  )
{
	int		index = 0;
	CHAR	lc_name[AT_EXT_AT_NAME] = {'\0'};
	T_AT_EXT_TABLE	*pTb = &at_exec_tb[0];

	EXT_AT_TRACE(("rAT_EXT_MI():cmd=%s, cmdLen=%d", cmd, *cmdLen));
	
	while(pTb->len != 0)
	{
		if(pTb->len > *cmdLen)	/* sort extended command in length order */
			return AT_FAIL;

		memset(lc_name, 0, AT_EXT_AT_NAME);
		memcpy(lc_name, cmd, pTb->len);
		
		if(!strcmp(pTb->name, lc_name))
		{
		/* command matched */
			cmd 	+= pTb->len;
			*cmdLen	-= pTb->len;

			if(*cmd == '=')	
			{
				cmd++;
				*cmdLen -= 1;
				
				if(*cmd == '?')	/* test cmd */
				{
					cmd++;
					*cmdLen -= 1;
					
					if(pTb->handle_t)
						return((*pTb->handle_t)(cmd, cmdLen, out, outLen, index));
					else
						return AT_FAIL;
				}
				else	/* set */
				{					
					if(pTb->handle_s)
						return((*pTb->handle_s)(cmd, cmdLen, out, outLen));
					else
						return AT_FAIL;
				}				
			}
			else if(*cmd == '?')	/* query cmd */
			{
				cmd++;
				*cmdLen -= 1;
				
				if(pTb->handle_q)
					return((*pTb->handle_q)(cmd, cmdLen, out, outLen));	
				else
					return AT_FAIL;	
			}
			else
				return AT_FAIL;
		}

		pTb++;
		index++;
	}

	EXT_AT_TRACE(("rAT_EXT_MI():failed!"));
	/* no matched ext command */
	return AT_FAIL;
}

/* general test output generator */
LOCAL T_ACI_RETURN gen_exec_t(CHAR *cmd, USHORT *cmdLen, CHAR *out, USHORT outLen, USHORT index)
{
	EXT_AT_TRACE(("gen_exec_t():cmd=%s, cmdLen=%d, index=%d", cmd, *cmdLen, index));

	ext_CreatePString(out, at_exec_tb[index].test_out);
	
	return AT_CMPL;
}

/* audio interface config query, compatible purpose only */
LOCAL T_ACI_RETURN saic_exec_q(CHAR *cmd, USHORT *cmdLen, CHAR *out, USHORT outLen)
{
	EXT_AT_TRACE(("asic_exec_q():len=%d,cmd=%s,outl=%d", *cmdLen, cmd, outLen));

	out[0]	= sprintf(&out[1], "%d,%d,%d", 1, 2, 2); 	
	out[out[0]+1] = 0xff;
		
	return AT_CMPL;
}

/* audio interface config setting, compatible purpose only */
LOCAL T_ACI_RETURN saic_exec_s(CHAR *cmd, USHORT *cmdLen, CHAR *out, USHORT outLen)
{
	SHORT	io, mic, ep;
	
	EXT_AT_TRACE(("asic_exec_s():len=%d,cmd=%s,outl=%d", *cmdLen, cmd, outLen));
	
	parse(cmd, "rrr", &io, &mic, &ep);
	EXT_AT_TRACE(("asic_exec_s():io=%2d,mic=%2d,ep=%2d", io, mic, ep));
	
	*cmdLen = 0;
	return AT_CMPL;
}

/* sperker volume level query */
LOCAL T_ACI_RETURN snfv_exec_q(CHAR *cmd, USHORT *cmdLen, CHAR *out, USHORT outLen)
{
	UBYTE	amp;
	
	EXT_AT_TRACE(("snfv_exec_q():len=%d,cmd=%s,outl=%d", *cmdLen, cmd, outLen));

	getVolSetting(&amp);
	
	if(amp != 0xff)
	{		
		out[0] = sprintf(&out[1], "%d", amp);
		out[out[0]+1] = 0xff;
		return AT_CMPL;
	}
		
	return AT_FAIL;	
}

/* speaker volume setting */
LOCAL T_ACI_RETURN snfv_exec_s(CHAR *cmd, USHORT *cmdLen, CHAR *out, USHORT outLen)
{	
	USHORT	amp;
	CHAR	*next;	

	EXT_AT_TRACE(("snfv_exec_q():len=%d,cmd=%s,outl=%d", *cmdLen, cmd, outLen));
	
	next = parse(cmd, "r", &amp);
	
	*cmdLen -= (next - cmd);
	if(amp < 7)
	{
		SetASpk_DownLinkPGA(amp);		
		return AT_CMPL;
	}	
	return AT_FAIL;
}

/* MUTE microphone query */
LOCAL T_ACI_RETURN snfm_exec_q(CHAR *cmd, USHORT *cmdLen, CHAR *out, USHORT outLen)
{
	USHORT mute;
	
	EXT_AT_TRACE(("snfm_exec_q():len=%d,cmd=%s,outl=%d", *cmdLen, cmd, outLen));

//	mute = SPIRead_ABB_Register(PAGE1, PWDNRG);
    mute =	ABB_Read_Register_on_page(PAGE1, PWDNRG );
	EXT_AT_TRACE(("snfm_exec_q():togreg=%d", mute));

	out[0] = sprintf(&out[1], "%d", mute & 0x0001);
	out[out[0]+1] = 0xff;
	
	return AT_CMPL;
}

/* MUTE microphone setting */
LOCAL T_ACI_RETURN snfm_exec_s(CHAR *cmd, USHORT *cmdLen, CHAR *out, USHORT outLen)
{
	SHORT mute;
	CHAR  *next;

	EXT_AT_TRACE(("snfm_exec_s():len=%d,cmd=%s,outl=%d", *cmdLen, cmd, outLen));

	next = parse(cmd, "r", &mute);

	EXT_AT_TRACE(("snfm_exec_s():mute=%d", mute));
	if(mute == 0)	// mute MIC
	{
		CloseMic();
	}
	else if(mute == 1)	// open MIC
	{
		OpenMic();
	}
	else
		return AT_FAIL;

	*cmdLen -= (next - cmd);
	return AT_CMPL;
}

/* audio hardware mode query */
LOCAL T_ACI_RETURN snfs_exec_q(CHAR *cmd, USHORT *cmdLen, CHAR *out, USHORT outLen)
{
	UBYTE mode;
	
	EXT_AT_TRACE(("snfs_exec_q():len=%d,cmd=%s,outl=%d", *cmdLen, cmd, outLen));

	getAudioHrdMode(&mode);

	out[0] = sprintf(&out[1], "%d", mode); 
	out[out[0]+1] = 0xff;
		
	return AT_CMPL;
}

/* audio hardware mode setting, 0: handheld, 1: handfree, 2: headset */
LOCAL T_ACI_RETURN snfs_exec_s(CHAR *cmd, USHORT *cmdLen, CHAR *out, USHORT outLen)
{
	SHORT	mode;
	CHAR*	next;
	
	EXT_AT_TRACE(("snfs_exec_q():len=%d,cmd=%s,outl=%d", *cmdLen, cmd, outLen));

	next = parse(cmd, "r", &mode);
	EXT_AT_TRACE(("snfs_exec_q():mode=%d",mode));

	*cmdLen -= (next - cmd);
	switch(mode)
	{
	case 0:
	case 1:	
		SetEarMode();
	break;

	case 2:
		SetHandsetMode();
	break;

	default:
		return AT_FAIL;
	}
	
	return AT_CMPL;
}