MU90 MPO Bridge

MU90 MPO Bridge: connecting the Elektronika MK-90 to a Linux PC

During the development of MU90 (Mad Unix 90) and the MBC (Mad BASIC Compiler), I encountered a rather practical limitation: writing software on a modern computer is one thing, but transferring it to an actual Elektronika MK-90 is quite another. The MK-90 is a Soviet handheld computer based on a PDP-11-compatible architecture. Its removable MPO memory modules are convenient when used with the original machine, but they were certainly not designed to communicate with a present-day PC.

Entering programs manually through the MK-90 keyboard is acceptable for short experiments. It becomes much less attractive when a program has to be modified, compiled and tested several times. I therefore decided to build a small interface that would allow me to access an MPO module directly from Linux, without modifying the computer or introducing unnecessary complexity.

The result is the MU90 MPO Bridge, an adapter based on the Waveshare RP2350-Zero and accompanied by a Linux command-line utility written in C, mpoctl. The interface allows complete memory images to be saved and restored and, when an MPO module contains the MKS2 filesystem used by MU90, individual files and directories to be managed from the PC.

The version discussed here is 0.2.2. The complete package is available here: MU90_MPO_Bridge_0.2.2_COMPLETE.zip.

What I wanted to achieve

The purpose of the project was not simply to read the contents of an old memory cartridge. I needed a reasonably straightforward development procedure: edit a BASIC program on Linux, compile it with MBC, copy the resulting file to an MPO module and execute it on the real MK-90.

Linux PC
   |
   | edit / compile
   v
program.bas / program.mbx
   |
   | mpoctl put
   v
RP2350-Zero USB bridge
   |
   v
MPO module
   |
   v
Elektronika MK-90

There was also another reason for making the adapter. Some of these modules have survived for decades, often with software or data that may no longer exist elsewhere. Before changing their contents, it is useful to be able to make a complete binary copy and verify that it can be read consistently. For this reason, raw memory access was included from the beginning, independently of any filesystem.

The hardware: Waveshare RP2350-Zero

I chose the Waveshare RP2350-Zero mainly for practical reasons. It is a small and inexpensive development board with native USB device support, sufficient RAM for the required buffers and more GPIO lines than this application needs. It also includes a WS2812 RGB LED, which I later used to indicate the operating state of the interface.

The actual connection is very simple. Apart from the power supply and ground, only three signals are required: CLOCK, DATA and SELECT. The connections used in version 0.2.2 are shown below.

RP2350-Zero MPO pin Signal
VBUS / 5 V 2 +5 V
GPIO2 3 CLOCK
GPIO4 4 DATA
GPIO3 5 SELECT
GND 6 Ground

MPO pin 1, corresponding to the battery terminal, is not connected in the present design.

Connections between the Waveshare RP2350-Zero and the MPO memory module

No additional USB interface IC is required. The RP2350 communicates with the host PC through its native USB port, while the three GPIO lines handle the proprietary synchronous serial interface of the MPO module.

Separating the physical interface from the filesystem

One of the design choices I considered important was to keep the firmware as simple as possible. The RP2350 does not need to know what a directory is, how a file is allocated or even whether the cartridge contains a valid filesystem. It only implements the MPO communication protocol and offers byte-range read and write operations to the computer.

Filesystem management is instead performed by mpoctl under Linux. This separation makes it possible to test the electrical interface and the low-level protocol without involving the MKS2 filesystem. It also means that changes to the filesystem implementation do not necessarily require a new firmware build.

MPO module
    |
    | proprietary synchronous serial interface
    v
RP2350 firmware
    |
    | USB CDC binary protocol + CRC32
    v
mpoctl (Linux)
    |
    | raw memory operations / MKS2 filesystem
    v
Linux files

Block diagram of the MU90 MPO Bridge

Communication between the PC and the microcontroller takes place over USB CDC, using a compact binary protocol. Commands include framing information and a CRC32 to detect transmission errors. The available operations include reading the firmware information, resetting the MPO bus, reading its status, reading and writing raw memory and performing writes with subsequent read-back verification.

