| /** @file | |
| Copyright (c) 2011 - 2020, Arm Limited. All rights reserved.<BR> | |
| SPDX-License-Identifier: BSD-2-Clause-Patent | |
| **/ | |
| #include <PiDxe.h> | |
| #include <Library/BaseMemoryLib.h> | |
| #include <Library/DevicePathLib.h> | |
| #include <Library/UefiBootServicesTableLib.h> | |
| #include <Library/UefiRuntimeServicesTableLib.h> | |
| #include <Library/MemoryAllocationLib.h> | |
| #include <Guid/GlobalVariable.h> | |
| #include "LcdGraphicsOutputDxe.h" | |
| extern BOOLEAN mDisplayInitialized; | |
| // | |
| // Function Definitions | |
| // | |
| STATIC | |
| EFI_STATUS | |
| VideoCopyNoHorizontalOverlap ( | |
| IN UINTN BitsPerPixel, | |
| IN volatile VOID *FrameBufferBase, | |
| IN UINT32 HorizontalResolution, | |
| IN UINTN SourceX, | |
| IN UINTN SourceY, | |
| IN UINTN DestinationX, | |
| IN UINTN DestinationY, | |
| IN UINTN Width, | |
| IN UINTN Height | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| UINTN SourceLine; | |
| UINTN DestinationLine; | |
| UINTN WidthInBytes; | |
| UINTN LineCount; | |
| INTN Step; | |
| VOID *SourceAddr; | |
| VOID *DestinationAddr; | |
| Status = EFI_SUCCESS; | |
| if ( DestinationY <= SourceY ) { | |
| // scrolling up (or horizontally but without overlap) | |
| SourceLine = SourceY; | |
| DestinationLine = DestinationY; | |
| Step = 1; | |
| } else { | |
| // scrolling down | |
| SourceLine = SourceY + Height; | |
| DestinationLine = DestinationY + Height; | |
| Step = -1; | |
| } | |
| switch (BitsPerPixel) { | |
| case LcdBitsPerPixel_24: | |
| WidthInBytes = Width * 4; | |
| for ( LineCount = 0; LineCount < Height; LineCount++ ) { | |
| // Update the start addresses of source & destination using 32bit pointer arithmetic | |
| SourceAddr = (VOID *)((UINT32 *)FrameBufferBase + SourceLine * HorizontalResolution + SourceX); | |
| DestinationAddr = (VOID *)((UINT32 *)FrameBufferBase + DestinationLine * HorizontalResolution + DestinationX); | |
| // Copy the entire line Y from video ram to the temp buffer | |
| CopyMem (DestinationAddr, SourceAddr, WidthInBytes); | |
| // Update the line numbers | |
| SourceLine += Step; | |
| DestinationLine += Step; | |
| } | |
| break; | |
| case LcdBitsPerPixel_16_555: | |
| case LcdBitsPerPixel_16_565: | |
| case LcdBitsPerPixel_12_444: | |
| WidthInBytes = Width * 2; | |
| for ( LineCount = 0; LineCount < Height; LineCount++ ) { | |
| // Update the start addresses of source & destination using 16bit pointer arithmetic | |
| SourceAddr = (VOID *)((UINT16 *)FrameBufferBase + SourceLine * HorizontalResolution + SourceX); | |
| DestinationAddr = (VOID *)((UINT16 *)FrameBufferBase + DestinationLine * HorizontalResolution + DestinationX); | |
| // Copy the entire line Y from video ram to the temp buffer | |
| CopyMem (DestinationAddr, SourceAddr, WidthInBytes); | |
| // Update the line numbers | |
| SourceLine += Step; | |
| DestinationLine += Step; | |
| } | |
| break; | |
| case LcdBitsPerPixel_8: | |
| case LcdBitsPerPixel_4: | |
| case LcdBitsPerPixel_2: | |
| case LcdBitsPerPixel_1: | |
| default: | |
| // Can't handle this case | |
| DEBUG ((DEBUG_ERROR, "ArmVeGraphics_Blt: EfiBltVideoToVideo: INVALID Number of Bits Per Pixel: %d\n", BitsPerPixel)); | |
| Status = EFI_INVALID_PARAMETER; | |
| goto EXIT; | |
| // break; | |
| } | |
| EXIT: | |
| return Status; | |
| } | |
| STATIC | |
| EFI_STATUS | |
| VideoCopyHorizontalOverlap ( | |
| IN UINTN BitsPerPixel, | |
| IN volatile VOID *FrameBufferBase, | |
| UINT32 HorizontalResolution, | |
| IN UINTN SourceX, | |
| IN UINTN SourceY, | |
| IN UINTN DestinationX, | |
| IN UINTN DestinationY, | |
| IN UINTN Width, | |
| IN UINTN Height | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| UINT32 *PixelBuffer32bit; | |
| UINT32 *SourcePixel32bit; | |
| UINT32 *DestinationPixel32bit; | |
| UINT16 *PixelBuffer16bit; | |
| UINT16 *SourcePixel16bit; | |
| UINT16 *DestinationPixel16bit; | |
| UINT32 SourcePixelY; | |
| UINT32 DestinationPixelY; | |
| UINTN SizeIn32Bits; | |
| UINTN SizeIn16Bits; | |
| Status = EFI_SUCCESS; | |
| switch (BitsPerPixel) { | |
| case LcdBitsPerPixel_24: | |
| // Allocate a temporary buffer | |
| PixelBuffer32bit = (UINT32 *)AllocatePool ((Height * Width) * sizeof (UINT32)); | |
| if (PixelBuffer32bit == NULL) { | |
| Status = EFI_OUT_OF_RESOURCES; | |
| goto EXIT; | |
| } | |
| SizeIn32Bits = Width * 4; | |
| // Copy from the video ram (source region) to a temp buffer | |
| for (SourcePixelY = SourceY, DestinationPixel32bit = PixelBuffer32bit; | |
| SourcePixelY < SourceY + Height; | |
| SourcePixelY++, DestinationPixel32bit += Width) | |
| { | |
| // Update the start address of line Y (source) | |
| SourcePixel32bit = (UINT32 *)FrameBufferBase + SourcePixelY * HorizontalResolution + SourceX; | |
| // Copy the entire line Y from video ram to the temp buffer | |
| CopyMem ((VOID *)DestinationPixel32bit, (CONST VOID *)SourcePixel32bit, SizeIn32Bits); | |
| } | |
| // Copy from the temp buffer to the video ram (destination region) | |
| for (DestinationPixelY = DestinationY, SourcePixel32bit = PixelBuffer32bit; | |
| DestinationPixelY < DestinationY + Height; | |
| DestinationPixelY++, SourcePixel32bit += Width) | |
| { | |
| // Update the start address of line Y (target) | |
| DestinationPixel32bit = (UINT32 *)FrameBufferBase + DestinationPixelY * HorizontalResolution + DestinationX; | |
| // Copy the entire line Y from the temp buffer to video ram | |
| CopyMem ((VOID *)DestinationPixel32bit, (CONST VOID *)SourcePixel32bit, SizeIn32Bits); | |
| } | |
| // Free up the allocated memory | |
| FreePool ((VOID *)PixelBuffer32bit); | |
| break; | |
| case LcdBitsPerPixel_16_555: | |
| case LcdBitsPerPixel_16_565: | |
| case LcdBitsPerPixel_12_444: | |
| // Allocate a temporary buffer | |
| PixelBuffer16bit = (UINT16 *)AllocatePool ((Height * Width) * sizeof (UINT16)); | |
| if (PixelBuffer16bit == NULL) { | |
| Status = EFI_OUT_OF_RESOURCES; | |
| goto EXIT; | |
| } | |
| // Access each pixel inside the source area of the Video Memory and copy it to the temp buffer | |
| SizeIn16Bits = Width * 2; | |
| for (SourcePixelY = SourceY, DestinationPixel16bit = PixelBuffer16bit; | |
| SourcePixelY < SourceY + Height; | |
| SourcePixelY++, DestinationPixel16bit += Width) | |
| { | |
| // Calculate the source address: | |
| SourcePixel16bit = (UINT16 *)FrameBufferBase + SourcePixelY * HorizontalResolution + SourceX; | |
| // Copy the entire line Y from Video to the temp buffer | |
| CopyMem ((VOID *)DestinationPixel16bit, (CONST VOID *)SourcePixel16bit, SizeIn16Bits); | |
| } | |
| // Copy from the temp buffer into the destination area of the Video Memory | |
| for (DestinationPixelY = DestinationY, SourcePixel16bit = PixelBuffer16bit; | |
| DestinationPixelY < DestinationY + Height; | |
| DestinationPixelY++, SourcePixel16bit += Width) | |
| { | |
| // Calculate the target address: | |
| DestinationPixel16bit = (UINT16 *)FrameBufferBase + (DestinationPixelY * HorizontalResolution + DestinationX); | |
| // Copy the entire line Y from the temp buffer to Video | |
| CopyMem ((VOID *)DestinationPixel16bit, (CONST VOID *)SourcePixel16bit, SizeIn16Bits); | |
| } | |
| // Free the allocated memory | |
| FreePool ((VOID *)PixelBuffer16bit); | |
| break; | |
| case LcdBitsPerPixel_8: | |
| case LcdBitsPerPixel_4: | |
| case LcdBitsPerPixel_2: | |
| case LcdBitsPerPixel_1: | |
| default: | |
| // Can't handle this case | |
| DEBUG ((DEBUG_ERROR, "ArmVeGraphics_Blt: EfiBltVideoToVideo: INVALID Number of Bits Per Pixel: %d\n", BitsPerPixel)); | |
| Status = EFI_INVALID_PARAMETER; | |
| goto EXIT; | |
| // break; | |
| } | |
| EXIT: | |
| return Status; | |
| } | |
| STATIC | |
| EFI_STATUS | |
| BltVideoFill ( | |
| IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This, | |
| IN OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL *EfiSourcePixel OPTIONAL, | |
| IN UINTN SourceX, | |
| IN UINTN SourceY, | |
| IN UINTN DestinationX, | |
| IN UINTN DestinationY, | |
| IN UINTN Width, | |
| IN UINTN Height, | |
| IN UINTN Delta OPTIONAL // Number of BYTES in a row of the BltBuffer | |
| ) | |
| { | |
| EFI_PIXEL_BITMASK *PixelInformation; | |
| EFI_STATUS Status; | |
| UINT32 HorizontalResolution; | |
| LCD_BPP BitsPerPixel; | |
| VOID *FrameBufferBase; | |
| VOID *DestinationAddr; | |
| UINT16 *DestinationPixel16bit; | |
| UINT16 Pixel16bit; | |
| UINT32 DestinationPixelX; | |
| UINT32 DestinationLine; | |
| UINTN WidthInBytes; | |
| Status = EFI_SUCCESS; | |
| PixelInformation = &This->Mode->Info->PixelInformation; | |
| FrameBufferBase = (UINTN *)((UINTN)(This->Mode->FrameBufferBase)); | |
| HorizontalResolution = This->Mode->Info->HorizontalResolution; | |
| LcdPlatformGetBpp (This->Mode->Mode, &BitsPerPixel); | |
| switch (BitsPerPixel) { | |
| case LcdBitsPerPixel_24: | |
| WidthInBytes = Width * 4; | |
| // Copy the SourcePixel into every pixel inside the target rectangle | |
| for (DestinationLine = DestinationY; | |
| DestinationLine < DestinationY + Height; | |
| DestinationLine++) | |
| { | |
| // Calculate the target address using 32bit pointer arithmetic: | |
| DestinationAddr = (VOID *)((UINT32 *)FrameBufferBase + DestinationLine * HorizontalResolution + DestinationX); | |
| // Fill the entire line | |
| SetMem32 (DestinationAddr, WidthInBytes, *((UINT32 *)EfiSourcePixel)); | |
| } | |
| break; | |
| case LcdBitsPerPixel_16_555: | |
| // Convert the EFI pixel at the start of the BltBuffer(0,0) into a video display pixel | |
| Pixel16bit = (UINT16)( | |
| ((EfiSourcePixel->Red << 7) & PixelInformation->RedMask) | |
| | ((EfiSourcePixel->Green << 2) & PixelInformation->GreenMask) | |
| | ((EfiSourcePixel->Blue >> 3) & PixelInformation->BlueMask) | |
| // | ( 0 & PixelInformation->ReservedMask ) | |
| ); | |
| // Copy the SourcePixel into every pixel inside the target rectangle | |
| for (DestinationLine = DestinationY; | |
| DestinationLine < DestinationY + Height; | |
| DestinationLine++) | |
| { | |
| for (DestinationPixelX = DestinationX; | |
| DestinationPixelX < DestinationX + Width; | |
| DestinationPixelX++) | |
| { | |
| // Calculate the target address: | |
| DestinationPixel16bit = (UINT16 *)FrameBufferBase + DestinationLine * HorizontalResolution + DestinationPixelX; | |
| // Copy the pixel into the new target | |
| *DestinationPixel16bit = Pixel16bit; | |
| } | |
| } | |
| break; | |
| case LcdBitsPerPixel_16_565: | |
| // Convert the EFI pixel at the start of the BltBuffer(0,0) into a video display pixel | |
| Pixel16bit = (UINT16)( | |
| ((EfiSourcePixel->Red << 8) & PixelInformation->RedMask) | |
| | ((EfiSourcePixel->Green << 3) & PixelInformation->GreenMask) | |
| | ((EfiSourcePixel->Blue >> 3) & PixelInformation->BlueMask) | |
| ); | |
| // Copy the SourcePixel into every pixel inside the target rectangle | |
| for (DestinationLine = DestinationY; | |
| DestinationLine < DestinationY + Height; | |
| DestinationLine++) | |
| { | |
| for (DestinationPixelX = DestinationX; | |
| DestinationPixelX < DestinationX + Width; | |
| DestinationPixelX++) | |
| { | |
| // Calculate the target address: | |
| DestinationPixel16bit = (UINT16 *)FrameBufferBase + DestinationLine * HorizontalResolution + DestinationPixelX; | |
| // Copy the pixel into the new target | |
| *DestinationPixel16bit = Pixel16bit; | |
| } | |
| } | |
| break; | |
| case LcdBitsPerPixel_12_444: | |
| // Convert the EFI pixel at the start of the BltBuffer(0,0) into a video display pixel | |
| Pixel16bit = (UINT16)( | |
| ((EfiSourcePixel->Red >> 4) & PixelInformation->RedMask) | |
| | ((EfiSourcePixel->Green) & PixelInformation->GreenMask) | |
| | ((EfiSourcePixel->Blue << 4) & PixelInformation->BlueMask) | |
| ); | |
| // Copy the SourcePixel into every pixel inside the target rectangle | |
| for (DestinationLine = DestinationY; | |
| DestinationLine < DestinationY + Height; | |
| DestinationLine++) | |
| { | |
| for (DestinationPixelX = DestinationX; | |
| DestinationPixelX < DestinationX + Width; | |
| DestinationPixelX++) | |
| { | |
| // Calculate the target address: | |
| DestinationPixel16bit = (UINT16 *)FrameBufferBase + DestinationLine * HorizontalResolution + DestinationPixelX; | |
| // Copy the pixel into the new target | |
| *DestinationPixel16bit = Pixel16bit; | |
| } | |
| } | |
| break; | |
| case LcdBitsPerPixel_8: | |
| case LcdBitsPerPixel_4: | |
| case LcdBitsPerPixel_2: | |
| case LcdBitsPerPixel_1: | |
| default: | |
| // Can't handle this case | |
| DEBUG ((DEBUG_ERROR, "LcdGraphicsBlt: EfiBltVideoFill: INVALID Number of Bits Per Pixel: %d\n", BitsPerPixel)); | |
| Status = EFI_INVALID_PARAMETER; | |
| break; | |
| } | |
| return Status; | |
| } | |
| STATIC | |
| EFI_STATUS | |
| BltVideoToBltBuffer ( | |
| IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This, | |
| IN OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer OPTIONAL, | |
| IN UINTN SourceX, | |
| IN UINTN SourceY, | |
| IN UINTN DestinationX, | |
| IN UINTN DestinationY, | |
| IN UINTN Width, | |
| IN UINTN Height, | |
| IN UINTN Delta OPTIONAL // Number of BYTES in a row of the BltBuffer | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| UINT32 HorizontalResolution; | |
| LCD_BPP BitsPerPixel; | |
| EFI_PIXEL_BITMASK *PixelInformation; | |
| EFI_GRAPHICS_OUTPUT_BLT_PIXEL *EfiDestinationPixel; | |
| VOID *FrameBufferBase; | |
| VOID *SourceAddr; | |
| VOID *DestinationAddr; | |
| UINT16 *SourcePixel16bit; | |
| UINT16 Pixel16bit; | |
| UINT32 SourcePixelX; | |
| UINT32 SourceLine; | |
| UINT32 DestinationPixelX; | |
| UINT32 DestinationLine; | |
| UINT32 BltBufferHorizontalResolution; | |
| UINTN WidthInBytes; | |
| Status = EFI_SUCCESS; | |
| PixelInformation = &This->Mode->Info->PixelInformation; | |
| HorizontalResolution = This->Mode->Info->HorizontalResolution; | |
| FrameBufferBase = (UINTN *)((UINTN)(This->Mode->FrameBufferBase)); | |
| if ((Delta != 0) && (Delta != Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL))) { | |
| // Delta is not zero and it is different from the width. | |
| // Divide it by the size of a pixel to find out the buffer's horizontal resolution. | |
| BltBufferHorizontalResolution = (UINT32)(Delta / sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)); | |
| } else { | |
| BltBufferHorizontalResolution = Width; | |
| } | |
| LcdPlatformGetBpp (This->Mode->Mode, &BitsPerPixel); | |
| switch (BitsPerPixel) { | |
| case LcdBitsPerPixel_24: | |
| WidthInBytes = Width * 4; | |
| // Access each line inside the Video Memory | |
| for (SourceLine = SourceY, DestinationLine = DestinationY; | |
| SourceLine < SourceY + Height; | |
| SourceLine++, DestinationLine++) | |
| { | |
| // Calculate the source and target addresses using 32bit pointer arithmetic: | |
| SourceAddr = (VOID *)((UINT32 *)FrameBufferBase + SourceLine * HorizontalResolution + SourceX); | |
| DestinationAddr = (VOID *)((UINT32 *)BltBuffer + DestinationLine * BltBufferHorizontalResolution + DestinationX); | |
| // Copy the entire line | |
| CopyMem (DestinationAddr, SourceAddr, WidthInBytes); | |
| } | |
| break; | |
| case LcdBitsPerPixel_16_555: | |
| // Access each pixel inside the Video Memory | |
| for (SourceLine = SourceY, DestinationLine = DestinationY; | |
| SourceLine < SourceY + Height; | |
| SourceLine++, DestinationLine++) | |
| { | |
| for (SourcePixelX = SourceX, DestinationPixelX = DestinationX; | |
| SourcePixelX < SourceX + Width; | |
| SourcePixelX++, DestinationPixelX++) | |
| { | |
| // Calculate the source and target addresses: | |
| SourcePixel16bit = (UINT16 *)FrameBufferBase + SourceLine * HorizontalResolution + SourcePixelX; | |
| EfiDestinationPixel = BltBuffer + DestinationLine * BltBufferHorizontalResolution + DestinationPixelX; | |
| // Snapshot the pixel from the video buffer once, to speed up the operation. | |
| // If we were dereferencing the pointer, as it is volatile, we would perform 3 memory read operations. | |
| Pixel16bit = *SourcePixel16bit; | |
| // Copy the pixel into the new target | |
| EfiDestinationPixel->Red = (UINT8)((Pixel16bit & PixelInformation->RedMask) >> 7); | |
| EfiDestinationPixel->Green = (UINT8)((Pixel16bit & PixelInformation->GreenMask) >> 2); | |
| EfiDestinationPixel->Blue = (UINT8)((Pixel16bit & PixelInformation->BlueMask) << 3); | |
| // EfiDestinationPixel->Reserved = (UINT8) 0; | |
| } | |
| } | |
| break; | |
| case LcdBitsPerPixel_16_565: | |
| // Access each pixel inside the Video Memory | |
| for (SourceLine = SourceY, DestinationLine = DestinationY; | |
| SourceLine < SourceY + Height; | |
| SourceLine++, DestinationLine++) | |
| { | |
| for (SourcePixelX = SourceX, DestinationPixelX = DestinationX; | |
| SourcePixelX < SourceX + Width; | |
| SourcePixelX++, DestinationPixelX++) | |
| { | |
| // Calculate the source and target addresses: | |
| SourcePixel16bit = (UINT16 *)FrameBufferBase + SourceLine * HorizontalResolution + SourcePixelX; | |
| EfiDestinationPixel = BltBuffer + DestinationLine * BltBufferHorizontalResolution + DestinationPixelX; | |
| // Snapshot the pixel from the video buffer once, to speed up the operation. | |
| // If we were dereferencing the pointer, as it is volatile, we would perform 3 memory read operations. | |
| Pixel16bit = *SourcePixel16bit; | |
| // Copy the pixel into the new target | |
| // There is no info for the Reserved byte, so we set it to zero | |
| EfiDestinationPixel->Red = (UINT8)((Pixel16bit & PixelInformation->RedMask) >> 8); | |
| EfiDestinationPixel->Green = (UINT8)((Pixel16bit & PixelInformation->GreenMask) >> 3); | |
| EfiDestinationPixel->Blue = (UINT8)((Pixel16bit & PixelInformation->BlueMask) << 3); | |
| // EfiDestinationPixel->Reserved = (UINT8) 0; | |
| } | |
| } | |
| break; | |
| case LcdBitsPerPixel_12_444: | |
| // Access each pixel inside the Video Memory | |
| for (SourceLine = SourceY, DestinationLine = DestinationY; | |
| SourceLine < SourceY + Height; | |
| SourceLine++, DestinationLine++) | |
| { | |
| for (SourcePixelX = SourceX, DestinationPixelX = DestinationX; | |
| SourcePixelX < SourceX + Width; | |
| SourcePixelX++, DestinationPixelX++) | |
| { | |
| // Calculate the source and target addresses: | |
| SourcePixel16bit = (UINT16 *)FrameBufferBase + SourceLine * HorizontalResolution + SourcePixelX; | |
| EfiDestinationPixel = BltBuffer + DestinationLine * BltBufferHorizontalResolution + DestinationPixelX; | |
| // Snapshot the pixel from the video buffer once, to speed up the operation. | |
| // If we were dereferencing the pointer, as it is volatile, we would perform 3 memory read operations. | |
| Pixel16bit = *SourcePixel16bit; | |
| // Copy the pixel into the new target | |
| EfiDestinationPixel->Red = (UINT8)((Pixel16bit & PixelInformation->RedMask) >> 4); | |
| EfiDestinationPixel->Green = (UINT8)((Pixel16bit & PixelInformation->GreenMask)); | |
| EfiDestinationPixel->Blue = (UINT8)((Pixel16bit & PixelInformation->BlueMask) << 4); | |
| // EfiDestinationPixel->Reserved = (UINT8) 0; | |
| } | |
| } | |
| break; | |
| case LcdBitsPerPixel_8: | |
| case LcdBitsPerPixel_4: | |
| case LcdBitsPerPixel_2: | |
| case LcdBitsPerPixel_1: | |
| default: | |
| // Can't handle this case | |
| DEBUG ((DEBUG_ERROR, "LcdGraphicsBlt: EfiBltVideoToBltBuffer: INVALID Number of Bits Per Pixel: %d\n", BitsPerPixel)); | |
| Status = EFI_INVALID_PARAMETER; | |
| break; | |
| } | |
| return Status; | |
| } | |
| STATIC | |
| EFI_STATUS | |
| BltBufferToVideo ( | |
| IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This, | |
| IN OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer OPTIONAL, | |
| IN UINTN SourceX, | |
| IN UINTN SourceY, | |
| IN UINTN DestinationX, | |
| IN UINTN DestinationY, | |
| IN UINTN Width, | |
| IN UINTN Height, | |
| IN UINTN Delta OPTIONAL // Number of BYTES in a row of the BltBuffer | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| UINT32 HorizontalResolution; | |
| LCD_BPP BitsPerPixel; | |
| EFI_PIXEL_BITMASK *PixelInformation; | |
| EFI_GRAPHICS_OUTPUT_BLT_PIXEL *EfiSourcePixel; | |
| VOID *FrameBufferBase; | |
| VOID *SourceAddr; | |
| VOID *DestinationAddr; | |
| UINT16 *DestinationPixel16bit; | |
| UINT32 SourcePixelX; | |
| UINT32 SourceLine; | |
| UINT32 DestinationPixelX; | |
| UINT32 DestinationLine; | |
| UINT32 BltBufferHorizontalResolution; | |
| UINTN WidthInBytes; | |
| Status = EFI_SUCCESS; | |
| PixelInformation = &This->Mode->Info->PixelInformation; | |
| HorizontalResolution = This->Mode->Info->HorizontalResolution; | |
| FrameBufferBase = (UINTN *)((UINTN)(This->Mode->FrameBufferBase)); | |
| if ((Delta != 0) && (Delta != Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL))) { | |
| // Delta is not zero and it is different from the width. | |
| // Divide it by the size of a pixel to find out the buffer's horizontal resolution. | |
| BltBufferHorizontalResolution = (UINT32)(Delta / sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)); | |
| } else { | |
| BltBufferHorizontalResolution = Width; | |
| } | |
| LcdPlatformGetBpp (This->Mode->Mode, &BitsPerPixel); | |
| switch (BitsPerPixel) { | |
| case LcdBitsPerPixel_24: | |
| WidthInBytes = Width * 4; | |
| // Access each pixel inside the BltBuffer Memory | |
| for (SourceLine = SourceY, DestinationLine = DestinationY; | |
| SourceLine < SourceY + Height; | |
| SourceLine++, DestinationLine++) | |
| { | |
| // Calculate the source and target addresses using 32bit pointer arithmetic: | |
| SourceAddr = (VOID *)((UINT32 *)BltBuffer + SourceLine * BltBufferHorizontalResolution + SourceX); | |
| DestinationAddr = (VOID *)((UINT32 *)FrameBufferBase + DestinationLine * HorizontalResolution + DestinationX); | |
| // Copy the entire row Y | |
| CopyMem (DestinationAddr, SourceAddr, WidthInBytes); | |
| } | |
| break; | |
| case LcdBitsPerPixel_16_555: | |
| // Access each pixel inside the BltBuffer Memory | |
| for (SourceLine = SourceY, DestinationLine = DestinationY; | |
| SourceLine < SourceY + Height; | |
| SourceLine++, DestinationLine++) | |
| { | |
| for (SourcePixelX = SourceX, DestinationPixelX = DestinationX; | |
| SourcePixelX < SourceX + Width; | |
| SourcePixelX++, DestinationPixelX++) | |
| { | |
| // Calculate the source and target addresses: | |
| EfiSourcePixel = BltBuffer + SourceLine * BltBufferHorizontalResolution + SourcePixelX; | |
| DestinationPixel16bit = (UINT16 *)FrameBufferBase + DestinationLine * HorizontalResolution + DestinationPixelX; | |
| // Copy the pixel into the new target | |
| // Only the most significant bits will be copied across: | |
| // To convert from 8 bits to 5 bits per pixel we throw away the 3 least significant bits | |
| *DestinationPixel16bit = (UINT16)( | |
| ((EfiSourcePixel->Red << 7) & PixelInformation->RedMask) | |
| | ((EfiSourcePixel->Green << 2) & PixelInformation->GreenMask) | |
| | ((EfiSourcePixel->Blue >> 3) & PixelInformation->BlueMask) | |
| // | ( 0 & PixelInformation->ReservedMask ) | |
| ); | |
| } | |
| } | |
| break; | |
| case LcdBitsPerPixel_16_565: | |
| // Access each pixel inside the BltBuffer Memory | |
| for (SourceLine = SourceY, DestinationLine = DestinationY; | |
| SourceLine < SourceY + Height; | |
| SourceLine++, DestinationLine++) | |
| { | |
| for (SourcePixelX = SourceX, DestinationPixelX = DestinationX; | |
| SourcePixelX < SourceX + Width; | |
| SourcePixelX++, DestinationPixelX++) | |
| { | |
| // Calculate the source and target addresses: | |
| EfiSourcePixel = BltBuffer + SourceLine * BltBufferHorizontalResolution + SourcePixelX; | |
| DestinationPixel16bit = (UINT16 *)FrameBufferBase + DestinationLine * HorizontalResolution + DestinationPixelX; | |
| // Copy the pixel into the new target | |
| // Only the most significant bits will be copied across: | |
| // To convert from 8 bits to 5 or 6 bits per pixel we throw away the 3 or 2 least significant bits | |
| // There is no room for the Reserved byte so we ignore that completely | |
| *DestinationPixel16bit = (UINT16)( | |
| ((EfiSourcePixel->Red << 8) & PixelInformation->RedMask) | |
| | ((EfiSourcePixel->Green << 3) & PixelInformation->GreenMask) | |
| | ((EfiSourcePixel->Blue >> 3) & PixelInformation->BlueMask) | |
| ); | |
| } | |
| } | |
| break; | |
| case LcdBitsPerPixel_12_444: | |
| // Access each pixel inside the BltBuffer Memory | |
| for (SourceLine = SourceY, DestinationLine = DestinationY; | |
| SourceLine < SourceY + Height; | |
| SourceLine++, DestinationLine++) | |
| { | |
| for (SourcePixelX = SourceX, DestinationPixelX = DestinationX; | |
| SourcePixelX < SourceX + Width; | |
| SourcePixelX++, DestinationPixelX++) | |
| { | |
| // Calculate the source and target addresses: | |
| EfiSourcePixel = BltBuffer + SourceLine * BltBufferHorizontalResolution + SourcePixelX; | |
| DestinationPixel16bit = (UINT16 *)FrameBufferBase + DestinationLine * HorizontalResolution + DestinationPixelX; | |
| // Copy the pixel into the new target | |
| // Only the most significant bits will be copied across: | |
| // To convert from 8 bits to 5 bits per pixel we throw away the 3 least significant bits | |
| *DestinationPixel16bit = (UINT16)( | |
| ((EfiSourcePixel->Red << 4) & PixelInformation->RedMask) | |
| | ((EfiSourcePixel->Green) & PixelInformation->GreenMask) | |
| | ((EfiSourcePixel->Blue >> 4) & PixelInformation->BlueMask) | |
| // | ( 0 & PixelInformation->ReservedMask ) | |
| ); | |
| } | |
| } | |
| break; | |
| case LcdBitsPerPixel_8: | |
| case LcdBitsPerPixel_4: | |
| case LcdBitsPerPixel_2: | |
| case LcdBitsPerPixel_1: | |
| default: | |
| // Can't handle this case | |
| DEBUG ((DEBUG_ERROR, "LcdGraphicsBlt: EfiBltBufferToVideo: INVALID Number of Bits Per Pixel: %d\n", BitsPerPixel)); | |
| Status = EFI_INVALID_PARAMETER; | |
| break; | |
| } | |
| return Status; | |
| } | |
| STATIC | |
| EFI_STATUS | |
| BltVideoToVideo ( | |
| IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This, | |
| IN OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer OPTIONAL, | |
| IN UINTN SourceX, | |
| IN UINTN SourceY, | |
| IN UINTN DestinationX, | |
| IN UINTN DestinationY, | |
| IN UINTN Width, | |
| IN UINTN Height, | |
| IN UINTN Delta OPTIONAL // Number of BYTES in a row of the BltBuffer | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| UINT32 HorizontalResolution; | |
| LCD_BPP BitsPerPixel; | |
| VOID *FrameBufferBase; | |
| HorizontalResolution = This->Mode->Info->HorizontalResolution; | |
| FrameBufferBase = (UINTN *)((UINTN)(This->Mode->FrameBufferBase)); | |
| // | |
| // BltVideo to BltVideo: | |
| // | |
| // Source is the Video Memory, | |
| // Destination is the Video Memory | |
| LcdPlatformGetBpp (This->Mode->Mode, &BitsPerPixel); | |
| FrameBufferBase = (UINTN *)((UINTN)(This->Mode->FrameBufferBase)); | |
| // The UEFI spec currently states: | |
| // "There is no limitation on the overlapping of the source and destination rectangles" | |
| // Therefore, we must be careful to avoid overwriting the source data | |
| if ( SourceY == DestinationY ) { | |
| // Copying within the same height, e.g. horizontal shift | |
| if ( SourceX == DestinationX ) { | |
| // Nothing to do | |
| Status = EFI_SUCCESS; | |
| } else if (((SourceX > DestinationX) ? (SourceX - DestinationX) : (DestinationX - SourceX)) < Width ) { | |
| // There is overlap | |
| Status = VideoCopyHorizontalOverlap (BitsPerPixel, FrameBufferBase, HorizontalResolution, SourceX, SourceY, DestinationX, DestinationY, Width, Height); | |
| } else { | |
| // No overlap | |
| Status = VideoCopyNoHorizontalOverlap (BitsPerPixel, FrameBufferBase, HorizontalResolution, SourceX, SourceY, DestinationX, DestinationY, Width, Height); | |
| } | |
| } else { | |
| // Copying from different heights | |
| Status = VideoCopyNoHorizontalOverlap (BitsPerPixel, FrameBufferBase, HorizontalResolution, SourceX, SourceY, DestinationX, DestinationY, Width, Height); | |
| } | |
| return Status; | |
| } | |
| /*************************************** | |
| * GraphicsOutput Protocol function, mapping to | |
| * EFI_GRAPHICS_OUTPUT_PROTOCOL.Blt | |
| * | |
| * PRESUMES: 1 pixel = 4 bytes (32bits) | |
| * ***************************************/ | |
| EFI_STATUS | |
| EFIAPI | |
| LcdGraphicsBlt ( | |
| IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This, | |
| IN OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer OPTIONAL, | |
| IN EFI_GRAPHICS_OUTPUT_BLT_OPERATION BltOperation, | |
| IN UINTN SourceX, | |
| IN UINTN SourceY, | |
| IN UINTN DestinationX, | |
| IN UINTN DestinationY, | |
| IN UINTN Width, | |
| IN UINTN Height, | |
| IN UINTN Delta OPTIONAL // Number of BYTES in a row of the BltBuffer | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| UINT32 HorizontalResolution; | |
| UINT32 VerticalResolution; | |
| LCD_INSTANCE *Instance; | |
| Instance = LCD_INSTANCE_FROM_GOP_THIS (This); | |
| // Setup the hardware if not already done | |
| if (!mDisplayInitialized) { | |
| Status = InitializeDisplay (Instance); | |
| if (EFI_ERROR (Status)) { | |
| goto EXIT; | |
| } | |
| } | |
| HorizontalResolution = This->Mode->Info->HorizontalResolution; | |
| VerticalResolution = This->Mode->Info->VerticalResolution; | |
| // Check we have reasonable parameters | |
| if ((Width == 0) || (Height == 0)) { | |
| DEBUG ((DEBUG_ERROR, "LcdGraphicsBlt: ERROR - Invalid dimension: Zero size area.\n")); | |
| Status = EFI_INVALID_PARAMETER; | |
| goto EXIT; | |
| } | |
| if ((BltOperation == EfiBltVideoFill) || (BltOperation == EfiBltBufferToVideo) || (BltOperation == EfiBltVideoToBltBuffer)) { | |
| ASSERT (BltBuffer != NULL); | |
| } | |
| /*if ((DestinationX >= HorizontalResolution) || (DestinationY >= VerticalResolution)) { | |
| DEBUG((DEBUG_ERROR, "LcdGraphicsBlt: ERROR - Invalid destination.\n" )); | |
| Status = EFI_INVALID_PARAMETER; | |
| goto EXIT; | |
| }*/ | |
| // If we are reading data out of the video buffer, check that the source area is within the display limits | |
| if ((BltOperation == EfiBltVideoToBltBuffer) || (BltOperation == EfiBltVideoToVideo)) { | |
| if ((SourceY + Height > VerticalResolution) || (SourceX + Width > HorizontalResolution)) { | |
| DEBUG ((DEBUG_INFO, "LcdGraphicsBlt: ERROR - Invalid source resolution.\n")); | |
| DEBUG ((DEBUG_INFO, " - SourceY=%d + Height=%d > VerticalResolution=%d.\n", SourceY, Height, VerticalResolution)); | |
| DEBUG ((DEBUG_INFO, " - SourceX=%d + Width=%d > HorizontalResolution=%d.\n", SourceX, Width, HorizontalResolution)); | |
| Status = EFI_INVALID_PARAMETER; | |
| goto EXIT; | |
| } | |
| } | |
| // If we are writing data into the video buffer, that the destination area is within the display limits | |
| if ((BltOperation == EfiBltVideoFill) || (BltOperation == EfiBltBufferToVideo) || (BltOperation == EfiBltVideoToVideo)) { | |
| if ((DestinationY + Height > VerticalResolution) || (DestinationX + Width > HorizontalResolution)) { | |
| DEBUG ((DEBUG_INFO, "LcdGraphicsBlt: ERROR - Invalid destination resolution.\n")); | |
| DEBUG ((DEBUG_INFO, " - DestinationY=%d + Height=%d > VerticalResolution=%d.\n", DestinationY, Height, VerticalResolution)); | |
| DEBUG ((DEBUG_INFO, " - DestinationX=%d + Width=%d > HorizontalResolution=%d.\n", DestinationX, Width, HorizontalResolution)); | |
| Status = EFI_INVALID_PARAMETER; | |
| goto EXIT; | |
| } | |
| } | |
| // | |
| // Perform the Block Transfer Operation | |
| // | |
| switch (BltOperation) { | |
| case EfiBltVideoFill: | |
| Status = BltVideoFill (This, BltBuffer, SourceX, SourceY, DestinationX, DestinationY, Width, Height, Delta); | |
| break; | |
| case EfiBltVideoToBltBuffer: | |
| Status = BltVideoToBltBuffer (This, BltBuffer, SourceX, SourceY, DestinationX, DestinationY, Width, Height, Delta); | |
| break; | |
| case EfiBltBufferToVideo: | |
| Status = BltBufferToVideo (This, BltBuffer, SourceX, SourceY, DestinationX, DestinationY, Width, Height, Delta); | |
| break; | |
| case EfiBltVideoToVideo: | |
| Status = BltVideoToVideo (This, BltBuffer, SourceX, SourceY, DestinationX, DestinationY, Width, Height, Delta); | |
| break; | |
| case EfiGraphicsOutputBltOperationMax: | |
| default: | |
| DEBUG ((DEBUG_ERROR, "LcdGraphicsBlt: Invalid Operation\n")); | |
| Status = EFI_INVALID_PARAMETER; | |
| break; | |
| } | |
| EXIT: | |
| return Status; | |
| } |