1. `include "defines.vh"
2. module decode_unit #(
3.                 parameter  INSTR_WIDTH  = 16,   // instructions are 16 bits in width
4.                 parameter  R_ADDR_WIDTH = 5
5.  
6.         )(
7.                 input  wire  [INSTR_WIDTH-1:0]   instruction,
8.                 output reg   [`OPCODE_COUNT-1:0] opcode_type,
9.                 output wire  [`GROUP_COUNT-1:0]  opcode_group,
10.                 output reg   [R_ADDR_WIDTH-1:0]  opcode_rd,
11.                 output reg   [R_ADDR_WIDTH-1:0]  opcode_rr,
12.                 output reg               [11:0]  opcode_imd,
13.                 output reg                [2:0]  opcode_bit
14.         );
15.  
16. /*Fiindca register file-ul procesorului nostru (ATtiny20)
17. are doar 16 registre, putem ignora bitii Rr si Rd de pe pozitiile 9 si 8
18. (Atmel garanteaza ca, din motive de compatibilitate, vor fi mereu setati
19. pe 1, sau, echivalent, vor fi folosite numai registrele R16 ? R31).
20. Deci opcode = 000111rdxxxxxxxx devifne 00011111xxxxxxxx. (Btw, that's ADD)
21. */
22.  
23.         always @* begin
24.                   casez (instruction)
25.                         16'b0000_11??_????_????: begin
26.                                 opcode_type = `TYPE_ADD;
27.                                 opcode_rd   = instruction[8:4];
28.                                 opcode_rr   = {instruction[9], instruction[3:0]};
29.                         end
30.                         16'b0001_11??_????_????: begin
31.                                 opcode_type = `TYPE_ADC;
32.                                 opcode_rd   = instruction[8:4];
33.                                 opcode_rr   = {instruction[9], instruction[3:0]};
34.                         end
35.                         16'b0010_00??_????_????: begin
36.                                 opcode_type = `TYPE_AND;
37.                                 opcode_rd   = instruction[8:4];
38.                                 opcode_rr   = {instruction[9], instruction[3:0]};
39.                         end
40.                                 16'b0010_01??_????_????: begin
41.                                 opcode_type = `TYPE_EOR;
42.                                 opcode_rd   = instruction[8:4];
43.                                 opcode_rr   = {instruction[9], instruction[3:0]};
44.                         end
45.                         /* TODO 5: LD_Y */
46.                         16'b1000_000?_????_1000: begin
47.                                 opcode_type = `TYPE_LD_Y;
48.                                 opcode_rd   = instruction[8:4];
49.                                 opcode_rr   = {R_ADDR_WIDTH{1'bx}};
50.                                 opcode_imd  = 12'bx;
51.                         end
52.                         /* TODO 3: LDI */
53.                         16'b1110_????_????_????: begin
54.                                 opcode_type = `TYPE_LDI;
55.                                 opcode_rd   = {1'b1, instruction[7:4]};
56.                                 opcode_rr   = {R_ADDR_WIDTH{1'bx}};
57.                                 opcode_imd  = {4'b0, instruction[11:8], instruction[3:0]};
58.                         end
59.                         /* TODO 6,7: instructions */
60.                         16'b1010_0???_????_????: begin
61.                                 opcode_type = `TYPE_LDS;
62.                                 opcode_rd   = {1'b1, instruction[7:4]};
63.                                 opcode_rr   = {R_ADDR_WIDTH{1'bx}};
64.                                 opcode_imd  = {~instruction[8], instruction[8], instruction[10:9], instruction[3:0]};
65.                         end
66.                         16'b0010_11??_????_????: begin
67.                                 opcode_type = `TYPE_MOV;
68.                                 opcode_rd   = instruction[8:4];
69.                                 opcode_rr   = {instruction[9], instruction[3:0]};
70.                                 opcode_imd  = 12'bx;
71.                         end
72.                         16'b1001_010?_????_0001: begin
73.                                 opcode_type = `TYPE_NEG;
74.                                 opcode_rd   = instruction[8:4];
75.                                 opcode_rr   = {R_ADDR_WIDTH{1'bx}};
76.                         end
77.                         16'b0000_0000_0000_0000: begin
78.                                 opcode_type = `TYPE_NOP;
79.                                 opcode_rd   = {R_ADDR_WIDTH{1'bx}};
80.                                 opcode_rr   = {R_ADDR_WIDTH{1'bx}};
81.                         end
82.                         16'b0010_10??_????_????: begin
83.                                 opcode_type = `TYPE_OR;
84.                                 opcode_rd   = instruction[8:4];
85.                                 opcode_rr   = {instruction[9], instruction[3:0]};
86.                         end
87.                         16'b0001_10??_????_????: begin
88.                                 opcode_type = `TYPE_SUB;
89.                                 opcode_rd   = instruction[8:4];
90.                                 opcode_rr   = {instruction[9], instruction[3:0]};
91.                         end
92.                         /*TODO 4: STS */
93.                         16'b1010_1???_????_????: begin
94.                                 opcode_type = `TYPE_STS;
95.                                 opcode_rd   = {R_ADDR_WIDTH{1'bx}};
96.                                 opcode_rr   = {1'b1, instruction[7:4]};
97.                                 opcode_imd  = {~instruction[8], instruction[8], instruction[10:9], instruction[3:0]};
98.                         end
99.                                 /* TODO : De codificat instructiunile din laborator. */
100.  
101.                                 default: begin
102.                                         opcode_type = `TYPE_UNKNOWN;
103.                                         opcode_rd   = {R_ADDR_WIDTH{1'bx}};
104.                                         opcode_rr   = {R_ADDR_WIDTH{1'bx}};
105.                                 end
106.                 /*TODO : completati cu opcodes ale voastre.
107.                   Where can I find such opcodes? Make them up or read the lab and see
108.                   they're at http://www.atmel.com/images/Atmel-0856-AVR-Instruction-Set-Manual.pdf  */
109.                   /* Cand gasiti o instructiune de UAL, setati opcode_type la valoarea corecta */
110.                   /*  instruction seamana cu un ADD? -> opcode_type = `TYPE_ADD; */
111.                   endcase
112.         end
113.  
114.         assign opcode_group[`GROUP_ALU_ONE_OP] =
115.                 (opcode_type == `TYPE_NEG);
116.         assign opcode_group[`GROUP_ALU_TWO_OP] =
117.                 (opcode_type == `TYPE_ADD) ||
118.                 (opcode_type == `TYPE_ADC) ||
119.                 (opcode_type == `TYPE_SUB) ||
120.                 (opcode_type == `TYPE_AND) ||
121.                 (opcode_type == `TYPE_EOR) ||
122.                 (opcode_type == `TYPE_OR);
123.         assign opcode_group[`GROUP_ALU] =
124.                 opcode_group[`GROUP_ALU_ONE_OP] ||
125.                 opcode_group[`GROUP_ALU_TWO_OP];
126.  
127.         assign opcode_group[`GROUP_LOAD_DIRECT] =
128.                 (opcode_type == `TYPE_LDS);
129.         assign opcode_group[`GROUP_LOAD_INDIRECT] =
130.                 (opcode_type == `TYPE_LD_Y);
131.  
132.         assign opcode_group[`GROUP_STORE_DIRECT] =
133.                 (opcode_type == `TYPE_STS);
134.         assign opcode_group[`GROUP_STORE_INDIRECT] =
135.                 0;
136.  
137.         assign opcode_group[`GROUP_REGISTER] =
138.                 /* TODO 3: LDI */
139.                 (opcode_type == `TYPE_LDI) ||
140.                 (opcode_type == `TYPE_MOV);
141.  
142.         assign opcode_group[`GROUP_LOAD] =
143.                 opcode_group[`GROUP_LOAD_DIRECT] ||
144.                 opcode_group[`GROUP_LOAD_INDIRECT];
145.         assign opcode_group[`GROUP_STORE] =
146.                 opcode_group[`GROUP_STORE_DIRECT] ||
147.                 opcode_group[`GROUP_STORE_INDIRECT];
148.         assign opcode_group[`GROUP_MEMORY] =
149.                 (opcode_group[`GROUP_LOAD] ||
150.                  opcode_group[`GROUP_STORE]);
151. endmodule
152.