* FreeLoader
*
* Copyright (C) 2003, 2004 Eric Kohl
+ * Copyright (C) 2009 Hervé Poussineau
*
* 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
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <freeldr.h>
InstData = (PCM_PNP_BIOS_INSTALLATION_CHECK)PnpBiosSupported();
if (InstData == NULL || strncmp((CHAR*)InstData->Signature, "$PnP", 4))
{
- DbgPrint((DPRINT_HWDETECT, "PnP-BIOS not supported\n"));
+ DPRINTM(DPRINT_HWDETECT, "PnP-BIOS not supported\n");
return;
}
- DbgPrint((DPRINT_HWDETECT, "Signature '%c%c%c%c'\n",
+ DPRINTM(DPRINT_HWDETECT, "Signature '%c%c%c%c'\n",
InstData->Signature[0], InstData->Signature[1],
- InstData->Signature[2], InstData->Signature[3]));
+ InstData->Signature[2], InstData->Signature[3]);
x = PnpBiosGetDeviceNodeCount(&NodeSize, &NodeCount);
// e.g. look: http://my.execpc.com/~geezer/osd/pnp/pnp16.c
if (x != 0 || NodeSize == 0 || NodeCount == 0)
{
- DbgPrint((DPRINT_HWDETECT, "PnP-BIOS failed to enumerate device nodes\n"));
+ DPRINTM(DPRINT_HWDETECT, "PnP-BIOS failed to enumerate device nodes\n");
return;
}
- DbgPrint((DPRINT_HWDETECT, "PnP-BIOS supported\n"));
- DbgPrint((DPRINT_HWDETECT, "MaxNodeSize %u NodeCount %u\n", NodeSize, NodeCount));
- DbgPrint((DPRINT_HWDETECT, "Estimated buffer size %u\n", NodeSize * NodeCount));
-
- /* Create component key */
- FldrCreateComponentKey(SystemKey,
- L"MultifunctionAdapter",
- *BusNumber,
- AdapterClass,
- MultiFunctionAdapter,
- &BusKey);
- (*BusNumber)++;
-
- /* Set the component information */
- FldrSetComponentInformation(BusKey,
- 0x0,
- 0x0,
- 0xFFFFFFFF);
-
- /* Set the identifier */
- FldrSetIdentifier(BusKey, "PNP BIOS");
+ DPRINTM(DPRINT_HWDETECT, "PnP-BIOS supported\n");
+ DPRINTM(DPRINT_HWDETECT, "MaxNodeSize %u NodeCount %u\n", NodeSize, NodeCount);
+ DPRINTM(DPRINT_HWDETECT, "Estimated buffer size %u\n", NodeSize * NodeCount);
/* Set 'Configuration Data' value */
Size = sizeof(CM_PARTIAL_RESOURCE_LIST) + (NodeSize * NodeCount);
PartialResourceList = MmHeapAlloc(Size);
if (PartialResourceList == NULL)
{
- DbgPrint((DPRINT_HWDETECT,
- "Failed to allocate resource descriptor\n"));
+ DPRINTM(DPRINT_HWDETECT,
+ "Failed to allocate resource descriptor\n");
return;
}
memset(PartialResourceList, 0, Size);
{
DeviceNode = (PCM_PNP_BIOS_DEVICE_NODE)DISKREADBUFFER;
- DbgPrint((DPRINT_HWDETECT,
+ DPRINTM(DPRINT_HWDETECT,
"Node: %u Size %u (0x%x)\n",
DeviceNode->Node,
DeviceNode->Size,
- DeviceNode->Size));
+ DeviceNode->Size);
memcpy (Ptr,
DeviceNode,
PnpBufferSize;
Size = sizeof(CM_PARTIAL_RESOURCE_LIST) + PnpBufferSize;
- DbgPrint((DPRINT_HWDETECT, "Real buffer size: %u\n", PnpBufferSize));
- DbgPrint((DPRINT_HWDETECT, "Resource size: %u\n", Size));
-
- FldrSetConfigurationData(BusKey, PartialResourceList, Size);
+ DPRINTM(DPRINT_HWDETECT, "Real buffer size: %u\n", PnpBufferSize);
+ DPRINTM(DPRINT_HWDETECT, "Resource size: %u\n", Size);
+
+ /* Create component key */
+ FldrCreateComponentKey(SystemKey,
+ AdapterClass,
+ MultiFunctionAdapter,
+ 0x0,
+ 0x0,
+ 0xFFFFFFFF,
+ "PNP BIOS",
+ PartialResourceList,
+ Size,
+ &BusKey);
+
+ (*BusNumber)++;
+
MmHeapFree(PartialResourceList);
}
-static VOID
-SetHarddiskConfigurationData(PCONFIGURATION_COMPONENT_DATA DiskKey,
- ULONG DriveNumber)
+static PCM_PARTIAL_RESOURCE_LIST
+GetHarddiskConfigurationData(ULONG DriveNumber, ULONG* pSize)
{
PCM_PARTIAL_RESOURCE_LIST PartialResourceList;
PCM_DISK_GEOMETRY_DEVICE_DATA DiskGeometry;
GEOMETRY Geometry;
ULONG Size;
+ //
+ // Initialize returned size
+ //
+ *pSize = 0;
+
/* Set 'Configuration Data' value */
Size = sizeof(CM_PARTIAL_RESOURCE_LIST) +
sizeof(CM_DISK_GEOMETRY_DEVICE_DATA);
PartialResourceList = MmHeapAlloc(Size);
if (PartialResourceList == NULL)
{
- DbgPrint((DPRINT_HWDETECT,
- "Failed to allocate a full resource descriptor\n"));
- return;
+ DPRINTM(DPRINT_HWDETECT,
+ "Failed to allocate a full resource descriptor\n");
+ return NULL;
}
memset(PartialResourceList, 0, Size);
}
else
{
- DbgPrint((DPRINT_HWDETECT, "Reading disk geometry failed\n"));
+ DPRINTM(DPRINT_HWDETECT, "Reading disk geometry failed\n");
MmHeapFree(PartialResourceList);
- return;
+ return NULL;
}
- DbgPrint((DPRINT_HWDETECT,
+ DPRINTM(DPRINT_HWDETECT,
"Disk %x: %u Cylinders %u Heads %u Sectors %u Bytes\n",
DriveNumber,
DiskGeometry->NumberOfCylinders,
DiskGeometry->NumberOfHeads,
DiskGeometry->SectorsPerTrack,
- DiskGeometry->BytesPerSector));
+ DiskGeometry->BytesPerSector);
- FldrSetConfigurationData(DiskKey, PartialResourceList, Size);
- MmHeapFree(PartialResourceList);
+ //
+ // Return configuration data
+ //
+ *pSize = Size;
+ return PartialResourceList;
+}
+
+typedef struct tagDISKCONTEXT
+{
+ ULONG DriveNumber;
+ ULONG SectorSize;
+ ULONGLONG SectorOffset;
+ ULONGLONG SectorCount;
+ ULONGLONG SectorNumber;
+} DISKCONTEXT;
+
+static LONG DiskClose(ULONG FileId)
+{
+ DISKCONTEXT* Context = FsGetDeviceSpecific(FileId);
+
+ MmHeapFree(Context);
+ return ESUCCESS;
+}
+
+static LONG DiskGetFileInformation(ULONG FileId, FILEINFORMATION* Information)
+{
+ DISKCONTEXT* Context = FsGetDeviceSpecific(FileId);
+
+ RtlZeroMemory(Information, sizeof(FILEINFORMATION));
+ Information->EndingAddress.QuadPart = (Context->SectorOffset + Context->SectorCount) * Context->SectorSize;
+ Information->CurrentAddress.LowPart = (Context->SectorOffset + Context->SectorNumber) * Context->SectorSize;
+
+ return ESUCCESS;
}
+static LONG DiskOpen(CHAR* Path, OPENMODE OpenMode, ULONG* FileId)
+{
+ DISKCONTEXT* Context;
+ ULONG DriveNumber, DrivePartition, SectorSize;
+ ULONGLONG SectorOffset = 0;
+ ULONGLONG SectorCount = 0;
+ PARTITION_TABLE_ENTRY PartitionTableEntry;
+ CHAR FileName[1];
+
+ if (!DissectArcPath(Path, FileName, &DriveNumber, &DrivePartition))
+ return EINVAL;
+
+ if (DrivePartition == 0xff)
+ {
+ /* This is a CD-ROM device */
+ SectorSize = 2048;
+ }
+ else
+ {
+ /* This is either a floppy disk device (DrivePartition == 0) or
+ * a hard disk device (DrivePartition != 0 && DrivePartition != 0xFF) but
+ * it doesn't matter which one because they both have 512 bytes per sector */
+ SectorSize = 512;
+ }
+
+ if (DrivePartition != 0xff && DrivePartition != 0)
+ {
+ if (!DiskGetPartitionEntry(DriveNumber, DrivePartition, &PartitionTableEntry))
+ return EINVAL;
+ SectorOffset = PartitionTableEntry.SectorCountBeforePartition;
+ SectorCount = PartitionTableEntry.PartitionSectorCount;
+ }
+
+ Context = MmHeapAlloc(sizeof(DISKCONTEXT));
+ if (!Context)
+ return ENOMEM;
+ Context->DriveNumber = DriveNumber;
+ Context->SectorSize = SectorSize;
+ Context->SectorOffset = SectorOffset;
+ Context->SectorCount = SectorCount;
+ Context->SectorNumber = 0;
+ FsSetDeviceSpecific(*FileId, Context);
+
+ return ESUCCESS;
+}
+
+static LONG DiskRead(ULONG FileId, VOID* Buffer, ULONG N, ULONG* Count)
+{
+ DISKCONTEXT* Context = FsGetDeviceSpecific(FileId);
+ UCHAR* Ptr = (UCHAR*)Buffer;
+ ULONG i, Length;
+ BOOLEAN ret;
+
+ *Count = 0;
+ i = 0;
+ while (N > 0)
+ {
+ Length = N;
+ if (Length > Context->SectorSize)
+ Length = Context->SectorSize;
+ ret = MachDiskReadLogicalSectors(
+ Context->DriveNumber,
+ Context->SectorNumber + Context->SectorOffset + i,
+ 1,
+ (PVOID)DISKREADBUFFER);
+ if (!ret)
+ return EIO;
+ RtlCopyMemory(Ptr, (PVOID)DISKREADBUFFER, Length);
+ Ptr += Length;
+ *Count += Length;
+ N -= Length;
+ i++;
+ }
+
+ return ESUCCESS;
+}
+
+static LONG DiskSeek(ULONG FileId, LARGE_INTEGER* Position, SEEKMODE SeekMode)
+{
+ DISKCONTEXT* Context = FsGetDeviceSpecific(FileId);
+
+ if (SeekMode != SeekAbsolute)
+ return EINVAL;
+ if (Position->LowPart & (Context->SectorSize - 1))
+ return EINVAL;
+
+ /* FIXME: take HighPart into account */
+ Context->SectorNumber = Position->LowPart / Context->SectorSize;
+ return ESUCCESS;
+}
+
+static const DEVVTBL DiskVtbl = {
+ DiskClose,
+ DiskGetFileInformation,
+ DiskOpen,
+ DiskRead,
+ DiskSeek,
+};
static VOID
-SetHarddiskIdentifier(PCONFIGURATION_COMPONENT_DATA DiskKey,
+GetHarddiskIdentifier(PCHAR Identifier,
ULONG DriveNumber)
{
PMASTER_BOOT_RECORD Mbr;
ULONG i;
ULONG Checksum;
ULONG Signature;
- CHAR Identifier[20];
CHAR ArcName[256];
+ PARTITION_TABLE_ENTRY PartitionTableEntry;
/* Read the MBR */
if (!MachDiskReadLogicalSectors(DriveNumber, 0ULL, 1, (PVOID)DISKREADBUFFER))
{
- DbgPrint((DPRINT_HWDETECT, "Reading MBR failed\n"));
+ DPRINTM(DPRINT_HWDETECT, "Reading MBR failed\n");
return;
}
Mbr = (PMASTER_BOOT_RECORD)DISKREADBUFFER;
Signature = Mbr->Signature;
- DbgPrint((DPRINT_HWDETECT, "Signature: %x\n", Signature));
+ DPRINTM(DPRINT_HWDETECT, "Signature: %x\n", Signature);
/* Calculate the MBR checksum */
Checksum = 0;
Checksum += Buffer[i];
}
Checksum = ~Checksum + 1;
- DbgPrint((DPRINT_HWDETECT, "Checksum: %x\n", Checksum));
+ DPRINTM(DPRINT_HWDETECT, "Checksum: %x\n", Checksum);
/* Fill out the ARC disk block */
reactos_arc_disk_info[reactos_disk_count].Signature = Signature;
reactos_arc_strings[reactos_disk_count];
reactos_disk_count++;
+ sprintf(ArcName, "multi(0)disk(0)rdisk(%lu)partition(0)", DriveNumber - 0x80);
+ FsRegisterDevice(ArcName, &DiskVtbl);
+
+ /* Add partitions */
+ i = 1;
+ DiskReportError(FALSE);
+ while (DiskGetPartitionEntry(DriveNumber, i, &PartitionTableEntry))
+ {
+ if (PartitionTableEntry.SystemIndicator != PARTITION_ENTRY_UNUSED)
+ {
+ sprintf(ArcName, "multi(0)disk(0)rdisk(%lu)partition(%lu)", DriveNumber - 0x80, i);
+ FsRegisterDevice(ArcName, &DiskVtbl);
+ }
+ i++;
+ }
+ DiskReportError(TRUE);
+
/* Convert checksum and signature to identifier string */
Identifier[0] = Hex[(Checksum >> 28) & 0x0F];
Identifier[1] = Hex[(Checksum >> 24) & 0x0F];
Identifier[17] = '-';
Identifier[18] = 'A';
Identifier[19] = 0;
- DbgPrint((DPRINT_HWDETECT, "Identifier: %s\n", Identifier));
-
- /* Set identifier */
- FldrSetIdentifier(DiskKey, Identifier);
+ DPRINTM(DPRINT_HWDETECT, "Identifier: %s\n", Identifier);
}
static ULONG
DiskResetController(FloppyNumber);
Ptr = GetInt1eTable();
-
- FldrCreateComponentKey(ControllerKey,
- L"FloppyDiskPeripheral",
- FloppyNumber,
- PeripheralClass,
- FloppyDiskPeripheral,
- &PeripheralKey);
- /* Set 'ComponentInformation' value */
- FldrSetComponentInformation(PeripheralKey,
- Input | Output,
- FloppyNumber,
- 0xFFFFFFFF);
+ /* Set 'Identifier' value */
+ sprintf(Identifier, "FLOPPY%ld", FloppyNumber + 1);
Size = sizeof(CM_PARTIAL_RESOURCE_LIST) +
sizeof(CM_FLOPPY_DEVICE_DATA);
PartialResourceList = MmHeapAlloc(Size);
if (PartialResourceList == NULL)
{
- DbgPrint((DPRINT_HWDETECT,
- "Failed to allocate resource descriptor\n"));
+ DPRINTM(DPRINT_HWDETECT,
+ "Failed to allocate resource descriptor\n");
return;
}
FloppyData->MaximumTrackValue = (FloppyType == 1) ? 39 : 79;
FloppyData->DataTransferRate = 0;
- /* Set 'Configuration Data' value */
- FldrSetConfigurationData(PeripheralKey, PartialResourceList, Size);
- MmHeapFree(PartialResourceList);
+ FldrCreateComponentKey(ControllerKey,
+ PeripheralClass,
+ FloppyDiskPeripheral,
+ Input | Output,
+ FloppyNumber,
+ 0xFFFFFFFF,
+ Identifier,
+ PartialResourceList,
+ Size,
+ &PeripheralKey);
- /* Set 'Identifier' value */
- sprintf(Identifier, "FLOPPY%ld", FloppyNumber + 1);
- FldrSetIdentifier(PeripheralKey, Identifier);
+ MmHeapFree(PartialResourceList);
}
}
static VOID
-DetectBiosFloppyController(PCONFIGURATION_COMPONENT_DATA BusKey,
- PCONFIGURATION_COMPONENT_DATA ControllerKey)
+DetectBiosFloppyController(PCONFIGURATION_COMPONENT_DATA BusKey)
{
+ PCONFIGURATION_COMPONENT_DATA ControllerKey;
PCM_PARTIAL_RESOURCE_LIST PartialResourceList;
PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
ULONG Size;
ULONG FloppyCount;
FloppyCount = GetFloppyCount();
- DbgPrint((DPRINT_HWDETECT,
+ DPRINTM(DPRINT_HWDETECT,
"Floppy count: %u\n",
- FloppyCount));
+ FloppyCount);
Size = sizeof(CM_PARTIAL_RESOURCE_LIST) +
2 * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
PartialResourceList = MmHeapAlloc(Size);
if (PartialResourceList == NULL)
{
- DbgPrint((DPRINT_HWDETECT,
- "Failed to allocate resource descriptor\n"));
+ DPRINTM(DPRINT_HWDETECT,
+ "Failed to allocate resource descriptor\n");
return;
}
memset(PartialResourceList, 0, Size);
PartialDescriptor->u.Dma.Channel = 2;
PartialDescriptor->u.Dma.Port = 0;
- /* Set 'Configuration Data' value */
- FldrSetConfigurationData(ControllerKey, PartialResourceList, Size);
+ /* Create floppy disk controller */
+ FldrCreateComponentKey(BusKey,
+ ControllerClass,
+ DiskController,
+ Output | Input,
+ 0x0,
+ 0xFFFFFFFF,
+ NULL,
+ PartialResourceList,
+ Size,
+ &ControllerKey);
+ DPRINTM(DPRINT_HWDETECT, "Created key: DiskController\\0\n");
+
MmHeapFree(PartialResourceList);
if (FloppyCount) DetectBiosFloppyPeripheral(ControllerKey);
}
-static VOID
-DetectBiosDisks(PCONFIGURATION_COMPONENT_DATA SystemKey,
- PCONFIGURATION_COMPONENT_DATA BusKey)
+static PCONFIGURATION_COMPONENT_DATA
+DetectSystem(VOID)
{
+ PCONFIGURATION_COMPONENT_DATA SystemKey;
PCM_PARTIAL_RESOURCE_LIST PartialResourceList;
PCM_INT13_DRIVE_PARAMETER Int13Drives;
GEOMETRY Geometry;
- PCONFIGURATION_COMPONENT_DATA DiskKey, ControllerKey;
ULONG DiskCount;
ULONG Size;
ULONG i;
}
if (! Changed)
{
- DbgPrint((DPRINT_HWDETECT, "BIOS reports success for disk %d but data didn't change\n",
- (int)DiskCount));
+ DPRINTM(DPRINT_HWDETECT, "BIOS reports success for disk %d but data didn't change\n",
+ (int)DiskCount);
break;
}
DiskCount++;
memset((PVOID) DISKREADBUFFER, 0xcd, 512);
}
DiskReportError(TRUE);
- DbgPrint((DPRINT_HWDETECT, "BIOS reports %d harddisk%s\n",
- (int)DiskCount, (DiskCount == 1) ? "": "s"));
-
- FldrCreateComponentKey(BusKey,
- L"DiskController",
- 0,
- ControllerClass,
- DiskController,
- &ControllerKey);
- DbgPrint((DPRINT_HWDETECT, "Created key: DiskController\\0\n"));
-
- /* Set 'ComponentInformation' value */
- FldrSetComponentInformation(ControllerKey,
- Output | Input | Removable,
- 0,
- 0xFFFFFFFF);
-
- DetectBiosFloppyController(BusKey, ControllerKey);
+ DPRINTM(DPRINT_HWDETECT, "BIOS reports %d harddisk%s\n",
+ (int)DiskCount, (DiskCount == 1) ? "": "s");
/* Allocate resource descriptor */
Size = sizeof(CM_PARTIAL_RESOURCE_LIST) +
PartialResourceList = MmHeapAlloc(Size);
if (PartialResourceList == NULL)
{
- DbgPrint((DPRINT_HWDETECT,
- "Failed to allocate resource descriptor\n"));
- return;
+ DPRINTM(DPRINT_HWDETECT,
+ "Failed to allocate resource descriptor\n");
+ return NULL;
}
/* Initialize resource descriptor */
Int13Drives[i].MaxHeads = Geometry.Heads - 1;
Int13Drives[i].NumberDrives = DiskCount;
- DbgPrint((DPRINT_HWDETECT,
+ DPRINTM(DPRINT_HWDETECT,
"Disk %x: %u Cylinders %u Heads %u Sectors %u Bytes\n",
0x80 + i,
Geometry.Cylinders - 1,
Geometry.Heads -1,
Geometry.Sectors,
- Geometry.BytesPerSector));
+ Geometry.BytesPerSector);
}
}
-
- /* Set 'Configuration Data' value */
- FldrSetConfigurationData(SystemKey, PartialResourceList, Size);
+
+ FldrCreateComponentKey(NULL,
+ SystemClass,
+ MaximumType,
+ 0x0,
+ 0x0,
+ 0xFFFFFFFF,
+ NULL,
+ PartialResourceList,
+ Size,
+ &SystemKey);
+
MmHeapFree(PartialResourceList);
+
+ return SystemKey;
+}
+
+static ULONG
+GetDiskCount(PCONFIGURATION_COMPONENT_DATA BusKey)
+{
+ PCONFIGURATION_COMPONENT_DATA System;
+ ULONG ConfigurationDataLength;
+ ULONG DiskCount = 0;
+
+ //
+ // Get root component
+ //
+ System = BusKey;
+ while (System->Parent)
+ System = System->Parent;
+
+ //
+ // Get root configuration data length
+ //
+ ConfigurationDataLength = System->ComponentEntry.ConfigurationDataLength;
+
+ //
+ // We assume that nothing wrong happened, and that configuration
+ // only consists of one CM_PARTIAL_RESOURCE_LIST entry, followed
+ // by n entries of CM_INT13_DRIVE_PARAMETER
+ //
+ if (ConfigurationDataLength > 0)
+ DiskCount = (ConfigurationDataLength - sizeof(CM_PARTIAL_RESOURCE_LIST))
+ / sizeof(CM_INT13_DRIVE_PARAMETER);
+
+ //
+ // Return number of disks
+ //
+ DPRINTM(DPRINT_HWDETECT, "Retrieving %lu INT13 disks\\0\n", DiskCount);
+ return DiskCount;
+};
+
+static VOID
+DetectBiosDisks(PCONFIGURATION_COMPONENT_DATA BusKey)
+{
+ PCONFIGURATION_COMPONENT_DATA DiskKey, ControllerKey;
+ BOOLEAN BootDriveReported = FALSE;
+ ULONG i;
+ ULONG DiskCount = GetDiskCount(BusKey);
+ CHAR BootPath[512];
+
+ FldrCreateComponentKey(BusKey,
+ ControllerClass,
+ DiskController,
+ Output | Input,
+ 0x0,
+ 0xFFFFFFFF,
+ NULL,
+ NULL,
+ 0,
+ &ControllerKey);
+ DPRINTM(DPRINT_HWDETECT, "Created key: DiskController\\0\n");
/* Create and fill subkey for each harddisk */
for (i = 0; i < DiskCount; i++)
{
+ PCM_PARTIAL_RESOURCE_LIST PartialResourceList;
+ ULONG Size;
+ CHAR Identifier[20];
+
+ if (BootDrive == 0x80 + i)
+ BootDriveReported = TRUE;
+
+ /* Get disk values */
+ PartialResourceList = GetHarddiskConfigurationData(0x80 + i, &Size);
+ GetHarddiskIdentifier(Identifier, 0x80 + i);
+
/* Create disk key */
FldrCreateComponentKey(ControllerKey,
- L"DiskPeripheral",
- i,
PeripheralClass,
DiskPeripheral,
+ Output | Input,
+ 0x0,
+ 0xFFFFFFFF,
+ Identifier,
+ PartialResourceList,
+ Size,
&DiskKey);
-
- /* Set 'ComponentInformation' value */
- FldrSetComponentInformation(DiskKey,
- Output | Input,
- 0,
- 0xFFFFFFFF);
-
- /* Set disk values */
- SetHarddiskConfigurationData(DiskKey, 0x80 + i);
- SetHarddiskIdentifier(DiskKey, 0x80 + i);
+ }
+
+ /* Get the drive we're booting from */
+ MachDiskGetBootPath(BootPath, sizeof(BootPath));
+
+ /* Add it, if it's a floppy or cdrom */
+ if ((BootDrive >= 0x80 && !BootDriveReported) ||
+ DiskIsDriveRemovable(BootDrive))
+ {
+ /* TODO: Check if it's really a cdrom drive */
+ ULONG* Buffer;
+ ULONG Checksum = 0;
+
+ /* Read the MBR */
+ if (!MachDiskReadLogicalSectors(BootDrive, 16ULL, 1, (PVOID)DISKREADBUFFER))
+ {
+ DPRINTM(DPRINT_HWDETECT, "Reading MBR failed\n");
+ return;
+ }
+
+ Buffer = (ULONG*)DISKREADBUFFER;
+
+ /* Calculate the MBR checksum */
+ for (i = 0; i < 2048 / sizeof(ULONG); i++) Checksum += Buffer[i];
+ DPRINTM(DPRINT_HWDETECT, "Checksum: %x\n", Checksum);
+
+ /* Fill out the ARC disk block */
+ reactos_arc_disk_info[reactos_disk_count].CheckSum = Checksum;
+ strcpy(reactos_arc_strings[reactos_disk_count], BootPath);
+ reactos_arc_disk_info[reactos_disk_count].ArcName =
+ reactos_arc_strings[reactos_disk_count];
+ reactos_disk_count++;
+
+ FsRegisterDevice(BootPath, &DiskVtbl);
}
}
Buffer[i] = READ_PORT_UCHAR(Port);
}
- DbgPrint((DPRINT_HWDETECT,
+ DPRINTM(DPRINT_HWDETECT,
"Mouse data: %x %x %x %x\n",
- Buffer[0],Buffer[1],Buffer[2],Buffer[3]));
+ Buffer[0],Buffer[1],Buffer[2],Buffer[3]);
/* Check that four bytes for signs */
for (i = 0; i < 4; ++i)
switch (Buffer[i + 1])
{
case '3':
- DbgPrint((DPRINT_HWDETECT,
- "Microsoft Mouse with 3-buttons detected\n"));
+ DPRINTM(DPRINT_HWDETECT,
+ "Microsoft Mouse with 3-buttons detected\n");
return MOUSE_TYPE_LOGITECH;
case 'Z':
- DbgPrint((DPRINT_HWDETECT,
- "Microsoft Wheel Mouse detected\n"));
+ DPRINTM(DPRINT_HWDETECT,
+ "Microsoft Wheel Mouse detected\n");
return MOUSE_TYPE_WHEELZ;
/* case '2': */
default:
- DbgPrint((DPRINT_HWDETECT,
- "Microsoft Mouse with 2-buttons detected\n"));
+ DPRINTM(DPRINT_HWDETECT,
+ "Microsoft Mouse with 2-buttons detected\n");
return MOUSE_TYPE_MICROSOFT;
}
}
ULONG j;
ULONG k;
- DbgPrint((DPRINT_HWDETECT,
- "DetectSerialPointerPeripheral()\n"));
+ DPRINTM(DPRINT_HWDETECT,
+ "DetectSerialPointerPeripheral()\n");
Identifier[0] = 0;
if (MouseType != MOUSE_TYPE_NONE)
{
Length = GetSerialMousePnpId(Base, Buffer);
- DbgPrint((DPRINT_HWDETECT,
+ DPRINTM(DPRINT_HWDETECT,
"PnP ID length: %u\n",
- Length));
+ Length);
if (Length != 0)
{
}
Buffer[Length] = 0;
- DbgPrint((DPRINT_HWDETECT,
+ DPRINTM(DPRINT_HWDETECT,
"PnP ID string: %s\n",
- Buffer));
+ Buffer);
/* Copy PnpId string */
for (i = 0; i < 7; i++)
}
}
- DbgPrint((DPRINT_HWDETECT,
+ DPRINTM(DPRINT_HWDETECT,
"Identifier string: %s\n",
- Identifier));
+ Identifier);
}
if (Length == 0 || strlen(Identifier) < 11)
}
}
- /* Create 'PointerPeripheral' key */
- FldrCreateComponentKey(ControllerKey,
- L"PointerPeripheral",
- 0,
- PeripheralClass,
- PointerPeripheral,
- &PeripheralKey);
- DbgPrint((DPRINT_HWDETECT,
- "Created key: PointerPeripheral\\0\n"));
-
- /* Set 'ComponentInformation' value */
- FldrSetComponentInformation(PeripheralKey,
- Input,
- 0,
- 0xFFFFFFFF);
-
/* Set 'Configuration Data' value */
memset(&PartialResourceList, 0, sizeof(CM_PARTIAL_RESOURCE_LIST));
PartialResourceList.Version = 1;
PartialResourceList.Revision = 1;
PartialResourceList.Count = 0;
- FldrSetConfigurationData(PeripheralKey,
- &PartialResourceList,
- sizeof(CM_PARTIAL_RESOURCE_LIST) -
- sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR));
+ /* Create 'PointerPeripheral' key */
+ FldrCreateComponentKey(ControllerKey,
+ PeripheralClass,
+ PointerPeripheral,
+ Input,
+ 0x0,
+ 0xFFFFFFFF,
+ Identifier,
+ &PartialResourceList,
+ sizeof(CM_PARTIAL_RESOURCE_LIST) -
+ sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR),
+ &PeripheralKey);
- /* Set 'Identifier' value */
- FldrSetIdentifier(PeripheralKey, Identifier);
+ DPRINTM(DPRINT_HWDETECT,
+ "Created key: PointerPeripheral\\0\n");
}
}
ULONG i;
ULONG Size;
- DbgPrint((DPRINT_HWDETECT, "DetectSerialPorts()\n"));
+ DPRINTM(DPRINT_HWDETECT, "DetectSerialPorts()\n");
ControllerNumber = 0;
BasePtr = (PUSHORT)0x400;
if (Base == 0)
continue;
- DbgPrint((DPRINT_HWDETECT,
+ DPRINTM(DPRINT_HWDETECT,
"Found COM%u port at 0x%x\n",
i + 1,
- Base));
+ Base);
- /* Create controller key */
- FldrCreateComponentKey(BusKey,
- L"SerialController",
- ControllerNumber,
- ControllerClass,
- SerialController,
- &ControllerKey);
-
- /* Set 'ComponentInformation' value */
- FldrSetComponentInformation(ControllerKey,
- Output | Input | ConsoleIn | ConsoleOut,
- ControllerNumber,
- 0xFFFFFFFF);
+ /* Set 'Identifier' value */
+ sprintf(Buffer, "COM%ld", i + 1);
/* Build full device descriptor */
Size = sizeof(CM_PARTIAL_RESOURCE_LIST) +
PartialResourceList = MmHeapAlloc(Size);
if (PartialResourceList == NULL)
{
- DbgPrint((DPRINT_HWDETECT,
- "Failed to allocate resource descriptor\n"));
+ DPRINTM(DPRINT_HWDETECT,
+ "Failed to allocate resource descriptor\n");
continue;
}
memset(PartialResourceList, 0, Size);
/* Set Interrupt */
PartialDescriptor = &PartialResourceList->PartialDescriptors[1];
PartialDescriptor->Type = CmResourceTypeInterrupt;
- PartialDescriptor->ShareDisposition = CmResourceShareUndetermined;
+ PartialDescriptor->ShareDisposition = CmResourceShareShared;
PartialDescriptor->Flags = CM_RESOURCE_INTERRUPT_LATCHED;
PartialDescriptor->u.Interrupt.Level = Irq[i];
- PartialDescriptor->u.Interrupt.Vector = 0;
+ PartialDescriptor->u.Interrupt.Vector = Irq[i];
PartialDescriptor->u.Interrupt.Affinity = 0xFFFFFFFF;
/* Set serial data (device specific) */
(PCM_SERIAL_DEVICE_DATA)&PartialResourceList->PartialDescriptors[3];
SerialDeviceData->BaudClock = 1843200; /* UART Clock frequency (Hertz) */
- /* Set 'Configuration Data' value */
- FldrSetConfigurationData(ControllerKey, PartialResourceList, Size);
- MmHeapFree(PartialResourceList);
+ /* Create controller key */
+ FldrCreateComponentKey(BusKey,
+ ControllerClass,
+ SerialController,
+ Output | Input | ConsoleIn | ConsoleOut,
+ ControllerNumber,
+ 0xFFFFFFFF,
+ Buffer,
+ PartialResourceList,
+ Size,
+ &ControllerKey);
- /* Set 'Identifier' value */
- sprintf(Buffer, "COM%ld", i + 1);
- FldrSetIdentifier(ControllerKey, Buffer);
- DbgPrint((DPRINT_HWDETECT,
- "Created value: Identifier %s\n",
- Buffer));
+ MmHeapFree(PartialResourceList);
if (!Rs232PortInUse(Base))
{
ULONG i;
ULONG Size;
- DbgPrint((DPRINT_HWDETECT, "DetectParallelPorts() called\n"));
+ DPRINTM(DPRINT_HWDETECT, "DetectParallelPorts() called\n");
ControllerNumber = 0;
BasePtr = (PUSHORT)0x408;
if (Base == 0)
continue;
- DbgPrint((DPRINT_HWDETECT,
+ DPRINTM(DPRINT_HWDETECT,
"Parallel port %u: %x\n",
ControllerNumber,
- Base));
-
- /* Create controller key */
- FldrCreateComponentKey(BusKey,
- L"ParallelController",
- ControllerNumber,
- ControllerClass,
- ParallelController,
- &ControllerKey);
+ Base);
- /* Set 'ComponentInformation' value */
- FldrSetComponentInformation(ControllerKey,
- Output,
- ControllerNumber,
- 0xFFFFFFFF);
+ /* Set 'Identifier' value */
+ sprintf(Buffer, "PARALLEL%ld", i + 1);
/* Build full device descriptor */
Size = sizeof(CM_PARTIAL_RESOURCE_LIST);
PartialResourceList = MmHeapAlloc(Size);
if (PartialResourceList == NULL)
{
- DbgPrint((DPRINT_HWDETECT,
- "Failed to allocate resource descriptor\n"));
+ DPRINTM(DPRINT_HWDETECT,
+ "Failed to allocate resource descriptor\n");
continue;
}
memset(PartialResourceList, 0, Size);
PartialDescriptor->ShareDisposition = CmResourceShareUndetermined;
PartialDescriptor->Flags = CM_RESOURCE_INTERRUPT_LATCHED;
PartialDescriptor->u.Interrupt.Level = Irq[i];
- PartialDescriptor->u.Interrupt.Vector = 0;
+ PartialDescriptor->u.Interrupt.Vector = Irq[i];
PartialDescriptor->u.Interrupt.Affinity = 0xFFFFFFFF;
}
- /* Set 'Configuration Data' value */
- FldrSetConfigurationData(ControllerKey, PartialResourceList, Size);
- MmHeapFree(PartialResourceList);
+ /* Create controller key */
+ FldrCreateComponentKey(BusKey,
+ ControllerClass,
+ ParallelController,
+ Output,
+ ControllerNumber,
+ 0xFFFFFFFF,
+ Buffer,
+ PartialResourceList,
+ Size,
+ &ControllerKey);
- /* Set 'Identifier' value */
- sprintf(Buffer, "PARALLEL%ld", i + 1);
- FldrSetIdentifier(ControllerKey, Buffer);
- DbgPrint((DPRINT_HWDETECT,
- "Created value: Identifier %s\n",
- Buffer));
+ MmHeapFree(PartialResourceList);
ControllerNumber++;
}
- DbgPrint((DPRINT_HWDETECT, "DetectParallelPorts() done\n"));
+ DPRINTM(DPRINT_HWDETECT, "DetectParallelPorts() done\n");
}
/* HACK: don't call DetectKeyboardDevice() as it fails in Qemu 0.8.2 */
if (TRUE || DetectKeyboardDevice())
{
- /* Create controller key */
- FldrCreateComponentKey(ControllerKey,
- L"KeyboardPeripheral",
- 0,
- PeripheralClass,
- KeyboardPeripheral,
- &PeripheralKey);
- DbgPrint((DPRINT_HWDETECT, "Created key: KeyboardPeripheral\\0\n"));
-
- /* Set 'ComponentInformation' value */
- FldrSetComponentInformation(PeripheralKey,
- Input | ConsoleIn,
- 0,
- 0xFFFFFFFF);
-
/* Set 'Configuration Data' value */
Size = sizeof(CM_PARTIAL_RESOURCE_LIST) +
sizeof(CM_KEYBOARD_DEVICE_DATA);
PartialResourceList = MmHeapAlloc(Size);
if (PartialResourceList == NULL)
{
- DbgPrint((DPRINT_HWDETECT,
- "Failed to allocate resource descriptor\n"));
+ DPRINTM(DPRINT_HWDETECT,
+ "Failed to allocate resource descriptor\n");
return;
}
KeyboardData->Subtype = 0;
KeyboardData->KeyboardFlags = 0x20;
- /* Set 'Configuration Data' value */
- FldrSetConfigurationData(PeripheralKey, PartialResourceList, Size);
- MmHeapFree(PartialResourceList);
+ /* Create controller key */
+ FldrCreateComponentKey(ControllerKey,
+ PeripheralClass,
+ KeyboardPeripheral,
+ Input | ConsoleIn,
+ 0x0,
+ 0xFFFFFFFF,
+ "PCAT_ENHANCED",
+ PartialResourceList,
+ Size,
+ &PeripheralKey);
+ DPRINTM(DPRINT_HWDETECT, "Created key: KeyboardPeripheral\\0\n");
- /* Set 'Identifier' value */
- FldrSetIdentifier(PeripheralKey, "PCAT_ENHANCED");
+ MmHeapFree(PartialResourceList);
}
}
PCONFIGURATION_COMPONENT_DATA ControllerKey;
ULONG Size;
- /* Create controller key */
- FldrCreateComponentKey(BusKey,
- L"KeyboardController",
- 0,
- ControllerClass,
- KeyboardController,
- &ControllerKey);
- DbgPrint((DPRINT_HWDETECT, "Created key: KeyboardController\\0\n"));
-
- /* Set 'ComponentInformation' value */
- FldrSetComponentInformation(ControllerKey,
- Input | ConsoleIn,
- 0,
- 0xFFFFFFFF);
-
/* Set 'Configuration Data' value */
Size = sizeof(CM_PARTIAL_RESOURCE_LIST) +
2 * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
PartialResourceList = MmHeapAlloc(Size);
if (PartialResourceList == NULL)
{
- DbgPrint((DPRINT_HWDETECT,
- "Failed to allocate resource descriptor\n"));
+ DPRINTM(DPRINT_HWDETECT,
+ "Failed to allocate resource descriptor\n");
return;
}
PartialDescriptor->ShareDisposition = CmResourceShareUndetermined;
PartialDescriptor->Flags = CM_RESOURCE_INTERRUPT_LATCHED;
PartialDescriptor->u.Interrupt.Level = 1;
- PartialDescriptor->u.Interrupt.Vector = 0;
+ PartialDescriptor->u.Interrupt.Vector = 1;
PartialDescriptor->u.Interrupt.Affinity = 0xFFFFFFFF;
/* Set IO Port 0x60 */
PartialDescriptor->u.Port.Start.HighPart = 0x0;
PartialDescriptor->u.Port.Length = 1;
- /* Set 'Configuration Data' value */
- FldrSetConfigurationData(ControllerKey, PartialResourceList, Size);
+ /* Create controller key */
+ FldrCreateComponentKey(BusKey,
+ ControllerClass,
+ KeyboardController,
+ Input | ConsoleIn,
+ 0x0,
+ 0xFFFFFFFF,
+ NULL,
+ PartialResourceList,
+ Size,
+ &ControllerKey);
+ DPRINTM(DPRINT_HWDETECT, "Created key: KeyboardController\\0\n");
+
MmHeapFree(PartialResourceList);
DetectKeyboardPeripheral(ControllerKey);
if (DetectPS2AuxPort())
{
- DbgPrint((DPRINT_HWDETECT, "Detected PS2 port\n"));
-
- /* Create controller key */
- FldrCreateComponentKey(BusKey,
- L"PointerController",
- 0,
- ControllerClass,
- PointerController,
- &ControllerKey);
- DbgPrint((DPRINT_HWDETECT, "Created key: PointerController\\0\n"));
-
- /* Set 'ComponentInformation' value */
- FldrSetComponentInformation(ControllerKey,
- Input,
- 0,
- 0xFFFFFFFF);
+ DPRINTM(DPRINT_HWDETECT, "Detected PS2 port\n");
memset(&PartialResourceList, 0, sizeof(CM_PARTIAL_RESOURCE_LIST));
PartialResourceList.PartialDescriptors[0].ShareDisposition = CmResourceShareUndetermined;
PartialResourceList.PartialDescriptors[0].Flags = CM_RESOURCE_INTERRUPT_LATCHED;
PartialResourceList.PartialDescriptors[0].u.Interrupt.Level = 12;
- PartialResourceList.PartialDescriptors[0].u.Interrupt.Vector = 0;
+ PartialResourceList.PartialDescriptors[0].u.Interrupt.Vector = 12;
PartialResourceList.PartialDescriptors[0].u.Interrupt.Affinity = 0xFFFFFFFF;
- /* Set 'Configuration Data' value */
- FldrSetConfigurationData(ControllerKey,
- &PartialResourceList,
- sizeof(CM_PARTIAL_RESOURCE_LIST));
+ /* Create controller key */
+ FldrCreateComponentKey(BusKey,
+ ControllerClass,
+ PointerController,
+ Input,
+ 0x0,
+ 0xFFFFFFFF,
+ NULL,
+ &PartialResourceList,
+ sizeof(CM_PARTIAL_RESOURCE_LIST),
+ &ControllerKey);
+ DPRINTM(DPRINT_HWDETECT, "Created key: PointerController\\0\n");
if (DetectPS2AuxDevice())
{
- DbgPrint((DPRINT_HWDETECT, "Detected PS2 mouse\n"));
-
- /* Create peripheral key */
- FldrCreateComponentKey(ControllerKey,
- L"PointerPeripheral",
- 0,
- ControllerClass,
- PointerPeripheral,
- &PeripheralKey);
- DbgPrint((DPRINT_HWDETECT, "Created key: PointerPeripheral\\0\n"));
-
- /* Set 'ComponentInformation' value */
- FldrSetComponentInformation(PeripheralKey,
- Input,
- 0,
- 0xFFFFFFFF);
+ DPRINTM(DPRINT_HWDETECT, "Detected PS2 mouse\n");
/* Initialize resource descriptor */
memset(&PartialResourceList, 0, sizeof(CM_PARTIAL_RESOURCE_LIST));
PartialResourceList.Revision = 1;
PartialResourceList.Count = 0;
- /* Set 'Configuration Data' value */
- FldrSetConfigurationData(PeripheralKey,
- &PartialResourceList,
- sizeof(CM_PARTIAL_RESOURCE_LIST) -
- sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR));
-
- /* Set 'Identifier' value */
- FldrSetIdentifier(PeripheralKey, "MICROSOFT PS2 MOUSE");
+ /* Create peripheral key */
+ FldrCreateComponentKey(ControllerKey,
+ ControllerClass,
+ PointerPeripheral,
+ Input,
+ 0x0,
+ 0xFFFFFFFF,
+ "MICROSOFT PS2 MOUSE",
+ &PartialResourceList,
+ sizeof(CM_PARTIAL_RESOURCE_LIST) -
+ sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR),
+ &PeripheralKey);
+ DPRINTM(DPRINT_HWDETECT, "Created key: PointerPeripheral\\0\n");
}
}
}
PCONFIGURATION_COMPONENT_DATA ControllerKey;
USHORT VesaVersion;
- FldrCreateComponentKey(BusKey,
- L"DisplayController",
- 0,
- ControllerClass,
- DisplayController,
- &ControllerKey);
- DbgPrint((DPRINT_HWDETECT, "Created key: DisplayController\\0\n"));
-
- /* Set 'ComponentInformation' value */
- FldrSetComponentInformation(ControllerKey,
- 0x00,
- 0,
- 0xFFFFFFFF);
-
/* FIXME: Set 'ComponentInformation' value */
VesaVersion = BiosIsVesaSupported();
if (VesaVersion != 0)
{
- DbgPrint((DPRINT_HWDETECT,
+ DPRINTM(DPRINT_HWDETECT,
"VESA version %c.%c\n",
(VesaVersion >> 8) + '0',
- (VesaVersion & 0xFF) + '0'));
+ (VesaVersion & 0xFF) + '0');
}
else
{
- DbgPrint((DPRINT_HWDETECT,
- "VESA not supported\n"));
+ DPRINTM(DPRINT_HWDETECT,
+ "VESA not supported\n");
}
if (VesaVersion >= 0x0200)
"VGA Display");
}
- /* Set 'Identifier' value */
- FldrSetIdentifier(ControllerKey, Buffer);
+ FldrCreateComponentKey(BusKey,
+ ControllerClass,
+ DisplayController,
+ 0x0,
+ 0x0,
+ 0xFFFFFFFF,
+ Buffer,
+ NULL,
+ 0,
+ &ControllerKey);
+ DPRINTM(DPRINT_HWDETECT, "Created key: DisplayController\\0\n");
/* FIXME: Add display peripheral (monitor) data */
}
PCONFIGURATION_COMPONENT_DATA BusKey;
ULONG Size;
- /* Create new bus key */
- FldrCreateComponentKey(SystemKey,
- L"MultifunctionAdapter",
- *BusNumber,
- AdapterClass,
- MultiFunctionAdapter,
- &BusKey);
-
- /* Set 'Component Information' value similar to my NT4 box */
- FldrSetComponentInformation(BusKey,
- 0x0,
- 0x0,
- 0xFFFFFFFF);
-
/* Increment bus number */
(*BusNumber)++;
- /* Set 'Identifier' value */
- FldrSetIdentifier(BusKey, "ISA");
-
/* Set 'Configuration Data' value */
Size = sizeof(CM_PARTIAL_RESOURCE_LIST) -
sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
PartialResourceList = MmHeapAlloc(Size);
if (PartialResourceList == NULL)
{
- DbgPrint((DPRINT_HWDETECT,
- "Failed to allocate resource descriptor\n"));
+ DPRINTM(DPRINT_HWDETECT,
+ "Failed to allocate resource descriptor\n");
return;
}
PartialResourceList->Revision = 1;
PartialResourceList->Count = 0;
- /* Set 'Configuration Data' value */
- FldrSetConfigurationData(BusKey, PartialResourceList, Size);
+ /* Create new bus key */
+ FldrCreateComponentKey(SystemKey,
+ AdapterClass,
+ MultiFunctionAdapter,
+ 0x0,
+ 0x0,
+ 0xFFFFFFFF,
+ "ISA",
+ PartialResourceList,
+ Size,
+ &BusKey);
+
MmHeapFree(PartialResourceList);
/* Detect ISA/BIOS devices */
- DetectBiosDisks(SystemKey, BusKey);
+ DetectBiosDisks(BusKey);
+
+ DetectBiosFloppyController(BusKey);
DetectSerialPorts(BusKey);
PCONFIGURATION_COMPONENT_DATA SystemKey;
ULONG BusNumber = 0;
- DbgPrint((DPRINT_HWDETECT, "DetectHardware()\n"));
+ DPRINTM(DPRINT_HWDETECT, "DetectHardware()\n");
/* Create the 'System' key */
- FldrCreateSystemKey(&SystemKey);
-
- /* Set empty component information */
- FldrSetComponentInformation(SystemKey,
- 0x0,
- 0x0,
- 0xFFFFFFFF);
+ SystemKey = DetectSystem();
/* Detect buses */
DetectPciBios(SystemKey, &BusNumber);
DetectIsaBios(SystemKey, &BusNumber);
DetectAcpiBios(SystemKey, &BusNumber);
- DbgPrint((DPRINT_HWDETECT, "DetectHardware() Done\n"));
+ DPRINTM(DPRINT_HWDETECT, "DetectHardware() Done\n");
return SystemKey;
}
projects / reactos.git / blobdiff