Subversion Repositories openrisc

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

//

//      vnc_kbd.c

//

//

//

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

// ####ECOSGPLCOPYRIGHTBEGIN####                                            

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

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

// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 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):    Chris Garry <cgarry@sweeneydesign.co.uk>

// Contributors:

// Date:         2003-08-22

// Purpose:

// Description:  Keyboard driver for the VNC serevr

//

//####DESCRIPTIONEND####

//

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

#include <cyg/kernel/kapi.h>

#include <cyg/infra/diag.h>   /* diag_printf */

#include <cyg/hal/hal_io.h>

#include <cyg/hal/hal_arch.h>

#include <cyg/hal/drv_api.h>

#include <cyg/hal/hal_intr.h>

#include <cyg/infra/cyg_type.h>

#include <cyg/infra/cyg_ass.h>

#include <cyg/fileio/fileio.h>  // For select() functionality

#include <cyg/io/devtab.h>

#include <pkgconf/vnc_server.h>

/* Local function prototypes */

static Cyg_ErrNo kbd_read(cyg_io_handle_t handle,

                          void *buffer,

                          cyg_uint32 *len);

static cyg_bool  kbd_select(cyg_io_handle_t handle,

                            cyg_uint32 which,

                            cyg_addrword_t info);

static Cyg_ErrNo kbd_set_config(cyg_io_handle_t handle,

                                cyg_uint32 key,

                                const void *buffer,

                                cyg_uint32 *len);

static Cyg_ErrNo kbd_get_config(cyg_io_handle_t handle,

                                cyg_uint32 key,

                                void *buffer,

                                cyg_uint32 *len);

static bool      kbd_init(struct cyg_devtab_entry *tab);

static Cyg_ErrNo kbd_lookup(struct cyg_devtab_entry **tab,

                            struct cyg_devtab_entry *st,

                            const char *name);

CHAR_DEVIO_TABLE(vnc_kbd_handlers,

                 NULL,                    /* Unsupported write() function */

                 kbd_read,

                 kbd_select,

                 kbd_get_config,

                 kbd_set_config);

CHAR_DEVTAB_ENTRY(vnc_kbd_device,

                  CYGDAT_VNC_SERVER_KEYBOARD_NAME,

                  NULL,                   /* Base device name */

                  &vnc_kbd_handlers,

                  kbd_init,

                  kbd_lookup,

                  NULL);                  /* Private data pointer */

#define MAX_EVENTS CYGNUM_VNC_SERVER_KEYBOARD_EVENTS

static cyg_uint8 data_queue[MAX_EVENTS*4];

static int queue_put_ptr = 0;

static int queue_get_ptr = 0;

static int data_in_queue = 0;

static cyg_selinfo  kbd_select_info;

static cyg_bool     kbd_select_active;

static int kbd_active = 0;

/*

 * Keystroke event handler routine - called by main VNC server loop

 * when new keystroke data is received from client

 */

void vnc_kbd_handler(cyg_uint8 *data)

{

    if (!kbd_active)

    {

        /* Keyboard is not active yet - ignore incoming data */

        return;

    }

    /* Add the keystroke event data to the data queue */

    cyg_scheduler_lock();

    if (data_in_queue >= (MAX_EVENTS*4))

    {

        diag_printf("VNC mouse driver buffer overflow\n");

        cyg_scheduler_unlock();

        return;

    }

    data_queue[queue_put_ptr]   = 0;        /* Padding */

    data_queue[queue_put_ptr+1] = data[1];  /* Key pressed (1 when pressed) */

    data_queue[queue_put_ptr+2] = data[6];  /* Keysym value for key MSB */

    data_queue[queue_put_ptr+3] = data[7];  /* Keysym value for key LSB */

    /* Increment pointer */

    queue_put_ptr +=4;

    if (queue_put_ptr >= (MAX_EVENTS*4))

    {

        queue_put_ptr = 0;

    }

    /* Increment count of data in queue */

    data_in_queue += 4;

    /* Wake up select() */

    if (kbd_select_active) {

        kbd_select_active = false;

        cyg_selwakeup(&kbd_select_info);

    }

    cyg_scheduler_unlock();

}

static Cyg_ErrNo kbd_read(cyg_io_handle_t handle,

                          void *buffer,

                          cyg_uint32 *len)

{

    int total;  /* Total bytes to read */

    cyg_uint8 *bp = (unsigned char *)buffer;

    int i;

    cyg_scheduler_lock();

    /* Each keystroke event generates 4 x cyg_uint8 values in the queue

     *   0: Padding - always zero

     *   1: Key pressed (1 when key is pressed)

     *   2: Keysym value MSB

     *   3: Keysym value LSB

     */

    if (*len <= data_in_queue)

    {

        /* Send all requested data */

        total = *len;

    }

    else

    {

        /* read() is requesting more data than there is in the queue */

        /* Send all data from the queue */

        total = data_in_queue;

    }

    for (i = 0; i < total; i++)

    {

        bp[i] = data_queue[queue_get_ptr];

        if (++queue_get_ptr >= (MAX_EVENTS*4))

        {

            queue_get_ptr = 0;

        }

    }

    data_in_queue -= total;

    cyg_scheduler_unlock();

    *len = total;

    return ENOERR;

}

static cyg_bool kbd_select(cyg_io_handle_t handle,

           cyg_uint32 which,

           cyg_addrword_t info)

{

    if (which == CYG_FREAD) {

        cyg_scheduler_lock();

        if (data_in_queue >= 4) {

            cyg_scheduler_unlock();

            return true;

        }

        if (!kbd_select_active) {

            kbd_select_active = true;

            cyg_selrecord(info, &kbd_select_info);

        }

        cyg_scheduler_unlock();

    }

    return false;

}

static Cyg_ErrNo kbd_set_config(cyg_io_handle_t handle,

               cyg_uint32 key,

               const void *buffer,

               cyg_uint32 *len)

{

    return EINVAL;

}

static Cyg_ErrNo kbd_get_config(cyg_io_handle_t handle,

               cyg_uint32 key,

               void *buffer,

               cyg_uint32 *len)

{

    return EINVAL;

}

static bool kbd_init(struct cyg_devtab_entry *tab)

{

    cyg_selinit(&kbd_select_info);

    return true;

}

static Cyg_ErrNo kbd_lookup(struct cyg_devtab_entry **tab,

           struct cyg_devtab_entry *st,

           const char *name)

{

    kbd_active = 1;

    return ENOERR;

}