env_tty.c

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

{
    UINT8 baudrate0, parity0, databits0, stopbits0, flowctrl0;
    UINT8 baudrate1, parity1, databits1, stopbits1, flowctrl1;
    char  *raw;
    bool  init_from_env;

    SYSCON_read( SYSCON_BOARD_INIT_BASED_ON_ENV_ID,
		 (void *)&init_from_env, sizeof(bool) );

    if( init_from_env )
    {
        /* Get initial settings from environment variables */

	/* TTY 0 */
        if( !env_get( ENV_MODETTY0, &raw, NULL, 0 ) )
	    raw = default_modetty;

	env_modetty_string2parts( raw,
                                  &baudrate0,
				  &parity0,
				  &databits0,
				  &stopbits0,
				  &flowctrl0 );

	/* TTY 1 */
        if( !env_get( ENV_MODETTY1, &raw, NULL, 0 ) )
	    raw = default_modetty;	

	env_modetty_string2parts( raw,
                                  &baudrate1,
				  &parity1,
				  &databits1,
				  &stopbits1,
				  &flowctrl1 );
    }
    else
    {
        /* Fixed initial settings */

        baudrate0 = baudrate1 = DEFAULT_BAUDRATE;
        parity0   = parity1   = DEFAULT_PARITY;
	databits0 = databits1 = DEFAULT_DATABITS;
	stopbits0 = stopbits1 = DEFAULT_STOPBITS,
	flowctrl0 = flowctrl1 = DEFAULT_FLOWCTRL;
    }

    /**** Store initial settings ****/

    /* TTY0 */

    SYSCON_write( SYSCON_COM_TTY0_BAUDRATE_ID,
		  (void *)&baudrate0, sizeof(UINT8) );

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

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

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

    SYSCON_write( SYSCON_COM_TTY0_FLOWCTRL_ID,
		  (void *)&flowctrl0, sizeof(UINT8) );

    /* TTY 1 */

    SYSCON_write( SYSCON_COM_TTY1_BAUDRATE_ID,
		  (void *)&baudrate1, sizeof(UINT8) );

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

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

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

    SYSCON_write( SYSCON_COM_TTY1_FLOWCTRL_ID,
		  (void *)&flowctrl1, sizeof(UINT8) );
}


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


/*  Functions for converting an enumerated value to string describing
 *  the value
 */


/************************************************************************
 *		env_baudrate_num2s
 ************************************************************************/
bool				/* TRUE -> OK, FALSE -> Not OK		*/
env_baudrate_num2s( 
    UINT32 param,
    char   **s )
{  
    return search_num2s( param, s, 
		         baudrate_num2s_array, 
		         BAUDRATE_NUM2S_COUNT );
}


/************************************************************************
 *		env_databits_num2s
 ************************************************************************/
bool				/* TRUE -> OK, FALSE -> Not OK		*/
env_databits_num2s( 
    UINT32 param,
    char   **s)
{
    return search_num2s( param, s,
		         databits_num2s_array,
			 DATABITS_NUM2S_COUNT );
}


/************************************************************************
 *		env_parity_num2s
 ************************************************************************/
bool				/* TRUE -> OK, FALSE -> Not OK		*/
env_parity_num2s( 
    UINT32 param,
    char   **s )
{
    return search_num2s( param, s,
		         parity_num2s_array,
			 PARITY_NUM2S_COUNT );
}


/************************************************************************
 *		env_stopbits_num2s
 ************************************************************************/
bool				/* TRUE -> OK, FALSE -> Not OK		*/
env_stopbits_num2s( 
    UINT32 param,
    char   **s )
{
    return search_num2s( param, s,
		         stopbits_num2s_array,
			 STOPBITS_NUM2S_COUNT );
}


/************************************************************************
 *		env_flowctrl_num2s
 ************************************************************************/
bool				/* TRUE -> OK, FALSE -> Not OK		*/
env_flowctrl_num2s( 
    UINT32 param,
    char   **s )
{
    return search_num2s( param, s,
		         flowctrl_num2s_array,
			 FLOWCTRL_NUM2S_COUNT );
}


