Disabling Quick Edit Mode

Posted on December 18, 2020 by Michal Necasek

Last week I decided to finally solve a minor annoyance that’s been pestering me since I switched my main development machine from Windows 7 to Windows 10 over a year ago. As it is with these things, a certain threshold of pain needs to be reached before delving into the unknown, because one never knows how many rabbit holes it will lead to.

The problem: Every now and then, I use the Open Watcom tools, often for cross-development to DOS or OS/2. When I do that, I tend to use the console-based tools, including the vi editor and wd debugger, in part because they work the same across platforms. Both tools can work with a mouse, and especially the debugger is just much productive when used with a mouse. On Windows 7, that works fine. Not so much on Windows 10, because instead of sending mouse events to the application, Windows tries to select text in the console window. Not helpful:

Quick Edit Mode makes the mouse unusable for a console application

Anyone who has fought with this problem probably knows the answer: Quick Edit Mode. When Quick Edit is enabled, mouse selects text from the console window, Enter copies, right-click pastes. Great for a shell, much less so in a mouse-driven text mode UI. On Windows 10, Quick Edit mode is on by default, and that is what caused me grief.

Continue reading →
Posted in NT, Undocumented, Watcom | 22 Comments

The Answer To 0x49: Fujitsu FMR

Posted on December 11, 2020 by Michal Necasek

This is a guest post by A. N. Other.

The following was originally intended as a comment to “Not MSX Either“, the 4th installment in the hunt for the mysterious 0x69 FAT VBR-start byte which was allowed in DOS. Due to the length and content I was asked to turn it into a guest-post, presented below.

Definitive answer to 0x49, leading to new speculations about 0x69.

First let me thank Octocontrabass for the golden tip that got things rolling!
Also bleuge for your marvelous effort (I’m very curious to some info about [46; 2E; 262]…).

I got into this matter as my fuzzy tester uncovered 0x49. Further testing did indeed show that MS was checking for 0x49 for >25 years and that it indeed still does so for Win10, instead of 0x69 as stated on Wikipedia (and corresponding talk page, in fact there is currently no mention of the reality of 0x49).

It is this 0x49 that, for practical reasons, interested me the most. And who knows, it might give some insight into the 0x69 (and I will end with some new theories about this based on the facts regarding to 0x49).

Continue reading →
Posted in DOS, NT, PC hardware, PC history, Undocumented | 7 Comments

Every Bit Matters

Posted on December 4, 2020 by Michal Necasek

A couple of months ago the OS/2 Museum got hold of a 13.6 GB Fujitsu MPE3136AT IDE drive from 1999. The drive was working… more or less. It behaved quite strangely; the drive was detected and readable, but seemed oddly slow. It should have been capable of Ultra DMA transfers but delivered data at just under 2 MB/sec.

Fujitsu MPE3136AT IDE drive

Looking through Linux dmesg output, it was apparent that the system was trying to communicate with the drive at Ultra DMA speeds, but kept falling back to slower PIO speeds due to CRC errors. Oddly, the drive vendor was also shown as FUBITSU, rather than FUJITSU as one would expect.

And looking at the data the drive returned, it was clear that it was somehow corrupted. For example messages in the boot sector clearly had some letters wrong, but only some.

What could possibly cause such a problem?

Continue reading →
Posted in Fixes, PC hardware, Storage | 6 Comments

Decoding Seagate Date Codes

Posted on November 27, 2020 by Michal Necasek

More or less everyone knows that throughout the 1990s and 2000s, Seagate did not label their drives with a date of manufacture like everyone sane would do, but instead used a custom and somewhat mysterious/confusing “date code”. For reasons that I’m sure made sense to Seagate, but definitely made no sense to Seagate’s customers, the date code refers to Seagate’s fiscal year rather than a calendar year.

