| 31,7 → 31,7 |
|---|
| */ |
| /** |
| * @file |
| * @brief SGCN driver. |
| * @brief SGCN driver. |
| */ |
| |
| #include <arch.h> |
| 101,9 → 101,6 |
|---|
| /** Returns a pointer to the console buffer header. */ |
| #define SGCN_BUFFER_HEADER (SGCN_BUFFER(sgcn_buffer_header_t, 0)) |
| |
| /** defined in drivers/kbd.c */ |
| extern kbd_type_t kbd_type; |
| |
| /** starting address of SRAM, will be set by the init_sram_begin function */ |
| static uintptr_t sram_begin; |
| |
| 130,7 → 127,7 |
|---|
| |
| |
| /* functions referenced from definitions of I/O operations structures */ |
| static void sgcn_putchar(outdev_t *, const char, bool); |
| static void sgcn_putchar(outdev_t *, const wchar_t, bool); |
| |
| /** SGCN output device operations */ |
| static outdev_operations_t sgcnout_ops = { |
| 137,12 → 134,6 |
|---|
| .write = sgcn_putchar |
| }; |
| |
| /** SGCN input device operations */ |
| static indev_operations_t sgcnin_ops = { |
| .poll = NULL |
| }; |
| |
| static indev_t sgcnin; /**< SGCN input device. */ |
| static outdev_t sgcnout; /**< SGCN output device. */ |
| |
| /** |
| 207,12 → 198,12 |
|---|
| |
| init_sram_begin(); |
| |
| ASSERT(strcmp(SRAM_TOC->magic, SRAM_TOC_MAGIC) == 0); |
| ASSERT(str_cmp(SRAM_TOC->magic, SRAM_TOC_MAGIC) == 0); |
| |
| /* lookup TOC entry with the correct key */ |
| uint32_t i; |
| for (i = 0; i < MAX_TOC_ENTRIES; i++) { |
| if (strcmp(SRAM_TOC->keys[i].key, CONSOLE_KEY) == 0) |
| if (str_cmp(SRAM_TOC->keys[i].key, CONSOLE_KEY) == 0) |
| break; |
| } |
| ASSERT(i < MAX_TOC_ENTRIES); |
| 264,18 → 255,20 |
|---|
| } |
| |
| /** |
| * SGCN output operation. Prints a single character to the SGCN. If the line |
| * feed character is written ('\n'), the carriage return character ('\r') is |
| * written straight away. |
| * SGCN output operation. Prints a single character to the SGCN. Newline |
| * character is converted to CRLF. |
| */ |
| static void sgcn_putchar(outdev_t *od, const char c, bool silent) |
| static void sgcn_putchar(outdev_t *od, const wchar_t ch, bool silent) |
| { |
| if (!silent) { |
| spinlock_lock(&sgcn_output_lock); |
| |
| sgcn_do_putchar(c); |
| if (c == '\n') |
| sgcn_do_putchar('\r'); |
| if (ascii_check(ch)) { |
| if (ch == '\n') |
| sgcn_do_putchar('\r'); |
| sgcn_do_putchar(ch); |
| } else |
| sgcn_do_putchar(U_SPECIAL); |
| |
| spinlock_unlock(&sgcn_output_lock); |
| } |
| 286,7 → 279,7 |
|---|
| */ |
| void sgcn_grab(void) |
| { |
| kbd_disabled = true; |
| kbd_disabled = false; |
| } |
| |
| /** |
| 302,7 → 295,7 |
|---|
| * there are some unread characters in the input queue. If so, it picks them up |
| * and sends them to the upper layers of HelenOS. |
| */ |
| static void sgcn_poll() |
| static void sgcn_poll(sgcn_instance_t *instance) |
| { |
| uint32_t begin = SGCN_BUFFER_HEADER->in_begin; |
| uint32_t end = SGCN_BUFFER_HEADER->in_end; |
| 320,13 → 313,12 |
|---|
| volatile uint32_t *in_rdptr_ptr = &(SGCN_BUFFER_HEADER->in_rdptr); |
| |
| while (*in_rdptr_ptr != *in_wrptr_ptr) { |
| |
| buf_ptr = (volatile char *) |
| SGCN_BUFFER(char, SGCN_BUFFER_HEADER->in_rdptr); |
| char c = *buf_ptr; |
| *in_rdptr_ptr = (((*in_rdptr_ptr) - begin + 1) % size) + begin; |
| |
| indev_push_character(&sgcnin, c); |
| indev_push_character(instance->srlnin, c); |
| } |
| |
| spinlock_unlock(&sgcn_input_lock); |
| 335,11 → 327,10 |
|---|
| /** |
| * Polling thread function. |
| */ |
| static void kkbdpoll(void *arg) { |
| static void ksgcnpoll(void *instance) { |
| while (1) { |
| if (!silent) { |
| sgcn_poll(); |
| } |
| if (!silent) |
| sgcn_poll(instance); |
| thread_usleep(POLL_INTERVAL); |
| } |
| } |
| 347,23 → 338,36 |
|---|
| /** |
| * A public function which initializes input from the Serengeti console. |
| */ |
| indev_t *sgcnin_init(void) |
| sgcn_instance_t *sgcnin_init(void) |
| { |
| sgcn_buffer_begin_init(); |
| |
| sgcn_instance_t *instance = |
| malloc(sizeof(sgcn_instance_t), FRAME_ATOMIC); |
| |
| if (instance) { |
| instance->srlnin = NULL; |
| instance->thread = thread_create(ksgcnpoll, instance, TASK, 0, |
| "ksgcnpoll", true); |
| |
| if (!instance->thread) { |
| free(instance); |
| return NULL; |
| } |
| } |
| |
| return instance; |
| } |
| |
| kbd_type = KBD_SGCN; |
| void sgcnin_wire(sgcn_instance_t *instance, indev_t *srlnin) |
| { |
| ASSERT(instance); |
| ASSERT(srlnin); |
| |
| instance->srlnin = srlnin; |
| thread_ready(instance->thread); |
| |
| sysinfo_set_item_val("kbd", NULL, true); |
| sysinfo_set_item_val("kbd.type", NULL, KBD_SGCN); |
| |
| thread_t *t = thread_create(kkbdpoll, NULL, TASK, 0, "kkbdpoll", true); |
| if (!t) |
| panic("Cannot create kkbdpoll."); |
| thread_ready(t); |
| |
| indev_initialize("sgcnin", &sgcnin, &sgcnin_ops); |
| |
| return &sgcnin; |
| } |
| |
| /** |