Patent Publication Number: US-5293587-A

Title: Terminal control circuitry with display list processor that fetches instructions from a program memory, character codes from a display memory, and character segment bitmaps from a font memory

Description:
COPYRIGHT NOTICE 
     A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever. 
     BACKGROUND OF THE INVENTION 
     The present invention relates generally to terminal controllers and more specifically to techniques for placing characters on a display. 
     One of the main functions of a terminal is to place rows of characters on a screen. Associated with the terminal is a display memory (also sometimes referred to as a screen buffer, video buffer, or coax buffer), which stores a character code and attribute for each character position on the screen. The display data are updated from the keyboard and from communications with the host computer. Font bitmaps for the characters are typically stored in a separate non-volatile font memory. In order to place a row of characters on the screen, repeated accesses are made to the display memory, appropriate locations in the font memory are accessed to build up the row of characters, a scan line at a time. This is a fairly straightforward process, since a given position on the screen corresponds to a given location in the display memory, and a given character code corresponds to a known starting address in font memory, with the particular scan line providing a known and predictable offset. 
     One level of sophistication is the provision of one or more windows on the screen. In this context, a window refers to a region of the display which is to contain characters typically unrelated to the characters in the surrounding region. Normally, a separate window buffer is provided for the window, and relevant portions of the display memory are overwritten with a copy of the relevant portions of the window buffer. 
     Sophistication is sometimes another word for complication, which is the case here. Providing windows requires extra memory and extra overhead in transferring blocks of memory from one place to another. 
     A further level of sophistication is supporting interlaced scanning. As is well known, an interlaced display typically provides a given level of resolution at a cheaper price. A normal CRT controller typically supports either non-interlace or single interlace scanning. Support of three-way or four-way interlace would presumably require additional circuitry. 
     SUMMARY OF THE INVENTION 
     The present invention provides display control logic for a terminal controller with support for such features as windows and interlace. The invention operates in a manner that is flexible and efficient in terms of memory and circuitry. 
     The basis for the improved operation is a display list processor (DLP) having a small but powerful instruction set that allows scan lines to be built up in a very flexible way. The DLP communicates with a program memory containing DLP instructions, a display memory containing character codes and attributes for the display, and a font memory containing bitmaps for the character fonts. 
     As the DLP program executes, it causes accesses to the display memory and brings in character codes and attributes for ultimate display on the screen. These character codes and attributes, as well as information representative of the scan line are input to a video data queue. The queue entries are clocked out of the queue by a character clock synchronized to the display, the character code and scan line information is used to generate addresses to font memory, and the bitmaps are read from font memory into a dot shifter. The dot shifter is clocked out by a dot clock synchronized to the display. 
     The DLP instruction set includes a DISPLAY STRING instruction which allows a portion of a scan line to be built up by specifying the length of the scan line segment and the starting address in memory. Thus, by executing a series of such instructions, a scan line can be built up based on characters stored in different parts of memory. The instruction set also includes SET ROW, LOOP, and LOOPBACK instructions to specify a given row and to set up a loop so that all the scan lines in a given row of characters can be built up by repeated executions of the DISPLAY STRING instructions. 
     One consequence of the DLP&#39;s ability to create scan line segments of specified length and origin is that the scan lines and hence the rows of characters can be built up with portions taken from different parts of the memory. Thus windows can be set up without having to transfer data from one portion of memory to another. Rather, data is directly accessed and converted into bit streams. 
     Similarly, since the DLP builds up the display a scan line at a time, it is possible, by suitable programming, to display the scan lines in any random scan line order. However, the special looping instructions are provided to display scan lines sequentially. By incrementing the loop counter by amounts other than one, it is possible to make interlaced, tri-interlaced, and quad-interlaced displays without any special hardware. 
     In a preferred embodiment, the DLP is incorporated into a single-chip terminal controller which also includes a RISC-based processor for handling terminal communications and other non-display operations. Program and data memories are preferably off-chip for flexibility. An external micro-processor may be used to support high-end terminal operations. 
     A further understanding of the nature and advantages of the present invention may be realized by reference to the remaining portions of the specification and the attached drawings. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     FIG. 1 is a block diagram of a single chip terminal controller embodying the present invention, including its connections with associated memories; 
     FIG. 2 is a block diagram of the display control logic portion of the terminal controller chip; 
     FIGS. 3A and 3B together provide a detailed block diagram of the display control logic; and 
     FIGS. 4A and 4B together provide a timing diagram illustrating display list processor instruction execution. 
    
    
     DESCRIPTION OF SPECIFIC EMBODIMENTS 
     System Overview 
     FIG. 1 is a block diagram of a single chip terminal controller (TC) 10 and associated memories including a system memory 12 and a font/code memory 13. TC 10 includes two on-board processors, a main processor, referred to as micro-engine 15 (with an associated sequencer 17 and on-chip ROM 18) for handling terminal and communication operation, and a display list processor (DLP) 20 (with associated sequencer 22) for handling the display. Micro-engine 15 communicates with a number of peripheral interfaces via an internal data bus 25. These include a keyboard controller 30, a light pen interface 32, a printer port 35, a set of timers 37, a serial (coax) interface having a coax transmitter 40 and a coax receiver 42, a set of external I/O ports 43 (which include a buzzer interface), and clock select logic 44. DLP 20 communicates with an attribute decoder 45 (having associated download logic) and associated video interface 47 to control a display such as a monochrome or color monitor (not shown). 
     System memory 12 is implemented as two 8K×8 static random access memory (SRAM) chips (one 32K×16 or two 32K×8 maximum) and is used to store micro-engine and DLP programs, video data for refresh, and coax data. Font/code memory 13 is implemented as a 32K×8 electrically programmable read only memory (EPROM) chip (64K×16 maximum) and is used to store font bitmaps for the display. It is also used to store code for downloading to system memory 12 at power up. The portions of font/code memory 13 used to store the fonts will sometimes be referred to as font memory. 
     Micro-engine 15 and DLP 20 are coupled via respective internal buses to a bus interface 50, which provides address lines 52 and bidirectional data lines 53 to system memory 12. A three-way arbiter 55 arbitrates cycles to allow the micro-engine, the DLP, and an optional external processor to access the memory. 
     Attribute decoder 45 is coupled to font/code memory 13 via address lines 57 and data lines 58, and to internal data bus 25 via a set of lines 60. The latter connection provides a data path between font/code memory 13 and system memory 12, thereby making it possible for logic associated with attribute decoder 45 to download code stored in the font/code memory to the system memory at power up. This is advantageous since SRAMs are typically much faster than EPROMs. 
     Micro-engine 15 is a high-speed reduced instruction set computer (RISC) for handling terminal operation, and has three states, a main state, a coax state, and an interrupt state. It includes an ALU, general purpose registers and special purpose registers associated with the various states, an accumulator with a zero, carry, and overflow flag for each state, and a program counter for each state with a three-deep pushdown stack for the main state. On-chip ROM 18 contains an initial program loader (IPL) which is executed at power up to effect the downloading from font/code memory 13 to system memory 12. 
     DLP 20 with its associated sequencer 22, attribute decoder 45, and video interface 47 provides overall display control. Sync signals for the display monitor and display format management are generated as a result of executing a sequence of instructions stored in system memory 12. The DLP retrieves character code and attributes from the display buffer in system memory 12 while logic associated with the attribute decoder retrieves character font information from font memory 13 so as to define the actual signals sent to the display. The DLP is pipelined and buffered to be able to sustain a 60 MHz video pixel rate without screen flickers. The attribute decode logic handles the 3270 attributes and supports background color select, color remapping, 2/4 color mode select, and the like. Video interface 47 provides RGB color signals for a color monitor (or a mono signal for a monochrome monitor), an intensity signal, horizontal and vertical sync signals, and video dot clock signals. 
     Keyboard interface 30 allows direct connection to an AT or PS/2 style keyboard. The interface provides open collector bidirectional pins for data and clock information for the data being exchanged. Printer interface 35 provides a bidirectional parallel port data bus and a number of control signals. 
     Data for coax transmission is encoded using the bi-phase Manchester II technique which has a fixed bit rate of 2.3587 MHz. In this encoding, the first half of the bit cell consists of the complementary data and the second half of the bit cell is the true data. There is always a central bit transition in the normal bit cell except in the transmission starting sequence which have the code violations in the frame. Received coax data is assumed to have the same encoding, and is decoded accordingly. 
     Clock select logic 44 performs a number of functions. First, it receives as inputs up to three external clock signals, designated DX1, DX2, and DX3, and provides as an external output a buffered version of DX1, designated DCLK1. Second, it responds to signals on data bus 25 to select one of the input clocks for micro-engine 15 and one for the video. Third, it receives the 18.8696-MHz X1 clock (input to coax receiver 42), and provides a frequency divided version (÷8), called the slow clock, for use by timers 37 and by the micro-engine at power up and during downloading from font/code memory 13 to system memory 12. 
     In one implementation, DX1 is 26.288 MHz and is used for both the micro-engine and display; in another DX1 is 35 MHz and is used for the micro-engine while DX2 is 64 MHz and is used for the display. 
     Arbiter 55 arbitrates cycles to allow micro-engine reads and writes, DLP instruction reads, DLP data reads, micro-engine coax interrupt processing, and (optional) external processor reads and writes. To this end, the arbiter receives micro-engine coax interrupt requests, DLP instruction requests, DLP data requests, and external processor requests on respective request lines 61, 62, 63, and 64. Memory cycles are granted by asserting signals on respective grant lines 66, 67, 68, and 69. 
     Display Control Logic Overview 
     FIG. 2 is a block diagram of DLP 20, attribute decoder 45, and video interface 47, which together constitute the display control logic. The basic operation is the fetching and execution of DLP instructions so as to generate a stream of character codes and other information, and the conversion of the codes and other information to video information for the display, as will now be described. 
     As a prefatory matter, it is noted that a portion of system memory 12 is dedicated to a display buffer in which are stored character codes (e.g., device buffer code representations) and other information such as character and line attributes. Another portion of the system memory is used to store instructions for the DLP. 
     Instruction sequencer 22 generates addresses to system memory 12 to access stored DLP instructions. These instructions are loaded into a pipelined instruction queue 75 that includes an instruction register (IR) 77, an initial instruction processor (IIP) 80, a holding register set 82 (also referred to as Platform 1 or P1), and an execution register/counter set 85 (also referred to as Platform 2 or P2). A certain class of DLP instructions, referred to as control instructions, are immediately executed by IIP 80 while other instructions, referred to as video instructions, are formatted and passed on to holding register set 82. The IIP may also add existing information that is not present in the current video instruction. 
     The video instructions include portions that relate to timing and portions that relate to the character codes and attributes to be displayed. The timing fields are communicated to a timing generator 87 while the other portions are communicated to a display data access machine 90. For those video instructions requiring access to system memory 12, display data access machine 90 generates memory addresses to the display buffer in system memory 12, and appropriately formats the display data received from the display buffer. For other instructions, it may pass the information through. The outputs from display data access machine 90 are communicated to a 10-deep video data queue 95. The DLP instruction set has the property that it allows portions of the display buffer to be accessed in any desired order. 
     Attribute decoder 45 receives the character codes and control information from video data queue 75. Associated logic generates suitable addresses to access the relevant portions of font memory 13. The DLP instruction set has the property that it allows portions of the font memory to be accessed in any desired order. 
     Attribute decoder 45 decodes the display and attribute data from the video data queue, and performs the corresponding 3270 coax attribute functions. The 3270 coax attribute include field, extended field, and character attributes. 
     The field attribute occupies one character position in the display buffer and is stored as a non-displayable character (actually displayed as a blank). Display related field attributes may specify intensified and non-displayable. 
     The extended field attribute is stored in the attribute buffer but is not displayed. It allows for blinking, reverse video, underscore, seven-color, and character font select. The character attribute is stored in the attribute buffer and controls the characteristics of each character on the screen. It allows for blinking, reverse video, underscore, seven-color, and character font select. 
     Display List Processor (DLP) Instruction Set 
     DLP 20 executes a small but powerful instruction set that provides considerable flexibility in creating characters on the display. As will be described in greater detail below, the DLP instructions provide for building a display structure on a scan line by scan line basis, with a do-loop type instruction provided to generate all the scanlines of a single character row. The vertical retrace pulse can be programmed to occur anywhere on the scanline for use with interlace, or quad-/tri-interlace modes if so desired. 
     The instruction set includes a set of video instructions and a set of control instructions. The video instructions include a DISPLAY STRING instruction, a REPEAT CHARACTER instruction, a WINDOW instruction, and a set of BLANK DISPLAY instructions. The control instructions include a LOAD instruction, a LOOP instruction, a SET CURSOR instruction, and a SET ROW COUNTER instruction. The video instruction formats are set forth in Tables 1A-D, and the control instruction formats are set forth in Table 1E. 
     Each video instruction includes one-bit fields for horizontal pulse (HP) and vertical pulse (VP). If the HP bit is set, the horizontal pulse will be generated. This provides the programmer total control over where the pulse starts on a scan line and where it ends, and thus allows the sync pulse to come any time during or before blanking. The VP bit provides the same flexibility. A number of the video instructions also contain a one-bit field specifying an interrupt to micro-engine 15. This allows the interrupt to be generated anywhere in the active video area, i.e., synchronized to a particular display point on the screen or at the start of blanking. 
     The DISPLAY STRING instruction allows a scan line to be built up in segments from various parts of memory. The instruction specifies a starting address for sequential display, namely, the address from which accesses have to start. This address is automatically incremented at the end of each memory read. It also specifies a length of string (less one), which is counted down to zero before the next display list instruction is executed, while displaying each character sequentially from the address indicated. The DISPLAY STRING instruction accesses the display buffer in system memory 12 for character code and attribute and the font memory 13 for the actual bit pattern as many times on every scanline as there are characters in a row. The instruction also specifies a status line indicator, which if set, causes the attribute data to be loaded from a fixed-status attribute register, and all display memory accesses yield character code data only. 
     The REPEAT CHARACTER instruction is used to generate the window border and overscan regions. The instruction specifies the character code and attribute, and the number of repetitions (less one) of the character. The instruction does not access system memory 12 and accesses font memory 13 only once per repeated character per scan line. (In a present version, the REPEAT CHARACTER instruction ignores the character code and only repeats the background color.) 
     The WINDOW instruction is executed at the start or end of a window scanline and creates the configuration necessary for the window, which may be totally different from the background display. 
     The four BLANK DISPLAY instructions are used to generate the blanking pulse for a specified number of character times during each scanline. In addition to specifying the length of the blanking pulse (in terms of character times), the instructions specify a 15-bit address of the next DLP instruction to be executed. The next DLP instruction address must be calculated during the blanking period, especially for those instructions that have to be synchronized to the display timing. The instructions include NOP (opcode=00), which performs no function other than those outlined above, and JUMP (opcode=01), LOOPBACK (opcode=10), and INCREMENT LOOP COUNTER (opcode=11) instructions, each of which performs another function in parallel. 
     The JUMP instruction specifies an end-of-screen jump to the start of the display list indicated by the next display list address field. 
     The LOOPBACK instruction specifies looping back to the next scan line of the present character box. During this time the loop counter is first incremented by a value determined by the F1 and F0 bits and then compared with the final value. If the counter value exceeds the final value, loopback is not performed, and the next consecutive display list instruction is executed. Otherwise, loopback occurs to the address specified in the address field. The loop increment is 1 for F(1:0)=00, 2 for F(1:0)=01, 3 for F(1:0)=10, and 4 for F(1:0)=11. 
     The INCREMENT instruction causes the loop counter to be incremented by an offset given by the value defined by the F0 and F1 bits, but performs no comparison or branch. 
     The control instructions do the flow control for the video instructions and the housekeeping chores for the display, such as cursor controls, color palettes, etc. There are two formats for these instructions, 32-bit and 16-bit. The 16-bit format is used for control operations they have a very high frequency of use. 
     The 32-bit LOAD instruction specifies the initialization of a designated destination register with 16-bit data. The seven possible destination registers are the attribute for the status line, the primary cursor coordinates, the print-box start coordinates, the print-box end coordinates, and three display configurations. 
     The 16-bit LOOP instruction (bit(12)=0, opcode=01) specifies a range of scan rows, and causes a loop on the succeeding instructions until a LOOPBACK instruction is encountered. The loop counter is started at the specified start value and finished when the loop counter exceeds the specified stop value. 
     The 16-bit SET CURSOR instruction (bit(12)=0, opcode=10) sets the cursor column or row register to the specified 8-bit value. One bit specifies whether the row register or the column register is to be set. 
     The 16-bit SET ROW instruction (bit(12)=1) loads the specified 5-bit value into the screen row register. 
     Display Control Logic Details 
     FIGS. 3A and 3B are detailed block diagrams of the display control logic illustrated in FIG. 2. FIG. 3A shows the various elements that define instruction sequencer 22, instruction register 77, portions of initial instruction processor 80, holding register set 82, and execution register/counter set 85. FIG. 3B shows the elements that define timing generator 87, data access machine 90, video data queue 95, attribute decoder 45, and video interface 47. Portions of execution register/counter set 85 are shown in phantom in FIG. 3B in order to facilitate correlation with FIG. 3A. 
     FIGS. 4A and 4B provide a timing diagram illustrating the execution of DLP instructions to the point where entries are loaded into video data queue 95. Two time bases are relevant to the operation of the display control logic. As noted above, DLP instructions and character codes and attributes must be fetched from system memory 12. Since access to the system memory is arbitrated with other devices in the system, most notably micro-engine 15, the portions of the display control logic that require memory accesses are based on timing established by memory cycles. A memory cycle is divided into time units designated TU0, TU1, TU2, and TU3. The data are then loaded into video data queue 95 based on this timing. A different time base is used for reading data out of the video data queue and transforming it to a video signal. Timing for these operations is determined by a dot clock synchronized to the display and a character clock based on the dot clock. 
     A program counter 115 specifies an address in system memory from which a DLP instruction is fetched and loaded into instruction register (IR) 77, which is clocked by the trailing edge of TU3. Decoding occurs immediately at an instruction decoder 120, and control instructions are executed (as will be discussed more fully below). Holding register set 82 includes a set of registers, different subsets of which are loaded depending on the instruction, as defined by instruction decoder 120. These include a Scan Stop register 122, a Scan Count register 125, a Video Timing register 127, a Font/Color register 130, a Count Value register 132, a Code/Address register 135, and a Scan Row register 137. Additionally, a portion of the instruction may be loaded into one side of an adder 140 associated with Scan Count register 125. 
     The contents of holding register set 82 are passed on, for the most part, to corresponding elements in execution register/counter set 85. Specifically, the content of Scan Stop register 122 and the output from adder 140 are communicated to a comparator 150; the content of Scan Count register 125 is communicated to the other side of adder 125 and to a Scan Line register 152; the contents of Video Timing register 127 and Font/Color register 130 are communicated to respective corresponding registers 155 and 157; the content of Count Value register 132 is loaded into a down counter 160; and the content of Code/Address register 135 is loaded into an address counter 162. 
     Scan Count register 125 is initially loaded from instruction register 77 to set up a loop, but is subsequently updated from the output of adder 140 during iterations within the loop. 
     As alluded to above, the display control logic includes a set of seven 16-bit registers 200. These can be loaded by the LOAD instruction (one of the control instructions) and are used to provide information for cursor and rule logic 202 and alternate data for font/color register 130. 
     Registers 200 and program counter 115 can also be loaded or modified directly by micro-engine 15 via a micro-engine interface 205. The interface includes three internal 8-bit I/O ports, one of which is used as a control register and the other two of which are used to form a 16-bit I/O data port. The control register includes a Write Enable bit, a Display List Access bit, a complementary Reset bit, and a 4-bit field designating a particular one of registers 200 (or program counter 115). At power up, all the bits are cleared so that the DLP will start up in the reset state, and until the micro-engine writes a 1 in the complementary Reset bit, the DLP will remain in the reset state. This allows the micro-engine to selectively turn the DLP (and hence the display) on or off. 
     Display List Processor Operation 
     The operation of the DLP may be explained with reference to the execution of a specific instruction sequence to display a line of characters on the screen. Assume that it is desired to display the first row of the display with 80 characters whose codes are stored in contiguous locations in the system memory starting at address Start1. For illustrative purposes, a simplified assembler language will be used. Numbers are in decimal, and counts are assumed to go from 1 to N as opposed rather than 0 to (N-1). 
     A representative sequence of instructions, written in the simplified assembler language, would be as follows: 
     SET ROW 1 
     LOOP 1, 16 
     LOOP1: 
     DISPLAY STRING Start1, 80 
     NOP 3 
     NOP 6, HP 
     LOOPBACK 5, LOOP1 
     The above sequence consists of: 
     (1) a SET ROW instruction to specify the first row on the display; (2) a LOOP instruction to set up a loop for 16 scan lines; (3) a DISPLAY STRING instruction within the loop to generate one scan line of display characters for each pass through the loop; (4) two NOP instructions within the loop to display blanks and set up the horizontal pulse for each pass through the loop; and (5) a LOOPBACK instruction to close the loop. 
     The execution of this instruction sequence will now be described with specific reference to the DLP elements described in connection with FIGS. 3A-B. 
     The SET ROW instruction is a 16-bit control causes the row number to be set to the value specified. This instruction causes the specified value (in this case 1) to be loaded into Scan Row register 137. 
     The LOOP instruction is a 16-bit control instruction specifying the scan lines to be processed within the loop. This instruction causes the starting scan line (0) to be loaded into Scan Count register 125 and the ending scan line (15) to be loaded into Scan Stop register 122. 
     The DISPLAY STRING instruction specifies the starting address and length of a string of characters to be displayed as part or all of a row on the display. This instruction initiates a request for memory and causes the length of the character string (80) to be loaded into Count Value register 132 and the starting address (Start1) to be loaded into Code/Address register 135. 
     These values are then loaded into down counter 160 and address counter 162 when the counters are available. This will be the case, for example, at startup or when a previous instruction has finished execution. The address stored in address counter 162 is applied to the system memory, and the character code and attribute are retrieved. Upon successful completion of the memory read, the down counter is decremented and the address counter is incremented. At this time, the character code and attribute from memory, along with the content of Scan Line register 152 and the font code from Font/Color register 130 are loaded into video queue 95. This sequence continues until down counter 160 reaches zero, which signifies the correct number of characters on the scan line have been entered into the queue. At this point, the next instruction is executed. This is a NOP instruction whose effect is to generate a specified number of blanks. The specified number of blanks is loaded into Count Value register 132 and the character code and attribute for a blank are loaded into Code/Address register 135. These are transferred to down counter 160 and address counter 162. Down counter 160 is decremented while address counter 162 is allowed to act as a simple register. The content of address counter 162 is passed directly through data access machine 90 without accessing memory. The appropriate number of queue entries are made, at which point the next instruction is executed. 
     The next instruction is also an NOP, which generates a number of blanks, but has the horizontal pulse bit set. This is passed through timing registers 127 and 155 to the timing logic to end the scan line. 
     The next instruction is a LOOPBACK instruction, which generates a number of blanks and increments the loop counter stored in Scan Count register 125. If the value stored in Scan Count register 125 has not exceeded the value stored in Scan Stop register 122, the address field in the LOOPBACK instruction is loaded into program counter 115. This causes another pass through the loop to allow the next scan line to be processed. The entire process (execution of DISPLAY STRING and NOP instructions) is repeated 15 times until the value stored in Scan Count register 125 has reached the value stored in Scan Stop register 122. 
     As these instructions are being executed, and the character codes and attributes are being loaded into the top of the queue, previous entries are read out at the bottom of the queue at a rate determined by the character clock. The character clock is a signal having a frequency that is a sub-multiple of the dot clock frequency, as determined by a divider 170. 
     The queue entries are then read out into font type, scan line, character code, and attribute registers 172, 175, 177, and 180. For each entry read out of the queue, the font type, character code, and scan line, in that order, are used to define an address to font/code memory 13, and the data returned from that memory is applied to a dot shifter 190. Dot shifter 190 is clocked by the dot clock, and provides the actual bit stream(s) that define(s) the modulation of the video signal. The character code and attribute stored in registers 177 and 180 are applied to attribute decoding circuitry 45. 
     Thus, it can be seen how the SET ROW, LOOP, DISPLAY STRING, NOP, and LOOPBACK instructions operate to allow building a row of characters, character slice by character slice within a given scan line, and scan line by scan line to make up the full row of characters. The operation of the DLP to execute the other instructions is summarized below. 
     The REPEAT character instruction causes the specified number of repetitions (less 1) to be loaded into Count Value register 132 and the specified character code and attribute to be loaded into Code/Address register 135. The character code and attribute are then passed to address counter 162, and made directly available to the queue since no memory access is required. 
     The JUMP instruction (one of the BLANK DISPLAY instructions) causes the specified next DLP instruction address to be loaded into program counter 115. It is noted that the NOP instructions do not affect the program counter. The INCREMENT LOOP COUNTER instruction performs like the LOOPBACK instruction but does not cause a branch. 
     The WINDOW instruction causes the specified window border character code and attribute to be loaded into Code/Address register 135 and the font select field to be loaded into Font/Color register 130. This is set up only, since the actual window coordinates are defined by the program. 
     Display List Processor Timing 
     The timing diagram shown in FIGS. 4A and 4B illustrates the execution of a number of DLP instructions stored in memory locations starting at 0004. The cycles are numbered from #0, and a particular access to memory occurs as a result of arbitration. In the particular implementation, the two 16-bit words of a 32-bit instruction are fetched from adjacent locations in separate memory cycles. The high word is written into both halves of IR 77 and the low word is then written into the lower half of the IR. In the specific example, the contents of the memory locations starting at 0004 are as follows: 
     
         ______________________________________                                    
