An interesting question recently popped up: How exactly did IBM build the ROM BIOS for the IBM PC? Knowing what tools were used should make it possible to use the ROM listing published in the IBM PC Technical Reference and reproduce the ROM image.
Only one thing was clear—the PC BIOS wasn’t developed on a PC. With later IBM PC/AT and XT/286 ROMs, the situation is simple because the published listings identify IBM Macro Assembler 2.00 as the tool used. With the PC BIOS (and early AT BIOS), there’s no such identification.
The PC BIOS source code is remarkably straightforward. It is a single source file which does not use any macros. The one telltale marker is a $TITLE directive at the very beginning. No known version of MASM accepts this syntax… but at least one other assembler does.
What Tools Did IBM Use?
The following is informed speculation; so far no authoritative answer has been found in any available publication. It’s clear that the ROM BIOS would be about the first piece of software that needed to be written for the PC. If the release marker in the PC BIOS is to be believed (and there seems to be no reason to doubt it), the PC BIOS was completed on April 24, 1981. The development presumably must have started in 1980, with tools available at the time.
The obvious choice would have been Intel’s own development system which included the ASM86 assembler, together with a linker and locator. Microsoft probably did not offer an 8086 assembler at the time. It is unclear if Digital Research did. It is known that SCP used its own assembler for developing 86-DOS in the same timeframe. Note that any further mentions of ASM86 refer to the Intel product, not any of the other assemblers of the same name.
There are newer versions of ASM86 available which run on top of DOS. And perhaps not surprisingly, ASM86 accepts the $TITLE directive without complaint. Unfortunately, these ASM86 releases generate significantly different code, and also produce somewhat different listing format, so they cannot be used for re-creating the PC BIOS.
So what’s the oldest surviving version of ASM86? After some searching, ASM86 version 2.0 turned up on bitsavers… on an image of a disk intended for use with Intel’s ISIS-II.
ISIS-II
In the 1970s, Intel started offering various development systems which could be used to run assemblers and compilers producing code for Intel’s various microprocessors and microcontrollers. This was a good way to jump-start software development because Intel provided a complete, fully functioning and debugged development system at the same time as the chips. ISIS stood for Intel Systems Implementation Supervisor and it was the operating system utilized in the Intel development systems, Intellec MDS and Intellec Series 2.
ISIS-II ran on top of 8080, Intel’s famous 8-bit CPU. It was an operating system somewhat similar to CP/M in structure, but by no means compatible. It was, perhaps surprisingly, written not in 8080 assembly but in PL/M, a high-level programming language developed for Intel by Gary Kildall in 1972. ISIS itself was first written around 1976 and upgraded to ISIS-II for floppy-based systems; it appears that ISIS was developed at Intel after Gary Kildall left to start Digital Research and commercialize CP/M (something Intel was not interested in).
Amazingly enough, there’s an ISIS-II simulator which can be used to run 8-bit software designed for the 8080 on modern x86 systems. As it turns out, the ISIS-II was quite reasonably designed and the software running on it cleanly written. All I/O was file-based (using FCBs, not file handles!) and console access was TTY-like, which means the tools can be transplanted onto the command shell of a modern OS.
One curiosity of ISIS-II is that it used OMF (Object Module Format popularized by Microsoft’s DOS development tools) not only for object files but also for the executables loaded by ISIS-II into memory. It helps that at least some tools (e.g. the dmpobj utility shipped with the Open Watcom compilers) understand the overall file structure even without knowledge of the meaning of 8080-specific records. With such tools it’s easy to verify the integrity of the files.
Extracting the Files
Okay, so there’s a working simulator, but what about the ASM86 files? The simulator works with host OS files, not with ISIS-II disk images. So the ASM86 executables somehow need to be extracted before they can be used.
As luck would have it, the ISIS-II disk format is quite well documented for such an antique and relatively obscure system. The OS/2 Museum developed a simple utility to take a raw image of an ISIS-II disk and break it down into individual files.
It’s worth mentioning that the ISIS-II had no concept of time and the files on ISIS-II disks therefore have no timestamps (clearly Intel was not yet ready for the wonders of ‘make’!). That makes it a bit difficult to determine the age of the files. The copyright messages embedded in the files hint that the newer ASM86 V2.1 was released in 1980 and V2.0 in 1979.
Running 1979 Tools 35 Years Later
With the ISIS-II simulator, it is very easy to run ASM86 V2.0, more or less exactly 35 years after it had been released. Well, that’s after fixing the simulator to load ASM86 properly—one of the overlays includes an object record loading data at a low address, which the simulator rejected, loaded the module only halfway, and soon thereafter crashed.
Running ASM86 on the PC BIOS source code (kindly provided by Vernon Brooks), things look promising:
ISIS-II MCS-86 MACRO ASSEMBLER, V2.0 ASSEMBLY COMPLETE, NO ERRORS FOUND
Besides an object file, a listing file is produced and… it does not match. For one thing, the code at FFFF:0 is assembled as a near jump (because the source code declares the target as NEAR!). There’s also only a single relocation record marked in the listing while the Technical Reference shows dozens.
Examining the differences in detail, it is apparent that ASM86 V2.0 is considerably smarted than whatever IBM used. This version of ASM86 makes good use of the fact that the code segments are declared at absolute (SEGMENT AT xxxx) and does more or less all of the relocation math on its own. The assembler used by IBM on the other hand seems to have effectively ignored that information and presumably only passed it along as a hint to the linker.
In addition, ASM86 V2.0 considers the segments private (which is the default), therefore not combinable with other segments, and calculates offsets into those segments directly. Again the assembler used by IBM did not take that into account and behaved as if the segments were public (i.e. could be combined with others, therefore the assembler emitted relocation records rather than calculating offsets itself).
All in all, the old ASM86 V2.0 produces more or less the same results as the newer V3.x which runs on top of DOS. The only result the ISIS-II excursion had was proving that ASM86 V2.x is not what IBM used.
Confirmation and Further Search
While browsing through the October 1985 issue of PC Tech Journal, an interesting nugget of information popped up. In an article reviewing IBM’s MASM 2.0 and Microsoft’s MASM 3.01 (extremely similar assemblers, despite the versioning), Ted Mirecki compares their listing format with that used in the PC Technical Reference and off-handedly mentions that the latter had been “produced with Intel’s ASM86”. Perhaps this was common knowledge 30 years ago, now long forgotten?
At any rate, it is a confirmation that IBM did in fact use Intel’s ASM86 to produce the PC BIOS. The question remains which version it was. The current best guess is that it was ASM86 V1.0, but a search did not turn up either binaries or documentation.
Looking through the ISIS-II disks, there is evidence that (not too surprisingly) ASM86 V1.0 did exist, since it left its signature in one or two object files, for example PLM86.LIB on the disk containing ASM86 V2.0 (disk 9700030-03).
Even listing files produced by ASM86 V1.0 might shed some light on the mystery; one of the differences in the Technical Reference listings and those generated by ASM86 V2.x is the way uninitialized variables created using the DUP keyword are treated, such as the one in line 52 of the original PC BIOS listing. ASM86 V2.x produces multiple lines while the version used to assemble the PC BIOS only emitted a single line to the listing.
The question remains where to find Intel ASM86 older than V2.0, or if this piece of PC history is irretrievably lost. If ASM86 V1.x surfaces, the PC BIOS should be revisited.
Fascinating post 😀
I decided to try and find it on the web and here’s what I’ve found :
(from http://z80cpu.eu/archive) there are tons of very old software in both of these archives
CP/M 8086 ASSEMBLER VER 1.0:
\rlee_peters_cpm_archive\rlee\D\DIGITAL RESEARCH\CPM_86\W-BIOS\ASM86.CMD
The one in here is even smaller, maybe it’s an older version:
maslin_archive\AARDVARK_Tape_Backups\maslin_c_d_3oct95\ddrive\sydex\tmp
Also these links : (search for asm86)
http://z80cpu.eu/archive/79-data-articles/archive/86-files-posted-to-usenet-by-emmanuel-roche
http://www.s100computers.com/Software%20Folder/Assembler%20Collection/Assembler%20Collection.htm
This seems to be the source code of v1.0
https://www.yumpu.com/en/document/view/20944404/8086-8088-v10-forth-interest-group/11
As I mentioned in the article, there was more than one assembler called ASM86 (probably at least three or four, the name is just too obvious). The links you provided seem to all refer to Digital Research’s ASM86, which is not the product IBM used.
Anything that refers to ASM86 and CP/M is almost certainly not the right thing. As far as I know, Intel’s ASM86 was never available on CP/M, although there was an ISIS-II simulator that ran on top of CP/M.
I wrote another ISIS-II simulator: Thames. I haven’t tested it with ASM86; it was written to support ASM80 and PLM80.
Cool. Now we just need that old ASM86…
Have you tried tracking down any System/23 ROMs? The hardware influence on the IBM PC was readily acknowledged by IBM but no mention of whether any software was ported over to jumpstart the IBM PC.
What would be the relevance of getting the System/23 Datamaster ROMs ? It’s not like the source code for the PC BIOS isn’t published. Also the Datamaster used a 8085, 8″ floppy drives, a different video controller and different hardware from the PC so it’s safe to say no, the Datamaster firmware was not ported over to the PC.
The question of relevance is what assembler was used to build the original PC BIOS, based upon available evidence it was likely Intel ASM86 v1.0. Also it looks like the final revision of the PC BIOS and first revision of the XT BIOS were built with a later version of ASM86 (presumably v2.0).
I have not seen the Datamaster ROMs anywhere. If you know where to find them, I might have a look. It is conceivable that some concepts and techniques were reused, even if the hardware was quite different.
There are Displaywriter ROMs out there, and that system was 8086-based. I have not looked at those ROMs.
The oldest DOS version of ASM86 found so far is V2.1 which is here – http://www.retroarchive.org/dos/lang/PLM8086Tools.zip
This version of ASM86 produces an exact match for the third PC BIOS (10/27/82) and the first XT BIOS (11/08/82) and the listings match that in the Technical Reference manuals. Of course it does not produce a match for the original PC BIOS (04/24/81). Perhaps ASM86 V1.0 ran on the original ISIS, not ISIS-II.
One clue as to what was used, the IBM PC Technical Reference mentions this in its bibliography: “INTEL 8086/8087/8088 Macro ASSEMBLY Language Reference Manual for 8088/8085 Based Development System”
Just out of college, I started developing microprocessor code on an MDS-II running ISIS-II, then later on a Series-III (x86) development system. I still have original 8″ & 5.25″ floppies with these compilers, and until recently a working MDS-II that I rescued from the scrap heap. I do not remember any CP/M versions and I would know as I had a CP/M system at home at the time. Intel did release a utility to “DOS’ify” Series-III/x86 version such as PL/M-86, etc to run in DOS which worked very well.
Very cool! No ASM86 V1.x in there I suppose?
Just off the top of my head, but Intel supported 8086 development tools that ran under ISIS-II (8080-based) before it supported the development tools hosted on the Series III (8086-based). It is likely that the ASM86 V1.x was the initial version that was 8080 object code (or technically a “cross assembler”).
I will take a look in my “archives” after work to see what I may have in that respect. If that version exists it should run under an ISIS-II simulator.
At least some ASM86 V2.0 and V2.1 releases ran under ISIS-II as well. I have not personally seen the Series III versions but have no reason to doubt that they did exist. I know some of the later ASM86 versions ran even on DOS.
So far the earliest ISIS-II version of ASM86 I can find is 2.1. I’ll keep looking. But that DOES confirm what you say about a 2.1 that runs under ISIS-II.
I have later versions that run on the Series III and also DOS. Intel provided a utility that attached a UDI (Universal Development Interface) to any of their ISIS-III tools that allowed them to run in the DOS environment. So virtually anything that ran on the Series III in .86 mode can be made to run on DOS. Intel also released DOS versions directly, but I believe they were just the .86 versions with the UDI already attached.
The DOS version of ASM86 V2.1 has the message *Illegal UDI Call* and references a temp file named XXUDIA.TMP so it was very likely built with the UDI you mentioned. Do you have any additional info on the UDI ?
It would still be nice to find whatever version of ASM86 was used to build the original IBM PC BIOS. Does anyone happen to have contact info for David Bradley ? He is the guy who developed the original IBM PC BIOS so he would definitely know.
I know of a pharmaceutical company in San Diego running ISIS in the lab. They are looking for someone with experience analyzing and extending the life of the data run on ISIS. Does anyone know of an expert in ISIS who would be interested in taking a look?
Is it really the same sort of 1970s Intel ISIS system we’re talking about here?
Dosfan…are you saying that when you try to assemble the IBM XT BIOS, that is when you get that UDI error? I don’t really have much on the UDI, but I can try to assemble the BIOS on an 8085-based development system. But I guess you probably have already tried that with ISIS emulation, no? I don’t have the source file to try, but if you want me to try assembling it on real Intel development systems I can do that. Just let me know here. Thanks.
No, I said that the DOS version of ASM86 V2.1 has the message *Illegal UDI Call* in its executable. I’ve only assembled the BIOS on DOS (or an XP VDM).
My only question is what version of ASM86 was used to build the three revisions of the IBM PC BIOS and the first revision of the PC XT BIOS. I suppose that only one of the original PC BIOS developers could answer that question.
Dave, the source is available on dosfan’s site, https://sites.google.com/site/pcdosretro/ (in the ‘IBM PC BIOS source code reconstruction section). If you could try building any of the old PC BIOSes on an original Intel development system, that would be cool.
Having read through all of this, I cannot quite see here what the process is to re-create an IBM PC BIOS Image?
I’ve downloaded the source from here: https://sites.google.com/site/pcdosretro/
Also downloaded the mentioned ASM86 2.1 for DOS. With that I now have a .LST and .OBJ, but then what?
What link tool is used to create the final binary ROM image? and how?
Thanks!
I honestly don’t know. I think the exercise may have ended at the point of getting the source code compiled and the listings to match, since the BIOS images are relatively easy to come by 🙂 IBM never documented how they built the BIOS, there are only a few clues here and there in the listings.
Look at the text files included with the zip files. Using an old enough version of MASM you can build everything except the oldest BIOS code which used some version of Intel ASM86.
As for the PC BIOS and first revision of the XT BIOS, they were built using a version of ASM86 prior to 2.1 and was likely built on an ISIS-II system. ASM86 2.1 will not produce an exact match due to better assembly generation. Notes are in the included text files.
I have a working MDS-230 currently upgraded to a Series-III. Looking though my 8″ floppy disks. I found a copy of ASM86 V1.0. This particular version is for a Series-III as it has the .86 extension. I pulled a copy of the PC BIOS off the above mentioned site. In the next few days, I will give it a try and see if the listing matches. I also have the original IBM technical reference manual that I can compare it with.
That’s really cool. It would be great to be able to reconstruct the IBM PC BIOS perfectly.
Please remind me, what kind of OS does your MDS-230 run? Or rather what OS can execute your ASM86 V1.0?
The Series-II (MDS-230) is running ISIS-II V4.3. Note that this is a modified version by Winchester Systems Inc. to work with their Datasafe 8 hard disk. This is a pre-SCSI type system. (SASI) Which still is in working order.
Last year I was able to upgrade the system from an IPB to IPC. (8080 to 8085) Then adding an RPB (8086) to make it a Series-III. So now I am able to run the 8080 tools as well as the 8086 tools. The ASM86 V1.0 was on a floppy along with ICE software and the RUN environment for a Series-III (V1.0).
I too am a fan of OS/2. I even have a copy of MS-OS2 that was provided with an Intel OEM system.
One easy way to check if the generated listing matches is to look at the interrupt routine offsets, they should correspond to the known offsets (for example INT 10h @ F000:F065) – see here: https://sites.google.com/site/pcdosretro/ibmbioshist
It seems likely that the PC BIOS v1 and v2 were built with ASM86 v1.0 on ISIS-II since that was the development platform of the time and no other assembler I know of uses the $TITLE directive. It would be great to have confirmation of this though.
Well, the news is that ASM86.86 V1.0 is NOT the assembler we are looking for! It was an interesting exercise though. I never got a complete assembly on the MDS. Even though it was done on a hard drive. I could not free up enough space and was getting disk full errors. Also, it took about half an hour for each try. The problem appears to be with the source in that it did not like the end of line characters. Maybe getting that taken care of would have made it successful run. Note that this was running on a Series-III with a 5mhz 8086. It would be much longer on the IPC(8085) or worse yet the IPB(8080).
Noted in above posts, I took a look at the UDI info. I knew I had the UDI2DOS program for decades but never needed it in my work. I do have the docs for it which are in the release notes for the 86 utilities. I transferred ASM86.86 and converted it to an .exe in a dos box in Linux. I ran it from there and was able to create a listing. It generates an error because there is no module name in the source file. I also noted that “DB” directives listed each byte on a separate line. So that would indicate that this is not the one. BTW it took about a second to assemble the file on the Linux box in the DOS emulator.
I will keep looking and checking versions of ASM86. Most of what I have is V2.1.
Regards, Mark
Thanks for trying that out!
I’m fairly certain there was also ASM86 V1.1. It seems unlikely that IBM would be using some custom tool and not some existing ASM86 release.
It was an interesting exercise. I will keep looking as I have quite a few disks. I too would think there was a V1.1. I have never ran across any material stating what the development environment was for the IBM PC. The company I worked for somehow had the source for the BIOS as they re-targeted it to a different address. They actually pulled the BIOS chips out of the IBM PC’s and replaced it with a ROM with a single jump instruction to the new address. The BIOS was then placed on a card in the system along with their program. It would power up like normal but instead of jumping to basic, it would jump to the other program. This was done before my time started there so I do not know much more than that. I suspect they typed in the source from the listing in the IBM technical reference but do not know for sure.
I did get the code to assemble like I did on the Linux box. I had to transfer the source file over to the MDS in binary mode. That took care of the end of line issues. It again took at least 30 minutes to compile. I should try the 8080 version of ASM86 and see how long it takes. Probably much longer.
Regards, Mark
What end of line characters are expected on the MDS ? The reconstructed files use the standard CRLF characters. Also it is possible that a directive or two is needed which doesn’t appear in the listings so I wouldn’t know about them.
Did you make a ASM86 1.0 DOS executable ? If so then I would like to try that myself. I can run it under real DOS (I have PC DOS 7.0 on a partition). I still think that ASM86 1.0 or 1.1 is the correct assembler since the revision 3 PC BIOS and revision 1 XT BIOS definitely build with ASM86 2.1 (I tested with the DOS version) and results in an exact match so it stands to reason that an older version of ASM86 was used for the first two revisions of the PC BIOS.
I am not sure what the character was but when I transferred it with kermit, it did so by ascii and not binary mode. Later re sending it in binary mode fixed the issue. I suspect it may have stripped a character or something. It looked ok in aedit in both cases. I am sure this version is not correct as the “DB” directives list one byte per line instead of combining them like the original listing does. Also, this one prints at least a banner at the top of the listing.
I did make a PC-DOS version with the UDI2DOS. The runtime on the Series-III was at least half an hour. On my Linux PC in a DOS box, it took about a second. Michal has a copy of each. He may make it downloadable from his site. If not, I can send a copy.
I am fairly certain that this ASM86.86 V1.0 was intended for the Series-III and was the first for it. However, there are earlier versions of ASM86 for the Series-II. The versions do not match up because they are for different CPU’s/Platforms. It is very likely that a version 2 for the Series-II was out before version 1 for the Series-III. The Series-III is a native compiler where the Series-II compiler is a cross compiler. I too agree that there is most likely an ASM86 V1.0 & V1.1 out there somewhere. Note that Intel even had an assembler that existed in ROMs for the Series-II. That one may be obtainable. You may want to check out http://www.isis-mds.com. Richard has a very nice collection of info there including links to other sites.
I rechecked the PC BIOS listing in the PC Technical Reference manual and based on the header “LOC OBJ LINE SOURCE” it can be inferred that the listing lines match the source lines one-to-one so there probably aren’t any missing directives. I agree that the DB issue you mentioned means that particular version of ASM86 isn’t the right one. Whatever the DOS ASM86 v2.1 was based upon is the right one as that version correctly assembles the version 3 PC BIOS though there is a non-critical error (no name directive encountered, default module name used). As far as I can find, v2.1 from 1985 was the first version of ASM86 for DOS.
It is possible that the first two revisions of the PC BIOS were built with ASM86 v2.0 (or v1.1) on Series-III. At the moment we can only be sure that v2.1 is too new and based upon your tests that v1.0 is too old. I am curious though, despite the DB listing differences does the v1.0 generated code match ? That would at least be a clue that we’re on the right track.
I did not look further in the listing to see if everything else matched. I did not bother with the link86/loc86/oh86 steps.
Remember though that ASM86 V1.0 on a Series-II (8080/8085) is not the same as ASM86.86 V1.0 on a Series-III (8086). The time factor being the Series-II was out first and would have been in use before the Series-III was out. Since the source is PLM that might be the same but ill bet the PLM compiler between the two was different as one generates 8080/85 code and the other 8086.
I believe that ISIS-II was the first Disk based OS. ISIS-1 must have been in ROM’s or something. I am going to look in my data books and see what was offered. It might be a clue to what was used.
Regards, Mark
Were the Series-II and Series-III ASM86 derived from the same PL/M source code or were they different code branches ?
I would imagine that IBM used the Series-III to develop the PC BIOS. Of course only the original BIOS developers would know for sure.
It is really hard to say if they were from the same code base. They both appear to create 2 temporary files that will remain if you run out of disk space. Though the temp names are different.
One difficult thing is a Series-II and Series-III look identical. One would have to look on a tag in the back but it is a simple matter to upgrade a II to a III. I did it myself and Intel offered kits. So even though it may say it is a Series-II, it may be a Series-III. The only way to be sure is to look at the Multibus boards and see if one of them is a RPB(5Mhz) or RPC(8Mhz).
Once one was upgraded. You can and do use the software tools for both the processors. Any program that ends in .86 is for a Series-III and you must run the program RUN to execute them.
It could have been either system for development. Possibly on a network. In earlier posts, someone mentioned the IBM System/23. I have one of those. I think it has an 8085. So its development could have also been on an Intel MDS. I do not really know for sure. I do know that IBM had the clout at the time to suck up all the cpu’s to make it hard for anyone else. So IBM would have had a lot of pull on Intel in those days. I had an uncle that worked at Boca once and a while.
I think it would make an interesting book to read on the development process that was used there. Probably a lot has been lost already.
I did time the assembly of the bios with ASM86 V2.1 running on the IPC (8085). It took about 20 minutes. The ASM86.86 V1.0 took at least 30 minutes. Maybe it is doing more optimization? The 8086 in this system has 512K. The 8085 only has 64K. Normally, a Series-III would have either 128K (RPB) or 256K(RPC). Still, the assembler may do more since it has more space.
Regards, Mark
I came across an old PC Magazine ad from 1984 –
https://books.google.com/books?id=UCIvSU6Y2GAC&lpg=PA388&ots=DU4qqhu8kE&dq=intel%20asm86&pg=PA388#v=onepage&q=intel%20asm86&f=false
Notice that Intel ASM86 is described as “the assembler used by IBM to design the PC” – clearly this is referring to the BIOS so I guess it was common knowledge back then. Unfortunately there is no information to be found about the development of the original PC BIOS. There also isn’t a whole lot of information around about the Intel MDS/ISIS systems. They seem like interesting systems for their time.
Nice find. What’s interesting that as far as I know, Microsoft did not use ASM86 at all, they had their own (eventually turned into MASM). They also liked to use DECs and such for cross development, not Intel’s MDS/ISIS machines. MS’s tools were however pretty closely modeled on Intel’s, including their use of OMF.
I think there is little doubt that it was done on an Intel MDS system with their ASM86. Looking at the timeline for the PC development. I do not think the Series-III was available yet so most likely it was a Series-II or MDS-800. As one of the developers for the PC worked on the System/23 firmware which was an 8085. I suspect it too was probably developed with an Intel MDS system. And this guy was tapped to move to Boca to be on the development team.
I think we are looking for an ASM86 V1.x that runs on an 8080/8085. Anything newer like the 8086 tools were too developed (new) to be the one. Also since the V2.1 of ASM86 works for the later BIOS versions, it simply must have been an older version of ASM86 on the 8080/8085 system.
I tried the ASM86.86 v1.0 executable which Michal generated for DOS and it results in the same code output as the released ASM86 v2.1 for DOS so that definitely isn’t the correct version. Now the question is what version of ASM86 for the 8080/8085 was used to build the PC BIOS and what version was used to build the XT BIOS and revision 3 PC BIOS. Did they update the development hardware and software from Series-II to Series-III or just the Series-II software in the interim (about one year) between the original PC BIOS and the XT BIOS.
The ASM86.86 V1.0 I provided was most likely the first version for the Series-III or called an MDS-286. The Series-II, MDS 225 was the 8085 (IPC) Version and a little older than the Series-III. The Series-II, MDS-230 was older still with an 8080 (IPB). I think the oldest possible system is the MDS-800 (8080) and it can be upgraded to have 8″ floppies and a hard disk system. The 1982 Intel catalog indicates that they were offering the MDS-225 (Series-II) & MDS-256 (Series-III). It also states that an MDS-800 could be upgraded to a Series-III. So to muddy the waters, it could have been done on any of those machines.
I think the ASM86 V1.x we are looking for would have run on an 808/8085 CPU. It could have been as old as an MDS-800 and as late as a Series-III as it would run on any variant. To narrow down the possibilities, I would say any Series-III is out as the V1.0 Version of ASM86.86 appears to do the same as the V2.1 for MS-DOS. I am not sure of Intel’s policy when someone upgrades a system if they received later versions of the software tools. Looking at the floppy disks I have, it appears that updates (newer versions) were sent out.
Most likely to find ASM86 V1.x would be found on a MDS-800 or some early variant of the Series-II. I am still looking through my stuff but no luck so far.
Regards
FYI, I found out how to produce a HEX file from the 3rd XT BIOS source using ASM86, and some more intel tools:
1. compile with ASM86 XTBIOS.ASM
this produces a XTBIOS.LST and a XTBIOS.OBJ
2. link with LINK86 XTBIOS.OBJ
this produces a XTBIOS.MP1 and a XTBIOS.LNK
3. use the locater: LOC86 XTBIOS.OBJ
this produces a XTBIOS and a XTBIOS.MP2
4. use the OH86 converter: OH86 XTBIOS
this produces a XTBIOS.HEX
🙂
This is a usual format for ROM flashing utilities
And the jump to the reset vector has the correct address!
EA 5B E0 00 F0…
5. (optional) convert to an image
this creates an XTBIOS.IMG, with size of 1FFEh
And the jump is in the correct address.
I have ran it in a simulator, deactivating the internal checksum routine and it correctly starts up CGA and displays Error 101 😀
So it cannot be so wrong 😉
Kind regards
Andi
Very cool! Do you have a ROM dump from an IBM XT to compare against?