URL https://opencores.org/ocsvn/rtf8088/rtf8088/trunk

Subversion Repositories rtf8088

[/] [rtf8088/] [trunk/] [rtl/] [verilog/] [EACALC.v] - Blame information for rev 4

Go to most recent revision | Details | Compare with Previous | View Log


// ============================================================================
//  EACALC
//  - calculation of effective address
//
//
//  (C) 2009-2012  Robert Finch, Stratford
//  robfinch[remove]@opencores.org
//
//
// This source file 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.                                      
//                                                                          
// This source file 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/>.    
//
//
//  Verilog 
//
// - the effective address calculation may need to fetch an additional
//   eight or sixteen bit displacement value in order to calculate the
//   effective address.
// - the EA calc only needs to be done once as there is only ever a 
//   single memory operand address. Once the EA is calculated it is
//   used for both the fetch and the store when memory is the target.
// ============================================================================
//
EACALC:
        // Terminate an outstanding MODRM fetch cycle
        if (cyc_o) begin
                if (ack_i) begin
                        `TERMINATE_CODE_READ
                        mod   <= dat_i[7:6];
                        rrr   <= dat_i[5:3];
                        sreg3 <= dat_i[5:3];
                        TTT   <= dat_i[5:3];
                        rm    <= dat_i[2:0];
                        $display("Mod/RM=%b_%b_%b", dat_i[7:6],dat_i[5:3],dat_i[2:0]);
                end
        end
        else begin
 
                disp16 <= 16'h0000;
 
                case(mod)
 
                2'b00:
                        begin
                                state <= EACALC1;
                                // ToDo: error on stack state
                                case(rm)
                                3'd0:   offset <= bx + si;
                                3'd1:   offset <= bx + di;
                                3'd2:   offset <= bp + si;
                                3'd3:   offset <= bp + di;
                                3'd4:   offset <= si;
                                3'd5:   offset <= di;
                                3'd6:   begin
                                                state <= EACALC_DISP16;
                                                offset <= 16'h0000;
                                                end
                                3'd7:   offset <= bx;
                                endcase
                        end
 
                2'b01:
                        begin
                                state <= EACALC_DISP8;
                                case(rm)
                                3'd0:   offset <= bx + si;
                                3'd1:   offset <= bx + di;
                                3'd2:   offset <= bp + si;
                                3'd3:   offset <= bp + di;
                                3'd4:   offset <= si;
                                3'd5:   offset <= di;
                                3'd6:   offset <= bp;
                                3'd7:   offset <= bx;
                                endcase
                        end
 
                2'b10:
                        begin
                                state <= EACALC_DISP16;
                                case(rm)
                                3'd0:   offset <= bx + si;
                                3'd1:   offset <= bx + di;
                                3'd2:   offset <= bp + si;
                                3'd3:   offset <= bp + di;
                                3'd4:   offset <= si;
                                3'd5:   offset <= di;
                                3'd6:   offset <= bp;
                                3'd7:   offset <= bx;
                                endcase
                        end
 
                2'b11:
                        begin
                                state <= EXECUTE;
                                case(ir)
                                `MOV_I8M:
                                        begin
                                                rrr <= rm;
                                                if (rrr==3'd0) state <= FETCH_IMM8;
                                        end
                                `MOV_I16M:
                                        begin
                                                rrr <= rm;
                                                if (rrr==3'd0) state <= FETCH_IMM16;
                                        end
                                `MOV_S2R:
                                        begin
                                                a <= rfso;
                                                b <= rfso;
                                        end
                                `MOV_R2S:
                                        begin
                                                a <= rmo;
                                                b <= rmo;
                                        end
                                `POP_MEM:
                                        begin
                                                ir <= 8'h58|rm;
                                                state <= POP;
                                        end
                                `XCHG_MEM:
                                        begin
                                                wrregs <= 1'b1;
                                                res <= rmo;
                                                b <= rrro;
                                        end
                                // shifts and rotates
                                8'hD0,8'hD1,8'hD2,8'hD3:
                                        begin
                                                b <= rmo;
                                        end
                                default:
                                    begin
                                                if (d) begin
                                                        a <= rmo;
                                                        b <= rrro;
                                                end
                                                else begin
                                                        a <= rrro;
                                                        b <= rmo;
                                                end
                                        end
                                endcase
                                hasFetchedData <= 1'b1;
                        end
                endcase
        end
 
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Fetch 16 bit displacement
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//
EACALC_DISP16:
        begin
                lock_o <= 1'b1;
                `INITIATE_CODE_READ
                state <= EACALC_DISP16_ACK;
        end
EACALC_DISP16_ACK:
        if (ack_i) begin
                `TERMINATE_CODE_READ
                disp16[7:0] <= dat_i;
                state <= EACALC_DISP16a;
        end
EACALC_DISP16a:
        begin
                `INITIATE_CODE_READ
                state <= EACALC_DISP16a_ACK;
        end
EACALC_DISP16a_ACK:
        if (ack_i) begin
                `TERMINATE_CODE_READ
                lock_o <= bus_locked;
                disp16[15:8] <= dat_i;
                state <= EACALC1;
        end
 
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Fetch 8 bit displacement
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//
EACALC_DISP8:
        begin
                `INITIATE_CODE_READ
                state <= EACALC_DISP8_ACK;
        end
EACALC_DISP8_ACK:
        if (ack_i) begin
                `TERMINATE_CODE_READ
                disp16 <= {{8{dat_i[7]}},dat_i};
                state <= EACALC1;
        end
 
 
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Add the displacement into the effective address
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//
EACALC1:
        begin
                casex(ir)
                `EXTOP:
                        casex(ir2)
                        8'h00:
                                begin
                                        case(rrr)
                                        3'b010: state <= FETCH_DESC;    // LLDT
                                        3'b011: state <= FETCH_DATA;    // LTR
                                        default: state <= FETCH_DATA;
                                        endcase
                                        if (w && (offsdisp==16'hFFFF)) begin
                                                int_num <= 8'h0d;
                                                state <= INT;
                                        end
                                end
                        8'h01:
                                begin
                                        case(rrr)
                                        3'b010: state <= FETCH_DESC;
                                        3'b011: state <= FETCH_DESC;
                                        default: state <= FETCH_DATA;
                                        endcase
                                        if (w && (offsdisp==16'hFFFF)) begin
                                                int_num <= 8'h0d;
                                                state <= INT;
                                        end
                                end
                        8'h03:
                                if (w && (offsdisp==16'hFFFF)) begin
                                        int_num <= 8'h0d;
                                        state <= INT;
                                end
                                else
                                        state <= FETCH_DATA;
                        default:
                                if (w && (offsdisp==16'hFFFF)) begin
                                        int_num <= 8'h0d;
                                        state <= INT;
                                end
                                else
                                        state <= FETCH_DATA;
                        endcase
                `MOV_I8M: state <= FETCH_IMM8;
                `MOV_I16M:
                        if (ip==16'hFFFF) begin
                                int_num <= 8'h0d;
                                state <= INT;
                        end
                        else
                                state <= FETCH_IMM16;
                `POP_MEM:
                        begin
                                state <= POP;
                        end
                `XCHG_MEM:
                        begin
//                              bus_locked <= 1'b1;
                                state <= FETCH_DATA;
                        end
                default:
                        begin
                                if (w && (offsdisp==16'hFFFF)) begin
                                        int_num <= 8'h0d;
                                        state <= INT;
                                end
                                else
                                        state <= FETCH_DATA;
                                if (ir==8'hff) begin
                                        case(rrr)
                                        3'b011: state <= CALLF; // CAll FAR indirect
                                        3'b101: state <= JUMP_VECTOR1;  // JMP FAR indirect
                                        3'b110: begin d <= 1'b0; state <= FETCH_DATA; end// for a push
                                        default: ;
                                        endcase
                                end
                        end
                endcase
//              ea <= ea + disp16;
                ea <= {seg_reg,`SEG_SHIFT} + offsdisp;  // offsdisp = offset + disp16
        end

Browse

Tools

Subversion Repositories rtf8088

[/] [rtf8088/] [trunk/] [rtl/] [verilog/] [EACALC.v] - Blame information for rev 4

Line No.	Rev	Author	Line
1	2	robfinch	`// ============================================================================`
2			`// EACALC`
3			`// - calculation of effective address`
4			`//`
5			`//`
6			`// (C) 2009-2012 Robert Finch, Stratford`
7			`// robfinch[remove]@opencores.org`
8			`//`
9			`//`
10			`// This source file is free software: you can redistribute it and/or modify`
11			`// it under the terms of the GNU Lesser General Public License as published`
12			`// by the Free Software Foundation, either version 3 of the License, or`
13			`// (at your option) any later version.`
14			`//`
15			`// This source file is distributed in the hope that it will be useful,`
16			`// but WITHOUT ANY WARRANTY; without even the implied warranty of`
17			`// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
18			`// GNU General Public License for more details.`
19			`//`
20			`// You should have received a copy of the GNU General Public License`
21			`// along with this program. If not, see <http://www.gnu.org/licenses/>.`
22			`//`
23			`//`
24			`// Verilog`
25			`//`
26			`// - the effective address calculation may need to fetch an additional`
27			`// eight or sixteen bit displacement value in order to calculate the`
28			`// effective address.`
29			`// - the EA calc only needs to be done once as there is only ever a`
30			`// single memory operand address. Once the EA is calculated it is`
31			`// used for both the fetch and the store when memory is the target.`
32			`// ============================================================================`
33			`//`
34			`EACALC:`
35			`// Terminate an outstanding MODRM fetch cycle`
36			`if (cyc_o) begin`
37			`if (ack_i) begin`
38			`TERMINATE_CODE_READ
39			`mod <= dat_i[7:6];`
40			`rrr <= dat_i[5:3];`
41			`sreg3 <= dat_i[5:3];`
42			`TTT <= dat_i[5:3];`
43			`rm <= dat_i[2:0];`
44			`$display("Mod/RM=%b_%b_%b", dat_i[7:6],dat_i[5:3],dat_i[2:0]);`
45			`end`
46			`end`
47			`else begin`
48
49			`disp16 <= 16'h0000;`
50
51			`case(mod)`
52
53			`2'b00:`
54			`begin`
55			`state <= EACALC1;`
56			`// ToDo: error on stack state`
57			`case(rm)`
58			`3'd0: offset <= bx + si;`
59			`3'd1: offset <= bx + di;`
60			`3'd2: offset <= bp + si;`
61			`3'd3: offset <= bp + di;`
62			`3'd4: offset <= si;`
63			`3'd5: offset <= di;`
64			`3'd6: begin`
65			`state <= EACALC_DISP16;`
66			`offset <= 16'h0000;`
67			`end`
68			`3'd7: offset <= bx;`
69			`endcase`
70			`end`
71
72			`2'b01:`
73			`begin`
74			`state <= EACALC_DISP8;`
75			`case(rm)`
76			`3'd0: offset <= bx + si;`
77			`3'd1: offset <= bx + di;`
78			`3'd2: offset <= bp + si;`
79			`3'd3: offset <= bp + di;`
80			`3'd4: offset <= si;`
81			`3'd5: offset <= di;`
82			`3'd6: offset <= bp;`
83			`3'd7: offset <= bx;`
84			`endcase`
85			`end`
86
87			`2'b10:`
88			`begin`
89			`state <= EACALC_DISP16;`
90			`case(rm)`
91			`3'd0: offset <= bx + si;`
92			`3'd1: offset <= bx + di;`
93			`3'd2: offset <= bp + si;`
94			`3'd3: offset <= bp + di;`
95			`3'd4: offset <= si;`
96			`3'd5: offset <= di;`
97			`3'd6: offset <= bp;`
98			`3'd7: offset <= bx;`
99			`endcase`
100			`end`
101
102			`2'b11:`
103			`begin`
104			`state <= EXECUTE;`
105			`case(ir)`
106			`MOV_I8M:
107			`begin`
108			`rrr <= rm;`
109			`if (rrr==3'd0) state <= FETCH_IMM8;`
110			`end`
111			`MOV_I16M:
112			`begin`
113			`rrr <= rm;`
114			`if (rrr==3'd0) state <= FETCH_IMM16;`
115			`end`
116			`MOV_S2R:
117			`begin`
118			`a <= rfso;`
119			`b <= rfso;`
120			`end`
121			`MOV_R2S:
122			`begin`
123			`a <= rmo;`
124			`b <= rmo;`
125			`end`
126			`POP_MEM:
127			`begin`
128			`ir <= 8'h58\|rm;`
129			`state <= POP;`
130			`end`
131			`XCHG_MEM:
132			`begin`
133			`wrregs <= 1'b1;`
134			`res <= rmo;`
135			`b <= rrro;`
136			`end`
137	4	robfinch	`// shifts and rotates`
138			`8'hD0,8'hD1,8'hD2,8'hD3:`
139			`begin`
140			`b <= rmo;`
141			`end`
142	2	robfinch	`default:`
143			`begin`
144			`if (d) begin`
145			`a <= rmo;`
146			`b <= rrro;`
147			`end`
148			`else begin`
149			`a <= rrro;`
150			`b <= rmo;`
151			`end`
152			`end`
153			`endcase`
154			`hasFetchedData <= 1'b1;`
155			`end`
156			`endcase`
157			`end`
158
159			`//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -`
160			`// Fetch 16 bit displacement`
161			`//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -`
162			`//`
163			`EACALC_DISP16:`
164			`begin`
165			`lock_o <= 1'b1;`
166			`INITIATE_CODE_READ
167			`state <= EACALC_DISP16_ACK;`
168			`end`
169			`EACALC_DISP16_ACK:`
170			`if (ack_i) begin`
171			`TERMINATE_CODE_READ
172			`disp16[7:0] <= dat_i;`
173			`state <= EACALC_DISP16a;`
174			`end`
175			`EACALC_DISP16a:`
176			`begin`
177			`INITIATE_CODE_READ
178			`state <= EACALC_DISP16a_ACK;`
179			`end`
180			`EACALC_DISP16a_ACK:`
181			`if (ack_i) begin`
182			`TERMINATE_CODE_READ
183			`lock_o <= bus_locked;`
184			`disp16[15:8] <= dat_i;`
185			`state <= EACALC1;`
186			`end`
187
188			`//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -`
189			`// Fetch 8 bit displacement`
190			`//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -`
191			`//`
192			`EACALC_DISP8:`
193			`begin`
194			`INITIATE_CODE_READ
195			`state <= EACALC_DISP8_ACK;`
196			`end`
197			`EACALC_DISP8_ACK:`
198			`if (ack_i) begin`
199			`TERMINATE_CODE_READ
200			`disp16 <= {{8{dat_i[7]}},dat_i};`
201			`state <= EACALC1;`
202			`end`
203
204
205			`//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -`
206			`// Add the displacement into the effective address`
207			`//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -`
208			`//`
209			`EACALC1:`
210			`begin`
211			`casex(ir)`
212			`EXTOP:
213			`casex(ir2)`
214			`8'h00:`
215			`begin`
216			`case(rrr)`
217			`3'b010: state <= FETCH_DESC; // LLDT`
218			`3'b011: state <= FETCH_DATA; // LTR`
219			`default: state <= FETCH_DATA;`
220			`endcase`
221			`if (w && (offsdisp==16'hFFFF)) begin`
222			`int_num <= 8'h0d;`
223			`state <= INT;`
224			`end`
225			`end`
226			`8'h01:`
227			`begin`
228			`case(rrr)`
229			`3'b010: state <= FETCH_DESC;`
230			`3'b011: state <= FETCH_DESC;`
231			`default: state <= FETCH_DATA;`
232			`endcase`
233			`if (w && (offsdisp==16'hFFFF)) begin`
234			`int_num <= 8'h0d;`
235			`state <= INT;`
236			`end`
237			`end`
238			`8'h03:`
239			`if (w && (offsdisp==16'hFFFF)) begin`
240			`int_num <= 8'h0d;`
241			`state <= INT;`
242			`end`
243			`else`
244			`state <= FETCH_DATA;`
245			`default:`
246			`if (w && (offsdisp==16'hFFFF)) begin`
247			`int_num <= 8'h0d;`
248			`state <= INT;`
249			`end`
250			`else`
251			`state <= FETCH_DATA;`
252			`endcase`
253			`MOV_I8M: state <= FETCH_IMM8;
254			`MOV_I16M:
255			`if (ip==16'hFFFF) begin`
256			`int_num <= 8'h0d;`
257			`state <= INT;`
258			`end`
259			`else`
260			`state <= FETCH_IMM16;`
261			`POP_MEM:
262			`begin`
263			`state <= POP;`
264			`end`
265			`XCHG_MEM:
266			`begin`
267			`// bus_locked <= 1'b1;`
268			`state <= FETCH_DATA;`
269			`end`
270			`default:`
271			`begin`
272			`if (w && (offsdisp==16'hFFFF)) begin`
273			`int_num <= 8'h0d;`
274			`state <= INT;`
275			`end`
276			`else`
277			`state <= FETCH_DATA;`
278			`if (ir==8'hff) begin`
279			`case(rrr)`
280			`3'b011: state <= CALLF; // CAll FAR indirect`
281			`3'b101: state <= JUMP_VECTOR1; // JMP FAR indirect`
282			`3'b110: begin d <= 1'b0; state <= FETCH_DATA; end// for a push`
283			`default: ;`
284			`endcase`
285			`end`
286			`end`
287			`endcase`
288			`// ea <= ea + disp16;`
289			ea <= {seg_reg,`SEG_SHIFT} + offsdisp; // offsdisp = offset + disp16
290			`end`