The Generic (Z80) IDE interface


Latest developments!
IDE geometry seeker (experimentally determines the operating geometry of the IDE drive)
GIDE BIOS, floppy-disk warm-boot
IDEGEN utility
GIDE BIOS, hard-disk warm-boot

The GIDE, by Tilmann Reh, is an IDE interface designed to be installed between the Z80 CPU and its socket in nearly any Z80-based computer. Where space prohibits ``under-the-Z80'' installation, the GIDE may be attached to a (short!) ribbon cable which is connected to the CPU socket with a 40-pin IDC DIP plug. If the CPU is soldered into the computer's main board, an additional socket may be (carefully!) soldered to the CPU and the GIDE board connected via ribbon cable as mentioned above.

Because of my involvement in the general 8-bit IDE project, Tilmann (through Herb Johnson) sent me the bare PCB and pre-programmed GALs for the GIDE for evaluation. Lately, I was able to collect the rest of the parts required to complete the board. I hope to present an account of my experiences with it.

Total construction time was about 90 minutes. Outside of having to deal with a couple of through-holes filling with solder prematurely, everything went smoothly. The GIDE provides for a battery-backed real-time clock and although I didn't have the 72421 clock chip, I installed all the supporting components for it anyway.

To do preliminary testing, I installed the GIDE under the CPU of an Applied Engineering Z80+ card (MicroSoft SoftCard clone). It booted and ran OK, so the GIDE board wasn't causing a problem. I hooked up the IDE hard disk I'd been running on my Epson QX-10 and whipped up a small code fragment under C. B. Falconer's DDTZ to send the IDE IDENTIFY command to the drive and read back the ID record.

