freeldr/freeldr/arch/i386/hardware.c

   1 /*
   2  *  FreeLoader
   3  *
   4  *  Copyright (C) 2003, 2004  Eric Kohl
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21 #include <freeldr.h>
  22 #include <arch.h>
  23 #include <rtl.h>
  24 #include <debug.h>
  25 #include <disk.h>
  26 #include <mm.h>
  27 #include <portio.h>
  28 #include <video.h>
  29
  30 #include "../../reactos/registry.h"
  31 #include "hardware.h"
  32
  33
  34 #define MILLISEC     (10)
  35 #define PRECISION    (8)
  36
  37 #define HZ (100)
  38 #define CLOCK_TICK_RATE (1193182)
  39 #define LATCH (CLOCK_TICK_RATE / HZ)
  40
  41
  42 /* No Mouse */
  43 #define MOUSE_TYPE_NONE                 0
  44 /* Microsoft Mouse with 2 buttons */
  45 #define MOUSE_TYPE_MICROSOFT    1
  46 /* Logitech Mouse with 3 buttons */
  47 #define MOUSE_TYPE_LOGITECH             2
  48 /* Microsoft Wheel Mouse (aka Z Mouse) */
  49 #define MOUSE_TYPE_WHEELZ               3
  50 /* Mouse Systems Mouse */
  51 #define MOUSE_TYPE_MOUSESYSTEMS 4
  52
  53
  54 /* PS2 stuff */
  55
  56 /* Controller registers. */
  57 #define CONTROLLER_REGISTER_STATUS                      0x64
  58 #define CONTROLLER_REGISTER_CONTROL                     0x64
  59 #define CONTROLLER_REGISTER_DATA                        0x60
  60
  61 /* Controller commands. */
  62 #define CONTROLLER_COMMAND_READ_MODE                    0x20
  63 #define CONTROLLER_COMMAND_WRITE_MODE                   0x60
  64 #define CONTROLLER_COMMAND_GET_VERSION                  0xA1
  65 #define CONTROLLER_COMMAND_MOUSE_DISABLE                0xA7
  66 #define CONTROLLER_COMMAND_MOUSE_ENABLE                 0xA8
  67 #define CONTROLLER_COMMAND_TEST_MOUSE                   0xA9
  68 #define CONTROLLER_COMMAND_SELF_TEST                    0xAA
  69 #define CONTROLLER_COMMAND_KEYBOARD_TEST                0xAB
  70 #define CONTROLLER_COMMAND_KEYBOARD_DISABLE             0xAD
  71 #define CONTROLLER_COMMAND_KEYBOARD_ENABLE              0xAE
  72 #define CONTROLLER_COMMAND_WRITE_MOUSE_OUTPUT_BUFFER    0xD3
  73 #define CONTROLLER_COMMAND_WRITE_MOUSE                  0xD4
  74
  75 /* Controller status */
  76 #define CONTROLLER_STATUS_OUTPUT_BUFFER_FULL            0x01
  77 #define CONTROLLER_STATUS_INPUT_BUFFER_FULL             0x02
  78 #define CONTROLLER_STATUS_SELF_TEST                     0x04
  79 #define CONTROLLER_STATUS_COMMAND                       0x08
  80 #define CONTROLLER_STATUS_UNLOCKED                      0x10
  81 #define CONTROLLER_STATUS_MOUSE_OUTPUT_BUFFER_FULL      0x20
  82 #define CONTROLLER_STATUS_GENERAL_TIMEOUT               0x40
  83 #define CONTROLLER_STATUS_PARITY_ERROR                  0x80
  84 #define AUX_STATUS_OUTPUT_BUFFER_FULL                   (CONTROLLER_STATUS_OUTPUT_BUFFER_FULL | \
  85                                                          CONTROLLER_STATUS_MOUSE_OUTPUT_BUFFER_FULL)
  86
  87 /* Timeout in ms for sending to keyboard controller. */
  88 #define CONTROLLER_TIMEOUT                              250
  89
  90
  91 typedef struct _CM_INT13_DRIVE_PARAMETER
  92 {
  93   U16 DriveSelect;
  94   U32 MaxCylinders;
  95   U16 SectorsPerTrack;
  96   U16 MaxHeads;
  97   U16 NumberDrives;
  98 } CM_INT13_DRIVE_PARAMETER, *PCM_INT13_DRIVE_PARAMETER;
  99
 100
 101 typedef struct _CM_DISK_GEOMETRY_DEVICE_DATA
 102 {
 103   U32 BytesPerSector;
 104   U32 NumberOfCylinders;
 105   U32 SectorsPerTrack;
 106   U32 NumberOfHeads;
 107 } CM_DISK_GEOMETRY_DEVICE_DATA, *PCM_DISK_GEOMETRY_DEVICE_DATA;
 108
 109
 110 typedef struct _CM_PNP_BIOS_DEVICE_NODE
 111 {
 112   U16 Size;
 113   U8  Node;
 114   U32 ProductId;
 115   U8  DeviceType[3];
 116   U16 DeviceAttributes;
 117 } __attribute__((packed)) CM_PNP_BIOS_DEVICE_NODE, *PCM_PNP_BIOS_DEVICE_NODE;
 118
 119
 120 typedef struct _CM_PNP_BIOS_INSTALLATION_CHECK
 121 {
 122   U8  Signature[4];
 123   U8  Revision;
 124   U8  Length;
 125   U16 ControlField;
 126   U8  Checksum;
 127   U32 EventFlagAddress;
 128   U16 RealModeEntryOffset;
 129   U16 RealModeEntrySegment;
 130   U16 ProtectedModeEntryOffset;
 131   U32 ProtectedModeCodeBaseAddress;
 132   U32 OemDeviceId;
 133   U16 RealModeDataBaseAddress;
 134   U32 ProtectedModeDataBaseAddress;
 135 } __attribute__((packed)) CM_PNP_BIOS_INSTALLATION_CHECK, *PCM_PNP_BIOS_INSTALLATION_CHECK;
 136
 137
 138 typedef struct _CM_SERIAL_DEVICE_DATA
 139 {
 140   U16 Version;
 141   U16 Revision;
 142   U32 BaudClock;
 143 } __attribute__((packed)) CM_SERIAL_DEVICE_DATA, *PCM_SERIAL_DEVICE_DATA;
 144
 145
 146 typedef struct _CM_FLOPPY_DEVICE_DATA
 147 {
 148   U16 Version;
 149   U16 Revision;
 150   CHAR Size[8];
 151   U32 MaxDensity;
 152   U32 MountDensity;
 153
 154   /* Version 2.0 data */
 155   U8 StepRateHeadUnloadTime;
 156   U8 HeadLoadTime;
 157   U8 MotorOffTime;
 158   U8 SectorLengthCode;
 159   U8 SectorPerTrack;
 160   U8 ReadWriteGapLength;
 161   U8 DataTransferLength;
 162   U8 FormatGapLength;
 163   U8 FormatFillCharacter;
 164   U8 HeadSettleTime;
 165   U8 MotorSettleTime;
 166   U8 MaximumTrackValue;
 167   U8 DataTransferRate;
 168 } __attribute__((packed)) CM_FLOPPY_DEVICE_DATA, *PCM_FLOPPY_DEVICE_DATA;
 169
 170
 171 typedef struct _CM_KEYBOARD_DEVICE_DATA
 172 {
 173   U16 Version;
 174   U16 Revision;
 175   U8 Type;
 176   U8 Subtype;
 177   U16 KeyboardFlags;
 178 } __attribute__((packed)) CM_KEYBOARD_DEVICE_DATA, *PCM_KEYBOARD_DEVICE_DATA;
 179
 180
 181 static char Hex[] = "0123456789ABCDEF";
 182 static unsigned int delay_count = 1;
 183
 184
 185 /* FUNCTIONS ****************************************************************/
 186
 187
 188 static VOID
 189 __KeStallExecutionProcessor(U32 Loops)
 190 {
 191   register unsigned int i;
 192   for (i = 0; i < Loops; i++);
 193 }
 194
 195 VOID KeStallExecutionProcessor(U32 Microseconds)
 196 {
 197   U64 LoopCount = ((U64)delay_count * (U64)Microseconds) / 1000ULL;
 198   __KeStallExecutionProcessor((U32)LoopCount);
 199 }
 200
 201
 202 static U32
 203 Read8254Timer(VOID)
 204 {
 205   U32 Count;
 206
 207   WRITE_PORT_UCHAR((PU8)0x43, 0x00);
 208   Count = READ_PORT_UCHAR((PU8)0x40);
 209   Count |= READ_PORT_UCHAR((PU8)0x40) << 8;
 210
 211   return Count;
 212 }
 213
 214
 215 static VOID
 216 WaitFor8254Wraparound(VOID)
 217 {
 218   U32 CurCount;
 219   U32 PrevCount = ~0;
 220   S32 Delta;
 221
 222   CurCount = Read8254Timer();
 223
 224   do
 225     {
 226       PrevCount = CurCount;
 227       CurCount = Read8254Timer();
 228       Delta = CurCount - PrevCount;
 229
 230       /*
 231        * This limit for delta seems arbitrary, but it isn't, it's
 232        * slightly above the level of error a buggy Mercury/Neptune
 233        * chipset timer can cause.
 234        */
 235     }
 236   while (Delta < 300);
 237 }
 238
 239
 240 VOID
 241 HalpCalibrateStallExecution(VOID)
 242 {
 243   U32 i;
 244   U32 calib_bit;
 245   U32 CurCount;
 246
 247   /* Initialise timer interrupt with MILLISECOND ms interval        */
 248   WRITE_PORT_UCHAR((PU8)0x43, 0x34);  /* binary, mode 2, LSB/MSB, ch 0 */
 249   WRITE_PORT_UCHAR((PU8)0x40, LATCH & 0xff); /* LSB */
 250   WRITE_PORT_UCHAR((PU8)0x40, LATCH >> 8); /* MSB */
 251
 252   /* Stage 1:  Coarse calibration                                   */
 253
 254   WaitFor8254Wraparound();
 255
 256   delay_count = 1;
 257
 258   do {
 259     delay_count <<= 1;                  /* Next delay count to try */
 260
 261     WaitFor8254Wraparound();
 262
 263     __KeStallExecutionProcessor(delay_count);      /* Do the delay */
 264
 265     CurCount = Read8254Timer();
 266   } while (CurCount > LATCH / 2);
 267
 268   delay_count >>= 1;              /* Get bottom value for delay     */
 269
 270   /* Stage 2:  Fine calibration                                     */
 271
 272   calib_bit = delay_count;        /* Which bit are we going to test */
 273
 274   for(i=0;i<PRECISION;i++) {
 275     calib_bit >>= 1;             /* Next bit to calibrate          */
 276     if(!calib_bit) break;        /* If we have done all bits, stop */
 277
 278     delay_count |= calib_bit;        /* Set the bit in delay_count */
 279
 280     WaitFor8254Wraparound();
 281
 282     __KeStallExecutionProcessor(delay_count);      /* Do the delay */
 283
 284     CurCount = Read8254Timer();
 285     if (CurCount <= LATCH / 2)   /* If a tick has passed, turn the */
 286       delay_count &= ~calib_bit; /* calibrated bit back off        */
 287   }
 288
 289   /* We're finished:  Do the finishing touches                      */
 290   delay_count /= (MILLISEC / 2);   /* Calculate delay_count for 1ms */
 291 }
 292
 293
 294 VOID
 295 SetComponentInformation(HKEY ComponentKey,
 296                         U32 Flags,
 297                         U32 Key,
 298                         U32 Affinity)
 299 {
 300   CM_COMPONENT_INFORMATION CompInfo;
 301   S32 Error;
 302
 303   CompInfo.Flags = Flags;
 304   CompInfo.Version = 0;
 305   CompInfo.Key = Key;
 306   CompInfo.Affinity = Affinity;
 307
 308   /* Set 'Component Information' value */
 309   Error = RegSetValue(ComponentKey,
 310                       "Component Information",
 311                       REG_BINARY,
 312                       (PU8)&CompInfo,
 313                       sizeof(CM_COMPONENT_INFORMATION));
 314   if (Error != ERROR_SUCCESS)
 315     {
 316       DbgPrint((DPRINT_HWDETECT, "RegSetValue() failed (Error %u)\n", (int)Error));
 317     }
 318 }
 319
 320
 321 static VOID
 322 DetectPnpBios(HKEY SystemKey, U32 *BusNumber)
 323 {
 324   PCM_FULL_RESOURCE_DESCRIPTOR FullResourceDescriptor;
 325   PCM_PNP_BIOS_DEVICE_NODE DeviceNode;
 326   PCM_PNP_BIOS_INSTALLATION_CHECK InstData;
 327   char Buffer[80];
 328   HKEY BusKey;
 329   U32 x;
 330   U32 NodeSize = 0;
 331   U32 NodeCount = 0;
 332   U8 NodeNumber;
 333   U32 FoundNodeCount;
 334   int i;
 335   U32 PnpBufferSize;
 336   U32 Size;
 337   char *Ptr;
 338   S32 Error;
 339
 340   InstData = (PCM_PNP_BIOS_INSTALLATION_CHECK)PnpBiosSupported();
 341   if (InstData == NULL || strncmp(InstData->Signature, "$PnP", 4))
 342     {
 343       DbgPrint((DPRINT_HWDETECT, "PnP-BIOS not supported\n"));
 344       return;
 345     }
 346   DbgPrint((DPRINT_HWDETECT, "Signature '%c%c%c%c'\n",
 347             InstData->Signature[0], InstData->Signature[1],
 348             InstData->Signature[2], InstData->Signature[3]));
 349
 350
 351   x = PnpBiosGetDeviceNodeCount(&NodeSize, &NodeCount);
 352   if (x != 0 || NodeSize == 0 || NodeCount == 0)
 353     {
 354       DbgPrint((DPRINT_HWDETECT, "PnP-BIOS failed to enumerate device nodes\n"));
 355       return;
 356     }
 357   DbgPrint((DPRINT_HWDETECT, "PnP-BIOS supported\n"));
 358   DbgPrint((DPRINT_HWDETECT, "MaxNodeSize %u  NodeCount %u\n", NodeSize, NodeCount));
 359   DbgPrint((DPRINT_HWDETECT, "Estimated buffer size %u\n", NodeSize * NodeCount));
 360
 361   /* Create new bus key */
 362   sprintf(Buffer,
 363           "MultifunctionAdapter\\%u", *BusNumber);
 364   Error = RegCreateKey(SystemKey,
 365                        Buffer,
 366                        &BusKey);
 367   if (Error != ERROR_SUCCESS)
 368     {
 369       DbgPrint((DPRINT_HWDETECT, "RegCreateKey() failed (Error %u)\n", (int)Error));
 370       return;
 371     }
 372
 373   /* Increment bus number */
 374   (*BusNumber)++;
 375
 376   /* Set 'Identifier' value */
 377   Error = RegSetValue(BusKey,
 378                       "Identifier",
 379                       REG_SZ,
 380                       (PU8)"PNP BIOS",
 381                       9);
 382   if (Error != ERROR_SUCCESS)
 383     {
 384       DbgPrint((DPRINT_HWDETECT, "RegSetValue() failed (Error %u)\n", (int)Error));
 385       return;
 386     }
 387
 388   /* Set 'Configuration Data' value */
 389   Size = sizeof(CM_FULL_RESOURCE_DESCRIPTOR) + (NodeSize * NodeCount);
 390   FullResourceDescriptor = MmAllocateMemory(Size);
 391   if (FullResourceDescriptor == NULL)
 392     {
 393       DbgPrint((DPRINT_HWDETECT,
 394                 "Failed to allocate resource descriptor\n"));
 395       return;
 396     }
 397   memset(FullResourceDescriptor, 0, Size);
 398
 399   /* Initialize resource descriptor */
 400   FullResourceDescriptor->InterfaceType = Internal;
 401   FullResourceDescriptor->BusNumber = 0;
 402   FullResourceDescriptor->PartialResourceList.Count = 1;
 403   FullResourceDescriptor->PartialResourceList.PartialDescriptors[0].Type =
 404     CmResourceTypeDeviceSpecific;
 405   FullResourceDescriptor->PartialResourceList.PartialDescriptors[0].ShareDisposition =
 406     CmResourceShareUndetermined;
 407 //  FullResourceDescriptor->PartialResourceList.PartialDescriptors[0].Flags =
 408
 409   Ptr = (char *)(((PVOID)&FullResourceDescriptor->PartialResourceList.PartialDescriptors[0]) +
 410                  sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR));
 411
 412   /* Set instalation check data */
 413   memcpy (Ptr, InstData, sizeof(CM_PNP_BIOS_INSTALLATION_CHECK));
 414   Ptr += sizeof(CM_PNP_BIOS_INSTALLATION_CHECK);
 415
 416   /* Copy device nodes */
 417   FoundNodeCount = 0;
 418   PnpBufferSize = sizeof(CM_PNP_BIOS_INSTALLATION_CHECK);
 419   for (i = 0; i < 0xFF; i++)
 420     {
 421       NodeNumber = (U8)i;
 422
 423       x = PnpBiosGetDeviceNode(&NodeNumber, (PVOID)DISKREADBUFFER);
 424       if (x == 0)
 425         {
 426           DeviceNode = (PCM_PNP_BIOS_DEVICE_NODE)DISKREADBUFFER;
 427
 428           DbgPrint((DPRINT_HWDETECT,
 429                     "Node: %u  Size %u (0x%x)\n",
 430                     DeviceNode->Node,
 431                     DeviceNode->Size,
 432                     DeviceNode->Size));
 433 //        printf("Node: %u  Size %u (0x%x)\n",
 434 //               DeviceNode->Node,
 435 //               DeviceNode->Size,
 436 //               DeviceNode->Size);
 437
 438           memcpy (Ptr,
 439                   DeviceNode,
 440                   DeviceNode->Size);
 441
 442           Ptr += DeviceNode->Size;
 443           PnpBufferSize += DeviceNode->Size;
 444
 445           FoundNodeCount++;
 446           if (FoundNodeCount >= NodeCount)
 447             break;
 448         }
 449     }
 450
 451   /* Set real data size */
 452   FullResourceDescriptor->PartialResourceList.PartialDescriptors[0].u.DeviceSpecificData.DataSize =
 453     PnpBufferSize;
 454   Size = sizeof(CM_FULL_RESOURCE_DESCRIPTOR) + PnpBufferSize;
 455
 456   DbgPrint((DPRINT_HWDETECT, "Real buffer size: %u\n", PnpBufferSize));
 457   DbgPrint((DPRINT_HWDETECT, "Resource size: %u\n", Size));
 458
 459   /* Set 'Configuration Data' value */
 460   Error = RegSetValue(BusKey,
 461                       "Configuration Data",
 462                       REG_FULL_RESOURCE_DESCRIPTOR,
 463                       (PU8) FullResourceDescriptor,
 464                       Size);
 465   MmFreeMemory(FullResourceDescriptor);
 466   if (Error != ERROR_SUCCESS)
 467     {
 468       DbgPrint((DPRINT_HWDETECT,
 469                 "RegSetValue(Configuration Data) failed (Error %u)\n",
 470                 (int)Error));
 471     }
 472 }
 473
 474
 475
 476 static VOID
 477 SetHarddiskConfigurationData(HKEY DiskKey,
 478                              U32 DriveNumber)
 479 {
 480   PCM_FULL_RESOURCE_DESCRIPTOR FullResourceDescriptor;
 481   PCM_DISK_GEOMETRY_DEVICE_DATA DiskGeometry;
 482   EXTENDED_GEOMETRY ExtGeometry;
 483   GEOMETRY Geometry;
 484   U32 Size;
 485   S32 Error;
 486
 487   /* Set 'Configuration Data' value */
 488   Size = sizeof(CM_FULL_RESOURCE_DESCRIPTOR) +
 489          sizeof(CM_DISK_GEOMETRY_DEVICE_DATA);
 490   FullResourceDescriptor = MmAllocateMemory(Size);
 491   if (FullResourceDescriptor == NULL)
 492     {
 493       DbgPrint((DPRINT_HWDETECT,
 494                 "Failed to allocate a full resource descriptor\n"));
 495       return;
 496     }
 497
 498   memset(FullResourceDescriptor, 0, Size);
 499   FullResourceDescriptor->InterfaceType = InterfaceTypeUndefined;
 500   FullResourceDescriptor->BusNumber = 0;
 501   FullResourceDescriptor->PartialResourceList.Count = 1;
 502   FullResourceDescriptor->PartialResourceList.PartialDescriptors[0].Type =
 503     CmResourceTypeDeviceSpecific;
 504 //  FullResourceDescriptor->PartialResourceList.PartialDescriptors[0].ShareDisposition =
 505 //  FullResourceDescriptor->PartialResourceList.PartialDescriptors[0].Flags =
 506   FullResourceDescriptor->PartialResourceList.PartialDescriptors[0].u.DeviceSpecificData.DataSize =
 507     sizeof(CM_DISK_GEOMETRY_DEVICE_DATA);
 508
 509   /* Get pointer to geometry data */
 510   DiskGeometry = ((PVOID)FullResourceDescriptor) + sizeof(CM_FULL_RESOURCE_DESCRIPTOR);
 511
 512   /* Get the disk geometry */
 513   ExtGeometry.Size = sizeof(EXTENDED_GEOMETRY);
 514   if (DiskGetExtendedDriveParameters(DriveNumber, &ExtGeometry, ExtGeometry.Size))
 515     {
 516       DiskGeometry->BytesPerSector = ExtGeometry.BytesPerSector;
 517       DiskGeometry->NumberOfCylinders = ExtGeometry.Cylinders;
 518       DiskGeometry->SectorsPerTrack = ExtGeometry.SectorsPerTrack;
 519       DiskGeometry->NumberOfHeads = ExtGeometry.Heads;
 520     }
 521   else if(DiskGetDriveParameters(DriveNumber, &Geometry))
 522     {
 523       DiskGeometry->BytesPerSector = Geometry.BytesPerSector;
 524       DiskGeometry->NumberOfCylinders = Geometry.Cylinders;
 525       DiskGeometry->SectorsPerTrack = Geometry.Sectors;
 526       DiskGeometry->NumberOfHeads = Geometry.Heads;
 527     }
 528   else
 529     {
 530       DbgPrint((DPRINT_HWDETECT, "Reading disk geometry failed\n"));
 531       MmFreeMemory(FullResourceDescriptor);
 532       return;
 533     }
 534   DbgPrint((DPRINT_HWDETECT,
 535            "Disk %x: %u Cylinders  %u Heads  %u Sectors  %u Bytes\n",
 536            DriveNumber,
 537            DiskGeometry->NumberOfCylinders,
 538            DiskGeometry->NumberOfHeads,
 539            DiskGeometry->SectorsPerTrack,
 540            DiskGeometry->BytesPerSector));
 541
 542   Error = RegSetValue(DiskKey,
 543                       "Configuration Data",
 544                       REG_FULL_RESOURCE_DESCRIPTOR,
 545                       (PU8) FullResourceDescriptor,
 546                       Size);
 547   MmFreeMemory(FullResourceDescriptor);
 548   if (Error != ERROR_SUCCESS)
 549     {
 550       DbgPrint((DPRINT_HWDETECT,
 551                 "RegSetValue(Configuration Data) failed (Error %u)\n",
 552                 (int)Error));
 553     }
 554 }
 555
 556
 557 static VOID
 558 SetHarddiskIdentifier(HKEY DiskKey,
 559                       U32 DriveNumber)
 560 {
 561   PMASTER_BOOT_RECORD Mbr;
 562   U32 *Buffer;
 563   U32 i;
 564   U32 Checksum;
 565   U32 Signature;
 566   char Identifier[20];
 567   S32 Error;
 568
 569   /* Read the MBR */
 570   if (!DiskReadLogicalSectors(DriveNumber, 0ULL, 1, (PVOID)DISKREADBUFFER))
 571     {
 572       DbgPrint((DPRINT_HWDETECT, "Reading MBR failed\n"));
 573       return;
 574     }
 575
 576   Buffer = (U32*)DISKREADBUFFER;
 577   Mbr = (PMASTER_BOOT_RECORD)DISKREADBUFFER;
 578
 579   Signature =  Mbr->Signature;
 580   DbgPrint((DPRINT_HWDETECT, "Signature: %x\n", Signature));
 581
 582   /* Calculate the MBR checksum */
 583   Checksum = 0;
 584   for (i = 0; i < 128; i++)
 585     {
 586       Checksum += Buffer[i];
 587     }
 588   Checksum = ~Checksum + 1;
 589   DbgPrint((DPRINT_HWDETECT, "Checksum: %x\n", Checksum));
 590
 591   /* Convert checksum and signature to identifier string */
 592   Identifier[0] = Hex[(Checksum >> 28) & 0x0F];
 593   Identifier[1] = Hex[(Checksum >> 24) & 0x0F];
 594   Identifier[2] = Hex[(Checksum >> 20) & 0x0F];
 595   Identifier[3] = Hex[(Checksum >> 16) & 0x0F];
 596   Identifier[4] = Hex[(Checksum >> 12) & 0x0F];
 597   Identifier[5] = Hex[(Checksum >> 8) & 0x0F];
 598   Identifier[6] = Hex[(Checksum >> 4) & 0x0F];
 599   Identifier[7] = Hex[Checksum & 0x0F];
 600   Identifier[8] = '-';
 601   Identifier[9] = Hex[(Signature >> 28) & 0x0F];
 602   Identifier[10] = Hex[(Signature >> 24) & 0x0F];
 603   Identifier[11] = Hex[(Signature >> 20) & 0x0F];
 604   Identifier[12] = Hex[(Signature >> 16) & 0x0F];
 605   Identifier[13] = Hex[(Signature >> 12) & 0x0F];
 606   Identifier[14] = Hex[(Signature >> 8) & 0x0F];
 607   Identifier[15] = Hex[(Signature >> 4) & 0x0F];
 608   Identifier[16] = Hex[Signature & 0x0F];
 609   Identifier[17] = '-';
 610   Identifier[18] = 'A';
 611   Identifier[19] = 0;
 612   DbgPrint((DPRINT_HWDETECT, "Identifier: %xsn", Identifier));
 613
 614   /* Set identifier */
 615   Error = RegSetValue(DiskKey,
 616                       "Identifier",
 617                       REG_SZ,
 618                       (PU8) Identifier,
 619                       20);
 620   if (Error != ERROR_SUCCESS)
 621     {
 622       DbgPrint((DPRINT_HWDETECT,
 623                 "RegSetValue(Identifier) failed (Error %u)\n",
 624                 (int)Error));
 625     }
 626 }
 627
 628
 629 static VOID
 630 DetectBiosDisks(HKEY SystemKey,
 631                 HKEY BusKey)
 632 {
 633   PCM_FULL_RESOURCE_DESCRIPTOR FullResourceDescriptor;
 634   PCM_INT13_DRIVE_PARAMETER Int13Drives;
 635   GEOMETRY Geometry;
 636   CHAR Buffer[80];
 637   HKEY DiskKey;
 638   U32 DiskCount;
 639   U32 Size;
 640   U32 i;
 641   S32 Error;
 642
 643   /* Count the number of visible drives */
 644   DiskReportError(FALSE);
 645   DiskCount = 0;
 646   while (DiskReadLogicalSectors(0x80 + DiskCount, 0ULL, 1, (PVOID)DISKREADBUFFER))
 647     {
 648       DiskCount++;
 649     }
 650   DiskReportError(TRUE);
 651   DbgPrint((DPRINT_HWDETECT, "BIOS reports %d harddisk%s\n",
 652             (int)DiskCount, (DiskCount == 1) ? "": "s"));
 653
 654   /* Allocate resource descriptor */
 655   Size = sizeof(CM_FULL_RESOURCE_DESCRIPTOR) +
 656          sizeof(CM_INT13_DRIVE_PARAMETER) * DiskCount;
 657   FullResourceDescriptor = MmAllocateMemory(Size);
 658   if (FullResourceDescriptor == NULL)
 659     {
 660       DbgPrint((DPRINT_HWDETECT,
 661                 "Failed to allocate resource descriptor\n"));
 662       return;
 663     }
 664
 665   /* Initialize resource descriptor */
 666   memset(FullResourceDescriptor, 0, Size);
 667   FullResourceDescriptor->InterfaceType = InterfaceTypeUndefined;
 668   FullResourceDescriptor->BusNumber = -1;
 669   FullResourceDescriptor->PartialResourceList.Count = 1;
 670   FullResourceDescriptor->PartialResourceList.PartialDescriptors[0].Type =
 671     CmResourceTypeDeviceSpecific;
 672 //  FullResourceDescriptor->PartialResourceList.PartialDescriptors[0].ShareDisposition =
 673 //  FullResourceDescriptor->PartialResourceList.PartialDescriptors[0].Flags =
 674   FullResourceDescriptor->PartialResourceList.PartialDescriptors[0].u.DeviceSpecificData.DataSize =
 675     sizeof(CM_INT13_DRIVE_PARAMETER) * DiskCount;
 676
 677   /* Get harddisk Int13 geometry data */
 678   Int13Drives = ((PVOID)FullResourceDescriptor) + sizeof(CM_FULL_RESOURCE_DESCRIPTOR);
 679   for (i = 0; i < DiskCount; i++)
 680     {
 681       if (DiskGetDriveParameters(0x80 + i, &Geometry))
 682         {
 683           Int13Drives[i].DriveSelect = 0x80 + i;
 684           Int13Drives[i].MaxCylinders = Geometry.Cylinders - 1;
 685           Int13Drives[i].SectorsPerTrack = Geometry.Sectors;
 686           Int13Drives[i].MaxHeads = Geometry.Heads - 1;
 687           Int13Drives[i].NumberDrives = DiskCount;
 688
 689           DbgPrint((DPRINT_HWDETECT,
 690                     "Disk %x: %u Cylinders  %u Heads  %u Sectors  %u Bytes\n",
 691                     0x80 + i,
 692                     Geometry.Cylinders - 1,
 693                     Geometry.Heads -1,
 694                     Geometry.Sectors,
 695                     Geometry.BytesPerSector));
 696         }
 697     }
 698
 699   /* Set 'Configuration Data' value */
 700   Error = RegSetValue(SystemKey,
 701                       "Configuration Data",
 702                       REG_FULL_RESOURCE_DESCRIPTOR,
 703                       (PU8) FullResourceDescriptor,
 704                       Size);
 705   MmFreeMemory(FullResourceDescriptor);
 706   if (Error != ERROR_SUCCESS)
 707     {
 708       DbgPrint((DPRINT_HWDETECT,
 709                 "RegSetValue(Configuration Data) failed (Error %u)\n",
 710                 (int)Error));
 711       return;
 712     }
 713
 714   /* Create and fill subkey for each harddisk */
 715   for (i = 0; i < DiskCount; i++)
 716     {
 717       /* Create disk key */
 718       sprintf (Buffer,
 719                "DiskController\\0\\DiskPeripheral\\%u",
 720                i);
 721
 722       Error = RegCreateKey(BusKey,
 723                            Buffer,
 724                            &DiskKey);
 725       if (Error != ERROR_SUCCESS)
 726         {
 727           DbgPrint((DPRINT_HWDETECT, "Failed to create drive key\n"));
 728           continue;
 729         }
 730       DbgPrint((DPRINT_HWDETECT, "Created key: %s\n", Buffer));
 731
 732       /* Set disk values */
 733       SetHarddiskConfigurationData(DiskKey, 0x80 + i);
 734       SetHarddiskIdentifier(DiskKey, 0x80 + i);
 735     }
 736 }
 737
 738
 739 static U32
 740 GetFloppyCount(VOID)
 741 {
 742   U8 Data;
 743
 744   WRITE_PORT_UCHAR((PUCHAR)0x70, 0x10);
 745   Data = READ_PORT_UCHAR((PUCHAR)0x71);
 746
 747   return ((Data & 0xF0) ? 1 : 0) + ((Data & 0x0F) ? 1 : 0);
 748 }
 749
 750
 751 static U8
 752 GetFloppyType(U8 DriveNumber)
 753 {
 754   U8 Data;
 755
 756   WRITE_PORT_UCHAR((PUCHAR)0x70, 0x10);
 757   Data = READ_PORT_UCHAR((PUCHAR)0x71);
 758
 759   if (DriveNumber == 0)
 760     return Data >> 4;
 761   else if (DriveNumber == 1)
 762     return Data & 0x0F;
 763
 764   return 0;
 765 }
 766
 767
 768 static PVOID
 769 GetInt1eTable(VOID)
 770 {
 771   PU16 SegPtr = (PU16)0x7A;
 772   PU16 OfsPtr = (PU16)0x78;
 773
 774   return (PVOID)(((U32)(*SegPtr)) << 4) + (U32)(*OfsPtr);
 775 }
 776
 777
 778 static VOID
 779 DetectBiosFloppyPeripheral(HKEY ControllerKey)
 780 {
 781   PCM_FULL_RESOURCE_DESCRIPTOR FullResourceDescriptor;
 782   PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
 783   PCM_FLOPPY_DEVICE_DATA FloppyData;
 784   char KeyName[32];
 785   char Identifier[20];
 786   HKEY PeripheralKey;
 787   U32 Size;
 788   S32 Error;
 789   U32 FloppyNumber;
 790   U8 FloppyType;
 791   U32 MaxDensity[6] = {0, 360, 1200, 720, 1440, 2880};
 792   PU8 Ptr;
 793
 794   for (FloppyNumber = 0; FloppyNumber < 2; FloppyNumber++)
 795   {
 796     FloppyType = GetFloppyType(FloppyNumber);
 797
 798     if ((FloppyType > 5) || (FloppyType == 0))
 799       continue;
 800
 801     DiskResetController(FloppyNumber);
 802
 803     Ptr = GetInt1eTable();
 804
 805     sprintf(KeyName, "FloppyDiskPeripheral\\%u", FloppyNumber);
 806
 807     Error = RegCreateKey(ControllerKey,
 808                          "FloppyDiskPeripheral\\0",
 809                          &PeripheralKey);
 810     if (Error != ERROR_SUCCESS)
 811     {
 812       DbgPrint((DPRINT_HWDETECT, "Failed to create peripheral key\n"));
 813       return;
 814     }
 815
 816     DbgPrint((DPRINT_HWDETECT, "Created key: %s\n", KeyName));
 817
 818     /* Set 'ComponentInformation' value */
 819     SetComponentInformation(PeripheralKey,
 820                             0x0,
 821                             FloppyNumber,
 822                             0xFFFFFFFF);
 823
 824     Size = sizeof(CM_FULL_RESOURCE_DESCRIPTOR) +
 825            sizeof(CM_FLOPPY_DEVICE_DATA);
 826     FullResourceDescriptor = MmAllocateMemory(Size);
 827     if (FullResourceDescriptor == NULL)
 828     {
 829       DbgPrint((DPRINT_HWDETECT,
 830                 "Failed to allocate resource descriptor\n"));
 831       return;
 832     }
 833
 834     memset(FullResourceDescriptor, 0, Size);
 835     FullResourceDescriptor->InterfaceType = Isa;
 836     FullResourceDescriptor->BusNumber = 0;
 837     FullResourceDescriptor->PartialResourceList.Count = 1;
 838
 839     PartialDescriptor = &FullResourceDescriptor->PartialResourceList.PartialDescriptors[0];
 840     PartialDescriptor->Type = CmResourceTypeDeviceSpecific;
 841     PartialDescriptor->ShareDisposition = CmResourceShareUndetermined;
 842     PartialDescriptor->u.DeviceSpecificData.DataSize = sizeof(CM_FLOPPY_DEVICE_DATA);
 843
 844     FloppyData = ((PVOID)FullResourceDescriptor) + sizeof(CM_FULL_RESOURCE_DESCRIPTOR);
 845     FloppyData->Version = 2;
 846     FloppyData->Revision = 0;
 847     FloppyData->MaxDensity = MaxDensity[FloppyType];
 848     FloppyData->MountDensity = 0;
 849     RtlCopyMemory(&FloppyData->StepRateHeadUnloadTime,
 850                   Ptr,
 851                   11);
 852     FloppyData->MaximumTrackValue = (FloppyType == 1) ? 39 : 79;
 853     FloppyData->DataTransferRate = 0;
 854
 855     /* Set 'Configuration Data' value */
 856     Error = RegSetValue(PeripheralKey,
 857                         "Configuration Data",
 858                         REG_FULL_RESOURCE_DESCRIPTOR,
 859                         (PU8) FullResourceDescriptor,
 860                         Size);
 861     MmFreeMemory(FullResourceDescriptor);
 862     if (Error != ERROR_SUCCESS)
 863     {
 864       DbgPrint((DPRINT_HWDETECT,
 865                 "RegSetValue(Configuration Data) failed (Error %u)\n",
 866                 (int)Error));
 867       return;
 868     }
 869
 870     /* Set 'Identifier' value */
 871     sprintf(Identifier, "FLOPPY%u", FloppyNumber + 1);
 872     Error = RegSetValue(PeripheralKey,
 873                         "Identifier",
 874                         REG_SZ,
 875                         (PU8)Identifier,
 876                         strlen(Identifier) + 1);
 877     if (Error != ERROR_SUCCESS)
 878     {
 879       DbgPrint((DPRINT_HWDETECT,
 880                 "RegSetValue() failed (Error %u)\n",
 881                 (int)Error));
 882     }
 883   }
 884 }
 885
 886
 887 static VOID
 888 DetectBiosFloppyController(HKEY SystemKey,
 889                            HKEY BusKey)
 890 {
 891   PCM_FULL_RESOURCE_DESCRIPTOR FullResourceDescriptor;
 892   PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
 893   HKEY ControllerKey;
 894   U32 Size;
 895   S32 Error;
 896   U32 FloppyCount;
 897
 898   FloppyCount = GetFloppyCount();
 899   DbgPrint((DPRINT_HWDETECT,
 900             "Floppy count: %u\n",
 901             FloppyCount));
 902
 903   if (FloppyCount == 0)
 904     return;
 905
 906   Error = RegCreateKey(BusKey,
 907                        "DiskController\\0",
 908                        &ControllerKey);
 909   if (Error != ERROR_SUCCESS)
 910     {
 911       DbgPrint((DPRINT_HWDETECT, "Failed to create controller key\n"));
 912       return;
 913     }
 914
 915   DbgPrint((DPRINT_HWDETECT, "Created key: DiskController\\0\n"));
 916
 917   /* Set 'ComponentInformation' value */
 918   SetComponentInformation(ControllerKey,
 919                           0x64,
 920                           0,
 921                           0xFFFFFFFF);
 922
 923   Size = sizeof(CM_FULL_RESOURCE_DESCRIPTOR) +
 924          2 * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
 925   FullResourceDescriptor = MmAllocateMemory(Size);
 926   if (FullResourceDescriptor == NULL)
 927     {
 928       DbgPrint((DPRINT_HWDETECT,
 929                 "Failed to allocate resource descriptor\n"));
 930       return;
 931     }
 932   memset(FullResourceDescriptor, 0, Size);
 933
 934   /* Initialize resource descriptor */
 935   FullResourceDescriptor->InterfaceType = Isa;
 936   FullResourceDescriptor->BusNumber = 0;
 937   FullResourceDescriptor->PartialResourceList.Count = 3;
 938
 939   /* Set IO Port */
 940   PartialDescriptor = &FullResourceDescriptor->PartialResourceList.PartialDescriptors[0];
 941   PartialDescriptor->Type = CmResourceTypePort;
 942   PartialDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
 943   PartialDescriptor->Flags = CM_RESOURCE_PORT_IO;
 944   PartialDescriptor->u.Port.Start = (U64)0x03F0;
 945   PartialDescriptor->u.Port.Length = 8;
 946
 947   /* Set Interrupt */
 948   PartialDescriptor = &FullResourceDescriptor->PartialResourceList.PartialDescriptors[1];
 949   PartialDescriptor->Type = CmResourceTypeInterrupt;
 950   PartialDescriptor->ShareDisposition = CmResourceShareUndetermined;
 951   PartialDescriptor->Flags = CM_RESOURCE_INTERRUPT_LATCHED;
 952   PartialDescriptor->u.Interrupt.Level = 6;
 953   PartialDescriptor->u.Interrupt.Vector = 6;
 954   PartialDescriptor->u.Interrupt.Affinity = 0xFFFFFFFF;
 955
 956   /* Set DMA channel */
 957   PartialDescriptor = &FullResourceDescriptor->PartialResourceList.PartialDescriptors[2];
 958   PartialDescriptor->Type = CmResourceTypeDma;
 959   PartialDescriptor->ShareDisposition = CmResourceShareUndetermined;
 960   PartialDescriptor->Flags = 0;
 961   PartialDescriptor->u.Dma.Channel = 2;
 962   PartialDescriptor->u.Dma.Port = 0;
 963
 964   /* Set 'Configuration Data' value */
 965   Error = RegSetValue(ControllerKey,
 966                       "Configuration Data",
 967                       REG_FULL_RESOURCE_DESCRIPTOR,
 968                       (PU8) FullResourceDescriptor,
 969                       Size);
 970   MmFreeMemory(FullResourceDescriptor);
 971   if (Error != ERROR_SUCCESS)
 972     {
 973       DbgPrint((DPRINT_HWDETECT,
 974                 "RegSetValue(Configuration Data) failed (Error %u)\n",
 975                 (int)Error));
 976       return;
 977     }
 978
 979   DetectBiosFloppyPeripheral(ControllerKey);
 980 }
 981
 982
 983 static VOID
 984 InitializeSerialPort(U32 Port,
 985                      U32 LineControl)
 986 {
 987   WRITE_PORT_UCHAR((PUCHAR)Port + 3, 0x80);  /* set DLAB on   */
 988   WRITE_PORT_UCHAR((PUCHAR)Port,     0x60);  /* speed LO byte */
 989   WRITE_PORT_UCHAR((PUCHAR)Port + 1, 0);     /* speed HI byte */
 990   WRITE_PORT_UCHAR((PUCHAR)Port + 3, LineControl);
 991   WRITE_PORT_UCHAR((PUCHAR)Port + 1, 0);     /* set comm and DLAB to 0 */
 992   WRITE_PORT_UCHAR((PUCHAR)Port + 4, 0x09);  /* DR int enable */
 993   READ_PORT_UCHAR((PUCHAR)Port + 5);  /* clear error bits */
 994 }
 995
 996
 997 static U32
 998 DetectSerialMouse(U32 Port)
 999 {
1000   CHAR Buffer[4];
1001   U32 i;
1002   U32 TimeOut = 200;
1003   U8 LineControl;
1004
1005   /* Shutdown mouse or something like that */
1006   LineControl = READ_PORT_UCHAR((PUCHAR)Port + 4);
1007   WRITE_PORT_UCHAR((PUCHAR)Port + 4, (LineControl & ~0x02) | 0x01);
1008   KeStallExecutionProcessor(100000);
1009
1010   /* Clear buffer */
1011   while (READ_PORT_UCHAR((PUCHAR)Port + 5) & 0x01)
1012     READ_PORT_UCHAR((PUCHAR)Port);
1013
1014   /*
1015    * Send modem control with 'Data Terminal Ready', 'Request To Send' and
1016    * 'Output Line 2' message. This enables mouse to identify.
1017    */
1018   WRITE_PORT_UCHAR((PUCHAR)Port + 4, 0x0b);
1019
1020   /* Wait 10 milliseconds for the mouse getting ready */
1021   KeStallExecutionProcessor(10000);
1022
1023   /* Read first four bytes, which contains Microsoft Mouse signs */
1024   for (i = 0; i < 4; i++)
1025     {
1026       while (((READ_PORT_UCHAR((PUCHAR)Port + 5) & 1) == 0) && (TimeOut > 0))
1027         {
1028           KeStallExecutionProcessor(1000);
1029           --TimeOut;
1030           if (TimeOut == 0)
1031             return MOUSE_TYPE_NONE;
1032         }
1033       Buffer[i] = READ_PORT_UCHAR((PUCHAR)Port);
1034     }
1035
1036   DbgPrint((DPRINT_HWDETECT,
1037             "Mouse data: %x %x %x %x\n",
1038             Buffer[0],Buffer[1],Buffer[2],Buffer[3]));
1039
1040   /* Check that four bytes for signs */
1041   for (i = 0; i < 4; ++i)
1042     {
1043       if (Buffer[i] == 'B')
1044         {
1045           /* Sign for Microsoft Ballpoint */
1046 //        DbgPrint("Microsoft Ballpoint device detected\n");
1047 //        DbgPrint("THIS DEVICE IS NOT SUPPORTED, YET\n");
1048           return MOUSE_TYPE_NONE;
1049         }
1050       else if (Buffer[i] == 'M')
1051         {
1052           /* Sign for Microsoft Mouse protocol followed by button specifier */
1053           if (i == 3)
1054             {
1055               /* Overflow Error */
1056               return MOUSE_TYPE_NONE;
1057             }
1058
1059           switch (Buffer[i + 1])
1060             {
1061               case '3':
1062                 DbgPrint((DPRINT_HWDETECT,
1063                           "Microsoft Mouse with 3-buttons detected\n"));
1064                 return MOUSE_TYPE_LOGITECH;
1065
1066               case 'Z':
1067                 DbgPrint((DPRINT_HWDETECT,
1068                           "Microsoft Wheel Mouse detected\n"));
1069                 return MOUSE_TYPE_WHEELZ;
1070
1071               /* case '2': */
1072               default:
1073                 DbgPrint((DPRINT_HWDETECT,
1074                           "Microsoft Mouse with 2-buttons detected\n"));
1075                 return MOUSE_TYPE_MICROSOFT;
1076             }
1077         }
1078     }
1079
1080   return MOUSE_TYPE_NONE;
1081 }
1082
1083
1084 static U32
1085 GetSerialMousePnpId(U32 Port, char *Buffer)
1086 {
1087   U32 TimeOut;
1088   U32 i = 0;
1089   char c;
1090   char x;
1091
1092   WRITE_PORT_UCHAR((PUCHAR)Port + 4, 0x09);
1093
1094   /* Wait 10 milliseconds for the mouse getting ready */
1095   KeStallExecutionProcessor(10000);
1096
1097   WRITE_PORT_UCHAR((PUCHAR)Port + 4, 0x0b);
1098
1099   KeStallExecutionProcessor(10000);
1100
1101   for (;;)
1102     {
1103       TimeOut = 200;
1104       while (((READ_PORT_UCHAR((PUCHAR)Port + 5) & 1) == 0) && (TimeOut > 0))
1105         {
1106           KeStallExecutionProcessor(1000);
1107           --TimeOut;
1108           if (TimeOut == 0)
1109             {
1110               return 0;
1111             }
1112         }
1113
1114       c = READ_PORT_UCHAR((PUCHAR)Port);
1115       if (c == 0x08 || c == 0x28)
1116         break;
1117     }
1118
1119   Buffer[i++] = c;
1120   x = c + 1;
1121
1122   for (;;)
1123     {
1124       TimeOut = 200;
1125       while (((READ_PORT_UCHAR((PUCHAR)Port + 5) & 1) == 0) && (TimeOut > 0))
1126         {
1127           KeStallExecutionProcessor(1000);
1128           --TimeOut;
1129           if (TimeOut == 0)
1130             return 0;
1131         }
1132       c = READ_PORT_UCHAR((PUCHAR)Port);
1133       Buffer[i++] = c;
1134       if (c == x)
1135         break;
1136       if (i >= 256)
1137         break;
1138     }
1139
1140   return i;
1141 }
1142
1143
1144 static VOID
1145 DetectSerialPointerPeripheral(HKEY ControllerKey,
1146                               U32 Base)
1147 {
1148   CM_FULL_RESOURCE_DESCRIPTOR FullResourceDescriptor;
1149   char Buffer[256];
1150   char Identifier[256];
1151   HKEY PeripheralKey;
1152   U32 MouseType;
1153   U32 Length;
1154   U32 i;
1155   U32 j;
1156   S32 Error;
1157
1158   DbgPrint((DPRINT_HWDETECT,
1159             "DetectSerialPointerPeripheral()\n"));
1160
1161   Identifier[0] = 0;
1162
1163   InitializeSerialPort(Base, 2);
1164   MouseType = DetectSerialMouse(Base);
1165
1166   if (MouseType != MOUSE_TYPE_NONE)
1167     {
1168       Length = GetSerialMousePnpId(Base, Buffer);
1169       DbgPrint((DPRINT_HWDETECT,
1170                 "PnP ID length: %u\n",
1171                 Length));
1172
1173       if (Length != 0)
1174         {
1175           /* Convert PnP sting to ASCII */
1176           if (Buffer[0] == 0x08)
1177             {
1178               for (i = 0; i < Length; i++)
1179                 Buffer[i] += 0x20;
1180             }
1181           Buffer[Length] = 0;
1182
1183           DbgPrint((DPRINT_HWDETECT,
1184                     "PnP ID string: %s\n",
1185                     Buffer));
1186
1187           /* Copy PnpId string */
1188           memcpy(&Identifier[0],
1189                  &Buffer[3],
1190                  7);
1191           memcpy(&Identifier[7],
1192                  " - ",
1193                  4);
1194
1195           /* Skip device serial number */
1196           i = 10;
1197           if (Buffer[i] == '\\')
1198             {
1199               for (j = ++i; i < Length; ++i)
1200                 {
1201                   if (Buffer[i] == '\\')
1202                     break;
1203                 }
1204               if (i >= Length)
1205                 i -= 3;
1206             }
1207
1208           /* Skip PnP class */
1209           if (Buffer[i] == '\\')
1210             {
1211               for (j = ++i; i < Length; ++i)
1212                 {
1213                   if (Buffer[i] == '\\')
1214                     break;
1215                 }
1216
1217               if (i >= Length)
1218                 i -= 3;
1219             }
1220
1221           /* Skip compatible PnP Id */
1222           if (Buffer[i] == '\\')
1223             {
1224               for (j = ++i; i < Length; ++i)
1225                 {
1226                   if (Buffer[i] == '\\')
1227                     break;
1228                 }
1229               if (Buffer[j] == '*')
1230                 ++j;
1231               if (i >= Length)
1232                 i -= 3;
1233             }
1234
1235           /* Get product description */
1236           if (Buffer[i] == '\\')
1237             {
1238               for (j = ++i; i < Length; ++i)
1239                 {
1240                   if (Buffer[i] == ';')
1241                     break;
1242                 }
1243               if (i >= Length)
1244                 i -= 3;
1245               if (i > j + 1)
1246                 {
1247                   memcpy(&Identifier[10],
1248                          &Buffer[j],
1249                          i - j);
1250                   Identifier[10 + (i-j)] = 0;
1251                 }
1252             }
1253
1254           DbgPrint((DPRINT_HWDETECT,
1255                     "Identifier string: %s\n",
1256                     Identifier));
1257         }
1258
1259       if (Length == 0 || strlen(Identifier) < 11)
1260         {
1261           switch (MouseType)
1262             {
1263               case MOUSE_TYPE_LOGITECH:
1264                 strcpy (Identifier,
1265                         "LOGITECH SERIAL MOUSE");
1266                 break;
1267
1268               case MOUSE_TYPE_WHEELZ:
1269                 strcpy (Identifier,
1270                         "MICROSOFT SERIAL MOUSE WITH WHEEL");
1271                 break;
1272
1273               case MOUSE_TYPE_MICROSOFT:
1274               default:
1275                 strcpy (Identifier,
1276                         "MICROSOFT SERIAL MOUSE");
1277                 break;
1278             }
1279         }
1280
1281       /* Create 'PointerPeripheral' key */
1282       Error = RegCreateKey(ControllerKey,
1283                            "PointerPeripheral\\0",
1284                            &PeripheralKey);
1285       if (Error != ERROR_SUCCESS)
1286         {
1287           DbgPrint((DPRINT_HWDETECT,
1288                     "Failed to create peripheral key\n"));
1289           return;
1290         }
1291       DbgPrint((DPRINT_HWDETECT,
1292                 "Created key: PointerPeripheral\\0\n"));
1293
1294       /* Set 'ComponentInformation' value */
1295       SetComponentInformation(PeripheralKey,
1296                               0x20,
1297                               0,
1298                               0xFFFFFFFF);
1299
1300       /* Set 'Configuration Data' value */
1301       memset(&FullResourceDescriptor, 0, sizeof(CM_FULL_RESOURCE_DESCRIPTOR));
1302       FullResourceDescriptor.InterfaceType = Isa;
1303       FullResourceDescriptor.BusNumber = 0;
1304       FullResourceDescriptor.PartialResourceList.Count = 0;
1305
1306       Error = RegSetValue(PeripheralKey,
1307                           "Configuration Data",
1308                           REG_FULL_RESOURCE_DESCRIPTOR,
1309                           (PU8)&FullResourceDescriptor,
1310                           sizeof(CM_FULL_RESOURCE_DESCRIPTOR) -
1311                           sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR));
1312       if (Error != ERROR_SUCCESS)
1313         {
1314           DbgPrint((DPRINT_HWDETECT,
1315                     "RegSetValue(Configuration Data) failed (Error %u)\n",
1316                     (int)Error));
1317         }
1318
1319       /* Set 'Identifier' value */
1320       Error = RegSetValue(PeripheralKey,
1321                           "Identifier",
1322                           REG_SZ,
1323                           (PU8)Identifier,
1324                           strlen(Identifier) + 1);
1325       if (Error != ERROR_SUCCESS)
1326         {
1327           DbgPrint((DPRINT_HWDETECT,
1328                     "RegSetValue() failed (Error %u)\n",
1329                     (int)Error));
1330         }
1331     }
1332 }
1333
1334
1335 static VOID
1336 DetectSerialPorts(HKEY BusKey)
1337 {
1338   PCM_FULL_RESOURCE_DESCRIPTOR FullResourceDescriptor;
1339   PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
1340   PCM_SERIAL_DEVICE_DATA SerialDeviceData;
1341   U32 Base[4] = {0x3F8, 0x2F8, 0x3E8, 0x2E8};
1342   U32 Irq[4] = {4, 3, 4, 3};
1343   char Buffer[80];
1344   U32 ControllerNumber = 0;
1345   HKEY ControllerKey;
1346   U32 i;
1347   S32 Error;
1348   U32 Size;
1349
1350   DbgPrint((DPRINT_HWDETECT, "DetectSerialPorts()\n"));
1351
1352   for (i = 0; i < 4; i++)
1353     {
1354       WRITE_PORT_UCHAR ((PUCHAR)(Base[i] + 4), 0x10);
1355       if (!(READ_PORT_UCHAR((PUCHAR)Base[i] + 6) & 0xf0))
1356         {
1357           DbgPrint((DPRINT_HWDETECT,
1358                     "Found COM%u port at 0x%x\n",
1359                     i + 1,
1360                     Base[i]));
1361
1362           /* Create controller key */
1363           sprintf(Buffer,
1364                   "SerialController\\%u",
1365                   ControllerNumber);
1366
1367           Error = RegCreateKey(BusKey,
1368                                Buffer,
1369                                &ControllerKey);
1370           if (Error != ERROR_SUCCESS)
1371             {
1372               DbgPrint((DPRINT_HWDETECT, "Failed to create controller key\n"));
1373               continue;
1374             }
1375           DbgPrint((DPRINT_HWDETECT, "Created key: %s\n", Buffer));
1376
1377           /* Set 'ComponentInformation' value */
1378           SetComponentInformation(ControllerKey,
1379                                   0x78,
1380                                   ControllerNumber,
1381                                   0xFFFFFFFF);
1382
1383           /* Build full device descriptor */
1384           Size = sizeof(CM_FULL_RESOURCE_DESCRIPTOR) +
1385                  2 * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR) +
1386                  sizeof(CM_SERIAL_DEVICE_DATA);
1387           FullResourceDescriptor = MmAllocateMemory(Size);
1388           if (FullResourceDescriptor == NULL)
1389             {
1390               DbgPrint((DPRINT_HWDETECT,
1391                         "Failed to allocate resource descriptor\n"));
1392               continue;
1393             }
1394           memset(FullResourceDescriptor, 0, Size);
1395
1396           /* Initialize resource descriptor */
1397           FullResourceDescriptor->InterfaceType = Isa;
1398           FullResourceDescriptor->BusNumber = 0;
1399           FullResourceDescriptor->PartialResourceList.Count = 3;
1400
1401           /* Set IO Port */
1402           PartialDescriptor = &FullResourceDescriptor->PartialResourceList.PartialDescriptors[0];
1403           PartialDescriptor->Type = CmResourceTypePort;
1404           PartialDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
1405           PartialDescriptor->Flags = CM_RESOURCE_PORT_IO;
1406           PartialDescriptor->u.Port.Start = (U64)Base[i];
1407           PartialDescriptor->u.Port.Length = 7;
1408
1409           /* Set Interrupt */
1410           PartialDescriptor = &FullResourceDescriptor->PartialResourceList.PartialDescriptors[1];
1411           PartialDescriptor->Type = CmResourceTypeInterrupt;
1412           PartialDescriptor->ShareDisposition = CmResourceShareUndetermined;
1413           PartialDescriptor->Flags = CM_RESOURCE_INTERRUPT_LATCHED;
1414           PartialDescriptor->u.Interrupt.Level = Irq[i];
1415           PartialDescriptor->u.Interrupt.Vector = Irq[i];
1416           PartialDescriptor->u.Interrupt.Affinity = 0xFFFFFFFF;
1417
1418           /* Set serial data (device specific) */
1419           PartialDescriptor = &FullResourceDescriptor->PartialResourceList.PartialDescriptors[2];
1420           PartialDescriptor->Type = CmResourceTypeDeviceSpecific;
1421           PartialDescriptor->ShareDisposition = CmResourceShareUndetermined;
1422           PartialDescriptor->Flags = 0;
1423           PartialDescriptor->u.DeviceSpecificData.DataSize = sizeof(CM_SERIAL_DEVICE_DATA);
1424
1425           SerialDeviceData =
1426            (PCM_SERIAL_DEVICE_DATA)&FullResourceDescriptor->PartialResourceList.PartialDescriptors[3];
1427           SerialDeviceData->BaudClock = 1843200; /* UART Clock frequency (Hertz) */
1428
1429           /* Set 'Configuration Data' value */
1430           Error = RegSetValue(ControllerKey,
1431                               "Configuration Data",
1432                               REG_FULL_RESOURCE_DESCRIPTOR,
1433                               (PU8) FullResourceDescriptor,
1434                               Size);
1435           MmFreeMemory(FullResourceDescriptor);
1436           if (Error != ERROR_SUCCESS)
1437             {
1438               DbgPrint((DPRINT_HWDETECT,
1439                         "RegSetValue(Configuration Data) failed (Error %u)\n",
1440                         (int)Error));
1441             }
1442
1443           /* Set 'Identifier' value */
1444           sprintf(Buffer,
1445                   "COM%u",
1446                   i + 1);
1447           Error = RegSetValue(ControllerKey,
1448                               "Identifier",
1449                               REG_SZ,
1450                               (PU8)Buffer,
1451                               5);
1452           if (Error != ERROR_SUCCESS)
1453             {
1454               DbgPrint((DPRINT_HWDETECT,
1455                         "RegSetValue() failed (Error %u)\n",
1456                         (int)Error));
1457               continue;
1458             }
1459           DbgPrint((DPRINT_HWDETECT,
1460                     "Created value: Identifier %s\n",
1461                     Buffer));
1462
1463           /* Detect serial mouse */
1464           DetectSerialPointerPeripheral(ControllerKey, Base[i]);
1465
1466           ControllerNumber++;
1467         }
1468     }
1469 }
1470
1471
1472 static BOOLEAN
1473 DetectKeyboardDevice(VOID)
1474 {
1475   UCHAR Status;
1476   UCHAR Scancode;
1477
1478   WRITE_PORT_UCHAR((PUCHAR)CONTROLLER_REGISTER_DATA,
1479                    0xF2);
1480
1481   KeStallExecutionProcessor(10000);
1482
1483   Status = READ_PORT_UCHAR((PUCHAR)CONTROLLER_REGISTER_STATUS);
1484   if ((Status & 0x01) != 0x01)
1485     {
1486       /* PC/XT keyboard or no keyboard */
1487       return FALSE;
1488     }
1489
1490   Scancode = READ_PORT_UCHAR((PUCHAR)CONTROLLER_REGISTER_DATA);
1491   if (Scancode != 0xFA)
1492     {
1493       /* No ACK received */
1494       return FALSE;
1495     }
1496
1497   KeStallExecutionProcessor(10000);
1498   Status = READ_PORT_UCHAR((PUCHAR)CONTROLLER_REGISTER_STATUS);
1499   if ((Status & 0x01) != 0x01)
1500     {
1501       /* Found AT keyboard */
1502       return TRUE;
1503     }
1504
1505   Scancode = READ_PORT_UCHAR((PUCHAR)CONTROLLER_REGISTER_DATA);
1506   if (Scancode != 0xAB)
1507     {
1508       /* No 0xAB received */
1509       return FALSE;
1510     }
1511
1512   KeStallExecutionProcessor(10000);
1513   Status = READ_PORT_UCHAR((PUCHAR)CONTROLLER_REGISTER_STATUS);
1514   if ((Status & 0x01) != 0x01)
1515     {
1516       /* No byte in buffer */
1517       return FALSE;
1518     }
1519
1520   Scancode = READ_PORT_UCHAR((PUCHAR)CONTROLLER_REGISTER_DATA);
1521   if (Scancode != 0x41)
1522     {
1523       /* No 0x41 received */
1524       return FALSE;
1525     }
1526
1527   /* Found MF-II keyboard */
1528   return TRUE;
1529 }
1530
1531
1532 static VOID
1533 DetectKeyboardPeripheral(HKEY ControllerKey)
1534 {
1535   PCM_FULL_RESOURCE_DESCRIPTOR FullResourceDescriptor;
1536   PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
1537   PCM_KEYBOARD_DEVICE_DATA KeyboardData;
1538   HKEY PeripheralKey;
1539   char Buffer[80];
1540   U32 Size;
1541   S32 Error;
1542
1543   if (DetectKeyboardDevice())
1544   {
1545     /* Create controller key */
1546     Error = RegCreateKey(ControllerKey,
1547                          "KeyboardPeripheral\\0",
1548                          &PeripheralKey);
1549     if (Error != ERROR_SUCCESS)
1550     {
1551       DbgPrint((DPRINT_HWDETECT, "Failed to create peripheral key\n"));
1552       return;
1553     }
1554     DbgPrint((DPRINT_HWDETECT, "Created key: KeyboardPeripheral\\0\n"));
1555
1556     /* Set 'ComponentInformation' value */
1557     SetComponentInformation(ControllerKey,
1558                             0x28,
1559                             0,
1560                             0xFFFFFFFF);
1561
1562     /* Set 'Configuration Data' value */
1563     Size = sizeof(CM_FULL_RESOURCE_DESCRIPTOR) +
1564            sizeof(CM_KEYBOARD_DEVICE_DATA);
1565     FullResourceDescriptor = MmAllocateMemory(Size);
1566     if (FullResourceDescriptor == NULL)
1567     {
1568       DbgPrint((DPRINT_HWDETECT,
1569                 "Failed to allocate resource descriptor\n"));
1570       return;
1571     }
1572
1573     /* Initialize resource descriptor */
1574     memset(FullResourceDescriptor, 0, Size);
1575     FullResourceDescriptor->InterfaceType = Isa;
1576     FullResourceDescriptor->BusNumber = 0;
1577     FullResourceDescriptor->PartialResourceList.Count = 1;
1578
1579     PartialDescriptor = &FullResourceDescriptor->PartialResourceList.PartialDescriptors[0];
1580     PartialDescriptor->Type = CmResourceTypeDeviceSpecific;
1581     PartialDescriptor->ShareDisposition = CmResourceShareUndetermined;
1582     PartialDescriptor->u.DeviceSpecificData.DataSize = sizeof(CM_KEYBOARD_DEVICE_DATA);
1583
1584     KeyboardData = ((PVOID)FullResourceDescriptor) + sizeof(CM_FULL_RESOURCE_DESCRIPTOR);
1585     KeyboardData->Version = 0;
1586     KeyboardData->Revision = 0;
1587     KeyboardData->Type = 4;
1588     KeyboardData->Subtype = 0;
1589     KeyboardData->KeyboardFlags = 0x20;
1590
1591     /* Set 'Configuration Data' value */
1592     Error = RegSetValue(PeripheralKey,
1593                         "Configuration Data",
1594                         REG_FULL_RESOURCE_DESCRIPTOR,
1595                         (PU8)FullResourceDescriptor,
1596                         Size);
1597     MmFreeMemory(FullResourceDescriptor);
1598     if (Error != ERROR_SUCCESS)
1599     {
1600       DbgPrint((DPRINT_HWDETECT,
1601                 "RegSetValue(Configuration Data) failed (Error %u)\n",
1602                 (int)Error));
1603     }
1604
1605     /* Set 'Identifier' value */
1606     strcpy(Buffer,
1607            "PCAT_ENHANCED");
1608     Error = RegSetValue(ControllerKey,
1609                         "Identifier",
1610                         REG_SZ,
1611                         (PU8)Buffer,
1612                         strlen(Buffer) + 1);
1613     if (Error != ERROR_SUCCESS)
1614     {
1615       DbgPrint((DPRINT_HWDETECT,
1616                 "RegSetValue() failed (Error %u)\n",
1617                 (int)Error));
1618     }
1619   }
1620 }
1621
1622
1623 static VOID
1624 DetectKeyboardController(HKEY BusKey)
1625 {
1626   PCM_FULL_RESOURCE_DESCRIPTOR FullResourceDescriptor;
1627   PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
1628   HKEY ControllerKey;
1629   U32 Size;
1630   S32 Error;
1631
1632   /* Create controller key */
1633   Error = RegCreateKey(BusKey,
1634                        "KeyboardController\\0",
1635                        &ControllerKey);
1636   if (Error != ERROR_SUCCESS)
1637     {
1638       DbgPrint((DPRINT_HWDETECT, "Failed to create controller key\n"));
1639       return;
1640     }
1641   DbgPrint((DPRINT_HWDETECT, "Created key: KeyboardController\\0\n"));
1642
1643   /* Set 'ComponentInformation' value */
1644   SetComponentInformation(ControllerKey,
1645                           0x28,
1646                           0,
1647                           0xFFFFFFFF);
1648
1649   /* Set 'Configuration Data' value */
1650   Size = sizeof(CM_FULL_RESOURCE_DESCRIPTOR) +
1651           2 * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
1652   FullResourceDescriptor = MmAllocateMemory(Size);
1653   if (FullResourceDescriptor == NULL)
1654     {
1655       DbgPrint((DPRINT_HWDETECT,
1656                 "Failed to allocate resource descriptor\n"));
1657       return;
1658     }
1659
1660   /* Initialize resource descriptor */
1661   memset(FullResourceDescriptor, 0, Size);
1662   FullResourceDescriptor->InterfaceType = Isa;
1663   FullResourceDescriptor->BusNumber = 0;
1664   FullResourceDescriptor->PartialResourceList.Count = 3;
1665
1666   /* Set Interrupt */
1667   PartialDescriptor = &FullResourceDescriptor->PartialResourceList.PartialDescriptors[0];
1668   PartialDescriptor->Type = CmResourceTypeInterrupt;
1669   PartialDescriptor->ShareDisposition = CmResourceShareUndetermined;
1670   PartialDescriptor->Flags = CM_RESOURCE_INTERRUPT_LATCHED;
1671   PartialDescriptor->u.Interrupt.Level = 1;
1672   PartialDescriptor->u.Interrupt.Vector = 1;
1673   PartialDescriptor->u.Interrupt.Affinity = 0xFFFFFFFF;
1674
1675   /* Set IO Port 0x60 */
1676   PartialDescriptor = &FullResourceDescriptor->PartialResourceList.PartialDescriptors[1];
1677   PartialDescriptor->Type = CmResourceTypePort;
1678   PartialDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
1679   PartialDescriptor->Flags = CM_RESOURCE_PORT_IO;
1680   PartialDescriptor->u.Port.Start = (U64)0x60;
1681   PartialDescriptor->u.Port.Length = 1;
1682
1683   /* Set IO Port 0x64 */
1684   PartialDescriptor = &FullResourceDescriptor->PartialResourceList.PartialDescriptors[2];
1685   PartialDescriptor->Type = CmResourceTypePort;
1686   PartialDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
1687   PartialDescriptor->Flags = CM_RESOURCE_PORT_IO;
1688   PartialDescriptor->u.Port.Start = (U64)0x64;
1689   PartialDescriptor->u.Port.Length = 1;
1690
1691   /* Set 'Configuration Data' value */
1692   Error = RegSetValue(ControllerKey,
1693                       "Configuration Data",
1694                       REG_FULL_RESOURCE_DESCRIPTOR,
1695                       (PU8)FullResourceDescriptor,
1696                       Size);
1697   MmFreeMemory(FullResourceDescriptor);
1698   if (Error != ERROR_SUCCESS)
1699     {
1700       DbgPrint((DPRINT_HWDETECT,
1701                 "RegSetValue(Configuration Data) failed (Error %u)\n",
1702                 (int)Error));
1703       return;
1704     }
1705
1706   DetectKeyboardPeripheral(ControllerKey);
1707 }
1708
1709
1710 static VOID
1711 PS2ControllerWait(VOID)
1712 {
1713   U32 Timeout;
1714   U8 Status;
1715
1716   for (Timeout = 0; Timeout < CONTROLLER_TIMEOUT; Timeout++)
1717     {
1718       Status = READ_PORT_UCHAR((PUCHAR)CONTROLLER_REGISTER_STATUS);
1719       if ((Status & CONTROLLER_STATUS_INPUT_BUFFER_FULL) == 0)
1720         return;
1721
1722       /* Sleep for one millisecond */
1723       KeStallExecutionProcessor(1000);
1724     }
1725 }
1726
1727
1728 static BOOLEAN
1729 DetectPS2AuxPort(VOID)
1730 {
1731   U32 Loops;
1732   U8 Scancode;
1733   U8 Status;
1734
1735   /* Put the value 0x5A in the output buffer using the
1736    * "WriteAuxiliary Device Output Buffer" command (0xD3).
1737    * Poll the Status Register for a while to see if the value really turns up
1738    * in the Data Register. If the KEYBOARD_STATUS_MOUSE_OBF bit is also set
1739    * to 1 in the Status Register, we assume this controller has an
1740    *  Auxiliary Port (a.k.a. Mouse Port).
1741    */
1742   PS2ControllerWait();
1743   WRITE_PORT_UCHAR((PUCHAR)CONTROLLER_REGISTER_CONTROL,
1744                    CONTROLLER_COMMAND_WRITE_MOUSE_OUTPUT_BUFFER);
1745   PS2ControllerWait();
1746
1747   /* 0x5A is a random dummy value */
1748   WRITE_PORT_UCHAR((PUCHAR)CONTROLLER_REGISTER_DATA,
1749                    0x5A);
1750
1751   for (Loops = 0; Loops < 10; Loops++)
1752     {
1753       Status = READ_PORT_UCHAR((PUCHAR)CONTROLLER_REGISTER_STATUS);
1754
1755       if ((Status & CONTROLLER_STATUS_OUTPUT_BUFFER_FULL) != 0)
1756         {
1757           Scancode = READ_PORT_UCHAR((PUCHAR)CONTROLLER_REGISTER_DATA);
1758           if ((Status & CONTROLLER_STATUS_MOUSE_OUTPUT_BUFFER_FULL) != 0)
1759             {
1760               return TRUE;
1761             }
1762           break;
1763         }
1764
1765       KeStallExecutionProcessor(10000);
1766     }
1767
1768   return FALSE;
1769 }
1770
1771
1772 static BOOLEAN
1773 DetectPS2AuxDevice(VOID)
1774 {
1775   U8 Scancode;
1776   U8 Status;
1777
1778   PS2ControllerWait();
1779   WRITE_PORT_UCHAR((PUCHAR)CONTROLLER_REGISTER_CONTROL,
1780                    CONTROLLER_COMMAND_WRITE_MOUSE);
1781   PS2ControllerWait();
1782
1783   /* Identify device */
1784   WRITE_PORT_UCHAR((PUCHAR)CONTROLLER_REGISTER_DATA,
1785                    0xF2);
1786
1787   KeStallExecutionProcessor(10000);
1788
1789   Status = READ_PORT_UCHAR((PUCHAR)CONTROLLER_REGISTER_STATUS);
1790   if ((Status & CONTROLLER_STATUS_MOUSE_OUTPUT_BUFFER_FULL) == 0)
1791     {
1792       return FALSE;
1793     }
1794
1795   Scancode = READ_PORT_UCHAR((PUCHAR)CONTROLLER_REGISTER_DATA);
1796   if (Scancode != 0xFA)
1797     return FALSE;
1798
1799   KeStallExecutionProcessor(10000);
1800
1801   Status = READ_PORT_UCHAR((PUCHAR)CONTROLLER_REGISTER_STATUS);
1802   if ((Status & CONTROLLER_STATUS_MOUSE_OUTPUT_BUFFER_FULL) == 0)
1803     {
1804       return FALSE;
1805     }
1806
1807   Scancode = READ_PORT_UCHAR((PUCHAR)CONTROLLER_REGISTER_DATA);
1808   if (Scancode != 0x00)
1809     return FALSE;
1810
1811   return TRUE;
1812 }
1813
1814
1815 static VOID
1816 DetectPS2Mouse(HKEY BusKey)
1817 {
1818   CM_FULL_RESOURCE_DESCRIPTOR FullResourceDescriptor;
1819   HKEY ControllerKey;
1820   HKEY PeripheralKey;
1821   S32 Error;
1822
1823   if (DetectPS2AuxPort())
1824     {
1825       DbgPrint((DPRINT_HWDETECT, "Detected PS2 port\n"));
1826
1827       /* Create controller key */
1828       Error = RegCreateKey(BusKey,
1829                            "PointerController\\0",
1830                            &ControllerKey);
1831       if (Error != ERROR_SUCCESS)
1832         {
1833           DbgPrint((DPRINT_HWDETECT, "Failed to create controller key\n"));
1834           return;
1835         }
1836       DbgPrint((DPRINT_HWDETECT, "Created key: PointerController\\0\n"));
1837
1838       /* Set 'ComponentInformation' value */
1839       SetComponentInformation(ControllerKey,
1840                               0x20,
1841                               0,
1842                               0xFFFFFFFF);
1843
1844       memset(&FullResourceDescriptor, 0, sizeof(CM_FULL_RESOURCE_DESCRIPTOR));
1845
1846       /* Initialize resource descriptor */
1847       FullResourceDescriptor.InterfaceType = Isa;
1848       FullResourceDescriptor.BusNumber = 0;
1849       FullResourceDescriptor.PartialResourceList.Count = 1;
1850
1851       /* Set Interrupt */
1852       FullResourceDescriptor.PartialResourceList.PartialDescriptors[0].Type = CmResourceTypeInterrupt;
1853       FullResourceDescriptor.PartialResourceList.PartialDescriptors[0].ShareDisposition = CmResourceShareUndetermined;
1854       FullResourceDescriptor.PartialResourceList.PartialDescriptors[0].Flags = CM_RESOURCE_INTERRUPT_LATCHED;
1855       FullResourceDescriptor.PartialResourceList.PartialDescriptors[0].u.Interrupt.Level = 12;
1856       FullResourceDescriptor.PartialResourceList.PartialDescriptors[0].u.Interrupt.Vector = 12;
1857       FullResourceDescriptor.PartialResourceList.PartialDescriptors[0].u.Interrupt.Affinity = 0xFFFFFFFF;
1858
1859       /* Set 'Configuration Data' value */
1860       Error = RegSetValue(ControllerKey,
1861                           "Configuration Data",
1862                           REG_FULL_RESOURCE_DESCRIPTOR,
1863                           (PU8)&FullResourceDescriptor,
1864                           sizeof(CM_FULL_RESOURCE_DESCRIPTOR));
1865       if (Error != ERROR_SUCCESS)
1866         {
1867           DbgPrint((DPRINT_HWDETECT,
1868                     "RegSetValue(Configuration Data) failed (Error %u)\n",
1869                     (int)Error));
1870           return;
1871         }
1872
1873
1874       if (DetectPS2AuxDevice())
1875         {
1876           DbgPrint((DPRINT_HWDETECT, "Detected PS2 mouse\n"));
1877
1878           /* Create peripheral key */
1879           Error = RegCreateKey(ControllerKey,
1880                                "PointerPeripheral\\0",
1881                                &PeripheralKey);
1882           if (Error != ERROR_SUCCESS)
1883             {
1884               DbgPrint((DPRINT_HWDETECT, "Failed to create peripheral key\n"));
1885               return;
1886             }
1887           DbgPrint((DPRINT_HWDETECT, "Created key: PointerPeripheral\\0\n"));
1888
1889           /* Set 'ComponentInformation' value */
1890           SetComponentInformation(PeripheralKey,
1891                                   0x20,
1892                                   0,
1893                                   0xFFFFFFFF);
1894
1895           /* Initialize resource descriptor */
1896           memset(&FullResourceDescriptor, 0, sizeof(CM_FULL_RESOURCE_DESCRIPTOR));
1897           FullResourceDescriptor.InterfaceType = Isa;
1898           FullResourceDescriptor.BusNumber = 0;
1899           FullResourceDescriptor.PartialResourceList.Count = 0;
1900
1901           /* Set 'Configuration Data' value */
1902           Error = RegSetValue(PeripheralKey,
1903                               "Configuration Data",
1904                               REG_FULL_RESOURCE_DESCRIPTOR,
1905                               (PU8)&FullResourceDescriptor,
1906                               sizeof(CM_FULL_RESOURCE_DESCRIPTOR) -
1907                               sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR));
1908           if (Error != ERROR_SUCCESS)
1909             {
1910               DbgPrint((DPRINT_HWDETECT,
1911                         "RegSetValue(Configuration Data) failed (Error %u)\n",
1912                         (int)Error));
1913               return;
1914             }
1915
1916           /* Set 'Identifier' value */
1917           Error = RegSetValue(PeripheralKey,
1918                               "Identifier",
1919                               REG_SZ,
1920                               (PU8)"MICROSOFT PS2 MOUSE",
1921                               20);
1922           if (Error != ERROR_SUCCESS)
1923             {
1924               DbgPrint((DPRINT_HWDETECT,
1925                         "RegSetValue() failed (Error %u)\n",
1926                         (int)Error));
1927               return;
1928             }
1929         }
1930     }
1931 }
1932
1933
1934 static VOID
1935 DetectDisplayController(HKEY BusKey)
1936 {
1937   CHAR Buffer[80];
1938   HKEY ControllerKey;
1939   U16 VesaVersion;
1940   S32 Error;
1941
1942   Error = RegCreateKey(BusKey,
1943                        "DisplayController\\0",
1944                        &ControllerKey);
1945   if (Error != ERROR_SUCCESS)
1946     {
1947       DbgPrint((DPRINT_HWDETECT, "Failed to create controller key\n"));
1948       return;
1949     }
1950   DbgPrint((DPRINT_HWDETECT, "Created key: PointerController\\0\n"));
1951
1952   /* Set 'ComponentInformation' value */
1953   SetComponentInformation(ControllerKey,
1954                           0x00,
1955                           0,
1956                           0xFFFFFFFF);
1957
1958   /* FIXME: Set 'ComponentInformation' value */
1959
1960   VesaVersion = BiosIsVesaSupported();
1961   if (VesaVersion != 0)
1962     {
1963       DbgPrint((DPRINT_HWDETECT,
1964                 "VESA version %c.%c\n",
1965                 (VesaVersion >> 8) + '0',
1966                 (VesaVersion & 0xFF) + '0'));
1967     }
1968   else
1969     {
1970       DbgPrint((DPRINT_HWDETECT,
1971                 "VESA not supported\n"));
1972     }
1973
1974   if (VesaVersion >= 0x0200)
1975     {
1976       strcpy(Buffer,
1977              "VBE Display");
1978     }
1979   else
1980     {
1981       strcpy(Buffer,
1982              "VGA Display");
1983     }
1984
1985   /* Set 'Identifier' value */
1986   Error = RegSetValue(ControllerKey,
1987                       "Identifier",
1988                       REG_SZ,
1989                       (PU8)Buffer,
1990                       strlen(Buffer) + 1);
1991   if (Error != ERROR_SUCCESS)
1992     {
1993       DbgPrint((DPRINT_HWDETECT,
1994                 "RegSetValue() failed (Error %u)\n",
1995                 (int)Error));
1996       return;
1997     }
1998
1999   /* FIXME: Add display peripheral (monitor) data */
2000 }
2001
2002
2003 static VOID
2004 DetectIsaBios(HKEY SystemKey, U32 *BusNumber)
2005 {
2006   PCM_FULL_RESOURCE_DESCRIPTOR FullResourceDescriptor;
2007   char Buffer[80];
2008   HKEY BusKey;
2009   U32 Size;
2010   S32 Error;
2011
2012   /* Create new bus key */
2013   sprintf(Buffer,
2014           "MultifunctionAdapter\\%u", *BusNumber);
2015   Error = RegCreateKey(SystemKey,
2016                        Buffer,
2017                        &BusKey);
2018   if (Error != ERROR_SUCCESS)
2019     {
2020       DbgPrint((DPRINT_HWDETECT, "RegCreateKey() failed (Error %u)\n", (int)Error));
2021       return;
2022     }
2023
2024   /* Set 'Component Information' value similar to my NT4 box */
2025   SetComponentInformation(BusKey,
2026                           0x0,
2027                           0x0,
2028                           0xFFFFFFFF);
2029
2030   /* Increment bus number */
2031   (*BusNumber)++;
2032
2033   /* Set 'Identifier' value */
2034   Error = RegSetValue(BusKey,
2035                       "Identifier",
2036                       REG_SZ,
2037                       (PU8)"ISA",
2038                       4);
2039   if (Error != ERROR_SUCCESS)
2040     {
2041       DbgPrint((DPRINT_HWDETECT, "RegSetValue() failed (Error %u)\n", (int)Error));
2042       return;
2043     }
2044
2045   /* Set 'Configuration Data' value */
2046   Size = sizeof(CM_FULL_RESOURCE_DESCRIPTOR) -
2047          sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
2048   FullResourceDescriptor = MmAllocateMemory(Size);
2049   if (FullResourceDescriptor == NULL)
2050     {
2051       DbgPrint((DPRINT_HWDETECT,
2052                 "Failed to allocate resource descriptor\n"));
2053       return;
2054     }
2055
2056   /* Initialize resource descriptor */
2057   memset(FullResourceDescriptor, 0, Size);
2058   FullResourceDescriptor->InterfaceType = Isa;
2059   FullResourceDescriptor->BusNumber = 0;
2060   FullResourceDescriptor->PartialResourceList.Count = 0;
2061
2062   /* Set 'Configuration Data' value */
2063   Error = RegSetValue(BusKey,
2064                       "Configuration Data",
2065                       REG_FULL_RESOURCE_DESCRIPTOR,
2066                       (PU8) FullResourceDescriptor,
2067                       Size);
2068   MmFreeMemory(FullResourceDescriptor);
2069   if (Error != ERROR_SUCCESS)
2070     {
2071       DbgPrint((DPRINT_HWDETECT,
2072                 "RegSetValue(Configuration Data) failed (Error %u)\n",
2073                 (int)Error));
2074       return;
2075     }
2076
2077   /* Detect ISA/BIOS devices */
2078   DetectBiosDisks(SystemKey, BusKey);
2079
2080   DetectBiosFloppyController(SystemKey, BusKey);
2081
2082   DetectSerialPorts(BusKey);
2083
2084 #if 0
2085   DetectParallelPorts(BusKey);
2086 #endif
2087
2088   DetectKeyboardController(BusKey);
2089
2090   DetectPS2Mouse(BusKey);
2091
2092   DetectDisplayController(BusKey);
2093
2094   /* FIXME: Detect more ISA devices */
2095 }
2096
2097
2098 VOID
2099 DetectHardware(VOID)
2100 {
2101   HKEY SystemKey;
2102   U32 BusNumber = 0;
2103   S32 Error;
2104
2105   DbgPrint((DPRINT_HWDETECT, "DetectHardware()\n"));
2106
2107   HalpCalibrateStallExecution ();
2108
2109   /* Create the 'System' key */
2110   Error = RegCreateKey(NULL,
2111                        "\\Registry\\Machine\\HARDWARE\\DESCRIPTION\\System",
2112                        &SystemKey);
2113   if (Error != ERROR_SUCCESS)
2114     {
2115       DbgPrint((DPRINT_HWDETECT, "RegCreateKey() failed (Error %u)\n", (int)Error));
2116       return;
2117     }
2118
2119 #if 0
2120   DetectSystemData();
2121 #endif
2122   DetectCPUs(SystemKey);
2123
2124   /* Detect buses */
2125 #if 0
2126   DetectPciBios(&BusNumber);
2127   DetectApmBios(&BusNumber);
2128 #endif
2129   DetectPnpBios(SystemKey, &BusNumber);
2130   DetectIsaBios(SystemKey, &BusNumber);
2131 #if 0
2132   DetectAcpiBios(&BusNumber);
2133 #endif
2134
2135
2136   DbgPrint((DPRINT_HWDETECT, "DetectHardware() Done\n"));
2137
2138 #if 0
2139   printf("*** System stopped ***\n");
2140   for (;;);
2141 #endif
2142 }
2143
2144 /* EOF */