(MCU M68HC08) MC68HC908JB8
bl08.c
參考資訊:
1. bl08.zip
2. mc68hc908jb8
bl08.c
// TODO POSIX COMPATIBLE IOCTL // Note page size for JB8 has been temporarily changed to 32 /* File: bl08.c Copyright (C) 2004,2008 Kustaa Nyholm This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2.0 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // This code compiles cleanly with i686-apple-darwin8-gcc-4.0.1 with command: // gcc -Wall -std=c99 -pedantic -o bl08 bl08.c // and uses only POSIX standard headers so this should be pretty // easy to port anywhere: Mac OS X, Linux , MinGW, Cygwin // // Having said that I'm pretty sure there is implicit assumptions that // int is 32 bits, char is signed 8 bits // I also expect that extending this code to handle S-records in the +2G range // will uncover more implicit assumptions. // // cheers Kusti // additions ... override value for non supported CPUs // reset control with DTR #include <asm/ioctls.h> #include <ctype.h> #include <fcntl.h> #include <stdarg.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <termios.h> #include <time.h> #include <unistd.h> //#include <asm/termios.h> #include <signal.h> #include <sys/types.h> #include <sys/wait.h> // Terrible hack here because POSIX says 'ioctl()' is in <stropts.h> but // for example Mac OS X Tiger does not have this header, OTOH I think // that <sys/ictl.h> is not POSIX either so how do you write // actual POSIX compliant code that compiles cleanly on POSIX... extern int ioctl(int filedes, int command, ...); // End of hack #define PIDFILENAME "bl08PIDfile.temp" int com = 0; char* COM = "/dev/ttyUSBS0"; char version[] = "1.0.0.0"; unsigned char image[0x10000]; // HC908 memory image // give some initial meaningfull values (based on MC68HC908GZ16) int FLASH = 0xE000; // Flash start address int PUTBYTE = 0xFEAF; // Receive byte routine address int GETBYTE = 0x1C00; // Receive byte routine address int RDVRRNG = 0x1C03; // Read/verify flash routine address int ERARRNG = 0x1C06; // Erase flash routine address int PRGRNGE = 0x1C09; // Flash programming routine address int FLBPR = 0xFF7E; // Flash block proctection register address int CPUSPEED = 8; // 2 x Fbus freq, e.g. ext osc 16 MHz -> Fbus == 4 Mh => CPUSPEED==2 int MONDATA = 0x48; // Flashing routines parameter block address int MONRTN = 0xFE20; // Monitor mode return jump address int EADDR = 0xFF7E; // For FLBPR in Flash the mass erase must use FLBPR as the // erase address // these are calculated int DATABUF; // Flashing routines data buffer address (==MONDATA+4) int PAGESIZE; // Databuffer size int WORKRAM; // Work storage needed for calling flashing routines int WORKTOP; // Topmost work storage address int CTRLBYT; // Address of flashing routine control variable (==MONDATA+0) int CPUSPD; // Address of flashing routine cpu speed variable (==MONDATA+1) int LADDR; // Address of flashing routine last address variable (==MONDATA+2) // HC908GZ16 Memory usage (note for some HC908 variants the ROM routines use // memory starting from 0x80): 0x40 - 0x47 reserved for future ROM routine // expansion needs 0x48 - 0x4B ROM routine parameters 0x4C - 0x6C ROM routine // data buffer (64 bytes as used in this code) 0xAC - 0xFF Working storage for // calling the ROM routines (about 17 bytes used) // Cavets // DATABUF size // security erase at FLBPR, power cycle int tickP1 = 15; int tickP2 = 1023; int verbose = 1; int size = sizeof(image); int useStdin = 0; int dumpStart = 0; int dumpSize = 0; char* dumpFormat = "hex"; int eraseFlash = 0; int verify = 0; int baudRate = B9600; char* executeCode = NULL; int pageErase = 0; int uploadOnly = 0; int terminalMode = 0; int connected = 0; int useFastProg = 0; int resetPulse = 0; int killPrevious = 0; int loadOnly = 0; void comErr(char* fmt, ...) { char buf[500]; va_list va; va_start(va, fmt); vsnprintf(buf, sizeof(buf), fmt, va); fprintf(stderr, "%s", buf); perror(COM); va_end(va); abort(); } void flsprintf(FILE* f, char* fmt, ...) { char buf[500]; va_list va; va_start(va, fmt); vsnprintf(buf, sizeof(buf), fmt, va); fprintf(f, "%s", buf); fflush(f); va_end(va); } void initSerialPort() { com = open(COM, O_RDWR | O_NOCTTY | O_NDELAY); if (com < 0) comErr("Failed to open seria port"); fcntl(com, F_SETFL, 0); struct termios opts; tcgetattr(com, &opts); opts.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); opts.c_cflag |= (CLOCAL | CREAD); opts.c_cflag &= ~PARENB; opts.c_cflag |= CSTOPB; // two stop bits opts.c_cflag &= ~CSIZE; opts.c_cflag |= CS8; opts.c_oflag &= ~OPOST; opts.c_iflag &= ~INPCK; opts.c_iflag &= ~(IXON | IXOFF | IXANY); opts.c_cc[VMIN] = 0; opts.c_cc[VTIME] = 10; // 0.1 sec cfsetispeed(&opts, baudRate); cfsetospeed(&opts, baudRate); if (tcsetattr(com, TCSANOW, &opts) != 0) { perror(COM); abort(); } tcflush(com, TCIOFLUSH); // just in case some crap is the buffers char buf = -2; while (read(com, &buf, 1) > 0) { if (verbose) printf("Unexpected data from serial port: %02X\n", buf & 0xFF); } } void putByte(int byte) { char buf = byte; if (verbose > 3) flsprintf(stdout, "TX: 0x%02X\n", byte); int n = write(com, &buf, 1); if (n != 1) comErr("Serial port failed to send a byte, write returned %d\n", n); } int getByte() { char buf; int n = read(com, &buf, 1); if (verbose > 3) flsprintf(stdout, n < 1 ? "RX: fail\n" : "RX: 0x%02X\n", buf & 0xFF); if (n == 1) return buf & 0xFF; comErr("Serial port failed to receive a byte, read returned %d\n", n); return -1; // never reached } // This reads away break 'character' from the serial line void flushBreak() { int i; for (i = 0; i < 2; ++i) { char buf; int n = read(com, &buf, 1); if (verbose > 3) flsprintf(stdout, n < 1 ? "FL: nothing\n" : "FL: 0x%02X\n", buf & 0xFF); } } void sendByte(int byte) { byte &= 0xFF; putByte(byte); char buf; if (read(com, &buf, 1) != 1) comErr("Loopback failed, nothing was received\n"); int rx = buf & 0xFF; // if (byte != rx) { // read(com, &buf, 1); // comErr("Loopback failed, sent 0x%02X, got 0x%02X\n", byte, rx); //} rx = getByte(); // if (byte != rx) // comErr("Target echo failed, sent 0x%02X, got 0x%02X\n", byte, rx); } void readMemory(int addr, int n, int tick) { if (verbose > 2) flsprintf(stdout, "Read memory address %04X size %04X\n", addr, n); unsigned char* p = &image[addr]; sendByte(0x4A); // Monitor mode READ command sendByte(addr >> 8); sendByte(addr & 0xFF); *(p++) = getByte(); n--; int tc = 0; while (n > 0) { sendByte(0x1A); // Monitor mode IREAD command int b1 = getByte(); int b2 = getByte(); *(p++) = b1; n--; if (n > 0) *(p++) = b2; n--; if (tick) { tc++; if ((tc & tickP1) == 0) flsprintf(stdout, "."); // if ((tc & tickP2)==0) // flsprintf(stdout,"\n"); } } } void writeMemory(int addr, int n, int tick) { if (verbose > 2) flsprintf(stdout, "Write memory address %04X size %04X\n", addr, n); unsigned char* p = &image[addr]; sendByte(0x49); // Monitor mode WRITE command sendByte(addr >> 8); sendByte(addr & 0xFF); sendByte(*(p++)); int tc = 1; while (n > 1) { sendByte(0x19); // Monitor mode IWRITE command sendByte(*(p++)); n -= 1; if (tick) { tc++; if ((tc & tickP1) == 0) flsprintf(stdout, "."); // if ((tc & tickP2)==0) // flsprintf(stdout,"\n"); } } } void connectTarget() { int j; if (connected) return; // Hmmm, following does not work, how should we do this // For blank device we need to send FF, but for non blank something else, // oth reprogramming a non blank device, does it make sense for (j = 0; j < 8; ++j) sendByte(0xFF); flushBreak(); readMemory(0x40, 1, 0); connected = 1; if ((image[0x40] & 0x40) == 0) flsprintf(stdout, "Failed to unlock the security"); // in case FLBPR is RAM based we clear it first by just writing it image[FLBPR] = 0xFF; writeMemory(FLBPR, 1, 0); } void dumpMemory(int addr, int n) { unsigned char* p = &image[addr]; int i; for (i = 0; i < n; ++i) { if ((i & 0xF) == 0) flsprintf(stdout, "%04X ", addr + i); flsprintf(stdout, "%02X ", *(p++) & 0xFF); if ((i & 0xF) == 7) flsprintf(stdout, " "); if ((i & 0xF) == 15) flsprintf(stdout, "\n"); } if ((i & 0xF) != 0) flsprintf(stdout, "\n"); } void dumpMemorySrec(int addr, int size) { unsigned char* p = &image[addr]; while (size > 0) { int n = size > 16 ? 16 : size; int bc = 2 + n + 1; flsprintf(stdout, "S1%02X%04X", bc, addr); int s = (addr >> 8) + (addr & 0xFF) + bc; int i; for (i = 0; i < n; ++i) { int bty = *p & 0xFF; s += bty; flsprintf(stdout, "%02X", bty); ++p; ++addr; } size -= n; flsprintf(stdout, "%02X\n", ~s & 0xFF); } } int readSP() { if (verbose > 2) flsprintf(stdout, "Read Stak Pointer\n"); sendByte(0x0C); // Monitor mode READSP command return (((getByte() << 8) | (getByte() & 0xFF)) - 1) & 0xFFFF; } int runFrom(int PC, int A, int CC, int HX) { int SP = readSP(); if (verbose > 2) flsprintf(stdout, "Execute code PC=%04X A=%02X CC=%02X H:X=%04X SP=%04X\n", PC, A, CC, HX, SP); image[SP + 1] = HX >> 8; image[SP + 2] = CC; image[SP + 3] = A; image[SP + 4] = HX & 0xFF; image[SP + 5] = PC >> 8; image[SP + 6] = PC & 0xFF; writeMemory(SP + 1, 6, 0); sendByte(0x28); // Monitor mode RUN command return SP; } int lastMon = -1; int callMonitor(int mon, int ctrlbyt, int accu, int faddr, int laddr) { int SP = readSP(); image[CTRLBYT] = ctrlbyt; // CTRLBYT BIT 6 = 1 = > mass erase image[CPUSPD] = CPUSPEED; // CPUSPD = 16 MHz ext clock = > 4 MHz Fbus speed = > 8 image[LADDR] = laddr >> 8; image[LADDR + 1] = laddr & 0xFF; writeMemory(MONDATA, 4, 0); if (WORKRAM > 0xFF) { flsprintf(stderr, "Work RAM must be on zero page"); abort(); } if (lastMon != mon) { // construct small HC908 code fragment to call the monitor function and // return results int i = WORKRAM + 2; image[i++] = 0xCD; // JSR mon ; calls the monitor routine image[i++] = mon >> 8; image[i++] = mon & 0xFF; image[i++] = 0x87; // PSHA ; save condition A image[i++] = 0x85; // TPA ; condition codes to A image[i++] = 0xB7; // STA ; store to WORKRAM image[i++] = WORKRAM; image[i++] = 0x86; // PULA ; restore A image[i++] = 0xB7; // STA ; store to WORKRAM+1 image[i++] = WORKRAM + 1; image[i++] = 0x45; // LDHX #SP+1 ; restore stack pointer image[i++] = (SP + 1) >> 8; image[i++] = (SP + 1) & 0xFF; image[i++] = 0x94; // TXS image[i++] = 0xCC; // JMP back to MON (this is the only way) image[i++] = MONRTN >> 8; image[i++] = MONRTN & 0xFF; if (WORKRAM >= WORKTOP) { // leave some stack space for monitor routines flsprintf(stderr, "Not enough WORKRAM on target"); abort(); } writeMemory(WORKRAM, i - WORKRAM, 0); lastMon = mon; } // now execute the fragment runFrom(WORKRAM + 2, accu, 0x00, faddr); // fetch the return values readMemory(WORKRAM, 2, 0); return ((image[WORKRAM] & 0xFF) << 8) | (image[WORKRAM + 1] & 0xFF); // return condition codes and accu } int fastProg(int faddr, int n) { static int n_addr; static int last_n; if (WORKRAM > 0xFF) { flsprintf(stderr, "Work RAM must be on zero page"); abort(); } if (lastMon != -1) { int SP = readSP(); image[CTRLBYT] = 0; // CTRLBYT =0 image[CPUSPD] = CPUSPEED; // CPUSPD = 16 MHz ext clock = > 4 MHz // Fbus speed = > 8 // construct small HC908 code fragment to call the monitor function and // return results int i = WORKRAM; image[i++] = 0x9D; // NOP / reserve space image[i++] = 0x9D; // NOP / reserve space image[i++] = 0x35; // STHX WORKRAM (dir) image[i++] = WORKRAM; image[i++] = 0x45; // LDHX #DATABUF image[i++] = DATABUF >> 8; image[i++] = DATABUF & 0xFF; image[i++] = 0xCD; // JSR GETBYTE ; calls the monitor routine image[i++] = GETBYTE >> 8; image[i++] = GETBYTE & 0xFF; // image[ i++ ] = 0xFE9C>>8; ; // 0xFE9C = GET WITH echo // image[ i++ ] = 0xFE9C&0xFF; image[i++] = 0xF7; // STA ,X image[i++] = 0x5C; // INCX image[i++] = 0xA3; // cpx #DATABUF+n n_addr = i; image[i++] = 0; // place holder image[i++] = 0x25; // BLO *-10 image[i++] = (-9) & 0xFF; image[i++] = 0x55; image[i++] = WORKRAM; image[i++] = 0xCD; // JSR PRGRNGE ; calls the monitor routine image[i++] = PRGRNGE >> 8; image[i++] = PRGRNGE & 0xFF; image[i++] = 0x45; // LDHX #SP+1 ; restore stack pointer image[i++] = (SP + 1) >> 8; image[i++] = (SP + 1) & 0xFF; image[i++] = 0x94; // TXS image[i++] = 0xCC; // JMP back to MON (this is the only way) image[i++] = MONRTN >> 8; image[i++] = MONRTN & 0xFF; if (WORKRAM >= WORKTOP) { // leave some stack space for monitor routines flsprintf(stderr, "Not enough WORKRAM on target"); abort(); } writeMemory(WORKRAM, i - WORKRAM, 0); // dumpMemorySrec(WORKRAM , i-WORKRAM); lastMon = -1; } if (last_n != n) { image[n_addr] = DATABUF + n; writeMemory(n_addr, 1, 0); last_n = n; } int laddr = faddr + n - 1; image[LADDR] = laddr >> 8; image[LADDR + 1] = laddr & 0xFF; writeMemory(LADDR, 2, 0); // now execute the fragment runFrom(WORKRAM + 2, 0x00, 0x00, faddr); // NOTE! to override flash security and erase FLBPR at be // used as the erase address for mass erase int i; for (i = 0; i < n; ++i) putByte(image[faddr + i]); for (i = 0; i < n; ++i) getByte(); readSP(); return 0; } int fastProg2(int faddr, int progn) { if (WORKRAM > 0xFF) { flsprintf(stderr, "Work RAM must be on zero page"); abort(); } int SP = readSP(); image[CTRLBYT] = 0; // CTRLBYT =0 image[CPUSPD] = CPUSPEED; // CPUSPD= 16 MHz ext => 4 MHz Fbus = > 8 // construct small HC908 code fragment to call the monitor function int i = WORKRAM; int j; int FADDR = i; image[i++] = faddr >> 8; // FADDR initial contents image[i++] = faddr & 0xFF; int PROGN = i; image[i++] = progn >> 8; // PROGN initial contents image[i++] = progn & 0xFF; int start = i; if (lastMon != -1) { image[i++] = 0x55; // LDHX PROGN get bytes left to program image[i++] = PROGN; image[i++] = 0x27; // BEQ DONE branch if all done int patchDone = i; image[i++] = 0; image[i++] = 0x65; // CPHX #PAGESIZE only page full at a time image[i++] = 0; image[i++] = PAGESIZE; image[i++] = 0x25; // BLO DOIT image[i++] = 2; image[i++] = 0xAE; // LDX #PAGESIZE image[i++] = PAGESIZE; image[i++] = 0x9F; // TXA image[i++] = 0x87; // PSHA image[i++] = 0xB6; // LDA PROGN+1 image[i++] = PROGN + 1; image[i++] = 0x9E; // SUB 1,SP image[i++] = 0xE0; image[i++] = 1; image[i++] = 0xB7; // STA PROGN+1 image[i++] = PROGN + 1; image[i++] = 0xB6; // LDA PROGN image[i++] = PROGN; image[i++] = 0xA2; // SBC #0 image[i++] = 0; image[i++] = 0xB7; // STA PROGN image[i++] = PROGN; image[i++] = 0x9F; // TXA image[i++] = 0x4A; // DECA image[i++] = 0xBB; // ADD FADDR+1 image[i++] = FADDR + 1; image[i++] = 0xB7; // STA LADDR+1 image[i++] = LADDR + 1; image[i++] = 0xB6; // LDA FADDR image[i++] = FADDR; image[i++] = 0xA9; // ADC #0 image[i++] = 0; image[i++] = 0xB7; // STA LADDR image[i++] = LADDR; image[i++] = 0x45; // LDHX #DATABUF image[i++] = DATABUF >> 8; image[i++] = DATABUF & 0xFF; image[i++] = 0x86; // PULA int getMore = i; image[i++] = 0x87; // PSHA image[i++] = 0xCD; // JSR GETBYTE image[i++] = GETBYTE >> 8; image[i++] = GETBYTE & 0xFF; image[i++] = 0xF7; // STA ,X image[i++] = 0x5C; // INCX image[i++] = 0x86; // PULA image[i++] = 0x4A; // DECA image[i++] = 0x26; // BNE GETMORE j = i; image[i++] = (getMore - (j + 1)) & 0xFF; image[i++] = 0x55; // LDHX FADDR image[i++] = FADDR; image[i++] = 0xCD; // JSR PRGRNGE image[i++] = PRGRNGE >> 8; image[i++] = PRGRNGE & 0xFF; image[i++] = 0x8B; // PSHH Annoyingly JB8 RDVRNG leaves H:X off by one image[i++] = 0x89; // PSHX compared to GZ16 necessiating this pus/pul sequence image[i++] = 0x55; // LDHX FADDR image[i++] = FADDR; image[i++] = 0xA6; // LDAA #1 image[i++] = 1; image[i++] = 0xCD; // JSR RDVRRNG image[i++] = RDVRRNG >> 8; image[i++] = RDVRRNG & 0xFF; image[i++] = 0x88; // PULX image[i++] = 0x8A; // PULH image[i++] = 0x35; // STHX FADDR image[i++] = FADDR; image[i++] = 0xCD; // JSR PUTBYTE image[i++] = PUTBYTE >> 8; image[i++] = PUTBYTE & 0xFF; image[i++] = 0x20; // BRA start j = i; image[i++] = (start - (j + 1)) & 0xFF; image[patchDone] = (i - (patchDone + 1)) & 0xFF; image[i++] = 0x45; // LDHX #SP+1 ; restore stack pointer image[i++] = (SP + 1) >> 8; image[i++] = (SP + 1) & 0xFF; image[i++] = 0x94; // TXS image[i++] = 0xCC; // JMP back to MON (this is the only way) image[i++] = MONRTN >> 8; image[i++] = MONRTN & 0xFF; if (i >= WORKTOP) { // leave some stack space for monitor routines flsprintf(stderr, "Not enough WORKRAM on target"); abort(); } writeMemory(WORKRAM, i - WORKRAM, 0); lastMon = -1; } else writeMemory(WORKRAM, 4, 0); runFrom(start, 0x00, 0x00, 0); while (progn) { int n = progn < PAGESIZE ? progn : PAGESIZE; int sum = 0; for (i = 0; i < n; ++i) { putByte(image[faddr + i]); } for (i = 0; i < n; ++i) { int b = getByte(); // flsprintf(stderr,"%d %02X\n",i,b); sum = (sum + b) & 0xFF; if (b != image[faddr + i]) flsprintf( stderr, "Program data transfer error, at %04X sent %02X got %02\n", faddr + i, image[faddr + i], b); } int back = getByte(); // flsprintf(stderr,"%02X\n",back); if (back != sum) flsprintf(stderr, "Program checksum failure, at %04X size %04X checksum " "calculated %02X received %02X\n", faddr, n, sum, back); progn -= n; faddr += n; if (verbose) flsprintf(stdout, "."); } return 0; } void massErase() { // NOTE! to override flash security and erase FLBPR must be used as the // erase address for mass erase if (verbose) flsprintf(stdout, "Mass erase\n"); callMonitor(ERARRNG, 0x40, 0, EADDR, 0); } void flashProgram(int addr, int size, int verify) { if (addr < FLASH) { flsprintf(stdout, "Programming address %04X below flash start address %04X\n", addr, FLASH); exit(0); } if (useFastProg) { if (verbose) flsprintf(stdout, "Program %04X - %04X ", addr, addr + size - 1); fastProg2(addr, size); if (verbose) flsprintf(stdout, "\n"); } else { while (size > 0) { int n = size <= PAGESIZE ? size : PAGESIZE; if (verbose) flsprintf(stdout, "Program %04X - %04X ", addr, addr + n - 1); memcpy(&image[DATABUF], &image[addr], n); writeMemory(DATABUF, n, verbose); callMonitor(PRGRNGE, 0, 0, addr, addr + n - 1); if (verify) { int cca = callMonitor(RDVRRNG, 0, 1, addr, addr + n - 1); int sum = 0; int i; for (i = 0; i < n; ++i) sum = (sum + image[addr + i]) & 0xFF; int back = cca & 0xFF; // get Accu from target if (sum != back) { flsprintf(stderr, "Program checksum failure, at %04X size %04X " "checksum calculated %02X received %02\n", addr, n, sum, back); abort(); } if (!(cca & 0x0100)) { // check Carry bit from target flsprintf(stderr, "Verify failed\n"); abort(); } if (verbose) flsprintf(stdout, "OK"); } if (verbose) flsprintf(stdout, "\n"); addr += n; size -= n; } } } int readSrec(int verbose, FILE* sf, unsigned char* image, int size, int base, int* ranges, int rn) { if (verbose) flsprintf(stdout, "Reading S-records\n"); memset(image, 0xff, size); char line[2 + 2 + 255 * 2 + 2 + 1]; // Sx + count + 255 bytes for data address & checksum + CR/LF // +nul (in windows) int amax = 0; int rc = 0; while (fgets(line, sizeof(line), sf) != NULL) { int o = 0; if (line[0] == 'S') { unsigned int n, a; sscanf(line + 2, "%2x", &n); n--; if (line[1] == '1') { sscanf(line + 4, "%4x", &a); n = n - 2; o = 8; } if (line[1] == '2') { sscanf(line + 4, "%6x", &a); n = n - 4; o = 10; } if (line[1] == '3') { sscanf(line + 4, "%8x", &a); n = n - 6; o = 12; } if (o != 0) { int i, j; if (ranges) { for (i = 0; i < rc; i += 2) { int rlo = ranges[i]; int rhi = rlo + ranges[i + 1]; if (!((a + n <= rlo) || (rhi <= a))) { flsprintf(stderr, "Overlapping S-record ranges %04X,%04X " "and %0x4 %04X\n", rlo, rhi - rlo, a, n); abort(); } } if (rc + 2 >= rn) return -1; ranges[rc] = a; ranges[rc + 1] = n; rc += 2; int cf = 0; do compact : { for (i = 0; i < rc; i += 2) { for (j = i + 2; j < rc; j += 2) { cf = 1; if (ranges[i] + ranges[i + 1] == ranges[j]) ranges[i + 1] += ranges[j + 1]; else if (ranges[i] == ranges[j] + ranges[j + 1]) ranges[i] -= ranges[j + 1]; else cf = 0; if (cf) { for (i = j + 2; i < rc; i++) ranges[i] = ranges[i + 2]; rc -= 2; cf = 0; goto compact; } } } } while (cf) ; } for (i = 0; i < n; ++i) { unsigned int d; sscanf(line + o + i * 2, "%2x", &d); if ((a >= base) && (a < base + size)) { image[a - base] = d; a++; amax = a > amax ? a : amax; } } } } if (verbose > 1) flsprintf(stdout, ">>> %s", line); if (verbose && o == 0) flsprintf(stdout, "Line ignored: %s\n", line); } if (verbose) { if (ranges) { int i; for (i = 0; i < rc; i += 2) flsprintf(stdout, "S-record data address %06X size %06X\n", ranges[i], ranges[i + 1]); } flsprintf(stdout, "\n"); } return rc; } void printHelp() { flsprintf(stdout, "bl08 burns MC68HC908 Flash memory from S-record file(s) using " "Monitor mode\n"); flsprintf(stdout, "Usage: \n"); flsprintf(stdout, " bl08 [-abcdefhiklmnpqrstuvx] [filename...]\n"); flsprintf( stdout, " -a address Set dump memory address (needs -s option too)\n"); flsprintf(stdout, " -b baudrate Set baudrate for target communication\n"); flsprintf(stdout, " -c device Set serial com device used to communicate with " "target\n"); flsprintf(stdout, " typically /dev/ttyS0 \n"); flsprintf( stdout, " -d dumpformat Set dump format, supported formats are: 'srec'\n"); flsprintf(stdout, " -e Erase target using mass erase mode, clearing " "security bytes\n"); flsprintf(stdout, " -f Use fast programming method"); flsprintf(stdout, " -g address Go execute target code from address or use '-g " "reset'\n"); flsprintf(stdout, " -h Print out this help text\n"); flsprintf(stdout, " -i Read input (S-records) from standard inputi\n"); flsprintf(stdout, " -k Kill previous instance of bl08\n"); flsprintf(stdout, " -l verbosity Set verbosity level, valid values are 0-4, " "default 1\n"); flsprintf(stdout, " -m Terminal emulator mode\n"); flsprintf(stdout, " -n Print bl08 version number\n"); flsprintf(stdout, " -o param=value Override target parameter value\n"); flsprintf(stdout, " param = " "ROMBASE,FLASH,PUTBYTE,GETBYTE,RDVRRNG,MONRTN\n"); flsprintf(stdout, " " "ERARRNG,PRGRNGE,FLBPR,MONDATA,PAGESIZE,EADDR\n"); flsprintf(stdout, " -p Use page erase when programming flash\n"); flsprintf(stdout, " -q Run quietly, same as -l 0\n"); flsprintf(stdout, " -s size Set dump memory size\n"); flsprintf(stdout, " -r pulse Pulse DTR for pulse milliseconds\n"); flsprintf(stdout, " -t cputype Set CPU type, valid values are: 'gz16'\n"); flsprintf(stdout, " -u Upload only (do not program flash)\n"); flsprintf(stdout, " -v Verify when programming \n"); flsprintf(stdout, " -x cpuspeed Set CPU speed, typically set for Fbus (in MHz) " "x 4 \n"); flsprintf(stdout, " -z Do not program, do no upload, just read in the " "S-rec file \n"); flsprintf(stdout, " addresses and sizes in decimal, for hex prefix with '0x'\n"); // Example exit(0); } void termEmu() { int STDIN = 0; int STDOUT = 1; // get rid of stuff that has been echoed to us tcflush(com, TCIFLUSH); // .. then get rid of the echoes and what ever... struct termios newtio, oldtio; tcgetattr(STDIN, &oldtio); // we do not want to change the console setting // forever, so keep the old tcgetattr(STDIN, &newtio); // configure the console to return as soon as it // a key is pressed newtio.c_lflag = 0; newtio.c_cc[VTIME] = 0; newtio.c_cc[VMIN] = 1; tcsetattr(STDIN, TCSANOW, &newtio); flsprintf(stdout, "\nTerminal mode, press CTRL-C to exit.\n"); fd_set readfs; int maxfd; int res; char buf[2]; maxfd = com + 1; while (1) { // wait for something from console or serial port FD_SET(STDIN, &readfs); FD_SET(com, &readfs); struct timeval tout; tout.tv_usec = 10; tout.tv_sec = 0; select(maxfd, &readfs, NULL, NULL, &tout); // copy console stuff to the serial port if (FD_ISSET(STDIN, &readfs)) { res = read(STDIN, buf, 1); if (buf[0] == 3) break; // CTRL-C terminates terminal mode write(com, buf, res); } // copy serial port stuff to console if (FD_ISSET(com, &readfs)) { res = read(com, buf, 1); write(STDOUT, buf, res); fflush(stdout); } } tcsetattr(0, TCSANOW, &oldtio); // restore console settings /// close(con); } void setCPUtype(char* cpu) { if (strcmp("gz16", cpu) == 0) { // These settings depend on the CPU version FLASH = 0xC000; PUTBYTE = 0xFEAF; GETBYTE = 0x1C00; RDVRRNG = 0x1C03; ERARRNG = 0x1C06; PRGRNGE = 0x1C09; MONRTN = 0xFE20; FLBPR = 0xFF7E; EADDR = FLBPR; MONDATA = 0x48; PAGESIZE = 64; } else if (strcmp("jb8", cpu) == 0) { // These settings depend on the CPU version FLASH = 0xDC00; PUTBYTE = 0xFED6; GETBYTE = 0xFC00; RDVRRNG = 0xFC03; ERARRNG = 0xFC06; PRGRNGE = 0xFC09; MONRTN = 0xFE55; FLBPR = 0xFE09; EADDR = FLASH; MONDATA = 0x48; PAGESIZE = 64; } else { flsprintf(stderr, "Unsupported CPU type '%s'\n", cpu); abort(); } // these are independent of CPU type DATABUF = MONDATA + 4; WORKRAM = DATABUF + PAGESIZE; WORKTOP = 0xF0; // this leaves 16 bytes for stack, the deepest ROM routines // use 11 so there some for myself too CTRLBYT = MONDATA + 0; CPUSPD = MONDATA + 1; LADDR = MONDATA + 2; if (DATABUF + PAGESIZE > 0xFF) { flsprintf(stderr, "bl08 limitation, DATABUF+PAGESIZE>0xFF, DATABUF=%04X, " "PAGESIZE=%04X\n", DATABUF, PAGESIZE); abort(); } } int getIntArg(char* arg) { if (strlen(arg) >= 2 && memcmp(arg, "0x", 2) == 0) { unsigned int u; sscanf(arg + 2, "%X", &u); return u; } else { int d; sscanf(arg, "%d", &d); return d; } } void parseOverride(char* str) { char* vp = strstr(str, "="); if (!vp) { flsprintf(stderr, "Bad override syntax, no '=' found\n"); abort(); } *vp = 0; vp++; int val = getIntArg(vp); if (strcmp("ROMBASE", str) == 0) { GETBYTE = val + 0; RDVRRNG = val + 3; ERARRNG = val + 6; PRGRNGE = val + 9; } else if (strcmp("FLASH", str) == 0) FLASH = val; else if (strcmp("PUTBYTE", str) == 0) PUTBYTE = val; else if (strcmp("GETBYTE", str) == 0) GETBYTE = val; else if (strcmp("RDVRRNG", str) == 0) RDVRRNG = val; else if (strcmp("ERARRNG", str) == 0) ERARRNG = val; else if (strcmp("PRGRNGE", str) == 0) PRGRNGE = val; else if (strcmp("FLBPR", str) == 0) FLBPR = val; else if (strcmp("MONDATA", str) == 0) MONDATA = val; else if (strcmp("PAGESIZE", str) == 0) PAGESIZE = val; else if (strcmp("MONRTN", str) == 0) MONRTN = val; else if (strcmp("EADDR", str) == 0) EADDR = val; else { flsprintf(stderr, "Attempt to override unrecognized variable %s\n", str); abort(); } } void parseArgs(int argc, char* argv[]) { int c; while ((c = getopt(argc, argv, "a:b:c:d:efg:hikl:mno:pqr:s:t:uvx:z")) != -1) { switch (c) { case 'a': dumpStart = getIntArg(optarg); break; case 'b': sscanf(optarg, "%d", &baudRate); break; case 'c': COM = optarg; break; case 'd': dumpFormat = optarg; break; case 'e': eraseFlash = 1; break; case 'f': useFastProg = 1; break; case 'g': executeCode = optarg; break; case 'h': printHelp(); break; case 'i': useStdin = 1; break; case 'k': killPrevious = 1; break; case 'l': sscanf(optarg, "%d", &verbose); break; case 'm': terminalMode = 1; break; case 'n': flsprintf(stdout, "%s\n", version); break; case 'p': pageErase = 1; break; case 'o': parseOverride(optarg); break; case 'q': verbose = 0; break; case 'r': resetPulse = getIntArg(optarg); break; case 's': dumpSize = getIntArg(optarg); break; case 't': setCPUtype(optarg); break; case 'u': uploadOnly = 1; break; case 'v': verify = 1; break; case 'x': sscanf(optarg, "%d", &CPUSPEED); break; case 'z': loadOnly = 1; break; case '?': if (isprint(optopt)) fprintf(stderr, "Unknown option `-%c'.\n", optopt); else fprintf(stderr, "Unknown option character `\\x%x'.\n", optopt); default: fprintf(stderr, "Bug, unhandled option '%c'\n", c); abort(); } } if (argc <= 1) printHelp(); } void ioctlErrCheck(int e) { if (e) { flsprintf(stdout, "ioctl returned %d\n", e); abort(); } } void generateReset() { #define TIOCM_DTR 0x002 int s; ioctlErrCheck(ioctl(com, TIOCMGET, &s)); s |= TIOCM_DTR; ioctlErrCheck(ioctl(com, TIOCMSET, &s)); struct timespec tspec; tspec.tv_sec = resetPulse / 1000; tspec.tv_nsec = (resetPulse % 1000) * 1000000; nanosleep(&tspec, 0); s &= ~TIOCM_DTR; ioctlErrCheck(ioctl(com, TIOCMSET, &s)); } void deletePidFile() { int stat = remove(PIDFILENAME); if (stat) printf("remove returned %d\n", stat); } void killPreviousInstance() { atexit(deletePidFile); int pid; FILE* pidf = fopen(PIDFILENAME, "r"); if (pidf) { fscanf(pidf, "%d", &pid); int stat = kill(pid, SIGKILL); if (stat != 0) printf("kill returned %d\n", stat); fclose(pidf); waitpid(pid, &stat, 0); if (WIFEXITED(stat) == 0) printf("waitpid returned %d\n", WIFEXITED(stat)); } pidf = fopen(PIDFILENAME, "w"); fprintf(pidf, "%d\n", getpid()); fclose(pidf); } int main(int argc, char* argv[]) { // default values setCPUtype("gz16"); CPUSPEED = 8; baudRate = 14400; parseArgs(argc, argv); if (killPrevious) killPreviousInstance(); if (verbose) flsprintf(stdout, "bl08 - MC68HC908 Bootloader - version %s\n", version); memset(image, 0xFF, sizeof(image)); int maxrc = 256; int ranges[maxrc]; int rc = 0; if (useStdin) rc += readSrec(verbose, stdin, image, sizeof(image), 0x0000, ranges + rc, maxrc - rc); int i; for (i = optind; i < argc; i++) { char* filename = argv[i]; FILE* sf = fopen(filename, "r"); if (sf == NULL) { flsprintf(stderr, "Failed to open '%s'\n", filename); abort(); } int rn = readSrec(verbose, sf, image, sizeof(image), 0x0000, ranges + rc, maxrc - rc); if (rn < 0) { flsprintf( stderr, "Too many discontinuous data ranges in S-record file '%s'\n", filename); abort(); } rc += rn; fclose(sf); } if (!loadOnly) { initSerialPort(); if (resetPulse) generateReset(); if (eraseFlash) { connectTarget(); massErase(); } if (rc > 0) { connectTarget(); if (pageErase) { for (i = 0; i < rc;) { int addr = ranges[i++]; int size = ranges[i++]; int a = addr / PAGESIZE * PAGESIZE; while (a < addr + size) { if (verbose) flsprintf(stdout, "Erase %04X - %04X\n", a, PAGESIZE); callMonitor(ERARRNG, 0, 0, a, 0); a += PAGESIZE; } } } else massErase(); int i; for (i = 0; i < rc;) { int addr = ranges[i++]; int size = ranges[i++]; if (uploadOnly) { if (verbose) flsprintf(stdout, "Uploading memory contents\n"); writeMemory(addr, size, verbose); if (verbose) flsprintf(stdout, "\n"); } else flashProgram(addr, size, verify); if (verbose > 1) { flsprintf(stdout, "Reading back memory/flash content"); readMemory(addr, size, verbose); flsprintf(stdout, "\n"); dumpMemory(addr, size); } } } if (executeCode) { connectTarget(); int addr; if (strcmp("reset", executeCode) == 0) { readMemory(0xFFFE, 2, 0); addr = ((image[0xFFFE] & 0xFF) << 8) | (image[0xFFFF] & 0xFF); } else addr = getIntArg(executeCode); if (verbose) flsprintf(stdout, "Execute code from %04X\n", addr); runFrom(addr, 0, 0, 0); } if (terminalMode) termEmu(); } if (dumpSize > 0) { if (!loadOnly) { connectTarget(); if (verbose) flsprintf(stdout, "Reading memory\n"); readMemory(dumpStart, dumpSize, verbose); } if (verbose) flsprintf(stdout, "\n"); if (dumpFormat) { if (strcmp("srec", dumpFormat) == 0) dumpMemorySrec(dumpStart, dumpSize); else if (strcmp("hex", dumpFormat) == 0) dumpMemory(dumpStart, dumpSize); else flsprintf(stderr, "Unknown dump format '%s'\n", dumpFormat); } } return 0; }