Subversion Repositories layer2

--------------------------------------------------------------------------------
-- PS2 Keyboard Controller                                                    --
--------------------------------------------------------------------------------
-- Copyright (C)2011  Mathias Hörtnagl <mathias.hoertnagl@gmail.comt>         --
--                                                                            --
-- This program is free software: you can redistribute it and/or modify       --
-- it under the terms of the GNU General Public License as published by       --
-- the Free Software Foundation, either version 3 of the License, or          --
-- (at your option) any later version.                                        --
--                                                                            --
-- This program is distributed in the hope that it will be useful,            --
-- but WITHOUT ANY WARRANTY; without even the implied warranty of             --
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              --
-- GNU General Public License for more details.                               --
--                                                                            --
-- You should have received a copy of the GNU General Public License          --
-- along with this program.  If not, see <http://www.gnu.org/licenses/>.      --
--------------------------------------------------------------------------------
-- http://www.computer-engineering.org/ps2keyboard/
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
 
library work;
use work.iwb.all;
 
entity keyb is
   port(
      si        : in  slave_in_t;
      so        : out slave_out_t;
   -- Non-Wishbone Signals
      PS2_CLK   : in  std_logic;
      PS2_DATA  : in  std_logic;
      intr      : out std_logic
   );
end keyb;
 
architecture rtl of keyb is
 
   constant EXTENDED_CODE : std_logic_vector(7 downto 0) := x"E0";
   constant BREAK_CODE    : std_logic_vector(7 downto 0) := x"F0";
   constant CAPS          : std_logic_vector(7 downto 0) := x"58";
   constant LEFT_SHIFT    : std_logic_vector(7 downto 0) := x"12";
   constant RIGHT_SHIFT   : std_logic_vector(7 downto 0) := x"59";
   constant LEFT_CTRL     : std_logic_vector(7 downto 0) := x"14";
   constant LEFT_ALT      : std_logic_vector(7 downto 0) := x"11";
   constant RIGHT_CTRL    : std_logic_vector(7 downto 0) := x"14";
   constant RIGHT_ALT     : std_logic_vector(7 downto 0) := x"11";
 
   component ps2 is
      port(
         clk      : in  std_logic;
         rst      : in  std_logic;
         PS2_CLK  : in  std_logic;
         PS2_DATA : in  std_logic;
         char     : out std_logic_vector(7 downto 0);
         rx_done  : out std_logic
      );
   end component;
 
   component ascii is
      port(
         clk   : in  std_logic;
         shft  : in  std_logic;
         altgr : in std_logic;
         code  : in  std_logic_vector(7 downto 0);
         char  : out std_logic_vector(7 downto 0)
      );
   end component;
 
   attribute RAM_STYLE : string;
   attribute RAM_STYLE of ascii : component is "BLOCK";
 
   type state_t is (Idle, ExtCode, BrkCode, ExtRelease, Translate, Check,
                    Ack, Ack2);
 
   type char_t is record
      shft  : std_logic;                           -- Shift key.
      cps   : std_logic;                           -- Caps key.
      ctrl  : std_logic;                           -- Control key.
      alt   : std_logic;                           -- Alt key.
      altgr : std_logic;                           -- Alt Gr key.
      m     : std_logic_vector(7 downto 0);        -- Scan code.
   end record;
 
   signal k, kin   : state_t := Idle;              -- Keyboard controller state.
   signal c, cin   : char_t;                       -- Character structure.
   signal code     : std_logic_vector(7 downto 0); -- PS2 scan code.
   signal char     : std_logic_vector(7 downto 0); -- ASCII character.
   signal shftcps  : std_logic;                    -- SHIFT xor CAPS.
   signal rx_done  : std_logic;                    -- PS2 receive done tick.
   signal key_done : std_logic;                    -- Keyboard ctrl done tick.
