reactos/drivers/storage/classpnp/power.c

   1 /*++
   2
   3 Copyright (C) Microsoft Corporation, 1991 - 1999
   4
   5 Module Name:
   6
   7     class.c
   8
   9 Abstract:
  10
  11     SCSI class driver routines
  12
  13 Environment:
  14
  15     kernel mode only
  16
  17 Notes:
  18
  19
  20 Revision History:
  21
  22 --*/
  23
  24 #include "classp.h"
  25
  26 #define CLASS_TAG_POWER     'WLcS'
  27
  28 NTSTATUS
  29 NTAPI
  30 ClasspPowerHandler(
  31     IN PDEVICE_OBJECT DeviceObject,
  32     IN PIRP Irp,
  33     IN CLASS_POWER_OPTIONS Options
  34     );
  35
  36 IO_COMPLETION_ROUTINE ClasspPowerDownCompletion;
  37
  38 IO_COMPLETION_ROUTINE ClasspPowerUpCompletion;
  39
  40 VOID
  41 NTAPI
  42 RetryPowerRequest(
  43     PDEVICE_OBJECT DeviceObject,
  44     PIRP Irp,
  45     PCLASS_POWER_CONTEXT Context
  46     );
  47
  48 NTSTATUS
  49 NTAPI
  50 ClasspStartNextPowerIrpCompletion(
  51     IN PDEVICE_OBJECT DeviceObject,
  52     IN PIRP Irp,
  53     IN PVOID Context
  54     );
  55
  56
  57 /*++////////////////////////////////////////////////////////////////////////////
  58
  59 ClassDispatchPower()
  60
  61 Routine Description:
  62
  63     This routine acquires the removelock for the irp and then calls the
  64     appropriate power callback.
  65
  66 Arguments:
  67
  68     DeviceObject -
  69     Irp -
  70
  71 Return Value:
  72
  73 --*/
  74 NTSTATUS
  75 NTAPI
  76 ClassDispatchPower(
  77     IN PDEVICE_OBJECT DeviceObject,
  78     IN PIRP Irp
  79     )
  80 {
  81     PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
  82     ULONG isRemoved;
  83
  84     //
  85     // NOTE: This code may be called at PASSIVE or DISPATCH, depending
  86     //       upon the device object it is being called for.
  87     //       don't do anything that would break under either circumstance.
  88     //
  89
  90     isRemoved = ClassAcquireRemoveLock(DeviceObject, Irp);
  91
  92     if(isRemoved) {
  93         ClassReleaseRemoveLock(DeviceObject, Irp);
  94         Irp->IoStatus.Status = STATUS_DEVICE_DOES_NOT_EXIST;
  95         PoStartNextPowerIrp(Irp);
  96         ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
  97         return STATUS_DEVICE_DOES_NOT_EXIST;
  98     }
  99
 100     return commonExtension->DevInfo->ClassPowerDevice(DeviceObject, Irp);
 101 } // end ClassDispatchPower()
 102
 103 /*++////////////////////////////////////////////////////////////////////////////
 104
 105 ClasspPowerUpCompletion()
 106
 107 Routine Description:
 108
 109     This routine is used for intermediate completion of a power up request.
 110     PowerUp requires four requests to be sent to the lower driver in sequence.
 111
 112         * The queue is "power locked" to ensure that the class driver power-up
 113           work can be done before request processing resumes.
 114
 115         * The power irp is sent down the stack for any filter drivers and the
 116           port driver to return power and resume command processing for the
 117           device.  Since the queue is locked, no queued irps will be sent
 118           immediately.
 119
 120         * A start unit command is issued to the device with appropriate flags
 121           to override the "power locked" queue.
 122
 123         * The queue is "power unlocked" to start processing requests again.
 124
 125     This routine uses the function in the srb which just completed to determine
 126     which state it is in.
 127
 128 Arguments:
 129
 130     DeviceObject - the device object being powered up
 131
 132     Irp - the IO_REQUEST_PACKET containing the power request
 133
 134     Srb - the SRB used to perform port/class operations.
 135
 136 Return Value:
 137
 138     STATUS_MORE_PROCESSING_REQUIRED or
 139     STATUS_SUCCESS
 140
 141 --*/
 142 NTSTATUS
 143 NTAPI
 144 ClasspPowerUpCompletion(
 145     IN PDEVICE_OBJECT DeviceObject,
 146     IN PIRP Irp,
 147     IN PVOID CompletionContext
 148     )
 149 {
 150     PCLASS_POWER_CONTEXT context = CompletionContext;
 151     PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
 152     PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
 153
 154     PIO_STACK_LOCATION currentStack = IoGetCurrentIrpStackLocation(Irp);
 155     PIO_STACK_LOCATION nextStack = IoGetNextIrpStackLocation(Irp);
 156
 157
 158     NTSTATUS status = STATUS_MORE_PROCESSING_REQUIRED;
 159
 160     DebugPrint((1, "ClasspPowerUpCompletion: Device Object %p, Irp %p, "
 161                    "Context %p\n",
 162                 DeviceObject, Irp, context));
 163
 164     ASSERT(!TEST_FLAG(context->Srb.SrbFlags, SRB_FLAGS_FREE_SENSE_BUFFER));
 165     ASSERT(!TEST_FLAG(context->Srb.SrbFlags, SRB_FLAGS_PORT_DRIVER_ALLOCSENSE));
 166     ASSERT(context->Options.PowerDown == FALSE);
 167     ASSERT(context->Options.HandleSpinUp);
 168
 169     if(Irp->PendingReturned) {
 170         IoMarkIrpPending(Irp);
 171     }
 172
 173     context->PowerChangeState.PowerUp++;
 174
 175     switch(context->PowerChangeState.PowerUp) {
 176
 177         case PowerUpDeviceLocked: {
 178
 179             DebugPrint((1, "(%p)\tPreviously sent power lock\n", Irp));
 180
 181             //
 182             // Issue the actual power request to the lower driver.
 183             //
 184
 185             IoCopyCurrentIrpStackLocationToNext(Irp);
 186
 187             //
 188             // If the lock wasn't successful then just bail out on the power
 189             // request unless we can ignore failed locks
 190             //
 191
 192             if((context->Options.LockQueue == TRUE) &&
 193                (!NT_SUCCESS(Irp->IoStatus.Status))) {
 194
 195                 DebugPrint((1, "(%p)\tIrp status was %lx\n",
 196                             Irp, Irp->IoStatus.Status));
 197                 DebugPrint((1, "(%p)\tSrb status was %lx\n",
 198                             Irp, context->Srb.SrbStatus));
 199
 200                 //
 201                 // Lock was not successful - throw down the power IRP
 202                 // by itself and don't try to spin up the drive or unlock
 203                 // the queue.
 204                 //
 205
 206                 context->InUse = FALSE;
 207                 context = NULL;
 208
 209                 //
 210                 // Set the new power state
 211                 //
 212
 213                 fdoExtension->DevicePowerState =
 214                     currentStack->Parameters.Power.State.DeviceState;
 215
 216                 Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
 217
 218                 IoCopyCurrentIrpStackLocationToNext(Irp);
 219
 220                 IoSetCompletionRoutine(Irp,
 221                                        ClasspStartNextPowerIrpCompletion,
 222                                        NULL,
 223                                        TRUE,
 224                                        TRUE,
 225                                        TRUE);
 226
 227                 //
 228                 // Indicate to Po that we've been successfully powered up so
 229                 // it can do it's notification stuff.
 230                 //
 231
 232                 PoSetPowerState(DeviceObject,
 233                                 currentStack->Parameters.Power.Type,
 234                                 currentStack->Parameters.Power.State);
 235
 236                 PoCallDriver(commonExtension->LowerDeviceObject, Irp);
 237
 238                 ClassReleaseRemoveLock(commonExtension->DeviceObject,
 239                                        Irp);
 240
 241                 return STATUS_MORE_PROCESSING_REQUIRED;
 242
 243             } else {
 244                 context->QueueLocked = (UCHAR) context->Options.LockQueue;
 245             }
 246
 247             Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
 248
 249             context->PowerChangeState.PowerUp = PowerUpDeviceLocked;
 250
 251             IoSetCompletionRoutine(Irp,
 252                                    ClasspPowerUpCompletion,
 253                                    context,
 254                                    TRUE,
 255                                    TRUE,
 256                                    TRUE);
 257
 258             status = PoCallDriver(commonExtension->LowerDeviceObject, Irp);
 259
 260             DebugPrint((2, "(%p)\tPoCallDriver returned %lx\n", Irp, status));
 261             break;
 262         }
 263
 264         case PowerUpDeviceOn: {
 265
 266             PCDB cdb;
 267
 268             if(NT_SUCCESS(Irp->IoStatus.Status)) {
 269
 270                 DebugPrint((1, "(%p)\tSending start unit to device\n", Irp));
 271
 272                 //
 273                 // Issue the start unit command to the device.
 274                 //
 275
 276                 context->Srb.Length = sizeof(SCSI_REQUEST_BLOCK);
 277                 context->Srb.Function = SRB_FUNCTION_EXECUTE_SCSI;
 278
 279                 context->Srb.SrbStatus = context->Srb.ScsiStatus = 0;
 280                 context->Srb.DataTransferLength = 0;
 281
 282                 context->Srb.TimeOutValue = START_UNIT_TIMEOUT;
 283
 284                 context->Srb.SrbFlags = SRB_FLAGS_NO_DATA_TRANSFER |
 285                                         SRB_FLAGS_DISABLE_AUTOSENSE |
 286                                         SRB_FLAGS_DISABLE_SYNCH_TRANSFER |
 287                                         SRB_FLAGS_NO_QUEUE_FREEZE;
 288
 289                 if(context->Options.LockQueue) {
 290                     SET_FLAG(context->Srb.SrbFlags, SRB_FLAGS_BYPASS_LOCKED_QUEUE);
 291                 }
 292
 293                 context->Srb.CdbLength = 6;
 294
 295                 cdb = (PCDB) (context->Srb.Cdb);
 296                 RtlZeroMemory(cdb, sizeof(CDB));
 297
 298
 299                 cdb->START_STOP.OperationCode = SCSIOP_START_STOP_UNIT;
 300                 cdb->START_STOP.Start = 1;
 301
 302                 context->PowerChangeState.PowerUp = PowerUpDeviceOn;
 303
 304                 IoSetCompletionRoutine(Irp,
 305                                        ClasspPowerUpCompletion,
 306                                        context,
 307                                        TRUE,
 308                                        TRUE,
 309                                        TRUE);
 310
 311                 nextStack->Parameters.Scsi.Srb = &(context->Srb);
 312                 nextStack->MajorFunction = IRP_MJ_SCSI;
 313
 314                 status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
 315
 316                 DebugPrint((2, "(%p)\tIoCallDriver returned %lx\n", Irp, status));
 317
 318             } else {
 319
 320                 //
 321                 // we're done.
 322                 //
 323
 324                 context->FinalStatus = Irp->IoStatus.Status;
 325                 goto ClasspPowerUpCompletionFailure;
 326             }
 327
 328             break;
 329         }
 330
 331         case PowerUpDeviceStarted: { // 3
 332
 333             //
 334             // First deal with an error if one occurred.
 335             //
 336
 337             if(SRB_STATUS(context->Srb.SrbStatus) != SRB_STATUS_SUCCESS) {
 338
 339                 BOOLEAN retry;
 340
 341                 DebugPrint((1, "%p\tError occured when issuing START_UNIT "
 342                             "command to device. Srb %p, Status %x\n",
 343                             Irp,
 344                             &context->Srb,
 345                             context->Srb.SrbStatus));
 346
 347                 ASSERT(!(TEST_FLAG(context->Srb.SrbStatus,
 348                                    SRB_STATUS_QUEUE_FROZEN)));
 349                 ASSERT(context->Srb.Function == SRB_FUNCTION_EXECUTE_SCSI);
 350
 351                 context->RetryInterval = 0;
 352
 353                 retry = ClassInterpretSenseInfo(
 354                             commonExtension->DeviceObject,
 355                             &context->Srb,
 356                             IRP_MJ_SCSI,
 357                             IRP_MJ_POWER,
 358                             MAXIMUM_RETRIES - context->RetryCount,
 359                             &status,
 360                             &context->RetryInterval);
 361
 362                 if((retry == TRUE) && (context->RetryCount-- != 0)) {
 363
 364                     DebugPrint((1, "(%p)\tRetrying failed request\n", Irp));
 365
 366                     //
 367                     // Decrement the state so we come back through here the
 368                     // next time.
 369                     //
 370
 371                     context->PowerChangeState.PowerUp--;
 372
 373                     RetryPowerRequest(commonExtension->DeviceObject,
 374                                       Irp,
 375                                       context);
 376
 377                     break;
 378
 379                 }
 380
 381                 // reset retries
 382                 context->RetryCount = MAXIMUM_RETRIES;
 383
 384             }
 385
 386 ClasspPowerUpCompletionFailure:
 387
 388             DebugPrint((1, "(%p)\tPreviously spun device up\n", Irp));
 389
 390             if (context->QueueLocked) {
 391                 DebugPrint((1, "(%p)\tUnlocking queue\n", Irp));
 392
 393                 context->Srb.Function = SRB_FUNCTION_UNLOCK_QUEUE;
 394                 context->Srb.SrbFlags = SRB_FLAGS_BYPASS_LOCKED_QUEUE;
 395                 context->Srb.SrbStatus = context->Srb.ScsiStatus = 0;
 396                 context->Srb.DataTransferLength = 0;
 397
 398                 nextStack->Parameters.Scsi.Srb = &(context->Srb);
 399                 nextStack->MajorFunction = IRP_MJ_SCSI;
 400
 401                 context->PowerChangeState.PowerUp = PowerUpDeviceStarted;
 402
 403                 IoSetCompletionRoutine(Irp,
 404                                        ClasspPowerUpCompletion,
 405                                        context,
 406                                        TRUE,
 407                                        TRUE,
 408                                        TRUE);
 409
 410                 status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
 411                 DebugPrint((1, "(%p)\tIoCallDriver returned %lx\n",
 412                             Irp, status));
 413                 break;
 414             }
 415
 416             // Fall-through to next case...
 417
 418         }
 419
 420         case PowerUpDeviceUnlocked: {
 421
 422             //
 423             // This is the end of the dance.  Free the srb and complete the
 424             // request finally.  We're ignoring possible intermediate
 425             // error conditions ....
 426             //
 427
 428             if (context->QueueLocked) {
 429                 DebugPrint((1, "(%p)\tPreviously unlocked queue\n", Irp));
 430                 ASSERT(NT_SUCCESS(Irp->IoStatus.Status));
 431                 ASSERT(context->Srb.SrbStatus == SRB_STATUS_SUCCESS);
 432             } else {
 433                 DebugPrint((1, "(%p)\tFall-through (queue not locked)\n", Irp));
 434             }
 435
 436             DebugPrint((1, "(%p)\tFreeing srb and completing\n", Irp));
 437             context->InUse = FALSE;
 438
 439             status = context->FinalStatus;
 440             Irp->IoStatus.Status = status;
 441
 442             context = NULL;
 443
 444             //
 445             // Set the new power state
 446             //
 447
 448             if(NT_SUCCESS(status)) {
 449                 fdoExtension->DevicePowerState =
 450                     currentStack->Parameters.Power.State.DeviceState;
 451             }
 452
 453             //
 454             // Indicate to Po that we've been successfully powered up so
 455             // it can do it's notification stuff.
 456             //
 457
 458             PoSetPowerState(DeviceObject,
 459                             currentStack->Parameters.Power.Type,
 460                             currentStack->Parameters.Power.State);
 461
 462             DebugPrint((1, "(%p)\tStarting next power irp\n", Irp));
 463             ClassReleaseRemoveLock(DeviceObject, Irp);
 464             PoStartNextPowerIrp(Irp);
 465
 466             return status;
 467         }
 468
 469         case PowerUpDeviceInitial: {
 470             NT_ASSERT(context->PowerChangeState.PowerUp != PowerUpDeviceInitial);
 471             break;
 472         }
 473     }
 474
 475     return STATUS_MORE_PROCESSING_REQUIRED;
 476 } // end ClasspPowerUpCompletion()
 477
 478 /*++////////////////////////////////////////////////////////////////////////////
 479
 480 ClasspPowerDownCompletion()
 481
 482 Routine Description:
 483
 484     This routine is used for intermediate completion of a power up request.
 485     PowerUp requires four requests to be sent to the lower driver in sequence.
 486
 487         * The queue is "power locked" to ensure that the class driver power-up
 488           work can be done before request processing resumes.
 489
 490         * The power irp is sent down the stack for any filter drivers and the
 491           port driver to return power and resume command processing for the
 492           device.  Since the queue is locked, no queued irps will be sent
 493           immediately.
 494
 495         * A start unit command is issued to the device with appropriate flags
 496           to override the "power locked" queue.
 497
 498         * The queue is "power unlocked" to start processing requests again.
 499
 500     This routine uses the function in the srb which just completed to determine
 501     which state it is in.
 502
 503 Arguments:
 504
 505     DeviceObject - the device object being powered up
 506
 507     Irp - the IO_REQUEST_PACKET containing the power request
 508
 509     Srb - the SRB used to perform port/class operations.
 510
 511 Return Value:
 512
 513     STATUS_MORE_PROCESSING_REQUIRED or
 514     STATUS_SUCCESS
 515
 516 --*/
 517 NTSTATUS
 518 NTAPI
 519 ClasspPowerDownCompletion(
 520     IN PDEVICE_OBJECT DeviceObject,
 521     IN PIRP Irp,
 522     IN PVOID CompletionContext
 523     )
 524 {
 525     PCLASS_POWER_CONTEXT context = CompletionContext;
 526     PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
 527     PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
 528
 529     PIO_STACK_LOCATION currentStack = IoGetCurrentIrpStackLocation(Irp);
 530     PIO_STACK_LOCATION nextStack = IoGetNextIrpStackLocation(Irp);
 531
 532     NTSTATUS status = STATUS_MORE_PROCESSING_REQUIRED;
 533
 534     DebugPrint((1, "ClasspPowerDownCompletion: Device Object %p, "
 535                    "Irp %p, Context %p\n",
 536                 DeviceObject, Irp, context));
 537
 538     ASSERT(!TEST_FLAG(context->Srb.SrbFlags, SRB_FLAGS_FREE_SENSE_BUFFER));
 539     ASSERT(!TEST_FLAG(context->Srb.SrbFlags, SRB_FLAGS_PORT_DRIVER_ALLOCSENSE));
 540     ASSERT(context->Options.PowerDown == TRUE);
 541     ASSERT(context->Options.HandleSpinDown);
 542
 543     if(Irp->PendingReturned) {
 544         IoMarkIrpPending(Irp);
 545     }
 546
 547     context->PowerChangeState.PowerDown2++;
 548
 549     switch(context->PowerChangeState.PowerDown2) {
 550
 551         case PowerDownDeviceLocked2: {
 552
 553             PCDB cdb;
 554
 555             DebugPrint((1, "(%p)\tPreviously sent power lock\n", Irp));
 556
 557             if((context->Options.LockQueue == TRUE) &&
 558                (!NT_SUCCESS(Irp->IoStatus.Status))) {
 559
 560                 DebugPrint((1, "(%p)\tIrp status was %lx\n",
 561                             Irp,
 562                             Irp->IoStatus.Status));
 563                 DebugPrint((1, "(%p)\tSrb status was %lx\n",
 564                             Irp,
 565                             context->Srb.SrbStatus));
 566
 567                 Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
 568
 569                 //
 570                 // Lock was not successful - throw down the power IRP
 571                 // by itself and don't try to spin down the drive or unlock
 572                 // the queue.
 573                 //
 574
 575                 context->InUse = FALSE;
 576                 context = NULL;
 577
 578                 //
 579                 // Set the new power state
 580                 //
 581
 582                 fdoExtension->DevicePowerState =
 583                     currentStack->Parameters.Power.State.DeviceState;
 584
 585                 //
 586                 // Indicate to Po that we've been successfully powered down
 587                 // so it can do it's notification stuff.
 588                 //
 589
 590                 IoCopyCurrentIrpStackLocationToNext(Irp);
 591                 IoSetCompletionRoutine(Irp,
 592                                        ClasspStartNextPowerIrpCompletion,
 593                                        NULL,
 594                                        TRUE,
 595                                        TRUE,
 596                                        TRUE);
 597
 598                 PoSetPowerState(DeviceObject,
 599                                 currentStack->Parameters.Power.Type,
 600                                 currentStack->Parameters.Power.State);
 601
 602                 fdoExtension->PowerDownInProgress = FALSE;
 603
 604                 PoCallDriver(commonExtension->LowerDeviceObject, Irp);
 605
 606                 ClassReleaseRemoveLock(commonExtension->DeviceObject,
 607                                        Irp);
 608
 609                 return STATUS_MORE_PROCESSING_REQUIRED;
 610
 611             } else {
 612                 context->QueueLocked = (UCHAR) context->Options.LockQueue;
 613             }
 614
 615             if (!TEST_FLAG(fdoExtension->PrivateFdoData->HackFlags,
 616                            FDO_HACK_NO_SYNC_CACHE)) {
 617
 618                 //
 619                 // send SCSIOP_SYNCHRONIZE_CACHE
 620                 //
 621
 622                 context->Srb.Length = sizeof(SCSI_REQUEST_BLOCK);
 623                 context->Srb.Function = SRB_FUNCTION_EXECUTE_SCSI;
 624
 625                 context->Srb.TimeOutValue = fdoExtension->TimeOutValue;
 626
 627                 context->Srb.SrbFlags = SRB_FLAGS_NO_DATA_TRANSFER |
 628                                         SRB_FLAGS_DISABLE_AUTOSENSE |
 629                                         SRB_FLAGS_DISABLE_SYNCH_TRANSFER |
 630                                         SRB_FLAGS_NO_QUEUE_FREEZE |
 631                                         SRB_FLAGS_BYPASS_LOCKED_QUEUE;
 632
 633                 context->Srb.SrbStatus = context->Srb.ScsiStatus = 0;
 634                 context->Srb.DataTransferLength = 0;
 635
 636                 context->Srb.CdbLength = 10;
 637
 638                 cdb = (PCDB) context->Srb.Cdb;
 639
 640                 RtlZeroMemory(cdb, sizeof(CDB));
 641                 cdb->SYNCHRONIZE_CACHE10.OperationCode = SCSIOP_SYNCHRONIZE_CACHE;
 642
 643                 IoSetCompletionRoutine(Irp,
 644                                        ClasspPowerDownCompletion,
 645                                        context,
 646                                        TRUE,
 647                                        TRUE,
 648                                        TRUE);
 649
 650                 nextStack->Parameters.Scsi.Srb = &(context->Srb);
 651                 nextStack->MajorFunction = IRP_MJ_SCSI;
 652
 653                 status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
 654
 655                 DebugPrint((1, "(%p)\tIoCallDriver returned %lx\n", Irp, status));
 656                 break;
 657
 658             } else {
 659
 660                 DebugPrint((1, "(%p)\tPower Down: not sending SYNCH_CACHE\n",
 661                             DeviceObject));
 662                 context->PowerChangeState.PowerDown2++;
 663                 context->Srb.SrbStatus = SRB_STATUS_SUCCESS;
 664                 // and fall through....
 665             }
 666             // no break in case the device doesn't like synch_cache commands
 667
 668         }
 669
 670         case PowerDownDeviceFlushed2: {
 671
 672             PCDB cdb;
 673
 674             DebugPrint((1, "(%p)\tPreviously send SCSIOP_SYNCHRONIZE_CACHE\n",
 675                         Irp));
 676
 677             //
 678             // SCSIOP_SYNCHRONIZE_CACHE was sent
 679             //
 680
 681             if(SRB_STATUS(context->Srb.SrbStatus) != SRB_STATUS_SUCCESS) {
 682
 683                 BOOLEAN retry;
 684
 685                 DebugPrint((1, "(%p)\tError occured when issuing "
 686                             "SYNCHRONIZE_CACHE command to device. "
 687                             "Srb %p, Status %lx\n",
 688                             Irp,
 689                             &context->Srb,
 690                             context->Srb.SrbStatus));
 691
 692                 ASSERT(!(TEST_FLAG(context->Srb.SrbStatus,
 693                                    SRB_STATUS_QUEUE_FROZEN)));
 694                 ASSERT(context->Srb.Function == SRB_FUNCTION_EXECUTE_SCSI);
 695
 696                 context->RetryInterval = 0;
 697                 retry = ClassInterpretSenseInfo(
 698                             commonExtension->DeviceObject,
 699                             &context->Srb,
 700                             IRP_MJ_SCSI,
 701                             IRP_MJ_POWER,
 702                             MAXIMUM_RETRIES - context->RetryCount,
 703                             &status,
 704                             &context->RetryInterval);
 705
 706                 if((retry == TRUE) && (context->RetryCount-- != 0)) {
 707
 708                         DebugPrint((1, "(%p)\tRetrying failed request\n", Irp));
 709
 710                         //
 711                         // decrement the state so we come back through here
 712                         // the next time.
 713                         //
 714
 715                         context->PowerChangeState.PowerDown2--;
 716                         RetryPowerRequest(commonExtension->DeviceObject,
 717                                           Irp,
 718                                           context);
 719                         break;
 720                 }
 721
 722                 DebugPrint((1, "(%p)\tSYNCHRONIZE_CACHE not retried\n", Irp));
 723                 context->RetryCount = MAXIMUM_RETRIES;
 724
 725             } // end !SRB_STATUS_SUCCESS
 726
 727             //
 728             // note: we are purposefully ignoring any errors.  if the drive
 729             //       doesn't support a synch_cache, then we're up a creek
 730             //       anyways.
 731             //
 732
 733             DebugPrint((1, "(%p)\tSending stop unit to device\n", Irp));
 734
 735             //
 736             // Issue the start unit command to the device.
 737             //
 738
 739             context->Srb.Length = sizeof(SCSI_REQUEST_BLOCK);
 740             context->Srb.Function = SRB_FUNCTION_EXECUTE_SCSI;
 741
 742             context->Srb.TimeOutValue = START_UNIT_TIMEOUT;
 743
 744             context->Srb.SrbFlags = SRB_FLAGS_NO_DATA_TRANSFER |
 745                                     SRB_FLAGS_DISABLE_AUTOSENSE |
 746                                     SRB_FLAGS_DISABLE_SYNCH_TRANSFER |
 747                                     SRB_FLAGS_NO_QUEUE_FREEZE |
 748                                     SRB_FLAGS_BYPASS_LOCKED_QUEUE;
 749
 750             context->Srb.SrbStatus = context->Srb.ScsiStatus = 0;
 751             context->Srb.DataTransferLength = 0;
 752
 753             context->Srb.CdbLength = 6;
 754
 755             cdb = (PCDB) context->Srb.Cdb;
 756             RtlZeroMemory(cdb, sizeof(CDB));
 757
 758             cdb->START_STOP.OperationCode = SCSIOP_START_STOP_UNIT;
 759             cdb->START_STOP.Start = 0;
 760             cdb->START_STOP.Immediate = 1;
 761
 762             IoSetCompletionRoutine(Irp,
 763                                    ClasspPowerDownCompletion,
 764                                    context,
 765                                    TRUE,
 766                                    TRUE,
 767                                    TRUE);
 768
 769             nextStack->Parameters.Scsi.Srb = &(context->Srb);
 770             nextStack->MajorFunction = IRP_MJ_SCSI;
 771
 772             status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
 773
 774             DebugPrint((1, "(%p)\tIoCallDriver returned %lx\n", Irp, status));
 775             break;
 776
 777         }
 778
 779         case PowerDownDeviceStopped2: {
 780
 781             BOOLEAN ignoreError = TRUE;
 782
 783             //
 784             // stop was sent
 785             //
 786
 787             if(SRB_STATUS(context->Srb.SrbStatus) != SRB_STATUS_SUCCESS) {
 788
 789                 BOOLEAN retry;
 790
 791                 DebugPrint((1, "(%p)\tError occured when issueing STOP_UNIT "
 792                             "command to device. Srb %p, Status %lx\n",
 793                             Irp,
 794                             &context->Srb,
 795                             context->Srb.SrbStatus));
 796
 797                 ASSERT(!(TEST_FLAG(context->Srb.SrbStatus,
 798                                    SRB_STATUS_QUEUE_FROZEN)));
 799                 ASSERT(context->Srb.Function == SRB_FUNCTION_EXECUTE_SCSI);
 800
 801                 context->RetryInterval = 0;
 802                 retry = ClassInterpretSenseInfo(
 803                             commonExtension->DeviceObject,
 804                             &context->Srb,
 805                             IRP_MJ_SCSI,
 806                             IRP_MJ_POWER,
 807                             MAXIMUM_RETRIES - context->RetryCount,
 808                             &status,
 809                             &context->RetryInterval);
 810
 811                 if((retry == TRUE) && (context->RetryCount-- != 0)) {
 812
 813                         DebugPrint((1, "(%p)\tRetrying failed request\n", Irp));
 814
 815                         //
 816                         // decrement the state so we come back through here
 817                         // the next time.
 818                         //
 819
 820                         context->PowerChangeState.PowerDown2--;
 821                         RetryPowerRequest(commonExtension->DeviceObject,
 822                                           Irp,
 823                                           context);
 824                         break;
 825                 }
 826
 827                 DebugPrint((1, "(%p)\tSTOP_UNIT not retried\n", Irp));
 828                 context->RetryCount = MAXIMUM_RETRIES;
 829
 830             } // end !SRB_STATUS_SUCCESS
 831
 832
 833             DebugPrint((1, "(%p)\tPreviously sent stop unit\n", Irp));
 834
 835             //
 836             // some operations, such as a physical format in progress,
 837             // should not be ignored and should fail the power operation.
 838             //
 839
 840             if (!NT_SUCCESS(status)) {
 841
 842                 PSENSE_DATA senseBuffer = context->Srb.SenseInfoBuffer;
 843
 844                 if (TEST_FLAG(context->Srb.SrbStatus,
 845                               SRB_STATUS_AUTOSENSE_VALID) &&
 846                     ((senseBuffer->SenseKey & 0xf) == SCSI_SENSE_NOT_READY) &&
 847                     (senseBuffer->AdditionalSenseCode == SCSI_ADSENSE_LUN_NOT_READY) &&
 848                     (senseBuffer->AdditionalSenseCodeQualifier == SCSI_SENSEQ_FORMAT_IN_PROGRESS)
 849                     ) {
 850                     ignoreError = FALSE;
 851                     context->FinalStatus = STATUS_DEVICE_BUSY;
 852                     status = context->FinalStatus;
 853                 }
 854
 855             }
 856
 857             if (NT_SUCCESS(status) || ignoreError) {
 858
 859                 //
 860                 // Issue the actual power request to the lower driver.
 861                 //
 862
 863                 Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
 864
 865                 IoCopyCurrentIrpStackLocationToNext(Irp);
 866
 867                 IoSetCompletionRoutine(Irp,
 868                                        ClasspPowerDownCompletion,
 869                                        context,
 870                                        TRUE,
 871                                        TRUE,
 872                                        TRUE);
 873
 874                 status = PoCallDriver(commonExtension->LowerDeviceObject, Irp);
 875
 876                 DebugPrint((1, "(%p)\tPoCallDriver returned %lx\n", Irp, status));
 877                 break;
 878             }
 879
 880             // else fall through w/o sending the power irp, since the device
 881             // is reporting an error that would be "really bad" to power down
 882             // during.
 883
 884         }
 885
 886         case PowerDownDeviceOff2: {
 887
 888             //
 889             // SpinDown request completed ... whether it succeeded or not is
 890             // another matter entirely.
 891             //
 892
 893             DebugPrint((1, "(%p)\tPreviously sent power irp\n", Irp));
 894
 895             if (context->QueueLocked) {
 896
 897                 DebugPrint((1, "(%p)\tUnlocking queue\n", Irp));
 898
 899                 context->Srb.Length = sizeof(SCSI_REQUEST_BLOCK);
 900
 901                 context->Srb.SrbStatus = context->Srb.ScsiStatus = 0;
 902                 context->Srb.DataTransferLength = 0;
 903
 904                 context->Srb.Function = SRB_FUNCTION_UNLOCK_QUEUE;
 905                 context->Srb.SrbFlags = SRB_FLAGS_BYPASS_LOCKED_QUEUE;
 906                 nextStack->Parameters.Scsi.Srb = &(context->Srb);
 907                 nextStack->MajorFunction = IRP_MJ_SCSI;
 908
 909                 IoSetCompletionRoutine(Irp,
 910                                        ClasspPowerDownCompletion,
 911                                        context,
 912                                        TRUE,
 913                                        TRUE,
 914                                        TRUE);
 915
 916                 status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
 917                 DebugPrint((1, "(%p)\tIoCallDriver returned %lx\n",
 918                             Irp,
 919                             status));
 920                 break;
 921             }
 922
 923         }
 924
 925         case PowerDownDeviceUnlocked2: {
 926
 927             //
 928             // This is the end of the dance.  Free the srb and complete the
 929             // request finally.  We're ignoring possible intermediate
 930             // error conditions ....
 931             //
 932
 933             if (context->QueueLocked == FALSE) {
 934                 DebugPrint((1, "(%p)\tFall through (queue not locked)\n", Irp));
 935             } else {
 936                 DebugPrint((1, "(%p)\tPreviously unlocked queue\n", Irp));
 937                 ASSERT(NT_SUCCESS(Irp->IoStatus.Status));
 938                 ASSERT(context->Srb.SrbStatus == SRB_STATUS_SUCCESS);
 939             }
 940
 941             DebugPrint((1, "(%p)\tFreeing srb and completing\n", Irp));
 942             context->InUse = FALSE;
 943             status = context->FinalStatus; // allow failure to propogate
 944             context = NULL;
 945
 946             if(Irp->PendingReturned) {
 947                 IoMarkIrpPending(Irp);
 948             }
 949
 950             Irp->IoStatus.Status = status;
 951             Irp->IoStatus.Information = 0;
 952
 953             if (NT_SUCCESS(status)) {
 954
 955                 //
 956                 // Set the new power state
 957                 //
 958
 959                 fdoExtension->DevicePowerState =
 960                     currentStack->Parameters.Power.State.DeviceState;
 961
 962             }
 963
 964
 965             DebugPrint((1, "(%p)\tStarting next power irp\n", Irp));
 966
 967             ClassReleaseRemoveLock(DeviceObject, Irp);
 968             PoStartNextPowerIrp(Irp);
 969             fdoExtension->PowerDownInProgress = FALSE;
 970
 971             return status;
 972         }
 973
 974         case PowerDownDeviceInitial2: {
 975             NT_ASSERT(context->PowerChangeState.PowerDown2 != PowerDownDeviceInitial2);
 976             break;
 977         }
 978     }
 979
 980     return STATUS_MORE_PROCESSING_REQUIRED;
 981 } // end ClasspPowerDownCompletion()
 982
 983 /*++////////////////////////////////////////////////////////////////////////////
 984
 985 ClasspPowerHandler()
 986
 987 Routine Description:
 988
 989     This routine reduces the number of useless spinups and spindown requests
 990     sent to a given device by ignoring transitions to power states we are
 991     currently in.
 992
 993     ISSUE-2000/02/20-henrygab - by ignoring spin-up requests, we may be
 994           allowing the drive
 995
 996 Arguments:
 997
 998     DeviceObject - the device object which is transitioning power states
 999     Irp - the power irp
1000     Options - a set of flags indicating what the device handles
1001
1002 Return Value:
1003
1004 --*/
1005 NTSTATUS
1006 NTAPI
1007 ClasspPowerHandler(
1008     IN PDEVICE_OBJECT DeviceObject,
1009     IN PIRP Irp,
1010     IN CLASS_POWER_OPTIONS Options  // ISSUE-2000/02/20-henrygab - pass pointer, not whole struct
1011     )
1012 {
1013     PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
1014     PDEVICE_OBJECT lowerDevice = commonExtension->LowerDeviceObject;
1015     PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
1016     PIO_STACK_LOCATION nextIrpStack;
1017     PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
1018     PCLASS_POWER_CONTEXT context;
1019
1020     if (!commonExtension->IsFdo) {
1021
1022         //
1023         // certain assumptions are made here,
1024         // particularly: having the fdoExtension
1025         //
1026
1027         DebugPrint((0, "ClasspPowerHandler: Called for PDO %p???\n",
1028                     DeviceObject));
1029         ASSERT(!"PDO using ClasspPowerHandler");
1030         return STATUS_NOT_SUPPORTED;
1031     }
1032
1033     DebugPrint((1, "ClasspPowerHandler: Power irp %p to %s %p\n",
1034                 Irp, (commonExtension->IsFdo ? "fdo" : "pdo"), DeviceObject));
1035
1036     switch(irpStack->MinorFunction) {
1037
1038         case IRP_MN_SET_POWER: {
1039             PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
1040
1041             DebugPrint((1, "(%p)\tIRP_MN_SET_POWER\n", Irp));
1042
1043             DebugPrint((1, "(%p)\tSetting %s state to %d\n",
1044                         Irp,
1045                         (irpStack->Parameters.Power.Type == SystemPowerState ?
1046                             "System" : "Device"),
1047                         irpStack->Parameters.Power.State.SystemState));
1048
1049                 switch (irpStack->Parameters.Power.ShutdownType){
1050
1051                     case PowerActionSleep:
1052                     case PowerActionHibernate:
1053                         if (fdoData->HotplugInfo.MediaRemovable || fdoData->HotplugInfo.MediaHotplug){
1054                             /*
1055                              *  We are suspending and this drive is either hot-pluggable
1056                              *  or contains removeable media.
1057                              *  Set the media dirty bit, since the media may change while
1058                              *  we are suspended.
1059                              */
1060                             SET_FLAG(DeviceObject->Flags, DO_VERIFY_VOLUME);
1061                         }
1062                         break;
1063                     default:
1064                         break;
1065                 }
1066
1067             break;
1068         }
1069
1070         default: {
1071
1072             DebugPrint((1, "(%p)\tIrp minor code = %#x\n",
1073                         Irp, irpStack->MinorFunction));
1074             break;
1075         }
1076     }
1077
1078     if (irpStack->Parameters.Power.Type != DevicePowerState ||
1079         irpStack->MinorFunction != IRP_MN_SET_POWER) {
1080
1081         DebugPrint((1, "(%p)\tSending to lower device\n", Irp));
1082
1083         goto ClasspPowerHandlerCleanup;
1084
1085     }
1086
1087     nextIrpStack = IoGetNextIrpStackLocation(Irp);
1088
1089     //
1090     // already in exact same state, don't work to transition to it.
1091     //
1092
1093     if(irpStack->Parameters.Power.State.DeviceState ==
1094        fdoExtension->DevicePowerState) {
1095
1096         DebugPrint((1, "(%p)\tAlready in device state %x\n",
1097                     Irp, fdoExtension->DevicePowerState));
1098         goto ClasspPowerHandlerCleanup;
1099
1100     }
1101
1102     //
1103     // or powering down from non-d0 state (device already stopped)
1104     // NOTE -- we're not sure whether this case can exist or not (the
1105     // power system may never send this sort of request) but it's trivial
1106     // to deal with.
1107     //
1108
1109     if ((irpStack->Parameters.Power.State.DeviceState != PowerDeviceD0) &&
1110         (fdoExtension->DevicePowerState != PowerDeviceD0)) {
1111         DebugPrint((1, "(%p)\tAlready powered down to %x???\n",
1112                     Irp, fdoExtension->DevicePowerState));
1113         fdoExtension->DevicePowerState =
1114             irpStack->Parameters.Power.State.DeviceState;
1115         goto ClasspPowerHandlerCleanup;
1116     }
1117
1118     //
1119     // or going into a hibernation state when we're in the hibernation path.
1120     // If the device is spinning then we should leave it spinning - if it's not
1121     // then the dump driver will start it up for us.
1122     //
1123
1124     if((irpStack->Parameters.Power.State.DeviceState == PowerDeviceD3) &&
1125        (irpStack->Parameters.Power.ShutdownType == PowerActionHibernate) &&
1126        (commonExtension->HibernationPathCount != 0)) {
1127
1128         DebugPrint((1, "(%p)\tdoing nothing for hibernation request for "
1129                        "state %x???\n",
1130                     Irp, fdoExtension->DevicePowerState));
1131         fdoExtension->DevicePowerState =
1132             irpStack->Parameters.Power.State.DeviceState;
1133         goto ClasspPowerHandlerCleanup;
1134     }
1135     //
1136     // or when not handling powering up and are powering up
1137     //
1138
1139     if ((!Options.HandleSpinUp) &&
1140         (irpStack->Parameters.Power.State.DeviceState == PowerDeviceD0)) {
1141
1142         DebugPrint((2, "(%p)\tNot handling spinup to state %x\n",
1143                     Irp, fdoExtension->DevicePowerState));
1144         fdoExtension->DevicePowerState =
1145             irpStack->Parameters.Power.State.DeviceState;
1146         goto ClasspPowerHandlerCleanup;
1147
1148     }
1149
1150     //
1151     // or when not handling powering down and are powering down
1152     //
1153
1154     if ((!Options.HandleSpinDown) &&
1155         (irpStack->Parameters.Power.State.DeviceState != PowerDeviceD0)) {
1156
1157         DebugPrint((2, "(%p)\tNot handling spindown to state %x\n",
1158                     Irp, fdoExtension->DevicePowerState));
1159         fdoExtension->DevicePowerState =
1160             irpStack->Parameters.Power.State.DeviceState;
1161         goto ClasspPowerHandlerCleanup;
1162
1163     }
1164
1165     context = &(fdoExtension->PowerContext);
1166
1167 #if DBG
1168     //
1169     // Mark the context as in use.  We should be synchronizing this but
1170     // since it's just for debugging purposes we don't worry too much.
1171     //
1172
1173     ASSERT(context->InUse == FALSE);
1174 #endif
1175
1176     RtlZeroMemory(context, sizeof(CLASS_POWER_CONTEXT));
1177     context->InUse = TRUE;
1178
1179     nextIrpStack->Parameters.Scsi.Srb = &(context->Srb);
1180     nextIrpStack->MajorFunction = IRP_MJ_SCSI;
1181
1182     context->FinalStatus = STATUS_SUCCESS;
1183
1184     context->Srb.Length = sizeof(SCSI_REQUEST_BLOCK);
1185     context->Srb.OriginalRequest = Irp;
1186     context->Srb.SrbFlags |= SRB_FLAGS_BYPASS_LOCKED_QUEUE
1187                           |  SRB_FLAGS_NO_QUEUE_FREEZE;
1188     context->Srb.Function = SRB_FUNCTION_LOCK_QUEUE;
1189
1190     context->Srb.SenseInfoBuffer =
1191         commonExtension->PartitionZeroExtension->SenseData;
1192     context->Srb.SenseInfoBufferLength = SENSE_BUFFER_SIZE;
1193     context->RetryCount = MAXIMUM_RETRIES;
1194
1195     context->Options = Options;
1196     context->DeviceObject = DeviceObject;
1197     context->Irp = Irp;
1198
1199     if(irpStack->Parameters.Power.State.DeviceState == PowerDeviceD0) {
1200
1201         ASSERT(Options.HandleSpinUp);
1202
1203         DebugPrint((2, "(%p)\tpower up - locking queue\n", Irp));
1204
1205         //
1206         // We need to issue a queue lock request so that we
1207         // can spin the drive back up after the power is restored
1208         // but before any requests are processed.
1209         //
1210
1211         context->Options.PowerDown = FALSE;
1212         context->PowerChangeState.PowerUp = PowerUpDeviceInitial;
1213         context->CompletionRoutine = ClasspPowerUpCompletion;
1214
1215     } else {
1216
1217         ASSERT(Options.HandleSpinDown);
1218
1219         fdoExtension->PowerDownInProgress = TRUE;
1220
1221         DebugPrint((2, "(%p)\tPowering down - locking queue\n", Irp));
1222
1223         PoSetPowerState(DeviceObject,
1224                         irpStack->Parameters.Power.Type,
1225                         irpStack->Parameters.Power.State);
1226
1227         context->Options.PowerDown = TRUE;
1228         context->PowerChangeState.PowerDown2 = PowerDownDeviceInitial2;
1229         context->CompletionRoutine = ClasspPowerDownCompletion;
1230
1231     }
1232
1233     //
1234     // we are not dealing with port-allocated sense in these routines.
1235     //
1236
1237     ASSERT(!TEST_FLAG(context->Srb.SrbFlags, SRB_FLAGS_FREE_SENSE_BUFFER));
1238     ASSERT(!TEST_FLAG(context->Srb.SrbFlags, SRB_FLAGS_PORT_DRIVER_ALLOCSENSE));
1239
1240     //
1241     // we are always returning STATUS_PENDING, so we need to always
1242     // set the irp as pending.
1243     //
1244
1245     IoMarkIrpPending(Irp);
1246
1247     if(Options.LockQueue) {
1248
1249         //
1250         // Send the lock irp down.
1251         //
1252
1253         IoSetCompletionRoutine(Irp,
1254                                context->CompletionRoutine,
1255                                context,
1256                                TRUE,
1257                                TRUE,
1258                                TRUE);
1259
1260         IoCallDriver(lowerDevice, Irp);
1261
1262     } else {
1263
1264         //
1265         // Call the completion routine directly.  It won't care what the
1266         // status of the "lock" was - it will just go and do the next
1267         // step of the operation.
1268         //
1269
1270         context->CompletionRoutine(DeviceObject, Irp, context);
1271     }
1272
1273     return STATUS_PENDING;
1274
1275 ClasspPowerHandlerCleanup:
1276
1277     ClassReleaseRemoveLock(DeviceObject, Irp);
1278
1279     DebugPrint((1, "(%p)\tStarting next power irp\n", Irp));
1280     IoCopyCurrentIrpStackLocationToNext(Irp);
1281     IoSetCompletionRoutine(Irp,
1282                            ClasspStartNextPowerIrpCompletion,
1283                            NULL,
1284                            TRUE,
1285                            TRUE,
1286                            TRUE);
1287     return PoCallDriver(lowerDevice, Irp);
1288 } // end ClasspPowerHandler()
1289
1290 /*++////////////////////////////////////////////////////////////////////////////
1291
1292 ClassMinimalPowerHandler()
1293
1294 Routine Description:
1295
1296     This routine is the minimum power handler for a storage driver.  It does
1297     the least amount of work possible.
1298
1299 --*/
1300 NTSTATUS
1301 NTAPI
1302 ClassMinimalPowerHandler(
1303     IN PDEVICE_OBJECT DeviceObject,
1304     IN PIRP Irp
1305     )
1306 {
1307     PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
1308     PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
1309     NTSTATUS status;
1310
1311     ClassReleaseRemoveLock(DeviceObject, Irp);
1312     PoStartNextPowerIrp(Irp);
1313
1314     if(commonExtension->IsFdo) {
1315
1316         if (DeviceObject->Characteristics & FILE_REMOVABLE_MEDIA) {
1317
1318             PFUNCTIONAL_DEVICE_EXTENSION fdoExtension =
1319                 DeviceObject->DeviceExtension;
1320
1321             //
1322             // Check if the system is going to hibernate or standby.
1323             //
1324             if (irpStack->MinorFunction == IRP_MN_SET_POWER){
1325                 PVPB vpb;
1326
1327                 switch (irpStack->Parameters.Power.ShutdownType){
1328
1329                     case PowerActionSleep:
1330                     case PowerActionHibernate:
1331                         //
1332                         // If the volume is mounted, set the verify bit so that
1333                         // the filesystem will be forced re-read the media
1334                         // after coming out of hibernation or standby.
1335                         //
1336                         vpb = ClassGetVpb(fdoExtension->DeviceObject);
1337                         if (vpb && (vpb->Flags & VPB_MOUNTED)){
1338                             SET_FLAG(fdoExtension->DeviceObject->Flags, DO_VERIFY_VOLUME);
1339                         }
1340                         break;
1341                     default:
1342                         break;
1343                 }
1344             }
1345         }
1346
1347         IoCopyCurrentIrpStackLocationToNext(Irp);
1348         return PoCallDriver(commonExtension->LowerDeviceObject, Irp);
1349
1350     } else {
1351
1352         if (irpStack->MinorFunction != IRP_MN_SET_POWER &&
1353             irpStack->MinorFunction != IRP_MN_QUERY_POWER) {
1354
1355             NOTHING;
1356
1357         } else {
1358
1359             Irp->IoStatus.Status = STATUS_SUCCESS;
1360             Irp->IoStatus.Information = 0;
1361
1362         }
1363         status = Irp->IoStatus.Status;
1364
1365         ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
1366         return status;
1367     }
1368 } // end ClassMinimalPowerHandler()
1369
1370 /*++////////////////////////////////////////////////////////////////////////////
1371
1372 ClassSpinDownPowerHandler()
1373
1374 Routine Description:
1375
1376     This routine is a callback for disks and other things which require both
1377     a start and a stop to be sent to the device.  (actually the starts are
1378     almost always optional, since most device power themselves on to process
1379     commands, but i digress).
1380
1381     Determines proper use of spinup, spindown, and queue locking based upon
1382     ScanForSpecialFlags in the FdoExtension.  This is the most common power
1383     handler passed into classpnp.sys
1384
1385 Arguments:
1386
1387     DeviceObject - Supplies the functional device object
1388
1389     Irp - Supplies the request to be retried.
1390
1391 Return Value:
1392
1393     None
1394
1395 --*/
1396 NTSTATUS
1397 NTAPI
1398 ClassSpinDownPowerHandler(
1399     IN PDEVICE_OBJECT DeviceObject,
1400     IN PIRP Irp
1401     )
1402 {
1403     PFUNCTIONAL_DEVICE_EXTENSION fdoExtension;
1404     CLASS_POWER_OPTIONS options;
1405
1406     fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
1407
1408     //
1409     // this will set all options to FALSE
1410     //
1411
1412     RtlZeroMemory(&options, sizeof(CLASS_POWER_OPTIONS));
1413
1414     //
1415     // check the flags to see what options we need to worry about
1416     //
1417
1418     if (!TEST_FLAG(fdoExtension->ScanForSpecialFlags,
1419                   CLASS_SPECIAL_DISABLE_SPIN_DOWN)) {
1420         options.HandleSpinDown = TRUE;
1421     }
1422
1423     if (!TEST_FLAG(fdoExtension->ScanForSpecialFlags,
1424                   CLASS_SPECIAL_DISABLE_SPIN_UP)) {
1425         options.HandleSpinUp = TRUE;
1426     }
1427
1428     if (!TEST_FLAG(fdoExtension->ScanForSpecialFlags,
1429                   CLASS_SPECIAL_NO_QUEUE_LOCK)) {
1430         options.LockQueue = TRUE;
1431     }
1432
1433     DebugPrint((3, "ClasspPowerHandler: Devobj %p\n"
1434                 "\t%shandling spin down\n"
1435                 "\t%shandling spin up\n"
1436                 "\t%slocking queue\n",
1437                 DeviceObject,
1438                 (options.HandleSpinDown ? "" : "not "),
1439                 (options.HandleSpinUp   ? "" : "not "),
1440                 (options.LockQueue      ? "" : "not ")
1441                 ));
1442
1443     //
1444     // do all the dirty work
1445     //
1446
1447     return ClasspPowerHandler(DeviceObject, Irp, options);
1448 } // end ClassSpinDownPowerHandler()
1449
1450 /*++////////////////////////////////////////////////////////////////////////////
1451
1452 ClassStopUnitPowerHandler()
1453
1454 Routine Description:
1455
1456     This routine is an outdated call.  To achieve equivalent functionality,
1457     the driver should set the following flags in ScanForSpecialFlags in the
1458     FdoExtension:
1459
1460         CLASS_SPECIAL_DISABLE_SPIN_UP
1461         CLASS_SPECIAL_NO_QUEUE_LOCK
1462
1463 --*/
1464 NTSTATUS
1465 NTAPI
1466 ClassStopUnitPowerHandler(
1467     IN PDEVICE_OBJECT DeviceObject,
1468     IN PIRP Irp
1469     )
1470 {
1471     PFUNCTIONAL_DEVICE_EXTENSION fdoExtension;
1472
1473     DebugPrint((0, "ClassStopUnitPowerHandler - Devobj %p using outdated call\n"
1474                 "Drivers should set the following flags in ScanForSpecialFlags "
1475                 " in the FDO extension:\n"
1476                 "\tCLASS_SPECIAL_DISABLE_SPIN_UP\n"
1477                 "\tCLASS_SPECIAL_NO_QUEUE_LOCK\n"
1478                 "This will provide equivalent functionality if the power "
1479                 "routine is then set to ClassSpinDownPowerHandler\n\n",
1480                 DeviceObject));
1481
1482     fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
1483
1484     SET_FLAG(fdoExtension->ScanForSpecialFlags,
1485              CLASS_SPECIAL_DISABLE_SPIN_UP);
1486     SET_FLAG(fdoExtension->ScanForSpecialFlags,
1487              CLASS_SPECIAL_NO_QUEUE_LOCK);
1488
1489     return ClassSpinDownPowerHandler(DeviceObject, Irp);
1490 } // end ClassStopUnitPowerHandler()
1491
1492 /*++////////////////////////////////////////////////////////////////////////////
1493
1494 RetryPowerRequest()
1495
1496 Routine Description:
1497
1498     This routine reinitializes the necessary fields, and sends the request
1499     to the lower driver.
1500
1501 Arguments:
1502
1503     DeviceObject - Supplies the device object associated with this request.
1504
1505     Irp - Supplies the request to be retried.
1506
1507     Context - Supplies a pointer to the power up context for this request.
1508
1509 Return Value:
1510
1511     None
1512
1513 --*/
1514 VOID
1515 NTAPI
1516 RetryPowerRequest(
1517     PDEVICE_OBJECT DeviceObject,
1518     PIRP Irp,
1519     PCLASS_POWER_CONTEXT Context
1520     )
1521 {
1522     PIO_STACK_LOCATION nextIrpStack = IoGetNextIrpStackLocation(Irp);
1523     PSCSI_REQUEST_BLOCK srb = &(Context->Srb);
1524     LARGE_INTEGER dueTime;
1525
1526     DebugPrint((1, "(%p)\tDelaying retry by queueing DPC\n", Irp));
1527
1528     ASSERT(Context->Irp == Irp);
1529     ASSERT(Context->DeviceObject == DeviceObject);
1530     ASSERT(!TEST_FLAG(Context->Srb.SrbFlags, SRB_FLAGS_FREE_SENSE_BUFFER));
1531     ASSERT(!TEST_FLAG(Context->Srb.SrbFlags, SRB_FLAGS_PORT_DRIVER_ALLOCSENSE));
1532
1533     //
1534     // reset the retry interval
1535     //
1536
1537     Context->RetryInterval = 0;
1538
1539     //
1540     // Reset byte count of transfer in SRB Extension.
1541     //
1542
1543     srb->DataTransferLength = 0;
1544
1545     //
1546     // Zero SRB statuses.
1547     //
1548
1549     srb->SrbStatus = srb->ScsiStatus = 0;
1550
1551     //
1552     // Set up major SCSI function.
1553     //
1554
1555     nextIrpStack->MajorFunction = IRP_MJ_SCSI;
1556
1557     //
1558     // Save SRB address in next stack for port driver.
1559     //
1560
1561     nextIrpStack->Parameters.Scsi.Srb = srb;
1562
1563     //
1564     // Set the completion routine up again.
1565     //
1566
1567     IoSetCompletionRoutine(Irp, Context->CompletionRoutine, Context,
1568                            TRUE, TRUE, TRUE);
1569
1570
1571     if (Context->RetryInterval == 0) {
1572
1573         DebugPrint((2, "(%p)\tDelaying minimum time (.2 sec)\n", Irp));
1574         dueTime.QuadPart = (LONGLONG)1000000 * 2;
1575
1576     } else {
1577
1578         DebugPrint((2, "(%p)\tDelaying %x seconds\n",
1579                     Irp, Context->RetryInterval));
1580         dueTime.QuadPart = (LONGLONG)1000000 * 10 * Context->RetryInterval;
1581
1582     }
1583
1584     ClassRetryRequest(DeviceObject, Irp, dueTime);
1585
1586     return;
1587
1588 } // end RetryRequest()
1589
1590 /*++////////////////////////////////////////////////////////////////////////////
1591
1592 ClasspStartNextPowerIrpCompletion()
1593
1594 Routine Description:
1595
1596     This routine guarantees that the next power irp (power up or down) is not
1597     sent until the previous one has fully completed.
1598
1599 --*/
1600 NTSTATUS
1601 NTAPI
1602 ClasspStartNextPowerIrpCompletion(
1603     IN PDEVICE_OBJECT DeviceObject,
1604     IN PIRP Irp,
1605     IN PVOID Context
1606     )
1607 {
1608     if(Irp->PendingReturned) {
1609         IoMarkIrpPending(Irp);
1610     }
1611
1612     PoStartNextPowerIrp(Irp);
1613     return STATUS_SUCCESS;
1614 } // end ClasspStartNextPowerIrpCompletion()