+ def __init__(self):
+ self.clk = ClockSignal()
+ self.reset = ResetSignal()
+ self.tty_write = Signal()
+ self.tty_write_data = Signal(8)
+ self.tty_write_busy = Signal()
+ self.switch_2 = Signal()
+ self.switch_3 = Signal()
+ self.led_1 = Signal()
+ self.led_3 = Signal()
+
+ ram_size = Constant(0x8000)
+ ram_start = Constant(0x10000, 32)
+ reset_vector = Signal(32)
+ mtvec = Signal(32)
+
+ reset_vector.eq(ram_start)
+ mtvec.eq(ram_start + 0x40)
+
+ l = []
+ for i in range(31):
+ l.append(Signal(32, name="register%d" % i))
+ registers = Array(l)
+
+ mi = MemoryInterface()
+
+ mii = Instance("cpu_memory_interface", name="memory_instance",
+ p_ram_size = ram_size,
+ p_ram_start = ram_start,
+ i_clk=ClockSignal(),
+ i_rst=ResetSignal(),
+ i_fetch_address = mi.fetch_address,
+ o_fetch_data = mi.fetch_data,
+ o_fetch_valid = mi.fetch_valid,
+ i_rw_address = mi.rw_address,
+ i_rw_byte_mask = mi.rw_byte_mask,
+ i_rw_read_not_write = mi.rw_read_not_write,
+ i_rw_active = mi.rw_active,
+ i_rw_data_in = mi.rw_data_in,
+ o_rw_data_out = mi.rw_data_out,
+ o_rw_address_valid = mi.rw_address_valid,
+ o_rw_wait = mi.rw_wait,
+ o_tty_write = self.tty_write,
+ o_tty_write_data = self.tty_write_data,
+ i_tty_write_busy = self.tty_write_busy,
+ i_switch_2 = self.switch_2,
+ i_switch_3 = self.switch_3,
+ o_led_1 = self.led_1,
+ o_led_3 = self.led_3
+ )
+ self.specials += mii
+
+ fetch_act = Signal(fetch_action)
+ fetch_target_pc = Signal(32)
+ fetch_output_pc = Signal(32)
+ fetch_output_instruction = Signal(32)
+ fetch_output_st = Signal(fetch_output_state)
+
+ fs = Instance("CPUFetchStage", name="fetch_stage",
+ i_clk=ClockSignal(),
+ i_rst=ResetSignal(),
+ o_memory_interface_fetch_address = mi.fetch_address,
+ i_memory_interface_fetch_data = mi.fetch_data,
+ i_memory_interface_fetch_valid = mi.fetch_valid,
+ i_fetch_action = fetch_act,
+ i_target_pc = fetch_target_pc,
+ o_output_pc = fetch_output_pc,
+ o_output_instruction = fetch_output_instruction,
+ o_output_state = fetch_output_st,
+ i_reset_vector = reset_vector,
+ i_mtvec = mtvec,
+ )
+ self.specials += fs
+
+ dc = Decoder()
+
+ cd = Instance("CPUDecoder", name="decoder",
+ i_instruction = fetch_output_instruction,
+ o_funct7 = dc.funct7,
+ o_funct3 = dc.funct3,
+ o_rd = dc.rd,
+ o_rs1 = dc.rs1,
+ o_rs2 = dc.rs2,
+ o_immediate = dc.immediate,
+ o_opcode = dc.opcode,
+ o_decode_action = dc.act
+ )
+ self.specials += cd
+
+ register_rs1 = Signal(32)
+ register_rs2 = Signal(32)
+ self.comb += If(dc.rs1 == 0,
+ register_rs1.eq(0)
+ ).Else(
+ register_rs1.eq(registers[dc.rs1-1]))
+ self.comb += If(dc.rs2 == 0,
+ register_rs2.eq(0)
+ ).Else(
+ register_rs2.eq(registers[dc.rs2-1]))
+
+ load_store_address = Signal(32)
+ load_store_address_low_2 = Signal(2)
+
+ self.comb += load_store_address.eq(dc.immediate + register_rs1)
+ self.comb += load_store_address_low_2.eq(
+ dc.immediate[:2] + register_rs1[:2])
+
+ load_store_misaligned = Signal()
+
+ lsa = self.get_ls_misaligned(load_store_misaligned, dc.funct3,
+ load_store_address_low_2)
+ self.comb += lsa
+
+ # XXX rwaddr not 31:2 any more
+ self.comb += mi.rw_address.eq(load_store_address[2:])
+
+ unshifted_load_store_byte_mask = Signal(4)
+
+ self.comb += unshifted_load_store_byte_mask.eq(self.get_lsbm(dc))
+
+ # XXX yuck. this will cause migen simulation to fail
+ # (however conversion to verilog works)
+ self.comb += mi.rw_byte_mask.eq(
+ _Operator("<<", [unshifted_load_store_byte_mask,
+ load_store_address_low_2]))
+
+ # XXX not obvious
+ b3 = Mux(load_store_address_low_2[1],
+ Mux(load_store_address_low_2[0], register_rs2[0:8],
+ register_rs2[8:16]),
+ Mux(load_store_address_low_2[0], register_rs2[16:24],
+ register_rs2[24:32]))
+ b2 = Mux(load_store_address_low_2[1], register_rs2[0:8],
+ register_rs2[16:24])
+ b1 = Mux(load_store_address_low_2[0], register_rs2[0:8],
+ register_rs2[8:16])
+ b0 = register_rs2[0:8]
+
+ self.comb += mi.rw_data_in.eq(Cat(b0, b1, b2, b3))
+
+ # XXX not obvious
+ unmasked_loaded_value = Signal(32)
+
+ b0 = Mux(load_store_address_low_2[1],
+ Mux(load_store_address_low_2[0], mi.rw_data_out[24:32],
+ mi.rw_data_out[16:24]),
+ Mux(load_store_address_low_2[0], mi.rw_data_out[15:8],
+ mi.rw_data_out[0:8]))
+ b1 = Mux(load_store_address_low_2[1], mi.rw_data_out[24:31],
+ mi.rw_data_out[8:16])
+ b23 = mi.rw_data_out[16:32]
+
+ self.comb += unmasked_loaded_value.eq(Cat(b0, b1, b23))
+
+ # XXX not obvious
+ loaded_value = Signal(32)
+
+ b0 = unmasked_loaded_value[0:8]
+ b1 = Mux(dc.funct3[0:2] == 0,
+ Replicate(~dc.funct3[2] & unmasked_loaded_value[7], 8),
+ unmasked_loaded_value[8:16])
+ b2 = Mux(dc.funct3[1] == 0,
+ Replicate(~dc.funct3[2] &
+ Mux(dc.funct3[0], unmasked_loaded_value[15],
+ unmasked_loaded_value[7]),
+ 16),
+ unmasked_loaded_value[16:32])
+
+ self.comb += loaded_value.eq(Cat(b0, b1, b2))
+
+ self.comb += mi.rw_active.eq(~self.reset
+ & (fetch_output_st == fetch_output_state_valid)
+ & ~load_store_misaligned
+ & ((dc.act & (DA.load | DA.store)) != 0))
+
+ self.comb += mi.rw_read_not_write.eq(~dc.opcode[5])
+
+ # alu
+ alu_a = Signal(32)
+ alu_b = Signal(32)
+ alu_result = Signal(32)
+
+ self.comb += alu_a.eq(register_rs1)
+ self.comb += alu_b.eq(Mux(dc.opcode[5],
+ register_rs2,
+ dc.immediate))