Subversion Repositories orsoc_graphics_accelerator

/*

ORSoC GFX accelerator core

Copyright 2012, ORSoC, Per Lenander, Anton Fosselius.

TOP MODULE

 This file is part of orgfx.

 orgfx is free software: you can redistribute it and/or modify

 it under the terms of the GNU Lesser General Public License as published by

 the Free Software Foundation, either version 3 of the License, or

 (at your option) any later version.

 orgfx 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 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License

 along with orgfx.  If not, see <http://www.gnu.org/licenses/>.

*/

module gfx_top (wb_clk_i, wb_rst_i, wb_inta_o,

  // Wishbone master signals (interfaces with video memory, write)

  wbm_write_cyc_o, wbm_write_stb_o, wbm_write_cti_o, wbm_write_bte_o, wbm_write_we_o, wbm_write_adr_o, wbm_write_sel_o, wbm_write_ack_i, wbm_write_err_i, wbm_write_dat_o,

  // Wishbone master signals (interfaces with video memory, read)

  wbm_read_cyc_o, wbm_read_stb_o, wbm_read_cti_o, wbm_read_bte_o, wbm_read_we_o, wbm_read_adr_o, wbm_read_sel_o, wbm_read_ack_i, wbm_read_err_i, wbm_read_dat_i,

  // Wishbone slave signals (interfaces with main bus/CPU)

  wbs_cyc_i, wbs_stb_i, wbs_cti_i, wbs_bte_i, wbs_we_i, wbs_adr_i, wbs_sel_i, wbs_ack_o, wbs_err_o, wbs_dat_i, wbs_dat_o

);

// Common wishbone signals

input         wb_clk_i;    // master clock input

input         wb_rst_i;    // Asynchronous active high reset

output        wb_inta_o;   // interrupt

// Wishbone master signals (write)

output        wbm_write_cyc_o;    // cycle output

output        wbm_write_stb_o;    // strobe output

output [ 2:0] wbm_write_cti_o;    // cycle type id

output [ 1:0] wbm_write_bte_o;    // burst type extension

output        wbm_write_we_o;     // write enable output

output [31:0] wbm_write_adr_o;    // address output

output [ 3:0] wbm_write_sel_o;    // byte select outputs (only 32bits accesses are supported)

input         wbm_write_ack_i;    // wishbone cycle acknowledge

input         wbm_write_err_i;    // wishbone cycle error

output [31:0] wbm_write_dat_o;    // wishbone data out

// Wishbone master signals (read)

output        wbm_read_cyc_o;    // cycle output

output        wbm_read_stb_o;    // strobe output

output [ 2:0] wbm_read_cti_o;    // cycle type id

output [ 1:0] wbm_read_bte_o;    // burst type extension

output        wbm_read_we_o;     // write enable output

output [31:0] wbm_read_adr_o;    // address output

output [ 3:0] wbm_read_sel_o;    // byte select outputs (only 32bits accesses are supported)

input         wbm_read_ack_i;    // wishbone cycle acknowledge

input         wbm_read_err_i;    // wishbone cycle error

input [31:0]  wbm_read_dat_i;    // wishbone data in

// Wishbone slave signals

input         wbs_cyc_i;    // cycle input

input         wbs_stb_i;    // strobe input

input [ 2:0]  wbs_cti_i;    // cycle type id

input [ 1:0]  wbs_bte_i;    // burst type extension

input         wbs_we_i;     // write enable input

input [31:0]  wbs_adr_i;    // address input

input [ 3:0]  wbs_sel_i;    // byte select input (only 32bits accesses are supported)

output        wbs_ack_o;    // wishbone cycle acknowledge

output        wbs_err_o;    // wishbone cycle error

input  [31:0] wbs_dat_i;    // wishbone data in

output [31:0] wbs_dat_o;    // wishbone data out

// Wires and variables

wire wbmwriter_sint; // connect to slave interface

wire wbmreader_sint;

wire raster_wbs_pipeline_ack;

wire [31:2] target_base_reg;

