cmprs_frame_sync.v 10.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11
/*!
 * <b>Module:</b>cmprs_frame_sync
 * @file cmprs_frame_sync.v
 * @date 2015-06-23  
 * @author Andrey Filippov     
 *
 * @brief Synchronizes memory channels (sensor and compressor)
 *
 * @copyright Copyright (c) 2015 Elphel, Inc.
 *
 * <b>License:</b>
12 13 14 15 16 17 18 19 20 21 22 23 24
 *
 * cmprs_frame_sync.v is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 *  cmprs_frame_sync.v 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/> .
25 26 27 28 29 30
 *
 * Additional permission under GNU GPL version 3 section 7:
 * If you modify this Program, or any covered work, by linking or combining it
 * with independent modules provided by the FPGA vendor only (this permission
 * does not extend to any 3-rd party modules, "soft cores" or macros) under
 * different license terms solely for the purpose of generating binary "bitstream"
31
 * files and/or simulating the code, the copyright holders of this Program give
32 33
 * you the right to distribute the covered work without those independent modules
 * as long as the source code for them is available from the FPGA vendor free of
Andrey Filippov's avatar
Andrey Filippov committed
34
 * charge, and there is no dependence on any encrypted modules for simulating of
35 36 37
 * the combined code. This permission applies to you if the distributed code
 * contains all the components and scripts required to completely simulate it
 * with at least one of the Free Software programs.
38
 */
