Lo-tech XT-CF flash utility source
Jump to navigation
Jump to search
Source code for a simple lo-tech XT-CF flash utility, which can be compiled using Turbo Pascal 6. Compiled code can be downloaded here.
Code
Program Flash;
{
Simple utility to read or write ROM images to or from SST39SF or AMIC A29010
flash chips, as used by the lo-tech XT-CF and Universal ROM Boards.
See http://www.lo-tech.co.uk/wiki/XT-CF-Boards
Written by: James Pearce
Last Updated: 09-Dec-13
VERSION HISTORY:
0.1 - Initial beta
0.2 - Added custom delay routines, to make it work on Pentium and higher
0.3 - Corrected maximum delay loop setting
1.0 - Initial 'finished' release for Peacon XT-CF board:
- removed ROM size parameter (as ROM is hard-wired to be 32KB)
1.1 - Updated release to support Peacon 8-Bit ROM Board:
- Included prompt to confirm writing
- Added (back) ROMSIZE parameter, as it could be 32 or 64KB
- Added ability to merge code
1.2 - Rebranded to lo-tech
Added support for AMIC A29010A 1Mb flash chip
ROMSIZE parameter removed (again) as not needed; just use an image > 32K
1.3 - Added support for SST29EE010 and SST29LE010 flash chips
Corrected usDelayLoop (was calibrated at 500uS instead of 125uS)
COMMAND LINE USAGE:
flash [image-file] [chip-base-address] (64k)
OR
flash interactive
Examples:
1. To overwrite the entire chip whose base address is D000, with the
contents of an image file of up to 32KB:
flash xtide.bin D000
2. As 1, but with an image file of up to 64KB:
flash xtide.bin D000 64k
3. To use ineractive programming mode:
flash interactive
In all cases, the ROM is completely erased and reprogrammed.
}
uses dos, crt;
CONST
FLASH_OK : BOOLEAN = TRUE;
FLASH_ERROR : BOOLEAN = FALSE;
RES_OK : Byte = 0;
RES_UNDER : Byte = 1;
RES_OVER : Byte = 2;
VERSION : String = '1.3-r02';
CHIP_UNKNOWN : String = 'Unknown';
SST29EE010 : String = 'SST 29EE010';
SST29LE010 : String = 'SST 29LE010';
SST512Kb : String = 'SST 512Kb';
SST1Mb : String = 'SST 1Mb';
SST2Mb : String = 'SST 2Mb';
SST4Mb : String = 'SST 4Mb';
AMIC1Mb : String = 'AMIC A29010';
TYPE
PByte = ^BYTE;
VAR
{global variables for the delay routines}
DelayCounter : LongInt;
Hr, Mn,
Sec, S100 : Word;
{global variables recording chip type}
ChipType : String;
procedure start_clock;
{stores the current system clock time in static globals, which
can then be used as a time base by function stop_clock at some
later point}
begin
GetTime(Hr,Mn,Sec,S100);
end;
function stop_clock : longint;
{returns number of miliseconds since start_clock was called,
assuming the day remains the same that is}
var h, m, s, cs : word;
begin
GetTime(h,m,s,cs);
stop_clock := ((h*3600000)+(m*60000)+(s*1000)+(cs*10)) -
((Hr*3600000)+(Mn*60000)+(Sec*1000)+(S100*10));
end;{function stop_clock}
procedure delayLoop( ms : word );
{creates a delay of ms miliseconds (once calibrated) by running
some DIV instructions}
var
a, b, c : word;
x : word;
y : LongInt;
begin
{first check if the in-built delay can be used}
if DelayCounter < 1 then Delay(ms)
else begin
c := WORD(DelayCounter AND $FFFF);
for x := 1 to ms do
begin
for y := 1 to DelayCounter do
begin
a := b div c;
inc(b);
end;{for}
end;{for x}
end;{if/else}
end;{procedure}
procedure usdelayLoop( count : word );
{creates a delay of count x 125 microseconds (once calibrated) by running
some DIV instructions}
var
a, b, c : word;
x : word;
y, ShortWait : LongInt;
begin
c := WORD(DelayCounter AND $FFFF);
ShortWait := DelayCounter SHR 3; {ms to 125us}
for x := 1 to count do
begin
for y := 1 to ShortWait do
begin
a := b div c;
inc(b);
end;{for}
end;{for x}
end;{procedure}
function test_delay : byte;
var
interval : longint;
begin
start_clock;
delayLoop(110); {testing for 110ms delay}
interval := stop_clock;
if interval < 110 then test_delay := RES_UNDER
else if interval > 110 then test_delay := RES_OVER
else test_delay := RES_OK;
end;{function test_delay}
procedure calibrate_delay;
var
res : byte;
interval : LongInt;
begin
{first check if the in-built delay procedure can be used. Otherwise
an XT will take a long time calibrating, for no purpose}
start_clock;
delayLoop(110); {testing for 110ms delay}
interval := stop_clock;
{ if interval = 110 then
DelayCounter := -1 {built-in procedure will be used}
{ else}
begin
{calibration required.}
{div is c.80 clocks on an 8088 => ~60 divs per ms}
DelayCounter := 30;
res := RES_UNDER;
while res <> RES_OK do
begin
res := test_delay;
if DelayCounter >= $40000000 then
begin
{we can't calibrate properly as we're about to overflow}
RES := RES_OK; {end the loop}
DelayCounter := $7FFFFFFF; {maximum value as it's signed}
end else
begin
if res = RES_UNDER then DelayCounter := DelayCounter * 2; {we need more delay}
if res = RES_OVER then DelayCounter := DelayCounter * 2 div 3; {we've overshot}
end;{if/else}
end;{while}
end;{if interval/else}
end;{procedure calibrate_delay}
function HexToWord( s : string ) : word;
{converts the hex represented by the string, to a WORD}
var
i : Byte;
Wd : Word;
Digit : Byte;
Error : Boolean;
begin
Wd := 0; Error := False;
if (length(s) <= 4) then begin
for i := 1 to length(s) do begin
case s[i] of
'0'..'9' : Digit := BYTE(s[i]) - 48;
'A'..'F' : Digit := 10 + (BYTE(s[i]) - 65);
'a'..'f' : Digit := 10 + (BYTE(s[i]) - 97);
else Error := True;
end;{case}
if Error then i := length(s)
else Wd := (Wd SHL 4) + Digit;
end;{for}
end;{if}
if Error then HexToWord := 0
else HexToWord := Wd;
end;{function HexToWord}
function WordToHex( Wd : word ) : string;
{converts a word to ASCII hex}
var
Digit, i : Byte;
AsciiDigit : Char;
s : string;
begin
BYTE(s[0]) := 4; {set string length}
for i := 4 downto 1 do
begin
{get the low 4 bits of Wd to Digit, and SHR Wd 4}
asm
mov ax, Wd
mov bx, ax
and bl, $0F
cmp bl, 10
jb @ZeroToNine
add bl, 17
@ZeroToNine:
add bl, 48
mov AsciiDigit, bl
shr ax, 1
shr ax, 1
shr ax, 1
shr ax, 1
mov Wd, ax
end;{asm}
s[i] := AsciiDigit;
end;{for i}
WordToHex := s;
end;{function WordToHex}
function Caps( s : string ) : string;
{returns string capitalised}
var
i : byte;
tempstr : string;
begin
BYTE(TempStr[0]) := BYTE(s[0]); {set length}
for i := 1 to 255 do
TempStr[i] := UpCase(s[i]); {copy all chars}
Caps := TempStr;
end;{function Caps}
function FlashType( baseaddr : word ) : Boolean;
{Attempts to determine flash chip type from supported types.
Returns FLASH_OK if determined properly, FLASH_ERROR otherwise.
Result itself is stored in global variable ChipType}
var
Location : ^byte;
begin
ChipType := CHIP_UNKNOWN;
{First check for SST39SF chips}
{ChipID routine entry...}
Location := ptr( baseaddr, $5555 );
Location^ := $AA;
Location := ptr( baseaddr, $2AAA );
Location^ := $55;
Location := ptr( baseaddr, $5555 );
Location^ := $90;
{check what's there}
{v1.3 - added 125uS delay, required by SST29EE010 before polling chip ID}
usdelayLoop(1);
Location := ptr( baseaddr, 0 );
If Location^ = $BF then
begin
Location := ptr( baseaddr, 1 );
case Location^ of
$07 : ChipType := SST29EE010;
$08 : ChipType := SST29LE010;
$B4 : ChipType := SST512Kb;
$B5 : ChipType := SST1Mb;
$B6 : ChipType := SST2Mb;
$B7 : ChipType := SST4Mb;
end; {case}
{Exit ChipID routine...}
Location := ptr( baseaddr, $5555 );
Location^ := $AA;
Location := ptr( baseaddr, $2AAA );
Location^ := $55;
Location := ptr( baseaddr, $5555 );
Location^ := $F0;
usdelayLoop(1); {125uS delay; required by SST29EE010}
end {if SST chip detected}
else
begin
{SST not detected; check now for AMIC A29010}
{Autoselect mode routine entry...}
Location := ptr( baseaddr, $555 );
Location^ := $AA;
Location := ptr( baseaddr, $2AA );
Location^ := $55;
Location := ptr( baseaddr, $555 );
Location^ := $90;
{check what's there}
Location := ptr( baseaddr, 0 );
If Location^ = $37 then
begin
Location := ptr( baseaddr, 1 );
case Location^ of
$A4 : ChipType := AMIC1Mb;
end;{case}
{Exit Autoselect mode by issuing reset...}
Location^ := $F0;
end;{if AMIC chip detected}
end;{if/else}
{return result}
If ChipType = CHIP_UNKNOWN then
FlashType := FLASH_ERROR
else
FlashType := FLASH_OK;
end;{function FlashType}
function eraseChip( baseaddr : word ) : boolean;
{erases the entire chip; returns FLASH_OK if successful}
var
Location : ^byte;
DQ7 : Byte;
Done : Boolean;
Error : Boolean;
LoopCount,
LoopMax : Word;
DivRes : Byte;
lastToggle,
thisToggle : Byte;
begin
{Route depends on the chip type}
If (ChipType = AMIC1Mb) or (ChipType = CHIP_UNKNOWN) then
begin
{AMIC A29010 erase command sequence}
Location := ptr( baseaddr, $555 );
Location^ := $AA;
Location := ptr( baseaddr, $2AA );
Location^ := $55;
Location := ptr( baseaddr, $555 );
Location^ := $80;
Location := ptr( baseaddr, $555 );
Location^ := $AA;
Location := ptr( baseaddr, $2AA );
Location^ := $55;
Location := ptr( baseaddr, $555 );
Location^ := $10;
LoopMax := 1875; {set timeout to 75s (1875 x 40ms)}
end else begin
{SST39SF and SST29xx erase command code...}
Location := ptr( baseaddr, $5555 );
Location^ := $AA;
Location := ptr( baseaddr, $2AAA );
Location^ := $55;
Location := ptr( baseaddr, $5555 );
Location^ := $80;
Location := ptr( baseaddr, $5555 );
Location^ := $AA;
Location := ptr( baseaddr, $2AAA );
Location^ := $55;
Location := ptr( baseaddr, $5555 );
Location^ := $10;
LoopMax := 25; {set timeout to 1s (25 x 40ms)}
end;{Chip specific erase command entry select}
{then wait}
Done := False;
Error := False;
LoopCount := 0;
Location := ptr( baseaddr, 0 ); {we'll poll address 0 to check when done}
if (ChipType = SST29EE010) or (ChipType = SST29LE010) then
begin
usDelayLoop(2); {250uS delay before we can poll}
{SST29xE010 provides a busy toggle bit (DQ6) that must be polled}
lastToggle := Location^ AND $80; {get DQ6 from device}
while (not done) and (not error) do
begin
inc(LoopCount);
delayLoop(40); {40ms delay}
thisToggle := Location^ AND $80; {get DQ6 from device}
if (thisToggle = lastToggle) then Done := true;
lastToggle := thisToggle;
if LoopCount mod 100 = 0 then write('.'); {provide an indication things are still running}
if (LoopCount = LoopMax) or KeyPressed then Error := true; {trap timeout based on chip type}
end;{while}
if (Done) then begin
{erase seemed to succeed, so enable SDP}
Location := ptr( baseaddr, $5555 );
Location^ := $AA;
Location := ptr( baseaddr, $2AAA );
Location^ := $55;
Location := ptr( baseaddr, $5555 );
Location^ := $A0;
end;{enable SDP}
end else begin
{other chips are handled with data polling}
while (not done) and (not error) do
begin
inc(LoopCount);
delayLoop(40); {40ms delay}
if Location^ = $FF then Done := true;
if LoopCount mod 100 = 0 then write('.'); {provide an indication things are still running}
if (LoopCount = LoopMax) or KeyPressed then Error := true; {trap timeout based on chip type}
end;{while}
end;{if/else}
If Error then
begin
If KeyPressed then write('Interrupted by keypress.')
else begin
WriteLn('** Timeout **');
Write('Expected FFh, but found ',WordToHex(Location^),'h.');
end;{else}
eraseChip := FLASH_ERROR;
end else eraseChip := FLASH_OK;
end;{function eraseChip}
function writeByte( baseaddr : word; offset : word; b : byte ) : BOOLEAN;
{writes byte b to baseaddr:offset, returns FLASH_OK if successful}
var
Location : ^byte;
DQ7 : Byte;
Done : Boolean;
Error : Boolean;
DivRes : byte;
usDelay,
LoopCount,
LoopMax : Word;
begin
{Routine depends on the chip type}
If (ChipType = AMIC1Mb) or (ChipType = CHIP_UNKNOWN) then
begin
{AMIC A29010 erase command sequence}
Location := ptr( baseaddr, $555 );
Location^ := $AA;
Location := ptr( baseaddr, $2AA );
Location^ := $55;
Location := ptr( baseaddr, $555 );
Location^ := $A0;
Location := ptr( baseaddr, offset );
Location^ := b;
usDelay := 1; {1 = 125us delay per byte}
LoopMax := 3; {timeout after 375us (3x125)}
end else begin
{SST39SF byte program command sequence}
Location := ptr( baseaddr, $5555 );
Location^ := $AA;
Location := ptr( baseaddr, $2AAA );
Location^ := $55;
Location := ptr( baseaddr, $5555 );
Location^ := $A0;
Location := ptr( baseaddr, offset );
Location^ := b;
usDelay := 1; {1 = 125us delay per byte}
LoopMax := 2; {timeout after 250us (2x125)}
end;{if/else}
{then wait}
Done := False;
Error := False;
LoopCount := 0;
while (not done) and (not error) do
begin
inc(LoopCount);
usdelayLoop(usDelay);
if Location^ = b then Done := true;
if (LoopCount = LoopMax) or KeyPressed then Error := true;
end;{while}
If Error then writeByte := FLASH_ERROR
else writeByte := FLASH_OK;
end;{function writeByte}
function writePage( baseaddr, pageaddr : word; var PageData : PByte ) : BOOLEAN;
{writes a 128 byte page to the device, returns FLASH_OK if successful}
{baseaddr = ROM chip base address
pageaddr = offset of page to be programmed (0, 128, 256...)
pagedata = pointer to 128 bytes of data to be programmed.}
var
Location : ^byte;
DQ7 : Byte;
Done : Boolean;
Error : Boolean;
DivRes : byte;
usDelay,
LoopCount,
LoopMax : Word;
i : byte;
begin
Error := True;
{Routine depends on the chip type}
if (ChipType = SST29EE010) or (ChipType = SST29LE010) then
begin
Location := ptr( baseaddr, 0 );
asm cli end; {clear interrupts - each bytes has to be sent within 100uS}
{SST29xE page SDP unlock sequence}
Location := ptr( baseaddr, $5555 );
Location^ := $AA;
Location := ptr( baseaddr, $2AAA );
Location^ := $55;
Location := ptr( baseaddr, $5555 );
Location^ := $A0;
{device should now (immediately) accept 128 bytes of data}
Location := ptr( baseaddr, pageaddr );
for i := 1 to 128 do
begin
Location^ := PageData^;
inc(Location);
inc(PageData);
end;{for}
{data sent to buffer - now wait for data to be ingested}
asm sti end; {re-enable interupts}
usdelayLoop(2); {250uS delay before we can check}
{then wait}
Done := False;
Error := False;
LoopCount := 0;
usDelay := 4; {4 = 500us delay per byte}
LoopMax := 20; {timeout after 10ms (20 x 500us)}
while (not done) and (not error) do
begin
inc(LoopCount);
usdelayLoop(usDelay);
if Location^ = PageData^ then Done := true;
if (LoopCount = LoopMax) or KeyPressed then Error := true;
end;{while}
end;{if/else}
If Error then writePage := FLASH_ERROR
else writePage := FLASH_OK;
end;{function writePage}
procedure FlashChip( imagefile, baseaddr : string );
{called once parameters are validated; this does the work!}
{$R- disable range checking, as the ROM is directly accessed and could be
64K exactly}
type
TRomImage = array[0..31767] of byte;
var
RomImage1,
RomImage2 : ^TRomImage;
Rom : ^TRomImage; {used to compare}
CurrentPage : PByte;
RomFile : File;
BytesRead,
BytesRead1,
BytesRead2,
CurrentPos : word;
Res : Integer;
RomBaseAddr : word;
Error : Boolean;
X, Y : Byte;
UpdateInt : word;
UpdateCount : word;
Percent : Byte;
Ch : Char;
CurrentByte : Byte;
begin
{load the ROM image file}
write('Opening ROM image... ');
new(RomImage1); new(RomImage2);
assign(RomFile,imagefile);
{$I- disable IO error checking}
reset(RomFile,1);
{$I+ }
if IOResult <> 0 then
begin
WriteLn('Unable to open file.');
Exit;
end;{if}
if (FileSize(RomFile) < 2048) or (FileSize(RomFile) > 65536) then
begin
{ROM file too small or too large}
WriteLn('ROM file must be between 2 and 64K.');
Close(RomFile);
Exit;
end else WriteLn('OK');
{get chip base address}
RomBaseAddr := HexToWord( baseaddr ); {starting location of ROM}
{Display detected flash type}
If FlashType(RomBaseAddr) = FLASH_OK then
WriteLn( 'Detected ', ChipType, ' Flash Chip at ', baseaddr, 'h' )
else
WriteLn( 'Unable to determine flash chip type. Attempting JDEC programming.');
{read the file}
Write('Reading... ');
BytesRead2 := 0;
BlockRead(RomFile,RomImage1^,32768,BytesRead1);
if not EoF(RomFile) then
BlockRead(RomFile,RomImage2^,32768,BytesRead2);
BytesRead := BytesRead1 + BytesRead2;
WriteLn( BytesRead, ' bytes read OK.');
Close(RomFile);
{erase the chip}
Write('Erasing ' );
if (eraseChip(RomBaseAddr) = FLASH_OK) then
begin
{erase was successful; write out new code}
writeLn('OK');
Error := False;
If BytesRead > 0 then
begin
WriteLn('Programming... ');
UpdateCount := 0;
Percent := 0;
X := WhereX;
Y := WhereY;
write( '0%' );
if (ChipType = SST29EE010) or (ChipType = SST29LE010) then
begin
{page-mode programming}
while CurrentPos < Pred(BytesRead) do
begin
if CurrentPos < 32768 then
CurrentPage := Addr(RomImage1^[CurrentPos])
else
CurrentPage := Addr(RomImage2^[CurrentPos-32768]);
if (writePage(RomBaseAddr,CurrentPos,CurrentPage) = FLASH_ERROR) then
begin
GotoXY(X,Y);
Writeln('Failed writing at page ',(CurrentPos div 128));
CurrentPos := Pred(BytesRead); {terminate loop}
Error := TRUE; {record error state}
end else begin
{programming that page succeeded - update screen and counters}
CurrentPos := CurrentPos + 128; {advance to the next page}
Percent := (CurrentPos*100) div BytesRead;
GotoXY(X,Y);
write(Percent,'%');
end;{if (writePage...}
end;{while}
end else begin
{byte-mode programming}
UpdateInt := BytesRead div 100;
for CurrentPos := 0 to Pred(BytesRead) do
begin
inc(UpdateCount);
if (UpdateCount = UpdateInt) then
begin
{update percentage displayed on-screen}
GotoXY(X,Y);
inc(Percent);
write(Percent,'%');
UpdateCount := 0;
end;{screen update}
if CurrentPos < 32768 then
CurrentByte := RomImage1^[CurrentPos]
else
CurrentByte := RomImage2^[CurrentPos-32768];
if (writeByte(RomBaseAddr,CurrentPos,CurrentByte) = FLASH_ERROR) then
begin
GotoXY(X,Y);
Writeln('Failed writing at byte ',CurrentPos);
CurrentPos := Pred(BytesRead); {terminate loop}
Error := TRUE; {record error state}
end;{if}
end;{for}
end;{if ChipType.../else}
if Not Error then begin
{write was OK; now check what's there}
GotoXY(X,Y);
WriteLn('OK ');
Write('Comparing... ');
Rom := Ptr( RomBaseAddr, 0 ); {access the ROM directly}
for CurrentPos := 0 to Pred(BytesRead) do
begin
if CurrentPos < 32768 then
CurrentByte := RomImage1^[CurrentPos]
else
CurrentByte := RomImage2^[CurrentPos-32768];
if Rom^[CurrentPos] <> CurrentByte then
begin
Error := True;
WriteLn('Error at offset ', WordToHex(CurrentPos), 'h');
CurrentPos := Pred(BytesRead);
end;{if}
end;{for}
If Not Error then WriteLn('OK!');
end;{if not error / else}
end;{if BytesRead > 0}
end {if eraseChip}
else
{chip erase failed}
WriteLn('Erase operation FAILED.');
Dispose(RomImage1); Dispose(RomImage2);
end;{procedure FlashChip}
function BaseOK( s : string ) : Boolean;
{checks that the base address i:
- in the correct range, A000 - F000
- 4K aligned
}
var
BaseAddr : Word;
begin
BaseAddr := HexToWord( s );
if ((BaseAddr AND $FF) = 0) and (BaseAddr >= $A000) and
(BaseAddr <= $F000) then
BaseOK := True
else
BaseOK := False;
end;{function BaseOK}
Procedure InteractiveProgrammer;
begin
WriteLn('Interactive programming feature not implemented yet.');
WriteLn;
WriteLn('Can you help? Please get in touch via the blog:');
WriteLn(' http://www.lo-tech.co.uk/about/');
WriteLn;
end;{procedure}
function ParamSpecified(s : string) : boolean;
{checks all command line arguments for s, returning true if found}
var i : word; found : boolean;
begin
found := false;
for i := 1 to ParamCount do
if Copy(ParamStr(i),1,Length(s)) = s then found := true;
ParamSpecified := found;
end;{function ParamSpecified}
Function ParamsOK( P1, P2 : string ) : Boolean;
{checks parameters, returns true if look OK}
var
f : file;
OK : Boolean;
begin
OK := True;
assign(f,P1);
{$i- } reset(f); {$i+ }
if IOResult <> 0 then begin
OK := False;
WriteLn('Couldn''t open file ', P1, '.');
end else begin
{found file OK}
close(f);
if not BaseOK(P2) then OK := False;
end;
if OK then
begin
{parameters suggest we're good to go - calibrate the timing loops}
write('Calibrating delay loops...');
calibrate_delay;
writeLn(' calibration factor is ', DelayCounter, '.');
end;{if OK}
ParamsOK := OK;
end;{function ParamsOK}
Procedure DisplayHelp;
begin
WriteLn('Supports SST 29xE010/39SF0x0, and AMIC A29010 flash chips.');
WriteLn;
WriteLn('Usage:');
WriteLn;
WriteLn('1. Simple mode - write an image file to the ROM. The ROM is');
WriteLn(' completely erased, then the file copied. Can be used with');
WriteLn(' 32KB or 64KB configurations.');
WriteLn;
WriteLn('eg: flash [image-file] [base-address]');
WriteLn;
WriteLn(' [image-file] - ROM image, i.e. xtide.bin');
WriteLn(' [base-address] - hex ROM window base address, i.e. D000');
WriteLn(' must be A000-F800');
WriteLn;
WriteLn('2. Interactive mode. Enables a number of different ROM images');
WriteLn(' to be stored in the chip and programmed independently. The');
WriteLn(' ROM contents index will be kept in a file on disk.');
WriteLn;
WriteLn('eg: flash interactive');
WriteLn;
end;{procedure DisplayHelp}
var Ch : Char;
BEGIN
WriteLn('Lo-tech XT-CF and 8-bit ROM Board Flash Programmer, version ',VERSION);
if ParamSpecified('interactive') then InteractiveProgrammer
else if ParamsOK( ParamStr(1), ParamStr(2) ) then
begin
FlashChip( ParamStr(1), ParamStr(2) );
WriteLn;
WriteLn('If BIOS images currently in use have been updated, it is HIGHLY');
WriteLn('recommended that the computer is now restarted.');
WriteLn;
Write('Press any key to return to DOS, or CTRL-ALT-DEL to restart.');
{clear keyboard buffer, in case user interrupted the process}
while keypressed do Ch := ReadKey;
{now pause}
repeat until keypressed;
if keypressed then Ch := Readkey;
end
else DisplayHelp;
END.{program}