flash/0000775000076500007650000000000010053752415011531 5ustar brdbrd00000000000000flash/Makefile0000644000076500007650000000062607366642344013207 0ustar brdbrd00000000000000all: flashpgm.hex wpflash clean: rm flashpgm.s flashpgm.asm flashpgm.hex flashpgm.lst wpflash flashpgm.hex: flashpgm.asm gpasm -r dec -p 16c74 flashpgm.asm flashpgm.s: flashpgm.c c2c -ndi -SRC -O2 -PPIC16F877 -md -oflashpgm.s flashpgm.c flashpgm.asm: flashpgm.s cp flashpgm.s flashpgm.asm wpflash: wpflash.c cc -o wpflash wpflash.c program: tm4 -c 16f877 -p /dev/ttyS0 -z 3f32 flashpgm.hex flash/flashpgm.s0000644000076500007650000007432410053751141013521 0ustar brdbrd00000000000000; This file was generated by C2C-plus compiler version 3.27.8e include "p16F877.inc" ;Variables ***************************************** _code_tmp_0000 equ 0x70 _code_tmp_0001 equ 0x71 _addrlow equ 0x72 _addrmed equ 0x73 _addrhi equ 0x74 _datalow equ 0x75 _datahi equ 0x76 _i equ 0x77 _count equ 0x78 _checksum equ 0x79 _temp equ 0x7a param00_cmd_write equ 0x7b param01_cmd_write equ 0x7c param02_cmd_write equ 0x7d param00_put_char equ 0x7e param00_put_buffer equ 0x7f param00_wait_complete equ 0x20 _buffer1 equ 0xa0 _buffer2 equ 0x110 _buffer3 equ 0x190 _buffer4 equ 0x21 _sbreg equ 0x99 _txsta equ 0x98 _rcsta equ 0x18 _txreg equ 0x19 _rcreg equ 0x1a _pir1 equ 0x0c _adcon1 equ 0x9f _pie1 equ 0x8c _strobeport equ 0x05 _strobedir equ 0x85 _datalowport equ 0x06 _datalowdir equ 0x86 _addrport equ 0x07 _addrdir equ 0x87 _datahiport equ 0x08 _datahidir equ 0x88 _controlport equ 0x09 _controldir equ 0x89 ORG 0 clrf PCLATH goto start__code _set_address goto _set_address__code _read_data goto _read_data__code _write_data goto _write_data__code _cmd_write goto _cmd_write__code _get_char goto _get_char__code _put_char goto _put_char__code _increment_address goto _increment_address__code _get_address_and_count goto _get_address_and_count__code _get_buffer goto _get_buffer__code _put_buffer goto _put_buffer__code _wait_complete goto _wait_complete__code _initialize goto _initialize__code _erase goto _erase__code _erasesector goto _erasesector__code _write goto _write__code _read goto _read__code _hello goto _hello__code start__code ;;;;;;;;char sbreg@0x99; ;;;;;;;; ;;;;;;;;char txsta@0x98; ;;;;;;;;#define TXEN 0x20 ;;;;;;;;#define BRGH 0x04 ;;;;;;;; ;;;;;;;;char rcsta@0x18; ;;;;;;;;#define SPEN 0x80 ;;;;;;;;#define CREN 0x10 ;;;;;;;; ;;;;;;;;char txreg@0x19; ;;;;;;;; ;;;;;;;;char rcreg@0x1a; ;;;;;;;; ;;;;;;;;char pir1@0x0c; ;;;;;;;;#define RCIF 0x20 ;;;;;;;;#define TXIF 0x10 ;;;;;;;; ;;;;;;;;char adcon1@0x9f; ;;;;;;;;#define ALL_DIGITAL 0x6 ;;;;;;;; ;;;;;;;;char pie1@0x8c; ;;;;;;;; ;;;;;;;;/* PORT A */ ;;;;;;;; ;;;;;;;;char strobeport@0x05; /* Only has 6 bits */ ;;;;;;;;char strobedir@0x85; ;;;;;;;;#define STROBELOW 4 ;;;;;;;;#define STROBEMED 3 ;;;;;;;;#define STROBEHI 2 ;;;;;;;; ;;;;;;;;/* PORT B */ ;;;;;;;; ;;;;;;;;char datalowport@0x06; /* Has 8 bits */ ;;;;;;;;char datalowdir@0x86; ;;;;;;;; ;;;;;;;;/* PORT C */ ;;;;;;;; ;;;;;;;;char addrport@0x07; /* has 6 bits (top 2 are UART bits) */ ;;;;;;;;char addrdir@0x87; ;;;;;;;;#define ADDRDIR 0xc0; /* Top two bits set to input (UART bits) */ ;;;;;;;; ;;;;;;;;/* Port D */ ;;;;;;;; ;;;;;;;;char datahiport@0x08; /* Bidirectional 8 bit port for data */ ;;;;;;;;char datahidir@0x88; ;;;;;;;; ;;;;;;;;/* Port E */ ;;;;;;;; ;;;;;;;;char controlport@0x09; /* Only has 3 bits */ ;;;;;;;;#define nCE_BIT 0 /* not Chip Enable */ ;;;;;;;;#define nOE_BIT 1 /* not Output Enable */ ;;;;;;;;#define nWE_BIT 2 /* not Write Enable */ ;;;;;;;;char controldir@0x89; ;;;;;;;; ;;;;;;;;#define INPUT_PORT 0xff ;;;;;;;;#define OUTPUT_PORT 0x00 ;;;;;;;; ;;;;;;;;char addrlow, addrmed, addrhi; ;;;;;;;;char datalow, datahi; ;;;;;;;; ;;;;;;;; ;;;;;;;;/* Buffer sizes are picked so that they fit ;;;;;;;; in the banks of 80 registers */ ;;;;;;;;char buffer1[80]; ;;;;;;;;char buffer2[80]; ;;;;;;;;char buffer3[80]; ;;;;;;;;char buffer4[16]; ;;;;;;;;char i; ;;;;;;;;char count; ;;;;;;;; ;;;;;;;;char checksum; ;;;;;;;;char temp; ;;;;;;;; ;;;;;;;; ;;;;;;;; ;;;;;;;;void main() { _main__code ;;;;;;;; ;;;;;;;; /* Initialize UART */ ;;;;;;;; ;;;;;;;; pie1 = 0; bsf STATUS, RP0 bcf STATUS, RP1 clrf _pie1 ;;;;;;;; txsta = TXEN | BRGH; movlw D'36' movwf _txsta ;;;;;;;; rcsta = SPEN | CREN; movlw D'144' bcf STATUS, RP0 movwf _rcsta ;;;;;;;; sbreg = 10; /* 115200 baud */ movlw D'10' bsf STATUS, RP0 movwf _sbreg ;;;;;;;; ;;;;;;;; adcon1 = ALL_DIGITAL; /* Turn off A/D convertors on PORT A */ movlw D'6' movwf _adcon1 ;;;;;;;; ;;;;;;;; datalowdir = INPUT_PORT; /* Set Ports at input/output */ movlw D'255' movwf _datalowdir ;;;;;;;; datahidir = INPUT_PORT; movlw D'255' movwf _datahidir ;;;;;;;; controldir = OUTPUT_PORT; clrf _controldir ;;;;;;;; ;;;;;;;; addrdir = ADDRDIR; /* Top two bits are UART, so input */ movlw D'192' movwf _addrdir ;;;;;;;; strobedir = OUTPUT_PORT; clrf _strobedir ;;;;;;;; ;;;;;;;; set_bit(controlport, nCE_BIT); /* Reset chip select lines */ bcf STATUS, RP0 bsf _controlport, D'0' ;;;;;;;; set_bit(controlport, nWE_BIT); bsf _controlport, D'2' ;;;;;;;; set_bit(controlport, nOE_BIT); bsf _controlport, D'1' ;;;;;;;; ;;;;;;;; addrport = 0; /* Reset address/strobe bits */ clrf _addrport ;;;;;;;; strobeport = 0; clrf _strobeport ;;;;;;;; ;;;;;;;; /* Loop executing commands */ ;;;;;;;; ;;;;;;;; while (1) { label_0038 ;;;;;;;; ;;;;;;;; switch(get_char()) { /* Get command byte */ call _get_char bcf PCLATH, 3 bcf PCLATH, 4 movwf _code_tmp_0000 ;;;;;;;; ;;;;;;;; case 'X': /* Erase flash */ movf _code_tmp_0000 , W sublw D'88' btfss STATUS, Z goto label_0041 ;;;;;;;; erase(); label_0042 call _erase bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; break; goto label_0040 ;;;;;;;; case 'S': /* Erase a sector */ label_0041 movf _code_tmp_0000 , W sublw D'83' btfss STATUS, Z goto label_0043 ;;;;;;;; erasesector(); label_0044 call _erasesector bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; break; goto label_0040 ;;;;;;;; case 'R': /* Read a block */ label_0043 movf _code_tmp_0000 , W sublw D'82' btfss STATUS, Z goto label_0045 ;;;;;;;; read(); label_0046 call _read bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; break; goto label_0040 ;;;;;;;; case 'W': /* Write a block */ label_0045 movf _code_tmp_0000 , W sublw D'87' btfss STATUS, Z goto label_0047 ;;;;;;;; write(); label_0048 call _write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; break; goto label_0040 ;;;;;;;; case 'H': /* Hello */ label_0047 movf _code_tmp_0000 , W sublw D'72' btfss STATUS, Z goto label_0049 ;;;;;;;; hello(); label_0050 call _hello bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; break; goto label_0040 ;;;;;;;; case 'I': /* Initialize flash back to read */ label_0049 movf _code_tmp_0000 , W sublw D'73' btfss STATUS, Z goto label_0051 ;;;;;;;; initialize(); label_0052 call _initialize bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; break; goto label_0040 ;;;;;;;; } label_0051 ;;;;;;;; } label_0040 ;;;;;;;;} goto label_0038 label_0039 _main__end ;;;;;;;; ;;;;;;;;/* Set the address latches from the address in [addrhi, addrmed, addrlow] */ ;;;;;;;; ;;;;;;;;void set_address() { _set_address__code ;;;;;;;; addrport = addrhi & 0x3f; movf _addrhi, W andlw D'63' bcf STATUS, RP0 bcf STATUS, RP1 movwf _addrport ;;;;;;;; strobeport = (addrhi >> 6) & 0x3; movf _addrhi, W movwf _code_tmp_0001 rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , W andlw D'3' andlw D'3' movwf _strobeport ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; set_bit(strobeport, STROBEHI); bsf _strobeport, D'2' ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; clear_bit(strobeport, STROBEHI); bcf _strobeport, D'2' ;;;;;;;; ;;;;;;;; addrport = addrmed & 0x3f; movf _addrmed, W andlw D'63' movwf _addrport ;;;;;;;; strobeport = (addrmed >> 6) & 0x3; movf _addrmed, W movwf _code_tmp_0001 rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , W andlw D'3' andlw D'3' movwf _strobeport ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; set_bit(strobeport, STROBEMED); bsf _strobeport, D'3' ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; clear_bit(strobeport, STROBEMED); bcf _strobeport, D'3' ;;;;;;;; ;;;;;;;; addrport = addrlow & 0x3f; movf _addrlow, W andlw D'63' movwf _addrport ;;;;;;;; strobeport = (addrlow >> 6) & 0x3; movf _addrlow, W movwf _code_tmp_0001 rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , W andlw D'3' andlw D'3' movwf _strobeport ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; set_bit(strobeport, STROBELOW); bsf _strobeport, D'4' ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; clear_bit(strobeport, STROBELOW); bcf _strobeport, D'4' ;;;;;;;;} return _set_address__end ;;;;;;;; ;;;;;;;;/* Read from the FLASH. Result in [datahi, datalow] */ ;;;;;;;; ;;;;;;;;void read_data() { _read_data__code ;;;;;;;; clear_bit(controlport, nCE_BIT); bcf STATUS, RP0 bcf STATUS, RP1 bcf _controlport, D'0' ;;;;;;;; clear_bit(controlport, nOE_BIT); bcf _controlport, D'1' ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; datalow = datalowport; movf _datalowport, W movwf _datalow ;;;;;;;; datahi = datahiport; movf _datahiport, W movwf _datahi ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; set_bit(controlport, nOE_BIT); bsf _controlport, D'1' ;;;;;;;; set_bit(controlport, nCE_BIT); bsf _controlport, D'0' ;;;;;;;;} return _read_data__end ;;;;;;;; ;;;;;;;;/* Write to the FLASH. Data to be stored in [datahi, datalow] */ ;;;;;;;; ;;;;;;;;void write_data() { _write_data__code ;;;;;;;; datalowdir = OUTPUT_PORT; bsf STATUS, RP0 bcf STATUS, RP1 clrf _datalowdir ;;;;;;;; datahidir = OUTPUT_PORT; clrf _datahidir ;;;;;;;; datalowport = datalow; movf _datalow, W bcf STATUS, RP0 movwf _datalowport ;;;;;;;; datahiport = datahi; movf _datahi, W movwf _datahiport ;;;;;;;; nop(); nop(); nop(); nop(); nop nop nop nop ;;;;;;;; clear_bit(controlport, nCE_BIT); bcf _controlport, D'0' ;;;;;;;; clear_bit(controlport, nWE_BIT); bcf _controlport, D'2' ;;;;;;;; nop(); nop(); nop(); nop(); nop nop nop nop ;;;;;;;; set_bit(controlport, nWE_BIT); bsf _controlport, D'2' ;;;;;;;; set_bit(controlport, nCE_BIT); bsf _controlport, D'0' ;;;;;;;; datalowdir = INPUT_PORT; movlw D'255' bsf STATUS, RP0 movwf _datalowdir ;;;;;;;; datahidir = INPUT_PORT; movlw D'255' movwf _datahidir ;;;;;;;;} return _write_data__end ;;;;;;;; ;;;;;;;;/* Write a command to a particular address */ ;;;;;;;;/* This routine doesn't clobber the [addrhi, addrmed, addrlo] registers */ ;;;;;;;; ;;;;;;;;void cmd_write(char amed, char alow, char dlow) { _cmd_write__code ;;;;;;;; addrport = 0; /* Addrhi is always zero */ bcf STATUS, RP0 bcf STATUS, RP1 clrf _addrport ;;;;;;;; strobeport = 0; clrf _strobeport ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; set_bit(strobeport, STROBEHI); bsf _strobeport, D'2' ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; clear_bit(strobeport, STROBEHI); bcf _strobeport, D'2' ;;;;;;;; ;;;;;;;; addrport = amed & 0x3f; movf param00_cmd_write, W andlw D'63' movwf _addrport ;;;;;;;; strobeport = (amed >> 6) & 0x3; movf param00_cmd_write, W movwf _code_tmp_0001 rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , W andlw D'3' andlw D'3' movwf _strobeport ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; set_bit(strobeport, STROBEMED); bsf _strobeport, D'3' ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; clear_bit(strobeport, STROBEMED); bcf _strobeport, D'3' ;;;;;;;; ;;;;;;;; addrport = alow & 0x3f; movf param01_cmd_write, W andlw D'63' movwf _addrport ;;;;;;;; strobeport = (alow >> 6) & 0x3; movf param01_cmd_write, W movwf _code_tmp_0001 rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , W andlw D'3' andlw D'3' movwf _strobeport ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; set_bit(strobeport, STROBELOW); bsf _strobeport, D'4' ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; clear_bit(strobeport, STROBELOW); bcf _strobeport, D'4' ;;;;;;;; ;;;;;;;; datahi = 0; /* Data hi is always zero */ clrf _datahi ;;;;;;;; datalow = dlow; movf param02_cmd_write, W movwf _datalow ;;;;;;;; write_data(); call _write_data bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;;} return _cmd_write__end ;;;;;;;; ;;;;;;;;/* Get a character from UART */ ;;;;;;;; ;;;;;;;;char get_char() { _get_char__code ;;;;;;;; while ((pir1 & RCIF) == 0) ; label_0000 bcf STATUS, RP0 bcf STATUS, RP1 movf _pir1, W andlw D'32' sublw D'0' btfss STATUS, Z goto label_0001 ;;;;;;;; return rcreg; goto label_0000 label_0001 bcf STATUS, RP0 bcf STATUS, RP1 movf _rcreg, W return ;;;;;;;;} _get_char__end ;;;;;;;; ;;;;;;;;/* Put a character to UART */ ;;;;;;;; ;;;;;;;;void put_char(char v) { _put_char__code ;;;;;;;; while ((pir1 & TXIF) == 0) ; label_0002 bcf STATUS, RP0 bcf STATUS, RP1 movf _pir1, W andlw D'16' sublw D'0' btfss STATUS, Z goto label_0003 ;;;;;;;; txreg = v; goto label_0002 label_0003 movf param00_put_char, W bcf STATUS, RP0 bcf STATUS, RP1 movwf _txreg ;;;;;;;;} return _put_char__end ;;;;;;;; ;;;;;;;;/* Increment [addrhi, addrmed, addrlow] as 24 bit quantity */ ;;;;;;;; ;;;;;;;;void increment_address() { _increment_address__code ;;;;;;;; if (++addrlow == 0) incf _addrlow, F movf _addrlow, W sublw D'0' btfss STATUS, Z goto label_0004 ;;;;;;;; if (++addrmed == 0) incf _addrmed, F movf _addrmed, W sublw D'0' btfss STATUS, Z goto label_0005 ;;;;;;;; ++addrhi; incf _addrhi, F ;;;;;;;;} label_0005 label_0004 return _increment_address__end ;;;;;;;; ;;;;;;;;/* Reads 4 characters into [addrhi, addrmed, addrlow] and count */ ;;;;;;;;/* Count is multiplied by two to be in bytes (0 == 256) */ ;;;;;;;; ;;;;;;;;void get_address_and_count() { _get_address_and_count__code ;;;;;;;; count = get_char(); /* Count = 1 to 128 */ call _get_char bcf PCLATH, 3 bcf PCLATH, 4 movwf _count ;;;;;;;; count = count + count; /* Double count */ clrf _code_tmp_0001 movf _count, W addwf _count, W btfsc STATUS, C incf _code_tmp_0001 , F movwf _count ;;;;;;;; ;;;;;;;; addrhi = get_char(); /* Addr from 0 -> 512K (19 bits) */ call _get_char bcf PCLATH, 3 bcf PCLATH, 4 movwf _addrhi ;;;;;;;; addrmed = get_char(); /* MSB first! */ call _get_char bcf PCLATH, 3 bcf PCLATH, 4 movwf _addrmed ;;;;;;;; addrlow = get_char(); call _get_char bcf PCLATH, 3 bcf PCLATH, 4 movwf _addrlow ;;;;;;;; ;;;;;;;;} return _get_address_and_count__end ;;;;;;;; ;;;;;;;;/* Get the next character from the buffer. */ ;;;;;;;;/* The buffer is made up of three smaller buffers so that */ ;;;;;;;;/* it fits in the PIC registers. */ ;;;;;;;; ;;;;;;;;/* The global variable 'i' contains the offset into the buffer. */ ;;;;;;;; ;;;;;;;;char get_buffer() { _get_buffer__code ;;;;;;;; if (i < 80) movlw D'80' subwf _i, W btfsc STATUS, C goto label_0006 ;;;;;;;; return buffer1[i]; movf _i, W addlw _buffer1 movwf FSR bcf STATUS, IRP movf INDF, W return ;;;;;;;; if (i < 160) label_0006 movlw D'160' subwf _i, W btfsc STATUS, C goto label_0007 ;;;;;;;; return buffer2[i-80]; movlw D'80' subwf _i, W addlw _buffer2 movwf FSR bsf STATUS, IRP movf INDF, W return ;;;;;;;; if (i < 240) label_0007 movlw D'240' subwf _i, W btfsc STATUS, C goto label_0008 ;;;;;;;; return buffer3[i-160]; movlw D'160' subwf _i, W addlw _buffer3 movwf FSR bsf STATUS, IRP movf INDF, W return ;;;;;;;; return buffer4[i-240]; label_0008 movlw D'240' subwf _i, W addlw _buffer4 movwf FSR bcf STATUS, IRP movf INDF, W return ;;;;;;;;} _get_buffer__end ;;;;;;;; ;;;;;;;;/* Put a character into the buffer. */ ;;;;;;;;/* The buffer is made up of three smaller buffers so that */ ;;;;;;;;/* it fits in the PIC registers. */ ;;;;;;;; ;;;;;;;;/* The global variable 'i' contains the offset into the buffer. */ ;;;;;;;; ;;;;;;;; ;;;;;;;;void put_buffer(char v) { _put_buffer__code ;;;;;;;; if (i < 80) { movlw D'80' subwf _i, W btfsc STATUS, C goto label_0009 ;;;;;;;; buffer1[i] = v; movf param00_put_buffer, W movwf _code_tmp_0001 movf _i, W addlw _buffer1 movwf FSR movf _code_tmp_0001 , W bcf STATUS, IRP movwf INDF ;;;;;;;; return; return ;;;;;;;; } ;;;;;;;; if (i < 160) { label_0009 movlw D'160' subwf _i, W btfsc STATUS, C goto label_0010 ;;;;;;;; buffer2[i-80] = v; movf param00_put_buffer, W movwf _code_tmp_0001 movlw D'80' subwf _i, W addlw _buffer2 movwf FSR movf _code_tmp_0001 , W bsf STATUS, IRP movwf INDF ;;;;;;;; return; return ;;;;;;;; } ;;;;;;;; if (i < 240) { label_0010 movlw D'240' subwf _i, W btfsc STATUS, C goto label_0011 ;;;;;;;; buffer3[i-160] = v; movf param00_put_buffer, W movwf _code_tmp_0001 movlw D'160' subwf _i, W addlw _buffer3 movwf FSR movf _code_tmp_0001 , W bsf STATUS, IRP movwf INDF ;;;;;;;; return; return ;;;;;;;; } ;;;;;;;; buffer4[i-240] = v; label_0011 movf param00_put_buffer, W movwf _code_tmp_0001 movlw D'240' subwf _i, W addlw _buffer4 movwf FSR movf _code_tmp_0001 , W bcf STATUS, IRP movwf INDF ;;;;;;;;} return _put_buffer__end ;;;;;;;; ;;;;;;;;/* Wait until an operation is complete */ ;;;;;;;;/* Waits until either DQ7 is equal to the bit being written ;;;;;;;; or until DQ5 is set to one indicating an error */ ;;;;;;;; ;;;;;;;;char wait_complete(char data) { _wait_complete__code ;;;;;;;; data = data & 0x80; /* Just keep lsb of data */ bcf STATUS, RP0 bcf STATUS, RP1 movf param00_wait_complete, W andlw D'128' movwf param00_wait_complete ;;;;;;;; ;;;;;;;; /* Read from chip */ ;;;;;;;; ;;;;;;;; clear_bit(controlport, nCE_BIT); bcf _controlport, D'0' ;;;;;;;; clear_bit(controlport, nOE_BIT); bcf _controlport, D'1' ;;;;;;;; ;;;;;;;; /* Wait until DQ7 == data bit 7 */ ;;;;;;;; /* Also check if DQ5 == 1 */ ;;;;;;;; ;;;;;;;; while (1) { label_0012 ;;;;;;;; datalow = datalowport; bcf STATUS, RP0 bcf STATUS, RP1 movf _datalowport, W movwf _datalow ;;;;;;;; if ((datalow & 0x80) == data) movf _datalow, W andlw D'128' subwf param00_wait_complete, W btfss STATUS, Z goto label_0014 ;;;;;;;; break; goto label_0013 label_0014 ;;;;;;;; if (datalow & 0x20) { btfss _datalow, 5 goto label_0015 ;;;;;;;; datalow = datalowport; bcf STATUS, RP0 bcf STATUS, RP1 movf _datalowport, W movwf _datalow ;;;;;;;; if ((datalow & 0x80) == data) movf _datalow, W andlw D'128' subwf param00_wait_complete, W btfss STATUS, Z goto label_0016 ;;;;;;;; break; goto label_0013 label_0016 ;;;;;;;; set_bit(controlport, nOE_BIT); bcf STATUS, RP0 bcf STATUS, RP1 bsf _controlport, D'1' ;;;;;;;; set_bit(controlport, nCE_BIT); bsf _controlport, D'0' ;;;;;;;; return 0; movlw D'0' return ;;;;;;;; } ;;;;;;;; } label_0015 ;;;;;;;; ;;;;;;;; set_bit(controlport, nOE_BIT); goto label_0012 label_0013 bcf STATUS, RP0 bcf STATUS, RP1 bsf _controlport, D'1' ;;;;;;;; set_bit(controlport, nCE_BIT); bsf _controlport, D'0' ;;;;;;;; return 1; movlw D'1' return ;;;;;;;;} _wait_complete__end ;;;;;;;; ;;;;;;;;/* Does a READ/RESET command */ ;;;;;;;; ;;;;;;;;void initialize() { _initialize__code ;;;;;;;; get_address_and_count(); call _get_address_and_count bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; ;;;;;;;; cmd_write(0x00, 0x00, 0xf0); /* 0x0000 <- 0xf0 */ movlw D'0' movwf param00_cmd_write movlw D'0' movwf param01_cmd_write movlw D'240' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; ;;;;;;;; put_char(0); movlw D'0' movwf param00_put_char call _put_char bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;;} return _initialize__end ;;;;;;;; ;;;;;;;;/* Does an ERASE command */ ;;;;;;;; ;;;;;;;;void erase() _erase__code ;;;;;;;;{ ;;;;;;;; get_address_and_count(); call _get_address_and_count bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; ;;;;;;;; cmd_write(0x05, 0x55, 0xaa); /* 0x0555 <- 0xaa */ movlw D'5' movwf param00_cmd_write movlw D'85' movwf param01_cmd_write movlw D'170' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; cmd_write(0x02, 0xaa, 0x55); /* 0x02aa <- 0x55 */ movlw D'2' movwf param00_cmd_write movlw D'170' movwf param01_cmd_write movlw D'85' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; cmd_write(0x05, 0x55, 0x80); /* 0x0555 <- 0x80 */ movlw D'5' movwf param00_cmd_write movlw D'85' movwf param01_cmd_write movlw D'128' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; cmd_write(0x05, 0x55, 0xaa); /* 0x0555 <- 0xaa */ movlw D'5' movwf param00_cmd_write movlw D'85' movwf param01_cmd_write movlw D'170' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; cmd_write(0x02, 0xaa, 0x55); /* 0x02aa <- 0x55 */ movlw D'2' movwf param00_cmd_write movlw D'170' movwf param01_cmd_write movlw D'85' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; cmd_write(0x05, 0x55, 0x10); /* 0x0555 <- 0x10 */ movlw D'5' movwf param00_cmd_write movlw D'85' movwf param01_cmd_write movlw D'16' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; ;;;;;;;; /* Wait for erase to complete */ ;;;;;;;; ;;;;;;;; if (wait_complete(0xff)) movlw D'255' bcf STATUS, RP0 bcf STATUS, RP1 movwf param00_wait_complete call _wait_complete bcf PCLATH, 3 bcf PCLATH, 4 sublw 0 btfsc STATUS, Z goto label_0017 ;;;;;;;; put_char(0); movlw D'0' movwf param00_put_char call _put_char bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; else goto label_0018 label_0017 ;;;;;;;; put_char(2); movlw D'2' movwf param00_put_char call _put_char bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;;} label_0018 return _erase__end ;;;;;;;;/* Does an ERASE SECTOR command */ ;;;;;;;; ;;;;;;;;void erasesector() _erasesector__code ;;;;;;;;{ ;;;;;;;; get_address_and_count(); call _get_address_and_count bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; ;;;;;;;; cmd_write(0x05, 0x55, 0xaa); /* 0x0555 <- 0xaa */ movlw D'5' movwf param00_cmd_write movlw D'85' movwf param01_cmd_write movlw D'170' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; cmd_write(0x02, 0xaa, 0x55); /* 0x02aa <- 0x55 */ movlw D'2' movwf param00_cmd_write movlw D'170' movwf param01_cmd_write movlw D'85' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; cmd_write(0x05, 0x55, 0x80); /* 0x0555 <- 0x80 */ movlw D'5' movwf param00_cmd_write movlw D'85' movwf param01_cmd_write movlw D'128' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; cmd_write(0x05, 0x55, 0xaa); /* 0x0555 <- 0xaa */ movlw D'5' movwf param00_cmd_write movlw D'85' movwf param01_cmd_write movlw D'170' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; cmd_write(0x02, 0xaa, 0x55); /* 0x02aa <- 0x55 */ movlw D'2' movwf param00_cmd_write movlw D'170' movwf param01_cmd_write movlw D'85' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; ;;;;;;;; set_address(); call _set_address bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; datalow = 0x30; movlw D'48' movwf _datalow ;;;;;;;; datahi = 0; clrf _datahi ;;;;;;;; write_data(); call _write_data bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; ;;;;;;;; /* Wait for erase to complete */ ;;;;;;;; ;;;;;;;; if (wait_complete(0xff)) movlw D'255' bcf STATUS, RP0 bcf STATUS, RP1 movwf param00_wait_complete call _wait_complete bcf PCLATH, 3 bcf PCLATH, 4 sublw 0 btfsc STATUS, Z goto label_0019 ;;;;;;;; put_char(0); movlw D'0' movwf param00_put_char call _put_char bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; else goto label_0020 label_0019 ;;;;;;;; put_char(2); movlw D'2' movwf param00_put_char call _put_char bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;;} label_0020 return _erasesector__end ;;;;;;;; ;;;;;;;; ;;;;;;;;/* Writes a block of data to the FLASH */ ;;;;;;;; ;;;;;;;;void write() _write__code ;;;;;;;;{ ;;;;;;;; ;;;;;;;; /* Read in address and length from serial port */ ;;;;;;;; ;;;;;;;; get_address_and_count(); call _get_address_and_count bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; ;;;;;;;; /* Read in the data from serial port into the buffers */ ;;;;;;;; ;;;;;;;; checksum = 0; clrf _checksum ;;;;;;;; i = 0; clrf _i ;;;;;;;; while (1) { label_0021 ;;;;;;;; temp = get_char(); call _get_char bcf PCLATH, 3 bcf PCLATH, 4 movwf _temp ;;;;;;;; checksum = checksum + temp; clrf _code_tmp_0001 movf _checksum, W addwf _temp, W btfsc STATUS, C incf _code_tmp_0001 , F movwf _checksum ;;;;;;;; if (checksum < temp) movf _temp, W subwf _checksum, W btfsc STATUS, C goto label_0023 ;;;;;;;; checksum++; incf _checksum, F ;;;;;;;; put_buffer(temp); label_0023 movf _temp, W movwf param00_put_buffer call _put_buffer bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; i++; incf _i, F ;;;;;;;; if (i == count) movf _i, W subwf _count, W btfss STATUS, Z goto label_0024 ;;;;;;;; break; goto label_0022 label_0024 ;;;;;;;; } ;;;;;;;; ;;;;;;;; /* Verify checksum */ ;;;;;;;; ;;;;;;;; temp = get_char(); goto label_0021 label_0022 call _get_char bcf PCLATH, 3 bcf PCLATH, 4 movwf _temp ;;;;;;;; if (checksum != temp) { movf _checksum, W subwf _temp, W btfsc STATUS, Z goto label_0025 label_0026 ;;;;;;;; put_char(1); movlw D'1' movwf param00_put_char call _put_char bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; return; return ;;;;;;;; } ;;;;;;;; ;;;;;;;; /* Write buffers out to flash */ ;;;;;;;; ;;;;;;;; i = 0; label_0025 clrf _i ;;;;;;;; while (1) { label_0027 ;;;;;;;; ;;;;;;;; cmd_write(0x05, 0x55, 0xaa); /* 0x0555 <- 0xaa */ movlw D'5' movwf param00_cmd_write movlw D'85' movwf param01_cmd_write movlw D'170' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; cmd_write(0x02, 0xaa, 0x55); /* 0x02aa <- 0x55 */ movlw D'2' movwf param00_cmd_write movlw D'170' movwf param01_cmd_write movlw D'85' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; cmd_write(0x05, 0x55, 0xa0); /* 0x0555 <- 0xa0 */ movlw D'5' movwf param00_cmd_write movlw D'85' movwf param01_cmd_write movlw D'160' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; ;;;;;;;; set_address(); call _set_address bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; datalow = get_buffer(); call _get_buffer bcf PCLATH, 3 bcf PCLATH, 4 movwf _datalow ;;;;;;;; i++; incf _i, F ;;;;;;;; datahi = get_buffer(); call _get_buffer bcf PCLATH, 3 bcf PCLATH, 4 movwf _datahi ;;;;;;;; i++; incf _i, F ;;;;;;;; write_data(); call _write_data bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; ;;;;;;;; if (wait_complete(datalow) == 0) { movf _datalow, W bcf STATUS, RP0 bcf STATUS, RP1 movwf param00_wait_complete call _wait_complete bcf PCLATH, 3 bcf PCLATH, 4 sublw D'0' btfss STATUS, Z goto label_0029 ;;;;;;;; put_char(2); movlw D'2' movwf param00_put_char call _put_char bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; return; return ;;;;;;;; } ;;;;;;;; ;;;;;;;; increment_address(); label_0029 call _increment_address bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; if (i == count) movf _i, W subwf _count, W btfss STATUS, Z goto label_0030 ;;;;;;;; break; goto label_0028 label_0030 ;;;;;;;; } ;;;;;;;; ;;;;;;;; /* Indicate success */ ;;;;;;;; ;;;;;;;; put_char(0); goto label_0027 label_0028 movlw D'0' movwf param00_put_char call _put_char bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;;} return _write__end ;;;;;;;; ;;;;;;;;/* Reads a block of data from the FLASH */ ;;;;;;;; ;;;;;;;;void read() { _read__code ;;;;;;;; ;;;;;;;; get_address_and_count(); call _get_address_and_count bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; ;;;;;;;; /* Read data from flash into buffers */ ;;;;;;;; ;;;;;;;; i = 0; clrf _i ;;;;;;;; while (1) { label_0031 ;;;;;;;; set_address(); call _set_address bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; read_data(); call _read_data bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; put_buffer(datalow); movf _datalow, W movwf param00_put_buffer call _put_buffer bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; i++; incf _i, F ;;;;;;;; put_buffer(datahi); movf _datahi, W movwf param00_put_buffer call _put_buffer bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; i++; incf _i, F ;;;;;;;; increment_address(); call _increment_address bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; if (i == count) movf _i, W subwf _count, W btfss STATUS, Z goto label_0033 ;;;;;;;; break; goto label_0032 label_0033 ;;;;;;;; } ;;;;;;;; ;;;;;;;; /* Write buffers to serial port */ ;;;;;;;; ;;;;;;;; checksum = 0; goto label_0031 label_0032 clrf _checksum ;;;;;;;; i = 0; clrf _i ;;;;;;;; while (1) { label_0034 ;;;;;;;; temp = get_buffer(); call _get_buffer bcf PCLATH, 3 bcf PCLATH, 4 movwf _temp ;;;;;;;; checksum = checksum + temp; clrf _code_tmp_0001 movf _checksum, W addwf _temp, W btfsc STATUS, C incf _code_tmp_0001 , F movwf _checksum ;;;;;;;; if (checksum < temp) movf _temp, W subwf _checksum, W btfsc STATUS, C goto label_0036 ;;;;;;;; checksum++; incf _checksum, F ;;;;;;;; put_char(temp); label_0036 movf _temp, W movwf param00_put_char call _put_char bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; i++; incf _i, F ;;;;;;;; if (i == count) movf _i, W subwf _count, W btfss STATUS, Z goto label_0037 ;;;;;;;; break; goto label_0035 label_0037 ;;;;;;;; } ;;;;;;;; ;;;;;;;; /* Write checksum to serial port */ ;;;;;;;; ;;;;;;;; put_char(checksum); goto label_0034 label_0035 movf _checksum, W movwf param00_put_char call _put_char bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;;} return _read__end ;;;;;;;; ;;;;;;;;/* Hello command to see if the programmer is alive */ ;;;;;;;; ;;;;;;;;void hello() _hello__code ;;;;;;;;{ ;;;;;;;; get_address_and_count(); call _get_address_and_count bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; put_char(0); movlw D'0' movwf param00_put_char call _put_char bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;;} return _hello__end END flash/flashpgm.asm0000644000076500007650000007432410053751141014037 0ustar brdbrd00000000000000; This file was generated by C2C-plus compiler version 3.27.8e include "p16F877.inc" ;Variables ***************************************** _code_tmp_0000 equ 0x70 _code_tmp_0001 equ 0x71 _addrlow equ 0x72 _addrmed equ 0x73 _addrhi equ 0x74 _datalow equ 0x75 _datahi equ 0x76 _i equ 0x77 _count equ 0x78 _checksum equ 0x79 _temp equ 0x7a param00_cmd_write equ 0x7b param01_cmd_write equ 0x7c param02_cmd_write equ 0x7d param00_put_char equ 0x7e param00_put_buffer equ 0x7f param00_wait_complete equ 0x20 _buffer1 equ 0xa0 _buffer2 equ 0x110 _buffer3 equ 0x190 _buffer4 equ 0x21 _sbreg equ 0x99 _txsta equ 0x98 _rcsta equ 0x18 _txreg equ 0x19 _rcreg equ 0x1a _pir1 equ 0x0c _adcon1 equ 0x9f _pie1 equ 0x8c _strobeport equ 0x05 _strobedir equ 0x85 _datalowport equ 0x06 _datalowdir equ 0x86 _addrport equ 0x07 _addrdir equ 0x87 _datahiport equ 0x08 _datahidir equ 0x88 _controlport equ 0x09 _controldir equ 0x89 ORG 0 clrf PCLATH goto start__code _set_address goto _set_address__code _read_data goto _read_data__code _write_data goto _write_data__code _cmd_write goto _cmd_write__code _get_char goto _get_char__code _put_char goto _put_char__code _increment_address goto _increment_address__code _get_address_and_count goto _get_address_and_count__code _get_buffer goto _get_buffer__code _put_buffer goto _put_buffer__code _wait_complete goto _wait_complete__code _initialize goto _initialize__code _erase goto _erase__code _erasesector goto _erasesector__code _write goto _write__code _read goto _read__code _hello goto _hello__code start__code ;;;;;;;;char sbreg@0x99; ;;;;;;;; ;;;;;;;;char txsta@0x98; ;;;;;;;;#define TXEN 0x20 ;;;;;;;;#define BRGH 0x04 ;;;;;;;; ;;;;;;;;char rcsta@0x18; ;;;;;;;;#define SPEN 0x80 ;;;;;;;;#define CREN 0x10 ;;;;;;;; ;;;;;;;;char txreg@0x19; ;;;;;;;; ;;;;;;;;char rcreg@0x1a; ;;;;;;;; ;;;;;;;;char pir1@0x0c; ;;;;;;;;#define RCIF 0x20 ;;;;;;;;#define TXIF 0x10 ;;;;;;;; ;;;;;;;;char adcon1@0x9f; ;;;;;;;;#define ALL_DIGITAL 0x6 ;;;;;;;; ;;;;;;;;char pie1@0x8c; ;;;;;;;; ;;;;;;;;/* PORT A */ ;;;;;;;; ;;;;;;;;char strobeport@0x05; /* Only has 6 bits */ ;;;;;;;;char strobedir@0x85; ;;;;;;;;#define STROBELOW 4 ;;;;;;;;#define STROBEMED 3 ;;;;;;;;#define STROBEHI 2 ;;;;;;;; ;;;;;;;;/* PORT B */ ;;;;;;;; ;;;;;;;;char datalowport@0x06; /* Has 8 bits */ ;;;;;;;;char datalowdir@0x86; ;;;;;;;; ;;;;;;;;/* PORT C */ ;;;;;;;; ;;;;;;;;char addrport@0x07; /* has 6 bits (top 2 are UART bits) */ ;;;;;;;;char addrdir@0x87; ;;;;;;;;#define ADDRDIR 0xc0; /* Top two bits set to input (UART bits) */ ;;;;;;;; ;;;;;;;;/* Port D */ ;;;;;;;; ;;;;;;;;char datahiport@0x08; /* Bidirectional 8 bit port for data */ ;;;;;;;;char datahidir@0x88; ;;;;;;;; ;;;;;;;;/* Port E */ ;;;;;;;; ;;;;;;;;char controlport@0x09; /* Only has 3 bits */ ;;;;;;;;#define nCE_BIT 0 /* not Chip Enable */ ;;;;;;;;#define nOE_BIT 1 /* not Output Enable */ ;;;;;;;;#define nWE_BIT 2 /* not Write Enable */ ;;;;;;;;char controldir@0x89; ;;;;;;;; ;;;;;;;;#define INPUT_PORT 0xff ;;;;;;;;#define OUTPUT_PORT 0x00 ;;;;;;;; ;;;;;;;;char addrlow, addrmed, addrhi; ;;;;;;;;char datalow, datahi; ;;;;;;;; ;;;;;;;; ;;;;;;;;/* Buffer sizes are picked so that they fit ;;;;;;;; in the banks of 80 registers */ ;;;;;;;;char buffer1[80]; ;;;;;;;;char buffer2[80]; ;;;;;;;;char buffer3[80]; ;;;;;;;;char buffer4[16]; ;;;;;;;;char i; ;;;;;;;;char count; ;;;;;;;; ;;;;;;;;char checksum; ;;;;;;;;char temp; ;;;;;;;; ;;;;;;;; ;;;;;;;; ;;;;;;;;void main() { _main__code ;;;;;;;; ;;;;;;;; /* Initialize UART */ ;;;;;;;; ;;;;;;;; pie1 = 0; bsf STATUS, RP0 bcf STATUS, RP1 clrf _pie1 ;;;;;;;; txsta = TXEN | BRGH; movlw D'36' movwf _txsta ;;;;;;;; rcsta = SPEN | CREN; movlw D'144' bcf STATUS, RP0 movwf _rcsta ;;;;;;;; sbreg = 10; /* 115200 baud */ movlw D'10' bsf STATUS, RP0 movwf _sbreg ;;;;;;;; ;;;;;;;; adcon1 = ALL_DIGITAL; /* Turn off A/D convertors on PORT A */ movlw D'6' movwf _adcon1 ;;;;;;;; ;;;;;;;; datalowdir = INPUT_PORT; /* Set Ports at input/output */ movlw D'255' movwf _datalowdir ;;;;;;;; datahidir = INPUT_PORT; movlw D'255' movwf _datahidir ;;;;;;;; controldir = OUTPUT_PORT; clrf _controldir ;;;;;;;; ;;;;;;;; addrdir = ADDRDIR; /* Top two bits are UART, so input */ movlw D'192' movwf _addrdir ;;;;;;;; strobedir = OUTPUT_PORT; clrf _strobedir ;;;;;;;; ;;;;;;;; set_bit(controlport, nCE_BIT); /* Reset chip select lines */ bcf STATUS, RP0 bsf _controlport, D'0' ;;;;;;;; set_bit(controlport, nWE_BIT); bsf _controlport, D'2' ;;;;;;;; set_bit(controlport, nOE_BIT); bsf _controlport, D'1' ;;;;;;;; ;;;;;;;; addrport = 0; /* Reset address/strobe bits */ clrf _addrport ;;;;;;;; strobeport = 0; clrf _strobeport ;;;;;;;; ;;;;;;;; /* Loop executing commands */ ;;;;;;;; ;;;;;;;; while (1) { label_0038 ;;;;;;;; ;;;;;;;; switch(get_char()) { /* Get command byte */ call _get_char bcf PCLATH, 3 bcf PCLATH, 4 movwf _code_tmp_0000 ;;;;;;;; ;;;;;;;; case 'X': /* Erase flash */ movf _code_tmp_0000 , W sublw D'88' btfss STATUS, Z goto label_0041 ;;;;;;;; erase(); label_0042 call _erase bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; break; goto label_0040 ;;;;;;;; case 'S': /* Erase a sector */ label_0041 movf _code_tmp_0000 , W sublw D'83' btfss STATUS, Z goto label_0043 ;;;;;;;; erasesector(); label_0044 call _erasesector bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; break; goto label_0040 ;;;;;;;; case 'R': /* Read a block */ label_0043 movf _code_tmp_0000 , W sublw D'82' btfss STATUS, Z goto label_0045 ;;;;;;;; read(); label_0046 call _read bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; break; goto label_0040 ;;;;;;;; case 'W': /* Write a block */ label_0045 movf _code_tmp_0000 , W sublw D'87' btfss STATUS, Z goto label_0047 ;;;;;;;; write(); label_0048 call _write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; break; goto label_0040 ;;;;;;;; case 'H': /* Hello */ label_0047 movf _code_tmp_0000 , W sublw D'72' btfss STATUS, Z goto label_0049 ;;;;;;;; hello(); label_0050 call _hello bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; break; goto label_0040 ;;;;;;;; case 'I': /* Initialize flash back to read */ label_0049 movf _code_tmp_0000 , W sublw D'73' btfss STATUS, Z goto label_0051 ;;;;;;;; initialize(); label_0052 call _initialize bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; break; goto label_0040 ;;;;;;;; } label_0051 ;;;;;;;; } label_0040 ;;;;;;;;} goto label_0038 label_0039 _main__end ;;;;;;;; ;;;;;;;;/* Set the address latches from the address in [addrhi, addrmed, addrlow] */ ;;;;;;;; ;;;;;;;;void set_address() { _set_address__code ;;;;;;;; addrport = addrhi & 0x3f; movf _addrhi, W andlw D'63' bcf STATUS, RP0 bcf STATUS, RP1 movwf _addrport ;;;;;;;; strobeport = (addrhi >> 6) & 0x3; movf _addrhi, W movwf _code_tmp_0001 rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , W andlw D'3' andlw D'3' movwf _strobeport ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; set_bit(strobeport, STROBEHI); bsf _strobeport, D'2' ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; clear_bit(strobeport, STROBEHI); bcf _strobeport, D'2' ;;;;;;;; ;;;;;;;; addrport = addrmed & 0x3f; movf _addrmed, W andlw D'63' movwf _addrport ;;;;;;;; strobeport = (addrmed >> 6) & 0x3; movf _addrmed, W movwf _code_tmp_0001 rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , W andlw D'3' andlw D'3' movwf _strobeport ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; set_bit(strobeport, STROBEMED); bsf _strobeport, D'3' ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; clear_bit(strobeport, STROBEMED); bcf _strobeport, D'3' ;;;;;;;; ;;;;;;;; addrport = addrlow & 0x3f; movf _addrlow, W andlw D'63' movwf _addrport ;;;;;;;; strobeport = (addrlow >> 6) & 0x3; movf _addrlow, W movwf _code_tmp_0001 rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , W andlw D'3' andlw D'3' movwf _strobeport ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; set_bit(strobeport, STROBELOW); bsf _strobeport, D'4' ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; clear_bit(strobeport, STROBELOW); bcf _strobeport, D'4' ;;;;;;;;} return _set_address__end ;;;;;;;; ;;;;;;;;/* Read from the FLASH. Result in [datahi, datalow] */ ;;;;;;;; ;;;;;;;;void read_data() { _read_data__code ;;;;;;;; clear_bit(controlport, nCE_BIT); bcf STATUS, RP0 bcf STATUS, RP1 bcf _controlport, D'0' ;;;;;;;; clear_bit(controlport, nOE_BIT); bcf _controlport, D'1' ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; datalow = datalowport; movf _datalowport, W movwf _datalow ;;;;;;;; datahi = datahiport; movf _datahiport, W movwf _datahi ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; set_bit(controlport, nOE_BIT); bsf _controlport, D'1' ;;;;;;;; set_bit(controlport, nCE_BIT); bsf _controlport, D'0' ;;;;;;;;} return _read_data__end ;;;;;;;; ;;;;;;;;/* Write to the FLASH. Data to be stored in [datahi, datalow] */ ;;;;;;;; ;;;;;;;;void write_data() { _write_data__code ;;;;;;;; datalowdir = OUTPUT_PORT; bsf STATUS, RP0 bcf STATUS, RP1 clrf _datalowdir ;;;;;;;; datahidir = OUTPUT_PORT; clrf _datahidir ;;;;;;;; datalowport = datalow; movf _datalow, W bcf STATUS, RP0 movwf _datalowport ;;;;;;;; datahiport = datahi; movf _datahi, W movwf _datahiport ;;;;;;;; nop(); nop(); nop(); nop(); nop nop nop nop ;;;;;;;; clear_bit(controlport, nCE_BIT); bcf _controlport, D'0' ;;;;;;;; clear_bit(controlport, nWE_BIT); bcf _controlport, D'2' ;;;;;;;; nop(); nop(); nop(); nop(); nop nop nop nop ;;;;;;;; set_bit(controlport, nWE_BIT); bsf _controlport, D'2' ;;;;;;;; set_bit(controlport, nCE_BIT); bsf _controlport, D'0' ;;;;;;;; datalowdir = INPUT_PORT; movlw D'255' bsf STATUS, RP0 movwf _datalowdir ;;;;;;;; datahidir = INPUT_PORT; movlw D'255' movwf _datahidir ;;;;;;;;} return _write_data__end ;;;;;;;; ;;;;;;;;/* Write a command to a particular address */ ;;;;;;;;/* This routine doesn't clobber the [addrhi, addrmed, addrlo] registers */ ;;;;;;;; ;;;;;;;;void cmd_write(char amed, char alow, char dlow) { _cmd_write__code ;;;;;;;; addrport = 0; /* Addrhi is always zero */ bcf STATUS, RP0 bcf STATUS, RP1 clrf _addrport ;;;;;;;; strobeport = 0; clrf _strobeport ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; set_bit(strobeport, STROBEHI); bsf _strobeport, D'2' ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; clear_bit(strobeport, STROBEHI); bcf _strobeport, D'2' ;;;;;;;; ;;;;;;;; addrport = amed & 0x3f; movf param00_cmd_write, W andlw D'63' movwf _addrport ;;;;;;;; strobeport = (amed >> 6) & 0x3; movf param00_cmd_write, W movwf _code_tmp_0001 rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , W andlw D'3' andlw D'3' movwf _strobeport ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; set_bit(strobeport, STROBEMED); bsf _strobeport, D'3' ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; clear_bit(strobeport, STROBEMED); bcf _strobeport, D'3' ;;;;;;;; ;;;;;;;; addrport = alow & 0x3f; movf param01_cmd_write, W andlw D'63' movwf _addrport ;;;;;;;; strobeport = (alow >> 6) & 0x3; movf param01_cmd_write, W movwf _code_tmp_0001 rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , F rrf _code_tmp_0001 , W andlw D'3' andlw D'3' movwf _strobeport ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; set_bit(strobeport, STROBELOW); bsf _strobeport, D'4' ;;;;;;;; nop(); nop(); nop(); nop nop nop ;;;;;;;; clear_bit(strobeport, STROBELOW); bcf _strobeport, D'4' ;;;;;;;; ;;;;;;;; datahi = 0; /* Data hi is always zero */ clrf _datahi ;;;;;;;; datalow = dlow; movf param02_cmd_write, W movwf _datalow ;;;;;;;; write_data(); call _write_data bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;;} return _cmd_write__end ;;;;;;;; ;;;;;;;;/* Get a character from UART */ ;;;;;;;; ;;;;;;;;char get_char() { _get_char__code ;;;;;;;; while ((pir1 & RCIF) == 0) ; label_0000 bcf STATUS, RP0 bcf STATUS, RP1 movf _pir1, W andlw D'32' sublw D'0' btfss STATUS, Z goto label_0001 ;;;;;;;; return rcreg; goto label_0000 label_0001 bcf STATUS, RP0 bcf STATUS, RP1 movf _rcreg, W return ;;;;;;;;} _get_char__end ;;;;;;;; ;;;;;;;;/* Put a character to UART */ ;;;;;;;; ;;;;;;;;void put_char(char v) { _put_char__code ;;;;;;;; while ((pir1 & TXIF) == 0) ; label_0002 bcf STATUS, RP0 bcf STATUS, RP1 movf _pir1, W andlw D'16' sublw D'0' btfss STATUS, Z goto label_0003 ;;;;;;;; txreg = v; goto label_0002 label_0003 movf param00_put_char, W bcf STATUS, RP0 bcf STATUS, RP1 movwf _txreg ;;;;;;;;} return _put_char__end ;;;;;;;; ;;;;;;;;/* Increment [addrhi, addrmed, addrlow] as 24 bit quantity */ ;;;;;;;; ;;;;;;;;void increment_address() { _increment_address__code ;;;;;;;; if (++addrlow == 0) incf _addrlow, F movf _addrlow, W sublw D'0' btfss STATUS, Z goto label_0004 ;;;;;;;; if (++addrmed == 0) incf _addrmed, F movf _addrmed, W sublw D'0' btfss STATUS, Z goto label_0005 ;;;;;;;; ++addrhi; incf _addrhi, F ;;;;;;;;} label_0005 label_0004 return _increment_address__end ;;;;;;;; ;;;;;;;;/* Reads 4 characters into [addrhi, addrmed, addrlow] and count */ ;;;;;;;;/* Count is multiplied by two to be in bytes (0 == 256) */ ;;;;;;;; ;;;;;;;;void get_address_and_count() { _get_address_and_count__code ;;;;;;;; count = get_char(); /* Count = 1 to 128 */ call _get_char bcf PCLATH, 3 bcf PCLATH, 4 movwf _count ;;;;;;;; count = count + count; /* Double count */ clrf _code_tmp_0001 movf _count, W addwf _count, W btfsc STATUS, C incf _code_tmp_0001 , F movwf _count ;;;;;;;; ;;;;;;;; addrhi = get_char(); /* Addr from 0 -> 512K (19 bits) */ call _get_char bcf PCLATH, 3 bcf PCLATH, 4 movwf _addrhi ;;;;;;;; addrmed = get_char(); /* MSB first! */ call _get_char bcf PCLATH, 3 bcf PCLATH, 4 movwf _addrmed ;;;;;;;; addrlow = get_char(); call _get_char bcf PCLATH, 3 bcf PCLATH, 4 movwf _addrlow ;;;;;;;; ;;;;;;;;} return _get_address_and_count__end ;;;;;;;; ;;;;;;;;/* Get the next character from the buffer. */ ;;;;;;;;/* The buffer is made up of three smaller buffers so that */ ;;;;;;;;/* it fits in the PIC registers. */ ;;;;;;;; ;;;;;;;;/* The global variable 'i' contains the offset into the buffer. */ ;;;;;;;; ;;;;;;;;char get_buffer() { _get_buffer__code ;;;;;;;; if (i < 80) movlw D'80' subwf _i, W btfsc STATUS, C goto label_0006 ;;;;;;;; return buffer1[i]; movf _i, W addlw _buffer1 movwf FSR bcf STATUS, IRP movf INDF, W return ;;;;;;;; if (i < 160) label_0006 movlw D'160' subwf _i, W btfsc STATUS, C goto label_0007 ;;;;;;;; return buffer2[i-80]; movlw D'80' subwf _i, W addlw _buffer2 movwf FSR bsf STATUS, IRP movf INDF, W return ;;;;;;;; if (i < 240) label_0007 movlw D'240' subwf _i, W btfsc STATUS, C goto label_0008 ;;;;;;;; return buffer3[i-160]; movlw D'160' subwf _i, W addlw _buffer3 movwf FSR bsf STATUS, IRP movf INDF, W return ;;;;;;;; return buffer4[i-240]; label_0008 movlw D'240' subwf _i, W addlw _buffer4 movwf FSR bcf STATUS, IRP movf INDF, W return ;;;;;;;;} _get_buffer__end ;;;;;;;; ;;;;;;;;/* Put a character into the buffer. */ ;;;;;;;;/* The buffer is made up of three smaller buffers so that */ ;;;;;;;;/* it fits in the PIC registers. */ ;;;;;;;; ;;;;;;;;/* The global variable 'i' contains the offset into the buffer. */ ;;;;;;;; ;;;;;;;; ;;;;;;;;void put_buffer(char v) { _put_buffer__code ;;;;;;;; if (i < 80) { movlw D'80' subwf _i, W btfsc STATUS, C goto label_0009 ;;;;;;;; buffer1[i] = v; movf param00_put_buffer, W movwf _code_tmp_0001 movf _i, W addlw _buffer1 movwf FSR movf _code_tmp_0001 , W bcf STATUS, IRP movwf INDF ;;;;;;;; return; return ;;;;;;;; } ;;;;;;;; if (i < 160) { label_0009 movlw D'160' subwf _i, W btfsc STATUS, C goto label_0010 ;;;;;;;; buffer2[i-80] = v; movf param00_put_buffer, W movwf _code_tmp_0001 movlw D'80' subwf _i, W addlw _buffer2 movwf FSR movf _code_tmp_0001 , W bsf STATUS, IRP movwf INDF ;;;;;;;; return; return ;;;;;;;; } ;;;;;;;; if (i < 240) { label_0010 movlw D'240' subwf _i, W btfsc STATUS, C goto label_0011 ;;;;;;;; buffer3[i-160] = v; movf param00_put_buffer, W movwf _code_tmp_0001 movlw D'160' subwf _i, W addlw _buffer3 movwf FSR movf _code_tmp_0001 , W bsf STATUS, IRP movwf INDF ;;;;;;;; return; return ;;;;;;;; } ;;;;;;;; buffer4[i-240] = v; label_0011 movf param00_put_buffer, W movwf _code_tmp_0001 movlw D'240' subwf _i, W addlw _buffer4 movwf FSR movf _code_tmp_0001 , W bcf STATUS, IRP movwf INDF ;;;;;;;;} return _put_buffer__end ;;;;;;;; ;;;;;;;;/* Wait until an operation is complete */ ;;;;;;;;/* Waits until either DQ7 is equal to the bit being written ;;;;;;;; or until DQ5 is set to one indicating an error */ ;;;;;;;; ;;;;;;;;char wait_complete(char data) { _wait_complete__code ;;;;;;;; data = data & 0x80; /* Just keep lsb of data */ bcf STATUS, RP0 bcf STATUS, RP1 movf param00_wait_complete, W andlw D'128' movwf param00_wait_complete ;;;;;;;; ;;;;;;;; /* Read from chip */ ;;;;;;;; ;;;;;;;; clear_bit(controlport, nCE_BIT); bcf _controlport, D'0' ;;;;;;;; clear_bit(controlport, nOE_BIT); bcf _controlport, D'1' ;;;;;;;; ;;;;;;;; /* Wait until DQ7 == data bit 7 */ ;;;;;;;; /* Also check if DQ5 == 1 */ ;;;;;;;; ;;;;;;;; while (1) { label_0012 ;;;;;;;; datalow = datalowport; bcf STATUS, RP0 bcf STATUS, RP1 movf _datalowport, W movwf _datalow ;;;;;;;; if ((datalow & 0x80) == data) movf _datalow, W andlw D'128' subwf param00_wait_complete, W btfss STATUS, Z goto label_0014 ;;;;;;;; break; goto label_0013 label_0014 ;;;;;;;; if (datalow & 0x20) { btfss _datalow, 5 goto label_0015 ;;;;;;;; datalow = datalowport; bcf STATUS, RP0 bcf STATUS, RP1 movf _datalowport, W movwf _datalow ;;;;;;;; if ((datalow & 0x80) == data) movf _datalow, W andlw D'128' subwf param00_wait_complete, W btfss STATUS, Z goto label_0016 ;;;;;;;; break; goto label_0013 label_0016 ;;;;;;;; set_bit(controlport, nOE_BIT); bcf STATUS, RP0 bcf STATUS, RP1 bsf _controlport, D'1' ;;;;;;;; set_bit(controlport, nCE_BIT); bsf _controlport, D'0' ;;;;;;;; return 0; movlw D'0' return ;;;;;;;; } ;;;;;;;; } label_0015 ;;;;;;;; ;;;;;;;; set_bit(controlport, nOE_BIT); goto label_0012 label_0013 bcf STATUS, RP0 bcf STATUS, RP1 bsf _controlport, D'1' ;;;;;;;; set_bit(controlport, nCE_BIT); bsf _controlport, D'0' ;;;;;;;; return 1; movlw D'1' return ;;;;;;;;} _wait_complete__end ;;;;;;;; ;;;;;;;;/* Does a READ/RESET command */ ;;;;;;;; ;;;;;;;;void initialize() { _initialize__code ;;;;;;;; get_address_and_count(); call _get_address_and_count bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; ;;;;;;;; cmd_write(0x00, 0x00, 0xf0); /* 0x0000 <- 0xf0 */ movlw D'0' movwf param00_cmd_write movlw D'0' movwf param01_cmd_write movlw D'240' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; ;;;;;;;; put_char(0); movlw D'0' movwf param00_put_char call _put_char bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;;} return _initialize__end ;;;;;;;; ;;;;;;;;/* Does an ERASE command */ ;;;;;;;; ;;;;;;;;void erase() _erase__code ;;;;;;;;{ ;;;;;;;; get_address_and_count(); call _get_address_and_count bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; ;;;;;;;; cmd_write(0x05, 0x55, 0xaa); /* 0x0555 <- 0xaa */ movlw D'5' movwf param00_cmd_write movlw D'85' movwf param01_cmd_write movlw D'170' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; cmd_write(0x02, 0xaa, 0x55); /* 0x02aa <- 0x55 */ movlw D'2' movwf param00_cmd_write movlw D'170' movwf param01_cmd_write movlw D'85' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; cmd_write(0x05, 0x55, 0x80); /* 0x0555 <- 0x80 */ movlw D'5' movwf param00_cmd_write movlw D'85' movwf param01_cmd_write movlw D'128' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; cmd_write(0x05, 0x55, 0xaa); /* 0x0555 <- 0xaa */ movlw D'5' movwf param00_cmd_write movlw D'85' movwf param01_cmd_write movlw D'170' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; cmd_write(0x02, 0xaa, 0x55); /* 0x02aa <- 0x55 */ movlw D'2' movwf param00_cmd_write movlw D'170' movwf param01_cmd_write movlw D'85' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; cmd_write(0x05, 0x55, 0x10); /* 0x0555 <- 0x10 */ movlw D'5' movwf param00_cmd_write movlw D'85' movwf param01_cmd_write movlw D'16' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; ;;;;;;;; /* Wait for erase to complete */ ;;;;;;;; ;;;;;;;; if (wait_complete(0xff)) movlw D'255' bcf STATUS, RP0 bcf STATUS, RP1 movwf param00_wait_complete call _wait_complete bcf PCLATH, 3 bcf PCLATH, 4 sublw 0 btfsc STATUS, Z goto label_0017 ;;;;;;;; put_char(0); movlw D'0' movwf param00_put_char call _put_char bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; else goto label_0018 label_0017 ;;;;;;;; put_char(2); movlw D'2' movwf param00_put_char call _put_char bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;;} label_0018 return _erase__end ;;;;;;;;/* Does an ERASE SECTOR command */ ;;;;;;;; ;;;;;;;;void erasesector() _erasesector__code ;;;;;;;;{ ;;;;;;;; get_address_and_count(); call _get_address_and_count bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; ;;;;;;;; cmd_write(0x05, 0x55, 0xaa); /* 0x0555 <- 0xaa */ movlw D'5' movwf param00_cmd_write movlw D'85' movwf param01_cmd_write movlw D'170' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; cmd_write(0x02, 0xaa, 0x55); /* 0x02aa <- 0x55 */ movlw D'2' movwf param00_cmd_write movlw D'170' movwf param01_cmd_write movlw D'85' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; cmd_write(0x05, 0x55, 0x80); /* 0x0555 <- 0x80 */ movlw D'5' movwf param00_cmd_write movlw D'85' movwf param01_cmd_write movlw D'128' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; cmd_write(0x05, 0x55, 0xaa); /* 0x0555 <- 0xaa */ movlw D'5' movwf param00_cmd_write movlw D'85' movwf param01_cmd_write movlw D'170' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; cmd_write(0x02, 0xaa, 0x55); /* 0x02aa <- 0x55 */ movlw D'2' movwf param00_cmd_write movlw D'170' movwf param01_cmd_write movlw D'85' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; ;;;;;;;; set_address(); call _set_address bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; datalow = 0x30; movlw D'48' movwf _datalow ;;;;;;;; datahi = 0; clrf _datahi ;;;;;;;; write_data(); call _write_data bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; ;;;;;;;; /* Wait for erase to complete */ ;;;;;;;; ;;;;;;;; if (wait_complete(0xff)) movlw D'255' bcf STATUS, RP0 bcf STATUS, RP1 movwf param00_wait_complete call _wait_complete bcf PCLATH, 3 bcf PCLATH, 4 sublw 0 btfsc STATUS, Z goto label_0019 ;;;;;;;; put_char(0); movlw D'0' movwf param00_put_char call _put_char bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; else goto label_0020 label_0019 ;;;;;;;; put_char(2); movlw D'2' movwf param00_put_char call _put_char bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;;} label_0020 return _erasesector__end ;;;;;;;; ;;;;;;;; ;;;;;;;;/* Writes a block of data to the FLASH */ ;;;;;;;; ;;;;;;;;void write() _write__code ;;;;;;;;{ ;;;;;;;; ;;;;;;;; /* Read in address and length from serial port */ ;;;;;;;; ;;;;;;;; get_address_and_count(); call _get_address_and_count bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; ;;;;;;;; /* Read in the data from serial port into the buffers */ ;;;;;;;; ;;;;;;;; checksum = 0; clrf _checksum ;;;;;;;; i = 0; clrf _i ;;;;;;;; while (1) { label_0021 ;;;;;;;; temp = get_char(); call _get_char bcf PCLATH, 3 bcf PCLATH, 4 movwf _temp ;;;;;;;; checksum = checksum + temp; clrf _code_tmp_0001 movf _checksum, W addwf _temp, W btfsc STATUS, C incf _code_tmp_0001 , F movwf _checksum ;;;;;;;; if (checksum < temp) movf _temp, W subwf _checksum, W btfsc STATUS, C goto label_0023 ;;;;;;;; checksum++; incf _checksum, F ;;;;;;;; put_buffer(temp); label_0023 movf _temp, W movwf param00_put_buffer call _put_buffer bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; i++; incf _i, F ;;;;;;;; if (i == count) movf _i, W subwf _count, W btfss STATUS, Z goto label_0024 ;;;;;;;; break; goto label_0022 label_0024 ;;;;;;;; } ;;;;;;;; ;;;;;;;; /* Verify checksum */ ;;;;;;;; ;;;;;;;; temp = get_char(); goto label_0021 label_0022 call _get_char bcf PCLATH, 3 bcf PCLATH, 4 movwf _temp ;;;;;;;; if (checksum != temp) { movf _checksum, W subwf _temp, W btfsc STATUS, Z goto label_0025 label_0026 ;;;;;;;; put_char(1); movlw D'1' movwf param00_put_char call _put_char bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; return; return ;;;;;;;; } ;;;;;;;; ;;;;;;;; /* Write buffers out to flash */ ;;;;;;;; ;;;;;;;; i = 0; label_0025 clrf _i ;;;;;;;; while (1) { label_0027 ;;;;;;;; ;;;;;;;; cmd_write(0x05, 0x55, 0xaa); /* 0x0555 <- 0xaa */ movlw D'5' movwf param00_cmd_write movlw D'85' movwf param01_cmd_write movlw D'170' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; cmd_write(0x02, 0xaa, 0x55); /* 0x02aa <- 0x55 */ movlw D'2' movwf param00_cmd_write movlw D'170' movwf param01_cmd_write movlw D'85' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; cmd_write(0x05, 0x55, 0xa0); /* 0x0555 <- 0xa0 */ movlw D'5' movwf param00_cmd_write movlw D'85' movwf param01_cmd_write movlw D'160' movwf param02_cmd_write call _cmd_write bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; ;;;;;;;; set_address(); call _set_address bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; datalow = get_buffer(); call _get_buffer bcf PCLATH, 3 bcf PCLATH, 4 movwf _datalow ;;;;;;;; i++; incf _i, F ;;;;;;;; datahi = get_buffer(); call _get_buffer bcf PCLATH, 3 bcf PCLATH, 4 movwf _datahi ;;;;;;;; i++; incf _i, F ;;;;;;;; write_data(); call _write_data bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; ;;;;;;;; if (wait_complete(datalow) == 0) { movf _datalow, W bcf STATUS, RP0 bcf STATUS, RP1 movwf param00_wait_complete call _wait_complete bcf PCLATH, 3 bcf PCLATH, 4 sublw D'0' btfss STATUS, Z goto label_0029 ;;;;;;;; put_char(2); movlw D'2' movwf param00_put_char call _put_char bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; return; return ;;;;;;;; } ;;;;;;;; ;;;;;;;; increment_address(); label_0029 call _increment_address bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; if (i == count) movf _i, W subwf _count, W btfss STATUS, Z goto label_0030 ;;;;;;;; break; goto label_0028 label_0030 ;;;;;;;; } ;;;;;;;; ;;;;;;;; /* Indicate success */ ;;;;;;;; ;;;;;;;; put_char(0); goto label_0027 label_0028 movlw D'0' movwf param00_put_char call _put_char bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;;} return _write__end ;;;;;;;; ;;;;;;;;/* Reads a block of data from the FLASH */ ;;;;;;;; ;;;;;;;;void read() { _read__code ;;;;;;;; ;;;;;;;; get_address_and_count(); call _get_address_and_count bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; ;;;;;;;; /* Read data from flash into buffers */ ;;;;;;;; ;;;;;;;; i = 0; clrf _i ;;;;;;;; while (1) { label_0031 ;;;;;;;; set_address(); call _set_address bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; read_data(); call _read_data bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; put_buffer(datalow); movf _datalow, W movwf param00_put_buffer call _put_buffer bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; i++; incf _i, F ;;;;;;;; put_buffer(datahi); movf _datahi, W movwf param00_put_buffer call _put_buffer bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; i++; incf _i, F ;;;;;;;; increment_address(); call _increment_address bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; if (i == count) movf _i, W subwf _count, W btfss STATUS, Z goto label_0033 ;;;;;;;; break; goto label_0032 label_0033 ;;;;;;;; } ;;;;;;;; ;;;;;;;; /* Write buffers to serial port */ ;;;;;;;; ;;;;;;;; checksum = 0; goto label_0031 label_0032 clrf _checksum ;;;;;;;; i = 0; clrf _i ;;;;;;;; while (1) { label_0034 ;;;;;;;; temp = get_buffer(); call _get_buffer bcf PCLATH, 3 bcf PCLATH, 4 movwf _temp ;;;;;;;; checksum = checksum + temp; clrf _code_tmp_0001 movf _checksum, W addwf _temp, W btfsc STATUS, C incf _code_tmp_0001 , F movwf _checksum ;;;;;;;; if (checksum < temp) movf _temp, W subwf _checksum, W btfsc STATUS, C goto label_0036 ;;;;;;;; checksum++; incf _checksum, F ;;;;;;;; put_char(temp); label_0036 movf _temp, W movwf param00_put_char call _put_char bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; i++; incf _i, F ;;;;;;;; if (i == count) movf _i, W subwf _count, W btfss STATUS, Z goto label_0037 ;;;;;;;; break; goto label_0035 label_0037 ;;;;;;;; } ;;;;;;;; ;;;;;;;; /* Write checksum to serial port */ ;;;;;;;; ;;;;;;;; put_char(checksum); goto label_0034 label_0035 movf _checksum, W movwf param00_put_char call _put_char bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;;} return _read__end ;;;;;;;; ;;;;;;;;/* Hello command to see if the programmer is alive */ ;;;;;;;; ;;;;;;;;void hello() _hello__code ;;;;;;;;{ ;;;;;;;; get_address_and_count(); call _get_address_and_count bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;; put_char(0); movlw D'0' movwf param00_put_char call _put_char bcf PCLATH, 3 bcf PCLATH, 4 ;;;;;;;;} return _hello__end END flash/wpflash0000755000076500007650000006521010053752415013125 0ustar brdbrd00000000000000ELF‡4”Q4 (!44€4€àà€€Ì5Ì5à5àÅàÅÈ € 8 È ÈÈÈ((( Qåtd/lib/ld-linux.so.2GNU    z†|\,†Dd<†q%L†È9\†2l†þ¬|†”VŒ†äÊjÊœ†7,¬†MG¼†öšÌ†æ:܆-cì†u†ü†|€ ‡ÈO‡(,‡<AÊ…<‡&‹dªyL‡8W\‡|ql‡#¶ |‡‹libc.so.6strcpyioctlstdoutfgetsperrorsleepfflushfprintfstdinstrncmpsscanffreadstrcmpfclosestderrmkstempfwriteexitfopen_IO_stdin_used__libc_start_maintcsetattr__gmon_start__GLIBC_2.1GLIBC_2.0ii Åii ÏäÉÊ Ê ÊˆÉŒÉÉ”É˜ÉœÉ É¤É¨É ¬É °É ´É¸É¼ÉÀÉÄÉÈÉÌÉÐÉÔÉØÉÜÉàÉU‰åƒìèµèè$ÉÃÿ5€Éÿ%„Éÿ%ˆÉhéàÿÿÿÿ%ŒÉhéÐÿÿÿÿ%ÉhéÀÿÿÿÿ%”Éhé°ÿÿÿÿ%˜Éh é ÿÿÿÿ%œÉh(éÿÿÿÿ% Éh0é€ÿÿÿÿ%¤Éh8épÿÿÿÿ%¨Éh@é`ÿÿÿÿ%¬ÉhHéPÿÿÿÿ%°ÉhPé@ÿÿÿÿ%´ÉhXé0ÿÿÿÿ%¸Éh`é ÿÿÿÿ%¼Éhhéÿÿÿÿ%ÀÉhpéÿÿÿÿ%ÄÉhxéðþÿÿÿ%ÈÉh€éàþÿÿÿ%ÌÉhˆéÐþÿÿÿ%ÐÉhéÀþÿÿÿ%ÔÉh˜é°þÿÿÿ%ØÉh é þÿÿÿ%ÜÉh¨éþÿÿÿ%àÉh°é€þÿÿ1í^‰áƒäðPTRh°©h`©QVhu‘èÿÿÿôU‰åSè[ÿAR‹ƒh…ÀtÿÐX[ÉÃU‰åPP€= Êu.¡èÅ‹…Òt´&ƒÀ£èÅÿÒ¡èÅ‹…ÒuëÆ ÊÉÉöU‰åQQ‹xÉ…Òt¸…Àtƒì hxÉè»wû÷ƒÄÉÃU‰åƒìÇEüÈ‹Eüƒ8uë&‹Eü‹;Eu‹Eü‹@£,ÈÇEøëEüƒëÐÇEø‹EøÉÃU‰åƒìÇEü€È‹Eüƒxuë‹Eü‹;Eu‹Eü‰EøëEüƒëÛÇEø‹EøÉÃU‰åƒì¡È‰EøÇÈÿÿÿÿƒì hˆªè:ƒÄ‰Eü‹Eø£Èƒìÿuh@ÊèfþÿÿƒÄ‹E‹@ £`ʃ=Èu‹U‹Eü‹@$B$£dÊë‹M‹Eü‹P ¡È)ÐA$£dʸ@ÊÉÃU‰åƒìƒ=Èu ÇEøë@ƒìÿuh@ÊèõýÿÿƒÄ¡È£`Ê‹Mü‹Eü‹P ¡È)Љ‹A$)УdÊÇEø@Ê‹EøÉÃU‰åƒìƒ=Èÿu‹E‰EüëZƒìhªÿuèIüÿÿƒÄ…Àuƒì ÿuèÞþÿÿƒÄ‰Eüë0ƒìhˆªÿuèüÿÿƒÄ…Àuƒì ÿuè@ÿÿÿƒÄ‰Eüë‹E‰Eü‹EüÉÃU‰åƒì¡,ȉEü‹Eü€8uë0ƒìÿuüÿuèÔûÿÿƒÄ…Àuƒì ÿuüèRÿÿÿƒÄ‰Eøë Eüƒ(ëÆèÇ‹EøÉÃU‰åƒì‹E ˆEÿ‹UŠEÿˆ}u ‹EÆ@ë ‹E²ÿ#UˆP‹M‹E‰ÂÁú°ÿ!ЈA‹M‹E‰ÂÁú°ÿ!ЈA‹U°ÿ#EˆBÉÃU‰åì…øþÿÿ‰…ôþÿÿƒìjÿµôþÿÿÿ5hÊèƒÄ‹…ôþÿÿ€8 uëÚ‹…ôþÿÿ€8 u>‹…ôþÿÿÆ…øþÿÿƒìh ªPèãúÿÿƒÄ…Àu Ç…ðþÿÿë…øþÿÿ‰…ôþÿÿë‘…ôþÿÿÿ뇋…ðþÿÿÉÃU‰åƒì(ƒì ÿuè¥þÿÿƒÄ‰Eüƒ}üuƒì hªè6ûÿÿƒÄƒì jèYûÿÿ‹Eü‹@ ‰Eø‹Uü‹Eü‹@$B ‰Eôƒì hàªèûÿÿƒÄƒì ÿ5ÊèƒúÿÿƒÄ¡Ê‰Eä‹EäƒxuéûÇEè‹Uä‹Eè;B|éÙ‹Uä‹Eä‹@¯Eè‰Â¯¤Ï„‰ÐÁøÁèÑø‰Eð‹Eä‹@‰Â¯¤Ï„‰ÐÁøÁèÑøEð‰Eì‹Eø;Eìrë{‹Eô;Eðwëq‹Eø;Eðv ƒìÿuðÿuøh «èJúÿÿƒÄƒì jèmúÿÿ‹Eô;Eìs ƒìÿuìÿuôh`«è"úÿÿƒÄƒì jèEúÿÿƒì h…«èúÿÿƒÄƒì ÿ5Êè‡ùÿÿƒÄEèÿéÿÿÿEäƒ é÷þÿÿƒì h‡«èÒùÿÿƒÄƒìÿuühŽ«è¿ùÿÿƒÄƒì ÿ5Êè>ùÿÿƒÄ¡Ê‰Eä‹EäƒxuéÆÇEè‹Uä‹Eè;B|餋Uä‹Eä‹@¯Eè‰Â¯¤Ï„‰ÐÁøÁèÑø‰Eð‹Eä‹@‰Â¯¤Ï„‰ÐÁøÁèÑøEð‰Eì‹Eø;EìrëF‹Eô;Eðwë<ƒì ‹Uä‹Eä‹@¯EèPèăăì h…«èøøÿÿƒÄƒì ÿ5ÊèwøÿÿƒÄEèÿéLÿÿÿEäƒ é,ÿÿÿƒì h‡«èÂøÿÿƒÄÉÃU‰åƒì(ƒì ÿuèüÿÿƒÄ‰Eüƒ}tƒìh€h Ïÿu 较ĉEôëƒìh€h Ïÿu èéƒÄ‰Eôÿuü‹Uô‰ÐÁàÐ…Ð…‹Eü‹H$Pÿ‹Eü‰Eà‹Mà‰ÐÁú÷y$‰EàÿuàÿuôhÀ«èøÿÿƒÄ‹Uü‹Eô;B$~ƒìÿuh¬èý÷ÿÿƒÄƒì jè øÿÿƒì ÿuè…üÿÿƒÄ‹Eü‹P ‰ÐÁú÷=¤Ï„‰E躉ÐÁú÷=¤Ï„‰E졤τEôPÿ‰ÐÁú÷=¤Ï„‰EðÇEø‹Eø;Eð|郃ìh‹Eø¯¤Ï„ ÏP‹EøEèPèèƒÄ…Àuƒìÿuøh"¬èS÷ÿÿƒÄ‹Eø%ÿ…Àu,ƒì‹Eø¯¤Ï„Ph5¬è,÷ÿÿƒÄƒì ÿ5Êè«öÿÿƒÄ‹UìEøépÿÿÿƒì‹Eø¯¤Ï„Ph9¬èóöÿÿƒÄ¸ÉÃU‰åƒìƒì ÿuè.úÿÿƒÄ‰EüƒìhL¬ÿu è"÷ÿÿƒÄ‰Eøƒ}øu#ƒìÿu hN¬ÿ5Êè öÿÿƒÄƒì jèÃöÿÿº‰ÐÁú÷=¤Ï„‰Eè‹Uü¡¤Ï„B$Pÿ‰ÐÁú÷=¤Ï„‰Eð‹Eü‹P ‰ÐÁú÷=¤Ï„‰Eìÿu ‹Eüÿp$ÿuüh€¬è:öÿÿƒÄÇEô‹Eô;Eð|錃ìhh Ï‹EôEìPè}ƒÄ…Àuƒì h°¬èöõÿÿƒÄÿuøhjh ÏèOöÿÿƒÄ‹Eô%ÿ…Àu,ƒì‹Eô¯¤Ï„Ph5¬è¸õÿÿƒÄƒì ÿ5Êè7õÿÿƒÄ‹UèEôégÿÿÿƒì‹Eô¯¤Ï„PhÀ¬èõÿÿƒÄƒì ÿuøèõÿÿƒÄ¸ÉÃU‰å쨃äð¸)ăì hà¬èGõÿÿƒÄƒ}èÉ‹E ƒÀƒìh­ÿ0ètôÿÿƒÄ…ÀuE ƒÿMÇÊÇÊët‹E ƒÀƒìh ­ÿ0è9ôÿÿƒÄ…ÀuE ƒÿMÇÊÇÊë9‹E ƒÀƒìh­ÿ0èþóÿÿƒÄ…ÀuE ƒÿMÇÊÇʃ=Êtèe£hÊé ƒìjh­èƒôÿÿƒÄ£hʃ=hÊÿu ƒìh!­ÿ5Êè¿óÿÿƒÄƒì jèbôÿÿÇE¸ÇE¼ÇEÀòÇEÄÆEÏÆE΃ìE¸Pjÿ5hÊèšóÿÿƒÄƒøÿu ƒìh!­ÿ5Êè_óÿÿƒÄƒì jèôÿÿƒ=Êu6ƒì h@­è¼óÿÿƒÄƒ=Êuèµ÷ÿÿƒìjhg­ÿ5hÊ臃ăì jèYóÿÿƒÄƒì hi­èyóÿÿƒÄƒì ÿ5ÊèøòÿÿƒÄè ‰E ƒìÿu h‚­èMóÿÿƒÄƒì hŸ­è=óÿÿƒÄƒì ÿ5Êè¼òÿÿƒÄèÍ…Àu ƒì jèFóÿÿƒì hµ­è óÿÿƒÄƒ} ~ƒìE˜PEœPè3ƒÄëƒìE˜PEœPèñƒÄ‹Eœ;E˜uǤτèóë Ǥτƒì ÿu˜ècôÿÿƒÄ‰E”ƒ}”uƒìÿuœh»­èŽòÿÿƒÄƒì jè±òÿÿ‹E”‹@£„Ï‹E”‹@£Ê¡„ϯ¤Ï„‰…\ÿÿÿƒ½\ÿÿÿy …\ÿÿÿÿ‹…\ÿÿÿÁø £ Ï„ƒìÿ5 Ï„¡¤Ï„ÁàPÿ5„Ï‹E”ÿp ‹¤Ï„‰ÐÁøÁèÑøPhà­èüñÿÿƒÄ ƒì ÿ5 Ï„è[óÿÿƒÄ…Àu ƒìÿ5 Ï„h ®èÑñÿÿƒÄƒì jèôñÿÿƒì h`®è·ñÿÿƒÄƒìhš®…hÿÿÿPè@òÿÿƒÄƒì …hÿÿÿPèòÿÿƒÄ‰…dÿÿÿƒ½dÿÿÿÿ„šƒì ÿµdÿÿÿèÊðÿÿƒÄƒì…hÿÿÿPh­®èjúÿÿƒÄƒì …hÿÿÿPè ƒÄ£È¡È‰…Xÿÿÿƒ½Xÿÿÿÿtƒ½Xÿÿÿtë$ƒì h´®è ñÿÿƒÄëDƒì hà®èûðÿÿƒÄë2ƒìÿ5Èh ¯èãðÿÿƒÄëƒì h@¯èÑðÿÿƒÄƒì jèôðÿÿ‹E ƒÀƒìhq¯ÿ0èÿïÿÿƒÄ…Àu1ƒ}tè-ƒì‹E ƒÀ ÿ0‹E ƒÀÿ0èœùÿÿƒÄ‰…`ÿÿÿéâ‹E ƒÀƒìhv¯ÿ0è²ïÿÿƒÄ…Àu3ƒ}tèà ƒìj‹E ƒÀ ÿ0‹E ƒÀÿ0èy÷ÿÿƒÄ‰…`ÿÿÿé“‹E ƒÀƒìh|¯ÿ0ècïÿÿƒÄ…Àu0ƒ}tè‘ ƒìj‹E ƒÀ ÿ0‹E ƒÀÿ0è*÷ÿÿƒÄ‰…`ÿÿÿëG‹E ƒÀƒìh…¯ÿ0èïÿÿƒÄ…Àu&ƒ}tèE ƒì ‹E ƒÀÿ0èEôÿÿƒÄ‰…`ÿÿÿëè% ‹…`ÿÿÿÉÃU‰åƒì(‹U‰ÐÁøÁèÑøPÿujREèPèóÿÿƒÄƒìjEèPÿ5hÊèBƒÄÇEä‹E@9Eä|ë/ƒì‹Uä‹E)Ð@P‹EäE Pÿ5hÊèRƒÄ‰EÜ‹UÜEäëÆÇEàÇEä‹Eä;E|ë)‹EäE ¾¶ÐEà}àÿ~¶Eà@‰EàEäÿëÍ‹EE ¾%ÿ9Eàt+ƒì‹EE ¾%ÿPÿuàh ¯èšîÿÿƒÄÇEØëÇEØ‹EØÉÃU‰åƒì8‹U‰ÐÁøÁèÑøPÿujWEèPèòÿÿƒÄƒìjEèPÿ5hÊè7ƒÄƒìÿuÿu ÿ5hÊè ƒÄ‰EäÇEàÇEä‹Eä;E|ë-‹EäE ¾¶ÐEà}àÿ~ ‹Eà@%ÿ‰EàEäÿëÉ°ÿ#EàˆEÛƒìjEÛPÿ5hÊ蹃ăìjEÛPÿ5hÊèæƒÄƒøtƒì hà¯èœíÿÿƒÄƒì jè¿íÿÿ€}Ûu ÇEÔë$ƒì¾EÛ%ÿPÿuh °èfíÿÿƒÄÇEÔ‹EÔÉÃU‰åƒì(jjjIEèPèêðÿÿƒÄƒìjEèPÿ5hÊèƒÄƒìjEçPÿ5hÊèIƒÄƒøtƒì h`°èÿìÿÿƒÄƒì jè"íÿÿ€}çu ÇEàë!ƒì¾Eç%ÿPh °èÌìÿÿƒÄÇEà‹EàÉÃU‰åƒì8jjjDEèPèPðÿÿƒÄƒìjEèPÿ5hÊ肃ăìjEØPÿ5hÊ诃ăøtƒì hà°èeìÿÿƒÄƒì jèˆìÿÿ€}Üt"ƒì¸ŠEØPh ±è<ìÿÿƒÄÇEÔëA‹M¸ŠE؉ÂÁ⸊EÙ‰‹M ¸ŠEÚ‰ÂÁ⸊EÛ‰ÇEÔ‹EÔÉÃU‰å‹EÇÿÿ‹E ÇX"¸]ÃU‰åƒì(jjjTEèPèaïÿÿƒÄƒìjEèPÿ5hÊè“ ƒÄƒìjEçPÿ5hÊèÀ ƒÄƒøtƒì h`±èvëÿÿƒÄƒì jè™ëÿÿ€}çu ÇEàë!ƒì¾Eç%ÿPh ±èCëÿÿƒÄÇEà‹EàÉÃU‰åì(ƒì hà±èëÿÿƒÄƒìh²ÿuèkëÿÿƒÄ‰Eôƒ}ôuÇ…äþÿÿÿÿÿÿ韃ìÿuôhÿ…èþÿÿPè˜êÿÿƒÄ…Àuëf…èþÿÿƒìj h²Pè™êÿÿƒÄ…ÀuÃìhÈh²…èþÿÿƒÀ PèÖêÿÿƒÄƒøt ÇÈÿÿÿÿƒì ÿuôè‰êÿÿƒÄ¡È‰…äþÿÿëƒì ÿuôènêÿÿƒÄÇ…äþÿÿÿÿÿÿ‹…äþÿÿÉÃU‰åƒì(jjjHEèPèÜíÿÿƒÄƒìjEèPÿ5hÊè ƒÄƒìjEçPÿ5hÊè; ƒÄƒøtƒì h ²èñéÿÿƒÄƒì jèêÿÿ¾EçÉÃU‰åƒì(jjjXEèPèqíÿÿƒÄƒìjEèPÿ5hÊè£ ƒÄƒìjEçPÿ5hÊèÐ ƒÄƒøtƒì h@²è†éÿÿƒÄƒì jè©éÿÿ€}çu ÇEàë!ƒì¾Eç%ÿPh`²èSéÿÿƒÄÇEà‹EàÉÃU‰åƒì(j‹U‰ÐÁøÁèÑøPjSEèPèÈìÿÿƒÄƒìjEèPÿ5hÊèú ƒÄƒìjEçPÿ5hÊè' ƒÄƒøtƒì h ²èÝèÿÿƒÄƒì jèéÿÿ€}çu ÇEàë!ƒì¾Eç%ÿPhà²èªèÿÿƒÄÇEà‹EàÉÃU‰åƒì‹EˆEÿ€}ÿ/~€}ÿ9 ¾Eÿƒè0‰EøëO€}ÿ`~€}ÿf ¾EÿƒèW‰Eøë7€}ÿ@~€}ÿF ¾Eÿƒè7‰Eøëƒì¾EÿPh ³è5èÿÿƒÄƒì jèXèÿÿ‹EøÉÃU‰åVSƒì0‹E‰EôÇEàÇEÜ‹Eô‰ÂEôÿ€::t ÇEØþÿÿÿéƒì ‹Eô¾PEôÿè=ÿÿÿƒÄ‰ÃÁãƒì ‹Eô¾PEôÿè!ÿÿÿƒÄ‰Eè‹Eè‰Eàƒì ‹Eô¾PEôÿèþþÿÿƒÄ‰ÃÁã ƒì ‹Eô¾PEôÿèâþÿÿƒÄÁàÃƒì ‹Eô¾PEôÿèÆþÿÿƒÄÁàÃƒì ‹Eô¾PEôÿèªþÿÿƒÄ‰Eð¶UðEà‹Eð‰ÂÁêEàƒ}èu ÇEØé=ƒì ‹Eô¾PEôÿèeþÿÿƒÄ‰ÃÁãƒì ‹Eô¾PEôÿèIþÿÿƒÄ‰Eä‹UäEà‹Eä‰EÔƒ}Ôtƒ}Ô„ØéuEèÿƒ}èÿué•¡ÊÁàEð;Erƒì h³èŠæÿÿƒÄƒì jè­æÿÿ¡ÊÁàEð‰Æu ƒì ‹Eô¾PEôÿè¾ýÿÿƒÄ‰ÃÁãƒì ‹Eô¾PEôÿè¢ýÿÿƒÄˆ¡ÊÁàEðE ¾¶ÐEàEðÿé[ÿÿÿ¡ÊÁà‰ÂUð‹E;†Ó‹U¡ÊÁàEð‰龃}èt ÇEØþÿÿÿéüƒì ‹Eô¾PEôÿè$ýÿÿƒÄ‰ÃÁã ƒì ‹Eô¾PEôÿèýÿÿƒÄÁàÃƒì ‹Eô¾PEôÿèìüÿÿƒÄÁàÃƒì ‹Eô¾PEôÿèÐüÿÿƒÄ£Ê¶ÊEà¡Ê‰ÂÁúEàëƒìÿuäh/³è3åÿÿƒÄÇEØþÿÿÿëPƒì ‹Eô¾PEôÿèxüÿÿƒÄ‰ÃÁãƒì ‹Eô¾PEôÿè\üÿÿƒÄEà€}àu‹E܉EØëÇEØÿÿÿÿ‹EØeø[^]ÃU‰åƒìxÇE”ÇEÇ$ʃ}tƒìh²ÿuèùäÿÿƒÄ‰Eôë¡Ê‰Eôƒ}uÇE@³ƒìÿuhF³èläÿÿƒÄƒì ÿ5ÊèëãÿÿƒÄƒ}ôuƒì h€³èEäÿÿƒÄƒì jèhäÿÿƒìÿuôjOE˜PèæãÿÿƒÄ…ÀuësE”ÿh$Êÿuÿu E˜PèáûÿÿƒÄ‰EŒƒ}Œÿu!ƒìE˜Pÿu”hÀ³èäãÿÿƒÄƒì jèäÿÿƒ}Œ~‹UŒEƒ}ŒþuŒƒìE˜Phï³è²ãÿÿƒÄésÿÿÿƒì ÿuôè¯ãÿÿƒÄƒì hµ­èãÿÿƒÄ¡$ÊÉÃU‰åƒìxÇE”ÇEÇ(ʃ}tƒìh²ÿuè±ãÿÿƒÄ‰Eôë¡Ê‰Eôƒ}uÇE@³ƒìÿuh´è$ãÿÿƒÄƒì ÿ5Êè£âÿÿƒÄƒ}ôuƒì h€³èýâÿÿƒÄƒì jè ãÿÿÿuôhjÿu èâÿÿƒÄ‰E‹E…Àuë‹EU ‹E(Êë̃ì ÿuôèÀâÿÿƒÄƒì hµ­è âÿÿƒÄ¡(ÊÉÃU‰åƒìƒìÿuh ´ÿ5ÊèúáÿÿƒÄèÉÃU‰åƒì¡,ȉEüƒìh8´ÿ5ÊèÏáÿÿƒÄƒìh@´ÿ5Êè¹áÿÿƒÄƒìh€´ÿ5Êè£áÿÿƒÄƒìhÀ´ÿ5ÊèáÿÿƒÄƒìhµÿ5ÊèwáÿÿƒÄƒìh@µÿ5ÊèaáÿÿƒÄ‹Eü€8uë!ƒìÿuühYµÿ5Êè>áÿÿƒÄEüƒ(ëÕƒìh]µÿ5Êè áÿÿƒÄƒì jèÃáÿÿU‰åƒì‹E ˆEÿŠEÿˆEþƒìEþPh†p@ÿuè½áÿÿƒÄƒøuƒì h_µèÈàÿÿƒÄÉÃU‰åƒìƒìEÿPhp€ÿuè‰áÿÿƒÄƒøuƒì hlµè”àÿÿƒÄ¸ŠEÿÉÃU‰åƒìƒìjhxµè"áÿÿƒÄ‰Eøƒ}øyƒì h†µèYàÿÿƒÄƒì jè áÿÿÇEüƒìEüPh‹pÿuøèáÿÿƒÄƒøuƒì h”µèàÿÿƒÄƒì jèÏàÿÿƒìjÿuøèÿþÿÿƒÄ‹EøÉÃU‰åƒìƒì ÿuè%ÿÿÿƒÄ%ÿ‰Eø°€#Eø„Àuáƒì ÿuèÿÿÿƒÄ%ÿ‰Eø‹EøÁøƒà‰Eüƒì°ÿ#E ¾ÀPÿuè›þÿÿƒÄƒì°ÿ#E ƒÈ¾ÀPÿuèþÿÿƒÄƒì ÿuè³þÿÿƒÄ%ÿ‰Eø°€#Eø„Àtáƒì ÿuè”þÿÿƒÄ%ÿ‰Eø‹EøÀ‰ÂâðEü ƒì‹E ÁøƒàƒÈ¾ÀPÿuèþÿÿƒÄƒì‹E Áø¾ÀƒàPÿuèþÿÿƒÄ‹EüÉÃU‰åƒì‹E‰Eüƒ}u鈃ìjÿuèÞþÿÿƒÄ…Àtƒì h£µèTßÿÿƒÄƒì jèwßÿÿ}ÿ‹E‰EøëÇEøÿ‹UøE)ƒìÿuøÿuèþÿÿƒÄEøÿƒ}øÿu뉃ì‹E ¾PE ÿÿuèhþÿÿƒÄë׋EüÉÃU‰åSƒì‹E‰Eøƒ}u鹃=,Êt+‹E ‰Â¡0ʀʊˆÿ0ÊE ÿÿ ,ÊEÿëÁƒìjÿuèþÿÿƒÄ£,ʃ=,Êuƒì hµµèqÞÿÿƒÄƒì jè”ÞÿÿÇ0Ê¡0Ê;,Êuë%¡0ʘ€Êƒìjÿ0Êÿuè£ýÿÿƒÄˆëÌÇ0Êé<ÿÿÿ‹Eø‹]üÉÃU‰åƒìƒ=Êtƒìÿuÿu ÿuècþÿÿƒÄ‰Eüëƒìÿuÿu ÿuèÝÿÿƒÄ‰Eü‹EüÉÃU‰åƒìƒ=Êtƒìÿuÿu ÿuèÃþÿÿƒÄ‰Eüëƒìÿuÿu ÿuèÞÿÿƒÄ‰Eü‹EüÉÃU‰åWV1öSè[à ƒì èxÜÿÿƒPüÿÿ“Püÿÿ)ÂÁú9Ös‰Eð‰×ÿ°‹EðF9þrõƒÄ [^_]ô&U‰åWVSè[ÃÁƒì ƒPüÿÿ»Püÿÿ)øÁø…ÀpÿuèRƒÄ [^_]öÿ·‰ðN…Àuöè5ƒÄ [^_]ÃU‰åSR»hÉ¡hɃøÿt ƒëÿЋƒøÿuôX[]ÃU‰åSè[Ã?Pè–ÝÿÿY[ÉÃ29F800BrootzImageEnter CTRL-A to enter programmer.Partition not found Checking partition and sector alignmentPartition start(%x) > Sector start (%x) Partition end(%x) < Sector end (%x) .done. Erasing %s sectorsData size is %d bytes (%d%% of '%s' partition used). Data to large for '%s' partition checksum error %d %d %d bytes written. wCould not open '%s' Reading partition '%s' (%d bytes) to file '%s' checksum error %d bytes read. Webpal flash programmer V3.1 1/29/04. -p-s-nowait/dev/ttyS0Can't open terminal Reboot Webpal to begin programming... Contacting programmer...detected version %d...done. Initializing flash...done Chip id unknown %04x Found %d X %s flash -- %dK X %d bits (total size = %d MByte). No sector table found for %d MByte sizeReading 'params' partition to check partitioning info... /tmp/wpflashXXXXXXparamsRoot partition disabled. No changes from default partition table Root partition starts at %x. Could not read partition information from flash readwritewritehexerasechecksum error reading data from flash: %d %d no resposne to 'write flash' command. write flash @ %08x: command failure: code %x not response to 'initialize' command 'initialize' command failure: code %x no response to 'device id' command 'device id' command failure: code %d no response to 'double_width' command 'double width' command failure: code %x Parsing partitioning information rroot_start=%xno response to 'hello' command no response to 'erase' command 'erase' command failure: code %x no resposne to 'erase sector' command 'erase sector' command failure: code %x bad hex digit: '%c' image too large unknown type %d stdinReading object file '%s'...failed...cannot open object file Checksum error in object file on line %d. %s %s Reading raw object file '%s'...Unknown partition: %s usage: wpflash read -- read wpflash write -- erase/write wpflash writehex -- erase/write wpflash erase -- erase all flash is one of: %s write failedread failed/dev/parport0Open parport0PPCLAIM failedWrite Sync error Read Sync error tÉallboot`params` zImage€€ root erx all boot€params€@zImageÀ@ root ÿÿÿÿÆ ÇÆ@@ €€X"@È€ª ô… 4ªH؃‚ Ù |ɸ<…… þÿÿoì„ÿÿÿoðÿÿo²„ÿÿÿÿÿÿÿÿ È"†2†B†R†b†r†‚†’†¢†²††Ò†â†ò†‡‡"‡2‡B‡R‡b‡r‡‚‡GCC: (GNU) 3.3.1 (Mandrake Linux 9.2 3.3.1-1mdk)GCC: (GNU) 3.3.1 (Mandrake Linux 9.2 3.3.1-1mdk)GCC: (GNU) 3.3.1 (Mandrake Linux 9.2 3.3.1-2mdk)GCC: (GNU) 3.3.1 (Mandrake Linux 9.2 3.3.1-2mdk)GCC: (GNU) 3.3.1 (Mandrake Linux 9.2 3.3.1-2mdk)GCC: (GNU) 3.3.1 (Mandrake Linux 9.2 3.3.1-1mdk)‡", 4ªô… ´‡!$² Jª †!yœ„_IO_stdin_usedu‡²‡../sysdeps/i386/elf/start.S/export/home/gb.local/rpm/BUILD/glibc-2.3.2/csuGNU AS 2.14.90.0.5€˜q´‡´‡^¢óÕ0WÜ"BÒc#TÐ$0~%qRo(ƒÔ9)B¥* s+Tæ,½intÉ-072Ú#3ìMu9Ú…:ìƒìd„0Ò…0/†qe‡ì£ˆ0›‰0CŠa(O‹Ú[Œ½•ý•#¥½¥W‡~÷Ža=q\ì‘0 ’aà“0W”ax–½¥—aÔ˜½Ú›½´ž½î¡a‰¦a‡§Ú‚ªq”«ìe®qz¯ìK´½œµh¬¶© ó†·º ÀÛLº½+½0 oEa ~b0 S FQé lR$À¥ITmN½#Sõ#ÆT$y ¶V#8I#eT©#¶!h#8"I#ª#„ ù&-7êAØg¯ 8wCH R½R7ºÀË×½½ X7å<?òu¦#çvç#íx½#Ozº# ú{º#÷}#Y~Ý#Ü#'€$# [„½#$…½#(†½#,¤‡½#0¾Š½#4Œ…#8 =º$@D“Ñ#®”Ñ#¦˜½#Fœ½# Û ½#U¢¬#8£I#1§š# À ÆB Ñ B %1Kè îéRB@N $½R¼O/ 5ARmXL R…½R7…ÀºÀË×ð]’ ˜¼½…ÀÀÑÑaÇ Íç½çò× íÀ ø çÅd  $½$ç …e5 ;G…š1B1jA#ñk‡#Àl*#m…#  nš# G”   Ié‚­ ®%#r¯R#°é#ø=¥¶± ².,4*2²#3=# M,5 */² º4 Q5.7 8½9T:0Ì–dª½™B/export/home/gb.local/rpm/BUILD/glibc-2.3.2/build-i586-linux/csu/crti.S/export/home/gb.local/rpm/BUILD/glibc-2.3.2/csuGNU AS 2.14.90.0.5€™(ë/export/home/gb.local/rpm/BUILD/glibc-2.3.2/build-i586-linux/csu/crtn.S/export/home/gb.local/rpm/BUILD/glibc-2.3.2/csuGNU AS 2.14.90.0.5€%% : ; I$ > $ >  : ;  : ; I8 I!I/  I : ;I  : ; : ; I  : ; ( ' II : ; &I'  < !I4: ; I?  %%S/û ../sysdeps/i386/elfstart.S‡.01:"VWYXû ÍÇû /usr/lib/gcc-lib/i586-mandrake-linux-gnu/3.3.1/include../sysdeps/generic/bits../wcsmbs../sysdeps/gnu../iconvinit.cstddef.htypes.hwchar.h_G_config.hgconv.h¥[û /export/home/gb.local/rpm/BUILD/glibc-2.3.2/build-i586-linux/csucrti.S4ª3,Wdô…#,:´‡ ,Wdd,,-ƒ[û /export/home/gb.local/rpm/BUILD/glibc-2.3.2/build-i586-linux/csucrtn.SJª † _G_int32_t__time_t__GCONV_INCOMPLETE_INPUT__GCONV_OK__state__gconv_init_fct_G_iconv_t__rlim64_t__GCONV_ILLEGAL_DESCRIPTOR__gconv_infoshort unsigned int/export/home/gb.local/rpm/BUILD/glibc-2.3.2/csuunsigned char__useconds_t__counter__fct__val__value__nsteps_G_int16_t__max_needed_from__gconv_btowc_fct__off_t__ssize_t__statepinit.c__fsfilcnt_t__steps__fsfilcnt64_t__blkcnt_t__gconv_loaded_object_G_fpos64_t__gconv_t__trans_end_fct__u_int__GCONV_ILLEGAL_INPUT__blksize_t__to_name__uint64_t__id_t__GCONV_EMPTY_INPUT__cd__ino_t__GCONV_NOCONV__invocation_counter__pid_t__u_short__count__quad_t__u_long__fsid_t__GCONV_FULL_OUTPUT__max_needed_to__timer_t__stateful__uint32_t__key_t__u_char__gconv_step__shlib_handle__min_needed_toshort int__dev_tlong long int__gconv_trans_data__outbuflong long unsigned int__uid_t__wchb__uint16_twint_t__u_quad_t__gconv_trans_end_fct__flags__outbufend__combined__gconv_trans_init_fct__init_fct__modname__trans_context_fctGNU C 3.3.1 (Mandrake Linux 9.2 3.3.1-1mdk)__trans_fct__rlim_t__wch__intptr_t__suseconds_t__ino64_twchar_t__GCONV_IS_LAST__blkcnt64_t__fsblkcnt64_t__mode_t__qaddr_t__pos__gconv_end_fct_IO_stdin_used__internal_use__GCONV_NODB__clock_t__gconv_step_data__gconv_trans_query_fct__socklen_t__int64_t__GCONV_NOMEM__off64_t__btowc_fct_G_fpos_t__int8_t__daddr_t__fsblkcnt_t_G_uint32_t__nlink_t__swblk_t__GCONV_INTERNAL_ERROR__mbstate_t__gid_t__clockid_t__int32_t__gconv_trans_context_fct__next__GCONV_IGNORE_ERRORS__end_fct__trans__uint8_t__gconv_fct__from_name__min_needed_from__gconv_trans_fct__data__caddr_t_G_uint16_t__loff_t__int16_t.symtab.strtab.shstrtab.interp.note.ABI-tag.hash.dynsym.dynstr.gnu.version.gnu.version_r.rel.dyn.rel.plt.init.text.fini.rodata.eh_frame.data.dynamic.ctors.dtors.jcr.got.bss.comment.debug_aranges.debug_pubnames.debug_info.debug_abbrev.debug_line.debug_str#(( 1HHÀ7 ‚Ð?؃ØÙGÿÿÿo²„²:Tþÿÿoì„ì0c … l <…<¸ uô…ôp † €{‡¤"4ª4*‡`ª`*f ȵÈ5™àÅà5À Ÿ È 8ȨhÉh9¯pÉp9¶xÉx9»|É|9lÀÊ:¨€ Å:,Î0;xݨ;%íÍ;O ùF8TGr0ÆI¯uP¼Và T œbì(H‚؃²„ì„…<… ô… † ‡ 4ª `ªȵàÅ ÈhÉpÉxÉ|ÉÊ ñÿñÿñÿVñÿañÿlñÿañÿñÿañÿñÿñÿñÿVñÿañÿ·ñÿ¾ñÿñÿNñÿ¾ñÿñÿñÿñÿVñÿ¾ñÿY´‡ iñÿthÉ‚pÉxÉèÅ¡ Ê­à‡ Ã ˆ iñÿÏlÉÜtÉéȵ÷xɪ ñÿñÿNñÿñÿñÿñÿñÿVñÿñÿañÿk$Êu(Ê@Ê(ˆ@È<”¨›ë §Æ­0ʸR¦þ Â,ÈÒŽÔ ä ÈíhÊñF¤& ÿ_‰] †|%,†D7l¤Ý =|‹£ M<†q^抖 o`ªvL†Èˆ“œk Ž¹žV ™\†¬l†þ¾ÌÅñÿÏI¥@ ØLˆI ìäÅù°©W |†”˜© +€Ê3šÓ =ó‚ L,ÊV›š bô… hŒ†äy©D ¢H ʟʱ‰¥< ¹O—  ÄÅ¥ ̇ Óœ†7äͨD í€Ëô¬†Mȼ†ö#€Ï(ÓˆŒ ?ÌÅñÿR`©I bèÉñÿnu‘Ú sÊz̆æ—„ÏœÌÅñÿ­ô§Ù »Z˜+ ÇÈØòš å ÊíàÅ ø Ï€ÿ܆-4ª ì†u)Ê6ü†|FÊK Ï„WÊ` ‡Èp2ŠR ‡(‘èÉñÿ˜¼‰v ¨|ɾ¨Ï„ñÿÃ,‡<Ôþœš ÚAžx Þ Çðä…™š ï€È ûÊ <‡&ÌÅñÿ0•ˆ> @dªOW£ï XP§¤ gL‡8yàņ„Šb Ž ¢\‡|²¤Ï„¸l‡#Ë Ú|‡‹/export/home/gb.local/rpm/BUILD/glibc-2.3.2/build-i586-linux/config.habi-note.S/export/home/gb.local/rpm/BUILD/glibc-2.3.2/build-i586-linux/csu/abi-tag.hinit.c/export/home/gb.local/rpm/BUILD/glibc-2.3.2/build-i586-linux/csu/crti.S/export/home/gb.local/rpm/BUILD/glibc-2.3.2/build-i586-linux/csu/defs.hinitfini.ccall_gmon_startcrtstuff.c__CTOR_LIST____DTOR_LIST____JCR_LIST__p.0completed.1__do_global_dtors_auxframe_dummy__CTOR_END____DTOR_END____FRAME_END____JCR_END____do_global_ctors_aux/export/home/gb.local/rpm/BUILD/glibc-2.3.2/build-i586-linux/csu/crtn.Swpflash.cmax_mem.0max_mem.1modifiedsectors2258parse_flash_paramspart1readoffsetxfer_bytepartition_tableprogram_partition_DYNAMICsfdbad_partitionfixup_root_partitionwrite@@GLIBC_2.0strcmp@@GLIBC_2.0usageerase_partitionclose@@GLIBC_2.0wait_boot_prompt_fp_hwperror@@GLIBC_2.0helloparse_linefprintf@@GLIBC_2.0fflush@@GLIBC_2.0__fini_array_endpp_writeset_partition_table__dso_handle__libc_csu_finitcsetattr@@GLIBC_2.0erase_sectorreadbufdevice_idread_partitionreadcountdouble_wide_initfread@@GLIBC_2.0do_readread_objectstdout@@GLIBC_2.0stderr@@GLIBC_2.0pp_readread_flashpp_open_startfgets@@GLIBC_2.0do_writebuffersleep@@GLIBC_2.0root_startstrncmp@@GLIBC_2.0addrfixup_zImage_partition__fini_array_start__libc_csu_init__bss_startmainnowait__libc_start_main@@GLIBC_2.0size__init_array_endparallel_readwrite_flashpartition_tablesdevice_id_v0maxaddrdata_startmembufprintf@@GLIBC_2.0_finifclose@@GLIBC_2.1sector_tableopen@@GLIBC_2.0pagetotalSizeMBparallelexit@@GLIBC_2.0find_partitionsscanf@@GLIBC_2.0_edatafixup_partition_GLOBAL_OFFSET_TABLE__endioctl@@GLIBC_2.0erasehexpart2initializeflash_chipsstdin@@GLIBC_2.0fopen@@GLIBC_2.1__init_array_startfind_flash_chip_IO_stdin_usedread_rawparallel_writefwrite@@GLIBC_2.0__data_startset_cmd_Jv_RegisterClassesread@@GLIBC_2.0widthmkstemp@@GLIBC_2.0__gmon_start__strcpy@@GLIBC_2.0flash/flashpgm.c0000664000076500007650000002236407416145155013513 0ustar brdbrd00000000000000char sbreg@0x99; char txsta@0x98; #define TXEN 0x20 #define BRGH 0x04 char rcsta@0x18; #define SPEN 0x80 #define CREN 0x10 char txreg@0x19; char rcreg@0x1a; char pir1@0x0c; #define RCIF 0x20 #define TXIF 0x10 char adcon1@0x9f; #define ALL_DIGITAL 0x6 char pie1@0x8c; /* PORT A */ char strobeport@0x05; /* Only has 6 bits */ char strobedir@0x85; #define STROBELOW 4 #define STROBEMED 3 #define STROBEHI 2 /* PORT B */ char datalowport@0x06; /* Has 8 bits */ char datalowdir@0x86; /* PORT C */ char addrport@0x07; /* has 6 bits (top 2 are UART bits) */ char addrdir@0x87; #define ADDRDIR 0xc0; /* Top two bits set to input (UART bits) */ /* Port D */ char datahiport@0x08; /* Bidirectional 8 bit port for data */ char datahidir@0x88; /* Port E */ char controlport@0x09; /* Only has 3 bits */ #define nCE_BIT 0 /* not Chip Enable */ #define nOE_BIT 1 /* not Output Enable */ #define nWE_BIT 2 /* not Write Enable */ char controldir@0x89; #define INPUT_PORT 0xff #define OUTPUT_PORT 0x00 char addrlow, addrmed, addrhi; char datalow, datahi; /* Buffer sizes are picked so that they fit in the banks of 80 registers */ char buffer1[80]; char buffer2[80]; char buffer3[80]; char buffer4[16]; char i; char count; char checksum; char temp; /* Set the address latches from the address in [addrhi, addrmed, addrlow] */ void set_address() { addrport = addrhi & 0x3f; strobeport = (addrhi >> 6) & 0x3; nop(); nop(); nop(); set_bit(strobeport, STROBEHI); nop(); nop(); nop(); clear_bit(strobeport, STROBEHI); addrport = addrmed & 0x3f; strobeport = (addrmed >> 6) & 0x3; nop(); nop(); nop(); set_bit(strobeport, STROBEMED); nop(); nop(); nop(); clear_bit(strobeport, STROBEMED); addrport = addrlow & 0x3f; strobeport = (addrlow >> 6) & 0x3; nop(); nop(); nop(); set_bit(strobeport, STROBELOW); nop(); nop(); nop(); clear_bit(strobeport, STROBELOW); } /* Read from the FLASH. Result in [datahi, datalow] */ void read_data() { clear_bit(controlport, nCE_BIT); clear_bit(controlport, nOE_BIT); nop(); nop(); nop(); datalow = datalowport; datahi = datahiport; nop(); nop(); nop(); set_bit(controlport, nOE_BIT); set_bit(controlport, nCE_BIT); } /* Write to the FLASH. Data to be stored in [datahi, datalow] */ void write_data() { datalowdir = OUTPUT_PORT; datahidir = OUTPUT_PORT; datalowport = datalow; datahiport = datahi; nop(); nop(); nop(); nop(); clear_bit(controlport, nCE_BIT); clear_bit(controlport, nWE_BIT); nop(); nop(); nop(); nop(); set_bit(controlport, nWE_BIT); set_bit(controlport, nCE_BIT); datalowdir = INPUT_PORT; datahidir = INPUT_PORT; } /* Write a command to a particular address */ /* This routine doesn't clobber the [addrhi, addrmed, addrlo] registers */ void cmd_write(char amed, char alow, char dlow) { addrport = 0; /* Addrhi is always zero */ strobeport = 0; nop(); nop(); nop(); set_bit(strobeport, STROBEHI); nop(); nop(); nop(); clear_bit(strobeport, STROBEHI); addrport = amed & 0x3f; strobeport = (amed >> 6) & 0x3; nop(); nop(); nop(); set_bit(strobeport, STROBEMED); nop(); nop(); nop(); clear_bit(strobeport, STROBEMED); addrport = alow & 0x3f; strobeport = (alow >> 6) & 0x3; nop(); nop(); nop(); set_bit(strobeport, STROBELOW); nop(); nop(); nop(); clear_bit(strobeport, STROBELOW); datahi = 0; /* Data hi is always zero */ datalow = dlow; write_data(); } /* Get a character from UART */ char get_char() { while ((pir1 & RCIF) == 0) ; return rcreg; } /* Put a character to UART */ void put_char(char v) { while ((pir1 & TXIF) == 0) ; txreg = v; } /* Increment [addrhi, addrmed, addrlow] as 24 bit quantity */ void increment_address() { if (++addrlow == 0) if (++addrmed == 0) ++addrhi; } /* Reads 4 characters into [addrhi, addrmed, addrlow] and count */ /* Count is multiplied by two to be in bytes (0 == 256) */ void get_address_and_count() { count = get_char(); /* Count = 1 to 128 */ count = count + count; /* Double count */ addrhi = get_char(); /* Addr from 0 -> 512K (19 bits) */ addrmed = get_char(); /* MSB first! */ addrlow = get_char(); } /* Get the next character from the buffer. */ /* The buffer is made up of three smaller buffers so that */ /* it fits in the PIC registers. */ /* The global variable 'i' contains the offset into the buffer. */ char get_buffer() { if (i < 80) return buffer1[i]; if (i < 160) return buffer2[i-80]; if (i < 240) return buffer3[i-160]; return buffer4[i-240]; } /* Put a character into the buffer. */ /* The buffer is made up of three smaller buffers so that */ /* it fits in the PIC registers. */ /* The global variable 'i' contains the offset into the buffer. */ void put_buffer(char v) { if (i < 80) { buffer1[i] = v; return; } if (i < 160) { buffer2[i-80] = v; return; } if (i < 240) { buffer3[i-160] = v; return; } buffer4[i-240] = v; } /* Wait until an operation is complete */ /* Waits until either DQ7 is equal to the bit being written or until DQ5 is set to one indicating an error */ char wait_complete(char data) { data = data & 0x80; /* Just keep lsb of data */ /* Read from chip */ clear_bit(controlport, nCE_BIT); clear_bit(controlport, nOE_BIT); /* Wait until DQ7 == data bit 7 */ /* Also check if DQ5 == 1 */ while (1) { datalow = datalowport; if ((datalow & 0x80) == data) break; if (datalow & 0x20) { datalow = datalowport; if ((datalow & 0x80) == data) break; set_bit(controlport, nOE_BIT); set_bit(controlport, nCE_BIT); return 0; } } set_bit(controlport, nOE_BIT); set_bit(controlport, nCE_BIT); return 1; } /* Does a READ/RESET command */ void initialize() { get_address_and_count(); cmd_write(0x00, 0x00, 0xf0); /* 0x0000 <- 0xf0 */ put_char(0); } /* Does an ERASE command */ void erase() { get_address_and_count(); cmd_write(0x05, 0x55, 0xaa); /* 0x0555 <- 0xaa */ cmd_write(0x02, 0xaa, 0x55); /* 0x02aa <- 0x55 */ cmd_write(0x05, 0x55, 0x80); /* 0x0555 <- 0x80 */ cmd_write(0x05, 0x55, 0xaa); /* 0x0555 <- 0xaa */ cmd_write(0x02, 0xaa, 0x55); /* 0x02aa <- 0x55 */ cmd_write(0x05, 0x55, 0x10); /* 0x0555 <- 0x10 */ /* Wait for erase to complete */ if (wait_complete(0xff)) put_char(0); else put_char(2); } /* Does an ERASE SECTOR command */ void erasesector() { get_address_and_count(); cmd_write(0x05, 0x55, 0xaa); /* 0x0555 <- 0xaa */ cmd_write(0x02, 0xaa, 0x55); /* 0x02aa <- 0x55 */ cmd_write(0x05, 0x55, 0x80); /* 0x0555 <- 0x80 */ cmd_write(0x05, 0x55, 0xaa); /* 0x0555 <- 0xaa */ cmd_write(0x02, 0xaa, 0x55); /* 0x02aa <- 0x55 */ set_address(); datalow = 0x30; datahi = 0; write_data(); /* Wait for erase to complete */ if (wait_complete(0xff)) put_char(0); else put_char(2); } /* Writes a block of data to the FLASH */ void write() { /* Read in address and length from serial port */ get_address_and_count(); /* Read in the data from serial port into the buffers */ checksum = 0; i = 0; while (1) { temp = get_char(); checksum = checksum + temp; if (checksum < temp) checksum++; put_buffer(temp); i++; if (i == count) break; } /* Verify checksum */ temp = get_char(); if (checksum != temp) { put_char(1); return; } /* Write buffers out to flash */ i = 0; while (1) { cmd_write(0x05, 0x55, 0xaa); /* 0x0555 <- 0xaa */ cmd_write(0x02, 0xaa, 0x55); /* 0x02aa <- 0x55 */ cmd_write(0x05, 0x55, 0xa0); /* 0x0555 <- 0xa0 */ set_address(); datalow = get_buffer(); i++; datahi = get_buffer(); i++; write_data(); if (wait_complete(datalow) == 0) { put_char(2); return; } increment_address(); if (i == count) break; } /* Indicate success */ put_char(0); } /* Reads a block of data from the FLASH */ void read() { get_address_and_count(); /* Read data from flash into buffers */ i = 0; while (1) { set_address(); read_data(); put_buffer(datalow); i++; put_buffer(datahi); i++; increment_address(); if (i == count) break; } /* Write buffers to serial port */ checksum = 0; i = 0; while (1) { temp = get_buffer(); checksum = checksum + temp; if (checksum < temp) checksum++; put_char(temp); i++; if (i == count) break; } /* Write checksum to serial port */ put_char(checksum); } /* Hello command to see if the programmer is alive */ void hello() { get_address_and_count(); put_char(0); } void main() { /* Initialize UART */ pie1 = 0; txsta = TXEN | BRGH; rcsta = SPEN | CREN; sbreg = 10; /* 115200 baud */ adcon1 = ALL_DIGITAL; /* Turn off A/D convertors on PORT A */ datalowdir = INPUT_PORT; /* Set Ports at input/output */ datahidir = INPUT_PORT; controldir = OUTPUT_PORT; addrdir = ADDRDIR; /* Top two bits are UART, so input */ strobedir = OUTPUT_PORT; set_bit(controlport, nCE_BIT); /* Reset chip select lines */ set_bit(controlport, nWE_BIT); set_bit(controlport, nOE_BIT); addrport = 0; /* Reset address/strobe bits */ strobeport = 0; /* Loop executing commands */ while (1) { switch(get_char()) { /* Get command byte */ case 'X': /* Erase flash */ erase(); break; case 'S': /* Erase a sector */ erasesector(); break; case 'R': /* Read a block */ read(); break; case 'W': /* Write a block */ write(); break; case 'H': /* Hello */ hello(); break; case 'I': /* Initialize flash back to read */ initialize(); break; } } } flash/flashpgm.lst0000644000076500007650000027062110053751141014057 0ustar brdbrd00000000000000gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 1 LOC OBJECT CODE LINE SOURCE TEXT VALUE 00001 ; This file was generated by C2C-plus compiler version 3.27.8e 00002 00003 include "p16F877.inc" 00001 ; 00002 ; pic16c84.h 00003 ; 00004 ; definitions for PIC16C84 registers 00005 ; 00006 00007 ; if ~defined(__16C84) & ~defined(__16F84) 00008 ; error "this include file is for PIC16C84" 00009 ; endif 00010 00011 ; Page 0 00000000 00012 IND0 equ 00h 00000000 00013 INDF equ 00h 00000001 00014 TMR0 equ 01h 00000001 00015 RTCC equ TMR0 00000002 00016 PCL equ 02h 00000003 00017 STATUS equ 03h 00000004 00018 FSR equ 04h 00000005 00019 PORTA equ 05h 00000006 00020 PORTB equ 06h 00000008 00021 EEDATA equ 08h 00000009 00022 EEADR equ 09h 0000000A 00023 PCLATH equ 0ah 0000000B 00024 INTCON equ 0bh 00025 00026 ; Page 1 00027 00000001 00028 OPTIO equ 01h 00000005 00029 TRISA equ 05h 00000006 00030 TRISB equ 06h 00000008 00031 EECON1 equ 08h 00000009 00032 EECON2 equ 09h 00033 00034 ; 00035 ; STATUS bits 00036 ; 00000007 00037 IRP equ 07h 00000006 00038 RP1 equ 06h 00000005 00039 RP0 equ 05h 00000004 00040 TO equ 04h 00000003 00041 PD equ 03h 00000002 00042 Z equ 02h 00000001 00043 DC equ 01h 00000000 00044 C equ 00h 00045 00046 ; 00047 ; INTCON bits 00048 ; 00000007 00049 GIE equ 7 00000006 00050 EEIE equ 6 00000005 00051 RTIE equ 5 gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 2 LOC OBJECT CODE LINE SOURCE TEXT VALUE 00000005 00052 TOIE equ 5 00000004 00053 INTE equ 4 00000003 00054 RBIE equ 3 00000002 00055 T0IF equ 2 00000002 00056 RTIF equ 2 00000001 00057 INTF equ 1 00000000 00058 RBIF equ 0 00059 00060 ; 00061 ; OPTION bits 00062 ; 00000007 00063 RBPU equ 7 00000006 00064 INTEDG equ 6 00000005 00065 RTS equ 5 00000004 00066 RTE equ 4 00000003 00067 PSA equ 3 00000002 00068 PS2 equ 2 00000001 00069 PS1 equ 1 00000000 00070 PS0 equ 0 00071 00072 ; 00073 ; EECON1 bits 00074 ; 00000004 00075 EEIF equ 4 00000003 00076 WRERR equ 3 00000002 00077 WREN equ 2 00000001 00078 EWR equ 1 00000000 00079 ERD equ 0 00080 00081 ; 00082 ; 'direction' flags 00083 ; 00000000 00084 W equ 0 00000001 00085 F equ 1 00086 00087 ;========================================================================== 00088 ; 00089 ; Configuration Bits 00090 ;========================================================================== 00091 00003FEF 00092 _CP_ON EQU 0x3FEF 00003FFF 00093 _CP_OFF EQU 0x3FFF 00003FFF 00094 _PWRTE_ON EQU 0x3FFF 00003FF7 00095 _PWRTE_OFF EQU 0x3FF7 00003FFF 00096 _WDT_ON EQU 0x3FFF 00003FFB 00097 _WDT_OFF EQU 0x3FFB 00003FFC 00098 _LP_OSC EQU 0x3FFC 00003FFD 00099 _XT_OSC EQU 0x3FFD 00003FFE 00100 _HS_OSC EQU 0x3FFE 00003FFF 00101 _RC_OSC EQU 0x3FFF 00102 00103 00004 ;Variables ***************************************** 00000070 00005 _code_tmp_0000 equ 0x70 gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 3 LOC OBJECT CODE LINE SOURCE TEXT VALUE 00000071 00006 _code_tmp_0001 equ 0x71 00000072 00007 _addrlow equ 0x72 00000073 00008 _addrmed equ 0x73 00000074 00009 _addrhi equ 0x74 00000075 00010 _datalow equ 0x75 00000076 00011 _datahi equ 0x76 00000077 00012 _i equ 0x77 00000078 00013 _count equ 0x78 00000079 00014 _checksum equ 0x79 0000007A 00015 _temp equ 0x7a 0000007B 00016 param00_cmd_write equ 0x7b 0000007C 00017 param01_cmd_write equ 0x7c 0000007D 00018 param02_cmd_write equ 0x7d 0000007E 00019 param00_put_char equ 0x7e 0000007F 00020 param00_put_buffer equ 0x7f 00000020 00021 param00_wait_complete equ 0x20 000000A0 00022 _buffer1 equ 0xa0 00000110 00023 _buffer2 equ 0x110 00000190 00024 _buffer3 equ 0x190 00000021 00025 _buffer4 equ 0x21 00000099 00026 _sbreg equ 0x99 00000098 00027 _txsta equ 0x98 00000018 00028 _rcsta equ 0x18 00000019 00029 _txreg equ 0x19 0000001A 00030 _rcreg equ 0x1a 0000000C 00031 _pir1 equ 0x0c 0000009F 00032 _adcon1 equ 0x9f 0000008C 00033 _pie1 equ 0x8c 00000005 00034 _strobeport equ 0x05 00000085 00035 _strobedir equ 0x85 00000006 00036 _datalowport equ 0x06 00000086 00037 _datalowdir equ 0x86 00000007 00038 _addrport equ 0x07 00000087 00039 _addrdir equ 0x87 00000008 00040 _datahiport equ 0x08 00000088 00041 _datahidir equ 0x88 00000009 00042 _controlport equ 0x09 00000089 00043 _controldir equ 0x89 0000 00044 ORG 0 0000 018A 00045 clrf PCLATH 0001 2813 00046 goto start__code 0002 00047 _set_address 0002 2863 00048 goto _set_address__code 0003 00049 _read_data 0003 28A8 00050 goto _read_data__code 0004 00051 _write_data 0004 28B9 00052 goto _write_data__code 0005 00053 _cmd_write 0005 28D4 00054 goto _cmd_write__code 0006 00055 _get_char 0006 2913 00056 goto _get_char__code 0007 00057 _put_char 0007 291F 00058 goto _put_char__code 0008 00059 _increment_address gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 4 LOC OBJECT CODE LINE SOURCE TEXT VALUE 0008 292C 00060 goto _increment_address__code 0009 00061 _get_address_and_count 0009 2938 00062 goto _get_address_and_count__code 000A 00063 _get_buffer 000A 294F 00064 goto _get_buffer__code 000B 00065 _put_buffer 000B 2976 00066 goto _put_buffer__code 000C 00067 _wait_complete 000C 29A9 00068 goto _wait_complete__code 000D 00069 _initialize 000D 29D3 00070 goto _initialize__code 000E 00071 _erase 000E 29E5 00072 goto _erase__code 000F 00073 _erasesector 000F 2A34 00074 goto _erasesector__code 0010 00075 _write 0010 2A83 00076 goto _write__code 0011 00077 _read 0011 2AFC 00078 goto _read__code 0012 00079 _hello 0012 2B3E 00080 goto _hello__code 0013 00081 start__code 00082 ;;;;;;;;char sbreg@0x99; 00083 ;;;;;;;; 00084 ;;;;;;;;char txsta@0x98; 00085 ;;;;;;;;#define TXEN 0x20 00086 ;;;;;;;;#define BRGH 0x04 00087 ;;;;;;;; 00088 ;;;;;;;;char rcsta@0x18; 00089 ;;;;;;;;#define SPEN 0x80 00090 ;;;;;;;;#define CREN 0x10 00091 ;;;;;;;; 00092 ;;;;;;;;char txreg@0x19; 00093 ;;;;;;;; 00094 ;;;;;;;;char rcreg@0x1a; 00095 ;;;;;;;; 00096 ;;;;;;;;char pir1@0x0c; 00097 ;;;;;;;;#define RCIF 0x20 00098 ;;;;;;;;#define TXIF 0x10 00099 ;;;;;;;; 00100 ;;;;;;;;char adcon1@0x9f; 00101 ;;;;;;;;#define ALL_DIGITAL 0x6 00102 ;;;;;;;; 00103 ;;;;;;;;char pie1@0x8c; 00104 ;;;;;;;; 00105 ;;;;;;;;/* PORT A */ 00106 ;;;;;;;; 00107 ;;;;;;;;char strobeport@0x05; /* Only has 6 bits */ 00108 ;;;;;;;;char strobedir@0x85; 00109 ;;;;;;;;#define STROBELOW 4 00110 ;;;;;;;;#define STROBEMED 3 00111 ;;;;;;;;#define STROBEHI 2 00112 ;;;;;;;; 00113 ;;;;;;;;/* PORT B */ gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 5 LOC OBJECT CODE LINE SOURCE TEXT VALUE 00114 ;;;;;;;; 00115 ;;;;;;;;char datalowport@0x06; /* Has 8 bits */ 00116 ;;;;;;;;char datalowdir@0x86; 00117 ;;;;;;;; 00118 ;;;;;;;;/* PORT C */ 00119 ;;;;;;;; 00120 ;;;;;;;;char addrport@0x07; /* has 6 bits (top 2 are UART bits) */ 00121 ;;;;;;;;char addrdir@0x87; 00122 ;;;;;;;;#define ADDRDIR 0xc0; /* Top two bits set to input (UART bits) */ 00123 ;;;;;;;; 00124 ;;;;;;;;/* Port D */ 00125 ;;;;;;;; 00126 ;;;;;;;;char datahiport@0x08; /* Bidirectional 8 bit port for data */ 00127 ;;;;;;;;char datahidir@0x88; 00128 ;;;;;;;; 00129 ;;;;;;;;/* Port E */ 00130 ;;;;;;;; 00131 ;;;;;;;;char controlport@0x09; /* Only has 3 bits */ 00132 ;;;;;;;;#define nCE_BIT 0 /* not Chip Enable */ 00133 ;;;;;;;;#define nOE_BIT 1 /* not Output Enable */ 00134 ;;;;;;;;#define nWE_BIT 2 /* not Write Enable */ 00135 ;;;;;;;;char controldir@0x89; 00136 ;;;;;;;; 00137 ;;;;;;;;#define INPUT_PORT 0xff 00138 ;;;;;;;;#define OUTPUT_PORT 0x00 00139 ;;;;;;;; 00140 ;;;;;;;;char addrlow, addrmed, addrhi; 00141 ;;;;;;;;char datalow, datahi; 00142 ;;;;;;;; 00143 ;;;;;;;; 00144 ;;;;;;;;/* Buffer sizes are picked so that they fit 00145 ;;;;;;;; in the banks of 80 registers */ 00146 ;;;;;;;;char buffer1[80]; 00147 ;;;;;;;;char buffer2[80]; 00148 ;;;;;;;;char buffer3[80]; 00149 ;;;;;;;;char buffer4[16]; 00150 ;;;;;;;;char i; 00151 ;;;;;;;;char count; 00152 ;;;;;;;; 00153 ;;;;;;;;char checksum; 00154 ;;;;;;;;char temp; 00155 ;;;;;;;; 00156 ;;;;;;;; 00157 ;;;;;;;; 00158 ;;;;;;;;void main() { 0013 00159 _main__code 00160 ;;;;;;;; 00161 ;;;;;;;; /* Initialize UART */ 00162 ;;;;;;;; 00163 ;;;;;;;; pie1 = 0; 0013 1683 00164 bsf STATUS, RP0 0014 1303 00165 bcf STATUS, RP1 Message [302] : Register in operand not in bank 0. Ensure bank bits are correct. 0015 018C 00166 clrf _pie1 gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 6 LOC OBJECT CODE LINE SOURCE TEXT VALUE 00167 ;;;;;;;; txsta = TXEN | BRGH; 0016 3024 00168 movlw D'36' Message [302] : Register in operand not in bank 0. Ensure bank bits are correct. 0017 0098 00169 movwf _txsta 00170 ;;;;;;;; rcsta = SPEN | CREN; 0018 3090 00171 movlw D'144' 0019 1283 00172 bcf STATUS, RP0 001A 0098 00173 movwf _rcsta 00174 ;;;;;;;; sbreg = 10; /* 115200 baud */ 001B 300A 00175 movlw D'10' 001C 1683 00176 bsf STATUS, RP0 Message [302] : Register in operand not in bank 0. Ensure bank bits are correct. 001D 0099 00177 movwf _sbreg 00178 ;;;;;;;; 00179 ;;;;;;;; adcon1 = ALL_DIGITAL; /* Turn off A/D convertors on PORT A */ 001E 3006 00180 movlw D'6' Message [302] : Register in operand not in bank 0. Ensure bank bits are correct. 001F 009F 00181 movwf _adcon1 00182 ;;;;;;;; 00183 ;;;;;;;; datalowdir = INPUT_PORT; /* Set Ports at input/output */ 0020 30FF 00184 movlw D'255' Message [302] : Register in operand not in bank 0. Ensure bank bits are correct. 0021 0086 00185 movwf _datalowdir 00186 ;;;;;;;; datahidir = INPUT_PORT; 0022 30FF 00187 movlw D'255' Message [302] : Register in operand not in bank 0. Ensure bank bits are correct. 0023 0088 00188 movwf _datahidir 00189 ;;;;;;;; controldir = OUTPUT_PORT; Message [302] : Register in operand not in bank 0. Ensure bank bits are correct. 0024 0189 00190 clrf _controldir 00191 ;;;;;;;; 00192 ;;;;;;;; addrdir = ADDRDIR; /* Top two bits are UART, so input */ 0025 30C0 00193 movlw D'192' Message [302] : Register in operand not in bank 0. Ensure bank bits are correct. 0026 0087 00194 movwf _addrdir 00195 ;;;;;;;; strobedir = OUTPUT_PORT; Message [302] : Register in operand not in bank 0. Ensure bank bits are correct. 0027 0185 00196 clrf _strobedir 00197 ;;;;;;;; 00198 ;;;;;;;; set_bit(controlport, nCE_BIT); /* Reset chip select lines */ 0028 1283 00199 bcf STATUS, RP0 0029 1409 00200 bsf _controlport, D'0' 00201 ;;;;;;;; set_bit(controlport, nWE_BIT); 002A 1509 00202 bsf _controlport, D'2' 00203 ;;;;;;;; set_bit(controlport, nOE_BIT); 002B 1489 00204 bsf _controlport, D'1' 00205 ;;;;;;;; 00206 ;;;;;;;; addrport = 0; /* Reset address/strobe bits */ 002C 0187 00207 clrf _addrport 00208 ;;;;;;;; strobeport = 0; 002D 0185 00209 clrf _strobeport 00210 ;;;;;;;; 00211 ;;;;;;;; /* Loop executing commands */ 00212 ;;;;;;;; gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 7 LOC OBJECT CODE LINE SOURCE TEXT VALUE 00213 ;;;;;;;; while (1) { 002E 00214 label_0038 00215 ;;;;;;;; 00216 ;;;;;;;; switch(get_char()) { /* Get command byte */ 002E 2006 00217 call _get_char 002F 118A 00218 bcf PCLATH, 3 0030 120A 00219 bcf PCLATH, 4 0031 00F0 00220 movwf _code_tmp_0000 00221 ;;;;;;;; 00222 ;;;;;;;; case 'X': /* Erase flash */ 0032 0870 00223 movf _code_tmp_0000 , W 0033 3C58 00224 sublw D'88' 0034 1D03 00225 btfss STATUS, Z 0035 283A 00226 goto label_0041 00227 ;;;;;;;; erase(); 0036 00228 label_0042 0036 200E 00229 call _erase 0037 118A 00230 bcf PCLATH, 3 0038 120A 00231 bcf PCLATH, 4 00232 ;;;;;;;; break; 0039 2862 00233 goto label_0040 00234 ;;;;;;;; case 'S': /* Erase a sector */ 003A 00235 label_0041 003A 0870 00236 movf _code_tmp_0000 , W 003B 3C53 00237 sublw D'83' 003C 1D03 00238 btfss STATUS, Z 003D 2842 00239 goto label_0043 00240 ;;;;;;;; erasesector(); 003E 00241 label_0044 003E 200F 00242 call _erasesector 003F 118A 00243 bcf PCLATH, 3 0040 120A 00244 bcf PCLATH, 4 00245 ;;;;;;;; break; 0041 2862 00246 goto label_0040 00247 ;;;;;;;; case 'R': /* Read a block */ 0042 00248 label_0043 0042 0870 00249 movf _code_tmp_0000 , W 0043 3C52 00250 sublw D'82' 0044 1D03 00251 btfss STATUS, Z 0045 284A 00252 goto label_0045 00253 ;;;;;;;; read(); 0046 00254 label_0046 0046 2011 00255 call _read 0047 118A 00256 bcf PCLATH, 3 0048 120A 00257 bcf PCLATH, 4 00258 ;;;;;;;; break; 0049 2862 00259 goto label_0040 00260 ;;;;;;;; case 'W': /* Write a block */ 004A 00261 label_0045 004A 0870 00262 movf _code_tmp_0000 , W 004B 3C57 00263 sublw D'87' 004C 1D03 00264 btfss STATUS, Z 004D 2852 00265 goto label_0047 00266 ;;;;;;;; write(); gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 8 LOC OBJECT CODE LINE SOURCE TEXT VALUE 004E 00267 label_0048 004E 2010 00268 call _write 004F 118A 00269 bcf PCLATH, 3 0050 120A 00270 bcf PCLATH, 4 00271 ;;;;;;;; break; 0051 2862 00272 goto label_0040 00273 ;;;;;;;; case 'H': /* Hello */ 0052 00274 label_0047 0052 0870 00275 movf _code_tmp_0000 , W 0053 3C48 00276 sublw D'72' 0054 1D03 00277 btfss STATUS, Z 0055 285A 00278 goto label_0049 00279 ;;;;;;;; hello(); 0056 00280 label_0050 0056 2012 00281 call _hello 0057 118A 00282 bcf PCLATH, 3 0058 120A 00283 bcf PCLATH, 4 00284 ;;;;;;;; break; 0059 2862 00285 goto label_0040 00286 ;;;;;;;; case 'I': /* Initialize flash back to read */ 005A 00287 label_0049 005A 0870 00288 movf _code_tmp_0000 , W 005B 3C49 00289 sublw D'73' 005C 1D03 00290 btfss STATUS, Z 005D 2862 00291 goto label_0051 00292 ;;;;;;;; initialize(); 005E 00293 label_0052 005E 200D 00294 call _initialize 005F 118A 00295 bcf PCLATH, 3 0060 120A 00296 bcf PCLATH, 4 00297 ;;;;;;;; break; 0061 2862 00298 goto label_0040 00299 ;;;;;;;; } 0062 00300 label_0051 00301 ;;;;;;;; } 0062 00302 label_0040 00303 ;;;;;;;;} 0062 282E 00304 goto label_0038 0063 00305 label_0039 0063 00306 _main__end 00307 ;;;;;;;; 00308 ;;;;;;;;/* Set the address latches from the address in [addrhi, addrmed, addrlow] */ 00309 ;;;;;;;; 00310 ;;;;;;;;void set_address() { 0063 00311 _set_address__code 00312 ;;;;;;;; addrport = addrhi & 0x3f; 0063 0874 00313 movf _addrhi, W 0064 393F 00314 andlw D'63' 0065 1283 00315 bcf STATUS, RP0 0066 1303 00316 bcf STATUS, RP1 0067 0087 00317 movwf _addrport 00318 ;;;;;;;; strobeport = (addrhi >> 6) & 0x3; 0068 0874 00319 movf _addrhi, W 0069 00F1 00320 movwf _code_tmp_0001 gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 9 LOC OBJECT CODE LINE SOURCE TEXT VALUE 006A 0CF1 00321 rrf _code_tmp_0001 , F 006B 0CF1 00322 rrf _code_tmp_0001 , F 006C 0CF1 00323 rrf _code_tmp_0001 , F 006D 0CF1 00324 rrf _code_tmp_0001 , F 006E 0CF1 00325 rrf _code_tmp_0001 , F 006F 0C71 00326 rrf _code_tmp_0001 , W 0070 3903 00327 andlw D'3' 0071 3903 00328 andlw D'3' 0072 0085 00329 movwf _strobeport 00330 ;;;;;;;; nop(); nop(); nop(); 0073 0000 00331 nop 0074 0000 00332 nop 0075 0000 00333 nop 00334 ;;;;;;;; set_bit(strobeport, STROBEHI); 0076 1505 00335 bsf _strobeport, D'2' 00336 ;;;;;;;; nop(); nop(); nop(); 0077 0000 00337 nop 0078 0000 00338 nop 0079 0000 00339 nop 00340 ;;;;;;;; clear_bit(strobeport, STROBEHI); 007A 1105 00341 bcf _strobeport, D'2' 00342 ;;;;;;;; 00343 ;;;;;;;; addrport = addrmed & 0x3f; 007B 0873 00344 movf _addrmed, W 007C 393F 00345 andlw D'63' 007D 0087 00346 movwf _addrport 00347 ;;;;;;;; strobeport = (addrmed >> 6) & 0x3; 007E 0873 00348 movf _addrmed, W 007F 00F1 00349 movwf _code_tmp_0001 0080 0CF1 00350 rrf _code_tmp_0001 , F 0081 0CF1 00351 rrf _code_tmp_0001 , F 0082 0CF1 00352 rrf _code_tmp_0001 , F 0083 0CF1 00353 rrf _code_tmp_0001 , F 0084 0CF1 00354 rrf _code_tmp_0001 , F 0085 0C71 00355 rrf _code_tmp_0001 , W 0086 3903 00356 andlw D'3' 0087 3903 00357 andlw D'3' 0088 0085 00358 movwf _strobeport 00359 ;;;;;;;; nop(); nop(); nop(); 0089 0000 00360 nop 008A 0000 00361 nop 008B 0000 00362 nop 00363 ;;;;;;;; set_bit(strobeport, STROBEMED); 008C 1585 00364 bsf _strobeport, D'3' 00365 ;;;;;;;; nop(); nop(); nop(); 008D 0000 00366 nop 008E 0000 00367 nop 008F 0000 00368 nop 00369 ;;;;;;;; clear_bit(strobeport, STROBEMED); 0090 1185 00370 bcf _strobeport, D'3' 00371 ;;;;;;;; 00372 ;;;;;;;; addrport = addrlow & 0x3f; 0091 0872 00373 movf _addrlow, W 0092 393F 00374 andlw D'63' gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 10 LOC OBJECT CODE LINE SOURCE TEXT VALUE 0093 0087 00375 movwf _addrport 00376 ;;;;;;;; strobeport = (addrlow >> 6) & 0x3; 0094 0872 00377 movf _addrlow, W 0095 00F1 00378 movwf _code_tmp_0001 0096 0CF1 00379 rrf _code_tmp_0001 , F 0097 0CF1 00380 rrf _code_tmp_0001 , F 0098 0CF1 00381 rrf _code_tmp_0001 , F 0099 0CF1 00382 rrf _code_tmp_0001 , F 009A 0CF1 00383 rrf _code_tmp_0001 , F 009B 0C71 00384 rrf _code_tmp_0001 , W 009C 3903 00385 andlw D'3' 009D 3903 00386 andlw D'3' 009E 0085 00387 movwf _strobeport 00388 ;;;;;;;; nop(); nop(); nop(); 009F 0000 00389 nop 00A0 0000 00390 nop 00A1 0000 00391 nop 00392 ;;;;;;;; set_bit(strobeport, STROBELOW); 00A2 1605 00393 bsf _strobeport, D'4' 00394 ;;;;;;;; nop(); nop(); nop(); 00A3 0000 00395 nop 00A4 0000 00396 nop 00A5 0000 00397 nop 00398 ;;;;;;;; clear_bit(strobeport, STROBELOW); 00A6 1205 00399 bcf _strobeport, D'4' 00400 ;;;;;;;;} 00A7 0008 00401 return 00A8 00402 _set_address__end 00403 ;;;;;;;; 00404 ;;;;;;;;/* Read from the FLASH. Result in [datahi, datalow] */ 00405 ;;;;;;;; 00406 ;;;;;;;;void read_data() { 00A8 00407 _read_data__code 00408 ;;;;;;;; clear_bit(controlport, nCE_BIT); 00A8 1283 00409 bcf STATUS, RP0 00A9 1303 00410 bcf STATUS, RP1 00AA 1009 00411 bcf _controlport, D'0' 00412 ;;;;;;;; clear_bit(controlport, nOE_BIT); 00AB 1089 00413 bcf _controlport, D'1' 00414 ;;;;;;;; nop(); nop(); nop(); 00AC 0000 00415 nop 00AD 0000 00416 nop 00AE 0000 00417 nop 00418 ;;;;;;;; datalow = datalowport; 00AF 0806 00419 movf _datalowport, W 00B0 00F5 00420 movwf _datalow 00421 ;;;;;;;; datahi = datahiport; 00B1 0808 00422 movf _datahiport, W 00B2 00F6 00423 movwf _datahi 00424 ;;;;;;;; nop(); nop(); nop(); 00B3 0000 00425 nop 00B4 0000 00426 nop 00B5 0000 00427 nop 00428 ;;;;;;;; set_bit(controlport, nOE_BIT); gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 11 LOC OBJECT CODE LINE SOURCE TEXT VALUE 00B6 1489 00429 bsf _controlport, D'1' 00430 ;;;;;;;; set_bit(controlport, nCE_BIT); 00B7 1409 00431 bsf _controlport, D'0' 00432 ;;;;;;;;} 00B8 0008 00433 return 00B9 00434 _read_data__end 00435 ;;;;;;;; 00436 ;;;;;;;;/* Write to the FLASH. Data to be stored in [datahi, datalow] */ 00437 ;;;;;;;; 00438 ;;;;;;;;void write_data() { 00B9 00439 _write_data__code 00440 ;;;;;;;; datalowdir = OUTPUT_PORT; 00B9 1683 00441 bsf STATUS, RP0 00BA 1303 00442 bcf STATUS, RP1 Message [302] : Register in operand not in bank 0. Ensure bank bits are correct. 00BB 0186 00443 clrf _datalowdir 00444 ;;;;;;;; datahidir = OUTPUT_PORT; Message [302] : Register in operand not in bank 0. Ensure bank bits are correct. 00BC 0188 00445 clrf _datahidir 00446 ;;;;;;;; datalowport = datalow; 00BD 0875 00447 movf _datalow, W 00BE 1283 00448 bcf STATUS, RP0 00BF 0086 00449 movwf _datalowport 00450 ;;;;;;;; datahiport = datahi; 00C0 0876 00451 movf _datahi, W 00C1 0088 00452 movwf _datahiport 00453 ;;;;;;;; nop(); nop(); nop(); nop(); 00C2 0000 00454 nop 00C3 0000 00455 nop 00C4 0000 00456 nop 00C5 0000 00457 nop 00458 ;;;;;;;; clear_bit(controlport, nCE_BIT); 00C6 1009 00459 bcf _controlport, D'0' 00460 ;;;;;;;; clear_bit(controlport, nWE_BIT); 00C7 1109 00461 bcf _controlport, D'2' 00462 ;;;;;;;; nop(); nop(); nop(); nop(); 00C8 0000 00463 nop 00C9 0000 00464 nop 00CA 0000 00465 nop 00CB 0000 00466 nop 00467 ;;;;;;;; set_bit(controlport, nWE_BIT); 00CC 1509 00468 bsf _controlport, D'2' 00469 ;;;;;;;; set_bit(controlport, nCE_BIT); 00CD 1409 00470 bsf _controlport, D'0' 00471 ;;;;;;;; datalowdir = INPUT_PORT; 00CE 30FF 00472 movlw D'255' 00CF 1683 00473 bsf STATUS, RP0 Message [302] : Register in operand not in bank 0. Ensure bank bits are correct. 00D0 0086 00474 movwf _datalowdir 00475 ;;;;;;;; datahidir = INPUT_PORT; 00D1 30FF 00476 movlw D'255' Message [302] : Register in operand not in bank 0. Ensure bank bits are correct. 00D2 0088 00477 movwf _datahidir 00478 ;;;;;;;;} gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 12 LOC OBJECT CODE LINE SOURCE TEXT VALUE 00D3 0008 00479 return 00D4 00480 _write_data__end 00481 ;;;;;;;; 00482 ;;;;;;;;/* Write a command to a particular address */ 00483 ;;;;;;;;/* This routine doesn't clobber the [addrhi, addrmed, addrlo] registers */ 00484 ;;;;;;;; 00485 ;;;;;;;;void cmd_write(char amed, char alow, char dlow) { 00D4 00486 _cmd_write__code 00487 ;;;;;;;; addrport = 0; /* Addrhi is always zero */ 00D4 1283 00488 bcf STATUS, RP0 00D5 1303 00489 bcf STATUS, RP1 00D6 0187 00490 clrf _addrport 00491 ;;;;;;;; strobeport = 0; 00D7 0185 00492 clrf _strobeport 00493 ;;;;;;;; nop(); nop(); nop(); 00D8 0000 00494 nop 00D9 0000 00495 nop 00DA 0000 00496 nop 00497 ;;;;;;;; set_bit(strobeport, STROBEHI); 00DB 1505 00498 bsf _strobeport, D'2' 00499 ;;;;;;;; nop(); nop(); nop(); 00DC 0000 00500 nop 00DD 0000 00501 nop 00DE 0000 00502 nop 00503 ;;;;;;;; clear_bit(strobeport, STROBEHI); 00DF 1105 00504 bcf _strobeport, D'2' 00505 ;;;;;;;; 00506 ;;;;;;;; addrport = amed & 0x3f; 00E0 087B 00507 movf param00_cmd_write, W 00E1 393F 00508 andlw D'63' 00E2 0087 00509 movwf _addrport 00510 ;;;;;;;; strobeport = (amed >> 6) & 0x3; 00E3 087B 00511 movf param00_cmd_write, W 00E4 00F1 00512 movwf _code_tmp_0001 00E5 0CF1 00513 rrf _code_tmp_0001 , F 00E6 0CF1 00514 rrf _code_tmp_0001 , F 00E7 0CF1 00515 rrf _code_tmp_0001 , F 00E8 0CF1 00516 rrf _code_tmp_0001 , F 00E9 0CF1 00517 rrf _code_tmp_0001 , F 00EA 0C71 00518 rrf _code_tmp_0001 , W 00EB 3903 00519 andlw D'3' 00EC 3903 00520 andlw D'3' 00ED 0085 00521 movwf _strobeport 00522 ;;;;;;;; nop(); nop(); nop(); 00EE 0000 00523 nop 00EF 0000 00524 nop 00F0 0000 00525 nop 00526 ;;;;;;;; set_bit(strobeport, STROBEMED); 00F1 1585 00527 bsf _strobeport, D'3' 00528 ;;;;;;;; nop(); nop(); nop(); 00F2 0000 00529 nop 00F3 0000 00530 nop 00F4 0000 00531 nop 00532 ;;;;;;;; clear_bit(strobeport, STROBEMED); gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 13 LOC OBJECT CODE LINE SOURCE TEXT VALUE 00F5 1185 00533 bcf _strobeport, D'3' 00534 ;;;;;;;; 00535 ;;;;;;;; addrport = alow & 0x3f; 00F6 087C 00536 movf param01_cmd_write, W 00F7 393F 00537 andlw D'63' 00F8 0087 00538 movwf _addrport 00539 ;;;;;;;; strobeport = (alow >> 6) & 0x3; 00F9 087C 00540 movf param01_cmd_write, W 00FA 00F1 00541 movwf _code_tmp_0001 00FB 0CF1 00542 rrf _code_tmp_0001 , F 00FC 0CF1 00543 rrf _code_tmp_0001 , F 00FD 0CF1 00544 rrf _code_tmp_0001 , F 00FE 0CF1 00545 rrf _code_tmp_0001 , F 00FF 0CF1 00546 rrf _code_tmp_0001 , F 0100 0C71 00547 rrf _code_tmp_0001 , W 0101 3903 00548 andlw D'3' 0102 3903 00549 andlw D'3' 0103 0085 00550 movwf _strobeport 00551 ;;;;;;;; nop(); nop(); nop(); 0104 0000 00552 nop 0105 0000 00553 nop 0106 0000 00554 nop 00555 ;;;;;;;; set_bit(strobeport, STROBELOW); 0107 1605 00556 bsf _strobeport, D'4' 00557 ;;;;;;;; nop(); nop(); nop(); 0108 0000 00558 nop 0109 0000 00559 nop 010A 0000 00560 nop 00561 ;;;;;;;; clear_bit(strobeport, STROBELOW); 010B 1205 00562 bcf _strobeport, D'4' 00563 ;;;;;;;; 00564 ;;;;;;;; datahi = 0; /* Data hi is always zero */ 010C 01F6 00565 clrf _datahi 00566 ;;;;;;;; datalow = dlow; 010D 087D 00567 movf param02_cmd_write, W 010E 00F5 00568 movwf _datalow 00569 ;;;;;;;; write_data(); 010F 2004 00570 call _write_data 0110 118A 00571 bcf PCLATH, 3 0111 120A 00572 bcf PCLATH, 4 00573 ;;;;;;;;} 0112 0008 00574 return 0113 00575 _cmd_write__end 00576 ;;;;;;;; 00577 ;;;;;;;;/* Get a character from UART */ 00578 ;;;;;;;; 00579 ;;;;;;;;char get_char() { 0113 00580 _get_char__code 00581 ;;;;;;;; while ((pir1 & RCIF) == 0) ; 0113 00582 label_0000 0113 1283 00583 bcf STATUS, RP0 0114 1303 00584 bcf STATUS, RP1 0115 080C 00585 movf _pir1, W 0116 3920 00586 andlw D'32' gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 14 LOC OBJECT CODE LINE SOURCE TEXT VALUE 0117 3C00 00587 sublw D'0' 0118 1D03 00588 btfss STATUS, Z 0119 291B 00589 goto label_0001 00590 ;;;;;;;; return rcreg; 011A 2913 00591 goto label_0000 011B 00592 label_0001 011B 1283 00593 bcf STATUS, RP0 011C 1303 00594 bcf STATUS, RP1 011D 081A 00595 movf _rcreg, W 011E 0008 00596 return 00597 ;;;;;;;;} 011F 00598 _get_char__end 00599 ;;;;;;;; 00600 ;;;;;;;;/* Put a character to UART */ 00601 ;;;;;;;; 00602 ;;;;;;;;void put_char(char v) { 011F 00603 _put_char__code 00604 ;;;;;;;; while ((pir1 & TXIF) == 0) ; 011F 00605 label_0002 011F 1283 00606 bcf STATUS, RP0 0120 1303 00607 bcf STATUS, RP1 0121 080C 00608 movf _pir1, W 0122 3910 00609 andlw D'16' 0123 3C00 00610 sublw D'0' 0124 1D03 00611 btfss STATUS, Z 0125 2927 00612 goto label_0003 00613 ;;;;;;;; txreg = v; 0126 291F 00614 goto label_0002 0127 00615 label_0003 0127 087E 00616 movf param00_put_char, W 0128 1283 00617 bcf STATUS, RP0 0129 1303 00618 bcf STATUS, RP1 012A 0099 00619 movwf _txreg 00620 ;;;;;;;;} 012B 0008 00621 return 012C 00622 _put_char__end 00623 ;;;;;;;; 00624 ;;;;;;;;/* Increment [addrhi, addrmed, addrlow] as 24 bit quantity */ 00625 ;;;;;;;; 00626 ;;;;;;;;void increment_address() { 012C 00627 _increment_address__code 00628 ;;;;;;;; if (++addrlow == 0) 012C 0AF2 00629 incf _addrlow, F 012D 0872 00630 movf _addrlow, W 012E 3C00 00631 sublw D'0' 012F 1D03 00632 btfss STATUS, Z 0130 2937 00633 goto label_0004 00634 ;;;;;;;; if (++addrmed == 0) 0131 0AF3 00635 incf _addrmed, F 0132 0873 00636 movf _addrmed, W 0133 3C00 00637 sublw D'0' 0134 1D03 00638 btfss STATUS, Z 0135 2937 00639 goto label_0005 00640 ;;;;;;;; ++addrhi; gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 15 LOC OBJECT CODE LINE SOURCE TEXT VALUE 0136 0AF4 00641 incf _addrhi, F 00642 ;;;;;;;;} 0137 00643 label_0005 0137 00644 label_0004 0137 0008 00645 return 0138 00646 _increment_address__end 00647 ;;;;;;;; 00648 ;;;;;;;;/* Reads 4 characters into [addrhi, addrmed, addrlow] and count */ 00649 ;;;;;;;;/* Count is multiplied by two to be in bytes (0 == 256) */ 00650 ;;;;;;;; 00651 ;;;;;;;;void get_address_and_count() { 0138 00652 _get_address_and_count__code 00653 ;;;;;;;; count = get_char(); /* Count = 1 to 128 */ 0138 2006 00654 call _get_char 0139 118A 00655 bcf PCLATH, 3 013A 120A 00656 bcf PCLATH, 4 013B 00F8 00657 movwf _count 00658 ;;;;;;;; count = count + count; /* Double count */ 013C 01F1 00659 clrf _code_tmp_0001 013D 0878 00660 movf _count, W 013E 0778 00661 addwf _count, W 013F 1803 00662 btfsc STATUS, C 0140 0AF1 00663 incf _code_tmp_0001 , F 0141 00F8 00664 movwf _count 00665 ;;;;;;;; 00666 ;;;;;;;; addrhi = get_char(); /* Addr from 0 -> 512K (19 bits) */ 0142 2006 00667 call _get_char 0143 118A 00668 bcf PCLATH, 3 0144 120A 00669 bcf PCLATH, 4 0145 00F4 00670 movwf _addrhi 00671 ;;;;;;;; addrmed = get_char(); /* MSB first! */ 0146 2006 00672 call _get_char 0147 118A 00673 bcf PCLATH, 3 0148 120A 00674 bcf PCLATH, 4 0149 00F3 00675 movwf _addrmed 00676 ;;;;;;;; addrlow = get_char(); 014A 2006 00677 call _get_char 014B 118A 00678 bcf PCLATH, 3 014C 120A 00679 bcf PCLATH, 4 014D 00F2 00680 movwf _addrlow 00681 ;;;;;;;; 00682 ;;;;;;;;} 014E 0008 00683 return 014F 00684 _get_address_and_count__end 00685 ;;;;;;;; 00686 ;;;;;;;;/* Get the next character from the buffer. */ 00687 ;;;;;;;;/* The buffer is made up of three smaller buffers so that */ 00688 ;;;;;;;;/* it fits in the PIC registers. */ 00689 ;;;;;;;; 00690 ;;;;;;;;/* The global variable 'i' contains the offset into the buffer. */ 00691 ;;;;;;;; 00692 ;;;;;;;;char get_buffer() { 014F 00693 _get_buffer__code 00694 ;;;;;;;; if (i < 80) gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 16 LOC OBJECT CODE LINE SOURCE TEXT VALUE 014F 3050 00695 movlw D'80' 0150 0277 00696 subwf _i, W 0151 1803 00697 btfsc STATUS, C 0152 2959 00698 goto label_0006 00699 ;;;;;;;; return buffer1[i]; 0153 0877 00700 movf _i, W 0154 3EA0 00701 addlw _buffer1 0155 0084 00702 movwf FSR 0156 1383 00703 bcf STATUS, IRP 0157 0800 00704 movf INDF, W 0158 0008 00705 return 00706 ;;;;;;;; if (i < 160) 0159 00707 label_0006 0159 30A0 00708 movlw D'160' 015A 0277 00709 subwf _i, W 015B 1803 00710 btfsc STATUS, C 015C 2964 00711 goto label_0007 00712 ;;;;;;;; return buffer2[i-80]; 015D 3050 00713 movlw D'80' 015E 0277 00714 subwf _i, W Warning [202] : Argument out of range. Least significant bits used. 015F 3E10 00715 addlw _buffer2 0160 0084 00716 movwf FSR 0161 1783 00717 bsf STATUS, IRP 0162 0800 00718 movf INDF, W 0163 0008 00719 return 00720 ;;;;;;;; if (i < 240) 0164 00721 label_0007 0164 30F0 00722 movlw D'240' 0165 0277 00723 subwf _i, W 0166 1803 00724 btfsc STATUS, C 0167 296F 00725 goto label_0008 00726 ;;;;;;;; return buffer3[i-160]; 0168 30A0 00727 movlw D'160' 0169 0277 00728 subwf _i, W Warning [202] : Argument out of range. Least significant bits used. 016A 3E90 00729 addlw _buffer3 016B 0084 00730 movwf FSR 016C 1783 00731 bsf STATUS, IRP 016D 0800 00732 movf INDF, W 016E 0008 00733 return 00734 ;;;;;;;; return buffer4[i-240]; 016F 00735 label_0008 016F 30F0 00736 movlw D'240' 0170 0277 00737 subwf _i, W 0171 3E21 00738 addlw _buffer4 0172 0084 00739 movwf FSR 0173 1383 00740 bcf STATUS, IRP 0174 0800 00741 movf INDF, W 0175 0008 00742 return 00743 ;;;;;;;;} 0176 00744 _get_buffer__end 00745 ;;;;;;;; 00746 ;;;;;;;;/* Put a character into the buffer. */ gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 17 LOC OBJECT CODE LINE SOURCE TEXT VALUE 00747 ;;;;;;;;/* The buffer is made up of three smaller buffers so that */ 00748 ;;;;;;;;/* it fits in the PIC registers. */ 00749 ;;;;;;;; 00750 ;;;;;;;;/* The global variable 'i' contains the offset into the buffer. */ 00751 ;;;;;;;; 00752 ;;;;;;;; 00753 ;;;;;;;;void put_buffer(char v) { 0176 00754 _put_buffer__code 00755 ;;;;;;;; if (i < 80) { 0176 3050 00756 movlw D'80' 0177 0277 00757 subwf _i, W 0178 1803 00758 btfsc STATUS, C 0179 2983 00759 goto label_0009 00760 ;;;;;;;; buffer1[i] = v; 017A 087F 00761 movf param00_put_buffer, W 017B 00F1 00762 movwf _code_tmp_0001 017C 0877 00763 movf _i, W 017D 3EA0 00764 addlw _buffer1 017E 0084 00765 movwf FSR 017F 0871 00766 movf _code_tmp_0001 , W 0180 1383 00767 bcf STATUS, IRP 0181 0080 00768 movwf INDF 00769 ;;;;;;;; return; 0182 0008 00770 return 00771 ;;;;;;;; } 00772 ;;;;;;;; if (i < 160) { 0183 00773 label_0009 0183 30A0 00774 movlw D'160' 0184 0277 00775 subwf _i, W 0185 1803 00776 btfsc STATUS, C 0186 2991 00777 goto label_0010 00778 ;;;;;;;; buffer2[i-80] = v; 0187 087F 00779 movf param00_put_buffer, W 0188 00F1 00780 movwf _code_tmp_0001 0189 3050 00781 movlw D'80' 018A 0277 00782 subwf _i, W Warning [202] : Argument out of range. Least significant bits used. 018B 3E10 00783 addlw _buffer2 018C 0084 00784 movwf FSR 018D 0871 00785 movf _code_tmp_0001 , W 018E 1783 00786 bsf STATUS, IRP 018F 0080 00787 movwf INDF 00788 ;;;;;;;; return; 0190 0008 00789 return 00790 ;;;;;;;; } 00791 ;;;;;;;; if (i < 240) { 0191 00792 label_0010 0191 30F0 00793 movlw D'240' 0192 0277 00794 subwf _i, W 0193 1803 00795 btfsc STATUS, C 0194 299F 00796 goto label_0011 00797 ;;;;;;;; buffer3[i-160] = v; 0195 087F 00798 movf param00_put_buffer, W 0196 00F1 00799 movwf _code_tmp_0001 gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 18 LOC OBJECT CODE LINE SOURCE TEXT VALUE 0197 30A0 00800 movlw D'160' 0198 0277 00801 subwf _i, W Warning [202] : Argument out of range. Least significant bits used. 0199 3E90 00802 addlw _buffer3 019A 0084 00803 movwf FSR 019B 0871 00804 movf _code_tmp_0001 , W 019C 1783 00805 bsf STATUS, IRP 019D 0080 00806 movwf INDF 00807 ;;;;;;;; return; 019E 0008 00808 return 00809 ;;;;;;;; } 00810 ;;;;;;;; buffer4[i-240] = v; 019F 00811 label_0011 019F 087F 00812 movf param00_put_buffer, W 01A0 00F1 00813 movwf _code_tmp_0001 01A1 30F0 00814 movlw D'240' 01A2 0277 00815 subwf _i, W 01A3 3E21 00816 addlw _buffer4 01A4 0084 00817 movwf FSR 01A5 0871 00818 movf _code_tmp_0001 , W 01A6 1383 00819 bcf STATUS, IRP 01A7 0080 00820 movwf INDF 00821 ;;;;;;;;} 01A8 0008 00822 return 01A9 00823 _put_buffer__end 00824 ;;;;;;;; 00825 ;;;;;;;;/* Wait until an operation is complete */ 00826 ;;;;;;;;/* Waits until either DQ7 is equal to the bit being written 00827 ;;;;;;;; or until DQ5 is set to one indicating an error */ 00828 ;;;;;;;; 00829 ;;;;;;;;char wait_complete(char data) { 01A9 00830 _wait_complete__code 00831 ;;;;;;;; data = data & 0x80; /* Just keep lsb of data */ 01A9 1283 00832 bcf STATUS, RP0 01AA 1303 00833 bcf STATUS, RP1 01AB 0820 00834 movf param00_wait_complete, W 01AC 3980 00835 andlw D'128' 01AD 00A0 00836 movwf param00_wait_complete 00837 ;;;;;;;; 00838 ;;;;;;;; /* Read from chip */ 00839 ;;;;;;;; 00840 ;;;;;;;; clear_bit(controlport, nCE_BIT); 01AE 1009 00841 bcf _controlport, D'0' 00842 ;;;;;;;; clear_bit(controlport, nOE_BIT); 01AF 1089 00843 bcf _controlport, D'1' 00844 ;;;;;;;; 00845 ;;;;;;;; /* Wait until DQ7 == data bit 7 */ 00846 ;;;;;;;; /* Also check if DQ5 == 1 */ 00847 ;;;;;;;; 00848 ;;;;;;;; while (1) { 01B0 00849 label_0012 00850 ;;;;;;;; datalow = datalowport; 01B0 1283 00851 bcf STATUS, RP0 01B1 1303 00852 bcf STATUS, RP1 gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 19 LOC OBJECT CODE LINE SOURCE TEXT VALUE 01B2 0806 00853 movf _datalowport, W 01B3 00F5 00854 movwf _datalow 00855 ;;;;;;;; if ((datalow & 0x80) == data) 01B4 0875 00856 movf _datalow, W 01B5 3980 00857 andlw D'128' 01B6 0220 00858 subwf param00_wait_complete, W 01B7 1D03 00859 btfss STATUS, Z 01B8 29BA 00860 goto label_0014 00861 ;;;;;;;; break; 01B9 29CD 00862 goto label_0013 01BA 00863 label_0014 00864 ;;;;;;;; if (datalow & 0x20) { 01BA 1EF5 00865 btfss _datalow, 5 01BB 29CC 00866 goto label_0015 00867 ;;;;;;;; datalow = datalowport; 01BC 1283 00868 bcf STATUS, RP0 01BD 1303 00869 bcf STATUS, RP1 01BE 0806 00870 movf _datalowport, W 01BF 00F5 00871 movwf _datalow 00872 ;;;;;;;; if ((datalow & 0x80) == data) 01C0 0875 00873 movf _datalow, W 01C1 3980 00874 andlw D'128' 01C2 0220 00875 subwf param00_wait_complete, W 01C3 1D03 00876 btfss STATUS, Z 01C4 29C6 00877 goto label_0016 00878 ;;;;;;;; break; 01C5 29CD 00879 goto label_0013 01C6 00880 label_0016 00881 ;;;;;;;; set_bit(controlport, nOE_BIT); 01C6 1283 00882 bcf STATUS, RP0 01C7 1303 00883 bcf STATUS, RP1 01C8 1489 00884 bsf _controlport, D'1' 00885 ;;;;;;;; set_bit(controlport, nCE_BIT); 01C9 1409 00886 bsf _controlport, D'0' 00887 ;;;;;;;; return 0; 01CA 3000 00888 movlw D'0' 01CB 0008 00889 return 00890 ;;;;;;;; } 00891 ;;;;;;;; } 01CC 00892 label_0015 00893 ;;;;;;;; 00894 ;;;;;;;; set_bit(controlport, nOE_BIT); 01CC 29B0 00895 goto label_0012 01CD 00896 label_0013 01CD 1283 00897 bcf STATUS, RP0 01CE 1303 00898 bcf STATUS, RP1 01CF 1489 00899 bsf _controlport, D'1' 00900 ;;;;;;;; set_bit(controlport, nCE_BIT); 01D0 1409 00901 bsf _controlport, D'0' 00902 ;;;;;;;; return 1; 01D1 3001 00903 movlw D'1' 01D2 0008 00904 return 00905 ;;;;;;;;} 01D3 00906 _wait_complete__end gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 20 LOC OBJECT CODE LINE SOURCE TEXT VALUE 00907 ;;;;;;;; 00908 ;;;;;;;;/* Does a READ/RESET command */ 00909 ;;;;;;;; 00910 ;;;;;;;;void initialize() { 01D3 00911 _initialize__code 00912 ;;;;;;;; get_address_and_count(); 01D3 2009 00913 call _get_address_and_count 01D4 118A 00914 bcf PCLATH, 3 01D5 120A 00915 bcf PCLATH, 4 00916 ;;;;;;;; 00917 ;;;;;;;; cmd_write(0x00, 0x00, 0xf0); /* 0x0000 <- 0xf0 */ 01D6 3000 00918 movlw D'0' 01D7 00FB 00919 movwf param00_cmd_write 01D8 3000 00920 movlw D'0' 01D9 00FC 00921 movwf param01_cmd_write 01DA 30F0 00922 movlw D'240' 01DB 00FD 00923 movwf param02_cmd_write 01DC 2005 00924 call _cmd_write 01DD 118A 00925 bcf PCLATH, 3 01DE 120A 00926 bcf PCLATH, 4 00927 ;;;;;;;; 00928 ;;;;;;;; put_char(0); 01DF 3000 00929 movlw D'0' 01E0 00FE 00930 movwf param00_put_char 01E1 2007 00931 call _put_char 01E2 118A 00932 bcf PCLATH, 3 01E3 120A 00933 bcf PCLATH, 4 00934 ;;;;;;;;} 01E4 0008 00935 return 01E5 00936 _initialize__end 00937 ;;;;;;;; 00938 ;;;;;;;;/* Does an ERASE command */ 00939 ;;;;;;;; 00940 ;;;;;;;;void erase() 01E5 00941 _erase__code 00942 ;;;;;;;;{ 00943 ;;;;;;;; get_address_and_count(); 01E5 2009 00944 call _get_address_and_count 01E6 118A 00945 bcf PCLATH, 3 01E7 120A 00946 bcf PCLATH, 4 00947 ;;;;;;;; 00948 ;;;;;;;; cmd_write(0x05, 0x55, 0xaa); /* 0x0555 <- 0xaa */ 01E8 3005 00949 movlw D'5' 01E9 00FB 00950 movwf param00_cmd_write 01EA 3055 00951 movlw D'85' 01EB 00FC 00952 movwf param01_cmd_write 01EC 30AA 00953 movlw D'170' 01ED 00FD 00954 movwf param02_cmd_write 01EE 2005 00955 call _cmd_write 01EF 118A 00956 bcf PCLATH, 3 01F0 120A 00957 bcf PCLATH, 4 00958 ;;;;;;;; cmd_write(0x02, 0xaa, 0x55); /* 0x02aa <- 0x55 */ 01F1 3002 00959 movlw D'2' 01F2 00FB 00960 movwf param00_cmd_write gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 21 LOC OBJECT CODE LINE SOURCE TEXT VALUE 01F3 30AA 00961 movlw D'170' 01F4 00FC 00962 movwf param01_cmd_write 01F5 3055 00963 movlw D'85' 01F6 00FD 00964 movwf param02_cmd_write 01F7 2005 00965 call _cmd_write 01F8 118A 00966 bcf PCLATH, 3 01F9 120A 00967 bcf PCLATH, 4 00968 ;;;;;;;; cmd_write(0x05, 0x55, 0x80); /* 0x0555 <- 0x80 */ 01FA 3005 00969 movlw D'5' 01FB 00FB 00970 movwf param00_cmd_write 01FC 3055 00971 movlw D'85' 01FD 00FC 00972 movwf param01_cmd_write 01FE 3080 00973 movlw D'128' 01FF 00FD 00974 movwf param02_cmd_write 0200 2005 00975 call _cmd_write 0201 118A 00976 bcf PCLATH, 3 0202 120A 00977 bcf PCLATH, 4 00978 ;;;;;;;; cmd_write(0x05, 0x55, 0xaa); /* 0x0555 <- 0xaa */ 0203 3005 00979 movlw D'5' 0204 00FB 00980 movwf param00_cmd_write 0205 3055 00981 movlw D'85' 0206 00FC 00982 movwf param01_cmd_write 0207 30AA 00983 movlw D'170' 0208 00FD 00984 movwf param02_cmd_write 0209 2005 00985 call _cmd_write 020A 118A 00986 bcf PCLATH, 3 020B 120A 00987 bcf PCLATH, 4 00988 ;;;;;;;; cmd_write(0x02, 0xaa, 0x55); /* 0x02aa <- 0x55 */ 020C 3002 00989 movlw D'2' 020D 00FB 00990 movwf param00_cmd_write 020E 30AA 00991 movlw D'170' 020F 00FC 00992 movwf param01_cmd_write 0210 3055 00993 movlw D'85' 0211 00FD 00994 movwf param02_cmd_write 0212 2005 00995 call _cmd_write 0213 118A 00996 bcf PCLATH, 3 0214 120A 00997 bcf PCLATH, 4 00998 ;;;;;;;; cmd_write(0x05, 0x55, 0x10); /* 0x0555 <- 0x10 */ 0215 3005 00999 movlw D'5' 0216 00FB 01000 movwf param00_cmd_write 0217 3055 01001 movlw D'85' 0218 00FC 01002 movwf param01_cmd_write 0219 3010 01003 movlw D'16' 021A 00FD 01004 movwf param02_cmd_write 021B 2005 01005 call _cmd_write 021C 118A 01006 bcf PCLATH, 3 021D 120A 01007 bcf PCLATH, 4 01008 ;;;;;;;; 01009 ;;;;;;;; /* Wait for erase to complete */ 01010 ;;;;;;;; 01011 ;;;;;;;; if (wait_complete(0xff)) 021E 30FF 01012 movlw D'255' 021F 1283 01013 bcf STATUS, RP0 0220 1303 01014 bcf STATUS, RP1 gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 22 LOC OBJECT CODE LINE SOURCE TEXT VALUE 0221 00A0 01015 movwf param00_wait_complete 0222 200C 01016 call _wait_complete 0223 118A 01017 bcf PCLATH, 3 0224 120A 01018 bcf PCLATH, 4 0225 3C00 01019 sublw 0 0226 1903 01020 btfsc STATUS, Z 0227 2A2E 01021 goto label_0017 01022 ;;;;;;;; put_char(0); 0228 3000 01023 movlw D'0' 0229 00FE 01024 movwf param00_put_char 022A 2007 01025 call _put_char 022B 118A 01026 bcf PCLATH, 3 022C 120A 01027 bcf PCLATH, 4 01028 ;;;;;;;; else 022D 2A33 01029 goto label_0018 022E 01030 label_0017 01031 ;;;;;;;; put_char(2); 022E 3002 01032 movlw D'2' 022F 00FE 01033 movwf param00_put_char 0230 2007 01034 call _put_char 0231 118A 01035 bcf PCLATH, 3 0232 120A 01036 bcf PCLATH, 4 01037 ;;;;;;;;} 0233 01038 label_0018 0233 0008 01039 return 0234 01040 _erase__end 01041 ;;;;;;;;/* Does an ERASE SECTOR command */ 01042 ;;;;;;;; 01043 ;;;;;;;;void erasesector() 0234 01044 _erasesector__code 01045 ;;;;;;;;{ 01046 ;;;;;;;; get_address_and_count(); 0234 2009 01047 call _get_address_and_count 0235 118A 01048 bcf PCLATH, 3 0236 120A 01049 bcf PCLATH, 4 01050 ;;;;;;;; 01051 ;;;;;;;; cmd_write(0x05, 0x55, 0xaa); /* 0x0555 <- 0xaa */ 0237 3005 01052 movlw D'5' 0238 00FB 01053 movwf param00_cmd_write 0239 3055 01054 movlw D'85' 023A 00FC 01055 movwf param01_cmd_write 023B 30AA 01056 movlw D'170' 023C 00FD 01057 movwf param02_cmd_write 023D 2005 01058 call _cmd_write 023E 118A 01059 bcf PCLATH, 3 023F 120A 01060 bcf PCLATH, 4 01061 ;;;;;;;; cmd_write(0x02, 0xaa, 0x55); /* 0x02aa <- 0x55 */ 0240 3002 01062 movlw D'2' 0241 00FB 01063 movwf param00_cmd_write 0242 30AA 01064 movlw D'170' 0243 00FC 01065 movwf param01_cmd_write 0244 3055 01066 movlw D'85' 0245 00FD 01067 movwf param02_cmd_write 0246 2005 01068 call _cmd_write gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 23 LOC OBJECT CODE LINE SOURCE TEXT VALUE 0247 118A 01069 bcf PCLATH, 3 0248 120A 01070 bcf PCLATH, 4 01071 ;;;;;;;; cmd_write(0x05, 0x55, 0x80); /* 0x0555 <- 0x80 */ 0249 3005 01072 movlw D'5' 024A 00FB 01073 movwf param00_cmd_write 024B 3055 01074 movlw D'85' 024C 00FC 01075 movwf param01_cmd_write 024D 3080 01076 movlw D'128' 024E 00FD 01077 movwf param02_cmd_write 024F 2005 01078 call _cmd_write 0250 118A 01079 bcf PCLATH, 3 0251 120A 01080 bcf PCLATH, 4 01081 ;;;;;;;; cmd_write(0x05, 0x55, 0xaa); /* 0x0555 <- 0xaa */ 0252 3005 01082 movlw D'5' 0253 00FB 01083 movwf param00_cmd_write 0254 3055 01084 movlw D'85' 0255 00FC 01085 movwf param01_cmd_write 0256 30AA 01086 movlw D'170' 0257 00FD 01087 movwf param02_cmd_write 0258 2005 01088 call _cmd_write 0259 118A 01089 bcf PCLATH, 3 025A 120A 01090 bcf PCLATH, 4 01091 ;;;;;;;; cmd_write(0x02, 0xaa, 0x55); /* 0x02aa <- 0x55 */ 025B 3002 01092 movlw D'2' 025C 00FB 01093 movwf param00_cmd_write 025D 30AA 01094 movlw D'170' 025E 00FC 01095 movwf param01_cmd_write 025F 3055 01096 movlw D'85' 0260 00FD 01097 movwf param02_cmd_write 0261 2005 01098 call _cmd_write 0262 118A 01099 bcf PCLATH, 3 0263 120A 01100 bcf PCLATH, 4 01101 ;;;;;;;; 01102 ;;;;;;;; set_address(); 0264 2002 01103 call _set_address 0265 118A 01104 bcf PCLATH, 3 0266 120A 01105 bcf PCLATH, 4 01106 ;;;;;;;; datalow = 0x30; 0267 3030 01107 movlw D'48' 0268 00F5 01108 movwf _datalow 01109 ;;;;;;;; datahi = 0; 0269 01F6 01110 clrf _datahi 01111 ;;;;;;;; write_data(); 026A 2004 01112 call _write_data 026B 118A 01113 bcf PCLATH, 3 026C 120A 01114 bcf PCLATH, 4 01115 ;;;;;;;; 01116 ;;;;;;;; /* Wait for erase to complete */ 01117 ;;;;;;;; 01118 ;;;;;;;; if (wait_complete(0xff)) 026D 30FF 01119 movlw D'255' 026E 1283 01120 bcf STATUS, RP0 026F 1303 01121 bcf STATUS, RP1 0270 00A0 01122 movwf param00_wait_complete gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 24 LOC OBJECT CODE LINE SOURCE TEXT VALUE 0271 200C 01123 call _wait_complete 0272 118A 01124 bcf PCLATH, 3 0273 120A 01125 bcf PCLATH, 4 0274 3C00 01126 sublw 0 0275 1903 01127 btfsc STATUS, Z 0276 2A7D 01128 goto label_0019 01129 ;;;;;;;; put_char(0); 0277 3000 01130 movlw D'0' 0278 00FE 01131 movwf param00_put_char 0279 2007 01132 call _put_char 027A 118A 01133 bcf PCLATH, 3 027B 120A 01134 bcf PCLATH, 4 01135 ;;;;;;;; else 027C 2A82 01136 goto label_0020 027D 01137 label_0019 01138 ;;;;;;;; put_char(2); 027D 3002 01139 movlw D'2' 027E 00FE 01140 movwf param00_put_char 027F 2007 01141 call _put_char 0280 118A 01142 bcf PCLATH, 3 0281 120A 01143 bcf PCLATH, 4 01144 ;;;;;;;;} 0282 01145 label_0020 0282 0008 01146 return 0283 01147 _erasesector__end 01148 ;;;;;;;; 01149 ;;;;;;;; 01150 ;;;;;;;;/* Writes a block of data to the FLASH */ 01151 ;;;;;;;; 01152 ;;;;;;;;void write() 0283 01153 _write__code 01154 ;;;;;;;;{ 01155 ;;;;;;;; 01156 ;;;;;;;; /* Read in address and length from serial port */ 01157 ;;;;;;;; 01158 ;;;;;;;; get_address_and_count(); 0283 2009 01159 call _get_address_and_count 0284 118A 01160 bcf PCLATH, 3 0285 120A 01161 bcf PCLATH, 4 01162 ;;;;;;;; 01163 ;;;;;;;; /* Read in the data from serial port into the buffers */ 01164 ;;;;;;;; 01165 ;;;;;;;; checksum = 0; 0286 01F9 01166 clrf _checksum 01167 ;;;;;;;; i = 0; 0287 01F7 01168 clrf _i 01169 ;;;;;;;; while (1) { 0288 01170 label_0021 01171 ;;;;;;;; temp = get_char(); 0288 2006 01172 call _get_char 0289 118A 01173 bcf PCLATH, 3 028A 120A 01174 bcf PCLATH, 4 028B 00FA 01175 movwf _temp 01176 ;;;;;;;; checksum = checksum + temp; gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 25 LOC OBJECT CODE LINE SOURCE TEXT VALUE 028C 01F1 01177 clrf _code_tmp_0001 028D 0879 01178 movf _checksum, W 028E 077A 01179 addwf _temp, W 028F 1803 01180 btfsc STATUS, C 0290 0AF1 01181 incf _code_tmp_0001 , F 0291 00F9 01182 movwf _checksum 01183 ;;;;;;;; if (checksum < temp) 0292 087A 01184 movf _temp, W 0293 0279 01185 subwf _checksum, W 0294 1803 01186 btfsc STATUS, C 0295 2A97 01187 goto label_0023 01188 ;;;;;;;; checksum++; 0296 0AF9 01189 incf _checksum, F 01190 ;;;;;;;; put_buffer(temp); 0297 01191 label_0023 0297 087A 01192 movf _temp, W 0298 00FF 01193 movwf param00_put_buffer 0299 200B 01194 call _put_buffer 029A 118A 01195 bcf PCLATH, 3 029B 120A 01196 bcf PCLATH, 4 01197 ;;;;;;;; i++; 029C 0AF7 01198 incf _i, F 01199 ;;;;;;;; if (i == count) 029D 0877 01200 movf _i, W 029E 0278 01201 subwf _count, W 029F 1D03 01202 btfss STATUS, Z 02A0 2AA2 01203 goto label_0024 01204 ;;;;;;;; break; 02A1 2AA3 01205 goto label_0022 02A2 01206 label_0024 01207 ;;;;;;;; } 01208 ;;;;;;;; 01209 ;;;;;;;; /* Verify checksum */ 01210 ;;;;;;;; 01211 ;;;;;;;; temp = get_char(); 02A2 2A88 01212 goto label_0021 02A3 01213 label_0022 02A3 2006 01214 call _get_char 02A4 118A 01215 bcf PCLATH, 3 02A5 120A 01216 bcf PCLATH, 4 02A6 00FA 01217 movwf _temp 01218 ;;;;;;;; if (checksum != temp) { 02A7 0879 01219 movf _checksum, W 02A8 027A 01220 subwf _temp, W 02A9 1903 01221 btfsc STATUS, Z 02AA 2AB1 01222 goto label_0025 02AB 01223 label_0026 01224 ;;;;;;;; put_char(1); 02AB 3001 01225 movlw D'1' 02AC 00FE 01226 movwf param00_put_char 02AD 2007 01227 call _put_char 02AE 118A 01228 bcf PCLATH, 3 02AF 120A 01229 bcf PCLATH, 4 01230 ;;;;;;;; return; gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 26 LOC OBJECT CODE LINE SOURCE TEXT VALUE 02B0 0008 01231 return 01232 ;;;;;;;; } 01233 ;;;;;;;; 01234 ;;;;;;;; /* Write buffers out to flash */ 01235 ;;;;;;;; 01236 ;;;;;;;; i = 0; 02B1 01237 label_0025 02B1 01F7 01238 clrf _i 01239 ;;;;;;;; while (1) { 02B2 01240 label_0027 01241 ;;;;;;;; 01242 ;;;;;;;; cmd_write(0x05, 0x55, 0xaa); /* 0x0555 <- 0xaa */ 02B2 3005 01243 movlw D'5' 02B3 00FB 01244 movwf param00_cmd_write 02B4 3055 01245 movlw D'85' 02B5 00FC 01246 movwf param01_cmd_write 02B6 30AA 01247 movlw D'170' 02B7 00FD 01248 movwf param02_cmd_write 02B8 2005 01249 call _cmd_write 02B9 118A 01250 bcf PCLATH, 3 02BA 120A 01251 bcf PCLATH, 4 01252 ;;;;;;;; cmd_write(0x02, 0xaa, 0x55); /* 0x02aa <- 0x55 */ 02BB 3002 01253 movlw D'2' 02BC 00FB 01254 movwf param00_cmd_write 02BD 30AA 01255 movlw D'170' 02BE 00FC 01256 movwf param01_cmd_write 02BF 3055 01257 movlw D'85' 02C0 00FD 01258 movwf param02_cmd_write 02C1 2005 01259 call _cmd_write 02C2 118A 01260 bcf PCLATH, 3 02C3 120A 01261 bcf PCLATH, 4 01262 ;;;;;;;; cmd_write(0x05, 0x55, 0xa0); /* 0x0555 <- 0xa0 */ 02C4 3005 01263 movlw D'5' 02C5 00FB 01264 movwf param00_cmd_write 02C6 3055 01265 movlw D'85' 02C7 00FC 01266 movwf param01_cmd_write 02C8 30A0 01267 movlw D'160' 02C9 00FD 01268 movwf param02_cmd_write 02CA 2005 01269 call _cmd_write 02CB 118A 01270 bcf PCLATH, 3 02CC 120A 01271 bcf PCLATH, 4 01272 ;;;;;;;; 01273 ;;;;;;;; set_address(); 02CD 2002 01274 call _set_address 02CE 118A 01275 bcf PCLATH, 3 02CF 120A 01276 bcf PCLATH, 4 01277 ;;;;;;;; datalow = get_buffer(); 02D0 200A 01278 call _get_buffer 02D1 118A 01279 bcf PCLATH, 3 02D2 120A 01280 bcf PCLATH, 4 02D3 00F5 01281 movwf _datalow 01282 ;;;;;;;; i++; 02D4 0AF7 01283 incf _i, F 01284 ;;;;;;;; datahi = get_buffer(); gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 27 LOC OBJECT CODE LINE SOURCE TEXT VALUE 02D5 200A 01285 call _get_buffer 02D6 118A 01286 bcf PCLATH, 3 02D7 120A 01287 bcf PCLATH, 4 02D8 00F6 01288 movwf _datahi 01289 ;;;;;;;; i++; 02D9 0AF7 01290 incf _i, F 01291 ;;;;;;;; write_data(); 02DA 2004 01292 call _write_data 02DB 118A 01293 bcf PCLATH, 3 02DC 120A 01294 bcf PCLATH, 4 01295 ;;;;;;;; 01296 ;;;;;;;; if (wait_complete(datalow) == 0) { 02DD 0875 01297 movf _datalow, W 02DE 1283 01298 bcf STATUS, RP0 02DF 1303 01299 bcf STATUS, RP1 02E0 00A0 01300 movwf param00_wait_complete 02E1 200C 01301 call _wait_complete 02E2 118A 01302 bcf PCLATH, 3 02E3 120A 01303 bcf PCLATH, 4 02E4 3C00 01304 sublw D'0' 02E5 1D03 01305 btfss STATUS, Z 02E6 2AED 01306 goto label_0029 01307 ;;;;;;;; put_char(2); 02E7 3002 01308 movlw D'2' 02E8 00FE 01309 movwf param00_put_char 02E9 2007 01310 call _put_char 02EA 118A 01311 bcf PCLATH, 3 02EB 120A 01312 bcf PCLATH, 4 01313 ;;;;;;;; return; 02EC 0008 01314 return 01315 ;;;;;;;; } 01316 ;;;;;;;; 01317 ;;;;;;;; increment_address(); 02ED 01318 label_0029 02ED 2008 01319 call _increment_address 02EE 118A 01320 bcf PCLATH, 3 02EF 120A 01321 bcf PCLATH, 4 01322 ;;;;;;;; if (i == count) 02F0 0877 01323 movf _i, W 02F1 0278 01324 subwf _count, W 02F2 1D03 01325 btfss STATUS, Z 02F3 2AF5 01326 goto label_0030 01327 ;;;;;;;; break; 02F4 2AF6 01328 goto label_0028 02F5 01329 label_0030 01330 ;;;;;;;; } 01331 ;;;;;;;; 01332 ;;;;;;;; /* Indicate success */ 01333 ;;;;;;;; 01334 ;;;;;;;; put_char(0); 02F5 2AB2 01335 goto label_0027 02F6 01336 label_0028 02F6 3000 01337 movlw D'0' 02F7 00FE 01338 movwf param00_put_char gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 28 LOC OBJECT CODE LINE SOURCE TEXT VALUE 02F8 2007 01339 call _put_char 02F9 118A 01340 bcf PCLATH, 3 02FA 120A 01341 bcf PCLATH, 4 01342 ;;;;;;;;} 02FB 0008 01343 return 02FC 01344 _write__end 01345 ;;;;;;;; 01346 ;;;;;;;;/* Reads a block of data from the FLASH */ 01347 ;;;;;;;; 01348 ;;;;;;;;void read() { 02FC 01349 _read__code 01350 ;;;;;;;; 01351 ;;;;;;;; get_address_and_count(); 02FC 2009 01352 call _get_address_and_count 02FD 118A 01353 bcf PCLATH, 3 02FE 120A 01354 bcf PCLATH, 4 01355 ;;;;;;;; 01356 ;;;;;;;; /* Read data from flash into buffers */ 01357 ;;;;;;;; 01358 ;;;;;;;; i = 0; 02FF 01F7 01359 clrf _i 01360 ;;;;;;;; while (1) { 0300 01361 label_0031 01362 ;;;;;;;; set_address(); 0300 2002 01363 call _set_address 0301 118A 01364 bcf PCLATH, 3 0302 120A 01365 bcf PCLATH, 4 01366 ;;;;;;;; read_data(); 0303 2003 01367 call _read_data 0304 118A 01368 bcf PCLATH, 3 0305 120A 01369 bcf PCLATH, 4 01370 ;;;;;;;; put_buffer(datalow); 0306 0875 01371 movf _datalow, W 0307 00FF 01372 movwf param00_put_buffer 0308 200B 01373 call _put_buffer 0309 118A 01374 bcf PCLATH, 3 030A 120A 01375 bcf PCLATH, 4 01376 ;;;;;;;; i++; 030B 0AF7 01377 incf _i, F 01378 ;;;;;;;; put_buffer(datahi); 030C 0876 01379 movf _datahi, W 030D 00FF 01380 movwf param00_put_buffer 030E 200B 01381 call _put_buffer 030F 118A 01382 bcf PCLATH, 3 0310 120A 01383 bcf PCLATH, 4 01384 ;;;;;;;; i++; 0311 0AF7 01385 incf _i, F 01386 ;;;;;;;; increment_address(); 0312 2008 01387 call _increment_address 0313 118A 01388 bcf PCLATH, 3 0314 120A 01389 bcf PCLATH, 4 01390 ;;;;;;;; if (i == count) 0315 0877 01391 movf _i, W 0316 0278 01392 subwf _count, W gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 29 LOC OBJECT CODE LINE SOURCE TEXT VALUE 0317 1D03 01393 btfss STATUS, Z 0318 2B1A 01394 goto label_0033 01395 ;;;;;;;; break; 0319 2B1B 01396 goto label_0032 031A 01397 label_0033 01398 ;;;;;;;; } 01399 ;;;;;;;; 01400 ;;;;;;;; /* Write buffers to serial port */ 01401 ;;;;;;;; 01402 ;;;;;;;; checksum = 0; 031A 2B00 01403 goto label_0031 031B 01404 label_0032 031B 01F9 01405 clrf _checksum 01406 ;;;;;;;; i = 0; 031C 01F7 01407 clrf _i 01408 ;;;;;;;; while (1) { 031D 01409 label_0034 01410 ;;;;;;;; temp = get_buffer(); 031D 200A 01411 call _get_buffer 031E 118A 01412 bcf PCLATH, 3 031F 120A 01413 bcf PCLATH, 4 0320 00FA 01414 movwf _temp 01415 ;;;;;;;; checksum = checksum + temp; 0321 01F1 01416 clrf _code_tmp_0001 0322 0879 01417 movf _checksum, W 0323 077A 01418 addwf _temp, W 0324 1803 01419 btfsc STATUS, C 0325 0AF1 01420 incf _code_tmp_0001 , F 0326 00F9 01421 movwf _checksum 01422 ;;;;;;;; if (checksum < temp) 0327 087A 01423 movf _temp, W 0328 0279 01424 subwf _checksum, W 0329 1803 01425 btfsc STATUS, C 032A 2B2C 01426 goto label_0036 01427 ;;;;;;;; checksum++; 032B 0AF9 01428 incf _checksum, F 01429 ;;;;;;;; put_char(temp); 032C 01430 label_0036 032C 087A 01431 movf _temp, W 032D 00FE 01432 movwf param00_put_char 032E 2007 01433 call _put_char 032F 118A 01434 bcf PCLATH, 3 0330 120A 01435 bcf PCLATH, 4 01436 ;;;;;;;; i++; 0331 0AF7 01437 incf _i, F 01438 ;;;;;;;; if (i == count) 0332 0877 01439 movf _i, W 0333 0278 01440 subwf _count, W 0334 1D03 01441 btfss STATUS, Z 0335 2B37 01442 goto label_0037 01443 ;;;;;;;; break; 0336 2B38 01444 goto label_0035 0337 01445 label_0037 01446 ;;;;;;;; } gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 30 LOC OBJECT CODE LINE SOURCE TEXT VALUE 01447 ;;;;;;;; 01448 ;;;;;;;; /* Write checksum to serial port */ 01449 ;;;;;;;; 01450 ;;;;;;;; put_char(checksum); 0337 2B1D 01451 goto label_0034 0338 01452 label_0035 0338 0879 01453 movf _checksum, W 0339 00FE 01454 movwf param00_put_char 033A 2007 01455 call _put_char 033B 118A 01456 bcf PCLATH, 3 033C 120A 01457 bcf PCLATH, 4 01458 ;;;;;;;;} 033D 0008 01459 return 033E 01460 _read__end 01461 ;;;;;;;; 01462 ;;;;;;;;/* Hello command to see if the programmer is alive */ 01463 ;;;;;;;; 01464 ;;;;;;;;void hello() 033E 01465 _hello__code 01466 ;;;;;;;;{ 01467 ;;;;;;;; get_address_and_count(); 033E 2009 01468 call _get_address_and_count 033F 118A 01469 bcf PCLATH, 3 0340 120A 01470 bcf PCLATH, 4 01471 ;;;;;;;; put_char(0); 0341 3000 01472 movlw D'0' 0342 00FE 01473 movwf param00_put_char 0343 2007 01474 call _put_char 0344 118A 01475 bcf PCLATH, 3 0345 120A 01476 bcf PCLATH, 4 01477 ;;;;;;;;} 0346 0008 01478 return 0347 01479 _hello__end gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 31 SYMBOL TABLE LABEL VALUE C 00000000 DC 00000001 EEADR 00000009 EECON1 00000008 EECON2 00000009 EEDATA 00000008 EEIE 00000006 EEIF 00000004 ERD 00000000 EWR 00000001 F 00000001 FSR 00000004 GIE 00000007 IND0 00000000 INDF 00000000 INTCON 0000000B INTE 00000004 INTEDG 00000006 INTF 00000001 IRP 00000007 OPTIO 00000001 PCL 00000002 PCLATH 0000000A PD 00000003 PORTA 00000005 PORTB 00000006 PS0 00000000 PS1 00000001 PS2 00000002 PSA 00000003 RBIE 00000003 RBIF 00000000 RBPU 00000007 RP0 00000005 RP1 00000006 RTCC 00000001 RTE 00000004 RTIE 00000005 RTIF 00000002 RTS 00000005 STATUS 00000003 T0IF 00000002 TMR0 00000001 TO 00000004 TOIE 00000005 TRISA 00000005 TRISB 00000006 W 00000000 WREN 00000002 WRERR 00000003 Z 00000002 _CP_OFF 00003FFF _CP_ON 00003FEF gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 32 LOC OBJECT CODE LINE SOURCE TEXT VALUE _HS_OSC 00003FFE _LP_OSC 00003FFC _PWRTE_OFF 00003FF7 _PWRTE_ON 00003FFF _RC_OSC 00003FFF _WDT_OFF 00003FFB _WDT_ON 00003FFF _XT_OSC 00003FFD __16C74 00000001 _adcon1 0000009F _addrdir 00000087 _addrhi 00000074 _addrlow 00000072 _addrmed 00000073 _addrport 00000007 _buffer1 000000A0 _buffer2 00000110 _buffer3 00000190 _buffer4 00000021 _checksum 00000079 _cmd_write 00000005 _cmd_write__code 000000D4 _cmd_write__end 00000113 _code_tmp_0000 00000070 _code_tmp_0001 00000071 _controldir 00000089 _controlport 00000009 _count 00000078 _datahi 00000076 _datahidir 00000088 _datahiport 00000008 _datalow 00000075 _datalowdir 00000086 _datalowport 00000006 _erase 0000000E _erase__code 000001E5 _erase__end 00000234 _erasesector 0000000F _erasesector__code 00000234 _erasesector__end 00000283 _get_address_and_count 00000009 _get_address_and_count__code 00000138 _get_address_and_count__end 0000014F _get_buffer 0000000A _get_buffer__code 0000014F _get_buffer__end 00000176 _get_char 00000006 _get_char__code 00000113 _get_char__end 0000011F _hello 00000012 _hello__code 0000033E _hello__end 00000347 _i 00000077 _increment_address 00000008 gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 33 LOC OBJECT CODE LINE SOURCE TEXT VALUE _increment_address__code 0000012C _increment_address__end 00000138 _initialize 0000000D _initialize__code 000001D3 _initialize__end 000001E5 _main__code 00000013 _main__end 00000063 _pie1 0000008C _pir1 0000000C _put_buffer 0000000B _put_buffer__code 00000176 _put_buffer__end 000001A9 _put_char 00000007 _put_char__code 0000011F _put_char__end 0000012C _rcreg 0000001A _rcsta 00000018 _read 00000011 _read__code 000002FC _read__end 0000033E _read_data 00000003 _read_data__code 000000A8 _read_data__end 000000B9 _sbreg 00000099 _set_address 00000002 _set_address__code 00000063 _set_address__end 000000A8 _strobedir 00000085 _strobeport 00000005 _temp 0000007A _txreg 00000019 _txsta 00000098 _wait_complete 0000000C _wait_complete__code 000001A9 _wait_complete__end 000001D3 _write 00000010 _write__code 00000283 _write__end 000002FC _write_data 00000004 _write_data__code 000000B9 _write_data__end 000000D4 label_0000 00000113 label_0001 0000011B label_0002 0000011F label_0003 00000127 label_0004 00000137 label_0005 00000137 label_0006 00000159 label_0007 00000164 label_0008 0000016F label_0009 00000183 label_0010 00000191 label_0011 0000019F label_0012 000001B0 gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 34 LOC OBJECT CODE LINE SOURCE TEXT VALUE label_0013 000001CD label_0014 000001BA label_0015 000001CC label_0016 000001C6 label_0017 0000022E label_0018 00000233 label_0019 0000027D label_0020 00000282 label_0021 00000288 label_0022 000002A3 label_0023 00000297 label_0024 000002A2 label_0025 000002B1 label_0026 000002AB label_0027 000002B2 label_0028 000002F6 label_0029 000002ED label_0030 000002F5 label_0031 00000300 label_0032 0000031B label_0033 0000031A label_0034 0000031D label_0035 00000338 label_0036 0000032C label_0037 00000337 label_0038 0000002E label_0039 00000063 label_0040 00000062 label_0041 0000003A label_0042 00000036 label_0043 00000042 label_0044 0000003E label_0045 0000004A label_0046 00000046 label_0047 00000052 label_0048 0000004E label_0049 0000005A label_0050 00000056 label_0051 00000062 label_0052 0000005E param00_cmd_write 0000007B param00_put_buffer 0000007F param00_put_char 0000007E param00_wait_complete 00000020 param01_cmd_write 0000007C param02_cmd_write 0000007D start__code 00000013 MEMORY USAGE MAP ('X' = Used, '-' = Unused) 00000000 : XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX 00000040 : XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX 00000080 : XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX gpasm-0.12.0 beta flashpgm.asm5-22-2004 15:21:21 PAGE 35 LOC OBJECT CODE LINE SOURCE TEXT VALUE 000000c0 : XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX 00000100 : XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX 00000140 : XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX 00000180 : XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX 000001c0 : XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX 00000200 : XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX 00000240 : XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX 00000280 : XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX 000002c0 : XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX 00000300 : XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX 00000340 : XXXXXXX--------- ---------------- ---------------- ---------------- All other memory blocks unused. Program Memory Words Used: 839 Errors : 0 Warnings : 4 reported, 0 suppressed Messages : 13 reported, 0 suppressed flash/flashpgm.hex0000644000076500007650000001104410053751141014031 0ustar brdbrd00000000000000:020000040000FA :100000008A0113286328A828B928D42813291F296E :100010002C2938294F297629A929D329E529342AD9 :10002000832AFC2A3E2B831603138C01243098006C :100030009030831298000A308316990006309F0092 :10004000FF308600FF3088008901C03087008501BD :1000500083120914091589148701850106208A1164 :100060000A12F0007008583C031D3A280E208A112D :100070000A1262287008533C031D42280F208A117F :100080000A1262287008523C031D4A2811208A1166 :100090000A1262287008573C031D522810208A114A :1000A0000A1262287008483C031D5A2812208A113F :1000B0000A1262287008493C031D62280D208A112B :1000C0000A1262282E2874083F398312031387000E :1000D0007408F100F10CF10CF10CF10CF10C710C45 :1000E00003390339850000000000000005150000F9 :1000F00000000000051173083F3987007308F10004 :10010000F10CF10CF10CF10CF10C710C0339033909 :1001100085000000000000008515000000000000C0 :10012000851172083F3987007208F100F10CF10C5B :10013000F10CF10CF10C710C03390339850000004E :100140000000000005160000000000000512080075 :100150008312031309108910000000000000060834 :10016000F5000808F60000000000000089140914DA :100170000800831603138601880175088312860020 :100180007608880000000000000000000910091136 :10019000000000000000000009150914FF3083165C :1001A0008600FF3088000800831203138701850151 :1001B000000000000000051500000000000005110F :1001C0007B083F3987007B08F100F10CF10CF10C42 :1001D000F10CF10C710C03390339850000000000AB :1001E0000000851500000000000085117C083F39E3 :1001F00087007C08F100F10CF10CF10CF10CF10C12 :10020000710C033903398500000000000000051659 :100210000000000000000512F6017D08F500042032 :100220008A110A120800831203130C082039003CBB :10023000031D1B291329831203131A0808008312B4 :1002400003130C081039003C031D27291F297E08C1 :100250008312031399000800F20A7208003C031D80 :100260003729F30A7308003C031D3729F40A0800F4 :1002700006208A110A12F800F1017808780703189D :10028000F10AF80006208A110A12F40006208A11E9 :100290000A12F30006208A110A12F20008005030F8 :1002A0007702031859297708A03E840083130008B9 :1002B0000800A03077020318642950307702103EFE :1002C0008400831700080800F030770203186F29B4 :1002D000A0307702903E8400831700080800F030B9 :1002E0007702213E84008313000808005030770213 :1002F000031883297F08F1007708A03E8400710865 :10030000831380000800A0307702031891297F082A :10031000F10050307702103E84007108831780008E :100320000800F030770203189F297F08F100A03001 :100330007702903E840071088317800008007F08D0 :10034000F100F0307702213E8400710883138000B1 :1003500008008312031320088039A00009108910B7 :10036000831203130608F500750880392002031D67 :10037000BA29CD29F51ECC29831203130608F500EE :10038000750880392002031DC629CD298312031365 :100390008914091400300800B0298312031389144A :1003A00009140130080009208A110A120030FB00EC :1003B0000030FC00F030FD0005208A110A120030E8 :1003C000FE0007208A110A12080009208A110A1269 :1003D0000530FB005530FC00AA30FD0005208A11D5 :1003E0000A120230FB00AA30FC005530FD00052047 :1003F0008A110A120530FB005530FC008030FD00E8 :1004000005208A110A120530FB005530FC00AA3085 :10041000FD0005208A110A120230FB00AA30FC0000 :100420005530FD0005208A110A120530FB005530B9 :10043000FC001030FD0005208A110A12FF308312E3 :100440000313A0000C208A110A12003C03192E2A63 :100450000030FE0007208A110A12332A0230FE0003 :1004600007208A110A12080009208A110A12053091 :10047000FB005530FC00AA30FD0005208A110A124D :100480000230FB00AA30FC005530FD0005208A1127 :100490000A120530FB005530FC008030FD000520BD :1004A0008A110A120530FB005530FC00AA30FD000D :1004B00005208A110A120230FB00AA30FC005530D8 :1004C000FD0005208A110A1202208A110A1230301A :1004D000F500F60104208A110A12FF30831203137B :1004E000A0000C208A110A12003C03197D2A00305A :1004F000FE0007208A110A12822A0230FE0007201D :100500008A110A12080009208A110A12F901F7015A :1005100006208A110A12FA00F10179087A070318F5 :10052000F10AF9007A0879020318972AF90A7A0879 :10053000FF000B208A110A12F70A77087802031DC0 :10054000A22AA32A882A06208A110A12FA00790808 :100550007A020319B12A0130FE0007208A110A121B :100560000800F7010530FB005530FC00AA30FD0003 :1005700005208A110A120230FB00AA30FC00553017 :10058000FD0005208A110A120530FB005530FC00E1 :10059000A030FD0005208A110A1202208A110A12D9 :1005A0000A208A110A12F500F70A0A208A110A1293 :1005B000F600F70A04208A110A1275088312031341 :1005C000A0000C208A110A12003C031DED2A023003 :1005D000FE0007208A110A12080008208A110A1258 :1005E00077087802031DF52AF62AB22A0030FE00A9 :1005F00007208A110A12080009208A110A12F7013D :1006000002208A110A1203208A110A127508FF00BB :100610000B208A110A12F70A7608FF000B208A11B4 :100620000A12F70A08208A110A1277087802031DB5 :100630001A2B1B2B002BF901F7010A208A110A1231 :10064000FA00F10179087A070318F10AF9007A082B :10065000790203182C2BF90A7A08FE0007208A1168 :100660000A12F70A77087802031D372B382B1D2B47 :100670007908FE0007208A110A12080009208A1151 :0E0680000A120030FE0007208A110A1208003C :00000001FF flash/flashpgm.cod0000664000076500007650000004400010053751141014012 0ustar brdbrd00000000000000!"#gpasm-0.12.0 betagpasm'Copyright (c) 1998-2004 gputils project 16c74ÿ      !"#$%&'()*+,-./0123444444456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg  !"#$%&'()*+,€-€./€01€23€45€67€89€:;€<€<€<€<€<€<€<= €> ? €@ A €B C €D E €F G€HI€JK€LM€NO€PQRSTUVWXYZ[\]^_`abcdefghijklmnopqrrrrrrrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£€¤€¥€¦€¦§§§§§§§€¨€©€©ª€«€¬€­®€¯€°€±€±²³€´€µ€µ¶ · €¸ €¹!€¹!º"€»"€¼#€¼#½$¾$€¾$¿%À%€Á%€Â&€Â&Ã'Ä'€Ä'Å(Æ(€Ç(€È)É*€Ê*Ë+€Ì+Í,Î,€Ï,Ð-€Ñ-Ò.Ó.Ô.Õ.Õ.Õ.Õ.Õ.Õ.Õ.Ö.×.Ø.€Ù.€Ú/€Û0€Ü1Ý2Þ2€ß2€à3€á4€â5ã6ä6€å6€æ7€ç8è9€é9ê:ë:€ì:€í;€î<€ï=ð>ñ>€ò>€ó?€ô@õA€öA÷BøB€ùB€úC€ûD€üEýFþF€ÿF€G€HI€IJJ€J€K€L€ M N N N N N N N N€ N€ O€PQ€QRR€R€S€T€UVV€V€W€XY€YZZ€ Z€![€"\€#]$^%^€&^€'_€(`)a€*a+b,b-b.b/b€0b1c2c3c4c5c6c7c8c€9c€:d€;e€<f€=g>h€?h€@i€Aj€Aj€Aj€Aj€Aj€Aj€Aj€Bk€Cl€Dm€En€Fo€Gp€Hq€IrJs€Ks€Lt€MuNv€OvPw€Qw€Rx€SyTz€UzV{W{€X{€Y|€Z}[~€\~€]€^€€_€`‚€aƒ€b„€c…€d†€e‡€fˆg‰€h‰€iŠ€j‹kŒ€lŒm€n€oŽ€pq€rs‘t‘€u‘€v’€w“€w“€w“€w“€w“€w“€w“x”€y”€z•€{–€|—€}˜€~™€š€€›€œ€‚€ƒž„Ÿ€…Ÿ€† €‡¡ˆ¢€‰¢Š£€‹£€Œ¤€¥Ž¦€¦§€‘§’¨“¨”¨•¨–¨—¨˜¨€™¨€š©€›ªœ«€«ž¬€Ÿ¬€ ­€¡®¢¯€£¯€¤°¥±€¦±€§²¨³€©³€ª´€«µ¬¶€­¶€­¶€­¶€­¶€­¶€­¶€­¶®·€¯·°¸€±¸²¹³¹´¹µ¹¶¹·¹¸¹€¹¹€ºº€»»€»»¼¼½¼€½¼¾½€¿½€À¾€Á¿ÂÀ€ÃÀ€ÄÁŀƀÇÀÈÄ€ÉÅÊÆ€ËÆÌÇ€ÍÇÎÈ€ÏÈ€ÐÉ€ÑÊ€ÒËÓÌ€ÔÌÕÍ€ÖÍ×΀Ø΀ÙÏ€ÚЀÚÐÛÑ€ÜÑ€ÝÒ€ÝÒÞÓ€ßÓ€ßÓ€ßÓ€ßÓ€ßÓ€ßÓ€ßÓàÔáÔâÔãÔäÔåÔæÔçÔ€èÔ€éÕ€êÖë×€ì×íØ€îØ€ïÙ€ðÚñÛ€òÛóÜ€ôÜ€õÝ€öÞ÷߀øßùàúà€ûà€üá€ýâþã€ÿã€ä€å€æ€ç€è€é€ê€ë€ì€ í î€ î€ ï€ ðñ€ñò€ò€ó€ôõ€õ€õ€õ€õ€õ€õ€õöö€ö€÷€øù€ù€ú€û€ü€ ý€!þ€"ÿ€#€$€%€&'€(€)€*+€,-€.€/ €0 1 €2 3 4 €5 6 €7 €89€:€;€<=€>?@ABCDEF€G€H€I€J€K€K€K€K€K€K€K€L€MN€OP€Q€R€S€TUVWXYZ[\]€^€_ €`!€a"€b#€c$€d%e&€f&g'€h'€i(€j)€k*l+€m+n,o,p,q,r,s,t,€u,€v-€w.€x/€y0z1€{1€|2€}3€~4€5€6€6€6€6€6€6€6€6‚7ƒ7„7€…7†8‡8ˆ8‰8Š8‹8Œ88€Ž8€9€:€‘;’<€“<€”=€•>€–?€—@€˜A™BšB€›B€œC€D€žEŸF€ F€¡G€¢H€£I¤J€¥J€¦K€§L€¨M©NªN€«N¬O­O®O¯O°O±O²O³O´OµO¶O€·O€·O€·O€·O€·O€·O€·O€¸P€¹Q€ºR»S€¼S€½T€¾U€¿V€ÀW€ÁXÂYÃY€ÄY€ÅZ€Æ[€Ç\È]€É]€Ê^€Ë_€Ë_€Ì`€Ía€Îb€ÏcÐdÑd€Òd€Óe€Ôf€ÕgÖh€×h€Øi€Ùj€Ùj€Úk€Ûl€Üm€ÝnÞoßo€ào€áp€âq€ãr€äs€åt€æuçvèvévêvëvëvëvëvëvëvëvìvívîvïvðvñvòvóv€ôv€õw€öx€÷yøz€ùz€ú{€û|€ü}€ý~€þ€ÿ€€‚€‚ƒƒƒ€ƒ€„€…€ † ‡€ ‡€ ˆ€ ‰€Š€‹€‹€Œ€€Ž€€‘‘‘€‘€’€“€”•€•€–€ —€ —€ —€ —€ —€ —€ —€!˜€"™€"™€#š€$›€%œ€&'ž€(ž)Ÿ*Ÿ+Ÿ€,Ÿ€- €.¡€/¢€0£€1¤€2¥€3¦€4§5¨€6¨7©8©9©:©;©<©=©>©?©€@©€Aª€B«€C¬€D­E®F®G®H®€I®J¯€K¯L°M°N°O°P°Q°R°€S°€T±€U²€U²€U²€U²€U²€U²€U²€V³W´€X´€Yµ€Z¶€[·€\¸]¹€^¹_º`º€aº€b»c¼€d¼€e½€f¾€g¿hÀ€iÀ€jÁ€k€lÀmÄnÅ€oÅpÆqÆ€rÆ€sÇ€tÈuÉ€vÉwÊ€xÊ€yËzÌ{Ì|Ì}Ì~̀̀̀̀‚΀ƒÏ„Ѐ…Ір‡Ñ€ˆÒ‰ÓŠÓ‹Ó‹Ó‹Ó‹Ó‹Ó‹Ó‹ÓŒÓÓŽÓÓÓ€‘Ó€’Ô€“Õ”Ö•Ö€–Ö€—×€˜Ø€™Ù€šÚ€›Û€œÜ€Ý€žÞŸß ß€¡ß€¢à€£á€¤â€¥ã¦ä€§ä¨å©åªå«å¬å­å®å¯å€°å€±æ€²ç³è´è€µè€¶é€·ê€¸ë€¹ì€ºí€»î€¼ï€½ð¾ñ€¿ñ€Àò€Áó€Áó€Áó€Áó€Áó€Áó€Áó€Âô€Ãõ€Äö€Å÷€Æø€ÇùÈú€Éú€Êû€Ëü€Ìý€Íþ€Îÿ€Ï€Ð€ÑҀӀԀՀր׀؀٠€Ú €Û Ü €Ý €Þ €ß€à€á€â€ã€ä€åæ€ç€è€é€ê€ë€ì€í€î€ïðñòó€ô€õ€ö €÷!€÷!€÷!€÷!€÷!€÷!€÷!€ø"€ù#€ú$€û%€ü&€ý'þ(€ÿ(€)€*€+€,-€-..€.€ /€ 0€ 1€ 2 33€34444444€4€5€677€7€8€9€:€ ;€!<€"=€#>€$?%@€&@€'A€(B€)C€*D€+E€,F€-G€-G€-G€-G€-G€-G€-G€.H/I€0I€1J€2K€3L€4M€5N€6O€7P€8Q9R€:R€;S€<T€=U€>V€?W€@X€AY€BZC[€D[€E\€F]€G^€H_€I`€Ja€Kb€LcMdNd€Od€Pe€QfRg€Sg€ThUi€ViWj€Xj€Yk€Zl[m\m]m^m€_m€`n€ao€bp€cq€cq€cq€cq€cq€cq€cq€dr€es€ft€gu€hviw€jw€kx€ly€mz€n{o|€p|q}r}€s}€t~€u€v€€wx‚y‚€z‚{ƒ|ƒ}ƒ~ƒƒ€ƒƒ‚ƒƒƒ„ƒ…ƒ†ƒ€‡ƒ€ˆ„€‰…Š†‹†Œ††€Ž†‡€‡‘ˆ’ˆ“ˆ€”ˆ€•‰€–Š€—‹˜Œ€™Œ€™Œ€™Œ€™Œ€™Œ€™Œ€™Œ€š€›Ž€œ€€ž‘Ÿ’€ ’€¡“€¢”€£•¤–€¥–¦—§—€¨—€©˜€ª™€«š€¬›­œ€®œ¯€°€±ž€²Ÿ€³ ´¡€µ¡¶¢·¢¸¢¹¢º¢»¢€¼¢½£€¾£€¿¤€À¥€Á¦Â§€Ã§€Ä¨€Å©€ÆªÇ«È«€É«€Ê¬€Ë­€Ì®€Í¯Î°€Ï°€Ï°€Ï°€Ï°€Ï°€Ï°€Ï°Ð±Ñ±Ò±Ó±Ô±Õ±€Ö±×²Ø²Ù²Ú²€Û²€Ü³€Ý´€Þµ€ß¶€à·€á¸€â¹€ãºä»€å»€æ¼€ç½€è¾€é¿€êÀ€ëÁ€ì€íÃîÄ€ïÄ€ðÅ€ñÆ€òÇ€óÈ€ôÉ€õÊ€öË€÷ÌøÍùÍ€úÍ€û΀üÏýЀþЀÿÑ€Ò€ÓÔ€ÔÕ€Õ€Õ€Õ€Õ€Õ€Õ€Õ€Ö€×€Ø Ù€ Ù Ú€ Ú€ Û€ÜÝ݀݀ހ߀à€á€â€ã€ä€å€æç€ç€è€é€ê€ ë!ì€"ì#í$í%í&í€'í€(î€)ï*ð€+ð€,ñ€-ò€.ó/ô€0ô1õ2õ3õ4õ5õ6õ€7õ8ö€9ö€:÷€;ø€;ø€;ø€;ø€;ø€;ø€;ø€<ù€=ú>û€?û@üAüBüCüDüEüFüGü€Hü€Iý€JþKÿLÿMÿNÿ€OÿPQR€S€T€UV€W€X€YZ€[€\€]€^ €_ ` €a b €c €d €e€f€gh€ij€k€l€mn€o€p€q€q€q€q€q€q€q€rs€tuvwxyz€{|€}~€€‚€ƒ€„€…€† ‡!€ˆ!€‰"€Š#€‹$€Œ%€&Ž'€'€(€‘)€’*“+€”+•,–,€—,€˜-€™.€š/€›0œ1€1ž2€Ÿ2€ 3€¡4€¢5£6€¤6¥7¦7§7§7§7§7§7§7§7¨7©7ª7€«7¬8€­8€®9€¯:€°;€±<²=€³=´>µ>¶>·>¸>¹>º>»>€¼>€½?€¾@¿A€ÀA€ÁB€ÂC€ÃD€ÄEÅF€ÆFÇGC/DC/EEADR/ EECON1/EECON2/ EEDATA/EEIE/EEIF/ERD/EWR/F/FSR/GIE/IND0/INDF/INTCON/ INTE/INTEDG/INTF/IRP/OPTIO/PCL/PCLATH/ PD/PORTA/PORTB/PS0/PS1/PS2/PSA/RBIE/RBIF/RBPU/RP0/RP1/RTCC/RTE/RTIE/RTIF/RTS/STATUS/T0IF/TMR0/TO/TOIE/TRISA/TRISB/W/WREN/WRERR/Z/_CP_OFF/?ÿ_CP_ON/?ï_HS_OSC/?þ_LP_OSC/?ü _PWRTE_OFF/?÷ _PWRTE_ON/?ÿ_RC_OSC/?ÿ_WDT_OFF/?û_WDT_ON/?ÿ_XT_OSC/?ý__16C74/_adcon1/Ÿ_addrdir/‡_addrhi/t_addrlow/r_addrmed/s _addrport/_buffer1/ _buffer2/_buffer3/_buffer4/! _checksum/y _cmd_write._cmd_write__code.Ô_cmd_write__end._code_tmp_0000/p_code_tmp_0001/q _controldir/‰ _controlport/ _count/x_datahi/v _datahidir/ˆ _datahiport/_datalow/u _datalowdir/† _datalowport/_erase. _erase__code.å _erase__end.4 _erasesector._erasesector__code.4_erasesector__end.ƒ_get_address_and_count. _get_address_and_count__code.8_get_address_and_count__end.O _get_buffer. _get_buffer__code.O_get_buffer__end.v _get_char._get_char__code._get_char__end._hello. _hello__code.> _hello__end.G_i/w_increment_address._increment_address__code.,_increment_address__end.8 _initialize. _initialize__code.Ó_initialize__end.å _main__code. _main__end.c_pie1/Œ_pir1/ _put_buffer. _put_buffer__code.v_put_buffer__end.© _put_char._put_char__code._put_char__end.,_rcreg/_rcsta/_read. _read__code.ü _read__end.> _read_data._read_data__code.¨_read_data__end.¹_sbreg/™ _set_address._set_address__code.c_set_address__end.¨ _strobedir/… _strobeport/_temp/z_txreg/_txsta/˜_wait_complete. _wait_complete__code.©_wait_complete__end.Ó_write. _write__code.ƒ _write__end.ü _write_data._write_data__code.¹_write_data__end.Ô label_0000. label_0001. label_0002. label_0003.' label_0004.7 label_0005.7 label_0006.Y label_0007.d label_0008.o label_0009.ƒ label_0010.‘ label_0011.Ÿ label_0012.° label_0013.Í label_0014.º label_0015.Ì label_0016.Æ label_0017.. label_0018.3 label_0019.} label_0020.‚ label_0021.ˆ label_0022.£ label_0023.— label_0024.¢ label_0025.± label_0026.« label_0027.² label_0028.ö label_0029.í label_0030.õ label_0031. label_0032. label_0033. label_0034. label_0035.8 label_0036., label_0037.7 label_0038.. label_0039.c label_0040.b label_0041.: label_0042.6 label_0043.B label_0044.> label_0045.J label_0046.F label_0047.R label_0048.N label_0049.Z label_0050.V label_0051.b label_0052.^param00_cmd_write/{param00_put_buffer/param00_put_char/~param00_wait_complete/ param01_cmd_write/|param02_cmd_write/} start__code. flashpgm.asm p16F877.inc flashpgm.cod flashpgm.lstŠ(c(¨(¹(Ô()),)8)O)v)©)Ó)å)4*ƒ*ü*>+ƒŒ$0˜0ƒ˜ 0ƒ™0Ÿÿ0†ÿ0ˆ‰À0‡…ƒ  ‰‡… Š ðpX<:( Š b(pS<B( Š b(pR<J( Š b(pW<R( Š b(pH<Z( Š b(pI<b( Š b(.(t?9ƒ‡tññ ñ ñ ñ ñ q 99…s?9‡sññ ñ ñ ñ ñ q 99………r?9‡rññ ñ ñ ñ ñ q 99…ƒ ‰õö‰ ƒ†ˆuƒ†vˆ    ÿ0ƒ†ÿ0ˆƒ‡…{?9‡{ññ ñ ñ ñ ñ q 99………|?9‡|ññ ñ ñ ñ ñ Œq 99…ö}õ Š ƒ  9<))ƒƒ 9<'))~ƒ™ò r<7)ó s<7)ô  Š øñxxñ ø Š ô Š ó Š òP0wY)w >„ƒ 0wd)P0w>„ƒð0wo) 0w>„ƒð0w!>„ƒP0wƒ)ñw >„qƒ€ 0w‘)ñP0w>„qƒ€ð0wŸ)ñ 0w>„qƒ€ñð0w!>„qƒ€ƒ €9  ‰ƒõu€9 º)Í)õÌ)ƒõu€9 Æ)Í)ƒ‰ 0°)ƒ‰ 0 Š 0û0üð0ý Š 0þ Š  Š 0ûU0üª0ý Š 0ûª0üU0ý Š 0ûU0ü€0ý Š 0ûU0üª0ý Š 0ûª0üU0ý Š 0ûU0ü0ý Š ÿ0ƒ  Š <.*0þ Š 3*0þ Š  Š 0ûU0üª0ý Š 0ûª0üU0ý Š 0ûU0ü€0ý Š 0ûU0üª0ý Š 0ûª0üU0ý Š  Š 00õö Š ÿ0ƒ  Š <}*0þ Š ‚*0þ Š  Š ù÷ Š úñyzñ ùzy—*ù zÿ Š ÷ wx¢*£*ˆ* Š úyz±*0þ Š ÷0ûU0üª0ý Š 0ûª0üU0ý Š 0ûU0ü 0ý Š  Š  Š õ÷ Š ö÷  Š uƒ  Š <í*0þ Š  Š wxõ*ö*²*0þ Š  Š ÷ Š  Š uÿ Š ÷ vÿ Š ÷  Š wx+++ù÷ Š úñyzñ ùzy,+ù zþ Š ÷ wx7+8++yþ Š  Š 0þ Š flash/flashpgm.hex.good0000644000076500007650000001101407416145046014767 0ustar brdbrd00000000000000:100000008A0113286328A828B928D22811291D2974 :100010002A2936294D297429A729D129E329322AE9 :10002000812AFA2A3C2B831603138C012430980072 :100030009030831298000A308316990006309F0092 :10004000FF308600FF3088008901C03087008501BD :1000500083120914091589148701850106208A1164 :100060000A12F0007008583C031D3A280E208A112D :100070000A1262287008533C031D42280F208A117F :100080000A1262287008523C031D4A2811208A1166 :100090000A1262287008573C031D522810208A114A :1000A0000A1262287008483C031D5A2812208A113F :1000B0000A1262287008493C031D62280D208A112B :1000C0000A1262282E2874083F398312031387000E :1000D0007408F100F10CF10CF10CF10CF10C710C45 :1000E00003390339850000000000000005150000F9 :1000F00000000000051173083F3987007308F10004 :10010000F10CF10CF10CF10CF10C710C0339033909 :1001100085000000000000008515000000000000C0 :10012000851172083F3987007208F100F10CF10C5B :10013000F10CF10CF10C710C03390339850000004E :100140000000000005160000000000000512080075 :100150008312031309108910000000000000060834 :10016000F5000808F60000000000000089140914DA :100170000800831603138601880175088312860020 :100180007608880000000000000009100911000036 :100190000000000009150914FF3083168600FF30A7 :1001A0008800080083120313870185010000000006 :1001B0000000051500000000000005117B083F3914 :1001C00087007B08F100F10CF10CF10CF10CF10C43 :1001D000710C03390339850000000000000085150B :1001E00000000000000085117C083F3987007C0872 :1001F000F100F10CF10CF10CF10CF10C710C033964 :100200000339850000000000000005160000000012 :1002100000000512F6017D08F50004208A110A127B :100220000800831203130C082039003C031D192910 :100230001129831203131A080800831203130C08F0 :100240001039003C031D25291D297E088312031344 :1002500099000800F20A7208003C031D3529F30AD0 :100260007308003C031D3529F40A080006208A1192 :100270000A12F800F101780878070318F10AF8006B :1002800006208A110A12F40006208A110A12F300CD :1002900006208A110A12F200080050307702031873 :1002A00057297708A03E8400831300080800A03077 :1002B00077020318622950307702103E84008317BA :1002C00000080800F030770203186D29A03077028B :1002D000903E8400831700080800F0307702213E2A :1002E0008400831300080800503077020318812926 :1002F0007F08F1007708A03E840071088313800016 :100300000800A030770203188F297F08F1005030D1 :100310007702103E84007108831780000800F030D7 :10032000770203189D297F08F100A0307702903EE4 :10033000840071088317800008007F08F100F03006 :100340007702213E84007108831380000800831225 :10035000031320088039A0000910891083120313A9 :100360000608F500750880392002031DB829CB293D :10037000F51ECA29831203130608F5007508803993 :100380002002031DC429CB298312031389140914E5 :1003900000300800AE2983120313891409140130B8 :1003A000080009208A110A120030FB000030FC000E :1003B000F030FD0005208A110A120030FE000720EF :1003C0008A110A12080009208A110A120530FB005E :1003D0005530FC00AA30FD0005208A110A120230B7 :1003E000FB00AA30FC005530FD0005208A110A12DE :1003F0000530FB005530FC008030FD0005208A11DF :100400000A120530FB005530FC00AA30FD00052023 :100410008A110A120230FB00AA30FC005530FD00A0 :1004200005208A110A120530FB005530FC001030FF :10043000FD0005208A110A12FF3083120313A00069 :100440000C208A110A12003C03192C2A0030FE00ED :1004500007208A110A12312A0230FE0007208A1171 :100460000A12080009208A110A120530FB005530D3 :10047000FC00AA30FD0005208A110A120230FB00A0 :10048000AA30FC005530FD0005208A110A12053003 :10049000FB005530FC008030FD0005208A110A1257 :1004A0000530FB005530FC00AA30FD0005208A1104 :1004B0000A120230FB00AA30FC005530FD00052076 :1004C0008A110A1202208A110A123030F500F60150 :1004D00004208A110A12FF3083120313A0000C209B :1004E0008A110A12003C03197B2A0030FE00072003 :1004F0008A110A12802A0230FE0007208A110A128D :10050000080009208A110A12F901F70106208A1150 :100510000A12FA00F10179087A070318F10AF900C2 :100520007A0879020318952AF90A7A08FF000B2045 :100530008A110A12F70A77087802031DA02AA12A55 :10054000862A06208A110A12FA0079087A0203190B :10055000AF2A0130FE0007208A110A120800F701B5 :100560000530FB005530FC00AA30FD0005208A1143 :100570000A120230FB00AA30FC005530FD000520B5 :100580008A110A120530FB005530FC00A030FD0036 :1005900005208A110A1202208A110A120A208A11E1 :1005A0000A12F500F70A0A208A110A12F600F70A61 :1005B00004208A110A12750883120313A0000C206C :1005C0008A110A12003C031DEB2A0230FE000720AC :1005D0008A110A12080008208A110A127708780284 :1005E000031DF32AF42AB02A0030FE0007208A11E6 :1005F0000A12080009208A110A12F70102208A1142 :100600000A1203208A110A127508FF000B208A11B2 :100610000A12F70A7608FF000B208A110A12F70A5D :1006200008208A110A1277087802031D182B192B4B :10063000FE2AF901F7010A208A110A12FA00F101D3 :1006400079087A070318F10AF9007A087902031881 :100650002A2BF90A7A08FE0007208A110A12F70AE3 :1006600077087802031D352B362B1B2B7908FE00EB :1006700007208A110A12080009208A110A12003084 :0A068000FE0007208A110A1208008C :00000001FF flash/wpflash.c.bck0000664000076500007650000004062307425114532014105 0ustar brdbrd00000000000000#include #include #include #include #include #include #include int do_write(int, void *, int); int do_read(int, void *, int); #define ERROR (-1) int sfd; int nowait = 0; int parallel = 0; #define FLASHSIZE (512 * 1024) char buffer [1024]; char membuf[FLASHSIZE*2]; struct cmd { char type; unsigned char length; unsigned char addrhi; unsigned char addrmed; unsigned char addrlow; }; int addr; /* Flash Partition definitions */ struct partition { char name[32]; int start; int size; } partitions[] = { { "all" , 0x000000, 0x100000 }, { "boot" , 0x000000, 0x006000 }, { "params", 0x006000, 0x002000 }, { "root" , 0x008000, 0x058000 }, { "zImage", 0x006000, 0x0a0000 }, { "" , 0x000000, 0x000000 } }; /* This structure defines the sectors on the FLASH */ #define SECTOR_COUNT 19 struct sector { int start; int size; } sectors[SECTOR_COUNT] = { { 0x000000, 0x004000 }, { 0x004000, 0x002000 }, { 0x006000, 0x002000 }, { 0x008000, 0x008000 }, { 0x010000, 0x010000 }, { 0x020000, 0x010000 }, { 0x030000, 0x010000 }, { 0x040000, 0x010000 }, { 0x050000, 0x010000 }, { 0x060000, 0x010000 }, { 0x070000, 0x010000 }, { 0x080000, 0x010000 }, { 0x090000, 0x010000 }, { 0x0A0000, 0x010000 }, { 0x0B0000, 0x010000 }, { 0x0C0000, 0x010000 }, { 0x0D0000, 0x010000 }, { 0x0E0000, 0x010000 }, { 0x0F0000, 0x010000 } }; /* Find a partition name */ struct partition * find_partition(char *name) { struct partition *partition = partitions; while (partition->name[0]) { if (strcmp(name, partition->name) == 0) return partition; partition++; } bad_partition(); } /* Initialize a "cmd" structure */ void set_cmd(struct cmd *cmd, char type, int addr, int length) { cmd->type = type; if (length == 256) cmd->length = 0; else cmd->length = length & 0xff; cmd->addrhi = (addr >> 16) & 0xff; cmd->addrmed = (addr >> 8) & 0xff; cmd->addrlow = (addr & 0xff); /* printf("cmd %02x %02x %02x %02x %02x\n", cmd->type, cmd->length, cmd->addrhi, cmd->addrmed, cmd->addrlow); */ } /* Wait for "WebPal Linux Loader" prompt from the Webpal. This indicates the WebPal has been booted and is waiting for "CONTROL-A" to signal it should jump to the programming code */ wait_boot_prompt() { char line[256], *s; s = line; while (1) { do_read(sfd, s, 1); if (*s == '\r') ; else if (*s == '\n') { *s = 0; if (strcmp(line, "Enter CTRL-A to enter programmer.") == 0) return 1; s = line; } else { s++; } } } /* Erase a partition */ erase_partition(char *name) { struct partition *partition = find_partition(name); int i; printf("Erasing %s sectors", partition->name); fflush(stdout); for (i=0; i < SECTOR_COUNT; i++) { if (partition->start >= (sectors[i].start + sectors[i].size)) continue; if ((partition->start + partition->size) <= sectors[i].start) continue; erase_sector(sectors[i].start); printf("."); fflush(stdout); } printf("done.\n"); } /* Program a partition */ program_partition(char *name, char *filename, int hexdump) { struct partition *partition = find_partition(name); int maxaddr, maxpgm; int i; /* Load data to be programmed in either hex or binary format */ if (hexdump) maxaddr = read_object(filename, membuf, FLASHSIZE*2); else maxaddr = read_raw(filename, membuf, FLASHSIZE*2); /* Print statistics and check data fits in partition. */ printf("Data size is %d bytes (%d%% of '%s' partition used).\n", maxaddr, (maxaddr * 100 + partition->size - 1)/ partition->size, partition->name); if (maxaddr > partition->size) { printf("Data to large for '%s' partition\n", name); exit(1); } /* Program the partition. Since we program in 16 bit quantities, we need to divide several value by 2 to convert */ maxpgm = (maxaddr + 1) / 2; erase_partition(name); for (addr = 0; addr < maxpgm; addr = addr + 128) { if (!write_flash(addr + (partition->start / 2), &membuf[addr*2], 128)) printf("checksum error %d\n", addr); if ((addr % 4096) == 0) { printf("%d\r", addr * 2); fflush(stdout); } } printf("%d\nDone.\n", addr * 2); } /* Read a partition */ read_partition(char *name, char *filename) { struct partition *partition = find_partition(name); FILE *file; int addr; file = fopen(filename, "w"); if (file == NULL) { fprintf(stderr, "Could not open '%s'\n", filename); exit(1); } printf("Reading partition '%s' to '%s'\n", partition->name, filename); for (addr = 0; addr < (partition->size / 2); addr = addr + 128) { if (!read_flash(addr + (partition->start / 2), membuf, 128)) printf("checksum error\n"); fwrite(membuf, 1, 256, file); if ((addr % 4096) == 0) { printf("%d\r", addr * 2); fflush(stdout); } } printf("%d\nDone.\n", addr * 2); fclose(file); return(0); } main(int argc, char **argv) { struct termios termios; char c; int i; int cpid; int count; int maxcount; if (argc < 2) usage(); /* Initialize programmer */ if (strcmp(argv[1], "-p") == 0) { argv++; argc--; parallel = 1; nowait = 0; } else if (strcmp(argv[1], "-s") == 0) { argv++; argc--; parallel = 0; nowait = 0; } else if (strcmp(argv[1], "-nowait") == 0) { argv++; argc--; parallel = 0; nowait = 2; } if (parallel) { sfd = pp_open(); } else { if ((sfd = open("/dev/ttyS0", O_RDWR)) == ERROR) { fprintf(stderr, "Can't open terminal\n"); exit(1); } termios.c_iflag = IGNBRK | IGNPAR; termios.c_oflag = 0; termios.c_cflag = B115200 | CS8 | CREAD | CLOCAL | CSTOPB; termios.c_lflag = 0; termios.c_cc[VMIN] = 1; termios.c_cc[VTIME] = 0; if (tcsetattr(sfd, TCSANOW, &termios) == ERROR) { fprintf(stderr, "Can't open terminal\n"); exit(1); } } if (!nowait) { printf("Reboot Webpal to begin programming...\n"); if (!parallel) wait_boot_prompt(); do_write(sfd, "\001", 1); } sleep(1); printf("Attempting to contact programmer..."); fflush(stdout); /* Send hello message to programming software to see if we can communicate */ if (!hello()) exit(1); printf("done\n"); printf("Initializing flash..."); fflush(stdout); /* Send initialize command to programming software */ if (!initialize()) exit(1); printf("done\n"); /* Read, write, writehex, or erase */ if (strcmp(argv[1], "read") == 0) { if (argc != 4) usage(); return read_partition(argv[2], argv[3]); } if (strcmp(argv[1], "write") == 0) { if (argc != 4) usage(); return program_partition(argv[2], argv[3], 0); } if (strcmp(argv[1], "writehex") == 0) { if (argc != 4) usage(); return program_partition(argv[2], argv[3], 1); } if (strcmp(argv[1], "erase") == 0) { if (argc != 3) usage(); return erase_partition(argv[2]); } usage(); } /* Reads a block of data from the flash */ /* Length is in 16 bit quantities */ int read_flash(int addr, char *buffer, int length) { struct cmd cmd; int count; int checksum; int readl; /* Build and send "R" command to programming software */ set_cmd(&cmd, 'R', addr, length); length = length * 2; do_write(sfd, &cmd, 5); /* Read data */ for (count = 0; count < length + 1; count = count + readl) { readl = do_read(sfd, buffer+count, length+1-count); if (readl == 0) exit; } /* Check checksum at end of data */ checksum = 0; for (count = 0; count < length; count++) { checksum += buffer[count] & 0xff; if (checksum >= 256) checksum = (checksum & 0xff) + 1; } if (checksum != (buffer[length] & 0xff)) { printf("checksum error %d %d\n", checksum, buffer[length] & 0xff); return 0; } else return 1; } /* Write a block of data to the flash */ /* Length is in 16 bit quantities */ int write_flash(int addr, char *buffer, int length) { struct cmd cmd; int count; int checksum; int readl; char checksumbuf[1]; /* Build and send "W" command */ set_cmd(&cmd, 'W', addr, length); length = length * 2; do_write(sfd, &cmd, 5); /* Send data to be programmed */ count = do_write(sfd, buffer, length); /* Generate and send checksum */ checksum = 0; for (count = 0; count < length; count++) { checksum += buffer[count] & 0xff; if (checksum >= 256) checksum = (checksum + 1) & 0xff; } checksumbuf[0] = checksum & 0xff; do_write(sfd, checksumbuf, 1); /* Read status */ if (do_read(sfd, checksumbuf, 1) != 1) { printf("didn't read anything\n"); exit(1); } if (checksumbuf[0] == 0) return 1; else { /* printf("read %x\n", checksumbuf[0] & 0xff) */; return 0; } } /* Send initialize command */ initialize() { struct cmd cmd; char checksumbuf[1]; set_cmd(&cmd, 'I', 0, 0); do_write(sfd, &cmd, 5); if (do_read(sfd, checksumbuf, 1) != 1) { printf("didn't read anything\n"); exit(1); } if (checksumbuf[0] == 0) { return 1; } else { printf("read %x\n", checksumbuf[0] & 0xff); return 0; } } /* Send hello command */ /* Used to verify communication with programming software */ hello() { struct cmd cmd; char checksumbuf[1]; set_cmd(&cmd, 'H', 0, 0); do_write(sfd, &cmd, 5); if (do_read(sfd, checksumbuf, 1) != 1) { printf("didn't read anything\n"); exit(1); } if (checksumbuf[0] == 0) { return 1; } else { printf("read %x\n", checksumbuf[0] & 0xff); return 0; } } /* Send erase (whole flash) command */ erase() { struct cmd cmd; char checksumbuf[1]; set_cmd(&cmd, 'X', 0, 0); do_write(sfd, &cmd, 5); if (do_read(sfd, checksumbuf, 1) != 1) { printf("didn't read anything\n"); exit(1); } if (checksumbuf[0] == 0) { return 1; } else { printf("read %x\n", checksumbuf[0] & 0xff); return 0; } } /* Send erase sector command */ erase_sector(int addr) { struct cmd cmd; char checksumbuf[1]; set_cmd(&cmd, 'S', addr / 2, 0); do_write(sfd, &cmd, 5); if (do_read(sfd, checksumbuf, 1) != 1) { printf("didn't read anything\n"); exit(1); } if (checksumbuf[0] == 0) { return 1; } else { printf("read %x\n", checksumbuf[0] & 0xff); return 0; } } /* Reads in hex files */ int page = 0; int maxaddr = 0; int hex(char c) { if ((c >= '0') && (c <= '9')) return c - '0'; if ((c >= 'a') && (c <= 'f')) return c - 'a' + 10; if ((c >= 'A') && (c <= 'F')) return c - 'A' + 10; printf("bad hex digit: '%c'\n", c); exit(1); } int parse_line(char *buffer, char *mem, int rom_size, int *max_mem) { char *c = buffer; unsigned int address, word_addr; unsigned int length,type; unsigned int checksum = 0; int count = 0; if (*c++ != ':') return -2; /* Skip colon */ length = (hex(*c++) << 4) + hex(*c++); checksum = length; address = (hex(*c++) << 12) + (hex(*c++) << 8) + (hex(*c++) << 4) + hex(*c++); checksum += address & 255; checksum += address >> 8; if (length == 0) { return 0; /* EOF record */ } type = (hex(*c++) << 4) + hex(*c++); checksum += type; switch (type) { case 0: while (length--) { if ((page * 16 + address) >= rom_size) { printf("image too large\n"); exit(1); } mem[page * 16 + address]= (hex(*c++) << 4) + hex(*c++); checksum += mem[page * 16 + address] & 0xff; address++; } if ((page * 16 + address) > *max_mem) *max_mem = page * 16 + address; break; case 2: if (length != 2) return -2; page = (hex(*c++) << 12) + (hex(*c++) << 8) + (hex(*c++) << 4) + hex(*c++); checksum += page & 0xff; checksum += page >> 8; break; default: printf("unknown type %d\n", type); return -2; } checksum += (hex(*c++) << 4) + hex(*c++); if ((checksum & 255) == 0) return count; else return -1; } int read_object(char *filename, char *memory, int rom_size) { FILE *f; char line[80]; int lines_read = 0; int count = 0; int bytes ; static int max_mem; max_mem = 0; if(filename) f = fopen(filename, "r"); else f = stdin; if(filename == NULL) filename = "stdin"; printf("Reading object file '%s'...",filename); fflush(stdout); if (f == NULL) { printf("failed...cannot open object file\n"); exit(1); } while (fgets(line, sizeof(line)-1, f)) { lines_read++; bytes = parse_line(line, memory,rom_size, &max_mem); if (bytes == -1) { printf("\nChecksum error in object file on line %d.\n%s\n", lines_read, line); exit(1); } if (bytes > 0) count += bytes; if (bytes == -2) printf("\n%s\n",line); } fclose(f); printf("done\n"); return max_mem; //return highest memory address used } /* Reads in binary files */ int read_raw(char *filename, char *memory, int rom_size) { FILE *f; char line[80]; int lines_read = 0; int count = 0; int bytes ; static int max_mem; max_mem = 0; if(filename) f = fopen(filename, "r"); else f = stdin; if(filename == NULL) filename = "stdin"; printf("Reading raw object file '%s'...",filename); fflush(stdout); if (f == NULL) { printf("failed...cannot open object file\n"); exit(1); } while (count = fread(memory, 1, 1024, f)) { memory += count; max_mem += count; } fclose(f); printf("done\n"); return max_mem; //return highest memory address used } bad_partition(char *name) { fprintf(stderr, "Unknown partition: %s\n\n", name); usage(); } usage() { struct partition *partition = partitions; fprintf(stderr, "usage:\n"); fprintf(stderr, " wpflash read -- read\n"); fprintf(stderr, " wpflash write -- erase/write\n"); fprintf(stderr, " wpflash writehex -- erase/write\n"); fprintf(stderr, " wpflash erase -- erase all flash\n\n"); fprintf(stderr, " is one of:"); while (partition->name[0]) { fprintf(stderr, " %s", partition->name); partition++; } fprintf(stderr, "\n"); exit(1); } pp_write(int fd, char value) { u_char d = value; if (ioctl(fd, PPWDATA, &d) == 1) perror("write failed"); } u_char pp_read(int fd) { u_char d; if (ioctl(fd, PPRSTATUS, &d) == 1) perror("read failed"); return d; } int pp_open() { int i; int fd; fd = open("/dev/parport0", O_RDWR); if (fd < 0) { perror("Open parport0"); exit(1); } i = 0; if (ioctl (fd, PPCLAIM, &i) == 1) { perror("PPCLAIM failed"); exit(1); } pp_write(fd, 0x00); return fd; } int xfer_byte(int fd, int ivalue) { int ovalue; int c; /* Input the low nibble */ while (1) { c = pp_read(fd); if ((c & 0x80) == 0) break; } c = pp_read(fd); /* printf("got first nibble %02x\n", c); */ ovalue = (c >> 3) & 0x0f; /* Output the low nibble */ pp_write(fd, ivalue & 0xff); pp_write(fd, 0x10 | (ivalue & 0xff)); /* Input the high nibble */ while (1) { c = pp_read(fd); if (c & 0x80) break; } c = pp_read(fd); /* printf("got second nibble %02x\n", c); */ ovalue = ovalue | ((c << 1) & 0xf0); /* Output the high nibble */ pp_write(fd, 0x10 | ((ivalue >> 4) & 0x0f)); pp_write(fd, (ivalue >> 4) & 0x0f); /* printf("ivalue %02x ovalue %02x \n", ivalue, ovalue); */ return ovalue; } int parallel_write(int fd, char *buffer, int count) { int tempcount = count; int thiscount; while (count) { if (xfer_byte(fd, 0) != 0) { printf("Sync error\n"); exit(1); } if (count < 256) thiscount = count; else thiscount = 255; count -= thiscount; xfer_byte(fd, thiscount); while (thiscount--) { xfer_byte(fd, *buffer++); } } return tempcount; } char readbuf[256]; int readcount = 0; int readoffset = 0; int parallel_read(int fd, char *buffer, int count) { int tempcount = count; while (count) { if (readcount) { *buffer++ = readbuf[readoffset++]; readcount--; count--; } else { readcount = xfer_byte(fd, 0); if (readcount == 0) { printf("Sync error\n"); exit(1); } readoffset = 0; while (readoffset != readcount) { readbuf[readoffset++] = xfer_byte(fd, 0); } readoffset = 0; } } return tempcount; } int do_write(int fd, void *buffer, int count) { if (parallel) return parallel_write(fd, buffer, count); else return write(fd, buffer, count); } int do_read(int fd, void *buffer, int count) { if (parallel) return parallel_read(fd, buffer, count); else return read(fd, buffer, count); } flash/p16F877.inc0000644000076500007650000000310607214462121013201 0ustar brdbrd00000000000000; ; pic16c84.h ; ; definitions for PIC16C84 registers ; ; if ~defined(__16C84) & ~defined(__16F84) ; error "this include file is for PIC16C84" ; endif ; Page 0 IND0 equ 00h INDF equ 00h TMR0 equ 01h RTCC equ TMR0 PCL equ 02h STATUS equ 03h FSR equ 04h PORTA equ 05h PORTB equ 06h EEDATA equ 08h EEADR equ 09h PCLATH equ 0ah INTCON equ 0bh ; Page 1 OPTIO equ 01h TRISA equ 05h TRISB equ 06h EECON1 equ 08h EECON2 equ 09h ; ; STATUS bits ; IRP equ 07h RP1 equ 06h RP0 equ 05h TO equ 04h PD equ 03h Z equ 02h DC equ 01h C equ 00h ; ; INTCON bits ; GIE equ 7 EEIE equ 6 RTIE equ 5 TOIE equ 5 INTE equ 4 RBIE equ 3 T0IF equ 2 RTIF equ 2 INTF equ 1 RBIF equ 0 ; ; OPTION bits ; RBPU equ 7 INTEDG equ 6 RTS equ 5 RTE equ 4 PSA equ 3 PS2 equ 2 PS1 equ 1 PS0 equ 0 ; ; EECON1 bits ; EEIF equ 4 WRERR equ 3 WREN equ 2 EWR equ 1 ERD equ 0 ; ; 'direction' flags ; W equ 0 F equ 1 ;========================================================================== ; ; Configuration Bits ;========================================================================== _CP_ON EQU 0x3FEF _CP_OFF EQU 0x3FFF _PWRTE_ON EQU 0x3FFF _PWRTE_OFF EQU 0x3FF7 _WDT_ON EQU 0x3FFF _WDT_OFF EQU 0x3FFB _LP_OSC EQU 0x3FFC _XT_OSC EQU 0x3FFD _HS_OSC EQU 0x3FFE _RC_OSC EQU 0x3FFF flash/webpal.simm0000664000076500007650000000337007214462121013672 0ustar brdbrd00000000000000SIMM NAME FLASH1 FLASH2 PRGM PIC PGRM PIN# PIN# PIN# NAME PORT 1 * GND VSS VSS GND GND 23 2 * D0 D0 D0 B0 16 3 * D16 D0 4 * D1 D1 D1 B1 14 5 * D17 D1 6 * D2 D2 D2 B2 12 7 * D18 D2 8 * D3 D3 D3 B3 10 9 * D19 D3 10 * VCC VCC VCC VCC VCC 21 11 * N/C 12 N/C 13 N/C 14 N/C 15 N/C 16 N/C 17 N/C 18 WE' WE' WE' WE' E2 19 19 OE' OE' OE' OE' E1 17 20 * D4 D4 21 * D20 D4 D4 B4 8 22 * D5 D5 23 * D21 D5 D5 B5 6 24 * D6 D6 25 * D22 D6 D6 B6 4 26 * D7 D7 27 * D23 D7 D7 B7 2 28 CE' CE' CE' CE' E0 15 29 * N/C 30 * VCC 31 LA23 32 LA22 33 LA21 34 LA20 A18 A18 A18 - U3-17 35 LA19 A17 A17 A17 - U3-18 36 LA18 A16 A16 A16 - U3-19 37 N/C 38 LA17 A15 A15 A15 - U2-12 39 N/C 40 LA16 A14 A14 A14 - U2-13 41 LA15 A13 A13 A13 - U2-14 42 LA14 A12 A12 A12 - U2-15 43 LA13 A11 A11 A11 - U2-16 44 LA12 A10 A10 A10 - U2-17 45 LA11 A9 A9 A9 - U2-18 46 LA10 A8 A8 A8 - U2-19 47 LA9 A7 A7 A7 - U1-12 48 LA8 A6 A6 A6 - U1-13 49 * D8 D8 D8 D0 37 50 * D24 D8 51 * D9 D9 D9 D1 39 52 * D25 D9 53 * D10 D10 D10 D2 40 54 * D26 D10 55 * D11 D11 D11 D3 38 56 * D27 D11 57 * D12 D12 D12 D4 28 58 * D28 D12 59 * VCC VCC VCC VCC VCC 21 60 * D29 D13 D5 26 61 * D13 D13 62 * D30 D14 D6 24 63 * D14 D14 64 * D31 D15/A-1 D7 22 65 * D15 D15/A-1 D15 66 LA7 A5 A5 A5 - U1-14 67 LA6 A4 A4 A4 - U1-15 68 LA5 A3 A3 A3 - U1-16 69 LA4 A2 A2 A2 - U1-17 70 LA3 A1 A1 A1 - U1-18 71 LA2 A0 A0 A0 - U1-19 72 * GND GND GND GND GND 23 OTHER WIRING FOR PROGRAMMER: ADDR6 A0 3 U123-8 ADDR7 A1 5 U123-9 STRB1 A2 7 U1-10 STRB2 A3 9 U2-10 STRB3 A4 11 U3-10 ADDR0 C0 29 U123-2 ADDR1 C1 31 U123-3 ADDR2 C2 33 U123-4 ADDR3 C3 35 U123-5 ADDR4 C4 36 U123-6 ADDR5 C5 34 U123-7 flash/wpflash.c0000664000076500007650000006232510053751726013355 0ustar brdbrd00000000000000#include #include #include #include #include #include #include int do_write(int, void *, int); int do_read(int, void *, int); #define ERROR (-1) int sfd; int nowait = 0; int parallel = 0; #define FLASHSIZE (8* 1024 * 1024) char buffer [1024]; char membuf[FLASHSIZE]; struct cmd { char type; unsigned char length; unsigned char addrhi; unsigned char addrmed; unsigned char addrlow; }; int addr; /* Flash Partition definitions */ struct partition { char name[32]; int start; int size; } ; struct partition part1[] = { { "all" , 0x000000, 0x100000 }, /* 1M */ { "boot" , 0x000000, 0x006000 }, /* 24K */ { "params", 0x006000, 0x002000 }, /* 8K */ { "zImage", 0x008000, 0x098000 }, /* 608K */ { "root" , 0x0a0000, 0x060000 }, /* 384K */ { "erx" , 0x020000, 0x0c0000 }, /* erx spot */ { "" , 0x000000, 0x000000 } }; struct partition part2[] = { { "all" , 0x000000, 0x200000 }, /* 2M */ { "boot" , 0x000000, 0x008000 }, /* 32K */ { "params", 0x008000, 0x004000 }, /* 16K */ { "zImage", 0x00c000, 0x094000 }, /* 592K */ { "root" , 0x0a0000, 0x160000 }, /* 1408K */ { "" , 0x000000, 0x000000 } }; int width; int totalSizeMB; int size; int root_start = -1; struct partition_table { int size; struct partition *table; } partition_tables[] = { { 1, part1 }, { 2, part2 }, { 0 } }; struct partition *partition_table = part1; struct partition modified; struct partition *find_partition(char *); /* This structure defines the sectors on the FLASH */ struct sector { int start; int size; int count; } sectors2258[] = { { 0x000000, 0x004000, 1 }, { 0x004000, 0x002000, 2 }, { 0x008000, 0x008000, 1 }, { 0x010000, 0x010000, 15 }, { 0, 0, 0} }; struct flash_chip { int id; int size; struct sector *sectors; char *name; } flash_chips[] = { {0x2258, 512, sectors2258, "29F800B"}, {0, 0, NULL} }; struct sector *sector_table = NULL; int set_partition_table(int size) { struct partition_table *p = partition_tables; while (p->size) { if (p->size == size) { partition_table = p->table; return (1); } p++; } return 0; } struct flash_chip * find_flash_chip(int id) { struct flash_chip *f = flash_chips; while (f->size) { if (f->id == id) return f; f++; } return NULL; } struct partition * fixup_zImage_partition(struct partition *partition) { struct partition *root; int saved_root_start; /* Look up roots original size and add new space to zImage partition size. root_start == 0 returns all its space */ saved_root_start = root_start; root_start = -1; root = find_partition("root"); root_start = saved_root_start; strcpy(modified.name, partition->name); modified.start = partition->start; if (root_start == 0) modified.size = partition->size + root->size; else modified.size = partition->size + (root_start - root->start); return &modified; } struct partition * fixup_root_partition(struct partition *partition) { struct partition *root; /* Root start == 0 means it doesn't exist! */ if (root_start == 0) return NULL; strcpy(modified.name, partition->name); modified.start = root_start; modified.size = root->size - (root_start - root->start); return &modified; } struct partition * fixup_partition(struct partition *partition) { if (root_start == -1) /* Nothing to change */ return partition; if (strcmp(partition->name, "zImage") == 0) return fixup_zImage_partition(partition); if (strcmp(partition->name, "root") == 0) return fixup_root_partition(partition); return partition; } /* Find a partition name */ struct partition * find_partition(char *name) { struct partition *partition = partition_table; while (partition->name[0]) { if (strcmp(name, partition->name) == 0) return fixup_partition(partition); partition++; } bad_partition(); } /* Initialize a "cmd" structure */ void set_cmd(struct cmd *cmd, char type, int addr, int length) { cmd->type = type; if (length == 256) cmd->length = 0; else cmd->length = length & 0xff; cmd->addrhi = (addr >> 16) & 0xff; cmd->addrmed = (addr >> 8) & 0xff; cmd->addrlow = (addr & 0xff); // printf("cmd %02x %02x %02x %02x %02x\n", // cmd->type, cmd->length, cmd->addrhi, // cmd->addrmed, cmd->addrlow); } /* Wait for "WebPal Linux Loader" prompt from the Webpal. This indicates the WebPal has been booted and is waiting for "CONTROL-A" to signal it should jump to the programming code */ wait_boot_prompt() { char line[256], *s; s = line; while (1) { do_read(sfd, s, 1); if (*s == '\r') ; else if (*s == '\n') { *s = 0; if (strcmp(line, "Enter CTRL-A to enter programmer.") == 0) return 1; s = line; } else { s++; } } } /* Erase a partition */ erase_partition(char *name) { struct partition *partition = find_partition(name); unsigned int partition_start, partition_end; unsigned int sector_start, sector_end; int i; struct sector *s; if (partition == NULL) { printf("Partition not found\n"); exit(1); } partition_start = partition->start; partition_end = partition->start + partition->size; /* Loop through the sectors making sure that the paritition is aligned with the sectors. Not the most efficient way of doing this, but its a simple way. Since sectors are for 16 flash, we have to modify the sector addresses based on the width of the flash. */ printf("Checking partition and sector alignment"); fflush(stdout); for (s = sector_table; s->size != 0; s++) { for (i=0; i < s->count; i++) { sector_start = (s->start + (s->size * i)) * width / 2; sector_end = sector_start + (s->size * width / 2); if (partition_start >= sector_end) continue; if (partition_end <= sector_start) continue; if (partition_start > sector_start) { printf( "Partition start(%x) > Sector start (%x)\n", partition_start, sector_start); exit(1); } if (partition_end < sector_end) { printf("Partition end(%x) < Sector end (%x)\n", partition_end, sector_end); exit(1); } printf("."); fflush(stdout); } } printf("done.\n"); /* Now erase the appropriate sectors on the flash for this partition. Note that although the sector addresses are multiplied by a width factor for the comparison with the partition addresses, the sector addresses are not changed based on the width when issuing the erase sector command. */ printf("Erasing %s sectors", partition->name); fflush(stdout); for (s = sector_table; s->size != 0; s++) { for (i=0; i < s->count; i++) { sector_start = (s->start + s->size * i) * width / 2; sector_end = sector_start + (s->size * width / 2); if (partition_start >= sector_end) continue; if (partition_end <= sector_start) continue; erase_sector(s->start + s->size * i); printf("."); fflush(stdout); } } printf("done.\n"); } /* Program a partition */ program_partition(char *name, char *filename, int hexdump) { struct partition *partition = find_partition(name); int addr, maxaddr, maxpgm, addrincr, startaddr; int i; /* Load data to be programmed in either hex or binary format */ if (hexdump) maxaddr = read_object(filename, membuf, FLASHSIZE); else maxaddr = read_raw(filename, membuf, FLASHSIZE); /* Print statistics and check data fits in partition. */ printf("Data size is %d bytes (%d%% of '%s' partition used).\n", maxaddr, (maxaddr * 100 + partition->size - 1)/ partition->size, partition->name); if (maxaddr > partition->size) { printf("Data to large for '%s' partition\n", name); exit(1); } /* Erase the partition. */ erase_partition(name); /* Calculate write loop variable based on flash width. Address values are in 'flash width' values. Pad maxpgm out to a even number of 'flash width' units. */ startaddr = partition->start / width; addrincr = 256 / width; maxpgm = (maxaddr + (width - 1)) / width; for (addr = 0; addr < maxpgm; addr = addr + addrincr) { if (!write_flash(startaddr + addr, &membuf[addr*width], 256)) printf("checksum error %d\n", addr); if ((addr % 4096) == 0) { printf("%d\r", addr * width); fflush(stdout); } } printf("%d bytes written.\n", addr * width); return 0; } /* Read a partition */ read_partition(char *name, char *filename) { struct partition *partition = find_partition(name); FILE *file; int addr, maxpgm, startaddr, addrincr; file = fopen(filename, "w"); if (file == NULL) { fprintf(stderr, "Could not open '%s'\n", filename); exit(1); } /* Calculate address values for read loop based on flash width. These addresses are in 'flash width' values. Pad maxpgm out to an even number of 'flash width' units (although the partitions should already be of this size). */ addrincr = 256 / width; maxpgm = (partition->size + (width - 1))/ width; startaddr = partition->start / width; printf("Reading partition '%s' (%d bytes) to file '%s'\n", partition->name, partition->size, filename); for (addr = 0; addr < maxpgm; addr = addr + addrincr) { if (!read_flash(startaddr + addr, membuf, 256)) printf("checksum error\n"); fwrite(membuf, 1, 256, file); if ((addr % 4096) == 0) { printf("%d\r", addr * width); fflush(stdout); } } printf("%d bytes read.\n", addr * width); fclose(file); return(0); } main(int argc, char **argv) { struct termios termios; char c; int i; int cpid; int count; int maxcount; int version; int deviceID1, deviceID2; struct flash_chip *f; char tempfile[32]; int fd; printf("Webpal flash programmer V3.1 1/29/04.\n"); if (argc < 2) usage(); if (strcmp(argv[1], "-p") == 0) { argv++; argc--; parallel = 1; nowait = 0; } else if (strcmp(argv[1], "-s") == 0) { argv++; argc--; parallel = 0; nowait = 0; } else if (strcmp(argv[1], "-nowait") == 0) { argv++; argc--; parallel = 0; nowait = 2; } if (parallel) { sfd = pp_open(); } else { if ((sfd = open("/dev/ttyS0", O_RDWR)) == ERROR) { fprintf(stderr, "Can't open terminal\n"); exit(1); } termios.c_iflag = IGNBRK | IGNPAR; termios.c_oflag = 0; termios.c_cflag = B115200 | CS8 | CREAD | CLOCAL | CSTOPB; termios.c_lflag = 0; termios.c_cc[VMIN] = 1; termios.c_cc[VTIME] = 0; if (tcsetattr(sfd, TCSANOW, &termios) == ERROR) { fprintf(stderr, "Can't open terminal\n"); exit(1); } } if (!nowait) { printf("Reboot Webpal to begin programming...\n"); if (!parallel) wait_boot_prompt(); do_write(sfd, "\001", 1); } sleep(1); /* Send hello message to programming software to see if we can communicate and to get version number */ printf("Contacting programmer..."); fflush(stdout); version = hello(); printf("detected version %d...done.\n", version); /* Send initialize command to programming software */ printf("Initializing flash..."); fflush(stdout); if (!initialize()) exit(1); printf("done\n"); /* Determine device. Use special 'dummy' routine for version 0 programmers */ if (version > 0) device_id(&deviceID1, &deviceID2); else device_id_v0(&deviceID1, &deviceID2); /* If both deviceIDs are the same, we have two chips wide, thus width is 4 bytes. Otherwise, assume its 2 bytes wide (one chip). For two chip case, send 'double_wide' command to programmer to tell it this */ if (deviceID1 == deviceID2) { width = 4; double_wide(); } else width = 2; /* Now look up the chip based on the deviceID. Save size, sector table, and calculate total size in MB */ if ((f = find_flash_chip(deviceID2)) == NULL) { printf("Chip id unknown %04x\n", deviceID1); exit(1); } size = f->size; sector_table = f->sectors; totalSizeMB = size * width / 1024; printf("Found %d X %s flash -- %dK X %d bits (total size = %d MByte).\n", width / 2, f->name, size, width * 8, totalSizeMB); /* Set partition table. Right now, this just uses the total size as key. FIXME: A better key would be the total size and flash chip ID */ if (!set_partition_table(totalSizeMB)) { printf("No sector table found for %d MByte size", totalSizeMB); exit(1); } /* Try and read partition information from params partition on the flash */ printf("Reading 'params' partition to check partitioning info...\n"); strcpy(tempfile, "/tmp/wpflashXXXXXX"); fd = mkstemp(tempfile); if (fd != -1) { close(fd); /* So much for race protection with mkstemp :-) */ read_partition("params", tempfile); root_start = parse_flash_params(tempfile); // unlink(tempfile); switch (root_start) { case 0: printf("Root partition disabled.\n"); break; case -1: printf("No changes from default partition table\n"); break; default: printf("Root partition starts at %x.\n", root_start); break; } } else { printf("Could not read partition information from flash\n"); exit(1); } /* New we are ready to do the operation requested */ /* Read, write, writehex, or erase */ if (strcmp(argv[1], "read") == 0) { if (argc != 4) usage(); return read_partition(argv[2], argv[3]); } if (strcmp(argv[1], "write") == 0) { if (argc != 4) usage(); return program_partition(argv[2], argv[3], 0); } if (strcmp(argv[1], "writehex") == 0) { if (argc != 4) usage(); return program_partition(argv[2], argv[3], 1); } if (strcmp(argv[1], "erase") == 0) { if (argc != 3) usage(); return erase_partition(argv[2]); } /* If we got to here, an invalid operation was specified */ usage(); } /* Reads a block of data from the flash. addr is in 'flash width' units. length is in bytes. */ int read_flash(int addr, char *buffer, int length) { struct cmd cmd; int count; int checksum; int readl; /* Build and send "R" command to programmer. Programmer wants length value in 16 bit quantities so divide by 2 */ set_cmd(&cmd, 'R', addr, length / 2); do_write(sfd, &cmd, 5); /* Read data */ for (count = 0; count < length + 1; count = count + readl) { readl = do_read(sfd, buffer+count, length+1-count); if (readl == 0) exit; } /* Check checksum at end of data */ checksum = 0; for (count = 0; count < length; count++) { checksum += buffer[count] & 0xff; if (checksum >= 256) checksum = (checksum & 0xff) + 1; } if (checksum != (buffer[length] & 0xff)) { printf("checksum error reading data from flash: %d %d\n", checksum, buffer[length] & 0xff); return 0; } else return 1; } /* Write a block of data to the flash. addr is is 'flash width' units. length is in bytes */ int write_flash(int addr, char *buffer, int length) { struct cmd cmd; int count; int checksum; int readl; char checksumbuf[1]; /* Build and send "W" command to programmer. Programmer wants length in 16 bit quantities so divide by 2 */ set_cmd(&cmd, 'W', addr, length / 2); do_write(sfd, &cmd, 5); /* Send data to be programmed */ count = do_write(sfd, buffer, length); /* Generate and send checksum */ checksum = 0; for (count = 0; count < length; count++) { checksum += buffer[count] & 0xff; if (checksum >= 256) checksum = (checksum + 1) & 0xff; } checksumbuf[0] = checksum & 0xff; do_write(sfd, checksumbuf, 1); /* Read status */ if (do_read(sfd, checksumbuf, 1) != 1) { printf("no resposne to 'write flash' command.\n"); exit(1); } if (checksumbuf[0] == 0) return 1; else { printf("write flash @ %08x: command failure: code %x\n", addr, checksumbuf[0] & 0xff); return 0; } } /* Send initialize command */ initialize() { struct cmd cmd; char checksumbuf[1]; set_cmd(&cmd, 'I', 0, 0); do_write(sfd, &cmd, 5); if (do_read(sfd, checksumbuf, 1) != 1) { printf("not response to 'initialize' command\n"); exit(1); } if (checksumbuf[0] == 0) { return 1; } else { printf("'initialize' command failure: code %x\n", checksumbuf[0] & 0xff); return 0; } } /* Send device id command. Returns the device id of the flash chip(s) in the programmer. Not supoorted in Version 0 programmers */ int device_id(int *deviceID1, int *deviceID2) { struct cmd cmd; unsigned char checksumbuf[5]; set_cmd(&cmd, 'D', 0, 0); do_write(sfd, &cmd, 5); if (do_read(sfd, checksumbuf, 5) != 5) { printf("no response to 'device id' command\n"); exit(1); } if (checksumbuf[4] != 0) { printf("'device id' command failure: code %d\n", checksumbuf[0] & 0xff); return 0; } *deviceID1 = checksumbuf[0] *256 + checksumbuf[1]; *deviceID2 = checksumbuf[2] *256 + checksumbuf[3]; return 1; } /* Dummy routine to simulate device_id command in programmer that do not support it. Simply returns a fixed device ID matching the flash supported by that version of the programmer */ int device_id_v0(int *deviceID1, int *deviceID2) { *deviceID1 = 0xffff; *deviceID2 = 0x2258; return 1; } /* Send 32 bit mode command/ Tells the programmer to program a 32 bit wide flash. Note supported on Version 0 programmers. */ double_wide() { struct cmd cmd; char checksumbuf[1]; set_cmd(&cmd, 'T', 0, 0); do_write(sfd, &cmd, 5); if (do_read(sfd, checksumbuf, 1) != 1) { printf("no response to 'double_width' command\n"); exit(1); } if (checksumbuf[0] == 0) { return 1; } else { printf("'double width' command failure: code %x\n", checksumbuf[0] & 0xff); return 0; } } int parse_flash_params(char *filename) { FILE *fp; char line[256]; printf("Parsing partitioning information\n"); fp = fopen(filename, "r"); if (fp == NULL) return -1; while (fgets(line, 255, fp)) { if (strncmp(line, "root_start=", 11) == 0) { if (sscanf(line+11, "%x", &root_start) != 1) root_start = -1; fclose(fp); return root_start; } } fclose(fp); return -1; } /* Send hello command Used to verify communication with programming software. Also returned version number of programmer */ int hello() { struct cmd cmd; char checksumbuf[1]; set_cmd(&cmd, 'H', 0, 0); do_write(sfd, &cmd, 5); if (do_read(sfd, checksumbuf, 1) != 1) { printf("no response to 'hello' command\n"); exit(1); } return (checksumbuf[0]); } /* Send erase (whole flash) command */ erase() { struct cmd cmd; char checksumbuf[1]; set_cmd(&cmd, 'X', 0, 0); do_write(sfd, &cmd, 5); if (do_read(sfd, checksumbuf, 1) != 1) { printf("no response to 'erase' command\n"); exit(1); } if (checksumbuf[0] == 0) { return 1; } else { printf("'erase' command failure: code %x\n", checksumbuf[0] & 0xff); return 0; } } /* Send erase sector command */ erase_sector(int addr) { struct cmd cmd; char checksumbuf[1]; set_cmd(&cmd, 'S', addr / 2, 0); do_write(sfd, &cmd, 5); if (do_read(sfd, checksumbuf, 1) != 1) { printf("no resposne to 'erase sector' command\n"); exit(1); } if (checksumbuf[0] == 0) { return 1; } else { printf("'erase sector' command failure: code %x\n", checksumbuf[0] & 0xff); return 0; } } /* Reads in hex files */ int page = 0; int maxaddr = 0; int hex(char c) { if ((c >= '0') && (c <= '9')) return c - '0'; if ((c >= 'a') && (c <= 'f')) return c - 'a' + 10; if ((c >= 'A') && (c <= 'F')) return c - 'A' + 10; printf("bad hex digit: '%c'\n", c); exit(1); } int parse_line(char *buffer, char *mem, int rom_size, int *max_mem) { char *c = buffer; unsigned int address, word_addr; unsigned int length,type; unsigned int checksum = 0; int count = 0; if (*c++ != ':') return -2; /* Skip colon */ length = (hex(*c++) << 4) + hex(*c++); checksum = length; address = (hex(*c++) << 12) + (hex(*c++) << 8) + (hex(*c++) << 4) + hex(*c++); checksum += address & 255; checksum += address >> 8; if (length == 0) { return 0; /* EOF record */ } type = (hex(*c++) << 4) + hex(*c++); checksum += type; switch (type) { case 0: while (length--) { if ((page * 16 + address) >= rom_size) { printf("image too large\n"); exit(1); } mem[page * 16 + address]= (hex(*c++) << 4) + hex(*c++); checksum += mem[page * 16 + address] & 0xff; address++; } if ((page * 16 + address) > *max_mem) *max_mem = page * 16 + address; break; case 2: if (length != 2) return -2; page = (hex(*c++) << 12) + (hex(*c++) << 8) + (hex(*c++) << 4) + hex(*c++); checksum += page & 0xff; checksum += page >> 8; break; default: printf("unknown type %d\n", type); return -2; } checksum += (hex(*c++) << 4) + hex(*c++); if ((checksum & 255) == 0) return count; else return -1; } int read_object(char *filename, char *memory, int rom_size) { FILE *f; char line[80]; int lines_read = 0; int count = 0; int bytes ; static int max_mem; max_mem = 0; if(filename) f = fopen(filename, "r"); else f = stdin; if(filename == NULL) filename = "stdin"; printf("Reading object file '%s'...",filename); fflush(stdout); if (f == NULL) { printf("failed...cannot open object file\n"); exit(1); } while (fgets(line, sizeof(line)-1, f)) { lines_read++; bytes = parse_line(line, memory,rom_size, &max_mem); if (bytes == -1) { printf("\nChecksum error in object file on line %d.\n%s\n", lines_read, line); exit(1); } if (bytes > 0) count += bytes; if (bytes == -2) printf("\n%s\n",line); } fclose(f); printf("done\n"); return max_mem; //return highest memory address used } /* Reads in binary files */ int read_raw(char *filename, char *memory, int rom_size) { FILE *f; char line[80]; int lines_read = 0; int count = 0; int bytes ; static int max_mem; max_mem = 0; if(filename) f = fopen(filename, "r"); else f = stdin; if(filename == NULL) filename = "stdin"; printf("Reading raw object file '%s'...",filename); fflush(stdout); if (f == NULL) { printf("failed...cannot open object file\n"); exit(1); } while (count = fread(memory, 1, 1024, f)) { memory += count; max_mem += count; } fclose(f); printf("done\n"); return max_mem; //return highest memory address used } bad_partition(char *name) { fprintf(stderr, "Unknown partition: %s\n\n", name); usage(); } usage() { struct partition *partition = partition_table; fprintf(stderr, "usage:\n"); fprintf(stderr, " wpflash read -- read\n"); fprintf(stderr, " wpflash write -- erase/write\n"); fprintf(stderr, " wpflash writehex -- erase/write\n"); fprintf(stderr, " wpflash erase -- erase all flash\n\n"); fprintf(stderr, " is one of:"); while (partition->name[0]) { fprintf(stderr, " %s", partition->name); partition++; } fprintf(stderr, "\n"); exit(1); } pp_write(int fd, char value) { u_char d = value; if (ioctl(fd, PPWDATA, &d) == 1) perror("write failed"); } u_char pp_read(int fd) { u_char d; if (ioctl(fd, PPRSTATUS, &d) == 1) perror("read failed"); return d; } int pp_open() { int i; int fd; fd = open("/dev/parport0", O_RDWR); if (fd < 0) { perror("Open parport0"); exit(1); } i = 0; if (ioctl (fd, PPCLAIM, &i) == 1) { perror("PPCLAIM failed"); exit(1); } pp_write(fd, 0x00); return fd; } int xfer_byte(int fd, int ivalue) { int ovalue; int c; /* Input the low nibble */ while (1) { c = pp_read(fd); if ((c & 0x80) == 0) break; } c = pp_read(fd); /* printf("got first nibble %02x\n", c); */ ovalue = (c >> 3) & 0x0f; /* Output the low nibble */ pp_write(fd, ivalue & 0xff); pp_write(fd, 0x10 | (ivalue & 0xff)); /* Input the high nibble */ while (1) { c = pp_read(fd); if (c & 0x80) break; } c = pp_read(fd); /* printf("got second nibble %02x\n", c); */ ovalue = ovalue | ((c << 1) & 0xf0); /* Output the high nibble */ pp_write(fd, 0x10 | ((ivalue >> 4) & 0x0f)); pp_write(fd, (ivalue >> 4) & 0x0f); /* printf("ivalue %02x ovalue %02x \n", ivalue, ovalue); */ return ovalue; } int parallel_write(int fd, char *buffer, int count) { int tempcount = count; int thiscount; while (count) { if (xfer_byte(fd, 0) != 0) { printf("Write Sync error\n"); exit(1); } if (count < 256) thiscount = count; else thiscount = 255; count -= thiscount; xfer_byte(fd, thiscount); while (thiscount--) { xfer_byte(fd, *buffer++); } } return tempcount; } char readbuf[256]; int readcount = 0; int readoffset = 0; int parallel_read(int fd, char *buffer, int count) { int tempcount = count; while (count) { if (readcount) { *buffer++ = readbuf[readoffset++]; readcount--; count--; } else { readcount = xfer_byte(fd, 0); if (readcount == 0) { printf("Read Sync error\n"); exit(1); } readoffset = 0; while (readoffset != readcount) { readbuf[readoffset++] = xfer_byte(fd, 0); } readoffset = 0; } } return tempcount; } int do_write(int fd, void *buffer, int count) { if (parallel) return parallel_write(fd, buffer, count); else return write(fd, buffer, count); } int do_read(int fd, void *buffer, int count) { if (parallel) return parallel_read(fd, buffer, count); else return read(fd, buffer, count); } flash/wpflash.c.oldone0000644000076500007650000004274407726507167014650 0ustar brdbrd00000000000000#include #include #include #include #include #include #include int do_write(int, void *, int); int do_read(int, void *, int); #define ERROR (-1) int sfd; int nowait = 0; int parallel = 0; #define FLASHSIZE (512 * 1024) char buffer [1024]; char membuf[FLASHSIZE*2]; struct cmd { char type; unsigned char length; unsigned char addrhi; unsigned char addrmed; unsigned char addrlow; }; int addr; /* Flash Partition definitions */ struct partition { char name[32]; int start; int size; } partitions[] = { { "all" , 0x000000, 0x100000 }, { "boot" , 0x000000, 0x006000 }, { "params", 0x006000, 0x002000 }, { "root" , 0x008000, 0x058000 }, { "zImage", 0x060000, 0x0a0000 }, { "" , 0x000000, 0x000000 } }; /* This structure defines the sectors on the FLASH */ #define SECTOR_COUNT 19 struct sector { int start; int size; } sectors[SECTOR_COUNT] = { { 0x000000, 0x004000 }, { 0x004000, 0x002000 }, { 0x006000, 0x002000 }, { 0x008000, 0x008000 }, { 0x010000, 0x010000 }, { 0x020000, 0x010000 }, { 0x030000, 0x010000 }, { 0x040000, 0x010000 }, { 0x050000, 0x010000 }, { 0x060000, 0x010000 }, { 0x070000, 0x010000 }, { 0x080000, 0x010000 }, { 0x090000, 0x010000 }, { 0x0A0000, 0x010000 }, { 0x0B0000, 0x010000 }, { 0x0C0000, 0x010000 }, { 0x0D0000, 0x010000 }, { 0x0E0000, 0x010000 }, { 0x0F0000, 0x010000 } }; /* Find a partition name */ struct partition * find_partition(char *name) { struct partition *partition = partitions; while (partition->name[0]) { if (strcmp(name, partition->name) == 0) return partition; partition++; } bad_partition(); } /* Initialize a "cmd" structure */ void set_cmd(struct cmd *cmd, char type, int addr, int length) { cmd->type = type; if (length == 256) cmd->length = 0; else cmd->length = length & 0xff; cmd->addrhi = (addr >> 16) & 0xff; cmd->addrmed = (addr >> 8) & 0xff; cmd->addrlow = (addr & 0xff); /* printf("cmd %02x %02x %02x %02x %02x\n", cmd->type, cmd->length, cmd->addrhi, cmd->addrmed, cmd->addrlow); */ } /* Wait for "WebPal Linux Loader" prompt from the Webpal. This indicates the WebPal has been booted and is waiting for "CONTROL-A" to signal it should jump to the programming code */ wait_boot_prompt() { char line[256], *s; s = line; while (1) { do_read(sfd, s, 1); if (*s == '\r') ; else if (*s == '\n') { *s = 0; if (strcmp(line, "Enter CTRL-A to enter programmer.") == 0) return 1; s = line; } else { s++; } } } /* Erase a partition */ erase_partition(char *name) { struct partition *partition = find_partition(name); int i; printf("Erasing %s sectors", partition->name); fflush(stdout); for (i=0; i < SECTOR_COUNT; i++) { if (partition->start >= (sectors[i].start + sectors[i].size)) continue; if ((partition->start + partition->size) <= sectors[i].start) continue; erase_sector(sectors[i].start); printf("."); fflush(stdout); } printf("done.\n"); } /* Program a partition */ program_partition(char *name, char *filename, int hexdump) { struct partition *partition = find_partition(name); int maxaddr, maxpgm; int i; /* Load data to be programmed in either hex or binary format */ if (hexdump) maxaddr = read_object(filename, membuf, FLASHSIZE*2); else maxaddr = read_raw(filename, membuf, FLASHSIZE*2); /* Print statistics and check data fits in partition. */ printf("Data size is %d bytes (%d%% of '%s' partition used).\n", maxaddr, (maxaddr * 100 + partition->size - 1)/ partition->size, partition->name); if (maxaddr > partition->size) { printf("Data to large for '%s' partition\n", name); exit(1); } /* Program the partition. Since we program in 16 bit quantities, we need to divide several value by 2 to convert */ maxpgm = (maxaddr + 1) / 2; erase_partition(name); for (addr = 0; addr < maxpgm; addr = addr + 128) { if (!write_flash(addr + (partition->start / 2), &membuf[addr*2], 128)) printf("checksum error %d\n", addr); if ((addr % 4096) == 0) { printf("%d\r", addr * 2); fflush(stdout); } } printf("%d\nDone.\n", addr * 2); } /* Read a partition */ read_partition(char *name, char *filename) { struct partition *partition = find_partition(name); FILE *file; int addr; file = fopen(filename, "w"); if (file == NULL) { fprintf(stderr, "Could not open '%s'\n", filename); exit(1); } printf("Reading partition '%s' to '%s'\n", partition->name, filename); for (addr = 0; addr < (partition->size / 2); addr = addr + 128) { if (!read_flash(addr + (partition->start / 2), membuf, 128)) printf("checksum error\n"); fwrite(membuf, 1, 256, file); if ((addr % 4096) == 0) { printf("%d\r", addr * 2); fflush(stdout); } } printf("%d\nDone.\n", addr * 2); fclose(file); return(0); } main(int argc, char **argv) { struct termios termios; char c; int i; int cpid; int count; int maxcount; if (argc < 2) usage(); /* Initialize programmer */ if (strcmp(argv[1], "-p") == 0) { argv++; argc--; parallel = 1; nowait = 0; } else if (strcmp(argv[1], "-s") == 0) { argv++; argc--; parallel = 0; nowait = 0; } else if (strcmp(argv[1], "-nowait") == 0) { argv++; argc--; parallel = 0; nowait = 2; } if (parallel) { sfd = pp_open(); } else { if ((sfd = open("/dev/ttyS0", O_RDWR)) == ERROR) { fprintf(stderr, "Can't open terminal\n"); exit(1); } termios.c_iflag = IGNBRK | IGNPAR; termios.c_oflag = 0; termios.c_cflag = B115200 | CS8 | CREAD | CLOCAL | CSTOPB; termios.c_lflag = 0; termios.c_cc[VMIN] = 1; termios.c_cc[VTIME] = 0; if (tcsetattr(sfd, TCSANOW, &termios) == ERROR) { fprintf(stderr, "Can't open terminal\n"); exit(1); } } if (!nowait) { printf("Reboot Webpal to begin programming...\n"); if (!parallel) wait_boot_prompt(); do_write(sfd, "\001", 1); } sleep(1); printf("Attempting to contact programmer..."); fflush(stdout); /* Send hello message to programming software to see if we can communicate */ if (!hello()) exit(1); printf("done\n"); printf("Initializing flash..."); fflush(stdout); /* Send initialize command to programming software */ if (!initialize()) exit(1); printf("done\n"); /* Get device id */ printf("Get device id\n"); device_id(); /* Read, write, writehex, or erase */ if (strcmp(argv[1], "read") == 0) { if (argc != 4) usage(); return read_partition(argv[2], argv[3]); } if (strcmp(argv[1], "write") == 0) { if (argc != 4) usage(); return program_partition(argv[2], argv[3], 0); } if (strcmp(argv[1], "writehex") == 0) { if (argc != 4) usage(); return program_partition(argv[2], argv[3], 1); } if (strcmp(argv[1], "erase") == 0) { if (argc != 3) usage(); return erase_partition(argv[2]); } usage(); } /* Reads a block of data from the flash */ /* Length is in 16 bit quantities */ int read_flash(int addr, char *buffer, int length) { struct cmd cmd; int count; int checksum; int readl; /* Build and send "R" command to programming software */ set_cmd(&cmd, 'R', addr, length); length = length * 2; do_write(sfd, &cmd, 5); /* Read data */ for (count = 0; count < length + 1; count = count + readl) { readl = do_read(sfd, buffer+count, length+1-count); if (readl == 0) exit; } /* Check checksum at end of data */ checksum = 0; for (count = 0; count < length; count++) { checksum += buffer[count] & 0xff; if (checksum >= 256) checksum = (checksum & 0xff) + 1; } if (checksum != (buffer[length] & 0xff)) { printf("checksum error %d %d\n", checksum, buffer[length] & 0xff); return 0; } else return 1; } /* Write a block of data to the flash */ /* Length is in 16 bit quantities */ int write_flash(int addr, char *buffer, int length) { struct cmd cmd; int count; int checksum; int readl; char checksumbuf[1]; /* Build and send "W" command */ set_cmd(&cmd, 'W', addr, length); length = length * 2; do_write(sfd, &cmd, 5); /* Send data to be programmed */ count = do_write(sfd, buffer, length); /* Generate and send checksum */ checksum = 0; for (count = 0; count < length; count++) { checksum += buffer[count] & 0xff; if (checksum >= 256) checksum = (checksum + 1) & 0xff; } checksumbuf[0] = checksum & 0xff; do_write(sfd, checksumbuf, 1); /* Read status */ if (do_read(sfd, checksumbuf, 1) != 1) { printf("didn't read anything\n"); exit(1); } if (checksumbuf[0] == 0) return 1; else { /* printf("read %x\n", checksumbuf[0] & 0xff) */; return 0; } } /* Send initialize command */ initialize() { struct cmd cmd; char checksumbuf[1]; set_cmd(&cmd, 'I', 0, 0); do_write(sfd, &cmd, 5); if (do_read(sfd, checksumbuf, 1) != 1) { printf("didn't read anything\n"); exit(1); } if (checksumbuf[0] == 0) { return 1; } else { printf("read %x\n", checksumbuf[0] & 0xff); return 0; } } /* Send device id command */ device_id() { struct cmd cmd; unsigned char checksumbuf[5]; set_cmd(&cmd, 'D', 0, 0); do_write(sfd, &cmd, 5); if (do_read(sfd, checksumbuf, 5) != 5) { printf("didn't read anything\n"); exit(1); } if (checksumbuf[4] != 0) { printf("read %x\n", checksumbuf[0] & 0xff); return 0; } printf("Device ID: %02x%02x %02x%02x\n", checksumbuf[0], checksumbuf[1], checksumbuf[2], checksumbuf[3], checksumbuf[4]); if ((checksumbuf[0] == checksumbuf[2]) && (checksumbuf[1] == checksumbuf[3])) double_wide(); return 1; } /* Send 32 bit mode command */ /* Used to indicate a 32 bit wide flash */ double_wide() { struct cmd cmd; char checksumbuf[1]; printf("32 bit wide flash detected\n"); set_cmd(&cmd, 'T', 0, 0); do_write(sfd, &cmd, 5); if (do_read(sfd, checksumbuf, 1) != 1) { printf("didn't read anything\n"); exit(1); } if (checksumbuf[0] == 0) { return 1; } else { printf("read %x\n", checksumbuf[0] & 0xff); return 0; } } /* Send hello command */ /* Used to verify communication with programming software */ hello() { struct cmd cmd; char checksumbuf[1]; set_cmd(&cmd, 'H', 0, 0); do_write(sfd, &cmd, 5); if (do_read(sfd, checksumbuf, 1) != 1) { printf("didn't read anything\n"); exit(1); } if (checksumbuf[0] == 0) { return 1; } else { printf("read %x\n", checksumbuf[0] & 0xff); return 0; } } /* Send erase (whole flash) command */ erase() { struct cmd cmd; char checksumbuf[1]; set_cmd(&cmd, 'X', 0, 0); do_write(sfd, &cmd, 5); if (do_read(sfd, checksumbuf, 1) != 1) { printf("didn't read anything\n"); exit(1); } if (checksumbuf[0] == 0) { return 1; } else { printf("read %x\n", checksumbuf[0] & 0xff); return 0; } } /* Send erase sector command */ erase_sector(int addr) { struct cmd cmd; char checksumbuf[1]; set_cmd(&cmd, 'S', addr / 2, 0); do_write(sfd, &cmd, 5); if (do_read(sfd, checksumbuf, 1) != 1) { printf("didn't read anything\n"); exit(1); } if (checksumbuf[0] == 0) { return 1; } else { printf("read %x\n", checksumbuf[0] & 0xff); return 0; } } /* Reads in hex files */ int page = 0; int maxaddr = 0; int hex(char c) { if ((c >= '0') && (c <= '9')) return c - '0'; if ((c >= 'a') && (c <= 'f')) return c - 'a' + 10; if ((c >= 'A') && (c <= 'F')) return c - 'A' + 10; printf("bad hex digit: '%c'\n", c); exit(1); } int parse_line(char *buffer, char *mem, int rom_size, int *max_mem) { char *c = buffer; unsigned int address, word_addr; unsigned int length,type; unsigned int checksum = 0; int count = 0; if (*c++ != ':') return -2; /* Skip colon */ length = (hex(*c++) << 4) + hex(*c++); checksum = length; address = (hex(*c++) << 12) + (hex(*c++) << 8) + (hex(*c++) << 4) + hex(*c++); checksum += address & 255; checksum += address >> 8; if (length == 0) { return 0; /* EOF record */ } type = (hex(*c++) << 4) + hex(*c++); checksum += type; switch (type) { case 0: while (length--) { if ((page * 16 + address) >= rom_size) { printf("image too large\n"); exit(1); } mem[page * 16 + address]= (hex(*c++) << 4) + hex(*c++); checksum += mem[page * 16 + address] & 0xff; address++; } if ((page * 16 + address) > *max_mem) *max_mem = page * 16 + address; break; case 2: if (length != 2) return -2; page = (hex(*c++) << 12) + (hex(*c++) << 8) + (hex(*c++) << 4) + hex(*c++); checksum += page & 0xff; checksum += page >> 8; break; default: printf("unknown type %d\n", type); return -2; } checksum += (hex(*c++) << 4) + hex(*c++); if ((checksum & 255) == 0) return count; else return -1; } int read_object(char *filename, char *memory, int rom_size) { FILE *f; char line[80]; int lines_read = 0; int count = 0; int bytes ; static int max_mem; max_mem = 0; if(filename) f = fopen(filename, "r"); else f = stdin; if(filename == NULL) filename = "stdin"; printf("Reading object file '%s'...",filename); fflush(stdout); if (f == NULL) { printf("failed...cannot open object file\n"); exit(1); } while (fgets(line, sizeof(line)-1, f)) { lines_read++; bytes = parse_line(line, memory,rom_size, &max_mem); if (bytes == -1) { printf("\nChecksum error in object file on line %d.\n%s\n", lines_read, line); exit(1); } if (bytes > 0) count += bytes; if (bytes == -2) printf("\n%s\n",line); } fclose(f); printf("done\n"); return max_mem; //return highest memory address used } /* Reads in binary files */ int read_raw(char *filename, char *memory, int rom_size) { FILE *f; char line[80]; int lines_read = 0; int count = 0; int bytes ; static int max_mem; max_mem = 0; if(filename) f = fopen(filename, "r"); else f = stdin; if(filename == NULL) filename = "stdin"; printf("Reading raw object file '%s'...",filename); fflush(stdout); if (f == NULL) { printf("failed...cannot open object file\n"); exit(1); } while (count = fread(memory, 1, 1024, f)) { memory += count; max_mem += count; } fclose(f); printf("done\n"); return max_mem; //return highest memory address used } bad_partition(char *name) { fprintf(stderr, "Unknown partition: %s\n\n", name); usage(); } usage() { struct partition *partition = partitions; fprintf(stderr, "usage:\n"); fprintf(stderr, " wpflash read -- read\n"); fprintf(stderr, " wpflash write -- erase/write\n"); fprintf(stderr, " wpflash writehex -- erase/write\n"); fprintf(stderr, " wpflash erase -- erase all flash\n\n"); fprintf(stderr, " is one of:"); while (partition->name[0]) { fprintf(stderr, " %s", partition->name); partition++; } fprintf(stderr, "\n"); exit(1); } pp_write(int fd, char value) { u_char d = value; if (ioctl(fd, PPWDATA, &d) == 1) perror("write failed"); } u_char pp_read(int fd) { u_char d; if (ioctl(fd, PPRSTATUS, &d) == 1) perror("read failed"); return d; } int pp_open() { int i; int fd; fd = open("/dev/parport0", O_RDWR); if (fd < 0) { perror("Open parport0"); exit(1); } i = 0; if (ioctl (fd, PPCLAIM, &i) == 1) { perror("PPCLAIM failed"); exit(1); } pp_write(fd, 0x00); return fd; } int xfer_byte(int fd, int ivalue) { int ovalue; int c; /* Input the low nibble */ while (1) { c = pp_read(fd); if ((c & 0x80) == 0) break; } c = pp_read(fd); /* printf("got first nibble %02x\n", c); */ ovalue = (c >> 3) & 0x0f; /* Output the low nibble */ pp_write(fd, ivalue & 0xff); pp_write(fd, 0x10 | (ivalue & 0xff)); /* Input the high nibble */ while (1) { c = pp_read(fd); if (c & 0x80) break; } c = pp_read(fd); /* printf("got second nibble %02x\n", c); */ ovalue = ovalue | ((c << 1) & 0xf0); /* Output the high nibble */ pp_write(fd, 0x10 | ((ivalue >> 4) & 0x0f)); pp_write(fd, (ivalue >> 4) & 0x0f); /* printf("ivalue %02x ovalue %02x \n", ivalue, ovalue); */ return ovalue; } int parallel_write(int fd, char *buffer, int count) { int tempcount = count; int thiscount; while (count) { if (xfer_byte(fd, 0) != 0) { printf("Write Sync error\n"); exit(1); } if (count < 256) thiscount = count; else thiscount = 255; count -= thiscount; xfer_byte(fd, thiscount); while (thiscount--) { xfer_byte(fd, *buffer++); } } return tempcount; } char readbuf[256]; int readcount = 0; int readoffset = 0; int parallel_read(int fd, char *buffer, int count) { int tempcount = count; while (count) { if (readcount) { *buffer++ = readbuf[readoffset++]; readcount--; count--; } else { readcount = xfer_byte(fd, 0); if (readcount == 0) { printf("Read Sync error\n"); exit(1); } readoffset = 0; while (readoffset != readcount) { readbuf[readoffset++] = xfer_byte(fd, 0); } readoffset = 0; } } return tempcount; } int do_write(int fd, void *buffer, int count) { if (parallel) return parallel_write(fd, buffer, count); else return write(fd, buffer, count); } int do_read(int fd, void *buffer, int count) { if (parallel) return parallel_read(fd, buffer, count); else return read(fd, buffer, count); }