verilog/rtl/mgmt_soc.v

/*
 *  PicoSoC - A simple example SoC using PicoRV32
 *
 *  Copyright (C) 2017  Clifford Wolf <clifford@clifford.at>
 *
 *  Permission to use, copy, modify, and/or distribute this software for any
 *  purpose with or without fee is hereby granted, provided that the above
 *  copyright notice and this permission notice appear in all copies.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 *  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 *  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 *  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 *  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 *  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 *  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 *  Revision 1,  July 2019:  Added signals to drive flash_clk and flash_csb
 *  output enable (inverted), tied to reset so that the flash is completely
 *  isolated from the processor when the processor is in reset.
 *
 *  Also: Made ram_wenb a 4-bit bus so that the memory access can be made
 *  byte-wide for byte-wide instructions.
 */

`ifdef PICORV32_V
`error "mgmt_soc.v must be read before picorv32.v!"
`endif

`define PICORV32_REGS mgmt_soc_regs

`include "picorv32.v"
`include "spimemio.v"
`include "simpleuart.v"
`include "simple_spi_master.v"
`include "counter_timer_high.v"
`include "counter_timer_low.v"
`include "wb_intercon.v"
`include "mem_wb.v"
`include "gpio_wb.v"
`include "sysctrl.v"
`include "la_wb.v"
`include "mprj_ctrl.v"
`include "convert_gpio_sigs.v"

module mgmt_soc (
`ifdef LVS
    inout vdd1v8,	    /* 1.8V domain */
    inout vss,
