Subversion Repositories openrisc

// ==========================================================================

//

//      serial.c

//

//      Public Domain Curses for eCos

//

// ===========================================================================

// ####ECOSGPLCOPYRIGHTBEGIN####                                            

// -------------------------------------------                              

// This file is part of eCos, the Embedded Configurable Operating System.   

// Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.

//

// eCos 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 or (at your option) any later      

// version.                                                                 

//

// eCos is distributed in the hope that it will be useful, but WITHOUT      

// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or    

// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License    

// for more details.                                                        

//

// You should have received a copy of the GNU General Public License        

// along with eCos; if not, write to the Free Software Foundation, Inc.,    

// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.            

//

// As a special exception, if other files instantiate templates or use      

// macros or inline functions from this file, or you compile this file      

// and link it with other works to produce a work based on this file,       

// this file does not by itself cause the resulting work to be covered by   

// the GNU General Public License. However the source code for this file    

// must still be made available in accordance with section (3) of the GNU   

// General Public License v2.                                               

//

// This exception does not invalidate any other reasons why a work based    

// on this file might be covered by the GNU General Public License.         

// -------------------------------------------                              

// ####ECOSGPLCOPYRIGHTEND####                                              

// ===========================================================================

// ===========================================================================

// #####DESCRIPTIONBEGIN####

//

// Author(s):    Sergei Gavrikov

// Contributors: Sergei Gavrikov

// Date:         2009-04-24

// Purpose:      PDCurses driver for a serial device

// Description:

//

// ####DESCRIPTIONEND####

//

// ========================================================================*/

#include <cyg/kernel/kapi.h>           // cyg_thread_delay

#include <cyg/infra/diag.h>            // diagnostic routings

#include <stdlib.h>                    // free, calloc

// eCos serial devices

#include <cyg/io/io.h>

#include <pkgconf/io_serial.h>

#include <cyg/io/serialio.h>

#include <cyg/io/config_keys.h>

// PDCurses

#include <pkgconf/pdcurses.h>

#include <curspriv.h>

#define NDEBUG

#if CYGDAT_PDCURSES_DRIVER_USE_VT100_ATTR

# define ENABLE_VT100_ATTR

#endif

#if CYGDAT_PDCURSES_DRIVER_USE_ANSI_COLORS

# define ENABLE_COLOR

#endif

#if CYGDAT_PDCURSES_DRIVER_USE_KEYPAD_KEYS

# define ENABLE_KEYPAD

#endif

static char     device[] = CYGDAT_PDCURSES_DRIVER_SERIAL_DEV;

static cyg_io_handle_t handle = NULL;

// ---------------------------------------------------------------------------

// acs_map --

//

// A port of PDCurses must provide acs_map[], a 128-element array of chtypes,

// with values laid out based on the Alternate Character Set of the VT100

// (see curses.h). PDC_transform_line() must use this table; when it

// encounters a chtype with the A_ALTCHARSET flag set. For far details reffer

// to a pdcurses/IMPLEMNT document.

chtype          acs_map[128];

// ---------------------------------------------------------------------------

unsigned long   pdc_key_modifiers = 0L;

// ---------------------------------------------------------------------------

// atrtab --

//

// An attibutes table (it is used internally for the port's PDC_init_pair(),

// PDC_pair_content().

static struct {

    short           f,

                    b;

} atrtab[PDC_COLOR_PAIRS];

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

// __gotoyx --

//

static void

__gotoyx(int y, int x)

{

    char            buf[8] = { '\033', '[', '0', '0', ';', '0', '0', 'H' };

    unsigned int    len = sizeof(buf);

    buf[2] = ((y + 1) / 10) + '0';

    buf[3] = ((y + 1) % 10) + '0';

    buf[5] = ((x + 1) / 10) + '0';

    buf[6] = ((x + 1) % 10) + '0';

    cyg_io_write(handle, buf, &len);

}

// ---------------------------------------------------------------------------

// PDC_gotoyx --

//

// Move the physical cursor (as opposed to the logical cursor affected by

// wmove()) to the given location. This is called mainly from doupdate(). In

// general, this function need not compare the old location with the new one,

// and should just move the cursor unconditionally.

// ---------------------------------------------------------------------------

void

PDC_gotoyx(int y, int x)

