kick.c

Go to the documentation of this file.

/******************************************************************/
//parallax propside workspace: 'Simple Libraries'
#include "simpletext.h"
#include "simpletools.h"
 
//additional parallax propeller-elf headers
#include <ctype.h>
 
//project headers
#include "libprop/putChar.h"
#include "libcommon/common.h"
#include "libcommon/serial-codes.h"
#include "libcommon/filespec.h"
#include "libSPI/SPI-command-set.h"
#include "libSPI/SPI-flash-bits.h"
#include "libkick/proppins.h"
#include "libkick/chipspec.h"
#include "libkick/key-enable-bits.h"
#include "libkick/fast-SPI.h"
#include "kick.h"                         //include macro defs, type defs and func prototypes
 
//project source files
#include "libprop/putChar.c"              //modified putChar()
#include "libcommon/hexdigit2bin.c"
#include "libcommon/bin2hexdigit.c"
#include "libcommon/filespec.c"           //file format database
#include "libkick/chipspec.c"             //chip database
 
//globals, will be patched by propeller-load
int _cfg_modeterminal = -1;               
int _cfg_rstdisable = -1;                 
int _cfg_baudrate = -1;                   
 
//globals
unsigned char cmd_CE = CMD__CE_0X60;      
struct tag_xcog0 xcog0;                   
struct tag_xcog1 xcog1;                   
enum tag_spimode spimode = mode_3;        
struct tag_chip chip = { 0, chipspec };
struct tag_filespec * pfspec;             
 
 
 
/******************************************************************/
int main(void) {
  //setup ledstat():
  xcog1.yellow = ON;
  xcog1.inlevel = 0;
  cog_run(&ledstat, STACK_LEDSTAT);
 
  //SPI-Bus ini: SPI-Bus is off
  xcog1.green = ON;    //indicate status: SPI-Bus is off
 
  //disable RST
  if(_cfg_rstdisable > 0) {
    high(RST_DISABLE);  //disable RST
    xcog1.orange = ON;
  }
 
  //reconfigure simpleterm
  if(_cfg_baudrate != BAUDRATE_DEFAULT)
    simpleterm_reopen(PIN_RX, PIN_TX, 0, _cfg_baudrate);
 
  //data initialisation
  chip_ini(CHIPSPEC_DEFAULT);
  pfspec = &(filespec[MOTBIN]);
 
  //Do we talk to connect or to a propeller-terminal?
  if(_cfg_modeterminal > 0) {   //terminal mode?
    greeting();
    connected();
    if(plug_detect()) {
      outstr("Terminal Mode. Using reduced set of keys.\r\n");
      menu(MODE_TERMINAL);   //call menu
    }
  }
  else {  //normal connect mode
    char k;           //used for initial handshake
    outfifo(ENQ);     //request trigger (if not already on the way)
    k = getChar();    //receive (any) trigger
 
    //enable RST
    _cfg_rstdisable = 0;
    low(RST_DISABLE);
    xcog1.orange = OFF;
 
    if(k == ACK) {  //connect has replied
      greeting();
      connected();
      if(plug_detect()) {
        outstr("\r\n");
        menu(MODE_CONNECT);    //call menu
      }
    }
  }
 
  //end of program
  SPI_OFF(MODE_SPI_OFF);
  OUTA |= BIT_PNP_DEVICE;   //disable pnp device, make sure SPI-Bus is off
  outstr("You may now switch off the chipflasher board.\r\n");
  for(int n = 3; n; n--) {
    exit_sequence(0x00);  //this is understood by both, connect _and_ propeller-terminal
    usleep(200000);
  }
  while(1);   //hang-up
  return(0);  //normal quit
}
 
 
 
void connected (
  void
  )
{
  char s[SIZE_STR_MESSAGE];
  sprinti(s, "%s%d%s", "Connected with ", _cfg_baudrate, " baud.\r\n");
  outstr(s);
}
 
 
 
void mirror (
  char * keymsg
  )
{
  outstr("\r\n");
  outstr(keymsg);
  outstr("...\r\n");
}
 
 
 
void option_readblock (
  const enum tag_blocksize blocksize
  )
{
  char s[SIZE_STR_MESSAGE];
  unsigned int blocks;
 
  //setup
  blocks = chip.pspec->chipsize / blocksize;
 
  //more input
  unsigned int block_to_read;
  xcog1.inlevel++;
  sprinti(s, "Block to read (hex 0..%x): ", blocks - 1);
  outstr(s);
  block_to_read = getHex();
 
  //catch range errors
  if(block_to_read >= blocks) {
    range_error();
    return;
  }
 
  //more input
  unsigned char mode_screen_output;
  mode_screen_output = yes_no("Do you need output on screen", 0) << 7;
 
  //action
  SPI_ON;
  chip_txfile(
    pfspec,
    chip.addrlen_in_bits,
    block_to_read * blocksize,
    blocksize,
    mode_screen_output
    );
  SPI_OFF(MODE_SPI_OFF);
}
 
 
 
/******************************************************************/
int do__WIP_polling(
  void
  )
{
  int r = WIP_polling();
  if(r > MAX_POLLING) {
    outstr("WIP_polling overflow.\r\n");
    return -1;
  }
  else {
    char s[SIZE_STR_MESSAGE];
    sprinti(s, "WIP_polling: %d\r\n", r);
    outstr(s);
  }
  return 0; //success
}
 
 
 
/******************************************************************/
void range_error(
  void
  )
{
  xcog1.inlevel = 0;
  outstr("Out of range error!\r\n");
}
 
 
 
/******************************************************************/
void option_batchblockerase(
  const enum tag_blocksize blocksize,
  const unsigned char blockcmd
  )
{
  char s[SIZE_STR_MESSAGE];
  unsigned int first_block;
  unsigned int last_block;
  unsigned int blocks;
 
  //setup
  blocks = chip.pspec->chipsize / blocksize;
 
  //more input
  xcog1.inlevel++;
  sprinti(s, "First block to erase (hex 0..%x): ", blocks - 1);
  outstr(s);
  first_block = getHex();
 
  //catch out of range error
  if(first_block >= blocks) {
    range_error();
    return;
  }
 
  //more input
  xcog1.inlevel++;
  sprinti(s, "Last block to erase (hex %x..%x): ", first_block, blocks - 1);
  outstr(s);
  last_block = getHex();
 
  //catch out of range error
  if( (last_block >= blocks) ||
      (last_block < first_block)  ) {
    range_error();
    return;
  }
 
  //check for dry-run
  check_dryrun();
 
  //action
  if(yes_no("Sure to proceed", 0)) {
    SPI_ON;
    while(first_block <= last_block) {
      unsigned int firstloc;
 
      firstloc = first_block * blocksize;
      WPn_HIGH;
      cmd_WREN();
      CHIP_ON;
      cmd(blockcmd, firstloc, chip.addrlen_in_bits);
      CHIP_OFF;
      WPn_LOW;
 
      sprinti(s, "Block 0x%x... ", first_block++);
      outstr(s);
      if(!do__WIP_polling()) {
        outstr("verifying...\r\n");
        if(verify_0xff(firstloc, blocksize)) {
          outstr("Verify error!\r\n");
          break;
        }
      }
      else
        break;
    }
  }
  SPI_OFF(MODE_SPI_OFF);  //check_dryrun() has left SPI Bus in standby mode
}
 
 
 
/******************************************************************/
void SR_intro(
  unsigned char regno
  )
{
  char s[SIZE_STR_MESSAGE];
  sprinti(s,  "\r\n" \
              "SR%d:\r\n" \
              , regno + 1);
  outstr(s);
}
 
 
 
/******************************************************************/
void global_sector_protect (
  unsigned char pswitch
  )
{
  xcog1.inlevel = 0;
  if(yes_no("Sure to proceed", 0)) {
    SPI_ON;
    WPn_HIGH;
 
    //any address within sector will do
    for(unsigned int addr = chip.pspec->chipsize; addr; addr -= SIZE_4K) {
      cmd_WREN();
      CHIP_ON;
      pswitch == OFF ? \
        cmd(CMD__US, addr - 1, 24) : \
        cmd(CMD__PS, addr - 1, 24);
      CHIP_OFF;
      WIP_polling();
    }
    WPn_LOW;
    SR_report(0);
    SPI_OFF(MODE_SPI_OFF);
  }
}
 
 
 
