cours3: soclib_vci_iss.h

File soclib_vci_iss.h, 5.3 KB (added by fpecheux, 16 years ago)

Un composant initiateur simple de type Instruction Set Simulator MIPS

Line 
1#ifndef SOCLIB_VCI_ISS_H
2#define SOCLIB_VCI_ISS_H
3
4#define sc_register sc_signal
5
6#include <signal.h>
7#include <iostream.h>
8#include <fstream.h>
9#include <stdlib.h>
10#include <systemc.h>
11
12template <
13   int ADDRSIZE,
14   int CELLSIZE,
15   int ERRSIZE,
16   int PLENSIZE,
17   int CLENSIZE,
18   int SRCIDSIZE,
19   int TRDIDSIZE,
20   int PKTIDSIZE >
21
22struct SOCLIB_VCI_ISS : sc_module {
23
24        sc_in<bool> CLK;
25        sc_in<bool> RESETN;
26        ADVANCED_VCI_INITIATOR<ADDRSIZE, CELLSIZE, ERRSIZE, PLENSIZE, CLENSIZE, SRCIDSIZE, TRDIDSIZE, PKTIDSIZE> VCI_INITIATOR;
27
28        const char *NAME;
29        sc_register<int>        ISS_FSM;
30        sc_register<int>        GPR[32];
31        sc_register<int>        PC,IR,EA;
32
33        enum{
34                ISS_REQ_IFETCH  = 0,
35                ISS_RSP_IFETCH  = 1,
36                ISS_DECODE_AND_EXECUTE  = 2,
37                ISS_REQ_LOAD  = 3,
38                ISS_RSP_LOAD  = 4,
39                ISS_REQ_STORE  = 5,
40                ISS_RSP_STORE  = 6
41        };
42
43        enum {
44                OP_SPECIAL = 0,
45                OP_ADDI = 8,
46                OP_ORI = 13,
47                OP_LW = 35,
48                OP_SW = 43,
49                FUNC_ADD = 32,
50                FUNC_SUB = 34,
51        };
52        SC_HAS_PROCESS (SOCLIB_VCI_ISS);
53
54SOCLIB_VCI_ISS (
55  sc_module_name insname
56)
57{
58#ifdef NONAME_RENAME
59        char name[100];
60        ISS_FSM.rename("ISS_FSM");
61        PC.rename("PC");
62        IR.rename("IR");
63        EA.rename("EA");
64        for (int j=0 ; j < 32; j++)
65          {
66                  sprintf(name,"GPR_%2.2d",j);
67                  GPR[j].rename(name);
68          }
69
70#endif
71
72  SC_METHOD (transition);
73  sensitive << CLK.pos();
74  SC_METHOD (genMoore);
75  sensitive << CLK.neg();
76
77  NAME = (char*) strdup(insname);
78
79  if (NAME == NULL) {
80      perror("malloc");
81      exit(1);
82   }
83  printf("SOCLIB_VCI_ISS instanciated with name %s\n",NAME);
84}
85
86void transition()
87{
88        if(RESETN == false)
89        {
90                ISS_FSM = ISS_REQ_IFETCH;
91                IR=0;
92                PC=0x00000000;
93                EA=0;
94                for (int i=0;i<32;i++)
95                        GPR[i]=0;
96        } else
97        {
98printf("ISS_FSM=%d\n",(int)ISS_FSM.read());
99                switch(ISS_FSM)
100                {
101                        case ISS_REQ_IFETCH :
102                                if(VCI_INITIATOR.CMDACK == true)
103                                {
104                                        ISS_FSM = ISS_RSP_IFETCH;
105                                }
106                                break;
107                        case ISS_RSP_IFETCH :
108                                if(VCI_INITIATOR.RSPVAL == true)
109                                {
110                                        ISS_FSM = ISS_DECODE_AND_EXECUTE;
111                                        IR = (int) VCI_INITIATOR.RDATA.read();
112                                }
113                                break;
114                        case ISS_DECODE_AND_EXECUTE :
115                                {
116                                        int opcod=(IR>>26)&0x3F;
117                                        int rs,rt,rd,func,imm;
118
119                                        switch (opcod)
120                                        {
121                                                case OP_ADDI:
122                                                        rs=(IR>>21)&0x1F;
123                                                        rt=(IR>>16)&0x1F;
124                                                        imm=(IR&0xFFFF);
125                                                        if (imm & 0x8000)
126                                                                imm |= 0xFFFF0000;
127
128                                                        GPR[rt]=GPR[rs] + imm;
129
130                                                        PC=PC+4;
131                                                        ISS_FSM=ISS_REQ_IFETCH;
132                                                        break;
133                                                case OP_ORI:
134                                                        rs=(IR>>21)&0x1F;
135                                                        rt=(IR>>16)&0x1F;
136                                                        imm=(IR&0xFFFF);
137                                                        if (imm & 0x8000)
138                                                                imm |= 0xFFFF0000;
139
140                                                        GPR[rt]=GPR[rs] | imm;
141
142                                                        PC=PC+4;
143                                                        ISS_FSM=ISS_REQ_IFETCH;
144                                                        break;
145                                                case OP_SPECIAL:
146                                                        rs=(IR>>21)&0x1F;
147                                                        rt=(IR>>16)&0x1F;
148                                                        rd=(IR>>11)&0x1F;
149                                                        func=IR&0x3F;
150                                                        switch (func)
151                                                        {
152                                                                case FUNC_ADD:
153                                                                        GPR[rd]=GPR[rs] + GPR[rt];
154                                                                        break;
155                                                                case FUNC_SUB:
156                                                                        GPR[rd]=GPR[rs] - GPR[rt];
157                                                                        break;
158                                                        }
159                                                        PC=PC+4;
160                                                        ISS_FSM=ISS_REQ_IFETCH;
161                                                        break;
162                                                case OP_LW:
163                                                        rs=(IR>>21)&0x1F;
164                                                        imm=(IR&0xFFFF);
165                                                        if (imm & 0x8000)
166                                                                imm |= 0xFFFF0000;
167                                                        EA=GPR[rs]+imm;
168                                                        ISS_FSM=ISS_REQ_LOAD;
169                                                        break;
170                        case OP_SW:
171                            rs=(IR>>21)&0x1F;
172                            imm=(IR&0xFFFF);
173                            if (imm & 0x8000)
174                                imm |= 0xFFFF0000;
175                            EA=GPR[rs]+imm;
176                            ISS_FSM=ISS_REQ_STORE;
177                                                        break;
178                                        }
179                                }
180                                break;
181                        case ISS_REQ_LOAD :
182                                if(VCI_INITIATOR.CMDACK == true)
183                                {
184                                        ISS_FSM = ISS_RSP_LOAD;
185                                }
186                                break;
187                        case ISS_RSP_LOAD :
188                                if(VCI_INITIATOR.RSPVAL == true)
189                                {
190                                        int rt;
191                                        rt=(IR>>16)&0x1F;
192
193                                        GPR[rt] = (int)VCI_INITIATOR.RDATA.read();
194
195                                        PC=PC+4;
196                                        ISS_FSM = ISS_REQ_IFETCH;
197                                }
198                                break;
199                        case ISS_REQ_STORE :
200                                if(VCI_INITIATOR.CMDACK == true)
201                                {
202                                        ISS_FSM = ISS_RSP_STORE;
203                                }
204                                break;
205                        case ISS_RSP_STORE :
206                                if(VCI_INITIATOR.RSPVAL == true)
207                                {
208                                        PC=PC+4;
209                                        ISS_FSM = ISS_REQ_IFETCH;
210                                }
211                                break;
212                }
213        }
214}
215
216void genMoore()
217{
218        int rt;
219
220        switch (ISS_FSM)
221        {
222                case ISS_REQ_IFETCH:
223                        VCI_INITIATOR.CMDVAL = true;
224                        VCI_INITIATOR.RSPACK = false;
225                        VCI_INITIATOR.ADDRESS = (sc_uint<32>) PC.read();
226                        VCI_INITIATOR.WDATA = 0;
227                        VCI_INITIATOR.CMD = VCI_CMD_READ;
228                        VCI_INITIATOR.EOP = true;
229                        VCI_INITIATOR.BE = 0xF;
230                        VCI_INITIATOR.PLEN = 1 << 2;
231                        break;
232                case ISS_RSP_IFETCH:
233                        VCI_INITIATOR.CMDVAL = false;
234                        VCI_INITIATOR.RSPACK = true;
235                        break;
236                case ISS_REQ_LOAD:
237                        VCI_INITIATOR.CMDVAL = true;
238                        VCI_INITIATOR.RSPACK = false;
239                        VCI_INITIATOR.ADDRESS = (sc_uint<32>) EA.read();
240                        VCI_INITIATOR.WDATA = 0;
241                        VCI_INITIATOR.CMD = VCI_CMD_READ;
242                        VCI_INITIATOR.EOP = true;
243                        VCI_INITIATOR.BE = 0xF;
244                        VCI_INITIATOR.PLEN = 1 << 2;
245                        break;
246                case ISS_RSP_LOAD:
247                        VCI_INITIATOR.CMDVAL = false;
248                        VCI_INITIATOR.RSPACK = true;
249                        break;
250                case ISS_REQ_STORE:
251                        VCI_INITIATOR.CMDVAL = true;
252                        VCI_INITIATOR.RSPACK = false;
253                        VCI_INITIATOR.ADDRESS = (sc_uint<32>) EA.read();
254                        rt=(IR>>16)&0x1F;
255                        VCI_INITIATOR.WDATA = (sc_uint<32>) GPR[rt];
256                        VCI_INITIATOR.CMD = VCI_CMD_WRITE;
257                        VCI_INITIATOR.EOP = true;
258                        VCI_INITIATOR.BE = 0xF;
259                        VCI_INITIATOR.PLEN = 1 << 2;
260                        break;
261                case ISS_RSP_STORE:
262                        VCI_INITIATOR.CMDVAL = false;
263                        VCI_INITIATOR.RSPACK = true;
264                        break;
265        }
266}
267
268};
269
270#endif
271