39 40 41 42
`timescale 1ns/1ps

module  cmprs_frame_sync#(
    parameter FRAME_HEIGHT_BITS=               16,    // Maximal frame height 
43 44 45
    parameter LAST_FRAME_BITS=                 16,     // number of bits in frame counter (before rolls over)
    parameter CMPRS_TIMEOUT_BITS=              12,
    parameter CMPRS_TIMEOUT=                   1000   // mclk cycles
46 47

)(
Andrey Filippov's avatar
Andrey Filippov committed
48
//    input                         rst,
49 50
    input                         xclk,               // global clock input, compressor single clock rate
    input                         mclk,               // global system/memory clock
Andrey Filippov's avatar
Andrey Filippov committed
51 52 53
    input                         mrst,               // @posedge mclk, sync reset
    input                         xrst,               // @posedge xclk, sync reset
    
54 55
    input                         cmprs_en,           // @mclk 0 resets immediately
    output                        cmprs_en_extend,    // @mclk keep compressor enabled for graceful shutdown
56 57 58

// TODO: delay vsync_late if still compressing previous frame in multi-frame buffer mode
     
59 60 61 62
    input                         cmprs_run,          // @mclk enable propagation of vsync_late to frame_start_dst in bonded(sync to src) mode
    input                         cmprs_standalone,   // @mclk single-cycle: generate a single frame_start_dst in unbonded (not synchronized) mode.
                                                      // cmprs_run should be off
    input                         sigle_frame_buf,    // memory controller uses a single frame buffer (frame_number_* == 0), use other sync                                                      
63
    input                         vsync_late,         // @mclk delayed start of frame, @xclk. In 353 it was 16 lines after VACT active
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
                                                      // source channel should already start, some delay give time for sequencer commands
                                                      // that should arrive before it
    input                         frame_started,      // @xclk started first macroblock (checking for broken frames)
                                                      
    output                        frame_start_dst,    // @mclk - trigger receive (tiled) memory channel (it will take care of single/repetitive
                                                      // this output either follows vsync_late (reclocks it) or generated in non-bonded mode
                                                      // (compress from memory)
    input [FRAME_HEIGHT_BITS-1:0] line_unfinished_src,// number of the current (unfinished ) line, in the source (sensor) channel (RELATIVE TO FRAME, NOT WINDOW?)
    input   [LAST_FRAME_BITS-1:0] frame_number_src,   // current frame number (for multi-frame ranges) in the source (sensor) channel
    input                         frame_done_src,     // single-cycle pulse when the full frame (window) was transferred to/from DDR3 memory 
                                                      // frame_done_src is later than line_unfinished_src/ frame_number_src changes
                                                      // Used withe a single-frame buffers
     
    input [FRAME_HEIGHT_BITS-1:0] line_unfinished,    // number of the current (unfinished ) line in this (compressor) channel
    input   [LAST_FRAME_BITS-1:0] frame_number,       // current frame number (for multi-frame ranges) in this (compressor channel
    input                         frame_done,         // input - single-cycle pulse when the full frame (window) was transferred to/from DDR3 memory 
    output reg                    suspend,            // suspend reading data for this channel - waiting for the source data
81 82

    input                         stuffer_running,    // @xclk2x stuffer is running/flushing
83
    output reg                    force_flush_long,    // force flush (abort frame), can be any clock and may last until stuffer_done_mclk
84
                                                      // stuffer will re-clock and extract 0->1 transition
85
    output                        stuffer_running_mclk,
86 87
    output                        reading_frame,
    output                        frame_started_mclk  // use to store frame number
88
);
89 90 91 92 93 94
/*
 Abort frame (force flush) if:
 a) "broken frame" - attempted to start a new frame before previous one was completely read from the memory
 b) turned off enable while frame was being compressed
 Abort frame lasts until flush end or timeout expire
*/
95
//    wire   vsync_late_mclk; // single mclk cycle, reclocked from vsync_late
96
//    wire   frame_started_mclk; 
97 98 99 100 101 102
    reg        bonded_mode;
    reg  [3:0] frame_start_dst_r;
    reg        frame_start_pend_r; // postpone frame_start_dst if previous frame was still being read during vsync_late 
    reg        frames_differ;  // src and dest point to different frames (single-frame buffer mode), disregard line_unfinished_*
    reg        frames_numbers_differ;  // src and dest point to different frames (multi-frame buffer mode), disregard line_unfinished_*
    reg        line_numbers_sync;      // src unfinished line number is > this unfinished line number
103
    
104 105 106 107
    reg        reading_frame_r;         // compressor is reading frame data (make sure input is done before starting next frame, otherwise make it a broken frame
//  reg        broken_frame;
    reg        aborted_frame;
    reg        stuffer_running_mclk_r;
108
    reg [CMPRS_TIMEOUT_BITS-1:0] timeout;
109 110 111
    reg        cmprs_en_extend_r=0;
    reg        cmprs_en_d;
    reg        suspend_end; // suspend at teh end of the current frame until frame number changes
112
//    reg    cmprs_en_xclk;
113
    assign frame_start_dst = frame_start_dst_r[0];
114
    assign cmprs_en_extend = cmprs_en_extend_r;
115 116 117 118
    
    assign stuffer_running_mclk = stuffer_running_mclk_r;
    assign reading_frame =        reading_frame_r;
    
119 120 121
//    always @ (posedge xclk) begin
//        cmprs_en_xclk <=cmprs_en;
//    end
Andrey Filippov's avatar
Andrey Filippov committed
122 123 124
    always @ (posedge mclk) begin
        if       (mrst)                                       cmprs_en_extend_r <= 0;
        else if  (cmprs_en)                                   cmprs_en_extend_r <= 1;
125
        else if  ((timeout == 0) || !stuffer_running_mclk_r)  cmprs_en_extend_r <= 0;
126 127
    end
    
128
    always @ (posedge mclk) begin
129
        stuffer_running_mclk_r <= stuffer_running; // re-clock from negedge xclk2x
130 131 132 133 134 135 136
        
        if      (cmprs_en)           timeout <= CMPRS_TIMEOUT;
        else if (!cmprs_en_extend_r) timeout <= 0;
        else                         timeout <= timeout - 1;
        
        cmprs_en_d <= cmprs_en;

137
///     broken_frame <=  cmprs_en && cmprs_run && vsync_late && reading_frame_r; // single xclk pulse
138
        aborted_frame <= cmprs_en_d && !cmprs_en && stuffer_running_mclk_r;
139
        
140
        if      (!stuffer_running_mclk_r ||!cmprs_en_extend_r) force_flush_long <= 0;
141 142
///     else if (broken_frame || aborted_frame)                force_flush_long <= 1;
        else if (aborted_frame)                                force_flush_long <= 1;
143 144

    
145 146
///     if (!cmprs_en || frame_done || (cmprs_run && vsync_late)) reading_frame_r <= 0;
        if (!cmprs_en || frame_done )                             reading_frame_r <= 0;
147
        else if (frame_started_mclk)                              reading_frame_r <= 1;
148

149 150 151 152 153 154 155 156 157 158 159 160 161 162
        if      (!cmprs_en)                                   frame_start_pend_r <= 0;
        else if (cmprs_run && vsync_late && reading_frame_r)  frame_start_pend_r <= 1;
        else if (frame_start_dst_r[0])                        frame_start_pend_r <= 0;
         
        if      (!cmprs_en)            suspend_end <= 0;
        else if (frame_done)           suspend_end <= 1;
        else if (frame_start_dst_r[3]) suspend_end <= 0;
        
        frame_start_dst_r[0] <= cmprs_en && (cmprs_run ? 
                                            ((vsync_late && !reading_frame_r) || (frame_start_pend_r  && frame_done)):
                                             cmprs_standalone);
        if      (!cmprs_en)   frame_start_dst_r[3:1] <=0;
        else                  frame_start_dst_r[3:1] <= frame_start_dst_r[2:0];                                             
        
163 164 165 166
        if      (!cmprs_en)        bonded_mode <= 0;
        else if (cmprs_run)        bonded_mode <= 1;
        else if (cmprs_standalone) bonded_mode <= 0;
        
167
        if (!cmprs_en || !cmprs_run || vsync_late) frames_differ <= 0;
168
        else if (frame_done_src)                   frames_differ <= 1'b1;
169
        
170
        frames_numbers_differ <= !suspend_end && (frame_number_src != frame_number); // during end of frame, before frame number is incremented
171 172 173
        
        line_numbers_sync <= (line_unfinished_src > line_unfinished);
        
174
        suspend <= bonded_mode && !((sigle_frame_buf ? frames_differ : frames_numbers_differ) || line_numbers_sync);
175 176 177 178
        
    
    end
    
179
//    pulse_cross_clock vsync_late_mclk_i (.rst(xrst), .src_clk(xclk), .dst_clk(mclk), .in_pulse(cmprs_en_xclk && vsync_late), .out_pulse(vsync_late_mclk),.busy());
Andrey Filippov's avatar
Andrey Filippov committed
180
    pulse_cross_clock frame_started_i   (.rst(xrst), .src_clk(xclk), .dst_clk(mclk), .in_pulse(frame_started), .out_pulse(frame_started_mclk),.busy());
181 182 183

endmodule