Code to install the new E820 mangler (which doesn't require copying
down to base memory, since it is now in the base-memory-resident
.text16 section).

Add __{text,data}16_array, since there's no way I can see to make the
usual __{text,data}16 trick work with arrays.  gcc seems to accept the
__asm__ ( asmlabel ) only after the [] of the array declaration, not
before.

Cope with regions bigger than 4GB.

We now split e820 regions around ourselves, rather than just
truncating the e820 region.  This avoids the worst-case scenario of
losing all memory over 4GB.

It's more important to get the memory map right now that we're
expecting to still be loaded when the OS starts in several situations
(e.g. Linux with UNDI driver, any OS with iSCSI/AoE boot, etc.).

- implemented printw (formatted string output, a la printf)
- implemented hline/vline (part of wborder family)
- screen cursor now relocates at same time as window cursor when
  restoring after a non-wrapping function

Allow vcprintf() to be called by external code such as the curses library.

Also trim another eight bytes from vsprintf.o.  :)

- fixes to _wputch to get positioning and wrap working properly
- fixes to wborder (same)
- addition of a few minor functions

Fixed debug code

Made the LBA48 example clearer.

Added (untested) support for ATA devices.  This code should be generic
enough to support both real IDE chipsets and AoE.

Refactored to reduce code size; now down from 1304 to 1105 bytes.

Tidied up debug messages; the log now contains one line per INT 13
operation, looking like

 INT 13,08 (80): Get drive parameters
 INT 13,02 (80): Read: C/H/S 0/47/14 = LBA 0xb9e <-> 1084:0000 (count 106)

Added missing @file block

Use insb/outsb; it's marginally faster.

READ CAPACITY (16) turns out to be an optional command (even though
READ(16) is mandatory); we must use READ CAPACITY (10) first and then
use READ CAPACITY (16) if the READ CAPACITY (10) returns "out of range".

Add EOVERFLOW==ERANGE

Expert advice tells me that we *do* have to explicitly state the
options even when we want to use the defaults.

- made some of the bit shifting attribute access simpler (in my mind)
- added extern declarations for global vars
- removed comments from static inlines (too time consuming to do them
  all, considering all so far have been due to the ridiculous amount of
  redundancy within the API spec)
- removed a few more extern func decls for funcs that cannot be
  implemented at this time

- made _wputch wrap lines as well as cols (wraps back to line 0, as we have not way to scroll...)
- implemented color_content, wborder, wblrtobot, wclrtoeol, wcolor_set and several small functions
- added rest of expected global variables

Add the concept of a "user pointer" (similar to the void __user * in
the kernel), which encapsulates the information needed to refer to an
external buffer.  Under normal operation, this can just be a void *
equivalent, but under -DKEEP_IT_REAL it would be a segoff_t equivalent.

Use this concept to avoid the need for bounce buffers in int13.c,
which reduces memory usage and opens up the possibility of using
multi-sector reads.

Extend the block-device API and the SCSI block device implementation
to support multi-sector reads.

Update iscsi.c to use user buffers.

Move the obsolete portions of realmode.h to old_realmode.h.

MS-DOS now boots an order of magnitude faster over iSCSI (~10 seconds
from power-up to C:> prompt in bochs).

Use typeof(sizeof(...)) to define a size_t.  This stops gcc complaining
about format errors for %zX arguments.

Documented login parameters that we negotiate.

iSCSI writes seem to be working (at least, the ethereal trace shows no
errors; still need to verify data integrity).

SCSI response PDUs are handled: status and sense data (if available) are
returned via the scsi_command structure.

Updated iSCSI session parameter usage.

All uses iscsi_state were removed some time ago; removing the
declaration.

Re-enable -Wformat, since our printf() is now more standards-conformant.

all window primitives implemented

Updated to new SourceForge CVS locations, and fix a couple of minor
mistakes.

Set ErrorRecoveryLevel=0 (we don't want to have to handle it).

Added missing drivers/scsi

Split debug functions out into core/debug.c, so that they can be
automatically linked in on demand.

Corrected warnings in misc.c.  strtoul() really should be
  unsigned long strtoul ( const char *p, const char **endp, int base )
but such is not the ANSI standard.

Strip down i386 PCI configuration space I/O to the bare minimum.  A
typical build will now include 880 bytes of PCI support code, compared to
2327 bytes in Etherboot 5.4.

(There is a slight cost of around 5 extra bytes per access to a
non-constant config space address; this should be an overall win.
Driver-specific accesses will usually be to constant addresses, for
which there is no additional cost.)

Restructured PCI subsystem to fit the new device model.

Generic PCI code now handles 64-bit BARs correctly when setting
"membase"; drivers should need to call pci_bar_start() only if they want
to use BARs other than the first memory or I/O BAR.

Split rarely-used PCI functions out into pciextra.c.

Core PCI code is now 662 bytes (down from 1308 bytes in Etherboot 5.4).
284 bytes of this saving comes from the pci/pciextra split.

Cosmetic changes to lots of drivers (e.g. vendor_id->vendor in order to
match the names used in Linux).

Missed a reference to heap.h.

Tear out old heap code, replace with code that simply allocates memory
for use by malloc().

This breaks the image-loading code (which previously used the heap to
allocate the buffer for downloading the image), but that's not a major
concern since I'm going to tear out all the image formats within the next
couple of days anyway.  Byebye, NBI!  :)

Fix typo

Kill off the "all devices are boot devices" idea

Add list_for_each_entry_safe.

Added generic device model.

Change movetoyx(), putc() and getc() to methods of the screen.

fixed build error (danjlynch, repeat: this is *not* perl, this is *not* perl...)

lightweight xcurses implementation for etherboot (Michael made me do it...)