Memory Location (Hex)                                                     
                 Content (Hex)                                            
______________________________________                                    
0004             8004                                                     
0005             000A                                                     
0006             6000                                                     
0007             1007                                                     
0008             4801                                                     
0009             0004                                                     
______________________________________                                    
 
    
     Locations 0004 and 0005 contain a DISPLAY STRING instruction specifying five characters starting at location 000A. Locations 0006 and 0007 contain a REPEAT instruction with a specified character. Locations 0008 and 0009 contain a JUMP to location 0004 with a two-character video blanking period. 
     During Cycle #10 (granted for a display instruction fetch) 0004 appears on the display address bus and the memory content (8004) is written into both halves of IR 77. P1 (holding register set 82) and P2 (execution register/counter set 85) are empty. 
     Cycle #1 is granted to the micro-engine. 
     During Cycle #2 (display instruction fetch) 0005 appears on the display address bus and the memory content (000A) is written into the lower half of IR 77. 
     During Cycle #3 (granted to the micro-engine) the content of the IR (DISPLAY STRING instruction) is loaded into P1. 
     During Cycle #4 (display instruction fetch) 0006 appears on the display address bus, the memory content (6000) is loaded into both halves of IR 77, and relevant portions of P1 are loaded into P2. 
     During Cycle #5 (granted for a display data fetch) the DISPLAY STRING instruction commences execution. 000A (the starting address specified in the DISPLAY STRING instruction) appears on the display address bus, and the fetched data from 000A (and the relevant portions of P2) are loaded into video queue 95. 
     During Cycle #6 (display instruction fetch) 0007 appears on the display address bus and the memory content (1007) is written into the lower half of IR 77. 
     During Cycle #7 (display data fetch) 000B appears on the display address bus, the content of IR 77 (REPEAT instruction) is loaded into P1, and the fetched data from 000B is loaded into the video queue. 
     The IR is loaded with the JUMP instruction during Cycles #8 and #10, separated by a data access from location 000C during cycle #9. At this point, however, the instruction pipeline is full, so the DLP will not make requests for display instruction fetches from memory. Cycles #11 and #12 are granted for display data fetches from locations 000D and 000E and corresponding queue entries are made. Once location 000E has been accessed, down counter 160 signifies the end of the count for the DISPLAY STRING instruction. The REPEAT instruction, which was waiting in P1, can now be loaded into P2 for execution, and the JUMP instruction in the IR is loaded into P1. At this point, a new instruction fetch cycle may be requested. 
     Random Display of Character Memory 
     The DISPLAY STRING instruction provides flexibility and efficiency in displaying rows of characters. More specifically, a row of characters on the display can be built up piecemeal from different parts of memory by programming a sequence of DISPLAY STRING instructions, each specifying the starting address of a portion of the line, and the number of characters in that portion. A significant use of this versatility is for placing windows on the display without requiring data transfers between memory locations. 
     A representative sequence of simplified assembler language instructions for setting up the ninth and tenth rows including the top border and first row of the window is as follows: 
     SET ROW 9 
     LOOP 1, 16 
     LOOP9: 
     DISPLAY STRING Start9, 20 
     WINDOW (Left Corner Char), Attr 
     REPEAT (Border Char), Attr, 39 
     WINDOW (Right Corner Char), Attr 
     DISPLAY STRING (Start9+61), 19 
     NOP 3 
     NOP 6, HP 
     LOOPBACK 5, LOOP9 
     SET ROW 10 
     LOOP 1, 16 
     LOOP10: 
     DISPLAY STRING Start10, 20 
     WINDOW (Border Char), Attr 
     DISPLAY STRING Startwin, 39 
     WINDOW (Border Char), Attr 
     DISPLAY STRING (Start10+61), 19 
     NOP 3 
     NOP 6, HP 
     LOOPBACK 5, LOOP10 
     In this sequence the starting address Start10 for row 10 is equal to Start9+80 since it is assumed that the background screen characters are stored in contiguous locations. Similarly, subsequent rows of the window will have starting addresses incremented by the window width (assuming the window characters are stored in contiguous locations). 
     Discussion of the Software 
     Appendix 1 (Copyright © 1990, Unpublished Work, Chips and Technologies, Inc.) provides a source code listing of DLP instructions for generating the display data for a 24×80 display without interlace. The loop increment is 1 (F(1:0)=00). 
     Appendix 2 (Copyright © 1990, Unpublished Work, Chips and Technologies, Inc.) provides a source code listing of DLP instructions for generating the display data for a 24×80 display with interlace. The loop increment is 2 (F(1:0)=01). 
     In the specific examples, an extra non-display control character is read out at the beginning of each scan line. Additionally, the window borders are drawn using the DISPLAY STRING instruction rather than the REPEAT CHARACTER instruction. 
     CONCLUSION 
     While the above is a complete description of the preferred embodiments of the invention, various alternatives, modifications, and equivalents may be used. Therefore, the above description should not be taken as limiting the scope of the invention which is defined by the appended claims. 
     
                       TABLE 1A                                                    
