-------Cut here for PP.C--------
/*
 * pp.c : A serial mode PIC 16C84 programmer
 *
 * Usage:
 *
 *      pp objfile1 [ objfile2 ]
 *
 * Where objfile1 is the program data in INHX16 format and
 * the optional objfile2 is EEPROM data also in INHX16 format.
 * The program asks for fuse details, but doesn't bother to
 * program the remainder of the configuration memory. The
 * programming algorithms used are taken from the Microchip
 * data sheet DS30189A.
 *
 * See the file pp.asc for a schematic of the hardware which
 * must be attached to LPT1.
 *
 * Revision details:
 * ??-Feb-1994: Version 0.0; started as a few routines to debug hardware.
 * 07-Mar-1994: Version 0.1; first code to successfully program a 16C84.
 *
 *
 * Copyright (C) 1994 David Tait (david.tait@man.ac.uk).
 * This program is free software.  Permission is granted to use,
 * copy, or redistribute this program so long as it is not sold
 * for profit.
 *
 * THIS PROGRAM IS PROVIDED AS IS AND WITHOUT WARRANTY OF ANY KIND,
 * EITHER EXPRESSED OR IMPLIED.
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <dos.h>
#include <conio.h>

#define IN      64
#define VPP     8
#define VDD     4
#define CLK     2
#define OUT     1

#define LDCONF  0
#define LDPROG  2
#define RDPROG  4
#define INCADD  6
#define BEGPRG  8
#define LDDATA  3
#define RDDATA  5

#define VPPDLY  100
#define PRGDLY  12
#define TSET    0
#define THLD    0
#define TDLY    2

#define PROGRAM 0
#define DATA    1
#define PSIZE   1024
#define DSIZE   64

#define CP      16
#define PWRTE   8
#define WDTE    4

#define inbit           (inportb(s_reg)&IN)
#define vppon           (d_bits &= ~VPP)
#define vppoff          (d_bits |= VPP)
#define vddon           (d_bits &= ~VDD)
#define vddoff          (d_bits |= VDD)
#define clkhi           (d_bits &= ~CLK)
#define clklo           (d_bits |= CLK)
#define outhi           (d_bits &= ~OUT)
#define outlo           (d_bits |= OUT)
#define assert          (outportb(d_reg,d_bits))

int progbuf[PSIZE];
int databuf[DSIZE];
int fuses;

int d_bits = 0;
int d_reg;
int s_reg;
int check;
char *version = "V-0.1";


void setup()
{
   int i;

   vppoff, vddoff, clklo, outlo, assert;
   d_reg = peek(0,0x408);     /* should be base address of LPT1 */
   s_reg = d_reg+1;

   for ( i=0; i<PSIZE; ++i )
      progbuf[i] = 0x3FFF;
   for ( i=0; i<DSIZE; ++i )
      databuf[i] = 0xFF;
}

void idle_mode()
{
   vppoff, clklo, outlo, assert;
   delay(VPPDLY);
   vddoff, assert;
}

void prog_mode()
{
   vppoff, vddon, clklo, outlo, assert;
   delay(VPPDLY);
   vppon, assert;
}

void quit(s)
char *s;
{
   fprintf(stderr,"ERROR: %s\n",s);
   idle_mode();
   exit(1);
}

void tiny_delay(ticks)
int ticks;
{
   while ( ticks-- )
      ;
}

void clock_out(bit)
int bit;
{
   bit? outhi: outlo, clkhi, assert;
   tiny_delay(TSET);
   clklo, assert;
   tiny_delay(THLD);
   outlo, assert;
}

int clock_in()
{
   int b;

   outhi, clkhi, assert;
   tiny_delay(TSET);
   clklo, assert;
   b = inbit? 0: 1;
   tiny_delay(THLD);
   return b;
}

void out_word(w)
int w;
{
   int b;

   clock_out(0);
   for ( b=0; b<14; ++b )
     clock_out(w&(1<<b));
   clock_out(0);
}

int in_word()
{
   int b, w;

   (void) clock_in();
   for ( w=0, b=0; b<14; ++b )
     w += clock_in()<<b;
   (void) clock_in();
   return w;
}

void command(cmd)
int cmd;
{
   int b;

   outlo, assert;
   tiny_delay(TDLY);
   for ( b=0; b<6; ++b )
      clock_out(cmd&(1<<b));
   outhi, assert;
   tiny_delay(TDLY);
}

#define yes     (c=getche(), c == 'y' || c == 'Y')

void ask_fuses()
{
   int c, osc, wdte, pwrte, cp;

   do {
      printf("\nOscillator type:\n 0)-LP  1)-XT  2)-HS  3)-RC ? ");
      osc = getche() - '0';
   } while ( osc < 0 || osc > 3 );

   printf("\nEnable watchdog timer (y/n) ? ");
   wdte = yes? WDTE: 0;
   printf("\nEnable power-up timer (y/n) ? ");
   pwrte = yes? PWRTE: 0;
   printf("\n         Protect code (y/n) ? ");
   cp = yes?  0: CP;
   printf("\n");
   fuses = osc + wdte + pwrte + cp;
}