{

#ifdef DEBUG

    diag_printf("PDC_gotoyx called: x %d y %d\n", x, y);

#endif

    __gotoyx(y, x);

    cyg_io_get_config(handle, CYG_IO_GET_CONFIG_SERIAL_OUTPUT_DRAIN, NULL,

                      NULL);

}

// ---------------------------------------------------------------------------

// PDC_transform_line --

//

// The core output routine. It takes len chtype entities from srcp (a pointer

// into curscr) and renders them to the physical screen at line lineno,

// column x. It must also translate characters 0-127 via acs_map[], if

// they're flagged with A_ALTCHARSET in the attribute portion of the chtype.

// ---------------------------------------------------------------------------

static short    curstoansi[8] = { 0, 4, 2, 6, 1, 5, 3, 7 };

static chtype   prev_attr = A_PROTECT;

void

PDC_transform_line(int lineno, int x, int len, const chtype *srcp)

{

    int             i;

    chtype          attr;

#ifdef DEBUG

    diag_printf("PDC_transform_line called: lineno %d curpos %d len %d\n",

                lineno, x, len);

#endif

    __gotoyx(lineno, x);

    for (i = 0; i < len; i++) {

        unsigned char   byte;

        chtype          ch = srcp[i];

        unsigned int    single = 1;

#if defined(ENABLE_COLOR) || defined(ENABLE_VT100_ATTR)

        attr = ch & A_ATTRIBUTES;

        // <ESC>[#; ... m

        if (prev_attr != attr) {

            short           fg,

                            bg,

                            pair;

            char            escape[32];

            unsigned int    count;

            count = 0;

            escape[count++] = '\x1b';

            escape[count++] = '[';

            escape[count++] = '0';

# ifdef ENABLE_COLOR

            pair = PAIR_NUMBER(attr);

            fg = curstoansi[atrtab[pair].f];

            bg = curstoansi[atrtab[pair].b];

            escape[count++] = ';';

            escape[count++] = '3';

            escape[count++] = '0' + fg;

            escape[count++] = ';';

            escape[count++] = '4';

            escape[count++] = '0' + bg;

# endif                         // ENABLE_COLOR

# ifdef ENABLE_VT100_ATTR

            if (attr & A_BOLD) {

                escape[count++] = ';';

                escape[count++] = '1';

            }

            if (attr & A_UNDERLINE) {

                escape[count++] = ';';

                escape[count++] = '4';

            }

            if (attr & A_BLINK) {

                escape[count++] = ';';

                escape[count++] = '5';

            }

            if (attr & A_REVERSE) {

                escape[count++] = ';';

                escape[count++] = '7';

            }

            if (attr & A_INVIS) {

                escape[count++] = ';';

                escape[count++] = '8';

            }

# endif                         // ENABLE_VT100_ATTR

            escape[count++] = 'm';

            cyg_io_write(handle, escape, &count);

            prev_attr = attr;

        }

#endif                          // ENABLE_COLOR || ENABLE_VT100_ATTR

#ifdef CHTYPE_LONG

        if (ch & A_ALTCHARSET && !(ch & 0xff80))

            ch = acs_map[ch & 0x7f];

#endif

        ch &= 0xff;

        byte = (unsigned char) ch;

        cyg_io_write(handle, &byte, &single);

    }

    cyg_io_get_config(handle, CYG_IO_GET_CONFIG_SERIAL_OUTPUT_DRAIN, NULL,

                      NULL);

}

// ---------------------------------------------------------------------------

// PDC_get_columns --

//

// Returns the size of the screen in columns. It's used in resize_term() to

// set the new value of COLS. (Some existing implementations also call it

// internally from PDC_scr_open(), but this is not required.)

// ---------------------------------------------------------------------------

int

PDC_get_columns(void)

{

    return CYGDAT_PDCURSES_DRIVER_SCREEN_COLUMNS;

}

// ---------------------------------------------------------------------------

// PDC_get_cursor_mode --

//

// Returns the size/shape of the cursor. The format of the result is

// unspecified, except that it must be returned as an int. This function is

// called from initscr(), and the result is stored in SP->orig_cursor, which

// is used by PDC_curs_set() to determine the size/shape of the cursor in

// normal visibility mode (curs_set(1)).