______________________________________                                    
DISPLAY STRING INSTRUCTION FORMATS                                        
Bit(s)         Field/Value                                                
______________________________________                                    
31..30         10                                                         
29             Reserved                                                   
28             Status Line Indicator                                      
27             Interrupt to Micro-Engine                                  
26             Reserved                                                   
25             Horizontal Pulse                                           
24             Vertical Pulse                                             
23..16         Length - 1                                                 
15             0                                                          
14..0          Starting Address                                           
______________________________________                                    
 
    
     
                       TABLE 1B                                                    
______________________________________                                    
REPEAT CHARACTER INSTRUCTION FORMAT                                       
Bit(s)         Field/Value                                                
______________________________________                                    
31..29         011                                                        
27             Interrupt to Micro-Engine                                  
26             0                                                          
25             Horizontal Pulse                                           
24             Vertical Pulse                                             
23..16         No. to Repeat - 1                                          
15..8          Character Code                                             
7..0           Character Attribute                                        
______________________________________                                    
 
    
     
                       TABLE 1C                                                    
______________________________________                                    
WINDOW INSTRUCTION FORMAT                                                 
Bit(s)         Field/Value                                                
______________________________________                                    
31..30         11                                                         
29..28         Reserved                                                   
27..26         Language Font Select                                       
25             Horizontal Pulse                                           
24             Vertical Pulse                                             
23             Horizontal Rule Enable                                     
22             Vertical Rule Enable                                       
21..20         Reserved                                                   
15..8          Window Border Character                                    
7..0           Window Border Attribute                                    
______________________________________                                    
 
    
     
                       TABLE 1D                                                    