Add INT 13,41 (extensions installation check).  LILO's MBR now uses
linear calls to load the MS-DOS boot sector in my test setup.

Split "iSCSI as a SCSI device" out from "iSCSI as a TCP protocol".

Fix a couple of minor typos.

Also capture INT 19 as a failure path, to allow for boot sectors that
don't conform to BBS (e.g. the one created by mkdosfs).

Add int13_boot(), to allow booting from INT 13 emulated drives.

Specify attributes on .text16.

Handle the '"%c", 0' case correctly.

Correctly handle zero-length buffers.

Updated documentation.

Shaved around 100 bytes off vsprintf.o.  It's now 50 bytes smaller than
the old implementation and provides much more conformant semantics,
including the ability to return the number of characters that would have
been printed to the string had the buffer been big enough.  (iSCSI needs
this functionality).

Rewrote printf and friends to better support standard C semantics.

At least cope with "%llx" by reading the correct-sized va_arg from the
stack, even if we don't yet print it out.

At some point, vsprintf() needs to be fixed up so that it can correctly
cope with limited-sized buffers (i.e. vsnprintf), long longs, and
standard format specifiers (e.g. "%04x").  We should also remove the
special types (MAC addresses and IP addresses).  This would then enable
us to use gcc's ability to type-check printf format strings.

Moved to net/tcp/iscsi.c.

Provide access to rm_cs and rm_ds from protected-mode code.

Provide a global counter for the number of interrupts hooked.

Allow re-entrancy and provide a global counter of the number of
interrupts hooked.

Define BIOS data segment in bios.h

Add flag definitions.

Add INT 13 emulation layer (which provides an interface to gPXE block
devices).

Add 64-bit byte-swapping operations.

Provide a SCSI device interface to the iSCSI protocol

Defined SCSI device interface, and added SCSI block device
implementation.

Defined a block device interface.

Add drivers/block and arch/i386/interface/pcbios

(Redoing check-in lost by SourceForge's failure.)

(Redoing check-in lost by SourceForge's failure.)

Moved to net/

(Redoing check-in lost by SourceForge's failure.)

Add method for hooking real-mode interrupt vectors.

(Redoing check-in lost by SourceForge's failure.)

Use .text16.data section with "aw" attributes, to avoid section type
conflicts when placing both code and data into .text16.

Add __from_{text16,data16}.

(Redoing check-in lost by SourceForge's failure.)

Avoid optimisation errors under -fstrict-aliasing.

Added tunctl (since it is difficult to find for many distros).

Preserve the whole of %esp across prot_call().  We have to split this
between the low half stored in the static variable rm_sp, and the high
half stored on the prot_call() stack, because:

  Just using the stack would screw up when a prot_call()ed routine
  executes a real_call(); it would have no way to find the current top of
  the RM stack.

  Extending rm_sp to rm_esp would not be safe, because the guarantee that
  rm_sp must return to the correct value by the time an external
  real-mode call returns applies only to %sp, not to %esp.

Allow access to variables in .text16 as well as .data16.  Chained
interrupt vectors, for example, will be easiest to handle if placed in
.text16.

Preserve GDT across prot_call().

This line should not have been checked in

Add infrastructure to support access to .data16 (and .text16) variables
from protected-mode code.

Set up %ds to point to .data16 in prot_to_real, so that code specified
via REAL_EXEC() and friends can access variables in .data16.

Move most real-mode librm variables from .text16 to .data16.

Added methods for efficiently declaring and accessing variables in
.data16.  librm will need to supply "char *data16", i.e. the virtual
address of the start of .data16.

BSS is now zeroed by libprefix (along with the otherwise non-zeroable
portions such as the stack) during the installation process.

init_fns() are called from main().  We need to think about initial
control flow some more.

Typo

Create two easy-to-use entry points in libprefix: install and
install_prealloc.  I *think* these will suffice for all the 16-bit
prefixes.

<name>_size variable is no longer needed, since we don't copy the code.
However, it's worth adding a .size directive so that objdump reports the
correct sizes for the code fragments.

Towards a(nother) new real-mode infrastructure, in which we take
advantage of the fact that we have to have a permanently-resident block
in base memory.

Move stack out to separate object, so that having a stack doesn't drag in
setup.S.

Verified as working

This should be much more elegant: we use flat real mode for the
highmem data, so decompress16 will be able to unpack blocks bigger
than 64kB.

Checking in because I don't want to lose this rather neat code for
running the decompresser in 16:16 protected mode using the real-mode
stack.  However, there's an even simpler way to do it...

Typo

Merge TCP aborted(), timedout() and closed() methods into a single
closed() method with a reason code.

Half-way tidy

Make all TCP methods optional; at least FTP data is a read-only
connection and so legitimately ignores acked() and senddata().

Proof-of-concept FTP implementation

Add a temporary snprintf, so that safely-written code can at least
compile, even if it won't yet be safe.

Fix up prototype of strtoul() to match POSIX.

Created net/tcp and moved hello.c there

Make tcp_connect() void; it will eventually have no failure case.

Put the TCP connection periodic processing in tcp.c, where it belongs.

Consistency

Moved uIP and tcp.c from proto/ to net/

Move init.h to gpxe/init.h.

Change semantics of network API so that packet-absorbing calls *always*
take ownership of the packet, rather than doing so only if they return
success.  This breaks semantic compatibility with Linux's
hard_start_xmit() method, but means that we don't have to worry so much
about error cases.

Split mechanism of processing received packets (net_rx_process()) out
from policy (net_step()), preparatory to putting net_step() in a separate
object.

Added basic code for implementing co-operative multitasking.

Yes, you really can do it in 65 bytes.

Give uIP a static IP address for proof-of-concept testing

Network layer now works as a proof of concept