`endif
    input clk,
    input resetn,

    // Trap state from CPU
    output trap,

    // GPIO (one pin)
    output gpio_out_pad,	// Connect to out on gpio pad
    input  gpio_in_pad,		// Connect to in on gpio pad
    output gpio_mode0_pad,	// Connect to dm[0] on gpio pad
    output gpio_mode1_pad,	// Connect to dm[2] on gpio pad
    output gpio_outenb_pad,	// Connect to oe_n on gpio pad
    output gpio_inenb_pad,	// Connect to inp_dis on gpio pad

    // LA signals
    input  [127:0] la_input,           	// From User Project to cpu
    output [127:0] la_output,          	// From CPU to User Project
    output [127:0] la_oen,              // LA output enable (active low) 

    // User Project I/O Configuration (serial load)
    input  mprj_vcc_pwrgood,
    input  mprj2_vcc_pwrgood,
    input  mprj_vdd_pwrgood,
    input  mprj2_vdd_pwrgood,
    output mprj_io_loader_resetn,
    output mprj_io_loader_clock,
    output mprj_io_loader_data,

    // User Project pad data (when management SoC controls the pad)
    input [`MPRJ_IO_PADS-1:0] mgmt_in_data,
    output [`MPRJ_IO_PADS-1:0] mgmt_out_data,
    output [`MPRJ_PWR_PADS-1:0] pwr_ctrl_out,

    // IRQ
    input  irq_spi,		// IRQ from standalone SPI

    // Flash memory control (SPI master)
    output flash_csb,
    output flash_clk,

    output flash_csb_oeb,
    output flash_clk_oeb,

    output flash_io0_oeb,
    output flash_io1_oeb,
    output flash_io2_oeb,
    output flash_io3_oeb,

    output flash_csb_ieb,
    output flash_clk_ieb,

    output flash_io0_ieb,
    output flash_io1_ieb,
    output flash_io2_ieb,
    output flash_io3_ieb,

    output flash_io0_do,
    output flash_io1_do,
    output flash_io2_do,
    output flash_io3_do,

    input  flash_io0_di,
    input  flash_io1_di,
    input  flash_io2_di,
    input  flash_io3_di,

    // SPI pass-thru mode
    input  pass_thru_mgmt,
    input  pass_thru_mgmt_csb,
    input  pass_thru_mgmt_sck,
    input  pass_thru_mgmt_sdi,
    output pass_thru_mgmt_sdo,

    // State of JTAG and SDO pins (override for management output use)
    output sdo_oenb_state,
    output jtag_oenb_state,
    // SPI master->slave direct link
    output hk_connect,
    // User clock monitoring
    input  user_clk,

    // WB MI A (User project)
    input mprj_ack_i,
    input [31:0] mprj_dat_i,
    output mprj_cyc_o,
    output mprj_stb_o,
    output mprj_we_o,
    output [3:0] mprj_sel_o,
    output [31:0] mprj_adr_o,
    output [31:0] mprj_dat_o,

    // MGMT area R/W interface for mgmt RAM
    output [`RAM_BLOCKS-1:0] mgmt_ena, 
    output [(`RAM_BLOCKS*4)-1:0] mgmt_wen_mask,
    output [`RAM_BLOCKS-1:0] mgmt_wen,
    output [7:0] mgmt_addr,
    output [31:0] mgmt_wdata,
    input  [(`RAM_BLOCKS*32)-1:0] mgmt_rdata,

    // MGMT area RO interface for user RAM 
    output mgmt_ena_ro,
    output [7:0] mgmt_addr_ro,
    input  [31:0] mgmt_rdata_ro
);
    /* Memory reverted back to 256 words while memory has to be synthesized */
    parameter [31:0] STACKADDR = (4*(`MEM_WORDS));       // end of memory
    parameter [31:0] PROGADDR_RESET = 32'h 1000_0000; 
    parameter [31:0] PROGADDR_IRQ   = 32'h 0000_0000;

    // Slaves Base Addresses
    parameter RAM_BASE_ADR    = 32'h 0000_0000;
    parameter STORAGE_RW_ADR  = 32'h 0100_0000;
    parameter STORAGE_RO_ADR  = 32'h 0200_0000;
    parameter FLASH_BASE_ADR  = 32'h 1000_0000;
    parameter UART_BASE_ADR   = 32'h 2000_0000;
    parameter GPIO_BASE_ADR   = 32'h 2100_0000;
    parameter COUNTER_TIMER0_BASE_ADR = 32'h 2200_0000;
    parameter COUNTER_TIMER1_BASE_ADR = 32'h 2300_0000;
    parameter SPI_MASTER_BASE_ADR = 32'h 2400_0000;
    parameter LA_BASE_ADR     = 32'h 2500_0000;
    parameter MPRJ_CTRL_ADR   = 32'h 2600_0000;
    parameter FLASH_CTRL_CFG  = 32'h 2D00_0000;
    parameter SYS_BASE_ADR    = 32'h 2F00_0000;
    parameter MPRJ_BASE_ADR   = 32'h 3000_0000;   // WB MI A
    
    // UART
    parameter UART_CLK_DIV = 8'h00;
    parameter UART_DATA    = 8'h04;

    // SPI Master
    parameter SPI_MASTER_CONFIG = 8'h00;
    parameter SPI_MASTER_DATA = 8'h04;

    // Counter-timer 0
    parameter COUNTER_TIMER0_CONFIG = 8'h00;
    parameter COUNTER_TIMER0_VALUE = 8'h04;
    parameter COUNTER_TIMER0_DATA = 8'h08;

    // Counter-timer 1
    parameter COUNTER_TIMER1_CONFIG = 8'h00;
    parameter COUNTER_TIMER1_VALUE = 8'h04;
    parameter COUNTER_TIMER1_DATA = 8'h08;
    
    // SOC GPIO
    parameter GPIO_DATA = 8'h00;
    parameter GPIO_ENA  = 8'h04;
    parameter GPIO_PU   = 8'h08;
    parameter GPIO_PD   = 8'h0c;
    
    // LA
    parameter LA_DATA_0 = 8'h00;
    parameter LA_DATA_1 = 8'h04;
    parameter LA_DATA_2 = 8'h08;
    parameter LA_DATA_3 = 8'h0c;
    parameter LA_ENA_0  = 8'h10;
    parameter LA_ENA_1  = 8'h14;
    parameter LA_ENA_2  = 8'h18;
    parameter LA_ENA_3  = 8'h1c;
    
    // System Control Registers
    parameter PWRGOOD       = 8'h00;
    parameter CLK_OUT       = 8'h04;
    parameter TRAP_OUT      = 8'h08;
    parameter IRQ_SRC       = 8'h0c;

    // Storage area RAM blocks
    parameter [(`RAM_BLOCKS*24)-1:0] RW_BLOCKS_ADR = {
        {24'h 10_0000},
        {24'h 00_0000}
    };

    parameter [23:0] RO_BLOCKS_ADR = {
        {24'h 00_0000}
    };

    // Wishbone Interconnect 
    localparam ADR_WIDTH = 32;
    localparam DAT_WIDTH = 32;
    localparam NUM_SLAVES = 14;

    parameter [NUM_SLAVES*ADR_WIDTH-1: 0] ADR_MASK = {
        {8'hFF, {ADR_WIDTH-8{1'b0}}},
        {8'hFF, {ADR_WIDTH-8{1'b0}}},
        {8'hFF, {ADR_WIDTH-8{1'b0}}},
        {8'hFF, {ADR_WIDTH-8{1'b0}}},
        {8'hFF, {ADR_WIDTH-8{1'b0}}},
        {8'hFF, {ADR_WIDTH-8{1'b0}}},
        {8'hFF, {ADR_WIDTH-8{1'b0}}},
        {8'hFF, {ADR_WIDTH-8{1'b0}}},
        {8'hFF, {ADR_WIDTH-8{1'b0}}},
        {8'hFF, {ADR_WIDTH-8{1'b0}}},
        {8'hFF, {ADR_WIDTH-8{1'b0}}},
        {8'hFF, {ADR_WIDTH-8{1'b0}}},
        {8'hFF, {ADR_WIDTH-8{1'b0}}},
        {8'hFF, {ADR_WIDTH-8{1'b0}}}
    };

    parameter [NUM_SLAVES*ADR_WIDTH-1: 0] SLAVE_ADR = {
        {SYS_BASE_ADR},
        {FLASH_CTRL_CFG},
        {MPRJ_BASE_ADR},
        {MPRJ_CTRL_ADR},
        {LA_BASE_ADR},
	{SPI_MASTER_BASE_ADR},
	{COUNTER_TIMER1_BASE_ADR},
	{COUNTER_TIMER0_BASE_ADR},
        {GPIO_BASE_ADR},
        {UART_BASE_ADR},
        {FLASH_BASE_ADR},
        {STORAGE_RO_ADR},
        {STORAGE_RW_ADR},
        {RAM_BASE_ADR}
    };

    // The following functions are connected to specific user project
    // area pins, when under control of the management area (during
    // startup, and when not otherwise programmed for the user project).

    // JTAG      = jtag_out		 (inout)
    // SDO       = sdo_out	         (output)   (shared with SPI master)
    // SDI       = mgmt_in_data[2]       (input)    (shared with SPI master)
    // CSB       = mgmt_in_data[3]       (input)    (shared with SPI master)
    // SCK       = mgmt_in_data[4]       (input)    (shared with SPI master)
    // ser_rx    = mgmt_in_data[5]       (input)
    // ser_tx    = mgmt_out_data[6]      (output)
    // irq_pin   = mgmt_in_data[7]       (input)
    // flash_csb = mgmt_out_data[8]      (output)   (user area flash)
    // flash_sck = mgmt_out_data[9]      (output)   (user area flash)
    // flash_io0 = mgmt_in/out_data[10]  (input)    (user area flash)
    // flash_io1 = mgmt_in/out_data[11]  (output)   (user area flash)
    // irq2_pin	 = mgmt_in_data[12]	 (input)
    // trap_mon	 = mgmt_in_data[13]	 (output)
    // clk1_mon	 = mgmt_in_data[14]	 (output)
    // clk2_mon	 = mgmt_in_data[15]	 (output)

    // OEB lines for [0] and [1] are the only ones connected directly to
    // the pad.  All others have OEB controlled by the configuration bit
    // in the control block.

    // memory-mapped I/O control registers
    wire gpio_pullup;    	// Intermediate GPIO pullup
    wire gpio_pulldown;  	// Intermediate GPIO pulldown
    wire gpio_outenb;    	// Intermediate GPIO out enable (bar)
    wire gpio_out;      	// Intermediate GPIO output

    wire trap_output_dest; 	// Trap signal output destination
    wire clk1_output_dest; 	// Core clock1 signal output destination
    wire clk2_output_dest; 	// Core clock2 signal output destination
    wire irq_7_inputsrc;	// IRQ 7 source
    wire irq_8_inputsrc;	// IRQ 8 source

    // Convert GPIO signals to sky130_fd_io pad signals
    convert_gpio_sigs convert_gpio_bit (
        .gpio_out(gpio_out),
        .gpio_outenb(gpio_outenb),
        .gpio_pu(gpio_pullup),
        .gpio_pd(gpio_pulldown),
        .gpio_out_pad(gpio_out_pad),
        .gpio_outenb_pad(gpio_outenb_pad),
        .gpio_inenb_pad(gpio_inenb_pad),
        .gpio_mode1_pad(gpio_mode1_pad),
        .gpio_mode0_pad(gpio_mode0_pad)
    );

    reg [31:0] irq;
    wire irq_7;
    wire irq_8;
    wire irq_stall;
    wire irq_uart;
    wire irq_spi_master;
    wire irq_counter_timer0;
    wire irq_counter_timer1;

    assign irq_stall = 0;
    assign irq_7 = (irq_7_inputsrc == 1'b1) ? mgmt_in_data[7] : 1'b0;
    assign irq_8 = (irq_8_inputsrc == 1'b1) ? mgmt_in_data[12] : 1'b0;

    always @* begin
        irq = 0;
        irq[3] = irq_stall;
        irq[4] = irq_uart;
        irq[6] = irq_spi;
        irq[7] = irq_7;
        irq[9] = irq_spi_master;
        irq[10] = irq_counter_timer0;
        irq[11] = irq_counter_timer1;
    end

    // Assumption : no syscon module and wb_clk is the clock coming from the
    // caravel_clocking module

    assign wb_clk_i = clk;
    assign wb_rst_i = ~resetn;      // Redundant

    // Wishbone Master
    wire [31:0] cpu_adr_o;
    wire [31:0] cpu_dat_i;
    wire [3:0] cpu_sel_o;
    wire cpu_we_o;
    wire cpu_cyc_o;
    wire cpu_stb_o;
    wire [31:0] cpu_dat_o;
    wire cpu_ack_i;
    
    picorv32_wb #(
        .STACKADDR(STACKADDR),
        .PROGADDR_RESET(PROGADDR_RESET),
        .PROGADDR_IRQ(PROGADDR_IRQ),
        .BARREL_SHIFTER(1),
        .COMPRESSED_ISA(1),
        .ENABLE_MUL(1),
        .ENABLE_DIV(1),
        .ENABLE_IRQ(1),
        .ENABLE_IRQ_QREGS(0)
    ) cpu (
        .wb_clk_i (wb_clk_i),
        .wb_rst_i (wb_rst_i),
        .trap     (trap),
        .irq      (irq),
        .mem_instr(mem_instr),
        .wbm_adr_o(cpu_adr_o),     
        .wbm_dat_i(cpu_dat_i),    
        .wbm_stb_o(cpu_stb_o),    
        .wbm_ack_i(cpu_ack_i),    
        .wbm_cyc_o(cpu_cyc_o),    
        .wbm_dat_o(cpu_dat_o),    
        .wbm_we_o(cpu_we_o),      
        .wbm_sel_o(cpu_sel_o)     
    );

    // Wishbone Slave SPIMEMIO
    wire spimemio_flash_stb_i;
    wire spimemio_flash_ack_o;
    wire [31:0] spimemio_flash_dat_o;

    wire spimemio_cfg_stb_i;
    wire spimemio_cfg_ack_o;
    wire [31:0] spimemio_cfg_dat_o;

    spimemio_wb spimemio (
        .wb_clk_i(wb_clk_i),
        .wb_rst_i(wb_rst_i),

        .wb_adr_i(cpu_adr_o), 
        .wb_dat_i(cpu_dat_o),
        .wb_sel_i(cpu_sel_o),
        .wb_we_i(cpu_we_o),
        .wb_cyc_i(cpu_cyc_o),

        // FLash Slave
        .wb_flash_stb_i(spimemio_flash_stb_i),
        .wb_flash_ack_o(spimemio_flash_ack_o),
        .wb_flash_dat_o(spimemio_flash_dat_o),
        
        // Config Register Slave 
        .wb_cfg_stb_i(spimemio_cfg_stb_i),
        .wb_cfg_ack_o(spimemio_cfg_ack_o),
        .wb_cfg_dat_o(spimemio_cfg_dat_o),

	.pass_thru(pass_thru_mgmt),
	.pass_thru_csb(pass_thru_mgmt_csb),
	.pass_thru_sck(pass_thru_mgmt_sck),
	.pass_thru_sdi(pass_thru_mgmt_sdi),
	.pass_thru_sdo(pass_thru_mgmt_sdo),

        .flash_csb (flash_csb),
        .flash_clk (flash_clk),

        .flash_csb_oeb (flash_csb_oeb),
        .flash_clk_oeb (flash_clk_oeb),

        .flash_io0_oeb (flash_io0_oeb),
        .flash_io1_oeb (flash_io1_oeb),
        .flash_io2_oeb (flash_io2_oeb),
        .flash_io3_oeb (flash_io3_oeb),

        .flash_csb_ieb (flash_csb_ieb),
        .flash_clk_ieb (flash_clk_ieb),

        .flash_io0_ieb (flash_io0_ieb),
        .flash_io1_ieb (flash_io1_ieb),
        .flash_io2_ieb (flash_io2_ieb),
        .flash_io3_ieb (flash_io3_ieb),

        .flash_io0_do (flash_io0_do),
        .flash_io1_do (flash_io1_do),
        .flash_io2_do (flash_io2_do),
        .flash_io3_do (flash_io3_do),

        .flash_io0_di (flash_io0_di),
        .flash_io1_di (flash_io1_di),
        .flash_io2_di (flash_io2_di),
        .flash_io3_di (flash_io3_di)
    );

    // Wishbone Slave uart	
    wire uart_stb_i;
    wire uart_ack_o;
    wire [31:0] uart_dat_o;
    wire uart_enabled;

    simpleuart_wb #(
        .BASE_ADR(UART_BASE_ADR),
        .CLK_DIV(UART_CLK_DIV),
        .DATA(UART_DATA)
    ) simpleuart (
        // Wishbone Interface
        .wb_clk_i(wb_clk_i),
        .wb_rst_i(wb_rst_i),

        .wb_adr_i(cpu_adr_o),      
        .wb_dat_i(cpu_dat_o),
        .wb_sel_i(cpu_sel_o),
        .wb_we_i(cpu_we_o),
        .wb_cyc_i(cpu_cyc_o),

        .wb_stb_i(uart_stb_i),
        .wb_ack_o(uart_ack_o),
        .wb_dat_o(uart_dat_o),

	.uart_enabled(uart_enabled),
        .ser_tx(ser_tx),
        .ser_rx(mgmt_in_data[5])
    );

    // Wishbone SPI master
    wire spi_master_stb_i;
    wire spi_master_ack_o;
    wire [31:0] spi_master_dat_o;

    simple_spi_master_wb #(
        .BASE_ADR(SPI_MASTER_BASE_ADR),
        .CONFIG(SPI_MASTER_CONFIG),
        .DATA(SPI_MASTER_DATA)
    ) simple_spi_master_inst (
        // Wishbone Interface
        .wb_clk_i(wb_clk_i),
        .wb_rst_i(wb_rst_i),

        .wb_adr_i(cpu_adr_o),      
        .wb_dat_i(cpu_dat_o),
        .wb_sel_i(cpu_sel_o),
        .wb_we_i(cpu_we_o),
        .wb_cyc_i(cpu_cyc_o),

        .wb_stb_i(spi_master_stb_i),
        .wb_ack_o(spi_master_ack_o),
        .wb_dat_o(spi_master_dat_o),

	.hk_connect(hk_connect),
        .csb(mgmt_out_pre[3]),
        .sck(mgmt_out_pre[4]),
        .sdi(mgmt_in_data[1]),
        .sdo(mgmt_out_pre[2]),
        .sdoenb(),
	.irq(irq_spi_master)
    );

    wire counter_timer_strobe, counter_timer_offset;
    wire counter_timer0_enable, counter_timer1_enable;
    wire counter_timer0_stop, counter_timer1_stop;

    // Wishbone Counter-timer 0
    wire counter_timer0_stb_i;
    wire counter_timer0_ack_o;
    wire [31:0] counter_timer0_dat_o;

    counter_timer_low_wb #(
        .BASE_ADR(COUNTER_TIMER0_BASE_ADR),
        .CONFIG(COUNTER_TIMER0_CONFIG),
        .VALUE(COUNTER_TIMER0_VALUE),
        .DATA(COUNTER_TIMER0_DATA)
    ) counter_timer_0 (
        // Wishbone Interface
        .wb_clk_i(wb_clk_i),
        .wb_rst_i(wb_rst_i),

        .wb_adr_i(cpu_adr_o),      
        .wb_dat_i(cpu_dat_o),
        .wb_sel_i(cpu_sel_o),
        .wb_we_i(cpu_we_o),
        .wb_cyc_i(cpu_cyc_o),

        .wb_stb_i(counter_timer0_stb_i),
        .wb_ack_o(counter_timer0_ack_o),
        .wb_dat_o(counter_timer0_dat_o),

	.enable_in(counter_timer1_enable),
	.stop_in(counter_timer1_stop),
	.strobe(counter_timer_strobe),
	.is_offset(counter_timer_offset),
	.enable_out(counter_timer0_enable),
	.stop_out(counter_timer0_stop),
	.irq(irq_counter_timer0)
    );

    // Wishbone Counter-timer 1
    wire counter_timer1_stb_i;
    wire counter_timer1_ack_o;
    wire [31:0] counter_timer1_dat_o;

    counter_timer_high_wb #(
        .BASE_ADR(COUNTER_TIMER1_BASE_ADR),
        .CONFIG(COUNTER_TIMER1_CONFIG),
        .VALUE(COUNTER_TIMER1_VALUE),
        .DATA(COUNTER_TIMER1_DATA)
    ) counter_timer_1 (
        // Wishbone Interface
        .wb_clk_i(wb_clk_i),
        .wb_rst_i(wb_rst_i),

        .wb_adr_i(cpu_adr_o),      
        .wb_dat_i(cpu_dat_o),
        .wb_sel_i(cpu_sel_o),
        .wb_we_i(cpu_we_o),
        .wb_cyc_i(cpu_cyc_o),

        .wb_stb_i(counter_timer1_stb_i),
        .wb_ack_o(counter_timer1_ack_o),
        .wb_dat_o(counter_timer1_dat_o),

	.enable_in(counter_timer0_enable),
	.strobe(counter_timer_strobe),
	.stop_in(counter_timer0_stop),
	.is_offset(counter_timer_offset),
	.enable_out(counter_timer1_enable),
	.stop_out(counter_timer1_stop),
	.irq(irq_counter_timer1)
    );

    // Wishbone Slave GPIO Registers
    wire gpio_stb_i;
    wire gpio_ack_o;
    wire [31:0] gpio_dat_o;

    gpio_wb #(
        .BASE_ADR(GPIO_BASE_ADR),
        .GPIO_DATA(GPIO_DATA),
        .GPIO_ENA(GPIO_ENA),
        .GPIO_PD(GPIO_PD),
        .GPIO_PU(GPIO_PU)
    ) gpio_wb (
        .wb_clk_i(wb_clk_i),
        .wb_rst_i(wb_rst_i),
        .wb_adr_i(cpu_adr_o), 
        .wb_dat_i(cpu_dat_o),
        .wb_sel_i(cpu_sel_o),
        .wb_we_i(cpu_we_o),
        .wb_cyc_i(cpu_cyc_o),
        .wb_stb_i(gpio_stb_i),
        .wb_ack_o(gpio_ack_o),
        .wb_dat_o(gpio_dat_o),
        .gpio_in_pad(gpio_in_pad),
        .gpio(gpio_out),
        .gpio_oeb(gpio_outenb),
        .gpio_pu(gpio_pullup),
        .gpio_pd(gpio_pulldown)
    );

    // Wishbone Slave System Control Register
    wire sys_stb_i;
    wire sys_ack_o;
    wire [31:0] sys_dat_o;
    
    sysctrl_wb #(
        .BASE_ADR(SYS_BASE_ADR),
        .PWRGOOD(PWRGOOD),
        .CLK_OUT(CLK_OUT),
        .TRAP_OUT(TRAP_OUT),
        .IRQ_SRC(IRQ_SRC)
    ) sysctrl (
        .wb_clk_i(wb_clk_i),
        .wb_rst_i(wb_rst_i),

        .wb_adr_i(cpu_adr_o), 
        .wb_dat_i(cpu_dat_o),
        .wb_sel_i(cpu_sel_o),
        .wb_we_i(cpu_we_o),
        .wb_cyc_i(cpu_cyc_o),
        
        .wb_stb_i(sys_stb_i),
        .wb_ack_o(sys_ack_o),
        .wb_dat_o(sys_dat_o),

	.usr1_vcc_pwrgood(mprj_vcc_pwrgood),
	.usr2_vcc_pwrgood(mprj2_vcc_pwrgood),
	.usr1_vdd_pwrgood(mprj_vdd_pwrgood),
	.usr2_vdd_pwrgood(mprj2_vdd_pwrgood),
        .trap_output_dest(trap_output_dest),
        .clk1_output_dest(clk1_output_dest),
        .clk2_output_dest(clk2_output_dest),
        .irq_7_inputsrc(irq_7_inputsrc),
        .irq_8_inputsrc(irq_8_inputsrc)
    );

    // Logic Analyzer 
    wire la_stb_i;
    wire la_ack_o;
    wire [31:0] la_dat_o;

    la_wb #(
        .BASE_ADR(LA_BASE_ADR),
        .LA_DATA_0(LA_DATA_0),
        .LA_DATA_1(LA_DATA_1),
        .LA_DATA_3(LA_DATA_3),
        .LA_ENA_0(LA_ENA_0),
        .LA_ENA_1(LA_ENA_1),
        .LA_ENA_2(LA_ENA_2),
        .LA_ENA_3(LA_ENA_3)
    ) la (
        .wb_clk_i(wb_clk_i),
        .wb_rst_i(wb_rst_i),

        .wb_adr_i(cpu_adr_o), 
        .wb_dat_i(cpu_dat_o),
        .wb_sel_i(cpu_sel_o),
        .wb_we_i(cpu_we_o),
        .wb_cyc_i(cpu_cyc_o),
        
        .wb_stb_i(la_stb_i),
        .wb_ack_o(la_ack_o),
        .wb_dat_o(la_dat_o),

        .la_data(la_output),
        .la_data_in(la_input),
        .la_oen(la_oen)
    );
    
    // User project WB MI A port
    assign mprj_cyc_o = cpu_cyc_o;
    assign mprj_we_o  = cpu_we_o;
    assign mprj_sel_o = cpu_sel_o;
    assign mprj_adr_o = cpu_adr_o;
    assign mprj_dat_o = cpu_dat_o;

    // WB Slave User Project Control
    wire mprj_ctrl_stb_i;
    wire mprj_ctrl_ack_o;
    wire [31:0] mprj_ctrl_dat_o;
    wire [`MPRJ_IO_PADS-1:0] mgmt_out_pre;

    // Bits assigned to specific functions as outputs prevent the
    // mprj GPIO-as-output from applying data when that function
    // is active

    assign mgmt_out_data[`MPRJ_IO_PADS-1:16] = mgmt_out_pre[`MPRJ_IO_PADS-1:16];

    // Routing of output monitors (PLL, trap, clk1, clk2)
    assign mgmt_out_data[15] = clk2_output_dest ? user_clk : mgmt_out_pre[15];
    assign mgmt_out_data[14] = clk1_output_dest ? clk : mgmt_out_pre[14];
    assign mgmt_out_data[13] = trap_output_dest ? trap : mgmt_out_pre[13];

    assign mgmt_out_data[12:7] = mgmt_out_pre[12:7];
    assign mgmt_out_data[6] = uart_enabled ? ser_tx : mgmt_out_pre[6];
    assign mgmt_out_data[5:0] = mgmt_out_pre[5:0];

    mprj_ctrl_wb #(
        .BASE_ADR(MPRJ_CTRL_ADR)
    ) mprj_ctrl (
        .wb_clk_i(wb_clk_i),
        .wb_rst_i(wb_rst_i),

        .wb_adr_i(cpu_adr_o), 
        .wb_dat_i(cpu_dat_o),
        .wb_sel_i(cpu_sel_o),
        .wb_we_i(cpu_we_o),
        .wb_cyc_i(cpu_cyc_o),
        .wb_stb_i(mprj_ctrl_stb_i),
        .wb_ack_o(mprj_ctrl_ack_o),
        .wb_dat_o(mprj_ctrl_dat_o),

	.serial_clock(mprj_io_loader_clock),
	.serial_resetn(mprj_io_loader_resetn),
	.serial_data_out(mprj_io_loader_data),
	.sdo_oenb_state(sdo_oenb_state),
	.jtag_oenb_state(jtag_oenb_state),
	.mgmt_gpio_out(mgmt_out_pre),
	.mgmt_gpio_in(mgmt_in_data),
	.pwr_ctrl_out(pwr_ctrl_out)
    );

    // Wishbone Slave RAM
    wire mem_stb_i;
    wire mem_ack_o;
    wire [31:0] mem_dat_o;

    mem_wb soc_mem (
    `ifdef LVS
        .VPWR(vdd1v8),
        .VGND(vss),
    `endif
        .wb_clk_i(wb_clk_i),
        .wb_rst_i(wb_rst_i),

        .wb_adr_i(cpu_adr_o), 
        .wb_dat_i(cpu_dat_o),
        .wb_sel_i(cpu_sel_o),
        .wb_we_i(cpu_we_o),
        .wb_cyc_i(cpu_cyc_o),

        .wb_stb_i(mem_stb_i),
        .wb_ack_o(mem_ack_o), 
        .wb_dat_o(mem_dat_o)
    );

    wire stg_rw_stb_i;
    wire stg_ro_stb_i;
    wire stg_rw_ack_o;
    wire stg_ro_ack_o;
    wire [31:0] stg_rw_dat_o;
    wire [31:0] stg_ro_dat_o;

    // Storage area wishbone brige
    storage_bridge_wb #(
        .RW_BLOCKS_ADR(RW_BLOCKS_ADR),
        .RO_BLOCKS_ADR(RO_BLOCKS_ADR)
    ) wb_bridge (
        .wb_clk_i(wb_clk_i),
        .wb_rst_i(wb_rst_i),
        .wb_adr_i(cpu_adr_o),
        .wb_dat_i(cpu_dat_o),
        .wb_sel_i(cpu_sel_o),
        .wb_we_i(cpu_we_o),
        .wb_cyc_i(cpu_cyc_o),
        .wb_stb_i({stg_ro_stb_i, stg_rw_stb_i}),
        .wb_ack_o({stg_ro_ack_o, stg_rw_ack_o}),
        .wb_rw_dat_o(stg_rw_dat_o),
        // MGMT_AREA RO WB Interface  
        .wb_ro_dat_o(stg_ro_dat_o),
        // MGMT Area native memory interface
        .mgmt_ena(mgmt_ena), 
        .mgmt_wen_mask(mgmt_wen_mask),
        .mgmt_wen(mgmt_wen),
        .mgmt_addr(mgmt_addr),
        .mgmt_wdata(mgmt_wdata),
        .mgmt_rdata(mgmt_rdata),
        // MGMT_AREA RO interface 
        .mgmt_ena_ro(mgmt_ena_ro),
        .mgmt_addr_ro(mgmt_addr_ro),
        .mgmt_rdata_ro(mgmt_rdata_ro)
    );

    // Wishbone intercon logic
    wb_intercon #(
        .AW(ADR_WIDTH),
        .DW(DAT_WIDTH),
        .NS(NUM_SLAVES),
        .ADR_MASK(ADR_MASK),
        .SLAVE_ADR(SLAVE_ADR)
    ) intercon (
        // Master Interface
        .wbm_adr_i(cpu_adr_o),
        .wbm_stb_i(cpu_stb_o),
        .wbm_dat_o(cpu_dat_i),
        .wbm_ack_o(cpu_ack_i),

        // Slaves Interface
        .wbs_stb_o({ sys_stb_i, spimemio_cfg_stb_i,
		mprj_stb_o, mprj_ctrl_stb_i, la_stb_i, 
		spi_master_stb_i, counter_timer1_stb_i, counter_timer0_stb_i,
		gpio_stb_i, uart_stb_i,
		spimemio_flash_stb_i, stg_ro_stb_i, stg_rw_stb_i, mem_stb_i }), 
        .wbs_dat_i({ sys_dat_o, spimemio_cfg_dat_o,
		mprj_dat_i, mprj_ctrl_dat_o, la_dat_o,
		spi_master_dat_o, counter_timer1_dat_o, counter_timer0_dat_o,
		gpio_dat_o, uart_dat_o,
		spimemio_flash_dat_o, stg_ro_dat_o ,stg_rw_dat_o, mem_dat_o }),
        .wbs_ack_i({ sys_ack_o, spimemio_cfg_ack_o,
		mprj_ack_i, mprj_ctrl_ack_o, la_ack_o,
		spi_master_ack_o, counter_timer1_ack_o, counter_timer0_ack_o,
		gpio_ack_o, uart_ack_o,
		spimemio_flash_ack_o, stg_ro_ack_o, stg_rw_ack_o, mem_ack_o })
    );

endmodule

// Implementation note:
// Replace the following two modules with wrappers for your SRAM cells.

module mgmt_soc_regs (
    input clk, wen,
    input [5:0] waddr,
    input [5:0] raddr1,
    input [5:0] raddr2,
    input [31:0] wdata,
    output [31:0] rdata1,
    output [31:0] rdata2
);
    reg [31:0] regs [0:31];

    always @(posedge clk)
        if (wen) regs[waddr[4:0]] <= wdata;

    assign rdata1 = regs[raddr1[4:0]];
    assign rdata2 = regs[raddr2[4:0]];
endmodule