stty.c

MIPS YAMON, a famous monitor inc. source, make file and PDF manuals.

    */
 
    if( action & ACTION_STORE )
	sprintf( msg, "Stored: " );
    else
	*msg = '\0';

    strcat( msg, "baudrate=" );
    env_baudrate_num2s( baudrate, &s );
    strcat( msg, s );

    strcat( msg, ", parity=" );
    env_parity_num2s( parity, &s );
    strcat( msg, s );

    strcat( msg, ", databits=" );
    env_databits_num2s( databits, &s );
    strcat( msg, s );

    strcat( msg, ", stopbits=" );
    env_stopbits_num2s( stopbits, &s );
    strcat( msg, s );

    strcat( msg, ", flowcontrol=" );
    env_flowctrl_num2s( flowctrl, &s );
    strcat( msg, s );

    strcat( msg, "\n" );

    if( SHELL_PUTS( msg ) ) return OK;


    if( (action & ACTION_READ) == 0 )
    {	
        /******************************
        ** move settings to "CURRENT"
        */

	if( port == PORT_TTY0 )
	{
            SYSCON_write( SYSCON_COM_TTY0_BAUDRATE_ID,
		   	  (void *)&baudrate, 
			  sizeof( UINT8 ) );

            SYSCON_write( SYSCON_COM_TTY0_PARITY_ID,
		   	  (void *)&parity, 
			  sizeof( UINT8 ) );

            SYSCON_write( SYSCON_COM_TTY0_DATABITS_ID,
		   	  (void *)&databits, 
			  sizeof( UINT8 ) );

            SYSCON_write( SYSCON_COM_TTY0_STOPBITS_ID,
		   	  (void *)&stopbits, 
			  sizeof( UINT8 ) );

            SYSCON_write( SYSCON_COM_TTY0_FLOWCTRL_ID,
		   	  (void *)&flowctrl, 
			  sizeof( UINT8 ) );
	}
	else
	{
            SYSCON_write( SYSCON_COM_TTY1_BAUDRATE_ID,
	  	          (void *)&baudrate, 
			  sizeof( UINT8 ) );

            SYSCON_write( SYSCON_COM_TTY1_PARITY_ID,
		   	  (void *)&parity, 
			  sizeof( UINT8 ) );

            SYSCON_write( SYSCON_COM_TTY1_DATABITS_ID,
		   	  (void *)&databits, 
			  sizeof( UINT8 ) );

            SYSCON_write( SYSCON_COM_TTY1_STOPBITS_ID,
		   	  (void *)&stopbits, 
			  sizeof( UINT8 ) );

            SYSCON_write( SYSCON_COM_TTY1_FLOWCTRL_ID,
		   	  (void *)&flowctrl, 
			  sizeof( UINT8 ) );
	}
	    
        /*******************************
        ** apply "CURRENT" settings 
        */

	re_init_port(port);
    }

    return OK;
}


/************************************************************************
 *                          re_init_port
 ************************************************************************/
static void
re_init_port(
    UINT32 port )
{
    /* Reinitialise device in order for the settings 
     * to take effect.
     */
 
    UINT32 major, minor;

    SYSCON_read( (port == PORT_TTY0) ? SYSCON_COM_TTY0_MAJOR : SYSCON_COM_TTY1_MAJOR,
	         (void *)(&major),
		 sizeof(UINT32) );

    SYSCON_read( (port == PORT_TTY0) ? SYSCON_COM_TTY0_MINOR : SYSCON_COM_TTY1_MINOR,
		 (void *)(&minor),
		 sizeof(UINT32) );

    if( port == DEFAULT_PORT )
    {
        SHELL_PUTS( "Reconfigure terminal program\n" );
        sys_wait_ms( 100 );
    }

    IO_init( major, minor, (void *)&port );
}