/******************************************************************/
void key_polling(
  unsigned char * key_is_valid,
  unsigned char * quit
  )
{
  char keyinput;
  int keyid = 0;
 
  keyinput = getChar();
  while((keymsg[keyid][1] != keyinput) &&
        (keymsg[keyid][3] != keyinput || keyinput == ' ') &&
        (keyid != ID_NONE))
    keyid++;
 
  if(!(keyreg & (1 << keyid))) {
    *key_is_valid = 0;
  }
  else {
    mirror(keymsg[keyid]);
 
    switch(keyinput) {
      //key active by default
      case 'q':   //quit
        {
          //action
          if(DIRA & BIT_PNP_DEVICE) {
            SPI_OFF(MODE_FORCE_SPI_OFF);
            outstr("The SPI bus has been powered off.\r\n");
            //TODO: Why do we have to reset the chip index?
            chip_ini(CHIPSPEC_DEFAULT);
            filespec_ini(chip.pspec->chipsize);
          }
          else {
            xcog1.inlevel = 0;
            *quit = 1;
            xcog1.green = ON;  //restore LED
          }
        }
        break;
 
      //key active by default
      case 't':   //toggle output format
        {
          //action
          xcog1.inlevel = 0;
          if(pfspec == &(filespec[MOTBIN]))
            pfspec = &(filespec[HEXDUMP]);
          else
            pfspec--;
        }
        break;
 
      case 'W': {   //set config
        char s[SIZE_STR_MESSAGE];
        unsigned char byte = 0;
        unsigned char m = 8;
        unsigned char bit;
        unsigned char max_regno = 0;
        unsigned char regno = 0;
        unsigned char bitmask;
        char* p;
 
        if(chip.pspec->cmdset & (1 << X35_RDSR2))
          max_regno = 1;
        if(chip.pspec->cmdset & (1 << X15_RDSR3))
          max_regno = 2;
 
        if(max_regno > 0) {
          xcog1.inlevel++;
          sprinti(s, "Which config register to change (%d..%d)? ", 1, max_regno + 1);
          outstr(s);
          regno = getDec() - 1;
          if(regno < 0 || regno > max_regno) {
            range_error();
            break;
          }
        }
        bitmask = chip.pspec->sr_wrmask[regno];
        p = chip.pspec->sr_bitnames[regno];
 
        SPI_ON;
        byte = SR_report(regno);
        SPI_OFF(MODE_SPI_OFF);
        xcog1.inlevel++;
        SR_intro(regno);
        outstr( "Bitname\tBit\tStatus\tValue?\r\n" \
                "-------\t---\t------\t------\r\n" \
                );
        while(*p != '\0') {
          outfifo(*p);
          if(*p == '\t') {
            char cstat;
            outfifo('0' + --m);
            outstr(":\t");  //trigger permanent flush with ':'.
            bit = 1 << m;
            cstat = byte & bit ? '1' : '0';
            outfifo(cstat);
            outfifo('\t');
            if(bitmask & bit) {
              unsigned char in;
              in = getChar();
              if(in == '0') {
                outfifo('0');
                byte &= ~bit;
              }
              else if(in == '1') {
                outfifo('1');
                byte |= bit;
              }
              else {
                outfifo(cstat);
              }
            }
            else {
              outfifo('x');
            }
            outstr("\r\n");
          }
          p++;
        }
        sprinti(s, "New register value would be: %d\r\n", byte);
        outstr(s);
        //action
        if(yes_no("Sure to proceed", 0)) {
          SPI_ON;
          WPn_HIGH;
          cmd_WRSR(regno, byte);
          sprinti(s, "polling checks: %d\r\n", WIP_polling());
          outstr(s);
          WPn_LOW;
          SR_report(regno);
          SPI_OFF(MODE_SPI_OFF);
        }
      }
      break;
 
      case 'r':   //show config
        {
          //action
          xcog1.inlevel = 0;
          SPI_ON;
          SR_report(0);
          if(chip.pspec->cmdset & (1 << X35_RDSR2))
            SR_report(1);
          if(chip.pspec->cmdset & (1 << X15_RDSR3))
            SR_report(2);
          SPI_OFF(MODE_SPI_OFF);
        }
        break;
 
      case 'G':   //global sector protect
        global_sector_protect(ON);
        break;
 
      case 'X':   //global sector unprotect
        global_sector_protect(OFF);
        break;
 
      //key active by default
      case 'f':   //force chip model
        {
          //action
          xcog1.inlevel = 0;
          if(!chip.index)
            chip_ini(ARRAY_CHIPSPEC - 1);
          else
            chip_ini(chip.index - 1);
          filespec_ini(chip.pspec->chipsize);
        }
        break;
 
      //key active by default
      case 'd':   //detect chip
        {
          char s[SIZE_STR_MESSAGE];
 
          //JEDEC__RDID (should be the first command to use)
          xcog1.inlevel = 0;
          unsigned char powerup_extra = POWERUP_EXTRA;
          int id_JEDEC;
 
          //power up
          do {
            SPI_ON;
            if(!(id_JEDEC = cmd_RDID_JEDEC())) {
              SPI_OFF(MODE_FORCE_SPI_OFF);
              usleep(POWERUP_OFFTIME);
            }
            else
              break;
          } while(powerup_extra--);
 
          //set chip
          if(powerup_extra == 0xff) {
            outstr("Power failure? Clip attached?\r\n");
          }
          else {
            struct tag_chipspec * check = chip.pspec - chip.index;
            unsigned char i = 0;
            while(i < ARRAY_CHIPSPEC) {
              if((check->cmdset & (1 << X9F_RDID)) && id_JEDEC == check->id_JEDEC)
                break;
              i++;
              check++;
            }
            if(i == ARRAY_CHIPSPEC) {   //no match occured
              outstr("No match in database.\r\n");
              sprinti(s, "Chip's JEDEC ID: 0x%06x\r\n", id_JEDEC);
              outstr(s);
              SPI_OFF(MODE_FORCE_SPI_OFF);
            }
            else {
              chip_ini(i);
              filespec_ini(chip.pspec->chipsize);
              sprinti(s, "Chip successfully detected: %s\r\n", chip.pspec->name);
              outstr(s);
              if(!chip.pspec->sr_is_static)
                outstr("NOTE: The Status Register is not static, the SPI bus is kept powered until you quit.\r\n");
              if(chip.pspec->id_JEDEC == 0x00ef3013)
                outstr("NOTE: You may set bit SRP in the status register to enable #WP control.\r\n");
              SPI_OFF(MODE_SPI_OFF);
            }
          }
        }
        break;
 
      case 'p':   //read page
        {
          //get more input
          char s[SIZE_STR_MESSAGE];
          unsigned int page_to_read;
          xcog1.inlevel++;
          sprinti(s, "Page to read (hex 0..%x): ", chip.pages - 1);
          outstr(s);
          page_to_read = getHex();
 
          //catch range error
          if(page_to_read >= chip.pages) {
            range_error();
            break;
          }
 
          //more input
          unsigned char mode_screen_output;
          mode_screen_output = yes_no("Do you need output on screen", 0) << 7;
 
          //action
          unsigned int firstloc;
          SPI_ON;
          firstloc = page_to_read * chip.pspec->pagesize;
          chip_txfile(
            pfspec,
            chip.addrlen_in_bits,
            firstloc,
            chip.pspec->pagesize,
            mode_screen_output
            );
          SPI_OFF(MODE_SPI_OFF);
        }
        break;
 
      case 'm':   //read random area
        {
          //more input
          char s[SIZE_STR_MESSAGE];
          unsigned int startaddr;
          xcog1.inlevel++;
          sprinti(s, "Startaddress (hex 0..%08x): ", chip.pspec->chipsize - 1);
          outstr(s);
          startaddr = getHex();
 
          //catch error
          if(startaddr >= chip.pspec->chipsize) {
            range_error();
            break;
          }
 
          //more input
          unsigned int lastaddr;
          xcog1.inlevel++;
          sprinti(s, "Last address (hex %08x..%08x): ", startaddr, chip.pspec->chipsize - 1);
          outstr(s);
          lastaddr = getHex();
 
          //catch error
          if(lastaddr >= chip.pspec->chipsize) {
            range_error();
            break;
          }
 
          //more input
          unsigned char mode_screen_output;
          mode_screen_output = yes_no("Do you need output on screen", 0) << 7;
 
          //action
          SPI_ON;
          chip_txfile(
            pfspec,
            chip.addrlen_in_bits,
            startaddr,
            lastaddr - startaddr + 1,
            mode_screen_output
            );
          SPI_OFF(MODE_SPI_OFF);
        }
        break;
 
      case 's':   //read block 4k
        option_readblock(BLOCK_4K);
        break;
 
      case 'k':   //read block 32k
        option_readblock(BLOCK_32K);
        break;
 
      case 'b':   //read block 64k
        option_readblock(BLOCK_64K);
        break;
 
      case 'c':   //read chip
        {
          //more input
          unsigned char mode_screen_output;
          mode_screen_output = yes_no("Do you need output on screen", 0) << 7;
 
          //action
          SPI_ON;
          chip_txfile(
            pfspec,
            chip.addrlen_in_bits,
            0x00,
            chip.pspec->chipsize,
            mode_screen_output
            );
          SPI_OFF(MODE_SPI_OFF);
        }
        break;
 
      case 'S':   //4k block erase
        option_batchblockerase(BLOCK_4K, CMD__SE);
        break;
 
      case 'K':   //erase block 32k
        option_batchblockerase(BLOCK_32K, CMD__BE32K);
        break;
 
      case 'B':   //erase block 64k
        option_batchblockerase(BLOCK_64K, CMD__BE64K);
        break;
 
      case 'C':   //erase chip
        {
          //action
          if(yes_no("Sure to proceed", 0)) {
            SPI_ON;
            chip_erase();
            outstr("verifying...\r\n");
            if(verify_0xff(0x00, chip.pspec->chipsize) != 0)
              outstr("Verify error!\r\n");
            SPI_OFF(MODE_SPI_OFF);
          }
        }
        break;
 
      case 'I':   //write file to chip
        {
          //more input
          unsigned char screen_output;
          screen_output = yes_no("Do you need output on screen", 1);
 
          //check for dry-run
          check_dryrun();
 
          //action
          if(yes_no("Sure to proceed", 0))
            chip_rxfile(&xcog0, screen_output);
          else
            SPI_OFF(MODE_SPI_OFF);
        }
        break;
 
      default:
        *key_is_valid = 0;
    }
    if(key_is_valid)
      outstr(MSG_DONE);
  }
}
 
 
 