The maximum transfer block is 1024 bytes. When more data must be transferred, the Linux application automatically divides the operation into smaller blocks. This avoids having to manage an entire cartridge image in the microcontroller’s memory.

The Linux application: mpoctl

The host application, mpoctl, is written in C and communicates with the bridge through the ordinary POSIX serial interface. No dedicated USB library is needed. Once connected, the device is normally available on Linux as, for example, /dev/ttyACM0.

Before attempting to access a cartridge, I normally check that the PC can communicate correctly with the interface:

./mpoctl --device /dev/ttyACM0 bridge-info

With firmware 0.2.2, the response has the following form:

transport:        USB CDC bridge
protocol:         1
firmware:         0.2.2
max transfer:     1024 bytes
capabilities:     ...

This is a simple check, but it confirms the connection to the RP2350 before the MPO module itself is involved.

Reading and preserving an MPO module

When dealing with an unknown module, especially one that may contain original software, I prefer to start with a complete backup. For a 10 KiB MPO module, the following commands produce two independent images:

./mpoctl --device /dev/ttyACM0 raw-read dump1.bin 10
./mpoctl --device /dev/ttyACM0 raw-read dump2.bin 10

sha256sum dump1.bin dump2.bin
cmp dump1.bin dump2.bin

The two SHA-256 hashes should be identical, and cmp should produce no output. This does not prove that the original data is logically correct, but it does establish that the two reads returned exactly the same sequence of bytes. It is a useful distinction: if repeated raw reads are inconsistent, there is little point in investigating filesystem structures before checking the lower-level communication.

A previously saved image can subsequently be restored with:

./mpoctl --device /dev/ttyACM0 raw-write backup.bin

Writes are followed by read-back verification. Naturally, restoring a raw image overwrites the contents of the cartridge, so the image must be known to be valid and must correspond to the correct module capacity.

MKS2 filesystem support

Raw access is useful for backups and diagnostics, but my main objective was to transfer files. The MU90 operating system uses a small filesystem called MKS2 on writable MPO modules. I therefore implemented the corresponding filesystem operations in mpoctl, leaving the RP2350 firmware unchanged.

The Linux utility handles the MKS2 superblock, the two metadata generations, checksums and copy-on-write metadata updates. It can also manage allocation and free space, directories, ordinary files, replacement, deletion and filesystem verification. These are all operations performed on the PC side; the bridge itself continues to see only memory addresses and bytes.

Of course, implementing a filesystem reader is not particularly useful if the data it produces cannot be read by the actual computer. I therefore tested interoperability in both directions, using the MU90 PDP-11 filesystem code inside the CPU model.

In the first test, MU90 formatted an MKS2 image and created files. The image was then exported and examined with mpoctl:

MU90 PDP-11 code
    -> format MKS2
    -> create files
    -> export MPO image
    -> mpoctl reads and verifies it

The opposite test was equally important. This time mpoctl created files and directories, and MU90 had to mount the resulting image and read the same files:

mpoctl
    -> create directory/file
    -> write MPO image
    -> MU90 PDP-11 mounts it
    -> MU90 reads the same file

Both tests passed. This was a more meaningful result than simply checking whether the directory entries appeared correct in a hex editor, because it verified that the two independent implementations could exchange data.

Using the bridge with the real MK-90

With an MKS2-formatted cartridge connected, the contents can be examined using:

./mpoctl --device /dev/ttyACM0 info
./mpoctl --device /dev/ttyACM0 ls /

During the first successful test on real hardware, the MPO contained a directory used for BASIC development:

/pr-basic
    demo.bas
    demo.mbx
    math.bas
    math.mbx

The same files were visible from MU90 running on the actual Elektronika MK-90. At that point the adapter was no longer just a way of reading a memory chip: it could be used as part of the ordinary development procedure.

To copy a file from the MPO module to the Linux working directory:

