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

Subversion Repositories apbtoaes128

[/] [apbtoaes128/] [trunk/] [pli/] [aes_init.h] - Blame information for rev 12

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

Line No. Rev Author Line
1 4 redbear
//////////////////////////////////////////////////////////////////
2
////
3
////
4
////    AES CORE BLOCK
5
////
6
////
7
////
8
//// This file is part of the APB to AES128 project
9
////
10
//// http://www.opencores.org/cores/apbtoaes128/
11
////
12
////
13
////
14
//// Description
15
////
16
//// Implementation of APB IP core according to
17
////
18
//// aes128_spec IP core specification document.
19
////
20
////
21
////
22
//// To Do: Things are right here but always all block can suffer changes
23
////
24
////
25
////
26
////
27
////
28
//// Author(s): - Felipe Fernandes Da Costa, fefe2560@gmail.com
29
////
30
///////////////////////////////////////////////////////////////// 
31
////
32
////
33
//// Copyright (C) 2009 Authors and OPENCORES.ORG
34
////
35
////
36
////
37
//// This source file may be used and distributed without
38
////
39
//// restriction provided that this copyright statement is not
40
////
41
//// removed from the file and that any derivative work contains
42
//// the original copyright notice and the associated disclaimer.
43
////
44
////
45
//// This source file is free software; you can redistribute it
46
////
47
//// and/or modify it under the terms of the GNU Lesser General
48
////
49
//// Public License as published by the Free Software Foundation;
50
//// either version 2.1 of the License, or (at your option) any
51
////
52
//// later version.
53
////
54
////
55
////
56
//// This source is distributed in the hope that it will be
57
////
58
//// useful, but WITHOUT ANY WARRANTY; without even the implied
59
////
60
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
61
////
62
//// PURPOSE. See the GNU Lesser General Public License for more
63
//// details.
64
////
65
////
66
////
67
//// You should have received a copy of the GNU Lesser General
68
////
69
//// Public License along with this source; if not, download it
70
////
71
//// from http://www.opencores.org/lgpl.shtml
72
////
73
////
74
///////////////////////////////////////////////////////////////////
75
static int init_calltf(char*user_data)
76
{
77
 
78
        vpiHandle PRESETn = vpi_handle_by_name("AES_GLADIC_tb.PRESETn", NULL);
79
        vpiHandle PWDATA = vpi_handle_by_name("AES_GLADIC_tb.PWDATA", NULL);
80
        vpiHandle PENABLE = vpi_handle_by_name("AES_GLADIC_tb.PENABLE", NULL);
81
        vpiHandle PSEL = vpi_handle_by_name("AES_GLADIC_tb.PSEL", NULL);
82
        vpiHandle PWRITE = vpi_handle_by_name("AES_GLADIC_tb.PWRITE", NULL);
83
        vpiHandle PADDR = vpi_handle_by_name("AES_GLADIC_tb.PADDR", NULL);
84
        vpiHandle PRDATA = vpi_handle_by_name("AES_GLADIC_tb.PRDATA", NULL);
85
        vpiHandle PREADY = vpi_handle_by_name("AES_GLADIC_tb.PREADY", NULL);
86
        vpiHandle PSLVERR = vpi_handle_by_name("AES_GLADIC_tb.PSLVERR", NULL);
87
        vpiHandle int_ccf = vpi_handle_by_name("AES_GLADIC_tb.int_ccf", NULL);
88
        vpiHandle int_err = vpi_handle_by_name("AES_GLADIC_tb.int_err", NULL);
89
        vpiHandle dma_req_wr = vpi_handle_by_name("AES_GLADIC_tb.dma_req_wr", NULL);
90
        vpiHandle dma_req_rd = vpi_handle_by_name("AES_GLADIC_tb.dma_req_rd", NULL);
91
        vpiHandle i = vpi_handle_by_name("AES_GLADIC_tb.i", NULL);
92
 
93
 
94
 
95
        STATE = IDLE;
96
 
97
 
98
        counter_write = 0;
99
        counter_read  = 0;
100 12 redbear
        counter_wait  = 0;
101 4 redbear
        PACKETS_GENERATED = 0;
102
        counter = 0;
103
        reset_counter = 0;
104
        flag = 0;
105
 
106
        a = 0;
107
        b = 0;
108
        c = 0;
109
        d = 0;
110
 
111 9 redbear
        v_monitor.value.integer=0;
112
        v_monitor_catch.value.integer=0;
113 12 redbear
        A=B=C=D=E=F=G=H=I=J=L=M=N=O=0;
114 9 redbear
 
115
        for(counter_monitor=0;counter_monitor < 16;counter_monitor++)
116
        {
117
                INPUT_KEYR[counter_monitor] =0x00;
118
                OUTPUT_KEYR[counter_monitor]=0x00;
119
 
120
                INPUT_IVR[counter_monitor]  =0x00;
121
                OUTPUT_IVR[counter_monitor] =0x00;
122
 
123
                INPUT_TEXT[counter_monitor]=0x00;
124
                OUTPUT_TEXT[counter_monitor]=0x00;
125
        }
126
 
127
        counter_monitor=0;
128
        cycle_counter =0;
129
 
130 12 redbear
 
131
        /*
132
                ECB ERROR TEST CASES DEFINITIONS
133 4 redbear
        */
134 12 redbear
 
135
        vector_CR[0]= 1;     // ECB ENCRYPTION  REGISTER ERROR DATATYPE 0
136
        vector_CR[1]= 3;     // ECB ENCRYPTION  REGISTER ERROR DATATYPE 1
137
        vector_CR[2]= 5;     // ECB ENCRYPTION  REGISTER ERROR DATATYPE 2
138
        vector_CR[3]= 7;     // ECB ENCRYPTION  REGISTER ERROR DATATYPE 3
139 4 redbear
 
140 12 redbear
        vector_CR[4]= 1025;  // ECB ENCRYPTION INT_ERR DATATYPE 0
141
        vector_CR[5]= 1027;  // ECB ENCRYPTION INT_ERR DATATYPE 1
142
        vector_CR[6]= 1029;  // ECB ENCRYPTION INT_ERR DATATYPE 2
143
        vector_CR[7]= 1031;  // ECB ENCRYPTION INT_ERR DATATYPE 3
144 4 redbear
 
145 12 redbear
        vector_CR[8] = 6145;  // ECB ENCRYPTION DMA REGISTER ERROR DATATYPE 0
146
        vector_CR[9] = 6147;  // ECB ENCRYPTION DMA REGISTER ERROR DATATYPE 1
147
        vector_CR[10]= 6149;  // ECB ENCRYPTION DMA REGISTER ERROR DATATYPE 2
148
        vector_CR[11]= 6151;  // ECB ENCRYPTION DMA REGISTER ERROR DATATYPE 3
149
 
150
        vector_CR[12]= 7169;  // ECB ENCRYPTION DMA INT_ERR DATATYPE 0
151
        vector_CR[13]= 7171;  // ECB ENCRYPTION DMA INT_ERR DATATYPE 1
152
        vector_CR[14]= 7173;  // ECB ENCRYPTION DMA INT_ERR DATATYPE 2
153
        vector_CR[15]= 7175;  // ECB ENCRYPTION DMA INT_ERR DATATYPE 3
154
 
155
        vector_CR[16]= 513;   // ECB ENCRYPTION INT_CCF REGISTER ERROR DATATYPE 0
156
        vector_CR[17]= 515;   // ECB ENCRYPTION INT_CCF REGISTER ERROR DATATYPE 1
157
        vector_CR[18]= 517;   // ECB ENCRYPTION INT_CCF REGISTER ERROR DATATYPE 2
158
        vector_CR[19]= 519;   // ECB ENCRYPTION INT_CCF REGISTER ERROR DATATYPE 3
159
 
160
        vector_CR[20]= 1537;  // ECB ENCRYPTION INT_CCF INT_ERR DATATYPE 0
161
        vector_CR[21]= 1539;  // ECB ENCRYPTION INT_CCF INT_ERR DATATYPE 1
162
        vector_CR[22]= 1541;  // ECB ENCRYPTION INT_CCF INT_ERR DATATYPE 2
163
        vector_CR[23]= 1543;  // ECB ENCRYPTION INT_CCF INT_ERR DATATYPE 3
164
 
165
        vector_CR[24]= 17;    // ECB DECRYPTION REGISTER ERROR DATATYPE 0
166
        vector_CR[25]= 19;    // ECB DECRYPTION REGISTER ERROR DATATYPE 1
167
        vector_CR[26]= 21;    // ECB DECRYPTION REGISTER ERROR DATATYPE 2
168
        vector_CR[27]= 23;    // ECB DECRYPTION REGISTER ERROR DATATYPE 3
169
 
170
        vector_CR[28]= 1041;  // ECB DECRYPTION INT_ERR DATATYPE 0
171
        vector_CR[29]= 1043;  // ECB DECRYPTION INT_ERR DATATYPE 1
172
        vector_CR[30]= 1045;  // ECB DECRYPTION INT_ERR DATATYPE 2
173
        vector_CR[31]= 1047;  // ECB DECRYPTION INT_ERR DATATYPE 3
174
 
175
        vector_CR[32]= 6161;  // ECB DECRYPTION DMA REGISTER ERROR  DATATYPE 0
176
        vector_CR[33]= 6163;  // ECB DECRYPTION DMA REGISTER ERROR  DATATYPE 1
177
        vector_CR[34]= 6165;  // ECB DECRYPTION DMA REGISTER ERROR  DATATYPE 2
178
        vector_CR[35]= 6167;  // ECB DECRYPTION DMA REGISTER ERROR  DATATYPE 3
179
 
180
        vector_CR[36]= 7185;  // ECB DECRYPTION DMA INT_ERR  DATATYPE 0
181
        vector_CR[37]= 7187;  // ECB DECRYPTION DMA INT_ERR  DATATYPE 1
182
        vector_CR[38]= 7189;  // ECB DECRYPTION DMA INT_ERR  DATATYPE 2
183
        vector_CR[39]= 7191;  // ECB DECRYPTION DMA INT_ERR  DATATYPE 3
184
 
185
        vector_CR[40]= 529;   // ECB DECRYPTION INT CCF REGISTER ERROR DATATYPE 0
186
        vector_CR[41]= 531;   // ECB DECRYPTION INT CCF REGISTER ERROR DATATYPE 1
187
        vector_CR[42]= 533;   // ECB DECRYPTION INT CCF REGISTER ERROR DATATYPE 2
188
        vector_CR[43]= 535;   // ECB DECRYPTION INT CCF REGISTER ERROR DATATYPE 3
189
 
190
        vector_CR[44]= 1553;  // ECB DECRYPTION INT CCF INT_ERR DATATYPE 0
191
        vector_CR[45]= 1555;  // ECB DECRYPTION INT CCF INT_ERR DATATYPE 1
192
        vector_CR[46]= 1557;  // ECB DECRYPTION INT CCF INT_ERR DATATYPE 2
193
        vector_CR[47]= 1559;  // ECB DECRYPTION INT CCF INT_ERR DATATYPE 3
194
 
195
        vector_CR[48]= 25;    // ECB DECRYPTION DERIVATION REGISTER ERROR DATATYPE 0
196
        vector_CR[49]= 27;    // ECB DECRYPTION DERIVATION REGISTER ERROR DATATYPE 1
197
        vector_CR[50]= 29;    // ECB DECRYPTION DERIVATION REGISTER ERROR DATATYPE 2
198
        vector_CR[51]= 31;    // ECB DECRYPTION DERIVATION REGISTER ERROR DATATYPE 3
199
 
200
        vector_CR[52]= 1049;  // ECB DECRYPTION DERIVATION INT_ERR DATATYPE 0
201
        vector_CR[53]= 1051;  // ECB DECRYPTION DERIVATION INT_ERR DATATYPE 1
202
        vector_CR[54]= 1053;  // ECB DECRYPTION DERIVATION INT_ERR DATATYPE 2
203
        vector_CR[55]= 1055;  // ECB DECRYPTION DERIVATION INT_ERR DATATYPE 3
204
 
205
        vector_CR[56]= 6169;  // ECB DECRYPTION DERIVATION DMA REGISTER ERROR DATATYPE 0
206
        vector_CR[57]= 6171;  // ECB DECRYPTION DERIVATION DMA REGISTER ERROR DATATYPE 1
207
        vector_CR[58]= 6173;  // ECB DECRYPTION DERIVATION DMA REGISTER ERROR DATATYPE 2
208
        vector_CR[59]= 6175;  // ECB DECRYPTION DERIVATION DMA REGISTER ERROR DATATYPE 3
209
 
210
        vector_CR[60]= 7193;  // ECB DECRYPTION DERIVATION DMA INT_ERR DATATYPE 0
211
        vector_CR[61]= 7195;  // ECB DECRYPTION DERIVATION DMA INT_ERR DATATYPE 1
212
        vector_CR[62]= 7197;  // ECB DECRYPTION DERIVATION DMA INT_ERR DATATYPE 2
213
        vector_CR[63]= 7199;  // ECB DECRYPTION DERIVATION DMA INT_ERR DATATYPE 3
214
 
215
        vector_CR[64]= 537;   // ECB DECRYPTION DERIVATION INT CCF REGISTER ERROR DATATYPE 0
216
        vector_CR[65]= 539;   // ECB DECRYPTION DERIVATION INT CCF REGISTER ERROR DATATYPE 1
217
        vector_CR[66]= 541;   // ECB DECRYPTION DERIVATION INT CCF REGISTER ERROR DATATYPE 2
218
        vector_CR[67]= 543;   // ECB DECRYPTION DERIVATION INT CCF REGISTER ERROR DATATYPE 3
219
 
220
        vector_CR[68]= 1561;  // ECB DECRYPTION DERIVATION INT CCF INT_ERR DATATYPE 0
221
        vector_CR[69]= 1563;  // ECB DECRYPTION DERIVATION INT CCF INT_ERR DATATYPE 1
222
        vector_CR[70]= 1565;  // ECB DECRYPTION DERIVATION INT CCF INT_ERR DATATYPE 2
223
        vector_CR[71]= 1567;  // ECB DECRYPTION DERIVATION INT CCF INT_ERR DATATYPE 3
224
 
225
        vector_CR[72]= 9;     // ECB KEY GENERATION REGISTER ERROR 
226
        vector_CR[73]= 1033;  // ECB KEY GENERATION INT_ERR 
227
 
228
        vector_CR[74]= 6153;  // ECB KEY GENERATION DMA REGISTER ERROR 
229
        vector_CR[75]= 7177;  // ECB KEY GENERATION DMA INT_ERR 
230
 
231
        vector_CR[76]= 521;   // ECB DECRYPTION DERIVATION INT CCF REGISTER ERROR
232
        vector_CR[77]= 1545;  // ECB DECRYPTION DERIVATION INT CCF INT_ERR
233
 
234
 
235
        /*
236
                CBC ERROR TEST CASES DEFINITIONS
237
        */
238
 
239
        vector_CR[78]= 33;    // CBC ENCRYPTION  REGISTER ERROR DATATYPE 0
240
        vector_CR[79]= 35;    // CBC ENCRYPTION  REGISTER ERROR DATATYPE 1
241
        vector_CR[80]= 37;    // CBC ENCRYPTION  REGISTER ERROR DATATYPE 2
242
        vector_CR[81]= 39;    // CBC ENCRYPTION  REGISTER ERROR DATATYPE 3
243
 
244
        vector_CR[82]= 1057;  // CBC ENCRYPTION INT_ERR DATATYPE 0
245
        vector_CR[83]= 1059;  // CBC ENCRYPTION INT_ERR DATATYPE 1
246
        vector_CR[84]= 1061;  // CBC ENCRYPTION INT_ERR DATATYPE 2
247
        vector_CR[85]= 1063;  // CBC ENCRYPTION INT_ERR DATATYPE 3
248
 
249
        vector_CR[86]= 6177;  // CBC ENCRYPTION DMA REGISTER ERROR DATATYPE 0
250
        vector_CR[87]= 6179;  // CBC ENCRYPTION DMA REGISTER ERROR DATATYPE 1
251
        vector_CR[88]= 6181;  // CBC ENCRYPTION DMA REGISTER ERROR DATATYPE 2
252
        vector_CR[89]= 6183;  // CBC ENCRYPTION DMA REGISTER ERROR DATATYPE 3
253
 
254
        vector_CR[90]= 7201;  // CBC ENCRYPTION DMA INT_ERR DATATYPE 0
255
        vector_CR[91]= 7203;  // CBC ENCRYPTION DMA INT_ERR DATATYPE 1
256
        vector_CR[92]= 7205;  // CBC ENCRYPTION DMA INT_ERR DATATYPE 2
257
        vector_CR[92]= 7207;  // CBC ENCRYPTION DMA INT_ERR DATATYPE 3
258
 
259
        vector_CR[93]= 545;   // CBC ENCRYPTION INT_CCF REGISTER ERROR DATATYPE 0
260
        vector_CR[94]= 547;   // CBC ENCRYPTION INT_CCF REGISTER ERROR DATATYPE 1
261
        vector_CR[95]= 549;   // CBC ENCRYPTION INT_CCF REGISTER ERROR DATATYPE 2
262
        vector_CR[96]= 551;   // CBC ENCRYPTION INT_CCF REGISTER ERROR DATATYPE 3
263
 
264
        vector_CR[97]= 1569;  // CBC ENCRYPTION INT_CCF INT_ERR DATATYPE 0
265
        vector_CR[98]= 1571;  // CBC ENCRYPTION INT_CCF INT_ERR DATATYPE 1
266
        vector_CR[99]= 1573;  // CBC ENCRYPTION INT_CCF INT_ERR DATATYPE 2
267
        vector_CR[100]= 1575; // CBC ENCRYPTION INT_CCF INT_ERR DATATYPE 3
268
 
269
        vector_CR[101]= 49;   // CBC DECRYPTION REGISTER ERROR DATATYPE 0
270
        vector_CR[102]= 51;   // CBC DECRYPTION REGISTER ERROR DATATYPE 1
271
        vector_CR[103]= 53;   // CBC DECRYPTION REGISTER ERROR DATATYPE 2
272
        vector_CR[104]= 55;   // CBC DECRYPTION REGISTER ERROR DATATYPE 3
273
 
274
        vector_CR[105]= 1073; // CBC DECRYPTION INT_ERR DATATYPE 0
275
        vector_CR[106]= 1075; // CBC DECRYPTION INT_ERR DATATYPE 1
276
        vector_CR[107]= 1077; // CBC DECRYPTION INT_ERR DATATYPE 2
277
        vector_CR[108]= 1079; // CBC DECRYPTION INT_ERR DATATYPE 3
278
 
279
        vector_CR[109]= 6193; // CBC DECRYPTION DMA REGISTER ERROR  DATATYPE 0
280
        vector_CR[110]= 6195; // CBC DECRYPTION DMA REGISTER ERROR  DATATYPE 1
281
        vector_CR[111]= 6197; // CBC DECRYPTION DMA REGISTER ERROR  DATATYPE 2
282
        vector_CR[112]= 6199; // CBC DECRYPTION DMA REGISTER ERROR  DATATYPE 3
283
 
284
        vector_CR[113]= 7217; // CBC DECRYPTION DMA INT_ERR  DATATYPE 0
285
        vector_CR[114]= 7219; // CBC DECRYPTION DMA INT_ERR  DATATYPE 1
286
        vector_CR[115]= 7221; // CBC DECRYPTION DMA INT_ERR  DATATYPE 2
287
        vector_CR[116]= 7223; // CBC DECRYPTION DMA INT_ERR  DATATYPE 3
288
 
289
        vector_CR[117]= 561;  // CBC DECRYPTION INT CCF REGISTER ERROR DATATYPE 0
290
        vector_CR[118]= 563;  // CBC DECRYPTION INT CCF REGISTER ERROR DATATYPE 1
291
        vector_CR[119]= 565;  // CBC DECRYPTION INT CCF REGISTER ERROR DATATYPE 2
292
        vector_CR[120]= 567;  // CBC DECRYPTION INT CCF REGISTER ERROR DATATYPE 3
293
 
294
        vector_CR[121]= 1585; // CBC DECRYPTION INT CCF INT_ERR DATATYPE 0
295
        vector_CR[122]= 1587; // CBC DECRYPTION INT CCF INT_ERR DATATYPE 1
296
        vector_CR[123]= 1589; // CBC DECRYPTION INT CCF INT_ERR DATATYPE 2
297
        vector_CR[124]= 1591; // CBC DECRYPTION INT CCF INT_ERR DATATYPE 3
298
 
299
        vector_CR[125]= 57;   // CBC DECRYPTION DERIVATION REGISTER ERROR DATATYPE 0
300
        vector_CR[126]= 59;   // CBC DECRYPTION DERIVATION REGISTER ERROR DATATYPE 1
301
        vector_CR[127]= 61;   // CBC DECRYPTION DERIVATION REGISTER ERROR DATATYPE 2
302
        vector_CR[128]= 63;   // CBC DECRYPTION DERIVATION REGISTER ERROR DATATYPE 3
303
 
304
        vector_CR[129]= 1081; // CBC DECRYPTION DERIVATION INT_ERR DATATYPE 0
305
        vector_CR[130]= 1083; // CBC DECRYPTION DERIVATION INT_ERR DATATYPE 1
306
        vector_CR[131]= 1085; // CBC DECRYPTION DERIVATION INT_ERR DATATYPE 2
307
        vector_CR[132]= 1087; // CBC DECRYPTION DERIVATION INT_ERR DATATYPE 3
308
 
309
        vector_CR[133]= 6201; // CBC DECRYPTION DERIVATION DMA REGISTER ERROR DATATYPE 0
310
        vector_CR[134]= 6203; // CBC DECRYPTION DERIVATION DMA REGISTER ERROR DATATYPE 1
311
        vector_CR[135]= 6205; // CBC DECRYPTION DERIVATION DMA REGISTER ERROR DATATYPE 2
312
        vector_CR[136]= 6207; // CBC DECRYPTION DERIVATION DMA REGISTER ERROR DATATYPE 3
313
 
314
        vector_CR[137]= 7225; // CBC DECRYPTION DERIVATION DMA INT_ERR DATATYPE 0
315
        vector_CR[138]= 7227; // CBC DECRYPTION DERIVATION DMA INT_ERR DATATYPE 1
316
        vector_CR[139]= 7229; // CBC DECRYPTION DERIVATION DMA INT_ERR DATATYPE 2
317
        vector_CR[140]= 7231; // CBC DECRYPTION DERIVATION DMA INT_ERR DATATYPE 3
318
 
319
        vector_CR[141]= 569;  // CBC DECRYPTION DERIVATION INT CCF REGISTER ERROR DATATYPE 0
320
        vector_CR[142]= 571;  // CBC DECRYPTION DERIVATION INT CCF REGISTER ERROR DATATYPE 1
321
        vector_CR[143]= 573;  // CBC DECRYPTION DERIVATION INT CCF REGISTER ERROR DATATYPE 2
322
        vector_CR[144]= 575;  // CBC DECRYPTION DERIVATION INT CCF REGISTER ERROR DATATYPE 3
323
 
324
        vector_CR[145]= 1593; // CBC DECRYPTION DERIVATION INT CCF INT_ERR DATATYPE 0
325
        vector_CR[146]= 1595; // CBC DECRYPTION DERIVATION INT CCF INT_ERR DATATYPE 1
326
        vector_CR[147]= 1597; // CBC DECRYPTION DERIVATION INT CCF INT_ERR DATATYPE 2
327
        vector_CR[148]= 1599; // CBC DECRYPTION DERIVATION INT CCF INT_ERR DATATYPE 3
328
 
329
        vector_CR[149]= 41;   // CBC KEY GENERATION REGISTER ERROR 
330
        vector_CR[150]= 1065; // CBC KEY GENERATION INT_ERR 
331
 
332
        vector_CR[151]= 6185; // CBC KEY GENERATION DMA REGISTER ERROR 
333
        vector_CR[152]= 7209; // CBC KEY GENERATION DMA INT_ERR 
334
 
335
        vector_CR[153]= 553;  // CBC DECRYPTION DERIVATION INT CCF REGISTER ERROR
336
        vector_CR[154]= 1577; // CBC DECRYPTION DERIVATION INT CCF INT_ERR
337
 
338
 
339
        /*
340
                CTR ERROR TEST CASES DEFINITIONS
341
        */
342
 
343
        vector_CR[155]= 65;   // CTR ENCRYPTION  REGISTER ERROR DATATYPE 0
344
        vector_CR[156]= 67;   // CTR ENCRYPTION  REGISTER ERROR DATATYPE 1
345
        vector_CR[157]= 69;   // CTR ENCRYPTION  REGISTER ERROR DATATYPE 2
346
        vector_CR[158]= 71;   // CTR ENCRYPTION  REGISTER ERROR DATATYPE 3
347
 
348
        vector_CR[159]= 1089; // CTR ENCRYPTION INT_ERR DATATYPE 0
349
        vector_CR[160]= 1091; // CTR ENCRYPTION INT_ERR DATATYPE 1
350
        vector_CR[161]= 1093; // CTR ENCRYPTION INT_ERR DATATYPE 2
351
        vector_CR[162]= 1095; // CTR ENCRYPTION INT_ERR DATATYPE 3
352
 
353
        vector_CR[163]= 6209; // CTR ENCRYPTION DMA REGISTER ERROR DATATYPE 0
354
        vector_CR[164]= 6211; // CTR ENCRYPTION DMA REGISTER ERROR DATATYPE 1
355
        vector_CR[165]= 6213; // CTR ENCRYPTION DMA REGISTER ERROR DATATYPE 2
356
        vector_CR[166]= 6215; // CTR ENCRYPTION DMA REGISTER ERROR DATATYPE 3
357
 
358
        vector_CR[167]= 7233; // CTR ENCRYPTION DMA INT_ERR DATATYPE 0
359
        vector_CR[168]= 7235; // CTR ENCRYPTION DMA INT_ERR DATATYPE 1
360
        vector_CR[169]= 7237; // CTR ENCRYPTION DMA INT_ERR DATATYPE 2
361
        vector_CR[170]= 7239; // CTR ENCRYPTION DMA INT_ERR DATATYPE 3
362
 
363
        vector_CR[171]= 577;  // CTR ENCRYPTION INT_CCF REGISTER ERROR DATATYPE 0
364
        vector_CR[172]= 579;  // CTR ENCRYPTION INT_CCF REGISTER ERROR DATATYPE 1
365
        vector_CR[173]= 581;  // CTR ENCRYPTION INT_CCF REGISTER ERROR DATATYPE 2
366
        vector_CR[174]= 583;  // CTR ENCRYPTION INT_CCF REGISTER ERROR DATATYPE 3
367
 
368
        vector_CR[175]= 1601; // CTR ENCRYPTION INT_CCF INT_ERR DATATYPE 0
369
        vector_CR[176]= 1603; // CTR ENCRYPTION INT_CCF INT_ERR DATATYPE 1
370
        vector_CR[177]= 1605; // CTR ENCRYPTION INT_CCF INT_ERR DATATYPE 2
371
        vector_CR[178]= 1607; // CTR ENCRYPTION INT_CCF INT_ERR DATATYPE 3
372
 
373
        vector_CR[179]= 81;   // CTR DECRYPTION REGISTER ERROR DATATYPE 0
374
        vector_CR[180]= 83;   // CTR DECRYPTION REGISTER ERROR DATATYPE 1
375
        vector_CR[181]= 85;   // CTR DECRYPTION REGISTER ERROR DATATYPE 2
376
        vector_CR[182]= 87;   // CTR DECRYPTION REGISTER ERROR DATATYPE 3
377
 
378
        vector_CR[183]= 1105; // CTR DECRYPTION INT_ERR DATATYPE 0
379
        vector_CR[184]= 1107; // CTR DECRYPTION INT_ERR DATATYPE 1
380
        vector_CR[185]= 1109; // CTR DECRYPTION INT_ERR DATATYPE 2
381
        vector_CR[186]= 1111; // CTR DECRYPTION INT_ERR DATATYPE 3
382
 
383
        vector_CR[187]= 6225; // CTR DECRYPTION DMA REGISTER ERROR  DATATYPE 0
384
        vector_CR[188]= 6227; // CTR DECRYPTION DMA REGISTER ERROR  DATATYPE 1
385
        vector_CR[189]= 6229; // CTR DECRYPTION DMA REGISTER ERROR  DATATYPE 2
386
        vector_CR[190]= 6231; // CTR DECRYPTION DMA REGISTER ERROR  DATATYPE 3
387
 
388
        vector_CR[191]= 7249; // CTR DECRYPTION DMA INT_ERR  DATATYPE 0
389
        vector_CR[192]= 7251; // CTR DECRYPTION DMA INT_ERR  DATATYPE 1
390
        vector_CR[193]= 7253; // CTR DECRYPTION DMA INT_ERR  DATATYPE 2
391
        vector_CR[194]= 7255; // CTR DECRYPTION DMA INT_ERR  DATATYPE 3
392
 
393
        vector_CR[195]= 593;  // CTR DECRYPTION INT CCF REGISTER ERROR DATATYPE 0
394
        vector_CR[196]= 595;  // CTR DECRYPTION INT CCF REGISTER ERROR DATATYPE 1
395
        vector_CR[197]= 597;  // CTR DECRYPTION INT CCF REGISTER ERROR DATATYPE 2
396
        vector_CR[198]= 599;  // CTR DECRYPTION INT CCF REGISTER ERROR DATATYPE 3
397
 
398
        vector_CR[199]= 1617; // CTR DECRYPTION INT CCF INT_ERR DATATYPE 0
399
        vector_CR[200]= 1619; // CTR DECRYPTION INT CCF INT_ERR DATATYPE 1
400
        vector_CR[201]= 1621; // CTR DECRYPTION INT CCF INT_ERR DATATYPE 2
401
        vector_CR[202]= 1623; // CTR DECRYPTION INT CCF INT_ERR DATATYPE 3
402
 
403
        vector_CR[203]= 89;   // CTR DECRYPTION DERIVATION REGISTER ERROR DATATYPE 0
404
        vector_CR[204]= 91;   // CTR DECRYPTION DERIVATION REGISTER ERROR DATATYPE 1
405
        vector_CR[205]= 93;   // CTR DECRYPTION DERIVATION REGISTER ERROR DATATYPE 2
406
        vector_CR[206]= 95;   // CTR DECRYPTION DERIVATION REGISTER ERROR DATATYPE 3
407
 
408
        vector_CR[207]= 1113; // CTR DECRYPTION DERIVATION INT_ERR DATATYPE 0
409
        vector_CR[208]= 1115; // CTR DECRYPTION DERIVATION INT_ERR DATATYPE 1
410
        vector_CR[209]= 1117; // CTR DECRYPTION DERIVATION INT_ERR DATATYPE 2
411
        vector_CR[210]= 1119; // CTR DECRYPTION DERIVATION INT_ERR DATATYPE 3
412
 
413
        vector_CR[211]= 6233; // CTR DECRYPTION DERIVATION DMA REGISTER ERROR DATATYPE 0
414
        vector_CR[212]= 6235; // CTR DECRYPTION DERIVATION DMA REGISTER ERROR DATATYPE 1
415
        vector_CR[213]= 6237; // CTR DECRYPTION DERIVATION DMA REGISTER ERROR DATATYPE 2
416
        vector_CR[214]= 6239; // CTR DECRYPTION DERIVATION DMA REGISTER ERROR DATATYPE 3
417
 
418
        vector_CR[215]= 7257; // CTR DECRYPTION DERIVATION DMA INT_ERR DATATYPE 0
419
        vector_CR[216]= 7259; // CTR DECRYPTION DERIVATION DMA INT_ERR DATATYPE 1
420
        vector_CR[217]= 7261; // CTR DECRYPTION DERIVATION DMA INT_ERR DATATYPE 2
421
        vector_CR[218]= 7263; // CTR DECRYPTION DERIVATION DMA INT_ERR DATATYPE 3
422
 
423
        vector_CR[219]= 601;  // CTR DECRYPTION DERIVATION INT CCF REGISTER ERROR DATATYPE 0
424
        vector_CR[220]= 603;  // CTR DECRYPTION DERIVATION INT CCF REGISTER ERROR DATATYPE 1
425
        vector_CR[221]= 605;  // CTR DECRYPTION DERIVATION INT CCF REGISTER ERROR DATATYPE 2
426
        vector_CR[222]= 607;  // CTR DECRYPTION DERIVATION INT CCF REGISTER ERROR DATATYPE 3
427
 
428
        vector_CR[223]= 1625; // CTR DECRYPTION DERIVATION INT CCF INT_ERR DATATYPE 0
429
        vector_CR[224]= 1627; // CTR DECRYPTION DERIVATION INT CCF INT_ERR DATATYPE 1
430
        vector_CR[225]= 1629; // CTR DECRYPTION DERIVATION INT CCF INT_ERR DATATYPE 2
431
        vector_CR[226]= 1631; // CTR DECRYPTION DERIVATION INT CCF INT_ERR DATATYPE 3
432
 
433
        vector_CR[227]= 73;   // CTR KEY GENERATION REGISTER ERROR 
434
        vector_CR[228]= 1097; // CTR KEY GENERATION INT_ERR 
435
 
436
        vector_CR[229]= 6185; // CTR KEY GENERATION DMA REGISTER ERROR 
437
        vector_CR[230]= 7209; // CTR KEY GENERATION DMA INT_ERR 
438
 
439
        vector_CR[231]= 553;  // CTR DECRYPTION DERIVATION INT CCF REGISTER ERROR
440
        vector_CR[232]= 1577; // CTR DECRYPTION DERIVATION INT CCF INT_ERR
441
 
442
        /*
443
                ADDR CASES DEFINITIONS
444
        */
445
 
446 4 redbear
        vector_address[0]= ADDR_AES_CR;
447 9 redbear
        vector_address[1]= ADDR_AES_KEYR3;
448
        vector_address[2]= ADDR_AES_KEYR2;
449
        vector_address[3]= ADDR_AES_KEYR1;
450
        vector_address[4]= ADDR_AES_KEYR0;
451 4 redbear
        vector_address[5]= ADDR_AES_IVR3;
452
        vector_address[6]= ADDR_AES_IVR2;
453
        vector_address[7]= ADDR_AES_IVR1;
454
        vector_address[8]= ADDR_AES_IVR0;
455 12 redbear
        vector_address[9]= ADDR_AES_SR;
456 4 redbear
 
457
 
458 12 redbear
 
459 4 redbear
        v_initial.format=vpiIntVal;
460
 
461
        v_initial.value.integer = 0;
462
        vpi_put_value(PENABLE, &v_initial, NULL, vpiNoDelay);
463
        vpi_put_value(PSEL , &v_initial, NULL, vpiNoDelay);
464
        vpi_put_value(PADDR, &v_initial, NULL, vpiNoDelay);
465
        vpi_put_value(i, &v_initial, NULL, vpiNoDelay);
466
        vpi_put_value(PWRITE, &v_initial, NULL, vpiNoDelay);
467
        vpi_put_value(PWDATA, &v_initial, NULL, vpiNoDelay);
468
 
469
 
470
 
471
        return 0;
472
}

powered by: WebSVN 2.1.0

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