/******************************************************************/
void check_dryrun(
  void
  )
{
  //check for dry-run
  unsigned char sr;
  SPI_ON;
  sr = cmd_RDSR(CMD__RDSR);
 
  if(chip.pspec->id_JEDEC == 0x00ef3013)
    sr &= 0b01111111;   //don't care for SRP
 
  if(sr & chip.pspec->sr_wrmask[0]) {
    outstr("Be aware: The Status Register 1 is not zero, some memory areas may be write protected.\r\n");
  }
  SPI_OFF(MODE_SPI_OFF);
}
 
 
 
/******************************************************************/
int plug_detect(
  void
  )
{
  if(input(PIN_PLUGTESTn)) {
    outstr("No SPI-plug detected!\r\n");
    return(0);
  }
  else {
    outstr("SPI-plug seems to be attached.\r\n");
    return(1);
  }
}
 
 
 
/******************************************************************/
void menu(
  unsigned char mode
  )
{
  char s[SIZE_STR_MESSAGE];
  unsigned char quit = 0;
  unsigned char key_is_valid = 1;
 
  while(!quit) {
    if(key_is_valid) {
      //set key
      keyreg = KEYREG_DEFAULT;
      if(mode & MODE_CONNECT)
        key_config();
 
      //greeting
      greeting();
 
      //status line 1
      sprinti(s, "Chip: %s", chip.pspec->name);
      outstr(s);
      sprinti(s, "\r\t\t\t\tFormat: %s", pfspec->format_name);
      outstr(s);
      {
        unsigned char mode_0xff = pfspec->mode_0xff;
        outstr("\r\t\t\t\t\t\t\t\t0xFF: ");
        outstr(mode_0xff & MODE_SPLIT ? "split, " : "");
        outstr(mode_0xff & MODE_STRIP ? "strip, " : "");
        sprinti(s, "inline_%d\r\n", mode_0xff & 0b00011111);
        outstr(s);
      }
 
      //menu
      menu_options();
      outstr("Your Choice? ");
    }
    else
      key_is_valid = 1;
 
    //key polling
    xcog1.inlevel = 1;
    key_polling(&key_is_valid, &quit);
    xcog1.inlevel = 0;
  }
}
 
 
 
/******************************************************************/
void hr(
  char c,
  int n,
  char nl
  )
{
  while(n--)
    outfifo(c);
  if(nl != NULL)
    outstr("\r\n");
}
 
 
 
/******************************************************************/
unsigned char get_addrlen(
  enum tag_type_of_addrlen type_of_addrlen,
  unsigned int addr
  )
{
  unsigned char addrlen_in_bytes;
 
  if(addr < SIZE_256) {
    if(type_of_addrlen == ADDRLEN_MOT)
      addrlen_in_bytes = 2;
    else
      addrlen_in_bytes = 1;
  }
  else if(addr < SIZE_64K)
    addrlen_in_bytes = 2;
  else if(addr < SIZE_128MBIT)
    addrlen_in_bytes = 3;
  else
    addrlen_in_bytes = 4;
 
  if(type_of_addrlen == ADDRLEN_IN_BITS)
    return(addrlen_in_bytes << 3);
  return(addrlen_in_bytes);
}
 
 
 
/******************************************************************/
void key_config(
  void
  )
{
  if(chip.pspec->cmdset & (1 << X03_READ)) {
    unsigned int reg = keyreg;
 
    //enable 'fetch file and write chip'
    if((chip.pspec->cmdset & (1 << X02_PP)) ||
        (chip.pspec->cmdset & (1 << X02_BP)) ||
        (chip.pspec->cmdset & (1 << XAD_CP)))
      reg |= KEYBIT_I;
 
    //enable 'read page'
    if(chip.pspec->cmdset & (1 << X02_PP))
      reg |= KEYBIT_p;
 
    //enable 'sector erase'
    if(chip.pspec->cmdset & (1 << X20_SE))
      reg |= KEYBIT_s | KEYBIT_S;
 
    //read block 32k
    //erase block 32k
    if(chip.pspec->cmdset & (1 << X52_BE32K))
      reg |= KEYBIT_k | KEYBIT_K;
 
    //read block 64k
    //erase block 64k
    if(chip.pspec->cmdset & (1 << XD8_BE64K))
      reg |= KEYBIT_b | KEYBIT_B;
 
    reg |= KEYBIT_c | KEYBIT_m;
 
    //enable 'erase chip'
    if(chip.pspec->cmdset & (1 << X60_CE)) {
      reg |= KEYBIT_C;
    }
    else if(chip.pspec->cmdset & (1 << XC7_CE)) {
      reg |= KEYBIT_C;
      cmd_CE = CMD__CE_0XC7;  //override global CE command
    }
 
    //enable 'report status register'
    if(chip.pspec->cmdset & (1 << X05_RDSR))
      reg |= KEYBIT_r;
 
    //enable 'write block protection bits'
    if(chip.pspec->cmdset & (1 << X01_WRSR))
      reg |= KEYBIT_W;
 
    //enable 'global protect'
    if(chip.pspec->cmdset & (1 << X36_PS))
      reg |= KEYBIT_G;
 
    //enable 'global unprotect'
    if(chip.pspec->cmdset & (1 << X39_US))
      reg |= KEYBIT_X;
 
    keyreg = reg;
  }
}
 
 
 
/******************************************************************/
void menu_line(
  unsigned int k1,
  char * k1msg,
  unsigned int k2,
  char * k2msg,
  unsigned int k3,
  char * k3msg
  )
{
  if(keyreg & (k1 | k2 | k3)) {
    if(keyreg & k1)
      outstr(k1msg);
    if(keyreg & k2) {
      outstr("\r\t\t\t\t");
      outstr(k2msg);
    }
    if(keyreg & k3) {
      outstr("\r\t\t\t\t\t\t\t\t");
      outstr(k3msg);
    }
    outstr("\r\n");
  }
}
 
 
 