wire [15:0] wbs_raster_target_size_x;

wire [15:0] wbs_raster_target_size_y;

wire [15:0] target_size_x_reg;

wire [15:0] target_size_y_reg;

assign target_size_x_reg = wbs_raster_target_size_x;

assign target_size_y_reg = wbs_raster_target_size_y;

wire [31:2] wbs_fragment_tex0_base;

wire [15:0] wbs_fragment_tex0_size_x;

wire [15:0] wbs_fragment_tex0_size_y;

wire [31:2] render_wbmwriter_addr;

wire [3:0]  render_wbmwriter_sel;

wire [31:0] render_wbmwriter_dat;

wire [1:0] color_depth_reg;

wire render_wbmwriter_memory_pixel_write;

wire wbs_raster_rect_write;

wire wbs_raster_line_write;

wire wbmwriter_render_ack;

// src pixel

wire [15:0] wbs_raster_src_pixel0_x;

wire [15:0] wbs_raster_src_pixel0_y;

wire [15:0] wbs_raster_src_pixel1_x;

wire [15:0] wbs_raster_src_pixel1_y;

// dest pixel

wire [15:0] wbs_raster_dest_pixel0_x;

wire [15:0] wbs_raster_dest_pixel0_y;

wire [15:0] wbs_raster_dest_pixel1_x;

wire [15:0] wbs_raster_dest_pixel1_y;

// clip pixel

wire [15:0] wbs_raster_clip_pixel0_x;

wire [15:0] wbs_raster_clip_pixel0_y;

wire [15:0] wbs_raster_clip_pixel1_x;

wire [15:0] wbs_raster_clip_pixel1_y;

wire [31:0] wbs_fragment_color;

wire texture_enable_reg;

wire        blending_enable_reg;

wire [7:0]  global_alpha_reg;

wire        colorkey_enable_reg;

wire [31:0] colorkey_reg;

// Slave wishbone interface. Reads wishbone bus and fills registers

gfx_wbs wb_databus (

  .clk_i             (wb_clk_i),

  .rst_i             (wb_rst_i),

  .adr_i             (wbs_adr_i[9:0]),

  .dat_i             (wbs_dat_i),

  .dat_o             (wbs_dat_o),

  .sel_i             (wbs_sel_i),

  .we_i              (wbs_we_i),

  .stb_i             (wbs_stb_i),

  .cyc_i             (wbs_cyc_i),

  .ack_o             (wbs_ack_o),

  .rty_o             (),

  .err_o             (wbs_err_o),

  .inta_o            (wb_inta_o),

  //source pixel

  .src_pixel0_x_o    (wbs_raster_src_pixel0_x),

  .src_pixel0_y_o    (wbs_raster_src_pixel0_y),

  .src_pixel1_x_o    (wbs_raster_src_pixel1_x),

  .src_pixel1_y_o    (wbs_raster_src_pixel1_y),

  //destination pixel

  .dest_pixel0_x_o   (wbs_raster_dest_pixel0_x),

  .dest_pixel0_y_o   (wbs_raster_dest_pixel0_y),

  .dest_pixel1_x_o   (wbs_raster_dest_pixel1_x),

  .dest_pixel1_y_o   (wbs_raster_dest_pixel1_y),

  //clip pixel

  .clip_pixel0_x_o   (wbs_raster_clip_pixel0_x),

  .clip_pixel0_y_o   (wbs_raster_clip_pixel0_y),

  .clip_pixel1_x_o   (wbs_raster_clip_pixel1_x),

  .clip_pixel1_y_o   (wbs_raster_clip_pixel1_y),

  .color_o           (wbs_fragment_color),

  .target_base_o     (target_base_reg),

  .target_size_x_o   (wbs_raster_target_size_x),

  .target_size_y_o   (wbs_raster_target_size_y),

  .tex0_base_o       (wbs_fragment_tex0_base),

  .tex0_size_x_o     (wbs_fragment_tex0_size_x),

  .tex0_size_y_o     (wbs_fragment_tex0_size_y),

  .color_depth_o     (color_depth_reg),

  .rect_write_o      (wbs_raster_rect_write),

  .line_write_o      (wbs_raster_line_write),

  .sint_i            (wbmwriter_sint | wbmreader_sint),

  .pipeline_ack_i    (raster_wbs_pipeline_ack),

  .texture_enable_o  (texture_enable_reg),

  .blending_enable_o (blending_enable_reg),

  .global_alpha_o    (global_alpha_reg),

  .colorkey_enable_o (colorkey_enable_reg),

  .colorkey_o        (colorkey_reg)

  );

/*

// TODO: Remove temp wires

wire vector_in;

wire vector;

// Vector processor applies transforms to points

gfx_vector_processor vp0 (

  .clk_i        (wb_clk_i),

  .rst_i        (wb_rst_i),

  .vector_i     (vector_in),

  .vector_o     (vector)

  );

*/

wire raster_fragment_write_enable;

wire [15:0] raster_fragment_x_pixel;

wire [15:0] raster_fragment_y_pixel;

wire fragment_raster_ack;

wire [15:0] raster_fragment_u;

wire [15:0] raster_fragment_v;

// Rasterizer generates pixels to calculate

gfx_rasterizer rasterizer0 (

  .clk_i            (wb_clk_i),

  .rst_i            (wb_rst_i),

  .ack_i            (fragment_raster_ack),

  .ack_o            (raster_wbs_pipeline_ack),

  .rect_write_i     (wbs_raster_rect_write),

  .line_write_i     (wbs_raster_line_write),

  .texture_enable_i (texture_enable_reg),

  // source pixel coordinates

  .src_pixel0_x_i   (wbs_raster_src_pixel0_x),

  .src_pixel0_y_i   (wbs_raster_src_pixel0_y),

  .src_pixel1_x_i   (wbs_raster_src_pixel1_x),

  .src_pixel1_y_i   (wbs_raster_src_pixel1_y),

  // destination pixel coordinates

  .dest_pixel0_x_i  (wbs_raster_dest_pixel0_x),

  .dest_pixel0_y_i  (wbs_raster_dest_pixel0_y),

  .dest_pixel1_x_i  (wbs_raster_dest_pixel1_x),

  .dest_pixel1_y_i  (wbs_raster_dest_pixel1_y),

  // clip pixel coordinates

  .clip_pixel0_x_i  (wbs_raster_clip_pixel0_x),

  .clip_pixel0_y_i  (wbs_raster_clip_pixel0_y),

  .clip_pixel1_x_i  (wbs_raster_clip_pixel1_x),

  .clip_pixel1_y_i  (wbs_raster_clip_pixel1_y),

  // Screen size

  .target_size_x_i  (wbs_raster_target_size_x),

  .target_size_y_i  (wbs_raster_target_size_y),

  // Output pixel

  .x_counter_o      (raster_fragment_x_pixel),

  .y_counter_o      (raster_fragment_y_pixel),

  .u_o              (raster_fragment_u),

  .v_o              (raster_fragment_v),

  .write_o          (raster_fragment_write_enable)

  );

wire fragment_blender_write_enable;

wire [15:0] fragment_blender_x_pixel;

wire [15:0] fragment_blender_y_pixel;

wire blender_fragment_ack;

wire [31:0] fragment_blender_color;

wire [7:0] fragment_blender_alpha;

wire wbmreader_fragment_texture_ack;

wire [31:0] wbmreader_fragment_texture_data;

wire [31:2] fragment_wbmreader_texture_addr;

wire [3:0] fragment_wbmreader_texture_sel;

wire fragment_wbmreader_texture_request;

// Fragment processor generates color of pixel (requires RAM read for textures)

gfx_fragment_processor fp0 (

  .clk_i             (wb_clk_i),

  .rst_i             (wb_rst_i),

  .global_alpha_i    (global_alpha_reg),

  .x_counter_i       (raster_fragment_x_pixel),

  .y_counter_i       (raster_fragment_y_pixel),

  .u_i               (raster_fragment_u),

  .v_i               (raster_fragment_v),

  .ack_i             (blender_fragment_ack),

  .write_i           (raster_fragment_write_enable),

  .pixel_x_o         (fragment_blender_x_pixel),

  .pixel_y_o         (fragment_blender_y_pixel),

  .pixel_color_i     (wbs_fragment_color),

  .pixel_color_o     (fragment_blender_color),

  .pixel_alpha_o     (fragment_blender_alpha),

  .write_o           (fragment_blender_write_enable),

  .ack_o             (fragment_raster_ack),

  .texture_ack_i     (wbmreader_fragment_texture_ack),

  .texture_data_i    (wbmreader_fragment_texture_data),

  .texture_addr_o    (fragment_wbmreader_texture_addr),

  .texture_sel_o     (fragment_wbmreader_texture_sel),

  .texture_request_o (fragment_wbmreader_texture_request),

  .texture_enable_i  (texture_enable_reg),

  .tex0_base_i       (wbs_fragment_tex0_base),

  .tex0_size_x_i     (wbs_fragment_tex0_size_x),

  .tex0_size_y_i     (wbs_fragment_tex0_size_y),

  .color_depth_i     (color_depth_reg),

  .colorkey_enable_i (colorkey_enable_reg),

  .colorkey_i        (colorkey_reg)

  );

wire blender_render_write_enable;

wire [15:0] blender_render_x_pixel;

wire [15:0] blender_render_y_pixel;

wire render_blender_ack;

wire [31:0] blender_render_color;

// Connected through arbiter

wire wbmreader_blender_target_ack;

wire [31:2] blender_wbmreader_target_addr;

wire [31:0] wbmreader_blender_target_data;

wire [3:0] blender_wbmreader_target_sel;

wire blender_wbmreader_target_request;

wire wbmreader_blender_busy;

// Applies alpha blending if enabled (requires RAM read to get target pixel color)

// Fragment processor generates color of pixel (requires RAM read for textures)

gfx_blender blender0 (

  .clk_i            (wb_clk_i),

  .rst_i            (wb_rst_i),

  .blending_enable_i (blending_enable_reg),

  // Render target information

  .target_base_i    (target_base_reg),

  .target_size_x_i  (target_size_x_reg),

  .target_size_y_i  (target_size_y_reg),

  .color_depth_i    (color_depth_reg),

  .x_counter_i      (fragment_blender_x_pixel),

  .y_counter_i      (fragment_blender_y_pixel),

  .alpha_i          (fragment_blender_alpha),

  .ack_i            (render_blender_ack),

  .target_ack_i     (wbmreader_blender_target_ack),

  .target_addr_o    (blender_wbmreader_target_addr),

  .target_data_i    (wbmreader_blender_target_data),

  .target_sel_o     (blender_wbmreader_target_sel),

  .target_request_o (blender_wbmreader_target_request),

  .wbm_busy_i       (wbmreader_blender_busy),

  .write_i          (fragment_blender_write_enable),

  .pixel_x_o        (blender_render_x_pixel),

  .pixel_y_o        (blender_render_y_pixel),

  .pixel_color_i    (fragment_blender_color),

  .pixel_color_o    (blender_render_color),

  .write_o          (blender_render_write_enable),

  .ack_o            (blender_fragment_ack)

  );

// Write pixel to target (check for out of bounds)

gfx_renderer renderer (

  .clk_i           (wb_clk_i),

  .rst_i           (wb_rst_i),

  // Render target information

  .target_base_i   (target_base_reg),

  .target_size_x_i (target_size_x_reg),

  .target_size_y_i (target_size_y_reg),

  .color_depth_i   (color_depth_reg),

  // Input pixel

  .pixel_x_i       (blender_render_x_pixel),

  .pixel_y_i       (blender_render_y_pixel),

  .color_i         (blender_render_color),

  .render_addr_o   (render_wbmwriter_addr),

  .render_sel_o    (render_wbmwriter_sel),

  .render_dat_o    (render_wbmwriter_dat),

  .ack_o           (render_blender_ack),

  .ack_i           (wbmwriter_render_ack),

  .write_i         (blender_render_write_enable),

  .write_o         (render_wbmwriter_memory_pixel_write)

  );

// Instansiate wishbone master interface (write only)

gfx_wbm_write wbm_writer (

  .clk_i           (wb_clk_i),

  .rst_i           (wb_rst_i),

  .cyc_o           (wbm_write_cyc_o),

  .stb_o           (wbm_write_stb_o),

  .cti_o           (wbm_write_cti_o),

  .bte_o           (wbm_write_bte_o),

  .we_o            (wbm_write_we_o),

  .adr_o           (wbm_write_adr_o),

  .sel_o           (wbm_write_sel_o),

  .ack_i           (wbm_write_ack_i),

  .err_i           (wbm_write_err_i),

  .dat_o           (wbm_write_dat_o),

  .sint_o          (wbmwriter_sint),

  .write_i         (render_wbmwriter_memory_pixel_write),

  .ack_o           (wbmwriter_render_ack),

  // send ack to renderer when done writing to memory.

  .render_addr_i   (render_wbmwriter_addr),

  .render_sel_i    (render_wbmwriter_sel),

  .render_dat_i    (render_wbmwriter_dat)

  );

wire wbmreader_arbiter_ack;

wire [31:2] arbiter_wbmreader_addr;

wire [31:0] wbmreader_arbiter_data;

wire [3:0] arbiter_wbmreader_sel;

wire arbiter_wbmreader_request;

// Instansiate wbm reader arbiter

gfx_wbm_read_arbiter wbm_arbiter (

  .master_busy_o     (wbmreader_blender_busy),

  // Interface against the wbm read module

  .read_request_o    (arbiter_wbmreader_request),

  .addr_o            (arbiter_wbmreader_addr),

  .sel_o             (arbiter_wbmreader_sel),

  .dat_i             (wbmreader_arbiter_data),

  .ack_i             (wbmreader_arbiter_ack),

  // Interface against masters (fragment processor)

  .m0_read_request_i (fragment_wbmreader_texture_request),

  .m0_addr_i         (fragment_wbmreader_texture_addr),

  .m0_sel_i          (fragment_wbmreader_texture_sel),

  .m0_dat_o          (wbmreader_fragment_texture_data),

  .m0_ack_o          (wbmreader_fragment_texture_ack),

  // Interface against masters (blender)

  .m1_read_request_i (blender_wbmreader_target_request),

  .m1_addr_i         (blender_wbmreader_target_addr),

  .m1_sel_i          (blender_wbmreader_target_sel),

  .m1_dat_o          (wbmreader_blender_target_data),

  .m1_ack_o          (wbmreader_blender_target_ack)

  );

// Instansiate wishbone master interface (read only for textures)

gfx_wbm_read wbm_reader (

  .clk_i            (wb_clk_i),

  .rst_i            (wb_rst_i),

  .cyc_o            (wbm_read_cyc_o),

  .stb_o            (wbm_read_stb_o),

  .cti_o            (wbm_read_cti_o),

  .bte_o            (wbm_read_bte_o),

  .we_o             (wbm_read_we_o),

  .adr_o            (wbm_read_adr_o),

  .sel_o            (wbm_read_sel_o),

  .ack_i            (wbm_read_ack_i),

  .err_i            (wbm_read_err_i),

  .dat_i            (wbm_read_dat_i),

  .sint_o           (wbmreader_sint),

  // send ack to renderer when done writing to memory.

  .read_request_i   (arbiter_wbmreader_request),

  .texture_addr_i   (arbiter_wbmreader_addr),

  .texture_sel_i    (arbiter_wbmreader_sel),

  .texture_dat_o    (wbmreader_arbiter_data),

  .texture_data_ack (wbmreader_arbiter_ack)

  );

endmodule