It worked! Well, actually I noticed an odd glitch that turned out to be a fault of the Z80+'s design. Seems Applied Engineering omitted the Z80's MREQ* and IORQ* signals from their Apple-][ bus-access logic. Thus there is no way to distinguish between an I/O cycle and a memory cycle!

The GIDE re-routes the Z80 RD* signal so that RD* is not asserted on the CPU socket when reading from the GIDE, but no such protection was given to the WR* signal. When I wrote to the IDE task file registers, I was also scribbling on system memory!

To remedy this problem, I cut the RD* and WR* traces leading from the Z80+ CPU socket, took a 74LS32 quad 2-input positive OR gate and carefully bent its pins completely backward, clipped off the narrow ends of the pins and hot-glued the chip to the solder-side of the Z80+. I soldered wire-wrap wire to make appropriate power and ground connections. I attached the CPU socket's MREQ* line to one input of two of the OR gates in the chip. I attached RD* and WR* to the other input of each of the OR gates. I then attached the output of the OR gates back to the remaining WR* and RD* circuitry using conveniently-located through-holes. I covered the protruding chip and wiring with some non-conductive adhesive tape.

No more scribbled memory!

I've now started experimenting with GIDE on my Davidge DSB 4/6 (DSB 4000, rev. B) single-board computer. When I initially installed the board, the machine couldn't boot--the boot drive just sat chattering over track 0. I know that I chose an appropriate base address, so something else must be amiss.

It turns out that there was bus contention for the RD* signal. The GIDE's masked read signal (RDQ*) doesn't assume a high-impedance state--it's always either high or low. The Davidge DSB 4/6 relies exclusively on the Z80DMAC to do disk I/O. As such, the Z80 CPU's RD* signal goes to high-Z and the DMAC drives the line. With the GIDE in place, the DMAC and the GIDE were fighting over the RD* signal. Hence the problem.

One solution to this would be to lift the DMAC's RD* pin and attach it by flying lead to the GIDE's CPU socket. I opted for a more radical solution. As I don't need the masked read (RDQ*) signal, I simply cut its trace on the GIDE PCB (leading from pin 13 of the GAL16V8 to pin 21 of the piggy-back connector) and soldered in a jumper in J3 that connects position ``A'' directly to position ``B.'' This modification returns the CPU's RD* signal to its customary place in the Z80 control bus.

With the GIDE thus modified, the Davidge boots up just fine!

As soon as I can procure a cheap, small-capacity (40MB or less) IDE hard disk, I will be able to proceed with testing and the eventual development of an IDE BIOS extension for the Davidge DSB 4/6.

GIDE Update: 20 November 1995

Back at the beginning of November, I managed to acquire, quite inexpensively, a Conner CP-3024 20MB IDE hard disk. This was fortuitous as I have the OEM manual for this drive (Conner sent it to me when I still had the CP-3022 drive, but the two drives were dissimilar enough that the manual didn't help me with the CP-3022).

Now that I had the actual drive to accompany the manual, I set it up to run on my Epson QX-10. The first thing I learned was how FAST it was compared to the CP-3022 (and the CP-342 I had been using since I fried the CP-3022). I looked at the data returned by my ID program and saw that the CP-3024 had a 16-sector buffer whereas the CP-3022 and CP-342 only have a 1-sector buffer.

The second thing I learned was that the geometry reported by the CP-3024 is not the one it actually uses. (The geometry reported by the CP-3022, in contrast, was the actual geometry that it used for regular access.) Since I had the OEM manual, it was apparent that the CP-3024 was reporting its physical geometry. Some more digging through the OEM manual indicated that the CP-3024 powered up in ``translation mode'' of 615 cylinders, 4 heads, 17 sectors per track.

What does this have to do with GIDE, since I can't use it on the Epson QX-10? With the Conner CP-3024 set up on the QX-10, I was able to move my Conner CP-342 to my Davidge DSB 4/6 single-board computer which is where I have the GIDE installed. If you recall, I had to modify the GIDE so it could reside in the Davidge (cut RDQ* and jumper position ``A'' to ``B'' on solder-jumper J3). I mounted the CP-342 in the Davidge's case, attached power and interface cables, and powered up.

It works just great! I had eariler re-compiled my ID and sector dump programs to run with the GIDE (changed a couple of #define statements) and it read everything correctly. I re-compiled my program that fills IDE disk sectors with E5h bytes for the GIDE and was preparing to ``zero-out'' the drive for further experimentation on the Davidge machine when I discovered another interesting behavior.

When the requested sector address is valid, the activity LED on the GIDE (and attached to the drive) flashes brightly. If an invalid sector address is specified, the LED flashes very weakly, almost invisibly. I used this behavior with my sector dump program to determine the operational geometry of the CP-342 drive: 981 cylinders, 5 heads, 17 sectors per track. The drive reports 806 cylinders, 4 heads, 26 sectors per track when queried with the ID program, however. Apparently, the ID record shows the physical geometry of the disk, but the drive powers up using the other geometry.

Obviously, determining the operating geometry by watching the LED is tedious, time-consuming, and error-prone (the LED behavior may not be the same on another manufacturer's drive). I realized that I should write a utility to experimentally determine the drive's operating geometry. In about 30 minutes I'd written a little program (in Z80 assembly language) to do just that.

The program simply starts counting up through the heads, then the sectors, then the cylinders, reading one sector. It counts up until it gets an ``IDNF -- ID Not Found'' error, at which time it knows it has found the maximum of the particular coordinate. Being a bit lazy and impatient, I wrote it to run under a debugger (I was using C.B. Falconer's ``DDTZ'') so I could simply load registers with the results and examine them. Eventually, I hope to make a more robust, generalized version of it.

The software confirmed the operating geometry I'd determined by watching the LED.

That's where things stand right now. The GIDE (as modified) works very well in the Davidge DSB 4000 single-board computer with the Conner CP-342 drive. Time and space constraints prevent me from doing much more with it until mid-December. Over the Christmas break, I hope to at least begin writing a hard-disk BIOS extension for the Davidge/GIDE system.

GIDE Update: 25 Dec 1995:

I finally managed to find some of the HCT-series logic that the GIDE board calls for and replaced the LS parts I had been using. At the same time, I was able to get the Seiko/Epson 72421 RTC module that the GIDE has space for. It was all available from Jameco, although they are closing out their HCT-series parts. (At least the prices were good--I got the HCT646 chips for $0.99 each!)

I put the RTC in the GIDE and hacked a battery for it (3.6V lithium). I now have a real-time clock in my Davidge DSB 4000 single-board machine. I put off hacking on the IDE side of things to hack on the RTC stuff. Using Tilmann Reh's supplied example code, I wrote a program to read the time either once or as a running clock (ala TD.COM). I was starting to think about how to do a proper "set" function when I wimped out.

I brought up NZCOM/ZDDOS/etc. on the Davidge.

I looked back through the CardZ180 OEM notes. I found and cleared the CZ flag and removed the special "CPR-stash" routine from the patch area. Now I had a generic version of NZCOM. At first, I brought it up (with ZDDOS) just fine and used ZSCONFIG to make sure that the clock functions were disabled.

I quickly hacked up a ZSDOS/DateStamper clock driver for the Davidge. Since I had to use the special NZBIO.ZRL that saves the index and alternate registers, I had an extra 128 bytes to play with. I simply loaded the clock driver (101 bytes) in the extra space and used ZSCONFIG to point ZDDOS' clock driver entry point at it. That worked marvelously until I got around to installing the !!!TIME&.DAT file on the boot disk.

It was then that I discovered that the NZDOS segment gets used as soon as it's loaded. With the datestamp file on the disk, the last few operations of NZCOM failed and hung since the CardZ180 OEM version of ZDDOS was trying to call the clock driver (FFF5h) before it had been loaded! Fortunately, I had just learned that the highest address used by the Davidge floppy-disk BIOS was FF16h, giving me plenty of room to stuff my clock driver in place at cold boot.

I re-arranged my clock driver so that the entry point would fall at FFF5h and added code to move the driver into place. On cold boot, the "turn-key" CCP command runs my clock loader, which sets up the clock driver. My loader, in turn, stuffs the CCP command buffer with "NZCOM" and jumps to the CCP--causing the CCP to now load NZCOM and bring up Z-System with a fully-functioning clock!

At the same time, I had managed to massage my GIDE IDE geometry seeker (experimentally determines the operating geometry of the IDE drive) into a stand-alone form. Not long thereafter, I changed the base port address and successfully assembled it for use with the Q10IDE interface for the Epson QX-10.

GIDE Update: 18 January 1996

I am pleased to announce that I have succeeded in writing a BIOS extension to support the GIDE on the Davidge DSB 4/6 single-board computer with floppy-disk BIOS FD-4000 v1.3. The BIOS also includes a clock driver to support ZDDOS/DateStamper with the GIDE real-time clock module.

The BIOS extension is intended to execute upon cold boot as the default CCP command. The loader portion determines if the current system has enough high memory to allow the hard disk BIOS module to load and if so, relocates the code and jumps to the "cold boot" routine which finishes the required initializations and transfers control to the CCP. As part of the initialization, it stuffs a new command into the CCP command buffer before control is transferred. This way, any turnkey operations may be maintained with the hard disk BIOS in place.

At first, I tried to get the hard-disk BIOS (HBIOS) and the floppy-disk BIOS (FBIOS) to share the uninitialized data (udata) areas used by the disk blocking/deblocking code. Unfortunately this didn't work very well. It worked OK as long I accessed only the hard disk or only the floppies, but file transfers from floppy to hard disk and vice versa failed if the file was larger than some threshold size.

Eventually, I decided to abandon that approach and defined a duplicate set of udata areas for the exclusive use of the HBIOS. In this form, everything works correctly.

While I was at it, I made it possible to re-map drive letters to an arbitrary drive. This allows the hard disk to become drive A: after the HBIOS is loaded. For my Conner CP-342, I simply made each head a different logical drive (it powers up as 981 cylinders, 5 heads, 17 sectors/track) to get 5 full 8MB logical drives. For simplicity's sake, I'm using 8K allocation units, which I believe to be an acceptable trade-off between internal fragmentation and allocation vector space requirements.

The HBIOS' size requires that a 62K CP/M system be built. Initially, a bootable floppy disk was required to remain in the first floppy disk drive (regardless of whether or not it remains drive A:) for warm-boots to re-load the CCP/BDOS. I've since written an ``IDEGEN'' utility to write the CP/M image out to the reserved tracks of the hard disk and added hard-disk warm-boot code to the HBIOS.

I've been running this BIOS without any problems for several months now and believe it to be very stable. I tried to make it generic enough that it would require little modification to be implemented on other machines.

I eventually intend to make it possible for the system to cold-boot from the hard disk. The additional BIOS code is straightforward, but it will require that I burn a new boot EPROM for the machine.

GIDE Update: 17 June 2025

Wow! It's been almost 30 years since I wrote the preceding paragraph. While recovering from shoulder surgery, I watched a lot of retrocomputing videos on YouTube (especially the excellent Usagi Electric) and it made me nostalgic for the kind of hacking I used to do. So I dug into the pile of stuff and got the Davidge DSB 4/6 out again. That was the easy part. The next few days were spent hunting for the boot floppies. The next hurdle was that the floppies didn't boot anymore. At least the 3.5-inch floppies didn't. So I had to disassemble the machine and swap the drive-select jumpers on the drives so the 5.25-inch drive would be the boot disk. The 5.25-inch floppy booted. It seems the single-density track 0 on the 3.5-inch floppies had "faded", but the double-density data area was intact, so I just FDGEN'd the 3.5-inch disks again.

Once the 3.5-inch floppies were bootable again, (and after cleaning the battery holder that would have kept the 72421 TOD clock running when the power was off—nigh-on 30 years with alkaline batteries installed was not kind to it), I reassembled things and started hacking again. My goal was to get the machine to boot from the IDE hard disk. First, I needed a way to get my GIDE bios extension to be part of the OS image. That was straightforward enough to patch (although I wrestled with the 16-bit overflow math for a bit). Next, I realized that my original IDEGEN utility only ever wrote the CCP+BDOS to the disk (since at the time that was all that was ever necessary). I wrestled with computing image sizes and sector counts but finally realized that my IDEGEN was just an enhanced version of the "GETSYS" and "PUTSYS" utilities described in the DRI CP/M2.2 documentation and I should just read and write the system tracks in their entirety.

Now I had the GIDE BIOS extension included in the OS image file and my IDEGEN utility could write the entire image to disk (and read it back), but I still couldn't boot the hard disk as the ROM code only knows about floppy disks. But who says the floppy-disk boot sector has to load the OS from the floppy? So I whipped up a 128-byte boot sector that could load the OS from the hard disk and jump to the (cold) BOOT routine and patched it into a stock 62K system image. Along the way, I learned a lot about dealing with expected errors (SECID_NF)-- namely that if a read or write command posts an error status you are under no obligation to perform the data transfer. That simplified things greatly.

That gets the system loaded, but I still need a program on the floppy disk to "activate" the hard disk BIOS extension. At least that was reduced to a simple jump to the HBIOS' BOOT routine. Since my floppy-based loader worked, it just needed some padding to be a hard-disk boot sector as well, so it chains 3 relative jumps to get to the 128-byte loader code. The idea is to keep any code that needs to be relocated in the same place as the stock single-density floppy boot sector. Testing showed that it appeared to work. So then I turned the floppy-resident hard-disk boot sector into a chain loader that would load the boot sector from the hard disk and jump to it.

I next turned back to the disassembly of the DSB-4/6's CBIOS since I never had source code to the running BIOS (only the skeletal CBIOS.ASM supplied by DRI). I made great strides in furthering the analysis and commenting of the code and gradually replacing hard-coded addresses with symbols and labels. My biggest struggle has been deciphering the CBIOS' UDATA areas--which is ironic considering that my analysis of that code nearly 30 years ago served as the model for the GIDE BIOS extension itself. I found the BIOS' own routines for printing messages and modified the HBIOS extension to use those instead of CP/M's function 9. That was the first piece of the puzzle

Eventually, I found the point in the CBIOS BOOT routine where it has finished everything it needs to do and is going to jump into the WBOOT routine to finish the initialization and jump to the CCP. The key point is that it loads HL with the CCP base address before jumping to the "GOCPM" point in WBOOT (WBOOT does likewise with CCP+3) which promptly pushes the CCP address on the stack so that when the WBOOT code eventually executes a RETurn instruction, control passes to the CCP (or CCP+3 for WBOOT).

To see if it would work, I patched in the address of the HBIOS' BOOT routine into the instruction that loaded the CCP's address before pushing it on the stack. When I next pressed the reset button, the ROM code loaded the floppy boot sector, which loaded the hard-disk boot sector, which loaded the OS. First the CBIOS sign-on message and CP/M Serial number were printed...

...and then the HBIOS's signon message appeared! I was a little confused by the "No File" message, but then I realized the system image I'd written to the hard disk still had a turnkey command installed in the CCP's Command Input Buffer (to run the old GBIOS62.COM program to install the BIOS and jump to its BOOT routine) and that wasn't on the hard disk. Everything seemed to be working!

As it stood, I had to patch the HBIOS extension at its execution address relative to the system image left by MOVCPM which made the resulting image rather large. I managed to decipher enough of the CBIOS' Udata areas to figure out which parts were initialized by BOOT/WBOOT so I could see about moving the HBIOS extension down closer and using a version of the loader routine from the GBIOS62.COM program to move it into place. As it turned out, there was enough space immediately after the CBIOS image for the loader program and what used to be the HBIOS BOOT routine (print sign-on, set up clock driver entry point, swap jump tables and load the CCP address in HL before jumping to our own GOCPM section of our WBOOT code). The HBIOS extension code had to be loaded further up to skip the Udata areas the CBIOS' BOOT/WBOOT routines initialized. This made the extension code overlap its destination address. The loader code detects this and uses "LDDR" to move the code from back to front. In this configuration, the system image file is only 7 records smaller, but I'll take it. It's as close to integration as I've ever come.

Almost there. ROM boots floppy boots HD boots CP/M. I took a detour to explore the possibility of using the Z80 DMAC for data transfer with the IDE disk. It would have to use "Burst mode" with "Forced RDY" since there are no signals besides the data and address busses and device select decoding connecting the IDE interface to the system. I could make it work for intermittent single-sector reads (never tried writes), but trying to use it to load the system from the reserved tracks failed as it would drop a byte along the way then get back in sync by the end of the sector. I modified my chain-loading floppy-resident boot sector to use DMA to load the HD boot sector, but I ultimately decided that it's not reliable enough. Perhaps in a more sophisicated implementation supporting more of the interface signals using the DMAC might become possible. The key issue is the lack of a byte-at-a-time signal from the IDE disk to indicate when it's ReaDY for a data transfer. That's what makes the DMAC work for the floppy disk subsystem.

On the system disk I got with the DSB-4/6 was the source for a ROM image, but not the ROM image the board actually executed. I'd started a disassembly of it nearly 30 years ago, but hadn't gotten very far. Curiously, among the things I got from the friend who gave me the DSB-4/6 system were printouts of the ROM source file, an assembler listing (.PRN file) and symbol table listing (.SYM file). None of these were on any of the disks I had related to the Davidge board. So, I resumed my commenting and analysis with a goal to faithfully re-create the source file--awkward formatting and comment tpyos(!) included. Having the printout showed certain instructions written but commented out as unnecessary--usually a JMP--because the code above simply "fell through" to the code below. I ultimately produced 2 versions--one faithful to the printout and one that represented the actual code in the ROM. The difference was only 2 bytes involved in the intialization of the first Z80 SIO/0 (used for console and serial printer). The code from the printout turned on the "AutoEnable" feature which kept the receiver and transmitter off until DCD (rcvr) and CTS (xmtr) were asserted. The actual ROM code did not turn this feature on.

The ROM code is in a 2716 EPROM, so only 2048 bytes and it was almost completely filled. (Apparently, the Rev C board has an option jumper to support a 4096-byte 2732 EPROM, but I have a Rev B board.) The ROM source I had was also intended to reside in a 2K EPROM yet it included support for booting from a SASI/SCSI disk. It was instructive to examine it to see how they managed to squeeze that support in. Mostly it was greatly-shortened messages and the other was converting the ROM Monitor functions from spaghetti-coded jumps/branches to calls and returns. Also, they made better use of one-time initialization, placing such code in areas that would potentially be over-written (for some reason they chose to load the floppy boot sector at 0080H--inside the ROM image [which is copied to RAM at the same address and the ROM switched off]). They stuffed a short SASI support subroutine and the DMAC initialization string for reading from the SASI disk in the remaining space between the start of ROM and the data areas used by the floppy disk code.

Rather than start with the newer source and replace the SASI support with IDE support, I took the long way around and started with the now-reconstituted source of the ROM the machine actually ran (the label covering the quartz window bore the inscription "D3115"). Shortening messages was the first, easiest thing to do. The second was to go even further to make sure the most one-time init code and data was moved to the area where the floppy boot sector might be loaded. Then I started grafting in code modifications from the other ROM source. That's when I realized what a hack job it was. The error exit path simply jumped to a routine that pointed HL at string to print "?" and then jumped back to before the beginning of the monitor which pushed its own address without adjusting the stack. This grated on me and it was a simple fix. Their parameter parsing required pointers to the byte _before_ the parameter storage. Converting an ASCII character to it's hex/binary value (if it was valid) was destructive and required compensation in the calling code. All of these were fairly straightforward to fix with minimal code size increase.

I'd have to fix those anyway, so typing them in myself made them easy to spot and correct, mostly. When I finally got a point where I was ready to program an EPROM with the new code, I had a new hurdle. I needed to get the files from the Davidge's disk to the machine that ran my EPROM programmer. I had, so far, been using one of my PC systems running NetBSD as the console and I could play silly tricks with 'cu' and PIP.COM to transfer ASCII files from Davidge to *NIX (usually for printing). I wasn't ready to trust that with "D3115IDE.HEX". I had long ago configured Ron Murray's 'ZMP' (terminal program w/Zmodem file transfer capability) to run on the DSB-4/6, even so far as to implement interrupt-driven receive with a 256-byte FIFO and RTS/CTS handshaking. But in the nearly 30 years since I last used it, I'd forgotten how I'd had it configured. Also, I needed at least a 6-wire cable to go between my DB-9/25 RJ11 adapters to support RTS/CTS. I had to dig around in my networking and telephone stuff to find my crimp tool and the 6P6C connectors and then go through my pile of de-commissioned ethernet patch cables (those rated less than Cat5e) and found one of suitable length to repurpose. I finally got everything figured out and in short order, I had the .HEX file on my file server. I probably could (should) have used NetBSD to transfer the file from the server to the PC-DOS partition of the EPROM burner station, but I chose instead to wade through OS/2--made more difficult because it decided it couldn't see the mouse anymore.

Then I had to dig around and find my stash of salvaged EPROMS. When I finally found them, I realized I had loads of 2764 through 27512 parts, but precious few 2716s and even fewer 2732s. The first 2716 I tried verified as erased, but failed programming, so it's dead. The second one programmed successfully! Getting at the ROM in the DSB-4/6 meant nearly completely disassembling the salvaged Leading Edge PC case I'd re-housed it in so long ago. I reassembled only enough to be able to power it back up...

...and IT WORKS!!! It takes a while for the floppy-disk boot code to give up before it tries the IDE disk, but I was soon greeted with the CBIOS signon and CP/M serial number, my HBIOS extension's signon and then watched NZCOM load from the hard disk (I had previously patched it into the CCP CIBUFF using the 'PATCH.COM' file/disk sector editor). The only annoying thing was that the floppy disk was still selected and the motor was running. I used DDT to whip up a short code snippet to de-select all floppy disks and indicate MOTOR OFF. So, that needed to go into the next iteration. I also needed to test the failure to boot from either source which should drop into the Monitor code. I unplugged the power from the IDE disk and only left the first floppy drive with a power connection. Again, it took a while but eventually it dropped to the Monitor. I tried using the P)ort command to turn off the floppy disk but it didn't work, also it errored out if I tried entering only a single digit for the new byte to write.

So the obvious thing was to add code to deselect all the floppies and set MOTOR OFF if it appeared that a valid boot sector had been successfully read from the IDE disk. The P)ort command not working was a missed edit on my part. One thing the newer ROM code got right is taking advantage of the ability of the register-indirect I/O to operate on _any_ register, so instead of "ld a,b ! out (c),a" it does "out (c),b" directly. The other problem was due to the destructive nature of the revised ASCHEX code and the calling code not being updated to match (and it was this way in the newer ROM source too, so I don't see how it would ever have worked). It was a simple fix and zero code increase as now calling code didn't have to compensate anymore. That led me to finally wrap my head around a couple of pieces of code that were essentially identical between the S)et and P)ort commands. Each command collects and converts up to two ASCII characters into a single byte value to store in memory or output to an I/O port. Once I re-organized the P)ort command to look more like the S)et command I could de-duplicate the code leaving lots of room for activities!

I wanted an option to drop to the Monitor or to skip the floppy boot attempt. So I implmemented a simple boot menu with a 5-second countdown. There's no external timing reference, so the loop values were determined empirically. As such, they're not exact but are close enough--it "feels like" 5 seconds--and yes, there is a countdown display. Satisfied that I'd fixed things (is running the Monitor under DDTZ "debugger-ception"?), I did the whole upload/copy/boot PC-DOS/burn/disassemble/install/reassemble dance--and flipped the power switch...

The sheer elation of watching the menu pop up is indescribable. It's one of those few times that I giggle! Even as I write this, I'm thinking of more optimisations and improvements.

GIDE Update: 10 July 2025

I finally got to the point of trying to attach multiple units to the GIDE. That's when I discovered that I'd been using possibly the worst drive for my development work. The Conner CP-342 does not work or play well with others--at least when set as primary (formerly known as "master"). It was so bad that some Western Digital IDE drives of the era have a special jumper setting just for the case where they are the secondary (formerly known as "slave") unit when a CP-342--mentioned specifically by model--is the primary.


For more information about GIDE in the USA, contact:

The Computer Journal

tcj@psyber.com


Return to Small Computer Systems
Return to top level

Copyright © 1995-2025 John D. Baker, jdbaker@NoSpAm!consolidated.net