8b90f510ba41b88e7af6235a917113a13a5af35d
[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   // Perform Reset
178   jtag_ir_shift8(IR_CNTRL_SIG_16BIT);
179   jtag_dr_shift16(0x2C01); // apply
180   jtag_dr_shift16(0x2401); // remove
181   CLRTCLK;
182   SETTCLK;
183   CLRTCLK;
184   SETTCLK;
185   CLRTCLK;
186   jtagid = jtag_ir_shift8(IR_ADDR_CAPTURE); // get JTAG identifier
187   SETTCLK;
188   
189   jtag430_writemem(0x0120, 0x5A80);   // Diabled Watchdog
190 }
191
192
193
194 #define ERASE_GLOB 0xA50E
195 #define ERASE_ALLMAIN 0xA50C
196 #define ERASE_MASS 0xA506
197 #define ERASE_MAIN 0xA504
198 #define ERASE_SGMT 0xA502
199
200 //! Configure flash, then write a word.
201 void jtag430_eraseflash(unsigned int mode, unsigned int adr, unsigned int count,
202                         unsigned int info){
203   jtag430_haltcpu();
204   
205   //FCTL1= erase mode
206   jtag430_writemem(0x0128, mode);
207   //FCTL2=0xA540, selecting MCLK as source, DIV=1
208   jtag430_writemem(0x012A, 0xA540);
209   //FCTL3=0xA500, should be 0xA540 for Info Seg A on 2xx chips.
210   if(info)
211     jtag430_writemem(0x012C, 0xA540);
212   else
213     jtag430_writemem(0x012C, 0xA500);
214   
215   //Write the erase word.
216   jtag430_writemem(adr, 0x55AA);
217   //Return to read mode.
218   CLRTCLK;
219   jtag_ir_shift8(IR_CNTRL_SIG_16BIT);
220   jtag_dr_shift16(0x2409);
221   
222   //Send the pulses.
223   jtag430_tclk_flashpulses(count);
224   
225   //FCTL1=0xA500, disabling flash write
226   jtag430_writemem(0x0128, 0xA500);
227   
228   //jtag430_releasecpu();
229 }
230
231
232 //! Reset the TAP state machine.
233 void jtag430_resettap(){
234   int i;
235   // Settle output
236   SETTDI; //430X2
237   SETTMS;
238   //SETTDI; //classic
239   TCKTOCK;
240
241   // Navigate to reset state.
242   // Should be at least six.
243   for(i=0;i<4;i++){
244     TCKTOCK;
245   }
246
247   // test-logic-reset
248   CLRTMS;
249   TCKTOCK;
250   SETTMS;
251   // idle
252
253     
254   /* sacred, by spec.
255      Sometimes this isn't necessary.  */
256   // fuse check
257   CLRTMS;
258   delay(50);
259   SETTMS;
260   CLRTMS;
261   delay(50);
262   SETTMS;
263   /**/
264   
265 }
266
267 unsigned char jtagid;
268
269 //! Get the JTAG ID
270 unsigned char jtag430x2_jtagid(){
271   jtag430_resettap();
272   jtagid=jtag_ir_shift8(IR_BYPASS);
273   if(jtagid!=0x89 && jtagid!=0x91){
274     debugstr("Unknown JTAG ID");
275     debughex(jtagid);
276   }
277   return jtagid;
278 }
279 //! Start JTAG, take pins
280 unsigned char jtag430x2_start(){
281   jtagsetup();
282   
283   //Known-good starting position.
284   //Might be unnecessary.
285   SETTST;
286   SETRST;
287   
288   delay(0xFFFF);
289   
290   //Entry sequence from Page 67 of SLAU265A for 4-wire MSP430 JTAG
291   CLRRST;
292   delay(20);//10
293   CLRTST;
294
295   delay(10);//5
296   SETTST;
297   msdelay(10);//5
298   SETRST;
299   P5DIR&=~RST;
300   
301   delay(0xFFFF);
302   
303   //Perform a reset and disable watchdog.
304   return jtag430x2_jtagid();
305 }
306
307
308 //! Start JTAG, take pins
309 void jtag430_start(){
310   jtagsetup();
311   
312   //Known-good starting position.
313   //Might be unnecessary.
314   SETTST;
315   SETRST;
316   delay(0xFFFF);
317
318
319   #ifndef SBWREWRITE
320   //Entry sequence from Page 67 of SLAU265A for 4-wire MSP430 JTAG
321   CLRRST;
322   delay(100); //100
323   CLRTST;
324   delay(50);  //50
325   SETTST;
326   delay(50);  //50
327   SETRST;
328   P5DIR&=~RST;
329   delay(0xFFFF);
330   #endif
331   
332   //Perform a reset and disable watchdog.
333   jtag430_por();
334   jtag430_writemem(0x120,0x5a80);//disable watchdog
335   
336   jtag430_haltcpu();
337 }
338
339 //! Stop JTAG.
340 void jtag430_stop(){
341   debugstr("Exiting JTAG.");
342   jtagsetup();
343   
344   //Known-good starting position.
345   //Might be unnecessary.
346   //SETTST;
347   CLRTST;
348   SETRST;
349   delay(0xFFFF);
350   
351   //Entry sequence from Page 67 of SLAU265A for 4-wire MSP430 JTAG
352   CLRRST;
353   delay(0xFFFF);
354   SETRST;
355   //P5DIR&=~RST;
356   //delay(0xFFFF);
357   
358 }
359
360 //! Set CPU to Instruction Fetch
361 void jtag430_setinstrfetch(){
362   
363   jtag_ir_shift8(IR_CNTRL_SIG_CAPTURE);
364
365   // Wait until instruction fetch state.
366   while(1){
367     if (jtag_dr_shift16(0x0000) & 0x0080)
368       return;
369     CLRTCLK;
370     SETTCLK;
371   }
372 }
373
374
375
376
377
378 //! Handles classic MSP430 JTAG commands.  Forwards others to JTAG.
379 void jtag430_handle_fn(uint8_t const app,
380                                            uint8_t const verb,
381                                            uint32_t const len)
382 {
383   unsigned long at, l;
384   unsigned int i, val;
385   
386   
387   /* FIXME
388    * Sometimes JTAG doesn't init correctly.
389    * This restarts the connection if the masked-rom
390    * chip ID cannot be read.  Should print warning
391    * for testing server.
392    */
393   if (jtagid!=0)
394     while((i=jtag430_readmem(0xff0))==0xFFFF){
395       debugstr("Reconnecting to target MSP430.");
396       jtag430x2_start();
397       PLEDOUT^=PLEDPIN;
398     }
399   PLEDOUT&=~PLEDPIN;
400   
401   
402   switch(verb){
403   case START:
404     /* old method, classic MSP430. 
405     //Enter JTAG mode.
406     jtag430x2_start();
407     //TAP setup, fuse check
408     jtag430_resettap();
409     
410     cmddata[0]=jtag_ir_shift8(IR_BYPASS);    
411     txdata(app,verb,1);
412     */
413     jtag430x2_start();
414     cmddata[0]=jtagid;
415     
416     jtag430mode=MSP430MODE;
417     
418     /* So the way this works is that a width of 20 does some
419        backward-compatibility finagling, causing the correct value
420        to be exchanged for addresses on 16-bit chips as well as the
421        new MSP430X chips.  (This has only been verified on the
422        MSP430F2xx family.  TODO verify for others.)
423     */
424     
425     drwidth=20;
426     
427     //Perform a reset and disable watchdog.
428     jtag430_por();
429     jtag430_writemem(0x120,0x5a80);//disable watchdog
430     
431     jtag430_haltcpu();
432     
433     jtag430_resettap();
434     txdata(app,verb,1);
435     
436     break;
437   case STOP:
438     jtag430_stop();
439     txdata(app,verb,0);
440     break;
441   case JTAG430_HALTCPU:
442     jtag430_haltcpu();
443     txdata(app,verb,0);
444     break;
445   case JTAG430_RELEASECPU:
446     jtag430_releasecpu();
447     txdata(app,verb,0);
448     break;
449   case JTAG430_SETINSTRFETCH:
450     jtag430_setinstrfetch();
451     txdata(app,verb,0);
452     break;
453     
454   case JTAG430_READMEM:
455   case PEEK:
456     at=cmddatalong[0];
457     
458     //Fetch large blocks for bulk fetches,
459     //small blocks for individual peeks.
460     if(len>5)
461       l=(cmddataword[2]);//always even.
462     else
463       l=2;
464     l&=~1;//clear lsbit
465     
466     txhead(app,verb,l);
467     for(i = 0; i < l; i += 2) {
468       jtag430_resettap();
469       val=jtag430_readmem(at);
470       
471       at+=2;
472       serial_tx(val&0xFF);
473       serial_tx((val&0xFF00)>>8);
474     }
475     break;
476   case JTAG430_WRITEMEM:
477   case POKE:
478     jtag430_haltcpu();
479     jtag430_writemem(cmddataword[0],cmddataword[2]);
480     cmddataword[0]=jtag430_readmem(cmddataword[0]);
481     txdata(app,verb,2);
482     break;
483     /*
484   case JTAG430_WRITEFLASH:
485
486     //debugstr("Poking flash memory.");
487     jtag430_writeflash(cmddataword[0],cmddataword[2]);
488     
489     //Try again if failure.
490     //if(cmddataword[2]!=jtag430_readmem(cmddataword[0]))
491     //  jtag430_writeflash(cmddataword[0],cmddataword[2]);
492     
493     //Return result.
494     cmddataword[0]=jtag430_readmem(cmddataword[0]);
495     
496     txdata(app,verb,2);
497     break; */
498   case JTAG430_WRITEFLASH:
499     at=cmddataword[0];
500     
501     for(i=0;i<(len>>1)-2;i++){
502       //debugstr("Poking flash memory.");
503       jtag430_writeflash(at+(i<<1),cmddataword[i+2]);
504       //Reflash if needed.  Try this twice to save grace?
505       if(cmddataword[i]!=jtag430_readmem(at))
506         jtag430_writeflash(at+(i<<1),cmddataword[i+2]);
507     }
508     
509     //Return result of first write as a word.
510     cmddataword[0]=jtag430_readmem(cmddataword[0]);
511     
512     txdata(app,verb,2);
513     break;
514   case JTAG430_ERASEFLASH:
515     jtag430_eraseflash(ERASE_MASS,0xFFFE,0x3000,0);
516     txdata(app,verb,0);
517     break;
518   case JTAG430_ERASEINFO:
519     jtag430_eraseflash(ERASE_SGMT,0x1000,0x3000,1);
520     txdata(app,verb,0);
521     break;
522   case JTAG430_SETPC:
523     jtag430_haltcpu();
524     //debughex("Setting PC.");
525     //debughex(cmddataword[0]);
526     jtag430_setpc(cmddataword[0]);
527     jtag430_releasecpu();
528     txdata(app,verb,0);
529     break;
530   case JTAG430_SETREG:
531     jtag430_setr(cmddata[0],cmddataword[1]);
532     txdata(app,verb,0);
533     break;
534   case JTAG430_GETREG:
535     //jtag430_getr(cmddata[0]);
536     debugstr("JTAG430_GETREG not yet implemented.");
537     cmddataword[0]=0xDEAD;
538     txdata(app,verb,2);
539     break;
540   case JTAG430_COREIP_ID:
541     //cmddataword[0]=jtag430_coreid();
542     cmddataword[0]=0xdead;
543     txdata(app,verb,2);
544     break;
545   case JTAG430_DEVICE_ID:
546     //cmddatalong[0]=jtag430_deviceid();
547     cmddataword[0]=0xdead;
548     cmddataword[0]=0xbeef;
549     txdata(app,verb,4);
550     break;
551   default:
552     (*(jtag_app.handle))(app,verb,len);
553   }
554   //jtag430_resettap();  //DO NOT UNCOMMENT
555 }