The good news is that Seagate no longer uses the cryptic date codes and prints a full date of manufacture on their drive labels, just like everyone else. The bad news is that there are countless millions of Seagate drives made before 2016 or so out there, and most of those drives only have the hard to decipher date code.

When was this Seagate drive made? It’s a mystery…

The four- or five-digit date code consists of a two-digit year, one- or two-digit week number (starting with 1), and one-digit day of the week (again starting with 1). If the week number is less than 10, the leading zero may be left out; that seems to have been the case on older drives, but later Seagate apparently switched to consistent five-digit codes.

Now, there are several online Seagate date conversion tools. So far, I have not found one that actually works properly. That is, they produce a date which is close but very often off by several days or even a week. While the few days probably don’t really matter in the end, I find it unnerving and sloppy, especially because it’s obvious that one can do better than that.

Continue reading →
Posted in PC history, Seagate, Storage | Leave a comment

Percussive Maintenance

Posted on November 25, 2020 by Michal Necasek

A couple of weeks ago this antique 1997 Cheetah 9 drive showed up at the OS/2 Museum:

A fat Cheetah

It was effectively a freebie, a faulty drive bought together with another, more desirable, and working drive. (Well, initially working, but that’s a whole different story.) Now, the model ST19101W Cheetah is historically an interesting drive, since it’s the first generation Cheetah, and those Cheetahs were the first 10,000 RPM drives ever. There were two models, Cheetah 4LP (1″ high) and Cheetah 9 (1.6″ high), with 4 and 9 GB capacities, respectively. When the Cheetah first became available, it was “unquestionably the fastest hard drive ever made” according to Red Hill.

This particular Cheetah 9 was quite sick and would not spin up. It was clearly trying to spin but failing, resulting in an endless cycle of attempted spin-up, beep, attempted spin-up, beep, and so on. The beeping was most likely resonance from the voice coil actuator, since the drive has no built in beeper.

Continue reading →
Posted in Hardware Hacks, Seagate | 7 Comments

Those Lot Numbers are Old

Posted on October 24, 2020 by Michal Necasek

The other day I was trying to decode the “lot numbers” printed on certain Seagate drives. In the meantime, I realized that those lot numbers have been in use for quite some time. They were in use around 2000, like on this Cheetah 73 made in 2001:

Seagate Cheetah label (2001)

They can be found on Seagate’s drives going back into the early 1990s, but always only on some of them—typically on higher-end enterprise drives, almost exclusively using SCSI/FC/SAS interfaces. One older example is this 1994 DEC-branded RZ25-E drive, which is definitely a Seagate-made drive and almost certainly a model ST1480N:

Digital RZ25-E (Seagate ST1480N) label

As it turns out, those lot numbers aren’t a Seagate invention. It’s something that Seagate adopted when it acquired (1989) the drive maker Imprimis, a subsidiary of CDC (Control Data Corporation).

Continue reading →
Posted in PC history, Seagate | 11 Comments

Not MSX, Either

Posted on October 7, 2020 by Michal Necasek

Further examining the mystery of boot sectors supposedly starting with byte value 69h, I considered the possibility that the check could have been added for MSX machines. The MSX platform ticks a lot of boxes: It wasn’t 8086 (but rather Z80), used 3.5″ floppies, used FAT format, appeared around 1985, and Microsoft was involved in it.

But looking closer, MSX is quite unlikely for one simple reason: Microsoft was clearly concerned about data exchange with PCs, and solved the problem differently. MSX floppy boot sectors actually start with the usual 8086 instructions, and if they’re booted on an MSX machine, the boot sector starts execution at offset 1Eh.

Not only that, but the MSX BIOS in fact requires that the floppy boot sector must start with byte EBh or E9h to be considered bootable at all.

The above is clearly documented in the MSX Technical Data Book (published by Sony in 1984). Extant MSX floppy images confirm the documentation—MSX floppies use 8086 opcodes in the first three bytes.

But wait, there’s more…

Continue reading →
Posted in IBM, Microsoft, PC history | 15 Comments

