rosco_m68k

As I've mentioned before, the rosco_m68k has a super cool retro-appropriate video adapter capability thanks to Xark's Xosera. While this is using an FPGA, the features it provides are right out of the machines we all know and love from the late 80's / early 90's.

While Xosera is still very much in-development, I'm pleased to say that the Xosera expansion board for the rosco_m68k is now available on Tindie for just $30 (PCB only). 

It's worth noting that, due to the fast pace of development, this is really aimed at early adopters right now, who don't mind living on the bleeding edge and are happy to source their own components (including an UPduino) - there is no kit option. Although things might change and you may have to reprogram the FPGA gateware at times, we're committed to continuing to support this adapter layout going forward, so you won't need to replace the hardware.

Take a look at Xark's project on Hackaday and the Github repository for all the details - for now, I'll just leave this Xosera version of a pretty classic demo here...

(I will just add that this is using scrolling palettes and the Xosera copper to do it's stuff, and I think it looks awesome! For more details check out the original Discord post where it was announced!)

Following my previous log about the first 2.0 prototype boards, I found a few small issues after receiving them. I'm happy to report these are all now fixed, and I have the new production candidate boards (r2.1) back from the fab. I've populated a couple for QA testing and so far everything is looking pretty good!

I also have the new Xosera production candidate boards, so keep an eye on the store for some exciting new stuff coming very soon!

In the meantime, here's a close-up of the latest 2.1 boards up and running :) 

And a boot with the 2.0 firmware, with output via Xosera (grabbed with an HDMI capture card, the inset shows the UART output)

I've been meaning to write a log about this for a while, but have been pretty terrible at writing updates lately as there's been so much going on with the project over on Discord and Tindie. However, better late than never (and apologies to Henk for the lateness). 

@henk.gooijen has been working on what is quite probably the best custom-made retro computer case I've ever seen, and he's putting a rosco_m68k at the heart of it. Words cannot adequately express how awesome this case is shaping up to be, so I'll lead with a picture.

I mean, honestly, just wow. 

Henk's has the front-panel custom made for the m68k bus, and has designed backing PCBs for all the LEDs and switches. It's super professional!

Behind that awesome front-panel, Henk's put together a full case, including expansion slots (based on a version of my baseboard, which he's had to hack due to my lack of foresight or regard for standards - suffice to say I'll know better in future and will be designing with the case in mind!).

And here it is with the rosco_m68k in place (at right of the picture), along with the expansion card that interfaces to the front-panel. (at left).

Needless to say, I'll be getting one of these made for myself in the very near future!

I've only really scratched the surface here, if you want to follow along for yourself and see how this awesome project progresses, check it out on Github!

There's been a lot going on over on Discord lately, and the pace is really picking up in rosco_m68k land! 

One of the big things I've been trying to get done for quite some time is the rosco_m68k r2 (which, to differentiate from the upcoming Pro version, is to be renamed the rosco_m68k Classic). I'm pleased to say that I found some time over the weekend, and the first r2 PCBs are now in production at the fab!

This is going to be a huge quality-of-life enhancement to the existing r1.23 board, with highlights including:

• On-board XR68C681 replaces the MFP, providing 115.2Kbps serial
• 1MB ROM, up from 64KB max on the current board
• The new ROMs are flashable in-circuit (no more pulling to update!)

Under the hood there are more improvements, including a move away from 7400-series logic and manufacturability improvements that should increase reliability. As well as providing a faster UART out of the box, removing the MC68901 is a big win for the project as it means one less out-of-production IC to source.

I'll update more once the new boards are back from China, but in the meantime, here's a (already slightly-outdated) render from Kicad:

As things are starting to heat up on the rosco_m68k pro, I decided it was time to spin it out into it's own project. Be sure to like and follow if you want to get the updates I'll be posting as things progress! https://hackaday.io/project/180929-roscom68kpro

I've mentioned Xosera briefly before, but in case you missed it, Xosera is a fully open-source FPGA-based video adapter created by my good friend @Xark . In the words of the project's Github:

Inspired in concept by it's "namesake" the Commander X16's VERA, Xosera is an original open-source video adapter design, built with open-source tools, that is being tailored with features appropriate for a Motorola 68K era retro computer.

Until now, video on the rosco_m68k has been a slightly hit-and-miss affair, with the main video card being the V9958-based one I designed last year. This is a nice little card, and works well, but suffers a couple of fairly major problems:

• The V9958 is super-hard to get (at least if you care about getting genuine, working chips)
• The 15KHz RGB video output (via SCART) isn't great if you're in a part of the world where SCART isn't really a thing
• The V9958, while nice, is more suited to 8-bit-era machines. For rosco_m68k, I wanted something with a bit more power!

Xark's been working on Xosera since fairly early on in the rosco_m68k timeline, and things have really heated up a bit lately since we decided that Xosera should be the standard video for the next rosco_m68k machine. Based on that, I (finally) got it together and designed the m68k bus interface board I'd been promising for months, and from there Xark has been doing fantastic work, delivering major new features and improvements almost daily.

As well as having Xosera be the video on the next rosco_m68k, we also want to support the existing models too, so the first prototype bus board is designed as an expansion that works with all rosco_m68k models. It's in the prototype stages yet, so rather than having the FPGA and supporting hardware on-board, it accepts an Upduino 3.0 that plugs in and provides all the FPGA goodness. Likewise for the video interface - rather than hardwire for (e.g.) VGA a standard PMOD interface is used, allowing Xark free-reign during the prototyping and development stage - for example using HDMI rather than VGA for output.

The prototype board looks like this:

In true prototype style there's lot of extra jumpers and test points on there for us to use while debugging things, but the bring-up was pretty much effortless in the end. Aside from a minor issue (my fault) in which I got the POD pinout the wrong way around, it works great. Populated and hooked up (with PMOD on wires to correct for inverted pinout), it looks like this:

We're not quite at the graphics mode yet, but have a couple of very-capable (and fast, this thing comfortably runs zero-wait-state on a 12MHz 68020, even on fast tight fill loops running out of on-die cache) text modes. Here's a little "tech demo" snake game I threw together while playing with it (in 100% m68k assembly):

Here it is displaying something like 4096 colours at once (this time driven by Xark's AVR testbed, which he built while waiting for his prototype m68k PCB):

This is very cool as it uses the advanced auxiliary registers provided by Xosera to monitor beam position and do clever things at just the right time. 

And finally, here's a short video from the "self-test" sequence Xark wrote for AVR, and which I ported to m68k (keeping it in C++ and building with the rosco_m68k GCC toolchain). This is running at 848x480 at 60Hz (via VGA).

Between Xosera and @MarkM's awesome work on IDE (that deserves its own log, which will be up soon!) things are moving fast over in rosco_m68k land. Be sure to like and follow the project for more, and for up-to-the-minute news come and join us on Discord. 

To stay up to date with Xosera, be sure to like and follow Xark's project, and take a look at his log which has more of the juicy details. You'll find a lot more FPGA detail over there too.

I'm just adding this log because it's the only way I can find to add pictures to the project. This is the special M68k 40th anniversary limited-edition board that we gave out as competition prizes last year :) 

I've posted before about how it's getting harder to find some of the vintage chips used in this project, and things aren't getting any better. I have a pretty good source for MC68010s at the moment (and have stock), but things like the MC68681 and V9958 are so hard to find that I've had to stop offering them as part of the kit on Tindie :(

With that in mind, there's been a lot of discussion recently over on Discord about future directions for the project, and the awesome community came up with some great ideas for the next major board version! Big thanks to everyone who's been involved in discussing this and suggesting ideas so far!

The Next Major Board Version

The new board won't replace the current one (in-fact, I've just sent of a new revision of the version 1 for manufacturing - more on that below!), but will be a kind of souped-up "pro" version - I'm thinking along the lines of A3000 vs A500 :) 

Briefly, these are the specs we're working to at the moment:

• Modular CPU, supporting 68020 or 68030 (modular, on a daughterboard)
• Full 32-bit data and address bus on the mainboard
• The MC68901 will be replaced in UART duty by a MaxLinear XR68C681 (PLCC, but mounted in a THT socket)
• Expansion via an evolution of the current bus, with buffering and DIN 41612 connectors
• 2MB RAM as standard, expandable (probably with SIMMs of some kind)
• IDE on-board (thanks to MarkM on Discord)
• I2C on board (with a PCF8584T)
• Video on board ( with Xark's Xosera FPGA project)
• Sound - Possibly something on-board, as yet undecided

Obviously some of these components will be SMD, which is a shame as I've always wanted this project to be easily-solderable by those of all skill-levels, but I think for the "pro" version it's not such a big deal, and I'm planning to offer the kits with those few components pre-soldered. 

In terms of design, it's very early days yet - I've barely broke ground in Kicad beyond setting up a new project and importing the relevant libraries, but I'll definitely keep updating here as things progress! And as always, all this is up for discussion, either in the comments here or on discord.

The Next r1 Revision

There's been a lot of work on the firmware lately, and the latest alpha firmware (v1.3) now has reasonably well-tested SD card support! In support of this I recently respun the r1.2 board with the addition of dedicated pins for an SD 5V adapter (like this one for example). There's also some bug fixes and general tidy up on there, making this the most reliable, most capable rosco_m68k ever. It will be launching on Tindie as soon as I get the boards back from the fab and check I've not made any silly mistakes :D 

New 68681 board

Following on from discussions on the next major version, I decided to back port some of the future-proofing ideas back to the r1, starting with replacing the existing MC68681 DUART board with a XR68C681-based one. The prototypes are working perfectly, and I'm waiting on a good quantity coming back from the fab right now. It looks like this:

This will be supported out-of-the-box with the next firmware release later this week, and the board will launch on Tindie (with the option of getting new ROMs in the package) at the same time. This will allow me to once again offer full kits of the 68681, which I've not been able to do for a while because of a lack of original MC68681s of sufficient quality.

Lots more going on

There's lots going on with this project, and this post only just scratches the surface! There's all kinds of community hardware projects in the works, from a "super IO" board that e2k is working on to Henk's flat-out-awesome front panel, and there's a ton of software happening too. I'll definitely try to be better about updating here but if you want to stay in the loop, join us over on Discord!

A while ago I bought some MC68020RC12s, and I recently decided it was time to do something with them, so I made a little adapter that allows the 020 to plug into the 64-pin DIL socket used by the MC68010 on the rosco_m68k. Of course this limits the 020 to 24-bit addressing and 16-bit data, but seemed a fun project and a good way to get started with integrating the 020 in preparation for the future.

The idea is basically to connect up the 020 to the mainboard bus, plus allow it to have it's own clock. There's a little bit of glue logic translation done by an ATF16V8BQL on the board. The layout looks like this:

The design isn't ready for prime-time yet, but I had a few prototypes made, and it works perfectly on the revision 1 board. There's an issue with DTACK generation on the revision 1.2 (which isn't new, we've known about it for a while but I've put off fixing it as it was "good enough" - until now). 

When plugged into the main board (with some spacers on the headers going into the CPU socket to give some vertical separation from the RAM/ROM chips) it looks like this:

Even with the 16-bit bus (and with a relatively-slow 12MHz 020), this is already showing an impressive turn of speed in benchmarks. The 10MHz 010 dhrystone results were:

rosco_m68k 68010-10Mhz ROM gcc-7.5.0 - 1086 (-O1)

rosco_m68k   68010-10Mhz     ROM             gcc-7.5.0        -      1086 (-O1)

While the 020 gives:

rosco_m68k   68020-12Mhz     ROM             gcc-7.5.0        -      2604 (-O1)
rosco_m68k   68020-12Mhz     ROM             gcc-10.2.0       -      2860 (-O1)
rosco_m68k   68020-12Mhz     ROM             gcc-10.2.0       -      2941 (-O1 -mtune=68020)

(The score is the figure in the right column, for a fair comparison both GCC 7.5.0 (which we were using at the time we last benchmarked the 010) and the current GCC 10.2.0 have been tested.

As usual, the design files, PLD code and gerbers can be found in the hardware projects repository in GitHub: https://github.com/rosco-m68k/hardware-projects/tree/master/r1_020_expansion 

Wow, it's been three months since I last updated here, but that's not because nothing's been happening with the project - in fact, exactly the opposite! I've been so busy improving things and keeping up with the awesome stuff the community are doing that I've just not had time to write a log for a while!

For this log I'll just do a quick update on what's been happening over the past couple of months, with a promise to get better at keeping things up to date here on HaD. 

MC68681 DUART

Something that's always been a sticking-point for me (and for quite a few others now) is the 9600 BPS speed limit on the built-in MC68901 UART. As a step toward addressing this, I designed a whole-new comms board for the rosco_m68k, based around the (very capable!) MC68681. This brings two independent UART channels, the potential for future expansion with some additional IO ports, and makes uploading code to the system much less painful thanks to it's reliable support for baud rates up to 115.2Kbps. 

Even better, this is a drop-in replacement for the MFP UART, with recent revision 1.2 ROM builds supporting it out of the box (with auto detection). The board itself looks like this:

I talked a bit about the design in a previous log, but at that point the board wasn't generally available, and the code for it was nowhere near complete (beyond a breadboard design and a basic demo). That's all changed, and it's now available on Tindie :)

SPI & LCD Awesomeness

There's been a lot of development lately around getting bit-banged SPI working, using the GPIOs provided by the MC68901, and @Xark changed the game by implementing some new SPI routines that were >5x as fast as the ones we had before. Not content with that, he went on to use his new SPI routines to implement an awesome bit-banged SPI LCD slide-show for the rosco_m68k! 

The code itself is awesome, but the video shows it even better:

That's right - this is a 16/32-bit m68k system pushing full-colour images out over SPI via the (almost forty-year-old) MC68901, all driven by some super-optimised hand-crafted assembly SPI routines. Totally awesome!

(In other news, Xark also became the first committer on the project who isn't me, and has already made some great contributions!)

SD Card Support

Hot on the heels of Xark's SPI stuff, we were able to revisit the SD Card support, specifically using the faster SPI routines to get a decent speed boost. 

It's early days yet (the code is still sitting in a PR but will likely be merged by the time you read this) but it's looking pretty good - SD support is in the development ROMs, with an SD loader, pretty-complete FAT support (thanks to ultraembedded's FAT library) and support for SD filesystems in user code via a new standard library.

And more!

There's been so much more going on that I haven't mentioned here - expect an upcoming post about a totally awesome front-panel project, a brand-new but very promising OS, and tons of other stuff. And this time, I promise it won't be three months before I do those posts!