______________________________________                                    
BLANK DISPLAY INSTRUCTION FORMAT                                          
Bit(s)        Field/Value                                                 
______________________________________                                    
31..29        100                                                         
28            Interrupt to Micro-Engine                                   
27..26        Opcode                                                      
25            Horizontal Pulse                                            
24            Vertical Pulse                                              
23            F1                                                          
22..16        Width - 1                                                   
15            F0                                                          
l4..0         Next DLP Instruction Address                                
Opcodes                                                                   
00            No Op                                                       
01            Jump                                                        
10            Loopback                                                    
11            Increment Loop Counter                                      
______________________________________                                    
 
    
     
                       TABLE 1E                                                    
______________________________________                                    
CONTROL INSTRUCTION FORMATS                                               
LOAD                                                                      
Bit(s)           Field/Value                                              
______________________________________                                    
31..29           000                                                      
28               0                                                        
27..26           Opcode = 00                                              
25..20           Reserved                                                 
19..16           Destination Register                                     
15..0            16-bit Data                                              
______________________________________                                    
LOOP                                                                      
Bit(s)           Field/Value (hex)                                        
______________________________________                                    
15..13           001                                                      
12               0                                                        
11..10           Opcode = 01                                              
9..5             Starting Scan Line                                       
4..0             Ending Scan Line                                         
______________________________________                                    
SET CURSOR                                                                
Bit(s)           Field/Value (hex)                                        
______________________________________                                    
12               0                                                        
11..10           Opcode = 10                                              
9                0                                                        
8                Row if 1, Column if 0                                    
7..0             Cursor Row/Col Value                                     
______________________________________                                    
SET ROW COUNTER                                                           
Bit(s)           Field/Value (hex)                                        
______________________________________                                    
12               1                                                        
9                1                                                        
4..0             Row Counter                                              
______________________________________                                    
 ##SPC1##