Changeset 215abc1 in mainline


Ignore:
Timestamp:
2009-06-03T18:49:33Z (15 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
05b9912
Parents:
bbdbf86
Message:

keyboard server rewrite: rename "kbd events" to more generic "console events" and similar changes
rename key_buffer.* to keybuffer.*
coding style changes

Location:
uspace/srv/kbd
Files:
12 edited
2 moved

Legend:

Unmodified
Added
Removed

  • uspace/srv/kbd/Makefile

    rbbdbf86 r215abc1  
    4747        genarch/gsp.c \
    4848        genarch/stroke.c \
    49         generic/key_buffer.c
     49        generic/keybuffer.c
    5050
    5151ARCH_SOURCES =

  • uspace/srv/kbd/ctl/gxe_fb.c

    rbbdbf86 r215abc1  
    3737
    3838#include <kbd.h>
    39 #include <kbd/kbd.h>
    40 #include <kbd/keycode.h>
     39#include <io/console.h>
     40#include <io/keycode.h>
    4141#include <kbd_ctl.h>
    4242#include <gsp.h>

  • uspace/srv/kbd/ctl/pc.c

    rbbdbf86 r215abc1  
    3333/**
    3434 * @file
    35  * @brief       PC keyboard controller driver.
     35 * @brief PC keyboard controller driver.
    3636 */
    3737
    3838#include <kbd.h>
    39 #include <kbd/kbd.h>
    40 #include <kbd/keycode.h>
     39#include <io/console.h>
     40#include <io/keycode.h>
    4141#include <kbd_ctl.h>
    4242#include <gsp.h>
    … …  
    189189void kbd_ctl_parse_scancode(int scancode)
    190190{
    191         kbd_ev_type_t type;
     191        console_ev_type_t type;
    192192        unsigned int key;
    193193        int *map;
    … …  
    214214        if (scancode & 0x80) {
    215215                scancode &= ~0x80;
    216                 type = KE_RELEASE;
     216                type = KEY_RELEASE;
    217217        } else {
    218                 type = KE_PRESS;
     218                type = KEY_PRESS;
    219219        }
    220220

  • uspace/srv/kbd/ctl/stty.c

    rbbdbf86 r215abc1  
    3737
    3838#include <kbd.h>
    39 #include <kbd/kbd.h>
    40 #include <kbd/keycode.h>
     39#include <io/keycode.h>
    4140#include <kbd_ctl.h>
    4241#include <gsp.h>

  • uspace/srv/kbd/ctl/sun.c

    rbbdbf86 r215abc1  
    3737
    3838#include <kbd.h>
    39 #include <kbd/kbd.h>
    40 #include <kbd/keycode.h>
     39#include <io/console.h>
     40#include <io/keycode.h>
    4141#include <kbd_ctl.h>
    4242
    … …  
    5353void kbd_ctl_parse_scancode(int scancode)
    5454{
    55         kbd_ev_type_t type;
     55        console_ev_type_t type;
    5656        unsigned int key;
    5757
    … …  
    6464        if (scancode & KBD_KEY_RELEASE) {
    6565                scancode &= ~KBD_KEY_RELEASE;
    66                 type = KE_RELEASE;
     66                type = KEY_RELEASE;
    6767        } else {
    68                 type = KE_PRESS;
     68                type = KEY_PRESS;
    6969        }
    7070

  • uspace/srv/kbd/genarch/stroke.c

    rbbdbf86 r215abc1  
    3232/**
    3333 * @file
    34  * @brief       Stroke simulator.
     34 * @brief Stroke simulator.
    3535 *
    3636 * When simulating a keyboard using a serial TTY we need to convert the
    3737 * recognized strokes (such as Shift-A) to sequences of key presses and
    3838 * releases (such as 'press Shift, press A, release A, release Shift').
     39 *
    3940 */
    4041
    4142#include <stroke.h>
    4243#include <kbd.h>
    43 #include <kbd/kbd.h>
    44 #include <kbd/keycode.h>
     44#include <io/console.h>
     45#include <io/keycode.h>
    4546
    4647/** Correspondence between modifers and the modifier keycodes. */
    … …  
    5960        while (mods_keys[i][0] != 0) {
    6061                if (mod & mods_keys[i][0]) {
    61                         kbd_push_ev(KE_PRESS, mods_keys[i][1]);
     62                        kbd_push_ev(KEY_PRESS, mods_keys[i][1]);
    6263                }
    6364                ++i;
    … …  
    6667        /* Simulate key press and release. */
    6768        if (key != 0) {
    68                 kbd_push_ev(KE_PRESS, key);
    69                 kbd_push_ev(KE_RELEASE, key);
     69                kbd_push_ev(KEY_PRESS, key);
     70                kbd_push_ev(KEY_RELEASE, key);
    7071        }
    7172
    … …  
    7475        while (mods_keys[i][0] != 0) {
    7576                if (mod & mods_keys[i][0]) {
    76                         kbd_push_ev(KE_RELEASE, mods_keys[i][1]);
     77                        kbd_push_ev(KEY_RELEASE, mods_keys[i][1]);
    7778                }
    7879                ++i;
    … …  
    8283/**
    8384 * @}
    84  */ 
     85 */

  • uspace/srv/kbd/generic/kbd.c

    rbbdbf86 r215abc1  
    2929/**
    3030 * @addtogroup kbdgen generic
    31  * @brief       HelenOS generic uspace keyboard handler.
    32  * @ingroup  kbd
     31 * @brief HelenOS generic uspace keyboard handler.
     32 * @ingroup kbd
    3333 * @{
    34  */ 
     34 */
    3535/** @file
    3636 */
    … …  
    4747#include <errno.h>
    4848#include <libadt/fifo.h>
    49 #include <kbd/kbd.h>
    50 #include <kbd/keycode.h>
     49#include <io/console.h>
     50#include <io/keycode.h>
    5151
    5252#include <kbd.h>
    53 #include <key_buffer.h>
     53#include <keybuffer.h>
    5454#include <kbd_port.h>
    5555#include <kbd_ctl.h>
    … …  
    8989void kbd_push_ev(int type, unsigned int key)
    9090{
    91         kbd_event_t ev;
     91        console_event_t ev;
    9292        unsigned mod_mask;
    9393
    … …  
    103103
    104104        if (mod_mask != 0) {
    105                 if (type == KE_PRESS)
     105                if (type == KEY_PRESS)
    106106                        mods = mods | mod_mask;
    107107                else
    … …  
    117117
    118118        if (mod_mask != 0) {
    119                 if (type == KE_PRESS) {
     119                if (type == KEY_PRESS) {
    120120                        /*
    121121                         * Only change lock state on transition from released
    … …  
    134134        printf("keycode: %u\n", key);
    135135*/
    136         if (type == KE_PRESS && (mods & KM_LCTRL) &&
     136        if (type == KEY_PRESS && (mods & KM_LCTRL) &&
    137137                key == KC_F1) {
    138138                active_layout = 0;
    … …  
    141141        }
    142142
    143         if (type == KE_PRESS && (mods & KM_LCTRL) &&
     143        if (type == KEY_PRESS && (mods & KM_LCTRL) &&
    144144                key == KC_F2) {
    145145                active_layout = 1;
    … …  
    148148        }
    149149
    150         if (type == KE_PRESS && (mods & KM_LCTRL) &&
     150        if (type == KEY_PRESS && (mods & KM_LCTRL) &&
    151151                key == KC_F3) {
    152152                active_layout = 2;

  • uspace/srv/kbd/generic/keybuffer.c

    rbbdbf86 r215abc1  
    2828
    2929/** @addtogroup kbdgen
    30  * @brief       HelenOS generic uspace keyboard handler.
    31  * @ingroup  kbd
     30 * @brief HelenOS generic uspace keyboard handler.
     31 * @ingroup kbd
    3232 * @{
    33  */ 
     33 */
    3434/** @file
    3535 */
    36 #include <key_buffer.h>
     36
     37#include <keybuffer.h>
    3738#include <futex.h>
    3839
    … …  
    5960
    6061/** Get free space in buffer.
    61  * This function is useful for processing some scancodes that are translated
     62 *
     63 * This function is useful for processing some scancodes that are translated
    6264 * to more than one character.
     65 *
    6366 * @return empty buffer space
     67 *
    6468 */
    65 int keybuffer_available(keybuffer_t *keybuffer)
     69size_t keybuffer_available(keybuffer_t *keybuffer)
    6670{
    6771        return KEYBUFFER_SIZE - keybuffer->items;
    … …  
    6973
    7074/**
     75 *
    7176 * @return nonzero, if buffer is not empty.
     77 *
    7278 */
    73 int keybuffer_empty(keybuffer_t *keybuffer)
     79bool keybuffer_empty(keybuffer_t *keybuffer)
    7480{
    7581        return (keybuffer->items == 0);
    … …  
    8086 * If the buffer is full, the event is ignored.
    8187 *
    82  * @param keybuffer     The keybuffer.
    83  * @param ev            The event to push.
     88 * @param keybuffer The keybuffer.
     89 * @param ev        The event to push.
     90 *
    8491 */
    85 void keybuffer_push(keybuffer_t *keybuffer, const kbd_event_t *ev)
     92void keybuffer_push(keybuffer_t *keybuffer, const console_event_t *ev)
    8693{
    8794        futex_down(&keybuffer_futex);
     95       
    8896        if (keybuffer->items < KEYBUFFER_SIZE) {
    8997                keybuffer->fifo[keybuffer->tail] = *ev;
    … …  
    9199                keybuffer->items++;
    92100        }
     101       
    93102        futex_up(&keybuffer_futex);
    94103}
    … …  
    96105/** Pop event from buffer.
    97106 *
    98  * @param edst  Pointer to where the event should be saved.
    99  * @return      Zero on empty buffer, nonzero otherwise.
     107 * @param edst Pointer to where the event should be saved.
     108 *
     109 * @return True if an event was popped.
     110 *
    100111 */
    101 int keybuffer_pop(keybuffer_t *keybuffer, kbd_event_t *edst)
     112bool keybuffer_pop(keybuffer_t *keybuffer, console_event_t *edst)
    102113{
    103114        futex_down(&keybuffer_futex);
     115       
    104116        if (keybuffer->items > 0) {
    105117                keybuffer->items--;
    106                 *edst = (keybuffer->fifo[keybuffer->head]) ;
     118                *edst = (keybuffer->fifo[keybuffer->head]);
    107119                keybuffer->head = (keybuffer->head + 1) % KEYBUFFER_SIZE;
    108120                futex_up(&keybuffer_futex);
    109                 return 1;
     121               
     122                return true;
    110123        }
     124       
    111125        futex_up(&keybuffer_futex);
    112         return 0;
     126       
     127        return false;
    113128}
    114129
    115130/**
    116131 * @}
    117  */ 
     132 */

  • uspace/srv/kbd/include/kbd.h

    rbbdbf86 r215abc1  
    2828
    2929/** @addtogroup kbdgen generic
    30  * @brief       HelenOS generic uspace keyboard handler.
    31  * @ingroup  kbd
     30 * @brief HelenOS generic uspace keyboard handler.
     31 * @ingroup kbd
    3232 * @{
    33  */ 
     33 */
    3434/** @file
    3535 */
    … …  
    3838#define KBD_KBD_H_
    3939
    40 #include <key_buffer.h>
     40#include <keybuffer.h>
    4141#include <ipc/ipc.h>
    4242
    43 #define KBD_EVENT       1024
    44 #define KBD_MS_LEFT     1025
    45 #define KBD_MS_RIGHT    1026
    46 #define KBD_MS_MIDDLE   1027
    47 #define KBD_MS_MOVE     1028
     43#define KBD_EVENT      1024
     44#define KBD_MS_LEFT    1025
     45#define KBD_MS_RIGHT   1026
     46#define KBD_MS_MIDDLE  1027
     47#define KBD_MS_MOVE    1028
    4848
    4949typedef enum {
    50         KBD_YIELD       = IPC_FIRST_USER_METHOD,
     50        KBD_YIELD = IPC_FIRST_USER_METHOD,
    5151        KBD_RECLAIM
    5252} kbd_request_t;
    … …  
    6262/**
    6363 * @}
    64  */
    65 
     64 */

  • uspace/srv/kbd/include/keybuffer.h

    rbbdbf86 r215abc1  
    2828
    2929/** @addtogroup kbdgen
    30  * @brief       HelenOS generic uspace keyboard handler.
    31  * @ingroup  kbd
     30 * @brief HelenOS generic uspace keyboard handler.
     31 * @ingroup kbd
    3232 * @{
    33  */ 
     33 */
    3434/** @file
    3535 */
    3636
    37 #ifndef __KEY_BUFFER_H__
    38 #define __KEY_BUFFER_H__
     37#ifndef __KEYBUFFER_H__
     38#define __KEYBUFFER_H__
    3939
    4040#include <sys/types.h>
    41 #include <kbd/kbd.h>
     41#include <io/console.h>
     42#include <bool.h>
    4243
    4344/** Size of buffer for pressed keys */
    44 #define KEYBUFFER_SIZE 128
     45#define KEYBUFFER_SIZE  128
    4546
    4647typedef struct {
    47         kbd_event_t fifo[KEYBUFFER_SIZE];
     48        console_event_t fifo[KEYBUFFER_SIZE];
    4849        unsigned long head;
    4950        unsigned long tail;
    … …  
    5354extern void keybuffer_free(keybuffer_t *);
    5455extern void keybuffer_init(keybuffer_t *);
    55 extern int keybuffer_available(keybuffer_t *);
    56 extern int keybuffer_empty(keybuffer_t *);
    57 extern void keybuffer_push(keybuffer_t *, const kbd_event_t *);
    58 extern int keybuffer_pop(keybuffer_t *, kbd_event_t *);
     56extern size_t keybuffer_available(keybuffer_t *);
     57extern bool keybuffer_empty(keybuffer_t *);
     58extern void keybuffer_push(keybuffer_t *, const console_event_t *);
     59extern bool keybuffer_pop(keybuffer_t *, console_event_t *);
    5960
    6061#endif
    … …  
    6263/**
    6364 * @}
    64  */
    65 
     65 */

  • uspace/srv/kbd/include/layout.h

    rbbdbf86 r215abc1  
    2828
    2929/** @addtogroup kbdgen generic
    30  * @brief       HelenOS generic uspace keyboard handler.
    31  * @ingroup  kbd
     30 * @brief HelenOS generic uspace keyboard handler.
     31 * @ingroup kbd
    3232 * @{
    33  */ 
     33 */
    3434/** @file
    3535 */
    … …  
    3838#define KBD_LAYOUT_H_
    3939
    40 #include <kbd/kbd.h>
    4140#include <sys/types.h>
     41#include <io/console.h>
    4242
    4343typedef struct {
    4444        void (*reset)(void);
    45         wchar_t (*parse_ev)(kbd_event_t *);
     45        wchar_t (*parse_ev)(console_event_t *);
    4646} layout_op_t;
    4747
    … …  
    5454/**
    5555 * @}
    56  */
    57 
     56 */

  • uspace/srv/kbd/layout/cz.c

    rbbdbf86 r215abc1  
    2828
    2929/** @addtogroup kbd
    30  * @brief       US QWERTY leyout.
     30 * @brief US QWERTY leyout.
    3131 * @{
    32  */ 
     32 */
    3333
    3434#include <kbd.h>
    35 #include <kbd/kbd.h>
    36 #include <kbd/keycode.h>
     35#include <io/console.h>
     36#include <io/keycode.h>
    3737#include <bool.h>
    3838#include <layout.h>
    3939
    4040static void layout_reset(void);
    41 static wchar_t layout_parse_ev(kbd_event_t *ev);
     41static wchar_t layout_parse_ev(console_event_t *ev);
    4242
    4343enum m_state {
    4444        ms_start,
    4545        ms_hacek,
    46         ms_carka       
     46        ms_carka
    4747};
    4848
    … …  
    273273}
    274274
    275 static wchar_t parse_ms_hacek(kbd_event_t *ev)
     275static wchar_t parse_ms_hacek(console_event_t *ev)
    276276{
    277277        wchar_t c;
    … …  
    291291}
    292292
    293 static wchar_t parse_ms_carka(kbd_event_t *ev)
     293static wchar_t parse_ms_carka(console_event_t *ev)
    294294{
    295295        wchar_t c;
    … …  
    309309}
    310310
    311 static wchar_t parse_ms_start(kbd_event_t *ev)
     311static wchar_t parse_ms_start(console_event_t *ev)
    312312{
    313313        wchar_t c;
    … …  
    384384}
    385385
    386 static wchar_t layout_parse_ev(kbd_event_t *ev)
    387 {
    388         if (ev->type != KE_PRESS)
    389                 return '\0';
    390 
     386static wchar_t layout_parse_ev(console_event_t *ev)
     387{
     388        if (ev->type != KEY_PRESS)
     389                return 0;
     390       
    391391        if (key_is_mod(ev->key))
    392                 return '\0';
    393 
     392                return 0;
     393       
    394394        switch (mstate) {
    395         case ms_start: return parse_ms_start(ev);
    396         case ms_hacek: return parse_ms_hacek(ev);
    397         case ms_carka: return parse_ms_carka(ev);
     395        case ms_start:
     396                return parse_ms_start(ev);
     397        case ms_hacek:
     398                return parse_ms_hacek(ev);
     399        case ms_carka:
     400                return parse_ms_carka(ev);
    398401        }
    399402}
    … …  
    401404/**
    402405 * @}
    403  */ 
     406 */

  • uspace/srv/kbd/layout/us_dvorak.c

    rbbdbf86 r215abc1  
    3333
    3434#include <kbd.h>
    35 #include <kbd/kbd.h>
    36 #include <kbd/keycode.h>
     35#include <io/console.h>
     36#include <io/keycode.h>
    3737#include <layout.h>
    3838
    3939static void layout_reset(void);
    40 static wchar_t layout_parse_ev(kbd_event_t *ev);
     40static wchar_t layout_parse_ev(console_event_t *ev);
    4141
    4242layout_op_t us_dvorak_op = {
    … …  
    210210}
    211211
    212 static wchar_t layout_parse_ev(kbd_event_t *ev)
     212static wchar_t layout_parse_ev(console_event_t *ev)
    213213{
    214214        wchar_t c;

  • uspace/srv/kbd/layout/us_qwerty.c

    rbbdbf86 r215abc1  
    3333
    3434#include <kbd.h>
    35 #include <kbd/kbd.h>
    36 #include <kbd/keycode.h>
     35#include <io/console.h>
     36#include <io/keycode.h>
    3737#include <layout.h>
    3838
    3939static void layout_reset(void);
    40 static wchar_t layout_parse_ev(kbd_event_t *ev);
     40static wchar_t layout_parse_ev(console_event_t *ev);
    4141
    4242layout_op_t us_qwerty_op = {
    … …  
    204204}
    205205
    206 static wchar_t layout_parse_ev(kbd_event_t *ev)
     206static wchar_t layout_parse_ev(console_event_t *ev)
    207207{
    208208        wchar_t c;
Note: See TracChangeset for help on using the changeset viewer.