OpenCores
URL https://opencores.org/ocsvn/t48/t48/trunk

Subversion Repositories t48

[/] [t48/] [tags/] [rel_1_1/] [rtl/] [vhdl/] [decoder_pack-p.vhd] - Blame information for rev 339

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

Line No. Rev Author Line
1 4 arniml
-------------------------------------------------------------------------------
2
--
3 284 arniml
-- $Id: decoder_pack-p.vhd,v 1.4 2008-04-29 21:19:21 arniml Exp $
4 4 arniml
--
5
-- Copyright (c) 2004, Arnim Laeuger (arniml@opencores.org)
6
--
7
-- All rights reserved
8
--
9
-------------------------------------------------------------------------------
10
 
11 284 arniml
library ieee;
12
use ieee.std_logic_1164.all;
13
 
14
use work.t48_pack.word_t;
15
 
16 179 arniml
package t48_decoder_pack is
17 4 arniml
 
18
  -----------------------------------------------------------------------------
19
  -- The Mnemonics.
20
  -----------------------------------------------------------------------------
21
  type mnemonic_t is (MN_ADD,
22
                      MN_ADD_A_DATA,
23
                      MN_ANL,
24
                      MN_ANL_A_DATA,
25
                      MN_ANL_EXT,
26
                      MN_CALL,
27
                      MN_CLR_A,
28
                      MN_CLR_C,
29
                      MN_CLR_F,
30
                      MN_CPL_A,
31
                      MN_CPL_C,
32
                      MN_CPL_F,
33
                      MN_DA,
34
                      MN_DEC,
35
                      MN_DIS_EN_I,
36
                      MN_DIS_EN_TCNTI,
37
                      MN_DJNZ,
38
                      MN_ENT0_CLK,
39
                      MN_IN,
40
                      MN_INC,
41
                      MN_INS,
42
                      MN_JBB,
43
                      MN_JC,
44
                      MN_JF,
45
                      MN_JMP,
46
                      MN_JMPP,
47
                      MN_JNI,
48
                      MN_JT,
49
                      MN_JTF,
50
                      MN_JZ,
51
                      MN_MOV_A_DATA,
52
                      MN_MOV_A_PSW,
53
                      MN_MOV_A_RR,
54
                      MN_MOV_PSW_A,
55
                      MN_MOV_RR,
56
                      MN_MOV_RR_DATA,
57
                      MN_MOV_T,
58 22 arniml
                      MN_MOVD_A_PP,
59 4 arniml
                      MN_MOVP,
60
                      MN_MOVX,
61
                      MN_NOP,
62
                      MN_ORL,
63
                      MN_ORL_A_DATA,
64
                      MN_ORL_EXT,
65 22 arniml
                      MN_OUTD_PP_A,
66 4 arniml
                      MN_OUTL_EXT,
67
                      MN_RET,
68
                      MN_RL,
69
                      MN_RR,
70
                      MN_SEL_MB,
71
                      MN_SEL_RB,
72
                      MN_STOP_TCNT,
73
                      MN_STRT,
74
                      MN_SWAP,
75
                      MN_XCH,
76
                      MN_XRL,
77
                      MN_XRL_A_DATA);
78
 
79 284 arniml
  type mnemonic_rec_t is
80
    record
81
      mnemonic    : mnemonic_t;
82
      multi_cycle : boolean;
83
    end record;
84
 
85
  function decode_opcode_f(opcode : in word_t) return
86
    mnemonic_rec_t;
87
 
88 179 arniml
end t48_decoder_pack;
89 4 arniml
 
90
 
91 284 arniml
package body t48_decoder_pack is
92
 
93
  function decode_opcode_f(opcode : in word_t) return
94
    mnemonic_rec_t is
95
    variable mnemonic_v    : mnemonic_t;
96
    variable multi_cycle_v : boolean;
97
    variable result_v      : mnemonic_rec_t;
98
  begin
99
    -- default assignment
100
    mnemonic_v    := MN_NOP;
101
    multi_cycle_v := false;
102
 
103
    case opcode is
104
      -- Mnemonic ADD ---------------------------------------------------------
105
      when "01101000" | "01101001" | "01101010" | "01101011" |  -- ADD A, Rr
106
           "01101100" | "01101101" | "01101110" | "01101111" |  --
