2 Implementation of the command set of USB Mass Storage Specification
3 for Bootability, Revision 1.0.
5 Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
19 Execute REQUEST SENSE Command to retrieve sense data from device.
21 @param UsbMass The device whose sense data is requested.
23 @retval EFI_SUCCESS The command is excuted successfully.
24 @retval EFI_DEVICE_ERROR Failed to request sense.
25 @retval EFI_NO_RESPONSE The device media doesn't response this request.
26 @retval EFI_INVALID_PARAMETER The command has some invalid parameters.
27 @retval EFI_WRITE_PROTECTED The device is write protected.
28 @retval EFI_MEDIA_CHANGED The device media has been changed.
33 IN USB_MASS_DEVICE
*UsbMass
36 USB_BOOT_REQUEST_SENSE_CMD SenseCmd
;
37 USB_BOOT_REQUEST_SENSE_DATA SenseData
;
38 EFI_BLOCK_IO_MEDIA
*Media
;
39 USB_MASS_TRANSPORT
*Transport
;
43 Transport
= UsbMass
->Transport
;
46 // Request the sense data from the device
48 ZeroMem (&SenseCmd
, sizeof (USB_BOOT_REQUEST_SENSE_CMD
));
49 ZeroMem (&SenseData
, sizeof (USB_BOOT_REQUEST_SENSE_DATA
));
51 SenseCmd
.OpCode
= USB_BOOT_REQUEST_SENSE_OPCODE
;
52 SenseCmd
.Lun
= (UINT8
) (USB_BOOT_LUN (UsbMass
->Lun
));
53 SenseCmd
.AllocLen
= (UINT8
) sizeof (USB_BOOT_REQUEST_SENSE_DATA
);
55 Status
= Transport
->ExecCommand (
58 sizeof (USB_BOOT_REQUEST_SENSE_CMD
),
61 sizeof (USB_BOOT_REQUEST_SENSE_DATA
),
63 USB_BOOT_GENERAL_CMD_TIMEOUT
,
66 if (EFI_ERROR (Status
) || CmdResult
!= USB_MASS_CMD_SUCCESS
) {
67 DEBUG ((EFI_D_ERROR
, "UsbBootRequestSense: (%r) CmdResult=0x%x\n", Status
, CmdResult
));
68 if (!EFI_ERROR (Status
)) {
69 Status
= EFI_DEVICE_ERROR
;
75 // If sense data is retrieved successfully, interpret the sense data
76 // and update the media status if necessary.
78 Media
= &UsbMass
->BlockIoMedia
;
80 switch (USB_BOOT_SENSE_KEY (SenseData
.SenseKey
)) {
82 case USB_BOOT_SENSE_NO_SENSE
:
83 Status
= EFI_NO_RESPONSE
;
86 case USB_BOOT_SENSE_RECOVERED
:
88 // Suppose hardware can handle this case, and recover later by itself
90 Status
= EFI_NOT_READY
;
93 case USB_BOOT_SENSE_NOT_READY
:
94 Status
= EFI_DEVICE_ERROR
;
95 if (SenseData
.Asc
== USB_BOOT_ASC_NO_MEDIA
) {
96 Media
->MediaPresent
= FALSE
;
97 Status
= EFI_NO_MEDIA
;
98 } else if (SenseData
.Asc
== USB_BOOT_ASC_NOT_READY
) {
99 Status
= EFI_NOT_READY
;
103 case USB_BOOT_SENSE_ILLEGAL_REQUEST
:
104 Status
= EFI_INVALID_PARAMETER
;
107 case USB_BOOT_SENSE_UNIT_ATTENTION
:
108 Status
= EFI_DEVICE_ERROR
;
109 if (SenseData
.Asc
== USB_BOOT_ASC_MEDIA_CHANGE
) {
111 // If MediaChange, reset ReadOnly and new MediaId
113 Status
= EFI_MEDIA_CHANGED
;
114 Media
->ReadOnly
= FALSE
;
119 case USB_BOOT_SENSE_DATA_PROTECT
:
120 Status
= EFI_WRITE_PROTECTED
;
121 Media
->ReadOnly
= TRUE
;
125 Status
= EFI_DEVICE_ERROR
;
129 DEBUG ((EFI_D_INFO
, "UsbBootRequestSense: (%r) with sense key %x/%x/%x\n",
131 USB_BOOT_SENSE_KEY (SenseData
.SenseKey
),
141 Execute the USB mass storage bootability commands.
143 This function executes the USB mass storage bootability commands.
144 If execution failed, retrieve the error by REQUEST_SENSE, then
145 update the device's status, such as ReadyOnly.
147 @param UsbMass The device to issue commands to
148 @param Cmd The command to execute
149 @param CmdLen The length of the command
150 @param DataDir The direction of data transfer
151 @param Data The buffer to hold the data
152 @param DataLen The length of expected data
153 @param Timeout The timeout used to transfer
155 @retval EFI_SUCCESS Command is excuted successfully
156 @retval Others Command execution failed.
161 IN USB_MASS_DEVICE
*UsbMass
,
164 IN EFI_USB_DATA_DIRECTION DataDir
,
170 USB_MASS_TRANSPORT
*Transport
;
174 Transport
= UsbMass
->Transport
;
175 Status
= Transport
->ExecCommand (
187 if (Status
== EFI_TIMEOUT
) {
188 DEBUG ((EFI_D_ERROR
, "UsbBootExecCmd: Timeout to Exec 0x%x Cmd\n", *(UINT8
*)Cmd
));
193 // If ExecCommand() returns no error and CmdResult is success,
194 // then the commnad transfer is successful.
196 if ((CmdResult
== USB_MASS_CMD_SUCCESS
) && !EFI_ERROR (Status
)) {
201 // If command execution failed, then retrieve error info via sense request.
203 return UsbBootRequestSense (UsbMass
);
208 Execute the USB mass storage bootability commands with retrial.
210 This function executes USB mass storage bootability commands.
211 If the device isn't ready, wait for it. If the device is ready
212 and error occurs, retry the command again until it exceeds the
213 limit of retrial times.
215 @param UsbMass The device to issue commands to
216 @param Cmd The command to execute
217 @param CmdLen The length of the command
218 @param DataDir The direction of data transfer
219 @param Data The buffer to hold the data
220 @param DataLen The length of expected data
221 @param Timeout The timeout used to transfer
223 @retval EFI_SUCCESS The command is executed successfully.
224 @retval EFI_MEDIA_CHANGED The device media has been changed.
225 @retval Others Command execution failed after retrial.
229 UsbBootExecCmdWithRetry (
230 IN USB_MASS_DEVICE
*UsbMass
,
233 IN EFI_USB_DATA_DIRECTION DataDir
,
241 EFI_EVENT TimeoutEvt
;
244 Status
= EFI_SUCCESS
;
245 Status
= gBS
->CreateEvent (
252 if (EFI_ERROR (Status
)) {
256 Status
= gBS
->SetTimer (TimeoutEvt
, TimerRelative
, EFI_TIMER_PERIOD_SECONDS(60));
257 if (EFI_ERROR (Status
)) {
262 // Execute the cmd and retry if it fails.
264 while (EFI_ERROR (gBS
->CheckEvent (TimeoutEvt
))) {
265 Status
= UsbBootExecCmd (
274 if (Status
== EFI_SUCCESS
|| Status
== EFI_MEDIA_CHANGED
|| Status
== EFI_NO_MEDIA
) {
278 // If the sense data shows the drive is not ready, we need execute the cmd again.
279 // We limit the upper boundary to 60 seconds.
281 if (Status
== EFI_NOT_READY
) {
285 // If the status is other error, then just retry 5 times.
287 if (Retry
++ >= USB_BOOT_COMMAND_RETRY
) {
293 if (TimeoutEvt
!= NULL
) {
294 gBS
->CloseEvent (TimeoutEvt
);
302 Execute TEST UNIT READY command to check if the device is ready.
304 @param UsbMass The device to test
306 @retval EFI_SUCCESS The device is ready.
307 @retval Others Device not ready.
312 IN USB_MASS_DEVICE
*UsbMass
315 USB_BOOT_TEST_UNIT_READY_CMD TestCmd
;
317 ZeroMem (&TestCmd
, sizeof (USB_BOOT_TEST_UNIT_READY_CMD
));
319 TestCmd
.OpCode
= USB_BOOT_TEST_UNIT_READY_OPCODE
;
320 TestCmd
.Lun
= (UINT8
) (USB_BOOT_LUN (UsbMass
->Lun
));
322 return UsbBootExecCmdWithRetry (
325 (UINT8
) sizeof (USB_BOOT_TEST_UNIT_READY_CMD
),
329 USB_BOOT_GENERAL_CMD_TIMEOUT
335 Execute INQUIRY Command to request information regarding parameters of
336 the device be sent to the host computer.
338 @param UsbMass The device to inquire.
340 @retval EFI_SUCCESS INQUIRY Command is executed successfully.
341 @retval Others INQUIRY Command is not executed successfully.
346 IN USB_MASS_DEVICE
*UsbMass
349 USB_BOOT_INQUIRY_CMD InquiryCmd
;
350 EFI_BLOCK_IO_MEDIA
*Media
;
353 Media
= &(UsbMass
->BlockIoMedia
);
355 ZeroMem (&InquiryCmd
, sizeof (USB_BOOT_INQUIRY_CMD
));
356 ZeroMem (&UsbMass
->InquiryData
, sizeof (USB_BOOT_INQUIRY_DATA
));
358 InquiryCmd
.OpCode
= USB_BOOT_INQUIRY_OPCODE
;
359 InquiryCmd
.Lun
= (UINT8
) (USB_BOOT_LUN (UsbMass
->Lun
));
360 InquiryCmd
.AllocLen
= (UINT8
) sizeof (USB_BOOT_INQUIRY_DATA
);
362 Status
= UsbBootExecCmdWithRetry (
365 (UINT8
) sizeof (USB_BOOT_INQUIRY_CMD
),
367 &UsbMass
->InquiryData
,
368 sizeof (USB_BOOT_INQUIRY_DATA
),
369 USB_BOOT_GENERAL_CMD_TIMEOUT
371 if (EFI_ERROR (Status
)) {
376 // Get information from PDT (Peripheral Device Type) field and Removable Medium Bit
377 // from the inquiry data.
379 UsbMass
->Pdt
= (UINT8
) (USB_BOOT_PDT (UsbMass
->InquiryData
.Pdt
));
380 Media
->RemovableMedia
= (BOOLEAN
) (USB_BOOT_REMOVABLE (UsbMass
->InquiryData
.Removable
));
382 // Set block size to the default value of 512 Bytes, in case no media is present at first time.
384 Media
->BlockSize
= 0x0200;
390 Execute READ CAPACITY 16 bytes command to request information regarding
391 the capacity of the installed medium of the device.
393 This function executes READ CAPACITY 16 bytes command to get the capacity
394 of the USB mass storage media, including the presence, block size,
395 and last block number.
397 @param UsbMass The device to retireve disk gemotric.
399 @retval EFI_SUCCESS The disk geometry is successfully retrieved.
400 @retval EFI_NOT_READY The returned block size is zero.
401 @retval Other READ CAPACITY 16 bytes command execution failed.
405 UsbBootReadCapacity16 (
406 IN USB_MASS_DEVICE
*UsbMass
409 UINT8 CapacityCmd
[16];
410 EFI_SCSI_DISK_CAPACITY_DATA16 CapacityData
;
411 EFI_BLOCK_IO_MEDIA
*Media
;
415 Media
= &UsbMass
->BlockIoMedia
;
417 Media
->MediaPresent
= FALSE
;
418 Media
->LastBlock
= 0;
419 Media
->BlockSize
= 0;
421 ZeroMem (CapacityCmd
, sizeof (CapacityCmd
));
422 ZeroMem (&CapacityData
, sizeof (CapacityData
));
424 CapacityCmd
[0] = EFI_SCSI_OP_READ_CAPACITY16
;
425 CapacityCmd
[1] = 0x10;
427 // Partial medium indicator, set the bytes 2 ~ 9 of the Cdb as ZERO.
429 ZeroMem ((CapacityCmd
+ 2), 8);
431 CapacityCmd
[13] = sizeof (CapacityData
);
433 Status
= UsbBootExecCmdWithRetry (
436 (UINT8
) sizeof (CapacityCmd
),
439 sizeof (CapacityData
),
440 USB_BOOT_GENERAL_CMD_TIMEOUT
442 if (EFI_ERROR (Status
)) {
447 // Get the information on media presence, block size, and last block number
448 // from READ CAPACITY data.
450 Media
->MediaPresent
= TRUE
;
451 Media
->LastBlock
= SwapBytes64 (ReadUnaligned64 ((CONST UINT64
*) &(CapacityData
.LastLba7
)));
453 BlockSize
= SwapBytes32 (ReadUnaligned32 ((CONST UINT32
*) &(CapacityData
.BlockSize3
)));
455 Media
->LowestAlignedLba
= (CapacityData
.LowestAlignLogic2
<< 8) |
456 CapacityData
.LowestAlignLogic1
;
457 Media
->LogicalBlocksPerPhysicalBlock
= (1 << CapacityData
.LogicPerPhysical
);
458 if (BlockSize
== 0) {
462 return UsbBootRequestSense (UsbMass
);
464 Media
->BlockSize
= BlockSize
;
472 Execute READ CAPACITY command to request information regarding
473 the capacity of the installed medium of the device.
475 This function executes READ CAPACITY command to get the capacity
476 of the USB mass storage media, including the presence, block size,
477 and last block number.
479 @param UsbMass The device to retireve disk gemotric.
481 @retval EFI_SUCCESS The disk geometry is successfully retrieved.
482 @retval EFI_NOT_READY The returned block size is zero.
483 @retval Other READ CAPACITY command execution failed.
487 UsbBootReadCapacity (
488 IN USB_MASS_DEVICE
*UsbMass
491 USB_BOOT_READ_CAPACITY_CMD CapacityCmd
;
492 USB_BOOT_READ_CAPACITY_DATA CapacityData
;
493 EFI_BLOCK_IO_MEDIA
*Media
;
497 Media
= &UsbMass
->BlockIoMedia
;
499 ZeroMem (&CapacityCmd
, sizeof (USB_BOOT_READ_CAPACITY_CMD
));
500 ZeroMem (&CapacityData
, sizeof (USB_BOOT_READ_CAPACITY_DATA
));
502 CapacityCmd
.OpCode
= USB_BOOT_READ_CAPACITY_OPCODE
;
503 CapacityCmd
.Lun
= (UINT8
) (USB_BOOT_LUN (UsbMass
->Lun
));
505 Status
= UsbBootExecCmdWithRetry (
508 (UINT8
) sizeof (USB_BOOT_READ_CAPACITY_CMD
),
511 sizeof (USB_BOOT_READ_CAPACITY_DATA
),
512 USB_BOOT_GENERAL_CMD_TIMEOUT
514 if (EFI_ERROR (Status
)) {
519 // Get the information on media presence, block size, and last block number
520 // from READ CAPACITY data.
522 Media
->MediaPresent
= TRUE
;
523 Media
->LastBlock
= SwapBytes32 (ReadUnaligned32 ((CONST UINT32
*) CapacityData
.LastLba
));
525 BlockSize
= SwapBytes32 (ReadUnaligned32 ((CONST UINT32
*) CapacityData
.BlockLen
));
526 if (BlockSize
== 0) {
530 return UsbBootRequestSense (UsbMass
);
532 Media
->BlockSize
= BlockSize
;
535 if (Media
->LastBlock
== 0xFFFFFFFF) {
536 Status
= UsbBootReadCapacity16 (UsbMass
);
537 if (!EFI_ERROR (Status
)) {
538 UsbMass
->Cdb16Byte
= TRUE
;
546 Retrieves SCSI mode sense information via MODE SENSE(6) command.
548 @param UsbMass The device whose sense data is requested.
550 @retval EFI_SUCCESS SCSI mode sense information retrieved successfully.
551 @retval Other Command execution failed.
556 IN USB_MASS_DEVICE
*UsbMass
560 USB_SCSI_MODE_SENSE6_CMD ModeSenseCmd
;
561 USB_SCSI_MODE_SENSE6_PARA_HEADER ModeParaHeader
;
562 EFI_BLOCK_IO_MEDIA
*Media
;
564 Media
= &UsbMass
->BlockIoMedia
;
566 ZeroMem (&ModeSenseCmd
, sizeof (USB_SCSI_MODE_SENSE6_CMD
));
567 ZeroMem (&ModeParaHeader
, sizeof (USB_SCSI_MODE_SENSE6_PARA_HEADER
));
570 // MODE SENSE(6) command is defined in Section 8.2.10 of SCSI-2 Spec
572 ModeSenseCmd
.OpCode
= USB_SCSI_MODE_SENSE6_OPCODE
;
573 ModeSenseCmd
.Lun
= (UINT8
) USB_BOOT_LUN (UsbMass
->Lun
);
574 ModeSenseCmd
.PageCode
= 0x3F;
575 ModeSenseCmd
.AllocateLen
= (UINT8
) sizeof (USB_SCSI_MODE_SENSE6_PARA_HEADER
);
577 Status
= UsbBootExecCmdWithRetry (
580 (UINT8
) sizeof (USB_SCSI_MODE_SENSE6_CMD
),
583 sizeof (USB_SCSI_MODE_SENSE6_PARA_HEADER
),
584 USB_BOOT_GENERAL_CMD_TIMEOUT
588 // Format of device-specific parameter byte of the mode parameter header is defined in
589 // Section 8.2.10 of SCSI-2 Spec.
590 // BIT7 of this byte is indicates whether the medium is write protected.
592 if (!EFI_ERROR (Status
)) {
593 Media
->ReadOnly
= (BOOLEAN
) ((ModeParaHeader
.DevicePara
& BIT7
) != 0);
601 Get the parameters for the USB mass storage media.
603 This function get the parameters for the USB mass storage media,
604 It is used both to initialize the media during the Start() phase
605 of Driver Binding Protocol and to re-initialize it when the media is
606 changed. Althought the RemoveableMedia is unlikely to change,
607 it is also included here.
609 @param UsbMass The device to retrieve disk gemotric.
611 @retval EFI_SUCCESS The disk gemotric is successfully retrieved.
612 @retval Other Failed to get the parameters.
617 IN USB_MASS_DEVICE
*UsbMass
620 EFI_BLOCK_IO_MEDIA
*Media
;
623 Media
= &(UsbMass
->BlockIoMedia
);
625 Status
= UsbBootInquiry (UsbMass
);
626 if (EFI_ERROR (Status
)) {
627 DEBUG ((EFI_D_ERROR
, "UsbBootGetParams: UsbBootInquiry (%r)\n", Status
));
632 // According to USB Mass Storage Specification for Bootability, only following
633 // 4 Peripheral Device Types are in spec.
635 if ((UsbMass
->Pdt
!= USB_PDT_DIRECT_ACCESS
) &&
636 (UsbMass
->Pdt
!= USB_PDT_CDROM
) &&
637 (UsbMass
->Pdt
!= USB_PDT_OPTICAL
) &&
638 (UsbMass
->Pdt
!= USB_PDT_SIMPLE_DIRECT
)) {
639 DEBUG ((EFI_D_ERROR
, "UsbBootGetParams: Found an unsupported peripheral type[%d]\n", UsbMass
->Pdt
));
640 return EFI_UNSUPPORTED
;
644 // Don't use the Removable bit in inquiry data to test whether the media
645 // is removable because many flash disks wrongly set this bit.
647 if ((UsbMass
->Pdt
== USB_PDT_CDROM
) || (UsbMass
->Pdt
== USB_PDT_OPTICAL
)) {
649 // CD-Rom device and Non-CD optical device
651 UsbMass
->OpticalStorage
= TRUE
;
653 // Default value 2048 Bytes, in case no media present at first time
655 Media
->BlockSize
= 0x0800;
658 Status
= UsbBootDetectMedia (UsbMass
);
665 Detect whether the removable media is present and whether it has changed.
667 @param UsbMass The device to check.
669 @retval EFI_SUCCESS The media status is successfully checked.
670 @retval Other Failed to detect media.
675 IN USB_MASS_DEVICE
*UsbMass
678 EFI_BLOCK_IO_MEDIA OldMedia
;
679 EFI_BLOCK_IO_MEDIA
*Media
;
684 Media
= &UsbMass
->BlockIoMedia
;
686 CopyMem (&OldMedia
, &(UsbMass
->BlockIoMedia
), sizeof (EFI_BLOCK_IO_MEDIA
));
688 CmdSet
= ((EFI_USB_INTERFACE_DESCRIPTOR
*) (UsbMass
->Context
))->InterfaceSubClass
;
690 Status
= UsbBootIsUnitReady (UsbMass
);
691 if (EFI_ERROR (Status
) && (Status
!= EFI_MEDIA_CHANGED
)) {
695 if ((UsbMass
->Pdt
!= USB_PDT_CDROM
) && (CmdSet
== USB_MASS_STORE_SCSI
)) {
697 // MODE SENSE is required for the device with PDT of 0x00/0x07/0x0E,
698 // according to Section 4 of USB Mass Storage Specification for Bootability.
699 // MODE SENSE(10) is useless here, while MODE SENSE(6) defined in SCSI
700 // could get the information of Write Protected.
701 // Since not all device support this command, skip if fail.
703 UsbScsiModeSense (UsbMass
);
706 Status
= UsbBootReadCapacity (UsbMass
);
707 if (EFI_ERROR (Status
)) {
708 DEBUG ((EFI_D_ERROR
, "UsbBootDetectMedia: UsbBootReadCapacity (%r)\n", Status
));
716 // Detect whether it is necessary to reinstall the Block I/O Protocol.
718 // MediaId may change in RequestSense for MediaChanged
719 // MediaPresent may change in RequestSense for NoMedia
720 // MediaReadOnly may change in RequestSense for WriteProtected or MediaChanged
721 // MediaPresent/BlockSize/LastBlock may change in ReadCapacity
723 if ((Media
->MediaId
!= OldMedia
.MediaId
) ||
724 (Media
->MediaPresent
!= OldMedia
.MediaPresent
) ||
725 (Media
->ReadOnly
!= OldMedia
.ReadOnly
) ||
726 (Media
->BlockSize
!= OldMedia
.BlockSize
) ||
727 (Media
->LastBlock
!= OldMedia
.LastBlock
)) {
730 // This function is called by Block I/O Protocol APIs, which run at TPL_NOTIFY.
731 // Here we temporarily restore TPL to TPL_CALLBACK to invoke ReinstallProtocolInterface().
733 OldTpl
= EfiGetCurrentTpl ();
734 gBS
->RestoreTPL (TPL_CALLBACK
);
736 gBS
->ReinstallProtocolInterface (
738 &gEfiBlockIoProtocolGuid
,
743 ASSERT (EfiGetCurrentTpl () == TPL_CALLBACK
);
744 gBS
->RaiseTPL (OldTpl
);
747 // Update MediaId after reinstalling Block I/O Protocol.
749 if (Media
->MediaPresent
!= OldMedia
.MediaPresent
) {
750 if (Media
->MediaPresent
) {
757 if ((Media
->ReadOnly
!= OldMedia
.ReadOnly
) ||
758 (Media
->BlockSize
!= OldMedia
.BlockSize
) ||
759 (Media
->LastBlock
!= OldMedia
.LastBlock
)) {
769 Read some blocks from the device.
771 @param UsbMass The USB mass storage device to read from
772 @param Lba The start block number
773 @param TotalBlock Total block number to read
774 @param Buffer The buffer to read to
776 @retval EFI_SUCCESS Data are read into the buffer
777 @retval Others Failed to read all the data
782 IN USB_MASS_DEVICE
*UsbMass
,
788 USB_BOOT_READ10_CMD ReadCmd
;
795 BlockSize
= UsbMass
->BlockIoMedia
.BlockSize
;
796 Status
= EFI_SUCCESS
;
798 while (TotalBlock
> 0) {
800 // Split the total blocks into smaller pieces to ease the pressure
801 // on the device. We must split the total block because the READ10
802 // command only has 16 bit transfer length (in the unit of block).
804 Count
= (UINT16
)((TotalBlock
< USB_BOOT_IO_BLOCKS
) ? TotalBlock
: USB_BOOT_IO_BLOCKS
);
805 ByteSize
= (UINT32
)Count
* BlockSize
;
808 // USB command's upper limit timeout is 5s. [USB2.0-9.2.6.1]
810 Timeout
= (UINT32
) USB_BOOT_GENERAL_CMD_TIMEOUT
;
813 // Fill in the command then execute
815 ZeroMem (&ReadCmd
, sizeof (USB_BOOT_READ10_CMD
));
817 ReadCmd
.OpCode
= USB_BOOT_READ10_OPCODE
;
818 ReadCmd
.Lun
= (UINT8
) (USB_BOOT_LUN (UsbMass
->Lun
));
819 WriteUnaligned32 ((UINT32
*) ReadCmd
.Lba
, SwapBytes32 (Lba
));
820 WriteUnaligned16 ((UINT16
*) ReadCmd
.TransferLen
, SwapBytes16 (Count
));
822 Status
= UsbBootExecCmdWithRetry (
825 (UINT8
) sizeof (USB_BOOT_READ10_CMD
),
831 if (EFI_ERROR (Status
)) {
834 DEBUG ((EFI_D_BLKIO
, "UsbBootReadBlocks: LBA (0x%x), Blk (0x%x)\n", Lba
, Count
));
836 Buffer
+= Count
* BlockSize
;
845 Write some blocks to the device.
847 @param UsbMass The USB mass storage device to write to
848 @param Lba The start block number
849 @param TotalBlock Total block number to write
850 @param Buffer Pointer to the source buffer for the data.
852 @retval EFI_SUCCESS Data are written into the buffer
853 @retval Others Failed to write all the data
858 IN USB_MASS_DEVICE
*UsbMass
,
864 USB_BOOT_WRITE10_CMD WriteCmd
;
871 BlockSize
= UsbMass
->BlockIoMedia
.BlockSize
;
872 Status
= EFI_SUCCESS
;
874 while (TotalBlock
> 0) {
876 // Split the total blocks into smaller pieces to ease the pressure
877 // on the device. We must split the total block because the WRITE10
878 // command only has 16 bit transfer length (in the unit of block).
880 Count
= (UINT16
)((TotalBlock
< USB_BOOT_IO_BLOCKS
) ? TotalBlock
: USB_BOOT_IO_BLOCKS
);
881 ByteSize
= (UINT32
)Count
* BlockSize
;
884 // USB command's upper limit timeout is 5s. [USB2.0-9.2.6.1]
886 Timeout
= (UINT32
) USB_BOOT_GENERAL_CMD_TIMEOUT
;
889 // Fill in the write10 command block
891 ZeroMem (&WriteCmd
, sizeof (USB_BOOT_WRITE10_CMD
));
893 WriteCmd
.OpCode
= USB_BOOT_WRITE10_OPCODE
;
894 WriteCmd
.Lun
= (UINT8
) (USB_BOOT_LUN (UsbMass
->Lun
));
895 WriteUnaligned32 ((UINT32
*) WriteCmd
.Lba
, SwapBytes32 (Lba
));
896 WriteUnaligned16 ((UINT16
*) WriteCmd
.TransferLen
, SwapBytes16 (Count
));
898 Status
= UsbBootExecCmdWithRetry (
901 (UINT8
) sizeof (USB_BOOT_WRITE10_CMD
),
907 if (EFI_ERROR (Status
)) {
910 DEBUG ((EFI_D_BLKIO
, "UsbBootWriteBlocks: LBA (0x%x), Blk (0x%x)\n", Lba
, Count
));
913 Buffer
+= Count
* BlockSize
;
921 Read some blocks from the device by SCSI 16 byte cmd.
923 @param UsbMass The USB mass storage device to read from
924 @param Lba The start block number
925 @param TotalBlock Total block number to read
926 @param Buffer The buffer to read to
928 @retval EFI_SUCCESS Data are read into the buffer
929 @retval Others Failed to read all the data
933 UsbBootReadBlocks16 (
934 IN USB_MASS_DEVICE
*UsbMass
,
947 BlockSize
= UsbMass
->BlockIoMedia
.BlockSize
;
948 Status
= EFI_SUCCESS
;
950 while (TotalBlock
> 0) {
952 // Split the total blocks into smaller pieces.
954 Count
= (UINT16
)((TotalBlock
< USB_BOOT_IO_BLOCKS
) ? TotalBlock
: USB_BOOT_IO_BLOCKS
);
955 ByteSize
= (UINT32
)Count
* BlockSize
;
958 // USB command's upper limit timeout is 5s. [USB2.0-9.2.6.1]
960 Timeout
= (UINT32
) USB_BOOT_GENERAL_CMD_TIMEOUT
;
963 // Fill in the command then execute
965 ZeroMem (ReadCmd
, sizeof (ReadCmd
));
967 ReadCmd
[0] = EFI_SCSI_OP_READ16
;
968 ReadCmd
[1] = (UINT8
) ((USB_BOOT_LUN (UsbMass
->Lun
) & 0xE0));
969 WriteUnaligned64 ((UINT64
*) &ReadCmd
[2], SwapBytes64 (Lba
));
970 WriteUnaligned32 ((UINT32
*) &ReadCmd
[10], SwapBytes32 (Count
));
972 Status
= UsbBootExecCmdWithRetry (
975 (UINT8
) sizeof (ReadCmd
),
981 if (EFI_ERROR (Status
)) {
984 DEBUG ((EFI_D_BLKIO
, "UsbBootReadBlocks16: LBA (0x%lx), Blk (0x%x)\n", Lba
, Count
));
986 Buffer
+= Count
* BlockSize
;
995 Write some blocks to the device by SCSI 16 byte cmd.
997 @param UsbMass The USB mass storage device to write to
998 @param Lba The start block number
999 @param TotalBlock Total block number to write
1000 @param Buffer Pointer to the source buffer for the data.
1002 @retval EFI_SUCCESS Data are written into the buffer
1003 @retval Others Failed to write all the data
1007 UsbBootWriteBlocks16 (
1008 IN USB_MASS_DEVICE
*UsbMass
,
1010 IN UINTN TotalBlock
,
1021 BlockSize
= UsbMass
->BlockIoMedia
.BlockSize
;
1022 Status
= EFI_SUCCESS
;
1024 while (TotalBlock
> 0) {
1026 // Split the total blocks into smaller pieces.
1028 Count
= (UINT16
)((TotalBlock
< USB_BOOT_IO_BLOCKS
) ? TotalBlock
: USB_BOOT_IO_BLOCKS
);
1029 ByteSize
= (UINT32
)Count
* BlockSize
;
1032 // USB command's upper limit timeout is 5s. [USB2.0-9.2.6.1]
1034 Timeout
= (UINT32
) USB_BOOT_GENERAL_CMD_TIMEOUT
;
1037 // Fill in the write16 command block
1039 ZeroMem (WriteCmd
, sizeof (WriteCmd
));
1041 WriteCmd
[0] = EFI_SCSI_OP_WRITE16
;
1042 WriteCmd
[1] = (UINT8
) ((USB_BOOT_LUN (UsbMass
->Lun
) & 0xE0));
1043 WriteUnaligned64 ((UINT64
*) &WriteCmd
[2], SwapBytes64 (Lba
));
1044 WriteUnaligned32 ((UINT32
*) &WriteCmd
[10], SwapBytes32 (Count
));
1046 Status
= UsbBootExecCmdWithRetry (
1049 (UINT8
) sizeof (WriteCmd
),
1055 if (EFI_ERROR (Status
)) {
1058 DEBUG ((EFI_D_BLKIO
, "UsbBootWriteBlocks: LBA (0x%lx), Blk (0x%x)\n", Lba
, Count
));
1060 Buffer
+= Count
* BlockSize
;
1061 TotalBlock
-= Count
;
1068 Use the USB clear feature control transfer to clear the endpoint stall condition.
1070 @param UsbIo The USB I/O Protocol instance
1071 @param EndpointAddr The endpoint to clear stall for
1073 @retval EFI_SUCCESS The endpoint stall condition is cleared.
1074 @retval Others Failed to clear the endpoint stall condition.
1078 UsbClearEndpointStall (
1079 IN EFI_USB_IO_PROTOCOL
*UsbIo
,
1080 IN UINT8 EndpointAddr
1083 EFI_USB_DEVICE_REQUEST Request
;
1088 Request
.RequestType
= 0x02;
1089 Request
.Request
= USB_REQ_CLEAR_FEATURE
;
1090 Request
.Value
= USB_FEATURE_ENDPOINT_HALT
;
1091 Request
.Index
= EndpointAddr
;
1093 Timeout
= USB_BOOT_GENERAL_CMD_TIMEOUT
/ USB_MASS_1_MILLISECOND
;
1095 Status
= UsbIo
->UsbControlTransfer (