void erase()
{
   int i;

   prog_mode();
   command(LDCONF);
   out_word(0x3FFF);
   for ( i=0; i<7; ++i )
      command(INCADD);
   command(1);
   command(7);
   command(BEGPRG);
   delay(PRGDLY);
   command(1);
   command(7);
}

void program(which)
int which;
{
   int i, n, w, mask, ldcmd, rdcmd, *buf;

   if ( which == PROGRAM ) {
      buf = progbuf;
      n = PSIZE;
      mask = 0x3FFF;
      ldcmd = LDPROG;
      rdcmd = RDPROG;
   } else {
      buf = databuf;
      n = DSIZE;
      mask = 0xFF;
      ldcmd = LDDATA;
      rdcmd = RDDATA;
   }

   prog_mode();
   for ( i=0; i<n; ++i ) {
      command(ldcmd);
      out_word(buf[i]);
      command(BEGPRG);
      delay(PRGDLY);
      command(rdcmd);
      w = in_word() & mask;
      if ( buf[i] != w ) {
	 fprintf(stderr,"%04x: %04x != %04x\n",i,w,buf[i]);
	 quit("Verify failed during programming");
      }
      command(INCADD);
   }
}

void verify(which)
int which;
{
   int i, n, w, mask, rdcmd, *buf;

   if ( which == PROGRAM ) {
      buf = progbuf;
      n = PSIZE;
      mask = 0x3FFF;
      rdcmd = RDPROG;
   } else {
      buf = databuf;
      n = DSIZE;
      mask = 0xFF;
      rdcmd = RDDATA;
   }

   prog_mode();
   for ( i=0; i<n; ++i ) {
      command(rdcmd);
      w = in_word() & mask;
      if ( buf[i] != w ) {
	 fprintf(stderr,"%04x: %04x != %04x\n",i,w,buf[i]);
	 quit("Verify failed");
      }
      command(INCADD);
   }
}

void config()
{
   int i;

   prog_mode();
   command(LDCONF);
   out_word(fuses);
   for ( i=0; i<7; ++i )
     command(INCADD);
   command(LDPROG);
   out_word(fuses);
   command(BEGPRG);
   delay(PRGDLY);
   command(RDPROG);
   if ( fuses != (in_word()&0x1F) )
     quit("Fuse failure");
}

int hexdigit(fp)
FILE *fp;
{
   int c;

   if ( (c=getc(fp)) == EOF )
      quit("Unexpected EOF in objfile");

   c -= c>'9'? 'A'-10: '0';
   if ( c<0 || c>0xF )
      quit("Bad hex digit in objfile");
   return c;
}

int hexbyte(fp)
FILE *fp;
{
   int b;

   b = hexdigit(fp);
   b = (b<<4) + hexdigit(fp);
   check += b;
   return b;
}

int hexword(fp)
FILE *fp;
{
   int w;

   w = hexbyte(fp);
   w = (w<<8) + hexbyte(fp);
   if ( w<0 || w>0x3FFF )
      quit("Illegal data in objfile");
   return w;
}

void loadhex(fp, buf, bufsize)
FILE *fp;
int buf[], bufsize;
{
   int type, nwords, address, i;

   type = 0;
   while ( type != 1 ) {
      if ( getc(fp) != ':' )
	 quit("Bad objfile format");
      check = 0;
      nwords = hexbyte(fp);
      address = hexword(fp);
      type = hexbyte(fp);
      for ( i=0; i<nwords; ++i, ++address ) {
	 if ( address >= bufsize )
	    quit("Illegal address in objfile");
	 buf[address] = hexword(fp);
      }
      (void) hexbyte(fp);
      (void) getc(fp);
      if ( check&0xFF )
	 quit("Checksum error in objfile");
   }
}

void main(argc, argv)
int argc;
char *argv[];
{
   FILE *progfp, *datafp;
   int dflg = 0;

   setup();
   if ( argc < 2 )
      quit("Usage: pp objfile1 [ objfile2 ]");
   if ( (progfp = fopen(argv[1],"r")) == NULL )
      quit("Can't open objfile1");
   if ( argc > 2 ) {
      ++dflg;
      if ( (datafp = fopen(argv[2],"r")) == NULL )
	 quit("Can't open objfile2");
   }

   loadhex(progfp, progbuf, PSIZE);
   if ( dflg )
      loadhex(datafp, databuf, DSIZE);

   printf("\nPIC 16C84 Programmer %s\n",version);
   ask_fuses();
   printf("\nInsert PIC and press a key to start (^C to abort) ...\n");
   if ( getch() == 3 )
      quit("Aborted");
   printf("\nProgramming ...\n");
   erase();
   program(PROGRAM);
   if ( dflg )
      program(DATA);
   printf("Verifying ...\n");
   verify(PROGRAM);
   if ( dflg )
      verify(DATA);
   printf("Blowing fuses ...\n");
   config();
   printf("Finished\n\n");
   idle_mode();
}
-------End of PP.C-------