summaryrefslogtreecommitdiff
path: root/appl/cmd/avr/burn.b
diff options
context:
space:
mode:
Diffstat (limited to 'appl/cmd/avr/burn.b')
-rw-r--r--appl/cmd/avr/burn.b859
1 files changed, 859 insertions, 0 deletions
diff --git a/appl/cmd/avr/burn.b b/appl/cmd/avr/burn.b
new file mode 100644
index 00000000..d1004cd1
--- /dev/null
+++ b/appl/cmd/avr/burn.b
@@ -0,0 +1,859 @@
+implement Burn;
+
+include "sys.m";
+ sys: Sys;
+
+include "draw.m";
+
+include "bufio.m";
+ bufio: Bufio;
+ Iobuf: import bufio;
+
+include "timers.m";
+ timers: Timers;
+ Timer: import timers;
+
+include "string.m";
+ str: String;
+
+include "arg.m";
+
+Burn: module
+{
+ init: fn(nil: ref Draw->Context, nil: list of string);
+};
+
+Avr: adt {
+ id: int;
+ rev: int;
+ flashsize: int;
+ eepromsize: int;
+ fusebytes: int;
+ lockbytes: int;
+ serfprog: int; # serial fuse programming support
+ serlprog: int; # serial lockbit programming support
+ serflread: int; # serial fuse/lockbit reading support
+ commonlfr: int; # lockbits and fuses are combined
+ sermemprog: int; # serial memory programming support
+ pagesize: int;
+ eeprompagesize: int;
+ selftimed: int; # all instructions are self-timed
+ fullpar: int; # part has full parallel interface
+ polling: int; # polling can be used during SPI access
+ fpoll: int; # flash poll value
+ epoll1: int; # eeprom poll value 1
+ epoll2: int; # eeprom poll value 2
+ name: string;
+ signalpagel: int; # posn of PAGEL signal (16rD7 by default)
+ signalbs2: int; # posn of BS2 signal (16rA0 by default)
+};
+
+F, T: con iota;
+ATMEGA128: con 16rB2; # 128k devices
+
+avrs: array of Avr = array[] of {
+ (ATMEGA128, 1, 131072, 4096, 3, 1, T, T, T, F, T, 256, 8, T, T, T, 16rFF, 16rFF, 16rFF, "ATmega128", 16rD7, 16rA0),
+};
+
+sfd: ref Sys->FD;
+cfd: ref Sys->FD;
+rd: ref Rd;
+mib510 := 1;
+
+Rd: adt {
+ c: chan of array of byte;
+ pid: int;
+ fd: ref Sys->FD;
+ buf: array of byte;
+ new: fn(fd: ref Sys->FD): ref Rd;
+ read: fn(r: self ref Rd, ms: int): array of byte;
+ readn: fn(r: self ref Rd, n: int, ms: int): array of byte;
+ flush: fn(r: self ref Rd);
+ stop: fn(r: self ref Rd);
+ reader: fn(r: self ref Rd, c: chan of int);
+};
+
+debug := 0;
+verify := 0;
+erase := 1;
+ignore := 0;
+
+init(nil: ref Draw->Context, args: list of string)
+{
+ sys = load Sys Sys->PATH;
+ bufio = ckl(load Bufio Bufio->PATH, Bufio->PATH);
+ str = ckl(load String String->PATH, String->PATH);
+ timers = ckl(load Timers Timers->PATH, Timers->PATH);
+
+ serial := "/dev/eia0";
+ fuseext := -1;
+ fuselow := -1;
+ fusehigh := -1;
+ arg := ckl(load Arg Arg->PATH, Arg->PATH);
+ arg->init(args);
+ arg->setusage("burn [-rD] [-d serialdev] file.out");
+ while((o := arg->opt()) != 0)
+ case o {
+ 'D' => debug++;
+ 'e' => erase = 0;
+ 'r' => verify = 1;
+ 'd' => serial = arg->earg();
+ 'i' => ignore = 1;
+ 'E' => fuseext = fuseval(arg->earg());
+ 'L' => fuselow = fuseval(arg->earg());
+ 'H' => fusehigh = fuseval(arg->earg());
+ * => arg->usage();
+ }
+ args = arg->argv();
+ if(len args != 1)
+ arg->usage();
+ arg = nil;
+
+ sfile := hd args;
+ fd := bufio->open(sfile, Sys->OREAD);
+ if(fd == nil)
+ err(sys->sprint("can't open %s: %r", sfile));
+
+ timers->init(2);
+ sfd = sys->open(serial, Sys->ORDWR);
+ if(sfd == nil)
+ err(sys->sprint("can't open %s: %r", "/dev/eia0"));
+ cfd = sys->open(serial+"ctl", Sys->ORDWR);
+ sys->fprint(cfd, "f");
+ sys->fprint(cfd, "b115200");
+ sys->fprint(cfd, "i8");
+# sys->fprint(cfd, "f\nb115200\ni8");
+ rd = Rd.new(sfd);
+
+ initialise();
+ if(fuseext >= 0 || fuselow >= 0 || fusehigh >= 0){
+ if(fuselow >= 0 && (fuselow & 16rF) == 0)
+ err("don't program external clock");
+ if(fuseext >= 0 && (fuseext & (1<<0)) == 0)
+ err("don't program ATmega103 compatibility");
+ if(fusehigh >= 0 && (fusehigh & (1<<7)) == 0)
+ err("don't program OCDEN=0");
+ if(fusehigh >= 0 && writefusehigh(fusehigh) >= 0)
+ sys->print("set fuse high=%.2ux\n", fusehigh);
+ if(fuselow >= 0 && writefuselow(fuselow) >= 0)
+ sys->print("set fuse low=%.2ux\n", fuselow);
+ if(fuseext >= 0 && writefuseext(fuseext) >= 0)
+ sys->print("set fuse ext=%.2ux\n", fuseext);
+ shutdown();
+ exit;
+ }
+
+ if(!verify && erase){
+ chiperase();
+ sys->print("Erased flash\n");
+ }
+
+ totbytes := 0;
+ while((l := fd.gets('\n')) != nil){
+ (c, addr, data) := sdecode(l);
+ if(c >= '1' && c <= '3'){
+ if(verify){
+ fdata := readflashdata(addr, len data);
+ if(!eq(fdata, data))
+ sys->print("mismatch: %d::%d at %4.4ux\n", len data, len fdata, addr);
+ }else if(writeflashdata(addr, data) != len data)
+ err("failed to program device");
+ totbytes += len data;
+ } else if(c == '0')
+ sys->print("title: %q\n", string data);
+ }
+ if(!verify){
+ flushpage();
+ sys->print("Programmed %ud (0x%4.4ux) bytes\n", totbytes, totbytes);
+ }
+
+ shutdown();
+}
+
+ckl[T](m: T, s: string): T
+{
+ if(m == nil)
+ err(sys->sprint("can't load %s: %r", s));
+ return m;
+}
+
+fuseval(s: string): int
+{
+ (n, t) := str->toint(s, 16);
+ if(t != nil || n < 0 || n > 255)
+ err("illegal fuse value");
+ return n;
+}
+
+cache: (int, array of byte);
+
+readflashdata(addr: int, nbytes: int): array of byte
+{
+ data := array[nbytes] of byte;
+ ia := addr;
+ ea := addr+nbytes;
+ while(addr < ea){
+ (ca, cd) := cache;
+ if(addr >= ca && addr < ca+len cd){
+ n := nbytes;
+ o := addr-ca;
+ if(o+n > len cd)
+ n = len cd - o;
+ if(addr-ia+n > len data)
+ n = len data - (addr-ia);
+ data[addr-ia:] = cd[o:o+n];
+ addr += n;
+ }else{
+ ca = addr & ~16rFF;
+ cd = readflashpage(ca, 16r100);
+ cache = (ca, cd);
+ }
+ }
+ return data;
+}
+
+writeflashdata(addr: int, data: array of byte): int
+{
+ pagesize := avrs[0].pagesize;
+ ia := addr;
+ ea := addr+len data;
+ while(addr < ea){
+ (ca, cd) := cache;
+ if(addr >= ca && addr < ca+len cd){
+ n := len data;
+ o := addr-ca;
+ if(o+n > len cd)
+ n = len cd - o;
+ cd[o:] = data[0:n];
+ addr += n;
+ data = data[n:];
+ }else{
+ if(flushpage() < 0)
+ break;
+ cache = (addr & ~16rFF, array[pagesize] of {* => byte 16rFF});
+ }
+ }
+ return addr-ia;
+}
+
+flushpage(): int
+{
+ (ca, cd) := cache;
+ if(len cd == 0)
+ return 0;
+ cache = (0, nil);
+ if(writeflashpage(ca, cd) != len cd)
+ return -1;
+ return len cd;
+}
+
+shutdown()
+{
+# setisp(0);
+ if(rd != nil){
+ rd.stop();
+ rd = nil;
+ }
+ if(timers != nil)
+ timers->shutdown();
+}
+
+err(s: string)
+{
+ sys->fprint(sys->fildes(2), "burn: %s\n", s);
+ shutdown();
+ raise "fail:error";
+}
+
+dump(a: array of byte): string
+{
+ s := sys->sprint("[%d]", len a);
+ for(i := 0; i < len a; i++)
+ s += sys->sprint(" %.2ux", int a[i]);
+ return s;
+}
+
+initialise()
+{
+ if(mib510){
+ # MIB510-specific: switch rs232 to STK500
+ for(i:=0; i<8; i++){
+ setisp0(1);
+ sys->sleep(10);
+ rd.flush();
+ if(setisp(1))
+ break;
+ }
+ if(!setisp(1))
+ err("no response from programmer");
+ }
+ resync();
+ resync();
+ if(!mib510){
+ r := rpc(array[] of {Cmd_STK_GET_SIGN_ON}, 7);
+ if(r != nil)
+ sys->print("got: %q\n", string r);
+ }
+ r := readsig();
+ if(len r > 0 && r[0] != byte 16rFF)
+ sys->print("sig: %s\n", dump(r));
+ (min, maj) := version();
+ sys->print("Firmware version: %s.%s\n", min, maj);
+ setdevice(avrs[0]);
+ pgmon();
+ r = readsig();
+ sys->print("sig: %s\n", dump(r));
+ pgmoff();
+ if(len r < 3 || r[0] != byte 16r1e || r[1] != byte 16r97 || r[2] != byte 16r02)
+ if(!ignore)
+ err("unlikely response: check connections");
+
+ # could set voltages here...
+ sys->print("fuses: h=%.2ux l=%.2ux e=%.2ux\n", readfusehigh(), readfuselow(), readfuseext());
+}
+
+resync()
+{
+ for(i := 0; i < 8; i++){
+ rd.flush();
+ r := rpc(array[] of {Cmd_STK_GET_SYNC}, 0);
+ if(r != nil)
+ return;
+ }
+ err("lost sync with programmer");
+}
+
+getparam(p: byte): int
+{
+ r := rpc(array[] of {Cmd_STK_GET_PARAMETER, p}, 1);
+ if(len r > 0)
+ return int r[0];
+ return -1;
+}
+
+version(): (string, string)
+{
+ maj := getparam(Parm_STK_SW_MAJOR);
+ min := getparam(Parm_STK_SW_MINOR);
+ if(mib510)
+ return (sys->sprint("%c", maj), sys->sprint("%c", min));
+ return (sys->sprint("%d", maj), sys->sprint("%d", min));
+}
+
+eq(a, b: array of byte): int
+{
+ if(len a != len b)
+ return 0;
+ for(i := 0; i < len a; i++)
+ if(a[i] != b[i])
+ return 0;
+ return 1;
+}
+
+#
+# Motorola S records
+#
+
+badsrec(s: string)
+{
+ err("bad S record: "+s);
+}
+
+hexc(c: int): int
+{
+ 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;
+ return -1;
+}
+
+g8(s: string): int
+{
+ if(len s >= 2){
+ c0 := hexc(s[0]);
+ c1 := hexc(s[1]);
+ if(c0 >= 0 && c1 >= 0)
+ return (c0<<4) | c1;
+ }
+ return -1;
+}
+
+# S d len
+sdecode(s: string): (int, int, array of byte)
+{
+ while(len s > 0 && (s[len s-1] == '\r' || s[len s-1] == '\n'))
+ s = s[0:len s-1];
+ if(len s < 4 || s[0] != 'S')
+ badsrec(s);
+ l := g8(s[2:4]);
+ if(l < 0)
+ badsrec("length: "+s);
+ if(2*l != len s - 4)
+ badsrec("length: "+s);
+ csum := l;
+ na := 2;
+ if(s[1] >= '1' && s[1] <= '3')
+ na = s[1]-'1'+2;
+ addr := 0;
+ for(i:=0; i<na; i++){
+ b := g8(s[4+i*2:]);
+ if(b < 0)
+ badsrec(s);
+ csum += b;
+ addr = (addr << 8) | b;
+ }
+ case s[1] {
+ '0' or # used as segment name (seems to be srec file name with TinyOS)
+ '1' to '3' or # data
+ '5' or # plot so far
+ '7' to '9' => # end/start address
+ ;
+ * =>
+ badsrec("type: "+s);
+ }
+ data := array[l-na-1] of byte;
+ for(i = 0; i < len data; i++){
+ c := g8(s[4+(na+i)*2:]);
+ csum += c;
+ data[i] = byte c;
+ }
+ v := g8(s[4+l*2-2:]);
+ csum += v;
+ if((csum & 16rFF) != 16rFF)
+ badsrec("checksum: "+s);
+ return (s[1], addr, data);
+}
+
+#
+# serial port
+#
+
+Rd.new(fd: ref Sys->FD): ref Rd
+{
+ r := ref Rd(chan[4] of array of byte, 0, fd, nil);
+ c := chan of int;
+ spawn r.reader(c);
+ <-c;
+ return r;
+}
+
+Rd.reader(r: self ref Rd, c: chan of int)
+{
+ r.pid = sys->pctl(0, nil);
+ c <-= 1;
+ for(;;){
+ buf := array[258] of byte;
+ n := sys->read(r.fd, buf, len buf);
+ if(n <= 0){
+ r.pid = 0;
+ err(sys->sprint("read error: %r"));
+ }
+ if(debug)
+ sys->print("<- %s\n", dump(buf[0:n]));
+ r.c <-= buf[0:n];
+ }
+}
+
+Rd.read(r: self ref Rd, ms: int): array of byte
+{
+ if((a := r.buf) != nil){
+ r.buf = nil;
+ return a;
+ }
+ t := Timer.start(ms);
+ alt{
+ a = <-r.c =>
+ t.stop();
+ Acc:
+ for(;;){
+ sys->sleep(5);
+ alt{
+ b := <-r.c =>
+ if(b == nil)
+ break Acc;
+ a = cat(a, b);
+ * =>
+ break Acc;
+ }
+ }
+ return a;
+ <-t.timeout =>
+ return nil;
+ }
+}
+
+Rd.readn(r: self ref Rd, n: int, ms: int): array of byte
+{
+ a: array of byte;
+
+ while((need := n - len a) > 0){
+ b := r.read(ms);
+ if(b == nil)
+ break;
+ if(len b > need){
+ r.buf = b[need:];
+ b = b[0:need];
+ }
+ a = cat(a, b);
+ }
+ return a;
+}
+
+Rd.flush(r: self ref Rd)
+{
+ r.buf = nil;
+ sys->sleep(5);
+ for(;;){
+ alt{
+ <-r.c =>
+ ;
+ * =>
+ return;
+ }
+ }
+}
+
+Rd.stop(r: self ref Rd)
+{
+ pid := r.pid;
+ if(pid){
+ fd := sys->open("#p/"+string pid+"/ctl", Sys->OWRITE);
+ if(fd != nil)
+ sys->fprint(fd, "kill");
+ }
+}
+
+cat(a, b: array of byte): array of byte
+{
+ if(len b == 0)
+ return a;
+ if(len a == 0)
+ return b;
+ c := array[len a + len b] of byte;
+ c[0:] = a;
+ c[len a:] = b;
+ return c;
+}
+
+#
+# STK500 communication protocol
+#
+
+STK_SIGN_ON_MESSAGE: con "AVR STK"; # Sign on string for Cmd_STK_GET_SIGN_ON
+
+# Responses
+
+Resp_STK_OK: con byte 16r10;
+Resp_STK_FAILED: con byte 16r11;
+Resp_STK_UNKNOWN: con byte 16r12;
+Resp_STK_NODEVICE: con byte 16r13;
+Resp_STK_INSYNC: con byte 16r14;
+Resp_STK_NOSYNC: con byte 16r15;
+
+Resp_ADC_CHANNEL_ERROR: con byte 16r16;
+Resp_ADC_MEASURE_OK: con byte 16r17;
+Resp_PWM_CHANNEL_ERROR: con byte 16r18;
+Resp_PWM_ADJUST_OK: con byte 16r19;
+
+# Special constants
+
+Sync_CRC_EOP: con byte 16r20;
+
+# Commands
+
+Cmd_STK_GET_SYNC: con byte 16r30;
+Cmd_STK_GET_SIGN_ON: con byte 16r31;
+
+Cmd_STK_SET_PARAMETER: con byte 16r40;
+Cmd_STK_GET_PARAMETER: con byte 16r41;
+Cmd_STK_SET_DEVICE: con byte 16r42;
+Cmd_STK_SET_DEVICE_EXT: con byte 16r45;
+
+Cmd_STK_ENTER_PROGMODE: con byte 16r50;
+Cmd_STK_LEAVE_PROGMODE: con byte 16r51;
+Cmd_STK_CHIP_ERASE: con byte 16r52;
+Cmd_STK_CHECK_AUTOINC: con byte 16r53;
+Cmd_STK_LOAD_ADDRESS: con byte 16r55;
+Cmd_STK_UNIVERSAL: con byte 16r56;
+Cmd_STK_UNIVERSAL_MULTI: con byte 16r57;
+
+Cmd_STK_PROG_FLASH: con byte 16r60;
+Cmd_STK_PROG_DATA: con byte 16r61;
+Cmd_STK_PROG_FUSE: con byte 16r62;
+Cmd_STK_PROG_LOCK: con byte 16r63;
+Cmd_STK_PROG_PAGE: con byte 16r64;
+Cmd_STK_PROG_FUSE_EXT: con byte 16r65;
+
+Cmd_STK_READ_FLASH: con byte 16r70;
+Cmd_STK_READ_DATA: con byte 16r71;
+Cmd_STK_READ_FUSE: con byte 16r72;
+Cmd_STK_READ_LOCK: con byte 16r73;
+Cmd_STK_READ_PAGE: con byte 16r74;
+Cmd_STK_READ_SIGN: con byte 16r75;
+Cmd_STK_READ_OSCCAL: con byte 16r76;
+Cmd_STK_READ_FUSE_EXT: con byte 16r77;
+Cmd_STK_READ_OSCCAL_EXT: con byte 16r78;
+
+# Parameter constants
+
+Parm_STK_HW_VER: con byte 16r80; # ' ' - R
+Parm_STK_SW_MAJOR: con byte 16r81; # ' ' - R
+Parm_STK_SW_MINOR: con byte 16r82; # ' ' - R
+Parm_STK_LEDS: con byte 16r83; # ' ' - R/W
+Parm_STK_VTARGET: con byte 16r84; # ' ' - R/W
+Parm_STK_VADJUST: con byte 16r85; # ' ' - R/W
+Parm_STK_OSC_PSCALE: con byte 16r86; # ' ' - R/W
+Parm_STK_OSC_CMATCH: con byte 16r87; # ' ' - R/W
+Parm_STK_RESET_DURATION: con byte 16r88; # ' ' - R/W
+Parm_STK_SCK_DURATION: con byte 16r89; # ' ' - R/W
+
+Parm_STK_BUFSIZEL: con byte 16r90; # ' ' - R/W, Range {0..255}
+Parm_STK_BUFSIZEH: con byte 16r91; # ' ' - R/W, Range {0..255}
+Parm_STK_DEVICE: con byte 16r92; # ' ' - R/W, Range {0..255}
+Parm_STK_PROGMODE: con byte 16r93; # ' ' - 'P' or 'S'
+Parm_STK_PARAMODE: con byte 16r94; # ' ' - TRUE or FALSE
+Parm_STK_POLLING: con byte 16r95; # ' ' - TRUE or FALSE
+Parm_STK_SELFTIMED: con byte 16r96; # ' ' - TRUE or FALSE
+
+# status bits
+
+Stat_STK_INSYNC: con byte 16r01; # INSYNC status bit, '1' - INSYNC
+Stat_STK_PROGMODE: con byte 16r02; # Programming mode, '1' - PROGMODE
+Stat_STK_STANDALONE: con byte 16r04; # Standalone mode, '1' - SM mode
+Stat_STK_RESET: con byte 16r08; # RESET button, '1' - Pushed
+Stat_STK_PROGRAM: con byte 16r10; # Program button, ' 1' - Pushed
+Stat_STK_LEDG: con byte 16r20; # Green LED status, '1' - Lit
+Stat_STK_LEDR: con byte 16r40; # Red LED status, '1' - Lit
+Stat_STK_LEDBLINK: con byte 16r80; # LED blink ON/OFF, '1' - Blink
+
+ispmode := array[] of {byte 16rAA, byte 16r55, byte 16r55, byte 16rAA, byte 16r17, byte 16r51, byte 16r31, byte 16r13, byte 0}; # last byte is 1 to switch isp on 0 to switch off
+
+ck(r: array of byte)
+{
+ if(r == nil)
+ err("programming failed");
+}
+
+pgmon()
+{
+ ck(rpc(array[] of {Cmd_STK_ENTER_PROGMODE}, 0));
+}
+
+pgmoff()
+{
+ ck(rpc(array[] of {Cmd_STK_LEAVE_PROGMODE}, 0));
+}
+
+setisp0(on: int)
+{
+ rd.flush();
+ buf := array[len ispmode] of byte;
+ buf[0:] = ispmode;
+ buf[8] = byte on;
+ sys->write(sfd, buf, len buf);
+}
+
+setisp(on: int): int
+{
+ rd.flush();
+ buf := array[len ispmode] of byte;
+ buf[0:] = ispmode;
+ buf[8] = byte on;
+ r := send(buf, 2);
+ return len r == 2 && ok(r);
+}
+
+readsig(): array of byte
+{
+ r := send(array[] of {Cmd_STK_READ_SIGN, Sync_CRC_EOP}, 5);
+ # doesn't behave as documented in AVR061: it repeats the command bytes instead
+ if(len r != 5 || r[0] != Cmd_STK_READ_SIGN || r[4] != Sync_CRC_EOP){
+ sys->fprint(sys->fildes(2), "bad reply %s\n", dump(r));
+ return nil;
+ }
+ return r[1:len r-1]; # trim proto bytes
+}
+
+pgrpc(a: array of byte, repn: int): array of byte
+{
+ pgmon();
+ r := rpc(a, repn);
+ pgmoff();
+ return r;
+}
+
+eop := array[] of {Sync_CRC_EOP};
+
+rpc(a: array of byte, repn: int): array of byte
+{
+ r := send(cat(a, eop), repn+2);
+ if(!ok(r)){
+ if(len r >= 2 && r[0] == Resp_STK_INSYNC && r[len r-1] == Resp_STK_NODEVICE)
+ err("internal error: programming parameters not correctly set");
+ if(len r >= 1 && r[0] == Resp_STK_NOSYNC)
+ err("lost synchronisation");
+ sys->fprint(sys->fildes(2), "bad reply %s\n", dump(r));
+ return nil;
+ }
+ return r[1:len r-1]; # trim sync bytes
+}
+
+send(a: array of byte, repn: int): array of byte
+{
+ if(debug)
+ sys->print("-> %s\n", dump(a));
+ if(sys->write(sfd, a, len a) != len a)
+ err(sys->sprint("write error: %r"));
+ return rd.readn(repn, 2000);
+}
+
+ok(r: array of byte): int
+{
+ return len r >= 2 && r[0] == Resp_STK_INSYNC && r[len r -1] == Resp_STK_OK;
+}
+
+universal(req: array of byte): int
+{
+ r := pgrpc(cat(array[] of {Cmd_STK_UNIVERSAL}, req), 1);
+ if(r == nil)
+ return -1;
+ return int r[0];
+}
+
+setdevice(d: Avr)
+{
+ b := array[] of {
+ Cmd_STK_SET_DEVICE,
+ byte d.id,
+ byte d.rev,
+ byte 0, # prog type (CHECK)
+ byte d.fullpar,
+ byte d.polling,
+ byte d.selftimed,
+ byte d.lockbytes,
+ byte d.fusebytes,
+ byte d.fpoll,
+ byte d.fpoll,
+ byte d.epoll1,
+ byte d.epoll2,
+ byte (d.pagesize >> 8), byte d.pagesize,
+ byte (d.eepromsize>>8), byte d.eepromsize,
+ byte (d.flashsize>>24), byte (d.flashsize>>16), byte (d.flashsize>>8), byte d.flashsize
+ };
+ ck(rpc(b, 0));
+ if(mib510)
+ return;
+ b = array[] of {
+ Cmd_STK_SET_DEVICE_EXT,
+ byte 4,
+ byte d.eeprompagesize,
+ byte d.signalpagel,
+ byte d.signalbs2,
+ byte 0 # ResetDisable
+ };
+ ck(rpc(b, 0));
+}
+
+chiperase()
+{
+ ck(pgrpc(array[] of {Cmd_STK_CHIP_ERASE}, 0));
+}
+
+readfuselow(): int
+{
+ return universal(array[] of {byte 16r50, byte 0, byte 0, byte 0});
+}
+
+readfusehigh(): int
+{
+ return universal(array[] of {byte 16r58, byte 8, byte 0, byte 0});
+}
+
+readfuseext(): int
+{
+ return universal(array[] of {byte 16r50, byte 8, byte 0, byte 0});
+}
+
+readlockfuse(): int
+{
+ return universal(array[] of {byte 16r58, byte 0, byte 0, byte 0});
+}
+
+readflashpage(addr: int, nb: int): array of byte
+{
+ return readmem('F', addr/2, nb);
+}
+
+readeeprompage(addr: int, nb: int): array of byte
+{
+ return readmem('E', addr, nb);
+}
+
+readmem(memtype: int, addr: int, nb: int): array of byte
+{
+ if(nb > 256)
+ nb = 256;
+ pgmon();
+ r := rpc(array[] of {Cmd_STK_LOAD_ADDRESS, byte addr, byte (addr>>8)}, 0);
+ if(r != nil){
+ r = send(array[] of {Cmd_STK_READ_PAGE, byte (nb>>8), byte nb, byte memtype, Sync_CRC_EOP}, nb+2);
+ l := len r;
+ # AVR601 says last byte should be Resp_STK_OK but it's not, at least on MIB; check for both
+ if(l >= 2 && r[0] == Resp_STK_INSYNC && (r[l-1] == Resp_STK_INSYNC || r[l-1] == Resp_STK_OK))
+ r = r[1:l-1]; # trim framing bytes
+ else{
+ sys->print("bad reply: %s\n", dump(r));
+ r = nil;
+ }
+ if(len r < nb)
+ sys->print("short [%d@%4.4ux]\n", nb, addr);
+ }
+ pgmoff();
+ return r;
+}
+
+writeflashpage(addr: int, data: array of byte): int
+{
+ return writemem('F', addr/2, data);
+}
+
+writeeeprompage(addr: int, data: array of byte): int
+{
+ return writemem('E', addr, data);
+}
+
+writemem(memtype: int, addr: int, data: array of byte): int
+{
+ nb := len data;
+ if(nb > 256){
+ nb = 256;
+ data = data[0:nb];
+ }
+ pgmon();
+ r := rpc(array[] of {Cmd_STK_LOAD_ADDRESS, byte addr, byte (addr>>8)}, 0);
+ if(r != nil){
+ r = rpc(cat(array[] of {Cmd_STK_PROG_PAGE, byte (nb>>8), byte nb, byte memtype},data), 0);
+ if(r == nil)
+ nb = -1;
+ }
+ pgmoff();
+ return nb;
+}
+
+writefuseext(v: int): int
+{
+ return universal(array[] of {byte 16rAC, byte 16rA4, byte 16rFF, byte v});
+}
+
+writefuselow(v: int): int
+{
+ return universal(array[] of {byte 16rAC, byte 16rA0, byte 16rFF, byte v});
+}
+
+writefusehigh(v: int): int
+{
+ return universal(array[] of {byte 16rAC, byte 16rA8, byte 16rFF, byte v});
+}
generated by cgit v1.2.3 (git 2.46.0) at 2025-12-10 12:36:03 +0000