AtaBusDxe: Fix ReadBlockEx andWriteBlockEx to still signal event when the BufferSize...
[mirror_edk2.git] / MdeModulePkg / Universal / Disk / DiskIoDxe / DiskIo.c
1 /** @file
2 DiskIo driver that lays on every BlockIo protocol in the system.
3 DiskIo converts a block oriented device to a byte oriented device.
4
5 Disk access may have to handle unaligned request about sector boundaries.
6 There are three cases:
7 UnderRun - The first byte is not on a sector boundary or the read request is
8 less than a sector in length.
9 Aligned - A read of N contiguous sectors.
10 OverRun - The last byte is not on a sector boundary.
11
12 Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
13 This program and the accompanying materials
14 are licensed and made available under the terms and conditions of the BSD License
15 which accompanies this distribution. The full text of the license may be found at
16 http://opensource.org/licenses/bsd-license.php
17
18 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
19 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
20
21 **/
22
23 #include "DiskIo.h"
24
25 //
26 // Driver binding protocol implementation for DiskIo driver.
27 //
28 EFI_DRIVER_BINDING_PROTOCOL gDiskIoDriverBinding = {
29 DiskIoDriverBindingSupported,
30 DiskIoDriverBindingStart,
31 DiskIoDriverBindingStop,
32 0xa,
33 NULL,
34 NULL
35 };
36
37 //
38 // Template for DiskIo private data structure.
39 // The pointer to BlockIo protocol interface is assigned dynamically.
40 //
41 DISK_IO_PRIVATE_DATA gDiskIoPrivateDataTemplate = {
42 DISK_IO_PRIVATE_DATA_SIGNATURE,
43 {
44 EFI_DISK_IO_PROTOCOL_REVISION,
45 DiskIoReadDisk,
46 DiskIoWriteDisk
47 },
48 {
49 EFI_DISK_IO2_PROTOCOL_REVISION,
50 DiskIo2Cancel,
51 DiskIo2ReadDiskEx,
52 DiskIo2WriteDiskEx,
53 DiskIo2FlushDiskEx
54 }
55 };
56
57 /**
58 Test to see if this driver supports ControllerHandle.
59
60 @param This Protocol instance pointer.
61 @param ControllerHandle Handle of device to test
62 @param RemainingDevicePath Optional parameter use to pick a specific child
63 device to start.
64
65 @retval EFI_SUCCESS This driver supports this device
66 @retval EFI_ALREADY_STARTED This driver is already running on this device
67 @retval other This driver does not support this device
68
69 **/
70 EFI_STATUS
71 EFIAPI
72 DiskIoDriverBindingSupported (
73 IN EFI_DRIVER_BINDING_PROTOCOL *This,
74 IN EFI_HANDLE ControllerHandle,
75 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
76 )
77 {
78 EFI_STATUS Status;
79 EFI_BLOCK_IO_PROTOCOL *BlockIo;
80
81 //
82 // Open the IO Abstraction(s) needed to perform the supported test.
83 //
84 Status = gBS->OpenProtocol (
85 ControllerHandle,
86 &gEfiBlockIoProtocolGuid,
87 (VOID **) &BlockIo,
88 This->DriverBindingHandle,
89 ControllerHandle,
90 EFI_OPEN_PROTOCOL_BY_DRIVER
91 );
92 if (EFI_ERROR (Status)) {
93 return Status;
94 }
95
96 //
97 // Close the I/O Abstraction(s) used to perform the supported test.
98 //
99 gBS->CloseProtocol (
100 ControllerHandle,
101 &gEfiBlockIoProtocolGuid,
102 This->DriverBindingHandle,
103 ControllerHandle
104 );
105 return EFI_SUCCESS;
106 }
107
108
109 /**
110 Start this driver on ControllerHandle by opening a Block IO protocol and
111 installing a Disk IO protocol on ControllerHandle.
112
113 @param This Protocol instance pointer.
114 @param ControllerHandle Handle of device to bind driver to
115 @param RemainingDevicePath Optional parameter use to pick a specific child
116 device to start.
117
118 @retval EFI_SUCCESS This driver is added to ControllerHandle
119 @retval EFI_ALREADY_STARTED This driver is already running on ControllerHandle
120 @retval other This driver does not support this device
121
122 **/
123 EFI_STATUS
124 EFIAPI
125 DiskIoDriverBindingStart (
126 IN EFI_DRIVER_BINDING_PROTOCOL *This,
127 IN EFI_HANDLE ControllerHandle,
128 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
129 )
130 {
131 EFI_STATUS Status;
132 DISK_IO_PRIVATE_DATA *Instance;
133 EFI_TPL OldTpl;
134
135 Instance = NULL;
136
137 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
138
139 //
140 // Connect to the Block IO and Block IO2 interface on ControllerHandle.
141 //
142 Status = gBS->OpenProtocol (
143 ControllerHandle,
144 &gEfiBlockIoProtocolGuid,
145 (VOID **) &gDiskIoPrivateDataTemplate.BlockIo,
146 This->DriverBindingHandle,
147 ControllerHandle,
148 EFI_OPEN_PROTOCOL_BY_DRIVER
149 );
150 if (EFI_ERROR (Status)) {
151 goto ErrorExit1;
152 }
153
154 Status = gBS->OpenProtocol (
155 ControllerHandle,
156 &gEfiBlockIo2ProtocolGuid,
157 (VOID **) &gDiskIoPrivateDataTemplate.BlockIo2,
158 This->DriverBindingHandle,
159 ControllerHandle,
160 EFI_OPEN_PROTOCOL_BY_DRIVER
161 );
162 if (EFI_ERROR (Status)) {
163 gDiskIoPrivateDataTemplate.BlockIo2 = NULL;
164 }
165
166 //
167 // Initialize the Disk IO device instance.
168 //
169 Instance = AllocateCopyPool (sizeof (DISK_IO_PRIVATE_DATA), &gDiskIoPrivateDataTemplate);
170 if (Instance == NULL) {
171 Status = EFI_OUT_OF_RESOURCES;
172 goto ErrorExit;
173 }
174
175 //
176 // The BlockSize and IoAlign of BlockIo and BlockIo2 should equal.
177 //
178 ASSERT ((Instance->BlockIo2 == NULL) ||
179 ((Instance->BlockIo->Media->IoAlign == Instance->BlockIo2->Media->IoAlign) &&
180 (Instance->BlockIo->Media->BlockSize == Instance->BlockIo2->Media->BlockSize)
181 ));
182
183 InitializeListHead (&Instance->TaskQueue);
184 EfiInitializeLock (&Instance->TaskQueueLock, TPL_NOTIFY);
185 Instance->SharedWorkingBuffer = AllocateAlignedPages (
186 EFI_SIZE_TO_PAGES (PcdGet32 (PcdDiskIoDataBufferBlockNum) * Instance->BlockIo->Media->BlockSize),
187 Instance->BlockIo->Media->IoAlign
188 );
189 if (Instance->SharedWorkingBuffer == NULL) {
190 Status = EFI_OUT_OF_RESOURCES;
191 goto ErrorExit;
192 }
193
194 //
195 // Install protocol interfaces for the Disk IO device.
196 //
197 if (Instance->BlockIo2 != NULL) {
198 Status = gBS->InstallMultipleProtocolInterfaces (
199 &ControllerHandle,
200 &gEfiDiskIoProtocolGuid, &Instance->DiskIo,
201 &gEfiDiskIo2ProtocolGuid, &Instance->DiskIo2,
202 NULL
203 );
204 } else {
205 Status = gBS->InstallMultipleProtocolInterfaces (
206 &ControllerHandle,
207 &gEfiDiskIoProtocolGuid, &Instance->DiskIo,
208 NULL
209 );
210 }
211
212 ErrorExit:
213 if (EFI_ERROR (Status)) {
214 if (Instance != NULL && Instance->SharedWorkingBuffer != NULL) {
215 FreeAlignedPages (
216 Instance->SharedWorkingBuffer,
217 EFI_SIZE_TO_PAGES (PcdGet32 (PcdDiskIoDataBufferBlockNum) * Instance->BlockIo->Media->BlockSize)
218 );
219 }
220
221 if (Instance != NULL) {
222 FreePool (Instance);
223 }
224
225 gBS->CloseProtocol (
226 ControllerHandle,
227 &gEfiBlockIoProtocolGuid,
228 This->DriverBindingHandle,
229 ControllerHandle
230 );
231 }
232
233 ErrorExit1:
234 gBS->RestoreTPL (OldTpl);
235 return Status;
236 }
237
238 /**
239 Stop this driver on ControllerHandle by removing Disk IO protocol and closing
240 the Block IO protocol on ControllerHandle.
241
242 @param This Protocol instance pointer.
243 @param ControllerHandle Handle of device to stop driver on
244 @param NumberOfChildren Number of Handles in ChildHandleBuffer. If number of
245 children is zero stop the entire bus driver.
246 @param ChildHandleBuffer List of Child Handles to Stop.
247
248 @retval EFI_SUCCESS This driver is removed ControllerHandle
249 @retval other This driver was not removed from this device
250
251 **/
252 EFI_STATUS
253 EFIAPI
254 DiskIoDriverBindingStop (
255 IN EFI_DRIVER_BINDING_PROTOCOL *This,
256 IN EFI_HANDLE ControllerHandle,
257 IN UINTN NumberOfChildren,
258 IN EFI_HANDLE *ChildHandleBuffer
259 )
260 {
261 EFI_STATUS Status;
262 EFI_DISK_IO_PROTOCOL *DiskIo;
263 EFI_DISK_IO2_PROTOCOL *DiskIo2;
264 DISK_IO_PRIVATE_DATA *Instance;
265 BOOLEAN AllTaskDone;
266
267 //
268 // Get our context back.
269 //
270 Status = gBS->OpenProtocol (
271 ControllerHandle,
272 &gEfiDiskIoProtocolGuid,
273 (VOID **) &DiskIo,
274 This->DriverBindingHandle,
275 ControllerHandle,
276 EFI_OPEN_PROTOCOL_GET_PROTOCOL
277 );
278 if (EFI_ERROR (Status)) {
279 return Status;
280 }
281 Status = gBS->OpenProtocol (
282 ControllerHandle,
283 &gEfiDiskIo2ProtocolGuid,
284 (VOID **) &DiskIo2,
285 This->DriverBindingHandle,
286 ControllerHandle,
287 EFI_OPEN_PROTOCOL_GET_PROTOCOL
288 );
289 if (EFI_ERROR (Status)) {
290 DiskIo2 = NULL;
291 }
292
293 Instance = DISK_IO_PRIVATE_DATA_FROM_DISK_IO (DiskIo);
294
295 if (DiskIo2 != NULL) {
296 //
297 // Call BlockIo2::Reset() to terminate any in-flight non-blocking I/O requests
298 //
299 ASSERT (Instance->BlockIo2 != NULL);
300 Status = Instance->BlockIo2->Reset (Instance->BlockIo2, FALSE);
301 if (EFI_ERROR (Status)) {
302 return Status;
303 }
304 Status = gBS->UninstallMultipleProtocolInterfaces (
305 ControllerHandle,
306 &gEfiDiskIoProtocolGuid, &Instance->DiskIo,
307 &gEfiDiskIo2ProtocolGuid, &Instance->DiskIo2,
308 NULL
309 );
310 } else {
311 Status = gBS->UninstallMultipleProtocolInterfaces (
312 ControllerHandle,
313 &gEfiDiskIoProtocolGuid, &Instance->DiskIo,
314 NULL
315 );
316 }
317 if (!EFI_ERROR (Status)) {
318
319 do {
320 EfiAcquireLock (&Instance->TaskQueueLock);
321 AllTaskDone = IsListEmpty (&Instance->TaskQueue);
322 EfiReleaseLock (&Instance->TaskQueueLock);
323 } while (!AllTaskDone);
324
325 FreeAlignedPages (
326 Instance->SharedWorkingBuffer,
327 EFI_SIZE_TO_PAGES (PcdGet32 (PcdDiskIoDataBufferBlockNum) * Instance->BlockIo->Media->BlockSize)
328 );
329
330 Status = gBS->CloseProtocol (
331 ControllerHandle,
332 &gEfiBlockIoProtocolGuid,
333 This->DriverBindingHandle,
334 ControllerHandle
335 );
336 ASSERT_EFI_ERROR (Status);
337 if (DiskIo2 != NULL) {
338 Status = gBS->CloseProtocol (
339 ControllerHandle,
340 &gEfiBlockIo2ProtocolGuid,
341 This->DriverBindingHandle,
342 ControllerHandle
343 );
344 ASSERT_EFI_ERROR (Status);
345 }
346
347 FreePool (Instance);
348 }
349
350 return Status;
351 }
352
353
354 /**
355 Destroy the sub task.
356
357 @param Instance Pointer to the DISK_IO_PRIVATE_DATA.
358 @param Subtask Subtask.
359
360 @return LIST_ENTRY * Pointer to the next link of subtask.
361 **/
362 LIST_ENTRY *
363 DiskIoDestroySubtask (
364 IN DISK_IO_PRIVATE_DATA *Instance,
365 IN DISK_IO_SUBTASK *Subtask
366 )
367 {
368 LIST_ENTRY *Link;
369
370 if (Subtask->Task != NULL) {
371 EfiAcquireLock (&Subtask->Task->SubtasksLock);
372 }
373 Link = RemoveEntryList (&Subtask->Link);
374 if (Subtask->Task != NULL) {
375 EfiReleaseLock (&Subtask->Task->SubtasksLock);
376 }
377
378 if (!Subtask->Blocking) {
379 if (Subtask->WorkingBuffer != NULL) {
380 FreeAlignedPages (
381 Subtask->WorkingBuffer,
382 Subtask->Length < Instance->BlockIo->Media->BlockSize
383 ? EFI_SIZE_TO_PAGES (Instance->BlockIo->Media->BlockSize)
384 : EFI_SIZE_TO_PAGES (Subtask->Length)
385 );
386 }
387 if (Subtask->BlockIo2Token.Event != NULL) {
388 gBS->CloseEvent (Subtask->BlockIo2Token.Event);
389 }
390 }
391 FreePool (Subtask);
392
393 return Link;
394 }
395
396 /**
397 The callback for the BlockIo2 ReadBlocksEx/WriteBlocksEx.
398 @param Event Event whose notification function is being invoked.
399 @param Context The pointer to the notification function's context,
400 which points to the DISK_IO_SUBTASK instance.
401 **/
402 VOID
403 EFIAPI
404 DiskIo2OnReadWriteComplete (
405 IN EFI_EVENT Event,
406 IN VOID *Context
407 )
408 {
409 DISK_IO_SUBTASK *Subtask;
410 DISK_IO2_TASK *Task;
411 EFI_STATUS TransactionStatus;
412 DISK_IO_PRIVATE_DATA *Instance;
413
414 Subtask = (DISK_IO_SUBTASK *) Context;
415 TransactionStatus = Subtask->BlockIo2Token.TransactionStatus;
416 Task = Subtask->Task;
417 Instance = Task->Instance;
418
419 ASSERT (Subtask->Signature == DISK_IO_SUBTASK_SIGNATURE);
420 ASSERT (Instance->Signature == DISK_IO_PRIVATE_DATA_SIGNATURE);
421 ASSERT (Task->Signature == DISK_IO2_TASK_SIGNATURE);
422
423 if ((Subtask->WorkingBuffer != NULL) && !EFI_ERROR (TransactionStatus) &&
424 (Task->Token != NULL) && !Subtask->Write
425 ) {
426 CopyMem (Subtask->Buffer, Subtask->WorkingBuffer + Subtask->Offset, Subtask->Length);
427 }
428
429 DiskIoDestroySubtask (Instance, Subtask);
430
431 if (EFI_ERROR (TransactionStatus) || IsListEmpty (&Task->Subtasks)) {
432 if (Task->Token != NULL) {
433 //
434 // Signal error status once the subtask is failed.
435 // Or signal the last status once the last subtask is finished.
436 //
437 Task->Token->TransactionStatus = TransactionStatus;
438 gBS->SignalEvent (Task->Token->Event);
439
440 //
441 // Mark token to NULL indicating the Task is a dead task.
442 //
443 Task->Token = NULL;
444 }
445 }
446 }
447
448 /**
449 Create the subtask.
450
451 @param Write TRUE: Write request; FALSE: Read request.
452 @param Lba The starting logical block address to read from on the device.
453 @param Offset The starting byte offset to read from the LBA.
454 @param Length The number of bytes to read from the device.
455 @param WorkingBuffer The aligned buffer to hold the data for reading or writing.
456 @param Buffer The buffer to hold the data for reading or writing.
457 @param Blocking TRUE: Blocking request; FALSE: Non-blocking request.
458
459 @return A pointer to the created subtask.
460 **/
461 DISK_IO_SUBTASK *
462 DiskIoCreateSubtask (
463 IN BOOLEAN Write,
464 IN UINT64 Lba,
465 IN UINT32 Offset,
466 IN UINTN Length,
467 IN VOID *WorkingBuffer, OPTIONAL
468 IN VOID *Buffer,
469 IN BOOLEAN Blocking
470 )
471 {
472 DISK_IO_SUBTASK *Subtask;
473 EFI_STATUS Status;
474
475 Subtask = AllocateZeroPool (sizeof (DISK_IO_SUBTASK));
476 if (Subtask == NULL) {
477 return NULL;
478 }
479 Subtask->Signature = DISK_IO_SUBTASK_SIGNATURE;
480 Subtask->Write = Write;
481 Subtask->Lba = Lba;
482 Subtask->Offset = Offset;
483 Subtask->Length = Length;
484 Subtask->WorkingBuffer = WorkingBuffer;
485 Subtask->Buffer = Buffer;
486 Subtask->Blocking = Blocking;
487 if (!Blocking) {
488 Status = gBS->CreateEvent (
489 EVT_NOTIFY_SIGNAL,
490 TPL_NOTIFY,
491 DiskIo2OnReadWriteComplete,
492 Subtask,
493 &Subtask->BlockIo2Token.Event
494 );
495 if (EFI_ERROR (Status)) {
496 FreePool (Subtask);
497 return NULL;
498 }
499 }
500 DEBUG ((
501 EFI_D_BLKIO,
502 " %c:Lba/Offset/Length/WorkingBuffer/Buffer = %016lx/%08x/%08x/%08x/%08x\n",
503 Write ? 'W': 'R', Lba, Offset, Length, WorkingBuffer, Buffer
504 ));
505
506 return Subtask;
507 }
508
509 /**
510 Create the subtask list.
511
512 @param Instance Pointer to the DISK_IO_PRIVATE_DATA.
513 @param Write TRUE: Write request; FALSE: Read request.
514 @param Offset The starting byte offset to read from the device.
515 @param BufferSize The size in bytes of Buffer. The number of bytes to read from the device.
516 @param Buffer A pointer to the buffer for the data.
517 @param Blocking TRUE: Blocking request; FALSE: Non-blocking request.
518 @param SharedWorkingBuffer The aligned buffer to hold the data for reading or writing.
519 @param Subtasks The subtask list header.
520
521 @retval TRUE The subtask list is created successfully.
522 @retval FALSE The subtask list is not created.
523 **/
524 BOOLEAN
525 DiskIoCreateSubtaskList (
526 IN DISK_IO_PRIVATE_DATA *Instance,
527 IN BOOLEAN Write,
528 IN UINT64 Offset,
529 IN UINTN BufferSize,
530 IN VOID *Buffer,
531 IN BOOLEAN Blocking,
532 IN VOID *SharedWorkingBuffer,
533 IN OUT LIST_ENTRY *Subtasks
534 )
535 {
536 UINT32 BlockSize;
537 UINT32 IoAlign;
538 UINT64 Lba;
539 UINT64 OverRunLba;
540 UINT32 UnderRun;
541 UINT32 OverRun;
542 UINT8 *BufferPtr;
543 UINTN Length;
544 UINTN DataBufferSize;
545 DISK_IO_SUBTASK *Subtask;
546 VOID *WorkingBuffer;
547 LIST_ENTRY *Link;
548
549 DEBUG ((EFI_D_BLKIO, "DiskIo: Create subtasks for task: Offset/BufferSize/Buffer = %016lx/%08x/%08x\n", Offset, BufferSize, Buffer));
550
551 BlockSize = Instance->BlockIo->Media->BlockSize;
552 IoAlign = Instance->BlockIo->Media->IoAlign;
553 if (IoAlign == 0) {
554 IoAlign = 1;
555 }
556
557 Lba = DivU64x32Remainder (Offset, BlockSize, &UnderRun);
558 BufferPtr = (UINT8 *) Buffer;
559
560 //
561 // Special handling for zero BufferSize
562 //
563 if (BufferSize == 0) {
564 Subtask = DiskIoCreateSubtask (Write, Lba, UnderRun, 0, NULL, BufferPtr, Blocking);
565 if (Subtask == NULL) {
566 goto Done;
567 }
568 InsertTailList (Subtasks, &Subtask->Link);
569 return TRUE;
570 }
571
572 if (UnderRun != 0) {
573 Length = MIN (BlockSize - UnderRun, BufferSize);
574 if (Blocking) {
575 WorkingBuffer = SharedWorkingBuffer;
576 } else {
577 WorkingBuffer = AllocateAlignedPages (EFI_SIZE_TO_PAGES (BlockSize), IoAlign);
578 if (WorkingBuffer == NULL) {
579 goto Done;
580 }
581 }
582 if (Write) {
583 //
584 // A half write operation can be splitted to a blocking block-read and half write operation
585 // This can simplify the sub task processing logic
586 //
587 Subtask = DiskIoCreateSubtask (FALSE, Lba, 0, BlockSize, NULL, WorkingBuffer, TRUE);
588 if (Subtask == NULL) {
589 goto Done;
590 }
591 InsertTailList (Subtasks, &Subtask->Link);
592 }
593
594 Subtask = DiskIoCreateSubtask (Write, Lba, UnderRun, Length, WorkingBuffer, BufferPtr, Blocking);
595 if (Subtask == NULL) {
596 goto Done;
597 }
598 InsertTailList (Subtasks, &Subtask->Link);
599
600 BufferPtr += Length;
601 Offset += Length;
602 BufferSize -= Length;
603 Lba ++;
604 }
605
606 OverRunLba = Lba + DivU64x32Remainder (BufferSize, BlockSize, &OverRun);
607 BufferSize -= OverRun;
608
609 if (OverRun != 0) {
610 if (Blocking) {
611 WorkingBuffer = SharedWorkingBuffer;
612 } else {
613 WorkingBuffer = AllocateAlignedPages (EFI_SIZE_TO_PAGES (BlockSize), IoAlign);
614 if (WorkingBuffer == NULL) {
615 goto Done;
616 }
617 }
618 if (Write) {
619 //
620 // A half write operation can be splitted to a blocking block-read and half write operation
621 // This can simplify the sub task processing logic
622 //
623 Subtask = DiskIoCreateSubtask (FALSE, OverRunLba, 0, BlockSize, NULL, WorkingBuffer, TRUE);
624 if (Subtask == NULL) {
625 goto Done;
626 }
627 InsertTailList (Subtasks, &Subtask->Link);
628 }
629
630 Subtask = DiskIoCreateSubtask (Write, OverRunLba, 0, OverRun, WorkingBuffer, BufferPtr + BufferSize, Blocking);
631 if (Subtask == NULL) {
632 goto Done;
633 }
634 InsertTailList (Subtasks, &Subtask->Link);
635 }
636
637 if (OverRunLba > Lba) {
638 //
639 // If the DiskIo maps directly to a BlockIo device do the read.
640 //
641 if (ALIGN_POINTER (BufferPtr, IoAlign) == BufferPtr) {
642 Subtask = DiskIoCreateSubtask (Write, Lba, 0, BufferSize, NULL, BufferPtr, Blocking);
643 if (Subtask == NULL) {
644 goto Done;
645 }
646 InsertTailList (Subtasks, &Subtask->Link);
647
648 BufferPtr += BufferSize;
649 Offset += BufferSize;
650 BufferSize -= BufferSize;
651
652 } else {
653 if (Blocking) {
654 //
655 // Use the allocated buffer instead of the original buffer
656 // to avoid alignment issue.
657 //
658 for (; Lba < OverRunLba; Lba += PcdGet32 (PcdDiskIoDataBufferBlockNum)) {
659 DataBufferSize = MIN (BufferSize, PcdGet32 (PcdDiskIoDataBufferBlockNum) * BlockSize);
660
661 Subtask = DiskIoCreateSubtask (Write, Lba, 0, DataBufferSize, SharedWorkingBuffer, BufferPtr, Blocking);
662 if (Subtask == NULL) {
663 goto Done;
664 }
665 InsertTailList (Subtasks, &Subtask->Link);
666
667 BufferPtr += DataBufferSize;
668 Offset += DataBufferSize;
669 BufferSize -= DataBufferSize;
670 }
671 } else {
672 WorkingBuffer = AllocateAlignedPages (EFI_SIZE_TO_PAGES (BufferSize), IoAlign);
673 if (WorkingBuffer == NULL) {
674 //
675 // If there is not enough memory, downgrade to blocking access
676 //
677 DEBUG ((EFI_D_VERBOSE, "DiskIo: No enough memory so downgrade to blocking access\n"));
678 if (!DiskIoCreateSubtaskList (Instance, Write, Offset, BufferSize, BufferPtr, TRUE, SharedWorkingBuffer, Subtasks)) {
679 goto Done;
680 }
681 } else {
682 Subtask = DiskIoCreateSubtask (Write, Lba, 0, BufferSize, WorkingBuffer, BufferPtr, Blocking);
683 if (Subtask == NULL) {
684 goto Done;
685 }
686 InsertTailList (Subtasks, &Subtask->Link);
687 }
688
689 BufferPtr += BufferSize;
690 Offset += BufferSize;
691 BufferSize -= BufferSize;
692 }
693 }
694 }
695
696 ASSERT (BufferSize == 0);
697
698 return TRUE;
699
700 Done:
701 //
702 // Remove all the subtasks.
703 //
704 for (Link = GetFirstNode (Subtasks); !IsNull (Subtasks, Link); ) {
705 Subtask = CR (Link, DISK_IO_SUBTASK, Link, DISK_IO_SUBTASK_SIGNATURE);
706 Link = DiskIoDestroySubtask (Instance, Subtask);
707 }
708 return FALSE;
709 }
710
711 /**
712 Terminate outstanding asynchronous requests to a device.
713
714 @param This Indicates a pointer to the calling context.
715
716 @retval EFI_SUCCESS All outstanding requests were successfully terminated.
717 @retval EFI_DEVICE_ERROR The device reported an error while performing the cancel
718 operation.
719 **/
720 EFI_STATUS
721 EFIAPI
722 DiskIo2Cancel (
723 IN EFI_DISK_IO2_PROTOCOL *This
724 )
725 {
726 DISK_IO_PRIVATE_DATA *Instance;
727 DISK_IO2_TASK *Task;
728 LIST_ENTRY *Link;
729
730 Instance = DISK_IO_PRIVATE_DATA_FROM_DISK_IO2 (This);
731
732 EfiAcquireLock (&Instance->TaskQueueLock);
733
734 for (Link = GetFirstNode (&Instance->TaskQueue)
735 ; !IsNull (&Instance->TaskQueue, Link)
736 ; Link = GetNextNode (&Instance->TaskQueue, Link)
737 ) {
738 Task = CR (Link, DISK_IO2_TASK, Link, DISK_IO2_TASK_SIGNATURE);
739
740 if (Task->Token != NULL) {
741 Task->Token->TransactionStatus = EFI_ABORTED;
742 gBS->SignalEvent (Task->Token->Event);
743 //
744 // Set Token to NULL so that the further BlockIo2 responses will be ignored
745 //
746 Task->Token = NULL;
747 }
748 }
749
750 EfiReleaseLock (&Instance->TaskQueueLock);
751
752 return EFI_SUCCESS;
753 }
754
755 /**
756 Remove the completed tasks from Instance->TaskQueue. Completed tasks are those who don't have any subtasks.
757
758 @param Instance Pointer to the DISK_IO_PRIVATE_DATA.
759
760 @retval TRUE The Instance->TaskQueue is empty after the completed tasks are removed.
761 @retval FALSE The Instance->TaskQueue is not empty after the completed tasks are removed.
762 **/
763 BOOLEAN
764 DiskIo2RemoveCompletedTask (
765 IN DISK_IO_PRIVATE_DATA *Instance
766 )
767 {
768 BOOLEAN QueueEmpty;
769 LIST_ENTRY *Link;
770 DISK_IO2_TASK *Task;
771
772 QueueEmpty = TRUE;
773
774 EfiAcquireLock (&Instance->TaskQueueLock);
775 for (Link = GetFirstNode (&Instance->TaskQueue); !IsNull (&Instance->TaskQueue, Link); ) {
776 Task = CR (Link, DISK_IO2_TASK, Link, DISK_IO2_TASK_SIGNATURE);
777 if (IsListEmpty (&Task->Subtasks)) {
778 Link = RemoveEntryList (&Task->Link);
779 ASSERT (Task->Token == NULL);
780 FreePool (Task);
781 } else {
782 Link = GetNextNode (&Instance->TaskQueue, Link);
783 QueueEmpty = FALSE;
784 }
785 }
786 EfiReleaseLock (&Instance->TaskQueueLock);
787
788 return QueueEmpty;
789 }
790
791 /**
792 Common routine to access the disk.
793
794 @param Instance Pointer to the DISK_IO_PRIVATE_DATA.
795 @param Write TRUE: Write operation; FALSE: Read operation.
796 @param MediaId ID of the medium to access.
797 @param Offset The starting byte offset on the logical block I/O device to access.
798 @param Token A pointer to the token associated with the transaction.
799 If this field is NULL, synchronous/blocking IO is performed.
800 @param BufferSize The size in bytes of Buffer. The number of bytes to read from the device.
801 @param Buffer A pointer to the destination buffer for the data.
802 The caller is responsible either having implicit or explicit ownership of the buffer.
803 **/
804 EFI_STATUS
805 DiskIo2ReadWriteDisk (
806 IN DISK_IO_PRIVATE_DATA *Instance,
807 IN BOOLEAN Write,
808 IN UINT32 MediaId,
809 IN UINT64 Offset,
810 IN EFI_DISK_IO2_TOKEN *Token,
811 IN UINTN BufferSize,
812 IN UINT8 *Buffer
813 )
814 {
815 EFI_STATUS Status;
816 EFI_BLOCK_IO_PROTOCOL *BlockIo;
817 EFI_BLOCK_IO2_PROTOCOL *BlockIo2;
818 EFI_BLOCK_IO_MEDIA *Media;
819 LIST_ENTRY *Link;
820 LIST_ENTRY *NextLink;
821 LIST_ENTRY Subtasks;
822 DISK_IO_SUBTASK *Subtask;
823 DISK_IO2_TASK *Task;
824 EFI_TPL OldTpl;
825 BOOLEAN Blocking;
826 BOOLEAN SubtaskBlocking;
827 LIST_ENTRY *SubtasksPtr;
828
829 Task = NULL;
830 BlockIo = Instance->BlockIo;
831 BlockIo2 = Instance->BlockIo2;
832 Media = BlockIo->Media;
833 Status = EFI_SUCCESS;
834 Blocking = (BOOLEAN) ((Token == NULL) || (Token->Event == NULL));
835
836 if (Media->MediaId != MediaId) {
837 return EFI_MEDIA_CHANGED;
838 }
839
840 if (Write && Media->ReadOnly) {
841 return EFI_WRITE_PROTECTED;
842 }
843
844 if (Blocking) {
845 //
846 // Wait till pending async task is completed.
847 //
848 while (!DiskIo2RemoveCompletedTask (Instance));
849
850 SubtasksPtr = &Subtasks;
851 } else {
852 DiskIo2RemoveCompletedTask (Instance);
853 Task = AllocatePool (sizeof (DISK_IO2_TASK));
854 if (Task == NULL) {
855 return EFI_OUT_OF_RESOURCES;
856 }
857
858 EfiAcquireLock (&Instance->TaskQueueLock);
859 InsertTailList (&Instance->TaskQueue, &Task->Link);
860 EfiReleaseLock (&Instance->TaskQueueLock);
861
862 Task->Signature = DISK_IO2_TASK_SIGNATURE;
863 Task->Instance = Instance;
864 Task->Token = Token;
865 EfiInitializeLock (&Task->SubtasksLock, TPL_NOTIFY);
866
867 SubtasksPtr = &Task->Subtasks;
868 }
869
870 InitializeListHead (SubtasksPtr);
871 if (!DiskIoCreateSubtaskList (Instance, Write, Offset, BufferSize, Buffer, Blocking, Instance->SharedWorkingBuffer, SubtasksPtr)) {
872 if (Task != NULL) {
873 FreePool (Task);
874 }
875 return EFI_OUT_OF_RESOURCES;
876 }
877 ASSERT (!IsListEmpty (SubtasksPtr));
878
879 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
880 for ( Link = GetFirstNode (SubtasksPtr), NextLink = GetNextNode (SubtasksPtr, Link)
881 ; !IsNull (SubtasksPtr, Link)
882 ; Link = NextLink, NextLink = GetNextNode (SubtasksPtr, NextLink)
883 ) {
884 Subtask = CR (Link, DISK_IO_SUBTASK, Link, DISK_IO_SUBTASK_SIGNATURE);
885 Subtask->Task = Task;
886 SubtaskBlocking = Subtask->Blocking;
887
888 ASSERT ((Subtask->Length % Media->BlockSize == 0) || (Subtask->Length < Media->BlockSize));
889
890 if (Subtask->Write) {
891 //
892 // Write
893 //
894 if (Subtask->WorkingBuffer != NULL) {
895 //
896 // A sub task before this one should be a block read operation, causing the WorkingBuffer filled with the entire one block data.
897 //
898 CopyMem (Subtask->WorkingBuffer + Subtask->Offset, Subtask->Buffer, Subtask->Length);
899 }
900
901 if (SubtaskBlocking) {
902 Status = BlockIo->WriteBlocks (
903 BlockIo,
904 MediaId,
905 Subtask->Lba,
906 (Subtask->Length % Media->BlockSize == 0) ? Subtask->Length : Media->BlockSize,
907 (Subtask->WorkingBuffer != NULL) ? Subtask->WorkingBuffer : Subtask->Buffer
908 );
909 } else {
910 Status = BlockIo2->WriteBlocksEx (
911 BlockIo2,
912 MediaId,
913 Subtask->Lba,
914 &Subtask->BlockIo2Token,
915 (Subtask->Length % Media->BlockSize == 0) ? Subtask->Length : Media->BlockSize,
916 (Subtask->WorkingBuffer != NULL) ? Subtask->WorkingBuffer : Subtask->Buffer
917 );
918 }
919
920 } else {
921 //
922 // Read
923 //
924 if (SubtaskBlocking) {
925 Status = BlockIo->ReadBlocks (
926 BlockIo,
927 MediaId,
928 Subtask->Lba,
929 (Subtask->Length % Media->BlockSize == 0) ? Subtask->Length : Media->BlockSize,
930 (Subtask->WorkingBuffer != NULL) ? Subtask->WorkingBuffer : Subtask->Buffer
931 );
932 if (!EFI_ERROR (Status) && (Subtask->WorkingBuffer != NULL)) {
933 CopyMem (Subtask->Buffer, Subtask->WorkingBuffer + Subtask->Offset, Subtask->Length);
934 }
935 } else {
936 Status = BlockIo2->ReadBlocksEx (
937 BlockIo2,
938 MediaId,
939 Subtask->Lba,
940 &Subtask->BlockIo2Token,
941 (Subtask->Length % Media->BlockSize == 0) ? Subtask->Length : Media->BlockSize,
942 (Subtask->WorkingBuffer != NULL) ? Subtask->WorkingBuffer : Subtask->Buffer
943 );
944 }
945 }
946
947 if (SubtaskBlocking || EFI_ERROR (Status)) {
948 //
949 // Make sure the subtask list only contains non-blocking subtasks.
950 // Remove failed non-blocking subtasks as well because the callback won't be called.
951 //
952 DiskIoDestroySubtask (Instance, Subtask);
953 }
954
955 if (EFI_ERROR (Status)) {
956 break;
957 }
958 }
959
960 gBS->RaiseTPL (TPL_NOTIFY);
961
962 //
963 // Remove all the remaining subtasks when failure.
964 // We shouldn't remove all the tasks because the non-blocking requests have been submitted and cannot be canceled.
965 //
966 if (EFI_ERROR (Status)) {
967 while (!IsNull (SubtasksPtr, NextLink)) {
968 Subtask = CR (NextLink, DISK_IO_SUBTASK, Link, DISK_IO_SUBTASK_SIGNATURE);
969 NextLink = DiskIoDestroySubtask (Instance, Subtask);
970 }
971 }
972
973 //
974 // It's possible that the non-blocking subtasks finish before raising TPL to NOTIFY,
975 // so the subtasks list might be empty at this point.
976 //
977 if (!Blocking && IsListEmpty (SubtasksPtr)) {
978 EfiAcquireLock (&Instance->TaskQueueLock);
979 RemoveEntryList (&Task->Link);
980 EfiReleaseLock (&Instance->TaskQueueLock);
981
982 if (!EFI_ERROR (Status) && (Task->Token != NULL)) {
983 //
984 // Task->Token should be set to NULL by the DiskIo2OnReadWriteComplete
985 // It it's not, that means the non-blocking request was downgraded to blocking request.
986 //
987 DEBUG ((EFI_D_VERBOSE, "DiskIo: Non-blocking request was downgraded to blocking request, signal event directly.\n"));
988 Task->Token->TransactionStatus = Status;
989 gBS->SignalEvent (Task->Token->Event);
990 }
991
992 FreePool (Task);
993 }
994
995 gBS->RestoreTPL (OldTpl);
996
997 return Status;
998 }
999
1000 /**
1001 Reads a specified number of bytes from a device.
1002
1003 @param This Indicates a pointer to the calling context.
1004 @param MediaId ID of the medium to be read.
1005 @param Offset The starting byte offset on the logical block I/O device to read from.
1006 @param Token A pointer to the token associated with the transaction.
1007 If this field is NULL, synchronous/blocking IO is performed.
1008 @param BufferSize The size in bytes of Buffer. The number of bytes to read from the device.
1009 @param Buffer A pointer to the destination buffer for the data.
1010 The caller is responsible either having implicit or explicit ownership of the buffer.
1011
1012 @retval EFI_SUCCESS If Event is NULL (blocking I/O): The data was read correctly from the device.
1013 If Event is not NULL (asynchronous I/O): The request was successfully queued for processing.
1014 Event will be signaled upon completion.
1015 @retval EFI_DEVICE_ERROR The device reported an error while performing the write.
1016 @retval EFI_NO_MEDIA There is no medium in the device.
1017 @retval EFI_MEDIA_CHNAGED The MediaId is not for the current medium.
1018 @retval EFI_INVALID_PARAMETER The read request contains device addresses that are not valid for the device.
1019 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources.
1020
1021 **/
1022 EFI_STATUS
1023 EFIAPI
1024 DiskIo2ReadDiskEx (
1025 IN EFI_DISK_IO2_PROTOCOL *This,
1026 IN UINT32 MediaId,
1027 IN UINT64 Offset,
1028 IN OUT EFI_DISK_IO2_TOKEN *Token,
1029 IN UINTN BufferSize,
1030 OUT VOID *Buffer
1031 )
1032 {
1033 return DiskIo2ReadWriteDisk (
1034 DISK_IO_PRIVATE_DATA_FROM_DISK_IO2 (This),
1035 FALSE, MediaId, Offset, Token, BufferSize, (UINT8 *) Buffer
1036 );
1037 }
1038
1039 /**
1040 Writes a specified number of bytes to a device.
1041
1042 @param This Indicates a pointer to the calling context.
1043 @param MediaId ID of the medium to be written.
1044 @param Offset The starting byte offset on the logical block I/O device to write to.
1045 @param Token A pointer to the token associated with the transaction.
1046 If this field is NULL, synchronous/blocking IO is performed.
1047 @param BufferSize The size in bytes of Buffer. The number of bytes to write to the device.
1048 @param Buffer A pointer to the buffer containing the data to be written.
1049
1050 @retval EFI_SUCCESS If Event is NULL (blocking I/O): The data was written correctly to the device.
1051 If Event is not NULL (asynchronous I/O): The request was successfully queued for processing.
1052 Event will be signaled upon completion.
1053 @retval EFI_WRITE_PROTECTED The device cannot be written to.
1054 @retval EFI_DEVICE_ERROR The device reported an error while performing the write operation.
1055 @retval EFI_NO_MEDIA There is no medium in the device.
1056 @retval EFI_MEDIA_CHNAGED The MediaId is not for the current medium.
1057 @retval EFI_INVALID_PARAMETER The write request contains device addresses that are not valid for the device.
1058 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources.
1059
1060 **/
1061 EFI_STATUS
1062 EFIAPI
1063 DiskIo2WriteDiskEx (
1064 IN EFI_DISK_IO2_PROTOCOL *This,
1065 IN UINT32 MediaId,
1066 IN UINT64 Offset,
1067 IN OUT EFI_DISK_IO2_TOKEN *Token,
1068 IN UINTN BufferSize,
1069 IN VOID *Buffer
1070 )
1071 {
1072 return DiskIo2ReadWriteDisk (
1073 DISK_IO_PRIVATE_DATA_FROM_DISK_IO2 (This),
1074 TRUE, MediaId, Offset, Token, BufferSize, (UINT8 *) Buffer
1075 );
1076 }
1077
1078 /**
1079 The callback for the BlockIo2 FlushBlocksEx.
1080 @param Event Event whose notification function is being invoked.
1081 @param Context The pointer to the notification function's context,
1082 which points to the DISK_IO2_FLUSH_TASK instance.
1083 **/
1084 VOID
1085 EFIAPI
1086 DiskIo2OnFlushComplete (
1087 IN EFI_EVENT Event,
1088 IN VOID *Context
1089 )
1090 {
1091 DISK_IO2_FLUSH_TASK *Task;
1092
1093 gBS->CloseEvent (Event);
1094
1095 Task = (DISK_IO2_FLUSH_TASK *) Context;
1096 ASSERT (Task->Signature == DISK_IO2_FLUSH_TASK_SIGNATURE);
1097 Task->Token->TransactionStatus = Task->BlockIo2Token.TransactionStatus;
1098 gBS->SignalEvent (Task->Token->Event);
1099
1100 FreePool (Task);
1101 }
1102
1103 /**
1104 Flushes all modified data to the physical device.
1105
1106 @param This Indicates a pointer to the calling context.
1107 @param Token A pointer to the token associated with the transaction.
1108 If this field is NULL, synchronous/blocking IO is performed.
1109
1110 @retval EFI_SUCCESS If Event is NULL (blocking I/O): The data was flushed successfully to the device.
1111 If Event is not NULL (asynchronous I/O): The request was successfully queued for processing.
1112 Event will be signaled upon completion.
1113 @retval EFI_WRITE_PROTECTED The device cannot be written to.
1114 @retval EFI_DEVICE_ERROR The device reported an error while performing the write operation.
1115 @retval EFI_NO_MEDIA There is no medium in the device.
1116 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources.
1117 **/
1118 EFI_STATUS
1119 EFIAPI
1120 DiskIo2FlushDiskEx (
1121 IN EFI_DISK_IO2_PROTOCOL *This,
1122 IN OUT EFI_DISK_IO2_TOKEN *Token
1123 )
1124 {
1125 EFI_STATUS Status;
1126 DISK_IO2_FLUSH_TASK *Task;
1127 DISK_IO_PRIVATE_DATA *Private;
1128
1129 Private = DISK_IO_PRIVATE_DATA_FROM_DISK_IO2 (This);
1130
1131 if ((Token != NULL) && (Token->Event != NULL)) {
1132 Task = AllocatePool (sizeof (DISK_IO2_FLUSH_TASK));
1133 if (Task == NULL) {
1134 return EFI_OUT_OF_RESOURCES;
1135 }
1136
1137 Status = gBS->CreateEvent (
1138 EVT_NOTIFY_SIGNAL,
1139 TPL_CALLBACK,
1140 DiskIo2OnFlushComplete,
1141 Task,
1142 &Task->BlockIo2Token.Event
1143 );
1144 if (EFI_ERROR (Status)) {
1145 FreePool (Task);
1146 return Status;
1147 }
1148 Task->Signature = DISK_IO2_FLUSH_TASK_SIGNATURE;
1149 Task->Token = Token;
1150 Status = Private->BlockIo2->FlushBlocksEx (Private->BlockIo2, &Task->BlockIo2Token);
1151 if (EFI_ERROR (Status)) {
1152 gBS->CloseEvent (Task->BlockIo2Token.Event);
1153 FreePool (Task);
1154 }
1155 } else {
1156 Status = Private->BlockIo2->FlushBlocksEx (Private->BlockIo2, NULL);
1157 }
1158
1159 return Status;
1160 }
1161
1162 /**
1163 Read BufferSize bytes from Offset into Buffer.
1164 Reads may support reads that are not aligned on
1165 sector boundaries. There are three cases:
1166 UnderRun - The first byte is not on a sector boundary or the read request is
1167 less than a sector in length.
1168 Aligned - A read of N contiguous sectors.
1169 OverRun - The last byte is not on a sector boundary.
1170
1171 @param This Protocol instance pointer.
1172 @param MediaId Id of the media, changes every time the media is replaced.
1173 @param Offset The starting byte offset to read from
1174 @param BufferSize Size of Buffer
1175 @param Buffer Buffer containing read data
1176
1177 @retval EFI_SUCCESS The data was read correctly from the device.
1178 @retval EFI_DEVICE_ERROR The device reported an error while performing the read.
1179 @retval EFI_NO_MEDIA There is no media in the device.
1180 @retval EFI_MEDIA_CHNAGED The MediaId does not matched the current device.
1181 @retval EFI_INVALID_PARAMETER The read request contains device addresses that are not
1182 valid for the device.
1183
1184 **/
1185 EFI_STATUS
1186 EFIAPI
1187 DiskIoReadDisk (
1188 IN EFI_DISK_IO_PROTOCOL *This,
1189 IN UINT32 MediaId,
1190 IN UINT64 Offset,
1191 IN UINTN BufferSize,
1192 OUT VOID *Buffer
1193 )
1194 {
1195 return DiskIo2ReadWriteDisk (
1196 DISK_IO_PRIVATE_DATA_FROM_DISK_IO (This),
1197 FALSE, MediaId, Offset, NULL, BufferSize, (UINT8 *) Buffer
1198 );
1199 }
1200
1201
1202 /**
1203 Writes BufferSize bytes from Buffer into Offset.
1204 Writes may require a read modify write to support writes that are not
1205 aligned on sector boundaries. There are three cases:
1206 UnderRun - The first byte is not on a sector boundary or the write request
1207 is less than a sector in length. Read modify write is required.
1208 Aligned - A write of N contiguous sectors.
1209 OverRun - The last byte is not on a sector boundary. Read modified write
1210 required.
1211
1212 @param This Protocol instance pointer.
1213 @param MediaId Id of the media, changes every time the media is replaced.
1214 @param Offset The starting byte offset to read from
1215 @param BufferSize Size of Buffer
1216 @param Buffer Buffer containing read data
1217
1218 @retval EFI_SUCCESS The data was written correctly to the device.
1219 @retval EFI_WRITE_PROTECTED The device can not be written to.
1220 @retval EFI_DEVICE_ERROR The device reported an error while performing the write.
1221 @retval EFI_NO_MEDIA There is no media in the device.
1222 @retval EFI_MEDIA_CHNAGED The MediaId does not matched the current device.
1223 @retval EFI_INVALID_PARAMETER The write request contains device addresses that are not
1224 valid for the device.
1225
1226 **/
1227 EFI_STATUS
1228 EFIAPI
1229 DiskIoWriteDisk (
1230 IN EFI_DISK_IO_PROTOCOL *This,
1231 IN UINT32 MediaId,
1232 IN UINT64 Offset,
1233 IN UINTN BufferSize,
1234 IN VOID *Buffer
1235 )
1236 {
1237 return DiskIo2ReadWriteDisk (
1238 DISK_IO_PRIVATE_DATA_FROM_DISK_IO (This),
1239 TRUE, MediaId, Offset, NULL, BufferSize, (UINT8 *) Buffer
1240 );
1241 }
1242
1243 /**
1244 The user Entry Point for module DiskIo. The user code starts with this function.
1245
1246 @param[in] ImageHandle The firmware allocated handle for the EFI image.
1247 @param[in] SystemTable A pointer to the EFI System Table.
1248
1249 @retval EFI_SUCCESS The entry point is executed successfully.
1250 @retval other Some error occurs when executing this entry point.
1251
1252 **/
1253 EFI_STATUS
1254 EFIAPI
1255 InitializeDiskIo (
1256 IN EFI_HANDLE ImageHandle,
1257 IN EFI_SYSTEM_TABLE *SystemTable
1258 )
1259 {
1260 EFI_STATUS Status;
1261
1262 //
1263 // Install driver model protocol(s).
1264 //
1265 Status = EfiLibInstallDriverBindingComponentName2 (
1266 ImageHandle,
1267 SystemTable,
1268 &gDiskIoDriverBinding,
1269 ImageHandle,
1270 &gDiskIoComponentName,
1271 &gDiskIoComponentName2
1272 );
1273 ASSERT_EFI_ERROR (Status);
1274
1275 return Status;
1276 }