drivers/storage/atapi/atapi.c

   1 /*
   2  *  ReactOS kernel
   3  *  Copyright (C) 2001, 2002 ReactOS Team
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19 /* $Id$
  20  *
  21  * COPYRIGHT:   See COPYING in the top level directory
  22  * PROJECT:     ReactOS ATAPI miniport driver
  23  * FILE:        services/storage/atapi/atapi.c
  24  * PURPOSE:     ATAPI miniport driver
  25  * PROGRAMMERS: Eric Kohl (ekohl@rz-online.de)
  26  * REVISIONS:
  27  *              09-09-2001 Created
  28  */
  29
  30 /*
  31  * Note:
  32  *   This driver is derived from Rex Jolliff's ide driver. Lots of his
  33  *   routines are still in here although they belong into the higher level
  34  *   drivers. They will be moved away as soon as possible.
  35  */
  36
  37 /*
  38  * TODO:
  39  *      - implement sending of atapi commands
  40  *      - handle removable atapi non-cdrom drives
  41  */
  42
  43 #define ENABLE_PCI
  44 #define ENABLE_NATIVE_PCI
  45 #define ENABLE_ISA
  46
  47 //  -------------------------------------------------------------------------
  48
  49 #include <ddk/ntddk.h>
  50 #include <ddk/srb.h>
  51 #include <ddk/scsi.h>
  52 #include <ddk/ntddscsi.h>
  53
  54 #include "atapi.h"
  55
  56 #define NDEBUG
  57 #include <debug.h>
  58
  59 #define VERSION  "0.0.1"
  60
  61
  62 //  -------------------------------------------------------  File Static Data
  63
  64 //    ATAPI_MINIPORT_EXTENSION
  65 //
  66 //  DESCRIPTION:
  67 //    Extension to be placed in each port device object
  68 //
  69 //  ACCESS:
  70 //    Allocated from NON-PAGED POOL
  71 //    Available at any IRQL
  72 //
  73
  74 typedef struct _ATAPI_MINIPORT_EXTENSION
  75 {
  76   IDE_DRIVE_IDENTIFY DeviceParams[2];
  77   BOOLEAN DevicePresent[2];
  78   BOOLEAN DeviceAtapi[2];
  79   ULONG TransferSize[2];
  80   BOOLEAN MultiSectorCommand[2];
  81   BOOLEAN DWordIo[2];
  82
  83
  84   ULONG CommandPortBase;
  85   ULONG ControlPortBase;
  86   ULONG BusMasterRegisterBase;
  87
  88   BOOLEAN ExpectingInterrupt;
  89   PSCSI_REQUEST_BLOCK CurrentSrb;
  90
  91
  92   PUCHAR DataBuffer;
  93   ULONG DataTransferLength;
  94 } ATAPI_MINIPORT_EXTENSION, *PATAPI_MINIPORT_EXTENSION;
  95
  96
  97 typedef struct _UNIT_EXTENSION
  98 {
  99   ULONG Dummy;
 100 } UNIT_EXTENSION, *PUNIT_EXTENSION;
 101
 102 PCI_SLOT_NUMBER LastSlotNumber;
 103
 104 #ifdef ENABLE_NATIVE_PCI
 105 typedef struct _PCI_NATIVE_CONTROLLER
 106 {
 107   USHORT VendorID;
 108   USHORT DeviceID;
 109 }
 110 PCI_NATIVE_CONTROLLER, *PPCI_NATIVE_CONTROLLER;
 111
 112 PCI_NATIVE_CONTROLLER const PciNativeController[] =
 113 {
 114     {
 115         0x105A,             // Promise
 116         0x4D68,             // PDC20268, Ultra100TX2
 117     },
 118     {
 119         0x105A,             // Promise
 120         0x4D30,             // PDC20267, Ultra100
 121     }
 122 };
 123 #endif
 124
 125
 126 //  -----------------------------------------------  Discardable Declarations
 127
 128 #ifdef  ALLOC_PRAGMA
 129
 130 //  make the initialization routines discardable, so that they
 131 //  don't waste space
 132
 133 #pragma  alloc_text(init, DriverEntry)
 134 #pragma  alloc_text(init, IDECreateController)
 135 #pragma  alloc_text(init, IDEPolledRead)
 136
 137 //  make the PASSIVE_LEVEL routines pageable, so that they don't
 138 //  waste nonpaged memory
 139
 140 #pragma  alloc_text(page, IDEShutdown)
 141 #pragma  alloc_text(page, IDEDispatchOpenClose)
 142 #pragma  alloc_text(page, IDEDispatchRead)
 143 #pragma  alloc_text(page, IDEDispatchWrite)
 144
 145 #endif  /*  ALLOC_PRAGMA  */
 146
 147 //  ---------------------------------------------------- Forward Declarations
 148
 149 static ULONG STDCALL
 150 AtapiFindCompatiblePciController(PVOID DeviceExtension,
 151                                  PVOID HwContext,
 152                                  PVOID BusInformation,
 153                                  PCHAR ArgumentString,
 154                                  PPORT_CONFIGURATION_INFORMATION ConfigInfo,
 155                                  PBOOLEAN Again);
 156
 157 static ULONG STDCALL
 158 AtapiFindIsaBusController(PVOID DeviceExtension,
 159                           PVOID HwContext,
 160                           PVOID BusInformation,
 161                           PCHAR ArgumentString,
 162                           PPORT_CONFIGURATION_INFORMATION ConfigInfo,
 163                           PBOOLEAN Again);
 164
 165 static ULONG STDCALL
 166 AtapiFindNativePciController(PVOID DeviceExtension,
 167                              PVOID HwContext,
 168                              PVOID BusInformation,
 169                              PCHAR ArgumentString,
 170                              PPORT_CONFIGURATION_INFORMATION ConfigInfo,
 171                              PBOOLEAN Again);
 172
 173 static BOOLEAN STDCALL
 174 AtapiInitialize(IN PVOID DeviceExtension);
 175
 176 static BOOLEAN STDCALL
 177 AtapiResetBus(IN PVOID DeviceExtension,
 178               IN ULONG PathId);
 179
 180 static BOOLEAN STDCALL
 181 AtapiStartIo(IN PVOID DeviceExtension,
 182              IN PSCSI_REQUEST_BLOCK Srb);
 183
 184 static BOOLEAN STDCALL
 185 AtapiInterrupt(IN PVOID DeviceExtension);
 186
 187 static BOOLEAN
 188 AtapiFindDevices(PATAPI_MINIPORT_EXTENSION DeviceExtension,
 189                  PPORT_CONFIGURATION_INFORMATION ConfigInfo);
 190
 191 static BOOLEAN
 192 AtapiIdentifyDevice(IN ULONG CommandPort,
 193                     IN ULONG ControlPort,
 194                     IN ULONG DriveNum,
 195                     IN BOOLEAN Atapi,
 196                     OUT PIDE_DRIVE_IDENTIFY DrvParms);
 197
 198 static BOOLEAN
 199 IDEResetController(IN ULONG CommandPort,
 200                    IN ULONG ControlPort);
 201
 202 static int
 203 AtapiPolledRead(IN ULONG CommandPort,
 204                 IN ULONG ControlPort,
 205                 IN BYTE PreComp,
 206                 IN BYTE SectorCnt,
 207                 IN BYTE SectorNum,
 208                 IN BYTE CylinderLow,
 209                 IN BYTE CylinderHigh,
 210                 IN BYTE DrvHead,
 211                 IN BYTE Command,
 212                 OUT BYTE *Buffer);
 213
 214
 215
 216 static ULONG
 217 AtapiSendAtapiCommand(IN PATAPI_MINIPORT_EXTENSION DeviceExtension,
 218                       IN PSCSI_REQUEST_BLOCK Srb);
 219
 220 static ULONG
 221 AtapiSendIdeCommand(IN PATAPI_MINIPORT_EXTENSION DeviceExtension,
 222                     IN PSCSI_REQUEST_BLOCK Srb);
 223
 224 static ULONG
 225 AtapiInquiry(IN PATAPI_MINIPORT_EXTENSION DeviceExtension,
 226              IN PSCSI_REQUEST_BLOCK Srb);
 227
 228 static ULONG
 229 AtapiReadCapacity(IN PATAPI_MINIPORT_EXTENSION DeviceExtension,
 230                   IN PSCSI_REQUEST_BLOCK Srb);
 231
 232 static ULONG
 233 AtapiReadWrite(IN PATAPI_MINIPORT_EXTENSION DeviceExtension,
 234                IN PSCSI_REQUEST_BLOCK Srb);
 235
 236 static ULONG
 237 AtapiFlushCache(PATAPI_MINIPORT_EXTENSION DeviceExtension,
 238                 PSCSI_REQUEST_BLOCK Srb);
 239
 240 static UCHAR
 241 AtapiErrorToScsi(PVOID DeviceExtension,
 242                  PSCSI_REQUEST_BLOCK Srb);
 243
 244 //  ----------------------------------------------------------------  Inlines
 245
 246 void
 247 IDESwapBytePairs(char *Buf,
 248                  int Cnt)
 249 {
 250   char  t;
 251   int   i;
 252
 253   for (i = 0; i < Cnt; i += 2)
 254     {
 255       t = Buf[i];
 256       Buf[i] = Buf[i+1];
 257       Buf[i+1] = t;
 258     }
 259 }
 260
 261
 262 //  -------------------------------------------------------  Public Interface
 263
 264 //    DriverEntry
 265 //
 266 //  DESCRIPTION:
 267 //    This function initializes the driver, locates and claims
 268 //    hardware resources, and creates various NT objects needed
 269 //    to process I/O requests.
 270 //
 271 //  RUN LEVEL:
 272 //    PASSIVE_LEVEL
 273 //
 274 //  ARGUMENTS:
 275 //    IN  PDRIVER_OBJECT   DriverObject  System allocated Driver Object
 276 //                                       for this driver
 277 //    IN  PUNICODE_STRING  RegistryPath  Name of registry driver service
 278 //                                       key
 279 //
 280 //  RETURNS:
 281 //    NTSTATUS
 282
 283 STDCALL NTSTATUS
 284 DriverEntry(IN PDRIVER_OBJECT DriverObject,
 285             IN PUNICODE_STRING RegistryPath)
 286 {
 287   HW_INITIALIZATION_DATA InitData;
 288   NTSTATUS Status;
 289
 290   DPRINT("ATAPI Driver %s\n", VERSION);
 291   DPRINT("RegistryPath: '%wZ'\n", RegistryPath);
 292
 293   /* Initialize data structure */
 294   RtlZeroMemory(&InitData,
 295                 sizeof(HW_INITIALIZATION_DATA));
 296   InitData.HwInitializationDataSize = sizeof(HW_INITIALIZATION_DATA);
 297   InitData.HwInitialize = AtapiInitialize;
 298   InitData.HwResetBus = AtapiResetBus;
 299   InitData.HwStartIo = AtapiStartIo;
 300   InitData.HwInterrupt = AtapiInterrupt;
 301
 302   InitData.DeviceExtensionSize = sizeof(ATAPI_MINIPORT_EXTENSION);
 303   InitData.SpecificLuExtensionSize = sizeof(UNIT_EXTENSION);
 304
 305   InitData.MapBuffers = TRUE;
 306
 307
 308   /* Search the PCI bus for compatibility mode ide controllers */
 309 #ifdef ENABLE_PCI
 310   InitData.HwFindAdapter = AtapiFindCompatiblePciController;
 311   InitData.NumberOfAccessRanges = 3;
 312   InitData.AdapterInterfaceType = PCIBus;
 313
 314   InitData.VendorId = NULL;
 315   InitData.VendorIdLength = 0;
 316   InitData.DeviceId = NULL;
 317   InitData.DeviceIdLength = 0;
 318
 319   Status = ScsiPortInitialize(DriverObject,
 320                               RegistryPath,
 321                               &InitData,
 322                               NULL);
 323 //  if (newStatus < statusToReturn)
 324 //    statusToReturn = newStatus;
 325 #endif
 326
 327   /* Search the PCI bus for all ide controllers */
 328 #ifdef ENABLE_NATIVE_PCI
 329
 330   InitData.HwFindAdapter = AtapiFindNativePciController;
 331   InitData.NumberOfAccessRanges = 3;
 332   InitData.AdapterInterfaceType = PCIBus;
 333
 334   InitData.VendorId = 0;
 335   InitData.VendorIdLength = 0;
 336   InitData.DeviceId = 0;
 337   InitData.DeviceIdLength = 0;
 338
 339   LastSlotNumber.u.AsULONG = 0xFFFFFFFF;
 340
 341   Status = ScsiPortInitialize(DriverObject,
 342                               RegistryPath,
 343                               &InitData,
 344                               NULL);
 345 //  if (newStatus < statusToReturn)
 346 //    statusToReturn = newStatus;
 347 #endif
 348
 349   /* Search the ISA bus for ide controllers */
 350 #ifdef ENABLE_ISA
 351   InitData.HwFindAdapter = AtapiFindIsaBusController;
 352   InitData.NumberOfAccessRanges = 2;
 353   InitData.AdapterInterfaceType = Isa;
 354
 355   InitData.VendorId = NULL;
 356   InitData.VendorIdLength = 0;
 357   InitData.DeviceId = NULL;
 358   InitData.DeviceIdLength = 0;
 359
 360   Status = ScsiPortInitialize(DriverObject,
 361                               RegistryPath,
 362                               &InitData,
 363                               NULL);
 364 //      if (newStatus < statusToReturn)
 365 //        statusToReturn = newStatus;
 366 #endif
 367
 368   DPRINT("Returning from DriverEntry\n");
 369
 370   return(Status);
 371 }
 372
 373
 374 BOOLEAN
 375 AtapiClaimHwResources(PATAPI_MINIPORT_EXTENSION DevExt,
 376                       PPORT_CONFIGURATION_INFORMATION ConfigInfo,
 377                       INTERFACE_TYPE InterfaceType,
 378                       ULONG CommandPortBase,
 379                       ULONG ControlPortBase,
 380                       ULONG BusMasterPortBase,
 381                       ULONG InterruptVector)
 382 {
 383    SCSI_PHYSICAL_ADDRESS IoAddress;
 384    PVOID IoBase;
 385
 386    IoAddress = ScsiPortConvertUlongToPhysicalAddress(CommandPortBase);
 387    IoBase = ScsiPortGetDeviceBase((PVOID)DevExt,
 388                                   InterfaceType,
 389                                   ConfigInfo->SystemIoBusNumber,
 390                                   IoAddress,
 391                                   8,
 392                                   TRUE);
 393    if (IoBase == NULL)
 394    {
 395       return FALSE;
 396    }
 397    DevExt->CommandPortBase = (ULONG)IoBase;
 398    ConfigInfo->AccessRanges[0].RangeStart = IoAddress;
 399    ConfigInfo->AccessRanges[0].RangeLength = 8;
 400    ConfigInfo->AccessRanges[0].RangeInMemory = FALSE;
 401
 402    if (ControlPortBase)
 403    {
 404       IoAddress = ScsiPortConvertUlongToPhysicalAddress(ControlPortBase + 2);
 405       IoBase = ScsiPortGetDeviceBase((PVOID)DevExt,
 406                                      InterfaceType,
 407                                      ConfigInfo->SystemIoBusNumber,
 408                                      IoAddress,
 409                                      1,
 410                                      TRUE);
 411       if (IoBase == NULL)
 412       {
 413          ScsiPortFreeDeviceBase((PVOID)DevExt,
 414                                 (PVOID)DevExt->CommandPortBase);
 415          return FALSE;
 416       }
 417       DevExt->ControlPortBase = (ULONG)IoBase;
 418       ConfigInfo->AccessRanges[1].RangeStart = IoAddress;
 419       ConfigInfo->AccessRanges[1].RangeLength = 1;
 420       ConfigInfo->AccessRanges[1].RangeInMemory = FALSE;
 421    }
 422    if (BusMasterPortBase)
 423    {
 424       IoAddress = ScsiPortConvertUlongToPhysicalAddress(BusMasterPortBase);
 425       IoBase = ScsiPortGetDeviceBase((PVOID)DevExt,
 426                                      InterfaceType,
 427                                      ConfigInfo->SystemIoBusNumber,
 428                                      IoAddress,
 429                                      8,
 430                                      TRUE);
 431       if (IoBase == NULL)
 432       {
 433          ScsiPortFreeDeviceBase((PVOID)DevExt, (PVOID)DevExt->CommandPortBase);
 434          ScsiPortFreeDeviceBase((PVOID)DevExt, (PVOID)DevExt->ControlPortBase);
 435          return FALSE;
 436       }
 437       ConfigInfo->AccessRanges[2].RangeStart = IoAddress;
 438       ConfigInfo->AccessRanges[2].RangeLength = 8;
 439       ConfigInfo->AccessRanges[2].RangeInMemory = FALSE;
 440    }
 441    ConfigInfo->BusInterruptLevel = InterruptVector;
 442    ConfigInfo->BusInterruptVector = InterruptVector;
 443    ConfigInfo->InterruptMode = (InterfaceType == Isa) ? Latched : LevelSensitive;
 444
 445    if ((CommandPortBase == 0x1F0 || ControlPortBase == 0x3F4) && !ConfigInfo->AtdiskPrimaryClaimed)
 446    {
 447       ConfigInfo->AtdiskPrimaryClaimed = TRUE;
 448    }
 449    if ((CommandPortBase == 0x170 || ControlPortBase == 0x374) && !ConfigInfo->AtdiskSecondaryClaimed)
 450    {
 451       ConfigInfo->AtdiskSecondaryClaimed = TRUE;
 452    }
 453    return TRUE;
 454 }
 455
 456
 457 #ifdef ENABLE_PCI
 458 static ULONG STDCALL
 459 AtapiFindCompatiblePciController(PVOID DeviceExtension,
 460                                  PVOID HwContext,
 461                                  PVOID BusInformation,
 462                                  PCHAR ArgumentString,
 463                                  PPORT_CONFIGURATION_INFORMATION ConfigInfo,
 464                                  PBOOLEAN Again)
 465 {
 466   PATAPI_MINIPORT_EXTENSION DevExt = (PATAPI_MINIPORT_EXTENSION)DeviceExtension;
 467   PCI_SLOT_NUMBER SlotNumber;
 468   PCI_COMMON_CONFIG PciConfig;
 469   ULONG DataSize;
 470   ULONG StartDeviceNumber;
 471   ULONG DeviceNumber;
 472   ULONG StartFunctionNumber;
 473   ULONG FunctionNumber;
 474   BOOLEAN ChannelFound;
 475   BOOLEAN DeviceFound;
 476   ULONG BusMasterBasePort = 0;
 477
 478   DPRINT("AtapiFindCompatiblePciController() Bus: %lu  Slot: %lu\n",
 479           ConfigInfo->SystemIoBusNumber,
 480           ConfigInfo->SlotNumber);
 481
 482   *Again = FALSE;
 483
 484   /* both channels were claimed: exit */
 485   if (ConfigInfo->AtdiskPrimaryClaimed == TRUE &&
 486       ConfigInfo->AtdiskSecondaryClaimed == TRUE)
 487     return(SP_RETURN_NOT_FOUND);
 488
 489   SlotNumber.u.AsULONG = ConfigInfo->SlotNumber;
 490   StartDeviceNumber = SlotNumber.u.bits.DeviceNumber;
 491   StartFunctionNumber = SlotNumber.u.bits.FunctionNumber;
 492   for (DeviceNumber = StartDeviceNumber; DeviceNumber < PCI_MAX_DEVICES; DeviceNumber++)
 493   {
 494      SlotNumber.u.bits.DeviceNumber = DeviceNumber;
 495      for (FunctionNumber = StartFunctionNumber; FunctionNumber < PCI_MAX_FUNCTION; FunctionNumber++)
 496      {
 497         SlotNumber.u.bits.FunctionNumber = FunctionNumber;
 498         ChannelFound = FALSE;
 499         DeviceFound = FALSE;
 500
 501         DataSize = ScsiPortGetBusData(DeviceExtension,
 502                                       PCIConfiguration,
 503                                       ConfigInfo->SystemIoBusNumber,
 504                                       SlotNumber.u.AsULONG,
 505                                       &PciConfig,
 506                                       PCI_COMMON_HDR_LENGTH);
 507         if (DataSize != PCI_COMMON_HDR_LENGTH)
 508         {
 509            if (FunctionNumber == 0)
 510            {
 511               break;
 512            }
 513            else
 514            {
 515               continue;
 516            }
 517         }
 518
 519         DPRINT("%x %x\n", PciConfig.BaseClass, PciConfig.SubClass);
 520         if (PciConfig.BaseClass == 0x01 &&
 521             PciConfig.SubClass == 0x01) // &&
 522 //          (PciConfig.ProgIf & 0x05) == 0)
 523         {
 524            /* both channels are in compatibility mode */
 525            DPRINT("Bus %1lu  Device %2lu  Func %1lu  VenID 0x%04hx  DevID 0x%04hx\n",
 526                   ConfigInfo->SystemIoBusNumber,
 527                   SlotNumber.u.bits.DeviceNumber,
 528                   SlotNumber.u.bits.FunctionNumber,
 529                   PciConfig.VendorID,
 530                   PciConfig.DeviceID);
 531            DPRINT("ProgIF 0x%02hx\n", PciConfig.ProgIf);
 532
 533            DPRINT("Found IDE controller in compatibility mode!\n");
 534
 535            ConfigInfo->NumberOfBuses = 1;
 536            ConfigInfo->MaximumNumberOfTargets = 2;
 537            ConfigInfo->MaximumTransferLength = 0x10000; /* max 64Kbyte */
 538
 539            if (PciConfig.ProgIf & 0x80)
 540            {
 541               DPRINT("Found IDE Bus Master controller!\n");
 542               if (PciConfig.u.type0.BaseAddresses[4] & PCI_ADDRESS_IO_SPACE)
 543               {
 544                   BusMasterBasePort = PciConfig.u.type0.BaseAddresses[4] & PCI_ADDRESS_IO_ADDRESS_MASK;
 545                   DPRINT("  IDE Bus Master Registers at IO %lx\n", BusMasterBasePort);
 546               }
 547            }
 548            if (ConfigInfo->AtdiskPrimaryClaimed == FALSE)
 549            {
 550               /* Both channels unclaimed: Claim primary channel */
 551               DPRINT("Primary channel!\n");
 552               ChannelFound = AtapiClaimHwResources(DevExt,
 553                                                    ConfigInfo,
 554                                                    PCIBus,
 555                                                    0x1F0,
 556                                                    0x3F4,
 557                                                    BusMasterBasePort,
 558                                                    14);
 559               *Again = TRUE;
 560            }
 561            else if (ConfigInfo->AtdiskSecondaryClaimed == FALSE)
 562            {
 563               /* Primary channel already claimed: claim secondary channel */
 564               DPRINT("Secondary channel!\n");
 565
 566               ChannelFound = AtapiClaimHwResources(DevExt,
 567                                                    ConfigInfo,
 568                                                    PCIBus,
 569                                                    0x170,
 570                                                    0x374,
 571                                                    BusMasterBasePort ? BusMasterBasePort + 8 : 0,
 572                                                    15);
 573               *Again = FALSE;
 574            }
 575            /* Find attached devices */
 576            if (ChannelFound)
 577            {
 578               DeviceFound = AtapiFindDevices(DevExt, ConfigInfo);
 579               ConfigInfo->SlotNumber = SlotNumber.u.AsULONG;
 580               DPRINT("AtapiFindCompatiblePciController() returns: SP_RETURN_FOUND\n");
 581               return(SP_RETURN_FOUND);
 582            }
 583         }
 584         if (FunctionNumber == 0 && !(PciConfig.HeaderType & PCI_MULTIFUNCTION))
 585         {
 586            break;
 587         }
 588      }
 589      StartFunctionNumber = 0;
 590   }
 591   DPRINT("AtapiFindCompatiblePciController() returns: SP_RETURN_NOT_FOUND\n");
 592
 593   return(SP_RETURN_NOT_FOUND);
 594 }
 595 #endif
 596
 597
 598 #ifdef ENABLE_ISA
 599 static ULONG STDCALL
 600 AtapiFindIsaBusController(PVOID DeviceExtension,
 601                           PVOID HwContext,
 602                           PVOID BusInformation,
 603                           PCHAR ArgumentString,
 604                           PPORT_CONFIGURATION_INFORMATION ConfigInfo,
 605                           PBOOLEAN Again)
 606 {
 607   PATAPI_MINIPORT_EXTENSION DevExt = (PATAPI_MINIPORT_EXTENSION)DeviceExtension;
 608   BOOLEAN ChannelFound = FALSE;
 609   BOOLEAN DeviceFound = FALSE;
 610
 611   DPRINT("AtapiFindIsaBusController() called!\n");
 612
 613   *Again = FALSE;
 614
 615   ConfigInfo->NumberOfBuses = 1;
 616   ConfigInfo->MaximumNumberOfTargets = 2;
 617   ConfigInfo->MaximumTransferLength = 0x10000; /* max 64Kbyte */
 618
 619   if (ConfigInfo->AtdiskPrimaryClaimed == FALSE)
 620     {
 621       /* Both channels unclaimed: Claim primary channel */
 622       DPRINT("Primary channel!\n");
 623
 624       ChannelFound = AtapiClaimHwResources(DevExt,
 625                                            ConfigInfo,
 626                                            Isa,
 627                                            0x1F0,
 628                                            0x3F4,
 629                                            0,
 630                                            14);
 631       *Again = TRUE;
 632     }
 633   else if (ConfigInfo->AtdiskSecondaryClaimed == FALSE)
 634     {
 635       /* Primary channel already claimed: claim secondary channel */
 636       DPRINT("Secondary channel!\n");
 637
 638       ChannelFound = AtapiClaimHwResources(DevExt,
 639                                            ConfigInfo,
 640                                            Isa,
 641                                            0x170,
 642                                            0x374,
 643                                            0,
 644                                            15);
 645       *Again = FALSE;
 646     }
 647   else
 648     {
 649       DPRINT("AtapiFindIsaBusController() both channels claimed. Returns: SP_RETURN_NOT_FOUND\n");
 650       *Again = FALSE;
 651       return(SP_RETURN_NOT_FOUND);
 652     }
 653
 654   /* Find attached devices */
 655   if (ChannelFound)
 656     {
 657       DeviceFound = AtapiFindDevices(DevExt,
 658                                      ConfigInfo);
 659       DPRINT("AtapiFindIsaBusController() returns: SP_RETURN_FOUND\n");
 660       return(SP_RETURN_FOUND);
 661     }
 662   *Again = FALSE;
 663   return SP_RETURN_NOT_FOUND;
 664 }
 665 #endif
 666
 667
 668 #ifdef ENABLE_NATIVE_PCI
 669 static ULONG STDCALL
 670 AtapiFindNativePciController(PVOID DeviceExtension,
 671                              PVOID HwContext,
 672                              PVOID BusInformation,
 673                              PCHAR ArgumentString,
 674                              PPORT_CONFIGURATION_INFORMATION ConfigInfo,
 675                              PBOOLEAN Again)
 676 {
 677   PATAPI_MINIPORT_EXTENSION DevExt = (PATAPI_MINIPORT_EXTENSION)DeviceExtension;
 678   PCI_COMMON_CONFIG PciConfig;
 679   PCI_SLOT_NUMBER SlotNumber;
 680   ULONG DataSize;
 681   ULONG DeviceNumber;
 682   ULONG StartDeviceNumber;
 683   ULONG FunctionNumber;
 684   ULONG StartFunctionNumber;
 685   ULONG BusMasterBasePort;
 686   ULONG Count;
 687   BOOLEAN ChannelFound;
 688
 689   DPRINT("AtapiFindNativePciController() called!\n");
 690
 691   SlotNumber.u.AsULONG = ConfigInfo->SlotNumber;
 692   StartDeviceNumber = SlotNumber.u.bits.DeviceNumber;
 693   StartFunctionNumber = SlotNumber.u.bits.FunctionNumber;
 694   for (DeviceNumber = StartDeviceNumber; DeviceNumber < PCI_MAX_DEVICES; DeviceNumber++)
 695   {
 696      SlotNumber.u.bits.DeviceNumber = DeviceNumber;
 697      for (FunctionNumber = StartFunctionNumber; FunctionNumber < PCI_MAX_FUNCTION; FunctionNumber++)
 698      {
 699         SlotNumber.u.bits.FunctionNumber = FunctionNumber;
 700         DataSize = ScsiPortGetBusData(DeviceExtension,
 701                                       PCIConfiguration,
 702                                       ConfigInfo->SystemIoBusNumber,
 703                                       SlotNumber.u.AsULONG,
 704                                       &PciConfig,
 705                                       PCI_COMMON_HDR_LENGTH);
 706         if (DataSize != PCI_COMMON_HDR_LENGTH)
 707         {
 708            break;
 709         }
 710         for (Count = 0; Count < sizeof(PciNativeController)/sizeof(PCI_NATIVE_CONTROLLER); Count++)
 711         {
 712            if (PciConfig.VendorID == PciNativeController[Count].VendorID &&
 713                PciConfig.DeviceID == PciNativeController[Count].DeviceID)
 714            {
 715               break;
 716            }
 717         }
 718         if (Count < sizeof(PciNativeController)/sizeof(PCI_NATIVE_CONTROLLER))
 719         {
 720            /* We have found a known native pci ide controller */
 721            if ((PciConfig.ProgIf & 0x80) && (PciConfig.u.type0.BaseAddresses[4] & PCI_ADDRESS_IO_SPACE))
 722            {
 723               DPRINT("Found IDE Bus Master controller!\n");
 724               BusMasterBasePort = PciConfig.u.type0.BaseAddresses[4] & PCI_ADDRESS_IO_ADDRESS_MASK;
 725               DPRINT("  IDE Bus Master Registers at IO %lx\n", BusMasterBasePort);
 726            }
 727            else
 728            {
 729               BusMasterBasePort = 0;
 730            }
 731
 732            DPRINT("VendorID: %04x, DeviceID: %04x\n", PciConfig.VendorID, PciConfig.DeviceID);
 733            ConfigInfo->NumberOfBuses = 1;
 734            ConfigInfo->MaximumNumberOfTargets = 2;
 735            ConfigInfo->MaximumTransferLength = 0x10000; /* max 64Kbyte */
 736
 737            /* FIXME:
 738                 We must not store and use the last tested slot number. If there is a recall
 739                 to the some device and we will claim the primary channel again than the call
 740                 to ScsiPortGetDeviceBase in AtapiClaimHwResource will fail and we can try to
 741                 claim the secondary channel.
 742             */
 743            ChannelFound = FALSE;
 744            if (LastSlotNumber.u.AsULONG != SlotNumber.u.AsULONG)
 745            {
 746               /* try to claim primary channel */
 747               if ((PciConfig.u.type0.BaseAddresses[0] & PCI_ADDRESS_IO_SPACE) &&
 748                   (PciConfig.u.type0.BaseAddresses[1] & PCI_ADDRESS_IO_SPACE))
 749               {
 750                  /* primary channel is enabled */
 751                  ChannelFound = AtapiClaimHwResources(DevExt,
 752                                                       ConfigInfo,
 753                                                       PCIBus,
 754                                                       PciConfig.u.type0.BaseAddresses[0] & PCI_ADDRESS_IO_ADDRESS_MASK,
 755                                                       PciConfig.u.type0.BaseAddresses[1] & PCI_ADDRESS_IO_ADDRESS_MASK,
 756                                                       BusMasterBasePort,
 757                                                       PciConfig.u.type0.InterruptLine);
 758                  if (ChannelFound)
 759                  {
 760                     AtapiFindDevices(DevExt, ConfigInfo);
 761                     *Again = TRUE;
 762                     ConfigInfo->SlotNumber = LastSlotNumber.u.AsULONG = SlotNumber.u.AsULONG;
 763                     return SP_RETURN_FOUND;
 764                  }
 765               }
 766            }
 767            if (!ChannelFound)
 768            {
 769               /* try to claim secondary channel */
 770               if ((PciConfig.u.type0.BaseAddresses[2] & PCI_ADDRESS_IO_SPACE) &&
 771                   (PciConfig.u.type0.BaseAddresses[3] & PCI_ADDRESS_IO_SPACE))
 772               {
 773                  /* secondary channel is enabled */
 774                  ChannelFound = AtapiClaimHwResources(DevExt,
 775                                                       ConfigInfo,
 776                                                       PCIBus,
 777                                                       PciConfig.u.type0.BaseAddresses[2] & PCI_ADDRESS_IO_ADDRESS_MASK,
 778                                                       PciConfig.u.type0.BaseAddresses[3] & PCI_ADDRESS_IO_ADDRESS_MASK,
 779                                                       BusMasterBasePort ? BusMasterBasePort + 8 : 0,
 780                                                       PciConfig.u.type0.InterruptLine);
 781                  if (ChannelFound)
 782                  {
 783                     AtapiFindDevices(DevExt, ConfigInfo);
 784                     *Again = FALSE;
 785                     LastSlotNumber.u.AsULONG = 0xFFFFFFFF;
 786                     return SP_RETURN_FOUND;
 787                  }
 788               }
 789            }
 790         }
 791      }
 792      StartFunctionNumber = 0;
 793   }
 794   *Again = FALSE;
 795   LastSlotNumber.u.AsULONG = 0xFFFFFFFF;
 796   DPRINT("AtapiFindNativePciController() done!\n");
 797
 798   return(SP_RETURN_NOT_FOUND);
 799 }
 800 #endif
 801
 802
 803 static BOOLEAN STDCALL
 804 AtapiInitialize(IN PVOID DeviceExtension)
 805 {
 806   return(TRUE);
 807 }
 808
 809
 810 static BOOLEAN STDCALL
 811 AtapiResetBus(IN PVOID DeviceExtension,
 812               IN ULONG PathId)
 813 {
 814   return(TRUE);
 815 }
 816
 817
 818 static BOOLEAN STDCALL
 819 AtapiStartIo(IN PVOID DeviceExtension,
 820              IN PSCSI_REQUEST_BLOCK Srb)
 821 {
 822   PATAPI_MINIPORT_EXTENSION DevExt;
 823   ULONG Result;
 824
 825   DPRINT("AtapiStartIo() called\n");
 826
 827   DevExt = (PATAPI_MINIPORT_EXTENSION)DeviceExtension;
 828
 829   switch (Srb->Function)
 830     {
 831       case SRB_FUNCTION_EXECUTE_SCSI:
 832         DevExt->CurrentSrb = Srb;
 833         if (DevExt->DeviceAtapi[Srb->TargetId] == TRUE)
 834           {
 835             Result = AtapiSendAtapiCommand(DevExt,
 836                                            Srb);
 837           }
 838         else
 839           {
 840             Result = AtapiSendIdeCommand(DevExt,
 841                                          Srb);
 842           }
 843         break;
 844
 845     }
 846
 847   Srb->SrbStatus = Result;
 848
 849
 850   if (Result != SRB_STATUS_PENDING)
 851     {
 852       DevExt->CurrentSrb = NULL;
 853       Srb->SrbStatus = (UCHAR)Result;
 854
 855       ScsiPortNotification(RequestComplete,
 856                            DeviceExtension,
 857                            Srb);
 858       ScsiPortNotification(NextRequest,
 859                            DeviceExtension,
 860                            NULL);
 861     }
 862   else
 863     {
 864       DPRINT("SrbStatus = SRB_STATUS_PENDING\n");
 865     }
 866
 867   DPRINT("AtapiStartIo() done\n");
 868
 869   return(TRUE);
 870 }
 871
 872
 873 static BOOLEAN STDCALL
 874 AtapiInterrupt(IN PVOID DeviceExtension)
 875 {
 876   PATAPI_MINIPORT_EXTENSION DevExt;
 877   PSCSI_REQUEST_BLOCK Srb;
 878   ULONG CommandPortBase;
 879   ULONG ControlPortBase;
 880
 881   UCHAR DeviceStatus;
 882   BOOLEAN IsLastBlock;
 883   BOOLEAN IsAtapi;
 884   ULONG Retries;
 885   PUCHAR TargetAddress;
 886   ULONG TransferSize;
 887
 888   DPRINT("AtapiInterrupt() called!\n");
 889
 890   DevExt = (PATAPI_MINIPORT_EXTENSION)DeviceExtension;
 891
 892   CommandPortBase = DevExt->CommandPortBase;
 893   ControlPortBase = DevExt->ControlPortBase;
 894
 895   if (DevExt->ExpectingInterrupt == FALSE)
 896     {
 897       DeviceStatus = IDEReadStatus(CommandPortBase);
 898       DPRINT("AtapiInterrupt(): Unexpected interrupt (port=%x)\n", CommandPortBase);
 899       return(FALSE);
 900     }
 901
 902   /* check if it was our irq */
 903   if ((DeviceStatus = IDEReadAltStatus(ControlPortBase)) & IDE_SR_BUSY)
 904   {
 905      ScsiPortStallExecution(1);
 906      if ((DeviceStatus = IDEReadAltStatus(ControlPortBase) & IDE_SR_BUSY))
 907      {
 908         DPRINT("AtapiInterrupt(): Unexpected interrupt (port=%x)\n", CommandPortBase);
 909         return(FALSE);
 910      }
 911   }
 912
 913   Srb = DevExt->CurrentSrb;
 914   DPRINT("Srb: %p\n", Srb);
 915
 916   DPRINT("CommandPortBase: %lx  ControlPortBase: %lx\n", CommandPortBase, ControlPortBase);
 917
 918   IsAtapi = DevExt->DeviceAtapi[Srb->TargetId];
 919   DPRINT("IsAtapi == %s\n", (IsAtapi) ? "TRUE" : "FALSE");
 920
 921   IsLastBlock = FALSE;
 922
 923   DeviceStatus = IDEReadStatus(CommandPortBase);
 924   DPRINT("DeviceStatus: %x\n", DeviceStatus);
 925
 926   if ((DeviceStatus & IDE_SR_ERR) &&
 927       (Srb->Cdb[0] != SCSIOP_REQUEST_SENSE))
 928     {
 929       /* Report error condition */
 930       Srb->SrbStatus = SRB_STATUS_ERROR;
 931       IsLastBlock = TRUE;
 932     }
 933   else
 934     {
 935       if (Srb->SrbFlags & SRB_FLAGS_DATA_IN)
 936         {
 937           DPRINT("Read data\n");
 938
 939           /* Update controller/device state variables */
 940           TargetAddress = DevExt->DataBuffer;
 941
 942           if (IsAtapi)
 943             {
 944               TransferSize = IDEReadCylinderLow(CommandPortBase);
 945               TransferSize += IDEReadCylinderHigh(CommandPortBase) << 8;
 946             }
 947           else
 948             {
 949               TransferSize = DevExt->TransferSize[Srb->TargetId];
 950             }
 951
 952           DPRINT("TransferLength: %lu\n", Srb->DataTransferLength);
 953           DPRINT("TransferSize: %lu\n", TransferSize);
 954
 955           if (DevExt->DataTransferLength <= TransferSize)
 956             {
 957               if (!IsAtapi)
 958               {
 959                  TransferSize = DevExt->DataTransferLength;
 960               }
 961               DevExt->DataTransferLength = 0;
 962               IsLastBlock = TRUE;
 963             }
 964           else
 965             {
 966               DevExt->DataTransferLength -= TransferSize;
 967               IsLastBlock = FALSE;
 968             }
 969           DevExt->DataBuffer += TransferSize;
 970           DPRINT("IsLastBlock == %s\n", (IsLastBlock) ? "TRUE" : "FALSE");
 971
 972           /* Wait for DRQ assertion */
 973           for (Retries = 0; Retries < IDE_MAX_DRQ_RETRIES &&
 974                !(IDEReadStatus(CommandPortBase) & IDE_SR_DRQ);
 975                Retries++)
 976             {
 977                 KeStallExecutionProcessor(10);
 978             }
 979
 980           /* Copy the block of data */
 981           if (DevExt->DWordIo[Srb->TargetId])
 982           {
 983              IDEReadBlock32(CommandPortBase,
 984                             TargetAddress,
 985                             TransferSize);
 986           }
 987           else
 988           {
 989              IDEReadBlock(CommandPortBase,
 990                           TargetAddress,
 991                           TransferSize);
 992           }
 993           /* check DRQ */
 994           if (IsLastBlock)
 995             {
 996               for (Retries = 0; Retries < IDE_MAX_BUSY_RETRIES &&
 997                    (IDEReadStatus(CommandPortBase) & IDE_SR_BUSY);
 998                    Retries++)
 999                 {
1000                   KeStallExecutionProcessor(10);
1001                 }
1002
1003               /* Check for data overrun */
1004               while (IDEReadStatus(CommandPortBase) & IDE_SR_DRQ)
1005                 {
1006                   DPRINT1("AtapiInterrupt(): reading overrun data!\n");
1007                   IDEReadWord(CommandPortBase);
1008                 }
1009             }
1010
1011           Srb->SrbStatus = SRB_STATUS_SUCCESS;
1012         }
1013       else if (Srb->SrbFlags & SRB_FLAGS_DATA_OUT)
1014         {
1015           DPRINT("Write data\n");
1016
1017           if (DevExt->DataTransferLength == 0)
1018             {
1019               /* Check for data overrun */
1020               if (DeviceStatus & IDE_SR_DRQ)
1021                 {
1022                   /* FIXME: Handle error! */
1023                   /* This can occure if the irq is shared with an other and if the
1024                      ide controller has a write buffer. We have write the last sectors
1025                      and the other device has a irq before ours. The isr is called but
1026                      we haven't a interrupt. The controller writes the sector buffer
1027                      and the status register shows DRQ because the write is not ended. */
1028                   DPRINT("AtapiInterrupt(): data overrun error!\n");
1029                 }
1030               IsLastBlock = TRUE;
1031             }
1032           else
1033             {
1034               /* Update DevExt data */
1035               TransferSize = DevExt->TransferSize[Srb->TargetId];
1036               if (DevExt->DataTransferLength < TransferSize)
1037               {
1038                  TransferSize = DevExt->DataTransferLength;
1039               }
1040
1041               TargetAddress = DevExt->DataBuffer;
1042               DevExt->DataBuffer += TransferSize;
1043               DevExt->DataTransferLength -= TransferSize;
1044
1045               /* Write the sector */
1046               if (DevExt->DWordIo[Srb->TargetId])
1047               {
1048                  IDEWriteBlock32(CommandPortBase,
1049                                  TargetAddress,
1050                                  TransferSize);
1051               }
1052               else
1053               {
1054                  IDEWriteBlock(CommandPortBase,
1055                                TargetAddress,
1056                                TransferSize);
1057               }
1058             }
1059
1060           Srb->SrbStatus = SRB_STATUS_SUCCESS;
1061         }
1062       else
1063         {
1064           DPRINT1("Unspecified transfer direction!\n");
1065           Srb->SrbStatus = SRB_STATUS_SUCCESS; // SRB_STATUS_ERROR;
1066           IsLastBlock = TRUE;
1067         }
1068     }
1069
1070
1071   if (Srb->SrbStatus == SRB_STATUS_ERROR)
1072     {
1073       Srb->SrbStatus = AtapiErrorToScsi(DeviceExtension,
1074                                         Srb);
1075     }
1076
1077
1078   /* complete this packet */
1079   if (IsLastBlock)
1080     {
1081       DevExt->ExpectingInterrupt = FALSE;
1082
1083       ScsiPortNotification(RequestComplete,
1084                            DeviceExtension,
1085                            Srb);
1086
1087       ScsiPortNotification(NextRequest,
1088                            DeviceExtension,
1089                            NULL);
1090     }
1091
1092   DPRINT("AtapiInterrupt() done!\n");
1093
1094   return(TRUE);
1095 }
1096
1097 //  ----------------------------------------------------  Discardable statics
1098
1099
1100 /**********************************************************************
1101  * NAME                                                 INTERNAL
1102  *      AtapiFindDevices
1103  *
1104  * DESCRIPTION
1105  *      Searches for devices on the given port.
1106  *
1107  * RUN LEVEL
1108  *      PASSIVE_LEVEL
1109  *
1110  * ARGUMENTS
1111  *      DeviceExtension
1112  *              Port device specific information.
1113  *
1114  *      ConfigInfo
1115  *              Port configuration information.
1116  *
1117  * RETURN VALUE
1118  *      TRUE: At least one device is attached to the port.
1119  *      FALSE: No device is attached to the port.
1120  */
1121
1122 static BOOLEAN
1123 AtapiFindDevices(PATAPI_MINIPORT_EXTENSION DeviceExtension,
1124                  PPORT_CONFIGURATION_INFORMATION ConfigInfo)
1125 {
1126   BOOLEAN DeviceFound = FALSE;
1127   ULONG CommandPortBase;
1128   ULONG ControlPortBase;
1129   ULONG UnitNumber;
1130   ULONG Retries;
1131   BYTE High, Low;
1132
1133   DPRINT("AtapiFindDevices() called\n");
1134
1135   CommandPortBase = ScsiPortConvertPhysicalAddressToUlong(ConfigInfo->AccessRanges[0].RangeStart);
1136   DPRINT("  CommandPortBase: %x\n", CommandPortBase);
1137
1138   ControlPortBase = ScsiPortConvertPhysicalAddressToUlong(ConfigInfo->AccessRanges[1].RangeStart);
1139   DPRINT("  ControlPortBase: %x\n", ControlPortBase);
1140
1141   for (UnitNumber = 0; UnitNumber < 2; UnitNumber++)
1142     {
1143       /* Select drive */
1144       IDEWriteDriveHead(CommandPortBase,
1145                         IDE_DH_FIXED | (UnitNumber ? IDE_DH_DRV1 : 0));
1146       ScsiPortStallExecution(500);
1147
1148       /* Disable interrupts */
1149       IDEWriteDriveControl(ControlPortBase,
1150                            IDE_DC_nIEN);
1151       ScsiPortStallExecution(500);
1152
1153       /* Check if a device is attached to the interface */
1154       IDEWriteCylinderHigh(CommandPortBase, 0xaa);
1155       IDEWriteCylinderLow(CommandPortBase, 0x55);
1156
1157       High = IDEReadCylinderHigh(CommandPortBase);
1158       Low = IDEReadCylinderLow(CommandPortBase);
1159
1160       IDEWriteCylinderHigh(CommandPortBase, 0);
1161       IDEWriteCylinderLow(CommandPortBase, 0);
1162
1163       if (Low != 0x55 || High != 0xaa)
1164       {
1165          DPRINT("No Drive found. UnitNumber %d CommandPortBase %x\n", UnitNumber, CommandPortBase);
1166          continue;
1167       }
1168
1169       IDEWriteCommand(CommandPortBase, IDE_CMD_RESET);
1170
1171       for (Retries = 0; Retries < 20000; Retries++)
1172         {
1173           if (!(IDEReadStatus(CommandPortBase) & IDE_SR_BUSY))
1174             {
1175               break;
1176             }
1177           ScsiPortStallExecution(150);
1178         }
1179       if (Retries >= 20000)
1180         {
1181           DPRINT("Timeout on drive %lu\n", UnitNumber);
1182           DeviceExtension->DevicePresent[UnitNumber] = FALSE;
1183           continue;
1184         }
1185
1186       High = IDEReadCylinderHigh(CommandPortBase);
1187       Low = IDEReadCylinderLow(CommandPortBase);
1188
1189       DPRINT("  Check drive %lu: High 0x%x Low 0x%x\n",
1190              UnitNumber,
1191              High,
1192              Low);
1193
1194       if (High == 0xEB && Low == 0x14)
1195         {
1196           if (AtapiIdentifyDevice(CommandPortBase,
1197                                   ControlPortBase,
1198                                   UnitNumber,
1199                                   TRUE,
1200                                   &DeviceExtension->DeviceParams[UnitNumber]))
1201             {
1202               DPRINT("  ATAPI drive found!\n");
1203               DeviceExtension->DevicePresent[UnitNumber] = TRUE;
1204               DeviceExtension->DeviceAtapi[UnitNumber] = TRUE;
1205               DeviceExtension->TransferSize[UnitNumber] = DeviceExtension->DeviceParams[UnitNumber].BytesPerSector;
1206               DeviceExtension->MultiSectorCommand[UnitNumber] = FALSE;
1207               DeviceExtension->DWordIo[UnitNumber] = FALSE;
1208               DeviceFound = TRUE;
1209             }
1210           else
1211             {
1212               DPRINT("  No ATAPI drive found!\n");
1213             }
1214         }
1215       else
1216         {
1217           if (AtapiIdentifyDevice(CommandPortBase,
1218                                   ControlPortBase,
1219                                   UnitNumber,
1220                                   FALSE,
1221                                   &DeviceExtension->DeviceParams[UnitNumber]))
1222             {
1223               DPRINT("  IDE drive found!\n");
1224               DeviceExtension->DevicePresent[UnitNumber] = TRUE;
1225               DeviceExtension->DeviceAtapi[UnitNumber] = FALSE;
1226               DeviceExtension->TransferSize[UnitNumber] = DeviceExtension->DeviceParams[UnitNumber].BytesPerSector;
1227               if ((DeviceExtension->DeviceParams[UnitNumber].RWMultImplemented & 0x8000) &&
1228                   (DeviceExtension->DeviceParams[UnitNumber].RWMultImplemented & 0xff) &&
1229                   (DeviceExtension->DeviceParams[UnitNumber].RWMultCurrent & 0x100) &&
1230                   (DeviceExtension->DeviceParams[UnitNumber].RWMultCurrent & 0xff))
1231               {
1232                  DeviceExtension->TransferSize[UnitNumber] *= (DeviceExtension->DeviceParams[UnitNumber].RWMultCurrent & 0xff);
1233                  DeviceExtension->MultiSectorCommand[UnitNumber] = TRUE;
1234               }
1235               else
1236               {
1237                  DeviceExtension->MultiSectorCommand[UnitNumber] = FALSE;
1238               }
1239               DeviceExtension->DWordIo[UnitNumber] = DeviceExtension->DeviceParams[UnitNumber].DWordIo ? TRUE : FALSE;
1240               DeviceFound = TRUE;
1241             }
1242           else
1243             {
1244               DPRINT("  No IDE drive found!\n");
1245             }
1246         }
1247     }
1248
1249   /* Reset pending interrupts */
1250   IDEReadStatus(CommandPortBase);
1251   /* Reenable interrupts */
1252   IDEWriteDriveControl(ControlPortBase, 0);
1253   ScsiPortStallExecution(500);
1254   /* Return with drive 0 selected */
1255   IDEWriteDriveHead(CommandPortBase, IDE_DH_FIXED);
1256   ScsiPortStallExecution(500);
1257
1258   DPRINT("AtapiFindDrives() done (DeviceFound %s)\n", (DeviceFound) ? "TRUE" : "FALSE");
1259
1260   return(DeviceFound);
1261 }
1262
1263
1264 //    AtapiResetController
1265 //
1266 //  DESCRIPTION:
1267 //    Reset the controller and report completion status
1268 //
1269 //  RUN LEVEL:
1270 //    PASSIVE_LEVEL
1271 //
1272 //  ARGUMENTS:
1273 //    IN  WORD  CommandPort  The address of the command port
1274 //    IN  WORD  ControlPort  The address of the control port
1275 //
1276 //  RETURNS:
1277 //
1278
1279 static BOOLEAN
1280 AtapiResetController(IN ULONG CommandPort,
1281                      IN ULONG ControlPort)
1282 {
1283   int Retries;
1284
1285   /* Assert drive reset line */
1286   IDEWriteDriveControl(ControlPort, IDE_DC_SRST);
1287
1288   /* Wait for min. 25 microseconds */
1289   ScsiPortStallExecution(IDE_RESET_PULSE_LENGTH);
1290
1291   /* Negate drive reset line */
1292   IDEWriteDriveControl(ControlPort, 0);
1293
1294   /* Wait for BUSY negation */
1295   for (Retries = 0; Retries < IDE_RESET_BUSY_TIMEOUT * 1000; Retries++)
1296     {
1297       if (!(IDEReadStatus(CommandPort) & IDE_SR_BUSY))
1298         {
1299           break;
1300         }
1301       ScsiPortStallExecution(10);
1302     }
1303
1304   if (Retries >= IDE_RESET_BUSY_TIMEOUT * 1000)
1305     {
1306       return(FALSE);
1307     }
1308
1309     //  return TRUE if controller came back to life. and
1310     //  the registers are initialized correctly
1311   return(IDEReadError(CommandPort) == 1);
1312 }
1313
1314 /*
1315  *  AtapiIdentifyDevice
1316  *
1317  *  DESCRIPTION:
1318  *      Get the identification block from the drive
1319  *
1320  *  RUN LEVEL:
1321  *      PASSIVE_LEVEL
1322  *
1323  *  ARGUMENTS:
1324  *      CommandPort
1325  *              Address of the command port
1326  *      ControlPort
1327  *              Address of the control port
1328  *      DriveNum
1329  *              The drive index (0,1)
1330  *      Atapi
1331  *              Send an ATA(FALSE) or an ATAPI(TRUE) identify comand
1332  *      DrvParms
1333  *              Address to write drive ident block
1334  *
1335  *  RETURNS:
1336  *      TRUE: The drive identification block was retrieved successfully
1337  *      FALSE: an error ocurred
1338  */
1339
1340 static BOOLEAN
1341 AtapiIdentifyDevice(IN ULONG CommandPort,
1342                     IN ULONG ControlPort,
1343                     IN ULONG DriveNum,
1344                     IN BOOLEAN Atapi,
1345                     OUT PIDE_DRIVE_IDENTIFY DrvParms)
1346 {
1347   LONG i;
1348
1349   /*  Get the Drive Identify block from drive or die  */
1350   if (AtapiPolledRead(CommandPort,
1351                       ControlPort,
1352                       0,
1353                       1,
1354                       0,
1355                       0,
1356                       0,
1357                       (DriveNum ? IDE_DH_DRV1 : 0),
1358                       (Atapi ? IDE_CMD_IDENT_ATAPI_DRV : IDE_CMD_IDENT_ATA_DRV),
1359                       (BYTE *)DrvParms) != 0)
1360     {
1361       DPRINT("IDEPolledRead() failed\n");
1362       return(FALSE);
1363     }
1364
1365   /*  Report on drive parameters if debug mode  */
1366   IDESwapBytePairs(DrvParms->SerialNumber, 20);
1367   IDESwapBytePairs(DrvParms->FirmwareRev, 8);
1368   IDESwapBytePairs(DrvParms->ModelNumber, 40);
1369   DPRINT("Config:%04x  Cyls:%5d  Heads:%2d  Sectors/Track:%3d  Gaps:%02d %02d\n",
1370          DrvParms->ConfigBits,
1371          DrvParms->LogicalCyls,
1372          DrvParms->LogicalHeads,
1373          DrvParms->SectorsPerTrack,
1374          DrvParms->InterSectorGap,
1375          DrvParms->InterSectorGapSize);
1376   DPRINT("Bytes/PLO:%3d  Vendor Cnt:%2d  Serial number:[%.20s]\n",
1377          DrvParms->BytesInPLO,
1378          DrvParms->VendorUniqueCnt,
1379          DrvParms->SerialNumber);
1380   DPRINT("Cntlr type:%2d  BufSiz:%5d  ECC bytes:%3d  Firmware Rev:[%.8s]\n",
1381          DrvParms->ControllerType,
1382          DrvParms->BufferSize * IDE_SECTOR_BUF_SZ,
1383          DrvParms->ECCByteCnt,
1384          DrvParms->FirmwareRev);
1385   DPRINT("Model:[%.40s]\n", DrvParms->ModelNumber);
1386   DPRINT("RWMultMax?:%04x  RWMult?:%02x  LBA:%d  DMA:%d  MinPIO:%d ns  MinDMA:%d ns\n",
1387          (DrvParms->RWMultImplemented),
1388          (DrvParms->RWMultCurrent) & 0xff,
1389          (DrvParms->Capabilities & IDE_DRID_LBA_SUPPORTED) ? 1 : 0,
1390          (DrvParms->Capabilities & IDE_DRID_DMA_SUPPORTED) ? 1 : 0,
1391          DrvParms->MinPIOTransTime,
1392          DrvParms->MinDMATransTime);
1393   DPRINT("TM:Cyls:%d  Heads:%d  Sectors/Trk:%d Capacity:%ld\n",
1394          DrvParms->TMCylinders,
1395          DrvParms->TMHeads,
1396          DrvParms->TMSectorsPerTrk,
1397          (ULONG)(DrvParms->TMCapacityLo + (DrvParms->TMCapacityHi << 16)));
1398   DPRINT("TM:SectorCount: 0x%04x%04x = %lu\n",
1399          DrvParms->TMSectorCountHi,
1400          DrvParms->TMSectorCountLo,
1401          (ULONG)((DrvParms->TMSectorCountHi << 16) + DrvParms->TMSectorCountLo));
1402
1403   if (! Atapi && 0 != (DrvParms->Capabilities & IDE_DRID_LBA_SUPPORTED))
1404     {
1405       /* LBA ATA drives always have a sector size of 512 */
1406       DrvParms->BytesPerSector = 512;
1407     }
1408   else
1409     {
1410       DPRINT("BytesPerSector %d\n", DrvParms->BytesPerSector);
1411       if (DrvParms->BytesPerSector == 0)
1412         {
1413           DrvParms->BytesPerSector = 512;
1414         }
1415       else
1416         {
1417           for (i = 15; i >= 0; i--)
1418             {
1419               if (DrvParms->BytesPerSector & (1 << i))
1420                 {
1421                   DrvParms->BytesPerSector = 1 << i;
1422                   break;
1423                 }
1424             }
1425         }
1426     }
1427   DPRINT("BytesPerSector %d\n", DrvParms->BytesPerSector);
1428
1429   return(TRUE);
1430 }
1431
1432
1433 //    AtapiPolledRead
1434 //
1435 //  DESCRIPTION:
1436 //    Read a sector of data from the drive in a polled fashion.
1437 //
1438 //  RUN LEVEL:
1439 //    PASSIVE_LEVEL
1440 //
1441 //  ARGUMENTS:
1442 //    IN   WORD  Address       Address of command port for drive
1443 //    IN   BYTE  PreComp       Value to write to precomp register
1444 //    IN   BYTE  SectorCnt     Value to write to sectorCnt register
1445 //    IN   BYTE  SectorNum     Value to write to sectorNum register
1446 //    IN   BYTE  CylinderLow   Value to write to CylinderLow register
1447 //    IN   BYTE  CylinderHigh  Value to write to CylinderHigh register
1448 //    IN   BYTE  DrvHead       Value to write to Drive/Head register
1449 //    IN   BYTE  Command       Value to write to Command register
1450 //    OUT  BYTE  *Buffer       Buffer for output data
1451 //
1452 //  RETURNS:
1453 //    int  0 is success, non 0 is an error code
1454 //
1455
1456 static int
1457 AtapiPolledRead(IN ULONG CommandPort,
1458                 IN ULONG ControlPort,
1459                 IN BYTE PreComp,
1460                 IN BYTE SectorCnt,
1461                 IN BYTE SectorNum,
1462                 IN BYTE CylinderLow,
1463                 IN BYTE CylinderHigh,
1464                 IN BYTE DrvHead,
1465                 IN BYTE Command,
1466                 OUT BYTE *Buffer)
1467 {
1468   ULONG SectorCount = 0;
1469   ULONG RetryCount;
1470   BOOLEAN Junk = FALSE;
1471   UCHAR Status;
1472
1473 //#if 0
1474   /* Wait for BUSY to clear */
1475   for (RetryCount = 0; RetryCount < IDE_MAX_BUSY_RETRIES; RetryCount++)
1476     {
1477       Status = IDEReadStatus(CommandPort);
1478       if (!(Status & IDE_SR_BUSY))
1479         {
1480           break;
1481         }
1482       ScsiPortStallExecution(10);
1483     }
1484   DPRINT("status=%02x\n", Status);
1485   DPRINT("waited %ld usecs for busy to clear\n", RetryCount * 10);
1486   if (RetryCount >= IDE_MAX_BUSY_RETRIES)
1487     {
1488       DPRINT("Drive is BUSY for too long\n");
1489       return(IDE_ER_ABRT);
1490     }
1491 //#endif
1492
1493   /*  Write Drive/Head to select drive  */
1494   IDEWriteDriveHead(CommandPort, IDE_DH_FIXED | DrvHead);
1495   ScsiPortStallExecution(500);
1496
1497   /* Disable interrupts */
1498   IDEWriteDriveControl(ControlPort, IDE_DC_nIEN);
1499   ScsiPortStallExecution(500);
1500
1501 #if 0
1502   /*  Wait for STATUS.BUSY and STATUS.DRQ to clear  */
1503   for (RetryCount = 0; RetryCount < IDE_MAX_BUSY_RETRIES; RetryCount++)
1504     {
1505       Status = IDEReadStatus(CommandPort);
1506       if (!(Status & IDE_SR_BUSY) && !(Status & IDE_SR_DRQ))
1507         {
1508           break;
1509         }
1510       ScsiPortStallExecution(10);
1511     }
1512   if (RetryCount >= IDE_MAX_BUSY_RETRIES)
1513     {
1514       return IDE_ER_ABRT;
1515     }
1516 #endif
1517
1518   /*  Issue command to drive  */
1519   if (DrvHead & IDE_DH_LBA)
1520     {
1521       DPRINT("READ:DRV=%d:LBA=1:BLK=%08d:SC=%02x:CM=%02x\n",
1522              DrvHead & IDE_DH_DRV1 ? 1 : 0,
1523              ((DrvHead & 0x0f) << 24) + (CylinderHigh << 16) + (CylinderLow << 8) + SectorNum,
1524              SectorCnt,
1525              Command);
1526     }
1527   else
1528     {
1529       DPRINT("READ:DRV=%d:LBA=0:CH=%02x:CL=%02x:HD=%01x:SN=%02x:SC=%02x:CM=%02x\n",
1530              DrvHead & IDE_DH_DRV1 ? 1 : 0,
1531              CylinderHigh,
1532              CylinderLow,
1533              DrvHead & 0x0f,
1534              SectorNum,
1535              SectorCnt,
1536              Command);
1537     }
1538
1539   /*  Setup command parameters  */
1540   IDEWritePrecomp(CommandPort, PreComp);
1541   IDEWriteSectorCount(CommandPort, SectorCnt);
1542   IDEWriteSectorNum(CommandPort, SectorNum);
1543   IDEWriteCylinderHigh(CommandPort, CylinderHigh);
1544   IDEWriteCylinderLow(CommandPort, CylinderLow);
1545   IDEWriteDriveHead(CommandPort, IDE_DH_FIXED | DrvHead);
1546
1547   /*  Issue the command  */
1548   IDEWriteCommand(CommandPort, Command);
1549   ScsiPortStallExecution(50);
1550
1551   /*  wait for DRQ or error  */
1552   for (RetryCount = 0; RetryCount < IDE_MAX_POLL_RETRIES; RetryCount++)
1553     {
1554       Status = IDEReadStatus(CommandPort);
1555       if (!(Status & IDE_SR_BUSY))
1556         {
1557           if (Status & IDE_SR_ERR)
1558             {
1559               IDEWriteDriveControl(ControlPort, 0);
1560               ScsiPortStallExecution(50);
1561               IDEReadStatus(CommandPort);
1562
1563               return(IDE_ER_ABRT);
1564             }
1565           if (Status & IDE_SR_DRQ)
1566             {
1567               break;
1568             }
1569           else
1570             {
1571               IDEWriteDriveControl(ControlPort, 0);
1572               ScsiPortStallExecution(50);
1573               IDEReadStatus(CommandPort);
1574
1575               return(IDE_ER_ABRT);
1576             }
1577         }
1578       ScsiPortStallExecution(10);
1579     }
1580
1581   /*  timed out  */
1582   if (RetryCount >= IDE_MAX_POLL_RETRIES)
1583     {
1584       IDEWriteDriveControl(ControlPort, 0);
1585       ScsiPortStallExecution(50);
1586       IDEReadStatus(CommandPort);
1587
1588       return(IDE_ER_ABRT);
1589     }
1590
1591   while (1)
1592     {
1593       /*  Read data into buffer  */
1594       if (Junk == FALSE)
1595         {
1596           IDEReadBlock(CommandPort, Buffer, IDE_SECTOR_BUF_SZ);
1597           Buffer += IDE_SECTOR_BUF_SZ;
1598         }
1599       else
1600         {
1601           UCHAR JunkBuffer[IDE_SECTOR_BUF_SZ];
1602           IDEReadBlock(CommandPort, JunkBuffer, IDE_SECTOR_BUF_SZ);
1603         }
1604       SectorCount++;
1605
1606       /*  Check for error or more sectors to read  */
1607       for (RetryCount = 0; RetryCount < IDE_MAX_BUSY_RETRIES; RetryCount++)
1608         {
1609           Status = IDEReadStatus(CommandPort);
1610           if (!(Status & IDE_SR_BUSY))
1611             {
1612               if (Status & IDE_SR_ERR)
1613                 {
1614                   IDEWriteDriveControl(ControlPort, 0);
1615                   ScsiPortStallExecution(50);
1616                   IDEReadStatus(CommandPort);
1617
1618                   return(IDE_ER_ABRT);
1619                 }
1620               if (Status & IDE_SR_DRQ)
1621                 {
1622                   if (SectorCount >= SectorCnt)
1623                     {
1624                       DPRINT("Buffer size exceeded!\n");
1625                       Junk = TRUE;
1626                     }
1627                   break;
1628                 }
1629               else
1630                 {
1631                   if (SectorCount > SectorCnt)
1632                     {
1633                       DPRINT("Read %lu sectors of junk!\n",
1634                              SectorCount - SectorCnt);
1635                     }
1636                   IDEWriteDriveControl(ControlPort, 0);
1637                   ScsiPortStallExecution(50);
1638                   IDEReadStatus(CommandPort);
1639
1640                   return(0);
1641                 }
1642             }
1643         }
1644     }
1645 }
1646
1647
1648 //  -------------------------------------------  Nondiscardable statics
1649
1650 static ULONG
1651 AtapiSendAtapiCommand(IN PATAPI_MINIPORT_EXTENSION DeviceExtension,
1652                       IN PSCSI_REQUEST_BLOCK Srb)
1653 {
1654   UCHAR ByteCountHigh;
1655   UCHAR ByteCountLow;
1656   ULONG Retries;
1657   ULONG CdbSize;
1658   UCHAR Status;
1659
1660   DPRINT("AtapiSendAtapiCommand() called!\n");
1661
1662   if (Srb->PathId != 0)
1663     {
1664       Srb->SrbStatus = SRB_STATUS_INVALID_PATH_ID;
1665       return(SRB_STATUS_INVALID_PATH_ID);
1666     }
1667
1668   if (Srb->TargetId > 1)
1669     {
1670       Srb->SrbStatus = SRB_STATUS_INVALID_TARGET_ID;
1671       return(SRB_STATUS_INVALID_TARGET_ID);
1672     }
1673
1674   if (Srb->Lun != 0)
1675     {
1676       Srb->SrbStatus = SRB_STATUS_INVALID_LUN;
1677       return(SRB_STATUS_INVALID_LUN);
1678     }
1679
1680   if (DeviceExtension->DevicePresent[Srb->TargetId] == FALSE)
1681     {
1682       Srb->SrbStatus = SRB_STATUS_NO_DEVICE;
1683       return(SRB_STATUS_NO_DEVICE);
1684     }
1685
1686   DPRINT("AtapiSendAtapiCommand(): TargetId: %lu\n",
1687          Srb->TargetId);
1688
1689   if (Srb->Cdb[0] == SCSIOP_INQUIRY)
1690     return(AtapiInquiry(DeviceExtension,
1691                         Srb));
1692
1693   /* Set pointer to data buffer. */
1694   DeviceExtension->DataBuffer = (PUCHAR)Srb->DataBuffer;
1695   DeviceExtension->DataTransferLength = Srb->DataTransferLength;
1696   DeviceExtension->CurrentSrb = Srb;
1697
1698   /* Wait for BUSY to clear */
1699   for (Retries = 0; Retries < IDE_MAX_BUSY_RETRIES; Retries++)
1700     {
1701       Status = IDEReadStatus(DeviceExtension->CommandPortBase);
1702       if (!(Status & IDE_SR_BUSY))
1703         {
1704           break;
1705         }
1706       ScsiPortStallExecution(10);
1707     }
1708   DPRINT("status=%02x\n", Status);
1709   DPRINT("waited %ld usecs for busy to clear\n", Retries * 10);
1710   if (Retries >= IDE_MAX_BUSY_RETRIES)
1711     {
1712       DPRINT("Drive is BUSY for too long\n");
1713       return(SRB_STATUS_BUSY);
1714     }
1715
1716   /* Select the desired drive */
1717   IDEWriteDriveHead(DeviceExtension->CommandPortBase,
1718                     IDE_DH_FIXED | (Srb->TargetId ? IDE_DH_DRV1 : 0));
1719
1720   /* Wait a little while */
1721   ScsiPortStallExecution(50);
1722
1723 #if 0
1724   /* Wait for BUSY to clear and DRDY to assert */
1725   for (Retries = 0; Retries < IDE_MAX_BUSY_RETRIES; Retries++)
1726     {
1727       Status = IDEReadStatus(DeviceExtension->CommandPortBase);
1728       if (!(Status & IDE_SR_BUSY) && (Status & IDE_SR_DRDY))
1729         {
1730           break;
1731         }
1732       ScsiPortStallExecution(10);
1733     }
1734   DPRINT("waited %ld usecs for busy to clear after drive select\n", Retries * 10);
1735   if (Retries >= IDE_MAX_BUSY_RETRIES)
1736     {
1737       DPRINT("Drive is BUSY for too long after drive select\n");
1738       return(SRB_STATUS_BUSY);
1739     }
1740 #endif
1741
1742   if (DeviceExtension->DataTransferLength < 0x10000)
1743     {
1744       ByteCountLow = (UCHAR)(DeviceExtension->DataTransferLength & 0xFF);
1745       ByteCountHigh = (UCHAR)(DeviceExtension->DataTransferLength >> 8);
1746     }
1747   else
1748     {
1749       ByteCountLow = 0xFF;
1750       ByteCountHigh = 0xFF;
1751     }
1752
1753   /* Set feature register */
1754   IDEWritePrecomp(DeviceExtension->CommandPortBase, 0);
1755
1756   /* Set command packet length */
1757   IDEWriteCylinderHigh(DeviceExtension->CommandPortBase, ByteCountHigh);
1758   IDEWriteCylinderLow(DeviceExtension->CommandPortBase, ByteCountLow);
1759
1760   /* Issue command to drive */
1761   IDEWriteCommand(DeviceExtension->CommandPortBase, IDE_CMD_PACKET);
1762
1763   /* Wait for DRQ to assert */
1764   for (Retries = 0; Retries < IDE_MAX_BUSY_RETRIES; Retries++)
1765     {
1766       Status = IDEReadStatus(DeviceExtension->CommandPortBase);
1767       if ((Status & IDE_SR_DRQ))
1768         {
1769           break;
1770         }
1771       ScsiPortStallExecution(10);
1772     }
1773
1774   CdbSize = (DeviceExtension->DeviceParams[Srb->TargetId].ConfigBits & 0x3 == 1) ? 16 : 12;
1775   DPRINT("CdbSize: %lu\n", CdbSize);
1776
1777   /* Write command packet */
1778   IDEWriteBlock(DeviceExtension->CommandPortBase,
1779                 (PUSHORT)Srb->Cdb,
1780                 CdbSize);
1781
1782   DeviceExtension->ExpectingInterrupt = TRUE;
1783
1784   DPRINT("AtapiSendAtapiCommand() done\n");
1785
1786   return(SRB_STATUS_PENDING);
1787 }
1788
1789
1790 static ULONG
1791 AtapiSendIdeCommand(IN PATAPI_MINIPORT_EXTENSION DeviceExtension,
1792                     IN PSCSI_REQUEST_BLOCK Srb)
1793 {
1794   ULONG SrbStatus = SRB_STATUS_SUCCESS;
1795
1796   DPRINT("AtapiSendIdeCommand() called!\n");
1797
1798   DPRINT("PathId: %lu  TargetId: %lu  Lun: %lu\n",
1799          Srb->PathId,
1800          Srb->TargetId,
1801          Srb->Lun);
1802
1803   switch (Srb->Cdb[0])
1804     {
1805       case SCSIOP_INQUIRY:
1806         SrbStatus = AtapiInquiry(DeviceExtension,
1807                                  Srb);
1808         break;
1809
1810       case SCSIOP_READ_CAPACITY:
1811         SrbStatus = AtapiReadCapacity(DeviceExtension,
1812                                       Srb);
1813         break;
1814
1815       case SCSIOP_READ:
1816       case SCSIOP_WRITE:
1817         SrbStatus = AtapiReadWrite(DeviceExtension,
1818                                    Srb);
1819         break;
1820
1821       case SCSIOP_SYNCHRONIZE_CACHE:
1822         SrbStatus = AtapiFlushCache(DeviceExtension,
1823                                     Srb);
1824         break;
1825
1826       case SCSIOP_MODE_SENSE:
1827       case SCSIOP_TEST_UNIT_READY:
1828       case SCSIOP_VERIFY:
1829       case SCSIOP_START_STOP_UNIT:
1830       case SCSIOP_REQUEST_SENSE:
1831         break;
1832
1833      default:
1834         DbgPrint("AtapiSendIdeCommand():unknown command %x\n",
1835                  Srb->Cdb[0]);
1836         SrbStatus = SRB_STATUS_INVALID_REQUEST;
1837         break;
1838     }
1839
1840   DPRINT("AtapiSendIdeCommand() done!\n");
1841
1842   return(SrbStatus);
1843 }
1844
1845
1846 static ULONG
1847 AtapiInquiry(PATAPI_MINIPORT_EXTENSION DeviceExtension,
1848              PSCSI_REQUEST_BLOCK Srb)
1849 {
1850   PIDE_DRIVE_IDENTIFY DeviceParams;
1851   PINQUIRYDATA InquiryData;
1852   ULONG i;
1853
1854   DPRINT("SCSIOP_INQUIRY: DeviceExtension %p  TargetId: %lu\n",
1855          DeviceExtension, Srb->TargetId);
1856
1857   if (Srb->PathId != 0)
1858     {
1859       Srb->SrbStatus = SRB_STATUS_INVALID_PATH_ID;
1860       return(SRB_STATUS_INVALID_PATH_ID);
1861     }
1862
1863   if (Srb->TargetId > 1)
1864     {
1865       Srb->SrbStatus = SRB_STATUS_INVALID_TARGET_ID;
1866       return(SRB_STATUS_INVALID_TARGET_ID);
1867     }
1868
1869   if (Srb->Lun != 0)
1870     {
1871       Srb->SrbStatus = SRB_STATUS_INVALID_LUN;
1872       return(SRB_STATUS_INVALID_LUN);
1873     }
1874
1875   if (DeviceExtension->DevicePresent[Srb->TargetId] == FALSE)
1876     {
1877       Srb->SrbStatus = SRB_STATUS_NO_DEVICE;
1878       return(SRB_STATUS_NO_DEVICE);
1879     }
1880
1881   InquiryData = Srb->DataBuffer;
1882   DeviceParams = &DeviceExtension->DeviceParams[Srb->TargetId];
1883
1884   /* clear buffer */
1885   for (i = 0; i < Srb->DataTransferLength; i++)
1886     {
1887       ((PUCHAR)Srb->DataBuffer)[i] = 0;
1888     }
1889
1890   /* set device class */
1891   if (DeviceExtension->DeviceAtapi[Srb->TargetId] == FALSE)
1892     {
1893       /* hard-disk */
1894       InquiryData->DeviceType = DIRECT_ACCESS_DEVICE;
1895     }
1896   else
1897     {
1898       /* get it from the ATAPI configuration word */
1899       InquiryData->DeviceType = (DeviceParams->ConfigBits >> 8) & 0x1F;
1900       DPRINT("Device class: %u\n", InquiryData->DeviceType);
1901     }
1902
1903   DPRINT("ConfigBits: 0x%x\n", DeviceParams->ConfigBits);
1904   if (DeviceParams->ConfigBits & 0x80)
1905     {
1906       DPRINT("Removable media!\n");
1907       InquiryData->RemovableMedia = 1;
1908     }
1909
1910   for (i = 0; i < 20; i += 2)
1911     {
1912       InquiryData->VendorId[i] =
1913         ((PUCHAR)DeviceParams->ModelNumber)[i];
1914       InquiryData->VendorId[i+1] =
1915         ((PUCHAR)DeviceParams->ModelNumber)[i+1];
1916     }
1917
1918   for (i = 0; i < 4; i++)
1919     {
1920       InquiryData->ProductId[12+i] = ' ';
1921     }
1922
1923   for (i = 0; i < 4; i += 2)
1924     {
1925       InquiryData->ProductRevisionLevel[i] =
1926         ((PUCHAR)DeviceParams->FirmwareRev)[i];
1927       InquiryData->ProductRevisionLevel[i+1] =
1928         ((PUCHAR)DeviceParams->FirmwareRev)[i+1];
1929     }
1930
1931   DPRINT("VendorId: '%.20s'\n", InquiryData->VendorId);
1932
1933   Srb->SrbStatus = SRB_STATUS_SUCCESS;
1934   return(SRB_STATUS_SUCCESS);
1935 }
1936
1937
1938 static ULONG
1939 AtapiReadCapacity(PATAPI_MINIPORT_EXTENSION DeviceExtension,
1940                   PSCSI_REQUEST_BLOCK Srb)
1941 {
1942   PREAD_CAPACITY_DATA CapacityData;
1943   PIDE_DRIVE_IDENTIFY DeviceParams;
1944   ULONG LastSector;
1945
1946   DPRINT("SCSIOP_READ_CAPACITY: TargetId: %lu\n", Srb->TargetId);
1947
1948   if (Srb->PathId != 0)
1949     {
1950       Srb->SrbStatus = SRB_STATUS_INVALID_PATH_ID;
1951       return(SRB_STATUS_INVALID_PATH_ID);
1952     }
1953
1954   if (Srb->TargetId > 1)
1955     {
1956       Srb->SrbStatus = SRB_STATUS_INVALID_TARGET_ID;
1957       return(SRB_STATUS_INVALID_TARGET_ID);
1958     }
1959
1960   if (Srb->Lun != 0)
1961     {
1962       Srb->SrbStatus = SRB_STATUS_INVALID_LUN;
1963       return(SRB_STATUS_INVALID_LUN);
1964     }
1965
1966   if (DeviceExtension->DevicePresent[Srb->TargetId] == FALSE)
1967     {
1968       Srb->SrbStatus = SRB_STATUS_NO_DEVICE;
1969       return(SRB_STATUS_NO_DEVICE);
1970     }
1971
1972   CapacityData = (PREAD_CAPACITY_DATA)Srb->DataBuffer;
1973   DeviceParams = &DeviceExtension->DeviceParams[Srb->TargetId];
1974
1975   /* Set sector (block) size to 512 bytes (big-endian). */
1976   CapacityData->BytesPerBlock = 0x20000;
1977
1978   /* Calculate last sector (big-endian). */
1979   if (DeviceParams->Capabilities & IDE_DRID_LBA_SUPPORTED)
1980     {
1981       LastSector = (ULONG)((DeviceParams->TMSectorCountHi << 16) +
1982                             DeviceParams->TMSectorCountLo) - 1;
1983     }
1984   else
1985     {
1986       LastSector = (ULONG)(DeviceParams->LogicalCyls *
1987                            DeviceParams->LogicalHeads *
1988                            DeviceParams->SectorsPerTrack)-1;
1989     }
1990
1991   CapacityData->LogicalBlockAddress = (((PUCHAR)&LastSector)[0] << 24) |
1992                                       (((PUCHAR)&LastSector)[1] << 16) |
1993                                       (((PUCHAR)&LastSector)[2] << 8) |
1994                                       ((PUCHAR)&LastSector)[3];
1995
1996   DPRINT("LastCount: %lu (%08lx / %08lx)\n",
1997          LastSector,
1998          LastSector,
1999          CapacityData->LogicalBlockAddress);
2000
2001   Srb->SrbStatus = SRB_STATUS_SUCCESS;
2002   return(SRB_STATUS_SUCCESS);
2003 }
2004
2005
2006 static ULONG
2007 AtapiReadWrite(PATAPI_MINIPORT_EXTENSION DeviceExtension,
2008                PSCSI_REQUEST_BLOCK Srb)
2009 {
2010   PIDE_DRIVE_IDENTIFY DeviceParams;
2011   ULONG StartingSector;
2012   ULONG SectorCount;
2013   UCHAR CylinderHigh;
2014   UCHAR CylinderLow;
2015   UCHAR DrvHead;
2016   UCHAR SectorNumber;
2017   UCHAR Command;
2018   ULONG Retries;
2019   UCHAR Status;
2020
2021   DPRINT("AtapiReadWrite() called!\n");
2022
2023   if (Srb->PathId != 0)
2024     {
2025       Srb->SrbStatus = SRB_STATUS_INVALID_PATH_ID;
2026       return(SRB_STATUS_INVALID_PATH_ID);
2027     }
2028
2029   if (Srb->TargetId > 1)
2030     {
2031       Srb->SrbStatus = SRB_STATUS_INVALID_TARGET_ID;
2032       return(SRB_STATUS_INVALID_TARGET_ID);
2033     }
2034
2035   if (Srb->Lun != 0)
2036     {
2037       Srb->SrbStatus = SRB_STATUS_INVALID_LUN;
2038       return(SRB_STATUS_INVALID_LUN);
2039     }
2040
2041   if (DeviceExtension->DevicePresent[Srb->TargetId] == FALSE)
2042     {
2043       Srb->SrbStatus = SRB_STATUS_NO_DEVICE;
2044       return(SRB_STATUS_NO_DEVICE);
2045     }
2046
2047   DPRINT("SCSIOP_WRITE: TargetId: %lu\n",
2048          Srb->TargetId);
2049
2050   DeviceParams = &DeviceExtension->DeviceParams[Srb->TargetId];
2051
2052   /* Get starting sector number from CDB. */
2053   StartingSector = ((PCDB)Srb->Cdb)->CDB10.LogicalBlockByte3 |
2054                    ((PCDB)Srb->Cdb)->CDB10.LogicalBlockByte2 << 8 |
2055                    ((PCDB)Srb->Cdb)->CDB10.LogicalBlockByte1 << 16 |
2056                    ((PCDB)Srb->Cdb)->CDB10.LogicalBlockByte0 << 24;
2057
2058   SectorCount = (Srb->DataTransferLength + DeviceParams->BytesPerSector - 1) /
2059                 DeviceParams->BytesPerSector;
2060
2061   DPRINT("Starting sector %lu  Number of bytes %lu  Sectors %lu\n",
2062          StartingSector,
2063          Srb->DataTransferLength,
2064          SectorCount);
2065
2066   if (DeviceParams->Capabilities & IDE_DRID_LBA_SUPPORTED)
2067     {
2068       SectorNumber = StartingSector & 0xff;
2069       CylinderLow = (StartingSector >> 8) & 0xff;
2070       CylinderHigh = (StartingSector >> 16) & 0xff;
2071       DrvHead = ((StartingSector >> 24) & 0x0f) |
2072           (Srb->TargetId ? IDE_DH_DRV1 : 0) |
2073           IDE_DH_LBA;
2074     }
2075   else
2076     {
2077       SectorNumber = (StartingSector % DeviceParams->SectorsPerTrack) + 1;
2078       StartingSector /= DeviceParams->SectorsPerTrack;
2079       DrvHead = (StartingSector % DeviceParams->LogicalHeads) |
2080           (Srb->TargetId ? IDE_DH_DRV1 : 0);
2081       StartingSector /= DeviceParams->LogicalHeads;
2082       CylinderLow = StartingSector & 0xff;
2083       CylinderHigh = StartingSector >> 8;
2084     }
2085
2086
2087   if (Srb->SrbFlags & SRB_FLAGS_DATA_IN)
2088     {
2089       Command = DeviceExtension->MultiSectorCommand[Srb->TargetId] ? IDE_CMD_READ_MULTIPLE : IDE_CMD_READ;
2090     }
2091   else
2092     {
2093       Command = DeviceExtension->MultiSectorCommand[Srb->TargetId] ? IDE_CMD_WRITE_MULTIPLE : IDE_CMD_WRITE;
2094     }
2095
2096   if (DrvHead & IDE_DH_LBA)
2097     {
2098       DPRINT("%s:BUS=%04x:DRV=%d:LBA=1:BLK=%08d:SC=%02x:CM=%02x\n",
2099              (Srb->SrbFlags & SRB_FLAGS_DATA_IN) ? "READ" : "WRITE",
2100              DeviceExtension->CommandPortBase,
2101              DrvHead & IDE_DH_DRV1 ? 1 : 0,
2102              ((DrvHead & 0x0f) << 24) +
2103                (CylinderHigh << 16) + (CylinderLow << 8) + SectorNumber,
2104              SectorCount,
2105              Command);
2106     }
2107   else
2108     {
2109       DPRINT("%s:BUS=%04x:DRV=%d:LBA=0:CH=%02x:CL=%02x:HD=%01x:SN=%02x:SC=%02x:CM=%02x\n",
2110              (Srb->SrbFlags & SRB_FLAGS_DATA_IN) ? "READ" : "WRITE",
2111              DeviceExtension->CommandPortBase,
2112              DrvHead & IDE_DH_DRV1 ? 1 : 0,
2113              CylinderHigh,
2114              CylinderLow,
2115              DrvHead & 0x0f,
2116              SectorNumber,
2117              SectorCount,
2118              Command);
2119     }
2120
2121   /* Set pointer to data buffer. */
2122   DeviceExtension->DataBuffer = (PUCHAR)Srb->DataBuffer;
2123   DeviceExtension->DataTransferLength = Srb->DataTransferLength;
2124
2125   DeviceExtension->CurrentSrb = Srb;
2126
2127   /*  wait for BUSY to clear  */
2128   for (Retries = 0; Retries < IDE_MAX_BUSY_RETRIES; Retries++)
2129     {
2130       Status = IDEReadStatus(DeviceExtension->CommandPortBase);
2131       if (!(Status & IDE_SR_BUSY))
2132         {
2133           break;
2134         }
2135       ScsiPortStallExecution(10);
2136     }
2137   DPRINT("status=%02x\n", Status);
2138   DPRINT("waited %ld usecs for busy to clear\n", Retries * 10);
2139   if (Retries >= IDE_MAX_BUSY_RETRIES)
2140     {
2141       DPRINT ("Drive is BUSY for too long\n");
2142       return(SRB_STATUS_BUSY);
2143     }
2144
2145   /*  Select the desired drive  */
2146   IDEWriteDriveHead(DeviceExtension->CommandPortBase,
2147                     IDE_DH_FIXED | DrvHead);
2148
2149   ScsiPortStallExecution(10);
2150 #if 0
2151   /*  wait for BUSY to clear and DRDY to assert */
2152   for (Retries = 0; Retries < IDE_MAX_BUSY_RETRIES; Retries++)
2153     {
2154       Status = IDEReadStatus(DeviceExtension->CommandPortBase);
2155       if (!(Status & IDE_SR_BUSY) && (Status & IDE_SR_DRDY))
2156         {
2157           break;
2158         }
2159       ScsiPortStallExecution(10);
2160     }
2161   DPRINT("waited %ld usecs for busy to clear after drive select\n", Retries * 10);
2162   if (Retries >= IDE_MAX_BUSY_RETRIES)
2163     {
2164       DPRINT("Drive is BUSY for too long after drive select\n");
2165       return(SRB_STATUS_BUSY);
2166     }
2167 #endif
2168
2169   /* Setup command parameters */
2170   IDEWritePrecomp(DeviceExtension->CommandPortBase, 0);
2171   IDEWriteSectorCount(DeviceExtension->CommandPortBase, SectorCount);
2172   IDEWriteSectorNum(DeviceExtension->CommandPortBase, SectorNumber);
2173   IDEWriteCylinderHigh(DeviceExtension->CommandPortBase, CylinderHigh);
2174   IDEWriteCylinderLow(DeviceExtension->CommandPortBase, CylinderLow);
2175   IDEWriteDriveHead(DeviceExtension->CommandPortBase, IDE_DH_FIXED | DrvHead);
2176
2177   /* Indicate expecting an interrupt. */
2178   DeviceExtension->ExpectingInterrupt = TRUE;
2179
2180   /* Issue command to drive */
2181   IDEWriteCommand(DeviceExtension->CommandPortBase, Command);
2182
2183   /* Write data block */
2184   if (Srb->SrbFlags & SRB_FLAGS_DATA_OUT)
2185     {
2186       PUCHAR TargetAddress;
2187       ULONG TransferSize;
2188
2189       /* Wait for controller ready */
2190       for (Retries = 0; Retries < IDE_MAX_WRITE_RETRIES; Retries++)
2191         {
2192           BYTE  Status = IDEReadStatus(DeviceExtension->CommandPortBase);
2193           if (!(Status & IDE_SR_BUSY) || (Status & IDE_SR_ERR))
2194             {
2195               break;
2196             }
2197           KeStallExecutionProcessor(10);
2198         }
2199       if (Retries >= IDE_MAX_WRITE_RETRIES)
2200         {
2201           DPRINT1("Drive is BUSY for too long after sending write command\n");
2202           return(SRB_STATUS_BUSY);
2203         }
2204
2205       /* Update DeviceExtension data */
2206       TransferSize = DeviceExtension->TransferSize[Srb->TargetId];
2207       if (DeviceExtension->DataTransferLength < TransferSize)
2208       {
2209          TransferSize = DeviceExtension->DataTransferLength;
2210       }
2211
2212       TargetAddress = DeviceExtension->DataBuffer;
2213       DeviceExtension->DataBuffer += TransferSize;
2214       DeviceExtension->DataTransferLength -= TransferSize;
2215
2216       /* Write data block */
2217       if (DeviceExtension->DWordIo[Srb->TargetId])
2218       {
2219          IDEWriteBlock32(DeviceExtension->CommandPortBase,
2220                          TargetAddress,
2221                          TransferSize);
2222       }
2223       else
2224       {
2225          IDEWriteBlock(DeviceExtension->CommandPortBase,
2226                        TargetAddress,
2227                        TransferSize);
2228       }
2229     }
2230
2231   DPRINT("AtapiReadWrite() done!\n");
2232
2233   /* Wait for interrupt. */
2234   return(SRB_STATUS_PENDING);
2235 }
2236
2237
2238 static ULONG
2239 AtapiFlushCache(PATAPI_MINIPORT_EXTENSION DeviceExtension,
2240                 PSCSI_REQUEST_BLOCK Srb)
2241 {
2242   ULONG Retries;
2243   UCHAR Status;
2244
2245   DPRINT1("AtapiFlushCache() called!\n");
2246
2247   if (Srb->PathId != 0)
2248     {
2249       Srb->SrbStatus = SRB_STATUS_INVALID_PATH_ID;
2250       return(SRB_STATUS_INVALID_PATH_ID);
2251     }
2252
2253   if (Srb->TargetId > 1)
2254     {
2255       Srb->SrbStatus = SRB_STATUS_INVALID_TARGET_ID;
2256       return(SRB_STATUS_INVALID_TARGET_ID);
2257     }
2258
2259   if (Srb->Lun != 0)
2260     {
2261       Srb->SrbStatus = SRB_STATUS_INVALID_LUN;
2262       return(SRB_STATUS_INVALID_LUN);
2263     }
2264
2265   if (DeviceExtension->DevicePresent[Srb->TargetId] == FALSE)
2266     {
2267       Srb->SrbStatus = SRB_STATUS_NO_DEVICE;
2268       return(SRB_STATUS_NO_DEVICE);
2269     }
2270
2271   DPRINT1("SCSIOP_SYNCRONIZE_CACHE: TargetId: %lu\n",
2272          Srb->TargetId);
2273
2274   /* Wait for BUSY to clear */
2275   for (Retries = 0; Retries < IDE_MAX_BUSY_RETRIES; Retries++)
2276     {
2277       Status = IDEReadStatus(DeviceExtension->CommandPortBase);
2278       if (!(Status & IDE_SR_BUSY))
2279         {
2280           break;
2281         }
2282       ScsiPortStallExecution(10);
2283     }
2284   DPRINT1("Status=%02x\n", Status);
2285   DPRINT1("Waited %ld usecs for busy to clear\n", Retries * 10);
2286   if (Retries >= IDE_MAX_BUSY_RETRIES)
2287     {
2288       DPRINT1("Drive is BUSY for too long\n");
2289       return(SRB_STATUS_BUSY);
2290     }
2291
2292   /* Select the desired drive */
2293   IDEWriteDriveHead(DeviceExtension->CommandPortBase,
2294                     IDE_DH_FIXED | (Srb->TargetId ? IDE_DH_DRV1 : 0));
2295   ScsiPortStallExecution(10);
2296
2297   /* Issue command to drive */
2298   IDEWriteCommand(DeviceExtension->CommandPortBase, IDE_CMD_FLUSH_CACHE);
2299
2300   /* Wait for controller ready */
2301   for (Retries = 0; Retries < IDE_MAX_WRITE_RETRIES; Retries++)
2302     {
2303       BYTE  Status = IDEReadStatus(DeviceExtension->CommandPortBase);
2304       if (!(Status & IDE_SR_BUSY) || (Status & IDE_SR_ERR))
2305         {
2306           break;
2307         }
2308       KeStallExecutionProcessor(10);
2309     }
2310   if (Retries >= IDE_MAX_WRITE_RETRIES)
2311     {
2312       DPRINT1("Drive is BUSY for too long after sending write command\n");
2313       return(SRB_STATUS_BUSY);
2314     }
2315
2316   /* Indicate expecting an interrupt. */
2317   DeviceExtension->ExpectingInterrupt = TRUE;
2318
2319   DPRINT1("AtapiFlushCache() done!\n");
2320
2321   /* Wait for interrupt. */
2322   return(SRB_STATUS_PENDING);
2323 }
2324
2325
2326 static UCHAR
2327 AtapiErrorToScsi(PVOID DeviceExtension,
2328                  PSCSI_REQUEST_BLOCK Srb)
2329 {
2330   PATAPI_MINIPORT_EXTENSION DevExt;
2331   ULONG CommandPortBase;
2332   ULONG ControlPortBase;
2333   UCHAR ErrorReg;
2334   UCHAR ScsiStatus;
2335   UCHAR SrbStatus;
2336
2337   DPRINT("AtapiErrorToScsi() called\n");
2338
2339   DevExt = (PATAPI_MINIPORT_EXTENSION)DeviceExtension;
2340
2341   CommandPortBase = DevExt->CommandPortBase;
2342   ControlPortBase = DevExt->ControlPortBase;
2343
2344   ErrorReg = IDEReadError(CommandPortBase);
2345
2346   if (DevExt->DeviceAtapi[Srb->TargetId])
2347     {
2348       switch (ErrorReg >> 4)
2349         {
2350           case SCSI_SENSE_NO_SENSE:
2351             DPRINT("ATAPI error: SCSI_SENSE_NO_SENSE\n");
2352             ScsiStatus = SCSISTAT_CHECK_CONDITION;
2353             SrbStatus = SRB_STATUS_ERROR;
2354             break;
2355
2356           case SCSI_SENSE_RECOVERED_ERROR:
2357             DPRINT("ATAPI error: SCSI_SENSE_RECOVERED_SENSE\n");
2358             ScsiStatus = 0;
2359             SrbStatus = SRB_STATUS_SUCCESS;
2360             break;
2361
2362           case SCSI_SENSE_NOT_READY:
2363             DPRINT("ATAPI error: SCSI_SENSE_NOT_READY\n");
2364             ScsiStatus = SCSISTAT_CHECK_CONDITION;
2365             SrbStatus = SRB_STATUS_ERROR;
2366             break;
2367
2368           case SCSI_SENSE_MEDIUM_ERROR:
2369             DPRINT("ATAPI error: SCSI_SENSE_MEDIUM_ERROR\n");
2370             ScsiStatus = SCSISTAT_CHECK_CONDITION;
2371             SrbStatus = SRB_STATUS_ERROR;
2372             break;
2373
2374           case SCSI_SENSE_HARDWARE_ERROR:
2375             DPRINT("ATAPI error: SCSI_SENSE_HARDWARE_ERROR\n");
2376             ScsiStatus = SCSISTAT_CHECK_CONDITION;
2377             SrbStatus = SRB_STATUS_ERROR;
2378             break;
2379
2380           case SCSI_SENSE_ILLEGAL_REQUEST:
2381             DPRINT("ATAPI error: SCSI_SENSE_ILLEGAL_REQUEST\n");
2382             ScsiStatus = SCSISTAT_CHECK_CONDITION;
2383             SrbStatus = SRB_STATUS_ERROR;
2384             break;
2385
2386           case SCSI_SENSE_UNIT_ATTENTION:
2387             DPRINT("ATAPI error: SCSI_SENSE_UNIT_ATTENTION\n");
2388             ScsiStatus = SCSISTAT_CHECK_CONDITION;
2389             SrbStatus = SRB_STATUS_ERROR;
2390             break;
2391
2392           case SCSI_SENSE_DATA_PROTECT:
2393             DPRINT("ATAPI error: SCSI_SENSE_DATA_PROTECT\n");
2394             ScsiStatus = SCSISTAT_CHECK_CONDITION;
2395             SrbStatus = SRB_STATUS_ERROR;
2396             break;
2397
2398           case SCSI_SENSE_BLANK_CHECK:
2399             DPRINT("ATAPI error: SCSI_SENSE_BLANK_CHECK\n");
2400             ScsiStatus = SCSISTAT_CHECK_CONDITION;
2401             SrbStatus = SRB_STATUS_ERROR;
2402             break;
2403
2404           case SCSI_SENSE_ABORTED_COMMAND:
2405             DPRINT("ATAPI error: SCSI_SENSE_ABORTED_COMMAND\n");
2406             ScsiStatus = SCSISTAT_CHECK_CONDITION;
2407             SrbStatus = SRB_STATUS_ERROR;
2408             break;
2409
2410           default:
2411             DPRINT("ATAPI error: Invalid sense key\n");
2412             ScsiStatus = 0;
2413             SrbStatus = SRB_STATUS_ERROR;
2414             break;
2415         }
2416     }
2417   else
2418     {
2419       DPRINT1("IDE error: %02x\n", ErrorReg);
2420
2421       ScsiStatus = 0;
2422       SrbStatus = SRB_STATUS_ERROR;
2423
2424 #if 0
2425       UCHAR SectorCount, SectorNum, CylinderLow, CylinderHigh;
2426       UCHAR DriveHead;
2427
2428       CylinderLow = IDEReadCylinderLow(CommandPortBase);
2429       CylinderHigh = IDEReadCylinderHigh(CommandPortBase);
2430       DriveHead = IDEReadDriveHead(CommandPortBase);
2431       SectorCount = IDEReadSectorCount(CommandPortBase);
2432       SectorNum = IDEReadSectorNum(CommandPortBase);
2433
2434       DPRINT1("IDE Error: ERR:%02x CYLLO:%02x CYLHI:%02x SCNT:%02x SNUM:%02x\n",
2435               ErrorReg,
2436               CylinderLow,
2437               CylinderHigh,
2438               SectorCount,
2439               SectorNum);
2440 #endif
2441     }
2442
2443
2444
2445   Srb->ScsiStatus = ScsiStatus;
2446
2447   DPRINT("AtapiErrorToScsi() done\n");
2448
2449   return(SrbStatus);
2450 }
2451
2452 /* EOF */