/************************************************************************
 *                          get_options
 *
 *  stty [-tty<0|1>] [-b|-u| [-p][<baudrate>][n|o|e][7|8][1|2][hw|none]]
 *  legal syntaxes:      Action:           Output:
 *    stty * -b          _READ | _LIST     baud rate possibilities
 *    stty * -u          _UPDATE           new settings + "Reconfigure..."
 *    stty *             _READ             settings
 *    stty * -p          _READ | _STORE    settings
 *    stty * -p <parm>   _STORE            new settings + "Reconfigure..."
 *    stty * <parm>      0                 "Reconfigure terminal program"
 *    b <baudrate>       0                 "Reconfigure terminal program"
 *
 ************************************************************************/
static UINT32
get_options(
    UINT32 argc,
    char   **argv,
    UINT8  *action,
    UINT8  *port,
    UINT8  *baudrate,
    UINT8  *parity,
    UINT8  *databits,
    UINT8  *stopbits,
    UINT8  *flowctrl,
    bool   sdb )
{
    char   *token;
    bool   ok             = TRUE;
    bool   baudrate_valid = FALSE;
    bool   parity_valid   = FALSE;
    bool   databits_valid = FALSE;
    bool   stopbits_valid = FALSE;
    bool   flowctrl_valid = FALSE;
    UINT32 arg;
    UINT32 error = SHELL_ERROR_SYNTAX;

    /* Setup defaults */
    *action   = ACTION_READ;
    *port     = DEFAULT_PORT;

    for( arg = 1; 
	          ok && 
	          (arg < argc) && 
		  (token = argv[arg]);
         arg++ )
    {
	 if( env_baudrate_s2num( token, baudrate, sizeof(UINT8)))
	 {             *action &= ~ACTION_READ;
             ok = !baudrate_valid;
             baudrate_valid = TRUE;
	 }
	 else if( sdb )
	 {
            if( *token == '-' )
	    {
	        error            = SHELL_ERROR_OPTION;
		shell_error_data = token;
		ok		 = FALSE;
	    }
         }
	 else if( (uart_count > 1) &&
	          (strcmp( token, "-tty0" )) == 0 )
	 {
	     *port = PORT_TTY0;
	 }
	 else if( (uart_count > 1) &&
	          (strcmp( token, "-tty1" )) == 0 )
	 {
	     *port = PORT_TTY1;
	 }
	 else if( strcmp( token, "-b" ) == 0 )
	 {
	     *action |= ACTION_LIST;
	 }
         else if( strcmp( token, "-u" ) == 0 )
	 {
             /* ACTION_READ is cleared below - after syntax checking */
	     *action |= ACTION_UPDATE;
	 }
         else if( strcmp( token, "-p" ) == 0 )
	 {
	     *action |= ACTION_STORE;
	 }
	 else if( env_parity_s2num( token, parity, sizeof(UINT8)))
	 {
             *action &= ~ACTION_READ;
             ok = !parity_valid;
             parity_valid = TRUE;
	 }
	 else if( env_databits_s2num( token, databits, sizeof(UINT8)))
	 {
             *action &= ~ACTION_READ;
             ok = !databits_valid;
             databits_valid = TRUE;
	 }
	 else if( env_stopbits_s2num( token, stopbits, sizeof(UINT8)))
	 {
             *action &= ~ACTION_READ;
             ok = !stopbits_valid;
             stopbits_valid = TRUE;
	 }
	 else if( env_flowctrl_s2num( token, flowctrl, sizeof(UINT8)))
	 {
             *action &= ~ACTION_READ;
             ok = !flowctrl_valid;
             flowctrl_valid = TRUE;
	 }
	 else
	 {
	    ok = FALSE;
	   
            if( *token == '-' )
	    {
	        error            = SHELL_ERROR_OPTION;
		shell_error_data = token;
	    }
	 }
    }

    /* Syntax check: Allow only legal combinations of options */
    if( sdb )
    {
        if (!(*action == 0 ) )
            ok = FALSE;
    }
    else
    {
        if (!(*action == 0 ||
              *action == (ACTION_READ)  ||
              *action == (ACTION_READ|ACTION_LIST)  ||
              *action == (ACTION_READ|ACTION_STORE)  ||
              *action == (ACTION_READ|ACTION_UPDATE)  ||
              *action == (ACTION_STORE) ) )
            ok = FALSE;
    }

    /* modify temporary action value used for syntax check */
    if (*action == (ACTION_READ|ACTION_UPDATE))
        *action &= ~ACTION_READ;

    if( !ok )
        return error;

    if( baudrate_valid )
    {
        /*  Validate baudrate for specific port.
         *  If the following write operation fails, the baudrate is
	 *  not supported.
	 */
	if( SYSCON_write( (*port == PORT_TTY0) ?
		              SYSCON_COM_TTY0_BAUDRATE_VERIFY_ID :
			      SYSCON_COM_TTY1_BAUDRATE_VERIFY_ID,
		          (void *)baudrate, sizeof(UINT8) ) != OK )
        {
	    return SHELL_ERROR_BAUDRATE;
	}
    }
    else
    {
        SYSCON_read( (*port == PORT_TTY0) ?
		          SYSCON_COM_TTY0_BAUDRATE_ID :
		          SYSCON_COM_TTY1_BAUDRATE_ID,
		     (void *)baudrate, sizeof(UINT8) );
    }

    if( !parity_valid )
    {
        SYSCON_read( (*port == PORT_TTY0) ?
		          SYSCON_COM_TTY0_PARITY_ID :
		          SYSCON_COM_TTY1_PARITY_ID,
		     (void *)parity, sizeof(UINT8) );
    }

    if( !databits_valid )
    {
        SYSCON_read( (*port == PORT_TTY0) ?
		          SYSCON_COM_TTY0_DATABITS_ID :
		          SYSCON_COM_TTY1_DATABITS_ID,
		     (void *)databits, sizeof(UINT8) );
    }

    if( !stopbits_valid )
    {
        SYSCON_read( (*port == PORT_TTY0) ?
		          SYSCON_COM_TTY0_STOPBITS_ID :
		          SYSCON_COM_TTY1_STOPBITS_ID,
		     (void *)stopbits, sizeof(UINT8) );
    }
    
    if( !flowctrl_valid )
    {
        SYSCON_read( (*port == PORT_TTY0) ?
		          SYSCON_COM_TTY0_FLOWCTRL_ID :
		          SYSCON_COM_TTY1_FLOWCTRL_ID,
		     (void *)flowctrl, sizeof(UINT8) );
    }
    
    return ok ? OK : error;
}