107
           "01100000" | "01100001" |                            -- ADD A, @ Rr
108
           "01111000" | "01111001" | "01111010" | "01111011" |  -- ADDC A, Rr
109
           "01111100" | "01111101" | "01111110" | "01111111" |  --
110
           "01110000" | "01110001" =>                           -- ADDC A, @ Rr
111
        mnemonic_v    := MN_ADD;
112
 
113
      -- Mnemonic ADD_A_DATA --------------------------------------------------
114
      when "00000011" |                                         -- ADD A, data
115
           "00010011" =>                                        -- ADDC A, data
116
        mnemonic_v    := MN_ADD_A_DATA;
117
        multi_cycle_v := true;
118
 
119
      -- Mnemonic ANL ---------------------------------------------------------
120
      when "01011000" | "01011001" | "01011010" | "01011011" |  -- ANL A, Rr
121
           "01011100" | "01011101" | "01011110" | "01011111" |  --
122
           "01010000" | "01010001" =>                           -- ANL A, @ Rr
123
        mnemonic_v    := MN_ANL;
124
 
125
      -- Mnemonic ANL_A_DATA --------------------------------------------------
126
      when "01010011" =>                                        -- ANL A, data
127
        mnemonic_v    := MN_ANL_A_DATA;
128
        multi_cycle_v := true;
129
 
130
      -- Mnemonic ANL_EXT -----------------------------------------------------
131
      when "10011000" |                                         -- ANL BUS, data
132
           "10011001" | "10011010" =>                           -- ANL PP, data
133
        mnemonic_v    := MN_ANL_EXT;
134
        multi_cycle_v := true;
135
 
136
      -- Mnemonic CALL --------------------------------------------------------
137
      when "00010100" | "00110100" | "01010100" | "01110100" |  -- CALL addr
138
           "10010100" | "10110100" | "11010100" | "11110100" => --
139
        mnemonic_v    := MN_CALL;
140
        multi_cycle_v := true;
141
 
142
      -- Mnemonic CLR_A -------------------------------------------------------
143
      when "00100111" =>                                        -- CLR A
144
        mnemonic_v    := MN_CLR_A;
145
 
146
      -- Mnemonic CLR_C -------------------------------------------------------
147
      when "10010111" =>                                        -- CLR C
148
        mnemonic_v    := MN_CLR_C;
149
 
150
      -- Mnemonic CLR_F -------------------------------------------------------
151
      when "10000101" |                                         -- CLR F0
152
           "10100101" =>
153
        mnemonic_v    := MN_CLR_F;
154
 
155
      -- Mnemonic CPL_A -------------------------------------------------------
156
      when "00110111" =>                                        -- CPL A
157
        mnemonic_v    := MN_CPL_A;
158
 
159
      -- Mnemonic CPL_C -------------------------------------------------------
160
      when "10100111" =>                                        -- CPL C
161
        mnemonic_v    := MN_CPL_C;
162
 
163
      -- Mnemonic CPL_F -------------------------------------------------------
164
      when "10010101" |                                         -- CPL F0
165
           "10110101" =>                                        -- CPL F1
166
        mnemonic_v    := MN_CPL_F;
167
 
168
      -- Mnemonic DA ----------------------------------------------------------
169
      when "01010111" =>                                        -- DA D
170
        mnemonic_v    := MN_DA;
171
 
172
      -- Mnemonic DEC ---------------------------------------------------------
173
      when "11001000" | "11001001" | "11001010" | "11001011" |  -- DEC Rr
174
           "11001100" | "11001101" | "11001110" | "11001111" |  --
175
           "00000111" =>                                        -- DEC A
176
        mnemonic_v    := MN_DEC;
177
 
178
      -- Mnemonic DIS_EN_I ----------------------------------------------------
179
      when "00010101" |                                         -- DIS I
180
           "00000101" =>                                        -- EN I
181
        mnemonic_v    := MN_DIS_EN_I;
182
 
183
      -- Mnemonic DIS_EN_TCNTI ------------------------------------------------
184
      when "00110101" |                                         -- DIS TCNTI
185
           "00100101" =>                                        -- EN TCNTI
186
        mnemonic_v    := MN_DIS_EN_TCNTI;
187
 
188
      -- Mnemonic DJNZ --------------------------------------------------------