/******************************************************************/
void menu_options(
  void
  )
{
  hr('-', MENUWIDTH, '\n');
  menu_line(
    KEYBIT_d, keymsg[KEYID_d],
    KEYBIT_t, keymsg[KEYID_t],
    KEYBIT_f, keymsg[KEYID_f]
    );
  menu_line(
    KEYBIT_r, keymsg[KEYID_r],
    KEYBIT_p, keymsg[KEYID_p],
    KEYBIT_m, keymsg[KEYID_m]
    );
  menu_line(
    KEYBIT_W, keymsg[KEYID_W],
    KEYBIT_G, keymsg[KEYID_G],
    KEYBIT_X, keymsg[KEYID_X]
    );
  menu_line(
    KEYBIT_s, keymsg[KEYID_s],
    KEYBIT_k, keymsg[KEYID_k],
    KEYBIT_b, keymsg[KEYID_b]
    );
  menu_line(
    KEYBIT_S, keymsg[KEYID_S],
    KEYBIT_K, keymsg[KEYID_K],
    KEYBIT_B, keymsg[KEYID_B]
    );
  menu_line(
    KEYBIT_c, keymsg[KEYID_c],
    KEYBIT_C, keymsg[KEYID_C],
    KEYBIT_I, keymsg[KEYID_I]
    );
  menu_line(
    KEYBIT_q, keymsg[KEYID_q],
    0, NULL,
    0, NULL
    );
}
 
 
 
/******************************************************************/
unsigned char verify_0xff(
  unsigned int firstloc,
  unsigned int memsize
  )
{
  unsigned char err = 0;
 
  CHIP_ON;
  cmd(CMD__READ, firstloc, chip.addrlen_in_bits);
  while(memsize--) {
    if(inb() != 0xff) {
      err = 1;
      break;
    }
  }
  CHIP_OFF;
  return err;
}
 
 
 
/******************************************************************/
void MOT_mkline(
  struct tag_linedat * linedat,
  union tag_typeS * typeS,
  char * linebuf
  )
{
  unsigned char checksum;
  unsigned char v;
  unsigned char n;
 
  //make sure struct is filled up
  MOT_typeS_fillup(typeS);
 
  //store datalength in first location, line ending is CR+NL
  *linebuf++ = 4 + (typeS->bf.addrlen << 1) + linedat->payload + 4;
 
  //print Sn... (2 bytes)
  linebuf += sprinti(linebuf, "S%01d", typeS->bf.num);
 
  //print length (2 bytes)
  v = typeS->bf.addrlen + linedat->payload + 1;
  linebuf += sprinti(linebuf, "%02x", v);
  checksum = v;  //start summing checksum
 
  //print address (4..8 bytes)
  n = typeS->bf.addrlen;
  while(n--) {
    v = (linedat->startaddr >> (n << 3)) & 0xff;
    linebuf += sprinti(linebuf, "%02x", v);
    checksum += v;
  };
 
  //print data (n bytes)
  n = linedat->payload;
  linedat->startaddr += n;  //update startaddress
  while(n--) {
    char byte = linedat->buf[linedat->rd++ & linedat->mask];
    *linebuf++ = byte;
    checksum += byte;
  };
 
  //print checksum (2 bytes) and CR+NL (2 bytes)
  sprinti(linebuf, "%02x\r\n", ~checksum & 0xff);
}
 
 
 
/******************************************************************/
int strpos(
  char * str,
  char c
  )
{
  int n = 0;
  char * p = str;
 
  while((*(p++) != c) && (n < SIZE_STRBUF))
    n++;
  return n;
}
 
 
 
/******************************************************************/
void MOT_header(
  char * header,
  char * linebuf
  )
{
  struct tag_linedat linedat = {
    header,                 //buf: characters are stored in header
    0xff,                   //mask: allow 0..255 characters
    0,                      //rd: reset to zero
    0,                      //wr: reset to zero
    0x0000,                 //startaddr: 0x0000
    strpos(header, '\0')    //payload: length of header string
  };
  union tag_typeS typeS = {
    0   //typeS.bf.addrlen is 0x00, typeS.num is 0x00; MOT_typeS_fillup() will
        //result in an S0 record.
  };
  MOT_mkline(&linedat, &typeS, linebuf);
}
 
 
 
/******************************************************************/
void MOT_data (
  struct tag_linedat * linedat,
  char * linebuf
)
{
  union tag_typeS typeS = { 0 };
  typeS.bf.data = 1;
  typeS.bf.addrlen = get_addrlen(ADDRLEN_MOT, linedat->startaddr);
  MOT_mkline(linedat, &typeS, linebuf);
}
 
 
 
/******************************************************************/
void MOT_summary (
  unsigned int lines,
  char * linebuf
  )
{
  struct tag_linedat r = { NULL, 0, 0, 0, lines, 0 };
  union tag_typeS typeS = { 0 };
  typeS.bf.linecount = 1;
  typeS.bf.addrlen = get_addrlen(ADDRLEN_MOT, lines);
  MOT_mkline(&r, &typeS, linebuf);
}
 
 
 
/******************************************************************/
unsigned char yes_no (
  char * question,
  unsigned char level_rst
  )
{
  unsigned char k;
 
  xcog1.inlevel++;  //increase input level
  outstr(question);
  outstr(" (Y = yes | n = no)? ");
  k = getChar();
  if(!level_rst)
    xcog1.inlevel = 0;  //no more input, action follows
  if(k == 'Y') {
    outstr("yes\r\n");
    return 1;
  }
  outstr("no\r\n");
  return 0;
}
 
 
 
/******************************************************************/
void chip_ini (
  unsigned char new_index
  )
{
  chip.pspec = chip.pspec - chip.index + new_index;
  chip.index = new_index;
  chip.addrlen_in_bits = get_addrlen(ADDRLEN_IN_BITS, chip.pspec->chipsize - 1);
  chip.pages = NOT_APPLICABLE;
  if(chip.pspec->pagesize != NOT_APPLICABLE)
    chip.pages = chip.pspec->chipsize / chip.pspec->pagesize;
}
 
 
 
signed char chip_read (
  struct tag_filespec * filespec,
  unsigned int firstloc,
  unsigned int memsize,
  unsigned int * lines,
  char * linebuf
  )
{
  //switches:
  #define SCANNING_DATA         0x00    //test != 0xff, test_old != 0xff
  #define DATA_START            0x01    //test != 0xff, test_old == 0xff
  #define FF_START              0x02    //test == 0xff, test_old != 0xff
  #define SCANNING_FF           0x03    //test == 0xff, test_old == 0xff
  //flags:
  #define APPLY_CUT             0x01
  #define HAS_NOT_BEEN_CUT_YET  0x02
  #define IS_0XFF               0x04
  //aux:
  #define MODE_0XFF             filespec->mode_0xff
  #define INLINE_0XFF           (MODE_0XFF & MODE_INLINE)
  #define PAYLOAD_DEFAULT       (filespec->payload_default)
 
  struct tag_linedat linedat = {
    malloc(PAYLOAD_DEFAULT << 1),  //shift left: provide extra space for inline prefetch
    (PAYLOAD_DEFAULT << 1) - 1,
    0,
    0,
    firstloc,
    0
  };
  unsigned char chars_tested = 0;
  unsigned char cut = 0;
  unsigned char test_old;
 
  /*
   * Create special startup condition:
   * We are jumping directly into DATA_START or SCANNING_FF.
   */
  unsigned char test = 0xff;                //makes it easy to check for 0xff
  unsigned char runlen = INLINE_0XFF + 1;   //SCANNING_FF decrements runlen
  unsigned char flags = ((IS_0XFF | HAS_NOT_BEEN_CUT_YET) & ~APPLY_CUT);
 
  //scan specified memory
  while(memsize) {
    //save & prefetch
    test_old = test;            //save
    test = inb();               //prefetch in respect to chars_tested
 
    //check memsize first to catch address roll-over
    if(chars_tested == memsize) {
      cut = chars_tested;
      flags |= APPLY_CUT;
    }
    else if(MODE_0XFF & MODE_SPLIT) {
      switch((((test == 0xff) << 1) | (test_old == 0xff))) {
        case FF_START:
          cut = chars_tested;     //save cut position in case we need later
          flags |= HAS_NOT_BEEN_CUT_YET;
          runlen = INLINE_0XFF;
          if(!runlen) {
            if(cut)
              flags |= APPLY_CUT;
          }
          break;
 
        case SCANNING_FF:
          if(runlen) {
            runlen--;
          }
          else {
            if(flags & HAS_NOT_BEEN_CUT_YET) {
              flags &= ~HAS_NOT_BEEN_CUT_YET;
              if(cut)
                flags |= APPLY_CUT;
            }
          }
          break;
 
        case DATA_START:
          if(!runlen) {
            cut = chars_tested;     //save cut position in case we need later
            if(cut)
              flags |= APPLY_CUT;
          }
          else {
            cut = 0;    //we didn’t use the saved cut position, let’s reset to zero
          }
          break;
 
        case SCANNING_DATA:
          break;
      }
    }
 
    //maximal payload?
    if(!(flags & APPLY_CUT)) {
      if(chars_tested == PAYLOAD_DEFAULT) {
        if(!cut)
          cut = chars_tested;
        flags |= APPLY_CUT;
      }
    }
 
    //store prefetch in buffer
    linedat.buf[linedat.wr++ & linedat.mask] = test;
 
    //check for 0xff line
    if(test_old != 0xff)
      flags &= ~IS_0XFF;
 
    //evaluate flags
    if(flags & APPLY_CUT) {
      //update
      chars_tested -= cut;
      memsize -= cut;
 
      //skip output of 0xff?
      if((MODE_0XFF & MODE_STRIP) && (flags & IS_0XFF)) {
        linedat.rd += cut;
        linedat.startaddr += cut;
        if(linebuf_out(NULL) == -1)
          goto ERROR;
      }
      else {
        //update linedat
        linedat.payload = cut;
 
        //make data line
        switch(filespec->format) {
          case HEXDUMP:
            HEXDUMP_mkline(&linedat, linebuf);
            break;
 
          case MOTBIN:
            MOT_data(&linedat, linebuf);
            break;
        }
 
        //put out
        if(linebuf_out(linebuf) == -1)
          goto ERROR;
        *lines += 1;  //sum up
      }
 
      //reset values
      cut = 0;
      flags = (IS_0XFF & ~APPLY_CUT & ~HAS_NOT_BEEN_CUT_YET);
    }
 
    //increment counter
    chars_tested++;
  }
  free(linedat.buf);
  return 0;
 
  ERROR:
    free(linedat.buf);
    return -1;
}
 
 
 
