]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Bus/Usb/UsbMassStorageDxe/UsbMassBoot.c
projects / mirror_edk2.git / blob
? search:


46330153e22bd2f42bc18542017e4d0d1840b7dc
[mirror_edk2.git] / MdeModulePkg / Bus / Usb / UsbMassStorageDxe / UsbMassBoot.c
1 /** @file
2 Implementation of the command set of USB Mass Storage Specification
3 for Bootability, Revision 1.0.
4
5 Copyright (c) 2007 - 2012, 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
10
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.
13
14 **/
15
16 #include "UsbMass.h"
17
18 /**
19 Execute REQUEST SENSE Command to retrieve sense data from device.
20
21 @param UsbMass The device whose sense data is requested.
22
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.
29
30 **/
31 EFI_STATUS
32 UsbBootRequestSense (
33 IN USB_MASS_DEVICE *UsbMass
34 )
35 {
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;
40 EFI_STATUS Status;
41 UINT32 CmdResult;
42
43 Transport = UsbMass->Transport;
44
45 //
46 // Request the sense data from the device
47 //
48 ZeroMem (&SenseCmd, sizeof (USB_BOOT_REQUEST_SENSE_CMD));
49 ZeroMem (&SenseData, sizeof (USB_BOOT_REQUEST_SENSE_DATA));
50
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);
54
55 Status = Transport->ExecCommand (
56 UsbMass->Context,
57 &SenseCmd,
58 sizeof (USB_BOOT_REQUEST_SENSE_CMD),
59 EfiUsbDataIn,
60 &SenseData,
61 sizeof (USB_BOOT_REQUEST_SENSE_DATA),
62 UsbMass->Lun,
63 USB_BOOT_GENERAL_CMD_TIMEOUT,
64 &CmdResult
65 );
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;
70 }
71 return Status;
72 }
73
74 //
75 // If sense data is retrieved successfully, interpret the sense data
76 // and update the media status if necessary.
77 //
78 Media = &UsbMass->BlockIoMedia;
79
80 switch (USB_BOOT_SENSE_KEY (SenseData.SenseKey)) {
81
82 case USB_BOOT_SENSE_NO_SENSE:
83 Status = EFI_NO_RESPONSE;
84 break;
85
86 case USB_BOOT_SENSE_RECOVERED:
87 //
88 // Suppose hardware can handle this case, and recover later by itself
89 //
90 Status = EFI_NOT_READY;
91 break;
92
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;
100 }
101 break;
102
103 case USB_BOOT_SENSE_ILLEGAL_REQUEST:
104 Status = EFI_INVALID_PARAMETER;
105 break;
106
107 case USB_BOOT_SENSE_UNIT_ATTENTION:
108 Status = EFI_DEVICE_ERROR;
109 if (SenseData.Asc == USB_BOOT_ASC_MEDIA_CHANGE) {
110 //
111 // If MediaChange, reset ReadOnly and new MediaId
112 //
113 Status = EFI_MEDIA_CHANGED;
114 Media->ReadOnly = FALSE;
115 Media->MediaId++;
116 }
117 break;
118
119 case USB_BOOT_SENSE_DATA_PROTECT:
120 Status = EFI_WRITE_PROTECTED;
121 Media->ReadOnly = TRUE;
122 break;
123
124 default:
125 Status = EFI_DEVICE_ERROR;
126 break;
127 }
128
129 DEBUG ((EFI_D_INFO, "UsbBootRequestSense: (%r) with sense key %x/%x/%x\n",
130 Status,
131 USB_BOOT_SENSE_KEY (SenseData.SenseKey),
132 SenseData.Asc,
133 SenseData.Ascq
134 ));
135
136 return Status;
137 }
138
139
140 /**
141 Execute the USB mass storage bootability commands.
142
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.
146
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
154
155 @retval EFI_SUCCESS Command is excuted successfully
156 @retval Others Command execution failed.
157
158 **/
159 EFI_STATUS
160 UsbBootExecCmd (
161 IN USB_MASS_DEVICE *UsbMass,
162 IN VOID *Cmd,
163 IN UINT8 CmdLen,
164 IN EFI_USB_DATA_DIRECTION DataDir,
165 IN VOID *Data,
166 IN UINT32 DataLen,
167 IN UINT32 Timeout
168 )
169 {
170 USB_MASS_TRANSPORT *Transport;
171 EFI_STATUS Status;
172 UINT32 CmdResult;
173
174 Transport = UsbMass->Transport;
175 Status = Transport->ExecCommand (
176 UsbMass->Context,
177 Cmd,
178 CmdLen,
179 DataDir,
180 Data,
181 DataLen,
182 UsbMass->Lun,
183 Timeout,
184 &CmdResult
185 );
186
187 if (Status == EFI_TIMEOUT) {
188 DEBUG ((EFI_D_ERROR, "UsbBootExecCmd: Timeout to Exec 0x%x Cmd\n", *(UINT8 *)Cmd));
189 return EFI_TIMEOUT;
190 }
191
192 //
193 // If ExecCommand() returns no error and CmdResult is success,
194 // then the commnad transfer is successful.
195 //
196 if ((CmdResult == USB_MASS_CMD_SUCCESS) && !EFI_ERROR (Status)) {
197 return EFI_SUCCESS;
198 }
199
200 //
201 // If command execution failed, then retrieve error info via sense request.
202 //
203 return UsbBootRequestSense (UsbMass);
204 }
205
206
207 /**
208 Execute the USB mass storage bootability commands with retrial.
209
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.
214
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
222
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.
226
227 **/
228 EFI_STATUS
229 UsbBootExecCmdWithRetry (
230 IN USB_MASS_DEVICE *UsbMass,
231 IN VOID *Cmd,
232 IN UINT8 CmdLen,
233 IN EFI_USB_DATA_DIRECTION DataDir,
234 IN VOID *Data,
235 IN UINT32 DataLen,
236 IN UINT32 Timeout
237 )
238 {
239 EFI_STATUS Status;
240 UINTN Retry;
241 EFI_EVENT TimeoutEvt;
242
243 Retry = 0;
244 Status = EFI_SUCCESS;
245 Status = gBS->CreateEvent (
246 EVT_TIMER,
247 TPL_CALLBACK,
248 NULL,
249 NULL,
250 &TimeoutEvt
251 );
252 if (EFI_ERROR (Status)) {
253 return Status;
254 }
255
256 Status = gBS->SetTimer (TimeoutEvt, TimerRelative, EFI_TIMER_PERIOD_SECONDS(60));
257 if (EFI_ERROR (Status)) {
258 goto EXIT;
259 }
260
261 //
262 // Execute the cmd and retry if it fails.
263 //
264 while (EFI_ERROR (gBS->CheckEvent (TimeoutEvt))) {
265 Status = UsbBootExecCmd (
266 UsbMass,
267 Cmd,
268 CmdLen,
269 DataDir,
270 Data,
271 DataLen,
272 Timeout
273 );
274 if (Status == EFI_SUCCESS || Status == EFI_MEDIA_CHANGED || Status == EFI_NO_MEDIA) {
275 break;
276 }
277 //
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.
280 //
281 if (Status == EFI_NOT_READY) {
282 continue;
283 }
284 //
285 // If the status is other error, then just retry 5 times.
286 //
287 if (Retry++ >= USB_BOOT_COMMAND_RETRY) {
288 break;
289 }
290 }
291
292 EXIT:
293 if (TimeoutEvt != NULL) {
294 gBS->CloseEvent (TimeoutEvt);
295 }
296
297 return Status;
298 }
299
300
301 /**
302 Execute TEST UNIT READY command to check if the device is ready.
303
304 @param UsbMass The device to test
305
306 @retval EFI_SUCCESS The device is ready.
307 @retval Others Device not ready.
308
309 **/
310 EFI_STATUS
311 UsbBootIsUnitReady (
312 IN USB_MASS_DEVICE *UsbMass
313 )
314 {
315 USB_BOOT_TEST_UNIT_READY_CMD TestCmd;
316
317 ZeroMem (&TestCmd, sizeof (USB_BOOT_TEST_UNIT_READY_CMD));
318
319 TestCmd.OpCode = USB_BOOT_TEST_UNIT_READY_OPCODE;
320 TestCmd.Lun = (UINT8) (USB_BOOT_LUN (UsbMass->Lun));
321
322 return UsbBootExecCmdWithRetry (
323 UsbMass,
324 &TestCmd,
325 (UINT8) sizeof (USB_BOOT_TEST_UNIT_READY_CMD),
326 EfiUsbNoData,
327 NULL,
328 0,
329 USB_BOOT_GENERAL_CMD_TIMEOUT
330 );
331 }
332
333
334 /**
335 Execute INQUIRY Command to request information regarding parameters of
336 the device be sent to the host computer.
337
338 @param UsbMass The device to inquire.
339
340 @retval EFI_SUCCESS INQUIRY Command is executed successfully.
341 @retval Others INQUIRY Command is not executed successfully.
342
343 **/
344 EFI_STATUS
345 UsbBootInquiry (
346 IN USB_MASS_DEVICE *UsbMass
347 )
348 {
349 USB_BOOT_INQUIRY_CMD InquiryCmd;
350 EFI_BLOCK_IO_MEDIA *Media;
351 EFI_STATUS Status;
352
353 Media = &(UsbMass->BlockIoMedia);
354
355 ZeroMem (&InquiryCmd, sizeof (USB_BOOT_INQUIRY_CMD));
356 ZeroMem (&UsbMass->InquiryData, sizeof (USB_BOOT_INQUIRY_DATA));
357
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);
361
362 Status = UsbBootExecCmdWithRetry (
363 UsbMass,
364 &InquiryCmd,
365 (UINT8) sizeof (USB_BOOT_INQUIRY_CMD),
366 EfiUsbDataIn,
367 &UsbMass->InquiryData,
368 sizeof (USB_BOOT_INQUIRY_DATA),
369 USB_BOOT_GENERAL_CMD_TIMEOUT
370 );
371 if (EFI_ERROR (Status)) {
372 return Status;
373 }
374
375 //
376 // Get information from PDT (Peripheral Device Type) field and Removable Medium Bit
377 // from the inquiry data.
378 //
379 UsbMass->Pdt = (UINT8) (USB_BOOT_PDT (UsbMass->InquiryData.Pdt));
380 Media->RemovableMedia = (BOOLEAN) (USB_BOOT_REMOVABLE (UsbMass->InquiryData.Removable));
381 //
382 // Set block size to the default value of 512 Bytes, in case no media is present at first time.
383 //
384 Media->BlockSize = 0x0200;
385
386 return Status;
387 }
388
389
390 /**
391 Execute READ CAPACITY command to request information regarding
392 the capacity of the installed medium of the device.
393
394 This function executes READ CAPACITY command to get the capacity
395 of the USB mass storage media, including the presence, block size,
396 and last block number.
397
398 @param UsbMass The device to retireve disk gemotric.
399
400 @retval EFI_SUCCESS The disk geometry is successfully retrieved.
401 @retval EFI_NOT_READY The returned block size is zero.
402 @retval Other READ CAPACITY command execution failed.
403
404 **/
405 EFI_STATUS
406 UsbBootReadCapacity (
407 IN USB_MASS_DEVICE *UsbMass
408 )
409 {
410 USB_BOOT_READ_CAPACITY_CMD CapacityCmd;
411 USB_BOOT_READ_CAPACITY_DATA CapacityData;
412 EFI_BLOCK_IO_MEDIA *Media;
413 EFI_STATUS Status;
414 UINT32 BlockSize;
415
416 Media = &UsbMass->BlockIoMedia;
417
418 ZeroMem (&CapacityCmd, sizeof (USB_BOOT_READ_CAPACITY_CMD));
419 ZeroMem (&CapacityData, sizeof (USB_BOOT_READ_CAPACITY_DATA));
420
421 CapacityCmd.OpCode = USB_BOOT_READ_CAPACITY_OPCODE;
422 CapacityCmd.Lun = (UINT8) (USB_BOOT_LUN (UsbMass->Lun));
423
424 Status = UsbBootExecCmdWithRetry (
425 UsbMass,
426 &CapacityCmd,
427 (UINT8) sizeof (USB_BOOT_READ_CAPACITY_CMD),
428 EfiUsbDataIn,
429 &CapacityData,
430 sizeof (USB_BOOT_READ_CAPACITY_DATA),
431 USB_BOOT_GENERAL_CMD_TIMEOUT
432 );
433 if (EFI_ERROR (Status)) {
434 return Status;
435 }
436
437 //
438 // Get the information on media presence, block size, and last block number
439 // from READ CAPACITY data.
440 //
441 Media->MediaPresent = TRUE;
442 Media->LastBlock = SwapBytes32 (ReadUnaligned32 ((CONST UINT32 *) CapacityData.LastLba));
443
444 BlockSize = SwapBytes32 (ReadUnaligned32 ((CONST UINT32 *) CapacityData.BlockLen));
445 if (BlockSize == 0) {
446 //
447 // Get sense data
448 //
449 return UsbBootRequestSense (UsbMass);
450 } else {
451 Media->BlockSize = BlockSize;
452 }
453
454 return Status;
455 }
456
457 /**
458 Retrieves SCSI mode sense information via MODE SENSE(6) command.
459
460 @param UsbMass The device whose sense data is requested.
461
462 @retval EFI_SUCCESS SCSI mode sense information retrieved successfully.
463 @retval Other Command execution failed.
464
465 **/
466 EFI_STATUS
467 UsbScsiModeSense (
468 IN USB_MASS_DEVICE *UsbMass
469 )
470 {
471 EFI_STATUS Status;
472 USB_SCSI_MODE_SENSE6_CMD ModeSenseCmd;
473 USB_SCSI_MODE_SENSE6_PARA_HEADER ModeParaHeader;
474 EFI_BLOCK_IO_MEDIA *Media;
475
476 Media = &UsbMass->BlockIoMedia;
477
478 ZeroMem (&ModeSenseCmd, sizeof (USB_SCSI_MODE_SENSE6_CMD));
479 ZeroMem (&ModeParaHeader, sizeof (USB_SCSI_MODE_SENSE6_PARA_HEADER));
480
481 //
482 // MODE SENSE(6) command is defined in Section 8.2.10 of SCSI-2 Spec
483 //
484 ModeSenseCmd.OpCode = USB_SCSI_MODE_SENSE6_OPCODE;
485 ModeSenseCmd.Lun = (UINT8) USB_BOOT_LUN (UsbMass->Lun);
486 ModeSenseCmd.PageCode = 0x3F;
487 ModeSenseCmd.AllocateLen = (UINT8) sizeof (USB_SCSI_MODE_SENSE6_PARA_HEADER);
488
489 Status = UsbBootExecCmdWithRetry (
490 UsbMass,
491 &ModeSenseCmd,
492 (UINT8) sizeof (USB_SCSI_MODE_SENSE6_CMD),
493 EfiUsbDataIn,
494 &ModeParaHeader,
495 sizeof (USB_SCSI_MODE_SENSE6_PARA_HEADER),
496 USB_BOOT_GENERAL_CMD_TIMEOUT
497 );
498
499 //
500 // Format of device-specific parameter byte of the mode parameter header is defined in
501 // Section 8.2.10 of SCSI-2 Spec.
502 // BIT7 of this byte is indicates whether the medium is write protected.
503 //
504 if (!EFI_ERROR (Status)) {
505 Media->ReadOnly = (BOOLEAN) ((ModeParaHeader.DevicePara & BIT7) != 0);
506 }
507
508 return Status;
509 }
510
511
512 /**
513 Get the parameters for the USB mass storage media.
514
515 This function get the parameters for the USB mass storage media,
516 It is used both to initialize the media during the Start() phase
517 of Driver Binding Protocol and to re-initialize it when the media is
518 changed. Althought the RemoveableMedia is unlikely to change,
519 it is also included here.
520
521 @param UsbMass The device to retrieve disk gemotric.
522
523 @retval EFI_SUCCESS The disk gemotric is successfully retrieved.
524 @retval Other Failed to get the parameters.
525
526 **/
527 EFI_STATUS
528 UsbBootGetParams (
529 IN USB_MASS_DEVICE *UsbMass
530 )
531 {
532 EFI_BLOCK_IO_MEDIA *Media;
533 EFI_STATUS Status;
534
535 Media = &(UsbMass->BlockIoMedia);
536
537 Status = UsbBootInquiry (UsbMass);
538 if (EFI_ERROR (Status)) {
539 DEBUG ((EFI_D_ERROR, "UsbBootGetParams: UsbBootInquiry (%r)\n", Status));
540 return Status;
541 }
542
543 //
544 // Don't use the Removable bit in inquiry data to test whether the media
545 // is removable because many flash disks wrongly set this bit.
546 //
547 if ((UsbMass->Pdt == USB_PDT_CDROM) || (UsbMass->Pdt == USB_PDT_OPTICAL)) {
548 //
549 // CD-Rom device and Non-CD optical device
550 //
551 UsbMass->OpticalStorage = TRUE;
552 //
553 // Default value 2048 Bytes, in case no media present at first time
554 //
555 Media->BlockSize = 0x0800;
556 }
557
558 Status = UsbBootDetectMedia (UsbMass);
559
560 return Status;
561 }
562
563
564 /**
565 Detect whether the removable media is present and whether it has changed.
566
567 @param UsbMass The device to check.
568
569 @retval EFI_SUCCESS The media status is successfully checked.
570 @retval Other Failed to detect media.
571
572 **/
573 EFI_STATUS
574 UsbBootDetectMedia (
575 IN USB_MASS_DEVICE *UsbMass
576 )
577 {
578 EFI_BLOCK_IO_MEDIA OldMedia;
579 EFI_BLOCK_IO_MEDIA *Media;
580 UINT8 CmdSet;
581 EFI_TPL OldTpl;
582 EFI_STATUS Status;
583
584 Media = &UsbMass->BlockIoMedia;
585
586 CopyMem (&OldMedia, &(UsbMass->BlockIoMedia), sizeof (EFI_BLOCK_IO_MEDIA));
587
588 CmdSet = ((EFI_USB_INTERFACE_DESCRIPTOR *) (UsbMass->Context))->InterfaceSubClass;
589
590 Status = UsbBootIsUnitReady (UsbMass);
591 if (EFI_ERROR (Status) && (Status != EFI_MEDIA_CHANGED)) {
592 goto ON_ERROR;
593 }
594
595 if ((UsbMass->Pdt != USB_PDT_CDROM) && (CmdSet == USB_MASS_STORE_SCSI)) {
596 //
597 // MODE SENSE is required for the device with PDT of 0x00/0x07/0x0E,
598 // according to Section 4 of USB Mass Storage Specification for Bootability.
599 // MODE SENSE(10) is useless here, while MODE SENSE(6) defined in SCSI
600 // could get the information of Write Protected.
601 // Since not all device support this command, skip if fail.
602 //
603 UsbScsiModeSense (UsbMass);
604 }
605
606 Status = UsbBootReadCapacity (UsbMass);
607 if (EFI_ERROR (Status)) {
608 DEBUG ((EFI_D_ERROR, "UsbBootDetectMedia: UsbBootReadCapacity (%r)\n", Status));
609 goto ON_ERROR;
610 }
611
612 return EFI_SUCCESS;
613
614 ON_ERROR:
615 //
616 // Detect whether it is necessary to reinstall the Block I/O Protocol.
617 //
618 // MediaId may change in RequestSense for MediaChanged
619 // MediaPresent may change in RequestSense for NoMedia
620 // MediaReadOnly may change in RequestSense for WriteProtected or MediaChanged
621 // MediaPresent/BlockSize/LastBlock may change in ReadCapacity
622 //
623 if ((Media->MediaId != OldMedia.MediaId) ||
624 (Media->MediaPresent != OldMedia.MediaPresent) ||
625 (Media->ReadOnly != OldMedia.ReadOnly) ||
626 (Media->BlockSize != OldMedia.BlockSize) ||
627 (Media->LastBlock != OldMedia.LastBlock)) {
628
629 //
630 // This function is called by Block I/O Protocol APIs, which run at TPL_NOTIFY.
631 // Here we temporarily restore TPL to TPL_CALLBACK to invoke ReinstallProtocolInterface().
632 //
633 OldTpl = EfiGetCurrentTpl ();
634 gBS->RestoreTPL (TPL_CALLBACK);
635
636 gBS->ReinstallProtocolInterface (
637 UsbMass->Controller,
638 &gEfiBlockIoProtocolGuid,
639 &UsbMass->BlockIo,
640 &UsbMass->BlockIo
641 );
642
643 ASSERT (EfiGetCurrentTpl () == TPL_CALLBACK);
644 gBS->RaiseTPL (OldTpl);
645
646 //
647 // Update MediaId after reinstalling Block I/O Protocol.
648 //
649 if (Media->MediaPresent != OldMedia.MediaPresent) {
650 if (Media->MediaPresent) {
651 Media->MediaId = 1;
652 } else {
653 Media->MediaId = 0;
654 }
655 }
656
657 if ((Media->ReadOnly != OldMedia.ReadOnly) ||
658 (Media->BlockSize != OldMedia.BlockSize) ||
659 (Media->LastBlock != OldMedia.LastBlock)) {
660 Media->MediaId++;
661 }
662 }
663
664 return Status;
665 }
666
667
668 /**
669 Read some blocks from the device.
670
671 @param UsbMass The USB mass storage device to read from
672 @param Lba The start block number
673 @param TotalBlock Total block number to read
674 @param Buffer The buffer to read to
675
676 @retval EFI_SUCCESS Data are read into the buffer
677 @retval Others Failed to read all the data
678
679 **/
680 EFI_STATUS
681 UsbBootReadBlocks (
682 IN USB_MASS_DEVICE *UsbMass,
683 IN UINT32 Lba,
684 IN UINTN TotalBlock,
685 OUT UINT8 *Buffer
686 )
687 {
688 USB_BOOT_READ10_CMD ReadCmd;
689 EFI_STATUS Status;
690 UINT16 Count;
691 UINT32 BlockSize;
692 UINT32 ByteSize;
693 UINT32 Timeout;
694
695 BlockSize = UsbMass->BlockIoMedia.BlockSize;
696 Status = EFI_SUCCESS;
697
698 while (TotalBlock > 0) {
699 //
700 // Split the total blocks into smaller pieces to ease the pressure
701 // on the device. We must split the total block because the READ10
702 // command only has 16 bit transfer length (in the unit of block).
703 //
704 Count = (UINT16)((TotalBlock < USB_BOOT_IO_BLOCKS) ? TotalBlock : USB_BOOT_IO_BLOCKS);
705 ByteSize = (UINT32)Count * BlockSize;
706
707 //
708 // USB command's upper limit timeout is 5s. [USB2.0-9.2.6.1]
709 //
710 Timeout = (UINT32) USB_BOOT_GENERAL_CMD_TIMEOUT;
711
712 //
713 // Fill in the command then execute
714 //
715 ZeroMem (&ReadCmd, sizeof (USB_BOOT_READ10_CMD));
716
717 ReadCmd.OpCode = USB_BOOT_READ10_OPCODE;
718 ReadCmd.Lun = (UINT8) (USB_BOOT_LUN (UsbMass->Lun));
719 WriteUnaligned32 ((UINT32 *) ReadCmd.Lba, SwapBytes32 (Lba));
720 WriteUnaligned16 ((UINT16 *) ReadCmd.TransferLen, SwapBytes16 (Count));
721
722 Status = UsbBootExecCmdWithRetry (
723 UsbMass,
724 &ReadCmd,
725 (UINT8) sizeof (USB_BOOT_READ10_CMD),
726 EfiUsbDataIn,
727 Buffer,
728 ByteSize,
729 Timeout
730 );
731 if (EFI_ERROR (Status)) {
732 return Status;
733 }
734 DEBUG ((EFI_D_BLKIO, "UsbBootReadBlocks: LBA (0x%x), Blk (0x%x)\n", Lba, TotalBlock));
735 Lba += Count;
736 Buffer += Count * BlockSize;
737 TotalBlock -= Count;
738 }
739
740 return Status;
741 }
742
743
744 /**
745 Write some blocks to the device.
746
747 @param UsbMass The USB mass storage device to write to
748 @param Lba The start block number
749 @param TotalBlock Total block number to write
750 @param Buffer Pointer to the source buffer for the data.
751
752 @retval EFI_SUCCESS Data are written into the buffer
753 @retval Others Failed to write all the data
754
755 **/
756 EFI_STATUS
757 UsbBootWriteBlocks (
758 IN USB_MASS_DEVICE *UsbMass,
759 IN UINT32 Lba,
760 IN UINTN TotalBlock,
761 IN UINT8 *Buffer
762 )
763 {
764 USB_BOOT_WRITE10_CMD WriteCmd;
765 EFI_STATUS Status;
766 UINT16 Count;
767 UINT32 BlockSize;
768 UINT32 ByteSize;
769 UINT32 Timeout;
770
771 BlockSize = UsbMass->BlockIoMedia.BlockSize;
772 Status = EFI_SUCCESS;
773
774 while (TotalBlock > 0) {
775 //
776 // Split the total blocks into smaller pieces to ease the pressure
777 // on the device. We must split the total block because the WRITE10
778 // command only has 16 bit transfer length (in the unit of block).
779 //
780 Count = (UINT16)((TotalBlock < USB_BOOT_IO_BLOCKS) ? TotalBlock : USB_BOOT_IO_BLOCKS);
781 ByteSize = (UINT32)Count * BlockSize;
782
783 //
784 // USB command's upper limit timeout is 5s. [USB2.0-9.2.6.1]
785 //
786 Timeout = (UINT32) USB_BOOT_GENERAL_CMD_TIMEOUT;
787
788 //
789 // Fill in the write10 command block
790 //
791 ZeroMem (&WriteCmd, sizeof (USB_BOOT_WRITE10_CMD));
792
793 WriteCmd.OpCode = USB_BOOT_WRITE10_OPCODE;
794 WriteCmd.Lun = (UINT8) (USB_BOOT_LUN (UsbMass->Lun));
795 WriteUnaligned32 ((UINT32 *) WriteCmd.Lba, SwapBytes32 (Lba));
796 WriteUnaligned16 ((UINT16 *) WriteCmd.TransferLen, SwapBytes16 (Count));
797
798 Status = UsbBootExecCmdWithRetry (
799 UsbMass,
800 &WriteCmd,
801 (UINT8) sizeof (USB_BOOT_WRITE10_CMD),
802 EfiUsbDataOut,
803 Buffer,
804 ByteSize,
805 Timeout
806 );
807 if (EFI_ERROR (Status)) {
808 return Status;
809 }
810 DEBUG ((EFI_D_BLKIO, "UsbBootWriteBlocks: LBA (0x%x), Blk (0x%x)\n", Lba, TotalBlock));
811 Lba += Count;
812 Buffer += Count * BlockSize;
813 TotalBlock -= Count;
814 }
815
816 return Status;
817 }
818
819 /**
820 Use the USB clear feature control transfer to clear the endpoint stall condition.
821
822 @param UsbIo The USB I/O Protocol instance
823 @param EndpointAddr The endpoint to clear stall for
824
825 @retval EFI_SUCCESS The endpoint stall condition is cleared.
826 @retval Others Failed to clear the endpoint stall condition.
827
828 **/
829 EFI_STATUS
830 UsbClearEndpointStall (
831 IN EFI_USB_IO_PROTOCOL *UsbIo,
832 IN UINT8 EndpointAddr
833 )
834 {
835 EFI_USB_DEVICE_REQUEST Request;
836 EFI_STATUS Status;
837 UINT32 CmdResult;
838 UINT32 Timeout;
839
840 Request.RequestType = 0x02;
841 Request.Request = USB_REQ_CLEAR_FEATURE;
842 Request.Value = USB_FEATURE_ENDPOINT_HALT;
843 Request.Index = EndpointAddr;
844 Request.Length = 0;
845 Timeout = USB_BOOT_GENERAL_CMD_TIMEOUT / USB_MASS_1_MILLISECOND;
846
847 Status = UsbIo->UsbControlTransfer (
848 UsbIo,
849 &Request,
850 EfiUsbNoData,
851 Timeout,
852 NULL,
853 0,
854 &CmdResult
855 );
856
857 return Status;
858 }
EFI Development Kit II mirror for PVE