| `default_nettype none |
| /* |
| * 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 USE_POWER_PINS |
| 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; |
| wire ser_tx; |
| |
| wire wb_clk_i; |
| wire wb_rst_i; |
| |
| 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; |
| wire mem_instr; |
| |
| 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 USE_POWER_PINS |
| .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 |
| `default_nettype wire |
