Jupiter is unlikely to be of any practical use to anyone but myself.  However, at some point, I will make it public, so that interested persons who do not have access to a Xilinx FPGA board can study the design.

Yesterday, I heard a lecture by David M. Baggett, a well-known software businessman.  Baggett was a co-author of the world-famous game “Crash Bandicoot” and co-founder of ITA Software.  Baggett credited a number of things, including luck, with the success of his ventures — but did not mention Lisp even once.

I can think of a number of possible reasons for this omission.  But perhaps it boils down to the simple fact that even a truly-superb marathon runner, when showing the world his gold medal, would rather not mention the seven-league boots he wore.

I should probably say a few words about the (presently experimental) Loper machine architecture.  The paradigm of choice is dataflow computation.  The goal is to create something which can one day be seamlessly converted to a fully-asynchronous design, implemented using Muller C-gates. The latter is extremely difficult (though not entirely impossible) on available FPGAs, so the “adult” form of the design would have to be fabbed in actual silicon (fat chance of this, at least in my lifetime.)

Loper has no “cores”, no instruction set (in the usual sense,) no interrupts or DMA.  These concepts are, for the most part, artifacts of the Von Neumann paradigm.  That is to say, epicycles.  And the destiny of epicycles is — to go away: “Beauty is the first test: there is no permanent place in this world for ugly mathematics.” (G. H. Hardy)

Eminent people and well-funded organizations would like to resurrect Moore’s Law. The most straightforward way to do this is to move to a fully-asynchronous dataflow architecture, where you can buy computational capacity “by the pound,” so long as your bottlenecks consist of something at least theoretically parallelizable. But they will not succeed, because they are unwilling to let go of the epicycles.  Their investment in existing idiocies – not only monetary, but psychological – is far too great.

Also note that the motives of the would-be Moore’s Law resurrectors are far from pure.  Scarcely anyone wishes to sell you a genuinely-fast computer.  What is really happening is that shitware peddlers fear that their days of selling ever-more bloated bloatware written by progressively-deskilled slave laborers might be coming to an end.  The introduction of practical dataflow machines could save these wretches, but only in the sense of “destroying the village in order to save it.”

Click for full size.

The Xilinx ML501 board includes a Tianma-TM162, which is a Hitachi-compatible character LCD module.  This is a gadget familiar to many electronics hobbyists.  Let’s create a memory-mapped port to access this device.

First, instantiate a Stierlitz in your top-level Verilog module:

wire 	sbus_ready;
wire 	sbus_rw;
wire 	sbus_start_op;
wire [40:0] 	sbus_address;
wire [7:0] 	sbus_data;
 
