]> git.proxmox.com Git - mirror_edk2.git/blob - IntelFrameworkModulePkg/Csm/BiosThunk/BlockIoDxe/BiosInt13.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
IntelFrameworkModulePkg: Clean up source files
[mirror_edk2.git] / IntelFrameworkModulePkg / Csm / BiosThunk / BlockIoDxe / BiosInt13.c
1 /** @file
2 Routines that use BIOS to support INT 13 devices.
3
4 Copyright (c) 1999 - 2018, Intel Corporation. All rights reserved.<BR>
5
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions
8 of the BSD License which accompanies this distribution. The
9 full text of the license may be found at
10 http://opensource.org/licenses/bsd-license.php
11
12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
14
15 **/
16
17 #include "BiosBlkIo.h"
18
19 //
20 // Module global variables
21 //
22 //
23 // Address packet is a buffer under 1 MB for all version EDD calls
24 //
25 extern EDD_DEVICE_ADDRESS_PACKET *mEddBufferUnder1Mb;
26
27 //
28 // This is a buffer for INT 13h func 48 information
29 //
30 extern BIOS_LEGACY_DRIVE *mLegacyDriverUnder1Mb;
31
32 //
33 // Buffer of 0xFE00 bytes for EDD 1.1 transfer must be under 1 MB
34 // 0xFE00 bytes is the max transfer size supported.
35 //
36 extern VOID *mEdd11Buffer;
37
38
39 /**
40 Initialize block I/O device instance
41
42 @param Dev Instance of block I/O device instance
43
44 @retval TRUE Initialization succeeds.
45 @retval FALSE Initialization fails.
46
47 **/
48 BOOLEAN
49 BiosInitBlockIo (
50 IN BIOS_BLOCK_IO_DEV *Dev
51 )
52 {
53 EFI_BLOCK_IO_PROTOCOL *BlockIo;
54 EFI_BLOCK_IO_MEDIA *BlockMedia;
55 BIOS_LEGACY_DRIVE *Bios;
56
57 BlockIo = &Dev->BlockIo;
58 BlockIo->Media = &Dev->BlockMedia;
59 BlockMedia = BlockIo->Media;
60 Bios = &Dev->Bios;
61
62 if (Int13GetDeviceParameters (Dev, Bios) != 0) {
63 if (Int13Extensions (Dev, Bios) != 0) {
64 BlockMedia->LastBlock = (EFI_LBA) Bios->Parameters.PhysicalSectors - 1;
65 BlockMedia->BlockSize = (UINT32) Bios->Parameters.BytesPerSector;
66
67 if ((Bios->Parameters.Flags & EDD_DEVICE_REMOVABLE) == EDD_DEVICE_REMOVABLE) {
68 BlockMedia->RemovableMedia = TRUE;
69 }
70
71 } else {
72 //
73 // Legacy Interfaces
74 //
75 BlockMedia->BlockSize = 512;
76 BlockMedia->LastBlock = (Bios->MaxHead + 1) * Bios->MaxSector * (Bios->MaxCylinder + 1) - 1;
77 }
78
79 DEBUG ((DEBUG_INIT, "BlockSize = %d LastBlock = %d\n", BlockMedia->BlockSize, BlockMedia->LastBlock));
80
81 BlockMedia->LogicalPartition = FALSE;
82 BlockMedia->WriteCaching = FALSE;
83
84 //
85 // BugBug: Need to set this for removable media devices if they do not
86 // have media present
87 //
88 BlockMedia->ReadOnly = FALSE;
89 BlockMedia->MediaPresent = TRUE;
90
91 BlockIo->Reset = BiosBlockIoReset;
92 BlockIo->FlushBlocks = BiosBlockIoFlushBlocks;
93
94 if (!Bios->ExtendedInt13) {
95 //
96 // Legacy interfaces
97 //
98 BlockIo->ReadBlocks = BiosReadLegacyDrive;
99 BlockIo->WriteBlocks = BiosWriteLegacyDrive;
100 } else if ((Bios->EddVersion == EDD_VERSION_30) && (Bios->Extensions64Bit)) {
101 //
102 // EDD 3.0 Required for Device path, but extended reads are not required.
103 //
104 BlockIo->ReadBlocks = Edd30BiosReadBlocks;
105 BlockIo->WriteBlocks = Edd30BiosWriteBlocks;
106 } else {
107 //
108 // Assume EDD 1.1 - Read and Write functions.
109 // This could be EDD 3.0 without Extensions64Bit being set.
110 // If it's EDD 1.1 this will work, but the device path will not
111 // be correct. This will cause confusion to EFI OS installation.
112 //
113 BlockIo->ReadBlocks = Edd11BiosReadBlocks;
114 BlockIo->WriteBlocks = Edd11BiosWriteBlocks;
115 }
116
117 BlockMedia->LogicalPartition = FALSE;
118 BlockMedia->WriteCaching = FALSE;
119
120 return TRUE;
121 }
122
123 return FALSE;
124 }
125
126 /**
127 Gets parameters of block I/O device.
128
129 @param BiosBlockIoDev Instance of block I/O device.
130 @param Drive Legacy drive.
131
132 @return Result of device parameter retrieval.
133
134 **/
135 UINTN
136 Int13GetDeviceParameters (
137 IN BIOS_BLOCK_IO_DEV *BiosBlockIoDev,
138 IN BIOS_LEGACY_DRIVE *Drive
139 )
140 {
141 UINTN CarryFlag;
142 UINT16 Cylinder;
143 EFI_IA32_REGISTER_SET Regs;
144
145 ZeroMem (&Regs, sizeof (EFI_IA32_REGISTER_SET));
146
147 Regs.H.AH = 0x08;
148 Regs.H.DL = Drive->Number;
149 CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
150 DEBUG ((DEBUG_INIT, "Int13GetDeviceParameters: INT 13 08 DL=%02x : CF=%d AH=%02x\n", Drive->Number, CarryFlag, Regs.H.AH));
151 if (CarryFlag != 0 || Regs.H.AH != 0x00) {
152 Drive->ErrorCode = Regs.H.AH;
153 return FALSE;
154 }
155
156 if (Drive->Floppy) {
157 if (Regs.H.BL == 0x10) {
158 Drive->AtapiFloppy = TRUE;
159 } else {
160 Drive->MaxHead = Regs.H.DH;
161 Drive->MaxSector = Regs.H.CL;
162 Drive->MaxCylinder = Regs.H.CH;
163 if (Drive->MaxSector == 0) {
164 //
165 // BugBug: You can not trust the Carry flag.
166 //
167 return FALSE;
168 }
169 }
170 } else {
171 Drive->MaxHead = (UINT8) (Regs.H.DH & 0x3f);
172 Cylinder = (UINT16) (((UINT16) Regs.H.DH & 0xc0) << 4);
173 Cylinder = (UINT16) (Cylinder | ((UINT16) Regs.H.CL & 0xc0) << 2);
174 Drive->MaxCylinder = (UINT16) (Cylinder + Regs.H.CH);
175 Drive->MaxSector = (UINT8) (Regs.H.CL & 0x3f);
176 }
177
178 return TRUE;
179 }
180
181 /**
182 Extension of INT13 call.
183
184 @param BiosBlockIoDev Instance of block I/O device.
185 @param Drive Legacy drive.
186
187 @return Result of this extension.
188
189 **/
190 UINTN
191 Int13Extensions (
192 IN BIOS_BLOCK_IO_DEV *BiosBlockIoDev,
193 IN BIOS_LEGACY_DRIVE *Drive
194 )
195 {
196 INTN CarryFlag;
197 EFI_IA32_REGISTER_SET Regs;
198
199 ZeroMem (&Regs, sizeof (EFI_IA32_REGISTER_SET));
200
201 Regs.H.AH = 0x41;
202 Regs.X.BX = 0x55aa;
203 Regs.H.DL = Drive->Number;
204 CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
205 DEBUG ((DEBUG_INIT, "Int13Extensions: INT 13 41 DL=%02x : CF=%d BX=%04x\n", Drive->Number, CarryFlag, Regs.X.BX));
206 if (CarryFlag != 0 || Regs.X.BX != 0xaa55) {
207 Drive->ExtendedInt13 = FALSE;
208 Drive->DriveLockingAndEjecting = FALSE;
209 Drive->Edd = FALSE;
210 return FALSE;
211 }
212
213 Drive->EddVersion = Regs.H.AH;
214 Drive->ExtendedInt13 = (BOOLEAN) ((Regs.X.CX & 0x01) == 0x01);
215 Drive->DriveLockingAndEjecting = (BOOLEAN) ((Regs.X.CX & 0x02) == 0x02);
216 Drive->Edd = (BOOLEAN) ((Regs.X.CX & 0x04) == 0x04);
217 Drive->Extensions64Bit = (BOOLEAN) (Regs.X.CX & 0x08);
218
219 Drive->ParametersValid = (UINT8) GetDriveParameters (BiosBlockIoDev, Drive);
220 return TRUE;
221 }
222
223 /**
224 Gets parameters of legacy drive.
225
226 @param BiosBlockIoDev Instance of block I/O device.
227 @param Drive Legacy drive.
228
229 @return Result of drive parameter retrieval.
230
231 **/
232 UINTN
233 GetDriveParameters (
234 IN BIOS_BLOCK_IO_DEV *BiosBlockIoDev,
235 IN BIOS_LEGACY_DRIVE *Drive
236 )
237 {
238 INTN CarryFlag;
239 EFI_IA32_REGISTER_SET Regs;
240 UINTN PointerMath;
241
242 ZeroMem (&Regs, sizeof (EFI_IA32_REGISTER_SET));
243
244 Regs.H.AH = 0x48;
245 Regs.H.DL = Drive->Number;
246
247 //
248 // EDD Buffer must be passed in with max buffer size as first entry in the buffer
249 //
250 mLegacyDriverUnder1Mb->Parameters.StructureSize = (UINT16) sizeof (EDD_DRIVE_PARAMETERS);
251 Regs.X.DS = EFI_SEGMENT ((UINTN)(&mLegacyDriverUnder1Mb->Parameters));
252 Regs.X.SI = EFI_OFFSET ((UINTN)(&mLegacyDriverUnder1Mb->Parameters));
253 CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
254 DEBUG ((DEBUG_INIT, "GetDriveParameters: INT 13 48 DL=%02x : CF=%d AH=%02x\n", Drive->Number, CarryFlag, Regs.H.AH));
255 if (CarryFlag != 0 || Regs.H.AH != 0x00) {
256 Drive->ErrorCode = Regs.H.AH;
257 SetMem (&Drive->Parameters, sizeof (Drive->Parameters), 0xaf);
258 return FALSE;
259 }
260 //
261 // We only have one buffer < 1MB, so copy into our instance data
262 //
263 CopyMem (
264 &Drive->Parameters,
265 &mLegacyDriverUnder1Mb->Parameters,
266 sizeof (Drive->Parameters)
267 );
268
269 if (Drive->AtapiFloppy) {
270 //
271 // Sense Media Type
272 //
273 Regs.H.AH = 0x20;
274 Regs.H.DL = Drive->Number;
275 CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
276 DEBUG ((DEBUG_INIT, "GetDriveParameters: INT 13 20 DL=%02x : CF=%d AL=%02x\n", Drive->Number, CarryFlag, Regs.H.AL));
277 if (CarryFlag != 0) {
278 //
279 // Media not present or unknown media present
280 //
281 if ((Drive->Parameters.Flags & EDD_GEOMETRY_VALID) == EDD_GEOMETRY_VALID) {
282 Drive->MaxHead = (UINT8) (Drive->Parameters.MaxHeads - 1);
283 Drive->MaxSector = (UINT8) Drive->Parameters.SectorsPerTrack;
284 ASSERT (Drive->MaxSector != 0);
285 Drive->MaxCylinder = (UINT16) (Drive->Parameters.MaxCylinders - 1);
286 } else {
287 Drive->MaxHead = 0;
288 Drive->MaxSector = 1;
289 Drive->MaxCylinder = 0;
290 }
291
292 } else {
293 //
294 // Media Present
295 //
296 switch (Regs.H.AL) {
297 case 0x03:
298 //
299 // 720 KB
300 //
301 Drive->MaxHead = 1;
302 Drive->MaxSector = 9;
303 Drive->MaxCylinder = 79;
304 break;
305
306 case 0x04:
307 //
308 // 1.44MB
309 //
310 Drive->MaxHead = 1;
311 Drive->MaxSector = 18;
312 Drive->MaxCylinder = 79;
313 break;
314
315 case 0x06:
316 //
317 // 2.88MB
318 //
319 Drive->MaxHead = 1;
320 Drive->MaxSector = 36;
321 Drive->MaxCylinder = 79;
322 break;
323
324 case 0x0C:
325 //
326 // 360 KB
327 //
328 Drive->MaxHead = 1;
329 Drive->MaxSector = 9;
330 Drive->MaxCylinder = 39;
331 break;
332
333 case 0x0D:
334 //
335 // 1.2 MB
336 //
337 Drive->MaxHead = 1;
338 Drive->MaxSector = 15;
339 Drive->MaxCylinder = 79;
340 break;
341
342 case 0x0E:
343 //
344 // Toshiba 3 mode
345 //
346 case 0x0F:
347 //
348 // NEC 3 mode
349 //
350 case 0x10:
351 //
352 // Default Media
353 //
354 if ((Drive->Parameters.Flags & EDD_GEOMETRY_VALID) == EDD_GEOMETRY_VALID) {
355 Drive->MaxHead = (UINT8) (Drive->Parameters.MaxHeads - 1);
356 Drive->MaxSector = (UINT8) Drive->Parameters.SectorsPerTrack;
357 ASSERT (Drive->MaxSector != 0);
358 Drive->MaxCylinder = (UINT16) (Drive->Parameters.MaxCylinders - 1);
359 } else {
360 Drive->MaxHead = 0;
361 Drive->MaxSector = 1;
362 Drive->MaxCylinder = 0;
363 }
364 break;
365
366 default:
367 //
368 // Unknown media type.
369 //
370 Drive->MaxHead = 0;
371 Drive->MaxSector = 1;
372 Drive->MaxCylinder = 0;
373 break;
374 }
375 }
376
377 Drive->Parameters.PhysicalSectors = (Drive->MaxHead + 1) * Drive->MaxSector * (Drive->MaxCylinder + 1);
378 Drive->Parameters.BytesPerSector = 512;
379 }
380 //
381 // This data comes from the BIOS so it may not allways be valid
382 // since the BIOS may reuse this buffer for future accesses
383 //
384 PointerMath = EFI_SEGMENT (Drive->Parameters.Fdpt) << 4;
385 PointerMath += EFI_OFFSET (Drive->Parameters.Fdpt);
386 Drive->FdptPointer = (VOID *) PointerMath;
387
388 return TRUE;
389 }
390 //
391 // Block IO Routines
392 //
393
394 /**
395 Read BufferSize bytes from Lba into Buffer.
396
397 @param This Indicates a pointer to the calling context.
398 @param MediaId Id of the media, changes every time the media is replaced.
399 @param Lba The starting Logical Block Address to read from
400 @param BufferSize Size of Buffer, must be a multiple of device block size.
401 @param Buffer A pointer to the destination buffer for the data. The caller is
402 responsible for either having implicit or explicit ownership of the buffer.
403
404 @retval EFI_SUCCESS The data was read correctly from the device.
405 @retval EFI_DEVICE_ERROR The device reported an error while performing the read.
406 @retval EFI_NO_MEDIA There is no media in the device.
407 @retval EFI_MEDIA_CHANGED The MediaId does not matched the current device.
408 @retval EFI_BAD_BUFFER_SIZE The Buffer was not a multiple of the block size of the device.
409 @retval EFI_INVALID_PARAMETER The read request contains LBAs that are not valid,
410 or the buffer is not on proper alignment.
411
412 **/
413 EFI_STATUS
414 EFIAPI
415 Edd30BiosReadBlocks (
416 IN EFI_BLOCK_IO_PROTOCOL *This,
417 IN UINT32 MediaId,
418 IN EFI_LBA Lba,
419 IN UINTN BufferSize,
420 OUT VOID *Buffer
421 )
422 {
423 EFI_BLOCK_IO_MEDIA *Media;
424 BIOS_BLOCK_IO_DEV *BiosBlockIoDev;
425 EDD_DEVICE_ADDRESS_PACKET *AddressPacket;
426 //
427 // I exist only for readability
428 //
429 EFI_IA32_REGISTER_SET Regs;
430 UINT64 TransferBuffer;
431 UINTN NumberOfBlocks;
432 UINTN TransferByteSize;
433 UINTN BlockSize;
434 BIOS_LEGACY_DRIVE *Bios;
435 UINTN CarryFlag;
436 UINTN MaxTransferBlocks;
437 EFI_BLOCK_IO_PROTOCOL *BlockIo;
438
439 Media = This->Media;
440 BlockSize = Media->BlockSize;
441
442 ZeroMem (&Regs, sizeof (EFI_IA32_REGISTER_SET));
443
444 if (MediaId != Media->MediaId) {
445 return EFI_MEDIA_CHANGED;
446 }
447
448 if (Lba > Media->LastBlock) {
449 return EFI_INVALID_PARAMETER;
450 }
451
452 if ((Lba + (BufferSize / BlockSize) - 1) > Media->LastBlock) {
453 return EFI_INVALID_PARAMETER;
454 }
455
456 if (BufferSize % BlockSize != 0) {
457 return EFI_BAD_BUFFER_SIZE;
458 }
459
460 if (Buffer == NULL) {
461 return EFI_INVALID_PARAMETER;
462 }
463
464 if (BufferSize == 0) {
465 return EFI_SUCCESS;
466 }
467
468 BiosBlockIoDev = BIOS_BLOCK_IO_FROM_THIS (This);
469 AddressPacket = mEddBufferUnder1Mb;
470
471 MaxTransferBlocks = MAX_EDD11_XFER / BlockSize;
472
473 TransferBuffer = (UINT64)(UINTN) Buffer;
474 for (; BufferSize > 0;) {
475 NumberOfBlocks = BufferSize / BlockSize;
476 NumberOfBlocks = NumberOfBlocks > MaxTransferBlocks ? MaxTransferBlocks : NumberOfBlocks;
477 //
478 // Max transfer MaxTransferBlocks
479 //
480 AddressPacket->PacketSizeInBytes = (UINT8) sizeof (EDD_DEVICE_ADDRESS_PACKET);
481 AddressPacket->Zero = 0;
482 AddressPacket->NumberOfBlocks = (UINT8) NumberOfBlocks;
483 AddressPacket->Zero2 = 0;
484 AddressPacket->SegOffset = 0xffffffff;
485 AddressPacket->Lba = (UINT64) Lba;
486 AddressPacket->TransferBuffer = TransferBuffer;
487
488 Regs.H.AH = 0x42;
489 Regs.H.DL = BiosBlockIoDev->Bios.Number;
490 Regs.X.SI = EFI_OFFSET (AddressPacket);
491 Regs.X.DS = EFI_SEGMENT (AddressPacket);
492
493 CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
494 DEBUG (
495 (
496 DEBUG_BLKIO, "Edd30BiosReadBlocks: INT 13 42 DL=%02x : CF=%d AH=%02x\n", BiosBlockIoDev->Bios.Number,
497 CarryFlag, Regs.H.AH
498 )
499 );
500
501 Media->MediaPresent = TRUE;
502 if (CarryFlag != 0) {
503 //
504 // Return Error Status
505 //
506 BiosBlockIoDev->Bios.ErrorCode = Regs.H.AH;
507 if (BiosBlockIoDev->Bios.ErrorCode == BIOS_DISK_CHANGED) {
508 Media->MediaId++;
509 Bios = &BiosBlockIoDev->Bios;
510 if (Int13GetDeviceParameters (BiosBlockIoDev, Bios) != 0) {
511 if (Int13Extensions (BiosBlockIoDev, Bios) != 0) {
512 Media->LastBlock = (EFI_LBA) Bios->Parameters.PhysicalSectors - 1;
513 Media->BlockSize = (UINT32) Bios->Parameters.BytesPerSector;
514 } else {
515 ASSERT (FALSE);
516 }
517
518 Media->ReadOnly = FALSE;
519 gBS->HandleProtocol (BiosBlockIoDev->Handle, &gEfiBlockIoProtocolGuid, (VOID **) &BlockIo);
520 gBS->ReinstallProtocolInterface (BiosBlockIoDev->Handle, &gEfiBlockIoProtocolGuid, BlockIo, BlockIo);
521 return EFI_MEDIA_CHANGED;
522 }
523 }
524
525 if (Media->RemovableMedia) {
526 Media->MediaPresent = FALSE;
527 }
528
529 return EFI_DEVICE_ERROR;
530 }
531
532 TransferByteSize = NumberOfBlocks * BlockSize;
533 BufferSize = BufferSize - TransferByteSize;
534 TransferBuffer += TransferByteSize;
535 Lba += NumberOfBlocks;
536 }
537
538 return EFI_SUCCESS;
539 }
540
541 /**
542 Write BufferSize bytes from Lba into Buffer.
543
544 @param This Indicates a pointer to the calling context.
545 @param MediaId The media ID that the write request is for.
546 @param Lba The starting logical block address to be written. The caller is
547 responsible for writing to only legitimate locations.
548 @param BufferSize Size of Buffer, must be a multiple of device block size.
549 @param Buffer A pointer to the source buffer for the data.
550
551 @retval EFI_SUCCESS The data was written correctly to the device.
552 @retval EFI_WRITE_PROTECTED The device can not be written to.
553 @retval EFI_DEVICE_ERROR The device reported an error while performing the write.
554 @retval EFI_NO_MEDIA There is no media in the device.
555 @retval EFI_MEDIA_CHNAGED The MediaId does not matched the current device.
556 @retval EFI_BAD_BUFFER_SIZE The Buffer was not a multiple of the block size of the device.
557 @retval EFI_INVALID_PARAMETER The write request contains LBAs that are not valid,
558 or the buffer is not on proper alignment.
559
560 **/
561 EFI_STATUS
562 EFIAPI
563 Edd30BiosWriteBlocks (
564 IN EFI_BLOCK_IO_PROTOCOL *This,
565 IN UINT32 MediaId,
566 IN EFI_LBA Lba,
567 IN UINTN BufferSize,
568 OUT VOID *Buffer
569 )
570 {
571 EFI_BLOCK_IO_MEDIA *Media;
572 BIOS_BLOCK_IO_DEV *BiosBlockIoDev;
573 EDD_DEVICE_ADDRESS_PACKET *AddressPacket;
574 //
575 // I exist only for readability
576 //
577 EFI_IA32_REGISTER_SET Regs;
578 UINT64 TransferBuffer;
579 UINTN NumberOfBlocks;
580 UINTN TransferByteSize;
581 UINTN BlockSize;
582 BIOS_LEGACY_DRIVE *Bios;
583 UINTN CarryFlag;
584 UINTN MaxTransferBlocks;
585 EFI_BLOCK_IO_PROTOCOL *BlockIo;
586
587 Media = This->Media;
588 BlockSize = Media->BlockSize;
589
590 ZeroMem (&Regs, sizeof (EFI_IA32_REGISTER_SET));
591
592 if (MediaId != Media->MediaId) {
593 return EFI_MEDIA_CHANGED;
594 }
595
596 if (Lba > Media->LastBlock) {
597 return EFI_DEVICE_ERROR;
598 }
599
600 if ((Lba + (BufferSize / BlockSize) - 1) > Media->LastBlock) {
601 return EFI_INVALID_PARAMETER;
602 }
603
604 if (BufferSize % BlockSize != 0) {
605 return EFI_BAD_BUFFER_SIZE;
606 }
607
608 if (Buffer == NULL) {
609 return EFI_INVALID_PARAMETER;
610 }
611
612 if (BufferSize == 0) {
613 return EFI_SUCCESS;
614 }
615
616 BiosBlockIoDev = BIOS_BLOCK_IO_FROM_THIS (This);
617 AddressPacket = mEddBufferUnder1Mb;
618
619 MaxTransferBlocks = MAX_EDD11_XFER / BlockSize;
620
621 TransferBuffer = (UINT64)(UINTN) Buffer;
622 for (; BufferSize > 0;) {
623 NumberOfBlocks = BufferSize / BlockSize;
624 NumberOfBlocks = NumberOfBlocks > MaxTransferBlocks ? MaxTransferBlocks : NumberOfBlocks;
625 //
626 // Max transfer MaxTransferBlocks
627 //
628 AddressPacket->PacketSizeInBytes = (UINT8) sizeof (EDD_DEVICE_ADDRESS_PACKET);
629 AddressPacket->Zero = 0;
630 AddressPacket->NumberOfBlocks = (UINT8) NumberOfBlocks;
631 AddressPacket->Zero2 = 0;
632 AddressPacket->SegOffset = 0xffffffff;
633 AddressPacket->Lba = (UINT64) Lba;
634 AddressPacket->TransferBuffer = TransferBuffer;
635
636 Regs.H.AH = 0x43;
637 Regs.H.AL = 0x00;
638 //
639 // Write Verify Off
640 //
641 Regs.H.DL = (UINT8) (BiosBlockIoDev->Bios.Number);
642 Regs.X.SI = EFI_OFFSET (AddressPacket);
643 Regs.X.DS = EFI_SEGMENT (AddressPacket);
644
645 CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
646 DEBUG (
647 (
648 DEBUG_BLKIO, "Edd30BiosWriteBlocks: INT 13 43 DL=%02x : CF=%d AH=%02x\n", BiosBlockIoDev->Bios.Number,
649 CarryFlag, Regs.H.AH
650 )
651 );
652
653 Media->MediaPresent = TRUE;
654 if (CarryFlag != 0) {
655 //
656 // Return Error Status
657 //
658 BiosBlockIoDev->Bios.ErrorCode = Regs.H.AH;
659 if (BiosBlockIoDev->Bios.ErrorCode == BIOS_DISK_CHANGED) {
660 Media->MediaId++;
661 Bios = &BiosBlockIoDev->Bios;
662 if (Int13GetDeviceParameters (BiosBlockIoDev, Bios) != 0) {
663 if (Int13Extensions (BiosBlockIoDev, Bios) != 0) {
664 Media->LastBlock = (EFI_LBA) Bios->Parameters.PhysicalSectors - 1;
665 Media->BlockSize = (UINT32) Bios->Parameters.BytesPerSector;
666 } else {
667 ASSERT (FALSE);
668 }
669
670 Media->ReadOnly = FALSE;
671 gBS->HandleProtocol (BiosBlockIoDev->Handle, &gEfiBlockIoProtocolGuid, (VOID **) &BlockIo);
672 gBS->ReinstallProtocolInterface (BiosBlockIoDev->Handle, &gEfiBlockIoProtocolGuid, BlockIo, BlockIo);
673 return EFI_MEDIA_CHANGED;
674 }
675 } else if (BiosBlockIoDev->Bios.ErrorCode == BIOS_WRITE_PROTECTED) {
676 Media->ReadOnly = TRUE;
677 return EFI_WRITE_PROTECTED;
678 }
679
680 if (Media->RemovableMedia) {
681 Media->MediaPresent = FALSE;
682 }
683
684 return EFI_DEVICE_ERROR;
685 }
686
687 Media->ReadOnly = FALSE;
688 TransferByteSize = NumberOfBlocks * BlockSize;
689 BufferSize = BufferSize - TransferByteSize;
690 TransferBuffer += TransferByteSize;
691 Lba += NumberOfBlocks;
692 }
693
694 return EFI_SUCCESS;
695 }
696
697 /**
698 Flush the Block Device.
699
700 @param This Indicates a pointer to the calling context.
701
702 @retval EFI_SUCCESS All outstanding data was written to the device
703 @retval EFI_DEVICE_ERROR The device reported an error while writting back the data
704 @retval EFI_NO_MEDIA There is no media in the device.
705
706 **/
707 EFI_STATUS
708 EFIAPI
709 BiosBlockIoFlushBlocks (
710 IN EFI_BLOCK_IO_PROTOCOL *This
711 )
712 {
713 return EFI_SUCCESS;
714 }
715
716 /**
717 Reset the Block Device.
718
719 @param This Indicates a pointer to the calling context.
720 @param ExtendedVerification Driver may perform diagnostics on reset.
721
722 @retval EFI_SUCCESS The device was reset.
723 @retval EFI_DEVICE_ERROR The device is not functioning properly and could
724 not be reset.
725
726 **/
727 EFI_STATUS
728 EFIAPI
729 BiosBlockIoReset (
730 IN EFI_BLOCK_IO_PROTOCOL *This,
731 IN BOOLEAN ExtendedVerification
732 )
733 {
734 BIOS_BLOCK_IO_DEV *BiosBlockIoDev;
735 EFI_IA32_REGISTER_SET Regs;
736 UINTN CarryFlag;
737
738 BiosBlockIoDev = BIOS_BLOCK_IO_FROM_THIS (This);
739
740 ZeroMem (&Regs, sizeof (EFI_IA32_REGISTER_SET));
741
742 Regs.H.AH = 0x00;
743 Regs.H.DL = BiosBlockIoDev->Bios.Number;
744 CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
745 DEBUG (
746 (
747 DEBUG_INIT, "BiosBlockIoReset: INT 13 00 DL=%02x : CF=%d AH=%02x\n", BiosBlockIoDev->Bios.Number, CarryFlag,
748 Regs.H.AH
749 )
750 );
751 if (CarryFlag != 0) {
752 if (Regs.H.AL == BIOS_RESET_FAILED) {
753 Regs.H.AH = 0x00;
754 Regs.H.DL = BiosBlockIoDev->Bios.Number;
755 CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
756 DEBUG (
757 (
758 DEBUG_INIT, "BiosBlockIoReset: INT 13 00 DL=%02x : CF=%d AH=%02x\n", BiosBlockIoDev->Bios.Number, CarryFlag,
759 Regs.H.AH
760 )
761 );
762 if (CarryFlag != 0) {
763 BiosBlockIoDev->Bios.ErrorCode = Regs.H.AH;
764 return EFI_DEVICE_ERROR;
765 }
766 }
767 }
768
769 return EFI_SUCCESS;
770 }
771 //
772 //
773 // These functions need to double buffer all data under 1MB!
774 //
775 //
776
777 /**
778 Read BufferSize bytes from Lba into Buffer.
779
780 @param This Indicates a pointer to the calling context.
781 @param MediaId Id of the media, changes every time the media is replaced.
782 @param Lba The starting Logical Block Address to read from
783 @param BufferSize Size of Buffer, must be a multiple of device block size.
784 @param Buffer A pointer to the destination buffer for the data. The caller is
785 responsible for either having implicit or explicit ownership of the buffer.
786
787 @retval EFI_SUCCESS The data was read correctly from the device.
788 @retval EFI_DEVICE_ERROR The device reported an error while performing the read.
789 @retval EFI_NO_MEDIA There is no media in the device.
790 @retval EFI_MEDIA_CHANGED The MediaId does not matched the current device.
791 @retval EFI_BAD_BUFFER_SIZE The Buffer was not a multiple of the block size of the device.
792 @retval EFI_INVALID_PARAMETER The read request contains LBAs that are not valid,
793 or the buffer is not on proper alignment.
794
795 **/
796 EFI_STATUS
797 EFIAPI
798 Edd11BiosReadBlocks (
799 IN EFI_BLOCK_IO_PROTOCOL *This,
800 IN UINT32 MediaId,
801 IN EFI_LBA Lba,
802 IN UINTN BufferSize,
803 OUT VOID *Buffer
804 )
805 {
806 EFI_BLOCK_IO_MEDIA *Media;
807 BIOS_BLOCK_IO_DEV *BiosBlockIoDev;
808 EDD_DEVICE_ADDRESS_PACKET *AddressPacket;
809 //
810 // I exist only for readability
811 //
812 EFI_IA32_REGISTER_SET Regs;
813 UINT64 TransferBuffer;
814 UINTN NumberOfBlocks;
815 UINTN TransferByteSize;
816 UINTN BlockSize;
817 BIOS_LEGACY_DRIVE *Bios;
818 UINTN CarryFlag;
819 UINTN MaxTransferBlocks;
820 EFI_BLOCK_IO_PROTOCOL *BlockIo;
821
822 Media = This->Media;
823 BlockSize = Media->BlockSize;
824
825 ZeroMem (&Regs, sizeof (EFI_IA32_REGISTER_SET));
826
827 if (MediaId != Media->MediaId) {
828 return EFI_MEDIA_CHANGED;
829 }
830
831 if (Lba > Media->LastBlock) {
832 return EFI_INVALID_PARAMETER;
833 }
834
835 if ((Lba + (BufferSize / BlockSize) - 1) > Media->LastBlock) {
836 return EFI_INVALID_PARAMETER;
837 }
838
839 if (BufferSize % BlockSize != 0) {
840 return EFI_BAD_BUFFER_SIZE;
841 }
842
843 if (Buffer == NULL) {
844 return EFI_INVALID_PARAMETER;
845 }
846
847 if (BufferSize == 0) {
848 return EFI_SUCCESS;
849 }
850
851 BiosBlockIoDev = BIOS_BLOCK_IO_FROM_THIS (This);
852 AddressPacket = mEddBufferUnder1Mb;
853
854 MaxTransferBlocks = MAX_EDD11_XFER / BlockSize;
855
856 TransferBuffer = (UINT64)(UINTN) mEdd11Buffer;
857 for (; BufferSize > 0;) {
858 NumberOfBlocks = BufferSize / BlockSize;
859 NumberOfBlocks = NumberOfBlocks > MaxTransferBlocks ? MaxTransferBlocks : NumberOfBlocks;
860 //
861 // Max transfer MaxTransferBlocks
862 //
863 AddressPacket->PacketSizeInBytes = (UINT8) sizeof (EDD_DEVICE_ADDRESS_PACKET);
864 AddressPacket->Zero = 0;
865 AddressPacket->NumberOfBlocks = (UINT8) NumberOfBlocks;
866 AddressPacket->Zero2 = 0;
867 //
868 // TransferBuffer has been 4KB alignment. Normalize TransferBuffer to make offset as 0 in seg:offset
869 // format to transfer maximum 127 blocks of data.
870 // Otherwise when offset adding data size exceeds 0xFFFF, if OpROM does not normalize TransferBuffer,
871 // INT13 function 42H will return data boundary error 09H.
872 //
873 AddressPacket->SegOffset = (UINT32) LShiftU64 (RShiftU64(TransferBuffer, 4), 16);
874 AddressPacket->Lba = (UINT64) Lba;
875
876 Regs.H.AH = 0x42;
877 Regs.H.DL = BiosBlockIoDev->Bios.Number;
878 Regs.X.SI = EFI_OFFSET (AddressPacket);
879 Regs.X.DS = EFI_SEGMENT (AddressPacket);
880
881 CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
882 DEBUG (
883 (
884 DEBUG_BLKIO, "Edd11BiosReadBlocks: INT 13 42 DL=%02x : CF=%d AH=%02x : LBA 0x%lx Block(s) %0d \n",
885 BiosBlockIoDev->Bios.Number, CarryFlag, Regs.H.AH, Lba, NumberOfBlocks
886 )
887 );
888 Media->MediaPresent = TRUE;
889 if (CarryFlag != 0) {
890 //
891 // Return Error Status
892 //
893 BiosBlockIoDev->Bios.ErrorCode = Regs.H.AH;
894 if (BiosBlockIoDev->Bios.ErrorCode == BIOS_DISK_CHANGED) {
895 Media->MediaId++;
896 Bios = &BiosBlockIoDev->Bios;
897 if (Int13GetDeviceParameters (BiosBlockIoDev, Bios) != 0) {
898 if (Int13Extensions (BiosBlockIoDev, Bios) != 0) {
899 Media->LastBlock = (EFI_LBA) Bios->Parameters.PhysicalSectors - 1;
900 Media->BlockSize = (UINT32) Bios->Parameters.BytesPerSector;
901 } else {
902 ASSERT (FALSE);
903 }
904
905 Media->ReadOnly = FALSE;
906 gBS->HandleProtocol (BiosBlockIoDev->Handle, &gEfiBlockIoProtocolGuid, (VOID **) &BlockIo);
907 gBS->ReinstallProtocolInterface (BiosBlockIoDev->Handle, &gEfiBlockIoProtocolGuid, BlockIo, BlockIo);
908 return EFI_MEDIA_CHANGED;
909 }
910 }
911
912 if (Media->RemovableMedia) {
913 Media->MediaPresent = FALSE;
914 }
915
916 return EFI_DEVICE_ERROR;
917 }
918
919 TransferByteSize = NumberOfBlocks * BlockSize;
920 CopyMem (Buffer, (VOID *) (UINTN) TransferBuffer, TransferByteSize);
921 BufferSize = BufferSize - TransferByteSize;
922 Buffer = (VOID *) ((UINT8 *) Buffer + TransferByteSize);
923 Lba += NumberOfBlocks;
924 }
925
926 return EFI_SUCCESS;
927 }
928
929 /**
930 Write BufferSize bytes from Lba into Buffer.
931
932 @param This Indicates a pointer to the calling context.
933 @param MediaId The media ID that the write request is for.
934 @param Lba The starting logical block address to be written. The caller is
935 responsible for writing to only legitimate locations.
936 @param BufferSize Size of Buffer, must be a multiple of device block size.
937 @param Buffer A pointer to the source buffer for the data.
938
939 @retval EFI_SUCCESS The data was written correctly to the device.
940 @retval EFI_WRITE_PROTECTED The device can not be written to.
941 @retval EFI_DEVICE_ERROR The device reported an error while performing the write.
942 @retval EFI_NO_MEDIA There is no media in the device.
943 @retval EFI_MEDIA_CHNAGED The MediaId does not matched the current device.
944 @retval EFI_BAD_BUFFER_SIZE The Buffer was not a multiple of the block size of the device.
945 @retval EFI_INVALID_PARAMETER The write request contains LBAs that are not valid,
946 or the buffer is not on proper alignment.
947
948 **/
949 EFI_STATUS
950 EFIAPI
951 Edd11BiosWriteBlocks (
952 IN EFI_BLOCK_IO_PROTOCOL *This,
953 IN UINT32 MediaId,
954 IN EFI_LBA Lba,
955 IN UINTN BufferSize,
956 OUT VOID *Buffer
957 )
958 {
959 EFI_BLOCK_IO_MEDIA *Media;
960 BIOS_BLOCK_IO_DEV *BiosBlockIoDev;
961 EDD_DEVICE_ADDRESS_PACKET *AddressPacket;
962 //
963 // I exist only for readability
964 //
965 EFI_IA32_REGISTER_SET Regs;
966 UINT64 TransferBuffer;
967 UINTN NumberOfBlocks;
968 UINTN TransferByteSize;
969 UINTN BlockSize;
970 BIOS_LEGACY_DRIVE *Bios;
971 UINTN CarryFlag;
972 UINTN MaxTransferBlocks;
973 EFI_BLOCK_IO_PROTOCOL *BlockIo;
974
975 Media = This->Media;
976 BlockSize = Media->BlockSize;
977
978 ZeroMem (&Regs, sizeof (EFI_IA32_REGISTER_SET));
979
980 if (MediaId != Media->MediaId) {
981 return EFI_MEDIA_CHANGED;
982 }
983
984 if (Lba > Media->LastBlock) {
985 return EFI_INVALID_PARAMETER;
986 }
987
988 if ((Lba + (BufferSize / BlockSize) - 1) > Media->LastBlock) {
989 return EFI_INVALID_PARAMETER;
990 }
991
992 if (BufferSize % BlockSize != 0) {
993 return EFI_BAD_BUFFER_SIZE;
994 }
995
996 if (Buffer == NULL) {
997 return EFI_INVALID_PARAMETER;
998 }
999
1000 if (BufferSize == 0) {
1001 return EFI_SUCCESS;
1002 }
1003
1004 BiosBlockIoDev = BIOS_BLOCK_IO_FROM_THIS (This);
1005 AddressPacket = mEddBufferUnder1Mb;
1006
1007 MaxTransferBlocks = MAX_EDD11_XFER / BlockSize;
1008
1009 TransferBuffer = (UINT64)(UINTN) mEdd11Buffer;
1010 for (; BufferSize > 0;) {
1011 NumberOfBlocks = BufferSize / BlockSize;
1012 NumberOfBlocks = NumberOfBlocks > MaxTransferBlocks ? MaxTransferBlocks : NumberOfBlocks;
1013 //
1014 // Max transfer MaxTransferBlocks
1015 //
1016 AddressPacket->PacketSizeInBytes = (UINT8) sizeof (EDD_DEVICE_ADDRESS_PACKET);
1017 AddressPacket->Zero = 0;
1018 AddressPacket->NumberOfBlocks = (UINT8) NumberOfBlocks;
1019 AddressPacket->Zero2 = 0;
1020 //
1021 // TransferBuffer has been 4KB alignment. Normalize TransferBuffer to make offset as 0 in seg:offset
1022 // format to transfer maximum 127 blocks of data.
1023 // Otherwise when offset adding data size exceeds 0xFFFF, if OpROM does not normalize TransferBuffer,
1024 // INT13 function 42H will return data boundary error 09H.
1025 //
1026 AddressPacket->SegOffset = (UINT32) LShiftU64 (RShiftU64(TransferBuffer, 4), 16);
1027 AddressPacket->Lba = (UINT64) Lba;
1028
1029 Regs.H.AH = 0x43;
1030 Regs.H.AL = 0x00;
1031 //
1032 // Write Verify disable
1033 //
1034 Regs.H.DL = BiosBlockIoDev->Bios.Number;
1035 Regs.X.SI = EFI_OFFSET (AddressPacket);
1036 Regs.X.DS = EFI_SEGMENT (AddressPacket);
1037
1038 TransferByteSize = NumberOfBlocks * BlockSize;
1039 CopyMem ((VOID *) (UINTN) TransferBuffer, Buffer, TransferByteSize);
1040
1041 CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
1042 DEBUG (
1043 (
1044 DEBUG_BLKIO, "Edd11BiosWriteBlocks: INT 13 43 DL=%02x : CF=%d AH=%02x\n: LBA 0x%lx Block(s) %0d \n",
1045 BiosBlockIoDev->Bios.Number, CarryFlag, Regs.H.AH, Lba, NumberOfBlocks
1046 )
1047 );
1048 Media->MediaPresent = TRUE;
1049 if (CarryFlag != 0) {
1050 //
1051 // Return Error Status
1052 //
1053 BiosBlockIoDev->Bios.ErrorCode = Regs.H.AH;
1054 if (BiosBlockIoDev->Bios.ErrorCode == BIOS_DISK_CHANGED) {
1055 Media->MediaId++;
1056 Bios = &BiosBlockIoDev->Bios;
1057 if (Int13GetDeviceParameters (BiosBlockIoDev, Bios) != 0) {
1058 if (Int13Extensions (BiosBlockIoDev, Bios) != 0) {
1059 Media->LastBlock = (EFI_LBA) Bios->Parameters.PhysicalSectors - 1;
1060 Media->BlockSize = (UINT32) Bios->Parameters.BytesPerSector;
1061 } else {
1062 ASSERT (FALSE);
1063 }
1064
1065 Media->ReadOnly = FALSE;
1066 gBS->HandleProtocol (BiosBlockIoDev->Handle, &gEfiBlockIoProtocolGuid, (VOID **) &BlockIo);
1067 gBS->ReinstallProtocolInterface (BiosBlockIoDev->Handle, &gEfiBlockIoProtocolGuid, BlockIo, BlockIo);
1068 return EFI_MEDIA_CHANGED;
1069 }
1070 } else if (BiosBlockIoDev->Bios.ErrorCode == BIOS_WRITE_PROTECTED) {
1071 Media->ReadOnly = TRUE;
1072 return EFI_WRITE_PROTECTED;
1073 }
1074
1075 if (Media->RemovableMedia) {
1076 Media->MediaPresent = FALSE;
1077 }
1078
1079 return EFI_DEVICE_ERROR;
1080 }
1081
1082 Media->ReadOnly = FALSE;
1083 BufferSize = BufferSize - TransferByteSize;
1084 Buffer = (VOID *) ((UINT8 *) Buffer + TransferByteSize);
1085 Lba += NumberOfBlocks;
1086 }
1087
1088 return EFI_SUCCESS;
1089 }
1090
1091 /**
1092 Read BufferSize bytes from Lba into Buffer.
1093
1094 @param This Indicates a pointer to the calling context.
1095 @param MediaId Id of the media, changes every time the media is replaced.
1096 @param Lba The starting Logical Block Address to read from
1097 @param BufferSize Size of Buffer, must be a multiple of device block size.
1098 @param Buffer A pointer to the destination buffer for the data. The caller is
1099 responsible for either having implicit or explicit ownership of the buffer.
1100
1101 @retval EFI_SUCCESS The data was read correctly from the device.
1102 @retval EFI_DEVICE_ERROR The device reported an error while performing the read.
1103 @retval EFI_NO_MEDIA There is no media in the device.
1104 @retval EFI_MEDIA_CHANGED The MediaId does not matched the current device.
1105 @retval EFI_BAD_BUFFER_SIZE The Buffer was not a multiple of the block size of the device.
1106 @retval EFI_INVALID_PARAMETER The read request contains LBAs that are not valid,
1107 or the buffer is not on proper alignment.
1108
1109 **/
1110 EFI_STATUS
1111 EFIAPI
1112 BiosReadLegacyDrive (
1113 IN EFI_BLOCK_IO_PROTOCOL *This,
1114 IN UINT32 MediaId,
1115 IN EFI_LBA Lba,
1116 IN UINTN BufferSize,
1117 OUT VOID *Buffer
1118 )
1119 {
1120 EFI_BLOCK_IO_MEDIA *Media;
1121 BIOS_BLOCK_IO_DEV *BiosBlockIoDev;
1122 EFI_IA32_REGISTER_SET Regs;
1123 UINTN UpperCylinder;
1124 UINTN Temp;
1125 UINTN Cylinder;
1126 UINTN Head;
1127 UINTN Sector;
1128 UINTN NumberOfBlocks;
1129 UINTN TransferByteSize;
1130 UINTN ShortLba;
1131 UINTN CheckLba;
1132 UINTN BlockSize;
1133 BIOS_LEGACY_DRIVE *Bios;
1134 UINTN CarryFlag;
1135 UINTN Retry;
1136 EFI_BLOCK_IO_PROTOCOL *BlockIo;
1137
1138 Media = This->Media;
1139 BlockSize = Media->BlockSize;
1140
1141 ZeroMem (&Regs, sizeof (EFI_IA32_REGISTER_SET));
1142
1143 if (MediaId != Media->MediaId) {
1144 return EFI_MEDIA_CHANGED;
1145 }
1146
1147 if (Lba > Media->LastBlock) {
1148 return EFI_INVALID_PARAMETER;
1149 }
1150
1151 if ((Lba + (BufferSize / BlockSize) - 1) > Media->LastBlock) {
1152 return EFI_INVALID_PARAMETER;
1153 }
1154
1155 if (BufferSize % BlockSize != 0) {
1156 return EFI_BAD_BUFFER_SIZE;
1157 }
1158
1159 if (Buffer == NULL) {
1160 return EFI_INVALID_PARAMETER;
1161 }
1162
1163 if (BufferSize == 0) {
1164 return EFI_SUCCESS;
1165 }
1166
1167 BiosBlockIoDev = BIOS_BLOCK_IO_FROM_THIS (This);
1168 ShortLba = (UINTN) Lba;
1169
1170 while (BufferSize != 0) {
1171 //
1172 // Compute I/O location in Sector, Head, Cylinder format
1173 //
1174 Sector = (ShortLba % BiosBlockIoDev->Bios.MaxSector) + 1;
1175 Temp = ShortLba / BiosBlockIoDev->Bios.MaxSector;
1176 Head = Temp % (BiosBlockIoDev->Bios.MaxHead + 1);
1177 Cylinder = Temp / (BiosBlockIoDev->Bios.MaxHead + 1);
1178
1179 //
1180 // Limit transfer to this Head & Cylinder
1181 //
1182 NumberOfBlocks = BufferSize / BlockSize;
1183 Temp = BiosBlockIoDev->Bios.MaxSector - Sector + 1;
1184 NumberOfBlocks = NumberOfBlocks > Temp ? Temp : NumberOfBlocks;
1185
1186 Retry = 3;
1187 do {
1188 //
1189 // Perform the IO
1190 //
1191 Regs.H.AH = 2;
1192 Regs.H.AL = (UINT8) NumberOfBlocks;
1193 Regs.H.DL = BiosBlockIoDev->Bios.Number;
1194
1195 UpperCylinder = (Cylinder & 0x0f00) >> 2;
1196
1197 CheckLba = Cylinder * (BiosBlockIoDev->Bios.MaxHead + 1) + Head;
1198 CheckLba = CheckLba * BiosBlockIoDev->Bios.MaxSector + Sector - 1;
1199
1200 DEBUG (
1201 (DEBUG_BLKIO,
1202 "RLD: LBA %x (%x), Sector %x (%x), Head %x (%x), Cyl %x, UCyl %x\n",
1203 ShortLba,
1204 CheckLba,
1205 Sector,
1206 BiosBlockIoDev->Bios.MaxSector,
1207 Head,
1208 BiosBlockIoDev->Bios.MaxHead,
1209 Cylinder,
1210 UpperCylinder)
1211 );
1212 ASSERT (CheckLba == ShortLba);
1213
1214 Regs.H.CL = (UINT8) ((Sector & 0x3f) + (UpperCylinder & 0xff));
1215 Regs.H.DH = (UINT8) (Head & 0x3f);
1216 Regs.H.CH = (UINT8) (Cylinder & 0xff);
1217
1218 Regs.X.BX = EFI_OFFSET (mEdd11Buffer);
1219 Regs.X.ES = EFI_SEGMENT (mEdd11Buffer);
1220
1221 DEBUG (
1222 (DEBUG_BLKIO,
1223 "INT 13h: AX:(02%02x) DX:(%02x%02x) CX:(%02x%02x) BX:(%04x) ES:(%04x)\n",
1224 Regs.H.AL,
1225 (UINT8) (Head & 0x3f),
1226 Regs.H.DL,
1227 (UINT8) (Cylinder & 0xff),
1228 (UINT8) ((Sector & 0x3f) + (UpperCylinder & 0xff)),
1229 EFI_OFFSET (mEdd11Buffer),
1230 EFI_SEGMENT (mEdd11Buffer))
1231 );
1232
1233 CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
1234 DEBUG (
1235 (
1236 DEBUG_BLKIO, "BiosReadLegacyDrive: INT 13 02 DL=%02x : CF=%d AH=%02x\n", BiosBlockIoDev->Bios.Number,
1237 CarryFlag, Regs.H.AH
1238 )
1239 );
1240 Retry--;
1241 } while (CarryFlag != 0 && Retry != 0 && Regs.H.AH != BIOS_DISK_CHANGED);
1242
1243 Media->MediaPresent = TRUE;
1244 if (CarryFlag != 0) {
1245 //
1246 // Return Error Status
1247 //
1248 BiosBlockIoDev->Bios.ErrorCode = Regs.H.AH;
1249 if (BiosBlockIoDev->Bios.ErrorCode == BIOS_DISK_CHANGED) {
1250 Media->MediaId++;
1251 Bios = &BiosBlockIoDev->Bios;
1252 if (Int13GetDeviceParameters (BiosBlockIoDev, Bios) != 0) {
1253 //
1254 // If the size of the media changed we need to reset the disk geometry
1255 //
1256 if (Int13Extensions (BiosBlockIoDev, Bios) != 0) {
1257 Media->LastBlock = (EFI_LBA) Bios->Parameters.PhysicalSectors - 1;
1258 Media->BlockSize = (UINT32) Bios->Parameters.BytesPerSector;
1259 } else {
1260 //
1261 // Legacy Interfaces
1262 //
1263 Media->LastBlock = (Bios->MaxHead + 1) * Bios->MaxSector * (Bios->MaxCylinder + 1) - 1;
1264 Media->BlockSize = 512;
1265 }
1266
1267 Media->ReadOnly = FALSE;
1268 gBS->HandleProtocol (BiosBlockIoDev->Handle, &gEfiBlockIoProtocolGuid, (VOID **) &BlockIo);
1269 gBS->ReinstallProtocolInterface (BiosBlockIoDev->Handle, &gEfiBlockIoProtocolGuid, BlockIo, BlockIo);
1270 return EFI_MEDIA_CHANGED;
1271 }
1272 }
1273
1274 if (Media->RemovableMedia) {
1275 Media->MediaPresent = FALSE;
1276 }
1277
1278 return EFI_DEVICE_ERROR;
1279 }
1280
1281 TransferByteSize = NumberOfBlocks * BlockSize;
1282 CopyMem (Buffer, mEdd11Buffer, TransferByteSize);
1283
1284 ShortLba = ShortLba + NumberOfBlocks;
1285 BufferSize = BufferSize - TransferByteSize;
1286 Buffer = (VOID *) ((UINT8 *) Buffer + TransferByteSize);
1287 }
1288
1289 return EFI_SUCCESS;
1290 }
1291
1292 /**
1293 Write BufferSize bytes from Lba into Buffer.
1294
1295 @param This Indicates a pointer to the calling context.
1296 @param MediaId The media ID that the write request is for.
1297 @param Lba The starting logical block address to be written. The caller is
1298 responsible for writing to only legitimate locations.
1299 @param BufferSize Size of Buffer, must be a multiple of device block size.
1300 @param Buffer A pointer to the source buffer for the data.
1301
1302 @retval EFI_SUCCESS The data was written correctly to the device.
1303 @retval EFI_WRITE_PROTECTED The device can not be written to.
1304 @retval EFI_DEVICE_ERROR The device reported an error while performing the write.
1305 @retval EFI_NO_MEDIA There is no media in the device.
1306 @retval EFI_MEDIA_CHNAGED The MediaId does not matched the current device.
1307 @retval EFI_BAD_BUFFER_SIZE The Buffer was not a multiple of the block size of the device.
1308 @retval EFI_INVALID_PARAMETER The write request contains LBAs that are not valid,
1309 or the buffer is not on proper alignment.
1310
1311 **/
1312 EFI_STATUS
1313 EFIAPI
1314 BiosWriteLegacyDrive (
1315 IN EFI_BLOCK_IO_PROTOCOL *This,
1316 IN UINT32 MediaId,
1317 IN EFI_LBA Lba,
1318 IN UINTN BufferSize,
1319 OUT VOID *Buffer
1320 )
1321 {
1322 EFI_BLOCK_IO_MEDIA *Media;
1323 BIOS_BLOCK_IO_DEV *BiosBlockIoDev;
1324 EFI_IA32_REGISTER_SET Regs;
1325 UINTN UpperCylinder;
1326 UINTN Temp;
1327 UINTN Cylinder;
1328 UINTN Head;
1329 UINTN Sector;
1330 UINTN NumberOfBlocks;
1331 UINTN TransferByteSize;
1332 UINTN ShortLba;
1333 UINTN CheckLba;
1334 UINTN BlockSize;
1335 BIOS_LEGACY_DRIVE *Bios;
1336 UINTN CarryFlag;
1337 UINTN Retry;
1338 EFI_BLOCK_IO_PROTOCOL *BlockIo;
1339
1340 Media = This->Media;
1341 BlockSize = Media->BlockSize;
1342
1343 ZeroMem (&Regs, sizeof (EFI_IA32_REGISTER_SET));
1344
1345 if (MediaId != Media->MediaId) {
1346 return EFI_MEDIA_CHANGED;
1347 }
1348
1349 if (Lba > Media->LastBlock) {
1350 return EFI_INVALID_PARAMETER;
1351 }
1352
1353 if ((Lba + (BufferSize / BlockSize) - 1) > Media->LastBlock) {
1354 return EFI_INVALID_PARAMETER;
1355 }
1356
1357 if (BufferSize % BlockSize != 0) {
1358 return EFI_BAD_BUFFER_SIZE;
1359 }
1360
1361 if (Buffer == NULL) {
1362 return EFI_INVALID_PARAMETER;
1363 }
1364
1365 if (BufferSize == 0) {
1366 return EFI_SUCCESS;
1367 }
1368
1369 BiosBlockIoDev = BIOS_BLOCK_IO_FROM_THIS (This);
1370 ShortLba = (UINTN) Lba;
1371
1372 while (BufferSize != 0) {
1373 //
1374 // Compute I/O location in Sector, Head, Cylinder format
1375 //
1376 Sector = (ShortLba % BiosBlockIoDev->Bios.MaxSector) + 1;
1377 Temp = ShortLba / BiosBlockIoDev->Bios.MaxSector;
1378 Head = Temp % (BiosBlockIoDev->Bios.MaxHead + 1);
1379 Cylinder = Temp / (BiosBlockIoDev->Bios.MaxHead + 1);
1380
1381 //
1382 // Limit transfer to this Head & Cylinder
1383 //
1384 NumberOfBlocks = BufferSize / BlockSize;
1385 Temp = BiosBlockIoDev->Bios.MaxSector - Sector + 1;
1386 NumberOfBlocks = NumberOfBlocks > Temp ? Temp : NumberOfBlocks;
1387
1388 Retry = 3;
1389 do {
1390 //
1391 // Perform the IO
1392 //
1393 Regs.H.AH = 3;
1394 Regs.H.AL = (UINT8) NumberOfBlocks;
1395 Regs.H.DL = BiosBlockIoDev->Bios.Number;
1396
1397 UpperCylinder = (Cylinder & 0x0f00) >> 2;
1398
1399 CheckLba = Cylinder * (BiosBlockIoDev->Bios.MaxHead + 1) + Head;
1400 CheckLba = CheckLba * BiosBlockIoDev->Bios.MaxSector + Sector - 1;
1401
1402 DEBUG (
1403 (DEBUG_BLKIO,
1404 "RLD: LBA %x (%x), Sector %x (%x), Head %x (%x), Cyl %x, UCyl %x\n",
1405 ShortLba,
1406 CheckLba,
1407 Sector,
1408 BiosBlockIoDev->Bios.MaxSector,
1409 Head,
1410 BiosBlockIoDev->Bios.MaxHead,
1411 Cylinder,
1412 UpperCylinder)
1413 );
1414 ASSERT (CheckLba == ShortLba);
1415
1416 Regs.H.CL = (UINT8) ((Sector & 0x3f) + (UpperCylinder & 0xff));
1417 Regs.H.DH = (UINT8) (Head & 0x3f);
1418 Regs.H.CH = (UINT8) (Cylinder & 0xff);
1419
1420 Regs.X.BX = EFI_OFFSET (mEdd11Buffer);
1421 Regs.X.ES = EFI_SEGMENT (mEdd11Buffer);
1422
1423 TransferByteSize = NumberOfBlocks * BlockSize;
1424 CopyMem (mEdd11Buffer, Buffer, TransferByteSize);
1425
1426 DEBUG (
1427 (DEBUG_BLKIO,
1428 "INT 13h: AX:(03%02x) DX:(%02x%02x) CX:(%02x%02x) BX:(%04x) ES:(%04x)\n",
1429 Regs.H.AL,
1430 (UINT8) (Head & 0x3f),
1431 Regs.H.DL,
1432 (UINT8) (Cylinder & 0xff),
1433 (UINT8) ((Sector & 0x3f) + (UpperCylinder & 0xff)),
1434 EFI_OFFSET (mEdd11Buffer),
1435 EFI_SEGMENT (mEdd11Buffer))
1436 );
1437
1438 CarryFlag = BiosBlockIoDev->LegacyBios->Int86 (BiosBlockIoDev->LegacyBios, 0x13, &Regs);
1439 DEBUG (
1440 (
1441 DEBUG_BLKIO, "BiosWriteLegacyDrive: INT 13 03 DL=%02x : CF=%d AH=%02x\n", BiosBlockIoDev->Bios.Number,
1442 CarryFlag, Regs.H.AH
1443 )
1444 );
1445 Retry--;
1446 } while (CarryFlag != 0 && Retry != 0 && Regs.H.AH != BIOS_DISK_CHANGED);
1447
1448 Media->MediaPresent = TRUE;
1449 if (CarryFlag != 0) {
1450 //
1451 // Return Error Status
1452 //
1453 BiosBlockIoDev->Bios.ErrorCode = Regs.H.AH;
1454 if (BiosBlockIoDev->Bios.ErrorCode == BIOS_DISK_CHANGED) {
1455 Media->MediaId++;
1456 Bios = &BiosBlockIoDev->Bios;
1457 if (Int13GetDeviceParameters (BiosBlockIoDev, Bios) != 0) {
1458 if (Int13Extensions (BiosBlockIoDev, Bios) != 0) {
1459 Media->LastBlock = (EFI_LBA) Bios->Parameters.PhysicalSectors - 1;
1460 Media->BlockSize = (UINT32) Bios->Parameters.BytesPerSector;
1461 } else {
1462 //
1463 // Legacy Interfaces
1464 //
1465 Media->LastBlock = (Bios->MaxHead + 1) * Bios->MaxSector * (Bios->MaxCylinder + 1) - 1;
1466 Media->BlockSize = 512;
1467 }
1468 //
1469 // If the size of the media changed we need to reset the disk geometry
1470 //
1471 Media->ReadOnly = FALSE;
1472 gBS->HandleProtocol (BiosBlockIoDev->Handle, &gEfiBlockIoProtocolGuid, (VOID **) &BlockIo);
1473 gBS->ReinstallProtocolInterface (BiosBlockIoDev->Handle, &gEfiBlockIoProtocolGuid, BlockIo, BlockIo);
1474 return EFI_MEDIA_CHANGED;
1475 }
1476 } else if (BiosBlockIoDev->Bios.ErrorCode == BIOS_WRITE_PROTECTED) {
1477 Media->ReadOnly = TRUE;
1478 return EFI_WRITE_PROTECTED;
1479 }
1480
1481 if (Media->RemovableMedia) {
1482 Media->MediaPresent = FALSE;
1483 }
1484
1485 return EFI_DEVICE_ERROR;
1486 }
1487
1488 Media->ReadOnly = FALSE;
1489 ShortLba = ShortLba + NumberOfBlocks;
1490 BufferSize = BufferSize - TransferByteSize;
1491 Buffer = (VOID *) ((UINT8 *) Buffer + TransferByteSize);
1492 }
1493
1494 return EFI_SUCCESS;
1495 }
EFI Development Kit II mirror for PVE