| /uspace/trunk/kbd/generic/kbd.c |
|---|
| 48,25 → 48,25 |
| ipcarg_t phonead; |
| int phoneid; |
| char connected = 0; |
| keybuffer_t keybuffer; |
| ipcarg_t retval, arg1, arg2; |
| printf("Uspace kbd service started.\n"); |
| // printf("Uspace kbd service started.\n"); |
| /* Initialize arch dependent parts */ |
| if (!(res = kbd_arch_init())) { |
| printf("Kbd registration failed with retval %d.\n", res); |
| // printf("Kbd registration failed with retval %d.\n", res); |
| return -1; |
| }; |
| /* Initialize key buffer */ |
| key_buffer_init(); |
| keybuffer_init(&keybuffer); |
| /* Register service at nameserver */ |
| printf("%s: Registering at naming service.\n", NAME); |
| // printf("%s: Registering at naming service.\n", NAME); |
| if ((res = ipc_connect_to_me(PHONE_NS, SERVICE_KEYBOARD, 0, &phonead)) != 0) { |
| printf("%s: Error: Registering at naming service failed.\n", NAME); |
| // printf("%s: Error: Registering at naming service failed.\n", NAME); |
| return -1; |
| }; |
| 75,7 → 75,7 |
| // printf("%s:Call phone=%lX..", NAME, call.in_phone_hash); |
| switch (IPC_GET_METHOD(call)) { |
| case IPC_M_PHONE_HUNGUP: |
| printf("%s: Phone hung up.\n", NAME); |
| // printf("%s: Phone hung up.\n", NAME); |
| connected = 0; |
| retval = 0; |
| break; |
| 97,7 → 97,7 |
| case IPC_M_INTERRUPT: |
| if (connected) { |
| /* recode to ASCII - one interrupt can produce more than one code so result is stored in fifo */ |
| kbd_arch_process(IPC_GET_ARG2(call)); |
| kbd_arch_process(&keybuffer, IPC_GET_ARG2(call)); |
| //printf("%s: GOT INTERRUPT: %c\n", NAME, key); |
| 106,20 → 106,20 |
| retval = 0; |
| while (!key_buffer_empty()) { |
| if (!key_buffer_pop((char *)&arg1)) { |
| printf("%s: KeyBuffer is empty but it should not be.\n"); |
| while (!keybuffer_empty(&keybuffer)) { |
| if (!keybuffer_pop(&keybuffer, (char *)&arg1)) { |
| // printf("%s: KeyBuffer is empty but it should not be.\n"); |
| break; |
| } |
| /*FIXME: detection of closed connection */ |
| ipc_call_async(phoneid, KBD_PUSHCHAR, arg1, 0, NULL); |
| ipc_call_async(phoneid, KBD_PUSHCHAR, arg1, NULL, NULL); |
| } |
| } |
| printf("%s: Interrupt processed.\n", NAME); |
| // printf("%s: Interrupt processed.\n", NAME); |
| break; |
| default: |
| printf("%s: Unknown method: %zd\n", NAME, IPC_GET_METHOD(call)); |
| // printf("%s: Unknown method: %zd\n", NAME, IPC_GET_METHOD(call)); |
| retval = ENOENT; |
| break; |
| } |
| /uspace/trunk/kbd/generic/key_buffer.c |
|---|
| 27,27 → 27,22 |
| */ |
| #include <key_buffer.h> |
| #include <libadt/fifo.h> |
| #define KBD_BUFFER_SIZE 128 /**< Size of buffer for pressed keys */ |
| FIFO_INITIALIZE_STATIC(buffer, char, KBD_BUFFER_SIZE); /**< Fifo for storing pressed keys */ |
| fifo_count_t buffer_items; /**< Counter of used items for prevent fifo overflow */ |
| /** Clear key buffer. |
| */ |
| void key_buffer_free(void) |
| void keybuffer_free(keybuffer_t *keybuffer) |
| { |
| buffer_items = 0; |
| buffer.head = buffer.tail = 0; |
| keybuffer->items = 0; |
| keybuffer->head = keybuffer->tail = keybuffer->items = 0; |
| } |
| /** Key buffer initialization. |
| * |
| */ |
| void key_buffer_init(void) |
| void keybuffer_init(keybuffer_t *keybuffer) |
| { |
| key_buffer_free(); |
| keybuffer_free(keybuffer); |
| } |
| /** Get free space in buffer. |
| 55,17 → 50,17 |
| * to more than one character. |
| * @return empty buffer space |
| */ |
| int key_buffer_available(void) |
| int keybuffer_available(keybuffer_t *keybuffer) |
| { |
| return KBD_BUFFER_SIZE - buffer_items; |
| return KEYBUFFER_SIZE - keybuffer->items; |
| } |
| /** |
| * @return nonzero, if buffer is not empty. |
| */ |
| int key_buffer_empty(void) |
| int keybuffer_empty(keybuffer_t *keybuffer) |
| { |
| return (buffer_items == 0); |
| return (keybuffer->items == 0); |
| } |
| /** Push key to key buffer. |
| 72,11 → 67,11 |
| * If buffer is full, character is ignored. |
| * @param key code of stored key |
| */ |
| void key_buffer_push(char key) |
| void keybuffer_push(keybuffer_t *keybuffer, char key) |
| { |
| if (buffer_items < KBD_BUFFER_SIZE) { |
| fifo_push(buffer, key); |
| buffer_items++; |
| if (keybuffer->items < KEYBUFFER_SIZE) { |
| keybuffer->fifo[keybuffer->tail = (keybuffer->tail + 1) < keybuffer->items ? (keybuffer->tail + 1) : 0] = (key); |
| keybuffer->items++; |
| } |
| } |
| 84,11 → 79,11 |
| * @param c pointer to space where to store character from buffer. |
| * @return zero on empty buffer, nonzero else |
| */ |
| int key_buffer_pop(char *c) |
| int keybuffer_pop(keybuffer_t *keybuffer, char *c) |
| { |
| if (buffer_items > 0) { |
| buffer_items--; |
| *c = fifo_pop(buffer); |
| if (keybuffer->items > 0) { |
| keybuffer->items--; |
| *c = keybuffer->fifo[keybuffer->head = (keybuffer->head + 1) < keybuffer->items ? (keybuffer->head + 1) : 0]; |
| return 1; |
| } |
| return 0; |