stierlitz foo(.clk(hpi_clock), /* 16MHz clock */
	       .reset(usbreset), /* Reset (active-high) */
	       .enable(1'b1), /* Hardwired ON for now */
	       /* Control wiring */
	       .bus_ready(sbus_ready),
	       .bus_address(sbus_address),
	       .bus_data(sbus_data),
	       .bus_rw(sbus_rw),
	       .bus_start_op(sbus_start_op),
	       /* CY7C67300 connections */
	       .cy_hpi_address(...),
	       .cy_hpi_data(...),
	       .cy_hpi_oen(...),
	       .cy_hpi_wen(...),
	       .cy_hpi_csn(...),
	       .cy_hpi_irq(...),
	       .cy_hpi_resetn(...)
	       );

Use the read/write logic from the earlier “128K of SRAM” example:

wire ram_we;
wire ram_oe;
assign ram_we = (~sbus_rw) & sbus_start_op;
assign ram_oe = sbus_rw & sbus_start_op;

Now let’s create an 8-bit memory-mapped output (at the very bottom of the address space) which maps to the LCD’s data port:

assign LCD_E = ((sbus_address[40:0] == 41'b0) && ram_we);
assign LCD_RS = sbus_data[7];
assign LCD_RW = 0;
assign LCD_DB[7:4] = sbus_data[3:0];

Now, the Lisp. Open the Stierlitz image:

(defvar *stierlitz*
  (open-stierlitz-image "/mnt/usb/LOPERIMG.BIN"))

The exact way in which the above works was discussed in the original post.

Stierlitz is inescapably wasteful in this case, but it will work perfectly.  This is how we will write to the LCD module’s data port:

(defun lcd-data-out (data)
  (let ((buf (make-array 512
			 :element-type '(unsigned-byte 8)
			 :initial-element #x00)))
    (stierlitz-seek 0) ;; Block zero
    (setf (aref buf 0) data) ;; Set zeroth byte to equal datum
    (write-sequence buf *stierlitz*) ;; Write to Stierlitz
    ;; Force cache flush
    ;; We shouldn't have to do this
    ;; when O_DIRECT is set ... Linux hate.
    (stierlitz-seek 0)))

Really basic code to drive the LCD module:

(defun lcd-write-nibble (data rs)
  "Send a nibble to the LCD module."
  (let ((dout
	 (logior
	  (logand data #b00001111)
	  (if rs #b10000000 0))))
    (sleep 0.01) ;; Must delay as per the LCD spec
    (lcd-data-out dout)))
 
(defun lcd-write (byte rs)
  "Send command or data byte to the LCD module."
  (let* ((upper-nibble (logand (ash byte -4) #xF))
	 (lower-nibble (logand byte #xf)))
    (lcd-write-nibble upper-nibble rs)
    (lcd-write-nibble lower-nibble rs)))
 
(defun lcd-write-char (char)
  "Write a character to the LCD module."
  (lcd-write (char-code char) t))
 
(defun lcd-write-cmd (cmd)
  "Write a command to the LCD module."
  (lcd-write cmd nil))
 
(defun lcd-init ()
  (lcd-write #b0010 nil) ;; Enable 4-bit mode
  (lcd-write-cmd #b00101000) ;; Function Set
  (lcd-write-cmd #b00001100) ;; Display on, cursor and blink off
  (lcd-write-cmd #b00000110) ;; Entry mode set
  (lcd-write-cmd #x01)) ;; Clear LCD

Now let’s try actually using all of this:

(lcd-init) ;; Initialize LCD module.
 
;; Write some text using the memory-mapped port
(loop for c across "www.loper-os.org" do (lcd-write-char c))

The result:

Nothing earth-shaking here, but this demo ought to make sense to everyone.

One ought to remember that, for a number of reasons, they were never really “in” fashion to begin with.  To my knowledge, every single one ever marketed fell into one of the following categories:

1. Military toy, priced somewhere in the luxury-car to small airplane range. (Typical example here.)
2. Consumer-grade, low-resolution garbage, suitable only for watching pornography on airplanes.  (Typical example here.)

Except for one: the Reflection Technology Private Eye.  Circa 1989 (!).  This particular gadget had a 720×280 monochrome display, implemented using a clever electromechanical principle. The Private Eye was a monocle and not particularly comfortable to use.  I got mine rather cheaply from a collector back in 2004:

Reflection Technology Private Eye P4.

Looking through the Private Eye.

The above product was (and, weirdly, still is!) the best of its class – that is, the most practically-useful head-mounted display that a normal person might be able to buy.  And yet it has a number of serious problems; chief among them is the fact that most people have two eyes.  Both of which like to be in use at the same time.

It would certainly be interesting to see a modern incarnation of such a thing.  The thing in question being a head-mounted display, suitable for viewing a reasonable screen-full of text – and one which costs less than a new car.  But somehow I suspect that at least one of these conditions will not be met by the (allegedly) upcoming new product.  High-resolution microdisplays have existed for a number of years.  I suspect that they are being kept firmly off the consumer market by patent trolls.

Now, what “killer app” awaits the head-mounted display?  What application would be lucrative enough to overcome the resistance of mighty patent trolls, and cause the gadget to actually be produced and aggressively marketed?

I’ve got some bad news… The killer app is quite likely to be the one described in the following story, whose author is unknown to me (please speak up if you happen to read this! [1])  I found it on an obscure forum sometime in 2007, and translated it from the original Russian.  Behold:

- Dad, can I grab 99 bucks from your card? I’ve got to pay for a book…
- Oh, what sort of book?
- Well, um, Dostoevsky. “Crime and Punishment”.
- But why do you need to buy it? We have it.
- Oh? What file’s it in?
- What do files have to do with it? Here it is, on the shelf..
- Ugh. That’s a paper book!
- So, what? I was your age when I read it.
- My age, my age… It hasn’t got a search. How do you think I’m going to find quotes? There’s no audio-accompaniment. No animations. Just the text, where you can’t even change the font… I’ll be the laughing stock of the whole school! *You* read it.
- Well, all right. Here, take the DVD. I bought it fifteen years ago or so.
- What? A DVD? And what do you think I can read that antique with? Give it to a technology museum. Maybe you’ll offer me Dostoevsky on paper tape next!
- If you’re so smart, search the net yourself and download it for free.
- You can download a book for free!?
- Well, yes. How else? The copyright on Dostoevsky’s books expired years ago. No doubt it’s out there somewhere.
- You’re kidding, Dad! Maybe in *your* time, at the start of the century, you could download everything for free. Haven’t you heard that five years ago the copyrights to all books were permanently transferred to the American Association of Book Publishers? Or do you want me to go to jail for life, like that sect member Dmitri Sklyarov?
- But Dostoevsky wasn’t an American! What do American publishers have to do with this?
- And who cares about that? Dad, you aren’t an anti-globalist, are you?
- No, no, son. All right, son, its a pity to spend almost 100 dollars just for a file. Why don’t you ask a classmate for a copy? They must have it. Give them some other file in exchange.
- But! If they give me their Dostoevsky, where could I read it?
- What do you mean, “where”? They’ll read their copies at their homes, and you’ll read yours here.
- Oh, you’re totally behind the times! You can only read a book on the comp where it was bought from. And the polarization code will be different… Dad, just give me the cash! I’ll buy myself a normal book.
- All right. Here’s a one-time password to remove 99 bucks from our account. In my time 100 dollars was big money…
- Ok. Downloaded. Thanks.
- Well, let me see it too… Listen, son, what are all those pictures? Those weren’t in the novel…
- Duh, those are the banners. Without banners it costs 699 bucks.The open file was peppered with blinking ads: “Axe Professional, 2018 – modern axes honed with a laser”; “Cosmetic Salon ‘At Lizanka’s’ – we won’t let you turn into a crone”; “Bothered by problems? Psychological services at ‘Porphyry’”; “Credit, cash advances, low interest!”; “RASKOLNIKOFF.COM – sending naughty old ladies anywhere on the globe”…
- Listen, son, why can’t I see the text of the novel? Do I have to wait for the banners to go away?
- Where have you been, Dad? You can wait forever. You have to read the text through the polarizer glasses. Without them, all you’ll see is the ads!
- What’s that for?
- What do you mean, what’s that for? So nobody who hasn’t paid can read the book! Think, I buy a book, and someone who didn’t buy anything could read it over my shoulder…
- What foolishness. So what if I put on glasses too?
- Hah! The file’s set up only for *my* glasses. Other glasses have different polarization.
- All right, let me see your glasses. I’ll read through them.
- How will you see? They won’t recognize your retina. You won’t see anything but a notice that you’re wearing someone else’s glasses! Dad, don’t bother me with your silliness! I’ve got to read the book before my license runs out. I’ve gotta read everything fast, or the license has to be renewed, or the book will self-destruct. Don’t distract me, I’m reading…

3 hours later…
- Oof! That’s all. I’m done reading!
- Really? How did you read all of “Crime and Punishment” in three hours?!
- Well, yeah. I’d have read it faster if it weren’t for the commercial breaks every half-hour.
- I still don’t believe it! Who, for example, is Svidrigailov?
- Who, who?
- Aaah, I get it. Who’s Luzhin? Who’s Sonya Marmeladova?
- Whoah! How am I supposed to know? I just read the Home Edition. It only has the part about how Raskolnikov kills the crone with an axe, and then turns himself in with repentance. To read about all those other people you’ve got to buy the Professional version or even the Enterprise Edition. We just don’t have that much money.
- Hmm, what madness, where’s the world going!
- It’s there already. Should’ve thought about it fifteen years ago, if not earlier…

Copyrasts will stop at nothing to preserve their stranglehold on modern culture.  So when your favorite hardware vendor offers you a comfortable head-mounted display with a built-in retina scanner (just what the doctor ordered for the security-conscious consumer!) – beware…

Richard Stallman’s “The Right to Read” is well on its way to becoming a true story (a large university I live across the street from is, like many others, aggressively pushing DRM-crippled textbooks.)  And so, how much will your grandchildren pay for their Enterprise Editions of Dostoevsky ?

Meet Stierlitz [1], perhaps the world’s strangest bus analyzer.  For basic use, it requires no software at all on the PC end, except for a reasonably-recent version of Linux.

Are you designing a new machine architecture from scratch?  Got a bus 31 or fewer bits wide, on which you would like to perform arbitrary reads and writes?

Stierlitz will sit on your bus and imitate a USB Mass Storage device. The latter will appear to have a FAT16 file system on it, containing a single binary “memory image” file.  (Remember, the maximum file size under FAT16 is 2GB. Hence 31 bits.)

Mount it (under Linux, using “mount -o sync …”) and perform block-sized arbitrary reads/writes by reading or writing blocks within the image “file.”  If you have an ill-behaved kernel which does not fully respect “-o sync”, you may need to perform “read/write/modify” cycles to get the intended results.

Make sure to use the O_DIRECT flag (or the “raw” block device, if your kernel still has one) to disable ALL caching of this “disk” on the PC end. AFAIK, you cannot do this at all on Windows or Mac OS. Therefore I did not bother testing Stierlitz on those poor, crippled systems.  Stierlitz contains a reasonably-complete implementation of a USB Mass Storage stack, and, in principle, ought to work on PCs other than my own.

If you snip out the FAT16 emulation, you can get 41 bits of address space.

You will need an FPGA development board with a Cypress CY7C67300 USB controller, such as the Xilinx ML501, and a copy of my “EZOTGDBG” utility.  The only contents of Cypress’s SDK which you will need to build Stierlitz is “QTASM.EXE”, the assembler.

On the FPGA end, you need this reasonably-compact (20 or so Virtex slices) state machine.  The price paid for this compactness is that the interface does not use the USB controller’s DMA capability.  This results in I/O speeds somewhat slower than the theoretical maximum (The CY7C67300 is a USB 1.1 device.)  My tests currently show ~500KB/s reads and ~200KB/s writes.  This is adequate for most of the purposes I have in mind.

To use Stierlitz in your Verilog project, instantiate something like this:

stierlitz foo(.clk(hpi_clock), /* 16MHz clock */
.reset(usbreset), /* Reset (active-high) */
.enable(1'b1), /* Hardwired ON for now */
/* Control wiring */
.bus_ready(...), /* "Short Bus" - user interface */
.bus_address(...),
.bus_data(...),
.bus_rw(...),
.bus_start_op(...),
/* CY7C67300 connections */
.cy_hpi_address(...),
.cy_hpi_data(...),
.cy_hpi_oen(...),
.cy_hpi_wen(...),
.cy_hpi_csn(...),
.cy_hpi_irq(...),
.cy_hpi_resetn(...)
);

There is a basic demo. It gives you a 128K “file” mapped to SRAM (you need an FPGA with at least this much “Block RAM.”)

But wait, there’s more!

Here is a very basic set of demo routines in Common Lisp (needs an SBCL-only POSIX plugin):

Open a Stierlitz image:

(defconstant +O_DIRECT+ #x4000)
 
(defun open-stierlitz-image (pathname)
  "Open Stierlitz image using sb-unix with blocking I/O."
  (multiple-value-bind (fd errno)
      (sb-unix:unix-open pathname
                        (logior sb-posix:o-rdwr
                                sb-posix:o-sync
                                +O_DIRECT+)
                         0)
    (unless fd
      (error "Could not open Stierlitz image: ~A!~%Errno: ~a~%"
             pathname (sb-int:strerror errno)))
    (sb-sys:make-fd-stream fd
     :input t
     :output t
     :element-type '(unsigned-byte 8)
     :buffering :none
     :pathname (make-pathname :name pathname))))
 
(defvar *stierlitz* (open-stierlitz-image "/mnt/usb/LOPERIMG.BIN"))

Seek within the image:

(defun stierlitz-seek (pos)
  (file-position *stierlitz* pos))
 
(stierlitz-seek 512) ;; Seek to start of second block...

Read a block:

(let ((buf (make-array 512 :element-type '(unsigned-byte 8))))
  (read-sequence buf *stierlitz*)
  ...
  )

Modify a block:

(let ((buf (make-array 512 :element-type '(unsigned-byte 8) :initial-element #xAA)))
  (write-sequence buf *stierlitz*)
  ...
  )

And so forth.

So, what’s next?

1) Logic to drive other peripherals found on the ML501 (Video, Ethernet, etc.)  Coming soon.
2) My own, proper logic synthesis system (Goodbye, Verilog. Goodbye, hundred-line FSM boilerplate and other such abominations.  And, eventually, goodbye, Xilinx toolchain.)  Coming soon…
3) And, last but not least, my CPU architecture, rationally-designed and, incidentally, entirely and meaningfully-unlike any existing one (including the Lisp Machines.)

Don’t expect too many posts like this one in the near future; they are quite labor-intensive to write.  And, judging by my server stats, most of my readers would much prefer to see ever-hotter hot air. Yes, there will certainly be more of that.

Since turning Loper OS into an ab initio CPU architecture project, I have been using Xilinx development boards for prototyping.  For the past year —  an ML-501.  The FPGA toolchain itself is (grudgingly) Linux-friendly, but those for many of the I/O chips included with the board are anything but.

For instance, on the ML-501 (and a few other Xilinx boards) there is a Cypress Semiconductor CY7C67300 “EZ-Host Programmable Embedded USB Host and Peripheral Controller.”  Sounds useful, no?  The free SDK includes a few code examples.  Cypress also distributes an assembler, “QTASM.EXE” (included with the EZ-Host BIOS source code.)  The assembler is Windows-only but will run happily under Wine.  And it would not be too difficult to write your own assembler for this very simple and decently-documented chip.

The Cypress EZ-Host (also called EZ-OTG) should not be confused with the commonplace Cypress EZ-USB chip!  This is a rather different architecture.  None of the EZ-USB tools will work.

Know that the EZ-Host SDK is a cruel kick in the face to a Linux user, because Cypress’s firmware-uploader and memory-dumper tool (”QTUI2C.EXE”) will not run under Wine.  Nor is any source for the tool available.

Imagine there were a construction company which expected carpenters to cut wood only with pocket knives!  Vendors who expect embedded firmware developers to use MS-Windows are just the same.  But odder still are vendors whose SDK is a mix of the reasonably Linux-friendly and the purely MS-bound.  That is quite like mandating pocket knife-only sawing on even-numbered days of the calendar.  (One less-than-shocking example of this: Intel.  And, well, Cypress.)

But, my fellow Xilinx and Cypress sufferers!  The hour of liberation has come! I have written EZOTGDBG, a quick, rough replacement for QTUI2C.EXE. The sole dependency is libusb-1.0. The license is GPL-3.  Friends, please test EZOTGDBG on your boards!   But all normal caveats apply!  In particular, your system will release magic blue smoke under the right circumstances if you don’t know what you are doing (or are merely unlucky.)  But if you own one of these toys you ought to have known that already.

All bug reports / hate mail / etc. for EZOTGDBG should only be submitted as comments to this post.

So what does any of this have to do with Loper?

The USB controller in question will eventually be used for the obvious purpose: as a USB host on which to hang traditional peripherals (keyboards, mice, disks, etc.)  But at that point, there will be no need to flash its firmware from the “mother ship.”

But right now the 67300 sits on “ShortBus”, the Loper prototype machine’s rough analogue to the original Lisp Machine’s “Spy Bus.” The basic idea here is to inspect/manipulate state under remote control.

And so, something like EZOTGDBG is needed, to initialize the controller when Loper cannot yet be relied upon to do so.

Writing programs like this is a misery, but it cannot be entirely avoided if the kind of thing I have in mind is to go forward.

The only Classic Mac emulator I know to work is Basilisk II.  If you run MS Windows, you can get that version here.

All comments regarding this being some morally depraved thing to do will be deleted.