| Message ID | 1467370471-20554-2-git-send-email-kraxel@redhat.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
On Fri, Jul 01, 2016 at 12:54:30PM +0200, Gerd Hoffmann wrote: > Signed-off-by: Gerd Hoffmann <kraxel@redhat.com> Thanks. See my comments below. [...] > --- a/src/misc.c > +++ b/src/misc.c > @@ -11,6 +11,7 @@ > #include "output.h" // debug_enter > #include "stacks.h" // call16_int > #include "string.h" // memset > +#include "util.h" // serial_10 > > #define PORT_MATH_CLEAR 0x00f0 > > @@ -57,6 +58,7 @@ handle_10(struct bregs *regs) > { > debug_enter(regs, DEBUG_HDL_10); > // don't do anything, since the VGA BIOS handles int10h requests > + sercon_10(regs); > } Might as well remove handle_10 and call sercon_10 directly from romlayout.S. [...] > --- a/src/serial.c > +++ b/src/serial.c > @@ -315,3 +315,343 @@ handle_17(struct bregs *regs) > default: handle_17XX(regs); break; > } > } > + > +/**************************************************************** > + * serial console output > + ****************************************************************/ I think this code should go in a new c file and not modify serial.c. [...] > +VARLOW u8 sercon_mode; > +VARLOW u8 sercon_cols; > +VARLOW u8 sercon_rows; > + > +VARLOW u8 sercon_row; > +VARLOW u8 sercon_col; I think the code should use the BDA equivalents of the above instead of declaring them in the private VARLOW space. Some old programs may rely on the equivalents in the BDA being updated. > + > +/* > + * We have a small output buffer here, for lazy output. That allows > + * to avoid a whole bunch of control sequences for pointless cursor > + * moves, so when logging the output it'll be *alot* less cluttered. > + * > + * sercon_char/attr is the actual output buffer. > + * sercon_col_lazy is the column of the terminal's cursor, typically > + * a few positions left of sercon_col. > + * sercon_attr_last is the most recent attribute sent to the terminal. > + */ > +VARLOW u8 sercon_attr_last; > +VARLOW u8 sercon_col_lazy; > +VARLOW u8 sercon_char[8]; > +VARLOW u8 sercon_attr[8]; > + > +VARLOW u8 sercon_cmap[8] = { '0', '4', '2', '6', '1', '5', '3', '7' }; For constant data (sercon_cmap) it would be preferable to use "static VAR16" (see kbd.c:scan_to_keycode[] and mouse.c:sample_rates[] as examples) and use GET_GLOBAL() instead of GET_LOW(). [...] > +static void sercon_print_char(u8 chr, u8 attr) > +{ > + if (chr != 0x00) { > + sercon_set_attr(attr); > + sercon_putchar(chr); > + } else { > + /* move cursor right */ > + sercon_putchar('\x1b'); > + sercon_putchar('['); > + sercon_putchar('C'); > + } > +} > + > +static void sercon_flush_lazy(void) > +{ > + u8 count = GET_LOW(sercon_col) - GET_LOW(sercon_col_lazy); > + u8 pos = 0; > + > + if (!count && !GET_LOW(sercon_attr[0])) > + return; > + > + while (count) { > + sercon_print_char(GET_LOW(sercon_char[pos]), > + GET_LOW(sercon_attr[pos])); > + count--; > + pos++; > + } > + > + if (pos < ARRAY_SIZE(sercon_char) && GET_LOW(sercon_char[pos])) { > + sercon_print_char(GET_LOW(sercon_char[pos]), > + GET_LOW(sercon_attr[pos])); > + /* move cursor left */ > + sercon_putchar('\x1b'); > + sercon_putchar('['); > + sercon_putchar('D'); > + } > + > + SET_LOW(sercon_col_lazy, GET_LOW(sercon_col)); > + for (pos = 0; pos < ARRAY_SIZE(sercon_char); pos++) { > + SET_LOW(sercon_attr[pos], 0x07); > + SET_LOW(sercon_char[pos], 0x00); > + } > +} So, if I understand the above correctly, it's a buffer of recent updates used to reduce serial bandwidth (and unclutter serial logs) in the case where the application code issues a bunch of cursor moves / cell updates that are mostly redundant. > +/* Set video mode */ > +static void sercon_1000(struct bregs *regs) > +{ > + SET_LOW(sercon_mode, regs->al); > + switch (regs->al) { > + case 0x03: > + default: > + SET_LOW(sercon_cols, 80); > + SET_LOW(sercon_rows, 25); > + regs->al = 0x30; > + } > + SET_LOW(sercon_row, 0); > + SET_LOW(sercon_col, 0); > + SET_LOW(sercon_col_lazy, 0); > + sercon_init(); > +} FYI, the screen should only be cleared if the high bit of the mode is not set. I do wonder if more of the vgabios interface code from vgasrc/vgabios.c could be reused here. > +/* Set cursor position */ > +static void sercon_1002(struct bregs *regs) > +{ > + u8 row = regs->dh; > + u8 col = regs->dl; > + > + if (row == GET_LOW(sercon_row) && > + col >= GET_LOW(sercon_col_lazy) && > + col < GET_LOW(sercon_col_lazy) + ARRAY_SIZE(sercon_char)) { > + SET_LOW(sercon_col, col); > + if (col+1 == GET_LOW(sercon_col_lazy) + ARRAY_SIZE(sercon_char)) > + sercon_flush_lazy(); > + } else { > + sercon_flush_lazy(); > + if (row == GET_LOW(sercon_row) && col == 0) { > + sercon_putchar('\r'); > + } else { > + sercon_cursor_goto(row, col); > + } > + SET_LOW(sercon_row, row); > + SET_LOW(sercon_col, col); > + SET_LOW(sercon_col_lazy, col); > + } > +} > + > +/* Get cursor position */ > +static void sercon_1003(struct bregs *regs) > +{ > + regs->ax = 0; > + regs->ch = 0; > + regs->cl = 7; > + regs->dh = GET_LOW(sercon_row); > + regs->dl = GET_LOW(sercon_col); > +} > + > +/* Scroll up window */ > +static void sercon_1006(struct bregs *regs) > +{ > + sercon_flush_lazy(); > + sercon_putchar('\r'); > + sercon_putchar('\n'); > +} > + > +/* Read character and attribute at cursor position */ > +static void sercon_1008(struct bregs *regs) > +{ > + regs->ah = 0x07; > + regs->bh = ' '; > +} FYI, the sgabios code seems to indicate that sercon_1008() needs to be implemented for some programs to work properly. The sgabios code even implements a cache of recent writes to try to get it to work. It's ugly. > +/* Write character and attribute at cursor position */ > +static void sercon_1009(struct bregs *regs) > +{ > + u16 count = regs->cx; > + u8 pos; > + > + if (count == 1) { > + pos = GET_LOW(sercon_col) - GET_LOW(sercon_col_lazy); > + if (pos < ARRAY_SIZE(sercon_char)) { > + sercon_char[pos] = regs->al; > + sercon_attr[pos] = regs->bl; > + } > + } else if (regs->al == 0x20 && > + GET_LOW(sercon_rows) * GET_LOW(sercon_cols) == count && > + GET_LOW(sercon_row) == 0 && > + GET_LOW(sercon_col) == 0) { > + /* override everything with spaces -> this is clear screen */ > + sercon_flush_lazy(); > + sercon_putchar('\x1b'); > + sercon_putchar('['); > + sercon_putchar('2'); > + sercon_putchar('J'); > + } else { > + sercon_flush_lazy(); > + sercon_set_attr(regs->bl); > + while (count) { > + sercon_putchar(regs->al); > + count--; > + } > + sercon_cursor_goto(GET_LOW(sercon_row), > + GET_LOW(sercon_col)); > + } > +} > + > +/* Teletype output */ > +static void sercon_100e(struct bregs *regs) > +{ > + u8 pos, row, col; > + > + switch (regs->al) { > + case 7: > + // beep > + break; > + case 8: > + sercon_flush_lazy(); > + sercon_putchar(regs->al); > + col = GET_LOW(sercon_col); > + if (col > 0) { > + col--; > + SET_LOW(sercon_col, col); > + SET_LOW(sercon_col_lazy, col); > + } > + break; > + case '\r': > + sercon_flush_lazy(); > + sercon_putchar(regs->al); > + SET_LOW(sercon_col, 0); > + SET_LOW(sercon_col_lazy, 0); > + break; > + case '\n': > + sercon_flush_lazy(); > + sercon_putchar(regs->al); > + row = GET_LOW(sercon_row); > + row++; > + if (row >= GET_LOW(sercon_rows)) > + row = GET_LOW(sercon_rows)-1; > + SET_LOW(sercon_row, row); > + break; > + default: > + pos = GET_LOW(sercon_col) - GET_LOW(sercon_col_lazy); > + sercon_char[pos] = regs->al; > + SET_LOW(sercon_col, GET_LOW(sercon_col) + 1); > + if (pos+1 == ARRAY_SIZE(sercon_char)) > + sercon_flush_lazy(); > + break; > + } > +} I'm finding it hard to understand how the "uncluttering" works in the above. I think it would be easier to understand if the vgabios interface code was separated from the "uncluttering" code. In particular, I wonder if it would be simpler if the interface code was more similar to vgasrc/vgabios.c and it just translated requests to set_cursor_pos(cursorpos) and write_char(cursorpos, charattr) type calls. Then the write_char() code could check if the position was near previously written characters and buffer it if so - flushing if not. Thus the "uncluttering" could be mostly done in write_char(). The set_cursor_pos() implementation could be very lazy - it only needs to update the BDA with the new position. The sercon_check_event() code could send an explicit cursor move for the case where the cursor is idling at some position not after the last written character. [...] > +void VISIBLE16 > +sercon_10(struct bregs *regs) > +{ > + if (!GET_LOW(sercon_port)) > + return; > + > + switch (regs->ah) { > + case 0x00: sercon_1000(regs); break; > + case 0x02: sercon_1002(regs); break; > + case 0x03: sercon_1003(regs); break; > + case 0x06: sercon_1006(regs); break; > + case 0x08: sercon_1008(regs); break; > + case 0x09: sercon_1009(regs); break; > + case 0x0e: sercon_100e(regs); break; > + case 0x0f: sercon_100f(regs); break; > + case 0x4f: sercon_104f(regs); break; > + default: > + dprintf(1, "%s: ah 0x%02x, not implemented\n", > + __func__, regs->ah); There is a warn_unimplemented(regs) for this. Also, would be nice to implement a sercon_10XX(regs) to match other areas of the code. -Kevin
Hi, > > @@ -57,6 +58,7 @@ handle_10(struct bregs *regs) > > { > > debug_enter(regs, DEBUG_HDL_10); > > // don't do anything, since the VGA BIOS handles int10h requests > > + sercon_10(regs); > > } > > Might as well remove handle_10 and call sercon_10 directly from > romlayout.S. Well, I expect this will change when adding support for parallel output to both vga and serial console. > > +/**************************************************************** > > + * serial console output > > + ****************************************************************/ > > I think this code should go in a new c file and not modify serial.c. Agree. Was thinking about that already as I saw the code grow ;) > [...] > > +VARLOW u8 sercon_mode; > > +VARLOW u8 sercon_cols; > > +VARLOW u8 sercon_rows; > > + > > +VARLOW u8 sercon_row; > > +VARLOW u8 sercon_col; > > I think the code should use the BDA equivalents of the above instead > of declaring them in the private VARLOW space. Some old programs may > rely on the equivalents in the BDA being updated. Figured that meanwhile. syslinux is one example. > > +VARLOW u8 sercon_cmap[8] = { '0', '4', '2', '6', '1', '5', '3', '7' }; > > For constant data (sercon_cmap) it would be preferable to use "static > VAR16" (see kbd.c:scan_to_keycode[] and mouse.c:sample_rates[] as > examples) and use GET_GLOBAL() instead of GET_LOW(). OK. > > + SET_LOW(sercon_col_lazy, GET_LOW(sercon_col)); > > + for (pos = 0; pos < ARRAY_SIZE(sercon_char); pos++) { > > + SET_LOW(sercon_attr[pos], 0x07); > > + SET_LOW(sercon_char[pos], 0x00); > > + } > > +} > > So, if I understand the above correctly, it's a buffer of recent > updates used to reduce serial bandwidth (and unclutter serial logs) in > the case where the application code issues a bunch of cursor moves / > cell updates that are mostly redundant. Yep. Typically happens for colored output. Apps use int10/09 to set character and attribute at the cursor position (but without moving the cursor). Then they move the cursor either using int10/02 (explicit set cursor position) or by printing the same character again using int10/0e (teletype, which prints character without updating attribute and moves the cursor forward). > > +/* Read character and attribute at cursor position */ > > +static void sercon_1008(struct bregs *regs) > > +{ > > + regs->ah = 0x07; > > + regs->bh = ' '; > > +} > > FYI, the sgabios code seems to indicate that sercon_1008() needs to be > implemented for some programs to work properly. The sgabios code even > implements a cache of recent writes to try to get it to work. It's > ugly. Didn't run into any issues yet, but also tested linux bootloaders only. Maybe we can reuse the output buffer which we have anyway. Logic needs reworked a bit. We can't just clear characters after printing them out if we want be able to read them later, so we need a separate pending-updates bit. Also should be bigger I guess, maybe 80 chars so it can cover a complete line. > I'm finding it hard to understand how the "uncluttering" works in the > above. I think it would be easier to understand if the vgabios > interface code was separated from the "uncluttering" code. > > In particular, I wonder if it would be simpler if the interface code > was more similar to vgasrc/vgabios.c and it just translated requests > to set_cursor_pos(cursorpos) and write_char(cursorpos, charattr) type > calls. Then the write_char() code could check if the position was > near previously written characters and buffer it if so - flushing if > not. Thus the "uncluttering" could be mostly done in write_char(). > The set_cursor_pos() implementation could be very lazy - it only needs > to update the BDA with the new position. The sercon_check_event() > code could send an explicit cursor move for the case where the cursor > is idling at some position not after the last written character. I'll have a look. > > + default: > > + dprintf(1, "%s: ah 0x%02x, not implemented\n", > > + __func__, regs->ah); > > There is a warn_unimplemented(regs) for this. Also, would be nice to > implement a sercon_10XX(regs) to match other areas of the code. Ok. cheers, Gerd
On 04/07/2016 10:16, Gerd Hoffmann wrote: > > + sercon_putchar('\x1b'); > + sercon_putchar('c'); > + /* clear screen */ > + sercon_putchar('\x1b'); > + sercon_putchar('['); > + sercon_putchar('2'); > + sercon_putchar('J'); > +} > + > +static void sercon_set_color(u8 fg, u8 bg, u8 bold) > +{ > + sercon_putchar('\x1b'); > + sercon_putchar('['); > + sercon_putchar('0'); > + if (fg != 7) { > + sercon_putchar(';'); > + sercon_putchar('3'); > + sercon_putchar(GET_LOW(sercon_cmap[fg & 7])); > + } > + if (bg != 0) { > + sercon_putchar(';'); > + sercon_putchar('4'); > + sercon_putchar(GET_LOW(sercon_cmap[bg & 7])); > + } > + if (bold) { > + sercon_putchar(';'); > + sercon_putchar('1'); > + } > + sercon_putchar('m'); Add a sercon_putstr perhaps? >>> +/* Read character and attribute at cursor position */ >>> > > +static void sercon_1008(struct bregs *regs) >>> > > +{ >>> > > + regs->ah = 0x07; >>> > > + regs->bh = ' '; >>> > > +} >> > >> > FYI, the sgabios code seems to indicate that sercon_1008() needs to be >> > implemented for some programs to work properly. The sgabios code even >> > implements a cache of recent writes to try to get it to work. It's >> > ugly. > Didn't run into any issues yet, but also tested linux bootloaders only. > > Maybe we can reuse the output buffer which we have anyway. Logic needs > reworked a bit. We can't just clear characters after printing them out > if we want be able to read them later, so we need a separate > pending-updates bit. Also should be bigger I guess, maybe 80 chars so > it can cover a complete line. 80x25 is just 2K... Perhaps it's simpler to just allocate the whole video buffer from the UMB or EBDA when serial console is in use? (GWBASIC in graphics modes, for one, uses 10/08 from the whole screen. I don't know if it does that in text modes too). Paolo
On Mo, 2016-07-04 at 11:11 +0200, Paolo Bonzini wrote: > > On 04/07/2016 10:16, Gerd Hoffmann wrote: > > > > + sercon_putchar('\x1b'); > > + sercon_putchar('c'); > > + /* clear screen */ > > + sercon_putchar('\x1b'); > > + sercon_putchar('['); > > + sercon_putchar('2'); > > + sercon_putchar('J'); > > +} > > + > > +static void sercon_set_color(u8 fg, u8 bg, u8 bold) > > +{ > > + sercon_putchar('\x1b'); > > + sercon_putchar('['); > > + sercon_putchar('0'); > > + if (fg != 7) { > > + sercon_putchar(';'); > > + sercon_putchar('3'); > > + sercon_putchar(GET_LOW(sercon_cmap[fg & 7])); > > + } > > + if (bg != 0) { > > + sercon_putchar(';'); > > + sercon_putchar('4'); > > + sercon_putchar(GET_LOW(sercon_cmap[bg & 7])); > > + } > > + if (bold) { > > + sercon_putchar(';'); > > + sercon_putchar('1'); > > + } > > + sercon_putchar('m'); > > Add a sercon_putstr perhaps? We run in real mode, so passing around pointers isn't that easy. Given this would make sense for constant strings only (like the 4-byte clear-screen sequence) and not so much for variable stuff we might put all strings in the global segment. Would this ... void sercon_putchar(char *ptr) { char c = GET_GLOBAL(ptr[0]); [ ... ] ... work? > > Maybe we can reuse the output buffer which we have anyway. Logic needs > > reworked a bit. We can't just clear characters after printing them out > > if we want be able to read them later, so we need a separate > > pending-updates bit. Also should be bigger I guess, maybe 80 chars so > > it can cover a complete line. > > 80x25 is just 2K... Perhaps it's simpler to just allocate the whole > video buffer from the UMB or EBDA when serial console is in use? 4k, we need both character and attribute. But, yes, if we can allocate that somewhere in real mode address space without running into memory pressure this might be the best option. cheers, Gerd
On 04/07/2016 14:46, Gerd Hoffmann wrote: > We run in real mode, so passing around pointers isn't that easy. > Given this would make sense for constant strings only (like the 4-byte > clear-screen sequence) and not so much for variable stuff we might put > all strings in the global segment. Hmm you're right, pointers are messy here. Paolo > > Would this ... > > void sercon_putchar(char *ptr) > { > char c = GET_GLOBAL(ptr[0]); > [ ... ] > > ... work? >
On Mon, Jul 04, 2016 at 02:46:24PM +0200, Gerd Hoffmann wrote: > On Mo, 2016-07-04 at 11:11 +0200, Paolo Bonzini wrote: > > On 04/07/2016 10:16, Gerd Hoffmann wrote: > > > +static void sercon_set_color(u8 fg, u8 bg, u8 bold) > > > +{ > > > + sercon_putchar('\x1b'); > > > + sercon_putchar('['); > > > + sercon_putchar('0'); > > Add a sercon_putstr perhaps? > > We run in real mode, so passing around pointers isn't that easy. > Given this would make sense for constant strings only (like the 4-byte > clear-screen sequence) and not so much for variable stuff we might put > all strings in the global segment. > > Would this ... > > void sercon_putchar(char *ptr) > { > char c = GET_GLOBAL(ptr[0]); > [ ... ] > > ... work? Yes. See output.c:puts_cs() as an example. It only works if it's a constant string (as opposed to a string built on the stack). > > > Maybe we can reuse the output buffer which we have anyway. Logic needs > > > reworked a bit. We can't just clear characters after printing them out > > > if we want be able to read them later, so we need a separate > > > pending-updates bit. Also should be bigger I guess, maybe 80 chars so > > > it can cover a complete line. > > > > 80x25 is just 2K... Perhaps it's simpler to just allocate the whole > > video buffer from the UMB or EBDA when serial console is in use? > > 4k, we need both character and attribute. But, yes, if we can allocate > that somewhere in real mode address space without running into memory > pressure this might be the best option. Unfortunately, the screen can be larger than 80x25. If a large buffer is desired, it's also possible to malloc_high() it and then use either: call32() to access it, or int1587 to read/write it (see ramdisk.c:ramdisk_copy() as an example). Either way it seems ugly. At one point I looked through the sgabios code and was able to understand how it did caching. I'll take another look and see if I can describe it. -Kevin
On 04/07/2016 17:26, Kevin O'Connor wrote: > > 4k, we need both character and attribute. But, yes, if we can allocate > > that somewhere in real mode address space without running into memory > > pressure this might be the best option. > > Unfortunately, the screen can be larger than 80x25. It can with SVGA BIOS, but Gerd here only supports mode 3, doesn't he? Paolo > If a large buffer is desired, it's also possible to malloc_high() it > and then use either: call32() to access it, or int1587 to read/write > it (see ramdisk.c:ramdisk_copy() as an example). Either way it seems > ugly. > > At one point I looked through the sgabios code and was able to > understand how it did caching. I'll take another look and see if I > can describe it.
On Mon, Jul 04, 2016 at 11:26:48AM -0400, Kevin O'Connor wrote: > At one point I looked through the sgabios code and was able to > understand how it did caching. I'll take another look and see if I > can describe it. So, if I read the sgabios code correctly, it allocates a buffer of: struct { u8 x, y; char c; } logbuf[256]; int logbuf_offset; Every character sent on the serial port is appended to "logbuf" in order, wrapping if necessary: logbuf[logbuf_offset++ % 256] = x, y, c. On a read, it scans backwards from logbuf_offset to find the last update to that cell. Interestingly, it doesn't store the attribute with the character - it's int1008 handler just returns the last attribute used anywhere on the screen. The code is only used if it is the sole vga code (as opposed to being used in addition to an existing vgabios). Does anyone know where one can find the original svn commit history for sgabios? Seems the original google code repo is no longer present. -Kevin
On 04/07/2016 18:00, Kevin O'Connor wrote: > So, if I read the sgabios code correctly, it allocates a buffer of: > > struct { u8 x, y; char c; } logbuf[256]; > int logbuf_offset; > > Every character sent on the serial port is appended to "logbuf" in > order, wrapping if necessary: logbuf[logbuf_offset++ % 256] = x, y, c. > On a read, it scans backwards from logbuf_offset to find the last > update to that cell. > > Interestingly, it doesn't store the attribute with the character - > it's int1008 handler just returns the last attribute used anywhere on > the screen. > > The code is only used if it is the sole vga code (as opposed to being > used in addition to an existing vgabios). > > Does anyone know where one can find the original svn commit history > for sgabios? Seems the original google code repo is no longer > present. There was no history as far as I remember, mostly a code drop. Paolo
On Mon, Jul 04, 2016 at 06:03:30PM +0200, Paolo Bonzini wrote: > On 04/07/2016 18:00, Kevin O'Connor wrote: > > Does anyone know where one can find the original svn commit history > > for sgabios? Seems the original google code repo is no longer > > present. > > There was no history as far as I remember, mostly a code drop. Ah, right. I found what I was looking for though - it was in the sgabios design.txt file instead of the revision history: Summary of new enhancements --------------------------- SGABIOS now keeps a log of the last 256 characters written to the screen and where they were written in the event an application like lilo asks for the current character under the cursor. These are currently stored in a 1KB EBDA allocation which can be expanded as needed. This method avoids having to store a 64KB buffer for the largest possible serial terminal supported (255x255). So, if I read the above correctly, it was lilo that inspired the "feature". Anyway, something to keep in mind. BTW, lots of good info in the rest of design.txt. Cheers, -Kevin
Hi, > > Unfortunately, the screen can be larger than 80x25. > > It can with SVGA BIOS, but Gerd here only supports mode 3, doesn't he? Current code yes, but that doesn't imply it'll stay that way forever. Supporting other sizes is just a matter of making sercon_1000() recognizing the mode numbers and set cols+rows accordingly. cheers, Gerd
Hi, > I found what I was looking for though - it was in the sgabios > design.txt file instead of the revision history: > So, if I read the above correctly, it was lilo that inspired the > "feature". Anyway, something to keep in mind. Oh. lilo. Interesting. I didn't expect http://www.qemu-advent-calendar.org/#day-1 becomes a useful testcase some day ;) > BTW, lots of good info in the rest of design.txt. Guess I should have a closer look at it. thanks for the pointer, Gerd
Hi, > > void sercon_putchar(char *ptr) > > { > > char c = GET_GLOBAL(ptr[0]); > > [ ... ] > > > > ... work? > > Yes. See output.c:puts_cs() as an example. It only works if it's a > constant string (as opposed to a string built on the stack). After cleaning up the code only three fixed sequences are left: reset, clear screen and move cursor right. Don't think it is worth creating a putstring function just for these. cheers, Gerd
diff --git a/src/misc.c b/src/misc.c index f02237c..f4b656d 100644 --- a/src/misc.c +++ b/src/misc.c @@ -11,6 +11,7 @@ #include "output.h" // debug_enter #include "stacks.h" // call16_int #include "string.h" // memset +#include "util.h" // serial_10 #define PORT_MATH_CLEAR 0x00f0 @@ -57,6 +58,7 @@ handle_10(struct bregs *regs) { debug_enter(regs, DEBUG_HDL_10); // don't do anything, since the VGA BIOS handles int10h requests + sercon_10(regs); } // NMI handler diff --git a/src/optionroms.c b/src/optionroms.c index 65f7fe0..e6b308c 100644 --- a/src/optionroms.c +++ b/src/optionroms.c @@ -432,9 +432,11 @@ vgarom_setup(void) run_file_roms("vgaroms/", 1, NULL); rom_reserve(0); - if (rom_get_last() == BUILD_ROM_START) + if (rom_get_last() == BUILD_ROM_START) { // No VGA rom found + sercon_enable(); return; + } VgaROM = (void*)BUILD_ROM_START; enable_vga_console(); diff --git a/src/serial.c b/src/serial.c index 88349c8..74b91bb 100644 --- a/src/serial.c +++ b/src/serial.c @@ -315,3 +315,343 @@ handle_17(struct bregs *regs) default: handle_17XX(regs); break; } } + +/**************************************************************** + * serial console output + ****************************************************************/ + +VARLOW u16 sercon_port; +VARLOW u8 sercon_mode; +VARLOW u8 sercon_cols; +VARLOW u8 sercon_rows; + +VARLOW u8 sercon_row; +VARLOW u8 sercon_col; + +/* + * We have a small output buffer here, for lazy output. That allows + * to avoid a whole bunch of control sequences for pointless cursor + * moves, so when logging the output it'll be *alot* less cluttered. + * + * sercon_char/attr is the actual output buffer. + * sercon_col_lazy is the column of the terminal's cursor, typically + * a few positions left of sercon_col. + * sercon_attr_last is the most recent attribute sent to the terminal. + */ +VARLOW u8 sercon_attr_last; +VARLOW u8 sercon_col_lazy; +VARLOW u8 sercon_char[8]; +VARLOW u8 sercon_attr[8]; + +VARLOW u8 sercon_cmap[8] = { '0', '4', '2', '6', '1', '5', '3', '7' }; + +static void sercon_putchar(u8 chr) +{ + u16 addr = GET_LOW(sercon_port); + u32 end = irqtimer_calc_ticks(0x0a); + + for (;;) { + u8 lsr = inb(addr+SEROFF_LSR); + if ((lsr & 0x60) == 0x60) { + // Success - can write data + outb(chr, addr+SEROFF_DATA); + break; + } + if (irqtimer_check(end)) { + break; + } + yield(); + } +} + +static void sercon_init(void) +{ + /* reset */ + sercon_putchar('\x1b'); + sercon_putchar('c'); + /* clear screen */ + sercon_putchar('\x1b'); + sercon_putchar('['); + sercon_putchar('2'); + sercon_putchar('J'); +} + +static void sercon_set_color(u8 fg, u8 bg, u8 bold) +{ + sercon_putchar('\x1b'); + sercon_putchar('['); + sercon_putchar('0'); + if (fg != 7) { + sercon_putchar(';'); + sercon_putchar('3'); + sercon_putchar(GET_LOW(sercon_cmap[fg & 7])); + } + if (bg != 0) { + sercon_putchar(';'); + sercon_putchar('4'); + sercon_putchar(GET_LOW(sercon_cmap[bg & 7])); + } + if (bold) { + sercon_putchar(';'); + sercon_putchar('1'); + } + sercon_putchar('m'); +} + +static void sercon_set_attr(u8 attr) +{ + if (attr == GET_LOW(sercon_attr_last)) + return; + + SET_LOW(sercon_attr_last, attr); + sercon_set_color((attr >> 0) & 7, + (attr >> 4) & 7, + attr & 0x08); +} + +static void sercon_cursor_goto(u8 row, u8 col) +{ + row++; col++; + sercon_putchar('\x1b'); + sercon_putchar('['); + sercon_putchar('0' + row / 10); + sercon_putchar('0' + row % 10); + sercon_putchar(';'); + sercon_putchar('0' + col / 10); + sercon_putchar('0' + col % 10); + sercon_putchar('H'); +} + +static void sercon_print_char(u8 chr, u8 attr) +{ + if (chr != 0x00) { + sercon_set_attr(attr); + sercon_putchar(chr); + } else { + /* move cursor right */ + sercon_putchar('\x1b'); + sercon_putchar('['); + sercon_putchar('C'); + } +} + +static void sercon_flush_lazy(void) +{ + u8 count = GET_LOW(sercon_col) - GET_LOW(sercon_col_lazy); + u8 pos = 0; + + if (!count && !GET_LOW(sercon_attr[0])) + return; + + while (count) { + sercon_print_char(GET_LOW(sercon_char[pos]), + GET_LOW(sercon_attr[pos])); + count--; + pos++; + } + + if (pos < ARRAY_SIZE(sercon_char) && GET_LOW(sercon_char[pos])) { + sercon_print_char(GET_LOW(sercon_char[pos]), + GET_LOW(sercon_attr[pos])); + /* move cursor left */ + sercon_putchar('\x1b'); + sercon_putchar('['); + sercon_putchar('D'); + } + + SET_LOW(sercon_col_lazy, GET_LOW(sercon_col)); + for (pos = 0; pos < ARRAY_SIZE(sercon_char); pos++) { + SET_LOW(sercon_attr[pos], 0x07); + SET_LOW(sercon_char[pos], 0x00); + } +} + +/* Set video mode */ +static void sercon_1000(struct bregs *regs) +{ + SET_LOW(sercon_mode, regs->al); + switch (regs->al) { + case 0x03: + default: + SET_LOW(sercon_cols, 80); + SET_LOW(sercon_rows, 25); + regs->al = 0x30; + } + SET_LOW(sercon_row, 0); + SET_LOW(sercon_col, 0); + SET_LOW(sercon_col_lazy, 0); + sercon_init(); +} + +/* Set cursor position */ +static void sercon_1002(struct bregs *regs) +{ + u8 row = regs->dh; + u8 col = regs->dl; + + if (row == GET_LOW(sercon_row) && + col >= GET_LOW(sercon_col_lazy) && + col < GET_LOW(sercon_col_lazy) + ARRAY_SIZE(sercon_char)) { + SET_LOW(sercon_col, col); + if (col+1 == GET_LOW(sercon_col_lazy) + ARRAY_SIZE(sercon_char)) + sercon_flush_lazy(); + } else { + sercon_flush_lazy(); + if (row == GET_LOW(sercon_row) && col == 0) { + sercon_putchar('\r'); + } else { + sercon_cursor_goto(row, col); + } + SET_LOW(sercon_row, row); + SET_LOW(sercon_col, col); + SET_LOW(sercon_col_lazy, col); + } +} + +/* Get cursor position */ +static void sercon_1003(struct bregs *regs) +{ + regs->ax = 0; + regs->ch = 0; + regs->cl = 7; + regs->dh = GET_LOW(sercon_row); + regs->dl = GET_LOW(sercon_col); +} + +/* Scroll up window */ +static void sercon_1006(struct bregs *regs) +{ + sercon_flush_lazy(); + sercon_putchar('\r'); + sercon_putchar('\n'); +} + +/* Read character and attribute at cursor position */ +static void sercon_1008(struct bregs *regs) +{ + regs->ah = 0x07; + regs->bh = ' '; +} + +/* Write character and attribute at cursor position */ +static void sercon_1009(struct bregs *regs) +{ + u16 count = regs->cx; + u8 pos; + + if (count == 1) { + pos = GET_LOW(sercon_col) - GET_LOW(sercon_col_lazy); + if (pos < ARRAY_SIZE(sercon_char)) { + sercon_char[pos] = regs->al; + sercon_attr[pos] = regs->bl; + } + } else if (regs->al == 0x20 && + GET_LOW(sercon_rows) * GET_LOW(sercon_cols) == count && + GET_LOW(sercon_row) == 0 && + GET_LOW(sercon_col) == 0) { + /* override everything with spaces -> this is clear screen */ + sercon_flush_lazy(); + sercon_putchar('\x1b'); + sercon_putchar('['); + sercon_putchar('2'); + sercon_putchar('J'); + } else { + sercon_flush_lazy(); + sercon_set_attr(regs->bl); + while (count) { + sercon_putchar(regs->al); + count--; + } + sercon_cursor_goto(GET_LOW(sercon_row), + GET_LOW(sercon_col)); + } +} + +/* Teletype output */ +static void sercon_100e(struct bregs *regs) +{ + u8 pos, row, col; + + switch (regs->al) { + case 7: + // beep + break; + case 8: + sercon_flush_lazy(); + sercon_putchar(regs->al); + col = GET_LOW(sercon_col); + if (col > 0) { + col--; + SET_LOW(sercon_col, col); + SET_LOW(sercon_col_lazy, col); + } + break; + case '\r': + sercon_flush_lazy(); + sercon_putchar(regs->al); + SET_LOW(sercon_col, 0); + SET_LOW(sercon_col_lazy, 0); + break; + case '\n': + sercon_flush_lazy(); + sercon_putchar(regs->al); + row = GET_LOW(sercon_row); + row++; + if (row >= GET_LOW(sercon_rows)) + row = GET_LOW(sercon_rows)-1; + SET_LOW(sercon_row, row); + break; + default: + pos = GET_LOW(sercon_col) - GET_LOW(sercon_col_lazy); + sercon_char[pos] = regs->al; + SET_LOW(sercon_col, GET_LOW(sercon_col) + 1); + if (pos+1 == ARRAY_SIZE(sercon_char)) + sercon_flush_lazy(); + break; + } +} + +/* Get current video mode */ +static void sercon_100f(struct bregs *regs) +{ + regs->al = GET_LOW(sercon_mode); + regs->ah = GET_LOW(sercon_cols); +} + +/* VBE 2.0 */ +static void sercon_104f(struct bregs *regs) +{ + regs->ax = 0x0100; +} + +void VISIBLE16 +sercon_10(struct bregs *regs) +{ + if (!GET_LOW(sercon_port)) + return; + + switch (regs->ah) { + case 0x00: sercon_1000(regs); break; + case 0x02: sercon_1002(regs); break; + case 0x03: sercon_1003(regs); break; + case 0x06: sercon_1006(regs); break; + case 0x08: sercon_1008(regs); break; + case 0x09: sercon_1009(regs); break; + case 0x0e: sercon_100e(regs); break; + case 0x0f: sercon_100f(regs); break; + case 0x4f: sercon_104f(regs); break; + default: + dprintf(1, "%s: ah 0x%02x, not implemented\n", + __func__, regs->ah); + } +} + +void sercon_enable(void) +{ + u16 addr = PORT_SERIAL1; + + SET_LOW(sercon_port, addr); + outb(0x03, addr + SEROFF_LCR); // 8N1 + outb(0x01, addr + 0x02); // enable fifo + enable_vga_console(); +} diff --git a/src/util.h b/src/util.h index 7b41207..29f17be 100644 --- a/src/util.h +++ b/src/util.h @@ -230,6 +230,8 @@ void code_mutable_preinit(void); // serial.c void serial_setup(void); void lpt_setup(void); +void sercon_10(struct bregs *regs); +void sercon_enable(void); // vgahooks.c void handle_155f(struct bregs *regs);
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com> --- src/misc.c | 2 + src/optionroms.c | 4 +- src/serial.c | 340 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/util.h | 2 + 4 files changed, 347 insertions(+), 1 deletion(-)