Hardware Interaction through C

Transcription

1 DOSSIER 21 Department of Computer Science & Information Technology / 21 Hardware Interaction through C C (and its object oriented version, C++) is one of the most widely used third generation programming languages. Its power and flexibility ensure that it is still the leading choice for almost all areas of application, especially in the software development environment. Many applications are written in C or C++, including the compilers for other programming languages. It is the language many operating systems are written in including UNIX, DOS and Windows. C has many strengths, which is the major reason that it has various diversified applications. It is flexible and portable; it can produce fast, compact code; it provides the programmer with objects to create and manipulate complex structures. But in my observation the major strength of C is its amazing competence in handling low level routines to control or interact with the hardware including input/output ports and operating system interrupts. This remarkable ability of this language makes it apt for system programming. This article presents you with a brief description of handling of various BIOS routines in C that are used to interact with the underlying hardware. Remember that although C is a portable language but the following routines are compatible with IBM PC and all generations of x86, original Intel 8086 and AMD compatible microprocessors, however Windows XP may overwrite some of the original interrupts. What is an interrupt? An interrupt is a hardware signal that tells the CPU to temporarily stop what it is doing and go do something else. Without interrupts the CPU would have to constantly check for external events; with interrupts the CPU can work on something else and still respond to an event as soon as it occurs. Apart from the external hardware interrupts, Intel 8086 family consists of a number of software interrupts also. Software interrupts are treated just like hardware interrupts, except that they are never disabled and do not result in an acknowledgement to other chips in the computer. There is an instruction provided by the Intel 8086 family for these software interrupts. This instruction is known as INT, and is given the number of the interrupt. BIOS (Basic I/O System) Interrupts All MS-DOS computers have some basic routines stored in read-only memory in the computer. These routines provide a mechanism for communicating with the keyboard and screen and other devices. This part of memory is given the title as BIOS (Basic Input/Output System). The BIOS can be thought of as coming between our C programs and the hardware of the computer itself. When we use a printf statement in our program, the compiler produces machine code which calls a subroutine in the BIOS to make characters appear on the computer screen. So generally we do not require working with BIOS but it provides with certain interrupts to interact with the hardware. DOS Interrupts The MS-DOS operating system provides a great many subroutines for disk handling, video card manipulation, keyboard access, file operations, time & date functions and so on. These routines are generally at a higher level than the BIOS routines, but they are invoked in a similar manner.

2 22 22 / Department of Computer Science & Information Technology / Department of Computer Science & Information Technology DOSSIER divided into two registers each of 8 bits namely the higher(h) and lower(l) order registers. One visual representation of the inter-relation of the computer, the BIOS, DOS and our C program is to think of the whole system as an onion, viz. As we move outwards through layers, the more machine independent our code should be and the vice versa. Thus we would expect printf to work satisfactorily on most machines with a C compiler. We would hope that DOS interrupts will work same way on all computers with the same version of MS-DOS, whereas BIOS interrupts will only work correctly on computers with an IBM compatible BIOS system Register Organisation The general idea about the registers organization of 8086 is necessary to implement the BIOS interrupts in C. Registers are the small amount of storage available on the CPU whose contents can be accessed more quickly than storage available elsewhere. Registers occupy the top level of the memory hierarchy. In 8086 there are in total 14 registers that are categorized as follows: General Purpose Registers there are 8 general purpose registers in 8086 that are used by the programmer for data manipulation. These registers are 16 bits long and they all are AX - the accumulator register (divided into AH / AL) BX - the base address register (divided into BH / BL) CX - the count register (divided into CH / CL) DX - the data register (divided into DH / DL) Index Registers The index registers can be used for arithmetic operations but there use is usually concerned with the memory addressing modes of They are Source Index Register (SI) and Destination Index Register (DI). SI - source index register: DI - destination index register: Pointer Registers They are not directly used by your program and thus have no real significance as far as this article is concerned. Segment Registers The segment registers have a very special purpose - pointing at accessible blocks of memory. They work together with index registers to access any memory location. CS- points at the segment containing the current program. DS - generally points at segment where variables are defined. ES - SS - extra segment register, it s up to a coder to define its usage. points at the segment containing the stack. Flags Registers They determines the current state of the processor. They are modified automatically by CPU after mathematical operations, this allows to determine the type of the result, and to determine conditions to transfer control to other parts of the program.

