Subversion Repositories cpu8080

// Simulation plugs exist in this code. Look for "????? SIMULATION PLUG"

//

// Debug plugs exist in this code. Look for "????? DEBUG PLUG"

//

// The ADM 3A terminal emulation is based on "ADM 3A Dumb Terminal Users

// Reference Manual" of April, 1986.

//

// It performs the basic cursor motions, but there was no way to know what many

// of the exact cursor actions would have been in the real terminal, because

// those kinds of things are undocumented. This includes what occurs when the

// cursor moves left when already at the extreme left hand side, up when already

// at the top, if the cursor is moved to home on clear, etc. I am sure there are

// plenty of others, these will just have to be implemented as I find out more

// information, or encounter programs that rely on these features.

//

// These are terminal features there is no plans to implement:

//

// 1. ENQ or answerback mode.

// 2. Bell (where would it go?).

// 3. Ctrl-N and Ctrl-O keyboard locking and extention port.

// 4. Graphics modes (I don't believe this was in the original ADM 3A in any

//    case, but added later).

//

// These are terminal features that are not implemented, but will be:

//

// 1. Absolute cursor positioning.

// 2. Attribute codes.

//

`define term_clear4  4'h7 // clear screen and home cursor #4

`define term_fndstr  4'h8 // find start of current line

`define term_scroll  4'h9 // scroll screen

`define term_scroll1 4'ha // scroll screen #1

`define term_scroll2 4'hb // scroll screen #2

`define term_scroll3 4'hc // scroll screen #3

`define term_scroll4 4'hd // scroll screen #4

`define term_scroll5 4'he // scroll screen #5

