git.rot13.org Git - goodfet/blob - client/goodfet.pic

   1 #!/usr/bin/env python
   2 # PIC client (currently only supports dsPIC33F/PIC24H.)
   3 #
   4 # Scott Livingston  <slivingston at caltech.edu>
   5 #
   6 # March, April 2010.
   7
   8
   9 import sys
  10 import time
  11
  12 from GoodFET import GoodFET
  13 from intelhex import IntelHex
  14
  15 #############
  16 # Some constants (not really immutable...)
  17 #############
  18 PICAPP = 0x34
  19 MONITORAPP = 0x00
  20 NOK = 0x7E
  21 dev_table = { 0x00EE : "dsPIC33FJ128GP708",
  22               0x00EF : "dsPIC33FJ128GP710" }
  23 cfg_table = { 0xF80000 : "FBS",
  24               0xF80002 : "FSS",
  25               0xF80004 : "FGS",
  26               0xF80006 : "FOSCSEL",
  27               0xF80008 : "FOSC",
  28               0xF8000A : "FWDT",
  29               0xF8000C : "FPOR",
  30               0xF8000E : "FICD",
  31               0xF80010 : "FUID0",
  32               0xF80012 : "FUID1",
  33               0xF80014 : "FUID2",
  34               0xF80016 : "FUID3",
  35               "width" : 7 } # For pretty printing.
  36
  37
  38 #############
  39 # Functions:
  40 #############
  41
  42 def runlist( cmd_li ):
  43     """Load (and execute) a given list of instructions.
  44 Assumes ICSP session already started."""
  45     cmd_byte_li = build_instr_stream( cmd_li )
  46     data = client.writecmd( PICAPP, 0x86, len(cmd_byte_li), cmd_byte_li )
  47     if client.app == PICAPP and client.verb == 0x86 and client.count != len(cmd_byte_li):
  48         print "Error: incomplete execution of sixlist.\nOnly %d instructions run." % (client.count/3)
  49         stopICSP()
  50         exit(-1)
  51     elif client.app == 0xff and client.verb == 0xff: # GoodFET debugstr
  52         print "Error (in runlist): failed transaction; aborting."
  53         stopICSP()
  54         exit(-1)
  55
  56 def build_instr_stream( cmd_li ):
  57     """Given a list of instruction words, returns a list of bytes of
  58 the same, in little endian ordering."""
  59     cmd_byte_li = []
  60     for instr in cmd_li:
  61         cmd_byte_li += [instr & 0xff,
  62                         (instr >> 8) & 0xff,
  63                         (instr >> 16) & 0xff]
  64     return cmd_byte_li
  65
  66 def readreg( reg_num ):
  67     """Read contents of a working register (i.e. W0, W1, ..., W15)."""
  68     instr = 0x883C20+(reg_num&0xf)
  69     client.writecmd( PICAPP, 0x82, 3, [instr & 0xff,
  70                                        (instr >> 8) & 0xff,
  71                                        (instr >> 16) & 0xff] )
  72     client.writecmd( PICAPP, 0x82, 3, [0x00,0x00,0x00] ) # NOP (pump clock)
  73     return readVISI()
  74
  75 def readVISI():
  76     """Read VISI register; assumes ICSP session already started."""
  77     data = client.writecmd( PICAPP, 0x83, 0 )
  78     result = ord(data[0])
  79     result |= ord(data[1]) << 8
  80     return result
  81
  82 def readNVMCON():
  83     """Read NVMCON register; assumes ICSP session already started."""
  84     rd_nvmcon_li = [0x803B00, # MOV NVMCON, W0
  85                     0x883C20, # MOV W0, VISI
  86                     0x000000, # NOP
  87                     0x000000] # NOP
  88     runlist( rd_nvmcon_li )
  89     return readVISI()
  90
  91 def startICSP():
  92     #print "Starting dsPIC33F/PIC24H ICSP session..."
  93     data = client.writecmd( PICAPP, 0x84, 0 )
  94
  95 def stopICSP():
  96     #print "Stopping dsPIC33F/PIC24H ICSP session..."
  97     data = client.writecmd( PICAPP, 0x85, 0 )
  98
  99 def dumpVISI():
 100     """Read and print VISI register to stdout; assumes ICSP session already started."""
 101     print "Reading VISI register..."
 102     result = readVISI()
 103     print "VISI: 0x%04X" % result
 104
 105 def instr2words( instr_list ):
 106     """Convert a list of 4 24-bit instructions to a list of 6 words
 107 (16-bit width).
 108
 109 Returns [-1] on failure."""
 110     if len(instr_list) < 4: # Catch mistakes
 111         print "Error in instr2words: operand has less than 4 elements."
 112         return [-1]
 113     word_list = [0,0,0,0,0,0]
 114     for k in [0,1]:
 115         word_list[k*3] = instr_list[k*2] & 0xffff
 116         word_list[k*3+1] = (instr_list[k*2]>>16)&0xff
 117         word_list[k*3+1] |= (instr_list[k*2+1]>>8)&0xff00
 118         word_list[k*3+2] = instr_list[k*2+1] & 0xffff
 119     return word_list
 120
 121 def words2instr( word_list ):
 122     """4 24-bit instructions from a packing in 6 words (16 bit width).
 123 This is the inverse of function instr2words.
 124
 125 Returns [-1] on failure."""
 126     if len(word_list) < 6: # Catch mistakes
 127         print "Error in words2instr: operand has less than 6 elements."
 128         return [-1]
 129     instr_list = [0,0,0,0]
 130     for k in [0,1]:
 131         instr_list[k*2] = word_list[k*3]
 132         instr_list[k*2] |= (word_list[k*3+1]&0xff)<<16
 133         instr_list[k*2+1] = word_list[k*3+2]
 134         instr_list[k*2+1] |= (word_list[k*3+1]&0xff00)<<8
 135     return instr_list
 136
 137
 138 #############
 139 # Main entry:
 140 #############
 141
 142 if len(sys.argv) == 1:
 143     print "Usage: %s verb [objects]" % sys.argv[0]
 144     print "Warning: only supports dsPIC33F/PIC24H (maybe)...\n"
 145     print "%s devid" % sys.argv[0]
 146     print "%s read 0x$addr" % sys.argv[0]
 147     print "%s dump $foo.hex [0x$start 0x$stop] [pretty]" % sys.argv[0]
 148     print "%s config" % sys.argv[0]
 149     print "%s program $foo.hex" % sys.argv[0]
 150     print "%s verify $foo.hex (NOTE: only addresses in $foo.hex are verified.)" % sys.argv[0]
 151     print "%s write $0xADDRESS $0xVALUE" % sys.argv[0]
 152     print "%s write_config $REG_NAME [$0x0000]" % sys.argv[0]
 153     print "%s erase [0x$page]" % sys.argv[0] # bulk or page erase
 154     print "%s six [instruction]" % sys.argv[0]
 155     print "%s sixfile [$foo.txt] (NOTE: plaintext, one instruction per line.)" % sys.argv[0]
 156     print "%s regout" % sys.argv[0]
 157     print """
 158 Note: use - for stdout.
 159 """
 160     sys.exit()
 161
 162 # Initialize and open connection to GoodFET
 163 client = GoodFET()
 164 client.verbose = False # Dump activity to terminal
 165 client.serInit( timeout=10 ) # UART comm timeout (in seconds)
 166
 167
 168 # Handle each possible PIC verb in turn
 169
 170 if sys.argv[1] == "devid": #0x81
 171     print "Requesting Application ID, DEVID and hardware revision..."
 172     data = client.writecmd( PICAPP, 0x81, 0 )
 173
 174     if len(data) > 0:
 175         appid = ord(data[0])
 176     else:
 177         appid = -1
 178     if len(data) > 2:
 179         devid = ord(data[1]) + (ord(data[2]) << 8)
 180     else:
 181         devid = -1
 182     if len(data) > 4:
 183         hwrev = ord(data[3]) + (ord(data[4]) << 8)
 184     else:
 185         hwrev = -1
 186     print "Application ID:   0x%02X" % appid
 187     if dev_table.has_key( devid ):
 188         print "DEVID:          0x%04X  (%s)" % ( devid, dev_table[devid] )
 189     else:
 190         print "DEVID:          0x%04X  (unknown)" %  devid
 191     print "revision:       0x%04X"% hwrev
 192     #print "\n(Note that -1 indicates failure to read a value.)"
 193
 194 elif sys.argv[1] == "config": # Dump configuration registers
 195     startICSP()
 196
 197     prep_cmd_li = [0x040200, # GOTO 0x0200
 198                    0x040200, # GOTO 0x0200
 199                    0x000000, # NOP
 200                    0x200F80, # MOV #0x00F8, W0
 201                    0x880190, # MOV W0, TBLPAG
 202                    0xEB0300, # CLR W6
 203                    0x207847, # MOV #VISI, W7
 204                    0x000000] # NOP
 205     rd_cmd_li = [0xBA0BB6, # TBLRDL [W6++], [W7]
 206                  0x000000, # NOP
 207                  0x000000] # NOP
 208     print "Dumping configuration registers..."
 209     for instr in prep_cmd_li:
 210         data = client.writecmd( PICAPP, 0x82, 3, [instr & 0xff,
 211                                                   (instr >> 8) & 0xff,
 212                                                   (instr >> 16) & 0xff] )
 213     for k in range(12): # twelve configuration registers total
 214         for instr in rd_cmd_li:
 215             data = client.writecmd( PICAPP, 0x82, 3, [instr & 0xff,
 216                                                   (instr >> 8) & 0xff,
 217                                                   (instr >> 16) & 0xff] )
 218         result = readVISI()
 219         addr = 0xF80000+k*2
 220         if cfg_table.has_key( addr ):
 221             print "0x%06X (%s): 0x%04X" % ( addr,
 222                                             cfg_table[addr].ljust(cfg_table["width"]),
 223                                             result )
 224         else:
 225             print "0x%06X: 0x%04X" % ( addr, result )
 226
 227     stopICSP()
 228
 229 elif sys.argv[1] == "program":
 230     if len(sys.argv) != 3:
 231         print "Error: an Intel HEX file to load must be given."
 232         exit(1)
 233
 234     try:
 235         proghex = IntelHex( sys.argv[2] )
 236     except IOError:
 237         print "Error while attempting to read from %s" % sys.argv[2]
 238         exit(-1)
 239
 240     wr_pm_li = [0x040200, # GOTO 0x0200
 241                 0x040200, # GOTO 0x0200
 242                 0x000000, # NOP
 243
 244                 0x24003A, # MOV $0x4003, W10
 245                 0x883B0A, # MOV W10, NVMCON
 246
 247                 0x200000,# + ((addr>>12)&0xff0),  # MOV #addr<23:16>, W0
 248                 0x880190, # MOV W0, TBLPAG
 249                 0x200007,# + ((addr&0xffff)<<4), # MOV #addr<15:0>, W7
 250
 251                 # Here we load the instruction into registers W0:W1
 252                 0x200000,# + ((new_words[0]&0xffff)<<4),
 253                 0x200001,# + ((new_words[1]&0xffff)<<4),
 254
 255                 0xEB0300, # CLR W6
 256                 0x000000, # NOP
 257                 0xBB0BB6, # TBLWTL [W6++], [W7]
 258                 0x000000, # NOP
 259                 0x000000, # NOP
 260                 0xBBDBB6, # TBLWTH.B [W6++], [W7++]
 261                 0x000000, # NOP
 262                 0x000000, # NOP
 263
 264                 0xA8E761, # BSET NVMCON, #WR
 265                 0x000000, # NOP
 266                 0x000000, # NOP
 267                 0x000000, # NOP
 268                 0x000000] # NOP
 269
 270     startICSP()
 271
 272     for addr in proghex.addresses():
 273         # Ignore non-aligned steps
 274         if addr % 4 != 0:
 275             continue
 276
 277         # Configuration registers must be treated separately
 278         if (addr>>1) >= 0xf80000 and (addr>>1) <= 0xf80017:
 279             wr_cfg_li = [0x040200, # GOTO 0x0200
 280                          0x040200, # GOTO 0x0200
 281                          0x000000, # NOP
 282                          0x200007 + ((addr<<3)&0xffff0), # MOV #addr<15:0>, W7
 283                          0x24000A, # MOV #0x4000, W10
 284                          0x883B0A, # MOV W10, NVMCON
 285                          0x200F80, # MOV #0xF8, W0
 286                          0x880190, # MOV W0, TBLPAG
 287                          0x200000 + ((proghex[addr]&0x00ff)<<4), # MOV #new_val<7:0>, W0
 288                          0xBB0B80, # TBLWTL W0, [W7]
 289                          0x000000, # NOP
 290                          0x000000, # NOP
 291                          0xA8E761, # BSET NVMCON, #WR
 292                          0x000000, # NOP
 293                          0x000000, # NOP
 294                          0x000000, # NOP
 295                          0x000000] # NOP
 296             runlist( wr_cfg_li )
 297             status = readNVMCON()
 298             while status & 0x8000:
 299                 client.writecmd( PICAPP, 0x82, 3, [0x00,0x00,0x00] )
 300                 status = readNVMCON()
 301             continue
 302
 303         # Build instruction from 3 separate bytes
 304         instr = proghex[addr]
 305         instr |= proghex[addr+1] << 8
 306         instr |= proghex[addr+2] << 16
 307
 308         # Change HEX file address to actual program memory address
 309         addr_pm = addr >> 1
 310
 311         # Program this instruction word
 312         addr_highb_cmd  = 0x200000 + ((addr_pm>>12)&0xff0)
 313         addr_loww_cmd   = 0x200007 + ((addr_pm&0xffff)<<4)
 314         instr_loww_cmd  = 0x200000 + ((instr&0xffff)<<4)
 315         instr_highb_cmd = 0x200001 + ((instr>>12)&0xff0)
 316         runlist( wr_pm_li[:5] + [addr_highb_cmd] + [wr_pm_li[6]]
 317                  + [addr_loww_cmd,
 318                     instr_loww_cmd, instr_highb_cmd]
 319                  + wr_pm_li[10:] )
 320         status = readNVMCON()
 321         while status & 0x8000:
 322             client.writecmd( PICAPP, 0x82, 3, [0x00,0x00,0x00] )
 323             status = readNVMCON()
 324
 325     stopICSP()
 326
 327
 328 elif sys.argv[1] == "verify":
 329     if len(sys.argv) != 3:
 330         print "Error: an Intel HEX file with which to compare must be given."
 331         exit(1)
 332
 333     try:
 334         proghex = IntelHex( sys.argv[2] )
 335     except IOError:
 336         print "Error while attempting to read from %s" % sys.argv[2]
 337         exit(-1)
 338
 339     readpm_cmd_li = [0x040200, # GOTO 0x0200
 340                      0x040200, # GOTO 0x0200
 341                      0x000000, # NOP
 342                      0x200000, # MOV #addr_pm<23:16>, W0
 343                      0x880190, # MOV W0, TBLPAG
 344                      0x200006, # MOV #addr_pm<15:0>, W6
 345                      0xEB0380, # CLR W7
 346                      0xEB0080, # CLR W1
 347                      0x000000, # NOP
 348                      0xBA1B96, # TBLRDL [W6], [W7++]
 349                      0x000000, # NOP
 350                      0x000000, # NOP
 351                      0xBACB96, # TBLRDH.B [W6], [W7]
 352                      0x000000, # NOP
 353                      0x000000] # NOP
 354
 355     print "WARNING: verifying config registers not yet supported."
 356
 357     startICSP()
 358
 359     # Step through addresses in HEX file and compare to those in target PIC
 360     for addr in proghex.addresses():
 361         # Ignore non-aligned steps
 362         if addr % 4 != 0:
 363             continue
 364
 365         # Configuration registers must be treated separately
 366         if (addr>>1) >= 0xf80000 and (addr>>1) <= 0xf80017:
 367             # Need to read datasheets to see which bits are masked.
 368             # Then add dictionary to handle this.
 369             # (Straightforward but tedious.)
 370             continue
 371         else:
 372             # Build instruction from 3 separate bytes
 373             instr = proghex[addr]
 374             instr |= proghex[addr+1] << 8
 375             instr |= proghex[addr+2] << 16
 376
 377         # Change HEX file address to actual program memory address
 378         addr_pm = addr >> 1
 379
 380         runlist( readpm_cmd_li[:3] + [readpm_cmd_li[3]+((addr_pm&0xff0000)>>12)]
 381                  + [readpm_cmd_li[4]] + [readpm_cmd_li[5]+((addr_pm&0xffff)<<4)]
 382                  + readpm_cmd_li[6:] )
 383         loww = readreg(0)  # Read W0, which has lower 16 bits
 384         highb = readreg(1) # Read W1, which has high 8 bits
 385         result = (highb<<16) | loww
 386
 387         # Compare; fail if mismatch
 388         if instr != result:
 389             print "Fail at address 0x%06X: found 0x%06X, expected 0x%06X." % (addr_pm, result, instr )
 390             stopICSP()
 391             exit(-1)
 392
 393     stopICSP()
 394
 395     print "PASSED" # Be verbose.
 396
 397
 398 elif sys.argv[1] == "write":
 399     if len(sys.argv) != 4:
 400         print "Error: an address (in program memory) and\n value (or instruction) to write must be given."
 401         exit(1)
 402
 403     addr = int(float.fromhex(sys.argv[2]))
 404     new_instr = int(float.fromhex(sys.argv[3]))
 405     #new_instr_li = []
 406     #for k in range(4):
 407     #    new_instr_li.append( int(float.fromhex(sys.argv[k+3])) )
 408
 409     #new_words = instr2words( new_instr_li )
 410
 411     wr_pm_li = [0x040200, # GOTO 0x0200
 412                 0x040200, # GOTO 0x0200
 413                 0x000000, # NOP
 414
 415                 0x24003A, # MOV $0x4003, W10
 416                 0x883B0A, # MOV W10, NVMCON
 417                 0x200000 + ((addr>>12)&0xff0),  # MOV #addr<23:16>, W0
 418                 0x880190, # MOV W0, TBLPAG
 419                 0x200007 + ((addr&0xffff)<<4), # MOV #addr<15:0>, W7
 420
 421                 # Here we load the instruction into registers W0:W1
 422                 0x200000 + ((new_instr&0xffff)<<4),
 423                 0x200001 + ((new_instr>>12)&0xff0),
 424                 #0x200000 + ((new_words[0]&0xffff)<<4),
 425                 #0x200001 + ((new_words[1]&0xffff)<<4),
 426                 #0x200002 + ((new_words[2]&0xffff)<<4),
 427                 #0x200003 + ((new_words[3]&0xffff)<<4),
 428                 #0x200004 + ((new_words[4]&0xffff)<<4),
 429                 #0x200005 + ((new_words[5]&0xffff)<<4),
 430
 431                 0xEB0300, # CLR W6
 432                 0x000000, # NOP
 433                 0xBB0BB6, # TBLWTL [W6++], [W7]
 434                 0x000000, # NOP
 435                 0x000000, # NOP
 436                 0xBB8B96, # TBLWTH [W6], [W7]
 437                 #0xBBDBB6, # TBLWTH.B [W6++], [W7++]
 438                 0x000000, # NOP
 439                 0x000000, # NOP
 440                 #0xBBEBB6, # TBLWTH.B [W6++], [++W7]
 441                 #0x000000, # NOP
 442                 #0x000000, # NOP
 443                 #0xBB1BB6, # TBLWTL [W6++], [W7++]
 444                 #0x000000, # NOP
 445                 #0x000000, # NOP
 446                 #0xBB0BB6, # TBLWTL [W6++], [W7]
 447                 #0x000000, # NOP
 448                 #0x000000, # NOP
 449                 #0xBBDBB6, # TBLWTH.B [W6++], [W7++]
 450                 #0x000000, # NOP
 451                 #0x000000, # NOP
 452                 #0xBBEBB6, # TBLWTH.B [W6++], [++W7]
 453                 #0x000000, # NOP
 454                 #0x000000, # NOP
 455                 #0xBB1BB6, # TBLWTL [W6++], [W7++]
 456                 #0x000000, # NOP
 457                 #0x000000, # NOP
 458
 459                 0xA8E761, # BSET NVMCON, #WR
 460                 0x000000, # NOP
 461                 0x000000, # NOP
 462                 0x000000, # NOP
 463                 0x000000] # NOP
 464
 465     startICSP()
 466
 467     runlist( wr_pm_li )
 468     status = readNVMCON()
 469     while status & 0x8000:
 470         client.writecmd( PICAPP, 0x82, 3, [0x00,0x00,0x00] ) # NOP (pump clock)
 471         status = readNVMCON()
 472
 473     stopICSP()
 474
 475 elif sys.argv[1] == "write_config":
 476     if len(sys.argv) < 3:
 477         print "Error: please specify the target config register."
 478         exit(1)
 479     elif len(sys.argv) == 3:
 480         new_val = 0xFF # Assume new value
 481     else:
 482         new_val = int(float.fromhex(sys.argv[3]))
 483     if sys.argv[2] not in cfg_table.values():
 484         print "Given register, %s, not recognized." % sys.argv[2]
 485         exit(1)
 486     reg_addr = cfg_table.keys()[cfg_table.values().index(sys.argv[2])]
 487
 488     wr_cfg_li = [0x040200, # GOTO 0x0200
 489                  0x040200, # GOTO 0x0200
 490                  0x000000, # NOP
 491                  0x200007 + ((reg_addr&0xffff)<<4), # MOV #addr<15:0>, W7
 492                  0x24000A, # MOV #0x4000, W10
 493                  0x883B0A, # MOV W10, NVMCON
 494                  0x200F80, # MOV #0xF8, W0
 495                  0x880190, # MOV W0, TBLPAG
 496                  0x200000 + ((new_val&0xffff)<<4), # MOV #<new_val>, W0
 497                  0xBB0B80, # TBLWTL W0, [W7]
 498                  0x000000, # NOP
 499                  0x000000, # NOP
 500                  0xA8E761, # BSET NVMCON, #WR
 501                  0x000000, # NOP
 502                  0x000000, # NOP
 503                  0x000000, # NOP
 504                  0x000000] # NOP
 505
 506     startICSP()
 507
 508     runlist( wr_cfg_li )
 509     status = readNVMCON()
 510     while status & 0x8000:
 511         client.writecmd( PICAPP, 0x82, 3, [0x00,0x00,0x00] ) # NOP (pump clock)
 512         status = readNVMCON()
 513
 514     stopICSP()
 515
 516
 517 elif sys.argv[1] == "read": # Read an address of program memory
 518     startICSP()
 519
 520     addr = int(float.fromhex(sys.argv[2]))
 521
 522     readpm_cmd_li = [0x040200,                         # GOTO 0x0200
 523                      0x040200,                         # GOTO 0x0200
 524                      0x000000,                         # NOP
 525                      0x200000+((addr & 0xff0000)>>12), # MOV #addr<23:16>, W0
 526                      0x880190,                         # MOV W0, TBLPAG
 527                      0x200006+((addr & 0xffff)<<4),    # MOV #addr<15:0>, W6
 528                      0xEB0380,                         # CLR W7
 529                      0xEB0080,                         # CLR W1
 530                      0x000000,                         # NOP
 531                      0xBA1B96,                         # TBLRDL [W6], [W7++]
 532                      0x000000,                         # NOP
 533                      0x000000,                         # NOP
 534                      0xBACB96,                         # TBLRDH.B [W6], [W7]
 535                      0x000000,                         # NOP
 536                      0x000000]                         # NOP
 537
 538     runlist( readpm_cmd_li )
 539     loww = readreg(0)  # Read W0, which has lower 16 bits
 540     highb = readreg(1) # Read W1, which has high 8 bits
 541     result = (highb<<16) | loww
 542
 543     print "0x%06X: 0x%06X" % ( addr, result )
 544
 545     stopICSP()
 546
 547 elif sys.argv[1] == "dump": # Read section of program memory
 548     if len(sys.argv) < 3:
 549         print "Error: please specify file in which to dump program memory."
 550         exit(1)
 551     fname = sys.argv[2]
 552
 553     if len(sys.argv) == 6:
 554         print_term = True
 555     else:
 556         print_term = False
 557
 558     if len(sys.argv) > 4:
 559         start_addr = int(float.fromhex(sys.argv[3]))
 560         stop_addr  = int(float.fromhex(sys.argv[4]))
 561     else:
 562         # Assume all of program memory (including unimplemented sections,
 563         # which will be read as zeroes.
 564         start_addr = 0x0
 565         stop_addr = 0xFFFFFE #
 566
 567     readpm_cmd_li = [0x200000,                         # MOV #addr<23:16>, W0
 568                      0x880190,                         # MOV W0, TBLPAG
 569                      0x200006,                         # MOV #addr<15:0>, W6
 570                      0xEB0380,                         # CLR W7
 571                      0xEB0080,                         # CLR W1
 572                      0x000000,                         # NOP
 573                      0xBA1B96,                         # TBLRDL [W6], [W7++]
 574                      0x000000,                         # NOP
 575                      0x000000,                         # NOP
 576                      0xBACB96,                         # TBLRDH.B [W6], [W7]
 577                      0x000000,                         # NOP
 578                      0x000000]                         # NOP
 579
 580     dumphex = IntelHex()
 581
 582     startICSP()
 583
 584     print "Reading program memory 0x%06X:0x%06X ..." % ( start_addr, stop_addr )
 585     # Prep device
 586     client.writecmd( PICAPP, 0x82, 3, [0x00,0x02,0x04] ) #GOTO 0x200 (reset)
 587     client.writecmd( PICAPP, 0x82, 3, [0x00,0x02,0x04] ) #GOTO 0x200 (reset)
 588     client.writecmd( PICAPP, 0x82, 3, [0x00,0x00,0x00] ) #NOP (pump clock)
 589     for addr in range( start_addr, stop_addr+2, 2 ):
 590         specify_addr_cmd = [readpm_cmd_li[0] + ((addr & 0xff0000)>>12),
 591                             readpm_cmd_li[1],
 592                             readpm_cmd_li[2] + ((addr & 0xffff)<<4)]
 593         runlist( specify_addr_cmd + readpm_cmd_li[3:] )
 594         loww = readreg(0)  # Read W0, which has lower 16 bits
 595         highb = readreg(1) # Read W1, which has high 8 bits
 596         result = (highb<<16) | loww
 597         dumphex.puts( (addr&0xffffff)*2,
 598                       chr(result&0xff)+chr((result>>8)&0xff)+chr((result>>16)&0xff)+chr(0) )
 599         if print_term:
 600             print "0x%06X    0x%06X" % (addr,result)
 601
 602     if not print_term:
 603         if fname == "-":
 604             dumphex.tofile( sys.stdout, format="hex" )
 605         else:
 606             dumphex.tofile( fname, format="hex" )
 607
 608     stopICSP()
 609
 610 elif sys.argv[1] == "erase": # Bulk erase (all program memory)
 611
 612     if len(sys.argv) == 3:
 613         addr = int(float.fromhex(sys.argv[2]))
 614     else:
 615         addr = None
 616
 617     if addr is None: # Bulk erase (all of program memory)
 618         erase_cmd_li = [0x040200, # GOTO 0x0200
 619                         0x040200, # GOTO 0x0200
 620                         0x000000, # NOP
 621                         0x2404FA, # MOV $0x404F, W10
 622                         0x883B0A, # MOV W10, NVMCON
 623                         0xA8E761, # BSET NVMCON, #WR
 624                         0x000000, # NOP
 625                         0x000000, # NOP
 626                         0x000000, # NOP
 627                         0x000000] # NOP
 628     else: # Page erase
 629         erase_cmd_li = [0x040200, # GOTO 0x0200
 630                         0x040200, # GOTO 0x0200
 631                         0x000000, # NOP
 632                         0x24042A, # MOV $0x4042, W10
 633                         0x883B0A, # MOV W10, NVMCON
 634                         0x200000+((addr & 0xff0000)>>12), # MOV #addr<23:16>, W0
 635                         0x880190, # MOV W0, TBLPAG
 636                         0x200001+((addr&0xffff)<<4), # MOV 0x0, W1
 637                         0x000000, # NOP
 638                         0xBB0881, # TBLTWL W1, [W1]
 639                         0x000000, # NOP
 640                         0x000000, # NOP
 641                         0xA8E761, # BSET NVMCON, #WR
 642                         0x000000, # NOP
 643                         0x000000, # NOP
 644                         0x000000, # NOP
 645                         0x000000] # NOP
 646         # Note that page alignment (effectively, bitmask of 0xffff80
 647         # applied to given program memory address) seems to be
 648         # enforced by hardware.
 649
 650     startICSP()
 651
 652     runlist( erase_cmd_li )
 653     status = readNVMCON()
 654     while status & 0x8000:
 655         client.writecmd( PICAPP, 0x82, 3, [0x00,0x00,0x00] ) # NOP (pump clock)
 656         status = readNVMCON()
 657
 658     stopICSP()
 659
 660 elif sys.argv[1] == "six": #0x82
 661     startICSP()
 662
 663     if len(sys.argv) < 3:
 664         instr = 0x000000 # Assume nop
 665     else:
 666         instr = int(float.fromhex(sys.argv[2]))
 667     print "Loading 0x%06X for execution..." % instr
 668     data = client.writecmd( PICAPP, 0x82, 3, [instr & 0xff,
 669                                        (instr >> 8) & 0xff,
 670                                        (instr >> 16) & 0xff] )
 671     print "Executing (by loading nop; pumping clock)..."
 672     data = client.writecmd( PICAPP, 0x82, 3, [0x00,0x00,0x00] )
 673
 674     dumpVISI()
 675
 676     stopICSP()
 677
 678 elif sys.argv[1] == "sixfile": #0x82 (repeated for each instruction in file)
 679     startICSP()
 680
 681     if len(sys.argv) < 3:
 682         print "Warning: no file given; trying cmd.txt..."
 683         fname = "cmd.txt"
 684     else:
 685         fname = sys.argv[2]
 686
 687     try:
 688         instrfile = open( fname, "r" )
 689     except:
 690         print "Failed to open file %s for reading." % fname
 691         exit(-1)
 692
 693     try:
 694         print "Opened file %s. Consecutively reading commmands..." % fname
 695         for line in instrfile:
 696             words = line.split()
 697             if len(words) > 0:
 698                 try:
 699                     instr = int(float.fromhex(words[0]))
 700                 except ValueError:
 701                     print "Warning: invalid instruction found at offset %d." % instrfile.tell()
 702                     continue
 703                 print "Loading 0x%06X for execution..." % instr
 704                 data = client.writecmd( PICAPP, 0x82, 3, [instr & 0xff,
 705                                                    (instr >> 8) & 0xff,
 706                                                    (instr >> 16) & 0xff] )
 707             #else:
 708             #    print "Warning: empty line found at offset %d." % instrfile.tell()
 709     except:
 710         print "Error: exception caught while reading file %s." % fname
 711         instrfile.close()
 712         stopICSP()
 713         exit(-1)
 714
 715     instrfile.close()
 716
 717     print "Loading nop, pumping clock (to finish execution)..."
 718     data = client.writecmd( PICAPP, 0x82, 3, [0x00,0x00,0x00] )
 719
 720     dumpVISI()
 721
 722     stopICSP()
 723
 724 elif sys.argv[1] == "regout": #0x83
 725     startICSP()
 726
 727     print "Reading VISI register..."
 728     data = client.writecmd( PICAPP, 0x83, 0 )
 729     result = ord(data[0])
 730     result |= ord(data[1]) << 8
 731     print "VISI: 0x%04X" % result
 732
 733     stopICSP()
 734
 735 else:
 736     print "Unrecognized verb: %s" % sys.argv[1]
 737     sys.exit(-1)
 738