loadstore1.vhdl

   1 library ieee;
   2 use ieee.std_logic_1164.all;
   3 use ieee.numeric_std.all;
   4
   5 library work;
   6 use work.decode_types.all;
   7 use work.common.all;
   8
   9 -- 2 cycle LSU
  10 -- We calculate the address in the first cycle
  11
  12 entity loadstore1 is
  13     generic (
  14         -- Non-zero to enable log data collection
  15         LOG_LENGTH : natural := 0
  16         );
  17     port (
  18         clk   : in std_ulogic;
  19         rst   : in std_ulogic;
  20
  21         l_in  : in Execute1ToLoadstore1Type;
  22         e_out : out Loadstore1ToExecute1Type;
  23         l_out : out Loadstore1ToWritebackType;
  24
  25         d_out : out Loadstore1ToDcacheType;
  26         d_in  : in DcacheToLoadstore1Type;
  27
  28         m_out : out Loadstore1ToMmuType;
  29         m_in  : in MmuToLoadstore1Type;
  30
  31         dc_stall  : in std_ulogic;
  32
  33         log_out : out std_ulogic_vector(9 downto 0)
  34         );
  35 end loadstore1;
  36
  37 -- Note, we don't currently use the stall output from the dcache because
  38 -- we know it can take two requests without stalling when idle, we are
  39 -- its only user, and we know it never stalls when idle.
  40
  41 architecture behave of loadstore1 is
  42
  43     -- State machine for unaligned loads/stores
  44     type state_t is (IDLE,              -- ready for instruction
  45                      SECOND_REQ,        -- send 2nd request of unaligned xfer
  46                      ACK_WAIT,          -- waiting for ack from dcache
  47                      MMU_LOOKUP,        -- waiting for MMU to look up translation
  48                      TLBIE_WAIT,        -- waiting for MMU to finish doing a tlbie
  49                      COMPLETE           -- extra cycle to complete an operation
  50                      );
  51
  52     type reg_stage_t is record
  53         -- latch most of the input request
  54         load         : std_ulogic;
  55         tlbie        : std_ulogic;
  56         dcbz         : std_ulogic;
  57         mfspr        : std_ulogic;
  58         addr         : std_ulogic_vector(63 downto 0);
  59         store_data   : std_ulogic_vector(63 downto 0);
  60         load_data    : std_ulogic_vector(63 downto 0);
  61         write_reg    : gpr_index_t;
  62         length       : std_ulogic_vector(3 downto 0);
  63         byte_reverse : std_ulogic;
  64         sign_extend  : std_ulogic;
  65         update       : std_ulogic;
  66         update_reg   : gpr_index_t;
  67         xerc         : xer_common_t;
  68         reserve      : std_ulogic;
  69         rc           : std_ulogic;
  70         nc           : std_ulogic;              -- non-cacheable access
  71         virt_mode    : std_ulogic;
  72         priv_mode    : std_ulogic;
  73         state        : state_t;
  74         dwords_done  : std_ulogic;
  75         last_dword   : std_ulogic;
  76         first_bytes  : std_ulogic_vector(7 downto 0);
  77         second_bytes : std_ulogic_vector(7 downto 0);
  78         dar          : std_ulogic_vector(63 downto 0);
  79         dsisr        : std_ulogic_vector(31 downto 0);
  80         instr_fault  : std_ulogic;
  81         sprval       : std_ulogic_vector(63 downto 0);
  82         busy         : std_ulogic;
  83         wait_dcache  : std_ulogic;
  84         wait_mmu     : std_ulogic;
  85         do_update    : std_ulogic;
  86         extra_cycle  : std_ulogic;
  87     end record;
  88
  89     type byte_sel_t is array(0 to 7) of std_ulogic;
  90     subtype byte_trim_t is std_ulogic_vector(1 downto 0);
  91     type trim_ctl_t is array(0 to 7) of byte_trim_t;
  92
  93     signal r, rin : reg_stage_t;
  94     signal lsu_sum : std_ulogic_vector(63 downto 0);
  95
  96     -- Generate byte enables from sizes
  97     function length_to_sel(length : in std_logic_vector(3 downto 0)) return std_ulogic_vector is
  98     begin
  99         case length is
 100             when "0001" =>
 101                 return "00000001";
 102             when "0010" =>
 103                 return "00000011";
 104             when "0100" =>
 105                 return "00001111";
 106             when "1000" =>
 107                 return "11111111";
 108             when others =>
 109                 return "00000000";
 110         end case;
 111     end function length_to_sel;
 112
 113     -- Calculate byte enables
 114     -- This returns 16 bits, giving the select signals for two transfers,
 115     -- to account for unaligned loads or stores
 116     function xfer_data_sel(size : in std_logic_vector(3 downto 0);
 117                            address : in std_logic_vector(2 downto 0))
 118         return std_ulogic_vector is
 119         variable longsel : std_ulogic_vector(15 downto 0);
 120     begin
 121         longsel := "00000000" & length_to_sel(size);
 122         return std_ulogic_vector(shift_left(unsigned(longsel),
 123                                             to_integer(unsigned(address))));
 124     end function xfer_data_sel;
 125
 126 begin
 127     -- Calculate the address in the first cycle
 128     lsu_sum <= std_ulogic_vector(unsigned(l_in.addr1) + unsigned(l_in.addr2)) when l_in.valid = '1' else (others => '0');
 129
 130     loadstore1_0: process(clk)
 131     begin
 132         if rising_edge(clk) then
 133             if rst = '1' then
 134                 r.state <= IDLE;
 135                 r.busy <= '0';
 136                 r.do_update <= '0';
 137             else
 138                 r <= rin;
 139             end if;
 140         end if;
 141     end process;
 142
 143     loadstore1_1: process(all)
 144         variable v : reg_stage_t;
 145         variable brev_lenm1 : unsigned(2 downto 0);
 146         variable byte_offset : unsigned(2 downto 0);
 147         variable j : integer;
 148         variable k : unsigned(2 downto 0);
 149         variable kk : unsigned(3 downto 0);
 150         variable long_sel : std_ulogic_vector(15 downto 0);
 151         variable byte_sel : std_ulogic_vector(7 downto 0);
 152         variable req : std_ulogic;
 153         variable busy : std_ulogic;
 154         variable addr : std_ulogic_vector(63 downto 0);
 155         variable maddr : std_ulogic_vector(63 downto 0);
 156         variable wdata : std_ulogic_vector(63 downto 0);
 157         variable write_enable : std_ulogic;
 158         variable do_update : std_ulogic;
 159         variable done : std_ulogic;
 160         variable data_permuted : std_ulogic_vector(63 downto 0);
 161         variable data_trimmed : std_ulogic_vector(63 downto 0);
 162         variable store_data : std_ulogic_vector(63 downto 0);
 163         variable use_second : byte_sel_t;
 164         variable trim_ctl : trim_ctl_t;
 165         variable negative : std_ulogic;
 166         variable sprn : std_ulogic_vector(9 downto 0);
 167         variable exception : std_ulogic;
 168         variable next_addr : std_ulogic_vector(63 downto 0);
 169         variable mmureq : std_ulogic;
 170         variable dsisr : std_ulogic_vector(31 downto 0);
 171         variable mmu_mtspr : std_ulogic;
 172         variable itlb_fault : std_ulogic;
 173     begin
 174         v := r;
 175         req := '0';
 176         v.mfspr := '0';
 177         mmu_mtspr := '0';
 178         itlb_fault := '0';
 179         sprn := std_ulogic_vector(to_unsigned(decode_spr_num(l_in.insn), 10));
 180         dsisr := (others => '0');
 181         mmureq := '0';
 182
 183         write_enable := '0';
 184
 185         do_update := r.do_update;
 186         v.do_update := '0';
 187
 188         -- load data formatting
 189         byte_offset := unsigned(r.addr(2 downto 0));
 190         brev_lenm1 := "000";
 191         if r.byte_reverse = '1' then
 192             brev_lenm1 := unsigned(r.length(2 downto 0)) - 1;
 193         end if;
 194
 195         -- shift and byte-reverse data bytes
 196         for i in 0 to 7 loop
 197             kk := ('0' & (to_unsigned(i, 3) xor brev_lenm1)) + ('0' & byte_offset);
 198             use_second(i) := kk(3);
 199             j := to_integer(kk(2 downto 0)) * 8;
 200             data_permuted(i * 8 + 7 downto i * 8) := d_in.data(j + 7 downto j);
 201         end loop;
 202
 203         -- Work out the sign bit for sign extension.
 204         -- Assumes we are not doing both sign extension and byte reversal,
 205         -- in that for unaligned loads crossing two dwords we end up
 206         -- using a bit from the second dword, whereas for a byte-reversed
 207         -- (i.e. big-endian) load the sign bit would be in the first dword.
 208         negative := (r.length(3) and data_permuted(63)) or
 209                     (r.length(2) and data_permuted(31)) or
 210                     (r.length(1) and data_permuted(15)) or
 211                     (r.length(0) and data_permuted(7));
 212
 213         -- trim and sign-extend
 214         for i in 0 to 7 loop
 215             if i < to_integer(unsigned(r.length)) then
 216                 if r.dwords_done = '1' then
 217                     trim_ctl(i) := '1' & not use_second(i);
 218                 else
 219                     trim_ctl(i) := "10";
 220                 end if;
 221             else
 222                 trim_ctl(i) := '0' & (negative and r.sign_extend);
 223             end if;
 224             case trim_ctl(i) is
 225                 when "11" =>
 226                     data_trimmed(i * 8 + 7 downto i * 8) := r.load_data(i * 8 + 7 downto i * 8);
 227                 when "10" =>
 228                     data_trimmed(i * 8 + 7 downto i * 8) := data_permuted(i * 8 + 7 downto i * 8);
 229                 when "01" =>
 230                     data_trimmed(i * 8 + 7 downto i * 8) := x"FF";
 231                 when others =>
 232                     data_trimmed(i * 8 + 7 downto i * 8) := x"00";
 233             end case;
 234         end loop;
 235
 236         -- Byte reversing and rotating for stores
 237         -- Done in the first cycle (when l_in.valid = 1)
 238         store_data := r.store_data;
 239         if l_in.valid = '1' then
 240             byte_offset := unsigned(lsu_sum(2 downto 0));
 241             brev_lenm1 := "000";
 242             if l_in.byte_reverse = '1' then
 243                 brev_lenm1 := unsigned(l_in.length(2 downto 0)) - 1;
 244             end if;
 245             for i in 0 to 7 loop
 246                 k := (to_unsigned(i, 3) - byte_offset) xor brev_lenm1;
 247                 j := to_integer(k) * 8;
 248                 store_data(i * 8 + 7 downto i * 8) := l_in.data(j + 7 downto j);
 249             end loop;
 250         end if;
 251         v.store_data := store_data;
 252
 253         -- compute (addr + 8) & ~7 for the second doubleword when unaligned
 254         next_addr := std_ulogic_vector(unsigned(r.addr(63 downto 3)) + 1) & "000";
 255
 256         -- Busy calculation.
 257         -- We need to minimize the delay from clock to busy valid because it
 258         -- gates the start of execution of the next instruction.
 259         busy := r.busy and not ((r.wait_dcache and d_in.valid) or (r.wait_mmu and m_in.done));
 260         v.busy := busy;
 261
 262         done := '0';
 263         if r.state /= IDLE and busy = '0' then
 264             done := '1';
 265         end if;
 266         exception := '0';
 267
 268         if r.dwords_done = '1' or r.state = SECOND_REQ then
 269             maddr := next_addr;
 270             byte_sel := r.second_bytes;
 271         else
 272             maddr := r.addr;
 273             byte_sel := r.first_bytes;
 274         end if;
 275         addr := maddr;
 276
 277         case r.state is
 278         when IDLE =>
 279
 280         when SECOND_REQ =>
 281             req := '1';
 282             v.state := ACK_WAIT;
 283             v.last_dword := '0';
 284
 285         when ACK_WAIT =>
 286             if d_in.error = '1' then
 287                 -- dcache will discard the second request if it
 288                 -- gets an error on the 1st of two requests
 289                 if d_in.cache_paradox = '1' then
 290                     -- signal an interrupt straight away
 291                     exception := '1';
 292                     dsisr(63 - 38) := not r.load;
 293                     -- XXX there is no architected bit for this
 294                     dsisr(63 - 35) := d_in.cache_paradox;
 295                 else
 296                     -- Look up the translation for TLB miss
 297                     -- and also for permission error and RC error
 298                     -- in case the PTE has been updated.
 299                     mmureq := '1';
 300                     v.state := MMU_LOOKUP;
 301                 end if;
 302             end if;
 303             if d_in.valid = '1' then
 304                 if r.last_dword = '0' then
 305                     v.dwords_done := '1';
 306                     v.last_dword := '1';
 307                     if r.load = '1' then
 308                         v.load_data := data_permuted;
 309                     end if;
 310                 else
 311                     write_enable := r.load;
 312                     if r.extra_cycle = '1' then
 313                         -- loads with rA update need an extra cycle
 314                         v.state := COMPLETE;
 315                         v.do_update := r.update;
 316                     else
 317                         -- stores write back rA update in this cycle
 318                         do_update := r.update;
 319                     end if;
 320                     v.busy := '0';
 321                 end if;
 322             end if;
 323             -- r.wait_dcache gets set one cycle after we come into ACK_WAIT state,
 324             -- which is OK because the dcache always takes at least two cycles.
 325             v.wait_dcache := r.last_dword and not r.extra_cycle;
 326
 327         when MMU_LOOKUP =>
 328             if m_in.done = '1' then
 329                 if r.instr_fault = '0' then
 330                     -- retry the request now that the MMU has installed a TLB entry
 331                     req := '1';
 332                     if r.last_dword = '0' then
 333                         v.state := SECOND_REQ;
 334                     else
 335                         v.state := ACK_WAIT;
 336                     end if;
 337                 end if;
 338             end if;
 339             if m_in.err = '1' then
 340                 exception := '1';
 341                 dsisr(63 - 33) := m_in.invalid;
 342                 dsisr(63 - 36) := m_in.perm_error;
 343                 dsisr(63 - 38) := not r.load;
 344                 dsisr(63 - 44) := m_in.badtree;
 345                 dsisr(63 - 45) := m_in.rc_error;
 346             end if;
 347
 348         when TLBIE_WAIT =>
 349
 350         when COMPLETE =>
 351
 352         end case;
 353
 354         if done = '1' or exception = '1' then
 355             v.state := IDLE;
 356             v.busy := '0';
 357         end if;
 358
 359         -- Note that l_in.valid is gated with busy inside execute1
 360         if l_in.valid = '1' then
 361             v.addr := lsu_sum;
 362             v.load := '0';
 363             v.dcbz := '0';
 364             v.tlbie := '0';
 365             v.instr_fault := '0';
 366             v.dwords_done := '0';
 367             v.last_dword := '1';
 368             v.write_reg := l_in.write_reg;
 369             v.length := l_in.length;
 370             v.byte_reverse := l_in.byte_reverse;
 371             v.sign_extend := l_in.sign_extend;
 372             v.update := l_in.update;
 373             v.update_reg := l_in.update_reg;
 374             v.xerc := l_in.xerc;
 375             v.reserve := l_in.reserve;
 376             v.rc := l_in.rc;
 377             v.nc := l_in.ci;
 378             v.virt_mode := l_in.virt_mode;
 379             v.priv_mode := l_in.priv_mode;
 380             v.wait_dcache := '0';
 381             v.wait_mmu := '0';
 382             v.do_update := '0';
 383             v.extra_cycle := '0';
 384
 385             addr := lsu_sum;
 386             maddr := l_in.addr2;    -- address from RB for tlbie
 387
 388             -- XXX Temporary hack. Mark the op as non-cachable if the address
 389             -- is the form 0xc------- for a real-mode access.
 390             if lsu_sum(31 downto 28) = "1100" and l_in.virt_mode = '0' then
 391                 v.nc := '1';
 392             end if;
 393
 394             -- Do length_to_sel and work out if we are doing 2 dwords
 395             long_sel := xfer_data_sel(l_in.length, v.addr(2 downto 0));
 396             byte_sel := long_sel(7 downto 0);
 397             v.first_bytes := byte_sel;
 398             v.second_bytes := long_sel(15 downto 8);
 399
 400             case l_in.op is
 401                 when OP_STORE =>
 402                     req := '1';
 403                 when OP_LOAD =>
 404                     req := '1';
 405                     v.load := '1';
 406                     -- Allow an extra cycle for RA update on loads
 407                     v.extra_cycle := l_in.update;
 408                 when OP_DCBZ =>
 409                     req := '1';
 410                     v.dcbz := '1';
 411                 when OP_TLBIE =>
 412                     mmureq := '1';
 413                     v.tlbie := '1';
 414                     v.state := TLBIE_WAIT;
 415                     v.wait_mmu := '1';
 416                 when OP_MFSPR =>
 417                     v.mfspr := '1';
 418                     -- partial decode on SPR number should be adequate given
 419                     -- the restricted set that get sent down this path
 420                     if sprn(9) = '0' and sprn(5) = '0' then
 421                         if sprn(0) = '0' then
 422                             v.sprval := x"00000000" & r.dsisr;
 423                         else
 424                             v.sprval := r.dar;
 425                         end if;
 426                     else
 427                         -- reading one of the SPRs in the MMU
 428                         v.sprval := m_in.sprval;
 429                     end if;
 430                     v.state := COMPLETE;
 431                 when OP_MTSPR =>
 432                     if sprn(9) = '0' and sprn(5) = '0' then
 433                         if sprn(0) = '0' then
 434                             v.dsisr := l_in.data(31 downto 0);
 435                         else
 436                             v.dar := l_in.data;
 437                         end if;
 438                         v.state := COMPLETE;
 439                     else
 440                         -- writing one of the SPRs in the MMU
 441                         mmu_mtspr := '1';
 442                         v.state := TLBIE_WAIT;
 443                         v.wait_mmu := '1';
 444                     end if;
 445                 when OP_FETCH_FAILED =>
 446                     -- send it to the MMU to do the radix walk
 447                     maddr := l_in.nia;
 448                     v.instr_fault := '1';
 449                     mmureq := '1';
 450                     v.state := MMU_LOOKUP;
 451                     v.wait_mmu := '1';
 452                 when others =>
 453                     assert false report "unknown op sent to loadstore1";
 454             end case;
 455
 456             if req = '1' then
 457                 if long_sel(15 downto 8) = "00000000" then
 458                     v.state := ACK_WAIT;
 459                 else
 460                     v.state := SECOND_REQ;
 461                 end if;
 462             end if;
 463
 464             v.busy := req or mmureq or mmu_mtspr;
 465         end if;
 466
 467         -- Update outputs to dcache
 468         d_out.valid <= req;
 469         d_out.load <= v.load;
 470         d_out.dcbz <= v.dcbz;
 471         d_out.nc <= v.nc;
 472         d_out.reserve <= v.reserve;
 473         d_out.addr <= addr;
 474         d_out.data <= store_data;
 475         d_out.byte_sel <= byte_sel;
 476         d_out.virt_mode <= v.virt_mode;
 477         d_out.priv_mode <= v.priv_mode;
 478
 479         -- Update outputs to MMU
 480         m_out.valid <= mmureq;
 481         m_out.iside <= v.instr_fault;
 482         m_out.load <= r.load;
 483         m_out.priv <= r.priv_mode;
 484         m_out.tlbie <= v.tlbie;
 485         m_out.mtspr <= mmu_mtspr;
 486         m_out.sprn <= sprn;
 487         m_out.addr <= maddr;
 488         m_out.slbia <= l_in.insn(7);
 489         m_out.rs <= l_in.data;
 490
 491         -- Update outputs to writeback
 492         -- Multiplex either cache data to the destination GPR or
 493         -- the address for the rA update.
 494         l_out.valid <= done;
 495         if r.mfspr = '1' then
 496             l_out.write_enable <= '1';
 497             l_out.write_reg <= r.write_reg;
 498             l_out.write_data <= r.sprval;
 499         elsif do_update = '1' then
 500             l_out.write_enable <= '1';
 501             l_out.write_reg <= r.update_reg;
 502             l_out.write_data <= r.addr;
 503         else
 504             l_out.write_enable <= write_enable;
 505             l_out.write_reg <= r.write_reg;
 506             l_out.write_data <= data_trimmed;
 507         end if;
 508         l_out.xerc <= r.xerc;
 509         l_out.rc <= r.rc and done;
 510         l_out.store_done <= d_in.store_done;
 511
 512         -- update exception info back to execute1
 513         e_out.busy <= busy;
 514         e_out.exception <= exception;
 515         e_out.instr_fault <= r.instr_fault;
 516         e_out.invalid <= m_in.invalid;
 517         e_out.badtree <= m_in.badtree;
 518         e_out.perm_error <= m_in.perm_error;
 519         e_out.rc_error <= m_in.rc_error;
 520         e_out.segment_fault <= m_in.segerr;
 521         if exception = '1' and r.instr_fault = '0' then
 522             v.dar := addr;
 523             if m_in.segerr = '0' then
 524                 v.dsisr := dsisr;
 525             end if;
 526         end if;
 527
 528         -- Update registers
 529         rin <= v;
 530
 531     end process;
 532
 533     l1_log: if LOG_LENGTH > 0 generate
 534         signal log_data : std_ulogic_vector(9 downto 0);
 535     begin
 536         ls1_log: process(clk)
 537         begin
 538             if rising_edge(clk) then
 539                 log_data <= e_out.busy &
 540                             e_out.exception &
 541                             l_out.valid &
 542                             m_out.valid &
 543                             d_out.valid &
 544                             m_in.done &
 545                             r.dwords_done &
 546                             std_ulogic_vector(to_unsigned(state_t'pos(r.state), 3));
 547             end if;
 548         end process;
 549         log_out <= log_data;
 550     end generate;
 551
 552 end;