ee5bfba18946f099d2d7de1eedd135aa406bd3ea
[reactos.git] / drivers / usb / usbstor / scsi.c
1 /*
2 * PROJECT: ReactOS Universal Serial Bus Bulk Storage Driver
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: drivers/usb/usbstor/pdo.c
5 * PURPOSE: USB block storage device driver.
6 * PROGRAMMERS:
7 * James Tabor
8 * Michael Martin (michael.martin@reactos.org)
9 * Johannes Anderwald (johannes.anderwald@reactos.org)
10 */
11
12 #include "usbstor.h"
13
14 #define NDEBUG
15 #include <debug.h>
16
17 NTSTATUS
18 USBSTOR_BuildCBW(
19 IN ULONG Tag,
20 IN ULONG DataTransferLength,
21 IN UCHAR LUN,
22 IN UCHAR CommandBlockLength,
23 IN PUCHAR CommandBlock,
24 IN OUT PCBW Control)
25 {
26 //
27 // sanity check
28 //
29 ASSERT(CommandBlockLength <= 16);
30
31 //
32 // now initialize CBW
33 //
34 Control->Signature = CBW_SIGNATURE;
35 Control->Tag = Tag;
36 Control->DataTransferLength = DataTransferLength;
37 Control->Flags = (CommandBlock[0] != SCSIOP_WRITE) ? 0x80 : 0x00;
38 Control->LUN = (LUN & MAX_LUN);
39 Control->CommandBlockLength = CommandBlockLength;
40
41 //
42 // copy command block
43 //
44 RtlCopyMemory(Control->CommandBlock, CommandBlock, CommandBlockLength);
45
46 //
47 // done
48 //
49 return STATUS_SUCCESS;
50 }
51
52 PIRP_CONTEXT
53 USBSTOR_AllocateIrpContext()
54 {
55 PIRP_CONTEXT Context;
56
57 //
58 // allocate irp context
59 //
60 Context = (PIRP_CONTEXT)AllocateItem(NonPagedPool, sizeof(IRP_CONTEXT));
61 if (!Context)
62 {
63 //
64 // no memory
65 //
66 return NULL;
67 }
68
69 //
70 // allocate cbw block
71 //
72 Context->cbw = (PCBW)AllocateItem(NonPagedPool, 512);
73 if (!Context->cbw)
74 {
75 //
76 // no memory
77 //
78 FreeItem(Context);
79 return NULL;
80 }
81
82 //
83 // done
84 //
85 return Context;
86
87 }
88
89 BOOLEAN
90 USBSTOR_IsCSWValid(
91 PIRP_CONTEXT Context)
92 {
93 //
94 // sanity checks
95 //
96 if (Context->csw->Signature != CSW_SIGNATURE)
97 {
98 DPRINT1("[USBSTOR] Expected Signature %x but got %x\n", CSW_SIGNATURE, Context->csw->Signature);
99 return FALSE;
100 }
101
102 if (Context->csw->Tag != (ULONG)Context->csw)
103 {
104 DPRINT1("[USBSTOR] Expected Tag %x but got %x\n", (ULONG)Context->csw, Context->csw->Tag);
105 return FALSE;
106 }
107
108 if (Context->csw->Status != 0x00)
109 {
110 DPRINT1("[USBSTOR] Expected Status 0x00 but got %x\n", Context->csw->Status);
111 return FALSE;
112 }
113
114 //
115 // CSW is valid
116 //
117 return TRUE;
118
119 }
120
121 NTSTATUS
122 USBSTOR_QueueWorkItem(
123 PIRP_CONTEXT Context,
124 PIRP Irp)
125 {
126 PERRORHANDLER_WORKITEM_DATA ErrorHandlerWorkItemData;
127
128 //
129 // Allocate Work Item Data
130 //
131 ErrorHandlerWorkItemData = ExAllocatePoolWithTag(NonPagedPool, sizeof(ERRORHANDLER_WORKITEM_DATA), USB_STOR_TAG);
132 if (!ErrorHandlerWorkItemData)
133 {
134 //
135 // no memory
136 //
137 return STATUS_INSUFFICIENT_RESOURCES;
138 }
139
140 //
141 // error handling started
142 //
143 Context->FDODeviceExtension->SrbErrorHandlingActive = TRUE;
144
145 //
146 // srb error handling finished
147 //
148 Context->FDODeviceExtension->TimerWorkQueueEnabled = FALSE;
149
150 //
151 // Initialize and queue the work item to handle the error
152 //
153 ExInitializeWorkItem(&ErrorHandlerWorkItemData->WorkQueueItem,
154 ErrorHandlerWorkItemRoutine,
155 ErrorHandlerWorkItemData);
156
157 ErrorHandlerWorkItemData->DeviceObject = Context->FDODeviceExtension->FunctionalDeviceObject;
158 ErrorHandlerWorkItemData->Context = Context;
159 ErrorHandlerWorkItemData->Irp = Irp;
160 ErrorHandlerWorkItemData->DeviceObject = Context->FDODeviceExtension->FunctionalDeviceObject;
161
162 DPRINT1("Queuing WorkItemROutine\n");
163 ExQueueWorkItem(&ErrorHandlerWorkItemData->WorkQueueItem, DelayedWorkQueue);
164 return STATUS_MORE_PROCESSING_REQUIRED;
165 }
166
167
168 //
169 // driver verifier
170 //
171 IO_COMPLETION_ROUTINE USBSTOR_CSWCompletionRoutine;
172
173 NTSTATUS
174 NTAPI
175 USBSTOR_CSWCompletionRoutine(
176 PDEVICE_OBJECT DeviceObject,
177 PIRP Irp,
178 PVOID Ctx)
179 {
180 PIRP_CONTEXT Context;
181 PIO_STACK_LOCATION IoStack;
182 PSCSI_REQUEST_BLOCK Request;
183 PCDB pCDB;
184 PREAD_CAPACITY_DATA_EX CapacityDataEx;
185 PREAD_CAPACITY_DATA CapacityData;
186 PUFI_CAPACITY_RESPONSE Response;
187 NTSTATUS Status;
188
189 //
190 // access context
191 //
192 Context = (PIRP_CONTEXT)Ctx;
193
194 //
195 // is there a mdl
196 //
197 if (Context->TransferBufferMDL)
198 {
199 //
200 // is there an irp associated
201 //
202 if (Context->Irp)
203 {
204 //
205 // did we allocate the mdl
206 //
207 if (Context->TransferBufferMDL != Context->Irp->MdlAddress)
208 {
209 //
210 // free mdl
211 //
212 IoFreeMdl(Context->TransferBufferMDL);
213 }
214 }
215 else
216 {
217 //
218 // free mdl
219 //
220 IoFreeMdl(Context->TransferBufferMDL);
221 }
222 }
223
224 DPRINT("USBSTOR_CSWCompletionRoutine Status %x\n", Irp->IoStatus.Status);
225
226 if (!NT_SUCCESS(Irp->IoStatus.Information))
227 {
228 if (Context->ErrorIndex == 0)
229 {
230 //
231 // increment error index
232 //
233 Context->ErrorIndex = 1;
234
235 //
236 // clear stall and resend cbw
237 //
238 Status = USBSTOR_QueueWorkItem(Context, Irp);
239 ASSERT(Status == STATUS_MORE_PROCESSING_REQUIRED);
240 return STATUS_MORE_PROCESSING_REQUIRED;
241 }
242
243 //
244 // perform reset recovery
245 //
246 Context->ErrorIndex = 2;
247 IoFreeIrp(Irp);
248 Status = USBSTOR_QueueWorkItem(Context, NULL);
249 ASSERT(Status == STATUS_MORE_PROCESSING_REQUIRED);
250 return STATUS_MORE_PROCESSING_REQUIRED;
251 }
252
253 if (!USBSTOR_IsCSWValid(Context))
254 {
255 //
256 // perform reset recovery
257 //
258 Context->ErrorIndex = 2;
259 IoFreeIrp(Irp);
260 Status = USBSTOR_QueueWorkItem(Context, NULL);
261 ASSERT(Status == STATUS_MORE_PROCESSING_REQUIRED);
262 return STATUS_MORE_PROCESSING_REQUIRED;
263 }
264
265
266 //
267 // get current stack location
268 //
269 IoStack = IoGetCurrentIrpStackLocation(Context->Irp);
270
271 //
272 // get request block
273 //
274 Request = (PSCSI_REQUEST_BLOCK)IoStack->Parameters.Others.Argument1;
275 ASSERT(Request);
276
277 Status = Irp->IoStatus.Status;
278
279 //
280 // get SCSI command data block
281 //
282 pCDB = (PCDB)Request->Cdb;
283 Request->SrbStatus = SRB_STATUS_SUCCESS;
284
285 //
286 // read capacity needs special work
287 //
288 if (pCDB->AsByte[0] == SCSIOP_READ_CAPACITY)
289 {
290 //
291 // get output buffer
292 //
293 Response = (PUFI_CAPACITY_RESPONSE)Context->TransferData;
294
295 //
296 // store in pdo
297 //
298 Context->PDODeviceExtension->BlockLength = NTOHL(Response->BlockLength);
299 Context->PDODeviceExtension->LastLogicBlockAddress = NTOHL(Response->LastLogicalBlockAddress);
300
301 if (Request->DataTransferLength == sizeof(READ_CAPACITY_DATA_EX))
302 {
303 //
304 // get input buffer
305 //
306 CapacityDataEx = (PREAD_CAPACITY_DATA_EX)Request->DataBuffer;
307
308 //
309 // set result
310 //
311 CapacityDataEx->BytesPerBlock = Response->BlockLength;
312 CapacityDataEx->LogicalBlockAddress.QuadPart = Response->LastLogicalBlockAddress;
313 Irp->IoStatus.Information = sizeof(READ_CAPACITY_DATA_EX);
314 }
315 else
316 {
317 //
318 // get input buffer
319 //
320 CapacityData = (PREAD_CAPACITY_DATA)Request->DataBuffer;
321
322 //
323 // set result
324 //
325 CapacityData->BytesPerBlock = Response->BlockLength;
326 CapacityData->LogicalBlockAddress = Response->LastLogicalBlockAddress;
327 Irp->IoStatus.Information = sizeof(READ_CAPACITY_DATA);
328 }
329
330 //
331 // free response
332 //
333 FreeItem(Context->TransferData);
334 }
335
336 //
337 // free cbw
338 //
339 FreeItem(Context->cbw);
340
341 //
342 // FIXME: check status
343 //
344 Context->Irp->IoStatus.Status = Irp->IoStatus.Status;
345 Context->Irp->IoStatus.Information = Context->TransferDataLength;
346
347 //
348 // terminate current request
349 //
350 USBSTOR_QueueTerminateRequest(Context->PDODeviceExtension->LowerDeviceObject, Context->Irp);
351
352 //
353 // complete request
354 //
355 IoCompleteRequest(Context->Irp, IO_NO_INCREMENT);
356
357 //
358 // start next request
359 //
360 USBSTOR_QueueNextRequest(Context->PDODeviceExtension->LowerDeviceObject);
361
362 //
363 // free our allocated irp
364 //
365 IoFreeIrp(Irp);
366
367 //
368 // free context
369 //
370 FreeItem(Context);
371
372 //
373 // done
374 //
375 return STATUS_MORE_PROCESSING_REQUIRED;
376 }
377
378 VOID
379 USBSTOR_SendCSW(
380 PIRP_CONTEXT Context,
381 PIRP Irp)
382 {
383 PIO_STACK_LOCATION IoStack;
384
385 //
386 // get next irp stack location
387 //
388 IoStack = IoGetNextIrpStackLocation(Irp);
389
390 //
391 // now initialize the urb for sending the csw
392 //
393 UsbBuildInterruptOrBulkTransferRequest(&Context->Urb,
394 sizeof(struct _URB_BULK_OR_INTERRUPT_TRANSFER),
395 Context->FDODeviceExtension->InterfaceInformation->Pipes[Context->FDODeviceExtension->BulkInPipeIndex].PipeHandle,
396 Context->csw,
397 NULL,
398 512, //FIXME
399 USBD_TRANSFER_DIRECTION_IN | USBD_SHORT_TRANSFER_OK,
400 NULL);
401
402 //
403 // initialize stack location
404 //
405 IoStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
406 IoStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_INTERNAL_USB_SUBMIT_URB;
407 IoStack->Parameters.Others.Argument1 = (PVOID)&Context->Urb;
408 IoStack->Parameters.DeviceIoControl.InputBufferLength = Context->Urb.UrbHeader.Length;
409 Irp->IoStatus.Status = STATUS_SUCCESS;
410
411
412 //
413 // setup completion routine
414 //
415 IoSetCompletionRoutine(Irp, USBSTOR_CSWCompletionRoutine, Context, TRUE, TRUE, TRUE);
416
417 //
418 // call driver
419 //
420 IoCallDriver(Context->FDODeviceExtension->LowerDeviceObject, Irp);
421 }
422
423
424 //
425 // driver verifier
426 //
427 IO_COMPLETION_ROUTINE USBSTOR_DataCompletionRoutine;
428
429 NTSTATUS
430 NTAPI
431 USBSTOR_DataCompletionRoutine(
432 PDEVICE_OBJECT DeviceObject,
433 PIRP Irp,
434 PVOID Ctx)
435 {
436 PIRP_CONTEXT Context;
437 NTSTATUS Status;
438
439
440 DPRINT("USBSTOR_DataCompletionRoutine Irp %p Ctx %p Status %x\n", Irp, Ctx, Irp->IoStatus.Status);
441
442 //
443 // access context
444 //
445 Context = (PIRP_CONTEXT)Ctx;
446
447 if (!NT_SUCCESS(Irp->IoStatus.Status))
448 {
449 //
450 // clear stall and resend cbw
451 //
452 Context->ErrorIndex = 1;
453 Status = USBSTOR_QueueWorkItem(Context, Irp);
454 ASSERT(Status == STATUS_MORE_PROCESSING_REQUIRED);
455 return STATUS_MORE_PROCESSING_REQUIRED;
456 }
457
458 //
459 // send csw
460 //
461 USBSTOR_SendCSW(Context, Irp);
462
463 //
464 // cancel completion
465 //
466 return STATUS_MORE_PROCESSING_REQUIRED;
467 }
468
469 //
470 // driver verifier
471 //
472 IO_COMPLETION_ROUTINE USBSTOR_CBWCompletionRoutine;
473
474 NTSTATUS
475 NTAPI
476 USBSTOR_CBWCompletionRoutine(
477 PDEVICE_OBJECT DeviceObject,
478 PIRP Irp,
479 PVOID Ctx)
480 {
481 PIRP_CONTEXT Context;
482 PIO_STACK_LOCATION IoStack;
483 UCHAR Code;
484 USBD_PIPE_HANDLE PipeHandle;
485
486 DPRINT("USBSTOR_CBWCompletionRoutine Irp %p Ctx %p Status %x\n", Irp, Ctx, Irp->IoStatus.Status);
487
488 //
489 // access context
490 //
491 Context = (PIRP_CONTEXT)Ctx;
492
493 //
494 // get next stack location
495 //
496 IoStack = IoGetNextIrpStackLocation(Irp);
497
498 //
499 // is there data to be submitted
500 //
501 if (Context->TransferDataLength)
502 {
503 //
504 // get command code
505 //
506 Code = Context->cbw->CommandBlock[0];
507
508 if (Code == SCSIOP_WRITE)
509 {
510 //
511 // write request use bulk out pipe
512 //
513 PipeHandle = Context->FDODeviceExtension->InterfaceInformation->Pipes[Context->FDODeviceExtension->BulkOutPipeIndex].PipeHandle;
514 }
515 else
516 {
517 //
518 // default bulk in pipe
519 //
520 PipeHandle = Context->FDODeviceExtension->InterfaceInformation->Pipes[Context->FDODeviceExtension->BulkInPipeIndex].PipeHandle;
521 }
522
523 //
524 // now initialize the urb for sending data
525 //
526 UsbBuildInterruptOrBulkTransferRequest(&Context->Urb,
527 sizeof(struct _URB_BULK_OR_INTERRUPT_TRANSFER),
528 PipeHandle,
529 NULL,
530 Context->TransferBufferMDL,
531 Context->TransferDataLength,
532 ((Code == SCSIOP_WRITE) ? USBD_TRANSFER_DIRECTION_OUT : (USBD_TRANSFER_DIRECTION_IN | USBD_SHORT_TRANSFER_OK)),
533 NULL);
534
535 //
536 // setup completion routine
537 //
538 IoSetCompletionRoutine(Irp, USBSTOR_DataCompletionRoutine, Context, TRUE, TRUE, TRUE);
539 }
540 else
541 {
542 //
543 // now initialize the urb for sending the csw
544 //
545
546 UsbBuildInterruptOrBulkTransferRequest(&Context->Urb,
547 sizeof(struct _URB_BULK_OR_INTERRUPT_TRANSFER),
548 Context->FDODeviceExtension->InterfaceInformation->Pipes[Context->FDODeviceExtension->BulkInPipeIndex].PipeHandle,
549 Context->csw,
550 NULL,
551 512, //FIXME
552 USBD_TRANSFER_DIRECTION_IN | USBD_SHORT_TRANSFER_OK,
553 NULL);
554
555 //
556 // setup completion routine
557 //
558 IoSetCompletionRoutine(Irp, USBSTOR_CSWCompletionRoutine, Context, TRUE, TRUE, TRUE);
559 }
560
561 //
562 // initialize stack location
563 //
564 IoStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
565 IoStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_INTERNAL_USB_SUBMIT_URB;
566 IoStack->Parameters.Others.Argument1 = (PVOID)&Context->Urb;
567 IoStack->Parameters.DeviceIoControl.InputBufferLength = Context->Urb.UrbHeader.Length;
568 Irp->IoStatus.Status = STATUS_SUCCESS;
569
570 //
571 // call driver
572 //
573 IoCallDriver(Context->FDODeviceExtension->LowerDeviceObject, Irp);
574
575 return STATUS_MORE_PROCESSING_REQUIRED;
576 }
577
578 VOID
579 DumpCBW(
580 PUCHAR Block)
581 {
582 DPRINT("%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
583 Block[0] & 0xFF, Block[1] & 0xFF, Block[2] & 0xFF, Block[3] & 0xFF, Block[4] & 0xFF, Block[5] & 0xFF, Block[6] & 0xFF, Block[7] & 0xFF, Block[8] & 0xFF, Block[9] & 0xFF,
584 Block[10] & 0xFF, Block[11] & 0xFF, Block[12] & 0xFF, Block[13] & 0xFF, Block[14] & 0xFF, Block[15] & 0xFF, Block[16] & 0xFF, Block[17] & 0xFF, Block[18] & 0xFF, Block[19] & 0xFF,
585 Block[20] & 0xFF, Block[21] & 0xFF, Block[22] & 0xFF, Block[23] & 0xFF, Block[24] & 0xFF, Block[25] & 0xFF, Block[26] & 0xFF, Block[27] & 0xFF, Block[28] & 0xFF, Block[29] & 0xFF,
586 Block[30] & 0xFF);
587
588 }
589
590 NTSTATUS
591 USBSTOR_SendCBW(
592 PIRP_CONTEXT Context,
593 PIRP Irp)
594 {
595 PIO_STACK_LOCATION IoStack;
596
597 //
598 // get next stack location
599 //
600 IoStack = IoGetNextIrpStackLocation(Irp);
601
602 //
603 // initialize stack location
604 //
605 IoStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
606 IoStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_INTERNAL_USB_SUBMIT_URB;
607 IoStack->Parameters.Others.Argument1 = (PVOID)&Context->Urb;
608 IoStack->Parameters.DeviceIoControl.InputBufferLength = Context->Urb.UrbHeader.Length;
609 Irp->IoStatus.Status = STATUS_SUCCESS;
610
611 //
612 // setup completion routine
613 //
614 IoSetCompletionRoutine(Irp, USBSTOR_CBWCompletionRoutine, Context, TRUE, TRUE, TRUE);
615
616 //
617 // call driver
618 //
619 return IoCallDriver(Context->FDODeviceExtension->LowerDeviceObject, Irp);
620 }
621
622 NTSTATUS
623 USBSTOR_SendRequest(
624 IN PDEVICE_OBJECT DeviceObject,
625 IN PIRP OriginalRequest,
626 IN UCHAR CommandLength,
627 IN PUCHAR Command,
628 IN ULONG TransferDataLength,
629 IN PUCHAR TransferData,
630 IN ULONG RetryCount)
631 {
632 PIRP_CONTEXT Context;
633 PPDO_DEVICE_EXTENSION PDODeviceExtension;
634 PFDO_DEVICE_EXTENSION FDODeviceExtension;
635 PIRP Irp;
636 PUCHAR MdlVirtualAddress;
637
638 //
639 // first allocate irp context
640 //
641 Context = USBSTOR_AllocateIrpContext();
642 if (!Context)
643 {
644 //
645 // no memory
646 //
647 return STATUS_INSUFFICIENT_RESOURCES;
648 }
649
650 //
651 // get PDO device extension
652 //
653 PDODeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
654
655 //
656 // get FDO device extension
657 //
658 FDODeviceExtension = (PFDO_DEVICE_EXTENSION)PDODeviceExtension->LowerDeviceObject->DeviceExtension;
659
660 //
661 // now build the cbw
662 //
663 USBSTOR_BuildCBW((ULONG)Context->cbw,
664 TransferDataLength,
665 PDODeviceExtension->LUN,
666 CommandLength,
667 Command,
668 Context->cbw);
669
670 DPRINT("CBW %p\n", Context->cbw);
671 DumpCBW((PUCHAR)Context->cbw);
672
673 //
674 // now initialize the urb
675 //
676 UsbBuildInterruptOrBulkTransferRequest(&Context->Urb,
677 sizeof(struct _URB_BULK_OR_INTERRUPT_TRANSFER),
678 FDODeviceExtension->InterfaceInformation->Pipes[FDODeviceExtension->BulkOutPipeIndex].PipeHandle,
679 Context->cbw,
680 NULL,
681 sizeof(CBW),
682 USBD_TRANSFER_DIRECTION_OUT,
683 NULL);
684
685 //
686 // initialize rest of context
687 //
688 Context->Irp = OriginalRequest;
689 Context->TransferData = TransferData;
690 Context->TransferDataLength = TransferDataLength;
691 Context->FDODeviceExtension = FDODeviceExtension;
692 Context->PDODeviceExtension = PDODeviceExtension;
693 Context->RetryCount = RetryCount;
694
695 //
696 // is there transfer data
697 //
698 if (Context->TransferDataLength)
699 {
700 //
701 // check if the original request already does have an mdl associated
702 //
703 if (OriginalRequest)
704 {
705 if ((OriginalRequest->MdlAddress != NULL) &&
706 (Context->TransferData == NULL || Command[0] == SCSIOP_READ || Command[0] == SCSIOP_WRITE))
707 {
708 //
709 // Sanity check that the Mdl does describe the TransferData for read/write
710 //
711 if (CommandLength == UFI_READ_WRITE_CMD_LEN)
712 {
713 MdlVirtualAddress = MmGetMdlVirtualAddress(OriginalRequest->MdlAddress);
714
715 //
716 // is there an offset
717 //
718 if (MdlVirtualAddress != Context->TransferData)
719 {
720 //
721 // lets build an mdl
722 //
723 Context->TransferBufferMDL = IoAllocateMdl(Context->TransferData, MmGetMdlByteCount(OriginalRequest->MdlAddress), FALSE, FALSE, NULL);
724 if (!Context->TransferBufferMDL)
725 {
726 //
727 // failed to allocate MDL
728 //
729 FreeItem(Context->cbw);
730 FreeItem(Context);
731 return STATUS_INSUFFICIENT_RESOURCES;
732 }
733
734 //
735 // now build the partial mdl
736 //
737 IoBuildPartialMdl(OriginalRequest->MdlAddress, Context->TransferBufferMDL, Context->TransferData, Context->TransferDataLength);
738 }
739 }
740
741 if (!Context->TransferBufferMDL)
742 {
743 //
744 // I/O paging request
745 //
746 Context->TransferBufferMDL = OriginalRequest->MdlAddress;
747 }
748 }
749 else
750 {
751 //
752 // allocate mdl for buffer, buffer must be allocated from NonPagedPool
753 //
754 Context->TransferBufferMDL = IoAllocateMdl(Context->TransferData, Context->TransferDataLength, FALSE, FALSE, NULL);
755 if (!Context->TransferBufferMDL)
756 {
757 //
758 // failed to allocate MDL
759 //
760 FreeItem(Context->cbw);
761 FreeItem(Context);
762 return STATUS_INSUFFICIENT_RESOURCES;
763 }
764
765 //
766 // build mdl for nonpaged pool
767 //
768 MmBuildMdlForNonPagedPool(Context->TransferBufferMDL);
769 }
770 }
771 else
772 {
773 //
774 // allocate mdl for buffer, buffer must be allocated from NonPagedPool
775 //
776 Context->TransferBufferMDL = IoAllocateMdl(Context->TransferData, Context->TransferDataLength, FALSE, FALSE, NULL);
777 if (!Context->TransferBufferMDL)
778 {
779 //
780 // failed to allocate MDL
781 //
782 FreeItem(Context->cbw);
783 FreeItem(Context);
784 return STATUS_INSUFFICIENT_RESOURCES;
785 }
786
787 //
788 // build mdl for nonpaged pool
789 //
790 MmBuildMdlForNonPagedPool(Context->TransferBufferMDL);
791 }
792 }
793
794 //
795 // now allocate the request
796 //
797 Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
798 if (!Irp)
799 {
800 FreeItem(Context->cbw);
801 FreeItem(Context);
802 return STATUS_INSUFFICIENT_RESOURCES;
803 }
804
805 if (OriginalRequest)
806 {
807 //
808 // mark orignal irp as pending
809 //
810 IoMarkIrpPending(OriginalRequest);
811 }
812
813 //
814 // send request
815 //
816 USBSTOR_SendCBW(Context, Irp);
817
818 //
819 // done
820 //
821 return STATUS_PENDING;
822 }
823
824 NTSTATUS
825 USBSTOR_SendFormatCapacity(
826 IN PDEVICE_OBJECT DeviceObject,
827 IN PIRP Irp,
828 IN ULONG RetryCount)
829 {
830 UFI_READ_FORMAT_CAPACITY Cmd;
831 PPDO_DEVICE_EXTENSION PDODeviceExtension;
832 PIO_STACK_LOCATION IoStack;
833 PSCSI_REQUEST_BLOCK Request;
834
835 //
836 // get current stack location
837 //
838 IoStack = IoGetCurrentIrpStackLocation(Irp);
839
840 //
841 // get PDO device extension
842 //
843 PDODeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
844
845 //
846 // get request block
847 //
848 Request = (PSCSI_REQUEST_BLOCK)IoStack->Parameters.Others.Argument1;
849
850 //
851 // initialize inquiry cmd
852 //
853 RtlZeroMemory(&Cmd, sizeof(UFI_READ_FORMAT_CAPACITY));
854 Cmd.Code = SCSIOP_READ_FORMATTED_CAPACITY;
855 Cmd.LUN = (PDODeviceExtension->LUN & MAX_LUN);
856 Cmd.AllocationLengthMsb = HTONS(Request->DataTransferLength & 0xFFFF) >> 8;
857 Cmd.AllocationLengthLsb = HTONS(Request->DataTransferLength & 0xFFFF) & 0xFF;
858
859 //
860 // now send the request
861 //
862 return USBSTOR_SendRequest(DeviceObject, Irp, UFI_READ_FORMAT_CAPACITY_CMD_LEN, (PUCHAR)&Cmd, Request->DataTransferLength, (PUCHAR)Request->DataBuffer, RetryCount);
863 }
864
865 NTSTATUS
866 USBSTOR_SendInquiry(
867 IN PDEVICE_OBJECT DeviceObject,
868 IN PIRP Irp,
869 IN ULONG RetryCount)
870 {
871 UFI_INQUIRY_CMD Cmd;
872 PPDO_DEVICE_EXTENSION PDODeviceExtension;
873 PIO_STACK_LOCATION IoStack;
874 PSCSI_REQUEST_BLOCK Request;
875
876 //
877 // get current stack location
878 //
879 IoStack = IoGetCurrentIrpStackLocation(Irp);
880
881 //
882 // get request block
883 //
884 Request = (PSCSI_REQUEST_BLOCK)IoStack->Parameters.Others.Argument1;
885
886 //
887 // get PDO device extension
888 //
889 PDODeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
890
891 //
892 // initialize inquiry cmd
893 //
894 RtlZeroMemory(&Cmd, sizeof(UFI_INQUIRY_CMD));
895 Cmd.Code = SCSIOP_INQUIRY;
896 Cmd.LUN = (PDODeviceExtension->LUN & MAX_LUN);
897 Cmd.AllocationLength = sizeof(UFI_INQUIRY_RESPONSE);
898
899 //
900 // sanity check
901 //
902 ASSERT(Request->DataTransferLength >= sizeof(UFI_INQUIRY_RESPONSE));
903
904 //
905 // now send the request
906 //
907 return USBSTOR_SendRequest(DeviceObject, Irp, UFI_INQUIRY_CMD_LEN, (PUCHAR)&Cmd, Request->DataTransferLength, (PUCHAR)Request->DataBuffer, RetryCount);
908 }
909
910 NTSTATUS
911 USBSTOR_SendCapacity(
912 IN PDEVICE_OBJECT DeviceObject,
913 IN PIRP Irp,
914 IN ULONG RetryCount)
915 {
916 UFI_CAPACITY_CMD Cmd;
917 PUFI_CAPACITY_RESPONSE Response;
918 PPDO_DEVICE_EXTENSION PDODeviceExtension;
919
920 //
921 // get PDO device extension
922 //
923 PDODeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
924
925 //
926 // allocate capacity response
927 //
928 Response = (PUFI_CAPACITY_RESPONSE)AllocateItem(NonPagedPool, PAGE_SIZE);
929 if (!Response)
930 {
931 //
932 // no memory
933 //
934 return STATUS_INSUFFICIENT_RESOURCES;
935 }
936
937 //
938 // initialize capacity cmd
939 //
940 RtlZeroMemory(&Cmd, sizeof(UFI_INQUIRY_CMD));
941 Cmd.Code = SCSIOP_READ_CAPACITY;
942 Cmd.LUN = (PDODeviceExtension->LUN & MAX_LUN);
943
944 //
945 // send request, response will be freed in completion routine
946 //
947 return USBSTOR_SendRequest(DeviceObject, Irp, UFI_READ_CAPACITY_CMD_LEN, (PUCHAR)&Cmd, sizeof(UFI_CAPACITY_RESPONSE), (PUCHAR)Response, RetryCount);
948 }
949
950 NTSTATUS
951 USBSTOR_SendModeSense(
952 IN PDEVICE_OBJECT DeviceObject,
953 IN PIRP Irp,
954 IN ULONG RetryCount)
955 {
956 #if 0
957 UFI_SENSE_CMD Cmd;
958 NTSTATUS Status;
959 PVOID Response;
960 PCBW OutControl;
961 PCDB pCDB;
962 PUFI_MODE_PARAMETER_HEADER Header;
963 #endif
964 PPDO_DEVICE_EXTENSION PDODeviceExtension;
965 PIO_STACK_LOCATION IoStack;
966 PSCSI_REQUEST_BLOCK Request;
967
968 //
969 // get PDO device extension
970 //
971 PDODeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
972
973 //
974 // sanity check
975 //
976 ASSERT(PDODeviceExtension->Common.IsFDO == FALSE);
977
978 //
979 // get current stack location
980 //
981 IoStack = IoGetCurrentIrpStackLocation(Irp);
982
983 //
984 // get request block
985 //
986 Request = (PSCSI_REQUEST_BLOCK)IoStack->Parameters.Others.Argument1;
987
988 RtlZeroMemory(Request->DataBuffer, Request->DataTransferLength);
989 Request->SrbStatus = SRB_STATUS_SUCCESS;
990 Irp->IoStatus.Information = Request->DataTransferLength;
991 Irp->IoStatus.Status = STATUS_SUCCESS;
992 USBSTOR_QueueTerminateRequest(PDODeviceExtension->LowerDeviceObject, Irp);
993 IoCompleteRequest(Irp, IO_NO_INCREMENT);
994
995 //
996 // start next request
997 //
998 USBSTOR_QueueNextRequest(PDODeviceExtension->LowerDeviceObject);
999
1000 return STATUS_SUCCESS;
1001
1002 #if 0
1003 //
1004 // get SCSI command data block
1005 //
1006 pCDB = (PCDB)Request->Cdb;
1007
1008 //
1009 // get PDO device extension
1010 //
1011 PDODeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
1012
1013 //
1014 // allocate sense response from non paged pool
1015 //
1016 Response = (PUFI_CAPACITY_RESPONSE)AllocateItem(NonPagedPool, Request->DataTransferLength);
1017 if (!Response)
1018 {
1019 //
1020 // no memory
1021 //
1022 return STATUS_INSUFFICIENT_RESOURCES;
1023 }
1024
1025 //
1026 // sanity check
1027 //
1028
1029
1030 // Supported pages
1031 // MODE_PAGE_ERROR_RECOVERY
1032 // MODE_PAGE_FLEXIBILE
1033 // MODE_PAGE_LUN_MAPPING
1034 // MODE_PAGE_FAULT_REPORTING
1035 // MODE_SENSE_RETURN_ALL
1036
1037 //
1038 // initialize mode sense cmd
1039 //
1040 RtlZeroMemory(&Cmd, sizeof(UFI_INQUIRY_CMD));
1041 Cmd.Code = SCSIOP_MODE_SENSE;
1042 Cmd.LUN = (PDODeviceExtension->LUN & MAX_LUN);
1043 Cmd.PageCode = pCDB->MODE_SENSE.PageCode;
1044 Cmd.PC = pCDB->MODE_SENSE.Pc;
1045 Cmd.AllocationLength = HTONS(pCDB->MODE_SENSE.AllocationLength);
1046
1047 DPRINT1("PageCode %x\n", pCDB->MODE_SENSE.PageCode);
1048 DPRINT1("PC %x\n", pCDB->MODE_SENSE.Pc);
1049
1050 //
1051 // now send mode sense cmd
1052 //
1053 Status = USBSTOR_SendCBW(DeviceObject, UFI_SENSE_CMD_LEN, (PUCHAR)&Cmd, Request->DataTransferLength, &OutControl);
1054 if (!NT_SUCCESS(Status))
1055 {
1056 //
1057 // failed to send CBW
1058 //
1059 DPRINT1("USBSTOR_SendCapacityCmd> USBSTOR_SendCBW failed with %x\n", Status);
1060 FreeItem(Response);
1061 ASSERT(FALSE);
1062 return Status;
1063 }
1064
1065 //
1066 // now send data block response
1067 //
1068 Status = USBSTOR_SendData(DeviceObject, Request->DataTransferLength, Response);
1069 if (!NT_SUCCESS(Status))
1070 {
1071 //
1072 // failed to send CBW
1073 //
1074 DPRINT1("USBSTOR_SendCapacityCmd> USBSTOR_SendData failed with %x\n", Status);
1075 FreeItem(Response);
1076 ASSERT(FALSE);
1077 return Status;
1078 }
1079
1080 Header = (PUFI_MODE_PARAMETER_HEADER)Response;
1081
1082 //
1083 // TODO: build layout
1084 //
1085 // first struct is the header
1086 // MODE_PARAMETER_HEADER / _MODE_PARAMETER_HEADER10
1087 //
1088 // followed by
1089 // MODE_PARAMETER_BLOCK
1090 //
1091 //
1092 UNIMPLEMENTED;
1093
1094 //
1095 // send csw
1096 //
1097 Status = USBSTOR_SendCSW(DeviceObject, OutControl, 512, &CSW);
1098
1099 DPRINT1("------------------------\n");
1100 DPRINT1("CSW %p\n", &CSW);
1101 DPRINT1("Signature %x\n", CSW.Signature);
1102 DPRINT1("Tag %x\n", CSW.Tag);
1103 DPRINT1("DataResidue %x\n", CSW.DataResidue);
1104 DPRINT1("Status %x\n", CSW.Status);
1105
1106 //
1107 // FIXME: handle error
1108 //
1109 ASSERT(CSW.Status == 0);
1110 ASSERT(CSW.DataResidue == 0);
1111
1112 //
1113 // calculate transfer length
1114 //
1115 *TransferBufferLength = Request->DataTransferLength - CSW.DataResidue;
1116
1117 //
1118 // copy buffer
1119 //
1120 RtlCopyMemory(Request->DataBuffer, Response, *TransferBufferLength);
1121
1122 //
1123 // free item
1124 //
1125 FreeItem(OutControl);
1126
1127 //
1128 // free response
1129 //
1130 FreeItem(Response);
1131
1132 //
1133 // done
1134 //
1135 return Status;
1136 #endif
1137 }
1138
1139 NTSTATUS
1140 USBSTOR_SendReadWrite(
1141 IN PDEVICE_OBJECT DeviceObject,
1142 IN PIRP Irp,
1143 IN ULONG RetryCount)
1144 {
1145 UFI_READ_WRITE_CMD Cmd;
1146 PPDO_DEVICE_EXTENSION PDODeviceExtension;
1147 PCDB pCDB;
1148 ULONG BlockCount, Temp;
1149 PIO_STACK_LOCATION IoStack;
1150 PSCSI_REQUEST_BLOCK Request;
1151
1152 //
1153 // get current stack location
1154 //
1155 IoStack = IoGetCurrentIrpStackLocation(Irp);
1156
1157 //
1158 // get request block
1159 //
1160 Request = (PSCSI_REQUEST_BLOCK)IoStack->Parameters.Others.Argument1;
1161
1162 //
1163 // get SCSI command data block
1164 //
1165 pCDB = (PCDB)Request->Cdb;
1166
1167 //
1168 // get PDO device extension
1169 //
1170 PDODeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
1171
1172 //
1173 // informal debug print
1174 //
1175 DPRINT("USBSTOR_SendReadWrite DataTransferLength %lu, BlockLength %lu\n", Request->DataTransferLength, PDODeviceExtension->BlockLength);
1176
1177 //
1178 // sanity check
1179 //
1180 ASSERT(PDODeviceExtension->BlockLength);
1181
1182 //
1183 // block count
1184 //
1185 BlockCount = Request->DataTransferLength / PDODeviceExtension->BlockLength;
1186
1187 //
1188 // initialize read cmd
1189 //
1190 RtlZeroMemory(&Cmd, sizeof(UFI_READ_WRITE_CMD));
1191 Cmd.Code = pCDB->AsByte[0];
1192 Cmd.LUN = (PDODeviceExtension->LUN & MAX_LUN);
1193 Cmd.ContiguousLogicBlocksByte0 = pCDB->CDB10.TransferBlocksMsb;
1194 Cmd.ContiguousLogicBlocksByte1 = pCDB->CDB10.TransferBlocksLsb;
1195 Cmd.LogicalBlockByte0 = pCDB->CDB10.LogicalBlockByte0;
1196 Cmd.LogicalBlockByte1 = pCDB->CDB10.LogicalBlockByte1;
1197 Cmd.LogicalBlockByte2 = pCDB->CDB10.LogicalBlockByte2;
1198 Cmd.LogicalBlockByte3 = pCDB->CDB10.LogicalBlockByte3;
1199
1200 //
1201 // sanity check
1202 //
1203 Temp = (Cmd.ContiguousLogicBlocksByte0 << 8 | Cmd.ContiguousLogicBlocksByte1);
1204 ASSERT(Temp == BlockCount);
1205
1206 DPRINT("USBSTOR_SendReadWrite BlockAddress %x%x%x%x BlockCount %lu BlockLength %lu\n", Cmd.LogicalBlockByte0, Cmd.LogicalBlockByte1, Cmd.LogicalBlockByte2, Cmd.LogicalBlockByte3, BlockCount, PDODeviceExtension->BlockLength);
1207
1208 //
1209 // send request
1210 //
1211 return USBSTOR_SendRequest(DeviceObject, Irp, UFI_READ_WRITE_CMD_LEN, (PUCHAR)&Cmd, Request->DataTransferLength, (PUCHAR)Request->DataBuffer, RetryCount);
1212 }
1213
1214 NTSTATUS
1215 USBSTOR_SendTestUnit(
1216 IN PDEVICE_OBJECT DeviceObject,
1217 IN OUT PIRP Irp,
1218 IN ULONG RetryCount)
1219 {
1220 UFI_TEST_UNIT_CMD Cmd;
1221 PPDO_DEVICE_EXTENSION PDODeviceExtension;
1222 PIO_STACK_LOCATION IoStack;
1223 PSCSI_REQUEST_BLOCK Request;
1224
1225 //
1226 // get current stack location
1227 //
1228 IoStack = IoGetCurrentIrpStackLocation(Irp);
1229
1230 //
1231 // get request block
1232 //
1233 Request = (PSCSI_REQUEST_BLOCK)IoStack->Parameters.Others.Argument1;
1234
1235 //
1236 // no transfer length
1237 //
1238 ASSERT(Request->DataTransferLength == 0);
1239
1240 //
1241 // get PDO device extension
1242 //
1243 PDODeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
1244
1245 //
1246 // initialize test unit cmd
1247 //
1248 RtlZeroMemory(&Cmd, sizeof(UFI_TEST_UNIT_CMD));
1249 Cmd.Code = SCSIOP_TEST_UNIT_READY;
1250 Cmd.LUN = (PDODeviceExtension->LUN & MAX_LUN);
1251
1252 //
1253 // send the request
1254 //
1255 return USBSTOR_SendRequest(DeviceObject, Irp, UFI_TEST_UNIT_CMD_LEN, (PUCHAR)&Cmd, 0, NULL, RetryCount);
1256 }
1257
1258 NTSTATUS
1259 USBSTOR_SendUnknownRequest(
1260 IN PDEVICE_OBJECT DeviceObject,
1261 IN OUT PIRP Irp,
1262 IN ULONG RetryCount)
1263 {
1264 PPDO_DEVICE_EXTENSION PDODeviceExtension;
1265 PIO_STACK_LOCATION IoStack;
1266 PSCSI_REQUEST_BLOCK Request;
1267 UFI_UNKNOWN_CMD Cmd;
1268
1269 //
1270 // get current stack location
1271 //
1272 IoStack = IoGetCurrentIrpStackLocation(Irp);
1273
1274 //
1275 // get request block
1276 //
1277 Request = IoStack->Parameters.Others.Argument1;
1278
1279 //
1280 // get PDO device extension
1281 //
1282 PDODeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
1283
1284 //
1285 // check that we're sending to the right LUN
1286 //
1287 ASSERT(Request->Cdb[1] == (PDODeviceExtension->LUN & MAX_LUN));
1288
1289 //
1290 // sanity check
1291 //
1292 ASSERT(Request->CdbLength <= sizeof(UFI_UNKNOWN_CMD));
1293
1294 //
1295 // initialize test unit cmd
1296 //
1297 RtlCopyMemory(&Cmd, Request->Cdb, Request->CdbLength);
1298
1299 //
1300 // send the request
1301 //
1302 return USBSTOR_SendRequest(DeviceObject, Irp, Request->CdbLength, (PUCHAR)&Cmd, Request->DataTransferLength, Request->DataBuffer, RetryCount);
1303 }
1304
1305 NTSTATUS
1306 USBSTOR_HandleExecuteSCSI(
1307 IN PDEVICE_OBJECT DeviceObject,
1308 IN PIRP Irp,
1309 IN ULONG RetryCount)
1310 {
1311 PCDB pCDB;
1312 NTSTATUS Status;
1313 PIO_STACK_LOCATION IoStack;
1314 PSCSI_REQUEST_BLOCK Request;
1315 PPDO_DEVICE_EXTENSION PDODeviceExtension;
1316
1317 //
1318 // get PDO device extension
1319 //
1320 PDODeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
1321
1322 //
1323 // sanity check
1324 //
1325 ASSERT(PDODeviceExtension->Common.IsFDO == FALSE);
1326
1327 //
1328 // get current stack location
1329 //
1330 IoStack = IoGetCurrentIrpStackLocation(Irp);
1331
1332 //
1333 // get request block
1334 //
1335 Request = (PSCSI_REQUEST_BLOCK)IoStack->Parameters.Others.Argument1;
1336
1337 //
1338 // get SCSI command data block
1339 //
1340 pCDB = (PCDB)Request->Cdb;
1341
1342 DPRINT("USBSTOR_HandleExecuteSCSI Operation Code %x\n", pCDB->AsByte[0]);
1343
1344 if (pCDB->AsByte[0] == SCSIOP_READ_CAPACITY)
1345 {
1346 //
1347 // sanity checks
1348 //
1349 ASSERT(Request->DataBuffer);
1350
1351 DPRINT("SCSIOP_READ_CAPACITY Length %lu\n", Request->DataTransferLength);
1352 Status = USBSTOR_SendCapacity(DeviceObject, Irp, RetryCount);
1353 }
1354 else if (pCDB->MODE_SENSE.OperationCode == SCSIOP_MODE_SENSE)
1355 {
1356 DPRINT("SCSIOP_MODE_SENSE DataTransferLength %lu\n", Request->DataTransferLength);
1357 ASSERT(pCDB->MODE_SENSE.AllocationLength == Request->DataTransferLength);
1358 ASSERT(Request->DataBuffer);
1359
1360 //
1361 // send mode sense command
1362 //
1363 Status = USBSTOR_SendModeSense(DeviceObject, Irp, RetryCount);
1364 }
1365 else if (pCDB->AsByte[0] == SCSIOP_READ_FORMATTED_CAPACITY)
1366 {
1367 DPRINT("SCSIOP_READ_FORMATTED_CAPACITY DataTransferLength %lu\n", Request->DataTransferLength);
1368
1369 //
1370 // send read format capacity
1371 //
1372 Status = USBSTOR_SendFormatCapacity(DeviceObject, Irp, RetryCount);
1373 }
1374 else if (pCDB->AsByte[0] == SCSIOP_INQUIRY)
1375 {
1376 DPRINT("SCSIOP_INQUIRY DataTransferLength %lu\n", Request->DataTransferLength);
1377
1378 //
1379 // send read format capacity
1380 //
1381 Status = USBSTOR_SendInquiry(DeviceObject, Irp, RetryCount);
1382 }
1383 else if (pCDB->MODE_SENSE.OperationCode == SCSIOP_READ || pCDB->MODE_SENSE.OperationCode == SCSIOP_WRITE)
1384 {
1385 DPRINT("SCSIOP_READ / SCSIOP_WRITE DataTransferLength %lu\n", Request->DataTransferLength);
1386
1387 //
1388 // send read / write command
1389 //
1390 Status = USBSTOR_SendReadWrite(DeviceObject, Irp, RetryCount);
1391 }
1392 else if (pCDB->AsByte[0] == SCSIOP_MEDIUM_REMOVAL)
1393 {
1394 DPRINT("SCSIOP_MEDIUM_REMOVAL\n");
1395
1396 //
1397 // just complete the request
1398 //
1399 Request->SrbStatus = SRB_STATUS_SUCCESS;
1400 Irp->IoStatus.Status = STATUS_SUCCESS;
1401 Irp->IoStatus.Information = Request->DataTransferLength;
1402 USBSTOR_QueueTerminateRequest(PDODeviceExtension->LowerDeviceObject, Irp);
1403 IoCompleteRequest(Irp, IO_NO_INCREMENT);
1404
1405 //
1406 // start next request
1407 //
1408 USBSTOR_QueueNextRequest(PDODeviceExtension->LowerDeviceObject);
1409
1410 return STATUS_SUCCESS;
1411 }
1412 else if (pCDB->MODE_SENSE.OperationCode == SCSIOP_TEST_UNIT_READY)
1413 {
1414 DPRINT("SCSIOP_TEST_UNIT_READY\n");
1415
1416 //
1417 // send test unit command
1418 //
1419 Status = USBSTOR_SendTestUnit(DeviceObject, Irp, RetryCount);
1420 }
1421 else
1422 {
1423 // Unknown request. Simply forward
1424 DPRINT1("Forwarding unknown Operation Code %x\n", pCDB->AsByte[0]);
1425 Status = USBSTOR_SendUnknownRequest(DeviceObject, Irp, RetryCount);
1426 }
1427
1428 return Status;
1429 }