Return to Stormville

Posted on September 29, 2020 by Michal Necasek

A while ago I griped about a strangely ill-behaved Intel DX79SR Stormville board. To recap, the board simply refused to take any memory in the 4th memory channel. Since then, there have been very interesting new development in the story.

I found another complaint about these boards that exactly matches my symptoms. I missed it at first because it doesn’t mention the DX79SR board (it’s about DX79SI/TO). To recap, in 2011, Intel came out with two boards based on the X79 chipset, DX79SI (Siler) and a slightly stripped down and cheaper DX79TO (Toler). In 2012, the DX79SI was replaced by DX79SR with more USB 3.0 ports and more 6Gbps SATA ports. The three boards all use the same PCB, same BIOS, and are for most intents and purposes identical. It is therefore unsurprising that they’d also have the same problems.

Worth noting is that near the end of the discussion, a user claimed to have fixed just such problem by straightening a bent pin in the CPU socket. Since the memory controller is on the CPU, that is not implausible, although I could not find any sign of a bent pin on my Stormville board.

Continue reading →
Posted in Bugs, Intel, PC hardware | 3 Comments

Really Atari ST?

Posted on September 21, 2020 by Michal Necasek

This blog has previously examined a very very strange code fragment in the BIOS module of DOS. To recap, when deciding whether a boot sector might have a valid BPB, DOS checks whether the first byte is a relative jump (opcode E9h) or a short jump (opcode EBh), both used by different DOS versions. But it also checks for a “direct jump” with 69h opcode.

The code looks like this in the MS-DOS 3.21 OAK, source file dated May 1, 1987:

         cmp    byte ptr cs:[DiskSector],069H   ; Is it a direct jump?
         je     Check_Signature                 ; don't need to find a NOP
         cmp    byte ptr cs:[DiskSector],0E9H   ; DOS 2.0 jump?
         je     Check_Signature                 ; no need for NOP
         cmp    byte ptr cs:[DiskSector],0EBH   ; How about a short jump.
         jne    BadDisk
         cmp    byte ptr cs:[DiskSector]+2,090H ; Is next one a NOP?
         jne    BadDisk

The code is not materially different in the MS-DOS 3.3 OAK, source file dated July 24, 1987:

         cmp    byte ptr cs:[DiskSector],069H   ; Is it a direct jump?
         JE     Check_bpb_MediaByte             ; DON'T NEED TO FIND A NOP
         cmp    byte ptr cs:[DiskSector],0E9H   ; DOS 2.0 jump?
         JE     Check_bpb_MediaByte             ; NO NEED FOR NOP
         cmp    byte ptr cs:[DiskSector],0EBH   ; How about a short jump.
         JNE    INVALIDBOOTSEC
         cmp    byte ptr cs:[DiskSector]+2,090H ; Is next one a NOP?
         JNE    INVALIDBOOTSEC

The labels are different but the logic is identical. But of course there is no such “direct jump” on x86, and the 69h opcode (undocumented on 8086, IMUL on later CPUs) makes no sense whatsoever. So what is it?

Continue reading →
Posted in DOS, Microsoft, PC history | 18 Comments

Seagate Serial Talk

Posted on August 5, 2020 by Michal Necasek

Some time ago, the OS/2 Museum obtained a 10 GB Seagate ST310014ACE hard disk (IDE 3.5″ low profile). The disk was unusable because it was locked. That is, it needed an unknown password to gain access to the medium.

Seagate ST310014ACE drive

After a few quick searches it turned out that this problem is surprisingly common. The particular model of hard disk was used in the first generation Xbox consoles and indeed it was locked there, which meant that after taking it out of the Xbox the disk was no longer usable.

Except there is a way to unlock these drives, using a serial terminal, a special adapter, and a couple of magic commands. How does that work?

Continue reading →
Posted in Hardware Hacks, PC hardware, Seagate | 22 Comments