/*  Functions for converting string describing a serial port setting
 *  to corresponding enumerated value.
 */

/************************************************************************
 *		env_baudrate_s2num
 ************************************************************************/
bool				/* TRUE -> OK, FALSE -> Not OK		*/
env_baudrate_s2num( 
    char *raw,			/* The string				*/
    void *decoded,		/* Decoded data				*/
    UINT32 size )		/* Size of decoded data			*/
{
    return search_s2num( raw, decoded, size, 
		         baudrate_num2s_array,
			 BAUDRATE_NUM2S_COUNT );
}


/************************************************************************
 *		env_databits_s2num
 ************************************************************************/
bool				/* TRUE -> OK, FALSE -> Not OK		*/
env_databits_s2num( 
    char *raw,			/* The string				*/
    void *decoded,		/* Decoded data				*/
    UINT32 size )		/* Size of decoded data			*/
{
    return search_s2num( raw, decoded, size, 
			 databits_num2s_array,
			 DATABITS_NUM2S_COUNT );
}


/************************************************************************
 *		env_parity_s2num
 ************************************************************************/
bool				/* TRUE -> OK, FALSE -> Not OK		*/
env_parity_s2num( 
    char *raw,			/* The string				*/
    void *decoded,		/* Decoded data				*/
    UINT32 size )		/* Size of decoded data			*/
{
    return search_s2num( raw, decoded, size, 
			 parity_num2s_array,
			 PARITY_NUM2S_COUNT );
}


/************************************************************************
 *		env_stopbits_s2num
 ************************************************************************/
bool				/* TRUE -> OK, FALSE -> Not OK		*/
env_stopbits_s2num(
    char *raw,			/* The string				*/
    void *decoded,		/* Decoded data				*/
    UINT32 size )		/* Size of decoded data			*/
{
    return search_s2num( raw, decoded, size, 
			 stopbits_num2s_array,
			 STOPBITS_NUM2S_COUNT );
}


/************************************************************************
 *		env_flowctrl_s2num
 ************************************************************************/
bool				/* TRUE -> OK, FALSE -> Not OK		*/
env_flowctrl_s2num( 
    char *raw,			/* The string				*/
    void *decoded,		/* Decoded data				*/
    UINT32 size )		/* Size of decoded data			*/
{
    return search_s2num( raw, decoded, size, 
			 flowctrl_num2s_array,
			 FLOWCTRL_NUM2S_COUNT );
}


/************************************************************************
 *
 *                          env_setup_env_tty
 *  Description :
 *  -------------
 *
 *  Create TTY specific system environment variables
 *
 *  Return values :
 *  ---------------
 *
 *  TRUE -> OK, else FALSE
 *
 ************************************************************************/
bool
env_setup_env_tty(
    bool default_switch )
{
    /* Setup system environment variables if this was not done
     * at a previous run.
     */

    UINT8  uart_count;
    char   *raw;
    bool   rc = TRUE;

    /* Determine the number of serial ports */
    SYSCON_read( SYSCON_BOARD_UART_COUNT_ID, 
		 (void *)&uart_count, 
		 sizeof(UINT8) );

    /* Modetty */

    if( uart_count > 0 )
    {
        if( default_switch || !env_get( ENV_MODETTY0, &raw, NULL, 0 ) )
            raw = default_modetty;		  /* Create new */

        if( env_set( ENV_MODETTY0, raw, ENV_ATTR_RW, 
	             default_modetty, modetty_s2num0 ) != OK )
        {
            rc = FALSE;
        }
    }

    if( uart_count > 1 )
    {
        if( default_switch || !env_get( ENV_MODETTY1, &raw, NULL, 0 ) )
            raw = default_modetty;		  /* Create new */

        if( env_set( ENV_MODETTY1, raw, ENV_ATTR_RW, 
	     	     default_modetty, modetty_s2num1 ) != OK )
        {
            rc = FALSE;
        }
    }

    /* Default boot port (ASC) */
    if( default_switch || !env_get( "bootserport", &raw, NULL, 0 ) )
	raw = default_bootserport;    /* Create new */
    if( env_set( "bootserport", raw, ENV_ATTR_RW, 
		 default_bootserport, env_decode_bootserport ) != OK )
    {
        rc = FALSE;
    }

    /* Initial settings */
    register_initial();
    
    return rc;
}