// ---------------------------------------------------------------------------

int

PDC_get_cursor_mode(void)

{

    return 0;

}

// ---------------------------------------------------------------------------

// PDC_get_rows --

//

// Returns the size of the screen in rows. It's used in resize_term() to set

// the new value of LINES. (Some existing implementations also call it

// internally from PDC_scr_open(), but this is not required.)

// ---------------------------------------------------------------------------

int

PDC_get_rows(void)

{

    return CYGDAT_PDCURSES_DRIVER_SCREEN_ROWS;

}

// ---------------------------------------------------------------------------

// PDC_check_key --

//

// Keyboard/mouse event check, called from wgetch(). Returns TRUE if there's

// an event ready to process. This function must be non-blocking.

// ---------------------------------------------------------------------------

static int      key_code = ERR;

static unsigned char keystroke[4] = { '\0', '\0', '\0', '\0' };

#define _FLSH_KEY() *(unsigned int *) &keystroke[0] = 0;

#if (CYG_BYTEORDER == CYG_LSBFIRST)

// Little endian

# define _UNGET_KEY(_n_)  *(unsigned int *) &keystroke[0] >>= 8*(_n_)

#elif (CYG_BYTEORDER == CYG_MSBFIRST)

// Big endian

# define _UNGET_KEY(_n_)  *(unsigned int *) &keystroke[0] <<= 8*(_n_)

#endif

bool

PDC_check_key(void)

{

    unsigned int    len,

                    count;

    cyg_serial_buf_info_t dev_buf_conf;

    len = sizeof(dev_buf_conf);

    cyg_io_get_config(handle, CYG_IO_GET_CONFIG_SERIAL_BUFFER_INFO,

                      &dev_buf_conf, &len);

#ifndef ENABLE_KEYPAD

    return (dev_buf_conf.rx_count > 0);

#else

    if ((count = dev_buf_conf.rx_count) > 0) {

        if (keystroke[0] == '\0') {

            count = min(count, 4);

            cyg_io_read(handle, &keystroke[0], &count);

        } else if (keystroke[1] == '\0') {

            count = min(count, 3);

            cyg_io_read(handle, &keystroke[1], &count);

        } else if (keystroke[2] == '\0') {

            count = min(count, 2);

            cyg_io_read(handle, &keystroke[2], &count);

        } else if (keystroke[3] == '\0') {

            count = min(count, 1);

            cyg_io_read(handle, &keystroke[3], &count);

        }

    }

    if (keystroke[0] == '\0')

        return FALSE;

    switch (keystroke[0]) {

    case '\x1b':

        switch (keystroke[1]) {

        case '[':

            switch (keystroke[2]) {

                // ^[[A -- KEY_UP

            case 'A':

                key_code = KEY_UP;

                _UNGET_KEY(3);

                return TRUE;

                // ^[[B -- KEY_DOWN

            case 'B':

                key_code = KEY_DOWN;

                _UNGET_KEY(3);

                return TRUE;

                // ^[[C -- KEY_RIGHT

            case 'C':

                key_code = KEY_RIGHT;

                _UNGET_KEY(3);

                return TRUE;

                // ^[[D -- KEY_LEFT

            case 'D':

                key_code = KEY_LEFT;

                _UNGET_KEY(3);

                return TRUE;

            case '1':

            case '4':

            case '5':

            case '6':

                switch (keystroke[3]) {

                case '~':

                    switch (keystroke[2]) {

                        // ^[[1~ -- KEY_HOME

                    case '1':

                        key_code = KEY_HOME;

                        _FLSH_KEY();

                        return TRUE;

                        // ^[[4~ -- KEY_END

                    case '4':

                        key_code = KEY_END;

                        _FLSH_KEY();

                        return TRUE;

                        // ^[[5~ -- KEY_PPAGE

                    case '5':

                        key_code = KEY_PPAGE;

                        _FLSH_KEY();

                        return TRUE;

                        // ^[[6~ -- KEY_NPAGE

                    case '6':

                        key_code = KEY_NPAGE;

                        _FLSH_KEY();

                        return TRUE;

                    }

                default:

                    break;

                }

            default:

                break;

            }

        case 'O':

            switch (keystroke[2]) {

                // ^[OF -- KEY_END

            case 'F':

                key_code = KEY_END;

                _UNGET_KEY(3);

                return TRUE;

                // ^[OH -- KEY_HOME

            case 'H':

                key_code = KEY_HOME;

                _UNGET_KEY(3);

                return TRUE;

            default:

                break;

            }

        default:

            break;

        }

    default:

        break;

    }

    key_code = keystroke[0];

    _UNGET_KEY(1);

    return TRUE;

#endif                          // ENABLE_KEYPAD

}

