It’s with a tinge of sadness that we and many others reported on the recent move by Zilog to end-of-life the original Z80 8-bit microprocessor. This was the part that gave so many engineers and programmers their first introduction to a computer of their own. Even though now outdated its presence has been a constant over the decades. Zilog will continue to sell a Z80 derivative in the form of their eZ80, but that’s not the only place the core can be found on silicon. [Rejunity] is bringing us an open-source z80 core on real hardware, thanks of course to the TinyTapeout ASIC project. The classic core will occupy two tiles on the upcoming TinyTapeout 7. While perhaps it’s not quite the same as a real 40-pin DIP in your hands, like all of the open-source custom silicon world, it’s as yet early days.
The core in question is derived from the TV80 open-source core, which we would be very interested to compare when fabricated at TinyTapeout’s 130nm process with an original chip from a much larger 1970s process. While It’s true that this project is more of an interesting demonstration of TinyTapeout than a practical everyday Z80, it does at least serve as a reminder that there may be a future point in which a run of open-source real Z80s or other chips might become possible.
This isn’t the first time we’ve featured a TinyTapeout project.
So pleased to see that someone tried this and it fits! :)
now I want to see someone try to fit a MOS6581 in there
I believe the actual fabrication technology used original in the 6581 contributes to its sound and a re-implementation on a completely different process will not be entirely faithful to the original 6581 sound.
The SID chip is a hybrid, part digital and part analog. It’s thus rather hard to emulate in pure digital hardware. There are however multiple solutions that use DSP hardware and software models of the SID to get close to the original (but rather too large to fit on an open chip like this.
With TinyTapeout we can now mix digital and analog design! Fingers crossed one day we will have 6581 silicon that is closer to original!
So out of curiosity, are there any FPGA cores that can very very very closely replicate the Z80 that would also be available in similar form factors? I am just thinking preservation here where you could zap in a Z80 core and pinmap to a cheap Lattice like device (for example) and revive old hardware. Or are we stuck with dwindling supplies and emulation on modern processors?
Given the eZ80 still exists, wouldn’t it be easier to just made an adapter board to fit one of those in the socket?
Yeah but what about when it doesn’t still exist (or, more realistically, exists in small enough numbers to make it prohibitively expensive). It happens faster than you’d think. There’s plenty of hardware I can think of from my youth (or even ten or fifteen years ago…) that used to be so common you couldn’t give it away, but now command large ebay auctions.
If it goes away, how will TI keep selling the TI-84 for $150?
They will probably buy a Z80 core design from Zilog and use it to shrink the TI-84 down to one chip (cheaper for them to make). Don’t expect the price to drop though.
The eZ80 is software compatible, but nowhere near cycle accurate. Their aim was to implement the instruction set, but in a modern pipelined core. I don’t think the bus is directly comparable either.
There is the A-Z80 https://baltazarstudios.com/z80-cpu/ that is based on reversed engineered logic from pictures of decapped Z80 ICs
I am considering to try it with https://github.com/rejunity/z80-open-silicon ASAP!
The hype about FPGA doesn’t make any sense to me. The technology isn’t same. It’s like using a random transistor as a substitute for a former high-end nuvistor or electron tube.
I’m afraid your statement doesn’t make sense to me. FPGAs are just a collection of logic blocks but are easily programmable to wired together and implement the logic you desire, including CPUs. The transistors in modern FPGAs are higher performance than those in 1970 Z-80’s in both speed and power efficiency, but FPGAs implement digital logic just like as CPUs do.
From a software point of view an FPGA can emulate any CPU type you’d like (obviously within the available resources on the chip). IO pins on an FPGA can be assigned as required, so once you have level shifted to 5v (FPGAs can work at multiple levels, but not normally above 3.3V) they can appear to be identical from a signaling point of view also.
You don’t need much FPGA fabric to implement a Z80, nor high performance, so it should be possible to create an FPGA implementation of a Z80 that fits in a 40 pin DIP socket, looks to the rest of the system exactly like a Z80, doesn’t cost much more than a real chip and runs Z80 code exactly like the original.
If your original device is prohibitively expensive, unreliable or unobtainable then FPGAs make a good deal of sense.
The technology isn’t the same but that doesn’t really matter for digital systems, as long as you can implement the same logic then it is functionally the same.
There is a reason that FPGAs are becoming popular for retro games or retro computers. FPGAs are capable of being used as functionally equivalent systems, even down to hardware bugs.
Now if it was an analogue system then you would have a point but the systems that are getting emulated are digital and the only difference using better or modern components yields is higher maximum clock speeds. You can run it at the original clock speeds and you would not be able to tell whether it was an FPGA or original chip you were using.
It seems you just don’t understand FPGAs and likely have never used one.
One issue with FPGAs is that they are 3.3V while Z80 is 5V. Not impossible to solve with PCB and buffering, but adds some complexity.
The first iteration Z80 on TinyTapeout won’t be 5V compatible either, however the ChipIgnite and Skywater 130 nm process actually allows to support 5V – so going to happen in the 2nd iteration, I think!
Jupiter ACE
Year 1982
Generation 4th
CPU Zilog 80
ran Forth.
2024. ARM A and M., RISC-V … and even x86 platforms.
Using indirect gcc c c technology:
6.3 Labels as Values.
https://gcc.gnu.org/onlinedocs/gcc/Labels-as-Values.html
“An alternate way to write the above example is
static const int array[] = { &&foo – &&foo, &&bar – &&foo,
&&hack – &&foo };
goto *(&&foo + array[i]);”
array[0]=0x0, array[1]=0x20, array[2]=0x40.
256 bit ONGOSUB/ONGOTO?
array[3] segment fault, core dump. 196-70s parlance?
“Note that this does not check whether the subscript is in bounds—array indexing in C never does that.”
What?
Huh?
[William Payne]
Some of your comments are so cryptic, I wonder if they even relate to to subject at hand.
A little more comments in your code perhaps?
Polish firm create a zx80 implementation in silicon. meybe ask for this code?
I wrote 8080/Z80 code for about 15 years from the first line to the last in 1993. Wonderiful projects. With a touch of nostalgia, I will miss it.
I interviewed Rej about the project here: https://youtu.be/GI1e22A2J3U
Most of what’s written is Swahili to me, though I know that my Moog The Source carries Z80 so just I worry, if a compatible replacement to it would be available anytime in case I need it anyone could please decipher or comment on that ?
I am sure, you will be able to buy Z80 easily for quite a while – there were enough manufactured for keep you going for long time.