]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Bus/Scsi/ScsiDiskDxe/ScsiDisk.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
MdeModulePkg ScsiDiskDxe: Fix async request retry times info lost issue
[mirror_edk2.git] / MdeModulePkg / Bus / Scsi / ScsiDiskDxe / ScsiDisk.c
1 /** @file
2 SCSI disk driver that layers on every SCSI IO protocol in the system.
3
4 Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 **/
14
15
16 #include "ScsiDisk.h"
17
18 EFI_DRIVER_BINDING_PROTOCOL gScsiDiskDriverBinding = {
19 ScsiDiskDriverBindingSupported,
20 ScsiDiskDriverBindingStart,
21 ScsiDiskDriverBindingStop,
22 0xa,
23 NULL,
24 NULL
25 };
26
27 EFI_DISK_INFO_PROTOCOL gScsiDiskInfoProtocolTemplate = {
28 EFI_DISK_INFO_SCSI_INTERFACE_GUID,
29 ScsiDiskInfoInquiry,
30 ScsiDiskInfoIdentify,
31 ScsiDiskInfoSenseData,
32 ScsiDiskInfoWhichIde
33 };
34
35 /**
36 Allocates an aligned buffer for SCSI disk.
37
38 This function allocates an aligned buffer for the SCSI disk to perform
39 SCSI IO operations. The alignment requirement is from SCSI IO interface.
40
41 @param ScsiDiskDevice The SCSI disk involved for the operation.
42 @param BufferSize The request buffer size.
43
44 @return A pointer to the aligned buffer or NULL if the allocation fails.
45
46 **/
47 VOID *
48 AllocateAlignedBuffer (
49 IN SCSI_DISK_DEV *ScsiDiskDevice,
50 IN UINTN BufferSize
51 )
52 {
53 return AllocateAlignedPages (EFI_SIZE_TO_PAGES (BufferSize), ScsiDiskDevice->ScsiIo->IoAlign);
54 }
55
56 /**
57 Frees an aligned buffer for SCSI disk.
58
59 This function frees an aligned buffer for the SCSI disk to perform
60 SCSI IO operations.
61
62 @param Buffer The aligned buffer to be freed.
63 @param BufferSize The request buffer size.
64
65 **/
66 VOID
67 FreeAlignedBuffer (
68 IN VOID *Buffer,
69 IN UINTN BufferSize
70 )
71 {
72 if (Buffer != NULL) {
73 FreeAlignedPages (Buffer, EFI_SIZE_TO_PAGES (BufferSize));
74 }
75 }
76
77 /**
78 The user Entry Point for module ScsiDisk.
79
80 The user code starts with this function.
81
82 @param ImageHandle The firmware allocated handle for the EFI image.
83 @param SystemTable A pointer to the EFI System Table.
84
85 @retval EFI_SUCCESS The entry point is executed successfully.
86 @retval other Some error occurs when executing this entry point.
87
88 **/
89 EFI_STATUS
90 EFIAPI
91 InitializeScsiDisk(
92 IN EFI_HANDLE ImageHandle,
93 IN EFI_SYSTEM_TABLE *SystemTable
94 )
95 {
96 EFI_STATUS Status;
97
98 //
99 // Install driver model protocol(s).
100 //
101 Status = EfiLibInstallDriverBindingComponentName2 (
102 ImageHandle,
103 SystemTable,
104 &gScsiDiskDriverBinding,
105 ImageHandle,
106 &gScsiDiskComponentName,
107 &gScsiDiskComponentName2
108 );
109 ASSERT_EFI_ERROR (Status);
110
111
112 return Status;
113 }
114
115 /**
116 Test to see if this driver supports ControllerHandle.
117
118 This service is called by the EFI boot service ConnectController(). In order
119 to make drivers as small as possible, there are a few calling restrictions for
120 this service. ConnectController() must follow these calling restrictions.
121 If any other agent wishes to call Supported() it must also follow these
122 calling restrictions.
123
124 @param This Protocol instance pointer.
125 @param ControllerHandle Handle of device to test
126 @param RemainingDevicePath Optional parameter use to pick a specific child
127 device to start.
128
129 @retval EFI_SUCCESS This driver supports this device
130 @retval EFI_ALREADY_STARTED This driver is already running on this device
131 @retval other This driver does not support this device
132
133 **/
134 EFI_STATUS
135 EFIAPI
136 ScsiDiskDriverBindingSupported (
137 IN EFI_DRIVER_BINDING_PROTOCOL *This,
138 IN EFI_HANDLE Controller,
139 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
140 )
141 {
142 EFI_STATUS Status;
143 EFI_SCSI_IO_PROTOCOL *ScsiIo;
144 UINT8 DeviceType;
145
146 Status = gBS->OpenProtocol (
147 Controller,
148 &gEfiScsiIoProtocolGuid,
149 (VOID **) &ScsiIo,
150 This->DriverBindingHandle,
151 Controller,
152 EFI_OPEN_PROTOCOL_BY_DRIVER
153 );
154 if (EFI_ERROR (Status)) {
155 return Status;
156 }
157
158 Status = ScsiIo->GetDeviceType (ScsiIo, &DeviceType);
159 if (!EFI_ERROR (Status)) {
160 if ((DeviceType == EFI_SCSI_TYPE_DISK) || (DeviceType == EFI_SCSI_TYPE_CDROM)) {
161 Status = EFI_SUCCESS;
162 } else {
163 Status = EFI_UNSUPPORTED;
164 }
165 }
166
167 gBS->CloseProtocol (
168 Controller,
169 &gEfiScsiIoProtocolGuid,
170 This->DriverBindingHandle,
171 Controller
172 );
173 return Status;
174 }
175
176
177 /**
178 Start this driver on ControllerHandle.
179
180 This service is called by the EFI boot service ConnectController(). In order
181 to make drivers as small as possible, there are a few calling restrictions for
182 this service. ConnectController() must follow these calling restrictions. If
183 any other agent wishes to call Start() it must also follow these calling
184 restrictions.
185
186 @param This Protocol instance pointer.
187 @param ControllerHandle Handle of device to bind driver to
188 @param RemainingDevicePath Optional parameter use to pick a specific child
189 device to start.
190
191 @retval EFI_SUCCESS This driver is added to ControllerHandle
192 @retval EFI_ALREADY_STARTED This driver is already running on ControllerHandle
193 @retval other This driver does not support this device
194
195 **/
196 EFI_STATUS
197 EFIAPI
198 ScsiDiskDriverBindingStart (
199 IN EFI_DRIVER_BINDING_PROTOCOL *This,
200 IN EFI_HANDLE Controller,
201 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
202 )
203 {
204 EFI_STATUS Status;
205 EFI_SCSI_IO_PROTOCOL *ScsiIo;
206 SCSI_DISK_DEV *ScsiDiskDevice;
207 BOOLEAN Temp;
208 UINT8 Index;
209 UINT8 MaxRetry;
210 BOOLEAN NeedRetry;
211 BOOLEAN MustReadCapacity;
212
213 MustReadCapacity = TRUE;
214
215 ScsiDiskDevice = (SCSI_DISK_DEV *) AllocateZeroPool (sizeof (SCSI_DISK_DEV));
216 if (ScsiDiskDevice == NULL) {
217 return EFI_OUT_OF_RESOURCES;
218 }
219
220 Status = gBS->OpenProtocol (
221 Controller,
222 &gEfiScsiIoProtocolGuid,
223 (VOID **) &ScsiIo,
224 This->DriverBindingHandle,
225 Controller,
226 EFI_OPEN_PROTOCOL_BY_DRIVER
227 );
228 if (EFI_ERROR (Status)) {
229 FreePool (ScsiDiskDevice);
230 return Status;
231 }
232
233 ScsiDiskDevice->Signature = SCSI_DISK_DEV_SIGNATURE;
234 ScsiDiskDevice->ScsiIo = ScsiIo;
235 ScsiDiskDevice->BlkIo.Revision = EFI_BLOCK_IO_PROTOCOL_REVISION3;
236 ScsiDiskDevice->BlkIo.Media = &ScsiDiskDevice->BlkIoMedia;
237 ScsiDiskDevice->BlkIo.Media->IoAlign = ScsiIo->IoAlign;
238 ScsiDiskDevice->BlkIo.Reset = ScsiDiskReset;
239 ScsiDiskDevice->BlkIo.ReadBlocks = ScsiDiskReadBlocks;
240 ScsiDiskDevice->BlkIo.WriteBlocks = ScsiDiskWriteBlocks;
241 ScsiDiskDevice->BlkIo.FlushBlocks = ScsiDiskFlushBlocks;
242 ScsiDiskDevice->BlkIo2.Media = &ScsiDiskDevice->BlkIoMedia;
243 ScsiDiskDevice->BlkIo2.Reset = ScsiDiskResetEx;
244 ScsiDiskDevice->BlkIo2.ReadBlocksEx = ScsiDiskReadBlocksEx;
245 ScsiDiskDevice->BlkIo2.WriteBlocksEx = ScsiDiskWriteBlocksEx;
246 ScsiDiskDevice->BlkIo2.FlushBlocksEx = ScsiDiskFlushBlocksEx;
247 ScsiDiskDevice->Handle = Controller;
248 InitializeListHead (&ScsiDiskDevice->BlkIo2Queue);
249
250 ScsiIo->GetDeviceType (ScsiIo, &(ScsiDiskDevice->DeviceType));
251 switch (ScsiDiskDevice->DeviceType) {
252 case EFI_SCSI_TYPE_DISK:
253 ScsiDiskDevice->BlkIo.Media->BlockSize = 0x200;
254 MustReadCapacity = TRUE;
255 break;
256
257 case EFI_SCSI_TYPE_CDROM:
258 ScsiDiskDevice->BlkIo.Media->BlockSize = 0x800;
259 ScsiDiskDevice->BlkIo.Media->ReadOnly = TRUE;
260 MustReadCapacity = FALSE;
261 break;
262 }
263 //
264 // The Sense Data Array's initial size is 6
265 //
266 ScsiDiskDevice->SenseDataNumber = 6;
267 ScsiDiskDevice->SenseData = (EFI_SCSI_SENSE_DATA *) AllocateZeroPool (
268 sizeof (EFI_SCSI_SENSE_DATA) * ScsiDiskDevice->SenseDataNumber
269 );
270 if (ScsiDiskDevice->SenseData == NULL) {
271 gBS->CloseProtocol (
272 Controller,
273 &gEfiScsiIoProtocolGuid,
274 This->DriverBindingHandle,
275 Controller
276 );
277 FreePool (ScsiDiskDevice);
278 return EFI_OUT_OF_RESOURCES;
279 }
280
281 //
282 // Retrieve device information
283 //
284 MaxRetry = 2;
285 for (Index = 0; Index < MaxRetry; Index++) {
286 Status = ScsiDiskInquiryDevice (ScsiDiskDevice, &NeedRetry);
287 if (!EFI_ERROR (Status)) {
288 break;
289 }
290
291 if (!NeedRetry) {
292 FreePool (ScsiDiskDevice->SenseData);
293 gBS->CloseProtocol (
294 Controller,
295 &gEfiScsiIoProtocolGuid,
296 This->DriverBindingHandle,
297 Controller
298 );
299 FreePool (ScsiDiskDevice);
300 return EFI_DEVICE_ERROR;
301 }
302 }
303 //
304 // The second parameter "TRUE" means must
305 // retrieve media capacity
306 //
307 Status = ScsiDiskDetectMedia (ScsiDiskDevice, MustReadCapacity, &Temp);
308 if (!EFI_ERROR (Status)) {
309 //
310 // Determine if Block IO & Block IO2 should be produced on this controller
311 // handle
312 //
313 if (DetermineInstallBlockIo(Controller)) {
314 InitializeInstallDiskInfo(ScsiDiskDevice, Controller);
315 Status = gBS->InstallMultipleProtocolInterfaces (
316 &Controller,
317 &gEfiBlockIoProtocolGuid,
318 &ScsiDiskDevice->BlkIo,
319 &gEfiBlockIo2ProtocolGuid,
320 &ScsiDiskDevice->BlkIo2,
321 &gEfiDiskInfoProtocolGuid,
322 &ScsiDiskDevice->DiskInfo,
323 NULL
324 );
325 if (!EFI_ERROR(Status)) {
326 ScsiDiskDevice->ControllerNameTable = NULL;
327 AddUnicodeString2 (
328 "eng",
329 gScsiDiskComponentName.SupportedLanguages,
330 &ScsiDiskDevice->ControllerNameTable,
331 L"SCSI Disk Device",
332 TRUE
333 );
334 AddUnicodeString2 (
335 "en",
336 gScsiDiskComponentName2.SupportedLanguages,
337 &ScsiDiskDevice->ControllerNameTable,
338 L"SCSI Disk Device",
339 FALSE
340 );
341 return EFI_SUCCESS;
342 }
343 }
344 }
345
346 gBS->FreePool (ScsiDiskDevice->SenseData);
347 gBS->FreePool (ScsiDiskDevice);
348 gBS->CloseProtocol (
349 Controller,
350 &gEfiScsiIoProtocolGuid,
351 This->DriverBindingHandle,
352 Controller
353 );
354 return Status;
355
356 }
357
358
359 /**
360 Stop this driver on ControllerHandle.
361
362 This service is called by the EFI boot service DisconnectController().
363 In order to make drivers as small as possible, there are a few calling
364 restrictions for this service. DisconnectController() must follow these
365 calling restrictions. If any other agent wishes to call Stop() it must
366 also follow these calling restrictions.
367
368 @param This Protocol instance pointer.
369 @param ControllerHandle Handle of device to stop driver on
370 @param NumberOfChildren Number of Handles in ChildHandleBuffer. If number of
371 children is zero stop the entire bus driver.
372 @param ChildHandleBuffer List of Child Handles to Stop.
373
374 @retval EFI_SUCCESS This driver is removed ControllerHandle
375 @retval other This driver was not removed from this device
376
377 **/
378 EFI_STATUS
379 EFIAPI
380 ScsiDiskDriverBindingStop (
381 IN EFI_DRIVER_BINDING_PROTOCOL *This,
382 IN EFI_HANDLE Controller,
383 IN UINTN NumberOfChildren,
384 IN EFI_HANDLE *ChildHandleBuffer OPTIONAL
385 )
386 {
387 EFI_BLOCK_IO_PROTOCOL *BlkIo;
388 SCSI_DISK_DEV *ScsiDiskDevice;
389 EFI_STATUS Status;
390
391 Status = gBS->OpenProtocol (
392 Controller,
393 &gEfiBlockIoProtocolGuid,
394 (VOID **) &BlkIo,
395 This->DriverBindingHandle,
396 Controller,
397 EFI_OPEN_PROTOCOL_GET_PROTOCOL
398 );
399 if (EFI_ERROR (Status)) {
400 return Status;
401 }
402
403 ScsiDiskDevice = SCSI_DISK_DEV_FROM_BLKIO (BlkIo);
404
405 //
406 // Wait for the BlockIo2 requests queue to become empty
407 //
408 while (!IsListEmpty (&ScsiDiskDevice->BlkIo2Queue));
409
410 Status = gBS->UninstallMultipleProtocolInterfaces (
411 Controller,
412 &gEfiBlockIoProtocolGuid,
413 &ScsiDiskDevice->BlkIo,
414 &gEfiBlockIo2ProtocolGuid,
415 &ScsiDiskDevice->BlkIo2,
416 &gEfiDiskInfoProtocolGuid,
417 &ScsiDiskDevice->DiskInfo,
418 NULL
419 );
420 if (!EFI_ERROR (Status)) {
421 gBS->CloseProtocol (
422 Controller,
423 &gEfiScsiIoProtocolGuid,
424 This->DriverBindingHandle,
425 Controller
426 );
427
428 ReleaseScsiDiskDeviceResources (ScsiDiskDevice);
429
430 return EFI_SUCCESS;
431 }
432 //
433 // errors met
434 //
435 return Status;
436 }
437
438 /**
439 Reset SCSI Disk.
440
441
442 @param This The pointer of EFI_BLOCK_IO_PROTOCOL
443 @param ExtendedVerification The flag about if extend verificate
444
445 @retval EFI_SUCCESS The device was reset.
446 @retval EFI_DEVICE_ERROR The device is not functioning properly and could
447 not be reset.
448 @return EFI_STATUS is returned from EFI_SCSI_IO_PROTOCOL.ResetDevice().
449
450 **/
451 EFI_STATUS
452 EFIAPI
453 ScsiDiskReset (
454 IN EFI_BLOCK_IO_PROTOCOL *This,
455 IN BOOLEAN ExtendedVerification
456 )
457 {
458 EFI_TPL OldTpl;
459 SCSI_DISK_DEV *ScsiDiskDevice;
460 EFI_STATUS Status;
461
462 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
463
464 ScsiDiskDevice = SCSI_DISK_DEV_FROM_BLKIO (This);
465
466 Status = ScsiDiskDevice->ScsiIo->ResetDevice (ScsiDiskDevice->ScsiIo);
467
468 if (EFI_ERROR (Status)) {
469 Status = EFI_DEVICE_ERROR;
470 goto Done;
471 }
472
473 if (!ExtendedVerification) {
474 goto Done;
475 }
476
477 Status = ScsiDiskDevice->ScsiIo->ResetBus (ScsiDiskDevice->ScsiIo);
478
479 if (EFI_ERROR (Status)) {
480 Status = EFI_DEVICE_ERROR;
481 goto Done;
482 }
483
484 Done:
485 gBS->RestoreTPL (OldTpl);
486 return Status;
487 }
488
489 /**
490 The function is to Read Block from SCSI Disk.
491
492 @param This The pointer of EFI_BLOCK_IO_PROTOCOL.
493 @param MediaId The Id of Media detected
494 @param Lba The logic block address
495 @param BufferSize The size of Buffer
496 @param Buffer The buffer to fill the read out data
497
498 @retval EFI_SUCCESS Successfully to read out block.
499 @retval EFI_DEVICE_ERROR Fail to detect media.
500 @retval EFI_NO_MEDIA Media is not present.
501 @retval EFI_MEDIA_CHANGED Media has changed.
502 @retval EFI_BAD_BUFFER_SIZE The Buffer was not a multiple of the block size of the device.
503 @retval EFI_INVALID_PARAMETER Invalid parameter passed in.
504
505 **/
506 EFI_STATUS
507 EFIAPI
508 ScsiDiskReadBlocks (
509 IN EFI_BLOCK_IO_PROTOCOL *This,
510 IN UINT32 MediaId,
511 IN EFI_LBA Lba,
512 IN UINTN BufferSize,
513 OUT VOID *Buffer
514 )
515 {
516 SCSI_DISK_DEV *ScsiDiskDevice;
517 EFI_BLOCK_IO_MEDIA *Media;
518 EFI_STATUS Status;
519 UINTN BlockSize;
520 UINTN NumberOfBlocks;
521 BOOLEAN MediaChange;
522 EFI_TPL OldTpl;
523
524 MediaChange = FALSE;
525 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
526 ScsiDiskDevice = SCSI_DISK_DEV_FROM_BLKIO (This);
527
528 if (!IS_DEVICE_FIXED(ScsiDiskDevice)) {
529
530 Status = ScsiDiskDetectMedia (ScsiDiskDevice, FALSE, &MediaChange);
531 if (EFI_ERROR (Status)) {
532 Status = EFI_DEVICE_ERROR;
533 goto Done;
534 }
535
536 if (MediaChange) {
537 gBS->ReinstallProtocolInterface (
538 ScsiDiskDevice->Handle,
539 &gEfiBlockIoProtocolGuid,
540 &ScsiDiskDevice->BlkIo,
541 &ScsiDiskDevice->BlkIo
542 );
543 gBS->ReinstallProtocolInterface (
544 ScsiDiskDevice->Handle,
545 &gEfiBlockIo2ProtocolGuid,
546 &ScsiDiskDevice->BlkIo2,
547 &ScsiDiskDevice->BlkIo2
548 );
549 Status = EFI_MEDIA_CHANGED;
550 goto Done;
551 }
552 }
553 //
554 // Get the intrinsic block size
555 //
556 Media = ScsiDiskDevice->BlkIo.Media;
557 BlockSize = Media->BlockSize;
558
559 NumberOfBlocks = BufferSize / BlockSize;
560
561 if (!(Media->MediaPresent)) {
562 Status = EFI_NO_MEDIA;
563 goto Done;
564 }
565
566 if (MediaId != Media->MediaId) {
567 Status = EFI_MEDIA_CHANGED;
568 goto Done;
569 }
570
571 if (Buffer == NULL) {
572 Status = EFI_INVALID_PARAMETER;
573 goto Done;
574 }
575
576 if (BufferSize == 0) {
577 Status = EFI_SUCCESS;
578 goto Done;
579 }
580
581 if (BufferSize % BlockSize != 0) {
582 Status = EFI_BAD_BUFFER_SIZE;
583 goto Done;
584 }
585
586 if (Lba > Media->LastBlock) {
587 Status = EFI_INVALID_PARAMETER;
588 goto Done;
589 }
590
591 if ((Lba + NumberOfBlocks - 1) > Media->LastBlock) {
592 Status = EFI_INVALID_PARAMETER;
593 goto Done;
594 }
595
596 if ((Media->IoAlign > 1) && (((UINTN) Buffer & (Media->IoAlign - 1)) != 0)) {
597 Status = EFI_INVALID_PARAMETER;
598 goto Done;
599 }
600
601 //
602 // If all the parameters are valid, then perform read sectors command
603 // to transfer data from device to host.
604 //
605 Status = ScsiDiskReadSectors (ScsiDiskDevice, Buffer, Lba, NumberOfBlocks);
606
607 Done:
608 gBS->RestoreTPL (OldTpl);
609 return Status;
610 }
611
612 /**
613 The function is to Write Block to SCSI Disk.
614
615 @param This The pointer of EFI_BLOCK_IO_PROTOCOL
616 @param MediaId The Id of Media detected
617 @param Lba The logic block address
618 @param BufferSize The size of Buffer
619 @param Buffer The buffer to fill the read out data
620
621 @retval EFI_SUCCESS Successfully to read out block.
622 @retval EFI_WRITE_PROTECTED The device can not be written to.
623 @retval EFI_DEVICE_ERROR Fail to detect media.
624 @retval EFI_NO_MEDIA Media is not present.
625 @retval EFI_MEDIA_CHNAGED Media has changed.
626 @retval EFI_BAD_BUFFER_SIZE The Buffer was not a multiple of the block size of the device.
627 @retval EFI_INVALID_PARAMETER Invalid parameter passed in.
628
629 **/
630 EFI_STATUS
631 EFIAPI
632 ScsiDiskWriteBlocks (
633 IN EFI_BLOCK_IO_PROTOCOL *This,
634 IN UINT32 MediaId,
635 IN EFI_LBA Lba,
636 IN UINTN BufferSize,
637 IN VOID *Buffer
638 )
639 {
640 SCSI_DISK_DEV *ScsiDiskDevice;
641 EFI_BLOCK_IO_MEDIA *Media;
642 EFI_STATUS Status;
643 UINTN BlockSize;
644 UINTN NumberOfBlocks;
645 BOOLEAN MediaChange;
646 EFI_TPL OldTpl;
647
648 MediaChange = FALSE;
649 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
650 ScsiDiskDevice = SCSI_DISK_DEV_FROM_BLKIO (This);
651
652 if (!IS_DEVICE_FIXED(ScsiDiskDevice)) {
653
654 Status = ScsiDiskDetectMedia (ScsiDiskDevice, FALSE, &MediaChange);
655 if (EFI_ERROR (Status)) {
656 Status = EFI_DEVICE_ERROR;
657 goto Done;
658 }
659
660 if (MediaChange) {
661 gBS->ReinstallProtocolInterface (
662 ScsiDiskDevice->Handle,
663 &gEfiBlockIoProtocolGuid,
664 &ScsiDiskDevice->BlkIo,
665 &ScsiDiskDevice->BlkIo
666 );
667 gBS->ReinstallProtocolInterface (
668 ScsiDiskDevice->Handle,
669 &gEfiBlockIo2ProtocolGuid,
670 &ScsiDiskDevice->BlkIo2,
671 &ScsiDiskDevice->BlkIo2
672 );
673 Status = EFI_MEDIA_CHANGED;
674 goto Done;
675 }
676 }
677 //
678 // Get the intrinsic block size
679 //
680 Media = ScsiDiskDevice->BlkIo.Media;
681 BlockSize = Media->BlockSize;
682
683 NumberOfBlocks = BufferSize / BlockSize;
684
685 if (!(Media->MediaPresent)) {
686 Status = EFI_NO_MEDIA;
687 goto Done;
688 }
689
690 if (MediaId != Media->MediaId) {
691 Status = EFI_MEDIA_CHANGED;
692 goto Done;
693 }
694
695 if (Media->ReadOnly) {
696 Status = EFI_WRITE_PROTECTED;
697 goto Done;
698 }
699
700 if (BufferSize == 0) {
701 Status = EFI_SUCCESS;
702 goto Done;
703 }
704
705 if (Buffer == NULL) {
706 Status = EFI_INVALID_PARAMETER;
707 goto Done;
708 }
709
710 if (BufferSize % BlockSize != 0) {
711 Status = EFI_BAD_BUFFER_SIZE;
712 goto Done;
713 }
714
715 if (Lba > Media->LastBlock) {
716 Status = EFI_INVALID_PARAMETER;
717 goto Done;
718 }
719
720 if ((Lba + NumberOfBlocks - 1) > Media->LastBlock) {
721 Status = EFI_INVALID_PARAMETER;
722 goto Done;
723 }
724
725 if ((Media->IoAlign > 1) && (((UINTN) Buffer & (Media->IoAlign - 1)) != 0)) {
726 Status = EFI_INVALID_PARAMETER;
727 goto Done;
728 }
729 //
730 // if all the parameters are valid, then perform read sectors command
731 // to transfer data from device to host.
732 //
733 Status = ScsiDiskWriteSectors (ScsiDiskDevice, Buffer, Lba, NumberOfBlocks);
734
735 Done:
736 gBS->RestoreTPL (OldTpl);
737 return Status;
738 }
739
740 /**
741 Flush Block to Disk.
742
743 EFI_SUCCESS is returned directly.
744
745 @param This The pointer of EFI_BLOCK_IO_PROTOCOL
746
747 @retval EFI_SUCCESS All outstanding data was written to the device
748
749 **/
750 EFI_STATUS
751 EFIAPI
752 ScsiDiskFlushBlocks (
753 IN EFI_BLOCK_IO_PROTOCOL *This
754 )
755 {
756 //
757 // return directly
758 //
759 return EFI_SUCCESS;
760 }
761
762
763 /**
764 Reset SCSI Disk.
765
766 @param This The pointer of EFI_BLOCK_IO2_PROTOCOL.
767 @param ExtendedVerification The flag about if extend verificate.
768
769 @retval EFI_SUCCESS The device was reset.
770 @retval EFI_DEVICE_ERROR The device is not functioning properly and could
771 not be reset.
772 @return EFI_STATUS is returned from EFI_SCSI_IO_PROTOCOL.ResetDevice().
773
774 **/
775 EFI_STATUS
776 EFIAPI
777 ScsiDiskResetEx (
778 IN EFI_BLOCK_IO2_PROTOCOL *This,
779 IN BOOLEAN ExtendedVerification
780 )
781 {
782 EFI_TPL OldTpl;
783 SCSI_DISK_DEV *ScsiDiskDevice;
784 EFI_STATUS Status;
785
786 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
787
788 ScsiDiskDevice = SCSI_DISK_DEV_FROM_BLKIO2 (This);
789
790 Status = ScsiDiskDevice->ScsiIo->ResetDevice (ScsiDiskDevice->ScsiIo);
791
792 if (EFI_ERROR (Status)) {
793 Status = EFI_DEVICE_ERROR;
794 goto Done;
795 }
796
797 if (!ExtendedVerification) {
798 goto Done;
799 }
800
801 Status = ScsiDiskDevice->ScsiIo->ResetBus (ScsiDiskDevice->ScsiIo);
802
803 if (EFI_ERROR (Status)) {
804 Status = EFI_DEVICE_ERROR;
805 goto Done;
806 }
807
808 Done:
809 gBS->RestoreTPL (OldTpl);
810 return Status;
811 }
812
813 /**
814 The function is to Read Block from SCSI Disk.
815
816 @param This The pointer of EFI_BLOCK_IO_PROTOCOL.
817 @param MediaId The Id of Media detected.
818 @param Lba The logic block address.
819 @param Token A pointer to the token associated with the transaction.
820 @param BufferSize The size of Buffer.
821 @param Buffer The buffer to fill the read out data.
822
823 @retval EFI_SUCCESS The read request was queued if Token-> Event is
824 not NULL. The data was read correctly from the
825 device if theToken-> Event is NULL.
826 @retval EFI_DEVICE_ERROR The device reported an error while attempting
827 to perform the read operation.
828 @retval EFI_NO_MEDIA There is no media in the device.
829 @retval EFI_MEDIA_CHANGED The MediaId is not for the current media.
830 @retval EFI_BAD_BUFFER_SIZE The BufferSize parameter is not a multiple of
831 the intrinsic block size of the device.
832 @retval EFI_INVALID_PARAMETER The read request contains LBAs that are not
833 valid, or the buffer is not on proper
834 alignment.
835 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a
836 lack of resources.
837
838 **/
839 EFI_STATUS
840 EFIAPI
841 ScsiDiskReadBlocksEx (
842 IN EFI_BLOCK_IO2_PROTOCOL *This,
843 IN UINT32 MediaId,
844 IN EFI_LBA Lba,
845 IN OUT EFI_BLOCK_IO2_TOKEN *Token,
846 IN UINTN BufferSize,
847 OUT VOID *Buffer
848 )
849 {
850 SCSI_DISK_DEV *ScsiDiskDevice;
851 EFI_BLOCK_IO_MEDIA *Media;
852 EFI_STATUS Status;
853 UINTN BlockSize;
854 UINTN NumberOfBlocks;
855 BOOLEAN MediaChange;
856 EFI_TPL OldTpl;
857
858 MediaChange = FALSE;
859 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
860 ScsiDiskDevice = SCSI_DISK_DEV_FROM_BLKIO2 (This);
861
862 if (!IS_DEVICE_FIXED(ScsiDiskDevice)) {
863
864 Status = ScsiDiskDetectMedia (ScsiDiskDevice, FALSE, &MediaChange);
865 if (EFI_ERROR (Status)) {
866 Status = EFI_DEVICE_ERROR;
867 goto Done;
868 }
869
870 if (MediaChange) {
871 gBS->ReinstallProtocolInterface (
872 ScsiDiskDevice->Handle,
873 &gEfiBlockIoProtocolGuid,
874 &ScsiDiskDevice->BlkIo,
875 &ScsiDiskDevice->BlkIo
876 );
877 gBS->ReinstallProtocolInterface (
878 ScsiDiskDevice->Handle,
879 &gEfiBlockIo2ProtocolGuid,
880 &ScsiDiskDevice->BlkIo2,
881 &ScsiDiskDevice->BlkIo2
882 );
883 Status = EFI_MEDIA_CHANGED;
884 goto Done;
885 }
886 }
887 //
888 // Get the intrinsic block size
889 //
890 Media = ScsiDiskDevice->BlkIo2.Media;
891 BlockSize = Media->BlockSize;
892
893 NumberOfBlocks = BufferSize / BlockSize;
894
895 if (!(Media->MediaPresent)) {
896 Status = EFI_NO_MEDIA;
897 goto Done;
898 }
899
900 if (MediaId != Media->MediaId) {
901 Status = EFI_MEDIA_CHANGED;
902 goto Done;
903 }
904
905 if (Buffer == NULL) {
906 Status = EFI_INVALID_PARAMETER;
907 goto Done;
908 }
909
910 if (BufferSize == 0) {
911 if ((Token != NULL) && (Token->Event != NULL)) {
912 Token->TransactionStatus = EFI_SUCCESS;
913 gBS->SignalEvent (Token->Event);
914 }
915
916 Status = EFI_SUCCESS;
917 goto Done;
918 }
919
920 if (BufferSize % BlockSize != 0) {
921 Status = EFI_BAD_BUFFER_SIZE;
922 goto Done;
923 }
924
925 if (Lba > Media->LastBlock) {
926 Status = EFI_INVALID_PARAMETER;
927 goto Done;
928 }
929
930 if ((Lba + NumberOfBlocks - 1) > Media->LastBlock) {
931 Status = EFI_INVALID_PARAMETER;
932 goto Done;
933 }
934
935 if ((Media->IoAlign > 1) && (((UINTN) Buffer & (Media->IoAlign - 1)) != 0)) {
936 Status = EFI_INVALID_PARAMETER;
937 goto Done;
938 }
939
940 //
941 // If all the parameters are valid, then perform read sectors command
942 // to transfer data from device to host.
943 //
944 if ((Token != NULL) && (Token->Event != NULL)) {
945 Token->TransactionStatus = EFI_SUCCESS;
946 Status = ScsiDiskAsyncReadSectors (
947 ScsiDiskDevice,
948 Buffer,
949 Lba,
950 NumberOfBlocks,
951 Token
952 );
953 } else {
954 Status = ScsiDiskReadSectors (
955 ScsiDiskDevice,
956 Buffer,
957 Lba,
958 NumberOfBlocks
959 );
960 }
961
962 Done:
963 gBS->RestoreTPL (OldTpl);
964 return Status;
965 }
966
967 /**
968 The function is to Write Block to SCSI Disk.
969
970 @param This The pointer of EFI_BLOCK_IO_PROTOCOL.
971 @param MediaId The Id of Media detected.
972 @param Lba The logic block address.
973 @param Token A pointer to the token associated with the transaction.
974 @param BufferSize The size of Buffer.
975 @param Buffer The buffer to fill the read out data.
976
977 @retval EFI_SUCCESS The data were written correctly to the device.
978 @retval EFI_WRITE_PROTECTED The device cannot be written to.
979 @retval EFI_NO_MEDIA There is no media in the device.
980 @retval EFI_MEDIA_CHANGED The MediaId is not for the current media.
981 @retval EFI_DEVICE_ERROR The device reported an error while attempting
982 to perform the write operation.
983 @retval EFI_BAD_BUFFER_SIZE The BufferSize parameter is not a multiple of
984 the intrinsic block size of the device.
985 @retval EFI_INVALID_PARAMETER The write request contains LBAs that are not
986 valid, or the buffer is not on proper
987 alignment.
988
989 **/
990 EFI_STATUS
991 EFIAPI
992 ScsiDiskWriteBlocksEx (
993 IN EFI_BLOCK_IO2_PROTOCOL *This,
994 IN UINT32 MediaId,
995 IN EFI_LBA Lba,
996 IN OUT EFI_BLOCK_IO2_TOKEN *Token,
997 IN UINTN BufferSize,
998 IN VOID *Buffer
999 )
1000 {
1001 SCSI_DISK_DEV *ScsiDiskDevice;
1002 EFI_BLOCK_IO_MEDIA *Media;
1003 EFI_STATUS Status;
1004 UINTN BlockSize;
1005 UINTN NumberOfBlocks;
1006 BOOLEAN MediaChange;
1007 EFI_TPL OldTpl;
1008
1009 MediaChange = FALSE;
1010 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
1011 ScsiDiskDevice = SCSI_DISK_DEV_FROM_BLKIO2 (This);
1012
1013 if (!IS_DEVICE_FIXED(ScsiDiskDevice)) {
1014
1015 Status = ScsiDiskDetectMedia (ScsiDiskDevice, FALSE, &MediaChange);
1016 if (EFI_ERROR (Status)) {
1017 Status = EFI_DEVICE_ERROR;
1018 goto Done;
1019 }
1020
1021 if (MediaChange) {
1022 gBS->ReinstallProtocolInterface (
1023 ScsiDiskDevice->Handle,
1024 &gEfiBlockIoProtocolGuid,
1025 &ScsiDiskDevice->BlkIo,
1026 &ScsiDiskDevice->BlkIo
1027 );
1028 gBS->ReinstallProtocolInterface (
1029 ScsiDiskDevice->Handle,
1030 &gEfiBlockIo2ProtocolGuid,
1031 &ScsiDiskDevice->BlkIo2,
1032 &ScsiDiskDevice->BlkIo2
1033 );
1034 Status = EFI_MEDIA_CHANGED;
1035 goto Done;
1036 }
1037 }
1038 //
1039 // Get the intrinsic block size
1040 //
1041 Media = ScsiDiskDevice->BlkIo2.Media;
1042 BlockSize = Media->BlockSize;
1043
1044 NumberOfBlocks = BufferSize / BlockSize;
1045
1046 if (!(Media->MediaPresent)) {
1047 Status = EFI_NO_MEDIA;
1048 goto Done;
1049 }
1050
1051 if (MediaId != Media->MediaId) {
1052 Status = EFI_MEDIA_CHANGED;
1053 goto Done;
1054 }
1055
1056 if (Media->ReadOnly) {
1057 Status = EFI_WRITE_PROTECTED;
1058 goto Done;
1059 }
1060
1061 if (BufferSize == 0) {
1062 if ((Token != NULL) && (Token->Event != NULL)) {
1063 Token->TransactionStatus = EFI_SUCCESS;
1064 gBS->SignalEvent (Token->Event);
1065 }
1066
1067 Status = EFI_SUCCESS;
1068 goto Done;
1069 }
1070
1071 if (Buffer == NULL) {
1072 Status = EFI_INVALID_PARAMETER;
1073 goto Done;
1074 }
1075
1076 if (BufferSize % BlockSize != 0) {
1077 Status = EFI_BAD_BUFFER_SIZE;
1078 goto Done;
1079 }
1080
1081 if (Lba > Media->LastBlock) {
1082 Status = EFI_INVALID_PARAMETER;
1083 goto Done;
1084 }
1085
1086 if ((Lba + NumberOfBlocks - 1) > Media->LastBlock) {
1087 Status = EFI_INVALID_PARAMETER;
1088 goto Done;
1089 }
1090
1091 if ((Media->IoAlign > 1) && (((UINTN) Buffer & (Media->IoAlign - 1)) != 0)) {
1092 Status = EFI_INVALID_PARAMETER;
1093 goto Done;
1094 }
1095
1096 //
1097 // if all the parameters are valid, then perform write sectors command
1098 // to transfer data from device to host.
1099 //
1100 if ((Token != NULL) && (Token->Event != NULL)) {
1101 Token->TransactionStatus = EFI_SUCCESS;
1102 Status = ScsiDiskAsyncWriteSectors (
1103 ScsiDiskDevice,
1104 Buffer,
1105 Lba,
1106 NumberOfBlocks,
1107 Token
1108 );
1109 } else {
1110 Status = ScsiDiskWriteSectors (
1111 ScsiDiskDevice,
1112 Buffer,
1113 Lba,
1114 NumberOfBlocks
1115 );
1116 }
1117
1118 Done:
1119 gBS->RestoreTPL (OldTpl);
1120 return Status;
1121 }
1122
1123 /**
1124 Flush the Block Device.
1125
1126 @param This Indicates a pointer to the calling context.
1127 @param Token A pointer to the token associated with the transaction.
1128
1129 @retval EFI_SUCCESS All outstanding data was written to the device.
1130 @retval EFI_DEVICE_ERROR The device reported an error while attempting to
1131 write data.
1132 @retval EFI_WRITE_PROTECTED The device cannot be written to.
1133 @retval EFI_NO_MEDIA There is no media in the device.
1134 @retval EFI_MEDIA_CHANGED The MediaId is not for the current media.
1135
1136 **/
1137 EFI_STATUS
1138 EFIAPI
1139 ScsiDiskFlushBlocksEx (
1140 IN EFI_BLOCK_IO2_PROTOCOL *This,
1141 IN OUT EFI_BLOCK_IO2_TOKEN *Token
1142 )
1143 {
1144 SCSI_DISK_DEV *ScsiDiskDevice;
1145 EFI_BLOCK_IO_MEDIA *Media;
1146 EFI_STATUS Status;
1147 BOOLEAN MediaChange;
1148 EFI_TPL OldTpl;
1149
1150 MediaChange = FALSE;
1151 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
1152 ScsiDiskDevice = SCSI_DISK_DEV_FROM_BLKIO2 (This);
1153
1154 if (!IS_DEVICE_FIXED(ScsiDiskDevice)) {
1155
1156 Status = ScsiDiskDetectMedia (ScsiDiskDevice, FALSE, &MediaChange);
1157 if (EFI_ERROR (Status)) {
1158 Status = EFI_DEVICE_ERROR;
1159 goto Done;
1160 }
1161
1162 if (MediaChange) {
1163 gBS->ReinstallProtocolInterface (
1164 ScsiDiskDevice->Handle,
1165 &gEfiBlockIoProtocolGuid,
1166 &ScsiDiskDevice->BlkIo,
1167 &ScsiDiskDevice->BlkIo
1168 );
1169 gBS->ReinstallProtocolInterface (
1170 ScsiDiskDevice->Handle,
1171 &gEfiBlockIo2ProtocolGuid,
1172 &ScsiDiskDevice->BlkIo2,
1173 &ScsiDiskDevice->BlkIo2
1174 );
1175 Status = EFI_MEDIA_CHANGED;
1176 goto Done;
1177 }
1178 }
1179
1180 Media = ScsiDiskDevice->BlkIo2.Media;
1181
1182 if (!(Media->MediaPresent)) {
1183 Status = EFI_NO_MEDIA;
1184 goto Done;
1185 }
1186
1187 if (Media->ReadOnly) {
1188 Status = EFI_WRITE_PROTECTED;
1189 goto Done;
1190 }
1191
1192 //
1193 // Wait for the BlockIo2 requests queue to become empty
1194 //
1195 while (!IsListEmpty (&ScsiDiskDevice->BlkIo2Queue));
1196
1197 Status = EFI_SUCCESS;
1198
1199 //
1200 // Signal caller event
1201 //
1202 if ((Token != NULL) && (Token->Event != NULL)) {
1203 Token->TransactionStatus = EFI_SUCCESS;
1204 gBS->SignalEvent (Token->Event);
1205 }
1206
1207 Done:
1208 gBS->RestoreTPL (OldTpl);
1209 return Status;
1210 }
1211
1212
1213 /**
1214 Detect Device and read out capacity ,if error occurs, parse the sense key.
1215
1216 @param ScsiDiskDevice The pointer of SCSI_DISK_DEV
1217 @param MustReadCapacity The flag about reading device capacity
1218 @param MediaChange The pointer of flag indicates if media has changed
1219
1220 @retval EFI_DEVICE_ERROR Indicates that error occurs
1221 @retval EFI_SUCCESS Successfully to detect media
1222
1223 **/
1224 EFI_STATUS
1225 ScsiDiskDetectMedia (
1226 IN SCSI_DISK_DEV *ScsiDiskDevice,
1227 IN BOOLEAN MustReadCapacity,
1228 OUT BOOLEAN *MediaChange
1229 )
1230 {
1231 EFI_STATUS Status;
1232 EFI_SCSI_SENSE_DATA *SenseData;
1233 UINTN NumberOfSenseKeys;
1234 BOOLEAN NeedRetry;
1235 BOOLEAN NeedReadCapacity;
1236 UINT8 Retry;
1237 UINT8 MaxRetry;
1238 EFI_BLOCK_IO_MEDIA OldMedia;
1239 UINTN Action;
1240 EFI_EVENT TimeoutEvt;
1241
1242 Status = EFI_SUCCESS;
1243 SenseData = NULL;
1244 NumberOfSenseKeys = 0;
1245 Retry = 0;
1246 MaxRetry = 3;
1247 Action = ACTION_NO_ACTION;
1248 NeedReadCapacity = FALSE;
1249 *MediaChange = FALSE;
1250 TimeoutEvt = NULL;
1251
1252 CopyMem (&OldMedia, ScsiDiskDevice->BlkIo.Media, sizeof (OldMedia));
1253
1254 Status = gBS->CreateEvent (
1255 EVT_TIMER,
1256 TPL_CALLBACK,
1257 NULL,
1258 NULL,
1259 &TimeoutEvt
1260 );
1261 if (EFI_ERROR (Status)) {
1262 return Status;
1263 }
1264
1265 Status = gBS->SetTimer (TimeoutEvt, TimerRelative, EFI_TIMER_PERIOD_SECONDS(120));
1266 if (EFI_ERROR (Status)) {
1267 goto EXIT;
1268 }
1269
1270 //
1271 // Sending Test_Unit cmd to poll device status.
1272 // If the sense data shows the drive is not ready or reset before, we need poll the device status again.
1273 // We limit the upper boundary to 120 seconds.
1274 //
1275 while (EFI_ERROR (gBS->CheckEvent (TimeoutEvt))) {
1276 Status = ScsiDiskTestUnitReady (
1277 ScsiDiskDevice,
1278 &NeedRetry,
1279 &SenseData,
1280 &NumberOfSenseKeys
1281 );
1282 if (!EFI_ERROR (Status)) {
1283 Status = DetectMediaParsingSenseKeys (
1284 ScsiDiskDevice,
1285 SenseData,
1286 NumberOfSenseKeys,
1287 &Action
1288 );
1289 if (EFI_ERROR (Status)) {
1290 goto EXIT;
1291 } else if (Action == ACTION_RETRY_COMMAND_LATER) {
1292 continue;
1293 } else {
1294 break;
1295 }
1296 } else {
1297 Retry++;
1298 if (!NeedRetry || (Retry >= MaxRetry)) {
1299 goto EXIT;
1300 }
1301 }
1302 }
1303
1304 if (EFI_ERROR (Status)) {
1305 goto EXIT;
1306 }
1307
1308 //
1309 // ACTION_NO_ACTION: need not read capacity
1310 // other action code: need read capacity
1311 //
1312 if (Action == ACTION_READ_CAPACITY) {
1313 NeedReadCapacity = TRUE;
1314 }
1315
1316 //
1317 // either NeedReadCapacity is TRUE, or MustReadCapacity is TRUE,
1318 // retrieve capacity via Read Capacity command
1319 //
1320 if (NeedReadCapacity || MustReadCapacity) {
1321 //
1322 // retrieve media information
1323 //
1324 for (Retry = 0; Retry < MaxRetry; Retry++) {
1325 Status = ScsiDiskReadCapacity (
1326 ScsiDiskDevice,
1327 &NeedRetry,
1328 &SenseData,
1329 &NumberOfSenseKeys
1330 );
1331 if (!EFI_ERROR (Status)) {
1332 //
1333 // analyze sense key to action
1334 //
1335 Status = DetectMediaParsingSenseKeys (
1336 ScsiDiskDevice,
1337 SenseData,
1338 NumberOfSenseKeys,
1339 &Action
1340 );
1341 if (EFI_ERROR (Status)) {
1342 //
1343 // if Status is error, it may indicate crisis error,
1344 // so return without retry.
1345 //
1346 goto EXIT;
1347 } else if (Action == ACTION_RETRY_COMMAND_LATER) {
1348 Retry = 0;
1349 continue;
1350 } else {
1351 break;
1352 }
1353 } else {
1354 Retry++;
1355 if (!NeedRetry || (Retry >= MaxRetry)) {
1356 goto EXIT;
1357 }
1358 }
1359 }
1360
1361 if (EFI_ERROR (Status)) {
1362 goto EXIT;
1363 }
1364 }
1365
1366 if (ScsiDiskDevice->BlkIo.Media->MediaId != OldMedia.MediaId) {
1367 //
1368 // Media change information got from the device
1369 //
1370 *MediaChange = TRUE;
1371 }
1372
1373 if (ScsiDiskDevice->BlkIo.Media->ReadOnly != OldMedia.ReadOnly) {
1374 *MediaChange = TRUE;
1375 ScsiDiskDevice->BlkIo.Media->MediaId += 1;
1376 }
1377
1378 if (ScsiDiskDevice->BlkIo.Media->BlockSize != OldMedia.BlockSize) {
1379 *MediaChange = TRUE;
1380 ScsiDiskDevice->BlkIo.Media->MediaId += 1;
1381 }
1382
1383 if (ScsiDiskDevice->BlkIo.Media->LastBlock != OldMedia.LastBlock) {
1384 *MediaChange = TRUE;
1385 ScsiDiskDevice->BlkIo.Media->MediaId += 1;
1386 }
1387
1388 if (ScsiDiskDevice->BlkIo.Media->MediaPresent != OldMedia.MediaPresent) {
1389 if (ScsiDiskDevice->BlkIo.Media->MediaPresent) {
1390 //
1391 // when change from no media to media present, reset the MediaId to 1.
1392 //
1393 ScsiDiskDevice->BlkIo.Media->MediaId = 1;
1394 } else {
1395 //
1396 // when no media, reset the MediaId to zero.
1397 //
1398 ScsiDiskDevice->BlkIo.Media->MediaId = 0;
1399 }
1400
1401 *MediaChange = TRUE;
1402 }
1403
1404 EXIT:
1405 if (TimeoutEvt != NULL) {
1406 gBS->CloseEvent (TimeoutEvt);
1407 }
1408 return Status;
1409 }
1410
1411
1412 /**
1413 Send out Inquiry command to Device.
1414
1415 @param ScsiDiskDevice The pointer of SCSI_DISK_DEV
1416 @param NeedRetry Indicates if needs try again when error happens
1417
1418 @retval EFI_DEVICE_ERROR Indicates that error occurs
1419 @retval EFI_SUCCESS Successfully to detect media
1420
1421 **/
1422 EFI_STATUS
1423 ScsiDiskInquiryDevice (
1424 IN OUT SCSI_DISK_DEV *ScsiDiskDevice,
1425 OUT BOOLEAN *NeedRetry
1426 )
1427 {
1428 UINT32 InquiryDataLength;
1429 UINT8 SenseDataLength;
1430 UINT8 HostAdapterStatus;
1431 UINT8 TargetStatus;
1432 EFI_SCSI_SENSE_DATA *SenseDataArray;
1433 UINTN NumberOfSenseKeys;
1434 EFI_STATUS Status;
1435 UINT8 MaxRetry;
1436 UINT8 Index;
1437 EFI_SCSI_SUPPORTED_VPD_PAGES_VPD_PAGE *SupportedVpdPages;
1438 EFI_SCSI_BLOCK_LIMITS_VPD_PAGE *BlockLimits;
1439 UINTN PageLength;
1440
1441 InquiryDataLength = sizeof (EFI_SCSI_INQUIRY_DATA);
1442 SenseDataLength = 0;
1443
1444 Status = ScsiInquiryCommand (
1445 ScsiDiskDevice->ScsiIo,
1446 SCSI_DISK_TIMEOUT,
1447 NULL,
1448 &SenseDataLength,
1449 &HostAdapterStatus,
1450 &TargetStatus,
1451 (VOID *) &(ScsiDiskDevice->InquiryData),
1452 &InquiryDataLength,
1453 FALSE
1454 );
1455 //
1456 // no need to check HostAdapterStatus and TargetStatus
1457 //
1458 if ((Status == EFI_SUCCESS) || (Status == EFI_WARN_BUFFER_TOO_SMALL)) {
1459 ParseInquiryData (ScsiDiskDevice);
1460
1461 if (ScsiDiskDevice->DeviceType == EFI_SCSI_TYPE_DISK) {
1462 //
1463 // Check whether the device supports Block Limits VPD page (0xB0)
1464 //
1465 SupportedVpdPages = AllocateAlignedBuffer (ScsiDiskDevice, sizeof (EFI_SCSI_SUPPORTED_VPD_PAGES_VPD_PAGE));
1466 if (SupportedVpdPages == NULL) {
1467 *NeedRetry = FALSE;
1468 return EFI_DEVICE_ERROR;
1469 }
1470 ZeroMem (SupportedVpdPages, sizeof (EFI_SCSI_SUPPORTED_VPD_PAGES_VPD_PAGE));
1471 InquiryDataLength = sizeof (EFI_SCSI_SUPPORTED_VPD_PAGES_VPD_PAGE);
1472 SenseDataLength = 0;
1473 Status = ScsiInquiryCommandEx (
1474 ScsiDiskDevice->ScsiIo,
1475 SCSI_DISK_TIMEOUT,
1476 NULL,
1477 &SenseDataLength,
1478 &HostAdapterStatus,
1479 &TargetStatus,
1480 (VOID *) SupportedVpdPages,
1481 &InquiryDataLength,
1482 TRUE,
1483 EFI_SCSI_PAGE_CODE_SUPPORTED_VPD
1484 );
1485 if (!EFI_ERROR (Status)) {
1486 PageLength = (SupportedVpdPages->PageLength2 << 8)
1487 | SupportedVpdPages->PageLength1;
1488 for (Index = 0; Index < PageLength; Index++) {
1489 if (SupportedVpdPages->SupportedVpdPageList[Index] == EFI_SCSI_PAGE_CODE_BLOCK_LIMITS_VPD) {
1490 break;
1491 }
1492 }
1493
1494 //
1495 // Query the Block Limits VPD page
1496 //
1497 if (Index < PageLength) {
1498 BlockLimits = AllocateAlignedBuffer (ScsiDiskDevice, sizeof (EFI_SCSI_BLOCK_LIMITS_VPD_PAGE));
1499 if (BlockLimits == NULL) {
1500 FreeAlignedBuffer (SupportedVpdPages, sizeof (EFI_SCSI_SUPPORTED_VPD_PAGES_VPD_PAGE));
1501 *NeedRetry = FALSE;
1502 return EFI_DEVICE_ERROR;
1503 }
1504 ZeroMem (BlockLimits, sizeof (EFI_SCSI_BLOCK_LIMITS_VPD_PAGE));
1505 InquiryDataLength = sizeof (EFI_SCSI_BLOCK_LIMITS_VPD_PAGE);
1506 SenseDataLength = 0;
1507 Status = ScsiInquiryCommandEx (
1508 ScsiDiskDevice->ScsiIo,
1509 SCSI_DISK_TIMEOUT,
1510 NULL,
1511 &SenseDataLength,
1512 &HostAdapterStatus,
1513 &TargetStatus,
1514 (VOID *) BlockLimits,
1515 &InquiryDataLength,
1516 TRUE,
1517 EFI_SCSI_PAGE_CODE_BLOCK_LIMITS_VPD
1518 );
1519 if (!EFI_ERROR (Status)) {
1520 ScsiDiskDevice->BlkIo.Media->OptimalTransferLengthGranularity =
1521 (BlockLimits->OptimalTransferLengthGranularity2 << 8) |
1522 BlockLimits->OptimalTransferLengthGranularity1;
1523 }
1524
1525 FreeAlignedBuffer (BlockLimits, sizeof (EFI_SCSI_BLOCK_LIMITS_VPD_PAGE));
1526 }
1527 }
1528
1529 FreeAlignedBuffer (SupportedVpdPages, sizeof (EFI_SCSI_SUPPORTED_VPD_PAGES_VPD_PAGE));
1530 }
1531 }
1532
1533 if (!EFI_ERROR (Status)) {
1534 return EFI_SUCCESS;
1535
1536 } else if (Status == EFI_NOT_READY) {
1537 *NeedRetry = TRUE;
1538 return EFI_DEVICE_ERROR;
1539
1540 } else if ((Status == EFI_INVALID_PARAMETER) || (Status == EFI_UNSUPPORTED)) {
1541 *NeedRetry = FALSE;
1542 return EFI_DEVICE_ERROR;
1543 }
1544 //
1545 // go ahead to check HostAdapterStatus and TargetStatus
1546 // (EFI_TIMEOUT, EFI_DEVICE_ERROR)
1547 //
1548
1549 Status = CheckHostAdapterStatus (HostAdapterStatus);
1550 if ((Status == EFI_TIMEOUT) || (Status == EFI_NOT_READY)) {
1551 *NeedRetry = TRUE;
1552 return EFI_DEVICE_ERROR;
1553 } else if (Status == EFI_DEVICE_ERROR) {
1554 //
1555 // reset the scsi channel
1556 //
1557 ScsiDiskDevice->ScsiIo->ResetBus (ScsiDiskDevice->ScsiIo);
1558 *NeedRetry = FALSE;
1559 return EFI_DEVICE_ERROR;
1560 }
1561
1562 Status = CheckTargetStatus (TargetStatus);
1563 if (Status == EFI_NOT_READY) {
1564 //
1565 // reset the scsi device
1566 //
1567 ScsiDiskDevice->ScsiIo->ResetDevice (ScsiDiskDevice->ScsiIo);
1568 *NeedRetry = TRUE;
1569 return EFI_DEVICE_ERROR;
1570
1571 } else if (Status == EFI_DEVICE_ERROR) {
1572 *NeedRetry = FALSE;
1573 return EFI_DEVICE_ERROR;
1574 }
1575
1576 //
1577 // if goes here, meant ScsiInquiryCommand() failed.
1578 // if ScsiDiskRequestSenseKeys() succeeds at last,
1579 // better retry ScsiInquiryCommand(). (by setting *NeedRetry = TRUE)
1580 //
1581 MaxRetry = 3;
1582 for (Index = 0; Index < MaxRetry; Index++) {
1583 Status = ScsiDiskRequestSenseKeys (
1584 ScsiDiskDevice,
1585 NeedRetry,
1586 &SenseDataArray,
1587 &NumberOfSenseKeys,
1588 TRUE
1589 );
1590 if (!EFI_ERROR (Status)) {
1591 *NeedRetry = TRUE;
1592 return EFI_DEVICE_ERROR;
1593 }
1594
1595 if (!*NeedRetry) {
1596 return EFI_DEVICE_ERROR;
1597 }
1598 }
1599 //
1600 // ScsiDiskRequestSenseKeys() failed after several rounds of retry.
1601 // set *NeedRetry = FALSE to avoid the outside caller try again.
1602 //
1603 *NeedRetry = FALSE;
1604 return EFI_DEVICE_ERROR;
1605 }
1606
1607 /**
1608 To test device.
1609
1610 When Test Unit Ready command succeeds, retrieve Sense Keys via Request Sense;
1611 When Test Unit Ready command encounters any error caused by host adapter or
1612 target, return error without retrieving Sense Keys.
1613
1614 @param ScsiDiskDevice The pointer of SCSI_DISK_DEV
1615 @param NeedRetry The pointer of flag indicates try again
1616 @param SenseDataArray The pointer of an array of sense data
1617 @param NumberOfSenseKeys The pointer of the number of sense data array
1618
1619 @retval EFI_DEVICE_ERROR Indicates that error occurs
1620 @retval EFI_SUCCESS Successfully to test unit
1621
1622 **/
1623 EFI_STATUS
1624 ScsiDiskTestUnitReady (
1625 IN SCSI_DISK_DEV *ScsiDiskDevice,
1626 OUT BOOLEAN *NeedRetry,
1627 OUT EFI_SCSI_SENSE_DATA **SenseDataArray,
1628 OUT UINTN *NumberOfSenseKeys
1629 )
1630 {
1631 EFI_STATUS Status;
1632 UINT8 SenseDataLength;
1633 UINT8 HostAdapterStatus;
1634 UINT8 TargetStatus;
1635 UINT8 Index;
1636 UINT8 MaxRetry;
1637
1638 SenseDataLength = (UINT8) (ScsiDiskDevice->SenseDataNumber * sizeof (EFI_SCSI_SENSE_DATA));
1639 *NumberOfSenseKeys = 0;
1640
1641 //
1642 // Parameter 3 and 4: do not require sense data, retrieve it when needed.
1643 //
1644 Status = ScsiTestUnitReadyCommand (
1645 ScsiDiskDevice->ScsiIo,
1646 SCSI_DISK_TIMEOUT,
1647 ScsiDiskDevice->SenseData,
1648 &SenseDataLength,
1649 &HostAdapterStatus,
1650 &TargetStatus
1651 );
1652 //
1653 // no need to check HostAdapterStatus and TargetStatus
1654 //
1655 if (Status == EFI_NOT_READY) {
1656 *NeedRetry = TRUE;
1657 return EFI_DEVICE_ERROR;
1658
1659 } else if ((Status == EFI_INVALID_PARAMETER) || (Status == EFI_UNSUPPORTED)) {
1660 *NeedRetry = FALSE;
1661 return EFI_DEVICE_ERROR;
1662 }
1663 //
1664 // go ahead to check HostAdapterStatus and TargetStatus(in case of EFI_DEVICE_ERROR)
1665 //
1666
1667 Status = CheckHostAdapterStatus (HostAdapterStatus);
1668 if ((Status == EFI_TIMEOUT) || (Status == EFI_NOT_READY)) {
1669 *NeedRetry = TRUE;
1670 return EFI_DEVICE_ERROR;
1671
1672 } else if (Status == EFI_DEVICE_ERROR) {
1673 //
1674 // reset the scsi channel
1675 //
1676 ScsiDiskDevice->ScsiIo->ResetBus (ScsiDiskDevice->ScsiIo);
1677 *NeedRetry = FALSE;
1678 return EFI_DEVICE_ERROR;
1679 }
1680
1681 Status = CheckTargetStatus (TargetStatus);
1682 if (Status == EFI_NOT_READY) {
1683 //
1684 // reset the scsi device
1685 //
1686 ScsiDiskDevice->ScsiIo->ResetDevice (ScsiDiskDevice->ScsiIo);
1687 *NeedRetry = TRUE;
1688 return EFI_DEVICE_ERROR;
1689
1690 } else if (Status == EFI_DEVICE_ERROR) {
1691 *NeedRetry = FALSE;
1692 return EFI_DEVICE_ERROR;
1693 }
1694
1695 if (SenseDataLength != 0) {
1696 *NumberOfSenseKeys = SenseDataLength / sizeof (EFI_SCSI_SENSE_DATA);
1697 *SenseDataArray = ScsiDiskDevice->SenseData;
1698 return EFI_SUCCESS;
1699 }
1700
1701 MaxRetry = 3;
1702 for (Index = 0; Index < MaxRetry; Index++) {
1703 Status = ScsiDiskRequestSenseKeys (
1704 ScsiDiskDevice,
1705 NeedRetry,
1706 SenseDataArray,
1707 NumberOfSenseKeys,
1708 FALSE
1709 );
1710 if (!EFI_ERROR (Status)) {
1711 return EFI_SUCCESS;
1712 }
1713
1714 if (!*NeedRetry) {
1715 return EFI_DEVICE_ERROR;
1716 }
1717 }
1718 //
1719 // ScsiDiskRequestSenseKeys() failed after several rounds of retry.
1720 // set *NeedRetry = FALSE to avoid the outside caller try again.
1721 //
1722 *NeedRetry = FALSE;
1723 return EFI_DEVICE_ERROR;
1724 }
1725
1726 /**
1727 Parsing Sense Keys which got from request sense command.
1728
1729 @param ScsiDiskDevice The pointer of SCSI_DISK_DEV
1730 @param SenseData The pointer of EFI_SCSI_SENSE_DATA
1731 @param NumberOfSenseKeys The number of sense key
1732 @param Action The pointer of action which indicates what is need to do next
1733
1734 @retval EFI_DEVICE_ERROR Indicates that error occurs
1735 @retval EFI_SUCCESS Successfully to complete the parsing
1736
1737 **/
1738 EFI_STATUS
1739 DetectMediaParsingSenseKeys (
1740 OUT SCSI_DISK_DEV *ScsiDiskDevice,
1741 IN EFI_SCSI_SENSE_DATA *SenseData,
1742 IN UINTN NumberOfSenseKeys,
1743 OUT UINTN *Action
1744 )
1745 {
1746 BOOLEAN RetryLater;
1747
1748 //
1749 // Default is to read capacity, unless..
1750 //
1751 *Action = ACTION_READ_CAPACITY;
1752
1753 if (NumberOfSenseKeys == 0) {
1754 if (ScsiDiskDevice->BlkIo.Media->MediaPresent == TRUE) {
1755 *Action = ACTION_NO_ACTION;
1756 }
1757 return EFI_SUCCESS;
1758 }
1759
1760 if (!ScsiDiskHaveSenseKey (SenseData, NumberOfSenseKeys)) {
1761 //
1762 // No Sense Key returned from last submitted command
1763 //
1764 if (ScsiDiskDevice->BlkIo.Media->MediaPresent == TRUE) {
1765 *Action = ACTION_NO_ACTION;
1766 }
1767 return EFI_SUCCESS;
1768 }
1769
1770 if (ScsiDiskIsNoMedia (SenseData, NumberOfSenseKeys)) {
1771 ScsiDiskDevice->BlkIo.Media->MediaPresent = FALSE;
1772 ScsiDiskDevice->BlkIo.Media->LastBlock = 0;
1773 *Action = ACTION_NO_ACTION;
1774 DEBUG ((EFI_D_VERBOSE, "ScsiDisk: ScsiDiskIsNoMedia\n"));
1775 return EFI_SUCCESS;
1776 }
1777
1778 if (ScsiDiskIsMediaChange (SenseData, NumberOfSenseKeys)) {
1779 ScsiDiskDevice->BlkIo.Media->MediaId++;
1780 DEBUG ((EFI_D_VERBOSE, "ScsiDisk: ScsiDiskIsMediaChange!\n"));
1781 return EFI_SUCCESS;
1782 }
1783
1784 if (ScsiDiskIsResetBefore (SenseData, NumberOfSenseKeys)) {
1785 *Action = ACTION_RETRY_COMMAND_LATER;
1786 DEBUG ((EFI_D_VERBOSE, "ScsiDisk: ScsiDiskIsResetBefore!\n"));
1787 return EFI_SUCCESS;
1788 }
1789
1790 if (ScsiDiskIsMediaError (SenseData, NumberOfSenseKeys)) {
1791 DEBUG ((EFI_D_VERBOSE, "ScsiDisk: ScsiDiskIsMediaError\n"));
1792 *Action = ACTION_RETRY_WITH_BACKOFF_ALGO;
1793 return EFI_DEVICE_ERROR;
1794 }
1795
1796 if (ScsiDiskIsHardwareError (SenseData, NumberOfSenseKeys)) {
1797 DEBUG ((EFI_D_VERBOSE, "ScsiDisk: ScsiDiskIsHardwareError\n"));
1798 *Action = ACTION_RETRY_WITH_BACKOFF_ALGO;
1799 return EFI_DEVICE_ERROR;
1800 }
1801
1802 if (!ScsiDiskIsDriveReady (SenseData, NumberOfSenseKeys, &RetryLater)) {
1803 if (RetryLater) {
1804 *Action = ACTION_RETRY_COMMAND_LATER;
1805 DEBUG ((EFI_D_VERBOSE, "ScsiDisk: ScsiDiskDriveNotReady!\n"));
1806 return EFI_SUCCESS;
1807 }
1808 *Action = ACTION_NO_ACTION;
1809 return EFI_DEVICE_ERROR;
1810 }
1811
1812 *Action = ACTION_RETRY_WITH_BACKOFF_ALGO;
1813 DEBUG ((EFI_D_VERBOSE, "ScsiDisk: Sense Key = 0x%x ASC = 0x%x!\n", SenseData->Sense_Key, SenseData->Addnl_Sense_Code));
1814 return EFI_SUCCESS;
1815 }
1816
1817
1818 /**
1819 Send read capacity command to device and get the device parameter.
1820
1821 @param ScsiDiskDevice The pointer of SCSI_DISK_DEV
1822 @param NeedRetry The pointer of flag indicates if need a retry
1823 @param SenseDataArray The pointer of an array of sense data
1824 @param NumberOfSenseKeys The number of sense key
1825
1826 @retval EFI_DEVICE_ERROR Indicates that error occurs
1827 @retval EFI_SUCCESS Successfully to read capacity or sense data is received.
1828
1829 **/
1830 EFI_STATUS
1831 ScsiDiskReadCapacity (
1832 IN OUT SCSI_DISK_DEV *ScsiDiskDevice,
1833 OUT BOOLEAN *NeedRetry,
1834 OUT EFI_SCSI_SENSE_DATA **SenseDataArray,
1835 OUT UINTN *NumberOfSenseKeys
1836 )
1837 {
1838 UINT8 HostAdapterStatus;
1839 UINT8 TargetStatus;
1840 EFI_STATUS CommandStatus;
1841 EFI_STATUS Status;
1842 UINT8 Index;
1843 UINT8 MaxRetry;
1844 UINT8 SenseDataLength;
1845 UINT32 DataLength10;
1846 UINT32 DataLength16;
1847 EFI_SCSI_DISK_CAPACITY_DATA *CapacityData10;
1848 EFI_SCSI_DISK_CAPACITY_DATA16 *CapacityData16;
1849
1850 CapacityData10 = AllocateAlignedBuffer (ScsiDiskDevice, sizeof (EFI_SCSI_DISK_CAPACITY_DATA));
1851 if (CapacityData10 == NULL) {
1852 *NeedRetry = FALSE;
1853 return EFI_DEVICE_ERROR;
1854 }
1855 CapacityData16 = AllocateAlignedBuffer (ScsiDiskDevice, sizeof (EFI_SCSI_DISK_CAPACITY_DATA16));
1856 if (CapacityData16 == NULL) {
1857 FreeAlignedBuffer (CapacityData10, sizeof (EFI_SCSI_DISK_CAPACITY_DATA));
1858 *NeedRetry = FALSE;
1859 return EFI_DEVICE_ERROR;
1860 }
1861
1862 SenseDataLength = 0;
1863 DataLength10 = sizeof (EFI_SCSI_DISK_CAPACITY_DATA);
1864 DataLength16 = sizeof (EFI_SCSI_DISK_CAPACITY_DATA16);
1865 ZeroMem (CapacityData10, sizeof (EFI_SCSI_DISK_CAPACITY_DATA));
1866 ZeroMem (CapacityData16, sizeof (EFI_SCSI_DISK_CAPACITY_DATA16));
1867
1868 *NumberOfSenseKeys = 0;
1869 *NeedRetry = FALSE;
1870
1871 //
1872 // submit Read Capacity(10) Command. If it returns capacity of FFFFFFFFh,
1873 // 16 byte command should be used to access large hard disk >2TB
1874 //
1875 CommandStatus = ScsiReadCapacityCommand (
1876 ScsiDiskDevice->ScsiIo,
1877 SCSI_DISK_TIMEOUT,
1878 NULL,
1879 &SenseDataLength,
1880 &HostAdapterStatus,
1881 &TargetStatus,
1882 (VOID *) CapacityData10,
1883 &DataLength10,
1884 FALSE
1885 );
1886
1887 ScsiDiskDevice->Cdb16Byte = FALSE;
1888 if ((!EFI_ERROR (CommandStatus)) && (CapacityData10->LastLba3 == 0xff) && (CapacityData10->LastLba2 == 0xff) &&
1889 (CapacityData10->LastLba1 == 0xff) && (CapacityData10->LastLba0 == 0xff)) {
1890 //
1891 // use Read Capacity (16), Read (16) and Write (16) next when hard disk size > 2TB
1892 //
1893 ScsiDiskDevice->Cdb16Byte = TRUE;
1894 //
1895 // submit Read Capacity(16) Command to get parameter LogicalBlocksPerPhysicalBlock
1896 // and LowestAlignedLba
1897 //
1898 CommandStatus = ScsiReadCapacity16Command (
1899 ScsiDiskDevice->ScsiIo,
1900 SCSI_DISK_TIMEOUT,
1901 NULL,
1902 &SenseDataLength,
1903 &HostAdapterStatus,
1904 &TargetStatus,
1905 (VOID *) CapacityData16,
1906 &DataLength16,
1907 FALSE
1908 );
1909 }
1910
1911 //
1912 // no need to check HostAdapterStatus and TargetStatus
1913 //
1914 if (CommandStatus == EFI_SUCCESS) {
1915 GetMediaInfo (ScsiDiskDevice, CapacityData10, CapacityData16);
1916 FreeAlignedBuffer (CapacityData10, sizeof (EFI_SCSI_DISK_CAPACITY_DATA));
1917 FreeAlignedBuffer (CapacityData16, sizeof (EFI_SCSI_DISK_CAPACITY_DATA16));
1918 return EFI_SUCCESS;
1919 }
1920
1921 FreeAlignedBuffer (CapacityData10, sizeof (EFI_SCSI_DISK_CAPACITY_DATA));
1922 FreeAlignedBuffer (CapacityData16, sizeof (EFI_SCSI_DISK_CAPACITY_DATA16));
1923
1924 if (CommandStatus == EFI_NOT_READY) {
1925 *NeedRetry = TRUE;
1926 return EFI_DEVICE_ERROR;
1927 } else if ((CommandStatus == EFI_INVALID_PARAMETER) || (CommandStatus == EFI_UNSUPPORTED)) {
1928 *NeedRetry = FALSE;
1929 return EFI_DEVICE_ERROR;
1930 }
1931
1932 //
1933 // go ahead to check HostAdapterStatus and TargetStatus
1934 // (EFI_TIMEOUT, EFI_DEVICE_ERROR, EFI_WARN_BUFFER_TOO_SMALL)
1935 //
1936
1937 Status = CheckHostAdapterStatus (HostAdapterStatus);
1938 if ((Status == EFI_TIMEOUT) || (Status == EFI_NOT_READY)) {
1939 *NeedRetry = TRUE;
1940 return EFI_DEVICE_ERROR;
1941
1942 } else if (Status == EFI_DEVICE_ERROR) {
1943 //
1944 // reset the scsi channel
1945 //
1946 ScsiDiskDevice->ScsiIo->ResetBus (ScsiDiskDevice->ScsiIo);
1947 *NeedRetry = FALSE;
1948 return EFI_DEVICE_ERROR;
1949 }
1950
1951 Status = CheckTargetStatus (TargetStatus);
1952 if (Status == EFI_NOT_READY) {
1953 //
1954 // reset the scsi device
1955 //
1956 ScsiDiskDevice->ScsiIo->ResetDevice (ScsiDiskDevice->ScsiIo);
1957 *NeedRetry = TRUE;
1958 return EFI_DEVICE_ERROR;
1959
1960 } else if (Status == EFI_DEVICE_ERROR) {
1961 *NeedRetry = FALSE;
1962 return EFI_DEVICE_ERROR;
1963 }
1964
1965 //
1966 // if goes here, meant ScsiReadCapacityCommand() failed.
1967 // if ScsiDiskRequestSenseKeys() succeeds at last,
1968 // better retry ScsiReadCapacityCommand(). (by setting *NeedRetry = TRUE)
1969 //
1970 MaxRetry = 3;
1971 for (Index = 0; Index < MaxRetry; Index++) {
1972
1973 Status = ScsiDiskRequestSenseKeys (
1974 ScsiDiskDevice,
1975 NeedRetry,
1976 SenseDataArray,
1977 NumberOfSenseKeys,
1978 TRUE
1979 );
1980 if (!EFI_ERROR (Status)) {
1981 return EFI_SUCCESS;
1982 }
1983
1984 if (!*NeedRetry) {
1985 return EFI_DEVICE_ERROR;
1986 }
1987 }
1988 //
1989 // ScsiDiskRequestSenseKeys() failed after several rounds of retry.
1990 // set *NeedRetry = FALSE to avoid the outside caller try again.
1991 //
1992 *NeedRetry = FALSE;
1993 return EFI_DEVICE_ERROR;
1994 }
1995
1996 /**
1997 Check the HostAdapter status and re-interpret it in EFI_STATUS.
1998
1999 @param HostAdapterStatus Host Adapter status
2000
2001 @retval EFI_SUCCESS Host adapter is OK.
2002 @retval EFI_TIMEOUT Timeout.
2003 @retval EFI_NOT_READY Adapter NOT ready.
2004 @retval EFI_DEVICE_ERROR Adapter device error.
2005
2006 **/
2007 EFI_STATUS
2008 CheckHostAdapterStatus (
2009 IN UINT8 HostAdapterStatus
2010 )
2011 {
2012 switch (HostAdapterStatus) {
2013 case EFI_EXT_SCSI_STATUS_HOST_ADAPTER_OK:
2014 return EFI_SUCCESS;
2015
2016 case EFI_EXT_SCSI_STATUS_HOST_ADAPTER_SELECTION_TIMEOUT:
2017 case EFI_EXT_SCSI_STATUS_HOST_ADAPTER_TIMEOUT:
2018 case EFI_EXT_SCSI_STATUS_HOST_ADAPTER_TIMEOUT_COMMAND:
2019 return EFI_TIMEOUT;
2020
2021 case EFI_EXT_SCSI_STATUS_HOST_ADAPTER_MESSAGE_REJECT:
2022 case EFI_EXT_SCSI_STATUS_HOST_ADAPTER_PARITY_ERROR:
2023 case EFI_EXT_SCSI_STATUS_HOST_ADAPTER_REQUEST_SENSE_FAILED:
2024 case EFI_EXT_SCSI_STATUS_HOST_ADAPTER_DATA_OVERRUN_UNDERRUN:
2025 case EFI_EXT_SCSI_STATUS_HOST_ADAPTER_BUS_RESET:
2026 return EFI_NOT_READY;
2027
2028 case EFI_EXT_SCSI_STATUS_HOST_ADAPTER_BUS_FREE:
2029 case EFI_EXT_SCSI_STATUS_HOST_ADAPTER_PHASE_ERROR:
2030 return EFI_DEVICE_ERROR;
2031
2032 default:
2033 return EFI_SUCCESS;
2034 }
2035 }
2036
2037
2038 /**
2039 Check the target status and re-interpret it in EFI_STATUS.
2040
2041 @param TargetStatus Target status
2042
2043 @retval EFI_NOT_READY Device is NOT ready.
2044 @retval EFI_DEVICE_ERROR
2045 @retval EFI_SUCCESS
2046
2047 **/
2048 EFI_STATUS
2049 CheckTargetStatus (
2050 IN UINT8 TargetStatus
2051 )
2052 {
2053 switch (TargetStatus) {
2054 case EFI_EXT_SCSI_STATUS_TARGET_GOOD:
2055 case EFI_EXT_SCSI_STATUS_TARGET_CHECK_CONDITION:
2056 case EFI_EXT_SCSI_STATUS_TARGET_CONDITION_MET:
2057 return EFI_SUCCESS;
2058
2059 case EFI_EXT_SCSI_STATUS_TARGET_INTERMEDIATE:
2060 case EFI_EXT_SCSI_STATUS_TARGET_INTERMEDIATE_CONDITION_MET:
2061 case EFI_EXT_SCSI_STATUS_TARGET_BUSY:
2062 case EFI_EXT_SCSI_STATUS_TARGET_TASK_SET_FULL:
2063 return EFI_NOT_READY;
2064
2065 case EFI_EXT_SCSI_STATUS_TARGET_RESERVATION_CONFLICT:
2066 return EFI_DEVICE_ERROR;
2067
2068 default:
2069 return EFI_SUCCESS;
2070 }
2071 }
2072
2073
2074 /**
2075 Retrieve all sense keys from the device.
2076
2077 When encountering error during the process, if retrieve sense keys before
2078 error encountered, it returns the sense keys with return status set to EFI_SUCCESS,
2079 and NeedRetry set to FALSE; otherwize, return the proper return status.
2080
2081 @param ScsiDiskDevice The pointer of SCSI_DISK_DEV
2082 @param NeedRetry The pointer of flag indicates if need a retry
2083 @param SenseDataArray The pointer of an array of sense data
2084 @param NumberOfSenseKeys The number of sense key
2085 @param AskResetIfError The flag indicates if need reset when error occurs
2086
2087 @retval EFI_DEVICE_ERROR Indicates that error occurs
2088 @retval EFI_SUCCESS Successfully to request sense key
2089
2090 **/
2091 EFI_STATUS
2092 ScsiDiskRequestSenseKeys (
2093 IN OUT SCSI_DISK_DEV *ScsiDiskDevice,
2094 OUT BOOLEAN *NeedRetry,
2095 OUT EFI_SCSI_SENSE_DATA **SenseDataArray,
2096 OUT UINTN *NumberOfSenseKeys,
2097 IN BOOLEAN AskResetIfError
2098 )
2099 {
2100 EFI_SCSI_SENSE_DATA *PtrSenseData;
2101 UINT8 SenseDataLength;
2102 BOOLEAN SenseReq;
2103 EFI_STATUS Status;
2104 EFI_STATUS FallStatus;
2105 UINT8 HostAdapterStatus;
2106 UINT8 TargetStatus;
2107
2108 FallStatus = EFI_SUCCESS;
2109 SenseDataLength = (UINT8) sizeof (EFI_SCSI_SENSE_DATA);
2110
2111 ZeroMem (
2112 ScsiDiskDevice->SenseData,
2113 sizeof (EFI_SCSI_SENSE_DATA) * (ScsiDiskDevice->SenseDataNumber)
2114 );
2115
2116 *NumberOfSenseKeys = 0;
2117 *SenseDataArray = ScsiDiskDevice->SenseData;
2118 Status = EFI_SUCCESS;
2119 PtrSenseData = AllocateAlignedBuffer (ScsiDiskDevice, sizeof (EFI_SCSI_SENSE_DATA));
2120 if (PtrSenseData == NULL) {
2121 return EFI_DEVICE_ERROR;
2122 }
2123
2124 for (SenseReq = TRUE; SenseReq;) {
2125 ZeroMem (PtrSenseData, sizeof (EFI_SCSI_SENSE_DATA));
2126 Status = ScsiRequestSenseCommand (
2127 ScsiDiskDevice->ScsiIo,
2128 SCSI_DISK_TIMEOUT,
2129 PtrSenseData,
2130 &SenseDataLength,
2131 &HostAdapterStatus,
2132 &TargetStatus
2133 );
2134 if ((Status == EFI_SUCCESS) || (Status == EFI_WARN_BUFFER_TOO_SMALL)) {
2135 FallStatus = EFI_SUCCESS;
2136
2137 } else if ((Status == EFI_TIMEOUT) || (Status == EFI_NOT_READY)) {
2138 *NeedRetry = TRUE;
2139 FallStatus = EFI_DEVICE_ERROR;
2140
2141 } else if ((Status == EFI_INVALID_PARAMETER) || (Status == EFI_UNSUPPORTED)) {
2142 *NeedRetry = FALSE;
2143 FallStatus = EFI_DEVICE_ERROR;
2144
2145 } else if (Status == EFI_DEVICE_ERROR) {
2146 if (AskResetIfError) {
2147 ScsiDiskDevice->ScsiIo->ResetDevice (ScsiDiskDevice->ScsiIo);
2148 }
2149
2150 FallStatus = EFI_DEVICE_ERROR;
2151 }
2152
2153 if (EFI_ERROR (FallStatus)) {
2154 if (*NumberOfSenseKeys != 0) {
2155 *NeedRetry = FALSE;
2156 Status = EFI_SUCCESS;
2157 goto EXIT;
2158 } else {
2159 Status = EFI_DEVICE_ERROR;
2160 goto EXIT;
2161 }
2162 }
2163
2164 CopyMem (ScsiDiskDevice->SenseData + *NumberOfSenseKeys, PtrSenseData, SenseDataLength);
2165 (*NumberOfSenseKeys) += 1;
2166
2167 //
2168 // no more sense key or number of sense keys exceeds predefined,
2169 // skip the loop.
2170 //
2171 if ((PtrSenseData->Sense_Key == EFI_SCSI_SK_NO_SENSE) ||
2172 (*NumberOfSenseKeys == ScsiDiskDevice->SenseDataNumber)) {
2173 SenseReq = FALSE;
2174 }
2175 }
2176
2177 EXIT:
2178 FreeAlignedBuffer (PtrSenseData, sizeof (EFI_SCSI_SENSE_DATA));
2179 return Status;
2180 }
2181
2182
2183 /**
2184 Get information from media read capacity command.
2185
2186 @param ScsiDiskDevice The pointer of SCSI_DISK_DEV
2187 @param Capacity10 The pointer of EFI_SCSI_DISK_CAPACITY_DATA
2188 @param Capacity16 The pointer of EFI_SCSI_DISK_CAPACITY_DATA16
2189
2190 **/
2191 VOID
2192 GetMediaInfo (
2193 IN OUT SCSI_DISK_DEV *ScsiDiskDevice,
2194 IN EFI_SCSI_DISK_CAPACITY_DATA *Capacity10,
2195 IN EFI_SCSI_DISK_CAPACITY_DATA16 *Capacity16
2196 )
2197 {
2198 UINT8 *Ptr;
2199
2200 if (!ScsiDiskDevice->Cdb16Byte) {
2201 ScsiDiskDevice->BlkIo.Media->LastBlock = (Capacity10->LastLba3 << 24) |
2202 (Capacity10->LastLba2 << 16) |
2203 (Capacity10->LastLba1 << 8) |
2204 Capacity10->LastLba0;
2205
2206 ScsiDiskDevice->BlkIo.Media->BlockSize = (Capacity10->BlockSize3 << 24) |
2207 (Capacity10->BlockSize2 << 16) |
2208 (Capacity10->BlockSize1 << 8) |
2209 Capacity10->BlockSize0;
2210 ScsiDiskDevice->BlkIo.Media->LowestAlignedLba = 0;
2211 ScsiDiskDevice->BlkIo.Media->LogicalBlocksPerPhysicalBlock = 0;
2212 } else {
2213 Ptr = (UINT8*)&ScsiDiskDevice->BlkIo.Media->LastBlock;
2214 *Ptr++ = Capacity16->LastLba0;
2215 *Ptr++ = Capacity16->LastLba1;
2216 *Ptr++ = Capacity16->LastLba2;
2217 *Ptr++ = Capacity16->LastLba3;
2218 *Ptr++ = Capacity16->LastLba4;
2219 *Ptr++ = Capacity16->LastLba5;
2220 *Ptr++ = Capacity16->LastLba6;
2221 *Ptr = Capacity16->LastLba7;
2222
2223 ScsiDiskDevice->BlkIo.Media->BlockSize = (Capacity16->BlockSize3 << 24) |
2224 (Capacity16->BlockSize2 << 16) |
2225 (Capacity16->BlockSize1 << 8) |
2226 Capacity16->BlockSize0;
2227
2228 ScsiDiskDevice->BlkIo.Media->LowestAlignedLba = (Capacity16->LowestAlignLogic2 << 8) |
2229 Capacity16->LowestAlignLogic1;
2230 ScsiDiskDevice->BlkIo.Media->LogicalBlocksPerPhysicalBlock = (1 << Capacity16->LogicPerPhysical);
2231 }
2232
2233 ScsiDiskDevice->BlkIo.Media->MediaPresent = TRUE;
2234 }
2235
2236 /**
2237 Parse Inquiry data.
2238
2239 @param ScsiDiskDevice The pointer of SCSI_DISK_DEV
2240
2241 **/
2242 VOID
2243 ParseInquiryData (
2244 IN OUT SCSI_DISK_DEV *ScsiDiskDevice
2245 )
2246 {
2247 ScsiDiskDevice->FixedDevice = (BOOLEAN) ((ScsiDiskDevice->InquiryData.Rmb == 1) ? 0 : 1);
2248 ScsiDiskDevice->BlkIoMedia.RemovableMedia = (BOOLEAN) (!ScsiDiskDevice->FixedDevice);
2249 }
2250
2251 /**
2252 Read sector from SCSI Disk.
2253
2254 @param ScsiDiskDevice The pointer of SCSI_DISK_DEV
2255 @param Buffer The buffer to fill in the read out data
2256 @param Lba Logic block address
2257 @param NumberOfBlocks The number of blocks to read
2258
2259 @retval EFI_DEVICE_ERROR Indicates a device error.
2260 @retval EFI_SUCCESS Operation is successful.
2261
2262 **/
2263 EFI_STATUS
2264 ScsiDiskReadSectors (
2265 IN SCSI_DISK_DEV *ScsiDiskDevice,
2266 OUT VOID *Buffer,
2267 IN EFI_LBA Lba,
2268 IN UINTN NumberOfBlocks
2269 )
2270 {
2271 UINTN BlocksRemaining;
2272 UINT8 *PtrBuffer;
2273 UINT32 BlockSize;
2274 UINT32 ByteCount;
2275 UINT32 MaxBlock;
2276 UINT32 SectorCount;
2277 UINT32 NextSectorCount;
2278 UINT64 Timeout;
2279 EFI_STATUS Status;
2280 UINT8 Index;
2281 UINT8 MaxRetry;
2282 BOOLEAN NeedRetry;
2283
2284 Status = EFI_SUCCESS;
2285
2286 BlocksRemaining = NumberOfBlocks;
2287 BlockSize = ScsiDiskDevice->BlkIo.Media->BlockSize;
2288
2289 //
2290 // limit the data bytes that can be transferred by one Read(10) or Read(16) Command
2291 //
2292 if (!ScsiDiskDevice->Cdb16Byte) {
2293 MaxBlock = 0xFFFF;
2294 } else {
2295 MaxBlock = 0xFFFFFFFF;
2296 }
2297
2298 PtrBuffer = Buffer;
2299
2300 while (BlocksRemaining > 0) {
2301
2302 if (BlocksRemaining <= MaxBlock) {
2303 if (!ScsiDiskDevice->Cdb16Byte) {
2304 SectorCount = (UINT16) BlocksRemaining;
2305 } else {
2306 SectorCount = (UINT32) BlocksRemaining;
2307 }
2308 } else {
2309 SectorCount = MaxBlock;
2310 }
2311
2312 ByteCount = SectorCount * BlockSize;
2313 //
2314 // |------------------------|-----------------|------------------|-----------------|
2315 // | ATA Transfer Mode | Transfer Rate | SCSI Interface | Transfer Rate |
2316 // |------------------------|-----------------|------------------|-----------------|
2317 // | PIO Mode 0 | 3.3Mbytes/sec | SCSI-1 | 5Mbytes/sec |
2318 // |------------------------|-----------------|------------------|-----------------|
2319 // | PIO Mode 1 | 5.2Mbytes/sec | Fast SCSI | 10Mbytes/sec |
2320 // |------------------------|-----------------|------------------|-----------------|
2321 // | PIO Mode 2 | 8.3Mbytes/sec | Fast-Wide SCSI | 20Mbytes/sec |
2322 // |------------------------|-----------------|------------------|-----------------|
2323 // | PIO Mode 3 | 11.1Mbytes/sec | Ultra SCSI | 20Mbytes/sec |
2324 // |------------------------|-----------------|------------------|-----------------|
2325 // | PIO Mode 4 | 16.6Mbytes/sec | Ultra Wide SCSI | 40Mbytes/sec |
2326 // |------------------------|-----------------|------------------|-----------------|
2327 // | Single-word DMA Mode 0 | 2.1Mbytes/sec | Ultra2 SCSI | 40Mbytes/sec |
2328 // |------------------------|-----------------|------------------|-----------------|
2329 // | Single-word DMA Mode 1 | 4.2Mbytes/sec | Ultra2 Wide SCSI | 80Mbytes/sec |
2330 // |------------------------|-----------------|------------------|-----------------|
2331 // | Single-word DMA Mode 2 | 8.4Mbytes/sec | Ultra3 SCSI | 160Mbytes/sec |
2332 // |------------------------|-----------------|------------------|-----------------|
2333 // | Multi-word DMA Mode 0 | 4.2Mbytes/sec | Ultra-320 SCSI | 320Mbytes/sec |
2334 // |------------------------|-----------------|------------------|-----------------|
2335 // | Multi-word DMA Mode 1 | 13.3Mbytes/sec | Ultra-640 SCSI | 640Mbytes/sec |
2336 // |------------------------|-----------------|------------------|-----------------|
2337 //
2338 // As ScsiDisk and ScsiBus driver are used to manage SCSI or ATAPI devices, we have to use
2339 // the lowest transfer rate to calculate the possible maximum timeout value for each operation.
2340 // From the above table, we could know 2.1Mbytes per second is lowest one.
2341 // The timout value is rounded up to nearest integar and here an additional 30s is added
2342 // to follow ATA spec in which it mentioned that the device may take up to 30s to respond
2343 // commands in the Standby/Idle mode.
2344 //
2345 Timeout = EFI_TIMER_PERIOD_SECONDS (ByteCount / 2100000 + 31);
2346
2347 MaxRetry = 2;
2348 for (Index = 0; Index < MaxRetry; Index++) {
2349 if (!ScsiDiskDevice->Cdb16Byte) {
2350 Status = ScsiDiskRead10 (
2351 ScsiDiskDevice,
2352 &NeedRetry,
2353 Timeout,
2354 PtrBuffer,
2355 &ByteCount,
2356 (UINT32) Lba,
2357 SectorCount
2358 );
2359 } else {
2360 Status = ScsiDiskRead16 (
2361 ScsiDiskDevice,
2362 &NeedRetry,
2363 Timeout,
2364 PtrBuffer,
2365 &ByteCount,
2366 Lba,
2367 SectorCount
2368 );
2369 }
2370 if (!EFI_ERROR (Status)) {
2371 break;
2372 }
2373
2374 if (!NeedRetry) {
2375 return EFI_DEVICE_ERROR;
2376 }
2377
2378 //
2379 // We need to retry. However, if ScsiDiskRead10() or ScsiDiskRead16() has
2380 // lowered ByteCount on output, we must make sure that we lower
2381 // SectorCount accordingly. SectorCount will be encoded in the CDB, and
2382 // it is invalid to request more sectors in the CDB than the entire
2383 // transfer (ie. ByteCount) can carry.
2384 //
2385 // In addition, ByteCount is only expected to go down, or stay unchaged.
2386 // Therefore we don't need to update Timeout: the original timeout should
2387 // accommodate shorter transfers too.
2388 //
2389 NextSectorCount = ByteCount / BlockSize;
2390 if (NextSectorCount < SectorCount) {
2391 SectorCount = NextSectorCount;
2392 //
2393 // Account for any rounding down.
2394 //
2395 ByteCount = SectorCount * BlockSize;
2396 }
2397 }
2398
2399 if ((Index == MaxRetry) && (Status != EFI_SUCCESS)) {
2400 return EFI_DEVICE_ERROR;
2401 }
2402
2403 //
2404 // actual transferred sectors
2405 //
2406 SectorCount = ByteCount / BlockSize;
2407
2408 Lba += SectorCount;
2409 PtrBuffer = PtrBuffer + SectorCount * BlockSize;
2410 BlocksRemaining -= SectorCount;
2411 }
2412
2413 return EFI_SUCCESS;
2414 }
2415
2416 /**
2417 Write sector to SCSI Disk.
2418
2419 @param ScsiDiskDevice The pointer of SCSI_DISK_DEV
2420 @param Buffer The buffer of data to be written into SCSI Disk
2421 @param Lba Logic block address
2422 @param NumberOfBlocks The number of blocks to read
2423
2424 @retval EFI_DEVICE_ERROR Indicates a device error.
2425 @retval EFI_SUCCESS Operation is successful.
2426
2427 **/
2428 EFI_STATUS
2429 ScsiDiskWriteSectors (
2430 IN SCSI_DISK_DEV *ScsiDiskDevice,
2431 IN VOID *Buffer,
2432 IN EFI_LBA Lba,
2433 IN UINTN NumberOfBlocks
2434 )
2435 {
2436 UINTN BlocksRemaining;
2437 UINT8 *PtrBuffer;
2438 UINT32 BlockSize;
2439 UINT32 ByteCount;
2440 UINT32 MaxBlock;
2441 UINT32 SectorCount;
2442 UINT32 NextSectorCount;
2443 UINT64 Timeout;
2444 EFI_STATUS Status;
2445 UINT8 Index;
2446 UINT8 MaxRetry;
2447 BOOLEAN NeedRetry;
2448
2449 Status = EFI_SUCCESS;
2450
2451 BlocksRemaining = NumberOfBlocks;
2452 BlockSize = ScsiDiskDevice->BlkIo.Media->BlockSize;
2453
2454 //
2455 // limit the data bytes that can be transferred by one Read(10) or Read(16) Command
2456 //
2457 if (!ScsiDiskDevice->Cdb16Byte) {
2458 MaxBlock = 0xFFFF;
2459 } else {
2460 MaxBlock = 0xFFFFFFFF;
2461 }
2462
2463 PtrBuffer = Buffer;
2464
2465 while (BlocksRemaining > 0) {
2466
2467 if (BlocksRemaining <= MaxBlock) {
2468 if (!ScsiDiskDevice->Cdb16Byte) {
2469 SectorCount = (UINT16) BlocksRemaining;
2470 } else {
2471 SectorCount = (UINT32) BlocksRemaining;
2472 }
2473 } else {
2474 SectorCount = MaxBlock;
2475 }
2476
2477 ByteCount = SectorCount * BlockSize;
2478 //
2479 // |------------------------|-----------------|------------------|-----------------|
2480 // | ATA Transfer Mode | Transfer Rate | SCSI Interface | Transfer Rate |
2481 // |------------------------|-----------------|------------------|-----------------|
2482 // | PIO Mode 0 | 3.3Mbytes/sec | SCSI-1 | 5Mbytes/sec |
2483 // |------------------------|-----------------|------------------|-----------------|
2484 // | PIO Mode 1 | 5.2Mbytes/sec | Fast SCSI | 10Mbytes/sec |
2485 // |------------------------|-----------------|------------------|-----------------|
2486 // | PIO Mode 2 | 8.3Mbytes/sec | Fast-Wide SCSI | 20Mbytes/sec |
2487 // |------------------------|-----------------|------------------|-----------------|
2488 // | PIO Mode 3 | 11.1Mbytes/sec | Ultra SCSI | 20Mbytes/sec |
2489 // |------------------------|-----------------|------------------|-----------------|
2490 // | PIO Mode 4 | 16.6Mbytes/sec | Ultra Wide SCSI | 40Mbytes/sec |
2491 // |------------------------|-----------------|------------------|-----------------|
2492 // | Single-word DMA Mode 0 | 2.1Mbytes/sec | Ultra2 SCSI | 40Mbytes/sec |
2493 // |------------------------|-----------------|------------------|-----------------|
2494 // | Single-word DMA Mode 1 | 4.2Mbytes/sec | Ultra2 Wide SCSI | 80Mbytes/sec |
2495 // |------------------------|-----------------|------------------|-----------------|
2496 // | Single-word DMA Mode 2 | 8.4Mbytes/sec | Ultra3 SCSI | 160Mbytes/sec |
2497 // |------------------------|-----------------|------------------|-----------------|
2498 // | Multi-word DMA Mode 0 | 4.2Mbytes/sec | Ultra-320 SCSI | 320Mbytes/sec |
2499 // |------------------------|-----------------|------------------|-----------------|
2500 // | Multi-word DMA Mode 1 | 13.3Mbytes/sec | Ultra-640 SCSI | 640Mbytes/sec |
2501 // |------------------------|-----------------|------------------|-----------------|
2502 //
2503 // As ScsiDisk and ScsiBus driver are used to manage SCSI or ATAPI devices, we have to use
2504 // the lowest transfer rate to calculate the possible maximum timeout value for each operation.
2505 // From the above table, we could know 2.1Mbytes per second is lowest one.
2506 // The timout value is rounded up to nearest integar and here an additional 30s is added
2507 // to follow ATA spec in which it mentioned that the device may take up to 30s to respond
2508 // commands in the Standby/Idle mode.
2509 //
2510 Timeout = EFI_TIMER_PERIOD_SECONDS (ByteCount / 2100000 + 31);
2511 MaxRetry = 2;
2512 for (Index = 0; Index < MaxRetry; Index++) {
2513 if (!ScsiDiskDevice->Cdb16Byte) {
2514 Status = ScsiDiskWrite10 (
2515 ScsiDiskDevice,
2516 &NeedRetry,
2517 Timeout,
2518 PtrBuffer,
2519 &ByteCount,
2520 (UINT32) Lba,
2521 SectorCount
2522 );
2523 } else {
2524 Status = ScsiDiskWrite16 (
2525 ScsiDiskDevice,
2526 &NeedRetry,
2527 Timeout,
2528 PtrBuffer,
2529 &ByteCount,
2530 Lba,
2531 SectorCount
2532 );
2533 }
2534 if (!EFI_ERROR (Status)) {
2535 break;
2536 }
2537
2538 if (!NeedRetry) {
2539 return EFI_DEVICE_ERROR;
2540 }
2541
2542 //
2543 // We need to retry. However, if ScsiDiskWrite10() or ScsiDiskWrite16()
2544 // has lowered ByteCount on output, we must make sure that we lower
2545 // SectorCount accordingly. SectorCount will be encoded in the CDB, and
2546 // it is invalid to request more sectors in the CDB than the entire
2547 // transfer (ie. ByteCount) can carry.
2548 //
2549 // In addition, ByteCount is only expected to go down, or stay unchaged.
2550 // Therefore we don't need to update Timeout: the original timeout should
2551 // accommodate shorter transfers too.
2552 //
2553 NextSectorCount = ByteCount / BlockSize;
2554 if (NextSectorCount < SectorCount) {
2555 SectorCount = NextSectorCount;
2556 //
2557 // Account for any rounding down.
2558 //
2559 ByteCount = SectorCount * BlockSize;
2560 }
2561 }
2562
2563 if ((Index == MaxRetry) && (Status != EFI_SUCCESS)) {
2564 return EFI_DEVICE_ERROR;
2565 }
2566 //
2567 // actual transferred sectors
2568 //
2569 SectorCount = ByteCount / BlockSize;
2570
2571 Lba += SectorCount;
2572 PtrBuffer = PtrBuffer + SectorCount * BlockSize;
2573 BlocksRemaining -= SectorCount;
2574 }
2575
2576 return EFI_SUCCESS;
2577 }
2578
2579 /**
2580 Asynchronously read sector from SCSI Disk.
2581
2582 @param ScsiDiskDevice The pointer of SCSI_DISK_DEV.
2583 @param Buffer The buffer to fill in the read out data.
2584 @param Lba Logic block address.
2585 @param NumberOfBlocks The number of blocks to read.
2586 @param Token A pointer to the token associated with the
2587 non-blocking read request.
2588
2589 @retval EFI_INVALID_PARAMETER Token is NULL or Token->Event is NULL.
2590 @retval EFI_DEVICE_ERROR Indicates a device error.
2591 @retval EFI_SUCCESS Operation is successful.
2592
2593 **/
2594 EFI_STATUS
2595 ScsiDiskAsyncReadSectors (
2596 IN SCSI_DISK_DEV *ScsiDiskDevice,
2597 OUT VOID *Buffer,
2598 IN EFI_LBA Lba,
2599 IN UINTN NumberOfBlocks,
2600 IN EFI_BLOCK_IO2_TOKEN *Token
2601 )
2602 {
2603 UINTN BlocksRemaining;
2604 UINT8 *PtrBuffer;
2605 UINT32 BlockSize;
2606 UINT32 ByteCount;
2607 UINT32 MaxBlock;
2608 UINT32 SectorCount;
2609 UINT64 Timeout;
2610 SCSI_BLKIO2_REQUEST *BlkIo2Req;
2611 EFI_STATUS Status;
2612
2613 if ((Token == NULL) || (Token->Event == NULL)) {
2614 return EFI_INVALID_PARAMETER;
2615 }
2616
2617 BlkIo2Req = AllocateZeroPool (sizeof (SCSI_BLKIO2_REQUEST));
2618 if (BlkIo2Req == NULL) {
2619 return EFI_OUT_OF_RESOURCES;
2620 }
2621
2622 BlkIo2Req->Token = Token;
2623 InsertTailList (&ScsiDiskDevice->BlkIo2Queue, &BlkIo2Req->Link);
2624 InitializeListHead (&BlkIo2Req->ScsiRWQueue);
2625
2626 Status = EFI_SUCCESS;
2627
2628 BlocksRemaining = NumberOfBlocks;
2629 BlockSize = ScsiDiskDevice->BlkIo.Media->BlockSize;
2630
2631 //
2632 // Limit the data bytes that can be transferred by one Read(10) or Read(16)
2633 // Command
2634 //
2635 if (!ScsiDiskDevice->Cdb16Byte) {
2636 MaxBlock = 0xFFFF;
2637 } else {
2638 MaxBlock = 0xFFFFFFFF;
2639 }
2640
2641 PtrBuffer = Buffer;
2642
2643 while (BlocksRemaining > 0) {
2644
2645 if (BlocksRemaining <= MaxBlock) {
2646 if (!ScsiDiskDevice->Cdb16Byte) {
2647 SectorCount = (UINT16) BlocksRemaining;
2648 } else {
2649 SectorCount = (UINT32) BlocksRemaining;
2650 }
2651 } else {
2652 SectorCount = MaxBlock;
2653 }
2654
2655 ByteCount = SectorCount * BlockSize;
2656 //
2657 // |------------------------|-----------------|------------------|-----------------|
2658 // | ATA Transfer Mode | Transfer Rate | SCSI Interface | Transfer Rate |
2659 // |------------------------|-----------------|------------------|-----------------|
2660 // | PIO Mode 0 | 3.3Mbytes/sec | SCSI-1 | 5Mbytes/sec |
2661 // |------------------------|-----------------|------------------|-----------------|
2662 // | PIO Mode 1 | 5.2Mbytes/sec | Fast SCSI | 10Mbytes/sec |
2663 // |------------------------|-----------------|------------------|-----------------|
2664 // | PIO Mode 2 | 8.3Mbytes/sec | Fast-Wide SCSI | 20Mbytes/sec |
2665 // |------------------------|-----------------|------------------|-----------------|
2666 // | PIO Mode 3 | 11.1Mbytes/sec | Ultra SCSI | 20Mbytes/sec |
2667 // |------------------------|-----------------|------------------|-----------------|
2668 // | PIO Mode 4 | 16.6Mbytes/sec | Ultra Wide SCSI | 40Mbytes/sec |
2669 // |------------------------|-----------------|------------------|-----------------|
2670 // | Single-word DMA Mode 0 | 2.1Mbytes/sec | Ultra2 SCSI | 40Mbytes/sec |
2671 // |------------------------|-----------------|------------------|-----------------|
2672 // | Single-word DMA Mode 1 | 4.2Mbytes/sec | Ultra2 Wide SCSI | 80Mbytes/sec |
2673 // |------------------------|-----------------|------------------|-----------------|
2674 // | Single-word DMA Mode 2 | 8.4Mbytes/sec | Ultra3 SCSI | 160Mbytes/sec |
2675 // |------------------------|-----------------|------------------|-----------------|
2676 // | Multi-word DMA Mode 0 | 4.2Mbytes/sec | Ultra-320 SCSI | 320Mbytes/sec |
2677 // |------------------------|-----------------|------------------|-----------------|
2678 // | Multi-word DMA Mode 1 | 13.3Mbytes/sec | Ultra-640 SCSI | 640Mbytes/sec |
2679 // |------------------------|-----------------|------------------|-----------------|
2680 //
2681 // As ScsiDisk and ScsiBus driver are used to manage SCSI or ATAPI devices,
2682 // we have to use the lowest transfer rate to calculate the possible
2683 // maximum timeout value for each operation.
2684 // From the above table, we could know 2.1Mbytes per second is lowest one.
2685 // The timout value is rounded up to nearest integar and here an additional
2686 // 30s is added to follow ATA spec in which it mentioned that the device
2687 // may take up to 30s to respond commands in the Standby/Idle mode.
2688 //
2689 Timeout = EFI_TIMER_PERIOD_SECONDS (ByteCount / 2100000 + 31);
2690
2691 if (!ScsiDiskDevice->Cdb16Byte) {
2692 Status = ScsiDiskAsyncRead10 (
2693 ScsiDiskDevice,
2694 Timeout,
2695 0,
2696 PtrBuffer,
2697 ByteCount,
2698 (UINT32) Lba,
2699 SectorCount,
2700 BlkIo2Req,
2701 Token
2702 );
2703 } else {
2704 Status = ScsiDiskAsyncRead16 (
2705 ScsiDiskDevice,
2706 Timeout,
2707 0,
2708 PtrBuffer,
2709 ByteCount,
2710 Lba,
2711 SectorCount,
2712 BlkIo2Req,
2713 Token
2714 );
2715 }
2716 if (EFI_ERROR (Status)) {
2717 //
2718 // Free the SCSI_BLKIO2_REQUEST structure only when the first SCSI
2719 // command fails. Otherwise, it will be freed in the callback function
2720 // ScsiDiskNotify().
2721 //
2722 if (IsListEmpty (&BlkIo2Req->ScsiRWQueue)) {
2723 RemoveEntryList (&BlkIo2Req->Link);
2724 FreePool (BlkIo2Req);
2725 }
2726 return EFI_DEVICE_ERROR;
2727 }
2728
2729 //
2730 // Sectors submitted for transfer
2731 //
2732 SectorCount = ByteCount / BlockSize;
2733
2734 Lba += SectorCount;
2735 PtrBuffer = PtrBuffer + SectorCount * BlockSize;
2736 BlocksRemaining -= SectorCount;
2737 }
2738
2739 return EFI_SUCCESS;
2740 }
2741
2742 /**
2743 Asynchronously write sector to SCSI Disk.
2744
2745 @param ScsiDiskDevice The pointer of SCSI_DISK_DEV.
2746 @param Buffer The buffer of data to be written into SCSI Disk.
2747 @param Lba Logic block address.
2748 @param NumberOfBlocks The number of blocks to read.
2749 @param Token A pointer to the token associated with the
2750 non-blocking read request.
2751
2752 @retval EFI_INVALID_PARAMETER Token is NULL or Token->Event is NULL
2753 @retval EFI_DEVICE_ERROR Indicates a device error.
2754 @retval EFI_SUCCESS Operation is successful.
2755
2756 **/
2757 EFI_STATUS
2758 ScsiDiskAsyncWriteSectors (
2759 IN SCSI_DISK_DEV *ScsiDiskDevice,
2760 IN VOID *Buffer,
2761 IN EFI_LBA Lba,
2762 IN UINTN NumberOfBlocks,
2763 IN EFI_BLOCK_IO2_TOKEN *Token
2764 )
2765 {
2766 UINTN BlocksRemaining;
2767 UINT8 *PtrBuffer;
2768 UINT32 BlockSize;
2769 UINT32 ByteCount;
2770 UINT32 MaxBlock;
2771 UINT32 SectorCount;
2772 UINT64 Timeout;
2773 SCSI_BLKIO2_REQUEST *BlkIo2Req;
2774 EFI_STATUS Status;
2775
2776 if ((Token == NULL) || (Token->Event == NULL)) {
2777 return EFI_INVALID_PARAMETER;
2778 }
2779
2780 BlkIo2Req = AllocateZeroPool (sizeof (SCSI_BLKIO2_REQUEST));
2781 if (BlkIo2Req == NULL) {
2782 return EFI_OUT_OF_RESOURCES;
2783 }
2784
2785 BlkIo2Req->Token = Token;
2786 InsertTailList (&ScsiDiskDevice->BlkIo2Queue, &BlkIo2Req->Link);
2787 InitializeListHead (&BlkIo2Req->ScsiRWQueue);
2788
2789 Status = EFI_SUCCESS;
2790
2791 BlocksRemaining = NumberOfBlocks;
2792 BlockSize = ScsiDiskDevice->BlkIo.Media->BlockSize;
2793
2794 //
2795 // Limit the data bytes that can be transferred by one Read(10) or Read(16)
2796 // Command
2797 //
2798 if (!ScsiDiskDevice->Cdb16Byte) {
2799 MaxBlock = 0xFFFF;
2800 } else {
2801 MaxBlock = 0xFFFFFFFF;
2802 }
2803
2804 PtrBuffer = Buffer;
2805
2806 while (BlocksRemaining > 0) {
2807
2808 if (BlocksRemaining <= MaxBlock) {
2809 if (!ScsiDiskDevice->Cdb16Byte) {
2810 SectorCount = (UINT16) BlocksRemaining;
2811 } else {
2812 SectorCount = (UINT32) BlocksRemaining;
2813 }
2814 } else {
2815 SectorCount = MaxBlock;
2816 }
2817
2818 ByteCount = SectorCount * BlockSize;
2819 //
2820 // |------------------------|-----------------|------------------|-----------------|
2821 // | ATA Transfer Mode | Transfer Rate | SCSI Interface | Transfer Rate |
2822 // |------------------------|-----------------|------------------|-----------------|
2823 // | PIO Mode 0 | 3.3Mbytes/sec | SCSI-1 | 5Mbytes/sec |
2824 // |------------------------|-----------------|------------------|-----------------|
2825 // | PIO Mode 1 | 5.2Mbytes/sec | Fast SCSI | 10Mbytes/sec |
2826 // |------------------------|-----------------|------------------|-----------------|
2827 // | PIO Mode 2 | 8.3Mbytes/sec | Fast-Wide SCSI | 20Mbytes/sec |
2828 // |------------------------|-----------------|------------------|-----------------|
2829 // | PIO Mode 3 | 11.1Mbytes/sec | Ultra SCSI | 20Mbytes/sec |
2830 // |------------------------|-----------------|------------------|-----------------|
2831 // | PIO Mode 4 | 16.6Mbytes/sec | Ultra Wide SCSI | 40Mbytes/sec |
2832 // |------------------------|-----------------|------------------|-----------------|
2833 // | Single-word DMA Mode 0 | 2.1Mbytes/sec | Ultra2 SCSI | 40Mbytes/sec |
2834 // |------------------------|-----------------|------------------|-----------------|
2835 // | Single-word DMA Mode 1 | 4.2Mbytes/sec | Ultra2 Wide SCSI | 80Mbytes/sec |
2836 // |------------------------|-----------------|------------------|-----------------|
2837 // | Single-word DMA Mode 2 | 8.4Mbytes/sec | Ultra3 SCSI | 160Mbytes/sec |
2838 // |------------------------|-----------------|------------------|-----------------|
2839 // | Multi-word DMA Mode 0 | 4.2Mbytes/sec | Ultra-320 SCSI | 320Mbytes/sec |
2840 // |------------------------|-----------------|------------------|-----------------|
2841 // | Multi-word DMA Mode 1 | 13.3Mbytes/sec | Ultra-640 SCSI | 640Mbytes/sec |
2842 // |------------------------|-----------------|------------------|-----------------|
2843 //
2844 // As ScsiDisk and ScsiBus driver are used to manage SCSI or ATAPI devices,
2845 // we have to use the lowest transfer rate to calculate the possible
2846 // maximum timeout value for each operation.
2847 // From the above table, we could know 2.1Mbytes per second is lowest one.
2848 // The timout value is rounded up to nearest integar and here an additional
2849 // 30s is added to follow ATA spec in which it mentioned that the device
2850 // may take up to 30s to respond commands in the Standby/Idle mode.
2851 //
2852 Timeout = EFI_TIMER_PERIOD_SECONDS (ByteCount / 2100000 + 31);
2853
2854 if (!ScsiDiskDevice->Cdb16Byte) {
2855 Status = ScsiDiskAsyncWrite10 (
2856 ScsiDiskDevice,
2857 Timeout,
2858 0,
2859 PtrBuffer,
2860 ByteCount,
2861 (UINT32) Lba,
2862 SectorCount,
2863 BlkIo2Req,
2864 Token
2865 );
2866 } else {
2867 Status = ScsiDiskAsyncWrite16 (
2868 ScsiDiskDevice,
2869 Timeout,
2870 0,
2871 PtrBuffer,
2872 ByteCount,
2873 Lba,
2874 SectorCount,
2875 BlkIo2Req,
2876 Token
2877 );
2878 }
2879 if (EFI_ERROR (Status)) {
2880 //
2881 // Free the SCSI_BLKIO2_REQUEST structure only when the first SCSI
2882 // command fails. Otherwise, it will be freed in the callback function
2883 // ScsiDiskNotify().
2884 //
2885 if (IsListEmpty (&BlkIo2Req->ScsiRWQueue)) {
2886 RemoveEntryList (&BlkIo2Req->Link);
2887 FreePool (BlkIo2Req);
2888 }
2889 return EFI_DEVICE_ERROR;
2890 }
2891
2892 //
2893 // Sectors submitted for transfer
2894 //
2895 SectorCount = ByteCount / BlockSize;
2896
2897 Lba += SectorCount;
2898 PtrBuffer = PtrBuffer + SectorCount * BlockSize;
2899 BlocksRemaining -= SectorCount;
2900 }
2901
2902 return EFI_SUCCESS;
2903 }
2904
2905
2906 /**
2907 Submit Read(10) command.
2908
2909 @param ScsiDiskDevice The pointer of ScsiDiskDevice
2910 @param NeedRetry The pointer of flag indicates if needs retry if error happens
2911 @param Timeout The time to complete the command
2912 @param DataBuffer The buffer to fill with the read out data
2913 @param DataLength The length of buffer
2914 @param StartLba The start logic block address
2915 @param SectorCount The number of blocks to read
2916
2917 @return EFI_STATUS is returned by calling ScsiRead10Command().
2918 **/
2919 EFI_STATUS
2920 ScsiDiskRead10 (
2921 IN SCSI_DISK_DEV *ScsiDiskDevice,
2922 OUT BOOLEAN *NeedRetry,
2923 IN UINT64 Timeout,
2924 OUT UINT8 *DataBuffer,
2925 IN OUT UINT32 *DataLength,
2926 IN UINT32 StartLba,
2927 IN UINT32 SectorCount
2928 )
2929 {
2930 UINT8 SenseDataLength;
2931 EFI_STATUS Status;
2932 EFI_STATUS ReturnStatus;
2933 UINT8 HostAdapterStatus;
2934 UINT8 TargetStatus;
2935 UINTN Action;
2936
2937 //
2938 // Implement a backoff algorithem to resolve some compatibility issues that
2939 // some SCSI targets or ATAPI devices couldn't correctly response reading/writing
2940 // big data in a single operation.
2941 // This algorithem will at first try to execute original request. If the request fails
2942 // with media error sense data or else, it will reduce the transfer length to half and
2943 // try again till the operation succeeds or fails with one sector transfer length.
2944 //
2945 BackOff:
2946 *NeedRetry = FALSE;
2947 Action = ACTION_NO_ACTION;
2948 SenseDataLength = (UINT8) (ScsiDiskDevice->SenseDataNumber * sizeof (EFI_SCSI_SENSE_DATA));
2949 ReturnStatus = ScsiRead10Command (
2950 ScsiDiskDevice->ScsiIo,
2951 Timeout,
2952 ScsiDiskDevice->SenseData,
2953 &SenseDataLength,
2954 &HostAdapterStatus,
2955 &TargetStatus,
2956 DataBuffer,
2957 DataLength,
2958 StartLba,
2959 SectorCount
2960 );
2961
2962 if (ReturnStatus == EFI_NOT_READY || ReturnStatus == EFI_BAD_BUFFER_SIZE) {
2963 *NeedRetry = TRUE;
2964 return EFI_DEVICE_ERROR;
2965 } else if ((ReturnStatus == EFI_INVALID_PARAMETER) || (ReturnStatus == EFI_UNSUPPORTED)) {
2966 *NeedRetry = FALSE;
2967 return ReturnStatus;
2968 }
2969
2970 //
2971 // go ahead to check HostAdapterStatus and TargetStatus
2972 // (EFI_TIMEOUT, EFI_DEVICE_ERROR, EFI_WARN_BUFFER_TOO_SMALL)
2973 //
2974 Status = CheckHostAdapterStatus (HostAdapterStatus);
2975 if ((Status == EFI_TIMEOUT) || (Status == EFI_NOT_READY)) {
2976 *NeedRetry = TRUE;
2977 return EFI_DEVICE_ERROR;
2978 } else if (Status == EFI_DEVICE_ERROR) {
2979 //
2980 // reset the scsi channel
2981 //
2982 ScsiDiskDevice->ScsiIo->ResetBus (ScsiDiskDevice->ScsiIo);
2983 *NeedRetry = FALSE;
2984 return EFI_DEVICE_ERROR;
2985 }
2986
2987 Status = CheckTargetStatus (TargetStatus);
2988 if (Status == EFI_NOT_READY) {
2989 //
2990 // reset the scsi device
2991 //
2992 ScsiDiskDevice->ScsiIo->ResetDevice (ScsiDiskDevice->ScsiIo);
2993 *NeedRetry = TRUE;
2994 return EFI_DEVICE_ERROR;
2995 } else if (Status == EFI_DEVICE_ERROR) {
2996 *NeedRetry = FALSE;
2997 return EFI_DEVICE_ERROR;
2998 }
2999
3000 if ((TargetStatus == EFI_EXT_SCSI_STATUS_TARGET_CHECK_CONDITION) || (EFI_ERROR (ReturnStatus))) {
3001 DEBUG ((EFI_D_ERROR, "ScsiDiskRead10: Check Condition happened!\n"));
3002 Status = DetectMediaParsingSenseKeys (ScsiDiskDevice, ScsiDiskDevice->SenseData, SenseDataLength / sizeof (EFI_SCSI_SENSE_DATA), &Action);
3003 if (Action == ACTION_RETRY_COMMAND_LATER) {
3004 *NeedRetry = TRUE;
3005 return EFI_DEVICE_ERROR;
3006 } else if (Action == ACTION_RETRY_WITH_BACKOFF_ALGO) {
3007 if (SectorCount <= 1) {
3008 //
3009 // Jump out if the operation still fails with one sector transfer length.
3010 //
3011 *NeedRetry = FALSE;
3012 return EFI_DEVICE_ERROR;
3013 }
3014 //
3015 // Try again with half length if the sense data shows we need to retry.
3016 //
3017 SectorCount >>= 1;
3018 *DataLength = SectorCount * ScsiDiskDevice->BlkIo.Media->BlockSize;
3019 goto BackOff;
3020 } else {
3021 *NeedRetry = FALSE;
3022 return EFI_DEVICE_ERROR;
3023 }
3024 }
3025
3026 return ReturnStatus;
3027 }
3028
3029
3030 /**
3031 Submit Write(10) Command.
3032
3033 @param ScsiDiskDevice The pointer of ScsiDiskDevice
3034 @param NeedRetry The pointer of flag indicates if needs retry if error happens
3035 @param Timeout The time to complete the command
3036 @param DataBuffer The buffer to fill with the read out data
3037 @param DataLength The length of buffer
3038 @param StartLba The start logic block address
3039 @param SectorCount The number of blocks to write
3040
3041 @return EFI_STATUS is returned by calling ScsiWrite10Command().
3042
3043 **/
3044 EFI_STATUS
3045 ScsiDiskWrite10 (
3046 IN SCSI_DISK_DEV *ScsiDiskDevice,
3047 OUT BOOLEAN *NeedRetry,
3048 IN UINT64 Timeout,
3049 IN UINT8 *DataBuffer,
3050 IN OUT UINT32 *DataLength,
3051 IN UINT32 StartLba,
3052 IN UINT32 SectorCount
3053 )
3054 {
3055 EFI_STATUS Status;
3056 EFI_STATUS ReturnStatus;
3057 UINT8 SenseDataLength;
3058 UINT8 HostAdapterStatus;
3059 UINT8 TargetStatus;
3060 UINTN Action;
3061
3062 //
3063 // Implement a backoff algorithem to resolve some compatibility issues that
3064 // some SCSI targets or ATAPI devices couldn't correctly response reading/writing
3065 // big data in a single operation.
3066 // This algorithem will at first try to execute original request. If the request fails
3067 // with media error sense data or else, it will reduce the transfer length to half and
3068 // try again till the operation succeeds or fails with one sector transfer length.
3069 //
3070 BackOff:
3071 *NeedRetry = FALSE;
3072 Action = ACTION_NO_ACTION;
3073 SenseDataLength = (UINT8) (ScsiDiskDevice->SenseDataNumber * sizeof (EFI_SCSI_SENSE_DATA));
3074 ReturnStatus = ScsiWrite10Command (
3075 ScsiDiskDevice->ScsiIo,
3076 Timeout,
3077 ScsiDiskDevice->SenseData,
3078 &SenseDataLength,
3079 &HostAdapterStatus,
3080 &TargetStatus,
3081 DataBuffer,
3082 DataLength,
3083 StartLba,
3084 SectorCount
3085 );
3086 if (ReturnStatus == EFI_NOT_READY || ReturnStatus == EFI_BAD_BUFFER_SIZE) {
3087 *NeedRetry = TRUE;
3088 return EFI_DEVICE_ERROR;
3089 } else if ((ReturnStatus == EFI_INVALID_PARAMETER) || (ReturnStatus == EFI_UNSUPPORTED)) {
3090 *NeedRetry = FALSE;
3091 return ReturnStatus;
3092 }
3093
3094 //
3095 // go ahead to check HostAdapterStatus and TargetStatus
3096 // (EFI_TIMEOUT, EFI_DEVICE_ERROR, EFI_WARN_BUFFER_TOO_SMALL)
3097 //
3098 Status = CheckHostAdapterStatus (HostAdapterStatus);
3099 if ((Status == EFI_TIMEOUT) || (Status == EFI_NOT_READY)) {
3100 *NeedRetry = TRUE;
3101 return EFI_DEVICE_ERROR;
3102 } else if (Status == EFI_DEVICE_ERROR) {
3103 //
3104 // reset the scsi channel
3105 //
3106 ScsiDiskDevice->ScsiIo->ResetBus (ScsiDiskDevice->ScsiIo);
3107 *NeedRetry = FALSE;
3108 return EFI_DEVICE_ERROR;
3109 }
3110
3111 Status = CheckTargetStatus (TargetStatus);
3112 if (Status == EFI_NOT_READY) {
3113 //
3114 // reset the scsi device
3115 //
3116 ScsiDiskDevice->ScsiIo->ResetDevice (ScsiDiskDevice->ScsiIo);
3117 *NeedRetry = TRUE;
3118 return EFI_DEVICE_ERROR;
3119 } else if (Status == EFI_DEVICE_ERROR) {
3120 *NeedRetry = FALSE;
3121 return EFI_DEVICE_ERROR;
3122 }
3123
3124 if ((TargetStatus == EFI_EXT_SCSI_STATUS_TARGET_CHECK_CONDITION) || (EFI_ERROR (ReturnStatus))) {
3125 DEBUG ((EFI_D_ERROR, "ScsiDiskWrite10: Check Condition happened!\n"));
3126 Status = DetectMediaParsingSenseKeys (ScsiDiskDevice, ScsiDiskDevice->SenseData, SenseDataLength / sizeof (EFI_SCSI_SENSE_DATA), &Action);
3127 if (Action == ACTION_RETRY_COMMAND_LATER) {
3128 *NeedRetry = TRUE;
3129 return EFI_DEVICE_ERROR;
3130 } else if (Action == ACTION_RETRY_WITH_BACKOFF_ALGO) {
3131 if (SectorCount <= 1) {
3132 //
3133 // Jump out if the operation still fails with one sector transfer length.
3134 //
3135 *NeedRetry = FALSE;
3136 return EFI_DEVICE_ERROR;
3137 }
3138 //
3139 // Try again with half length if the sense data shows we need to retry.
3140 //
3141 SectorCount >>= 1;
3142 *DataLength = SectorCount * ScsiDiskDevice->BlkIo.Media->BlockSize;
3143 goto BackOff;
3144 } else {
3145 *NeedRetry = FALSE;
3146 return EFI_DEVICE_ERROR;
3147 }
3148 }
3149
3150 return ReturnStatus;
3151 }
3152
3153
3154 /**
3155 Submit Read(16) command.
3156
3157 @param ScsiDiskDevice The pointer of ScsiDiskDevice
3158 @param NeedRetry The pointer of flag indicates if needs retry if error happens
3159 @param Timeout The time to complete the command
3160 @param DataBuffer The buffer to fill with the read out data
3161 @param DataLength The length of buffer
3162 @param StartLba The start logic block address
3163 @param SectorCount The number of blocks to read
3164
3165 @return EFI_STATUS is returned by calling ScsiRead16Command().
3166 **/
3167 EFI_STATUS
3168 ScsiDiskRead16 (
3169 IN SCSI_DISK_DEV *ScsiDiskDevice,
3170 OUT BOOLEAN *NeedRetry,
3171 IN UINT64 Timeout,
3172 OUT UINT8 *DataBuffer,
3173 IN OUT UINT32 *DataLength,
3174 IN UINT64 StartLba,
3175 IN UINT32 SectorCount
3176 )
3177 {
3178 UINT8 SenseDataLength;
3179 EFI_STATUS Status;
3180 EFI_STATUS ReturnStatus;
3181 UINT8 HostAdapterStatus;
3182 UINT8 TargetStatus;
3183 UINTN Action;
3184
3185 //
3186 // Implement a backoff algorithem to resolve some compatibility issues that
3187 // some SCSI targets or ATAPI devices couldn't correctly response reading/writing
3188 // big data in a single operation.
3189 // This algorithem will at first try to execute original request. If the request fails
3190 // with media error sense data or else, it will reduce the transfer length to half and
3191 // try again till the operation succeeds or fails with one sector transfer length.
3192 //
3193 BackOff:
3194 *NeedRetry = FALSE;
3195 Action = ACTION_NO_ACTION;
3196 SenseDataLength = (UINT8) (ScsiDiskDevice->SenseDataNumber * sizeof (EFI_SCSI_SENSE_DATA));
3197 ReturnStatus = ScsiRead16Command (
3198 ScsiDiskDevice->ScsiIo,
3199 Timeout,
3200 ScsiDiskDevice->SenseData,
3201 &SenseDataLength,
3202 &HostAdapterStatus,
3203 &TargetStatus,
3204 DataBuffer,
3205 DataLength,
3206 StartLba,
3207 SectorCount
3208 );
3209 if (ReturnStatus == EFI_NOT_READY || ReturnStatus == EFI_BAD_BUFFER_SIZE) {
3210 *NeedRetry = TRUE;
3211 return EFI_DEVICE_ERROR;
3212 } else if ((ReturnStatus == EFI_INVALID_PARAMETER) || (ReturnStatus == EFI_UNSUPPORTED)) {
3213 *NeedRetry = FALSE;
3214 return ReturnStatus;
3215 }
3216
3217 //
3218 // go ahead to check HostAdapterStatus and TargetStatus
3219 // (EFI_TIMEOUT, EFI_DEVICE_ERROR, EFI_WARN_BUFFER_TOO_SMALL)
3220 //
3221 Status = CheckHostAdapterStatus (HostAdapterStatus);
3222 if ((Status == EFI_TIMEOUT) || (Status == EFI_NOT_READY)) {
3223 *NeedRetry = TRUE;
3224 return EFI_DEVICE_ERROR;
3225 } else if (Status == EFI_DEVICE_ERROR) {
3226 //
3227 // reset the scsi channel
3228 //
3229 ScsiDiskDevice->ScsiIo->ResetBus (ScsiDiskDevice->ScsiIo);
3230 *NeedRetry = FALSE;
3231 return EFI_DEVICE_ERROR;
3232 }
3233
3234 Status = CheckTargetStatus (TargetStatus);
3235 if (Status == EFI_NOT_READY) {
3236 //
3237 // reset the scsi device
3238 //
3239 ScsiDiskDevice->ScsiIo->ResetDevice (ScsiDiskDevice->ScsiIo);
3240 *NeedRetry = TRUE;
3241 return EFI_DEVICE_ERROR;
3242 } else if (Status == EFI_DEVICE_ERROR) {
3243 *NeedRetry = FALSE;
3244 return EFI_DEVICE_ERROR;
3245 }
3246
3247 if ((TargetStatus == EFI_EXT_SCSI_STATUS_TARGET_CHECK_CONDITION) || (EFI_ERROR (ReturnStatus))) {
3248 DEBUG ((EFI_D_ERROR, "ScsiDiskRead16: Check Condition happened!\n"));
3249 Status = DetectMediaParsingSenseKeys (ScsiDiskDevice, ScsiDiskDevice->SenseData, SenseDataLength / sizeof (EFI_SCSI_SENSE_DATA), &Action);
3250 if (Action == ACTION_RETRY_COMMAND_LATER) {
3251 *NeedRetry = TRUE;
3252 return EFI_DEVICE_ERROR;
3253 } else if (Action == ACTION_RETRY_WITH_BACKOFF_ALGO) {
3254 if (SectorCount <= 1) {
3255 //
3256 // Jump out if the operation still fails with one sector transfer length.
3257 //
3258 *NeedRetry = FALSE;
3259 return EFI_DEVICE_ERROR;
3260 }
3261 //
3262 // Try again with half length if the sense data shows we need to retry.
3263 //
3264 SectorCount >>= 1;
3265 *DataLength = SectorCount * ScsiDiskDevice->BlkIo.Media->BlockSize;
3266 goto BackOff;
3267 } else {
3268 *NeedRetry = FALSE;
3269 return EFI_DEVICE_ERROR;
3270 }
3271 }
3272
3273 return ReturnStatus;
3274 }
3275
3276
3277 /**
3278 Submit Write(16) Command.
3279
3280 @param ScsiDiskDevice The pointer of ScsiDiskDevice
3281 @param NeedRetry The pointer of flag indicates if needs retry if error happens
3282 @param Timeout The time to complete the command
3283 @param DataBuffer The buffer to fill with the read out data
3284 @param DataLength The length of buffer
3285 @param StartLba The start logic block address
3286 @param SectorCount The number of blocks to write
3287
3288 @return EFI_STATUS is returned by calling ScsiWrite16Command().
3289
3290 **/
3291 EFI_STATUS
3292 ScsiDiskWrite16 (
3293 IN SCSI_DISK_DEV *ScsiDiskDevice,
3294 OUT BOOLEAN *NeedRetry,
3295 IN UINT64 Timeout,
3296 IN UINT8 *DataBuffer,
3297 IN OUT UINT32 *DataLength,
3298 IN UINT64 StartLba,
3299 IN UINT32 SectorCount
3300 )
3301 {
3302 EFI_STATUS Status;
3303 EFI_STATUS ReturnStatus;
3304 UINT8 SenseDataLength;
3305 UINT8 HostAdapterStatus;
3306 UINT8 TargetStatus;
3307 UINTN Action;
3308
3309 //
3310 // Implement a backoff algorithem to resolve some compatibility issues that
3311 // some SCSI targets or ATAPI devices couldn't correctly response reading/writing
3312 // big data in a single operation.
3313 // This algorithem will at first try to execute original request. If the request fails
3314 // with media error sense data or else, it will reduce the transfer length to half and
3315 // try again till the operation succeeds or fails with one sector transfer length.
3316 //
3317 BackOff:
3318 *NeedRetry = FALSE;
3319 Action = ACTION_NO_ACTION;
3320 SenseDataLength = (UINT8) (ScsiDiskDevice->SenseDataNumber * sizeof (EFI_SCSI_SENSE_DATA));
3321 ReturnStatus = ScsiWrite16Command (
3322 ScsiDiskDevice->ScsiIo,
3323 Timeout,
3324 ScsiDiskDevice->SenseData,
3325 &SenseDataLength,
3326 &HostAdapterStatus,
3327 &TargetStatus,
3328 DataBuffer,
3329 DataLength,
3330 StartLba,
3331 SectorCount
3332 );
3333 if (ReturnStatus == EFI_NOT_READY || ReturnStatus == EFI_BAD_BUFFER_SIZE) {
3334 *NeedRetry = TRUE;
3335 return EFI_DEVICE_ERROR;
3336 } else if ((ReturnStatus == EFI_INVALID_PARAMETER) || (ReturnStatus == EFI_UNSUPPORTED)) {
3337 *NeedRetry = FALSE;
3338 return ReturnStatus;
3339 }
3340
3341 //
3342 // go ahead to check HostAdapterStatus and TargetStatus
3343 // (EFI_TIMEOUT, EFI_DEVICE_ERROR, EFI_WARN_BUFFER_TOO_SMALL)
3344 //
3345 Status = CheckHostAdapterStatus (HostAdapterStatus);
3346 if ((Status == EFI_TIMEOUT) || (Status == EFI_NOT_READY)) {
3347 *NeedRetry = TRUE;
3348 return EFI_DEVICE_ERROR;
3349 } else if (Status == EFI_DEVICE_ERROR) {
3350 //
3351 // reset the scsi channel
3352 //
3353 ScsiDiskDevice->ScsiIo->ResetBus (ScsiDiskDevice->ScsiIo);
3354 *NeedRetry = FALSE;
3355 return EFI_DEVICE_ERROR;
3356 }
3357
3358 Status = CheckTargetStatus (TargetStatus);
3359 if (Status == EFI_NOT_READY) {
3360 //
3361 // reset the scsi device
3362 //
3363 ScsiDiskDevice->ScsiIo->ResetDevice (ScsiDiskDevice->ScsiIo);
3364 *NeedRetry = TRUE;
3365 return EFI_DEVICE_ERROR;
3366 } else if (Status == EFI_DEVICE_ERROR) {
3367 *NeedRetry = FALSE;
3368 return EFI_DEVICE_ERROR;
3369 }
3370
3371 if ((TargetStatus == EFI_EXT_SCSI_STATUS_TARGET_CHECK_CONDITION) || (EFI_ERROR (ReturnStatus))) {
3372 DEBUG ((EFI_D_ERROR, "ScsiDiskWrite16: Check Condition happened!\n"));
3373 Status = DetectMediaParsingSenseKeys (ScsiDiskDevice, ScsiDiskDevice->SenseData, SenseDataLength / sizeof (EFI_SCSI_SENSE_DATA), &Action);
3374 if (Action == ACTION_RETRY_COMMAND_LATER) {
3375 *NeedRetry = TRUE;
3376 return EFI_DEVICE_ERROR;
3377 } else if (Action == ACTION_RETRY_WITH_BACKOFF_ALGO) {
3378 if (SectorCount <= 1) {
3379 //
3380 // Jump out if the operation still fails with one sector transfer length.
3381 //
3382 *NeedRetry = FALSE;
3383 return EFI_DEVICE_ERROR;
3384 }
3385 //
3386 // Try again with half length if the sense data shows we need to retry.
3387 //
3388 SectorCount >>= 1;
3389 *DataLength = SectorCount * ScsiDiskDevice->BlkIo.Media->BlockSize;
3390 goto BackOff;
3391 } else {
3392 *NeedRetry = FALSE;
3393 return EFI_DEVICE_ERROR;
3394 }
3395 }
3396
3397 return ReturnStatus;
3398 }
3399
3400
3401 /**
3402 Internal helper notify function in which determine whether retry of a SCSI
3403 Read/Write command is needed and signal the event passed from Block I/O(2) if
3404 the SCSI I/O operation completes.
3405
3406 @param Event The instance of EFI_EVENT.
3407 @param Context The parameter passed in.
3408
3409 **/
3410 VOID
3411 EFIAPI
3412 ScsiDiskNotify (
3413 IN EFI_EVENT Event,
3414 IN VOID *Context
3415 )
3416 {
3417 EFI_STATUS Status;
3418 SCSI_ASYNC_RW_REQUEST *Request;
3419 SCSI_DISK_DEV *ScsiDiskDevice;
3420 EFI_BLOCK_IO2_TOKEN *Token;
3421 UINTN Action;
3422 UINT32 OldDataLength;
3423 UINT32 OldSectorCount;
3424 UINT8 MaxRetry;
3425
3426 gBS->CloseEvent (Event);
3427
3428 Request = (SCSI_ASYNC_RW_REQUEST *) Context;
3429 ScsiDiskDevice = Request->ScsiDiskDevice;
3430 Token = Request->BlkIo2Req->Token;
3431 OldDataLength = Request->DataLength;
3432 OldSectorCount = Request->SectorCount;
3433 MaxRetry = 2;
3434
3435 //
3436 // If previous sub-tasks already fails, no need to process this sub-task.
3437 //
3438 if (Token->TransactionStatus != EFI_SUCCESS) {
3439 goto Exit;
3440 }
3441
3442 //
3443 // Check HostAdapterStatus and TargetStatus
3444 // (EFI_TIMEOUT, EFI_DEVICE_ERROR, EFI_WARN_BUFFER_TOO_SMALL)
3445 //
3446 Status = CheckHostAdapterStatus (Request->HostAdapterStatus);
3447 if ((Status == EFI_TIMEOUT) || (Status == EFI_NOT_READY)) {
3448 if (++Request->TimesRetry > MaxRetry) {
3449 Token->TransactionStatus = EFI_DEVICE_ERROR;
3450 goto Exit;
3451 } else {
3452 goto Retry;
3453 }
3454 } else if (Status == EFI_DEVICE_ERROR) {
3455 //
3456 // reset the scsi channel
3457 //
3458 ScsiDiskDevice->ScsiIo->ResetBus (ScsiDiskDevice->ScsiIo);
3459 Token->TransactionStatus = EFI_DEVICE_ERROR;
3460 goto Exit;
3461 }
3462
3463 Status = CheckTargetStatus (Request->TargetStatus);
3464 if (Status == EFI_NOT_READY) {
3465 //
3466 // reset the scsi device
3467 //
3468 ScsiDiskDevice->ScsiIo->ResetDevice (ScsiDiskDevice->ScsiIo);
3469 if (++Request->TimesRetry > MaxRetry) {
3470 Token->TransactionStatus = EFI_DEVICE_ERROR;
3471 goto Exit;
3472 } else {
3473 goto Retry;
3474 }
3475 } else if (Status == EFI_DEVICE_ERROR) {
3476 Token->TransactionStatus = EFI_DEVICE_ERROR;
3477 goto Exit;
3478 }
3479
3480 if (Request->TargetStatus == EFI_EXT_SCSI_STATUS_TARGET_CHECK_CONDITION) {
3481 DEBUG ((EFI_D_ERROR, "ScsiDiskNotify: Check Condition happened!\n"));
3482
3483 Status = DetectMediaParsingSenseKeys (
3484 ScsiDiskDevice,
3485 Request->SenseData,
3486 Request->SenseDataLength / sizeof (EFI_SCSI_SENSE_DATA),
3487 &Action
3488 );
3489 if (Action == ACTION_RETRY_COMMAND_LATER) {
3490 if (++Request->TimesRetry > MaxRetry) {
3491 Token->TransactionStatus = EFI_DEVICE_ERROR;
3492 goto Exit;
3493 } else {
3494 goto Retry;
3495 }
3496 } else if (Action == ACTION_RETRY_WITH_BACKOFF_ALGO) {
3497 if (Request->SectorCount <= 1) {
3498 //
3499 // Jump out if the operation still fails with one sector transfer
3500 // length.
3501 //
3502 Token->TransactionStatus = EFI_DEVICE_ERROR;
3503 goto Exit;
3504 }
3505 //
3506 // Try again with two half length request if the sense data shows we need
3507 // to retry.
3508 //
3509 Request->SectorCount >>= 1;
3510 Request->DataLength = Request->SectorCount * ScsiDiskDevice->BlkIo.Media->BlockSize;
3511 Request->TimesRetry = 0;
3512
3513 goto Retry;
3514 } else {
3515 Token->TransactionStatus = EFI_DEVICE_ERROR;
3516 goto Exit;
3517 }
3518 }
3519
3520 //
3521 // This sub-task succeeds, no need to retry.
3522 //
3523 goto Exit;
3524
3525 Retry:
3526 if (Request->InBuffer != NULL) {
3527 //
3528 // SCSI read command
3529 //
3530 if (!ScsiDiskDevice->Cdb16Byte) {
3531 Status = ScsiDiskAsyncRead10 (
3532 ScsiDiskDevice,
3533 Request->Timeout,
3534 Request->TimesRetry,
3535 Request->InBuffer,
3536 Request->DataLength,
3537 (UINT32) Request->StartLba,
3538 Request->SectorCount,
3539 Request->BlkIo2Req,
3540 Token
3541 );
3542 } else {
3543 Status = ScsiDiskAsyncRead16 (
3544 ScsiDiskDevice,
3545 Request->Timeout,
3546 Request->TimesRetry,
3547 Request->InBuffer,
3548 Request->DataLength,
3549 Request->StartLba,
3550 Request->SectorCount,
3551 Request->BlkIo2Req,
3552 Token
3553 );
3554 }
3555
3556 if (EFI_ERROR (Status)) {
3557 Token->TransactionStatus = EFI_DEVICE_ERROR;
3558 goto Exit;
3559 } else if (OldSectorCount != Request->SectorCount) {
3560 //
3561 // Original sub-task will be split into two new sub-tasks with smaller
3562 // DataLength
3563 //
3564 if (!ScsiDiskDevice->Cdb16Byte) {
3565 Status = ScsiDiskAsyncRead10 (
3566 ScsiDiskDevice,
3567 Request->Timeout,
3568 0,
3569 Request->InBuffer + Request->SectorCount * ScsiDiskDevice->BlkIo.Media->BlockSize,
3570 OldDataLength - Request->DataLength,
3571 (UINT32) Request->StartLba + Request->SectorCount,
3572 OldSectorCount - Request->SectorCount,
3573 Request->BlkIo2Req,
3574 Token
3575 );
3576 } else {
3577 Status = ScsiDiskAsyncRead16 (
3578 ScsiDiskDevice,
3579 Request->Timeout,
3580 0,
3581 Request->InBuffer + Request->SectorCount * ScsiDiskDevice->BlkIo.Media->BlockSize,
3582 OldDataLength - Request->DataLength,
3583 Request->StartLba + Request->SectorCount,
3584 OldSectorCount - Request->SectorCount,
3585 Request->BlkIo2Req,
3586 Token
3587 );
3588 }
3589 if (EFI_ERROR (Status)) {
3590 Token->TransactionStatus = EFI_DEVICE_ERROR;
3591 goto Exit;
3592 }
3593 }
3594 } else {
3595 //
3596 // SCSI write command
3597 //
3598 if (!ScsiDiskDevice->Cdb16Byte) {
3599 Status = ScsiDiskAsyncWrite10 (
3600 ScsiDiskDevice,
3601 Request->Timeout,
3602 Request->TimesRetry,
3603 Request->OutBuffer,
3604 Request->DataLength,
3605 (UINT32) Request->StartLba,
3606 Request->SectorCount,
3607 Request->BlkIo2Req,
3608 Token
3609 );
3610 } else {
3611 Status = ScsiDiskAsyncWrite16 (
3612 ScsiDiskDevice,
3613 Request->Timeout,
3614 Request->TimesRetry,
3615 Request->OutBuffer,
3616 Request->DataLength,
3617 Request->StartLba,
3618 Request->SectorCount,
3619 Request->BlkIo2Req,
3620 Token
3621 );
3622 }
3623
3624 if (EFI_ERROR (Status)) {
3625 Token->TransactionStatus = EFI_DEVICE_ERROR;
3626 goto Exit;
3627 } else if (OldSectorCount != Request->SectorCount) {
3628 //
3629 // Original sub-task will be split into two new sub-tasks with smaller
3630 // DataLength
3631 //
3632 if (!ScsiDiskDevice->Cdb16Byte) {
3633 Status = ScsiDiskAsyncWrite10 (
3634 ScsiDiskDevice,
3635 Request->Timeout,
3636 0,
3637 Request->OutBuffer + Request->SectorCount * ScsiDiskDevice->BlkIo.Media->BlockSize,
3638 OldDataLength - Request->DataLength,
3639 (UINT32) Request->StartLba + Request->SectorCount,
3640 OldSectorCount - Request->SectorCount,
3641 Request->BlkIo2Req,
3642 Token
3643 );
3644 } else {
3645 Status = ScsiDiskAsyncWrite16 (
3646 ScsiDiskDevice,
3647 Request->Timeout,
3648 0,
3649 Request->OutBuffer + Request->SectorCount * ScsiDiskDevice->BlkIo.Media->BlockSize,
3650 OldDataLength - Request->DataLength,
3651 Request->StartLba + Request->SectorCount,
3652 OldSectorCount - Request->SectorCount,
3653 Request->BlkIo2Req,
3654 Token
3655 );
3656 }
3657 if (EFI_ERROR (Status)) {
3658 Token->TransactionStatus = EFI_DEVICE_ERROR;
3659 goto Exit;
3660 }
3661 }
3662 }
3663
3664 Exit:
3665 RemoveEntryList (&Request->Link);
3666 if (IsListEmpty (&Request->BlkIo2Req->ScsiRWQueue)) {
3667 //
3668 // The last SCSI R/W command of a BlockIo2 request completes
3669 //
3670 RemoveEntryList (&Request->BlkIo2Req->Link);
3671 FreePool (Request->BlkIo2Req); // Should be freed only once
3672 gBS->SignalEvent (Token->Event);
3673 }
3674
3675 FreePool (Request->SenseData);
3676 FreePool (Request);
3677 }
3678
3679
3680 /**
3681 Submit Async Read(10) command.
3682
3683 @param ScsiDiskDevice The pointer of ScsiDiskDevice.
3684 @param Timeout The time to complete the command.
3685 @param TimesRetry The number of times the command has been retried.
3686 @param DataBuffer The buffer to fill with the read out data.
3687 @param DataLength The length of buffer.
3688 @param StartLba The start logic block address.
3689 @param SectorCount The number of blocks to read.
3690 @param BlkIo2Req The upstream BlockIo2 request.
3691 @param Token The pointer to the token associated with the
3692 non-blocking read request.
3693
3694 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a
3695 lack of resources.
3696 @return others Status returned by calling
3697 ScsiRead10CommandEx().
3698
3699 **/
3700 EFI_STATUS
3701 ScsiDiskAsyncRead10 (
3702 IN SCSI_DISK_DEV *ScsiDiskDevice,
3703 IN UINT64 Timeout,
3704 IN UINT8 TimesRetry,
3705 OUT UINT8 *DataBuffer,
3706 IN UINT32 DataLength,
3707 IN UINT32 StartLba,
3708 IN UINT32 SectorCount,
3709 IN OUT SCSI_BLKIO2_REQUEST *BlkIo2Req,
3710 IN EFI_BLOCK_IO2_TOKEN *Token
3711 )
3712 {
3713 EFI_STATUS Status;
3714 SCSI_ASYNC_RW_REQUEST *Request;
3715 EFI_EVENT AsyncIoEvent;
3716
3717 AsyncIoEvent = NULL;
3718
3719 Request = AllocateZeroPool (sizeof (SCSI_ASYNC_RW_REQUEST));
3720 if (Request == NULL) {
3721 return EFI_OUT_OF_RESOURCES;
3722 }
3723 InsertTailList (&BlkIo2Req->ScsiRWQueue, &Request->Link);
3724
3725 Request->SenseDataLength = (UINT8) (6 * sizeof (EFI_SCSI_SENSE_DATA));
3726 Request->SenseData = AllocateZeroPool (Request->SenseDataLength);
3727 if (Request->SenseData == NULL) {
3728 Status = EFI_OUT_OF_RESOURCES;
3729 goto ErrorExit;
3730 }
3731
3732 Request->ScsiDiskDevice = ScsiDiskDevice;
3733 Request->Timeout = Timeout;
3734 Request->TimesRetry = TimesRetry;
3735 Request->InBuffer = DataBuffer;
3736 Request->DataLength = DataLength;
3737 Request->StartLba = StartLba;
3738 Request->SectorCount = SectorCount;
3739 Request->BlkIo2Req = BlkIo2Req;
3740
3741 //
3742 // Create Event
3743 //
3744 Status = gBS->CreateEvent (
3745 EVT_NOTIFY_SIGNAL,
3746 TPL_CALLBACK,
3747 ScsiDiskNotify,
3748 Request,
3749 &AsyncIoEvent
3750 );
3751 if (EFI_ERROR(Status)) {
3752 goto ErrorExit;
3753 }
3754
3755 Status = ScsiRead10CommandEx (
3756 ScsiDiskDevice->ScsiIo,
3757 Request->Timeout,
3758 Request->SenseData,
3759 &Request->SenseDataLength,
3760 &Request->HostAdapterStatus,
3761 &Request->TargetStatus,
3762 Request->InBuffer,
3763 &Request->DataLength,
3764 (UINT32) Request->StartLba,
3765 Request->SectorCount,
3766 AsyncIoEvent
3767 );
3768 if (EFI_ERROR(Status)) {
3769 goto ErrorExit;
3770 }
3771
3772 return EFI_SUCCESS;
3773
3774 ErrorExit:
3775 if (AsyncIoEvent != NULL) {
3776 gBS->CloseEvent (AsyncIoEvent);
3777 }
3778
3779 if (Request != NULL) {
3780 if (Request->SenseData != NULL) {
3781 FreePool (Request->SenseData);
3782 }
3783
3784 RemoveEntryList (&Request->Link);
3785 FreePool (Request);
3786 }
3787
3788 return Status;
3789 }
3790
3791
3792 /**
3793 Submit Async Write(10) command.
3794
3795 @param ScsiDiskDevice The pointer of ScsiDiskDevice.
3796 @param Timeout The time to complete the command.
3797 @param TimesRetry The number of times the command has been retried.
3798 @param DataBuffer The buffer contains the data to write.
3799 @param DataLength The length of buffer.
3800 @param StartLba The start logic block address.
3801 @param SectorCount The number of blocks to write.
3802 @param BlkIo2Req The upstream BlockIo2 request.
3803 @param Token The pointer to the token associated with the
3804 non-blocking read request.
3805
3806 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a
3807 lack of resources.
3808 @return others Status returned by calling
3809 ScsiWrite10CommandEx().
3810
3811 **/
3812 EFI_STATUS
3813 ScsiDiskAsyncWrite10 (
3814 IN SCSI_DISK_DEV *ScsiDiskDevice,
3815 IN UINT64 Timeout,
3816 IN UINT8 TimesRetry,
3817 IN UINT8 *DataBuffer,
3818 IN UINT32 DataLength,
3819 IN UINT32 StartLba,
3820 IN UINT32 SectorCount,
3821 IN OUT SCSI_BLKIO2_REQUEST *BlkIo2Req,
3822 IN EFI_BLOCK_IO2_TOKEN *Token
3823 )
3824 {
3825 EFI_STATUS Status;
3826 SCSI_ASYNC_RW_REQUEST *Request;
3827 EFI_EVENT AsyncIoEvent;
3828
3829 AsyncIoEvent = NULL;
3830
3831 Request = AllocateZeroPool (sizeof (SCSI_ASYNC_RW_REQUEST));
3832 if (Request == NULL) {
3833 return EFI_OUT_OF_RESOURCES;
3834 }
3835 InsertTailList (&BlkIo2Req->ScsiRWQueue, &Request->Link);
3836
3837 Request->SenseDataLength = (UINT8) (6 * sizeof (EFI_SCSI_SENSE_DATA));
3838 Request->SenseData = AllocateZeroPool (Request->SenseDataLength);
3839 if (Request->SenseData == NULL) {
3840 Status = EFI_OUT_OF_RESOURCES;
3841 goto ErrorExit;
3842 }
3843
3844 Request->ScsiDiskDevice = ScsiDiskDevice;
3845 Request->Timeout = Timeout;
3846 Request->TimesRetry = TimesRetry;
3847 Request->OutBuffer = DataBuffer;
3848 Request->DataLength = DataLength;
3849 Request->StartLba = StartLba;
3850 Request->SectorCount = SectorCount;
3851 Request->BlkIo2Req = BlkIo2Req;
3852
3853 //
3854 // Create Event
3855 //
3856 Status = gBS->CreateEvent (
3857 EVT_NOTIFY_SIGNAL,
3858 TPL_CALLBACK,
3859 ScsiDiskNotify,
3860 Request,
3861 &AsyncIoEvent
3862 );
3863 if (EFI_ERROR(Status)) {
3864 goto ErrorExit;
3865 }
3866
3867 Status = ScsiWrite10CommandEx (
3868 ScsiDiskDevice->ScsiIo,
3869 Request->Timeout,
3870 Request->SenseData,
3871 &Request->SenseDataLength,
3872 &Request->HostAdapterStatus,
3873 &Request->TargetStatus,
3874 Request->OutBuffer,
3875 &Request->DataLength,
3876 (UINT32) Request->StartLba,
3877 Request->SectorCount,
3878 AsyncIoEvent
3879 );
3880 if (EFI_ERROR(Status)) {
3881 goto ErrorExit;
3882 }
3883
3884 return EFI_SUCCESS;
3885
3886 ErrorExit:
3887 if (AsyncIoEvent != NULL) {
3888 gBS->CloseEvent (AsyncIoEvent);
3889 }
3890
3891 if (Request != NULL) {
3892 if (Request->SenseData != NULL) {
3893 FreePool (Request->SenseData);
3894 }
3895
3896 RemoveEntryList (&Request->Link);
3897 FreePool (Request);
3898 }
3899
3900 return Status;
3901 }
3902
3903
3904 /**
3905 Submit Async Read(16) command.
3906
3907 @param ScsiDiskDevice The pointer of ScsiDiskDevice.
3908 @param Timeout The time to complete the command.
3909 @param TimesRetry The number of times the command has been retried.
3910 @param DataBuffer The buffer to fill with the read out data.
3911 @param DataLength The length of buffer.
3912 @param StartLba The start logic block address.
3913 @param SectorCount The number of blocks to read.
3914 @param BlkIo2Req The upstream BlockIo2 request.
3915 @param Token The pointer to the token associated with the
3916 non-blocking read request.
3917
3918 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a
3919 lack of resources.
3920 @return others Status returned by calling
3921 ScsiRead16CommandEx().
3922
3923 **/
3924 EFI_STATUS
3925 ScsiDiskAsyncRead16 (
3926 IN SCSI_DISK_DEV *ScsiDiskDevice,
3927 IN UINT64 Timeout,
3928 IN UINT8 TimesRetry,
3929 OUT UINT8 *DataBuffer,
3930 IN UINT32 DataLength,
3931 IN UINT64 StartLba,
3932 IN UINT32 SectorCount,
3933 IN OUT SCSI_BLKIO2_REQUEST *BlkIo2Req,
3934 IN EFI_BLOCK_IO2_TOKEN *Token
3935 )
3936 {
3937 EFI_STATUS Status;
3938 SCSI_ASYNC_RW_REQUEST *Request;
3939 EFI_EVENT AsyncIoEvent;
3940
3941 AsyncIoEvent = NULL;
3942
3943 Request = AllocateZeroPool (sizeof (SCSI_ASYNC_RW_REQUEST));
3944 if (Request == NULL) {
3945 return EFI_OUT_OF_RESOURCES;
3946 }
3947 InsertTailList (&BlkIo2Req->ScsiRWQueue, &Request->Link);
3948
3949 Request->SenseDataLength = (UINT8) (6 * sizeof (EFI_SCSI_SENSE_DATA));
3950 Request->SenseData = AllocateZeroPool (Request->SenseDataLength);
3951 if (Request->SenseData == NULL) {
3952 Status = EFI_OUT_OF_RESOURCES;
3953 goto ErrorExit;
3954 }
3955
3956 Request->ScsiDiskDevice = ScsiDiskDevice;
3957 Request->Timeout = Timeout;
3958 Request->TimesRetry = TimesRetry;
3959 Request->InBuffer = DataBuffer;
3960 Request->DataLength = DataLength;
3961 Request->StartLba = StartLba;
3962 Request->SectorCount = SectorCount;
3963 Request->BlkIo2Req = BlkIo2Req;
3964
3965 //
3966 // Create Event
3967 //
3968 Status = gBS->CreateEvent (
3969 EVT_NOTIFY_SIGNAL,
3970 TPL_CALLBACK,
3971 ScsiDiskNotify,
3972 Request,
3973 &AsyncIoEvent
3974 );
3975 if (EFI_ERROR(Status)) {
3976 goto ErrorExit;
3977 }
3978
3979 Status = ScsiRead16CommandEx (
3980 ScsiDiskDevice->ScsiIo,
3981 Request->Timeout,
3982 Request->SenseData,
3983 &Request->SenseDataLength,
3984 &Request->HostAdapterStatus,
3985 &Request->TargetStatus,
3986 Request->InBuffer,
3987 &Request->DataLength,
3988 Request->StartLba,
3989 Request->SectorCount,
3990 AsyncIoEvent
3991 );
3992 if (EFI_ERROR(Status)) {
3993 goto ErrorExit;
3994 }
3995
3996 return EFI_SUCCESS;
3997
3998 ErrorExit:
3999 if (AsyncIoEvent != NULL) {
4000 gBS->CloseEvent (AsyncIoEvent);
4001 }
4002
4003 if (Request != NULL) {
4004 if (Request->SenseData != NULL) {
4005 FreePool (Request->SenseData);
4006 }
4007
4008 RemoveEntryList (&Request->Link);
4009 FreePool (Request);
4010 }
4011
4012 return Status;
4013 }
4014
4015
4016 /**
4017 Submit Async Write(16) command.
4018
4019 @param ScsiDiskDevice The pointer of ScsiDiskDevice.
4020 @param Timeout The time to complete the command.
4021 @param TimesRetry The number of times the command has been retried.
4022 @param DataBuffer The buffer contains the data to write.
4023 @param DataLength The length of buffer.
4024 @param StartLba The start logic block address.
4025 @param SectorCount The number of blocks to write.
4026 @param BlkIo2Req The upstream BlockIo2 request.
4027 @param Token The pointer to the token associated with the
4028 non-blocking read request.
4029
4030 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a
4031 lack of resources.
4032 @return others Status returned by calling
4033 ScsiWrite16CommandEx().
4034
4035 **/
4036 EFI_STATUS
4037 ScsiDiskAsyncWrite16 (
4038 IN SCSI_DISK_DEV *ScsiDiskDevice,
4039 IN UINT64 Timeout,
4040 IN UINT8 TimesRetry,
4041 IN UINT8 *DataBuffer,
4042 IN UINT32 DataLength,
4043 IN UINT64 StartLba,
4044 IN UINT32 SectorCount,
4045 IN OUT SCSI_BLKIO2_REQUEST *BlkIo2Req,
4046 IN EFI_BLOCK_IO2_TOKEN *Token
4047 )
4048 {
4049 EFI_STATUS Status;
4050 SCSI_ASYNC_RW_REQUEST *Request;
4051 EFI_EVENT AsyncIoEvent;
4052
4053 AsyncIoEvent = NULL;
4054
4055 Request = AllocateZeroPool (sizeof (SCSI_ASYNC_RW_REQUEST));
4056 if (Request == NULL) {
4057 return EFI_OUT_OF_RESOURCES;
4058 }
4059 InsertTailList (&BlkIo2Req->ScsiRWQueue, &Request->Link);
4060
4061 Request->SenseDataLength = (UINT8) (6 * sizeof (EFI_SCSI_SENSE_DATA));
4062 Request->SenseData = AllocateZeroPool (Request->SenseDataLength);
4063 if (Request->SenseData == NULL) {
4064 Status = EFI_OUT_OF_RESOURCES;
4065 goto ErrorExit;
4066 }
4067
4068 Request->ScsiDiskDevice = ScsiDiskDevice;
4069 Request->Timeout = Timeout;
4070 Request->TimesRetry = TimesRetry;
4071 Request->OutBuffer = DataBuffer;
4072 Request->DataLength = DataLength;
4073 Request->StartLba = StartLba;
4074 Request->SectorCount = SectorCount;
4075 Request->BlkIo2Req = BlkIo2Req;
4076
4077 //
4078 // Create Event
4079 //
4080 Status = gBS->CreateEvent (
4081 EVT_NOTIFY_SIGNAL,
4082 TPL_CALLBACK,
4083 ScsiDiskNotify,
4084 Request,
4085 &AsyncIoEvent
4086 );
4087 if (EFI_ERROR(Status)) {
4088 goto ErrorExit;
4089 }
4090
4091 Status = ScsiWrite16CommandEx (
4092 ScsiDiskDevice->ScsiIo,
4093 Request->Timeout,
4094 Request->SenseData,
4095 &Request->SenseDataLength,
4096 &Request->HostAdapterStatus,
4097 &Request->TargetStatus,
4098 Request->OutBuffer,
4099 &Request->DataLength,
4100 Request->StartLba,
4101 Request->SectorCount,
4102 AsyncIoEvent
4103 );
4104 if (EFI_ERROR(Status)) {
4105 goto ErrorExit;
4106 }
4107
4108 return EFI_SUCCESS;
4109
4110 ErrorExit:
4111 if (AsyncIoEvent != NULL) {
4112 gBS->CloseEvent (AsyncIoEvent);
4113 }
4114
4115 if (Request != NULL) {
4116 if (Request->SenseData != NULL) {
4117 FreePool (Request->SenseData);
4118 }
4119
4120 RemoveEntryList (&Request->Link);
4121 FreePool (Request);
4122 }
4123
4124 return Status;
4125 }
4126
4127
4128 /**
4129 Check sense key to find if media presents.
4130
4131 @param SenseData The pointer of EFI_SCSI_SENSE_DATA
4132 @param SenseCounts The number of sense key
4133
4134 @retval TRUE NOT any media
4135 @retval FALSE Media presents
4136 **/
4137 BOOLEAN
4138 ScsiDiskIsNoMedia (
4139 IN EFI_SCSI_SENSE_DATA *SenseData,
4140 IN UINTN SenseCounts
4141 )
4142 {
4143 EFI_SCSI_SENSE_DATA *SensePtr;
4144 UINTN Index;
4145 BOOLEAN IsNoMedia;
4146
4147 IsNoMedia = FALSE;
4148 SensePtr = SenseData;
4149
4150 for (Index = 0; Index < SenseCounts; Index++) {
4151 //
4152 // Sense Key is EFI_SCSI_SK_NOT_READY (0x2),
4153 // Additional Sense Code is ASC_NO_MEDIA (0x3A)
4154 //
4155 if ((SensePtr->Sense_Key == EFI_SCSI_SK_NOT_READY) &&
4156 (SensePtr->Addnl_Sense_Code == EFI_SCSI_ASC_NO_MEDIA)) {
4157 IsNoMedia = TRUE;
4158 }
4159 SensePtr++;
4160 }
4161
4162 return IsNoMedia;
4163 }
4164
4165
4166 /**
4167 Parse sense key.
4168
4169 @param SenseData The pointer of EFI_SCSI_SENSE_DATA
4170 @param SenseCounts The number of sense key
4171
4172 @retval TRUE Error
4173 @retval FALSE NOT error
4174
4175 **/
4176 BOOLEAN
4177 ScsiDiskIsMediaError (
4178 IN EFI_SCSI_SENSE_DATA *SenseData,
4179 IN UINTN SenseCounts
4180 )
4181 {
4182 EFI_SCSI_SENSE_DATA *SensePtr;
4183 UINTN Index;
4184 BOOLEAN IsError;
4185
4186 IsError = FALSE;
4187 SensePtr = SenseData;
4188
4189 for (Index = 0; Index < SenseCounts; Index++) {
4190
4191 switch (SensePtr->Sense_Key) {
4192
4193 case EFI_SCSI_SK_MEDIUM_ERROR:
4194 //
4195 // Sense Key is EFI_SCSI_SK_MEDIUM_ERROR (0x3)
4196 //
4197 switch (SensePtr->Addnl_Sense_Code) {
4198
4199 //
4200 // fall through
4201 //
4202 case EFI_SCSI_ASC_MEDIA_ERR1:
4203
4204 //
4205 // fall through
4206 //
4207 case EFI_SCSI_ASC_MEDIA_ERR2:
4208
4209 //
4210 // fall through
4211 //
4212 case EFI_SCSI_ASC_MEDIA_ERR3:
4213 case EFI_SCSI_ASC_MEDIA_ERR4:
4214 IsError = TRUE;
4215 break;
4216
4217 default:
4218 break;
4219 }
4220
4221 break;
4222
4223 case EFI_SCSI_SK_NOT_READY:
4224 //
4225 // Sense Key is EFI_SCSI_SK_NOT_READY (0x2)
4226 //
4227 switch (SensePtr->Addnl_Sense_Code) {
4228 //
4229 // Additional Sense Code is ASC_MEDIA_UPSIDE_DOWN (0x6)
4230 //
4231 case EFI_SCSI_ASC_MEDIA_UPSIDE_DOWN:
4232 IsError = TRUE;
4233 break;
4234
4235 default:
4236 break;
4237 }
4238 break;
4239
4240 default:
4241 break;
4242 }
4243
4244 SensePtr++;
4245 }
4246
4247 return IsError;
4248 }
4249
4250
4251 /**
4252 Check sense key to find if hardware error happens.
4253
4254 @param SenseData The pointer of EFI_SCSI_SENSE_DATA
4255 @param SenseCounts The number of sense key
4256
4257 @retval TRUE Hardware error exits.
4258 @retval FALSE NO error.
4259
4260 **/
4261 BOOLEAN
4262 ScsiDiskIsHardwareError (
4263 IN EFI_SCSI_SENSE_DATA *SenseData,
4264 IN UINTN SenseCounts
4265 )
4266 {
4267 EFI_SCSI_SENSE_DATA *SensePtr;
4268 UINTN Index;
4269 BOOLEAN IsError;
4270
4271 IsError = FALSE;
4272 SensePtr = SenseData;
4273
4274 for (Index = 0; Index < SenseCounts; Index++) {
4275
4276 //
4277 // Sense Key is EFI_SCSI_SK_HARDWARE_ERROR (0x4)
4278 //
4279 if (SensePtr->Sense_Key == EFI_SCSI_SK_HARDWARE_ERROR) {
4280 IsError = TRUE;
4281 }
4282
4283 SensePtr++;
4284 }
4285
4286 return IsError;
4287 }
4288
4289
4290 /**
4291 Check sense key to find if media has changed.
4292
4293 @param SenseData The pointer of EFI_SCSI_SENSE_DATA
4294 @param SenseCounts The number of sense key
4295
4296 @retval TRUE Media is changed.
4297 @retval FALSE Media is NOT changed.
4298 **/
4299 BOOLEAN
4300 ScsiDiskIsMediaChange (
4301 IN EFI_SCSI_SENSE_DATA *SenseData,
4302 IN UINTN SenseCounts
4303 )
4304 {
4305 EFI_SCSI_SENSE_DATA *SensePtr;
4306 UINTN Index;
4307 BOOLEAN IsMediaChanged;
4308
4309 IsMediaChanged = FALSE;
4310 SensePtr = SenseData;
4311
4312 for (Index = 0; Index < SenseCounts; Index++) {
4313 //
4314 // Sense Key is EFI_SCSI_SK_UNIT_ATTENTION (0x6),
4315 // Additional sense code is EFI_SCSI_ASC_MEDIA_CHANGE (0x28)
4316 //
4317 if ((SensePtr->Sense_Key == EFI_SCSI_SK_UNIT_ATTENTION) &&
4318 (SensePtr->Addnl_Sense_Code == EFI_SCSI_ASC_MEDIA_CHANGE)) {
4319 IsMediaChanged = TRUE;
4320 }
4321
4322 SensePtr++;
4323 }
4324
4325 return IsMediaChanged;
4326 }
4327
4328 /**
4329 Check sense key to find if reset happens.
4330
4331 @param SenseData The pointer of EFI_SCSI_SENSE_DATA
4332 @param SenseCounts The number of sense key
4333
4334 @retval TRUE It is reset before.
4335 @retval FALSE It is NOT reset before.
4336
4337 **/
4338 BOOLEAN
4339 ScsiDiskIsResetBefore (
4340 IN EFI_SCSI_SENSE_DATA *SenseData,
4341 IN UINTN SenseCounts
4342 )
4343 {
4344 EFI_SCSI_SENSE_DATA *SensePtr;
4345 UINTN Index;
4346 BOOLEAN IsResetBefore;
4347
4348 IsResetBefore = FALSE;
4349 SensePtr = SenseData;
4350
4351 for (Index = 0; Index < SenseCounts; Index++) {
4352
4353 //
4354 // Sense Key is EFI_SCSI_SK_UNIT_ATTENTION (0x6)
4355 // Additional Sense Code is EFI_SCSI_ASC_RESET (0x29)
4356 //
4357 if ((SensePtr->Sense_Key == EFI_SCSI_SK_UNIT_ATTENTION) &&
4358 (SensePtr->Addnl_Sense_Code == EFI_SCSI_ASC_RESET)) {
4359 IsResetBefore = TRUE;
4360 }
4361
4362 SensePtr++;
4363 }
4364
4365 return IsResetBefore;
4366 }
4367
4368 /**
4369 Check sense key to find if the drive is ready.
4370
4371 @param SenseData The pointer of EFI_SCSI_SENSE_DATA
4372 @param SenseCounts The number of sense key
4373 @param RetryLater The flag means if need a retry
4374
4375 @retval TRUE Drive is ready.
4376 @retval FALSE Drive is NOT ready.
4377
4378 **/
4379 BOOLEAN
4380 ScsiDiskIsDriveReady (
4381 IN EFI_SCSI_SENSE_DATA *SenseData,
4382 IN UINTN SenseCounts,
4383 OUT BOOLEAN *RetryLater
4384 )
4385 {
4386 EFI_SCSI_SENSE_DATA *SensePtr;
4387 UINTN Index;
4388 BOOLEAN IsReady;
4389
4390 IsReady = TRUE;
4391 *RetryLater = FALSE;
4392 SensePtr = SenseData;
4393
4394 for (Index = 0; Index < SenseCounts; Index++) {
4395
4396 switch (SensePtr->Sense_Key) {
4397
4398 case EFI_SCSI_SK_NOT_READY:
4399 //
4400 // Sense Key is EFI_SCSI_SK_NOT_READY (0x2)
4401 //
4402 switch (SensePtr->Addnl_Sense_Code) {
4403 case EFI_SCSI_ASC_NOT_READY:
4404 //
4405 // Additional Sense Code is EFI_SCSI_ASC_NOT_READY (0x4)
4406 //
4407 switch (SensePtr->Addnl_Sense_Code_Qualifier) {
4408 case EFI_SCSI_ASCQ_IN_PROGRESS:
4409 //
4410 // Additional Sense Code Qualifier is
4411 // EFI_SCSI_ASCQ_IN_PROGRESS (0x1)
4412 //
4413 IsReady = FALSE;
4414 *RetryLater = TRUE;
4415 break;
4416
4417 default:
4418 IsReady = FALSE;
4419 *RetryLater = FALSE;
4420 break;
4421 }
4422 break;
4423
4424 default:
4425 break;
4426 }
4427 break;
4428
4429 default:
4430 break;
4431 }
4432
4433 SensePtr++;
4434 }
4435
4436 return IsReady;
4437 }
4438
4439 /**
4440 Check sense key to find if it has sense key.
4441
4442 @param SenseData - The pointer of EFI_SCSI_SENSE_DATA
4443 @param SenseCounts - The number of sense key
4444
4445 @retval TRUE It has sense key.
4446 @retval FALSE It has NOT any sense key.
4447
4448 **/
4449 BOOLEAN
4450 ScsiDiskHaveSenseKey (
4451 IN EFI_SCSI_SENSE_DATA *SenseData,
4452 IN UINTN SenseCounts
4453 )
4454 {
4455 EFI_SCSI_SENSE_DATA *SensePtr;
4456 UINTN Index;
4457 BOOLEAN HaveSenseKey;
4458
4459 if (SenseCounts == 0) {
4460 HaveSenseKey = FALSE;
4461 } else {
4462 HaveSenseKey = TRUE;
4463 }
4464
4465 SensePtr = SenseData;
4466
4467 for (Index = 0; Index < SenseCounts; Index++) {
4468
4469 //
4470 // Sense Key is SK_NO_SENSE (0x0)
4471 //
4472 if ((SensePtr->Sense_Key == EFI_SCSI_SK_NO_SENSE) &&
4473 (Index == 0)) {
4474 HaveSenseKey = FALSE;
4475 }
4476
4477 SensePtr++;
4478 }
4479
4480 return HaveSenseKey;
4481 }
4482
4483 /**
4484 Release resource about disk device.
4485
4486 @param ScsiDiskDevice The pointer of SCSI_DISK_DEV
4487
4488 **/
4489 VOID
4490 ReleaseScsiDiskDeviceResources (
4491 IN SCSI_DISK_DEV *ScsiDiskDevice
4492 )
4493 {
4494 if (ScsiDiskDevice == NULL) {
4495 return ;
4496 }
4497
4498 if (ScsiDiskDevice->SenseData != NULL) {
4499 FreePool (ScsiDiskDevice->SenseData);
4500 ScsiDiskDevice->SenseData = NULL;
4501 }
4502
4503 if (ScsiDiskDevice->ControllerNameTable != NULL) {
4504 FreeUnicodeStringTable (ScsiDiskDevice->ControllerNameTable);
4505 ScsiDiskDevice->ControllerNameTable = NULL;
4506 }
4507
4508 FreePool (ScsiDiskDevice);
4509
4510 ScsiDiskDevice = NULL;
4511 }
4512
4513 /**
4514 Determine if Block Io & Block Io2 should be produced.
4515
4516
4517 @param ChildHandle Child Handle to retrieve Parent information.
4518
4519 @retval TRUE Should produce Block Io & Block Io2.
4520 @retval FALSE Should not produce Block Io & Block Io2.
4521
4522 **/
4523 BOOLEAN
4524 DetermineInstallBlockIo (
4525 IN EFI_HANDLE ChildHandle
4526 )
4527 {
4528 EFI_SCSI_PASS_THRU_PROTOCOL *ScsiPassThru;
4529 EFI_EXT_SCSI_PASS_THRU_PROTOCOL *ExtScsiPassThru;
4530
4531 //
4532 // Firstly, check if ExtScsiPassThru Protocol parent handle exists. If existence,
4533 // check its attribute, logic or physical.
4534 //
4535 ExtScsiPassThru = (EFI_EXT_SCSI_PASS_THRU_PROTOCOL *)GetParentProtocol (&gEfiExtScsiPassThruProtocolGuid, ChildHandle);
4536 if (ExtScsiPassThru != NULL) {
4537 if ((ExtScsiPassThru->Mode->Attributes & EFI_SCSI_PASS_THRU_ATTRIBUTES_LOGICAL) != 0) {
4538 return TRUE;
4539 }
4540 }
4541
4542 //
4543 // Secondly, check if ScsiPassThru Protocol parent handle exists. If existence,
4544 // check its attribute, logic or physical.
4545 //
4546 ScsiPassThru = (EFI_SCSI_PASS_THRU_PROTOCOL *)GetParentProtocol (&gEfiScsiPassThruProtocolGuid, ChildHandle);
4547 if (ScsiPassThru != NULL) {
4548 if ((ScsiPassThru->Mode->Attributes & EFI_SCSI_PASS_THRU_ATTRIBUTES_LOGICAL) != 0) {
4549 return TRUE;
4550 }
4551 }
4552
4553 return FALSE;
4554 }
4555
4556 /**
4557 Search protocol database and check to see if the protocol
4558 specified by ProtocolGuid is present on a ControllerHandle and opened by
4559 ChildHandle with an attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.
4560 If the ControllerHandle is found, then the protocol specified by ProtocolGuid
4561 will be opened on it.
4562
4563
4564 @param ProtocolGuid ProtocolGuid pointer.
4565 @param ChildHandle Child Handle to retrieve Parent information.
4566
4567 **/
4568 VOID *
4569 EFIAPI
4570 GetParentProtocol (
4571 IN EFI_GUID *ProtocolGuid,
4572 IN EFI_HANDLE ChildHandle
4573 )
4574 {
4575 UINTN Index;
4576 UINTN HandleCount;
4577 VOID *Interface;
4578 EFI_STATUS Status;
4579 EFI_HANDLE *HandleBuffer;
4580
4581 //
4582 // Retrieve the list of all handles from the handle database
4583 //
4584 Status = gBS->LocateHandleBuffer (
4585 ByProtocol,
4586 ProtocolGuid,
4587 NULL,
4588 &HandleCount,
4589 &HandleBuffer
4590 );
4591
4592 if (EFI_ERROR (Status)) {
4593 return NULL;
4594 }
4595
4596 //
4597 // Iterate to find who is parent handle that is opened with ProtocolGuid by ChildHandle
4598 //
4599 for (Index = 0; Index < HandleCount; Index++) {
4600 Status = EfiTestChildHandle (HandleBuffer[Index], ChildHandle, ProtocolGuid);
4601 if (!EFI_ERROR (Status)) {
4602 Status = gBS->HandleProtocol (HandleBuffer[Index], ProtocolGuid, (VOID **)&Interface);
4603 if (!EFI_ERROR (Status)) {
4604 gBS->FreePool (HandleBuffer);
4605 return Interface;
4606 }
4607 }
4608 }
4609
4610 gBS->FreePool (HandleBuffer);
4611 return NULL;
4612 }
4613
4614 /**
4615 Provides inquiry information for the controller type.
4616
4617 This function is used by the IDE bus driver to get inquiry data. Data format
4618 of Identify data is defined by the Interface GUID.
4619
4620 @param[in] This Pointer to the EFI_DISK_INFO_PROTOCOL instance.
4621 @param[in, out] InquiryData Pointer to a buffer for the inquiry data.
4622 @param[in, out] InquiryDataSize Pointer to the value for the inquiry data size.
4623
4624 @retval EFI_SUCCESS The command was accepted without any errors.
4625 @retval EFI_NOT_FOUND Device does not support this data class
4626 @retval EFI_DEVICE_ERROR Error reading InquiryData from device
4627 @retval EFI_BUFFER_TOO_SMALL InquiryDataSize not big enough
4628
4629 **/
4630 EFI_STATUS
4631 EFIAPI
4632 ScsiDiskInfoInquiry (
4633 IN EFI_DISK_INFO_PROTOCOL *This,
4634 IN OUT VOID *InquiryData,
4635 IN OUT UINT32 *InquiryDataSize
4636 )
4637 {
4638 EFI_STATUS Status;
4639 SCSI_DISK_DEV *ScsiDiskDevice;
4640
4641 ScsiDiskDevice = SCSI_DISK_DEV_FROM_DISKINFO (This);
4642
4643 Status = EFI_BUFFER_TOO_SMALL;
4644 if (*InquiryDataSize >= sizeof (ScsiDiskDevice->InquiryData)) {
4645 Status = EFI_SUCCESS;
4646 CopyMem (InquiryData, &ScsiDiskDevice->InquiryData, sizeof (ScsiDiskDevice->InquiryData));
4647 }
4648 *InquiryDataSize = sizeof (ScsiDiskDevice->InquiryData);
4649 return Status;
4650 }
4651
4652
4653 /**
4654 Provides identify information for the controller type.
4655
4656 This function is used by the IDE bus driver to get identify data. Data format
4657 of Identify data is defined by the Interface GUID.
4658
4659 @param[in] This Pointer to the EFI_DISK_INFO_PROTOCOL
4660 instance.
4661 @param[in, out] IdentifyData Pointer to a buffer for the identify data.
4662 @param[in, out] IdentifyDataSize Pointer to the value for the identify data
4663 size.
4664
4665 @retval EFI_SUCCESS The command was accepted without any errors.
4666 @retval EFI_NOT_FOUND Device does not support this data class
4667 @retval EFI_DEVICE_ERROR Error reading IdentifyData from device
4668 @retval EFI_BUFFER_TOO_SMALL IdentifyDataSize not big enough
4669
4670 **/
4671 EFI_STATUS
4672 EFIAPI
4673 ScsiDiskInfoIdentify (
4674 IN EFI_DISK_INFO_PROTOCOL *This,
4675 IN OUT VOID *IdentifyData,
4676 IN OUT UINT32 *IdentifyDataSize
4677 )
4678 {
4679 EFI_STATUS Status;
4680 SCSI_DISK_DEV *ScsiDiskDevice;
4681
4682 if (CompareGuid (&This->Interface, &gEfiDiskInfoScsiInterfaceGuid) || CompareGuid (&This->Interface, &gEfiDiskInfoUfsInterfaceGuid)) {
4683 //
4684 // Physical SCSI bus does not support this data class.
4685 //
4686 return EFI_NOT_FOUND;
4687 }
4688
4689 ScsiDiskDevice = SCSI_DISK_DEV_FROM_DISKINFO (This);
4690
4691 Status = EFI_BUFFER_TOO_SMALL;
4692 if (*IdentifyDataSize >= sizeof (ScsiDiskDevice->IdentifyData)) {
4693 Status = EFI_SUCCESS;
4694 CopyMem (IdentifyData, &ScsiDiskDevice->IdentifyData, sizeof (ScsiDiskDevice->IdentifyData));
4695 }
4696 *IdentifyDataSize = sizeof (ScsiDiskDevice->IdentifyData);
4697 return Status;
4698 }
4699
4700 /**
4701 Provides sense data information for the controller type.
4702
4703 This function is used by the IDE bus driver to get sense data.
4704 Data format of Sense data is defined by the Interface GUID.
4705
4706 @param[in] This Pointer to the EFI_DISK_INFO_PROTOCOL instance.
4707 @param[in, out] SenseData Pointer to the SenseData.
4708 @param[in, out] SenseDataSize Size of SenseData in bytes.
4709 @param[out] SenseDataNumber Pointer to the value for the sense data size.
4710
4711 @retval EFI_SUCCESS The command was accepted without any errors.
4712 @retval EFI_NOT_FOUND Device does not support this data class.
4713 @retval EFI_DEVICE_ERROR Error reading SenseData from device.
4714 @retval EFI_BUFFER_TOO_SMALL SenseDataSize not big enough.
4715
4716 **/
4717 EFI_STATUS
4718 EFIAPI
4719 ScsiDiskInfoSenseData (
4720 IN EFI_DISK_INFO_PROTOCOL *This,
4721 IN OUT VOID *SenseData,
4722 IN OUT UINT32 *SenseDataSize,
4723 OUT UINT8 *SenseDataNumber
4724 )
4725 {
4726 return EFI_NOT_FOUND;
4727 }
4728
4729
4730 /**
4731 This function is used by the IDE bus driver to get controller information.
4732
4733 @param[in] This Pointer to the EFI_DISK_INFO_PROTOCOL instance.
4734 @param[out] IdeChannel Pointer to the Ide Channel number. Primary or secondary.
4735 @param[out] IdeDevice Pointer to the Ide Device number. Master or slave.
4736
4737 @retval EFI_SUCCESS IdeChannel and IdeDevice are valid.
4738 @retval EFI_UNSUPPORTED This is not an IDE device.
4739
4740 **/
4741 EFI_STATUS
4742 EFIAPI
4743 ScsiDiskInfoWhichIde (
4744 IN EFI_DISK_INFO_PROTOCOL *This,
4745 OUT UINT32 *IdeChannel,
4746 OUT UINT32 *IdeDevice
4747 )
4748 {
4749 SCSI_DISK_DEV *ScsiDiskDevice;
4750
4751 if (CompareGuid (&This->Interface, &gEfiDiskInfoScsiInterfaceGuid) || CompareGuid (&This->Interface, &gEfiDiskInfoUfsInterfaceGuid)) {
4752 //
4753 // This is not an IDE physical device.
4754 //
4755 return EFI_UNSUPPORTED;
4756 }
4757
4758 ScsiDiskDevice = SCSI_DISK_DEV_FROM_DISKINFO (This);
4759 *IdeChannel = ScsiDiskDevice->Channel;
4760 *IdeDevice = ScsiDiskDevice->Device;
4761
4762 return EFI_SUCCESS;
4763 }
4764
4765
4766 /**
4767 Issues ATA IDENTIFY DEVICE command to identify ATAPI device.
4768
4769 This function tries to fill 512-byte ATAPI_IDENTIFY_DATA for ATAPI device to
4770 implement Identify() interface for DiskInfo protocol. The ATA command is sent
4771 via SCSI Request Packet.
4772
4773 @param ScsiDiskDevice The pointer of SCSI_DISK_DEV
4774
4775 @retval EFI_SUCCESS The ATAPI device identify data were retrieved successfully.
4776 @retval others Some error occurred during the identification that ATAPI device.
4777
4778 **/
4779 EFI_STATUS
4780 AtapiIdentifyDevice (
4781 IN OUT SCSI_DISK_DEV *ScsiDiskDevice
4782 )
4783 {
4784 EFI_SCSI_IO_SCSI_REQUEST_PACKET CommandPacket;
4785 UINT8 Cdb[6];
4786
4787 //
4788 // Initialize SCSI REQUEST_PACKET and 6-byte Cdb
4789 //
4790 ZeroMem (&CommandPacket, sizeof (CommandPacket));
4791 ZeroMem (Cdb, sizeof (Cdb));
4792
4793 Cdb[0] = ATA_CMD_IDENTIFY_DEVICE;
4794 CommandPacket.Timeout = SCSI_DISK_TIMEOUT;
4795 CommandPacket.Cdb = Cdb;
4796 CommandPacket.CdbLength = (UINT8) sizeof (Cdb);
4797 CommandPacket.InDataBuffer = &ScsiDiskDevice->IdentifyData;
4798 CommandPacket.InTransferLength = sizeof (ScsiDiskDevice->IdentifyData);
4799
4800 return ScsiDiskDevice->ScsiIo->ExecuteScsiCommand (ScsiDiskDevice->ScsiIo, &CommandPacket, NULL);
4801 }
4802
4803
4804 /**
4805 Initialize the installation of DiskInfo protocol.
4806
4807 This function prepares for the installation of DiskInfo protocol on the child handle.
4808 By default, it installs DiskInfo protocol with SCSI interface GUID. If it further
4809 detects that the physical device is an ATAPI/AHCI device, it then updates interface GUID
4810 to be IDE/AHCI interface GUID.
4811
4812 @param ScsiDiskDevice The pointer of SCSI_DISK_DEV.
4813 @param ChildHandle Child handle to install DiskInfo protocol.
4814
4815 **/
4816 VOID
4817 InitializeInstallDiskInfo (
4818 IN SCSI_DISK_DEV *ScsiDiskDevice,
4819 IN EFI_HANDLE ChildHandle
4820 )
4821 {
4822 EFI_STATUS Status;
4823 EFI_DEVICE_PATH_PROTOCOL *DevicePathNode;
4824 EFI_DEVICE_PATH_PROTOCOL *ChildDevicePathNode;
4825 ATAPI_DEVICE_PATH *AtapiDevicePath;
4826 SATA_DEVICE_PATH *SataDevicePath;
4827 UINTN IdentifyRetry;
4828
4829 Status = gBS->HandleProtocol (ChildHandle, &gEfiDevicePathProtocolGuid, (VOID **) &DevicePathNode);
4830 //
4831 // Device Path protocol must be installed on the device handle.
4832 //
4833 ASSERT_EFI_ERROR (Status);
4834 //
4835 // Copy the DiskInfo protocol template.
4836 //
4837 CopyMem (&ScsiDiskDevice->DiskInfo, &gScsiDiskInfoProtocolTemplate, sizeof (gScsiDiskInfoProtocolTemplate));
4838
4839 while (!IsDevicePathEnd (DevicePathNode)) {
4840 ChildDevicePathNode = NextDevicePathNode (DevicePathNode);
4841 if ((DevicePathType (DevicePathNode) == HARDWARE_DEVICE_PATH) &&
4842 (DevicePathSubType (DevicePathNode) == HW_PCI_DP) &&
4843 (DevicePathType (ChildDevicePathNode) == MESSAGING_DEVICE_PATH) &&
4844 ((DevicePathSubType (ChildDevicePathNode) == MSG_ATAPI_DP) ||
4845 (DevicePathSubType (ChildDevicePathNode) == MSG_SATA_DP))) {
4846
4847 IdentifyRetry = 3;
4848 do {
4849 //
4850 // Issue ATA Identify Device Command via SCSI command, which is required to publish DiskInfo protocol
4851 // with IDE/AHCI interface GUID.
4852 //
4853 Status = AtapiIdentifyDevice (ScsiDiskDevice);
4854 if (!EFI_ERROR (Status)) {
4855 if (DevicePathSubType(ChildDevicePathNode) == MSG_ATAPI_DP) {
4856 //
4857 // We find the valid ATAPI device path
4858 //
4859 AtapiDevicePath = (ATAPI_DEVICE_PATH *) ChildDevicePathNode;
4860 ScsiDiskDevice->Channel = AtapiDevicePath->PrimarySecondary;
4861 ScsiDiskDevice->Device = AtapiDevicePath->SlaveMaster;
4862 //
4863 // Update the DiskInfo.Interface to IDE interface GUID for the physical ATAPI device.
4864 //
4865 CopyGuid (&ScsiDiskDevice->DiskInfo.Interface, &gEfiDiskInfoIdeInterfaceGuid);
4866 } else {
4867 //
4868 // We find the valid SATA device path
4869 //
4870 SataDevicePath = (SATA_DEVICE_PATH *) ChildDevicePathNode;
4871 ScsiDiskDevice->Channel = SataDevicePath->HBAPortNumber;
4872 ScsiDiskDevice->Device = SataDevicePath->PortMultiplierPortNumber;
4873 //
4874 // Update the DiskInfo.Interface to AHCI interface GUID for the physical AHCI device.
4875 //
4876 CopyGuid (&ScsiDiskDevice->DiskInfo.Interface, &gEfiDiskInfoAhciInterfaceGuid);
4877 }
4878 return;
4879 }
4880 } while (--IdentifyRetry > 0);
4881 } else if ((DevicePathType (ChildDevicePathNode) == MESSAGING_DEVICE_PATH) &&
4882 (DevicePathSubType (ChildDevicePathNode) == MSG_UFS_DP)) {
4883 CopyGuid (&ScsiDiskDevice->DiskInfo.Interface, &gEfiDiskInfoUfsInterfaceGuid);
4884 break;
4885 }
4886 DevicePathNode = ChildDevicePathNode;
4887 }
4888
4889 return;
4890 }
EFI Development Kit II mirror for PVE