Being simple to make and cheap, the adapter has found a home in many machines besides the Sinclair already – only a couple of PCBs are left and the feedback from assemblers has been good.
The main challenge with the Sinclair is the available expansion slot height, which is what the small form-factor adapter was designed to solve. Here it is fitted to the Sinclair, with the top cover fitted.
Since the Sinclair doesn’t have any spare power connectors, make use of the 4-hole power outlet on the PCB to attach a floppy-drive style power lead to power an IDE to CompactFlash adapter (alternatively the keypin on the adapter will supply 5V, if the CompactFlash adapter in use supports this).
Testing, after a couple of false starts, has been successful so far. Be sure to set ‘IDE Controllers’ to 1 (and the adapter type to XT-CF of course) when configuring the XTIDE Universal BIOS. The BIOS can be written out using the lo-tech XT-CF flash utility.
Tandy helpfully included an expansion slot in their 1400 series of laptops, and in places there is reference to an expansion box, but it seems it never made it to market. The later 1400FD and 1400HD models retained the expansion slot and added a second (slightly different) slot for an MFM HDD controller, as implemented in the 1400HD.
The expansion slot is basically an 8-bit ISA slot, but with a different pinout and a few differences, in a custom card form factor to fit in the machine. Power budget is also limited to 200mA, according to the service manual. Fortunately, Tandy documentation provides everything needed to create a card – so here is what I believe to be the first ever expansion card for Tandy 1400 Series laptops (only about 20 years late):
Expansion Card Design
Based on the information available in the Tandy technical reference, I’ve created a wiki page detailing everything about the expansion slots. Some of the Tandy documentation is contradictory, but my wiki is based on what is now a proven design. I’ve also included an Eagle layout for the PCB (restricted to a 100 x 100mm footprint, to enable low-cost manufacture by SeeedStudio).
My XT-CF cards provide hard disk functionality to PC/XT and PC/AT class machines based on CompactFlash (or microdrives), and for the Tandy 1400 the design needs just four ICs – a flash ROM, two 74688 address decoders and a 74139 decoder. Being XT-CF compatible, the design is fully supported by the XTIDE Universal BIOS (from build r554).
I built this board a while back, and although BIOS flashing went OK the machine didn’t want to initialise the XTIDE Universal BIOS. The BIOS was clearly detecting the option ROM as the floppy seek test was performed on only the first floppy with it present (the BIOS assuming that an HDD would be installed in place of the second floppy, exactly as the 1400HD was shipped), but the BIOS initialisation messages never appeared.
This has had me stumped and the board simply sat on the side since. But recently XTIDE Universal BIOS project lead Tomi posted a code update (in r552):
XTIDE Universal BIOS can now be initialized if non-standard main BIOS does not call INT 19h or if INT 19h handler is replaced by some other BIOS.
And sure enough, the BIOS fired into life and the machine booted (and yes, the SuperTwist LCD screen really does look this bad):
The solution isn’t quite perfect – the fixed disk is inaccessible when restarted via CTRL-ALT-DELETE, but since boot time on this machine is identical for both soft boot and cold boot, this is just something that we need to live with for now.
1400LT, 1400FD and 1400HD
For 1400FD systems at least with BIOS 1.04, the system BIOS assumes the second floppy isn’t installed when the XT-CF option ROM is present (this may also affect 1400LT systems). For now this is a limitation, but with 32KB of flash ROM available it should be possible to resolve it by adding a floppy BIOS to the card.
For 1400HD machines, the MFM controller must be removed since both cards have their BIOS at C800h (upper memory space is somewhat limited in the 1400 series as Tandy included RAM in the upper memory area for use as a RAM disk).
Using the ‘XTplus’ XTIDE Universal BIOS build (thanks to the V20 CPU), DOS throughput (as measured with my own test utility) is at least 550KB/s. Due to the 8-bit data bus and V20 microcode optimisations, there is no performance difference between standard 8-bit PIO and BIU offload modes (as set with XTCFMODE), although both modes are supported.
ENIG PCBs (gold plated) are available now through the shop page.
Components will also be needed from your local electronics outlet such as Farnell, Mouser or Digikey – full Bill of Materials in the wiki. There is no bracket needed, since the card slides into the expansion slot guides within the system chassis, and the fit into the slot is tight enough not to need and further support.
I was contacted recently by the owner of a Sinclair PC200 (an XT class machine in an Atari ST style case) about my XT-CF boards, wondering if a custom board could be built for the machine, with its physical 50mm height restriction on its two ISA slots. The quick answer to that is no, since the CompactFlash header is too big in either orientation, but I’d already been pondering on the idea of a super-simple PCB providing a 40-pin IDE header, based on the lo-tech 8-bit ROM board, so this seemed like a good opportunity to finish the design.
A through-hole, small form factor 8-bit ISA adapter providing a 40-pin IDE header suitable for connection to a separate IDE to CompactFlash adapter (available cheaply on eBay). By using a 40-pin header instead of a CompactFlash socket, home assembly of the device is made simple as all required components are 2.54mm pitch through-hole.
Other than the small form factor (and without any provision for a slot bracket), the PCB is a standard ISA card and can be used in any PC with an ISA slot.
New IDE Logic Implementation
Making an XT/IDE derivative in such a small PCB meant minimising the component count:
Whilst the XT-CF-lite was based closely on the original XT/IDE adapter, borrowing directly its OR and inverter gate design to provide IDE register access and IDE reset, with this new board this has been condensed into a single 74LS139.
Because of the 40-pin potentially cabled connection to the CompactFlash adapter, a buffer (74HCT245) is required, but with only 8-bit transfer mode supported (hence the CompactFlash designation), a 16-to-8-bit MUX isn’t required
Any CompactFlash or microdrive device should work with this adapter, and probably ATA-2 compliant hard drives (since 8-bit transfer mode is a requirement of ATA-2).
I wanted to include as much functionality as possible, so implementing the logic for IBM PC/XT Slot-8 compatibility (developed with the CPLD based XT-CF adapters) was a goal. Although out of space on the ISA component side, the layout could accommodate a few SMT components on the ISA solder side: these are entirely optional, but when populated provide LED drive and Slot-8 functions.
The logic required to provide slot-8 functionality is straight-forward – it’s just an echo of MEMR or IOR when either the ROM or IDE ports (respectively) are selected, with an open-collector drive since other logic on the system board can also drive this signal (as I’ve written about before). In this new board, this is implemented with a single 74LS33D quad NOR gate, the one spare gate being used to provide LED drive too:
LED drive requires the SMT 74LS33D populated since CompactFlash devices provide only minimal activity LED drive current, which is likely already absorbed by LEDs on the required CompactFlash to IDE adapter.
The boards are fully supported by the XTIDE Universal BIOS (from build R545), with standard 8-bit PIO transfer mode and the enhanced performance BIU Offload mode just as with the XT-CF-lite. The DMA transfer mode of the XT-CFv3 is not however supported.
ENIG (gold plated) rev.2 PCBs are available via the shop page.
The XT-CFv3 DMA transfer mode works in an unconventional way to deliver the highest possible throughput for the original IBM PC and PC/XT – here’s how.
The Intel 8237 DMA Controller
In the PC and PC/XT, the Intel 8237 DMA controller provides two functions – it keeps system memory alive by periodic refresh, and it enables transfers to and from IO devices with minimal CPU intervention (the floppy drive, many hard disk controllers, and SoundBlaster cards use DMA). To achieve this, the DMA controller has four sets of DMA Request (DRQ) and DMA Acknowledge (DACK) lines and broadly, the process is:
DRQ is asserted by the requesting IO device (e.g. the floppy drive controller)
The DMA controller raises the HOLD line (connected to the 8088 CPU)
The 8088 CPU completes the current bus cycle, then asserts HLDA (Hold Acknowledge) so passing control to the DMA controller. At this point, all output lines on the CPU are put in a high-Z state (effectively disconnected) and the CPU enters a waiting state
Now the DMA controller has control of the bus, it presents the memory address on the address bus and asserts AEN, which signals to IO devices not involved in the DMA transfer to disregard the bus cycle
The DMA controller next asserts DACK, preparing the IO device to present (or receive) data
Then the DMA controller asserts both IOR (IO read) and MEMW (memory write) concurrently, or IOW (IO write) and MEMR (memory read), so feeding data directly from the device to memory or vice-versa
The DMA controller transfer counter and memory address registers are then updated
What happens next depends on whether more data is available (so DRQ is still asserted), whether the transfer counter has reached zero, and finally the DMA controller operating mode. In single byte transfer mode, the DMA controller will return control to the CPU by releasing HOLD after each byte, whilst in demand mode the process will continue until the IO device releases DRQ (block mode generally isn’t used because it can disrupt RAM refresh, as described below).
DMA vs Port IO
In demand mode DMA runs much faster than 8088/V20 transfers since with DMA, each byte is delivered to memory in just one bus cycle. The 8088, on the other hand, has to read the byte from the IO device in one bus cycle then store it to memory in a second bus cycle, because both the IO device and memory use the same address bus. On the 8088, the code to fetch a block of port mapped data is less than ideal:
mov cx, 512
in al, dx
The instruction fetch and jumps of course make this slow, although it can be improved by unrolling. In the XTIDE Universal BIOS, this is the basis of the 8-bit port-mapped IO operating mode for the XT-CF series, achieving about 170KB/s at 4.77MHz. The V20 though streamlines this by eliminating instruction fetch and jump overhead:
mov cx, 512
Freeing up the bus for just the data by the elimination of all the instructions pays significant dividends – this delivers about 390KB/s at 4.77MHz (and is available in the ‘XTplus’ XTIDE Universal BIOS build, for V20/286 powered XT class hardware).
Making DMA Scream
DMA on the PC and PC/XT brings with it some challenges:
Programming the DMA controller absorbs many cycles
Control must be returned to the CPU every 15 µs (72 cycles) for RAM refresh
To play sampled SoundBlaster audio at 22KHz, the DMA controller must be available to service the SoundBlaster DRQ once every 216 cycles
For my goal of ultimate throughput, packing bytes back-to-back on the data bus is the key – and with each byte taking 4 cycles, 18 bytes can be transferred before disrupting RAM refresh. For the XT-CFv3, this is achieved with some counter logic to release DRQ after 16 bytes (since that makes the maths easy and provides a margin of safety):
In the XT-CFv3, the oDRQ output in the schematic is delivered to the ISA bus via a 3-state output buffer, because the card must be able to co-exist with any original hard disk controller and DMA channels (DRQ/DACK pairs) can’t be shared as there are no pull-ups on the DRQ lines, so the card must drive the line continually when DMA function is in use.
Because DRQ is released by the counter, the DRQ lines on the IDE interface can’t be used – and in any case, DMA isn’t even supported by the majority of CompactFlash cards. The XT-CFv3 therefore provides another mechanism – to allow the software direct control over DRQ through an IO port write (the address decoding for which appears in the schematic above as ‘XTCF_DRQ_PORT’). This approach makes the transfer code itself elegant, once the DMA controller has been programmed:
mov cx, 32
out dx, al ; Raise XT-CFv3 DRQ & transfer 16 bytes
loop .TransferNextDmaBlock ; loop also adds required wait-state
The results are heavily dependent on the media: the majority of CompactFlash cards support only single-sector transfers, and therefore the DMA controller must be programmed once for every 512 bytes transferred, which delivers about 420 KB/s – a vast improvement on 8-bit port IO. But for devices supporting multi-sector transfers, performance rises to 530KB/s with an 8088 and a 560KB/s with a V20 (both at 4.77MHz).
Since working on the Dangerous Prototypes version of the XT/IDE project, I’ve been increasingly interested in ‘the storage problem’ for early 1980’s PCs – it’s both difficult to transfer files between machines and increasingly problematic storing data on them too, with still surviving hard drives now well into borrowed time.
The goal was to make a board with the DMA function of the XT-CFv2, but as easy to make as the XT-CF-lite (only the CompactFlash header represents something of a soldering challenge). So the XT-CFv3 specs:
8-bit ISA card providing bootable fixed-disk storage for PC/XT and PC/AT class hardware
Up to 8GB usable by MS-DOS (DOS limit)
CompactFlash header positioned to allow CompactFlash media to be exchanged through a custom ISA card slot, without opening the PC
32KB in-system re-programmable flash ROM, providing storage for the XTIDE Universal BIOS boot ROM with 24KB free
Provides several transfer modes optimised for 8088, V20 and 286 machines
Up to 530KB/s in a stock PC/XT, and up to 1.1.MB/s in a 12MHz 286
Low-cost manufacturing requirements
Programmable Logic: the Xilinx XC9536
At the heart of the XT-CFv3 is the Xilinx XC9536 CPLD. To me, these are little pieces of silicon magic – simply hook up the components on the PCB to the nearest convenient CPLD pin, then define in software the circuit logic the CPLD should perform and upload it into the CPLD. This is great for home-brew projects like this, since once the basic PCB layout is done and the board electrically sound, the design can be revised over-and-over by just reprogramming the CPLD.
The XT-CFv3 logic is a greatly simplified version of that from the XT-CFv2, which aside from electrical reliability issues, was working well enough – so I was confident the logic would work. Even so, six revisions were needed to finally bring the thing to life. But it’s running now with three modes of operation – more on which will follow soon 🙂
DMA is the big XT-CFv3 feature: it offers performance way beyond what any disk controller ‘back in the day’ could do, achieving up to 530KB/s on a stock PC/XT. The CPLD implementation makes this possible since it can do the work of many discrete logic chips (and of course be reprogrammed in the development phase getting it running). More on this, and the other operating modes, to follow soon.
The XT-CFv3 is just entering field testing so is some way off still. The plan though is to offer bare PCBs and brackets for home assembly.
When the idea of a 3.3V CPLD was first mused on at Dangerous Prototypes – because of the lack of availability of 5V parts – some queries were raised over quite how 5V tolerant the inputs would be in reality. And it seems those fears weren’t without foundation, since steadily the prototype boards started to misbehave; they all seemed to follow the same pattern with DMA transfers going slow and then failing altogether, then memory-mapped IO failing next. For whatever reason, basic port-mapped IO seemed to survive.
Stumped by this, I turned my attention to the XT-CF-lite board (now sold out, sorry!), keen to deliver ‘something’ after all this time. And the board seems to work well – built on the 8-bit transfer mechanism and experiences with the XT-CFv2 in port-mapped mode, the board is entirely 5V 7400 series based, but critically there is no buffer on the data lines: the CompactFlash (or flash ROM) drive the data bus directly. Which got me thinking.
Whilst the XT-CFv2 uses a tricky-to-solder 100-pin 72-macrocell CPLD, by eliminating all 16 CompactFlash data lines and the 8 ISA data lines, I wondered if the logic be moulded into an easier-to-handle VQ44 package CPLD? I wanted to keep DMA and Slot-8 compatibility, but memory-mapped IO turned out to be something of distraction – it’s only faster because it enables 8088 CPUs to use REP MOVSB to make a transfer, but DMA is much faster on an 8088, and the V20 (and 286+) can use REP INSW anyway. So losing memory-mapped transfers seems OK to me.
In a stroke of luck, I spotted forthcoming stock of Xilinx XC9536 CPLDs in VQ44 format at Farnell – absolutely ideal for this as the simplified logic easily fits in the 36 macrocells, and the 34 IO pins are just enough.
So round the prototype mill we go again, this project has turned out to be way harder and more time consuming than I was expecting 15-months back. But it’s only a hobby and it is still progressing – I’m currently awaiting delivery of the first XT-CFv3 PCBs, although the CPLDs won’t be available until the end of February. The logic is much simpler, the board will be easier to make like the Lite version.
In the mean time, I’m improving the flash utility to work with the cheaper and more readily available A29010 flash chips – so fingers crossed for 3rd-time lucky 🙂
Beta testing of the XT-CFv2 has uncovered some compatibility and reliability issues that will take time to fix, so in the mean time – and conscious of the long development time already of these boards – I’ve turned my attention to making a simpler, more home-assembler friendly XT-CF derivative.
Surface-mount (SMT), especially the 0.5mm pitch components, seem to have put off home-assemblers, and then there’s the need to program the CPLD. Though SMT can’t be avoided because of the CompactFlash header, using SOIC chips but still in the same PCB footprint (and ISA slot bracket), things can be made a lot easier.
Just like the XT-CFv2, it’s a self-contained ISA disk device, functionally like a hard-card, providing solid-state, bootable storage to any PC with an ISA slot – right back to the original IBM PC 5150.
This board provides the same basic functionality of the XT-CFv2 – a 32K (accessible) flash-based ROM (with 24KB available for any user purposes), XTIDE Universal BIOS support and the port-based IO transfer mode used by the XT-CFv2 by default. But there are some limitations, because the CPLD on the XT-CFv2 provides a wealth of logic space not present here, so the lite version misses out on BIOS port auto-detection, memory-mapped IO, DMA, slot-8 compatibility, and reduced-wait-state operation for PC/AT and above.
Usually a buffer chip like the 74LS245 would be used between the ISA bus and the media, but I took a chance that one isn’t needed, because the CF card is directly connected (i.e. not cabled) and has 8mA output drive strength. And luckily, it seems to work!
That’s SMT – wasn’t is supposed to be easier to make?
We can’t get away from SMT and still use CompactFlash – through-hole sockets do exist on datasheets, but are near impossible to find. Compared to the XT-CFv2:
0.5mm lead-pitch flash chip has been replaced with an easy through-hole DIP package, and the 100-pin CPLD has been eliminated altogether
1206 package resistor networks have been replaced with a through-hole network
And of course there’s no CPLD programming to do once it’s assembled. The activity LED and driver IC (IC6) can be left-off if need be. The tiny 0603 package capacitors and resistors remain but are also quite easy. The hardest part is the CF header, but locating points on the header hold it in position whilst it’s soldered, and the trick is to use plenty of flux and flow solder over the pins generously, then use solder wick and more flux to clean up the job.
The XT-CTv2 is an 8-bit ISA card that works like a hard-card – a self contained, bootable hard disk for any PC with an ISA slot, right back to the original IBM PC 5150.
It’s powered directly from the ISA slot and uses fast and cheap Compact Flash cards for storage, accessible through the custom-made ISA slot bracket, making file exchange between machines easy and without the need to open the machine.
My project goals were to build a board fast enough for Trixter’s incredible 8088-Corruption to play 30fps video on a PC/XT without re-buffering pauses, and to replace the by now themselves ageing IDE disks with smaller, cheaper and more portable compact flash (or microdrive) media.
Basically, because it’s easy. Compact-flash cards can be made to behave like IDE hard drives so making possible the use of the well established XTIDE Universal BIOS, and they also support 8-bit transfers – ideal for this application. And besides, whilst compact-flash has been around for years, it’s still the media of choice for professional photography and embedded applications, so hopefully will last a while longer yet.
As a development of the Dangerous Prototypes XT/IDE design, the board is based on a programmable logic (CPLD) chip, so the logic making it work is literally drawn out in software and then programmed into the CPLD chip – and this can be done over-and-over.
So with an electrically sound board, thanks to the work by Dangerous Prototypes, a novice like me is free to try and re-try ideas, and hopefully eventually come up a working design.
With countless hours researching, pondering, testing and tweaking – and the kind help of many vcforum members – slowly the logic and BIOS modifications have come together. XTIDE Universal BIOS project lead Tomi is very kindly adding code specific to this board under adapter type ‘Lo-tech XT-CF’.
The primary goal was speed. There are several ways to transfer data in the PC, and this board offers three alternatives. For best compatibility, it defaults to 8-bit port-mapped IO that, in a PC/XT, does about 150KB/s.
Once DOS is running, 16-bit memory-mapped IO can be enabled with a simple utility, providing 240-300KB/s – similar to the fastest 8-bit controllers in the 1980s. And for PC/AT systems, that can be improved further with reduced wait-states (to about 1MB/s, in a 12MHz 80286).
With port-mapped and memory-mapped modes, the XT-CFv2 can be used in the PC/XTs ‘slot 8’, a slot usually seen as wasted because not many cards work in it, and can also co-exist with MFM or RLL drives if required.
But the XT-CFv2’s stand-out feature is its DMA mode – although there’s nothing unusal about an 8-bit disk controller using DMA, this works differently. Instead of using IRQs and single byte transfer mode, with the XT-CFv2 the CPU actively controls the transfer by repeatedly instructing the XT-CFv2 to call the DMA controller to transfer 16 bytes at a time (as much as can be done before needing to pause to allow the DMA controller to refresh system RAM). The result is file system throughput way beyond what a 4.77MHz 8088 can achieve on its own; up to 530KB/s. As far I can tell, this makes it the fastest ever PC/XT disk controller – and by some margin 🙂
Separately, I’m organising a batch of about 20 assembled boards as a kind of public Beta over the next few weeks; watch this space! After that, feedback depending hopefully things will move on to a run of about 100 boards.
With the 8088/8086 CPUs, Intel provided instructions to copy blocks of memory – such as “rep movsw” – but an equivalent for port IO didn’t arrive until the 80286 (also in NEC’s V20). So on a PC or PC-XT, separate load, store and loop instructions are needed, for example:
in ax, dx ; get 16-bit word from controller
stosw ; and store it in memory
loop .TransferLoop ; and repeat
That runs at about 200KB/s on a 4.77MHz 8088 (any disk access based on it would be slower, because of the file system and other overheads), but could be improved by ‘unrolling’ a bit, since the loop instruction is slow – this being the code used in the ‘ChuckMod’ BIOS for reads, translating to about 210KB/s in real file-system throughput.
But, if the hardware can be arranged to make the sector data look like a block of memory, this code can be replaced with ‘rep movsw’, which runs at 360KB/s. There’s another advantage too; for machines with 16-bit buses (such as 8086 CPUs in systems with only 8-bit ISA slots), there’s no overhead in gathering the instructions from the 8-bit ROM to execute, leaving the external bus clear for just the IO itself.
To make each sector of data look like a memory block, we don’t need any memory on the card; we just need to respond to the ascending memory address addresses the CPU will be asking for.
That in itself is quite easy – we just ignore the address lines that will be changing – but it’s complicated by three of those lines being used to communicate with the IDE interface already. But since this board is CPLD based, it’s relatively easy to add logic to hold those low during a memory-mapped transfer.
The first hurdle was to speed up writes generally. Although the ChuckMod design makes access to the ports sequential, for writes we need to write to the drive on the second byte, whereas for reads we need to read on the first, hence why write speeds are lower than reads for the ChuckMod design (as it needs byte transfers for writes).
To get past that, I tried to distinguish writes using /IOR and /IOW triggers, but this wasn’t stable since those signals are sent slightly after the address lines, and the IDE interface expects that ordering. We need to know if it’s a read or write at the start, so in my design I use an address line: reads are via port x00h as usual, but writes are to port x10h.
The 8- to 16-bit MUX itself then becomes quite simple, just a single byte latch and some buffers, and a few logic gates to work out which way data is travelling:
And amazingly, it worked! Write speed is nearly doubled with this logic, running at over 200KB/s.
So then to memory-mapped support. I’ve literally added-on the capability, making it possible for the design to work with either port or memory-mapped IO. This gives only a couple of changes to the MUX module but a whole second address decoder section for it (the bottom half):
To distinguish writes on memory-mapped transfers (to get the IDE transfer ordering correct), I couldn’t use A4 as with port based IO, so A9 is used instead, so reads are from Base+0000h and writes are from Base+0200h. One other change is to include a test for A19 on both halves, so only one of the decoders can produce an output.
The universal BIOS developers requested some way of identifying the card, so I added a ‘device ID’ constant at an unused port address (x0Fh). Then came the idea of loading the memory-mapped IO base address into the card via the same port, hence this buffer design, the latch on the left storing the memory-mapped base address:
The design looked like it should work, but fitting it into the CPLD proved difficult. After a bit of reading, some tweaks to the settings finally got it fitted.
Enabling the write-cache on a microdrive I was using for testing, writes increased to 300KB/s.
The BIOS code is very much at the ‘alpha’ stage – I’ve not found any problems with it, but it’s hard-coded to use a transfer window at a base address of D800h.
Better BIOS support, with on-the fly memory-mapped configuration, more system and drive testing, and looking into whether a production run of assembled boards is feasible. None of that is too bad – the project is nearly finished!
After that I have a couple more ideas – to re-visit the idea of a board with both compact flash and 40-pin header, and to port the design to the Tandy 1400FD.
About the XT-CF
The Peacon XT-CF has been designed as a cheap-to-make 8-bit ISA board providing a bootable compact-flash socket to any PC with an ISA slot. The board draws on the basic physical design of the Dangerous Prototypes XT-IDE V2 board, itself inspired by the original XT/IDE project. The board makes use of the interoperability of 3.3V and 5V logic signals to enable the use of low-cost 3.3V surface-mount components, and has been sized to fit within board size limits of Seeedstudio for low-cost production.
So what’s next for the XT/IDE project? Besides the few DPv1b and DPv2 boards left, effectively none of the boards are available. For the DPv2, many hobbyists will be unwilling to tackle SMT boards and being just over 100mm wide, it’s expensive to have made by (eg) Seeedstudio as a one-off.
Andrew Lynch periodically orders a short run of the ‘Mk.II’ XT/IDE board, although currently it looks that all stock is depleted. Other projects, such as the ‘JR-IDE’ controller for the PCJnr, are ongoing but again have no boards available to buy for an ordinary PC as of right now.
Dangerous Prototypes v2
One motivation behind the Dangerous Prototypes development with SMT was the possibility of a cost-effective short run of finished boards – professionally assembled with the CPLD and EEPROM programmed. In effect, the first new commercial 8-bit ISA card probably for at least 15 years 🙂
The problem is quantities, as to be viable it needs demand enough for 100 boards or more. Since there’s probably only been 100 of the original XT/IDE boards ever made, that just seems unlikely.
DOS can only access about 8GB, which is way more than could ever be filled with XT class software, yet CF cards that size are currently about £10. And being solid-state, they have near zero command latency – look at the performance numbers side-by-side with the ST-412 in the ubiquitous PC/XT:
And don’t think CF cards top-out at 13 IOPS; that’s just a reflection of the file system processing speed with a 4.77MHz 8088. The same CF card on the same XT/IDE controller (with ‘chuck-mod’) in a Pentium-200 turns in over 1MB/s and 700 IOPS – compared to about 140 IOPS from a current SATA drive.
Why not SD or SDHC?
The great advantage of CF cards is that they have a ‘true-IDE’ mode, in which they behave like an IDE disk. This is why CF-to-IDE adapters are so simple; literally they are just a plug adapter with a couple of LEDs thrown in for good measure. So modifying the DPv2 for CF should be quite straightforward, whereas implementing an SD card controller would require a CPLD with much more capacity and some supporting hardware with it.
Against the Grain
So going completely against the survey, my card as it exists today has only a CF slot, mounted so the CF card is accessible through the expansion slot bracket (but not hot-pluggable). Originally based on the DPv2, there’s now little left in the design from it other than the CPLD choice (the Xilinx XC9572XL). By replacing the EEPROM with a flash chip and revising the logic design, it should be quite a bit cheaper than the DPv2.
But as ever, there’s a problem: it needs a custom ISA bracket. Laser cutting and punch-press are options, but only cost effective at 50 units+. But for prototyping, I’ve managed to get one made by a friend.
The first challenge is revising Pietja’s CPLD code for my board; since the CF header pinout is ‘muddled up’ compared to the IDE 40-pin header, it made sense to just adjust the CPLD pinout to match, rather than mess about with complex PCB trace routing. The Xilinx CPLD coding is developed through Xilinx ISE, which helpfully they provide for free (after registration).
The next problem is programming the SST39SFxxx flash chip. It’s byte-programmable but with a software data protection scheme (which prevents bad code elsewhere over-writing the contents) that isn’t supported by the XTIDE universal BIOS utility, flashing this card will be a two-step process: configuring and saving the ROM image with the xt-ide universal BIOS configuration utility, then flashing the card using my own simple flash utility.
The First Cut…
So the prototype board has been built, the bracket pressed, the flashing utility compiled. After quite a learning curve with ISE… it works!
So far I’ve only adjusted Pietja’s DPv2 CPLD code for it (changed the pinout and ROM decode), and this is the original XT/IDE design, but it’s a start. The next step is to generate CPLD code for my revised circuit design that I hope will get writes going as fast as reads do with the ‘chuck-mod’ – but that’s all a job for another day.
Interested in building one of these? All the parts can be sourced from Farnell, and the resources you need are right here – some notes on SMT soldering and the XT-CF wiki page through which you can find CPLD code, parts lists and the flashing utility. You’ll need some way to program the CPLD too (via the JTAG header).
I’ve got a few of these blank PCBs to give away, so leave your email address in a comment (won’t be visible to others) and I’ll send you one for nothing!
Privacy & Cookies Policy
Necessary cookies are absolutely essential for the website to function properly. This category only includes cookies that ensures basic functionalities and security features of the website. These cookies do not store any personal information.
Any cookies that may not be particularly necessary for the website to function and is used specifically to collect user personal data via analytics, ads, other embedded contents are termed as non-necessary cookies. It is mandatory to procure user consent prior to running these cookies on your website.