begin
 
   -----------------------------------------------------------------------------
   -- PS2 Controller                                                          --
   -----------------------------------------------------------------------------
   ps2_ctrl : ps2 port map(
      clk      => si.clk,
      rst      => si.rst,
      PS2_CLK  => PS2_CLK,
      PS2_DATA => PS2_DATA,
      char     => code,
      rx_done  => rx_done
   );
 
   -----------------------------------------------------------------------------
   -- ScanCode To ASCII ROM                                                   --
   -----------------------------------------------------------------------------
   shftcps <= c.shft xor c.cps;     -- If both are set, turn to lower case.
 
   ascii_rom : ascii port map(
      clk   => si.clk,
      shft  => shftcps,
      altgr => c.altgr,
      code  => c.m,
      char  => char
   );
 
   -----------------------------------------------------------------------------
   -- Keyboard Control                                                        --
   -----------------------------------------------------------------------------
   key : process(k, c, rx_done, code, si.stb, si.we, si, char)
   begin
 
      kin <= k;
      cin <= c;
 
      intr   <= '0';
      so.ack <= '0';
      --key_done <= '0';  
 
      case k is
 
         -- Wait for some key input.
         when Idle =>
            if rx_done = '1' then
               case code is
 
                  when EXTENDED_CODE =>
                     kin   <= ExtCode;
 
                  when BREAK_CODE =>
                     kin   <= BrkCode;
 
                  -- User pressed a functional key. Just latch and then return
                  -- to Idle state. The CPU does not need to be bothered.
                  when LEFT_SHIFT | RIGHT_SHIFT =>
                     cin.shft <= '1';
                     kin      <= Idle;
                  when CAPS =>
                     cin.cps  <= not c.cps;
                     kin      <= Idle;
                  when LEFT_CTRL =>
                     cin.ctrl <= '1';
                     kin      <= Idle;
                  when LEFT_ALT =>
                     cin.alt  <= '1';
                     kin      <= Idle;
 
                  -- The actual key code.
                  when others =>
                     cin.m <= code;
                     kin   <= Translate;
               end case;
            end if;
 
         -- PREVIOUS STATE: Idle.
         when ExtCode =>
            if rx_done = '1' then
               case code is
 
                  -- If we receive a BREAK CODE we know that the following
                  -- pressed key (represented by the next byte) has been
                  -- released.
                  when BREAK_CODE =>
                     kin   <= ExtRelease;
 
                  -- The RIGHT CTRL and RIGHT ALT (ALT GR) are the same key
                  -- codes as LEFT CTRL and LEFT ALT plus an preceeding EXTENDED
                  -- CODE. RIGHT ALT (ALT GR) has a different functional
                  -- meaning.
                  when RIGHT_CTRL =>
                     cin.ctrl  <= '1';
                     kin       <= Idle;
                  when RIGHT_ALT =>
                     cin.altgr <= '1';
                     kin       <= Idle;
 
                  -- Once more the actual key code.
                  when others =>
                     cin.m <= code;
                     kin   <= Translate;
               end case;
            end if;
 
         -- PREVIOUS STATE: Idle.
         when BrkCode =>
            if rx_done = '1' then
               case code is
 
                  -- A functional key has been released.
                  when LEFT_SHIFT | RIGHT_SHIFT =>
                     cin.shft <= '0';
                     kin      <= Idle;
                  when LEFT_CTRL =>
                     cin.ctrl <= '0';
                     kin      <= Idle;
                  when LEFT_ALT =>
                     cin.alt  <= '0';
                     kin      <= Idle;
 
                  -- Do nothing when CAPS is released.
                  when CAPS =>
                     kin <= Idle;
 
                  -- Do nothing on key release.
                  when others =>
                     kin <= Idle;
               end case;
            end if;
 
         -- PREVIOUS STATE: ExtCode.
         -- Either turn off the RIGHT CTRL or RIGHT ALT flags, or receive a non
         -- functional key code release.
         when ExtRelease =>
            if rx_done = '1' then
               case code is
 
                  -- The RIGHT CTRL and RIGHT ALT (ALT GR) are the same key
                  -- codes as LEFT CTRL and LEFT ALT plus an preceeding EXTENDED
                  -- CODE. RIGHT ALT (ALT GR) has a different functional
                  -- meaning.
                  when RIGHT_CTRL =>
                     cin.ctrl <= '0';
                     kin      <= Idle;
                  when RIGHT_ALT =>
                     cin.altgr <= '0';
                     kin       <= Idle;
 
                  -- Do nothing on key release.
                  when others =>
                     kin   <= Idle;
               end case;
            end if;
 
         -- PREVIOUS STATES: Idle, ExtCode.
         -- One cycle delay for the ASCII-ROM to translate the keyboard code.
         when Translate =>
            kin <= Check;
 
         -- Ignore all undefined keys.
         when Check =>
            if char = x"00" then
               kin <= Idle;
            else
               kin <= Ack;
            end if;
 
         -- Wait for a Wishbone read, set interrrupt meanwhile.
         when Ack =>
            intr <= '1';
            if wb_read(si) then
               so.ack <= '1';
               --key_done <= '1';
               kin      <= Ack2;
            end if;
 
         -- Wait and hold done signal until master notices ack signal and pulls
         -- stb down.
         when Ack2 =>
            intr   <= '1';
            so.ack <= '1';
            --key_done <= '1';
            if si.stb = '0' then
               kin <= Idle;
            end if;
 
      end case;
   end process;
 
   so.dat <= x"0000" & c.shft & c.ctrl & c.alt & c.altgr & x"0" & char;
   --so.ack <= key_done;
 
   -----------------------------------------------------------------------------
   -- Registers                                                               --
   -----------------------------------------------------------------------------
     reg : process(si.clk)
   begin
      if rising_edge(si.clk) then
         k <= kin;
         c <= cin;
         if si.rst = '1' then
            k <= Idle;
            c <= ('0','0','0','0','0',(others => '-'));
         end if;
      end if;
   end process;
end rtl;