recipes/rc2014/eeprom/usr.asm

@@ -1,43 +0,0 @@
-; If you find youself needing to write to an EEPROM through a shell that isn't
-; built for this, compile this dependency-less code (change memory offsets as
-; needed) and run it in a USR-like fashion.
-
-	ld	bc, 0x1000	; bytecount to write
-	ld	de, 0xd000	; source data
-	ld	hl, 0x2000	; dest EEPROM memory mapping
-
-loop:
-	ld	a, (de)
-	ld	(hl), a
-	push	de		; --> lvl 1
-	push	bc		; --> lvl 2
-	ld	bc, 0x2000	; Should be plenty enough to go > 10ms
-	ld	e, a		; save expected data for verification
-wait:
-	; as long as writing operation is running, IO/6 will toggle at each
-	; read attempt and IO/7 will be the opposite of what was written. Simply
-	; wait until the read operation yields the same value as what we've
-	; written
-	ld	a, (hl)
-	cp	e
-	jr	z, waitend
-	dec	bc
-	ld	a, b
-	or	c
-	jr	nz, wait
-	; mismatch
-	pop	bc		; <-- lvl 2
-	pop	de		; <-- lvl 1
-	ld	a, 1		; nonzero
-	or	a		; unset Z
-	ret
-waitend:
-	pop	bc		; <-- lvl 2
-	pop	de		; <-- lvl 1
-	inc	hl
-	inc	de
-	dec	bc
-	ld	a, b
-	or	c
-	jr	nz, loop
-	ret			; Z already set

tools/.gitignore

@@ -1,3 +1 @@
-*.o
 /memdumpb
-/uploadb

tools/Makefile

@@ -1,22 +1,13 @@
+CFLAGS ?= -Wall
+
 MEMDUMP_TGT = memdumpb
 MEMDUMP_SRC = memdump.c
-UPLOAD_TGT = uploadb
-UPLOAD_SRC = upload.c
-TARGETS = $(MEMDUMP_TGT) $(UPLOAD_TGT)
-OBJS = common.o
 
-all: $(TARGETS)
+all: ${MEMDUMP_TGT}
 
-.SUFFIXES: .c .o
+${MEMDUMP_TGT}: ${MEMDUMP_SRC}
-.c.o:
+	${CC} ${CFLAGS} ${MEMDUMP_SRC} -o ${MEMDUMP_TGT}
-	$(CC) $(CFLAGS) -c $< -o $@
-
-$(MEMDUMP_TGT): $(MEMDUMP_SRC) $(OBJS)
-	$(CC) $(CFLAGS) $(MEMDUMP_SRC) $(OBJS) -o $@
-
-$(UPLOAD_TGT): $(UPLOAD_SRC) $(OBJS)
-	$(CC) $(CFLAGS) $(UPLOAD_SRC) $(OBJS) -o $@
 
 .PHONY: clean
 clean:
-	rm -f $(TARGETS) $(OBJS)
+	rm -f ${MEMDUMP_TGT}

tools/common.c

@@ -1,19 +0,0 @@
-#include <stdlib.h>
-#include <unistd.h>
-
-void sendcmd(int fd, char *cmd)
-{
-    char junk[2];
-    while (*cmd) {
-        write(fd, cmd, 1);
-        read(fd, &junk, 1);
-        cmd++;
-        // The other side is sometimes much slower than us and if we don't let
-        // it breathe, it can choke.
-        usleep(1000);
-    }
-    write(fd, "\n", 1);
-    read(fd, &junk, 2); // sends back \r\n
-    usleep(1000);
-}
-

tools/common.h

@@ -1,2 +0,0 @@
-void sendcmd(int fd, char *cmd);
-

tools/emul/.gitignore

@@ -8,3 +8,4 @@
 /cfsin/ed
 /cfsin/basic
 /cfsin/user.h
+*.o

tools/memdump.c

@@ -3,12 +3,26 @@
 #include <fcntl.h>
 #include <unistd.h>
 
-#include "common.h"
-
 /* Read specified number of bytes at specified memory address through a BASIC
  * remote shell and dump it to stdout.
  */
 