`define term_scroll6 4'hf // scroll screen #6

   input        ps2_clk;  // clock from keyboard

   input        ps2_data; // data from keyboard

   output [7:0] diag;     // diagnostic 8 bit port

   reg [10:0]  tcursor; // cursor temp address

   // keyboard communication

   wire   [7:0] scancode;   // key scancode

   wire         parity;     // keyboard parity

   wire         busy;       // busy scanning code

   wire         rdy;        // ready with code

   wire         error;      // scancode error

   reg          scnrdy;     // scancode 

   reg          capslock;   // caps lock toggle

   reg          leftshift;  // state of left shift key

   reg          rightshift; // state of right shift key

   reg          leftctrl;   // state of left control key

   reg          rightctrl;  // state of right control key

   reg          relcod;     // release code active

   reg          extcod;     // extention code active

   wire   [7:0] asciidata;  // output of lookup rom

   wire   [7:0] asciidatau; // output of lookup rom

   reg          clrrdy;     // clear input ready

   // here we put signals out the diagnostic port if required.

   assign diag[0] = busy;

   assign diag[1] = rdy;

   assign diag[2] = scnrdy;

   assign diag[3] = ps2_clk;

   assign diag[4] = ps2_data;

   assign diag[5] = relcod;

   assign diag[6] = leftctrl;

   assign diag[7] = rightctrl;

   // codes on release, which has to be changed, since we need both asserts and

   // deasserts.

   scnromu kbdtblu(scancode, asciidatau); // lower case

   // process keyboard input state

   always @(posedge clock)

      if (reset) begin // perform reset actions

         leftshift <= 0; // clear left shift key state

         rightshift <= 0; // clear right shift key state

         leftctrl <= 0; // clear left control key state

         rightctrl <= 0; // clear right control key state

         capslock <= 0; // clear caps lock state

         relcod <= 0; // clear release status

         scnrdy <= 0; // clear key ready

   end else begin

      if (rdy) begin

          // if the release code $f0 occurs, set release until the next key occurs

          if (scancode == 8'hf0) relcod <= 1;

          // if the extention code $e0 occurs, set the extention flag

          if (scancode == 8'he0) extcod <= 1;

          else if (relcod) begin // release

             relcod <= 0; // reset release code

             // reset any extention code

             if (scancode != 8'hf0 && scancode != 8'he0) extcod <= 0;

             // if caps lock is hit, toggle caps lock status

             if (scancode == 8'h58) capslock <= !capslock;

             // process left and right shift key up

             if (scancode == 8'h12) leftshift <= 0; // left up

             if (scancode == 8'h59) rightshift <= 0; // right up

             // process control key up

             if (scancode == 8'h14) begin

                if (extcod) rightctrl <= 0; // right up

                else leftctrl <= 0; // left up

             end

          end else begin // assert

             scnrdy <= 1; // set key is ready

             // reset any extention code

             if (scancode != 8'hf0 && scancode != 8'he0) extcod <= 0;

             // process left and right shift key down

             if (scancode == 8'h12) leftshift <= 1; // left down

             if (scancode == 8'h59) rightshift <= 1; // right down

             // process control key down

             if (scancode == 8'h14) begin

                if (extcod) rightctrl <= 1; // right down

                else leftctrl <= 1; // left down

             end

          end

      end else if (clrrdy) scnrdy <= 0; // clear key ready

   end

   always @(posedge clock)

         // ????? SIMULATION PLUG

         // Don't clear screen, this takes too long in simulation

         // state <= `term_idle; // continue

         clrrdy <= 0; // set clear ready off

   end else begin

            // Return decoded keyboard, with shifting. The letter keys, 'a'-'z',

            // can be shifted by the shift keys, but not by caps lock state.

            // The other keys can be shifted by either. This matches PC 

            // behavior, which lets you have cap locks on without shifting the

            // letter keys. The control codes are shifted as a block from `($60)

            // to ~($7e) down to $00. This leaves out \US and \DEL, but these

            // codes get generated by the DEL key.

            if (asciidata >= 8'h60 && asciidata <= 8'h7e && (leftctrl || rightctrl))

               datao <= asciidata & 8'h1f;

            else if (asciidata >= 8'h61 && asciidata <= 8'h7a)

               datao <= leftshift||rightshift||capslock ? asciidatau: asciidata;

            else

               datao <= leftshift||rightshift ? asciidatau: asciidata;

            clrrdy <= 1; // clear scancode ready f/f

            datao <= (!outrdy << 7) | (scnrdy << 5); // return ready statuses

      end else clrrdy <= 0; // clear keyboard ready signal

      case (state) // run output state

               // process character after CPU goes away

                  if (chrdatw == 8'h0a) begin // line down (line feed)

                     if (cursor < 23*80) begin // not at screen end

                        cursor <= cursor+80;

                        wrtchr <= 0; // remove ready to write

                        outrdy <= 1; // set ready to send

                     end else begin

                        tcursor <= 0; // set temp cursor to screen start

                        state <= `term_scroll; // go to scroll screen

                      end

                  end else if (chrdatw == 8'h0b) begin // line up

                     if (cursor >= 80) cursor <= cursor-80;

                     wrtchr <= 0; // remove ready to write

                     outrdy <= 1; // set ready to send

                  end else if (chrdatw == 8'h0d) begin // carriage return

                     tcursor <= 0; // set start of line cursor

                     state <= `term_fndstr; // go to find start of line

                  end else if (chrdatw == 8'h08) begin // character left

                     // if not at home position, back up

                     if (cursor > 0) cursor <= cursor-1;

                     wrtchr <= 0; // remove ready to write

                     outrdy <= 1; // set ready to send

                  end else if (chrdatw == 8'h0c) begin // character right

                     // if not at screen end, go forward

                     if (cursor < 80*24-1) cursor <= cursor+1;

                     wrtchr <= 0; // remove ready to write

                     outrdy <= 1; // set ready to send

                  end else if (chrdatw == 8'h1e) begin // home

                     cursor <= 0; // set to home position

                     wrtchr <= 0; // remove ready to write

                     outrdy <= 1; // set ready to send

                  end else if (chrdatw == 8'h1a) begin // clear screen

                     state <= `term_clear; // go to screen clear

                     wrtchr <= 0; // remove ready to write

                     outrdy <= 1; // set ready to send

                  end else begin // unsupported control character

         end

            state <= `term_wrtstd4; // continue

         end

         `term_wrtstd4: begin // write standard character #3

         `term_fndstr: begin // find start of current line

            if (tcursor+80 > cursor) begin // found

               cursor <= tcursor; // set cursor to line start

               wrtchr <= 0; // remove ready to write

               outrdy <= 1; // set ready to send

               state <= `term_idle; // continue

            end else tcursor <= tcursor+80; // advance to next line

         end

         `term_scroll: begin // scroll screen up

            // move all data up a line

            if (tcursor < 80*23) begin // scroll up

               cmread <= 1; // set read display

               cmaddr <= tcursor+80; // set address to read

               state <= `term_scroll1; // continue

            end else state <= `term_scroll5; // go blank last line

         end

         `term_scroll1: begin // scroll screen up #1

            state <= `term_scroll2; // hold read

         end

         `term_scroll2: begin // scroll screen up #2

            cmdatai <= cmdata; // get data at address

            cmread <= 0; // turn off read

            state <= `term_scroll3; // continue

         end

         `term_scroll3: begin // scroll screen up #3

            cmdatae <= 1; // enable data to write

            cmwrite <= 1; // set to write

            cmaddr <= tcursor;

            state <= `term_scroll4; // continue

         end

         `term_scroll4: begin // scroll screen up #4

            cmwrite <= 0; // turn off write

            cmdatae <= 0; // turn off enable

            tcursor <= tcursor+1; // next address

            state <= `term_scroll; // repeat character move

         end

         `term_scroll5: begin // scroll screen up #5

            // blank out last line

            if (tcursor < 80*24) begin // blank out

               cmdatai <= 8'h20; // set to write spaces

               cmdatae <= 1; // enable data to write

               cmwrite <= 1; // set to write

               cmaddr <= tcursor;

               state <= `term_scroll6; // continue

            end else begin // terminate

               wrtchr <= 0; // remove ready to write

               outrdy <= 1; // set ready to send

               state <= `term_idle; // continue

            end

         end

         `term_scroll6: begin // scroll screen up #6

            cmwrite <= 0; // turn off write

            cmdatae <= 0; // turn off enable

            tcursor <= tcursor+1; // next address

            state <= `term_scroll5; // repeat blank out

         end

   end

      input [10:0]  cursor;  // cursor address

   reg  [7:0]  pixdatl; // pixel data low holding

      // starting the character counter at the end of the line allows the scan

      // to cross the area the CPU is filling, and is ok at hardware time.

      // chrcnt <= 7'h0; // clear counters

      chrcnt <= 80-20; // clear counters

      // ????? SIMULATION PLUG

      // Starting the row count at 1 allows pixels to appear on the simulation,

      // and produces only a single bad line in real hardware

      // rowcnt <= 5'h1;

   end else if (eof) begin // if end of frame

      chrcnt <= 7'h0; // clear counters

      rowcnt <= 5'h0;

      lincnt <= 5'h0;

      scnadr <= 11'h0;

      fchsta <= 1; // set to fetch first set of characters

            if (scnadr+chrcnt == cursor)

               pixdatl <= ~{ chrdata[0], chrdata[1], chrdata[2], chrdata[3],

                             chrdata[4], chrdata[5], chrdata[6], chrdata[7] };

            else

               pixdatl <= { chrdata[0], chrdata[1], chrdata[2], chrdata[3],

               pixeldata <= pixdatl |

                 (~{ chrdata[0], chrdata[1], chrdata[2], chrdata[3],

                     chrdata[4], chrdata[5], chrdata[6], chrdata[7] } &

                  8'hff) << 8;

            else

               pixeldata <= pixdatl |

      // The design of characters is such that they are embedded into an odd

      // number of pixels, 7x19, with one space pixel to the right and bottom

      // of each cell. The character layout works best on an odd cell width

      // and height, because this gives a clear center to the character.

      // Each characters baseline is marked. The baseline is where the capital

      // characters sit, and only the descenders go below this position.