sp12mega8/ 40775 10243 30014 0 7605321122 12345 5ustar jrothweihomesyssp12mega8/sp12.c100644 10243 30014 171574 7605063223 13455 0ustar jrothweihomesys/* SP12: A serial programmer for working with Atmel AVR uCs */ /* Copyright (C) 1997-2001 Ken Huntington, Kevin Towers, Pitronics. */ /* 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 */ /* 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 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. */ /* Pitronics can be reached by email: sbolt@xs4all.nl */ /* Kevin Towers can be reached by email: ktowers@omnexcontrols.com */ /* Ken Huntington can be reached by email: kenh@compmore.net */ #include #include #include #ifndef LINUX #include #else #include "dos_cpt.h" #endif #include #include "sp12.h" const char USAGE[] = { " SP12/32 version 1.0.3jhr: A serial programmer for Atmel AVR uCs.\n" " Copyright (C) 1997-2001 Ken Huntington, Kevin Towers, Pitronics. \n" "SYNOPSIS\n" " sp12 - [filename or address(:data)] - [filename...\n" "OPTIONS\n" " i - init L2, L3 - lock modes\n" " e - eprom area S0, S1 - FSTRT modes\n" " p - program area R0, R1 - RC enable/disable\n" " w - write to area D0, D1 - BODEN modes\n" " r - read from area V0, V1 - BODLEVEL select\n" " a - address(:data) next K[nnn] - CKSEL fuses\n" " f - filename next A0, A1 - EESAVE modes\n" " I - create Intel Hex file U[nn] - SUT fuses\n" " H - Hex dump with ascii rF - read lock & fuse bits\n" " E - chip erase M[n.n] - match Sck to uC clock\n" " B - blank check P[nnn] - parallel port control\n" " C - calculate checksum o0, o1 - optimization\n" " X - Atmega8 flag bits,mask. Y - Atmega8 high flag bits,mask.\n" "EXAMPLES\n" " sp12 -wpfC prog.hex -wefC data.eep -L2 (Writes prog.hex into \n" " program area, and data.eep into eeprom area, providing\n" " checksums for both; the device is then locked mode 2)\n" " sp12 -wea 0x01:153 (Writes 153 into eeprom address 0x01.\n" " Other data formats: 0x99, 0231, B10011001\n"}; static int initFlag = 0; /* i on command line; flag set nn */ static int flashFlag = 0; /* p on command line */ static int eepromFlag = 0; /* e */ static int writeFlag = 0; /* w */ static int readFlag = 0; /* r */ static int lockFlag = 0; /* L, 2, 3 */ static int RCENflag = 0; /* R, 0, 1 */ static int FSTRTflag = 0; /* S, 0, 1 */ static int CKSELflag = 0; /* K, nnn */ static int SUTflag = 0; /* U, nnn */ static int BODENflag = 0; /* D, 0, 1 */ static int BODLEVELflag = 0; /* V, 0, 1 */ static int EESAVEflag = 0; /* A, 0, 1 */ static int readLockFuseFlag = 0; /* F */ static int fileFlag = 0; /* d */ static int addressFlag = 0; /* a */ static int eraseFlag = 0; /* E */ static int blankChkFlag = 0; /* B */ static int checksumFlag = 0; /* C */ static int testFlag = 0; /* T */ static int portFlag = 0; /* P */ static int optimizeFlag = 0; /* o, 0, 1 */ static int overlayFlag = 0; /* O, 0, 1 */ static float clkSpeed = 0; /* M, value between 0.1 and 12 */ static float prevClkSpeed = 0; /* previous clkSpeed */ static int IntelFlag = 0; /* I */ static int hexAsciiFlag = 0; /* H */ static int addressAvailable = 0; static int pathAvailable = 0; static char flashPath[MAXLEN]; /* path/filename source or destination */ static char eepromPath[MAXLEN]; /* path/filename source or destination */ static char checksumPath[MAXLEN]; /* path/filename source */ static char commandStr[MAXLEN]; /* stores commands for logging */ static unsigned int flashAddress = 0; static unsigned int flashData = 0; static unsigned int eepromAddress = 0; static unsigned int eepromData = 0; static unsigned int *flashBuf; /* flash buffer */ static unsigned int *eepromBuf; /* eeprom buffer */ static unsigned char M8_newFlagsL=0, M8_newFlagsLmask=0; static unsigned char M8_newFlagsH=0, M8_newFlagsHmask=0; void exitSp12(int exitState) { char binary[9] = "76543210"; /* Stores conversion num to binary */ portControl(DEFAULT_EXIT_STATE, 1); num2bin((unsigned char) DEFAULT_EXIT_STATE, binary); printf("Writing the byte %#04x (%d, B%s) ", DEFAULT_EXIT_STATE, DEFAULT_EXIT_STATE, binary); printf("to the parallel port data bits.\n"); if (flashBuf) free(flashBuf); if (eepromBuf) free(eepromBuf); exit(exitState); } /* Read the device code. If initFlag is 0, then set the parameters */ /* according to the code; else set them as indicated by initFlag. */ /* Quit if the device code is unrecognized and initFlag = 0 */ /* Return the device code, or 1 in case the device is not recognized */ /* or 12 in case initFlag is 12, forcing asumption of a 1200. */ int setDevicePars(int initFlag) { int deviceCode = 0; readDeviceCode(); deviceCode = deviceCode | device.sigByte_2; deviceCode = deviceCode << 8; deviceCode = deviceCode | device.sigByte_1; fprintf(stderr,"deviceCode 0x%x\n",deviceCode); switch (deviceCode) { case 0x0190: strcpy(device.name, "AT90S1200(A)"); device.eepromLimit = 64; device.flashLimit = 512; device.fuseMode = 0; break; case 0x0191: strcpy(device.name, "AT90S2313"); device.eepromLimit = 128; device.flashLimit = 1024; device.fuseMode = 0; break; case 0x0691: case 0x0391: strcpy(device.name, "AT90(L)S2343 or Tiny22(L)"); device.eepromLimit = 128; device.flashLimit = 1024; device.fuseMode = 4; break; case 0x0291: strcpy(device.name, "AT90(L)S2323"); device.eepromLimit = 128; device.flashLimit = 1024; device.fuseMode = 5; break; case 0x0192: strcpy(device.name, "AT90S4414"); device.eepromLimit = 256; device.flashLimit = 2048; device.fuseMode = 0; break; case 0x0591: strcpy(device.name, "AT90(L)S2333"); device.eepromLimit = 128; device.flashLimit = 1024; device.fuseMode = 7; break; case 0x0392: strcpy(device.name, "AT90(L)S4433"); device.eepromLimit = 256; device.flashLimit = 2048; device.fuseMode = 7; break; case 0x0292: strcpy(device.name, "AT90(L)S4434"); device.eepromLimit = 256; device.flashLimit = 2048; device.fuseMode = 5; break; case 0x0193: strcpy(device.name, "AT90S8515"); device.eepromLimit = 512; device.flashLimit = 4096; device.fuseMode = 0; break; case 0x0393: strcpy(device.name, "AT90(L)S8535"); device.eepromLimit = 512; device.flashLimit = 4096; device.fuseMode = 5; break; case 0x0196: strcpy(device.name, "ATmega603"); device.eepromLimit = 2048; device.flashLimit = 32768L; device.fuseMode = 6; device.pageMode = 1; break; case 0x0101: // Atmel's mask error patch case 0x0197: strcpy(device.name, "ATmega103"); device.eepromLimit = 4096; device.flashLimit = 65536L; device.fuseMode = 6; device.pageMode = 1; break; case 0x0793: strcpy(device.name, "ATmega8"); device.eepromLimit = 512; device.flashLimit = 8192; device.fuseMode = 8; /* Check this. */ device.pageMode = 1; /* Check this. */ break; default: strcpy(device.name, "unknown device, or no device"); device.eepromLimit = 0; device.flashLimit = 0; deviceCode = 1; } switch (device.sigByte_0) { case 0x1E: strcpy(device.madeBy, "Atmel"); break; default: strcpy(device.madeBy, "an unknown manufacturer"); } switch (initFlag) { case 12: strcpy(device.name, "AT90S1200(A)"); device.eepromLimit = 64; device.flashLimit = 512; device.fuseMode = 0; deviceCode = 12; break; case 13: strcpy(device.name, "AT90S2313"); device.eepromLimit = 128; device.flashLimit = 1024; device.fuseMode = 0; break; case 22: case 43: strcpy(device.name, "AT90(L)S2343 or Tiny22(L)"); device.eepromLimit = 128; device.flashLimit = 1024; device.fuseMode = 4; break; case 23: strcpy(device.name, "AT90(L)S2323"); device.eepromLimit = 128; device.flashLimit = 1024; device.fuseMode = 5; break; case 14: strcpy(device.name, "AT90S4414"); device.eepromLimit = 256; device.flashLimit = 2048; break; case 233: strcpy(device.name, "AT90(L)S2333"); device.eepromLimit = 128; device.flashLimit = 1024; device.fuseMode = 7; break; case 433: strcpy(device.name, "AT90(L)S4433"); device.eepromLimit = 256; device.flashLimit = 2048; device.fuseMode = 7; break; case 34: strcpy(device.name, "AT90(L)S4434"); device.eepromLimit = 256; device.flashLimit = 2048; device.fuseMode = 5; break; case 15: strcpy(device.name, "AT90S8515"); device.eepromLimit = 512; device.flashLimit = 4096; break; case 35: strcpy(device.name, "AT90(L)S8535"); device.eepromLimit = 512; device.flashLimit = 4096; device.fuseMode = 5; break; case 603: strcpy(device.name, "ATmega603"); device.eepromLimit = 2048; device.flashLimit = 32768L; device.fuseMode = 6; device.pageMode = 1; break; case 103: strcpy(device.name, "ATmega103"); device.eepromLimit = 2048; device.flashLimit = 65536L; device.fuseMode = 6; device.pageMode = 1; break; case 0: break; default: printf("WARNING: -i%d is not a supported device.\n\n", initFlag); } device.initPerformed = 1; return(deviceCode); } /* Lock the device by mode. Quoting the AT90S1200 datasheet: */ /* Mode 2: further programming of the flash is disabled. */ /* Mode 3: same as mode 2, but verify is also disabled. */ void lockDevice(void) { if (lockFlag == 2) { writeLockBits(lockFlag); printf("Device now write-protected.\n"); } if (lockFlag == 3) { writeLockBits(lockFlag); printf("Device now read- and write-protected.\n"); } lockFlag = 0; } /* Program the RCEN fuse bit (valid only for certain AT90S2343 */ /* and Tiny22 uCs, check sp12.doc for details). */ /* 0: Internal RC clock enabled. */ /* 1: Internal RC clock disabled. */ /* Note that the fuse bit can be altered even if the device is */ /* locked mode 3. */ void progRCEN(void) { if (RCENflag == 10) { if (writeRCENfuse(RCENflag) == 0) { printf("Internal RC clock enabled, if available;\n"); printf("check sp12.doc for details.\n"); } else { printf("Internal RC clock STILL DISABLED.\n"); } } if (RCENflag == 11) { if (writeRCENfuse(RCENflag) == 0) { printf("Internal RC clock disabled, if external clock option\n"); printf("is available; check sp12.doc for details.\n"); } else { printf("Internal RC clock STILL ENABLED.\n"); } } RCENflag = 0; } /* Program the FSTRT fuse (valid only for the AT90S2323, 4434, 8535) */ /* 0: Short start-up time selected. */ /* 1: Default (long) start-up time selected. */ /* Note that the fuse bit can be altered even if the device is */ /* locked mode 3. */ void progFSTRT(void) { if (FSTRTflag == 10) { if (writeFSTRTfuse(FSTRTflag) == 0) printf("Short start-up time selected.\n"); else printf("Default (long) start-up time STILL SELECTED.\n"); } if (FSTRTflag == 11) { if (writeFSTRTfuse(FSTRTflag) == 0) printf("Default (long) start-up time selected.\n"); else printf("Short start-up time STILL SELECTED.\n"); } FSTRTflag = 0; } /* Program the fuse bits. */ /* (Valid only for the AT90S2333, 4433 and ATmega103/603). */ int progFUSES(void) { unsigned char fuses; char binary[9] = "76543210"; /* Stores conversion num to binary */ fuses = readLockFuse(); if (device.fuseMode == 6) { if (EESAVEflag && (fuses & 0xC0) != 0xC0) { if ((fuses & 0xC0) == 0x80) printf("WARNING: The device is write-protected;\n"); if ((fuses & 0xC0) == 0) printf("WARNING: The device is read- and write-protected;\n"); printf("Therefore EESAVE mode can't be changed.\n"); } fuses = fuses & 0x3F; fuses = fuses | 0x34; if (SUTflag != 0) { SUTflag = SUTflag - 1; SUTflag = SUTflag & 0x03; fuses = fuses | SUTflag; SUTflag = SUTflag | 0xFC; fuses = fuses & SUTflag; SUTflag = 0; } if (EESAVEflag == 10) fuses = fuses & 0xF7; if (EESAVEflag == 11) fuses = fuses | 0x08; EESAVEflag = 0; writeFUSES(fuses); /* * Read back as check: */ fuses = readLockFuse(); printf("The following information was read back from\n"); printf("the fuse bits:\n"); printf(" Start-up time code selected is %d (", fuses & 0x03); switch (fuses & 0x03) { case 0: printf ("5 CPU cycles)\n"); break; case 1: printf ("512 WDT cycles)\n"); break; case 2: printf ("4K WDT cycles)\n"); break; case 3: printf ("16K WDT cycles)\n"); break; default: break; } if (fuses & 0x08) printf(" EEPROM is NOT preserved thru chip erase\n"); else printf(" EEPROM is preserved thru chip erase\n"); } if (device.fuseMode == 7) { fuses = fuses & 0x3F; if (CKSELflag != 0) { CKSELflag = CKSELflag - 1; CKSELflag = CKSELflag & 0x07; fuses = fuses | CKSELflag; CKSELflag = CKSELflag | 0xF8; fuses = fuses & CKSELflag; CKSELflag = 0; } if (BODENflag == 10) fuses = fuses & 0xF7; if (BODENflag == 11) fuses = fuses | 0x08; BODENflag = 0; if (BODLEVELflag == 10) fuses = fuses & 0xEF; if (BODLEVELflag == 11) fuses = fuses | 0x10; BODLEVELflag = 0; writeFUSES(fuses); if ((fuses & 0x08) == 0) printf(" Brown-out detection enabled.\n"); if ((fuses & 0x08) != 0) printf(" Brown-out detection disabled.\n"); if ((fuses & 0x10) == 0) printf(" Brown-out trigger set at 4.0V.\n"); if ((fuses & 0x10) != 0) printf(" Brown-out trigger set at 2.7V.\n"); num2bin((unsigned char) fuses, binary); printf(" CKSEL = %s (datasheet page 20, table 5)\n", &binary[5]); } return(fuses); } /* Routines to program the flag bytes of the Atmega8 only. */ int progM8flagsL(char newflags, char flagmask) { char oldflags, setflags, modflags; int cmdWord; int rtnval; oldflags = (unsigned char) clockOutCommand(READ_FUSE_M8); setflags = (oldflags & ~flagmask) | (newflags & flagmask); printf("Changing low flags from 0x%x to 0x%x\n",0xff&oldflags,0xff&setflags); /* Form the appropriate command word. */ cmdWord = 0xaca0ff00 | (0xFF&setflags); rtnval = clockOutCommand(cmdWord); printf("rtnval 0x%x\n",rtnval); delay(timeConst.chipErase); modflags = (unsigned char) clockOutCommand(READ_FUSE_M8); printf("Flags now read as 0x%x\n",0xff&modflags); return 0xff&setflags; } int progM8flagsH(char newflags, char flagmask) { char oldflags, setflags; oldflags = (unsigned char) clockOutCommand(READ_FUSE_HI_M8); setflags = (oldflags & ~flagmask) | (newflags & flagmask); printf("Changing high flags from 0x%x to 0x%x\n",0xff&oldflags,0xff&setflags); return 0xff&setflags; } /* Merely check whether options -L, -E, -F, -R, -S, -K, D, V, */ /* A or U was used, and say something about it. */ void reportLEFRSKDVAUflags(void) { if (lockFlag) { printf("You have selected option -L%d to lock ", lockFlag); printf("the device,\nwhich has had no effect. Do not "); printf("use this\noption in combination with others.\n"); lockFlag = 0; } if (eraseFlag) { printf("You have selected option -E for erase, which has had no\n"); printf("effect. Options -w, -p and -f together cause an automatic\n"); printf("erase; -E should be used on its own or together with B if\n"); printf("you want a blank check afterwards.\n"); eraseFlag = 0; } if (readLockFuseFlag && device.fuseMode > 2) { printf("You have selected option -F to read the lock and fuse bits,\n"); printf("which has had no effect. This option can only be used in the\n"); printf("command -rF, not together with other options.\n"); readLockFuseFlag = 0; } if (readLockFuseFlag && device.fuseMode < 3) { printf("You have selected option -F to read the lock and fuse bits,\n"); printf("which has had no effect. This option is valid only for the\n"); printf("AT90S2323, 2343, 2333, 4433, 4434, 8535 and ATmega103/603.\n"); readLockFuseFlag = 0; } if (RCENflag && device.fuseMode == 4) { printf("You have selected option -R0 or -R1 to (un)program the\n"); printf("RCEN fuse, which has had no effect. This option can only\n"); printf("be used as a separate command, not together with other\n"); printf("options.\n"); RCENflag = 0; } if (RCENflag && device.fuseMode != 4) { printf("You have selected option -R0 or -R1 to (un)program the\n"); printf("RCEN fuse, which has had no effect. This option is valid\n"); printf("only for certain AT90S2343 and Tiny22 uCs; check sp12.doc.\n"); printf("for details.\n"); RCENflag = 0; } if (BODENflag && device.fuseMode == 7) { printf("You have selected option -D0 or -D1 to (un)program the\n"); printf("BODEN fuse, which has had no effect. This option can only\n"); printf("be used as a separate command or in combination with Vn\n"); printf("and Knnn, not together with other options.\n"); BODENflag = 0; } if (BODENflag && device.fuseMode != 7) { printf("You have selected option -D0 or -D1 to (un)program the\n"); printf("BODEN fuse, which has had no effect. This option is valid\n"); printf("only for the AT90S2333 and 4433.\n"); BODENflag = 0; } if (BODLEVELflag && device.fuseMode == 7) { printf("You have selected option -V0 or -V1 to (un)program the\n"); printf("BODLEVEL fuse, which has had no effect. This option can only\n"); printf("be used as a separate command or in combination with Dn\n"); printf("and Knnn, not together with other options.\n"); BODLEVELflag = 0; } if (BODLEVELflag && device.fuseMode != 7) { printf("You have selected option -V0 or -V1 to (un)program the\n"); printf("BODLEVEL fuse, which has had no effect. This option is valid\n"); printf("only for the AT90S2333 and 4433.\n"); BODLEVELflag = 0; } if (CKSELflag && device.fuseMode == 7) { printf("You have selected option -Knnn to program the CKSEL fuses,\n"); printf("which has had no effect. This option can only be used as\n"); printf("a separate command or in combination with Dn and Vn, not\n"); printf("not together with other options.\n"); CKSELflag = 0; } if (CKSELflag && device.fuseMode != 7) { printf("You have selected option -Knnn to program the CKSEL fuses,\n"); printf("which has had no effect. This option is valid only for\n"); printf("the AT90S2333 and 4433.\n"); CKSELflag = 0; } if (FSTRTflag && device.fuseMode == 5) { printf("You have selected option -S0 or -S1 to (un)program the\n"); printf("FSTRT fuse, which has had no effect. This option can only\n"); printf("be used as a separate command, not together with other\n"); printf("options.\n"); FSTRTflag = 0; } if (FSTRTflag && device.fuseMode != 5) { printf("You have selected option -S0 or -S1 to (un)program the\n"); printf("FSTRT fuse, which has had no effect. This option is valid\n"); printf("only for the AT90S4434 and 8535.\n"); FSTRTflag = 0; } if (EESAVEflag && device.fuseMode == 6) { printf("You have selected option -A0 or -A1 to (un)program the\n"); printf("EESAVE fuse, which has had no effect. This option can only\n"); printf("be used as a separate command or in combination with Unn,\n"); printf("not together with other options.\n"); EESAVEflag = 0; } if (EESAVEflag && device.fuseMode != 6) { printf("You have selected option -A0 or -A1 to (un)program the\n"); printf("EESAVE fuse, which has had no effect. This option is valid\n"); printf("only for the ATmega103/603.\n"); EESAVEflag = 0; } if (SUTflag && device.fuseMode == 6) { printf("You have selected option -Unn to program the SUT fuses,\n"); printf("which has had no effect. This option can only be used\n"); printf("as a separate command or in combination with An, not\n"); printf("together with other options.\n"); SUTflag = 0; } if (SUTflag && device.fuseMode != 6) { printf("You have selected option -Unn to program the SUT fuses,\n"); printf("which has had no effect. This option is valid only for\n"); printf("the ATmega103/603.\n"); SUTflag = 0; } } /* Merely check whether option -B was used, */ /* and say something about it. */ void reportBflag(void) { if (blankChkFlag) { printf("You have selected option -B for blank check, which has had \n"); printf("no effect. Options -w, -p and -f together cause an automatic\n"); printf("erase; if you also want a blank check before programming,\n"); printf("use -Bwpf. Use -EB if you just want an erase followed by a\n"); printf("blank check, or -B on its own for a blank check without a\n"); printf("preceding erase.\n"); blankChkFlag = 0; } } /* Blank check the device. */ int blank_check(void) { int signal = 0; printf("Performing blank check...\n"); signal = blankCheck(device.flashLimit, device.eepromLimit); if (signal == 0) printf("The program and eeprom area's are blank.\n"); if ((signal & 0x01) == 1) printf("The program area is NOT blank.\n"); if ((signal & 0x02) == 2) printf("The eeprom area is NOT blank.\n"); return(signal); } /* The command processor */ void processCommand(void) { long address; int error; /* Storing return value */ int lockFuse; int fuses = 0; int deviceCode = 0; char binary[9] = "76543210"; /* Stores conversion num to binary */ /* * If it hasn't been done yet, then set the device parameters * according to device code and option -i[NN] */ if (!device.initPerformed) { printf("Enabling AVR serial reading/programming...\n"); /* * First see if it's a 1200, which doesn't echo 0x53 * on the third byte of PROGRAM_ENABLE. * Initiating contact at low speed */ strcpy(device.name, "AT90S1200(A)"); setSckTiming(0.1); enableSPI(1200); deviceCode = setDevicePars(initFlag); if (deviceCode == 1) { /* * It doesn't look like a 1200. If a uC is connected, * the SPI shiftregister is not in synch. We'll now fail * if it is an out of synch 1200, but other uCs do * echo 0x53 on the third byte of PROGRAM_ENABLE. * So we'll try synch pulses for a while. */ enableSPI(0); deviceCode = setDevicePars(initFlag); if (device.sigByte_0 == 0 && device.sigByte_1 == 1 && device.sigByte_2 == 2) { printf("WARNING: You have connected an unidentifiable\n"); printf(" device, which may be locked mode 3. \n"); printf(" Access to a supported, mode 3 locked \n"); printf(" device can be regained, but only by \n"); printf(" erasing it first.\n"); printf(" Check SP12.doc for details.\n\n"); } } if (initFlag == 0) { printf("The device code bytes 0,1,2: %#x, %#x, %#x were read\n", device.sigByte_0, device.sigByte_1, device.sigByte_2); printf("from parallel port %#x and indicate the following:\n", portAddress); printf("You have connected an %s\n", device.name); printf("The device was made by %s\n\n", device.madeBy); } if (device.flashLimit == 0 || device.eepromLimit == 0) { printf("Nothing to do for sp12.\n"); exitSp12(1); } if (initFlag != 0 && device.flashLimit != 0) { printf("Device code check OVERRULED! Assuming an %s\n\n", device.name); } /* * Continue with the Sck wave form for the now known uC, * at the default speed. */ setSckTiming(clockSpdDefault); } /* * Inititalize buffers */ for (address = 0; address < device.flashLimit; address++) flashBuf[address] = 0xFFFF; for (address = 0; address < device.eepromLimit; address++) eepromBuf[address] = 0xFFF; /* * Set Sck timing to match the now known uC's wave form * and clock speed asked for by an -Mn.n command. */ if (clkSpeed && clkSpeed != prevClkSpeed) { printf("Sck timing set for %.1f MHz or higher.\n", setSckTiming(clkSpeed)); prevClkSpeed = clkSpeed; } clkSpeed = 0; /* * if r --> p || e || F * rp --> rpf --> read program area; write to file * rpa --> read program address to stdout * rp --> read program area to stdout * re --> ref --> read eeprom area; write to file * rea --> read eeprom address to stdout * re --> read eeprom area to stdout * rF --> read the lock and fuse bits * (only valid for the AT90S2323, 2343, 4434 and * 8535) * check for C * check for L, E, B, R, S, but just report them */ if (readFlag && writeFlag) { printf("Do not use options -w and -r in a single command.\n"); exitSp12(2); } if (readFlag) { readFlag = 0; if (flashFlag && eepromFlag) { printf("Do not use options -p and -e in a single command.\n"); exitSp12(2); } if (flashFlag && eepromFlag && readLockFuseFlag) { printf("Do not use options -p, -e and -F in a single command.\n"); exitSp12(2); } if (flashFlag && readLockFuseFlag) { printf("Do not use options -p and -F in a single command.\n"); exitSp12(2); } if (eepromFlag && readLockFuseFlag) { printf("Do not use options -e and -F in a single command.\n"); exitSp12(2); } if ((!pathAvailable || addressAvailable) && IntelFlag) { printf("The Intel Hex format is only available when writing\n"); printf("an entire memory area to file.\n"); exitSp12(2); } if (addressAvailable && hexAsciiFlag) { printf("A hex dump with ascii translation is only possible\n"); printf("when writing an entire memory area to file.\n"); exitSp12(2); } if (IntelFlag && hexAsciiFlag) { printf("Select either Intel Hex format or hex dump with\n"); printf("ascii translation; not both at the same time\n"); exitSp12(2); } if (flashFlag) { flashFlag = 0; if (addressAvailable) { addressAvailable = 0; flashData = readCodeWord(flashAddress); printf("The word %#06x was read from program address %#08x\n", flashData, flashAddress); } else { printf("Reading program area.\n"); readFlashArea(flashBuf, device.flashLimit); if (pathAvailable) { pathAvailable = 0; printf("Writing program area content to %s\n", flashPath); if (fileFlashBuf(flashBuf, device.flashLimit, flashPath, IntelFlag, hexAsciiFlag) != 0) { printf("%s %s\n", FILE_WRITE_ERROR, flashPath); exitSp12(2); } IntelFlag = 0; hexAsciiFlag = 0; } else { if (hexAsciiFlag) { printBuffer(flashBuf, device.flashLimit, 1); hexAsciiFlag = 0; } else { for (address = 0; address < device.flashLimit; address++) printf("%06lx:%04x\n", address, flashBuf[address]); } } } if (checksumFlag) { checksumFlag = 0; readFlashArea(flashBuf, device.flashLimit); printf("Checksum program area: %04x\n", checksum(flashBuf, device.flashLimit)); } } if (eepromFlag) { eepromFlag = 0; if (addressAvailable) { addressAvailable = 0; eepromData = readDataByte(eepromAddress); num2bin((unsigned char) eepromData, binary); printf("The byte %#04x (%d, %#o, B%s) ", eepromData, eepromData, eepromData, binary); printf("was read from eeprom address %#06x\n", eepromAddress); } else { printf("Reading eeprom area.\n"); readEepromArea(eepromBuf, device.eepromLimit); if (pathAvailable) { pathAvailable = 0; printf("Writing eeprom area content to %s\n", eepromPath); if (fileEepromBuf(eepromBuf, device.eepromLimit, eepromPath, IntelFlag, hexAsciiFlag) != 0) { printf("%s %s\n", FILE_WRITE_ERROR, eepromPath); exitSp12(2); } IntelFlag = 0; hexAsciiFlag = 0; } else { if (hexAsciiFlag) { printBuffer(eepromBuf, device.eepromLimit, 0); hexAsciiFlag = 0; } else { printf("Address: Data in hex, dec, oct, bin\n"); for (address = 0; address < device.eepromLimit; address++) { num2bin((unsigned char) eepromBuf[address], binary); printf( " %#04lx: %#04x %3d %#4o %s\n", address, eepromBuf[address], eepromBuf[address], eepromBuf[address], binary); } } } } if (checksumFlag) { checksumFlag = 0; readEepromArea(eepromBuf, device.eepromLimit); printf("Checksum eeprom area: %04x\n", checksum(eepromBuf, device.eepromLimit)); } } if (readLockFuseFlag && device.fuseMode > 2) { readLockFuseFlag = 0; lockFuse = readLockFuse(); printf("The following information was read from the\n"); printf("lock and fuse bits:\n"); if ((lockFuse & 0x01) == 0 && device.fuseMode == 4) { printf(" Internal RC clock enabled.\n"); printf(" (If available; check sp12.doc for details.)\n"); } if ((lockFuse & 0x01) == 1 && device.fuseMode == 4) { printf(" Internal RC clock disabled.\n"); printf(" (If available; check sp12.doc for details.)\n"); } if ((lockFuse & 0x01) == 0 && device.fuseMode == 5) printf(" Short start-up time selected.\n"); if ((lockFuse & 0x01) == 1 && device.fuseMode == 5) printf(" Default (long) start-up time selected.\n"); if (device.fuseMode == 6) { printf(" Start-up time code selected is %d (", lockFuse & 0x03); switch (lockFuse & 0x03) { case 0: printf ("5 CPU cycles)\n"); break; case 1: printf ("512 WDT cycles)\n"); break; case 2: printf ("4K WDT cycles)\n"); break; case 3: printf ("16K WDT cycles)\n"); break; default: break; } if (lockFuse & 0x08) printf(" EEPROM is NOT preserved thru chip erase\n"); else printf(" EEPROM is preserved thru chip erase\n"); } if (device.fuseMode == 7) { if ((lockFuse & 0x08) == 0) printf(" Brown-out detection enabled.\n"); if ((lockFuse & 0x08) != 0) printf(" Brown-out detection disabled.\n"); if ((lockFuse & 0x10) == 0) printf(" Brown-out trigger set at 4.0V.\n"); if ((lockFuse & 0x10) != 0) printf(" Brown-out trigger set at 2.7V.\n"); num2bin((unsigned char) lockFuse, binary); printf(" CKSEL = %s (datasheet page 20, table 5)\n", &binary[5]); } if (device.fuseMode == 8) { extern char lockAndFuse[4]; static char *blbmsg[4] = { "Neither Write nor read allowed.", "Read not allowed", "Write not allowed.", "No restrictions." }; static char *lbmsg[4] = { "Programming and verification disabled.", "Undefined condition", "Programming disabled, verification enabled.", "Programming and verification enabled." }; /* Decode the bits for the Atmega8. */ /* Lock bits. */ printf(" lock bits 0x%2.2x\n",0xff&lockAndFuse[0]); printf(" BLB12 BLB21: %d %d Boot Block %s\n", (lockAndFuse[0]&0x20)!=0, (lockAndFuse[0]&0x10)!=0, blbmsg[(lockAndFuse[0]>>4)&3]); printf(" BLB02 BLB01: %d %d Application %s\n", (lockAndFuse[0]&8)!=0, (lockAndFuse[0]&4)!=0, blbmsg[(lockAndFuse[0]>>2)&3]); printf(" LB1 LB0: %d %d %s\n", (lockAndFuse[0]&2)!=0, (lockAndFuse[0]&1)!=0, lbmsg[lockAndFuse[0]&3]); /* Low fuse bits. */ printf(" low fuse bits 0x%2.2x\n",0xff&lockAndFuse[1]); printf(" BODLEVEL %d BODEN %d SUT[1:0] %d CKSEL[3:0] 0x%x\n", (lockAndFuse[1]>>7)&1, (lockAndFuse[1]>>6)&1, (lockAndFuse[1]>>4)&3, lockAndFuse[1]&0xf); printf(" high fuse bits 0x%2.2x\n",0xff&lockAndFuse[2]); printf(" RTDISBL %d WDTON %d SPIEN %d CKOPT %d EESAVE %d" " BOOTSZ[1:0] %d BOOTRST %d\n", (lockAndFuse[2]>>7)&1, (lockAndFuse[2]>>6)&1, (lockAndFuse[2]>>5)&1, (lockAndFuse[2]>>4)&1, (lockAndFuse[2]>>3)&1, (lockAndFuse[2]>>1)&3, lockAndFuse[2]&1); } else if (device.fuseMode > 5) { /* 2333, 4433, mega103/603 */ if ((lockFuse & 0xC0) == 0x80) printf(" Device is write-protected.\n"); } else { /* 4434, 8535 */ if ((lockFuse & 0xC0) == 0x40) printf(" Device is write-protected.\n"); } if ((lockFuse & 0xC0) == 0) printf(" Device is read- and write-protected\n"); if ((lockFuse & 0xC0) == 0xc0) printf(" Device is not protected\n"); } reportLEFRSKDVAUflags(); reportBflag(); } /* * If w --> p || e * wp --> f || a * wpf --> chip erase; * write file to program area * wpa --> NO chip erase (warning); * write address:data * we --> f || a * wef --> write file to eeprom area * wpa --> write address:data * check for C; complete write before reading p || e * back into array to compute the checksum * check for L, E, F, R, S but just report them */ if (writeFlag) { writeFlag = 0; timeConst.byteWrite = timeConst.byteWriteDefault; timeConst.byteWriteAdjusted = 0; writeRetries = 0; if (flashFlag && eepromFlag) { printf("Do not use options -p and -e in a single command.\n"); exitSp12(2); } if (flashFlag) { flashFlag = 0; if (addressAvailable) { addressAvailable = 0; if (device.pageMode) { printf ("ERROR: Single address flash programming " "not available on ATMega's.\n"); exitSp12(2); } printf("WARNING: writing to single address in program area.\n"); printf(" Chip erase is not automatic; unless you \n"); printf(" used a separate -E command, it may not be \n"); printf(" possible to correctly write new data.\n"); printf("Writing %#06x into address %#08x in program area.\n", flashData, flashAddress); error = writeFlashVerified(flashAddress, flashData, optimizeFlag); if (logWrites(commandStr, flashAddress, flashData, flashPath, flashBuf, overlayFlag, &error) != 0) printf("%s %s\n", FILE_WRITE_ERROR, "sp12log.txt"); if (error) { printf("Readback ERROR at program address %#06x\n", flashAddress); exitSp12(3); } } else if (pathAvailable) { pathAvailable = 0; if (!overlayFlag) { printf("Performing chip erase...\n"); eraseDevice(); } if (blankChkFlag) { blankChkFlag = 0; if(blank_check()) exitSp12(3); } printf("Writing content of %s into program area.\n", flashPath); error = readFlashFile(flashPath, flashBuf, device.flashLimit); if (error) { printf("%s %s\n", flashPath, FILE_ERROR); exitSp12(2); } error = writeFlashArea(flashBuf, device.flashLimit, optimizeFlag); if (logWrites(commandStr, flashAddress, flashData, flashPath, flashBuf, overlayFlag, &error) != 0) printf("%s %s\n", FILE_WRITE_ERROR, "sp12log.txt"); if (error) { printf("Readback ERROR after %d write retries.\n", writeRetries); if (overlayFlag) printf("The error may be due to an overlay conflict.\n"); exitSp12(3); } else { printf("%s written and verified.\n", flashPath); printf("write retries: %d", writeRetries); if (!device.pageMode) printf(", byteWrite: %ld percent of default\n", (timeConst.byteWrite * 100) / timeConst.byteWriteDefault); else printf(".\n"); } } if (checksumFlag) { checksumFlag = 0; readFlashArea(flashBuf, device.flashLimit); printf("Checksum program area: %04x\n", checksum(flashBuf, device.flashLimit)); } } if (eepromFlag) { eepromFlag = 0; if (addressAvailable) { addressAvailable = 0; printf("Writing %#x into address %#x in eeprom area.\n", eepromData, eepromAddress); error=writeEepromVerified(eepromAddress, eepromData, optimizeFlag); if (logWrites(commandStr, eepromAddress, eepromData, eepromPath, eepromBuf, overlayFlag, &error) != 0) printf("%s %s\n", FILE_WRITE_ERROR, "sp12log.txt"); if (error) { printf("Readback ERROR at eeprom address %#04x\n", eepromAddress); exitSp12(3); } } else if (pathAvailable) { pathAvailable = 0; printf("Writing content of %s into eeprom area.\n", eepromPath); error = readEepromFile(eepromPath, eepromBuf, device.eepromLimit); if (error) { printf("%s %s\n", eepromPath, FILE_ERROR); exitSp12(2); } error = writeEepromArea(eepromBuf, device.eepromLimit, optimizeFlag, overlayFlag); if (logWrites(commandStr, eepromAddress, eepromData, eepromPath, eepromBuf, overlayFlag, &error) != 0) printf("%s %s\n", FILE_WRITE_ERROR, "sp12log.txt"); if (error) { printf("Readback ERROR after %d write retries.\n", writeRetries); exitSp12(3); } else { printf("%s written and verified.\n", eepromPath); printf("write retries: %d, byteWrite: %ld percent of default\n", writeRetries, (timeConst.byteWrite * 100) / timeConst.byteWriteDefault); } } if (checksumFlag) { checksumFlag = 0; readEepromArea(eepromBuf, device.eepromLimit); printf("Checksum eeprom area: %04x\n", checksum(eepromBuf, device.eepromLimit)); } reportBflag(); } reportLEFRSKDVAUflags(); overlayFlag = 0; } /* * if C --> (p || e) || ((p || e) && f) * Cp(f) --> read program area (file) into * device.flashLimit word array; * calculate checksum for array * Ce(f) --> read eeprom area (file) into * device.eepromLimit byte array; * calculate checksum for array * check for L, E, B, F, R, S but just report them */ if (checksumFlag) { checksumFlag = 0; if (eepromFlag) { eepromFlag = 0; if (pathAvailable) { pathAvailable = 0; if (readEepromFile(checksumPath, eepromBuf, device.eepromLimit) != 0) { printf("%s %s\n", checksumPath, FILE_ERROR); exitSp12(2); } else { printf("Checksum eeprom file %s: %04x\n", checksumPath, checksum(eepromBuf, device.eepromLimit)); } } else { readEepromArea(eepromBuf, device.eepromLimit); printf("Checksum eeprom area: %04x\n", checksum(eepromBuf, device.eepromLimit)); } } else if (flashFlag) { flashFlag = 0; if (pathAvailable) { pathAvailable = 0; if (readFlashFile(checksumPath, flashBuf, device.flashLimit) != 0) { printf("%s %s\n", checksumPath, FILE_ERROR); exitSp12(2); } else { printf("Checksum program file %s: %04x\n", checksumPath, checksum(flashBuf, device.flashLimit)); } } else { readFlashArea(flashBuf, device.flashLimit); printf("Checksum program area: %04x\n", checksum(flashBuf, device.flashLimit)); } } else { printf("you have selected option -C, but there is nothing\n"); printf("on the command line to calculate a checksum for.\n"); } reportLEFRSKDVAUflags(); reportBflag(); } /* * if L2 || L3 --> write lockbits mode * check for E, B, F, R, S but just report them */ if (lockFlag) { logLocks(flashBuf, lockFlag); lockDevice(); reportLEFRSKDVAUflags(); reportBflag(); } /* * if R0 || R1 --> write RCEN fuse bit 0 or 1 * check for L, E, B, F, S but just report them */ if (RCENflag) { if (device.fuseMode == 4) progRCEN(); reportLEFRSKDVAUflags(); reportBflag(); } /* * if S0 || S1 --> write FSTRT fuse bit 0 or 1 * check for L, E, B, F, R but just report them */ if (FSTRTflag) { if (device.fuseMode == 5) progFSTRT(); reportLEFRSKDVAUflags(); reportBflag(); } /* * if Knnn --> write fuse bits (changing CKSEL) * if D0 || D1 --> write fuse bits (changing BODEN) * if V0 || V1 --> write fuse bits (changing BODLEVEL) */ if (CKSELflag || BODENflag || BODLEVELflag) { if (device.fuseMode == 7) fuses = progFUSES(); if ((fuses & 0x08) == 0) { printf("(Re)enabling brown-out detection usually causes the\n"); printf("AT90(L)S2233/4433 to hang, so there is nothing further\n"); printf("to do for sp12. Before programming can continue, power\n"); printf("to the 2233/4433 must be switched off and back on again.\n"); exitSp12(0); } else { reportLEFRSKDVAUflags(); reportBflag(); } } /* * if Unn --> write fuse bits (changing SUT) * if A0 || A1 --> write fuse bits (changing EESAVE) */ if (SUTflag || EESAVEflag) { if (device.fuseMode == 6) fuses = progFUSES(); reportLEFRSKDVAUflags(); reportBflag(); } /* For the ATmega8 only. */ if(device.fuseMode == 8) { if(M8_newFlagsLmask != 0) { progM8flagsL(M8_newFlagsL,M8_newFlagsLmask); M8_newFlagsLmask = 0; } if(M8_newFlagsHmask != 0) { progM8flagsH(M8_newFlagsH,M8_newFlagsHmask); M8_newFlagsHmask = 0; } } /* * If E --> chip erase */ if (eraseFlag) { eraseFlag = 0; printf("Performing chip erase...\n"); eraseDevice(); } /* * if B --> blank check */ if (blankChkFlag) { blankChkFlag = 0; blank_check(); } /* * if i --> do nothing (init already done, device already reported) * just clear initFlag */ initFlag = 0; } int main(int argc, char *argv[]) { int ascii; /* characters on command line */ int idx = 0; /* index arguments on command line */ char *dataPtr; /* for separating address:data */ int exitFlag = 0; char binary[9] = "76543210"; /* Stores conversion num to binary */ device.initPerformed = 0; flashPath[0] = '\0'; eepromPath[0] = '\0'; checksumPath[0] = '\0'; #ifdef LINUX /* * Take control of LPT I/O ports */ if (ioperm(0x278,3,1)) {perror("ioperm error at 0x278");exit(1);} if (ioperm(0x378,3,1)) {perror("ioperm error at 0x378");exit(1);} if (ioperm(0x3BC,3,1)) {perror("ioperm error at 0x3BC");exit(1);} /* * Revoke setuid/setguid-root status */ setgid(getgid()); setuid(getuid()); #endif /* * Check if something is on the command line, print usage message * if not, else do init; if in sp12 mode, put power on the device * (using Centronics data bits as power source), enable serial * reading/programming */ if (argc < 2 || strchr(argv[1], 'h') != NULL) { printf("%s", USAGE); exit(0); } else { printf("SP12 version 1.0.3jhr performing init...\n"); initSp12(); } /* * allocate our memory buffers */ flashBuf = malloc(FLASHBUF_UPPERLIMIT * sizeof (unsigned int)); if (flashBuf == NULL) { printf ("ERROR: No memory available for buffer!\n"); exitSp12(2); } eepromBuf = malloc(EEPROMBUF_UPPERLIMIT * sizeof (unsigned int)); if (eepromBuf == NULL) { printf ("ERROR: No memory available for buffer!\n"); exitSp12(2); } /* * Dissect the command line, acting on commands from left to right. */ idx = 0; while (++idx < argc) { if (*argv[idx] != '-' && fileFlag) { fileFlag = 0; if (addressFlag) { printf("Do not use options -f and -a in a single command.\n"); exitSp12(2); } if (checksumFlag && !readFlag && !writeFlag) { strcpy(checksumPath, argv[idx]); pathAvailable = 1; processCommand(); } else if (flashFlag) { strcpy(flashPath, argv[idx]); pathAvailable = 1; processCommand(); } else if (eepromFlag) { strcpy(eepromPath, argv[idx]); pathAvailable = 1; processCommand(); } else { printf("Option -f must be combined with option -e, -p or -C\n"); exitSp12(2); } } else if (*argv[idx] != '-' && addressFlag) { addressFlag = 0; dataPtr = argv[idx]; if (writeFlag && (dataPtr = strchr(argv[idx], ':')) == NULL) { printf("Option -wa must be followed by address:data\n"); exitSp12(2); } if (writeFlag) dataPtr[0] = '\0'; if (flashFlag) { flashAddress =str2num(argv[idx]); if (writeFlag) flashData = str2num(++dataPtr); addressAvailable = 1; processCommand(); } else if (eepromFlag) { eepromAddress =str2num(argv[idx]); if (writeFlag) eepromData = str2num(++dataPtr); addressAvailable = 1; processCommand(); } else { printf("Option -a must be combined with option -e or -p\n"); exitSp12(2); } } else if (*argv[idx] != '-') { printf("No -a or -f option preceding argument `%s'\n", argv[idx]); } if (*argv[idx] == '-') { if (strchr(argv[idx], 'w') != NULL) strcpy(commandStr, argv[idx]); printf("Looping: idx %d argv[idx] %s (0x%x)\n", idx,argv[idx],(int)(argv[idx])); while ((ascii = *++argv[idx]) != '\0') { switch(ascii) { case 'i': if (strlen(argv[idx]) > 1) initFlag = atoi(++argv[idx]); if (idx > 1) { printf("WARNING: option -i[NN] has no effect unless\n"); printf(" it is first on the command line.\n"); } break; case 'K': if (strlen(argv[idx]) > 1) CKSELflag = 1 + strtol(++argv[idx], NULL, 2); break; case 'U': if (strlen(argv[idx]) > 1) SUTflag = 1 + strtol(++argv[idx], NULL, 2); break; case 'T': if (strlen(argv[idx]) > 1) testFlag = atoi(++argv[idx]); break; case 'M': if (strlen(argv[idx]) > 1) { clkSpeed = atof(++argv[idx]); if (clkSpeed <= 0.1) clkSpeed = 0.1; argv[idx][1] = '\0'; } break; case 'P': if (strlen(argv[idx]) > 1) { if (argv[idx][2] == 'x') portFlag = (int) strtol(++argv[idx], NULL, 16); else portFlag = (int) strtol(++argv[idx], NULL, 10); if ((idx + 1) == argc) exitFlag = 1; else exitFlag = 0; portControl(portFlag, exitFlag); num2bin((unsigned char) portFlag, binary); printf("Writing the byte %#04x (%d, B%s) ", portFlag, portFlag, binary); printf("to the parallel port data bits.\n"); if ((idx + 1) < argc) portFlag = 0; argv[idx][1] = '\0'; } break; case 'p': flashFlag = 1; break; case 'e': eepromFlag = 1; break; case 'w': writeFlag = 1; break; case 'r': readFlag = 1; break; case 'L': lockFlag = 1; break; case 'R': RCENflag = 1; break; case 'S': FSTRTflag = 1; break; case 'D': BODENflag = 1; break; case 'V': BODLEVELflag = 1; break; case 'A': EESAVEflag = 1; break; case '0': if (RCENflag == 1) RCENflag = 10; if (FSTRTflag == 1) FSTRTflag = 10; if (BODENflag == 1) BODENflag = 10; if (BODLEVELflag == 1) BODLEVELflag = 10; if (EESAVEflag == 1) EESAVEflag = 10; if (optimizeFlag == 1) optimizeFlag = 10; break; case '1': if (RCENflag == 1) RCENflag = 11; if (FSTRTflag == 1) FSTRTflag = 11; if (BODENflag == 1) BODENflag = 11; if (BODLEVELflag == 1) BODLEVELflag = 11; if (EESAVEflag == 1) EESAVEflag = 11; if (optimizeFlag == 1) optimizeFlag = 11; break; case '2': if (lockFlag == 1) lockFlag = 2; break; case '3': if (lockFlag == 1) lockFlag = 3; break; case '4': /* valid as part of -i[NN] only, so ignore */ break; case '5': /* valid as part of -i[NN] only, so ignore */ break; case 'f': fileFlag = 1; break; case 'a': addressFlag = 1; break; case 'E': eraseFlag = 1; break; case 'B': blankChkFlag = 1; break; case 'C': checksumFlag = 1; break; case 'F': readLockFuseFlag = 1; break; case 'I': IntelFlag = 1; break; case 'H': hexAsciiFlag = 1; break; case 'o': optimizeFlag = 1; break; case 'O': overlayFlag = 1; break; case 'X': if (strlen(argv[idx]) > 1) { char *strp; printf("processing %s\n",argv[idx]+1); M8_newFlagsL=strtol(++argv[idx],&strp,0); printf("processing %s %s\n",argv[idx],strp); argv[idx]=strp; if(*argv[idx] != ',') { printf("The -X option is: -Xflags,flagmask\n"); exit(2); } M8_newFlagsLmask=strtol(argv[idx]+1,&strp,0); argv[idx][1] = '\0'; printf("argv[%d] %s strp %s\n",idx,argv[idx],strp); printf("New low flags will be 0x%x mask 0x%x\n", 0xff&M8_newFlagsL,0xff&M8_newFlagsLmask); } else { printf("The -X option is: -Xflags,flagmask\n"); exit(2); } break; case 'Y': if (strlen(argv[idx]) > 1) { char *strp; printf("processing %s\n",argv[idx]+1); M8_newFlagsH=strtol(argv[idx]+1,&strp,0); printf("processing %s %s\n",argv[idx],strp); M8_newFlagsHmask=strtol(strp+1,NULL,0); printf("New high flags will be 0x%x mask 0x%x\n", 0xff&M8_newFlagsH,0xff&M8_newFlagsHmask); argv[idx][1] = '\0'; } else { printf("The -Y option is: -Yflags,flagmask\n"); exit(2); } break; default: printf("The character `%c' ", ascii); printf("is not a valid option.\n"); break; } } if (!fileFlag && !addressFlag) processCommand(); } } /* * Exiting with the byte `portFlag' on the parallel port data bits. * When the -Tnn option is not (also) used as the final option on * the command line, this defaults to 0x00. */ if (SCK == S_SCK && testFlag) { switch(testFlag) { case 1: portFlag = RESET; break; case 2: portFlag = RESET | PORTPOWER; break; default: break; } } else if (testFlag) { printf("Option -T is not available in Kanda compatible mode.\n"); } if (!portFlag) portFlag = DEFAULT_EXIT_STATE; portControl(portFlag, 1); if (SCK == S_SCK) { if (portFlag & 0x02) printf("Reset was left high.\n"); if (portFlag & 0x7C) printf("One or more `power' bits were left high.\n"); } return(0); } sp12mega8/buffer.c100644 10243 30014 56763 7300466106 14122 0ustar jrothweihomesys/* SP12: A serial programmer for working with Atmel AVR uCs */ /* Copyright (C) 1997-2001 Ken Huntington, Kevin Towers, Pitronics. */ /* 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 */ /* 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 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. */ /* Pitronics can be reached by email: sbolt@xs4all.nl */ /* Kevin Towers can be reached by email: ktowers@omnexcontrols.com */ /* Ken Huntington can be reached by email: kenh@compmore.net */ #include #include #include #include #include "sp12.h" /* Converts address or data string to number, automatically */ /* selecting hex (0xNNN), oct (0NNN), binary (BNNN) or */ /* dec (NNN) input. */ unsigned int str2num(char *addressOrData) { unsigned int number; /* * Determine format (hex, decimal or binary) by looking at prefix * and convert data to unsigned int using base 2, 8, 10 or 16 */ if (addressOrData[1] == 'x') number = (unsigned int) strtol(addressOrData, NULL, 16); else if (addressOrData[0] == '0') number = (unsigned int) strtol(addressOrData, NULL, 8); else if (addressOrData[0] == 'B') number = (unsigned int) strtol(&addressOrData[1], NULL, 2); else number = (unsigned int) strtol(addressOrData, NULL, 10); return(number); } /* convert unsigned int to a string-representation of the */ /* binary number (ascii `0' is 48, ascii `1' is 49) */ void num2bin(unsigned char buffer, char *binary) { int Bi; for (Bi = 7; Bi >= 0; Bi--) { binary[Bi] = (buffer & 0x01) + 48; buffer = buffer >> 1; } } /* Reads program file in Atmel generic format (address:data) or */ /* Intel HEX format; stores data into into flashBuf by address. */ /* flashBuf by address. The two numbers in the generic format are */ /* hex without `0x'. For example: 00000c:99e1 */ /* Note: the 16-bit bufLimit is not suitable for Mega address space. */ int readFlashFile(char flashPath[], unsigned int flashBuf[], long bufLimit) { FILE *flashBufPtr; char wordstring[WORDLEN]; long address; unsigned int data; char buffer[MAXLEN]; long offsetAddress = 0L; int dataByteCount; unsigned int lineAddress; int recordType; int idx; int checksum; int tmp; if ((flashBufPtr = fopen(flashPath, "r")) == NULL) { return(1); } else { if (fgets(wordstring, WORDLEN, flashBufPtr) != NULL) { /* * Try Atmel generic format (default of the Atmel assembler). */ if (wordstring[FLASH_DATAPTR] == ':') { fseek(flashBufPtr, 0, SEEK_SET); while (fgets(wordstring, WORDLEN, flashBufPtr) != NULL) { sscanf(wordstring, "%lx", &address); if (wordstring[FLASH_DATAPTR] != ':') { return(1); } sscanf(&wordstring[FLASH_DATAPTR + 1], "%x", &data); if (address < bufLimit) flashBuf[address] = data; else return(1); } fclose(flashBufPtr); return(0); } /* * Try Intel HEX format. */ if (wordstring[0] == ':') { fseek(flashBufPtr, 0, SEEK_SET); while (fgets(buffer, MAXLEN, flashBufPtr) != NULL) { checksum = 0; sscanf(&buffer[1], "%2x", &dataByteCount); checksum += dataByteCount; sscanf(&buffer[3], "%4x", &lineAddress); sscanf(&buffer[3], "%2x", &tmp); checksum += tmp; sscanf(&buffer[5], "%2x", &tmp); checksum += tmp; sscanf(&buffer[7], "%2x", &recordType); checksum += recordType; /* * Record type 02 means update offset address */ if (recordType == 2) { sscanf(&buffer[9], "%4lx", &offsetAddress); sscanf(&buffer[9], "%2x", &tmp); checksum += tmp; sscanf(&buffer[11], "%2x", &tmp); checksum += tmp; checksum = (unsigned char) (0x100 - (unsigned char) checksum); sscanf(&buffer[13], "%2x", &tmp); if (checksum != tmp) return(1); } if (recordType == 0) { for (idx = 9; idx < 9 + dataByteCount * 2; idx += 2) { sscanf(&buffer[idx], "%2x", &data); /* * Use word addresses for the AT90 2-byte data format */ address = lineAddress / 2; address = address + (offsetAddress * 0x10) / 2; if (address < bufLimit) { if (lineAddress & 0x0001) /* is it an odd address? */ /* then set MSB of data */ flashBuf[address] &= (data << 8) | 0x00ff; else /* else set LSB of data */ flashBuf[address] &= data | 0xff00; } else { return(1); } lineAddress++; checksum += data; } checksum = (unsigned char) (0x100 - (unsigned char) checksum); sscanf(&buffer[idx], "%2x", &tmp); if (checksum != tmp) return(1); } } fclose(flashBufPtr); return(0); } } } return(1); } /* Reads eeprom file in format address:data, stores data into */ /* eepromBuf by address. Both numbers can be hexadecimal (0xC4), */ /* decimal (196), octal (0304) or binary (B11000100). */ int readEepromFile(char eepromPath[], unsigned int eepromBuf[], long bufLimit) { FILE *eepromBufPtr; char wordstring[WORDLEN]; long address; unsigned int data; char buffer[MAXLEN]; char *dataPtr; long offsetAddress = 0L; int dataByteCount; unsigned int lineAddress; int recordType; int idx; int checksum; int tmp; if ((eepromBufPtr = fopen(eepromPath, "r")) == NULL) { return(1); } else { if (fgets(wordstring, WORDLEN, eepromBufPtr) != NULL) { /* * Try sp12 eeprom format. */ if (strchr(wordstring, ':') != &wordstring[0]) { fseek(eepromBufPtr, 0, SEEK_SET); while (fgets(wordstring, WORDLEN, eepromBufPtr) != NULL) { if ((dataPtr = strchr(wordstring, ':')) == NULL) { return(1); } dataPtr[0] = '\0'; address =str2num(wordstring); data = str2num(++dataPtr); if (address < bufLimit) eepromBuf[address] = data; else return(1); } fclose(eepromBufPtr); return(0); } /* * Try Intel HEX format. */ if (strchr(wordstring, ':') == &wordstring[0]) { fseek(eepromBufPtr, 0, SEEK_SET); while (fgets(buffer, MAXLEN, eepromBufPtr) != NULL) { checksum = 0; sscanf(&buffer[1], "%2x", &dataByteCount); checksum += dataByteCount; sscanf(&buffer[3], "%4x", &lineAddress); sscanf(&buffer[3], "%2x", &tmp); checksum += tmp; sscanf(&buffer[5], "%2x", &tmp); checksum += tmp; sscanf(&buffer[7], "%2x", &recordType); checksum += recordType; /* * Record type 02 means update offset address */ if (recordType == 2) { sscanf(&buffer[9], "%4lx", &offsetAddress); sscanf(&buffer[9], "%2x", &tmp); checksum += tmp; sscanf(&buffer[11], "%2x", &tmp); checksum += tmp; checksum = (unsigned char) (0x100 - (unsigned char) checksum); sscanf(&buffer[13], "%2x", &tmp); if (checksum != tmp) return(1); } if (recordType == 0) { address = lineAddress; address = address + (offsetAddress * 0x10) / 2; /* * Use byte addresses for single byte eeprom data format. */ for (idx = 9; idx < 9 + dataByteCount * 2; idx += 2) { sscanf(&buffer[idx], "%2x", &data); if (address < bufLimit) eepromBuf[address] = data; else return(1); address++; checksum += data; } checksum = (unsigned char) (0x100 - (unsigned char) checksum); sscanf(&buffer[idx], "%2x", &tmp); if (checksum != tmp) return(1); } } fclose(eepromBufPtr); return(0); } } } return(1); } /* Calculate checksum over buffer[]; int bufLimit is number of */ /* elements in buffer. */ unsigned int checksum(unsigned int buffer[], long bufLimit) { long idx; unsigned int chksum = 0; /* * cyclic right shift 1 of chksum + buffer element */ for (idx = 0; idx < bufLimit; idx++) { if (buffer[idx] == 0xfff) buffer[idx] = 0xff; chksum = ((chksum>>1) + ((chksum & 1) ?0x8000:0) + buffer[idx]) & 0xffff; } return(chksum); } /* Routines to write the flash or eeprom buffer into a file, */ /* using Intel HEX format or as a hex dump with ascii translation. */ #define BYTES_PER_LINE 16 static int flash_intel_hex (FILE *filePtr, unsigned int *buffer, long addr, long length) { int line_cnt = 0; /* line byte count */ int line_len = 0; /* expected line length */ unsigned char checksum = 0; unsigned char byt; length *= 2; while (length > 0) { if (addr > 0xFFFF) { /* add record type 02 */ fprintf (filePtr, ":020000021000EC\n"); addr = 0x10000 - addr; } if (line_cnt == 0) { /* write line header */ line_len = (length > BYTES_PER_LINE) ? BYTES_PER_LINE : length; fprintf (filePtr, ":%02X%04lX00", line_len, addr); checksum = line_len; checksum += addr & 0xff; checksum += addr >> 8; } if (addr & 0x0001) { /* is it an odd address? */ byt = *buffer >> 8; /* write MSB */ buffer++; } else { byt = *buffer & 0x00ff; /* write LSB */ } fprintf (filePtr, "%02X", byt); checksum += byt; if (++line_cnt == line_len) { /* write checksum */ fprintf (filePtr, "%02X\n", -checksum & 0xff); line_cnt = 0; } addr++; length--; } fprintf (filePtr, ":00000001FF\n"); /* write the terminator */ return (0); } static int eeprom_intel_hex (FILE *filePtr, unsigned int *buffer, unsigned int addr, long length) { int line_cnt = 0; /* line byte count */ int line_len = 0; /* expected line length */ unsigned char checksum = 0; while (length > 0) { if (line_cnt == 0) { /* write line header */ line_len = (length > BYTES_PER_LINE) ? BYTES_PER_LINE : length; fprintf (filePtr, ":%02X%04X00", line_len, addr); checksum = line_len; checksum += addr & 0xff; checksum += addr >> 8; } fprintf (filePtr, "%02X", *buffer); checksum += *buffer; if (++line_cnt == line_len) { /* write checksum */ fprintf (filePtr, "%02X\n", -checksum & 0xff); line_cnt = 0; } buffer++; addr++; length--; } fprintf (filePtr, ":00000001FF\n"); /* write the terminator */ return (0); } int file_hex_ascii(FILE *filePtr, unsigned int buffer[], int bufLimit, int twoByteFlag) { unsigned long address; char dataStr[MAXLEN]; char asciiStr[MAXLEN]; char lineBuf[MAXLEN]; unsigned char loByte, hiByte; int addressPerLine = 0x10; dataStr[0] = '\0'; asciiStr[0] = '\0'; for (address = 0; address < bufLimit; address++) { if ((address > 0) && (address % addressPerLine) == 0) { if ((fprintf(filePtr, "%06lx %s %s\n", address - addressPerLine, dataStr, asciiStr)) == EOF) return(1); dataStr[0] = '\0'; asciiStr[0] = '\0'; } if (twoByteFlag) { addressPerLine = 0x08; loByte = (unsigned char) buffer[address]; hiByte = (unsigned char) (buffer[address] >> 8); sprintf(lineBuf, "%02x %02x ", hiByte, loByte); strcat(dataStr, lineBuf); if ((hiByte > 31) && (hiByte < 127)) sprintf(lineBuf, "%c", hiByte); else sprintf(lineBuf, "."); strcat(asciiStr, lineBuf); if ((loByte > 31) && (loByte < 127)) sprintf(lineBuf, "%c", loByte); else sprintf(lineBuf, "."); strcat(asciiStr, lineBuf); } else { sprintf(lineBuf, "%02x ", buffer[address]); strcat(dataStr, lineBuf); if ((buffer[address] > 31) && (buffer[address] < 127)) sprintf(lineBuf, "%c", buffer[address]); else sprintf(lineBuf, "."); strcat(asciiStr, lineBuf); } } if ((fprintf(filePtr, "%06lx %s %s\n", address - addressPerLine, dataStr, asciiStr)) == EOF) return(1); fprintf(filePtr, "Checksum: %04x\n", checksum(buffer, bufLimit)); return(0); } /* Writes flashBuf[] into FILE *flashBufPtr using either Intel HEX */ /* or the `native' format. */ /* If write to file fails, return(1), else return(0) */ int fileFlashBuf(unsigned int flashBuf[], long bufLimit, char flashPath[], int intel_flag, int hex_ascii_flag) { FILE *flashBufPtr; long address; if ((flashBufPtr = fopen(flashPath, "w")) == NULL) return(1); if (hex_ascii_flag) { file_hex_ascii(flashBufPtr, flashBuf, bufLimit, 1); } else if (intel_flag) { flash_intel_hex(flashBufPtr, flashBuf, 0, bufLimit); } else { for (address = 0; address < bufLimit; address++) { if ((fprintf(flashBufPtr, "%06lx:%04x\n", address, flashBuf[address])) == EOF) return(1); } } fclose(flashBufPtr); return(0); } /* Writes eepromBuf[] into FILE *eepromBufPtr; */ /* If write to file fails, return(1), else return(0) */ int fileEepromBuf(unsigned int eepromBuf[], long bufLimit, char eepromPath[], int intel_flag, int hex_ascii_flag) { FILE *eepromBufPtr; long address; char binary[9] = "76543210"; if ((eepromBufPtr = fopen(eepromPath, "w")) == NULL) return(1); if (hex_ascii_flag) { file_hex_ascii(eepromBufPtr, eepromBuf, bufLimit, 0); } else if (intel_flag) { eeprom_intel_hex(eepromBufPtr, eepromBuf, 0, bufLimit); } else { if ((fprintf(eepromBufPtr, "Address: Data in hex, dec, oct, bin\n")) == EOF) return(1); for (address = 0; address < bufLimit; address++) { num2bin((unsigned char) eepromBuf[address], binary); if ((fprintf(eepromBufPtr, " %#06lx: %#04x %3d %#4o %s\n", address, eepromBuf[address], eepromBuf[address], eepromBuf[address], binary)) == EOF) return(1); } } fclose(eepromBufPtr); return(0); } /* Writes buffer[] to stdout as a hex dump with ascii translation */ void printBuffer(unsigned int buffer[], long bufLimit, int twoByteFlag) { long address; char dataStr[MAXLEN]; char asciiStr[MAXLEN]; char lineBuf[MAXLEN]; unsigned char loByte, hiByte; int addressPerLine = 0x10; dataStr[0] = '\0'; asciiStr[0] = '\0'; for (address = 0; address < bufLimit; address++) { if ((address > 0) && (address % addressPerLine) == 0) { printf("%06lx %s %s\n", address - addressPerLine, dataStr, asciiStr); dataStr[0] = '\0'; asciiStr[0] = '\0'; } if (twoByteFlag) { addressPerLine = 0x08; loByte = (unsigned char) buffer[address]; hiByte = (unsigned char) (buffer[address] >> 8); sprintf(lineBuf, "%02x %02x ", hiByte, loByte); strcat(dataStr, lineBuf); if ((hiByte > 31) && (hiByte < 127)) sprintf(lineBuf, "%c", hiByte); else sprintf(lineBuf, "."); strcat(asciiStr, lineBuf); if ((loByte > 31) && (loByte < 127)) sprintf(lineBuf, "%c", loByte); else sprintf(lineBuf, "."); strcat(asciiStr, lineBuf); } else { sprintf(lineBuf, "%02x ", buffer[address]); strcat(dataStr, lineBuf); if ((buffer[address] > 31) && (buffer[address] < 127)) sprintf(lineBuf, "%c", buffer[address]); else sprintf(lineBuf, "."); strcat(asciiStr, lineBuf); } } printf("%06lx %s %s\n", address - addressPerLine, dataStr, asciiStr); printf("Checksum: %04x\n", checksum(buffer, bufLimit)); } /* Add spaces until lenght or max is reached */ void formatStr(char *logStr, int length, int max) { int idx; for (idx = 0; idx < length; idx++) { if (idx == max) { logStr[idx] = '\0'; break; } if (logStr[idx] == '\0') { logStr[idx] = ' '; logStr[idx + 1] = '\0'; } } } /* Add a line to the log about a write command */ int logWrites(char *commandStr, unsigned int address, int data, char *path, unsigned int buffer[], int overlayFlag, int *error) { FILE *logPtr; time_t curTime; struct tm *locTime; unsigned int areaChksum = 0; unsigned int *queryBuf; int idx; long adrsCnt; char deviceName[MAXLEN]; char fileName[MAXLEN]; char *fileNamePtr; if (log.logging != 1) return(0); formatStr(commandStr, 6, MAXLEN); strcpy(deviceName, device.name); if (strcmp(deviceName, "AT90(L)S2343 or Tiny22(L)") == 0) strcpy(deviceName, "2343/Tiny22"); formatStr(deviceName, 12, MAXLEN); queryBuf = malloc(FLASHBUF_UPPERLIMIT * sizeof (unsigned int)); if (queryBuf == NULL) { printf ("ERROR: No memory available for buffer!\n"); return(0); } curTime = time(NULL); locTime = localtime(&curTime); if ((logPtr = fopen(log.logPath, "a")) == NULL) { free(queryBuf); return(1); } fprintf(logPtr, "%s %s ", deviceName, commandStr); if (strchr(commandStr, 'f') != NULL) { strcpy(fileName, path); fileNamePtr = fileName; idx = strlen(fileName); while (idx-- > 0 && fileName[idx] != '\\' && fileName[idx] != '/') fileNamePtr = &fileName[idx]; formatStr(fileNamePtr, 14, MAXLEN - idx); fprintf(logPtr, "%s ", fileNamePtr); if (log.query) { if (strchr(commandStr, 'p') != NULL) { readFlashArea(queryBuf, device.flashLimit); areaChksum = checksum(queryBuf, device.flashLimit); *error = 0; for (adrsCnt = 0; adrsCnt < device.flashLimit; adrsCnt++) { if (overlayFlag && buffer[adrsCnt] == 0xffff) continue; if (queryBuf[adrsCnt] != buffer[adrsCnt]) { *error = 1; break; } } } else { readEepromArea(queryBuf, device.eepromLimit); areaChksum = checksum(queryBuf, device.eepromLimit); *error = 0; for (adrsCnt = 0; adrsCnt < device.eepromLimit; adrsCnt++) { if (overlayFlag && buffer[adrsCnt] > 0xFF) continue; if (queryBuf[adrsCnt] != (unsigned char) buffer[adrsCnt]) { *error = 1; break; } } } if (*error) fprintf(logPtr, "readback ERROR %s", asctime(locTime)); else fprintf(logPtr, "checksum %04x %s", areaChksum, asctime(locTime)); } else { fprintf(logPtr, "not queried %s", asctime(locTime)); } } else { if (strchr(commandStr, 'p') != NULL) fprintf(logPtr, "%08x:%#06x ", address, data); else fprintf(logPtr, "%08x:%#04x ", address, data); if (*error) fprintf(logPtr, "readback ERROR %s", asctime(locTime)); else fprintf(logPtr, "verified %s", asctime(locTime)); } fclose(logPtr); free(queryBuf); return(0); } /* Add a line to the log about a lock command */ int logLocks(unsigned int buffer[], int lockFlag) { FILE *logPtr; time_t curTime; struct tm *locTime; unsigned int areaChksum = 0; char deviceName[MAXLEN]; if (log.logging != 1) return(0); strcpy(deviceName, device.name); formatStr(deviceName, 12, MAXLEN); curTime = time(NULL); locTime = localtime(&curTime); if ((logPtr = fopen(log.logPath, "a")) == NULL) return(1); fprintf(logPtr, "%s -L%i ", deviceName, lockFlag); readFlashArea(buffer, device.flashLimit); areaChksum = checksum(buffer, device.flashLimit); fprintf(logPtr, "flash %04x ", areaChksum); readEepromArea(buffer, device.eepromLimit); areaChksum = checksum(buffer, device.eepromLimit); fprintf(logPtr, "eeprom %04x %s", areaChksum, asctime(locTime)); fclose(logPtr); return(0); } sp12mega8/flash.c100644 10243 30014 20173 7605130543 13731 0ustar jrothweihomesys/* SP12: A serial programmer for working with Atmel AVR uCs */ /* Copyright (C) 1997-2001 Ken Huntington, Kevin Towers, Pitronics. */ /* 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 */ /* 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 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. */ /* Pitronics can be reached by email: sbolt@xs4all.nl */ /* Kevin Towers can be reached by email: ktowers@omnexcontrols.com */ /* Ken Huntington can be reached by email: kenh@compmore.net */ #include #include #include #ifndef LINUX #include #else #include "dos_cpt.h" #endif #include "sp12.h" /* Accepts a 16-bit address. Reads the codeWord in two steps */ /* from the device connected to the Centronics port. */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ unsigned int readCodeWord(unsigned int address) { unsigned char readByte; unsigned int codeWord; unsigned long readCmd; codeWord = 0; readCmd = READ_PROG_HI | ((long) address << 8); readByte = (unsigned char) clockOutCommand(readCmd); codeWord = codeWord | readByte; readCmd = READ_PROG_LO | ((long) address << 8); readByte = (unsigned char) clockOutCommand(readCmd); codeWord = (codeWord << 8) | readByte; return(codeWord); } /* Accepts a 16-bit codeWord and a 7-bit address. Writes the code */ /* in two steps with no delays into the ATMega device connected to */ /* the Centronics port. */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ void loadCodePage(unsigned int address, unsigned int codeWord) { unsigned char loByte; unsigned char hiByte; unsigned long writeCmd; loByte = (unsigned char) codeWord & 0x00FF; hiByte = (unsigned char) ((codeWord & 0xFF00) >> 8); writeCmd = WRITE_PROG_LO | ((long) address << 8); writeCmd = writeCmd | loByte; printf(" cmd 0x%lx <=word 0x%x addr 0x%x\n",writeCmd,codeWord,address); clockOutCommand(writeCmd); writeCmd = WRITE_PROG_HI | ((long) address << 8); writeCmd = writeCmd | hiByte; printf(" cmd 0x%lx <=word 0x%x addr 0x%x\n",writeCmd,codeWord,address); clockOutCommand(writeCmd); } /* Accepts a 16-bit page number and programs it into the ATMega */ /* device connected to the Centronics parallel port. */ /* The page is read back and compared with the buffer; if all */ /* is well, 0 is returned, else 1. */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ int writeCodePage(unsigned int flashBuf[], unsigned int address) { unsigned long Ti, writeCmd; long idx; writeCmd = WRITE_PAGE | ((long) address << 8); printf(" cmd 0x%lx <= addr 0x%x\n",writeCmd,address); clockOutCommand(writeCmd); for (Ti = 0; Ti <= timeConst.pageWrite; Ti++) { } for (idx = address + 1 - PAGE_SIZE; idx <= address; idx++) { unsigned int rtnwrd; rtnwrd = readCodeWord(idx); if (flashBuf[idx] != rtnwrd) { printf("flashBuf[%ld] 0x%x rtnwrd 0x%x\n",idx,flashBuf[idx],rtnwrd); return(1); } } return(0); } /* Accepts a 16-bit codeWord and a 16-bit address. Writes the code */ /* in two steps into the device connected to the Centronics port and */ /* verifies arrival. Returns 1 if verify fails three times, else 0. */ /* The time constant byteWrite is adjusted dynamically, */ /* if the device is not a 1200(A) and optimizeFlag allows. */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ int writeFlashVerified(unsigned int address, unsigned int codeWord, int optimizeFlag) { unsigned char loByte; unsigned char hiByte; unsigned long readCmd, writeCmd; int failure; loByte = (unsigned char) codeWord & 0x00FF; hiByte = (unsigned char) ((codeWord & 0xFF00) >> 8); writeCmd = WRITE_PROG_HI | ((long) address << 8); writeCmd = writeCmd | hiByte; readCmd = READ_PROG_HI | ((long) address << 8); failure = writeByteVerified(writeCmd, readCmd, optimizeFlag); if (failure == 0) { writeCmd = WRITE_PROG_LO | ((long) address << 8); writeCmd = writeCmd | loByte; readCmd = READ_PROG_LO | ((long) address << 8); failure = writeByteVerified(writeCmd, readCmd, optimizeFlag); } return(failure); } /* Expects flashBuf[] to be filled with data. */ /* If a (page) write fails, 1 is returned, else 0. */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ int writeFlashArea(unsigned int flashBuf[], long bufLimit, int optimizeFlag) { long address, previous; int writeFlg = 0; int idx = 1; previous = 0; printf("...............................................................\r"); for (address = 0; address < bufLimit; address++) { if (device.pageMode) { printf("Writing address 0x%lx in page mode\n",address); if (flashBuf[address] != 0xffff) { loadCodePage((unsigned int) address, flashBuf[address]); writeFlg = 1; } if (writeFlg && (address > 0) && ((address & PAGE_MASK) == PAGE_MASK)) { writeFlg = 0; if (writeCodePage(flashBuf, (unsigned int) address) == 1) { if (++idx < 4) { address = address + 1 - PAGE_SIZE; writeRetries++; } else { printf("!!\n"); return (1); } } else { idx = 1; } } } else { printf("Writing address 0x%lx in non page mode\n",address); if (flashBuf[address] != 0xffff) { if (writeFlashVerified((unsigned int) address, flashBuf[address], optimizeFlag) == 1) { printf("!!\n"); return (1); } } } if (address >= (previous + bufLimit / 64)) { putchar('o'); fflush(stdout); previous = address; } } printf("\n"); return (0); } /* (expects flashBuf[] to be filled with 0xFFFF) */ /* Loops readCodeWord into flashBuf[] */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ void readFlashArea(unsigned int flashBuf[], long bufLimit) { long address, previous; previous = 0; printf("...............................................................\r"); for (address = 0; address < bufLimit; address++) { flashBuf[address] = readCodeWord((unsigned int) address); if (address >= (previous + bufLimit / 64)) { putchar('o'); fflush(stdout); previous = address; } } printf("\n"); } sp12mega8/sp12.h100644 10243 30014 51213 7605125123 13423 0ustar jrothweihomesys/* SP12: A serial programmer for working with Atmel AVR uCs */ /* Copyright (C) 1997-2001 Ken Huntington, Kevin Towers, Pitronics. */ /* 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 */ /* 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 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. */ /* Pitronics can be reached by email: sbolt@xs4all.nl */ /* Kevin Towers can be reached by email: ktowers@omnexcontrols.com */ /* Ken Huntington can be reached by email: kenh@compmore.net */ #define WORDLEN 16 #define DATALEN 5 #define FLASH_DATAPTR 6 #define MAXLEN 200 #define FLASHBUF_UPPERLIMIT 65536L #define EEPROMBUF_UPPERLIMIT 8192L #define PAGE_SIZE 32 /* # bytes in one page */ #define PAGE_MASK 0x1f /* mask to isolate page offset */ #define FILE_ERROR "does not exist, wrong format,\n address > limit, or HEX file checksum failure." #define FILE_WRITE_ERROR "Unable to write to, or finish writing to" #define STK200TEST 0x02 /* data-1 connected to status-7 */ #define STK200PRESENT 0x80 #define STK300TEST 0x01 /* data-0 connected to status-5 */ #define STK300PRESENT 0x20 /* * program control line definitions for sp12 cable/dongle */ #define S_SCK 0x01 /* SPI clock out */ #define S_MOSI 0x80 /* SPI data out */ #define S_MISO_BITNR 7 /* SPI data in bit number */ #define S_MISO_INV 0xFF /* inverted */ #define S_RESET 0x02 /* processor reset control */ #define S_ENABLE 0 /* Dummy */ #define S_PORTPOWER 0x7C /* `port power' bits */ #define S_DEFAULT_EXIT_STATE 0 #define S_PORTACTIVE 0x7C /* reserved for portControl() */ /* * program control line definitions for Kanda STK200 dongle */ #define K_SCK 0x10 /* SPI clock out */ #define K_MOSI 0x20 /* SPI data out */ #define K_MISO_BITNR 6 /* SPI data in bit number */ #define K_MISO_INV 0x00 /* not inverted */ #define K_RESET 0x80 /* processor reset control */ #define K_ENABLE 0x0C /* ~enables Kanda `dongle' */ #define K_PORTPOWER 0 /* Dummy */ #define K_DEFAULT_EXIT_STATE 0x0C #define K_PORTACTIVE 0x43 /* * These macros perform various bit operations on scalar types using bit masks */ #define bit_set(value, bit) ((value) |= (bit)) #define bit_clear(value, bit) ((value) &= ~(bit)) #define bit_comp(value, bit) ((value) ^= (bit)) #define bit_test(value, bit) (((value) & (bit)) != 0) /*---------------------- The global constants -----------------------*/ /*----------------------- defined in init.c ------------------------*/ extern const unsigned long PROGRAM_ENABLE; extern const unsigned long CHIP_ERASE; extern const unsigned long READ_PROG_HI; extern const unsigned long READ_PROG_LO; extern const unsigned long WRITE_PROG_HI; extern const unsigned long WRITE_PROG_LO; extern const unsigned long WRITE_PAGE; extern const unsigned long READ_EEPROM; extern const unsigned long WRITE_EEPROM; extern const unsigned long WRITE_LOCK_W; extern const unsigned long WRITE_LOCK_RW; extern const unsigned long PROG_RCEN_FUSE; extern const unsigned long UNPROG_RCEN_FUSE; extern const unsigned long PROG_FSTRT_FUSE; extern const unsigned long UNPROG_FSTRT_FUSE; extern const unsigned long READ_LOCK_FUSE; extern const unsigned long READ_LOCK; extern const unsigned long READ_FUSE; extern const unsigned long WRITE_FUSES; extern const unsigned long READ_DEVICE; extern const unsigned long READ_LOCK_M8; extern const unsigned long READ_FUSE_M8; extern const unsigned long READ_FUSE_HI_M8; extern const unsigned long READ_CAL_M8; /*-------------------- No more global constants ---------------------*/ /*---------------------- The global variables -----------------------*/ /*----------------------- defined in init.c ------------------------*/ extern unsigned char SCK; extern unsigned char MOSI; extern unsigned char MISO_BITNR; extern unsigned char MISO_INV; extern unsigned char RESET; extern unsigned char ENABLE; extern unsigned char PORTPOWER; extern unsigned char DEFAULT_EXIT_STATE; extern unsigned char PORTACTIVE; struct timeConsts { double loop; double port; /* time taken by outportb() */ unsigned long sckLO; unsigned long sckHI; unsigned long resetPuls; unsigned programEnable; unsigned chipErase; unsigned long byteWrite; unsigned long byteWriteDefault; int byteWriteAdjusted; /* a flag */ unsigned long pageWrite; unsigned powerOn; }; struct device_info { unsigned char sigByte_0; unsigned char sigByte_1; unsigned char sigByte_2; char name[30]; char madeBy[30]; long eepromLimit; long flashLimit; int initPerformed; int pageMode; /* true if page programmed device */ int fuseMode; /* 0: AT90S1200, 2313, 4414, 8515 */ /* 4: 2343 (lock +r, RCEN +rw) */ /* 5: 2323 4434, 8535 (lock +r, */ /* FSTRT +rw) */ /* 6: (ATmega103/603) */ /* 7: 2333, 4433 (lock +r, CKSELx3 +rw */ /* BODx2 +rw) */ }; struct logging { char logPath[MAXLEN]; int logging; int query; }; extern struct timeConsts timeConst; extern struct device_info device; extern struct logging log; extern int portAddress; extern int portStatus; extern int writeRetries; extern float clockSpdDefault; extern int KandaMode; /* Cable/dongle Kanda or sp12 */ extern unsigned char outbyte; /* current state of device */ /* control port */ /*-------------------- No more global variables ---------------------*/ /* * A few prototypes. */ /* Look for the rc file, using environment variable `SP12' (if */ /* this variable has not been set, the current directory is used). */ /* If the rc file exists, then read the time constants and the */ /* parallel port address from this file. If the rc file is not */ /* found, then calibrate the time constants, check for available */ /* parallel ports, set (usually the primary) address, and write */ /* it all into a new rc file. Afterwards check if the parallel */ /* port is actually there (guarding against a corrupt rc file, and */ /* setting the port data register to 0xF0), and also check if the */ /* time constants aren't 0. exit(1) if a check fails. */ void initSp12(void); /* Determines the number of bits in command, and shifts them */ /* highest bit first into unsigned char output, which then */ /* is used to clock them out bit by bit through Centronics */ /* data-7. */ /* Reads back and returns whatever the uC clocks out on Miso */ /* while the command is clocked in. */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ unsigned long clockOutCommand(unsigned long command); /* Accepts a 16-bit address, and shifts it highest bit first */ /* into unsigned char output, which then is used to clock the */ /* bits out one by one hrough Centronics data-7 */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ void clockOutAddress(unsigned int address); /* Read one data byte from the status register of the */ /* Centronics port. */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ unsigned char clockInByte(void); /* Accepts a 16-bit address. Reads the codeWord in two steps */ /* from the device connected to the Centronics port. */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ unsigned int readCodeWord(unsigned int address); /* Accepts a 16-bit codeWord and a 7-bit address. Writes the code */ /* in two steps with no delays into the ATMega device connected to */ /* the Centronics port. */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ void loadCodePage(unsigned int address, unsigned int codeWord); /* Accepts a 16-bit page number and programs it into the ATMega */ /* device connected to the Centronics parallel port. */ /* The page is read back and compared with the buffer; if all */ /* is well, 0 is returned, else 1. */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ int writeCodePage(unsigned int flashBuf[], unsigned int address); /* Accepts a 16-bit codeWord and a 16-bit address. Writes the code */ /* in two steps into the device connected to the Centronics port and */ /* verifies arrival. Returns 1 if verify fails three times, else 0. */ /* The time constant byteWrite is adjusted dynamically, */ /* if the device is not a 1200(A) and optimizeFlag allows. */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ int writeFlashVerified(unsigned int address, unsigned int codeWord, int optimizeFlag); /* Expects flashBuf[] to be filled with data. */ /* If a (page) write fails, 1 is returned, else 0. */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ int writeFlashArea(unsigned int flashBuf[], long bufLimit, int optimizeFlag); /* Assume the device connected to the Centronics port is powered, */ /* but that device sck was not held low during power-up, so a */ /* reset pulse is needed before the SPI can be enabled. */ /* Assume also that power has yet to be switched on (for separate */ /* programmer powered by parallel port, instead of in-circuit */ /* programming. */ /* If uC is 1200, emit just one PROGRAM_ENABLE command. */ /* Else retry until the third byte read back by clockOutCommand() */ /* is 0x53, or at least 32 retries have been unsuccessful. */ int enableSPI(int uC); /* Adapt Sck timing to user's clock speed setting */ /* (Init sets the timing equal to sck0.5M, and the flag will be */ /* zero unless altered by the command line.) */ float setSckTiming(float clkSpeed); /* Before writing to the flash area, the device has to be erased. */ /* Note: This command also erases the eeprom area (all to 0xFF). */ /* There is no need for general erase before writing to the */ /* eeprom area, since the device has an auto-erase built into */ /* the eeprom write cycle. Thus you can alter one or more eeprom */ /* addresses without disturbing the rest of the device. */ void eraseDevice(void); /* A routine to switch off the powerbits; useful only when the */ /* separate programmer is used instead of in-circuit programming. */ void portControl(int portFlag, int exitFlag); /* Quoting the AT90S1200 datasheet: */ /* Mode 2: further programming of the flash is disabled. */ /* Mode 3: same as mode 2, but verify is also disabled. */ void writeLockBits(int mode); /* Valid only for the AT90S2343. */ /* 0: Internal RC clock enabled. */ /* 1: Internal RC clock disabled. */ /* Note that the fuse bit can be altered even if the device is */ /* locked mode 3. */ /* Verifies the fuse bit and returns 0 if OK, else returns 1. */ int writeRCENfuse(int state); /* Valid only for the AT90S2323, 4434, 8535. */ /* 0: Short start-up time selected. */ /* 1: Default (long) start-up time selected. */ /* Note that the fuse bit can be altered even if the device is */ /* locked mode 3. */ /* Verifies the fuse bit and returns 0 if OK, else returns 1. */ int writeFSTRTfuse(int state); /* Valid only for the AT90S2333, 4433 and ATmega103/603. */ /* Since (re)enabling brown-out detection usually causes the */ /* AT90(L)S2333/4433 to hang, the fuses are only written, not */ /* verified. */ int writeFUSES(unsigned char fuses); /* Reads the lock and fuse bits from the device connected to the */ /* Centronics parallel port. Valid only for AT90S2323, 2343, 4434 */ /* 2333, 4333, 8535 and ATmega103/603. */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ unsigned char readLockFuse(void); /* Read the signature bits from the device attached to the */ /* Centronics parallel port. */ void readDeviceCode(void); /* Converts address or data string to number, automatically */ /* selecting hex (0xNNN), oct (0NNN), binary (BNNN) or */ /* dec (NNN) input. */ unsigned int str2num(char *addressOrData); /* convert unsigned int to a string-representation of the */ /* binary number (ascii `0' is 48, ascii `1' is 49) */ void num2bin(unsigned char buffer, char *binary); /* Reads program file in format address:data, stores data into */ /* flashBuf by address. The two numbers must be hex without `0x' */ /* for example: 00000c:99e1 */ int readFlashFile(char flashPath[], unsigned int flashBuf[], long bufLimit); /* Reads program file in Atmel generic format (address:data) or */ /* Intel HEX format; stores data into into flashBuf by address. */ /* flashBuf by address. The two numbers in the generic format are */ /* hex without `0x'. For example: 00000c:99e1 */ int readEepromFile(char eepromPath[], unsigned int eepromBuf[], long bufLimit); /* Calculate checksum over buffer[]; bufLimit is number of */ /* elements in buffer. */ unsigned int checksum(unsigned int buffer[], long bufLimit); /* (expects flashBuf[] to be filled with 0xFFFF) */ /* Loops readCodeWord into flashBuf[] */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ void readFlashArea(unsigned int flashBuf[], long bufLimit); /* Writes flashBuf[] into FILE *flashBufPtr; */ /* If write to file fails, return(1), else return(0) */ int fileFlashBuf(unsigned int flashBuf[], long bufLimit, char flashPath[], int intel_flag, int hex_ascii_flag); /* Reads flash and eeprom area's. Return 1 if a flash address does */ /* not contain 0xFFFF, or 3 if an eeprom address also isn't blank; */ /* return 2 if the flash is blank, but the eeprom isn't; */ /* return 0 is both area's are blank. */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ int blankCheck(long flashLimit, long eepromLimit); /* Accepts a dataByte and a 16-bit address. Writes the byte into */ /* the device connected to the Centronics port and verifies arrival. */ /* Returns 1 if verify fails three times, else 0. */ /* The time constant byteWrite is adjusted dynamically, */ /* if the device is not a 1200(A) and/or optimizeFlag allows. */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ int writeByteVerified(unsigned long writeCommand, unsigned long readCommand, int optimizeFlag); /* Writes eepromBuf[] into FILE *eepromBufPtr; */ /* If write to file fails, return(1), else return(0) */ int fileEepromBuf(unsigned int eepromBuf[], long bufLimit, char eepromPath[], int intel_flag, int hex_ascii_flag); /* Accepts a 16-bit address. Reads the dataByte in two steps */ /* from the device connected to the Centronics port. */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ unsigned char readDataByte(unsigned int address); /* Writes buffer[] to stdout as a hex dump with ascii translation */ void printBuffer(unsigned int buffer[], long bufLimit, int twoByteFlag); /* Add a line to the log about a write command */ int logWrites(char *commandStr, unsigned int address, int data, char *path, unsigned int buffer[], int overlayFlag, int *error); /* Add a line to the log about a lock command */ int logLocks(unsigned int buffer[], int lockFlag); /* Accepts a dataByte and a 16-bit address. Writes the code in two */ /* steps into the device connected to the Centronics port and */ /* verifies arrival. Returns 1 if verify fails three times, else 0. */ /* The time constant byteWrite is adjusted dynamically, */ /* if the device is not a 1200(A) and optimizeFlag allows. */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ int writeEepromVerified(unsigned int address, unsigned char dataByte, int optimizeFlag); /* Expects eepromBuf[] to be filled with data. */ /* executes writeEepromVerified() address by address; */ /* if verify fails, stops and returns 1, else returns 0. */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ int writeEepromArea(unsigned int eepromBuf[], long bufLimit, int optimizeFlag, int overlayFlag); /* (expects eepromBuf[] to be filled with 0xFF) */ /* Loops readDataByte into eepromBuf[] */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ void readEepromArea(unsigned int EepromBuf[], long bufLimit); sp12mega8/makefile100644 10243 30014 1370 7605125774 14160 0ustar jrothweihomesys# # Makefile for the Free Software Foundations gcc compiler # Optimize flag = 1 to achieve correct timing # CC=gcc LINK=gcc # # LINUX FLAGS CFLAGS=-c -O1 -Wall -DLINUX LFLAGS=-s -o TARGET=sp12 ERASE=rm -f # DOS FLAGS #CFLAGS=-c -O1 -Wall #LFLAGS=-lemu -s -o #TARGET=sp12.exe #ERASE=del # OBJECTS=sp12.o init.o flash.o device.o buffer.o eeprom.o # all: $(TARGET) sp12.o: sp12.c $(CC) $(CFLAGS) sp12.c init.o: init.c $(CC) $(CFLAGS) init.c flash.o: flash.c $(CC) $(CFLAGS) flash.c device.o: device.c $(CC) $(CFLAGS) device.c buffer.o: buffer.c $(CC) $(CFLAGS) buffer.c eeprom.o: eeprom.c $(CC) $(CFLAGS) eeprom.c $(OBJECTS): sp12.h $(TARGET): makefile $(OBJECTS) $(LINK) $(LFLAGS) $(TARGET) $(OBJECTS) clean: $(ERASE) $(TARGET) $(ERASE) *.o sp12mega8/init.c100644 10243 30014 42456 7605125653 13615 0ustar jrothweihomesys/* SP12: A serial programmer for working with Atmel AVR uCs */ /* Copyright (C) 1997-2001 Ken Huntington, Kevin Towers, Pitronics. */ /* 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 */ /* 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 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. */ /* Pitronics can be reached by email: sbolt@xs4all.nl */ /* Kevin Towers can be reached by email: ktowers@omnexcontrols.com */ /* Ken Huntington can be reached by email: kenh@compmore.net */ #include #include #include #ifndef LINUX #include #else #include "dos_cpt.h" #endif #include #include "sp12.h" const char RC_USAGE[] = { "# SP12: A serial programmer for working with Atmel AVR uCs \n" "# Copyright (C) 1997-2001 Ken Huntington, Kevin Towers, Pitronics.\n" "# \n" "# This program is free software; you can redistribute it and/or \n" "# modify it under the terms of the GNU General Public License \n" "# as published by the Free Software Foundation; either version 2 \n" "# of the License, or (at your option) any later version. \n" "# \n" "# This program is distributed in the hope that it will be useful, \n" "# but WITHOUT ANY WARRANTY; without even the implied warranty of \n" "# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the \n" "# GNU General Public License for more details.\n" "# \n" "# You should have received a copy of the GNU General Public License \n" "# along with this program; if not, write to the Free Software \n" "# Foundation, Inc., 59 Temple Place - Suite 330, Boston, \n" "# MA 02111-1307, USA. \n" "# \n" "# Pitronics can be reached by email: sbolt@xs4all.nl \n" "# Kevin Towers can be reached by email: ktowers@omnexcontrols.com\n" "# Ken Huntington can be reached by email: kenh@compmore.net \n" "# \n" "# Runtime configuration file to initialise time constants,\n" "# parallel port, logging and port mode (sp12 native or Kanda \n" "# compatible).\n" "# Sp12 will make this file when first started; it will appear \n" "# in the directory as defined by the environment variable SP12,\n" "# or in the current directory if this variable is not set.\n" "# The next time sp12 starts, time constants, port address, logging\n" "# parameters and port mode will be read from this file.\n" "# The primary parallel port address will be automatically selected.\n" "# if you need to use, for instance, the secondary (0x278), then\n" "# by all means edit this file manually, but don't change the *format*\n" "# of the NNNN=ddd type statements, only the values. Note that\n" "# BYTEWRITE is an upper limit; the value actually used is dynamically\n" "# adjusted when sp12 runs. Check changes.doc for other details.\n"}; /*--------------------- The global constants ------------------------*/ const unsigned long PROGRAM_ENABLE = 0xAC53FFFFL; const unsigned long CHIP_ERASE = 0xAC80FFFFL; const unsigned long READ_PROG_HI = 0x280000FFL; const unsigned long READ_PROG_LO = 0x200000FFL; const unsigned long WRITE_PROG_HI = 0x48000000L; const unsigned long WRITE_PROG_LO = 0x40000000L; const unsigned long WRITE_PAGE = 0x4C001FFFL; const unsigned long READ_EEPROM = 0xA00000FFL; const unsigned long WRITE_EEPROM = 0xC0000000L; const unsigned long WRITE_LOCK_W = 0xACFDFFFFL; const unsigned long WRITE_LOCK_RW = 0xACF9FFFFL; const unsigned long PROG_RCEN_FUSE = 0xACBEFFFFL; const unsigned long UNPROG_RCEN_FUSE = 0xACBFFFFFL; const unsigned long PROG_FSTRT_FUSE = 0xACBEFFFFL; const unsigned long UNPROG_FSTRT_FUSE = 0xACBFFFFFL; const unsigned long READ_LOCK_FUSE = 0x58FFFFFFL; const unsigned long READ_LOCK = 0x58FFFFFFL; const unsigned long READ_FUSE = 0x50FFFFFFL; const unsigned long WRITE_FUSES = 0xACBFFFFFL; const unsigned long READ_DEVICE = 0x30FF00FFL; /* New modes for the ATmega8 (mode 8) */ const unsigned long READ_LOCK_M8 = 0x5800FFFFL; const unsigned long READ_FUSE_M8 = 0x5000FFFFL; const unsigned long READ_FUSE_HI_M8 = 0x5808FFFFL; const unsigned long READ_CAL_M8 = 0x383F00FFL; /*------------------- No more global constants ----------------------*/ /*---------------------- The global variables -----------------------*/ unsigned char SCK; unsigned char MOSI; unsigned char MISO_BITNR; unsigned char MISO_INV; unsigned char RESET; unsigned char ENABLE; unsigned char PORTPOWER; unsigned char DEFAULT_EXIT_STATE; unsigned char PORTACTIVE; struct timeConsts timeConst; struct device_info device; struct logging log; int portAddress; int portStatus; int writeRetries; float clockSpdDefault; unsigned char outbyte; int KandaMode; /*-------------------- No more global variables ---------------------*/ /* Look for available parallel ports, like the bios does, but */ /* setting the data register to 0x80 and avoiding some rare */ /* difficulties. The port address actually set will be the */ /* last one available in the order 0x278, 0x378, 0x3BCR, but */ /* the status of all three will be reported in the rc file. */ void checkParPort(FILE *rcPtr) { printf("Looking for parallel ports...\n"); outportb(0x278, 0x80); /* Check secondary address, report */ /* status in rc file, set portAddress */ delay(1); /* Give port time to react */ if (inportb(0x278) == 0x80) { portAddress = 0x278; fprintf(rcPtr, "# Parallel port available at 0x278\n"); } else { fprintf(rcPtr, "# NO parallel port at 0x278\n"); } outportb(0x378, 0x80); /* Check primary address, report */ /* status in rc file, set portAddress */ delay(1); /* Give port time to react */ if (inportb(0x378) == 0x80) { portAddress = 0x378; fprintf(rcPtr, "# Parallel port available at 0x378\n"); } else { fprintf(rcPtr, "# NO parallel port at 0x378\n"); } outportb(0x3BC, 0x80); /* Check address on MDPA, report */ /* status in rc file, set portAddress */ delay(1); /* Give port time to react */ if (inportb(0x3BC) == 0x80) { portAddress = 0x3BC; fprintf(rcPtr, "# Parallel port available at 0x3BC\n"); } else { fprintf(rcPtr, "# NO parallel port at 0x3BC\n"); } fprintf(rcPtr, "# This port address will be used:\n"); fprintf(rcPtr, "PORT=%#x\n", portAddress); } /* Calibrate several time constants for delays that take care */ /* of minimum pulse widths. portAddress must be valid. */ void initTimeConst(FILE *rcPtr) { clock_t start, end; unsigned long reference; unsigned long Ti; /* Timing loop counter */ unsigned long Ni; /* Temp. ref while calibrating */ /* timeConst.port */ printf("Calibrating delay loop. This may take some time...\n"); /* * Measure time taken by timing loop, * calibrate reference */ reference = 1e6; /* 1e6 gives reasonable speed and */ /* accuracy in slow PCs like a 286 */ do { start = clock(); for (Ti = 0; Ti < reference; Ti++) { } end = clock(); /* * Calculate elapsed time in seconds */ timeConst.loop = ((double) (end - start)) / CLOCKS_PER_SEC; if (timeConst.loop < 0.005) { reference = reference * 4; continue; } if (timeConst.loop < 1) reference = (unsigned long) (reference * 1.2 / timeConst.loop); } while (timeConst.loop < 1); /* * This line alters timeConst.loop as calculated by the loop * above by a factor of two, when compiled by Linux gcc 2.7. * Compiler magic... */ timeConst.loop = ((double) (end - start)) / CLOCKS_PER_SEC; /* * Measure time taken by outportb() calls */ Ni = 1e4; do { start = clock(); for (Ti = 0; Ti < Ni; Ti++) { outportb(portAddress, 0x00); } end = clock(); /* * Make timeConst.port equal to elapsed time in seconds */ timeConst.port = ((double) (end - start)) / CLOCKS_PER_SEC; if (timeConst.port < 0.005) { Ni = Ni * 4; continue; } if (timeConst.port < 1) Ni = (unsigned long) (Ni * 1.2 / timeConst.port); } while (timeConst.port < 1); /* * Set timeConst.port to time taken by 1 outportb() in seconds. */ timeConst.port = (timeConst.port - Ni * timeConst.loop / reference) / Ni; /* * Set timeConst.loop to count for 1 second */ timeConst.loop = reference / timeConst.loop; /* All time constants set to 1 or larger; a check on time constants */ /* being zero is later used to estimate rc-file validity */ /* Calculate byteWrite for 64ms */ timeConst.pageWrite = timeConst.loop * 64e-3; if (timeConst.pageWrite == 0) timeConst.pageWrite = 1; /* Calculate byteWrite for 12ms */ timeConst.byteWrite = timeConst.loop * 12e-3; if (timeConst.byteWrite == 0) timeConst.byteWrite = 1; /* Calculate resetPuls for 50ms */ timeConst.resetPuls = timeConst.loop * 50e-3; if (timeConst.resetPuls == 0) timeConst.resetPuls = 1; /* Set the other time constants in milliseconds */ timeConst.programEnable = 40; timeConst.chipErase = 120; /* assume ATMega worst case */ timeConst.powerOn = 200; /* Set the default uC clock speed in MHz */ clockSpdDefault = 0.7; fprintf(rcPtr, "# Set KANDA=1 to adapt parallel port pinout:\n"); fprintf(rcPtr, "# to the cable/dongles supplied with the\n"); fprintf(rcPtr, "# Atmel/Kanda STK200/300 starter kits.\n"); fprintf(rcPtr, "# When KANDA=0 (default) the pinout conforms\n"); fprintf(rcPtr, "# to the original SP12 cable and Ken Huntington's\n"); fprintf(rcPtr, "# dongle.\n"); fprintf(rcPtr, "KANDA=%d\n", KandaMode); fprintf(rcPtr, "# Set log path/file to log writes and locks\n"); fprintf(rcPtr, "# to less than 200 characters:\n"); fprintf(rcPtr, "LOGPATH=%s\n", log.logPath); fprintf(rcPtr, "# Set logging=1 to activate logging:\n"); fprintf(rcPtr, "LOGGING=%d\n", log.logging); fprintf(rcPtr, "# Set both logging and query=1 to always query writes:\n"); fprintf(rcPtr, "QUERY=%d\n", log.query); fprintf(rcPtr, "# Time constant for 50ms will be:\n"); fprintf(rcPtr, "RESETPULS=%ld\n", timeConst.resetPuls); fprintf(rcPtr, "# Chip erase delay, 120ms ATMega, 20ms others:\n"); fprintf(rcPtr, "CHIPERASE=%d\n", timeConst.chipErase); fprintf(rcPtr, "# Time constant for 200ms will be:\n"); fprintf(rcPtr, "POWERON=%d\n", timeConst.powerOn); fprintf(rcPtr, "# Set clockSpdDefault to a suitable value in MHz.\n"); fprintf(rcPtr, "CLOCKSPDDEFAULT=%.1f\n", clockSpdDefault); fprintf(rcPtr, "# Do not change anything below this line.\n"); fprintf(rcPtr, "# ---------------------------------------\n"); fprintf(rcPtr, "LOOPCOUNT=%g\n", timeConst.loop); fprintf(rcPtr, "PORTACCESSTIME=%g\n", timeConst.port); fprintf(rcPtr, "BYTEWRITE=%ld\n", timeConst.byteWrite); fprintf(rcPtr, "PAGEWRITE=%ld\n", timeConst.pageWrite); fprintf(rcPtr, "PROGRAMENABLE=%d\n", timeConst.programEnable); } /* Look for the rc file, using environment variable `SP12' (if */ /* this variable has not been set, the current directory is used). */ /* If the rc file exists, then read the time constants and the */ /* parallel port address from this file. If the rc file is not */ /* found, then calibrate the time constants, check for available */ /* parallel ports, set (usually the primary) address, and write */ /* it all into a new rc file. Afterwards check if the parallel */ /* port is actually there (guarding against a corrupt rc file, and */ /* setting the port data register to 0x80), and also check if the */ /* time constants aren't 0. exit(1) if a check fails, else set */ /* parallel port data register 0x00, and portStatus to */ /* portAddress + 1 */ void initSp12(void) { FILE *rcPtr; char *sp12rc; char rcPath[MAXLEN]; char rcLine[MAXLEN]; timeConst.sckLO = 0; timeConst.sckHI = 0; timeConst.resetPuls = 0; timeConst.programEnable = 0; timeConst.chipErase = 0; timeConst.byteWrite = 0; timeConst.powerOn = 0; portAddress = 0; portStatus = 0; writeRetries = 0; timeConst.byteWriteAdjusted = 0; log.logging = 0; log.query = 0; strcpy(log.logPath, "sp12log.txt"); KandaMode = 0; if ((sp12rc = getenv("SP12")) != NULL) { strcpy(rcPath, sp12rc); #ifdef LINUX if (rcPath[strlen(rcPath)-1] != '/') strcat (rcPath, "/"); #else if (rcPath[strlen(rcPath)-1] != '\\') strcat (rcPath, "\\"); #endif strcat(rcPath, "_sp12rc"); } else { strcpy(rcPath, "_sp12rc"); } printf("rcPath: %s\n", rcPath); if ((rcPtr = fopen(rcPath, "r")) != NULL) { /* * Read data from existing rc file, or... */ while (fgets(rcLine, MAXLEN, rcPtr) != NULL) { sscanf(rcLine, "PORT=%x", &portAddress); sscanf(rcLine, "KANDA=%d", &KandaMode); sscanf(rcLine, "LOGPATH=%s", log.logPath); sscanf(rcLine, "LOGGING=%d", &log.logging); sscanf(rcLine, "QUERY=%d", &log.query); sscanf(rcLine, "RESETPULS=%ld", &timeConst.resetPuls); sscanf(rcLine, "CHIPERASE=%d", &timeConst.chipErase); sscanf(rcLine, "POWERON=%d", &timeConst.powerOn); sscanf(rcLine, "CLOCKSPDDEFAULT=%f", &clockSpdDefault); sscanf(rcLine, "LOOPCOUNT=%lg", &timeConst.loop); sscanf(rcLine, "PORTACCESSTIME=%lg", &timeConst.port); sscanf(rcLine, "BYTEWRITE=%ld", &timeConst.byteWrite); sscanf(rcLine, "PAGEWRITE=%ld", &timeConst.pageWrite); sscanf(rcLine, "PROGRAMENABLE=%d", &timeConst.programEnable); } } else { /* * Make a new rc file */ delay(100); /* helps calibration to reach same values every time */ if ((rcPtr = fopen(rcPath, "w")) == NULL) { fprintf(stderr, "Unable to open %s for writing.\n", rcPath); exit(1); } fprintf(rcPtr, "%s\n", RC_USAGE); checkParPort(rcPtr); initTimeConst(rcPtr); } fclose(rcPtr); /* * Do check if the time constants aren't zero... */ if (portAddress == 0 || timeConst.loop == 0 || timeConst.port == 0 || timeConst.programEnable == 0 || timeConst.chipErase == 0 || timeConst.byteWrite == 0 || timeConst.powerOn == 0 || timeConst.pageWrite == 0) { fprintf(stderr, "Initialisation has failed (parallel port not found,\n"); fprintf(stderr, "or %s corrupt).\n", rcPath); exit(1); } timeConst.byteWriteDefault = timeConst.byteWrite; /* * And if the port is actually there. */ outportb(portAddress, 0x80); if (inportb(portAddress) != 0x80) { fprintf(stderr, "Initialisation has failed (parallel port not\n"); fprintf(stderr, "responding, or %s corrupt).\n", rcPath); exit(1); } else { outportb(portAddress, 0x00); portStatus = portAddress + 1; } /* * Now set the parallel port pinout to match * either the original sp12 cable and Ken's `dongle' * or the cable/dongle as supplied with the * Atmel/Kanda STK200/300 starter kits. */ if (!KandaMode) { SCK = S_SCK; MOSI = S_MOSI; MISO_BITNR = S_MISO_BITNR; MISO_INV = S_MISO_INV; RESET = S_RESET; ENABLE = S_ENABLE; PORTPOWER = S_PORTPOWER; DEFAULT_EXIT_STATE = S_DEFAULT_EXIT_STATE; PORTACTIVE = S_PORTACTIVE; printf("Running in SP12 cable/dongle compatible mode.\n"); } else { SCK = K_SCK; MOSI = K_MOSI; MISO_BITNR = K_MISO_BITNR; MISO_INV = K_MISO_INV; RESET = K_RESET; ENABLE = K_ENABLE; PORTPOWER = K_PORTPOWER; DEFAULT_EXIT_STATE = K_DEFAULT_EXIT_STATE; PORTACTIVE = K_PORTACTIVE; printf("Running in Kanda cable/dongle compatible mode.\n"); } outbyte = PORTPOWER; /* Default: start with `port power' on */ /* (all zeroes when KANDA=1) */ } sp12mega8/device.c100644 10243 30014 41330 7604721525 14076 0ustar jrothweihomesys/* SP12: A serial programmer for working with Atmel AVR uCs */ /* Copyright (C) 1997-2001 Ken Huntington, Kevin Towers, Pitronics. */ /* 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 */ /* 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 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. */ /* Pitronics can be reached by email: sbolt@xs4all.nl */ /* Kevin Towers can be reached by email: ktowers@omnexcontrols.com */ /* Ken Huntington can be reached by email: kenh@compmore.net */ #include #include #include #ifndef LINUX #include #else #include "dos_cpt.h" #endif #include "sp12.h" /* Assume the device connected to the Centronics port is powered, */ /* but that device sck was not held low during power-up, so a */ /* reset pulse is needed before the SPI can be enabled. */ /* Assume also that power has yet to be switched on (for separate */ /* programmer powered by parallel port, instead of in-circuit */ /* programming. */ /* If uC is 1200, emit just one PROGRAM_ENABLE command. */ /* Else retry until the third byte read back by clockOutCommand() */ /* is 0x53, or at least 32 retries have been unsuccessful. */ int enableSPI(int uC) { unsigned long readBack = 0; unsigned long Ti; int tries = 0; /* * Initialise programming lines. */ bit_clear(outbyte, ENABLE | SCK | MOSI | RESET); outportb(portAddress, outbyte); /* * Delay to make sure capacitor on separate programmer is charged. */ delay(timeConst.powerOn); /* * If the resetPuls time constant > 0, then Hi pulse device reset */ if (timeConst.resetPuls > 0) { bit_set(outbyte, RESET); outportb(portAddress, outbyte); /* * Delay to make sure that a capacitor * from reset to gnd is (dis)charged */ for (Ti = 0; Ti <= timeConst.resetPuls; Ti++) { } bit_clear(outbyte, RESET); outportb(portAddress, outbyte); /* * Delay before program (SPI) enable command */ delay(timeConst.programEnable); } /* * Command program enable and check synchronization */ while (tries < 33) { tries++; readBack = clockOutCommand(PROGRAM_ENABLE); readBack = (readBack & 0x0000FF00L) >> 8; if ((readBack == 0x53) || (uC == 1200)) { break; } else { /* * Pulse SCK lo-hi-lo */ bit_clear(outbyte, SCK); outportb(portAddress, outbyte); for (Ti = 0; Ti <= timeConst.sckLO; Ti++) { } bit_set(outbyte, SCK); outportb(portAddress, outbyte); for (Ti = 0; Ti <= timeConst.sckHI; Ti++) { } bit_clear(outbyte, SCK); outportb(portAddress, outbyte); for (Ti = 0; Ti <= timeConst.sckLO; Ti++) { } } } if (tries > 1) printf("Sp12 tried %d times to find a working device.\n", tries); if ((readBack != 0x53) && (uC != 1200)) printf("No device connected.\n"); /* printf("readBack: %#lx, tries: %d\n", readBack, tries); */ return(tries); } /* Adapt Sck timing to user's clock speed setting */ /* (Init sets the timing equal to sck0.5M, and the flag will be */ /* zero unless altered by the command line.) */ float setSckTiming(float clkSpeed) { float signal; clkSpeed = (float) 2 / (clkSpeed * 1e6); if (clkSpeed > timeConst.port) timeConst.sckLO = (unsigned long) (timeConst.loop * (clkSpeed - timeConst.port)); else timeConst.sckLO = 1; if (strcmp(device.name, "AT90S1200(A)") == 0 && (clkSpeed * 2) > timeConst.port) timeConst.sckHI = (unsigned long) (timeConst.loop * (clkSpeed * 2 - timeConst.port)); else timeConst.sckHI = timeConst.sckLO; // printf("sckLO %ld, sckHI %ld\n", timeConst.sckLO, timeConst.sckHI); signal = 1.8e-6 / clkSpeed; if (strcmp(device.name, "AT90S1200(A)") == 0) { if ((signal / 2) > (1.8e-6 / timeConst.port)) signal = 4.0e-6 / timeConst.port; } else { if (signal > (1.8e-6 / timeConst.port)) signal = 2.0e-6 / timeConst.port; } return(signal); } /* Before writing to the flash area, the device has to be erased. */ /* Note: This command also erases the eeprom area (all to 0xFF). */ /* There is no need for general erase before writing to the */ /* eeprom area, since the device has an auto-erase built into */ /* the eeprom write cycle. Thus you can alter one or more eeprom */ /* addresses without disturbing the rest of the device. */ void eraseDevice(void) { clockOutCommand(CHIP_ERASE); /* * Delay before program (SPI) enable sequence */ delay(timeConst.chipErase); /* * syncronisation must be ok, so just one PROGRAM_ENABLE * command will be clocked out. */ enableSPI(1200); } /* A routine to switch control the optional test bits on the */ /* parallel port. */ void portControl(int portFlag, int exitFlag) { if (exitFlag) { outbyte = (unsigned char) portFlag; } else { outbyte = (unsigned char) portFlag & PORTACTIVE; delay(10); } outportb(portAddress, outbyte); } /* Reads flash and eeprom area's. Return 1 if a flash address does */ /* not contain 0xFFFF, or 3 if an eeprom address also isn't blank; */ /* return 2 if the flash is blank, but the eeprom isn't; */ /* return 0 is both area's are blank. */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ int blankCheck(long flashLimit, long eepromLimit) { long address; int signal = 0; for (address = 0; address < flashLimit; address++) { if (readCodeWord(address) != 0xffff) signal |= 0x01; } for (address = 0; address < eepromLimit; address++) { if (readDataByte(address) != 0xff) signal |= 0x02; } return(signal); } /* Quoting the AT90 datasheet: */ /* Mode 2: further programming of the flash is disabled. */ /* Mode 3: same as mode 2, but verify is also disabled. */ void writeLockBits(int mode) { if (mode == 2) clockOutCommand(WRITE_LOCK_W); if (mode == 3) clockOutCommand(WRITE_LOCK_RW); } /* Valid only for the AT90S2343. */ /* 0: Internal RC clock enabled. */ /* 1: Internal RC clock disabled. */ /* Note that the fuse bit can be altered even if the device is */ /* locked mode 3. */ /* Verifies the fuse bit and returns 0 if OK, else returns 1. */ int writeRCENfuse(int state) { int lockFuse = 0; unsigned long Ti; if (state == 10) { clockOutCommand(PROG_RCEN_FUSE); for (Ti = 0; Ti <= timeConst.byteWrite; Ti++) { } lockFuse = readLockFuse(); if ((lockFuse & 0x01) == 1) return(1); } if (state == 11) { clockOutCommand(UNPROG_RCEN_FUSE); for (Ti = 0; Ti <= timeConst.byteWrite; Ti++) { } lockFuse = readLockFuse(); if ((lockFuse & 0x01) == 0) return(1); } return(0); } /* Valid only for the AT90S2323, 4434, 8535. */ /* 0: Short start-up time selected. */ /* 1: Default (long) start-up time selected. */ /* Note that the fuse bit can be altered even if the device is */ /* locked mode 3. */ /* Verifies the fuse bit and returns 0 if OK, else returns 1. */ int writeFSTRTfuse(int state) { int lockFuse = 0; unsigned long Ti; if (state == 10) { clockOutCommand(PROG_FSTRT_FUSE); for (Ti = 0; Ti <= timeConst.byteWrite; Ti++) { } lockFuse = readLockFuse(); if ((lockFuse & 0x01) == 1) return(1); } if (state == 11) { clockOutCommand(UNPROG_FSTRT_FUSE); for (Ti = 0; Ti <= timeConst.byteWrite; Ti++) { } lockFuse = readLockFuse(); if ((lockFuse & 0x01) == 0) return(1); } return(0); } /* Valid only for the AT90S2333, 4433 and ATmega103/603. */ /* Since (re)enabling brown-out detection usually causes the */ /* AT90(L)S2333/4433 to hang, the fuses are only written, not */ /* verified. */ int writeFUSES(unsigned char fuses) { unsigned long fuseWord = 0; unsigned long writeCmd; fuseWord = (unsigned long) fuses << 16; fuseWord = fuseWord & 0x003F0000L; writeCmd = WRITE_FUSES | fuseWord; fuseWord = fuseWord | 0xFFC0FFFFL; writeCmd = writeCmd & fuseWord; clockOutCommand(writeCmd); /* * ByteWrite delay not long enough to allow reading back * of true ATmega103/603 fuses directly after this */ delay(timeConst.chipErase); return(0); } /* Reads the lock and fuse bits from the device connected to the */ /* Centronics parallel port. Valid only for AT90S2323, 2343, 4434 */ /* 2333, 4333, 8535 and ATmega103/603. */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ unsigned char lockAndFuse[4]; /* for the ATmega8 */ unsigned char readLockFuse(void) { unsigned char lock; unsigned char lockFuse; if (device.fuseMode == 8) { /* Just read the words for now. Interpret later. */ lockAndFuse[0] = (unsigned char) clockOutCommand(READ_LOCK_M8); lockAndFuse[1] = (unsigned char) clockOutCommand(READ_FUSE_M8); lockAndFuse[2] = (unsigned char) clockOutCommand(READ_FUSE_HI_M8); lockAndFuse[3] = (unsigned char) clockOutCommand(READ_CAL_M8); fprintf(stderr, "ATmega8 lock 0x%2.2x fuse 0x%2.2x 0x%2.2x cal 0x%2.2x\n", lockAndFuse[0],lockAndFuse[1],lockAndFuse[2],lockAndFuse[3]); /* This is a hack, to keep return a value similar to the 2323 etc */ lockFuse = (lockAndFuse[0]<<5) &0xc0; } else if (device.fuseMode > 5) { lock = (unsigned char) clockOutCommand(READ_LOCK); lockFuse = (unsigned char) clockOutCommand(READ_FUSE); lockFuse = lockFuse & 0x3F; lock = lock << 5; lock = lock & 0x00FF; lockFuse = lockFuse | lock; } else { lockFuse = (unsigned char) clockOutCommand(READ_LOCK_FUSE); } return(lockFuse); } /* Read the signature bits from the device attached to the */ /* Centronics parallel port. */ void readDeviceCode(void) { unsigned long readCmd; readCmd = READ_DEVICE | 0x0200L; device.sigByte_2 = (unsigned char) clockOutCommand(readCmd); readCmd = READ_DEVICE | 0x0100L; device.sigByte_1 = (unsigned char) clockOutCommand(readCmd); readCmd = READ_DEVICE | 0x0000L; device.sigByte_0 = (unsigned char) clockOutCommand(readCmd); } /* Shifts the command highest bit first into unsigned char output, */ /* which then is used to clock them out bit by bit through */ /* Centronics data-7. */ /* Reads back and returns whatever the uC clocks out on Miso */ /* while the command is clocked in. */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ unsigned long clockOutCommand(unsigned long command) { unsigned long inBuf; unsigned long readBack = 0x0L; unsigned char inbyte; /* from Centronics status reg. */ int mostSigBit; int i; unsigned long Ti; mostSigBit = 31; /* * Bits mostSigBit-0 to be clocked out */ for (i = mostSigBit; i >= 0; i--) { /* * Bits mostSigBit-0 to be clocked out */ if ((command >> i) & 0x01L) bit_set(outbyte, MOSI); else bit_clear(outbyte, MOSI); bit_clear(outbyte, SCK); outportb(portAddress, outbyte); /* * Minimum delay SCK lo period */ for (Ti = 0; Ti <= timeConst.sckLO; Ti++) { } /* * Set bit-0 (SCK) hi, leave all other bits as they are */ bit_set(outbyte, SCK); outportb(portAddress, outbyte); /* * Minimum delay SCK hi period */ for (Ti = 0; Ti <= timeConst.sckHI; Ti++) { } /* * Fetch parallel port status register, clear all bits * except 7 (MOSI), invert, shift and or into buffer */ inbyte = inportb(portStatus); inBuf = ((unsigned long) (inbyte ^ MISO_INV)) >> MISO_BITNR; inBuf = (inBuf & 0x00000001L) << i; readBack = readBack | inBuf; } /* * return SCK to lo */ bit_clear(outbyte, SCK); outportb(portAddress, outbyte); return(readBack); } /* Accepts a dataByte and a 16-bit address. Writes the byte into */ /* the device connected to the Centronics port and verifies arrival. */ /* Returns 1 if verify fails three times, else 0. */ /* The time constant byteWrite is adjusted dynamically, */ /* if the device is not a 1200(A) and/or optimizeFlag allows. */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ int writeByteVerified(unsigned long writeCommand, unsigned long readCommand, int optimizeFlag) { unsigned long Ti; int idx; unsigned char readBack; int failure = 0; unsigned char dataByte; /* * First check if the data isn't already in the uC */ dataByte = (unsigned char) writeCommand; readBack = (unsigned char) clockOutCommand(readCommand); if (readBack == dataByte) return(failure); /* * Else write the data into the uC */ dataByte = (unsigned char) writeCommand; clockOutCommand(writeCommand); switch (dataByte) { case 0xFF: case 0x7F: case 0x80: case 0x00: for (Ti = 0; Ti <= timeConst.byteWriteDefault; Ti++) { } readBack = (unsigned char) clockOutCommand(readCommand); break; default: for (Ti = 0; Ti <= timeConst.byteWrite; Ti++) { } readBack = (unsigned char) clockOutCommand(readCommand); if ((strcmp(device.name, "AT90S1200(A)") != 0 && optimizeFlag != 10) || optimizeFlag == 11) { if (readBack != dataByte) { timeConst.byteWrite += timeConst.byteWriteDefault / 12; timeConst.byteWriteAdjusted = 1; for (Ti = 0; Ti <= timeConst.byteWrite; Ti++) { } readBack = (unsigned char) clockOutCommand(readCommand); } else { if (timeConst.byteWriteAdjusted == 0) timeConst.byteWrite -= timeConst.byteWriteDefault / 12; } } } idx = 1; if (readBack != dataByte) { timeConst.byteWrite = timeConst.byteWriteDefault; timeConst.byteWriteAdjusted = 0; do { clockOutCommand(writeCommand); for (Ti = 0; Ti <= timeConst.byteWrite; Ti++) { } readBack = (unsigned char) clockOutCommand(readCommand); } while (readBack != dataByte && ++idx < 4); writeRetries += idx - 1; if (readBack != dataByte) failure = 1; } return(failure); } sp12mega8/licence.txt100664 10243 30014 44330 7605316016 14637 0ustar jrothweihomesysGNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: * a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. * b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. * c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: * a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, * b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, * c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. one line to give the program's name and an idea of what it does. Copyright (C) 19yy name of author 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 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 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. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) 19yy name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. signature of Ty Coon, 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. sp12mega8/eeprom.c100644 10243 30014 11474 7225105454 14130 0ustar jrothweihomesys/* SP12: A serial programmer for working with Atmel AVR uCs */ /* Copyright (C) 1997-2001 Ken Huntington, Kevin Towers, Pitronics. */ /* 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 */ /* 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 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. */ /* Pitronics can be reached by email: sbolt@xs4all.nl */ /* Kevin Towers can be reached by email: ktowers@omnexcontrols.com */ /* Ken Huntington can be reached by email: kenh@compmore.net */ #include #include #include #ifndef LINUX #include #else #include "dos_cpt.h" #endif #include "sp12.h" /* Accepts a 16-bit address. Reads the dataByte in two steps */ /* from the device connected to the Centronics port. */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ unsigned char readDataByte(unsigned int address) { unsigned int dataByte; unsigned long readCmd; readCmd = READ_EEPROM | ((long) address << 8); dataByte = (unsigned char) clockOutCommand(readCmd); return(dataByte); } /* Accepts a dataByte and a 16-bit address. Writes the code in two */ /* steps into the device connected to the Centronics port and */ /* verifies arrival. Returns 1 if verify fails three times, else 0. */ /* The time constant byteWrite is adjusted dynamically, */ /* if the device is not a 1200(A) and optimizeFlag allows. */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ int writeEepromVerified(unsigned int address, unsigned char dataByte, int optimizeFlag) { int failure; unsigned long readCmd, writeCmd; readCmd = READ_EEPROM | ((long) address << 8); writeCmd = WRITE_EEPROM | ((long) address << 8); writeCmd = writeCmd | dataByte; failure = writeByteVerified(writeCmd, readCmd, optimizeFlag); return(failure); } /* Expects eepromBuf[] to be filled with data. */ /* executes writeEepromVerified() address by address; */ /* if verify fails, stops and returns 1, else returns 0. */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ int writeEepromArea(unsigned int eepromBuf[], long bufLimit, int optimizeFlag, int overlayFlag) { long address, previous; previous = 0; printf("...............................................................\r"); /* * If the overlayFlag is cleared, all addresses are written to * since all data words (including 0xFF) can be valid. * When the overlayFlag is set, buffer addresses containing * the original 0xFFF padding are skipped. */ for (address = 0; address < bufLimit; address++) { if (address >= (previous + bufLimit / 64)) { putchar('o'); fflush(stdout); previous = address; } if (overlayFlag && eepromBuf[address] > 0xFF) continue; if (writeEepromVerified (address, (unsigned char) eepromBuf[address], optimizeFlag) == 1) { printf("!!\n"); return (1); } } printf("\n"); return (0); } /* (expects eepromBuf[] to be filled with 0xFF) */ /* Loops readDataByte into eepromBuf[] */ /* Power bits prior state assumed on; left on at return. */ /* SCK prior state assumed lo; left lo at return. */ void readEepromArea(unsigned int eepromBuf[], long bufLimit) { long address, previous; previous = 0; printf("...............................................................\r"); for (address = 0; address < bufLimit; address++) { eepromBuf[address] = readDataByte(address); if (address >= (previous + bufLimit / 64)) { putchar('o'); fflush(stdout); previous = address; } } printf("\n"); } sp12mega8/sp12100775 10243 30014 142350 7605130546 13232 0ustar jrothweihomesysELF44 (444JJ,xKK /lib/ld-linux.so.2GNU%(&%"$'   !  #ZX[(hb';xgI'"(n'AȈ؈5w ": M$M(8@aHHXI#hx"'!,<gȉ7؉Ou"' _(8%DH'BXd hlibc.so.6strcpyasctimegetgidprintf__strtod_internalstdoutgetenv__strtol_internalusleepfgetsmemcpyperror__cxa_finalizegetuidmallocfflushiopermfprintfstrcat__deregister_frame_infofseeksetgidsscanflocaltimetimesprintffclosestderrexitfopen_IO_putc_IO_stdin_used__libc_start_mainclockstrchrsetuid__register_frame_infofree__gmon_start__GLIBC_2.1.3GLIBC_2.1GLIBC_2.0si sii ii M& M$MLLLLLLLLL L L L L LLLLLLLLLLLLLLLL L!L"L$M%M'Uii5xL%|L%Lh%Lh%Lh%Lh%Lh %Lh(%Lh0%Lh8p%Lh@`%LhHP%LhP@%LhX0%Lh` %Lhh%Lhp%Lhx%Lh%Lh%Lh%Lh%Lh%Lh%Lh%Lhp%Lh`%LhP%Lh@%Lh0%Lh %Lh%Lh%Lh%Mh%Mh1^PTRhh0QVhUS[tЋ]ÐU=Ju>JPJСJ8ut hKJÐUUth(MhK?ÐUÍUSEBEBEjQPH]SQPO SQPPhh =Pt5PD=Pt5P*uUVSu0KRR ÃSh!5$Mu~a#@q#ZP;*j h2hR@R@DRPR j h?hRd@RDRPRjhIhR$@RDRPRj hchR@RDRPRfj hphR@RDRPR&j hzhRd@RDRPRj hhR$@RDRPRj hhR@RDRPRfj hhR@RDRPR&j hhRd@RDRPRj hhR$@RDR.vj hhR@RDRPRLRoRATme@ga8@RDR PRLR3vjhhRt@RDR=Ru!RAtmef@lt&jhh!R$P> )  4Ug'#<"+r(['j h2hRb@R@DRPR `j h?hR$@RDRPR'jhIhR@RDRPRj hchR@RDRPRj hphR}@RDRj hzhRP@RDRPRSt&j hhR@RDRPRj hhR@RDRPRj hhR@RDRvj hhRt@RDRPRzj hhR@@RDR*j hhR@RDRPRLRVh HR؍e[^ÍvU=Kuj@hKn =Kuj@hKKÍvU=K uEj @u$hh t&h =K u:j =@uh`h hKÐU= K u1j o@uh h@[= K u4j 5@uh1&h KÍvU$SEBEBE@E=PRp= Kt@$EuhEth@Eu hh{EPEPBEPhVE]ÐUVS]E E5L-V,?ŠE "]؃SPh@ P>Phf Q)ЍPV> %Phs؍e[^ÐUS]E E5P->ŠE "]؃SPh_؋]U=Kt=5Kh6h ) h`K=0KtDhh h h`0K =$K=PR~7hh h $K=$Kt@=PR7hSh`F h6$K=K=PRuDhh  h`hK =KtM=PRtDhh hh<K =K=PRuDh`VhI h9h ,K =Kt@=PRt7h`h` hK=K=PRuDhh  h`h K =Kt@=PRt7h]hP h@K=K=PRuDhh  h`hK =Kt@=PRt7hh hK= K=PRuDh@mh` h`PhC K = Kt@=PRt7h@h h  K= K=PRuDh@ h  h h K = Kt@=PRt7h@ th g h< W K=K=PRuDh` 'h  h  h K =Kt==PRt4h` h h4 KU=4Kt^h` h  h oh b h` Rh E4KÐUSh $5@R5DR4à uh th t h@ ؋]ÐU,WVS1EBEBE=HRh` j h2hR5^2؃h{0 5JjT05JR% =uWh h  h h` hh =Ju_RPRPRPh5Qh@u hRht`h!RhN =DRt =@Ruh,j =Jt=DRthRh5Q0؃1;DR}vPC;DR|1;@R}PC;@R|LKE@tDPKE@t2$h0$h \LKPK LK=K =Jth`j =KT K=J=Jthj =JtX=Jt#=$Kthj^ =Jt#=$Kth tj2 =Jt#=$Kth`Hj =`Kt =\Kto=TKt*hh j=\Kt3=XKt*hh@ j=TKt3=XKt*hh jI=JJ=\Kt9\K5dK(hK5dKPh- h45DR5P+ =`K`Kh@Mh`5XK5TKh@M5DR5PA0t$h@MhhjS TKXK\=XKt%j5DR5PBXK.1;DR}$P4Sh"C;DR|ރ=8KtC8K5DR5P*5DR5P;Ph0=JJ=\Ktr\K5lK*J%pK]SpKP4 SpKPPPh[ 5lKh EBt&hD+5@R5PJ =`K`Kh Nh`5XK5TKh N5@R5Pr@0t$h Nhhjf TKXK=XKt%j5@R5PAXKYhG1ۃ;@R}?uVPP@3VP444Sh0C;@R|ă=8KtC8K5@R5PI5@R5P9Ph 0=$K=PR$KJ.h@vhmi u&=PRuhHh; t.=PRuhh u!=PRuh t=PRuh`=PRSh؃t&tNt)t4Bh'.h6hGhWKt hh)=PRuou h vh@u hhEP%P0EPh =PR{TRPhTRxK4TRPTRPhW TR4TRPTRPh$TR$4KTR$PTRPh URPhUR$PURPURPURPh@0VRPhsVR$PVRPVRPVRPVRPVRPVRPh+0:=PR~%=u#t&%@uhuh %=uhH[=J(JQQQQ=Jw=JthVj =JGJ=\K\K=LRthj hh  h`h 5dK5hKh5DK5hK5dK;!E EP5HK5Ph@M5hK5dKhO= thhh9}5dKh j =`K`K=HKuhI&=4Kt 4Kt jth@Mh5DR5Ph@M,E t$hh@Mh]j 5DK5DR5PR EEP5HK5Ph@M5hK5dKhOa<0thhh}t;5Qh =HKth`jm_h@Mh5Qh~ =LRu!Q15QPhhD=8KtC8K5DR5P 5DR5P#2Ph0=J`J=\K\K5lK5pKh5DKpKP5lKN@E EP5HK5Ph N5pK5lKhO: thhh@}Z5lKh@=`K:`Kh Nh5@R5Ph N-E t$hh Nhj{ 5HK5DK5@R5P?EEP5HK5Ph N5pK5lKhO90thhhD}t#5Qh (j@t&h NhQ15QP5Qh =8KtC8K5@R5Pj?5@R5P/Ph 0+HK=8K8K=JJ=`KtZ`K5@R5PhO+5@R5P/PhOht&5@R5P>5@R5P.Ph =JJ=`Ktq`K5DR5PhO't#hhOhQjy5DR5PN.PhOh P5DR5P5DR5P.Ph0h@h l=Kt&5K5P: @=Kt=PRu== Kt=PRu=Ku=Ku =Ktk=PRuuIhh h@h j u =Ku = Kt=PRuK=PRuV=uKt"uKPtKP(uK=wKt"wKPvKPwK=0Kt0KhIb=4Kt4KJe[^_ÐU,WVSEBEBEHR@M NOjjhxthjt&jjhxthcjjjhWth3jy`PjP }~jhE pth`h j h hPuh` jC hPuh` Rj EU9U M܋U 8-=(K(K=,Kth j =8Kt%=Ku=JuM܋E 4hO:=JtU܋M 4h@Mt&=Jt-E܋U 4h NI`KIh M܋U 8-<=,K,K=Jt:j:SÅuh !j =Jt=Jt5M܋E 4!dK=JtPCS!hK<=JtGU܋M 4f!lK=JtCSK!pK\KAh`!Kj #t&U܋M 8-t#Ph!U܋M 8-jwE܋U 4tM܋E 4hOU܋M PPRh!BЃG$|$E܋U <HvMjj j42J}h "Sh`"E܋U <HsMjjj4@KQE܋U <H0Mjjj4@KE܋U <HMjj j4K=PR~'58-Ã5<-p$?54-Y%]ÍvUD-P5RD-PR 5D- RÉU WVS15QQfEUs Q Q Q QQ"QQ1;Qw Q@9vQ QQ1;Qw Q@9vU2Q% Q KbQ"QQQ[^_ÐUWVS]EEEM QE:Eu1EEMQE= } t /=u(1;QwQ&@9vE P1;Qw Q@9vM QfER7 t u E:EtZQ%88QQ1;QwQ&@9vM QE)&=QuQ%88)QM:MtqQQQEP1;Qw Q@9vM QeE:EtC~QHأQE:EtEEe[^_Ðt&UExxujj80ujj 8Bu@jjjP趮 jj jP訮ÉUS] U$0Iy[U WVSEDž h@8P=4PjEP'}:jjR߭]^$PhB8S袮}: PhF8EP}M9$$ M PjS臭uZv}:fjjQ;t&PhI8)PPhM8+S̭ WhI8S躭WhI8-P蟭 PhI8/P{uy PhQ81SNWhI8S? WhI83P!WhI85P ;( PhI8+(P輬艅$ $U9$u$ M !$ M !  9WWhI8+(P;u?Ph(P,R被1 [^_U WVSEDžh@8P  Pj]S諪j:Sũ9jj RWHj:W蕩ÅWtƃCSh ;uU  PjWuU]j:S*9Mjj P輩(t&$PhI8)P]$ PhM8+S< RhI8S$PhI8-P PhI8/PߩPhQ81S让RhI8S虩 PhI83PuRhI85PM ; ƻ @PhI8P;uU F$ 9|PhI8P覨;u9 RhP R61[^_ÉUWVSu} 119}7t&<ut %C9|͉[^_ÉUWVSuEEE}~hV8EPh)ƃ}u8}~EVEPhg8EP4EEEEtE E E Pht8EP]EE9Eu&E%Phy8EP迥EFO*h8EP蚥1e[^_UWVS}uEE}u3u~EWEPh8EP@]ÉÃE 0ht8EPE EE9Eu%%Phy8EPEE GNkh8EP¤1e[^_U|WVSDžƅ8ƅpDžE9ptX1uF􋅘P8P+Ph8UR ƅ8ƅp}DžE PWh8VGV8Pg ^w Wh8Vh8Q SP#<^wPh8Sh8R轤QP{M 4h8S脤S8P褣M B ^w Rh8Sh8P=RQTE9pP8P+Ph8URP t&MQE P5Ph8UR&1x[^_ÉU WVS} h8utƃuf}tjWEPVCt&}tWjEPV '19}!E4Sh8V薡tC9|V蠢1e[^_ÉUWVSM88EBEBEh8QǃtV}tjE PURWj}tE PjURWrmt&h9Wu Vv1;] }AuVUPVUPPPSh@9W螠0tC;] |ȃW觡1e[^_ÐU|WVSDžƅ8ƅpDžE 9p~Gu6P8P+Ph8Ƞƅ8ƅp}DžMPWh8VV8P< ^w Wh8Vh8RSQ<^wPh8Sh8P蒠RQ|U4h8SXS8PxEB ^w Rh8Sh8RQP(U 9)pP8P+Ph8 M QEPPh8x[^_ÉUSU] M19}%9u<u  D@9}9u[ÐUWVS]=QhjEPhR8P.8h9u8j h9P^hj 8P5hx` uh96j~llPɜd h9hPNhu`Q"EP8Ph9hQ茜jfEP;upPpމ߰ЍPH~)<\t#</tt&I~ <\t</u)PjSSh9hQ =Q@jpEP芛tn5DR`Q&5DR`PËM 1҃ B;DR}t E<tው`M;tj5@R`Q5@R`P+ËM 1҃ B;@R}-}t E<wM`9tӋE M 9t"dP蘛Ph9t&dPyPSh9t&dPVPh9~jpEP*t SM Qh: SM Qh:hPAM 9tdPPh9t&dP֚Ph,:hQ hP`QC1H[^_ÉUWVS}=Qt1hR8PAhj 8Sxj4 4P60h9hP辚ƃ u Sh?:V"5DRW 5DRWÃShK:V 5@RWv5@RWà 0P苙PSh]:V讘 V™1 [^_UE -PM%ÉUE - -U ЃuQPÐU WVSu 1h:1ۃ9t&}F?9|&5 MjoF5 M߃}t E<w6URUPSEuh:tt&C9wh:R1e[^_U WVSu 1h:-1ۃ9}TS%U}F?9|&5 Mjok5 M߃C9|h:×e[^_ÍvUSdL=dLt Ѓ;u[UÍt&US[XZ記] SP12/32 version 1.0.3jhr: A serial programmer for Atmel AVR uCs. Copyright (C) 1997-2001 Ken Huntington, Kevin Towers, Pitronics. SYNOPSIS sp12 - [filename or address(:data)] - [filename... OPTIONS i - init L2, L3 - lock modes e - eprom area S0, S1 - FSTRT modes p - program area R0, R1 - RC enable/disable w - write to area D0, D1 - BODEN modes r - read from area V0, V1 - BODLEVEL select a - address(:data) next K[nnn] - CKSEL fuses f - filename next A0, A1 - EESAVE modes I - create Intel Hex file U[nn] - SUT fuses H - Hex dump with ascii rF - read lock & fuse bits E - chip erase M[n.n] - match Sck to uC clock B - blank check P[nnn] - parallel port control C - calculate checksum o0, o1 - optimization X - Atmega8 flag bits,mask. Y - Atmega8 high flag bits,mask. EXAMPLES sp12 -wpfC prog.hex -wefC data.eep -L2 (Writes prog.hex into program area, and data.eep into eeprom area, providing checksums for both; the device is then locked mode 2) sp12 -wea 0x01:153 (Writes 153 into eeprom address 0x01. Other data formats: 0x99, 0231, B10011001 76543210Writing the byte %#04x (%d, B%s) to the parallel port data bits. deviceCode 0x%x AT90S1200(A)AT90S2313AT90(L)S2343 or Tiny22(L)AT90(L)S2323AT90S4414AT90(L)S2333AT90(L)S4433AT90(L)S4434AT90S8515AT90(L)S8535ATmega603ATmega103ATmega8unknown device, or no deviceAtmelan unknown manufacturerWARNING: -i%d is not a supported device. Device now write-protected. Device now read- and write-protected. Internal RC clock enabled, if available; check sp12.doc for details. Internal RC clock STILL DISABLED. Internal RC clock disabled, if external clock option is available; check sp12.doc for details. Internal RC clock STILL ENABLED. Short start-up time selected. Default (long) start-up time STILL SELECTED. Default (long) start-up time selected. Short start-up time STILL SELECTED. WARNING: The device is write-protected; WARNING: The device is read- and write-protected; Therefore EESAVE mode can't be changed. The following information was read back from the fuse bits: Start-up time code selected is %d (5 CPU cycles) 512 WDT cycles) 4K WDT cycles) 16K WDT cycles) EEPROM is NOT preserved thru chip erase EEPROM is preserved thru chip erase Brown-out detection enabled. Brown-out detection disabled. Brown-out trigger set at 4.0V. Brown-out trigger set at 2.7V. CKSEL = %s (datasheet page 20, table 5) Changing low flags from 0x%x to 0x%x rtnval 0x%x Flags now read as 0x%x Changing high flags from 0x%x to 0x%x You have selected option -L%d to lock the device, which has had no effect. Do not use this option in combination with others. You have selected option -E for erase, which has had no effect. Options -w, -p and -f together cause an automatic erase; -E should be used on its own or together with B if you want a blank check afterwards. You have selected option -F to read the lock and fuse bits, which has had no effect. This option can only be used in the command -rF, not together with other options. which has had no effect. This option is valid only for the AT90S2323, 2343, 2333, 4433, 4434, 8535 and ATmega103/603. You have selected option -R0 or -R1 to (un)program the RCEN fuse, which has had no effect. This option can only be used as a separate command, not together with other options. RCEN fuse, which has had no effect. This option is valid only for certain AT90S2343 and Tiny22 uCs; check sp12.doc. for details. You have selected option -D0 or -D1 to (un)program the BODEN fuse, which has had no effect. This option can only be used as a separate command or in combination with Vn and Knnn, not together with other options. BODEN fuse, which has had no effect. This option is valid only for the AT90S2333 and 4433. You have selected option -V0 or -V1 to (un)program the BODLEVEL fuse, which has had no effect. This option can only be used as a separate command or in combination with Dn BODLEVEL fuse, which has had no effect. This option is valid You have selected option -Knnn to program the CKSEL fuses, which has had no effect. This option can only be used as a separate command or in combination with Dn and Vn, not not together with other options. which has had no effect. This option is valid only for the AT90S2333 and 4433. You have selected option -S0 or -S1 to (un)program the FSTRT fuse, which has had no effect. This option can only FSTRT fuse, which has had no effect. This option is valid only for the AT90S4434 and 8535. You have selected option -A0 or -A1 to (un)program the EESAVE fuse, which has had no effect. This option can only be used as a separate command or in combination with Unn, EESAVE fuse, which has had no effect. This option is valid only for the ATmega103/603. You have selected option -Unn to program the SUT fuses, which has had no effect. This option can only be used as a separate command or in combination with An, not together with other options. the ATmega103/603. You have selected option -B for blank check, which has had no effect. Options -w, -p and -f together cause an automatic erase; if you also want a blank check before programming, use -Bwpf. Use -EB if you just want an erase followed by a blank check, or -B on its own for a blank check without a preceding erase. Performing blank check... The program and eeprom area's are blank. The program area is NOT blank. The eeprom area is NOT blank. Enabling AVR serial reading/programming... WARNING: You have connected an unidentifiable device, which may be locked mode 3. Access to a supported, mode 3 locked device can be regained, but only by erasing it first. Check SP12.doc for details. The device code bytes 0,1,2: %#x, %#x, %#x were read from parallel port %#x and indicate the following: You have connected an %s The device was made by %s Nothing to do for sp12. Device code check OVERRULED! Assuming an %s Sck timing set for %.1f MHz or higher. Do not use options -w and -r in a single command. Do not use options -p and -e in a single command. Do not use options -p, -e and -F in a single command. Do not use options -p and -F in a single command. Do not use options -e and -F in a single command. The Intel Hex format is only available when writing an entire memory area to file. A hex dump with ascii translation is only possible when writing an entire memory area to file. Select either Intel Hex format or hex dump with ascii translation; not both at the same time The word %#06x was read from program address %#08x Reading program area. Writing program area content to %s Unable to write to, or finish writing to%s %s %06lx:%04x Checksum program area: %04x The byte %#04x (%d, %#o, B%s) was read from eeprom address %#06x Reading eeprom area. Writing eeprom area content to %s Address: Data in hex, dec, oct, bin %#04lx: %#04x %3d %#4o %s Checksum eeprom area: %04x The following information was read from the lock and fuse bits: Internal RC clock enabled. (If available; check sp12.doc for details.) Internal RC clock disabled. Short start-up time selected. Default (long) start-up time selected. No restrictions.Write not allowed.Read not allowedNeither Write nor read allowed.Programming and verification enabled.Programming disabled, verification enabled.Undefined conditionProgramming and verification disabled. lock bits 0x%2.2x BLB12 BLB21: %d %d Boot Block %s BLB02 BLB01: %d %d Application %s LB1 LB0: %d %d %s low fuse bits 0x%2.2x BODLEVEL %d BODEN %d SUT[1:0] %d CKSEL[3:0] 0x%x high fuse bits 0x%2.2x RTDISBL %d WDTON %d SPIEN %d CKOPT %d EESAVE %d BOOTSZ[1:0] %d BOOTRST %d Device is write-protected. Device is read- and write-protected Device is not protected ERROR: Single address flash programming not available on ATMega's. WARNING: writing to single address in program area. Chip erase is not automatic; unless you used a separate -E command, it may not be possible to correctly write new data. Writing %#06x into address %#08x in program area. sp12log.txtReadback ERROR at program address %#06x Performing chip erase... Writing content of %s into program area. does not exist, wrong format, address > limit, or HEX file checksum failure.Readback ERROR after %d write retries. The error may be due to an overlay conflict. %s written and verified. write retries: %d, byteWrite: %ld percent of default . Writing %#x into address %#x in eeprom area. Readback ERROR at eeprom address %#04x Writing content of %s into eeprom area. write retries: %d, byteWrite: %ld percent of default Checksum eeprom file %s: %04x Checksum program file %s: %04x you have selected option -C, but there is nothing on the command line to calculate a checksum for. (Re)enabling brown-out detection usually causes the AT90(L)S2233/4433 to hang, so there is nothing further to do for sp12. Before programming can continue, power to the 2233/4433 must be switched off and back on again. =ioperm error at 0x278ioperm error at 0x378ioperm error at 0x3BC%sSP12 version 1.0.3jhr performing init... ERROR: No memory available for buffer! Do not use options -f and -a in a single command. Option -f must be combined with option -e, -p or -C Option -wa must be followed by address:data Option -a must be combined with option -e or -p No -a or -f option preceding argument `%s' Looping: idx %d argv[idx] %s (0x%x) WARNING: option -i[NN] has no effect unless it is first on the command line. processing %s processing %s %s The -X option is: -Xflags,flagmask argv[%d] %s strp %s New low flags will be 0x%x mask 0x%x New high flags will be 0x%x mask 0x%x The -Y option is: -Yflags,flagmask The character `%c' is not a valid option. Option -T is not available in Kanda compatible mode. Reset was left high. One or more `power' bits were left high. ?= pм`R оغPv@g# SP12: A serial programmer for working with Atmel AVR uCs # Copyright (C) 1997-2001 Ken Huntington, Kevin Towers, Pitronics. # # 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 # 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 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. # # Pitronics can be reached by email: sbolt@xs4all.nl # Kevin Towers can be reached by email: ktowers@omnexcontrols.com # Ken Huntington can be reached by email: kenh@compmore.net # # Runtime configuration file to initialise time constants, # parallel port, logging and port mode (sp12 native or Kanda # compatible). # Sp12 will make this file when first started; it will appear # in the directory as defined by the environment variable SP12, # or in the current directory if this variable is not set. # The next time sp12 starts, time constants, port address, logging # parameters and port mode will be read from this file. # The primary parallel port address will be automatically selected. # if you need to use, for instance, the secondary (0x278), then # by all means edit this file manually, but don't change the *format* # of the NNNN=ddd type statements, only the values. Note that # BYTEWRITE is an upper limit; the value actually used is dynamically # adjusted when sp12 runs. Check changes.doc for other details. S( H@LXXP0XPX?8Looking for parallel ports... # Parallel port available at 0x278 # NO parallel port at 0x278 # Parallel port available at 0x378 # NO parallel port at 0x378 # Parallel port available at 0x3BC # NO parallel port at 0x3BC # This port address will be used: PORT=%#x Calibrating delay loop. This may take some time... # Set KANDA=1 to adapt parallel port pinout: # to the cable/dongles supplied with the # Atmel/Kanda STK200/300 starter kits. # When KANDA=0 (default) the pinout conforms # to the original SP12 cable and Ken Huntington's # dongle. KANDA=%d # Set log path/file to log writes and locks # to less than 200 characters: LOGPATH=%s # Set logging=1 to activate logging: LOGGING=%d # Set both logging and query=1 to always query writes: QUERY=%d # Time constant for 50ms will be: RESETPULS=%ld # Chip erase delay, 120ms ATMega, 20ms others: CHIPERASE=%d # Time constant for 200ms will be: POWERON=%d # Set clockSpdDefault to a suitable value in MHz. CLOCKSPDDEFAULT=%.1f # Do not change anything below this line. # --------------------------------------- LOOPCOUNT=%g PORTACCESSTIME=%g BYTEWRITE=%ld PAGEWRITE=%ld PROGRAMENABLE=%d .A{Gzt?333333?Mb?~jt??333?sp12log.txtSP12/_sp12rcrcPath: %s rPORT=%xKANDA=%dLOGPATH=%sLOGGING=%dQUERY=%dRESETPULS=%ldCHIPERASE=%dPOWERON=%dCLOCKSPDDEFAULT=%fLOOPCOUNT=%lgPORTACCESSTIME=%lgBYTEWRITE=%ldPAGEWRITE=%ldPROGRAMENABLE=%dwUnable to open %s for writing. %s Initialisation has failed (parallel port not found, or %s corrupt). Initialisation has failed (parallel port not responding, or %s corrupt). Running in SP12 cable/dongle compatible mode. Running in Kanda cable/dongle compatible mode. cmd 0x%lx <=word 0x%x addr 0x%x cmd 0x%lx <= addr 0x%x flashBuf[%ld] 0x%x rtnwrd 0x%x ............................................................... Writing address 0x%lx in page mode !! Writing address 0x%lx in non page mode Sp12 tried %d times to find a working device. No device connected. AT90S1200(A).A@1E2>?>>ATmega8 lock 0x%2.2x fuse 0x%2.2x 0x%2.2x cal 0x%2.2x r%lx%x%2x%4x%4lx:020000021000EC :%02X%04lX00%02X%02X :00000001FF :%02X%04X00%06lx %s %s %02x %02x %c.%02x Checksum: %04x w%06lx:%04x 76543210Address: Data in hex, dec, oct, bin %#06lx: %#04x %3d %#4o %s AT90(L)S2343 or Tiny22(L)2343/Tiny22ERROR: No memory available for buffer! a%s %s %s readback ERROR %schecksum %04x %snot queried %s%08x:%#06x %08x:%#04x verified %s%s -L%i flash %04x eeprom %04x %s............................................................... !! pL`L  0 (d d tL oȆooxK^n~Έވ.>N^n~Ήމ.>N^nGCC: (GNU) 3.2.1 20021111 (Debian prerelease)GCC: (GNU) 3.2.1 20021111 (Debian prerelease)GCC: (GNU) 2.95.4 20010810 (Debian prerelease)GCC: (GNU) 2.95.4 20010810 (Debian prerelease)GCC: (GNU) 2.95.4 20010810 (Debian prerelease)GCC: (GNU) 2.95.4 20010810 (Debian prerelease)GCC: (GNU) 2.95.4 20010810 (Debian prerelease)GCC: (GNU) 2.95.4 20010810 (Debian prerelease)GCC: (GNU) 2.95.4 20010810 (Debian prerelease)GCC: (GNU) 2.95.4 20010810 (Debian prerelease)GCC: (GNU) 3.2.1 20021111 (Debian prerelease)01.0101.0101.0101.0101.0101.0101.0101.01.symtab.strtab.shstrtab.interp.note.ABI-tag.hash.dynsym.dynstr.gnu.version.gnu.version_r.rel.got.rel.bss.rel.plt.init.plt.text.fini.rodata.data.eh_frame.dynamic.ctors.dtors.got.sbss.bss.comment.note# 1((<7 dd?GoxxPToȆ@c l u    ~00HH0 gr@@rH JKKdLdlLltLt M  M 8  -Ϳsp12mega8/dos_cpt.h100644 10243 30014 2556 7225105442 14257 0ustar jrothweihomesys/* SP12: A serial programmer for working with Atmel AT90S uCs */ /* Copyright (C) 1997-2001 Ken Huntington, Kevin Towers, Pitronics. */ /* 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 */ /* 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 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. */ /* Pitronics can be reached by email: sbolt@xs4all.nl */ /* Kevin Towers can be reached by email: ktowers@omnexcontrols.com */ /* Ken Huntington can be reached by email: kenh@compmore.net */ #include #include #define inportb(a) inb(a) #define outportb(a,b) outb(b,a) #define delay(a) usleep(a*1000) sp12mega8/README_jr.txt100664 10243 30014 3531 7605321273 14644 0ustar jrothweihomesysJoseph Rothweiler January 3, 2003 http://www.myown1.com email:joe.nospam.1@myown1.com This directory contains a hacked version of the SP12 programmer for Atmel chips. The original version was released under the GPL (see licence.txt), and is available from http://www.xs4all.nl/~sbolt/e-spider_prog.html This is a preliminary version, which has been tested for Linux and the ATmega8 only. Changes that were needed include: - The ATmega8 has an extended set of fuse bits to control read and write access to the program memory, with separate boot and application program sections. - There are many additional flag bits, which control the processor clock source and other operating modes of the chip. There are now 2 bytes of flags that need to be programmed. - The memory page is 32 instructions. Other mega chips seem to use a 128-instruction page. The hacks I made for the Atmega8 probably broke the program for other megas. - The ATmega8 requires that instructions be written low byte first, then high byte. Routine loadCodePage() in SP12 originally did it in reverse order for the mega103/603 (not sure if they require reverse order or if they don't care). In this version, the '-Xflags,mask' option is used to set the flags in the lower flag byte. Any bit that is set to 1 in 'mask' means that the corresponding flag is to be modified. 'flags' contains the flag bits to be programmed. Either value may be decimal, octal(with a leading 0), or hex (with a leading 0x). For example, to set the device to use an external 8 MHz crystal, use: sp12 -X0xf,0xf or to switch back to the internal RC oscillator, use sp12 -X1,0xf To see all of the flag, fuse, and calibration byte settings, sp12 -rF (Options to set the high flag byte and fuse values are not complete yet.) The L, S, R, D, V, K, A, U, M options have not been tested, and probably don't work.