AT BIOS KIT

The Comprehensive Guide
to Creating an AT Bios in C

A Complete Description of the Bios
Including Source Code on Diskette

John O. Foster & John P. Choisser

Annabooks

ISBN 0-929392-02-7

AT BIOS KIT

The Comprehensive Guide
to Creating an AT Bios in C

John O. Foster & John P. Choisser

A Complete Dtelimptipn o|^t^W^
Including Source Code f n <Di&bfce

Annabooks

AT BiosKit
by John O. Foster and John P. Choisser

Published by

Annabooks

12145 Alta Carmel Court, Suite 250-262

San Diego, CA. 92128

Copyright (C) Annabooks 1988, 1989

Copyright (C) FOSCO 1988, 1989

All Rights Reserved. No part of the contents of this book may be reproduced or transmitted in any
form or by any means without the written permission of the publisher, except for the inclusion of brief
quotations in a review.

Object Code produced from the Source Code files may be reproduced only in accordance with the
terms of the license agreement.

November 1989

Printed in the United States of America

ISBN 0-929392-02-7

This book is designed to provide information about a Basic Input Output System (BIOS) for an AT
type computer. No warranty of suitability, purpose, or fitness is implied. The information contained
within as supplied on an "as-is" basis. The authors and publishers shall have neither liability nor respon-
sibility to any person or entity with respect to any loss or damage, real or claimed, in connection with or
arising from any information contained in this book.

Dedication

John O. Foster

This Book is dedicated especially to Patricia, and to the rest of the family for all
their help and support.

John P. Choisser

This Book is dedicated to Coleen for her loving support during my career change.

Preface

What started as a diversion has turned into a gratifying nuisance. Publishing the XT-
AT Handbook and the XT Bioskit was an exercise in "Is anyone interested?" The
Handbook proved there were some people out there, and the XT BiosKit indicated
there were a lot of people out there. "Do you publish an AT Bios Book?" was often
asked. When we at Annabooks tallied up the interest, the next move was obvious.
More and more system designers are moving from 8088 based systems to 286 and
386 based systems. And the fascinating thing we heard was the variety of uses to
which the PC architecture was being put...

We heard from those who are involved in automation, robotics, research, education,
avionics, consumer and office products, energy management and control, and
industries and applications too numerous to mention, both in the U.S. and around
the world. Product volumes involved ranged from 5 and 10 per year, to thousands
per month.

We even heard that because of the BiosKit, projects that were designed for 286
based systems could be changed to 8088 based systems. Being able to use the
BiosKit was important enough to justify changing the product.

For all you who asked for an AT BiosKit, we are happy to present this latest volume
in an exciting series which will cover a variety of topics, always in the form of a
"working" book.

John O. Foster

Hidden Meadows, California

November 1988

Table of Contents

SECTION A

"ABOUT THE BIOS"

One

Introduction

Two

Audience

Three

About the Programs

Four

Tools Required

Five

Ownership, License, and Warranty

Six

Overview

SECTION B

THE C UTILITY PROGAMS"

One

The Biossum File

Two

The Biosdate File

Three

The Biostype File

Four

The Biosgen File

SECTION C

THE BUILD PROGRAMS"

One

The Make File

Two

The Link File

Three

The Cutinp File

SECTION D

THE ASM PROGRAMS"

One

The Prfxanc File

Two

The Top File

Three

The Pad File

Four

The Fill File

Five

The Data File

Six

The Virt File

SECTION E

THE C PROGRAMS"

One

The Kith File

Two

The Misc File

Three

The Pod Module

Four

The Equipment Driver

Five

The Memory Size Driver

Six

The Keyboard Driver

Seven

The Video Driver

Eight

The Floppy Disk Driver

Nine

The Hard Disk Driver

Ten

The Boot File

Eleven

The Cassette Driver

Twelve

The Parallel Printer Driver

Thirteen

The Comm Driver

Fourteen

The Timer Interrupt

Fifteen

The Time of Day Function

Sixteen

The Print Screen Function

Seventeen

The SysVue File

SECTION F

"ODDS AND ENDS"

One

Loading Static Ram

Two

The Indent Program

Three

The Hilite Program

Four

The Parens Program

Five

The Bin2Hex Filter

Six

The Splitbin Program

Seven

The Mergebin Program

Eight

The Patch.asm File

NOTES

SECTION A

About the Bios

This section introduces the Bios, lists some reasons for creating your own
customized Bios, explains Ownership and License information, and provides an
Overview of the structure of the Bios.

Introduction A- 1-1

ONE
Introduction

Unseen and unnoticed, the Bios (Basic input/output system) of a personal computer
takes control when power is switched on, setting up the hardware devices, running
tests, and booting up the operating system from disk. Without a Bios the machine is
an unusable, non-operating collection of hardware components. Yet the Bios is a
mysterious component for the majority of users. The Bios is a collection of programs
stored on a read-only memory chip and is usually considered to be part of the
hardware set, but these routines are like any other software. They can be analyzed,
understood, modified and re-created as desired.

This Book

This book is a guide to analyzing and understanding what a Bios is, how it works,
and how one goes about creating a Bios. The descriptions of the Bios functions are
augmented with listings of the programs required to perform those functions. The
auxiliary tools and utility programs which are used to create the Bios are also
included with an explanation of their purpose and function.

What is the Bios?

Bios is an acronym for Basic input/output system. It is a set of programs that reside
in non-volatile memory (often called firmware; programs that are implemented in
hardware memory chip(s) and are not lost when power is turned off). The Bios
includes the power-on diagnostics, a boot-up program, and device drivers for the
keyboard, disk, display, serial ports, printer port, and miscellaneous functions. A
Bios is usually written in assembly language, but the BiosKit is done in the C
language wherever possible. Some low-level operations require assembly language
for memory allocation reasons and some operations are done in assembly language
for efficiency. But by providing the bulk of the BiosKit in C, it is much easier to
understand, modify, and maintain the code.

Why do your own Bios?

You may want special features, such as special interface card support, SysVue
capability, faster bootup, equipment status displays, and so forth. Some of these
features are difficult to implement with a supplied Bios since you do not have the
capability to modify it. Additionally, a standard Bios may not have the compatibility
that you desire. You may also wish to upgrade your machine to newer capabilities
that are included in later generations of compatible computers.

If you are a manufacturer or systems integrator, you may have found that your own
Bios requires expensive long-term commitments to a Bios vendor that may not be
able to respond to your needs in a timely manner. Once you have control of your
Bios in your own hands, you will be able to modify and maintain your Bios at your
own discretion.

If you are a manufacturer of systems for use in government or commercial
applications which require delivery of source code for all software included in a
system, BiosKit allows you to easily meet these requirements without cumbersome

A-l-2 Introduction

escrow agreements or additional payment to a Bios Supplier to obtain source code.
By including BiosKit Documentation as part of your product, you may satisfy your
project requirements. If your project requires special verification or certification
activities, Bioskit not only gives you access to source code, it also allows you to
configure it as you desire.

A-Tvpe BiosKit

Audience A-2-1

TWO
Audience

This book is intended for various groups of people:

* Those who have an unsatisfied curiosity about the internal workings of their
personal computer.

* Those who are involved in the hardware and system design details of PC's and
need to understand the workings of a Bios.

* Those who are creating special applications of PC systems and find that the typical
PC Bios may have some shortcomings or omissions.

* Those who just want to make their own Bios so they can enjoy the satisfaction of
having done it.

* And especially for those people that are in more than one just one of the above
groups.

More Notes

About The Programs A-3-1

THREE
About the Programs

This book and the magnetic media included with it provide you with the source code
and explanations needed for you to customize your own Bios for an AT type
compatible computer. The majority of the source code is in the C language with
supporting routines in assembly language. C was chosen for a variety of reasons,
including:

* It is well suited to systems level programs because it permits access to machine
features.

* It is widely used, understood, and a de-facto standard among system level
programmers.

* There are many publications available for reference, tutorials, as well as periodical
publications for alternate information.

* It is supported by a variety of affordable compilers.

* Its architecture and structure encourage good programming practices which help
to minimize the frustrating aspects of debugging and error-correction.

Because of some restrictive aspects of a Bios program, some of the programs are
written in assembly language, as you might expect with systems-level C programs.
This is required because:

* Certain locations in the completed program need to be fixed at absolute memory
locations (the reset jump).

* Constants need to reside in read-only memory and be allocated to the code
segment in fixed locations.

* Some operations such as block moves (used in CRT scrolling, for instance) are
much faster than the C counterparts.

Things To Do

Tools Required A-4-1

FOUR
Tools Required

Building and customizing the Bios requires some tools. Knowledge is the basic tool.
Then you will need the physical tools; the hardware and software described below.

Knowledge Tools

Readers should have or be prepared to acquire some degree of skill in the following
areas to comprehend and become proficient in the creation and enhancement of a
Bios:

* operation of DOS

* operation of a text editor

* assembly language understanding

* understanding of the C language

* understanding of the AT architecture

There are many excellent publications available on these subjects in addition to the
manuals that are supplied with the software tools listed below. By visiting your
library and book store, and by reading computer periodicals, and especially by
talking to computer-interested acquaintances, you will find ways to augment your
knowledge. For those who may be apprehensive about tackling a Bios project,
remember that knowledge is acquired by bits and pieces. Curiosity, patience, and a
positive attitude will be your best ally.

Software Tools

To build the Bios you will need the following tools:

* C Compiler

Recommended - Microsoft V 5.1 or later

Other Compilers may require some modification of

the Source Code.

* Macro- Assembler - Microsoft V 5.1 or later

* Linker - Microsoft (included with MASM or Compiler)

* Debug program (included with MASM)

* A Make Utility (included with MASM or Compiler)

* An Archive or backup utility is also recommended.

You may chose alternate tools, but they may require some modification of the
source code to build and execute successfully.

Hardware Tools

Your development computer should be an XT/ AT compatible with 640K of ram, a
hard disk, and a printer. Either a color or monochrome monitor is sufficient.

To program Eproms for your computer you will need a Prom programmer. The
Sunshine (brand name) programmer (approximately $125.00) is suggested.

To erase Proms, a Walling Datarase UVProm Eraser is suggested ($35 to $55).

A-4-2 Tools Required

Target Tools

The programs in this book were designed for use with an AT compatible hardware
set. This means that the original AT or the truly compatible "clone/compatibles" will
require little or no Bios modification to operate successfully. There are some areas
of difference, however, that may affect your Bios details. Some of these are
described below.

Prom/Rom chip types - Some high volume ATs use masked Rom chips for the Bios.
These chips may or may not have the same electrical characteristics and pinout as
the Prom chips you would normally use for your Bios. You should verify that the
pinout of the original Bios chip you intend to replace is compatible with the chip you
will be using. If it is not pin compatible, you may be able to replace it by using an
appropriate adapter.

The next consideration is the addressing capability of the original Bios Socket(s) in
your target system. Depending on the original design, the address mapping may be
hard-wired or jumper (or decoding device) selectable to accom modate the Bios
Proms you create. You should have the range of F0000-FFFFF available for your
Bios. This will probably require two Proms, one for even bytes and one for odd bytes
in your target system.

Turbo machines generally interpret a special combination of keystrokes to
enter/leave the turbo mode. This decoding may be added to the keyboard handler
(Bioskb.c ) in the scan code conversion section of the hardware interrupt service
routine. Turbo-AT's may use one of the spare output pins of the 8042 keyboard
controller chip to change the CPU clock speed. To determine if this method is used,
you may manually toggle these bits using Sysvue (Port In and Out commands) to see
if this scheme is used to control the Turbo switching. If you include a Turbo
switching feature and subsequently have floppy disk failures, the DMA clock speed
is to be suspected. Some Turbo motherboards switch the DMA clock to high speed
along with the CPU clock. It may be necessary to include an "Unturbo" and
"Returbo" sequence in the floppy disk module (Biosdiskx) to insure that the DMA
is operated at the slow clock speed during disk transfers. To do this, save the state of
the signal used to implement the speed switch upon entry to the Disk_io handler,
and restore it to its previous condition upon exit. A Turbo machine may have a

A-Tvpe BiosKit

Tools Required A-4-3

Turbo" mode display (typically an LED) to show when it is in turbo mode. This
indicator is usually driven from the same speed switch signal that controls the clock.

One method of investigating compatibility is to attempt to run the standard version
of DOS on a computer. If a given computer operates only with its customized
version of DOS, some hardware incompatibility might be expected.

SysVue

Bonus - BiosKit includes the source code for SysVue, a Prom resident program that
provides many of the features of disk resident Debug programs. SysVue is always
available with a keystroke sequence. It is extremely handy for checking custom
features of your Bios.

Once you have successfully built the standard version of the BiosKit, you will be
ready to consider special versions for your particular application.

Section A: About the Bios

Things I Should Do Soon

Ownership, License, Warranty A-5-1

FIVE
Ownership, License, and Warranty

The following paragraphs explain the ownership (right of title) of the Source Code
and of the Binary Code generated from it, the license granted to you to duplicate
the object code, and the warranty of this published information. This information is
important to you. Please read it carefully.

Ownership of Source Code

The Source Code for BiosKit is an intellectual work covered under the copyright
laws of the United States and other countries. Title to ownership is retained by
FOSCO. Your purchase of the BiosKit includes a license to use the Source Code,
but does not convey right of title of said Source Code to you. You may use the
Source Code in accordance with the License Agreement as described in the
following paragraph.

License to Duplicate

With the purchase of the BiosKit, FOSCO and Annabooks have waived the $4.00
per copy license fee for the first ten (10) copies of the BiosKit Binary code for your
own use, or for sale in your product.

You are responsible for remitting to Annabooks the fee of $4.00 per copy for
additional copies. This fee remittance should be made payable to Annabooks and
annotated as "AT Bioskit License Fee". It should be made on not less than a
quarter-year basis and must be payable in U.S. (US$) funds.

Payments should be sent to the following address:
Annabooks

12145 Alta Carmel Court, Suite 250-262
San Diego, CA. 92128

Please abide by the license fee requirements to avoid the need for legal recourse on
the part of Annabooks and FOSCO to insure compliance with these requirements.

During the build/customization phases, you may program an unlimited number of
Proms until you have completed the Bios. Once you place the Proms in a computer
used to run programs, the Proms are included in the ten (10) quantity covered by
this license to duplicate.

Any Bios built from the BiosKit must include the FOSCO copyright information
included with the original source code. You may add additional information, but you
may not delete any copyright information included in the standard BiosKit.

A-5-2 Ownership, License, Warranty

DISCLAIMER AND LIMITED WARRANTY

The information contained in this book and on the diskette is believed to be factual
and accurate; however, no claim of such, nor of fitness to purchaser's intended use,
is implied. Although the programs described in this book (and contained on the
diskette) are believed to be compatible in function and operation with the normal
operation of an AT type computer, no warranty as to the completeness of
compatibility to any other Bios is implied or expressed. Prudence dictates that the
user must verify fitness, correctness, and applicability of the information contained
in this publication. The diskette(s) are warranted to be readable when installed in a
compatible computer. Warranty is limited to the replacement of unreadable
diskette(s) within 90 days of purchase. The Diskette(s) are not copy-protected and
should be used only to make working copies, and then archived for backup
purposes. Liability under this warranty is limited to the replacement of the
diskette(s) even if claims otherwise have been made by purchaser or any user of the
information contained in this publication . This statement of warranty constitutes the
full and complete agreement between seller and buyer, and may not be modified bv
oral representation or written instrument without the permission of FOSCO and
Annabooks.

A-Tvpe BiosKit

Overview A-6-1

SIX
Overview

This chapter is intended to acquaint you with the major functions and parts of the
Bios. To do this, we will follow the flow of the Bios from the power-on hardware
reset point and summarize what happens as the computer is turned on. Descriptions
of detailed operations will follow in later sections and be correlated with the Source
Code Listings.

Power On -

The 80286 processors start operation at segment:offset address FFFFF:0000. This
means that program execution begins at the last paragraph (16 bytes) at the top of
address space. This location normally will have a far jump to a lower address where
the Bios will start to initialize and check-out hardware features of the system.

Diagnostics -

This usually starts at a label called 'reset' and includes checking of the CPU chip
registers, tests and initialization of the peripheral chips, and ends up by invoking a
bootstrap routine.

Bootstrap -

The function of the bootstrap routine is to load DOS from a floppy disk. If you have
a hard disk in the system, a failure to boot from a floppy is usually followed by an
attempt to boot from the hard disk. If no disk is available, you may wish to default to
SysVue or some other Prom resident program you may elect.

Drivers -

The Bios contains the low-level drivers for a variety of devices. DOS normally
assumes these drivers are present in the Bios and makes calls to them to perform
peripheral access. The drivers correspond to the Bios Interrupts documented in
various publications about PC's and DOS. To fully support DOS, these drivers must
be included, and their devices initialized by the Bios.

Bios Structure

This description of the Bios structure is intended to clarify some of the
characteristics of the Bios.

The 80286 processor starts executing code (from a power-up reset) at the highest
paragraph in the memory map. This is at Segment:Offset FFFFF:0000. To properly
respond to the hardware reset, valid executable code must be stored at this location
in the Bios Prom. To insure that the instruction intended for this location is
assembled and linked correctly, the final module of the Bios is manipulated in such
a way that the normal linker utilities (such as Microsoft's Linker which links
programs in an ascending address sequence), can achieve this result. The top
module of the Bios is written in Assembly language, so that programmer control is
maintained over the location of certain instructions. Additionally, the top module

A-6-2 Overview

provides a place to include various table structures and assembly language
subroutines, which are C functions.

From the power-on reset, a jump is executed (at FFFFF:0000) to an assembly
language initialization code sequence which initializes the DMA controller, the
Ram Refresh, and the first 64 Kbytes of System Ram. Once this has been
accomplished, the C language POD (Power On Diagnostic) module is executed.
This module continues the power-up and diagnostic checks of the system, and also
calls setup (initialization) routines in the various device driver modules. When the
system has been completely initialized, the bootstrap function is called.

The POD process includes:

loading the interrupt vector locations,

initializing the display adapter,

determining the size of the system Ram,

testing the system Ram,

reading the equipment configuration CMOS Ram,

performing a checksum test on the Bios prom,

identifying and initializing COM and LPT ports,

calling any executable Rom option modules,

initializing the floppy disk drive(s),

and finally calling the bootstrap procedure.

Why Link is Done Twice

During the linking process when building the Bios, a trial link is performed. This
trial link determines how far short the Bios falls of filling a complete segment (64
Kbytes). This shortfall in length is calculated, and a filler module is built which will
compensate for the shortfall. The Bios is then linked again with the filler module to
produce a Bios in which the required locations are fixed at the correct addresses.
This file is then converted from an .EXE format file to a .BIN binary image file
suitable for transfer to a Prom programmer.

How to develop and test a Bios

The simplest way, of course, is to build a Bios, program a Prom, install the Prom in
the system, and see how the system runs. This method is time consuming and
debugging can be difficult, particularly if the system doesn't run at all. The preferred
method is to install a Static Ram Adapter Card residing above the video ram area,
and away from any rom-scan devices such as EGA Video and Hard Disk Adapters
that might be installed in your target system. Recommended location is segment
D000. The Test Bios is then loaded into the Ram area and a Jump instruction is
executed to start executing the Test Bios. The Load-and-Jump can be performed
using a Debug Batch file as shown in Section F. To effectively integrate the Bios,
you should have (or should add) a pushbutton reset switch to your target system.
This allows you to easily reset and restart your system with its prom-based Bios if
your Test Bios should lock up or run away due to modifications which you are
testing.

An additional aid to testing is to add debug mode display statements to track the
activity of the Bios. These may be included in your C modules by using the
write_string("text n ) statement. Hexadecimal byte and word values may be dumped

A-Tvpe BiosKit

Overview A-6-3

using the Ibyte(value) and lword(value) statements. By referring to the BiosVue.c
module, you may examine examples of the usage of these statements.

When you have verified the operation of your modified Bios, the debug-mode
statements may be removed, and the Bios rebuilt.

Driver Structure

By examining the structure of the Driver modules, you will see that they are
essentially self-contained. They may call common assembly language functions in
BiosTop.asm and common C functions in BiosMisc.c, but they seldom will call other
modules except through the Interrupt structure. This helps to isolate interaction and
serves to make testing easier.

Drivers have the general structure of a Setup routine followed by the Driver itself.
Some drivers may also have a service routine for its associated hardware interrupt.
The Setup routines are called from BiosPod to initialize the drivers during the
Power-On-Diagnostics.

Programming Style

As you work with the source code, you will begin to apply your particular style of
programming to re-writes, additions, and changes. This is normal and it is a sign of
your increasing understanding of the programs. Don't be afraid to analyze the
program structure and experiment. There are at least as many ways to code a
function as there are programmers! Since this book deals with each topic only once,
we had to present each example in a particular manner. You have a different
perspective and style, and you will probably see it in a slightly different manner.
Remember there are many right ways to code a function. It is sometimes difficult to
find one of those right ways; it is usually easier to find one of the wrong ways!

Section A: About the Bios

Things I Should Avoid Doing

SECTION B

The C Utility Programs

These programs are used during the building process to add the date-stamp,
calculate the checksum, install the CPU type identification, and to fix some
locations at absolute addresses.

The Biossum File B-M

ONE
The Biossum File

The Biossum.c file is used during the Bios Build process to calculate the additive
checksum of the Bios and to insert the checksum value into the last byte of the Bios.
It looks for the first non-FF location and treats it as the start of the block. If the Bios
is padded with FF's at the front of the file, the program will scan forward every 2K
bytes to look for the start. This allows you to reserve space in 2 Kbyte blocks at the
front for your own special programs. The Rom-Scan routine will determine where
the Bios starts and scan up to that point.

*

* Copyright <c) FOSCO 1988, 1989 - All Rights Reserved

* Module Name: Bios checksum calculator

*

* Version: 1.00

*

* Author: FOSCO

* Date: 1-5-89

*

* Filename: biossum.c

*

* Functional Description:

* This program calculates a checksum and inserts it into the last byte location of the Bios.

*

* Arguments:

* Filename

* Return:

* None

* Version History:
*

*

/MNCLUDE FILES*/

#include <stdio.h>

/♦FUNCTION PROTOTYPES*/

/♦GLOBAL VARIABLES*/

unsigned numread.i:
char sum, buffer [32768] ;
FILE *stream;

/♦GLOBAL CONSTANTS*/

/♦LOCAL DEFINITIONS ♦/

/♦LOCAL CONSTANTS ♦/

/♦PROGRAM*/

main(argc,argv)
int argc;
char *argv[];

if (argc <2)
i

printf("Not enough parameters on command line\n");

exit(0);
>

if ((stream = fopen(argv[1] ."r+b")) == NULL) printf("Could not open file for reading\n");
else
<

sum=0;

numread = fread((char *)buffer,sizeof(char), 32768, stream);

B-l-2 The Biossum File

/*

** Scan for the first non -ff- celt at 2k boundaries to mark the start of the bios code.
** Reserve the prior cells for rom module integration later when customizing the bios prom
** with extensions.
*/

for (i=0;(i < numread) && (buffer [i] ■* Oxff); i += 2048);

/* i is advanced to beginning of actual bios code */
for <;i<numread;i++) sum += buffer[i];

numread = fread((char *)buffer,sizeof(char),32767,stream);

for (i=0;i<numread;i++) sum ♦= buffertil;

sum = -sum;

buffer [i] = sum;

fseek<stream.-1L,SEEK END);

f wri te(&sum, 1 , 1 , stream);
>

fclose(stream);
>

A-Tvpe BiosKit

The Biosdate File B-2-1

TWO
The Biosdate File

The Biosdate.c file is the program which inserts the current date value as the date-
stamp in the Bios module. Tliis date is determined from the current date in your
development machine. It will obviously affect the overall checksum of the Bios
module, if you re-build on different days.

/A**************************************************************************************************

*

* Copyright <c) FOSCO 1988, 1989 - All Rights Reserved

* Module Name: bios date routine

*

* Version: 1.00

* Author: FOSCO

*

* Date: 1-05-89

* Filename: Biosdate.c

*

* Functional Description:

*

* Insert date string into bios binary file. This program inserts the current date information

* into the date field in the Bios at location FFF5

*
*

* Arguments:

* Filename

*

* Return:

* Writes date field in bios. bin file
*

* Version History:

* 1-5-89 font revision

*
***************************************************************

/♦INCLUDE FILES*/

^include <stdio.h>

/♦FUNCTION PROTOTYPES*/

/♦GLOBAL VARIABLES*/

FILE *stream;

char date_buf f er [9] ;

/♦GLOBAL CONSTANTS*/

/* LOCAL DEFINITIONS*/

/* PROGRAM ♦/

main(argc,argv)
int argc;
char ♦argv[];
i
if (argc <2)
i

printfC'Not enough parameters on command line\n");
exit(0);
>

if ((stream = fopen(argv[1],"r+b M )) == NULL) printf ("Could not open file for reading\n");
else
i
fseek(stream,-11,SEEK END); /* find date field */
strdate(date buffer)J
7write((char *)date buffer, sizeof(char), 8, stream);
>

fclose(stream);
>

Things Someone Else Should Do

The Biostype File B-3-1

THREE
The Biostype File

The Biostype.c file is used to insert a byte identifying the type of system in which the
Bios is installed. The type identification may be used by some applications (or the
Bios if so desired) to determine operational characteristics of the system hardware
and/or software. This byte is located at the next- to-last location of the Bios. In an
AT Bios, there is also another identification function; Interrupt 15, Function code
CO, which returns system configuration parameters. This parameter block provides
additional type information.

* Copyright (c) FOSCO 1988, 1989 - All Rights Reserved

* Module Name: Bios type

*

* Version: 1.00

*

* Author: FOSCO

* Date: 5-5-88

* Filename: biostype.c

* Functional Description:

* Insert CPU Type byte into bios binary file. This program inserts a machine identification byte

* at location FFFE in the Bios. Because of an Assembler quirk, if we try to define this in the

* Source file, the assembler increments the offset counter and believes that the segment becomes

* larger than 64K bytes, which it considers an error condition.

*
*

* Arguments:

* biostype filespec [type]

* where type is pc,xt,at, jr,xt640

* if type is omitted, then default is xt

*

* Return:

* Writes type byte in bios. bin file 'filespec'

*

* Version History:

*
*

/♦INCLUDE FILES*/

#include <stdio.h>
#include <string.h>

/♦FUNCTION PROTOTYPES*/

/♦GLOBAL VARIABLES*/

FILE *stream;

char type_buffer[2];

/*GLOBU CONSTANTS*/

/♦LOCAL DEFINITIONS*/

^define at Oxfc /* these are the standard defined types */
#define xt Oxfe
#define pc Oxff
#define jr Oxfd
^define xt640 Oxfb

/♦PROGRAM*/

main(argc,argv) /* bios. bin */
int argc;
char *argv[];
i
char cpu_type = xt; /* default to XT type byte */

B-3-2 The Biostype File

if (argc <2)
i

printf(*'Not enough parameters on command hne\n");

exit(O);
>
if (argc > 2)

if (strcmpi(argv[2],"at H ) == 0) cpu type = at;

if (strcmpi(argvt2],"xt ,, ) == 0) cpu"*type = xt;

if (strcmpi(argv[2],"pc H ) « 0) cpu type = pc;

if (strcmpiCargvteVJr' 1 ) == 0) cpu type * jr;

if (strcmpi(argv[2],"xt640") — 0) cpu type = xt640;
>

if ((stream = fopen(argv[1],"r+b">) == NULL) printf( H Could not open file for reading\n");
else
C

fseek(stream.-2 f SEEK END); /* find type field */

type buffer[o] = cpu"type;

fwn'7e((char *)type 5uffer,sizeof(char),1 # stream);
>

fclose(stream);
>

A-Tvpe BiosKit

The Biosgen File B-4-1

FOUR
The Biosgen File

The Biosgen.c file is used during the build process to sense the size of the Bios code
and calculate a value which will be used to upward justify the Biostop module so
that it resides in the highest portion of the Bios segment. This is required to insure
that when a power-on hardware reset occurs there is an instruction present to be
executed.

/***************************************************************************************************

*

* Copyright (c) FOSCO 1988, 1989 - All Rights Reserved

* Module Name: Bios filler generator

*

* Version: 2.00

* Author: FOSCO

* Date: 12-01-88

*

* Filename: biosgen.c

*

* Functional Description:

*

* This program reads the map file (bios. map) and calculates how far short it falls from ending at

* the top of the segment. Then it builds a biosfill.inc file that pads out enough to complete the

* segment (64k bytes). The .inc file is used in a second linking of the .obj files. This produces

* a full 64k byte file with the power-on reset jumps fixed at offset FFFO in the binary image file.

* Arguments:

* biosgen bios. map biosfill.inc

* Return:

* Creates a biosfill.inc file

*

* Version History: 2.00 9/12/88

* The method of determining the file length was changed to operate with 5.1 tools. This program

* now looks at the .MAP and searches for the ORG E000 label. If it finds the label, it looks at

* the offset value associated with it, and calculates the fill value from that. If it does not

* find the label, it prints an Abort Message. If the .map file shows that the Bios is too large,

* it prints a message indicating that the Bios will not fit into the segment.

* Notes:

* This file normally compiles with two Warning Messages. They may be disabled by changing the

* message level switch in the make file. The program will execute OK even with the warnings.

*
********************************************************************

/♦INCLUDE FILES*/

#include <stdio.h>
#include <string.h>

/♦FUNCTION PROTOTYPES*/

unsigned int hval(unsigned char);

/♦GLOBAL VARIABLES*/

FILE *stream:

int radix = 10;

char first [20] , second [20] , th i rd [20] ;

char *p;

unsigned int ij

unsigned int chff;

unsigned int find; /* find/ no find flag */

unsigned int find_string;

unsigned long int~numread;

unsigned char line[255], ♦result;

/♦GLOBAL CONSTANTS*/

/♦LOCAL DEFINITIONS*/

/♦PROGRAM*/

B-4-2 The Biosgen File

main(argc,argv) /* sourcefile.map,destfile.inc */
int argc;
char *argv[];
i

/* this is the label we will search for */
char *estring = ,, _ORG_E000 M ;

/* this is where we move the offset value of the label*/

char *vstring = "0000";

if (argc <3)
C

printf ("Not enough parameters on command line\n");

exit(0);
>

if ((stream = fopen(argv[1],"r+b")) == NULL) printf("Could not open file for reading\n");
else
i

find = 0;

/* check each line of the .map file for the wanted label*/

do

C
if((result = fgets( line, 255, stream)) != NULL);

<:

/* check for the label */

if (strstr(result,estring) != NULL)

i

find string = OxeOOO;

strncpy(vstring,&l ine[6] ,4);

diff = 0:

for(i=0;i<4;i++)

diff = (diff « 4) + hval(vstring[i]);
>

find = 1;
>
>
>
while ((result != NULL) && (find == 0));

fclose(stream);

if (find « 0) /* no find */
i

printf ("Could not find ORG F000 label in .MAP file\n\r");

printf( "Aborting operationAnVr");

printf (" 1. Check command line argument specifies .MAP file\n\r");

printf (" 2. Check .MAP file for proper labels. \n\r M );
>

else
<

printf (" File size = %5u\n\r",diff+(0x10000-find_stnng));

if (diff >= find string)

C
printf (".EXE file is to large to process - aborting fill generation\n\r M );

else
i
numread = find_string - diff; /* num to write */

printf(" Free Space * X5u\n\r M , numread);

/* now build the text line for the biosfill.inc file */

st rcpy( first," db ");

strcpy( second, ultoa(numread, second, radix) ) ;

strcpy( third," dup(Offh)");

strcat(f irst, second);

strcat(first, third);

if ((stream = fopen(argvt2],"w")) == NULL) printf ("Could not open file for writing\n");
else
<
fwrite((char *)first,sizeof (char), strlen(f irst), stream);
>
>

fclose(stream);
>
>

/* convert hex ascii to val */
unsigned hval (unsigned char cval) {

A-Tvpe BiosKit

The Biosgen File B-4-3

unsigned val;
cval -= '0';

if (cval > 9) cval -= 7;
val = cval;
return(val);
>

Section B: The C Utility Programs

Things I keep Forgetting

SECTION C

The Build Programs

These programs are used to assemble, compile and link the Bios modules. The
process is automated to permit a complete build with just a few keystrokes.

The Make File C-M

ONE
The Make File

The Make File is the top level file used in building a Bios. It includes all the
operations needed to compile and assemble the source files, to link them into a
code module, and to convert the code module into a binary image file for Prom
programming. This file will also build the utility programs needed for the build
process. Using the MAKE utility simplifies the operation and allows the building of
the Bios with just a few keystrokes.

# Copyright (c) 1988, 1989 FOSCO - Alt Rights Reserved

# Module Name: atbios.make
#

# Version: 1.00
#

# Author: FOSCO
#

# Date: 1-5-89

# Filename: at
#

# Functional Description:
#

# This is the Make file to build the AT Bios

# To Build the Bios, type 'make bios' <enter>
#

# Version History:
#

#

i^*********************************************^

# — inference rules - see description of MAKE utility

ibj: atprfx.
$*/U1/ZI/z;

.asm.obj: atprfx. inc
masm

.obj.exe:
link $*;

.c.obj: atkit.h
cl /Zp1 /J /WO /G2 /c /Zl /Zi /AS /Ox $*.c

# list of files to build

#--- These are utility routines used to build the Bios

# routine to fill up to top module

biosgen.exe: $*.c
cl /WO /Ox /Zi $*.c /link /Co

# routine to place date in binary file

biosdate.exe: $*.c
cl /WO /Ox /Zi $*.c /link /Co

# routine to place type byte in binary file

biostype.exe: $*.c
cl /WO /Ox /Zi $*.c /link /Co

# routine to checksum binary file

biossum.exe: $*.c
cl /WO /Ox /Zi $*.c /link /Co

# routine to display parenthesized text
parens.exe: $*.c

C-l-2 The Make File

cl /WO /Ox /Zi $*.c /link /Co

# routine to indent according to O

indent.exe: $*.c
cl /WO /Ox /Zi $*.c /link /Co

# routine to display comments

hi lite.exe: $*.c
cl /WO /Ox /Zi $*.c /link /Co

# routine to split out even/ odd bytes

splitbin.exe: $*.c
cl /WO /Ox /Zi $*.c /link /Co

# routine to merge in even/odd bytes (for test purposes)

mergebin.exe: $*.c
cl /WO /Ox /Zi $*.c /link /Co

# binary image to Intel hexadecimal filter

bin2hex.exe: $*.asm
masm $*;
link $*;

atpad.asm:
atpad.obj:

atdata.asm:
atdata.obj:

atprsc.obj:

atmem.obj:

atmisc.obj:

atboot.obj:

atvue.obj:

atcomm.obj:

atkb.obj:

atdisk.obj:

athard.obj:

atlpt.obj:

•- These are the Bios Modules

# routine to pad the front of the Bios

# the data declaration module for biosvue

# print screen driver

# memory size driver

# misc drivers in 'C

# bootstrap routine

# sys vue

# comm driver

# keyboard driver

# floppy disk driver

# hard disk driver

# Ipt driver

# crt driver

A-Tvpe BiosKit

The Make File C-l-3

atcrt.obj:

attmr.obj:

attod.obj:

atequi .obj:

atcass.obj:

atpod.obj:

atvirt.asm:
atvirt.obj:

attop.asm:
attop.obj:

# timer driver

# time of day driver

# equipment driver

# cassette driver

# power on diagnostics

# virtual mode driver

# absolutized high location module

# This is the linking process

# make binary file of bios

at. bin: \

atdisk.obj at I ink atkb.obj atvue.obj \
atcomm.obj at I pt. obj atcrt.obj atcut.inp \
atpod.obj at pad. obi" atdata.obj atvirt.obj \
at boot. obj atcass.obj atequi. obj attmr.obj \
atmisc.obj attop.obj at \
attod.obj atprsc.obj atmem.obj at hard. obj \
biostype.exe biosdate.exe biossum.exe biosgen.exe

copy atblank.inc atfill.inc

masm atfill:

link aatlink

biosgen at. map atfill.inc

masm atfill;

link /Co aatlink

debug otcut.inp

biosdate at. bin

biostype at. bin at

biossum at. bin

splitbin at

Section C: The Build Programs

Things I Forgot

The Link File C-2-1

TWO

The Link File

The Link File is an indirect file used by the linker to convert the group of bios — .obj
files into an executable (.EXE) file module. The EXE module will then be
converted to a binary image file for loading a prom programmer.

atpad+

atdata+

atpod+

atboot+

atcorniH-

atkb+

atdisk+

athard+

atlpt+

atcrt+

atequi+

atmenH-

attmr+

attod+

atprsc+

atcass+

atmisc+

atvue+

atvirt+

atfill+

attop,

at,

at/m;

Things I Remember

The Cut.inp File C-3-1

THREE
The CutJnp File

The Cut.inp is used after the second link to transform the .EXE file, which is output
by the linker, to a .BIN (binary image file). This type of operation is usually done by
using the DOS Utility "EXE2BIN", but ff EXE2BIN n cannot handle a full segment
.exe file.

****************************************************************************************************

*

* Copyright (c) FOSCO 1988, 1989 - All Rights Reserved

* Module Name: Cut of bios after second linking

*

* Version: 2.00

* Author: FOSCO

*

* Date: 1-5-89

*

* Filename: atcut.inp

*

* Functional Description:

*

* This input file is used to perform an exe -> bin load of the bios. exe file. Because it

* is a 64k file, the traditional exe2bin program overflows. This file directs that a

* 64 Kbyte output file (bios. bin) be written. This output file will be the binary image

* used for prom programming.

* Arguments:

*

* Return:

*

* Version History:

**************************************************************

nat.exe

I

rbx

1

rex

nat.bin

w cs:0

q

Things Someone Should Tell Me

SECTION D

The ASM Programs

These programs are used to include assembly language functions, tables, virtual
memory support, and initial start-up code for the Bios.

The Prfcinc File D-l-1

ONE
The Prfx.inc File

The Prfx.inc is the include file used for the assembly (.ASM) modules. It specifies
the memory model, macro definitions, segment loading order for the linker, and
required absolute offset locations for various data and code.

page 55,132

***************************************************************************************************

Copyright <c) FOSCO 1988 - All Rights Reserved

Module Name: AT Bios assembly module prefix

Version: 2.01

Author: FOSCO

Date: 01-01-89

F i I ename : bi osprf x . i nc

Functional Description:

This include file is used for the standard definitions for assembly language modules of the bios.

It is used to define the segment names, the segment loading sequence, assorted macros, and
location assignments.

Version History:
2.01 - Font revision

***********************************************

.286p
.seq

text segment word public 'code'
"text ends

data segment word public 'data'
^data ends

const segment word public 'const'
const ends

bss segment word public 'bss'
"bss ends

fill segment word public 'fill'
"fill ends

stack segment word stack 'stack'
"stack ends

_atext segment word public 'acode'
"atext ends

.model small,C

dgroup group text, data, const, bss, fill, atext
assume "cs: dgroup, ds: dgroup ~

.xlist

ok equ
error equ -1

; macros for Bios generation

delay macro

imp $+2
jmp $+2
endm

D-l-2 The Prfc.inc File

send eoi

macro

push

mov

out

delay

out

pop

endm

write cmos

~ push
push
call
add
endm

read cmos macro
push
call
add
endm

ax

al,20h
20h,al

0a0h,al
ax

macro address, value

value

address

out cmos

sp,4

address
address
i nemos
sp,2

true equ -1
false equ

; stack swappers for interrupt routines

int header

push

jmp

endm

macro dest
offset dest
interrupt shell

this 8088 version emulates the push immediate opcode

int header_88
push
push
mov
mov
xchg

pop
jmp
endm

macro dest ; this is the 8088 version

ax ; this saves ax on the stack

bp ; save bp while we access the stack

bp,sp ; use bp for a pointer

ax, offset dest ; ax - dest

ax, tbp+2] ; restore ax and put the dest on the stack

bx ; restore bp, leaving the dest

interrupt shell

required by MS C Compiler

This definition is required by the C Compiler.
The value was determined by looking the standard C libraries,
acrtused equ 9876h

; Bios Equates

dma

pitjxjrt
pi t _port~1
pit_port~2
pitjaort^cmnd

pio_port_a
pio_port""b
pio_port~c
pio_port~cmnd

segment 00
segment~00

equ

equ
equ
equ
equ

equ
equ
equ
equ

00

040h
041 h
042h
043h

060h
061 h
062h
063h

; dma channel addr reg port addr

8255 port a addr
8255 port b addr
8255 port c addr

segment at
ends

; comment /* rom bios data area */

segment 40
comm list dw
lpt_Tist dw

org

voffset
vsegment dw
vf lag

4 dup(?)
3 dup(?)

67h
dw
?
db

segment at 40h

org 078h
lpt_timeout_Iist db 4 dup(?)
comm timeout list db 4 dup(?)
segment 40 ends

macros used to indicate org conflicts

free=0
slop=0

A-Tvpe BiosKit

The Prfc.inc File D-l-3

romorg

aout

aaout

macro arg
i f def temp
temp=$
if 1

if ($ le (arg-OeOOOh)
3out «- »,<arg-OeO00h)-$,«
free=free+arg-$
else
aout «-
%out

slop=slop+$-(arg-0e000h)
end if

»,$-(arg-0e000h),«

bytes free»

bytes TOO LONG !!!!!»

end if

else

temp=$

endif

if 1

aout

«»,arg,«

endif

org

arg-OeOOOh

endm

macro

arg1,arg2,arg3

.radix 16

aaout

arg1,%(arg2),arg3

.radix

10

endm

macro

arg1,arg2,arg3

%out

argl arg2 arg3

endm

ORIGIN OF &arg»

Rom entry points
Unfortunately, these entry points need to be enforced since many users assume these to be fixed.
Even though it violates the PC rules, we have to live with it.

public
public
public

copyright
"reset
"nmi
Haoot

"comm table
"comnfio equ
"keyboard io
"keyboarcTisr
"disk io "equ
~disk"isr equ
~disk~parms
jar inter io

video io equ
"videojMrms
"mem size equ
"equipment
"cassette io
"video font
"time of day
"timer int
"vector
"dummy iret
jjrint"screen
"hard reset
~date~stamp
^hardware^id

.list

.data

.code

_print screen, keyboard io, keyboard isr, diskjo, disk_isr

video~io, cassette io,]j)rinter io, > _ : Pime_ > pf_day,_mem_size
"equipment7 comm io7 timer_int ~

equ

equ

equ

equ

equ

0e739h

equ

equ

0ec59h

0ef57h

equ

equ

0?065h

equ

Of 841 h

equ

equ

equ

equ

equ

equ

equ

equ

equ

equ

equ

OeOOOh
0e05bh
0e2c3h
0e6f2h
0e729h

0e82eh
0e987h

0efc7h
0efd2h

OfOaAh

0f84dh
0f859h
0fa6eh
0fe6eh
0fea5h
0fef3h
0ff53h
0ff54h
OfffOh
0fff5h
Offfeh

power on start
date stamp of bios
hardware ID byte

Section D: The ASM Programs

Things I Should Tell Someone

The Top File D-2-1

TWO

The Top File

The Top.asm File is an assembly language file which is linked so as to reside in the
top portion of the Bios segment. It is the module which responds to the power-on
hardware reset of the system. This module is where the execution of code starts, and
is used to reset critical peripheral functions and start Ram Refresh. A minimum
block of Ram is assigned to allow the use of a stack and then control is transferred
to the POD (Power On Diagnostics) routine. This module also contains the
assembly language support functions used by the Bios. The Bios ID and Copyright
ASCII text information, the CPU type byte, the Bios date-stamp, and the Bios
checksum byte are also in this module.

*************************************************************************^^

Copyright <c) FOSCO 1988, 1989 - All Rights Reserved
Module Name: AT Bios top of the segment assembly module
Version: 1.02
Author: FOSCO
Date: 10-18-89
Filename: attop.asm
Language MS MASM 5.1
Functional Description:

This module serves these purposes;

1. It provides the power-on jump at location FFFFO.

2. It starts the Ram refresh.

3. It allocates a stack.

4. It transfers flow to the power-on diagnostic module.

5. It holds assembly language functions

This module is linked as the final module in order for it to respond to the hardware reset
power- on jump.

Version History:
1.01
In the sense program for test bios' at D000 or E000, changed the lines (2 places) from:

cmp byte ptr ds:[DI+2],80h
to the following:

cmp byte ptr ds:[2],80h
because the inclusion of the DI index was unwanted. DI may or may not be = 0000
1.02

Deleted the test for a Bios at Segment E000
Added interrupt disable around the insw/outsw for the hard disk

rep in and rep_out functions.
Added stack" swap option for function call interrupts to minimize use of
callers stack space (for DOS 4.xx compatiblity)
Updated various modules (see modules for descriptions)

**************************************************************************

include atprfx.inc

extrn biospod:near ; pod module is a destination

extrn boot: near

extrn comm io:near

extrn keyboard io:near

extrn keyboarcTisr:near

extrn disk io:near

extrn disk~isr:near

extrn printer io:near

extrn video io:near

extrn mem size: near

extrn equipment: near

extrn cassette io:near

D-2-2 The Top File

extrn time of dayrnear

extrn timer i Fit: near

extrn print~screen:near

extrn watch~f lag: word

extrn syserror:far

extrn restart2:near

extrn restart5:near

extrn restart9:near

extrn restart10:near

public labels

public ver id

public biosMd

public name~id

public owner_id

public reset

public type byte

public date's tamp

publ
publ
publ
publ
publ
publ
publ
publ
publ
publ
publ

c comm list

c Ipt list

c coml timeout list

c Ipt Timeout Tist

c conTig table

c video Tont

c column table

c video Barms

c mode table

c hdislc table

c acrtused

a correct link may be confirmed by checking this label's location in the file Bios. map
;========== This is Bios Identification ===================

atext segment
~ assume cs:dgroup

org_E000 label byte

; There may be some programs sensitive to what bit pattern resides in this area. If so, this text
; area may be encoded as needed.

bios compat field label byte

d5 12 dup(Offh)

db 8ah

db 'IBMC

db 14 dup(Offh)

;========= This is part of the power up sequence =========

romorg reset
reset proc ~
jmp reseta

align 16

ver id label byte

db 'Version 1.02 ',0
bios id label byte
name'id label byte

db 'Annabooks AT BiosKit ',0
owner id label byte

db 'Copyright <c) FOSCO 1988, 1989 - All Rights Reserved ',0

; This ASCII field is intended to show the Copyright and even/odd identification when you are
; using 2 Proms to hold the Bios. If you examine (dump) the individual Proms, you will see a
; clear message, and will be able to discern whether it is the even or odd prom.

align 16

db 'CCooppyyrriigghhtt <(cc)> 11998888,, 11998899'

db ' FFO0SSCC0O -• AATT--BBIIOOSSKKIITT '

db '-- AAllll RRiigghhttss RReesseerrweedd ',00

align 16

db 'eovdedn ffiieelldd ',00

align 16

; Programmers Note:

A-Tvpe BiosKit

The Top File D-2-3

Ue have noticed some reset problems with some CPU boards. If the power-on voltage does not come
up cleanly and strongly, the 286 may not get a good reset. It seems that this sometimes happens
on loaded systems with marginal power supplies.

The reset signal to the CPU may not delay long enough before it rises through the threshold
voltage to allow the CPU to start. It also may pass through the indeterminate area (can't decide
whether it is a logic "0" or a logic "1") too slowly and break into oscillation.

Another problem area we have also seen is that the crystal or oscillator may not get started
consistently. If these problems are caused by hardware problems, there is little that the
software can do except try to execute some delay loops until things are stable.

If you experience problems in this area, a scope is handy for checking the sequencing of
the "power good" signal from the power supply, the oscillator circuits, and the waveform of
the reset signal. After that, an emulator may be required to help to pinpoint the problem.

From a software standpoint, inserting delay loops may be about the only thing you can attempt.

If you encounter, and especially if you solve a problem in this area, sharing your information
would be a generous gesture.

reset a:

cli ; disable interrupts

eld

mov al,80h ; disable nmi's

out 70h,al

; check for bios' patched in

; This patch checking sequence is a powerful development tool. You may link to a "test" Bios at
segment D000. It allows you to modify and test Bios',

while still retaining an operating Bios at segment F000. For more information, see the Chapter

on "The Patch. asm file".

If we find a Bios patch (by checking its signature), then we go to it.

mov ax,0d000h ; check seg dOOO first

mov ds,ax

emp word ptr ds:[0],05b1h

jne check? ; no bios here, continue

emp byte ptr ds:[2],80h

jne checkz ; no bios here, continue

mov ax,cs ; are we checking ourselves ?

emp ax,0d000h

je check2 ; yes, skip it

xor ex, ex ; set 64k count

xor al,al ; clear checksum

xor si, si ; clear index

checkl: ; do a checksum on the test bios

add al,ds:[si]

inc si

loop checkl

or al,al

jne check2

db Oeah ; jump to bios at dOOO

dw 00003h

dw OdOOOh
check2:

First, we need to check to see if this was a power- on start or a restart from virtual mode.

If it is a power-up start, then we will go through this startup and then go to BiosPod.

If it is a restart we will go to a particular restart routine.

in al,64h ; look at the 8742 status port
test al,04h ; test the power on condition flag
jnz 3F ; jump if not a power on start

; put valid restart code in croos Ofh

mov al.8fh ; prepare to clear cmos cell Of

out 70h,al ; select the address

delay

xor al.al

out 71h,al ; mark as valid power-up code

xor ax, ax
mov ds,ax
mov word ptr ds:[472h],0 ; reset warm boot flag

jmp power_on_start

SKD: ; determine type of restart

Section D: The ASM Programs

D-2-4 The Top File

aa:

aa:

aa:
aa:

aa:
aa:

aa:

mov

out

delay

in

or

jnz

jmp

cmp
jne

mov

out

delay

xor

out

jmp

cmp
jne

mov

out

delay

xor

out

jmp

cmp
jne

mov

out

delay

xor

out

jmp

cmp
jne

mov

out

delay

xor

out

jmp

al,8fh
70h\al

; prepare to read cmos cell Of
; select the address

; get the cmos contents

al,71h

al,al

S)F

powerjjn_start

al,02
3F

al.8fh
70h\al

al,al

71h,al

restart2 ; memory test return

al,05
3F

reset the restart code to "O"

reset the restart code to M 0"

al,8fh
70h,al

al.al

71h,al

restart5 ; jmp dword with interrupt

reset the restart code to "0"

block move return

al,09
3F

al,8fh
70h\al

al.al

71h,al

restart©

al,10
3F

al,8fh
70h,al

al.al

71h\al

restartlO ; jmp dword without interrupt

reset the restart code to "0"

; unsupported restart code
;-- save the restart code in case we want to display an invalid code
power_on_start:
; start the refresh timer

mov al,74h

out pit port cmnd,al

mov al,T8

out pit port 1,al

mov al,0

out pitj»rt_1,al

; save the warm boot flag while we clear the lower 64k

start the ram refresh timer

xor

mov
mov

ax, ax
es,ax
bp,es:[472h]

; make sure all repeats are in forward direction

eld
; cycle the ram memory to pre- charge the rams

xor
mov
mov
rep

mov
mov
mov
rep

ax, ax
di,0
cx,32768
stosw

ax,-1
di,0
ex, 32768

stosw

store zeroes

store ones

A-Tvpe BiosKit

The Top File D-2-5

xor
mov
mov
rep

mov
mov
mov
rep

ax, ax
di,0

ex ,32768
stosw

ax,-1
di,0
ex, 32768
stosw

; store zeroes
; store ones

do a quick ram test on the lower 64k
copy the bios to low ram

mov

si.OOOOh

mov

di,0000h

mov

ex, 32768

rep

movs

word ptr es:[di],word ptr cs:[si]

comp bios to low ram

mov

mov

mov

repz

mov

si.OOOOh
di,0000h
ex, 32768
emps
sp,cx

word ptr es:[di],word ptr es:[si]

; save ex - ex * * ok, else ram compare error

now do a ram clear on 64k - then proceed

ax, ax
ex, 32768
di ,di
stosw

xor
mov
xor
rep

mov es:[472h],bp ; restore the warm boot flag in its place
mov es:[415h],sp ; save the low ram test indicator

;-- now we can use 'C because we can have a stack Mi!

;--- set up the local stack - now we can use real calls —

ax, ax

;/"

xor
cli
mov
mov

from

ss,ax

sp,ax ; top of the sys_seg

here on we can use 'C because we have a stack */

reset

push cs

pop ds

jmp biospod
encip

'C wants ds = cs

The NMI routine may be expanded as desired. It resets the parity toggles and returns to
the interrupted program.

romorg

label

push

xor

out

in

or

out

and

out

pop

iret

nmi
Byte
ax

al.al
OaOh.al
al,61h
al,30h
61h.al
al.Ocfh
61h,al
ax

; disable nmi interrupts
; reset the nmi toggles

; This is where the hard disk table can reside. There is room for 60-70 entries as needed. You
; may modify these entries to support the disk types you desire.

hd tbl struc struc
hdrive~cyls dw ?
hdrive~heads db ?

" dw
hdrive_precomp dw ?

db
hdrive contrl db ?

" db
db

Section D: The ASM Programs

D-2-6 The Top File

db o
hdrive Indng dw ?
hdrive""sectors db ?

" db

hdj:bl_struc ends

drive type macro a1,a2,a3,a4,a5,a6,a7

hd tbl struc <a2,a3,0,a4,0,a5,0,0,0,a6,a7,0>
enchi

align 16

hdisk_table label byte

drive,
drive"
drive"
drive'
drive|
drive"
drive"
drive"
drive"
drive"
drive"
drive"
drive]
drive"
drive"
drive'
drive]
drive
drive"
drive
drive]
drive]
drive
drive
drive
drive
drive"
drive
drive]
drive
drive
drive
drive

.type b

.type 2,
.type 3,
.type 4,
.type 5,
.type 6,
.type 7,
.type 8,
.type 9.
type 10
"type 11
"type 12
"type 13
Itype 14
type 15
"type 16
"type 17
"type 18
"type 19
"type 20
"type 21
>ype 22
.type 23
.type 24
.tvpe 25
.type 26

- ty P* 11
.type 28
.type 29
type 30
Itype 31
.type 32
.type 33

306,

4

128

305,

615,

4

300

615,

615,

6

300

615,

940

8

512

940,

940

6

512

940,

615

4

-1

615,

462

8

256

511,

733

5

-1

733,

900

15

-1

8

901,

820,

3

-1

820,

855

5

-1

855,

855

7

-1

855,

306

8

128

319,

733,

7

-1

733,

0,

612

4

663,

977

5

300

977,

977

7

-1

977,

1024

► ,7

512

1023,

733

5

300

, 732,

733

7

300

733,

733

5

300

,0

733,

306

4

, 336,

612

4

305

,0

, 663,

306

4

-1

, 340,

612

4

, -1

,0

, 670,

698

7

r 300

,0

, 732,

976

5

,488

,0

r 977,

306

4

r

,0

, 340,

611

4

,306

,0

, 663,

732.

, 7

,300

,0

, 732,

102!

S,5

, -1

,0

,1023,

306

2

, -1

,0

r 305,

,17
,17
,17
,17
,17
,17
,17
,17
,17
,17
,17
,17
,17
,17
,
,17
,17
,17
,17
,17
,17
,17
,17
,17
,17
,17
,17
,17
,17
,17
,17
,17
,17

; The SysVue "TYPES" Command looks for this following
; entry to sense the end of the hard drive parameter table.
drive_type -1,-1,-1,-1,-1,-1,-1 ; end of table

; this function is used to reset the parity logic

reset_parity enables proc uses ax

in" al,61h ; reset the nmi toggles

or al.30h

out 61h,al

and al.Ocfh

out 61n,al

ret
r eset _par i ty_enabl es

endp

romorg
jmp

boot
Boot

This is the table referenced by the Int 15, Function CO
get system configuration parameters call.

config table label byte

" dw 8

db Ofch

db 01h

db

db 70h
db

; length of table in bytes

; model byte

; sub model byte

; bios level

; DMA 3, cascade 8259, rtc clock

4 dup(0); spares

romorg comm table
comm table label byte ~

dw 1047,768,384,192,96,48,24,12

romorg
jmp

_comm io
comm To

romorg _keyboard_io

A-Tvpe BiosKit

The Top File D-2-7

jmp keyboardjo

romorg keyboarder
jmp lceyboard_Tsr

romorg disk io

int_header~ ~ disk_io ; disk uses own stack

romorg disk isr
jmp 3isk_Tsr

; This is the default disk parameter table. The Biosdisk.c Module actually uses its own set
; of enhanced parameters to support the additional drive types available.

romorg disk_parms
fdisk table label byte

db 0dfh f 2,25h,2,0fh,1bh,0ffh,54h,0f6h,0fh,8

romorg jar inter io
jmp printer_To

romorg video io ; video uses own stack
int_header~ ~ video__io

romorg videojsarms
video _pa rms label byTe

db 38h, 40, 2dh, 10, 1fh,6,19h,1ch, 2, 7,6,7,0, 0,0,0
db 71h, 80, 5ah, 10, 1fh,6,19h,1ch, 2, 7,6,7,0, 0,0,0

db 38h,40,2dh,10,7fh,6,64h,70h, 2, 1.6.7,0.0.0.0
db 61h, 80, 52h, 15, 19h,6,19h,19h, 2, 13, 11, 12,6,6,0.0

; The length tabel is not used by bioscrt.c

; we include it in case some user thinks it exists.

length table label byte

~ dw 2048,4096,16384,16384

column table label byte

" db 40,40,80,80,40,40,80,80
mode table label byte

db 2ch,28h,2dh,29h,2ah,2eh,1eh,29h

;==== this large area is used for the asm routines ======

; This is used by the hard disk driver for data-in xfers

rep in proc uses es di ex dx, tseg: word, toff : word, port: word, count: word

mov dx,port

mov es,tseg

mov di , toff

mov ex, count

pushf ; save flags while disabling

cli

eld

rep insw

popf

ret
rep_in endp

; This is used by the hard disk driver for data-out xfers

rep out proc uses ds si ex dx,tseg:word,toff:word,port:word,count:word

mov dx.port

mov ds,tseg

mov si, toff

mov ex, count

pushf ; save flags while disabling

cli

eld

rep outsw

popf

ret
rep_out endp

; this is the ram test called by 'C

; This test is used in real-mode only.

/unsigned int ram_test(unsigned base, unsigned length)

; returns ok = 1
; returns error =

Section D: The ASM Programs

D-2-8 The Top File

mov

si, ok

ram test20:

xor

df ,di

mov

ex, test length

xor

ax, ax

rep

stosw

mov

ax, si

ret

ram test endp

; write and read bios pattern into 64k
ram test proc uses ex ds si es di,test_base:word,test_length:word
mov ex, test length
mov es,test~base
push cs
pop ds
eld

mov si.OOOOh

xor di,di ; set di =

rep movsw

mov si,0000h

xor di,di ; set di =

mov ex, test length

repe empsw

jcxz ram testIO
mov si, error
jmp short ram_test20
ram_test10: ~

jv si, ok

; set di =

; clear the block

; return the condition in ax

; This routine is used to re-locate the Bios -system- segment from the top of the 1st 64k segment
; (at power-on time) to the top of the System Ram at run-time.

move system segment proc uses ax ex dx ds si es di ( to seg:word,seg size: word
cTi ; disable interrupts because

I of moving the stack
mov es,to_seg ; destination segment

; calc the base segment address

move mm bytes
set di =

; reset the stack segment
; save dest segment for 40 :e
stack is top of 64k segment

; now clear the old segment
; set di =

; clear the old block

set new sys seg ptr

; re-enable interrupts

mov

ex, seg size

shr

ex, 4

mov

ax,1000h

sub

ax, ex

mov

ds.ax

mov

ex, seg size

xor

si, si

xor

di,di

rep

movs byte pi

mov

ax,es

mov

dx,ax

and

ax,0f000h ;

mov

ss,ax

mov

ax,ds

mov

es,ax

xor

di,di

mov

ex, seg size

xor

ax, ax ~

rep

stosb

mov

ax,40h

mov

ds,ax

mov

ds:[0eh],dx

sti

ret

move system segment endp

; unsigned int checksum( unsigned segment, unsigned length)

checksum proc uses bx ex ds,segptr: word, length arg:word

; get Ease address
; get count

mov

ds,segptr

mov

ex, length arg

xor

ax, ax

xor

bx,bx

S3: add

al,ds:[bx]

inc

bx

loop

SB

ret

checksum endp

point to next byte

A-Tvpe BiosKit

The Top File D-2-9

;-- this is the far call routine called by 'C rom scan --•

; void far_ca 1 1 (unsigned int segment, unsigned int address)

far call proc segptr: word, addr: word
LOCAL temp segment: word, temp offset: word
pushf ""

ds

es

segptr

temp segment

addr"

temp offset

dworH ptr [temp offset]

es

push a

push

push

push

pop L

push

8fc

pop

pop as

pop?
popf
ret
far_call endp

;-- this jump to boot passes the drive # in dl --

; boot_jump(seg, off, drive);

boot jump proc segptr:word,addr:word,drive:word
local temp_segment: word, temp_offset: word

get segment
get offset

push

push
pop
mov
jmp
boot jump endp

segptr

temp segment

addr""

temp offset

dx, drive

dword ptr [temp offset]

; get segment

; get offset

; beep routine

; void beep(void);

beep

beepIO:

33:

aa:

beep

proc uses ax bx ex dx

mov
mov
in
mov

and

out

mov

loop

or

out

mov

loop

dec

jnz

mov

out

ret

endp

bx,128
dx,pio_port b
al,dx
ah,al

al.Ofch
dx,al
ex, 64

as

al,2

dx,al

cx,64

SB

bx

beepIO

al,ah

dx,al

; 128 cycles last about 1/12 sec.
; save the 8255 port byte

; turn the beeper off
; make the duty cycle 50X

; turn the beeper on
; leave it on = to the off time

; count the major cycles down

; get the original port byte
; restore the 8255 to previous

seg_40_constant dw 40h

; void setds_system_segment(void);

setds system segment proc

~ mov ds,cs:seg 40 constant
mov ds,ds:[0en*]
ret
setds_system_segment endp

;-- this is used to set the OS to a specified value -•
; void setds (unsigned ptr);

setds proc seg_ptr:word

push seg_ptr

pop ds

ret
setds endp

;-- get the current stack segment value --
; unsigned get_ss(void);

Section D: The ASM Programs

D-2-10 The Top File

get ss proc

mov ax,ss

ret
get_ss endp

;-- test the specified watch flag bits —
; return true if set, false if not

; unsigned watch(unsigned);

watch proc uses ds, bits: word

call setds_system_segment

mov ax, bits ~

test ds: watch flag, ax

mov ax, false"

jz SF

mov ax, true
33: ret
watch endp

;-- this can be used to force a break while debugging -•

trap proc ; this can be used for hard breakpoint ing

int 18h ; goes to SysVue

ret
trap endp

; check to see if any key present at console device --
; returns true if a key waiting

kbhit proc ; returns true if any key hit

mov ax,0100h

int 16h

mov ax, false

jz SF

mov ax, true
aa:

ret
kbhit endp

;::==:=::=:: COHSOle In Routine ssstsisssssssss

; char ci(void);
ci proc

mov ax.

int 16h

ret
ci endp

;*====—=== block checksum routine =s=====s==sas=*/

; unsigned checksum bios block(void)
extrn bios_start:near

checksum_bios block proc uses bx ds,seg_eddr:word,off_addr:word

~ push" cs ~

pop ds ; set ds - cs to eliminate need for CS: overide

xor ax, ax ; clear accumulator

mov bx, offset bios start

33: add al,[bx]

inc bx ; exit at end of segment

jnz 3B

ret
checksum_bios_block endp

;*=sa====ssrs Console Out Routine s=ss=ss==ss=s*/

; console out routine
; co(char);

co proc uses ax bx. char: byte

mov ah.Oen

mov a I, char

mov bx,0

int 10h

ret
co endp

;--- calc the hdisk size - this uses some long unsigneds --

; unsigned calc hdisk size(cy Is, heads, sectors);

; returns a value in Ix in megabytes

; By doing this in ASM, the C Lib function is not needed.

calc_hdisk_size proc uses dx si, cy Is: word, heads: word, sectors: word

A-Tvpe BiosKit

The Top File D-2-11

xor

dx,dx

mov

ax,cyls

mov

si, heads

mul

si

mov

si .sectors

mul

si

mov

si, 2000

div

si

ret

calc hdisk size

endp

; this is used by the timer interrupt to chain to a user

timer chain

push
pop
int
ret

timer chain

proc uses ds

40h

ds

1ch

endp

; this chains the hard -> floppy disk without extra
; stack usage

fdisk chain

proc

mov

sp,b

pop

es

pop

ds

popa

int

40h

retf 2

fdisk chain

endp

discard the callers return address

; returns the high order word of an unsigned long integer as an unsigned in ax
; unsigned hi_regs( unsigned long)

fii regs proc
~ mov
ret
hi regs endp

low arg:word,high_arg:word
ax,Righ_arg

; long multiply for setting tod clock

; unsigned long I mul (unsigned long, unsigned)

I mul

I mul

proc

mov

mov

mov

mul

ret

endp

uses bx,ax arg:word,dx arg: word, bx_arg: word

dx,dx arg - - -

ax,ax~arg

bx,bx~arg

bx

convert binary
mov
mov
shr
and
aad
xor
ret

convert binary

proc
ax, arg
ah,al
ah, 4
al,0fh

ah, ah

endp

arg: word

; void bin2dec( value, return array[5]);
; the output array is in DST

bin2dec proc uses ax di si dx,value:word,array_ptr:word

mov di,array_ptr

mov byte ptr ds:[di+0],'

mov byte ptr ds:[di+1],'

mov byte ptr ds:Cdi+2],'

mov byte ptr ds:[di+33,'

mov byte ptr ds:[di+4],'0

mov byte ptr ds:tdi+5],0

aa:

string terminator char

add
mov

di,4
si, 10

mov
mov

ax, value
dx,0

div
add
mov
dec

si

dl,'0'
ds:[di],dl
di

or

ax, ax

Section D: The ASM Programs

D-2-12 The Top File

jnz ae

ret
bin2dec endp

; unsigned dec2bin( unsigned decval);

; the arg is max of 9999 decimal - ok for up to 8192k of extended memory

; the binary value is returned in ax

dec2bin proc uses dx di ex, decval: word

mov dx,0 ; clear accumulator

mov ax,0

mov dt',10 ; load multiplier

mov ex, 4 ; load loop count

33: mul di ; mul by ten

rol decval, 4 ; get next digit

mov bx, decval ; load to bx

and bx,000fh ; save only wanted digit

add ax,bx ; add to accumulated number

loop 38 ; do for all four digits

ret
dec2bin endp

; move string routine for alpha mode crt scrolling

; void move_row(unsigned segment, unsigned from_off set, unsigned to_offset, unsigned count)

move row proc uses ex si di es ds,segptr:word,from:word,to:word,count
~ ...... .^. . segmen t

; from
; to
; count

mov

ds,segptr

mov

es,segptr

mov

si, from

mov

di,to

mov

ex, count

eld

JCXZ

3F

rep

movsw

ret

as:

move_row endp

; clear row routine for alpha mode crt scrolling

; void c I ear_row( unsigned segment, unsigned address, unsigned count, unsigned fill)

clear row proc uses ax ex di es, segptr: word, addr: word, count: word, filler: word

; segment
; address
; count
; fill

mov

es, segptr

mov

di,addr

mov

ex, count

mov

ax,filler

eld

JCXZ

3F

rep

stosw

33: ret

elear_row endp

;-- move string routine for graphics mode crt scrolling

; void move_graphics_row( segment, fromj)ffset,to_offset, count)

move graphics row proc uses ex dx si di es ds,segptr:word,from:word,to:word,count:word

mov" dx,0 ; use dx to move tour lines each

move graphics rowS:

; segment

; from
; to
; count

aa:

aa:

mov

ds, segptr

mov

es, segptr

mov

si, from

mov

di,to

mov

ex, count

eld

add

si,dx

add

di,dx

jcxz

3F

rep

movsw

mov

si,Cbp+6]

mov
add

di , tbp+83
si,2000h

add

di,2000h

mov

ex, [bp+10]

eld

add

si,dx

add

di,dx

jcxz

3F

rep

movsw

add

dx,80

?mp

dx,320

jb

move_g raph i cs_row5

from

to

add for odd row

add for odd row

count

A-Tvpe BiosKit

The Top File D-2-13

ret
move_graphics_row endp

; clear row routine for alpha mode crt scrolling

; void c I ear_graphics_row< segment, address, count, fill)

clear graphics row proc uses ax ex dx di es,segptr:word,addr:word,count:word,filler:word
mov ~ dx,0 ; use dx to clear four lines each

clear graphics row5:

~ mov ~ es,segptr

mov di,addr

mov ex, count

mov ax,filler

eld

add di,dx

jcxz SF

rep stosw

33: mov di,[bp+6]

add di,2000h

mov ex, [bp+8]

mov ax, [bp+10]

add di,dx

eld

jcxz 3F

rep stosw

33: add dx,80

emp dx,320

jb clear graphics row5

ret
clear graphics row endp

segment
address
count
fill

address

add for odd row

count

fill

low level routines for 'C

; this version assumes the regs are in the system segment, note that it also requires a

; slightly different regs structure than int86 or int86x because it always passes es and ds.

axoff equ 4

exoff equ 6

dxoff equ 8

sioff equ 10

dioff equ 12

bpoff equ 14

bxoff equ 16

dsoff equ 18

esoff equ 20

floff equ 22

jmp off equ 24

jmp'seg equ 26
code_string_location equ 28

; void sys_int(char number, reg_block);

code string proc far

Ids bx,cs: [bx+bxoff]

int
number offset = $-code string-1

ret ""
code string length = $-code string
code~string~ endp ~

sys_int proc uses si di ax bx ex dx es ds, number : word, regs_block: word
mov bx,regs_block

; move the code string image

; get count of bytes to move
mov ex, code string length

; point~to org~of code string
mov si. offset code string ~

; build ptr to'desti nation
mov di,bx
add di, off set code string location

; set segment Tor destination
push ds
pop es

; now do the copy
rep movs byte ptr es:tdi], byte ptr cs:Csi]

; load the correct interrupt number
mov ax, number
mov [bx+code string location+number offset], al

Section D: The ASM Programs

D-2-14 The Top File

; load the jump vector
mov word ptr [bx+jmp off],code_string location
add [bx+jmp off] ,bx "
mov [bx+jmp~seg],ds

; load the registers

mov ax, [bx+axof f]

mov ex, [bx+exof f]

mov dx, [bx+dxof f]

mov si, [bx+sioff]

mov di,[bx+dioff]

mov es, [bx+esoff]

: save the real bp for the implied LEAVE instruction
push op
mov bp, [bx+bpof f]
push ds
push bx
call dword ptr ds:[bx+jmp_off]

now we have to swap out ds:bx with the stack-saved ones

push bx ; save returned ds:bx

push ds

push bp ; save bp - will be used as ptr

mov bp, s

;?Ep*61 ;

Ids bx, [bp+61 ; re- load myblock ds:bx

pop ds: [bx+bpof f] ; restore returned bp

pop ds: [bx+dsoff]

pop ds: [bx+bxoff]

pop bp ; discard old ds:bx slots

pop bp ; without affecting flags

; bp is now pre- interrupt value

pop bp

; store the registers

mov [bx+esoff ],es

mov [bx+axof f] ,ax

mov [bx+cxoff],cx

mov [bx+dxof f] ,dx

mov [bx+sioff] ,si

mov [bx+dioff],di

pushf ; save flags

pop [bx+floff]

ret
sys_int endp

; SysErr routine puts an error code in ax, then goes to sysvue -- This is an expansion feature
; you may wish to implement.

sys err proc uses ax,error_code:word

mov ax, error code"

pushf

call syserror

ret
sys_err endp

get vector returns the selected vector in OX: AX.
This routine is done in assembly language because a 'C
routine would need the library long shirt function to
build the seg:off into DX:AX.

; unsigned long get_vector(char number);
get_vector proc uses bx es, number: word

xor

bx,bx

mov

es,bx

mov

bx, number

xor

bh,bh

shl

bx,1

shl

bx,1

cli

mov

dx,es:[bx]+2

mov

ax,es:[bx]

sti

ret

:_vector endp

:ds proc

int #

; mul by 4

A-Tvpe BiosKit

The Top File D-2-15

mov ax,ds
ret
getds endp

; return the bios code segment value in AX.

; This function is coded this way so the Bios may be operated at segments other than F000.

; unsigned bios_cs(void);

bios cs proc

mov ax,cs

ret
bios_cs endp

; Disable interrupts

; void disable(void);

disable proc

cli

ret
disable endp

; Enable interrupts

; void enable(void);

enable proc

sti

ret
enable endp

; void del ay (unsigned res, unsigned count);

res == - delay in useconds

res != - use as milliseconds resolution

count = count

delay_call proc uses ax ex dx ds, res: word, count: word

emp
jnz

micro delay:
"" mov
xor
mov
div
add
mov

33: in
and
emp
je
mov
loop
ret

mi Hi delay:
~ mov

mi Hi major:

push
mov

33: call
loop
pop
loop
ret

delay_call

read timer count
~ xor

aa
aa
aa

aa:
aa-.
aa:

out

imp

l*Q

jmp

in

mov

imp

jmp

jmp

in

xchg

res.O
milli_delay

ax, count
dx,dx
ex, 15
ex

ax, 2
ex, ax

al,61h

al,10h

ah,al

38

ah,al

38

ex, count

micro seconds delay

this has 15 usee resolution

each toggle of the refresh bit is 15 usees

now ex = count/15

make sure we have at least 15-30 usees min.

ex will be a loop count

get port b refresh bit
save only the bit we want

now use current state
wait n times

; res argument - # of mi 1 1 is resolution
this is major loop

ex

ex. res

delay a mi Hi

38

ex

millijnajor

endp

; this is minor loop

; wait for resolution counts

; repeat major loop for total counts

proc

al,al

43h,al

3F

3F

3F

al,40h

ah,al

3F

3F

3F

al,40h

ah,al

each count = .8 usees

; latch timer count into storage register

; delay for 8253 response

; delay for 8253 response

Section D: The ASM Programs

D-2-16 The Top File

ret
read timer count

endp

return count in ax

; Note: Remember that the counters in the 8253/8254 are down counters,
; so that we have to subtract the desired count from the current count.

delay a mi Hi
~ ~ call
call
mov
sub
cmp
jb
mov
not
call
cmp
jae
ret

delay a milli

33:

proc uses ex

read timer count

reacTt imer""count

ex, ax ""

ex, 1250

ex, ax

3F

ex, ax

ex

read timer count

ax, ex

as

endp

; delay 1 millisecond

; do a double read

; since count rate is 1.19 Mhz, about

; 1250 timer counts * 1 millisecond

; delay count > current count, no rollover

; use delay based from zero if rollover

; delay until current count >= calced count

get_offset

push
ret

proc ; this function is used to retrun the callers offset

ax ; it pops the callers address into ax

ax ; puts it back so it can be used for the ret instruction

get_offset endp

;--- These are additional peek and poke functions

; unsigned peek40( unsigned offset);

peek40 proc uses bx es,offptr:word

mov bx,40h

mov es,bx

mov bx,offptr

mov ax,es:[bx]

ret
peek40 endp

; char peekb40(unsigned offset);

peekb40 proc uses bx es. of fptr: word

mov bx,40h

mov es,bx

mov bx,offptr

mov al,es:[bx]

xor ah, ah

ret
peekb40 endp

; char peekbcs( unsigned offset);

peekbes proc uses bx, of fptr: word

mov bx, of fptr

mov al,cs:[bx]

xor ah, ah

ret
peekbes endp

; unsigned peekcs( unsigned offset);

peekes proc uses bx,offptr:word

mov bx,offptr

mov ax,cs:[bx]

ret
peekes endp

; void pokeb40( unsigned offset, char value);

pokeb40 proc uses ax bx es,offptr:word,value:word

mov bx,40h

mov es,bx

mov bx, of fptr

mov ax, value

mov es:[bx],al

ret
pokeb40 endp

; void poke40(unsigned offset, unsigned value);

poke40 proc uses ax bx es, of fptr: word, value: word
mov bx,40n
mov es,bx
mov bx, of fptr
mov ax, value

peeks in segment 40h

A-Tvpe BiosKit

The Top File D-2-17

mov es:[bx],ax
ret
poke40 endp

; void andb40< unsigned offset, char value);

andb40 proc uses ax bx es, of fptr: word, value: word

mov bx,40h

mov es,bx

mov bx,offptr

mov ax, value

and es:[bx],al

ret
andb40 endp

; void and40( unsigned offset, unsigned value);

and40 proc uses ax bx es,offptr:word,value;word

mov bx,40h

mov es,bx

mov bx, of fptr

mov ax, value

and es:[bx],ax

ret
and40 endp

; void orb40( unsigned offset, char value);

orb40 proc uses ax bx es, of fptr: word, value: word

mov bx,40h

mov es,bx

mov bx, of fptr

mov ax, value

or es:[bx],al

ret
orb40 endp

; void xorb40(unsigned offset, char value);

xorb40 proc uses ax bx es.offpt^word.value^ord

mov bx,40n

mov es,bx

mov bx, of fptr

mov ax, value

xor es:[bx],al

ret
xorb40 endp

;--- These are the standard peeks, pokes, ins, and outs

; unsigned peek (unsigned segment, unsigned offset)

peek proc uses bx es,segptr:word,offptr:word

mov es.segptr

mov bx, of fptr

mov ax,es:[bx]

ret
peek endp

; void poke( segment, offset, value);

poke proc uses ax bx es,segptr:word,offptr:word,value:word

mov es,segptr

mov bx, of fptr

mov ax, value

mov es:[bx],ax

ret
poke endp

; char peekb( unsigned segment, unsigned offset);

peekb proc uses bx es,segptr:word,offptr:word

mov es,segptr

mov bx, of fptr

mov al,es:[bx]

xor ah, ah

ret
peekb endp

; void pokeb( unsigned segment, unsigned offset, char value);

pokeb proc uses ax bx es,segptr:word,offptr:word,value:word
mov es,segptr
mov bx, of fptr
mov ax, value
mov es:Cbx],al

Section D: The ASM Programs

D-2-18 The Top File

ret
pokeb endp

; unsigned inport( unsigned port);

inport proc uses dx, port: word

mov dx,port

in ax,dx

ret
inport endp

; void outport(unsigned port, unsigned value);

outport proc uses dx ax,port:word,value:word

mov dx,port

mov ax, value

out dx,ax

ret
outport endp

; char inportb( unsigned port);

inportb proc uses dx, port: word

mov dx,port

in al,dx

xor ah, ah

ret
inportb endp

; void outportb(unsigned port, char value);

outportb proc uses ax dx, port: word, value: word

mov dx.port

mov ax, value

out dx,al

ret
outportb endp

cstods proc ; set ds = to cs

push cs

pop ds

ret
cstods endp

Sdummy isr proc

send eoi

iret -
$dummy_isr endp

$iret proc

iret

$iret endp

- Stack swapper for interrupt routines - (see intjieader macro) ---

•- Typically code written in C may use more stack space then

•- tweaked assembly language code. Intermediate variables created

- by using "for" and "while" loops may be assigned to the stack.
•- Also the use of the "Interrupt" declaration for Interrupt
•- service routines causes all the registers to be pushed on the
•- stack. Normally this does not cause problems, because user or
-- application declared stacks are usually large enough to be safe.
■- However, there are some instances where a program ignores the user
■- declared stack (PC-DOS 3.xx VDISK) or system software (PC/MS 4.xx
■- 10. SYS) sets a very tight stack, which will run with most (but not all)
■- BIOS' written in assembly. (The more curious among us may have
■- already discovered the phrase "may run on some PC and XT machines",
■- in the DOS 4.xx manuals).

■- Starting with DOS 3.xx, the "stackss^y* command has been included

■- for CONFIG.SYS use to set up a stack pool for swapping stacks on

•- the hardware (caused through the 8259 interrupt control ler(s)) interrupts.

- This alleviated some stack overflow problems encountered when
■- running true IBM PC-DOS on true IBM hardware. So it wasn't an error

- committed either by the 3rd party clone or BIOS creators. It simply

- was a result of the programming style used in writing the DOS.
•- Microsoft is currently the most prominent "bender" of the rules
■- (previously IBM possessed the leverage) and we (as well as Intel)
■- are forced to conform. The code below implements a stack swapping
■- mechanism for use by Function Call Interrupts by creating a stack
■- in the system segment ram area for the desired function call.
■- The swap occurs before the Interrupt Service Routine is called.
-- allowing all the user registers to be pushed onto the new stack.
■- This limits user stack usage and seems to solve the problems.

A-Tvpe BiosKit

The Top File D-2-19

Example of usage:

A non- swapped interrupt -

Vector > cdecl far interrupt sample(interrupt_registers)

A swapped interrupt -

Vector > push dest

jmp interrupt shell

. (swap to system stack)

. > cdecl far interrupt sample(interrupt_registers)

.< .

. (restore to callers stack)

The code below is entered with destination address on the stack
push dest
jmp interrupt_shell

extrn bx save: word, ds save: word, dest save: word
extrn ss~save:word,sp~save: word, length mark: word
extrn current_open:word,endJ>lock:worcT

size_requested equ 256 ; default standard size

interrupt_shell proc

push ds

push bx

mov bx,0

mov ds,bx

entered with interrupts disabled as a
result of the previous Int xx opcode.

aa:

mov ds,ds: [040eh] ; get system segment

pop bx save ; sys:xx

pop ds'save ; sys:xx+2

pop dest save ; sys:xx+4

mov bx, cur rent open

pushf ~ ; save callers flag state

add bx,size requested ; check for space available

cmp bx,end Block

jb 3F ~ ; jump if enough space

popf ; use current stack, jump to isr service

push dest save

Ids bx,dword ptr ds:[bx save] ; restore ds:bx to callers values

ret

mov bx, current open ; get base address of block

add current open, size requested

popf

; mark the block "in use 11

mov ds: [bx+ length mark], size requested

mov ds:[bx+ss save],ss ; save the caller stack pointers

mov ds:[bx+sp~save],sp ; in the allocated stack block

mov sp,ds ~

mov ss,sp

mov sp,ds:[current_open] ; set sp at top of new block

pushf

push cs

push offset continue ; set up phony interrupt call

push dest save ; set destination address

Ids bx,dword ptr ds:[bx_save] ; restore ds:bx to callers values

ret ; go to dest with phnoy call

continue:

push bx

push ds

mov bx,0

mov ds,bx

mov ds,ds:[40eh]

pop ds save

pop bx~save

pushf

sub ds: [current open], size requested

popf

Section D: The ASM Programs

D-2-20 The Top File

mov bx, current open

mov ss,ds:[bx+ss save] ; get the callers stack description

mov sp,ds: [bx+sp~save]

mov ds: [bx+ length" mark],0 ; mark the block as free

Ids bx.dword ptr 3s: [bx save]

retf
inter rupt_shell

2

endp

; return with cuurent flags
;============== end of the asm routines ===================

romorg mem size
jmp memjsize

romorg ^equipment
jmp equipment

romorg cassette io

int header"" "cassette io

cassette uses own stack

romorg video font
video font label byte

; ~ These are the bit -mapped characters for the graphics mode. They must be here
; because some user software uses these for generating characters in graphics mode.

db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db

OOOh
07eh
07eh
(tech
01 Oh
038h
01 Oh
OOOh
Offh
OOOh
Offh
OOfh
03ch
03fh
07fh
099h
080h
002h
018h
066h
07fh
03eh
OOOh
018h
018h
018h
OOOh
OOOh
OOOh
OOOh
OOOh
OOOh
OOOh
030h
06ch
06ch
030h
OOOh
038h
060h
018h
060h
OOOh
OOOh
OOOh
OOOh
OOOh
006h
07ch
030h
078h
078h
01 ch
Ofch
038h
Ofch
078h
078h
OOOh
OOOh
018h

,000h
,081h
,0ffh
.Of eh
,038h
,07ch
.010h
,000h
,0ffh
,03ch
,0c3h
,007h
,066h
,033h
,063h
,05ah
,0e0h
,00eh
,03ch
,066h
,0dbh
.063h
,000h
,03ch
,03ch
,018h
,018h
,030h
,000h
,024h
,018h
,0ffh
,000h
,078h
,06ch
,06ch
,07ch
,0c6h
,06ch
,060h
,030h
,030h
,066h
,030h
,000h
,000h
,000h
,00ch
,0c6h
,070h
,0cch
.Occh
,03ch
.OcOh
,060h
.Occh
.Occh
,0cch
,030h
,030h
,030h

,000h
,0a5h
,0dbh
,0f eh
,07ch
,038h
,038h
,018h
,0e7h
,066h
,099h
.OOfh
,066h
.03fh
,07fh
,03ch
.0f8h
,03eh
.07eh
,066h
,0dbh
,038h
,000h
,07eh
.07eh
,018h
,00ch
,060h
,0c0h
,066h
,03ch
,0ffh
,000h
,078h
,06ch
,0feh
.OcOh
,0cch
,038h
,0c0h
,060h
# 018h
,03ch
,030h
,000h
,000h
,000h
,018h
# 0ceh
,030h
,00ch
,00ch
,06ch
,0f8h
,0c0h
,00ch
,0cch
,0cch
,030h
,030h
,060h

,000h
,081h
,0ffh
f 0feh
,0feh
,0feh
,07ch
,03ch
,0c3h
,042h
,0bdh
,07dh
,066h
,030h
,063h
,0e7h
,0feh
,0feh
,018h
,066h
,07bh
,06ch
,000h
,018h
,018h
f 018h
,0feh
,0feh
f 0c0h
,0ffh
,07eh
,07eh
,000h
,030h
,000h
,06ch
,078h
,018h
,076h
,000h
,060h
,018h
,0ffh
.Ofch
,000h
# 0fch
,000h
,030h
,0deh
,030h
,038h
,038h
.Occh
,00ch
,0f8h
,018h
,078h
,07ch
,000h
.OOOh
.OcOh

.OOOh
,0bdh
,0c3h
,07ch
,07ch
,0feh
,0f eh
,03ch
,0c3h
,042h
,0bdh
.Occh
.03ch
,030h
,06eh
,0e7h
,0f8h
,03eh
,018h
,066h
,01bh
,06ch
,07eh
,07eh
,018h
,07eh
,00ch
,060h
.OcOh
,066h
,0ffh
,03ch
,000h
,030h
,000h
,0f eh
,00ch
,030h
.Odch
.OOOh
,060h
.018h
.03ch
,030h
,000h
.OOOh
.OOOh
,060h
,0f6h
,030h
,060h
.OOch
,0feh
.OOch
.Occh
,030h
,0cch
.OOch
,000h
.OOOh
.060h

,000h
,099h
,0e7h
.038h
,038h
,07ch
,07ch
,018h
,0e7h
,066h
,099h
,0cch
,018h
,070h
,067h
,03ch
,0e0h
,00eh
,07eh
.OOOh
,01bh
,038h
,07eh
,03ch
,018h
,03ch
,018h
,030h
.Of eh
,024h
,0ffh
,018h
,000h
.OOOh
,000h
,06ch
,0f8h
,066h
.Occh
,000h
,030h
,030h
,066h
,030h
,030h
.OOOh
,030h
.OcOh
.0e6h
,030h
,0cch
,0cch
.OOch
,0cch
.Occh
,030h
.Occh
,018h
,030h
,030h
,030h

,000h
.081h
,0ffh
,010h
.01 Oh
,038h
,038h
,000h
.Offh
,03ch
,0c3h
.Occh
,07eh
,0f0h
,0e6h
,05ah
,080h
,002h
,03ch
,066h
,01bh
,0cch
,07eh
,018h
,018h
,018h
,000h
,000h
,000h
.OOOh
.OOOh
.OOOh
,000h
.030h
.OOOh
,06ch
,030h
,0c6h
,076h
.OOOh
,018h
.060h
,0O0h
,000h
.030h
.OOOh
,030h
.080h
,07ch
,0fch
,0fch
,078h
,01eh
,078h
,078h
,030h
.078h
,070h
,030h
,030h
,018h

,000h
,07eh
,07eh
,000h
,000h
.07ch
,07ch
.OOOh
.Offh
.OOOh
.Offh
,078h
.018h
,0e0h
.OcOh
,099h
.OOOh
,000h
,018h
.OOOh
,000h
,078h
.OOOh
,0ffh
,000h
,000h
.OOOh
.OOOh
,000h
,000h
.OOOh
.OOOh
,000h
,000h
,000h
.OOOh
.OOOh
.OOOh
,000h
.OOOh
.OOOh
.OOOh
.OOOh
,000h
,060h
,000h
,000h
.OOOh
.OOOh
.OOOh
.OOOh
,000h
,000h
.OOOh
.OOOh
.OOOh
,000h
.OOOh
,000h
,060h
.OOOh

00 - nul

01 - A A

02 - A B

03 - A C

04 - A

05 - A E

06 - A F

07 - A G

08 - A H

09 - A I
OA - A J
OB - A K
OC - A L
00 - A M
OE - A M
OF - A

10 - A P

11 - A Q

12 - A R

13 - A S

14 - A T

15 - A U

16 - A V

17 - A U

18 - A X

19 - A Y
1A - A Z
1B - A [
1C - A \
1D - A ]
1E - A 6
1F - A -

20 - spc

21 - I

22 - M

23 - #

24 - $

25 - X

26 - &

27 - '

28 - <

29 - )
2A - *
2B - +

IS" '
2D - -

2E - .

2F - /

30 -

31 - 1

32 - 2

33 - 3

34 - 4

35 - 5

36 - 6

37 - 7

38 - 8

39 - 9
3A - :
3B - ;
3C - <

A-Tvpe BiosKit

The Top File D-2-21

db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db
db

romorg
jmp

romorg
jmp

romorg
iret

OOOh
060h
078h
07ch
030h
Ofch
03ch
0f8h
Ofeh
Ofeh
03ch
Occh
078h
01eh
0e6h
OfOh
Ocoh
0c6h
038h
Ofch
078h
Ofch
078h
Ofch
Occh
Occh
0c6h
0c6h
Occh
Ofeh
078h
OcOh
078h
010h
OOOh
030h
OOOh
OeOh
OOOh
01ch
OOOh
038h
OOOh
OeOh
030h
OOch
OeOh
070h
OOOh
OOOh
OOOh
OOOh
OOOh
OOOh
OOOh
010h
OOOh
OOOh
OOOh
OOOh
OOOh
OOOh
01 ch
018h
OeOh
076h
OOOh

,000h
,030h
,Occh
,0c6h
,078h
,066h
,066h
,06ch
,062h
,062h
,066h
,Occh
,030h
,00ch
,066h
,060h
,Oeeh
,0e6h
,06ch
,066h
.Occh
,066h
,Occh
,0b4h
r Occh
,Occh
,0c6h
,0c6h
,Occh
,0c6h
,060h
,060h
,018h
,038h
,000h
,030h
,000h
,060h
,000h
,00ch
,000h
,06ch
,000h
,060h
,000h
,000h
,060h
,030h
,000h
,000h
,000h
,000h
,000h
,000h
,000h
,030h
,000h
,000h
,000h
,000h
,000h
,000h
,030h
,018h
,030h
,Odch
,010h

.Ofch
,018h
,00ch
,Odeh
.Occh
,066h
,0c0h
,066h
,068h
,068h
,OcOh
.Occh
,030h
,00ch
,06ch
,060h
,Ofeh
,0f6h
,0c6h
,066h
.Occh
,066h
,OeOh
,030h
,Occh
.Occh
,0c6h
,06ch
.Occh
,08ch
,060h
,030h
,018h
,06ch
,000h
,018h
,078h
,060h
,078h
,00ch
,078h
,060h
,076h
,06ch
,070h
,00ch
,066h
,030h
.Occh
,0f8h
,078h
,Odch
,076h
,Odch
,07ch
,07ch
,Occh
.Occh
,0c6h
,0c6h
.Occh
,Ofch
,030h
,018h
,030h
,000h
,038h

,000h
,00ch
,018h
,Odeh
.Occh
,07ch
,0c0h
,066h
,078h
,078h
,0c0h
,Ofch
,030h
,00ch
,078h
,060h
,Ofeh
,0deh
,0c6h
,07ch
.Occh
,07ch
,070h
,030h
,Occh
.Occh
,0d6h
,038h
,078h
,018h
,060h
,018h
,018h
,0c6h
,000h
,000h
,00ch
,07ch
f Occh
,07ch
.Occh
f 0f0h
,Occh
,076h
,030h
,00ch
,06ch
,030h
,Ofeh
,Occh
.Occh
,066h
.Occh
,076h
,OcOh
,030h
,0cch
,0cch
,0d6h
,06ch
,Occh
,098h
,OeOh
,000h
,01ch
,000h
,06ch

,000h
,018h
,030h
,Odeh
,Ofch
,066h
,0c0h
r 066h
,068h
,068h
,Oceh
.Occh
,030h
.Occh
,06ch
,062h
,0d6h
,Oceh
,0c6h
,060h
,Odch
,06ch
,01ch
,030h
,Occh
.Occh
,Ofeh
,038h
,030h
,032h
,060h
,00ch
,018h
,000h
,000h
,000h
,07ch
,066h
f OcOh
,Occh
,Ofch
,060h
.Occh
,066h
,030h
,00ch
,078h
,030h
,Ofeh
,Occh
.Occh
,066h
.Occh
,066h
,078h
,030h
,Occh
.Occh
,Ofeh
,038h
.Occh
,030h
,030h
f 018h
,030h
,000h
,0c6h

,0fch
,030h
,000h
,OcOh
.Occh
,066h
,066h
,06ch
,062h
,060h
,066h
.Occh
,030h
,Occh
,066h
,066h
,0c6h
,0c6h
,06ch
,060h
f 078h
,066h
.Occh
,030h
,Occh
,078h
,Oeeh
,06ch
,030h
,066h
,060h
,006h
,018h
,000h
,000h
,000h
,Occh
,066h
,Occh
.Occh
,OcOh
,060h
,07ch
,066h
,030h
.Occh
,06ch
,030h
,0d6h
,Occh
.Occh
,07ch
,07ch
,060h
,00ch
,034h
.Occh
f 078h
,Ofeh
,06ch
,07ch
,064h
,030h
,018h
,030h
,000h
,0c6h

,000h
,060h
,030h
,078h
.Occh
,Ofch
,03ch
,0f8h
,Ofeh
,OfOh
,03eh
,Occh
,078h
,078h
,0e6h
,Ofeh
,0c6h
,0c6h
,038h
,0f0h
,01ch
,0e6h
,078h
# 078h
,Ofch
,030h
( 0c6h
,0c6h
,078h
,Ofeh
,078h
,002h
,078h
,000h
,000h
,000h
# 076h
f 0dch
,078h
,076h
,078h
,0f0h
,00ch
,0e6h
# 078h
.Occh
f 0e6h
,078h
,0c6h
.Occh
# 078h
( 060h
f 00ch
f 0f0h
f 0f8h
,018h
,076h
,030h
,06ch
,0c6h
,00ch
,Ofch
,01ch
,018h
,OeOh
,000h
f Ofeh

,000h
,000h
,000h
,000h
,000h
,000h
,000h
,000h
,000h
,000h
,000h
,000h
,000h
,000h
,000h
f 000h
f 000h
,000h
,000h
,000h
f 000h
,000h
f 000h
,000h
,000h
,000h
,000h
,000h
t 000h
,000h
,000h
,000h
,000h
# 000h
# Offh
,000h
,000h
,000h
,000h
,000h
,000h
,000h
,0f8h
,000h
,000h
,078h
,000h
,000h
,000h
,000h
,000h
,0f0h
f 01eh
,000h
,000h
,000h
,000h
,000h
,000h
,000h
,0f8h
,000h
,000h
,000h
,000h
,000h
,000h

time of day
7ime_of_aay

timer int
7imer_Tnt

__dummy_i ret

3D - -
3E - >

3F - ?

40 - S

41 - A

42 - B

43 - C

44 - D

45 - E

46 - F

47 - G

48 - H

49
4A
4B
4C
4D
4E

4F -

50 - P

51 - Q

52 - R

53 - S

54 - T

55 - U

56 - V

57 - U

58 - X

59 - Y
5A - Z
5B - [
5C - \
50 - ]
5E - *
5F -

60 - T

61 - a

62 - b

63 - c

64 - d

65 - e

66 - f

67 - g

68 - h

69 - i
6A - i
6B - k

6C
60
6E
6F
70
71

72 - r

73 - s

74
75
76
77
78
79 - y

romorg _print screen
intjieader print~screen

; print screen uses own stack

abort string label byte

13,10, 'WARMING - This program cannot be executed under DOS. ',13, 10,'$'

abort:

db

push
pop

; if this program is started by dos, we display a message and abort
cs

Section D: The ASM Programs

D-2-22 The Top File

mov dx, offset abort string

mov ax.0900h

int 21h ; print string

mov ax,4c00h

int 21h ; exit to DOS

;ss== this is the hardware entry point after a reset ==«

romorg hard reset

starting point:

db

Oeah

dw

0e05bh

dw

OfOOOh

;=== This is the standard location for the date-stamp »«»

romorg date stamp
date stamp label byte ~

db '--/--/--',

; These locations are loaded with the current date by biosdate during the build process.

;======== This is the CPU type byte ====«*====«

type byte label byte
db

; This location is loaded with the type byte value by bios type during the build process.

;=== This is where the Bios checksum value is stored «*=««

db

; This location is loaded with the calculated checksum by biossum during the build process.
_atext ends

end abort

A-Tvpe BiosKit

The Pad File D-3-1

THREE
The Pad File

The Pad.asm File is an assembly language file used to assign the starting offset of
the Bios to a location greater than 0000 in the segment. If it is desired to reserve
space at the beginning of the Bios segment for optional rom-scan modules, or to
reduce the size of the Bios to less than 64 Kbytes in order to use a smaller-size
prom, the biospad module is used to declare the Bios starting offset. A signature is
placed at the beginning of this module to facilitate the detection of secondary and
test Bios'. The signature is a representation of the word "bios" expressed by the
hexadecimal characters "bl05".
*******************************************************************

Copyright (c) FOSCO 1988 - All Rights Reserved

Module Name: AT Bios pad out the front of the bios

Version: 1.00

Author: FOSCO

Date: 12-01-88

Filename: atpad.asm

Functional Description:

This module is used to fill out the front of the bios prom when a less than 64k bios is desired.
The linker always generates a 64k binary image module. The unused locations are preset to all
ones (FF) so that prom programmers may skip over these locations. This leaves them unused
and available for merging in optional rom-scan modules for an extended custom Bios.

Version History:

**************************************************************************************************

include atprfx.inc

.code

extrn reset: near

bios start proc

dw 05b1h ; this is a Bios signature

db 80h

jmp reset
bios_start endp

end

Things I Should Forget

The Fill File D-4-1

FOUR
The Fill File

The Fill. asm File is an assembly language file used during the linking process to
upwardly justify the biostop module so that it resides at the end of the Bios segment.

***********************************************************************

Copyright (c) FOSCO 1988 - All Rights Reserved

Module Name: Bios fill at link time

Version: 1.00

Author: FOSCO

Date: 5-12-88

Filename: atfill.asm

Functional Description:

Uses biosfill.inc (generated by BIOSGEN) to fill out area so the biostop module will
be positioned correctly at the top of the bios.

Version History:

**************************************************************************************************/

include atprfx.inc
_f i 1 1 segment

include atfill.inc
_fill ends

end

Meetings I Should Go To

The Data File D-5-1

FIVE

The Data File

The Data.asm File is an assembly language file used to declare the variables
assigned to the system scratch Ram segment and those used by the SysVue program.
These variables will be assigned to the top 2 Kbytes of space in the system Ram
Memory map by the power-up (POD) routine.

The memory block pool definitions also reside in this file. The acquire_block and
release_block operations (in Biosmisc.c) are used to assign memory for use as
variables to limit use of the stack by Bios function call routines.

*********************************************************************^

Copyright (c) FOSCO 1988 - All Rights Reserved

Module Name: AT Bios system data definition

Version: 1.00

Author: FOSCO

Date: 12-01-88

Filename: atdata.asm

Language: MS MASM 5.1

Functional Description:

This module is used to declare the variables in the system ram segment. Most of these variables

are used by biosvue.

A stack is assigned at the top of the module for use by the POO routines.

Version History:

**********************************************************************

include atprfx.inc
; the data section to declare the system ram for biosvue

pub
pub
pub
pub
pub
pub
pub
pub
pub
pub
pub
pub
pub
pub

Sb

pUD

pub
pub
pub
pub
pub
pub
pub
pub
pub
pub
pub
pub
pub
pub
pub
pub
pub

c mode size

c mode~*type

c sysvue busy

c inchar"

c buffer

c exit flag

c buffer index

c reg_saves

c inreg saves

c outreg saves

c token Index

c token~value

c cc

c token buffer

c command index

c flag index

c token number

c list Index

c last'delim

c break* flag

c last dump start seg

c last~dump~start""off

c int leg ~ ~"

c int~off

c reg~index

c brelk chain

c trace~chain

c trap_chain

c present

c sum

c enter seg, enter off

c char_count

c reco?d_type

D-5-2 The Data File

publ
publ
publ
publ
publ
publ
publ

trace count

watch~flag

watch~se lection

u found

JT

redirect flag

dec array

=== definition of system scratch object ~=

scratch segment at

aid

dw

sysvue variables

Object Structure Definitions

optional id field = 5aa5 to be valid
load this field if you need to locate
this object in an expanded system.

sysvue^busy dw ?
mode size dw ?
mode~type dw ?
inchar dw ?
buffer dw 80 dup(?)
exit flag dw ?
buffer index dw ?

~ align 16
reg saves label word

dw 16 dup (?)
inreg saves label word

dw 16 dup(?)
out reg saves label word

" dw 16 dup(?)
token index dw ?
token'value dw 8 dup(?)
cc ~ dw ?
token buffer dw 16 dup(?)
command index dw ?
flag inSex
token number dw ?
list Index dw
last'delim dw
break" flag dw
last_3ump_start__seg dw ?
last~dumpTstart""off dw ?
int seg dw "~ ?
int~off dw ?
reg~index dw ?
break chain dd ?
trace~chain dd ?
trap chain dd ?
present dw
trace count
sum ~ dw
enter seg dw
enter~of f dw
char count dw
record type dw ?
watch Tlag dw ?
watch~selection dw ?
u found dw ?
jj dw ?
redirect flag dw ?
dec_array db 6 dup(?)

;:»::==:s::sss Variables for functions sa«sassKsas

line input buffer

: -1 = exit from sysvue
; ptr for buffer

these are normal saves

these are used for INT command
these are used for INT command

dw

?
?
?

?

dw

?
?

ptr for token string

token string

gotten from _token_index

nr. of matching item

; last delimiter found

■ reserved space for protected mode tables
pointer to parent bios

parent

org

48h

public

parent

dw

?

reserved space for protected mode tables

align 16
public GOT block
GDT block label byte ~

dq 7 dup<?>

public
IDT_block dq

align
public

IDT block
"

16
psuedoJJDT

A-Tvpe BiosKit

The Data File D-5-3

psuedo_LIDT df

align 8
public psuedo LGOT
psuedo_LGDT df ~

align 16

public virtual block

virtual block label byte

~ db 256 dup<?)

; block space for allocating

public start block
public current open
public end block
public block beg
public block~end

The following area is a block-pool, from which blocks can be allocated by the functions:
acquire block
release~block
These allow dynamic allocation for recursive functions while minimizing stack space used,
public ds save.bx save,dest save, length mark
public sp~save,ss~save

align 16

start block dw ?
current open dw ?
end_block dw ?

bx save dw ?

ds'save dw ?

dest_save dw ?

align 16

block beg label word

dw 1024 dup<?)
block end label word

scratch ends

; This structure is used to save the old stack pointer in the new
; stack block. It is used to switch back to the callers stack
; after a swapping interrupt.

swap seg segment at

length mark dw ?

dw ? ; also user ID field

sp save dw ? ; save of callers ss:sp

ss^save dw ?

swlp_seg ends

end

Section D: The ASM Programs

Meetings I Should Avoid

The Virt File D-6-1

SIX
The Virt File

The Virt.asm File contains the virtual mode routines.

Three major items are handled by the virtual routines:

1. Sizing and testing any extended ram

2. Block move routine which supports Virtual Ram Disks.

3. Switching machine operation to virtual mode.

Default descriptor tables are built for ram test and for the block move. The user
needs to build the tables when switching to virtual mode. The test and the move
routines have their own restart sequences, so that the CPU may be restarted back in
real mode, and continue operation.

A restart consists of saving a restart code in the CMOS RAM at location OF. An
error code may be returned in DMA page register port 80. The values are used to
determine what action to take. An optional argument may be saved in port 88. A
signal is then sent to the 8042 keyboard controller which pulses the reset line to the
CPU. The CPU then restarts in the default real-mode and the restart-code value is
checked to see if it is other than a power-up or a normal reset switch sequence. If a
valid restart code value is found in port 80, the Biostop.asm module code diverts to
the specific restart sequence. This restart sequence then restores the machine state
(registers) and returns control to the program which caused the CPU to go to virtual
mode.

The 286 CPU normally starts operation in the real-mode upon power-up. It may be
switched to virtual mode by setting the protection enable (PE) bit in the machine
status word (MSW). Because of a quirk in the original design of the 286 CPU, the
only way to switch back to the real-mode, (which is the normal mode for DOS), is by
actually causing a hardware reset of the CPU chip. To permit this, the 8042 output
port has an output line which connects to the 286's reset input line. A command may
be sent to the 8042 to pulse this reset line.

The 386 has provision for switching to and from the virtual mode internally by
modifying the machine status register (MSW) by a 386-specific instruction (MOV to
Control Register). This enhancement of the 386 negates the need for the
complicated restart handling of the 286.

One item about the 286 which is of interest is that there is a Interrupt Descriptor
Table Register (IDTR) which provides the base address of the interrupt vectors.
Upon a hardware reset, this register is set to a value of 0000, so that the base
address of the interrupt vector segment is at zero. When switching to virtual mode,
this register is changed to point to an Interrupt Descriptor Table (IDT). This
permits the interrupt vector segment to be re-located without changing the contents
of the vector locations. This basing register is also active in the real-mode (since it
defaults to 0000, we are not aware of its existence in real-mode) and can be used to
relocate or substitute multiple sets of interrupt vectors. In standard DOS practice,
however, this option is not exercised.

D-6-2 The Virt File

Why the DMA page register is used to save parameters - During the restart
sequence, there are usually some values that need to be passed from the virtual-
mode program back to the real-mode program. These could be saved in the CMOS
RAM, or somewhere in system memory. A very convenient spot that was originally
used on the AT type machines, is the DMA page register chip. In the earlier PC and
XT type of machines, the register was a write only device, which handled the four
standard DMA channels. This chip held the high four bits of the memory address
during a DMA transfer, as the 8237 DMA chip only has 16-bit internal registers.
The AT type of machines have an additional 8237 DMA controller for 16-bit wide
data transfers. Now there was a need for 8 page registers (one for each of the 8
DMA channels). Instead of using two of the XT type chips (74670), a newer chip
was selected. This is the 74612 type of chip. This contains 16 8-bit registers, 8 of
which are used for the DMA channels.

These registers are both read/write, so two of these are used for passing parameters
by the AT BiosKit. The basic restart-type code is passed in location OF of the
CMOS-RAM, but an error-descriptive value is passed in the page register port at 80,
and a second argument may be passed in register port 88.

Notes for potential 386/376 users - The 386, as mentioned previously, has an
enhanced mechanism for switching between real and virtual modes, while the 376
assumes the virtual mode of operation from reset, since it does not have the real-
mode capability.

Copyright (c) FOSCO 1988, 1989 - All Rights Reserved

Module Name: AT BiosKit Virtual memory support

Version: 1.02

Author: FOSCO

Date: 10-20-89

Filename: atvirt.asm

Language MS MASM 5.1

Functional Description:

Version History:
1.01

Deleted some extraneous code (GOT structures)
1.02

Corrected block move errors

Changed restart from 8042 sequence to double fault shutdown sequence

Added support for restart 5 and 10

Changed "jmp myself" loop after shutdown to a HLT to keep busses quiet

include atprfx.inc

extrn
extrn
extrn
extrn
extrn

extrn

extrn

public

public

public

err_port equ
arg port equ
port a
port~b
intaUO
inta01

outcmos:near
GOT block: near
IDT~block:near
psuedo LGDT:near
psuedo~L I DT : near

co : near
I word: near
restarts
restart9
restartIO

080h ; save stuff in page register chip

088h : byte for saving aux. data on restarts

equ 060n

equ 061h

equ 020h

equ 021h

A-Tvpe BiosKit

The Virt File D-6-3

intbOO equ OaOh

intbOl equ 0a1h

status port equ 064h

input Buffer full equ 02h

restart cell" equ 08fh
restart""command equ Ofeh
cmos port equ 070h

disaEle_parity equ OOch

enable_parity equ 0f3h

parity_error equ OcOh

build_24bit address macro arg1,arg2
push arg2
push argl
call build 24
add sp,4 ~
endm

build descriptor macro arg1,arg2
push arg2
push argl

call build descriptor routine
add sp,4 "" ~
endm

; These are macros to enable or disable A20, added 5-12-89 <BG>

active equ Odfh

inactive equ Oddh

changejrumber = ; Number of change_a20 call

empty 8042 macro

~ local empty loop

empty number = empty number + 1 ; Inc number of empty call

xor ~ ex, ex
empty loop:

in al,64h

and al,02h

loopnz empty loop

mov a I, empty number

endm

change a20 macro arg ;; Odfh = enable, Oddh = disable

~ local error check, exit change
empty_number = 0""; Start of? with empty number =
change number = change number + 10h

empty 8042

jnz ~ error check

mov al,0dTh

out 64h,al

empty 8042

jnz ~ error check

mov at, arg

out 60h,al

empty 8042
error check: ~

clc

jz exit change

stc ~

add a I, change number
exit_change: ~

endm

; End of new macros <BG>

;==== definitions for virtual modes =====
;==== (test_ram and movejslock) ====

Code/Data Descriptor definitions

desc st rue

lim 15 dw ; limit (15-0)

bas~15~0 dw ; base (15-0)

bas~23""16 db ; base (23-16)

access - db ; access rights

irsv dw ; intel 386 reserved next 2 bytes

desc ends

; trap/ interrupt gate definition

tigdesc struc

code offset dw ? ; offset to routine

code"select dw ? ; selector to routine

db ; always zero

Section D: The ASM Programs

D-6-4 The Virt File

db
dw

hb_arb
tigdesc ends
len_desc equ 8

;========== Global Descriptor Table structures ==========

; the GDT for the block move organization

; This structure order is determined by the function call format.
; Do not alter it !

; We also use this structure for the extended memory testing
move st rue

00

08

10

high base and access rights
reserved for 386

move_dmy

move~gdt

moveas

move~es

move~cs

move~ss

move~idt

move~ends

idt
idt
idt'

dq
dq

dq

st rue
ends

23

dq

18
20
28
30 * this exists for both move and mem- test

00

; the GDT for virtual mode function call

; This structure order is determined by the functi<

; Do not alter it !

mode struc

mode_dmy dq

mode'gdt dq

mode~idt dq

mode'ds dq

mode'es dq

mode'ss dq

mode""cs dq

model} i os dq

mode~ends

m ca

11 format.

00

- unusable

08

- GDT

10

- IDT

18

- data

20

- extra

28

- stack

30

- code

38

- bios

the gdt segment for the POD and the move -■

gdt segment segment at
gdt'start label byte

desc <>

desc <>

desc <>

desc <>

desc <>

desc <>

desc <>
gdt end label byte
gdt~len = gdt end- gdt start
gdt'segment ends

idt segment segment at
idt'start label byte

~ desc <>
idt_segment ends

virtual_enable equ 1

null_idt: desc<>

■========== end of definitions ============

table not usable

08 - GDT

10 - temp for ds

18 - temp for es

20 - temp for ss

28 - temp for cs

30 - IDT - created for move

rom idt descriptor

; this module includes all the code for accesssing the virtual memory and running in protected mode

.code

move virtual block - function code 15h

virtual move proc uses ds,word count: word, global segment: word, global offset:word

cli ~ ; disable interrupTs/execeptions
eld

xor a I, a I ; clear the error bucket
out err port, a I

change a20 active ; enable full range addressing <BG>

jnc ~ 3F j no carry says A20 ok

change a20 inactive ; disable it again <BG>

mov ~ ax,0300h ; mark A20 error, return to caller

ret ; quick return when A20 error

A-Tvpe BiosKit

The Virt File D-6-5

aa:

pusha

push

ds

push

es

push

40h

pop

ds

assume

ds : segment J

mov

ax,ss

mov

vsegment , ax

mov

ax,sp

mov

voffset,ax

write_cmos restart_cell,9
bui ld_descn"ptor es,si

continue:

aa:

mov

mov
mov
mov

Igdt

lidt

mov
Imsw
delay
db

dw
dw

nop

mov

mov

mov

mov

mov

mov

sub

sub

rep

in

test

jz

xchg

xchg

mov

out

in

delay

or

out

delay

and

out

; save return pointers in low ram
; save stack description in low ram

set restart type 9

; get and save the move count

cx,word_count

ax,40h

es,ax

es, word ptr es: [Oeh] ; get system seg

fword ptr es:psuedo_LGDT; point the gdt-reg to the block

fword ptr es:psuedoJ.IDT ; IDT's are built

ax,virtual_enable

ax

Oeah

continue
move cs

; go into protected mode
; this jump to clear queue
; jmp far ptr into cs: selector to
; set access rights
continue executing 2 lines below

ax, move ss

ss,ax

ax, move ds

ds,ax ~

ax, move es

es,ax ~

di,di

si, si

movsw

al,port_b

al, parity error

3F

ds: [di],ax

ds: [di],ax

al,1

err_port,al

al,port_b

al,disable_parity
port_b,al

al,enable_parity
port_b,al

set up selectors

; word count is already in CX
; this does the actual move
see if a parity error on move

; jump if no error

; re- write the bad word

; set parity error code in bucket

reset parity

change a20 inactive

jnc ~ 3F

in al,err_port

or al,al

jnz 3F

mov al,3

out err port, al

aa:

ifndef SLOW RESET
; try causing a shutdown

lidt fword ptr cs:null idt

int 3

; Use keyboard controller to reset if shutdown won't work

were there any previous errors ?
test for non-zero

no - set A20 error code

Shutdown may not work on some chipsets <BG>

else
<BG>

end if

mov
out

hit

a I, restart command
status_port,al

; this causes restart

; End of alternate reset code <BG>
; stop cpu to quiet the busses

;- This is where the restart from the block moves comes in -

restart9: ; proc
mov
mov
assume

ax,40h

ds,ax

ds: segment 40

Section D: The ASM Programs

D-6-6 The Virt File

cli

mov

ax,vsegment

mov

ss,ax

mov

ax,voffset

mov

sp,ax

pop

es

pop

ds

popa

in

al,err_port

mov

ah,al

xor

al,al

ret

virtual move endp

; restore the original real stack

; get returning error code
return with error code in AH

switch to virtual mode -

Int 15, function 89

void virtual mode(bhbl.seg.off)

called with Eh = 8259 #1 index

called with bl = 8259 #2 index

called with es = segment of pointer to global desc. table

called with si * offset of pointer to global desc. table

returns with ax = = ok, else not zero = error

all other registers destroyed Hi!

virtual mode proc bhbl: word, desc seg:word,desc off: word
cli

change a20 active
jnc ~ 3F
mov ax,-1 ; set error, quick return to caller

SB:

IDT

ret

mov es,desc seg

mov si,desc~off

Igdt fword pTr es: [si] .mode_gdt

lidt fword ptr es: [si] .mode_idt

; reload the 8259 interrupt controllers because we have changed the base address of the

; ( the interrupt vectors).

this is parm from caller

mov

al,11h

out

inta00,al

delay

mov

ax, bhbl

xchg

ah,al

out

inta01,al

delay

mov

al,04h

out

inta01,al

delay

mov

al,01h

out

inta01,al

delay

mov

al,0ffh

out

inta01,al

mov

al,11h

out

intb00,al

delay

mov

ax, bhbl

out

intb01,al

mov

al,2

delay

out

intb01,al

delay

mov

al,1

out

intb01,al

delay

mov

al,0ffh

out

intb01,al

this is parm from caller

; build our own CS: as the bas 23 16 value for the descriptor table. This way we can execute from
; a secondary or a test bios, at other than segment F000.

mov ax,cs

shr ax, 12 ; now looks as 32-16 value

mov es: [si]. mode cs.lim 15 0,-1

mov es : [s i ] .mode~cs . bas~23~l6. a I

mov es : [s i ] . mode^cs . bas~1 5"0 ,

mov es : [s i ] . mode~cs . access793h

mov es: [si] .mode~cs.irsv,0

mov ax, virtual enable

Imsw ax

A-Tvpe BiosKit

The Virt File D-6-7

delay

mov

mov

mov

mov

mov

mov

pop

add

push
push
retf
virtualjnode endp

ax,mode_ds

ds , ax

ax,mode_es

es,ax

ax,mode_ss

ss,ax

bx

sp,4

mode cs
bx "

this jump to clear queue

get the return address off the stack

need to adjust this MM

we may have to back up through the call

into the Int 15 function to return

to the real caller. ????

push cs selector on stack

push return on stack

return to user

These are the "continue" points for returning from virtual mode to

real mode, when using the switch to virtual mode function above

The User MUST disable both interrupts and NMI, and load V OFFSET and

V_SEGMENT with a valid continuation address, then the user must

load the restart code (5d or 10d (05h or Oah)) in CMOS location

xx, then cause a double fault exception to force a CPU reset. Not many

users get involved in this.

Programmers Opinion: If you really want to operate in virtual mode,

get a 386 machine.

purge the keyboard buffer

send an EOI to the interrupt controller

to purge pending timer interrupts

restart5:

in

al,60h

mov

al,20h

out

20h,al

restartlO:

mov

ax,40h

mov

ds,ax

jmp

dword ptr voffset

voffset is in segment 40:

idt descriptor label byte

dw rom idt len
dw offset rom idt
db 0fh,0

idt descriptorjength = $-idt_descriptor

ronfidt: " ~

tigdesc <exc 00, move cs,,87h>
t i gdesc <exc~01 , move~cs , , 87h>
t i gdesc <exc~02 , move~cs , , 87h>
t i gdesc <exc~03 , move""cs , , 87h>
t i gdesc <exc~04 , move~cs , , 87h>
t i gdesc <exc~05 , move""cs , , 87h>
t i gdesc <exc~06 , move~cs , , 87h>
t i gdesc <exc~07, move""cs , , 87h>
t i gdesc <exc~08 , move~cs , , 87h>
tigdesc <exc~09,move~cs,,87h>
t i gdesc <exc~1 , move~cs , , 87h>
t i gdesc <exc~1 1 , move""cs , , 87h>
t i gdesc <exc~1 2 , move~cs , , 87h>
t i gdesc <exc~1 3 , move"*cs , , 87h>
t i gdesc <exc~1 4 , move~cs , , 87h>
t i gdesc <exc~1 5 , move~cs , , 87h>
t i gdesc <exc~1 6 , move~cs , , 87h>
t i gdesc <exc~1 7, move~cs , , 87h>
t i gdesc <exc~1 8 , move~cs , , 87h>
tigdesc <exc~19,move~cs,,87h>
tigdesc <exc~20,move"cs,,87h>
t i gdesc <exc~2 1 , move~cs , , 87h>
t i gdesc <exc~22 , move~cs , , 87h>
t i gdesc <exc~23 , move~cs , , 87h>
t i gdesc <exc~24 , move~cs , , 87h>
t i gdesc <exc~25 , move~cs , , 87h>
t i gdesc <exc~26 , move~cs , , 87h>
tigdesc <exc~"27,move~cs,,87h>
tigdesc <exc~28,move~cs,,87h>
t i gdesc <exc""29 , move~cs , , 87h>
t i gdesc <exc~30 , move~cs , , 87h>
t i gdesc <exc~3 1 , move~cs , , 87h>

rom idt len equ $-rom Tdt ~

resident idt table is in bios cs

ex int

:

mov

al,2

out

err_port,al

mov

a l, restart command

out

status _por?, a l

aa:

hit

exception interrupts for move
error code - 2 - excep. int. error

Section D: The ASM Programs

D-6-8 The Virt File

jmp

as

restore idt label fword

~ dw 3ffh ; lim 15

dw ; base

dw

iret addr label word
~ i ret

; this sets up an all inclusive exception table, if we get an exception while we are in
; virtual mode, we want to process and report it.

sys idt offsets
~ " dw
dw
dw
dw
dw
dw
dw
dw
dw
dw
dw
dw
dw
dw
dw
dw
dw
dw
dw
dw
dw
dw
dw
dw
dw
dw
dw
dw
dw
dw
dw
dw

label word

Of1

Pset

of

set

Of1

fset

of

set

of

Pset

of

set

of

set

of

Pset

of

set

of

set

of

set

of

set

of

set

of

set

of

set

of

set

of

set

of

set

of

set

of

set

of

set

of

set

of

set

of

set

of

set

of

set

of

: set

of

set

of

: set

of

: set

of

'set

ofi

fset

exc 00
exc~01
exc"02
exc~03
exc~04
exc~05
exc~06
exc""07
exc~"08
exc~09
exc"~10
exc~1 1
exc"12
exc"13
exc 14
exc~15
exc 16
exc~17
exc"18
exc"19
exc~20
exc~21
exc"22
exc~23
exc""24
exc~25
exc~26
exc~27
exc~28
exc~29
exc"30
exc~31

00
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

divide error

single step

rani

trap

into detect

bounds check

invalid opcode

NPX not available

double fault

NPX segment error

invalid tss

cs, ds, es not present

SS: not present

general prot error

a NPX error

this is the canned gdt for the pod routines

gdt data start label word

~ desc <0,0,0,0> ; 00

desc <gdt I en. offset GOT block, 0,93h>

desc <-1,U00Oh,0fh,93h> ""; 10 - temp for ds

desc <-1,0000h,10h,93h> ; 18

desc <-1 f 0O0Oh,OOh,93h> ; 20

desc <-1,0000h,00h,93h> ; 28

; 08 - the GDT

desc <rom_idt - (en,rom_idt,0,93h>
gdt_data_end label word "" ~

temp for es
temp for cs
temp for ss

30 - the IDT

exc 00: mov

exc 01: mov

exc 02: mov

exc 03: mov
jmp
mov
jmp

exc 04:

exc 05:

push
mov
mov
sub
mov
mov
pop
mov
jmp

exc 06: mov
exc 07: mov

al,0
test exc

ai,r

test exc
at-
test exc
al,3~
test exc
al,4~
test exc

load al with exception number

es

ax , move es

es,ax

di,di

word ptr es: Cdi],0

word ptr es: [di+2],07fffh

es

al,5

test_exc

at, 6
test exc
al,7"

this is a bounds check

A-Tvpe BiosKit

The Virt File D-6-9

jmp test exc

exc 08: mov al,8""

jmp test_exc

exc 09: mov al,9~

jmp test exc

exc 10: mov al,lO

jmp test exc

exc 11: mov al,1l

jmp test exc

exc 12: mov a 1, 12

jmp test exc

exc 13: mov al,l3 •

~ jmp test exc

exc 14: mov a 1,1?

jmp test exc

exc 15: mov al,l5

~ jmp test exc

exc 16: mov al,lS

~ jmp test exc

exc 17: mov al,l7

jmp test exc

exc 18: mov al,l8

jmp test exc

exc 19: mov a 1, 19

~ jmp test exc

exc 20: mov al,2U

jmp test exc

exc 21: mov al,2T

~ jmp test exc

exc 22: mov al,22

jmp test exc

exc 23: mov al,23

jmp test exc

exc 24: mov al,25

jmp test exc

exc 25: mov al,25

jmp test exc

exc 26: mov at ,25

jmp test exc

exc 27: mov a I, 27

~ jmp test exc

exc 28: mov al,28

~ jmp test exc

exc 29: mov al,29

jmp test exc

exc 30: mov al,3U

jmp test exc

exc 31: mov al,3T

~ jmp test_exc

; if we got an exception, process it so we can return an
; exception code.

test exc:

add al,80h ; add 80h to these exceptions

out err_port,al

iret

build a descriptor table in the system ram segment ---

; we do this for both the block move and the mem- test

; t seg:t off points to the template to build

; we will~filt in some dynamic values

; it will be built in system: segment: GO T_block

; build the global descriptor tables

; These are built with current CS: in case we are in test mode

build_descriptor_routine proc t_seg:word,t_off:word

;-- ds:si * seg:off of the template

mov ds,t seg
mov si,t~off

;-- es:di = location in system segment to build the descriptor

mov di, offset GOT block

mov ax,40h

mov es,ax

mov es, word ptr es:[0eh]

;-- ex = length of the template

mov ex, 24 ; template is 48 bytes long

Section D: The ASM Programs

D-6-10 The Virt File

push di ; save base address of GOT table

rep movsw
pop di

;-- build a dynamic GOT descriptor

build 24bit address es,<offset GOT block>
mov ~ es:[di] .move gdt.lim 15 U,38h
mov es : [d i ] . move~gdt . bas~1 5~0 . ax
mov es : [d i 3 . move~gdt . bas~23~1 6, d I
mov es : [d i 3 . move~gdt . access7°3h
mov es : [d i ] . move~gdt . i r s v ,

;-- build a dynamic CS: descriptor

build 24bit address cs,0
mov ~ es:[di].move cs.lim 15 0,-1
mov es : [d i 3 . move~cs . bas~ 1 5~0 . ax
mov es : [d i 3 . move~cs . bas~23~1 6 , d I
mov es:[di3.move~cs.acc~ss~9bh
mov es : [d i 3 . move~cs . i rs v ,

;-- build a dynamic SS: descriptor

build 24bit address ss,0
mov ~ es:[di3.move ss.lim 15 0,-1
mov es : [di 3 .move~ss . bas~1 5""0, ax
mov es : [d i 3 . move~ss . bas~23""1 6 . d I
mov es : [d i 3 . move~ss . access7 9 3n
mov es : [d i 3 . move'ss . i r s v ,

;-- build a dynamic IOT descriptor

build 24bit address es,<offset IDT block>
mov ~ es:[di3.move idt.lim 15_0,6
mov es: [di3.move~idt.bas~15~0.ax
mov es:[di3.move~idt.bas~23~1o.dl
mov es: [di3.move~idt.access7°3n
mov es:[di3.move~idt.irsv,0

;-- now build the IOT descriptor

build 24bit address cs f <offset rom idt>

mov ~ dT,offset IDT block

mov es:[di"3.idt .Tim 15 0,6

mov es : [d i 3 . i dt~ . bas~1 5~0 , ax

mov es: [di3 . idt~.bas~23~16,dl

mov es : [d i 3 . i dt~ . access793h

mov es:[di3 .idt~. irsv,0

;-- now build the psuedo GOT descriptor

build 24bit address es,<offset GOT block>
mov ~ d7, offset psuedo L60T ~
mov word ptr es: [di+003 ,56
mov es: [di+023,ax
mov es: [di+043,dx

;•- now build the psuedo IDT descriptor

build 24bit address es f <offset IDT block>

mov ~ dT, offset psuedo LIDT

mov word ptr es: [di +003,256

mov es: [di+023,ax

mov es:[di+043,dx
ret

build descriptor routine endp

; returns a 24 bit address in DX:AX

build 24 proc xseg:word, xoff:word

~ xor dx,dx

mov ax,xseg ; build 24-bit address from seg:off

mov dl,ah

shr dl,4

shl ax, 4

add ax,xoff

adc dl,0

ret
build 24 endp

Test Ram - size, test, and clear

A-Tvpe BiosKit

The Virt File D-6-11

; returns ok/error code in AX - size in cmos(30 and 31)

; note: this are all near procs, since they can be

; called from the Bios CS: only. After we do a restart,

; we are also in the Bios CS:, so we automatically connect

; with the right return address.

; The ram test is a combination of a block-move (Bios ->

; test area) followed by a block compare.

qmsg: db 13,10,"A20 error on entry",

test ext mem proc

~ cli ; disable interrupts/execeptions

eld

mov al.Offh

out 21h,al ; mask the 8259

pusha ; save all the reggies

push ds
push es

write cmos 30h,0 ; clear the reporting cells
write~cmos 31h.O ; for ext mem size
xor "" al,al
out err_port,al ; clear the error reporting cell

Note: Interesting point:

It takes the 8042 a discrete amount of time to actually enable the A20 address line after
this command is given. It is given in some publications as > 20 useconds. If the extended
mem tests cuase a system crash, it may be because A20 has not switched yet, and < 1Mb ram
is getting trashed. See the delay routines in the wrap enable/disable functions.

change a20 active ; enable full range addressing <BG>

; Error numbers 51.52.53 <BG>
jnc 3F ; no carry says A20 ok

mov ah,al ; save number of "empty" that failed <BG>

change a20 inactive ; <BG>

mov ~ al,ah ; retrieve number of "empty" that failed <BG>

out errj3ort,al
pop es
pop ds
popa

mov ax,0300h ; mark A20 error, return to caller
sti ; re-enable interrupts

33:

ret ; quick return when A20 error

push 40h

pop ds ; save return pointers in low ram

assume ds:segment_40

mov ax,ss ; save stack description in low ram

mov vsegment,ax

mov ax.sp

mov voffset,ax

write_cmos restart_cell,2 ; set restart type 2

build a complete GDT table set

Once we do this, we can't do any interrupts, because the LIDT changes the interrput vector table
base. Since we set it up for exceptions, we won't be able to do video interrupts.

build_descriptor cs,<offset GDT_data_start>

mov ax,40h

mov es,ax

mov es, word ptr es: [Oeh] ; get system seg

Igdt fword ptr es:psuedo_LGDT; point the gdt-reg to the block

lidt fword ptr es:psuedoJ.IDT ; IDT's are built

mov ax, virtual enable

Imsw ax ~ ; goto virtual mode

delay ; this jump to clear queue

db Oeah ; jmp far ptr into cs: selector

; to set access rights
dw next
dw move_cs

next: delay

mov ax, offset move_ss
mov ss,ax ~

Section D: The ASM Programs

D-6-12 The Virt File

mov
mov
assume

start loc equ

end loc

mov
mov

mem check:

~ inc

cmp

jae

mov

eld
mov
mov
sub
sub
mov

rep
sub
sub
mov

repe
jcxz
jmp

sub
mov
xor
rep
jmp

> 15 Mb boundary ?

mem ok:

ax, offset move gdt

ds,ax

ds:gdt segment

OOfh "

equ Ofeh

dl, start loc : start at 1 Mb - 64K

ds:move_es.bas_15_0,0 ; set es: segment = xxOOOO

dl

dl,end loc

mem exit

ds:move_es.bas_23_16,dl ; set es: segment

; make sure direct is forward
ax,move_es
es,ax
di ,di
si, si
cx,8000h ; move 64k

: this preloads the block
movs word ptr es:[di],word ptr cs:[si]
di,di
si, si
cx,8000h ; compare 64k

; this does the actual test
emps word ptr cs: [si], word ptr es:[di]
mem ok ; it's OK
menTexit ; exit

di,di
cx,8000h
ax, ax
stosw
mem check

now clear the block

clear 64x

check the next block

mem exit:

xor

dec
sub
shl

dh.dh

dl

dx, start loc

dx,6

; bump dl down to last good segment
; re justify to "0000"
; example 256K = 100h

; just return tested OK size - pod can display findings

write cmos 30h.dx ; write the cmos

xchg " dh.dl

write_cmos 3lh,dx

change a20 inactive ; empty numbers 71,72,73 <BG>

jnc ~ 3F

mov ah,al

in al,err_port

or al,al

jnz 3F

mov al,ah

out

33:

i f ndef NO_SHUTDOUN

; try causing a shutdown

err_port,al

; save number of "empty" that failed <BG>

; were there any previous errors ?

; test for non-zero

; no - set A20 exit error code to

; number of failed "empty" <BG>

; Shutdown may not work on some chipsets <BG>

else
<BG>

end if

lidt
int

mov
out

fword ptr cs:null idt
3

; Use keyboard controller to reset if shutdown won't work

a I, restart command
status_porT,al

hit
test_extjnem endp

; This is the real return from the ext mem test

restart2

; End of alternate reset code <BG>
; stop the CPU to quiet the busses

33:

proc

mov

mov

assume

mov

mov

mov

mov

pop

pop

popa

in

or

jnz

mov

sti

ret

ax ( 40h

ds,ax

ds: segment 40

ax,vsegmenf

ss,ax

ax,voffset

sp,ax

es

ds

al,err_port

al.al

3F

ax, ok

restore the original real stack

now pop the registers

; get returning error code
; if non-zero, return "error"

return(ok);

A-Tvpe BiosKit

The Virt File D-6-13

mov ax, error

sti

ret ; return(error);

restart2 endp

end

Section D: The ASM Programs

Meetings I Should Call

SECTION E

The C Programs

These are the modules of the Bios which are in C. They include the Function Calls
and the Interrupt Service Routines.

The Kith File E-l-1

ONE
The Kith File

The Kith file is the 'C header file used for all the Bios modules. The 'C language
utilities used in the build process use normal .h files since they run from normal
Ram. Because the Bios is a prom-resident program, it has its own special
requirements in the use of the CPU's segment registers. Declarations to provide
interrupt routine support are also in this file. A special simplified interrupt sequence
is provided in order to save and restore registers when either calling interrupt
routines, or in defining a function to act as an interrupt routine. Because of these
features included in the bioskit.h file, interrupt service routines are written as
regular functions, with the machine register state being declared as unsigned integer
parameters on the stack.

*

* Copyright <c> FOSCO 1988, 1989 - All Rights Reserved

*

* Module Name: AT Bios h file of standard definitons

* Version: 1.02

* Author: FOSCO

*

* Date: 11-01-89

*

* Filename: atkit.h

* Language MSC 5.1

* Functional Description:

* This file is used for the standard header for bios 'C programs. It is the only header file

* that should be #defined in the Bios modules. Other headers may contain conflicting definitions.

*

* The Bios does not use any standard library for two main reasons:

* 1. The linker attempts to place library routines at the top of the segment,

* which must contain some fixed code.

*

* 2. The standard libraries assume that the program is running under DOS (which is

* not the case for Bios), and may make 0OS references.

* The file Bios top. asm contains the assembly- language functions required for the Bios.

* Version History:

* 1.01

* Font revision - content unchanged

* 1.02

* Defined casts for low ram variables

*

unsigned peek (unsigned, unsigned);
unsigned peek40( unsigned);
unsigned peekcs( unsigned);
void poke(unsigned,unsigned,unsigned);
void poke40( unsigned, unsigned);

unsigned char peekb( unsigned, unsigned);
unsigned char peekb40( unsigned);
unsigned char peekbcs(unsigned);
unsigned peekcs(unsigned);

void pokeb( unsigned, unsigned, unsigned char);
void pokeb40( unsigned, unsigned char);
void beep(void);

void and40( unsigned, unsigned);
void andb40( unsigned, unsigned char);
void or40(unsigned, unsigned);
void orb40(unsigned, unsigned char);
void xor40(unsigned, unsigned);

E-l-2 The Kith File

void xorb40(unsigned,unsigned char);

unsigned inport( unsigned);
uns i gned char i npor tb( uns i gned) ;
void out port (unsigned, unsigned);
void outportb(unsi gned, unsigned char);

unsigned bios cs(void);

void set vector (unsigned, unsigned, unsigned *);

void I byTe( unsigned char);

void I word( unsigned);

void write string( unsigned *);

void bios_unsigned( unsigned, unsigned *, unsigned *);

void out cmos( unsigned, unsigned char);

unsigned char i nemos (unsigned);

unsigned acquire scratch block(unsigned, unsigned, unsigned, struct callers far *);

void release block(unsigned);

unsigned long set timeout count (unsigned);

void snapshot in(unsigned7 struct callers far *);

void snapshot~out( unsigned, struct callers far *);

^define true 1
#define false

#define yes true
#define no false

#define ok

#define error -1 /* error codes may be 0001 -ffff */

#define at Oxfc // type byte definition

#define xt Oxfe // type byte definition

#define cr 13
#define If 10
#def ine bspace 8

#define sys_seg_size 4096 // size of the system segment

#define BIT15 0x8000

#define BIT14 0x4000

#define BIT 13 0x2000

#define BIT12 0x1000

#define BIT11 0x0800

^define BIT10 0x0400

#define BIT9 0x0200

#define BIT8 0x0100

#define BIT7 0x0080

#define BIT6 0x0040

#define BIT5 0x0020

#define BIT4 0x0010

#define BIT3 0x0008

#define BIT2 0x0004

#def ine BIT1 0x0002

#def ine BIT0 0x0001

// Define the watch bits

// These bits are also used by the block acquire/ re I ease

// function as the owners ID codes. This is for future enhancements.

#def ine VIDEO BIT0
#define VUE BIT1
#define CASSETTE BIT2
#define EQUIPMENT BIT3
#def ine MEMORY BIT4
#define LPT BIT5
#define COM BIT6
#define FLOPPY BIT7
#define HARD BIT8
#define TOD BIT9
#define BOOT BIT10
#define TIMER BIT11
#define KEYBOARD BIT12
#define PRSC BIT13
#define POD BIT14

// define the devices subject to watching - exclude some !

#define WATCH MASK CASSETTE|EQUIPMENT|MEMORY|COM|FLOPPY|HARD|TOD|BOOT

#define carry"bit 0x0001

#define zero_Bit 0x0040

#define interrupt registers \

unsigned es, unsigned ds, unsigned di, unsigned si, unsigned bp, unsigned sp, \

unsigned bx, unsigned dx, unsigned ex, unsigned ax, unsigned ip, unsigned cs, unsigned flags

A-Tvpe BiosKit

The Kith File E-l-3

// This definition is the same as above except for the semi-colons in place of the commas.
// It is used for snapshots.

#define snap registers \

unsigned es; unsigned ds; unsigned di; unsigned si;unsigned bp; unsigned sp; \

unsigned bx; unsigned dx; unsigned ex; unsigned ax; unsigned ip; unsigned cs; unsigned

flags;

// This is the structure of the callers save registers on the stack
// after an int. function entry

struct callers
i
unsigned es;
unsigned ds;
unsigned di;
unsigned si;
unsigned bp;
unsigned sp;
unsigned bx;
unsigned dx;
unsigned ex;
unsigned ax;
unsigned ip;
unsigned cs;
unsigned flags;
> ;

// This definition provides a simplified means to set the interrupt vector to the service routine.

#define I ink_interrupt( level, name) set_vector(level l bios_cs() f name)

//

#define variables typedef struct (\

unsigned length tag; \

unsigned user i3;\

unsigned ax;\~

unsigned cx;\

unsigned dx;\

unsigned si;\

unsigned di;\

unsigned bp;\

unsigned bx;

unsigned ds;\

unsigned es;\

unsigned flags;\

unsigned jmp off;\

unsigned jmp seg;\

unsigned code_string[18]; /* reserved for code string */ \

#define end_variables unsigned char size; >

// This definition sizes the block acquire to include the variables specified
// in the variable declaration

#define acquire block(id) acquire scratch block(id, \
(&myblock->size~- &myblock->lengtff tag) +~\
(16-((&myblock->size - &myblock->length_tag) X 16)))

//

// definitions of variables in data segment segment 40h

/* this is so we can do LDS BX */ \

#define VECTOR(nr) (*( (unsigned long far *)
#define VECTOR 00 (*((unsigned long far *)
#define VECTC4T00 OFFSET (*(<unsigned far *)
#define VECTOR~00~SEGMENT (*((unsigned far *)

#define VECTOR 00 (*((unsigned long far *)
#define VECTOR"00 OFFSET (*((unsigned far *)
#define VECTOR^OO'SEGMENT (*( (unsigned far *)

#define VECTOR 00 (*((unsigned long far *)
#define VECTOR"00 OFFSET (*((unsigned far *)
#define VECTOR~00~SEGMENT (*( (unsigned far *)

#define VECTOR 13 (*((unsigned long far *)
#define VECTOR'13 OFFSET (*((unsigned far *)
#define VECT0R~13~SEGMENT (*((unsigned far *)

#define VECTOR 40 (^((unsigned long far *)
#define VECTOR"40 OFFSET (*( (unsigned far *)
#define VECTOR~40~SEGMENT (*((unsigned far *)

4 * nr))
0x0000))

0x0000))

0x0000))

0x004c))

0x0100))

0x0000))
0x0002))

0x0000))
0x0002))

0x0000))
0x0002))

0x004c))
0x004e))

0x0100))
0x0102))

Section E: The C Programs

E-l-4 The Kit.h File

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

#de

(We

#de

#de

#de

#de

#de

/*

/*

/*

#de

#de

#de

#de

#de

#de

#de

#de

#de

ne SYSTEH SEGMENT PTR ('((unsigned far *) 0x40e))
ne SWITCH"BYTE ('^unsigned char far *) 0x410))
ne EQUIP FLAG ('((unsigned far *) 0x410))
ne MEMORY SIZE (*( (unsigned far *) 0x413))
ne KB FLAG ('((unsigned char far *) 0x417))
ne KB~FLAG 1 (*((unsigned char far *) 0x418))
ne ALT INPUT (*( (unsigned char far *) 0x419))
ne BUFFER HEAD (*((unsigned far *) 0x41a))
ne BUFFER~TAIL (*((unsigned far *) 0x41c))
ne KB BUFFER ('((unsigned far *) 0x41e))
ne SEEK STATUS (*( (unsigned char far *) 0x43e))
ne MOTOR" STATUS (*( (unsigned char far *) 0x43f>)
ne MOTOR'COUNT (*( (unsigned char far *) 0x440))
ne DISK STATUS (*( (unsigned char far *) 0x441))
ne CRT RODE (*( (unsigned char far *) 0x449))
ne CRT~COLS (*( (unsigned far *) 0x44a))

CRT"LENGTH (*((unsigned far *) 0x44c))
CRT~START (*((unsigned far *) 0x44e))

ne CURSOR POSH (*( (unsigned far *) 0x450))

ne CURSOR'MOOE (*( (unsigned far *) 0x460))

ne ACTIVE"PAGE (*((unsigned char far *) 0x462))

ne AD0R 6845 (*((unsigned far *) 0x463))

ne CRT RODE SET (*((unsigned char far *) 0x465))

ne CROaLLFTTE (*( (unsigned char far *) 0x466))

ne V OFFSET (*( (unsigned far *) 0x467))

ne VSEGMENT (*( (unsigned far *) 0x469))

ne \TFLAG (*(( unsigned char far *) 0x46b))

ne TIMER LOU (^((unsigned far *) 0x46c))

ne TIMER~HIGH (*((unsigned far *). 0x46e))

ne TIMER""LONG (*( (unsigned long far *) 0x46c))

ne TIMER'LONG MAX 0x1800b0 /* 24 hour count */

ne TIMER~0FL T*((unsigned char far *) 0x470))

ne BIOS BREAK ('((unsigned char far *) 0x471))

ne RESET FLAG ('((unsigned far *) 0x472))

ne HD STKTUS1 ('((unsigned char far *> 0x474))

ne HD~NUM ('((unsigned char far *) 0x475))

ne HD"CONTROL ('((unsigned char far *) 0x476))

ne LPT TIMEOUT LIST ('((unsigned char far *) 0x478))

ne COMH TIMEOUT LIST ('((unsigned char far *) 0x47c))

ne BUFFER START~(*( (unsigned far *) 0x480))

ne BUFFER~EN0 ('((unsigned far *) 0x482))

ne ROWS ('((unsigned char far *) 0x484))

ne POINTS ('((unsigned far *) 0x485))

ne INFO ('((unsigned char far *) 0x487))

ne INFO 3 ('((unsigned char far *) 0x488))

ne HD STATUS ('((unsigned char far *) 0x48c))

ne HD"ERROR ('((unsigned char far *) 0x48d))

ne HD"IMT FLAG ('((unsigned char far *) 0x48e))

ne HF~CNTffL ('((unsigned char far *) 0x48f))
90-493 are floppy disk drive and media type bytes */
94-497 are floppy disk drive current track positions */
b flags 2 and 3 must be re-located if using more than 2 floppy drives
ine KB FLAG 3 ('((unsigned char far *) 0x496))
ine KB"FLAG"2 ('((unsigned char far *) 0x497))
ine USER FLA"G ('((unsigned far *) 0x498))
ine USER~FLAG SEG ('((unsigned far *) 0x49a))
ine RTC TOW ('((unsigned far *) 0x49c))
ine RTC"HIGH ('((unsigned far *) 0x49e))
ine RTCWAIT FLAG ('((unsigned char far *) 0x4A0))
ine PRSt BUST ('((unsigned char far *) 0x500))
ine BOOT"AREA ('((unsigned char far *) 0x7c00))

end Of biOSkit.h ssasssassswssssssasssssssssssssss*/

A-Tvpe BiosKIt

The Misc File E-2-1

TWO
The Misc File

The Misc.c file contains functions which are used by various modules. Many of the
functions used by the Setup and Watch commands in Sysvue reside in this file. The
register snapshot routines are in here, as well as most of the support functions for
the 8042 keyboard controller chip.

/*********************************************************************************************^

* Copyright (c) FOSCO 1988, 1989 - All Rights Reserved

* Module Name: AT Bios misc. functions

*

* Version: 1.02

*

* Author: FOSCO

*

* Date: 10-20-89

* Filename: atmisc.c

*

* Language: MS C 5.1

*

* Functional Description:

* This module includes miscellaneous functions used by various modules.

*

* Arguments:

* Return:

*

* Version History:

* 1.01

* Changed the "current video 1 * peekb40 from 0x13 (mem size) to 0x10 (switch byte)

* 1.02

* Added 8253 timer-based timeout support

*
***********************************************************************

/♦INCLUDE FILES*/

#include "atkit.h"

/♦FUNCTION PROTOTYPES*/

void eoi_sequence();

extern unsigned char type byte;
extern unsigned char decjirrayW];
extern const unsigned char hdisk_table;
void pause(void); ~

unsigned get video(void);
unsigned sen3 8042 (unsigned);
unsigned send~8042 data( unsigned);
unsigned wait~to rx 8042(void);
unsigned wait~to~send_8042(void);

/♦LOCAL CONSTANTS*/

// these are the text words for the setup program

const display list[] =
i

"EGA".

"CGA 40 x 25",

"CGA 80 x 25",

"Monochrome",

>;

/♦PROGRAMS*/

/*=========== send EOI to Interrupt Controller ==========*/

void eoi_sequence() i outportb( 0x20, 0x20); >
/*====—== Dump hex word on Console ==============*/

E-2-2 The Misc File

void Iword(w) {lbyte(w » 8); Ibyte(w);}

/*======== Dump hex byte on Console ==============*/

void Ibyte(outchar)
i

unsigned char c;

c = (outchar » 4) & OxOf;

if (c > 9) c+= 7;

co(c + '0');

c = outchar & OxOf;

if <c > 9) c+= 7;

co(c + '0');
>

/*===s=s=a Check for 0-9, a-f, A-F character =====*/
unsigned ishex(c) /* returns true or false */

if <(c >= '0') && (c <= '9')) return (true);

if ((c >= 'a') && (c <= 'f')) return (true);

if ((c >= 'A') && (c <= 'F')) return (true);

return( false);
>
/*======== Check for a-z character =====»=======»*/

unsigned islower(c) /* returns true or false */

if ((c >= 'a') && (c <= 'z')) return (true);
return(false);

/*======== Check for a-z, A-Z character a=s=sss*/

unsigned isalpha(c) /* returns true or false */
i

if ((c >= 'a') && (c <= 'z')) return (true);

if ((c >= 'A') && (c <= 'Z')) return (true);

return( false);
>
/*======== write String on Console ===*==========*/

void write string(loc)
C
while (peekb(bios_cs(),loc) != 0) I co(peekb(bios_cs() # loc++)); >

/*======== set Interrupt Vector ==*=====*====*/

void set vectord'nt number, seg, off )
i

disableO;

poke(0x00,int number * 4.off):

poke(0x00,(inT number * 4) + 2,seg);

enableO; ~
>

/*======== Read CMOS Ram ============*/

unsigned char i nemos ( unsigned address)
i
outportb( 0x70, address | 0x80); return(inportb(0x71));

/*======== write CMOS Ram ====x«=a Sa i=*/

void outcmos(unsigned address, unsigned char value)
outportb( 0x70, address | 0x80); out portb( 0x71, value );

/*======= return true if (type == arg) =======*/

// If you wish to dynamically determine the kind of machine, then these functions will check

// the type byte.

// To determine CPU type, expand this function with CPU testing.

// check for motherboard type

unsigned type( unsigned int arg)
i
if((arg == at) || (arg == xt))

if ((arg == xt) && (peekbcs(&type byte) == xt))\

return(true); ~

if ((arg == at) && (peekbcs(&type byte) == at))\

return(true);

A-Tvpe BiosKit

The Misc File E-2-3

if((arg ==86) || (arg == 186) ||

(arg == 286) || (arg == 386))// check for cpu type

return(false);
>

return(false);
>

#define swapped 1 // in myblock->status, this tells if stack is swapped

extern unsigned start_plock;
extern unsigned current open;
extern unsigned end block;
extern unsigned watch_flag;

variables
end_variables poolregs;

// block size is passed as number of bytes needed.

unsigned acquire_scratch_block( unsigned id, unsigned block_size)

poolregs *block_ptr;

setds system segmentO;

disableO; ~

if ((current open + block size) < end block)

i

// this open space is alloca table

blockjDtr = current open;

current open += block size:

block_ptr -> length tig = block size;

block_ptr -> user_i3 = id; ~

if((id &' (watch flag & (WATCH MASK))) != 0)
i

write string("\n\rAcquire Block "); Iword(blockptr);

if(id~== FLOPPY) write string(" Floppy");

if (id == HARD) write stringC Disk");

if (id == BOOT) write~string(" Boot");

if (id == CASSETTE) write string(» Cass");

if (id == EQUIPMENT) write string(" Equi");

if (id == MEMORY) write stringC Mem");

if (id == LPT) write string(" Lpt");

if(id == COM) write""string( M Com");

if (id == TOD) write""string( M Tod");

if (id == KEYBOARD) write string(" Kb");

return(blockj3tr);

// acquire the start block so we can flag system error

current open = start block;

sys err?0x1111); // This is an arbitrary code

ena5le();

return(current_open); // this is an error condition

void release_block(poolregs *block_ptr)

if((block_ptr ->user id & ((WATCH MASK) & watch flag)) != 0)
i

write string("\n\rRelease Block "); Iword(blockptr);

if(block_ptr -> user id == FLOPPY)

write stnng( M Floppy 1 ');

if(block_ptr -> user id == HARD) write string(" Disk");

if (block _ptr -> user~id == BOOT) write"string(" Boot");

if(blockjptr -> user~id == CASSETTE) "

write stnng(" Cass"T;

if(block_ptr -> user id == EQUIPMENT)

write_string(" Equi"T;

if(blockj3tr -> user id == MEMORY) write string(" Mem");

if(blockj3tr -> user""id == LPT) write string(" Lpt");

if(blockj3tr -> user~id == COM) write~string(" Com ,, );

if(block ptr -> user~id == TOD) write~string(" Tod");

if(block_ptr -> user^id == KEYBOARD) write_string(" Kb");

>

disableO;

// If you wish to zero out the released block, then a clear block function could be created here.

Section E: The C Programs

E-2-4 The Misc File

// clear_block(block_ptr,block_ptr -> length_tag);

block_ptr -> length tag = 0;
current open - bloclc_ptr;
enabled;
>

// register snapshots

// this will execute if the "watch" bit for the specified device is set

void snapshot in(unsigned device, struct callers far * frame)

if (watch (device))
i

write string("\n\rax="); lword(frame->ax);

write~string(" bx="); lword(frame->bx);

write~string(" cx= H ); lword(frame->cx)j

write"string(" dx="); lword(frame->dx);

write~string(" sp="); lword(frame->sp);

write~string(" bp="); lword(frame->bp);

write""string(" si= M ); lword(frame->si);

write~string(" di= M ); lword(frame->di);

write string("\n\rds="); lword(frame->ds);
write~string(" es="); lword(frame->es);

write~string(" ss= H ); lword(&frame->es + 1); // this = old ss
write~string(" cs="); lword(frame->cs);
write"string(" ip="); lword(frame->ip);
write~string(" ••);

if(device == FLOPPY) write stringC FLOPPY ");
if (device =* HARD) write string<" DISK ••);
if(device « BOOT) write~string(" BOOT ");
if (device == CASSETTE) write string(" CASS •');
if(device *= EQUIPMENT) write stringC EQUI ");
if(device == MEMORY) write stringC MEM »);
if (device == LPT) write stringC LPT ");
if(device == COM) write~string(" COM ");
if (device « TOO) write~string(" TOO ••);
if (device == KEYBOARD) write stringC KB ");
>
>

void snapshot out (unsigned device, struct callers far *frame)

<:

if(watch(device))
C

write string("\n\rax="); lword(fraroe->ax);

write""stringC bx="); lword(frame->bx);

write""stringC ex*"); lword(frame->cx);

write~stringC dx="); lword(frame->dx);

write~string(" sp="); lword(frame->sp);

write~string(" bp=°); lword(frame->bp);

write~stringC si="); lword(frame->si);

write~string(" di= M ); lword(frame->di);

write stringC\n\rds="); lword(frame->ds);
write~string(" es= M ); lword(frame->es);
write~string(" ss= M ); lword(&frame->es + 1);
write~stringC cs="); lword(frame->cs);
write~"string(" ip= M ); lword(frame->ip);
write""stringC Carry*"); lword(frame->f lags & 0x01);
>
>

void watch string( unsigned device, unsigned msg)
C

if(watch(device)) write string(msg);
>

void watch word(unsigned device, unsigned msg)
{

if(watch(device)) I word (msg);
>

void watch byte(unsigned device, unsigned msg)
{

if (watch (device)) Ibyte(msg);
>

void watch char(unsigned device, unsigned msg)

<:

if(watch(device)) co(msg);
>

A-Tvpe BiosKit

The Misc File E-2-5

// these will execute only in the cold-boot condition
// they will not execute for warm-boot

void cold st ring( unsigned msg)
C

if(coldO) write string(msg);
>

void cold word( unsigned msg)

<:

if(coldO) Iword(msg);
>

void cold byte(unsigned msg)
i

if(coldO) Ibyte(msg);
>

void cold char(unsigned msg)

<:

if(coldO) co(msg);
>

//============ S et the timer counter on boot up =====

#define seconds
#define minutes 2
#define hours 4

#define counts sec 18

#define counts~min 1092

#define counts~hr 60 * counts jnin

unsigned long ImuKunsigned long, unsigned);
unsigned convert_binary(unsigned char);

unsigned set count (void)
C

unsigned char temp;

unsigned long count,long_temp;

if ((temp = i nemos (hours)) > 0x23) return(error);
long temp = convertjsinary(temp);
count = lmul(long_temp,counts_hr);

if ((temp = i nemos (minutes)) > 0x59) return(error);
long_temp = convert_binary(temp);
count += lmul(long_temp,counts_min);

if ((temp = i nemos (seconds)) > 0x59) return(error);
long temp = convert binary(temp);
count +=lmul(long_temp,counts_sec);

TIMER LONG = count;
return(ok);
>

Return the drive type for a specified drive,
drive 00-03 = floppy
drive 80-81 = hard

unsigned char cmos_drive_type( unsigned char drive_nr)

switch (drive nr)
i

case 0: return(incmos(0x10) » 4);

case 1: return(incmos(0x10) & OxOf);

case 2: return<incmos(0x11) » 4);

case 3: return(incmos(0x11) & OxOf);

case 0x80:

if((incmos(0x12) » 4) == 15) return(incmos(0x19));

return(incmos(0x12) » 4);

case 0x81:

if((incmos(0x12) & 15) == 15) return(incmos(0x1a));

return(incmos(0x12) & OxOf);
>
return(O);

//========== return the cmos system memory size =====

Section E: The C Programs

E-2-6 The Misc File

unsigned cmos memO

unsigned temp;
temp = incmos(0x16);
temp = temp « 8;
temp |= incmos(0x15);
return<temp);
>

//========== return the cmos extended memory size =====

unsigned cmos ext()
i

unsigned temp;

temp = incmos(0x18);

temp = temp « 8;

temp |= incmos(0x17);

return(temp);

//==== return the cmos extended found memory size =====

unsigned cmos ext foundO
C ~ "

unsigned temp;

temp = incmos(0x31);

temp = temp « 8;

temp |= incmos(0x30);

return(temp);
>

// display the time

variables
end_variables timevars;

void display_time(void)

timevars *myblock;
myblock = acquire block(VUE);
myblock ->ax = 0x0200;
sys int(0x1a, myblock):
co(T<myblock->cx » 12) & OxOf) | '0');
co<((myblock->cx » 8) & OxOf) I '0');
co(':');

co<((myblock->cx » 4) & OxOf) '0');
co(<(myblock->cx ) & OxOf) '0');
co(':');

co(<(myblock->dx » 12) & OxOf) '0');
co(((myblock->dx » 8) & OxOf) I '0');
>

// display the date

variables
end_variables datevars;

void display_date(void)

datevars *myblock;
myblock = acquire block(VUE);
myblock ->ax = 0x0400;
sys_int(0x1a, myblock);

co(((myblock->dx » 12) & OxOf) I # 0');

co(((myblock->dx » 8) & OxOf) I '0');

co(V');

co<((myblock->dx » 4) & OxOf) I '0');

co(((myblock->dx ) & OxOf) '0');

co(V');

co(((myblock->cx » 12) & OxOf) '0');

co(((myblock->cx » 8) & OxOf)

co(( (myblock- >cx » 4) & OxOf)

co<((myblock->cx ) & OxOf)
>

'0');
'0');
'0');

// this is the text list for the floppy drive types

const drive listt] =

i

"No Drive"

"360k",

"1.2M",

"720k",

"1 .44M"

"Unknown", /* "2.88M could go here if implemented */

"Unknown",

A-Tvpe BiosKSt

The Misc File E-2-7

"Unknown",

>;

// display the disk drive configuration

void display_drives(void)

unsigned next hard = 'C;

// the letter~code of the next hard drive

// find the number of floppy drives
if((incmos(0x14) & 0x01) != 0)

if (cmos_drive_type(0) != 0)

write string( M \n\r Drive A: ")j

write~string(peek<bios_cs<),&drive_list[cmos_drive_ > type(0)]>);

if(((incmos(0x14> » 6) & 0x03) > 0)
C
if (cmos_drive_type(1) != 0)

write string("\n\r Drive B: M )j

write~string(peek(bios_cs<) # 4drive_Ust[cmos_drive_type(1)]));

if((<incmos(0x14) » 6) & 0x03) > 1)
C
if (cmos drive type<2) != 0)

i -A

write stnng("\n\r Drive C: ")f

write~string(peek<bios_cs(),&drive_hsttcmos_drive_type<2)]));

if(((incmos<0x14) » 6) & 0x03) > 2)

if (cmos_drive_type<3) »= 0)

write string("\n\r Drive D: M )j
write"string(peek(bios_cs(),Wrive_list[anos_ - drive_type<3)]));

>
>
>
>

// The letters used for the disk drives can change depending on the number of floppy drives in the
// system. Find the number of floppy drives

if((incmos(0x14) & 0x01) !- 0)
i

if((<incmos<0x14) » 6) & 0x03) > 1) next hard++;

if(((incmos(0x14) » 6) & 0x03) > 2) next~hard++;
>

if (cmos_drive_type<0x80) !* 0)

write string("\n\r Drive ••); co(next_hard);
write~string( M : Type '•);

// this should be printed in decimal !!
lbyte(cmos drive type(0x80));

> "

if (cmos_drive_type<0x81) != 0)

write string( M \n\r Drive "); co(next hard*1);
write^string(": Type '•);

// this should be printed in decimal !!
lbyte(cmos drive type(0x81));

> "
>

display video type

void display_video(void)

write string<"\n\r Default Video: ");
write'stringCpeekCbios^sO.&display^listtget^videoO]));

write string("\n\rExpected Video: ");
write~string(peek<bios_cs() f &display_ j> list[(incmos(0x14) » 4) & 0x03]));

write_string("\n\r Current Video: ");

Section E: The C Programs

E-2-8 The Misc File

write string(peek<bios cs(),&display list[<SUITCH BYTE » 4) & 0x03]));
>

/* calculate cmos checksum

unsigned calc cmos(void)
i

unsigned j,x.sum = 0;

x = (incmos(0x2e) « 8) | incmos(0x2f);

for(j=0x10:j<=0x2d;j++) sum ♦= incmos(j);

out cmos (OxZe, sum » 8);

out cmos ( 0x2 f , sum) ;

return(x);
>

display sys mem size

display sys mem()
i " "

bin2dec(cmos mem(),&dec array);

co(dec arrayTO]); ~

co<dec~array[1]);

co(dec~array[2] );

co(dec~array[3] );

co(dec~array[4]);
>

/* display ext mem size

display ext memo
C " "

bin2dec(cmos ext(),&dec array);

co(dec arrayTO]);

co(dec~array[1] );

co(dec~array[2] );

co(dec~array[3] );

co(dec""array[4] );
>

/* set sys mem size

set sys mem( unsigned sys size)
<: " ~

out cmos (Ox 15, sys size);

outcmos(0x16,sys~size » 8);

calc cmos();
>

set ext mem size

set ext mem( unsigned ext size)
i " "

outcmos(0x17,ext size);

outcmos(0x18,ext~size » 8);

calc cmos();
>

/*== return the number of floppy drives in the system ==*/

unsigned number of floppies(void)

if (Cincmos(OxH) & 0x01) == 0) return(O);
return((incmos(0x14) » 6) ♦ 1);
>

/*==== display hard disk table parameters ==x=*/

void display_hdisk_types(void)

unsigned qq, jk.cyls, heads, sectors. approx size;

// list the table entries, calc the approximate disk size

// use the sectors/track to accomodate the RLL drives

// format is:

// type, cyls, heads, sectors, size

write_string( M Type Cylinders Heads Sectors Size\n\r H );

jk = 0; qq=1j

while(peek(bios cs(), jk+&hdisk table) != -1)

// display drive type
bin2dec(qq,&dec array);
co(dec array [2] T;
co(dec~array[3]);
co(dec~array[4]);
write ItringC ");

A-Tvpe BiosKit

The Misc File E-2-9

// display cylinders

cyls = peek(bios cs(), jk+&hdisk_table);

bi n2dec< cy I s , &dec_array ) ;

co(dec array[03);~

co(dec'~array[13)

co<dec~arrayt2])

co(dec~array[3])

co(dec~array[4])

write_string(" ••);

// display heads

heads = peekb(bios cs(), jk+2+&hdisk table);

bin2dec( heads. &dec~ar ray); ~

co(dec arrayCu] );

co(dec""array[1]);

co<dec~array[23);

co(dec~array[3]);

co(dec~array[41 );

write_string<" ");

// display sectors

sectors = peekb(bios cs(),jk+14+&hdisk_table);

bi n2dec( sectors, &dec~ar ray) ;

co(dec arraytO]);

co<dec~array[13);

co(dec~array[2]);

co(dec""array[3] );

co(dec~array[4] );

write_string<" ");

// display size (cyls*heads*sectors) in Mbytes

approx_size = calc_hdisk_size<cyls, heads, sectors);

bin2dec(approx size,&dec array);

co(dec array [OT); ""

co(dec~array[1])

co<dec~array[2])

co(dec""array[3])

co<dec"array[4])

write_string<"\n\r");

gq++;

jk = jk ♦ 16: // look to next table entry
if((qq & OxOOOf) == 0)

pauseO;

write string("Type Cylinders Heads Sectors Size\n\r H );
>
>
>

pause and wait for key

void pause(void)

while(kbhit()Kci();>; // get any pending keys

write string( M hit any key for more \n\r");

while?!kbhit()X>;
>

/* display MPX status ■

void display npx(void)
i

write string( "Expected: ");

if((incmos(0x14) & 0x02) == 0)

i
write string( M No M );

else
i

write string("Yes M );
>

write string<" Found: ");
if((S0lTCH BYTE & 0x02) == 0)

<:

write string<"No");
>

else
i

write stringCYes");
>

Section E: The C Programs

E-2-10 The Misc File

// return a long timeout count

// - returns a long TIMER LONG + count, corrects for 24 hour rollover
// - if rollover near, then delay until rollover, then return count

unsigned long get current timer(void)
i ~

return< TIMER LONG);
>

unsigned long set timeout count (unsigned count)

while((get_current_timer() + count) > TIMER LONG MAX);
return(get~"current~timer() + count);
>

// keyboard controller support

The 8042 keyboard controller uses ports 0x60 and 0x64.

0x60 = data in and out

0x64 = status in.

The status bits are:

Bit Description

7 Parity error = odd (no error), 1 = even

6 rx timeout 1 * error

5 tx timeout 1 = error

4 inhibit 0/1 * inhibit/not inhibited

3 data/command port 60 = data/command

2 system flag 0* powerup, 1= reset

1 inp bfr full 0/1 = empty/full

out bfr full 0/1 = empty/full

8042 commands (to port 64):

0x60 write next byte (0x64) to controller: (use 0x45)
Bit Description

7 always

6 1 a PC compatibility mode

5 1 = PC mode

4 1 = disable keyboard

3 1= inhibit override

2 0= reset system flag

1 always

1 = enable out bfr full int. (IRQ1)

Oxaa self test 8042

returns 0x55 in out bfr (0x60) if OK

xOcO read 8042 input port into out bfr (0x60)
bit Description of input port

7 0/1 = keylock switch locked/not locked

6 0/1 = CGA/MDA vidoe jumper

5 0/1 Mfg Jumper present/absent

4 0/1 system ram = 512/256 K

0xd1 write next byte (0x64) to controller

bit Description

7 kb data out line

6 kb clock out line

1 Gate A20

1= reset system

// reset the 8042

unsigned reset 8042O
i

unsigned stat = ok;

// mask out interrupts in case they are still enabled

outportb( 0x21. inportb( 0x21) | 0x02);

// purge the 8042' s output buffer

inportb(0x60):

// reset the 8042

if (wait to send 8042O == error) stat = error;

if(sencT80?2(0xaa) == error) stat = error;

if(wait~to rx 8042O == error) stat = error;

if(inportbT0x50) != 0x55) stat = error;

// configure 8042

if (wait to send 8042 () == error) stat = error;

if(sencT8052(0x50) == error) stat = error;

A-Tvpe BiosKit

The Misc File E-2-11

outpor tb< 0x60 , 0x45 ) ;
outportb(0x21,inportb(0x21) & -0x02);
return(stat);
>

// this gets the video jumper byte from the 8042

// returns 2 = CGA, 3 = MDA

unsigned get videoO
C

unsigned temp = 0;

outportb(0x21.inportb(0x21) | 0x02);

wait to send 8042O;

sencT80?2(0xc0); // read the jumper command

wait~to rx 8042O;

temp""= Tnportb(0x60);

outportb(0x21,inportb(0x21) & -0x02);

if ((temp & 0x40) == 0) return(2);

// return CGA index value, else

return(3); // return MDA index value
>

// wait until 8042 ready to accept another byte

unsigned wait to send 8042O

unsigned long jj = set_timeout_count(20); // 1 second delay

do < if((inportb(0x64) & 0x02) == 0) return(ok); > while (TIMER LONG < )]);
return( error);
>

//--- wait for 8042 output buffer to be loaded

unsigned wait to rx 8042O
i - - -

unsigned long jj = set_timeout_count(20); // 1 second delay

do t if((inportb(0x64) & 0x01) != 0) return(ok); > while (TIMER LONG < jj);
return(error);

// — send a command and wait until accepted —

unsigned send 8042 (value)
C
out portb( 0x64, value); return(wait_to_send_8042());

// — check buffer ready and send data —

unsigned send 8042 data(value)
{

unsigned trys = 10;

while (trys-- > 0)

i
if(wait_to_send_8042() == ok) < outportb(0x60, value); return(ok); >

return( error);
>

Section E: The C Programs

Things Worth Making A Note Of

The Pod File E-3-1

THREE
The Pod File

The Pod.c (Power On Diagnostics)file contains power-up diagnostics and initializing
routines. This file inits some of the peripherals and also calls the setups for most of
the other function calls. A general convention to develop (it has been implemented
for some cases) is to examine the status returned from a function call setup routine,
to determine the degree of success in initializing a device (such as video, disk,
keyboard, etc.) This returned status can then be used to display an enhanced
message during the POD.

* Copyright (c) FOSCO 1988 - All Rights Reserved

* Module Name: AT bios power on diagnostics

* Version: 1.01

* Author: FOSCO

*

* Date: 12-31-88

*

* Filename: biospod.c

* Language: MS C 5.1

* Functional Description:
*

* This module does the power on diagnostics and initialization. When it finishes, it does

* a bootstrap to load the system.

* Arguments:

*

* Return:

*

* Version History:

* Added NMI disable bit to the read swtiches function.

/♦INCLUDE FILES*/

#include "atkit.h"

/♦FUNCTION PROTOTYPES*/

void biospod(void);
unsigned comm_setup(void);
unsigned Ipt setup(void);
void biospodTvoid);

unsigned xchg(unsigned, unsigned, unsigned);
unsigned ram test(unsigned segment, unsigned length);
void move system segment (unsigned, unsigned);
unsigned char read switches(void);
unsigned rom_checkTunsigned);
void cout( unsigned char);
unsigned checksum( unsigned, unsigned, unsigned);
unsigned cold(void);

/♦GLOBAL VARIABLES*/

extern unsigned start block;

extern unsigned current_open;

extern unsigned end block;

extern unsigned block beg;

extern unsigned block~end;

variables
end_variables podregs;

/♦GLOBAL CONSTANTS ♦/

extern $iret;

E-3-2 The Pod File

extern Sdunmy isr;
extern dividej
extern bios id;
extern date's tamp;
extern bios^start;

/♦LOCAL DEFINITIONS*/

#def
#def
#def
#def
#def
#def
#def
#def
#def
#def
#def
#def

ne piojxirt b 0x61

ne default equip 0x006d

ne boot reTrys 6

ne dma 0x00

ne inta01 0x21

ne timer controlport 0x43

ne timer~counterj)_Po r t 0x40

ne timer~counter~2_port 0x42

ne port 5 0x61

ne cp ~ 13

ne escape 27

ne carry bit 0x0001

/♦PROGRAM*/

// Biostop module already has found 64k of ram to operate with.

void biospod(void)

podregs *myblock;

unsigned ext mem size = 0;

unsigned dummy, ~

rom scan end, /* end segment value for rom scan */

i , J'7

cs, /* save for code segment value */

error code: /* temp save for returned error codes */

unsigned char checksum;

unsigned video status; // returned from video setup

unsigned equipment status; // returned from equip setup

cs = bios_cs<);

/* use top of 1st 64k for system segment */
SYSTEM_SEGMENTJ>TR = 0x1000-(sys_seg_size » 4);

/* set pool delimiters */

setds system segmentO;

start~block = current open = &block beg;

end_bTock - &block_en3;

/* set the equipment switch flag */
SUITCH_BYTE = read_switches();

/* load default interrupt vectors */

f or( i=0, j=0; i<31 ; i++, j+=4)
i

poke( 0x0000, j,&$i ret); /* load software defaults */

/* override hardware defaults */

if (<i >= 8) && (i <= 16)) poke( 0x0000, j,&$dunmy isr);

poke< 0x0000, j +2, cs);

/* load default interrupt vectors for 8259 #2 */

for( i=0, j=0x70*4; i<8; i++, j+«4)
i

poke( 0x0000, ],4$dummy isr);

poke(0x0000,j+2,cs);

/* div by zero interrupt */
poke(0x0000, 0x0000, &di vide);

setup the 8255 if one exists

outportb( 0x63, 0x99): /* set the control register */
outportb(port_b,0x70); /* disable the parity checkers */

setup the dma controllers

#def ine DMA1 0x00
#define DMA2 OxcO

outportb(DMAl+8.0x04); // disable dma #1
outportb(DMA2+16,0x04); // disable dma #2

outportb<DMA1+13,0x00); // master clear
outportb(DMA2+26,0x00);

A-Tvpe BiosKit

The Pod File E-3-3

outportb(DMAl+8,0x00); // now do dma setup
outportb<DMA2+l6,0x00>;

outportb(DMAl+11,0x40); // set the channel defaults

outpor tb<DMA2+22, OxcO ) ;

outportb<DMAl+1 1 ,0x41 );

outportb(DMA2+22,0x41 );

outportb(DMAl+1 1,0x42);

outpor tb< DMA2+22 , 0x42 ) ;

outportb(DMA1+1 1,0x43);

outportb<DMA2+22, 0x43 ) ;

outportb(DMA2+20,0x00); // enable cascade of ch#

/* setup the 8259 interrupt controller

outportb< 0x20, 0x11)
outportb< 0x21, 0x08)
outportb( 0x21 ,0x04)
outportb(0x21,0x01)
outpor tb( 0x21, Oxff)

outportb< OxaO , 0x1 1 )
outportb(0xa1 ,0x70)
outportb(0xa 1,0x02)
outportb(0xa1 ,0x01 )
outportb<0xa1,0xff)

// icwl
// icw2
// icw3
// icw4
// disable all interrupts

// icwl
// icw2
// icw3
// icw4
// disable all interrupts

/* allow any stray interrupts to be reset */
enableO;

setup adapters and peripherals

equipment status=equipment setupO;
video_staTus=video_setup< )J

write string("\n\r");
write"string(&bios id);
wr i te~st r i ng(&date~stamp) ;

// If a restart sequence is generated which we do not recognize, we abort to a regular re-boot,
// and display the unknown restart code.
if(incmos(0x0f) != 0) // invalid restart code

write string("\n\rlnvalid Restart Code -");lbyte<incmos<0x0f));
>

cold string<"\n\rBios at "); cold word(bios cs());

cold~string<"\n\rLow 64K Ram Test ");

if(peek(0x00, 0x412) == 0) // check low-ram error flag

cold stringC'OK");
>

else
i

cold string( M Error");
>

cold stringO'VArVideo Function ");

colcrstringCOK");

colcrstring<"\n\rEquipment Function. ...");
0010^™^^");

colcrstring<"\n\rKeyboard Function ");

if(keyboard_setup() == ok)

cold stringC'OK");
>

else
i

cold stringC'Error");
>
enableO:

cold string< H \n\rSysVue "); sysvue setupO;

coltTstringCOK");

cold~string("\n\rMemory Size Function.."); mem size setupO;

colcTstringCOK");

colcTstringC'XnXrTimer Function "); timer setupO;

colcTstringCOK");

colcTstring<"\n\rTime of Day Function.."); time of day setupO;

if (set count () == ok) // set the timer counter"" ~ ~

i

cold stringC'OK");
>

else
i

Section E: The C Programs

E-3-4 The Pod File

cold stringC'Error");
>

cold string("\n\rPrint Screen "); print screen setupO;

cold~string<"OK");

cold~string("\n\rCassette Function "); cassette setupO;

cold~string<"OK");

cold~string<"\n\rBootstrap Function.... ••); boot setupO;

colcTstringCOK");

/* enable speaker */

outportb(pio_port_b, inportb(pio_port_b) & -0x03);

setup timer for the rtc

outportb< timer control_port,0x36);
outportb( t i mer~"counter~0_port , Oxf f ) ;
outpor tb< t i mer~counter~0 _por t , Oxf f ) ;
outportb(0x21,Tnportb(UxZ1) & -0x01); /* enable the rtc */

setup timer 2 for the beeper

outportb( timer control_port,0xb6);
outportb( t imer~counter~2_port , 0x33) ;
outportb(timer3counter~2_port,0x05);

/*

Size and Test Ram - from 64K up to 640K

cold^stringCXn");

for (i = 64; (i < 640) && (ram_test(i « 6,32768) « ok); MEMORY_SIZE = i += 64);

cold string<"\rRam Test at ");cold word(i « 6);

cold~string<» - OK ");
>

// Now reset the sys segment to the top of ram. The function will copy the 0f80h bio
// the system segment then reset the stack segment register to it, then do a return.

MEMORY_SIZE « (i = MEMORY SIZE - sys^seg_size/1024);
move system segment (i « 5, sys seg sTze)J
coldrstring7 M \n\rSystem Segment atT. . H );cold_word(i«6);

now test ram above 1Meg

// extended mem test returns ok/error
// if ok - size is in cmos(30 and 31)

write string("\n");

if (test ext mem<) == ok)

i ~ ~

ext mem size = incmos(0x31) « 8 | i nemos (0x30);

if(ext mem size == 0)

C " "
cold string( M \rExtended Ram Mot Found");

>

else

C
for (i = 0;i <= extjnem_size;i +«64)

cold string<"\rExt Ram at ");cold word((i » 4) + 0x1000);

col<Tstring<"0");
cold~string(" - OK ");
>
>
>

else
C
if(inportb(0x80) < 0x80)

cold_ - string<»'\rError on A20 Control...");

else
C

cold string("\rException Error ");

cold~byte(inportb(0x80) & -0x80);
>
>

do a checksum on the rom bios prom

cold string("\n\rRom checksum ");

checlcsum = checksum_bios_block();

A-Tvpe BiosKit

The Pod File E-3-5

if (checksum == 0) cold_string("OK");

else

C

write stringC'Error ");

IbyteTchecksum);
>

/* enable timer and kb interrupts V

outportb(0x21,inportb(0x21) & Oxfc);

/* setup the comm and Ipt ports */

cold string("\n\rCOM Function "); comm setupO;

coicrstringt" ^");

cold string("\n\rLPT Function "); Ipt setupO;

colcTstringC'OK");

/* check for game port */

if <<inportb< 0x0201) & OxOf) == ) EQUIP_FLAG |= 0x1000;

/*

setup the floppy disk controller
V

cold string( M \n\rFloppy Disk ");

if (Tdisk setupO == ok)
i

cold string("OK");
>
else

cold string("OK");
>

/*

setup the hard disk controller

cold string( M \n\rHard Disk Check ");

if ((error code = hdisk setupO) == ok)
C

cold string("..OK");
>
else

<:

cold word(error code);
>

Check for optional rom modules from c8000 -> beginning of bios in 2k increments.
A valid module has'55aa' in the first 2 locations, length indicator (length/512) in the
3rd location, and test/init. code starting in the 4th location. These modules may adjust
the mem size downward to reserve scratch ram memory.

rom scan end = &bios start;

rom~scan~end = ( rom_scan_end » 4) | OxfOOO;

cold strina( M \n\rScan Rom from '•);
coldTword(0xc800); cold stringC to ••);
colcTword(rom_scan_end)7 co^stringe'VAr 11 );

// for debugging !!

//rom scan end = OxdOOO; // keeps from re- loading our self

// rom-scan logic has problem with >= 64k blocks !!

for (i=0xc800;i<rom_scan_end ;i = rom_check( i ) ) ;

cold_string("\n\rRom scan complete");

/* *>

/* re-enable the rtc in case scan module disabled it */
outportb( 0x21, inportb( 0x21) & -0x01);

/*=-=-=-=-=-= now do the boot =-=-=-=-=-=-=-=-=*/

Section E: The C Programs

E-3-6 The Pod File

cold_string( M \n\r> Booting System <\n\r\n");

myblock = acquire_b lock (POD);

while (0==0) // stay in this loop forever

/* make sure kb interrupt is enabled */

outportb(0x21,inportb(0x21) & -0x02);

enableO;

beepO;

write stringC'VAr");

sys int(0x19,myblock); // try boot from boot module

sys~int(0x18,myblock); // try booting to SysVue
> "
release block(myblock);

I*

unsigned xchg(unsigned segment,
unsigned address, unsigned value)
C

register i,j;

i = peek( segment, address);

poke( segment , address , va I ue ) ;

j = peek( segment, address);

poke( segment , address , i ) ;

return (j);

read the cmos dipswitch

char read switchesO

outportb(0x70,0x94);

return< inportb(0x71 ) );
>
/*

unsigned rom check( address)
C

unsigned length, next address;

/* if not a module return next address */

if(peek(address,0) != 0xaa55) return( address + 0x80);
/* get length to checksum */

length - peekb( address, 2 )*5 12; // blocks are 512 bytes
next_address = address + (length » 4);

if (checksum( address, length) == 0)
i
if (address 1 = bios cs()) // don't call ourselves !!!
i

cold string("\n\rRom Signature found at : "); cold word( address);
far call(address,3);
> ~

return(next address);
>

unsigned war m( void)
i

if (RESET FLAG *= 0x1234) return(true);

return( false);
>

unsigned cold(void)
{

if (RESET FLAG != 0x1234) return(true);

return( false);
>

A-Tvpe BiosKit

The Equipment Driver E-4-1

FOUR
The Equipment Driver

The Equipment Configuration Driver is an Interrupt Function Call (Oxll) that is
used by DOS and other programs to determine the options which are present in a
system. It is called with no input parameters and returns a value in the AX register
describing the system options. The POD reads the configuration dipswitch and
stores this value along with an adapter configuration byte into the word at
0040:0010.

/**********************************************************************************************^

*

* Copyright (c> FOSCO 1988, 1989 - All Rights Reserved

* Module Name: AT Bios equipment function

*

* Version: 1.01

*

* Author: FOSCO

*

* Date: 10-20-89

*

* Filename: biosequi.c

* Language MS C 5.1

*

* Functional Description:
*

* Interrupt 0x11 - get equipment configuration

* This function call returns an equipment configuration word.

* The equip_flag variable is set during the power on.

* Returns the Equipment Word in AX:

* Bit Description

* 15,14 number of printers attached

* 13 =

* 12 = 1 = game port attached

* 11,10,9 number of rs232 cards attached

* 8 =

* 7.6 number of diskette drives

* 00=1, 01=2, 10=3, 11=4 only if bit = 1

* 5.4 initial video mode

* 00 - no video adapter

* 01 - 40x25 bw using color card

* 10 - 80x25 bw using color card

* 11 - 80x25 bw using bw card

* 3,2 not used

* 1 0/1 = no 8087/8087

* 0/1 = boot from int 18/f loppy disk

* Arguments:

* None

*

* Return:

* Equipment word in AX

* Version History:

* 1.01

* Replaced peeks and pokes with casts

***************************************************************************

/♦INCLUDE FILES*/

#include "atkit.h"

unsigned equipment setup(void);

void interrupt cdecl far equipment(interrupt_registers);

/♦GLOBALS*/

extern _equipment;

E-4-2 The Equipment Driver

/♦LOCAL DEFINITIONS*/

/♦PROGRAM*/

unsigned equipment setupO
C

I i nk_ i nter rupt < Ox 1 1 , &_equ i pment ) ;

return(ok); ~
>

void interrupt cdecl far equipment (interrupt registers)
i
ax = EQUIP FLAG;
>

A-Tvpe BiosKit

The Memory Size Driver E-5-1

FIVE
The Memoiy Size Driver

The Memory Size Driver is an Interrupt (0x12) Function Call that is used by various
programs (including DOS) to determine how much RAM is in the system.

/**********************************************************************^

*

* Copyright (c) FOSCO 1988, 1989 - All Rights Reserved

* Module Name: AT Bios memory size function

* Version: 1.01

*

* Author: FOSCO

*

* Date: 10-20-89

* Filename: atmem.c

*

* Language: MS C 5.1

*

* Functional Description:

* Interrupt 12h - get memory size

*

* This function call returns the amount of System RAM in AX.

* The value indicates the number of 1024 byte blocks of RAM.

* Arguments:

* None

*

* Return:

* Mem size in AX

*

* Version History:

* 1.01

* Replaced peeks and pokes with casts

*********************************************************************

/♦INCLUDE FILES*/

#include "atkit.h"

/♦FUNCTION PROTOTYPES*/

unsigned mem size setup(void); // called by pod to set the interrupt vector to the service routine
void interrupt cdecl far mem_size( inter rupt_registers); // returns the mem size in Ikbyte blocks

/* G L O B A I S */

extern _mem_size;

/♦DEFINITIONS*/

/* PROGRAM ♦/

unsigned mem_size_setup()

link interrupt (0x1 2, & mem size);
return(ok);
>

void interrupt cdecl far mem_size<interrupt_registers)

ax = MEMORY SIZE;
>

Things Not Worth Writing Down

The Keyboard Driver E-6-1

SIX
The Keyboard Driver

The Keyboard Driver is used to obtain keyboard input from the keyboard.

If a non-standard keyboard or alternate input device is being used, it is suggested
that the keyboard function call structure be retained. The application will then be
independent of the hardware characteristics of the actual input device, and may be
exercised in a development environment with the standard keyboard input device.

/***************************************************************************************************

* Copyright (c) FOSCO 1988, 1989 - All Rights Reserved

* Module Name: AT Bios keyboard driver

* Version: 1.06

*

* Author: FOSCO

*

* Date: 11-01-89

*

* Fi lename: atkb.c

*

* Language: MS C 5.1

* Functional Description:

* Arguments:

*

* Return:

*

* Version History:

* 1.01

* Added an nmi disable (out 70 with 8x) for re-boots (ctrl-alt del).

* -

* 1.02

* Modified buffer store to discard newest key on overrun.

*

* 1.03

* Improved numeric keypad handling.

* 1.04

* On "check for key in buffer", zeroed out only the zero bit rather than all the flag bits.

* Disabled interrupts during the "check for" sequence to insure correct key code was returned.*

* 1.05

* Added F11 and F12 support

* 1.06

* Replaced peeks and pokes with casts

**********************************************************

/♦INCLUDE FILES*/
#include "atkit.h"

/* F U N C T I H PROTOTYPES*/

unsigned keyboard setup(void);

void interrupt cdecl far keyboard io(interrupt_registers);

void interrupt cdecl far keyboard~isr();

unsigned translate from co I umn( unsigned char);

void reset(void); ~

void intlb(void);

void update leds(void);

void disable keyboard(void);

void enable_lceyboard(void);

uns i gned send_8042_data< uns i gned) ;

/♦GLOBAL VARIABLES*/

/♦GLOBAL CONSTANTS*/

E-6-2 The Keyboard Driver

extern keyboard io;
extern "keyboarcTisr;

/♦LOCAL DEFINITIONS*/

#define pio_port a 0x60
#define pio_port3j 0x61
#define status _port 0x64
#define in bfr full 0x02
//#define Buffer head 0x1 a
//#define buffer~tail 0x1c
#def ine buffer begin 0x1e
//#define buffer start 0x80
//#define buffer~end 0x82
#define wait for~key 0x00
#define checlc for key in buffer 0x01
#define get_fTags~0x0Z

#define break code 0x80 /* add to key to get break code */

#define tab key 15

#define ctl~key 29

#define lefT key 42

#define righT key 54

#define pnnt~screen 55

#define alt key 56

#define caps key 58

#define f1 59

#define f2 60

#define f3 61

#define f4 62

#define f5 63

#define f6 64

#define f7 65

#define f8 66

#define f9 67

#define f10 68

#define f 11 87

#define f12 88

#define numjcey 69

#define scroll key 70

#define nuro 82

#define num"1 79

#define num~2 80

#define num"3 81

^define num~4 75

ffdefine nunT5 76

#define num~6 77

#define num~7 71

#define nunT8 72

#define num~9 73

#def ine minus key 74
#define plus lcey 78
#define ins Key 82
#define del~key 83
#def ine sysjcey 84

#define ack code Oxfa
#define resehd_code Oxfe

#define ins state 0x80
#define caps state 0x40
^define num_state 0x20
#define scroll state 0x10
#define alt shift 0x08
#define ctTshift 0x04
#define lefT shift 0x02
#define right_shift 0x01

#define ins shift 0x80
#define caps shift 0x40
#def ine num shift 0x20
#define scroll shift 0x10
#define hold_s!ate 0x08

#define alt column 3
#define ctl~column 2
#define shiTt column 1
#define base_column

/♦LOCAL CONSTANTS*/

/*======== This is the keyboard table s=s==ss=============*/

const unsigned char kb_table[89] [4] =<

A-Tvpe BiosKit

The Keyboard Driver E-6-3

/* This table covers all keys.
** Some keys are pre-checked for special handling.
** Some special keys are padded out in this table.
** The format is: base, upper, Ctrl, alt cases.
** The alt cases are handled as extended codes.

/

,0

27 ,27
#1 -

'2
'3
'4
'5
'6
'7
'8
'9
'0

8
9

'q
'w
'e
T

't

'y

'u
'i
'o

'P

'[

VI

13

-1

'a

's

'd

'f

'?
'h

'J
'k
'I

39

1
92

'2

'x
'c
'v
'b
'n
'm

;s

1

Q
U
E

R
T
Y
U
I

P
<

:!f

A
S

F
G
H
J
K

:il

,'X
,'C
,'V
,'B
,'N
,'M
,'<
,'>

a

127

-1

17

23

5

18

20

25

21

9

15

16

27

i 29

10

-1

1

19

4

6

7

8

10

11

12

-1

-1

-1

H\

,26

t

'/','?', -1
-1 ,-1 .-1
'*', -1,114,

-1 ,-1 .-1.
32 ,32 ,32

1 .-1 ,-1.

30

>, /* base padding for indexing*/

1 >,
120 -
121
122
123
124
125
126
127
128
129
130
131

-1

-1

16

17

18

19

20

21

22

23

24

25

-1

-1
30
31
32
33
34
35
36
37
38

44
45
46
47
48
49
50
-1
-1
-1
-1
-1
-1
32
-1

function key cases*/

59

-84,

60

,85,

61

,86,

62

87,

63

88,

64

89,

65

90,

66

91,

67

92,

68

93,

-1

-1,

:-i

-1,

* r

turn

71

'7'

72

'8'

[73

'9'

75

'4'

•-1

'5'

:77

'6'

94.104 >,

95.105 >,

96.106 >,

97.107 >,

98.108 },

99.109 >,

100.110 >,

101.111 >,

102.112 >,

103.113 >,

-]''] >' '
1,-1 >, /

1 -

key
key
key
key
key
key
key
key
key
key 10
key 11 -
key 12 -
key 13 -
key 14 -
key 15 -
key 16 -
key 17 -
key 18 -
key 19 -
key 20 -
key 21 -
key 22 -
key 23 -
key 24 -
key 25 -
key 26

special handling */

S, /* key 27

key 28
key 29
key 30
key 31
key 32
key 33
key 34
key 35
key 36
key 37
key 38
key 39
key 40
key 41
key 42
key 43
key 44
key 45
key 46
key 47
key 48
key 49
key 50
key 51
key 52
key 53 -

Escape key*/
M'V
'2' -
'3'*/
'4'*/
'5'*/
'6'*/
'7'*/
'8'*/
'9'*/
'0'*/

'-'*/
/=/*/

backspace*/
tab*/
'Q'*/
'W'*/
'E'*/
'R'*/
'T'*/
'Y'*/
'U'*/
'I'*/
'0'*/
'P'*/
't'*/
']'*/
CR*/
control shift */

left shift */

key 54 - right shift - */

key 55 - prt-scr - */

key 56 - Alt - */

key 57 - space bar*/

key 58 - caps- lock - */

key 59 •
key 60 •
key 61 •
key 62 •
key 63 •
key 64 -
key 65
key 66

F1*/
F2*/
F3*/
F4*/
F5*/
F6*/
- F7*/
F8*/

/*

I*

/* key 67 - F9*/

/* key 68 - F10*/

' key 69 - num-lock - *

r key 70 - scroll -lock

key pad - cases are base, upper, Ctrl, alt*/
,119,-1 >, /* key 71 - home*/
,-1.-1 >, /* key 72 - cursor up*/
,132,-1 >, /* key 73 - page up*/
',-1,-1 >, /* key 74 - minus sign*/
,115,-1 >, /* key 75 - cursor left*/
,-1,-1 >, /* key 76 - center key*/
,116,-1 >, /* key 77 - cursor right*/

Section E: The C Programs

E-6-4 The Keyboard Driver

<79,'V
{80, '2'

{82, '0'
{83,'.'
{-1, -1

{-1, -1
{-1, -1

.-1,-1 >, /* key 78 - plus sign*/
117,-1 >, /* key 79 - end*/
-1,-1 >, /* key 80 - cursor down*/
118,-1 >, /* key 81 - page down*/
-1,-1 >, /* key 82 - insert */

1,-1 >, /* key 83 - delete */
1,-1 >, /* key 84 - sys key */
1,-1 >, /* key 85 */

v . . 1 -1 > /* key 86 */

C133,135\13>,13$ >, /* key 87 - F11 */

{134,136,138,140 >, /* key 88 - F12 */

>;

/♦PROGRAM*/

/I:::!::::::::::::::::::!: 5 :!:::::::!:*:::::! 7

/* Interrupt 16h - Keyboard function call */

unsigned keyboard setup(void)
{

unsigned status = ok:

link interrupt(0x16,& keyboard io);

I i nk~i nterrubt ( 0x09, &~keyboarcTi sr ) ;

if (reset 8042 () == error) status = error;

BUFFER HEAD = buffer begin;

BUFFER""TAIL = buffer~begin;

BUFFER~START * buffer begin;

BUFFER"EN0 = buffer begin + 32;

outporTb(0x21,inporfb(0x21) & -0x02);

enable keyboardO;

//outportb(pio_port b, inportb(pio_port b) | OxcO);

/* reset the port *7

// outportb(pio_port b,inportb<pio port b) & -0x80);

KB FLAG = 0; // resef the flags

KB'FLAG 1 = 0; // reset the flags

KB~FLAG~2 » 0; // reset the flags

KB"FLAG~3 * 0; // reset the flags

re?urn( status);
>

void interrupt cdecl far keyboardj*o(interrupt_registers)

enable ();
switch(ax » 8)
{

case wait for key:

while (BUTFER'HEAD == BUFFER TAIL)

{

enableO;
disabled);

>;

ax = peek40(BUFFER HEAD); BUFFER HEAD +» 2;

if (BUFFER HEA0 >*~BUFFER END) BUFFER HEAD = BUFFER START;

enableO; " - - -

break;

case check for key in buffer:

disable();~

flags &= -zero bit; // clear only the zero bit in the flags

ax = peek40(BUFFER HEAD);

if (BUFFER HEAD «~BUFFER TAIL) flags |= zero bit;

enableO; " ■ ~ "

break;

case get flags:

ax = (ax"& OxffOO) j KB FLAG;

break; "*

>

/* ==« keyboard hardware interrupt service routine «=== */

variables

unsigned char scan code, scan_byte, col;

unsigned scan word7temp; "*

end variables~kb_regs;

A-Tvpe BiosKit

The Keyboard Driver E-6-5

void interrupt cdecl far keyboard_isr(interrupt_registers)

kb regs *myblock;

myBlock * acquire block(KEYBOARD);

enableO;

disable keyboardO;

/* get scan code from input port */

myblock->scan code = inportb(piojx»rt a);

myblock->scan3word = -1; /* preset scan word to default no-load */

switch (myblock->scan code)
C
/* first do all the special handling keys */

case ack code:

KB FLAG 2 | = 0x10;

break;

case resend code:
KB FLAG 2 |= 0x20;
break;

case sys key:
break;

cdSG tsb k©y*

if((KB FtAG & (left shift I right shift)) != 0)

mybloclc->scan word = 15*256;

else ~

myblock->scan_word = 15*256+9;

break;

case ctl key:
KB_FLAG J= ctl^shift;
break; ~

case break code+ctl key:
KB FLAG &=~-ctl shift;
break;

case left key:

KB FLAG |= left shift;

break; ~

case break code* I eft key:
KB FLAG &="-left shiTt;
break;

case right key:

KB FLAG |="right shift;

break;

case break code+right key:
KB_FLAG &=~-right_shi?t;
break;

case print screen:
if ((KB FLA5 & ctl shift) != 0)
mybloclc->scan wor3 * 114*256;
else ~

if((KB FLAG & (left shift | right shift)) != 0)

sys int(0x05,mybloclc);

else

myblock->scan_word ■ 55*256+'*';

break;

case break code+print screen: /* print screen break */
break;

case alt key:

KB FLAG T= alt shift;

/*~if((KB FLAG"& alt shift) == 0) */

ALT IMPUT~= 0;

break;

case break code+alt key:

KB FLAG &="-alt shift;

ifTALT INPUT !=~0) myblock->scan word = ALT INPUT;

break;"

case caps key:

if ((KB FQG 1 & caps shift) == 0)

/* if key noT depressed */

Section E: The C Programs

E-6-6 The Keyboard Driver

KB FLAG 1 |= caps shift;
KB~FLAG~ A = caps sfate;

break;

case break code+caps key:
KB FLAG 1 Z= ~caps_sRift;
break; ~ ""

case num key:

if ((KB FLAG 1 & nun shift) == 0)

/* if key noT depressed */

KB FLAG 1 |= num shift;
KB~FLAG" A = num state;

> " "

if ((KB FLAG & ctl shift) != 0)

/* do pause mode w /

(

KB FLAG 1 l= hold state;

ifTCRT RODE I* 7)~

(
outportb(0x3d8,CRT MODE SET);

> "
eoi sequenceO;
enaBle keyboardO;

while ?(KB FLAG 1 & hold state) !=0) O

> "
break;

case break code+num key:
KB FLAG 1 Z* -num sRift;
break;

case scroll key:

if ((KB FLAB 1 & scroll shift) == 0)

/* if key nof depressed"*/

KB FLAG 1 |= scroll shift;

ifT(KB_FLAG_1 & (ctT_shift | alt_shift)) « 0)

// don't change state if Ctrl or alt keys down
KB FLAG A - scroll state;

> "

if((KB FLAG & ctl shift) != 0)
<

eoi sequenceO;

enaBle keyboardO;

if((KB"FLAG & alt shift) !* 0)

i
sys int(0x18,myblock);

> "

else /* break condition V
C

BIOS BREAK = 0x80;

sys Tnt(0x1b # myblock);

> "
>
break;

case break code+scroll key:
KB FLAG 1 != -scroll sliift;
break;

case ins key:

if ((KB FLAG & alt shift) I* 0)
€
assemble alt numeric(myblock->scan code);

> ~ "
else

C
if ((KB FLAG & ins shift) == 0)
(

KB FLAG A = ins state; /* toggle insert state */

KB~FLAG 1 |= ins shift;

> "

// If in either num state or shift state, but not bithe, code * '0'
// else code = ~

if ((KB FLAG & num state) == 0)
(

if ((KB FLAG & ( left shift | riaht shift)) == 0)
mybloc1c->scan word =~ins key*256;

else ~ ~

A-Type BiosKit

The Keyboard Driver E-6-7

myblock->scan word = ins key*256+'0';

else

if ((KB FLAG & (left shift | right shift)) != 0)
mybloclc->scan_word « ins_key*256;
else ~ ~
myblock->scan word = ins key*256+'0';
> "

>
break;

case break code+ins key:
KB FLAG 1 S= -ins sHift;
break; ~ ~

case minus key:

myblock->scan word = 74*256+' -';

break; ~

case plus key:

myblock->scan word = 78*256+'+';

break; ~

case del key:

if((KB FrAG & (ctl shift I alt shift)) == (ctl shift I alt shift))

< ~ - i -

if ((KB FLAG & (left shift I right shift)) « 0)
i " "

RESET FLAG = 0x1234; /* warm boot */
>

else
i

RESET FLAG = 0; /* cold boot */
>

disableO:

incmos(OxOO); // set NMI mask
far calKbios cs(),&reset);
> "
else
i
if ((KB FLAG & nun state) != 0)
C

if((KB FLAG & (left shift I right shift)) == 0)

mybloclc->scan word = 83*256+'.';

else

myblock->scan word - 83*256;
>

else
i

if ((KB FLAG &

(left shift | right shift)) != 0)

myblock->scan word = 83*256+'.';

else ""

myblock->scan word = 83*256;
>
>
break;

case break code+del key:
break; ~ ~

default: /* not a special handling key */

if ((myblock->scan code & 0x80) == 0)
/* do only the makes for these */

myblock->scan_code &= 0x7f; /* clear the break bit */

/* release the hold state if it is active */
if((KB_FLAGJ & hold_state) != 0) KB FLAGJ &= ~hold_state;
else - - - -

i
switch (myblock->scan_code)

case num 0:
case num~1:
case num~2:
case num"3:
case num~4:
case num^5:
case num~6:
case nurnjT:
case num~8:
case num™"9 *
if ((KB FLAG & alt shift) != 0)

Section E: The C Programs

E-6-8 The Keyboard Driver

assemble_altjTumeric(myblock->scan_code);
else ~ ~
i

myblock->col = 0; /* BASE = (all extended codes) */
if ((KB FLAG & alt shift) != )

myblock->col = alt column; /* ALT =3 (all suppressed) */
else if ((KB FLAG & ctl shift) != 0)

~ myblock->col = ctl_column; /* CTRL = 2 (all extended codes */

if ((KB FLAG & (num state)) != 0)

myblocK"->scan_worcT= peekbcs(&kb_table[myblock->scan_code] [1]);
else

myblock->scan_word » peekbcs(&kb_table[myblock->scan_code] [myblock->col])«8;

>

break;

case f1:

case f2:

case f3:

case f4:

case f5:

case f6:

case f7:

case f8:

case f°:

case f 10:

case f 11 s

case f 12:

myblock->scan word * translate from column(myblock->scan code);

if ((myblock->scan word & OxffUO) =5 0)

myblock->scan worcf"= myblock->scan_word « 8;

break;

default:

myblock->scan word = translate from column(myblock->scan_code);

/* if not an extended code return *7

if((myblock->scan word & OxffOO) =» 0)

i

myblock->scan byte = myblock->scan word;

/* caps lock correction */

if((KB_FLAG & caps_state) != 0)

if (((myblock->scan byte >= 'AO &&
(myblocfc->scan byte~<= 'Z')) II
((myblock->scan byte >* 'a') SA
(myblock->scan Byte <= 'z')))
myolock->scan_Byte A = 0x20;

myblock->scan word = (myblock->scan code « 8) | myblock->scan byte;
>

break;
>
>

break;
>
>

if(myblock->scan word != -1) /* load scan word into buffer */
{

//

// increment the temporary tail pointer
myblock->temp = BUFFER TAIL + 2;
// check for wrap-around and reset to start if needed
if (myblock->temp == BUFFER END) myblock->temp = BUFFER START;
// if overwrite will not happen, then store the scan word
if (myblock->temp 1* BUFFER HEAD)
C
poke40(BUFFER TAIL,myblock->scan_word);
// now update~the tail "
BUFFER TAIL = myblock->temp;
>
else

beepO;
>
//

/* read the in service register to see if eoi is needed */

outportb(0x20,0x0b);

if((inportb(0x20) & 0x02) != 0)

C

ou t port b( 0x20, 0x20) ;

enable keyboardO;
>
update_leds();

A-Tvpe BiosKit

The Keyboard Driver E-6-9

release block(myblock);
>

/*========== end of keyboard isr routine ===========*/

unsigned translate from co I umn< unsigned char scan code)

unsigned char col = 0;

if ((KB FLAG & alt shift) != )

return(peekbcs(&kb table [scan code] [alt column]) « 8);

else - - -

i
if ((KB FLAG & ctl shift) != 0) col = ctl column; /* 2 */
else
i

if ((KB FLAG & (left shift I right shift)) != 0)

col = sh"ift_column; 7* 1 */ ""

>

return (peekbcs(&kb_table[scan_code] [col] ));

assemble alt numeric( unsigned char scan code)
i " "

unsigned char code;

code = peekbcs(&kb table [scan code][1]);

if ((code >» '0') S& (code <="'9'))

(ALT INPUT *= 10) + (code & OxOf);

/*-- update the keyboard leds if state has changed --*/

void update leds(void)

if(((KB FLAG & 0x70) » 4) != (KB FLAG 2 & 0x07))
i ~

II check update busy bit
if ((KB FLAG 2 & 0x40) == 0)
i

eoi sequenceO;
enaEle keyboardO;

KB FLAS 2 \- 0x40; // set update busy
ifTsend~8042 data(Oxed) == ok) // send the led command
C "

delay call (0,10000); // wait about 10 mi I Usees
KB FLfc 2 &- 0xf8; // build new led bits
KB"FLAG"2 |= (KB FLAG & 0x70) » 4;
eoT sequenceO; ~
enaEle keyboardO;
// send the led code

if (send 8042 data(KB FLAG 2 & 0x07) 1= ok)
C ~ "
// send enable if we had a tx error
send_8042_data( Oxf 4 ) ;

>

KB_FLAG_2 &= -0x40; // clear update busy

enableO;

void disablejceyboardo
send_8042(0xad);

void enable_keyboard()
send_8042(0xae);

Section E: The C Programs

The Video Driver E-7-1

SEVEN
The Video Driver

The Video Driver is used to operate the CRT display.

If a video adapter is not installed in a system, it is wise to retain the video function,
and internally modify it to direct output to an alternate device. This permits
character oriented video output (such as the "write_tty" command) to retain PC
compatibility during the development phases. As an example, the video driver might
relay characters to a serial channel output routine, but the application could be
exercised on a system with a video device installed.

Note: Screen flickering - some early generation video adapters do not have clean
memory-write/refresh-read timing and flickering may be observed when updating
the screen. Most of the currently available adapters, in our experience, seem to
minimize this flickering effect. If you observe flickering, the general method to
pursue to minimize this is to sample the horizontal re-trace status, (usually bit of
the status port, 3BA or 3DA), and write into display memory only when the adapter
is in retrace (moving the blanked beam from right to left to start a new line). The
vertical sync time can also be used for writing.

Note: 24 line scrolling - The standard Write-TTY function scrolls all 25 lines. A 24
line scroll may be a desirable option in order to maintain a "status" line a t the
bottom of the screen. This may be accomplished by modifying the Write-TTY
function to either always scroll 24 (or 25) or to sense a flag (or variable) to
determine how many lines should be scrolled.

/***************************************************************************************************

*

* Copyright (c) FOSCO 1988, 1989 - All Rights Reserved

* Module Name: AT Bios crt driver

* Version: 1.03

*

* Author: FOSCO

*

* Date: 10-20-89

*

* Filename: atcrt.c

*

* Language: MSC 5.1

* Functional Description:

* This driver manages the video display.

* Arguments:

*

* Return:

*

* Version History:

* 1.01

* Corrected some get cursor position statements; added active page index to the

* peekb40(cursorj3osn+(peekb40(activej>age)<<1)) uses active page # as word index

* into cursor co-ordinates table in segment 40:50-5f.

* 1.02

* Added some graphics improvements

* 1.03

* Used typecast segment 40: variables

*******************************************************************

/♦INCLUDE FILES*/

E-7-2 The Video Driver

#include "atkit.h"

/♦FUNCTION PROTOTYPES*/

void $iret<void);

unsigned video setup(void);

void interrupt~cdecl far video_io(interrupt_registers);

extern void move row (unsigned, unsigned, unsigned, unsigned);

extern void clear row (unsigned, unsigned, unsigned, unsigned);

extern void move~graphics row (

uns i gned , uns i gned7uns i gnedjuns i gned) ;

extern void clear graphics row (

uns i gned , uns i gned7uns i gned7uns i gned) ;

unsigned check mode(void);

void load 6845""byte( unsigned, unsigned char);

void loacT6845~word(unsigned, unsigned)*

unsigned expand byte(unsigned char, unsigned char);

void set the cursor to I oc( unsigned);

void store cursorjx>si?ion(unsi gned, unsigned);

unsigned f7nd_position(void);

void scroll end(void);

unsigned swap(unsigned);

unsigned posit ion( unsigned char, unsigned char);

unsigned rom check (unsigned);

unsigned find_page_position(unsigned char);

/♦GLOBAL VARIABLES*/

extern unsigned redirect_flag;

/♦GLOBAL CONSTANTS*/

extern _video_io;

/♦LOCAL DEFINITIONS*/

#define cursor jaosn 0x50

#define up

(Wefine down 1

#define is graphics 0x01

tfdefine is^alpha 0x02

#define bell 0x07
#define backspace 0x08
#define carriage return OxOd
#define line_fee3 0x0a

#define VIDEOJO 0x10

#define color address 0x03d4
#def ine mono address 0x03b4
#define egajiddress 0x03c0

/*=== command equates =*=*/

#def
#def
#def
#def
#def
#def
#def
#def
#def
#def
#def
#def
#def
#def
#def
#def
#def

ne set mode

ne set~cursor shape 1

ne set^cursorjsosition 2

ne rea3 cursor_position 3

ne reaeTlightjaen 4

ne set Ictive_page 5

ne scroll up 6

ne scroll~down 7

ne read ac current 8

ne write ac current 9

ne write~c current 10 /* 0A */

ne set color 11 /* 0B */

ne writejpixel 12 /* 0C */

ne read pixel 13 /* 00 */

ne write tty 14 /* 0E */

ne return video state 15 /* OF */

ne write_string~ 19 /* 13 */

/♦LOCAL CONSTANTS ♦/

/♦ constants */

extern const unsigned char video font [128] [8];
extern const unsigned char mode Table [8];
extern const unsigned char column table[8]:
extern const unsigned char video_parms[4] [16];

A-Tvpe BiosKit

The Video Driver E-7-3

// We do not use the length table in biostop.asm because it only has four entries,
const unsigned length table [8] =
C
2048,2048,4096,4096, 16384, 16384, 16384,4096

>;

/♦PROGRAM*/

/* video setup ■

variables

end_variables video_setup_regs;

unsigned video__setup(void)

video setup_regs *myblock;
myblock = acquire_block(VIDEO);

/* reset any video cards */
outportb(color_address + 4, 0);
outportb(mono Iddress + 4, 1);
inportb(mono address + 6);
inportb(color address + 6);
outportb(ega_address, 0);

/* load vector for this routine */
link interrupt(0x10,& video io);
set_vector(0x1d,bios_cs(),&video_parms[0] );
// set default port address to color board
// this is done in case we have an EGA
AD0R_6845 = color_address;

/* determine type of video */

switch (EQUIP FLAG & 0x0030)

<:

case 0x30: /* monochrome */
AODR 6845 = mono address;
myblock -> ax = Ux0002;
sys_int(0x10, myblock);

break;

case 0x00: /* none - assume color */

case 0x20: /* cga 80 */

myblock -> ax = 0x0003;

sys int(0x10, myblock);

break;

case 0x10: /* cga 40 */
myblock -> ax = 0x0001;
sys_int(0x10, myblock);
brelk;

rom_check( OxcOOO ) ;

release_block(myblock);

return(ok);

/*=== ===*/

/*=== MAIN VIDEO ROUTINE ===*/

/*=== ===*/

variables

unsigned i,j,reg index, video segment:

unsigned parm segment, parm o7fset,fill word;

unsigned row, col, line counf;

unsigned char outcharj

unsigned temp, temp cursor, fill length;

end_variables video_regs; ~

void interrupt cdecl far video_io(interruptj*egisters)

video regs *myblock;
enable( ) ;

myblock = acquire__block<VIDEO);

if (AODR 6845 != 0)
i

if (ADDR 6845 == mono address)

C "

myblock->video segment = OxbOOO; /* mono card */

>

Section E: The C Programs

E-7-4 The Video Driver

else

myblock->video segment = 0xb800; /* color card */
>

switch (ax » 8)
i

/*=== =«*/

/*=== AH = = set mode =«*/

/*== s AL = mode to be selected (0-9) ===*/

/*=== ===*/

case setjnode:

if ((SWITCH BYTE & 0x30) == 0x30)
C

CRT MODE = 7; /* if mono, force mode 7 */

ADD? 6845 = mono address;

myblock->video segment = OxbOOO;
>

else
{.

ADDR 6845 = color address:

myblock->video_segment - 0xb800;

if ((ax & Oxff) != 7)

CRT MODE = ax; /* if color, use selected mode */

else

if ((SWITCH BYTE & 0x30) « 0x20) CRT MCOE = 0; else CRT MODE = 2;

>

CRT MODE SET = peekbcs(&mode tableCCRT MODE]);
outportbT(AD0R_6845) + 4, CRT_MODE_SETj;

myblock->parm offset » peek (0x00, 0x74);
myblock->parnTsegment = peek (0x00, 0x76);

if (CRT MODE >»2) myblock->parm offset += 16; /* 16 */
if (CRT'MODE >=4) myblock->parm""offset += 16; /* 16+16 */
if (CRn«DE «7) myblock->parnfoffset += 16; /* 16+16+16 */

CURSOR_MODE = swap(peek(myblock->parm_segment,(myblock->parm_offset+10)));

for (myblock->reg_index=0;myblock->reg_index < 16;myblock->reg < jndex++)

load 6845_byte(myblock->reg_index,peekb(myblock->parm_seginent,myblock->parm_offset+myblock-
>reg_index));~ ~ - -

CRT START = 0;

ACTTVE_PAGE = 0; /* set active page to zero */

/* enable video and correct port setting */

outportb((ADDR_6845) + 4,peekbcs(&mode_table[CRT_MODE]));

CRT_M00E_SET = peekbcs(&mode_table[CRT_MODEJ );

CRTJCOLS = peekbcs(&column_tableCCRT_MODE]);

CRTJ.ENGTH = peekcs(&length_tabletCRT_MODE]);

for (myblock->i = 0; myblock->i < 8; myblock->i++)
poke40(cursorjx>sn + myblock->i, 0); /* clear all cursor positions */

if (CRT MODE == 6) /* set pallette register */
i

outportb((ADDR 6845) + 5,0x3f);

CRT PALLETTE =~0x3f;
> "
else
i

outportb((ADDR 6845) + 5,0x30);

CRT_PALLETTE =""0x30;

if (check mode() == is graphics)

myb(ock->Till word » 0J

else

myblock->fill_word = 0x0720;

myblock->fill_length = 2 * CRTJ.ENGTH;

A-Tvpe BiosKit

The Video Driver E-7-5

/* clear the screen */

CURSOR_MO0E = 0x0607;

for (myblock->i = 0; myblock->i < myblock->fill_length; myblock->i += 2)
poke(myblock->video_segment, myblock->i, myblock->fill_word);

break;
I*

/*=== AH = 1 = set the cursor shape

/*=== CH = start line
/*=== CL = stop line

7

case set_cursor_shape:

CURSORJ4O0E = ex; toad_6845_word(10,cx>;

break;

/*=== AH » 2 = set cursor position ===*/

/*=== DH = row
/*=== DL = column
/*=== BH = page

*==*/
===*/
===*/
===*/

case set_cursorjx>sition:

poke40( cursor _posn+ ((bx » 8> « 1), dx);

if <ACTIVE_PAGE == (bx » 8>)

load 6845 word(14.((CRT START) +

~ ((T(dx » 8) * CR*T_COLS) ♦ (dx & Oxff) ) « 1) »1 ));

break;

/*=== AH = 3 = read cursor position
/*=== BH = page | DH = row

/*===
/*===
/*===
/*===

DL = column

CX = cursor mode

====*/
===*/
===*/
=«*/
===*/
===*/
===*/
====*/

====*/

case read_cursor_pos i t i on :

ex = CURSOR_MODE; dx = CURSOR J>OSM + ((bx » 8) « 1);

break;

/*=== AH = 4 = read light pen position

/*===
/*===
/*=«
/*===
/*===
/*=«
/*===
/*====

AH = = no info
AH * 1 = info

DH - row

DL = column

CH = raster line

V

BX = horz. position ===*/

case read_light_pen:

ax = ax & OxOOff; /* set no light pen return code */

break;

* *
II II
II II
II II

=========*/

===*/

/*=== AH = 5 = set active page

===*/
===*/

/*=== AL = active page # I

===*/
=«*/

Section E: The C Programs

E-7-6 The Video Driver

case set_active_page:

ACTIVE PAGE = ax;

CRT STA"RT = CRT LENGTH * (ax & OxOOff);

dx = peek40( cursor _posn+((ax & OxOOff) « 1));

load 6845 word(12,CRT START / 2);

load~6845~word(14,(CRT START +

(((Ox »~8) * CRT COLS" ) + (dx & Oxff) ) « 1)

»1 >);

break;

/*lll Ill*/

/*ss= AH = 6 = scroll up ===*/

/*=== ==»*/

/*=== AL = # rows to scroll (0 = blank ) ==-*/

/*=ss cx = row, co I of upper left corner ===*/

/*sss DX = row, co I of lower right corner ==»*/

/*=== bh = attribute for blanked line ===*/

/*=« ===*/

case scroll up:

if (check mode() == is graphics)
C
if ((ax & Oxff) == 0) /* blank the field */
C

myblock->i = (dx » 8) - (cx » 8);

for (myblock->line count = 0; myblock->line count <= myblock->i; myblock->line count++)
C
for (myblock->row = (cx » 8); myblock->row <= (dx »8); myblock->row++)

clear graphics row(myblock->video segment,
((mybTock->row~* 320) + (cx & OxfT)),
(dx & Oxff) - (cx & Oxff) + 1,0);

>

else /* scroll the field */
<

/* i will a the # of rows to scroll */

myblock->i = ax & Oxff;

for (myblock->line count * 0;myblock->line count < myblock->i;myblock->line count++)
i

for (myblock->row = (cx » 8); myblock->row < (dx »8); myblock->row++)
<

move graphics row(myblock->video segment,
((my5lock->row ♦ 1) * 320) + (cx~& Oxff),
(myblock->row * 320) ♦ (cx & Oxff),
(dx & Oxff) - (cx & 0xff)+1);
>

myblock->row = dx » 8:
clear graphics row(myblock->video segment,
(myblock->row w 320) + (cx & OxffT,
(dx & Oxff) - (cx & Oxff) + 1,0);
>
>
>
else /* alpha mode scroll */

if ((ax & Oxff) « 0) /* blank the field */
C

myblock->i = (dx » 8) - (cx » 8);

for (myblock->line count = 0; myblock->tine count <= myblock->i; myblock->line count++)

C
for (myblock->row = (cx » 8); myblock->row <= (dx »8); myblock->row++)

clear row(myblock->video segment,
((mybTock->row * CRT COLS) ♦ (cx & Oxff)) * 2,
(dx & Oxff) - (cx & Uxff) ♦ 1,
(bx & OxffOO) I 0x20);
>
>
>

else /* scroll the field */
<

myblock->i = ax & Oxff;

for (myblock->line count = 0; myblock->line count < mvblock->i; myblock->line count++)
<
for (myblock->row = (cx » 8); myblock->row < (dx »8); myblock->row++)
C
move_row(mybl ock- >vi deo__segment ,

A-Tvpe BiosKit

The Video Driver E-7-7

(((myblock->row + 1) * CRT COLS)+(cx & 0xff))*2,

((myblock->row * CRT COLS)+(cx & 0xff))*2,

(dx & Oxff)-(cx & 0xTf)+1);
>

myblock->row = dx » 8;
clear row(myblock->video segment,
((mybTock->row * CRT C0L5)+(cx & 0xff))*2 f
(dx & Oxff)-(cx & 0x7f)+1,
<(bx & OxffOO) | 0x20));

>
>

break;

/*=« AH = 7 = scroll down =*=*/

/*=== sxs*/

/*ssa AL = # rows to scroll (0 = blank window) ===*/

/*==s ex a row, col of upper left corner ===*/

/*=ss dx = row, col of lower right corner =»*/

/*=== BH = attribute for blanked line «**/

/*=== «=*/

case scroll__down:

if (check modeO == is graphics)
i
if ((ax & Oxff) == 0) /* blank the field */

myblock->i = (dx » 8) - (ex » 8);

for (myblock->line count = 0; myblock->line count <= myblock->i; myblock->line count++)
i
for (myblock->row * (ex » 8); myblock->row <= (dx »8); myblock->row++)
C

clear graphics row(myblock->video segment,
((mybTock->row*320)+(cx & Oxff)),"
(dx & 0xff)-(cx & 0xff)+1,0);
>
>
>

else /* scroll the field */
i
for (myblock->line count = 0; myblock->line count < (ax & Oxff);
myblock->line coun?++) ~

C
for (myblock->row = (dx » 8); myblock->row > (ex »8); myblock->row--)
i

move graphics row(myblock->video segment,
((my5lock->row - 1) * 320) + (cx"& Oxff),
(myblock->row * 320) + (ex & Oxff),
(dx & 0xff)-(cx & 0xff)+1);
>

myblock->row = ex » 8:
clear graphics row(myblock->video segment,
(myblock->row w 320) ♦ (ex & OxffT,
(dx & 0xff)-(cx & 0xff)+1,0);
>
>
>

else
i
if ((ax & Oxff) « 0) /* blank the field */

for (myblock->row = (dx » 8); myblock->row < (ex »8); rayblock->row--)

for (myblock->col=(cx & Oxff); myblock->col< (dx & Oxff); myblock->col++)
i

pokeb(myblock->video segment,

(((myblock->row * CRT COLS) + myblock->col)*2),0x20);
>
>
>

else /* scroll the field */
i
for (myblock->line count = 0; myblock->line count < (ax & Oxff);
myblock->line counT++) "

i
for (myblock->row = (dx » 8); myblock->row > (ex »8); myblock->row--)
i

move row(myblock->video segment,
(((myblock->row - 1) * CRT COLS)+(cx & 0xff))*2,
((myblock->row * CRT COLS)+(cx & 0xff))*2,
(dx & 0xff)-(cx & 0x7f)+1);
>

Section E: The C Programs

E-7-8 The Video Driver

myblock->row = ex » 8;

clear row(myblock->video segment,
C(mybTock->row * CRT C0L5 + (ex & 0xff))*2),
(dx & Oxff)-(cx & 0xTf)+1,
(<bx & OxffOO) I 0x20));
>
>
>

break;

/*=== ===*/

/*=== AH = 8 = read attr and char at cursor ===*/
/*=== =«*/

/*=== BH = page # AL = char ===*/
/*=== for alpha only | AH = attrib «=*/

case read_ac_current:

if (check modeO == is graphics)
i
for (myblock->j = 0; myblock->j < 128; myblock->j++)
C

myblock->temp = true;

for (myblock->i=0; myblock->i <= 7; myblock->i++)
i

/* if mode is 640 x 200 */
if (CRT MODE == 6)
<
if(peekb(myblock->video segment.

(myblock->row * 320) ♦ 7(myblocfc->i & Oxfe) * 40) + myblock->col +
((myblock->i & 1) * 0x2000)) != peekbcs(&video_font[ax & 0x007f] [myblock->i]))
myblock->temp * false; ~"

else /* 320 x 200 mode V
C

if(peek(myblock->video segment,

(myblock->row * 320) +~((myblock->i & Oxfe) * 40) + (myblock->col * 2) + ((myblock->i & 1) *
0x2000)) !=

expand byte(peekbcs(&video fontEax & 0x007f] Cmyblock->U),3))

mybloclc->temp = false;

if (myblock->temp =* true)

ax = (ax & OxffOO) | myblock->j;
break; /* get out with the find */

>

>
>

else /* --- alpha read --- */

i

ax = peek(myblock->video_segment # findj>agej3osition(bx » 8));

break;

/*=== AH = 9 * write attr and char at cursor ===*/

/*=== bh = page #
/*=== for alpha only

/*=== CX = # write

/*=== AL = character

/*«= bl * attribute

===*/
===*/
===*/
===*/
=«*/
===*/

case write_ac_current:

if(check_mode() « is_graphics)

myblock->row = peekb40(cursor_posn+((bx » 8) « 1) +1);
myblock->col = peekb40( cursor __posn+((bx » 8) « 1));
for (myblock->i=0; myblock->i < a 7; myblock->i++)
C
/* if the mode is 640 x 200 */
if (CRT MODE == 6)
i

pokeb(myblock->video segment.

(myblock->row * 320)~+ ((myblock->i & Oxfe) * 40) +
myblock->col +

A-Tvpe BiosKit

The Video Driver E-7-9

((myblock->i & 1) * 0x2000).

peekbcs(&video font [ax & Ox0O7f] [myblock->i]));
>

else
i

/* if the mode is 320 x 200 */

poke(myblock->video segment.

(myblock->row * 3207 + <<myblock->i & Oxfe) * 40) ♦

(myblock->col * 2) +

(<myblock->i & 1) * 0x2000),

expand byte(peekbcs(&video font tax & 0x007f] [myblock->i]),

bx& 0x83));
>
>
>
else

<:

myblock->temp = findj3age_position(bx » 8);
for (myblock->i = 0; myblock->i < ex; myblock->i++)
i

poke(myblock->video segment, myblock->temp+(2 * myblock->i),((bx « 8) I (ax & Oxff)));
>

break;

/*=== AH = 10 = write char at cursor position ===*/
/*=« =«*/

/*=== BH = page # ===*/

/*=== for alpha onlyl ===*/

/*=== CX = # to write ===*/

/*=== AL = character ===*/

/*=« ===*/

/ * ====SS=================S=========S!==============V

case write_c_current:

if(check_mode<) == is_graphics)

myblock->row = peekb40( cursor jx>sn+((bx » 8) « 1)+1);
myblock->col = peekb40( cursor jx>sn+((bx » 8) « 1));
for (myblock->i=0; myblock->i <= 7; myblock->i++)
i

/* if the mode is 640 x 200 */
if (CRT M00E « 6)
<

pokeb(myblock->video segment.

(myblock->row * 320)"+ ((myblock->i & Oxfe) * 40) +
myblock->col +
((myblock->i & 1) * 0x2000).
peekbcs(&video font [ax & 0x007f] [myblock->i]));
>

else
i

/* if the mode is 320 x 200 */

poke(myblock->video segment.

(myblock->row * 320T + ((myblock->i & Oxfe) * 40) +

(myblock->col * 2) +

((myblock->i & 1) * 0x2000),

expand_byte(peekbcs(&video_font[ax & 0x007f] [myblock->i]),3));

>
>

else
i

myblock->temp = find_page_position(bx » 8);

for (myblock->i = 0; myblock->i < ex; myblock->i++)

<
pokeb(myblock->video segment, myblock->temp + (2 * myblock->i),ax);

>
>

break;

/*=== ah » 11 = set color for MRES graphics ===*/

/*=== ===*/

/*=== BH = ===*/

/*ss= bl = background color ===*/

Section E: The C Programs

E-7-10 The Video Driver

/*«= BH = 1 ===*/

/*=== BL = pallette select ===*/
/*=== _ ===*/

case set color:

/* get current pallette value */

if((bx » 8) »= 0) /* this is color */

i

/* turn off low 5 bits of current color */

CRT PALLETTE &- OxeO:

CRT~PALLETTE |= (bx & 0x1f);

/* Turn off high three bits of input */
>
else /* select pallette */

<

CRT PALLETTE &= Oxdf; /* turn off pallete select bit */

if(Tbx & 0x01) !* 0)

CRT PALLETTE |= 0x20; /* turn on pallette select bit */
> ~

outportb((AODR 6845) + 5, CRT PALLETTE);
break; ~

/*=== ===*/

/*==» AH = 12 = write pixel ===*/

/*=== ===*/

/*=s= DX = row 0-199 ===*/

/*=== cx = column 0-639 ===*/

/*=== AL = pixel value (1 or 2 bits) ===*/

/*=»= bit 7 = 1 = XOR lower bits =»*/

/*=« ===V

case writejDixel:

/* calc row address for even/odd */

myblock->row = dx * 40 + <<dx & 1) * (0x2000-40));

if (CRT MODE == 6) /* write one 1 bit */

<

/* col variable is used for bit mask */

myblock->col * 1 « (cx X 8);

/* calc address for 1 bit in 8 */

myblock->row += cx / 8;

rkeb(mvblock->video segment, myblock->row,((peekb(myblock->video segment, myblock-> row)
~myblock->col) I
((ax & 0x0001) « (cx X 8))));

>

else /* write 2 bits */

<

/* col variable is used for bit mask */

myblock->col = 3 « (cx X 4);

/* calc address for 2 bits in 8 */
myblock->row += cx/4;

pokeb(myblock->video segment, myblock->row,((peekb(myblock->video segment, myblock->row)

& ~myblock->col) I

((ax & 0x0003) « (cx X 4})));

>

break;

/*=== AH > 13 > read pixel =«*/

/*=== DX = row 0-199
/*=== cx = column 0-639

AL a pixel ===*/

case read_pixel:

/* calc row address for even/odd */

myblock->row = dx * 40 + ((dx & 1) * (0x2000-40));

if (CRT MODE == 6) /* read one 1 bit */
I

/* calc address for 1 bit in 8 */

A-TVpe BiosKit

The Video Driver E-7-11

myblock->row += cx/8;

ax = (ax & OxffOO) |
((peekb(myblock->video_segment,myblock->row) » (ex X 8)) & 1);

>

else /* read 2 bits */

C

/* calc address for 2 bits in 8 */
myblock->row += cx/4;

ax = (ax & OxffOO) |
((peekb(myblock->video_segment,myblock->row) » (ex X 4)) & 3);

>

break;

/*=== ===*/

/*=== AH = 14 = write tty ===*/

/*=== ===*/

/*=== AL = character to write ===*/

/*=== BL = f ground color in graphics ===*/

/*=== use active page ===*/

case write_tty:

if (redirect flag != 0)
C

myblock -> ax = ax & OxOOff;

myblock -> dx * 0;

sys int(0x17 # myblock);
> "

/* get current cursor */

myblock->row = peekb40( cursor _posn + (ACTIVE PAGE « 1)+1);
myblock->col = peekb40(cursorjx»sn + (ACTIVE"PAGE « 1));

switch (ax & OxOOff)
i

case bell:

beepO;

break;

case backspace:

if (myblock->col !=0) myblock->col--;

break;

case carriage_return:
myblock->col = 0;
break;

case line_feed:

if (myblock->row == 24)

i

/* find the fill attribute */

myblock -> ax = 0x0800;

// set bh to active page

myblock -> bx = ACTIVE PAGE;

myblock -> bx = mybloclc -> bx « 8;

sys int(VIDEO IO ( myblock);

// set bh to Blank line attribute

myblock -> bx - (myblock -> ax & OxffOO);

myblock -> ax = 0x0601; /* scroll call */
myblock -> ex = 0:

myblock -> dx = (24 « 8) | (CRT COLS - 1);
sys int(VIDEO IO, myblock);

> "
else

myblock->row++;
>

break;

default: /* any other character */

myblock -> ax = (write c current « 8) I (ax & OxOOff);

myblock -> bx = ACTIVE~PA"GE;

myblock -> bx = myblocfc" -> bx « 8;

myblock -> ex = 1;

sys int(VIDEO 10, myblock);

Section E: The C Programs

E-7-12 The Video Driver

myblock->col++;

if <myblock->col >= CRT COLS)

C

myblock->col = 0;

if (myblock->row ==24)

/* find the fill attribute */

myblock -> ax = 0x0800;

myblock -> bx = ACTIVE PAGE;

myblock -> bx = myblocE -> bx « 8;

sys int(VIDEO IO, myblock);

mybTock -> bx = (myblock -> ax & OxffOO);

myblock -> ax = 0x0601;
myblock -> ex = 0;

myblock -> dx = (24 « 8) | (CRT COLS - 1);
sys int(VIDEO IO, myblock);
> "
else
i

myblock->row++;
>
>

break;
>

myblock->temp = (myblock->row « 8) | (myblock->col & OxOOff );
poke40(cursor_posn+((ACTIVE_PAGE) « 1),myblock->temp);

load 6845 word(14,(CRT START ♦

((my5lock T >row * CRT_C0lS) ♦ myblock->col ) « 1) »1 );

break;

/*::: :: =v

/*=== AH = 15 = return video state ===*/
/*«= ===*/

/*=== AH = # of cols ===*/

/*=== AL = mode ===*/

/*=== BH = page ===*/

/*=== =«*/

case return_video_state:

ax = (CRT COLS « 8) | CRT MODE;

bx = (bx S OxOOff) | (ACTl7E_PAGE « 8);

break;

/*=== ah » 19 = write string ===*/

/*=== ===*/

/*=== ES:BP = pointer to string =as*/

/*=== cx = length of string ===*/

/*=== DX = cursor position ===*/

/*=== BH = page # ===*/

/*=== ===*/

/*=== AL = = write string - don't move cursor ===*/

/*=== BL = attribute ===*/

/*=== AL = 1 = write string - move cursor ===*/

/*=== BL = attribute ===*/

/*=== AL = 2 = write char and attribute ===*/

/*=== - don't move cursor »«=*/

/*=== AL = 3 = write char and attribute ===*/

/*=== - move cursor ===*/

/*=« «=*/

case write_string:

/* if count > and opcode 0-3 */

if ((cx != 0) && ((ax & OxOOff) <= 3))

i

/* save current cursor for this page */

myblock->temp_cursor = peek40(cursor_posn+(bx » 8)«1);

/* set cursor to callers position */

myblock -> ax = (set cursorjsosition « 8);

myblock -> dx = dx;

myblock -> bx = bx;

sys int(VIDE0 IO, myblock);

mybTock->row = myblock -> dx » 8:

myblock->col = myblock ->dx & OxOOff;

A-Tvoe BiosKit

The Video Driver E-7-13

for (myblock->i = 0; myblock->i < ex; myblock->i++)
{
myblock->outchar = peekb(es,bp+myblock->i);

if ((myblock->outchar == backspace) J|
(myblock->outchar == carriage return) ||
(myblock->outchar == line_feea))

myblock -> ax = (write tty « 8) | mybtock->outchar;

myblock -> bx = bx;

sys int(VIDE0 10, myblock);

mybTock->row = (peek40( cursor _posn+(bx » 8)«D) » 8;

myblock->col = peek40(cursor_posn+(bx » 8)«1);

else

myblock -> ex - 1;
myblock -> bx = bx;
if <ax & OxOOff > 2)

<:

myblock -> bx = peekb(es,bp);
bp++;

myblock -> ax = (write ac current « 8) | myblock->outchar;
sys int(VIDE0 10, myblock)!
myblock ->co I ++;

if (myblock->col » (CRT COLS))
i

myblock->row++;
if (myblock->row >=25)
{

myblock->col = 0;

myblock -> ax = (write tty « 8) | line feed;
sys int(VIDEO_IO,myblock);
mybTock->row- r ;
>
>

/* update cursor */

myblock -> ax = (set cursor_position « 8);
myblock -> dx = (mybTock->row « 8) | myblock->col;
sys int(VIDE0 10, myblock);
> "
>

/* restore original cursor */
if ((ax & 1) == 0)

poke40((cursor_posn + ((bx »8) « 1)),mvblock->temp cursor);
myblock -> ax = (set cursor_position « 8); ~
myblock -> dx = myblock->temp cursor;
sys int(VIDEO 10, myblock); ~
> "

break;

/*=== ===*/

/*=== default case for invalid opcodes ===*/
/*=== _ ===*/

>

release block(myblock);
>

/*=== SUPPORTING FUNCTIONS ===*/

// find position - returns offset page*row*col
unsigned findjx>sition()
return( f i nd_page jms i t i on( ACT I VE_PAGE ) ) ;

unsigned find_page_position(unsigned char page)

unsigned temp, length:
unsigned char row, col;

temp = peek40( cursor _posn + (page « 1));
row » temp » 8;
col = temp;

Section E: The C Programs

E-7-14 The Video Driver

length = CRT LENGTH;
temp = lengtR * page;
return(temp ♦ position(row,col));
>

**--- calc buffer address of character at AX = row, col

**--- returns ax offset of character in buffer

*/

unsigned posit ion (unsigned char row, unsigned char col)

retum(((row * CRT C0LS)+col)«1);
>

**--- scroll end
*/

void scroll end()
i
if (CRT MODE !* 7) outportb(0x3d8,CRT MOOE SET);

**--- convert cursor position to buffer offset
*/

unsigned cursor_to_offset()

return(((peek40(cursor_posn) » 8) * CRT COLS * 4) + CURSOR POSN & OxOff);
>

** — convert input row-col to buffer offset
*/

/* input is row, col position */
unsigned ca I c_orf set (unsigned input)

return((( input » 8) * CRT_COLS * 4) + input & OxOff);

** — return alpha or graphics mode flag
*/

unsigned check modeO
i

if ((CRT MODE >= 4) && (CRT_MODE <= 6)) return(is_graphics);

return(is alpha); ~ ~

>

/*—

**--- expand the byte for medium res.

**--- double the input byte to an output integer

*/

unsigned expand byte(unsigned char the byte, unsigned char color)
C
register temp = 0;
unsigned char mask = 0x80;
while (mask != 0)
C
temp = temp « 2;
if ((the byte & mask) != 0)
if((color & 0x80) == 0)

temp |= (color & 0x03);
else

temp A = (color & 0x03);
mask = mask » 1;

return(((temp » 8) & OxOOff) | ((temp «8 ) & OxffOO));

/* */

/*--- — */

/*--- load a word into the 6845 reg 'n' and 'n'+1 --*/
/*... ...*/

/* */

void load 6845 word (unsigned address, unsigned value)
i ~

load 6845 byte( address, value » 8);

I oad~6845~byte( address + 1, value);
>

A-Tvpe BiosKit

The Video Driver E-7-15

/* */

/*--- load a byte into the 6845 reg 'n' ---*/
/*--- ---*/

/* */

void load 6845 byte(unsigned address, unsigned char value)
i "

outportb(ADOR 6845. address);

outportb< ( (AD&R 6845) + 1), value);
>

unsigned swap( unsigned a word)
t
retum((aword » 8) I (aword « 8));
>

Section E: The C Programs

The Floppy Disk Driver E-8-1

EIGHT
The Floppy Disk Driver

The Floppy Disk Driver is used to operate the floppy disk.

This driver structure has been organized to support up to four (4) floppy disk drives.
The normal AT style disk controller does not provide the motor and select logic to
do so. Two possible options are to:

1. Install a second controller at an alternate address and sense which port address
should be referenced for each drive. This would entail declaring a "port" variable
which would be used on the inport and outport commands.

2. Install a controller which does support four drive configurations. If such a
controller is not commercially available, one may design and construct such a
device by duplicating the standard functions and adding the required motor and
select logic. Since newer LSI based floppy disk controllers (such as the Intel 82072)
simplify this task, one may wish to consider this alternative.

Presuming that the new perpendicular-recording 4 Mbyte floppy disk drives will
become desired options, the disk parameter tables are organized for easy expansion.
By inspecting the defined tables in the source file, one will observe that some entries
are already included for the 4 Mb drives. Take note that these drive parameters
(and the 4Mb drives) have not been installed or tested on the Bios development
system, so that some additional development work will be required to implement
the 4 Mb drive type.

The standard location in the CMOS RAM for storing the drive types for Drive A:
and B: is cell 10 hex. We have chosen the "reserved" cell 11 hex for storing the type
byte for floppy Drives C: and D:. If these should conflict with some other use, they
may be re-assigned as you wish.

For those of you who are creating diskless systems, our Annabooks PromKit
publication provides additional information on how the standard floppy disk driver
may be replaced / chained / enhanced so a different physical device may be used
for a logical floppy disk.

* Copyright (c) FOSCO 1988, 1989 - All Rights Reserved

*

* Module Name: AT Bios enhanced floppy disk driver

* Version: 1.02

*

* Author: FOSCO

* Date: 10-20-89

*

* Filename: atdisk.c

*

* Functional Description:
*

* Arguments:

* Return:

*

* Version History:

* 1.01

E-8-2 The Floppy Disk Driver

* Moved misplaced parm table entry for 720k drive from index 2 to index 3

* 1.02

* Replaced peeks and pokes with casts

* Moved variables to myblock

*
***************************************************************************

/♦INCLUDE FILES ♦/
#include ••atkit.h"

/♦FUNCTION PROTOTYPES*/

void fdisk setup(void);

void interrupt cdecl far disk io(void);

void interrupt cdecl far disk~isr(void);

unsigned char send fdcCunsigned char);

void send_rate( unsigned);

unsigned retry(unsigned);

unsigned char med change< unsigned);

unsigned char calc sectors(unsigned);

unsigned char cmos~"type( unsigned char);

unsigned char get 5arm( unsigned, unsigned char);

unsigned char waiT int(void);

unsigned reca I (unsigned);

unsigned char seek (unsigned);

void wait for head( unsigned);

unsigned char'read id(unsigned);

unsigned char get Tdc status(unsigned);

unsigned char rea3 dsk*chng(unsigned);

unsigned char results (void);

unsigned char chk stat 2(void);

void send spec if y~command( unsigned );

void FDC reset(unligned);

void delly call (unsigned, unsigned);

unsigned cFfar dma setup(unsigned, unsigned, unsigned);

void purge fdc(voTd)j

unsigned char fdc_i nit (unsigned);

/♦GLOBAL CONSTANTS*/

extern _disk_io;
extern "disk^isr;

/♦GLOBAL VARIABLES*/

/♦LOCAL DEFINITIONS*/

#define FDC STATUS 0x42

#define DISK ID 0x90 /♦ hold drive/media type ♦/

#define LAST~TRACK 0x94 /♦ 94-97 holds last track number

#define RATE 500 0x00
#define RATE"300 0x01
#define RATE~250 0x02
#define RATE~1000 0x03
#define INT FLAG BIT7
#define MOT0R_WAIT 0x25

#define BAD CMD 0x01
#define BAD'ADDR MARK 0x02
#define WRITE PROTECT 0x03
#define RECORD" NOT FND 0x04
#def ine MEDIA CHANCE 0x06
#define BAD DflA 0x08
#def ine DMA'BOUNDARY 0x09
#define MED~NOT FND 0x0c
#define BAD"CRC" 0x10
#define BAD~FDC 0x20
#define BAD'SEEK 0x40
#define TIMEJXJT 0x80

/♦ function code definitions ♦/

#define RESET 0x00
#define READ STATUS 0x01
#define READ"SECTORS 0x02
#define WRITE SECTORS 0x03
#define VERIFY SECTORS 0x04
#define FORMAT"TRACK 0x05
#define DISK PA"RMS 0x08
#define DISK""TYPE 0x15
#define DISK~CHANGE 0x16
#define FORMAT SET 0x17
#define SET MEfflA 0x18

A-Tvpe BiosKit

The Floppy Disk Driver E-8-3

#define BAO_FUNCTION 0x19

#define TRY Oxff

/* FDC port definitions */

#define DOR PORT 0x3f2
#define MSR~PORT 0x3f4
#define DATA" PORT 0x3f5
#define DIR PORT 0x3f7
#define DRR~PORT 0x3f7

#define ROM BIT7
#define DIO BIT6
#define BUSY BIT4
#define DSKCHANGE_BIT BIT7

/* DMA port definitions */

^define DMA MASK 0x0a
fctefine DMA~MODE 0x0b
#define DMA"FLFF 0x0c
#define DMA'ADR 0x04
#define DMA~BASE 0x05
#define DMA'PAGE 0x81

/* DMA literal definitions */

#define DMA ON 0x02
#define DMA'OFF 0x06
#define DMA'RX MODE 0x46
^define DMA""TX"MODE 0x4a
#define DMA~VRFY MODE 0x42
#define TX D"IR Dx01
#define RXTJIR 0x00

/* FDC commands */

#define FDC READ 0xe6
#define FDCWRITE 0xc5
#define FDC"FORMAT 0x4d
#define FDC'READID 0x4a

/*=== These are the floppy disk parameter tables =====

* The tables are organized as an Array of up to 8 Drive types, each supporting up to 8 media types.

* Each item is 16 bytes long

*/

/* DISK TABLE indexes */

#def
#def
#def
#def
#def
#def
#def
#def
#def
#def
#def
#def
#def
#def
«def

ne DT SPEC1 // specify command 1

ne DT~SPEC2 1 // specify command 2

ne DT"OFF TIM 2 // motor off count

ne DT""BYT"SEC 3 // bytes/sector

ne DT~SEC~TRK 4 // sectors/track

ne DT"GAP"5 // gap

ne DT"DTL 6 // dtl

ne DT GAP3 7 // gap 3 for format command

ne DT~FIL BYT 8 //fill byte for format command

ne DT~HD TIM 9 // head settle time

ne DfSTff TIM 10 // motor start time

ne DT"MAX"TRK 11 // max # of tracks for drive

ne DT~RATE 12 // data rate

ne DT""TYPE // drive and media type (not used)

ne DT'STEP 14 // double step flag

#define drive established 0x08
#define drive~field 0x07
#define drive~none 00
#define drive~360 01
#define drive~12 02
#define drive~720 03
#define drive~14 04
#define drive~28 05

#define media established 0x80

#define media'field 0x70

#define media~~none 0x00

#define media~360 0x10

#define media~12 0x20

#define media"720 0x30

#def ine media""14 0x40

#define media"28 0x50

// media definitions for transition table

Section E: The C Programs

E-8-4 The Floppy Disk Driver

#define m none 0x0
#define m"360 0x1
#define m"12 0x2
#define m~720 0x3
#define nTl4 0x4
#define m~28 0x5

#define m_wait 0x25

/♦LOCAL CONSTANTS*/

const unsigned char transition table [8] [4]= {
// This table covers the sequence of media type to try for
// each drive type in establishing the media in the drive.
// The media is defaulted to the first item in this table
// for a particular drive type. When we attempt retries, we
// step through the possible media types until we come
// to "none" marking the end of the table.

/* drive type (None) */ On none,m none,m none,m none>,

/* drive type 1 ( 360) */ On~360, m~none,m~none,m~none> f

/* drive type 2 ( 1.2) */ <nf12. m~360, m~none,nfnone>,

/* drive type 3 < 720) */ <m"720, m"none,m~none,m~none> #

/* drive type 4 (1.44) */ On~14, m"720, nfnone,m none>,

/* drive type 5 (2.88) */ On~28, m~14, m~720, m~none>,

/* drive type 6 unused */ <m~none,m~none,m"'none,m~none>,

/* drive type 7 unused */ <m"none # m~none,m~none # m~none> #

>; "

const unsigned char fdisk table [8] [8] [16]= i
I* this entry is for compatibility with the XT disk driver */
i
/* drive type = None (Default to 360) */

<0x0af,2,m wait,2.9,0x2a,-1.0x50,0x0f6,15,8,39,RATE 250 f drive 360|media_360,0,0>,

<o,o,o,o, 0,0,0,0,0, o,o, o,o,o,o,o>,

<0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0>,
€0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0>,

€ 2'2'2'2'2'2'2'2'2'2'2'2'2'2'2'2^'

€0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0>,
<0,0,0,0,0,0,0,0,0.0,0,0,0,0,0,0>,

c

/* drive type 1 = 360 */

/* = no media in 360 kb drive */
C0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0>,

/* 1 = 360 kb media in 360 kb drive */
{0xOaf,2,m_wait,2,9,0x2a,-1,0x5O,0x0f6,15,8,39,RATE_250,drive_36O|media_36O,0,O>,

/* 2-7 not used */
<0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0>,

<2'2'2'2'2'2'2'2'2'2'2'2'2'2'2'2J'

<2'2»2'2'2'2'2'2'2'2'2'2'2'2'2'2}'

< 2»2»2»2'2'2'2'2'2'2»2'2'2»2'2'2 > ' ~
co,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o>,

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0>,

>,

/* drive type 2 = 1.2 */

/* = no media in 1.2 mb drive */
<0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0>,

/* 1 a 360 kb media in 1.2 mb drive */
<0xaf,2,mj.ait,2,9,0x2a,-1,0x50,0x0f6,15,8,39,RATE_300 ,driveJ2|media_360,1,0>,

/* 2 = 1.2 mb media in 1.2 mb drive */
<0xaf,2,m_wait,2,15,0x1b,-1,0x54,0x0f6,15,8,79,RATE_500 ,driveJ2|mediaJ2,0,0>,

/* 3-7 = not used */

<2'2'2'2»2'2'2'2'2'2'2'2'2'2'2'2}'
co,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o>,

<0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0>,

{ 2»2'2'2'2'2'2»2'2'2'2'2»2'2'2'2^'

€0,0, 0,0,0,0,0, o,o,o,o,o,o,o,o,o>,
>,

/* drive type 3 = 720

A-Tvpe BiosKit

The Floppy Disk Driver E-8-5

/* = no media in 720 kb drive */
C0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0>,

/* 1-2 = not used */
<0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0>,
CO, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0,0},

/* 3 = 720 kb media in 720 kb drive */
C0x0af,2,m_wait,2,9,0x2a,-1,0x50,0x0f6,15,8,79,RATE_250 ,drive_720|media_720,0,0>,

/* 4-7 = not used */

co,o, 0,0, 0,0, 0,0, 0,0,0,0,0,0,0,0},

co,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o>,
co,o,o,o,o,o,o,o,o,o,o,o,o,o,o,0},
},

c

/* drive type 4 = 1.44 */

/* * no media in 1.44 mb drive */
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

/* 1-2 ■ not used */

CO, 0,0, 0,0,0, 0,0,0,0, 0,0,0,0, 0,0>,

C0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

/* 3 = 720 kb media in 1.44 mb drive */
C0xaf,2,m_wait,2,9,0x2a,-1,0x50,Ox0f6,15,8,79,RATE_250 ,drive_14|media_720,0,0>,

/* 4 = 1.44 kb media in 1.44 mb drive */
C0xaf,2,m_wait,2,18,0x1b,-1,0x6c,0x0f6,15,8,79,RATEJ00 ,drive_14|mediaJ4,0,0>,

/* 5-7 = not used */

<2'2»2-2'2»2'2'2»2'2»2»2'2»2»2'2 > »

c 2'2'2'2'2'2'2'2'2'2'2»2'2'2»2'2?»
co,o,o,o,o,o,o, 0,0,0,0,0,0,0,0,0},

- drive type 5 = 2.88

// The 2.88 Meg drives have not been tested.

// These tables are included as a help to integrating 2.88 drives into your system.

// The correct parameters must be determined in conjunction with the drive manufacturers

// specifications.

/* * no media in 2.88 mb drive */

co,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o},

/* 1-2 not used */

{ 2'2»2'2'2'2'2'2»2'2'2'2'2»2'2'2>'

{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

/* 3 = 720 kb media in 2.88 mb drive */
C0xaf,2,m_wait,2,9,0x2a,-1,0x50,0x0f6,15,8,79,RATE_250 ,drive_28|media_720,0,0>,

/* 4 = 1.44 kb media in 2.88 mb drive */
C0xaf,2,m_wait,2,18,0x1b,-1,0x6c,0x0f6,15,8,79,RATE_500 ,drive_28|media_14,0,0>,

/* 5 = 2.88 kb media in 2.88 mb drive */
C0xaf,2,m_wait,2,36,Ox1b,-1,0x53,0xOf6,15,8,79,RATEJ0OO,drive_28|media_28,O,0},

/* 6-7 not used */
CO, 0,0, 0,0,0, 0,0.0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
}.

C
/* drive type 6 = reserved */

€0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

t 2'2'2'2'2'2'2'2'2'2'2-2'2»2'2'2 > '
c 2'2'2'2'2'2'2'2'2'2'2'2'2'2'2'2 > «

CO, 0,0, 0,0,0,0,0,0,0, 0,0,0,0, 0,0},
€0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
€0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},

},

€
/* drive type 7 = reserved */

Section E: The C Programs

E-8-6 The Floppy Disk Driver

{0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0>,
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0>,
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0>,
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
{0,0,0,0,0,0,0,0,0,0,0,0,0 0,0,0>,
{0,0,0,0,0,0,0,0,0,0,0,0,0 0,0,0>,
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0>,

>;

/♦PROGRAM*/

/••Ik******************************************************
*

* FOSCO Enhanced Floppy Disk Driver

* Copyright FOSCO 1988, 1989

*
**********************************************************/

/*

This driver uses a drive/media id byte as follows:

bit 7 0/1 = media not established / established

bit 6-4 media type

000 = no established media

001 = 360 (40/80 track)

010 = 1.2 (80 track)

011 =720 (80 track)

100 = 1.4 (80 track)

101 = 2.8 (80 track)
110 - 111 reserved

bit 3 = 0/1 * drive not established / established

bit 2-0 Drive type

000 no established drive type

001 = 360 (40 track)

010 = 1.2 (80 track)

011 =720 (80 track)

100 = 1.4 (80 track)

101 = 2.8 (80 track)
110 - 111 reserved

The drive/media bytes are located at 40:90-93 for up to four drives.*/
/*=================== STARTOFCOoi ====================*/

variables

unsigned char fd drive_type;

unsigned char fcTstateJ

unsigned char f effete command;

unsigned char fd~dma~command;

unsigned char fcTsecTor track;

unsigned char fcTmedia type;

unsigned char fcTfcodeJ

unsigned char fd~drive;

unsigned char fcTnr sectors;

unsigned char fcThead;

unsigned char fcTsector;

unsigned char fcTtrack;

unsigned fd max_?rack;

unsigned feTmax~sectors;

unsigned fd~i; ""

unsigned fcTtry count;

unsigned fcTmedTa index;

unsigned chlr encTt rack, end head, end sector, num sectors, sectors track;

unsigned dma address; ~ ~

unsigned long I check;

unsigned nibble, upper byte, lower byte, length;

unsigned char error byte, time out flag;

end variables fdisk~regs; ~ ~

setup the controller

void fdisk setup ()
{ "

fdisk regs *myblock:

myblock = acquire_block(FLOPPY);

link_interrupt(0x13,&_disk_io);

A-Tvpe BiosKit

The Floppy Disk Driver E-8-7

/* clear drive state */

/* clear drive 1 state */

/* clear drive 2 state */

/* clear drive 3 state */

link interrupt(0x0e,& disk isr);
set_vector(0x1e,bios_cs(),Efdisk_table[0] [0] CO]);

outportb(0x21,inportb(0x21) & -BIT6); // unmask int's
SEEK STATUS = 0; /* clear seek status */
MOTOR* COUNT = 0: /* clear motor count */
MOTOlTSTATUS = 0; /* clear motor status */
DISK_STATUS = 0; /* clear disk status */

HF CNTRL 1=1;

RTC WAIT FLAG |= 1;

pokIb40(fflSK ID+0,0)

pokeb40(DISK~ID+1,0)

pokeb40(DISK"ID+2,0)

pokeb40(DISlClD+3,0)

pokeb40(DISK ID+0,cmos type(0));
pokeb40<D I SK""I D+1 , cmos"type( 1 ) ) ;
pokeb40(DISK~ID+2,cmos~type(2));
pokeb40(D I SK~ID+3, cmos~type(3) );

RTC WAIT FLAG &= Oxfe; /* allow for rtc wait */
MOTBR_COUNT = get_parm(myblock,2); /* set motor count */

myblock -> dx = 0x0000;

myblock -> ax * 0x0000; /* reset the FDC */
sys int(0x13, myblock);
release block(myblock);
>

/*======== BEGINNING OF MAIN ROUTINES ===================*/

/* handle the floppy disk function service call */

void interrupt cdecl far disk ioO'nterrupt registers)
< "

fdisk regs *myblock;
// disableO; // some XT type disk controllers will pre-enable

myblock = acquire block( FLOPPY);
// enableO;

snapshot^inC FLOPPY, &es);

myblock->fd fcode = ax » 8:
myblock->fcTdrive = dx & OxOOff;
myblock->fcTnr sectors = ax & OxOOff;
myblock->fcThead = dx » 8:
myblock->fd~sector = ex & OxOOff;
myblock->fcTtrack = ex » 8;

flags &= -0x0001; /* clear the carry flag for returns */

DISK_STATUS =0; /* clear status */

if <(<ax » 8) != 0) && ((dx & OxOOff) > 3))
i II bad function code because of drive number

DISK_STATUS = BAD_CMD; ax * (BAO_CMD « 8) | (ax & Oxff);

flags I s 1; /* set return error~flag */
>

else
i

I* make sure any residual status is unloaded *l

purge fdc();

/* seT the data rate register to a default value */

outportb(DRR_PORT , RATE_250) ;

switch (myblock->fd fcode)
C

case RESET : /* reset the disk controller */

watch string( FLOPPY, "Reset");

FDC reset(myblock);

ax = (DISK STATUS « 8) II (ax & Oxff);

if ((ax & UxffOO) != 0) flags |= 1;

break;

case READ STATUS:

watch strTng( FLOPPY, "Read Status");

ax = PISK STATUS « 8:

if ((ax &"0xff00) != 0) flags |= 1;

break;

Section E: The C Programs

E-8-8 The Floppy Disk Driver

case READ SECTORS: /* read sectors */
watch strTng<FLOPPY, H Read sectors");
MOTOR'STATUS &» -INT FLAG;
myblock->fd fdc command = FDC READ;
myblock->fcTdma*"commard = DMA~RX_MODE;
goto read_write~verify; ~

case WRITE SECTORS:

watch string( FLOPPY. "Write sectors");

MOTOR~STATUS 1= 0x80;

myblock->fd fdc command = FDC WRITE;

myblock->fcTctaa~command = DMA~TX MODE;

goto read_wr i te~ver i f y ;

case VERIFY SECTORS:
watch stn"ng< FLOPPY, "Verify sectors");
MOTOR"STATUS &* -INT FLAG;
myblock->fd fdc command = FDC READ;
myblock->feTdma"command = DMA"VRFY MODE;
goto read_w? i te~ver i f y;

read_wr i te_ver i f y :

// if a media change sensed, then de-establish media
if (med change(myblock) == error)
<

andb40(DISK ID+myblock->fd drive,0x0f);

myblock->fdmedia index = U;
> ~
myblock->fd try count =3:

do // this~is the major loop, try the major operation 3 times
i

watch_string(FLOPPY,"\n\rMajor Loop");

// if media not established, then set media type » drive type
// set media_index = 0, set media type by index

if <(peekb40(DISIC ID+myblock->fd drive) & media established) == 0)

< ~ - . -

// set the media index for the first possible type of media
myblock->fd_drive_type = peekb40(DISK_ID+myblock->fd_drive) & 0x07;

// set the DISK ID with the first media type to try
pokeW0(DISK ID+myblock->fd drive, (peekb40<DISICJD+myblock->fd_drive) &
-media field) J

(peekbcsC&transition table [myblock->fd drive type] [0]) « 4));
// set the media type according to the drive type CinBex = 0]
myblock->fd_media_type = (peekb40(DISK_ID+myblock->fd_drive) » 4) & 0x07;

do // this is the minor loop
// do until we run out of retrys
<

watch string(FLOPPY," Minor Loop ");

purge~fdc(); /* make sure any residual status is unloaded */

// set up drive and media indexes before doing the dma setup,

// which needs to know how many bytes per sector for calcing xfr length

myblock->fd drive type * peekb40(DISK ID+myblock->fd drive) & 0x07;

myblock->fd~media"type * <peekb40(DISK ID+myblock->fa drive) » 4) & 0x07;

watch string( FLOPPY, 1 " Disk ID byte * "T;

watdTbyte< FLOPPY, peekb40(DISIC_ID+fflyblock->fd_drive) );

if (dma_setup(myblock,es,bx) *« ok)

/* send the specify command */
send fdc(3);

sentff dc(get_parm(myblock, 0) ) ;
sencTfdcCget j»rm(myblock, 1 ) ) ;

send_rate(myblock);

if (fdc init(myblock) =« ok)

if (send fdc(myblock->fd track) == ok)
i
if (send fdc(myblock->fd head) == ok)
i "

if (send fdc(myblock->fd sector) == ok)
i
if (send_fdc(get_parm(myblock,3)) == ok)

if (send_fdc(getj>arm(myblock,4)) == ok)

if (send_fdc(getj3arm(myblock,5)) == ok)

A-Tvpe BiosKit

The Floppy Disk Driver E-8-9

i

if (send_fdc(get_parm<myblock,6)) == ok)
if (get fdc status(myblock) == ok)
orb40(DISK_ID+myblock->fd_drive,media_established); break; // get out with good

operation

>
>
>
>
>
>
>
>
>
>
>

while (retry(myblock) == error);

watch string(FLOPPY,"\n\rDISK STATUS = ");watch byte< FLOPPY, DISK STATUS);
> "

while <(--myblock->fd try count > 0) &&

((peekb40(DISK~ID+myblock->fd drive) & media established) == 0) &&
((DISK STATUS & TIRE OUT) 1= TIME~0UT));
ax = (DISK STATUS « 8) T (calc sectors(mvblock)); "
if ((ax & UxffOO) != 0) flags |= 1;
break;

case FORMAT TRACK : /* format track */
watch st ring( FLOPPY," Format track");
myblock->fd fdc command = FDC FORMAT;
myblock->fd~dma""coninand = DMA"TX MODE;

// if media~not~established, Tfhen set media type = drive type
if ((peekb40(DISK ID+myblock->fd drive) & media established) == 0)
pokeb40(Dl5K ID+myblock->Td drive.

(peekb40(DISK ID+myblock->fd drive) & 0x07) |

((peekb46(DISK_ID+iyblock->fd_drive) & 0x07) « 4));

MOTOR STATUS |= 0x80; /* indicate write operation */

if (med change(myblock) == ok) /* check for media change */

i

watch string(FLOPPY,"\n\rNo media change");

send Tdc(3); /* send specify command */

sencTf dc ( get_parm(mybl ock , ) ) ;

sencTf dc(get parm(myblock, 1 ) ) i

watch" string7jFL0PPY,"\n\rSpecify Command Sent");

send rate(myblock);

if (dma_setup(myblock,es,bx) == ok)

watch string(FLOPPY "\n\rDma Setup ok");

if (f3c init(myblock) == ok)

i

watch string( FLOPPY, "\n\rFDC Init ok");

if (send_fdc(getj>arm(myblock,3)) == ok)

watch string(FLOPPY,"\n\rSent parm 3"):
if (send_fdc(get_parm(myblock,4)) =* ok)

watch string(FLOPPY,"\n\rSent parm 4"):
if (send_fdc(get_parm<myblock,7>) == ok)

watch_string(FLOPPY, M \n\rSent parm 7");

send fdc(get_parm(myblock,8)); /* send command */
watch"_stnngTFLOPPY, M \n\rFDC Commands all sent");

get fdc_status(myblock);

watch_string( FLOPPY, "\n\rFDC status rx'd");

>
>
>

>
>

ax = DISK STATUS « 8;

if ((ax &"0xff00) != 0) flags |= 1;

break;

case DISK PARMS : /* read drive parameters */

watch strTng(FLOPPY,"Read disk parms");

ax = Ex * ex = dx = es = 0: /* reset all registers */

if (myblock->fd_drive > OxsO)

ax = (ax & Oxff) | (BAD_CMD « 8); flags |= 1; /* set return error flag */

Section E: The C Programs

E-8-10 The Floppy Disk Driver

else
i
if ((EQUIP FLAG & 0x01) !* 0) /* there are drives present */
<

di = dx; // save old dx temporarily
dx = EQUIP FLAG » 6;
/* return W of drives in dx */
if (di > dx) /* called for a non-existent drive */
di = 0; /* return with null parameters */
else
i

di = 0;
if (cmos_type(myblock->fd_drive) !* 0) /* get parms for this type */

myblock->fd_drive_type * myblock->fdjnedia_type * cmos_type(myblock->fd_drive) & 0x07;

di = &fdisk table tmyblock->fd drive type] tmyblock->fd media typeHO];
myblock->fd~'sector track * peekbcs(£fdisk table [myblock->fcTdnve type] [myblock-
>fd media type] CDT'SEC TRK]); " "

my5lock->fcTmax~track = peekbcs(&fdisk table Cmyblock->fd drive type] [myblock-
>fd media type] [DT~MA)rTRK]); ~ "

cx~* ( (myblock->f d max track « 8) & OxffOO) I (myblock->fd sector track & 0x3f);
dx * (1 « 8) I dxj "
bx = cmos type(myblock->fd drive) & 0x07;
es = bios""cs(); // needs to be our code segment
>
>
>

break;

case DISK TYPE : /* read disk type */
watch_strTng( FLOPPY, "Read disk type");

ax &= OxOOff; /* no drive */

if ((peekb40(DISK_ID+myblock->fd_drive) & drive_field) !* drive_none)

if ((peekb40(DISKJD+myblock->fd_drive) & drive_field) »» drive_360)
ax |= 0x0100; /* 40 track, no change line */

else

ax I- 0x0200; /* 80 track, change line */
>
>
break;

case DISK CHANGE : /* return change line condition */

watch str7ng(FL0PPY, M Read disk change line");

/* if "no drive - then return a timeout condition */

if ((peekb40(DISK ID+myblock->fd drive) & drive field) == drive none)

i " "

DISK STATUS 1= TIME OUT;
>

else
{

/* if 360 k drive - always return disk change */

if ((peekb40(DISK ID+myblock->fd drive) & drive field) == drive 360)

DISK STATUS * MEDTA CHANGE; "

else"

/* if 720, 1.4, or 2.8 drive - read the change line */

if (read dskchng(myblock) l» )

DISK.STATUS » MEDIAJTHANGE;

ax - (DISK STATUS « 8) I (ax ft Oxff );
if ((ax ft UxffOO) != 0) flags |* 1;
break;

case FORMAT SET : /* set disk type V
watch_string(FLOPPY,"Set disk type");

/* set drive to requested format/media V

myblock->fd_drive_type = peekb40(DISK_ID+myblock->fd_drive) ft 0x07;

switch (ax ft OxOOff) /* use requested type for switch */

case 1: /* 360/360 */

if(myblock->fd drive type *= drive 360)

Eokeb40(DISK ID+myblock->fd drive,Tmedia 360 | drive 360 | media established));
reak; ~ ~ ~ ~ ■

case 2: /* 360/1.2 */

if(myblock->fd drive type == drive 12)

pokeb40(DISK ID"+myblock->fd drive,7media 360 | drive 12 | media established));

A-Tvpe BiosKit

The Floppy Disk Driver E-8-11

break;

case 3: /* 1.2/1.2 */

if(myblock->fd drive type == drive 12)

pokeb40(DISK_ID>niyblocfc->fd_drive,Tmedia_12 | drive_12 | media_established));

break; ~ "" - - -

case 4: /* 720/720 */

if(myblock->fd drive type == drive 720)

pokeb40(DISK ID"+myblocfc->fd drive, Tmedia 720 | drive 720 | media established));

break; ~ - - _ _

default:

DISK STATUS = BAD CMD; /* bad command */

break";
>

ax = (DISK STATUS « 8) I (ax & Oxff);
if ((ax & UxffOO) != 0) flags |= 1;
break;

case SET MEDIA : /* set media type */

watch string( FLOPPY ."Set media type");

// gel the max tracks called for

myblock->fd max track = (ex » 8) | ((ex « 2) & 0x300);

// get the max sectors called for

myblock->fd max sectors = ex & 0x003 f;

if (cmos type(myblock->fd drive) t = 0)

C

myblock->fd drive type = cmos tYpe(myblock->fd drive) & 0x07;

watch st ring( FLOPPY, "\n\rD rive is ");watch byte(FLOPPY,myblock->fd drive);

watch~string(FLOPPY, M \n\rDrive type is ");watch byte( FLOPPY, myblock"->fd drive type);

// "myblock->fd drive type = peekb40(DISK ID+myblock->fd drive)& 0x07j

// use the transition table for this drive " ""

for (myblock->fd i= 0;peekbcs(&transition table [myblock->fd drive type] [myblock->fd i]) !=
0;myblock->fd i++)

i

myblock->fd media type = peekbcs(&transition table [myblock->fd drive type] [myblock->fd i]);
watch_string( FLOPPY, l, \n\rMedi a type is ,, );waTch_byte(FLOPPY,myBlock->fd_media_type);

if ((myblock->fd max sectors == peekbcs(&fdisk table [myblock->fd drive type] Cmyb lock -
>fd media type] [DT SEC TRtt)) && \ ~ "

" ~ (myblock->fd max track == peekbcs(&fdisk table [myblock->fd drive type] [myblock-
>fd_media_type][DT_MAX_TRK]))) ~ " "

// return the disk parms ptr to the caller

di = &fdisk_tableCmyblock->fd_drive_type] [myblock- >fd_media_type] [0];
es = bios cs(); "* ~

// set the disk id to the established supported media

pokeb40(DISK ID+myblock->fd drive, myblock->fd drive type | (myblock->fd media type « 4) |
drive established I media established);

watch""string(FLOPPY, ,, \n\rRedia established, drive byte is: •');
watch"byte( FLOPPY, peekb40(0 I SK ID+myblock->fd drive));
// need a break to say OK here - ! ! !
goto set media exit;
> "
>

if (peekbcs(&transition table [myblock->fd drive type] [myblock- >fd i]) == 0)
DISK STATUS = MED NOT FHD; ~

> " "

set media exit:

ax = (DISK STATUS « 8) I (ax & Oxff);
if ((ax & UxffOO) != 0) flags |= 1;
break;

default : /* invalid function code - return bad code */
watch string(FLOPPY,"Bad Command");

disk Status = bad cmd;

ax -'(BAD CMD « 8) | (ax & Oxff);
flags |* T; /* set return error flag */

> /* end of switch */

>

snapshot_out ( FLOPPY ,&es) ;

MOTOR COUNT = get pa rm( myblock, 2); /* set motor count */
re I ease_bl ock(mybTock ) ;

> /* end of disk_io */

Section E: The C Programs

E-8-12 The Floppy Disk Driver

/* reset the disk system */

void FDC reset(fdisk regs *myblock)

unsigned i;
unsigned char status;

disableO;

status = (MOTOR STATUS « 4) | 8;

// if a motor is on, set the drive select bits accordingly

switch (status & OxfO)

C

/* motor 2 on */

case 0x20: status |= 0x01; break;

/* motor 3 on */

case 0x40: status |= 0x02; break;

/* motor 4 on */

case 0x80: status 1= 0x03; break;
>

outportb (DOR PORT, status); /* reset disk controller */
SEEK STATUS *~0;

outportb (DOR PORT, status | 0x04); // reset the reset bit
enableO; 7* enable interrupts */
/* wait for interrupt */

if (wait into ■» error) {DISK STATUS |= BAD FDC; return; >
for (i ="0; i < 4; i++) /* number of drives */
<

/* send command */

if (send fdc(8) == error) < DISK_STATUS |= BAD_FDC; return; >

/* check'results */

if (resultsO !» ok) i DISK STATUS 1= BAD FDC; return: >

if (peekb40(FDC_STATUS) \- Ti | 0xc6)) < D*ISK_STATUS ]* BAD_FDC; return; >

send_speci f y_cofflmand(myblock);

/*33333S3S333333S333333333333333333S3333333S3S33333X33333S

When the hardware interrupt occurs from the floppy disk,
this function sets bit 7 in the seek status flag and sends
an end-of- interrupt command to the 8259.

void interrupt cdecl far diskjsr (void)
SEEK_STATUS |= INT_FLAG; outportb (0x20,0x20); /* send eoi */

Return the drive type for a specified drive.

V

unsigned char cmos type (unsigned char drive nr)
C

unsigned char drive type * 0;
switch(drive nr) ~
i

case 0: drive type = i nemos (0x10) » 4: break;

case 1: drive'type = incmos(OxlO) & OxOf; break;

case 2: drive"type = incmos(0x11) » 4: break;

case 3: drive'type = incmos(0x11) & Oxuf; break;
>

if (drive type != 0) drive type \- drive established;
return(drTve_type) ;

Send a byte to the FDC.

V

unsigned char send fdc( unsigned char parm)
C
unsigned long i = set_timeout_count(5); // wait at least 1 sec

do
i
if ((inportb(MSR PORT) & OxcO) == RQH)

A-Tvpe BiosKit

The Floppy Disk Driver E-8-13

outportb(DATA PORT.parm);

delay cat I (0,50); /* delay at least 50 useconds */
return (ok);
>
>

while (TIMER LONG < i);
DISK STATUS J a TIMEJXJT;
return (error);
>

Get the indexed value from the disk parameter table.
*/

unsigned char get_parm(fdisk regs *myb lock, unsigned char index)
C
return(peekbcs(4fdisk_tabletmyblock->fd_ > drive_type] Cmyblock->fd_media_type] [index] ));

/ * =s=sa===as!:s==============::s:ss============s==S!============s

Send the specify command to the FDC.
*/

void send_specify_command (fdisk_regs *myblock)

send fdc(3);

senoTfdc(get_parm(myblock,0));

sencTfdc(get_parm(inyblock,1)); /* send conmand */

/ * =!!====s====SS!===:S!SSS=s:=S!==ss=S!========ass!==== - S!=s===ssss * /

Turn motor on and wait for motor start up time if this is a
write operation. Proceed immediately if a read operation.

1. save the last state of the motor.

2. turn on the selected motor.

3. if not a write, exit immediately.

3. if a write, if the same motor was already on, exit, else wait for the delay.

*/

void motor on(fdisk regs *myblock)
i
unsigned char thisjnotor, lastjnotor, wait;

disableO;

MOTOR COUNT = Oxff;

/* hi? timer with max on-count */

last motor = MOTOR STATUS & OxOf;

wait"= MOTOR STATUS & 0x80;

MOTOR STATUS""* this motor = (1 « myblock->fd drive);

outportb(DOR_PORT,(This motor « 4) | 0x0c | myblock->fd_drive);

enableO;

if ((last motor != this motor) && (wait != 0))

t

// delay for a write and a motor start

// force a delay in 1/8 seconds

// delay « (resolution, count) in milliseconds */

delay call(125.getparm(myblock,10));

MOTOR"COUNT * Oxff;

/* MT timer with max on-count */

watch string(FLOPPY, M \n\rMotor on Delay = ");

watchT3yte( FLOPPY, get jaarmdnyblock, 10) );

>

Wait for the hardware interrupt to occur. Time-out and return
if no interrupt.

V

unsigned char wait int (void)

i

I* this time out should be 3 sees */
unsigned long i = set_timeout_count(3 * 20);

Section E: The C Programs

E-8-14 The Floppy Disk Driver

disableO:

outportb( 0x21, inportb< 0x21) & -BIT6);

enableO; -

do

{.

if ((SEEK STATUS & INT FLAG) != 0) < SEEK STATUS &= -INT FLAG; return (ok); >
>

while (TIMER LONG < i);

DISK STATUS T= TIME OUT; SEEK STATUS &= -INT FLAG;
return (error); "" ~

>

Send the data- transfer- rate command to controller
- */

void send rate(fdisk regs *myblock)

outportb(DRR PORT, peekbcs(&f disk table[peekb40(DISK ID+myblock->fd drive) & 0x07]
[(peekb40(Dl5K ID+myblock->fd drive) » 4) & 0x07] CUT RATE]));
>

Process the interrupt received after recalibrate or seek.

*/

unsigned char chk stat 2 (void)
i "

if (wait into = s error) return (error);
if (send"*fdc(8) == error) return (error);
if (resuTtsO sat error) return (error);

if ((peekb40(FDC STATUS) & 0x60) =* 0x60) /* normal termination V
C

watch string(FLOPPY, M \n\rSeek Error, fdc status was - ••);

watch~byte( FLOPPY, peekb40( FDC STATUS) ) ;

DISK STATUS |= BAD SEEK;

return (error); ~

return (ok);
>

/ * s=s=sra=ssss=s= „ sa=S!= „ =s==ss==:s=s=S!===S!==S!==s:===sa=s=!SS=

Initialize dma controller for read, write, verify operations.
- */

unsigned char dma setup(fdisk regs *myblock, unsigned es, unsigned bx)

i "

disableO; /* disable interrupts */
outportb(DMA FLFF,0x00); /* set the first/last ff */
outportb(DMA3lASK,DMA_OFF); /* disable channel while loading */

outportb(DMA M00E,myblock->fd dma command); /* output mode byte */

if (myblock->fd dma command »« DMA" VRFY MODE) /* dma verify command ? */

< /* yes */" " ~

myblock->dma address = 0;

myblock-> lower byte = 0;

myblock->upper~byte = 0;
myblock->nibble = 0;

>

else

t

myblock->dma address = es ♦ (bx » 4);

myblock->nibEle = myblock->dma address » 12;

myblock->upper byte » myblock->dma address » 4;

myblock->lower33yte = (myblock->dmi_address « 4) | (bx & OxOOOf);

myblock->length = ((myblock->fd nr sectors * 128) « get parm(myblock,3)) - 1;
watch string(FLOPPY, M \n\rTransfer length « ");
watch~word(FLOPPY,myblock->length);

outportb(DMA ADR,myblock-> lower byte); /* output low address */
outportb(DMA~ADR,myblock->upper~byte); /* output high address */
outportb(DMA~PAGE,myblock->nibbTe); /* output page address V
outportb(DMA"BASE,myblock->length & Oxff); // output low byte length
outportb(DMA~BASE,myblock->length » 8); // output high byte length
enableO; ""/* enable interrupts */

outportb(DMA_MASK,DMA_ON); /* init disk channel */

A-Tvpe BiosKit

The Floppy Disk Driver E-8-15

myblock->lcheck = 0;

myblock->lcheck = ((myblock->upper byte & Oxff) « 8) | (myblock-> lower byte & Oxff);

myblock->lcheck = myblock->lcheck + (unsigned long) myblock-> length;

if <myblock->lcheck & OxffffOOOO) /* test for overflow */

£ I* overflow */

DISK STATUS = DMA BOUNDARY;

watch" st ring< FLOPPY, "\n\rDMA overflow");

return (error);
>

return (ok);
>

Move the head to the selected track.
*/

unsigned char seek(fdisk regs *myblock)
C

//unsigned char drive type, media type;
if ((SEEK STATUS & (T « mybloclc->fd drive)) == 0) /* need recal */

SEEK_STATUS |= (1 « myblock->fd_drive); /* mark recal will be done */

/* try 2 attemps at recalibrate, then if failed, return error */
if (recal(myblock) == error)
i
DISK STATUS = 0;

if ( recal (myblock) == error) return (error);
>

pokeb40(LAST TRACK+(myblock->fd drive) ,0); /* clear track number */
/* if we want track zero, then fust wait for head and exit */
if (myblock->fd track == 0) < wait for head(myblock); return (ok); >
> " " "

if (peekbcs(&fdisk table [myblock- >fd drive type] [myblock- >fd media type] [DT STEP]) != 0)

myblock->7d track *= 2;
if (peekb40(LAST TRACK+myblock->fd drive) == myblock->fd track)

returnTok)j "" "~

/* update new position */

pokeb40(LAST TRACK+myblock->fd drive,myblock->fd track);
if (send fdcTOxOf) == error) return (error);
if (send~fdc(myblock->fd drive) == error) return (error);
if (sencTfdc(myblock->fd~track) == error) return (error);
if (chk stat 2() == error) return (error);
wait for head(myblock);
return (ok);
>

Recalibrate the drive.

- */

unsigned recaKfdisk regs *myblock)
{

if (send fdc(7) == error) return (error);

if (send~fdc(myblock->fd drive) == error) return (error);

/* send command */

if (chk stat 2() == error) return (error);

/* return wiTh error */

return (ok); /* return with no error */
>

Determine whether a retry is necessary.
Returning an OK says don't retry any more
Returning an ERROR says retry again

unsigned retry(fdisk regs *myblock)
<

unsigned char media type;
/* if operation timed out - say no refry */
if ((DISK STATUS & TIME OUT ) == TIME OUT) return (ok);
/* if media is established - say no retry */

& medii

if ((peekb40(DISK_ID+myblock->fd_drive) & media_established) != 0) return (ok);

/* we have to step through the media */

II get the next possible media type for this drive type

media_type = peekbcs(&transition_table[myblock->fd_drive_type] [++myblock->fd_mediaJndex]);

Section E: The C Programs

E-8-16 The Floppy Disk Driver

if (media_type == media_none) // then at end of possibles

// dis-establish media

// return - no more

andb40(DISK ID+myblock->fd drive, ~(media_established | media_field));

return(ok); - •""

// insert the new media type into the DISK ID and return saying try again
pokeb40(DISK ID+myblock->fd drive,(peekb407DlSK ID+myblock->fd drive) & -media field)
(media_type << 4));

DISK STATUS = 0;
poke540(FDC STATUS, 0);
return< error); /* return saying retry */
>

/ * ====s==s=sa=s=s==aas=S!!===sa======aa==!S=as=!S=ss=S!aaas!==s

Read anything from the controller following an interrupt.
This may include up to seven bytes of status.

*/

unsigned char results (void)

unsigned long i;
unsigned char count, flag;

for (count = 0; count < 7; count++) // get up to seven bytes

flag = error;

i = set_timeout_count(2); // set delay to 50-100 ms.

do
C
if ((inportb(MSR_PORT) & OxcO) » OxcO) /* data available from FDC */

pokeb40(FDC STATUS+count, inportb(DATA PORT)); /* save status */

delay cal 1(0,100); /* at least 100 us~for the FDC */

flag ■ ok;
>

/* check busy bit */
if ((inportb(MSR_P0RT) & BUSY) == 0) return (ok);

while (TIMER LONG < i);

if (flag ~ error) € DISK STATUS |= TIME OUT; return (error); >
> ~

DISK STATUS |= BAD FDC; /* too many bytes */
return (error);
>

Purge the FDC of any status it is waiting to send.
*/

void purge fdc (void)
C
while ((inportb(MSR_PORT) & OxcO) == OxcO)

inportb(DATA PORT); /* read status */

de I ay_cal 1(0750); /* at least 50 us for the FDC */

>

Read the state of the disk change line.
*/

unsigned char read dskchng(fdisk regs *myblock)

motor on(myblock); /* turn motor on */
return (inportb(DIR_PORT) & DSKCHANGE_BIT);

Execute the FDC read id command.

--*/

unsigned char read_id (fdisk_regs *myblock)

A-Tvpe BiosKit

The Floppy Disk Driver E-8-17

if (send fdc(FDC REAOID) — error) return(error);

if (send~fdc(mybTock->fd head « 2 | myblock->fd drive) == error) return (error);

return (get fdc status(myblock));

Wait for the head to settle after a seek.

void wait for head(fdisk regs *myblock)

unsigned char wait;

wait = get _parm(myblock.9); /* get head settle */
if ((MOTOR STATUS & 0x80) != 0) //if write
< /* yes */
if (wait == 0) /* wait zero ? */
i /* yes */

if ((peekb40(DISK ID+(myblock->fd drive)) » 4) & 0x07)
wait = 0x14; /*~default 360 heaa time */
else

wait = OxOf; /* default others head time */
>
>

else
i
if (wait ss 0) /* is wait zero ? */
return; /* yes, return */
>

delay call(1,wait); /* delay n milliseconds */
>

Checks for a media change, reset media changes and check
media changes.

Returns:

ok » media not changed, error = media changed

unsigned char med_change(fdisk_regs *myblock)

if (read dskchng(myblock) == 0) return (ok);
/* clear'media established and media type */
andb40(0ISK_I0+myblock->fd_drive,-media_established);

disableO;

MOTOR STATUS &= -(1 « myblock->fd drive);

/* turn off motor status */

enableO;

motor on(myblock);

FDC reset(myblock);

mybTock->fd track = 0;

seek(mybloclc);

myblocfe->fd track = 1;

seek(mybloclc);

DISK STATUS = MEDIA CHANGE;

if (7ead_dskchng(my5lock) != 0) DISK_STATUS = TIME OUT;

return (irror); " ~

/*=== = ===== == == === == = = ====== == ============================

Seek to the requested track and initialize the controller
*/

unsigned char fdc init(fdisk regs *myblock)

C "

motor_on(myblock);

if (seek(myblock) == error) return (error);
if (send fdc(myblock->fd fdc command) == error) retum(error):
if (send~fdc(((myblock->Td head «2) & BIT2) | myblock->fd drive) == error)
return(error); ~ ~

return (ok);

Wait until an operation is complete, then accept the status
from the controller.

Section E: The C Programs

E-8-18 The Floppy Disk Driver

unsigned char get fdc status(fdisk regs *myblock)
C

myblock->time out flag ~ wait int();

if (results()~ = = error) return (error);

if (myblock->time out flag -- error)

i
if (DISK STATUS « 0) return(ok); else return(error);

>

if ((peekb40(FDC STATUS) & OxcO) == 0)

if (DISK_STATUS == 0) return(ok); else return(error);
if ((peekb40(FDC_STATUS) & OxcO) != 0x40) < DISK_STATUS |= BAD_FDC; return( error); >

myblock->error byte = peekb40(F0C STATUS
/* get controller status */
if ((myblock->error byte & BIT7) !=
else if ((myblock->error~byte & BITS) ! =
else if ((myblock->error~"byte & BIT4) ! =
else if ((myblock->error~byte & BIT2) !=
else if ((myblock->error~byte & BIT1) !=
else if ((myblock->error~byte & BIT0) !=
else {DISK STATUS |= BAD FDC;>
if (DISK STATUS != 0) return( error ) ;
return(olc);

♦ D;

0) {DISK STATUS
0) <DISK~STATUS
0) {DISlCSTATUS
0) CDISK~STATUS
0) <DISK~STATUS
0) <DISK~STATUS

RECORD NOT FND;>
BAD CRC;> "
BAD~DMA;>
RECORD NOT FND:>
WRITE PROTECT; >
BAD AffDR MARK;>

calculate number of sectors that were actually transferred.

returns:

number of sectors transferred

unsigned char calc sectors (fdisk regs *myblock)

if (DISK_STATUS != 0) return (0);

myblock->sectors track = get_parm(myblock,4);
myblock->end track = peekb40?FDC STATUS + 3);
myblock->encThead = peekb40(FDC STATUS + 4);
myblock->end~sector ■ peekb40<FD"C STATUS + 5);
myblock->nunTsectors =0; ~
if (myblock->end track != myblock->fd track)

mybloclc->num sectors += mybTock->sectors track;
if (myblock~>end head T= myblock->fd head)

mybloclc->num sectors += myBlock->sectors track;
myblock->num sectors += (myblock->end sector - mybTock->fd_sector);
return<myblock->num sectors);
>

A-Tvpe BiosKit

The Hard Disk Driver E-9-1

NINE
The Hard Disk Driver

The Hard Disk Driver is used to operate an optional hard disk drive. This driver
supports the standard AT type of hard disk controller. Other disk interfaces such as
SCSI, ESDI, and SMD may require drastically different hardware level interaction,
but the Bios register interface will remain the same as in this driver. If you are
developing any of these drivers, this module may be used as a starting point, since
the functional requirements at the Bios function call interface remain the same.

*

* Copyright <c) FOSCO 1988, 1989 - All Rights Reserved

* Module Name: AT Bios hard disk driver

*

* Version: 1.04

*

* Author: FOSCO

*

* Date: 10-20-89

*

* Filename: athard.c

* Language MSC 5.1

* Functional Description:

* Interrupt 13h - hard disk driver

* AH = - do a reset on the controller, set recal needed

* AH * 1 - read the last operation status into AL

* for the following operations

* DL = drive number (0x80-0x81)

* DH * head number

* CH = track number

* CL = sector number (except for Format)

* AL - number of sectors (except for Format)

* ES:BX - data buffer address (except for Format)

*

* AH = 2 - read sectors

*

* AH = 3 - write sectors

*

* AH = 4 - verify sectors

*

* The above commands return in AL the # of sectors succesfull

*

* AH = 5 - format track

* ES:BX points to (4 sector bytes) * # of sectors

* Each field (1 per sector) =

* C = Cylinder (track ) number

* H = head number

* R = sector number

* N = number of bytes per sector encoded as:

* 00 = 128 bytes per sector

* 01 = 256 bytes per sector

* 02 = 512 bytes per sector

* 03 = 1024 bytes per sector

*

* AH = 6 - not used

*

* AH = 7 - not used

*

* AH = 8 - Return the Drive Parameters

*

* AH = 9 - Initialize the drive pair

* AH = 10 - Read Long

*

* AH = 11 - Write Long

*

* AH = 12 - Seek

E-9-2 The Hard Disk Driver

* AH = 13 - Alternate disk reset

*

* AH = 14 - not used

* AH = 15 - not used

*

* AH a 16 - test drive ready

* AH = 17 - Recalibrate

* AH = 18 - not used

*

* AH = 19 - not used

*

* AH = 20 - controller diagnostic

*

* AH = 21 - read drive type

*

* Returns:

* Carry Flag Clear = good operation - AH =

* Carry Flag Set ■ Failure - AH = failure code

*

* Arguments:

*

* Return:

*

* Version History:

* 1.01

* DMA overrun check was being called with the ex register instead of the ax register. Changed

* calls to pass ax.

* 1.02

* Corrected previous error in check overrun, (test for nr sectors * 0x7f).

* Corrected error in check error byfe function

* 1.03 "

* Changed init routine to check for any disks present before linking

* vector 40h.

* 1.04

* Replaced peeks and pokes with casts

* Moved variables to myblock

* Changed setup to skip vectoring if no hard disks present

* Changed most function calls to pass only myblock pointer for arguments

* Corrected error in FORMAT case (using wrong block index)

*

*****************************************************************************

/♦INCLUDE FILES*/

#include "atkit.h"

/♦FUNCTION PROTOTYPES*/

/*»»ssssss:s»» function prototypes s=s====ss==±sss==s=*/

unsigned hdisk setup(void);

void interrupt~cdeci far hdisk io( interrupt registers);

void interrupt edeel far hdisk~isr (void);

unsigned char calc hsectors(unsigned char, unsigned char, unsigned char);

unsigned Wait for Tnt(void);

unsigned not busyTvoid);

unsigned check over run< unsigned, unsigned, unsigned);

unsigned wait 7or data(void);

unsigned chedc hcTstatus(void);

unsigned check*"status byte(void);

unsigned check"error byte(void);

unsigned load commarek unsigned);

unsigned hi_regs( unsigned long);

/♦GLOBAL VARIABLES*/

/♦GLOBAL CONSTANTS ♦/

extern const unsigned char hdisk_table;

/♦LOCAL DEFINITIONS ♦/

#define OUTPUT REQ BIT 0x08
#define eccjnode 0x02

#define send_command load_command(myblock)

// bios ram usage definitions

#define bad bat 0x80

A-TVpe BiosKit

The Hard Disk Driver E-9-3

#define bad chksm 0x40

//■

error code definitions

#define NO ERROR 0x00
#define BAD* CMO 0x01
#define BAO'ADORESS 0x02
#define BAD'SECTOR 0x04
#define BAO'RESET 0x05
#define BAD'PARHS 0x07
#define BAD~DMA 0x09
#define BAD'SECTOR FLAG 0x0a
#define BAD~CYLINDf:R 0x0b
#define BAO'FORMAT OxOd
#define BAO'CONTROL OxOe
^define BAD~DMA ARB OxOf
#define BAO"ECC" 0x10
#define BAO'ECC OK 0x11
#define BAD'HDC" 0x20
#define BAD'SEEK 0x40
#define TIME OUT 0x80
#define NOT READY Oxaa
#def ine UNDlTF ERR Oxbb
#define BAD UfflTE Oxcc
#define BAD~STATUS OxeO
#define BAO'SENSE Oxff

//-

function code definitions

KWefine RESET 0x00
#define READ STATUS 0x01
#define REAO'SECTORS 0x02
#define WRITE SECTORS 0x03
#define VERIFY SECTORS 0x04
#define FORMAT"TRACK 0x05
#define BAD FUNCTION 0x06
#define GET'PARAMETERS 0x08
#define INIT DRIVE 0x09
^define READ*"LONG 0x0a
#define WRIT? LONG 0x0b
KWefine SEEK 0x0c
#define ALT RESET OxOd
#define TEST DRIVE READY 0x10
^define RECAtlBRATf 0x11
#define DIAGNOSTIC 0x14
#define GET DISK TYPE 0x15
#define PARK HEAD'S 0x19
#define FORMXT UNIT 0x1 a
#define BAD.COHMAND 0x1 b

#def ine TRY Oxff

// I/O port definitions

#define HD PORT 0x1 fO

// controller task register file (ports) (frame)
// for a port write -

// - write data
// 1 - pre-comp
111- sector count
// 3 - sector number
// 4 - low cyl
II 5 - high cyl
II 6 - size/drive/head
II 7 - command register

// for a port read

read data
error register
sector count
sector number
low cyl
high cyl
size/drive/head
status register

#define HD REG PORT 0x3f6

//-

controller internal command codes

#define HOC RECAL 0x10
#define HDC~READ 0x20
#define HDC~READ LONG 0x22

Section E: The C Programs

E-9-4 The Hard Disk Driver

#define HOC WRITE 0x30
#define HDC~WRITE LONG 0x32
#define HDC~VERIFY 0x40
#define HDC~FORMAT 0x50
#define HDC"INIT 0x60
#def ine HDC~SEEK 0x70
#define HDCDlAG 0x90
#define HDC~SET_PARM 0x91

/♦LOCAL CONSTANTS*/

//const char ndisk_table[1] [1] [16];

/♦PROGRAM*/

variables

unsigned char hd frame t8]; /* The command block is built in this frame */
unsigned hd table sea; /* pointers to drive parameter table */

unsi ■•<--•• - -

gned hd table sea;
gned hd~table~off;

unsigned hd~xfr sea; /* pointers to the transfer area */

unsigned hd~xfr"off;
end variables hdregs;

/* setup the controller */

unsigned hdisk_setup()

unsigned error code * ok;
hdregs *mybloclc;
unsigned char drive type;
myblock = acquire_bTock(HARD);

HD NUM - 0; /* clear number of drives */
HD~CONTROL = 0;/* clear control byte */
HD~STATUS1 = 0;/* clear disk status */

if (incmos(0x8e) & (bad bat I bad chksm) != 0)

C - i -

outcmos(0x8e, incmos(0x8e) & ~0x10); error code = error;
>

else
C

/* get disk type for drive 1 from cmos */

drive type = incmos(0x12) » 4;

if (drive_type != 0) /* there are 1 or more drives */

VECTOR_40 = VECT0R_13; /* move floppy vector to interrupt 40 */

tink_interrupt(0x13,hdisk_io); /* link 13 for functions and 76 (IRQ14) for isr */

I ink_interrupt(0x76,hdisk_isr);

set_vector(0x41 # bios cs(),&hdisk_table); /* set default table addresses to type */
set~vector(0x46,bios~cs(),&hdisk~table);

outportb(0xa1,inportb(0xa1) & -0x40); /* enable IRQ 14 */

outportb(0x21,inportb(0x21) & -0x05); /* enable IRQ 2 in slave mode */

if(drive_type «= 15) drive_type * incmos(0x19); /* get extended type */

/* set pointer to table [type] into int 41 vector */
poke( 0x00. 0x41 * 4,&hdisk table+((drive type-1)*16));
HD_NUM = 1; // say there Ts one drive *

drive type « incmos(0x12) & OxOf;

if (drive^type != 0) /* there are 1 or more drives */

if(drive_type « 15) drive_type = incmos(Oxla); /* get extended type */

/* set pointer to table [type] into int 46 vector */

poke( 0x00. 0x46 * 4,&hdisk table+((drive type-1)*16));

HO NUM = 2; // say there are two drives
> "

/* test the hard disk controller */

myblock->dx = 0x0080;

myblock->ax = DIAGNOSTIC « 8;

sys int(0x13, myblock);

if T(myblock->f lags & carry bit) i- 0)

error code * 0x1782; /* return error code */
>
/* do a reset on the drive(s) */

A-Tvpe BiosKit

The Hard Disk Driver E-9-5

myblock->dx = 0x0080;

myblock->ax = RESET « 8;

sys int(0x13, myblock);

if T(myblock->flags & carry_bit) != 0)

error code = 0x1790; /* return error code */
>

>

release block(myblock);
return(error code);

/*===~===~BiGINNlNG OF MAIN ROUTINES ============*/

/* handle the floppy disk function service call */

void interrupt cdecl far hdisk io (interrupt registers)

hdregs *myblock;

if<(dx & 0x0080) == 0) /* if dl <= 7f, then divert to floppy disk */

C

// fdisk chain is an assembly language routine which

// unstacks the pushed registers, then executes an int 40

// to the floppy driver. This prevents the stack from

// becoming too deep. DOS has a problem with its stack

// being too short to support many nested, interrupts.

fdisk chainO; // does not return here !!!

enableO;

myblock = acquireJjlock(HARD);

snapshot_in(HARD,&es);

flags &= -0x0001; /* clear the carry flag for returns */

HD_STATUS1 = 0; /* clear status */

// set precomp - varies for drive zero or one !!!

if (<dx & Oxff) > 0x81) ax = BAD_COMMAND « 8; /* bad drive number */

if(HD_NUM — 0) ax = BAD_COMMAND « 8; /* no hard drives */

if((dx & 0x7f) > (HD_NUM - 1» ax = BAD_COMMAND « 8; /* bad drive number */

if (<dx & 0x01) == 0) // drive 0:

i

myblock->hd table seg = peek (0x00, 0x0 106);

myblock- >hd"table~off = peek (0x00, 0x0 104);
>

else // drive 1:
i

myblock->hd table seg = peek(0x00,0x011a);

myblock->hdTtable~off = peek(0x00, 0x0118);

// set the control byte

HD CONTROL = (HD CONTROL & OxcO) | peekb(myblock->hd_table_seg,myblock->hd_table_off+8);

//""set the regisTer port

outportb(H0 REG PORT,peekb(myblock->hd table seg, myblock->hd table off+8));

// build the frame

myblock->hd framed] = peek(myblock->hd table seg, myblock->hd table off+5) » 2;

myblock->hcrframe[2] * ax & OxOOff; " // sector count

myblock->h<rframe[3] = ex & 0x3f; // sector number

myblock->herframe[4] = ex » 8; // cyl low

myblock->hcrframe[5] = (ex » 6) & 0x03; // cyl high

myblock->hcTframe[6] = ((dx & 0x01) « 4) | ((dx » 8) & OxOf) | OxaO;

myblock->hcTframe[7] = 0; // pre-clear this item

// normalize es:bx to xfr seg:xfr off = xxxx:000x
myblock->hd xfr seg = es ♦ (bx »~4);
myblock->hcTxfr~off = bx & OxOOOf;

/* now execute the CASE for the selected function */

switch (ax » 8)
<

case RESET: /* reset the disk controller */

watch_str i ng( HARD , "RESET" ) ;

myblock->ax = 0; // do a reset on the Floppy controller first

sys int (0x40, myblock);

if T(dx & OxOOff) > 0x81) // not legal drive #

<
ax = myblock->ax; // pass results back to caller

Section E: The C Programs

E-9-6 The Hard Disk Driver

flags = myblock->flags;
>

else // do the hard drive too
i

// enable the IRQ

outportb(0xa1,inportb(0xa1) & Oxbf);

// reset the controller

outportb< HD_REG_PORT , 4) ;

// DELAY 5-10 USECS
delay_call(0,10);

// set the head, and clear the reset bit
outportb(HD REG PORT, HO CONTROL & OxOf);
if (not busyT) s = error)"
i
HD STATUS1 = BAD RESET;
waTch string( HARD", "NOT BUSY BAD RESET 11 );
>

else
i

watch string(HARD ."Not busy was OK");
if(inportb(HD PORT+1) != 0x01)
C
HO STATUS 1 = BAD RESET;

waTch string(HARff, M Port 1 not = 01 bad reset");
>

else
i

watch string(HARD "Init and Recal the drives");
myblock->ax = INIT DRIVE « 8;
myblock->dx = 0x0050;
sys_int(0x13,myblock);

myblock->ax = RECALIBRATE « 8;

myblock->dx = 0x0080;

sys int(0x13 ( myblock);

// If two drives, do the next one

if (HO NUM > 1)

C

myblock->ax * INIT DRIVE « 8;

myblock->dx = 0x0081;

sys_int(0x13,myblock);

myblock->ax = RECALIBRATE « 8;
myblock->dx = 0x0081:
sys int(0x13,myblock);
> "

HD STATUS1 s 0; // clear the error bits
wafch st ring( HARD, "Good reset");
>

HD STATUS1 = 0; // clear the error bits
wa?ch string(HARD,"Good reset");
>
>
break;

case READ STATUS:

watch st rTng( HARD, "READ STATUS");

ax = Tax & OxffOO) | HD"STATUS1;

break;

case READ SECTORS:

watch strTng(HARD,"READ SECTORS");

myblock->hd frame [7] = HOC READ;

if(myblock->hd_frameC2] s="0) i HD_STATUS1 » BAD_CMD; break; >

watch string(HARD,"\n\rChecking Overrun"):

if (check overrun(myblock->hd frameC2],rayblock->hd xfr off,myblock->hd frameiT]) « ok)

i - - -

watch_string(HARD f "\n\rOverrun ok");

if (send command « ok)
C

watch string(HARD,"\n\rSent command");
// ouput commands
// do this loop for each sector
do
C
if (wait for into = s ok)
// wait~for~data ready interrupt

watch string(HARD,"\n\rReady for data");

// do~the sector transfer

rep in(myblock->hd xfr seg, myblock->hd xfr off,HD PORT, 256);

mybTock->hd xfr ofT +=512;

A-Tvpe BiosKit

The Hard Disk Driver E-9-7

watch string(HARD,»\n\rXFR done");
if (cHeck hd statusO == error) break;
watch str7ngTHARD,"\n\rStatus was OK");
>

while(--myblock->hd frame [2] != 0);
>
>

break;

case WRITE SECTORS:

watch string(HARD, "WRITE SECTORS");

myblock->hd_frame[7] = HD"C_WRITE;

if(myblock->hd_frame[2] == 0) i HD_STATUS1 * BAD_CMD; break; >

// check for transfer overrun

if (check overrun(myblock->hd frame[2],myblock->hd xfr off,myblock->hd frame[7]) == ok)

<: " " "

watch string(HARD,"\n\rOverrun ok");

if (send command == ok)

i
watch_string(HARD,"\n\rSent command 1 *);

// wait for data request
if(wait for dataO == ok)
C " "

watch string(HARD,"\n\rReady for data");
// do this loop for each sector
do
C

// do the sector transfer

rep out(myblock->hd xfr seg,mybtock->hd xfr off,HD PORT, 256);
mybTock->hd xfr off""+= 512;
watch string(HAR~D,"\n\rXFR done");
if (wait for into !* ok) break; // wait for completion
watch s?r i ng( HARD f "\n\rComplet ion Interrupt rx'd");
if (cFeck hd statusO == error) break;
watch strTng7HARD,"\n\rStatus was OK");
>

while(((HD STATUS & 0X08) !- 0) && (--myblock->hd frameC2] != 0));
if(inportbrHD PORT+2) != 0)
C

watch string(HARD,"\n\rXfer Aborted = original error code = ");
watch"word(HARD,HD STATUS1);
HD STA"TUS1 = UNDEF"ERR;
> "
>
>
>
break;

case VERIFY SECTORS:
watch st ring< HARD /'VERIFY SECTORS");
myblock->hd frame [7] = HOC VERIFY;
if (send command == ok) ~

<:

if (wait for into as ok)

C " "
check hd statusO;

> ~ "
>
break;

case FORMAT TRACK:
watch st ring( HARD, "FORMAT TRACK");
myblock->hd frame [7] = HDC FORMAT;

myblock->hd~frame[2] * peeEb(myblock->hd table seg, myblock->hd table_off+K);
if (send command == ok)
i
watch_string(HARD,"\n\rSent command");

// wait for data request interrupt
if (wait for dataO == ok)
i " "

watch string(HARD,"\n\rReady for data");
// do~this loop for each sector
do
i

// do the sector transfer

rep out(myblock->hd xfr seg,myblock->hd xfr off,HD PORT, 256);
mybTock->hd xfr off~+= 512;
watch string(HAR*D,"\n\rXFR done");
if(waTt for into != ok) break; // wait for completion
watch sf r i ng( HARD, "\n\rComp let ion Interrupt rx'd");

Section E: The C Programs

E-9-8 The Hard Disk Driver

if (check hd statusO == error) break;
watch strTngTHARD,"\n\rStatus was OK");
>

while(((HD STATUS & 0x08) != 0) && (--myblock->hd frame[2] !* 0));
// if the controller is still asking for more data, then it is an error
if(inportb(H0 PORT+2) != 0) HD STATUS1 = UNDEF ERR;
> "

>
break;

case GET PARAMETERS:
watch_string(HARD, "GET_PARAMETERS");

// build ch = max cyls, cl = max sectors

// get lower 8 bits of max cyls

ax = peek(myblock->hd table seg,myblock->hd table off)-1;

ex = ax « 8;

ex |= ((ax » 2) & OxOOcO);

// get max sectors

ex |= (peekb(myblock->hd_table_seg,myblock->hd_table_off+14));

// bui Id dh = max heads, dl = # drives

dx = (peekb(myblock->hd table seg,myblock->hd table off+2)-1) « 8;

dx |= HD_NUM; " ~

ax = 0;
break;

case INIT DRIVE:

watch strTng(HARD,"INIT DRIVE");

myblock->hd frame[7] = HDC SET_PARM;

// set max Heads "* "

myblock->hd frame[6] = (myblock->hd fraroeC6] & OxfO) | \

(peekb(myblock->hd table seg,myblocIc->hd table_off+2)-1);

// set sector counT " ~

myblock->hd frame [2] * peekb(myblock->hd table seg,myblock->hd table off+14);

// set low cylinder = "* ~

myblock->hd frame [4] ■ 0;

// set high~cylinder =

myblock-^d^frameCS] » 0;

if (send command ss ok)
i

if (not busyO == ok)

i
check_hd_status( );

>

break;

case READ LONG:

watch strTng( HARD, "READ LOMG");

myblock->hd_frame[7] = HDC_READ_LOMG;

if(myblock->hd_frame[23 « 0) i HD_STATUS1 = BAD_CMD; break; >

// check for transfer overrun

// watch string(HARD "VArChecking Overrun");

if (check3overrun(myblock->hd_frameC23 ,myblock->hd_xf r_off ,myblock->hd_framet7] ) -- ok)

// watch string(HARD f M \n\rOverrun ok");

// commancTphase

if (send command « ok)

i

// watch string(HARD,"\n\rSent command");

// ouput commands

// do this loop for each sector

do

<
if (wait for into = s ok)
// wait~for"data ready interrupt

watch string(HARD,"\n\rReady for data");

// do""the sector transfer

rep in(myblock->hd xfr seg,myblock->hd xfr off,HD PORT, 256);

mybTock->hd_xfr_ofT +=512; ~

// read the 4 extra bytes

pokeb(myblock*>hd xfr seg,myblock->hd xfr off++,inportb(HD PORT));

pokeb( mybl ock - >hd~xf r~seg , mybl ock- >hd~xf r~of f ♦+ , i npor tb( HD~P0RT ) ) ;

pokeb(myblock->hd"xfr~seg,myblock->hcrxfr""off++,inportb(HD PORT));

pokeb(myblock->hcTxfr"seg,myblock->h<rxfr"off++,inportb(HD"'PORT));

A-Tvpe BiosKit

The Hard Disk Driver E-9-9

// watch string(HARD,"\n\rXFR done");

if (check hd statusO == error) break;

// watch"_string(HARD,"\n\rStatus was OK");

while(--myblock->hd frame[2] > 0);
>
>

break;

case WRITE LONG:

watch string(HARD, "WRITE LONG");

myblock->hd_frame[7] = HffC_URITE_LONG;

if(myblock->hd_frame[2] == 0) i HD_STATUS1 = BAD_CMD; break; >

// check for transfer overrun

if(check overrun(myblock->hd frame[2],myblock->hd xfr off,myblock->hd frame[7]) == ok)

i " ~ "

watch string(HARD,"\n\rOverrun ok");

if (send command == ok)

C
watch_st r i ng( HARD , "\n\rSent command" ) ;

// wait for data request interrupt
if (wait for data() == ok)
C " "

watch string(HARD,"\n\rReady for data");
// do~this loop for each sector
do
{.

// do the sector transfer

rep out(myblock->hd xfr seg,myblock->hd xfr off,HD PORT, 256);
mybTock->nd_xfr off"+= 512:
// ecc mode"- send 4 more bytes

outportb(HD PORT,peek(myblock->hd xfr seg,myblock->hd xfr off++));
outportb( HD~PORT , peek(mybl ock- >hd~xf r""seg,myblock->hd~xf r"of f ++ ) ) ;
outportb(HD~PORT,peek(myblock->hcTxfr~seg,myblock->horxfr~off++));
outpor tb( HD~PORT , peek( mybl ock- >hd~xf r~seg , myb t ock- >hd~xf r~of f ++ ) ) ;
watch string(HARD,"\n\rXFR done")7 ~ ~ "

if(waTt for into != ok) break; // wait for completion
watch sfring(HARD,"\n\rCompletion Interrupt rx'd");
if (cReck hd statusO == error) break;
watch strTngTHARD, M \n\rStatus was OK");
>

while(((HD STATUS & 0x08) != 0) && (--myblock->hd_frame[2] != 0)>;
// if the controller still asking for more then an error.
if(inportb(HD PORT+2) != 0) HD STATUS1 = UNDEF ERR;
> ~

>
>
break;

case SEEK:

watch string(HARD,"SEEK");

myblock->hd frame [7] = HOC SEEK;

if (send command == ok) ~

i

if(wait for into ~ ok) check hd statusO;

if(HD STATU51 == BAD SEEK) HD STATUS 1 = 0;
>
break;

case ALT RESET:

watch string( HARD, "ALT RESET");

breakj ~

case TEST DRIVE READY:

watch strTng( HARD, "TEST DRIVE READY");

if(noT busyO == ok) " ~

i

outportb(HD P0RT+6,myblock->hd frame[6]);

check hd stltusO;

break;

case RECALIBRATE:

watch st ring( HARD, "RECALIBRATE");

myblock->hd frame [7] = HOC RECAL;

if (send command == ok) ~

(

if(wait for into == ok)

i " "

check hd statusO;

Section E: The C Programs

E-9-10 The Hard Disk Driver

else
i

if (wait for into == ok)

check h3 statusO;

>

if(HD_STATUS1 == BAD_SEEK) HD_STATUS1 = 0;

breakj

case DIAGNOSTIC:

watch st ring (HARD, "DIAGNOSTIC" );

/* mafc"e sure interrupts are disabled when changing the interrupt mask */

disableO:

outportb(0xa1,inportb(0xa1) & - 0x40);

outportb(0x21,inportb(0x21) & - 0x20);

enableO;

if (not busyO *« ok) /* ok to start diag */

i

outportb(HD PORT+7,HDC DIAG);

if (not busyO == ok) ~ /* wait for completion */

i
if ((HD ERROR = inportb(HD PORT+1)) != 1)

HD STATUS1 = BAD HDC;

else
i
HD STATUS1 = TIME OUT;

>

break;

case GET DISK TYPE:

watch string(HARD,"GET DISK TYPE");

// cyTs = peek(hd table seg,hd table off)

// heads = peekb(ha table seg,h9 table off+2)

// sectors * peekb(hcTtable~s*g,h<Oable~off+14)

ex = hi regs((peek(myblock->hd table seg,myblock->hd table off)-1) *
peekb(myblock->hd table seg,my5lock->hd table off+2)~* ~
peekb(mybl ock- >hcTtabl e~seg # mybl ock- >hcTtable~of f +14 ) ) ;

dx = (peek(myblock->hd table seg,myblock->hd table off)-1) *
peekb(myblock->hd table seg,mybTocfc->hd table off+Z) *
peekb(myblock->hcTtable~seg,myblock->hcrtable~off+14);

ax - 0x0300;
break;

default : /* invalid function code - return bad code */

HO STATUS1 = BAD CMD:

ax~= (BAD CHD «~8) J (ax & Oxff );

break; ~

> /* end of switch */

ax = (ax & OxOOff) | (HD STATUS1 « 8);
if((ax & OxffOO) l« 0) fTags |= 1;

if (watch (HARD))
i

II display port ins

write string("\n\rPort ins If 1 * ");lbyte(inportb(HD PORT+D);

write""string( M 1f2 = ">
write~string<" 1f3 = ••)
write~string<" 1f4 = ")
write~string( M 1f5 » ")
write""string( M 1f6 * ••)
write~string( H 1f7 * ")
write^stringC'XnXr");

>

snapshot out ( HARD r &es);

release 5lock(myblock);
>

lbyte(inportb(HD PORT+2))
lbyte( inportb<HD"PORT+3))
lbyte( inportb(HD"PORT+4))
lbyte( inportb<HD"PORT+5))
lbyte( inportb<HD~PORT+6))
lbyte( inportb(HD~PORT+7))

/*

I* check for the controller not busy */

unsigned not busy(void)

i

I* get current count and add 5 sees to it */
unsigned long delay_count = set_timeout_count(5 * 20);

enableO;

A-Tvpe BiosKit

The Hard Disk Driver E-9-11

// clear status byte
HD_STATUS1 = N0_ERR0R;

do

( if ((inportb(HD PORT+7) & 0x80) == 0) return(ok); >

while ( TIMER J.ONG""< delay_count);

// set time out error
HD_STATUS1 = TIMEJXIT;

// return error condition to caller
return< error); /* time out */
>

void interrupt cdecl far hdisk isr (void)
(

HD INT FLAG = -1:

out por tb( OxaO , 0x20 ) ;

out portb( 0x20, 0x20); /* send eoi */
>

Wait for the hardware interrupt to occur. Time-out and
return if no interrupt.

*/

unsigned wait for int (void)
( " "

/* this time out should be 3 sees */

unsigned long delay_count = set_timeout_count(3 * 20);

enableO;

do

( if(HD INT FLAG != 0) ( HD INT FLAG = 0; HD STATUS1 = 0; return (ok); } >
while (TTIMER LONG < delay count)):
HD INT FLAG ="0; HD STATUS! | = TIMEJXJT;
relurnTerror); ""
>

Wait for the data request. Time-out and
return if no request.

................. ........ ............*

/

unsigned wait for data (void)
i ~ "

unsigned long delay_count = set_timeout_count(2 * 20);

enableO;

/* this time out should be 2 sees */

do

i if((inportb(HD PORT+7) & OUTPUT REQ BIT) != 0) I return(ok); > >

while (TIMER L0N5 < delay count);"

HD STATUS 1 ="TIME OUT; ~

return (error);

>
/ * ===a=!as=SSSS3::s==s=========sass=SSSSS!SS=======s===sss========

recalibrate the drive.
*/

// -

unsigned check hd statusO
i " "

if (check status byte() == error) return( error);

if((inportb(HD PSRT+7) & 0x01) == 0) return(ok);

return( check error byteO);
> ~

//

// This is a reminder of what is in the tables
//const char status mask [5] =(0x80, 0x20, 0x40, 0x10,0x04};
//const char status~err [5] =(0x00, 0xcc,0xaa, 0x40, 0x11 >;
//const char status~key [5] =(0x00,0x00,0x40, 0x10, 0x00};

unsi gned check_status_byte( )

Section E: The C Programs

E-9-12 The Hard Disk Driver

unsigned i;

unsigned char temp;

HD STATUS1 * 0; // start with a clear

temp ■ HD STATUS = inportb<HD PORT+7);

if (watch (HARD))

i write string( M \n\rHD STATUS = "); Ibyte(temp); write string(»\n\r H ); >
if((temp & 0x80)"!= 0) return(oJc);

if((temp & 0x20) != 0) < HD STATUS1 = Oxcc; return( error); >
if ((temp & 0x40) == 0) < HD""STATUS1 = Oxaa; return(error); >
if((temp & 0x10) == 0) i HD""STATUS1 = 0x40; retum(error); >
if ((temp & 0x04) != 0) { HD"STATUS1 = 0x11; >
return(ok); ~

>

//

const unsigned char error table [8] = \

{

BAD SECTOR, /* 0x80 - bad block V

BAD~ECC, /* 0x40 - bad data ecc */

UNDFF ERR, /* 0x20 - not used */

BAD SECTOR, /* 0x10 - id not found */

UNDEF ERR, /* 0x08 - not used */

BAD CflD, /* 0x04 - aborted command */

BAD'SEEK, /* 0x02 - trk not found on recalibrate */

BAD~ADDRESS, /* 0x01 - data address mark not found */

>; "

unsigned check error byte()
i "

unsigned i = 0, temp * 0:

temp = HD ERROR = inportb(HD PORT+1);

watch strfng(HARD "\n\rError"~Byte from 1F1 =••); watch byte( HARD, temp);

whileT(temp & Oxff) != 0)

if ((temp & 0x80) != 0)

HD STATUS1 = peekb(bios cs(),&error tabled']);

waTch string(HARD,»«\n\rError Byte returned ='•); watch^byteCHARD.HD^STATUSD;

return( error); ~

>
temp «» 1; i++;

watch string(HARD,"\n\rMo error detected");
return (ok);
>

//

// check for transfer overrun

// if ecc mode than use 7f04 as max, else use 8000

unsigned check overrun(nr sectors, xfr off, ecc char)

if (nr_sectors < 0x7f) return(ok); // always ok

if ((ecc char & ecc mode) !* 0)
i

if ((nr sectors == 0x7f) && (xfr off < 4)) return(ok);
>

else
i

if(nr sectors == 0x7f) return(ok);

if((n? sectors « 0x80) && (xfr off == 0)) return(ok);
>

HD STATUS1 = BAD DMA;
reTurn( error);
>

//

unsigned load command(hdregs *myparm)
{

unsigned count = 10000;
// hdregs *myparm;
// myparm = arg;

// check for time out on drive being ready
// watch string(HARD,"Load command entry\n\r'»);
do
C

// check for controller and drive ready
if (not busyO ~ ok)
i

II watch string( HARD, "not busy 0K\n\r M );
// select drive
outportb(HD PORT+6,myparm->hd frame [6]);

A-Tvpe BiosKit

The Hard Disk Driver E-9-13

if (check status byte() == ok)
i "

II watch string(HARD, M status byte was ok\n\r H );

// reset the interrupt flag byte

HD_INT_FLAG = 0;

// enable the interrupts

disableO:

outportb(0xa1 f inportb(Oxal) & Oxbf);

outportb(0x21,inportb(0x21) & Oxfb);

enableO;

// check for retries

if((HD CONTROL & OxcO) != 0)

i
if(((myparm->hd frame [7] & OxfO) >= 0x20) && \
<<myparm->hd frame[7] & OxfO) <= 0x40))
myparm- >hd_f Fame [7] |= 0x01;

if (watch (HARD))
C
// output the commands

write string("\n\rPort outs If 1 = ");
lbyteTmyparm->hd frametl])-

write stringC 1T2 = '•)
write~string(" 1f3 = '»)
write~string(" 1f4 = ")
write'stringC If 5 = ")
write"string(" 1f6 = '•)
write"string(" 1f7 = '•)
write~string( H \n\r");

lbyte(myparm->hd frame [2])
lbyte(myparm->hd~f rame[3] )
lbyte(myparm->hcTf rame[4] )
lbyte(myparm->hcTf rame[5] )
lbyte(myparm->hcTf rame[6] )
lbyte(myparm->hcTf rame[7] )

j

outportb(HD PORT+1,myparm->hd framed])
outportb( HD~PORT+2, myparm- >hd~f rame [2] )
outportb( HD~PORT+3, myparm- >hd~f rame [3])
outportb(HD"PORT+4,myparm->hcTf rame[4] )
outportb(HD~PORT+5, myparm- >hd~f rame [5] )
outportb(HD~P0RT+6, myparm- >hd~f rame [6] )
outportb( HD~P0RT+7 # myparm- >hd~f rame [7] )
return(ok);"

while(count-- >
return( error );

0);

/*====================================================*/

/*====================================================*/

/*====================================================*/

Section E: The C Programs

The Boot File E-10-1

TEN
The Boot File

The Bootx File is the bootstrap function call routine which is used to load DOS
from a floppy disk device. The boot routine attempts to read the boot sector of the
specified drive and if successful transfers control to the loaded routine (which in
turn loads the remainder of the operating system).

To allow flexibility in the way the system attempts to boot, there is a "bootjist" in
the boot program which defines the drives which will be used in the boot process.
This list may specify the hard or floppy drives in any order.

If your Boot requirements are non-standard or specific to a dedicated application,
you may wish to modify the standard boot routine. All the standard system
initialization has been done by the POD when the boot routine is finally called. A
specialized boot program may load an operating system or start executing an
application directly. If one is not using an operating system to support an
application, one must not design and code the application so that it makes reference
to non-existent operating system features!

The boot routine should exit if the boot process is not completed. This will allow the
POD routine to attempt an alternate path, such as defaulting to SysVue.

/***************************************************************************************************

* Copyright (c) FOSCO 1988 - All Rights Reserved

* Module Name: AT Bios bootstrap routine

* Version: 1.00

*

* Author: FOSCO

* Date: 12-01-88

* Filename: atboot.c

* Language: MS C 5.1

*

* Functional Description:
*

* This module does the bootstrap load to get DOS loaded and running.

* We look at the boot list to determine what drives should be used for the boot attempts.

* The boot sector is loaded into 0000:7c00 and control is transferred to that address.

* If the boot cannot be performed, then we exit.

*

* Arguments:

*

* Return:

*

* Version History:

************************************************************************

/♦INCLUDE FILES*/

#include "atkit.h"

/♦FUNCTION PROTOTYPES*/

unsigned boot setup(void):

void interrupt cdecl far boot(void);

void boo t_jump( unsigned, unsigned, unsigned);

/* GLOBAL VARIABLES*/

E-10-2 The Boot File

/♦GLOBAL CONSTANTS*/

// this is the list of possible boot devices, in the order in which they should be tried.
// If all the named drives are tried and fail, then exit
// The list is terminated by a -1

const unsigned boot_list[] ={0x00,0x80,0x01,0x81,-1,};

//This example shows the boot preference order to be:
// Drives A:, C:, B:, and D:

// Programmers Caution:

// Some versions of DOS may not allow booting from B: or D: due to DOS internal programs
// defaulting to A: or C:, regardless of the drive number being passed in the DL register
// to the DOS boot sector routine.

// Programmers Note:

// This version of boot checks for a particular signature in the last two (2) bytes of the boot
// sector. This seems to be an IBM or Microsoft convention on their boot records. Boot records of
// operating systems other than IBM or MS may not have this signature. If you wish to modify the
// boot module to accept any value for the signature, you may delete the signature comparison logic
// accordingly.

/* LOCAL DEFINITIONS*/

#define boot retrys 2
#define resel flag 0x72
^define switcK_byte 0x10

/♦PROGRAM*/

unsigned boot setup(void)

link interrupt(0x19,boot);
return(ok);
>

// The boot routine

variables
end_variables bootregs;

void interrupt cdecl far boot(interrupt_registers)

unsigned i, break flag,boot_drive,boot_index;
bootregs *myblock"; ~ "
myblock » acquire block(BOOT);
snapshot_i n< BOOT , Ses ) ;

//write_string<" Booting \n\r M );

// clear the boot area

for <i = Ox7cOO; i < 0x7e00; pokeb< 0x0000, i++,0));

for(boot index = 0; peekcs<&boot list [boot index]) ! = -1; boot index++>

for (i=0;i < boot retrys; i++)

boot_drive = peekcs(&boot_list[boot_index]);

watch string(BOOT,"\n\rBooting from Drive # •');
watch~byte(BOOT,boot drive);
watch"string(BOOT,"\n\rAttempt # M );
watctrbyte<BOOT,i);

myblock -> ax * 0x0000; // try a reset

myblock -> dx » boot drive;

sys int(0x13,myblock7;

/* Tf no carry returned on reset then try booting */

if((myblock -> flags & carry bit) ss 0)

{.

myblock -> ax * 0x0201; /* try to read boot sector */

myblock -> bx = 0x7c00;

myblock -> es = 0x0000;

myblock -> dx = boot drive;

myblock -> ex = 0x000*1;

sys int(0x13, myblock):

if("fmyblock -> flags & carry bit) == 0)

/* no carry returned on read"*/

i

/* check for boot sector signature */
/* See programmers note above */
if (peek(0x0000,0x7dfe) == 0xaa55)

A-Tvpe BiosKit

The Boot File E-10-3

RESET FLAG = 0; /* clear reset flag */
enableO;

release block(myblock);

watch st ring( BOOT # "\n\r Jumping to boot sector\n\r H );
/* go~and don't return */
boot jump< 0x0000, 0x7c00, boot drive);
>

else
i

watch string(BO0T,"\n\rSignature was ");
watch"word< BOOT , peek< 0x0000 , 0x7dfe) );
>
>

else
i
II check for a timeout on the disk controller
if((myblock->ax & 0x8000) != 0) i = boot retrys + 1;
watch string(BOOT, M \n\rCarry returneS on Read");
>
>
else

watch string(BOOT,"\n\rCarry returned on Reset");
>
>
>

watch string<BO0T,"\n\rRetrys exhausted");
snapsHot out (BOOT, &es) ;
release Elock(myblock);
>

Section E: The C Programs

The Cassette Driver E-ll-1

ELEVEN
The Cassette Driver

Although an AT Type machine does not have a cassette interface, a driver is
provided in the event a program makes a cassette function call. The function call
returns a cassette error condition to the caller. The A-Type machines use an
extended set of functions codes for AT specific functions for joystick input, virtual
mode control, multi-tasking hooks, sys-request functions, etc.

/***************************************************************************************************

*

* Copyright (c) FOSCO 1988, 1989 - All Rights Reserved

* Module Name: AT Bios cassette function

*

* Version: 1.01

* Author: FOSCO

* Date: 10-20-89

*

* Filename: atcass.c

*

* Functional Description:

* This module returns an error condition in AX in the event a user program calls this function.

* Version History:

* 1.01

* Replaced peeks and pokes with casts

**********************************************************

/♦INCLUDE FILES*/

#include "atkit.h"

void interrupt cdecl far cassette_io(interrupt_registers);

/* G I B A L S */

extern unsigned char config table;
extern _cassette_io;

/•LOCAL DEFINTIONS*/

#def
#def
#def
#def
#def
#def
#def
#def
#def
#def
#def
#def
#def

ne OPEN DEVICE 0x80

ne CLOSE DEVICE 0x81

ne PROGRAM TERMINATE 0x82

ne EVENT WKIT 0x83

ne JOYSTICK SUPPORT 0x84

ne SYS REQ KEY 0x85

ne WAIT 0xS6

ne MOVE BLOCK 0x87

ne GET EXTENDED MEMORY SIZE 0x88

ne SWITCH TO PRu*TECTED""MODE 0x89

ne DEVICE"BU5Y 0x90 "

ne INTERRUPT COMPLETE 0x91

ne RETURN SYSTEM CONFIG PARAMETERS OxCO

#define rtc_wait_flag OxaO

/♦PROGRAM*/

//

unsigned cassette setupO
i
link_Jnterrupt<0x15,&_cassette_io); return(ok);

//

void interrupt cdecl far cassette_io(interrupt_registers>

enableO;
setds_system_segment( );

E-ll-2 The Cassette Driver

snapshot_i n( CASSETTE , &es ) ;

switch (ax » 8)
i

case OPEN DEVICE:

watch strTng(CASSETTE,"Open Device' 1 );

breakj

case CLOSE DEVICE:

watch string(CASSETTE, "Close Device");

breakj

case PROGRAM TERMINATE:

watch stringTCASSETTE, "Program Terminate");

breakj

case EVENT WAIT:

watch string(CASSETTE, "Event Wait");
if((RTC WAIT FLAG & 0x01) != 0)
< "

flags |= carry bit;
>

else
C

outportb(0xa1,inportb(0xa1) & Oxfe);

USER FLAG SEG = es;

USER~FLAG~= bx;

RTC UOW = ex;

RTC~HIGH = dx;

RTC~WAIT FLAG = 1;

// enable PIE in cmos chip

outcmos(0x0b,(incmos(0x0b) & 0x7f) | 0x40);

break;

case JOYSTICK SUPPORT:

watch string(CASSETTE, "Joystick");

breakj

case SYS REQ KEY:

watch stringTCASSETTE, "Sys Req Key");

breakj

case WAIT:

watch string(CASSETTE,"Wait"):

if((RTC_WAIT_FLAG & 0x01) != 0) flags |= carryjait;

else ~ ~

<

disableO:

outportb(oxa1,inportb(0xa1) & Oxfe);

USER FLAG SEG = ds:

USER~FLAG~a rtc wait flag;

RTC HIGH = ex; "

RTC~LOW = dx;

RTC~WAIT FLAG * 1;

// enable PIE in cmos chip

outcmos(0x0b, (incmos(OxOb) & 0x7f) | 0x40);

enable();

do i > while((RTC WAIT FLAG & 0x80) -* 0);
RTC WAIT FLAG a Oj

> "
break;

case MOVE BLOCK:

watch strTng(CASSETTE,"Move Block");

// format * virtual move(word count .global segment ,global_off set)

ax = virtual move(cx,es,si); ""

if (ax !* 0)~flags | a carry^bit;

break; ""

case GET EXTENDED MEMORY SIZE:

watch string(CASSrTTE,"Get Ext Mem Size");

ax s Tncmos(0x31);

ax ■ ax « 8;

ax |= i nemos (0x30);

break;

case SWITCH TO PROTECTED MODE:

watch string(CA"SSETTE, "Switch to Virtual");

// format = virtual mode( index, global segment, global_off set);

ax = virtual mode(bx,es,si);

break;

case DEVICE BUSY:

A-Tvpe BiosKit

The Cassette Driver E-ll-3

watch st ring (CASSETTE ."Device Busy");

flags~&= -0x0001;

break;

case INTERRUPT COMPLETE:

watch string<CA"SSETTE f "Interrupt Complete");

breakj

case RETURN SYSTEM CONFIG PARAMETERS:

watch string(CASSETTE,"Open Device");

es = Bios cs();

bx = &con?ig table;

flags &= -carry bit;

ax &= OxOOff;

break;

default:

watch string(CASSETTE "Default");

ax = Tax & OxOOff) j 6x8600;

flags |= carry bit;

break;
>
snapshot_out ( CASSETTE , &es ) ;

Section E: The C Programs

The Parallel Printer Driver E-12-1

TWELVE
The Parallel Printer Driver

The Parallel Printer Driver is an Interrupt (0x17) function call that is used to
communicate with the printer. A parallel printer is one which has a "Centronics"
interface and is referred to as LPT1, 2, or 3. The printer driver provides simple
commands to initialize the printer or send a character to the printer.

Although a hardware interrupt line (IRQ7) is normally assigned for the parallel
printer port, interrupt operation is not supported by the standard Bios driver. The
typical printer adapter has logic to support the use of the interrupt, but it is not clear
how the interrupt would be used if there is more than one printer port installed.
Some print spooling programs may possibly use the interrupt, but we are not aware
of it. There may also be logic in some printer adapters to disable the output data
latch, thereby allowing a bi-directional data capability. The control logic to use such
a feature is not a standard Bios function.

/********************************************************************************^^

*

* Copyright <c) FOSCO 1988, 1989 - All Rights Reserved

* Module Name: AT Bios LPT driver

* Version: 1.02

*

* Author: FOSCO

*

* Date: 2-25-89

* Filename: atlpt.c

*

* Language: MS C 5.1

*

* Functional Description:

*

* Int 0x17 - parallel printer driver

* Input:
*

* AH = print the character in AL

* on return, ah = 1 if character could not be printed

* (time out).

* Other bits set as on normal status call

*

* AH = 1 initialize the printer port

* returns with AH set with printer status
*

* AH = 2 read the printer status into (ah)
♦76543210

time out
unused
unused

1 = i/o error
1 = selected
1 = out of paper
1 = acknowledge
1 = not busy

+

+

+

............................

* OX = printer to be used (0,1,2)
*

*

* Arguments:

* Return:

*

* Version History:

* 1.01

* Chnaged the time out loop and pre-cleared (AH) to insure returning status was clean.

* 1.02

* Pre-cleared the port list before scanning to prevent phamtoms LPT's being assumed.

********************************************************************************

E-12-2 The Parallel Printer Driver

/♦INCLUDE FILES*/

#include ••atkit.h"

/♦FUNCTION PROTOTYPES*/

unsigned Ipt setup(void);

void scan Ipt (unsigned);

void interrupt cdecl far printer_io(interrupt_registers);

/♦GLOBAL VARIABLES*/

extern unsigned Ipt list [4];

extern unsigned char lpt_timeout_list[4];

/♦GLOBAL CONSTANTS*/

extern _printer_io;

/♦LOCAL DEFINITIONS*/

#define print the character
#define init The_port 1
#define reacTthe status 2
#define equipment 0x10

/♦PROGRAM*/

unsigned lpt_setup<)

unsigned i;

link interrupt(0x17,&_printer io);

for Ti=0;i<3;i++) poke40(&lpt~list[ij,0); // pre-clear the list
scan lpt(0x3bc);
scan"lpt(0x378);
scan~lpt(0x278);

for Ti=0:i<3;i++) pokeb40(&lpt timeout list [i], 0x14);
return(ok); ""

>

void scan_ Ipt (unsigned port)

unsigned i;

outportb( port , 0x55 ) ;

if (inportb(port) == 0x55)

EQUIP FLAG += 0x4000;

for (T = 0; ((i < 3) && (peek40(&lpt listen > != 0)); i++);

poke40(&lpt_list[i],port);

>

//=

void interrupt cdecl far printer io( interrupt registers)

unsigned port,i,j;

setds system segmentO;
snapsh"ot_i n(rPT , &es ) ;

if (dx <= 2) /* valid Ipt number ? */

port = peek40(&lpt listCdx]); /* get port number */
switch (ax » 8 ) T /* test for valid commands */

case print the character:

ax = ax & 0x007f;

watch string(LPT, H Print Char");

outportb (port, ax); /* output character to port */

// see if the printer is busy

for (j = (peekb40(&lpt_timeout_list[dx]) & Oxff); j > 0; j— )

for (i= 1000; i > ; i-- )
if ((inportb(port+1) & 0x80) !* 0) break; /* if not busy */

if ((inportb(port+1) & 0x80) != 0) break; /* if not busy */

if ((inportb(port+1) & 0x80) != 0) /* if not busy */

outportb (port+2, OxOd); /* set strobe high */
outportb (port+2, 0x0c); /* set strobe low */

A-Tvpe BiosKit

The Parallel Printer Driver E-12-3

ax = <(<inportb(port+1) & 0xf8) A 0x48) « 8) | (ax & Oxff);
else // port was busy, so device not available

ax = (<(ax | 0x0100 ) & Oxfvff) A 0x48); /* printer timed-out */
break;

case init the port:
ax * ax &"*0x0off;
watch_stn'ng(LPT,"Init Port");

outportb (port+2, 0x08); /* set init line low */

/* delay for reset to take place */
for (i=0; i <= 4000; i++ ) ;

outportb (port+2, 0x0c); /* set init line high */
goto read_status;

case read the status :
ax = ax STOxOUff;
watch_string(LPT,"Read Status");

pAflH StfltUS"

ax ="(<<inportb(port+1) & 0xf8) A 0x48) « 8) | ax;

>

snapshot out(LPT,&es);
>

Section E: The C Programs

The Coram Driver E-13-1

THIRTEEN
The Comm Driver

The Comm Driver is an Interrupt (0x14) Function Call that is used to communicate
with the serial port adapters.

Note - The most common problem involved with serial devices on the Com ports is

the incorrect use of the control signals, CTS, RTS, DTR, and DSR. If you

experience problems in communication, try jumpering CTS to RTS, and DSR to

DTR.

This may help to localize and correct the problem.

The extended function calls available on some PS/2 machines are not included in
this standard driver. These are relatively simple to add if you wish to enhance your
Com Driver.

Note - The standard serial port Bios driver does not support interrupt driven
operation. Most tele-communication software packages will replace the Bios driver
with their own driver.

*

* Copyright (c) FOSCO 1988, 1989 - All Rights Reserved

* Module Name: AT Bios com port driver
*

* Version: 1.02

*

* Author: FOSCO

*

* Date: 2-25-89

*

* Filename: atcomm.c

*

* Language: MS C 5.1

*

* Functional Description:

* Interrupt 0x14 -- Serial Port Driver

* Provides a function call for initializing, sending data, receiving data, and reading the status

* of an asynchronous adapter.

* Upon Entry:

*

* DX = Logical Async device # (0,1,2,3) for C0M1,2,3,4

* Initial

ize the

port:

* AH = OOh

* AL - initialization parameters

* Bit

Meaning

* Bits

7,6,5

*

110 Baud

*

1

150

*

1

300

*

1 1

600

*

1

1200

*

1 1

2400

*

1 1

4800

*

1 1 1

9600

* Bits

4,3

*

No parity

*

1

Odd parity

*

1

No parity

1 1

Even parity

Bit

E-13-2 The Comm Driver

* One stop bit

* 1 Two stop bits

*

* Bits 1,0

* 5 bits/char

* 16 bits/char

* 10 7 bits/char

* 118 bits/char

*

* Send a character:

* AH = 01h

* AL = the character to send

*

* Receive a character:

* AH = 02h

*

* Read the port status:

* AH = 03h

*

* Upon Exit:

*

* For 'Initialize the port' (AH=0):

* AH a Line status

* Bit Meaning if = 1

* ... ..............

* 7 Time out

* 6 Tx Empty (TEMT)

* 5 Tx Holding Register Empty (THRE)

* 4 Break Interrupt <BI)

* 3 Framing Error <FE)

* 2 Parity Error (PE)

* 1 Overrun Error (OE)

* Data Ready (DR)

* AL s Modem status

* Bit Meaning if = 1

* 7 Data Carrier Detect (DCD)

* 6 Ring Indicator (RI)

* 5 Data Set Ready (DSR)

* 4 Clear To Send (CTS)

* 3 Delta Data Carrier Detect (DDCD)

* 2 Trailing Edge Ring Indicator (TERI)

* 1 Delta Data Set Ready (DDSR)

* Delta Clear To Send (DCTS)

*

* For 'Send a character (AH = 1):

* AL = unchanged (character that was sent)

* AH s Completion code

* 1XXX XXXX - Time out, char not sent

* 0YYY YYYY - Tx Successful, Bits 6 - = Line status

* For 'Receive a character (AH =2):

* AL = The received char, if successful

* AH = Completion code

* 1XXX XXXX - Time out, no char received

* 000Y YYY0 - Data received, but error detected

* See Line status Bit Definitions

*

* For 'Get port status' (AH=3):

* AH = Line status (see above)

* AL = Modem status (see above)

*

* Global Variables:

* Async_adapter_port_list (word * 4):

* Word - adapter address of COM1

* Word 1 = adapter address of COM2

* Word 2 = adapter address of COM3

* Word 3 = adapter address of COM4
*

* These four words contain the hardware port addresses of the async adapters. Four async

* adapters can be supported although the operating system may only recognize COM 1,2.

* Async time out count (byte * 4):

* — — —

* Byte a time out count value for COM1

* Byte 1 « time out count value for COM2

* Byte 2 * time out count value for COM3

* Byte 3 a time out count value for COM4

* The time outs for no response use the contents of these cells for a count.

* Registers Modified:

* AX is modified

A-Tvpe BiosKit

The Comm Driver E-13-3

* Arguments:

*

* Return:

*

* Version History:

* 1.01

* Get divisor corrected by using a peek to reference the baud rate table

* " 1 .02

* Pre-cleared comm list before scanning to insure no phantoms present.

/♦INCLUDE FILES*/

#include "atkit.h"

/♦FUNCTION PROTOTYPES*/

unsigned comm setup(void);

void scan comm( unsigned);

void interrupt cdecl far comm_io<interrupt_registers);

/♦GLOBAL VARIABLES*/

extern unsigned comm list [4];

extern unsigned char~comm_timeout_list [4];

/♦GLOBAL CONSTANTS*/

const unsigned baud_table[8] ={1047, 768,384, 192, 96, 48,24, 12>;
extern _comm_io; ~

/♦LOCAL DEFINITIONS ♦/

/♦ 8250/16450 register offsets from base address ♦/

#define tx data reg 0x00
#define rx"~data~reg 0x00
#define div lsb~Yeg 0x00
#define div~msb~reg 0x01
#define int~enb~reg 0x01
#define int""id reg 0x02
#define line Ctrl reg 0x03
#define modem ctrT reg 0x04
#define line stat reg 0x05
#define modem_staf_reg 0x06

/♦ 8250/16450 register bit definitions ♦/

#define txrdy 0x60

#define rxrdy 0x01

#define dsr bit 0x20

#define dtr"bit 0x01

#define cts~bit 0x10

#define rts~bit 0x02

/♦ opcode definitions */

#define initialize 0x00
^define send character 0x01
#define rx cHaracter 0x02
#define read_status 0x03

#define equipment 0x10
#define timeout_bit 0x8000

/♦PROGRAM*/

// SCAN Com Ports -

// This routine is called to determine how many serial ports are in the system

unsigned comm_setup(void)

unsigned i;

link interrupt(0x14,& comm io);

for Ti=0;i<4;i++) poke40(&comm list[i],0); // insure list is clear before scanning
scan comm(0x3f8); ~

scan~comm( 0x2f 8 ) ;
scan~comm( 0x3e8 ) ;
scan~comm( 0x2e8) ;

for Ti=0;i<4;i++) pokeb40(&comm timeout list[i],0x01);
retum(ofc);
>

void scan_comm( unsigned port)

Section E: The C Programs

E-13-4 The Comm Driver

unsigned f;

outportb(port+3,0x55);

if (inportb(port+3) == 0x55)

EQUIP FLAG += 0x0200:

for (T = 0;((i < 4) && (peek40(&comm list[i]) != 0));i++);

poke40(&comm_l ist [i] ,port);

void interrupt cdecl far comm,jo( inter rupt_registers)

unsigned port address, divisor;
unsigned time~"out;
unsigned long"~timeout counter;
se tds_sys t em_segment < T;

snapshot_i n( COM , &es ) ;

if (dx > 3) /* check for DX out of range */
i

watch string(COM f M Bad Port");
>

else
C

/* get the time out parameter */

time_out = peekb40(&comm_timeout_list[dx]);

/* scale to use as a major loop counter */

time_out *= 10; /* figure 1 count = 500 millisec = 10 clock ticks

/* get the port address for the (DX) specified device */
port_address = peek40(&comm_list[dx]);

/* if no serial port for this logical device....*/
if (port address == 0)
i

/* return with a time-out error */
ax 1= timeout bit;
>

else
i

switch (ax » 8)
i

case initialize: /* INITIALIZE THE PORT */

ax &= OxOOff;

watch string(COM,"Init Port");

/* seT divisor latch enable */

outportb(port address+line ctrl_reg,0x80);

/* get the divisor */ ~ ~

divisor = peekcs(&baud table[(ax » 5) & 0x0007]);

/* load the baud rate 3i visor into the 8250 */

outportb(port address+div Isb reg, divisor);

outportWport^address+div'msb-reg, (divisor » 8));

/* set length7parity # stop~bits */

outportb(port address+line Ctrl reg, (ax & 0x1f));

/* set DTR ana RTS lines *7

outportb(port address+modem Ctrl reg, (0x08 | dtr bit | rts bit));

ax = inportb(port address+lTne sfat reg); "

ax = (ax « 8) | Tnportb(port address+modem stat reg);

break; ~

case send character: /* SEND A CHARACTER */
watch_strTng(C0M,"Send Char");

/* start with clean return status */
ax &- OxOOff;

/* set dtr and rts */

outportb(port address+modem Ctrl reg, inportb(port address+modem ctrl_reg) | dtr_bit | rts_bit);

/* check dsr and cts */

timeout_counter = set_timeout_count(time_out);

while(((inportb(port_address+modem_stat_reg) & (dsr_bit | cts_bit)) != (dsrjiit | cts_bit)))

if (TIMER LONG >* timeout counter) {ax |« timeout bit; break; >
>

if ((ax & OxffOO) == 0) /* OK - no timeout */
{

timeout_counter = set_timeout_count( time-out);

while((inportb(port_address+line_stat_reg) & txrdy) != txrdy)

A-TVpe BiosKit

The Comm Driver E-13-5

if (TIMERJ.ONG >= timeout_counter) <ax |= timeoutjait; break;}

if <(ax & OxffOO) == 0) /* OK - no timeout V
<

/* send the character */

outportbCport address+tx data reg.ax);

/* return the~status in A"H */~

ax = (ax & OxOOff) | (inportb(port_address+line_stat_reg) « 8);

>

break;

case rx character: /* RECEIVE A CHARACTER */
watch_string(COM,"Rx Char");

/* start with clean return status */
ax &= OxOOff;

/* set DTR out */

outportb(port_address+modem_ctrl_reg, inportb<port_address+modem_ctrl_reg) | dtr_bit);

/* check OSR */

timeout counter = set timeout count (time out):

whileUTinportWportJicldress+mVxiem^stat^reg) & dsr_bit) != dsr_bit))

if (TIMER_LONG >* timeout^counter) <ax |= timeout_bit; break;}

if ((ax & OxffOO) == 0) /* OK - no timeout */
i

/* check for data ready */

timeout counter = set timeout count (time out);

while((Tinportb(port_Iddress+Tine_stat_reg) & rxrdy) != rxrdy))

if (TIMER LONG >= timeout counter) <ax 1= timeout bit; break;}
}

if ((ax & OxffOO) == 0) /* OK - no timeout */
C

ax = ((inportb(port_address+line_stat_reg) & 0x1e) « 8) | inportb(port_address+rx_data_reg);

}

break;

case read status: /* READ THE STATUS */
watch_strTng(COM f "Read Status' 1 );

ax = inportb(port address+line stat reg);

ax * (ax « 8) | Tnportb(port address+modem_stat reg);

break; ""

default:

watch string(COM t "Bad Command 11 );

ax |=~timeout_bit;

}
}

}

snapshot out(COH,&es);
}

Section E: The C Programs

The Timer Interrupt E-14-1

FOURTEEN
The Timer Interrupt

The Timer Interrupt is called by the hardware real-time clock every 53 milliseconds
to increment the time count. This count is used by DOS to calculate the time of day.

Note - A user supplied routine may be linked to the timer interrupt routine, using
interrupt 1C. This user routine should be of minimal execution time, since other
interrupts are disabled while it is running. If it retains control too long, other
interrupts may be missed.

/***************************************************************************************************

* Copyright (c) FOSCO 1988, 1989 - All Rights Reserved

*

* Module Name: AT Bios real time clock service routine

*

* Version: 1.01

* Author: FOSCO

*

* Date: 10-20-89

*

* Filename: attmr.c

* Language: MS C 5.1

* Functional Description:

*

* Interrupt 0x08

* This routine services the real time clock interrupt.

* Arguments:

* Return:

*

* Version History:

* 1.01

* Replaced peeks and pokes with casts

***********************************************************************

/•INCLUDE FILES*/
#include "atkit.h"

/♦FUNCTION PROTOTYPES*/
void interrupt cdecl far timer_int(interrupt_registers);
/*GL0BALS*/
extern _timer_int;
/♦CONSTANTS*/
/♦DEFINES*/
/♦PROGRAM*/
unsigned timer_setup()
I ink_interrupt(0x08,&_timer_int); return(ok);

//=

void interrupt cdecl far timer_int(interrupt_registers)

/* increment timer count check for 24 hour value */

if(++TIMER_LONG >= TIMERJ.ONGJIAX) { TIMERJ.ONG = 0; TIMER_0FL = 1; >

if (--MOTOR COUNT == 0)

E-14-2 The Timer Interrupt

MOTOR STATUS &* OxfO; /* turn off motor running bits
outportb(0x3f2,0x0c); /* turn off any FD motors */

>

timer chainO;

eo i _sequence< ) ;

A-Tvpe BiosKit

The Time of Day Function E-15-1

FIFTEEN
The Time of Day Function

The Time of Day Function is used to read and set the timer counter, which is
incremented by the timer interrupt.

* Copyright (c) FOSCO 1988, 1989 - All Rights Reserved

* Module Name: AT Bios time of day function

* Version: 1.03

*

* Author: FOSCO

*

* Date: 10-20-89

*

* Filename: attod.c

*

* Language: MS C 5.1

* Functional Description:

* Interrupt OxlA - Time of Day function call -

* read/set the clock

*
*

* Interrupt 1AH - Time of Day function call

* read/set the internal clock or the 6818 clock chip

* AH » - read the clock.

* returns :

* CX s high word of count

* DX = low word of count

* AL = if no 24 hour rollover since last read
*

* AH = 1 - set the clock

* CX = high word of count

* DX = low word of count

*

* AH » 2 - read the time from the 6818 clock

* returns:

* CH = BCD hours

* CL = BCD minutes

* DH = BCD seconds

* CY flag if 6818 not running

*

* AH = 3 - set the time to the 6818 clock

* CH = BCD hours

* CL = BCD minutes

* DH a BCD seconds

* DL = 0/1 = normal/daylight time
*

* AH = 4 - read the date from the 6818 clock

* returns:

* CH = BCD century

* CL = BCD year

* DH = BCD month

* DL = BCD day

* CY flag if 6818 not running
*

* AH = 5 - set the date to the 6818 clock

* CH = BCD century

* CL = BCD year

* DH = BCD month

* DL = BCD day

* AH = 6 - set the 6818 alarm

* CH - BCD hours from set time

* CL * BCD minutes from set time

* DH s BCD seconds from set time

* returns:

* CY flag if alarm already set

* NOTE: function 6 is hooked through Int. 4ah, user replaceable.

*

* AH = 7 - reset the 6818 alarm off

E-15-2 The Time of Day Function

* Version History

* 1.01

* Added enableO; coining into ISR. Fixed Procomm Exiting hangup problem

* 1.02

* Changed outcmos(32... to out cmos( 0x32... for setting century byte

* 1.03

* Replaced peeks and pokes with casts

****************************************************************************

/♦INCLUDE FILES*/

#include "atkit.h"

/♦FUNCTION PROTOTYPES*/

unsigned time of day setupO;

void interrupt c3ecl""far time of day( interrupt registers);

unsigned update in_progress(void7;

unsigned initiaTize_status(void);

/♦GLOBALS*/

extern _time_of_day;

/♦LOCAL DEFINITIONS*/

(Wefine READ CURRENT CLOCK 0x00
^define SET CURRENT CLOCK 0x01
#define READ" RTC 0xU2
#define SET R"TC 0x03
#define READ" DATE 0x04
#define SET ffATE 0x05
ftdefine SET~ALARM 0x06
#define RESfT_ALARM 0x07

/♦PROGRAM*/

unsigned time of day setupO
i " " ~

link interrupt(0x1a,& time of day);

return(ok);
>

void interrupt cdecl far timej>f_day(interrupt_registers)

enableO;

setds system segment ();
snapshot in(T0D,&es);
switch(ax » 8)

<:

case READ CURRENT CLOCK:

watch strTng<TOD. n Read Current Clock");

ax = Tax & OxffOO) | TIMER OFL;

dx = TIMER LOW;

ex = TIMER~HIGH;

TIMER OFL * 0;

breakj

case SET CURRENT CLOCK:

watch string(TC©7 ,, Set Current Clock");

TIMER~LOW = dx;

TIMER~HIGH » ex;

TIMER"OFL = 0;

break;

case READ RTC:

watch strTng(TOD."Read Time");

flags""&= -carry bit;

if <update_injjirogress() == error)

flags |= carryjbit;

else
i

dx = incmos(O);

dx = dx « 8:

ex = incmos(4);

ex = (ex « 8) | incmos(2);

break;

case SET RTC:

watch string(TOD,"Set Time");

if (update_in_progress<) « error)

A-Tvpe BiosKit

The Time of Day Function E-15-3

<:

initialize statusO;
>

outcmos(0x00,dx » 8);
outcmos(0x02,cx);
outcmos(0x04,cx » 8):

outcmos(0x0b,(incmos(0x0b) & 0x30) | <dx & 0x0001) | 2);
break;

case READ DATE:

watch_strTng<TOO,"Read Date");
flags~&= -carry bit;
if (update_in_progress() == error)

flags |= carry_bit;

else
i

ex = i nemos (0x32);

ex = (ex « 8) | incmos(9);

dx = i nemos (8);

dx = (dx « 8) I incmos(7);
>
break;

case SET DATE:

watch_string(T00, H Set Date");

if (update_in_progress() == error)

initialize statusO;
>

outcmos(6,0):
outcmos(7,dx);
outcmos(8,dx » 8);
outcmos(9,cx);
outcmos(0x32,cx » 8):
outcmos(0x0b,(incmos(0x0b) & 0x7f));
break;

case SET ALARM:

watch string(TOD "Set Alarm");

flags""&= -carry bit:

if((incmos(0x0bT & 0x20) != 0)

i

ax a 0:

flags 1= carry bit;
>

else
i

if(update_inj3rogress() == error)

initialize statusO;

>

outcmos(1,dx » 8);

outcmos(3,cx);

outcmos(5.cx » 8);

outportb(uxa1,inportb(0xa1) | Oxfe):

outcmos(0x0b,(incmos(0x0b) & 0x7f) 1 0x20);
>
break;

case RESET ALARM:

watch st rir>g< TOO /'Reset Alarm"):

outcmos(0x0b # incmos(0x0b) & 0x57);

break;

default:

watch string(T00 ( "Bad Command");

flags'" |* carry bit;

break; ~

>

snapshot out(T0D,&es);
>

//

unsigned update in progress(void)

unsigned j;

for(j = 0; j < 600; j++)

if ((incmos(OxOa) & 0x80) == 0) return(ok);
>
return(error);

Section E: The C Programs

E-15-4 The Time of Day Function

unsigned initialize status(void)

outcmos(0x0a,26);
outcmos(0x0b,82);
i nemos (0x0c);
i nemos (OxOd);

A-Tvpe BiosKit

The Print Screen Function E-16-1

SIXTEEN
The Print Screen Function

The Print Screen Function is used to print the screen contents to LPT1.

Some additions and enhancements could be:

* Creating an "active_printer" flag (in system ram) which could be used to direct
screen prints to LPT2 or LPT3.

* Providing a screen print function to output on a serial channel.

* Using this module as a guideline for creating a print-screen to disk-file
applications program.

There are various public-domain print-screen functions which support video
adapters other than MDA and CGA. An EGA print-screen routine for instance, has
been circulated on various Bulletin Board Systems. The logic of one of these could
be adapted to replace the standard print screen function , if desired.

/***************************************************************************************************

*

* Copyright (c> FOSCO 1988, 1989 - All Rights Reserved

* Module Name: AT Bios print screen function

*

* Version: 1.01

*

* Author: FOSCO

*

* Date: 10-20-89

*

* Filename: atprsc.c
*

* Language: MSC 5.1

*

* Functional Description:
*

* Interrupt 0x05

* This module copies the contents of the screen buffer to the printer.

* Arguments:

* None

* Return:

* None

*

* Version History:

* 1.01

* replaced peeks and pokes with casts

**********************************************************************************

/* INCLUDE FILES*/

#include "atkit.h"

/♦FUNCTION PROTOTYPES*/

void interrupt cdecl far print screen( interrupt registers);
void print_screen_service(struct prscregs *); ~

/* G L B A L S */

extern _print_screen;

/♦PROGRAM*/

vo i d pr i nt_sc r een_setup< )

Iink_interrupt(0x05,&j3rint_screen);

variables

E-16-2 The Print Screen Function

unsigned columns_per line, old cursor, cur rent_cursor;
unsigned char row,coT,current~char;
end_var iables prscregs;

void interrupt cdecl far print_screen(interrupt_registers)

prscregs *myblock;

status byte */
i

PRSC BUSY ■ 1; /* set status = busy */
myblock->ax = OxOfOO;
sys int(0x10,myblock>;
/* get current screen mode */
myblock->columns_per_line s myblock->ax » 8;

myblock->ax * OxOOOd;
myblock->dx = 0;
sys int(0x17,myblock);
mybTock->ax = 0x000a;
myblock->dx = 0;
sys_int(0x17 # myolock);

myblock->ax = 0x0300;

sys int(0x10,myblock);

/* read and save old cursor position */

myblock->old cursor * myblock->dx;

myblock->roW~= myblock->col » 0;

for <myblock->row « 0;

(myblock->row < 25) & ! print error;
myblock->rovH-+) ~

<:

for (myblock->col = 0;

(myblock->col < myblock->columns_per line) & I print error;
myblock->col++)
i

// set cursor position
myblock->ax » 0x0200;

myblock->dx * (myblock->row «8) | myblock->col;
sys_jnt<0x10,myblock);

// read character at cursor
myblock->ax = 0x0800;
myblock*>bx * 0;
sys_int(0x10 f myolock);

// print character

myblock->current char » myblock->ax;

if (royblock->current char==0) myblock->current char = 0x20;

myblock->dx = 0;

myblock'>ax = myblock->current char & OxOOff;

sys int(0x17,myolock):

if(7.myblock->ax & 0x0100) != 0) print error = true;
>

// do the cr-lf at end of columns
myblock->ax = OxOOOd;
myblock->dx = 0:
sys int(0x17,myblock);
mybtock->ax = 0x000a;
myblock->dx * 0;
sys int(0x17,myblock);
if(T»nyblock->ax & 0x0100) 1= 0) print_error = true;

myblock->ax » 0x0200; // reset cursor to original position
myblock->dx * myblocfc->old_cursor;
sys int(0x10.myblock);

PRSC BUSY = 0; /* clear status * not busy */
>

A-Tvpe BiosKit

The Vue File E-17-1

SEVENTEEN
The Vue File

The Vue.c file is the source code for SysVue, the resident monitor/debugger
program. SysVue allows the user to gain access to the system features from any
program. If the bootstrap operation is unsuccessful, program control is automatically
transferred to SysVue.

SysVue has some Watch features built-in to assist in development/debugging. The
"select" command is used to set and clear specific bits in the watch_selection
variable. These bits are checked when "watch" is "on" and display commands
imbedded in the various function routines are enabled. These display commands
are:

"watch_string(device,"string") ;

"watch_word(device,word_value) ;

"watch_byte(device,byte__value) ;

These watch commands check to see if the corresponding "device" bit is set in the
watch_flag variable. If so, the command is executed. When developing and
debugging code, this feature is extremely handy. For a final version, one may wish to
delete the "watch_xxxx()" calls to save space and increase speed.

The SysVue "SF command is used to display pertinent data about the Bios and the
system. It is especially handy for tech support communications, allowing the user to
use the "SF command to display and convey commonly requested information to the
technically oriented person. Since it also shows configuration information, it permits
a quick peek at the current system configuration.

The system Setup is accomplished by the use of the:
"Time" and "Date" commands to set the clock\calendar
"Drive" to set the number and type of floppy and hard drives
"Video" to set the type of video adapter
"Mem" to set the size of system and extended memory
"Npx" to declare the presence of the numeric processor
"Types" to display the hard disk types in the resident type table
"Cmos" to display the checksum value of the CMOS RAM

The redirection command ">","> con"," >lpt" are used to copy the screen output to a
printing device. This allows generating audit trails when involved in debugging, and
with "watch" enabled, can provide a wealth of data concerning internal Bios
operation. Since one can re-compile the Bios with additional "watch_xxx()"
commands, debugging aids can easily be placed where desired.

The "Trace" and "e" (for execute) commands allow a detailed single-step trail to be
generated when required. Once a problem area is located with "watch" features, this
single stepping can provide lowest level tracing of system action. Single stepping
does NOT sense when the stack-segment or stack-pointers are changed, so
unpredictable results may occur when these registers are changed.

E-17-2 The Vue File

The "Int" command allows the execution of an interrupt, using the register values set
with the "Rxx" commands. This permits specialized execution of bios functions from
within sysvue. With the watch function enabled, this is a handy debugging aid.

SysVue may also be expanded with new commands as desired.

An easy way for you to generate documentation of your version of SysVue is to use
the " > LPT" command to provide hard copy of the various screens and menus. These
printouts may then be integrated into the user documentation you create.

* Copyright (c) FOSCO 1988 - All Rights Reserved

* Module Name: AT Bios SysVue

* Version: 1.00

* Author: FOSCO

*

* Date: 12-01-88

*

* Filename: atvue.c

*

* Functional Description:

* This is the SysVue module which is a Bios-resident debug/monitor program.

* NOTE:

* Entry to SysVue is by CTRL -ALT -BREAK.

*

* Arguments:

* Return:

*

* Version History:

/♦INCLUDE FILES*/

#include "atkit.h"

/♦FUNCTION PROTOTYPES*/

unsigned sysvue setupO;

void interrupt cdecl far sysvue(void);

void interrupt cdecl far sysbreak(void);

char ci(void);

void co(char);

unsigned ishex(char);

unsigned islower(char);

unsigned isalpha(char);

unsigned isdelim(char);

void I word( unsigned);

void pword( unsigned);

void Ibyte(char);

void pbyte(char);

char get byte(void);

unsignecTget word(void);

void poked(unsigned, unsigned long int);

void set system segment (void);

void syntax error(void);

void write string( unsigned);

unsigned get token(void);

unsigned get~token number (unsigned *);

void find next lis? item(void);

void get Tine TnputTchar): /* arg is line terminator char */

unsignecTget Token valueO;

unsigned long get TimitsO;

void set vector(cFar, unsigned, unsigned);

unsignecTlong get vector(char);

unsigned console J5reak( void);

void far call (unsigned, unsigned);

uns i gnecTva I ue_present ( char ) ;

void display regs( unsigned);

void display^ lags (unsigned);

/♦GLOBAL VARIABLES*/

A-Tvpe BiosKit

The Vue File E« 17-3

external data (variables) declarations

extern reset;

extern unsigned comm list C] ;

extern unsigned lpt_Tist[];

/* variables are in system scratch segment of RAM */

extern char sysvue busy; /* 0/1 = not busy/busy */

extern unsigned long break chain;

extern unsigned long trace'chain;

extern unsigned long trap chain;

extern char mode_type,mode size, sum, char count;

extern char exit flag;

extern char buffer [80];

extern unsigned buffer index, token index;

extern list index, token number; ~

extern unsigned commancTindex:

extern unsigned token_valueC8];

extern unsigned cc;

extern char present;

extern unsigned last dump start seg;

extern unsigned last~dump~start~off;

extern unsigned enter seg7enter"~off;

extern char inchar; ~ ""

extern unsigned int seg,int off;

extern unsigned reg~index;

extern unsigned reg~saves[15l:

extern unsigned inreg saves [15];

extern unsigned out r eg saves [15] ;

extern unsigned trace_count;

extern char break flag;

extern char token~buf f er [] ;

extern char last cielim;

extern char record_type:

extern unsigned watch flag;

extern unsigned watch~se lection;

extern unsigned u found;

extern unsigned jj;

extern unsigned redirect flag;

extern char dec_array[6]J

/♦GLOBAL CONSTANTS*/

/* external data (constants) declarations *

/* constants are in Bios ROM */

extern bios id;
extern ver Td;
extern bios name;
extern owner_id;
extern date_stamp;

/♦LOCAL DEFINITIONS*/

#define byte 1
#define word 2
#define dword 4

#define ascii 1
#define hex 2

#define datajrecord
#define end of file record 1
#define extended address record 2
#define start_ad3ress_record 3

/* this are the delimiters for bios vue command strings */

#define space 32
#define comma 44
#define colon 58
#define semicolon 59
#define leftparen 40
#define rightparen 41
#define period 46
#define ques 63
#define tab 9
#define quote 34
#define slash 47

enumeration lists

/* This list MUST be in the same order as the command token list.

** The enumerated values for the commands are assigned by this list.

** These values are used by the case operator in the main body of SysVue.

Section E: The C Programs

E-17-4 The Vue File

** For each entry in this list, there must be a corresponding entry in the Command Token List.
** The token list is searched and the number of the find is used as the command switch value.
*/

enum command
C

command NUl, /* Nul value = no find */

commancTC, /* compare */

commancTcA, /* compare ascii */

commancTCB, /* compare byte */

commancTCW, /* compare word */

command~CD, /* compare double */

commancTCHK, /* checksum */

command~CLS. /* clear screen */

commancTCOLD BOOT, /* cold boot */

commancTCMOST /* display cmos contents and checksum */

commancTbATE, /* set date */

commancTD. /* dump */

commancTDA, /* dump ascii */

commancTDB, /* dump byte */

commancTDW, /* dump word */

commancTDD, /* dump double word */

commancfbRIVE, /* set number and type of drives */

commancTE. /* enter or execute */

commancTEA, /* enter ascii */

commancTEB, /* enter byte */

commancTEW, /* enter word */

commancTED, /* enter double */

commancTEXlT, /* exit from SysVue */

command~F £ /* fill */

commancTFA, /* fill ascii */

commaneTFB, /* fill byte */

commancTFU, /* fill word */

command~FD, /* fill double */

commancTH, /* hex add and subtract */

commancTHARD BOOT, /* hard boot */

command~HELP7

commancTl, /* input port */

commancTlB, /* input byte */

commancTlW, /* input word */

commancTlNt, /* interrupt */

commancTM, /* move */

command~MEM, /* set/display mem sizes */

commancTNPX, /* select NPX present or not */

commancTO, /* output port */

commancTOB, /* output byte */

commancTOU, /* output word */

commancTQUIT, /* exit from SysVue */

commancTR. /* display registers */

command~RAX, /* register ax */

commancTRBX, /* register bx */

commancTRCX, /* register ex */

commancTROX, /* register dx */

commancTRSP, /* register sp */

commancTRBP, /* register bp */

commancTRSI, /* register si */

commancTRDI, /* register di */

commancTRDS, /* register ds */

command~RES, /* register es */

command~RSS, /* register ss */

commancTRCS, /* register cs */

commancTRIP, /* register ip */

command~RF, /* register flags */

commancTRHEX, /* read Intel hex */

commancTSI, /* display info */

commancTSELECT, /* select watch parameters */

command's, /* search */

commancTSA, /* search ascii */

commancTSB, /* search byte */

commancTSW, /* search word */

commancTSO, /* search double */

commancTTIME, /* set time */

commancTT, /* single step */

commancTTRACE, /* single step */

commaneTTYPES, /* list hard drive types on table */

commancTviOEO, /* set/display video adapters */

commarxTWATCH, /* watch bios */

commancTWARM BOOT, /* warm boot */

commancTWHEXT /* write Intel hex */

command~TO LPT, /* direct output to Ipt */

commancTTO~COM, /* direct output to console */

commandrBACK_TO__CON, /* default back to console */

/* this enumeration list is used for the register
** display commands.

A-Tvpe BiosKit

The Vue File E-17-5

enun order
i

nulreg,

axsave , bxsave , cxsave , dxsave , spsave ,

bpsave , s i save , d i save , dssave , essave ,

sssave,cssave, ipsave,pswsave,
■»»

/"LOCAL CONSTANTS*/

// this is a list of the command tokens for bios vue, it MUST agree with the enumeration list

const command token listtl 3
i "

C", /* compare */
CA", /* compare ascii */
CB", /* compare byte */
CU", /* compare word */
CD", /* compare double */
CMC", /* checksum */
CLS", /* clear screen */
•COLD", /* cold boot */

■CMOS", /* display cmos contnets and checksum */
•DATE", /* set date */
"D», /* dump */
"DA", /* dump ascii */
/* dump byte */
/* dump word */
/* dump double */

" /* display or set drives */
/* enter */

08",

DU",

DD",

DRIVE

E",

EA", /* enter ascii */

EB", /* enter byte */

EW", /* enter word */

ED" /* enter double */

EXIT", /* exit from SysVue */

"" /* fill */

F",

FA",

FB",

FW", /* fill word */

FD", /* fill double */

H" /* hex add and subtract */

HARD", /* hard boot */

HELP", /* display help */

I", /* input port */

IB", /* input byte */

IW", /* input word */

INT", /* interrupt */

M", /* move */

MEM", /* set/display meory sizes */

NPX", /* select NPX present or not */

•0", /* output port */

OB", /* output byte */

OW" /* output word */

QUIT", /* exit form SysVue */

R M , /* display registers */

/* fill ascii */
/* fill byte */

I*

I*

RAX"

RBX"

RCX"

RDX"

RSP"

RBP"

RSI"

RDI"

RDS"

RES"

RSS"

RCS"

RIP"

RF",

RHEX

SI",

SELECT

S», /

SA",

SB",

SW",

SD",

TIME",

T»,

TRACE",

TYPES",

VIDEO",

WATCH",

V
V
V

*/
*/

V
V
V
V
7

/* register ax */

/* register bx */

/* register ex

/* register dx

/* register sp

/* register bj?

/* register si

/* register di

/* register ds

/* register es

/* register ss

/* register cs

/* register ip
/* register flags */
, /* read Intel hex */
/* display id */

/* select watch parameters */
* search */
/* search ascii */
/* search byte */
/* search word */
/* search double */

/* set time */

/* list hard drive types on table */
/* set/display video adpaters */
/* watch bios */

Section E: The C Programs

E-17-6 The Vue File

"WARM", /* warm boot */

"UHEX", /* write Intel hex */

">LPT",

">CON",
••>■•

8-1) /* list terminator */

>;

// the register token list is searched to determine the switch value for the register commands.

const register token list[] =
C
"AX", "BX", "CX", "DX", "SP", "BP", "SI ", "01 ", "DS", "ES", "SS", »CS", "IP", - 1 ,

>;

// the flag token list is used for the flag register command

const flag token list[]=
<. "

"NC" "CY" "--" •»--•• »pQii iipgn 11.. 11 11. .ii "na" ••AC" "--" "--'• "NZ" "ZR" "--" "--"

"PL"' "NG"' "01 "' "EI " ' "UP"' "DM"' "NV" ' "OV" ' " •• ' •• <• ' i* it' •• — ti ' •■ — •*' •• ■■ u..ii'ii..u'.j

> ................

// the flag display token list is used for the flag register command

const flag display token list[16][2]=

i "

••NC" "CY" ••--•■ »--•• «ipo M "PE" "--" ••••■• "NA" "AC" "--" ••--'* "NZ" "ZR" "--" ••--••

■«PI_m ' *t|^Q*t ' *tQ I ** * >*E I " ' "UP" "DN" "NV" "OV" "--" ••--'• ••--'• 11. .■• 11. .11 M..11 11. .11 11. .ii
y ...............

// This is a list of the delimiter characters to be accepted when parsing command lines.
// A zero value marks the end of the list.

const char delim_list[] =

space, comma, colon, semicolon, leftparen, rightparen, period, ques,tab,quote,slash,0
>;

/♦PROGRAM*/

/*========= sysvue Setup Routine ss==s====a*/

// This routine is called by the POO to effect the installation of SysVue by patching Interrupt 18.

unsigned sysvue setupO
i

link interrupt(0x18, sysvue);

return(ok);
>

/*======= SysVue Main Routine ==================*/

/*==============================================*/

variables
end_variables vueregs;

// these are arbitrary identifiers so the main routine will know how it was entered

#def ine trap origin 5
#define trace origin 6
#def ine boot origin 7
#define divi3e_origin 8
#define syserr~origin 9

void sysmainO;

void interrupt cdecl far Divide(interrupt_registers)

sysmain(divide origin);
>

void interrupt cdecl far SysError(interrupt_registers)

sysmain(syserr origin);
>

void interrupt cdecl far Sysvue( interrupt registers)
i
sysma i n( boot_or i g i n) ;

A-Tvpe BiosKit

The Vue File E-17-7

void interrupt cdecl far Systrap< interrupt registers)

sysmain(trap origin);
>

void interrupt cdecl far Systrace( interrupt registers)
C

sysmain( trace origin);
>

void sysmain( unsigned origin, interrupt registers)
C

vueregs *myblock;

enableO;

myblock = acquire block(VUE);

/* variables will~be referenced in sys seg */

exit_flag = 0;

if((origin == boot origin) && (sys vue busy != 0))
C

write string("\n\rSysVue Busy");
>

else
i

sysvue_busy*1;

// chain the break vector through sysvue logic: if the break flag is set by the sysbreak isr,
// return a true from the csts routine to abort the op in progress, when exiting sysvue:
// de-chain the vector back to the original state for normal operation.

break chain » get vector(Oxlb);
I i nkJTnterrupt (OxTb, sysbreak) ;

// move the stacked registers into the saves so we know where we came from

reg saves [axsave] » ax;

reg~saves [bxsave] = bx;

reg~saves [cxsave] = ex;

reg~saves [dxsave] = dx;

reg~saves[sisave] = si;

reg~saves[disave] = di;

reg~saves [essave] - es;

reg~saves [dssave] = ds;

reg'saves [spsave] » sp;

reg~saves [sssave] 3 get ss();

reg~saves Cpswsave] = fllgs;

reg~saves[ipsave] » ip;

reg'saves Ccssave] = cs;

if (origin == trace origin) // de- chain trace vector
i
set_vector(0x1,trace_chain » 16 # trace_chain);

// if(peek(0x26a, 0x316) == OxObeb)

II place for option of silent trace until condition
// trace_count =1;

display regs(&reg_saves);

write s7ring( M \n\r ");

lwordTcs);write string( M : M );lword(ip);write stringC ");

lbyte(peekb(cs f Tp)); ~

write stringC "):

I wordTpeek( cs , i p+ 1 ) ) ;

//>

if (--trace count !* 0)
<
if (console breakO)
<.

exit flag=0;
trace count=1;
>

else
<

// check for any key
if (kbhitO)
C

exit flag=0;
trace count=1;
>
else

Section E: The C Programs

E-17-8 The Vue File

exit flag=1;

reg saves [pswsave] |= 0x0100; // set trace bit
// chain- in the trace vector
trace chain = get vector(Oxl);
I i nk Interrupt (OxT, Systrace) ;
>
>
}

f(origin == trap_origin) // de-chain trap vector

// restore the trapped locations and decrement the pc value
// clear the trap saves and stuff

f(origin == boot_origin)

trace count =1;

// restore the trapped locations and decrement the

// pc value

// clear the trap saves and stuff

mode size = byte; /* default to byte presentation mode */
mode~type = hex; /* default to hex (not ascii) */
'f (origin =» boot_origin)

write_string("\n\rSysvue Copyright (c) FOSCO 1988, 1989 - All Rights Reserved.");

f(origin « divide_origin)

write string( M \n\rOivide Overflow at location - ");
IwordTcs); write_string( ,, : ,, );lword(ip);

f(origin ■« syserr_origin)

write_string("\n\rSystem Error, Type - "); Iword(ax);

while (exit flag ==0)

i

write string( M \n\rSysVue>");
get_llne_input(cr);

/* move past leading spaces */
while(buffer[buffer_index] »» ' ') buffer_index++;

if(get token() == true) /* if there is a command */
i

/* get the token number for the

** command from the token list

*/

command_index = get_token_number(&command_ > token_list);

/* get the rest of the arguments on the command line */
get_values();

/* execute the command */
switch (command index)
C

default: /* command not found */

syntax error ();

break; -

/*============ COMPARE COMMAND *«=*=«*/

case command CA:

mode_type - ascii; mode_size * byte; goto compare_case;

case command CB:

mode^type = Hex; mode_size = byte; goto compare^case;

case command CW:

mode^type = Hex; mode_size » word; goto compare_case;

case command CO:

mode_type = Rex; mode_size * dword; goto compare_case;

case command C:

A-Tvpe BiosKSt

The Vue File E-17-9

compare case:
do

if (peekb( token value CO], token valued]) != peekb( token value [4], token value [5]))
i

co<13); co(10);

Iwordctoken value CO]); co(':');

lword(token~valueM] );

coC '); coT'>'); co(' ');

lbyte(peekb(token value CO], token valued]));

coc' ')• co(' ')•" ~

lbyte(peekb(token value [4], token valueC5]));

coC '); co('<');~co(' ');

lword(token value [4]); co(':');

lword(token~valueC5] );
>

if (console breakO) break;
token valued]**; token value[5]++;
>

while ((token valued] < token valueC3]) &&
(token_valueCT] != 0));

break;

/*======= clear Screen Command **=========*/

case command CLS:

// read current video mode

myblock->ax = OxOfOO;

sys int(0x10,myblock);

// reset video mode (clears screen)

myblock->ax = myblock->ax & OxOOff;

sys int(0x10 # myblock);

break;

/*=========== CMOS Command ================*/

case command_CMOS:

// this would be a great place to have a dump of the CMOS contents.

write stringC'Calculated CMOS checksum: ");
token~valueC1] = 0;

for(token valueCO] = 0x10; token valueCO] < 0x2e;
token valueC0]++>
i
token valued] += incmos(token valueCO]);
>
lword(token_valueC1] );

write string( M \n\r Actual CMOS checksum: ");
lwordT(incmos(0x2e)« 8) | i nemos (0x2f));

break;

/*============ d Commands =================*/

case command DA:

models ize = byte; mode_type s ascii; goto dump_case;

case command OB:

mode_size = byte; mode_type = hex; goto dump_case;

case command DW:

mode_size = word; mode_type = hex; goto dump_case;

case command 0D:

mode_size = 3word; mode_type = hex; goto dump_case;

case command D:
dump_case: ~

cc = 256; /* default dump length in characters */
if (mode_type == ascii) cc = 1024;

if ((present & 0x80) == 0)

token valued] = last dump start off + cc;
token~valueC0] * last~dump~start~seg;
>

if (token value [3] == 0)
C
token value [33 = token valued] + cc;
>
last_dump_start_seg = token_valueC0];

Section E: The C Programs

E-17-10 The Vue File

last_dump_start_off = token_valueC1];

do
i

co(cp); co(lf); lword(token value [0]);

co(':');lword(token_valuedT); co( / ');

if (mode type == ascii)

<:

do
<

cc = peekb( token value CO] .token value[1]++) & 0x7f;

if <<cc < 0x20) T| (cc > 0x7e))~cc = '.';

co(cc);
>

while ((token valued] X 64) !» 0);
>

if ( (mode_type == hex) || (mode_type ==0))

if ((mode size == byte) II (mode size == 0))
C

do
i

coC ');

lbyte(peekb(token value[0],token valueC1]++));

/* print extra space every four characters */

if ((token valued] X 4) == 0) co(' ');
>
while ((token_valued] X 16) != 0);

if (mode size == word)
C

do
<

coC ');

lword(peek(token value CO], token valued]));
token valued] += 2;
if ((Ttoken_valuedl & Oxfffe) X 4) »* 0) coC ');

while (((token valued] & Oxfffe) X 16) !* 0);
>

if (mode size == dword)

do
<

co(' ');

lword(peek(token value CO], token valueC1]+2));

co(':');

I word( peek (token value[0],token valued]));

token valued] +« 4; ~

if ((Ttoken_valueC1] & Oxfffe) X 4) « 0) coC ');

while (((token valued] & Oxfffe) X 16) != 0);
>

/* print the ascii char for the hex dump */

co(' ');

token valued] -= 16;

do ~

<

cc = peekb(token value CO] .token valued]++) & 0x7f;

if ((cc < 0x20) JJ (cc > 0x7e))~cc = '.';

co(cc);

while ((token valued] X 16) != 0);
>
if (console_break()) break;

while ((token valued] < token value [3]) && (token valued] I s 0));
break; ~ ~ ~

/*=========== Exit Commands sssssssssks*/

case command EXIT:
case commancTQUIT:
exit flag=1;~
breafc";

/*:s:sshs:ss Enter Commands ======»=====*/

case command EA:

mode_size = Byte; mode_type = ascii; goto enter_case;

A-TVpe BiosKit

The Vue File E- 17-11

case command EB:

mode_size * Byte; mode_type = hex; goto enter_case;

case command EU:

models ize = word; mode_type = hex; goto enter_case;

case command ED:

mode_size = 3word; mode_type = hex; goto enter_case;

case command_E:

// if e<enter> then it is execute else it is enter

if (value_present(1) == 0) // e<enter> is execute

exit flag=1;

trace count * -1;

reg saves [pswsave] |= 0x0100; // set trace bit

// chain- in the trace vector

trace chain = get vector(Oxl);

link Interrupt (0xT,Syst race);

brealc;

>

enter_case:

/* if there is a command line input, just store it */
if(value_present(3) == true)

if (mode size == byte) pokeb< token value [0], token value[1], token value[3]);
if(mode~size == word) poke( token value[0],token valued], token value [3]);
if (mode's ize == dword) - - -

<

poke( token value[0],token valued], token value[3]);

poke<token~value[0],token3value[1]+2,token_value[2j);

>

else
i
lword(token_value[0] ); co(':'); lword(token_ > value[1]);

/* solicit input */

enter sea = token value [0];
enter'off = token~value[1l;

inchar = ' ';

while (inchar == ' ')

i

co(' ');

if (mode size==byte) lbyte(peekb(enter seg, enter off));

if (mode's ize==word) tword(peek( enter seg, enter off));

if(mode~size==dword) ~ ~

<
lword(peek(enter seg, enter off+2));
co(':'>;
lword(peek(enter seg, enter off));

> "

co< '-'■>;

get line inputC ');

/* Terminate this on a space or a cr */

get valuesO;

l f (value_present(1 ))

if (mode size—byte) pokeb( enter seg, enter off, token valued]);
if(mode"size==word) poke( enter seg, enter off, token valued]);
if (mode's ize==dword) ~

<

poke(enter_seg,enter_off, token valued] );

poke( enter'seg , enter'of f +2 , tokin_va I ue [0] ) ;

>

enter off = enter off + mode size;
if ((Inter off X 5) == 0) "
I

co(cr); co(lf);

lword(enter seg); co( / :'); lword(enter off);
>
>
>
break;

/*========== pill Commands ============*/

Section E: The C Programs

E- 17-12 The Vue File

case command FB:

mode_size = Byte; mode_type * hex; goto fill_case;

case command FW:

mode_size = word; mode_type = hex; goto fill_case;

case command FD:

models ize = 3word; mode_type = hex; goto fill_case;

case command F:
fill case: ~

do ~

<:

if (mode size == byte) pokeb( token value[0],token valued], token value[5]>;

if(mode""size == word) poke(token_value[0], token J7alue[1],token_value[5]);

if (mode's ize == dword) - - -

C

poke( token value CO], token valued], token value 15]);
poke(token~value[0],token~value[1]+2, token value [4]);

>

if (console breakO) break;

token valued] +« mode size;
> ~ .

while ((token valued] < token valuet3]) &&
(token value [T] != 0));
break;""

/*======= int Command ==»==============*/

// This command invokes the interrupt selected. It uses the sys int registers and the
// sys_int command. The user has to confirm the command with an""X to execute it.

// this command should use a separate set of registers ????

case command_INT:

/* get the interrupt number from the command line */

/* print the vector value */

if (token valued] < 256)

write_string("Interrupt is at ");

int off = peek(0x00, token valued] * 4):
int~seg * peek(0x00,(token_value[1] * 4) +2);

lword(int_seg); co(':'); lword(int_off); co(' ');

write_string("Press X to confirm execution");

/* wait for confirmation */
cc = ci();

if ((cc « 'X') II (cc == 'x'))
i

write string("\n\r"); // do a cr If for a clean line

myblock ->ax = reg saves [axsave] ;

myblock ->bx = reg~saves [bxsave] ;

myblock ->cx = reg""saves [cxsave] ;

myblock ->dx - reg""saves [dxsave] ;

myblock ->si = reg~saves[sisave];

myblock ->di ■ reg~saves[disave];

myblock ->ds = reg~saves [dssave] ;

myblock ->es = reg~saves [essave] ;

sys_int(token_value[1], myblock);

out reg saves [axsave] = myblock ->ax;

out reg~saves [bxsave] » myblock ->bx;

out reg'saves [cxsave] * myblock ->cx;

out reg~saves [dxsave] « myblock ->dx;

outreg~saves[sisave] = myblock ->si;

out reg"*saves[di save] = myblock ->di;

out reg'saves [essave] « myblock ->es;

out reg~saves [dssave] = myblock ->ds:
outreg~saves[pswsave] - myblock ->flags;

/* display the register upon return */

display regs(&outreg saves);
>
>
else write_string( ,, Value Out of Range ••);

break;

A-Tvpe BiosKit

The Vue File E- 17-13

/*============= HELP =============*/

case command HELP:

write s
writers
write s
writers
write~s
write~s
write~s
write~s
write~s
write~s
write~s
writers
write~s
writers
writers
writers
wn"te~s
write~s
write~s
pause?)
write s
write~s
write~s
writers
write~s
write~s
write~s
writers
write~s
writers
write~s
writers
write~s
write~s
write~s
write~s

ring?
ring(
ring<
ring(
ring(
ring(
ring(
ring(
ring(
ring<
ring(
ring<
ring<
ring(
ring<
ring<
ring(
ring<
ring<

ring<
ring(
ring<
ring<
ring<
ring(
ring<
ring(
ring(
ring<
ring(
ring(
ring<
ring<
ring<
ring<

C <range> <address> - compare\n\r H );

CLS - Clear Screen\n\r M );

CHK <range> - checksum\n\r H ):

COLD - cold boot to cuurent Bios\n\r M );

CMOS - display the CMOS checksun\n\r");

DCtype] [<range>] - dump memory\n\r");

DRIVE [0-3 I A:-F:][type] - display/set drives\n\r H );

DATE [xx/xx/xxxx] - Display or Set Date\n\r H );

E - execute single step until any key hit\n\r M );

ECtype] <address> [<list>] - enter\n\r");

EXIT - exit from SysVue\n\r M );

FCtype] <range> <list> - fill \n\r M > ;

H <value> <value> - hex add/sub\n\r");

HARD - re- boot to primary Bios\n\r M );

HELP - help screen\n\r M );

I [type] <address> - In port\n\r M );

IMT <value> - Interrupt\n\r");

M <range> <address> - move\n\r M );

MEM [sys,ext] - display/ set memory sizes\n\r");

NPX [011] - No NPX/Yes MPX\n\r H );
0[type] <address> <value> - Out port\n\r");
•QUIT - exit from SysVue\n\r M );
R[<reg>] <value> - register\n\r");
RHEX <range> - read Intel hex\n\r M );
S[type] <range> <key> <mask> - search\n\r");
SELECT - Select Watch Parameters\n\r M );
SI - Display System Information\n\r M );
TIME [xx : xx : xx] - Display or Set Time\n\r");
TRACE [count] - Trace count steps or until anykey hit\n\r H );
TYPES - Display hard disk type parameters\n\r">;
•VIDEO [type] - display/set video type\n\r");
WARM - warm boot to current Bios\n\r">;
WATCH - Toggle watch on/off\n\r M );
WHEX <range> - write Intel hex\n\r");
•>[CON | LPT] - redirect console output \n\r H );

break;

/*========== Calculator Command =========*/

case command H:

write stringT"Sum is: ••); lword(token value[1]+token value [3]);

write^string( M Difference is: "); lword(token_valueI1]-token value [3]);

breakj

/*===== sys Info Command ===========*/

case command_SI:

write string<"\n\r Current Time: ••); display time();
write~string<"\n\r Current Date: ");display_3ate();

write_string( H \n\r Bios Name: "); write_string(&bios_id);

write_string("\n\r Bios Version: "); write_string(&ver_id);

write^stringC^'XnVr Bios Date: •'); write_string(&date_stamp);

write^stringCXnXr Copyright: "); write_string(&owner_id);

write_string( H \n\r Bios Size: 64k At Segment: •'); lword<bios_cs<));

write string( H \n\r CPU: ");

// a cpu type sensing routine could be added here

write string( ,, 80286");

write~string("\n\r NPX: "); display_npx();

write string( M \n\r Com Ports: ");

for (cc = 0:

<(cc < 4) && <peek40<&comm - list[cc]) != 0));cc++)

lword(peek40(&comm_list[cc])); co(' ');

write_string("\n\r LPT Ports: ");

for (cc = 0:

(<cc < 3) && <peek40<&lpt_list[cc]) != 0));cc++)

lword(peek40(&lpt list[cc])); co(' ');
>

// display the disk drives in the system

Section E: The C Programs

E-17-14 The Vue File

display_drives();
display_video();

write string("\n\rMemory Size System Extended");

write~string( H \n\r Expected: '•);

displly sys mem();

write s¥nng( M ■•);

display ext mem();

write sTring("\n\r Found: ••);

bin2dec(peek40(0x13) + (sys seg size/ 1024), idee array);

co(dec array [0]); ~

co(dec*"arraydi);

co(dec~array[2]);

co(dec~array[33);

co(dec~array[4]);

write stringC 1 "):

bin2dec(cmos ext found(),&dec array);

co(dec arrayT0])J ~

co<dec~array[13);

co(dec""array[23);

co(dec~array[33);

co(dec~array[4]);

#if(0«1>

write stringC^VArCMOS Values are:");
write~string("\n\rOi agnostic "); lbyte(incmos(0x0e));
write"string( M \n\rRestart ,, );lbyte(incmos(0x0f));

write~string( H \n\rFloppy Disks ");lbyte(incmos(0x10));
write~string( M \n\rHard Disks ");lbyte(incmos(0x12));
write'stringO'VArEquipment ");lbyte(incmos(0x14));
#endiT

break;

/* set time V

case command TIME:

if(value_present(0)) // if anything entered

myblock->cx ■ token_value[0];

myblock->cx » (myblock->cx « 8) | token valued];

myblock->dx » token valueC3];

myblock->dx = myblock->dx « 8;

myblock->ax * 0x0300;

sys int(0x1a,myblock);

if(Tmyblock->flags & carry bit) != 0)

write_string("Error setting time");

write stringC'Current Time is - M );display timeO;

breakj ~

set date

case command DATE:

if(value_present(0)) // if anything entered

myblock->dx * token valueCO];

myblock->dx * (myblock->dx « 8) | token valued];

myblock->cx * token value [3]; "*

myblock->ax = 0x0500;

sys int(0x1a,myblock);

if(?myblock->flags & carry bit) Is 0)

write_string( H Error setting date 11 );

write stringC'Current Date is - ");display date();
breakj ~

/* set drives */

case command_DRIVE:

// if value - a-f, then set type of drive in system
if((token valueCO] >= 0x0a) && (token valueCO] <= 0x0f))

// a and b are easy, c,d,e,f have to count drives

// A: is floppy
if(number_of_floppies() > 0)

if (token valueCO] == 0x0a)
i

outcmos(0x10,(incmos(0x10) & OxOf) I ((token valued] & 0x0007) « 4));
>

A-Tvoe BiosKit

The Vue File E- 17-15

>

// B: is floppy
if (number of floppiesO > 1)
i
if(token_yatue[0] == 0x0b)

outcmos(0x10,(incmos(0x10) & OxfO) | (token valued] & 0x0007));
>
>

// C: is floppy
if (number of floppiesO > 2)
< "

if (token value[0] == 0x0c)
C
outcmos(0x11 / (incmos(0x11) & OxOf) | ((token_valued] & 0x0007) « 4));

>

// D: is floppy
if (number of floppiesO > 3)
C " "

if(token_value[0] == OxOd)

outcmos(0x11 ( (incmos(0x11) & OxfO) | (token_valuedl & 0x0007));

>

// these are for hard disks -

if (number of floppiesO <= 2)
// C: and~0:~are hard drives
<

if (token value [0] == 0x0c)

C
if (token_value[1] < 14) // use primary cell

outcmos(0x12,(incmos(0x12) & OxOf) | ((token_value[1] & OxOOOf) « 4));

else // use secondary cell

outcmos(0x12,incmos(0x12) J OxfO);

outcmos( 0x19, token valued]);
>
>
if (token value [0] == OxOd)

if (token_value[1] < 14) // use primary cell

outcmos(0x12,(incmos(0x12) & OxfO) | (token_value[1] & OxOOOf));

else // use secondary cell

outcmos(0x12,incmos(0x12) J OxOf);
outcmos(0x1a, token valued]);

>
>

if(number of floppiesO « 3)
// D: and~E:~are hard drives
i
if (token value [0] == OxOd)

if (token_value[1] < 14) // use primary cell

outcmos(0x12,(incmos(0x12) & OxOf) | ((token_yaluedl & OxOOOf) « 4));

else // use secondary cell

outcmos(0x12,incmos(0x12) J OxfO);
outcmos(0x19, token valued] );
>
>

if (token valueCO] == OxOe)
i
if (token_value[1] < 14) // use primary cell

outcmos(0x12,(incmos(0x12) & OxfO) | (token_value[13 & OxOOOf));

else // use secondary cell
t

outcmos(0x12,incmos(0x12) J OxOf);
outcmos(0x1a, token valued]);
>
>
>

if (number of floppiesO == 4)
// E: ancTF^are hard drives
i
if(token_value[0] == OxOe)

Section E: The C Programs

E-17-16 The Vue File

if (token_valuedl < 14) // use primary cell

outcmos(0x12,(incmos(0x12) & OxOf) | ((token_yalued] & OxOOOf) « 4));

else // use secondary cell
i

outcmos(0x12,incmos(0x12) J OxfO);
outcmos(0x19, token valued]);
>

> .

if (token valuetO] == OxOf)
i
if (token valued] < 14) // use primary cell
i
outcmos(0x12,(incmos(0x12) & OxfO) | (token_valued] & OxOOOf));

else // use secondary cell
i

outcmos(0x12,incmos(0x12) J OxOf);
outcmos(0x1a, token valued]);
>

>

calc_cmos(); // recalc checksum

else
C
if(value_present(D) // if anything entered

// if value = 0-4, then # of drives in system
if(token valued] <= 4)
<
if(token valued] == 0) // set no-drives in system
C
outcmos(0x14,incmos(0x14) & -0x01);
calc_cmos();

else // there are drives in system

outcmos(0x14,incmos(0x14) | 0x01);
outcmos(0x14,(incmos(0x14) & 0x3f) I \
((token valued] -1) « 6));
calc_cmos();

>

>
>

write stringC'Options are\n\r M );
write~string("0-4 = # of floppy drives\n\r M );
write~string("A:n - F:n = set drive type\n\r");
write""string("For Floppy drives:\n\r M );
write""string( M = no drive\n\r M );
write~string( H 1 = 360k drive\n\r");
write"string( M 2 = 1.2M drive\n\r M );
write~string( M 3 * 720k drive\n\r M );
write""string( M 4 * 1.44M drive\n\r M );
write""string("For Hard drives: 1 ');
write~string(" n = drive type\n\r");

write~string(°For list of hard drive types, enter ""Types" ,,M );
display drivesO;
break;

list drive types from hdisk table

case command TYPES:
displayjidisk" types();
break; "" ~

/* set memory sizes */

case command_MEM:

if(valuejaresent(1)) // if anything entered

set sys mem(dec2bin( token valued]));

if(value_present(3)) // if anything entered
i

set ext mem(dec2bin( token value [3]));
> ~ "

write string(" System Memory Size is - ");display sys memO;
write~string("\n\rExtended Memory Size is - H );display~ext_mem();

break;

A-Tvpe BiosKit

The Vue File E-17-17

/*--- select NPX present/not present */

case command NPX:
i f ( va I ue_present < 1 ) )

if ((token valued] & 0x01) == 0)
i

outcmos(0x14,incmos(0x14) & -0x02);
>

else
i

outcmos (Ox 14,i nemos ( Ox 14) | 0x02);

calc cmos();
>

write string( "Opt ions are: = No, 1 » Yes\n\r");
write~string("NPX ");
display npx();
break;

set video type

case command VIDEO:

write stringT"Options are\n\rO=EGA\n\M=CGA 40x25\n\r2=CGA 80x25\n\r3=Monochrome");

if (value _present(1)) // if anything entered

// chekc for argument range validity

if((token value[1] >= 0) && (token valued] <= 3))

C

// this is where we set the video bits

outcmos(0x14,(incmos(0x14) & Oxcf) | ((token valued] & 0x0003) « 4));

calc cmos();
>
else

write string("\n\rVideo type argument must be between 0-3");
beepO;

>

else
i

write string("\n\rTo change Expected Video, type ""VIDEO n <enter>""\n\r");
>

display video();
break;

/*======== input from port Command ======*/

case command_IB: mode_size = byte; lbyte(inportb(token_value[1])); break;

case command_IW: mode_size = word; lWord(inport(token_valueCU)); break;

case command I:
switch (mode'size)
i

case byte: lbyte(inportb(token_value[1])); break;

case word: lword(inport(token valued])); break;
>
break;

/*========= output from Port Commands =========*/

case command J)B: mode_size = byte; outportb(token_value[1],token_value[3]); break;

case command_OU: mode_size = word; outport(token_value[1],token_value[3]); break;

case command 0:
switch ( mode's ize)
i

case byte: outportb( token valued], token value[3]); break;

case word: outport(token~valued],token~value[3]); break;

break;

/*=== Hove Command ===*/

case command_M:

do
i

pokeb( token value [4], token valueC5]++,

peekb( token~va I ue [0] . token~va I ue d ] ++ ) ) ;

if (console 5reak()) break;"
>

Section E: The C Programs

E-17-18 The Vue File

while ((token valued] < token value[3]) &&

(token valuelTj != 0));

break;""

/*=== Register Display Command »«*/

case command R: /* display all the registers V

display regs?&reg saves);

break;

/*=== Register Display and Change Commands ===*/

case command_RAX: reg_index - axsave; goto redisplay;

case command_RBX: reg_index = bxsave; goto r_di splay;

case command_RCX: reg_index = cxsave; goto r_di splay;

case command_RDX: reg_index = dxsave; goto redisplay;

case command_RSP: reg_index = spsave; goto redisplay;

case command_RBP: reg_index = bpsave; goto r_display;

case command_RSI: reg_index » si save; goto redisplay;

case command_RDI: reg_index » disave; goto redisplay;

case command_RDS: reg_index » dssave; goto redisplay;

case command_RES: reg_index ■ essave; goto redisplay;

case command_RSS: reg_index 3 sssave; goto r_di splay;

case command_RCS: reg_index » essave; goto r_display;

case command_RIP: reg_index » ipsave; goto redisplay;

r_di splay:

/* if there is a command line input, just store it */

if(value_present(1) *= true)

reg saves [reg index] = token value[1];

else
i

write string(peek(bios cs(),&register token list [reg index-1]));

co(' T ); ~ *

lword(reg saves [reg index]);

co(cr); co(lf); co( T :');

/* solicit input for register */

get line input(cr);

get~values();

1 f ( va I ue jaresent ( 1 ) )

reg saves [reg index] « token value[1];

>

break;

/* Flag Register Command */

case command_RF:

/* we have to look at command line for flag alpha's */
/* if there is a command line input, just store it */

commaixHndex = get_token_number(&flag_token_list);

if(command_index == 0) // solicit input

display flagsO;
write sTring( M - ");
get line input(cr);
get~token( ) ;

command index = get token number (&f lag token list);
> " "

if (command index != 0)
i

command index--; // rebase to zero

I word( command_i ndex ) ;

A-Tvpe BiosKit

The Vue File E- 17-19

if ((command_index & 1) == 0)

/* even number - clear bit */

reg saves [pswsave] &= -(1 « (command index/2));
> "
else
i

/* odd number - set bit */

reg_saves [pswsave] |= (1 « (commarKMndex/2));

>

break;

/*==s=s= s == Read Intel Hex =================*/

case command_RHEX:

/* start looking for record marker */

do
<

whiled'nchar = ci() != ':') O

sum = 0;

char count = get byteO;

token value [1] =~get word();

recor3_type = get_byfe();

switch (record type)
i

case data record:
if (char count ==0)
i
record type = end_of_file_record;
break;" ~ "
>
while (char count > 0)

pokeb(token_yalue[0] ,token_yaluet1] ,get_byte());

get byteO;

if Tsum != 0) record type = end_of_file_record;

break; ~ - - -

case end of file record:
/* return to sysvue main */
break;

case extended address record:

/* set load address segment */

token value CO] = get wordO;

get byteO;

if (sum != 0) record type = end_of_file_record;

break;

case start address_record:

/* set cs:Tp of reg set */

reg saves [cssave] = get wordO;

reg~saves[ipsave] = get~word();

get~byte();

if Tsum != 0) record_type = end_of_file_record;

break; ~ ~ ~

while (record_type !* end_of_.fi I e_record);
break; " - - -

/*========= write Intel Hex =================*/

case command_UHEX:

/* disregard if range = nul */
if ((token valued] II token value[3]) != 0)
<

/* write extended address record for segment */
write_string("\r\n: M );
sum =~0;

pbyte(2);pword(0);pbyte(2);
pword( token valueCO]);
pbyte(sum);~
do
i

write stringCXrVn: 11 );
if ((Token value[33 - token valued]) > 16)
i

char count = 16;
>

Section E: The C Programs

E-17-20 The Vue File

else

char count = token valueCl - token valued];
>

sum = 0;

pbyte(char count); /* record count */
pword(token valued]); /* address */
pbyte(O); /* data mode type record */
while (char count > 0)~
<

pbyte(peekb< token value[0] ,token_valueC1] ));

token value CI] ++;"

char_count--;

poyte(sum);

if (console breakO) break;
> " ■

while ((token valued] < token valueC3]) &&
(token_valueCT] != 0));

/* write start address record */

if ((token value[4] II token value[5]) != 0)

write string( H \r\n:");
sum =~0:

pbyte(4);pword(0);pbyte(4);
pword( token value [4]);
pword( token~va lue [5] ) ;
pbyte(sum);"

write str ing( M \r\n: 00000001 FF M );
>
break;

/*sssssssss Search Commands assassaaasssssssa*/

case command_SA: mode_size - byte; mode_type * ascii; goto search_case;

case command_SB: mode_size = byte; mode_type * hex; goto search_case;

case command_SW: mode_size » word; mode_type a hex; goto search_case;

case cocnmand_SD: mode_size a dword; mode_type a hex; goto search_case;

case command_S:

search_case:

/* if no mask entered, then all bits significant */
if((token value[6] I token value[7] )«0)

token value [6] a -token value [6];
token~value[7] a ~token~value[7];
>

if (mode size as byte)

/* clear~un-needed bits from mask */

i

token value [6] a 0:

token~valueC7] &a OxOOff;

if (mode size as word)
/* c I ear"un- needed bits from mask */
<
token value [6] a 0;
>

do
C
if((((peek(token value C0] f token valued]) & token value [7]) as

(token value[5] 5 token valueC7]))T &&
(((peek(token value COT, token valued]-*-?) & token value[6]) ==
(tolcen valueC4] & token~valueC6]))))
i ~

co(13); co(10): /* cr-lf */
lword(token value CO]);
co(':'); "
lword(token valued]);
coC '); ~

if (mode size as byte)
C
lbyte(peekb(token_valueCO] ,token_valueC1] ));

A-Tvpe BiosKit

The Vue File E- 17-21

if (mode size == word)
i
lword(peek(token value CO], token valued]));

if (mode size == dword)
i
lword(peek(token value CO], token value[1]+2));
co('-');

lword(peek(token value CO], token valued]));
> "

>

if (console breakO) break;
token valued] ++;
>

while ((token valued] < token value [3]) &&
(token value[T] != 0));
break;"

/*=======r= checksum Command ===========*/

case command CHK:

sum * 0;

do

i

sum += peekb( token valueCO] ,token valued]-*-*-);

if (console break(T) break;
>

while ((token value[1] < token value[3]) &&
(token valued] != 0)>;
/* add~in the last byte */
sum += peekb(token value CO], token valued]);
write string( "Checksum = "); ~
IbyteTsum);
break;

/*========== Re- Boot Commands ===========*/

case command COLD BOOT:

RESET FLAG ="0; /» reset the warm boot flag */

disabTeO; incmos(OxOO); // set NMI mask

far call (bios cs(),&reset);

break;

case command WARM BOOT:

/* reset the~warm~boot flag */

RESET FLAG - 0x1234;

disabTeO; incmos(OxOO); // set NMI mask

far call(bios cs(),&reset);

brelk;

case command HARD BOOT: /* forces cs: to fOOO */

RESET FLAG =~0; /» reset the warm boot flag */

disabTeO; incmos(OxOO); // set NMI mask

far call(6xf000,0xfff0);

brelk;

Trace Commands ===========*/

case command T:

case commancTTRACE :

trace count = token valued];

if(trace_count == 0T trace_count = 1;

exit flag*1; "

reg saves Cpswsave] |« 0x0100; // set trace bit

// chain- in the trace vector

trace chain = get vector(Oxl);

link Interrupt (0xT,Syst race);

brealc;

/**====== Select Watch parms command =======*/

case command SELECT:
if (value _present(D)

// modify parms

watch selection = token valued];
>

write stringC'Options are (the OR) as follows:\n\r");
IwordTviDEO); write string(" = Video\n\r M );
Iword(VUE); write string( M = SysVue\n\r M );
I word( CASSETTE); write string( M = Cassette\n\r");
I word( EQUIPMENT); write string(» = Equip\n\r H );
I word( MEMORY); write stringC = Mem\n\r H );
Iword(LPT); write stringC = Lpt\n\r");
Iword(COM); write"string( H = Com\n\r M );

Section E: The C Programs

E-17-22 The Vue File

l word( FLOPPY); write string(" = Floppy\n\r");
Iword(HARD); write sfring(" = Hard\n\r");
Iword(TOO); write string(" = Tod\n\r H );
tword(BOOT); write_string(" = Boot\n\r");

write stringC'Current Watch Selections are: ••);
watcR selection &= WATCH MASK;
if (watch selection == 0) write string("None");
if((watch" selection & VIDEO) != 0) write string("Video ");
if ((watdTse lection & VUE) != 0) write sfringC'SysVue •');
if((watch~selection & CASSETTE) != 0) write string ("Cass ");
if((watch"selection & EQUIPMENT)!* 0) write~string("Equip ");
if((watch"se lection & MEMORY) !* 0) write sTring(»Mem ");
if((watch""selection & LPT) != 0) write string( M Lpt ");
if((watch~selection & COM) !» 0) write""string("Com ");
if((watch~selection & FLOPPY) I* 0) write string(»Floppy ");
if ((watdTse lection & HARD) != 0) write sTring("Hard '•);
if((watch""selection & TOD) != 0) write string( M Tod »•);
if((watch~selection & BOOT) !* 0) write stringC'Boot ");
if((watch~selection & TIMER) != 0) write string("Tmr ");
if ((watdTse lection & KEYBOARD) != 0) wrTte_string("Kb »>;

write string("\n\rWatch is currently ");
if (watch flag == 0)
<

write string( M Off M );
>
else

write stringC'On");
>
break;

/*=========== watch command ===»==========*/

case command WATCH:
// toggle waTch flag
if (watch flag != 0)
€

watch flag * 0;

Write~String(" Off");
>

else
I

Write String(" On");

watch~flag « watch selection;

if(re3irect flag != 0) watch flag &* -LPT;
>
break;

/*s3s=ssss=ss Re-direction commands =====*=======«*/

case command TO CON:
case commancTBACK TO CON:
redirect flag « 0J
break;

case command TO LPT:

redirect flag ="~1;

// If you are watching the printer driver, it must not be copying screen output to the printer.

// An insidious recursion results, blowing the system away !

if((watch_flag & LPT) !» 0) watch_flag &= -LPT;

break; ~ ~

>
>

>;

ax = reg saves Caxsave] ;
bx = reg~saves [bxsave] ;
ex - reg~"saves [exsave] ;
dx = reg'saves [dxsave] ;
si = reg~saves[sisave];
di = reg~saves[disave];
ds = reg~saves [dssave] ;
es = reg~saves [essave] ;
flags = reg saves [pswsave] ;
cs = reg_saves [essave] ;
ip = reg~saves[ipsave];

// If tracing, we should link the trace vector here

// If trapping (breakpointing), we should link the trap vector here.

set_yector(0x1b,break_chain » 16,break_chain);

A-Tvpe BiosKit

The Vue File E- 17-23

sysvue busy = 0; /* release Sysvue */
>

release block(myblock);
>

/*=========== console Status Routines ============*/

unsigned console breakO

/* returns true Tor abort operation */

i

if (break flag == 0) return( false);

break flag = 0;

return(true);
>

/* V

/* dump byte and word functions */

void pword(w) /* print word, accumulate checksum */

pbyte<w » 8); pbyte(w);
>

void pbyte(outchar) /* print byte, accumulate checksum */
i

sum -= outchar; /* bui Id checksum for whex command */

Ibyte(outchar);
>

/* dummy nmi interrupt routine */

void nmi into
C

>

/* supporting functions */

// This function displays the register set. It is used by the 'R' Command and the 'INT' Command.

void display regs(unsigned *reg saves)
C

co(cr); co<lf);

for (token index = 0;token index < 13;token index++)
<

write string(peek(bios cs(),&register token list [token index]));
co('= T ); " "

lword(reg savesttoken index+1]);
co(' '); coC ');

if (token index == 7) { co(cr); co(lf); >
>

coC '); coC ');
display flags(reg saves);
>

void display flags (unsigned *reg saves)
i

unsigned even odd;

int scan index;

/* display the flag conditions */

for (scan index = 15; scan index > -1; scan index--)

even_odd * ( reg_saves Cpswsave] » scanjndex) & 1;

if (peekb(bios_cs(),peek(bios_cs(),&flag_display_token_list[scan_index3 Ceven_odd])) != '-')

write string(peek(bios cs(),&flag display token listtscan index] [even odd]));
coC T ); ~ "

>

>

get a byte for rhex

char get byte()
i

char cc,d;

cc = ci() - '0';

if (cc > 9) cc -= 7;

d = ci() - '0';

if (d > 9) d -= 7;

cc - cc « 4 I d;

Section E: The C Programs

E-17-24 The Vue File

sum += cc:
return (d);

get a word for rhex

unsigned get word()
return ((get_byte() « 8) | get_byte());

unsigned isdelim(char c) /* returns true or false */
C

int q=0;

char cc;

/* write string( M \n\rIsdelim "): lbyte(c);co<' ');*/

for (;(cc""= peekb(bios_cs(),&deliin_hst[q++])) != 0;)

/* lbyte(cc):co(' ');*/

if (cc *s (c & Oxff)) retum(true);
>;
return( false);

unsigned get tokenO

// this gets the next token from the line input buffer and puts it into the token buffer

// It uses the buffer index and advances until end of data.

// It returns true if~a token was found and false if no token found

if ((buffer [buffer index] »* 0) l| (buffer [buffer index] *■ cr)> return(false);

/* move from buffer to token buffer */

for (token index=0; ( i sde I im( buffer [buffer index]) == false) && (buffer [buffer index] '.= 0) ;

token buffer [token i ndex++] =buf f er [buffer Tndex++] ) ;

token"buffer[token~index] =0;

/* puT in end of siring marker */

last delim * buffer [bur fer index];

buffer^index**; /* advance~buffer index over delimiter */

return~(true);

void syntax error(void)
C

write string( M \n\rSyntax Error");
>

// Get Line Input is the normal input function. It always terminates on a cr OR on the char

// specified on the callers arg. If the caller wants only a CR termination, then he calls with CR

// as the arg.

void get_line_input(term) /* get the input line */

buffer index * 0;
do
<
if((inchar « ci()) == bspace)

if (buffer index !* 0)
i

buffer index--;

co( bspace);

co(' ');

co (bspace);

buffer [buffer index] = 0;
>
>

else /* not a backspace V
i

/* lower to upper case */

if ((inchar >» 'a') && (inchar <« 'z')) inchar A * 0x20;
co(inchar); /* echo character */
if((inchar != term) && (inchar != cr))
/* if a regular character */
(.

buffer [buff er index] = inchar;

buffer_index++;

else /* a cr or a term char */

buffer [buff er index] = 0;
buffer [buffer~index+1] = 0;
if (inchar =="cr) co(lf);

A-TYpe BiosKit

The Vue File E- 17-25

>
>
>

while ((inchar != term) && (inchar != cr));
buffer index = 0;
>

/*--- get the value specified by this token ---*/

unsigned get token valueO

char cc;

unsigned token value;

token value = U; /* pre-clear token value cell */

token~index * 0;

token'number = get token number(&register token list):

if (token number == 0) / w it is a value, not a Token */

i /* determine value */

token index = 0;

while""(token buffer[token index] != 0)

<:

cc = token buffer [token index];
if (ishex(cc) == true) ~
i
if (isalpha(cc) == true) cc += 9;
cc &= OxOf; /* now it is a nibble */
/* merge it into token */
token value = (token value « 4) I cc;
>

token index**;
>

return(token value);
>
else

// if there is a token #, then get the value of that token

C

return(reg saves [token number- 13);
>
>

/* V

// search the specified token list against the token buffer and return the token number if a find -
// no find - return token_number =

unsigned get token number(unsigned *token listjatr)

unsigned token index, list index=0, token number=1;
/* points to current string being checked */
unsigned list_item;
unsigned itenTindex=0;

while

((list item * peek(bios cs(), &token list_ptr[list index**])) != -1)

€

for (token index = 0,item index = 0:

((token buTfer[token index] I- 0) && (peekb(bios cs(),list item*item index) != 0) &&

(token 5uffer[token Index] == peekb(bios cs(), list itemHTem_index)7);

/* co(peekb(bios csT),list item*list index)),*/

token_i ndex++, i tem_i ndex++T;

// If they are both at the end of string, then they matched.

if ((token buffer[token index] == 0) && (peekb(bios cs(),list item*item index) == 0))
C ~

/*

** write string("\n\rToken is •'); lword(token number);

*/

return( token number);
>

/* count the tokens */
token number**;
/* ~

** write string("\n\rToken # ");
** lword(token number);
** write string( M \n\rList index ");
** IwordTlist index);
** write string( M \n\rList pointer ••);
** IworoTlist item);
*/

>;

/* co(peekb(bios_cs(),list_item*list_index));

*/

return(O);

Section E: The C Programs

E-17-26 The Vue File

/* The sysbreak routine is invoked by the CTRL-BREAK or CTRL-C keys and sets the break flag.
** This is checked by the CSTS routine to see if an operation should be aborted. It is linked
** upon entry to SysVue and de- 1 inked upon exit.
*/

void interrupt cdecl far sysbreak(interrupt_registers)

cstodsO; // do this because it is assumed that cs = ds
setds system segment ();

/* all varia5les will be referenced in sys seg V
break flag - 1;
>

/* This function evaluates the arguments on the command line and gets the values associated with

** the args and places their values into the token_value array.

** The values are arranged: ~

** seg:off - seg: off - seg: off - seg: off

** The corresponding present bit is set in the 'present' char to indicate if a an arg was

** present for that value.

*/

get valuesO
< ~

unsigned i; /* i is a local variable used for the index */

/* clear the token value array */

for (i=0; i< 8;token value[i++3 = 0): present =0; i = 0;

/* write string( M \n\rEntering get values ");

*/

do

if (get tokenO == true) /* there is a token - */
i

token value [i+1] = get token valueO;
present j= (0x80 » (i+D);
if ((last delim == ':') || (last_delim == '/'))
/* the toEen is a register token */
C
token valued*] = token value[i+1];
present |= (0x80 » i)7
present A* -(0x80 » O+D);;
token value [i+1] = 0;

if(ge"f tokenO == true) /* there is a token - */
<

token valueti+1] = get token valueO;
present |= (0x80 » (i+D);

>
>

i += 2;
>

while (i < 8);
/*

**write string("\n\rExiting get values");
*/
>

/* Value present looks at the present bit for token_values 0-7 and returns a true if the bit is

** set, indicating a value was entered ~

*/

uns i gned va I ue jjresent ( i ndex )

if (((present « index) & 0x80) !» 0) return(true);
return(false);
>

A-Tvoe BiosKit

SECTION F

Odds and Ends

This section includes tips on loading a Test Bios into Static Ram by using Debug
Batch files, and other assorted subjects.

Loading Test Ram F-l-1

ONE
Loading Bios Test Ram

The following example shows how a Static Ram Adapter card installed in a target
system can be loaded with the Bios image to test the Bios without programming
Eproms. This example assumes the target machine has 64 Kbytes of static Ram at
segment D000. Note that the Adapter uses static rather than dynamic Ram and that
the Ram is located in the high memory map area, rather than in the System Ram
area (0 - 640 K). The low Ram area is cleared when a Bios starts, so the Bios image
must be outside the 0-640 K range. Dynamic Ram Refresh is re-initialized during
the Bios Power-up, so Static Ram is required for the Test-Bios to remain intact.

Create a file named loadat.inp file (as shown below) to provide input to the debug
program. It will be used to automate the copying of the Bios image from the DOS
transient area to the static Ram location. Note that the transfer is done in 4000 byte
portions, as the debug program treats the length argument (4000) as a signed
integer. A value of 8000 would be unreliable. Following the copying commands, a
Go command starts executing the Bios at its reset label. By inspecting the Bios.map
file, the offset for the label reset may be verified.

nbios.bin

1

m cs:0000 1 4000 d000:0000

m cs:4000 1 4000 d000:4000

mcs:800014000d000:8000

m cs:c000 1 4000 dOOOxOOO

g=d000:e05b

To perform this loading procedure, enter debug < loadat.inp

Next, to avoid typing the full command debug < loadat.inp every time you want to
load the Ram, create a file such as load.bat which contains the one line as shown
below:

debug < loadat.inp

Now all that is required to perform the complete copy, load, and go procedure is to
enter load and allow the batch file to invoke the process.

A sample schematic is included for a static ram adapter which you may wish to use
as a design guideline in case you decide to construct your own adapter. This
schematic shows the general philosophy you can use in your design. Fosco and
Annabooks have not constructed an adapter from this schematic, but have used the
same design approach in the past. The functions shown in the programmable logic
device (16L8) can be duplicated with discrete logic, but a PAL approach is the

F-l-2 Loading Test Ram

simplest. PAL's are a specific family of programmable devices by MMI, and PAL is
a registered trademark of MMI. An adapter of this type will also accommodate the
Dallas Semiconducter battery backed ram modules, so a non-volatile ram board can
be configured.

A-Tvpe BiosKit

+5V

1 0K

RES.

±

WRITE PROTECT
SWITCH

-All.
JdSL
ML
ML

_AJi

A14

roT

T6L8

jamiL

RAM!/

SSS24:
RAM3/

BWR/
PBHB/

EQUATIONS.

BWR/ = WR/ *S1/

RAMO/ = A19/ * AJ8/ * X * Y *At3/

RAM?/* At 9/ * At 8/ *X *Y *At5/

RAM2/ = At9/ * At8/ * X * Y *A15

RAM3/* At9/ * A13/ *X *Y*A15

DENB/ = RD/ * RAMO/

* RD/ * RAM! /
+ RD/ * RAM2/

♦ RD/ * RAM3/

NOTES.

A14/
AT4
A14/
A14

WRITE PROTECT
RAM SELECTS

DATA ENABLE FOR DATA BUFFER

DENB/

FOR SEGMENT DOOO:
X« A17/

Y = AY6

FOR SEGMENT EOOO.
X« At7

Y = At 6/

ML

Ml

M

Mi.

Mi

M2.

Ml

MO.

28-PIN SOCKETS WILL ACCEPT
62256 RAM's
DALLAS 1 235 RAM's

DATA LINES SHOULD BE BUFFERED THROUGH
A 245 IN ORDER TO DRIVE THE BUS.

ADORESS LINE BUFFERING IS OPTIONAL

DECODER IS MM! T6L8 PAL

THIS SCHEMATIC IS FOR EXAMPLE ONLY.
FOSCO & ANNA8G0KSMAKE NO REPRESENTATION
AS TO THE CORRECTNESS OF THE EXAMPLE.

245

RA.M3/

RAM2/

RAMO/ 20

BDQ7

3D05

BDQ4

_3DQ3_

BPQQ

.SBJL

BAQ1

BAQ3

BAQ4

BAQ5

gfflfi

BAQ7

BA12

.BAH

19

8D06 t8

17

t6

15

.SQQ2 11

-BDJU L2.

Tt

2L

BAOO LO.

JAQ2 a.

-BAOS 25.

-BAQ2 21

3MSL 21

sajj 21

Mil 2L

_L

2XRI 21

M

RAM?/ 20.

^7

07

D6

D5

D4

03

D2

Dt

DO

OE/
AOO
AC1
A02
A03
A04
A05
A06
A07
A08
AC9
AtO
Alt
A12
At3
A14

WE/

2SL

BiosKit Static Ram Board

FOSCO

28035 MOUNTAIN MEADOW ROAD

ESC0NDID0.CA.92026

St 9+744-8086

The Indent Program F-2-1

TWO
The Indent Program

The Indent program is used to indent the lines of a source file according to the
nesting of the left and right bracket characters ({ and }) to ease the readability of
the code. Some editors have built-in features to do this automatically for you, so this
Indent program may not be needed. If you are using an ordinary editor, you will find
this program useful.

/♦WW***********************************************************************************************

* Copyright (c) FOSCO 1988, 1989 - All Rights Reserved

* Module Name: Indent

* Version: 1.01

* Author: FOSCO

* Date: 10-10-89

*

* Filename: Indent. c

*

* Functional Description:

* This program is a utility which is used to indent C source code lines according to the nesting

* level of the left and right bracket characters ( C } ). It improves readability of the souce

* file, but does not affect the logic flow. It is useful when a general purpose editor is being

* used to prepare source files.

* Arguments:

* File name

* Return:

*

* Version History:

* 1.01

* Updated under QuickC 2 for convenience.

* General clean-up and simplification.

*************************************************************************

/♦INCLUDE FILES*/

#include <stdio.h>

/♦GLOBAL VARIABLES*/

FILE *instream;

FILE *outstream;

unsigned int length, i,numread,numwritten, tab » 0;

#define blen 512

unsigned char instring[blen],outstring[blen],buffer[16384];

#define true -1

#define false

unsigned write_ok = true;

/♦LOCAL DEFINITIONS*/

#define tabchar 9

#define rt brace 125

#define If "brace 123

#define in3ent_level 1 /* # of columns to indent */

/♦PROGRAM*/

/* indent c programs according to O characters */

maind'nt argc, char *argv[])
i

printf< "FOSCO/ Annabooks Indent Source Utility Vl.01\n\r«);

if (argc <2) < printf( H Not enough arguments on command line\n M ); exit(0); >

if ((instream = fopen(argv[1], N r N )) == NULL)

printf ("Could not open file for reading\n M );
else
i
length = filelength(fileno(instream));

F-2-2 The Indent Program

if (length « -1) printf ("Bad Length on input file\n");

else

i

if ((outstream - fopen("$id.$$$" "w")) == NULL)

printf ("Could not open file for writing\n");

else

<:

tab=0;

while (fgets(instring,blen, instream) f= 0)

I

II skip over leading spaces

i=0; while (instring[i++] == ' '); i--;

// check for right brace here so we de- indent the current line

if ((instring[i] == rt brace) && (tab >= indent level))
tab -* indent_level; ~

// pad front of output string with required # of spaces
strnset(outstring,' ',tab);outstring[tab] = 0;

// now copy instringCU to outstringttab]
strcat(&outstring[tab] ,&instringCi] );

// write to the temp file and mark any errors

if(fputs(outstring.outstream) != 0) write ok = false;;

// check for left braces here so we indent the following line

if (instring[i] == If brace)

C

tab += indent level;

// check for closing brace on same line

for(; i<strlen(instring);i++)

if ((instringti] == rt brace) && (tab >= indent level))
i

tab -= indent level;

break; "*
>
>

>
>
>

f closed' nstr earn) :
fclose(outstream);

if (! write ok)

printf( M \n\rError in writing temporary file, processing aborted.");

printf ("Original file Xs remains unchanged. \n\r" f argvn]);
>

else
C

// now copy the $id.$$$ to the original file

if (((instream » fopen("$?d.$$$", H r+b»)) J* NULL) &&

((outstream=fopen(argv[1],"w+b")) != NULL))

do
C

numread » fread((char *)buffer, si zeof (char), 16384, instream);
numwritten = fwrite((char *)buffer, sizeof(char),numread,outstream);
if (numwritten Is numread)
i

printf ("Transfer error on file Xs. Use $10.$$$ as recovery file./n",argv[1]);
write ok * false;
>
>

while (numread > 0);
f close( ins tr earn);
fclose( out stream);
if (write ok)

if~((numread = remove ("$id.$$$")) != 0)

printf ( H \n\rError deleting temp file $ID.$$$\n\r M );

>
>
>

A-Tvpe BiosKit

The Hilite Program F-3-1

THREE
The Hilite Program

The Hilite program is used to display program comments in intensified video on the
display. It scans the source file and looks for pairs of comment delimiters ( /* and
*/ ), and intensifies the video between these marks. It is useful for detecting
incorrect comment delimiter pairs, which may comment out wanted source code
statements. When strange errors show up in the compilation of a 'slightly' edited
program, comment delimiter errors may cause drastic errors. If a program compiles
properly but program operation changes radically, a comment check with Hilite may
help in determining the cause(s).

/**************************************************************************************************

*

* Copyright (c) FOSCO 1988, 1989 - All Rights Reserved

*

* Module Name: Hilite

*

* Version: 1.00

* Author: FOSCO

*

* Date: 1-1-89

*

* Filename: hilite.c

*

* Functional Description:

* This program is used to hilite the comments in a C source program as it is displayed on

* the screen.

*

* Arguments:

* File name

* Return:

*

* Version History:

************************************************************************

/♦INCLUDE FILES*/

/♦FUNCTION PROTOTYPES*/

/♦GLOBAL VARIABLES*/

/♦GLOBAL CONSTANTS*/

/♦LOCAL DEFINITIONS ♦/

/♦LOCALCONSTANTS*/

/♦PROGRAM*/

/* highlight c programs according to / * * / characters */

#include <stdio.h>
#include <dos.h>
#include <ctype.h>
#define cr 13
#define If 10
#define space 32
#define on 1
#define off
#define star '*'
#define slash 47
#define bspace 8;

FILE *instream;

unsigned int length;

unsigned int i;

unsigned char comment. ch,last_char;

unsigned char buffer [16384]; ~

union REGS regs;

main(argc,argv)
int argc;

F-3-2 The Hilite Program

char *argv[];
i
if (argc <2)
i

printf("Not enough parameters on command line\n");
exit(O);

if ((instream = fopen^rgvMVr+b")) == NULL) printf ("Could not open file for reading\n H );
else
<
length * filelength(fileno( instream));

for (i=0; i<length && <<ch = getc( instream)) != EOF); i++>

if ((last char == slash ) && (ch == star ))
i
comment = on; /* backspace and turn on last slash */

regs.h.ah = OxOe;
regs.h.al = bspace;
regs.h.bh = 0;
int86(0x10,&regs,&regs);
regs.h.bl = OxOf;

regs.h.ah = 0x09; /* write attribute at cursor */
regs.h.al = 0x20; /* display without highlight */
regs.h.bh = 0x00;
regs.x.cx = 0x0001;
int86(0x10,&regs,&regs);

regs.h.ah = OxOe;
regs.h.al » slash;
regs.h.bh = 0;
int86(0x10,&regs,&regs);
regs.h.bl * OxOf;
>

if (comment « on)
C

regs.h.bl * OxOf;
>

else
i

regs.h.bl = 0x07;
>

regs.h.ah = 0x09; /* write attribute at cursor */
regs.h.al = 0x20; /* display without highlight */
regs.h.bh * 0x00:
regs.x.cx = 0x0001;
if (isprint(ch)) int86(0x10,&regs,&regs);

regs.h.ah = OxOe; /* write tty */
regs.h.al = ch*
regs.h.bh = OxoO;
int86(0x10,&regs,&regs);

if ((last char == star ) && (ch » slash )) comment » off;
last char""= ch;
>

fclose( instream);
>
>

A-Tvoe BiosKit

The Parens Program F-4-1

FOUR
The Parens Program

The Parens program is used to display parenthesized text in intensified video on the
display. It scans the source file and looks for parentheses characters and intensifies
the video between these marks. It is useful for detecting incorrect parenthesizing.

/***************************************************************************************************

*

* Copyright (c) FOSCO 1988, 1989 - All Rights Reserved

*

* Module Name: Parens

*

* Version: 1.00

*

* Author: FOSCO

*

* Date: 1-5-89

*

* Filename: parens. c

* Functional Description:

* This progam is used to display parenthesized text on the screen in itensified video.

*

* Arguments:

* File name

*

* Return:

* Version History:

*
*******************************************************************

/* INCLUDE FILES*/

/♦FUNCTION PROTOTYPES*/

/♦GLOBAL VARIABLES*/

/*GLOBALCONSTANTS*/

/♦LOCAL DEFINITIONS*/

/♦LOCAL CONSTANTS ♦/

/♦ PROGRAM ♦/

/♦ highlight c programs according to () characters ♦/

#include <stdio.h>
#include <dos.h>
#include <ctype.h>
#define cr 13
#define If 10
#define space 32
#define on 1
#define off
#def ine I par en 40
#def ine rparen 41

FILE ♦instream;
unsigned int length;
unsigned int i;
unsigned char ch, depth;
unsigned char buffer [16384];
union REGS regs;

main(argc,argv)
int argc;
char ♦argv[];
i
if (argc <2)
i

printf("Not enough parameters on command line\n H );
exit<0);

if ((instream « fopen(argv[1], ,, r+b ,, )> == NULL) printf("Could not open file for reading\n M );
else

F-4-2 The Parens Program

<:

length = filelength(fileno(instream));

depth = 0;

for (i=0; i<length && ((ch = getc(instream)) != EOF); i++)

<:

if (ch == tparen) depth++;

if (depth != 0)

t

regs.h.bl = OxOf;
>

else
i

regs.h.bl * 0x07;
>

regs.h.ah = 0x09; /* write attribute at cursor */
regs.h.al = 0x20; /* display without highlight */
regs.h.bh = 0x00:
regs.x.cx ■ 0x0001;
if (isprint(ch)) int86(0x10,&regs,&regs);

regs.h.ah * OxOe; /* write tty */
regs.h.al ~ ch:
regs.h.bh * 0x00;
int86(0x10,&regs,&regs);

if (ch a* rparen) depth--;

>

fclose(instream);
>
>

A-Tvpe BiosKit

The Bin2Hex Filter F-5-1

FIVE
The Bin2Hex Filter

The Bin2Hex filter is used to convert a binary image file into Intel Hexadecimal
Format. This is a common format used by many prom programmers such as Data
I/O, etc. Since this is a filter, the output may be directed to a file, an output port, or
the screen.

***********************************************************************

Copyright (c) FOSCO 1988, 1989 - All Rights Reserved

Module Name: Binary to Intel hexadecimal filter
Version: 1.00
Author: FOSCO
Date: 1-5-89
Filename: bin2hex.asm

Functional Description:

This program converts the contents of a file to Intel hexadecimal format. Since many Prom
Programmers will accept an Intel Hex download format. .BIN files may be converted.
Filter outputs can be directed as shown in the examples below.

Arguments:
bin2hex <infile.bin >outfile.hex
bin2hex < infile.bin >C0M1
bin2hex < infile.bin >C0N

Return:

Version History:
1-5-89 - font revision

***************************************************************************************************

/PROGRAM

.model compact

stack segment word stack 'stack'
stack ends

stdin equ
stdout equ 1

.data

ibuff db 16 dupCO)

obuff db 32 dup(0)

line count dw

char""count db

checksum db

ochar db

eof db 13,10,':00000001FF'

.code

assume cs:_text,ds:_data

bin2hex proc

mov ax, data

mov ds,ax

mov line count,
$$D01 :

mov bx, stdin ; get stdin

mov ex, 16

mov dx, offset ibuff

mov ah.3fh

int 21 h
JC $$EN1

F-5-2 The Bin2hex Filter

or

ax, ax

; don

JZ $$EN1

mov

char_count,al

call

write line

JMP SHORT

$$001 -~

$$EN1:

call

write eof

; write eof

mov

ax,4c0Oh
2lfi

int

; return to dos

bin2hex

endp

write_li

ine proc

mov

checksum,

mov

c I, char count

xor

ch.ch "

mov

al,13

; carriage retui

call

putc

mov

al,10

; line feed

call

putc

mov

al, M : M

call

putc

mov

a I, char count

sub

checksum, a I

call

convert

mov

ax, I ine count

mov

al,ah *"

sub

checksum, a I

call

convert

mov

ax, line count

sub

checksum, a I

call

convert

mov

al,00

sub

checksum, a I

call

convert

add

line count, 16
si, offset ibuff

mov

$$005:

lodsb

sub

checksum, a I

call

convert

LOOP $$005

mov

a I, checksum

call

convert

ret

write_li

ine endp

convert

proc

push

ax

push

ax

shr

al,1

shr

al,1

shr

al,1

shr

al,1

and

al,0fh

add

al,'0'

cmp

al,'9'

JNA $$IF7

add

al,7

$$IF7:

call

putc

pop

ax

and

al,0fh

add

al,'0'

cmp

al,'9'

JNA $$IF9

add

al,7

$$IF9:

call

putc

pop

ax

ret

convert

endp

putc

proc

push

ax

push

bx

push

ex

push

dx

mov

ochar,al

mov

bx,stdout

mov

cx,1

mov

dx, offset ochar

mov

ah.40h

int

2lfi

pop

dx

pop

ex

pop

bx

A-Tvpe BiosKit

The Bin2Hex Filter F-5-3

putc

pop
ret
endp

write eof proc
push
push
push
push
mov
mov
mov
mov
int
pop
pop
pop
pop
ret

write_eof endp

end

ax

ax

bx

ex

dx

bx,stdout

ex, 13

dx, offset eof

ah,40h

2lft

dx

ex

bx

ax

bin2hex

Section F: Odds and Ends

The Splitbin Program F-6-1

SIX
The Splitbin Program

The Splitbin Program is used to Split the at.bin file into an atevn and at.odd file for
programming the two Proms normally needed for an AT Bios.

Some of the newer Chipsets used in AT clones may allow you to use a 64k x 8 prom
for the complete Bios. These Chipsets are based on the idea that the Bios would be
moved to Shadow Ram which usually operates with fewer wait states than Prom,
allowing higher performance operation. This may provide you with a design
advantage if you are designing your own CPU board. Check with the VLSI chipset
vendor for more information on this possible feature, and what additional software
that might be required. If your AT motherboard has this feature, then the Splitbin
won't be needed.

The Splitbin command line argument is the filename without the extension ("at" not
"atbin"). Splitbin adds the ".bin" to the input filename argument and the ".evn" and
".odd" extensions to the output files.

/I**********************************************************************

* Copyright <c) FOSCO 1989 - All Rights Reserved

* Module Name: Bin file splitter to even/odd

*

* Version: 1.00

*

* Author: FOSCO

*

* Date: 10-1-89

*

* Filename: Splitbin. c

*

* Language: MS C 5.1

*

* Functional Description:

* This program reads the .bin file specified by the argument,

* and splits it into an .evn and a .odd file.

* Version History:

/♦INCLUDE FILES*/
#include <stdio.h>

/♦GLOBAL VARIABLES*/

#define blen 8192

FILE *instream < *evenstream,*oddstream;

unsigned char inbuffer[2*blen], evenbuffer[blen], oddbufferlblenj;

unsigned char inname[16], oddname[16],evenname[l6];

unsigned numread,i,j;

/♦PROGRAM*/

unsigned main(int argc, char *argv[])

printf("\n\rFOSCO/Annabcoks Split xx.bin to xx.evn and xx.odd files Utility\n\r");

if (argc == 2)

i

strcpy(inname,argv[1]); strcatd'nname^'.bin");

strcpy(evenname f argv[1] ); strcat<evenname, M .evn M );

strcpy(oddname,argv[1] ); strcat(oddname, ".odd");

if((instream = fopen<inname, ,, rb ,, )) !=* NULL)

F-6-2 The Splitbin Program

if((evenstreem * fopen(evenname, M wb M )) != NULL)
if((oddstream * fopen(oddname,"wb">) != NULL)
i
while(

(numread * fread((char *)inbuffer,sizeof(char),2*blen,instream))

!= NULL)

i

for(i=0,j=0; j < numread; i++,j+ a 2)

evenbufferti] = inbuffer[j];
oddbufferti] = inbuffer[j+1];
)

fwriteCCchar *)evenbuffer,sizeof(char),numread/2,evenstream);
fwrite((char *)oddbuffer,sizeof(char),numread/2 / oddstream);
>
' >

else
i
printfCNo .bin file specified in command line\n\r M );

return(O);
>

A-Tvpe BiosKit

The Mergebin Program F-7-1

SEVEN
The Mergebin Program

The Mergebin Program is the companion to the Splitbin Program and may be used
to combine n .evn" and ".odd" files to a ".bin" file. The command line argument is the
filename (without extension). Mergebin looks for the ".evn" and ".odd" files and
creates a ".bin" file. Mergebin is handy if you want to read existing Bios proms and
create a complete image, as well as providing a means to verify the even/odd
conversion process (Splitbin) by merging a split and comparing results.

/A*********************************************************************

*

* Copyright (c) FOSCO 1989 - All Rights Reserved

* Module Name: Merge evn/odd files to a bin file

*

* Version: 1.00

*

* Author: FOSCO

*

* Date: 10-1-89

*

* Filename: Mergebin. c

*

* Language: MS C 5.1

*

* Functional Description:

* This program merges the .evn and .odd file into a combined .bin file.

* Version History:

*

/♦INCLUDE FILES*/

#include <stdio.h>

/♦GLOBAL VARIABLES*/

#def ine blen 8192

FILE *outst ream, *evenst ream, *oddst ream;

unsigned char outbuffer[2*blen], evenbuffer[blen], oddbuf fer [blen];

unsigned char outname[16], oddname[16],evenname[l6];

unsigned numread, i,j;

/♦PROGRAM*/

unsigned mainO'nt argc, char *argv[])

printf( M \n\rFOSCO/Annaboolcs Merge xx.evn and xx.odd to xx.bin files Utility\n\r H );
if (argc == 2)
i

strcpy(outname,argv[1] ): strcat(outname, ,, .bin H );
strcpy(evenname,argv[1]); st^cat(evenname, M .evn ,, );
strcpy(oddname,argv[1]); strcat(oddname, ,, .odd");
if((outstream = fopen(outname,"wb H )) != NULL)
if ((evens t ream * fopen(evermame, M rb")) != NULL)
if((oddstream - fopen(oddname # "rb M )) != NULL)
C

while(

((numread = fread((char *)evenbuffer,sizeof(char).blen,evenstream)) != NULL) &&
((numread = fread((char *) oddbuf f er, s i zeof ( cha r ), blen, odds tr earn)) != NULL)
>

for(i=0,j=0; i < numread; i++,j+=2)
i

outbuffertj] = evenbuffer[i];
outbufferCj+1] = oddbuf f er [i];
>

fwrite((char *)outbuffer, si zeof (char) , numread*2, out stream) ;
>
>
>

F-7-2 The Mergebin Program

else
i

printfC'No .bin file specified in command line\n\r M );
>

return(O);
>

A-Tvpe BiosKit

The Patch.asm File F-8-1

EIGHT
The Patch.asm File

If you have a problem with the initial installation of the generic version of the AT
BiosKit, this chapter may be of interest to you. Normally the generic Bios image
"at.bin n that is supplied on the distribution diskette will run on almost all AT system
boards, so that is where most readers start. If you are planning to make
modifications of the BiosKit, read this chapter anyway, as it will give you some ideas
on how to speed up checkout (also refer to the Chapter on "Loading Static Ram") by
eliminating the Prom Erase/Program cycle for your Bios Under Test. The contents
of the patch.asm program are a normal feature of the BiosKit, so the material in this
Chapter may help you to appreciate the BiosKit methodology.

This patch procedure may be useful to you if you are modifying the standard AT
Bioskit to you particular hardware configuration and you have access to a previously
configured Bios from another source. Its purpose is to provide a method to sense the
existence of a "test" copy of Bios in Ram, and transfer control to the "test" copy. This
patch will permit control to the transferred before any significant checks or
initialization is done by the other Bios.

This patch program was created during the early days of testing the AT Bios in static
ram. We were using a system with "another" Bios chip, and loading and running the
development Bios in Ram as described in Chapter F-l. The typical AT Bios has the
restart routines locked into the segment at F000, because they do not check for rom-
scan or secondary Bios until well into the Bios. In order to wrest control away from
the primary Bios residing at segment F000 immediately upon a hardware reset
signal, it was necessary to intercept the control flow at the very beginning of the
code. To provide for this, the patch sequence in this file was created. It is intended
to be loaded into a modified "other" Bios.

The typical Bios will have a reset control flow similar to the example shown below:

F000:FFF0 Jmp Far F000:E05B

F000:E05B Jmp Near - reset_code

F000:reset_code CLI ; disable interrupts

mov al,8F ; disable NMTs

Out 70,al ; write to CMOS

xxx ; and so on

xxx

The patch is intended to be patched in between the jump at F000:E05B and the
reset_code, so it looks like the example shown below:

F000:FFF0 Jmp Far F000-.E05B

F000:E05B Jmp Near - patch

F000:patch ... ; patch program in this file

; checks for test Bios and

F-8-2 The Patch.asm File

; transfers control if valid
jmp reset_code

F00Q:reset^code CU ; disable interrupts

mov al,8F ; disable NMI's

Out 70,al ; write to CMOS

s r ? s - ' xxx ; and so on

?hi>= &i\ \.y^ ; -- ■' xxx

To Install the patch, make a binary image copy of the "other" Bios using Debug. This

can -be done by the following

sequence:

Debug < enter > (call up debug)

nother.bin < enter > (name the file to be created)

res < enter > (examine the CS register)

xxxx (displays current value)

res xxyx <enter> (xxyx = xxxx + 10)

m f000:0000 1 4000 cs.OOOO < enter >

m f000:4000 1 4000 cs:4000 < enter >

m f000:8000 1 4000 cs:8000 < enter >

m fOOOxOOO 1 4000 cs:c000 <enter>

(this copies the bios to ram)
rbx 1 < enter > (this sets the length of the file)

rcxO < enter >

w cs:0 < enter > (this writes the file on disk)

q < enter > (this exits debug)

Now that you have an image of the "other" bios on disk, you may reload it (using
Debug), and find an unused area large enough to accommodate the patch program.
When a space has been found, the patch program may be inserted by using the
"asm" command and loading the code. Replace the old jump at E05B with a jump to
the patch, and use that original destination for the jump out of the patch.

After carefully checking that the patch is entered and linked correctly, use the "w"
command to rewrite the file to disk.

The modified file will need its checksum corrected. The Biossum program may be
used to calculate a new checksum. First though, you need to check the size of the
bios. Remember, we wrote a full 64k file for the binary file. Reload it using debug
and determine where code starts. If it is a typical assembly la nguag e version Bios,
the code will start at location 8000. Fill the area from 0000 to 7FFF with "FF" using
the debug "fill" command. The Biossum program will skip over "ff bytes, until it
finds a non-"ff byte and assume that checksumming should then begin. After you
have performed this fill (if required), then calculate a new checksum with the
following command:

Biossumother.bin < enter >

Finally, if two proms are required (even and odd bytes), run "Evenodd other" to /

produce the two binary images required. Program a set of modified proms (we

A-Tvoe BiosKit

The Patch.asm File F-8-3

strongly recommend you retain the original unaltered proms) and install and test
them in you machine.

This modified bios will then adhere to the standard Annabooks conventions for
secondary and test Bios', and you may proceed with developing arid testing' yoilr
personalized version of the AT BiosKit.

The patch file below is intended to provide you with a guide to creating the patching
code you will need, not necessarily an executable .EXE file. By assembling file with
a "MASM patch,,; < enter > " command, the listing file generated will illustrate the
object code required. The actual patching is most easily done by using thte ilasmf? o
command in the DOS Debug as described above. Therefore this module is provided -^
for reference only. : < r; r..- l* m

******************************************************** ....,.;

Copyright (c) FOSCO 1988 - All Rights Reserved !t

Module Name: Patch for "other" bios' for system checkout

Version: 1.00

Author: FOSCO

Date: 12-01-88

Filename: patch.asm

Language MS MASM 5.1

Functional Description:

This patch is intended to be patched into a non
Annabooks Bios to allow the secondary bios feature to
be used. The Annabooks Bios under development may then
be loaded into and executed from High- Ram in the D000
segment. The order of priority for selection
is:

1. D000 segment - test (usually Ram, may be Prom)

2. F000 segment - primary (Prom)

Version History: *-

.model small , .

.code ■■■•>.■:." *'■•■'■ .■'•/••

f-~j>

1

--i}

c*iii >

u

XO

-»

•;f

? ':■"' ^

i * v.

■) V'*'

' ■* ■stiff"

■3

v

* t . ..1:

'..> *

A

t, , .

r X&

L. -

;■*>*

■<:f

-., ■■ '

If,

Ml •■.

\i

check for bios' patched in

■ IV

If we find a Bios patch (by checking its signature), ,i

then we go to it. , /•■• ■. ,r a • .- fcofci.'-ji* :

patch a jump at F000:E05B to jump to "patch" ..»,- .-, w <- '.srif, m 'tsS.fi ..?OJ<

patch:

i'V W

mov ax,0d000h ; check seg dOOO

mov ds,ax ■■> *-"^--'- '-"■• * ■■ "■*

xor si, si ; check for bios signature , > *• -?vv f '.* ■'.->; }Jil^-^ - :} '

cmp word ptr ds:[si],05b1h "'", 4 "-;v * .'- ~, ; hq*'

jne checkz ; jumps if bad signature ' « • - «* * >*,.<** ; »

:then check for length count .... .-"."j ? ,4- tr*0'n r,i " v -"<'- $'**-<■"•

cmp byte ptr ds: [si+2] ,80h ' J * " " "* . ,,«,-:,;

jne check2 ; jump if bad length count ,.*>;> ...-fftfii .■'»■■&« ■•«•- •"> t -' i

xor ex, ex ; set 64k count

xor a I, a I ; clear checksum register , > a

checkl: . »•« > p J,'-^uIO juA^SDSO

add al,ds:[si] ; build checksum for 64K bytes

inc si ,,

loop checkl . v .~ ;f . . . <,-?') \' ,7iiJR"*i

or al,al ; zero = good *

jne check2 ; jumps if bad checksum * ■"* '\P--:

db Oeah ; jump to bios at dOOO

dw OfffOh

dw OdOOOh

SSi/hoiQ

Section F: Odds and Ends

F-8-4 The Patch.asm File

check2 :

jrap 1234h ; jump to E05B's original destination

; you must determine this location I

end

A-TVpe BiosKit