/************************************************************************
 *  Implementation : Public functions
 ************************************************************************/

/************************************************************************
 *
 *                          shell_stty_init
 *  Description :
 *  -------------
 *
 *  Initialise command
 *
 *  Return values :
 *  ---------------
 *
 *  void
 *
 ************************************************************************/
t_cmd *
shell_stty_init( void )
{
    /* Determine the number of serial ports */
    SYSCON_read( SYSCON_BOARD_UART_COUNT_ID, 
		 (void *)&uart_count, 
		 sizeof(UINT8) );

    if( uart_count > 1 )
    {
        cmd_def.syntax       = syntax;
	cmd_def.option_count = OPTION_COUNT;
	cmd_def.descr	     = help_text;
    }
    else
    {
        cmd_def.syntax       = syntax_one_tty;
	cmd_def.option_count = OPTION_COUNT_ONE_TTY;
	cmd_def.descr	     = help_text_one_tty;
    }

    return &cmd_def;
}

/************************************************************************
 *
 *                          shell_stty_sdb_init
 *  Description :
 *  -------------
 *
 *  Initialise command
 *
 *  Return values :
 *  ---------------
 *
 *  void
 *
 ************************************************************************/
t_cmd *
shell_stty_sdb_init( void )
{
    return &cmd_def_sdb_lower;
}