3 DOSSIER 23 Department of Computer Science & Information Technology / 23 Generally you cannot access these registers directly. The various bits are set to 1 if there corresponding conditions are satisfied otherwise they are set to 0. The bit pattern with their respective conditions is shown in the figure below. For further details about the flags and the conditions go through the architecture details of 8086 which would be available in any 8086 book. Thus REGS consists of two structure member whose definitions are as follows: struct BYTEREGS unsigned char al, ah, bl, bh ; unsigned char cl, ch, dl, dh ; ; struct WORDREGS unsigned int ax, bx, cx, dx ; unsigned int si, di, cflag, flags ; ; NOTE: ax, bx etc denotes the 16 bit registers while al, bl denotes lower order 8 bit registers and ah, bh denotes higher order 8 bit registers. cflag denotes the Carry Flag and flags denotes the 16 bit flag register. Interrupt Handling in C C language provides a union REGS, couple of structures (WORDREGS and BYTEREGS) and four functions to implement the above stated BIOS and DOS interrupts that enables the language to interact with the hardware including keyboard and I/O ports. These four functions including the structures and union are defined in <DOS.H> header file, and thus this header file has to be included in your program that implements these service routines. REGS (union) The union REGS is used to pass information to and from the available functions for interrupts handling. The definition of this union is as follows: union REGS struct WORDREGS x ; struct BYTEREGS h ; ; int86, int86x, intdos, intdosx These functions are used to implement general 8086 software interrupt routines. intdos and intdosx execute DOS interrupt 0x21 to invoke a specified DOS function. The value of inregs- >h.ah specifies the DOS function to be invoked. Both int86 and int86x execute an 8086 software interrupt specified by the argument intno. With int86x and intdosx, you can invoke an 8086 software interrupt that takes a value of DS (Data Segment) different from the default data segment, and/or takes an argument in ES (Extra Segment). Declaration int int86(int intno, union REGS *inregs, union REGS *outregs); int int86x(int intno, union REGS *inregs, union REGS *outregs, struct SREGS *segregs); int intdos(union REGS *inregs, union REGS *outregs); int intdosx(union REGS *inregs, union REGS *outregs, struct SREGS *segregs); Before the interrupt Before executing the software interrupt, these functions copy register values from inregs into the 8086 registers. int86x also copies the segregs->ds and segregs->es values into the

4 24 24 / Department of Computer Science & Information Technology / Department of Computer Science & Information Technology DOSSIER corresponding registers before executing the software interrupt. This feature allows programs that use far pointers or a large data memory model to specify which segment is to be used for the software interrupt. After the interrupt After the software interrupt returns, these functions copy the following: 1. Current register values to outregs. 2. Status of the carry flag to the x.cflag field in outregs. 3. Value of the 8086 flags register to the x.flags field in outregs. int86x and intdosx also restores DS and sets the segregs->es and segregs->ds fields to the values of the corresponding segment registers of If the carry flag is set, it usually indicates that an error has occurred and when an MS-DOS system call results in an error, _doserrno is set to the DOS error code. NOTE: inregs can point to the same structure that outregs points to. Return Value All functions return the value of AX after completion of the software interrupt. Examples int86() The following statements clear the screen by using BIOS interrupt 10H to first read the current video mode, then reset the video mode to its current mode: #include <dos.h> union REGS*/ inregs.h.ah = 0x0F; /*for int86() and /*set BIOS int86(0x10, &inregs, &outregs); / *read video mode*/ inregs.h.ah = 0; /*set BIOS inregs.h.al = outregs.h.al; /*set video mode number*/ int86(0x10, &inregs, &outregs); / *set video mode*/ screen)*/ /*also clears the int86x() The following statements read the boot sector (track 0, sector 1) of the disk in drive A: by calling BIOS interrupt 13h. #include <dos.h>/*for int86x(), macros FP_SEG() and FP_OFF(), struct SREGS*/ segread(), union REGS and #include <stdio.h> / *for printf()*/ #include <stdlib.h> / *for _doserrno*/ char buf [1024]; char far * bufptr; struct SREGS segregs; segread(&segregs); segment registers*/ /*set the bufptr = (char far *) buf;/*need a far pointer to buf */ segregs.es = FP_SEG(bufptr); /*...to set the address of*/