// ---------------------------------------------------------------------------

// PDC_flushinp --

//

// This is the core of flushinp(). It discards any pending key or mouse

// events, removing them from any internal queue and from the OS queue, if

// applicable.

// ---------------------------------------------------------------------------

void

PDC_flushinp(void)

{

    cyg_io_get_config(handle, CYG_IO_GET_CONFIG_SERIAL_INPUT_FLUSH, NULL,

                      NULL);

#ifdef ENABLE_KEYPAD

    _FLSH_KEY();

#endif

}

// ---------------------------------------------------------------------------

// PDC_get_key --

//

// Get the next available key, or mouse event (indicated by a return of

// KEY_MOUSE), and remove it from the OS' input queue, if applicable. This

// function is called from wgetch(). This function may be blocking, and

// traditionally is; but it need not be. If a valid key or mouse event cannot

// be returned, for any reason, this function returns -1. For more details

// read `pdcurses/IMPLEMNT' document.

// ---------------------------------------------------------------------------

int

PDC_get_key(void)

{

#ifndef ENABLE_KEYPAD

    int             input = 0;

    unsigned int    count = 1;

    if (ENOERR == cyg_io_read(handle, &input, &count))

        return input;

    return ERR;

#else

    return key_code;

#endif                          // ENABLE_KEYPAD

}

// ---------------------------------------------------------------------------

// PDC_modifiers_set --

//

// Called from PDC_return_key_modifiers(). If your platform needs to do

// anything in response to a change in SP->return_key_modifiers, do it here.

// Returns OK or ERR, which is passed on by the caller.

// ---------------------------------------------------------------------------

int

PDC_modifiers_set(void)

{

    return ERR;

}

// ---------------------------------------------------------------------------

// PDC_mouse_set --

//

// Called by mouse_set(), mouse_on(), and mouse_off() -- all the functions

// that modify SP->_trap_mbe. If your platform needs to do anything in

// response to a change in SP->_trap_mbe (for example, turning the mouse

// cursor on or off), do it here. Returns OK or ERR, which is passed on by

// the caller.

// ---------------------------------------------------------------------------

int

PDC_mouse_set(void)

{

    return ERR;

}

// ---------------------------------------------------------------------------

// PDC_set_keyboard_binary --

//

// Set keyboard input to "binary" mode. If you need to do something to keep

// the OS from processing ^C, etc. on your platform, do it here. TRUE turns

// the mode on; FALSE reverts it. This function is called from raw() and

// noraw().

// ---------------------------------------------------------------------------

void

PDC_set_keyboard_binary(bool on)

{

#ifdef DEBUF

    diag_printf("PDC_set_keyboard_binary() called: on %d\n", on);

#endif

}

// ---------------------------------------------------------------------------

// PDC_can_change_color --

//

// Returns TRUE if init_color() and color_content() give meaningful results,

// FALSE otherwise. Called from can_change_color().

// ---------------------------------------------------------------------------

bool

PDC_can_change_color(void)

{

    return FALSE;

}

// ---------------------------------------------------------------------------

// PDC_color_content --

//

// The core of color_content(). This does all the work of that function,

// except checking for values out of range and null pointers.

// ---------------------------------------------------------------------------

int

PDC_color_content(short color, short *red, short *green, short *blue)

{

    return ERR;

}

// ---------------------------------------------------------------------------

// PDC_init_color --

//

// The core of init_color(). This does all the work of that function, except

// checking for values out of range.

// ---------------------------------------------------------------------------

int

PDC_init_color(short color, short red, short green, short blue)

{

    return ERR;

}

// ---------------------------------------------------------------------------

// PDC_init_pair --

//

// The core of init_pair(). This does all the work of that function, except

// checking for values out of range. The values passed to this function

// should be returned by a call to PDC_pair_content() with the same pair

