1 /**
2 * \ingroup MODULHAL
3 *
4 * \file edt.h
5 *
6 * \brief <FILEBRIEF>
7 *
8 */
9 /*
10 * Copyright (C) 2012 Texas Instruments Incorporated - http://www.ti.com/
11 *
12 *
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions
15 * are met:
16 *
17 * Redistributions of source code must retain the above copyright
18 * notice, this list of conditions and the following disclaimer.
19 *
20 * Redistributions in binary form must reproduce the above copyright
21 * notice, this list of conditions and the following disclaimer in the
22 * documentation and/or other materials provided with the
23 * distribution.
24 *
25 * Neither the name of Texas Instruments Incorporated nor the names of
26 * its contributors may be used to endorse or promote products derived
27 * from this software without specific prior written permission.
28 *
29 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
30 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
31 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
32 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
33 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
34 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
35 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
36 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
37 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
38 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
39 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
40 */
41
42 #ifndef _EDT_H_
43 #define _EDT_H_
44 #include "JTAG_defs.h"
45 #include "hil_Structs.h"
46 #include "hal.h"
47
48 typedef void (*HilInitFunc)();
49 typedef void (*HilInitGetEdtCommenFunc)(edt_common_methods_t* edt_commen);
50 typedef void (*HilInitGetEdtDistinctFunc)(edt_distinct_methods_t* edt_distinct);
51
52 extern edt_common_methods_t _edt_Common_Methods;
53 extern edt_distinct_methods_t _edt_Distinct_Methods;
54
55 extern unsigned short altRomAddressForCpuRead;
56 extern unsigned short wdtctlAddress5xx;
57 extern DevicePowerSettings devicePowerSettings;
58
59 // Hil common methods
60 #pragma inline=forced
IHIL_Init(void)61 short IHIL_Init(void) { return _edt_Common_Methods.Init();}
62
63 #pragma inline=forced
IHIL_SetVcc(unsigned short vcc)64 short IHIL_SetVcc(unsigned short vcc){ return _edt_Common_Methods.SetVcc(vcc); }
65
66 #pragma inline=forced
IHIL_SwitchVccFET(unsigned short switchVccFET)67 void IHIL_SwitchVccFET(unsigned short switchVccFET){ _edt_Common_Methods.SwitchVccFET(switchVccFET);}
68
69 #pragma inline=forced
IHIL_GetVcc(double * Vcc,double * ExtVcc)70 short IHIL_GetVcc(double* Vcc, double* ExtVcc){ return _edt_Common_Methods.GetVcc(Vcc, ExtVcc);}
71
72 #pragma inline=forced
IHIL_SetProtocol(unsigned short protocol_id)73 short IHIL_SetProtocol(unsigned short protocol_id){ return _edt_Common_Methods.SetProtocol(protocol_id);}
74
75 #pragma inline=forced
IHIL_SetPsaTCLK(unsigned short tclkValue)76 void IHIL_SetPsaTCLK(unsigned short tclkValue){_edt_Common_Methods.SetPsaTCLK(tclkValue);}
77
78 #pragma inline=forced
IHIL_Open(unsigned char state)79 short IHIL_Open(unsigned char state){ return _edt_Common_Methods.Open(state);}
80
81 #pragma inline=forced
IHIL_Close(void)82 short IHIL_Close(void){return _edt_Common_Methods.Close();}
83
84 #pragma inline=forced
IHIL_Delay_1us(unsigned short usecs)85 void IHIL_Delay_1us(unsigned short usecs){_edt_Common_Methods.Delay_1us(usecs);}
86
87 #pragma inline=forced
IHIL_Delay_1ms(unsigned short msecs)88 void IHIL_Delay_1ms(unsigned short msecs){_edt_Common_Methods.Delay_1ms(msecs);}
89
90 #pragma inline=forced
IHIL_IccMonitor_Process(unsigned short flags)91 short IHIL_IccMonitor_Process(unsigned short flags){ return _edt_Common_Methods.Loop(flags);}
92
93 #pragma inline=forced
IHIL_EntrySequences(unsigned char states)94 void IHIL_EntrySequences(unsigned char states){_edt_Common_Methods.EntrySequences(states);}
95
96 #pragma inline=forced
IHIL_BSL_EntrySequence(unsigned short switchBypassOff)97 void IHIL_BSL_EntrySequence(unsigned short switchBypassOff){_edt_Common_Methods.BSL_EntrySequence(switchBypassOff);}
98
99 #pragma inline=forced
IHIL_BSL_EntrySequence1xx_4xx()100 void IHIL_BSL_EntrySequence1xx_4xx(){ _edt_Common_Methods.BSL_EntrySequence1xx_4xx();}
101
102 #pragma inline=forced
IHIL_SetReset(unsigned char value)103 void IHIL_SetReset(unsigned char value){_edt_Common_Methods.SetReset(value);}
104
105 #pragma inline=forced
IHIL_SetTest(unsigned char value)106 void IHIL_SetTest(unsigned char value){_edt_Common_Methods.SetTest(value);}
107
108 #pragma inline=forced
IHIL_SetTMS(unsigned char value)109 void IHIL_SetTMS(unsigned char value){_edt_Common_Methods.SetTMS(value);}
110
111 #pragma inline=forced
IHIL_SetTCK(unsigned char value)112 void IHIL_SetTCK(unsigned char value){_edt_Common_Methods.SetTCK(value);}
113
114 #pragma inline=forced
IHIL_SetTDI(unsigned char value)115 void IHIL_SetTDI(unsigned char value){_edt_Common_Methods.SetTDI(value);}
116
117 #pragma inline=forced
IHIL_InitDelayTimer(void)118 void IHIL_InitDelayTimer(void){_edt_Common_Methods.initDelayTimer();}
119
120 #pragma inline=forced
IHIL_SetJtagSpeed(unsigned short jtagSpeed,unsigned short sbwSpeed)121 void IHIL_SetJtagSpeed(unsigned short jtagSpeed, unsigned short sbwSpeed){_edt_Common_Methods.SetJtagSpeed(jtagSpeed,sbwSpeed);}
122
123 #pragma inline=forced
IHIL_ConfigureSetPc(unsigned short PCclockBeforeCapture)124 void IHIL_ConfigureSetPc(unsigned short PCclockBeforeCapture){_edt_Common_Methods.ConfigureSetPc(PCclockBeforeCapture);}
125 // Hil distinct methods
126 #pragma inline=forced
IHIL_TapReset(void)127 short IHIL_TapReset(void){return _edt_Distinct_Methods.TapReset();}
128
129 #pragma inline=forced
IHIL_CheckJtagFuse(void)130 short IHIL_CheckJtagFuse(void){return _edt_Distinct_Methods.CheckJtagFuse();}
131
132 #pragma inline=forced
IHIL_Tclk(unsigned char tclk)133 void IHIL_Tclk(unsigned char tclk){_edt_Distinct_Methods.Tclk(tclk);}
134
135 #pragma inline=forced
IHIL_Instr4(unsigned char ir)136 char IHIL_Instr4(unsigned char ir){return _edt_Distinct_Methods.Instr04(ir);}
137
138 #pragma inline=forced
IHIL_StepPsa(unsigned long length)139 void IHIL_StepPsa(unsigned long length){_edt_Distinct_Methods.StepPsa(length);}
140
141 #pragma inline=forced
IHIL_BlowFuse(unsigned char targetHasTestVpp)142 short IHIL_BlowFuse(unsigned char targetHasTestVpp){return _edt_Distinct_Methods.BlowFuse(targetHasTestVpp);}
143
144 #pragma inline=forced
IHIL_GetPrevInstruction()145 unsigned char IHIL_GetPrevInstruction(){ return _edt_Distinct_Methods.GetPrevInstruction();}
146
147 #pragma inline=forced
IHIL_TCLK(void)148 void IHIL_TCLK(void){IHIL_Tclk(0); IHIL_Tclk(1);}
149
150 #pragma inline=forced
SetReg_XBits(unsigned long long * Data,unsigned short count)151 unsigned long long SetReg_XBits(unsigned long long *Data, unsigned short count){return _edt_Distinct_Methods.SetReg_XBits(Data,count);}
152
153 #pragma inline=forced
SetReg_35Bits(unsigned long long * Data)154 unsigned long long SetReg_35Bits(unsigned long long *Data){return _edt_Distinct_Methods.SetReg_XBits35(Data);}
155
156 #pragma inline=forced
SetReg_8Bits(unsigned char data)157 unsigned char SetReg_8Bits(unsigned char data){return _edt_Distinct_Methods.SetReg_XBits08(data);}
158
159 #pragma inline=forced
SetReg_16Bits(unsigned short data)160 unsigned short SetReg_16Bits(unsigned short data){return _edt_Distinct_Methods.SetReg_XBits16(data);}
161
162 #pragma inline=forced
SetReg_20Bits(unsigned long data)163 unsigned long SetReg_20Bits(unsigned long data) {return _edt_Distinct_Methods.SetReg_XBits20(data);}
164
165 #pragma inline=forced
SetReg_32Bits(unsigned long data)166 unsigned long SetReg_32Bits(unsigned long data){return _edt_Distinct_Methods.SetReg_XBits32(data);}
167
168 #pragma inline=forced
SetReg_64Bits(unsigned long long data)169 unsigned long long SetReg_64Bits(unsigned long long data){return _edt_Distinct_Methods.SetReg_XBits64(data);}
170
171 //ARM interface functions
172 #pragma inline=forced
IHIL_Write_Read_Dp(unsigned char address,unsigned long * data,unsigned short rnw)173 short IHIL_Write_Read_Dp(unsigned char address, unsigned long *data, unsigned short rnw)
174 {return _edt_Distinct_Methods.write_read_Dp(address,data, rnw);}
175 #pragma inline=forced
IHIL_Write_Read_Ap(unsigned long address,unsigned long * data,unsigned short rnw)176 short IHIL_Write_Read_Ap(unsigned long address, unsigned long *data, unsigned short rnw)
177 {return _edt_Distinct_Methods.write_read_Ap(address, data, rnw);}
178 #pragma inline=forced
IHIL_Write_Read_Mem_Ap(unsigned short ap_sel,unsigned long address,unsigned long * data,unsigned short rnw)179 short IHIL_Write_Read_Mem_Ap(unsigned short ap_sel, unsigned long address, unsigned long *data, unsigned short rnw)
180 { return _edt_Distinct_Methods.write_read_mem_Ap(ap_sel, address, data, rnw);}
181 #pragma inline=forced
IHIL_SwdTransferData(unsigned char regiser,unsigned long * data,unsigned char rnw)182 unsigned char IHIL_SwdTransferData(unsigned char regiser, unsigned long* data, unsigned char rnw)
183 { return _edt_Distinct_Methods.SwdTransferData(regiser, data, rnw);}
184
185 #pragma inline=forced
SetReg8_64Bits(unsigned long long data,unsigned short loopCount,unsigned short PG)186 unsigned long long SetReg8_64Bits(unsigned long long data, unsigned short loopCount, unsigned short PG)
187 {return _edt_Distinct_Methods.SetReg_XBits8_64(data, loopCount, PG);}
188
189 // JTAG instruction register access
190 #pragma inline=forced
cntrl_sig_low_byte()191 short cntrl_sig_low_byte() { return _edt_Distinct_Methods.Instr(IR_CNTRL_SIG_LOW_BYTE); }
192
193 #pragma inline=forced
cntrl_sig_capture()194 short cntrl_sig_capture() { return _edt_Distinct_Methods.Instr(IR_CNTRL_SIG_CAPTURE); }
195
196 #pragma inline=forced
cntrl_sig_high_byte()197 short cntrl_sig_high_byte() { return _edt_Distinct_Methods.Instr(IR_CNTRL_SIG_HIGH_BYTE); }
198
199 #pragma inline=forced
cntrl_sig_16bit()200 short cntrl_sig_16bit() { return _edt_Distinct_Methods.Instr(IR_CNTRL_SIG_16BIT); }
201
202 #pragma inline=forced
cntrl_sig_release()203 short cntrl_sig_release() { return _edt_Distinct_Methods.Instr(IR_CNTRL_SIG_RELEASE); }
204
205 #pragma inline=forced
addr_16bit()206 short addr_16bit() { return _edt_Distinct_Methods.Instr(IR_ADDR_16BIT); }
207
208 #pragma inline=forced
addr_capture()209 short addr_capture() { return _edt_Distinct_Methods.Instr(IR_ADDR_CAPTURE); }
210
211 #pragma inline=forced
data_16bit()212 short data_16bit() { return _edt_Distinct_Methods.Instr(IR_DATA_16BIT); }
213
214 #pragma inline=forced
data_capture()215 short data_capture() {return _edt_Distinct_Methods.Instr(IR_DATA_CAPTURE); }
216
217 #pragma inline=forced
data_to_addr()218 short data_to_addr() { return _edt_Distinct_Methods.Instr(IR_DATA_TO_ADDR); }
219
220 #pragma inline=forced
data_quick()221 short data_quick() { return _edt_Distinct_Methods.Instr(IR_DATA_QUICK); }
222
223 #pragma inline=forced
config_fuses()224 short config_fuses() { return _edt_Distinct_Methods.Instr(IR_CONFIG_FUSES); }
225
226 #pragma inline=forced
eem_data_exchange()227 short eem_data_exchange() { return _edt_Distinct_Methods.Instr(IR_EMEX_DATA_EXCHANGE); }
228
229 #pragma inline=forced
eem_data_exchange32()230 short eem_data_exchange32() { return _edt_Distinct_Methods.Instr(IR_EMEX_DATA_EXCHANGE32); }
231
232 #pragma inline=forced
eem_read_control()233 short eem_read_control() { return _edt_Distinct_Methods.Instr(IR_EMEX_READ_CONTROL); }
234
235 #pragma inline=forced
eem_write_control()236 short eem_write_control() { return _edt_Distinct_Methods.Instr(IR_EMEX_WRITE_CONTROL); }
237
238 #pragma inline=forced
eem_read_trigger()239 short eem_read_trigger() { return _edt_Distinct_Methods.Instr(IR_EMEX_READ_TRIGGER); }
240
241 #pragma inline=forced
data_psa()242 short data_psa() { return _edt_Distinct_Methods.Instr(IR_DATA_PSA); }
243
244 #pragma inline=forced
shift_out_psa()245 short shift_out_psa() { return _edt_Distinct_Methods.Instr(IR_SHIFT_OUT_PSA); }
246
247 #pragma inline=forced
flash_16bit_update()248 short flash_16bit_update() { return _edt_Distinct_Methods.Instr(IR_FLASH_16BIT_UPDATE); }
249
250 #pragma inline=forced
jmb_exchange()251 short jmb_exchange() { return _edt_Distinct_Methods.Instr(IR_JMB_EXCHANGE); }
252
253 #pragma inline=forced
device_ip_pointer()254 short device_ip_pointer() { return _edt_Distinct_Methods.Instr(IR_DEVICE_ID);}
255
256 #pragma inline=forced
core_ip_pointer()257 short core_ip_pointer() { return _edt_Distinct_Methods.Instr(IR_COREIP_ID);}
258
259 #pragma inline=forced
jstate_read()260 short jstate_read() { return _edt_Distinct_Methods.Instr(IR_JSTATE_ID);}
261
262 #pragma inline=forced
test_reg()263 short test_reg() { return _edt_Distinct_Methods.Instr(IR_TEST_REG);}
264
265 #pragma inline=forced
test_reg_3V()266 short test_reg_3V() { return _edt_Distinct_Methods.Instr(IR_TEST_3V_REG);}
267
268 #pragma inline=forced
prepare_blow()269 short prepare_blow() { return _edt_Distinct_Methods.Instr(IR_PREPARE_BLOW);}
270
271 #pragma inline=forced
ex_blow()272 short ex_blow() { return _edt_Distinct_Methods.Instr(IR_EX_BLOW);}
273
274 #define OUT1RDY 0x0008
275 #define OUT0RDY 0x0004
276 #define IN1RDY 0x0002
277 #define IN0RDY 0x0001
278
279 #define JMB32B 0x0010
280 #define OUTREQ 0x0004
281 #define INREQ 0x0001
282
283 // JTAG logic functions
284 #pragma inline=forced
isInstrLoad()285 short isInstrLoad()
286 {
287 cntrl_sig_capture();
288 if((SetReg_16Bits(0) & (CNTRL_SIG_INSTRLOAD | CNTRL_SIG_READ)) != (CNTRL_SIG_INSTRLOAD | CNTRL_SIG_READ))
289 {
290 return -1;
291 }
292 return 0;
293 }
294
295 #pragma inline=forced
instrLoad()296 short instrLoad()
297 {
298 unsigned short i = 0;
299
300 cntrl_sig_low_byte();
301 SetReg_8Bits(CNTRL_SIG_READ);
302 IHIL_Tclk(1);
303
304 for(i = 0; i < 10; i++)
305 {
306 if(isInstrLoad() == 0)
307 {
308 return 0;
309 }
310 IHIL_TCLK();
311 }
312 return -1;
313 }
314
315 #pragma inline=forced
halt_cpu()316 void halt_cpu()
317 {
318 data_16bit();
319 SetReg_16Bits(0x3FFF);
320 IHIL_Tclk(0);
321 cntrl_sig_16bit();
322 SetReg_16Bits(0x2409);
323 IHIL_Tclk(1);
324 }
325
326 #pragma inline=forced
release_cpu()327 void release_cpu()
328 {
329 IHIL_Tclk(0);
330 cntrl_sig_16bit();
331 SetReg_16Bits(0x2401);
332 addr_capture();
333 IHIL_Tclk(1);
334 }
335
336 #pragma inline=forced
ReadMemWord(unsigned short address)337 unsigned short ReadMemWord(unsigned short address)
338 {
339 unsigned short data = 0;
340 halt_cpu();
341 IHIL_Tclk(0);
342 addr_16bit();
343 SetReg_16Bits(address);
344 data_to_addr();
345 IHIL_Tclk(1);
346 IHIL_Tclk(0);
347 data = SetReg_16Bits(0);
348 release_cpu();
349 return data;
350 }
351
352 #pragma inline=forced
ReadMemWordX(unsigned long address)353 unsigned short ReadMemWordX(unsigned long address)
354 {
355 unsigned short data = 0;
356 halt_cpu();
357 IHIL_Tclk(0);
358 addr_16bit();
359 SetReg_20Bits(address & 0xFFFFF);
360 data_to_addr();
361 IHIL_Tclk(1);
362 IHIL_Tclk(0);
363 data = SetReg_16Bits(0);
364 release_cpu();
365 return data;
366 }
367
368 #pragma inline=forced
ReadMemWordXv2(unsigned long address)369 unsigned short ReadMemWordXv2(unsigned long address)
370 {
371 unsigned short data = 0;
372 IHIL_Tclk(0);
373 addr_16bit();
374 SetReg_20Bits(address & 0xFFFFF);
375 IHIL_Tclk(1);
376 IHIL_Tclk(0);
377 data_capture();
378 data = SetReg_16Bits(0);
379 IHIL_Tclk(1);
380 IHIL_Tclk(0);
381 IHIL_Tclk(1);
382 return data;
383 }
384
385 #pragma inline=forced
WriteMemWord(unsigned short address,unsigned short data)386 void WriteMemWord(unsigned short address, unsigned short data)
387 {
388 halt_cpu();
389 IHIL_Tclk(0);
390 cntrl_sig_low_byte();
391 SetReg_8Bits(0x08);
392 addr_16bit();
393 SetReg_16Bits(address);
394 data_to_addr();
395 SetReg_16Bits(data);
396 IHIL_Tclk(1);
397 release_cpu();
398 }
399
400 #pragma inline=forced
WriteMemWordX(unsigned long address,unsigned short data)401 void WriteMemWordX(unsigned long address, unsigned short data)
402 {
403 halt_cpu();
404 IHIL_Tclk(0);
405 cntrl_sig_low_byte();
406 SetReg_8Bits(0x08);
407 addr_16bit();
408 SetReg_20Bits(address & 0xFFFFF);
409 data_to_addr();
410 SetReg_16Bits(data);
411 IHIL_Tclk(1);
412 release_cpu();
413 }
414
415 #pragma inline=forced
WriteMemWordXv2(unsigned long address,unsigned short data)416 void WriteMemWordXv2(unsigned long address, unsigned short data)
417 {
418 IHIL_Tclk(0);
419 cntrl_sig_16bit();
420 SetReg_16Bits(0x0500);
421 addr_16bit();
422 SetReg_20Bits(address);
423 IHIL_Tclk(1);
424 data_to_addr();
425 SetReg_16Bits(data);
426 IHIL_Tclk(0);
427 cntrl_sig_16bit();
428 SetReg_16Bits(0x0501);
429 IHIL_Tclk(1);
430 IHIL_Tclk(0);
431 IHIL_Tclk(1);
432 }
433
434 #pragma inline=forced
WriteMemByte(unsigned long address,unsigned short data)435 void WriteMemByte(unsigned long address, unsigned short data)
436 {
437 halt_cpu();
438 IHIL_Tclk(0);
439 addr_16bit();
440 SetReg_16Bits(address);
441 data_to_addr();
442 SetReg_8Bits(data);
443 IHIL_Tclk(1);
444 IHIL_Tclk(0);
445 release_cpu();
446 }
447
448 #pragma inline=forced
ReadCpuReg_uShort(unsigned short reg)449 unsigned short ReadCpuReg_uShort(unsigned short reg)
450 {
451 short op = 0;
452 unsigned short data = 0;
453
454 cntrl_sig_16bit();
455 SetReg_16Bits(0x3401);
456 data_16bit();
457 op = ((reg << 8) & 0x0F00) | 0x4082;
458 SetReg_16Bits(op);
459 IHIL_Tclk(0);
460 data_capture();
461 IHIL_Tclk(1);
462 data_16bit();
463 SetReg_16Bits(0x00fe);
464 IHIL_Tclk(0);
465 data_capture();
466 IHIL_Tclk(1);
467 IHIL_Tclk(0);
468 IHIL_Tclk(1);
469 SetReg_16Bits(0);
470 data = SetReg_16Bits(0);
471 IHIL_Tclk(0);
472 cntrl_sig_16bit();
473 SetReg_16Bits(0x2401);
474 IHIL_Tclk(1);
475 return data;
476 }
477
478 #pragma inline=forced
ReadCpuReg(unsigned short reg)479 unsigned short ReadCpuReg(unsigned short reg)
480 {
481 short op = 0;
482 unsigned short data = 0;
483
484 cntrl_sig_16bit();
485 SetReg_16Bits(0x3401);
486 data_16bit();
487 op = ((reg << 8) & 0x0F00) | 0x4082;
488 SetReg_16Bits(op);
489 IHIL_Tclk(0);
490 data_capture();
491 IHIL_Tclk(1);
492 data_16bit();
493 SetReg_16Bits(0x00fe);
494 IHIL_Tclk(0);
495 data_capture();
496 IHIL_Tclk(1);
497 IHIL_Tclk(0);
498 IHIL_Tclk(1);
499 data = SetReg_16Bits(0);
500 IHIL_Tclk(0);
501 cntrl_sig_16bit();
502 SetReg_16Bits(0x2401);
503 IHIL_Tclk(1);
504 return data;
505 }
506
507 #pragma inline=forced
ReadCpuRegX(unsigned short reg)508 unsigned long ReadCpuRegX(unsigned short reg)
509 {
510 short op = 0;
511 unsigned short Rx_l = 0;
512 unsigned short Rx_h = 0;
513
514 cntrl_sig_high_byte();
515 SetReg_16Bits(0x34);
516 op = ((reg << 8) & 0x0F00) | 0x60;
517 data_16bit();
518 IHIL_Tclk(1);
519 SetReg_16Bits(op);
520 IHIL_Tclk(0);
521 data_capture();
522 IHIL_Tclk(1);
523 data_16bit();
524 IHIL_Tclk(1);
525 SetReg_16Bits(0x00fc);
526 IHIL_Tclk(0);
527 data_capture();
528 IHIL_Tclk(1);
529 Rx_l = SetReg_16Bits(0);
530 IHIL_Tclk(0);
531 IHIL_Tclk(1);
532 Rx_h = SetReg_16Bits(0);
533 IHIL_Tclk(0);
534 cntrl_sig_high_byte();
535 SetReg_8Bits(0x24);
536 IHIL_Tclk(1);
537 return ((unsigned long)Rx_h<<16) + Rx_l;
538 }
539
540 #pragma inline=forced
ReadCpuRegXv2(unsigned short reg)541 unsigned long ReadCpuRegXv2(unsigned short reg)
542 {
543 unsigned short Rx_l = 0;
544 unsigned short Rx_h = 0;
545 unsigned short jtagId = cntrl_sig_capture();
546 const unsigned short jmbAddr = (jtagId == 0x98) ? 0x14c : 0x18c;
547
548 IHIL_Tclk(0);
549 data_16bit();
550 IHIL_Tclk(1);
551 SetReg_16Bits(reg);
552 cntrl_sig_16bit();
553 SetReg_16Bits(0x1401);
554 data_16bit();
555 IHIL_TCLK();
556 if (altRomAddressForCpuRead)
557 {
558 SetReg_16Bits(0x0ff6);
559 }
560 else
561 {
562 SetReg_16Bits(jmbAddr);
563 }
564 IHIL_TCLK();
565 SetReg_16Bits(0x3ffd);
566 IHIL_Tclk(0);
567 if (altRomAddressForCpuRead)
568 {
569 cntrl_sig_16bit();
570 SetReg_16Bits(0x0501);
571 }
572 data_capture();
573 IHIL_Tclk(1);
574 Rx_l = SetReg_16Bits(0);
575 IHIL_TCLK();
576 Rx_h = SetReg_16Bits(0);
577 IHIL_TCLK();
578 IHIL_TCLK();
579 IHIL_TCLK();
580 if (!altRomAddressForCpuRead)
581 {
582 cntrl_sig_16bit();
583 SetReg_16Bits(0x0501);
584 }
585 IHIL_Tclk(0);
586 data_capture();
587 IHIL_Tclk(1);
588 return((unsigned long)Rx_h<<16) + Rx_l;
589 }
590
591 #pragma inline=forced
WriteCpuReg(unsigned short reg,unsigned short data)592 void WriteCpuReg(unsigned short reg, unsigned short data)
593 {
594 unsigned short op = 0;
595 cntrl_sig_16bit();
596 SetReg_16Bits(0x3401);
597 data_16bit();
598 op = (0x4030 | reg);
599 SetReg_16Bits(op);
600 IHIL_Tclk(0);
601 data_capture();
602 IHIL_Tclk(1);
603 data_16bit();
604 SetReg_16Bits(data);
605 IHIL_Tclk(0);
606 data_capture();
607 IHIL_Tclk(1);
608 data_16bit();
609 SetReg_16Bits(0x3ffd);
610 IHIL_Tclk(0);
611 data_capture();
612 IHIL_Tclk(1);
613 IHIL_Tclk(0);
614 cntrl_sig_16bit();
615 SetReg_16Bits(0x2401);
616 IHIL_Tclk(1);
617 }
618
619 #pragma inline=forced
WriteCpuRegX(unsigned short mova,unsigned long data)620 void WriteCpuRegX(unsigned short mova, unsigned long data)
621 {
622 unsigned short op = 0x0080 | mova | ((data >> 8) & 0x0F00);
623 cntrl_sig_high_byte();
624 SetReg_8Bits(0x34);
625 data_16bit();
626 IHIL_Tclk(1);
627 SetReg_16Bits(op);
628 IHIL_Tclk(0);
629 data_capture();
630 IHIL_Tclk(1);
631 data_16bit();
632 IHIL_Tclk(1);
633 SetReg_16Bits(data & 0xFFFF);
634 IHIL_Tclk(0);
635 data_capture();
636 IHIL_Tclk(1);
637 data_16bit();
638 IHIL_Tclk(1);
639 SetReg_16Bits(0x3ffd);
640 IHIL_Tclk(0);
641 data_capture();
642 IHIL_Tclk(1);
643 IHIL_Tclk(0);
644 cntrl_sig_high_byte();
645 SetReg_8Bits(0x24);
646 IHIL_Tclk(1);
647 }
648
649 // BUGFIX BTT1722 added
650 #pragma inline=forced
WriteCpuRegXv2(unsigned short mova,unsigned short data)651 void WriteCpuRegXv2(unsigned short mova, unsigned short data)
652 {
653 IHIL_Tclk(0);
654 data_16bit();
655 IHIL_Tclk(1);
656 SetReg_16Bits(mova);
657 cntrl_sig_16bit();
658 SetReg_16Bits(0x1401);
659 data_16bit();
660 IHIL_TCLK();
661 SetReg_16Bits(data);
662 IHIL_TCLK();
663 SetReg_16Bits(0x3ffd);
664 IHIL_TCLK();
665 IHIL_Tclk(0);
666 addr_capture();
667 SetReg_20Bits(0x00000);
668 IHIL_Tclk(1);
669 cntrl_sig_16bit();
670 SetReg_16Bits(0x0501);
671 IHIL_TCLK();
672 IHIL_Tclk(0);
673 data_capture();
674 IHIL_Tclk(1);
675 }
676
677 #pragma inline=forced
SetPc(unsigned short pc)678 void SetPc(unsigned short pc)
679 {
680 cntrl_sig_16bit();
681 SetReg_16Bits(0x3401);
682 data_16bit();
683 SetReg_16Bits(0x4030);
684 IHIL_TCLK();
685 SetReg_16Bits(pc);
686 IHIL_TCLK();
687 addr_capture();
688 IHIL_Tclk(0);
689 cntrl_sig_16bit();
690 SetReg_16Bits(0x2401);
691 IHIL_Tclk(1);
692 }
693
694 #pragma inline=forced
SetPcJtagBug(unsigned short pc)695 void SetPcJtagBug(unsigned short pc)
696 {
697 data_16bit();
698 SetReg_16Bits(0x4030);
699 IHIL_Tclk(1);
700 IHIL_Tclk(0);
701 SetReg_16Bits(pc);
702 IHIL_Tclk(1);
703 IHIL_Tclk(0);
704 IHIL_Tclk(1);
705 IHIL_Tclk(0);
706 }
707
708 #pragma inline=forced
SetPcX(unsigned long pc)709 void SetPcX(unsigned long pc)
710 {
711 unsigned short pc_high = (unsigned short)(0x80 | (((pc)>>8) & 0x0F00));
712 unsigned short pc_low = (unsigned short)((pc) & 0xFFFF);
713 cntrl_sig_high_byte();
714 SetReg_8Bits(0x34);
715 data_16bit();
716 SetReg_16Bits(pc_high);
717 IHIL_TCLK();
718 SetReg_16Bits(pc_low);
719 IHIL_TCLK();
720 addr_capture();
721 IHIL_Tclk(0);
722 cntrl_sig_high_byte();
723 SetReg_8Bits(0x24);
724 IHIL_Tclk(1);
725 }
726
727 #pragma inline=forced
SetPcXv2(unsigned short Mova,unsigned short pc)728 void SetPcXv2(unsigned short Mova, unsigned short pc)
729 {
730 cntrl_sig_capture();
731 SetReg_16Bits(0x0000);
732 IHIL_Tclk(0);
733 data_16bit();
734 IHIL_Tclk(1);
735 SetReg_16Bits(Mova);
736 IHIL_Tclk(0);
737 cntrl_sig_16bit();
738 SetReg_16Bits(0x1400);
739 data_16bit();
740 IHIL_Tclk(0);
741 IHIL_Tclk(1);
742 SetReg_16Bits(pc);
743 IHIL_Tclk(0);
744 IHIL_Tclk(1);
745 SetReg_16Bits(0x4303);
746 IHIL_Tclk(0);
747 addr_capture();
748 SetReg_20Bits(0x00000);
749 }
750
751 #pragma inline=forced
SyncJtag()752 unsigned short SyncJtag()
753 {
754 unsigned short lOut = 0, i = 50;
755 cntrl_sig_16bit();
756 SetReg_16Bits(0x2401);
757 cntrl_sig_capture();
758 do
759 {
760 lOut = SetReg_16Bits(0x0000);
761 i--;
762 }
763 while(((lOut == 0xFFFF) || !(lOut & 0x0200)) && i);
764 if(!i)
765 {
766 return 0;
767 }
768 return lOut;
769 }
770
771 #pragma inline=forced
SyncJtagX()772 void SyncJtagX()
773 {
774 unsigned short lOut = 0, i = 50;
775 cntrl_sig_16bit();
776 SetReg_16Bits(0x2401);
777 cntrl_sig_capture();
778 SetReg_16Bits(0x0000);
779 IHIL_Tclk(1);
780 if (!(lOut & 0x0200))
781 {
782 cntrl_sig_high_byte();
783 SetReg_8Bits(0x34);
784 eem_data_exchange32();
785 SetReg_32Bits(0x89);
786 SetReg_32Bits(0);
787 eem_data_exchange32();
788 SetReg_32Bits(0x88);
789 SetReg_32Bits(lOut|0x40);
790 eem_data_exchange32();
791 SetReg_32Bits(0x88);
792 SetReg_32Bits(lOut);
793 }
794 cntrl_sig_capture();
795 do
796 {
797 lOut = SetReg_16Bits(0x0000);
798 i--;
799 }
800 while(((lOut == 0xFFFF) || !(lOut & 0x0200)) && i);
801 }
802
803 #pragma inline=forced
SyncJtagXv2()804 void SyncJtagXv2()
805 {
806 unsigned short i = 50, lOut = 0 ;
807 cntrl_sig_16bit();
808 SetReg_16Bits(0x1501);
809 cntrl_sig_capture();
810 do
811 {
812 lOut = SetReg_16Bits(0x0000);
813 i--;
814 }
815 while(((lOut == 0xFFFF) || !(lOut & 0x0200)) && i);
816 }
817
818 #pragma inline=forced
wait_for_synch()819 unsigned short wait_for_synch()
820 {
821 unsigned short i = 0;
822 cntrl_sig_capture();
823
824 while(!(SetReg_16Bits(0) & 0x0200) && i++ < 50);
825 if(i >= 50)
826 {
827 return 0;
828 }
829 return 1;
830 }
831
832 #pragma inline=forced
RestoreTestRegs()833 void RestoreTestRegs()
834 {
835 if(devicePowerSettings.powerTestReg3VMask)
836 {
837 test_reg_3V();
838 SetReg_16Bits(devicePowerSettings.powerTestReg3VDefault);
839 IHIL_Delay_1ms(20);
840 }
841 if(devicePowerSettings.powerTestRegMask)
842 {
843 test_reg();
844 SetReg_32Bits(devicePowerSettings.powerTestRegDefault);
845 IHIL_Delay_1ms(20);
846 }
847 }
848
849 #pragma inline=forced
EnableLpmx5()850 void EnableLpmx5()
851 {
852 if(devicePowerSettings.powerTestReg3VMask)
853 {
854 unsigned short reg_3V = 0;
855 test_reg_3V();
856 reg_3V= SetReg_16Bits(devicePowerSettings.powerTestReg3VDefault);
857
858 SetReg_16Bits(reg_3V & ~devicePowerSettings.powerTestReg3VMask|
859 devicePowerSettings.enableLpmx5TestReg3V);
860
861 IHIL_Delay_1ms(20);
862 }
863
864 if(devicePowerSettings.powerTestRegMask)
865 {
866 unsigned long reg_test = 0;
867 test_reg();
868 reg_test = SetReg_32Bits(devicePowerSettings.powerTestRegDefault);
869
870 SetReg_32Bits(reg_test & ~devicePowerSettings.powerTestRegMask|
871 devicePowerSettings.enableLpmx5TestReg);
872
873 IHIL_Delay_1ms(20);
874 }
875 }
876
877 #pragma inline=forced
DisableLpmx5()878 void DisableLpmx5()
879 {
880 if(devicePowerSettings.powerTestReg3VMask)
881 {
882 unsigned short reg_3V = 0;
883 test_reg_3V();
884 reg_3V = SetReg_16Bits(devicePowerSettings.powerTestReg3VDefault);
885
886 SetReg_16Bits(reg_3V & ~devicePowerSettings.powerTestReg3VMask|
887 devicePowerSettings.disableLpmx5TestReg3V);
888 IHIL_Delay_1ms(20);
889 }
890
891 if(devicePowerSettings.powerTestRegMask)
892 {
893 unsigned long reg_test = 0;
894 test_reg();
895 SetReg_32Bits(devicePowerSettings.powerTestRegDefault);
896
897 SetReg_32Bits(reg_test & ~devicePowerSettings.powerTestRegMask|
898 devicePowerSettings.disableLpmx5TestReg);
899
900 IHIL_Delay_1ms(20);
901 }
902 }
903
904 unsigned long i_ReadJmbOut();
905 unsigned short i_ReadJmbOut16();
906
907 short i_WriteJmbIn(unsigned short data);
908 short i_WriteJmbIn32(unsigned short dataA, unsigned short dataB);
909
910 short checkWakeup();
911 short powerUpArm();
912
913
914 #pragma inline=forced
915 // -----------------------------------------------------------------------------
JTAG_PsaSetup(unsigned long StartAddr)916 void JTAG_PsaSetup(unsigned long StartAddr)
917 {
918 data_16bit();
919 IHIL_Tclk(1);
920 SetReg_16Bits(MOV_IMM_PC);
921 IHIL_Tclk(0);
922 IHIL_Tclk(1);
923 SetReg_16Bits(StartAddr - 2);
924 IHIL_Tclk(0);
925 IHIL_Tclk(1);
926 IHIL_Tclk(0);
927 IHIL_Tclk(1);
928 IHIL_Tclk(0);
929 addr_capture();
930 SetReg_16Bits(0x0000);
931 }
932
933 #pragma inline=forced
934 // -----------------------------------------------------------------------------
JTAG_EnhancedPsaSetup(unsigned long StartAddr)935 void JTAG_EnhancedPsaSetup(unsigned long StartAddr)
936 {
937 halt_cpu();
938 IHIL_Tclk(0);
939 data_16bit();
940 SetReg_16Bits(StartAddr - 2);
941 }
942
943 #pragma inline=forced
944 // -----------------------------------------------------------------------------
JTAG_PsaEnd(void)945 void JTAG_PsaEnd(void)
946 {
947 // Intentionally does nothing
948 }
949
950 #pragma inline=forced
951 // -----------------------------------------------------------------------------
JTAG_EnhancedPsaEnd(void)952 void JTAG_EnhancedPsaEnd(void)
953 {
954 release_cpu();
955 isInstrLoad();
956 }
957
958 #endif
959
960