void chip_txfile (
  struct tag_filespec * filespec,
  unsigned char addrlen_in_bits,
  unsigned int firstloc,
  unsigned int memsize,
  unsigned char screenmode
  )
{
  char linebuf[SIZE_LINEBUF];
  unsigned int lines = 0;
 
  //activate host
  outfifo(SOH);
  if(screenmode & MODE_SCREEN_OUTPUT)
    outfifo(CHIP_TO_FILE);
  else
    outfifo(CHIP_TO_FILE_NOSCREEN);
  outfifo(filespec->format);
 
  //put chip on
  CHIP_ON;
  cmd(CMD__READ, firstloc, addrlen_in_bits);
 
  //create header
  char header[SIZE_HEADER];
  sprinti(header, HEADER, chip.pspec->name);
 
  //select format
  switch(filespec->format) {
    case MOTBIN:
      //make & put header
      MOT_header(header, linebuf);
      if(linebuf_out(linebuf) == -1)
        goto ERROR;
 
      //read chip
      if(chip_read(filespec, firstloc, memsize, &lines, linebuf) == -1)
        goto ERROR;
 
      //make & put summary line
      MOT_summary(lines, linebuf);
      if(linebuf_out(linebuf) == -1)
        goto ERROR;
      break;
 
    case HEXDUMP:
      //make & put header
      *linebuf = sprinti(linebuf, "-#header: %s\r\n", header) - 1;
      if(linebuf_out(linebuf) == -1)
        goto ERROR;
 
      //read chip
      if(chip_read(filespec, firstloc, memsize, &lines, linebuf) == -1)
        goto ERROR;
 
      //make & put summary line
      *linebuf = sprinti(linebuf, "-#lines: %d\r\n", lines) - 1;
      if(linebuf_out(linebuf) == -1)
        goto ERROR;
      break;
  }
  goto SUCCESS;
 
  ERROR:
 
  SUCCESS:
    CHIP_OFF;
    //terminate connection
    outfifo(EOT);
    return;
}
 
 
 
/******************************************************************/
signed char linebuf_out (
  char * linebuf
  )
{
  unsigned char c;
  char * p;
 
  do {
    p = linebuf;
    outfifo(STX);
    for(int n = *p++; n; n--)
      outfifo(*p++);
    outfifo(ETX);
    c = getChar();
  } while(c == ENQ);
 
  if(c != ACK)
    return -1;
  return 0;
}
 
 
 
char outfifo (
  char c
  )
{
  if(c == CARR_RET)
    c = CLIM_CR;
  else if(c == NEW_LINE)
    c = CLIM_NL;
  putChar(c);
  return (c);
}
 
 
 
int outstr (
  char * s
  )
{
  int n = 0;
 
  //don't allow this loop to run infinitively
  while(*s != '\0' && n < 256) {
    outfifo(*s++);
    n++;
  }
  return(n);
}
 
 
 
/******************************************************************/
void HEXDUMP_mkline (
  struct tag_linedat * linedat,
  char * linebuf_orig
  )
{
  char * linebuf = linebuf_orig;
  unsigned int prescan = linedat->rd;
  unsigned char n, tab, fillup;
 
  //create space for datalength
  linebuf++;
 
  //write addr
  linebuf += sprinti(linebuf, "%08x: ", linedat->startaddr);
 
  //write hex bytes
  n = linedat->payload;
  linedat->startaddr += n;  //update startaddr in advance
  while(n--)
    linebuf += sprinti(linebuf, "%02x ", linedat->buf[prescan++ & linedat->mask]);
 
  //append ascii equivalent
  n = linedat->payload;
  tab = fillup = pfspec->payload_default - n;
  while(tab--)
    linebuf += sprinti(linebuf, "   ");
  linebuf += sprinti(linebuf, " #");
  while(n--) {
    unsigned char test;
    test = linedat->buf[linedat->rd++ & linedat->mask];
    *linebuf++ = isprint(test) ? test : '.';
  }
  while(fillup--)
    *linebuf++ = ' ';
 
  //write new line
  *linebuf++ = '\r';
  *linebuf++ = '\n';
 
  //save datalength
  *linebuf_orig = linebuf - linebuf_orig - 1;
}
 
 
 
/******************************************************************/
void greeting (
  )
{
  outfifo('\r');
  hr('=', 5, NULL);
  outstr(HEADER_KICK);
  hr('=', MENUWIDTH - (sizeof(HEADER_KICK) - 1) - 5, '\n');
}
 
 
 
/******************************************************************/
void cmd_WREN (
  void
  )
{
  CHIP_ON;
  outbits(CMD__WREN, 1 << 7);
  CHIP_OFF;
}
 
 
 
/******************************************************************/
void cmd_WRSR (
  const unsigned char regno,
  const unsigned char byte
  )
{
  unsigned char msbit = 7;
  unsigned int value = 0x00000000 | byte;
 
  //get SR0 backup for some chips using X01_WRSR to access SR1.
  value |= (cmd_RDSR(0) & chip.pspec->sr_wrmask[0]) << 8;
 
  CHIP_ON;
  if(chip.pspec->cmdset & (1 << X50_EWSR))
    outbits(CMD__EWSR, 1 << 7);
  else
    outbits(CMD__WREN, 1 << 7);
  CHIP_OFF;
  CHIP_ON;
  switch(regno) {
    case 2:
      outbits(CMD__WRSR3, 1 << 7);
      break;
 
    case 1:
      if(!(chip.pspec->cmdset & (1 << X31_WRSR2))) {
        /*
         * FIXME
         * Take care NOT to read volatile '1'-bits of SR0 and writing it
         * into non-volatile bits!
         *
         */
        msbit = 15;
        outbits(CMD__WRSR, 1 << 7);
      }
      else {
        outbits(CMD__WRSR2, 1 << 7);
      }
      break;
 
    case 0:
    default:
      outbits(CMD__WRSR, 1 << 7);
      break;
  }
  outbits(value, 1 << msbit);
  CHIP_OFF;
}
 
 
 
/******************************************************************/
void page_write (
  const unsigned int addr,
  unsigned char * buffer
  )
{
  unsigned int pageaddr;
  int n_bytes;
 
  //mask page address
  pageaddr = addr & ~(chip.pspec->pagesize - 1);
 
  //disable hardware write protection
  WPn_HIGH;
 
  //set Write Enable Latch Bit
  cmd_WREN();
 
  //start
  CHIP_ON;
 
  //send PAGE PROGRAM command
  cmd(CMD__PP, pageaddr, chip.addrlen_in_bits);
 
  //how many bytes?
  n_bytes = chip.pspec->pagesize;
 
  while(n_bytes--) {
    //send databyte
    outbits(*buffer, 1 << 7);
 
    //increment pointers
    buffer++;
 
    //TODO: still in range?
  }
 
  //initiate pgm-cycle
  CHIP_OFF;
 
  //detect end of write cycle
  WIP_polling();             //wait until write cycle is finished
 
  //enable hardware write protection
  WPn_LOW;
}
 
 
 
