| /kernel/trunk/generic/include/console/chardev.h |
|---|
| 41,6 → 41,8 |
| void (* suspend)(chardev_t *); /**< Suspend pushing characters. */ |
| void (* resume)(chardev_t *); /**< Resume pushing characters. */ |
| void (* write)(chardev_t *, char c); /**< Write character to stream. */ |
| /** Read character directly from device, assume interrupts disabled */ |
| char (* read)(chardev_t *); |
| }; |
| typedef struct chardev_operations chardev_operations_t; |
| /kernel/trunk/generic/src/console/console.c |
|---|
| 34,6 → 34,8 |
| #include <arch/types.h> |
| #include <typedefs.h> |
| #include <arch.h> |
| #include <func.h> |
| #include <print.h> |
| /** Standard input character device. */ |
| chardev_t *stdin = NULL; |
| 50,6 → 52,18 |
| __u8 ch; |
| ipl_t ipl; |
| if (haltstate) { |
| /* If we are here, we are hopefully on the processor, that |
| * issued the 'halt' command, so proceed to read the character |
| * directly from input |
| */ |
| if (chardev->op->read) |
| return chardev->op->read(chardev); |
| /* no other way of interacting with user, halt */ |
| printf("cpu: halted - no kconsole\n"); |
| cpu_halt(); |
| } |
| waitq_sleep(&chardev->wq); |
| ipl = interrupts_disable(); |
| spinlock_lock(&chardev->lock); |
| 114,5 → 128,6 |
| void putchar(char c) |
| { |
| stdout->op->write(stdout, c); |
| if (stdout->op->write) |
| stdout->op->write(stdout, c); |
| } |
| /kernel/trunk/generic/src/console/kconsole.c |
|---|
| 247,7 → 247,7 |
| if (c == '\n') { |
| putchar(c); |
| break; |
| } if (c == '\b') { |
| } if (c == '\b') { /* Backspace */ |
| if (position == 0) |
| continue; |
| for (i=position; i<curlen;i++) |
| 261,7 → 261,7 |
| rdln_print_c('\b',curlen-position+1); |
| continue; |
| } |
| if (c == '\t') { |
| if (c == '\t') { /* Tabulator */ |
| int found; |
| /* Move to the end of the word */ |
| 309,7 → 309,7 |
| rdln_print_c('\b', curlen-position); |
| continue; |
| } |
| if (c == 0x1b) { |
| if (c == 0x1b) { /* Special command */ |
| mod = _getc(input); |
| c = _getc(input); |
| 317,6 → 317,7 |
| continue; |
| if (c == 0x33 && _getc(input) == 0x7e) { |
| /* Delete */ |
| if (position == curlen) |
| continue; |
| for (i=position+1; i<curlen;i++) { |
| 331,7 → 332,7 |
| rdln_print_c('\b',position); |
| position = 0; |
| } |
| else if (c == 0x46) { |
| else if (c == 0x46) { /* End */ |
| for (i=position;i<curlen;i++) |
| putchar(current[i]); |
| position = curlen; |
| 355,7 → 356,7 |
| rdln_print_c('\b',position); |
| rdln_print_c(' ',curlen); |
| rdln_print_c('\b',curlen); |
| if (c == 0x41) |
| if (c == 0x41) /* Up */ |
| histposition--; |
| else |
| histposition++; |
| /kernel/trunk/generic/src/lib/func.c |
|---|
| 32,6 → 32,7 |
| #include <arch/asm.h> |
| #include <arch.h> |
| #include <typedefs.h> |
| #include <console/kconsole.h> |
| __u32 haltstate = 0; /**< Halt flag */ |
| 45,6 → 46,11 |
| { |
| haltstate = 1; |
| interrupts_disable(); |
| #ifdef CONFIG_DEBUG |
| printf("\n"); |
| kconsole(NULL); /* Run kconsole as a last resort to user */ |
| #endif |
| if (CPU) |
| printf("cpu%d: halted\n", CPU->id); |
| else |
| /kernel/trunk/arch/mips32/src/panic.S |
|---|
| 38,6 → 38,11 |
| /* From printf return directly to halt() */ |
| panic_printf: |
| lui $ra, %hi(halt) |
| jal printf |
| nop |
| j halt |
| nop |
| /* This code does not work, god knows why */ |
| /* lui $ra, %hi(halt) |
| j printf |
| ori $ra, %lo(halt) |
| ori $ra, %lo(halt) */ |
| /kernel/trunk/arch/mips32/src/drivers/serial.c |
|---|
| 71,12 → 71,22 |
| return i; |
| } |
| static chardev_operations_t serial_ops = { |
| .resume = serial_enable, |
| .suspend = serial_disable, |
| .write = serial_write |
| }; |
| /** Read character from serial port, wait until available */ |
| static char serial_do_read(chardev_t *dev) |
| { |
| serial_t *sd = (serial_t *)dev->data; |
| char ch; |
| while (!(SERIAL_READ_LSR(sd->port) & 1)) |
| ; |
| ch = SERIAL_READ(sd->port); |
| if (ch =='\r') |
| ch = '\n'; |
| return ch; |
| } |
| /** Process keyboard interrupt. Does not work in simics? */ |
| static void serial_interrupt(int n, void *stack) |
| { |
| 93,6 → 103,14 |
| } |
| static chardev_operations_t serial_ops = { |
| .resume = serial_enable, |
| .suspend = serial_disable, |
| .write = serial_write, |
| .read = serial_do_read |
| }; |
| iroutine old_timer; |
| /** Do polling on timer interrupt */ |
| static void timer_replace(int n, void *stack) |
| /kernel/trunk/arch/mips32/src/drivers/msim.c |
|---|
| 37,11 → 37,13 |
| static void msim_write(chardev_t *dev, const char ch); |
| static void msim_enable(chardev_t *dev); |
| static void msim_disable(chardev_t *dev); |
| static char msim_do_read(chardev_t *dev); |
| static chardev_operations_t msim_ops = { |
| .resume = msim_enable, |
| .suspend = msim_disable, |
| .write = msim_write |
| .write = msim_write, |
| .read = msim_do_read, |
| }; |
| /** Putchar that works with MSIM & gxemul */ |
| 63,10 → 65,27 |
| } |
| #include <print.h> |
| /** Read character using polling, assume interrupts disabled */ |
| static char msim_do_read(chardev_t *dev) |
| { |
| char ch; |
| while (1) { |
| ch = *((volatile char *) MSIM_KBD_ADDRESS); |
| if (ch) { |
| if (ch == '\r') |
| return '\n'; |
| if (ch == 0x7f) |
| return '\b'; |
| return ch; |
| } |
| } |
| } |
| /** Process keyboard interrupt. */ |
| static void msim_interrupt(int n, void *stack) |
| { |
| char ch; |
| char ch = 0; |
| ch = *((char *) MSIM_KBD_ADDRESS); |
| if (ch =='\r') |