9a33a7242a385d6b884406b3d43e6012876542d4
[goodfet] / firmware / apps / jtag / jtag430.c
1 /*! \file jtag430.c
2   \author Travis Goodspeed <travis at radiantmachines.com>
3   \brief MSP430 JTAG (16-bit)
4 */
5
6 #include "platform.h"
7 #include "command.h"
8 #include "jtag430.h"
9
10 //! Handles classic MSP430 JTAG commands.  Forwards others to JTAG.
11 void jtag430_handle_fn(uint8_t const app,
12                                            uint8_t const verb,
13                                            uint32_t const len);
14
15 // define the jtag430 app's app_t
16 app_t const jtag430_app = {
17
18         /* app number */
19         JTAG430,
20
21         /* handle fn */
22         jtag430_handle_fn,
23
24         /* name */
25         "JTAG430",
26
27         /* desc */
28         "\tThe JTAG430 app adds to the basic JTAG app\n"
29         "\tsupport for JTAG'ing MSP430 devices.\n"
30 };
31
32 unsigned int jtag430mode=MSP430X2MODE;
33
34 //! Set a register.
35 void jtag430_setr(u8 reg, u16 val){
36   jtag_ir_shift8(IR_CNTRL_SIG_16BIT);
37   jtag_dr_shift16(0x3401);// release low byte
38   jtag_ir_shift8(IR_DATA_16BIT);
39   
40   //0x4030 is "MOV #foo, r0"
41   //Right-most field is register, so 0x4035 loads r5
42   jtag_dr_shift16(0x4030+reg);
43   CLRTCLK;
44   SETTCLK;
45   jtag_dr_shift16(val);// Value for the register
46   CLRTCLK;
47   jtag_ir_shift8(IR_ADDR_CAPTURE);
48   SETTCLK;
49   CLRTCLK ;// Now reg is set to new value.
50   jtag_ir_shift8(IR_CNTRL_SIG_16BIT);
51   jtag_dr_shift16(0x2401);// low byte controlled by JTAG
52 }
53
54 //! Set the program counter.
55 void jtag430_setpc(unsigned int adr){
56   jtag430_setr(0,adr);
57 }
58
59 //! Halt the CPU
60 void jtag430_haltcpu(){
61   //jtag430_setinstrfetch();
62   
63   jtag_ir_shift8(IR_DATA_16BIT);
64   jtag_dr_shift16(0x3FFF);//JMP $+0
65   
66   CLRTCLK;
67   jtag_ir_shift8(IR_CNTRL_SIG_16BIT);
68   jtag_dr_shift16(0x2409);//set JTAG_HALT bit
69   SETTCLK;
70 }
71
72 //! Release the CPU
73 void jtag430_releasecpu(){
74   CLRTCLK;
75   //debugstr("Releasing target MSP430.");
76   
77   /*
78   jtag_ir_shift8(IR_CNTRL_SIG_16BIT);
79   jtag_dr_shift16(0x2C01); //Apply reset.
80   jtag_dr_shift16(0x2401); //Release reset.
81   */
82   jtag_ir_shift8(IR_CNTRL_SIG_RELEASE);
83   SETTCLK;
84 }
85
86 //! Read data from address
87 unsigned int jtag430_readmem(unsigned int adr){
88   unsigned int toret;
89   jtag430_haltcpu();
90   
91   CLRTCLK;
92   jtag_ir_shift8(IR_CNTRL_SIG_16BIT);
93   
94   if(adr>0xFF)
95     jtag_dr_shift16(0x2409);//word read
96   else
97     jtag_dr_shift16(0x2419);//byte read
98   jtag_ir_shift8(IR_ADDR_16BIT);
99   jtag_dr_shiftadr(adr);//address
100   jtag_ir_shift8(IR_DATA_TO_ADDR);
101   SETTCLK;
102
103   CLRTCLK;
104   toret=jtag_dr_shift16(0x0000);//16 bit return
105   
106   return toret;
107 }
108
109 //! Write data to address.
110 void jtag430_writemem(unsigned int adr, unsigned int data){
111   CLRTCLK;
112   jtag_ir_shift8(IR_CNTRL_SIG_16BIT);
113   if(adr>0xFF)
114     jtag_dr_shift16(0x2408);//word write
115   else
116     jtag_dr_shift16(0x2418);//byte write
117   jtag_ir_shift8(IR_ADDR_16BIT);
118   jtag_dr_shiftadr(adr);
119   jtag_ir_shift8(IR_DATA_TO_ADDR);
120   jtag_dr_shift16(data);
121   SETTCLK;
122 }
123
124 //! Write data to flash memory.  Must be preconfigured.
125 void jtag430_writeflashword(unsigned int adr, unsigned int data){
126   
127   CLRTCLK;
128   jtag_ir_shift8(IR_CNTRL_SIG_16BIT);
129   jtag_dr_shift16(0x2408);//word write
130   jtag_ir_shift8(IR_ADDR_16BIT);
131   jtag_dr_shiftadr(adr);
132   jtag_ir_shift8(IR_DATA_TO_ADDR);
133   jtag_dr_shift16(data);
134   SETTCLK;
135   
136   //Return to read mode.
137   CLRTCLK;
138   jtag_ir_shift8(IR_CNTRL_SIG_16BIT);
139   jtag_dr_shift16(0x2409);
140   
141   /*
142   jtag430_writemem(adr,data);
143   CLRTCLK;
144   jtag_ir_shift8(IR_CNTRL_SIG_16BIT);
145   jtag_dr_shift16(0x2409);
146   */
147   
148   //Pulse TCLK
149   jtag430_tclk_flashpulses(35); //35 standard
150 }
151
152 //! Configure flash, then write a word.
153 void jtag430_writeflash(unsigned int adr, unsigned int data){
154   jtag430_haltcpu();
155   
156   //FCTL1=0xA540, enabling flash write
157   jtag430_writemem(0x0128, 0xA540);
158   //FCTL2=0xA540, selecting MCLK as source, DIV=1
159   jtag430_writemem(0x012A, 0xA540);
160   //FCTL3=0xA500, should be 0xA540 for Info Seg A on 2xx chips.
161   jtag430_writemem(0x012C, 0xA500); //all but info flash.
162   //if(jtag430_readmem(0x012C));
163   
164   //Write the word itself.
165   jtag430_writeflashword(adr,data);
166   
167   //FCTL1=0xA500, disabling flash write
168   jtag430_writemem(0x0128, 0xA500);
169   
170   //jtag430_releasecpu();
171 }
172
173
174
175 //! Power-On Reset
176 void jtag430_por(){
177   unsigned int jtagid;
178
179   // Perform Reset
180   jtag_ir_shift8(IR_CNTRL_SIG_16BIT);
181   jtag_dr_shift16(0x2C01); // apply
182   jtag_dr_shift16(0x2401); // remove
183   CLRTCLK;
184   SETTCLK;
185   CLRTCLK;
186   SETTCLK;
187   CLRTCLK;
188   jtagid = jtag_ir_shift8(IR_ADDR_CAPTURE); // get JTAG identifier
189   SETTCLK;
190   
191   jtag430_writemem(0x0120, 0x5A80);   // Diabled Watchdog
192 }
193
194
195
196 #define ERASE_GLOB 0xA50E
197 #define ERASE_ALLMAIN 0xA50C
198 #define ERASE_MASS 0xA506
199 #define ERASE_MAIN 0xA504
200 #define ERASE_SGMT 0xA502
201
202 //! Configure flash, then write a word.
203 void jtag430_eraseflash(unsigned int mode, unsigned int adr, unsigned int count,
204                         unsigned int info){
205   jtag430_haltcpu();
206   
207   //FCTL1= erase mode
208   jtag430_writemem(0x0128, mode);
209   //FCTL2=0xA540, selecting MCLK as source, DIV=1
210   jtag430_writemem(0x012A, 0xA540);
211   //FCTL3=0xA500, should be 0xA540 for Info Seg A on 2xx chips.
212   if(info)
213     jtag430_writemem(0x012C, 0xA540);
214   else
215     jtag430_writemem(0x012C, 0xA500);
216   
217   //Write the erase word.
218   jtag430_writemem(adr, 0x55AA);
219   //Return to read mode.
220   CLRTCLK;
221   jtag_ir_shift8(IR_CNTRL_SIG_16BIT);
222   jtag_dr_shift16(0x2409);
223   
224   //Send the pulses.
225   jtag430_tclk_flashpulses(count);
226   
227   //FCTL1=0xA500, disabling flash write
228   jtag430_writemem(0x0128, 0xA500);
229   
230   //jtag430_releasecpu();
231 }
232
233
234 //! Reset the TAP state machine.
235 void jtag430_resettap(){
236   int i;
237   // Settle output
238   SETTDI; //430X2
239   SETTMS;
240   //SETTDI; //classic
241   TCKTOCK;
242
243   // Navigate to reset state.
244   // Should be at least six.
245   for(i=0;i<4;i++){
246     TCKTOCK;
247   }
248
249   // test-logic-reset
250   CLRTMS;
251   TCKTOCK;
252   SETTMS;
253   // idle
254
255     
256   /* sacred, by spec.
257      Sometimes this isn't necessary.  */
258   // fuse check
259   CLRTMS;
260   delay(50);
261   SETTMS;
262   CLRTMS;
263   delay(50);
264   SETTMS;
265   /**/
266   
267 }
268
269 //! Start JTAG, take pins
270 void jtag430_start(){
271   jtagsetup();
272   
273   //Known-good starting position.
274   //Might be unnecessary.
275   SETTST;
276   SETRST;
277   delay(0xFFFF);
278
279
280   #ifndef SBWREWRITE
281   //Entry sequence from Page 67 of SLAU265A for 4-wire MSP430 JTAG
282   CLRRST;
283   delay(100); //100
284   CLRTST;
285   delay(50);  //50
286   SETTST;
287   delay(50);  //50
288   SETRST;
289   P5DIR&=~RST;
290   delay(0xFFFF);
291   #endif
292   
293   //Perform a reset and disable watchdog.
294   jtag430_por();
295   jtag430_writemem(0x120,0x5a80);//disable watchdog
296   
297   jtag430_haltcpu();
298 }
299
300 //! Stop JTAG.
301 void jtag430_stop(){
302   debugstr("Exiting JTAG.");
303   jtagsetup();
304   
305   //Known-good starting position.
306   //Might be unnecessary.
307   //SETTST;
308   CLRTST;
309   SETRST;
310   delay(0xFFFF);
311   
312   //Entry sequence from Page 67 of SLAU265A for 4-wire MSP430 JTAG
313   CLRRST;
314   delay(0xFFFF);
315   SETRST;
316   //P5DIR&=~RST;
317   //delay(0xFFFF);
318   
319 }
320
321 //! Set CPU to Instruction Fetch
322 void jtag430_setinstrfetch(){
323   
324   jtag_ir_shift8(IR_CNTRL_SIG_CAPTURE);
325
326   // Wait until instruction fetch state.
327   while(1){
328     if (jtag_dr_shift16(0x0000) & 0x0080)
329       return;
330     CLRTCLK;
331     SETTCLK;
332   }
333 }
334
335
336 //! Handles classic MSP430 JTAG commands.  Forwards others to JTAG.
337 void jtag430_handle_fn(uint8_t const app,
338                                            uint8_t const verb,
339                                            uint32_t const len)
340 {
341   unsigned long at, l;
342   unsigned int i, val;
343   
344   
345   /* FIXME
346    * Sometimes JTAG doesn't init correctly.
347    * This restarts the connection if the masked-rom
348    * chip ID cannot be read.  Should print warning
349    * for testing server.
350    */
351   while((i=jtag430_readmem(0xff0))==0xFFFF){
352     debugstr("Reconnecting to target MSP430.");
353     jtag430_start();
354     PLEDOUT^=PLEDPIN;
355   }
356   PLEDOUT&=~PLEDPIN;
357   
358   
359   switch(verb){
360   case START:
361     //Enter JTAG mode.
362     jtag430_start();
363     //TAP setup, fuse check
364     jtag430_resettap();
365     
366     cmddata[0]=jtag_ir_shift8(IR_BYPASS);    
367     txdata(app,verb,1);
368
369     break;
370   case STOP:
371     jtag430_stop();
372     txdata(app,verb,0);
373     break;
374   case JTAG430_HALTCPU:
375     jtag430_haltcpu();
376     txdata(app,verb,0);
377     break;
378   case JTAG430_RELEASECPU:
379     jtag430_releasecpu();
380     txdata(app,verb,0);
381     break;
382   case JTAG430_SETINSTRFETCH:
383     jtag430_setinstrfetch();
384     txdata(app,verb,0);
385     break;
386     
387   case JTAG430_READMEM:
388   case PEEK:
389     at=cmddatalong[0];
390     
391     //Fetch large blocks for bulk fetches,
392     //small blocks for individual peeks.
393     if(len>5)
394       l=(cmddataword[2]);//always even.
395     else
396       l=2;
397     l&=~1;//clear lsbit
398     
399     txhead(app,verb,l);
400     for(i = 0; i < l; i += 2) {
401       jtag430_resettap();
402       val=jtag430_readmem(at);
403       
404       at+=2;
405       serial_tx(val&0xFF);
406       serial_tx((val&0xFF00)>>8);
407     }
408     break;
409   case JTAG430_WRITEMEM:
410   case POKE:
411     jtag430_haltcpu();
412     jtag430_writemem(cmddataword[0],cmddataword[2]);
413     cmddataword[0]=jtag430_readmem(cmddataword[0]);
414     txdata(app,verb,2);
415     break;
416     /*
417   case JTAG430_WRITEFLASH:
418
419     //debugstr("Poking flash memory.");
420     jtag430_writeflash(cmddataword[0],cmddataword[2]);
421     
422     //Try again if failure.
423     //if(cmddataword[2]!=jtag430_readmem(cmddataword[0]))
424     //  jtag430_writeflash(cmddataword[0],cmddataword[2]);
425     
426     //Return result.
427     cmddataword[0]=jtag430_readmem(cmddataword[0]);
428     
429     txdata(app,verb,2);
430     break; */
431   case JTAG430_WRITEFLASH:
432     at=cmddataword[0];
433     
434     for(i=0;i<(len>>1)-2;i++){
435       //debugstr("Poking flash memory.");
436       jtag430_writeflash(at+(i<<1),cmddataword[i+2]);
437       //Reflash if needed.  Try this twice to save grace?
438       if(cmddataword[i]!=jtag430_readmem(at))
439         jtag430_writeflash(at+(i<<1),cmddataword[i+2]);
440     }
441     
442     //Return result of first write as a word.
443     cmddataword[0]=jtag430_readmem(cmddataword[0]);
444     
445     txdata(app,verb,2);
446     break;
447   case JTAG430_ERASEFLASH:
448     jtag430_eraseflash(ERASE_MASS,0xFFFE,0x3000,0);
449     txdata(app,verb,0);
450     break;
451   case JTAG430_ERASEINFO:
452     jtag430_eraseflash(ERASE_SGMT,0x1000,0x3000,1);
453     txdata(app,verb,0);
454     break;
455   case JTAG430_SETPC:
456     jtag430_haltcpu();
457     //debughex("Setting PC.");
458     //debughex(cmddataword[0]);
459     jtag430_setpc(cmddataword[0]);
460     jtag430_releasecpu();
461     txdata(app,verb,0);
462     break;
463   case JTAG430_SETREG:
464     jtag430_setr(cmddata[0],cmddataword[1]);
465     txdata(app,verb,0);
466     break;
467   case JTAG430_GETREG:
468     //jtag430_getr(cmddata[0]);
469     debugstr("JTAG430_GETREG not yet implemented.");
470     cmddataword[0]=0xDEAD;
471     txdata(app,verb,2);
472     break;
473   case JTAG430_COREIP_ID:
474   case JTAG430_DEVICE_ID:
475     cmddataword[0]=0;
476     cmddataword[1]=0;
477     txdata(app,verb,4);
478     break;
479     
480   default:
481     (*(jtag_app.handle))(app,verb,len);
482   }
483   //jtag430_resettap();  //DO NOT UNCOMMENT
484 }