/******************************************************************/
void exit_sequence (
  const char status
  )
{
  outfifo(EXIT_CHAR_A);
  outfifo(EXIT_CHAR_B);
  outfifo(status);  //status
}
 
 
 
/******************************************************************/
int WIP_polling (
  void
  )
{
  unsigned char b;
  int n = 0;
 
  CHIP_ON;
  outbits(CMD__RDSR, 1 << 7);
  do {
    b = inb();
    if(++n > MAX_POLLING)
      break;
  } while(b & WIP);  //cancel on overflow
  CHIP_OFF;
  return n;
}
 
 
 
/******************************************************************/
unsigned int CPM_polling (
  void
  )
{
  unsigned char b;
  unsigned int n = 0;
 
  CHIP_ON;
  outbits(CMD__RDSR, 1 << 7);
  do
  {
    b = inb();
    n++;
  }
  while((b & CPM) && n);  //cancel on overflow
  CHIP_OFF;
  return n;
}
 
 
 
/******************************************************************/
unsigned char SR_report (
  unsigned char regno
  )
{
  char* p = chip.pspec->sr_bitnames[regno];
  unsigned char bitmask = chip.pspec->sr_wrmask[regno];
  unsigned char is_static = chip.pspec->sr_is_static[regno];
  char s[SIZE_STR_MESSAGE];
  unsigned char status;
 
  status = cmd_RDSR(regno);
  SR_intro(regno);
 
  //bit names and current status
  sprinti(s,  "Bit No\t\t7\t6\t5\t4\t3\t2\t1\t0\r\n" \
              "Bitname\t\t%s\r\n" \
              "Status\t\t" \
              , p);
  outstr(s);
  for(int n = 0b10000000; n; n >>= 1)
    outstr((status & n) != 0 ? "1\t" : "0\t");
 
  //write access
  outstr( "\r\n" \
          "writable?\t" \
          );
  for(int n = 0b10000000; n; n >>= 1)
    outstr((bitmask & n) != 0 ? "w\t" : "-\t");
 
  //static bits
  outstr( "\r\n" \
          "volatile?\t" \
          );
  for(int n = 0b10000000; n; n >>= 1)
    outstr((is_static & n) != 0 ? "-\t" : "v\t");
  outstr("\r\n\n");
 
  return status;
}
 
 
 
inline unsigned char inb (
  void
  )
{
  return inbits(1 << 7);
}
 
 
 
unsigned int inbits (
  unsigned int msbit
  )
{
  unsigned int in = 0;
  while(msbit) {
    CLOCK_LOW; tCLQV;
    if(INA & BIT_MISO)
      in |= msbit;
    CLOCK_HIGH;
    msbit >>= 1;
  }
  return in;
}
 
 
 
void outbits (
  const unsigned int value,
  unsigned int msbit
  )
{
  while(msbit) {
    CLOCK_LOW;
    if(value & msbit) {
      SO_HIGH;
    }
    else {
      SO_LOW;
    }
    CLOCK_HIGH;
    msbit >>= 1;
  }
}
 
 
 
void cmd (
  const unsigned char cmd,
  const unsigned int value,
  unsigned char bits
  )
{
  outbits(cmd, 1 << 7);
  outbits(value, 1 << --bits);
}
 
 
 
int cmd_RDID_JEDEC (
  void
  )
{
  int id_JEDEC;
  CHIP_ON;
  outbits(CMD__RDID, 1 << 7);
  id_JEDEC = inbits(1 << 23);
  if(chip.pspec->cmdset & (1 << X00_NOP))   //for SST25VF016B only?
    outbits(CMD__NOP, 1 << 7);
  CHIP_OFF;
  return id_JEDEC;
}
 
 
 
void cmd_DP (
  void
  )
{
  int dt = (CLKFREQ / 1000000) * 10;
 
  CHIP_ON;
  outbits(CMD__DP, 1 << 7);
  CHIP_OFF;
  //Macronix Datasheet:
  //now wait about 10µs for tDP(2)
  waitcnt(CNT + dt);
}
 
 
 
/******************************************************************/
unsigned char cmd_RDSR (
    unsigned char regno
  )
{
  unsigned char buf;
 
  CHIP_ON;
  switch(regno) {
    case 2:
      outbits(CMD__RDSR3, 1 << 7);
      break;
 
    case 1:
      outbits(CMD__RDSR2, 1 << 7);
      break;
 
    case 0:
    default:
      outbits(CMD__RDSR, 1 << 7);
      break;
  }
  buf = inb();
  CHIP_OFF;
 
  return buf;
}
 
 
 
void cmd_WRDI (
  void
  )
{
  CHIP_ON;
  outbits(CMD__WRDI, 1 << 7);
  CHIP_OFF;
}
 
 
 
/******************************************************************/
void SPI_ini (
  void
  )
{
  //entry condition: all outputs are tristate.
 
  //adjust pins
  WPn_LOW;
  HOLDn_HIGH;
  SO_LOW;
 
  //prepare all clock pin output registers
  if(spimode == mode_0)
    OUTA &= ~SCLK_AVAIL;
  else
    OUTA |= SCLK_AVAIL;
 
  //apply SPI power and let it come up together with PIN_CEn
  if(!(DIRA & BIT_PNP_DEVICE)) {
    DIRA |= BIT_PNP_DEVICE;         //enable pnp device
    usleep(POWERUP_SPI * 1000);     //used for chips within motherboards
  }
 
  //activate output of selected pins
  DIRA |= (SCLK_ACTIVE | BIT_WPn | BIT_HOLDn | BIT_MOSI);
 
  //give lines some time to settle
  //Note this is essential for the GA-G41M-ES2L!
  usleep(POWERUP_SPILINES * 1000);
}
 
 
 
/******************************************************************/
void SPI_off (
  int mode
  )
{
  int is_static = chip.pspec->sr_is_static[0] | \
                  chip.pspec->sr_is_static[1] | \
                  chip.pspec->sr_is_static[2];
 
  switch(mode) {
    case MODE_FORCE_SPI_OFF:
      is_static = 1;
 
    case MODE_SPI_OFF:
      if(is_static && (chip.pspec->cmdset & (1 << XB9_DP)))
        cmd_DP();   //enter deep power down as a security feature
      DIRA &= ~SPI_BUS;   //pins go tristate
 
    case MODE_SPI_POWEROFF:
      /*
       * NOTE
       * This case must not be used without a preceding MODE_SPI_OFF!
       *
       */
      if(is_static)
        DIRA &= ~BIT_PNP_DEVICE;    //disable pnp device
      break;
  }
}
 
 
 
/******************************************************************/
int hex2bin (
  unsigned char a,
  unsigned char b
  )
{
  signed char hnib;
  signed char lnib;
 
  hnib = hexdigit2bin(a);
  lnib = hexdigit2bin(b);
 
  if(hnib == -1 || lnib == -1)
    return -1;  //no true hex
  return (hnib << 4) | lnib;
}
 
 
 
 
void PGM_cycle (
  enum tag_cmdstat * cmdstat,
  unsigned char odd_tracker
  )
{
  switch(*cmdstat) {
    case cmd_off:
      return;           //nothing to do
 
    case cmd_on:
      CHIP_OFF;         //force pgm-cycle, if any
      WIP_polling();    //detect end of write cycle
      break;
 
    case cmd_CP:
      if(odd_tracker)
        outbits(0xff, 1 << 7);     //send dummy byte which does not contain any zero bits
      CHIP_OFF;         //force pgm-cycle, if any
      WIP_polling();    //detect end of write cycle
      cmd_WRDI();
      CPM_polling();
      break;
  }
  *cmdstat = cmd_off;
}
 
 
 
/******************************************************************/
void ledstat()
{
  int statcycle = 0;
  int timestamp;
  struct {
    int phases;
    int phase;
    int ison;
  } led = { 0, 0, 0 };
 
  while(1) {
    //get timestamp
    timestamp = CNT;
 
    //report xcog1.inlevel status
    if(!statcycle) {
      statcycle = STATUS_CYCLE;
      led.ison = 1;
      led.phase = LED_PHASE;
      led.phases = xcog1.inlevel << 1;
      if(led.phases)
        led.phases--;
    }
    else {
      statcycle--;
      if(led.phases) {
        if(!led.phase) {
          led.ison ^= 1;
          led.phase = LED_PHASE;
          led.phases--;
        }
        else {
          led.phase--;
        }
      }
    }
 
    //control LED_GREEN
    if(xcog1.green && led.ison) {
      high(LED_GREEN);
    }
    else {
      low(LED_GREEN);
    }
 
    //control LED_ORANGE
    if(xcog1.orange)
      high(LED_ORANGE);
    else
      low(LED_ORANGE);
 
    //keep monitoring adapter plug
    if(xcog1.yellow) {
      if(input(PIN_PLUGTESTn)) {
        //TODO: SPI power should be shutdown here.
        high(LED_YELLOW);
      }
      else
        low(LED_YELLOW);
    }
 
    //loop resolution
    waitcnt(timestamp + LOOP_RES);
  }
}
 
 
 
