HelenOSHelenOS-docHelenOS-historic

Català-Valencià – Catalan中文 – Chinese (Simplified)中文 – Chinese (Traditional)Česky – CzechDansk – DanishNederlands – DutchEnglish – EnglishSuomi – FinnishFrançais – FrenchDeutsch – Germanעברית – Hebrewहिंदी – HindiMagyar – HungarianBahasa Indonesia – IndonesianItaliano – Italian日本語 – Japanese한국어 – KoreanМакедонски – Macedonianमराठी – MarathiNorsk – NorwegianPolski – PolishPortuguês – PortuguesePortuguês – Portuguese (Brazil)Русский – RussianSlovenčina – SlovakSlovenščina – SlovenianEspañol – SpanishSvenska – SwedishTürkçe – TurkishУкраїнська – UkrainianOëzbekcha – Uzbek

Compare Revisions

• This comparison shows the changes necessary to convert path

  → /branches/dd/uspace/ @ 4155

  → /branches/dd/uspace/ @ 4156

  ↔ Reverse comparison

• Compare Path:	Rev

  With Path:	Rev

No changes between revisions

Ignore whitespace Rev 4155 → Rev 4156

/branches/dd/uspace/app/bdsh/exec.c
121,7 → 121,7
free(tmp);
if (tid == 0) {
cli_error(CL_EEXEC, "Can not spawn %s", cmd);
cli_error(CL_EEXEC, "Cannot spawn `%s'.", cmd);
return 1;
} else {
return 0;

/branches/dd/uspace/app/init/init.c
44,6 → 44,7
#include <task.h>
#include <malloc.h>
#include <macros.h>
#include <console.h>
#include "init.h"
#include "version.h"
82,12 → 83,12
argv[0] = fname;
argv[1] = NULL;
if (task_spawn(fname, argv))
/* Add reasonable delay to avoid
intermixed klog output */
if (task_spawn(fname, argv)) {
/* Add reasonable delay to avoid intermixed klog output. */
usleep(10000);
else
} else {
printf(NAME ": Error spawning %s\n", fname);
}
}
int main(int argc, char *argv[])
99,7 → 100,7
return -1;
}
// FIXME: spawn("/srv/pci");
spawn("/srv/pci");
spawn("/srv/fb");
spawn("/srv/kbd");
spawn("/srv/console");

/branches/dd/uspace/app/init/version.c
61,7 → 61,8
/** Print version information. */
void version_print(void)
{
printf("HelenOS init\nRelease %s%s%s\nCopyright (c) 2006 HelenOS project\n", release, revision, timestamp);
printf("HelenOS init\nRelease %s%s%s\n", release, revision, timestamp);
printf("Copyright (c) 2001-2009 HelenOS project\n");
}
/** @}

/branches/dd/uspace/app/tetris/input.c
58,6 → 58,7
#include <async.h>
#include <ipc/console.h>
#include <console.h>
#include <kbd/kbd.h>
/* return true iff the given timeval is positive */
114,7 → 115,7
if (!lastchar) {
again:
if (!getchar_inprog) {
cons_phone = get_console_phone();
cons_phone = console_phone_get();
getchar_inprog = async_send_2(cons_phone,
CONSOLE_GETKEY, 0, 0, &charcall);
}

/branches/dd/uspace/app/klog/klog.c
41,6 → 41,7
#include <as.h>
#include <sysinfo.h>
#include <io/stream.h>
#include <console.h>
#include <errno.h>
#define NAME "klog"
81,12 → 82,11
return -1;
}
int devno = sysinfo_value("klog.devno");
int inr = sysinfo_value("klog.inr");
if (ipc_register_irq(inr, devno, 0, NULL) != EOK) {
printf(NAME ": Error registering klog notifications\n");
return -1;
}
// int inr = sysinfo_value("klog.inr");
// if (ipc_register_irq(inr, devno, 0, NULL) != EOK) {
// printf(NAME ": Error registering klog notifications\n");
// return -1;
// }
async_set_interrupt_received(interrupt_received);
klog_update();

/branches/dd/uspace/lib/libc/include/ddi.h
37,6 → 37,7
#include <task.h>
extern int device_assign_devno(void);
extern int physmem_map(void *, void *, unsigned long, int);
extern int iospace_enable(task_id_t, void *, unsigned long);
extern int preemption_control(int);

/branches/dd/uspace/lib/libc/include/console.h
38,9 → 38,17
#include <console/style.h>
#include <console/color.h>
extern void console_open(void);
extern void console_close(void);
extern int console_phone_get(void);
extern void console_wait(void);
extern void console_clear(void);
extern void console_goto(int, int);
extern void console_putchar(int);
extern void console_flush(void);
extern int console_get_size(int *, int *);
extern void console_set_style(int);
extern void console_set_color(int, int, int);

/branches/dd/uspace/lib/libc/include/io/stream.h
39,8 → 39,6
#define EMFILE -17
extern void open_console(void);
extern void close_console(void);
extern void klog_update(void);
extern ssize_t read_stdin(void *, size_t);
47,9 → 45,6
extern ssize_t write_stdout(const void *, size_t);
extern ssize_t write_stderr(const void *, size_t);
extern int get_console_phone(void);
extern void console_wait(void);
#endif
/** @}

/branches/dd/uspace/lib/libc/generic/kbd.c
37,15 → 37,19
#include <kbd/kbd.h>
#include <ipc/ipc.h>
#include <ipc/console.h>
#include <console.h>
#include <async.h>
int kbd_get_event(kbd_event_t *ev)
{
int console_phone = get_console_phone();
int cons_phone = console_phone_get();
ipcarg_t r0, r1, r2, r3;
int rc;
rc = async_req_0_4(console_phone, CONSOLE_GETKEY, &r0, &r1, &r2, &r3);
if (cons_phone < 0)
return -1;
rc = async_req_0_4(cons_phone, CONSOLE_GETKEY, &r0, &r1, &r2, &r3);
if (rc < 0)
return -1;

/branches/dd/uspace/lib/libc/generic/ddi.c
41,6 → 41,16
#include <libarch/config.h>
#include <kernel/ddi/ddi_arg.h>
/** Return unique device number.
*
* @return New unique device number.
*
*/
int device_assign_devno(void)
{
return __SYSCALL0(SYS_DEVICE_ASSIGN_DEVNO);
}
/** Map piece of physical memory to task.
*
* Caller of this function must have the CAP_MEM_MANAGER capability.

/branches/dd/uspace/lib/libc/generic/console.c
1,4 → 1,6
/*
* Copyright (c) 2006 Josef Cejka
* Copyright (c) 2006 Jakub Vana
* Copyright (c) 2008 Jiri Svoboda
* All rights reserved.
*
35,29 → 37,70
#include <async.h>
#include <io/stream.h>
#include <ipc/console.h>
#include <ipc/services.h>
#include <console.h>
static int console_phone = -1;
void console_open(void)
{
if (console_phone < 0) {
int phone = ipc_connect_me_to(PHONE_NS, SERVICE_CONSOLE, 0, 0);
if (phone >= 0)
console_phone = phone;
}
}
void console_close(void)
{
if (console_phone >= 0) {
if (ipc_hangup(console_phone) == 0) {
console_phone = -1;
}
}
}
int console_phone_get(void)
{
if (console_phone < 0)
console_open();
return console_phone;
}
void console_wait(void)
{
while (console_phone < 0)
console_open();
}
void console_clear(void)
{
int cons_phone = get_console_phone();
int cons_phone = console_phone_get();
async_msg_0(cons_phone, CONSOLE_CLEAR);
}
void console_goto(int row, int col)
{
int cons_phone = get_console_phone();
int cons_phone = console_phone_get();
async_msg_2(cons_phone, CONSOLE_GOTO, row, col);
}
void console_putchar(int c)
{
int cons_phone = console_phone_get();
async_msg_1(cons_phone, CONSOLE_PUTCHAR, c);
}
void console_flush(void)
{
int cons_phone = get_console_phone();
int cons_phone = console_phone_get();
async_msg_0(cons_phone, CONSOLE_FLUSH);
}
int console_get_size(int *rows, int *cols)
{
int cons_phone = get_console_phone();
int cons_phone = console_phone_get();
ipcarg_t r, c;
int rc;
71,25 → 114,25
void console_set_style(int style)
{
int cons_phone = get_console_phone();
int cons_phone = console_phone_get();
async_msg_1(cons_phone, CONSOLE_SET_STYLE, style);
}
void console_set_color(int fg_color, int bg_color, int flags)
{
int cons_phone = get_console_phone();
int cons_phone = console_phone_get();
async_msg_3(cons_phone, CONSOLE_SET_COLOR, fg_color, bg_color, flags);
}
void console_set_rgb_color(int fg_color, int bg_color)
{
int cons_phone = get_console_phone();
int cons_phone = console_phone_get();
async_msg_2(cons_phone, CONSOLE_SET_RGB_COLOR, fg_color, bg_color);
}
void console_cursor_visibility(int show)
{
int cons_phone = get_console_phone();
int cons_phone = console_phone_get();
async_msg_1(cons_phone, CONSOLE_CURSOR_VISIBILITY, show != 0);
}

/branches/dd/uspace/lib/libc/generic/io/stream.c
43,13 → 43,12
#include <ipc/fb.h>
#include <ipc/services.h>
#include <ipc/console.h>
#include <console.h>
#include <kbd/kbd.h>
#include <unistd.h>
#include <async.h>
#include <sys/types.h>
static int console_phone = -1;
ssize_t write_stderr(const void *buf, size_t count)
{
return count;
57,8 → 56,9
ssize_t read_stdin(void *buf, size_t count)
{
open_console();
if (console_phone >= 0) {
int cons_phone = console_phone_get();
if (cons_phone >= 0) {
kbd_event_t ev;
int rc;
size_t i = 0;
79,55 → 79,23
ssize_t write_stdout(const void *buf, size_t count)
{
open_console();
if (console_phone >= 0) {
int cons_phone = console_phone_get();
if (cons_phone >= 0) {
int i;
for (i = 0; i < count; i++)
async_msg_1(console_phone, CONSOLE_PUTCHAR,
((const char *) buf)[i]);
console_putchar(((const char *) buf)[i]);
return count;
} else
return __SYSCALL3(SYS_KLOG, 1, (sysarg_t) buf, count);
}
void open_console(void)
{
if (console_phone < 0) {
int phone = ipc_connect_me_to(PHONE_NS, SERVICE_CONSOLE, 0, 0);
if (phone >= 0)
console_phone = phone;
}
}
void close_console(void)
{
if (console_phone >= 0) {
if (ipc_hangup(console_phone) == 0) {
console_phone = -1;
}
}
}
void klog_update(void)
{
(void) __SYSCALL3(SYS_KLOG, 1, NULL, 0);
}
int get_console_phone(void)
{
if (console_phone < 0)
console_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_CONSOLE, 0, 0);
return console_phone;
}
void console_wait(void)
{
while (console_phone < 0)
get_console_phone();
}
/** @}
*/

