diff options
author | Brad Griffis | 2017-01-19 15:16:29 -0600 |
---|---|---|
committer | Brad Griffis | 2017-01-19 15:16:29 -0600 |
commit | 5b8f2da36b480131b6e61b5df70916cc128c5dd1 (patch) | |
tree | 3fc0970513f814bccb6512ec2057a59f604b0a16 | |
download | am57xx-dss-files-5b8f2da36b480131b6e61b5df70916cc128c5dd1.tar.gz am57xx-dss-files-5b8f2da36b480131b6e61b5df70916cc128c5dd1.tar.xz am57xx-dss-files-5b8f2da36b480131b6e61b5df70916cc128c5dd1.zip |
Initial commit
-rwxr-xr-x | am57xx-ipu-mmu-analysis.dss | 421 |
1 files changed, 421 insertions, 0 deletions
diff --git a/am57xx-ipu-mmu-analysis.dss b/am57xx-ipu-mmu-analysis.dss new file mode 100755 index 0000000..c9ddb18 --- /dev/null +++ b/am57xx-ipu-mmu-analysis.dss | |||
@@ -0,0 +1,421 @@ | |||
1 | /* | ||
2 | * Copyright (c) 2006-2014, Texas Instruments Incorporated | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * | ||
9 | * * Redistributions of source code must retain the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer. | ||
11 | * | ||
12 | * * Redistributions in binary form must reproduce the above copyright | ||
13 | * notice, this list of conditions and the following disclaimer in the | ||
14 | * documentation and/or other materials provided with the distribution. | ||
15 | * | ||
16 | * * Neither the name of Texas Instruments Incorporated nor the names of | ||
17 | * its contributors may be used to endorse or promote products derived | ||
18 | * from this software without specific prior written permission. | ||
19 | * | ||
20 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | ||
21 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, | ||
22 | * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | ||
23 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR | ||
24 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | ||
25 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | ||
26 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; | ||
27 | * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, | ||
28 | * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR | ||
29 | * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, | ||
30 | * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
31 | * | ||
32 | */ | ||
33 | |||
34 | function d2h(d) {return ("00000000" + (d).toString(16)).slice(-8);} | ||
35 | |||
36 | var newline = "\n"; | ||
37 | |||
38 | function printRegisterValue(ds, name, addr) | ||
39 | { | ||
40 | value = debugSessionDAP.memory.readWord(0,addr,false); | ||
41 | value_string = d2h(value); | ||
42 | file.write(name + " = 0x" + value_string + newline); | ||
43 | return value; // return the register value for interrogation | ||
44 | } | ||
45 | |||
46 | // Build a filename that includes date/time | ||
47 | var today = new Date(); | ||
48 | var year4digit = today.getFullYear(); | ||
49 | var month2digit = ("0" + (today.getMonth()+1)).slice(-2); | ||
50 | var day2digit = ("0" + today.getDate()).slice(-2); | ||
51 | var hour2digit = ("0" + today.getHours()).slice(-2); | ||
52 | var minutes2digit = ("0" + today.getMinutes()).slice(-2); | ||
53 | var seconds2digit = ("0" + today.getSeconds()).slice(-2); | ||
54 | var filename_date = '_' + year4digit + '-' + month2digit + '-' + day2digit + '_' + hour2digit + minutes2digit + seconds2digit; | ||
55 | var userHomeFolder = System.getProperty("user.home"); | ||
56 | var filename = userHomeFolder + '/Desktop/' + 'am57xx-ipu-mmu-analysis' + filename_date + '.txt'; | ||
57 | |||
58 | debugSessionDAP = ds.openSession("*","CS_DAP_DebugSS"); | ||
59 | |||
60 | try { | ||
61 | debugSessionDAP.target.connect(); | ||
62 | } catch (ex) { | ||
63 | print(newline + " ERROR: Could not connect to DAP_DebugSS." + newline); | ||
64 | } | ||
65 | |||
66 | file = new java.io.FileWriter(filename); | ||
67 | |||
68 | |||
69 | var reg_val; | ||
70 | |||
71 | reg_val = printRegisterValue(debugSessionDAP, "CM_IPU1_IPU1_CLKCTRL", 0x4A005520); | ||
72 | if ( (reg_val & 0x30000) == 0<<16 ) { file.write(" * IPU1 is fully functional." + newline); } | ||
73 | if ( (reg_val & 0x30000) == (1<<16) ) { file.write(" * IPU1 is transitioning." + newline); } | ||
74 | if ( (reg_val & 0x30000) == 2<<16 ) { file.write(" * IPU1 is in idle." + newline); } | ||
75 | if ( (reg_val & 0x30000) == 3<<16 ) { file.write(" * IPU1 is disabled." + newline); } | ||
76 | |||
77 | decodeLargePages(debugSessionDAP, 0x58880800); | ||
78 | decodeMediumPages(debugSessionDAP, 0x58880860); | ||
79 | decodeSmallPages(debugSessionDAP, 0x58880920); | ||
80 | |||
81 | function decodeLargePages(ds, addr) | ||
82 | { | ||
83 | |||
84 | decodeLargePage(ds, addr, 0); | ||
85 | decodeLargePage(ds, addr, 1); | ||
86 | decodeLargePage(ds, addr, 2); | ||
87 | decodeLargePage(ds, addr, 3); | ||
88 | } | ||
89 | |||
90 | function decodeMediumPages(ds, addr) | ||
91 | { | ||
92 | |||
93 | decodeMediumPage(ds, addr, 0); | ||
94 | decodeMediumPage(ds, addr, 1); | ||
95 | } | ||
96 | |||
97 | function decodeSmallPages(ds, addr) | ||
98 | { | ||
99 | decodeSmallPage(ds, addr, 0); | ||
100 | decodeSmallPage(ds, addr, 1); | ||
101 | decodeSmallPage(ds, addr, 2); | ||
102 | decodeSmallPage(ds, addr, 3); | ||
103 | decodeSmallPage(ds, addr, 4); | ||
104 | decodeSmallPage(ds, addr, 5); | ||
105 | decodeSmallPage(ds, addr, 6); | ||
106 | decodeSmallPage(ds, addr, 7); | ||
107 | decodeSmallPage(ds, addr, 8); | ||
108 | decodeSmallPage(ds, addr, 9); | ||
109 | } | ||
110 | |||
111 | |||
112 | |||
113 | function decodeLargePage(ds, addr, page) | ||
114 | { | ||
115 | var phys_addr, logical_addr, policy_reg, size; | ||
116 | |||
117 | file.write(newline + "***** Decoding Large Page " + page + " *****" + newline + newline); | ||
118 | var reg_name = "CACHE_MMU_LARGE_ADDR_" + page; | ||
119 | logical_addr = printRegisterValue(ds, reg_name, addr+page*4); | ||
120 | |||
121 | addr = addr + 0x20; | ||
122 | reg_name = "CACHE_MMU_LARGE_XLTE_" + page; | ||
123 | physical_addr = printRegisterValue(ds, reg_name, addr+page*4); | ||
124 | |||
125 | addr = addr + 0x20; | ||
126 | reg_name = "CACHE_MMU_LARGE_POLICY_" + page; | ||
127 | policy = printRegisterValue(ds, reg_name, addr+page*4); | ||
128 | |||
129 | file.write(newline); | ||
130 | |||
131 | if( (policy&1) == 0 ) { | ||
132 | file.write("PAGE NOT ENABLED" + newline); | ||
133 | } else { | ||
134 | file.write("PAGE ENABLED" + newline); | ||
135 | |||
136 | file.write("Logical Address = 0x" + d2h(logical_addr) + " - 0x"); | ||
137 | if( (policy & 1<<1) == 1<<1 ) { | ||
138 | size = 512 * 1024 * 1024; // 512 MB | ||
139 | } else { | ||
140 | size = 32 * 1024 * 1024; // 32MB | ||
141 | } | ||
142 | file.write(d2h(logical_addr+size-1) + newline); | ||
143 | |||
144 | if ( (physical_addr&1) == 1 ) { // "ignore" bit | ||
145 | physical_addr = logical_addr; | ||
146 | } | ||
147 | file.write("Physical address = 0x" + d2h(physical_addr) + " - 0x"); | ||
148 | file.write(d2h(physical_addr+size-1) + newline); | ||
149 | |||
150 | file.write("Policy" + newline); | ||
151 | |||
152 | if( (policy & 1<<19) == 1<<19 ) { | ||
153 | file.write(" * L1 write policy is writeback" + newline); | ||
154 | } else { | ||
155 | file.write(" * L1 write policy is writethrough" + newline); | ||
156 | } | ||
157 | |||
158 | if( (policy & 1<<18) == 1<<18 ) { | ||
159 | file.write(" * L1 allocate policy: follow sideband" + newline); | ||
160 | } else { | ||
161 | file.write(" * L1 allocate policy: no writes allocated" + newline); | ||
162 | } | ||
163 | |||
164 | if( (policy & 1<<17) == 1<<17 ) { | ||
165 | file.write(" * L1 writes posted" + newline); | ||
166 | } else { | ||
167 | file.write(" * L1 writes non-posted" + newline); | ||
168 | } | ||
169 | |||
170 | if( (policy & 1<<16) == 1<<16 ) { | ||
171 | file.write(" * L1 cacheable" + newline); | ||
172 | } else { | ||
173 | file.write(" * L1 noncacheable" + newline); | ||
174 | } | ||
175 | |||
176 | if( (policy & 1<<7) == 1<<7 ) { | ||
177 | file.write(" * Send cache exclusion sideband" + newline); | ||
178 | } else { | ||
179 | file.write(" * Do not send cache exclusion sideband" + newline); | ||
180 | } | ||
181 | |||
182 | if( (policy & 1<<6) == 1<<6 ) { | ||
183 | file.write(" * Preload enabled" + newline); | ||
184 | } else { | ||
185 | file.write(" * Preload disabled" + newline); | ||
186 | } | ||
187 | |||
188 | if( (policy & 1<<5) == 1<<5 ) { | ||
189 | file.write(" * Read-only" + newline); | ||
190 | } else { | ||
191 | file.write(" * Read/Write" + newline); | ||
192 | } | ||
193 | |||
194 | if( (policy & 1<<4) == 1<<4 ) { | ||
195 | file.write(" * Execute-only" + newline); | ||
196 | } else { | ||
197 | file.write(" * Read/Write/Execute" + newline); | ||
198 | } | ||
199 | |||
200 | if( (policy & 1<<3) == 1<<3 ) { | ||
201 | file.write(" * Follow volatile qualifier" + newline); | ||
202 | } else { | ||
203 | file.write(" * Do not follow volatile qualifier" + newline); | ||
204 | } | ||
205 | |||
206 | if( (policy & 1<<1) == 1<<1 ) { | ||
207 | file.write(" * 512 MB page" + newline); | ||
208 | } else { | ||
209 | file.write(" * 32 MB page" + newline); | ||
210 | } | ||
211 | } | ||
212 | } | ||
213 | |||
214 | |||
215 | function decodeMediumPage(ds, addr, page) | ||
216 | { | ||
217 | var phys_addr, logical_addr, policy_reg, size; | ||
218 | |||
219 | file.write(newline + "***** Decoding Medium Page " + page + " *****" + newline + newline); | ||
220 | var reg_name = "CACHE_MMU_MED_ADDR_" + page; | ||
221 | logical_addr = printRegisterValue(ds, reg_name, addr+page*4); | ||
222 | |||
223 | addr = addr + 0x40; | ||
224 | reg_name = "CACHE_MMU_MED_XLTE_" + page; | ||
225 | physical_addr = printRegisterValue(ds, reg_name, addr+page*4); | ||
226 | |||
227 | addr = addr + 0x40; | ||
228 | reg_name = "CACHE_MMU_MED_POLICY_" + page; | ||
229 | policy = printRegisterValue(ds, reg_name, addr+page*4); | ||
230 | |||
231 | file.write(newline); | ||
232 | |||
233 | if( (policy&1) == 0 ) { | ||
234 | file.write("PAGE NOT ENABLED" + newline); | ||
235 | } else { | ||
236 | file.write("PAGE ENABLED" + newline); | ||
237 | |||
238 | file.write("Logical Address = 0x" + d2h(logical_addr) + " - 0x"); | ||
239 | if( (policy & 1<<1) == 1<<1 ) { | ||
240 | size = 256 * 1024; // 256 KB | ||
241 | } else { | ||
242 | size = 128 * 1024; // 128 KB | ||
243 | } | ||
244 | file.write(d2h(logical_addr+size-1) + newline); | ||
245 | |||
246 | if ( (physical_addr&1) == 1 ) { // "ignore" bit | ||
247 | physical_addr = logical_addr; | ||
248 | } | ||
249 | file.write("Physical address = 0x" + d2h(physical_addr) + " - 0x"); | ||
250 | file.write(d2h(physical_addr+size-1) + newline); | ||
251 | |||
252 | file.write("Policy" + newline); | ||
253 | |||
254 | if( (policy & 1<<19) == 1<<19 ) { | ||
255 | file.write(" * L1 write policy is writeback" + newline); | ||
256 | } else { | ||
257 | file.write(" * L1 write policy is writethrough" + newline); | ||
258 | } | ||
259 | |||
260 | if( (policy & 1<<18) == 1<<18 ) { | ||
261 | file.write(" * L1 allocate policy: follow sideband" + newline); | ||
262 | } else { | ||
263 | file.write(" * L1 allocate policy: no writes allocated" + newline); | ||
264 | } | ||
265 | |||
266 | if( (policy & 1<<17) == 1<<17 ) { | ||
267 | file.write(" * L1 writes posted" + newline); | ||
268 | } else { | ||
269 | file.write(" * L1 writes non-posted" + newline); | ||
270 | } | ||
271 | |||
272 | if( (policy & 1<<16) == 1<<16 ) { | ||
273 | file.write(" * L1 cacheable" + newline); | ||
274 | } else { | ||
275 | file.write(" * L1 noncacheable" + newline); | ||
276 | } | ||
277 | |||
278 | if( (policy & 1<<7) == 1<<7 ) { | ||
279 | file.write(" * Send cache exclusion sideband" + newline); | ||
280 | } else { | ||
281 | file.write(" * Do not send cache exclusion sideband" + newline); | ||
282 | } | ||
283 | |||
284 | if( (policy & 1<<6) == 1<<6 ) { | ||
285 | file.write(" * Preload enabled" + newline); | ||
286 | } else { | ||
287 | file.write(" * Preload disabled" + newline); | ||
288 | } | ||
289 | |||
290 | if( (policy & 1<<5) == 1<<5 ) { | ||
291 | file.write(" * Read-only" + newline); | ||
292 | } else { | ||
293 | file.write(" * Read/Write" + newline); | ||
294 | } | ||
295 | |||
296 | if( (policy & 1<<4) == 1<<4 ) { | ||
297 | file.write(" * Execute-only" + newline); | ||
298 | } else { | ||
299 | file.write(" * Read/Write/Execute" + newline); | ||
300 | } | ||
301 | |||
302 | if( (policy & 1<<3) == 1<<3 ) { | ||
303 | file.write(" * Follow volatile qualifier" + newline); | ||
304 | } else { | ||
305 | file.write(" * Do not follow volatile qualifier" + newline); | ||
306 | } | ||
307 | |||
308 | if( (policy & 1<<1) == 1<<1 ) { | ||
309 | file.write(" * 256 KB page" + newline); | ||
310 | } else { | ||
311 | file.write(" * 128 KB page" + newline); | ||
312 | } | ||
313 | } | ||
314 | } | ||
315 | |||
316 | function decodeSmallPage(ds, addr, page) | ||
317 | { | ||
318 | var phys_addr, logical_addr, policy_reg, size; | ||
319 | |||
320 | file.write(newline + "***** Decoding Small Page " + page + " *****" + newline + newline); | ||
321 | var reg_name = "CACHE_MMU_SMALL_ADDR_" + page; | ||
322 | logical_addr = printRegisterValue(ds, reg_name, addr+page*4); | ||
323 | |||
324 | addr = addr + 0x80; | ||
325 | reg_name = "CACHE_MMU_SMALL_XLTE_" + page; | ||
326 | physical_addr = printRegisterValue(ds, reg_name, addr+page*4); | ||
327 | |||
328 | addr = addr + 0x80; | ||
329 | reg_name = "CACHE_MMU_SMALL_POLICY_" + page; | ||
330 | policy = printRegisterValue(ds, reg_name, addr+page*4); | ||
331 | |||
332 | file.write(newline); | ||
333 | |||
334 | if( (policy&1) == 0 ) { | ||
335 | file.write("PAGE NOT ENABLED" + newline); | ||
336 | } else { | ||
337 | file.write("PAGE ENABLED" + newline); | ||
338 | |||
339 | file.write("Logical Address = 0x" + d2h(logical_addr) + " - 0x"); | ||
340 | if( (policy & 1<<1) == 1<<1 ) { | ||
341 | size = 16 * 1024; // 16 KB | ||
342 | } else { | ||
343 | size = 4 * 1024; // 4 KB | ||
344 | } | ||
345 | file.write(d2h(logical_addr+size-1) + newline); | ||
346 | |||
347 | if ( (physical_addr&1) == 1 ) { // "ignore" bit | ||
348 | physical_addr = logical_addr; | ||
349 | } | ||
350 | file.write("Physical address = 0x" + d2h(physical_addr) + " - 0x"); | ||
351 | file.write(d2h(physical_addr+size-1) + newline); | ||
352 | |||
353 | file.write("Policy" + newline); | ||
354 | |||
355 | if( (policy & 1<<19) == 1<<19 ) { | ||
356 | file.write(" * L1 write policy is writeback" + newline); | ||
357 | } else { | ||
358 | file.write(" * L1 write policy is writethrough" + newline); | ||
359 | } | ||
360 | |||
361 | if( (policy & 1<<18) == 1<<18 ) { | ||
362 | file.write(" * L1 allocate policy: follow sideband" + newline); | ||
363 | } else { | ||
364 | file.write(" * L1 allocate policy: no writes allocated" + newline); | ||
365 | } | ||
366 | |||
367 | if( (policy & 1<<17) == 1<<17 ) { | ||
368 | file.write(" * L1 writes posted" + newline); | ||
369 | } else { | ||
370 | file.write(" * L1 writes non-posted" + newline); | ||
371 | } | ||
372 | |||
373 | if( (policy & 1<<16) == 1<<16 ) { | ||
374 | file.write(" * L1 cacheable" + newline); | ||
375 | } else { | ||
376 | file.write(" * L1 noncacheable" + newline); | ||
377 | } | ||
378 | |||
379 | if( (policy & 1<<7) == 1<<7 ) { | ||
380 | file.write(" * Send cache exclusion sideband" + newline); | ||
381 | } else { | ||
382 | file.write(" * Do not send cache exclusion sideband" + newline); | ||
383 | } | ||
384 | |||
385 | if( (policy & 1<<6) == 1<<6 ) { | ||
386 | file.write(" * Preload enabled" + newline); | ||
387 | } else { | ||
388 | file.write(" * Preload disabled" + newline); | ||
389 | } | ||
390 | |||
391 | if( (policy & 1<<5) == 1<<5 ) { | ||
392 | file.write(" * Read-only" + newline); | ||
393 | } else { | ||
394 | file.write(" * Read/Write" + newline); | ||
395 | } | ||
396 | |||
397 | if( (policy & 1<<4) == 1<<4 ) { | ||
398 | file.write(" * Execute-only" + newline); | ||
399 | } else { | ||
400 | file.write(" * Read/Write/Execute" + newline); | ||
401 | } | ||
402 | |||
403 | if( (policy & 1<<3) == 1<<3 ) { | ||
404 | file.write(" * Follow volatile qualifier" + newline); | ||
405 | } else { | ||
406 | file.write(" * Do not follow volatile qualifier" + newline); | ||
407 | } | ||
408 | |||
409 | if( (policy & 1<<1) == 1<<1 ) { | ||
410 | file.write(" * 16 KB page" + newline); | ||
411 | } else { | ||
412 | file.write(" * 4 KB page" + newline); | ||
413 | } | ||
414 | } | ||
415 | } | ||
416 | |||
417 | |||
418 | file.close(); | ||
419 | print("Created file " + filename); | ||
420 | debugSessionDAP.target.disconnect(); | ||
421 | |||