189
      when "11101000" | "11101001" | "11101010" | "11101011" |  -- DJNZ Rr, addr
190
           "11101100" | "11101101" | "11101110" | "11101111" => --
191
        mnemonic_v    := MN_DJNZ;
192
        multi_cycle_v := true;
193
 
194
      -- Mnemonic ENT0_CLK ----------------------------------------------------
195
      when "01110101" =>                                        -- ENT0 CLK
196
        mnemonic_v    := MN_ENT0_CLK;
197
 
198
      -- Mnemonic IN ----------------------------------------------------------
199
      when "00001001" | "00001010" =>                           -- IN A, Pp
200
        mnemonic_v    := MN_IN;
201
        multi_cycle_v := true;
202
 
203
      -- Mnemonic INC ---------------------------------------------------------
204
      when "00010111" |                                         -- INC A
205
           "00011000" | "00011001" | "00011010" | "00011011" |  -- INC Rr
206
           "00011100" | "00011101" | "00011110" | "00011111" |  --
207
           "00010000" | "00010001" =>                           -- INC @ Rr
208
        mnemonic_v    := MN_INC;
209
 
210
      -- Mnemonic INS ---------------------------------------------------------
211
      when "00001000" =>                                        -- INS A, BUS
212
        mnemonic_v    := MN_INS;
213
        multi_cycle_v := true;
214
 
215
      -- Mnemonic JBB ---------------------------------------------------------
216
      when "00010010" | "00110010" | "01010010" | "01110010" |  -- JBb addr
217
           "10010010" | "10110010" | "11010010" | "11110010" => --
218
        mnemonic_v    := MN_JBB;
219
        multi_cycle_v := true;
220
 
221
      -- Mnemonic JC ----------------------------------------------------------
222
      when "11110110" |                                         -- JC addr
223
           "11100110" =>                                        -- JNC addr
224
        mnemonic_v    := MN_JC;
225
        multi_cycle_v := true;
226
 
227
      -- Mnemonic JF ----------------------------------------------------------
228
      when "10110110" |                                         -- JF0 addr
229
           "01110110" =>                                        -- JF1 addr
230
        mnemonic_v    := MN_JF;
231
        multi_cycle_v := true;
232
 
233
      -- Mnemonic JMP ---------------------------------------------------------
234
      when "00000100" | "00100100" | "01000100" | "01100100" |  -- JMP addr
235
           "10000100" | "10100100" | "11000100" | "11100100" => --
236
        mnemonic_v    := MN_JMP;
237
        multi_cycle_v := true;
238
 
239
      -- Mnemonic JMPP --------------------------------------------------------
240
      when "10110011" =>                                        -- JMPP @ A
241
        mnemonic_v    := MN_JMPP;
242
        multi_cycle_v := true;
243
 
244
      -- Mnemonic JNI ---------------------------------------------------------
245
      when "10000110" =>                                        -- JNI addr
246
        mnemonic_v    := MN_JNI;
247
        multi_cycle_v := true;
248
 
249
      -- Mnemonic JT ----------------------------------------------------------
250
      when "00100110" |                                         -- JNT0 addr
251
           "01000110" |                                         -- JNT1 addr
252
           "00110110" |                                         -- JT0 addr
253
           "01010110" =>                                        -- JT1 addr
254
        mnemonic_v    := MN_JT;
255
        multi_cycle_v := true;
256
 
257
      -- Mnemonic JTF ---------------------------------------------------------
258
      when "00010110" =>                                        -- JTF addr
259
        mnemonic_v    := MN_JTF;
260
        multi_cycle_v := true;
261
 
262
      -- Mnemonic JZ ----------------------------------------------------------
263
      when "10010110" |                                         -- JNZ addr
264
           "11000110" =>                                        -- JZ addr
265
        mnemonic_v    := MN_JZ;
266
        multi_cycle_v := true;
267
 
268
      -- Mnemonic MOV_A_DATA --------------------------------------------------
269
      when "00100011" =>                                        -- MOV A, data
270
        mnemonic_v    := MN_MOV_A_DATA;
271
        multi_cycle_v := true;
272
 
273
      -- Mnemonic MOV_A_PSW ---------------------------------------------------
274
      when "11000111" =>                                        -- MOV A, PSW
275
        mnemonic_v    := MN_MOV_A_PSW;
276
 
