def PrintXY(self, uString, x=-1, y=-1):
if x != -1:
self.PointerX = x
if y != -1:
self.PointerY = y
self.HiiFont.StringToImage (
EfiPy.byref (self.HiiFont),
ft.EFI_HII_IGNORE_IF_NO_GLYPH | ft.EFI_HII_OUT_FLAG_CLIP | \
ft.EFI_HII_OUT_FLAG_CLIP_CLEAN_X | ft.EFI_HII_OUT_FLAG_CLIP_CLEAN_Y | \
ft.EFI_HII_IGNORE_LINE_BREAK | ft.EFI_HII_DIRECT_TO_SCREEN,
uString,
EfiPy.byref (self.FontInfo),
EfiPy.byref (self.pBlt),
self.PointerX,
self.PointerY,
EfiPy.byref (self.RowInfoArray),
EfiPy.byref (self.RowInfoArraySize),
None)
for idx in range(self.RowInfoArraySize.value):
RowInfo = self.RowInfoArray[idx]
self.OrigX = self.PointerX
self.PointerX += RowInfo.LineWidth
self.LineHeight = RowInfo.LineHeight
self.LineWidth = RowInfo.LineWidth
def _PciGetNextBusRange(self, Descriptors):
if Descriptors == None:
return 0, pci.PCI_MAX_BUS, False
TempDesc = EfiPy.cast(
Descriptors, EfiPy.POINTER(Acpi.EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR))
# print "2. TempDesc[0].Desc, TempDesc[0].ResType", TempDesc[0].Desc, TempDesc[0].ResType
Idx = 0
while TempDesc[Idx].Desc != Acpi.ACPI_END_TAG_DESCRIPTOR:
if TempDesc[Idx].ResType == Acpi.ACPI_ADDRESS_SPACE_TYPE_BUS:
AddrRangeMin = TempDesc[Idx].AddrRangeMin
AddrRangeMax = TempDesc[Idx].AddrRangeMax
Descriptors.value += EfiPy.sizeof(
Acpi.EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR)
return Descriptors, TempDesc[Idx].AddrRangeMin, TempDesc[
Idx].AddrRangeMax, False
Descriptors.value += EfiPy.sizeof(
Acpi.EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR)
Idx += 1
if TempDesc[Idx].Desc == Acpi.ACPI_END_TAG_DESCRIPTOR:
return Descriptors, 0, pci.PCI_MAX_BUS, True
return None, None, None, True
def Run (self):
FileSpace = self.Shell.WorkSpace[WsIdxVol]
FileFolder = self.Shell.WorkSpace[WsIdxPath]
EfiPyTime = EfiPy.EFI_TIME ()
CapTime = EfiPy.EFI_TIME_CAPABILITIES ()
Status = EfiPy.gRT.GetTime (EfiPy.byref (EfiPyTime), EfiPy.byref (CapTime))
if EfiPy.EFI_ERROR (Status):
return
# EfiPyTime = EFI_TIME (RetTime)
for FilePath in self.args[1:]:
FileSpace, FileFolder, SpaceOnly, SpaceFound = self.ParseFolder (FilePath)
if SpaceFound == False:
self.StdOut.printf(u"%s is not valide volume\r\n" % FileSpace)
continue
if SpaceOnly == True:
self.StdOut.printf(u"%s Only volume identified\r\n" % FileSpace)
continue
self.ListTouch (FileSpace, FileFolder, EfiPyTime)
return 0
def ListDir (self, TargetSpace, TargetFolder, SpaceOnly, SpaceFound):
RootFs, FilePath = EfiPyFileOp.GetRootFsOperation (
self.Shell.WS, u"%s%s" %(TargetSpace, TargetFolder)
)
if RootFs == None:
self.StdOut.printf(u"File %s%s not found\r\n" % (TargetSpace, TargetFolder))
return 0
NewFs = EfiPy.POINTER(EFI_FILE_PROTOCOL) ()
Status = RootFs.Open (
EfiPy.byref (RootFs),
EfiPy.byref (NewFs),
TargetFolder,
EFI_FILE_MODE_READ,
0
)
if EfiPy.EFI_ERROR (Status):
self.StdOut.printf(u"File %s%s not found\r\n" % (TargetSpace, TargetFolder))
return 0
FileFolder = self.ParseAbsPath (NewFs[0])
self.StdOut.printf(u"Directory of: %s%s\r\n" % (TargetSpace, FileFolder))
NewFs[0].Close (NewFs)
FileNode = EfiPyFileOp.GetFilesInPath (RootFs, FilePath)
for FileItem in FileNode:
self.OutputFile (FileItem[2], FileItem[1])
def __init__(self):
TmpProtocol = EfiPy.PVOID()
Status = EfiPy.gBS.LocateProtocol(EfiPy.byref(gEfiHiiFontProtocolGuid),
None, EfiPy.byref(TmpProtocol))
if EfiPy.EFI_ERROR(Status):
return
self.Gfx = EfiPyGfx()
self.HiiFont = EfiPy.cast(TmpProtocol,
EfiPy.POINTER(EFI_HII_FONT_PROTOCOL))[0]
self.Blt = EFI_IMAGE_OUTPUT()
self.pBlt = EfiPy.pointer(self.Blt)
self.Blt.Width = self.Gfx.Info.HorizontalResolution
self.Blt.Height = self.Gfx.Info.VerticalResolution
self.Blt.Image.Screen = EfiPy.pointer(self.Gfx.Gop)
self.FontInfo = EFI_FONT_DISPLAY_INFO()
self.RowInfoArray = EfiPy.POINTER(EFI_HII_ROW_INFO)()
self.RowInfoArraySize = EfiPy.UINTN()
self.FontInfo.ForegroundColor = self.Gfx.RGB(0xFF, 0xFF, 0xFF)
self.FontInfo.BackgroundColor = self.Gfx.RGB(0x00, 0x00, 0x00)
self.OrigX = 0
self.PointerX = 0
self.PointerY = 0
self.LineHeight = 0
self.LineWidth = 0
def Run(self):
# print len(self.args), self.args
TimeCurr = EfiPy.EFI_TIME()
Status = EfiPy.gRT.GetTime(EfiPy.byref(TimeCurr), None)
if Status != EfiPy.EFI_SUCCESS:
self.StdOut.printf(u"Date operation error\r\n")
return 0
RetStatus = EfiPy.EFI_SUCCESS
if len(self.args) == 1:
self.StdOut.printf(u"%02d:%02d:%02d (%d)\r\n" %
(TimeCurr.Hour, TimeCurr.Minute,
TimeCurr.Second, TimeCurr.TimeZone))
elif len(self.args) == 2:
TimePara = self.args[1].split(u":")
if len(TimePara) == 3:
TimeHour = int(TimePara[0])
TimeMinute = int(TimePara[1])
TimeSecond = int(TimePara[2])
elif len(TimePara) == 2:
TimeHour = int(TimePara[0])
TimeMinute = int(TimePara[1])
TimeSecond = TimeCurr.Second
else:
RetStatus = EfiPy.EFI_INVALID_PARAMETER
if TimeHour > 23 or TimeHour < 0:
RetStatus = EfiPy.EFI_INVALID_PARAMETER
if TimeMinute > 60 or TimeMinute < 0:
RetStatus = EfiPy.EFI_INVALID_PARAMETER
if TimeSecond > 60 or TimeSecond < 0:
RetStatus = EfiPy.EFI_INVALID_PARAMETER
if RetStatus == EfiPy.EFI_SUCCESS:
TimeCurr.Hour, TimeCurr.Minute, TimeCurr.Second = TimeHour, TimeMinute, TimeSecond
Status = EfiPy.gRT.SetTime(EfiPy.byref(TimeCurr), None)
RetStatus = Status
else:
RetStatus = EfiPy.EFI_INVALID_PARAMETER
if RetStatus == EfiPy.EFI_INVALID_PARAMETER:
self.StdOut.printf(
u"Time inccorect input parameter. TIME [hh:mm[:ss]]\r\n")
return 0
def _GetInfo(self, Gop):
SizeOfInfo = EfiPy.UINTN()
Info = EfiPy.POINTER(EFI_GRAPHICS_OUTPUT_MODE_INFORMATION)()
Status = Gop.QueryMode(EfiPy.byref(Gop), Gop.Mode[0].Mode,
EfiPy.byref(SizeOfInfo), EfiPy.byref(Info))
return Info[0]
def _PciGetProtocolAndResource(self, Handle):
TmpDev = EfiPy.PVOID()
Status = EfiPy.gBS.HandleProtocol(
Handle, EfiPy.byref(gEfiPciRootBridgeIoProtocolGuid),
EfiPy.byref(TmpDev))
if EfiPy.EFI_ERROR(Status):
self.StdOut.printf(
"Locate HandleProtocol Fail (2) (Status = 0x%016X)!\r\n" %
Status)
return None, None
IoDev = (EfiPy.cast(TmpDev,
EfiPy.POINTER(EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL)))[0]
Descriptors = EfiPy.PVOID()
Status = IoDev.Configuration(EfiPy.byref(IoDev),
EfiPy.byref(Descriptors))
if Status == EfiPy.EFI_UNSUPPORTED:
self.StdOut.printf(
"Locate HandleProtocol Fail (2) (Status = 0x%016X)!\r\n" %
Status)
return IoDev, None
return IoDev, Descriptors
class EXTENDED_SYSTEM_DESCRIPTION_TABLE(EFIPY_INDUSTRY_STRUCTURE):
_fields_ = [
("Signature", EfiPy.UINT32), ("Length", EfiPy.UINT32),
("Revision", EfiPy.UINT8), ("Checksum", EfiPy.UINT8),
("OemId", EfiPy.UINT8 * 6), ("OemTableId", EfiPy.UINT64),
("OemRevision", EfiPy.UINT32), ("CreatorId", EfiPy.UINT32),
("CreatorRevision", EfiPy.UINT32),
("DescriptionEntry", EfiPy.UINT64 *
((_Xsdt.Length - EfiPy.sizeof(EFI_ACPI_DESCRIPTION_HEADER)) /
EfiPy.sizeof(EfiPy.UINT64)))
]
def Run(self):
Count = EfiPy.UINT64()
Status = EfiPy.gBS.GetNextMonotonicCount(EfiPy.byref(Count))
if EfiPy.RETURN_ERROR(Status):
return 0
self.StdOut.printf("%016X\r\n" % Count.value)
return 0
def ParseAbsPath (self, FileHandle):
AbsList = []
Status = EfiPy.EFI_SUCCESS
while Status == EfiPy.EFI_SUCCESS:
BufferSize = EfiPy.UINTN (0)
Status = FileHandle.GetInfo (
EfiPy.byref (FileHandle),
gEfiFileInfoGuid,
EfiPy.byref (BufferSize),
None
)
TmpBuffer = bytearray (BufferSize.value)
fInfo = EFI_FILE_INFO.from_buffer (TmpBuffer)
Status = FileHandle.GetInfo (
EfiPy.byref (FileHandle),
gEfiFileInfoGuid,
EfiPy.byref (BufferSize),
EfiPy.byref (fInfo)
)
if Status != EfiPy.EFI_SUCCESS:
break
TempStr = (TmpBuffer[EFI_FILE_INFO.FileName.offset: -2]).decode("utf-16")
if fInfo.Attribute & EFI_FILE_DIRECTORY == EFI_FILE_DIRECTORY:
AbsList.append (TempStr + u"\\")
else:
AbsList.append (TempStr)
NewFs = EfiPy.POINTER(EFI_FILE_PROTOCOL) ()
Status = FileHandle.Open (
EfiPy.byref (FileHandle),
EfiPy.byref (NewFs),
u"..",
EFI_FILE_MODE_READ,
0
)
if Status != EfiPy.EFI_SUCCESS:
break
if len(AbsList) > 1:
FileHandle.Close ( EfiPy.byref (FileHandle))
FileHandle = NewFs[0]
return "".join(v for v in AbsList[::-1])
def Detect_Protocol(self, Guid, Protocol):
TmpCount = EfiPy.UINTN(0)
TmpBuff = EfiPy.POINTER(EfiPy.EFI_HANDLE)()
self._ProtocolFilter.stop("LocateHandleBuffer")
Status = EfiPy.gBS.LocateHandleBuffer(EfiPy.ByProtocol,
EfiPy.byref(Guid), None,
EfiPy.byref(TmpCount),
EfiPy.byref(TmpBuff))
self._ProtocolFilter.start("LocateHandleBuffer")
if Status != EfiPy.EFI_SUCCESS:
return
self._ProtocolFilter.stop("HandleProtocol")
for Index in range(TmpCount.value):
Target = EfiPy.PVOID()
Status = EfiPy.gBS.HandleProtocol(TmpBuff[Index],
EfiPy.byref(Guid),
EfiPy.byref(Target))
if Status != EfiPy.EFI_SUCCESS:
continue
self.Target.append((Target, TmpBuff[Index]))
self._ProtocolFilter.start("HandleProtocol")
def Run(self):
# print len(self.args), self.args
TimeCurr = EfiPy.EFI_TIME()
Status = EfiPy.gRT.GetTime(EfiPy.byref(TimeCurr), None)
if Status != EfiPy.EFI_SUCCESS:
self.StdOut.printf(u"Date operation error\r\n")
return 0
RetStatus = EfiPy.EFI_SUCCESS
if len(self.args) == 1:
self.StdOut.printf(u"%02d/%02d/%04d\r\n" %
(TimeCurr.Month, TimeCurr.Day, TimeCurr.Year))
elif len(self.args) == 2:
TimePara = self.args[1].split(u"/")
if len(TimePara) != 3:
RetStatus = EfiPy.EFI_INVALID_PARAMETER
else:
TimeMonth = int(TimePara[0])
TimeDay = int(TimePara[1])
TimeYear = int(TimePara[2])
if TimeMonth > 12 or TimeMonth < 1:
RetStatus = EfiPy.EFI_INVALID_PARAMETER
if TimeDay > 31 or TimeDay < 1:
RetStatus = EfiPy.EFI_INVALID_PARAMETER
if RetStatus == EfiPy.EFI_SUCCESS:
TimeCurr.Month, TimeCurr.Day, TimeCurr.Year = TimeMonth, TimeDay, TimeYear
Status = EfiPy.gRT.SetTime(EfiPy.byref(TimeCurr), None)
RetStatus = Status
else:
RetStatus = EfiPy.EFI_INVALID_PARAMETER
if RetStatus == EfiPy.EFI_INVALID_PARAMETER:
self.StdOut.printf(
u"Date inccorect input parameter. [mm/dd/yyyy]\r\n")
return 0
def Rect(self, x, y, w, h, color=None):
if color == None:
color = self.RGB(0xFF, 0xFF, 0xFF)
self.Gop.Blt(
EfiPy.byref(self.Gop),
EfiPy.byref(color),
EfiBltVideoFill,
0,
0, # SourceX, SourceY
x,
y, # DestinationX, DestinationY
w,
h, # Width, Height
0)
def ParaGet(self):
self.Address = 0x00
self.Length = 0x00
self.Mmio = self.Paras[u"-mmio"][1]
CheckRight = True
self.Address = EfiPy.addressof(EfiPy.gST)
self.Length = 16 * 32
if type(self.args) is not list:
raise NameError(u"EFIPY_CMD_MEM._parameters.TypeError1")
try:
if len(self.args) > 3:
raise NameError(u"EFIPY_CMD_MEM._parameters.TypeError2")
self.Address = int(self.args[1], 16)
if len(self.args) == 3:
self.Length = int(self.args[2], 16)
if 0 == self.Length:
self.StdOut.printf(
"Memory Length can not be zeor, set as dafault 0x%20X\r\n"
% (16 * 32))
self.Length = 16 * 32
except:
self.StdOut.printf("Invalide parameter %s\r\n" % str(self.args))
def __init__(self, dOut):
_bAnalyze.__init__(self, dOut)
self.Guid = None # pAnalyzer
AppList = []
DrvList = []
self.ProtocolFuncList = (
("InstallProtocolInterface", None),
("ReinstallProtocolInterface", None),
("UninstallProtocolInterface", None),
# ("LocateHandleBuffer", None),
# ("HandleProtocol", None),
# ("OpenProtocol", None),
# ("CloseProtocol", None),
# ("ProtocolsPerHandle", None),
# ("LocateProtocol", None),
# ("InstallMultipleProtocolInterfaces", None),
# ("UninstallMultipleProtocolInterfaces",None),
)
self._ProtocolFilter = _bAnalyze(dOut)
self._ProtocolFilter.Build_Capability(EfiPy.EFI_BOOT_SERVICES)
self._ProtocolFilter.Filter.append(
self._ProtocolFilter.Build_Filter(EfiPy.byref(EfiPy.gBS), None))
for ProtoclFun in self.ProtocolFuncList:
self._ProtocolFilter.install(ProtoclFun[0])
self._ProtocolAllStart()
def StructDump(c_p, _class, _obj, leading=0):
for field in _class._fields_:
_c = field[1]
_o = getattr(_obj, field[0])
print " " * leading, "%s: " % field[0],
if issubclass(field[1], Isb.SMBIOS_TABLE_STRING):
print "%d(0x%X," % (_o.value, _o.value),
if _o.value != 0:
c_t = c_p
for idx in range(_o.value - 1):
c_t = c_t + len(EfiPy.PCHAR8(c_t).value) + 1
c_s = EfiPy.PCHAR8(c_t)
print 'String: "%s")' % c_s.value
else:
print "String: [Empty])"
elif issubclass(field[1], EfiPy._SimpleCData):
print "%d(0x%X)" % (_o, _o)
elif isinstance(_o, EfiPy.GUID):
print "%s" % _o
elif isinstance(_o, EfiPy.Structure):
print "(Structure)"
StructDump(c_p, _c, _o, leading + 2)
elif isinstance(_o, EfiPy.Array):
print "Array * %d" % len(_o)
for idx in range(len(_o)):
print " " * (leading + 2), "%s[%d]:" % (field[0], idx),
if type(_o[idx]) in [int, long]:
print "%d(0x%X)" % (_o[idx], _o[idx])
else:
print
StructDump(c_p, type(_o[idx]), _o[idx], leading + 4)
def ConnectDevicePath(self, DevicePathToConnect=None):
if DevicePathToConnect == None:
DevicePathToConnect = self.DevPath
if DevicePathToConnect == None:
return e.EFI_INVALID_PARAMETER
PreviousHandle = e.PVOID()
Handle = e.EFI_HANDLE()
while True:
RemainingDevicePath = DevicePathToConnect
Status = e.gBS.LocateDevicePath(
e.byref(gEfiDevicePathProtocolGuid),
e.byref(RemainingDevicePath), e.byref(Handle))
if not e.EFI_ERROR(Status) and Handle != None:
if PreviousHandle.value == Handle.value:
Status = e.EFI_NOT_FOUND
else:
PreviousHandle = Handle
self.dOut.ExtraOut(
"1. ConnectController Handle... 0x%08X\n" %
Handle.value)
Status = e.gBS.ConnectController(Handle, None,
RemainingDevicePath, True)
if e.EFI_ERROR(Status) or RemainingDevicePath[0].IsDevicePathEnd():
break
def __init__(self, DevPathName, OutFile=None):
self.dOut = bOutClass(OutFile)
# Locate EFI_DEVICE_PATH_TO_TEXT_PROTOCOL protocol
Interface = e.PVOID()
Status = e.gBS.LocateProtocol(
e.byref(gEfiDevicePathToTextProtocolGuid), None, Interface)
if e.EFI_ERROR(Status):
self.dOut.ExtraOut(
"Locate EFI_DEVICE_PATH_TO_TEXT_PROTOCOL Protocol Error # (Status:%x)\n"
% Status)
self.dOut.terminate()
exit(0)
self.DevPathToText = e.cast(
Interface, e.POINTER(EFI_DEVICE_PATH_TO_TEXT_PROTOCOL))[0]
def function_filter2(*args):
Information = function_filter2.func_dict["Information"]
dOut = function_filter2.func_dict["dOut"]
_xml = '<Function name="%s" fAddre="0x%X" Structure="%s" sAddr="0x%X">\n' % (
Information[0], Information[2], Information[1].__name__,
Information[3])
dOut.append(_xml)
_xml = '<Input length="%d">\n' % len(args)
cnt = 0
for arg in args:
s = get_arg_xml(arg)
_xml += '<arg%d %s ></arg%d>\n' % (cnt, s, cnt)
cnt += 1
dOut.append(_xml + '</Input>\n')
Pre_func = function_filter2.func_dict["Pre_func"]
Post_func = function_filter2.func_dict["Post_func"]
func_type = function_filter2.func_dict["Native_func"]
func_addr = function_filter2.func_dict["Native_addr"]
Alias_type = function_filter2.func_dict["Alias_type"]
if Pre_func != None:
fRest, args = Pre_func(dOut, *args)
f = func_type(function_filter2)
Alias_type.from_address(EfiPy.addressof(f)).value = func_addr
rest = f(*args)
if Post_func != None:
fRest, args = Post_func(dOut, rest, *args)
if rest != None:
_xml = '<Output %s>\n' % get_arg_xml(rest)
else:
_xml = '<Output>\n'
cnt = 0
for arg in args:
s = get_arg_xml(arg)
_xml += '<arg%d %s></arg%d>\n' % (cnt, s, cnt)
cnt += 1
dOut.append(_xml + '</Output>\n')
dOut.append('</Function>\n')
if rest != None:
return rest
def Run (self):
for ws in self.Shell.WS:
RootFs, FilePath = EfiPyFileOp.GetRootFsOperation (self.Shell.WS, ws)
if RootFs == None:
continue
# Status, RetValue = RootFs.GetInfo (gEfiFileSystemInfoGuid)
# if EFI_ERROR (Status):
# self.StdOut.printf(u"Get Volume %s Fail (%d) r\n" %(ws, Status))
# FsInfo = EFI_FILE_SYSTEM_INFO (RetValue[1])
BufferSize = EfiPy.UINTN (0)
Status = RootFs.GetInfo (
EfiPy.byref (RootFs),
gEfiFileSystemInfoGuid,
EfiPy.byref (BufferSize),
None
)
if Status != EfiPy.EFI_BUFFER_TOO_SMALL:
continue
# print "BufferSize.value", BufferSize.value
# print "EfiPy.sizeof (EFI_FILE_SYSTEM_INFO)", EfiPy.sizeof (EFI_FILE_SYSTEM_INFO)
if BufferSize.value >= EfiPy.sizeof (EFI_FILE_SYSTEM_INFO):
TmpBuffer = bytearray (BufferSize.value)
else:
TmpBuffer = bytearray (EfiPy.sizeof (EFI_FILE_SYSTEM_INFO))
FsInfo = EFI_FILE_SYSTEM_INFO.from_buffer (TmpBuffer)
Status = RootFs.GetInfo (
EfiPy.byref (RootFs),
gEfiFileSystemInfoGuid,
EfiPy.byref (BufferSize),
EfiPy.byref (FsInfo)
)
if Status != EfiPy.EFI_SUCCESS:
continue
# import Utility.EfiPyUtility
# Utility.EfiPyUtility.EfiPyHexDump (self.StdOut, 2, 0x00, TmpBuffer, True)
self.OutputVol (ws, FsInfo, TmpBuffer, BufferSize.value)
return 0
def Dump(self):
print "Current Mode: %d" % self.Gop.Mode[0].Mode
print "Max Mode: %X" % self.Gop.Mode[0].MaxMode
print "FrameBufferBase: %X" % self.Gop.Mode[0].FrameBufferBase
print "FrameBufferSize: %X" % self.Gop.Mode[0].FrameBufferSize
SizeOfInfo = EfiPy.UINTN()
Info = EfiPy.POINTER(EFI_GRAPHICS_OUTPUT_MODE_INFORMATION)()
for idx in range(self.Gop.Mode[0].MaxMode):
Status = self.Gop.QueryMode(EfiPy.byref(self.Gop), idx,
EfiPy.byref(SizeOfInfo),
EfiPy.byref(Info))
if EfiPy.EFI_ERROR(Status):
print "Get Mode %d error (Status: %X" % (idx, Status)
continue
print "\nMode %d Information" % idx
print "==================================================================================="
print "Version: %X" % Info[0].Version
print "HorizontalResolution: %d" % Info[0].HorizontalResolution
print "VerticalResolution: %d" % Info[0].VerticalResolution
print "PixelFormat: %d" % Info[0].PixelFormat
print "PixelInformation (R:0x%08X, G:0x%08X, B:0x%08X)" % (
Info[0].PixelInformation.RedMask,
Info[0].PixelInformation.GreenMask,
Info[0].PixelInformation.BlueMask)
print "PixelsPerScanLine %d" % Info[0].PixelsPerScanLine
def DriverLoad(self, pFullPathDev):
NewHandle = EfiPy.EFI_HANDLE()
Status = EfiPy.gBS.LoadImage(0, EfiPy.gImageHandle, pFullPathDev, None,
0, EfiPy.byref(NewHandle))
if EfiPy.EFI_ERROR(Status):
return Status, -1
TmpImage = EfiPy.PVOID()
Status = EfiPy.gBS.HandleProtocol(
NewHandle, EfiPy.byref(gEfiLoadedImageProtocolGuid),
EfiPy.byref(TmpImage))
if EfiPy.EFI_ERROR(Status):
EfiPy.gBS.Exit(EfiPy.byref(TmpImage), EfiPy.EFI_INVALID_PARAMETER,
0, None)
return EfiPy.EFI_INVALID_PARAMETER, -2
LoadedDriverImage = EfiPy.cast(
TmpImage, EfiPy.POINTER(EFI_LOADED_IMAGE_PROTOCOL))
if (LoadedDriverImage[0].ImageCodeType != EfiBootServicesCode) and \
(LoadedDriverImage[0].ImageCodeType != EfiRuntimeServicesCode):
return EfiPy.EFI_INVALID_PARAMETER, LoadedDriverImage[
0].ImageCodeType
self._ProtocolAllStart()
StartStatus = EfiPy.gBS.StartImage(NewHandle, None, None)
self._ProtocolAllStop()
return Status, StartStatus
def IsFileExist (self, FileSpace, FileFolder):
if FileSpace == None or FileFolder == None:
return False
RootFs, FilePath = EfiPyFileOp.GetRootFsOperation (
self.Shell.WS,
u"%s%s" %(FileSpace, FileFolder)
)
if RootFs == None:
return False
NewFs = EfiPy.POINTER(EFI_FILE_PROTOCOL) ()
Status = RootFs.Open (
EfiPy.byref (RootFs),
EfiPy.byref (NewFs),
FilePath,
EFI_FILE_MODE_READ,
0
)
RetValue = True
if EfiPy.EFI_ERROR (Status):
RetValue = False
Status = RootFs.Close (EfiPy.byref (RootFs))
# if EfiPy.EFI_ERROR (Status):
# print "Error 1"
if RetValue == True:
Status = NewFs[0].Close (NewFs)
# if EfiPy.EFI_ERROR (Status):
# print "Error 2"
return RetValue
def _DmpVariable (self, name, guid):
DataSize = EfiPy.UINTN (0x00)
Status = EfiPy.gRT.GetVariable (
name,
EfiPy.byref (guid),
None,
EfiPy.byref (DataSize),
None
)
if Status != EfiPy.EFI_BUFFER_TOO_SMALL:
return
Attributes = EfiPy.UINT32(0x00)
DataBuffer =(EfiPy.CHAR8 * DataSize.value)("\00")
Status = EfiPy.gRT.GetVariable (
name,
EfiPy.byref (guid),
EfiPy.byref (Attributes),
EfiPy.byref (DataSize),
EfiPy.byref (DataBuffer)
)
if not EfiPy.RETURN_ERROR (Status):
StrVarAttr = ""
if (Attributes.value & EfiPy.EFI_VARIABLE_NON_VOLATILE) > 0:
StrVarAttr = "NV"
if (Attributes.value & EfiPy.EFI_VARIABLE_RUNTIME_ACCESS) > 0:
if len(StrVarAttr) > 0:
StrVarAttr = StrVarAttr + "+"
StrVarAttr = StrVarAttr + "RS"
if (Attributes.value & EfiPy.EFI_VARIABLE_BOOTSERVICE_ACCESS) > 0:
if len(StrVarAttr) > 0:
StrVarAttr = StrVarAttr + "+"
StrVarAttr = StrVarAttr + "BS"
self.StdOut.printf("Variable - %s - '%s:%s' - DataSize = 0x%X\r\n" % (StrVarAttr, guid, name, DataSize.value))
EfiPyHexDump (self.StdOut, 2, 0x0000, DataBuffer, True)
else:
self.StdOut.printf("Get Variable %s %s error\r\n" % (name, guid))
def TestHint(fnt=None, HintString=None):
from EfiPy.MdePkg.Protocol.SimpleTextIn import EFI_INPUT_KEY
if HintString != None and fnt != None:
fnt.PrintXY(u"%s" % HintString, 200, 300)
InKey = EFI_INPUT_KEY()
Status = -1
while Status != EfiPy.EFI_SUCCESS:
Status = EfiPy.gST.ConIn[0].ReadKeyStroke(EfiPy.gST.ConIn,
EfiPy.byref(InKey))
def SmbiosDump(Record):
print "=========================================================="
try:
SmbiosClass = getattr(Isb, "SMBIOS_TABLE_TYPE%d" % Record[0].Type)
sbObjp = EfiPy.cast(Record, EfiPy.PVOID)
sbObj = EfiPy.cast(Record, EfiPy.POINTER(SmbiosClass))[0]
print "Type %3d, Length: %d, Handle: 0x%08X" % (
sbObj.Hdr.Type, sbObj.Hdr.Length, sbObj.Hdr.Handle)
c_p = sbObjp.value + sbObj.Hdr.Length
StructDump(c_p, SmbiosClass, sbObj, 0)
except:
SmbiosClass = Isb.SMBIOS_STRUCTURE
sbObj = EfiPy.cast(Record, EfiPy.POINTER(SmbiosClass))[0]
print "Type %3d, Length: %d, Handle: 0x%08X" % (
sbObj.Type, sbObj.Length, sbObj.Handle)
def DumpAllVariable():
import copy
VariableList = []
VariableName = u"\x00" * 100
VariableSize = EfiPy.UINTN(EfiPy.sizeof(EfiPy.CHAR16) * 100)
VariableTsize = EfiPy.UINTN(EfiPy.sizeof(EfiPy.CHAR16) * 100)
VariableGuid = EfiPy.EFI_GUID()
while True:
Status = EfiPy.gRT.GetNextVariableName(EfiPy.byref(VariableTsize),
EfiPy.PCHAR16(VariableName),
EfiPy.byref(VariableGuid))
if Status == EfiPy.EFI_BUFFER_TOO_SMALL:
VariableName = VariableName + u"\x00" * 100
VariableSize.value += EfiPy.sizeof(EfiPy.CHAR16) * 100
VariableTsize.value = VariableSize.value
continue
if Status == EfiPy.EFI_SUCCESS:
VariableList.append([
VariableName[:VariableName.index(u"\x00")],
copy.copy(VariableGuid)
])
VariableTsize.value = VariableSize.value
continue
break
for Var in VariableList:
DmpVariable(Var[0], Var[1])
return 0
def _ConnectPciRootBridge(self):
RootBridgeHandleCount = e.UINTN(0)
RootBridgeHandleBuffer = e.POINTER(e.EFI_HANDLE)()
Status = e.gBS.LocateHandleBuffer(
e.ByProtocol, e.byref(gEfiPciRootBridgeIoProtocolGuid), None,
e.byref(RootBridgeHandleCount), e.byref(RootBridgeHandleBuffer))
if e.EFI_ERROR(Status):
return Status
for RootBridgeIndex in range(RootBridgeHandleCount.value):
self.dOut.ExtraOut("2. ConnectController Handle... 0x%08X\n" %
RootBridgeHandleBuffer[RootBridgeIndex].value)
e.gBS.ConnectController(RootBridgeHandleBuffer[RootBridgeIndex],
None, None, False)
return e.EFI_SUCCESS
def SetSize(self, FileSpace, FileFolder, FileSize):
if self.Shell.WS[FileSpace.upper()][WsIdxPath] == u"":
self.StdOut.printf(u"%s is not valide volume\r\n" % FileSpace)
return
RootFs, FilePath = EfiPyFileOp.GetRootFsOperation(
self.Shell.WS, u"%s%s" % (FileSpace, FileFolder))
if RootFs == None:
self.StdOut.printf(u"Volume %s cannot be opened\r\n" % FileSpace)
return 0
NewFs = EfiPy.POINTER(EFI_FILE_PROTOCOL)()
Status = RootFs.Open(EfiPy.byref(RootFs), EfiPy.byref(NewFs),
FileFolder,
EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE, 0)
if Status == EfiPy.EFI_NOT_FOUND:
Status = RootFs.Open(
EfiPy.byref(RootFs), EfiPy.byref(NewFs), FileFolder,
EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE
| EFI_FILE_MODE_CREATE, 0)
if EfiPy.EFI_ERROR(Status):
self.StdOut.printf(u"File %s%s cannot be opened 0x%016X\r\n" %
(FileSpace, FileFolder, Status))
return 0
BufferSize = EfiPy.UINTN(0)
Status = NewFs[0].GetInfo(NewFs, gEfiFileInfoGuid,
EfiPy.byref(BufferSize), None)
if Status != EfiPy.EFI_BUFFER_TOO_SMALL:
NewFs[0].Close(NewFs)
return 0
TmpBuffer = bytearray(BufferSize.value)
fInfo = EFI_FILE_INFO.from_buffer(TmpBuffer)
Status = NewFs[0].GetInfo(NewFs, gEfiFileInfoGuid,
EfiPy.byref(BufferSize), EfiPy.byref(fInfo))
if Status != EfiPy.EFI_SUCCESS:
NewFs[0].Close(NewFs)
return 0
fInfo.FileSize = FileSize
Status = NewFs[0].SetInfo(NewFs, gEfiFileInfoGuid, BufferSize,
EfiPy.byref(fInfo))
self.StdOut.printf(u"Set size %s%s, Status: 0x%016X\r\n" %
(FileSpace, FileFolder, Status))
NewFs[0].Close(NewFs)
return 0