/************************************************************************
 *
 *                          env_modetty_string2parts
 *  Description :
 *  -------------
 *
 *  Convert string containing serial port settings (environment
 *  variable format) to values.
 *
 *  Return values :
 *  ---------------
 *
 *  Always TRUE
 *
 ************************************************************************/
bool
env_modetty_string2parts(
    char  *raw,		/* String with settings (e.g. "9600,n,8,1,hw" ) */
    UINT8 *baudrate,
    UINT8 *parity,
    UINT8 *databits,
    UINT8 *stopbits,
    UINT8 *flowctrl )
{
    UINT32 mode;

    modetty_s2num( FALSE, 0, raw, &mode, sizeof(UINT32) );

    *baudrate = mode & 0xff;
    *parity   = (mode >>  8) & 0xff;
    *databits = (mode >> 16) & 0xff;
    *stopbits = (mode >> 24) & 0x0f;
    *flowctrl = (mode >> 28) & 0x0f;

    return TRUE;
}


/************************************************************************
 *
 *                          env_modetty_parts2string
 *  Description :
 *  -------------
 *
 *  Converts serial port settings to string containing the serial port
 *  configuration. Returns pointer to this string in parameter **s.
 *
 *  Return values :
 *  ---------------
 *
 *  Always TRUE
 *
 ************************************************************************/
bool
env_modetty_parts2string(
    char  **s,		
    UINT8 baudrate,
    UINT8 parity,
    UINT8 databits,
    UINT8 stopbits,
    UINT8 flowctrl )
{
    char         *myp;
    static char  myraw[24];   /* "921600,n,8,1,xonxoff" (max) */
    int          n;
    
    /* Contruct the string from its serial parts */
    if ( !env_baudrate_num2s( baudrate, &myp ) ) return FALSE;
    n = strlen(myp) + 1;
    if (n > sizeof(myraw)-1) return FALSE;
    strcpy(myraw, myp);
    strcat(myraw, ",");

    if ( !env_parity_num2s( parity, &myp ) ) return FALSE;
    n += strlen(myp) + 1;
    if (n > sizeof(myraw)-1) return FALSE;
    strcat(myraw, myp);
    strcat(myraw, ",");

    if ( !env_databits_num2s( databits, &myp ) ) return FALSE;
    n += strlen(myp) + 1;
    if (n > sizeof(myraw)-1) return FALSE;
    strcat(myraw, myp);
    strcat(myraw, ",");

    if ( !env_stopbits_num2s( stopbits, &myp ) ) return FALSE;
    n += strlen(myp)+1;
    if (n > sizeof(myraw)-1) return FALSE;
    strcat(myraw, myp);
    strcat(myraw, ",");

    if ( !env_flowctrl_num2s( flowctrl, &myp ) ) return FALSE;
    n += strlen(myp);
    if (n > sizeof(myraw)-1) return FALSE;
    strcat(myraw, myp);

    *s = myraw;

    return TRUE;
}


/************************************************************************
 *
 *                          env_decode_bootserport
 *  Description :
 *  -------------
 *
 *  Decode boot serial port
 *
 *  Return values :
 *  ---------------
 *
 *  TRUE -> OK, FALSE -> Failed
 *
 ************************************************************************/
bool 
env_decode_bootserport(
    char   *raw,		/* The string				*/
    void   *decoded,		/* Decoded data				*/
    UINT32 size )		/* Size of decoded data			*/
{
    if( decoded && (size != sizeof(UINT32)) )
        return FALSE;

    if( strcmp( raw, "tty0" ) == 0 )
    {
        if( decoded )
            *(UINT32 *)decoded = PORT_TTY0;
	return TRUE;
    }
    else if( strcmp( raw, "tty1" ) == 0 )
    {
        if( decoded )
            *(UINT32 *)decoded = PORT_TTY1;
	return TRUE;
    }
    else
        return FALSE;
}