/******************************************************************/
void burn()
{
  int space = 0;
  int spacectr = 0;
  int queue = 0;
  unsigned char odd_tracker = 0;
  unsigned int addr = 0;
  enum tag_cmdstat cmdstat = cmd_off;
  enum {
    check_flags,
    check_queue,
    load_data,
    load_lineaddr,
    gooff,
    spioff
  } runctrl = 0;   
 
  SPI_ON;           //main cog should have left the SPI chip powered!
  WPn_HIGH;         //disable hardware write protection
  while(1) {
    switch(runctrl) {
      case check_flags:
        if(xcog0.rq_spioff) {
          runctrl = gooff;  //jump
          break;
        }
        else if(xcog0.rq_lineaddr) {
          runctrl = load_lineaddr;  //jump
          break;
        }
 
      case check_queue:
        queue = xcog0.offwr - xcog0.offrd;
        if(queue) {
          xcog0.queue_empty = 0;
          if(cmdstat != cmd_off) {
            runctrl = load_data;  //jump
            break;
          }
        }
        else {
          xcog0.queue_empty = 1;
          runctrl = check_flags;  //jump
          break;
        }
 
        //set_space:
        space = spacectr = xcog0.psize - (addr & (xcog0.psize - 1));
 
        //start_cmd:
        if(cmdstat == cmd_CP) {
          CHIP_ON;          //continue
          outbits(CMD__CP, 1 << 7);
        }
        else {
          cmd_WREN();       //set Write Enable Latch Bit
          CHIP_ON;          //start
          if(xcog0.cmd == CMD__CP) {
            if(addr & 1) {
              cmd(xcog0.cmd, addr - 1, xcog0.abits);
              outbits(0xff, 1 << 7);   //dummy byte without zero bits
              odd_tracker ^= 1;
            }
            else
              cmd(xcog0.cmd, addr, xcog0.abits);
            cmdstat = cmd_CP;
          }
          else {
            cmd(xcog0.cmd, addr, xcog0.abits);
            cmdstat = cmd_on;
          }
        }
 
      case load_data:
        while(spacectr && queue) {
          outbits(*(xcog0.pbuf + (xcog0.offrd++ & (xcog0.bufsize - 1))), 1 << 7);
          queue--;
          spacectr--;
          odd_tracker ^= 1;
        }
 
        //check_spacectr:
        if(!spacectr) {
          PGM_cycle(&cmdstat, odd_tracker);
          addr += space;
        }
        runctrl = check_flags;  //jump
        break;
 
      case load_lineaddr:
        if(addr != xcog0.lineaddr) {
          PGM_cycle(&cmdstat, odd_tracker);   //in case cmdstat != cmd_off
          addr = xcog0.lineaddr;  //update addr
          odd_tracker = 0;        //initialize odd_tracker
        }
        xcog0.rq_lineaddr = 0;
        runctrl = check_queue;  //jump
        break;
 
      case gooff:
        PGM_cycle(&cmdstat, odd_tracker);   //in case cmdstat != cmd_off
        WPn_LOW;          //enable hardware write protection
        SPI_OFF(MODE_SPI_OFF);
        xcog0.rq_spioff = 0;
        runctrl = spioff;  //final step, hang up
 
      case spioff:
        break;
    }
  }
}
 
 
 
/******************************************************************/
void MOT_typeS_fillup(
  union tag_typeS * typeS
  )
{
  if(!typeS->bf.addrlen) {  //calculate bf members based on member num
    char num = typeS->bf.num;
 
    typeS->mem = 0;
 
    if(num < 1) {
      typeS->bf.addrlen = 2;
      typeS->bf.start = 1;
    }
    else if(num < 4) {
      typeS->bf.addrlen = num + 1;
      typeS->bf.data = 1;
    }
    else if(num < 5) {
      typeS->bf.none = 1;
    }
    else if(num < 7) {
      typeS->bf.addrlen = num - 3;
      typeS->bf.linecount = 1;
    }
    else if(num < 10) {
      typeS->bf.addrlen = 11 - num;
      typeS->bf.startexec = 1;
    }
    else {
      typeS->bf.none = 1;
    }
    typeS->bf.num = num;
  }
  else {  //calculate member num based on bf members
    if(typeS->bf.start)
      typeS->bf.num = 0;
    else if(typeS->bf.data)
      typeS->bf.num = typeS->bf.addrlen - 1;
    else if(typeS->bf.linecount)
      typeS->bf.num = typeS->bf.addrlen == 2 ? 5 : 6;
    else if(typeS->bf.startexec)
      typeS->bf.num = 11 - typeS->bf.addrlen;
    else {
      typeS->bf.num = 4;  //not a valid type
      typeS->bf.none = 1;
    }
  }
}
 
 
 
/******************************************************************/
char HEXDUMP_rxline (
  struct tag_xcog0 * px,
  unsigned int * lines
  )
{
  unsigned int pwr;
  char errcode;
  enum {
    rx_lineaddr,
    rx_firstspace,
    rx_data,
    rx_le,
    rx_done
  } rx = rx_lineaddr;
  unsigned char x, n;
  unsigned char cmax;
  unsigned char c[9]; //enough space to fetch address bytes in one go
  int16_t vbin;
  unsigned int lineaddr;
 
  errcode = ERRC__SUCCESS;
  pwr = px->offwr;  //setup a local copy of global pointer
  lineaddr = 0;
  x = 0;
  n = 0;
  cmax = 1;
  do {
    GET_CHAR_GROUP(cmax);
    switch(rx) {
      case rx_lineaddr:
        if(c[0] == '#') {
          rx = rx_le;
          n = 127;  //maximum of allowed garbage characters
          break;
        }
        if(x > 8) {
          errcode = ERRC__HEXDUMP_PARSING_ERROR;
          break;
        }
        if(c[0] != ':') {
          vbin = hexdigit2bin(c[0]);
          if(vbin == -1) {
            errcode = ERRC__NO_HEX_DIGIT;
            break;
          }
          c[1 + x++] = vbin;
        }
        else {
          unsigned char k = 0;  //byte selector
          unsigned char t = 0;  //nibble selector
          rx = rx_firstspace;
          while(x--) {
            vbin = c[1 + x] << (t << 2);
            lineaddr |= vbin << (k << 3);
            k += t;
            t ^= 1;
          }
          px->lineaddr = lineaddr;
          px->rq_lineaddr = 1;
        }
        break;
 
      case rx_firstspace:
        if(c[0] != ' ') {
          errcode = ERRC__HEXDUMP_PARSING_ERROR;
          break;
        }
        rx = rx_data;
        cmax = 3;
        break;
 
      case rx_data:
        if(n > xcog0.bufsize) {
          errcode = ERRC__LINE_TOO_LONG; //?!
          break;
        }
        if(c[0] == ' ' && (c[1] == '#' || c[1] == ' ')) {
          n -= 2;     //maximum of allowed garbage characters
          cmax = 1;
          rx = rx_le;
          break;
        }
        vbin = hex2bin(c[0], c[1]);
        if(vbin == -1) {
          errcode = ERRC__NO_HEX_DIGIT;
          break;
        }
        if((errcode = queue(px, vbin, &pwr)))
          break;
        if(c[2] == CLIM_HEXDUMP) {
          rx = rx_done;
          cmax = 0;   //don't read more chars!
          break;
        }
        if(c[2] != ' ') {
          errcode = ERRC__HEXDUMP_PARSING_ERROR;
          break;
        }
        break;
 
      case rx_le:
        n--;
        if(n < 0) {
          errcode = ERRC__LINE_TOO_LONG;
          break;
        }
        if(c[0] == CLIM_HEXDUMP) {
          *lines += 1;
        }
        else
          break;
 
      case rx_done:
        px->offwr = pwr;
        return(errcode);
    }
  } while(!errcode);
  return(errcode);
}
 
 
 