// number. PDC_transform_line() should use the specified colors when

// rendering a chtype with the given pair number.

// ---------------------------------------------------------------------------

void

PDC_init_pair(short pair, short fg, short bg)

{

#ifdef DEBUG

    diag_printf("PDC_init_pair called: pair %d fg %d bg %d\n", pair, fg,

                bg);

#endif

    atrtab[pair].f = fg;

    atrtab[pair].b = bg;

}

// ---------------------------------------------------------------------------

// PDC_pair_content --

//

// The core of pair_content(). This does all the work of that function,

// except checking for values out of range and null pointers.

// ---------------------------------------------------------------------------

int

PDC_pair_content(short pair, short *fg, short *bg)

{

    *fg = atrtab[pair].f;

    *bg = atrtab[pair].b;

    return OK;

}

// ---------------------------------------------------------------------------

// PDC_reset_prog_mode --

//

// The non-portable functionality of reset_prog_mode() is handled here --

// whatever's not done in _restore_mode(). In current ports: In OS/2, this

// sets the keyboard to binary mode; in Win32, it enables or disables the

// mouse pointer to match the saved mode; in others it does nothing.

// ---------------------------------------------------------------------------

void

PDC_reset_prog_mode(void)

{

}

// ---------------------------------------------------------------------------

// PDC_reset_shell_mode --

//

// The same thing, for reset_shell_mode(). In OS/2 and Win32, it restores the

// default console mode; in others it does nothing.

// ---------------------------------------------------------------------------

void

PDC_reset_shell_mode(void)

{

}

// ---------------------------------------------------------------------------

// PDC_resize_screen --

//

// This does the main work of resize_term(). It may respond to non-zero

// parameters, by setting the screen to the specified size; to zero

// parameters, by setting the screen to a size chosen by the user at runtime,

// in an unspecified way (e.g., by dragging the edges of the window); or

// both. It may also do nothing, if there's no appropriate action for the

// platform.

// ---------------------------------------------------------------------------

int

PDC_resize_screen(int nlines, int ncols)

{

    if (nlines == 0 && ncols == 0)

        return OK;

    SP->resized = FALSE;

    SP->cursrow = SP->curscol = 0;

    return OK;

}

// ---------------------------------------------------------------------------

// PDC_restore_screen_mode --

//

// Called from _restore_mode() in kernel.c, this function does the actual

// mode changing, if applicable. Currently used only in DOS and OS/2.

// ---------------------------------------------------------------------------

void

PDC_restore_screen_mode(int i)

{

}

// ---------------------------------------------------------------------------

// PDC_save_screen_mode --

//

// Called from _save_mode() in kernel.c, this function saves the actual

// screen mode, if applicable. Currently used only in DOS and OS/2.

// ---------------------------------------------------------------------------

void

PDC_save_screen_mode(int i)

{

}

// ---------------------------------------------------------------------------

// PDC_scr_close --

//

// The platform-specific part of endwin(). It may restore the image of the

// original screen saved by PDC_scr_open(), if the PDC_RESTORE_SCREEN

// environment variable is set; either way, if using an existing terminal,

// this function should restore it to the mode it had at startup, and move

// the cursor to the lower left corner. (The X11 port does nothing.)

// ---------------------------------------------------------------------------

void

PDC_scr_close(void)

{

    handle = NULL;

}

// ---------------------------------------------------------------------------

// PDC_scr_free --

//

// Frees the memory for SP allocated by PDC_scr_open(). Called by

// delscreen().

// ---------------------------------------------------------------------------

void

PDC_scr_free(void)

{

#ifdef DEBUG

    diag_printf("PDC_scr_free called\n");

#endif

    if (SP)

        free(SP);

}

// ---------------------------------------------------------------------------

// PDC_scr_open --

//

// The platform-specific part of initscr(). It's actually called from

// Xinitscr(); the arguments, if present, correspond to those used with

// main(), and may be used to set the title of the terminal window, or for

// other, platform-specific purposes.

// ---------------------------------------------------------------------------

int

PDC_scr_open(int argc, char **argv)

{

    static bool     acs_map_init = false;

    int             i = 0;

#ifdef DEBUG

    diag_printf("PDC_scr_open called\n");

#endif

    if (NULL == handle) {

        unsigned int    wait = 0;