06818963db
Initially, with serdrive as HDD/FDD image server, only active when starting the PCXT core, never on other cores.
499 lines
12 KiB
C++
499 lines
12 KiB
C++
//======================================================================
|
|
//
|
|
// Project: XTIDE Universal BIOS, Serial Port Server
|
|
//
|
|
// File: image.cpp - Abstract base class for disk image support
|
|
//
|
|
|
|
//
|
|
// XTIDE Universal BIOS and Associated Tools
|
|
// Copyright (C) 2009-2010 by Tomi Tilli, 2011-2013 by XTIDE Universal BIOS Team.
|
|
//
|
|
// This program is free software; you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation; either version 2 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
// Visit http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
|
|
//
|
|
|
|
#include "Library.h"
|
|
#include <memory.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
|
|
unsigned int hdd_table[128][3] = {
|
|
{ 306, 4, 17 }, /* 0 - 7 */
|
|
{ 615, 2, 17 },
|
|
{ 306, 4, 26 },
|
|
{ 1024, 2, 17 },
|
|
{ 697, 3, 17 },
|
|
{ 306, 8, 17 },
|
|
{ 614, 4, 17 },
|
|
{ 615, 4, 17 },
|
|
|
|
{ 670, 4, 17 }, /* 8 - 15 */
|
|
{ 697, 4, 17 },
|
|
{ 987, 3, 17 },
|
|
{ 820, 4, 17 },
|
|
{ 670, 5, 17 },
|
|
{ 697, 5, 17 },
|
|
{ 733, 5, 17 },
|
|
{ 615, 6, 17 },
|
|
|
|
{ 462, 8, 17 }, /* 016-023 */
|
|
{ 306, 8, 26 },
|
|
{ 615, 4, 26 },
|
|
{ 1024, 4, 17 },
|
|
{ 855, 5, 17 },
|
|
{ 925, 5, 17 },
|
|
{ 932, 5, 17 },
|
|
{ 1024, 2, 40 },
|
|
|
|
{ 809, 6, 17 }, /* 024-031 */
|
|
{ 976, 5, 17 },
|
|
{ 977, 5, 17 },
|
|
{ 698, 7, 17 },
|
|
{ 699, 7, 17 },
|
|
{ 981, 5, 17 },
|
|
{ 615, 8, 17 },
|
|
{ 989, 5, 17 },
|
|
|
|
{ 820, 4, 26 }, /* 032-039 */
|
|
{ 1024, 5, 17 },
|
|
{ 733, 7, 17 },
|
|
{ 754, 7, 17 },
|
|
{ 733, 5, 26 },
|
|
{ 940, 6, 17 },
|
|
{ 615, 6, 26 },
|
|
{ 462, 8, 26 },
|
|
|
|
{ 830, 7, 17 }, /* 040-047 */
|
|
{ 855, 7, 17 },
|
|
{ 751, 8, 17 },
|
|
{ 1024, 4, 26 },
|
|
{ 918, 7, 17 },
|
|
{ 925, 7, 17 },
|
|
{ 855, 5, 26 },
|
|
{ 977, 7, 17 },
|
|
|
|
{ 987, 7, 17 }, /* 048-055 */
|
|
{ 1024, 7, 17 },
|
|
{ 823, 4, 38 },
|
|
{ 925, 8, 17 },
|
|
{ 809, 6, 26 },
|
|
{ 976, 5, 26 },
|
|
{ 977, 5, 26 },
|
|
{ 698, 7, 26 },
|
|
|
|
{ 699, 7, 26 }, /* 056-063 */
|
|
{ 940, 8, 17 },
|
|
{ 615, 8, 26 },
|
|
{ 1024, 5, 26 },
|
|
{ 733, 7, 26 },
|
|
{ 1024, 8, 17 },
|
|
{ 823, 10, 17 },
|
|
{ 754, 11, 17 },
|
|
|
|
{ 830, 10, 17 }, /* 064-071 */
|
|
{ 925, 9, 17 },
|
|
{ 1224, 7, 17 },
|
|
{ 940, 6, 26 },
|
|
{ 855, 7, 26 },
|
|
{ 751, 8, 26 },
|
|
{ 1024, 9, 17 },
|
|
{ 965, 10, 17 },
|
|
|
|
{ 969, 5, 34 }, /* 072-079 */
|
|
{ 980, 10, 17 },
|
|
{ 960, 5, 35 },
|
|
{ 918, 11, 17 },
|
|
{ 1024, 10, 17 },
|
|
{ 977, 7, 26 },
|
|
{ 1024, 7, 26 },
|
|
{ 1024, 11, 17 },
|
|
|
|
{ 940, 8, 26 }, /* 080-087 */
|
|
{ 776, 8, 33 },
|
|
{ 755, 16, 17 },
|
|
{ 1024, 12, 17 },
|
|
{ 1024, 8, 26 },
|
|
{ 823, 10, 26 },
|
|
{ 830, 10, 26 },
|
|
{ 925, 9, 26 },
|
|
|
|
{ 960, 9, 26 }, /* 088-095 */
|
|
{ 1024, 13, 17 },
|
|
{ 1224, 11, 17 },
|
|
{ 900, 15, 17 },
|
|
{ 969, 7, 34 },
|
|
{ 917, 15, 17 },
|
|
{ 918, 15, 17 },
|
|
{ 1524, 4, 39 },
|
|
|
|
{ 1024, 9, 26 }, /* 096-103 */
|
|
{ 1024, 14, 17 },
|
|
{ 965, 10, 26 },
|
|
{ 980, 10, 26 },
|
|
{ 1020, 15, 17 },
|
|
{ 1023, 15, 17 },
|
|
{ 1024, 15, 17 },
|
|
{ 1024, 16, 17 },
|
|
|
|
{ 1224, 15, 17 }, /* 104-111 */
|
|
{ 755, 16, 26 },
|
|
{ 903, 8, 46 },
|
|
{ 984, 10, 34 },
|
|
{ 900, 15, 26 },
|
|
{ 917, 15, 26 },
|
|
{ 1023, 15, 26 },
|
|
{ 684, 16, 38 },
|
|
|
|
{ 1930, 4, 62 }, /* 112-119 */
|
|
{ 967, 16, 31 },
|
|
{ 1013, 10, 63 },
|
|
{ 1218, 15, 36 },
|
|
{ 654, 16, 63 },
|
|
{ 659, 16, 63 },
|
|
{ 702, 16, 63 },
|
|
{ 1002, 13, 63 },
|
|
|
|
{ 854, 16, 63 }, /* 119-127 */
|
|
{ 987, 16, 63 },
|
|
{ 995, 16, 63 },
|
|
{ 1024, 16, 63 },
|
|
{ 1036, 16, 63 },
|
|
{ 1120, 16, 59 },
|
|
{ 1054, 16, 63 },
|
|
{ 0, 0, 0 }
|
|
};
|
|
|
|
struct floppyInfo floppyInfos[] =
|
|
{
|
|
{ 1, 2949120 / 512, 6, 80, 2, 36 }, // 2.88MB 3.5"
|
|
{ 0, 2867200 / 512, 6, 80, 2, 36 }, // 2.88MB 3.5" (alternate spelling with 2.8)
|
|
{ 0, 2969600 / 512, 6, 80, 2, 36 }, // 2.88MB 3.5" (alternate spelling with 2.9)
|
|
{ 1, 1474560 / 512, 4, 80, 2, 18 }, // 1.44MB 3.5"
|
|
{ 0, 1433600 / 512, 4, 80, 2, 18 }, // 1.44MB 3.5" (alternate spelling with 1.4)
|
|
{ 1, 1228800 / 512, 2, 80, 2, 15 }, // 1.2MB 5.25"
|
|
{ 1, 737280 / 512, 3, 80, 1, 18 }, // 720KB 3.5"
|
|
{ 1, 368640 / 512, 1, 40, 2, 9 }, // 360KB 5.25"
|
|
{ 1, 327680 / 512, 0, 40, 2, 8 }, // 320KB 5.25"
|
|
{ 1, 184320 / 512, 0, 40, 1, 9 }, // 180KB 5.25" single sided
|
|
{ 1, 163840 / 512, 0, 40, 1, 8 }, // 160KB 5.25" single sided
|
|
{ 0, 0, 0, 0, 0, 0 }
|
|
};
|
|
|
|
struct hddInfo hddInfos[] = { { 0, 0, 0, 0 } };
|
|
|
|
struct floppyInfo *FindFloppyInfoBySize( double size )
|
|
{
|
|
struct floppyInfo *fi;
|
|
|
|
for( fi = floppyInfos; fi->size != 0 && !(size+5 > fi->size && size-5 < fi->size); fi++ ) ;
|
|
|
|
if( fi->size == 0 )
|
|
fi = NULL;
|
|
|
|
return( fi );
|
|
}
|
|
|
|
struct hddInfo* FindHDDInfoBySize(unsigned long size)
|
|
{
|
|
struct hddInfo* fi;
|
|
unsigned long size_chs;
|
|
bool is_chs = false;
|
|
|
|
|
|
for (int i = 0; i < 127; i++) {
|
|
size_chs = ((unsigned long)hdd_table[i][0]) * (unsigned long)hdd_table[i][1] * (unsigned long)hdd_table[i][2] * 512;
|
|
if (size == size_chs)
|
|
{
|
|
fi = hddInfos;
|
|
fi->size = size;
|
|
fi->cylinders = hdd_table[i][0];
|
|
fi->heads = hdd_table[i][1];
|
|
fi->sectors = hdd_table[i][2];
|
|
is_chs = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!is_chs)
|
|
fi = NULL;
|
|
|
|
return(fi);
|
|
}
|
|
|
|
void flipEndian( unsigned short *buff, unsigned int len )
|
|
{
|
|
for( unsigned int t = 0; t < len/2; t++ )
|
|
buff[t] = (buff[t] & 0xff) << 8 | (buff[t] & 0xff00) >> 8;
|
|
}
|
|
|
|
Image::Image( const char *, int, int, int, unsigned long, unsigned long, unsigned long, int)
|
|
{
|
|
}
|
|
|
|
|
|
void Image::init( const char *name, int p_readOnly, int p_drive, unsigned long p_cyl, unsigned long p_head, unsigned long p_sect, int p_useCHS )
|
|
{
|
|
double sizef;
|
|
char sizeChar;
|
|
struct floppyInfo *f;
|
|
|
|
for( const char *c = shortFileName = name; *c; c++ )
|
|
if( *c == '\\' || *c == '/' || *c == ':' )
|
|
shortFileName = c+1;
|
|
|
|
if( *(shortFileName) == 0 )
|
|
{
|
|
log( 1, "Can't parse '%s' for short file name\n\n", name );
|
|
shortFileName = "SerDrive";
|
|
}
|
|
|
|
readOnly = p_readOnly;
|
|
drive = p_drive;
|
|
|
|
if( totallba > 0xfffffff ) // lba28 limit - 28 bits
|
|
log( -1, "'%s', Image size larger than LBA28 maximum of 137,438,952,960 bytes, %lu", name, totallba );
|
|
|
|
if( totallba == 0 )
|
|
log( -1, "'%s', Image size zero?" );
|
|
|
|
floppy = 0;
|
|
for( f = floppyInfos; f->size && !(f->size == totallba && f->real); f++ ) ;
|
|
if( f->size )
|
|
{
|
|
floppy = 1;
|
|
floppyType = f->type;
|
|
p_useCHS = 1;
|
|
p_cyl = f->cylinders;
|
|
p_head = f->heads;
|
|
p_sect = f->sectors;
|
|
totallba = p_cyl * p_head * p_sect;
|
|
}
|
|
|
|
if( p_cyl )
|
|
{
|
|
if( (p_sect > 255 || p_sect < 1) || (p_head > 16 || p_head < 1) || (p_cyl > 65536 || p_cyl < 1) )
|
|
log( -1, "'%s', parts of the CHS geometry (%lu:%lu:%lu) are out of the range (1-65536:1-16:1-255)", name, p_cyl, p_head, p_sect );
|
|
else if( totallba != (p_sect * p_head * p_cyl) )
|
|
log( -1, "'%s', file size does not match geometry", name );
|
|
sect = p_sect;
|
|
head = p_head;
|
|
cyl = p_cyl;
|
|
}
|
|
else
|
|
{
|
|
if( totallba > 65536*16*63 )
|
|
{
|
|
log( 0, "'%s': Warning: Image size is greater than derived standard CHS maximum, limiting CHS to 65535:16:63, consider using -g to specify geometry", name );
|
|
cyl = 65536;
|
|
head = 16;
|
|
sect = 63;
|
|
}
|
|
else if( (totallba % 16) != 0 || ((totallba/16) % 63) != 0 )
|
|
{
|
|
log( -1, "'%s', file size does not match standard CHS geometry (x:16:63), please specify geometry explicitly with -g", name );
|
|
}
|
|
else
|
|
{
|
|
sect = 63;
|
|
head = 16;
|
|
cyl = (totallba / sect / head);
|
|
if( cyl > 65536 )
|
|
{
|
|
log( -1, "'%s', derived standard CHS geometry of %lu:16:63 is has more cylinders than 65536, please specify geometry explicitly with -g", name, cyl, head, sect );
|
|
}
|
|
}
|
|
}
|
|
|
|
useCHS = p_useCHS;
|
|
|
|
sizef = totallba/2048.0;
|
|
sizeChar = 'M';
|
|
if( sizef < 1 )
|
|
{
|
|
sizef *= 1024;
|
|
sizeChar = 'K';
|
|
}
|
|
if( useCHS )
|
|
log( 0, "%s: %s with CHS geometry %u:%u:%u, size %.2lf %cB",
|
|
name, (floppy ? "Floppy Disk" : "Hard Disk"), cyl, head, sect, sizef, sizeChar );
|
|
else
|
|
log( 0, "%s: %s with %lu LBA sectors, size %.2lf %cB (CHS geometry %u:%u:%u)",
|
|
name, (floppy ? "Floppy Disk" : "Hard Disk"), totallba, sizef, sizeChar, cyl, head, sect );
|
|
}
|
|
|
|
int Image::parseGeometry( char *str, unsigned long *p_cyl, unsigned long *p_head, unsigned long *p_sect )
|
|
{
|
|
char *c, *s, *h;
|
|
unsigned long cyl, sect, head;
|
|
|
|
c = str;
|
|
for( h = c; *h && *h != ':' && *h != 'x' && *h != 'X'; h++ ) ;
|
|
if( !*h )
|
|
return( 0 );
|
|
|
|
*h = '\0';
|
|
h++;
|
|
for( s = h+1; *s && *s != ':' && *s != 'x' && *s != 'X'; s++ ) ;
|
|
if( !*s )
|
|
return( 0 );
|
|
|
|
*s = '\0';
|
|
s++;
|
|
|
|
cyl = atol(c);
|
|
head = atol(h);
|
|
sect = atol(s);
|
|
|
|
if( cyl == 0 || sect == 0 || head == 0 )
|
|
return( 0 );
|
|
|
|
*p_cyl = cyl;
|
|
*p_head = head;
|
|
*p_sect = sect;
|
|
|
|
return( 1 );
|
|
}
|
|
|
|
#define ATA_wGenCfg 0
|
|
#define ATA_wCylCnt 1
|
|
#define ATA_wHeadCnt 3
|
|
#define ATA_wBpTrck 4
|
|
#define ATA_wBpSect 5
|
|
#define ATA_wSPT 6
|
|
|
|
#define ATA_strSerial 10
|
|
#define ATA_strSerial_Length 20
|
|
|
|
#define ATA_strFirmware 23
|
|
#define ATA_strFirmware_Length 8
|
|
|
|
#define ATA_strModel 27
|
|
#define ATA_strModel_Length 40 // Maximum allowable length of the string according to the ATA spec
|
|
#define XTIDEBIOS_strModel_Length 30 // Maximum length copied out of the ATA information by the BIOS
|
|
|
|
#define ATA_wCaps 49
|
|
#define ATA_wCurCyls 54
|
|
#define ATA_wCurHeads 55
|
|
#define ATA_wCurSPT 56
|
|
#define ATA_dwCurSCnt 57
|
|
#define ATA_dwLBACnt 60
|
|
|
|
// Words carved out of the vendor specific area for our use
|
|
//
|
|
#define ATA_wSerialServerVersion 157
|
|
#define ATA_wSerialDriveFlags 158
|
|
#define ATA_wSerialPortAndBaud 159
|
|
|
|
// Defines used in the words above
|
|
//
|
|
#define ATA_wCaps_LBA 0x200
|
|
|
|
#define ATA_wGenCfg_FIXED 0x40
|
|
|
|
// These are all shifted by 1 bit to the right, so that SerialDPT_Finalize can shift them into proper position
|
|
// and shift the high order bit into the carry flag to indicate a floppy drive is present.
|
|
//
|
|
#define ATA_wSerialDriveFlags_Floppy 0x88
|
|
#define ATA_wSerialDriveFlags_Present 0x02
|
|
#define ATA_wSerialDriveFlags_FloppyType_FieldPosition 4
|
|
|
|
struct comPorts {
|
|
unsigned long port;
|
|
unsigned char com;
|
|
};
|
|
struct comPorts supportedComPorts[] =
|
|
{
|
|
{ 0x3f8, '1' },
|
|
{ 0x2f8, '2' },
|
|
{ 0x3e8, '3' },
|
|
{ 0x2e8, '4' },
|
|
{ 0x2f0, '5' },
|
|
{ 0x3e0, '6' },
|
|
{ 0x2e0, '7' },
|
|
{ 0x260, '8' },
|
|
{ 0x368, '9' },
|
|
{ 0x268, 'A' },
|
|
{ 0x360, 'B' },
|
|
{ 0x270, 'C' },
|
|
{ 0, 0 }
|
|
};
|
|
|
|
void Image::respondInquire( unsigned short *buff, unsigned short originalPortAndBaud, struct baudRate *baudRate, unsigned short port, unsigned char scan )
|
|
{
|
|
char formatBuff[ 128 ];
|
|
char speedBuff[XTIDEBIOS_strModel_Length];
|
|
|
|
memset( &buff[0], 0, 514 );
|
|
|
|
if( scan )
|
|
{
|
|
unsigned short comPort = 0;
|
|
struct comPorts *cp;
|
|
|
|
if( port )
|
|
{
|
|
for( cp = supportedComPorts; cp->port && cp->port != port; cp++ ) ;
|
|
if( cp->port )
|
|
comPort = cp->com;
|
|
}
|
|
|
|
if( comPort )
|
|
sprintf( speedBuff, " (COM%c/%s)", comPort, baudRate->display );
|
|
else
|
|
sprintf( speedBuff, " %s (%s baud)", shortFileName, baudRate->display );
|
|
|
|
sprintf( formatBuff, "%.*s%s ", XTIDEBIOS_strModel_Length - strlen(speedBuff), shortFileName, speedBuff );
|
|
}
|
|
else
|
|
sprintf( formatBuff, "%.*s ", XTIDEBIOS_strModel_Length, shortFileName );
|
|
strncpy( (char *) &buff[ATA_strModel], formatBuff, ATA_strModel_Length );
|
|
flipEndian( &buff[ATA_strModel], ATA_strModel_Length );
|
|
|
|
strncpy( (char *) &buff[ATA_strSerial], "SerialDrive ", ATA_strSerial_Length );
|
|
flipEndian( &buff[ATA_strSerial], ATA_strSerial_Length );
|
|
|
|
sprintf( formatBuff, "%d.%d ", SERIAL_SERVER_MAJORVERSION, SERIAL_SERVER_MINORVERSION );
|
|
strncpy( (char *) &buff[ATA_strFirmware], formatBuff, ATA_strFirmware_Length );
|
|
flipEndian( &buff[ATA_strFirmware], ATA_strFirmware_Length );
|
|
|
|
buff[ ATA_wCylCnt ] = cyl;
|
|
buff[ ATA_wHeadCnt ] = head;
|
|
buff[ ATA_wSPT ] = sect;
|
|
|
|
if( !useCHS )
|
|
{
|
|
buff[ ATA_wCaps ] = ATA_wCaps_LBA;
|
|
buff[ ATA_dwLBACnt ] = (unsigned short) (totallba & 0xffff);
|
|
buff[ ATA_dwLBACnt+1 ] = (unsigned short) (totallba >> 16);
|
|
}
|
|
|
|
// We echo back the port and baud that we were called on from the client,
|
|
// the client then uses this value to finalize the DPT.
|
|
//
|
|
buff[ ATA_wSerialPortAndBaud ] = originalPortAndBaud;
|
|
|
|
// In case the client requires a specific server version...
|
|
//
|
|
buff[ ATA_wSerialServerVersion ] = (SERIAL_SERVER_MAJORVERSION << 8) | SERIAL_SERVER_MINORVERSION;
|
|
|
|
buff[ ATA_wSerialDriveFlags ] = ATA_wSerialDriveFlags_Present;
|
|
if( floppy )
|
|
buff[ ATA_wSerialDriveFlags ] |=
|
|
ATA_wSerialDriveFlags_Floppy | (floppyType << ATA_wSerialDriveFlags_FloppyType_FieldPosition);
|
|
|
|
// we always set this, so that the bulk of the BIOS will consider this disk as a hard disk
|
|
//
|
|
buff[ ATA_wGenCfg ] = ATA_wGenCfg_FIXED;
|
|
}
|
|
|