/branches/dd/uspace/lib/libc/arch/mips32eb/include/ddi.h
0,0 → 1,0
link ../../mips32/include/ddi.h
Property changes:
Added: svn:special
+*
\ No newline at end of property

/branches/dd/uspace/lib/libc/arch/mips32eb/Makefile.inc
29,9 → 29,9
## Toolchain configuration
#
TARGET = mips-sgi-irix5
TARGET = mips-linux-gnu
TOOLCHAIN_DIR = $(CROSS_PREFIX)/mips/bin
CFLAGS += -mips3
CFLAGS += -mips3
ARCH_SOURCES += arch/$(UARCH)/src/syscall.c \
arch/$(UARCH)/src/fibril.S \
40,4 → 40,4
LFLAGS += -N
BFD_ARCH = mips
BFD_NAME = elf32-big
BFD_NAME = elf32-tradbigmips

/branches/dd/uspace/srv/kbd/ctl/pc.c
39,6 → 39,7
#include <kbd/kbd.h>
#include <kbd/keycode.h>
#include <kbd_ctl.h>
#include <gsp.h>
enum dec_state {
ds_s,
45,7 → 46,7
ds_e
};
static enum dec_state ds = ds_s;
static enum dec_state ds;
static int scanmap_simple[] = {
179,6 → 180,11
[0x1c] = KC_NENTER
};
int kbd_ctl_init(void)
{
ds = ds_s;
return 0;
}
void kbd_ctl_parse_scancode(int scancode)
{

/branches/dd/uspace/srv/kbd/ctl/stty.c
39,291 → 39,191
#include <kbd/kbd.h>
#include <kbd/keycode.h>
#include <kbd_ctl.h>
#include <gsp.h>
#include <stroke.h>
static void parse_ds_start(int scancode);
static void parse_ds_e(int scancode);
static void parse_ds_e1(int scancode);
static void parse_ds_e2(int scancode);
static void parse_ds_e2a(int scancode);
static void parse_ds_e2b(int scancode);
/** Scancode parser */
static gsp_t sp;
static void parse_leaf(int scancode, int (*map)[2], size_t map_length);
/** Current parser state */
static int ds;
enum dec_state {
ds_start,
ds_e,
ds_e1,
ds_e2,
ds_e2a,
ds_e2b
};
#include <stdio.h>
static int map_start[][2] = {
int seq_defs[] = {
/* Not shifted */
[0x60] = { 0, KC_BACKTICK },
0, KC_BACKTICK, 0x60, GSP_END,
[0x31] = { 0, KC_1 },
[0x32] = { 0, KC_2 },
[0x33] = { 0, KC_3 },
[0x34] = { 0, KC_4 },
[0x35] = { 0, KC_5 },
[0x36] = { 0, KC_6 },
[0x37] = { 0, KC_7 },
[0x38] = { 0, KC_8 },
[0x39] = { 0, KC_9 },
[0x30] = { 0, KC_0 },
0, KC_1, 0x31, GSP_END,
0, KC_2, 0x32, GSP_END,
0, KC_3, 0x33, GSP_END,
0, KC_4, 0x34, GSP_END,
0, KC_5, 0x35, GSP_END,
0, KC_6, 0x36, GSP_END,
0, KC_7, 0x37, GSP_END,
0, KC_8, 0x38, GSP_END,
0, KC_9, 0x39, GSP_END,
0, KC_0, 0x30, GSP_END,
[0x2d] = { 0, KC_MINUS },
[0x3d] = { 0, KC_EQUALS },
[0x08] = { 0, KC_BACKSPACE },
0, KC_MINUS, 0x2d, GSP_END,
0, KC_EQUALS, 0x3d, GSP_END,
0, KC_BACKSPACE, 0x08, GSP_END,
[0x0f] = { 0, KC_TAB },
0, KC_TAB, 0x09, GSP_END,
[0x71] = { 0, KC_Q },
[0x77] = { 0, KC_W },
[0x65] = { 0, KC_E },
[0x72] = { 0, KC_R },
[0x74] = { 0, KC_T },
[0x79] = { 0, KC_Y },
[0x75] = { 0, KC_U },
[0x69] = { 0, KC_I },
[0x6f] = { 0, KC_O },
[0x70] = { 0, KC_P },
0, KC_Q, 0x71, GSP_END,
0, KC_W, 0x77, GSP_END,
0, KC_E, 0x65, GSP_END,
0, KC_R, 0x72, GSP_END,
0, KC_T, 0x74, GSP_END,
0, KC_Y, 0x79, GSP_END,
0, KC_U, 0x75, GSP_END,
0, KC_I, 0x69, GSP_END,
0, KC_O, 0x6f, GSP_END,
0, KC_P, 0x70, GSP_END,
[0x5b] = { 0, KC_LBRACKET },
[0x5d] = { 0, KC_RBRACKET },
0, KC_LBRACKET, 0x5b, GSP_END,
0, KC_RBRACKET, 0x5d, GSP_END,
[0x61] = { 0, KC_A },
[0x73] = { 0, KC_S },
[0x64] = { 0, KC_D },
[0x66] = { 0, KC_F },
[0x67] = { 0, KC_G },
[0x68] = { 0, KC_H },
[0x6a] = { 0, KC_J },
[0x6b] = { 0, KC_K },
[0x6c] = { 0, KC_L },
0, KC_A, 0x61, GSP_END,
0, KC_S, 0x73, GSP_END,
0, KC_D, 0x64, GSP_END,
0, KC_F, 0x66, GSP_END,
0, KC_G, 0x67, GSP_END,
0, KC_H, 0x68, GSP_END,
0, KC_J, 0x6a, GSP_END,
0, KC_K, 0x6b, GSP_END,
0, KC_L, 0x6c, GSP_END,
[0x3b] = { 0, KC_SEMICOLON },
[0x27] = { 0, KC_QUOTE },
[0x5c] = { 0, KC_BACKSLASH },
0, KC_SEMICOLON, 0x3b, GSP_END,
0, KC_QUOTE, 0x27, GSP_END,
0, KC_BACKSLASH, 0x5c, GSP_END,
[0x7a] = { 0, KC_Z },
[0x78] = { 0, KC_X },
[0x63] = { 0, KC_C },
[0x76] = { 0, KC_V },
[0x62] = { 0, KC_B },
[0x6e] = { 0, KC_N },
[0x6d] = { 0, KC_M },
0, KC_Z, 0x7a, GSP_END,
0, KC_X, 0x78, GSP_END,
0, KC_C, 0x63, GSP_END,
0, KC_V, 0x76, GSP_END,
0, KC_B, 0x62, GSP_END,
0, KC_N, 0x6e, GSP_END,
0, KC_M, 0x6d, GSP_END,
[0x2c] = { 0, KC_COMMA },
[0x2e] = { 0, KC_PERIOD },
[0x2f] = { 0, KC_SLASH },
0, KC_COMMA, 0x2c, GSP_END,
0, KC_PERIOD, 0x2e, GSP_END,
0, KC_SLASH, 0x2f, GSP_END,
[0x20] = { 0, KC_SPACE },
/* Shifted */
[0x1b] = { 0, KC_ESCAPE },
KM_SHIFT, KC_BACKTICK, 0x7e, GSP_END,
[0x0a] = { 0, KC_ENTER },
[0x0d] = { 0, KC_ENTER },
KM_SHIFT, KC_1, 0x21, GSP_END,
KM_SHIFT, KC_2, 0x40, GSP_END,
KM_SHIFT, KC_3, 0x23, GSP_END,
KM_SHIFT, KC_4, 0x24, GSP_END,
KM_SHIFT, KC_5, 0x25, GSP_END,
KM_SHIFT, KC_6, 0x5e, GSP_END,
KM_SHIFT, KC_7, 0x26, GSP_END,
KM_SHIFT, KC_8, 0x2a, GSP_END,
KM_SHIFT, KC_9, 0x28, GSP_END,
KM_SHIFT, KC_0, 0x29, GSP_END,
/* with Shift pressed */
KM_SHIFT, KC_MINUS, 0x5f, GSP_END,
KM_SHIFT, KC_EQUALS, 0x2b, GSP_END,
[0x7e] = { KM_LSHIFT, KC_BACKTICK },
KM_SHIFT, KC_Q, 0x51, GSP_END,
KM_SHIFT, KC_W, 0x57, GSP_END,
KM_SHIFT, KC_E, 0x45, GSP_END,
KM_SHIFT, KC_R, 0x52, GSP_END,
KM_SHIFT, KC_T, 0x54, GSP_END,
KM_SHIFT, KC_Y, 0x59, GSP_END,
KM_SHIFT, KC_U, 0x55, GSP_END,
KM_SHIFT, KC_I, 0x49, GSP_END,
KM_SHIFT, KC_O, 0x4f, GSP_END,
KM_SHIFT, KC_P, 0x50, GSP_END,
[0x21] = { KM_LSHIFT, KC_1 },
[0x40] = { KM_LSHIFT, KC_2 },
[0x23] = { KM_LSHIFT, KC_3 },
[0x24] = { KM_LSHIFT, KC_4 },
[0x25] = { KM_LSHIFT, KC_5 },
[0x5e] = { KM_LSHIFT, KC_6 },
[0x26] = { KM_LSHIFT, KC_7 },
[0x2a] = { KM_LSHIFT, KC_8 },
[0x28] = { KM_LSHIFT, KC_9 },
[0x29] = { KM_LSHIFT, KC_0 },
KM_SHIFT, KC_LBRACKET, 0x7b, GSP_END,
KM_SHIFT, KC_RBRACKET, 0x7d, GSP_END,
[0x5f] = { KM_LSHIFT, KC_MINUS },
[0x2b] = { KM_LSHIFT, KC_EQUALS },
KM_SHIFT, KC_A, 0x41, GSP_END,
KM_SHIFT, KC_S, 0x53, GSP_END,
KM_SHIFT, KC_D, 0x44, GSP_END,
KM_SHIFT, KC_F, 0x46, GSP_END,
KM_SHIFT, KC_G, 0x47, GSP_END,
KM_SHIFT, KC_H, 0x48, GSP_END,
KM_SHIFT, KC_J, 0x4a, GSP_END,
KM_SHIFT, KC_K, 0x4b, GSP_END,
KM_SHIFT, KC_L, 0x4c, GSP_END,
[0x51] = { KM_LSHIFT, KC_Q },
[0x57] = { KM_LSHIFT, KC_W },
[0x45] = { KM_LSHIFT, KC_E },
[0x52] = { KM_LSHIFT, KC_R },
[0x54] = { KM_LSHIFT, KC_T },
[0x59] = { KM_LSHIFT, KC_Y },
[0x55] = { KM_LSHIFT, KC_U },
[0x49] = { KM_LSHIFT, KC_I },
[0x4f] = { KM_LSHIFT, KC_O },
[0x50] = { KM_LSHIFT, KC_P },
KM_SHIFT, KC_SEMICOLON, 0x3a, GSP_END,
KM_SHIFT, KC_QUOTE, 0x22, GSP_END,
KM_SHIFT, KC_BACKSLASH, 0x7c, GSP_END,
[0x7b] = { KM_LSHIFT, KC_LBRACKET },
[0x7d] = { KM_LSHIFT, KC_RBRACKET },
KM_SHIFT, KC_Z, 0x5a, GSP_END,
KM_SHIFT, KC_X, 0x58, GSP_END,
KM_SHIFT, KC_C, 0x43, GSP_END,
KM_SHIFT, KC_V, 0x56, GSP_END,
KM_SHIFT, KC_B, 0x42, GSP_END,
KM_SHIFT, KC_N, 0x4e, GSP_END,
KM_SHIFT, KC_M, 0x4d, GSP_END,
[0x41] = { KM_LSHIFT, KC_A },
[0x53] = { KM_LSHIFT, KC_S },
[0x44] = { KM_LSHIFT, KC_D },
[0x46] = { KM_LSHIFT, KC_F },
[0x47] = { KM_LSHIFT, KC_G },
[0x48] = { KM_LSHIFT, KC_H },
[0x4a] = { KM_LSHIFT, KC_J },
[0x4b] = { KM_LSHIFT, KC_K },
[0x4c] = { KM_LSHIFT, KC_L },
KM_SHIFT, KC_COMMA, 0x3c, GSP_END,
KM_SHIFT, KC_PERIOD, 0x3e, GSP_END,
KM_SHIFT, KC_SLASH, 0x3f, GSP_END,
[0x3a] = { KM_LSHIFT, KC_SEMICOLON },
[0x22] = { KM_LSHIFT, KC_QUOTE },
[0x7c] = { KM_LSHIFT, KC_BACKSLASH },
/* ... */
[0x5a] = { KM_LSHIFT, KC_Z },
[0x58] = { KM_LSHIFT, KC_X },
[0x43] = { KM_LSHIFT, KC_C },
[0x56] = { KM_LSHIFT, KC_V },
[0x42] = { KM_LSHIFT, KC_B },
[0x4e] = { KM_LSHIFT, KC_N },
[0x4d] = { KM_LSHIFT, KC_M },
0, KC_SPACE, 0x20, GSP_END,
0, KC_ENTER, 0x0a, GSP_END,
0, KC_ENTER, 0x0d, GSP_END,
[0x3c] = { KM_LSHIFT, KC_COMMA },
[0x3e] = { KM_LSHIFT, KC_PERIOD },
[0x3f] = { KM_LSHIFT, KC_SLASH }
};
0, KC_ESCAPE, 0x1b, 0x1b, GSP_END,
static int map_e1[][2] =
{
[0x50] = { 0, KC_F1 },
[0x51] = { 0, KC_F2 },
[0x52] = { 0, KC_F3 },
[0x53] = { 0, KC_F4 },
};
0, KC_F1, 0x1b, 0x4f, 0x50, GSP_END,
0, KC_F2, 0x1b, 0x4f, 0x51, GSP_END,
0, KC_F3, 0x1b, 0x4f, 0x52, GSP_END,
0, KC_F4, 0x1b, 0x4f, 0x53, GSP_END,
0, KC_F5, 0x1b, 0x5b, 0x31, 0x35, 0x7e, GSP_END,
0, KC_F6, 0x1b, 0x5b, 0x31, 0x37, 0x7e, GSP_END,
0, KC_F7, 0x1b, 0x5b, 0x31, 0x38, 0x7e, GSP_END,
0, KC_F8, 0x1b, 0x5b, 0x31, 0x39, 0x7e, GSP_END,
0, KC_F9, 0x1b, 0x5b, 0x32, 0x30, 0x7e, GSP_END,
0, KC_F10, 0x1b, 0x5b, 0x32, 0x31, 0x7e, GSP_END,
0, KC_F11, 0x1b, 0x5b, 0x32, 0x33, 0x7e, GSP_END,
0, KC_F12, 0x1b, 0x5b, 0x32, 0x34, 0x7e, GSP_END,
static int map_e2[][2] =
{
[0x41] = { 0, KC_UP },
[0x42] = { 0, KC_DOWN },
[0x44] = { 0, KC_LEFT },
[0x43] = { 0, KC_RIGHT },
};
0, KC_INSERT, 0x1b, 0x5b, 0x32, 0x7e, GSP_END,
0, KC_HOME, 0x1b, 0x5b, 0x48, GSP_END,
0, KC_PAGE_UP, 0x1b, 0x5b, 0x35, 0x7e, GSP_END,
0, KC_DELETE, 0x1b, 0x5b, 0x33, 0x7e, GSP_END,
0, KC_END, 0x1b, 0x5b, 0x46, GSP_END,
0, KC_PAGE_DOWN, 0x1b, 0x5b, 0x36, 0x7e, GSP_END,
static int map_e2a[][2] =
{
[0x35] = { 0, KC_F5 },
[0x37] = { 0, KC_F6 },
[0x38] = { 0, KC_F7 },
[0x39] = { 0, KC_F8 },
};
0, KC_UP, 0x1b, 0x5b, 0x41, GSP_END,
0, KC_LEFT, 0x1b, 0x5b, 0x44, GSP_END,
0, KC_DOWN, 0x1b, 0x5b, 0x42, GSP_END,
0, KC_RIGHT, 0x1b, 0x5b, 0x43, GSP_END,
static int map_e2b[][2] =
{
[0x30] = { 0, KC_F9 },
[0x31] = { 0, KC_F10 },
[0x32] = { 0, KC_F11 },
[0x33] = { 0, KC_F12 },
0, 0
};
static unsigned int mods_keys[][2] = {
{ KM_LSHIFT, KC_LSHIFT },
{ 0, 0 }
};
static enum dec_state ds;
void kbd_ctl_parse_scancode(int scancode)
int kbd_ctl_init(void)
{
switch (ds) {
case ds_start: parse_ds_start(scancode); break;
case ds_e: parse_ds_e(scancode); break;
case ds_e1: parse_ds_e1(scancode); break;
case ds_e2: parse_ds_e2(scancode); break;
case ds_e2a: parse_ds_e2a(scancode); break;
case ds_e2b: parse_ds_e2b(scancode); break;
}
}
ds = 0;
static void parse_ds_start(int scancode)
{
if (scancode == 0x1b) {
ds = ds_e;
return;
}
parse_leaf(scancode, map_start, sizeof(map_start) / (2 * sizeof(int)));
gsp_init(&sp);
return gsp_insert_defs(&sp, seq_defs);
}
static void parse_ds_e(int scancode)
void kbd_ctl_parse_scancode(int scancode)
{
if (scancode < 0 || scancode >= 0x80) return;
unsigned mods, key;
switch (scancode) {
case 0x4f: ds = ds_e1; return;
case 0x5b: ds = ds_e2; return;
case 0x1b: ds = ds_start; break;
default: ds = ds_start; return;
}
kbd_push_ev(KE_PRESS, KC_ESCAPE);
}
static void parse_ds_e1(int scancode)
{
parse_leaf(scancode, map_e1, sizeof(map_e1) / (2 * sizeof(int)));
}
static void parse_ds_e2(int scancode)
{
switch (scancode) {
case 0x31: ds = ds_e2a; break;
case 0x32: ds = ds_e2b; break;
default: ds = ds_start; break;
}
parse_leaf(scancode, map_e2, sizeof(map_e2) / (2 * sizeof(int)));
}
static void parse_ds_e2a(int scancode)
{
parse_leaf(scancode, map_e2a, sizeof(map_e2a) / (2 * sizeof(int)));
}
static void parse_ds_e2b(int scancode)
{
parse_leaf(scancode, map_e2b, sizeof(map_e2b) / (2 * sizeof(int)));
}
static void parse_leaf(int scancode, int (*map)[2], size_t map_length)
{
unsigned int key, mod;
int i;
ds = ds_start;
if (scancode < 0 || scancode >= map_length)
return;
mod = map[scancode][0];
key = map[scancode][1];
/* Simulate modifier pressing. */
i = 0;
while (mods_keys[i][0] != 0) {
if (mod & mods_keys[i][0]) {
kbd_push_ev(KE_PRESS, mods_keys[i][1]);
}
++i;
}
ds = gsp_step(&sp, ds, scancode, &mods, &key);
if (key != 0) {
kbd_push_ev(KE_PRESS, key);
kbd_push_ev(KE_RELEASE, key);
stroke_sim(mods, key);
}
/* Simulate modifier releasing. */
i = 0;
while (mods_keys[i][0] != 0) {
if (mod & mods_keys[i][0]) {
kbd_push_ev(KE_RELEASE, mods_keys[i][1]);
}
++i;
}
}
/**
* @}
*/

/branches/dd/uspace/srv/kbd/ctl/sun.c
45,6 → 45,11
static int scanmap_simple[];
int kbd_ctl_init(void)
{
return 0;
}
void kbd_ctl_parse_scancode(int scancode)
{
kbd_ev_type_t type;

/branches/dd/uspace/srv/kbd/ctl/gxe_fb.c
39,282 → 39,189
#include <kbd/kbd.h>
#include <kbd/keycode.h>
#include <kbd_ctl.h>
#include <gsp.h>
#include <stroke.h>
static void parse_ds_start(int scancode);
static void parse_ds_e(int scancode);
static void parse_ds_e1(int scancode);
static void parse_ds_e1a(int scancode);
static void parse_ds_e1b(int scancode);
static void parse_ds_e1c(int scancode);
/** Scancode parser */
static gsp_t sp;
static void parse_leaf(int scancode, int (*map)[2], size_t map_length);
/** Current parser state */
static int ds;
enum dec_state {
ds_start,
ds_e,
ds_e1,
ds_e1a,
ds_e1b,
ds_e1c
};
#include <stdio.h>
static int map_start[][2] = {
int seq_defs[] = {
/* Not shifted */
[0x60] = { 0, KC_BACKTICK },
0, KC_BACKTICK, 0x60, GSP_END,
[0x31] = { 0, KC_1 },
[0x32] = { 0, KC_2 },
[0x33] = { 0, KC_3 },
[0x34] = { 0, KC_4 },
[0x35] = { 0, KC_5 },
[0x36] = { 0, KC_6 },
[0x37] = { 0, KC_7 },
[0x38] = { 0, KC_8 },
[0x39] = { 0, KC_9 },
[0x30] = { 0, KC_0 },
0, KC_1, 0x31, GSP_END,
0, KC_2, 0x32, GSP_END,
0, KC_3, 0x33, GSP_END,
0, KC_4, 0x34, GSP_END,
0, KC_5, 0x35, GSP_END,
0, KC_6, 0x36, GSP_END,
0, KC_7, 0x37, GSP_END,
0, KC_8, 0x38, GSP_END,
0, KC_9, 0x39, GSP_END,
0, KC_0, 0x30, GSP_END,
[0x2d] = { 0, KC_MINUS },
[0x3d] = { 0, KC_EQUALS },
[0x08] = { 0, KC_BACKSPACE },
0, KC_MINUS, 0x2d, GSP_END,
0, KC_EQUALS, 0x3d, GSP_END,
0, KC_BACKSPACE, 0x08, GSP_END,
[0x0f] = { 0, KC_TAB },
0, KC_TAB, 0x09, GSP_END,
[0x71] = { 0, KC_Q },
[0x77] = { 0, KC_W },
[0x65] = { 0, KC_E },
[0x72] = { 0, KC_R },
[0x74] = { 0, KC_T },
[0x79] = { 0, KC_Y },
[0x75] = { 0, KC_U },
[0x69] = { 0, KC_I },
[0x6f] = { 0, KC_O },
[0x70] = { 0, KC_P },
0, KC_Q, 0x71, GSP_END,
0, KC_W, 0x77, GSP_END,
0, KC_E, 0x65, GSP_END,
0, KC_R, 0x72, GSP_END,
0, KC_T, 0x74, GSP_END,
0, KC_Y, 0x79, GSP_END,
0, KC_U, 0x75, GSP_END,
0, KC_I, 0x69, GSP_END,
0, KC_O, 0x6f, GSP_END,
0, KC_P, 0x70, GSP_END,
[0x5b] = { 0, KC_LBRACKET },
[0x5d] = { 0, KC_RBRACKET },
0, KC_LBRACKET, 0x5b, GSP_END,
0, KC_RBRACKET, 0x5d, GSP_END,
[0x61] = { 0, KC_A },
[0x73] = { 0, KC_S },
[0x64] = { 0, KC_D },
[0x66] = { 0, KC_F },
[0x67] = { 0, KC_G },
[0x68] = { 0, KC_H },
[0x6a] = { 0, KC_J },
[0x6b] = { 0, KC_K },
[0x6c] = { 0, KC_L },
0, KC_A, 0x61, GSP_END,
0, KC_S, 0x73, GSP_END,
0, KC_D, 0x64, GSP_END,
0, KC_F, 0x66, GSP_END,
0, KC_G, 0x67, GSP_END,
0, KC_H, 0x68, GSP_END,
0, KC_J, 0x6a, GSP_END,
0, KC_K, 0x6b, GSP_END,
0, KC_L, 0x6c, GSP_END,
[0x3b] = { 0, KC_SEMICOLON },
[0x27] = { 0, KC_QUOTE },
[0x5c] = { 0, KC_BACKSLASH },
0, KC_SEMICOLON, 0x3b, GSP_END,
0, KC_QUOTE, 0x27, GSP_END,
0, KC_BACKSLASH, 0x5c, GSP_END,
[0x7a] = { 0, KC_Z },
[0x78] = { 0, KC_X },
[0x63] = { 0, KC_C },
[0x76] = { 0, KC_V },
[0x62] = { 0, KC_B },
[0x6e] = { 0, KC_N },
[0x6d] = { 0, KC_M },
0, KC_Z, 0x7a, GSP_END,
0, KC_X, 0x78, GSP_END,
0, KC_C, 0x63, GSP_END,
0, KC_V, 0x76, GSP_END,
0, KC_B, 0x62, GSP_END,
0, KC_N, 0x6e, GSP_END,
0, KC_M, 0x6d, GSP_END,
[0x2c] = { 0, KC_COMMA },
[0x2e] = { 0, KC_PERIOD },
[0x2f] = { 0, KC_SLASH },
0, KC_COMMA, 0x2c, GSP_END,
0, KC_PERIOD, 0x2e, GSP_END,
0, KC_SLASH, 0x2f, GSP_END,
[0x20] = { 0, KC_SPACE },
/* Shifted */
[0x1b] = { 0, KC_ESCAPE },
KM_SHIFT, KC_BACKTICK, 0x7e, GSP_END,
[0x0a] = { 0, KC_ENTER },
[0x0d] = { 0, KC_ENTER },
KM_SHIFT, KC_1, 0x21, GSP_END,
KM_SHIFT, KC_2, 0x40, GSP_END,
KM_SHIFT, KC_3, 0x23, GSP_END,
KM_SHIFT, KC_4, 0x24, GSP_END,
KM_SHIFT, KC_5, 0x25, GSP_END,
KM_SHIFT, KC_6, 0x5e, GSP_END,
KM_SHIFT, KC_7, 0x26, GSP_END,
KM_SHIFT, KC_8, 0x2a, GSP_END,
KM_SHIFT, KC_9, 0x28, GSP_END,
KM_SHIFT, KC_0, 0x29, GSP_END,
/* with Shift pressed */
KM_SHIFT, KC_MINUS, 0x5f, GSP_END,
KM_SHIFT, KC_EQUALS, 0x2b, GSP_END,
[0x7e] = { KM_LSHIFT, KC_BACKTICK },
KM_SHIFT, KC_Q, 0x51, GSP_END,
KM_SHIFT, KC_W, 0x57, GSP_END,
KM_SHIFT, KC_E, 0x45, GSP_END,
KM_SHIFT, KC_R, 0x52, GSP_END,
KM_SHIFT, KC_T, 0x54, GSP_END,
KM_SHIFT, KC_Y, 0x59, GSP_END,
KM_SHIFT, KC_U, 0x55, GSP_END,
KM_SHIFT, KC_I, 0x49, GSP_END,
KM_SHIFT, KC_O, 0x4f, GSP_END,
KM_SHIFT, KC_P, 0x50, GSP_END,
[0x21] = { KM_LSHIFT, KC_1 },
[0x40] = { KM_LSHIFT, KC_2 },
[0x23] = { KM_LSHIFT, KC_3 },
[0x24] = { KM_LSHIFT, KC_4 },
[0x25] = { KM_LSHIFT, KC_5 },
[0x5e] = { KM_LSHIFT, KC_6 },
[0x26] = { KM_LSHIFT, KC_7 },
[0x2a] = { KM_LSHIFT, KC_8 },
[0x28] = { KM_LSHIFT, KC_9 },
[0x29] = { KM_LSHIFT, KC_0 },
KM_SHIFT, KC_LBRACKET, 0x7b, GSP_END,
KM_SHIFT, KC_RBRACKET, 0x7d, GSP_END,
[0x5f] = { KM_LSHIFT, KC_MINUS },
[0x2b] = { KM_LSHIFT, KC_EQUALS },
KM_SHIFT, KC_A, 0x41, GSP_END,
KM_SHIFT, KC_S, 0x53, GSP_END,
KM_SHIFT, KC_D, 0x44, GSP_END,
KM_SHIFT, KC_F, 0x46, GSP_END,
KM_SHIFT, KC_G, 0x47, GSP_END,
KM_SHIFT, KC_H, 0x48, GSP_END,
KM_SHIFT, KC_J, 0x4a, GSP_END,
KM_SHIFT, KC_K, 0x4b, GSP_END,
KM_SHIFT, KC_L, 0x4c, GSP_END,
[0x51] = { KM_LSHIFT, KC_Q },
[0x57] = { KM_LSHIFT, KC_W },
[0x45] = { KM_LSHIFT, KC_E },
[0x52] = { KM_LSHIFT, KC_R },
[0x54] = { KM_LSHIFT, KC_T },
[0x59] = { KM_LSHIFT, KC_Y },
[0x55] = { KM_LSHIFT, KC_U },
[0x49] = { KM_LSHIFT, KC_I },
[0x4f] = { KM_LSHIFT, KC_O },
[0x50] = { KM_LSHIFT, KC_P },
KM_SHIFT, KC_SEMICOLON, 0x3a, GSP_END,
KM_SHIFT, KC_QUOTE, 0x22, GSP_END,
KM_SHIFT, KC_BACKSLASH, 0x7c, GSP_END,
[0x7b] = { KM_LSHIFT, KC_LBRACKET },
[0x7d] = { KM_LSHIFT, KC_RBRACKET },
KM_SHIFT, KC_Z, 0x5a, GSP_END,
KM_SHIFT, KC_X, 0x58, GSP_END,
KM_SHIFT, KC_C, 0x43, GSP_END,
KM_SHIFT, KC_V, 0x56, GSP_END,
KM_SHIFT, KC_B, 0x42, GSP_END,
KM_SHIFT, KC_N, 0x4e, GSP_END,
KM_SHIFT, KC_M, 0x4d, GSP_END,
[0x41] = { KM_LSHIFT, KC_A },
[0x53] = { KM_LSHIFT, KC_S },
[0x44] = { KM_LSHIFT, KC_D },
[0x46] = { KM_LSHIFT, KC_F },
[0x47] = { KM_LSHIFT, KC_G },
[0x48] = { KM_LSHIFT, KC_H },
[0x4a] = { KM_LSHIFT, KC_J },
[0x4b] = { KM_LSHIFT, KC_K },
[0x4c] = { KM_LSHIFT, KC_L },
KM_SHIFT, KC_COMMA, 0x3c, GSP_END,
KM_SHIFT, KC_PERIOD, 0x3e, GSP_END,
KM_SHIFT, KC_SLASH, 0x3f, GSP_END,
[0x3a] = { KM_LSHIFT, KC_SEMICOLON },
[0x22] = { KM_LSHIFT, KC_QUOTE },
[0x7c] = { KM_LSHIFT, KC_BACKSLASH },
/* ... */
[0x5a] = { KM_LSHIFT, KC_Z },
[0x58] = { KM_LSHIFT, KC_X },
[0x43] = { KM_LSHIFT, KC_C },
[0x56] = { KM_LSHIFT, KC_V },
[0x42] = { KM_LSHIFT, KC_B },
[0x4e] = { KM_LSHIFT, KC_N },
[0x4d] = { KM_LSHIFT, KC_M },
0, KC_SPACE, 0x20, GSP_END,
0, KC_ENTER, 0x0a, GSP_END,
0, KC_ENTER, 0x0d, GSP_END,
[0x3c] = { KM_LSHIFT, KC_COMMA },
[0x3e] = { KM_LSHIFT, KC_PERIOD },
[0x3f] = { KM_LSHIFT, KC_SLASH }
};
0, KC_ESCAPE, 0x1b, 0x1b, GSP_END,
static int map_e1[][2] =
{
};
0, KC_F1, 0x1b, 0x5b, 0x4f, 0x50, GSP_END,
0, KC_F2, 0x1b, 0x5b, 0x4f, 0x51, GSP_END,
0, KC_F3, 0x1b, 0x5b, 0x4f, 0x52, GSP_END,
0, KC_F4, 0x1b, 0x5b, 0x4f, 0x53, GSP_END,
0, KC_F5, 0x1b, 0x5b, 0x31, 0x35, GSP_END,
0, KC_F6, 0x1b, 0x5b, 0x31, 0x37, GSP_END,
0, KC_F7, 0x1b, 0x5b, 0x31, 0x38, GSP_END,
0, KC_F8, 0x1b, 0x5b, 0x31, 0x39, GSP_END,
0, KC_F9, 0x1b, 0x5b, 0x32, 0x38, GSP_END,
0, KC_F10, 0x1b, 0x5b, 0x32, 0x39, GSP_END,
0, KC_F11, 0x1b, 0x5b, 0x32, 0x33, GSP_END,
0, KC_F12, 0x1b, 0x5b, 0x32, 0x34, GSP_END,
static int map_e1a[][2] =
{
[0x50] = { 0, KC_F1 },
[0x51] = { 0, KC_F2 },
[0x52] = { 0, KC_F3 },
[0x53] = { 0, KC_F4 },
};
0, KC_INSERT, 0x1b, 0x5b, 0x32, 0x7e, GSP_END,
0, KC_HOME, 0x1b, 0x5b, 0x48, GSP_END,
0, KC_PAGE_UP, 0x1b, 0x5b, 0x35, 0x7e, GSP_END,
0, KC_DELETE, 0x1b, 0x5b, 0x33, 0x7e, GSP_END,
0, KC_END, 0x1b, 0x5b, 0x46, GSP_END,
0, KC_PAGE_DOWN, 0x1b, 0x5b, 0x36, 0x7e, GSP_END,
static int map_e1b[][2] =
{
[0x33] = { 0, KC_F5 },
[0x37] = { 0, KC_F6 },
[0x38] = { 0, KC_F7 },
[0x39] = { 0, KC_F8 },
};
0, KC_UP, 0x1b, 0x5b, 0x41, GSP_END,
0, KC_LEFT, 0x1b, 0x5b, 0x44, GSP_END,
0, KC_DOWN, 0x1b, 0x5b, 0x42, GSP_END,
0, KC_RIGHT, 0x1b, 0x5b, 0x43, GSP_END,
static int map_e1c[][2] =
{
[0x38] = { 0, KC_F9 },
[0x39] = { 0, KC_F10 },
[0x33] = { 0, KC_F11 },
[0x34] = { 0, KC_F12 },
0, 0
};
static unsigned int mods_keys[][2] = {
{ KM_LSHIFT, KC_LSHIFT },
{ 0, 0 }
};
static enum dec_state ds = ds_start;
void kbd_ctl_parse_scancode(int scancode)
int kbd_ctl_init(void)
{
switch (ds) {
case ds_start: parse_ds_start(scancode); break;
case ds_e: parse_ds_e(scancode); break;
case ds_e1: parse_ds_e1(scancode); break;
case ds_e1a: parse_ds_e1a(scancode); break;
case ds_e1b: parse_ds_e1b(scancode); break;
case ds_e1c: parse_ds_e1c(scancode); break;
}
}
ds = 0;
static void parse_ds_start(int scancode)
{
if (scancode == 0x1b) {
ds = ds_e;
return;
}
parse_leaf(scancode, map_start, sizeof(map_start) / (2 * sizeof(int)));
gsp_init(&sp);
return gsp_insert_defs(&sp, seq_defs);
}
static void parse_ds_e(int scancode)
void kbd_ctl_parse_scancode(int scancode)
{
switch (scancode) {
case 0x5b: ds = ds_e1; return;
case 0x1b: ds = ds_start; break;
default: ds = ds_start; return;
}
unsigned mods, key;
kbd_push_ev(KE_PRESS, KC_ESCAPE);
}
static void parse_ds_e1(int scancode)
{
switch (scancode) {
case 0x4f: ds = ds_e1a; return;
case 0x31: ds = ds_e1b; return;
case 0x32: ds = ds_e1c; return;
default: ds = ds_start; break;
}
parse_leaf(scancode, map_e1, sizeof(map_e1) / (2 * sizeof(int)));
}
static void parse_ds_e1a(int scancode)
{
parse_leaf(scancode, map_e1a, sizeof(map_e1a) / (2 * sizeof(int)));
}
static void parse_ds_e1b(int scancode)
{
parse_leaf(scancode, map_e1b, sizeof(map_e1b) / (2 * sizeof(int)));
}
static void parse_ds_e1c(int scancode)
{
parse_leaf(scancode, map_e1c, sizeof(map_e1c) / (2 * sizeof(int)));
}
static void parse_leaf(int scancode, int (*map)[2], size_t map_length)
{
unsigned int key, mod;
int i;
ds = ds_start;
if (scancode < 0 || scancode >= map_length)
return;
mod = map[scancode][0];
key = map[scancode][1];
/* Simulate modifier pressing. */
i = 0;
while (mods_keys[i][0] != 0) {
if (mod & mods_keys[i][0]) {
kbd_push_ev(KE_PRESS, mods_keys[i][1]);
}
++i;
}
ds = gsp_step(&sp, ds, scancode, &mods, &key);
if (key != 0) {
kbd_push_ev(KE_PRESS, key);
kbd_push_ev(KE_RELEASE, key);
stroke_sim(mods, key);
}
/* Simulate modifier releasing. */
i = 0;
while (mods_keys[i][0] != 0) {
if (mod & mods_keys[i][0]) {
kbd_push_ev(KE_RELEASE, mods_keys[i][1]);
}
++i;
}
}
/**

/branches/dd/uspace/srv/kbd/include/gsp.h
0,0 → 1,84
/*
* Copyright (c) 2009 Jiri Svoboda
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* - The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/** @addtogroup kbdgen generic
* @brief Generic scancode parser.
* @ingroup kbd
* @{
*/
/** @file
*/
#ifndef KBD_GSP_H_
#define KBD_GSP_H_
#include <libadt/hash_table.h>
enum {
GSP_END = -1, /**< Terminates a sequence. */
GSP_DEFAULT = -2 /**< Wildcard, catches unhandled cases. */
};
/** Scancode parser description */
typedef struct {
/** Transition table, (state, input) -> (state, output) */
hash_table_t trans;
/** Number of states */
int states;
} gsp_t;
/** Scancode parser transition. */
typedef struct {
link_t link; /**< Link to hash table in @c gsp_t */
/* Preconditions */
int old_state; /**< State before transition */
int input; /**< Input symbol (scancode) */
/* Effects */
int new_state; /**< State after transition */
/* Output emitted during transition */
unsigned out_mods; /**< Modifier to emit */
unsigned out_key; /**< Keycode to emit */
} gsp_trans_t;
extern void gsp_init(gsp_t *);
extern int gsp_insert_defs(gsp_t *, const int *);
extern int gsp_insert_seq(gsp_t *, const int *, unsigned, unsigned);
extern int gsp_step(gsp_t *, int, int, unsigned *, unsigned *);
#endif
/**
* @}
*/

/branches/dd/uspace/srv/kbd/include/kbd_ctl.h
38,7 → 38,9
#define KBD_CTL_H_
extern void kbd_ctl_parse_scancode(int);
extern int kbd_ctl_init(void);
#endif
/**

/branches/dd/uspace/srv/kbd/include/stroke.h
0,0 → 1,47
/*
* Copyright (c) 2009 Jiri Svoboda
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* - The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/** @addtogroup kbdgen generic
* @brief Generic scancode parser.
* @ingroup kbd
* @{
*/
/** @file
*/
#ifndef KBD_STROKE_H_
#define KBD_STROKE_H_
extern void stroke_sim(unsigned, unsigned);
#endif
/**
* @}
*/

/branches/dd/uspace/srv/kbd/port/gxemul.c
39,6 → 39,7
#include <sysinfo.h>
#include <kbd_port.h>
#include <kbd.h>
#include <ddi.h>
static irq_cmd_t gxemul_cmds[] = {
{
63,7 → 64,7
{
async_set_interrupt_received(gxemul_irq_handler);
gxemul_cmds[0].addr = (void *) sysinfo_value("kbd.address.virtual");
ipc_register_irq(sysinfo_value("kbd.inr"), sysinfo_value("kbd.devno"),
ipc_register_irq(sysinfo_value("kbd.inr"), device_assign_devno(),
0, &gxemul_kbd);
return 0;
}

/branches/dd/uspace/srv/kbd/port/ns16550.c
99,7 → 99,7
ns16550_kernel = sysinfo_value("kbd.address.kernel");
ns16550_kbd.cmds[0].addr = (void *) (ns16550_kernel + LSR_REG);
ns16550_kbd.cmds[3].addr = (void *) (ns16550_kernel + RBR_REG);
ipc_register_irq(sysinfo_value("kbd.inr"), sysinfo_value("kbd.devno"),
ipc_register_irq(sysinfo_value("kbd.inr"), device_assign_devno(),
0, &ns16550_kbd);
return pio_enable((void *) ns16550_physical, 8, &vaddr);
}

/branches/dd/uspace/srv/kbd/port/msim.c
39,6 → 39,7
#include <sysinfo.h>
#include <kbd_port.h>
#include <kbd.h>
#include <ddi.h>
irq_cmd_t msim_cmds[] = {
{
63,7 → 64,7
{
async_set_interrupt_received(msim_irq_handler);
msim_cmds[0].addr = sysinfo_value("kbd.address.virtual");
ipc_register_irq(sysinfo_value("kbd.inr"), sysinfo_value("kbd.devno"),
ipc_register_irq(sysinfo_value("kbd.inr"), device_assign_devno(),
0, &msim_kbd);
return 0;
}

/branches/dd/uspace/srv/kbd/port/i8042.c
43,6 → 43,7
#include <sysinfo.h>
#include <kbd_port.h>
#include <kbd.h>
#include <ddi.h>
#include "i8042.h"
/* Interesting bits for status register */
136,7 → 137,7
/* Enable kbd */
i8042_kbd.cmds[0].addr = &((i8042_t *) i8042_kernel)->status;
i8042_kbd.cmds[3].addr = &((i8042_t *) i8042_kernel)->data;
ipc_register_irq(sysinfo_value("kbd.inr"), sysinfo_value("kbd.devno"), 0, &i8042_kbd);
ipc_register_irq(sysinfo_value("kbd.inr"), device_assign_devno(), 0, &i8042_kbd);
int newcontrol = i8042_KBD_IE | i8042_KBD_TRANSLATE;
if (mouseenabled)

/branches/dd/uspace/srv/kbd/port/ski.c
71,9 → 71,12
(void) arg;
while (1) {
c = ski_getchar();
if (c != 0)
while (1) {
c = ski_getchar();
if (c == 0)
break;
kbd_push_scancode(c);
}
usleep(POLL_INTERVAL);
}

/branches/dd/uspace/srv/kbd/port/z8530.c
89,7 → 89,7
CHAN_A_STATUS;
z8530_cmds[3].addr = (void *) sysinfo_value("kbd.address.kernel") +
CHAN_A_DATA;
ipc_register_irq(sysinfo_value("kbd.inr"), sysinfo_value("kbd.devno"),
ipc_register_irq(sysinfo_value("kbd.inr"), device_assign_devno(),
sysinfo_value("kbd.inr"), &z8530_kbd);
return 0;
}

/branches/dd/uspace/srv/kbd/port/sgcn.c
36,13 → 36,15
#include <as.h>
#include <ddi.h>
#include <ipc/ipc.h>
#include <async.h>
#include <kbd.h>
#include <kbd_port.h>
#include <sysinfo.h>
#include <stdio.h>
#include <thread.h>
#define POLL_INTERVAL 10000
/**
* SGCN buffer header. It is placed at the very beginning of the SGCN
* buffer.
87,16 → 89,16
*/
static uintptr_t sram_buffer_offset;
static void sgcn_irq_handler(ipc_callid_t iid, ipc_call_t *call);
/* polling thread */
static void *sgcn_thread_impl(void *arg);
/**
* Initializes the SGCN driver.
* Maps the physical memory (SRAM) and registers the interrupt.
* Maps the physical memory (SRAM) and creates the polling thread.
*/
int kbd_port_init(void)
{
async_set_interrupt_received(sgcn_irq_handler);
sram_virt_addr = (uintptr_t) as_get_mappable_page(sysinfo_value("sram.area.size"));
if (physmem_map((void *) sysinfo_value("sram.address.physical"),
(void *) sram_virt_addr, sysinfo_value("sram.area.size") / PAGE_SIZE,
106,8 → 108,15
}
sram_buffer_offset = sysinfo_value("sram.buffer.offset");
ipc_register_irq(sysinfo_value("kbd.inr"), sysinfo_value("kbd.devno"),
0, (void *) 0);
thread_id_t tid;
int rc;
rc = thread_create(sgcn_thread_impl, NULL, "kbd_poll", &tid);
if (rc != 0) {
return rc;
}
return 0;
}
115,7 → 124,7
* Handler of the "key pressed" event. Reads codes of all the pressed keys from
* the buffer.
*/
static void sgcn_irq_handler(ipc_callid_t iid, ipc_call_t *call)
static void sgcn_key_pressed(void)
{
char c;
137,5 → 146,19
}
}
/**
* Thread to poll SGCN for keypresses.
*/
static void *sgcn_thread_impl(void *arg)
{
(void) arg;
while (1) {
sgcn_key_pressed();
usleep(POLL_INTERVAL);
}
}
/** @}
*/

/branches/dd/uspace/srv/kbd/genarch/stroke.c
0,0 → 1,84
/*
* Copyright (c) 2009 Jiri Svoboda
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* - The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/** @addtogroup kbd
* @{
*/
/**
* @file
* @brief Stroke simulator.
*
* When simulating a keyboard using a serial TTY we need to convert the
* recognized strokes (such as Shift-A) to sequences of key presses and
* releases (such as 'press Shift, press A, release A, release Shift').
*/
#include <stroke.h>
#include <kbd.h>
#include <kbd/kbd.h>
#include <kbd/keycode.h>
/** Correspondence between modifers and the modifier keycodes. */
static unsigned int mods_keys[][2] = {
{ KM_LSHIFT, KC_LSHIFT },
{ 0, 0 }
};
/** Simulate keystroke using sequences of key presses and releases. */
void stroke_sim(unsigned mod, unsigned key)
{
int i;
/* Simulate modifier presses. */
i = 0;
while (mods_keys[i][0] != 0) {
if (mod & mods_keys[i][0]) {
kbd_push_ev(KE_PRESS, mods_keys[i][1]);
}
++i;
}
/* Simulate key press and release. */
if (key != 0) {
kbd_push_ev(KE_PRESS, key);
kbd_push_ev(KE_RELEASE, key);
}
/* Simulate modifier releases. */
i = 0;
while (mods_keys[i][0] != 0) {
if (mod & mods_keys[i][0]) {
kbd_push_ev(KE_RELEASE, mods_keys[i][1]);
}
++i;
}
}
/**
* @}
*/

/branches/dd/uspace/srv/kbd/genarch/gsp.c
0,0 → 1,288
/*
* Copyright (c) 2009 Jiri Svoboda
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* - The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
* @addtogroup kbdgen generic
* @ingroup kbd
* @{
*/
/** @file
* @brief Generic scancode parser.
*
* The scancode parser is a simple finite state machine. It is described
* using sequences of input symbols (scancodes) and the corresponding output
* value (mods, key pair). When the parser recognizes a sequence,
* it outputs the value and restarts. If a transition is undefined,
* the parser restarts, too.
*
* Apart from precise values, GSP_DEFAULT allows to catch general cases.
* I.e. if we knew that after 0x1b 0x4f there always follow two more
* scancodes, we can define (0x1b, 0x4f, GSP_DEFAULT, GSP_DEFAULT, GSP_END)
* with null output. This will force the parser to read the entire sequence,
* not leaving garbage on the input if it does not recognize the specific
* sequence.
*/
#include <gsp.h>
#include <libadt/hash_table.h>
#include <stdlib.h>
#include <stdio.h>
#define TRANS_TABLE_CHAINS 256
/*
* Hash table operations for the transition function.
*/
static hash_index_t trans_op_hash(unsigned long key[]);
static int trans_op_compare(unsigned long key[], hash_count_t keys,
link_t *item);
static void trans_op_remove_callback(link_t *item);
static hash_table_operations_t trans_ops = {
.hash = trans_op_hash,
.compare = trans_op_compare,
.remove_callback = trans_op_remove_callback
};
static gsp_trans_t *trans_lookup(gsp_t *p, int state, int input);
static void trans_insert(gsp_t *p, gsp_trans_t *t);
static gsp_trans_t *trans_new(void);
/** Initialise scancode parser. */
void gsp_init(gsp_t *p)
{
p->states = 1;
hash_table_create(&p->trans, TRANS_TABLE_CHAINS, 2, &trans_ops);
}
/** Insert a series of definitions into the parser.
*
* @param p The parser.
* @param defs Definition list. Each definition starts with two output values
* (mods, key) and continues with a sequence of input values
* terminated with GSP_END. The definition list is terminated
* with two zeroes (0, 0) for output values.
*/
int gsp_insert_defs(gsp_t *p, const int *defs)
{
unsigned mods, key;
const int *dp;
int rc;
dp = defs;
while (1) {
/* Read the output values. */
mods = *dp++;
key = *dp++;
if (key == 0) break;
/* Insert one sequence. */
rc = gsp_insert_seq(p, dp, mods, key);
if (rc != 0)
return rc;
/* Skip to the next definition. */
while (*dp != GSP_END)
++dp;
++dp;
}
return 0;
}
/** Insert one sequence into the parser.
*
* @param p The parser.
* @param seq Sequence of input values terminated with GSP_END.
* @param mods Corresponsing output value.
* @param key Corresponsing output value.
*/
int gsp_insert_seq(gsp_t *p, const int *seq, unsigned mods, unsigned key)
{
int state;
gsp_trans_t *t;
state = 0;
t = NULL;
/* Input sequence must be non-empty. */
if (*seq == GSP_END)
return -1;
while (*(seq + 1) != GSP_END) {
t = trans_lookup(p, state, *seq);
if (t == NULL) {
/* Create new state. */
t = trans_new();
t->old_state = state;
t->input = *seq;
t->new_state = p->states++;
t->out_mods = 0;
t->out_key = 0;
trans_insert(p, t);
}
state = t->new_state;
++seq;
}
/* Process the last transition. */
t = trans_lookup(p, state, *seq);
if (t != NULL) {
exit(1);
return -1; /* Conflicting definition. */
}
t = trans_new();
t->old_state = state;
t->input = *seq;
t->new_state = 0;
t->out_mods = mods;
t->out_key = key;
trans_insert(p, t);
return 0;
}
/** Compute one parser step.
*
* Computes the next state and output values for a given state and input.
* This handles everything including restarts and default branches.
*
* @param p The parser.
* @param state Old state.
* @param input Input symbol (scancode).
* @param mods Output value (modifier).
* @param key Output value (key).
* @return New state.
*/
int gsp_step(gsp_t *p, int state, int input, unsigned *mods, unsigned *key)
{
gsp_trans_t *t;
t = trans_lookup(p, state, input);
if (t == NULL) {
t = trans_lookup(p, state, GSP_DEFAULT);
}
if (t == NULL) {
printf("gsp_step: not found\n");
*mods = NULL;
*key = NULL;
return 0;
}
*mods = t->out_mods;
*key = t->out_key;
return t->new_state;
}
/** Transition function lookup.
*
* Returns the value of the transition function for the given state
* and input. Note that the transition must be specified precisely,
* to obtain the default branch use input = GSP_DEFAULT.
*
* @param p Parser.
* @param state Current state.
* @param input Input value.
* @return The transition or @c NULL if not defined.
*/
static gsp_trans_t *trans_lookup(gsp_t *p, int state, int input)
{
link_t *item;
unsigned long key[2];
key[0] = state;
key[1] = input;
item = hash_table_find(&p->trans, key);
if (item == NULL) return NULL;
return hash_table_get_instance(item, gsp_trans_t, link);
}
/** Define a new transition.
*
* @param p The parser.
* @param t Transition with all fields defined.
*/
static void trans_insert(gsp_t *p, gsp_trans_t *t)
{
unsigned long key[2];
key[0] = t->old_state;
key[1] = t->input;
hash_table_insert(&p->trans, &key, &t->link);
}
/** Allocate transition structure. */
static gsp_trans_t *trans_new(void)
{
gsp_trans_t *t;
t = malloc(sizeof(gsp_trans_t));
if (t == NULL) {
printf("Memory allocation failed.\n");
exit(1);
}
return t;
}
/*
* Transition function hash table operations.
*/
static hash_index_t trans_op_hash(unsigned long key[])
{
return (key[0] * 17 + key[1]) % TRANS_TABLE_CHAINS;
}
static int trans_op_compare(unsigned long key[], hash_count_t keys,
link_t *item)
{
gsp_trans_t *t;
t = hash_table_get_instance(item, gsp_trans_t, link);
return (key[0] == t->old_state && key[1] == t->input);
}
static void trans_op_remove_callback(link_t *item)
{
}
/**
* @}
*/

/branches/dd/uspace/srv/kbd/generic/kbd.c
189,8 → 189,12
}
/* Initialize port driver. */
if (kbd_port_init())
if (kbd_port_init() != 0)
return -1;
/* Initialize controller driver. */
if (kbd_ctl_init() != 0)
return -1;
/* Initialize key buffer */
keybuffer_init(&keybuffer);

/branches/dd/uspace/srv/kbd/Makefile
44,6 → 44,8
OUTPUT = kbd
GENERIC_SOURCES = \
generic/kbd.c \
genarch/gsp.c \
genarch/stroke.c \
generic/key_buffer.c
ARCH_SOURCES =
77,7 → 79,7
port/i8042.c \
ctl/pc.c
endif
ifeq ($(MACHINE), i640GX)
ifeq ($(MACHINE), i460GX)
GENARCH_SOURCES += \
port/i8042.c \
ctl/pc.c
114,9 → 116,15
ctl/stty.c
endif
ifeq ($(UARCH), sparc64)
ifeq ($(MACHINE),serengeti)
GENARCH_SOURCES += \
port/sgcn.c \
ctl/stty.c
else
GENARCH_SOURCES += \
port/z8530.c \
ctl/sun.c
endif
endif
GENERIC_OBJECTS := $(addsuffix .o,$(basename $(GENERIC_SOURCES)))

/branches/dd/uspace/srv/console/console.c
586,14 → 586,13
return -1;
/* Receive kernel notifications */
if (sysinfo_value("kconsole.present")) {
int devno = sysinfo_value("kconsole.devno");
int inr = sysinfo_value("kconsole.inr");
if (ipc_register_irq(inr, devno, 0, NULL) != EOK)
printf(NAME ": Error registering kconsole notifications\n");
async_set_interrupt_received(interrupt_received);
}
// if (sysinfo_value("kconsole.present")) {
// int inr = sysinfo_value("kconsole.inr");
// if (ipc_register_irq(inr, device_assign_devno(), 0, NULL) != EOK)
// printf(NAME ": Error registering kconsole notifications\n");
//
// async_set_interrupt_received(interrupt_received);
// }
// FIXME: avoid connectiong to itself, keep using klog
// printf(NAME ": Accepting connections\n");

/branches/dd/uspace/srv/loader/main.c
53,6 → 53,7
#include <ipc/services.h>
#include <ipc/loader.h>
#include <loader/pcb.h>
#include <console.h>
#include <errno.h>
#include <async.h>
#include <as.h>
282,13 → 283,13
/* Dynamically linked program */
DPRINTF("Run ELF interpreter.\n");
DPRINTF("Entry point: 0x%lx\n", interp_info.entry);
close_console();
console_close();
ipc_answer_0(rid, EOK);
elf_run(&interp_info, &pcb);
} else {
/* Statically linked program */
close_console();
console_close();
ipc_answer_0(rid, EOK);
elf_run(&prog_info, &pcb);
}

/branches/dd/uspace/srv/fb/serial_console.c
46,6 → 46,8
#include <console/color.h>
#include <console/style.h>
#include "../console/screenbuffer.h"
#include "main.h"
#include "serial_console.h"
#define MAX_CONTROL 20
52,8 → 54,8
static void serial_sgr(const unsigned int mode);
static int width;
static int height;
static int scr_width;
static int scr_height;
static bool color = true; /** True if producing color output. */
static putc_function_t putc_function;
102,7 → 104,7
void serial_goto(const unsigned int row, const unsigned int col)
{
if ((row > height) || (col > width))
if ((row > scr_height) || (col > scr_width))
return;
char control[MAX_CONTROL];
125,7 → 127,7
void serial_scroll(int i)
{
if (i > 0) {
serial_goto(height - 1, 0);
serial_goto(scr_height - 1, 0);
while (i--)
serial_puts("\033D");
} else if (i < 0) {
163,11 → 165,84
void serial_console_init(putc_function_t putc_fn, uint32_t w, uint32_t h)
{
width = w;
height = h;
scr_width = w;
scr_height = h;
putc_function = putc_fn;
}
static void serial_set_style(int style)
{
if (style == STYLE_EMPHASIS) {
if (color) {
serial_sgr(SGR_RESET);
serial_sgr(SGR_FGCOLOR + CI_RED);
serial_sgr(SGR_BGCOLOR + CI_WHITE);
}
serial_sgr(SGR_BOLD);
} else {
if (color) {
serial_sgr(SGR_RESET);
serial_sgr(SGR_FGCOLOR + CI_BLACK);
serial_sgr(SGR_BGCOLOR + CI_WHITE);
}
serial_sgr(SGR_NORMAL_INT);
}
}
static void serial_set_idx(unsigned fgcolor, unsigned bgcolor,
unsigned flags)
{
if (color) {
serial_sgr(SGR_RESET);
serial_sgr(SGR_FGCOLOR + color_map[fgcolor]);
serial_sgr(SGR_BGCOLOR + color_map[bgcolor]);
} else {
if (fgcolor < bgcolor)
serial_sgr(SGR_RESET);
else
serial_sgr(SGR_REVERSE);
}
}
static void serial_set_rgb(uint32_t fgcolor, uint32_t bgcolor)
{
if (fgcolor < bgcolor)
serial_sgr(SGR_REVERSE_OFF);
else
serial_sgr(SGR_REVERSE);
}
static void serial_set_attrs(const attrs_t *a)
{
switch (a->t) {
case at_style: serial_set_style(a->a.s.style); break;
case at_rgb: serial_set_rgb(a->a.r.fg_color, a->a.r.bg_color); break;
case at_idx: serial_set_idx(a->a.i.fg_color,
a->a.i.bg_color, a->a.i.flags); break;
default: break;
}
}
static void draw_text_data(keyfield_t *data)
{
int i, j;
attrs_t *a0, *a1;
serial_goto(0, 0);
a0 = &data[0].attrs;
serial_set_attrs(a0);
for (i = 0; i < scr_height; i++) {
for (j = 0; j < scr_width; j++) {
a1 = &data[i * scr_width + j].attrs;
if (!attrs_same(*a0, *a1))
serial_set_attrs(a1);
(*putc_function)(data[i * scr_width + j].character);
a0 = a1;
}
}
}
/**
* Main function of the thread serving client connections.
*/
176,6 → 251,9
int retval;
ipc_callid_t callid;
ipc_call_t call;
keyfield_t *interbuf = NULL;
size_t intersize = 0;
char c;
int lastcol = 0;
int lastrow = 0;
183,8 → 261,10
int newrow;
int fgcolor;
int bgcolor;
int flags;
int style;
int i;
if (client_connected) {
ipc_answer_0(iid, ELIMIT);
198,7 → 278,7
to 0 - height rows. */
serial_clrscr();
serial_goto(0, 0);
serial_set_scroll_region(height);
serial_set_scroll_region(scr_height);
while (true) {
callid = async_get_call(&call);
207,6 → 287,25
client_connected = 0;
ipc_answer_0(callid, EOK);
return;
case IPC_M_SHARE_OUT:
/* We accept one area for data interchange */
intersize = IPC_GET_ARG2(call);
if (intersize >= scr_width * scr_height *
sizeof(*interbuf)) {
receive_comm_area(callid, &call,
(void *) &interbuf);
continue;
}
retval = EINVAL;
break;
case FB_DRAW_TEXT_DATA:
if (!interbuf) {
retval = EINVAL;
break;
}
draw_text_data(interbuf);
retval = 0;
break;
case FB_PUTCHAR:
c = IPC_GET_ARG1(call);
newrow = IPC_GET_ARG2(call);
227,7 → 326,7
retval = 0;
break;
case FB_GET_CSIZE:
ipc_answer_2(callid, EOK, height, width);
ipc_answer_2(callid, EOK, scr_height, scr_width);
continue;
case FB_CLEAR:
serial_clrscr();
234,52 → 333,28
retval = 0;
break;
case FB_SET_STYLE:
style = IPC_GET_ARG1(call);
if (style == STYLE_EMPHASIS) {
if (color) {
serial_sgr(SGR_RESET);
serial_sgr(SGR_FGCOLOR + CI_RED);
serial_sgr(SGR_BGCOLOR + CI_WHITE);
}
serial_sgr(SGR_BOLD);
} else {
if (color) {
serial_sgr(SGR_RESET);
serial_sgr(SGR_FGCOLOR + CI_BLACK);
serial_sgr(SGR_BGCOLOR + CI_WHITE);
}
serial_sgr(SGR_NORMAL_INT);
}
style = IPC_GET_ARG1(call);
serial_set_style(style);
retval = 0;
break;
case FB_SET_COLOR:
fgcolor = IPC_GET_ARG1(call);
bgcolor = IPC_GET_ARG2(call);
flags = IPC_GET_ARG3(call);
if (color) {
serial_sgr(SGR_RESET);
serial_sgr(SGR_FGCOLOR + color_map[fgcolor]);
serial_sgr(SGR_BGCOLOR + color_map[bgcolor]);
} else {
if (fgcolor < bgcolor)
serial_sgr(SGR_RESET);
else
serial_sgr(SGR_REVERSE);
}
serial_set_idx(fgcolor, bgcolor, flags);
retval = 0;
break;
case FB_SET_RGB_COLOR:
fgcolor = IPC_GET_ARG1(call);
bgcolor = IPC_GET_ARG2(call);
if (fgcolor < bgcolor)
serial_sgr(SGR_REVERSE_OFF);
else
serial_sgr(SGR_REVERSE);
serial_set_rgb(fgcolor, bgcolor);
retval = 0;
break;
case FB_SCROLL:
i = IPC_GET_ARG1(call);
if ((i > height) || (i < -height)) {
if ((i > scr_height) || (i < -scr_height)) {
retval = EINVAL;
break;
}

/branches/dd/uspace/srv/fb/serial_console.h
46,7 → 46,6
void serial_goto(const unsigned int row, const unsigned int col);
void serial_clrscr(void);
void serial_scroll(int i);
void serial_set_style(const unsigned int mode);
void serial_cursor_disable(void);
void serial_cursor_enable(void);
void serial_set_scroll_region(unsigned height);

/branches/dd/uspace/srv/obio/obio.c
94,7 → 94,7
switch (IPC_GET_METHOD(call)) {
case BUS_CLEAR_INTERRUPT:
inr = IPC_GET_ARG1(call);
base_virt[OBIO_CIR(inr) & INO_MASK] = 0;
base_virt[OBIO_CIR(inr & INO_MASK)] = 0;
ipc_answer_0(callid, EOK);
break;
default: