Subversion Repositories rtf_sprite_controller

`timescale 1ns / 1ps

// ============================================================================

//        __

//   \\__/ o\    (C) 2005-2022  Robert Finch, Waterloo

//    \  __ /    All rights reserved.

//     \/_//     robfinch@finitron.ca

//       ||

//

//      rfSpriteController.sv

//              sprite / hardware cursor controller

//

// BSD 3-Clause License

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are met:

//

// 1. Redistributions of source code must retain the above copyright notice, this

//    list of conditions and the following disclaimer.

//

// 2. Redistributions in binary form must reproduce the above copyright notice,

//    this list of conditions and the following disclaimer in the documentation

//    and/or other materials provided with the distribution.

//

// 3. Neither the name of the copyright holder nor the names of its

//    contributors may be used to endorse or promote products derived from

//    this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE

// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//

//

//      Sprite Controller

//

//      FEATURES

//      - parameterized number of sprites 1,2,4,6,8,14,16 or 32

//      - sprite image cache buffers

//              - each image cache is capable of holding multiple

//                sprite images

//              - an embedded DMA controller is used for sprite reload

//      - programmable image offset within cache

//      - programmable sprite width,height, and pixel size

//              - sprite width and height may vary from 1 to 256 as long

//                as the product doesn't exceed 4096.

//          - pixels may be programmed to be 1,2,3 or 4 video clocks

//            both height and width are programmable

//      - programmable sprite position

//      - programmable 8, 16 or 32 bits for color

//              eg 32k color + 1 bit alpha blending indicator (1,5,5,5)

//      - fixed display and DMA priority

//          sprite 0 highest, sprite 31 lowest

//      - graphics plane control

//

//              This core requires an external timing generator to

//      provide horizontal and vertical sync signals, but

//      otherwise can be used as a display controller on it's

//      own. However, normally this core would be embedded

//      within another core such as a VGA controller. Sprite

//      positions are referenced to the rising edge of the

//      vertical and horizontal sync pulses.

//              The core includes an embedded dual port RAM to hold the

//      sprite images. The image RAM is updated using a built in DMA

//      controller. The DMA controller uses 32 bit accesses to fill

//      the sprite buffers. The circuit features an automatic bus

//  transaction timeout; if the system bus hasn't responded

//  within 20 clock cycles, the DMA controller moves onto the

//  next address.

//              The controller uses a ram underlay to cache the values

//      of the registers. This is a lot cheaper resource wise than

//      using a 32 to 1 multiplexor (well at least for an FPGA).

//

//      All registers are 32 bits wide

//

//      These registers repeat in incrementing block of four registers

//      and pertain to each sprite

//      00:     - position register

//              HPOS    [11: 0] horizontal position (hctr value)

//          VPOS        [27:16] vertical position (vctr value)

//

//      04:     SZ      - size register

//                      bits

//                      [ 7: 0] width of sprite in pixels - 1

//                      [15: 8] height of sprite in pixels -1

//                      [19:16] size of horizontal pixels - 1 in clock cycles

//                      [23:20] size of vertical pixels in scan-lines - 1

//                              * the product of width * height cannot exceed 2048 !

//                              if it does, the display will begin repeating

//                      [27:24] output plane

//                      [31:30] color depth 01=RGB332,10=RGB555+A,11=RGB888+A

//

//      08: ADR [31:12] 20 bits sprite image address bits

//                      This registers contain the high order address bits of the

//          location of the sprite image in system memory.

//                      The DMA controller will assign the low order 12 bits

//                      during DMA.

//                  [11:0] image offset bits [11:0]

//                      offset of the sprite image within the sprite image cache

//                      typically zero

//

//      0C: TC  [23:0]  transparent color

//                      This register identifies which color of the sprite

//                      is transparent

//

//

//

//      0C-1FC: registers reserved for up to thirty-one other sprites

//

//      200:            DMA burst reg sprite 0

//                              [8:0]  burst start

//                              [24:16] burst end

//      ...

//      27C:            DMA burst reg sprite 31

//

//  280:        [ 7: 0] Frame size, multiples of 16 pixels

//                              [15: 8] Number of frames of animation

//        [25:16] Animation Rate

//                              [29:26] Frame size, LSBs 0 to 3

//                              [30]            Auto repeat

//                              [31]    Enable animation

//  ...

//      2FC:    Animation register sprite #31

//

//      Global status and control

//      3C0: EN [31:0] sprite enable register

//  3C4: IE     [31:0] sprite interrupt enable / status

//      3C8: SCOL       [31:0] sprite-sprite collision register

//      3CC: BCOL       [31:0] sprite-background collision register

//      3D0: DT         [31:0] sprite DMA trigger on

//      3D4: DT         [31:0] sprite DMA trigger off

//      3D8: VDT        [31:0] sprite vertical sync DMA trigger

//      3EC: BC   [29:0] background color

//  3FC: ADDR   [31:0] sprite DMA address bits [63:32]

//

//=============================================================================

import wishbone_pkg::*;

module rfSpriteController(

// Bus Slave interface

//------------------------------

// Slave signals

input rst_i,                    // reset

input s_clk_i,          // clock

input s_cs_i,

input   wb_write_request32_t wbs_req,

output wb_read_response32_t wbs_resp,

//------------------------------

// Bus Master Signals

input m_clk_i,                          // clock

output wb_write_request128_t wbm_req,

input wb_read_response128_t wbm_resp,

output [4:0] m_spriteno_o,

//--------------------------

input dot_clk_i,                // video dot clock

input hsync_i,                  // horizontal sync pulse

input vsync_i,                  // vertical sync pulse

input blank_i,                  // blanking signal

input [39:0] zrgb_i,                    // input pixel stream

output [39:0] zrgb_o,   // output pixel stream 12-12-12-4

output irq,                                     // interrupt request

input test,

input xonoff_i

);

reg m_soc_o;

wire vclk = dot_clk_i;

wire hSync = hsync_i;

wire vSync = vsync_i;

reg [39:0] zrgb_o;

//--------------------------------------------------------------------

// Core Parameters

//--------------------------------------------------------------------

parameter pnSpr = 32;           // number of sprites

parameter phBits = 12;          // number of bits in horizontal timing counter

parameter pvBits = 12;          // number of bits in vertical timing counter

localparam pnSprm = pnSpr-1;

//--------------------------------------------------------------------

// Variable Declarations

//--------------------------------------------------------------------

reg ce;                                                                         // controller enable

wb_write_request32_t wb_reqs;   // synchronized request

wire [4:0] sprN = wb_reqs.adr[8:4];

reg [phBits-1:0] hctr;          // horizontal reference counter (counts dots since hSync)

reg [pvBits-1:0] vctr;          // vertical reference counter (counts scanlines since vSync)

reg sprSprIRQ;

reg sprBkIRQ;

reg [31:0] out;                 // sprite output

reg outact;                             // sprite output is active

reg [3:0] outplane;

reg [pnSprm:0] bkCollision;             // sprite-background collision

reg [29:0] bgTc;                        // background transparent color

reg [29:0] bkColor;             // background color

reg [pnSprm:0] sprWe;   // block ram write enable for image cache update

reg [pnSprm:0] sprRe;   // block ram read enable for image cache update

// Global control registers

reg [31:0] sprEn;       // enable sprite

reg [pnSprm:0] sprCollision;        // sprite-sprite collision

reg sprSprIe;                   // sprite-sprite interrupt enable

reg sprBkIe;            // sprite-background interrupt enable

reg sprSprIRQPending;   // sprite-sprite collision interrupt pending

reg sprBkIRQPending;    // sprite-background collision interrupt pending

reg sprSprIRQPending1;  // sprite-sprite collision interrupt pending

reg sprBkIRQPending1;   // sprite-background collision interrupt pending

reg sprSprIRQ1;                 // vclk domain regs

reg sprBkIRQ1;

// Sprite control registers

reg [31:0] sprSprCollision;

reg [pnSprm:0] sprSprCollision1;

reg [31:0] sprBkCollision;

reg [pnSprm:0] sprBkCollision1;

reg [23:0] sprTc [pnSprm:0];            // sprite transparent color code

// How big the pixels are:

// 1 to 16 video clocks

reg [3:0] hSprRes [pnSprm:0];           // sprite horizontal resolution

reg [3:0] vSprRes [pnSprm:0];           // sprite vertical resolution

reg [7:0] sprWidth [pnSprm:0];          // number of pixels in X direction

reg [7:0] sprHeight [pnSprm:0];         // number of vertical pixels

reg [3:0] sprPlane [pnSprm:0];          // output plane sprite is in

reg [1:0] sprColorDepth [pnSprm:0];

reg [1:0] colorBits;

// Sprite DMA control

reg [8:0] sprBurstStart [pnSprm:0];

reg [8:0] sprBurstEnd   [pnSprm:0];

reg [31:0] vSyncT;                                                              // DMA on vSync

// display and timing signals

reg [31:0] hSprReset;   // horizontal reset

reg [31:0] vSprReset;   // vertical reset

reg [31:0] hSprDe;              // sprite horizontal display enable

reg [31:0] vSprDe;              // sprite vertical display enable

reg [31:0] sprDe;                       // display enable

reg [phBits-1:0] hSprPos [pnSprm:0];    // sprite horizontal position

reg [pvBits-1:0] vSprPos [pnSprm:0];    // sprite vertical position

reg [7:0] hSprCnt [pnSprm:0];   // sprite horizontal display counter

reg [7:0] vSprCnt [pnSprm:0];   // vertical display counter

reg [11:0] sprImageOffs [pnSprm:0];     // offset within sprite memory

reg [12:0] sprAddr [pnSprm:0];  // index into sprite memory (pixel number)

reg [9:0] sprAddr1 [pnSprm:0];  // index into sprite memory

reg [2:0] sprAddr2 [pnSprm:0];  // index into sprite memory

reg [2:0] sprAddr3 [pnSprm:0];  // index into sprite memory

reg [2:0] sprAddr4 [pnSprm:0];  // index into sprite memory

reg [2:0] sprAddr5 [pnSprm:0];  // index into sprite memory

reg [11:0] sprAddrB [pnSprm:0]; // backup address cache for rescan

wire [31:0] sprOut4 [pnSprm:0]; // sprite image data output

reg [31:0] sprOut [pnSprm:0];   // sprite image data output

reg [31:0] sprOut5 [pnSprm:0];  // sprite image data output

// Animation

reg [11:0] sprFrameSize [pnSprm:0];

reg [7:0] sprFrames [pnSprm:0];

reg [7:0] sprCurFrame [pnSprm:0];

reg [9:0] sprRate [pnSprm:0];

reg [9:0] sprCurRateCount [pnSprm:0];

reg [pnSprm:0] sprEnableAnimation;

reg [pnSprm:0] sprAutoRepeat;

// DMA access

reg [31:12] sprSysAddr [pnSprm:0];      // system memory address of sprite image (low bits)

reg [4:0] dmaOwner;                     // which sprite has the DMA channel

reg [31:0] sprDt;               // DMA trigger register

reg dmaActive;                          // this flag indicates that a block DMA transfer is active

genvar g;

//--------------------------------------------------------------------

// DMA control / bus interfacing

//--------------------------------------------------------------------

reg cs_regs;

always_ff @(posedge s_clk_i)

        cs_regs <= wbs_req.cyc & wbs_req.stb & s_cs_i;

always_ff @(posedge s_clk_i)

        wb_reqs <= wbs_req;

wire s_ack_o;

ack_gen #(

        .READ_STAGES(3),

        .WRITE_STAGES(1),

        .REGISTER_OUTPUT(1)

)

uag1 (

        .clk_i(s_clk_i),

        .ce_i(1'b1),

        .i(cs_regs),

        .we_i(cs_regs & wb_reqs.we),

        .o(s_ack_o),

        .rid_i(0),

        .wid_i(0),

        .rid_o(),

        .wid_o()

);

always_comb

begin

        wbs_resp.ack = s_ack_o & wbs_req.cyc & wbs_req.stb;

        wbs_resp.next = s_ack_o & wbs_req.cyc & wbs_req.stb;

end

assign irq = sprSprIRQ|sprBkIRQ;

//--------------------------------------------------------------------

// DMA control / bus interfacing

//--------------------------------------------------------------------

reg [5:0] dmaStart;

reg [8:0] cob;  // count of burst cycles

assign wbm_req.bte = LINEAR;

assign wbm_req.cti = CLASSIC;

assign wbm_req.stb = wbm_req.cyc;

assign wbm_req.sel = 16'hFFFF;

assign wbm_req.cid = 4'd5;

assign m_spriteno_o = dmaOwner;

reg [2:0] mstate;

parameter IDLE = 3'd0;

parameter ACTIVE = 3'd1;

parameter ACK = 3'd2;

parameter NACK = 3'd3;

wire pe_m_ack_i;

edge_det ued2 (.rst(rst_i), .clk(m_clk_i), .ce(1'b1), .i(wbm_resp.ack), .pe(pe_m_ack_i), .ne(), .ee());

always_ff @(posedge m_clk_i)

if (rst_i)

        mstate <= IDLE;

else begin

        case(mstate)

        IDLE:

                if (|sprDt & ce)

                        mstate <= ACTIVE;

        ACTIVE:

                mstate <= ACK;

        ACK:

                if (wbm_resp.ack | wbm_resp.err)

                        mstate <= NACK;

        NACK:

                if (~(wbm_resp.ack|wbm_resp.err))

                        mstate <= cob==sprBurstEnd[dmaOwner] ? IDLE : ACTIVE;

        default:

                mstate <= IDLE;

        endcase

end

integer n30;

always_ff @(posedge m_clk_i)

begin

        case(mstate)

        IDLE:

                begin

                        dmaOwner <= 5'd0;

                        for (n30 = pnSprm; n30 >= 0; n30 = n30 - 1)

                                if (sprDt[n30])

                                        dmaOwner <= n30;

                end

        default:        ;

        endcase

end

always_ff @(posedge m_clk_i)

if (rst_i)

        dmaStart <= 6'b0;

else begin

        dmaStart <= {dmaStart[4:0],1'b0};

        case(mstate)

        IDLE:

                if (|sprDt & ce)

                        dmaStart <= 6'h3F;

        default:        ;

        endcase

end

integer n32;

always_ff @(posedge m_clk_i)

begin

        case(mstate)

        IDLE:

                for (n32 = pnSprm; n32 >= 0; n32 = n32 - 1)

                        if (sprDt[n32])

                                cob <= sprBurstStart[n32];

        ACTIVE:

                cob <= cob + 2'd2;

        default:        ;

        endcase

end

always_ff @(posedge m_clk_i)

if (rst_i)

        wb_m_nack();

else begin

        case(mstate)

        IDLE:

                wb_m_nack();

        ACTIVE:

                begin

                        wbm_req.cyc <= 1'b1;

                        wbm_req.adr <= {sprSysAddr[dmaOwner],cob[8:1],4'h0};

                end

        ACK:

                if (wbm_resp.ack|wbm_resp.err)

                        wb_m_nack();

        endcase

end

task wb_m_nack;

begin

        wbm_req.cyc <= 1'b0;

end

endtask

// generate a write enable strobe for the sprite image memory

integer n1;

reg [8:0] m_adr_or;

reg [127:0] m_dat_ir;

reg ack1;

always_ff @(posedge m_clk_i)

for (n1 = 0; n1 < pnSpr; n1 = n1 + 1)

        sprWe[n1] <= (dmaOwner==n1 && (pe_m_ack_i||ack1));

always_ff @(posedge m_clk_i)

        ack1 <= pe_m_ack_i;

always_ff @(posedge m_clk_i)

if (pe_m_ack_i|ack1)

        m_adr_or <= {wbm_req.adr[11:4],ack1};

always_ff @(posedge m_clk_i)

if (pe_m_ack_i) begin

        if (test)

                m_dat_ir <= {8{1'b0,dmaOwner,10'b0}};

        else

                m_dat_ir <= {wbm_resp.dat[63:0],wbm_resp.dat[127:64]};

end

else if (ack1)

        m_dat_ir <= {64'd0,m_dat_ir[127:64]};

//--------------------------------------------------------------------

//--------------------------------------------------------------------

reg [31:0] reg_shadow [0:255];

reg [7:0] radr;

always_ff @(posedge s_clk_i)

begin

    if (cs_regs & wb_reqs.we & wb_reqs.sel[0])  reg_shadow[wb_reqs.adr[9:2]][7:0] <= wb_reqs.dat[7:0];

    if (cs_regs & wb_reqs.we & wb_reqs.sel[1])  reg_shadow[wb_reqs.adr[9:2]][15:8] <= wb_reqs.dat[15:8];

    if (cs_regs & wb_reqs.we & wb_reqs.sel[2])  reg_shadow[wb_reqs.adr[9:2]][23:16] <= wb_reqs.dat[23:16];

    if (cs_regs & wb_reqs.we & wb_reqs.sel[3])  reg_shadow[wb_reqs.adr[9:2]][31:24] <= wb_reqs.dat[31:24];

end

always @(posedge s_clk_i)

  radr <= wb_reqs.adr[9:2];

wire [31:0] reg_shadow_o = reg_shadow[radr];

// register/sprite memory output mux

always_ff @(posedge s_clk_i)

        if (cs_regs)

                case (wb_reqs.adr[9:2])         // synopsys full_case parallel_case

                8'b11110000:    wbs_resp.dat <= sprEn;

                8'b11110001:    wbs_resp.dat <= {sprBkIRQPending|sprSprIRQPending,5'b0,sprBkIRQPending,sprSprIRQPending,6'b0,sprBkIe,sprSprIe};

                8'b11110010:    wbs_resp.dat <= sprSprCollision;

                8'b11110011:    wbs_resp.dat <= sprBkCollision;

                8'b11110100:    wbs_resp.dat <= sprDt;

                default:        wbs_resp.dat <= reg_shadow_o;

                endcase

        else

                wbs_resp.dat <= 32'h0;

// vclk -> clk_i

always @(posedge s_clk_i)

begin

        sprSprIRQ <= sprSprIRQ1;

        sprBkIRQ <= sprBkIRQ1;

        sprSprIRQPending <= sprSprIRQPending1;

        sprBkIRQPending <= sprBkIRQPending1;

        sprSprCollision <= sprSprCollision1;

        sprBkCollision <= sprBkCollision1;

end

// register updates

// on the clk_i domain

reg vSync1;

integer n33;

always_ff @(posedge s_clk_i)

if (rst_i) begin

        vSyncT <= 32'hFFFF0000;//FFFFFFFF;

        sprEn <= 32'hFFFFFFFF;

        sprDt <= 0;

  for (n33 = 0; n33 < pnSpr; n33 = n33 + 1) begin

                sprSysAddr[n33] <= 20'b0000_0000_0011_0000_0000 + n33;  //0030_0000

        end

        sprSprIe <= 0;

        sprBkIe  <= 0;

  // Set reasonable starting positions on the screen

  // so that the sprites might be visible for testing

  for (n33 = 0; n33 < pnSpr; n33 = n33 + 1) begin

    hSprPos[n33] <= 200 + (n33 & 7) * 70;

    vSprPos[n33] <= 100 + (n33 >> 3) * 100;

    sprTc[n33] <= 24'h7FFF;             // White 16 bpp

                sprWidth[n33] <= 8'd16;         // 16x16 sprites

                sprHeight[n33] <= 8'd16;

                hSprRes[n33] <= 2;      // our standard display

                vSprRes[n33] <= 2;

                sprImageOffs[n33] <= 0;

                sprPlane[n33] <= 4'hF;//n[3:0];

                sprBurstStart[n33] <= 9'h000;

                sprBurstEnd[n33] <= 9'h1FE;

                sprColorDepth[n33] <= 2'b10;

                sprFrameSize[n33] <= 12'd256;

                sprFrames[n33] <= 8'd5;

                sprRate[n33] <= 12'd10;

                sprEnableAnimation[n33] <= 1'b1;

                sprAutoRepeat[n33] <= 1'b1;

        end

  hSprPos[0] <= 210;

  vSprPos[0] <= 72;

  bgTc <= 24'h08_08_08;

  bkColor <= 24'hFF_FF_60;

end

else begin

        ce <= xonoff_i;

        vSync1 <= vSync;

        if (vSync & ~vSync1)

                sprDt <= sprDt | vSyncT;

        // clear DMA trigger bit once DMA is recognized

        if (dmaStart[5])

                sprDt[dmaOwner] <= 1'b0;

        // Disable animation after frame count expired, if not auto-repeat.

  for (n33 = 0; n33 < pnSpr; n33 = n33 + 1)

                if (sprCurFrame[n33] >= sprFrames[n33] && !sprAutoRepeat[n33])

                        sprEnableAnimation[n33] <= 1'b0;

        if (cs_regs & wb_reqs.we) begin

                casez (wb_reqs.adr[9:2])

                8'b100?????:

                        begin

                                if (&wb_reqs.sel[1:0]) sprBurstStart[wb_reqs.adr[6:2]] <= {wb_reqs.dat[8:1],1'b0};

                                if (&wb_reqs.sel[3:2]) sprBurstEnd[wb_reqs.adr[6:2]] <= {wb_reqs.dat[24:17],1'b0};

                        end

                8'b101?????:

                        begin

                                if (wb_reqs.sel[0]) sprFrameSize[wb_reqs.adr[6:2]][11:4] <= wb_reqs.dat[7:0];

                                if (wb_reqs.sel[1]) sprFrames[wb_reqs.adr[6:2]] <= wb_reqs.dat[15:8];

                                if (wb_reqs.sel[2]) sprRate[wb_reqs.adr[6:2]][7:0] <= wb_reqs.dat[23:16];

                                if (wb_reqs.sel[3])

                                        begin

                                                sprRate[wb_reqs.adr[6:2]][9:8] <= wb_reqs.dat[25:24];

                                                sprFrameSize[wb_reqs.adr[6:2]][3:0] <= wb_reqs.dat[29:26];

                                                sprAutoRepeat[wb_reqs.adr[6:2]] <= wb_reqs.dat[30];

                                                sprEnableAnimation[wb_reqs.adr[6:2]] <= wb_reqs.dat[31];

                                        end

                        end

                8'b11110000:    // 3C0

                        begin

                                if (wb_reqs.sel[0]) sprEn[7:0] <= wb_reqs.dat[7:0];

                                if (wb_reqs.sel[1]) sprEn[15:8] <= wb_reqs.dat[15:8];

                                if (wb_reqs.sel[2]) sprEn[23:16] <= wb_reqs.dat[23:16];

                                if (wb_reqs.sel[3]) sprEn[31:24] <= wb_reqs.dat[31:24];

                        end

                8'b11110001:    // 3C4

                        if (wb_reqs.sel[0]) begin

                                sprSprIe <= wb_reqs.dat[0];

                                sprBkIe <= wb_reqs.dat[1];

                        end

                // update DMA trigger

                // s_wb_reqs.dat[7:0] indicates which triggers to set  (1=set,0=ignore)

                // s_wb_reqs.dat[7:0] indicates which triggers to clear (1=clear,0=ignore)

                8'b11110100:    // 3D0

                        begin

                                if (wb_reqs.sel[0])     sprDt[7:0] <= sprDt[7:0] | wb_reqs.dat[7:0];

                                if (wb_reqs.sel[1]) sprDt[15:8] <= sprDt[15:8] | wb_reqs.dat[15:8];

                                if (wb_reqs.sel[2]) sprDt[23:16] <= sprDt[23:16] | wb_reqs.dat[23:16];

                                if (wb_reqs.sel[3])     sprDt[31:24] <= sprDt[31:24] | wb_reqs.dat[31:24];

                        end

                8'b11110101:    // 3D4

                        begin

                                if (wb_reqs.sel[0])     sprDt[7:0] <= sprDt[7:0] & ~wb_reqs.dat[7:0];

                                if (wb_reqs.sel[1]) sprDt[15:8] <= sprDt[15:8] & ~wb_reqs.dat[15:8];

                                if (wb_reqs.sel[2]) sprDt[23:16] <= sprDt[23:16] & ~wb_reqs.dat[23:16];

                                if (wb_reqs.sel[3])     sprDt[31:24] <= sprDt[31:24] & ~wb_reqs.dat[31:24];

                        end

                8'b11110110:    // 3D8

                        begin

                                if (wb_reqs.sel[0])     vSyncT[7:0] <= wb_reqs.dat[7:0];

                                if (wb_reqs.sel[1]) vSyncT[15:8] <= wb_reqs.dat[15:8];

                                if (wb_reqs.sel[2]) vSyncT[23:16] <= wb_reqs.dat[23:16];

                                if (wb_reqs.sel[3])     vSyncT[31:24] <= wb_reqs.dat[31:24];

                        end

                8'b11111010:    // 3E8

                        begin

                                if (wb_reqs.sel[0])     bgTc[7:0] <= wb_reqs.dat[7:0];

                                if (wb_reqs.sel[1])     bgTc[15:8] <= wb_reqs.dat[15:8];

                                if (wb_reqs.sel[2])     bgTc[23:16] <= wb_reqs.dat[23:16];

                                if (wb_reqs.sel[3])     bgTc[29:24] <= wb_reqs.dat[29:24];

                        end

                8'b11111011:    // 3EC

                        begin

                                if (wb_reqs.sel[0]) bkColor[7:0] <= wb_reqs.dat[7:0];

                                if (wb_reqs.sel[1]) bkColor[15:8] <= wb_reqs.dat[15:8];

                                if (wb_reqs.sel[2]) bkColor[23:16] <= wb_reqs.dat[23:16];

                                if (wb_reqs.sel[3]) bkColor[29:24] <= wb_reqs.dat[29:24];

                        end

//              8'b11111100:    // 3F0

//                      if (wb_reqs.sel[0]) ce <= wb_reqs[0];

                8'b0?????00:

                         begin

                        if (wb_reqs.sel[0]) hSprPos[sprN][ 7:0] <= wb_reqs.dat[ 7: 0];

                        if (wb_reqs.sel[1]) hSprPos[sprN][11:8] <= wb_reqs.dat[11: 8];

                        if (wb_reqs.sel[2]) vSprPos[sprN][ 7:0] <= wb_reqs.dat[23:16];

                        if (wb_reqs.sel[3]) vSprPos[sprN][11:8] <= wb_reqs.dat[27:24];

                end

    8'b0?????01:

                        begin

                if (wb_reqs.sel[0]) begin

                                        sprWidth[sprN] <= wb_reqs.dat[7:0];

        end

                if (wb_reqs.sel[1]) begin

                                        sprHeight[sprN] <= wb_reqs.dat[15:8];

        end

                                if (wb_reqs.sel[2]) begin

                hSprRes[sprN] <= wb_reqs.dat[19:16];

                vSprRes[sprN] <= wb_reqs.dat[23:20];

                                end

                                if (wb_reqs.sel[3]) begin

                                        sprPlane[sprN] <= wb_reqs.dat[27:24];

                                        sprColorDepth[sprN] <= wb_reqs.dat[31:30];

                                end

                        end

                8'b0?????10:

                        begin   // DMA address set on clk_i domain

        if (wb_reqs.sel[0]) sprImageOffs[sprN][ 7:0] <= wb_reqs.dat[7:0];

        if (wb_reqs.sel[1]) sprImageOffs[sprN][11:8] <= wb_reqs.dat[11:8];

                                if (wb_reqs.sel[1]) sprSysAddr[sprN][15:12] <= wb_reqs.dat[15:12];

                                if (wb_reqs.sel[2]) sprSysAddr[sprN][23:16] <= wb_reqs.dat[23:16];

                                if (wb_reqs.sel[3]) sprSysAddr[sprN][31:24] <= wb_reqs.dat[31:24];

                        end

                8'b0?????11:

                        begin

                                if (wb_reqs.sel[0]) sprTc[sprN][ 7:0] <= wb_reqs.dat[ 7:0];

                                if (wb_reqs.sel[1]) sprTc[sprN][15:8] <= wb_reqs.dat[15:8];

                                if (wb_reqs.sel[2]) sprTc[sprN][23:16] <= wb_reqs.dat[23:16];

                        end

                default:        ;

                endcase

        end

end

//-------------------------------------------------------------

// Sprite Image Cache RAM

// This RAM is dual ported with an SoC side and a display

// controller side.

//-------------------------------------------------------------

integer n2;

always_ff @(posedge vclk)

for (n2 = 0; n2 < pnSpr; n2 = n2 + 1)

case(sprColorDepth[n2])

2'd1:   sprAddr1[n2] <= {sprAddr[n2][11:3],~sprAddr[n2][2]};

2'd2:   sprAddr1[n2] <= {sprAddr[n2][10:2],~sprAddr[n2][1]};

2'd3:   sprAddr1[n2] <= {sprAddr[n2][ 9:1],~sprAddr[n2][0]};

default:        ;

endcase

// The three LSBs of the image index need to be pipelined so they may be used

// to select the pixel. Output from the SRAM is always 32-bits wide so an

// additional mux is needed.

integer n4, n5, n27, n29;

always_ff @(posedge vclk)

for (n4 = 0; n4 < pnSpr; n4 = n4 + 1)

        sprAddr2[n4] <= ~sprAddr[n4][2:0];

always_ff @(posedge vclk)

for (n5 = 0; n5 < pnSpr; n5 = n5 + 1)

        sprAddr3[n5] <= sprAddr2[n5];

always_ff @(posedge vclk)

for (n27 = 0; n27 < pnSpr; n27 = n27 + 1)

        sprAddr4[n27] <= sprAddr3[n27];

always_ff @(posedge vclk)

for (n29 = 0; n29 < pnSpr; n29 = n29 + 1)

        sprAddr5[n29] <= sprAddr4[n29];

// The pixels are displayed from most signicant to least signicant bits of the

// word. Display order is opposite to memory storage. So, the least significant

// address bits are flipped to get the correct display.

integer n3;

always_ff @(posedge vclk)

for (n3 = 0; n3 < pnSpr; n3 = n3 + 1)

case(sprColorDepth[n3])

2'd1:

        case(sprAddr5[n3][1:0])

        2'd3:   sprOut5[n3] <= sprOut4[n3][31:24];

        2'd2:   sprOut5[n3] <= sprOut4[n3][23:16];

        2'd1:   sprOut5[n3] <= sprOut4[n3][15:8];

        2'd0:   sprOut5[n3] <= sprOut4[n3][7:0];

        endcase

2'd2:

        case(sprAddr5[n3][0])

        1'd0:   sprOut5[n3] <= {sprOut4[n3][15],16'h0000,sprOut4[n3][14:0]};

        1'd1:   sprOut5[n3] <= {sprOut4[n3][31],16'h0000,sprOut4[n3][30:16]};

        endcase

2'd3:

        sprOut5[n3] <= sprOut4[n3];

default:        ;

endcase

generate

for (g = 0; g < pnSpr; g = g + 1) begin : sprRam

        SpriteRam sprRam0

        (

                .clka(m_clk_i),

                .addra(m_adr_or),

                .dina(m_dat_ir[63:0]),

                .ena(sprWe[g]),

                .wea(sprWe[g]),

                // Core reg and output reg 3 clocks from read address

                .clkb(vclk),

                .addrb(sprAddr1[g]),

                .doutb(sprOut4[g]),

                .enb(1'b1)

        );

        end

endgenerate

//-------------------------------------------------------------

// Timing counters and addressing

// Sprites are like miniature bitmapped displays, they need

// all the same timing controls.

//-------------------------------------------------------------

// Create a timing reference using horizontal and vertical

// sync

wire hSyncEdge, vSyncEdge;

edge_det ed0(.rst(rst_i), .clk(vclk), .ce(1'b1), .i(hSync), .pe(hSyncEdge), .ne(), .ee() );

edge_det ed1(.rst(rst_i), .clk(vclk), .ce(1'b1), .i(vSync), .pe(vSyncEdge), .ne(), .ee() );

always_ff @(posedge vclk)

if (hSyncEdge) hctr <= {phBits{1'b0}};

else hctr <= hctr + 2'd1;

always_ff @(posedge vclk)

if (vSyncEdge) vctr <= {pvBits{1'b0}};

else if (hSyncEdge) vctr <= vctr + 2'd1;

// track sprite horizontal reset

integer n19;

always_ff @(posedge vclk)

for (n19 = 0; n19 < pnSpr; n19 = n19 + 1)

        hSprReset[n19] <= hctr==hSprPos[n19];

// track sprite vertical reset

integer n20;

always_ff @(posedge vclk)

for (n20 = 0; n20 < pnSpr; n20 = n20 + 1)

        vSprReset[n20] <= vctr==vSprPos[n20];

integer n21;

always_comb

for (n21 = 0; n21 < pnSpr; n21 = n21 + 1)

        sprDe[n21] <= hSprDe[n21] & vSprDe[n21];

// take care of sprite size scaling

// video clock division

reg [31:0] hSprNextPixel;

reg [31:0] vSprNextPixel;

reg [3:0] hSprPt [31:0];   // horizontal pixel toggle

reg [3:0] vSprPt [31:0];   // vertical pixel toggle

integer n17;

always_comb

for (n17 = 0; n17 < pnSpr; n17 = n17 + 1)

    hSprNextPixel[n17] = hSprPt[n17]==hSprRes[n17];

integer n18;

always_comb

for (n18 = 0; n18 < pnSpr; n18 = n18 + 1)

    vSprNextPixel[n18] = vSprPt[n18]==vSprRes[n18];

// horizontal pixel toggle counter

integer n6;

always_ff @(posedge vclk)

for (n6 = 0; n6 < pnSpr; n6 = n6 + 1)

        if (hSprReset[n6])

                hSprPt[n6] <= 4'd0;

  else if (hSprNextPixel[n6])

    hSprPt[n6] <= 4'd0;

  else

    hSprPt[n6] <= hSprPt[n6] + 2'd1;

// vertical pixel toggle counter

integer n7;

always_ff @(posedge vclk)

for (n7 = 0; n7 < pnSpr; n7 = n7 + 1)

  if (hSprReset[n7]) begin

        if (vSprReset[n7])

                vSprPt[n7] <= 4'd0;

    else if (vSprNextPixel[n7])

      vSprPt[n7] <= 4'd0;

    else

      vSprPt[n7] <= vSprPt[n7] + 2'd1;

  end

// Animation rate count and frame increment.

integer n28;

always_ff @(posedge vclk)

        if (vSyncEdge) begin

                for (n28 = 0; n28 < pnSpr; n28 = n28 + 1) begin

                        if (sprEnableAnimation[n28]) begin

                                sprCurRateCount[n28] <= sprCurRateCount[n28] + 2'd1;

                                if (sprCurRateCount[n28] >= sprRate[n28]) begin

                                        sprCurRateCount[n28] <= 'd0;

                                        sprCurFrame[n28] <= sprCurFrame[n28] + 2'd1;

                                        if (sprCurFrame[n28] >= sprFrames[n28])

                                                sprCurFrame[n28] <= 'd0;

                                end

                        end

                        else

                                sprCurFrame[n28] <= 'd0;

                end

        end

// clock sprite image address counters

integer n8;

always_ff @(posedge vclk)

for (n8 = 0; n8 < pnSpr; n8 = n8 + 1) begin

    // hReset and vReset - top left of sprite,

    // reset address to image offset

        if (hSprReset[n8] & vSprReset[n8]) begin

                sprAddr[n8]  <= sprImageOffs[n8] + sprCurFrame[n8] * sprFrameSize[n8];

                sprAddrB[n8] <= sprImageOffs[n8] + sprCurFrame[n8] * sprFrameSize[n8];

        end

        // hReset:

        //  If the next vertical pixel

        //      set backup address to current address

        //  else

        //      set current address to backup address

        //      in order to rescan the line

        else if (hSprReset[n8]) begin

                if (vSprNextPixel[n8])

                        sprAddrB[n8] <= sprAddr[n8];

                else

                        sprAddr[n8]  <= sprAddrB[n8];

        end

        // Not hReset or vReset - somewhere on the sprite scan line

        // just advance the address when the next pixel should be

        // fetched

        else if (hSprDe[n8] & hSprNextPixel[n8])

                sprAddr[n8] <= sprAddr[n8] + 2'd1;

end

// clock sprite column (X) counter

integer n9;

always_ff @(posedge vclk)

for (n9 = 0; n9 < pnSpr; n9 = n9 + 1)

        if (hSprReset[n9])

                hSprCnt[n9] <= 8'd1;

        else if (hSprNextPixel[n9])

                hSprCnt[n9] <= hSprCnt[n9] + 2'd1;

// clock sprite horizontal display enable

integer n10;

always_ff @(posedge vclk)

for (n10 = 0; n10 < pnSpr; n10 = n10 + 1) begin

        if (hSprReset[n10])

                hSprDe[n10] <= 1'b1;

        else if (hSprNextPixel[n10]) begin

                if (hSprCnt[n10] == sprWidth[n10])

                        hSprDe[n10] <= 1'b0;

        end

end

// clock the sprite row (Y) counter

integer n11;

always_ff @(posedge vclk)

for (n11 = 0; n11 < pnSpr; n11 = n11 + 1)

        if (hSprReset[n11]) begin

                if (vSprReset[n11])

                        vSprCnt[n11] <= 8'd1;

                else if (vSprNextPixel[n11])

                        vSprCnt[n11] <= vSprCnt[n11] + 2'd1;

        end

// clock sprite vertical display enable

integer n12;

always_ff @(posedge vclk)

for (n12 = 0; n12 < pnSpr; n12 = n12 + 1) begin

        if (hSprReset[n12]) begin

                if (vSprReset[n12])

                        vSprDe[n12] <= 1'b1;

                else if (vSprNextPixel[n12]) begin

                        if (vSprCnt[n12] == sprHeight[n12])

                                vSprDe[n12] <= 1'b0;

                end

        end

end

//-------------------------------------------------------------

// Output stage

//-------------------------------------------------------------

// function used for color blending

// given an alpha and a color component, determine the resulting color

// this blends towards black or white

// alpha is eight bits ranging between 0 and 1.999...

// 1 bit whole, 7 bits fraction

function [11:0] fnBlend;

input [7:0] alpha;

input [11:0] color1bits;

input [11:0] color2bits;

begin

        fnBlend = (({8'b0,color1bits} * alpha) >> 7) + (({8'h00,color2bits} * (9'h100 - alpha)) >> 7);