+void sendcmd(int fd, char *cmd)
+{
+    char junk[2];
+    while (*cmd) {
+        write(fd, cmd, 1);
+        read(fd, &junk, 1);
+        cmd++;
+        // The other side is sometimes much slower than us and if we don't let
+        // it breathe, it can choke.
+        usleep(1000);
+    }
+    write(fd, "\n", 1);
+    read(fd, &junk, 2); // sends back \r\n
+    usleep(1000);
+}
+
 int main(int argc, char **argv)
 {
     if (argc != 4) {
@@ -36,12 +50,17 @@ int main(int argc, char **argv)
     for (int i=0; i<bytecount; i++) {
         sendcmd(fd, "peek m");
         read(fd, s, 2); // read prompt
-        sendcmd(fd, "puth a");
+        sendcmd(fd, "print a");
-        read(fd, s, 2); // read hex pair
+        for (int j=0; j<3; j++) {
-        s[2] = 0; // null terminate
+            read(fd, s+j, 1);
-        unsigned char c = strtol(s, NULL, 16);
+            s[j+1] = 0; // always null-terminate
+            if (s[j] < '0') {
+                break;
+            }
+        }
+        unsigned char c = strtol(s, NULL, 10);
         putchar(c);
-        read(fd, s, 2); // read prompt
+        read(fd, s, 3); // read \r\n + prompt - last char
         sendcmd(fd, "m=m+1");
         read(fd, s, 2); // read prompt
     }

tools/upload.c

@@ -1,65 +0,0 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include <fcntl.h>
-#include <unistd.h>
-
-#include "common.h"
-
-/* Push specified file to specified device **running the BASIC shell** and verify
- * that the sent contents is correct.
- */
-
-int main(int argc, char **argv)
-{
-    if (argc != 4) {
-        fprintf(stderr, "Usage: ./upload device memptr fname\n");
-        return 1;
-    }
-    unsigned int memptr = strtol(argv[2], NULL, 16);
-    FILE *fp = fopen(argv[3], "r");
-    if (!fp) {
-        fprintf(stderr, "Can't open %s.\n", argv[3]);
-        return 1;
-    }
-    fseek(fp, 0, SEEK_END);
-    unsigned int bytecount = ftell(fp);
-    fprintf(stderr, "memptr: 0x%04x bytecount: 0x%04x.\n", memptr, bytecount);
-    if (memptr+bytecount > 0xffff) {
-        fprintf(stderr, "memptr+bytecount out of range.\n");
-        fclose(fp);
-        return 1;
-    }
-    rewind(fp);
-    int fd = open(argv[1], O_RDWR|O_NOCTTY);
-    char s[0x10];
-    sprintf(s, "m=0x%04x", memptr);
-    sendcmd(fd, s);
-    read(fd, s, 2); // read prompt
-
-    while (fread(s, 1, 1, fp)) {
-        putchar('.');
-        fflush(stdout);
-        unsigned char c = s[0];
-        sendcmd(fd, "getc");
-        write(fd, &c, 1);
-        read(fd, s, 2); // read prompt
-        sendcmd(fd, "puth a");
-        read(fd, s, 2); // read hex pair
-        s[2] = 0; // null terminate
-        unsigned char c2 = strtol(s, NULL, 16);
-        read(fd, s, 2); // read prompt
-        if (c != c2) {
-            // mismatch!
-            unsigned int pos = ftell(fp);
-            fprintf(stderr, "Mismatch at byte %d! %d != %d.\n", pos, c, c2);
-            return 1;
-        }
-        sendcmd(fd, "poke m a");
-        read(fd, s, 2); // read prompt
-        sendcmd(fd, "m=m+1");
-        read(fd, s, 2); // read prompt
-    }
-    printf("Done!\n");
-    return 0;
-}
-

tools/uploadb.pl

@@ -0,0 +1,79 @@
+#!/usr/bin/perl
+# Push specified file to specified device **running the BASIC shell** and verify
+# that the sent contents is correct.
+use strict;
+use Fcntl;
+
+if (@ARGV != 3) {
+    print "Usage: ./uploadb.pl device memptr filename\n";
+    exit 1;
+}
+
+my ($device, $memptr, $fname) = @ARGV;
+
+if (hex($memptr) >= 0x10000) { die "memptr is out of range"; }
+
+if (! -e $fname) { die "${fname} does not exist"; }
+my $fsize = -s $fname;
+my $maxsize = 0x10000 - hex($memptr);
+if ($fsize > $maxsize) { die "File too big. ${maxsize} bytes max"; }
+
+my $fh;
+unless (open($fh, '<', $fname)) { die "Can't open $fname"; }
+
+my $devh;
+unless (sysopen($devh, $device, O_RDWR|O_NOCTTY)) { die "Can't open $device"; }
+
+sub sendcmd {
+    # The serial link echoes back all typed characters and expects us to read
+    # them. We have to send each char one at a time.
+    my $junk;
+    foreach my $char (split //, shift) {
+        syswrite $devh, $char;
+        sysread $devh, $junk, 1;
+    }
+    syswrite $devh, "\n";
+    sysread $devh, $junk, 2; # send back \r\n
+}
+
+sendcmd("m=0x${memptr}");
+
+my $rd;
+sysread $devh, $rd, 2; # read prompt
+
+# disable buffering
+$| = 1;
+
+while (sysread $fh, my $char, 1) {
+    print ".";
+    for (my $i=0; $i<5; $i++) { # try 5 times
+        sendcmd("getc");
+        syswrite $devh, $char;
+        sysread $devh, $rd, 2; # read prompt
+        sendcmd("print a");
+        my $s = "";
+        while (1) {
+            sysread $devh, $rd, 1;
+            if ($rd !~ /\d/) { last; }
+            $s .= $rd;
+        }
+        sysread $devh, $rd, 3; # read prompt
+        if ($s == ord($char)) {
+            last;
+        } else {
+            if ($i < 4) {
+                print "Mismatch at byte ${i}! ${s} != ${ord($char)}. Retrying.\n";
+            } else {
+                die "Maximum retries reached, abort.\n";
+            }
+        }
+    }
+    sendcmd("poke m a");
+    sysread $devh, $rd, 2; # read prompt
+    sendcmd("m=m+1");
+    sysread $devh, $rd, 2; # read prompt
+}
+
+print "Done!\n";
+close $fh;
+close $devh;