./mpoctl --device /dev/ttyACM0 get /pr-basic/math.bas

A different destination filename can be specified when necessary:

./mpoctl --device /dev/ttyACM0 \
    get /pr-basic/math.bas math-backup.bas

Copying a compiled program from Linux to the module is just as straightforward:

./mpoctl --device /dev/ttyACM0 \
    put math.mbx /pr-basic/math.mbx

For example, after editing math.bas, I can compile it with MBC and transfer the resulting executable:

./mbc math.bas

./mpoctl --device /dev/ttyACM0 \
    put math.mbx /pr-basic/math.mbx

On the MK-90, MU90 can then execute the program directly from the cartridge:

cd /mnt/smp1/pr-basic
exec math.mbx

This is precisely the development cycle I was trying to obtain. The source code remains on the Linux PC, where it is easier to edit and compile, while testing is carried out on the original hardware.

The utility also provides basic directory management. The following example creates a directory, copies a file into it, lists its contents and then removes the file and directory:

./mpoctl --device /dev/ttyACM0 mkdir /basic

./mpoctl --device /dev/ttyACM0 \
    put program.bas /basic/program.bas

./mpoctl --device /dev/ttyACM0 ls /basic

./mpoctl --device /dev/ttyACM0 rm /basic/program.bas

./mpoctl --device /dev/ttyACM0 rmdir /basic

After modifying a cartridge, I can explicitly check the filesystem with:

./mpoctl --device /dev/ttyACM0 verify

This checks MKS2 structures and file data. A successful USB transfer alone would only tell me that a communication command completed, not that the resulting filesystem is consistent.

The RGB LED as a diagnostic indicator

The Waveshare board includes a WS2812 RGB LED, which turned out to be useful for a device that often works without much attention from the operator. In firmware 0.2.2 the LED indicates the current state of the interface:

Colour Meaning
Purple Powered, waiting for USB enumeration
Blue USB connection ready; interface idle
Cyan MPO read operation
Orange MPO write or verification
Green Operation completed successfully
Red Error
White MPO bus reset

Since the LED is connected independently of the MPO signals, this feature required no changes to the external connections. It is a small addition, but it allows the state of an operation to be recognised immediately, without continuously checking the terminal.

Development tools and present limitations

The firmware is developed with Visual Studio Code, the official Raspberry Pi Pico extension and Pico SDK 2.3.x. The build target is waveshare_rp2350_zero. USB CDC is implemented using TinyUSB, while the Pico SDK hardware libraries manage the GPIO and the onboard WS2812 LED.

There is one distinction worth making. Although the adapter is connected to the PC through USB, it is not a USB Mass Storage device. The MPO module does not appear as an ordinary removable drive that can be mounted by Linux, Windows or macOS. Access is performed explicitly through mpoctl.

A possible future development would be to expose a synthetic FAT volume and translate file operations to MKS2, or to introduce a filesystem directly interoperable with MU90. Both approaches deserve consideration, but they would add another layer of software and possible failure modes. For the present stage of development I prefer the command-line utility, which makes operations explicit and provides much more useful diagnostics.

Conclusions

MU90 MPO Bridge is not a particularly complicated piece of hardware: a small RP2350 board, three signal lines and a USB connection are enough. Most of the work is in implementing the original memory-module protocol correctly and making the Linux software understand the same on-disk structures used by MU90.

The practical result is that I can develop and compile a program on Linux, copy it to an MPO cartridge and execute it on a real MK-90, without manually re-entering the source code. At the same time, the raw read and write functions provide a convenient way to archive the contents of old modules before experimenting with them.

For me, this is the real value of the project: it makes an old computer considerably easier to use for new software development, while leaving its original hardware and storage format intact.


MU90 MPO Bridge 0.2.2
Waveshare RP2350-Zero / Elektronika MK-90 MPO interface
All rights reserved 2026 (C) Papadopol Lucian-Ioan
l.i.papadopol@gmail.com

This software is free to use but not to share/modify and/or make profit.