277
      -- Mnemonic MOV_A_RR ----------------------------------------------------
278
      when "11111000" | "11111001" | "11111010" | "11111011" |  -- MOV A, Rr
279
           "11111100" | "11111101" | "11111110" | "11111111" |  --
280
           "11110000" | "11110001" =>                           -- MOV A, @ Rr
281
        mnemonic_v    := MN_MOV_A_RR;
282
 
283
      -- Mnemonic MOV_PSW_A ---------------------------------------------------
284
      when "11010111" =>                                        -- MOV PSW, A
285
        mnemonic_v    := MN_MOV_PSW_A;
286
 
287
      -- Mnemonic MOV_RR ------------------------------------------------------
288
      when "10101000" | "10101001" | "10101010" | "10101011" |  -- MOV Rr, A
289
           "10101100" | "10101101" | "10101110" | "10101111" |  --
290
           "10100000" | "10100001" =>                           -- MOV @ Rr, A
291
        mnemonic_v    := MN_MOV_RR;
292
 
293
      -- Mnemonic MOV_RR_DATA -------------------------------------------------
294
      when "10111000" | "10111001" | "10111010" | "10111011" |  -- MOV Rr, data
295
           "10111100" | "10111101" | "10111110" | "10111111" |  --
296
           "10110000" | "10110001" =>                           -- MOV @ Rr, data
297
        mnemonic_v    := MN_MOV_RR_DATA;
298
        multi_cycle_v := true;
299
 
300
      -- Mnemonic MOV_T -------------------------------------------------------
301
      when "01100010" |                                         -- MOV T, A
302
           "01000010" =>                                        -- MOV A, T
303
        mnemonic_v    := MN_MOV_T;
304
 
305
      -- Mnemonic MOVD_A_PP ---------------------------------------------------
306
      when "00001100" | "00001101" | "00001110" | "00001111" => -- MOVD A, Pp
307
        mnemonic_v    := MN_MOVD_A_PP;
308
        multi_cycle_v := true;
309
 
310
      -- Mnemonic MOVP --------------------------------------------------------
311
      when "10100011" |                                         -- MOVP A, @ A
312
           "11100011" =>                                        -- MOVP3 A, @ A
313
        mnemonic_v    := MN_MOVP;
314
        multi_cycle_v := true;
315
 
316
      -- Mnemonic MOVX --------------------------------------------------------
317
      when "10000000" | "10000001" |                            -- MOVX A, @ Rr
318
           "10010000" | "10010001" =>                           -- MOVX @ Rr, A
319
        mnemonic_v    := MN_MOVX;
320
        multi_cycle_v := true;
321
 
322
      -- Mnemonic NOP ---------------------------------------------------------
323
      when "00000000" =>                                        -- NOP
324
        mnemonic_v    := MN_NOP;
325
 
326
      -- Mnemonic ORL ---------------------------------------------------------
327
      when "01001000" | "01001001" | "01001010" | "01001011" |  -- ORL A, Rr
328
           "01001100" | "01001101" | "01001110" | "01001111" |  --
329
           "01000000" | "01000001" =>                           -- ORL A, @ Rr
330
        mnemonic_v    := MN_ORL;
331
 
332
      -- Mnemonic ORL_A_DATA --------------------------------------------------
333
      when "01000011" =>                                        -- ORL A, data
334
        mnemonic_v    := MN_ORL_A_DATA;
335
        multi_cycle_v := true;
336
 
337
      -- Mnemonic ORL_EXT -----------------------------------------------------
338
      when "10001000" |                                         -- ORL BUS, data
339
           "10001001" | "10001010" =>                           -- ORL Pp, data
340
        mnemonic_v    := MN_ORL_EXT;
341
        multi_cycle_v := true;
342
 
343
      -- Mnemonic OUTD_PP_A ---------------------------------------------------
344
      when "00111100" | "00111101" | "00111110" | "00111111" |  -- MOVD Pp, A
345
           "10011100" | "10011101" | "10011110" | "10011111" |  -- ANLD PP, A
346
           "10001100" | "10001101" | "10001110" | "10001111" => -- ORLD Pp, A
347
        mnemonic_v    := MN_OUTD_PP_A;
348
        multi_cycle_v := true;
349
 
350
      -- Mnemonic OUTL_EXT ----------------------------------------------------