5 DOSSIER 25 Department of Computer Science & Information Technology / 25 inregs.x.bx = FP_OFF(bufptr); /*... buf for the BIOS */ inregs.h.ah = 2; inregs.h.al = 1; sectors to read*/ inregs.h.ch = 0; boot sector*/ inregs.h.cl = 1; boot sector*/ inregs.h.dh = 0; side number*/ inregs.h.dl = 0; number to A:*/ /*set the BIOS /*set # of /*set track # of /*set sector # of /*set disk /*set drive int86x(0x13, &inregs, &outregs, &segregs);/*read sector*/ if (outregs.x.cflag) printf( ERROR #%d: status = %d, # sectors read = %d\n, outregs.h.al); _doserrno, outregs.h.ah, intdos() The following statements print statistics about disk usage for drive A: #include <dos.h> and union REGS*/ /*for intdos() #include <stdio.h> / *for printf()*/ inregs.h.ah = 0x36;/*get disk free space inregs.h.dl = 1; /*drive A:*/ clusters, clusters, outregs.x.cx, intdosx() intdos(&inregs, &outregs); printf( %d sectors/cluster, %d outregs.x.dx); %d bytes/sector, %d total outregs.x.ax, outregs.x.bx, The following statements output string to the standard output. #include <dos.h> FP_SEG() and FP_OFF(), struct SREGS*/ struct SREGS segregs; char far *string = /*intdosx(), macros union REGS and this string is not in the default data segment$ ; inregs.h.ah = 0x9; /*output string inregs.x.dx = FP_OFF(string);/*DS:DX is far address of string*/ segregs.ds = FP_SEG(string); intdosx(&inregs, &outregs, &segregs); In the above examples the following interrupts have been used: INT 10h / AH = 0 - set video mode. Input: AL = desired video mode. These video modes are supported:

6 26 26 / Department of Computer Science & Information Technology / Department of Computer Science & Information Technology DOSSIER 00h - text mode. 40x colors. 8 pages. 03h - text mode. 80x colors. 8 pages. 13h - graphical mode. 40x colors. 320x200 pixels. 1 page. INT 13h / AH = 02h - read disk sectors into memory. INT 13h / AH = 03h - write disk sectors. Input: AL = number of sectors to read/write (must be nonzero) CH = cylinder number (0..79). CL = sector number (1..18). DH = head number (0..1). DL = drive number (0..3, for the emulator it depends on quantity of FLOPPY_ files). ES:BX points to data buffer. Return: CF set on error. CF clear if successful. AH = status (0 - if successful). AL = number of sectors transferred. Note: each sector has 512 bytes. INT 21h/AH=36h Input: DL = drive number (00h = default, 01h = A:, etc). Return: AX = FFFFh if invalid drive else AX = sectors per cluster BX = number of free clusters CX = bytes per sector DX = total clusters on drive INT 21h / AH=9 - output of a string at DS:DX. String must be terminated by $. Return: AL = 24h (the $ terminating the string, despite official docs which state that nothing is returned) (at least DOS and NWDOS). This article presents only a brief description of Interrupt handling through C and illustrates only a few interrupts with their usage. Nevertheless it still gives a very well estimation of the knack of C language to handle the interrupts and thereby interact with the underlying hardware. This incredible potency of this language makes it an asset for the system programmers. This article imparts a great deal of information on just a few couples of interrupts though if you want to study further in detail, you can find the complete list of interrupts on a web page titled Ralf Brown s Interrupt List Indexed HTML Version - Release 61 whose URL is References: 1. Oxford University Computing services C Programming Guide 2. Emulator8086 website Ralf Brown Interrupt list Help available in Turbo C v3.0 Compiler Ankit Chaudhary 04CS112