![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to atd_conf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / scsi / atdisk / i386|
Return to atd_conf.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / scsi / atdisk / i386 |
1.1 ! root 1: /*++ ! 2: ! 3: Copyright (c) 1991, 1992, 1993 Microsoft Corporation ! 4: ! 5: Module Name: ! 6: ! 7: i386\atd_conf.c ! 8: ! 9: Abstract: ! 10: ! 11: This file includes the routine to get ix86 platform-dependent ! 12: configuration information for the AT disk (aka ST506, ISA, and ix86 ! 13: standard hard disk) driver for NT. ! 14: ! 15: If this driver is ported to a different platform, this file (and ! 16: atd_plat.h) will need to be modified extensively. The build ! 17: procedure should make sure that the proper version of this file is ! 18: available as atd_conf.h (which is included by atdisk.c) when ! 19: building for a specific platform. ! 20: ! 21: Author: ! 22: ! 23: Chad Schwitters (chads) 21-Feb-1991. ! 24: ! 25: Environment: ! 26: ! 27: Kernel mode only. ! 28: ! 29: Notes: ! 30: ! 31: Revision History: ! 32: ! 33: --*/ ! 34: ! 35: #include "ntddk.h" // various NT definitions ! 36: #include "ntdddisk.h" // disk device driver I/O control codes ! 37: #include <atd_plat.h> // this driver's platform dependent stuff ! 38: #include <atd_data.h> // this driver's data declarations ! 39: ! 40: NTSTATUS ! 41: AtConfigCallBack( ! 42: IN PVOID Context, ! 43: IN PUNICODE_STRING PathName, ! 44: IN INTERFACE_TYPE BusType, ! 45: IN ULONG BusNumber, ! 46: IN PKEY_VALUE_FULL_INFORMATION *BusInformation, ! 47: IN CONFIGURATION_TYPE ControllerType, ! 48: IN ULONG ControllerNumber, ! 49: IN PKEY_VALUE_FULL_INFORMATION *ControllerInformation, ! 50: IN CONFIGURATION_TYPE PeripheralType, ! 51: IN ULONG PeripheralNumber, ! 52: IN PKEY_VALUE_FULL_INFORMATION *PeripheralInformation ! 53: ); ! 54: ! 55: BOOLEAN ! 56: UpdateGeometryFromBios( ! 57: PDRIVER_OBJECT DriverObject, ! 58: DRIVE_DATA *DriveData, ! 59: ULONG DiskNumber ! 60: ); ! 61: ! 62: BOOLEAN ! 63: UpdateGeometryFromParameterTable( ! 64: DRIVE_DATA *DriveData, ! 65: CCHAR *ControlFlags, ! 66: ULONG ParameterTableOffset ! 67: ); ! 68: ! 69: BOOLEAN ! 70: GetGeometryFromIdentify( ! 71: PCONTROLLER_DATA ControllerData, ! 72: ULONG DiskNumber ! 73: ); ! 74: ! 75: BOOLEAN ! 76: IssueIdentify( ! 77: PCONTROLLER_DATA ControllerData, ! 78: PUCHAR Buffer, ! 79: ULONG DiskNumber ! 80: ); ! 81: ! 82: #ifdef ALLOC_PRAGMA ! 83: #pragma alloc_text(init,AtConfigCallBack) ! 84: #pragma alloc_text(init,AtGetConfigInfo) ! 85: #pragma alloc_text(init,UpdateGeometryFromBios) ! 86: #pragma alloc_text(init,UpdateGeometryFromParameterTable) ! 87: #endif ! 88: ! 89: ! 90: NTSTATUS ! 91: AtConfigCallBack( ! 92: IN PVOID Context, ! 93: IN PUNICODE_STRING PathName, ! 94: IN INTERFACE_TYPE BusType, ! 95: IN ULONG BusNumber, ! 96: IN PKEY_VALUE_FULL_INFORMATION *BusInformation, ! 97: IN CONFIGURATION_TYPE ControllerType, ! 98: IN ULONG ControllerNumber, ! 99: IN PKEY_VALUE_FULL_INFORMATION *ControllerInformation, ! 100: IN CONFIGURATION_TYPE PeripheralType, ! 101: IN ULONG PeripheralNumber, ! 102: IN PKEY_VALUE_FULL_INFORMATION *PeripheralInformation ! 103: ) ! 104: ! 105: /*++ ! 106: ! 107: Routine Description: ! 108: ! 109: This routine is used to acquire all of the configuration ! 110: information for each floppy disk controller and the ! 111: peripheral driver attached to that controller. ! 112: ! 113: Arguments: ! 114: ! 115: Context - Pointer to boolean. ! 116: ! 117: PathName - unicode registry path. Not Used. ! 118: ! 119: BusType - Internal, Isa, ... ! 120: ! 121: BusNumber - Should Always be zero. ! 122: ! 123: BusInformation - Configuration information about the bus. Not Used. ! 124: ! 125: ControllerType - Controller Type. Not Used. ! 126: ! 127: ControllerNumber - Which controller if there is more than one ! 128: controller in the system. Not Used ! 129: ! 130: ControllerInformation - Array of pointers to the three pieces of ! 131: registry information. Not Used ! 132: ! 133: PeripheralType - Peripheral Type. Not Used. ! 134: ! 135: PeripheralNumber - Which floppy if this controller is maintaining ! 136: more than one. Not Used ! 137: ! 138: PeripheralInformation - Arrya of pointers to the three pieces of ! 139: registry information. Not Used. ! 140: ! 141: Return Value: ! 142: ! 143: STATUS_SUCCESS ! 144: ! 145: --*/ ! 146: ! 147: { ! 148: ! 149: ASSERT(BusNumber == 0); ! 150: *((PBOOLEAN)Context) = TRUE; ! 151: return STATUS_SUCCESS; ! 152: ! 153: } ! 154: ! 155: NTSTATUS ! 156: AtGetConfigInfo( ! 157: IN PDRIVER_OBJECT DriverObject, ! 158: IN PUNICODE_STRING RegistryPath, ! 159: IN OUT PCONFIG_DATA ConfigData ! 160: ) ! 161: ! 162: /*++ ! 163: ! 164: Routine Description: ! 165: ! 166: This routine is called once at initialization time by ! 167: AtDiskInitialize() to get information about the disks that are to be ! 168: supported. ! 169: ! 170: Some values here are simply assumed (i.e. number of controllers, and ! 171: base address of controller). Other are determined by poking CMOS ! 172: (i.e. how many drives are on the controller) or by peering into ROM (i.e. ! 173: sectors per track for each drive). ! 174: ! 175: Arguments: ! 176: ! 177: DriverObject - The driver object for this driver. ! 178: ! 179: RegistryPath - The string that takes us to this drivers service node. ! 180: ! 181: ConfigData - a pointer to the pointer to a data structure that ! 182: describes the controllers and the disks attached to them ! 183: ! 184: Return Value: ! 185: ! 186: Returns STATUS_SUCCESS unless there is no drive 0. ! 187: ! 188: --*/ ! 189: ! 190: { ! 191: ULONG paramTable; ! 192: PUSHORT paramVector; ! 193: UCHAR *namePointer; ! 194: ULONG i, j, k; ! 195: UCHAR configuredIrq; ! 196: UCHAR writeValue; ! 197: UCHAR driveTypes; ! 198: PCONFIGURATION_INFORMATION configurationInformation; ! 199: BOOLEAN machineIsCompaq = FALSE; ! 200: BOOLEAN foundIt = FALSE; ! 201: ULONG diskCount; ! 202: INTERFACE_TYPE defaultInterfaceType; ! 203: ULONG defaultBusNumber; ! 204: KIRQL defaultIrql; ! 205: PHYSICAL_ADDRESS defaultBaseAddress; ! 206: PHYSICAL_ADDRESS defaultPortAddress; ! 207: RTL_QUERY_REGISTRY_TABLE registryTable[2] = {0}; ! 208: UNICODE_STRING ps1Data; ! 209: UNICODE_STRING ps1Value; ! 210: BOOLEAN ps1Detected; ! 211: UCHAR buffer[512]; ! 212: CCHAR badDisks[][40] = {" 94244-383"}; ! 213: ULONG numberOfBadDisks = sizeof(badDisks)/sizeof(badDisks[0]); ! 214: ! 215: // ! 216: // Get the temporary configuration manager information. ! 217: // ! 218: ! 219: configurationInformation = IoGetConfigurationInformation( ); ! 220: ConfigData->HardDiskCount = &configurationInformation->DiskCount; ! 221: ConfigData->ArcNamePrefix = TemporaryArcNamePrefix; ! 222: diskCount = configurationInformation->DiskCount; ! 223: ! 224: // ! 225: // This driver only knows how to work on the first isa ! 226: // or eisa bus in the system. Call IoQeuryDeviceDescription ! 227: // to make sure that there is such a bus on the system. ! 228: // ! 229: ! 230: foundIt = FALSE; ! 231: ! 232: // ! 233: // If it can't find the bus then just assume that it's the ! 234: // first isa bus. ! 235: // ! 236: ! 237: defaultInterfaceType = Isa; ! 238: defaultBusNumber = 0; ! 239: ! 240: IoQueryDeviceDescription( ! 241: &defaultInterfaceType, ! 242: &defaultBusNumber, ! 243: NULL, ! 244: NULL, ! 245: NULL, ! 246: NULL, ! 247: AtConfigCallBack, ! 248: &foundIt ! 249: ); ! 250: ! 251: if (!foundIt) { ! 252: ! 253: defaultInterfaceType = Eisa; ! 254: defaultBusNumber = 0; ! 255: IoQueryDeviceDescription( ! 256: &defaultInterfaceType, ! 257: &defaultBusNumber, ! 258: NULL, ! 259: NULL, ! 260: NULL, ! 261: NULL, ! 262: AtConfigCallBack, ! 263: &foundIt ! 264: ); ! 265: ! 266: if (!foundIt) { ! 267: ! 268: defaultInterfaceType = Isa; ! 269: defaultBusNumber = 0; ! 270: AtDump( ! 271: ATERRORS, ! 272: ("ATDISK: Not EISA OR ISA BY CONFIG, ASSUME ISA\n") ! 273: ); ! 274: ! 275: } ! 276: } ! 277: ! 278: // ! 279: // Check if first controller s unclaimed. ! 280: // ! 281: ! 282: if (!configurationInformation->AtDiskPrimaryAddressClaimed) { ! 283: ! 284: // ! 285: // Fill in some controller information. ! 286: // ! 287: ! 288: defaultBaseAddress.LowPart = 0x1F0; ! 289: defaultBaseAddress.HighPart = 0; ! 290: defaultPortAddress.LowPart = 0x3f6; ! 291: defaultPortAddress.HighPart = 0; ! 292: defaultIrql = 14; ! 293: AtDiskControllerInfo( ! 294: DriverObject, ! 295: RegistryPath, ! 296: 0, ! 297: &ConfigData->Controller[0], ! 298: defaultBaseAddress, ! 299: defaultPortAddress, ! 300: defaultIrql, ! 301: defaultInterfaceType, ! 302: defaultBusNumber, ! 303: TRUE ! 304: ); ! 305: ! 306: // ! 307: // Check if controller active at primary address. ! 308: // ! 309: ! 310: if (AtControllerPresent(&ConfigData->Controller[0])) { ! 311: ! 312: // ! 313: // Claim ATDISK primary IO address range. ! 314: // ! 315: ! 316: configurationInformation->AtDiskPrimaryAddressClaimed = TRUE; ! 317: ! 318: ConfigData->Controller[0].OkToUseThisController = TRUE; ! 319: ! 320: // ! 321: // Check to see if this is a ps/1 compatible. If it is ! 322: // then we have to do something different. (Don't ask ! 323: // me, ask IBM. I'm sure that they have an interesting ! 324: // answer.) If it is a ps/1 compatible, then zero out ! 325: // the cmos types. We'll look in the BIOS. ! 326: // ! 327: ! 328: ps1Data.Length = 0; ! 329: ps1Data.MaximumLength = sizeof(buffer); ! 330: ps1Data.Buffer = (PWCHAR)&buffer[0]; ! 331: RtlInitUnicodeString( ! 332: &ps1Value, ! 333: L"PS1/PS1 COMPATIBLE" ! 334: ); ! 335: registryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | ! 336: RTL_QUERY_REGISTRY_REQUIRED; ! 337: registryTable[0].Name = L"Identifier"; ! 338: registryTable[0].EntryContext = &ps1Data; ! 339: ! 340: if (!NT_SUCCESS(RtlQueryRegistryValues( ! 341: RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL, ! 342: L"\\REGISTRY\\MACHINE\\HARDWARE\\DESCRIPTION\\SYSTEM", ! 343: ®istryTable[0], ! 344: NULL, ! 345: NULL ! 346: ))) { ! 347: ! 348: // ! 349: // How odd, no identifer string! We'll it's probably not a ps1. ! 350: // ! 351: ! 352: ps1Detected = FALSE; ! 353: ! 354: } else { ! 355: ! 356: ps1Detected = RtlEqualUnicodeString( ! 357: &ps1Data, ! 358: &ps1Value, ! 359: FALSE ! 360: ); ! 361: ! 362: ! 363: } ! 364: ! 365: if (ps1Detected) { ! 366: ! 367: ConfigData->Controller[0].Disk[0].DriveType = 0; ! 368: ConfigData->Controller[0].Disk[1].DriveType = 0; ! 369: ! 370: } else { ! 371: ! 372: // ! 373: // Check CMOS for drive types for first and second disk. ! 374: // ! 375: ! 376: WRITE_PORT_UCHAR(CFGMEM_QUERY_PORT, CFGMEM_FIRST_CONTROLLER_DRIVE_TYPES); ! 377: ! 378: KeStallExecutionProcessor( 1L ); ! 379: ! 380: driveTypes = READ_PORT_UCHAR( CFGMEM_DATA_PORT ); ! 381: ! 382: ConfigData->Controller[0].Disk[0].DriveType = (UCHAR) ! 383: ( driveTypes & CFGMEM_DRIVES_FIRST_DRIVE_MASK ); ! 384: ! 385: if ( ConfigData->Controller[0].Disk[0].DriveType == 0xf0 ) { ! 386: ! 387: WRITE_PORT_UCHAR( CFGMEM_QUERY_PORT, CFGMEM_HARD_DRIVE_TYPE_ONE ); ! 388: ! 389: KeStallExecutionProcessor( 1L ); ! 390: ! 391: ConfigData->Controller[0].Disk[0].DriveType = ! 392: READ_PORT_UCHAR( CFGMEM_DATA_PORT ); ! 393: } ! 394: ! 395: ConfigData->Controller[0].Disk[1].DriveType = (UCHAR) ! 396: ( driveTypes & CFGMEM_DRIVES_SECOND_DRIVE_MASK ); ! 397: ! 398: if ( ConfigData->Controller[0].Disk[1].DriveType == 0x0f ) { ! 399: ! 400: WRITE_PORT_UCHAR( CFGMEM_QUERY_PORT, CFGMEM_HARD_DRIVE_TYPE_TWO ); ! 401: ! 402: KeStallExecutionProcessor( 1L ); ! 403: ! 404: ConfigData->Controller[0].Disk[1].DriveType = ! 405: READ_PORT_UCHAR( CFGMEM_DATA_PORT ); ! 406: } ! 407: ! 408: } ! 409: ! 410: if (ConfigData->Controller[0].Disk[0].DriveType) { ! 411: ! 412: // ! 413: // Bump disk count. ! 414: // ! 415: ! 416: diskCount++; ! 417: ! 418: // ! 419: // Map BIOS vector 41 for first disk. ! 420: // ! 421: ! 422: paramVector = MmMapIoSpace( ! 423: RtlConvertUlongToLargeInteger ( ! 424: PTR_TO_FDPT0_ADDRESS), ! 425: sizeof( ULONG ), ! 426: FALSE ); ! 427: ! 428: // ! 429: // Map drive parameter table for first disk. ! 430: // ! 431: ! 432: if (*paramVector) { ! 433: ! 434: UpdateGeometryFromParameterTable(&ConfigData->Controller[0].Disk[0], ! 435: &ConfigData->Controller[0].ControlFlags, ! 436: ((*(paramVector + 1)) << 4 ) + *paramVector); ! 437: ! 438: } else { ! 439: ! 440: // ! 441: // Check BIOS information passed in from NTDETECT. ! 442: // ! 443: ! 444: if (UpdateGeometryFromBios(DriverObject, ! 445: &ConfigData->Controller[0].Disk[0], ! 446: 0)) { ! 447: ConfigData->Controller[0].Disk[0].DriveType = 0xFF; ! 448: } ! 449: } ! 450: ! 451: MmUnmapIoSpace( paramVector, sizeof( ULONG ) ); ! 452: ! 453: } else { ! 454: ! 455: // ! 456: // Verify that a disk is attached to the first controller. ! 457: // ! 458: ! 459: if (IssueIdentify(&ConfigData->Controller[0], ! 460: buffer, ! 461: 0)) { ! 462: ! 463: // ! 464: // Check BIOS information passed in from NTDETECT. ! 465: // ! 466: ! 467: if (UpdateGeometryFromBios(DriverObject, ! 468: &ConfigData->Controller[0].Disk[0], ! 469: 0)) { ! 470: ! 471: diskCount++; ! 472: ConfigData->Controller[0].Disk[0].DriveType = 0xFF; ! 473: } ! 474: } ! 475: } ! 476: ! 477: if (ConfigData->Controller[0].Disk[1].DriveType) { ! 478: ! 479: // ! 480: // Bump disk count. ! 481: // ! 482: ! 483: diskCount++; ! 484: ! 485: // ! 486: // Map BIOS vector 46 for second disk. ! 487: // ! 488: ! 489: paramVector = MmMapIoSpace( ! 490: RtlConvertUlongToLargeInteger ( ! 491: PTR_TO_FDPT1_ADDRESS), ! 492: sizeof( ULONG ), ! 493: FALSE ); ! 494: ! 495: // ! 496: // Map drive parameter table for second disk. ! 497: // ! 498: ! 499: if (*paramVector) { ! 500: ! 501: if (UpdateGeometryFromParameterTable(&ConfigData->Controller[0].Disk[1], ! 502: &ConfigData->Controller[0].ControlFlags, ! 503: ((*(paramVector + 1)) << 4 ) + *paramVector)) { ! 504: ConfigData->Controller[0].Disk[1].DriveType = 0xFF; ! 505: } ! 506: ! 507: } else { ! 508: ! 509: // ! 510: // Check BIOS information passed in from NTDETECT. ! 511: // ! 512: ! 513: if (UpdateGeometryFromBios(DriverObject, ! 514: &ConfigData->Controller[0].Disk[1], ! 515: 1)) { ! 516: ConfigData->Controller[0].Disk[1].DriveType = 0xFF; ! 517: } ! 518: } ! 519: ! 520: MmUnmapIoSpace( paramVector, sizeof( ULONG ) ); ! 521: ! 522: } else { ! 523: ! 524: // ! 525: // Verify that a second disk is attached to the first controller. ! 526: // ! 527: ! 528: if (IssueIdentify(&ConfigData->Controller[0], ! 529: buffer, ! 530: 1)) { ! 531: ! 532: // ! 533: // Check BIOS information passed in from NTDETECT. ! 534: // ! 535: ! 536: if (UpdateGeometryFromBios(DriverObject, ! 537: &ConfigData->Controller[0].Disk[1], ! 538: 1)) { ! 539: ! 540: diskCount++; ! 541: ConfigData->Controller[0].Disk[1].DriveType = 0xFF; ! 542: } ! 543: } ! 544: } ! 545: } ! 546: } ! 547: ! 548: // ! 549: // Check for unclaimed second controller. ! 550: // ! 551: ! 552: if (!configurationInformation->AtDiskSecondaryAddressClaimed) { ! 553: ! 554: // ! 555: // Fill in controller description. ! 556: // ! 557: ! 558: defaultBaseAddress.LowPart = 0x170; ! 559: defaultBaseAddress.HighPart = 0; ! 560: defaultPortAddress.LowPart = 0x376; ! 561: defaultPortAddress.HighPart = 0; ! 562: ! 563: // ! 564: // If this is a compaq then the values for the ! 565: // vector may be wrong. They will get mapped ! 566: // to the correct value in a little bit. ! 567: // ! 568: ! 569: defaultIrql = 15; ! 570: AtDiskControllerInfo( ! 571: DriverObject, ! 572: RegistryPath, ! 573: 1, ! 574: &ConfigData->Controller[1], ! 575: defaultBaseAddress, ! 576: defaultPortAddress, ! 577: defaultIrql, ! 578: defaultInterfaceType, ! 579: defaultBusNumber, ! 580: TRUE ! 581: ); ! 582: ! 583: // ! 584: // Check if controller present at secondary address. ! 585: // ! 586: ! 587: if (AtControllerPresent(&ConfigData->Controller[1])) { ! 588: ! 589: // ! 590: // Claim ATDISK secondary IO address range. ! 591: // ! 592: ! 593: configurationInformation->AtDiskSecondaryAddressClaimed = TRUE; ! 594: ! 595: ConfigData->Controller[1].OkToUseThisController = TRUE; ! 596: ! 597: // ! 598: // Map BIOS vendor signature to check for Compaq. ! 599: // ! 600: ! 601: namePointer = MmMapIoSpace( RtlConvertUlongToLargeInteger ( ! 602: PTR_TO_NAME_STRING), ! 603: NAME_STRING_LENGTH, ! 604: FALSE ); ! 605: ! 606: if ( ( *namePointer == 'C' ) && ! 607: ( *( namePointer + 1 ) == 'O' ) && ! 608: ( *( namePointer + 2 ) == 'M' ) && ! 609: ( *( namePointer + 3 ) == 'P' ) && ! 610: ( *( namePointer + 4 ) == 'A' ) && ! 611: ( *( namePointer + 5 ) == 'Q' ) ) { ! 612: ! 613: machineIsCompaq = TRUE; ! 614: AtDump( ! 615: ATINIT, ! 616: ("ATDISK: Machine is a compaq!\n") ! 617: ); ! 618: ! 619: } ! 620: ! 621: MmUnmapIoSpace( namePointer, NAME_STRING_LENGTH ); ! 622: ! 623: // ! 624: // Compaq uses CMOS to store the drive type for up to two disks ! 625: // attached to their secondary controllers. ! 626: // ! 627: ! 628: if ( machineIsCompaq ) { ! 629: ! 630: // ! 631: // Query CMOS about types of drives 3 and 4. If they exist, get ! 632: // pointers to the appropriate places in our internal fixed disk ! 633: // parameter table. ! 634: // ! 635: ! 636: WRITE_PORT_UCHAR( CFGMEM_QUERY_PORT, CFGMEM_HARD_DRIVE_TYPE_THREE ); ! 637: ! 638: KeStallExecutionProcessor( 1L ); ! 639: ! 640: ConfigData->Controller[1].Disk[0].DriveType = ! 641: READ_PORT_UCHAR( CFGMEM_DATA_PORT ); ! 642: ! 643: if (ConfigData->Controller[1].Disk[0].DriveType) { ! 644: ! 645: // ! 646: // Bump disk count. ! 647: // ! 648: ! 649: diskCount++; ! 650: ! 651: // ! 652: // Use drive type as an index into the system BIOS drive parameter ! 653: // table to find a corresponding geometry entry. ! 654: // ! 655: ! 656: paramTable = DRIVE_PARAMETER_TABLE_OFFSET + ! 657: (ConfigData->Controller[1].Disk[0].DriveType -1) * ! 658: sizeof(FIXED_DISK_PARAMETER_TABLE); ! 659: ! 660: UpdateGeometryFromParameterTable(&ConfigData->Controller[1].Disk[0], ! 661: &ConfigData->Controller[1].ControlFlags, ! 662: paramTable); ! 663: } ! 664: ! 665: WRITE_PORT_UCHAR( CFGMEM_QUERY_PORT, CFGMEM_HARD_DRIVE_TYPE_FOUR ); ! 666: ! 667: KeStallExecutionProcessor( 1L ); ! 668: ! 669: ConfigData->Controller[1].Disk[1].DriveType = ! 670: READ_PORT_UCHAR( CFGMEM_DATA_PORT ); ! 671: ! 672: if (ConfigData->Controller[1].Disk[1].DriveType) { ! 673: ! 674: // ! 675: // Bump disk count. ! 676: // ! 677: ! 678: diskCount++; ! 679: ! 680: // ! 681: // Use drive type as an index into the system BIOS drive parameter ! 682: // table to find a corresponding geometry entry. ! 683: // ! 684: ! 685: paramTable = DRIVE_PARAMETER_TABLE_OFFSET + ! 686: (ConfigData->Controller[1].Disk[1].DriveType -1) * ! 687: sizeof(FIXED_DISK_PARAMETER_TABLE); ! 688: ! 689: UpdateGeometryFromParameterTable(&ConfigData->Controller[1].Disk[1], ! 690: &ConfigData->Controller[1].ControlFlags, ! 691: paramTable); ! 692: } ! 693: ! 694: // ! 695: // If disk 3 or 4 was found, set up the secondary controller. ! 696: // ! 697: ! 698: if ( ( ConfigData->Controller[1].Disk[0].DriveType != 0 ) || ! 699: ( ConfigData->Controller[1].Disk[1].DriveType != 0 ) ) { ! 700: ! 701: configuredIrq = READ_PORT_UCHAR( SECOND_CONTROLLER_IRQ_PORT ); ! 702: ! 703: if ( ( configuredIrq & IRQ_PORT_DISABLED_MASK ) == ! 704: IRQ_PORT_DISABLED ) { ! 705: ! 706: // ! 707: // NT (or OS/2) has already written to this port, which ! 708: // disables further writes. The bit set in the lower ! 709: // nibble indicates which IRQ is being used. ! 710: // ! 711: ! 712: switch ( configuredIrq ) { ! 713: ! 714: case IRQ_PORT_DISABLED + 1: { ! 715: ! 716: configuredIrq = 11; ! 717: break; ! 718: } ! 719: ! 720: case IRQ_PORT_DISABLED + 2: { ! 721: ! 722: configuredIrq = 12; ! 723: break; ! 724: } ! 725: ! 726: case IRQ_PORT_DISABLED + 4: { ! 727: ! 728: configuredIrq = 14; ! 729: break; ! 730: } ! 731: ! 732: default: { ! 733: ! 734: // ! 735: // Case 8 is IRQ 15; but in case we got garbage ! 736: // let's assume 15 and see if it works. ! 737: // ! 738: ! 739: configuredIrq = 15; ! 740: break; ! 741: } ! 742: } ! 743: ! 744: } else { ! 745: ! 746: // ! 747: // This is the first boot after a powercycle. We need ! 748: // to determine the IRQ being used by checking which bit ! 749: // *isn't* set in the *high* nibble. Then we need to ! 750: // write the IRQ_PORT_DISABLED + the proper IRQ bit in ! 751: // the lower nibble. ! 752: // ! 753: ! 754: switch ( configuredIrq ) { ! 755: ! 756: case 0xe0: { ! 757: ! 758: configuredIrq = 11; ! 759: writeValue = IRQ_PORT_DISABLED + 1; ! 760: break; ! 761: } ! 762: ! 763: case 0xd0: { ! 764: ! 765: configuredIrq = 12; ! 766: writeValue = IRQ_PORT_DISABLED + 2; ! 767: break; ! 768: } ! 769: ! 770: case 0xb0: { ! 771: ! 772: configuredIrq = 14; ! 773: writeValue = IRQ_PORT_DISABLED + 4; ! 774: break; ! 775: } ! 776: ! 777: default: { ! 778: ! 779: // ! 780: // Case 0x70 is IRQ 15, but we also want to try ! 781: // IRQ 15 if we got garbage from the register. ! 782: // ! 783: ! 784: configuredIrq = 15; ! 785: writeValue = IRQ_PORT_DISABLED + 8; ! 786: break; ! 787: } ! 788: } ! 789: ! 790: WRITE_PORT_UCHAR( SECOND_CONTROLLER_IRQ_PORT, writeValue ); ! 791: } ! 792: ! 793: ConfigData->Controller[1].OriginalControllerIrql = configuredIrq; ! 794: ConfigData->Controller[1].OriginalControllerVector = configuredIrq; ! 795: ! 796: ConfigData->Controller[1].ControllerVector = ! 797: HalGetInterruptVector( ! 798: ConfigData->Controller[1].InterfaceType, ! 799: ConfigData->Controller[1].BusNumber, ! 800: ConfigData->Controller[1].OriginalControllerIrql, ! 801: ConfigData->Controller[1].OriginalControllerVector, ! 802: &ConfigData->Controller[1].ControllerIrql, ! 803: &ConfigData->Controller[1].ProcessorNumber ); ! 804: } ! 805: ! 806: } else { ! 807: ! 808: // ! 809: // If it's not a compaq then the interrupt is already ! 810: // set up. ! 811: // ! 812: ! 813: // ! 814: // Verify a disk is attached to the second controller. ! 815: // ! 816: ! 817: if (IssueIdentify(&ConfigData->Controller[1], ! 818: buffer, ! 819: 0)) { ! 820: ! 821: // ! 822: // Check if the BIOS has information about this disk. ! 823: // ! 824: ! 825: if (UpdateGeometryFromBios(DriverObject, ! 826: &ConfigData->Controller[1].Disk[0], ! 827: diskCount)) { ! 828: ! 829: diskCount++; ! 830: ConfigData->Controller[1].Disk[0].DriveType = 0xFF; ! 831: ! 832: } else { ! 833: ! 834: // ! 835: // Get geometry information for disk 0 from IDENTIFY command. ! 836: // ! 837: ! 838: if (GetGeometryFromIdentify(&ConfigData->Controller[1], ! 839: 0)) { ! 840: ! 841: diskCount++; ! 842: ConfigData->Controller[1].Disk[0].DriveType = 0xFF; ! 843: } ! 844: } ! 845: ! 846: // ! 847: // Verify a disk is attached to the second controller. ! 848: // ! 849: ! 850: if (IssueIdentify(&ConfigData->Controller[1], ! 851: buffer, ! 852: 1)) { ! 853: ! 854: // ! 855: // Check if the BIOS has information about this disk. ! 856: // ! 857: ! 858: if (UpdateGeometryFromBios(DriverObject, ! 859: &ConfigData->Controller[1].Disk[1], ! 860: diskCount)) { ! 861: ! 862: diskCount++; ! 863: ConfigData->Controller[1].Disk[1].DriveType = 0xFF; ! 864: ! 865: } else { ! 866: ! 867: // ! 868: // Get geometry information for disk 1 from IDENTIFY command. ! 869: // ! 870: ! 871: if (GetGeometryFromIdentify(&ConfigData->Controller[1], ! 872: 1)) { ! 873: ! 874: diskCount++; ! 875: ConfigData->Controller[1].Disk[1].DriveType = 0xFF; ! 876: } ! 877: } ! 878: } ! 879: } ! 880: } ! 881: } ! 882: } ! 883: ! 884: for (i=2;i < MAXIMUM_NUMBER_OF_CONTROLLERS;i++) { ! 885: ! 886: if (AtDiskControllerInfo( ! 887: DriverObject, ! 888: RegistryPath, ! 889: i, ! 890: &ConfigData->Controller[i], ! 891: defaultBaseAddress, ! 892: defaultPortAddress, ! 893: defaultIrql, ! 894: defaultInterfaceType, ! 895: defaultBusNumber, ! 896: FALSE ! 897: )) { ! 898: ! 899: // ! 900: // Assume that if it is such a "high" controller, ! 901: // is following the ata spec, and that it's ok ! 902: // to set the control flags as we should. ! 903: // ! 904: ! 905: ConfigData->Controller[i].ControlFlags = 0x08; ! 906: ! 907: if (!AtControllerPresent(&ConfigData->Controller[i])) { ! 908: ! 909: continue; ! 910: ! 911: } ! 912: ! 913: if (!AtResetController( ! 914: ConfigData->Controller[i].ControllerBaseAddress + STATUS_REGISTER, ! 915: ConfigData->Controller[i].ControlPortAddress, ! 916: ConfigData->Controller[i].ControlFlags ! 917: )) { ! 918: ! 919: continue; ! 920: ! 921: } ! 922: ! 923: ConfigData->Controller[i].OkToUseThisController = TRUE; ! 924: ! 925: // ! 926: // Get geometry information for disk 0 from IDENTIFY command. ! 927: // ! 928: ! 929: if (GetGeometryFromIdentify(&ConfigData->Controller[i], ! 930: 0)) { ! 931: ! 932: diskCount++; ! 933: ConfigData->Controller[i].Disk[0].DriveType = 0xFF; ! 934: ! 935: // ! 936: // Get geometry information for disk 1 from IDENTIFY command. ! 937: // ! 938: ! 939: if (GetGeometryFromIdentify(&ConfigData->Controller[i], ! 940: 1)) { ! 941: ! 942: diskCount++; ! 943: ConfigData->Controller[i].Disk[1].DriveType = 0xFF; ! 944: } ! 945: } ! 946: } ! 947: } ! 948: // ! 949: // Check if any disks were found. ! 950: // ! 951: ! 952: if (!diskCount) { ! 953: return STATUS_NO_SUCH_DEVICE; ! 954: } ! 955: ! 956: // ! 957: // Update device map in registry with disk information. ! 958: // ! 959: ! 960: for (i=0; i< MAXIMUM_NUMBER_OF_CONTROLLERS; i++) { ! 961: for (j=0; j< MAXIMUM_NUMBER_OF_DISKS_PER_CONTROLLER; j++) { ! 962: ! 963: ! 964: if (!ConfigData->Controller[i].Disk[j].DriveType) { ! 965: continue; ! 966: } ! 967: ! 968: // ! 969: // Issue IDENTIFY command. ! 970: // ! 971: ! 972: if (IssueIdentify(&ConfigData->Controller[i], ! 973: buffer, ! 974: j)) { ! 975: ! 976: PUSHORT tempS; ! 977: UCHAR tempByte; ! 978: ! 979: // ! 980: // Byte flip model number, revision, and serial number string. ! 981: // ! 982: ! 983: tempS = ((PIDENTIFY_DATA)buffer)->ModelNumber; ! 984: for (k=0; k<20; k++) { ! 985: tempByte = (UCHAR)(tempS[k] & 0x00FF); ! 986: tempS[k] = tempS[k] >> 8; ! 987: tempS[k] |= tempByte << 8; ! 988: } ! 989: ! 990: tempS = ((PIDENTIFY_DATA)buffer)->FirmwareRevision; ! 991: for (k=0; k<4; k++) { ! 992: tempByte = (UCHAR)(tempS[k] & 0x00FF); ! 993: tempS[k] = tempS[k] >> 8; ! 994: tempS[k] |= tempByte << 8; ! 995: } ! 996: ! 997: tempS = ((PIDENTIFY_DATA)buffer)->SerialNumber; ! 998: for (k=0; k<10; k++) { ! 999: tempByte = (UCHAR)(tempS[k] & 0x00FF); ! 1000: tempS[k] = tempS[k] >> 8; ! 1001: tempS[k] |= tempByte << 8; ! 1002: } ! 1003: ! 1004: } else { ! 1005: ! 1006: RtlZeroMemory( ! 1007: &buffer[0], ! 1008: 512 ! 1009: ); ! 1010: ! 1011: } ! 1012: ! 1013: for (k=0;k<numberOfBadDisks;k++) { ! 1014: ! 1015: // ! 1016: // Check if we should disable the read cache. ! 1017: // ! 1018: ! 1019: if (!strncmp( ! 1020: &badDisks[k][0], ! 1021: (PUCHAR)&((PIDENTIFY_DATA)buffer)->ModelNumber[0], ! 1022: strlen(&badDisks[k][0]) ! 1023: )) { ! 1024: ! 1025: ConfigData->Controller[i].Disk[j].DisableReadCache = TRUE; ! 1026: ! 1027: } ! 1028: ! 1029: } ! 1030: ! 1031: // ! 1032: // Update device map. ! 1033: // ! 1034: ! 1035: AtBuildDeviceMap(i, ! 1036: j, ! 1037: ConfigData->Controller[i].OriginalControllerBaseAddress, ! 1038: ConfigData->Controller[i].OriginalControllerIrql, ! 1039: &ConfigData->Controller[i].Disk[j], ! 1040: (PIDENTIFY_DATA)buffer); ! 1041: ! 1042: } ! 1043: } ! 1044: ! 1045: return STATUS_SUCCESS; ! 1046: } ! 1047: ! 1048: ! 1049: BOOLEAN ! 1050: UpdateGeometryFromBios( ! 1051: PDRIVER_OBJECT DriverObject, ! 1052: DRIVE_DATA *DriveData, ! 1053: ULONG DiskNumber ! 1054: ) ! 1055: ! 1056: /*++ ! 1057: ! 1058: Routine Description: ! 1059: ! 1060: This updates geometry information in a disk extension ! 1061: from BIOS information passed in from NTDETECT. ! 1062: ! 1063: Arguments: ! 1064: ! 1065: DriverObject - Contains pointer to NTDETECT information. ! 1066: DriveData - Store geometry in this structure. ! 1067: DiskNumber - Drive 1(0) or drive 2(1). ! 1068: ! 1069: Return Value: ! 1070: ! 1071: TRUE if information for this disk exists in registry from BIOS. ! 1072: ! 1073: --*/ ! 1074: ! 1075: { ! 1076: OBJECT_ATTRIBUTES objectAttributes; ! 1077: UNICODE_STRING valueName; ! 1078: NTSTATUS status; ! 1079: PCM_FULL_RESOURCE_DESCRIPTOR resourceDescriptor; ! 1080: PKEY_VALUE_FULL_INFORMATION keyData; ! 1081: PUCHAR buffer; ! 1082: ULONG length; ! 1083: ULONG numberOfDrives; ! 1084: HANDLE biosKey; ! 1085: PCM_INT13_DRIVE_PARAMETER int13ParamTable; ! 1086: ! 1087: // ! 1088: // Initialize the object for the key. ! 1089: // ! 1090: ! 1091: InitializeObjectAttributes( &objectAttributes, ! 1092: DriverObject->HardwareDatabase, ! 1093: OBJ_CASE_INSENSITIVE, ! 1094: NULL, ! 1095: (PSECURITY_DESCRIPTOR) NULL ); ! 1096: ! 1097: // ! 1098: // Create the key. ! 1099: // ! 1100: ! 1101: status = ZwOpenKey( ! 1102: &biosKey, ! 1103: KEY_READ, ! 1104: &objectAttributes ! 1105: ); ! 1106: ! 1107: ! 1108: if (!NT_SUCCESS(status)) { ! 1109: return FALSE; ! 1110: } ! 1111: ! 1112: RtlInitUnicodeString( &valueName, L"Configuration Data" ); ! 1113: ! 1114: keyData = ExAllocatePool(PagedPool, 2048); ! 1115: ! 1116: if (keyData == NULL) { ! 1117: ZwClose(biosKey); ! 1118: return FALSE; ! 1119: } ! 1120: ! 1121: status = ZwQueryValueKey( ! 1122: biosKey, ! 1123: &valueName, ! 1124: KeyValueFullInformation, ! 1125: keyData, ! 1126: 2048, ! 1127: &length ! 1128: ); ! 1129: ! 1130: ZwClose(biosKey); ! 1131: ! 1132: if (!NT_SUCCESS(status)) { ! 1133: ExFreePool(keyData); ! 1134: return FALSE; ! 1135: } ! 1136: ! 1137: resourceDescriptor = (PCM_FULL_RESOURCE_DESCRIPTOR) ((PUCHAR) keyData + ! 1138: keyData->DataOffset); ! 1139: ! 1140: // ! 1141: // Check that the data is long enough to hold a full resource descriptor, ! 1142: // and that the last resouce list is device-specific and long enough. ! 1143: // ! 1144: ! 1145: if (keyData->DataLength < sizeof(CM_FULL_RESOURCE_DESCRIPTOR) || ! 1146: resourceDescriptor->PartialResourceList.Count == 0 || ! 1147: resourceDescriptor->PartialResourceList.PartialDescriptors[0].Type != ! 1148: CmResourceTypeDeviceSpecific || ! 1149: resourceDescriptor->PartialResourceList.PartialDescriptors[0] ! 1150: .u.DeviceSpecificData.DataSize < sizeof(ULONG) ! 1151: ) { ! 1152: ! 1153: ExFreePool(keyData); ! 1154: return FALSE; ! 1155: } ! 1156: ! 1157: length = resourceDescriptor->PartialResourceList.PartialDescriptors[0] ! 1158: .u.DeviceSpecificData.DataSize; ! 1159: ! 1160: // ! 1161: // Point to the BIOS data. The BIOS data is located after the first ! 1162: // partial Resource list which should be device specific data. ! 1163: // ! 1164: ! 1165: buffer = (PUCHAR) keyData + keyData->DataOffset + ! 1166: sizeof(CM_FULL_RESOURCE_DESCRIPTOR); ! 1167: ! 1168: ! 1169: numberOfDrives = length / sizeof(CM_INT13_DRIVE_PARAMETER); ! 1170: ! 1171: // ! 1172: // Use the defaults if the drive number is greater than the ! 1173: // number of drives detected by the BIOS. ! 1174: // ! 1175: ! 1176: if (numberOfDrives <= DiskNumber) { ! 1177: ExFreePool(keyData); ! 1178: return FALSE; ! 1179: } ! 1180: ! 1181: // ! 1182: // Point to the array of drive parameters. ! 1183: // ! 1184: ! 1185: int13ParamTable = (PCM_INT13_DRIVE_PARAMETER) buffer + DiskNumber; ! 1186: ! 1187: // ! 1188: // Initialize this drive. ! 1189: // ! 1190: ! 1191: DriveData->BytesPerSector = 512; ! 1192: DriveData->BytesPerInterrupt = 512; ! 1193: ! 1194: DriveData->ReadCommand = 0x20; ! 1195: DriveData->WriteCommand = 0x30; ! 1196: DriveData->VerifyCommand = 0x40; ! 1197: ! 1198: DriveData->PretendNumberOfCylinders = ! 1199: DriveData->NumberOfCylinders = ! 1200: (USHORT)(int13ParamTable->MaxCylinders + 1); ! 1201: DriveData->PretendTracksPerCylinder = ! 1202: DriveData->TracksPerCylinder = ! 1203: (int13ParamTable->MaxHeads + 1); ! 1204: DriveData->PretendSectorsPerTrack = ! 1205: DriveData->SectorsPerTrack = ! 1206: int13ParamTable->SectorsPerTrack; ! 1207: DriveData->WritePrecomp = 0; ! 1208: ! 1209: return TRUE; ! 1210: } ! 1211: ! 1212: ! 1213: BOOLEAN ! 1214: UpdateGeometryFromParameterTable( ! 1215: DRIVE_DATA *DriveData, ! 1216: CCHAR *ControlFlags, ! 1217: ULONG ParameterTableOffset ! 1218: ) ! 1219: ! 1220: /*++ ! 1221: ! 1222: Routine Description: ! 1223: ! 1224: This updates geometry information in a disk extension ! 1225: from a BIOS parameter table entry. ! 1226: ! 1227: Arguments: ! 1228: ! 1229: DriveData - Store geometry in this structure. ! 1230: ControlFlags - Points to a value to set in the controller when initializing. ! 1231: ParameterTableOffset - Raw ROM address. ! 1232: ! 1233: Return Value: ! 1234: ! 1235: Nothing. ! 1236: ! 1237: --*/ ! 1238: ! 1239: { ! 1240: PFIXED_DISK_PARAMETER_TABLE parameterTable; ! 1241: ! 1242: // ! 1243: // Map system BIOS drive parameter table. ! 1244: // ! 1245: ! 1246: parameterTable = MmMapIoSpace(RtlConvertUlongToLargeInteger( ! 1247: ParameterTableOffset), ! 1248: DRIVE_PARAMETER_TABLE_LENGTH, ! 1249: FALSE); ! 1250: ! 1251: // ! 1252: // Initialize this drive. ! 1253: // ! 1254: ! 1255: DriveData->BytesPerSector = 512; ! 1256: DriveData->BytesPerInterrupt = 512; ! 1257: ! 1258: DriveData->ReadCommand = 0x20; ! 1259: DriveData->WriteCommand = 0x30; ! 1260: DriveData->VerifyCommand = 0x40; ! 1261: ! 1262: DriveData->PretendNumberOfCylinders = ! 1263: parameterTable->MaxCylinders; ! 1264: DriveData->PretendTracksPerCylinder = ! 1265: parameterTable->MaxHeads; ! 1266: DriveData->PretendSectorsPerTrack = ! 1267: parameterTable->SectorsPerTrack; ! 1268: DriveData->WritePrecomp = ! 1269: parameterTable->StartWritePrecomp; ! 1270: *ControlFlags = parameterTable->ControlFlags; ! 1271: ! 1272: // ! 1273: // Some of these values might have been "pretend" values useful for ! 1274: // dealing with DOS. If so, determine the real values. ! 1275: // ! 1276: ! 1277: if ( ( parameterTable->Signature & 0xf0 ) == 0xa0 ) { ! 1278: ! 1279: // ! 1280: // The values obtained were fake; get the real ones. ! 1281: // ! 1282: ! 1283: DriveData->NumberOfCylinders = ! 1284: parameterTable->TranslatedMaxCylinders; ! 1285: DriveData->TracksPerCylinder = ! 1286: parameterTable->TranslatedMaxHeads; ! 1287: DriveData->SectorsPerTrack = ! 1288: parameterTable->TranslatedSectorsPerTrack; ! 1289: ! 1290: } else { ! 1291: ! 1292: // ! 1293: // The values obtained were correct (as far as it goes). ! 1294: // ! 1295: ! 1296: DriveData->NumberOfCylinders = ! 1297: parameterTable->MaxCylinders; ! 1298: DriveData->TracksPerCylinder = ! 1299: parameterTable->MaxHeads; ! 1300: DriveData->SectorsPerTrack = ! 1301: parameterTable->SectorsPerTrack; ! 1302: ! 1303: ! 1304: } ! 1305: ! 1306: MmUnmapIoSpace(parameterTable, sizeof(FIXED_DISK_PARAMETER_TABLE)); ! 1307: ! 1308: return TRUE; ! 1309: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.