/******************************************************************/
char MOT_rxline (
  struct tag_xcog0 * px,
  unsigned int * lines,
  int hexmode
  )
{
  char errcode;
  enum {
    rx_S,
    rx_type,
    rx_len,
    rx_lineaddr,
    rx_data,
    rx_chksum
  } rx = rx_S;
  unsigned int pwr;
  union tag_typeS typeS;
  unsigned int lineaddr;
  unsigned char x = 0;    //counts address bytes
  unsigned char n = 0;    //counts data bytes
  unsigned char sum = 0;
  int16_t vbin;
  unsigned char cmax;     //0: no char; 1: one char; 2: two chars etc.
  unsigned char c[2] = { 0, 0 };  //enough space to fetch a byte in one go
 
  errcode = ERRC__SUCCESS;
  pwr = px->offwr;  //setup a local copy of global pointer
  typeS.mem = 0;
  lineaddr = 0;
  cmax = 1;
  do {
    GET_CHAR_GROUP(cmax);
    switch(rx) {
      case rx_S:
        if(c[0] != 'S') {
          errcode = ERRC__NO_MOT;
          break;
        }
        rx = rx_type;
        break;
 
      case rx_type:
        vbin = hexdigit2bin(c[0]);
        if(vbin == -1) {
          errcode = ERRC__NO_HEX_DIGIT;
          break;
        }
        typeS.bf.num = vbin;
        MOT_typeS_fillup(&typeS);
        if(typeS.bf.none) {
          errcode = ERRC__NO_MOT;
          break;
        }
        x = typeS.bf.addrlen;
        rx = rx_len;
        cmax = 2;
        break;
 
      case rx_len:
        vbin = hex2bin(c[0], c[1]);
        if(vbin == -1) {
          errcode = ERRC__NO_HEX_DIGIT;
          break;
        }
        sum = vbin;
        n = vbin - x - 1;
        if(typeS.bf.data) {
#ifndef ERROR_MSG__LINE_TOO_LONG
          //reallocate buffer (this seems to work fine)
          if(n > px->bufsize) {
            free(px->pbuf);
            px->pbuf = malloc(n);
            px->bufsize = n;
          }
#else
          //safe workaround:
          if(n > px->bufsize) {
            errcode = ERRC__LINE_TOO_LONG;
            break;
          }
#endif
        }
        rx = rx_lineaddr;
        break;
 
      case rx_lineaddr:
        if(x) {
          x--;
          vbin = hex2bin(c[0], c[1]);
          if(vbin == -1) {
            errcode = ERRC__NO_HEX_DIGIT;
            break;
          }
          sum += vbin;
          lineaddr |= vbin << (x << 3);
        }
        if(!x) {
          if(typeS.bf.linecount || typeS.bf.startexec)
            rx = rx_chksum;
          else {
            rx = rx_data;
            px->lineaddr = lineaddr;
            px->rq_lineaddr = 1;
            cmax = hexmode ? 2 : 1;
          }
        }
        break;
 
      case rx_data:
        if(n) {
          n--;
          vbin = hexmode ? hex2bin(c[0], c[1]) : c[0];
          if(vbin == -1) {
            errcode = ERRC__NO_HEX_DIGIT;
            break;
          }
          sum += vbin;
          if(typeS.bf.data) {
            if((errcode = queue(px, vbin, &pwr)))
              break;
          }
        }
        if(!n) {
          rx = rx_chksum;
          cmax = 2;
        }
        break;
 
      case rx_chksum:
        vbin = hex2bin(c[0], c[1]);
        if(vbin == -1) {
          errcode = ERRC__NO_HEX_DIGIT;
          break;
        }
        if(vbin != (~sum & 0xff)) {
          errcode = ERRC__CHECKSUM_MISMATCH;
          break;
        }
        if(typeS.bf.linecount && *lines != lineaddr) {
            errcode = ERRC__LINE_COUNT_MISMATCH;
            break;
        }
        if(typeS.bf.data)
          *lines += 1;
        px->offwr = pwr;
        return(errcode);
    }
  } while(!errcode);
  return(errcode);
}
 
 
 
char queue (
  struct tag_xcog0 * px,
  unsigned char vbin,
  unsigned int * pwr
  )
{
  if((*pwr - px->offrd) >= px->bufsize)
    return ERRC__BUFFER_OVERRUN;
  else {
    *(px->pbuf + (*pwr & (px->bufsize - 1))) = vbin; //access volatile globals
    (*pwr)++;
    return ERRC__SUCCESS;
  }
}
 
 
 
void report_err(
  char reported_err
  )
{
  if(reported_err != 0) {
    outstr("Error Code: ");
    outfifo(reported_err + 48);
    outstr("\r\n");
  }
}
 
 
 
void chip_rxfile (
  struct tag_xcog0 * px,
  char screen_output
  )
{
  enum tag_rxstep {
    rx_stx_or_eot,
    rx_error,
    send_nak,
    rx_done
  } rx = rx_stx_or_eot;
  char errcode = ERRC__SUCCESS;
  unsigned int lines = 0;
  char a = 0;
 
  //cog setup
  px->bufsize = pfspec->payload_default;
  px->pbuf = malloc(px->bufsize);
  if(chip.pspec->cmdset & (1 << X02_PP)) {
    px->cmd = CMD__PP;
    px->psize = chip.pspec->pagesize;
  }
  else if(chip.pspec->cmdset & (1 << XAD_CP)) {
    px->cmd = CMD__CP;
    px->psize = 2;
  }
  else if(chip.pspec->cmdset & (1 << X02_BP)) {
    px->cmd = CMD__BP;
    px->psize = 1;
  }
  px->offrd = 0;
  px->offwr = 0;
  px->lineaddr = 0;
  px->rq_spioff = 0;
  px->queue_empty = 1;
  px->abits = chip.addrlen_in_bits;
  px->pcog = cog_run(&burn, STACK_BURNBUF);
 
  //send header
  outfifo(SOH);
  if(screen_output)
    outfifo(FILE_TO_CHIP);
  else
    outfifo(FILE_TO_CHIP_NOSCREEN);
  outfifo(pfspec->format);
 
  while(1) {
    switch(rx) {
      case rx_stx_or_eot:
        do
          a = getChar();
        while(a != EOT && a != STX);
        if(a == EOT) {
          rx = rx_done;
          break;
        }
        outfifo(a);   //feedback
        switch(pfspec->format) {
          case MOTBIN:
            errcode = MOT_rxline(px, &lines, BINMODE);
            break;
 
          case HEXDUMP:
            errcode = HEXDUMP_rxline(px, &lines);
            break;
        }
        if(errcode) {
          rx = rx_error;
          break;
        }
 
        //rx_etx_or_can:
        a = getChar();  //fetch ETX
        if(a == CAN) {
          errcode = ERRC__JOB_CANCELLATION;
          rx = send_nak;
          break;
        }
        /*
         * NOTE connect is NOT sending any line ending characters except:
         * - ETX for MOT format
         * - CLIM_HEXDUMP + ETX for HEXDUMP format, but the
         *   received CLIM_HEXDUMP has already been processed by HEXDUMP_rxline().
         *
         */
 
        //send_LE:
        /*
         * NOTE: HEXDUMP_rxline uses CLIM_HEXDUMP for detection of line ending,
         * and this character, i.e. a Carriage Return, has already been sent
         * as feedback.
         *
         */
        PUTCHAR_CR;
        PUTCHAR_NL;
 
        //wait_burn:
        while(!px->queue_empty);
 
        //send_ack:
        outfifo(ACK);
        rx = rx_stx_or_eot;
        break;
 
      case rx_error:
        if(errcode != ERRC__JOB_CANCELLATION)
          do
            a = outfifo(getChar());     //feedback
          while(a != ETX && a != CAN);  //CAN?! Yes, user may hit 'q' after error occured and transmission will then end with CAN
 
      case send_nak:
        outfifo(NAK);
        outfifo(errcode);   //send error code
        rx = rx_stx_or_eot;
        break;
 
      case rx_done:
        px->rq_spioff = 1;
        while(px->rq_spioff);
        cog_end(px->pcog);
        free(px->pbuf);
        SPI_OFF(MODE_SPI_POWEROFF);
        report_err(errcode);
        return;
    }
  }
}
 
 
 
 
/******************************************************************/
void chip_erase(
  void
  )
{
  char s[SIZE_STR_MESSAGE];
 
  WPn_HIGH;
  cmd_WREN();             //send WREN instruction
  CHIP_ON;
  outbits(cmd_CE, 1 << 7);
  CHIP_OFF;
  WPn_LOW;
  sprinti(s, "WIP_polling: %d\r\n", WIP_polling());
  outstr(s);
}