351
      when "00111001" | "00111010" |                            -- OUTL Pp, A
352
           "00000010" =>                                        -- OUTL BUS, A
353
        mnemonic_v    := MN_OUTL_EXT;
354
        multi_cycle_v := true;
355
 
356
      -- Mnemonic RET ---------------------------------------------------------
357
      when "10000011" |                                         -- RET
358
           "10010011" =>                                        -- RETR
359
        mnemonic_v    := MN_RET;
360
        multi_cycle_v := true;
361
 
362
      -- Mnemonic RL ----------------------------------------------------------
363
      when "11100111" |                                         -- RL A
364
           "11110111" =>                                        -- RLC A
365
        mnemonic_v    := MN_RL;
366
 
367
      -- Mnemonic RR ----------------------------------------------------------
368
      when "01110111" |                                         -- RR A
369
           "01100111" =>                                        -- RRC A
370
        mnemonic_v    := MN_RR;
371
 
372
      -- Mnemonic SEL_MB ------------------------------------------------------
373
      when "11100101" |                                         -- SEL MB0
374
           "11110101" =>                                        -- SEL MB1
375
        mnemonic_v    := MN_SEL_MB;
376
 
377
      -- Mnemonic SEL_RB ------------------------------------------------------
378
      when "11000101" |                                         -- SEL RB0
379
           "11010101" =>                                        -- SEL RB1
380
        mnemonic_v    := MN_SEL_RB;
381
 
382
      -- Mnemonic STOP_TCNT ---------------------------------------------------
383
      when "01100101" =>                                        -- STOP TCNT
384
        mnemonic_v    := MN_STOP_TCNT;
385
 
386
      -- Mnemonic START -------------------------------------------------------
387
      when "01000101" |                                         -- STRT CNT
388
           "01010101" =>                                        -- STRT T
389
        mnemonic_v    := MN_STRT;
390
 
391
      -- Mnemonic SWAP --------------------------------------------------------
392
      when "01000111" =>                                        -- SWAP A
393
        mnemonic_v    := MN_SWAP;
394
 
395
      -- Mnemonic XCH ---------------------------------------------------------
396
      when "00101000" | "00101001" | "00101010" | "00101011" |  -- XCH A, Rr
397
           "00101100" | "00101101" | "00101110" | "00101111" |  --
398
           "00100000" | "00100001" |                            -- XCH A, @ Rr
399
           "00110000" | "00110001" =>                           -- XCHD A, @ Rr
400
        mnemonic_v    := MN_XCH;
401
 
402
      -- Mnemonic XRL ---------------------------------------------------------
403
      when "11011000" | "11011001" | "11011010" | "11011011" |  -- XRL A, Rr
404
           "11011100" | "11011101" | "11011110" | "11011111" |  --
405
           "11010000" | "11010001" =>                           -- XRL A, @ Rr
406
        mnemonic_v    := MN_XRL;
407
 
408
      -- Mnemonic XRL_A_DATA --------------------------------------------------
409
      when "11010011" =>                                        -- XRL A, data
410
        mnemonic_v    := MN_XRL_A_DATA;
411
        multi_cycle_v := true;
412
 
413
      when others =>
414
        -- pragma translate_off
415
        assert now = 0 ns
416
          report "Unknown opcode."
417
          severity warning;
418
        -- pragma translate_on
419
 
420
    end case;
421
 
422
    result_v.mnemonic    := mnemonic_v;
423
    result_v.multi_cycle := multi_cycle_v;
424
 
425
    return result_v;
426
  end;
427
 
428
end t48_decoder_pack;
429
 
430
 
431 4 arniml
-------------------------------------------------------------------------------
432
-- File History:
433
--
434
-- $Log: not supported by cvs2svn $
435 284 arniml
-- Revision 1.3  2005/06/11 10:08:43  arniml
436
-- introduce prefix 't48_' for all packages, entities and configurations
437
--
438 179 arniml
-- Revision 1.2  2004/03/28 13:09:53  arniml
439
-- merge MN_ANLD, MN_MOVD_PP_A and MN_ORLD_PP_A to OUTLD_PP_A
440
--
441 22 arniml
-- Revision 1.1  2004/03/23 21:31:52  arniml
442
-- initial check-in
443 4 arniml
--
444
-------------------------------------------------------------------------------

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.