Imported Upstream version 0.1+git15+20130418+09259caupstream/0.1+git15+20130418+09259caupstream

706 files changed, 73829 insertions, 54520 deletions

diff --git a/AppPkg/Applications/Main/Main.c b/AppPkg/Applications/Main/Main.c
index c2762d57..f588a30f 100644
--- a/AppPkg/Applications/Main/Main.c
+++ b/AppPkg/Applications/Main/Main.c
@@ -32,7 +32,6 @@
   @retval  Other     An error occurred.

 ***/

 int

-EFIAPI

 main (

   IN int Argc,

   IN char **Argv

diff --git a/AppPkg/Applications/Python/Efi/config.c b/AppPkg/Applications/Python/Efi/config.c
index 7ae26319..7cc021c9 100644
--- a/AppPkg/Applications/Python/Efi/config.c
+++ b/AppPkg/Applications/Python/Efi/config.c
@@ -17,46 +17,59 @@
 #include "Python.h"

 

 extern void initarray(void);

+extern void init_ast(void);

 extern void initbinascii(void);

+extern void init_bisect(void);

 extern void initcmath(void);

+extern void init_codecs(void);

+extern void init_collections(void);

+extern void initcPickle(void);

+extern void initcStringIO(void);

+extern void init_csv(void);

+extern void init_ctypes(void);

+extern void initdatetime(void);

+extern void initedk2(void);

 extern void initerrno(void);

+extern void init_functools(void);

 extern void initfuture_builtins(void);

 extern void initgc(void);

+extern void init_heapq(void);

+extern void init_hotshot(void);

+extern void initimp(void);

+extern void init_io(void);

+extern void inititertools(void);

+extern void init_json(void);

+extern void init_lsprof(void);

 extern void initmath(void);

 extern void init_md5(void);

-extern void initedk2(void);

+extern void initmmap(void);

 extern void initoperator(void);

-extern void initsignal(void);

+extern void initparser(void);

+extern void initpyexpat(void);

+extern void init_random(void);

+extern void initselect(void);

 extern void init_sha(void);

 extern void init_sha256(void);

 extern void init_sha512(void);

+extern void initsignal(void);

+extern void init_socket(void);

+extern void init_sre(void);

 extern void initstrop(void);

-extern void inittime(void);

+extern void init_struct(void);

+extern void init_subprocess(void);

+extern void init_symtable(void);

 extern void initthread(void);

-extern void initcStringIO(void);

-extern void initcPickle(void);

-extern void init_codecs(void);

+extern void inittime(void);

+extern void initunicodedata(void);

 extern void init_weakref(void);

-extern void init_hotshot(void);

+extern void init_winreg(void);

 extern void initxxsubtype(void);

 extern void initzipimport(void);

-extern void init_random(void);

-extern void inititertools(void);

-extern void init_collections(void);

-extern void init_heapq(void);

-extern void init_bisect(void);

-extern void init_symtable(void);

-extern void initmmap(void);

-extern void init_csv(void);

-extern void init_sre(void);

-extern void initparser(void);

-extern void init_winreg(void);

-extern void init_struct(void);

-extern void initdatetime(void);

-extern void init_functools(void);

-extern void init_json(void);

 extern void initzlib(void);

 

+extern void PyMarshal_Init(void);

+extern void _PyWarnings_Init(void);

+

 extern void init_multibytecodec(void);

 extern void init_codecs_cn(void);

 extern void init_codecs_hk(void);

@@ -64,26 +77,13 @@ extern void init_codecs_iso2022(void);
 extern void init_codecs_jp(void);

 extern void init_codecs_kr(void);

 extern void init_codecs_tw(void);

-extern void init_subprocess(void);

-extern void init_lsprof(void);

-extern void init_ast(void);

-extern void init_io(void);

-extern void _PyWarnings_Init(void);

-

-extern void init_socket(void);

-extern void initselect(void);

-

-extern void PyMarshal_Init(void);

-extern void initimp(void);

-extern void initunicodedata(void);

-extern void init_ctypes(void);

 

 struct _inittab _PyImport_Inittab[] = {

 

     //{"_ast", init_ast},

-    //{"_bisect", init_bisect},                   /* A fast version of bisect.py */

+    //{"_bisect", init_bisect},               /* A fast version of bisect.py */

     //{"_csv", init_csv},

-    //{"_heapq", init_heapq},                     /* A fast version of heapq.py */

+    //{"_heapq", init_heapq},                 /* A fast version of heapq.py */

     //{"_io", init_io},

     //{"_json", init_json},

     //{"_md5", init_md5},

@@ -99,9 +99,10 @@ struct _inittab _PyImport_Inittab[] = {
     //{"datetime", initdatetime},

     //{"future_builtins", initfuture_builtins},

     //{"parser", initparser},

+    //{"pyexpat", initpyexpat},

     //{"select", initselect},

     //{"signal", initsignal},

-    //{"strop", initstrop},                       /* redefines some string operations that are 100-1000 times faster */

+    //{"strop", initstrop},                   /* redefines some string operations that are 100-1000 times faster */

     //{"unicodedata", initunicodedata},

     //{"xxsubtype", initxxsubtype},

     //{"zipimport", initzipimport},

diff --git a/AppPkg/Applications/Python/PyMod-2.7.2/Modules/expat/expat_external.h b/AppPkg/Applications/Python/PyMod-2.7.2/Modules/expat/expat_external.h
new file mode 100644
index 00000000..b7395958
--- /dev/null
+++ b/AppPkg/Applications/Python/PyMod-2.7.2/Modules/expat/expat_external.h
@@ -0,0 +1,121 @@
+/* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd

+   See the file COPYING for copying permission.

+*/

+

+#ifndef Expat_External_INCLUDED

+#define Expat_External_INCLUDED 1

+

+/* External API definitions */

+

+/* Namespace external symbols to allow multiple libexpat version to

+   co-exist. */

+#if !defined(UEFI_C_SOURCE)

+  #include "pyexpatns.h"

+#endif

+

+#if defined(_MSC_EXTENSIONS) && !defined(__BEOS__) && !defined(__CYGWIN__)

+#define XML_USE_MSC_EXTENSIONS 1

+#endif

+

+/* Expat tries very hard to make the API boundary very specifically

+   defined.  There are two macros defined to control this boundary;

+   each of these can be defined before including this header to

+   achieve some different behavior, but doing so it not recommended or

+   tested frequently.

+

+   XMLCALL    - The calling convention to use for all calls across the

+                "library boundary."  This will default to cdecl, and

+                try really hard to tell the compiler that's what we

+                want.

+

+   XMLIMPORT  - Whatever magic is needed to note that a function is

+                to be imported from a dynamically loaded library

+                (.dll, .so, or .sl, depending on your platform).

+

+   The XMLCALL macro was added in Expat 1.95.7.  The only one which is

+   expected to be directly useful in client code is XMLCALL.

+

+   Note that on at least some Unix versions, the Expat library must be

+   compiled with the cdecl calling convention as the default since

+   system headers may assume the cdecl convention.

+*/

+#ifndef XMLCALL

+#if defined(XML_USE_MSC_EXTENSIONS)

+#define XMLCALL __cdecl

+#elif defined(__GNUC__) && defined(__i386)

+#define XMLCALL __attribute__((cdecl))

+#else

+/* For any platform which uses this definition and supports more than

+   one calling convention, we need to extend this definition to

+   declare the convention used on that platform, if it's possible to

+   do so.

+

+   If this is the case for your platform, please file a bug report

+   with information on how to identify your platform via the C

+   pre-processor and how to specify the same calling convention as the

+   platform's malloc() implementation.

+*/

+#define XMLCALL

+#endif

+#endif  /* not defined XMLCALL */

+

+

+#if !defined(XML_STATIC) && !defined(XMLIMPORT)

+#ifndef XML_BUILDING_EXPAT

+/* using Expat from an application */

+

+#ifdef XML_USE_MSC_EXTENSIONS

+#define XMLIMPORT __declspec(dllimport)

+#endif

+

+#endif

+#endif  /* not defined XML_STATIC */

+

+

+/* If we didn't define it above, define it away: */

+#ifndef XMLIMPORT

+#define XMLIMPORT

+#endif

+

+

+#define XMLPARSEAPI(type) XMLIMPORT type XMLCALL

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+#ifdef XML_UNICODE_WCHAR_T

+#define XML_UNICODE

+#endif

+

+#ifdef XML_UNICODE     /* Information is UTF-16 encoded. */

+#ifdef XML_UNICODE_WCHAR_T

+typedef wchar_t XML_Char;

+typedef wchar_t XML_LChar;

+#else

+typedef unsigned short XML_Char;

+typedef char XML_LChar;

+#endif /* XML_UNICODE_WCHAR_T */

+#else                  /* Information is UTF-8 encoded. */

+typedef char XML_Char;

+typedef char XML_LChar;

+#endif /* XML_UNICODE */

+

+#ifdef XML_LARGE_SIZE  /* Use large integers for file/stream positions. */

+#if defined(XML_USE_MSC_EXTENSIONS) && _MSC_VER < 1400

+typedef __int64 XML_Index; 

+typedef unsigned __int64 XML_Size;

+#else

+typedef long long XML_Index;

+typedef unsigned long long XML_Size;

+#endif

+#else

+typedef long XML_Index;

+typedef unsigned long XML_Size;

+#endif /* XML_LARGE_SIZE */

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif /* not Expat_External_INCLUDED */

diff --git a/AppPkg/Applications/Python/PyMod-2.7.2/Modules/expat/xmlparse.c b/AppPkg/Applications/Python/PyMod-2.7.2/Modules/expat/xmlparse.c
new file mode 100644
index 00000000..e303c7a7
--- /dev/null
+++ b/AppPkg/Applications/Python/PyMod-2.7.2/Modules/expat/xmlparse.c
@@ -0,0 +1,6279 @@
+/* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd

+   See the file COPYING for copying permission.

+*/

+

+#define XML_BUILDING_EXPAT 1

+

+#ifdef COMPILED_FROM_DSP

+#include "winconfig.h"

+#elif defined(MACOS_CLASSIC)

+#include "macconfig.h"

+#elif defined(__amigaos4__)

+#include "amigaconfig.h"

+#elif defined(HAVE_EXPAT_CONFIG_H)

+#include <expat_config.h>

+#endif /* ndef COMPILED_FROM_DSP */

+

+#include <stddef.h>

+#include <string.h>                     /* memset(), memcpy() */

+#include <assert.h>

+

+#if defined(UEFI_C_SOURCE)

+  #include <expat/expat.h>

+#else

+  #include "expat.h"

+#endif

+

+#ifdef XML_UNICODE

+#define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX

+#define XmlConvert XmlUtf16Convert

+#define XmlGetInternalEncoding XmlGetUtf16InternalEncoding

+#define XmlGetInternalEncodingNS XmlGetUtf16InternalEncodingNS

+#define XmlEncode XmlUtf16Encode

+#define MUST_CONVERT(enc, s) (!(enc)->isUtf16 || (((unsigned long)s) & 1))

+typedef unsigned short ICHAR;

+#else

+#define XML_ENCODE_MAX XML_UTF8_ENCODE_MAX

+#define XmlConvert XmlUtf8Convert

+#define XmlGetInternalEncoding XmlGetUtf8InternalEncoding

+#define XmlGetInternalEncodingNS XmlGetUtf8InternalEncodingNS

+#define XmlEncode XmlUtf8Encode

+#define MUST_CONVERT(enc, s) (!(enc)->isUtf8)

+typedef char ICHAR;

+#endif

+

+

+#ifndef XML_NS

+

+#define XmlInitEncodingNS XmlInitEncoding

+#define XmlInitUnknownEncodingNS XmlInitUnknownEncoding

+#undef XmlGetInternalEncodingNS

+#define XmlGetInternalEncodingNS XmlGetInternalEncoding

+#define XmlParseXmlDeclNS XmlParseXmlDecl

+

+#endif

+

+#ifdef XML_UNICODE

+

+#ifdef XML_UNICODE_WCHAR_T

+#define XML_T(x) (const wchar_t)x

+#define XML_L(x) L ## x

+#else

+#define XML_T(x) (const unsigned short)x

+#define XML_L(x) x

+#endif

+

+#else

+

+#define XML_T(x) x

+#define XML_L(x) x

+

+#endif

+

+/* Round up n to be a multiple of sz, where sz is a power of 2. */

+#define ROUND_UP(n, sz) (((n) + ((sz) - 1)) & ~((sz) - 1))

+

+/* Handle the case where memmove() doesn't exist. */

+#ifndef HAVE_MEMMOVE

+#ifdef HAVE_BCOPY

+#define memmove(d,s,l) bcopy((s),(d),(l))

+#else

+#error memmove does not exist on this platform, nor is a substitute available

+#endif /* HAVE_BCOPY */

+#endif /* HAVE_MEMMOVE */

+

+#include "internal.h"

+#include "xmltok.h"

+#include "xmlrole.h"

+

+typedef const XML_Char *KEY;

+

+typedef struct {

+  KEY name;

+} NAMED;

+

+typedef struct {

+  NAMED **v;

+  unsigned char power;

+  size_t size;

+  size_t used;

+  const XML_Memory_Handling_Suite *mem;

+} HASH_TABLE;

+

+/* Basic character hash algorithm, taken from Python's string hash:

+   h = h * 1000003 ^ character, the constant being a prime number.

+

+*/

+#ifdef XML_UNICODE

+#define CHAR_HASH(h, c) \

+  (((h) * 0xF4243) ^ (unsigned short)(c))

+#else

+#define CHAR_HASH(h, c) \

+  (((h) * 0xF4243) ^ (unsigned char)(c))

+#endif

+

+/* For probing (after a collision) we need a step size relative prime

+   to the hash table size, which is a power of 2. We use double-hashing,

+   since we can calculate a second hash value cheaply by taking those bits

+   of the first hash value that were discarded (masked out) when the table

+   index was calculated: index = hash & mask, where mask = table->size - 1.

+   We limit the maximum step size to table->size / 4 (mask >> 2) and make

+   it odd, since odd numbers are always relative prime to a power of 2.

+*/

+#define SECOND_HASH(hash, mask, power) \

+  ((((hash) & ~(mask)) >> ((power) - 1)) & ((mask) >> 2))

+#define PROBE_STEP(hash, mask, power) \

+  ((unsigned char)((SECOND_HASH(hash, mask, power)) | 1))

+

+typedef struct {

+  NAMED **p;

+  NAMED **end;

+} HASH_TABLE_ITER;

+

+#define INIT_TAG_BUF_SIZE 32  /* must be a multiple of sizeof(XML_Char) */

+#define INIT_DATA_BUF_SIZE 1024

+#define INIT_ATTS_SIZE 16

+#define INIT_ATTS_VERSION 0xFFFFFFFF

+#define INIT_BLOCK_SIZE 1024

+#define INIT_BUFFER_SIZE 1024

+

+#define EXPAND_SPARE 24

+

+typedef struct binding {

+  struct prefix *prefix;

+  struct binding *nextTagBinding;

+  struct binding *prevPrefixBinding;

+  const struct attribute_id *attId;

+  XML_Char *uri;

+  int uriLen;

+  int uriAlloc;

+} BINDING;

+

+typedef struct prefix {

+  const XML_Char *name;

+  BINDING *binding;

+} PREFIX;

+

+typedef struct {

+  const XML_Char *str;

+  const XML_Char *localPart;

+  const XML_Char *prefix;

+  int strLen;

+  int uriLen;

+  int prefixLen;

+} TAG_NAME;

+

+/* TAG represents an open element.

+   The name of the element is stored in both the document and API

+   encodings.  The memory buffer 'buf' is a separately-allocated

+   memory area which stores the name.  During the XML_Parse()/

+   XMLParseBuffer() when the element is open, the memory for the 'raw'

+   version of the name (in the document encoding) is shared with the

+   document buffer.  If the element is open across calls to

+   XML_Parse()/XML_ParseBuffer(), the buffer is re-allocated to

+   contain the 'raw' name as well.

+

+   A parser re-uses these structures, maintaining a list of allocated

+   TAG objects in a free list.

+*/

+typedef struct tag {

+  struct tag *parent;           /* parent of this element */

+  const char *rawName;          /* tagName in the original encoding */

+  int rawNameLength;

+  TAG_NAME name;                /* tagName in the API encoding */

+  char *buf;                    /* buffer for name components */

+  char *bufEnd;                 /* end of the buffer */

+  BINDING *bindings;

+} TAG;

+

+typedef struct {

+  const XML_Char *name;

+  const XML_Char *textPtr;

+  int textLen;                  /* length in XML_Chars */

+  int processed;                /* # of processed bytes - when suspended */

+  const XML_Char *systemId;

+  const XML_Char *base;

+  const XML_Char *publicId;

+  const XML_Char *notation;

+  XML_Bool open;

+  XML_Bool is_param;

+  XML_Bool is_internal; /* true if declared in internal subset outside PE */

+} ENTITY;

+

+typedef struct {

+  enum XML_Content_Type         type;

+  enum XML_Content_Quant        quant;

+  const XML_Char *              name;

+  int                           firstchild;

+  int                           lastchild;

+  int                           childcnt;

+  int                           nextsib;

+} CONTENT_SCAFFOLD;

+

+#define INIT_SCAFFOLD_ELEMENTS 32

+

+typedef struct block {

+  struct block *next;

+  int size;

+  XML_Char s[1];

+} BLOCK;

+

+typedef struct {

+  BLOCK *blocks;

+  BLOCK *freeBlocks;

+  const XML_Char *end;

+  XML_Char *ptr;

+  XML_Char *start;

+  const XML_Memory_Handling_Suite *mem;

+} STRING_POOL;

+

+/* The XML_Char before the name is used to determine whether

+   an attribute has been specified. */

+typedef struct attribute_id {

+  XML_Char *name;

+  PREFIX *prefix;

+  XML_Bool maybeTokenized;

+  XML_Bool xmlns;

+} ATTRIBUTE_ID;

+

+typedef struct {

+  const ATTRIBUTE_ID *id;

+  XML_Bool isCdata;

+  const XML_Char *value;

+} DEFAULT_ATTRIBUTE;

+

+typedef struct {

+  unsigned long version;

+  unsigned long hash;

+  const XML_Char *uriName;

+} NS_ATT;

+

+typedef struct {

+  const XML_Char *name;

+  PREFIX *prefix;

+  const ATTRIBUTE_ID *idAtt;

+  int nDefaultAtts;

+  int allocDefaultAtts;

+  DEFAULT_ATTRIBUTE *defaultAtts;

+} ELEMENT_TYPE;

+

+typedef struct {

+  HASH_TABLE generalEntities;

+  HASH_TABLE elementTypes;

+  HASH_TABLE attributeIds;

+  HASH_TABLE prefixes;

+  STRING_POOL pool;

+  STRING_POOL entityValuePool;

+  /* false once a parameter entity reference has been skipped */

+  XML_Bool keepProcessing;

+  /* true once an internal or external PE reference has been encountered;

+     this includes the reference to an external subset */

+  XML_Bool hasParamEntityRefs;

+  XML_Bool standalone;

+#ifdef XML_DTD

+  /* indicates if external PE has been read */

+  XML_Bool paramEntityRead;

+  HASH_TABLE paramEntities;

+#endif /* XML_DTD */

+  PREFIX defaultPrefix;

+  /* === scaffolding for building content model === */

+  XML_Bool in_eldecl;

+  CONTENT_SCAFFOLD *scaffold;

+  unsigned contentStringLen;

+  unsigned scaffSize;

+  unsigned scaffCount;

+  int scaffLevel;

+  int *scaffIndex;

+} DTD;

+

+typedef struct open_internal_entity {

+  const char *internalEventPtr;

+  const char *internalEventEndPtr;

+  struct open_internal_entity *next;

+  ENTITY *entity;

+  int startTagLevel;

+  XML_Bool betweenDecl; /* WFC: PE Between Declarations */

+} OPEN_INTERNAL_ENTITY;

+

+typedef enum XML_Error PTRCALL Processor(XML_Parser parser,

+                                         const char *start,

+                                         const char *end,

+                                         const char **endPtr);

+

+static Processor prologProcessor;

+static Processor prologInitProcessor;

+static Processor contentProcessor;

+static Processor cdataSectionProcessor;

+#ifdef XML_DTD

+static Processor ignoreSectionProcessor;

+static Processor externalParEntProcessor;

+static Processor externalParEntInitProcessor;

+static Processor entityValueProcessor;

+static Processor entityValueInitProcessor;

+#endif /* XML_DTD */

+static Processor epilogProcessor;

+static Processor errorProcessor;

+static Processor externalEntityInitProcessor;

+static Processor externalEntityInitProcessor2;

+static Processor externalEntityInitProcessor3;

+static Processor externalEntityContentProcessor;

+static Processor internalEntityProcessor;

+

+static enum XML_Error

+handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName);

+static enum XML_Error

+processXmlDecl(XML_Parser parser, int isGeneralTextEntity,

+               const char *s, const char *next);

+static enum XML_Error

+initializeEncoding(XML_Parser parser);

+static enum XML_Error

+doProlog(XML_Parser parser, const ENCODING *enc, const char *s,

+         const char *end, int tok, const char *next, const char **nextPtr,

+         XML_Bool haveMore);

+static enum XML_Error

+processInternalEntity(XML_Parser parser, ENTITY *entity,

+                      XML_Bool betweenDecl);

+static enum XML_Error

+doContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,

+          const char *start, const char *end, const char **endPtr,

+          XML_Bool haveMore);

+static enum XML_Error

+doCdataSection(XML_Parser parser, const ENCODING *, const char **startPtr,

+               const char *end, const char **nextPtr, XML_Bool haveMore);

+#ifdef XML_DTD

+static enum XML_Error

+doIgnoreSection(XML_Parser parser, const ENCODING *, const char **startPtr,

+                const char *end, const char **nextPtr, XML_Bool haveMore);

+#endif /* XML_DTD */

+

+static enum XML_Error

+storeAtts(XML_Parser parser, const ENCODING *, const char *s,

+          TAG_NAME *tagNamePtr, BINDING **bindingsPtr);

+static enum XML_Error

+addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,

+           const XML_Char *uri, BINDING **bindingsPtr);

+static int

+defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *, XML_Bool isCdata,

+                XML_Bool isId, const XML_Char *dfltValue, XML_Parser parser);

+static enum XML_Error

+storeAttributeValue(XML_Parser parser, const ENCODING *, XML_Bool isCdata,

+                    const char *, const char *, STRING_POOL *);

+static enum XML_Error

+appendAttributeValue(XML_Parser parser, const ENCODING *, XML_Bool isCdata,

+                     const char *, const char *, STRING_POOL *);

+static ATTRIBUTE_ID *

+getAttributeId(XML_Parser parser, const ENCODING *enc, const char *start,

+               const char *end);

+static int

+setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *);

+static enum XML_Error

+storeEntityValue(XML_Parser parser, const ENCODING *enc, const char *start,

+                 const char *end);

+static int

+reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,

+                            const char *start, const char *end);

+static int

+reportComment(XML_Parser parser, const ENCODING *enc, const char *start,

+              const char *end);

+static void

+reportDefault(XML_Parser parser, const ENCODING *enc, const char *start,

+              const char *end);

+

+static const XML_Char * getContext(XML_Parser parser);

+static XML_Bool

+setContext(XML_Parser parser, const XML_Char *context);

+

+static void FASTCALL normalizePublicId(XML_Char *s);

+

+static DTD * dtdCreate(const XML_Memory_Handling_Suite *ms);

+/* do not call if parentParser != NULL */

+static void dtdReset(DTD *p, const XML_Memory_Handling_Suite *ms);

+static void

+dtdDestroy(DTD *p, XML_Bool isDocEntity, const XML_Memory_Handling_Suite *ms);

+static int

+dtdCopy(DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms);

+static int

+copyEntityTable(HASH_TABLE *, STRING_POOL *, const HASH_TABLE *);

+

+static NAMED *

+lookup(HASH_TABLE *table, KEY name, size_t createSize);

+static void FASTCALL

+hashTableInit(HASH_TABLE *, const XML_Memory_Handling_Suite *ms);

+static void FASTCALL hashTableClear(HASH_TABLE *);

+static void FASTCALL hashTableDestroy(HASH_TABLE *);

+static void FASTCALL

+hashTableIterInit(HASH_TABLE_ITER *, const HASH_TABLE *);

+static NAMED * FASTCALL hashTableIterNext(HASH_TABLE_ITER *);

+

+static void FASTCALL

+poolInit(STRING_POOL *, const XML_Memory_Handling_Suite *ms);

+static void FASTCALL poolClear(STRING_POOL *);

+static void FASTCALL poolDestroy(STRING_POOL *);

+static XML_Char *

+poolAppend(STRING_POOL *pool, const ENCODING *enc,

+           const char *ptr, const char *end);

+static XML_Char *

+poolStoreString(STRING_POOL *pool, const ENCODING *enc,

+                const char *ptr, const char *end);

+static XML_Bool FASTCALL poolGrow(STRING_POOL *pool);

+static const XML_Char * FASTCALL

+poolCopyString(STRING_POOL *pool, const XML_Char *s);

+static const XML_Char *

+poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n);

+static const XML_Char * FASTCALL

+poolAppendString(STRING_POOL *pool, const XML_Char *s);

+

+static int FASTCALL nextScaffoldPart(XML_Parser parser);

+static XML_Content * build_model(XML_Parser parser);

+static ELEMENT_TYPE *

+getElementType(XML_Parser parser, const ENCODING *enc,

+               const char *ptr, const char *end);

+

+static XML_Parser

+parserCreate(const XML_Char *encodingName,

+             const XML_Memory_Handling_Suite *memsuite,

+             const XML_Char *nameSep,

+             DTD *dtd);

+static void

+parserInit(XML_Parser parser, const XML_Char *encodingName);

+

+#define poolStart(pool) ((pool)->start)

+#define poolEnd(pool) ((pool)->ptr)

+#define poolLength(pool) ((pool)->ptr - (pool)->start)

+#define poolChop(pool) ((void)--(pool->ptr))

+#define poolLastChar(pool) (((pool)->ptr)[-1])

+#define poolDiscard(pool) ((pool)->ptr = (pool)->start)

+#define poolFinish(pool) ((pool)->start = (pool)->ptr)

+#define poolAppendChar(pool, c) \

+  (((pool)->ptr == (pool)->end && !poolGrow(pool)) \

+   ? 0 \

+   : ((*((pool)->ptr)++ = c), 1))

+

+struct XML_ParserStruct {

+  /* The first member must be userData so that the XML_GetUserData

+     macro works. */

+  void *m_userData;

+  void *m_handlerArg;

+  char *m_buffer;

+  const XML_Memory_Handling_Suite m_mem;

+  /* first character to be parsed */

+  const char *m_bufferPtr;

+  /* past last character to be parsed */

+  char *m_bufferEnd;

+  /* allocated end of buffer */

+  const char *m_bufferLim;

+  XML_Index m_parseEndByteIndex;

+  const char *m_parseEndPtr;

+  XML_Char *m_dataBuf;

+  XML_Char *m_dataBufEnd;

+  XML_StartElementHandler m_startElementHandler;

+  XML_EndElementHandler m_endElementHandler;

+  XML_CharacterDataHandler m_characterDataHandler;

+  XML_ProcessingInstructionHandler m_processingInstructionHandler;

+  XML_CommentHandler m_commentHandler;

+  XML_StartCdataSectionHandler m_startCdataSectionHandler;

+  XML_EndCdataSectionHandler m_endCdataSectionHandler;

+  XML_DefaultHandler m_defaultHandler;

+  XML_StartDoctypeDeclHandler m_startDoctypeDeclHandler;

+  XML_EndDoctypeDeclHandler m_endDoctypeDeclHandler;

+  XML_UnparsedEntityDeclHandler m_unparsedEntityDeclHandler;

+  XML_NotationDeclHandler m_notationDeclHandler;

+  XML_StartNamespaceDeclHandler m_startNamespaceDeclHandler;

+  XML_EndNamespaceDeclHandler m_endNamespaceDeclHandler;

+  XML_NotStandaloneHandler m_notStandaloneHandler;

+  XML_ExternalEntityRefHandler m_externalEntityRefHandler;

+  XML_Parser m_externalEntityRefHandlerArg;

+  XML_SkippedEntityHandler m_skippedEntityHandler;

+  XML_UnknownEncodingHandler m_unknownEncodingHandler;

+  XML_ElementDeclHandler m_elementDeclHandler;

+  XML_AttlistDeclHandler m_attlistDeclHandler;

+  XML_EntityDeclHandler m_entityDeclHandler;

+  XML_XmlDeclHandler m_xmlDeclHandler;

+  const ENCODING *m_encoding;

+  INIT_ENCODING m_initEncoding;

+  const ENCODING *m_internalEncoding;

+  const XML_Char *m_protocolEncodingName;

+  XML_Bool m_ns;

+  XML_Bool m_ns_triplets;

+  void *m_unknownEncodingMem;

+  void *m_unknownEncodingData;

+  void *m_unknownEncodingHandlerData;

+  void (XMLCALL *m_unknownEncodingRelease)(void *);

+  PROLOG_STATE m_prologState;

+  Processor *m_processor;

+  enum XML_Error m_errorCode;

+  const char *m_eventPtr;

+  const char *m_eventEndPtr;

+  const char *m_positionPtr;

+  OPEN_INTERNAL_ENTITY *m_openInternalEntities;

+  OPEN_INTERNAL_ENTITY *m_freeInternalEntities;

+  XML_Bool m_defaultExpandInternalEntities;

+  int m_tagLevel;

+  ENTITY *m_declEntity;

+  const XML_Char *m_doctypeName;

+  const XML_Char *m_doctypeSysid;

+  const XML_Char *m_doctypePubid;

+  const XML_Char *m_declAttributeType;

+  const XML_Char *m_declNotationName;

+  const XML_Char *m_declNotationPublicId;

+  ELEMENT_TYPE *m_declElementType;

+  ATTRIBUTE_ID *m_declAttributeId;

+  XML_Bool m_declAttributeIsCdata;

+  XML_Bool m_declAttributeIsId;

+  DTD *m_dtd;

+  const XML_Char *m_curBase;

+  TAG *m_tagStack;

+  TAG *m_freeTagList;

+  BINDING *m_inheritedBindings;

+  BINDING *m_freeBindingList;

+  int m_attsSize;

+  int m_nSpecifiedAtts;

+  int m_idAttIndex;

+  ATTRIBUTE *m_atts;

+  NS_ATT *m_nsAtts;

+  unsigned long m_nsAttsVersion;

+  unsigned char m_nsAttsPower;

+  POSITION m_position;

+  STRING_POOL m_tempPool;

+  STRING_POOL m_temp2Pool;

+  char *m_groupConnector;

+  unsigned int m_groupSize;

+  XML_Char m_namespaceSeparator;

+  XML_Parser m_parentParser;

+  XML_ParsingStatus m_parsingStatus;

+#ifdef XML_DTD

+  XML_Bool m_isParamEntity;

+  XML_Bool m_useForeignDTD;

+  enum XML_ParamEntityParsing m_paramEntityParsing;

+#endif

+};

+

+#define MALLOC(s) (parser->m_mem.malloc_fcn((s)))

+#define REALLOC(p,s) (parser->m_mem.realloc_fcn((p),(s)))

+#define FREE(p) (parser->m_mem.free_fcn((p)))

+

+#define userData (parser->m_userData)

+#define handlerArg (parser->m_handlerArg)

+#define startElementHandler (parser->m_startElementHandler)

+#define endElementHandler (parser->m_endElementHandler)

+#define characterDataHandler (parser->m_characterDataHandler)

+#define processingInstructionHandler \

+        (parser->m_processingInstructionHandler)

+#define commentHandler (parser->m_commentHandler)

+#define startCdataSectionHandler \

+        (parser->m_startCdataSectionHandler)

+#define endCdataSectionHandler (parser->m_endCdataSectionHandler)

+#define defaultHandler (parser->m_defaultHandler)

+#define startDoctypeDeclHandler (parser->m_startDoctypeDeclHandler)

+#define endDoctypeDeclHandler (parser->m_endDoctypeDeclHandler)

+#define unparsedEntityDeclHandler \

+        (parser->m_unparsedEntityDeclHandler)

+#define notationDeclHandler (parser->m_notationDeclHandler)

+#define startNamespaceDeclHandler \

+        (parser->m_startNamespaceDeclHandler)

+#define endNamespaceDeclHandler (parser->m_endNamespaceDeclHandler)

+#define notStandaloneHandler (parser->m_notStandaloneHandler)

+#define externalEntityRefHandler \

+        (parser->m_externalEntityRefHandler)

+#define externalEntityRefHandlerArg \

+        (parser->m_externalEntityRefHandlerArg)

+#define internalEntityRefHandler \

+        (parser->m_internalEntityRefHandler)

+#define skippedEntityHandler (parser->m_skippedEntityHandler)

+#define unknownEncodingHandler (parser->m_unknownEncodingHandler)

+#define elementDeclHandler (parser->m_elementDeclHandler)

+#define attlistDeclHandler (parser->m_attlistDeclHandler)

+#define entityDeclHandler (parser->m_entityDeclHandler)

+#define xmlDeclHandler (parser->m_xmlDeclHandler)

+#define encoding (parser->m_encoding)

+#define initEncoding (parser->m_initEncoding)

+#define internalEncoding (parser->m_internalEncoding)

+#define unknownEncodingMem (parser->m_unknownEncodingMem)

+#define unknownEncodingData (parser->m_unknownEncodingData)

+#define unknownEncodingHandlerData \

+  (parser->m_unknownEncodingHandlerData)

+#define unknownEncodingRelease (parser->m_unknownEncodingRelease)

+#define protocolEncodingName (parser->m_protocolEncodingName)

+#define ns (parser->m_ns)

+#define ns_triplets (parser->m_ns_triplets)

+#define prologState (parser->m_prologState)

+#define processor (parser->m_processor)

+#define errorCode (parser->m_errorCode)

+#define eventPtr (parser->m_eventPtr)

+#define eventEndPtr (parser->m_eventEndPtr)

+#define positionPtr (parser->m_positionPtr)

+#define position (parser->m_position)

+#define openInternalEntities (parser->m_openInternalEntities)

+#define freeInternalEntities (parser->m_freeInternalEntities)

+#define defaultExpandInternalEntities \

+        (parser->m_defaultExpandInternalEntities)

+#define tagLevel (parser->m_tagLevel)

+#define buffer (parser->m_buffer)

+#define bufferPtr (parser->m_bufferPtr)

+#define bufferEnd (parser->m_bufferEnd)

+#define parseEndByteIndex (parser->m_parseEndByteIndex)

+#define parseEndPtr (parser->m_parseEndPtr)

+#define bufferLim (parser->m_bufferLim)

+#define dataBuf (parser->m_dataBuf)

+#define dataBufEnd (parser->m_dataBufEnd)

+#define _dtd (parser->m_dtd)

+#define curBase (parser->m_curBase)

+#define declEntity (parser->m_declEntity)

+#define doctypeName (parser->m_doctypeName)

+#define doctypeSysid (parser->m_doctypeSysid)

+#define doctypePubid (parser->m_doctypePubid)

+#define declAttributeType (parser->m_declAttributeType)

+#define declNotationName (parser->m_declNotationName)

+#define declNotationPublicId (parser->m_declNotationPublicId)

+#define declElementType (parser->m_declElementType)

+#define declAttributeId (parser->m_declAttributeId)

+#define declAttributeIsCdata (parser->m_declAttributeIsCdata)

+#define declAttributeIsId (parser->m_declAttributeIsId)

+#define freeTagList (parser->m_freeTagList)

+#define freeBindingList (parser->m_freeBindingList)

+#define inheritedBindings (parser->m_inheritedBindings)

+#define tagStack (parser->m_tagStack)

+#define atts (parser->m_atts)

+#define attsSize (parser->m_attsSize)

+#define nSpecifiedAtts (parser->m_nSpecifiedAtts)

+#define idAttIndex (parser->m_idAttIndex)

+#define nsAtts (parser->m_nsAtts)

+#define nsAttsVersion (parser->m_nsAttsVersion)

+#define nsAttsPower (parser->m_nsAttsPower)

+#define tempPool (parser->m_tempPool)

+#define temp2Pool (parser->m_temp2Pool)

+#define groupConnector (parser->m_groupConnector)

+#define groupSize (parser->m_groupSize)

+#define namespaceSeparator (parser->m_namespaceSeparator)

+#define parentParser (parser->m_parentParser)

+#define ps_parsing (parser->m_parsingStatus.parsing)

+#define ps_finalBuffer (parser->m_parsingStatus.finalBuffer)

+#ifdef XML_DTD

+#define isParamEntity (parser->m_isParamEntity)

+#define useForeignDTD (parser->m_useForeignDTD)

+#define paramEntityParsing (parser->m_paramEntityParsing)

+#endif /* XML_DTD */

+

+XML_Parser XMLCALL

+XML_ParserCreate(const XML_Char *encodingName)

+{

+  return XML_ParserCreate_MM(encodingName, NULL, NULL);

+}

+

+XML_Parser XMLCALL

+XML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep)

+{

+  XML_Char tmp[2];

+  *tmp = nsSep;

+  return XML_ParserCreate_MM(encodingName, NULL, tmp);

+}

+

+static const XML_Char implicitContext[] = {

+  'x', 'm', 'l', '=', 'h', 't', 't', 'p', ':', '/', '/',

+  'w', 'w', 'w', '.', 'w', '3', '.', 'o', 'r', 'g', '/',

+  'X', 'M', 'L', '/', '1', '9', '9', '8', '/',

+  'n', 'a', 'm', 'e', 's', 'p', 'a', 'c', 'e', '\0'

+};

+

+XML_Parser XMLCALL

+XML_ParserCreate_MM(const XML_Char *encodingName,

+                    const XML_Memory_Handling_Suite *memsuite,

+                    const XML_Char *nameSep)

+{

+  XML_Parser parser = parserCreate(encodingName, memsuite, nameSep, NULL);

+  if (parser != NULL && ns) {

+    /* implicit context only set for root parser, since child

+       parsers (i.e. external entity parsers) will inherit it

+    */

+    if (!setContext(parser, implicitContext)) {

+      XML_ParserFree(parser);

+      return NULL;

+    }

+  }

+  return parser;

+}

+

+static XML_Parser

+parserCreate(const XML_Char *encodingName,

+             const XML_Memory_Handling_Suite *memsuite,

+             const XML_Char *nameSep,

+             DTD *dtd)

+{

+  XML_Parser parser;

+

+  if (memsuite) {

+    XML_Memory_Handling_Suite *mtemp;

+    parser = (XML_Parser)

+      memsuite->malloc_fcn(sizeof(struct XML_ParserStruct));

+    if (parser != NULL) {

+      mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);

+      mtemp->malloc_fcn = memsuite->malloc_fcn;

+      mtemp->realloc_fcn = memsuite->realloc_fcn;

+      mtemp->free_fcn = memsuite->free_fcn;

+    }

+  }

+  else {

+    XML_Memory_Handling_Suite *mtemp;

+    parser = (XML_Parser)malloc(sizeof(struct XML_ParserStruct));

+    if (parser != NULL) {

+      mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);

+      mtemp->malloc_fcn = malloc;

+      mtemp->realloc_fcn = realloc;

+      mtemp->free_fcn = free;

+    }

+  }

+

+  if (!parser)

+    return parser;

+

+  buffer = NULL;

+  bufferLim = NULL;

+

+  attsSize = INIT_ATTS_SIZE;

+  atts = (ATTRIBUTE *)MALLOC(attsSize * sizeof(ATTRIBUTE));

+  if (atts == NULL) {

+    FREE(parser);

+    return NULL;

+  }

+  dataBuf = (XML_Char *)MALLOC(INIT_DATA_BUF_SIZE * sizeof(XML_Char));

+  if (dataBuf == NULL) {

+    FREE(atts);

+    FREE(parser);

+    return NULL;

+  }

+  dataBufEnd = dataBuf + INIT_DATA_BUF_SIZE;

+

+  if (dtd)

+    _dtd = dtd;

+  else {

+    _dtd = dtdCreate(&parser->m_mem);

+    if (_dtd == NULL) {

+      FREE(dataBuf);

+      FREE(atts);

+      FREE(parser);

+      return NULL;

+    }

+  }

+

+  freeBindingList = NULL;

+  freeTagList = NULL;

+  freeInternalEntities = NULL;

+

+  groupSize = 0;

+  groupConnector = NULL;

+

+  unknownEncodingHandler = NULL;

+  unknownEncodingHandlerData = NULL;

+

+  namespaceSeparator = '!';

+  ns = XML_FALSE;

+  ns_triplets = XML_FALSE;

+

+  nsAtts = NULL;

+  nsAttsVersion = 0;

+  nsAttsPower = 0;

+

+  poolInit(&tempPool, &(parser->m_mem));

+  poolInit(&temp2Pool, &(parser->m_mem));

+  parserInit(parser, encodingName);

+

+  if (encodingName && !protocolEncodingName) {

+    XML_ParserFree(parser);

+    return NULL;

+  }

+

+  if (nameSep) {

+    ns = XML_TRUE;

+    internalEncoding = XmlGetInternalEncodingNS();

+    namespaceSeparator = *nameSep;

+  }

+  else {

+    internalEncoding = XmlGetInternalEncoding();

+  }

+

+  return parser;

+}

+

+static void

+parserInit(XML_Parser parser, const XML_Char *encodingName)

+{

+  processor = prologInitProcessor;

+  XmlPrologStateInit(&prologState);

+  protocolEncodingName = (encodingName != NULL

+                          ? poolCopyString(&tempPool, encodingName)

+                          : NULL);

+  curBase = NULL;

+  XmlInitEncoding(&initEncoding, &encoding, 0);

+  userData = NULL;

+  handlerArg = NULL;

+  startElementHandler = NULL;

+  endElementHandler = NULL;

+  characterDataHandler = NULL;

+  processingInstructionHandler = NULL;

+  commentHandler = NULL;

+  startCdataSectionHandler = NULL;

+  endCdataSectionHandler = NULL;

+  defaultHandler = NULL;

+  startDoctypeDeclHandler = NULL;

+  endDoctypeDeclHandler = NULL;

+  unparsedEntityDeclHandler = NULL;

+  notationDeclHandler = NULL;

+  startNamespaceDeclHandler = NULL;

+  endNamespaceDeclHandler = NULL;

+  notStandaloneHandler = NULL;

+  externalEntityRefHandler = NULL;

+  externalEntityRefHandlerArg = parser;

+  skippedEntityHandler = NULL;

+  elementDeclHandler = NULL;

+  attlistDeclHandler = NULL;

+  entityDeclHandler = NULL;

+  xmlDeclHandler = NULL;

+  bufferPtr = buffer;

+  bufferEnd = buffer;

+  parseEndByteIndex = 0;

+  parseEndPtr = NULL;

+  declElementType = NULL;

+  declAttributeId = NULL;

+  declEntity = NULL;

+  doctypeName = NULL;

+  doctypeSysid = NULL;

+  doctypePubid = NULL;

+  declAttributeType = NULL;

+  declNotationName = NULL;

+  declNotationPublicId = NULL;

+  declAttributeIsCdata = XML_FALSE;

+  declAttributeIsId = XML_FALSE;

+  memset(&position, 0, sizeof(POSITION));

+  errorCode = XML_ERROR_NONE;

+  eventPtr = NULL;

+  eventEndPtr = NULL;

+  positionPtr = NULL;

+  openInternalEntities = NULL;

+  defaultExpandInternalEntities = XML_TRUE;

+  tagLevel = 0;

+  tagStack = NULL;

+  inheritedBindings = NULL;

+  nSpecifiedAtts = 0;

+  unknownEncodingMem = NULL;

+  unknownEncodingRelease = NULL;

+  unknownEncodingData = NULL;

+  parentParser = NULL;

+  ps_parsing = XML_INITIALIZED;

+#ifdef XML_DTD

+  isParamEntity = XML_FALSE;

+  useForeignDTD = XML_FALSE;

+  paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;

+#endif

+}

+

+/* moves list of bindings to freeBindingList */

+static void FASTCALL

+moveToFreeBindingList(XML_Parser parser, BINDING *bindings)

+{

+  while (bindings) {

+    BINDING *b = bindings;

+    bindings = bindings->nextTagBinding;

+    b->nextTagBinding = freeBindingList;

+    freeBindingList = b;

+  }

+}

+

+XML_Bool XMLCALL

+XML_ParserReset(XML_Parser parser, const XML_Char *encodingName)

+{

+  TAG *tStk;

+  OPEN_INTERNAL_ENTITY *openEntityList;

+  if (parentParser)

+    return XML_FALSE;

+  /* move tagStack to freeTagList */

+  tStk = tagStack;

+  while (tStk) {

+    TAG *tag = tStk;

+    tStk = tStk->parent;

+    tag->parent = freeTagList;

+    moveToFreeBindingList(parser, tag->bindings);

+    tag->bindings = NULL;

+    freeTagList = tag;

+  }

+  /* move openInternalEntities to freeInternalEntities */

+  openEntityList = openInternalEntities;

+  while (openEntityList) {

+    OPEN_INTERNAL_ENTITY *openEntity = openEntityList;

+    openEntityList = openEntity->next;

+    openEntity->next = freeInternalEntities;

+    freeInternalEntities = openEntity;

+  }

+  moveToFreeBindingList(parser, inheritedBindings);

+  FREE(unknownEncodingMem);

+  if (unknownEncodingRelease)

+    unknownEncodingRelease(unknownEncodingData);

+  poolClear(&tempPool);

+  poolClear(&temp2Pool);

+  parserInit(parser, encodingName);

+  dtdReset(_dtd, &parser->m_mem);

+  return setContext(parser, implicitContext);

+}

+

+enum XML_Status XMLCALL

+XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName)

+{

+  /* Block after XML_Parse()/XML_ParseBuffer() has been called.

+     XXX There's no way for the caller to determine which of the

+     XXX possible error cases caused the XML_STATUS_ERROR return.

+  */

+  if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)

+    return XML_STATUS_ERROR;

+  if (encodingName == NULL)

+    protocolEncodingName = NULL;

+  else {

+    protocolEncodingName = poolCopyString(&tempPool, encodingName);

+    if (!protocolEncodingName)

+      return XML_STATUS_ERROR;

+  }

+  return XML_STATUS_OK;

+}

+

+XML_Parser XMLCALL

+XML_ExternalEntityParserCreate(XML_Parser oldParser,

+                               const XML_Char *context,

+                               const XML_Char *encodingName)

+{

+  XML_Parser parser = oldParser;

+  DTD *newDtd = NULL;

+  DTD *oldDtd = _dtd;

+  XML_StartElementHandler oldStartElementHandler = startElementHandler;

+  XML_EndElementHandler oldEndElementHandler = endElementHandler;

+  XML_CharacterDataHandler oldCharacterDataHandler = characterDataHandler;

+  XML_ProcessingInstructionHandler oldProcessingInstructionHandler

+      = processingInstructionHandler;

+  XML_CommentHandler oldCommentHandler = commentHandler;

+  XML_StartCdataSectionHandler oldStartCdataSectionHandler

+      = startCdataSectionHandler;

+  XML_EndCdataSectionHandler oldEndCdataSectionHandler

+      = endCdataSectionHandler;

+  XML_DefaultHandler oldDefaultHandler = defaultHandler;

+  XML_UnparsedEntityDeclHandler oldUnparsedEntityDeclHandler

+      = unparsedEntityDeclHandler;

+  XML_NotationDeclHandler oldNotationDeclHandler = notationDeclHandler;

+  XML_StartNamespaceDeclHandler oldStartNamespaceDeclHandler

+      = startNamespaceDeclHandler;

+  XML_EndNamespaceDeclHandler oldEndNamespaceDeclHandler

+      = endNamespaceDeclHandler;

+  XML_NotStandaloneHandler oldNotStandaloneHandler = notStandaloneHandler;

+  XML_ExternalEntityRefHandler oldExternalEntityRefHandler

+      = externalEntityRefHandler;

+  XML_SkippedEntityHandler oldSkippedEntityHandler = skippedEntityHandler;

+  XML_UnknownEncodingHandler oldUnknownEncodingHandler

+      = unknownEncodingHandler;

+  XML_ElementDeclHandler oldElementDeclHandler = elementDeclHandler;

+  XML_AttlistDeclHandler oldAttlistDeclHandler = attlistDeclHandler;

+  XML_EntityDeclHandler oldEntityDeclHandler = entityDeclHandler;

+  XML_XmlDeclHandler oldXmlDeclHandler = xmlDeclHandler;

+  ELEMENT_TYPE * oldDeclElementType = declElementType;

+

+  void *oldUserData = userData;

+  void *oldHandlerArg = handlerArg;

+  XML_Bool oldDefaultExpandInternalEntities = defaultExpandInternalEntities;

+  XML_Parser oldExternalEntityRefHandlerArg = externalEntityRefHandlerArg;

+#ifdef XML_DTD

+  enum XML_ParamEntityParsing oldParamEntityParsing = paramEntityParsing;

+  int oldInEntityValue = prologState.inEntityValue;

+#endif

+  XML_Bool oldns_triplets = ns_triplets;

+

+#ifdef XML_DTD

+  if (!context)

+    newDtd = oldDtd;

+#endif /* XML_DTD */

+

+  /* Note that the magical uses of the pre-processor to make field

+     access look more like C++ require that `parser' be overwritten

+     here.  This makes this function more painful to follow than it

+     would be otherwise.

+  */

+  if (ns) {

+    XML_Char tmp[2];

+    *tmp = namespaceSeparator;

+    parser = parserCreate(encodingName, &parser->m_mem, tmp, newDtd);

+  }

+  else {

+    parser = parserCreate(encodingName, &parser->m_mem, NULL, newDtd);

+  }

+

+  if (!parser)

+    return NULL;

+

+  startElementHandler = oldStartElementHandler;

+  endElementHandler = oldEndElementHandler;

+  characterDataHandler = oldCharacterDataHandler;

+  processingInstructionHandler = oldProcessingInstructionHandler;

+  commentHandler = oldCommentHandler;

+  startCdataSectionHandler = oldStartCdataSectionHandler;

+  endCdataSectionHandler = oldEndCdataSectionHandler;

+  defaultHandler = oldDefaultHandler;

+  unparsedEntityDeclHandler = oldUnparsedEntityDeclHandler;

+  notationDeclHandler = oldNotationDeclHandler;

+  startNamespaceDeclHandler = oldStartNamespaceDeclHandler;

+  endNamespaceDeclHandler = oldEndNamespaceDeclHandler;

+  notStandaloneHandler = oldNotStandaloneHandler;

+  externalEntityRefHandler = oldExternalEntityRefHandler;

+  skippedEntityHandler = oldSkippedEntityHandler;

+  unknownEncodingHandler = oldUnknownEncodingHandler;

+  elementDeclHandler = oldElementDeclHandler;

+  attlistDeclHandler = oldAttlistDeclHandler;

+  entityDeclHandler = oldEntityDeclHandler;

+  xmlDeclHandler = oldXmlDeclHandler;

+  declElementType = oldDeclElementType;

+  userData = oldUserData;

+  if (oldUserData == oldHandlerArg)

+    handlerArg = userData;

+  else

+    handlerArg = parser;

+  if (oldExternalEntityRefHandlerArg != oldParser)

+    externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;

+  defaultExpandInternalEntities = oldDefaultExpandInternalEntities;

+  ns_triplets = oldns_triplets;

+  parentParser = oldParser;

+#ifdef XML_DTD

+  paramEntityParsing = oldParamEntityParsing;

+  prologState.inEntityValue = oldInEntityValue;

+  if (context) {

+#endif /* XML_DTD */

+    if (!dtdCopy(_dtd, oldDtd, &parser->m_mem)

+      || !setContext(parser, context)) {

+      XML_ParserFree(parser);

+      return NULL;

+    }

+    processor = externalEntityInitProcessor;

+#ifdef XML_DTD

+  }

+  else {

+    /* The DTD instance referenced by _dtd is shared between the document's

+       root parser and external PE parsers, therefore one does not need to

+       call setContext. In addition, one also *must* not call setContext,

+       because this would overwrite existing prefix->binding pointers in

+       _dtd with ones that get destroyed with the external PE parser.

+       This would leave those prefixes with dangling pointers.

+    */

+    isParamEntity = XML_TRUE;

+    XmlPrologStateInitExternalEntity(&prologState);

+    processor = externalParEntInitProcessor;

+  }

+#endif /* XML_DTD */

+  return parser;

+}

+

+static void FASTCALL

+destroyBindings(BINDING *bindings, XML_Parser parser)

+{

+  for (;;) {

+    BINDING *b = bindings;

+    if (!b)

+      break;

+    bindings = b->nextTagBinding;

+    FREE(b->uri);

+    FREE(b);

+  }

+}

+

+void XMLCALL

+XML_ParserFree(XML_Parser parser)

+{

+  TAG *tagList;

+  OPEN_INTERNAL_ENTITY *entityList;

+  if (parser == NULL)

+    return;

+  /* free tagStack and freeTagList */

+  tagList = tagStack;

+  for (;;) {

+    TAG *p;

+    if (tagList == NULL) {

+      if (freeTagList == NULL)

+        break;

+      tagList = freeTagList;

+      freeTagList = NULL;

+    }

+    p = tagList;

+    tagList = tagList->parent;

+    FREE(p->buf);

+    destroyBindings(p->bindings, parser);

+    FREE(p);

+  }

+  /* free openInternalEntities and freeInternalEntities */

+  entityList = openInternalEntities;

+  for (;;) {

+    OPEN_INTERNAL_ENTITY *openEntity;

+    if (entityList == NULL) {

+      if (freeInternalEntities == NULL)

+        break;

+      entityList = freeInternalEntities;

+      freeInternalEntities = NULL;

+    }

+    openEntity = entityList;

+    entityList = entityList->next;

+    FREE(openEntity);

+  }

+

+  destroyBindings(freeBindingList, parser);

+  destroyBindings(inheritedBindings, parser);

+  poolDestroy(&tempPool);

+  poolDestroy(&temp2Pool);

+#ifdef XML_DTD

+  /* external parameter entity parsers share the DTD structure

+     parser->m_dtd with the root parser, so we must not destroy it

+  */

+  if (!isParamEntity && _dtd)

+#else

+  if (_dtd)

+#endif /* XML_DTD */

+    dtdDestroy(_dtd, (XML_Bool)!parentParser, &parser->m_mem);

+  FREE((void *)atts);

+  FREE(groupConnector);

+  FREE(buffer);

+  FREE(dataBuf);

+  FREE(nsAtts);

+  FREE(unknownEncodingMem);

+  if (unknownEncodingRelease)

+    unknownEncodingRelease(unknownEncodingData);

+  FREE(parser);

+}

+

+void XMLCALL

+XML_UseParserAsHandlerArg(XML_Parser parser)

+{

+  handlerArg = parser;

+}

+

+enum XML_Error XMLCALL

+XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD)

+{

+#ifdef XML_DTD

+  /* block after XML_Parse()/XML_ParseBuffer() has been called */

+  if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)

+    return XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING;

+  useForeignDTD = useDTD;

+  return XML_ERROR_NONE;

+#else

+  return XML_ERROR_FEATURE_REQUIRES_XML_DTD;

+#endif

+}

+

+void XMLCALL

+XML_SetReturnNSTriplet(XML_Parser parser, int do_nst)

+{

+  /* block after XML_Parse()/XML_ParseBuffer() has been called */

+  if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)

+    return;

+  ns_triplets = do_nst ? XML_TRUE : XML_FALSE;

+}

+

+void XMLCALL

+XML_SetUserData(XML_Parser parser, void *p)

+{

+  if (handlerArg == userData)

+    handlerArg = userData = p;

+  else

+    userData = p;

+}

+

+enum XML_Status XMLCALL

+XML_SetBase(XML_Parser parser, const XML_Char *p)

+{

+  if (p) {

+    p = poolCopyString(&_dtd->pool, p);

+    if (!p)

+      return XML_STATUS_ERROR;

+    curBase = p;

+  }

+  else

+    curBase = NULL;

+  return XML_STATUS_OK;

+}

+

+const XML_Char * XMLCALL

+XML_GetBase(XML_Parser parser)

+{

+  return curBase;

+}

+

+int XMLCALL

+XML_GetSpecifiedAttributeCount(XML_Parser parser)

+{

+  return nSpecifiedAtts;

+}

+

+int XMLCALL

+XML_GetIdAttributeIndex(XML_Parser parser)

+{

+  return idAttIndex;

+}

+

+void XMLCALL

+XML_SetElementHandler(XML_Parser parser,

+                      XML_StartElementHandler start,

+                      XML_EndElementHandler end)

+{

+  startElementHandler = start;

+  endElementHandler = end;

+}

+

+void XMLCALL

+XML_SetStartElementHandler(XML_Parser parser,

+                           XML_StartElementHandler start) {

+  startElementHandler = start;

+}

+

+void XMLCALL

+XML_SetEndElementHandler(XML_Parser parser,

+                         XML_EndElementHandler end) {

+  endElementHandler = end;

+}

+

+void XMLCALL

+XML_SetCharacterDataHandler(XML_Parser parser,

+                            XML_CharacterDataHandler handler)

+{

+  characterDataHandler = handler;

+}

+

+void XMLCALL

+XML_SetProcessingInstructionHandler(XML_Parser parser,

+                                    XML_ProcessingInstructionHandler handler)

+{

+  processingInstructionHandler = handler;

+}

+

+void XMLCALL

+XML_SetCommentHandler(XML_Parser parser,

+                      XML_CommentHandler handler)

+{

+  commentHandler = handler;

+}

+

+void XMLCALL

+XML_SetCdataSectionHandler(XML_Parser parser,

+                           XML_StartCdataSectionHandler start,

+                           XML_EndCdataSectionHandler end)

+{

+  startCdataSectionHandler = start;

+  endCdataSectionHandler = end;

+}

+

+void XMLCALL

+XML_SetStartCdataSectionHandler(XML_Parser parser,

+                                XML_StartCdataSectionHandler start) {

+  startCdataSectionHandler = start;

+}

+

+void XMLCALL

+XML_SetEndCdataSectionHandler(XML_Parser parser,

+                              XML_EndCdataSectionHandler end) {

+  endCdataSectionHandler = end;

+}

+

+void XMLCALL

+XML_SetDefaultHandler(XML_Parser parser,

+                      XML_DefaultHandler handler)

+{

+  defaultHandler = handler;

+  defaultExpandInternalEntities = XML_FALSE;

+}

+

+void XMLCALL

+XML_SetDefaultHandlerExpand(XML_Parser parser,

+                            XML_DefaultHandler handler)

+{

+  defaultHandler = handler;

+  defaultExpandInternalEntities = XML_TRUE;

+}

+

+void XMLCALL

+XML_SetDoctypeDeclHandler(XML_Parser parser,

+                          XML_StartDoctypeDeclHandler start,

+                          XML_EndDoctypeDeclHandler end)

+{

+  startDoctypeDeclHandler = start;

+  endDoctypeDeclHandler = end;

+}

+

+void XMLCALL

+XML_SetStartDoctypeDeclHandler(XML_Parser parser,

+                               XML_StartDoctypeDeclHandler start) {

+  startDoctypeDeclHandler = start;

+}

+

+void XMLCALL

+XML_SetEndDoctypeDeclHandler(XML_Parser parser,

+                             XML_EndDoctypeDeclHandler end) {

+  endDoctypeDeclHandler = end;

+}

+

+void XMLCALL

+XML_SetUnparsedEntityDeclHandler(XML_Parser parser,

+                                 XML_UnparsedEntityDeclHandler handler)

+{

+  unparsedEntityDeclHandler = handler;

+}

+

+void XMLCALL

+XML_SetNotationDeclHandler(XML_Parser parser,

+                           XML_NotationDeclHandler handler)

+{

+  notationDeclHandler = handler;

+}

+

+void XMLCALL

+XML_SetNamespaceDeclHandler(XML_Parser parser,

+                            XML_StartNamespaceDeclHandler start,

+                            XML_EndNamespaceDeclHandler end)

+{

+  startNamespaceDeclHandler = start;

+  endNamespaceDeclHandler = end;

+}

+

+void XMLCALL

+XML_SetStartNamespaceDeclHandler(XML_Parser parser,

+                                 XML_StartNamespaceDeclHandler start) {

+  startNamespaceDeclHandler = start;

+}

+

+void XMLCALL

+XML_SetEndNamespaceDeclHandler(XML_Parser parser,

+                               XML_EndNamespaceDeclHandler end) {

+  endNamespaceDeclHandler = end;

+}

+

+void XMLCALL

+XML_SetNotStandaloneHandler(XML_Parser parser,

+                            XML_NotStandaloneHandler handler)

+{

+  notStandaloneHandler = handler;

+}

+

+void XMLCALL

+XML_SetExternalEntityRefHandler(XML_Parser parser,

+                                XML_ExternalEntityRefHandler handler)

+{

+  externalEntityRefHandler = handler;

+}

+

+void XMLCALL

+XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg)

+{

+  if (arg)

+    externalEntityRefHandlerArg = (XML_Parser)arg;

+  else

+    externalEntityRefHandlerArg = parser;

+}

+

+void XMLCALL

+XML_SetSkippedEntityHandler(XML_Parser parser,

+                            XML_SkippedEntityHandler handler)

+{

+  skippedEntityHandler = handler;

+}

+

+void XMLCALL

+XML_SetUnknownEncodingHandler(XML_Parser parser,

+                              XML_UnknownEncodingHandler handler,

+                              void *data)

+{

+  unknownEncodingHandler = handler;

+  unknownEncodingHandlerData = data;

+}

+

+void XMLCALL

+XML_SetElementDeclHandler(XML_Parser parser,

+                          XML_ElementDeclHandler eldecl)

+{

+  elementDeclHandler = eldecl;

+}

+

+void XMLCALL

+XML_SetAttlistDeclHandler(XML_Parser parser,

+                          XML_AttlistDeclHandler attdecl)

+{

+  attlistDeclHandler = attdecl;

+}

+

+void XMLCALL

+XML_SetEntityDeclHandler(XML_Parser parser,

+                         XML_EntityDeclHandler handler)

+{

+  entityDeclHandler = handler;

+}

+

+void XMLCALL

+XML_SetXmlDeclHandler(XML_Parser parser,

+                      XML_XmlDeclHandler handler) {

+  xmlDeclHandler = handler;

+}

+

+int XMLCALL

+XML_SetParamEntityParsing(XML_Parser parser,

+                          enum XML_ParamEntityParsing peParsing)

+{

+  /* block after XML_Parse()/XML_ParseBuffer() has been called */

+  if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)

+    return 0;

+#ifdef XML_DTD

+  paramEntityParsing = peParsing;

+  return 1;

+#else

+  return peParsing == XML_PARAM_ENTITY_PARSING_NEVER;

+#endif

+}

+

+enum XML_Status XMLCALL

+XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)

+{

+  switch (ps_parsing) {

+  case XML_SUSPENDED:

+    errorCode = XML_ERROR_SUSPENDED;

+    return XML_STATUS_ERROR;

+  case XML_FINISHED:

+    errorCode = XML_ERROR_FINISHED;

+    return XML_STATUS_ERROR;

+  default:

+    ps_parsing = XML_PARSING;

+  }

+

+  if (len == 0) {

+    ps_finalBuffer = (XML_Bool)isFinal;

+    if (!isFinal)

+      return XML_STATUS_OK;

+    positionPtr = bufferPtr;

+    parseEndPtr = bufferEnd;

+

+    /* If data are left over from last buffer, and we now know that these

+       data are the final chunk of input, then we have to check them again

+       to detect errors based on that fact.

+    */

+    errorCode = processor(parser, bufferPtr, parseEndPtr, &bufferPtr);

+

+    if (errorCode == XML_ERROR_NONE) {

+      switch (ps_parsing) {

+      case XML_SUSPENDED:

+        XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);

+        positionPtr = bufferPtr;

+        return XML_STATUS_SUSPENDED;

+      case XML_INITIALIZED:

+      case XML_PARSING:

+        ps_parsing = XML_FINISHED;

+        /* fall through */

+      default:

+        return XML_STATUS_OK;

+      }

+    }

+    eventEndPtr = eventPtr;

+    processor = errorProcessor;

+    return XML_STATUS_ERROR;

+  }

+#ifndef XML_CONTEXT_BYTES

+  else if (bufferPtr == bufferEnd) {

+    const char *end;

+    int nLeftOver;

+    enum XML_Error result;

+    parseEndByteIndex += len;

+    positionPtr = s;

+    ps_finalBuffer = (XML_Bool)isFinal;

+

+    errorCode = processor(parser, s, parseEndPtr = s + len, &end);

+

+    if (errorCode != XML_ERROR_NONE) {

+      eventEndPtr = eventPtr;

+      processor = errorProcessor;

+      return XML_STATUS_ERROR;

+    }

+    else {

+      switch (ps_parsing) {

+      case XML_SUSPENDED:

+        result = XML_STATUS_SUSPENDED;

+        break;

+      case XML_INITIALIZED:

+      case XML_PARSING:

+        result = XML_STATUS_OK;

+        if (isFinal) {

+          ps_parsing = XML_FINISHED;

+          return result;

+        }

+        break;

+      default:

+        /* XML_FINISHED case required by compiler - but not tested - djv */

+        return XML_STATUS_OK;

+      }

+    }

+

+    XmlUpdatePosition(encoding, positionPtr, end, &position);

+    nLeftOver = s + len - end;

+    if (nLeftOver) {

+      if (buffer == NULL || nLeftOver > bufferLim - buffer) {

+        /* FIXME avoid integer overflow */

+        char *temp;

+        temp = (buffer == NULL

+                ? (char *)MALLOC(len * 2)

+                : (char *)REALLOC(buffer, len * 2));

+        if (temp == NULL) {

+          errorCode = XML_ERROR_NO_MEMORY;

+          return XML_STATUS_ERROR;

+        }

+        buffer = temp;

+        if (!buffer) {

+          errorCode = XML_ERROR_NO_MEMORY;

+          eventPtr = eventEndPtr = NULL;

+          processor = errorProcessor;

+          return XML_STATUS_ERROR;

+        }

+        bufferLim = buffer + len * 2;

+      }

+      memcpy(buffer, end, nLeftOver);

+    }

+    bufferPtr = buffer;

+    bufferEnd = buffer + nLeftOver;

+    positionPtr = bufferPtr;

+    parseEndPtr = bufferEnd;

+    eventPtr = bufferPtr;

+    eventEndPtr = bufferPtr;

+    return result;

+  }

+#endif  /* not defined XML_CONTEXT_BYTES */

+  else {

+    void *buff = XML_GetBuffer(parser, len);

+    if (buff == NULL)

+      return XML_STATUS_ERROR;

+    else {

+      memcpy(buff, s, len);

+      return XML_ParseBuffer(parser, len, isFinal);

+    }

+  }

+}

+

+enum XML_Status XMLCALL

+XML_ParseBuffer(XML_Parser parser, int len, int isFinal)

+{

+  const char *start;

+  enum XML_Status result = XML_STATUS_OK;

+

+  switch (ps_parsing) {

+  case XML_SUSPENDED:

+    errorCode = XML_ERROR_SUSPENDED;

+    return XML_STATUS_ERROR;

+  case XML_FINISHED:

+    errorCode = XML_ERROR_FINISHED;

+    return XML_STATUS_ERROR;

+  default:

+    ps_parsing = XML_PARSING;

+  }

+

+  start = bufferPtr;

+  positionPtr = start;

+  bufferEnd += len;

+  parseEndPtr = bufferEnd;

+  parseEndByteIndex += len;

+  ps_finalBuffer = (XML_Bool)isFinal;

+

+  errorCode = processor(parser, start, parseEndPtr, &bufferPtr);

+

+  if (errorCode != XML_ERROR_NONE) {

+    eventEndPtr = eventPtr;

+    processor = errorProcessor;

+    return XML_STATUS_ERROR;

+  }

+  else {

+    switch (ps_parsing) {

+    case XML_SUSPENDED:

+      result = XML_STATUS_SUSPENDED;

+      break;

+    case XML_INITIALIZED:

+    case XML_PARSING:

+      if (isFinal) {

+        ps_parsing = XML_FINISHED;

+        return result;

+      }

+    default: ;  /* should not happen */

+    }

+  }

+

+  XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);

+  positionPtr = bufferPtr;

+  return result;

+}

+

+void * XMLCALL

+XML_GetBuffer(XML_Parser parser, int len)

+{

+  switch (ps_parsing) {

+  case XML_SUSPENDED:

+    errorCode = XML_ERROR_SUSPENDED;

+    return NULL;

+  case XML_FINISHED:

+    errorCode = XML_ERROR_FINISHED;

+    return NULL;

+  default: ;

+  }

+

+  if (len > bufferLim - bufferEnd) {

+    /* FIXME avoid integer overflow */

+    int neededSize = len + (int)(bufferEnd - bufferPtr);

+#ifdef XML_CONTEXT_BYTES

+    int keep = (int)(bufferPtr - buffer);

+

+    if (keep > XML_CONTEXT_BYTES)

+      keep = XML_CONTEXT_BYTES;

+    neededSize += keep;

+#endif  /* defined XML_CONTEXT_BYTES */

+    if (neededSize  <= bufferLim - buffer) {

+#ifdef XML_CONTEXT_BYTES

+      if (keep < bufferPtr - buffer) {

+        int offset = (int)(bufferPtr - buffer) - keep;

+        memmove(buffer, &buffer[offset], bufferEnd - bufferPtr + keep);

+        bufferEnd -= offset;

+        bufferPtr -= offset;

+      }

+#else

+      memmove(buffer, bufferPtr, bufferEnd - bufferPtr);

+      bufferEnd = buffer + (bufferEnd - bufferPtr);

+      bufferPtr = buffer;

+#endif  /* not defined XML_CONTEXT_BYTES */

+    }

+    else {

+      char *newBuf;

+      int bufferSize = (int)(bufferLim - bufferPtr);

+      if (bufferSize == 0)

+        bufferSize = INIT_BUFFER_SIZE;

+      do {

+        bufferSize *= 2;

+      } while (bufferSize < neededSize);

+      newBuf = (char *)MALLOC(bufferSize);

+      if (newBuf == 0) {

+        errorCode = XML_ERROR_NO_MEMORY;

+        return NULL;

+      }

+      bufferLim = newBuf + bufferSize;

+#ifdef XML_CONTEXT_BYTES

+      if (bufferPtr) {

+        int keep = (int)(bufferPtr - buffer);

+        if (keep > XML_CONTEXT_BYTES)

+          keep = XML_CONTEXT_BYTES;

+        memcpy(newBuf, &bufferPtr[-keep], bufferEnd - bufferPtr + keep);

+        FREE(buffer);

+        buffer = newBuf;

+        bufferEnd = buffer + (bufferEnd - bufferPtr) + keep;

+        bufferPtr = buffer + keep;

+      }

+      else {

+        bufferEnd = newBuf + (bufferEnd - bufferPtr);

+        bufferPtr = buffer = newBuf;

+      }

+#else

+      if (bufferPtr) {

+        memcpy(newBuf, bufferPtr, bufferEnd - bufferPtr);

+        FREE(buffer);

+      }

+      bufferEnd = newBuf + (bufferEnd - bufferPtr);

+      bufferPtr = buffer = newBuf;

+#endif  /* not defined XML_CONTEXT_BYTES */

+    }

+  }

+  return bufferEnd;

+}

+

+enum XML_Status XMLCALL

+XML_StopParser(XML_Parser parser, XML_Bool resumable)

+{

+  switch (ps_parsing) {

+  case XML_SUSPENDED:

+    if (resumable) {

+      errorCode = XML_ERROR_SUSPENDED;

+      return XML_STATUS_ERROR;

+    }

+    ps_parsing = XML_FINISHED;

+    break;

+  case XML_FINISHED:

+    errorCode = XML_ERROR_FINISHED;

+    return XML_STATUS_ERROR;

+  default:

+    if (resumable) {

+#ifdef XML_DTD

+      if (isParamEntity) {

+        errorCode = XML_ERROR_SUSPEND_PE;

+        return XML_STATUS_ERROR;

+      }

+#endif

+      ps_parsing = XML_SUSPENDED;

+    }

+    else

+      ps_parsing = XML_FINISHED;

+  }

+  return XML_STATUS_OK;

+}

+

+enum XML_Status XMLCALL

+XML_ResumeParser(XML_Parser parser)

+{

+  enum XML_Status result = XML_STATUS_OK;

+

+  if (ps_parsing != XML_SUSPENDED) {

+    errorCode = XML_ERROR_NOT_SUSPENDED;

+    return XML_STATUS_ERROR;

+  }

+  ps_parsing = XML_PARSING;

+

+  errorCode = processor(parser, bufferPtr, parseEndPtr, &bufferPtr);

+

+  if (errorCode != XML_ERROR_NONE) {

+    eventEndPtr = eventPtr;

+    processor = errorProcessor;

+    return XML_STATUS_ERROR;

+  }

+  else {

+    switch (ps_parsing) {

+    case XML_SUSPENDED:

+      result = XML_STATUS_SUSPENDED;

+      break;

+    case XML_INITIALIZED:

+    case XML_PARSING:

+      if (ps_finalBuffer) {

+        ps_parsing = XML_FINISHED;

+        return result;

+      }

+    default: ;

+    }

+  }

+

+  XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);

+  positionPtr = bufferPtr;

+  return result;

+}

+

+void XMLCALL

+XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status)

+{

+  assert(status != NULL);

+  *status = parser->m_parsingStatus;

+}

+

+enum XML_Error XMLCALL

+XML_GetErrorCode(XML_Parser parser)

+{

+  return errorCode;

+}

+

+XML_Index XMLCALL

+XML_GetCurrentByteIndex(XML_Parser parser)

+{

+  if (eventPtr)

+    return parseEndByteIndex - (parseEndPtr - eventPtr);

+  return -1;

+}

+

+int XMLCALL

+XML_GetCurrentByteCount(XML_Parser parser)

+{

+  if (eventEndPtr && eventPtr)

+    return (int)(eventEndPtr - eventPtr);

+  return 0;

+}

+

+const char * XMLCALL

+XML_GetInputContext(XML_Parser parser, int *offset, int *size)

+{

+#ifdef XML_CONTEXT_BYTES

+  if (eventPtr && buffer) {

+    *offset = (int)(eventPtr - buffer);

+    *size   = (int)(bufferEnd - buffer);

+    return buffer;

+  }

+#endif /* defined XML_CONTEXT_BYTES */

+  return (char *) 0;

+}

+

+XML_Size XMLCALL

+XML_GetCurrentLineNumber(XML_Parser parser)

+{

+  if (eventPtr && eventPtr >= positionPtr) {

+    XmlUpdatePosition(encoding, positionPtr, eventPtr, &position);

+    positionPtr = eventPtr;

+  }

+  return position.lineNumber + 1;

+}

+

+XML_Size XMLCALL

+XML_GetCurrentColumnNumber(XML_Parser parser)

+{

+  if (eventPtr && eventPtr >= positionPtr) {

+    XmlUpdatePosition(encoding, positionPtr, eventPtr, &position);

+    positionPtr = eventPtr;

+  }

+  return position.columnNumber;

+}

+

+void XMLCALL

+XML_FreeContentModel(XML_Parser parser, XML_Content *model)

+{

+  FREE(model);

+}

+

+void * XMLCALL

+XML_MemMalloc(XML_Parser parser, size_t size)

+{

+  return MALLOC(size);

+}

+

+void * XMLCALL

+XML_MemRealloc(XML_Parser parser, void *ptr, size_t size)

+{

+  return REALLOC(ptr, size);

+}

+

+void XMLCALL

+XML_MemFree(XML_Parser parser, void *ptr)

+{

+  FREE(ptr);

+}

+

+void XMLCALL

+XML_DefaultCurrent(XML_Parser parser)

+{

+  if (defaultHandler) {

+    if (openInternalEntities)

+      reportDefault(parser,

+                    internalEncoding,

+                    openInternalEntities->internalEventPtr,

+                    openInternalEntities->internalEventEndPtr);

+    else

+      reportDefault(parser, encoding, eventPtr, eventEndPtr);

+  }

+}

+

+const XML_LChar * XMLCALL

+XML_ErrorString(enum XML_Error code)

+{

+  static const XML_LChar* const message[] = {

+    0,

+    XML_L("out of memory"),

+    XML_L("syntax error"),

+    XML_L("no element found"),

+    XML_L("not well-formed (invalid token)"),

+    XML_L("unclosed token"),

+    XML_L("partial character"),

+    XML_L("mismatched tag"),

+    XML_L("duplicate attribute"),

+    XML_L("junk after document element"),

+    XML_L("illegal parameter entity reference"),

+    XML_L("undefined entity"),

+    XML_L("recursive entity reference"),

+    XML_L("asynchronous entity"),

+    XML_L("reference to invalid character number"),

+    XML_L("reference to binary entity"),

+    XML_L("reference to external entity in attribute"),

+    XML_L("XML or text declaration not at start of entity"),

+    XML_L("unknown encoding"),

+    XML_L("encoding specified in XML declaration is incorrect"),

+    XML_L("unclosed CDATA section"),

+    XML_L("error in processing external entity reference"),

+    XML_L("document is not standalone"),

+    XML_L("unexpected parser state - please send a bug report"),

+    XML_L("entity declared in parameter entity"),

+    XML_L("requested feature requires XML_DTD support in Expat"),

+    XML_L("cannot change setting once parsing has begun"),

+    XML_L("unbound prefix"),

+    XML_L("must not undeclare prefix"),

+    XML_L("incomplete markup in parameter entity"),

+    XML_L("XML declaration not well-formed"),

+    XML_L("text declaration not well-formed"),

+    XML_L("illegal character(s) in public id"),

+    XML_L("parser suspended"),

+    XML_L("parser not suspended"),

+    XML_L("parsing aborted"),

+    XML_L("parsing finished"),

+    XML_L("cannot suspend in external parameter entity"),

+    XML_L("reserved prefix (xml) must not be undeclared or bound to another namespace name"),

+    XML_L("reserved prefix (xmlns) must not be declared or undeclared"),

+    XML_L("prefix must not be bound to one of the reserved namespace names")

+  };

+  if (code > 0 && code < sizeof(message)/sizeof(message[0]))

+    return message[code];

+  return NULL;

+}

+

+const XML_LChar * XMLCALL

+XML_ExpatVersion(void) {

+

+  /* V1 is used to string-ize the version number. However, it would

+     string-ize the actual version macro *names* unless we get them

+     substituted before being passed to V1. CPP is defined to expand

+     a macro, then rescan for more expansions. Thus, we use V2 to expand

+     the version macros, then CPP will expand the resulting V1() macro

+     with the correct numerals. */

+  /* ### I'm assuming cpp is portable in this respect... */

+

+#define V1(a,b,c) XML_L(#a)XML_L(".")XML_L(#b)XML_L(".")XML_L(#c)

+#define V2(a,b,c) XML_L("expat_")V1(a,b,c)

+

+  return V2(XML_MAJOR_VERSION, XML_MINOR_VERSION, XML_MICRO_VERSION);

+

+#undef V1

+#undef V2

+}

+

+XML_Expat_Version XMLCALL

+XML_ExpatVersionInfo(void)

+{

+  XML_Expat_Version version;

+

+  version.major = XML_MAJOR_VERSION;

+  version.minor = XML_MINOR_VERSION;

+  version.micro = XML_MICRO_VERSION;

+

+  return version;

+}

+

+const XML_Feature * XMLCALL

+XML_GetFeatureList(void)

+{

+  static const XML_Feature features[] = {

+    {XML_FEATURE_SIZEOF_XML_CHAR,  XML_L("sizeof(XML_Char)"),

+     sizeof(XML_Char)},

+    {XML_FEATURE_SIZEOF_XML_LCHAR, XML_L("sizeof(XML_LChar)"),

+     sizeof(XML_LChar)},

+#ifdef XML_UNICODE

+    {XML_FEATURE_UNICODE,          XML_L("XML_UNICODE"), 0},

+#endif

+#ifdef XML_UNICODE_WCHAR_T

+    {XML_FEATURE_UNICODE_WCHAR_T,  XML_L("XML_UNICODE_WCHAR_T"), 0},

+#endif

+#ifdef XML_DTD

+    {XML_FEATURE_DTD,              XML_L("XML_DTD"), 0},

+#endif

+#ifdef XML_CONTEXT_BYTES

+    {XML_FEATURE_CONTEXT_BYTES,    XML_L("XML_CONTEXT_BYTES"),

+     XML_CONTEXT_BYTES},

+#endif

+#ifdef XML_MIN_SIZE

+    {XML_FEATURE_MIN_SIZE,         XML_L("XML_MIN_SIZE"), 0},

+#endif

+#ifdef XML_NS

+    {XML_FEATURE_NS,               XML_L("XML_NS"), 0},

+#endif

+    {XML_FEATURE_END,              NULL, 0}

+  };

+

+  return features;

+}

+

+/* Initially tag->rawName always points into the parse buffer;

+   for those TAG instances opened while the current parse buffer was

+   processed, and not yet closed, we need to store tag->rawName in a more

+   permanent location, since the parse buffer is about to be discarded.

+*/

+static XML_Bool

+storeRawNames(XML_Parser parser)

+{

+  TAG *tag = tagStack;

+  while (tag) {

+    int bufSize;

+    int nameLen = sizeof(XML_Char) * (tag->name.strLen + 1);

+    char *rawNameBuf = tag->buf + nameLen;

+    /* Stop if already stored.  Since tagStack is a stack, we can stop

+       at the first entry that has already been copied; everything

+       below it in the stack is already been accounted for in a

+       previous call to this function.

+    */

+    if (tag->rawName == rawNameBuf)

+      break;

+    /* For re-use purposes we need to ensure that the

+       size of tag->buf is a multiple of sizeof(XML_Char).

+    */

+    bufSize = nameLen + ROUND_UP(tag->rawNameLength, sizeof(XML_Char));

+    if (bufSize > tag->bufEnd - tag->buf) {

+      char *temp = (char *)REALLOC(tag->buf, bufSize);

+      if (temp == NULL)

+        return XML_FALSE;

+      /* if tag->name.str points to tag->buf (only when namespace

+         processing is off) then we have to update it

+      */

+      if (tag->name.str == (XML_Char *)tag->buf)

+        tag->name.str = (XML_Char *)temp;

+      /* if tag->name.localPart is set (when namespace processing is on)

+         then update it as well, since it will always point into tag->buf

+      */

+      if (tag->name.localPart)

+        tag->name.localPart = (XML_Char *)temp + (tag->name.localPart -

+                                                  (XML_Char *)tag->buf);

+      tag->buf = temp;

+      tag->bufEnd = temp + bufSize;

+      rawNameBuf = temp + nameLen;

+    }

+    memcpy(rawNameBuf, tag->rawName, tag->rawNameLength);

+    tag->rawName = rawNameBuf;

+    tag = tag->parent;

+  }

+  return XML_TRUE;

+}

+

+static enum XML_Error PTRCALL

+contentProcessor(XML_Parser parser,

+                 const char *start,

+                 const char *end,

+                 const char **endPtr)

+{

+  enum XML_Error result = doContent(parser, 0, encoding, start, end,

+                                    endPtr, (XML_Bool)!ps_finalBuffer);

+  if (result == XML_ERROR_NONE) {

+    if (!storeRawNames(parser))

+      return XML_ERROR_NO_MEMORY;

+  }

+  return result;

+}

+

+static enum XML_Error PTRCALL

+externalEntityInitProcessor(XML_Parser parser,

+                            const char *start,

+                            const char *end,

+                            const char **endPtr)

+{

+  enum XML_Error result = initializeEncoding(parser);

+  if (result != XML_ERROR_NONE)

+    return result;

+  processor = externalEntityInitProcessor2;

+  return externalEntityInitProcessor2(parser, start, end, endPtr);

+}

+

+static enum XML_Error PTRCALL

+externalEntityInitProcessor2(XML_Parser parser,

+                             const char *start,

+                             const char *end,

+                             const char **endPtr)

+{

+  const char *next = start; /* XmlContentTok doesn't always set the last arg */

+  int tok = XmlContentTok(encoding, start, end, &next);

+  switch (tok) {

+  case XML_TOK_BOM:

+    /* If we are at the end of the buffer, this would cause the next stage,

+       i.e. externalEntityInitProcessor3, to pass control directly to

+       doContent (by detecting XML_TOK_NONE) without processing any xml text

+       declaration - causing the error XML_ERROR_MISPLACED_XML_PI in doContent.

+    */

+    if (next == end && !ps_finalBuffer) {

+      *endPtr = next;

+      return XML_ERROR_NONE;

+    }

+    start = next;

+    break;

+  case XML_TOK_PARTIAL:

+    if (!ps_finalBuffer) {

+      *endPtr = start;

+      return XML_ERROR_NONE;

+    }

+    eventPtr = start;

+    return XML_ERROR_UNCLOSED_TOKEN;

+  case XML_TOK_PARTIAL_CHAR:

+    if (!ps_finalBuffer) {

+      *endPtr = start;

+      return XML_ERROR_NONE;

+    }

+    eventPtr = start;

+    return XML_ERROR_PARTIAL_CHAR;

+  }

+  processor = externalEntityInitProcessor3;

+  return externalEntityInitProcessor3(parser, start, end, endPtr);

+}

+

+static enum XML_Error PTRCALL

+externalEntityInitProcessor3(XML_Parser parser,

+                             const char *start,

+                             const char *end,

+                             const char **endPtr)

+{

+  int tok;

+  const char *next = start; /* XmlContentTok doesn't always set the last arg */

+  eventPtr = start;

+  tok = XmlContentTok(encoding, start, end, &next);

+  eventEndPtr = next;

+

+  switch (tok) {

+  case XML_TOK_XML_DECL:

+    {

+      enum XML_Error result;

+      result = processXmlDecl(parser, 1, start, next);

+      if (result != XML_ERROR_NONE)

+        return result;

+      switch (ps_parsing) {

+      case XML_SUSPENDED:

+        *endPtr = next;

+        return XML_ERROR_NONE;

+      case XML_FINISHED:

+        return XML_ERROR_ABORTED;

+      default:

+        start = next;

+      }

+    }

+    break;

+  case XML_TOK_PARTIAL:

+    if (!ps_finalBuffer) {

+      *endPtr = start;

+      return XML_ERROR_NONE;

+    }

+    return XML_ERROR_UNCLOSED_TOKEN;

+  case XML_TOK_PARTIAL_CHAR:

+    if (!ps_finalBuffer) {

+      *endPtr = start;

+      return XML_ERROR_NONE;

+    }

+    return XML_ERROR_PARTIAL_CHAR;

+  }

+  processor = externalEntityContentProcessor;

+  tagLevel = 1;

+  return externalEntityContentProcessor(parser, start, end, endPtr);

+}

+

+static enum XML_Error PTRCALL

+externalEntityContentProcessor(XML_Parser parser,

+                               const char *start,

+                               const char *end,

+                               const char **endPtr)

+{

+  enum XML_Error result = doContent(parser, 1, encoding, start, end,

+                                    endPtr, (XML_Bool)!ps_finalBuffer);

+  if (result == XML_ERROR_NONE) {

+    if (!storeRawNames(parser))

+      return XML_ERROR_NO_MEMORY;

+  }

+  return result;

+}

+

+static enum XML_Error

+doContent(XML_Parser parser,

+          int startTagLevel,

+          const ENCODING *enc,

+          const char *s,

+          const char *end,

+          const char **nextPtr,

+          XML_Bool haveMore)

+{

+  /* save one level of indirection */

+  DTD * const dtd = _dtd;

+

+  const char **eventPP;

+  const char **eventEndPP;

+  if (enc == encoding) {

+    eventPP = &eventPtr;

+    eventEndPP = &eventEndPtr;

+  }

+  else {

+    eventPP = &(openInternalEntities->internalEventPtr);

+    eventEndPP = &(openInternalEntities->internalEventEndPtr);

+  }

+  *eventPP = s;

+

+  for (;;) {

+    const char *next = s; /* XmlContentTok doesn't always set the last arg */

+    int tok = XmlContentTok(enc, s, end, &next);

+    *eventEndPP = next;

+    switch (tok) {

+    case XML_TOK_TRAILING_CR:

+      if (haveMore) {

+        *nextPtr = s;

+        return XML_ERROR_NONE;

+      }

+      *eventEndPP = end;

+      if (characterDataHandler) {

+        XML_Char c = 0xA;

+        characterDataHandler(handlerArg, &c, 1);

+      }

+      else if (defaultHandler)

+        reportDefault(parser, enc, s, end);

+      /* We are at the end of the final buffer, should we check for

+         XML_SUSPENDED, XML_FINISHED?

+      */

+      if (startTagLevel == 0)

+        return XML_ERROR_NO_ELEMENTS;

+      if (tagLevel != startTagLevel)

+        return XML_ERROR_ASYNC_ENTITY;

+      *nextPtr = end;

+      return XML_ERROR_NONE;

+    case XML_TOK_NONE:

+      if (haveMore) {

+        *nextPtr = s;

+        return XML_ERROR_NONE;

+      }

+      if (startTagLevel > 0) {

+        if (tagLevel != startTagLevel)

+          return XML_ERROR_ASYNC_ENTITY;

+        *nextPtr = s;

+        return XML_ERROR_NONE;

+      }

+      return XML_ERROR_NO_ELEMENTS;

+    case XML_TOK_INVALID:

+      *eventPP = next;

+      return XML_ERROR_INVALID_TOKEN;

+    case XML_TOK_PARTIAL:

+      if (haveMore) {

+        *nextPtr = s;

+        return XML_ERROR_NONE;

+      }

+      return XML_ERROR_UNCLOSED_TOKEN;

+    case XML_TOK_PARTIAL_CHAR:

+      if (haveMore) {

+        *nextPtr = s;

+        return XML_ERROR_NONE;

+      }

+      return XML_ERROR_PARTIAL_CHAR;

+    case XML_TOK_ENTITY_REF:

+      {

+        const XML_Char *name;

+        ENTITY *entity;

+        XML_Char ch = (XML_Char) XmlPredefinedEntityName(enc,

+                                              s + enc->minBytesPerChar,

+                                              next - enc->minBytesPerChar);

+        if (ch) {

+          if (characterDataHandler)

+            characterDataHandler(handlerArg, &ch, 1);

+          else if (defaultHandler)

+            reportDefault(parser, enc, s, next);

+          break;

+        }

+        name = poolStoreString(&dtd->pool, enc,

+                                s + enc->minBytesPerChar,

+                                next - enc->minBytesPerChar);

+        if (!name)

+          return XML_ERROR_NO_MEMORY;

+        entity = (ENTITY *)lookup(&dtd->generalEntities, name, 0);

+        poolDiscard(&dtd->pool);

+        /* First, determine if a check for an existing declaration is needed;

+           if yes, check that the entity exists, and that it is internal,

+           otherwise call the skipped entity or default handler.

+        */

+        if (!dtd->hasParamEntityRefs || dtd->standalone) {

+          if (!entity)

+            return XML_ERROR_UNDEFINED_ENTITY;

+          else if (!entity->is_internal)

+            return XML_ERROR_ENTITY_DECLARED_IN_PE;

+        }

+        else if (!entity) {

+          if (skippedEntityHandler)

+            skippedEntityHandler(handlerArg, name, 0);

+          else if (defaultHandler)

+            reportDefault(parser, enc, s, next);

+          break;

+        }

+        if (entity->open)

+          return XML_ERROR_RECURSIVE_ENTITY_REF;

+        if (entity->notation)

+          return XML_ERROR_BINARY_ENTITY_REF;

+        if (entity->textPtr) {

+          enum XML_Error result;

+          if (!defaultExpandInternalEntities) {

+            if (skippedEntityHandler)

+              skippedEntityHandler(handlerArg, entity->name, 0);

+            else if (defaultHandler)

+              reportDefault(parser, enc, s, next);

+            break;

+          }

+          result = processInternalEntity(parser, entity, XML_FALSE);

+          if (result != XML_ERROR_NONE)

+            return result;

+        }

+        else if (externalEntityRefHandler) {

+          const XML_Char *context;

+          entity->open = XML_TRUE;

+          context = getContext(parser);

+          entity->open = XML_FALSE;

+          if (!context)

+            return XML_ERROR_NO_MEMORY;

+          if (!externalEntityRefHandler(externalEntityRefHandlerArg,

+                                        context,

+                                        entity->base,

+                                        entity->systemId,

+                                        entity->publicId))

+            return XML_ERROR_EXTERNAL_ENTITY_HANDLING;

+          poolDiscard(&tempPool);

+        }

+        else if (defaultHandler)

+          reportDefault(parser, enc, s, next);

+        break;

+      }

+    case XML_TOK_START_TAG_NO_ATTS:

+      /* fall through */

+    case XML_TOK_START_TAG_WITH_ATTS:

+      {

+        TAG *tag;

+        enum XML_Error result;

+        XML_Char *toPtr;

+        if (freeTagList) {

+          tag = freeTagList;

+          freeTagList = freeTagList->parent;

+        }

+        else {

+          tag = (TAG *)MALLOC(sizeof(TAG));

+          if (!tag)

+            return XML_ERROR_NO_MEMORY;

+          tag->buf = (char *)MALLOC(INIT_TAG_BUF_SIZE);

+          if (!tag->buf) {

+            FREE(tag);

+            return XML_ERROR_NO_MEMORY;

+          }

+          tag->bufEnd = tag->buf + INIT_TAG_BUF_SIZE;

+        }

+        tag->bindings = NULL;

+        tag->parent = tagStack;

+        tagStack = tag;

+        tag->name.localPart = NULL;

+        tag->name.prefix = NULL;

+        tag->rawName = s + enc->minBytesPerChar;

+        tag->rawNameLength = XmlNameLength(enc, tag->rawName);

+        ++tagLevel;

+        {

+          const char *rawNameEnd = tag->rawName + tag->rawNameLength;

+          const char *fromPtr = tag->rawName;

+          toPtr = (XML_Char *)tag->buf;

+          for (;;) {

+            int bufSize;

+            int convLen;

+            XmlConvert(enc,

+                       &fromPtr, rawNameEnd,

+                       (ICHAR **)&toPtr, (ICHAR *)tag->bufEnd - 1);

+            convLen = (int)(toPtr - (XML_Char *)tag->buf);

+            if (fromPtr == rawNameEnd) {

+              tag->name.strLen = convLen;

+              break;

+            }

+            bufSize = (int)(tag->bufEnd - tag->buf) << 1;

+            {

+              char *temp = (char *)REALLOC(tag->buf, bufSize);

+              if (temp == NULL)

+                return XML_ERROR_NO_MEMORY;

+              tag->buf = temp;

+              tag->bufEnd = temp + bufSize;

+              toPtr = (XML_Char *)temp + convLen;

+            }

+          }

+        }

+        tag->name.str = (XML_Char *)tag->buf;

+        *toPtr = XML_T('\0');

+        result = storeAtts(parser, enc, s, &(tag->name), &(tag->bindings));

+        if (result)

+          return result;

+        if (startElementHandler)

+          startElementHandler(handlerArg, tag->name.str,

+                              (const XML_Char **)atts);

+        else if (defaultHandler)

+          reportDefault(parser, enc, s, next);

+        poolClear(&tempPool);

+        break;

+      }

+    case XML_TOK_EMPTY_ELEMENT_NO_ATTS:

+      /* fall through */

+    case XML_TOK_EMPTY_ELEMENT_WITH_ATTS:

+      {

+        const char *rawName = s + enc->minBytesPerChar;

+        enum XML_Error result;

+        BINDING *bindings = NULL;

+        XML_Bool noElmHandlers = XML_TRUE;

+        TAG_NAME name;

+        name.str = poolStoreString(&tempPool, enc, rawName,

+                                   rawName + XmlNameLength(enc, rawName));

+        if (!name.str)

+          return XML_ERROR_NO_MEMORY;

+        poolFinish(&tempPool);

+        result = storeAtts(parser, enc, s, &name, &bindings);

+        if (result)

+          return result;

+        poolFinish(&tempPool);

+        if (startElementHandler) {

+          startElementHandler(handlerArg, name.str, (const XML_Char **)atts);

+          noElmHandlers = XML_FALSE;

+        }

+        if (endElementHandler) {

+          if (startElementHandler)

+            *eventPP = *eventEndPP;

+          endElementHandler(handlerArg, name.str);

+          noElmHandlers = XML_FALSE;

+        }

+        if (noElmHandlers && defaultHandler)

+          reportDefault(parser, enc, s, next);

+        poolClear(&tempPool);

+        while (bindings) {

+          BINDING *b = bindings;

+          if (endNamespaceDeclHandler)

+            endNamespaceDeclHandler(handlerArg, b->prefix->name);

+          bindings = bindings->nextTagBinding;

+          b->nextTagBinding = freeBindingList;

+          freeBindingList = b;

+          b->prefix->binding = b->prevPrefixBinding;

+        }

+      }

+      if (tagLevel == 0)

+        return epilogProcessor(parser, next, end, nextPtr);

+      break;

+    case XML_TOK_END_TAG:

+      if (tagLevel == startTagLevel)

+        return XML_ERROR_ASYNC_ENTITY;

+      else {

+        int len;

+        const char *rawName;

+        TAG *tag = tagStack;

+        tagStack = tag->parent;

+        tag->parent = freeTagList;

+        freeTagList = tag;

+        rawName = s + enc->minBytesPerChar*2;

+        len = XmlNameLength(enc, rawName);

+        if (len != tag->rawNameLength

+            || memcmp(tag->rawName, rawName, len) != 0) {

+          *eventPP = rawName;

+          return XML_ERROR_TAG_MISMATCH;

+        }

+        --tagLevel;

+        if (endElementHandler) {

+          const XML_Char *localPart;

+          const XML_Char *prefix;

+          XML_Char *uri;

+          localPart = tag->name.localPart;

+          if (ns && localPart) {

+            /* localPart and prefix may have been overwritten in

+               tag->name.str, since this points to the binding->uri

+               buffer which gets re-used; so we have to add them again

+            */

+            uri = (XML_Char *)tag->name.str + tag->name.uriLen;

+            /* don't need to check for space - already done in storeAtts() */

+            while (*localPart) *uri++ = *localPart++;

+            prefix = (XML_Char *)tag->name.prefix;

+            if (ns_triplets && prefix) {

+              *uri++ = namespaceSeparator;

+              while (*prefix) *uri++ = *prefix++;

+             }

+            *uri = XML_T('\0');

+          }

+          endElementHandler(handlerArg, tag->name.str);

+        }

+        else if (defaultHandler)

+          reportDefault(parser, enc, s, next);

+        while (tag->bindings) {

+          BINDING *b = tag->bindings;

+          if (endNamespaceDeclHandler)

+            endNamespaceDeclHandler(handlerArg, b->prefix->name);

+          tag->bindings = tag->bindings->nextTagBinding;

+          b->nextTagBinding = freeBindingList;

+          freeBindingList = b;

+          b->prefix->binding = b->prevPrefixBinding;

+        }

+        if (tagLevel == 0)

+          return epilogProcessor(parser, next, end, nextPtr);

+      }

+      break;

+    case XML_TOK_CHAR_REF:

+      {

+        int n = XmlCharRefNumber(enc, s);

+        if (n < 0)

+          return XML_ERROR_BAD_CHAR_REF;

+        if (characterDataHandler) {

+          XML_Char buf[XML_ENCODE_MAX];

+          characterDataHandler(handlerArg, buf, XmlEncode(n, (ICHAR *)buf));

+        }

+        else if (defaultHandler)

+          reportDefault(parser, enc, s, next);

+      }

+      break;

+    case XML_TOK_XML_DECL:

+      return XML_ERROR_MISPLACED_XML_PI;

+    case XML_TOK_DATA_NEWLINE:

+      if (characterDataHandler) {

+        XML_Char c = 0xA;

+        characterDataHandler(handlerArg, &c, 1);

+      }

+      else if (defaultHandler)

+        reportDefault(parser, enc, s, next);

+      break;

+    case XML_TOK_CDATA_SECT_OPEN:

+      {

+        enum XML_Error result;

+        if (startCdataSectionHandler)

+          startCdataSectionHandler(handlerArg);

+#if 0

+        /* Suppose you doing a transformation on a document that involves

+           changing only the character data.  You set up a defaultHandler

+           and a characterDataHandler.  The defaultHandler simply copies

+           characters through.  The characterDataHandler does the

+           transformation and writes the characters out escaping them as

+           necessary.  This case will fail to work if we leave out the

+           following two lines (because & and < inside CDATA sections will

+           be incorrectly escaped).

+

+           However, now we have a start/endCdataSectionHandler, so it seems

+           easier to let the user deal with this.

+        */

+        else if (characterDataHandler)

+          characterDataHandler(handlerArg, dataBuf, 0);

+#endif

+        else if (defaultHandler)

+          reportDefault(parser, enc, s, next);

+        result = doCdataSection(parser, enc, &next, end, nextPtr, haveMore);

+        if (result != XML_ERROR_NONE)

+          return result;

+        else if (!next) {

+          processor = cdataSectionProcessor;

+          return result;

+        }

+      }

+      break;

+    case XML_TOK_TRAILING_RSQB:

+      if (haveMore) {

+        *nextPtr = s;

+        return XML_ERROR_NONE;

+      }

+      if (characterDataHandler) {

+        if (MUST_CONVERT(enc, s)) {

+          ICHAR *dataPtr = (ICHAR *)dataBuf;

+          XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);

+          characterDataHandler(handlerArg, dataBuf,

+                               (int)(dataPtr - (ICHAR *)dataBuf));

+        }

+        else

+          characterDataHandler(handlerArg,

+                               (XML_Char *)s,

+                               (int)((XML_Char *)end - (XML_Char *)s));

+      }

+      else if (defaultHandler)

+        reportDefault(parser, enc, s, end);

+      /* We are at the end of the final buffer, should we check for

+         XML_SUSPENDED, XML_FINISHED?

+      */

+      if (startTagLevel == 0) {

+        *eventPP = end;

+        return XML_ERROR_NO_ELEMENTS;

+      }

+      if (tagLevel != startTagLevel) {

+        *eventPP = end;

+        return XML_ERROR_ASYNC_ENTITY;

+      }

+      *nextPtr = end;

+      return XML_ERROR_NONE;

+    case XML_TOK_DATA_CHARS:

+      if (characterDataHandler) {

+        if (MUST_CONVERT(enc, s)) {

+          for (;;) {

+            ICHAR *dataPtr = (ICHAR *)dataBuf;

+            XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);

+            *eventEndPP = s;

+            characterDataHandler(handlerArg, dataBuf,

+                                 (int)(dataPtr - (ICHAR *)dataBuf));

+            if (s == next)

+              break;

+            *eventPP = s;

+          }

+        }

+        else

+          characterDataHandler(handlerArg,

+                               (XML_Char *)s,

+                               (int)((XML_Char *)next - (XML_Char *)s));

+      }

+      else if (defaultHandler)

+        reportDefault(parser, enc, s, next);

+      break;

+    case XML_TOK_PI:

+      if (!reportProcessingInstruction(parser, enc, s, next))

+        return XML_ERROR_NO_MEMORY;

+      break;

+    case XML_TOK_COMMENT:

+      if (!reportComment(parser, enc, s, next))

+        return XML_ERROR_NO_MEMORY;

+      break;

+    default:

+      if (defaultHandler)

+        reportDefault(parser, enc, s, next);

+      break;

+    }

+    *eventPP = s = next;

+    switch (ps_parsing) {

+    case XML_SUSPENDED:

+      *nextPtr = next;

+      return XML_ERROR_NONE;

+    case XML_FINISHED:

+      return XML_ERROR_ABORTED;

+    default: ;

+    }

+  }

+  /* not reached */

+}

+

+/* Precondition: all arguments must be non-NULL;

+   Purpose:

+   - normalize attributes

+   - check attributes for well-formedness

+   - generate namespace aware attribute names (URI, prefix)

+   - build list of attributes for startElementHandler

+   - default attributes

+   - process namespace declarations (check and report them)

+   - generate namespace aware element name (URI, prefix)

+*/

+static enum XML_Error

+storeAtts(XML_Parser parser, const ENCODING *enc,

+          const char *attStr, TAG_NAME *tagNamePtr,

+          BINDING **bindingsPtr)

+{

+  DTD * const dtd = _dtd;  /* save one level of indirection */

+  ELEMENT_TYPE *elementType;

+  int nDefaultAtts;

+  const XML_Char **appAtts;   /* the attribute list for the application */

+  int attIndex = 0;

+  int prefixLen;

+  int i;

+  int n;

+  XML_Char *uri;

+  int nPrefixes = 0;

+  BINDING *binding;

+  const XML_Char *localPart;

+

+  /* lookup the element type name */

+  elementType = (ELEMENT_TYPE *)lookup(&dtd->elementTypes, tagNamePtr->str,0);

+  if (!elementType) {

+    const XML_Char *name = poolCopyString(&dtd->pool, tagNamePtr->str);

+    if (!name)

+      return XML_ERROR_NO_MEMORY;

+    elementType = (ELEMENT_TYPE *)lookup(&dtd->elementTypes, name,

+                                         sizeof(ELEMENT_TYPE));

+    if (!elementType)

+      return XML_ERROR_NO_MEMORY;

+    if (ns && !setElementTypePrefix(parser, elementType))

+      return XML_ERROR_NO_MEMORY;

+  }

+  nDefaultAtts = elementType->nDefaultAtts;

+

+  /* get the attributes from the tokenizer */

+  n = XmlGetAttributes(enc, attStr, attsSize, atts);

+  if (n + nDefaultAtts > attsSize) {

+    int oldAttsSize = attsSize;

+    ATTRIBUTE *temp;

+    attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;

+    temp = (ATTRIBUTE *)REALLOC((void *)atts, attsSize * sizeof(ATTRIBUTE));

+    if (temp == NULL)

+      return XML_ERROR_NO_MEMORY;

+    atts = temp;

+    if (n > oldAttsSize)

+      XmlGetAttributes(enc, attStr, n, atts);

+  }

+

+  appAtts = (const XML_Char **)atts;

+  for (i = 0; i < n; i++) {

+    /* add the name and value to the attribute list */

+    ATTRIBUTE_ID *attId = getAttributeId(parser, enc, atts[i].name,

+                                         atts[i].name

+                                         + XmlNameLength(enc, atts[i].name));

+    if (!attId)

+      return XML_ERROR_NO_MEMORY;

+    /* Detect duplicate attributes by their QNames. This does not work when

+       namespace processing is turned on and different prefixes for the same

+       namespace are used. For this case we have a check further down.

+    */

+    if ((attId->name)[-1]) {

+      if (enc == encoding)

+        eventPtr = atts[i].name;

+      return XML_ERROR_DUPLICATE_ATTRIBUTE;

+    }

+    (attId->name)[-1] = 1;

+    appAtts[attIndex++] = attId->name;

+    if (!atts[i].normalized) {

+      enum XML_Error result;

+      XML_Bool isCdata = XML_TRUE;

+

+      /* figure out whether declared as other than CDATA */

+      if (attId->maybeTokenized) {

+        int j;

+        for (j = 0; j < nDefaultAtts; j++) {

+          if (attId == elementType->defaultAtts[j].id) {

+            isCdata = elementType->defaultAtts[j].isCdata;

+            break;

+          }

+        }

+      }

+

+      /* normalize the attribute value */

+      result = storeAttributeValue(parser, enc, isCdata,

+                                   atts[i].valuePtr, atts[i].valueEnd,

+                                   &tempPool);

+      if (result)

+        return result;

+      appAtts[attIndex] = poolStart(&tempPool);

+      poolFinish(&tempPool);

+    }

+    else {

+      /* the value did not need normalizing */

+      appAtts[attIndex] = poolStoreString(&tempPool, enc, atts[i].valuePtr,

+                                          atts[i].valueEnd);

+      if (appAtts[attIndex] == 0)

+        return XML_ERROR_NO_MEMORY;

+      poolFinish(&tempPool);

+    }

+    /* handle prefixed attribute names */

+    if (attId->prefix) {

+      if (attId->xmlns) {

+        /* deal with namespace declarations here */

+        enum XML_Error result = addBinding(parser, attId->prefix, attId,

+                                           appAtts[attIndex], bindingsPtr);

+        if (result)

+          return result;

+        --attIndex;

+      }

+      else {

+        /* deal with other prefixed names later */

+        attIndex++;

+        nPrefixes++;

+        (attId->name)[-1] = 2;

+      }

+    }

+    else

+      attIndex++;

+  }

+

+  /* set-up for XML_GetSpecifiedAttributeCount and XML_GetIdAttributeIndex */

+  nSpecifiedAtts = attIndex;

+  if (elementType->idAtt && (elementType->idAtt->name)[-1]) {

+    for (i = 0; i < attIndex; i += 2)

+      if (appAtts[i] == elementType->idAtt->name) {

+        idAttIndex = i;

+        break;

+      }

+  }

+  else

+    idAttIndex = -1;

+

+  /* do attribute defaulting */

+  for (i = 0; i < nDefaultAtts; i++) {

+    const DEFAULT_ATTRIBUTE *da = elementType->defaultAtts + i;

+    if (!(da->id->name)[-1] && da->value) {

+      if (da->id->prefix) {

+        if (da->id->xmlns) {

+          enum XML_Error result = addBinding(parser, da->id->prefix, da->id,

+                                             da->value, bindingsPtr);

+          if (result)

+            return result;

+        }

+        else {

+          (da->id->name)[-1] = 2;

+          nPrefixes++;

+          appAtts[attIndex++] = da->id->name;

+          appAtts[attIndex++] = da->value;

+        }

+      }

+      else {

+        (da->id->name)[-1] = 1;

+        appAtts[attIndex++] = da->id->name;

+        appAtts[attIndex++] = da->value;

+      }

+    }

+  }

+  appAtts[attIndex] = 0;

+

+  /* expand prefixed attribute names, check for duplicates,

+     and clear flags that say whether attributes were specified */

+  i = 0;

+  if (nPrefixes) {

+    int j;  /* hash table index */

+    unsigned long version = nsAttsVersion;

+    int nsAttsSize = (int)1 << nsAttsPower;

+    /* size of hash table must be at least 2 * (# of prefixed attributes) */

+    if ((nPrefixes << 1) >> nsAttsPower) {  /* true for nsAttsPower = 0 */

+      NS_ATT *temp;

+      /* hash table size must also be a power of 2 and >= 8 */

+      while (nPrefixes >> nsAttsPower++);

+      if (nsAttsPower < 3)

+        nsAttsPower = 3;

+      nsAttsSize = (int)1 << nsAttsPower;

+      temp = (NS_ATT *)REALLOC(nsAtts, nsAttsSize * sizeof(NS_ATT));

+      if (!temp)

+        return XML_ERROR_NO_MEMORY;

+      nsAtts = temp;

+      version = 0;  /* force re-initialization of nsAtts hash table */

+    }

+    /* using a version flag saves us from initializing nsAtts every time */

+    if (!version) {  /* initialize version flags when version wraps around */

+      version = INIT_ATTS_VERSION;

+      for (j = nsAttsSize; j != 0; )

+        nsAtts[--j].version = version;

+    }

+    nsAttsVersion = --version;

+

+    /* expand prefixed names and check for duplicates */

+    for (; i < attIndex; i += 2) {

+      const XML_Char *s = appAtts[i];

+      if (s[-1] == 2) {  /* prefixed */

+        ATTRIBUTE_ID *id;

+        const BINDING *b;

+        unsigned long uriHash = 0;

+        ((XML_Char *)s)[-1] = 0;  /* clear flag */

+        id = (ATTRIBUTE_ID *)lookup(&dtd->attributeIds, s, 0);

+        if (!id)

+          return XML_ERROR_NO_MEMORY;

+        b = id->prefix->binding;

+        if (!b)

+          return XML_ERROR_UNBOUND_PREFIX;

+

+        /* as we expand the name we also calculate its hash value */

+        for (j = 0; j < b->uriLen; j++) {

+          const XML_Char c = b->uri[j];

+          if (!poolAppendChar(&tempPool, c))

+            return XML_ERROR_NO_MEMORY;

+          uriHash = CHAR_HASH(uriHash, c);

+        }

+        while (*s++ != XML_T(':'))

+          ;

+        do {  /* copies null terminator */

+          const XML_Char c = *s;

+          if (!poolAppendChar(&tempPool, *s))

+            return XML_ERROR_NO_MEMORY;

+          uriHash = CHAR_HASH(uriHash, c);

+        } while (*s++);

+

+        { /* Check hash table for duplicate of expanded name (uriName).

+             Derived from code in lookup(HASH_TABLE *table, ...).

+          */

+          unsigned char step = 0;

+          unsigned long mask = nsAttsSize - 1;

+          j = uriHash & mask;  /* index into hash table */

+          while (nsAtts[j].version == version) {

+            /* for speed we compare stored hash values first */

+            if (uriHash == nsAtts[j].hash) {

+              const XML_Char *s1 = poolStart(&tempPool);

+              const XML_Char *s2 = nsAtts[j].uriName;

+              /* s1 is null terminated, but not s2 */

+              for (; *s1 == *s2 && *s1 != 0; s1++, s2++);

+              if (*s1 == 0)

+                return XML_ERROR_DUPLICATE_ATTRIBUTE;

+            }

+            if (!step)

+              step = PROBE_STEP(uriHash, mask, nsAttsPower);

+            j < step ? (j += nsAttsSize - step) : (j -= step);

+          }

+        }

+

+        if (ns_triplets) {  /* append namespace separator and prefix */

+          tempPool.ptr[-1] = namespaceSeparator;

+          s = b->prefix->name;

+          do {

+            if (!poolAppendChar(&tempPool, *s))

+              return XML_ERROR_NO_MEMORY;

+          } while (*s++);

+        }

+

+        /* store expanded name in attribute list */

+        s = poolStart(&tempPool);

+        poolFinish(&tempPool);

+        appAtts[i] = s;

+

+        /* fill empty slot with new version, uriName and hash value */

+        nsAtts[j].version = version;

+        nsAtts[j].hash = uriHash;

+        nsAtts[j].uriName = s;

+

+        if (!--nPrefixes) {

+          i += 2;

+          break;

+        }

+      }

+      else  /* not prefixed */

+        ((XML_Char *)s)[-1] = 0;  /* clear flag */

+    }

+  }

+  /* clear flags for the remaining attributes */

+  for (; i < attIndex; i += 2)

+    ((XML_Char *)(appAtts[i]))[-1] = 0;

+  for (binding = *bindingsPtr; binding; binding = binding->nextTagBinding)

+    binding->attId->name[-1] = 0;

+

+  if (!ns)

+    return XML_ERROR_NONE;

+

+  /* expand the element type name */

+  if (elementType->prefix) {

+    binding = elementType->prefix->binding;

+    if (!binding)

+      return XML_ERROR_UNBOUND_PREFIX;

+    localPart = tagNamePtr->str;

+    while (*localPart++ != XML_T(':'))

+      ;

+  }

+  else if (dtd->defaultPrefix.binding) {

+    binding = dtd->defaultPrefix.binding;

+    localPart = tagNamePtr->str;

+  }

+  else

+    return XML_ERROR_NONE;

+  prefixLen = 0;

+  if (ns_triplets && binding->prefix->name) {

+    for (; binding->prefix->name[prefixLen++];)

+      ;  /* prefixLen includes null terminator */

+  }

+  tagNamePtr->localPart = localPart;

+  tagNamePtr->uriLen = binding->uriLen;

+  tagNamePtr->prefix = binding->prefix->name;

+  tagNamePtr->prefixLen = prefixLen;

+  for (i = 0; localPart[i++];)

+    ;  /* i includes null terminator */

+  n = i + binding->uriLen + prefixLen;

+  if (n > binding->uriAlloc) {

+    TAG *p;

+    uri = (XML_Char *)MALLOC((n + EXPAND_SPARE) * sizeof(XML_Char));

+    if (!uri)

+      return XML_ERROR_NO_MEMORY;

+    binding->uriAlloc = n + EXPAND_SPARE;

+    memcpy(uri, binding->uri, binding->uriLen * sizeof(XML_Char));

+    for (p = tagStack; p; p = p->parent)

+      if (p->name.str == binding->uri)

+        p->name.str = uri;

+    FREE(binding->uri);

+    binding->uri = uri;

+  }

+  /* if namespaceSeparator != '\0' then uri includes it already */

+  uri = binding->uri + binding->uriLen;

+  memcpy(uri, localPart, i * sizeof(XML_Char));

+  /* we always have a namespace separator between localPart and prefix */

+  if (prefixLen) {

+    uri += i - 1;

+    *uri = namespaceSeparator;  /* replace null terminator */

+    memcpy(uri + 1, binding->prefix->name, prefixLen * sizeof(XML_Char));

+  }

+  tagNamePtr->str = binding->uri;

+  return XML_ERROR_NONE;

+}

+

+/* addBinding() overwrites the value of prefix->binding without checking.

+   Therefore one must keep track of the old value outside of addBinding().

+*/

+static enum XML_Error

+addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,

+           const XML_Char *uri, BINDING **bindingsPtr)

+{

+  static const XML_Char xmlNamespace[] = {

+    'h', 't', 't', 'p', ':', '/', '/',

+    'w', 'w', 'w', '.', 'w', '3', '.', 'o', 'r', 'g', '/',

+    'X', 'M', 'L', '/', '1', '9', '9', '8', '/',

+    'n', 'a', 'm', 'e', 's', 'p', 'a', 'c', 'e', '\0'

+  };

+  static const int xmlLen =

+    (int)sizeof(xmlNamespace)/sizeof(XML_Char) - 1;

+  static const XML_Char xmlnsNamespace[] = {

+    'h', 't', 't', 'p', ':', '/', '/',

+    'w', 'w', 'w', '.', 'w', '3', '.', 'o', 'r', 'g', '/',

+    '2', '0', '0', '0', '/', 'x', 'm', 'l', 'n', 's', '/', '\0'

+  };

+  static const int xmlnsLen =

+    (int)sizeof(xmlnsNamespace)/sizeof(XML_Char) - 1;

+

+  XML_Bool mustBeXML = XML_FALSE;

+  XML_Bool isXML = XML_TRUE;

+  XML_Bool isXMLNS = XML_TRUE;

+

+  BINDING *b;

+  int len;

+

+  /* empty URI is only valid for default namespace per XML NS 1.0 (not 1.1) */

+  if (*uri == XML_T('\0') && prefix->name)

+    return XML_ERROR_UNDECLARING_PREFIX;

+

+  if (prefix->name

+      && prefix->name[0] == XML_T('x')

+      && prefix->name[1] == XML_T('m')

+      && prefix->name[2] == XML_T('l')) {

+

+    /* Not allowed to bind xmlns */

+    if (prefix->name[3] == XML_T('n')

+        && prefix->name[4] == XML_T('s')

+        && prefix->name[5] == XML_T('\0'))

+      return XML_ERROR_RESERVED_PREFIX_XMLNS;

+

+    if (prefix->name[3] == XML_T('\0'))

+      mustBeXML = XML_TRUE;

+  }

+

+  for (len = 0; uri[len]; len++) {

+    if (isXML && (len > xmlLen || uri[len] != xmlNamespace[len]))

+      isXML = XML_FALSE;

+

+    if (!mustBeXML && isXMLNS

+        && (len > xmlnsLen || uri[len] != xmlnsNamespace[len]))

+      isXMLNS = XML_FALSE;

+  }

+  isXML = isXML && len == xmlLen;

+  isXMLNS = isXMLNS && len == xmlnsLen;

+

+  if (mustBeXML != isXML)

+    return mustBeXML ? XML_ERROR_RESERVED_PREFIX_XML

+                     : XML_ERROR_RESERVED_NAMESPACE_URI;

+

+  if (isXMLNS)

+    return XML_ERROR_RESERVED_NAMESPACE_URI;

+

+  if (namespaceSeparator)

+    len++;

+  if (freeBindingList) {

+    b = freeBindingList;

+    if (len > b->uriAlloc) {

+      XML_Char *temp = (XML_Char *)REALLOC(b->uri,

+                          sizeof(XML_Char) * (len + EXPAND_SPARE));

+      if (temp == NULL)

+        return XML_ERROR_NO_MEMORY;

+      b->uri = temp;

+      b->uriAlloc = len + EXPAND_SPARE;

+    }

+    freeBindingList = b->nextTagBinding;

+  }

+  else {

+    b = (BINDING *)MALLOC(sizeof(BINDING));

+    if (!b)

+      return XML_ERROR_NO_MEMORY;

+    b->uri = (XML_Char *)MALLOC(sizeof(XML_Char) * (len + EXPAND_SPARE));

+    if (!b->uri) {

+      FREE(b);

+      return XML_ERROR_NO_MEMORY;

+    }

+    b->uriAlloc = len + EXPAND_SPARE;

+  }

+  b->uriLen = len;

+  memcpy(b->uri, uri, len * sizeof(XML_Char));

+  if (namespaceSeparator)

+    b->uri[len - 1] = namespaceSeparator;

+  b->prefix = prefix;

+  b->attId = attId;

+  b->prevPrefixBinding = prefix->binding;

+  /* NULL binding when default namespace undeclared */

+  if (*uri == XML_T('\0') && prefix == &_dtd->defaultPrefix)

+    prefix->binding = NULL;

+  else

+    prefix->binding = b;

+  b->nextTagBinding = *bindingsPtr;

+  *bindingsPtr = b;

+  /* if attId == NULL then we are not starting a namespace scope */

+  if (attId && startNamespaceDeclHandler)

+    startNamespaceDeclHandler(handlerArg, prefix->name,

+                              prefix->binding ? uri : 0);

+  return XML_ERROR_NONE;

+}

+

+/* The idea here is to avoid using stack for each CDATA section when

+   the whole file is parsed with one call.

+*/

+static enum XML_Error PTRCALL

+cdataSectionProcessor(XML_Parser parser,

+                      const char *start,

+                      const char *end,

+                      const char **endPtr)

+{

+  enum XML_Error result = doCdataSection(parser, encoding, &start, end,

+                                         endPtr, (XML_Bool)!ps_finalBuffer);

+  if (result != XML_ERROR_NONE)

+    return result;

+  if (start) {

+    if (parentParser) {  /* we are parsing an external entity */

+      processor = externalEntityContentProcessor;

+      return externalEntityContentProcessor(parser, start, end, endPtr);

+    }

+    else {

+      processor = contentProcessor;

+      return contentProcessor(parser, start, end, endPtr);

+    }

+  }

+  return result;

+}

+

+/* startPtr gets set to non-null if the section is closed, and to null if

+   the section is not yet closed.

+*/

+static enum XML_Error

+doCdataSection(XML_Parser parser,

+               const ENCODING *enc,

+               const char **startPtr,

+               const char *end,

+               const char **nextPtr,

+               XML_Bool haveMore)

+{

+  const char *s = *startPtr;

+  const char **eventPP;

+  const char **eventEndPP;

+  if (enc == encoding) {

+    eventPP = &eventPtr;

+    *eventPP = s;

+    eventEndPP = &eventEndPtr;

+  }

+  else {

+    eventPP = &(openInternalEntities->internalEventPtr);

+    eventEndPP = &(openInternalEntities->internalEventEndPtr);

+  }

+  *eventPP = s;

+  *startPtr = NULL;

+

+  for (;;) {

+    const char *next;

+    int tok = XmlCdataSectionTok(enc, s, end, &next);

+    *eventEndPP = next;

+    switch (tok) {

+    case XML_TOK_CDATA_SECT_CLOSE:

+      if (endCdataSectionHandler)

+        endCdataSectionHandler(handlerArg);

+#if 0

+      /* see comment under XML_TOK_CDATA_SECT_OPEN */

+      else if (characterDataHandler)

+        characterDataHandler(handlerArg, dataBuf, 0);

+#endif

+      else if (defaultHandler)

+        reportDefault(parser, enc, s, next);

+      *startPtr = next;

+      *nextPtr = next;

+      if (ps_parsing == XML_FINISHED)

+        return XML_ERROR_ABORTED;

+      else

+        return XML_ERROR_NONE;

+    case XML_TOK_DATA_NEWLINE:

+      if (characterDataHandler) {

+        XML_Char c = 0xA;

+        characterDataHandler(handlerArg, &c, 1);

+      }

+      else if (defaultHandler)

+        reportDefault(parser, enc, s, next);

+      break;

+    case XML_TOK_DATA_CHARS:

+      if (characterDataHandler) {

+        if (MUST_CONVERT(enc, s)) {

+          for (;;) {

+            ICHAR *dataPtr = (ICHAR *)dataBuf;

+            XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);

+            *eventEndPP = next;

+            characterDataHandler(handlerArg, dataBuf,

+                                 (int)(dataPtr - (ICHAR *)dataBuf));

+            if (s == next)

+              break;

+            *eventPP = s;

+          }

+        }

+        else

+          characterDataHandler(handlerArg,

+                               (XML_Char *)s,

+                               (int)((XML_Char *)next - (XML_Char *)s));

+      }

+      else if (defaultHandler)

+        reportDefault(parser, enc, s, next);

+      break;

+    case XML_TOK_INVALID:

+      *eventPP = next;

+      return XML_ERROR_INVALID_TOKEN;

+    case XML_TOK_PARTIAL_CHAR:

+      if (haveMore) {

+        *nextPtr = s;

+        return XML_ERROR_NONE;

+      }

+      return XML_ERROR_PARTIAL_CHAR;

+    case XML_TOK_PARTIAL:

+    case XML_TOK_NONE:

+      if (haveMore) {

+        *nextPtr = s;

+        return XML_ERROR_NONE;

+      }

+      return XML_ERROR_UNCLOSED_CDATA_SECTION;

+    default:

+      *eventPP = next;

+      return XML_ERROR_UNEXPECTED_STATE;

+    }

+

+    *eventPP = s = next;

+    switch (ps_parsing) {

+    case XML_SUSPENDED:

+      *nextPtr = next;

+      return XML_ERROR_NONE;

+    case XML_FINISHED:

+      return XML_ERROR_ABORTED;

+    default: ;

+    }

+  }

+  /* not reached */

+}

+

+#ifdef XML_DTD

+

+/* The idea here is to avoid using stack for each IGNORE section when

+   the whole file is parsed with one call.

+*/

+static enum XML_Error PTRCALL

+ignoreSectionProcessor(XML_Parser parser,

+                       const char *start,

+                       const char *end,

+                       const char **endPtr)

+{

+  enum XML_Error result = doIgnoreSection(parser, encoding, &start, end,

+                                          endPtr, (XML_Bool)!ps_finalBuffer);

+  if (result != XML_ERROR_NONE)

+    return result;

+  if (start) {

+    processor = prologProcessor;

+    return prologProcessor(parser, start, end, endPtr);

+  }

+  return result;

+}

+

+/* startPtr gets set to non-null is the section is closed, and to null

+   if the section is not yet closed.

+*/

+static enum XML_Error

+doIgnoreSection(XML_Parser parser,

+                const ENCODING *enc,

+                const char **startPtr,

+                const char *end,

+                const char **nextPtr,

+                XML_Bool haveMore)

+{

+  const char *next;

+  int tok;

+  const char *s = *startPtr;

+  const char **eventPP;

+  const char **eventEndPP;

+  if (enc == encoding) {

+    eventPP = &eventPtr;

+    *eventPP = s;

+    eventEndPP = &eventEndPtr;

+  }

+  else {

+    eventPP = &(openInternalEntities->internalEventPtr);

+    eventEndPP = &(openInternalEntities->internalEventEndPtr);

+  }

+  *eventPP = s;

+  *startPtr = NULL;

+  tok = XmlIgnoreSectionTok(enc, s, end, &next);

+  *eventEndPP = next;

+  switch (tok) {

+  case XML_TOK_IGNORE_SECT:

+    if (defaultHandler)

+      reportDefault(parser, enc, s, next);

+    *startPtr = next;

+    *nextPtr = next;

+    if (ps_parsing == XML_FINISHED)

+      return XML_ERROR_ABORTED;

+    else

+      return XML_ERROR_NONE;

+  case XML_TOK_INVALID:

+    *eventPP = next;

+    return XML_ERROR_INVALID_TOKEN;

+  case XML_TOK_PARTIAL_CHAR:

+    if (haveMore) {

+      *nextPtr = s;

+      return XML_ERROR_NONE;

+    }

+    return XML_ERROR_PARTIAL_CHAR;

+  case XML_TOK_PARTIAL:

+  case XML_TOK_NONE:

+    if (haveMore) {

+      *nextPtr = s;

+      return XML_ERROR_NONE;

+    }

+    return XML_ERROR_SYNTAX; /* XML_ERROR_UNCLOSED_IGNORE_SECTION */

+  default:

+    *eventPP = next;

+    return XML_ERROR_UNEXPECTED_STATE;

+  }

+  /* not reached */

+}

+

+#endif /* XML_DTD */

+

+static enum XML_Error

+initializeEncoding(XML_Parser parser)

+{

+  const char *s;

+#ifdef XML_UNICODE

+  char encodingBuf[128];

+  if (!protocolEncodingName)

+    s = NULL;

+  else {

+    int i;

+    for (i = 0; protocolEncodingName[i]; i++) {

+      if (i == sizeof(encodingBuf) - 1

+          || (protocolEncodingName[i] & ~0x7f) != 0) {

+        encodingBuf[0] = '\0';

+        break;

+      }

+      encodingBuf[i] = (char)protocolEncodingName[i];

+    }

+    encodingBuf[i] = '\0';

+    s = encodingBuf;

+  }

+#else

+  s = protocolEncodingName;

+#endif

+  if ((ns ? XmlInitEncodingNS : XmlInitEncoding)(&initEncoding, &encoding, s))

+    return XML_ERROR_NONE;

+  return handleUnknownEncoding(parser, protocolEncodingName);

+}

+

+static enum XML_Error

+processXmlDecl(XML_Parser parser, int isGeneralTextEntity,

+               const char *s, const char *next)

+{

+  const char *encodingName = NULL;

+  const XML_Char *storedEncName = NULL;

+  const ENCODING *newEncoding = NULL;

+  const char *version = NULL;

+  const char *versionend;

+  const XML_Char *storedversion = NULL;

+  int standalone = -1;

+  if (!(ns

+        ? XmlParseXmlDeclNS

+        : XmlParseXmlDecl)(isGeneralTextEntity,

+                           encoding,

+                           s,

+                           next,

+                           &eventPtr,

+                           &version,

+                           &versionend,

+                           &encodingName,

+                           &newEncoding,

+                           &standalone)) {

+    if (isGeneralTextEntity)

+      return XML_ERROR_TEXT_DECL;

+    else

+      return XML_ERROR_XML_DECL;

+  }

+  if (!isGeneralTextEntity && standalone == 1) {

+    _dtd->standalone = XML_TRUE;

+#ifdef XML_DTD

+    if (paramEntityParsing == XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE)

+      paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;

+#endif /* XML_DTD */

+  }

+  if (xmlDeclHandler) {

+    if (encodingName != NULL) {

+      storedEncName = poolStoreString(&temp2Pool,

+                                      encoding,

+                                      encodingName,

+                                      encodingName

+                                      + XmlNameLength(encoding, encodingName));

+      if (!storedEncName)

+              return XML_ERROR_NO_MEMORY;

+      poolFinish(&temp2Pool);

+    }

+    if (version) {

+      storedversion = poolStoreString(&temp2Pool,

+                                      encoding,

+                                      version,

+                                      versionend - encoding->minBytesPerChar);

+      if (!storedversion)

+        return XML_ERROR_NO_MEMORY;

+    }

+    xmlDeclHandler(handlerArg, storedversion, storedEncName, standalone);

+  }

+  else if (defaultHandler)

+    reportDefault(parser, encoding, s, next);

+  if (protocolEncodingName == NULL) {

+    if (newEncoding) {

+      if (newEncoding->minBytesPerChar != encoding->minBytesPerChar) {

+        eventPtr = encodingName;

+        return XML_ERROR_INCORRECT_ENCODING;

+      }

+      encoding = newEncoding;

+    }

+    else if (encodingName) {

+      enum XML_Error result;

+      if (!storedEncName) {

+        storedEncName = poolStoreString(

+          &temp2Pool, encoding, encodingName,

+          encodingName + XmlNameLength(encoding, encodingName));

+        if (!storedEncName)

+          return XML_ERROR_NO_MEMORY;

+      }

+      result = handleUnknownEncoding(parser, storedEncName);

+      poolClear(&temp2Pool);

+      if (result == XML_ERROR_UNKNOWN_ENCODING)

+        eventPtr = encodingName;

+      return result;

+    }

+  }

+

+  if (storedEncName || storedversion)

+    poolClear(&temp2Pool);

+

+  return XML_ERROR_NONE;

+}

+

+static enum XML_Error

+handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName)

+{

+  if (unknownEncodingHandler) {

+    XML_Encoding info;

+    int i;

+    for (i = 0; i < 256; i++)

+      info.map[i] = -1;

+    info.convert = NULL;

+    info.data = NULL;

+    info.release = NULL;

+    if (unknownEncodingHandler(unknownEncodingHandlerData, encodingName,

+                               &info)) {

+      ENCODING *enc;

+      unknownEncodingMem = MALLOC(XmlSizeOfUnknownEncoding());

+      if (!unknownEncodingMem) {

+        if (info.release)

+          info.release(info.data);

+        return XML_ERROR_NO_MEMORY;

+      }

+      enc = (ns

+             ? XmlInitUnknownEncodingNS

+             : XmlInitUnknownEncoding)(unknownEncodingMem,

+                                       info.map,

+                                       info.convert,

+                                       info.data);

+      if (enc) {

+        unknownEncodingData = info.data;

+        unknownEncodingRelease = info.release;

+        encoding = enc;

+        return XML_ERROR_NONE;

+      }

+    }

+    if (info.release != NULL)

+      info.release(info.data);

+  }

+  return XML_ERROR_UNKNOWN_ENCODING;

+}

+

+static enum XML_Error PTRCALL

+prologInitProcessor(XML_Parser parser,

+                    const char *s,

+                    const char *end,

+                    const char **nextPtr)

+{

+  enum XML_Error result = initializeEncoding(parser);

+  if (result != XML_ERROR_NONE)

+    return result;

+  processor = prologProcessor;

+  return prologProcessor(parser, s, end, nextPtr);

+}

+

+#ifdef XML_DTD

+

+static enum XML_Error PTRCALL

+externalParEntInitProcessor(XML_Parser parser,

+                            const char *s,

+                            const char *end,

+                            const char **nextPtr)

+{

+  enum XML_Error result = initializeEncoding(parser);

+  if (result != XML_ERROR_NONE)

+    return result;

+

+  /* we know now that XML_Parse(Buffer) has been called,

+     so we consider the external parameter entity read */

+  _dtd->paramEntityRead = XML_TRUE;

+

+  if (prologState.inEntityValue) {

+    processor = entityValueInitProcessor;

+    return entityValueInitProcessor(parser, s, end, nextPtr);

+  }

+  else {

+    processor = externalParEntProcessor;

+    return externalParEntProcessor(parser, s, end, nextPtr);

+  }

+}

+

+static enum XML_Error PTRCALL

+entityValueInitProcessor(XML_Parser parser,

+                         const char *s,

+                         const char *end,

+                         const char **nextPtr)

+{

+  int tok;

+  const char *start = s;

+  const char *next = start;

+  eventPtr = start;

+

+  for (;;) {

+    tok = XmlPrologTok(encoding, start, end, &next);

+    eventEndPtr = next;

+    if (tok <= 0) {

+      if (!ps_finalBuffer && tok != XML_TOK_INVALID) {

+        *nextPtr = s;

+        return XML_ERROR_NONE;

+      }

+      switch (tok) {

+      case XML_TOK_INVALID:

+        return XML_ERROR_INVALID_TOKEN;

+      case XML_TOK_PARTIAL:

+        return XML_ERROR_UNCLOSED_TOKEN;

+      case XML_TOK_PARTIAL_CHAR:

+        return XML_ERROR_PARTIAL_CHAR;

+      case XML_TOK_NONE:   /* start == end */

+      default:

+        break;

+      }

+      /* found end of entity value - can store it now */

+      return storeEntityValue(parser, encoding, s, end);

+    }

+    else if (tok == XML_TOK_XML_DECL) {

+      enum XML_Error result;

+      result = processXmlDecl(parser, 0, start, next);

+      if (result != XML_ERROR_NONE)

+        return result;

+      switch (ps_parsing) {

+      case XML_SUSPENDED:

+        *nextPtr = next;

+        return XML_ERROR_NONE;

+      case XML_FINISHED:

+        return XML_ERROR_ABORTED;

+      default:

+        *nextPtr = next;

+      }

+      /* stop scanning for text declaration - we found one */

+      processor = entityValueProcessor;

+      return entityValueProcessor(parser, next, end, nextPtr);

+    }

+    /* If we are at the end of the buffer, this would cause XmlPrologTok to

+       return XML_TOK_NONE on the next call, which would then cause the

+       function to exit with *nextPtr set to s - that is what we want for other

+       tokens, but not for the BOM - we would rather like to skip it;

+       then, when this routine is entered the next time, XmlPrologTok will

+       return XML_TOK_INVALID, since the BOM is still in the buffer

+    */

+    else if (tok == XML_TOK_BOM && next == end && !ps_finalBuffer) {

+      *nextPtr = next;

+      return XML_ERROR_NONE;

+    }

+    start = next;

+    eventPtr = start;

+  }

+}

+

+static enum XML_Error PTRCALL

+externalParEntProcessor(XML_Parser parser,

+                        const char *s,

+                        const char *end,

+                        const char **nextPtr)

+{

+  const char *next = s;

+  int tok;

+

+  tok = XmlPrologTok(encoding, s, end, &next);

+  if (tok <= 0) {

+    if (!ps_finalBuffer && tok != XML_TOK_INVALID) {

+      *nextPtr = s;

+      return XML_ERROR_NONE;

+    }

+    switch (tok) {

+    case XML_TOK_INVALID:

+      return XML_ERROR_INVALID_TOKEN;

+    case XML_TOK_PARTIAL:

+      return XML_ERROR_UNCLOSED_TOKEN;

+    case XML_TOK_PARTIAL_CHAR:

+      return XML_ERROR_PARTIAL_CHAR;

+    case XML_TOK_NONE:   /* start == end */

+    default:

+      break;

+    }

+  }

+  /* This would cause the next stage, i.e. doProlog to be passed XML_TOK_BOM.

+     However, when parsing an external subset, doProlog will not accept a BOM

+     as valid, and report a syntax error, so we have to skip the BOM

+  */

+  else if (tok == XML_TOK_BOM) {

+    s = next;

+    tok = XmlPrologTok(encoding, s, end, &next);

+  }

+

+  processor = prologProcessor;

+  return doProlog(parser, encoding, s, end, tok, next,

+                  nextPtr, (XML_Bool)!ps_finalBuffer);

+}

+

+static enum XML_Error PTRCALL

+entityValueProcessor(XML_Parser parser,

+                     const char *s,

+                     const char *end,

+                     const char **nextPtr)

+{

+  const char *start = s;

+  const char *next = s;

+  const ENCODING *enc = encoding;

+  int tok;

+

+  for (;;) {

+    tok = XmlPrologTok(enc, start, end, &next);

+    if (tok <= 0) {

+      if (!ps_finalBuffer && tok != XML_TOK_INVALID) {

+        *nextPtr = s;

+        return XML_ERROR_NONE;

+      }

+      switch (tok) {

+      case XML_TOK_INVALID:

+        return XML_ERROR_INVALID_TOKEN;

+      case XML_TOK_PARTIAL:

+        return XML_ERROR_UNCLOSED_TOKEN;

+      case XML_TOK_PARTIAL_CHAR:

+        return XML_ERROR_PARTIAL_CHAR;

+      case XML_TOK_NONE:   /* start == end */

+      default:

+        break;

+      }

+      /* found end of entity value - can store it now */

+      return storeEntityValue(parser, enc, s, end);

+    }

+    start = next;

+  }

+}

+

+#endif /* XML_DTD */

+

+static enum XML_Error PTRCALL

+prologProcessor(XML_Parser parser,

+                const char *s,

+                const char *end,

+                const char **nextPtr)

+{

+  const char *next = s;

+  int tok = XmlPrologTok(encoding, s, end, &next);

+  return doProlog(parser, encoding, s, end, tok, next,

+                  nextPtr, (XML_Bool)!ps_finalBuffer);

+}

+

+static enum XML_Error

+doProlog(XML_Parser parser,

+         const ENCODING *enc,

+         const char *s,

+         const char *end,

+         int tok,

+         const char *next,

+         const char **nextPtr,

+         XML_Bool haveMore)

+{

+#ifdef XML_DTD

+  static const XML_Char externalSubsetName[] = { '#' , '\0' };

+#endif /* XML_DTD */

+  static const XML_Char atypeCDATA[] = { 'C', 'D', 'A', 'T', 'A', '\0' };

+  static const XML_Char atypeID[] = { 'I', 'D', '\0' };

+  static const XML_Char atypeIDREF[] = { 'I', 'D', 'R', 'E', 'F', '\0' };

+  static const XML_Char atypeIDREFS[] = { 'I', 'D', 'R', 'E', 'F', 'S', '\0' };

+  static const XML_Char atypeENTITY[] = { 'E', 'N', 'T', 'I', 'T', 'Y', '\0' };

+  static const XML_Char atypeENTITIES[] =

+      { 'E', 'N', 'T', 'I', 'T', 'I', 'E', 'S', '\0' };

+  static const XML_Char atypeNMTOKEN[] = {

+      'N', 'M', 'T', 'O', 'K', 'E', 'N', '\0' };

+  static const XML_Char atypeNMTOKENS[] = {

+      'N', 'M', 'T', 'O', 'K', 'E', 'N', 'S', '\0' };

+  static const XML_Char notationPrefix[] = {

+      'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N', '(', '\0' };

+  static const XML_Char enumValueSep[] = { '|', '\0' };

+  static const XML_Char enumValueStart[] = { '(', '\0' };

+

+  /* save one level of indirection */

+  DTD * const dtd = _dtd;

+

+  const char **eventPP;

+  const char **eventEndPP;

+  enum XML_Content_Quant quant;

+

+  if (enc == encoding) {

+    eventPP = &eventPtr;

+    eventEndPP = &eventEndPtr;

+  }

+  else {

+    eventPP = &(openInternalEntities->internalEventPtr);

+    eventEndPP = &(openInternalEntities->internalEventEndPtr);

+  }

+

+  for (;;) {

+    int role;

+    XML_Bool handleDefault = XML_TRUE;

+    *eventPP = s;

+    *eventEndPP = next;

+    if (tok <= 0) {

+      if (haveMore && tok != XML_TOK_INVALID) {

+        *nextPtr = s;

+        return XML_ERROR_NONE;

+      }

+      switch (tok) {

+      case XML_TOK_INVALID:

+        *eventPP = next;

+        return XML_ERROR_INVALID_TOKEN;

+      case XML_TOK_PARTIAL:

+        return XML_ERROR_UNCLOSED_TOKEN;

+      case XML_TOK_PARTIAL_CHAR:

+        return XML_ERROR_PARTIAL_CHAR;

+      case -XML_TOK_PROLOG_S:

+        tok = -tok;

+        break;

+      case XML_TOK_NONE:

+#ifdef XML_DTD

+        /* for internal PE NOT referenced between declarations */

+        if (enc != encoding && !openInternalEntities->betweenDecl) {

+          *nextPtr = s;

+          return XML_ERROR_NONE;

+        }

+        /* WFC: PE Between Declarations - must check that PE contains

+           complete markup, not only for external PEs, but also for

+           internal PEs if the reference occurs between declarations.

+        */

+        if (isParamEntity || enc != encoding) {

+          if (XmlTokenRole(&prologState, XML_TOK_NONE, end, end, enc)

+              == XML_ROLE_ERROR)

+            return XML_ERROR_INCOMPLETE_PE;

+          *nextPtr = s;

+          return XML_ERROR_NONE;

+        }

+#endif /* XML_DTD */

+        return XML_ERROR_NO_ELEMENTS;

+      default:

+        tok = -tok;

+        next = end;

+        break;

+      }

+    }

+    role = XmlTokenRole(&prologState, tok, s, next, enc);

+    switch (role) {

+    case XML_ROLE_XML_DECL:

+      {

+        enum XML_Error result = processXmlDecl(parser, 0, s, next);

+        if (result != XML_ERROR_NONE)

+          return result;

+        enc = encoding;

+        handleDefault = XML_FALSE;

+      }

+      break;

+    case XML_ROLE_DOCTYPE_NAME:

+      if (startDoctypeDeclHandler) {

+        doctypeName = poolStoreString(&tempPool, enc, s, next);

+        if (!doctypeName)

+          return XML_ERROR_NO_MEMORY;

+        poolFinish(&tempPool);

+        doctypePubid = NULL;

+        handleDefault = XML_FALSE;

+      }

+      doctypeSysid = NULL; /* always initialize to NULL */

+      break;

+    case XML_ROLE_DOCTYPE_INTERNAL_SUBSET:

+      if (startDoctypeDeclHandler) {

+        startDoctypeDeclHandler(handlerArg, doctypeName, doctypeSysid,

+                                doctypePubid, 1);

+        doctypeName = NULL;

+        poolClear(&tempPool);

+        handleDefault = XML_FALSE;

+      }

+      break;

+#ifdef XML_DTD

+    case XML_ROLE_TEXT_DECL:

+      {

+        enum XML_Error result = processXmlDecl(parser, 1, s, next);

+        if (result != XML_ERROR_NONE)

+          return result;

+        enc = encoding;

+        handleDefault = XML_FALSE;

+      }

+      break;

+#endif /* XML_DTD */

+    case XML_ROLE_DOCTYPE_PUBLIC_ID:

+#ifdef XML_DTD

+      useForeignDTD = XML_FALSE;

+      declEntity = (ENTITY *)lookup(&dtd->paramEntities,

+                                    externalSubsetName,

+                                    sizeof(ENTITY));

+      if (!declEntity)

+        return XML_ERROR_NO_MEMORY;

+#endif /* XML_DTD */

+      dtd->hasParamEntityRefs = XML_TRUE;

+      if (startDoctypeDeclHandler) {

+        if (!XmlIsPublicId(enc, s, next, eventPP))

+          return XML_ERROR_PUBLICID;

+        doctypePubid = poolStoreString(&tempPool, enc,

+                                       s + enc->minBytesPerChar,

+                                       next - enc->minBytesPerChar);

+        if (!doctypePubid)

+          return XML_ERROR_NO_MEMORY;

+        normalizePublicId((XML_Char *)doctypePubid);

+        poolFinish(&tempPool);

+        handleDefault = XML_FALSE;

+        goto alreadyChecked;

+      }

+      /* fall through */

+    case XML_ROLE_ENTITY_PUBLIC_ID:

+      if (!XmlIsPublicId(enc, s, next, eventPP))

+        return XML_ERROR_PUBLICID;

+    alreadyChecked:

+      if (dtd->keepProcessing && declEntity) {

+        XML_Char *tem = poolStoreString(&dtd->pool,

+                                        enc,

+                                        s + enc->minBytesPerChar,

+                                        next - enc->minBytesPerChar);

+        if (!tem)

+          return XML_ERROR_NO_MEMORY;

+        normalizePublicId(tem);

+        declEntity->publicId = tem;

+        poolFinish(&dtd->pool);

+        if (entityDeclHandler)

+          handleDefault = XML_FALSE;

+      }

+      break;

+    case XML_ROLE_DOCTYPE_CLOSE:

+      if (doctypeName) {

+        startDoctypeDeclHandler(handlerArg, doctypeName,

+                                doctypeSysid, doctypePubid, 0);

+        poolClear(&tempPool);

+        handleDefault = XML_FALSE;

+      }

+      /* doctypeSysid will be non-NULL in the case of a previous

+         XML_ROLE_DOCTYPE_SYSTEM_ID, even if startDoctypeDeclHandler

+         was not set, indicating an external subset

+      */

+#ifdef XML_DTD

+      if (doctypeSysid || useForeignDTD) {

+        XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;

+        dtd->hasParamEntityRefs = XML_TRUE;

+        if (paramEntityParsing && externalEntityRefHandler) {

+          ENTITY *entity = (ENTITY *)lookup(&dtd->paramEntities,

+                                            externalSubsetName,

+                                            sizeof(ENTITY));

+          if (!entity)

+            return XML_ERROR_NO_MEMORY;

+          if (useForeignDTD)

+            entity->base = curBase;

+          dtd->paramEntityRead = XML_FALSE;

+          if (!externalEntityRefHandler(externalEntityRefHandlerArg,

+                                        0,

+                                        entity->base,

+                                        entity->systemId,

+                                        entity->publicId))

+            return XML_ERROR_EXTERNAL_ENTITY_HANDLING;

+          if (dtd->paramEntityRead) {

+            if (!dtd->standalone &&

+                notStandaloneHandler &&

+                !notStandaloneHandler(handlerArg))

+              return XML_ERROR_NOT_STANDALONE;

+          }

+          /* if we didn't read the foreign DTD then this means that there

+             is no external subset and we must reset dtd->hasParamEntityRefs

+          */

+          else if (!doctypeSysid)

+            dtd->hasParamEntityRefs = hadParamEntityRefs;

+          /* end of DTD - no need to update dtd->keepProcessing */

+        }

+        useForeignDTD = XML_FALSE;

+      }

+#endif /* XML_DTD */

+      if (endDoctypeDeclHandler) {

+        endDoctypeDeclHandler(handlerArg);

+        handleDefault = XML_FALSE;

+      }

+      break;

+    case XML_ROLE_INSTANCE_START:

+#ifdef XML_DTD

+      /* if there is no DOCTYPE declaration then now is the

+         last chance to read the foreign DTD

+      */

+      if (useForeignDTD) {

+        XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;

+        dtd->hasParamEntityRefs = XML_TRUE;

+        if (paramEntityParsing && externalEntityRefHandler) {

+          ENTITY *entity = (ENTITY *)lookup(&dtd->paramEntities,

+                                            externalSubsetName,

+                                            sizeof(ENTITY));

+          if (!entity)

+            return XML_ERROR_NO_MEMORY;

+          entity->base = curBase;

+          dtd->paramEntityRead = XML_FALSE;

+          if (!externalEntityRefHandler(externalEntityRefHandlerArg,

+                                        0,

+                                        entity->base,

+                                        entity->systemId,

+                                        entity->publicId))

+            return XML_ERROR_EXTERNAL_ENTITY_HANDLING;

+          if (dtd->paramEntityRead) {

+            if (!dtd->standalone &&

+                notStandaloneHandler &&

+                !notStandaloneHandler(handlerArg))

+              return XML_ERROR_NOT_STANDALONE;

+          }

+          /* if we didn't read the foreign DTD then this means that there

+             is no external subset and we must reset dtd->hasParamEntityRefs

+          */

+          else

+            dtd->hasParamEntityRefs = hadParamEntityRefs;

+          /* end of DTD - no need to update dtd->keepProcessing */

+        }

+      }

+#endif /* XML_DTD */

+      processor = contentProcessor;

+      return contentProcessor(parser, s, end, nextPtr);

+    case XML_ROLE_ATTLIST_ELEMENT_NAME:

+      declElementType = getElementType(parser, enc, s, next);

+      if (!declElementType)

+        return XML_ERROR_NO_MEMORY;

+      goto checkAttListDeclHandler;

+    case XML_ROLE_ATTRIBUTE_NAME:

+      declAttributeId = getAttributeId(parser, enc, s, next);

+      if (!declAttributeId)

+        return XML_ERROR_NO_MEMORY;

+      declAttributeIsCdata = XML_FALSE;

+      declAttributeType = NULL;

+      declAttributeIsId = XML_FALSE;

+      goto checkAttListDeclHandler;

+    case XML_ROLE_ATTRIBUTE_TYPE_CDATA:

+      declAttributeIsCdata = XML_TRUE;

+      declAttributeType = atypeCDATA;

+      goto checkAttListDeclHandler;

+    case XML_ROLE_ATTRIBUTE_TYPE_ID:

+      declAttributeIsId = XML_TRUE;

+      declAttributeType = atypeID;

+      goto checkAttListDeclHandler;

+    case XML_ROLE_ATTRIBUTE_TYPE_IDREF:

+      declAttributeType = atypeIDREF;

+      goto checkAttListDeclHandler;

+    case XML_ROLE_ATTRIBUTE_TYPE_IDREFS:

+      declAttributeType = atypeIDREFS;

+      goto checkAttListDeclHandler;

+    case XML_ROLE_ATTRIBUTE_TYPE_ENTITY:

+      declAttributeType = atypeENTITY;

+      goto checkAttListDeclHandler;

+    case XML_ROLE_ATTRIBUTE_TYPE_ENTITIES:

+      declAttributeType = atypeENTITIES;

+      goto checkAttListDeclHandler;

+    case XML_ROLE_ATTRIBUTE_TYPE_NMTOKEN:

+      declAttributeType = atypeNMTOKEN;

+      goto checkAttListDeclHandler;

+    case XML_ROLE_ATTRIBUTE_TYPE_NMTOKENS:

+      declAttributeType = atypeNMTOKENS;

+    checkAttListDeclHandler:

+      if (dtd->keepProcessing && attlistDeclHandler)

+        handleDefault = XML_FALSE;

+      break;

+    case XML_ROLE_ATTRIBUTE_ENUM_VALUE:

+    case XML_ROLE_ATTRIBUTE_NOTATION_VALUE:

+      if (dtd->keepProcessing && attlistDeclHandler) {

+        const XML_Char *prefix;

+        if (declAttributeType) {

+          prefix = enumValueSep;

+        }

+        else {

+          prefix = (role == XML_ROLE_ATTRIBUTE_NOTATION_VALUE

+                    ? notationPrefix

+                    : enumValueStart);

+        }

+        if (!poolAppendString(&tempPool, prefix))

+          return XML_ERROR_NO_MEMORY;

+        if (!poolAppend(&tempPool, enc, s, next))

+          return XML_ERROR_NO_MEMORY;

+        declAttributeType = tempPool.start;

+        handleDefault = XML_FALSE;

+      }

+      break;

+    case XML_ROLE_IMPLIED_ATTRIBUTE_VALUE:

+    case XML_ROLE_REQUIRED_ATTRIBUTE_VALUE:

+      if (dtd->keepProcessing) {

+        if (!defineAttribute(declElementType, declAttributeId,

+                             declAttributeIsCdata, declAttributeIsId,

+                             0, parser))

+          return XML_ERROR_NO_MEMORY;

+        if (attlistDeclHandler && declAttributeType) {

+          if (*declAttributeType == XML_T('(')

+              || (*declAttributeType == XML_T('N')

+                  && declAttributeType[1] == XML_T('O'))) {

+            /* Enumerated or Notation type */

+            if (!poolAppendChar(&tempPool, XML_T(')'))

+                || !poolAppendChar(&tempPool, XML_T('\0')))

+              return XML_ERROR_NO_MEMORY;

+            declAttributeType = tempPool.start;

+            poolFinish(&tempPool);

+          }

+          *eventEndPP = s;

+          attlistDeclHandler(handlerArg, declElementType->name,

+                             declAttributeId->name, declAttributeType,

+                             0, role == XML_ROLE_REQUIRED_ATTRIBUTE_VALUE);

+          poolClear(&tempPool);

+          handleDefault = XML_FALSE;

+        }

+      }

+      break;

+    case XML_ROLE_DEFAULT_ATTRIBUTE_VALUE:

+    case XML_ROLE_FIXED_ATTRIBUTE_VALUE:

+      if (dtd->keepProcessing) {

+        const XML_Char *attVal;

+        enum XML_Error result =

+          storeAttributeValue(parser, enc, declAttributeIsCdata,

+                              s + enc->minBytesPerChar,

+                              next - enc->minBytesPerChar,

+                              &dtd->pool);

+        if (result)

+          return result;

+        attVal = poolStart(&dtd->pool);

+        poolFinish(&dtd->pool);

+        /* ID attributes aren't allowed to have a default */

+        if (!defineAttribute(declElementType, declAttributeId,

+                             declAttributeIsCdata, XML_FALSE, attVal, parser))

+          return XML_ERROR_NO_MEMORY;

+        if (attlistDeclHandler && declAttributeType) {

+          if (*declAttributeType == XML_T('(')

+              || (*declAttributeType == XML_T('N')

+                  && declAttributeType[1] == XML_T('O'))) {

+            /* Enumerated or Notation type */

+            if (!poolAppendChar(&tempPool, XML_T(')'))

+                || !poolAppendChar(&tempPool, XML_T('\0')))

+              return XML_ERROR_NO_MEMORY;

+            declAttributeType = tempPool.start;

+            poolFinish(&tempPool);

+          }

+          *eventEndPP = s;

+          attlistDeclHandler(handlerArg, declElementType->name,

+                             declAttributeId->name, declAttributeType,

+                             attVal,

+                             role == XML_ROLE_FIXED_ATTRIBUTE_VALUE);

+          poolClear(&tempPool);

+          handleDefault = XML_FALSE;

+        }

+      }

+      break;

+    case XML_ROLE_ENTITY_VALUE:

+      if (dtd->keepProcessing) {

+        enum XML_Error result = storeEntityValue(parser, enc,

+                                            s + enc->minBytesPerChar,

+                                            next - enc->minBytesPerChar);

+        if (declEntity) {

+          declEntity->textPtr = poolStart(&dtd->entityValuePool);

+          declEntity->textLen = (int)(poolLength(&dtd->entityValuePool));

+          poolFinish(&dtd->entityValuePool);

+          if (entityDeclHandler) {

+            *eventEndPP = s;

+            entityDeclHandler(handlerArg,

+                              declEntity->name,

+                              declEntity->is_param,

+                              declEntity->textPtr,

+                              declEntity->textLen,

+                              curBase, 0, 0, 0);

+            handleDefault = XML_FALSE;

+          }

+        }

+        else

+          poolDiscard(&dtd->entityValuePool);

+        if (result != XML_ERROR_NONE)

+          return result;

+      }

+      break;

+    case XML_ROLE_DOCTYPE_SYSTEM_ID:

+#ifdef XML_DTD

+      useForeignDTD = XML_FALSE;

+#endif /* XML_DTD */

+      dtd->hasParamEntityRefs = XML_TRUE;

+      if (startDoctypeDeclHandler) {

+        doctypeSysid = poolStoreString(&tempPool, enc,

+                                       s + enc->minBytesPerChar,

+                                       next - enc->minBytesPerChar);

+        if (doctypeSysid == NULL)

+          return XML_ERROR_NO_MEMORY;

+        poolFinish(&tempPool);

+        handleDefault = XML_FALSE;

+      }

+#ifdef XML_DTD

+      else

+        /* use externalSubsetName to make doctypeSysid non-NULL

+           for the case where no startDoctypeDeclHandler is set */

+        doctypeSysid = externalSubsetName;

+#endif /* XML_DTD */

+      if (!dtd->standalone

+#ifdef XML_DTD

+          && !paramEntityParsing

+#endif /* XML_DTD */

+          && notStandaloneHandler

+          && !notStandaloneHandler(handlerArg))

+        return XML_ERROR_NOT_STANDALONE;

+#ifndef XML_DTD

+      break;

+#else /* XML_DTD */

+      if (!declEntity) {

+        declEntity = (ENTITY *)lookup(&dtd->paramEntities,

+                                      externalSubsetName,

+                                      sizeof(ENTITY));

+        if (!declEntity)

+          return XML_ERROR_NO_MEMORY;

+        declEntity->publicId = NULL;

+      }

+      /* fall through */

+#endif /* XML_DTD */

+    case XML_ROLE_ENTITY_SYSTEM_ID:

+      if (dtd->keepProcessing && declEntity) {

+        declEntity->systemId = poolStoreString(&dtd->pool, enc,

+                                               s + enc->minBytesPerChar,

+                                               next - enc->minBytesPerChar);

+        if (!declEntity->systemId)

+          return XML_ERROR_NO_MEMORY;

+        declEntity->base = curBase;

+        poolFinish(&dtd->pool);

+        if (entityDeclHandler)

+          handleDefault = XML_FALSE;

+      }

+      break;

+    case XML_ROLE_ENTITY_COMPLETE:

+      if (dtd->keepProcessing && declEntity && entityDeclHandler) {

+        *eventEndPP = s;

+        entityDeclHandler(handlerArg,

+                          declEntity->name,

+                          declEntity->is_param,

+                          0,0,

+                          declEntity->base,

+                          declEntity->systemId,

+                          declEntity->publicId,

+                          0);

+        handleDefault = XML_FALSE;

+      }

+      break;

+    case XML_ROLE_ENTITY_NOTATION_NAME:

+      if (dtd->keepProcessing && declEntity) {

+        declEntity->notation = poolStoreString(&dtd->pool, enc, s, next);

+        if (!declEntity->notation)

+          return XML_ERROR_NO_MEMORY;

+        poolFinish(&dtd->pool);

+        if (unparsedEntityDeclHandler) {

+          *eventEndPP = s;

+          unparsedEntityDeclHandler(handlerArg,

+                                    declEntity->name,

+                                    declEntity->base,

+                                    declEntity->systemId,

+                                    declEntity->publicId,

+                                    declEntity->notation);

+          handleDefault = XML_FALSE;

+        }

+        else if (entityDeclHandler) {

+          *eventEndPP = s;

+          entityDeclHandler(handlerArg,

+                            declEntity->name,

+                            0,0,0,

+                            declEntity->base,

+                            declEntity->systemId,

+                            declEntity->publicId,

+                            declEntity->notation);

+          handleDefault = XML_FALSE;

+        }

+      }

+      break;

+    case XML_ROLE_GENERAL_ENTITY_NAME:

+      {

+        if (XmlPredefinedEntityName(enc, s, next)) {

+          declEntity = NULL;

+          break;

+        }

+        if (dtd->keepProcessing) {

+          const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);

+          if (!name)

+            return XML_ERROR_NO_MEMORY;

+          declEntity = (ENTITY *)lookup(&dtd->generalEntities, name,

+                                        sizeof(ENTITY));

+          if (!declEntity)

+            return XML_ERROR_NO_MEMORY;

+          if (declEntity->name != name) {

+            poolDiscard(&dtd->pool);

+            declEntity = NULL;

+          }

+          else {

+            poolFinish(&dtd->pool);

+            declEntity->publicId = NULL;

+            declEntity->is_param = XML_FALSE;

+            /* if we have a parent parser or are reading an internal parameter

+               entity, then the entity declaration is not considered "internal"

+            */

+            declEntity->is_internal = !(parentParser || openInternalEntities);

+            if (entityDeclHandler)

+              handleDefault = XML_FALSE;

+          }

+        }

+        else {

+          poolDiscard(&dtd->pool);

+          declEntity = NULL;

+        }

+      }

+      break;

+    case XML_ROLE_PARAM_ENTITY_NAME:

+#ifdef XML_DTD

+      if (dtd->keepProcessing) {

+        const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);

+        if (!name)

+          return XML_ERROR_NO_MEMORY;

+        declEntity = (ENTITY *)lookup(&dtd->paramEntities,

+                                           name, sizeof(ENTITY));

+        if (!declEntity)

+          return XML_ERROR_NO_MEMORY;

+        if (declEntity->name != name) {

+          poolDiscard(&dtd->pool);

+          declEntity = NULL;

+        }

+        else {

+          poolFinish(&dtd->pool);

+          declEntity->publicId = NULL;

+          declEntity->is_param = XML_TRUE;

+          /* if we have a parent parser or are reading an internal parameter

+             entity, then the entity declaration is not considered "internal"

+          */

+          declEntity->is_internal = !(parentParser || openInternalEntities);

+          if (entityDeclHandler)

+            handleDefault = XML_FALSE;

+        }

+      }

+      else {

+        poolDiscard(&dtd->pool);

+        declEntity = NULL;

+      }

+#else /* not XML_DTD */

+      declEntity = NULL;

+#endif /* XML_DTD */

+      break;

+    case XML_ROLE_NOTATION_NAME:

+      declNotationPublicId = NULL;

+      declNotationName = NULL;

+      if (notationDeclHandler) {

+        declNotationName = poolStoreString(&tempPool, enc, s, next);

+        if (!declNotationName)

+          return XML_ERROR_NO_MEMORY;

+        poolFinish(&tempPool);

+        handleDefault = XML_FALSE;

+      }

+      break;

+    case XML_ROLE_NOTATION_PUBLIC_ID:

+      if (!XmlIsPublicId(enc, s, next, eventPP))

+        return XML_ERROR_PUBLICID;

+      if (declNotationName) {  /* means notationDeclHandler != NULL */

+        XML_Char *tem = poolStoreString(&tempPool,

+                                        enc,

+                                        s + enc->minBytesPerChar,

+                                        next - enc->minBytesPerChar);

+        if (!tem)

+          return XML_ERROR_NO_MEMORY;

+        normalizePublicId(tem);

+        declNotationPublicId = tem;

+        poolFinish(&tempPool);

+        handleDefault = XML_FALSE;

+      }

+      break;

+    case XML_ROLE_NOTATION_SYSTEM_ID:

+      if (declNotationName && notationDeclHandler) {

+        const XML_Char *systemId

+          = poolStoreString(&tempPool, enc,

+                            s + enc->minBytesPerChar,

+                            next - enc->minBytesPerChar);

+        if (!systemId)

+          return XML_ERROR_NO_MEMORY;

+        *eventEndPP = s;

+        notationDeclHandler(handlerArg,

+                            declNotationName,

+                            curBase,

+                            systemId,

+                            declNotationPublicId);

+        handleDefault = XML_FALSE;

+      }

+      poolClear(&tempPool);

+      break;

+    case XML_ROLE_NOTATION_NO_SYSTEM_ID:

+      if (declNotationPublicId && notationDeclHandler) {

+        *eventEndPP = s;

+        notationDeclHandler(handlerArg,

+                            declNotationName,

+                            curBase,

+                            0,

+                            declNotationPublicId);

+        handleDefault = XML_FALSE;

+      }

+      poolClear(&tempPool);

+      break;

+    case XML_ROLE_ERROR:

+      switch (tok) {

+      case XML_TOK_PARAM_ENTITY_REF:

+        /* PE references in internal subset are

+           not allowed within declarations. */

+        return XML_ERROR_PARAM_ENTITY_REF;

+      case XML_TOK_XML_DECL:

+        return XML_ERROR_MISPLACED_XML_PI;

+      default:

+        return XML_ERROR_SYNTAX;

+      }

+#ifdef XML_DTD

+    case XML_ROLE_IGNORE_SECT:

+      {

+        enum XML_Error result;

+        if (defaultHandler)

+          reportDefault(parser, enc, s, next);

+        handleDefault = XML_FALSE;

+        result = doIgnoreSection(parser, enc, &next, end, nextPtr, haveMore);

+        if (result != XML_ERROR_NONE)

+          return result;

+        else if (!next) {

+          processor = ignoreSectionProcessor;

+          return result;

+        }

+      }

+      break;

+#endif /* XML_DTD */

+    case XML_ROLE_GROUP_OPEN:

+      if (prologState.level >= groupSize) {

+        if (groupSize) {

+          char *temp = (char *)REALLOC(groupConnector, groupSize *= 2);

+          if (temp == NULL)

+            return XML_ERROR_NO_MEMORY;

+          groupConnector = temp;

+          if (dtd->scaffIndex) {

+            int *temp = (int *)REALLOC(dtd->scaffIndex,

+                          groupSize * sizeof(int));

+            if (temp == NULL)

+              return XML_ERROR_NO_MEMORY;

+            dtd->scaffIndex = temp;

+          }

+        }

+        else {

+          groupConnector = (char *)MALLOC(groupSize = 32);

+          if (!groupConnector)

+            return XML_ERROR_NO_MEMORY;

+        }

+      }

+      groupConnector[prologState.level] = 0;

+      if (dtd->in_eldecl) {

+        int myindex = nextScaffoldPart(parser);

+        if (myindex < 0)

+          return XML_ERROR_NO_MEMORY;

+        dtd->scaffIndex[dtd->scaffLevel] = myindex;

+        dtd->scaffLevel++;

+        dtd->scaffold[myindex].type = XML_CTYPE_SEQ;

+        if (elementDeclHandler)

+          handleDefault = XML_FALSE;

+      }

+      break;

+    case XML_ROLE_GROUP_SEQUENCE:

+      if (groupConnector[prologState.level] == '|')

+        return XML_ERROR_SYNTAX;

+      groupConnector[prologState.level] = ',';

+      if (dtd->in_eldecl && elementDeclHandler)

+        handleDefault = XML_FALSE;

+      break;

+    case XML_ROLE_GROUP_CHOICE:

+      if (groupConnector[prologState.level] == ',')

+        return XML_ERROR_SYNTAX;

+      if (dtd->in_eldecl

+          && !groupConnector[prologState.level]

+          && (dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type

+              != XML_CTYPE_MIXED)

+          ) {

+        dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type

+            = XML_CTYPE_CHOICE;

+        if (elementDeclHandler)

+          handleDefault = XML_FALSE;

+      }

+      groupConnector[prologState.level] = '|';

+      break;

+    case XML_ROLE_PARAM_ENTITY_REF:

+#ifdef XML_DTD

+    case XML_ROLE_INNER_PARAM_ENTITY_REF:

+      dtd->hasParamEntityRefs = XML_TRUE;

+      if (!paramEntityParsing)

+        dtd->keepProcessing = dtd->standalone;

+      else {

+        const XML_Char *name;

+        ENTITY *entity;

+        name = poolStoreString(&dtd->pool, enc,

+                                s + enc->minBytesPerChar,

+                                next - enc->minBytesPerChar);

+        if (!name)

+          return XML_ERROR_NO_MEMORY;

+        entity = (ENTITY *)lookup(&dtd->paramEntities, name, 0);

+        poolDiscard(&dtd->pool);

+        /* first, determine if a check for an existing declaration is needed;

+           if yes, check that the entity exists, and that it is internal,

+           otherwise call the skipped entity handler

+        */

+        if (prologState.documentEntity &&

+            (dtd->standalone

+             ? !openInternalEntities

+             : !dtd->hasParamEntityRefs)) {

+          if (!entity)

+            return XML_ERROR_UNDEFINED_ENTITY;

+          else if (!entity->is_internal)

+            return XML_ERROR_ENTITY_DECLARED_IN_PE;

+        }

+        else if (!entity) {

+          dtd->keepProcessing = dtd->standalone;

+          /* cannot report skipped entities in declarations */

+          if ((role == XML_ROLE_PARAM_ENTITY_REF) && skippedEntityHandler) {

+            skippedEntityHandler(handlerArg, name, 1);

+            handleDefault = XML_FALSE;

+          }

+          break;

+        }

+        if (entity->open)

+          return XML_ERROR_RECURSIVE_ENTITY_REF;

+        if (entity->textPtr) {

+          enum XML_Error result;

+          XML_Bool betweenDecl =

+            (role == XML_ROLE_PARAM_ENTITY_REF ? XML_TRUE : XML_FALSE);

+          result = processInternalEntity(parser, entity, betweenDecl);

+          if (result != XML_ERROR_NONE)

+            return result;

+          handleDefault = XML_FALSE;

+          break;

+        }

+        if (externalEntityRefHandler) {

+          dtd->paramEntityRead = XML_FALSE;

+          entity->open = XML_TRUE;

+          if (!externalEntityRefHandler(externalEntityRefHandlerArg,

+                                        0,

+                                        entity->base,

+                                        entity->systemId,

+                                        entity->publicId)) {

+            entity->open = XML_FALSE;

+            return XML_ERROR_EXTERNAL_ENTITY_HANDLING;

+          }

+          entity->open = XML_FALSE;

+          handleDefault = XML_FALSE;

+          if (!dtd->paramEntityRead) {

+            dtd->keepProcessing = dtd->standalone;

+            break;

+          }

+        }

+        else {

+          dtd->keepProcessing = dtd->standalone;

+          break;

+        }

+      }

+#endif /* XML_DTD */

+      if (!dtd->standalone &&

+          notStandaloneHandler &&

+          !notStandaloneHandler(handlerArg))

+        return XML_ERROR_NOT_STANDALONE;

+      break;

+

+    /* Element declaration stuff */

+

+    case XML_ROLE_ELEMENT_NAME:

+      if (elementDeclHandler) {

+        declElementType = getElementType(parser, enc, s, next);

+        if (!declElementType)

+          return XML_ERROR_NO_MEMORY;

+        dtd->scaffLevel = 0;

+        dtd->scaffCount = 0;

+        dtd->in_eldecl = XML_TRUE;

+        handleDefault = XML_FALSE;

+      }

+      break;

+

+    case XML_ROLE_CONTENT_ANY:

+    case XML_ROLE_CONTENT_EMPTY:

+      if (dtd->in_eldecl) {

+        if (elementDeclHandler) {

+          XML_Content * content = (XML_Content *) MALLOC(sizeof(XML_Content));

+          if (!content)

+            return XML_ERROR_NO_MEMORY;

+          content->quant = XML_CQUANT_NONE;

+          content->name = NULL;

+          content->numchildren = 0;

+          content->children = NULL;

+          content->type = ((role == XML_ROLE_CONTENT_ANY) ?

+                           XML_CTYPE_ANY :

+                           XML_CTYPE_EMPTY);

+          *eventEndPP = s;

+          elementDeclHandler(handlerArg, declElementType->name, content);

+          handleDefault = XML_FALSE;

+        }

+        dtd->in_eldecl = XML_FALSE;

+      }

+      break;

+

+    case XML_ROLE_CONTENT_PCDATA:

+      if (dtd->in_eldecl) {

+        dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type

+            = XML_CTYPE_MIXED;

+        if (elementDeclHandler)

+          handleDefault = XML_FALSE;

+      }

+      break;

+

+    case XML_ROLE_CONTENT_ELEMENT:

+      quant = XML_CQUANT_NONE;

+      goto elementContent;

+    case XML_ROLE_CONTENT_ELEMENT_OPT:

+      quant = XML_CQUANT_OPT;

+      goto elementContent;

+    case XML_ROLE_CONTENT_ELEMENT_REP:

+      quant = XML_CQUANT_REP;

+      goto elementContent;

+    case XML_ROLE_CONTENT_ELEMENT_PLUS:

+      quant = XML_CQUANT_PLUS;

+    elementContent:

+      if (dtd->in_eldecl) {

+        ELEMENT_TYPE *el;

+        const XML_Char *name;

+        int nameLen;

+        const char *nxt = (quant == XML_CQUANT_NONE

+                           ? next

+                           : next - enc->minBytesPerChar);

+        int myindex = nextScaffoldPart(parser);

+        if (myindex < 0)

+          return XML_ERROR_NO_MEMORY;

+        dtd->scaffold[myindex].type = XML_CTYPE_NAME;

+        dtd->scaffold[myindex].quant = quant;

+        el = getElementType(parser, enc, s, nxt);

+        if (!el)

+          return XML_ERROR_NO_MEMORY;

+        name = el->name;

+        dtd->scaffold[myindex].name = name;

+        nameLen = 0;

+        for (; name[nameLen++]; );

+        dtd->contentStringLen +=  nameLen;

+        if (elementDeclHandler)

+          handleDefault = XML_FALSE;

+      }

+      break;

+

+    case XML_ROLE_GROUP_CLOSE:

+      quant = XML_CQUANT_NONE;

+      goto closeGroup;

+    case XML_ROLE_GROUP_CLOSE_OPT:

+      quant = XML_CQUANT_OPT;

+      goto closeGroup;

+    case XML_ROLE_GROUP_CLOSE_REP:

+      quant = XML_CQUANT_REP;

+      goto closeGroup;

+    case XML_ROLE_GROUP_CLOSE_PLUS:

+      quant = XML_CQUANT_PLUS;

+    closeGroup:

+      if (dtd->in_eldecl) {

+        if (elementDeclHandler)

+          handleDefault = XML_FALSE;

+        dtd->scaffLevel--;

+        dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel]].quant = quant;

+        if (dtd->scaffLevel == 0) {

+          if (!handleDefault) {

+            XML_Content *model = build_model(parser);

+            if (!model)

+              return XML_ERROR_NO_MEMORY;

+            *eventEndPP = s;

+            elementDeclHandler(handlerArg, declElementType->name, model);

+          }

+          dtd->in_eldecl = XML_FALSE;

+          dtd->contentStringLen = 0;

+        }

+      }

+      break;

+      /* End element declaration stuff */

+

+    case XML_ROLE_PI:

+      if (!reportProcessingInstruction(parser, enc, s, next))

+        return XML_ERROR_NO_MEMORY;

+      handleDefault = XML_FALSE;

+      break;

+    case XML_ROLE_COMMENT:

+      if (!reportComment(parser, enc, s, next))

+        return XML_ERROR_NO_MEMORY;

+      handleDefault = XML_FALSE;

+      break;

+    case XML_ROLE_NONE:

+      switch (tok) {

+      case XML_TOK_BOM:

+        handleDefault = XML_FALSE;

+        break;

+      }

+      break;

+    case XML_ROLE_DOCTYPE_NONE:

+      if (startDoctypeDeclHandler)

+        handleDefault = XML_FALSE;

+      break;

+    case XML_ROLE_ENTITY_NONE:

+      if (dtd->keepProcessing && entityDeclHandler)

+        handleDefault = XML_FALSE;

+      break;

+    case XML_ROLE_NOTATION_NONE:

+      if (notationDeclHandler)

+        handleDefault = XML_FALSE;

+      break;

+    case XML_ROLE_ATTLIST_NONE:

+      if (dtd->keepProcessing && attlistDeclHandler)

+        handleDefault = XML_FALSE;

+      break;

+    case XML_ROLE_ELEMENT_NONE:

+      if (elementDeclHandler)

+        handleDefault = XML_FALSE;

+      break;

+    } /* end of big switch */

+

+    if (handleDefault && defaultHandler)

+      reportDefault(parser, enc, s, next);

+

+    switch (ps_parsing) {

+    case XML_SUSPENDED:

+      *nextPtr = next;

+      return XML_ERROR_NONE;

+    case XML_FINISHED:

+      return XML_ERROR_ABORTED;

+    default:

+      s = next;

+      tok = XmlPrologTok(enc, s, end, &next);

+    }

+  }

+  /* not reached */

+}

+

+static enum XML_Error PTRCALL

+epilogProcessor(XML_Parser parser,

+                const char *s,

+                const char *end,

+                const char **nextPtr)

+{

+  processor = epilogProcessor;

+  eventPtr = s;

+  for (;;) {

+    const char *next = NULL;

+    int tok = XmlPrologTok(encoding, s, end, &next);

+    eventEndPtr = next;

+    switch (tok) {

+    /* report partial linebreak - it might be the last token */

+    case -XML_TOK_PROLOG_S:

+      if (defaultHandler) {

+        reportDefault(parser, encoding, s, next);

+        if (ps_parsing == XML_FINISHED)

+          return XML_ERROR_ABORTED;

+      }

+      *nextPtr = next;

+      return XML_ERROR_NONE;

+    case XML_TOK_NONE:

+      *nextPtr = s;

+      return XML_ERROR_NONE;

+    case XML_TOK_PROLOG_S:

+      if (defaultHandler)

+        reportDefault(parser, encoding, s, next);

+      break;

+    case XML_TOK_PI:

+      if (!reportProcessingInstruction(parser, encoding, s, next))

+        return XML_ERROR_NO_MEMORY;

+      break;

+    case XML_TOK_COMMENT:

+      if (!reportComment(parser, encoding, s, next))

+        return XML_ERROR_NO_MEMORY;

+      break;

+    case XML_TOK_INVALID:

+      eventPtr = next;

+      return XML_ERROR_INVALID_TOKEN;

+    case XML_TOK_PARTIAL:

+      if (!ps_finalBuffer) {

+        *nextPtr = s;

+        return XML_ERROR_NONE;

+      }

+      return XML_ERROR_UNCLOSED_TOKEN;

+    case XML_TOK_PARTIAL_CHAR:

+      if (!ps_finalBuffer) {

+        *nextPtr = s;

+        return XML_ERROR_NONE;

+      }

+      return XML_ERROR_PARTIAL_CHAR;

+    default:

+      return XML_ERROR_JUNK_AFTER_DOC_ELEMENT;

+    }

+    eventPtr = s = next;

+    switch (ps_parsing) {

+    case XML_SUSPENDED:

+      *nextPtr = next;

+      return XML_ERROR_NONE;

+    case XML_FINISHED:

+      return XML_ERROR_ABORTED;

+    default: ;

+    }

+  }

+}

+

+static enum XML_Error

+processInternalEntity(XML_Parser parser, ENTITY *entity,

+                      XML_Bool betweenDecl)

+{

+  const char *textStart, *textEnd;

+  const char *next;

+  enum XML_Error result;

+  OPEN_INTERNAL_ENTITY *openEntity;

+

+  if (freeInternalEntities) {

+    openEntity = freeInternalEntities;

+    freeInternalEntities = openEntity->next;

+  }

+  else {

+    openEntity = (OPEN_INTERNAL_ENTITY *)MALLOC(sizeof(OPEN_INTERNAL_ENTITY));

+    if (!openEntity)

+      return XML_ERROR_NO_MEMORY;

+  }

+  entity->open = XML_TRUE;

+  entity->processed = 0;

+  openEntity->next = openInternalEntities;

+  openInternalEntities = openEntity;

+  openEntity->entity = entity;

+  openEntity->startTagLevel = tagLevel;

+  openEntity->betweenDecl = betweenDecl;

+  openEntity->internalEventPtr = NULL;

+  openEntity->internalEventEndPtr = NULL;

+  textStart = (char *)entity->textPtr;

+  textEnd = (char *)(entity->textPtr + entity->textLen);

+

+#ifdef XML_DTD

+  if (entity->is_param) {

+    int tok = XmlPrologTok(internalEncoding, textStart, textEnd, &next);

+    result = doProlog(parser, internalEncoding, textStart, textEnd, tok,

+                      next, &next, XML_FALSE);

+  }

+  else

+#endif /* XML_DTD */

+    result = doContent(parser, tagLevel, internalEncoding, textStart,

+                       textEnd, &next, XML_FALSE);

+

+  if (result == XML_ERROR_NONE) {

+    if (textEnd != next && ps_parsing == XML_SUSPENDED) {

+      entity->processed = (int)(next - textStart);

+      processor = internalEntityProcessor;

+    }

+    else {

+      entity->open = XML_FALSE;

+      openInternalEntities = openEntity->next;

+      /* put openEntity back in list of free instances */

+      openEntity->next = freeInternalEntities;

+      freeInternalEntities = openEntity;

+    }

+  }

+  return result;

+}

+

+static enum XML_Error PTRCALL

+internalEntityProcessor(XML_Parser parser,

+                        const char *s,

+                        const char *end,

+                        const char **nextPtr)

+{

+  ENTITY *entity;

+  const char *textStart, *textEnd;

+  const char *next;

+  enum XML_Error result;

+  OPEN_INTERNAL_ENTITY *openEntity = openInternalEntities;

+  if (!openEntity)

+    return XML_ERROR_UNEXPECTED_STATE;

+

+  entity = openEntity->entity;

+  textStart = ((char *)entity->textPtr) + entity->processed;

+  textEnd = (char *)(entity->textPtr + entity->textLen);

+

+#ifdef XML_DTD

+  if (entity->is_param) {

+    int tok = XmlPrologTok(internalEncoding, textStart, textEnd, &next);

+    result = doProlog(parser, internalEncoding, textStart, textEnd, tok,

+                      next, &next, XML_FALSE);

+  }

+  else

+#endif /* XML_DTD */

+    result = doContent(parser, openEntity->startTagLevel, internalEncoding,

+                       textStart, textEnd, &next, XML_FALSE);

+

+  if (result != XML_ERROR_NONE)

+    return result;

+  else if (textEnd != next && ps_parsing == XML_SUSPENDED) {

+    entity->processed = (int)(next - (char *)entity->textPtr);

+    return result;

+  }

+  else {

+    entity->open = XML_FALSE;

+    openInternalEntities = openEntity->next;

+    /* put openEntity back in list of free instances */

+    openEntity->next = freeInternalEntities;

+    freeInternalEntities = openEntity;

+  }

+

+#ifdef XML_DTD

+  if (entity->is_param) {

+    int tok;

+    processor = prologProcessor;

+    tok = XmlPrologTok(encoding, s, end, &next);

+    return doProlog(parser, encoding, s, end, tok, next, nextPtr,

+                    (XML_Bool)!ps_finalBuffer);

+  }

+  else

+#endif /* XML_DTD */

+  {

+    processor = contentProcessor;

+    /* see externalEntityContentProcessor vs contentProcessor */

+    return doContent(parser, parentParser ? 1 : 0, encoding, s, end,

+                     nextPtr, (XML_Bool)!ps_finalBuffer);

+  }

+}

+

+static enum XML_Error PTRCALL

+errorProcessor(XML_Parser parser,

+               const char *s,

+               const char *end,

+               const char **nextPtr)

+{

+  return errorCode;

+}

+

+static enum XML_Error

+storeAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,

+                    const char *ptr, const char *end,

+                    STRING_POOL *pool)

+{

+  enum XML_Error result = appendAttributeValue(parser, enc, isCdata, ptr,

+                                               end, pool);

+  if (result)

+    return result;

+  if (!isCdata && poolLength(pool) && poolLastChar(pool) == 0x20)

+    poolChop(pool);

+  if (!poolAppendChar(pool, XML_T('\0')))

+    return XML_ERROR_NO_MEMORY;

+  return XML_ERROR_NONE;

+}

+

+static enum XML_Error

+appendAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,

+                     const char *ptr, const char *end,

+                     STRING_POOL *pool)

+{

+  DTD * const dtd = _dtd;  /* save one level of indirection */

+  for (;;) {

+    const char *next;

+    int tok = XmlAttributeValueTok(enc, ptr, end, &next);

+    switch (tok) {

+    case XML_TOK_NONE:

+      return XML_ERROR_NONE;

+    case XML_TOK_INVALID:

+      if (enc == encoding)

+        eventPtr = next;

+      return XML_ERROR_INVALID_TOKEN;

+    case XML_TOK_PARTIAL:

+      if (enc == encoding)

+        eventPtr = ptr;

+      return XML_ERROR_INVALID_TOKEN;

+    case XML_TOK_CHAR_REF:

+      {

+        XML_Char buf[XML_ENCODE_MAX];

+        int i;

+        int n = XmlCharRefNumber(enc, ptr);

+        if (n < 0) {

+          if (enc == encoding)

+            eventPtr = ptr;

+          return XML_ERROR_BAD_CHAR_REF;

+        }

+        if (!isCdata

+            && n == 0x20 /* space */

+            && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))

+          break;

+        n = XmlEncode(n, (ICHAR *)buf);

+        if (!n) {

+          if (enc == encoding)

+            eventPtr = ptr;

+          return XML_ERROR_BAD_CHAR_REF;

+        }

+        for (i = 0; i < n; i++) {

+          if (!poolAppendChar(pool, buf[i]))

+            return XML_ERROR_NO_MEMORY;

+        }

+      }

+      break;

+    case XML_TOK_DATA_CHARS:

+      if (!poolAppend(pool, enc, ptr, next))

+        return XML_ERROR_NO_MEMORY;

+      break;

+    case XML_TOK_TRAILING_CR:

+      next = ptr + enc->minBytesPerChar;

+      /* fall through */

+    case XML_TOK_ATTRIBUTE_VALUE_S:

+    case XML_TOK_DATA_NEWLINE:

+      if (!isCdata && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))

+        break;

+      if (!poolAppendChar(pool, 0x20))

+        return XML_ERROR_NO_MEMORY;

+      break;

+    case XML_TOK_ENTITY_REF:

+      {

+        const XML_Char *name;

+        ENTITY *entity;

+        char checkEntityDecl;

+        XML_Char ch = (XML_Char) XmlPredefinedEntityName(enc,

+                                              ptr + enc->minBytesPerChar,

+                                              next - enc->minBytesPerChar);

+        if (ch) {

+          if (!poolAppendChar(pool, ch))

+                return XML_ERROR_NO_MEMORY;

+          break;

+        }

+        name = poolStoreString(&temp2Pool, enc,

+                               ptr + enc->minBytesPerChar,

+                               next - enc->minBytesPerChar);

+        if (!name)

+          return XML_ERROR_NO_MEMORY;

+        entity = (ENTITY *)lookup(&dtd->generalEntities, name, 0);

+        poolDiscard(&temp2Pool);

+        /* First, determine if a check for an existing declaration is needed;

+           if yes, check that the entity exists, and that it is internal.

+        */

+        if (pool == &dtd->pool)  /* are we called from prolog? */

+          checkEntityDecl =

+#ifdef XML_DTD

+              prologState.documentEntity &&

+#endif /* XML_DTD */

+              (dtd->standalone

+               ? !openInternalEntities

+               : !dtd->hasParamEntityRefs);

+        else /* if (pool == &tempPool): we are called from content */

+          checkEntityDecl = !dtd->hasParamEntityRefs || dtd->standalone;

+        if (checkEntityDecl) {

+          if (!entity)

+            return XML_ERROR_UNDEFINED_ENTITY;

+          else if (!entity->is_internal)

+            return XML_ERROR_ENTITY_DECLARED_IN_PE;

+        }

+        else if (!entity) {

+          /* Cannot report skipped entity here - see comments on

+             skippedEntityHandler.

+          if (skippedEntityHandler)

+            skippedEntityHandler(handlerArg, name, 0);

+          */

+          /* Cannot call the default handler because this would be

+             out of sync with the call to the startElementHandler.

+          if ((pool == &tempPool) && defaultHandler)

+            reportDefault(parser, enc, ptr, next);

+          */

+          break;

+        }

+        if (entity->open) {

+          if (enc == encoding)

+            eventPtr = ptr;

+          return XML_ERROR_RECURSIVE_ENTITY_REF;

+        }

+        if (entity->notation) {

+          if (enc == encoding)

+            eventPtr = ptr;

+          return XML_ERROR_BINARY_ENTITY_REF;

+        }

+        if (!entity->textPtr) {

+          if (enc == encoding)

+            eventPtr = ptr;

+              return XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF;

+        }

+        else {

+          enum XML_Error result;

+          const XML_Char *textEnd = entity->textPtr + entity->textLen;

+          entity->open = XML_TRUE;

+          result = appendAttributeValue(parser, internalEncoding, isCdata,

+                                        (char *)entity->textPtr,

+                                        (char *)textEnd, pool);

+          entity->open = XML_FALSE;

+          if (result)

+            return result;

+        }

+      }

+      break;

+    default:

+      if (enc == encoding)

+        eventPtr = ptr;

+      return XML_ERROR_UNEXPECTED_STATE;

+    }

+    ptr = next;

+  }

+  /* not reached */

+}

+

+static enum XML_Error

+storeEntityValue(XML_Parser parser,

+                 const ENCODING *enc,

+                 const char *entityTextPtr,

+                 const char *entityTextEnd)

+{

+  DTD * const dtd = _dtd;  /* save one level of indirection */

+  STRING_POOL *pool = &(dtd->entityValuePool);

+  enum XML_Error result = XML_ERROR_NONE;

+#ifdef XML_DTD

+  int oldInEntityValue = prologState.inEntityValue;

+  prologState.inEntityValue = 1;

+#endif /* XML_DTD */

+  /* never return Null for the value argument in EntityDeclHandler,

+     since this would indicate an external entity; therefore we

+     have to make sure that entityValuePool.start is not null */

+  if (!pool->blocks) {

+    if (!poolGrow(pool))

+      return XML_ERROR_NO_MEMORY;

+  }

+

+  for (;;) {

+    const char *next;

+    int tok = XmlEntityValueTok(enc, entityTextPtr, entityTextEnd, &next);

+    switch (tok) {

+    case XML_TOK_PARAM_ENTITY_REF:

+#ifdef XML_DTD

+      if (isParamEntity || enc != encoding) {

+        const XML_Char *name;

+        ENTITY *entity;

+        name = poolStoreString(&tempPool, enc,

+                               entityTextPtr + enc->minBytesPerChar,

+                               next - enc->minBytesPerChar);

+        if (!name) {

+          result = XML_ERROR_NO_MEMORY;

+          goto endEntityValue;

+        }

+        entity = (ENTITY *)lookup(&dtd->paramEntities, name, 0);

+        poolDiscard(&tempPool);

+        if (!entity) {

+          /* not a well-formedness error - see XML 1.0: WFC Entity Declared */

+          /* cannot report skipped entity here - see comments on

+             skippedEntityHandler

+          if (skippedEntityHandler)

+            skippedEntityHandler(handlerArg, name, 0);

+          */

+          dtd->keepProcessing = dtd->standalone;

+          goto endEntityValue;

+        }

+        if (entity->open) {

+          if (enc == encoding)

+            eventPtr = entityTextPtr;

+          result = XML_ERROR_RECURSIVE_ENTITY_REF;

+          goto endEntityValue;

+        }

+        if (entity->systemId) {

+          if (externalEntityRefHandler) {

+            dtd->paramEntityRead = XML_FALSE;

+            entity->open = XML_TRUE;

+            if (!externalEntityRefHandler(externalEntityRefHandlerArg,

+                                          0,

+                                          entity->base,

+                                          entity->systemId,

+                                          entity->publicId)) {

+              entity->open = XML_FALSE;

+              result = XML_ERROR_EXTERNAL_ENTITY_HANDLING;

+              goto endEntityValue;

+            }

+            entity->open = XML_FALSE;

+            if (!dtd->paramEntityRead)

+              dtd->keepProcessing = dtd->standalone;

+          }

+          else

+            dtd->keepProcessing = dtd->standalone;

+        }

+        else {

+          entity->open = XML_TRUE;

+          result = storeEntityValue(parser,

+                                    internalEncoding,

+                                    (char *)entity->textPtr,

+                                    (char *)(entity->textPtr

+                                             + entity->textLen));

+          entity->open = XML_FALSE;

+          if (result)

+            goto endEntityValue;

+        }

+        break;

+      }

+#endif /* XML_DTD */

+      /* In the internal subset, PE references are not legal

+         within markup declarations, e.g entity values in this case. */

+      eventPtr = entityTextPtr;

+      result = XML_ERROR_PARAM_ENTITY_REF;

+      goto endEntityValue;

+    case XML_TOK_NONE:

+      result = XML_ERROR_NONE;

+      goto endEntityValue;

+    case XML_TOK_ENTITY_REF:

+    case XML_TOK_DATA_CHARS:

+      if (!poolAppend(pool, enc, entityTextPtr, next)) {

+        result = XML_ERROR_NO_MEMORY;

+        goto endEntityValue;

+      }

+      break;

+    case XML_TOK_TRAILING_CR:

+      next = entityTextPtr + enc->minBytesPerChar;

+      /* fall through */

+    case XML_TOK_DATA_NEWLINE:

+      if (pool->end == pool->ptr && !poolGrow(pool)) {

+              result = XML_ERROR_NO_MEMORY;

+        goto endEntityValue;

+      }

+      *(pool->ptr)++ = 0xA;

+      break;

+    case XML_TOK_CHAR_REF:

+      {

+        XML_Char buf[XML_ENCODE_MAX];

+        int i;

+        int n = XmlCharRefNumber(enc, entityTextPtr);

+        if (n < 0) {

+          if (enc == encoding)

+            eventPtr = entityTextPtr;

+          result = XML_ERROR_BAD_CHAR_REF;

+          goto endEntityValue;

+        }

+        n = XmlEncode(n, (ICHAR *)buf);

+        if (!n) {

+          if (enc == encoding)

+            eventPtr = entityTextPtr;

+          result = XML_ERROR_BAD_CHAR_REF;

+          goto endEntityValue;

+        }

+        for (i = 0; i < n; i++) {

+          if (pool->end == pool->ptr && !poolGrow(pool)) {

+            result = XML_ERROR_NO_MEMORY;

+            goto endEntityValue;

+          }

+          *(pool->ptr)++ = buf[i];

+        }

+      }

+      break;

+    case XML_TOK_PARTIAL:

+      if (enc == encoding)

+        eventPtr = entityTextPtr;

+      result = XML_ERROR_INVALID_TOKEN;

+      goto endEntityValue;

+    case XML_TOK_INVALID:

+      if (enc == encoding)

+        eventPtr = next;

+      result = XML_ERROR_INVALID_TOKEN;

+      goto endEntityValue;

+    default:

+      if (enc == encoding)

+        eventPtr = entityTextPtr;

+      result = XML_ERROR_UNEXPECTED_STATE;

+      goto endEntityValue;

+    }

+    entityTextPtr = next;

+  }

+endEntityValue:

+#ifdef XML_DTD

+  prologState.inEntityValue = oldInEntityValue;

+#endif /* XML_DTD */

+  return result;

+}

+

+static void FASTCALL

+normalizeLines(XML_Char *s)

+{

+  XML_Char *p;

+  for (;; s++) {

+    if (*s == XML_T('\0'))

+      return;

+    if (*s == 0xD)

+      break;

+  }

+  p = s;

+  do {

+    if (*s == 0xD) {

+      *p++ = 0xA;

+      if (*++s == 0xA)

+        s++;

+    }

+    else

+      *p++ = *s++;

+  } while (*s);

+  *p = XML_T('\0');

+}

+

+static int

+reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,

+                            const char *start, const char *end)

+{

+  const XML_Char *target;

+  XML_Char *data;

+  const char *tem;

+  if (!processingInstructionHandler) {

+    if (defaultHandler)

+      reportDefault(parser, enc, start, end);

+    return 1;

+  }

+  start += enc->minBytesPerChar * 2;

+  tem = start + XmlNameLength(enc, start);

+  target = poolStoreString(&tempPool, enc, start, tem);

+  if (!target)

+    return 0;

+  poolFinish(&tempPool);

+  data = poolStoreString(&tempPool, enc,

+                        XmlSkipS(enc, tem),

+                        end - enc->minBytesPerChar*2);

+  if (!data)

+    return 0;

+  normalizeLines(data);

+  processingInstructionHandler(handlerArg, target, data);

+  poolClear(&tempPool);

+  return 1;

+}

+

+static int

+reportComment(XML_Parser parser, const ENCODING *enc,

+              const char *start, const char *end)

+{

+  XML_Char *data;

+  if (!commentHandler) {

+    if (defaultHandler)

+      reportDefault(parser, enc, start, end);

+    return 1;

+  }

+  data = poolStoreString(&tempPool,

+                         enc,

+                         start + enc->minBytesPerChar * 4,

+                         end - enc->minBytesPerChar * 3);

+  if (!data)

+    return 0;

+  normalizeLines(data);

+  commentHandler(handlerArg, data);

+  poolClear(&tempPool);

+  return 1;

+}

+

+static void

+reportDefault(XML_Parser parser, const ENCODING *enc,

+              const char *s, const char *end)

+{

+  if (MUST_CONVERT(enc, s)) {

+    const char **eventPP;

+    const char **eventEndPP;

+    if (enc == encoding) {

+      eventPP = &eventPtr;

+      eventEndPP = &eventEndPtr;

+    }

+    else {

+      eventPP = &(openInternalEntities->internalEventPtr);

+      eventEndPP = &(openInternalEntities->internalEventEndPtr);

+    }

+    do {

+      ICHAR *dataPtr = (ICHAR *)dataBuf;

+      XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);

+      *eventEndPP = s;

+      defaultHandler(handlerArg, dataBuf, (int)(dataPtr - (ICHAR *)dataBuf));

+      *eventPP = s;

+    } while (s != end);

+  }

+  else

+    defaultHandler(handlerArg, (XML_Char *)s, (int)((XML_Char *)end - (XML_Char *)s));

+}

+

+

+static int

+defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, XML_Bool isCdata,

+                XML_Bool isId, const XML_Char *value, XML_Parser parser)

+{

+  DEFAULT_ATTRIBUTE *att;

+  if (value || isId) {

+    /* The handling of default attributes gets messed up if we have

+       a default which duplicates a non-default. */

+    int i;

+    for (i = 0; i < type->nDefaultAtts; i++)

+      if (attId == type->defaultAtts[i].id)

+        return 1;

+    if (isId && !type->idAtt && !attId->xmlns)

+      type->idAtt = attId;

+  }

+  if (type->nDefaultAtts == type->allocDefaultAtts) {

+    if (type->allocDefaultAtts == 0) {

+      type->allocDefaultAtts = 8;

+      type->defaultAtts = (DEFAULT_ATTRIBUTE *)MALLOC(type->allocDefaultAtts

+                            * sizeof(DEFAULT_ATTRIBUTE));

+      if (!type->defaultAtts)

+        return 0;

+    }

+    else {

+      DEFAULT_ATTRIBUTE *temp;

+      int count = type->allocDefaultAtts * 2;

+      temp = (DEFAULT_ATTRIBUTE *)

+        REALLOC(type->defaultAtts, (count * sizeof(DEFAULT_ATTRIBUTE)));

+      if (temp == NULL)

+        return 0;

+      type->allocDefaultAtts = count;

+      type->defaultAtts = temp;

+    }

+  }

+  att = type->defaultAtts + type->nDefaultAtts;

+  att->id = attId;

+  att->value = value;

+  att->isCdata = isCdata;

+  if (!isCdata)

+    attId->maybeTokenized = XML_TRUE;

+  type->nDefaultAtts += 1;

+  return 1;

+}

+

+static int

+setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType)

+{

+  DTD * const dtd = _dtd;  /* save one level of indirection */

+  const XML_Char *name;

+  for (name = elementType->name; *name; name++) {

+    if (*name == XML_T(':')) {

+      PREFIX *prefix;

+      const XML_Char *s;

+      for (s = elementType->name; s != name; s++) {

+        if (!poolAppendChar(&dtd->pool, *s))

+          return 0;

+      }

+      if (!poolAppendChar(&dtd->pool, XML_T('\0')))

+        return 0;

+      prefix = (PREFIX *)lookup(&dtd->prefixes, poolStart(&dtd->pool),

+                                sizeof(PREFIX));

+      if (!prefix)

+        return 0;

+      if (prefix->name == poolStart(&dtd->pool))

+        poolFinish(&dtd->pool);

+      else

+        poolDiscard(&dtd->pool);

+      elementType->prefix = prefix;

+

+    }

+  }

+  return 1;

+}

+

+static ATTRIBUTE_ID *

+getAttributeId(XML_Parser parser, const ENCODING *enc,

+               const char *start, const char *end)

+{

+  DTD * const dtd = _dtd;  /* save one level of indirection */

+  ATTRIBUTE_ID *id;

+  const XML_Char *name;

+  if (!poolAppendChar(&dtd->pool, XML_T('\0')))

+    return NULL;

+  name = poolStoreString(&dtd->pool, enc, start, end);

+  if (!name)

+    return NULL;

+  /* skip quotation mark - its storage will be re-used (like in name[-1]) */

+  ++name;

+  id = (ATTRIBUTE_ID *)lookup(&dtd->attributeIds, name, sizeof(ATTRIBUTE_ID));

+  if (!id)

+    return NULL;

+  if (id->name != name)

+    poolDiscard(&dtd->pool);

+  else {

+    poolFinish(&dtd->pool);

+    if (!ns)

+      ;

+    else if (name[0] == XML_T('x')

+        && name[1] == XML_T('m')

+        && name[2] == XML_T('l')

+        && name[3] == XML_T('n')

+        && name[4] == XML_T('s')

+        && (name[5] == XML_T('\0') || name[5] == XML_T(':'))) {

+      if (name[5] == XML_T('\0'))

+        id->prefix = &dtd->defaultPrefix;

+      else

+        id->prefix = (PREFIX *)lookup(&dtd->prefixes, name + 6, sizeof(PREFIX));

+      id->xmlns = XML_TRUE;

+    }

+    else {

+      int i;

+      for (i = 0; name[i]; i++) {

+        /* attributes without prefix are *not* in the default namespace */

+        if (name[i] == XML_T(':')) {

+          int j;

+          for (j = 0; j < i; j++) {

+            if (!poolAppendChar(&dtd->pool, name[j]))

+              return NULL;

+          }

+          if (!poolAppendChar(&dtd->pool, XML_T('\0')))

+            return NULL;

+          id->prefix = (PREFIX *)lookup(&dtd->prefixes, poolStart(&dtd->pool),

+                                        sizeof(PREFIX));

+          if (!id->prefix)

+            return NULL;

+          if (id->prefix->name == poolStart(&dtd->pool))

+            poolFinish(&dtd->pool);

+          else

+            poolDiscard(&dtd->pool);

+          break;

+        }

+      }

+    }

+  }

+  return id;

+}

+

+#define CONTEXT_SEP XML_T('\f')

+

+static const XML_Char *

+getContext(XML_Parser parser)

+{

+  DTD * const dtd = _dtd;  /* save one level of indirection */

+  HASH_TABLE_ITER iter;

+  XML_Bool needSep = XML_FALSE;

+

+  if (dtd->defaultPrefix.binding) {

+    int i;

+    int len;

+    if (!poolAppendChar(&tempPool, XML_T('=')))

+      return NULL;

+    len = dtd->defaultPrefix.binding->uriLen;

+    if (namespaceSeparator)

+      len--;

+    for (i = 0; i < len; i++)

+      if (!poolAppendChar(&tempPool, dtd->defaultPrefix.binding->uri[i]))

+        return NULL;

+    needSep = XML_TRUE;

+  }

+

+  hashTableIterInit(&iter, &(dtd->prefixes));

+  for (;;) {

+    int i;

+    int len;

+    const XML_Char *s;

+    PREFIX *prefix = (PREFIX *)hashTableIterNext(&iter);

+    if (!prefix)

+      break;

+    if (!prefix->binding)

+      continue;

+    if (needSep && !poolAppendChar(&tempPool, CONTEXT_SEP))

+      return NULL;

+    for (s = prefix->name; *s; s++)

+      if (!poolAppendChar(&tempPool, *s))

+        return NULL;

+    if (!poolAppendChar(&tempPool, XML_T('=')))

+      return NULL;

+    len = prefix->binding->uriLen;

+    if (namespaceSeparator)

+      len--;

+    for (i = 0; i < len; i++)

+      if (!poolAppendChar(&tempPool, prefix->binding->uri[i]))

+        return NULL;

+    needSep = XML_TRUE;

+  }

+

+

+  hashTableIterInit(&iter, &(dtd->generalEntities));

+  for (;;) {

+    const XML_Char *s;

+    ENTITY *e = (ENTITY *)hashTableIterNext(&iter);

+    if (!e)

+      break;

+    if (!e->open)

+      continue;

+    if (needSep && !poolAppendChar(&tempPool, CONTEXT_SEP))

+      return NULL;

+    for (s = e->name; *s; s++)

+      if (!poolAppendChar(&tempPool, *s))

+        return 0;

+    needSep = XML_TRUE;

+  }

+

+  if (!poolAppendChar(&tempPool, XML_T('\0')))

+    return NULL;

+  return tempPool.start;

+}

+

+static XML_Bool

+setContext(XML_Parser parser, const XML_Char *context)

+{

+  DTD * const dtd = _dtd;  /* save one level of indirection */

+  const XML_Char *s = context;

+

+  while (*context != XML_T('\0')) {

+    if (*s == CONTEXT_SEP || *s == XML_T('\0')) {

+      ENTITY *e;

+      if (!poolAppendChar(&tempPool, XML_T('\0')))

+        return XML_FALSE;

+      e = (ENTITY *)lookup(&dtd->generalEntities, poolStart(&tempPool), 0);

+      if (e)

+        e->open = XML_TRUE;

+      if (*s != XML_T('\0'))

+        s++;

+      context = s;

+      poolDiscard(&tempPool);

+    }

+    else if (*s == XML_T('=')) {

+      PREFIX *prefix;

+      if (poolLength(&tempPool) == 0)

+        prefix = &dtd->defaultPrefix;

+      else {

+        if (!poolAppendChar(&tempPool, XML_T('\0')))

+          return XML_FALSE;

+        prefix = (PREFIX *)lookup(&dtd->prefixes, poolStart(&tempPool),

+                                  sizeof(PREFIX));

+        if (!prefix)

+          return XML_FALSE;

+        if (prefix->name == poolStart(&tempPool)) {

+          prefix->name = poolCopyString(&dtd->pool, prefix->name);

+          if (!prefix->name)

+            return XML_FALSE;

+        }

+        poolDiscard(&tempPool);

+      }

+      for (context = s + 1;

+           *context != CONTEXT_SEP && *context != XML_T('\0');

+           context++)

+        if (!poolAppendChar(&tempPool, *context))

+          return XML_FALSE;

+      if (!poolAppendChar(&tempPool, XML_T('\0')))

+        return XML_FALSE;

+      if (addBinding(parser, prefix, NULL, poolStart(&tempPool),

+                     &inheritedBindings) != XML_ERROR_NONE)

+        return XML_FALSE;

+      poolDiscard(&tempPool);

+      if (*context != XML_T('\0'))

+        ++context;

+      s = context;

+    }

+    else {

+      if (!poolAppendChar(&tempPool, *s))

+        return XML_FALSE;

+      s++;

+    }

+  }

+  return XML_TRUE;

+}

+

+static void FASTCALL

+normalizePublicId(XML_Char *publicId)

+{

+  XML_Char *p = publicId;

+  XML_Char *s;

+  for (s = publicId; *s; s++) {

+    switch (*s) {

+    case 0x20:

+    case 0xD:

+    case 0xA:

+      if (p != publicId && p[-1] != 0x20)

+        *p++ = 0x20;

+      break;

+    default:

+      *p++ = *s;

+    }

+  }

+  if (p != publicId && p[-1] == 0x20)

+    --p;

+  *p = XML_T('\0');

+}

+

+static DTD *

+dtdCreate(const XML_Memory_Handling_Suite *ms)

+{

+  DTD *p = (DTD *)ms->malloc_fcn(sizeof(DTD));

+  if (p == NULL)

+    return p;

+  poolInit(&(p->pool), ms);

+  poolInit(&(p->entityValuePool), ms);

+  hashTableInit(&(p->generalEntities), ms);

+  hashTableInit(&(p->elementTypes), ms);

+  hashTableInit(&(p->attributeIds), ms);

+  hashTableInit(&(p->prefixes), ms);

+#ifdef XML_DTD

+  p->paramEntityRead = XML_FALSE;

+  hashTableInit(&(p->paramEntities), ms);

+#endif /* XML_DTD */

+  p->defaultPrefix.name = NULL;

+  p->defaultPrefix.binding = NULL;

+

+  p->in_eldecl = XML_FALSE;

+  p->scaffIndex = NULL;

+  p->scaffold = NULL;

+  p->scaffLevel = 0;

+  p->scaffSize = 0;

+  p->scaffCount = 0;

+  p->contentStringLen = 0;

+

+  p->keepProcessing = XML_TRUE;

+  p->hasParamEntityRefs = XML_FALSE;

+  p->standalone = XML_FALSE;

+  return p;

+}

+

+static void

+dtdReset(DTD *p, const XML_Memory_Handling_Suite *ms)

+{

+  HASH_TABLE_ITER iter;

+  hashTableIterInit(&iter, &(p->elementTypes));

+  for (;;) {

+    ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);

+    if (!e)

+      break;

+    if (e->allocDefaultAtts != 0)

+      ms->free_fcn(e->defaultAtts);

+  }

+  hashTableClear(&(p->generalEntities));

+#ifdef XML_DTD

+  p->paramEntityRead = XML_FALSE;

+  hashTableClear(&(p->paramEntities));

+#endif /* XML_DTD */

+  hashTableClear(&(p->elementTypes));

+  hashTableClear(&(p->attributeIds));

+  hashTableClear(&(p->prefixes));

+  poolClear(&(p->pool));

+  poolClear(&(p->entityValuePool));

+  p->defaultPrefix.name = NULL;

+  p->defaultPrefix.binding = NULL;

+

+  p->in_eldecl = XML_FALSE;

+

+  ms->free_fcn(p->scaffIndex);

+  p->scaffIndex = NULL;

+  ms->free_fcn(p->scaffold);

+  p->scaffold = NULL;

+

+  p->scaffLevel = 0;

+  p->scaffSize = 0;

+  p->scaffCount = 0;

+  p->contentStringLen = 0;

+

+  p->keepProcessing = XML_TRUE;

+  p->hasParamEntityRefs = XML_FALSE;

+  p->standalone = XML_FALSE;

+}

+

+static void

+dtdDestroy(DTD *p, XML_Bool isDocEntity, const XML_Memory_Handling_Suite *ms)

+{

+  HASH_TABLE_ITER iter;

+  hashTableIterInit(&iter, &(p->elementTypes));

+  for (;;) {

+    ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);

+    if (!e)

+      break;

+    if (e->allocDefaultAtts != 0)

+      ms->free_fcn(e->defaultAtts);

+  }

+  hashTableDestroy(&(p->generalEntities));

+#ifdef XML_DTD

+  hashTableDestroy(&(p->paramEntities));

+#endif /* XML_DTD */

+  hashTableDestroy(&(p->elementTypes));

+  hashTableDestroy(&(p->attributeIds));

+  hashTableDestroy(&(p->prefixes));

+  poolDestroy(&(p->pool));

+  poolDestroy(&(p->entityValuePool));

+  if (isDocEntity) {

+    ms->free_fcn(p->scaffIndex);

+    ms->free_fcn(p->scaffold);

+  }

+  ms->free_fcn(p);

+}

+

+/* Do a deep copy of the DTD. Return 0 for out of memory, non-zero otherwise.

+   The new DTD has already been initialized.

+*/

+static int

+dtdCopy(DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms)

+{

+  HASH_TABLE_ITER iter;

+

+  /* Copy the prefix table. */

+

+  hashTableIterInit(&iter, &(oldDtd->prefixes));

+  for (;;) {

+    const XML_Char *name;

+    const PREFIX *oldP = (PREFIX *)hashTableIterNext(&iter);

+    if (!oldP)

+      break;

+    name = poolCopyString(&(newDtd->pool), oldP->name);

+    if (!name)

+      return 0;

+    if (!lookup(&(newDtd->prefixes), name, sizeof(PREFIX)))

+      return 0;

+  }

+

+  hashTableIterInit(&iter, &(oldDtd->attributeIds));

+

+  /* Copy the attribute id table. */

+

+  for (;;) {

+    ATTRIBUTE_ID *newA;

+    const XML_Char *name;

+    const ATTRIBUTE_ID *oldA = (ATTRIBUTE_ID *)hashTableIterNext(&iter);

+

+    if (!oldA)

+      break;

+    /* Remember to allocate the scratch byte before the name. */

+    if (!poolAppendChar(&(newDtd->pool), XML_T('\0')))

+      return 0;

+    name = poolCopyString(&(newDtd->pool), oldA->name);

+    if (!name)

+      return 0;

+    ++name;

+    newA = (ATTRIBUTE_ID *)lookup(&(newDtd->attributeIds), name,

+                                  sizeof(ATTRIBUTE_ID));

+    if (!newA)

+      return 0;

+    newA->maybeTokenized = oldA->maybeTokenized;

+    if (oldA->prefix) {

+      newA->xmlns = oldA->xmlns;

+      if (oldA->prefix == &oldDtd->defaultPrefix)

+        newA->prefix = &newDtd->defaultPrefix;

+      else

+        newA->prefix = (PREFIX *)lookup(&(newDtd->prefixes),

+                                        oldA->prefix->name, 0);

+    }

+  }

+

+  /* Copy the element type table. */

+

+  hashTableIterInit(&iter, &(oldDtd->elementTypes));

+

+  for (;;) {

+    int i;

+    ELEMENT_TYPE *newE;

+    const XML_Char *name;

+    const ELEMENT_TYPE *oldE = (ELEMENT_TYPE *)hashTableIterNext(&iter);

+    if (!oldE)

+      break;

+    name = poolCopyString(&(newDtd->pool), oldE->name);

+    if (!name)

+      return 0;

+    newE = (ELEMENT_TYPE *)lookup(&(newDtd->elementTypes), name,

+                                  sizeof(ELEMENT_TYPE));

+    if (!newE)

+      return 0;

+    if (oldE->nDefaultAtts) {

+      newE->defaultAtts = (DEFAULT_ATTRIBUTE *)

+          ms->malloc_fcn(oldE->nDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));

+      if (!newE->defaultAtts) {

+        ms->free_fcn(newE);

+        return 0;

+      }

+    }

+    if (oldE->idAtt)

+      newE->idAtt = (ATTRIBUTE_ID *)

+          lookup(&(newDtd->attributeIds), oldE->idAtt->name, 0);

+    newE->allocDefaultAtts = newE->nDefaultAtts = oldE->nDefaultAtts;

+    if (oldE->prefix)

+      newE->prefix = (PREFIX *)lookup(&(newDtd->prefixes),

+                                      oldE->prefix->name, 0);

+    for (i = 0; i < newE->nDefaultAtts; i++) {

+      newE->defaultAtts[i].id = (ATTRIBUTE_ID *)

+          lookup(&(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);

+      newE->defaultAtts[i].isCdata = oldE->defaultAtts[i].isCdata;

+      if (oldE->defaultAtts[i].value) {

+        newE->defaultAtts[i].value

+            = poolCopyString(&(newDtd->pool), oldE->defaultAtts[i].value);

+        if (!newE->defaultAtts[i].value)

+          return 0;

+      }

+      else

+        newE->defaultAtts[i].value = NULL;

+    }

+  }

+

+  /* Copy the entity tables. */

+  if (!copyEntityTable(&(newDtd->generalEntities),

+                       &(newDtd->pool),

+                       &(oldDtd->generalEntities)))

+      return 0;

+

+#ifdef XML_DTD

+  if (!copyEntityTable(&(newDtd->paramEntities),

+                       &(newDtd->pool),

+                       &(oldDtd->paramEntities)))

+      return 0;

+  newDtd->paramEntityRead = oldDtd->paramEntityRead;

+#endif /* XML_DTD */

+

+  newDtd->keepProcessing = oldDtd->keepProcessing;

+  newDtd->hasParamEntityRefs = oldDtd->hasParamEntityRefs;

+  newDtd->standalone = oldDtd->standalone;

+

+  /* Don't want deep copying for scaffolding */

+  newDtd->in_eldecl = oldDtd->in_eldecl;

+  newDtd->scaffold = oldDtd->scaffold;

+  newDtd->contentStringLen = oldDtd->contentStringLen;

+  newDtd->scaffSize = oldDtd->scaffSize;

+  newDtd->scaffLevel = oldDtd->scaffLevel;

+  newDtd->scaffIndex = oldDtd->scaffIndex;

+

+  return 1;

+}  /* End dtdCopy */

+

+static int

+copyEntityTable(HASH_TABLE *newTable,

+                STRING_POOL *newPool,

+                const HASH_TABLE *oldTable)

+{

+  HASH_TABLE_ITER iter;

+  const XML_Char *cachedOldBase = NULL;

+  const XML_Char *cachedNewBase = NULL;

+

+  hashTableIterInit(&iter, oldTable);

+

+  for (;;) {

+    ENTITY *newE;

+    const XML_Char *name;

+    const ENTITY *oldE = (ENTITY *)hashTableIterNext(&iter);

+    if (!oldE)

+      break;

+    name = poolCopyString(newPool, oldE->name);

+    if (!name)

+      return 0;

+    newE = (ENTITY *)lookup(newTable, name, sizeof(ENTITY));

+    if (!newE)

+      return 0;

+    if (oldE->systemId) {

+      const XML_Char *tem = poolCopyString(newPool, oldE->systemId);

+      if (!tem)

+        return 0;

+      newE->systemId = tem;

+      if (oldE->base) {

+        if (oldE->base == cachedOldBase)

+          newE->base = cachedNewBase;

+        else {

+          cachedOldBase = oldE->base;

+          tem = poolCopyString(newPool, cachedOldBase);

+          if (!tem)

+            return 0;

+          cachedNewBase = newE->base = tem;

+        }

+      }

+      if (oldE->publicId) {

+        tem = poolCopyString(newPool, oldE->publicId);

+        if (!tem)

+          return 0;

+        newE->publicId = tem;

+      }

+    }

+    else {

+      const XML_Char *tem = poolCopyStringN(newPool, oldE->textPtr,

+                                            oldE->textLen);

+      if (!tem)

+        return 0;

+      newE->textPtr = tem;

+      newE->textLen = oldE->textLen;

+    }

+    if (oldE->notation) {

+      const XML_Char *tem = poolCopyString(newPool, oldE->notation);

+      if (!tem)

+        return 0;

+      newE->notation = tem;

+    }

+    newE->is_param = oldE->is_param;

+    newE->is_internal = oldE->is_internal;

+  }

+  return 1;

+}

+

+#define INIT_POWER 6

+

+static XML_Bool FASTCALL

+keyeq(KEY s1, KEY s2)

+{

+  for (; *s1 == *s2; s1++, s2++)

+    if (*s1 == 0)

+      return XML_TRUE;

+  return XML_FALSE;

+}

+

+static unsigned long FASTCALL

+hash(KEY s)

+{

+  unsigned long h = 0;

+  while (*s)

+    h = CHAR_HASH(h, *s++);

+  return h;

+}

+

+static NAMED *

+lookup(HASH_TABLE *table, KEY name, size_t createSize)

+{

+  size_t i;

+  if (table->size == 0) {

+    size_t tsize;

+    if (!createSize)

+      return NULL;

+    table->power = INIT_POWER;

+    /* table->size is a power of 2 */

+    table->size = (size_t)1 << INIT_POWER;

+    tsize = table->size * sizeof(NAMED *);

+    table->v = (NAMED **)table->mem->malloc_fcn(tsize);

+    if (!table->v) {

+      table->size = 0;

+      return NULL;

+    }

+    memset(table->v, 0, tsize);

+    i = hash(name) & ((unsigned long)table->size - 1);

+  }

+  else {

+    unsigned long h = hash(name);

+    unsigned long mask = (unsigned long)table->size - 1;

+    unsigned char step = 0;

+    i = h & mask;

+    while (table->v[i]) {

+      if (keyeq(name, table->v[i]->name))

+        return table->v[i];

+      if (!step)

+        step = PROBE_STEP(h, mask, table->power);

+      i < step ? (i += table->size - step) : (i -= step);

+    }

+    if (!createSize)

+      return NULL;

+

+    /* check for overflow (table is half full) */

+    if (table->used >> (table->power - 1)) {

+      unsigned char newPower = table->power + 1;

+      size_t newSize = (size_t)1 << newPower;

+      unsigned long newMask = (unsigned long)newSize - 1;

+      size_t tsize = newSize * sizeof(NAMED *);

+      NAMED **newV = (NAMED **)table->mem->malloc_fcn(tsize);

+      if (!newV)

+        return NULL;

+      memset(newV, 0, tsize);

+      for (i = 0; i < table->size; i++)

+        if (table->v[i]) {

+          unsigned long newHash = hash(table->v[i]->name);

+          size_t j = newHash & newMask;

+          step = 0;

+          while (newV[j]) {

+            if (!step)

+              step = PROBE_STEP(newHash, newMask, newPower);

+            j < step ? (j += newSize - step) : (j -= step);

+          }

+          newV[j] = table->v[i];

+        }

+      table->mem->free_fcn(table->v);

+      table->v = newV;

+      table->power = newPower;

+      table->size = newSize;

+      i = h & newMask;

+      step = 0;

+      while (table->v[i]) {

+        if (!step)

+          step = PROBE_STEP(h, newMask, newPower);

+        i < step ? (i += newSize - step) : (i -= step);

+      }

+    }

+  }

+  table->v[i] = (NAMED *)table->mem->malloc_fcn(createSize);

+  if (!table->v[i])

+    return NULL;

+  memset(table->v[i], 0, createSize);

+  table->v[i]->name = name;

+  (table->used)++;

+  return table->v[i];

+}

+

+static void FASTCALL

+hashTableClear(HASH_TABLE *table)

+{

+  size_t i;

+  for (i = 0; i < table->size; i++) {

+    table->mem->free_fcn(table->v[i]);

+    table->v[i] = NULL;

+  }

+  table->used = 0;

+}

+

+static void FASTCALL

+hashTableDestroy(HASH_TABLE *table)

+{

+  size_t i;

+  for (i = 0; i < table->size; i++)

+    table->mem->free_fcn(table->v[i]);

+  table->mem->free_fcn(table->v);

+}

+

+static void FASTCALL

+hashTableInit(HASH_TABLE *p, const XML_Memory_Handling_Suite *ms)

+{

+  p->power = 0;

+  p->size = 0;

+  p->used = 0;

+  p->v = NULL;

+  p->mem = ms;

+}

+

+static void FASTCALL

+hashTableIterInit(HASH_TABLE_ITER *iter, const HASH_TABLE *table)

+{

+  iter->p = table->v;

+  iter->end = iter->p + table->size;

+}

+

+static NAMED * FASTCALL

+hashTableIterNext(HASH_TABLE_ITER *iter)

+{

+  while (iter->p != iter->end) {

+    NAMED *tem = *(iter->p)++;

+    if (tem)

+      return tem;

+  }

+  return NULL;

+}

+

+static void FASTCALL

+poolInit(STRING_POOL *pool, const XML_Memory_Handling_Suite *ms)

+{

+  pool->blocks = NULL;

+  pool->freeBlocks = NULL;

+  pool->start = NULL;

+  pool->ptr = NULL;

+  pool->end = NULL;

+  pool->mem = ms;

+}

+

+static void FASTCALL

+poolClear(STRING_POOL *pool)

+{

+  if (!pool->freeBlocks)

+    pool->freeBlocks = pool->blocks;

+  else {

+    BLOCK *p = pool->blocks;

+    while (p) {

+      BLOCK *tem = p->next;

+      p->next = pool->freeBlocks;

+      pool->freeBlocks = p;

+      p = tem;

+    }

+  }

+  pool->blocks = NULL;

+  pool->start = NULL;

+  pool->ptr = NULL;

+  pool->end = NULL;

+}

+

+static void FASTCALL

+poolDestroy(STRING_POOL *pool)

+{

+  BLOCK *p = pool->blocks;

+  while (p) {

+    BLOCK *tem = p->next;

+    pool->mem->free_fcn(p);

+    p = tem;

+  }

+  p = pool->freeBlocks;

+  while (p) {

+    BLOCK *tem = p->next;

+    pool->mem->free_fcn(p);

+    p = tem;

+  }

+}

+

+static XML_Char *

+poolAppend(STRING_POOL *pool, const ENCODING *enc,

+           const char *ptr, const char *end)

+{

+  if (!pool->ptr && !poolGrow(pool))

+    return NULL;

+  for (;;) {

+    XmlConvert(enc, &ptr, end, (ICHAR **)&(pool->ptr), (ICHAR *)pool->end);

+    if (ptr == end)

+      break;

+    if (!poolGrow(pool))

+      return NULL;

+  }

+  return pool->start;

+}

+

+static const XML_Char * FASTCALL

+poolCopyString(STRING_POOL *pool, const XML_Char *s)

+{

+  do {

+    if (!poolAppendChar(pool, *s))

+      return NULL;

+  } while (*s++);

+  s = pool->start;

+  poolFinish(pool);

+  return s;

+}

+

+static const XML_Char *

+poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n)

+{

+  if (!pool->ptr && !poolGrow(pool))

+    return NULL;

+  for (; n > 0; --n, s++) {

+    if (!poolAppendChar(pool, *s))

+      return NULL;

+  }

+  s = pool->start;

+  poolFinish(pool);

+  return s;

+}

+

+static const XML_Char * FASTCALL

+poolAppendString(STRING_POOL *pool, const XML_Char *s)

+{

+  while (*s) {

+    if (!poolAppendChar(pool, *s))

+      return NULL;

+    s++;

+  }

+  return pool->start;

+}

+

+static XML_Char *

+poolStoreString(STRING_POOL *pool, const ENCODING *enc,

+                const char *ptr, const char *end)

+{

+  if (!poolAppend(pool, enc, ptr, end))

+    return NULL;

+  if (pool->ptr == pool->end && !poolGrow(pool))

+    return NULL;

+  *(pool->ptr)++ = 0;

+  return pool->start;

+}

+

+static XML_Bool FASTCALL

+poolGrow(STRING_POOL *pool)

+{

+  if (pool->freeBlocks) {

+    if (pool->start == 0) {

+      pool->blocks = pool->freeBlocks;

+      pool->freeBlocks = pool->freeBlocks->next;

+      pool->blocks->next = NULL;

+      pool->start = pool->blocks->s;

+      pool->end = pool->start + pool->blocks->size;

+      pool->ptr = pool->start;

+      return XML_TRUE;

+    }

+    if (pool->end - pool->start < pool->freeBlocks->size) {

+      BLOCK *tem = pool->freeBlocks->next;

+      pool->freeBlocks->next = pool->blocks;

+      pool->blocks = pool->freeBlocks;

+      pool->freeBlocks = tem;

+      memcpy(pool->blocks->s, pool->start,

+             (pool->end - pool->start) * sizeof(XML_Char));

+      pool->ptr = pool->blocks->s + (pool->ptr - pool->start);

+      pool->start = pool->blocks->s;

+      pool->end = pool->start + pool->blocks->size;

+      return XML_TRUE;

+    }

+  }

+  if (pool->blocks && pool->start == pool->blocks->s) {

+    int blockSize = (int)(pool->end - pool->start)*2;

+    pool->blocks = (BLOCK *)

+      pool->mem->realloc_fcn(pool->blocks,

+                             (offsetof(BLOCK, s)

+                              + blockSize * sizeof(XML_Char)));

+    if (pool->blocks == NULL)

+      return XML_FALSE;

+    pool->blocks->size = blockSize;

+    pool->ptr = pool->blocks->s + (pool->ptr - pool->start);

+    pool->start = pool->blocks->s;

+    pool->end = pool->start + blockSize;

+  }

+  else {

+    BLOCK *tem;

+    int blockSize = (int)(pool->end - pool->start);

+    if (blockSize < INIT_BLOCK_SIZE)

+      blockSize = INIT_BLOCK_SIZE;

+    else

+      blockSize *= 2;

+    tem = (BLOCK *)pool->mem->malloc_fcn(offsetof(BLOCK, s)

+                                        + blockSize * sizeof(XML_Char));

+    if (!tem)

+      return XML_FALSE;

+    tem->size = blockSize;

+    tem->next = pool->blocks;

+    pool->blocks = tem;

+    if (pool->ptr != pool->start)

+      memcpy(tem->s, pool->start,

+             (pool->ptr - pool->start) * sizeof(XML_Char));

+    pool->ptr = tem->s + (pool->ptr - pool->start);

+    pool->start = tem->s;

+    pool->end = tem->s + blockSize;

+  }

+  return XML_TRUE;

+}

+

+static int FASTCALL

+nextScaffoldPart(XML_Parser parser)

+{

+  DTD * const dtd = _dtd;  /* save one level of indirection */

+  CONTENT_SCAFFOLD * me;

+  int next;

+

+  if (!dtd->scaffIndex) {

+    dtd->scaffIndex = (int *)MALLOC(groupSize * sizeof(int));

+    if (!dtd->scaffIndex)

+      return -1;

+    dtd->scaffIndex[0] = 0;

+  }

+

+  if (dtd->scaffCount >= dtd->scaffSize) {

+    CONTENT_SCAFFOLD *temp;

+    if (dtd->scaffold) {

+      temp = (CONTENT_SCAFFOLD *)

+        REALLOC(dtd->scaffold, dtd->scaffSize * 2 * sizeof(CONTENT_SCAFFOLD));

+      if (temp == NULL)

+        return -1;

+      dtd->scaffSize *= 2;

+    }

+    else {

+      temp = (CONTENT_SCAFFOLD *)MALLOC(INIT_SCAFFOLD_ELEMENTS

+                                        * sizeof(CONTENT_SCAFFOLD));

+      if (temp == NULL)

+        return -1;

+      dtd->scaffSize = INIT_SCAFFOLD_ELEMENTS;

+    }

+    dtd->scaffold = temp;

+  }

+  next = dtd->scaffCount++;

+  me = &dtd->scaffold[next];

+  if (dtd->scaffLevel) {

+    CONTENT_SCAFFOLD *parent = &dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel-1]];

+    if (parent->lastchild) {

+      dtd->scaffold[parent->lastchild].nextsib = next;

+    }

+    if (!parent->childcnt)

+      parent->firstchild = next;

+    parent->lastchild = next;

+    parent->childcnt++;

+  }

+  me->firstchild = me->lastchild = me->childcnt = me->nextsib = 0;

+  return next;

+}

+

+static void

+build_node(XML_Parser parser,

+           int src_node,

+           XML_Content *dest,

+           XML_Content **contpos,

+           XML_Char **strpos)

+{

+  DTD * const dtd = _dtd;  /* save one level of indirection */

+  dest->type = dtd->scaffold[src_node].type;

+  dest->quant = dtd->scaffold[src_node].quant;

+  if (dest->type == XML_CTYPE_NAME) {

+    const XML_Char *src;

+    dest->name = *strpos;

+    src = dtd->scaffold[src_node].name;

+    for (;;) {

+      *(*strpos)++ = *src;

+      if (!*src)

+        break;

+      src++;

+    }

+    dest->numchildren = 0;

+    dest->children = NULL;

+  }

+  else {

+    unsigned int i;

+    int cn;

+    dest->numchildren = dtd->scaffold[src_node].childcnt;

+    dest->children = *contpos;

+    *contpos += dest->numchildren;

+    for (i = 0, cn = dtd->scaffold[src_node].firstchild;

+         i < dest->numchildren;

+         i++, cn = dtd->scaffold[cn].nextsib) {

+      build_node(parser, cn, &(dest->children[i]), contpos, strpos);

+    }

+    dest->name = NULL;

+  }

+}

+

+static XML_Content *

+build_model (XML_Parser parser)

+{

+  DTD * const dtd = _dtd;  /* save one level of indirection */

+  XML_Content *ret;

+  XML_Content *cpos;

+  XML_Char * str;

+  int allocsize = (dtd->scaffCount * sizeof(XML_Content)

+                   + (dtd->contentStringLen * sizeof(XML_Char)));

+

+  ret = (XML_Content *)MALLOC(allocsize);

+  if (!ret)

+    return NULL;

+

+  str =  (XML_Char *) (&ret[dtd->scaffCount]);

+  cpos = &ret[1];

+

+  build_node(parser, 0, ret, &cpos, &str);

+  return ret;

+}

+

+static ELEMENT_TYPE *

+getElementType(XML_Parser parser,

+               const ENCODING *enc,

+               const char *ptr,

+               const char *end)

+{

+  DTD * const dtd = _dtd;  /* save one level of indirection */

+  const XML_Char *name = poolStoreString(&dtd->pool, enc, ptr, end);

+  ELEMENT_TYPE *ret;

+

+  if (!name)

+    return NULL;

+  ret = (ELEMENT_TYPE *) lookup(&dtd->elementTypes, name, sizeof(ELEMENT_TYPE));

+  if (!ret)

+    return NULL;

+  if (ret->name != name)

+    poolDiscard(&dtd->pool);

+  else {

+    poolFinish(&dtd->pool);

+    if (!setElementTypePrefix(parser, ret))

+      return NULL;

+  }

+  return ret;

+}

diff --git a/AppPkg/Applications/Python/Python-2.7.2/Modules/expat/expat_external.h b/AppPkg/Applications/Python/Python-2.7.2/Modules/expat/expat_external.h
index 5246622b..d71d051a 100644
--- a/AppPkg/Applications/Python/Python-2.7.2/Modules/expat/expat_external.h
+++ b/AppPkg/Applications/Python/Python-2.7.2/Modules/expat/expat_external.h
@@ -9,7 +9,9 @@
 

 /* Namespace external symbols to allow multiple libexpat version to

    co-exist. */

-#include "pyexpatns.h"

+#if !defined(UEFI_C_SOURCE)

+  #include "pyexpatns.h"

+#endif

 

 #if defined(_MSC_EXTENSIONS) && !defined(__BEOS__) && !defined(__CYGWIN__)

 #define XML_USE_MSC_EXTENSIONS 1

@@ -101,7 +103,7 @@ typedef char XML_LChar;
 

 #ifdef XML_LARGE_SIZE  /* Use large integers for file/stream positions. */

 #if defined(XML_USE_MSC_EXTENSIONS) && _MSC_VER < 1400

-typedef __int64 XML_Index; 

+typedef __int64 XML_Index;

 typedef unsigned __int64 XML_Size;

 #else

 typedef long long XML_Index;

diff --git a/AppPkg/Applications/Python/Python-2.7.2/Modules/expat/xmlparse.c b/AppPkg/Applications/Python/Python-2.7.2/Modules/expat/xmlparse.c
index cb84274d..87ee2ea1 100644
--- a/AppPkg/Applications/Python/Python-2.7.2/Modules/expat/xmlparse.c
+++ b/AppPkg/Applications/Python/Python-2.7.2/Modules/expat/xmlparse.c
@@ -18,7 +18,11 @@
 #include <string.h>                     /* memset(), memcpy() */

 #include <assert.h>

 

+#if defined(UEFI_C_SOURCE)

+  #include <expat/expat.h>

+#else

 #include "expat.h"

+#endif

 

 #ifdef XML_UNICODE

 #define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX

@@ -1493,6 +1497,10 @@ XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
           ps_parsing = XML_FINISHED;

           return result;

         }

+        break;

+      default:

+        /* XML_FINISHED case required by compiler - but not tested - djv */

+        return XML_STATUS_OK;

       }

     }

 

diff --git a/AppPkg/Applications/Python/PythonCore.inf b/AppPkg/Applications/Python/PythonCore.inf
index 63098658..91c3afa2 100644
--- a/AppPkg/Applications/Python/PythonCore.inf
+++ b/AppPkg/Applications/Python/PythonCore.inf
@@ -41,9 +41,12 @@
   LibWchar

   LibGen

   LibNetUtil

-  BsdSocketLib

-  EfiSocketLib

   DevShell

+  #

+  # Comment out the following two library classes if socket support is

+  # NOT being built in to Python.

+  #BsdSocketLib

+  #EfiSocketLib

 

 [FixedPcd]

   gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask|0x0F

@@ -72,8 +75,10 @@
 #Python

   PyMod-$(PYTHON_VERSION)/Python/getcopyright.c

   PyMod-$(PYTHON_VERSION)/Python/marshal.c

+  PyMod-$(PYTHON_VERSION)/Python/import.c

 

   Python-$(PYTHON_VERSION)/Python/_warnings.c

+  Python-$(PYTHON_VERSION)/Python/Python-ast.c

   Python-$(PYTHON_VERSION)/Python/asdl.c

   Python-$(PYTHON_VERSION)/Python/ast.c

   Python-$(PYTHON_VERSION)/Python/bltinmodule.c

@@ -93,7 +98,6 @@
   Python-$(PYTHON_VERSION)/Python/getplatform.c

   Python-$(PYTHON_VERSION)/Python/getversion.c

   Python-$(PYTHON_VERSION)/Python/graminit.c

-  Python-$(PYTHON_VERSION)/Python/import.c

   Python-$(PYTHON_VERSION)/Python/importdl.c

   Python-$(PYTHON_VERSION)/Python/modsupport.c

   Python-$(PYTHON_VERSION)/Python/mysnprintf.c

@@ -106,7 +110,6 @@
   Python-$(PYTHON_VERSION)/Python/pystate.c

   Python-$(PYTHON_VERSION)/Python/pystrcmp.c

   Python-$(PYTHON_VERSION)/Python/pystrtod.c

-  Python-$(PYTHON_VERSION)/Python/Python-ast.c

   Python-$(PYTHON_VERSION)/Python/pythonrun.c

   Python-$(PYTHON_VERSION)/Python/structmember.c

   Python-$(PYTHON_VERSION)/Python/symtable.c

@@ -114,6 +117,8 @@
   Python-$(PYTHON_VERSION)/Python/traceback.c

 

 #Objects

+  PyMod-$(PYTHON_VERSION)/Objects/longobject.c

+

   Python-$(PYTHON_VERSION)/Objects/abstract.c

   Python-$(PYTHON_VERSION)/Objects/boolobject.c

   Python-$(PYTHON_VERSION)/Objects/bufferobject.c

@@ -137,7 +142,6 @@
   Python-$(PYTHON_VERSION)/Objects/intobject.c

   Python-$(PYTHON_VERSION)/Objects/iterobject.c

   Python-$(PYTHON_VERSION)/Objects/listobject.c

-  Python-$(PYTHON_VERSION)/Objects/longobject.c

   Python-$(PYTHON_VERSION)/Objects/memoryobject.c

   Python-$(PYTHON_VERSION)/Objects/methodobject.c

   Python-$(PYTHON_VERSION)/Objects/moduleobject.c

@@ -170,6 +174,7 @@
   Python-$(PYTHON_VERSION)/Modules/_bisectmodule.c              #

   Python-$(PYTHON_VERSION)/Modules/_codecsmodule.c              #

   Python-$(PYTHON_VERSION)/Modules/_collectionsmodule.c         #

+  Python-$(PYTHON_VERSION)/Modules/_csv.c                       #

   Python-$(PYTHON_VERSION)/Modules/_heapqmodule.c               #

   Python-$(PYTHON_VERSION)/Modules/_json.c                      #

   Python-$(PYTHON_VERSION)/Modules/_localemodule.c              #

@@ -190,20 +195,27 @@
   Python-$(PYTHON_VERSION)/Modules/md5module.c                  #

   Python-$(PYTHON_VERSION)/Modules/operator.c                   #

   Python-$(PYTHON_VERSION)/Modules/parsermodule.c               #

-  Python-$(PYTHON_VERSION)/Modules/shamodule.c                  #

   Python-$(PYTHON_VERSION)/Modules/sha256module.c               #

   Python-$(PYTHON_VERSION)/Modules/sha512module.c               #

+  Python-$(PYTHON_VERSION)/Modules/shamodule.c                  #

   Python-$(PYTHON_VERSION)/Modules/signalmodule.c               #

   Python-$(PYTHON_VERSION)/Modules/socketmodule.c               #

   Python-$(PYTHON_VERSION)/Modules/stropmodule.c                #

+  Python-$(PYTHON_VERSION)/Modules/symtablemodule.c             #

   Python-$(PYTHON_VERSION)/Modules/timemodule.c                 #

   Python-$(PYTHON_VERSION)/Modules/unicodedata.c                #

   Python-$(PYTHON_VERSION)/Modules/xxsubtype.c                  #

   Python-$(PYTHON_VERSION)/Modules/zipimport.c                  #

   Python-$(PYTHON_VERSION)/Modules/zlibmodule.c                 #

 

-  Python-$(PYTHON_VERSION)/Modules/_csv.c                       #

-  Python-$(PYTHON_VERSION)/Modules/symtablemodule.c             #

+#Modules/_io

+  Python-$(PYTHON_VERSION)/Modules/_io/_iomodule.c              #

+  Python-$(PYTHON_VERSION)/Modules/_io/bufferedio.c             #

+  Python-$(PYTHON_VERSION)/Modules/_io/bytesio.c                #

+  Python-$(PYTHON_VERSION)/Modules/_io/fileio.c                 #

+  Python-$(PYTHON_VERSION)/Modules/_io/iobase.c                 #

+  Python-$(PYTHON_VERSION)/Modules/_io/stringio.c               #

+  Python-$(PYTHON_VERSION)/Modules/_io/textio.c                 #

 

 #Modules/cjkcodecs

   Python-$(PYTHON_VERSION)/Modules/cjkcodecs/multibytecodec.c   #

@@ -214,14 +226,11 @@
   Python-$(PYTHON_VERSION)/Modules/cjkcodecs/_codecs_kr.c       #

   Python-$(PYTHON_VERSION)/Modules/cjkcodecs/_codecs_tw.c       #

 

-#Modules/_io

-  Python-$(PYTHON_VERSION)/Modules/_io/_iomodule.c              #

-  Python-$(PYTHON_VERSION)/Modules/_io/bufferedio.c             #

-  Python-$(PYTHON_VERSION)/Modules/_io/bytesio.c                #

-  Python-$(PYTHON_VERSION)/Modules/_io/fileio.c                 #

-  Python-$(PYTHON_VERSION)/Modules/_io/iobase.c                 #

-  Python-$(PYTHON_VERSION)/Modules/_io/stringio.c               #

-  Python-$(PYTHON_VERSION)/Modules/_io/textio.c                 #

+#Modules/expat

+  Python-$(PYTHON_VERSION)/Modules/pyexpat.c                    #

+  PyMod-$(PYTHON_VERSION)/Modules/expat/xmlparse.c              #

+  Python-$(PYTHON_VERSION)/Modules/expat/xmlrole.c              #

+  Python-$(PYTHON_VERSION)/Modules/expat/xmltok.c               #

 

 #Modules/zlib

   Python-$(PYTHON_VERSION)/Modules/zlib/adler32.c               #

@@ -238,8 +247,8 @@
   Python-$(PYTHON_VERSION)/Modules/zlib/zutil.c                 #

 

 [BuildOptions]

-   MSFT:*_*_IA32_CC_FLAGS         = /Oi- /wd4018 /wd4054 /wd4055 /wd4101 /wd4131 /wd4152 /wd4204 /wd4210 /wd4244 /wd4267 /wd4305 /wd4310 /wd4389 /wd4701 /wd4702 /wd4706 /I$(WORKSPACE)\AppPkg\Applications\Python\Ia32 /I$(WORKSPACE)\AppPkg\Applications\Python\Efi /I$(WORKSPACE)\AppPkg\Applications\Python\Python-$(PYTHON_VERSION)\Include

-   MSFT:*_*_X64_CC_FLAGS          = /Oi- /wd4018 /wd4054 /wd4055 /wd4101 /wd4131 /wd4152 /wd4204 /wd4210 /wd4244 /wd4267 /wd4305 /wd4310 /wd4389 /wd4701 /wd4702 /wd4706 /I$(WORKSPACE)\AppPkg\Applications\Python\X64 /I$(WORKSPACE)\AppPkg\Applications\Python\Efi /I$(WORKSPACE)\AppPkg\Applications\Python\Python-$(PYTHON_VERSION)\Include

-    GCC:*_*_IA32_CC_FLAGS         = -fno-builtin -Wno-format -I$(WORKSPACE)/AppPkg/Applications/Python/Ia32 -I$(WORKSPACE)/AppPkg/Applications/Python/Python-$(PYTHON_VERSION)/Include

-    GCC:*_*_X64_CC_FLAGS          = -Wno-format -I$(WORKSPACE)/AppPkg/Applications/Python/X64 -I$(WORKSPACE)/AppPkg/Applications/Python/Python-$(PYTHON_VERSION)/Include

+   MSFT:*_*_IA32_CC_FLAGS         = /Oi- /wd4018 /wd4054 /wd4055 /wd4101 /wd4131 /wd4152 /wd4204 /wd4210 /wd4244 /wd4267 /wd4305 /wd4310 /wd4389 /wd4701 /wd4702 /wd4706 /I$(WORKSPACE)\AppPkg\Applications\Python\Ia32 /I$(WORKSPACE)\AppPkg\Applications\Python\Efi /I$(WORKSPACE)\AppPkg\Applications\Python\Python-$(PYTHON_VERSION)\Include /DHAVE_MEMMOVE /DUSE_PYEXPAT_CAPI /DXML_STATIC

+   MSFT:*_*_X64_CC_FLAGS          = /Oi- /wd4018 /wd4054 /wd4055 /wd4101 /wd4131 /wd4152 /wd4204 /wd4210 /wd4244 /wd4267 /wd4305 /wd4310 /wd4389 /wd4701 /wd4702 /wd4706 /I$(WORKSPACE)\AppPkg\Applications\Python\X64 /I$(WORKSPACE)\AppPkg\Applications\Python\Efi /I$(WORKSPACE)\AppPkg\Applications\Python\Python-$(PYTHON_VERSION)\Include /DHAVE_MEMMOVE /DUSE_PYEXPAT_CAPI /DXML_STATIC

+    GCC:*_*_IA32_CC_FLAGS         = -fno-builtin -Wno-format -I$(WORKSPACE)/AppPkg/Applications/Python/Ia32 -I$(WORKSPACE)/AppPkg/Applications/Python/Python-$(PYTHON_VERSION)/Include -DHAVE_MEMMOVE -DUSE_PYEXPAT_CAPI -DXML_STATIC

+    GCC:*_*_X64_CC_FLAGS          = -Wno-format -I$(WORKSPACE)/AppPkg/Applications/Python/X64 -I$(WORKSPACE)/AppPkg/Applications/Python/Python-$(PYTHON_VERSION)/Include -DHAVE_MEMMOVE -DUSE_PYEXPAT_CAPI -DXML_STATIC

     GCC:*_*_IPF_SYMRENAME_FLAGS   = --redefine-syms=$(WORKSPACE)/StdLib/GccSymRename.txt

diff --git a/AppPkg/Applications/Sockets/DataSink/DataSink.c b/AppPkg/Applications/Sockets/DataSink/DataSink.c
index f2c3b3b7..14b2fd1a 100644
--- a/AppPkg/Applications/Sockets/DataSink/DataSink.c
+++ b/AppPkg/Applications/Sockets/DataSink/DataSink.c
@@ -340,7 +340,7 @@ SocketPoll (
                         ( pPortIpAddress4->sin_addr.s_addr >> 8 ) & 0xff,

                         ( pPortIpAddress4->sin_addr.s_addr >> 16 ) & 0xff,

                         ( pPortIpAddress4->sin_addr.s_addr >> 24 ) & 0xff,

-                        htons ( pPortIpAddress4->sin_port ),

+                        ntohs ( pPortIpAddress4->sin_port ),

                         errno ));

             }

             else {

@@ -362,7 +362,7 @@ SocketPoll (
                         pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 13 ],

                         pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 14 ],

                         pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 15 ],

-                        htons ( pPortIpAddress6->sin6_port ),

+                        ntohs ( pPortIpAddress6->sin6_port ),

                         errno ));

             }

 

@@ -380,7 +380,7 @@ SocketPoll (
                           ( pPortIpAddress4->sin_addr.s_addr >> 8 ) & 0xff,

                           ( pPortIpAddress4->sin_addr.s_addr >> 16 ) & 0xff,

                           ( pPortIpAddress4->sin_addr.s_addr >> 24 ) & 0xff,

-                          htons ( pPortIpAddress4->sin_port )));

+                          ntohs ( pPortIpAddress4->sin_port )));

               }

               else {

                 DEBUG (( DEBUG_INFO,

@@ -402,7 +402,7 @@ SocketPoll (
                           pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 13 ],

                           pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 14 ],

                           pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 15 ],

-                          htons ( pPortIpAddress6->sin6_port )));

+                          ntohs ( pPortIpAddress6->sin6_port )));

               }

             }

             else {

@@ -414,7 +414,7 @@ SocketPoll (
                           ( pPortIpAddress4->sin_addr.s_addr >> 8 ) & 0xff,

                           ( pPortIpAddress4->sin_addr.s_addr >> 16 ) & 0xff,

                           ( pPortIpAddress4->sin_addr.s_addr >> 24 ) & 0xff,

-                          htons ( pPortIpAddress4->sin_port ),

+                          ntohs ( pPortIpAddress4->sin_port ),

                           errno ));

               }

               else {

@@ -437,7 +437,7 @@ SocketPoll (
                           pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 13 ],

                           pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 14 ],

                           pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 15 ],

-                          htons ( pPortIpAddress6->sin6_port ),

+                          ntohs ( pPortIpAddress6->sin6_port ),

                           errno ));

               }

             }

@@ -484,7 +484,7 @@ SocketPoll (
                           ( pRemoteAddress4->sin_addr.s_addr >> 8 ) & 0xff,

                           ( pRemoteAddress4->sin_addr.s_addr >> 16 ) & 0xff,

                           ( pRemoteAddress4->sin_addr.s_addr >> 24 ) & 0xff,

-                          htons ( pRemoteAddress4->sin_port ));

+                          ntohs ( pRemoteAddress4->sin_port ));

                 }

                 else {

                   Print ( L"Rejecting connection to remote system [%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]:%d\r\n",

@@ -504,7 +504,7 @@ SocketPoll (
                           pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 13 ],

                           pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 14 ],

                           pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 15 ],

-                          htons ( pRemoteAddress6->sin6_port ));

+                          ntohs ( pRemoteAddress6->sin6_port ));

                 }

 

                 //

@@ -522,7 +522,7 @@ SocketPoll (
                               ( pRemoteAddress4->sin_addr.s_addr >> 8 ) & 0xff,

                               ( pRemoteAddress4->sin_addr.s_addr >> 16 ) & 0xff,

                               ( pRemoteAddress4->sin_addr.s_addr >> 24 ) & 0xff,

-                              htons ( pRemoteAddress4->sin_port )));

+                              ntohs ( pRemoteAddress4->sin_port )));

                   }

                   else {

                     DEBUG (( DEBUG_INFO,

@@ -544,7 +544,7 @@ SocketPoll (
                               pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 13 ],

                               pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 14 ],

                               pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 15 ],

-                              htons ( pRemoteAddress6->sin6_port )));

+                              ntohs ( pRemoteAddress6->sin6_port )));

                   }

                 }

                 else {

@@ -570,7 +570,7 @@ SocketPoll (
                           ( pRemoteAddress4->sin_addr.s_addr >> 8 ) & 0xff,

                           ( pRemoteAddress4->sin_addr.s_addr >> 16 ) & 0xff,

                           ( pRemoteAddress4->sin_addr.s_addr >> 24 ) & 0xff,

-                          htons ( pRemoteAddress4->sin_port ));

+                          ntohs ( pRemoteAddress4->sin_port ));

                 }

                 else {

                   Print ( L"Connected to remote system [%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]:%d\r\n",

@@ -590,7 +590,7 @@ SocketPoll (
                           pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 13 ],

                           pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 14 ],

                           pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 15 ],

-                          htons ( pRemoteAddress6->sin6_port ));

+                          ntohs ( pRemoteAddress6->sin6_port ));

                 }

 

                 //

@@ -625,7 +625,7 @@ SocketPoll (
                           ( pPortIpAddress4->sin_addr.s_addr >> 8 ) & 0xff,

                           ( pPortIpAddress4->sin_addr.s_addr >> 16 ) & 0xff,

                           ( pPortIpAddress4->sin_addr.s_addr >> 24 ) & 0xff,

-                          htons ( pPortIpAddress4->sin_port )));

+                          ntohs ( pPortIpAddress4->sin_port )));

               }

               else {

                 DEBUG (( DEBUG_INFO,

@@ -648,7 +648,7 @@ SocketPoll (
                           pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 13 ],

                           pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 14 ],

                           pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 15 ],

-                          htons ( pPortIpAddress6->sin6_port )));

+                          ntohs ( pPortIpAddress6->sin6_port )));

               }

 

               //

@@ -677,7 +677,7 @@ SocketPoll (
                           ( pPortIpAddress4->sin_addr.s_addr >> 8 ) & 0xff,

                           ( pPortIpAddress4->sin_addr.s_addr >> 16 ) & 0xff,

                           ( pPortIpAddress4->sin_addr.s_addr >> 24 ) & 0xff,

-                          htons ( pPortIpAddress4->sin_port ),

+                          ntohs ( pPortIpAddress4->sin_port ),

                           errno ));

               }

               else {

@@ -699,7 +699,7 @@ SocketPoll (
                           pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 13 ],

                           pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 14 ],

                           pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 15 ],

-                          htons ( pPortIpAddress6->sin6_port ),

+                          ntohs ( pPortIpAddress6->sin6_port ),

                           errno ));

               }

               CloseStatus = close ( PollFd[ Index ].fd );

@@ -713,7 +713,7 @@ SocketPoll (
                             ( pPortIpAddress4->sin_addr.s_addr >> 8 ) & 0xff,

                             ( pPortIpAddress4->sin_addr.s_addr >> 16 ) & 0xff,

                             ( pPortIpAddress4->sin_addr.s_addr >> 24 ) & 0xff,

-                            htons ( pPortIpAddress4->sin_port )));

+                            ntohs ( pPortIpAddress4->sin_port )));

                 }

                 else {

                   DEBUG (( DEBUG_INFO,

@@ -735,7 +735,7 @@ SocketPoll (
                             pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 13 ],

                             pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 14 ],

                             pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 15 ],

-                            htons ( pPortIpAddress6->sin6_port )));

+                            ntohs ( pPortIpAddress6->sin6_port )));

                 }

               }

               else {

@@ -747,7 +747,7 @@ SocketPoll (
                             ( pPortIpAddress4->sin_addr.s_addr >> 8 ) & 0xff,

                             ( pPortIpAddress4->sin_addr.s_addr >> 16 ) & 0xff,

                             ( pPortIpAddress4->sin_addr.s_addr >> 24 ) & 0xff,

-                            htons ( pPortIpAddress4->sin_port ),

+                            ntohs ( pPortIpAddress4->sin_port ),

                             errno ));

                 }

                 else {

@@ -770,7 +770,7 @@ SocketPoll (
                             pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 13 ],

                             pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 14 ],

                             pPortIpAddress6->sin6_addr.__u6_addr.__u6_addr8[ 15 ],

-                            htons ( pPortIpAddress6->sin6_port ),

+                            ntohs ( pPortIpAddress6->sin6_port ),

                             errno ));

                 }

               }

diff --git a/AppPkg/Applications/Sockets/DataSource/DataSource.c b/AppPkg/Applications/Sockets/DataSource/DataSource.c
index cf4caa2b..0dcd882e 100644
--- a/AppPkg/Applications/Sockets/DataSource/DataSource.c
+++ b/AppPkg/Applications/Sockets/DataSource/DataSource.c
@@ -386,7 +386,7 @@ SocketConnect (
             ( pRemoteAddress4->sin_addr.s_addr >> 8 ) & 0xff,

             ( pRemoteAddress4->sin_addr.s_addr >> 16 ) & 0xff,

             ( pRemoteAddress4->sin_addr.s_addr >> 24 ) & 0xff,

-            htons ( pRemoteAddress4->sin_port ));

+            ntohs ( pRemoteAddress4->sin_port ));

   }

   else {

     Print ( L"Connecting to remote system [%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]:%d\r\n",

@@ -406,7 +406,7 @@ SocketConnect (
             pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 13 ],

             pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 14 ],

             pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 15 ],

-            htons ( pRemoteAddress6->sin6_port ));

+            ntohs ( pRemoteAddress6->sin6_port ));

   }

 

   //

@@ -441,7 +441,7 @@ SocketConnect (
                 ( pRemoteAddress4->sin_addr.s_addr >> 8 ) & 0xff,

                 ( pRemoteAddress4->sin_addr.s_addr >> 16 ) & 0xff,

                 ( pRemoteAddress4->sin_addr.s_addr >> 24 ) & 0xff,

-                htons ( pRemoteAddress4->sin_port ));

+                ntohs ( pRemoteAddress4->sin_port ));

       }

       else {

         Print ( L"Connected to remote system [%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]:%d\r\n",

@@ -461,8 +461,9 @@ SocketConnect (
                 pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 13 ],

                 pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 14 ],

                 pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 15 ],

-                htons ( pRemoteAddress6->sin6_port ));

+                ntohs ( pRemoteAddress6->sin6_port ));

       }

+Print ( L"ConnectStatus: %d, Status: %r\r\n", ConnectStatus, Status );

     }

     else {

       //

@@ -478,6 +479,7 @@ SocketConnect (
   //

   //  Return the operation status

   //

+Print ( L"SocketConnect returning Status: %r\r\n", Status );

   return Status;

 }

 

@@ -571,6 +573,7 @@ SocketSend (
       DEBUG (( DEBUG_INFO,

                 "ERROR: send failed, errno: %d\r\n",

                 errno ));

+Print ( L"ERROR: send failed, errno: %d\r\n", errno );

 

       //

       //  Try again

@@ -636,6 +639,7 @@ SocketOpen (
     //  Wait for the remote network application to start

     //

     Status = SocketConnect ( );

+Print ( L"Status: %r\r\n", Status );

     if ( EFI_NOT_STARTED == Status ) {

       Status = SocketClose ( );

       continue;

@@ -659,6 +663,7 @@ SocketOpen (
   //

   //  Return the operation status

   //

+Print ( L"Returning Status: %r\r\n", Status );

   return Status;

 }

 

@@ -720,7 +725,7 @@ Tcp4Close (
                   pIpAddress[1],

                   pIpAddress[2],

                   pIpAddress[3],

-                  htons ( ((struct sockaddr_in *)&RemoteHostAddress)->sin_port ));

+                  ntohs ( ((struct sockaddr_in *)&RemoteHostAddress)->sin_port ));

         }

       }

     }

@@ -922,7 +927,7 @@ Tcp4Locate (
               pIpAddress[1],

               pIpAddress[2],

               pIpAddress[3],

-              htons ( ((struct sockaddr_in *)&RemoteHostAddress)->sin_port ));

+              ntohs ( ((struct sockaddr_in *)&RemoteHostAddress)->sin_port ));

       bTcp4Connecting = FALSE;

     }

 

@@ -1229,7 +1234,7 @@ Tcp4Open (
     Tcp4ConfigData.AccessPoint.RemoteAddress.Addr[1] = (UINT8)( ((struct sockaddr_in *)&RemoteHostAddress)->sin_addr.s_addr >> 8 );

     Tcp4ConfigData.AccessPoint.RemoteAddress.Addr[2] = (UINT8)( ((struct sockaddr_in *)&RemoteHostAddress)->sin_addr.s_addr >> 16 );

     Tcp4ConfigData.AccessPoint.RemoteAddress.Addr[3] = (UINT8)( ((struct sockaddr_in *)&RemoteHostAddress)->sin_addr.s_addr >> 24 );

-    Tcp4ConfigData.AccessPoint.RemotePort = ((struct sockaddr_in *)&RemoteHostAddress)->sin_port;

+    Tcp4ConfigData.AccessPoint.RemotePort = ntohs (((struct sockaddr_in *)&RemoteHostAddress)->sin_port);

     Tcp4ConfigData.AccessPoint.UseDefaultAddress = TRUE;

     Tcp4ConfigData.AccessPoint.SubnetMask.Addr[0] = 0;

     Tcp4ConfigData.AccessPoint.SubnetMask.Addr[1] = 0;

@@ -1288,7 +1293,7 @@ Tcp4Open (
             pIpAddress[1],

             pIpAddress[2],

             pIpAddress[3],

-            htons ( ((struct sockaddr_in *)&RemoteHostAddress)->sin_port ));

+            ntohs ( ((struct sockaddr_in *)&RemoteHostAddress)->sin_port ));

   } while ( 0 );

 

   if ( EFI_ERROR ( Status )) {

diff --git a/AppPkg/ISSUES.txt b/AppPkg/ISSUES.txt
new file mode 100644
index 00000000..0458deec
--- /dev/null
+++ b/AppPkg/ISSUES.txt
@@ -0,0 +1,28 @@
+  Status Key:

+    Open          Problem is unresolved and final disposition unknown.

+    Verified      Problem has been reproduced.

+    Understood    Root cause of problem is understood.

+    Document      Problem is to be fixed through improved documentation.

+    Fixed         Problem has been resolved and changes committed.

+

+Enquire Issues

+=============

+      Category                                         Reported       Status

+    ----------------------------------------------  --------------  -----------

+

+Main Issues

+=============

+      Category                                         Reported       Status

+    ----------------------------------------------  --------------  -----------

+1:  The main() function should not be defined EFIAPI          2012  Fixed 1/2013

+

+Python Issues

+=============

+      Category                                         Reported       Status

+    ----------------------------------------------  --------------  -----------

+1:  Setup documentation is unclear.                           2012  Understood

+    Not all sources in the Python tree are the patched version, yet the

+    documentation implies that they are.

+

+2:  The EDK II Python User's Manual is not on tianocore.      2012  Understood

+

diff --git a/ArmPkg/Application/LinuxLoader/LinuxAtagLoader.inf b/ArmPkg/Application/LinuxLoader/LinuxAtagLoader.inf
index 0c0ee477..db1a3dc8 100644
--- a/ArmPkg/Application/LinuxLoader/LinuxAtagLoader.inf
+++ b/ArmPkg/Application/LinuxLoader/LinuxAtagLoader.inf
@@ -1,5 +1,5 @@
 #/* @file

-#  Copyright (c) 2011, ARM Limited. All rights reserved.

+#  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

 #  

 #  This program and the accompanying materials                          

 #  are licensed and made available under the terms and conditions of the BSD License         

@@ -35,3 +35,5 @@
 

 [Protocols]

   gEfiLoadedImageProtocolGuid

+  gEfiDevicePathToTextProtocolGuid

+

diff --git a/ArmPkg/Application/LinuxLoader/LinuxConfig.c b/ArmPkg/Application/LinuxLoader/LinuxConfig.c
index b95d0a4d..c88dc65e 100644
--- a/ArmPkg/Application/LinuxLoader/LinuxConfig.c
+++ b/ArmPkg/Application/LinuxLoader/LinuxConfig.c
@@ -1,353 +1,354 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-#include "LinuxInternal.h"
-
-#define DEFAULT_BOOT_ENTRY_DESCRIPTION  L"Linux"
-#define MAX_STR_INPUT                   300
-#define MAX_ASCII_INPUT                 300
-
-typedef enum {
-  LINUX_LOADER_NEW = 1,
-  LINUX_LOADER_UPDATE
-} LINUX_LOADER_ACTION;
-
-STATIC
-EFI_STATUS
-EditHIInputStr (
-  IN OUT CHAR16  *CmdLine,
-  IN     UINTN   MaxCmdLine
-  )
-{
-  UINTN           CmdLineIndex;
-  UINTN           WaitIndex;
-  CHAR8           Char;
-  EFI_INPUT_KEY   Key;
-  EFI_STATUS      Status;
-
-  Print (CmdLine);
-
-  for (CmdLineIndex = StrLen (CmdLine); CmdLineIndex < MaxCmdLine; ) {
-    Status = gBS->WaitForEvent (1, &gST->ConIn->WaitForKey, &WaitIndex);
-    ASSERT_EFI_ERROR (Status);
-
-    Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
-    ASSERT_EFI_ERROR (Status);
-
-    // Unicode character is valid when Scancode is NUll
-    if (Key.ScanCode == SCAN_NULL) {
-      // Scan code is NUll, hence read Unicode character
-      Char = (CHAR8)Key.UnicodeChar;
-    } else {
-      Char = CHAR_NULL;
-    }
-
-    if ((Char == CHAR_LINEFEED) || (Char == CHAR_CARRIAGE_RETURN) || (Char == 0x7f)) {
-      CmdLine[CmdLineIndex] = '\0';
-      Print (L"\n\r");
-
-      return EFI_SUCCESS;
-    } else if ((Key.UnicodeChar == L'\b') || (Key.ScanCode == SCAN_LEFT) || (Key.ScanCode == SCAN_DELETE)){
-      if (CmdLineIndex != 0) {
-        CmdLineIndex--;
-        Print (L"\b \b");
-      }
-    } else if ((Key.ScanCode == SCAN_ESC) || (Char == 0x1B) || (Char == 0x0)) {
-      return EFI_INVALID_PARAMETER;
-    } else {
-      CmdLine[CmdLineIndex++] = Key.UnicodeChar;
-      Print (L"%c", Key.UnicodeChar);
-    }
-  }
-
-  return EFI_SUCCESS;
-}
-
-STATIC
-EFI_STATUS
-EditHIInputAscii (
-  IN OUT CHAR8   *CmdLine,
-  IN     UINTN   MaxCmdLine
-  )
-{
-  CHAR16*     Str;
-  EFI_STATUS  Status;
-
-  Str = (CHAR16*)AllocatePool (MaxCmdLine * sizeof(CHAR16));
-  AsciiStrToUnicodeStr (CmdLine, Str);
-
-  Status = EditHIInputStr (Str, MaxCmdLine);
-
-  UnicodeStrToAsciiStr (Str, CmdLine);
-  FreePool (Str);
-
-  return Status;
-}
-
-STATIC
-EFI_STATUS
-GetHIInputInteger (
-  OUT UINTN   *Integer
-  )
-{
-  CHAR16      CmdLine[255];
-  EFI_STATUS  Status;
-
-  CmdLine[0] = '\0';
-  Status = EditHIInputStr (CmdLine, 255);
-  if (!EFI_ERROR(Status)) {
-    *Integer = StrDecimalToUintn (CmdLine);
-  }
-
-  return Status;
-}
-
-#if 0
-EFI_STATUS
-GenerateDeviceDescriptionName (
-  IN  EFI_HANDLE  Handle,
-  IN OUT CHAR16*  Description
-  )
-{
-  EFI_STATUS                        Status;
-  EFI_COMPONENT_NAME_PROTOCOL*      ComponentName2Protocol;
-  EFI_DEVICE_PATH_TO_TEXT_PROTOCOL* DevicePathToTextProtocol;
-  EFI_DEVICE_PATH_PROTOCOL*         DevicePathProtocol;
-  CHAR16*                           DriverName;
-  CHAR16*                           DevicePathTxt;
-  EFI_DEVICE_PATH*                  DevicePathNode;
-
-  ComponentName2Protocol = NULL;
-  Status = gBS->HandleProtocol (Handle, &gEfiComponentName2ProtocolGuid, (VOID **)&ComponentName2Protocol);
-  if (!EFI_ERROR(Status)) {
-    //TODO: Fixme. we must find the best langague
-    Status = ComponentName2Protocol->GetDriverName (ComponentName2Protocol,"en",&DriverName);
-    if (!EFI_ERROR(Status)) {
-      StrnCpy (Description,DriverName,BOOT_DEVICE_DESCRIPTION_MAX);
-    }
-  }
-
-  if (EFI_ERROR(Status)) {
-    // Use the lastest non null entry of the Device path as a description
-    Status = gBS->HandleProtocol (Handle, &gEfiDevicePathProtocolGuid, (VOID **)&DevicePathProtocol);
-    if (EFI_ERROR(Status)) {
-      return Status;
-    }
-
-    // Convert the last non end-type Device Path Node in text for the description
-    DevicePathNode = GetLastDevicePathNode (DevicePathProtocol);
-    Status = gBS->LocateProtocol (&gEfiDevicePathToTextProtocolGuid, NULL, (VOID **)&DevicePathToTextProtocol);
-    ASSERT_EFI_ERROR(Status);
-    DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText(DevicePathNode,TRUE,TRUE);
-    StrnCpy (Description, DevicePathTxt, BOOT_DEVICE_DESCRIPTION_MAX);
-    FreePool (DevicePathTxt);
-  }
-
-  return EFI_SUCCESS;
-}
-#endif
-
-EFI_STATUS
-LinuxLoaderConfig (
-  IN EFI_LOADED_IMAGE_PROTOCOL   *LoadedImage
-  )
-{
-  EFI_STATUS                   Status;
-  LINUX_LOADER_ACTION          Choice;
-  UINTN                        BootOrderSize;
-  UINT16*                      BootOrder;
-  UINTN                        BootOrderCount;
-  UINTN                        Index;
-  CHAR16                       Description[MAX_ASCII_INPUT];
-  CHAR8                        CmdLine[MAX_ASCII_INPUT];
-  CHAR16                       Initrd[MAX_STR_INPUT];
-  UINT16                       InitrdPathListLength;
-  UINT16                       CmdLineLength;
-  BDS_LOAD_OPTION*             BdsLoadOption;
-  BDS_LOAD_OPTION**            SupportedBdsLoadOptions;
-  UINTN                        SupportedBdsLoadOptionCount;
-  LINUX_LOADER_OPTIONAL_DATA*  LinuxOptionalData;
-  EFI_DEVICE_PATH*             DevicePathRoot;
-
-  SupportedBdsLoadOptions = NULL;
-  SupportedBdsLoadOptionCount = 0;
-
-  do {
-    Print (L"[%d] Create new Linux Boot Entry\n",LINUX_LOADER_NEW);
-    Print (L"[%d] Update Linux Boot Entry\n",LINUX_LOADER_UPDATE);
-
-    Print (L"Option: ");
-    Status = GetHIInputInteger (&Choice);
-    if (Status == EFI_INVALID_PARAMETER) {
-      Print (L"\n");
-      return Status;
-    } else if ((Choice != LINUX_LOADER_NEW) && (Choice != LINUX_LOADER_UPDATE)) {
-      Print (L"Error: the option should be either '%d' or '%d'\n",LINUX_LOADER_NEW,LINUX_LOADER_UPDATE);
-      Status = EFI_INVALID_PARAMETER;
-    }
-  } while (EFI_ERROR(Status));
-
-  if (Choice == LINUX_LOADER_UPDATE) {
-    // If no compatible entry then we just create a new entry
-    Choice = LINUX_LOADER_NEW;
-
-    // Scan the OptionalData of every entry for the correct signature
-    Status = GetEnvironmentVariable (L"BootOrder", NULL, &BootOrderSize, (VOID**)&BootOrder);
-    if (!EFI_ERROR(Status)) {
-      BootOrderCount = BootOrderSize / sizeof(UINT16);
-
-      // Allocate an array to handle maximum number of supported Boot Entry
-      SupportedBdsLoadOptions = (BDS_LOAD_OPTION**)AllocatePool(sizeof(BDS_LOAD_OPTION*) * BootOrderCount);
-
-      SupportedBdsLoadOptionCount = 0;
-
-      // Check if the signature is present in the list of the current Boot entries
-      for (Index = 0; Index < BootOrderCount; Index++) {
-        Status = BootOptionFromLoadOptionIndex (BootOrder[Index], &BdsLoadOption);
-        if (!EFI_ERROR(Status)) {
-          if ((BdsLoadOption->OptionalDataSize >= sizeof(UINT32)) &&
-              (*(UINT32*)BdsLoadOption->OptionalData == LINUX_LOADER_SIGNATURE)) {
-            SupportedBdsLoadOptions[SupportedBdsLoadOptionCount++] = BdsLoadOption;
-            Choice = LINUX_LOADER_UPDATE;
-          }
-        }
-      }
-    }
-    FreePool (BootOrder);
-  }
-
-  if (Choice == LINUX_LOADER_NEW) {
-    Description[0] = '\0';
-    CmdLine[0]     = '\0';
-    Initrd[0]      = '\0';
-
-    BdsLoadOption = (BDS_LOAD_OPTION*)AllocateZeroPool (sizeof(BDS_LOAD_OPTION));
-
-    DEBUG_CODE_BEGIN();
-      CHAR16*                           DevicePathTxt;
-      EFI_DEVICE_PATH_TO_TEXT_PROTOCOL* DevicePathToTextProtocol;
-
-      Status = gBS->LocateProtocol (&gEfiDevicePathToTextProtocolGuid, NULL, (VOID **)&DevicePathToTextProtocol);
-      ASSERT_EFI_ERROR(Status);
-      DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (LoadedImage->FilePath, TRUE, TRUE);
-
-      Print(L"EFI OS Loader: %s\n",DevicePathTxt);
-
-      FreePool(DevicePathTxt);
-    DEBUG_CODE_END();
-
-    //
-    // Fill the known fields of BdsLoadOption
-    //
-
-    BdsLoadOption->Attributes = LOAD_OPTION_ACTIVE | LOAD_OPTION_CATEGORY_BOOT;
-
-    // Get the full Device Path for this file
-    Status = gBS->HandleProtocol (LoadedImage->DeviceHandle, &gEfiDevicePathProtocolGuid, (VOID **)&DevicePathRoot);
-    ASSERT_EFI_ERROR(Status);
-
-    BdsLoadOption->FilePathList = AppendDevicePath (DevicePathRoot, LoadedImage->FilePath);
-    BdsLoadOption->FilePathListLength = GetDevicePathSize (BdsLoadOption->FilePathList);
-  } else {
-    if (SupportedBdsLoadOptionCount > 1) {
-      for (Index = 0; Index < SupportedBdsLoadOptionCount; Index++) {
-        Print (L"[%d] %s\n",Index + 1,SupportedBdsLoadOptions[Index]->Description);
-      }
-
-      do {
-        Print (L"Update Boot Entry: ");
-        Status = GetHIInputInteger (&Choice);
-        if (Status == EFI_INVALID_PARAMETER) {
-          Print (L"\n");
-          return Status;
-        } else if ((Choice < 1) && (Choice > SupportedBdsLoadOptionCount)) {
-          Print (L"Choose entry from 1 to %d\n",SupportedBdsLoadOptionCount);
-          Status = EFI_INVALID_PARAMETER;
-        }
-      } while (EFI_ERROR(Status));
-      BdsLoadOption = SupportedBdsLoadOptions[Choice-1];
-    }
-    StrnCpy (Description, BdsLoadOption->Description, MAX_STR_INPUT);
-
-    LinuxOptionalData = (LINUX_LOADER_OPTIONAL_DATA*)BdsLoadOption->OptionalData;
-    if (LinuxOptionalData->CmdLineLength > 0) {
-      CopyMem (CmdLine, (CHAR8*)LinuxOptionalData + sizeof(LINUX_LOADER_OPTIONAL_DATA), LinuxOptionalData->CmdLineLength);
-    } else {
-      CmdLine[0] = '\0';
-    }
-
-    if (LinuxOptionalData->InitrdPathListLength > 0) {
-      CopyMem (Initrd, (CHAR8*)LinuxOptionalData + sizeof(LINUX_LOADER_OPTIONAL_DATA) + LinuxOptionalData->CmdLineLength, LinuxOptionalData->InitrdPathListLength);
-    } else {
-      Initrd[0] = L'\0';
-    }
-    DEBUG((EFI_D_ERROR,"L\n"));
-  }
-
-  // Description
-  Print (L"Description: ");
-  Status = EditHIInputStr (Description, MAX_STR_INPUT);
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-  if (StrLen (Description) == 0) {
-    StrnCpy (Description, DEFAULT_BOOT_ENTRY_DESCRIPTION, MAX_STR_INPUT);
-  }
-  BdsLoadOption->Description = Description;
-
-  // CmdLine
-  Print (L"Command Line: ");
-  Status = EditHIInputAscii (CmdLine, MAX_ASCII_INPUT);
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  // Initrd
-  Print (L"Initrd name: ");
-  Status = EditHIInputStr (Initrd, MAX_STR_INPUT);
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  CmdLineLength = AsciiStrLen (CmdLine);
-  if (CmdLineLength > 0) {
-    CmdLineLength += sizeof(CHAR8);
-  }
-
-  InitrdPathListLength = StrLen (Initrd) * sizeof(CHAR16);
-  if (InitrdPathListLength > 0) {
-    InitrdPathListLength += sizeof(CHAR16);
-  }
-
-  BdsLoadOption->OptionalDataSize = sizeof(LINUX_LOADER_OPTIONAL_DATA) + CmdLineLength + InitrdPathListLength;
-
-  LinuxOptionalData = (LINUX_LOADER_OPTIONAL_DATA*)AllocatePool (BdsLoadOption->OptionalDataSize);
-  BdsLoadOption->OptionalData = LinuxOptionalData;
-
-  LinuxOptionalData->Signature = LINUX_LOADER_SIGNATURE;
-  LinuxOptionalData->CmdLineLength = CmdLineLength;
-  LinuxOptionalData->InitrdPathListLength = InitrdPathListLength;
-
-  if (CmdLineLength > 0) {
-    CopyMem (LinuxOptionalData + 1, CmdLine, CmdLineLength);
-  }
-  if (InitrdPathListLength > 0) {
-    CopyMem ((UINT8*)(LinuxOptionalData + 1) + CmdLineLength, Initrd, InitrdPathListLength);
-  }
-
-  // Create or Update the boot entry
-  Status = BootOptionToLoadOptionVariable (BdsLoadOption);
-
-  return Status;
-}
+/** @file

+*

+*  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

+*

+*  This program and the accompanying materials

+*  are licensed and made available under the terms and conditions of the BSD License

+*  which accompanies this distribution.  The full text of the license may be found at

+*  http://opensource.org/licenses/bsd-license.php

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+*

+**/

+

+#include "LinuxInternal.h"

+

+#define DEFAULT_BOOT_ENTRY_DESCRIPTION  L"Linux"

+#define MAX_STR_INPUT                   300

+#define MAX_ASCII_INPUT                 300

+

+typedef enum {

+  LINUX_LOADER_NEW = 1,

+  LINUX_LOADER_UPDATE

+} LINUX_LOADER_ACTION;

+

+STATIC

+EFI_STATUS

+EditHIInputStr (

+  IN OUT CHAR16  *CmdLine,

+  IN     UINTN   MaxCmdLine

+  )

+{

+  UINTN           CmdLineIndex;

+  UINTN           WaitIndex;

+  CHAR8           Char;

+  EFI_INPUT_KEY   Key;

+  EFI_STATUS      Status;

+

+  Print (CmdLine);

+

+  for (CmdLineIndex = StrLen (CmdLine); CmdLineIndex < MaxCmdLine; ) {

+    Status = gBS->WaitForEvent (1, &gST->ConIn->WaitForKey, &WaitIndex);

+    ASSERT_EFI_ERROR (Status);

+

+    Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);

+    ASSERT_EFI_ERROR (Status);

+

+    // Unicode character is valid when Scancode is NUll

+    if (Key.ScanCode == SCAN_NULL) {

+      // Scan code is NUll, hence read Unicode character

+      Char = (CHAR8)Key.UnicodeChar;

+    } else {

+      Char = CHAR_NULL;

+    }

+

+    if ((Char == CHAR_LINEFEED) || (Char == CHAR_CARRIAGE_RETURN) || (Char == 0x7f)) {

+      CmdLine[CmdLineIndex] = '\0';

+      Print (L"\n\r");

+

+      return EFI_SUCCESS;

+    } else if ((Key.UnicodeChar == L'\b') || (Key.ScanCode == SCAN_LEFT) || (Key.ScanCode == SCAN_DELETE)){

+      if (CmdLineIndex != 0) {

+        CmdLineIndex--;

+        Print (L"\b \b");

+      }

+    } else if ((Key.ScanCode == SCAN_ESC) || (Char == 0x1B) || (Char == 0x0)) {

+      return EFI_INVALID_PARAMETER;

+    } else {

+      CmdLine[CmdLineIndex++] = Key.UnicodeChar;

+      Print (L"%c", Key.UnicodeChar);

+    }

+  }

+

+  return EFI_SUCCESS;

+}

+

+STATIC

+EFI_STATUS

+EditHIInputAscii (

+  IN OUT CHAR8   *CmdLine,

+  IN     UINTN   MaxCmdLine

+  )

+{

+  CHAR16*     Str;

+  EFI_STATUS  Status;

+

+  Str = (CHAR16*)AllocatePool (MaxCmdLine * sizeof(CHAR16));

+  AsciiStrToUnicodeStr (CmdLine, Str);

+

+  Status = EditHIInputStr (Str, MaxCmdLine);

+

+  UnicodeStrToAsciiStr (Str, CmdLine);

+  FreePool (Str);

+

+  return Status;

+}

+

+STATIC

+EFI_STATUS

+GetHIInputInteger (

+  OUT UINTN   *Integer

+  )

+{

+  CHAR16      CmdLine[255];

+  EFI_STATUS  Status;

+

+  CmdLine[0] = '\0';

+  Status = EditHIInputStr (CmdLine, 255);

+  if (!EFI_ERROR(Status)) {

+    *Integer = StrDecimalToUintn (CmdLine);

+  }

+

+  return Status;

+}

+

+#if 0

+EFI_STATUS

+GenerateDeviceDescriptionName (

+  IN  EFI_HANDLE  Handle,

+  IN OUT CHAR16*  Description

+  )

+{

+  EFI_STATUS                        Status;

+  EFI_COMPONENT_NAME_PROTOCOL*      ComponentName2Protocol;

+  EFI_DEVICE_PATH_TO_TEXT_PROTOCOL* DevicePathToTextProtocol;

+  EFI_DEVICE_PATH_PROTOCOL*         DevicePathProtocol;

+  CHAR16*                           DriverName;

+  CHAR16*                           DevicePathTxt;

+  EFI_DEVICE_PATH*                  DevicePathNode;

+

+  ComponentName2Protocol = NULL;

+  Status = gBS->HandleProtocol (Handle, &gEfiComponentName2ProtocolGuid, (VOID **)&ComponentName2Protocol);

+  if (!EFI_ERROR(Status)) {

+    //TODO: Fixme. we must find the best langague

+    Status = ComponentName2Protocol->GetDriverName (ComponentName2Protocol,"en",&DriverName);

+    if (!EFI_ERROR(Status)) {

+      StrnCpy (Description,DriverName,BOOT_DEVICE_DESCRIPTION_MAX);

+    }

+  }

+

+  if (EFI_ERROR(Status)) {

+    // Use the lastest non null entry of the Device path as a description

+    Status = gBS->HandleProtocol (Handle, &gEfiDevicePathProtocolGuid, (VOID **)&DevicePathProtocol);

+    if (EFI_ERROR(Status)) {

+      return Status;

+    }

+

+    // Convert the last non end-type Device Path Node in text for the description

+    DevicePathNode = GetLastDevicePathNode (DevicePathProtocol);

+    Status = gBS->LocateProtocol (&gEfiDevicePathToTextProtocolGuid, NULL, (VOID **)&DevicePathToTextProtocol);

+    ASSERT_EFI_ERROR(Status);

+    DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText(DevicePathNode,TRUE,TRUE);

+    StrnCpy (Description, DevicePathTxt, BOOT_DEVICE_DESCRIPTION_MAX);

+    FreePool (DevicePathTxt);

+  }

+

+  return EFI_SUCCESS;

+}

+#endif

+

+EFI_STATUS

+LinuxLoaderConfig (

+  IN EFI_LOADED_IMAGE_PROTOCOL   *LoadedImage

+  )

+{

+  EFI_STATUS                   Status;

+  LINUX_LOADER_ACTION          Choice;

+  UINTN                        BootOrderSize;

+  UINT16*                      BootOrder;

+  UINTN                        BootOrderCount;

+  UINTN                        Index;

+  CHAR16                       Description[MAX_ASCII_INPUT];

+  CHAR8                        CmdLine[MAX_ASCII_INPUT];

+  CHAR16                       Initrd[MAX_STR_INPUT];

+  UINT16                       InitrdPathListLength;

+  UINT16                       CmdLineLength;

+  BDS_LOAD_OPTION*             BdsLoadOption;

+  BDS_LOAD_OPTION**            SupportedBdsLoadOptions;

+  UINTN                        SupportedBdsLoadOptionCount;

+  LINUX_LOADER_OPTIONAL_DATA*  LinuxOptionalData;

+  EFI_DEVICE_PATH*             DevicePathRoot;

+

+  Choice = (LINUX_LOADER_ACTION)0;

+  SupportedBdsLoadOptions = NULL;

+  SupportedBdsLoadOptionCount = 0;

+

+  do {

+    Print (L"[%d] Create new Linux Boot Entry\n",LINUX_LOADER_NEW);

+    Print (L"[%d] Update Linux Boot Entry\n",LINUX_LOADER_UPDATE);

+

+    Print (L"Option: ");

+    Status = GetHIInputInteger ((UINTN*)&Choice);

+    if (Status == EFI_INVALID_PARAMETER) {

+      Print (L"\n");

+      return Status;

+    } else if ((Choice != LINUX_LOADER_NEW) && (Choice != LINUX_LOADER_UPDATE)) {

+      Print (L"Error: the option should be either '%d' or '%d'\n",LINUX_LOADER_NEW,LINUX_LOADER_UPDATE);

+      Status = EFI_INVALID_PARAMETER;

+    }

+  } while (EFI_ERROR(Status));

+

+  if (Choice == LINUX_LOADER_UPDATE) {

+    // If no compatible entry then we just create a new entry

+    Choice = LINUX_LOADER_NEW;

+

+    // Scan the OptionalData of every entry for the correct signature

+    Status = GetGlobalEnvironmentVariable (L"BootOrder", NULL, &BootOrderSize, (VOID**)&BootOrder);

+    if (!EFI_ERROR(Status)) {

+      BootOrderCount = BootOrderSize / sizeof(UINT16);

+

+      // Allocate an array to handle maximum number of supported Boot Entry

+      SupportedBdsLoadOptions = (BDS_LOAD_OPTION**)AllocatePool(sizeof(BDS_LOAD_OPTION*) * BootOrderCount);

+

+      SupportedBdsLoadOptionCount = 0;

+

+      // Check if the signature is present in the list of the current Boot entries

+      for (Index = 0; Index < BootOrderCount; Index++) {

+        Status = BootOptionFromLoadOptionIndex (BootOrder[Index], &BdsLoadOption);

+        if (!EFI_ERROR(Status)) {

+          if ((BdsLoadOption->OptionalDataSize >= sizeof(UINT32)) &&

+              (*(UINT32*)BdsLoadOption->OptionalData == LINUX_LOADER_SIGNATURE)) {

+            SupportedBdsLoadOptions[SupportedBdsLoadOptionCount++] = BdsLoadOption;

+            Choice = LINUX_LOADER_UPDATE;

+          }

+        }

+      }

+    }

+    FreePool (BootOrder);

+  }

+

+  if (Choice == LINUX_LOADER_NEW) {

+    Description[0] = '\0';

+    CmdLine[0]     = '\0';

+    Initrd[0]      = '\0';

+

+    BdsLoadOption = (BDS_LOAD_OPTION*)AllocateZeroPool (sizeof(BDS_LOAD_OPTION));

+

+    DEBUG_CODE_BEGIN();

+      CHAR16*                           DevicePathTxt;

+      EFI_DEVICE_PATH_TO_TEXT_PROTOCOL* DevicePathToTextProtocol;

+

+      Status = gBS->LocateProtocol (&gEfiDevicePathToTextProtocolGuid, NULL, (VOID **)&DevicePathToTextProtocol);

+      ASSERT_EFI_ERROR(Status);

+      DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (LoadedImage->FilePath, TRUE, TRUE);

+

+      Print(L"EFI OS Loader: %s\n",DevicePathTxt);

+

+      FreePool(DevicePathTxt);

+    DEBUG_CODE_END();

+

+    //

+    // Fill the known fields of BdsLoadOption

+    //

+

+    BdsLoadOption->Attributes = LOAD_OPTION_ACTIVE | LOAD_OPTION_CATEGORY_BOOT;

+

+    // Get the full Device Path for this file

+    Status = gBS->HandleProtocol (LoadedImage->DeviceHandle, &gEfiDevicePathProtocolGuid, (VOID **)&DevicePathRoot);

+    ASSERT_EFI_ERROR(Status);

+

+    BdsLoadOption->FilePathList = AppendDevicePath (DevicePathRoot, LoadedImage->FilePath);

+    BdsLoadOption->FilePathListLength = GetDevicePathSize (BdsLoadOption->FilePathList);

+  } else {

+    if (SupportedBdsLoadOptionCount > 1) {

+      for (Index = 0; Index < SupportedBdsLoadOptionCount; Index++) {

+        Print (L"[%d] %s\n",Index + 1,SupportedBdsLoadOptions[Index]->Description);

+      }

+

+      do {

+        Print (L"Update Boot Entry: ");

+        Status = GetHIInputInteger ((UINTN*)&Choice);

+        if (Status == EFI_INVALID_PARAMETER) {

+          Print (L"\n");

+          return Status;

+        } else if ((Choice < 1) && (Choice > SupportedBdsLoadOptionCount)) {

+          Print (L"Choose entry from 1 to %d\n",SupportedBdsLoadOptionCount);

+          Status = EFI_INVALID_PARAMETER;

+        }

+      } while (EFI_ERROR(Status));

+      BdsLoadOption = SupportedBdsLoadOptions[Choice-1];

+    }

+    StrnCpy (Description, BdsLoadOption->Description, MAX_STR_INPUT);

+

+    LinuxOptionalData = (LINUX_LOADER_OPTIONAL_DATA*)BdsLoadOption->OptionalData;

+    if (LinuxOptionalData->CmdLineLength > 0) {

+      CopyMem (CmdLine, (CHAR8*)LinuxOptionalData + sizeof(LINUX_LOADER_OPTIONAL_DATA), LinuxOptionalData->CmdLineLength);

+    } else {

+      CmdLine[0] = '\0';

+    }

+

+    if (LinuxOptionalData->InitrdPathListLength > 0) {

+      CopyMem (Initrd, (CHAR8*)LinuxOptionalData + sizeof(LINUX_LOADER_OPTIONAL_DATA) + LinuxOptionalData->CmdLineLength, LinuxOptionalData->InitrdPathListLength);

+    } else {

+      Initrd[0] = L'\0';

+    }

+    DEBUG((EFI_D_ERROR,"L\n"));

+  }

+

+  // Description

+  Print (L"Description: ");

+  Status = EditHIInputStr (Description, MAX_STR_INPUT);

+  if (EFI_ERROR(Status)) {

+    return Status;

+  }

+  if (StrLen (Description) == 0) {

+    StrnCpy (Description, DEFAULT_BOOT_ENTRY_DESCRIPTION, MAX_STR_INPUT);

+  }

+  BdsLoadOption->Description = Description;

+

+  // CmdLine

+  Print (L"Command Line: ");

+  Status = EditHIInputAscii (CmdLine, MAX_ASCII_INPUT);

+  if (EFI_ERROR(Status)) {

+    return Status;

+  }

+

+  // Initrd

+  Print (L"Initrd name: ");

+  Status = EditHIInputStr (Initrd, MAX_STR_INPUT);

+  if (EFI_ERROR(Status)) {

+    return Status;

+  }

+

+  CmdLineLength = AsciiStrLen (CmdLine);

+  if (CmdLineLength > 0) {

+    CmdLineLength += sizeof(CHAR8);

+  }

+

+  InitrdPathListLength = StrLen (Initrd) * sizeof(CHAR16);

+  if (InitrdPathListLength > 0) {

+    InitrdPathListLength += sizeof(CHAR16);

+  }

+

+  BdsLoadOption->OptionalDataSize = sizeof(LINUX_LOADER_OPTIONAL_DATA) + CmdLineLength + InitrdPathListLength;

+

+  LinuxOptionalData = (LINUX_LOADER_OPTIONAL_DATA*)AllocatePool (BdsLoadOption->OptionalDataSize);

+  BdsLoadOption->OptionalData = LinuxOptionalData;

+

+  LinuxOptionalData->Signature = LINUX_LOADER_SIGNATURE;

+  LinuxOptionalData->CmdLineLength = CmdLineLength;

+  LinuxOptionalData->InitrdPathListLength = InitrdPathListLength;

+

+  if (CmdLineLength > 0) {

+    CopyMem (LinuxOptionalData + 1, CmdLine, CmdLineLength);

+  }

+  if (InitrdPathListLength > 0) {

+    CopyMem ((UINT8*)(LinuxOptionalData + 1) + CmdLineLength, Initrd, InitrdPathListLength);

+  }

+

+  // Create or Update the boot entry

+  Status = BootOptionToLoadOptionVariable (BdsLoadOption);

+

+  return Status;

+}

diff --git a/ArmPkg/Application/LinuxLoader/LinuxFdtLoader.inf b/ArmPkg/Application/LinuxLoader/LinuxFdtLoader.inf
index a132dd9f..fbd13308 100644
--- a/ArmPkg/Application/LinuxLoader/LinuxFdtLoader.inf
+++ b/ArmPkg/Application/LinuxLoader/LinuxFdtLoader.inf
@@ -1,5 +1,5 @@
 #/* @file

-#  Copyright (c) 2011, ARM Limited. All rights reserved.

+#  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

 #  

 #  This program and the accompanying materials                          

 #  are licensed and made available under the terms and conditions of the BSD License         

@@ -35,3 +35,5 @@
 

 [Protocols]

   gEfiLoadedImageProtocolGuid

+  gEfiDevicePathToTextProtocolGuid

+

diff --git a/ArmPkg/Application/LinuxLoader/LinuxInternal.h b/ArmPkg/Application/LinuxLoader/LinuxInternal.h
index e4862735..88d786f6 100644
--- a/ArmPkg/Application/LinuxLoader/LinuxInternal.h
+++ b/ArmPkg/Application/LinuxLoader/LinuxInternal.h
@@ -1,49 +1,50 @@
-/** @file
-*
-*  Copyright (c) 2011, ARM Limited. All rights reserved.
-*
-*  This program and the accompanying materials
-*  are licensed and made available under the terms and conditions of the BSD License
-*  which accompanies this distribution.  The full text of the license may be found at
-*  http://opensource.org/licenses/bsd-license.php
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-*
-**/
-
-#ifndef __LOADER_INTERNAL_H
-#define __LOADER_INTERNAL_H
-
-#include <Uefi.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/BdsLib.h>
-#include <Library/DebugLib.h>
-#include <Library/DevicePathLib.h>
-#include <Library/MemoryAllocationLib.h>
-#include <Library/UefiBootServicesTableLib.h>
-#include <Library/UefiLib.h>
-
-#include <Protocol/LoadedImage.h>
-
-#define LINUX_KERNEL_NAME               L"zImage"
-#define FDT_NAME                        L"platform.dtb"
-
-#define LINUX_LOADER_SIGNATURE    SIGNATURE_32('l', 'i', 'l', 'o')
-
-typedef struct {
-  UINT32                        Signature;
-  UINT16                        CmdLineLength;
-  UINT16                        InitrdPathListLength;
-
-  // These following fields have variable length:
-  //CHAR8*                      CmdLine;
-  //CHAR16*                     Initrd;
-} LINUX_LOADER_OPTIONAL_DATA;
-
-EFI_STATUS
-LinuxLoaderConfig (
-  IN EFI_LOADED_IMAGE_PROTOCOL   *LoadedImage
-  );
-
-#endif
+/** @file

+*

+*  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

+*

+*  This program and the accompanying materials

+*  are licensed and made available under the terms and conditions of the BSD License

+*  which accompanies this distribution.  The full text of the license may be found at

+*  http://opensource.org/licenses/bsd-license.php

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+*

+**/

+

+#ifndef __LOADER_INTERNAL_H

+#define __LOADER_INTERNAL_H

+

+#include <Uefi.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/BdsLib.h>

+#include <Library/DebugLib.h>

+#include <Library/DevicePathLib.h>

+#include <Library/MemoryAllocationLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/UefiLib.h>

+

+#include <Protocol/LoadedImage.h>

+#include <Protocol/DevicePathToText.h>

+

+#define LINUX_KERNEL_NAME               L"zImage"

+#define FDT_NAME                        L"platform.dtb"

+

+#define LINUX_LOADER_SIGNATURE    SIGNATURE_32('l', 'i', 'l', 'o')

+

+typedef struct {

+  UINT32                        Signature;

+  UINT16                        CmdLineLength;

+  UINT16                        InitrdPathListLength;

+

+  // These following fields have variable length:

+  //CHAR8*                      CmdLine;

+  //CHAR16*                     Initrd;

+} LINUX_LOADER_OPTIONAL_DATA;

+

+EFI_STATUS

+LinuxLoaderConfig (

+  IN EFI_LOADED_IMAGE_PROTOCOL   *LoadedImage

+  );

+

+#endif

diff --git a/ArmPkg/ArmPkg.dec b/ArmPkg/ArmPkg.dec
index 7a4aa799..86a3dba7 100644
--- a/ArmPkg/ArmPkg.dec
+++ b/ArmPkg/ArmPkg.dec
@@ -65,6 +65,9 @@
   # it has been configured by the CPU DXE

   gArmTokenSpaceGuid.PcdDebuggerExceptionSupport|FALSE|BOOLEAN|0x00000032

   

+  # Define if the Power State Coordination Interface (PSCI) is supported by the Platform Trusted Firmware

+  gArmTokenSpaceGuid.PcdArmPsciSupport|FALSE|BOOLEAN|0x00000033

+  

 [PcdsFixedAtBuild.common]

   gArmTokenSpaceGuid.PcdTrustzoneSupport|FALSE|BOOLEAN|0x00000006

 

diff --git a/ArmPkg/ArmPkg.dsc b/ArmPkg/ArmPkg.dsc
index abc25a69..1b8cff11 100644
--- a/ArmPkg/ArmPkg.dsc
+++ b/ArmPkg/ArmPkg.dsc
@@ -1,131 +1,135 @@
-#/** @file
-# ARM processor package.
-#
-# Copyright (c) 2009 - 2010, Apple Inc. All rights reserved.<BR>
-#
-#    This program and the accompanying materials
-#    are licensed and made available under the terms and conditions of the BSD License
-#    which accompanies this distribution. The full text of the license may be found at
-#    http://opensource.org/licenses/bsd-license.php
-#
-#    THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#**/
-
-################################################################################
-#
-# Defines Section - statements that will be processed to create a Makefile.
-#
-################################################################################
-[Defines]
-  PLATFORM_NAME                  = ArmPkg
-  PLATFORM_GUID                  = 5CFBD99E-3C43-4E7F-8054-9CDEAFF7710F
-  PLATFORM_VERSION               = 0.1
-  DSC_SPECIFICATION              = 0x00010005
-  OUTPUT_DIRECTORY               = Build/Arm
-  SUPPORTED_ARCHITECTURES        = ARM
-  BUILD_TARGETS                  = DEBUG|RELEASE
-  SKUID_IDENTIFIER               = DEFAULT
-
-[BuildOptions]
-  XCODE:*_*_ARM_PLATFORM_FLAGS  == -arch armv7
-  XCODE:RELEASE_*_*_CC_FLAGS     = -DMDEPKG_NDEBUG 
-  
-  GCC:*_*_ARM_PLATFORM_FLAGS    == -march=armv7-a -mfpu=neon
-  GCC:RELEASE_*_*_CC_FLAGS     = -DMDEPKG_NDEBUG 
-
-  RVCT:*_*_ARM_PLATFORM_FLAGS  == --cpu Cortex-A8
-  RVCT:RELEASE_*_*_CC_FLAGS  = -DMDEPKG_NDEBUG 
-
-[LibraryClasses.common]
-  BaseLib|MdePkg/Library/BaseLib/BaseLib.inf
-  BaseMemoryLib|MdePkg/Library/BaseMemoryLib/BaseMemoryLib.inf
-  CacheMaintenanceLib|ArmPkg/Library/ArmCacheMaintenanceLib/ArmCacheMaintenanceLib.inf
-  DebugLib|MdePkg/Library/BaseDebugLibNull/BaseDebugLibNull.inf
-  HobLib|MdePkg/Library/DxeHobLib/DxeHobLib.inf
-  MemoryAllocationLib|MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf
-  PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf
-  PrintLib|MdePkg/Library/BasePrintLib/BasePrintLib.inf
-  TimerLib|MdePkg/Library/BaseTimerLibNullTemplate/BaseTimerLibNullTemplate.inf
-  UefiBootServicesTableLib|MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.inf
-  UefiDriverEntryPoint|MdePkg/Library/UefiDriverEntryPoint/UefiDriverEntryPoint.inf
-  UefiLib|MdePkg/Library/UefiLib/UefiLib.inf
-  DevicePathLib|MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.inf
-  UefiRuntimeServicesTableLib|MdePkg/Library/UefiRuntimeServicesTableLib/UefiRuntimeServicesTableLib.inf
-  PeCoffGetEntryPointLib|MdePkg/Library/BasePeCoffGetEntryPointLib/BasePeCoffGetEntryPointLib.inf
-
-  SemihostLib|ArmPkg/Library/SemihostLib/SemihostLib.inf
-  UncachedMemoryAllocationLib|ArmPkg/Library/UncachedMemoryAllocationLib/UncachedMemoryAllocationLib.inf
-  DxeServicesTableLib|MdePkg/Library/DxeServicesTableLib/DxeServicesTableLib.inf
-  DefaultExceptionHandlerLib|ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandlerLib.inf
-
-  ArmLib|ArmPkg/Library/ArmLib/ArmV7/ArmV7Lib.inf
-  CpuLib|MdePkg/Library/BaseCpuLib/BaseCpuLib.inf
-  ArmDisassemblerLib|ArmPkg/Library/ArmDisassemblerLib/ArmDisassemblerLib.inf
-  DmaLib|ArmPkg/Library/ArmDmaLib/ArmDmaLib.inf
-  ArmTrustZoneLib|ArmPkg/Library/ArmTrustZoneLib/ArmTrustZoneLib.inf
-
-  UefiApplicationEntryPoint|MdePkg/Library/UefiApplicationEntryPoint/UefiApplicationEntryPoint.inf
-  PerformanceLib|MdePkg/Library/BasePerformanceLibNull/BasePerformanceLibNull.inf
-  # TODO: Check if we cannot remove this dependancy (Mayve using the SerialLibNull implementation makes the EFI application do not print)
-  SerialPortLib|MdePkg/Library/BaseSerialPortLibNull/BaseSerialPortLibNull.inf
-
-  BdsLib|ArmPkg/Library/BdsLib/BdsLib.inf
-  FdtLib|EmbeddedPkg/Library/FdtLib/FdtLib.inf
-  
-  IoLib|MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.inf
-
-[LibraryClasses.common.PEIM]
-  HobLib|MdePkg/Library/PeiHobLib/PeiHobLib.inf
-  PeimEntryPoint|MdePkg/Library/PeimEntryPoint/PeimEntryPoint.inf
-  MemoryAllocationLib|MdePkg/Library/PeiMemoryAllocationLib/PeiMemoryAllocationLib.inf
-  PeiServicesLib|MdePkg/Library/PeiServicesLib/PeiServicesLib.inf
-  PeiServicesTablePointerLib|MdePkg/Library/PeiServicesTablePointerLib/PeiServicesTablePointerLib.inf
-
-[LibraryClasses.common.DXE_DRIVER]
-  ArmPlatformGlobalVariableLib|ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/Dxe/DxeArmPlatformGlobalVariableLib.inf
-
-[LibraryClasses.ARM]
-  NULL|ArmPkg/Library/CompilerIntrinsicsLib/CompilerIntrinsicsLib.inf
-
-[Components.common]
-  ArmPkg/Library/ArmCacheMaintenanceLib/ArmCacheMaintenanceLib.inf
-  ArmPkg/Library/ArmDisassemblerLib/ArmDisassemblerLib.inf
-  ArmPkg/Library/ArmDmaLib/ArmDmaLib.inf
-#  ArmPkg/Library/ArmLib/Arm11/Arm11ArmLib.inf
-#  ArmPkg/Library/ArmLib/Arm11/Arm11ArmLibPrePi.inf
-#  ArmPkg/Library/ArmLib/Arm9/Arm9ArmLib.inf
-#  ArmPkg/Library/ArmLib/Arm9/Arm9ArmLibPrePi.inf
-  ArmPkg/Library/ArmLib/ArmV7/ArmV7Lib.inf
-  ArmPkg/Library/ArmLib/ArmV7/ArmV7LibPrePi.inf
-  ArmPkg/Library/ArmLib/ArmV7/ArmV7LibSec.inf
-  ArmPkg/Library/ArmLib/Null/NullArmLib.inf
-  ArmPkg/Library/BaseMemoryLibStm/BaseMemoryLibStm.inf
-  ArmPkg/Library/BaseMemoryLibVstm/BaseMemoryLibVstm.inf
-  ArmPkg/Library/BasePeCoffLib/BasePeCoffLib.inf
-  ArmPkg/Library/BdsLib/BdsLib.inf
-  ArmPkg/Library/CompilerIntrinsicsLib/CompilerIntrinsicsLib.inf
-  ArmPkg/Library/DebugPeCoffExtraActionLib/DebugPeCoffExtraActionLib.inf
-  ArmPkg/Library/DebugUncachedMemoryAllocationLib/DebugUncachedMemoryAllocationLib.inf
-  ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandlerLib.inf
-  ArmPkg/Library/RvdPeCoffExtraActionLib/RvdPeCoffExtraActionLib.inf
-  ArmPkg/Library/SemiHostingDebugLib/SemiHostingDebugLib.inf
-  ArmPkg/Library/SemiHostingSerialPortLib/SemiHostingSerialPortLib.inf
-  ArmPkg/Library/SemihostLib/SemihostLib.inf
-  ArmPkg/Library/UncachedMemoryAllocationLib/UncachedMemoryAllocationLib.inf
-
-  ArmPkg/Drivers/ArmCpuLib/ArmCortexA8Lib/ArmCortexA8Lib.inf
-  ArmPkg/Drivers/ArmCpuLib/ArmCortexA9Lib/ArmCortexA9Lib.inf
-  ArmPkg/Drivers/ArmCpuLib/ArmCortexA15Lib/ArmCortexA15Lib.inf
-  ArmPkg/Drivers/CpuDxe/CpuDxe.inf
-  ArmPkg/Drivers/CpuPei/CpuPei.inf
-  ArmPkg/Drivers/PL390Gic/PL390GicDxe.inf
-  ArmPkg/Drivers/PL390Gic/PL390GicLib.inf
-  ArmPkg/Drivers/PL390Gic/PL390GicSecLib.inf
-  ArmPkg/Drivers/TimerDxe/TimerDxe.inf
-
-  ArmPkg/Filesystem/SemihostFs/SemihostFs.inf
-
-  ArmPkg/Application/LinuxLoader/LinuxAtagLoader.inf
-  ArmPkg/Application/LinuxLoader/LinuxFdtLoader.inf
+#/** @file

+# ARM processor package.

+#

+# Copyright (c) 2009 - 2010, Apple Inc. All rights reserved.<BR>

+# Copyright (c) 2011 - 2013, ARM Ltd. All rights reserved.<BR>

+#

+#    This program and the accompanying materials

+#    are licensed and made available under the terms and conditions of the BSD License

+#    which accompanies this distribution. The full text of the license may be found at

+#    http://opensource.org/licenses/bsd-license.php

+#

+#    THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#    WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#**/

+

+################################################################################

+#

+# Defines Section - statements that will be processed to create a Makefile.

+#

+################################################################################

+[Defines]

+  PLATFORM_NAME                  = ArmPkg

+  PLATFORM_GUID                  = 5CFBD99E-3C43-4E7F-8054-9CDEAFF7710F

+  PLATFORM_VERSION               = 0.1

+  DSC_SPECIFICATION              = 0x00010005

+  OUTPUT_DIRECTORY               = Build/Arm

+  SUPPORTED_ARCHITECTURES        = ARM

+  BUILD_TARGETS                  = DEBUG|RELEASE

+  SKUID_IDENTIFIER               = DEFAULT

+

+[BuildOptions]

+  XCODE:*_*_ARM_PLATFORM_FLAGS  == -arch armv7

+  XCODE:RELEASE_*_*_CC_FLAGS     = -DMDEPKG_NDEBUG 

+  

+  GCC:*_*_ARM_PLATFORM_FLAGS    == -march=armv7-a -mfpu=neon

+  GCC:RELEASE_*_*_CC_FLAGS     = -DMDEPKG_NDEBUG 

+

+  RVCT:*_*_ARM_PLATFORM_FLAGS  == --cpu Cortex-A8

+  RVCT:RELEASE_*_*_CC_FLAGS  = -DMDEPKG_NDEBUG 

+

+[LibraryClasses.common]

+  BaseLib|MdePkg/Library/BaseLib/BaseLib.inf

+  BaseMemoryLib|MdePkg/Library/BaseMemoryLib/BaseMemoryLib.inf

+  CacheMaintenanceLib|ArmPkg/Library/ArmCacheMaintenanceLib/ArmCacheMaintenanceLib.inf

+  DebugLib|MdePkg/Library/BaseDebugLibNull/BaseDebugLibNull.inf

+  HobLib|MdePkg/Library/DxeHobLib/DxeHobLib.inf

+  MemoryAllocationLib|MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf

+  PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf

+  PrintLib|MdePkg/Library/BasePrintLib/BasePrintLib.inf

+  TimerLib|MdePkg/Library/BaseTimerLibNullTemplate/BaseTimerLibNullTemplate.inf

+  UefiBootServicesTableLib|MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.inf

+  UefiDriverEntryPoint|MdePkg/Library/UefiDriverEntryPoint/UefiDriverEntryPoint.inf

+  UefiLib|MdePkg/Library/UefiLib/UefiLib.inf

+  DevicePathLib|MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.inf

+  UefiRuntimeServicesTableLib|MdePkg/Library/UefiRuntimeServicesTableLib/UefiRuntimeServicesTableLib.inf

+  PeCoffGetEntryPointLib|MdePkg/Library/BasePeCoffGetEntryPointLib/BasePeCoffGetEntryPointLib.inf

+

+  SemihostLib|ArmPkg/Library/SemihostLib/SemihostLib.inf

+  UncachedMemoryAllocationLib|ArmPkg/Library/UncachedMemoryAllocationLib/UncachedMemoryAllocationLib.inf

+  DxeServicesTableLib|MdePkg/Library/DxeServicesTableLib/DxeServicesTableLib.inf

+  DefaultExceptionHandlerLib|ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandlerLib.inf

+

+  ArmLib|ArmPkg/Library/ArmLib/ArmV7/ArmV7Lib.inf

+  CpuLib|MdePkg/Library/BaseCpuLib/BaseCpuLib.inf

+  ArmSmcLib|ArmPkg/Library/ArmSmcLib/ArmSmcLib.inf

+  ArmDisassemblerLib|ArmPkg/Library/ArmDisassemblerLib/ArmDisassemblerLib.inf

+  DmaLib|ArmPkg/Library/ArmDmaLib/ArmDmaLib.inf

+

+  UefiApplicationEntryPoint|MdePkg/Library/UefiApplicationEntryPoint/UefiApplicationEntryPoint.inf

+  PerformanceLib|MdePkg/Library/BasePerformanceLibNull/BasePerformanceLibNull.inf

+  SerialPortLib|MdePkg/Library/BaseSerialPortLibNull/BaseSerialPortLibNull.inf

+

+  BdsLib|ArmPkg/Library/BdsLib/BdsLib.inf

+  FdtLib|EmbeddedPkg/Library/FdtLib/FdtLib.inf

+  

+  IoLib|MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.inf

+

+[LibraryClasses.common.PEIM]

+  HobLib|MdePkg/Library/PeiHobLib/PeiHobLib.inf

+  PeimEntryPoint|MdePkg/Library/PeimEntryPoint/PeimEntryPoint.inf

+  MemoryAllocationLib|MdePkg/Library/PeiMemoryAllocationLib/PeiMemoryAllocationLib.inf

+  PeiServicesLib|MdePkg/Library/PeiServicesLib/PeiServicesLib.inf

+  PeiServicesTablePointerLib|MdePkg/Library/PeiServicesTablePointerLib/PeiServicesTablePointerLib.inf

+

+[LibraryClasses.common.DXE_DRIVER]

+  ArmPlatformGlobalVariableLib|ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/Dxe/DxeArmPlatformGlobalVariableLib.inf

+

+[LibraryClasses.ARM]

+  NULL|ArmPkg/Library/CompilerIntrinsicsLib/CompilerIntrinsicsLib.inf

+

+[Components.common]

+  ArmPkg/Library/ArmCacheMaintenanceLib/ArmCacheMaintenanceLib.inf

+  ArmPkg/Library/ArmDisassemblerLib/ArmDisassemblerLib.inf

+  ArmPkg/Library/ArmDmaLib/ArmDmaLib.inf

+#  ArmPkg/Library/ArmLib/Arm11/Arm11ArmLib.inf

+#  ArmPkg/Library/ArmLib/Arm11/Arm11ArmLibPrePi.inf

+#  ArmPkg/Library/ArmLib/Arm9/Arm9ArmLib.inf

+#  ArmPkg/Library/ArmLib/Arm9/Arm9ArmLibPrePi.inf

+  ArmPkg/Library/ArmLib/ArmV7/ArmV7Lib.inf

+  ArmPkg/Library/ArmLib/ArmV7/ArmV7LibPrePi.inf

+  ArmPkg/Library/ArmLib/ArmV7/ArmV7LibSec.inf

+  ArmPkg/Library/ArmLib/Null/NullArmLib.inf

+  ArmPkg/Library/BaseMemoryLibStm/BaseMemoryLibStm.inf

+  ArmPkg/Library/BaseMemoryLibVstm/BaseMemoryLibVstm.inf

+  ArmPkg/Library/BasePeCoffLib/BasePeCoffLib.inf

+  ArmPkg/Library/BdsLib/BdsLib.inf

+  ArmPkg/Library/CompilerIntrinsicsLib/CompilerIntrinsicsLib.inf

+  ArmPkg/Library/DebugAgentSymbolsBaseLib/DebugAgentSymbolsBaseLib.inf

+  ArmPkg/Library/DebugPeCoffExtraActionLib/DebugPeCoffExtraActionLib.inf

+  ArmPkg/Library/DebugUncachedMemoryAllocationLib/DebugUncachedMemoryAllocationLib.inf

+  ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandlerLib.inf

+  ArmPkg/Library/RvdPeCoffExtraActionLib/RvdPeCoffExtraActionLib.inf

+  ArmPkg/Library/SemiHostingDebugLib/SemiHostingDebugLib.inf

+  ArmPkg/Library/SemiHostingSerialPortLib/SemiHostingSerialPortLib.inf

+  ArmPkg/Library/SemihostLib/SemihostLib.inf

+  ArmPkg/Library/UncachedMemoryAllocationLib/UncachedMemoryAllocationLib.inf

+

+  ArmPkg/Drivers/ArmCpuLib/ArmCortexA8Lib/ArmCortexA8Lib.inf

+  ArmPkg/Drivers/ArmCpuLib/ArmCortexA9Lib/ArmCortexA9Lib.inf

+  ArmPkg/Drivers/ArmCpuLib/ArmCortexA15Lib/ArmCortexA15Lib.inf

+  ArmPkg/Drivers/CpuDxe/CpuDxe.inf

+  ArmPkg/Drivers/CpuPei/CpuPei.inf

+  ArmPkg/Drivers/PL390Gic/PL390GicDxe.inf

+  ArmPkg/Drivers/PL390Gic/PL390GicLib.inf

+  ArmPkg/Drivers/PL390Gic/PL390GicSecLib.inf

+  ArmPkg/Drivers/TimerDxe/TimerDxe.inf

+

+  ArmPkg/Library/ArmSmcLib/ArmSmcLib.inf

+  ArmPkg/Library/ArmSmcLibNull/ArmSmcLibNull.inf

+

+  ArmPkg/Filesystem/SemihostFs/SemihostFs.inf

+

+  ArmPkg/Application/LinuxLoader/LinuxAtagLoader.inf

+  ArmPkg/Application/LinuxLoader/LinuxFdtLoader.inf

diff --git a/ArmPkg/Drivers/ArmCpuLib/ArmCortexA9Lib/ArmCortexA9Lib.c b/ArmPkg/Drivers/ArmCpuLib/ArmCortexA9Lib/ArmCortexA9Lib.c
index 8d9530ce..2bf2d810 100644
--- a/ArmPkg/Drivers/ArmCpuLib/ArmCortexA9Lib/ArmCortexA9Lib.c
+++ b/ArmPkg/Drivers/ArmCpuLib/ArmCortexA9Lib/ArmCortexA9Lib.c
@@ -48,9 +48,6 @@ ArmCpuSetup (
 

   // If MPCore then Enable the SCU

   if (ArmIsMpCore()) {

-    // Signals the Cortex-A9 processor is taking part in coherency

-    ArmSetAuxCrBit (A9_FEATURE_SMP);

-

     ArmEnableScu ();

   }

 }

@@ -63,6 +60,8 @@ ArmCpuSetupSmpNonSecure (
 {

   INTN          ScuBase;

 

+  ArmSetAuxCrBit (A9_FEATURE_SMP);
+
   // Make the SCU accessible in Non Secure world

   if (IS_PRIMARY_CORE(MpId)) {

     ScuBase = ArmGetScuBaseAddress();

diff --git a/ArmPkg/Drivers/CpuDxe/ArmV4/ExceptionSupport.S b/ArmPkg/Drivers/CpuDxe/ArmV4/ExceptionSupport.S
index 96bd6824..2b439f33 100644
--- a/ArmPkg/Drivers/CpuDxe/ArmV4/ExceptionSupport.S
+++ b/ArmPkg/Drivers/CpuDxe/ArmV4/ExceptionSupport.S
@@ -1,191 +1,191 @@
-#------------------------------------------------------------------------------ 
-#
-# Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-#
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#------------------------------------------------------------------------------
-
-.text
-.align 3
-
-GCC_ASM_EXPORT(ExceptionHandlersStart)
-GCC_ASM_EXPORT(ExceptionHandlersEnd)
-GCC_ASM_EXPORT(CommonExceptionEntry)
-GCC_ASM_EXPORT(AsmCommonExceptionEntry)
-GCC_ASM_EXPORT(CommonCExceptionHandler)
-
-ASM_PFX(ExceptionHandlersStart):
-
-ASM_PFX(Reset):
-  b ASM_PFX(ResetEntry)
-
-ASM_PFX(UndefinedInstruction):
-  b ASM_PFX(UndefinedInstructionEntry)
-
-ASM_PFX(SoftwareInterrupt):
-  b ASM_PFX(SoftwareInterruptEntry)
-
-ASM_PFX(PrefetchAbort):
-  b ASM_PFX(PrefetchAbortEntry)
-
-ASM_PFX(DataAbort):
-  b ASM_PFX(DataAbortEntry)
-
-ASM_PFX(ReservedException):
-  b ASM_PFX(ReservedExceptionEntry)
-
-ASM_PFX(Irq):
-  b ASM_PFX(IrqEntry)
-
-ASM_PFX(Fiq):
-  b ASM_PFX(FiqEntry)
-
-ASM_PFX(ResetEntry):
-  srsdb     #0x13!                    @ Store return state on SVC stack
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-  
-  mov       R0,#0
-  ldr       R1,ASM_PFX(CommonExceptionEntry)
-  bx        R1
-
-ASM_PFX(UndefinedInstructionEntry):
-  srsdb     #0x13!                    @ Store return state on SVC stack
-  cps       #0x13                     @ Switch to SVC for common stack
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-
-  mov       r0,#1
-  ldr       r1,ASM_PFX(CommonExceptionEntry)
-  bx        r1
-
-ASM_PFX(SoftwareInterruptEntry):
-  srsdb     #0x13!                    @ Store return state on SVC stack
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-
-  mov       r0,#2
-  ldr       r1,ASM_PFX(CommonExceptionEntry)
-  bx        r1
-
-ASM_PFX(PrefetchAbortEntry):
-  sub       LR,LR,#4
-  srsdb     #0x13!                    @ Store return state on SVC stack
-  cps       #0x13                     @ Switch to SVC for common stack
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-
-  mov       r0,#3
-  ldr       r1,ASM_PFX(CommonExceptionEntry)
-  bx        r1
-
-ASM_PFX(DataAbortEntry):
-  sub       LR,LR,#8
-  srsdb     #0x13!                    @ Store return state on SVC stack
-  cps       #0x13                     @ Switch to SVC for common stack
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-
-  mov       r0,#4
-  ldr       r1,ASM_PFX(CommonExceptionEntry)
-  bx        r1
-
-ASM_PFX(ReservedExceptionEntry):
-  srsdb     #0x13!                    @ Store return state on SVC stack
-  cps       #0x13                     @ Switch to SVC for common stack
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-
-  mov       r0,#5
-  ldr       r1,ASM_PFX(CommonExceptionEntry)
-  bx        r1
-
-ASM_PFX(IrqEntry):
-  sub       LR,LR,#4
-  srsdb     #0x13!                    @ Store return state on SVC stack
-  cps       #0x13                     @ Switch to SVC for common stack
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-
-  mov       r0,#6
-  ldr       r1,ASM_PFX(CommonExceptionEntry)
-  bx        r1
-
-ASM_PFX(FiqEntry):
-  sub       LR,LR,#4
-  srsdb     #0x13!                    @ Store return state on SVC stack
-  cps       #0x13                     @ Switch to SVC for common stack
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-
-  mov       r0,#7
-  ldr       r1,ASM_PFX(CommonExceptionEntry)
-  bx        r1
-
-ASM_PFX(CommonExceptionEntry):
-  .byte       0x12
-  .byte       0x34
-  .byte       0x56
-  .byte       0x78
-
-ASM_PFX(ExceptionHandlersEnd):
-
-ASM_PFX(AsmCommonExceptionEntry):
-  mrc       p15, 0, R1, c6, c0, 2   @ Read IFAR
-  str       R1, [SP, #0x50]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.IFAR 
-  
-  mrc       p15, 0, R1, c5, c0, 1   @ Read IFSR
-  str       R1, [SP, #0x4c]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.IFSR
-  
-  mrc       p15, 0, R1, c6, c0, 0   @ Read DFAR
-  str       R1, [SP, #0x48]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.DFAR
-  
-  mrc       p15, 0, R1, c5, c0, 0   @ Read DFSR
-  str       R1, [SP, #0x44]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.DFSR
-  
-  ldr       R1, [SP, #0x5c]         @ srsdb saved pre-exception CPSR on the stack 
-  str       R1, [SP, #0x40]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.CPSR
-  and       r1, r1, #0x1f           @ Check to see if User or System Mode
-  cmp       r1, #0x1f
-  cmpne     r1, #0x10
-  add       R2, SP, #0x38           @ Store it in EFI_SYSTEM_CONTEXT_ARM.LR
-  ldmneed   r2, {lr}^               @ User or System mode, use unbanked register
-  ldmneed   r2, {lr}                @ All other modes used banked register
-
-  ldr       R1, [SP, #0x58]         @ PC is the LR pushed by srsdb 
-  str       R1, [SP, #0x3c]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.PC
-  
-  sub       R1, SP, #0x60           @ We pused 0x60 bytes on the stack 
-  str       R1, [SP, #0x34]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.SP
-  
-                                              @ R0 is exception type 
-  mov       R1,SP                             @ Prepare System Context pointer as an argument for the exception handler
-  blx       ASM_PFX(CommonCExceptionHandler)  @ Call exception handler
-  
-  ldr       R2,[SP,#0x40]           @ EFI_SYSTEM_CONTEXT_ARM.CPSR
-  str       R2,[SP,#0x5c]           @ Store it back to srsdb stack slot so it can be restored 
-
-  ldr       R2,[SP,#0x3c]           @ EFI_SYSTEM_CONTEXT_ARM.PC
-  str       R2,[SP,#0x58]           @ Store it back to srsdb stack slot so it can be restored 
-
-  ldmfd     SP!,{R0-R12}            @ Restore general purpose registers
-                                    @ Exception handler can not change SP or LR as we would blow chunks
-                                    
-  add       SP,SP,#0x20             @ Clear out the remaining stack space
-  ldmfd     SP!,{LR}                @ restore the link register for this context
-  rfefd     SP!                     @ return from exception via srsdb stack slot
+#------------------------------------------------------------------------------ 

+#

+# Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+.text

+.align 3

+

+GCC_ASM_EXPORT(ExceptionHandlersStart)

+GCC_ASM_EXPORT(ExceptionHandlersEnd)

+GCC_ASM_EXPORT(CommonExceptionEntry)

+GCC_ASM_EXPORT(AsmCommonExceptionEntry)

+GCC_ASM_EXPORT(CommonCExceptionHandler)

+

+ASM_PFX(ExceptionHandlersStart):

+

+ASM_PFX(Reset):

+  b ASM_PFX(ResetEntry)

+

+ASM_PFX(UndefinedInstruction):

+  b ASM_PFX(UndefinedInstructionEntry)

+

+ASM_PFX(SoftwareInterrupt):

+  b ASM_PFX(SoftwareInterruptEntry)

+

+ASM_PFX(PrefetchAbort):

+  b ASM_PFX(PrefetchAbortEntry)

+

+ASM_PFX(DataAbort):

+  b ASM_PFX(DataAbortEntry)

+

+ASM_PFX(ReservedException):

+  b ASM_PFX(ReservedExceptionEntry)

+

+ASM_PFX(Irq):

+  b ASM_PFX(IrqEntry)

+

+ASM_PFX(Fiq):

+  b ASM_PFX(FiqEntry)

+

+ASM_PFX(ResetEntry):

+  srsdb     #0x13!                    @ Store return state on SVC stack

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+  

+  mov       R0,#0

+  ldr       R1,ASM_PFX(CommonExceptionEntry)

+  bx        R1

+

+ASM_PFX(UndefinedInstructionEntry):

+  srsdb     #0x13!                    @ Store return state on SVC stack

+  cps       #0x13                     @ Switch to SVC for common stack

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+

+  mov       r0,#1

+  ldr       r1,ASM_PFX(CommonExceptionEntry)

+  bx        r1

+

+ASM_PFX(SoftwareInterruptEntry):

+  srsdb     #0x13!                    @ Store return state on SVC stack

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+

+  mov       r0,#2

+  ldr       r1,ASM_PFX(CommonExceptionEntry)

+  bx        r1

+

+ASM_PFX(PrefetchAbortEntry):

+  sub       LR,LR,#4

+  srsdb     #0x13!                    @ Store return state on SVC stack

+  cps       #0x13                     @ Switch to SVC for common stack

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+

+  mov       r0,#3

+  ldr       r1,ASM_PFX(CommonExceptionEntry)

+  bx        r1

+

+ASM_PFX(DataAbortEntry):

+  sub       LR,LR,#8

+  srsdb     #0x13!                    @ Store return state on SVC stack

+  cps       #0x13                     @ Switch to SVC for common stack

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+

+  mov       r0,#4

+  ldr       r1,ASM_PFX(CommonExceptionEntry)

+  bx        r1

+

+ASM_PFX(ReservedExceptionEntry):

+  srsdb     #0x13!                    @ Store return state on SVC stack

+  cps       #0x13                     @ Switch to SVC for common stack

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+

+  mov       r0,#5

+  ldr       r1,ASM_PFX(CommonExceptionEntry)

+  bx        r1

+

+ASM_PFX(IrqEntry):

+  sub       LR,LR,#4

+  srsdb     #0x13!                    @ Store return state on SVC stack

+  cps       #0x13                     @ Switch to SVC for common stack

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+

+  mov       r0,#6

+  ldr       r1,ASM_PFX(CommonExceptionEntry)

+  bx        r1

+

+ASM_PFX(FiqEntry):

+  sub       LR,LR,#4

+  srsdb     #0x13!                    @ Store return state on SVC stack

+  cps       #0x13                     @ Switch to SVC for common stack

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+

+  mov       r0,#7

+  ldr       r1,ASM_PFX(CommonExceptionEntry)

+  bx        r1

+

+ASM_PFX(CommonExceptionEntry):

+  .byte       0x12

+  .byte       0x34

+  .byte       0x56

+  .byte       0x78

+

+ASM_PFX(ExceptionHandlersEnd):

+

+ASM_PFX(AsmCommonExceptionEntry):

+  mrc       p15, 0, R1, c6, c0, 2   @ Read IFAR

+  str       R1, [SP, #0x50]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.IFAR 

+  

+  mrc       p15, 0, R1, c5, c0, 1   @ Read IFSR

+  str       R1, [SP, #0x4c]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.IFSR

+  

+  mrc       p15, 0, R1, c6, c0, 0   @ Read DFAR

+  str       R1, [SP, #0x48]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.DFAR

+  

+  mrc       p15, 0, R1, c5, c0, 0   @ Read DFSR

+  str       R1, [SP, #0x44]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.DFSR

+  

+  ldr       R1, [SP, #0x5c]         @ srsdb saved pre-exception CPSR on the stack 

+  str       R1, [SP, #0x40]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.CPSR

+  and       r1, r1, #0x1f           @ Check to see if User or System Mode

+  cmp       r1, #0x1f

+  cmpne     r1, #0x10

+  add       R2, SP, #0x38           @ Store it in EFI_SYSTEM_CONTEXT_ARM.LR

+  ldmneed   r2, {lr}^               @ User or System mode, use unbanked register

+  ldmneed   r2, {lr}                @ All other modes used banked register

+

+  ldr       R1, [SP, #0x58]         @ PC is the LR pushed by srsdb 

+  str       R1, [SP, #0x3c]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.PC

+  

+  sub       R1, SP, #0x60           @ We pused 0x60 bytes on the stack 

+  str       R1, [SP, #0x34]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.SP

+  

+                                              @ R0 is exception type 

+  mov       R1,SP                             @ Prepare System Context pointer as an argument for the exception handler

+  blx       ASM_PFX(CommonCExceptionHandler)  @ Call exception handler

+  

+  ldr       R2,[SP,#0x40]           @ EFI_SYSTEM_CONTEXT_ARM.CPSR

+  str       R2,[SP,#0x5c]           @ Store it back to srsdb stack slot so it can be restored 

+

+  ldr       R2,[SP,#0x3c]           @ EFI_SYSTEM_CONTEXT_ARM.PC

+  str       R2,[SP,#0x58]           @ Store it back to srsdb stack slot so it can be restored 

+

+  ldmfd     SP!,{R0-R12}            @ Restore general purpose registers

+                                    @ Exception handler can not change SP or LR as we would blow chunks

+                                    

+  add       SP,SP,#0x20             @ Clear out the remaining stack space

+  ldmfd     SP!,{LR}                @ restore the link register for this context

+  rfefd     SP!                     @ return from exception via srsdb stack slot

diff --git a/ArmPkg/Drivers/CpuDxe/ArmV4/ExceptionSupport.asm b/ArmPkg/Drivers/CpuDxe/ArmV4/ExceptionSupport.asm
index 4af58339..2ea8d65f 100644
--- a/ArmPkg/Drivers/CpuDxe/ArmV4/ExceptionSupport.asm
+++ b/ArmPkg/Drivers/CpuDxe/ArmV4/ExceptionSupport.asm
@@ -1,152 +1,152 @@
-//------------------------------------------------------------------------------ 
-//
-// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-//
-// This program and the accompanying materials
-// are licensed and made available under the terms and conditions of the BSD License
-// which accompanies this distribution.  The full text of the license may be found at
-// http://opensource.org/licenses/bsd-license.php
-//
-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-//
-//------------------------------------------------------------------------------
-
-  EXPORT  ExceptionHandlersStart
-  EXPORT  ExceptionHandlersEnd
-  EXPORT  CommonExceptionEntry
-  EXPORT  AsmCommonExceptionEntry
-  IMPORT  CommonCExceptionHandler
-
-  PRESERVE8
-  AREA  DxeExceptionHandlers, CODE, READONLY
-  
-ExceptionHandlersStart
-
-Reset
-  b   ResetEntry
-
-UndefinedInstruction
-  b   UndefinedInstructionEntry
-
-SoftwareInterrupt
-  b   SoftwareInterruptEntry
-
-PrefetchAbort
-  b   PrefetchAbortEntry
-
-DataAbort
-  b   DataAbortEntry
-
-ReservedException
-  b   ReservedExceptionEntry
-
-Irq
-  b   IrqEntry
-
-Fiq
-  b   FiqEntry
-
-ResetEntry
-  stmfd     SP!,{R0-R1}
-  mov       R0,#0
-  ldr       R1,CommonExceptionEntry
-  bx        R1
-
-UndefinedInstructionEntry
-  stmfd     SP!,{R0-R1}
-  mov       R0,#1
-  ldr       R1,CommonExceptionEntry
-  bx        R1
-
-SoftwareInterruptEntry
-  stmfd     SP!,{R0-R1}
-  mov       R0,#2
-  ldr       R1,CommonExceptionEntry
-  bx        R1
-
-PrefetchAbortEntry
-  stmfd     SP!,{R0-R1}
-  mov       R0,#3
-  SUB       LR,LR,#4
-  ldr       R1,CommonExceptionEntry
-  bx        R1
-
-DataAbortEntry
-  stmfd     SP!,{R0-R1}
-  mov       R0,#4
-  SUB       LR,LR,#8
-  ldr       R1,CommonExceptionEntry
-  bx        R1
-
-ReservedExceptionEntry
-  stmfd     SP!,{R0-R1}
-  mov       R0,#5
-  ldr       R1,CommonExceptionEntry
-  bx        R1
-
-IrqEntry
-  stmfd     SP!,{R0-R1}
-  mov       R0,#6
-  SUB       LR,LR,#4
-  ldr       R1,CommonExceptionEntry
-  bx        R1
-
-FiqEntry
-  stmfd     SP!,{R0-R1}
-  mov       R0,#7
-  SUB       LR,LR,#4
-  ldr       R1,CommonExceptionEntry
-  bx        R1
-
-CommonExceptionEntry
-  dcd       0x12345678
-
-ExceptionHandlersEnd
-
-AsmCommonExceptionEntry
-  mrc       p15, 0, r1, c6, c0, 2   ; Read IFAR
-  stmfd     SP!,{R1}                ; Store the IFAR
-  
-  mrc       p15, 0, r1, c5, c0, 1   ; Read IFSR
-  stmfd     SP!,{R1}                ; Store the IFSR
-  
-  mrc       p15, 0, r1, c6, c0, 0   ; Read DFAR
-  stmfd     SP!,{R1}                ; Store the DFAR
-  
-  mrc       p15, 0, r1, c5, c0, 0   ; Read DFSR
-  stmfd     SP!,{R1}                ; Store the DFSR
-  
-  mrs       R1,SPSR                 ; Read SPSR (which is the pre-exception CPSR)
-  stmfd     SP!,{R1}                ; Store the SPSR
-  
-  stmfd     SP!,{LR}                ; Store the link register (which is the pre-exception PC)
-  stmfd     SP,{SP,LR}^             ; Store user/system mode stack pointer and link register
-  nop                               ; Required by ARM architecture
-  SUB       SP,SP,#0x08             ; Adjust stack pointer
-  stmfd     SP!,{R2-R12}            ; Store general purpose registers
-  
-  ldr       R3,[SP,#0x50]           ; Read saved R1 from the stack (it was saved by the exception entry routine)
-  ldr       R2,[SP,#0x4C]           ; Read saved R0 from the stack (it was saved by the exception entry routine)
-  stmfd     SP!,{R2-R3}             ; Store general purpose registers R0 and R1
-  
-  mov       R1,SP                   ; Prepare System Context pointer as an argument for the exception handler
-  
-  sub       SP,SP,#4                ; Adjust SP to preserve 8-byte alignment
-  blx       CommonCExceptionHandler ; Call exception handler
-  add       SP,SP,#4                ; Adjust SP back to where we were
-  
-  ldr       R2,[SP,#0x40]           ; Load CPSR from context, in case it has changed
-  MSR       SPSR_cxsf,R2            ; Store it back to the SPSR to be restored when exiting this handler
-
-  ldmfd     SP!,{R0-R12}            ; Restore general purpose registers
-  ldm       SP,{SP,LR}^             ; Restore user/system mode stack pointer and link register
-  nop                               ; Required by ARM architecture
-  add       SP,SP,#0x08             ; Adjust stack pointer
-  ldmfd     SP!,{LR}                ; Restore the link register (which is the pre-exception PC)
-  add       SP,SP,#0x1C             ; Clear out the remaining stack space
-  movs      PC,LR                   ; Return from exception
-  
-  END
-
-
+//------------------------------------------------------------------------------ 

+//

+// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+//

+// This program and the accompanying materials

+// are licensed and made available under the terms and conditions of the BSD License

+// which accompanies this distribution.  The full text of the license may be found at

+// http://opensource.org/licenses/bsd-license.php

+//

+// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+//

+//------------------------------------------------------------------------------

+

+  EXPORT  ExceptionHandlersStart

+  EXPORT  ExceptionHandlersEnd

+  EXPORT  CommonExceptionEntry

+  EXPORT  AsmCommonExceptionEntry

+  IMPORT  CommonCExceptionHandler

+

+  PRESERVE8

+  AREA  DxeExceptionHandlers, CODE, READONLY

+  

+ExceptionHandlersStart

+

+Reset

+  b   ResetEntry

+

+UndefinedInstruction

+  b   UndefinedInstructionEntry

+

+SoftwareInterrupt

+  b   SoftwareInterruptEntry

+

+PrefetchAbort

+  b   PrefetchAbortEntry

+

+DataAbort

+  b   DataAbortEntry

+

+ReservedException

+  b   ReservedExceptionEntry

+

+Irq

+  b   IrqEntry

+

+Fiq

+  b   FiqEntry

+

+ResetEntry

+  stmfd     SP!,{R0-R1}

+  mov       R0,#0

+  ldr       R1,CommonExceptionEntry

+  bx        R1

+

+UndefinedInstructionEntry

+  stmfd     SP!,{R0-R1}

+  mov       R0,#1

+  ldr       R1,CommonExceptionEntry

+  bx        R1

+

+SoftwareInterruptEntry

+  stmfd     SP!,{R0-R1}

+  mov       R0,#2

+  ldr       R1,CommonExceptionEntry

+  bx        R1

+

+PrefetchAbortEntry

+  stmfd     SP!,{R0-R1}

+  mov       R0,#3

+  SUB       LR,LR,#4

+  ldr       R1,CommonExceptionEntry

+  bx        R1

+

+DataAbortEntry

+  stmfd     SP!,{R0-R1}

+  mov       R0,#4

+  SUB       LR,LR,#8

+  ldr       R1,CommonExceptionEntry

+  bx        R1

+

+ReservedExceptionEntry

+  stmfd     SP!,{R0-R1}

+  mov       R0,#5

+  ldr       R1,CommonExceptionEntry

+  bx        R1

+

+IrqEntry

+  stmfd     SP!,{R0-R1}

+  mov       R0,#6

+  SUB       LR,LR,#4

+  ldr       R1,CommonExceptionEntry

+  bx        R1

+

+FiqEntry

+  stmfd     SP!,{R0-R1}

+  mov       R0,#7

+  SUB       LR,LR,#4

+  ldr       R1,CommonExceptionEntry

+  bx        R1

+

+CommonExceptionEntry

+  dcd       0x12345678

+

+ExceptionHandlersEnd

+

+AsmCommonExceptionEntry

+  mrc       p15, 0, r1, c6, c0, 2   ; Read IFAR

+  stmfd     SP!,{R1}                ; Store the IFAR

+  

+  mrc       p15, 0, r1, c5, c0, 1   ; Read IFSR

+  stmfd     SP!,{R1}                ; Store the IFSR

+  

+  mrc       p15, 0, r1, c6, c0, 0   ; Read DFAR

+  stmfd     SP!,{R1}                ; Store the DFAR

+  

+  mrc       p15, 0, r1, c5, c0, 0   ; Read DFSR

+  stmfd     SP!,{R1}                ; Store the DFSR

+  

+  mrs       R1,SPSR                 ; Read SPSR (which is the pre-exception CPSR)

+  stmfd     SP!,{R1}                ; Store the SPSR

+  

+  stmfd     SP!,{LR}                ; Store the link register (which is the pre-exception PC)

+  stmfd     SP,{SP,LR}^             ; Store user/system mode stack pointer and link register

+  nop                               ; Required by ARM architecture

+  SUB       SP,SP,#0x08             ; Adjust stack pointer

+  stmfd     SP!,{R2-R12}            ; Store general purpose registers

+  

+  ldr       R3,[SP,#0x50]           ; Read saved R1 from the stack (it was saved by the exception entry routine)

+  ldr       R2,[SP,#0x4C]           ; Read saved R0 from the stack (it was saved by the exception entry routine)

+  stmfd     SP!,{R2-R3}             ; Store general purpose registers R0 and R1

+  

+  mov       R1,SP                   ; Prepare System Context pointer as an argument for the exception handler

+  

+  sub       SP,SP,#4                ; Adjust SP to preserve 8-byte alignment

+  blx       CommonCExceptionHandler ; Call exception handler

+  add       SP,SP,#4                ; Adjust SP back to where we were

+  

+  ldr       R2,[SP,#0x40]           ; Load CPSR from context, in case it has changed

+  MSR       SPSR_cxsf,R2            ; Store it back to the SPSR to be restored when exiting this handler

+

+  ldmfd     SP!,{R0-R12}            ; Restore general purpose registers

+  ldm       SP,{SP,LR}^             ; Restore user/system mode stack pointer and link register

+  nop                               ; Required by ARM architecture

+  add       SP,SP,#0x08             ; Adjust stack pointer

+  ldmfd     SP!,{LR}                ; Restore the link register (which is the pre-exception PC)

+  add       SP,SP,#0x1C             ; Clear out the remaining stack space

+  movs      PC,LR                   ; Return from exception

+  

+  END

+

+

diff --git a/ArmPkg/Drivers/CpuDxe/Exception.c b/ArmPkg/Drivers/CpuDxe/ArmV6/Exception.c
index 55a71321..55a71321 100644
--- a/ArmPkg/Drivers/CpuDxe/Exception.c
+++ b/ArmPkg/Drivers/CpuDxe/ArmV6/Exception.c
diff --git a/ArmPkg/Drivers/CpuDxe/ArmV6/ExceptionSupport.S b/ArmPkg/Drivers/CpuDxe/ArmV6/ExceptionSupport.S
index 86d2a713..948ad699 100644
--- a/ArmPkg/Drivers/CpuDxe/ArmV6/ExceptionSupport.S
+++ b/ArmPkg/Drivers/CpuDxe/ArmV6/ExceptionSupport.S
@@ -1,297 +1,297 @@
-#------------------------------------------------------------------------------ 
-#
-# Use ARMv6 instruction to operate on a single stack
-#
-# Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-#
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#------------------------------------------------------------------------------
-
-#include <Library/PcdLib.h>
-
-/*
-
-This is the stack constructed by the exception handler (low address to high address)
-                # R0 - IFAR is EFI_SYSTEM_CONTEXT for ARM
-  Reg   Offset
-  ===   ======              
-  R0    0x00    # stmfd     SP!,{R0-R12}
-  R1    0x04
-  R2    0x08
-  R3    0x0c
-  R4    0x10
-  R5    0x14
-  R6    0x18
-  R7    0x1c
-  R8    0x20
-  R9    0x24
-  R10   0x28
-  R11   0x2c
-  R12   0x30
-  SP    0x34    # reserved via adding 0x20 (32) to the SP
-  LR    0x38
-  PC    0x3c
-  CPSR  0x40
-  DFSR  0x44
-  DFAR  0x48
-  IFSR  0x4c
-  IFAR  0x50
-  
-  LR    0x54    # SVC Link register (we need to restore it)
-  
-  LR    0x58    # pushed by srsfd    
-  CPSR  0x5c    
-
- */
- 
-
-GCC_ASM_EXPORT(ExceptionHandlersStart)
-GCC_ASM_EXPORT(ExceptionHandlersEnd)
-GCC_ASM_EXPORT(CommonExceptionEntry)
-GCC_ASM_EXPORT(AsmCommonExceptionEntry)
-GCC_ASM_EXPORT(CommonCExceptionHandler)
-
-.text
-#if !defined(__APPLE__)
-.fpu neon    @ makes vpush/vpop assemble
-#endif
-.align 5
-
-
-//
-// This code gets copied to the ARM vector table
-// ExceptionHandlersStart - ExceptionHandlersEnd gets copied
-//
-ASM_PFX(ExceptionHandlersStart):
-
-ASM_PFX(Reset):
-  b ASM_PFX(ResetEntry)
-
-ASM_PFX(UndefinedInstruction):
-  b ASM_PFX(UndefinedInstructionEntry)
-
-ASM_PFX(SoftwareInterrupt):
-  b ASM_PFX(SoftwareInterruptEntry)
-
-ASM_PFX(PrefetchAbort):
-  b ASM_PFX(PrefetchAbortEntry)
-
-ASM_PFX(DataAbort):
-  b ASM_PFX(DataAbortEntry)
-
-ASM_PFX(ReservedException):
-  b ASM_PFX(ReservedExceptionEntry)
-
-ASM_PFX(Irq):
-  b ASM_PFX(IrqEntry)
-
-ASM_PFX(Fiq):
-  b ASM_PFX(FiqEntry)
-
-ASM_PFX(ResetEntry):
-  srsdb     #0x13!                    @ Store return state on SVC stack
-                                      @ We are already in SVC mode
-
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-  
-  mov       R0,#0                     @ ExceptionType
-  ldr       R1,ASM_PFX(CommonExceptionEntry)
-  bx        R1
-
-ASM_PFX(UndefinedInstructionEntry):
-  sub       LR, LR, #4                @ Only -2 for Thumb, adjust in CommonExceptionEntry
-  srsdb     #0x13!                    @ Store return state on SVC stack
-  cps       #0x13                     @ Switch to SVC for common stack
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-
-  mov       R0,#1                     @ ExceptionType
-  ldr       R1,ASM_PFX(CommonExceptionEntry)
-  bx        R1
-
-ASM_PFX(SoftwareInterruptEntry):
-  sub       LR, LR, #4                @ Only -2 for Thumb, adjust in CommonExceptionEntry
-  srsdb     #0x13!                    @ Store return state on SVC stack
-                                      @ We are already in SVC mode
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-
-  mov       R0,#2                     @ ExceptionType
-  ldr       R1,ASM_PFX(CommonExceptionEntry)
-  bx        R1
-
-ASM_PFX(PrefetchAbortEntry):
-  sub       LR,LR,#4
-  srsdb     #0x13!                    @ Store return state on SVC stack
-  cps       #0x13                     @ Switch to SVC for common stack
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-
-  mov       R0,#3                     @ ExceptionType
-  ldr       R1,ASM_PFX(CommonExceptionEntry)
-  bx        R1
-
-ASM_PFX(DataAbortEntry):
-  sub       LR,LR,#8
-  srsdb     #0x13!                    @ Store return state on SVC stack
-  cps       #0x13                     @ Switch to SVC for common stack
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-
-  mov       R0,#4
-  ldr       R1,ASM_PFX(CommonExceptionEntry)
-  bx        R1
-
-ASM_PFX(ReservedExceptionEntry):
-  srsdb     #0x13!                    @ Store return state on SVC stack
-  cps       #0x13                     @ Switch to SVC for common stack
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-
-  mov       R0,#5
-  ldr       R1,ASM_PFX(CommonExceptionEntry)
-  bx        R1
-
-ASM_PFX(IrqEntry):
-  sub       LR,LR,#4
-  srsdb     #0x13!                    @ Store return state on SVC stack
-  cps       #0x13                     @ Switch to SVC for common stack
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-
-  mov       R0,#6                     @ ExceptionType
-  ldr       R1,ASM_PFX(CommonExceptionEntry)
-  bx        R1
-
-ASM_PFX(FiqEntry):
-  sub       LR,LR,#4
-  srsdb     #0x13!                    @ Store return state on SVC stack
-  cps       #0x13                     @ Switch to SVC for common stack
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-                                      @ Since we have already switch to SVC R8_fiq - R12_fiq
-                                      @ never get used or saved
-  mov       R0,#7                     @ ExceptionType
-  ldr       R1,ASM_PFX(CommonExceptionEntry)
-  bx        R1
-
-//
-// This gets patched by the C code that patches in the vector table
-//
-ASM_PFX(CommonExceptionEntry):
-  .word       ASM_PFX(AsmCommonExceptionEntry)
-
-ASM_PFX(ExceptionHandlersEnd):
-
-//
-// This code runs from CpuDxe driver loaded address. It is patched into 
-// CommonExceptionEntry.
-//
-ASM_PFX(AsmCommonExceptionEntry):
-  mrc       p15, 0, R1, c6, c0, 2   @ Read IFAR
-  str       R1, [SP, #0x50]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.IFAR 
-  
-  mrc       p15, 0, R1, c5, c0, 1   @ Read IFSR
-  str       R1, [SP, #0x4c]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.IFSR
-  
-  mrc       p15, 0, R1, c6, c0, 0   @ Read DFAR
-  str       R1, [SP, #0x48]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.DFAR
-  
-  mrc       p15, 0, R1, c5, c0, 0   @ Read DFSR
-  str       R1, [SP, #0x44]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.DFSR
-  
-  ldr       R1, [SP, #0x5c]         @ srsdb saved pre-exception CPSR on the stack 
-  str       R1, [SP, #0x40]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.CPSR
-
-  add       R2, SP, #0x38           @ Make R2 point to EFI_SYSTEM_CONTEXT_ARM.LR
-  and       R3, R1, #0x1f           @ Check CPSR to see if User or System Mode
-  cmp       R3, #0x1f               @ if ((CPSR == 0x10) || (CPSR == 0x1df))
-  cmpne     R3, #0x10               @   
-  stmeqed   R2, {lr}^               @   save unbanked lr
-                                    @ else 
-  stmneed   R2, {lr}                @   save SVC lr
-
-
-  ldr       R5, [SP, #0x58]         @ PC is the LR pushed by srsfd 
-                                    @ Check to see if we have to adjust for Thumb entry
-  sub       r4, r0, #1              @ if (ExceptionType == 1 || ExceptionType ==2)) {
-  cmp       r4, #1                  @   // UND & SVC have differnt LR adjust for Thumb 
-  bhi       NoAdjustNeeded
-  
-  tst       r1, #0x20               @   if ((CPSR & T)) == T) {  // Thumb Mode on entry 
-  addne     R5, R5, #2              @     PC += 2@
-  str       R5,[SP,#0x58]           @ Update LR value pused by srsfd 
-  
-NoAdjustNeeded:
-
-  str       R5, [SP, #0x3c]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.PC
-  
-  sub       R1, SP, #0x60           @ We pused 0x60 bytes on the stack 
-  str       R1, [SP, #0x34]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.SP
-  
-                                    @ R0 is ExceptionType 
-  mov       R1,SP                   @ R1 is SystemContext 
-
-#if (FixedPcdGet32(PcdVFPEnabled))
-  vpush     {d0-d15}                @ save vstm registers in case they are used in optimizations
-#endif
-
-/* 
-VOID
-EFIAPI
-CommonCExceptionHandler (
-  IN     EFI_EXCEPTION_TYPE           ExceptionType,   R0
-  IN OUT EFI_SYSTEM_CONTEXT           SystemContext    R1
-  )
-
-*/  
-  blx       ASM_PFX(CommonCExceptionHandler)  @ Call exception handler
-
-#if (FixedPcdGet32(PcdVFPEnabled))
-  vpop      {d0-d15}  
-#endif
-
-  ldr       R1, [SP, #0x4c]         @ Restore EFI_SYSTEM_CONTEXT_ARM.IFSR
-  mcr       p15, 0, R1, c5, c0, 1   @ Write IFSR
-
-  ldr       R1, [SP, #0x44]         @ sRestore EFI_SYSTEM_CONTEXT_ARM.DFSR
-  mcr       p15, 0, R1, c5, c0, 0   @ Write DFSR
-  
-  ldr       R1,[SP,#0x3c]           @ EFI_SYSTEM_CONTEXT_ARM.PC
-  str       R1,[SP,#0x58]           @ Store it back to srsfd stack slot so it can be restored 
-
-  ldr       R1,[SP,#0x40]           @ EFI_SYSTEM_CONTEXT_ARM.CPSR
-  str       R1,[SP,#0x5c]           @ Store it back to srsfd stack slot so it can be restored 
-  
-  add       R3, SP, #0x54           @ Make R3 point to SVC LR saved on entry
-  add       R2, SP, #0x38           @ Make R2 point to EFI_SYSTEM_CONTEXT_ARM.LR
-  and       R1, R1, #0x1f           @ Check to see if User or System Mode
-  cmp       R1, #0x1f               @ if ((CPSR == 0x10) || (CPSR == 0x1f))
-  cmpne     R1, #0x10               @   
-  ldmeqed   R2, {lr}^               @   restore unbanked lr
-                                    @ else
-  ldmneed   R3, {lr}                @   restore SVC lr, via ldmfd SP!, {LR}
-  
-  ldmfd     SP!,{R0-R12}            @ Restore general purpose registers
-                                    @ Exception handler can not change SP
-                                    
-  add       SP,SP,#0x20             @ Clear out the remaining stack space
-  ldmfd     SP!,{LR}                @ restore the link register for this context
-  rfefd     SP!                     @ return from exception via srsfd stack slot
-  
+#------------------------------------------------------------------------------ 

+#

+# Use ARMv6 instruction to operate on a single stack

+#

+# Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+#include <Library/PcdLib.h>

+

+/*

+

+This is the stack constructed by the exception handler (low address to high address)

+                # R0 - IFAR is EFI_SYSTEM_CONTEXT for ARM

+  Reg   Offset

+  ===   ======              

+  R0    0x00    # stmfd     SP!,{R0-R12}

+  R1    0x04

+  R2    0x08

+  R3    0x0c

+  R4    0x10

+  R5    0x14

+  R6    0x18

+  R7    0x1c

+  R8    0x20

+  R9    0x24

+  R10   0x28

+  R11   0x2c

+  R12   0x30

+  SP    0x34    # reserved via adding 0x20 (32) to the SP

+  LR    0x38

+  PC    0x3c

+  CPSR  0x40

+  DFSR  0x44

+  DFAR  0x48

+  IFSR  0x4c

+  IFAR  0x50

+  

+  LR    0x54    # SVC Link register (we need to restore it)

+  

+  LR    0x58    # pushed by srsfd    

+  CPSR  0x5c    

+

+ */

+ 

+

+GCC_ASM_EXPORT(ExceptionHandlersStart)

+GCC_ASM_EXPORT(ExceptionHandlersEnd)

+GCC_ASM_EXPORT(CommonExceptionEntry)

+GCC_ASM_EXPORT(AsmCommonExceptionEntry)

+GCC_ASM_EXPORT(CommonCExceptionHandler)

+

+.text

+#if !defined(__APPLE__)

+.fpu neon    @ makes vpush/vpop assemble

+#endif

+.align 5

+

+

+//

+// This code gets copied to the ARM vector table

+// ExceptionHandlersStart - ExceptionHandlersEnd gets copied

+//

+ASM_PFX(ExceptionHandlersStart):

+

+ASM_PFX(Reset):

+  b ASM_PFX(ResetEntry)

+

+ASM_PFX(UndefinedInstruction):

+  b ASM_PFX(UndefinedInstructionEntry)

+

+ASM_PFX(SoftwareInterrupt):

+  b ASM_PFX(SoftwareInterruptEntry)

+

+ASM_PFX(PrefetchAbort):

+  b ASM_PFX(PrefetchAbortEntry)

+

+ASM_PFX(DataAbort):

+  b ASM_PFX(DataAbortEntry)

+

+ASM_PFX(ReservedException):

+  b ASM_PFX(ReservedExceptionEntry)

+

+ASM_PFX(Irq):

+  b ASM_PFX(IrqEntry)

+

+ASM_PFX(Fiq):

+  b ASM_PFX(FiqEntry)

+

+ASM_PFX(ResetEntry):

+  srsdb     #0x13!                    @ Store return state on SVC stack

+                                      @ We are already in SVC mode

+

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+  

+  mov       R0,#0                     @ ExceptionType

+  ldr       R1,ASM_PFX(CommonExceptionEntry)

+  bx        R1

+

+ASM_PFX(UndefinedInstructionEntry):

+  sub       LR, LR, #4                @ Only -2 for Thumb, adjust in CommonExceptionEntry

+  srsdb     #0x13!                    @ Store return state on SVC stack

+  cps       #0x13                     @ Switch to SVC for common stack

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+

+  mov       R0,#1                     @ ExceptionType

+  ldr       R1,ASM_PFX(CommonExceptionEntry)

+  bx        R1

+

+ASM_PFX(SoftwareInterruptEntry):

+  sub       LR, LR, #4                @ Only -2 for Thumb, adjust in CommonExceptionEntry

+  srsdb     #0x13!                    @ Store return state on SVC stack

+                                      @ We are already in SVC mode

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+

+  mov       R0,#2                     @ ExceptionType

+  ldr       R1,ASM_PFX(CommonExceptionEntry)

+  bx        R1

+

+ASM_PFX(PrefetchAbortEntry):

+  sub       LR,LR,#4

+  srsdb     #0x13!                    @ Store return state on SVC stack

+  cps       #0x13                     @ Switch to SVC for common stack

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+

+  mov       R0,#3                     @ ExceptionType

+  ldr       R1,ASM_PFX(CommonExceptionEntry)

+  bx        R1

+

+ASM_PFX(DataAbortEntry):

+  sub       LR,LR,#8

+  srsdb     #0x13!                    @ Store return state on SVC stack

+  cps       #0x13                     @ Switch to SVC for common stack

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+

+  mov       R0,#4

+  ldr       R1,ASM_PFX(CommonExceptionEntry)

+  bx        R1

+

+ASM_PFX(ReservedExceptionEntry):

+  srsdb     #0x13!                    @ Store return state on SVC stack

+  cps       #0x13                     @ Switch to SVC for common stack

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+

+  mov       R0,#5

+  ldr       R1,ASM_PFX(CommonExceptionEntry)

+  bx        R1

+

+ASM_PFX(IrqEntry):

+  sub       LR,LR,#4

+  srsdb     #0x13!                    @ Store return state on SVC stack

+  cps       #0x13                     @ Switch to SVC for common stack

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+

+  mov       R0,#6                     @ ExceptionType

+  ldr       R1,ASM_PFX(CommonExceptionEntry)

+  bx        R1

+

+ASM_PFX(FiqEntry):

+  sub       LR,LR,#4

+  srsdb     #0x13!                    @ Store return state on SVC stack

+  cps       #0x13                     @ Switch to SVC for common stack

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+                                      @ Since we have already switch to SVC R8_fiq - R12_fiq

+                                      @ never get used or saved

+  mov       R0,#7                     @ ExceptionType

+  ldr       R1,ASM_PFX(CommonExceptionEntry)

+  bx        R1

+

+//

+// This gets patched by the C code that patches in the vector table

+//

+ASM_PFX(CommonExceptionEntry):

+  .word       ASM_PFX(AsmCommonExceptionEntry)

+

+ASM_PFX(ExceptionHandlersEnd):

+

+//

+// This code runs from CpuDxe driver loaded address. It is patched into 

+// CommonExceptionEntry.

+//

+ASM_PFX(AsmCommonExceptionEntry):

+  mrc       p15, 0, R1, c6, c0, 2   @ Read IFAR

+  str       R1, [SP, #0x50]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.IFAR 

+  

+  mrc       p15, 0, R1, c5, c0, 1   @ Read IFSR

+  str       R1, [SP, #0x4c]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.IFSR

+  

+  mrc       p15, 0, R1, c6, c0, 0   @ Read DFAR

+  str       R1, [SP, #0x48]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.DFAR

+  

+  mrc       p15, 0, R1, c5, c0, 0   @ Read DFSR

+  str       R1, [SP, #0x44]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.DFSR

+  

+  ldr       R1, [SP, #0x5c]         @ srsdb saved pre-exception CPSR on the stack 

+  str       R1, [SP, #0x40]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.CPSR

+

+  add       R2, SP, #0x38           @ Make R2 point to EFI_SYSTEM_CONTEXT_ARM.LR

+  and       R3, R1, #0x1f           @ Check CPSR to see if User or System Mode

+  cmp       R3, #0x1f               @ if ((CPSR == 0x10) || (CPSR == 0x1df))

+  cmpne     R3, #0x10               @   

+  stmeqed   R2, {lr}^               @   save unbanked lr

+                                    @ else 

+  stmneed   R2, {lr}                @   save SVC lr

+

+

+  ldr       R5, [SP, #0x58]         @ PC is the LR pushed by srsfd 

+                                    @ Check to see if we have to adjust for Thumb entry

+  sub       r4, r0, #1              @ if (ExceptionType == 1 || ExceptionType ==2)) {

+  cmp       r4, #1                  @   // UND & SVC have differnt LR adjust for Thumb 

+  bhi       NoAdjustNeeded

+  

+  tst       r1, #0x20               @   if ((CPSR & T)) == T) {  // Thumb Mode on entry 

+  addne     R5, R5, #2              @     PC += 2@

+  str       R5,[SP,#0x58]           @ Update LR value pused by srsfd 

+  

+NoAdjustNeeded:

+

+  str       R5, [SP, #0x3c]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.PC

+  

+  sub       R1, SP, #0x60           @ We pused 0x60 bytes on the stack 

+  str       R1, [SP, #0x34]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.SP

+  

+                                    @ R0 is ExceptionType 

+  mov       R1,SP                   @ R1 is SystemContext 

+

+#if (FixedPcdGet32(PcdVFPEnabled))

+  vpush     {d0-d15}                @ save vstm registers in case they are used in optimizations

+#endif

+

+/* 

+VOID

+EFIAPI

+CommonCExceptionHandler (

+  IN     EFI_EXCEPTION_TYPE           ExceptionType,   R0

+  IN OUT EFI_SYSTEM_CONTEXT           SystemContext    R1

+  )

+

+*/  

+  blx       ASM_PFX(CommonCExceptionHandler)  @ Call exception handler

+

+#if (FixedPcdGet32(PcdVFPEnabled))

+  vpop      {d0-d15}  

+#endif

+

+  ldr       R1, [SP, #0x4c]         @ Restore EFI_SYSTEM_CONTEXT_ARM.IFSR

+  mcr       p15, 0, R1, c5, c0, 1   @ Write IFSR

+

+  ldr       R1, [SP, #0x44]         @ sRestore EFI_SYSTEM_CONTEXT_ARM.DFSR

+  mcr       p15, 0, R1, c5, c0, 0   @ Write DFSR

+  

+  ldr       R1,[SP,#0x3c]           @ EFI_SYSTEM_CONTEXT_ARM.PC

+  str       R1,[SP,#0x58]           @ Store it back to srsfd stack slot so it can be restored 

+

+  ldr       R1,[SP,#0x40]           @ EFI_SYSTEM_CONTEXT_ARM.CPSR

+  str       R1,[SP,#0x5c]           @ Store it back to srsfd stack slot so it can be restored 

+  

+  add       R3, SP, #0x54           @ Make R3 point to SVC LR saved on entry

+  add       R2, SP, #0x38           @ Make R2 point to EFI_SYSTEM_CONTEXT_ARM.LR

+  and       R1, R1, #0x1f           @ Check to see if User or System Mode

+  cmp       R1, #0x1f               @ if ((CPSR == 0x10) || (CPSR == 0x1f))

+  cmpne     R1, #0x10               @   

+  ldmeqed   R2, {lr}^               @   restore unbanked lr

+                                    @ else

+  ldmneed   R3, {lr}                @   restore SVC lr, via ldmfd SP!, {LR}

+  

+  ldmfd     SP!,{R0-R12}            @ Restore general purpose registers

+                                    @ Exception handler can not change SP

+                                    

+  add       SP,SP,#0x20             @ Clear out the remaining stack space

+  ldmfd     SP!,{LR}                @ restore the link register for this context

+  rfefd     SP!                     @ return from exception via srsfd stack slot

+  

diff --git a/ArmPkg/Drivers/CpuDxe/Mmu.c b/ArmPkg/Drivers/CpuDxe/ArmV6/Mmu.c
index dcc7b682..dcc7b682 100644
--- a/ArmPkg/Drivers/CpuDxe/Mmu.c
+++ b/ArmPkg/Drivers/CpuDxe/ArmV6/Mmu.c
diff --git a/ArmPkg/Drivers/CpuDxe/CpuDxe.inf b/ArmPkg/Drivers/CpuDxe/CpuDxe.inf
index b471e4ac..16afd045 100644
--- a/ArmPkg/Drivers/CpuDxe/CpuDxe.inf
+++ b/ArmPkg/Drivers/CpuDxe/CpuDxe.inf
@@ -40,8 +40,8 @@
 #

 

 [Sources.ARM]

-  Mmu.c

-  Exception.c

+  ArmV6/Mmu.c

+  ArmV6/Exception.c

   ArmV6/ExceptionSupport.asm | RVCT

   ArmV6/ExceptionSupport.S   | GCC

 

diff --git a/ArmPkg/Drivers/CpuPei/CpuPei.inf b/ArmPkg/Drivers/CpuPei/CpuPei.inf
index 3d1665aa..ec8b9f5c 100755
--- a/ArmPkg/Drivers/CpuPei/CpuPei.inf
+++ b/ArmPkg/Drivers/CpuPei/CpuPei.inf
@@ -53,7 +53,7 @@
   gEmbeddedTokenSpaceGuid.PcdPrePiCpuMemorySize

   gEmbeddedTokenSpaceGuid.PcdPrePiCpuIoSize

 

-[FeaturePcd]  
+[FeaturePcd]  

   gEmbeddedTokenSpaceGuid.PcdCacheEnable  

 

 [depex]

diff --git a/ArmPkg/Drivers/PL390Gic/PL390GicDxe.c b/ArmPkg/Drivers/PL390Gic/PL390GicDxe.c
index 1a8239e7..31e91f9c 100644
--- a/ArmPkg/Drivers/PL390Gic/PL390GicDxe.c
+++ b/ArmPkg/Drivers/PL390Gic/PL390GicDxe.c
@@ -1,425 +1,426 @@
-/*++
-
-Copyright (c) 2009, Hewlett-Packard Company. All rights reserved.<BR>
-Portions copyright (c) 2010, Apple Inc. All rights reserved.<BR>
-Portions copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR> 
-
-This program and the accompanying materials                          
-are licensed and made available under the terms and conditions of the BSD License         
-which accompanies this distribution.  The full text of the license may be found at        
-http://opensource.org/licenses/bsd-license.php                                            
-                                                                                          
-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.   
-
-Module Name:
-
-  Gic.c
-
-Abstract:
-
-  Driver implementing the GIC interrupt controller protocol
-
---*/
-
-#include <PiDxe.h>
-
-#include <Library/BaseLib.h>
-#include <Library/DebugLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/MemoryAllocationLib.h>
-#include <Library/UefiBootServicesTableLib.h>
-#include <Library/UefiLib.h>
-#include <Library/PcdLib.h>
-#include <Library/IoLib.h>
-#include <Library/ArmGicLib.h>
-
-#include <Protocol/Cpu.h>
-#include <Protocol/HardwareInterrupt.h>
-
-#define ARM_GIC_DEFAULT_PRIORITY  0x80
-
-extern EFI_HARDWARE_INTERRUPT_PROTOCOL gHardwareInterruptProtocol;
-
-//
-// Notifications
-//
-EFI_EVENT EfiExitBootServicesEvent      = (EFI_EVENT)NULL;
-
-// Maximum Number of Interrupts
-UINTN mGicNumInterrupts                 = 0;
-
-HARDWARE_INTERRUPT_HANDLER  *gRegisteredInterruptHandlers = NULL;
-
-/**
-  Register Handler for the specified interrupt source.
-
-  @param This     Instance pointer for this protocol
-  @param Source   Hardware source of the interrupt
-  @param Handler  Callback for interrupt. NULL to unregister
-
-  @retval EFI_SUCCESS Source was updated to support Handler.
-  @retval EFI_DEVICE_ERROR  Hardware could not be programmed.
-
-**/
-EFI_STATUS
-EFIAPI
-RegisterInterruptSource (
-  IN EFI_HARDWARE_INTERRUPT_PROTOCOL    *This,
-  IN HARDWARE_INTERRUPT_SOURCE          Source,
-  IN HARDWARE_INTERRUPT_HANDLER         Handler
-  )
-{
-  if (Source > mGicNumInterrupts) {
-    ASSERT(FALSE);
-    return EFI_UNSUPPORTED;
-  }
-  
-  if ((Handler == NULL) && (gRegisteredInterruptHandlers[Source] == NULL)) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  if ((Handler != NULL) && (gRegisteredInterruptHandlers[Source] != NULL)) {
-    return EFI_ALREADY_STARTED;
-  }
-
-  gRegisteredInterruptHandlers[Source] = Handler;
-
-  // If the interrupt handler is unregistered then disable the interrupt
-  if (NULL == Handler){
-  	return This->DisableInterruptSource (This, Source);
-  } else {
-  	return This->EnableInterruptSource (This, Source);
-  }
-}
-
-/**
-  Enable interrupt source Source.
-
-  @param This     Instance pointer for this protocol
-  @param Source   Hardware source of the interrupt
-
-  @retval EFI_SUCCESS       Source interrupt enabled.
-  @retval EFI_DEVICE_ERROR  Hardware could not be programmed.
-
-**/
-EFI_STATUS
-EFIAPI
-EnableInterruptSource (
-  IN EFI_HARDWARE_INTERRUPT_PROTOCOL    *This,
-  IN HARDWARE_INTERRUPT_SOURCE          Source
-  )
-{
-  UINT32    RegOffset;
-  UINTN     RegShift;
-  
-  if (Source > mGicNumInterrupts) {
-    ASSERT(FALSE);
-    return EFI_UNSUPPORTED;
-  }
-  
-  // Calculate enable register offset and bit position
-  RegOffset = Source / 32;
-  RegShift = Source % 32;
-
-  // Write set-enable register
-  MmioWrite32 (PcdGet32(PcdGicDistributorBase) + ARM_GIC_ICDISER + (4*RegOffset), 1 << RegShift);
-  
-  return EFI_SUCCESS;
-}
-
-/**
-  Disable interrupt source Source.
-
-  @param This     Instance pointer for this protocol
-  @param Source   Hardware source of the interrupt
-
-  @retval EFI_SUCCESS       Source interrupt disabled.
-  @retval EFI_DEVICE_ERROR  Hardware could not be programmed.
-
-**/
-EFI_STATUS
-EFIAPI
-DisableInterruptSource (
-  IN EFI_HARDWARE_INTERRUPT_PROTOCOL    *This,
-  IN HARDWARE_INTERRUPT_SOURCE          Source
-  )
-{
-  UINT32    RegOffset;
-  UINTN     RegShift;
-  
-  if (Source > mGicNumInterrupts) {
-    ASSERT(FALSE);
-    return EFI_UNSUPPORTED;
-  }
-  
-  // Calculate enable register offset and bit position
-  RegOffset = Source / 32;
-  RegShift = Source % 32;
-
-  // Write set-enable register
-  MmioWrite32 (PcdGet32(PcdGicDistributorBase) + ARM_GIC_ICDICER + (4*RegOffset), 1 << RegShift);
-  
-  return EFI_SUCCESS;
-}
-
-/**
-  Return current state of interrupt source Source.
-
-  @param This     Instance pointer for this protocol
-  @param Source   Hardware source of the interrupt
-  @param InterruptState  TRUE: source enabled, FALSE: source disabled.
-
-  @retval EFI_SUCCESS       InterruptState is valid
-  @retval EFI_DEVICE_ERROR  InterruptState is not valid
-
-**/
-EFI_STATUS
-EFIAPI
-GetInterruptSourceState (
-  IN EFI_HARDWARE_INTERRUPT_PROTOCOL    *This,
-  IN HARDWARE_INTERRUPT_SOURCE          Source,
-  IN BOOLEAN                            *InterruptState
-  )
-{
-  UINT32    RegOffset;
-  UINTN     RegShift;
-  
-  if (Source > mGicNumInterrupts) {
-    ASSERT(FALSE);
-    return EFI_UNSUPPORTED;
-  }
-  
-  // calculate enable register offset and bit position
-  RegOffset = Source / 32;
-  RegShift = Source % 32;
-    
-  if ((MmioRead32 (PcdGet32(PcdGicDistributorBase) + ARM_GIC_ICDISER + (4*RegOffset)) & (1<<RegShift)) == 0) {
-    *InterruptState = FALSE;
-  } else {
-    *InterruptState = TRUE;
-  }
-  
-  return EFI_SUCCESS;
-}
-
-/**
-  Signal to the hardware that the End Of Intrrupt state 
-  has been reached.
-
-  @param This     Instance pointer for this protocol
-  @param Source   Hardware source of the interrupt
-
-  @retval EFI_SUCCESS       Source interrupt EOI'ed.
-  @retval EFI_DEVICE_ERROR  Hardware could not be programmed.
-
-**/
-EFI_STATUS
-EFIAPI
-EndOfInterrupt (
-  IN EFI_HARDWARE_INTERRUPT_PROTOCOL    *This,
-  IN HARDWARE_INTERRUPT_SOURCE          Source
-  )
-{
-  if (Source > mGicNumInterrupts) {
-    ASSERT(FALSE);
-    return EFI_UNSUPPORTED;
-  }
-
-  MmioWrite32 (PcdGet32(PcdGicInterruptInterfaceBase) + ARM_GIC_ICCEIOR, Source);
-  return EFI_SUCCESS;
-}
-
-/**
-  EFI_CPU_INTERRUPT_HANDLER that is called when a processor interrupt occurs.
-
-  @param  InterruptType    Defines the type of interrupt or exception that
-                           occurred on the processor.This parameter is processor architecture specific.
-  @param  SystemContext    A pointer to the processor context when
-                           the interrupt occurred on the processor.
-
-  @return None
-
-**/
-VOID
-EFIAPI
-IrqInterruptHandler (
-  IN EFI_EXCEPTION_TYPE           InterruptType,
-  IN EFI_SYSTEM_CONTEXT           SystemContext
-  )
-{
-  UINT32                      GicInterrupt;
-  HARDWARE_INTERRUPT_HANDLER  InterruptHandler;
-
-  GicInterrupt = MmioRead32 (PcdGet32(PcdGicInterruptInterfaceBase) + ARM_GIC_ICCIAR);
-
-  // Special Interrupts (ID1020-ID1023) have an Interrupt ID greater than the number of interrupt (ie: Spurious interrupt).
-  if (GicInterrupt >= mGicNumInterrupts) {
-    // The special interrupt do not need to be acknowledge
-    return;
-  }
-  
-  InterruptHandler = gRegisteredInterruptHandlers[GicInterrupt];
-  if (InterruptHandler != NULL) {
-    // Call the registered interrupt handler.
-    InterruptHandler (GicInterrupt, SystemContext);
-  } else {
-    DEBUG ((EFI_D_ERROR, "Spurious GIC interrupt: 0x%x\n", GicInterrupt));
-  }
-
-  EndOfInterrupt (&gHardwareInterruptProtocol, GicInterrupt);
-}
-
-//
-// Making this global saves a few bytes in image size
-//
-EFI_HANDLE  gHardwareInterruptHandle = NULL;
-
-//
-// The protocol instance produced by this driver
-//
-EFI_HARDWARE_INTERRUPT_PROTOCOL gHardwareInterruptProtocol = {
-  RegisterInterruptSource,
-  EnableInterruptSource,
-  DisableInterruptSource,
-  GetInterruptSourceState,
-  EndOfInterrupt
-};
-
-/**
-  Shutdown our hardware
-  
-  DXE Core will disable interrupts and turn off the timer and disable interrupts
-  after all the event handlers have run.
-
-  @param[in]  Event   The Event that is being processed
-  @param[in]  Context Event Context
-**/
-VOID
-EFIAPI
-ExitBootServicesEvent (
-  IN EFI_EVENT  Event,
-  IN VOID       *Context
-  )
-{
-  UINTN    Index;
-  
-  // Acknowledge all pending interrupts
-  for (Index = 0; Index < mGicNumInterrupts; Index++) {
-    DisableInterruptSource (&gHardwareInterruptProtocol, Index);
-  }
-
-  for (Index = 0; Index < mGicNumInterrupts; Index++) {
-    EndOfInterrupt (&gHardwareInterruptProtocol, Index);
-  }
-
-  // Disable Gic Interface
-  MmioWrite32 (PcdGet32(PcdGicInterruptInterfaceBase) + ARM_GIC_ICCICR, 0x0);
-  MmioWrite32 (PcdGet32(PcdGicInterruptInterfaceBase) + ARM_GIC_ICCPMR, 0x0);
-
-  // Disable Gic Distributor
-  MmioWrite32 (PcdGet32(PcdGicDistributorBase) + ARM_GIC_ICDDCR, 0x0);
-}
-
-/**
-  Initialize the state information for the CPU Architectural Protocol
-
-  @param  ImageHandle   of the loaded driver
-  @param  SystemTable   Pointer to the System Table
-
-  @retval EFI_SUCCESS           Protocol registered
-  @retval EFI_OUT_OF_RESOURCES  Cannot allocate protocol data structure
-  @retval EFI_DEVICE_ERROR      Hardware problems
-
-**/
-EFI_STATUS
-InterruptDxeInitialize (
-  IN EFI_HANDLE         ImageHandle,
-  IN EFI_SYSTEM_TABLE   *SystemTable
-  )
-{
-  EFI_STATUS              Status;
-  UINTN                   Index;
-  UINT32                  RegOffset;
-  UINTN                   RegShift;
-  EFI_CPU_ARCH_PROTOCOL   *Cpu;
-  UINT32                  CpuTarget;
-  
-  // Check PcdGicPrimaryCoreId has been set in case the Primary Core is not the core 0 of Cluster 0
-  DEBUG_CODE_BEGIN();
-  if ((PcdGet32(PcdArmPrimaryCore) != 0) && (PcdGet32 (PcdGicPrimaryCoreId) == 0)) {
-    DEBUG((EFI_D_WARN,"Warning: the PCD PcdGicPrimaryCoreId does not seem to be set up for the configuration.\n"));
-  }
-  DEBUG_CODE_END();
-
-  // Make sure the Interrupt Controller Protocol is not already installed in the system.
-  ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL, &gHardwareInterruptProtocolGuid);
-
-  mGicNumInterrupts = ArmGicGetMaxNumInterrupts (PcdGet32(PcdGicDistributorBase));
-
-  for (Index = 0; Index < mGicNumInterrupts; Index++) {
-    DisableInterruptSource (&gHardwareInterruptProtocol, Index);
-    
-    // Set Priority 
-    RegOffset = Index / 4;
-    RegShift = (Index % 4) * 8;
-    MmioAndThenOr32 (
-      PcdGet32(PcdGicDistributorBase) + ARM_GIC_ICDIPR + (4*RegOffset),
-      ~(0xff << RegShift), 
-      ARM_GIC_DEFAULT_PRIORITY << RegShift
-      );
-  }
-
-  // Configure interrupts for Primary Cpu
-  CpuTarget = (1 << PcdGet32 (PcdGicPrimaryCoreId));
-  CpuTarget |= (CpuTarget << 24) | (CpuTarget << 16) | (CpuTarget << 8);
-  for (Index = 0; Index < (mGicNumInterrupts / 4); Index++) {
-    MmioWrite32 (PcdGet32(PcdGicDistributorBase) + ARM_GIC_ICDIPTR + (Index*4), CpuTarget);
-  }
-
-  // Set binary point reg to 0x7 (no preemption)
-  MmioWrite32 (PcdGet32(PcdGicInterruptInterfaceBase) + ARM_GIC_ICCBPR, 0x7);
-
-  // Set priority mask reg to 0xff to allow all priorities through
-  MmioWrite32 (PcdGet32(PcdGicInterruptInterfaceBase) + ARM_GIC_ICCPMR, 0xff);
-  
-  // Enable gic cpu interface
-  MmioWrite32 (PcdGet32(PcdGicInterruptInterfaceBase) + ARM_GIC_ICCICR, 0x1);
-
-  // Enable gic distributor
-  MmioWrite32 (PcdGet32(PcdGicDistributorBase) + ARM_GIC_ICDDCR, 0x1);
-  
-  // Initialize the array for the Interrupt Handlers
-  gRegisteredInterruptHandlers = (HARDWARE_INTERRUPT_HANDLER*)AllocateZeroPool (sizeof(HARDWARE_INTERRUPT_HANDLER) * mGicNumInterrupts);
-  
-  Status = gBS->InstallMultipleProtocolInterfaces (
-                  &gHardwareInterruptHandle,
-                  &gHardwareInterruptProtocolGuid,   &gHardwareInterruptProtocol,
-                  NULL
-                  );
-  ASSERT_EFI_ERROR (Status);
-  
-  //
-  // Get the CPU protocol that this driver requires.
-  //
-  Status = gBS->LocateProtocol(&gEfiCpuArchProtocolGuid, NULL, (VOID **)&Cpu);
-  ASSERT_EFI_ERROR(Status);
-
-  //
-  // Unregister the default exception handler.
-  //
-  Status = Cpu->RegisterInterruptHandler(Cpu, EXCEPT_ARM_IRQ, NULL);
-  ASSERT_EFI_ERROR(Status);
-
-  //
-  // Register to receive interrupts
-  //
-  Status = Cpu->RegisterInterruptHandler(Cpu, EXCEPT_ARM_IRQ, IrqInterruptHandler);
-  ASSERT_EFI_ERROR(Status);
-
-  // Register for an ExitBootServicesEvent
-  Status = gBS->CreateEvent (EVT_SIGNAL_EXIT_BOOT_SERVICES, TPL_NOTIFY, ExitBootServicesEvent, NULL, &EfiExitBootServicesEvent);
-  ASSERT_EFI_ERROR (Status);
-
-  return Status;
-}
+/*++

+

+Copyright (c) 2009, Hewlett-Packard Company. All rights reserved.<BR>

+Portions copyright (c) 2010, Apple Inc. All rights reserved.<BR>

+Portions copyright (c) 2011-2013, ARM Ltd. All rights reserved.<BR> 

+

+This program and the accompanying materials                          

+are licensed and made available under the terms and conditions of the BSD License         

+which accompanies this distribution.  The full text of the license may be found at        

+http://opensource.org/licenses/bsd-license.php                                            

+                                                                                          

+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.   

+

+Module Name:

+

+  Gic.c

+

+Abstract:

+

+  Driver implementing the GIC interrupt controller protocol

+

+--*/

+

+#include <PiDxe.h>

+

+#include <Library/ArmLib.h>

+#include <Library/BaseLib.h>

+#include <Library/DebugLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/MemoryAllocationLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/UefiLib.h>

+#include <Library/PcdLib.h>

+#include <Library/IoLib.h>

+#include <Library/ArmGicLib.h>

+

+#include <Protocol/Cpu.h>

+#include <Protocol/HardwareInterrupt.h>

+

+#define ARM_GIC_DEFAULT_PRIORITY  0x80

+

+extern EFI_HARDWARE_INTERRUPT_PROTOCOL gHardwareInterruptProtocol;

+

+//

+// Notifications

+//

+EFI_EVENT EfiExitBootServicesEvent      = (EFI_EVENT)NULL;

+

+// Maximum Number of Interrupts

+UINTN mGicNumInterrupts                 = 0;

+

+HARDWARE_INTERRUPT_HANDLER  *gRegisteredInterruptHandlers = NULL;

+

+/**

+  Register Handler for the specified interrupt source.

+

+  @param This     Instance pointer for this protocol

+  @param Source   Hardware source of the interrupt

+  @param Handler  Callback for interrupt. NULL to unregister

+

+  @retval EFI_SUCCESS Source was updated to support Handler.

+  @retval EFI_DEVICE_ERROR  Hardware could not be programmed.

+

+**/

+EFI_STATUS

+EFIAPI

+RegisterInterruptSource (

+  IN EFI_HARDWARE_INTERRUPT_PROTOCOL    *This,

+  IN HARDWARE_INTERRUPT_SOURCE          Source,

+  IN HARDWARE_INTERRUPT_HANDLER         Handler

+  )

+{

+  if (Source > mGicNumInterrupts) {

+    ASSERT(FALSE);

+    return EFI_UNSUPPORTED;

+  }

+  

+  if ((Handler == NULL) && (gRegisteredInterruptHandlers[Source] == NULL)) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  if ((Handler != NULL) && (gRegisteredInterruptHandlers[Source] != NULL)) {

+    return EFI_ALREADY_STARTED;

+  }

+

+  gRegisteredInterruptHandlers[Source] = Handler;

+

+  // If the interrupt handler is unregistered then disable the interrupt

+  if (NULL == Handler){

+  	return This->DisableInterruptSource (This, Source);

+  } else {

+  	return This->EnableInterruptSource (This, Source);

+  }

+}

+

+/**

+  Enable interrupt source Source.

+

+  @param This     Instance pointer for this protocol

+  @param Source   Hardware source of the interrupt

+

+  @retval EFI_SUCCESS       Source interrupt enabled.

+  @retval EFI_DEVICE_ERROR  Hardware could not be programmed.

+

+**/

+EFI_STATUS

+EFIAPI

+EnableInterruptSource (

+  IN EFI_HARDWARE_INTERRUPT_PROTOCOL    *This,

+  IN HARDWARE_INTERRUPT_SOURCE          Source

+  )

+{

+  UINT32    RegOffset;

+  UINTN     RegShift;

+  

+  if (Source > mGicNumInterrupts) {

+    ASSERT(FALSE);

+    return EFI_UNSUPPORTED;

+  }

+  

+  // Calculate enable register offset and bit position

+  RegOffset = Source / 32;

+  RegShift = Source % 32;

+

+  // Write set-enable register

+  MmioWrite32 (PcdGet32(PcdGicDistributorBase) + ARM_GIC_ICDISER + (4*RegOffset), 1 << RegShift);

+  

+  return EFI_SUCCESS;

+}

+

+/**

+  Disable interrupt source Source.

+

+  @param This     Instance pointer for this protocol

+  @param Source   Hardware source of the interrupt

+

+  @retval EFI_SUCCESS       Source interrupt disabled.

+  @retval EFI_DEVICE_ERROR  Hardware could not be programmed.

+

+**/

+EFI_STATUS

+EFIAPI

+DisableInterruptSource (

+  IN EFI_HARDWARE_INTERRUPT_PROTOCOL    *This,

+  IN HARDWARE_INTERRUPT_SOURCE          Source

+  )

+{

+  UINT32    RegOffset;

+  UINTN     RegShift;

+  

+  if (Source > mGicNumInterrupts) {

+    ASSERT(FALSE);

+    return EFI_UNSUPPORTED;

+  }

+  

+  // Calculate enable register offset and bit position

+  RegOffset = Source / 32;

+  RegShift = Source % 32;

+

+  // Write set-enable register

+  MmioWrite32 (PcdGet32(PcdGicDistributorBase) + ARM_GIC_ICDICER + (4*RegOffset), 1 << RegShift);

+  

+  return EFI_SUCCESS;

+}

+

+/**

+  Return current state of interrupt source Source.

+

+  @param This     Instance pointer for this protocol

+  @param Source   Hardware source of the interrupt

+  @param InterruptState  TRUE: source enabled, FALSE: source disabled.

+

+  @retval EFI_SUCCESS       InterruptState is valid

+  @retval EFI_DEVICE_ERROR  InterruptState is not valid

+

+**/

+EFI_STATUS

+EFIAPI

+GetInterruptSourceState (

+  IN EFI_HARDWARE_INTERRUPT_PROTOCOL    *This,

+  IN HARDWARE_INTERRUPT_SOURCE          Source,

+  IN BOOLEAN                            *InterruptState

+  )

+{

+  UINT32    RegOffset;

+  UINTN     RegShift;

+  

+  if (Source > mGicNumInterrupts) {

+    ASSERT(FALSE);

+    return EFI_UNSUPPORTED;

+  }

+  

+  // calculate enable register offset and bit position

+  RegOffset = Source / 32;

+  RegShift = Source % 32;

+    

+  if ((MmioRead32 (PcdGet32(PcdGicDistributorBase) + ARM_GIC_ICDISER + (4*RegOffset)) & (1<<RegShift)) == 0) {

+    *InterruptState = FALSE;

+  } else {

+    *InterruptState = TRUE;

+  }

+  

+  return EFI_SUCCESS;

+}

+

+/**

+  Signal to the hardware that the End Of Intrrupt state 

+  has been reached.

+

+  @param This     Instance pointer for this protocol

+  @param Source   Hardware source of the interrupt

+

+  @retval EFI_SUCCESS       Source interrupt EOI'ed.

+  @retval EFI_DEVICE_ERROR  Hardware could not be programmed.

+

+**/

+EFI_STATUS

+EFIAPI

+EndOfInterrupt (

+  IN EFI_HARDWARE_INTERRUPT_PROTOCOL    *This,

+  IN HARDWARE_INTERRUPT_SOURCE          Source

+  )

+{

+  if (Source > mGicNumInterrupts) {

+    ASSERT(FALSE);

+    return EFI_UNSUPPORTED;

+  }

+

+  MmioWrite32 (PcdGet32(PcdGicInterruptInterfaceBase) + ARM_GIC_ICCEIOR, Source);

+  return EFI_SUCCESS;

+}

+

+/**

+  EFI_CPU_INTERRUPT_HANDLER that is called when a processor interrupt occurs.

+

+  @param  InterruptType    Defines the type of interrupt or exception that

+                           occurred on the processor.This parameter is processor architecture specific.

+  @param  SystemContext    A pointer to the processor context when

+                           the interrupt occurred on the processor.

+

+  @return None

+

+**/

+VOID

+EFIAPI

+IrqInterruptHandler (

+  IN EFI_EXCEPTION_TYPE           InterruptType,

+  IN EFI_SYSTEM_CONTEXT           SystemContext

+  )

+{

+  UINT32                      GicInterrupt;

+  HARDWARE_INTERRUPT_HANDLER  InterruptHandler;

+

+  GicInterrupt = MmioRead32 (PcdGet32(PcdGicInterruptInterfaceBase) + ARM_GIC_ICCIAR);

+

+  // Special Interrupts (ID1020-ID1023) have an Interrupt ID greater than the number of interrupt (ie: Spurious interrupt).

+  if (GicInterrupt >= mGicNumInterrupts) {

+    // The special interrupt do not need to be acknowledge

+    return;

+  }

+  

+  InterruptHandler = gRegisteredInterruptHandlers[GicInterrupt];

+  if (InterruptHandler != NULL) {

+    // Call the registered interrupt handler.

+    InterruptHandler (GicInterrupt, SystemContext);

+  } else {

+    DEBUG ((EFI_D_ERROR, "Spurious GIC interrupt: 0x%x\n", GicInterrupt));

+  }

+

+  EndOfInterrupt (&gHardwareInterruptProtocol, GicInterrupt);

+}

+

+//

+// Making this global saves a few bytes in image size

+//

+EFI_HANDLE  gHardwareInterruptHandle = NULL;

+

+//

+// The protocol instance produced by this driver

+//

+EFI_HARDWARE_INTERRUPT_PROTOCOL gHardwareInterruptProtocol = {

+  RegisterInterruptSource,

+  EnableInterruptSource,

+  DisableInterruptSource,

+  GetInterruptSourceState,

+  EndOfInterrupt

+};

+

+/**

+  Shutdown our hardware

+  

+  DXE Core will disable interrupts and turn off the timer and disable interrupts

+  after all the event handlers have run.

+

+  @param[in]  Event   The Event that is being processed

+  @param[in]  Context Event Context

+**/

+VOID

+EFIAPI

+ExitBootServicesEvent (

+  IN EFI_EVENT  Event,

+  IN VOID       *Context

+  )

+{

+  UINTN    Index;

+  

+  // Acknowledge all pending interrupts

+  for (Index = 0; Index < mGicNumInterrupts; Index++) {

+    DisableInterruptSource (&gHardwareInterruptProtocol, Index);

+  }

+

+  for (Index = 0; Index < mGicNumInterrupts; Index++) {

+    EndOfInterrupt (&gHardwareInterruptProtocol, Index);

+  }

+

+  // Disable Gic Interface

+  MmioWrite32 (PcdGet32(PcdGicInterruptInterfaceBase) + ARM_GIC_ICCICR, 0x0);

+  MmioWrite32 (PcdGet32(PcdGicInterruptInterfaceBase) + ARM_GIC_ICCPMR, 0x0);

+

+  // Disable Gic Distributor

+  MmioWrite32 (PcdGet32(PcdGicDistributorBase) + ARM_GIC_ICDDCR, 0x0);

+}

+

+/**

+  Initialize the state information for the CPU Architectural Protocol

+

+  @param  ImageHandle   of the loaded driver

+  @param  SystemTable   Pointer to the System Table

+

+  @retval EFI_SUCCESS           Protocol registered

+  @retval EFI_OUT_OF_RESOURCES  Cannot allocate protocol data structure

+  @retval EFI_DEVICE_ERROR      Hardware problems

+

+**/

+EFI_STATUS

+InterruptDxeInitialize (

+  IN EFI_HANDLE         ImageHandle,

+  IN EFI_SYSTEM_TABLE   *SystemTable

+  )

+{

+  EFI_STATUS              Status;

+  UINTN                   Index;

+  UINT32                  RegOffset;

+  UINTN                   RegShift;

+  EFI_CPU_ARCH_PROTOCOL   *Cpu;

+  UINT32                  CpuTarget;

+  

+  // Check PcdGicPrimaryCoreId has been set in case the Primary Core is not the core 0 of Cluster 0

+  DEBUG_CODE_BEGIN();

+  if ((PcdGet32(PcdArmPrimaryCore) != 0) && (PcdGet32 (PcdGicPrimaryCoreId) == 0)) {

+    DEBUG((EFI_D_WARN,"Warning: the PCD PcdGicPrimaryCoreId does not seem to be set up for the configuration.\n"));

+  }

+  DEBUG_CODE_END();

+

+  // Make sure the Interrupt Controller Protocol is not already installed in the system.

+  ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL, &gHardwareInterruptProtocolGuid);

+

+  mGicNumInterrupts = ArmGicGetMaxNumInterrupts (PcdGet32(PcdGicDistributorBase));

+

+  for (Index = 0; Index < mGicNumInterrupts; Index++) {

+    DisableInterruptSource (&gHardwareInterruptProtocol, Index);

+    

+    // Set Priority 

+    RegOffset = Index / 4;

+    RegShift = (Index % 4) * 8;

+    MmioAndThenOr32 (

+      PcdGet32(PcdGicDistributorBase) + ARM_GIC_ICDIPR + (4*RegOffset),

+      ~(0xff << RegShift), 

+      ARM_GIC_DEFAULT_PRIORITY << RegShift

+      );

+  }

+

+  // Configure interrupts for Primary Cpu

+  CpuTarget = (1 << PcdGet32 (PcdGicPrimaryCoreId));

+  CpuTarget |= (CpuTarget << 24) | (CpuTarget << 16) | (CpuTarget << 8);

+  for (Index = 0; Index < (mGicNumInterrupts / 4); Index++) {

+    MmioWrite32 (PcdGet32(PcdGicDistributorBase) + ARM_GIC_ICDIPTR + (Index*4), CpuTarget);

+  }

+

+  // Set binary point reg to 0x7 (no preemption)

+  MmioWrite32 (PcdGet32(PcdGicInterruptInterfaceBase) + ARM_GIC_ICCBPR, 0x7);

+

+  // Set priority mask reg to 0xff to allow all priorities through

+  MmioWrite32 (PcdGet32(PcdGicInterruptInterfaceBase) + ARM_GIC_ICCPMR, 0xff);

+  

+  // Enable gic cpu interface

+  MmioWrite32 (PcdGet32(PcdGicInterruptInterfaceBase) + ARM_GIC_ICCICR, 0x1);

+

+  // Enable gic distributor

+  MmioWrite32 (PcdGet32(PcdGicDistributorBase) + ARM_GIC_ICDDCR, 0x1);

+  

+  // Initialize the array for the Interrupt Handlers

+  gRegisteredInterruptHandlers = (HARDWARE_INTERRUPT_HANDLER*)AllocateZeroPool (sizeof(HARDWARE_INTERRUPT_HANDLER) * mGicNumInterrupts);

+  

+  Status = gBS->InstallMultipleProtocolInterfaces (

+                  &gHardwareInterruptHandle,

+                  &gHardwareInterruptProtocolGuid,   &gHardwareInterruptProtocol,

+                  NULL

+                  );

+  ASSERT_EFI_ERROR (Status);

+  

+  //

+  // Get the CPU protocol that this driver requires.

+  //

+  Status = gBS->LocateProtocol(&gEfiCpuArchProtocolGuid, NULL, (VOID **)&Cpu);

+  ASSERT_EFI_ERROR(Status);

+

+  //

+  // Unregister the default exception handler.

+  //

+  Status = Cpu->RegisterInterruptHandler(Cpu, ARM_ARCH_EXCEPTION_IRQ, NULL);

+  ASSERT_EFI_ERROR(Status);

+

+  //

+  // Register to receive interrupts

+  //

+  Status = Cpu->RegisterInterruptHandler(Cpu, ARM_ARCH_EXCEPTION_IRQ, IrqInterruptHandler);

+  ASSERT_EFI_ERROR(Status);

+

+  // Register for an ExitBootServicesEvent

+  Status = gBS->CreateEvent (EVT_SIGNAL_EXIT_BOOT_SERVICES, TPL_NOTIFY, ExitBootServicesEvent, NULL, &EfiExitBootServicesEvent);

+  ASSERT_EFI_ERROR (Status);

+

+  return Status;

+}

diff --git a/ArmPkg/Drivers/PL390Gic/PL390GicDxe.inf b/ArmPkg/Drivers/PL390Gic/PL390GicDxe.inf
index b63216ee..422fd414 100644
--- a/ArmPkg/Drivers/PL390Gic/PL390GicDxe.inf
+++ b/ArmPkg/Drivers/PL390Gic/PL390GicDxe.inf
@@ -1,57 +1,57 @@
-#/** @file
-#  
-#  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-#  Copyright (c) 2012, ARM Ltd. All rights reserved.<BR>
-#
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = PL390GicDxe
-  FILE_GUID                      = DE371F7C-DEC4-4D21-ADF1-593ABCC15882 
-  MODULE_TYPE                    = DXE_DRIVER
-  VERSION_STRING                 = 1.0
-
-  ENTRY_POINT                    = InterruptDxeInitialize
-
-
-[Sources.common]
-  PL390Gic.c
-  PL390GicDxe.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  EmbeddedPkg/EmbeddedPkg.dec
-  ArmPkg/ArmPkg.dec
-
-[LibraryClasses]
-  BaseLib
-  UefiLib
-  UefiBootServicesTableLib
-  DebugLib
-  PrintLib
-  MemoryAllocationLib
-  UefiDriverEntryPoint
-  IoLib
-
-[Protocols]
-  gHardwareInterruptProtocolGuid
-  gEfiCpuArchProtocolGuid
-  
-[FixedPcd.common]
-  gArmTokenSpaceGuid.PcdGicDistributorBase
-  gArmTokenSpaceGuid.PcdGicInterruptInterfaceBase
-  
-  gArmTokenSpaceGuid.PcdArmPrimaryCore
-  gArmTokenSpaceGuid.PcdGicPrimaryCoreId
-
-[Depex]
-  gEfiCpuArchProtocolGuid
+#/** @file

+#  

+#  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+#  Copyright (c) 2012, ARM Ltd. All rights reserved.<BR>

+#

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = PL390GicDxe

+  FILE_GUID                      = DE371F7C-DEC4-4D21-ADF1-593ABCC15882 

+  MODULE_TYPE                    = DXE_DRIVER

+  VERSION_STRING                 = 1.0

+

+  ENTRY_POINT                    = InterruptDxeInitialize

+

+

+[Sources.common]

+  PL390Gic.c

+  PL390GicDxe.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  EmbeddedPkg/EmbeddedPkg.dec

+  ArmPkg/ArmPkg.dec

+

+[LibraryClasses]

+  BaseLib

+  UefiLib

+  UefiBootServicesTableLib

+  DebugLib

+  PrintLib

+  MemoryAllocationLib

+  UefiDriverEntryPoint

+  IoLib

+

+[Protocols]

+  gHardwareInterruptProtocolGuid

+  gEfiCpuArchProtocolGuid

+  

+[FixedPcd.common]

+  gArmTokenSpaceGuid.PcdGicDistributorBase

+  gArmTokenSpaceGuid.PcdGicInterruptInterfaceBase

+  

+  gArmTokenSpaceGuid.PcdArmPrimaryCore

+  gArmTokenSpaceGuid.PcdGicPrimaryCoreId

+

+[Depex]

+  gEfiCpuArchProtocolGuid

diff --git a/ArmPkg/Drivers/PL390Gic/PL390GicLib.inf b/ArmPkg/Drivers/PL390Gic/PL390GicLib.inf
index 4eb6ffbd..d0cac020 100644
--- a/ArmPkg/Drivers/PL390Gic/PL390GicLib.inf
+++ b/ArmPkg/Drivers/PL390Gic/PL390GicLib.inf
@@ -23,6 +23,9 @@
   PL390Gic.c

   PL390GicNonSec.c

 

+[LibraryClasses]

+  IoLib

+

 [Packages]

   ArmPkg/ArmPkg.dec

   MdePkg/MdePkg.dec

diff --git a/ArmPkg/Drivers/TimerDxe/TimerDxe.c b/ArmPkg/Drivers/TimerDxe/TimerDxe.c
index 50de7668..cbc34e8e 100644
--- a/ArmPkg/Drivers/TimerDxe/TimerDxe.c
+++ b/ArmPkg/Drivers/TimerDxe/TimerDxe.c
@@ -1,380 +1,380 @@
-/** @file
-  Timer Architecture Protocol driver of the ARM flavor
-
-  Copyright (c) 2011 ARM Ltd. All rights reserved.<BR>
-  
-  This program and the accompanying materials                          
-  are licensed and made available under the terms and conditions of the BSD License         
-  which accompanies this distribution.  The full text of the license may be found at        
-  http://opensource.org/licenses/bsd-license.php                                            
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-
-**/
-
-
-#include <PiDxe.h>
-
-#include <Library/ArmLib.h>
-#include <Library/BaseLib.h>
-#include <Library/DebugLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/UefiBootServicesTableLib.h>
-#include <Library/UefiLib.h>
-#include <Library/PcdLib.h>
-#include <Library/IoLib.h>
-#include <Library/ArmV7ArchTimerLib.h>
-
-#include <Protocol/Timer.h>
-#include <Protocol/HardwareInterrupt.h>
-
-// The notification function to call on every timer interrupt.
-EFI_TIMER_NOTIFY      mTimerNotifyFunction     = (EFI_TIMER_NOTIFY)NULL;
-EFI_EVENT             EfiExitBootServicesEvent = (EFI_EVENT)NULL;
-
-// The current period of the timer interrupt
-UINT64 mTimerPeriod = 0;
-
-// Cached copy of the Hardware Interrupt protocol instance
-EFI_HARDWARE_INTERRUPT_PROTOCOL *gInterrupt = NULL;
-
-/**
-  This function registers the handler NotifyFunction so it is called every time 
-  the timer interrupt fires.  It also passes the amount of time since the last 
-  handler call to the NotifyFunction.  If NotifyFunction is NULL, then the 
-  handler is unregistered.  If the handler is registered, then EFI_SUCCESS is 
-  returned.  If the CPU does not support registering a timer interrupt handler, 
-  then EFI_UNSUPPORTED is returned.  If an attempt is made to register a handler 
-  when a handler is already registered, then EFI_ALREADY_STARTED is returned.  
-  If an attempt is made to unregister a handler when a handler is not registered, 
-  then EFI_INVALID_PARAMETER is returned.  If an error occurs attempting to 
-  register the NotifyFunction with the timer interrupt, then EFI_DEVICE_ERROR 
-  is returned.
-
-  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
-  @param  NotifyFunction   The function to call when a timer interrupt fires. This
-                           function executes at TPL_HIGH_LEVEL. The DXE Core will
-                           register a handler for the timer interrupt, so it can know
-                           how much time has passed. This information is used to
-                           signal timer based events. NULL will unregister the handler.
-  @retval EFI_SUCCESS           The timer handler was registered.
-  @retval EFI_UNSUPPORTED       The platform does not support timer interrupts.
-  @retval EFI_ALREADY_STARTED   NotifyFunction is not NULL, and a handler is already
-                                registered.
-  @retval EFI_INVALID_PARAMETER NotifyFunction is NULL, and a handler was not
-                                previously registered.
-  @retval EFI_DEVICE_ERROR      The timer handler could not be registered.
-
-**/
-EFI_STATUS
-EFIAPI
-TimerDriverRegisterHandler (
-  IN EFI_TIMER_ARCH_PROTOCOL  *This,
-  IN EFI_TIMER_NOTIFY         NotifyFunction
-  )
-{
-  if ((NotifyFunction == NULL) && (mTimerNotifyFunction == NULL)) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  if ((NotifyFunction != NULL) && (mTimerNotifyFunction != NULL)) {
-    return EFI_ALREADY_STARTED;
-  }
-
-  mTimerNotifyFunction = NotifyFunction;
-
-  return EFI_SUCCESS;
-}
-
-/**
-    Disable the timer
-**/
-VOID
-EFIAPI
-ExitBootServicesEvent (
-  IN EFI_EVENT  Event,
-  IN VOID       *Context
-  )
-{
-  ArmArchTimerDisableTimer ();
-}
-
-/**
-
-  This function adjusts the period of timer interrupts to the value specified 
-  by TimerPeriod.  If the timer period is updated, then the selected timer 
-  period is stored in EFI_TIMER.TimerPeriod, and EFI_SUCCESS is returned.  If 
-  the timer hardware is not programmable, then EFI_UNSUPPORTED is returned.  
-  If an error occurs while attempting to update the timer period, then the 
-  timer hardware will be put back in its state prior to this call, and 
-  EFI_DEVICE_ERROR is returned.  If TimerPeriod is 0, then the timer interrupt 
-  is disabled.  This is not the same as disabling the CPU's interrupts.  
-  Instead, it must either turn off the timer hardware, or it must adjust the 
-  interrupt controller so that a CPU interrupt is not generated when the timer 
-  interrupt fires. 
-
-  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
-  @param  TimerPeriod      The rate to program the timer interrupt in 100 nS units. If
-                           the timer hardware is not programmable, then EFI_UNSUPPORTED is
-                           returned. If the timer is programmable, then the timer period
-                           will be rounded up to the nearest timer period that is supported
-                           by the timer hardware. If TimerPeriod is set to 0, then the
-                           timer interrupts will be disabled.
-
-
-  @retval EFI_SUCCESS           The timer period was changed.
-  @retval EFI_UNSUPPORTED       The platform cannot change the period of the timer interrupt.
-  @retval EFI_DEVICE_ERROR      The timer period could not be changed due to a device error.
-
-**/
-EFI_STATUS
-EFIAPI
-TimerDriverSetTimerPeriod (
-  IN EFI_TIMER_ARCH_PROTOCOL  *This,
-  IN UINT64                   TimerPeriod
-  )
-{
-  UINT64      TimerTicks;
-  
-  // Always disable the timer
-  ArmArchTimerDisableTimer ();
-
-  if (TimerPeriod != 0) {
-    // Convert TimerPeriod to micro sec units
-    TimerTicks = DivU64x32 (TimerPeriod, 10);
-
-    TimerTicks = MultU64x32 (TimerTicks, (PcdGet32(PcdArmArchTimerFreqInHz)/1000000));
-
-    ArmArchTimerSetTimerVal((UINTN)TimerTicks);
-
-    // Enable the timer
-    ArmArchTimerEnableTimer ();
-  }
-
-  // Save the new timer period
-  mTimerPeriod = TimerPeriod;
-  return EFI_SUCCESS;
-}
-
-/**
-  This function retrieves the period of timer interrupts in 100 ns units, 
-  returns that value in TimerPeriod, and returns EFI_SUCCESS.  If TimerPeriod 
-  is NULL, then EFI_INVALID_PARAMETER is returned.  If a TimerPeriod of 0 is 
-  returned, then the timer is currently disabled.
-
-  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
-  @param  TimerPeriod      A pointer to the timer period to retrieve in 100 ns units. If
-                           0 is returned, then the timer is currently disabled.
-
-
-  @retval EFI_SUCCESS           The timer period was returned in TimerPeriod.
-  @retval EFI_INVALID_PARAMETER TimerPeriod is NULL.
-
-**/
-EFI_STATUS
-EFIAPI
-TimerDriverGetTimerPeriod (
-  IN EFI_TIMER_ARCH_PROTOCOL   *This,
-  OUT UINT64                   *TimerPeriod
-  )
-{
-  if (TimerPeriod == NULL) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  *TimerPeriod = mTimerPeriod;
-  return EFI_SUCCESS;
-}
-
-/**
-  This function generates a soft timer interrupt. If the platform does not support soft 
-  timer interrupts, then EFI_UNSUPPORTED is returned. Otherwise, EFI_SUCCESS is returned. 
-  If a handler has been registered through the EFI_TIMER_ARCH_PROTOCOL.RegisterHandler() 
-  service, then a soft timer interrupt will be generated. If the timer interrupt is 
-  enabled when this service is called, then the registered handler will be invoked. The 
-  registered handler should not be able to distinguish a hardware-generated timer 
-  interrupt from a software-generated timer interrupt.
-
-  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
-
-  @retval EFI_SUCCESS           The soft timer interrupt was generated.
-  @retval EFI_UNSUPPORTED       The platform does not support the generation of soft timer interrupts.
-
-**/
-EFI_STATUS
-EFIAPI
-TimerDriverGenerateSoftInterrupt (
-  IN EFI_TIMER_ARCH_PROTOCOL  *This
-  )
-{
-  return EFI_UNSUPPORTED;
-}
-
-/**
-  Interface structure for the Timer Architectural Protocol.
-
-  @par Protocol Description:
-  This protocol provides the services to initialize a periodic timer
-  interrupt, and to register a handler that is called each time the timer
-  interrupt fires.  It may also provide a service to adjust the rate of the
-  periodic timer interrupt.  When a timer interrupt occurs, the handler is
-  passed the amount of time that has passed since the previous timer
-  interrupt.
-
-  @param RegisterHandler
-  Registers a handler that will be called each time the
-  timer interrupt fires.  TimerPeriod defines the minimum
-  time between timer interrupts, so TimerPeriod will also
-  be the minimum time between calls to the registered
-  handler.
-
-  @param SetTimerPeriod
-  Sets the period of the timer interrupt in 100 nS units.
-  This function is optional, and may return EFI_UNSUPPORTED.
-  If this function is supported, then the timer period will
-  be rounded up to the nearest supported timer period.
-
-
-  @param GetTimerPeriod
-  Retrieves the period of the timer interrupt in 100 nS units.
-
-  @param GenerateSoftInterrupt
-  Generates a soft timer interrupt that simulates the firing of
-  the timer interrupt. This service can be used to invoke the   registered handler if the timer interrupt has been masked for
-  a period of time.
-
-**/
-EFI_TIMER_ARCH_PROTOCOL   gTimer = {
-  TimerDriverRegisterHandler,
-  TimerDriverSetTimerPeriod,
-  TimerDriverGetTimerPeriod,
-  TimerDriverGenerateSoftInterrupt
-};
-
-/**
-
-  C Interrupt Handler called in the interrupt context when Source interrupt is active.
-
-
-  @param Source         Source of the interrupt. Hardware routing off a specific platform defines
-                        what source means.
-
-  @param SystemContext  Pointer to system register context. Mostly used by debuggers and will
-                        update the system context after the return from the interrupt if
-                        modified. Don't change these values unless you know what you are doing
-
-**/
-VOID
-EFIAPI
-TimerInterruptHandler (
-  IN  HARDWARE_INTERRUPT_SOURCE   Source,
-  IN  EFI_SYSTEM_CONTEXT          SystemContext
-  )
-{
-  EFI_TPL      OriginalTPL;
-
-  //
-  // DXE core uses this callback for the EFI timer tick. The DXE core uses locks
-  // that raise to TPL_HIGH and then restore back to current level. Thus we need
-  // to make sure TPL level is set to TPL_HIGH while we are handling the timer tick.
-  //
-  OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);
-
-  // Check if the timer interrupt is active
-  if ((ArmArchTimerGetTimerCtrlReg () ) & ARM_ARCH_TIMER_ISTATUS) {
-
-    // Signal end of interrupt early to help avoid losing subsequent ticks from long duration handlers
-    gInterrupt->EndOfInterrupt (gInterrupt, Source);
-
-    if (mTimerNotifyFunction) {
-      mTimerNotifyFunction (mTimerPeriod);
-    }
-
-    // Reload the Timer
-    TimerDriverSetTimerPeriod (&gTimer, FixedPcdGet32(PcdTimerPeriod));
-  }
-
-  // Enable timer interrupts
-  gInterrupt->EnableInterruptSource (gInterrupt, Source);
-
-  gBS->RestoreTPL (OriginalTPL);
-}
-
-
-/**
-  Initialize the state information for the Timer Architectural Protocol and
-  the Timer Debug support protocol that allows the debugger to break into a
-  running program.
-
-  @param  ImageHandle   of the loaded driver
-  @param  SystemTable   Pointer to the System Table
-
-  @retval EFI_SUCCESS           Protocol registered
-  @retval EFI_OUT_OF_RESOURCES  Cannot allocate protocol data structure
-  @retval EFI_DEVICE_ERROR      Hardware problems
-
-**/
-EFI_STATUS
-EFIAPI
-TimerInitialize (
-  IN EFI_HANDLE         ImageHandle,
-  IN EFI_SYSTEM_TABLE   *SystemTable
-  )
-{
-  EFI_HANDLE  Handle = NULL;
-  EFI_STATUS  Status;
-  UINTN TimerCtrlReg;
-
-  if (ArmIsArchTimerImplemented () == 0) {
-    DEBUG ((EFI_D_ERROR, "ARM Architectural Timer is not available in the CPU, hence cann't use this Driver \n"));
-    ASSERT (0);
-  }
-
-  // Find the interrupt controller protocol.  ASSERT if not found.
-  Status = gBS->LocateProtocol (&gHardwareInterruptProtocolGuid, NULL, (VOID **)&gInterrupt);
-  ASSERT_EFI_ERROR (Status);
-
-  // Disable the timer
-  Status = TimerDriverSetTimerPeriod (&gTimer, 0);
-  ASSERT_EFI_ERROR (Status);
-
-  // Install secure and Non-secure interrupt handlers
-  // Note: Because it is not possible to determine the security state of the
-  // CPU dynamically, we just install interrupt handler for both sec and non-sec
-  // timer PPI
-  Status = gInterrupt->RegisterInterruptSource (gInterrupt, PcdGet32 (PcdArmArchTimerSecIntrNum), TimerInterruptHandler);
-  ASSERT_EFI_ERROR (Status);
-
-  Status = gInterrupt->RegisterInterruptSource (gInterrupt, PcdGet32 (PcdArmArchTimerIntrNum), TimerInterruptHandler);
-  ASSERT_EFI_ERROR (Status);
-
-  // Unmask timer interrupts
-  TimerCtrlReg = ArmArchTimerGetTimerCtrlReg ();
-  TimerCtrlReg &= ~ARM_ARCH_TIMER_IMASK;
-  ArmArchTimerSetTimerCtrlReg (TimerCtrlReg);
-
-  // Set up default timer
-  Status = TimerDriverSetTimerPeriod (&gTimer, FixedPcdGet32(PcdTimerPeriod)); // TIMER_DEFAULT_PERIOD
-  ASSERT_EFI_ERROR (Status);
-
-  // Install the Timer Architectural Protocol onto a new handle
-  Status = gBS->InstallMultipleProtocolInterfaces(
-                  &Handle,
-                  &gEfiTimerArchProtocolGuid,      &gTimer,
-                  NULL
-                  );
-  ASSERT_EFI_ERROR(Status);
-
-  // enable Secure timer interrupts
-  Status = gInterrupt->EnableInterruptSource (gInterrupt, PcdGet32 (PcdArmArchTimerSecIntrNum));
-
-  // enable NonSecure timer interrupts
-  Status = gInterrupt->EnableInterruptSource (gInterrupt, PcdGet32 (PcdArmArchTimerIntrNum));
-
-  // Register for an ExitBootServicesEvent
-  Status = gBS->CreateEvent (EVT_SIGNAL_EXIT_BOOT_SERVICES, TPL_NOTIFY, ExitBootServicesEvent, NULL, &EfiExitBootServicesEvent);
-  ASSERT_EFI_ERROR (Status);
-
-  return Status;
-}
+/** @file

+  Timer Architecture Protocol driver of the ARM flavor

+

+  Copyright (c) 2011 ARM Ltd. All rights reserved.<BR>

+  

+  This program and the accompanying materials                          

+  are licensed and made available under the terms and conditions of the BSD License         

+  which accompanies this distribution.  The full text of the license may be found at        

+  http://opensource.org/licenses/bsd-license.php                                            

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+

+**/

+

+

+#include <PiDxe.h>

+

+#include <Library/ArmLib.h>

+#include <Library/BaseLib.h>

+#include <Library/DebugLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/UefiLib.h>

+#include <Library/PcdLib.h>

+#include <Library/IoLib.h>

+#include <Library/ArmV7ArchTimerLib.h>

+

+#include <Protocol/Timer.h>

+#include <Protocol/HardwareInterrupt.h>

+

+// The notification function to call on every timer interrupt.

+EFI_TIMER_NOTIFY      mTimerNotifyFunction     = (EFI_TIMER_NOTIFY)NULL;

+EFI_EVENT             EfiExitBootServicesEvent = (EFI_EVENT)NULL;

+

+// The current period of the timer interrupt

+UINT64 mTimerPeriod = 0;

+

+// Cached copy of the Hardware Interrupt protocol instance

+EFI_HARDWARE_INTERRUPT_PROTOCOL *gInterrupt = NULL;

+

+/**

+  This function registers the handler NotifyFunction so it is called every time 

+  the timer interrupt fires.  It also passes the amount of time since the last 

+  handler call to the NotifyFunction.  If NotifyFunction is NULL, then the 

+  handler is unregistered.  If the handler is registered, then EFI_SUCCESS is 

+  returned.  If the CPU does not support registering a timer interrupt handler, 

+  then EFI_UNSUPPORTED is returned.  If an attempt is made to register a handler 

+  when a handler is already registered, then EFI_ALREADY_STARTED is returned.  

+  If an attempt is made to unregister a handler when a handler is not registered, 

+  then EFI_INVALID_PARAMETER is returned.  If an error occurs attempting to 

+  register the NotifyFunction with the timer interrupt, then EFI_DEVICE_ERROR 

+  is returned.

+

+  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.

+  @param  NotifyFunction   The function to call when a timer interrupt fires. This

+                           function executes at TPL_HIGH_LEVEL. The DXE Core will

+                           register a handler for the timer interrupt, so it can know

+                           how much time has passed. This information is used to

+                           signal timer based events. NULL will unregister the handler.

+  @retval EFI_SUCCESS           The timer handler was registered.

+  @retval EFI_UNSUPPORTED       The platform does not support timer interrupts.

+  @retval EFI_ALREADY_STARTED   NotifyFunction is not NULL, and a handler is already

+                                registered.

+  @retval EFI_INVALID_PARAMETER NotifyFunction is NULL, and a handler was not

+                                previously registered.

+  @retval EFI_DEVICE_ERROR      The timer handler could not be registered.

+

+**/

+EFI_STATUS

+EFIAPI

+TimerDriverRegisterHandler (

+  IN EFI_TIMER_ARCH_PROTOCOL  *This,

+  IN EFI_TIMER_NOTIFY         NotifyFunction

+  )

+{

+  if ((NotifyFunction == NULL) && (mTimerNotifyFunction == NULL)) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  if ((NotifyFunction != NULL) && (mTimerNotifyFunction != NULL)) {

+    return EFI_ALREADY_STARTED;

+  }

+

+  mTimerNotifyFunction = NotifyFunction;

+

+  return EFI_SUCCESS;

+}

+

+/**

+    Disable the timer

+**/

+VOID

+EFIAPI

+ExitBootServicesEvent (

+  IN EFI_EVENT  Event,

+  IN VOID       *Context

+  )

+{

+  ArmArchTimerDisableTimer ();

+}

+

+/**

+

+  This function adjusts the period of timer interrupts to the value specified 

+  by TimerPeriod.  If the timer period is updated, then the selected timer 

+  period is stored in EFI_TIMER.TimerPeriod, and EFI_SUCCESS is returned.  If 

+  the timer hardware is not programmable, then EFI_UNSUPPORTED is returned.  

+  If an error occurs while attempting to update the timer period, then the 

+  timer hardware will be put back in its state prior to this call, and 

+  EFI_DEVICE_ERROR is returned.  If TimerPeriod is 0, then the timer interrupt 

+  is disabled.  This is not the same as disabling the CPU's interrupts.  

+  Instead, it must either turn off the timer hardware, or it must adjust the 

+  interrupt controller so that a CPU interrupt is not generated when the timer 

+  interrupt fires. 

+

+  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.

+  @param  TimerPeriod      The rate to program the timer interrupt in 100 nS units. If

+                           the timer hardware is not programmable, then EFI_UNSUPPORTED is

+                           returned. If the timer is programmable, then the timer period

+                           will be rounded up to the nearest timer period that is supported

+                           by the timer hardware. If TimerPeriod is set to 0, then the

+                           timer interrupts will be disabled.

+

+

+  @retval EFI_SUCCESS           The timer period was changed.

+  @retval EFI_UNSUPPORTED       The platform cannot change the period of the timer interrupt.

+  @retval EFI_DEVICE_ERROR      The timer period could not be changed due to a device error.

+

+**/

+EFI_STATUS

+EFIAPI

+TimerDriverSetTimerPeriod (

+  IN EFI_TIMER_ARCH_PROTOCOL  *This,

+  IN UINT64                   TimerPeriod

+  )

+{

+  UINT64      TimerTicks;

+  

+  // Always disable the timer

+  ArmArchTimerDisableTimer ();

+

+  if (TimerPeriod != 0) {

+    // Convert TimerPeriod to micro sec units

+    TimerTicks = DivU64x32 (TimerPeriod, 10);

+

+    TimerTicks = MultU64x32 (TimerTicks, (PcdGet32(PcdArmArchTimerFreqInHz)/1000000));

+

+    ArmArchTimerSetTimerVal((UINTN)TimerTicks);

+

+    // Enable the timer

+    ArmArchTimerEnableTimer ();

+  }

+

+  // Save the new timer period

+  mTimerPeriod = TimerPeriod;

+  return EFI_SUCCESS;

+}

+

+/**

+  This function retrieves the period of timer interrupts in 100 ns units, 

+  returns that value in TimerPeriod, and returns EFI_SUCCESS.  If TimerPeriod 

+  is NULL, then EFI_INVALID_PARAMETER is returned.  If a TimerPeriod of 0 is 

+  returned, then the timer is currently disabled.

+

+  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.

+  @param  TimerPeriod      A pointer to the timer period to retrieve in 100 ns units. If

+                           0 is returned, then the timer is currently disabled.

+

+

+  @retval EFI_SUCCESS           The timer period was returned in TimerPeriod.

+  @retval EFI_INVALID_PARAMETER TimerPeriod is NULL.

+

+**/

+EFI_STATUS

+EFIAPI

+TimerDriverGetTimerPeriod (

+  IN EFI_TIMER_ARCH_PROTOCOL   *This,

+  OUT UINT64                   *TimerPeriod

+  )

+{

+  if (TimerPeriod == NULL) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  *TimerPeriod = mTimerPeriod;

+  return EFI_SUCCESS;

+}

+

+/**

+  This function generates a soft timer interrupt. If the platform does not support soft 

+  timer interrupts, then EFI_UNSUPPORTED is returned. Otherwise, EFI_SUCCESS is returned. 

+  If a handler has been registered through the EFI_TIMER_ARCH_PROTOCOL.RegisterHandler() 

+  service, then a soft timer interrupt will be generated. If the timer interrupt is 

+  enabled when this service is called, then the registered handler will be invoked. The 

+  registered handler should not be able to distinguish a hardware-generated timer 

+  interrupt from a software-generated timer interrupt.

+

+  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.

+

+  @retval EFI_SUCCESS           The soft timer interrupt was generated.

+  @retval EFI_UNSUPPORTED       The platform does not support the generation of soft timer interrupts.

+

+**/

+EFI_STATUS

+EFIAPI

+TimerDriverGenerateSoftInterrupt (

+  IN EFI_TIMER_ARCH_PROTOCOL  *This

+  )

+{

+  return EFI_UNSUPPORTED;

+}

+

+/**

+  Interface structure for the Timer Architectural Protocol.

+

+  @par Protocol Description:

+  This protocol provides the services to initialize a periodic timer

+  interrupt, and to register a handler that is called each time the timer

+  interrupt fires.  It may also provide a service to adjust the rate of the

+  periodic timer interrupt.  When a timer interrupt occurs, the handler is

+  passed the amount of time that has passed since the previous timer

+  interrupt.

+

+  @param RegisterHandler

+  Registers a handler that will be called each time the

+  timer interrupt fires.  TimerPeriod defines the minimum

+  time between timer interrupts, so TimerPeriod will also

+  be the minimum time between calls to the registered

+  handler.

+

+  @param SetTimerPeriod

+  Sets the period of the timer interrupt in 100 nS units.

+  This function is optional, and may return EFI_UNSUPPORTED.

+  If this function is supported, then the timer period will

+  be rounded up to the nearest supported timer period.

+

+

+  @param GetTimerPeriod

+  Retrieves the period of the timer interrupt in 100 nS units.

+

+  @param GenerateSoftInterrupt

+  Generates a soft timer interrupt that simulates the firing of

+  the timer interrupt. This service can be used to invoke the   registered handler if the timer interrupt has been masked for

+  a period of time.

+

+**/

+EFI_TIMER_ARCH_PROTOCOL   gTimer = {

+  TimerDriverRegisterHandler,

+  TimerDriverSetTimerPeriod,

+  TimerDriverGetTimerPeriod,

+  TimerDriverGenerateSoftInterrupt

+};

+

+/**

+

+  C Interrupt Handler called in the interrupt context when Source interrupt is active.

+

+

+  @param Source         Source of the interrupt. Hardware routing off a specific platform defines

+                        what source means.

+

+  @param SystemContext  Pointer to system register context. Mostly used by debuggers and will

+                        update the system context after the return from the interrupt if

+                        modified. Don't change these values unless you know what you are doing

+

+**/

+VOID

+EFIAPI

+TimerInterruptHandler (

+  IN  HARDWARE_INTERRUPT_SOURCE   Source,

+  IN  EFI_SYSTEM_CONTEXT          SystemContext

+  )

+{

+  EFI_TPL      OriginalTPL;

+

+  //

+  // DXE core uses this callback for the EFI timer tick. The DXE core uses locks

+  // that raise to TPL_HIGH and then restore back to current level. Thus we need

+  // to make sure TPL level is set to TPL_HIGH while we are handling the timer tick.

+  //

+  OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);

+

+  // Check if the timer interrupt is active

+  if ((ArmArchTimerGetTimerCtrlReg () ) & ARM_ARCH_TIMER_ISTATUS) {

+

+    // Signal end of interrupt early to help avoid losing subsequent ticks from long duration handlers

+    gInterrupt->EndOfInterrupt (gInterrupt, Source);

+

+    if (mTimerNotifyFunction) {

+      mTimerNotifyFunction (mTimerPeriod);

+    }

+

+    // Reload the Timer

+    TimerDriverSetTimerPeriod (&gTimer, FixedPcdGet32(PcdTimerPeriod));

+  }

+

+  // Enable timer interrupts

+  gInterrupt->EnableInterruptSource (gInterrupt, Source);

+

+  gBS->RestoreTPL (OriginalTPL);

+}

+

+

+/**

+  Initialize the state information for the Timer Architectural Protocol and

+  the Timer Debug support protocol that allows the debugger to break into a

+  running program.

+

+  @param  ImageHandle   of the loaded driver

+  @param  SystemTable   Pointer to the System Table

+

+  @retval EFI_SUCCESS           Protocol registered

+  @retval EFI_OUT_OF_RESOURCES  Cannot allocate protocol data structure

+  @retval EFI_DEVICE_ERROR      Hardware problems

+

+**/

+EFI_STATUS

+EFIAPI

+TimerInitialize (

+  IN EFI_HANDLE         ImageHandle,

+  IN EFI_SYSTEM_TABLE   *SystemTable

+  )

+{

+  EFI_HANDLE  Handle = NULL;

+  EFI_STATUS  Status;

+  UINTN TimerCtrlReg;

+

+  if (ArmIsArchTimerImplemented () == 0) {

+    DEBUG ((EFI_D_ERROR, "ARM Architectural Timer is not available in the CPU, hence cann't use this Driver \n"));

+    ASSERT (0);

+  }

+

+  // Find the interrupt controller protocol.  ASSERT if not found.

+  Status = gBS->LocateProtocol (&gHardwareInterruptProtocolGuid, NULL, (VOID **)&gInterrupt);

+  ASSERT_EFI_ERROR (Status);

+

+  // Disable the timer

+  Status = TimerDriverSetTimerPeriod (&gTimer, 0);

+  ASSERT_EFI_ERROR (Status);

+

+  // Install secure and Non-secure interrupt handlers

+  // Note: Because it is not possible to determine the security state of the

+  // CPU dynamically, we just install interrupt handler for both sec and non-sec

+  // timer PPI

+  Status = gInterrupt->RegisterInterruptSource (gInterrupt, PcdGet32 (PcdArmArchTimerSecIntrNum), TimerInterruptHandler);

+  ASSERT_EFI_ERROR (Status);

+

+  Status = gInterrupt->RegisterInterruptSource (gInterrupt, PcdGet32 (PcdArmArchTimerIntrNum), TimerInterruptHandler);

+  ASSERT_EFI_ERROR (Status);

+

+  // Unmask timer interrupts

+  TimerCtrlReg = ArmArchTimerGetTimerCtrlReg ();

+  TimerCtrlReg &= ~ARM_ARCH_TIMER_IMASK;

+  ArmArchTimerSetTimerCtrlReg (TimerCtrlReg);

+

+  // Set up default timer

+  Status = TimerDriverSetTimerPeriod (&gTimer, FixedPcdGet32(PcdTimerPeriod)); // TIMER_DEFAULT_PERIOD

+  ASSERT_EFI_ERROR (Status);

+

+  // Install the Timer Architectural Protocol onto a new handle

+  Status = gBS->InstallMultipleProtocolInterfaces(

+                  &Handle,

+                  &gEfiTimerArchProtocolGuid,      &gTimer,

+                  NULL

+                  );

+  ASSERT_EFI_ERROR(Status);

+

+  // enable Secure timer interrupts

+  Status = gInterrupt->EnableInterruptSource (gInterrupt, PcdGet32 (PcdArmArchTimerSecIntrNum));

+

+  // enable NonSecure timer interrupts

+  Status = gInterrupt->EnableInterruptSource (gInterrupt, PcdGet32 (PcdArmArchTimerIntrNum));

+

+  // Register for an ExitBootServicesEvent

+  Status = gBS->CreateEvent (EVT_SIGNAL_EXIT_BOOT_SERVICES, TPL_NOTIFY, ExitBootServicesEvent, NULL, &EfiExitBootServicesEvent);

+  ASSERT_EFI_ERROR (Status);

+

+  return Status;

+}

diff --git a/ArmPkg/Drivers/TimerDxe/TimerDxe.inf b/ArmPkg/Drivers/TimerDxe/TimerDxe.inf
index 4fe2e2f0..061fcbc6 100644
--- a/ArmPkg/Drivers/TimerDxe/TimerDxe.inf
+++ b/ArmPkg/Drivers/TimerDxe/TimerDxe.inf
@@ -1,59 +1,59 @@
-#/** @file
-#  
-#    Component description file for Timer DXE module
-#  
-#  Copyright (c) 2009 - 2010, Apple Inc. All rights reserved.<BR>
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = ArmTimerDxe
-  FILE_GUID                      = 49ea041e-6752-42ca-b0b1-7344fe2546b7 
-  MODULE_TYPE                    = DXE_DRIVER
-  VERSION_STRING                 = 1.0
-
-  ENTRY_POINT                    = TimerInitialize
-
-[Sources.common]
-  TimerDxe.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  EmbeddedPkg/EmbeddedPkg.dec
-  ArmPkg/ArmPkg.dec
-  ArmPlatformPkg/ArmPlatformPkg.dec
-
-[LibraryClasses]
-  ArmLib
-  BaseLib
-  UefiRuntimeServicesTableLib
-  UefiLib
-  UefiBootServicesTableLib
-  BaseMemoryLib
-  DebugLib
-  UefiDriverEntryPoint
-  IoLib  
-
-[Guids]
-
-[Protocols]
-  gEfiTimerArchProtocolGuid  
-  gHardwareInterruptProtocolGuid
-
-[Pcd.common]
-  gEmbeddedTokenSpaceGuid.PcdTimerPeriod
-  gArmTokenSpaceGuid.PcdArmArchTimerSecIntrNum  
-  gArmTokenSpaceGuid.PcdArmArchTimerIntrNum
-  gArmTokenSpaceGuid.PcdArmArchTimerFreqInHz  
-
-[Depex]
-  gHardwareInterruptProtocolGuid
-  
\ No newline at end of file
+#/** @file

+#  

+#    Component description file for Timer DXE module

+#  

+#  Copyright (c) 2009 - 2010, Apple Inc. All rights reserved.<BR>

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = ArmTimerDxe

+  FILE_GUID                      = 49ea041e-6752-42ca-b0b1-7344fe2546b7 

+  MODULE_TYPE                    = DXE_DRIVER

+  VERSION_STRING                 = 1.0

+

+  ENTRY_POINT                    = TimerInitialize

+

+[Sources.common]

+  TimerDxe.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  EmbeddedPkg/EmbeddedPkg.dec

+  ArmPkg/ArmPkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+

+[LibraryClasses]

+  ArmLib

+  BaseLib

+  UefiRuntimeServicesTableLib

+  UefiLib

+  UefiBootServicesTableLib

+  BaseMemoryLib

+  DebugLib

+  UefiDriverEntryPoint

+  IoLib  

+

+[Guids]

+

+[Protocols]

+  gEfiTimerArchProtocolGuid  

+  gHardwareInterruptProtocolGuid

+

+[Pcd.common]

+  gEmbeddedTokenSpaceGuid.PcdTimerPeriod

+  gArmTokenSpaceGuid.PcdArmArchTimerSecIntrNum  

+  gArmTokenSpaceGuid.PcdArmArchTimerIntrNum

+  gArmTokenSpaceGuid.PcdArmArchTimerFreqInHz  

+

+[Depex]

+  gHardwareInterruptProtocolGuid

+  
\ No newline at end of file
diff --git a/ArmPkg/Filesystem/SemihostFs/Arm/SemihostFs.c b/ArmPkg/Filesystem/SemihostFs/Arm/SemihostFs.c
index e6604ba0..b04e866a 100644
--- a/ArmPkg/Filesystem/SemihostFs/Arm/SemihostFs.c
+++ b/ArmPkg/Filesystem/SemihostFs/Arm/SemihostFs.c
@@ -2,7 +2,8 @@
   Support a Semi Host file system over a debuggers JTAG

 

   Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

-  

+  Portions copyright (c) 2011-2013, ARM Ltd. All rights reserved.<BR>

+

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -73,7 +74,7 @@ typedef struct {
   EFI_FILE    File;

   CHAR8       *FileName;

   UINT32      Position;

-  UINT32      SemihostHandle;

+  UINTN       SemihostHandle;

   BOOLEAN     IsRoot;

 } SEMIHOST_FCB;

 

@@ -152,10 +153,8 @@ FileOpen (
 {

   SEMIHOST_FCB  *FileFcb = NULL;

   EFI_STATUS    Status   = EFI_SUCCESS;

-  UINT32        SemihostHandle;

+  UINTN         SemihostHandle;

   CHAR8         *AsciiFileName;

-  CHAR8         *AsciiPtr;

-  UINTN         Length;

   UINT32        SemihostMode;

   BOOLEAN       IsRoot;

 

@@ -163,22 +162,18 @@ FileOpen (
     return EFI_INVALID_PARAMETER;

   }

 

-  // Semihost interface requires ASCII filesnames

-  Length = StrSize (FileName);

-

-  AsciiFileName = AllocatePool (Length);

+  // Semihost interface requires ASCII filenames

+  AsciiFileName = AllocatePool ((StrLen (FileName) + 1) * sizeof (CHAR8));

   if (AsciiFileName == NULL) {

     return EFI_OUT_OF_RESOURCES;

   }

+  UnicodeStrToAsciiStr (FileName, AsciiFileName);

 

-  AsciiPtr = AsciiFileName;

-

-  while (Length--) {

-    *AsciiPtr++ = *FileName++ & 0xFF;

-  }

-

-  if ((AsciiStrCmp (AsciiFileName, "\\") == 0) || (AsciiStrCmp (AsciiFileName, "/") == 0) || (AsciiStrCmp (AsciiFileName, "") == 0)) {

-    // Opening '/', '\', or the NULL pathname is trying to open the root directory

+  if ((AsciiStrCmp (AsciiFileName, "\\") == 0) ||

+      (AsciiStrCmp (AsciiFileName, "/")  == 0) ||

+      (AsciiStrCmp (AsciiFileName, "")   == 0) ||

+      (AsciiStrCmp (AsciiFileName, ".")  == 0)) {

+    // Opening '/', '\', '.', or the NULL pathname is trying to open the root directory

     IsRoot = TRUE;

 

     // Root directory node doesn't have a name.

@@ -296,6 +291,7 @@ FileRead (
   Fcb = SEMIHOST_FCB_FROM_THIS(File);

 

   if (Fcb->IsRoot == TRUE) {

+    // By design, the Semihosting feature does not allow to list files on the host machine.

     Status = EFI_UNSUPPORTED;

   } else {

     Status = SemihostFileRead (Fcb->SemihostHandle, BufferSize, Buffer);

@@ -357,7 +353,7 @@ FileSetPosition (
   )

 {

   SEMIHOST_FCB *Fcb    = NULL;

-  UINT32       Length;

+  UINTN        Length;

   EFI_STATUS   Status;

 

   Fcb = SEMIHOST_FCB_FROM_THIS(File);

@@ -392,7 +388,7 @@ GetFileInfo (
   UINTN           NameSize = 0;

   UINTN           ResultSize;

   UINTN           Index;

-  UINT32          Length;

+  UINTN           Length;

   EFI_STATUS      Status;

 

   if (Fcb->IsRoot == TRUE) {

diff --git a/ArmPkg/Filesystem/SemihostFs/SemihostFs.inf b/ArmPkg/Filesystem/SemihostFs/SemihostFs.inf
index 25b72894..30ce6665 100644
--- a/ArmPkg/Filesystem/SemihostFs/SemihostFs.inf
+++ b/ArmPkg/Filesystem/SemihostFs/SemihostFs.inf
@@ -1,46 +1,46 @@
-#/** @file
-#  Support a Semi Host file system over a debuggers JTAG
-#
-#  Copyright (c) 2009, Apple Inc. All rights reserved.<BR>
-#  This program and the accompanying materials                          
-#  are licensed and made available under the terms and conditions of the BSD License         
-#  which accompanies this distribution.  The full text of the license may be found at        
-#  http://opensource.org/licenses/bsd-license.php                                            
-#
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-#
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = SemihostFs
-  FILE_GUID                      = C5B9C74A-6D72-4719-99AB-C59F199091EB
-  MODULE_TYPE                    = UEFI_DRIVER
-  VERSION_STRING                 = 1.0
-
-  ENTRY_POINT                    = SemihostFsEntryPoint
-
-[Sources.ARM]
-  Arm/SemihostFs.c
-  
-[Packages]
-  MdePkg/MdePkg.dec
-  ArmPkg/ArmPkg.dec
-
-[LibraryClasses]
-  BaseLib
-  MemoryAllocationLib
-  SemihostLib
-  UefiDriverEntryPoint
-  UefiLib
-
-[Guids]
-  gEfiFileSystemInfoGuid
-  gEfiFileInfoGuid
-  gEfiFileSystemVolumeLabelInfoIdGuid
-
-[Protocols]
-  gEfiSimpleFileSystemProtocolGuid
-  gEfiDevicePathProtocolGuid
-  
+#/** @file

+#  Support a Semi Host file system over a debuggers JTAG

+#

+#  Copyright (c) 2009, Apple Inc. All rights reserved.<BR>

+#  This program and the accompanying materials                          

+#  are licensed and made available under the terms and conditions of the BSD License         

+#  which accompanies this distribution.  The full text of the license may be found at        

+#  http://opensource.org/licenses/bsd-license.php                                            

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+#

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = SemihostFs

+  FILE_GUID                      = C5B9C74A-6D72-4719-99AB-C59F199091EB

+  MODULE_TYPE                    = UEFI_DRIVER

+  VERSION_STRING                 = 1.0

+

+  ENTRY_POINT                    = SemihostFsEntryPoint

+

+[Sources.ARM]

+  Arm/SemihostFs.c

+  

+[Packages]

+  MdePkg/MdePkg.dec

+  ArmPkg/ArmPkg.dec

+

+[LibraryClasses]

+  BaseLib

+  MemoryAllocationLib

+  SemihostLib

+  UefiDriverEntryPoint

+  UefiLib

+

+[Guids]

+  gEfiFileSystemInfoGuid

+  gEfiFileInfoGuid

+  gEfiFileSystemVolumeLabelInfoIdGuid

+

+[Protocols]

+  gEfiSimpleFileSystemProtocolGuid

+  gEfiDevicePathProtocolGuid

+  

diff --git a/ArmPkg/Include/Chipset/ArmV7.h b/ArmPkg/Include/Chipset/ArmV7.h
index 3d1b4eea..e64deb14 100644
--- a/ArmPkg/Include/Chipset/ArmV7.h
+++ b/ArmPkg/Include/Chipset/ArmV7.h
@@ -1,7 +1,7 @@
 /** @file

 

   Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

-  Copyright (c) 2011, ARM Ltd. All rights reserved.<BR>

+  Copyright (c) 2011-2013, ARM Ltd. All rights reserved.<BR>

 

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

@@ -19,6 +19,9 @@
 #include <Chipset/ArmV7Mmu.h>

 #include <Chipset/ArmV7ArchTimer.h>

 

+// ARM Interrupt ID in Exception Table

+#define ARM_ARCH_EXCEPTION_IRQ            EXCEPT_ARM_IRQ

+

 // Domain Access Control Register

 #define DOMAIN_ACCESS_CONTROL_MASK(a)     (3UL << (2 * (a)))

 #define DOMAIN_ACCESS_CONTROL_NONE(a)     (0UL << (2 * (a)))

@@ -26,6 +29,21 @@
 #define DOMAIN_ACCESS_CONTROL_RESERVED(a) (2UL << (2 * (a)))

 #define DOMAIN_ACCESS_CONTROL_MANAGER(a)  (3UL << (2 * (a)))

 

+// CPSR - Coprocessor Status Register definitions

+#define CPSR_MODE_USER       0x10

+#define CPSR_MODE_FIQ        0x11

+#define CPSR_MODE_IRQ        0x12

+#define CPSR_MODE_SVC        0x13

+#define CPSR_MODE_ABORT      0x17

+#define CPSR_MODE_HYP        0x1A

+#define CPSR_MODE_UNDEFINED  0x1B

+#define CPSR_MODE_SYSTEM     0x1F

+#define CPSR_MODE_MASK       0x1F

+#define CPSR_ASYNC_ABORT     (1 << 8)

+#define CPSR_IRQ             (1 << 7)

+#define CPSR_FIQ             (1 << 6)

+

+

 // CPACR - Coprocessor Access Control Register definitions

 #define CPACR_CP_DENIED(cp)     0x00

 #define CPACR_CP_PRIV(cp)       ((0x1 << ((cp) << 1)) & 0x0FFFFFFF)

diff --git a/ArmPkg/Include/IndustryStandard/ArmSmc.h b/ArmPkg/Include/IndustryStandard/ArmSmc.h
new file mode 100644
index 00000000..f6d062c7
--- /dev/null
+++ b/ArmPkg/Include/IndustryStandard/ArmSmc.h
@@ -0,0 +1,52 @@
+/** @file

+*

+*  Copyright (c) 2012-2013, ARM Limited. All rights reserved.

+*

+*  This program and the accompanying materials

+*  are licensed and made available under the terms and conditions of the BSD License

+*  which accompanies this distribution.  The full text of the license may be found at

+*  http://opensource.org/licenses/bsd-license.php

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+*

+**/

+

+#ifndef __ARM_SMC_H__

+#define __ARM_SMC_H__

+

+#include <IndustryStandard/ArmTrustZoneSmc.h>

+

+#define ARM_SMC_ID_PRESENCE       ARM_TRUSTZONE_ARM_FAST_SMC_ID_PRESENCE

+#define ARM_SMC_ID_UID            ARM_TRUSTZONE_ARM_FAST_SMC_ID_UID

+#define ARM_SMC_ID_REVISION       ARM_TRUSTZONE_ARM_FAST_SMC_ID_REVISION

+#define ARM_SMC_ARM_CPU_SUSPEND   0x80100001

+#define ARM_SMC_ARM_CPU_OFF       0x80100002

+#define ARM_SMC_ARM_CPU_ON        0x80100003

+#define ARM_SMC_ARM_MIGRATE       0x80100004

+

+#define ARM_SMC_ARM_CPU_SUSPEND_STANDBY_STATE       (0 << 16)

+#define ARM_SMC_ARM_CPU_SUSPEND_POWER_DOWN_STATE    (1 << 16)

+

+#define ARM_SMC_ARM_CPU_SUSPEND_CURRENT_CPU         (0 << 24)

+#define ARM_SMC_ARM_CPU_SUSPEND_CLUSTER_AFFINITY_1  (1 << 24)

+#define ARM_SMC_ARM_CPU_SUSPEND_CLUSTER_AFFINITY_2  (2 << 24)

+#define ARM_SMC_ARM_CPU_SUSPEND_CLUSTER_AFFINITY_3  (3 << 24)

+

+#define ARM_SMC_ARM_CPU_OFF_MASK_STATE              (1 << 16)

+#define ARM_SMC_ARM_CPU_OFF_STANDBY_STATE           (0 << 16)

+#define ARM_SMC_ARM_CPU_OFF_POWER_DOWN_STATE        (1 << 16)

+

+#define ARM_SMC_ARM_CPU_OFF_CURRENT_CPU             (0 << 24)

+#define ARM_SMC_ARM_CPU_OFF_CLUSTER_AFFINITY_1      (1 << 24)

+#define ARM_SMC_ARM_CPU_OFF_CLUSTER_AFFINITY_2      (2 << 24)

+#define ARM_SMC_ARM_CPU_OFF_CLUSTER_AFFINITY_3      (3 << 24)

+

+

+#define ARM_SMC_ARM_RETURN_SUCCESS            (UINTN)(0)

+#define ARM_SMC_ARM_RETURN_NOT_IMPLEMENTED    (UINTN)(-1)

+#define ARM_SMC_ARM_RETURN_INVALID_PARAMETER  (UINTN)(-2)

+#define ARM_SMC_ARM_RETURN_DENIED             (UINTN)(-3)

+#define ARM_SMC_ARM_RETURN_CORE_NOT_AVAILABLE (UINTN)(-3)

+

+#endif

diff --git a/ArmPkg/Include/IndustryStandard/ArmTrustZoneSmc.h b/ArmPkg/Include/IndustryStandard/ArmTrustZoneSmc.h
new file mode 100644
index 00000000..62f8f61a
--- /dev/null
+++ b/ArmPkg/Include/IndustryStandard/ArmTrustZoneSmc.h
@@ -0,0 +1,159 @@
+/** @file

+*

+*  Copyright (c) 2012-2013, ARM Limited. All rights reserved.

+*

+*  This program and the accompanying materials

+*  are licensed and made available under the terms and conditions of the BSD License

+*  which accompanies this distribution.  The full text of the license may be found at

+*  http://opensource.org/licenses/bsd-license.php

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+*

+**/

+

+#ifndef __ARM_TRUSTZONE_SMC_H__

+#define __ARM_TRUSTZONE_SMC_H__

+

+#define ARM_TRUSTZONE_UID_4LETTERID   0x1

+#define ARM_TRUSTZONE_UID_MD5         0x2

+

+#define IS_ARM_TRUSTZONE_SUPPORTED_SMC(Rx,Region)       (((UINTN)(Rx) >= (UINTN)ARM_TRUSTZONE_##Region##_SMC_ID_START) && ((UINTN)(Rx) <= (UINTN)ARM_TRUSTZONE_##Region##_SMC_ID_END))

+

+#define IS_ARM_TRUSTZONE_DEPRECIATED_SMC(Rx)            ((UINTN)(Rx) <= (UINTN)ARM_TRUSTZONE_DEPRECIATED_SMC_ID_END)

+#define IS_ARM_TRUSTZONE_TRUSTED_OS_SMC(Rx)             IS_ARM_TRUSTZONE_SUPPORTED_SMC(Rx,TRUSTED_OS)

+#define IS_ARM_TRUSTZONE_ARM_FAST_SMC(Rx)               IS_ARM_TRUSTZONE_SUPPORTED_SMC(Rx,ARM_FAST)

+#define IS_ARM_TRUSTZONE_SIP_FAST_SMC(Rx)               IS_ARM_TRUSTZONE_SUPPORTED_SMC(Rx,SIP_FAST)

+#define IS_ARM_TRUSTZONE_ODM_FAST_SMC(Rx)               IS_ARM_TRUSTZONE_SUPPORTED_SMC(Rx,ODM_FAST)

+#define IS_ARM_TRUSTZONE_OEM_FAST_SMC(Rx)               IS_ARM_TRUSTZONE_SUPPORTED_SMC(Rx,OEM_FAST)

+#define IS_ARM_TRUSTZONE_TRUSTED_USER_FAST_SMC(Rx)      IS_ARM_TRUSTZONE_SUPPORTED_SMC(Rx,TRUSTED_USER_FAST)

+#define IS_ARM_TRUSTZONE_TRUSTED_OS_FAST_SMC(Rx)        IS_ARM_TRUSTZONE_SUPPORTED_SMC(Rx,TRUSTED_OS_FAST)

+

+#define IS_ARM_TRUSTZONE_SUPPORTED_SMC_ID_PRESENCE(Rx,Region) ((Rx) == ARM_TRUSTZONE_##Region##_SMC_ID_PRESENCE)

+#define IS_ARM_TRUSTZONE_SUPPORTED_SMC_ID_UID(Rx,Region)      (((Rx) == ARM_TRUSTZONE_##Region##_SMC_ID_UID)   || \

+                                                               ((Rx) == ARM_TRUSTZONE_##Region##_SMC_ID_UID+1) || \

+                                                               ((Rx) == ARM_TRUSTZONE_##Region##_SMC_ID_UID+2) || \

+                                                               ((Rx) == ARM_TRUSTZONE_##Region##_SMC_ID_UID+3) || \

+                                                               ((Rx) == ARM_TRUSTZONE_##Region##_SMC_ID_UID+4))

+#define IS_ARM_TRUSTZONE_SUPPORTED_SMC_ID_REVISION(Rx,Region) (((Rx) == ARM_TRUSTZONE_##Region##_SMC_ID_REVISION)   || \

+                                                               ((Rx) == ARM_TRUSTZONE_##Region##_SMC_ID_REVISION+1))

+#define IS_ARM_TRUSTZONE_SUPPORTED_SMC_ID_RPC(Rx,Region)      (((Rx) >= ARM_TRUSTZONE_##Region##_SMC_ID_RPC_START) && \

+                                                               ((Rx) <= ARM_TRUSTZONE_##Region##_SMC_ID_RPC_END))

+

+#define ARM_TRUSTZONE_SUPPORTED_SMC_ID_UID_INDEX(Rx,Region)       ((Rx) - ARM_TRUSTZONE_##Region##_SMC_ID_UID)

+#define ARM_TRUSTZONE_SUPPORTED_SMC_ID_REVISION_INDEX(Rx,Region)  ((Rx) - ARM_TRUSTZONE_##Region##_SMC_ID_REVISION)

+#define ARM_TRUSTZONE_SUPPORTED_SMC_ID_RPC_INDEX(Rx,Region)       ((Rx) - ARM_TRUSTZONE_##Region##_SMC_ID_RPC_START)

+

+#define ARM_TRUSTZONE_TRUSTED_OS_SMC_ID_RPC_INDEX(Rx)       ARM_TRUSTZONE_SUPPORTED_SMC_ID_RPC_INDEX(Rx,TRUSTED_OS)

+

+#define IS_ARM_TRUSTZONE_ARM_FAST_SMC_ID_PRESENCE(Rx)       IS_ARM_TRUSTZONE_SUPPORTED_SMC_ID_PRESENCE(Rx,ARM_FAST)

+#define IS_ARM_TRUSTZONE_ARM_FAST_SMC_ID_UID(Rx)            IS_ARM_TRUSTZONE_SUPPORTED_SMC_ID_UID(Rx,ARM_FAST)

+#define IS_ARM_TRUSTZONE_ARM_FAST_SMC_ID_REVISION(Rx)       IS_ARM_TRUSTZONE_SUPPORTED_SMC_ID_REVISION(Rx,ARM_FAST)

+#define IS_ARM_TRUSTZONE_ARM_FAST_SMC_ID_RPC(Rx)            IS_ARM_TRUSTZONE_SUPPORTED_SMC_ID_RPC(Rx,ARM_FAST)

+#define ARM_TRUSTZONE_ARM_FAST_SMC_ID_UID_INDEX(Rx)         ARM_TRUSTZONE_SUPPORTED_SMC_ID_UID_INDEX(Rx,ARM_FAST)

+#define ARM_TRUSTZONE_ARM_FAST_SMC_ID_REVISION_INDEX(Rx)    ARM_TRUSTZONE_SUPPORTED_SMC_ID_REVISION_INDEX(Rx,ARM_FAST)

+#define ARM_TRUSTZONE_ARM_FAST_SMC_ID_RPC_INDEX(Rx)         ARM_TRUSTZONE_SUPPORTED_SMC_ID_RPC_INDEX(Rx,ARM_FAST)

+

+#define IS_ARM_TRUSTZONE_ODM_FAST_SMC_ID_PRESENCE(Rx)       IS_ARM_TRUSTZONE_SUPPORTED_SMC_ID_PRESENCE(Rx,ODM_FAST)

+#define IS_ARM_TRUSTZONE_ODM_FAST_SMC_ID_UID(Rx)            IS_ARM_TRUSTZONE_SUPPORTED_SMC_ID_UID(Rx,ODM_FAST)

+#define IS_ARM_TRUSTZONE_ODM_FAST_SMC_ID_REVISION(Rx)       IS_ARM_TRUSTZONE_SUPPORTED_SMC_ID_REVISION(Rx,ODM_FAST)

+#define IS_ARM_TRUSTZONE_ODM_FAST_SMC_ID_RPC(Rx)            IS_ARM_TRUSTZONE_SUPPORTED_SMC_ID_RPC(Rx,ODM_FAST)

+#define ARM_TRUSTZONE_ODM_FAST_SMC_ID_UID_INDEX(Rx)         ARM_TRUSTZONE_SUPPORTED_SMC_ID_UID_INDEX(Rx,ODM_FAST)

+#define ARM_TRUSTZONE_ODM_FAST_SMC_ID_REVISION_INDEX(Rx)    ARM_TRUSTZONE_SUPPORTED_SMC_ID_REVISION_INDEX(Rx,ODM_FAST)

+#define ARM_TRUSTZONE_ODM_FAST_SMC_ID_RPC_INDEX(Rx)         ARM_TRUSTZONE_SUPPORTED_SMC_ID_RPC_INDEX(Rx,ODM_FAST)

+

+#define IS_ARM_TRUSTZONE_OEM_FAST_SMC_ID_PRESENCE(Rx)       IS_ARM_TRUSTZONE_SUPPORTED_SMC_ID_PRESENCE(Rx,OEM_FAST)

+#define IS_ARM_TRUSTZONE_OEM_FAST_SMC_ID_UID(Rx)            IS_ARM_TRUSTZONE_SUPPORTED_SMC_ID_UID(Rx,OEM_FAST)

+#define IS_ARM_TRUSTZONE_OEM_FAST_SMC_ID_REVISION(Rx)       IS_ARM_TRUSTZONE_SUPPORTED_SMC_ID_REVISION(Rx,OEM_FAST)

+#define IS_ARM_TRUSTZONE_OEM_FAST_SMC_ID_RPC(Rx)            IS_ARM_TRUSTZONE_SUPPORTED_SMC_ID_RPC(Rx,OEM_FAST)

+#define ARM_TRUSTZONE_OEM_FAST_SMC_ID_UID_INDEX(Rx)         ARM_TRUSTZONE_SUPPORTED_SMC_ID_UID_INDEX(Rx,OEM_FAST)

+#define ARM_TRUSTZONE_OEM_FAST_SMC_ID_REVISION_INDEX(Rx)    ARM_TRUSTZONE_SUPPORTED_SMC_ID_REVISION_INDEX(Rx,OEM_FAST)

+#define ARM_TRUSTZONE_OEM_FAST_SMC_ID_RPC_INDEX(Rx)         ARM_TRUSTZONE_SUPPORTED_SMC_ID_RPC_INDEX(Rx,OEM_FAST)

+

+#define IS_ARM_TRUSTZONE_SIP_FAST_SMC_ID_PRESENCE(Rx)       IS_ARM_TRUSTZONE_SUPPORTED_SMC_ID_PRESENCE(Rx,SIP_FAST)

+#define IS_ARM_TRUSTZONE_SIP_FAST_SMC_ID_UID(Rx)            IS_ARM_TRUSTZONE_SUPPORTED_SMC_ID_UID(Rx,SIP_FAST)

+#define IS_ARM_TRUSTZONE_SIP_FAST_SMC_ID_REVISION(Rx)       IS_ARM_TRUSTZONE_SUPPORTED_SMC_ID_REVISION(Rx,SIP_FAST)

+#define IS_ARM_TRUSTZONE_SIP_FAST_SMC_ID_RPC(Rx)            IS_ARM_TRUSTZONE_SUPPORTED_SMC_ID_RPC(Rx,SIP_FAST)

+#define ARM_TRUSTZONE_SIP_FAST_SMC_ID_UID_INDEX(Rx)         ARM_TRUSTZONE_SUPPORTED_SMC_ID_UID_INDEX(Rx,SIP_FAST)

+#define ARM_TRUSTZONE_SIP_FAST_SMC_ID_REVISION_INDEX(Rx)    ARM_TRUSTZONE_SUPPORTED_SMC_ID_REVISION_INDEX(Rx,SIP_FAST)

+#define ARM_TRUSTZONE_SIP_FAST_SMC_ID_RPC_INDEX(Rx)         ARM_TRUSTZONE_SUPPORTED_SMC_ID_RPC_INDEX(Rx,SIP_FAST)

+

+#define ARM_TRUSTZONE_TRUSTED_USER_FAST_SMC_ID_RPC_INDEX(Rx)    ARM_TRUSTZONE_SUPPORTED_SMC_ID_RPC_INDEX(Rx,TRUSTED_USER_FAST)

+

+#define IS_ARM_TRUSTZONE_TRUSTED_OS_FAST_SMC_ID_PRESENCE(Rx)    IS_ARM_TRUSTZONE_SUPPORTED_SMC_ID_PRESENCE(Rx,TRUSTED_OS_FAST)

+#define IS_ARM_TRUSTZONE_TRUSTED_OS_FAST_SMC_ID_UID(Rx)         IS_ARM_TRUSTZONE_SUPPORTED_SMC_ID_UID(Rx,TRUSTED_OS_FAST)

+#define IS_ARM_TRUSTZONE_TRUSTED_OS_FAST_SMC_ID_REVISION(Rx)    IS_ARM_TRUSTZONE_SUPPORTED_SMC_ID_REVISION(Rx,TRUSTED_OS_FAST)

+#define IS_ARM_TRUSTZONE_TRUSTED_OS_FAST_SMC_ID_RPC(Rx)         IS_ARM_TRUSTZONE_SUPPORTED_SMC_ID_RPC(Rx,TRUSTED_OS_FAST)

+#define ARM_TRUSTZONE_TRUSTED_OS_FAST_SMC_ID_UID_INDEX(Rx)      ARM_TRUSTZONE_SUPPORTED_SMC_ID_UID_INDEX(Rx,TRUSTED_OS_FAST)

+#define ARM_TRUSTZONE_TRUSTED_OS_FAST_SMC_ID_REVISION_INDEX(Rx) ARM_TRUSTZONE_SUPPORTED_SMC_ID_REVISION_INDEX(Rx,TRUSTED_OS_FAST)

+#define ARM_TRUSTZONE_TRUSTED_OS_FAST_SMC_ID_RPC_INDEX(Rx)      ARM_TRUSTZONE_SUPPORTED_SMC_ID_RPC_INDEX(Rx,TRUSTED_OS_FAST)

+

+

+#define ARM_TRUSTZONE_DEPRECIATED_SMC_ID_START          0x00000000

+#define ARM_TRUSTZONE_DEPRECIATED_SMC_ID_END            0x01FFFFFF

+

+

+#define ARM_TRUSTZONE_TRUSTED_OS_SMC_ID_START           0x02000000

+#define ARM_TRUSTZONE_TRUSTED_OS_SMC_ID_END             0x1FFFFFFF

+

+#define ARM_TRUSTZONE_TRUSTED_OS_SMC_ID_RPC_START       0x02000000

+#define ARM_TRUSTZONE_TRUSTED_OS_SMC_ID_RPC_END         0x1FFFFFFF

+

+

+#define ARM_TRUSTZONE_ARM_FAST_SMC_ID_START             0x80000000

+#define ARM_TRUSTZONE_ARM_FAST_SMC_ID_END               0x80FFFFFF

+

+#define ARM_TRUSTZONE_ARM_FAST_SMC_ID_RPC_START         0x80000000

+#define ARM_TRUSTZONE_ARM_FAST_SMC_ID_RPC_END           0x80FFFEFF

+#define ARM_TRUSTZONE_ARM_FAST_SMC_ID_PRESENCE          0x80FFFF00

+#define ARM_TRUSTZONE_ARM_FAST_SMC_ID_UID               0x80FFFF10

+#define ARM_TRUSTZONE_ARM_FAST_SMC_ID_REVISION          0x80FFFF20

+

+

+#define ARM_TRUSTZONE_SIP_FAST_SMC_ID_START             0x81000000

+#define ARM_TRUSTZONE_SIP_FAST_SMC_ID_END               0x81FFFFFF

+

+#define ARM_TRUSTZONE_SIP_FAST_SMC_ID_RPC_START         0x81000000

+#define ARM_TRUSTZONE_SIP_FAST_SMC_ID_RPC_END           0x81FFFEFF

+#define ARM_TRUSTZONE_SIP_FAST_SMC_ID_PRESENCE          0x81FFFF00

+#define ARM_TRUSTZONE_SIP_FAST_SMC_ID_UID               0x81FFFF10

+#define ARM_TRUSTZONE_SIP_FAST_SMC_ID_REVISION          0x81FFFF20

+

+

+#define ARM_TRUSTZONE_ODM_FAST_SMC_ID_START             0x82000000

+#define ARM_TRUSTZONE_ODM_FAST_SMC_ID_END               0x82FFFFFF

+

+#define ARM_TRUSTZONE_ODM_FAST_SMC_ID_RPC_START         0x82000000

+#define ARM_TRUSTZONE_ODM_FAST_SMC_ID_RPC_END           0x82FFFEFF

+#define ARM_TRUSTZONE_ODM_FAST_SMC_ID_PRESENCE          0x82FFFF00

+#define ARM_TRUSTZONE_ODM_FAST_SMC_ID_UID               0x82FFFF10

+#define ARM_TRUSTZONE_ODM_FAST_SMC_ID_REVISION          0x82FFFF20

+

+

+#define ARM_TRUSTZONE_OEM_FAST_SMC_ID_START             0x83000000

+#define ARM_TRUSTZONE_OEM_FAST_SMC_ID_END               0x83FFFFFF

+

+#define ARM_TRUSTZONE_OEM_FAST_SMC_ID_RPC_START         0x83000000

+#define ARM_TRUSTZONE_OEM_FAST_SMC_ID_RPC_END           0x83FFFEFF

+#define ARM_TRUSTZONE_OEM_FAST_SMC_ID_PRESENCE          0x83FFFF00

+#define ARM_TRUSTZONE_OEM_FAST_SMC_ID_UID               0x83FFFF10

+#define ARM_TRUSTZONE_OEM_FAST_SMC_ID_REVISION          0x83FFFF20

+

+

+#define ARM_TRUSTZONE_TRUSTED_USER_FAST_SMC_ID_START    0xF0000000

+#define ARM_TRUSTZONE_TRUSTED_USER_FAST_SMC_ID_END      0xF1FFFFFF

+

+#define ARM_TRUSTZONE_TRUSTED_USER_FAST_SMC_ID_RPC_START  0xF0000000

+#define ARM_TRUSTZONE_TRUSTED_USER_FAST_SMC_ID_RPC_END    0xF1FFFEFF

+

+

+#define ARM_TRUSTZONE_TRUSTED_OS_FAST_SMC_ID_START      0xF2000000

+#define ARM_TRUSTZONE_TRUSTED_OS_FAST_SMC_ID_END        0xFFFFFFFF

+

+#define ARM_TRUSTZONE_TRUSTED_OS_FAST_SMC_ID_RPC_START  0xF2000000

+#define ARM_TRUSTZONE_TRUSTED_OS_FAST_SMC_ID_RPC_END    0xFFFFFEFF

+#define ARM_TRUSTZONE_TRUSTED_OS_FAST_SMC_ID_PRESENCE   0xF2FFFF00

+#define ARM_TRUSTZONE_TRUSTED_OS_FAST_SMC_ID_UID        0xF2FFFF10

+#define ARM_TRUSTZONE_TRUSTED_OS_FAST_SMC_ID_REVISION   0xF2FFFF20

+

+#endif

diff --git a/ArmPkg/Include/Library/ArmCpuLib.h b/ArmPkg/Include/Library/ArmCpuLib.h
index 6f92b111..0c415992 100644
--- a/ArmPkg/Include/Library/ArmCpuLib.h
+++ b/ArmPkg/Include/Library/ArmCpuLib.h
@@ -1,28 +1,28 @@
-/** @file
-
-  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __ARMCPU_LIB__
-#define __ARMCPU_LIB__
-
-VOID
-ArmCpuSetup (
-  IN  UINTN         MpId
-  );
-
-VOID
-ArmCpuSetupSmpNonSecure (
-  IN  UINTN         MpId
-  );
-
-#endif // __ARMCPU_LIB__
+/** @file

+

+  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __ARMCPU_LIB__

+#define __ARMCPU_LIB__

+

+VOID

+ArmCpuSetup (

+  IN  UINTN         MpId

+  );

+

+VOID

+ArmCpuSetupSmpNonSecure (

+  IN  UINTN         MpId

+  );

+

+#endif // __ARMCPU_LIB__

diff --git a/ArmPkg/Include/Library/ArmDisassemblerLib.h b/ArmPkg/Include/Library/ArmDisassemblerLib.h
index 038f2ddf..757c95ec 100644
--- a/ArmPkg/Include/Library/ArmDisassemblerLib.h
+++ b/ArmPkg/Include/Library/ArmDisassemblerLib.h
@@ -1,43 +1,43 @@
-/** @file
-
-  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __ARM_DISASSEBLER_LIB_H__
-#define __ARM_DISASSEBLER_LIB_H__
-
-/**
-  Place a dissasembly of of **OpCodePtr into buffer, and update OpCodePtr to 
-  point to next instructin. 
-  
-  We cheat and only decode instructions that access 
-  memory. If the instruction is not found we dump the instruction in hex.
-   
-  @param  OpCodePtrPtr  Pointer to pointer of ARM Thumb instruction to disassemble.  
-  @param  Thumb         TRUE for Thumb(2), FALSE for ARM instruction stream
-  @param  Extended      TRUE dump hex for instruction too.
+/** @file

+

+  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __ARM_DISASSEBLER_LIB_H__

+#define __ARM_DISASSEBLER_LIB_H__

+

+/**

+  Place a dissasembly of of **OpCodePtr into buffer, and update OpCodePtr to 

+  point to next instructin. 

+  

+  We cheat and only decode instructions that access 

+  memory. If the instruction is not found we dump the instruction in hex.

+   

+  @param  OpCodePtrPtr  Pointer to pointer of ARM Thumb instruction to disassemble.  

+  @param  Thumb         TRUE for Thumb(2), FALSE for ARM instruction stream

+  @param  Extended      TRUE dump hex for instruction too.

   @param  ItBlock       Size of IT Block

-  @param  Buf           Buffer to sprintf disassembly into.
-  @param  Size          Size of Buf in bytes. 
-  
-**/
-VOID
-DisassembleInstruction (
-  IN  UINT8     **OpCodePtr,
-  IN  BOOLEAN   Thumb,
-  IN  BOOLEAN   Extended,
+  @param  Buf           Buffer to sprintf disassembly into.

+  @param  Size          Size of Buf in bytes. 

+  

+**/

+VOID

+DisassembleInstruction (

+  IN  UINT8     **OpCodePtr,

+  IN  BOOLEAN   Thumb,

+  IN  BOOLEAN   Extended,

   IN OUT UINT32 *ItBlock,

-  OUT CHAR8     *Buf,
-  OUT UINTN     Size
-  );
-  
-#endif 
+  OUT CHAR8     *Buf,

+  OUT UINTN     Size

+  );

+  

+#endif 

diff --git a/ArmPkg/Include/Library/ArmLib.h b/ArmPkg/Include/Library/ArmLib.h
index 23beb242..b12be142 100644
--- a/ArmPkg/Include/Library/ArmLib.h
+++ b/ArmPkg/Include/Library/ArmLib.h
@@ -1,561 +1,585 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  Copyright (c) 2011 - 2012, ARM Ltd. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __ARM_LIB__
-#define __ARM_LIB__
-
-#include <Uefi/UefiBaseType.h>
-
-#ifdef ARM_CPU_ARMv6
-#include <Chipset/ARM1176JZ-S.h>
-#else
-#include <Chipset/ArmV7.h>
-#endif
-
-typedef enum {
-  ARM_CACHE_TYPE_WRITE_BACK,
-  ARM_CACHE_TYPE_UNKNOWN
-} ARM_CACHE_TYPE;
-
-typedef enum {
-  ARM_CACHE_ARCHITECTURE_UNIFIED,
-  ARM_CACHE_ARCHITECTURE_SEPARATE,
-  ARM_CACHE_ARCHITECTURE_UNKNOWN
-} ARM_CACHE_ARCHITECTURE;
-
-typedef struct {
-  ARM_CACHE_TYPE          Type;
-  ARM_CACHE_ARCHITECTURE  Architecture;
-  BOOLEAN                 DataCachePresent;
-  UINTN                   DataCacheSize;
-  UINTN                   DataCacheAssociativity;
-  UINTN                   DataCacheLineLength;
-  BOOLEAN                 InstructionCachePresent;
-  UINTN                   InstructionCacheSize;
-  UINTN                   InstructionCacheAssociativity;
-  UINTN                   InstructionCacheLineLength;
-} ARM_CACHE_INFO;
-
-/**
- * The UEFI firmware must not use the ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_* attributes.
- *
- * The Non Secure memory attribute (ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_*) should only
- * be used in Secure World to distinguished Secure to Non-Secure memory.
- */
-typedef enum {
-  ARM_MEMORY_REGION_ATTRIBUTE_UNCACHED_UNBUFFERED = 0,
-  ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_UNCACHED_UNBUFFERED,
-  ARM_MEMORY_REGION_ATTRIBUTE_WRITE_BACK,
-  ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_WRITE_BACK,
-  ARM_MEMORY_REGION_ATTRIBUTE_WRITE_THROUGH,
-  ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_WRITE_THROUGH,
-  ARM_MEMORY_REGION_ATTRIBUTE_DEVICE,
-  ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_DEVICE
-} ARM_MEMORY_REGION_ATTRIBUTES;
-
-#define IS_ARM_MEMORY_REGION_ATTRIBUTES_SECURE(attr) ((UINT32)(attr) & 1)
-
-typedef struct {
-  EFI_PHYSICAL_ADDRESS          PhysicalBase;
-  EFI_VIRTUAL_ADDRESS           VirtualBase;
-  UINTN                         Length;
-  ARM_MEMORY_REGION_ATTRIBUTES  Attributes;
-} ARM_MEMORY_REGION_DESCRIPTOR;
-
-typedef VOID (*CACHE_OPERATION)(VOID);
-typedef VOID (*LINE_OPERATION)(UINTN);
-
-//
-// ARM Processor Mode
-//
-typedef enum {
-  ARM_PROCESSOR_MODE_USER       = 0x10,
-  ARM_PROCESSOR_MODE_FIQ        = 0x11,
-  ARM_PROCESSOR_MODE_IRQ        = 0x12,
-  ARM_PROCESSOR_MODE_SUPERVISOR = 0x13,
-  ARM_PROCESSOR_MODE_ABORT      = 0x17,
-  ARM_PROCESSOR_MODE_HYP        = 0x1A,
-  ARM_PROCESSOR_MODE_UNDEFINED  = 0x1B,
-  ARM_PROCESSOR_MODE_SYSTEM     = 0x1F,
-  ARM_PROCESSOR_MODE_MASK       = 0x1F
-} ARM_PROCESSOR_MODE;
-
-//
-// ARM Cpu IDs
-//
-#define ARM_CPU_IMPLEMENTER_MASK          (0xFFU << 24)
-#define ARM_CPU_IMPLEMENTER_ARMLTD        (0x41U << 24)
-#define ARM_CPU_IMPLEMENTER_DEC           (0x44U << 24)
-#define ARM_CPU_IMPLEMENTER_MOT           (0x4DU << 24)
-#define ARM_CPU_IMPLEMENTER_QUALCOMM      (0x51U << 24)
-#define ARM_CPU_IMPLEMENTER_MARVELL       (0x56U << 24)
-
-#define ARM_CPU_PRIMARY_PART_MASK         (0xFFF << 4)
-#define ARM_CPU_PRIMARY_PART_CORTEXA5     (0xC05 << 4)
-#define ARM_CPU_PRIMARY_PART_CORTEXA7     (0xC07 << 4)
-#define ARM_CPU_PRIMARY_PART_CORTEXA8     (0xC08 << 4)
-#define ARM_CPU_PRIMARY_PART_CORTEXA9     (0xC09 << 4)
-#define ARM_CPU_PRIMARY_PART_CORTEXA15    (0xC0F << 4)
-
-//
-// ARM MP Core IDs
-//
-#define IS_PRIMARY_CORE(MpId) (((MpId) & PcdGet32(PcdArmPrimaryCoreMask)) == PcdGet32(PcdArmPrimaryCore))
-#define ARM_CORE_MASK         0xFF
-#define ARM_CLUSTER_MASK      (0xFF << 8)
-#define GET_CORE_ID(MpId)     ((MpId) & ARM_CORE_MASK)
-#define GET_CLUSTER_ID(MpId)  (((MpId) & ARM_CLUSTER_MASK) >> 8)
-// Get the position of the core for the Stack Offset (4 Core per Cluster)
-//   Position = (ClusterId * 4) + CoreId
-#define GET_CORE_POS(MpId)    ((((MpId) & ARM_CLUSTER_MASK) >> 6) + ((MpId) & ARM_CORE_MASK))
-#define PRIMARY_CORE_ID       (PcdGet32(PcdArmPrimaryCore) & ARM_CORE_MASK)
-
-ARM_CACHE_TYPE
-EFIAPI
-ArmCacheType (
-  VOID
-  );
-
-ARM_CACHE_ARCHITECTURE
-EFIAPI
-ArmCacheArchitecture (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmCacheInformation (
-  OUT ARM_CACHE_INFO  *CacheInfo
-  );
-
-BOOLEAN
-EFIAPI
-ArmDataCachePresent (
-  VOID
-  );
-  
-UINTN
-EFIAPI
-ArmDataCacheSize (
-  VOID
-  );
-  
-UINTN
-EFIAPI
-ArmDataCacheAssociativity (
-  VOID
-  );
-  
-UINTN
-EFIAPI
-ArmDataCacheLineLength (
-  VOID
-  );
-  
-BOOLEAN
-EFIAPI
-ArmInstructionCachePresent (
-  VOID
-  );
-  
-UINTN
-EFIAPI
-ArmInstructionCacheSize (
-  VOID
-  );
-  
-UINTN
-EFIAPI
-ArmInstructionCacheAssociativity (
-  VOID
-  );
-  
-UINTN
-EFIAPI
-ArmInstructionCacheLineLength (
-  VOID
-  );
-  
-UINT32
-EFIAPI
-Cp15IdCode (
-  VOID
-  );
-  
-UINT32
-EFIAPI
-Cp15CacheInfo (
-  VOID
-  );
-
-BOOLEAN
-EFIAPI
-ArmIsMpCore (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmInvalidateDataCache (
-  VOID
-  );
-
-
-VOID
-EFIAPI
-ArmCleanInvalidateDataCache (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmCleanDataCache (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmCleanDataCacheToPoU (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmInvalidateInstructionCache (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmInvalidateDataCacheEntryByMVA (
-  IN  UINTN   Address
-  );
-
-VOID
-EFIAPI
-ArmCleanDataCacheEntryByMVA (
-  IN  UINTN   Address
-  );
-
-VOID
-EFIAPI
-ArmCleanInvalidateDataCacheEntryByMVA (
-  IN  UINTN   Address
-  );
-
-VOID
-EFIAPI
-ArmEnableDataCache (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmDisableDataCache (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmEnableInstructionCache (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmDisableInstructionCache (
-  VOID
-  );
-  
-VOID
-EFIAPI
-ArmEnableMmu (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmDisableMmu (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmDisableCachesAndMmu (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmInvalidateInstructionAndDataTlb (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmEnableInterrupts (
-  VOID
-  );
-
-UINTN
-EFIAPI
-ArmDisableInterrupts (
-  VOID
-  );
-  
-BOOLEAN
-EFIAPI
-ArmGetInterruptState (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmEnableFiq (
-  VOID
-  );
-
-UINTN
-EFIAPI
-ArmDisableFiq (
-  VOID
-  );
-  
-BOOLEAN
-EFIAPI
-ArmGetFiqState (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmInvalidateTlb (
-  VOID
-  );
-  
-VOID
-EFIAPI
-ArmUpdateTranslationTableEntry (
-  IN  VOID     *TranslationTableEntry,
-  IN  VOID     *Mva
-  );
-  
-VOID
-EFIAPI
-ArmSetDomainAccessControl (
-  IN  UINT32  Domain
-  );
-
-VOID
-EFIAPI
-ArmSetTTBR0 (
-  IN  VOID  *TranslationTableBase
-  );
-
-VOID *
-EFIAPI
-ArmGetTTBR0BaseAddress (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmConfigureMmu (
-  IN  ARM_MEMORY_REGION_DESCRIPTOR  *MemoryTable,
-  OUT VOID                          **TranslationTableBase OPTIONAL,
-  OUT UINTN                         *TranslationTableSize  OPTIONAL
-  );
-  
-BOOLEAN
-EFIAPI
-ArmMmuEnabled (
-  VOID
-  );
-  
-VOID
-EFIAPI
-ArmSwitchProcessorMode (
-  IN ARM_PROCESSOR_MODE Mode
-  );
-
-ARM_PROCESSOR_MODE
-EFIAPI
-ArmProcessorMode (
-  VOID
-  );
-  
-VOID
-EFIAPI
-ArmEnableBranchPrediction (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmDisableBranchPrediction (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmSetLowVectors (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmSetHighVectors (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmDataMemoryBarrier (
-  VOID
-  );
-  
-VOID
-EFIAPI
-ArmDataSyncronizationBarrier (
-  VOID
-  );
-  
-VOID
-EFIAPI
-ArmInstructionSynchronizationBarrier (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmWriteVBar (
-  IN  UINT32   VectorBase
-  );
-
-UINT32
-EFIAPI
-ArmReadVBar (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmWriteAuxCr (
-  IN  UINT32    Bit
-  );
-
-UINT32
-EFIAPI
-ArmReadAuxCr (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmSetAuxCrBit (
-  IN  UINT32    Bits
-  );
-
-VOID
-EFIAPI
-ArmUnsetAuxCrBit (
-  IN  UINT32    Bits
-  );
-
-VOID
-EFIAPI
-ArmCallSEV (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmCallWFE (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmCallWFI (
-  VOID
-  );
-
-UINTN
-EFIAPI
-ArmReadMpidr (
-  VOID
-  );
-
-UINT32
-EFIAPI
-ArmReadCpacr (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmWriteCpacr (
-  IN  UINT32   Access
-  );
-
-VOID
-EFIAPI
-ArmEnableVFP (
-  VOID
-  );
-
-UINT32
-EFIAPI
-ArmReadNsacr (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmWriteNsacr (
-  IN  UINT32   SetWayFormat
-  );
-
-UINT32
-EFIAPI
-ArmReadScr (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmWriteScr (
-  IN  UINT32   SetWayFormat
-  );
-
-UINT32
-EFIAPI
-ArmReadMVBar (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmWriteMVBar (
-  IN  UINT32   VectorMonitorBase
-  );
-
-UINT32
-EFIAPI
-ArmReadSctlr (
-  VOID
-  );
-
-#endif // __ARM_LIB__
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  Copyright (c) 2011 - 2012, ARM Ltd. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __ARM_LIB__

+#define __ARM_LIB__

+

+#include <Uefi/UefiBaseType.h>

+

+#ifdef ARM_CPU_ARMv6

+#include <Chipset/ARM1176JZ-S.h>

+#else

+#include <Chipset/ArmV7.h>

+#endif

+

+typedef enum {

+  ARM_CACHE_TYPE_WRITE_BACK,

+  ARM_CACHE_TYPE_UNKNOWN

+} ARM_CACHE_TYPE;

+

+typedef enum {

+  ARM_CACHE_ARCHITECTURE_UNIFIED,

+  ARM_CACHE_ARCHITECTURE_SEPARATE,

+  ARM_CACHE_ARCHITECTURE_UNKNOWN

+} ARM_CACHE_ARCHITECTURE;

+

+typedef struct {

+  ARM_CACHE_TYPE          Type;

+  ARM_CACHE_ARCHITECTURE  Architecture;

+  BOOLEAN                 DataCachePresent;

+  UINTN                   DataCacheSize;

+  UINTN                   DataCacheAssociativity;

+  UINTN                   DataCacheLineLength;

+  BOOLEAN                 InstructionCachePresent;

+  UINTN                   InstructionCacheSize;

+  UINTN                   InstructionCacheAssociativity;

+  UINTN                   InstructionCacheLineLength;

+} ARM_CACHE_INFO;

+

+/**

+ * The UEFI firmware must not use the ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_* attributes.

+ *

+ * The Non Secure memory attribute (ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_*) should only

+ * be used in Secure World to distinguished Secure to Non-Secure memory.

+ */

+typedef enum {

+  ARM_MEMORY_REGION_ATTRIBUTE_UNCACHED_UNBUFFERED = 0,

+  ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_UNCACHED_UNBUFFERED,

+  ARM_MEMORY_REGION_ATTRIBUTE_WRITE_BACK,

+  ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_WRITE_BACK,

+  ARM_MEMORY_REGION_ATTRIBUTE_WRITE_THROUGH,

+  ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_WRITE_THROUGH,

+  ARM_MEMORY_REGION_ATTRIBUTE_DEVICE,

+  ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_DEVICE

+} ARM_MEMORY_REGION_ATTRIBUTES;

+

+#define IS_ARM_MEMORY_REGION_ATTRIBUTES_SECURE(attr) ((UINT32)(attr) & 1)

+

+typedef struct {

+  EFI_PHYSICAL_ADDRESS          PhysicalBase;

+  EFI_VIRTUAL_ADDRESS           VirtualBase;

+  UINTN                         Length;

+  ARM_MEMORY_REGION_ATTRIBUTES  Attributes;

+} ARM_MEMORY_REGION_DESCRIPTOR;

+

+typedef VOID (*CACHE_OPERATION)(VOID);

+typedef VOID (*LINE_OPERATION)(UINTN);

+

+//

+// ARM Processor Mode

+//

+typedef enum {

+  ARM_PROCESSOR_MODE_USER       = 0x10,

+  ARM_PROCESSOR_MODE_FIQ        = 0x11,

+  ARM_PROCESSOR_MODE_IRQ        = 0x12,

+  ARM_PROCESSOR_MODE_SUPERVISOR = 0x13,

+  ARM_PROCESSOR_MODE_ABORT      = 0x17,

+  ARM_PROCESSOR_MODE_HYP        = 0x1A,

+  ARM_PROCESSOR_MODE_UNDEFINED  = 0x1B,

+  ARM_PROCESSOR_MODE_SYSTEM     = 0x1F,

+  ARM_PROCESSOR_MODE_MASK       = 0x1F

+} ARM_PROCESSOR_MODE;

+

+//

+// ARM Cpu IDs

+//

+#define ARM_CPU_IMPLEMENTER_MASK          (0xFFU << 24)

+#define ARM_CPU_IMPLEMENTER_ARMLTD        (0x41U << 24)

+#define ARM_CPU_IMPLEMENTER_DEC           (0x44U << 24)

+#define ARM_CPU_IMPLEMENTER_MOT           (0x4DU << 24)

+#define ARM_CPU_IMPLEMENTER_QUALCOMM      (0x51U << 24)

+#define ARM_CPU_IMPLEMENTER_MARVELL       (0x56U << 24)

+

+#define ARM_CPU_PRIMARY_PART_MASK         (0xFFF << 4)

+#define ARM_CPU_PRIMARY_PART_CORTEXA5     (0xC05 << 4)

+#define ARM_CPU_PRIMARY_PART_CORTEXA7     (0xC07 << 4)

+#define ARM_CPU_PRIMARY_PART_CORTEXA8     (0xC08 << 4)

+#define ARM_CPU_PRIMARY_PART_CORTEXA9     (0xC09 << 4)

+#define ARM_CPU_PRIMARY_PART_CORTEXA15    (0xC0F << 4)

+

+//

+// ARM MP Core IDs

+//

+#define IS_PRIMARY_CORE(MpId) (((MpId) & PcdGet32(PcdArmPrimaryCoreMask)) == PcdGet32(PcdArmPrimaryCore))

+#define ARM_CORE_MASK         0xFF

+#define ARM_CLUSTER_MASK      (0xFF << 8)

+#define GET_CORE_ID(MpId)     ((MpId) & ARM_CORE_MASK)

+#define GET_CLUSTER_ID(MpId)  (((MpId) & ARM_CLUSTER_MASK) >> 8)

+// Get the position of the core for the Stack Offset (4 Core per Cluster)

+//   Position = (ClusterId * 4) + CoreId

+#define GET_CORE_POS(MpId)    ((((MpId) & ARM_CLUSTER_MASK) >> 6) + ((MpId) & ARM_CORE_MASK))

+#define PRIMARY_CORE_ID       (PcdGet32(PcdArmPrimaryCore) & ARM_CORE_MASK)

+

+ARM_CACHE_TYPE

+EFIAPI

+ArmCacheType (

+  VOID

+  );

+

+ARM_CACHE_ARCHITECTURE

+EFIAPI

+ArmCacheArchitecture (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmCacheInformation (

+  OUT ARM_CACHE_INFO  *CacheInfo

+  );

+

+BOOLEAN

+EFIAPI

+ArmDataCachePresent (

+  VOID

+  );

+  

+UINTN

+EFIAPI

+ArmDataCacheSize (

+  VOID

+  );

+  

+UINTN

+EFIAPI

+ArmDataCacheAssociativity (

+  VOID

+  );

+  

+UINTN

+EFIAPI

+ArmDataCacheLineLength (

+  VOID

+  );

+  

+BOOLEAN

+EFIAPI

+ArmInstructionCachePresent (

+  VOID

+  );

+  

+UINTN

+EFIAPI

+ArmInstructionCacheSize (

+  VOID

+  );

+  

+UINTN

+EFIAPI

+ArmInstructionCacheAssociativity (

+  VOID

+  );

+  

+UINTN

+EFIAPI

+ArmInstructionCacheLineLength (

+  VOID

+  );

+  

+UINT32

+EFIAPI

+Cp15IdCode (

+  VOID

+  );

+  

+UINT32

+EFIAPI

+Cp15CacheInfo (

+  VOID

+  );

+

+BOOLEAN

+EFIAPI

+ArmIsMpCore (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmInvalidateDataCache (

+  VOID

+  );

+

+

+VOID

+EFIAPI

+ArmCleanInvalidateDataCache (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmCleanDataCache (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmCleanDataCacheToPoU (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmInvalidateInstructionCache (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmInvalidateDataCacheEntryByMVA (

+  IN  UINTN   Address

+  );

+

+VOID

+EFIAPI

+ArmCleanDataCacheEntryByMVA (

+  IN  UINTN   Address

+  );

+

+VOID

+EFIAPI

+ArmCleanInvalidateDataCacheEntryByMVA (

+  IN  UINTN   Address

+  );

+

+VOID

+EFIAPI

+ArmEnableDataCache (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmDisableDataCache (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmEnableInstructionCache (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmDisableInstructionCache (

+  VOID

+  );

+  

+VOID

+EFIAPI

+ArmEnableMmu (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmDisableMmu (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmDisableCachesAndMmu (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmInvalidateInstructionAndDataTlb (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmEnableInterrupts (

+  VOID

+  );

+

+UINTN

+EFIAPI

+ArmDisableInterrupts (

+  VOID

+  );

+

+BOOLEAN

+EFIAPI

+ArmGetInterruptState (

+  VOID

+  );

+

+UINTN

+EFIAPI

+ArmDisableIrq (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmEnableIrq (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmEnableFiq (

+  VOID

+  );

+

+UINTN

+EFIAPI

+ArmDisableFiq (

+  VOID

+  );

+  

+BOOLEAN

+EFIAPI

+ArmGetFiqState (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmInvalidateTlb (

+  VOID

+  );

+  

+VOID

+EFIAPI

+ArmUpdateTranslationTableEntry (

+  IN  VOID     *TranslationTableEntry,

+  IN  VOID     *Mva

+  );

+  

+VOID

+EFIAPI

+ArmSetDomainAccessControl (

+  IN  UINT32  Domain

+  );

+

+VOID

+EFIAPI

+ArmSetTTBR0 (

+  IN  VOID  *TranslationTableBase

+  );

+

+VOID *

+EFIAPI

+ArmGetTTBR0BaseAddress (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmConfigureMmu (

+  IN  ARM_MEMORY_REGION_DESCRIPTOR  *MemoryTable,

+  OUT VOID                          **TranslationTableBase OPTIONAL,

+  OUT UINTN                         *TranslationTableSize  OPTIONAL

+  );

+  

+BOOLEAN

+EFIAPI

+ArmMmuEnabled (

+  VOID

+  );

+  

+VOID

+EFIAPI

+ArmSwitchProcessorMode (

+  IN ARM_PROCESSOR_MODE Mode

+  );

+

+ARM_PROCESSOR_MODE

+EFIAPI

+ArmProcessorMode (

+  VOID

+  );

+  

+VOID

+EFIAPI

+ArmEnableBranchPrediction (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmDisableBranchPrediction (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmSetLowVectors (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmSetHighVectors (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmDataMemoryBarrier (

+  VOID

+  );

+  

+VOID

+EFIAPI

+ArmDataSyncronizationBarrier (

+  VOID

+  );

+  

+VOID

+EFIAPI

+ArmInstructionSynchronizationBarrier (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmWriteVBar (

+  IN  UINT32   VectorBase

+  );

+

+UINT32

+EFIAPI

+ArmReadVBar (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmWriteAuxCr (

+  IN  UINT32    Bit

+  );

+

+UINT32

+EFIAPI

+ArmReadAuxCr (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmSetAuxCrBit (

+  IN  UINT32    Bits

+  );

+

+VOID

+EFIAPI

+ArmUnsetAuxCrBit (

+  IN  UINT32    Bits

+  );

+

+VOID

+EFIAPI

+ArmCallSEV (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmCallWFE (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmCallWFI (

+  VOID

+  );

+

+UINTN

+EFIAPI

+ArmReadMpidr (

+  VOID

+  );

+

+UINT32

+EFIAPI

+ArmReadCpacr (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmWriteCpacr (

+  IN  UINT32   Access

+  );

+

+VOID

+EFIAPI

+ArmEnableVFP (

+  VOID

+  );

+

+UINT32

+EFIAPI

+ArmReadNsacr (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmWriteNsacr (

+  IN  UINT32   SetWayFormat

+  );

+

+UINT32

+EFIAPI

+ArmReadScr (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmWriteScr (

+  IN  UINT32   SetWayFormat

+  );

+

+UINT32

+EFIAPI

+ArmReadMVBar (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmWriteMVBar (

+  IN  UINT32   VectorMonitorBase

+  );

+

+UINT32

+EFIAPI

+ArmReadSctlr (

+  VOID

+  );

+

+UINTN

+EFIAPI

+ArmReadHVBar (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmWriteHVBar (

+  IN  UINTN   HypModeVectorBase

+  );

+

+#endif // __ARM_LIB__

diff --git a/ArmPlatformPkg/Include/Library/ArmSmcLib.h b/ArmPkg/Include/Library/ArmSmcLib.h
index ff946f2d..ff946f2d 100644
--- a/ArmPlatformPkg/Include/Library/ArmSmcLib.h
+++ b/ArmPkg/Include/Library/ArmSmcLib.h
diff --git a/ArmPkg/Include/Library/ArmV7ArchTimerLib.h b/ArmPkg/Include/Library/ArmV7ArchTimerLib.h
index d2f4a46c..98318481 100644
--- a/ArmPkg/Include/Library/ArmV7ArchTimerLib.h
+++ b/ArmPkg/Include/Library/ArmV7ArchTimerLib.h
@@ -1,115 +1,115 @@
-/** @file
-
-  Copyright (c) 2011, ARM Ltd. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __ARM_V7_ARCH_TIMER_LIB_H__
-#define __ARM_V7_ARCH_TIMER_LIB_H__
-
-#define ARM_ARCH_TIMER_ENABLE           (1 << 0)
-#define ARM_ARCH_TIMER_IMASK            (1 << 1)
-#define ARM_ARCH_TIMER_ISTATUS          (1 << 2)
-
-typedef enum {
-  CntFrq = 0,
-  CntPct,
-  CntkCtl,
-  CntpTval,
-  CntpCtl,
-  CntvTval,
-  CntvCtl,
-  CntvCt,
-  CntpCval,
-  CntvCval,
-  CntvOff,
-  CnthCtl,
-  CnthpTval,
-  CnthpCtl,
-  CnthpCval,
-  RegMaximum
-}ARM_ARCH_TIMER_REGS;
-
-VOID
-EFIAPI
-ArmArchTimerReadReg (
-  IN   ARM_ARCH_TIMER_REGS   Reg,
-  OUT  VOID                  *DstBuf
-  );
-
-VOID
-EFIAPI
-ArmArchTimerWriteReg (
-  IN   ARM_ARCH_TIMER_REGS   Reg,
-  IN   VOID                  *SrcBuf
-  );
-
-VOID
-EFIAPI
-ArmArchTimerEnableTimer (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmArchTimerDisableTimer (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmArchTimerSetTimerFreq (
-  IN   UINTN  FreqInHz
-  );
-
-UINTN
-EFIAPI
-ArmArchTimerGetTimerFreq (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmArchTimerSetTimerVal (
-  IN   UINTN   Val
-  );
-
-UINTN
-EFIAPI
-ArmArchTimerGetTimerVal (
-  VOID
-  );
-
-UINT64
-EFIAPI
-ArmArchTimerGetSystemCount (
-  VOID
-  );
-
-UINTN
-EFIAPI
-ArmArchTimerGetTimerCtrlReg (
-  VOID
-  );
-
-VOID
-EFIAPI
-ArmArchTimerSetTimerCtrlReg (
-  UINTN Val
-  );
-
-VOID
-EFIAPI
-ArmArchTimerSetCompareVal (
-  IN   UINT64   Val
-  );
-
-#endif // __ARM_V7_ARCH_TIMER_LIB_H__
+/** @file

+

+  Copyright (c) 2011, ARM Ltd. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __ARM_V7_ARCH_TIMER_LIB_H__

+#define __ARM_V7_ARCH_TIMER_LIB_H__

+

+#define ARM_ARCH_TIMER_ENABLE           (1 << 0)

+#define ARM_ARCH_TIMER_IMASK            (1 << 1)

+#define ARM_ARCH_TIMER_ISTATUS          (1 << 2)

+

+typedef enum {

+  CntFrq = 0,

+  CntPct,

+  CntkCtl,

+  CntpTval,

+  CntpCtl,

+  CntvTval,

+  CntvCtl,

+  CntvCt,

+  CntpCval,

+  CntvCval,

+  CntvOff,

+  CnthCtl,

+  CnthpTval,

+  CnthpCtl,

+  CnthpCval,

+  RegMaximum

+}ARM_ARCH_TIMER_REGS;

+

+VOID

+EFIAPI

+ArmArchTimerReadReg (

+  IN   ARM_ARCH_TIMER_REGS   Reg,

+  OUT  VOID                  *DstBuf

+  );

+

+VOID

+EFIAPI

+ArmArchTimerWriteReg (

+  IN   ARM_ARCH_TIMER_REGS   Reg,

+  IN   VOID                  *SrcBuf

+  );

+

+VOID

+EFIAPI

+ArmArchTimerEnableTimer (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmArchTimerDisableTimer (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmArchTimerSetTimerFreq (

+  IN   UINTN  FreqInHz

+  );

+

+UINTN

+EFIAPI

+ArmArchTimerGetTimerFreq (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmArchTimerSetTimerVal (

+  IN   UINTN   Val

+  );

+

+UINTN

+EFIAPI

+ArmArchTimerGetTimerVal (

+  VOID

+  );

+

+UINT64

+EFIAPI

+ArmArchTimerGetSystemCount (

+  VOID

+  );

+

+UINTN

+EFIAPI

+ArmArchTimerGetTimerCtrlReg (

+  VOID

+  );

+

+VOID

+EFIAPI

+ArmArchTimerSetTimerCtrlReg (

+  UINTN Val

+  );

+

+VOID

+EFIAPI

+ArmArchTimerSetCompareVal (

+  IN   UINT64   Val

+  );

+

+#endif // __ARM_V7_ARCH_TIMER_LIB_H__

diff --git a/ArmPkg/Include/Library/BdsLib.h b/ArmPkg/Include/Library/BdsLib.h
index c8e02c93..d16748da 100644
--- a/ArmPkg/Include/Library/BdsLib.h
+++ b/ArmPkg/Include/Library/BdsLib.h
@@ -1,14 +1,14 @@
 /** @file

 *

-*  Copyright (c) 2011, ARM Limited. All rights reserved.

-*  

-*  This program and the accompanying materials                          

-*  are licensed and made available under the terms and conditions of the BSD License         

-*  which accompanies this distribution.  The full text of the license may be found at        

-*  http://opensource.org/licenses/bsd-license.php                                            

+*  Copyright (c) 2013, ARM Limited. All rights reserved.

 *

-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*  This program and the accompanying materials

+*  are licensed and made available under the terms and conditions of the BSD License

+*  which accompanies this distribution.  The full text of the license may be found at

+*  http://opensource.org/licenses/bsd-license.php

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

 *

 **/

 

@@ -67,8 +67,17 @@ BdsConnectAllDrivers (
   );

 

 EFI_STATUS

+GetGlobalEnvironmentVariable (

+  IN     CONST CHAR16*   VariableName,

+  IN     VOID*           DefaultValue,

+  IN OUT UINTN*          Size,

+  OUT    VOID**          Value

+  );

+

+EFI_STATUS

 GetEnvironmentVariable (

   IN     CONST CHAR16*   VariableName,

+  IN     EFI_GUID*       VendorGuid,

   IN     VOID*           DefaultValue,

   IN OUT UINTN*          Size,

   OUT    VOID**          Value

diff --git a/ArmPkg/Include/Library/DefaultExceptionHandlerLib.h b/ArmPkg/Include/Library/DefaultExceptionHandlerLib.h
index cf3fe0cc..7166dbb3 100644
--- a/ArmPkg/Include/Library/DefaultExceptionHandlerLib.h
+++ b/ArmPkg/Include/Library/DefaultExceptionHandlerLib.h
@@ -1,31 +1,31 @@
-/** @file
-
-  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __DEFAULT_EXCEPTION_HANDLER_LIB_H__
-#define __DEFAULT_EXCEPTION_HANDLER_LIB_H__
-
-/**
-  This is the default action to take on an unexpected exception
-
-  @param  ExceptionType    Type of the exception
-  @param  SystemContext    Register state at the time of the Exception
-
-**/
-VOID
-DefaultExceptionHandler (
-  IN     EFI_EXCEPTION_TYPE           ExceptionType,
-  IN OUT EFI_SYSTEM_CONTEXT           SystemContext
-  );
-  
-#endif 
+/** @file

+

+  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __DEFAULT_EXCEPTION_HANDLER_LIB_H__

+#define __DEFAULT_EXCEPTION_HANDLER_LIB_H__

+

+/**

+  This is the default action to take on an unexpected exception

+

+  @param  ExceptionType    Type of the exception

+  @param  SystemContext    Register state at the time of the Exception

+

+**/

+VOID

+DefaultExceptionHandler (

+  IN     EFI_EXCEPTION_TYPE           ExceptionType,

+  IN OUT EFI_SYSTEM_CONTEXT           SystemContext

+  );

+  

+#endif 

diff --git a/ArmPkg/Include/Library/SemihostLib.h b/ArmPkg/Include/Library/SemihostLib.h
index 68f4b772..62565517 100644
--- a/ArmPkg/Include/Library/SemihostLib.h
+++ b/ArmPkg/Include/Library/SemihostLib.h
@@ -1,100 +1,101 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __SEMIHOSTING_H__
-#define __SEMIHOSTING_H__
-
-/*
- *
- *  Please refer to ARM RVDS 3.0 Compiler and Libraries Guide for more information
- *  about the semihosting interface.
- *
- */
- 
-#define SEMIHOST_FILE_MODE_READ     (0 << 2)
-#define SEMIHOST_FILE_MODE_WRITE    (1 << 2)
-#define SEMIHOST_FILE_MODE_APPEND   (2 << 2)
-#define SEMIHOST_FILE_MODE_CREATE   (1 << 1)
-#define SEMIHOST_FILE_MODE_BINARY   (1 << 0)
-#define SEMIHOST_FILE_MODE_ASCII    (0 << 0)
-
-BOOLEAN
-SemihostConnectionSupported (
-  VOID
-  );
-
-RETURN_STATUS
-SemihostFileOpen (
-  IN  CHAR8  *FileName,
-  IN  UINT32 Mode,
-  OUT UINT32 *FileHandle
-  );
-
-RETURN_STATUS
-SemihostFileSeek (
-  IN UINT32 FileHandle,
-  IN UINT32 Offset
-  );
-
-RETURN_STATUS
-SemihostFileRead (
-  IN     UINT32 FileHandle,
-  IN OUT UINT32 *Length,
-  OUT    VOID   *Buffer
-  );
-
-RETURN_STATUS
-SemihostFileWrite (
-  IN     UINT32 FileHandle,
-  IN OUT UINT32 *Length,
-  IN     VOID   *Buffer
-  );
-
-RETURN_STATUS
-SemihostFileClose (
-  IN UINT32 FileHandle
-  );
-
-RETURN_STATUS
-SemihostFileLength (
-  IN  UINT32 FileHandle,
-  OUT UINT32 *Length
-  );
-
-RETURN_STATUS
-SemihostFileRemove (
-  IN CHAR8 *FileName
-  );
-
-CHAR8
-SemihostReadCharacter (
-  VOID
-  );
-
-VOID
-SemihostWriteCharacter (
-  IN CHAR8 Character
-  );
-
-VOID
-SemihostWriteString (
-  IN CHAR8 *String
-  );
-  
-UINT32
-SemihostSystem (
-  IN CHAR8 *CommandLine
-  );
-  
-#endif // __SEMIHOSTING_H__
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  Portions copyright (c) 2011, 2012, ARM Ltd. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __SEMIHOSTING_H__

+#define __SEMIHOSTING_H__

+

+/*

+ *

+ *  Please refer to ARM RVDS 3.0 Compiler and Libraries Guide for more information

+ *  about the semihosting interface.

+ *

+ */

+ 

+#define SEMIHOST_FILE_MODE_READ     (0 << 2)

+#define SEMIHOST_FILE_MODE_WRITE    (1 << 2)

+#define SEMIHOST_FILE_MODE_APPEND   (2 << 2)

+#define SEMIHOST_FILE_MODE_CREATE   (1 << 1)

+#define SEMIHOST_FILE_MODE_BINARY   (1 << 0)

+#define SEMIHOST_FILE_MODE_ASCII    (0 << 0)

+

+BOOLEAN

+SemihostConnectionSupported (

+  VOID

+  );

+

+RETURN_STATUS

+SemihostFileOpen (

+  IN  CHAR8  *FileName,

+  IN  UINT32 Mode,

+  OUT UINTN  *FileHandle

+  );

+

+RETURN_STATUS

+SemihostFileSeek (

+  IN UINTN  FileHandle,

+  IN UINTN  Offset

+  );

+

+RETURN_STATUS

+SemihostFileRead (

+  IN     UINTN  FileHandle,

+  IN OUT UINTN  *Length,

+  OUT    VOID   *Buffer

+  );

+

+RETURN_STATUS

+SemihostFileWrite (

+  IN     UINTN  FileHandle,

+  IN OUT UINTN  *Length,

+  IN     VOID   *Buffer

+  );

+

+RETURN_STATUS

+SemihostFileClose (

+  IN UINTN  FileHandle

+  );

+

+RETURN_STATUS

+SemihostFileLength (

+  IN  UINTN  FileHandle,

+  OUT UINTN  *Length

+  );

+

+RETURN_STATUS

+SemihostFileRemove (

+  IN CHAR8 *FileName

+  );

+

+CHAR8

+SemihostReadCharacter (

+  VOID

+  );

+

+VOID

+SemihostWriteCharacter (

+  IN CHAR8 Character

+  );

+

+VOID

+SemihostWriteString (

+  IN CHAR8 *String

+  );

+  

+UINT32

+SemihostSystem (

+  IN CHAR8 *CommandLine

+  );

+  

+#endif // __SEMIHOSTING_H__

diff --git a/ArmPkg/Include/Library/UncachedMemoryAllocationLib.h b/ArmPkg/Include/Library/UncachedMemoryAllocationLib.h
index ac77fbc6..4161fc7c 100644
--- a/ArmPkg/Include/Library/UncachedMemoryAllocationLib.h
+++ b/ArmPkg/Include/Library/UncachedMemoryAllocationLib.h
@@ -1,665 +1,665 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __UNCACHED_MEMORY_ALLOCATION_LIB_H__
-#define __UNCACHED_MEMORY_ALLOCATION_LIB_H__
-
-/**
-  Converts a cached or uncached address to a physical address suitable for use in SoC registers.
-
-  @param  VirtualAddress                 The pointer to convert.
-
-  @return The physical address of the supplied virtual pointer.
-
-**/
-EFI_PHYSICAL_ADDRESS
-ConvertToPhysicalAddress (
-  IN VOID *VirtualAddress
-  );
-
-/**
-  Converts a cached or uncached address to a cached address.
-
-  @param  Address                 The pointer to convert.
-
-  @return The address of the cached memory location corresponding to the input address.
-
-**/
-VOID *
-ConvertToCachedAddress (
-  IN VOID *Address
-  );
-
-/**
-  Converts a cached or uncached address to an uncached address.
-
-  @param  Address                 The pointer to convert.
-
-  @return The address of the uncached memory location corresponding to the input address.
-
-**/
-VOID *
-ConvertToUncachedAddress (
-  IN VOID *Address
-  );
-
-/**
-  Allocates one or more 4KB pages of type EfiBootServicesData.
-
-  Allocates the number of 4KB pages of type EfiBootServicesData and returns a pointer to the
-  allocated buffer.  The buffer returned is aligned on a 4KB boundary.  If Pages is 0, then NULL
-  is returned.  If there is not enough memory remaining to satisfy the request, then NULL is
-  returned.
-
-  @param  Pages                 The number of 4 KB pages to allocate.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID *
-EFIAPI
-UncachedAllocatePages (
-  IN UINTN  Pages
-  );
-
-/**
-  Allocates one or more 4KB pages of type EfiRuntimeServicesData.
-
-  Allocates the number of 4KB pages of type EfiRuntimeServicesData and returns a pointer to the
-  allocated buffer.  The buffer returned is aligned on a 4KB boundary.  If Pages is 0, then NULL
-  is returned.  If there is not enough memory remaining to satisfy the request, then NULL is
-  returned.
-
-  @param  Pages                 The number of 4 KB pages to allocate.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID *
-EFIAPI
-UncachedAllocateRuntimePages (
-  IN UINTN  Pages
-  );
-
-/**
-  Allocates one or more 4KB pages of type EfiReservedMemoryType.
-
-  Allocates the number of 4KB pages of type EfiReservedMemoryType and returns a pointer to the
-  allocated buffer.  The buffer returned is aligned on a 4KB boundary.  If Pages is 0, then NULL
-  is returned.  If there is not enough memory remaining to satisfy the request, then NULL is
-  returned.
-
-  @param  Pages                 The number of 4 KB pages to allocate.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID *
-EFIAPI
-UncachedAllocateReservedPages (
-  IN UINTN  Pages
-  );
-
-/**
-  Frees one or more 4KB pages that were previously allocated with one of the page allocation
-  functions in the Memory Allocation Library.
-
-  Frees the number of 4KB pages specified by Pages from the buffer specified by Buffer.  Buffer
-  must have been allocated on a previous call to the page allocation services of the Memory
-  Allocation Library.
-  If Buffer was not allocated with a page allocation function in the Memory Allocation Library,
-  then ASSERT().
-  If Pages is zero, then ASSERT().
- 
-  @param  Buffer                Pointer to the buffer of pages to free.
-  @param  Pages                 The number of 4 KB pages to free.
-
-**/
-VOID
-EFIAPI
-UncachedFreePages (
-  IN VOID   *Buffer,
-  IN UINTN  Pages
-  );
-
-/**
-  Allocates one or more 4KB pages of type EfiBootServicesData at a specified alignment.
-
-  Allocates the number of 4KB pages specified by Pages of type EfiBootServicesData with an
-  alignment specified by Alignment.  The allocated buffer is returned.  If Pages is 0, then NULL is
-  returned.  If there is not enough memory at the specified alignment remaining to satisfy the
-  request, then NULL is returned.
-  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
-
-  @param  Pages                 The number of 4 KB pages to allocate.
-  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.
-                                If Alignment is zero, then byte alignment is used.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID *
-EFIAPI
-UncachedAllocateAlignedPages (
-  IN UINTN  Pages,
-  IN UINTN  Alignment
-  );
-
-/**
-  Allocates one or more 4KB pages of type EfiRuntimeServicesData at a specified alignment.
-
-  Allocates the number of 4KB pages specified by Pages of type EfiRuntimeServicesData with an
-  alignment specified by Alignment.  The allocated buffer is returned.  If Pages is 0, then NULL is
-  returned.  If there is not enough memory at the specified alignment remaining to satisfy the
-  request, then NULL is returned.
-  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
-
-  @param  Pages                 The number of 4 KB pages to allocate.
-  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.
-                                If Alignment is zero, then byte alignment is used.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID *
-EFIAPI
-UncachedAllocateAlignedRuntimePages (
-  IN UINTN  Pages,
-  IN UINTN  Alignment
-  );
-
-/**
-  Allocates one or more 4KB pages of type EfiReservedMemoryType at a specified alignment.
-
-  Allocates the number of 4KB pages specified by Pages of type EfiReservedMemoryType with an
-  alignment specified by Alignment.  The allocated buffer is returned.  If Pages is 0, then NULL is
-  returned.  If there is not enough memory at the specified alignment remaining to satisfy the
-  request, then NULL is returned.
-  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
-
-  @param  Pages                 The number of 4 KB pages to allocate.
-  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.
-                                If Alignment is zero, then byte alignment is used.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID *
-EFIAPI
-UncachedAllocateAlignedReservedPages (
-  IN UINTN  Pages,
-  IN UINTN  Alignment
-  );
-
-/**
-  Frees one or more 4KB pages that were previously allocated with one of the aligned page
-  allocation functions in the Memory Allocation Library.
-
-  Frees the number of 4KB pages specified by Pages from the buffer specified by Buffer.  Buffer
-  must have been allocated on a previous call to the aligned page allocation services of the Memory
-  Allocation Library.
-  If Buffer was not allocated with an aligned page allocation function in the Memory Allocation
-  Library, then ASSERT().
-  If Pages is zero, then ASSERT().
-  
-  @param  Buffer                Pointer to the buffer of pages to free.
-  @param  Pages                 The number of 4 KB pages to free.
-
-**/
-VOID
-EFIAPI
-UncachedFreeAlignedPages (
-  IN VOID   *Buffer,
-  IN UINTN  Pages
-  );
-
-/**
-  Allocates a buffer of type EfiBootServicesData.
-
-  Allocates the number bytes specified by AllocationSize of type EfiBootServicesData and returns a
-  pointer to the allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is
-  returned.  If there is not enough memory remaining to satisfy the request, then NULL is returned.
-
-  @param  AllocationSize        The number of bytes to allocate.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID *
-EFIAPI
-UncachedAllocatePool (
-  IN UINTN  AllocationSize
-  );
-
-/**
-  Allocates a buffer of type EfiRuntimeServicesData.
-
-  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData and returns
-  a pointer to the allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is
-  returned.  If there is not enough memory remaining to satisfy the request, then NULL is returned.
-
-  @param  AllocationSize        The number of bytes to allocate.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID *
-EFIAPI
-UncachedAllocateRuntimePool (
-  IN UINTN  AllocationSize
-  );
-
-/**
-  Allocates a buffer of type EfieservedMemoryType.
-
-  Allocates the number bytes specified by AllocationSize of type EfieservedMemoryType and returns
-  a pointer to the allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is
-  returned.  If there is not enough memory remaining to satisfy the request, then NULL is returned.
-
-  @param  AllocationSize        The number of bytes to allocate.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID *
-EFIAPI
-UncachedAllocateReservedPool (
-  IN UINTN  AllocationSize
-  );
-
-/**
-  Allocates and zeros a buffer of type EfiBootServicesData.
-
-  Allocates the number bytes specified by AllocationSize of type EfiBootServicesData, clears the
-  buffer with zeros, and returns a pointer to the allocated buffer.  If AllocationSize is 0, then a
-  valid buffer of 0 size is returned.  If there is not enough memory remaining to satisfy the
-  request, then NULL is returned.
-
-  @param  AllocationSize        The number of bytes to allocate and zero.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID *
-EFIAPI
-UncachedAllocateZeroPool (
-  IN UINTN  AllocationSize
-  );
-
-/**
-  Allocates and zeros a buffer of type EfiRuntimeServicesData.
-
-  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData, clears the
-  buffer with zeros, and returns a pointer to the allocated buffer.  If AllocationSize is 0, then a
-  valid buffer of 0 size is returned.  If there is not enough memory remaining to satisfy the
-  request, then NULL is returned.
-
-  @param  AllocationSize        The number of bytes to allocate and zero.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID *
-EFIAPI
-UncachedAllocateRuntimeZeroPool (
-  IN UINTN  AllocationSize
-  );
-
-/**
-  Allocates and zeros a buffer of type EfiReservedMemoryType.
-
-  Allocates the number bytes specified by AllocationSize of type EfiReservedMemoryType, clears the
-  buffer with zeros, and returns a pointer to the allocated buffer.  If AllocationSize is 0, then a
-  valid buffer of 0 size is returned.  If there is not enough memory remaining to satisfy the
-  request, then NULL is returned.
-
-  @param  AllocationSize        The number of bytes to allocate and zero.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID *
-EFIAPI
-UncachedAllocateReservedZeroPool (
-  IN UINTN  AllocationSize
-  );
-
-/**
-  Copies a buffer to an allocated buffer of type EfiBootServicesData.
-
-  Allocates the number bytes specified by AllocationSize of type EfiBootServicesData, copies
-  AllocationSize bytes from Buffer to the newly allocated buffer, and returns a pointer to the
-  allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there
-  is not enough memory remaining to satisfy the request, then NULL is returned.
-  If Buffer is NULL, then ASSERT().
-  If AllocationSize is greater than (MAX_ADDRESS ? Buffer + 1), then ASSERT(). 
-
-  @param  AllocationSize        The number of bytes to allocate and zero.
-  @param  Buffer                The buffer to copy to the allocated buffer.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID *
-EFIAPI
-UncachedAllocateCopyPool (
-  IN UINTN       AllocationSize,
-  IN CONST VOID  *Buffer
-  );
-
-/**
-  Copies a buffer to an allocated buffer of type EfiRuntimeServicesData.
-
-  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData, copies
-  AllocationSize bytes from Buffer to the newly allocated buffer, and returns a pointer to the
-  allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there
-  is not enough memory remaining to satisfy the request, then NULL is returned.
-  If Buffer is NULL, then ASSERT().
-  If AllocationSize is greater than (MAX_ADDRESS ? Buffer + 1), then ASSERT(). 
-
-  @param  AllocationSize        The number of bytes to allocate and zero.
-  @param  Buffer                The buffer to copy to the allocated buffer.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID *
-EFIAPI
-UncachedAllocateRuntimeCopyPool (
-  IN UINTN       AllocationSize,
-  IN CONST VOID  *Buffer
-  );
-
-/**
-  Copies a buffer to an allocated buffer of type EfiReservedMemoryType.
-
-  Allocates the number bytes specified by AllocationSize of type EfiReservedMemoryType, copies
-  AllocationSize bytes from Buffer to the newly allocated buffer, and returns a pointer to the
-  allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there
-  is not enough memory remaining to satisfy the request, then NULL is returned.
-  If Buffer is NULL, then ASSERT().
-  If AllocationSize is greater than (MAX_ADDRESS ? Buffer + 1), then ASSERT(). 
-
-  @param  AllocationSize        The number of bytes to allocate and zero.
-  @param  Buffer                The buffer to copy to the allocated buffer.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID *
-EFIAPI
-UncachedAllocateReservedCopyPool (
-  IN UINTN       AllocationSize,
-  IN CONST VOID  *Buffer
-  );
-
-/**
-  Frees a buffer that was previously allocated with one of the pool allocation functions in the
-  Memory Allocation Library.
-
-  Frees the buffer specified by Buffer.  Buffer must have been allocated on a previous call to the
-  pool allocation services of the Memory Allocation Library.
-  If Buffer was not allocated with a pool allocation function in the Memory Allocation Library,
-  then ASSERT().
-
-  @param  Buffer                Pointer to the buffer to free.
-
-**/
-VOID
-EFIAPI
-UncachedFreePool (
-  IN VOID   *Buffer
-  );
-
-/**
-  Allocates a buffer of type EfiBootServicesData at a specified alignment.
-
-  Allocates the number bytes specified by AllocationSize of type EfiBootServicesData with an
-  alignment specified by Alignment.  The allocated buffer is returned.  If AllocationSize is 0,
-  then a valid buffer of 0 size is returned.  If there is not enough memory at the specified
-  alignment remaining to satisfy the request, then NULL is returned.
-  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
-
-  @param  AllocationSize        The number of bytes to allocate.
-  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.
-                                If Alignment is zero, then byte alignment is used.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID *
-EFIAPI
-UncachedAllocateAlignedPool (
-  IN UINTN  AllocationSize,
-  IN UINTN  Alignment
-  );
-
-/**
-  Allocates a buffer of type EfiRuntimeServicesData at a specified alignment.
-
-  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData with an
-  alignment specified by Alignment.  The allocated buffer is returned.  If AllocationSize is 0,
-  then a valid buffer of 0 size is returned.  If there is not enough memory at the specified
-  alignment remaining to satisfy the request, then NULL is returned.
-  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
-
-  @param  AllocationSize        The number of bytes to allocate.
-  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.
-                                If Alignment is zero, then byte alignment is used.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID *
-EFIAPI
-UncachedAllocateAlignedRuntimePool (
-  IN UINTN  AllocationSize,
-  IN UINTN  Alignment
-  );
-
-/**
-  Allocates a buffer of type EfieservedMemoryType at a specified alignment.
-
-  Allocates the number bytes specified by AllocationSize of type EfieservedMemoryType with an
-  alignment specified by Alignment.  The allocated buffer is returned.  If AllocationSize is 0,
-  then a valid buffer of 0 size is returned.  If there is not enough memory at the specified
-  alignment remaining to satisfy the request, then NULL is returned.
-  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
-
-  @param  AllocationSize        The number of bytes to allocate.
-  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.
-                                If Alignment is zero, then byte alignment is used.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID *
-EFIAPI
-UncachedAllocateAlignedReservedPool (
-  IN UINTN  AllocationSize,
-  IN UINTN  Alignment
-  );
-
-/**
-  Allocates and zeros a buffer of type EfiBootServicesData at a specified alignment.
-
-  Allocates the number bytes specified by AllocationSize of type EfiBootServicesData with an
-  alignment specified by Alignment, clears the buffer with zeros, and returns a pointer to the
-  allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there
-  is not enough memory at the specified alignment remaining to satisfy the request, then NULL is
-  returned.
-  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
-
-  @param  AllocationSize        The number of bytes to allocate.
-  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.
-                                If Alignment is zero, then byte alignment is used.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID *
-EFIAPI
-UncachedAllocateAlignedZeroPool (
-  IN UINTN  AllocationSize,
-  IN UINTN  Alignment
-  );
-
-/**
-  Allocates and zeros a buffer of type EfiRuntimeServicesData at a specified alignment.
-
-  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData with an
-  alignment specified by Alignment, clears the buffer with zeros, and returns a pointer to the
-  allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there
-  is not enough memory at the specified alignment remaining to satisfy the request, then NULL is
-  returned.
-  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
-
-  @param  AllocationSize        The number of bytes to allocate.
-  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.
-                                If Alignment is zero, then byte alignment is used.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID *
-EFIAPI
-UncachedAllocateAlignedRuntimeZeroPool (
-  IN UINTN  AllocationSize,
-  IN UINTN  Alignment
-  );
-
-/**
-  Allocates and zeros a buffer of type EfieservedMemoryType at a specified alignment.
-
-  Allocates the number bytes specified by AllocationSize of type EfieservedMemoryType with an
-  alignment specified by Alignment, clears the buffer with zeros, and returns a pointer to the
-  allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there
-  is not enough memory at the specified alignment remaining to satisfy the request, then NULL is
-  returned.
-  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
-
-  @param  AllocationSize        The number of bytes to allocate.
-  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.
-                                If Alignment is zero, then byte alignment is used.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID *
-EFIAPI
-UncachedAllocateAlignedReservedZeroPool (
-  IN UINTN  AllocationSize,
-  IN UINTN  Alignment
-  );
-
-/**
-  Copies a buffer to an allocated buffer of type EfiBootServicesData at a specified alignment.
-
-  Allocates the number bytes specified by AllocationSize of type EfiBootServicesData type with an
-  alignment specified by Alignment.  The allocated buffer is returned.  If AllocationSize is 0,
-  then a valid buffer of 0 size is returned.  If there is not enough memory at the specified
-  alignment remaining to satisfy the request, then NULL is returned.
-  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
-
-  @param  AllocationSize        The number of bytes to allocate.
-  @param  Buffer                The buffer to copy to the allocated buffer.
-  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.
-                                If Alignment is zero, then byte alignment is used.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID *
-EFIAPI
-UncachedAllocateAlignedCopyPool (
-  IN UINTN       AllocationSize,
-  IN CONST VOID  *Buffer,
-  IN UINTN       Alignment
-  );
-
-/**
-  Copies a buffer to an allocated buffer of type EfiRuntimeServicesData at a specified alignment.
-
-  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData type with an
-  alignment specified by Alignment.  The allocated buffer is returned.  If AllocationSize is 0,
-  then a valid buffer of 0 size is returned.  If there is not enough memory at the specified
-  alignment remaining to satisfy the request, then NULL is returned.
-  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
-
-  @param  AllocationSize        The number of bytes to allocate.
-  @param  Buffer                The buffer to copy to the allocated buffer.
-  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.
-                                If Alignment is zero, then byte alignment is used.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID *
-EFIAPI
-UncachedAllocateAlignedRuntimeCopyPool (
-  IN UINTN       AllocationSize,
-  IN CONST VOID  *Buffer,
-  IN UINTN       Alignment
-  );
-
-/**
-  Copies a buffer to an allocated buffer of type EfiReservedMemoryType at a specified alignment.
-
-  Allocates the number bytes specified by AllocationSize of type EfiReservedMemoryType type with an
-  alignment specified by Alignment.  The allocated buffer is returned.  If AllocationSize is 0,
-  then a valid buffer of 0 size is returned.  If there is not enough memory at the specified
-  alignment remaining to satisfy the request, then NULL is returned.
-  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
-
-  @param  AllocationSize        The number of bytes to allocate.
-  @param  Buffer                The buffer to copy to the allocated buffer.
-  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.
-                                If Alignment is zero, then byte alignment is used.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID *
-EFIAPI
-UncachedAllocateAlignedReservedCopyPool (
-  IN UINTN       AllocationSize,
-  IN CONST VOID  *Buffer,
-  IN UINTN       Alignment
-  );
-
-/**
-  Frees a buffer that was previously allocated with one of the aligned pool allocation functions 
-  in the Memory Allocation Library.
-
-  Frees the buffer specified by Buffer.  Buffer must have been allocated on a previous call to the
-  aligned pool allocation services of the Memory Allocation Library.
-  If Buffer was not allocated with an aligned pool allocation function in the Memory Allocation
-  Library, then ASSERT().
-
-  @param  Buffer                Pointer to the buffer to free.
-
-**/
-VOID
-EFIAPI
-UncachedFreeAlignedPool (
-  IN VOID   *Buffer
-  );
-
-VOID
-EFIAPI
-UncachedSafeFreePool (
-  IN VOID   *Buffer
-  );
-
-#endif // __UNCACHED_MEMORY_ALLOCATION_LIB_H__
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __UNCACHED_MEMORY_ALLOCATION_LIB_H__

+#define __UNCACHED_MEMORY_ALLOCATION_LIB_H__

+

+/**

+  Converts a cached or uncached address to a physical address suitable for use in SoC registers.

+

+  @param  VirtualAddress                 The pointer to convert.

+

+  @return The physical address of the supplied virtual pointer.

+

+**/

+EFI_PHYSICAL_ADDRESS

+ConvertToPhysicalAddress (

+  IN VOID *VirtualAddress

+  );

+

+/**

+  Converts a cached or uncached address to a cached address.

+

+  @param  Address                 The pointer to convert.

+

+  @return The address of the cached memory location corresponding to the input address.

+

+**/

+VOID *

+ConvertToCachedAddress (

+  IN VOID *Address

+  );

+

+/**

+  Converts a cached or uncached address to an uncached address.

+

+  @param  Address                 The pointer to convert.

+

+  @return The address of the uncached memory location corresponding to the input address.

+

+**/

+VOID *

+ConvertToUncachedAddress (

+  IN VOID *Address

+  );

+

+/**

+  Allocates one or more 4KB pages of type EfiBootServicesData.

+

+  Allocates the number of 4KB pages of type EfiBootServicesData and returns a pointer to the

+  allocated buffer.  The buffer returned is aligned on a 4KB boundary.  If Pages is 0, then NULL

+  is returned.  If there is not enough memory remaining to satisfy the request, then NULL is

+  returned.

+

+  @param  Pages                 The number of 4 KB pages to allocate.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID *

+EFIAPI

+UncachedAllocatePages (

+  IN UINTN  Pages

+  );

+

+/**

+  Allocates one or more 4KB pages of type EfiRuntimeServicesData.

+

+  Allocates the number of 4KB pages of type EfiRuntimeServicesData and returns a pointer to the

+  allocated buffer.  The buffer returned is aligned on a 4KB boundary.  If Pages is 0, then NULL

+  is returned.  If there is not enough memory remaining to satisfy the request, then NULL is

+  returned.

+

+  @param  Pages                 The number of 4 KB pages to allocate.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID *

+EFIAPI

+UncachedAllocateRuntimePages (

+  IN UINTN  Pages

+  );

+

+/**

+  Allocates one or more 4KB pages of type EfiReservedMemoryType.

+

+  Allocates the number of 4KB pages of type EfiReservedMemoryType and returns a pointer to the

+  allocated buffer.  The buffer returned is aligned on a 4KB boundary.  If Pages is 0, then NULL

+  is returned.  If there is not enough memory remaining to satisfy the request, then NULL is

+  returned.

+

+  @param  Pages                 The number of 4 KB pages to allocate.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID *

+EFIAPI

+UncachedAllocateReservedPages (

+  IN UINTN  Pages

+  );

+

+/**

+  Frees one or more 4KB pages that were previously allocated with one of the page allocation

+  functions in the Memory Allocation Library.

+

+  Frees the number of 4KB pages specified by Pages from the buffer specified by Buffer.  Buffer

+  must have been allocated on a previous call to the page allocation services of the Memory

+  Allocation Library.

+  If Buffer was not allocated with a page allocation function in the Memory Allocation Library,

+  then ASSERT().

+  If Pages is zero, then ASSERT().

+ 

+  @param  Buffer                Pointer to the buffer of pages to free.

+  @param  Pages                 The number of 4 KB pages to free.

+

+**/

+VOID

+EFIAPI

+UncachedFreePages (

+  IN VOID   *Buffer,

+  IN UINTN  Pages

+  );

+

+/**

+  Allocates one or more 4KB pages of type EfiBootServicesData at a specified alignment.

+

+  Allocates the number of 4KB pages specified by Pages of type EfiBootServicesData with an

+  alignment specified by Alignment.  The allocated buffer is returned.  If Pages is 0, then NULL is

+  returned.  If there is not enough memory at the specified alignment remaining to satisfy the

+  request, then NULL is returned.

+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().

+

+  @param  Pages                 The number of 4 KB pages to allocate.

+  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.

+                                If Alignment is zero, then byte alignment is used.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID *

+EFIAPI

+UncachedAllocateAlignedPages (

+  IN UINTN  Pages,

+  IN UINTN  Alignment

+  );

+

+/**

+  Allocates one or more 4KB pages of type EfiRuntimeServicesData at a specified alignment.

+

+  Allocates the number of 4KB pages specified by Pages of type EfiRuntimeServicesData with an

+  alignment specified by Alignment.  The allocated buffer is returned.  If Pages is 0, then NULL is

+  returned.  If there is not enough memory at the specified alignment remaining to satisfy the

+  request, then NULL is returned.

+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().

+

+  @param  Pages                 The number of 4 KB pages to allocate.

+  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.

+                                If Alignment is zero, then byte alignment is used.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID *

+EFIAPI

+UncachedAllocateAlignedRuntimePages (

+  IN UINTN  Pages,

+  IN UINTN  Alignment

+  );

+

+/**

+  Allocates one or more 4KB pages of type EfiReservedMemoryType at a specified alignment.

+

+  Allocates the number of 4KB pages specified by Pages of type EfiReservedMemoryType with an

+  alignment specified by Alignment.  The allocated buffer is returned.  If Pages is 0, then NULL is

+  returned.  If there is not enough memory at the specified alignment remaining to satisfy the

+  request, then NULL is returned.

+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().

+

+  @param  Pages                 The number of 4 KB pages to allocate.

+  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.

+                                If Alignment is zero, then byte alignment is used.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID *

+EFIAPI

+UncachedAllocateAlignedReservedPages (

+  IN UINTN  Pages,

+  IN UINTN  Alignment

+  );

+

+/**

+  Frees one or more 4KB pages that were previously allocated with one of the aligned page

+  allocation functions in the Memory Allocation Library.

+

+  Frees the number of 4KB pages specified by Pages from the buffer specified by Buffer.  Buffer

+  must have been allocated on a previous call to the aligned page allocation services of the Memory

+  Allocation Library.

+  If Buffer was not allocated with an aligned page allocation function in the Memory Allocation

+  Library, then ASSERT().

+  If Pages is zero, then ASSERT().

+  

+  @param  Buffer                Pointer to the buffer of pages to free.

+  @param  Pages                 The number of 4 KB pages to free.

+

+**/

+VOID

+EFIAPI

+UncachedFreeAlignedPages (

+  IN VOID   *Buffer,

+  IN UINTN  Pages

+  );

+

+/**

+  Allocates a buffer of type EfiBootServicesData.

+

+  Allocates the number bytes specified by AllocationSize of type EfiBootServicesData and returns a

+  pointer to the allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is

+  returned.  If there is not enough memory remaining to satisfy the request, then NULL is returned.

+

+  @param  AllocationSize        The number of bytes to allocate.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID *

+EFIAPI

+UncachedAllocatePool (

+  IN UINTN  AllocationSize

+  );

+

+/**

+  Allocates a buffer of type EfiRuntimeServicesData.

+

+  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData and returns

+  a pointer to the allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is

+  returned.  If there is not enough memory remaining to satisfy the request, then NULL is returned.

+

+  @param  AllocationSize        The number of bytes to allocate.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID *

+EFIAPI

+UncachedAllocateRuntimePool (

+  IN UINTN  AllocationSize

+  );

+

+/**

+  Allocates a buffer of type EfieservedMemoryType.

+

+  Allocates the number bytes specified by AllocationSize of type EfieservedMemoryType and returns

+  a pointer to the allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is

+  returned.  If there is not enough memory remaining to satisfy the request, then NULL is returned.

+

+  @param  AllocationSize        The number of bytes to allocate.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID *

+EFIAPI

+UncachedAllocateReservedPool (

+  IN UINTN  AllocationSize

+  );

+

+/**

+  Allocates and zeros a buffer of type EfiBootServicesData.

+

+  Allocates the number bytes specified by AllocationSize of type EfiBootServicesData, clears the

+  buffer with zeros, and returns a pointer to the allocated buffer.  If AllocationSize is 0, then a

+  valid buffer of 0 size is returned.  If there is not enough memory remaining to satisfy the

+  request, then NULL is returned.

+

+  @param  AllocationSize        The number of bytes to allocate and zero.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID *

+EFIAPI

+UncachedAllocateZeroPool (

+  IN UINTN  AllocationSize

+  );

+

+/**

+  Allocates and zeros a buffer of type EfiRuntimeServicesData.

+

+  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData, clears the

+  buffer with zeros, and returns a pointer to the allocated buffer.  If AllocationSize is 0, then a

+  valid buffer of 0 size is returned.  If there is not enough memory remaining to satisfy the

+  request, then NULL is returned.

+

+  @param  AllocationSize        The number of bytes to allocate and zero.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID *

+EFIAPI

+UncachedAllocateRuntimeZeroPool (

+  IN UINTN  AllocationSize

+  );

+

+/**

+  Allocates and zeros a buffer of type EfiReservedMemoryType.

+

+  Allocates the number bytes specified by AllocationSize of type EfiReservedMemoryType, clears the

+  buffer with zeros, and returns a pointer to the allocated buffer.  If AllocationSize is 0, then a

+  valid buffer of 0 size is returned.  If there is not enough memory remaining to satisfy the

+  request, then NULL is returned.

+

+  @param  AllocationSize        The number of bytes to allocate and zero.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID *

+EFIAPI

+UncachedAllocateReservedZeroPool (

+  IN UINTN  AllocationSize

+  );

+

+/**

+  Copies a buffer to an allocated buffer of type EfiBootServicesData.

+

+  Allocates the number bytes specified by AllocationSize of type EfiBootServicesData, copies

+  AllocationSize bytes from Buffer to the newly allocated buffer, and returns a pointer to the

+  allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there

+  is not enough memory remaining to satisfy the request, then NULL is returned.

+  If Buffer is NULL, then ASSERT().

+  If AllocationSize is greater than (MAX_ADDRESS ? Buffer + 1), then ASSERT(). 

+

+  @param  AllocationSize        The number of bytes to allocate and zero.

+  @param  Buffer                The buffer to copy to the allocated buffer.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID *

+EFIAPI

+UncachedAllocateCopyPool (

+  IN UINTN       AllocationSize,

+  IN CONST VOID  *Buffer

+  );

+

+/**

+  Copies a buffer to an allocated buffer of type EfiRuntimeServicesData.

+

+  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData, copies

+  AllocationSize bytes from Buffer to the newly allocated buffer, and returns a pointer to the

+  allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there

+  is not enough memory remaining to satisfy the request, then NULL is returned.

+  If Buffer is NULL, then ASSERT().

+  If AllocationSize is greater than (MAX_ADDRESS ? Buffer + 1), then ASSERT(). 

+

+  @param  AllocationSize        The number of bytes to allocate and zero.

+  @param  Buffer                The buffer to copy to the allocated buffer.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID *

+EFIAPI

+UncachedAllocateRuntimeCopyPool (

+  IN UINTN       AllocationSize,

+  IN CONST VOID  *Buffer

+  );

+

+/**

+  Copies a buffer to an allocated buffer of type EfiReservedMemoryType.

+

+  Allocates the number bytes specified by AllocationSize of type EfiReservedMemoryType, copies

+  AllocationSize bytes from Buffer to the newly allocated buffer, and returns a pointer to the

+  allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there

+  is not enough memory remaining to satisfy the request, then NULL is returned.

+  If Buffer is NULL, then ASSERT().

+  If AllocationSize is greater than (MAX_ADDRESS ? Buffer + 1), then ASSERT(). 

+

+  @param  AllocationSize        The number of bytes to allocate and zero.

+  @param  Buffer                The buffer to copy to the allocated buffer.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID *

+EFIAPI

+UncachedAllocateReservedCopyPool (

+  IN UINTN       AllocationSize,

+  IN CONST VOID  *Buffer

+  );

+

+/**

+  Frees a buffer that was previously allocated with one of the pool allocation functions in the

+  Memory Allocation Library.

+

+  Frees the buffer specified by Buffer.  Buffer must have been allocated on a previous call to the

+  pool allocation services of the Memory Allocation Library.

+  If Buffer was not allocated with a pool allocation function in the Memory Allocation Library,

+  then ASSERT().

+

+  @param  Buffer                Pointer to the buffer to free.

+

+**/

+VOID

+EFIAPI

+UncachedFreePool (

+  IN VOID   *Buffer

+  );

+

+/**

+  Allocates a buffer of type EfiBootServicesData at a specified alignment.

+

+  Allocates the number bytes specified by AllocationSize of type EfiBootServicesData with an

+  alignment specified by Alignment.  The allocated buffer is returned.  If AllocationSize is 0,

+  then a valid buffer of 0 size is returned.  If there is not enough memory at the specified

+  alignment remaining to satisfy the request, then NULL is returned.

+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().

+

+  @param  AllocationSize        The number of bytes to allocate.

+  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.

+                                If Alignment is zero, then byte alignment is used.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID *

+EFIAPI

+UncachedAllocateAlignedPool (

+  IN UINTN  AllocationSize,

+  IN UINTN  Alignment

+  );

+

+/**

+  Allocates a buffer of type EfiRuntimeServicesData at a specified alignment.

+

+  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData with an

+  alignment specified by Alignment.  The allocated buffer is returned.  If AllocationSize is 0,

+  then a valid buffer of 0 size is returned.  If there is not enough memory at the specified

+  alignment remaining to satisfy the request, then NULL is returned.

+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().

+

+  @param  AllocationSize        The number of bytes to allocate.

+  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.

+                                If Alignment is zero, then byte alignment is used.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID *

+EFIAPI

+UncachedAllocateAlignedRuntimePool (

+  IN UINTN  AllocationSize,

+  IN UINTN  Alignment

+  );

+

+/**

+  Allocates a buffer of type EfieservedMemoryType at a specified alignment.

+

+  Allocates the number bytes specified by AllocationSize of type EfieservedMemoryType with an

+  alignment specified by Alignment.  The allocated buffer is returned.  If AllocationSize is 0,

+  then a valid buffer of 0 size is returned.  If there is not enough memory at the specified

+  alignment remaining to satisfy the request, then NULL is returned.

+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().

+

+  @param  AllocationSize        The number of bytes to allocate.

+  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.

+                                If Alignment is zero, then byte alignment is used.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID *

+EFIAPI

+UncachedAllocateAlignedReservedPool (

+  IN UINTN  AllocationSize,

+  IN UINTN  Alignment

+  );

+

+/**

+  Allocates and zeros a buffer of type EfiBootServicesData at a specified alignment.

+

+  Allocates the number bytes specified by AllocationSize of type EfiBootServicesData with an

+  alignment specified by Alignment, clears the buffer with zeros, and returns a pointer to the

+  allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there

+  is not enough memory at the specified alignment remaining to satisfy the request, then NULL is

+  returned.

+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().

+

+  @param  AllocationSize        The number of bytes to allocate.

+  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.

+                                If Alignment is zero, then byte alignment is used.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID *

+EFIAPI

+UncachedAllocateAlignedZeroPool (

+  IN UINTN  AllocationSize,

+  IN UINTN  Alignment

+  );

+

+/**

+  Allocates and zeros a buffer of type EfiRuntimeServicesData at a specified alignment.

+

+  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData with an

+  alignment specified by Alignment, clears the buffer with zeros, and returns a pointer to the

+  allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there

+  is not enough memory at the specified alignment remaining to satisfy the request, then NULL is

+  returned.

+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().

+

+  @param  AllocationSize        The number of bytes to allocate.

+  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.

+                                If Alignment is zero, then byte alignment is used.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID *

+EFIAPI

+UncachedAllocateAlignedRuntimeZeroPool (

+  IN UINTN  AllocationSize,

+  IN UINTN  Alignment

+  );

+

+/**

+  Allocates and zeros a buffer of type EfieservedMemoryType at a specified alignment.

+

+  Allocates the number bytes specified by AllocationSize of type EfieservedMemoryType with an

+  alignment specified by Alignment, clears the buffer with zeros, and returns a pointer to the

+  allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is returned.  If there

+  is not enough memory at the specified alignment remaining to satisfy the request, then NULL is

+  returned.

+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().

+

+  @param  AllocationSize        The number of bytes to allocate.

+  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.

+                                If Alignment is zero, then byte alignment is used.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID *

+EFIAPI

+UncachedAllocateAlignedReservedZeroPool (

+  IN UINTN  AllocationSize,

+  IN UINTN  Alignment

+  );

+

+/**

+  Copies a buffer to an allocated buffer of type EfiBootServicesData at a specified alignment.

+

+  Allocates the number bytes specified by AllocationSize of type EfiBootServicesData type with an

+  alignment specified by Alignment.  The allocated buffer is returned.  If AllocationSize is 0,

+  then a valid buffer of 0 size is returned.  If there is not enough memory at the specified

+  alignment remaining to satisfy the request, then NULL is returned.

+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().

+

+  @param  AllocationSize        The number of bytes to allocate.

+  @param  Buffer                The buffer to copy to the allocated buffer.

+  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.

+                                If Alignment is zero, then byte alignment is used.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID *

+EFIAPI

+UncachedAllocateAlignedCopyPool (

+  IN UINTN       AllocationSize,

+  IN CONST VOID  *Buffer,

+  IN UINTN       Alignment

+  );

+

+/**

+  Copies a buffer to an allocated buffer of type EfiRuntimeServicesData at a specified alignment.

+

+  Allocates the number bytes specified by AllocationSize of type EfiRuntimeServicesData type with an

+  alignment specified by Alignment.  The allocated buffer is returned.  If AllocationSize is 0,

+  then a valid buffer of 0 size is returned.  If there is not enough memory at the specified

+  alignment remaining to satisfy the request, then NULL is returned.

+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().

+

+  @param  AllocationSize        The number of bytes to allocate.

+  @param  Buffer                The buffer to copy to the allocated buffer.

+  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.

+                                If Alignment is zero, then byte alignment is used.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID *

+EFIAPI

+UncachedAllocateAlignedRuntimeCopyPool (

+  IN UINTN       AllocationSize,

+  IN CONST VOID  *Buffer,

+  IN UINTN       Alignment

+  );

+

+/**

+  Copies a buffer to an allocated buffer of type EfiReservedMemoryType at a specified alignment.

+

+  Allocates the number bytes specified by AllocationSize of type EfiReservedMemoryType type with an

+  alignment specified by Alignment.  The allocated buffer is returned.  If AllocationSize is 0,

+  then a valid buffer of 0 size is returned.  If there is not enough memory at the specified

+  alignment remaining to satisfy the request, then NULL is returned.

+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().

+

+  @param  AllocationSize        The number of bytes to allocate.

+  @param  Buffer                The buffer to copy to the allocated buffer.

+  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.

+                                If Alignment is zero, then byte alignment is used.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID *

+EFIAPI

+UncachedAllocateAlignedReservedCopyPool (

+  IN UINTN       AllocationSize,

+  IN CONST VOID  *Buffer,

+  IN UINTN       Alignment

+  );

+

+/**

+  Frees a buffer that was previously allocated with one of the aligned pool allocation functions 

+  in the Memory Allocation Library.

+

+  Frees the buffer specified by Buffer.  Buffer must have been allocated on a previous call to the

+  aligned pool allocation services of the Memory Allocation Library.

+  If Buffer was not allocated with an aligned pool allocation function in the Memory Allocation

+  Library, then ASSERT().

+

+  @param  Buffer                Pointer to the buffer to free.

+

+**/

+VOID

+EFIAPI

+UncachedFreeAlignedPool (

+  IN VOID   *Buffer

+  );

+

+VOID

+EFIAPI

+UncachedSafeFreePool (

+  IN VOID   *Buffer

+  );

+

+#endif // __UNCACHED_MEMORY_ALLOCATION_LIB_H__

diff --git a/ArmPkg/Library/ArmCacheMaintenanceLib/ArmCacheMaintenanceLib.c b/ArmPkg/Library/ArmCacheMaintenanceLib/ArmCacheMaintenanceLib.c
index 0dd45300..2557a2cf 100644
--- a/ArmPkg/Library/ArmCacheMaintenanceLib/ArmCacheMaintenanceLib.c
+++ b/ArmPkg/Library/ArmCacheMaintenanceLib/ArmCacheMaintenanceLib.c
@@ -1,125 +1,125 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-#include <Base.h>
-#include <Library/ArmLib.h>
-#include <Library/PcdLib.h>
-
-VOID
-CacheRangeOperation (
-  IN  VOID            *Start,
-  IN  UINTN           Length,
-  IN  CACHE_OPERATION CacheOperation,
-  IN  LINE_OPERATION  LineOperation
-  )
-{
-  UINTN ArmCacheLineLength         = ArmDataCacheLineLength();
-  UINTN ArmCacheLineAlignmentMask  = ArmCacheLineLength - 1;
-  UINTN ArmCacheOperationThreshold = PcdGet32(PcdArmCacheOperationThreshold);
-  
-  if ((CacheOperation != NULL) && (Length >= ArmCacheOperationThreshold)) {
-    CacheOperation ();
-  } else {
-    // Align address (rounding down)
-    UINTN AlignedAddress = (UINTN)Start - ((UINTN)Start & ArmCacheLineAlignmentMask);
-    UINTN EndAddress     = (UINTN)Start + Length;
-
-    // Perform the line operation on an address in each cache line
-    while (AlignedAddress < EndAddress) {
-      LineOperation(AlignedAddress);
-      AlignedAddress += ArmCacheLineLength;
-    }
-  }
-}
-
-VOID
-EFIAPI
-InvalidateInstructionCache (
-  VOID
-  )
-{
-  ArmCleanDataCache();
-  ArmInvalidateInstructionCache();
-}
-
-VOID
-EFIAPI
-InvalidateDataCache (
-  VOID
-  )
-{
-  ArmInvalidateDataCache();
-}
-
-VOID *
-EFIAPI
-InvalidateInstructionCacheRange (
-  IN      VOID                      *Address,
-  IN      UINTN                     Length
-  )
-{
-  CacheRangeOperation (Address, Length, ArmCleanDataCacheToPoU, ArmCleanDataCacheEntryByMVA);
-  ArmInvalidateInstructionCache ();
-  return Address;
-}
-
-VOID
-EFIAPI
-WriteBackInvalidateDataCache (
-  VOID
-  )
-{
-  ArmCleanInvalidateDataCache();
-}
-
-VOID *
-EFIAPI
-WriteBackInvalidateDataCacheRange (
-  IN      VOID                      *Address,
-  IN      UINTN                     Length
-  )
-{
-  CacheRangeOperation(Address, Length, ArmCleanInvalidateDataCache, ArmCleanInvalidateDataCacheEntryByMVA);
-  return Address;
-}
-
-VOID
-EFIAPI
-WriteBackDataCache (
-  VOID
-  )
-{
-  ArmCleanDataCache();
-}
-
-VOID *
-EFIAPI
-WriteBackDataCacheRange (
-  IN      VOID                      *Address,
-  IN      UINTN                     Length
-  )
-{
-  CacheRangeOperation(Address, Length, ArmCleanDataCache, ArmCleanDataCacheEntryByMVA);
-  return Address;
-}
-
-VOID *
-EFIAPI
-InvalidateDataCacheRange (
-  IN      VOID                      *Address,
-  IN      UINTN                     Length
-  )
-{
-  CacheRangeOperation(Address, Length, NULL, ArmInvalidateDataCacheEntryByMVA);
-  return Address;
-}
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+#include <Base.h>

+#include <Library/ArmLib.h>

+#include <Library/PcdLib.h>

+

+VOID

+CacheRangeOperation (

+  IN  VOID            *Start,

+  IN  UINTN           Length,

+  IN  CACHE_OPERATION CacheOperation,

+  IN  LINE_OPERATION  LineOperation

+  )

+{

+  UINTN ArmCacheLineLength         = ArmDataCacheLineLength();

+  UINTN ArmCacheLineAlignmentMask  = ArmCacheLineLength - 1;

+  UINTN ArmCacheOperationThreshold = PcdGet32(PcdArmCacheOperationThreshold);

+  

+  if ((CacheOperation != NULL) && (Length >= ArmCacheOperationThreshold)) {

+    CacheOperation ();

+  } else {

+    // Align address (rounding down)

+    UINTN AlignedAddress = (UINTN)Start - ((UINTN)Start & ArmCacheLineAlignmentMask);

+    UINTN EndAddress     = (UINTN)Start + Length;

+

+    // Perform the line operation on an address in each cache line

+    while (AlignedAddress < EndAddress) {

+      LineOperation(AlignedAddress);

+      AlignedAddress += ArmCacheLineLength;

+    }

+  }

+}

+

+VOID

+EFIAPI

+InvalidateInstructionCache (

+  VOID

+  )

+{

+  ArmCleanDataCache();

+  ArmInvalidateInstructionCache();

+}

+

+VOID

+EFIAPI

+InvalidateDataCache (

+  VOID

+  )

+{

+  ArmInvalidateDataCache();

+}

+

+VOID *

+EFIAPI

+InvalidateInstructionCacheRange (

+  IN      VOID                      *Address,

+  IN      UINTN                     Length

+  )

+{

+  CacheRangeOperation (Address, Length, ArmCleanDataCacheToPoU, ArmCleanDataCacheEntryByMVA);

+  ArmInvalidateInstructionCache ();

+  return Address;

+}

+

+VOID

+EFIAPI

+WriteBackInvalidateDataCache (

+  VOID

+  )

+{

+  ArmCleanInvalidateDataCache();

+}

+

+VOID *

+EFIAPI

+WriteBackInvalidateDataCacheRange (

+  IN      VOID                      *Address,

+  IN      UINTN                     Length

+  )

+{

+  CacheRangeOperation(Address, Length, ArmCleanInvalidateDataCache, ArmCleanInvalidateDataCacheEntryByMVA);

+  return Address;

+}

+

+VOID

+EFIAPI

+WriteBackDataCache (

+  VOID

+  )

+{

+  ArmCleanDataCache();

+}

+

+VOID *

+EFIAPI

+WriteBackDataCacheRange (

+  IN      VOID                      *Address,

+  IN      UINTN                     Length

+  )

+{

+  CacheRangeOperation(Address, Length, ArmCleanDataCache, ArmCleanDataCacheEntryByMVA);

+  return Address;

+}

+

+VOID *

+EFIAPI

+InvalidateDataCacheRange (

+  IN      VOID                      *Address,

+  IN      UINTN                     Length

+  )

+{

+  CacheRangeOperation(Address, Length, NULL, ArmInvalidateDataCacheEntryByMVA);

+  return Address;

+}

diff --git a/ArmPkg/Library/ArmCacheMaintenanceLib/ArmCacheMaintenanceLib.inf b/ArmPkg/Library/ArmCacheMaintenanceLib/ArmCacheMaintenanceLib.inf
index 12470480..7a43bfe9 100644
--- a/ArmPkg/Library/ArmCacheMaintenanceLib/ArmCacheMaintenanceLib.inf
+++ b/ArmPkg/Library/ArmCacheMaintenanceLib/ArmCacheMaintenanceLib.inf
@@ -1,37 +1,37 @@
-#/** @file
-# Semihosting  serail port lib
-#
-# Copyright (c) 2008, Apple Inc. All rights reserved.<BR>
-#
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution. The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = ArmCacheMaintenanceLib
-  FILE_GUID                      = 1A20BE1F-33AD-450C-B49A-7123FCA8B7F9
-  MODULE_TYPE                    = BASE
-  VERSION_STRING                 = 1.0
-  LIBRARY_CLASS                  = CacheMaintenanceLib 
-
-[Sources.common]
-  ArmCacheMaintenanceLib.c
-
-[Packages]
-  ArmPkg/ArmPkg.dec
-  MdePkg/MdePkg.dec
-
-[LibraryClasses]
-  ArmLib
-  BaseLib
-
-[FixedPcd]
-  gArmTokenSpaceGuid.PcdArmCacheOperationThreshold
-  
+#/** @file

+# Semihosting  serail port lib

+#

+# Copyright (c) 2008, Apple Inc. All rights reserved.<BR>

+#

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution. The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = ArmCacheMaintenanceLib

+  FILE_GUID                      = 1A20BE1F-33AD-450C-B49A-7123FCA8B7F9

+  MODULE_TYPE                    = BASE

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = CacheMaintenanceLib 

+

+[Sources.common]

+  ArmCacheMaintenanceLib.c

+

+[Packages]

+  ArmPkg/ArmPkg.dec

+  MdePkg/MdePkg.dec

+

+[LibraryClasses]

+  ArmLib

+  BaseLib

+

+[FixedPcd]

+  gArmTokenSpaceGuid.PcdArmCacheOperationThreshold

+  

diff --git a/ArmPkg/Library/ArmDmaLib/ArmDmaLib.inf b/ArmPkg/Library/ArmDmaLib/ArmDmaLib.inf
index 5c809ba3..54656951 100755
--- a/ArmPkg/Library/ArmDmaLib/ArmDmaLib.inf
+++ b/ArmPkg/Library/ArmDmaLib/ArmDmaLib.inf
@@ -47,4 +47,4 @@
 [Pcd]

 

 [Depex]

-  gEfiCpuArchProtocolGuid
\ No newline at end of file
+  gEfiCpuArchProtocolGuid
\ No newline at end of file
diff --git a/ArmPkg/Library/ArmLib/Arm11/Arm11Lib.inf b/ArmPkg/Library/ArmLib/Arm11/Arm11Lib.inf
index b28a4578..5f24ffaf 100644
--- a/ArmPkg/Library/ArmLib/Arm11/Arm11Lib.inf
+++ b/ArmPkg/Library/ArmLib/Arm11/Arm11Lib.inf
@@ -22,8 +22,8 @@
   LIBRARY_CLASS                  = ArmLib

 

 [Sources.common]

-  ../Common/ArmLibSupport.S    | GCC

-  ../Common/ArmLibSupport.asm  | RVCT

+  ../Common/Arm/ArmLibSupport.S    | GCC

+  ../Common/Arm/ArmLibSupport.asm  | RVCT

   ../Common/ArmLib.c

   

   Arm11Support.S    | GCC

diff --git a/ArmPkg/Library/ArmLib/Arm11/Arm11LibMem.c b/ArmPkg/Library/ArmLib/Arm11/Arm11LibMem.c
index 86427035..c683861c 100644
--- a/ArmPkg/Library/ArmLib/Arm11/Arm11LibMem.c
+++ b/ArmPkg/Library/ArmLib/Arm11/Arm11LibMem.c
@@ -1,133 +1,133 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include <Chipset/ARM1176JZ-S.h>
-#include <Library/ArmLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/MemoryAllocationLib.h>
-
-VOID
-FillTranslationTable (
-  IN  UINT32                        *TranslationTable,
-  IN  ARM_MEMORY_REGION_DESCRIPTOR  *MemoryRegion
-  )
-{
-  UINT32  *Entry;
-  UINTN   Sections;
-  UINTN   Index;
-  UINT32  Attributes;
-  UINT32  PhysicalBase = MemoryRegion->PhysicalBase;
-  
-  switch (MemoryRegion->Attributes) {
-    case ARM_MEMORY_REGION_ATTRIBUTE_WRITE_BACK:
-      Attributes = TT_DESCRIPTOR_SECTION_WRITE_BACK(0);
-      break;
-    case ARM_MEMORY_REGION_ATTRIBUTE_WRITE_THROUGH:
-      Attributes = TT_DESCRIPTOR_SECTION_WRITE_THROUGH(0);
-      break;
-    case ARM_MEMORY_REGION_ATTRIBUTE_UNCACHED_UNBUFFERED:
-      Attributes = TT_DESCRIPTOR_SECTION_UNCACHED(0);
-      break;
-    case ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_WRITE_BACK:
-      Attributes = TT_DESCRIPTOR_SECTION_WRITE_BACK(1);
-      break;
-    case ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_WRITE_THROUGH:
-      Attributes = TT_DESCRIPTOR_SECTION_WRITE_THROUGH(1);
-      break;
-    case ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_UNCACHED_UNBUFFERED:
-      Attributes = TT_DESCRIPTOR_SECTION_UNCACHED(1);
-      break;
-    default:
-      Attributes = TT_DESCRIPTOR_SECTION_UNCACHED(0);
-      break;
-  }
-  
-  Entry    = TRANSLATION_TABLE_ENTRY_FOR_VIRTUAL_ADDRESS(TranslationTable, MemoryRegion->VirtualBase);
-  Sections = ((( MemoryRegion->Length - 1 ) / TT_DESCRIPTOR_SECTION_SIZE ) + 1 );
-  
-  for (Index = 0; Index < Sections; Index++)
-  {
-    *Entry++     =  TT_DESCRIPTOR_SECTION_BASE_ADDRESS(PhysicalBase) | Attributes;
-    PhysicalBase += TT_DESCRIPTOR_SECTION_SIZE;
-  }
-}
-
-VOID
-EFIAPI
-ArmConfigureMmu (
-  IN  ARM_MEMORY_REGION_DESCRIPTOR  *MemoryTable,
-  OUT VOID                          **TranslationTableBase OPTIONAL,
-  OUT UINTN                         *TranslationTableSize  OPTIONAL
-  )
-{
-  VOID  *TranslationTable;
-
-  // Allocate pages for translation table.
-  TranslationTable = AllocatePages(EFI_SIZE_TO_PAGES(TRANSLATION_TABLE_SIZE + TRANSLATION_TABLE_ALIGNMENT));
-  TranslationTable = (VOID *)(((UINTN)TranslationTable + TRANSLATION_TABLE_ALIGNMENT_MASK) & ~TRANSLATION_TABLE_ALIGNMENT_MASK);
-
-  if (TranslationTableBase != NULL) {
-    *TranslationTableBase = TranslationTable;
-  }
-  
-  if (TranslationTableBase != NULL) {
-    *TranslationTableSize = TRANSLATION_TABLE_SIZE;
-  }
-
-  ZeroMem(TranslationTable, TRANSLATION_TABLE_SIZE);
-
-  ArmCleanInvalidateDataCache();
-  ArmInvalidateInstructionCache();
-  ArmInvalidateTlb();
-
-  ArmDisableDataCache();
-  ArmDisableInstructionCache();
-  ArmDisableMmu();
-
-  // Make sure nothing sneaked into the cache
-  ArmCleanInvalidateDataCache();
-  ArmInvalidateInstructionCache();
-
-  while (MemoryTable->Length != 0) {
-    FillTranslationTable(TranslationTable, MemoryTable);
-    MemoryTable++;
-  }
-
-  ArmSetTTBR0(TranslationTable);
-    
-  ArmSetDomainAccessControl(DOMAIN_ACCESS_CONTROL_NONE(15) |
-                            DOMAIN_ACCESS_CONTROL_NONE(14) |
-                            DOMAIN_ACCESS_CONTROL_NONE(13) |
-                            DOMAIN_ACCESS_CONTROL_NONE(12) |
-                            DOMAIN_ACCESS_CONTROL_NONE(11) |
-                            DOMAIN_ACCESS_CONTROL_NONE(10) |
-                            DOMAIN_ACCESS_CONTROL_NONE( 9) |
-                            DOMAIN_ACCESS_CONTROL_NONE( 8) |
-                            DOMAIN_ACCESS_CONTROL_NONE( 7) |
-                            DOMAIN_ACCESS_CONTROL_NONE( 6) |
-                            DOMAIN_ACCESS_CONTROL_NONE( 5) |
-                            DOMAIN_ACCESS_CONTROL_NONE( 4) |
-                            DOMAIN_ACCESS_CONTROL_NONE( 3) |
-                            DOMAIN_ACCESS_CONTROL_NONE( 2) |
-                            DOMAIN_ACCESS_CONTROL_NONE( 1) |
-                            DOMAIN_ACCESS_CONTROL_MANAGER(0));
-    
-  ArmEnableInstructionCache();
-  ArmEnableDataCache();
-  ArmEnableMmu();  
-}
-
-
-
-
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include <Chipset/ARM1176JZ-S.h>

+#include <Library/ArmLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/MemoryAllocationLib.h>

+

+VOID

+FillTranslationTable (

+  IN  UINT32                        *TranslationTable,

+  IN  ARM_MEMORY_REGION_DESCRIPTOR  *MemoryRegion

+  )

+{

+  UINT32  *Entry;

+  UINTN   Sections;

+  UINTN   Index;

+  UINT32  Attributes;

+  UINT32  PhysicalBase = MemoryRegion->PhysicalBase;

+  

+  switch (MemoryRegion->Attributes) {

+    case ARM_MEMORY_REGION_ATTRIBUTE_WRITE_BACK:

+      Attributes = TT_DESCRIPTOR_SECTION_WRITE_BACK(0);

+      break;

+    case ARM_MEMORY_REGION_ATTRIBUTE_WRITE_THROUGH:

+      Attributes = TT_DESCRIPTOR_SECTION_WRITE_THROUGH(0);

+      break;

+    case ARM_MEMORY_REGION_ATTRIBUTE_UNCACHED_UNBUFFERED:

+      Attributes = TT_DESCRIPTOR_SECTION_UNCACHED(0);

+      break;

+    case ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_WRITE_BACK:

+      Attributes = TT_DESCRIPTOR_SECTION_WRITE_BACK(1);

+      break;

+    case ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_WRITE_THROUGH:

+      Attributes = TT_DESCRIPTOR_SECTION_WRITE_THROUGH(1);

+      break;

+    case ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_UNCACHED_UNBUFFERED:

+      Attributes = TT_DESCRIPTOR_SECTION_UNCACHED(1);

+      break;

+    default:

+      Attributes = TT_DESCRIPTOR_SECTION_UNCACHED(0);

+      break;

+  }

+  

+  Entry    = TRANSLATION_TABLE_ENTRY_FOR_VIRTUAL_ADDRESS(TranslationTable, MemoryRegion->VirtualBase);

+  Sections = ((( MemoryRegion->Length - 1 ) / TT_DESCRIPTOR_SECTION_SIZE ) + 1 );

+  

+  for (Index = 0; Index < Sections; Index++)

+  {

+    *Entry++     =  TT_DESCRIPTOR_SECTION_BASE_ADDRESS(PhysicalBase) | Attributes;

+    PhysicalBase += TT_DESCRIPTOR_SECTION_SIZE;

+  }

+}

+

+VOID

+EFIAPI

+ArmConfigureMmu (

+  IN  ARM_MEMORY_REGION_DESCRIPTOR  *MemoryTable,

+  OUT VOID                          **TranslationTableBase OPTIONAL,

+  OUT UINTN                         *TranslationTableSize  OPTIONAL

+  )

+{

+  VOID  *TranslationTable;

+

+  // Allocate pages for translation table.

+  TranslationTable = AllocatePages(EFI_SIZE_TO_PAGES(TRANSLATION_TABLE_SIZE + TRANSLATION_TABLE_ALIGNMENT));

+  TranslationTable = (VOID *)(((UINTN)TranslationTable + TRANSLATION_TABLE_ALIGNMENT_MASK) & ~TRANSLATION_TABLE_ALIGNMENT_MASK);

+

+  if (TranslationTableBase != NULL) {

+    *TranslationTableBase = TranslationTable;

+  }

+  

+  if (TranslationTableBase != NULL) {

+    *TranslationTableSize = TRANSLATION_TABLE_SIZE;

+  }

+

+  ZeroMem(TranslationTable, TRANSLATION_TABLE_SIZE);

+

+  ArmCleanInvalidateDataCache();

+  ArmInvalidateInstructionCache();

+  ArmInvalidateTlb();

+

+  ArmDisableDataCache();

+  ArmDisableInstructionCache();

+  ArmDisableMmu();

+

+  // Make sure nothing sneaked into the cache

+  ArmCleanInvalidateDataCache();

+  ArmInvalidateInstructionCache();

+

+  while (MemoryTable->Length != 0) {

+    FillTranslationTable(TranslationTable, MemoryTable);

+    MemoryTable++;

+  }

+

+  ArmSetTTBR0(TranslationTable);

+    

+  ArmSetDomainAccessControl(DOMAIN_ACCESS_CONTROL_NONE(15) |

+                            DOMAIN_ACCESS_CONTROL_NONE(14) |

+                            DOMAIN_ACCESS_CONTROL_NONE(13) |

+                            DOMAIN_ACCESS_CONTROL_NONE(12) |

+                            DOMAIN_ACCESS_CONTROL_NONE(11) |

+                            DOMAIN_ACCESS_CONTROL_NONE(10) |

+                            DOMAIN_ACCESS_CONTROL_NONE( 9) |

+                            DOMAIN_ACCESS_CONTROL_NONE( 8) |

+                            DOMAIN_ACCESS_CONTROL_NONE( 7) |

+                            DOMAIN_ACCESS_CONTROL_NONE( 6) |

+                            DOMAIN_ACCESS_CONTROL_NONE( 5) |

+                            DOMAIN_ACCESS_CONTROL_NONE( 4) |

+                            DOMAIN_ACCESS_CONTROL_NONE( 3) |

+                            DOMAIN_ACCESS_CONTROL_NONE( 2) |

+                            DOMAIN_ACCESS_CONTROL_NONE( 1) |

+                            DOMAIN_ACCESS_CONTROL_MANAGER(0));

+    

+  ArmEnableInstructionCache();

+  ArmEnableDataCache();

+  ArmEnableMmu();  

+}

+

+

+

+

diff --git a/ArmPkg/Library/ArmLib/Arm11/Arm11LibPrePi.inf b/ArmPkg/Library/ArmLib/Arm11/Arm11LibPrePi.inf
index cd36d8b3..7239acea 100644
--- a/ArmPkg/Library/ArmLib/Arm11/Arm11LibPrePi.inf
+++ b/ArmPkg/Library/ArmLib/Arm11/Arm11LibPrePi.inf
@@ -22,8 +22,8 @@
   LIBRARY_CLASS                  = ArmLib

 

 [Sources.common]

-  ../Common/ArmLibSupport.S    | GCC

-  ../Common/ArmLibSupport.asm  | RVCT

+  ../Common/Arm/ArmLibSupport.S    | GCC

+  ../Common/Arm/ArmLibSupport.asm  | RVCT

   ../Common/ArmLib.c

   

   Arm11Support.S    | GCC

diff --git a/ArmPkg/Library/ArmLib/Arm11/Arm11LibSec.inf b/ArmPkg/Library/ArmLib/Arm11/Arm11LibSec.inf
index 4c3566e3..e693c46d 100644
--- a/ArmPkg/Library/ArmLib/Arm11/Arm11LibSec.inf
+++ b/ArmPkg/Library/ArmLib/Arm11/Arm11LibSec.inf
@@ -22,8 +22,8 @@
   LIBRARY_CLASS                  = ArmLib

 

 [Sources.common]

-  ../Common/ArmLibSupport.S    | GCC

-  ../Common/ArmLibSupport.asm  | RVCT

+  ../Common/Arm/ArmLibSupport.S    | GCC

+  ../Common/Arm/ArmLibSupport.asm  | RVCT

   ../Common/ArmLib.c

   

   Arm11Support.S    | GCC

diff --git a/ArmPkg/Library/ArmLib/Arm11/Arm11Support.S b/ArmPkg/Library/ArmLib/Arm11/Arm11Support.S
index 7ff377c0..2f4be7e9 100644
--- a/ArmPkg/Library/ArmLib/Arm11/Arm11Support.S
+++ b/ArmPkg/Library/ArmLib/Arm11/Arm11Support.S
@@ -1,262 +1,262 @@
-#------------------------------------------------------------------------------ 
-#
-# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-# Copyright (c) 2011, ARM Limited. All rights reserved.
-#
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#------------------------------------------------------------------------------
-
-#include <AsmMacroIoLib.h>
-
-.text
-.align 2
-GCC_ASM_EXPORT(ArmDisableCachesAndMmu)
-GCC_ASM_EXPORT(ArmInvalidateInstructionAndDataTlb)
-GCC_ASM_EXPORT(ArmCleanInvalidateDataCache)
-GCC_ASM_EXPORT(ArmCleanDataCache)
-GCC_ASM_EXPORT(ArmInvalidateDataCache)
-GCC_ASM_EXPORT(ArmInvalidateInstructionCache)
-GCC_ASM_EXPORT(ArmInvalidateDataCacheEntryByMVA)
-GCC_ASM_EXPORT(ArmCleanDataCacheEntryByMVA)
-GCC_ASM_EXPORT(ArmCleanInvalidateDataCacheEntryByMVA)
-GCC_ASM_EXPORT(ArmEnableMmu)
-GCC_ASM_EXPORT(ArmDisableMmu)
-GCC_ASM_EXPORT(ArmMmuEnabled)
-GCC_ASM_EXPORT(ArmEnableDataCache)
-GCC_ASM_EXPORT(ArmDisableDataCache)
-GCC_ASM_EXPORT(ArmEnableInstructionCache)
-GCC_ASM_EXPORT(ArmDisableInstructionCache)
-GCC_ASM_EXPORT(ArmEnableBranchPrediction)
-GCC_ASM_EXPORT(ArmDisableBranchPrediction)
-GCC_ASM_EXPORT(ArmDataMemoryBarrier)
-GCC_ASM_EXPORT(ArmDataSyncronizationBarrier)
-GCC_ASM_EXPORT(ArmInstructionSynchronizationBarrier)
-GCC_ASM_EXPORT(ArmSetLowVectors)
-GCC_ASM_EXPORT(ArmSetHighVectors)
-GCC_ASM_EXPORT(ArmIsMpCore)
-GCC_ASM_EXPORT(ArmCallWFI)
-GCC_ASM_EXPORT(ArmReadMpidr)
-GCC_ASM_EXPORT(ArmUpdateTranslationTableEntry)
-GCC_ASM_EXPORT(ArmEnableFiq)
-GCC_ASM_EXPORT(ArmDisableFiq)
-GCC_ASM_EXPORT(ArmEnableInterrupts)
-GCC_ASM_EXPORT(ArmDisableInterrupts)
-GCC_ASM_EXPORT (ArmEnableVFP)
-
-Arm11PartNumberMask:  .word       0xFFF0
-Arm11PartNumber:      .word	      0xB020
-
-.set DC_ON, (0x1<<2)
-.set IC_ON, (0x1<<12)
-.set XP_ON, (0x1<<23)
-.set CTRL_M_BIT,  (1 << 0)
-.set CTRL_C_BIT,  (1 << 2)
-.set CTRL_I_BIT,  (1 << 12)
-
-ASM_PFX(ArmDisableCachesAndMmu):
-  mrc   p15, 0, r0, c1, c0, 0           @ Get control register
-  bic   r0, r0, #CTRL_M_BIT             @ Disable MMU
-  bic   r0, r0, #CTRL_C_BIT             @ Disable D Cache
-  bic   r0, r0, #CTRL_I_BIT             @ Disable I Cache
-  mcr   p15, 0, r0, c1, c0, 0           @ Write control register
-  bx      LR
-
-ASM_PFX(ArmInvalidateInstructionAndDataTlb):
-  mcr     p15, 0, r0, c8, c7, 0      @ Invalidate Inst TLB and Data TLB
-  bx lr
-
-ASM_PFX(ArmInvalidateDataCacheEntryByMVA):
-  mcr     p15, 0, r0, c7, c6, 1   @invalidate single data cache line                                           
-  bx      lr
-
-
-ASM_PFX(ArmCleanDataCacheEntryByMVA):
-  mcr     p15, 0, r0, c7, c10, 1  @clean single data cache line     
-  bx      lr
-
-
-ASM_PFX(ArmCleanInvalidateDataCacheEntryByMVA):
-  mcr     p15, 0, r0, c7, c14, 1  @clean and invalidate single data cache line
-  bx      lr
-
-
-ASM_PFX(ArmCleanDataCache):
-  mcr     p15, 0, r0, c7, c10, 0  @ clean entire data cache
-  bx      lr
-
-
-ASM_PFX(ArmCleanInvalidateDataCache):
-  mcr     p15, 0, r0, c7, c14, 0  @ clean and invalidate entire data cache
-  bx      lr
-
-
-ASM_PFX(ArmInvalidateDataCache):
-  mcr     p15, 0, r0, c7, c6, 0  @ invalidate entire data cache
-  bx      lr
-
-
-ASM_PFX(ArmInvalidateInstructionCache):
-  mcr     p15, 0, r0, c7, c5, 0  @invalidate entire instruction cache
-  mov     R0,#0
-  mcr     p15,0,R0,c7,c5,4       @Flush Prefetch buffer
-  bx      lr
-
-ASM_PFX(ArmEnableMmu):
-  mrc     p15,0,R0,c1,c0,0
-  orr     R0,R0,#1
-  mcr     p15,0,R0,c1,c0,0
-  bx      LR
-
-ASM_PFX(ArmMmuEnabled):
-  mrc     p15,0,R0,c1,c0,0
-  and     R0,R0,#1
-  bx      LR
-
-ASM_PFX(ArmDisableMmu):
-  mrc     p15,0,R0,c1,c0,0
-  bic     R0,R0,#1
-  mcr     p15,0,R0,c1,c0,0
-  mov     R0,#0
-  mcr     p15,0,R0,c7,c10,4     @Data synchronization barrier
-  mov     R0,#0
-  mcr     p15,0,R0,c7,c5,4      @Flush Prefetch buffer
-  bx      LR
-
-ASM_PFX(ArmEnableDataCache):
-  LoadConstantToReg(DC_ON, R1)  @ldr     R1,=DC_ON
-  mrc     p15,0,R0,c1,c0,0      @Read control register configuration data
-  orr     R0,R0,R1              @Set C bit
-  mcr     p15,0,r0,c1,c0,0      @Write control register configuration data
-  bx      LR
-    
-ASM_PFX(ArmDisableDataCache):
-  LoadConstantToReg(DC_ON, R1)  @ldr     R1,=DC_ON
-  mrc     p15,0,R0,c1,c0,0      @Read control register configuration data
-  bic     R0,R0,R1              @Clear C bit
-  mcr     p15,0,r0,c1,c0,0      @Write control register configuration data
-  bx      LR
-
-ASM_PFX(ArmEnableInstructionCache):
-  ldr     R1,=IC_ON
-  mrc     p15,0,R0,c1,c0,0     @Read control register configuration data
-  orr     R0,R0,R1             @Set I bit
-  mcr     p15,0,r0,c1,c0,0     @Write control register configuration data
-  bx      LR
-  
-ASM_PFX(ArmDisableInstructionCache):
-  ldr     R1,=IC_ON
-  mrc     p15,0,R0,c1,c0,0     @Read control register configuration data
-  bic     R0,R0,R1             @Clear I bit.
-  mcr     p15,0,r0,c1,c0,0     @Write control register configuration data
-  bx      LR
-
-ASM_PFX(ArmEnableBranchPrediction):
-  mrc     p15, 0, r0, c1, c0, 0
-  orr     r0, r0, #0x00000800
-  mcr     p15, 0, r0, c1, c0, 0
-  bx      LR
-
-ASM_PFX(ArmDisableBranchPrediction):
-  mrc     p15, 0, r0, c1, c0, 0
-  bic     r0, r0, #0x00000800
-  mcr     p15, 0, r0, c1, c0, 0
-  bx      LR
-
-ASM_PFX(ArmDataMemoryBarrier):
-  mov R0, #0
-  mcr P15, #0, R0, C7, C10, #5 
-  bx      LR
-  
-ASM_PFX(ArmDataSyncronizationBarrier):
-  mov R0, #0
-  mcr P15, #0, R0, C7, C10, #4 
-  bx      LR
-  
-ASM_PFX(ArmInstructionSynchronizationBarrier):
-  mov R0, #0
-  mcr P15, #0, R0, C7, C5, #4 
-  bx      LR
-
-ASM_PFX(ArmSetLowVectors):
-  mrc     p15, 0, r0, c1, c0, 0 @ Read SCTLR into R0 (Read control register configuration data)
-  bic     r0, r0, #0x00002000   @ clear V bit
-  mcr     p15, 0, r0, c1, c0, 0 @ Write R0 into SCTLR (Write control register configuration data)
-  bx      LR
-
-ASM_PFX(ArmSetHighVectors):
-  mrc     p15, 0, r0, c1, c0, 0 @ Read SCTLR into R0 (Read control register configuration data)
-  orr     r0, r0, #0x00002000   @ clear V bit
-  mcr     p15, 0, r0, c1, c0, 0 @ Write R0 into SCTLR (Write control register configuration data)
-  bx      LR
-
-ASM_PFX(ArmIsMpCore):
-  push    { r1 }
-  mrc     p15, 0, r0, c0, c0, 0
-  # Extract Part Number to check it is an ARM11MP core (0xB02)
-  LoadConstantToReg (Arm11PartNumberMask, r1)
-  and     r0, r0, r1
-  LoadConstantToReg (Arm11PartNumber, r1)
-  cmp     r0, r1
-  movne   r0, #0
-  pop     { r1 }
-  bx      lr     
-
-ASM_PFX(ArmCallWFI):
-  wfi
-  bx      lr
-
-ASM_PFX(ArmReadMpidr):
-  mrc     p15, 0, r0, c0, c0, 5       @ read MPIDR
-  bx      lr
-
-ASM_PFX(ArmEnableFiq):
-  mrs     R0,CPSR
-  bic     R0,R0,#0x40    @Enable FIQ interrupts
-  msr     CPSR_c,R0
-  bx      LR
-
-ASM_PFX(ArmDisableFiq):
-  mrs     R0,CPSR
-  orr     R1,R0,#0x40    @Disable FIQ interrupts
-  msr     CPSR_c,R1
-  tst     R0,#0x80
-  moveq   R0,#1
-  movne   R0,#0
-  bx      LR
-
-ASM_PFX(ArmEnableInterrupts):
-  mrs     R0,CPSR
-  bic     R0,R0,#0x80    @Enable IRQ interrupts
-  msr     CPSR_c,R0
-  bx      LR
-
-ASM_PFX(ArmDisableInterrupts):
-  mrs     R0,CPSR
-  orr     R1,R0,#0x80    @Disable IRQ interrupts
-  msr     CPSR_c,R1
-  tst     R0,#0x80
-  moveq   R0,#1
-  movne   R0,#0
-  bx      LR
-
-ASM_PFX(ArmEnableVFP):
-  # Read CPACR (Coprocessor Access Control Register)
-  mrc     p15, 0, r0, c1, c0, 2
-  # Enable VPF access (Full Access to CP10, CP11) (V* instructions)
-  orr     r0, r0, #0x00f00000
-  # Write back CPACR (Coprocessor Access Control Register)
-  mcr     p15, 0, r0, c1, c0, 2
-  # Set EN bit in FPEXC. The Advanced SIMD and VFP extensions are enabled and operate normally.
-  mov     r0, #0x40000000
-  #TODO: Fixme - need compilation flag
-  #fmxr    FPEXC, r0
-  bx      lr
-
-ASM_FUNCTION_REMOVE_IF_UNREFERENCED
+#------------------------------------------------------------------------------ 

+#

+# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+# Copyright (c) 2011, ARM Limited. All rights reserved.

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+#include <AsmMacroIoLib.h>

+

+.text

+.align 2

+GCC_ASM_EXPORT(ArmDisableCachesAndMmu)

+GCC_ASM_EXPORT(ArmInvalidateInstructionAndDataTlb)

+GCC_ASM_EXPORT(ArmCleanInvalidateDataCache)

+GCC_ASM_EXPORT(ArmCleanDataCache)

+GCC_ASM_EXPORT(ArmInvalidateDataCache)

+GCC_ASM_EXPORT(ArmInvalidateInstructionCache)

+GCC_ASM_EXPORT(ArmInvalidateDataCacheEntryByMVA)

+GCC_ASM_EXPORT(ArmCleanDataCacheEntryByMVA)

+GCC_ASM_EXPORT(ArmCleanInvalidateDataCacheEntryByMVA)

+GCC_ASM_EXPORT(ArmEnableMmu)

+GCC_ASM_EXPORT(ArmDisableMmu)

+GCC_ASM_EXPORT(ArmMmuEnabled)

+GCC_ASM_EXPORT(ArmEnableDataCache)

+GCC_ASM_EXPORT(ArmDisableDataCache)

+GCC_ASM_EXPORT(ArmEnableInstructionCache)

+GCC_ASM_EXPORT(ArmDisableInstructionCache)

+GCC_ASM_EXPORT(ArmEnableBranchPrediction)

+GCC_ASM_EXPORT(ArmDisableBranchPrediction)

+GCC_ASM_EXPORT(ArmDataMemoryBarrier)

+GCC_ASM_EXPORT(ArmDataSyncronizationBarrier)

+GCC_ASM_EXPORT(ArmInstructionSynchronizationBarrier)

+GCC_ASM_EXPORT(ArmSetLowVectors)

+GCC_ASM_EXPORT(ArmSetHighVectors)

+GCC_ASM_EXPORT(ArmIsMpCore)

+GCC_ASM_EXPORT(ArmCallWFI)

+GCC_ASM_EXPORT(ArmReadMpidr)

+GCC_ASM_EXPORT(ArmUpdateTranslationTableEntry)

+GCC_ASM_EXPORT(ArmEnableFiq)

+GCC_ASM_EXPORT(ArmDisableFiq)

+GCC_ASM_EXPORT(ArmEnableInterrupts)

+GCC_ASM_EXPORT(ArmDisableInterrupts)

+GCC_ASM_EXPORT (ArmEnableVFP)

+

+Arm11PartNumberMask:  .word       0xFFF0

+Arm11PartNumber:      .word	      0xB020

+

+.set DC_ON, (0x1<<2)

+.set IC_ON, (0x1<<12)

+.set XP_ON, (0x1<<23)

+.set CTRL_M_BIT,  (1 << 0)

+.set CTRL_C_BIT,  (1 << 2)

+.set CTRL_I_BIT,  (1 << 12)

+

+ASM_PFX(ArmDisableCachesAndMmu):

+  mrc   p15, 0, r0, c1, c0, 0           @ Get control register

+  bic   r0, r0, #CTRL_M_BIT             @ Disable MMU

+  bic   r0, r0, #CTRL_C_BIT             @ Disable D Cache

+  bic   r0, r0, #CTRL_I_BIT             @ Disable I Cache

+  mcr   p15, 0, r0, c1, c0, 0           @ Write control register

+  bx      LR

+

+ASM_PFX(ArmInvalidateInstructionAndDataTlb):

+  mcr     p15, 0, r0, c8, c7, 0      @ Invalidate Inst TLB and Data TLB

+  bx lr

+

+ASM_PFX(ArmInvalidateDataCacheEntryByMVA):

+  mcr     p15, 0, r0, c7, c6, 1   @invalidate single data cache line                                           

+  bx      lr

+

+

+ASM_PFX(ArmCleanDataCacheEntryByMVA):

+  mcr     p15, 0, r0, c7, c10, 1  @clean single data cache line     

+  bx      lr

+

+

+ASM_PFX(ArmCleanInvalidateDataCacheEntryByMVA):

+  mcr     p15, 0, r0, c7, c14, 1  @clean and invalidate single data cache line

+  bx      lr

+

+

+ASM_PFX(ArmCleanDataCache):

+  mcr     p15, 0, r0, c7, c10, 0  @ clean entire data cache

+  bx      lr

+

+

+ASM_PFX(ArmCleanInvalidateDataCache):

+  mcr     p15, 0, r0, c7, c14, 0  @ clean and invalidate entire data cache

+  bx      lr

+

+

+ASM_PFX(ArmInvalidateDataCache):

+  mcr     p15, 0, r0, c7, c6, 0  @ invalidate entire data cache

+  bx      lr

+

+

+ASM_PFX(ArmInvalidateInstructionCache):

+  mcr     p15, 0, r0, c7, c5, 0  @invalidate entire instruction cache

+  mov     R0,#0

+  mcr     p15,0,R0,c7,c5,4       @Flush Prefetch buffer

+  bx      lr

+

+ASM_PFX(ArmEnableMmu):

+  mrc     p15,0,R0,c1,c0,0

+  orr     R0,R0,#1

+  mcr     p15,0,R0,c1,c0,0

+  bx      LR

+

+ASM_PFX(ArmMmuEnabled):

+  mrc     p15,0,R0,c1,c0,0

+  and     R0,R0,#1

+  bx      LR

+

+ASM_PFX(ArmDisableMmu):

+  mrc     p15,0,R0,c1,c0,0

+  bic     R0,R0,#1

+  mcr     p15,0,R0,c1,c0,0

+  mov     R0,#0

+  mcr     p15,0,R0,c7,c10,4     @Data synchronization barrier

+  mov     R0,#0

+  mcr     p15,0,R0,c7,c5,4      @Flush Prefetch buffer

+  bx      LR

+

+ASM_PFX(ArmEnableDataCache):

+  LoadConstantToReg(DC_ON, R1)  @ldr     R1,=DC_ON

+  mrc     p15,0,R0,c1,c0,0      @Read control register configuration data

+  orr     R0,R0,R1              @Set C bit

+  mcr     p15,0,r0,c1,c0,0      @Write control register configuration data

+  bx      LR

+    

+ASM_PFX(ArmDisableDataCache):

+  LoadConstantToReg(DC_ON, R1)  @ldr     R1,=DC_ON

+  mrc     p15,0,R0,c1,c0,0      @Read control register configuration data

+  bic     R0,R0,R1              @Clear C bit

+  mcr     p15,0,r0,c1,c0,0      @Write control register configuration data

+  bx      LR

+

+ASM_PFX(ArmEnableInstructionCache):

+  ldr     R1,=IC_ON

+  mrc     p15,0,R0,c1,c0,0     @Read control register configuration data

+  orr     R0,R0,R1             @Set I bit

+  mcr     p15,0,r0,c1,c0,0     @Write control register configuration data

+  bx      LR

+  

+ASM_PFX(ArmDisableInstructionCache):

+  ldr     R1,=IC_ON

+  mrc     p15,0,R0,c1,c0,0     @Read control register configuration data

+  bic     R0,R0,R1             @Clear I bit.

+  mcr     p15,0,r0,c1,c0,0     @Write control register configuration data

+  bx      LR

+

+ASM_PFX(ArmEnableBranchPrediction):

+  mrc     p15, 0, r0, c1, c0, 0

+  orr     r0, r0, #0x00000800

+  mcr     p15, 0, r0, c1, c0, 0

+  bx      LR

+

+ASM_PFX(ArmDisableBranchPrediction):

+  mrc     p15, 0, r0, c1, c0, 0

+  bic     r0, r0, #0x00000800

+  mcr     p15, 0, r0, c1, c0, 0

+  bx      LR

+

+ASM_PFX(ArmDataMemoryBarrier):

+  mov R0, #0

+  mcr P15, #0, R0, C7, C10, #5 

+  bx      LR

+  

+ASM_PFX(ArmDataSyncronizationBarrier):

+  mov R0, #0

+  mcr P15, #0, R0, C7, C10, #4 

+  bx      LR

+  

+ASM_PFX(ArmInstructionSynchronizationBarrier):

+  mov R0, #0

+  mcr P15, #0, R0, C7, C5, #4 

+  bx      LR

+

+ASM_PFX(ArmSetLowVectors):

+  mrc     p15, 0, r0, c1, c0, 0 @ Read SCTLR into R0 (Read control register configuration data)

+  bic     r0, r0, #0x00002000   @ clear V bit

+  mcr     p15, 0, r0, c1, c0, 0 @ Write R0 into SCTLR (Write control register configuration data)

+  bx      LR

+

+ASM_PFX(ArmSetHighVectors):

+  mrc     p15, 0, r0, c1, c0, 0 @ Read SCTLR into R0 (Read control register configuration data)

+  orr     r0, r0, #0x00002000   @ clear V bit

+  mcr     p15, 0, r0, c1, c0, 0 @ Write R0 into SCTLR (Write control register configuration data)

+  bx      LR

+

+ASM_PFX(ArmIsMpCore):

+  push    { r1 }

+  mrc     p15, 0, r0, c0, c0, 0

+  # Extract Part Number to check it is an ARM11MP core (0xB02)

+  LoadConstantToReg (Arm11PartNumberMask, r1)

+  and     r0, r0, r1

+  LoadConstantToReg (Arm11PartNumber, r1)

+  cmp     r0, r1

+  movne   r0, #0

+  pop     { r1 }

+  bx      lr     

+

+ASM_PFX(ArmCallWFI):

+  wfi

+  bx      lr

+

+ASM_PFX(ArmReadMpidr):

+  mrc     p15, 0, r0, c0, c0, 5       @ read MPIDR

+  bx      lr

+

+ASM_PFX(ArmEnableFiq):

+  mrs     R0,CPSR

+  bic     R0,R0,#0x40    @Enable FIQ interrupts

+  msr     CPSR_c,R0

+  bx      LR

+

+ASM_PFX(ArmDisableFiq):

+  mrs     R0,CPSR

+  orr     R1,R0,#0x40    @Disable FIQ interrupts

+  msr     CPSR_c,R1

+  tst     R0,#0x80

+  moveq   R0,#1

+  movne   R0,#0

+  bx      LR

+

+ASM_PFX(ArmEnableInterrupts):

+  mrs     R0,CPSR

+  bic     R0,R0,#0x80    @Enable IRQ interrupts

+  msr     CPSR_c,R0

+  bx      LR

+

+ASM_PFX(ArmDisableInterrupts):

+  mrs     R0,CPSR

+  orr     R1,R0,#0x80    @Disable IRQ interrupts

+  msr     CPSR_c,R1

+  tst     R0,#0x80

+  moveq   R0,#1

+  movne   R0,#0

+  bx      LR

+

+ASM_PFX(ArmEnableVFP):

+  # Read CPACR (Coprocessor Access Control Register)

+  mrc     p15, 0, r0, c1, c0, 2

+  # Enable VPF access (Full Access to CP10, CP11) (V* instructions)

+  orr     r0, r0, #0x00f00000

+  # Write back CPACR (Coprocessor Access Control Register)

+  mcr     p15, 0, r0, c1, c0, 2

+  # Set EN bit in FPEXC. The Advanced SIMD and VFP extensions are enabled and operate normally.

+  mov     r0, #0x40000000

+  #TODO: Fixme - need compilation flag

+  #fmxr    FPEXC, r0

+  bx      lr

+

+ASM_FUNCTION_REMOVE_IF_UNREFERENCED

diff --git a/ArmPkg/Library/ArmLib/Arm11/Arm11Support.asm b/ArmPkg/Library/ArmLib/Arm11/Arm11Support.asm
index fb3e91b7..8c270930 100644
--- a/ArmPkg/Library/ArmLib/Arm11/Arm11Support.asm
+++ b/ArmPkg/Library/ArmLib/Arm11/Arm11Support.asm
@@ -1,157 +1,157 @@
-//------------------------------------------------------------------------------ 
-//
-// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-//
-// This program and the accompanying materials
-// are licensed and made available under the terms and conditions of the BSD License
-// which accompanies this distribution.  The full text of the license may be found at
-// http://opensource.org/licenses/bsd-license.php
-//
-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-//
-//------------------------------------------------------------------------------
-
-    EXPORT  ArmCleanInvalidateDataCache
-    EXPORT  ArmCleanDataCache
-    EXPORT  ArmInvalidateDataCache
-    EXPORT  ArmInvalidateInstructionCache
-    EXPORT  ArmInvalidateDataCacheEntryByMVA
-    EXPORT  ArmCleanDataCacheEntryByMVA
-    EXPORT  ArmCleanInvalidateDataCacheEntryByMVA
-    EXPORT  ArmEnableMmu
-    EXPORT  ArmDisableMmu
-    EXPORT  ArmMmuEnabled
-    EXPORT  ArmEnableDataCache
-    EXPORT  ArmDisableDataCache
-    EXPORT  ArmEnableInstructionCache
-    EXPORT  ArmDisableInstructionCache
-    EXPORT  ArmEnableBranchPrediction
-    EXPORT  ArmDisableBranchPrediction
-    EXPORT  ArmDataMemoryBarrier
-    EXPORT  ArmDataSyncronizationBarrier
-    EXPORT  ArmInstructionSynchronizationBarrier
-
-
-DC_ON       EQU     ( 0x1:SHL:2 )
-IC_ON       EQU     ( 0x1:SHL:12 )
-XP_ON       EQU     ( 0x1:SHL:23 )
-
-
-    AREA    ArmCacheLib, CODE, READONLY
-    PRESERVE8
-
-
-ArmInvalidateDataCacheEntryByMVA
-  mcr     p15, 0, r0, c7, c6, 1   ; invalidate single data cache line                                           
-  bx      lr
-
-
-ArmCleanDataCacheEntryByMVA
-  mcr     p15, 0, r0, c7, c10, 1  ; clean single data cache line     
-  bx      lr
-
-
-ArmCleanInvalidateDataCacheEntryByMVA
-  mcr     p15, 0, r0, c7, c14, 1  ; clean and invalidate single data cache line
-  bx      lr
-
-
-ArmCleanDataCache
-  mcr     p15, 0, r0, c7, c10, 0  ; clean entire data cache
-  bx      lr
-
-
-ArmCleanInvalidateDataCache
-  mcr     p15, 0, r0, c7, c14, 0  ; clean and invalidate entire data cache
-  bx      lr
-
-
-ArmInvalidateDataCache
-  mcr     p15, 0, r0, c7, c6, 0  ; invalidate entire data cache
-  bx      lr
-
-
-ArmInvalidateInstructionCache
-  mcr     p15, 0, r0, c7, c5, 0  ;invalidate entire instruction cache
-  mov     R0,#0
-  mcr     p15,0,R0,c7,c5,4       ;Flush Prefetch buffer
-  bx      lr
-
-ArmEnableMmu
-  mrc     p15,0,R0,c1,c0,0
-  orr     R0,R0,#1
-  mcr     p15,0,R0,c1,c0,0
-  bx      LR
-
-ArmMmuEnabled
-  mrc     p15,0,R0,c1,c0,0
-  and     R0,R0,#1
-  bx      LR
-
-ArmDisableMmu
-  mrc     p15,0,R0,c1,c0,0
-  bic     R0,R0,#1
-  mcr     p15,0,R0,c1,c0,0
-  mov     R0,#0
-  mcr     p15,0,R0,c7,c10,4     ;Data synchronization barrier
-  mov     R0,#0
-  mcr     p15,0,R0,c7,c5,4      ;Flush Prefetch buffer
-  bx      LR
-
-ArmEnableDataCache
-  LDR     R1,=DC_ON
-  MRC     p15,0,R0,c1,c0,0      ;Read control register configuration data
-  ORR     R0,R0,R1              ;Set C bit
-  MCR     p15,0,r0,c1,c0,0      ;Write control register configuration data
-  BX      LR
-    
-ArmDisableDataCache
-  LDR     R1,=DC_ON
-  MRC     p15,0,R0,c1,c0,0      ;Read control register configuration data
-  BIC     R0,R0,R1              ;Clear C bit
-  MCR     p15,0,r0,c1,c0,0      ;Write control register configuration data
-  BX      LR
-
-ArmEnableInstructionCache
-  LDR     R1,=IC_ON
-  MRC     p15,0,R0,c1,c0,0     ;Read control register configuration data
-  ORR     R0,R0,R1             ;Set I bit
-  MCR     p15,0,r0,c1,c0,0     ;Write control register configuration data
-  BX      LR
-  
-ArmDisableInstructionCache
-  LDR     R1,=IC_ON
-  MRC     p15,0,R0,c1,c0,0     ;Read control register configuration data
-  BIC     R0,R0,R1             ;Clear I bit.
-  MCR     p15,0,r0,c1,c0,0     ;Write control register configuration data
-  BX      LR
-
-ArmEnableBranchPrediction
-  mrc     p15, 0, r0, c1, c0, 0
-  orr     r0, r0, #0x00000800
-  mcr     p15, 0, r0, c1, c0, 0
-  bx      LR
-
-ArmDisableBranchPrediction
-  mrc     p15, 0, r0, c1, c0, 0
-  bic     r0, r0, #0x00000800
-  mcr     p15, 0, r0, c1, c0, 0
-  bx      LR
-
-ASM_PFX(ArmDataMemoryBarrier):
-  mov R0, #0
-  mcr P15, #0, R0, C7, C10, #5 
-  bx      LR
-  
-ASM_PFX(ArmDataSyncronizationBarrier):
-  mov R0, #0
-  mcr P15, #0, R0, C7, C10, #4 
-  bx      LR
-  
-ASM_PFX(ArmInstructionSynchronizationBarrier):
-  MOV R0, #0
-  MCR P15, #0, R0, C7, C5, #4 
-  bx      LR
-
-    END
+//------------------------------------------------------------------------------ 

+//

+// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+//

+// This program and the accompanying materials

+// are licensed and made available under the terms and conditions of the BSD License

+// which accompanies this distribution.  The full text of the license may be found at

+// http://opensource.org/licenses/bsd-license.php

+//

+// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+//

+//------------------------------------------------------------------------------

+

+    EXPORT  ArmCleanInvalidateDataCache

+    EXPORT  ArmCleanDataCache

+    EXPORT  ArmInvalidateDataCache

+    EXPORT  ArmInvalidateInstructionCache

+    EXPORT  ArmInvalidateDataCacheEntryByMVA

+    EXPORT  ArmCleanDataCacheEntryByMVA

+    EXPORT  ArmCleanInvalidateDataCacheEntryByMVA

+    EXPORT  ArmEnableMmu

+    EXPORT  ArmDisableMmu

+    EXPORT  ArmMmuEnabled

+    EXPORT  ArmEnableDataCache

+    EXPORT  ArmDisableDataCache

+    EXPORT  ArmEnableInstructionCache

+    EXPORT  ArmDisableInstructionCache

+    EXPORT  ArmEnableBranchPrediction

+    EXPORT  ArmDisableBranchPrediction

+    EXPORT  ArmDataMemoryBarrier

+    EXPORT  ArmDataSyncronizationBarrier

+    EXPORT  ArmInstructionSynchronizationBarrier

+

+

+DC_ON       EQU     ( 0x1:SHL:2 )

+IC_ON       EQU     ( 0x1:SHL:12 )

+XP_ON       EQU     ( 0x1:SHL:23 )

+

+

+    AREA    ArmCacheLib, CODE, READONLY

+    PRESERVE8

+

+

+ArmInvalidateDataCacheEntryByMVA

+  mcr     p15, 0, r0, c7, c6, 1   ; invalidate single data cache line                                           

+  bx      lr

+

+

+ArmCleanDataCacheEntryByMVA

+  mcr     p15, 0, r0, c7, c10, 1  ; clean single data cache line     

+  bx      lr

+

+

+ArmCleanInvalidateDataCacheEntryByMVA

+  mcr     p15, 0, r0, c7, c14, 1  ; clean and invalidate single data cache line

+  bx      lr

+

+

+ArmCleanDataCache

+  mcr     p15, 0, r0, c7, c10, 0  ; clean entire data cache

+  bx      lr

+

+

+ArmCleanInvalidateDataCache

+  mcr     p15, 0, r0, c7, c14, 0  ; clean and invalidate entire data cache

+  bx      lr

+

+

+ArmInvalidateDataCache

+  mcr     p15, 0, r0, c7, c6, 0  ; invalidate entire data cache

+  bx      lr

+

+

+ArmInvalidateInstructionCache

+  mcr     p15, 0, r0, c7, c5, 0  ;invalidate entire instruction cache

+  mov     R0,#0

+  mcr     p15,0,R0,c7,c5,4       ;Flush Prefetch buffer

+  bx      lr

+

+ArmEnableMmu

+  mrc     p15,0,R0,c1,c0,0

+  orr     R0,R0,#1

+  mcr     p15,0,R0,c1,c0,0

+  bx      LR

+

+ArmMmuEnabled

+  mrc     p15,0,R0,c1,c0,0

+  and     R0,R0,#1

+  bx      LR

+

+ArmDisableMmu

+  mrc     p15,0,R0,c1,c0,0

+  bic     R0,R0,#1

+  mcr     p15,0,R0,c1,c0,0

+  mov     R0,#0

+  mcr     p15,0,R0,c7,c10,4     ;Data synchronization barrier

+  mov     R0,#0

+  mcr     p15,0,R0,c7,c5,4      ;Flush Prefetch buffer

+  bx      LR

+

+ArmEnableDataCache

+  LDR     R1,=DC_ON

+  MRC     p15,0,R0,c1,c0,0      ;Read control register configuration data

+  ORR     R0,R0,R1              ;Set C bit

+  MCR     p15,0,r0,c1,c0,0      ;Write control register configuration data

+  BX      LR

+    

+ArmDisableDataCache

+  LDR     R1,=DC_ON

+  MRC     p15,0,R0,c1,c0,0      ;Read control register configuration data

+  BIC     R0,R0,R1              ;Clear C bit

+  MCR     p15,0,r0,c1,c0,0      ;Write control register configuration data

+  BX      LR

+

+ArmEnableInstructionCache

+  LDR     R1,=IC_ON

+  MRC     p15,0,R0,c1,c0,0     ;Read control register configuration data

+  ORR     R0,R0,R1             ;Set I bit

+  MCR     p15,0,r0,c1,c0,0     ;Write control register configuration data

+  BX      LR

+  

+ArmDisableInstructionCache

+  LDR     R1,=IC_ON

+  MRC     p15,0,R0,c1,c0,0     ;Read control register configuration data

+  BIC     R0,R0,R1             ;Clear I bit.

+  MCR     p15,0,r0,c1,c0,0     ;Write control register configuration data

+  BX      LR

+

+ArmEnableBranchPrediction

+  mrc     p15, 0, r0, c1, c0, 0

+  orr     r0, r0, #0x00000800

+  mcr     p15, 0, r0, c1, c0, 0

+  bx      LR

+

+ArmDisableBranchPrediction

+  mrc     p15, 0, r0, c1, c0, 0

+  bic     r0, r0, #0x00000800

+  mcr     p15, 0, r0, c1, c0, 0

+  bx      LR

+

+ASM_PFX(ArmDataMemoryBarrier):

+  mov R0, #0

+  mcr P15, #0, R0, C7, C10, #5 

+  bx      LR

+  

+ASM_PFX(ArmDataSyncronizationBarrier):

+  mov R0, #0

+  mcr P15, #0, R0, C7, C10, #4 

+  bx      LR

+  

+ASM_PFX(ArmInstructionSynchronizationBarrier):

+  MOV R0, #0

+  MCR P15, #0, R0, C7, C5, #4 

+  bx      LR

+

+    END

diff --git a/ArmPkg/Library/ArmLib/Arm9/Arm9ArmLib.inf b/ArmPkg/Library/ArmLib/Arm9/Arm9ArmLib.inf
index 4eebf769..e962ca40 100644
--- a/ArmPkg/Library/ArmLib/Arm9/Arm9ArmLib.inf
+++ b/ArmPkg/Library/ArmLib/Arm9/Arm9ArmLib.inf
@@ -22,8 +22,8 @@
   LIBRARY_CLASS                  = ArmLib

 

 [Sources.common]

-  ../Common/ArmLibSupport.S    | GCC

-  ../Common/ArmLibSupport.asm  | RVCT

+  ../Common/Arm/ArmLibSupport.S    | GCC

+  ../Common/Arm/ArmLibSupport.asm  | RVCT

   ../Common/ArmLib.c

 

   Arm9Support.S    | GCC

diff --git a/ArmPkg/Library/ArmLib/Arm9/Arm9ArmLibPrePi.inf b/ArmPkg/Library/ArmLib/Arm9/Arm9ArmLibPrePi.inf
index e1900c5a..4c570019 100644
--- a/ArmPkg/Library/ArmLib/Arm9/Arm9ArmLibPrePi.inf
+++ b/ArmPkg/Library/ArmLib/Arm9/Arm9ArmLibPrePi.inf
@@ -22,8 +22,8 @@
   LIBRARY_CLASS                  = ArmLib

 

 [Sources.common]

-  ../Common/ArmLibSupport.S    | GCC

-  ../Common/ArmLibSupport.asm  | RVCT

+  ../Common/Arm/ArmLibSupport.S    | GCC

+  ../Common/Arm/ArmLibSupport.asm  | RVCT

   ../Common/ArmLib.c

 

   Arm9Support.S    | GCC

diff --git a/ArmPkg/Library/ArmLib/Arm9/Arm9Lib.c b/ArmPkg/Library/ArmLib/Arm9/Arm9Lib.c
index 7c3a384a..c92f9159 100644
--- a/ArmPkg/Library/ArmLib/Arm9/Arm9Lib.c
+++ b/ArmPkg/Library/ArmLib/Arm9/Arm9Lib.c
@@ -1,131 +1,131 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include <Chipset/ARM926EJ-S.h>
-#include <Library/ArmLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/MemoryAllocationLib.h>
-#include <Library/DebugLib.h>
-
-VOID
-FillTranslationTable (
-  IN  UINT32                        *TranslationTable,
-  IN  ARM_MEMORY_REGION_DESCRIPTOR  *MemoryRegion
-  )
-{
-  UINT32  *Entry;
-  UINTN   Sections;
-  UINTN   Index;
-  UINT32  Attributes;
-  UINT32  PhysicalBase = MemoryRegion->PhysicalBase;
-  
-  switch (MemoryRegion->Attributes) {
-    case ARM_MEMORY_REGION_ATTRIBUTE_WRITE_BACK:
-      Attributes = TT_DESCRIPTOR_SECTION_WRITE_BACK;
-      break;
-    case ARM_MEMORY_REGION_ATTRIBUTE_WRITE_THROUGH:
-      Attributes = TT_DESCRIPTOR_SECTION_WRITE_THROUGH;
-      break;
-    case ARM_MEMORY_REGION_ATTRIBUTE_UNCACHED_UNBUFFERED:
-      Attributes = TT_DESCRIPTOR_SECTION_UNCACHED_UNBUFFERED;
-      break;
-    case ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_WRITE_BACK:
-    case ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_WRITE_THROUGH:
-    case ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_UNCACHED_UNBUFFERED:
-      ASSERT(0); // Trustzone is not supported on ARMv5
-    default:
-      Attributes = TT_DESCRIPTOR_SECTION_UNCACHED_UNBUFFERED;
-      break;
-  }
-  
-  Entry    = TRANSLATION_TABLE_ENTRY_FOR_VIRTUAL_ADDRESS(TranslationTable, MemoryRegion->VirtualBase);
-  Sections = MemoryRegion->Length / TT_DESCRIPTOR_SECTION_SIZE;
-  
-  // The current code does not support memory region size that is not aligned on TT_DESCRIPTOR_SECTION_SIZE boundary
-  ASSERT (MemoryRegion->Length % TT_DESCRIPTOR_SECTION_SIZE == 0);
-  
-  for (Index = 0; Index < Sections; Index++)
-  {
-    *Entry++     =  TT_DESCRIPTOR_SECTION_BASE_ADDRESS(PhysicalBase) | Attributes;
-    PhysicalBase += TT_DESCRIPTOR_SECTION_SIZE;
-  }
-}
-
-VOID
-EFIAPI
-ArmConfigureMmu (
-  IN  ARM_MEMORY_REGION_DESCRIPTOR  *MemoryTable,
-  OUT VOID                          **TranslationTableBase OPTIONAL,
-  OUT UINTN                         *TranslationTableSize  OPTIONAL
-  )
-{
-  VOID  *TranslationTable;
-
-  // Allocate pages for translation table.
-  TranslationTable = AllocatePages(EFI_SIZE_TO_PAGES(TRANSLATION_TABLE_SIZE + TRANSLATION_TABLE_ALIGNMENT));
-  TranslationTable = (VOID *)(((UINTN)TranslationTable + TRANSLATION_TABLE_ALIGNMENT_MASK) & ~TRANSLATION_TABLE_ALIGNMENT_MASK);
-
-  if (TranslationTableBase != NULL) {
-    *TranslationTableBase = TranslationTable;
-  }
-  
-  if (TranslationTableBase != NULL) {
-    *TranslationTableSize = TRANSLATION_TABLE_SIZE;
-  }
-
-  ZeroMem(TranslationTable, TRANSLATION_TABLE_SIZE);
-
-  ArmCleanInvalidateDataCache();
-  ArmInvalidateInstructionCache();
-  ArmInvalidateTlb();
-
-  ArmDisableDataCache();
-  ArmDisableInstructionCache();
-  ArmDisableMmu();
-
-  // Make sure nothing sneaked into the cache
-  ArmCleanInvalidateDataCache();
-  ArmInvalidateInstructionCache();
-
-  while (MemoryTable->Length != 0) {
-    FillTranslationTable(TranslationTable, MemoryTable);
-    MemoryTable++;
-  }
-
-  ArmSetTTBR0(TranslationTable);
-    
-  ArmSetDomainAccessControl(DOMAIN_ACCESS_CONTROL_NONE(15) |
-                            DOMAIN_ACCESS_CONTROL_NONE(14) |
-                            DOMAIN_ACCESS_CONTROL_NONE(13) |
-                            DOMAIN_ACCESS_CONTROL_NONE(12) |
-                            DOMAIN_ACCESS_CONTROL_NONE(11) |
-                            DOMAIN_ACCESS_CONTROL_NONE(10) |
-                            DOMAIN_ACCESS_CONTROL_NONE( 9) |
-                            DOMAIN_ACCESS_CONTROL_NONE( 8) |
-                            DOMAIN_ACCESS_CONTROL_NONE( 7) |
-                            DOMAIN_ACCESS_CONTROL_NONE( 6) |
-                            DOMAIN_ACCESS_CONTROL_NONE( 5) |
-                            DOMAIN_ACCESS_CONTROL_NONE( 4) |
-                            DOMAIN_ACCESS_CONTROL_NONE( 3) |
-                            DOMAIN_ACCESS_CONTROL_NONE( 2) |
-                            DOMAIN_ACCESS_CONTROL_NONE( 1) |
-                            DOMAIN_ACCESS_CONTROL_MANAGER(0));
-    
-  ArmEnableInstructionCache();
-  ArmEnableDataCache();
-  ArmEnableMmu();
-}
-
-
-
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include <Chipset/ARM926EJ-S.h>

+#include <Library/ArmLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/MemoryAllocationLib.h>

+#include <Library/DebugLib.h>

+

+VOID

+FillTranslationTable (

+  IN  UINT32                        *TranslationTable,

+  IN  ARM_MEMORY_REGION_DESCRIPTOR  *MemoryRegion

+  )

+{

+  UINT32  *Entry;

+  UINTN   Sections;

+  UINTN   Index;

+  UINT32  Attributes;

+  UINT32  PhysicalBase = MemoryRegion->PhysicalBase;

+  

+  switch (MemoryRegion->Attributes) {

+    case ARM_MEMORY_REGION_ATTRIBUTE_WRITE_BACK:

+      Attributes = TT_DESCRIPTOR_SECTION_WRITE_BACK;

+      break;

+    case ARM_MEMORY_REGION_ATTRIBUTE_WRITE_THROUGH:

+      Attributes = TT_DESCRIPTOR_SECTION_WRITE_THROUGH;

+      break;

+    case ARM_MEMORY_REGION_ATTRIBUTE_UNCACHED_UNBUFFERED:

+      Attributes = TT_DESCRIPTOR_SECTION_UNCACHED_UNBUFFERED;

+      break;

+    case ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_WRITE_BACK:

+    case ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_WRITE_THROUGH:

+    case ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_UNCACHED_UNBUFFERED:

+      ASSERT(0); // Trustzone is not supported on ARMv5

+    default:

+      Attributes = TT_DESCRIPTOR_SECTION_UNCACHED_UNBUFFERED;

+      break;

+  }

+  

+  Entry    = TRANSLATION_TABLE_ENTRY_FOR_VIRTUAL_ADDRESS(TranslationTable, MemoryRegion->VirtualBase);

+  Sections = MemoryRegion->Length / TT_DESCRIPTOR_SECTION_SIZE;

+  

+  // The current code does not support memory region size that is not aligned on TT_DESCRIPTOR_SECTION_SIZE boundary

+  ASSERT (MemoryRegion->Length % TT_DESCRIPTOR_SECTION_SIZE == 0);

+  

+  for (Index = 0; Index < Sections; Index++)

+  {

+    *Entry++     =  TT_DESCRIPTOR_SECTION_BASE_ADDRESS(PhysicalBase) | Attributes;

+    PhysicalBase += TT_DESCRIPTOR_SECTION_SIZE;

+  }

+}

+

+VOID

+EFIAPI

+ArmConfigureMmu (

+  IN  ARM_MEMORY_REGION_DESCRIPTOR  *MemoryTable,

+  OUT VOID                          **TranslationTableBase OPTIONAL,

+  OUT UINTN                         *TranslationTableSize  OPTIONAL

+  )

+{

+  VOID  *TranslationTable;

+

+  // Allocate pages for translation table.

+  TranslationTable = AllocatePages(EFI_SIZE_TO_PAGES(TRANSLATION_TABLE_SIZE + TRANSLATION_TABLE_ALIGNMENT));

+  TranslationTable = (VOID *)(((UINTN)TranslationTable + TRANSLATION_TABLE_ALIGNMENT_MASK) & ~TRANSLATION_TABLE_ALIGNMENT_MASK);

+

+  if (TranslationTableBase != NULL) {

+    *TranslationTableBase = TranslationTable;

+  }

+  

+  if (TranslationTableBase != NULL) {

+    *TranslationTableSize = TRANSLATION_TABLE_SIZE;

+  }

+

+  ZeroMem(TranslationTable, TRANSLATION_TABLE_SIZE);

+

+  ArmCleanInvalidateDataCache();

+  ArmInvalidateInstructionCache();

+  ArmInvalidateTlb();

+

+  ArmDisableDataCache();

+  ArmDisableInstructionCache();

+  ArmDisableMmu();

+

+  // Make sure nothing sneaked into the cache

+  ArmCleanInvalidateDataCache();

+  ArmInvalidateInstructionCache();

+

+  while (MemoryTable->Length != 0) {

+    FillTranslationTable(TranslationTable, MemoryTable);

+    MemoryTable++;

+  }

+

+  ArmSetTTBR0(TranslationTable);

+    

+  ArmSetDomainAccessControl(DOMAIN_ACCESS_CONTROL_NONE(15) |

+                            DOMAIN_ACCESS_CONTROL_NONE(14) |

+                            DOMAIN_ACCESS_CONTROL_NONE(13) |

+                            DOMAIN_ACCESS_CONTROL_NONE(12) |

+                            DOMAIN_ACCESS_CONTROL_NONE(11) |

+                            DOMAIN_ACCESS_CONTROL_NONE(10) |

+                            DOMAIN_ACCESS_CONTROL_NONE( 9) |

+                            DOMAIN_ACCESS_CONTROL_NONE( 8) |

+                            DOMAIN_ACCESS_CONTROL_NONE( 7) |

+                            DOMAIN_ACCESS_CONTROL_NONE( 6) |

+                            DOMAIN_ACCESS_CONTROL_NONE( 5) |

+                            DOMAIN_ACCESS_CONTROL_NONE( 4) |

+                            DOMAIN_ACCESS_CONTROL_NONE( 3) |

+                            DOMAIN_ACCESS_CONTROL_NONE( 2) |

+                            DOMAIN_ACCESS_CONTROL_NONE( 1) |

+                            DOMAIN_ACCESS_CONTROL_MANAGER(0));

+    

+  ArmEnableInstructionCache();

+  ArmEnableDataCache();

+  ArmEnableMmu();

+}

+

+

+

diff --git a/ArmPkg/Library/ArmLib/Arm9/Arm9Support.S b/ArmPkg/Library/ArmLib/Arm9/Arm9Support.S
index 49e266dd..28cc5b6e 100644
--- a/ArmPkg/Library/ArmLib/Arm9/Arm9Support.S
+++ b/ArmPkg/Library/ArmLib/Arm9/Arm9Support.S
@@ -1,153 +1,153 @@
-#------------------------------------------------------------------------------ 
-#
-# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-#
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#------------------------------------------------------------------------------
-
-.text
-.align 2
-GCC_ASM_EXPORT(ArmCleanInvalidateDataCache)
-GCC_ASM_EXPORT(ArmCleanDataCache)
-GCC_ASM_EXPORT(ArmInvalidateDataCache)
-GCC_ASM_EXPORT(ArmInvalidateInstructionCache)
-GCC_ASM_EXPORT(ArmInvalidateDataCacheEntryByMVA)
-GCC_ASM_EXPORT(ArmCleanDataCacheEntryByMVA)
-GCC_ASM_EXPORT(ArmCleanInvalidateDataCacheEntryByMVA)
-GCC_ASM_EXPORT(ArmEnableMmu)
-GCC_ASM_EXPORT(ArmDisableMmu)
-GCC_ASM_EXPORT(ArmMmuEnabled)
-GCC_ASM_EXPORT(ArmEnableDataCache)
-GCC_ASM_EXPORT(ArmDisableDataCache)
-GCC_ASM_EXPORT(ArmEnableInstructionCache)
-GCC_ASM_EXPORT(ArmDisableInstructionCache)
-GCC_ASM_EXPORT(ArmEnableBranchPrediction)
-GCC_ASM_EXPORT(ArmDisableBranchPrediction)
-GCC_ASM_EXPORT(ArmDataMemoryBarrier)
-GCC_ASM_EXPORT(ArmDataSyncronizationBarrier)
-GCC_ASM_EXPORT(ArmInstructionSynchronizationBarrier)
-
-
-.set DC_ON, (1<<2)
-.set IC_ON, (1<<12)
-
-#------------------------------------------------------------------------------
-
-ASM_PFX(ArmInvalidateDataCacheEntryByMVA):
-  mcr     p15, 0, r0, c7, c6, 1   @ invalidate single data cache line                                           
-  bx      lr
-
-ASM_PFX(ArmCleanDataCacheEntryByMVA):
-  mcr     p15, 0, r0, c7, c10, 1  @ clean single data cache line     
-  bx      lr
-
-ASM_PFX(ArmCleanInvalidateDataCacheEntryByMVA):
-  mcr     p15, 0, r0, c7, c14, 1  @ clean and invalidate single data cache line
-  bx      lr
-
-ASM_PFX(ArmEnableInstructionCache):
-  ldr    r1,=IC_ON
-  mrc    p15,0,r0,c1,c0,0     @Read control register configuration data
-  orr    r0,r0,r1             @Set I bit
-  mcr    p15,0,r0,c1,c0,0     @Write control register configuration data
-  bx     LR
-  
-ASM_PFX(ArmDisableInstructionCache):
-  ldr    r1,=IC_ON
-  mrc    p15,0,r0,c1,c0,0     @Read control register configuration data
-  bic    r0,r0,r1             @Clear I bit.
-  mcr    p15,0,r0,c1,c0,0     @Write control register configuration data
-  bx     LR
-  
-ASM_PFX(ArmInvalidateInstructionCache):
-  mov     r0,#0
-  mcr     p15,0,r0,c7,c5,0     @Invalidate entire Instruction cache. 
-                         @Also flushes the branch target cache.
-  mov     r0,#0
-  mcr     p15,0,r0,c7,c10,4    @Data write buffer
-  bx      LR
-
-ASM_PFX(ArmEnableMmu):
-  mrc     p15,0,R0,c1,c0,0
-  orr     R0,R0,#1
-  mcr     p15,0,R0,c1,c0,0
-  bx      LR
-
-ASM_PFX(ArmMmuEnabled):
-  mrc     p15,0,R0,c1,c0,0
-  and     R0,R0,#1
-  bx      LR
-
-ASM_PFX(ArmDisableMmu):
-  mrc     p15,0,R0,c1,c0,0
-  bic     R0,R0,#1
-  mcr     p15,0,R0,c1,c0,0
-  mov     R0,#0
-  mcr     p15,0,R0,c7,c10,4     @Drain write buffer
-  bx      LR
-
-ASM_PFX(ArmEnableDataCache):
-  ldr     R1,=DC_ON
-  mrc     p15,0,R0,c1,c0,0      @Read control register configuration data
-  orr     R0,R0,R1              @Set C bit
-  mcr     p15,0,r0,c1,c0,0      @Write control register configuration data
-  bx      LR
-  
-ASM_PFX(ArmDisableDataCache):
-  ldr     R1,=DC_ON
-  mrc     p15,0,R0,c1,c0,0      @Read control register configuration data
-  bic     R0,R0,R1              @Clear C bit
-  mcr     p15,0,r0,c1,c0,0      @Write control register configuration data
-  bx      LR
-
-ASM_PFX(ArmCleanDataCache):
-  mrc     p15,0,r15,c7,c10,3
-  bne     ASM_PFX(ArmCleanDataCache)
-  mov     R0,#0
-  mcr     p15,0,R0,c7,c10,4  @Drain write buffer
-  bx      LR
-    
-ASM_PFX(ArmInvalidateDataCache):
-  mov     R0,#0
-  mcr     p15,0,R0,c7,c6,0        @Invalidate entire data cache
-  mov     R0,#0
-  mcr     p15,0,R0,c7,c10,4       @Drain write buffer
-  bx      LR
-
-ASM_PFX(ArmCleanInvalidateDataCache):
-  mrc     p15,0,r15,c7,c14,3
-  bne     ASM_PFX(ArmCleanInvalidateDataCache)
-  mov     R0,#0
-  mcr     p15,0,R0,c7,c10,4        @Drain write buffer
-  bx      LR
-
-ASM_PFX(ArmEnableBranchPrediction):
-  bx      LR                      @Branch prediction is not supported.
-
-ASM_PFX(ArmDisableBranchPrediction):
-  bx      LR                      @Branch prediction is not supported.
-
-ASM_PFX(ArmDataMemoryBarrier):
-  mov R0, #0
-  mcr P15, #0, R0, C7, C10, #5    @ check if this is OK?
-  bx      LR
-  
-ASM_PFX(ArmDataSyncronizationBarrier):
-  mov R0, #0
-  mcr P15, #0, R0, C7, C10, #4   @ check if this is OK?
-  bx      LR
-  
-ASM_PFX(ArmInstructionSynchronizationBarrier):
-  mov R0, #0
-  mcr P15, #0, R0, C7, C5, #4     @ check if this is OK?
-  bx      LR
-
-ASM_FUNCTION_REMOVE_IF_UNREFERENCED
-
+#------------------------------------------------------------------------------ 

+#

+# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+.text

+.align 2

+GCC_ASM_EXPORT(ArmCleanInvalidateDataCache)

+GCC_ASM_EXPORT(ArmCleanDataCache)

+GCC_ASM_EXPORT(ArmInvalidateDataCache)

+GCC_ASM_EXPORT(ArmInvalidateInstructionCache)

+GCC_ASM_EXPORT(ArmInvalidateDataCacheEntryByMVA)

+GCC_ASM_EXPORT(ArmCleanDataCacheEntryByMVA)

+GCC_ASM_EXPORT(ArmCleanInvalidateDataCacheEntryByMVA)

+GCC_ASM_EXPORT(ArmEnableMmu)

+GCC_ASM_EXPORT(ArmDisableMmu)

+GCC_ASM_EXPORT(ArmMmuEnabled)

+GCC_ASM_EXPORT(ArmEnableDataCache)

+GCC_ASM_EXPORT(ArmDisableDataCache)

+GCC_ASM_EXPORT(ArmEnableInstructionCache)

+GCC_ASM_EXPORT(ArmDisableInstructionCache)

+GCC_ASM_EXPORT(ArmEnableBranchPrediction)

+GCC_ASM_EXPORT(ArmDisableBranchPrediction)

+GCC_ASM_EXPORT(ArmDataMemoryBarrier)

+GCC_ASM_EXPORT(ArmDataSyncronizationBarrier)

+GCC_ASM_EXPORT(ArmInstructionSynchronizationBarrier)

+

+

+.set DC_ON, (1<<2)

+.set IC_ON, (1<<12)

+

+#------------------------------------------------------------------------------

+

+ASM_PFX(ArmInvalidateDataCacheEntryByMVA):

+  mcr     p15, 0, r0, c7, c6, 1   @ invalidate single data cache line                                           

+  bx      lr

+

+ASM_PFX(ArmCleanDataCacheEntryByMVA):

+  mcr     p15, 0, r0, c7, c10, 1  @ clean single data cache line     

+  bx      lr

+

+ASM_PFX(ArmCleanInvalidateDataCacheEntryByMVA):

+  mcr     p15, 0, r0, c7, c14, 1  @ clean and invalidate single data cache line

+  bx      lr

+

+ASM_PFX(ArmEnableInstructionCache):

+  ldr    r1,=IC_ON

+  mrc    p15,0,r0,c1,c0,0     @Read control register configuration data

+  orr    r0,r0,r1             @Set I bit

+  mcr    p15,0,r0,c1,c0,0     @Write control register configuration data

+  bx     LR

+  

+ASM_PFX(ArmDisableInstructionCache):

+  ldr    r1,=IC_ON

+  mrc    p15,0,r0,c1,c0,0     @Read control register configuration data

+  bic    r0,r0,r1             @Clear I bit.

+  mcr    p15,0,r0,c1,c0,0     @Write control register configuration data

+  bx     LR

+  

+ASM_PFX(ArmInvalidateInstructionCache):

+  mov     r0,#0

+  mcr     p15,0,r0,c7,c5,0     @Invalidate entire Instruction cache. 

+                         @Also flushes the branch target cache.

+  mov     r0,#0

+  mcr     p15,0,r0,c7,c10,4    @Data write buffer

+  bx      LR

+

+ASM_PFX(ArmEnableMmu):

+  mrc     p15,0,R0,c1,c0,0

+  orr     R0,R0,#1

+  mcr     p15,0,R0,c1,c0,0

+  bx      LR

+

+ASM_PFX(ArmMmuEnabled):

+  mrc     p15,0,R0,c1,c0,0

+  and     R0,R0,#1

+  bx      LR

+

+ASM_PFX(ArmDisableMmu):

+  mrc     p15,0,R0,c1,c0,0

+  bic     R0,R0,#1

+  mcr     p15,0,R0,c1,c0,0

+  mov     R0,#0

+  mcr     p15,0,R0,c7,c10,4     @Drain write buffer

+  bx      LR

+

+ASM_PFX(ArmEnableDataCache):

+  ldr     R1,=DC_ON

+  mrc     p15,0,R0,c1,c0,0      @Read control register configuration data

+  orr     R0,R0,R1              @Set C bit

+  mcr     p15,0,r0,c1,c0,0      @Write control register configuration data

+  bx      LR

+  

+ASM_PFX(ArmDisableDataCache):

+  ldr     R1,=DC_ON

+  mrc     p15,0,R0,c1,c0,0      @Read control register configuration data

+  bic     R0,R0,R1              @Clear C bit

+  mcr     p15,0,r0,c1,c0,0      @Write control register configuration data

+  bx      LR

+

+ASM_PFX(ArmCleanDataCache):

+  mrc     p15,0,r15,c7,c10,3

+  bne     ASM_PFX(ArmCleanDataCache)

+  mov     R0,#0

+  mcr     p15,0,R0,c7,c10,4  @Drain write buffer

+  bx      LR

+    

+ASM_PFX(ArmInvalidateDataCache):

+  mov     R0,#0

+  mcr     p15,0,R0,c7,c6,0        @Invalidate entire data cache

+  mov     R0,#0

+  mcr     p15,0,R0,c7,c10,4       @Drain write buffer

+  bx      LR

+

+ASM_PFX(ArmCleanInvalidateDataCache):

+  mrc     p15,0,r15,c7,c14,3

+  bne     ASM_PFX(ArmCleanInvalidateDataCache)

+  mov     R0,#0

+  mcr     p15,0,R0,c7,c10,4        @Drain write buffer

+  bx      LR

+

+ASM_PFX(ArmEnableBranchPrediction):

+  bx      LR                      @Branch prediction is not supported.

+

+ASM_PFX(ArmDisableBranchPrediction):

+  bx      LR                      @Branch prediction is not supported.

+

+ASM_PFX(ArmDataMemoryBarrier):

+  mov R0, #0

+  mcr P15, #0, R0, C7, C10, #5    @ check if this is OK?

+  bx      LR

+  

+ASM_PFX(ArmDataSyncronizationBarrier):

+  mov R0, #0

+  mcr P15, #0, R0, C7, C10, #4   @ check if this is OK?

+  bx      LR

+  

+ASM_PFX(ArmInstructionSynchronizationBarrier):

+  mov R0, #0

+  mcr P15, #0, R0, C7, C5, #4     @ check if this is OK?

+  bx      LR

+

+ASM_FUNCTION_REMOVE_IF_UNREFERENCED

+

diff --git a/ArmPkg/Library/ArmLib/Arm9/Arm9Support.asm b/ArmPkg/Library/ArmLib/Arm9/Arm9Support.asm
index dfee136b..fc87828e 100644
--- a/ArmPkg/Library/ArmLib/Arm9/Arm9Support.asm
+++ b/ArmPkg/Library/ArmLib/Arm9/Arm9Support.asm
@@ -1,153 +1,153 @@
-//------------------------------------------------------------------------------ 
-//
-// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-//
-// This program and the accompanying materials
-// are licensed and made available under the terms and conditions of the BSD License
-// which accompanies this distribution.  The full text of the license may be found at
-// http://opensource.org/licenses/bsd-license.php
-//
-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-//
-//------------------------------------------------------------------------------
-
-    EXPORT  ArmCleanInvalidateDataCache
-    EXPORT  ArmCleanDataCache
-    EXPORT  ArmInvalidateDataCache
-    EXPORT  ArmInvalidateInstructionCache
-    EXPORT  ArmInvalidateDataCacheEntryByMVA
-    EXPORT  ArmCleanDataCacheEntryByMVA
-    EXPORT  ArmCleanInvalidateDataCacheEntryByMVA
-    EXPORT  ArmEnableMmu
-    EXPORT  ArmDisableMmu
-    EXPORT  ArmMmuEnabled
-    EXPORT  ArmEnableDataCache
-    EXPORT  ArmDisableDataCache
-    EXPORT  ArmEnableInstructionCache
-    EXPORT  ArmDisableInstructionCache
-    EXPORT  ArmEnableBranchPrediction
-    EXPORT  ArmDisableBranchPrediction
-    EXPORT  ArmDataMemoryBarrier
-    EXPORT  ArmDataSyncronizationBarrier
-    EXPORT  ArmInstructionSynchronizationBarrier
-
-
-DC_ON       EQU     ( 0x1:SHL:2 )
-IC_ON       EQU     ( 0x1:SHL:12 )
-
-    AREA    ArmCacheLib, CODE, READONLY
-    PRESERVE8
-
-
-ArmInvalidateDataCacheEntryByMVA
-  MCR     p15, 0, r0, c7, c6, 1   ; invalidate single data cache line                                           
-  BX      lr
-
-
-ArmCleanDataCacheEntryByMVA
-  MCR     p15, 0, r0, c7, c10, 1  ; clean single data cache line     
-  BX      lr
-
-
-ArmCleanInvalidateDataCacheEntryByMVA
-  MCR     p15, 0, r0, c7, c14, 1  ; clean and invalidate single data cache line
-  BX      lr
-
-ArmEnableInstructionCache
-  LDR     R1,=IC_ON
-  MRC     p15,0,R0,c1,c0,0     ;Read control register configuration data
-  ORR     R0,R0,R1             ;Set I bit
-  MCR     p15,0,r0,c1,c0,0     ;Write control register configuration data
-  BX      LR
-  
-ArmDisableInstructionCache
-  LDR     R1,=IC_ON
-  MRC     p15,0,R0,c1,c0,0     ;Read control register configuration data
-  BIC     R0,R0,R1             ;Clear I bit.
-  MCR     p15,0,r0,c1,c0,0     ;Write control register configuration data
-  BX      LR
-
-ArmInvalidateInstructionCache
-  MOV     R0,#0
-  MCR     p15,0,R0,c7,c5,0      ;Invalidate entire instruction cache
-  MOV     R0,#0
-  MCR     p15,0,R0,c7,c10,4     ;Drain write buffer
-  BX      LR
-
-ArmEnableMmu
-  mrc     p15,0,R0,c1,c0,0
-  orr     R0,R0,#1
-  mcr     p15,0,R0,c1,c0,0
-  bx      LR
-
-ArmMmuEnabled
-  mrc     p15,0,R0,c1,c0,0
-  and     R0,R0,#1
-  bx      LR
-
-ArmDisableMmu
-  mrc     p15,0,R0,c1,c0,0
-  bic     R0,R0,#1
-  mcr     p15,0,R0,c1,c0,0
-  mov     R0,#0
-  mcr     p15,0,R0,c7,c10,4     ;Drain write buffer
-  bx      LR
-
-ArmEnableDataCache
-  LDR     R1,=DC_ON
-  MRC     p15,0,R0,c1,c0,0      ;Read control register configuration data
-  ORR     R0,R0,R1              ;Set C bit
-  MCR     p15,0,r0,c1,c0,0      ;Write control register configuration data
-  BX      LR
-    
-ArmDisableDataCache
-  LDR     R1,=DC_ON
-  MRC     p15,0,R0,c1,c0,0      ;Read control register configuration data
-  BIC     R0,R0,R1              ;Clear C bit
-  MCR     p15,0,r0,c1,c0,0      ;Write control register configuration data
-  BX      LR
-
-ArmCleanDataCache
-  MRC     p15,0,r15,c7,c10,3
-  BNE     ArmCleanDataCache
-  MOV     R0,#0
-  MCR     p15,0,R0,c7,c10,4      ;Drain write buffer
-  BX      LR
-
-ArmInvalidateDataCache
-  MOV     R0,#0
-  MCR     p15,0,R0,c7,c6,0      ;Invalidate entire data cache
-  MOV     R0,#0
-  MCR     p15,0,R0,c7,c10,4     ;Drain write buffer
-  BX      LR
-  
-ArmCleanInvalidateDataCache
-  MRC     p15,0,r15,c7,c14,3
-  BNE     ArmCleanInvalidateDataCache
-  MOV     R0,#0
-  MCR     p15,0,R0,c7,c10,4      ;Drain write buffer
-  BX      LR
-
-ArmEnableBranchPrediction
-  bx      LR                    ;Branch prediction is not supported.
-
-ArmDisableBranchPrediction
-  bx      LR                    ;Branch prediction is not supported.
-
-ASM_PFX(ArmDataMemoryBarrier):
-  mov R0, #0
-  mcr P15, #0, R0, C7, C10, #5  ; Check to see if this is correct
-  bx      LR
-  
-ASM_PFX(ArmDataSyncronizationBarrier):
-  mov R0, #0
-  mcr P15, #0, R0, C7, C10, #4 ; Check to see if this is correct
-  bx      LR
-  
-ASM_PFX(ArmInstructionSynchronizationBarrier):
-  MOV R0, #0
-  MCR P15, #0, R0, C7, C5, #4 ; Check to see if this is correct
-  bx      LR
-
-    END
+//------------------------------------------------------------------------------ 

+//

+// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+//

+// This program and the accompanying materials

+// are licensed and made available under the terms and conditions of the BSD License

+// which accompanies this distribution.  The full text of the license may be found at

+// http://opensource.org/licenses/bsd-license.php

+//

+// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+//

+//------------------------------------------------------------------------------

+

+    EXPORT  ArmCleanInvalidateDataCache

+    EXPORT  ArmCleanDataCache

+    EXPORT  ArmInvalidateDataCache

+    EXPORT  ArmInvalidateInstructionCache

+    EXPORT  ArmInvalidateDataCacheEntryByMVA

+    EXPORT  ArmCleanDataCacheEntryByMVA

+    EXPORT  ArmCleanInvalidateDataCacheEntryByMVA

+    EXPORT  ArmEnableMmu

+    EXPORT  ArmDisableMmu

+    EXPORT  ArmMmuEnabled

+    EXPORT  ArmEnableDataCache

+    EXPORT  ArmDisableDataCache

+    EXPORT  ArmEnableInstructionCache

+    EXPORT  ArmDisableInstructionCache

+    EXPORT  ArmEnableBranchPrediction

+    EXPORT  ArmDisableBranchPrediction

+    EXPORT  ArmDataMemoryBarrier

+    EXPORT  ArmDataSyncronizationBarrier

+    EXPORT  ArmInstructionSynchronizationBarrier

+

+

+DC_ON       EQU     ( 0x1:SHL:2 )

+IC_ON       EQU     ( 0x1:SHL:12 )

+

+    AREA    ArmCacheLib, CODE, READONLY

+    PRESERVE8

+

+

+ArmInvalidateDataCacheEntryByMVA

+  MCR     p15, 0, r0, c7, c6, 1   ; invalidate single data cache line                                           

+  BX      lr

+

+

+ArmCleanDataCacheEntryByMVA

+  MCR     p15, 0, r0, c7, c10, 1  ; clean single data cache line     

+  BX      lr

+

+

+ArmCleanInvalidateDataCacheEntryByMVA

+  MCR     p15, 0, r0, c7, c14, 1  ; clean and invalidate single data cache line

+  BX      lr

+

+ArmEnableInstructionCache

+  LDR     R1,=IC_ON

+  MRC     p15,0,R0,c1,c0,0     ;Read control register configuration data

+  ORR     R0,R0,R1             ;Set I bit

+  MCR     p15,0,r0,c1,c0,0     ;Write control register configuration data

+  BX      LR

+  

+ArmDisableInstructionCache

+  LDR     R1,=IC_ON

+  MRC     p15,0,R0,c1,c0,0     ;Read control register configuration data

+  BIC     R0,R0,R1             ;Clear I bit.

+  MCR     p15,0,r0,c1,c0,0     ;Write control register configuration data

+  BX      LR

+

+ArmInvalidateInstructionCache

+  MOV     R0,#0

+  MCR     p15,0,R0,c7,c5,0      ;Invalidate entire instruction cache

+  MOV     R0,#0

+  MCR     p15,0,R0,c7,c10,4     ;Drain write buffer

+  BX      LR

+

+ArmEnableMmu

+  mrc     p15,0,R0,c1,c0,0

+  orr     R0,R0,#1

+  mcr     p15,0,R0,c1,c0,0

+  bx      LR

+

+ArmMmuEnabled

+  mrc     p15,0,R0,c1,c0,0

+  and     R0,R0,#1

+  bx      LR

+

+ArmDisableMmu

+  mrc     p15,0,R0,c1,c0,0

+  bic     R0,R0,#1

+  mcr     p15,0,R0,c1,c0,0

+  mov     R0,#0

+  mcr     p15,0,R0,c7,c10,4     ;Drain write buffer

+  bx      LR

+

+ArmEnableDataCache

+  LDR     R1,=DC_ON

+  MRC     p15,0,R0,c1,c0,0      ;Read control register configuration data

+  ORR     R0,R0,R1              ;Set C bit

+  MCR     p15,0,r0,c1,c0,0      ;Write control register configuration data

+  BX      LR

+    

+ArmDisableDataCache

+  LDR     R1,=DC_ON

+  MRC     p15,0,R0,c1,c0,0      ;Read control register configuration data

+  BIC     R0,R0,R1              ;Clear C bit

+  MCR     p15,0,r0,c1,c0,0      ;Write control register configuration data

+  BX      LR

+

+ArmCleanDataCache

+  MRC     p15,0,r15,c7,c10,3

+  BNE     ArmCleanDataCache

+  MOV     R0,#0

+  MCR     p15,0,R0,c7,c10,4      ;Drain write buffer

+  BX      LR

+

+ArmInvalidateDataCache

+  MOV     R0,#0

+  MCR     p15,0,R0,c7,c6,0      ;Invalidate entire data cache

+  MOV     R0,#0

+  MCR     p15,0,R0,c7,c10,4     ;Drain write buffer

+  BX      LR

+  

+ArmCleanInvalidateDataCache

+  MRC     p15,0,r15,c7,c14,3

+  BNE     ArmCleanInvalidateDataCache

+  MOV     R0,#0

+  MCR     p15,0,R0,c7,c10,4      ;Drain write buffer

+  BX      LR

+

+ArmEnableBranchPrediction

+  bx      LR                    ;Branch prediction is not supported.

+

+ArmDisableBranchPrediction

+  bx      LR                    ;Branch prediction is not supported.

+

+ASM_PFX(ArmDataMemoryBarrier):

+  mov R0, #0

+  mcr P15, #0, R0, C7, C10, #5  ; Check to see if this is correct

+  bx      LR

+  

+ASM_PFX(ArmDataSyncronizationBarrier):

+  mov R0, #0

+  mcr P15, #0, R0, C7, C10, #4 ; Check to see if this is correct

+  bx      LR

+  

+ASM_PFX(ArmInstructionSynchronizationBarrier):

+  MOV R0, #0

+  MCR P15, #0, R0, C7, C5, #4 ; Check to see if this is correct

+  bx      LR

+

+    END

diff --git a/ArmPkg/Library/ArmLib/ArmV7/ArmV7ArchTimer.c b/ArmPkg/Library/ArmLib/ArmV7/ArmV7ArchTimer.c
index 7835b414..478a5da6 100644
--- a/ArmPkg/Library/ArmLib/ArmV7/ArmV7ArchTimer.c
+++ b/ArmPkg/Library/ArmLib/ArmV7/ArmV7ArchTimer.c
@@ -1,275 +1,275 @@
-/** @file
-*
-*  Copyright (c) 2011, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-#include <Uefi.h> 
-#include <Chipset/ArmV7.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/MemoryAllocationLib.h>
-#include <Library/ArmLib.h>
-#include <Library/BaseLib.h>
-#include <Library/DebugLib.h>
-#include "ArmV7Lib.h"
-#include "ArmLibPrivate.h"
-#include <Library/ArmV7ArchTimerLib.h>
-
-VOID
-EFIAPI
-ArmArchTimerReadReg (
-    IN   ARM_ARCH_TIMER_REGS   Reg,
-    OUT  VOID                  *DstBuf
-    )
-{
-  // Check if the Generic/Architecture timer is implemented
-  if (ArmIsArchTimerImplemented ()) {
-
-    switch (Reg) {
-
-    case CntFrq:
-      *((UINTN *)DstBuf) = ArmReadCntFrq ();
-      break;
-
-    case CntPct:
-      *((UINT64 *)DstBuf) = ArmReadCntPct ();
-      break;
-
-    case CntkCtl:
-      *((UINTN *)DstBuf) = ArmReadCntkCtl();
-      break;
-
-    case CntpTval:
-      *((UINTN *)DstBuf) = ArmReadCntpTval ();
-      break;
-
-    case CntpCtl:
-      *((UINTN *)DstBuf) = ArmReadCntpCtl ();
-      break;
-
-    case CntvTval:
-      *((UINTN *)DstBuf) = ArmReadCntvTval ();
-      break;
-
-    case CntvCtl:
-      *((UINTN *)DstBuf) = ArmReadCntvCtl ();
-      break;
-
-    case CntvCt:
-      *((UINT64 *)DstBuf) = ArmReadCntvCt ();
-      break;
-
-    case CntpCval:
-      *((UINT64 *)DstBuf) = ArmReadCntpCval ();
-      break;
-
-    case CntvCval:
-      *((UINT64 *)DstBuf) = ArmReadCntvCval ();
-      break;
-
-    case CntvOff:
-      *((UINT64 *)DstBuf) = ArmReadCntvOff ();
-      break;
-
-    case CnthCtl:
-    case CnthpTval:
-    case CnthpCtl:
-    case CnthpCval:
-    DEBUG ((EFI_D_ERROR, "The register is related to Hypervisor Mode. Can't perform requested operation\n "));
-      break;
-
-    default:
-      DEBUG ((EFI_D_ERROR, "Unknown ARM Generic Timer register %x. \n ", Reg));
-    }
-  } else {
-    DEBUG ((EFI_D_ERROR, "Attempt to read ARM Generic Timer registers. But ARM Generic Timer extension is not implemented \n "));
-    ASSERT (0);
-  }
-}
-
-VOID
-EFIAPI
-ArmArchTimerWriteReg (
-    IN   ARM_ARCH_TIMER_REGS   Reg,
-    IN   VOID                  *SrcBuf
-    )
-{
-  // Check if the Generic/Architecture timer is implemented
-  if (ArmIsArchTimerImplemented ()) {
-
-    switch (Reg) {
-
-    case CntFrq:
-      ArmWriteCntFrq (*((UINTN *)SrcBuf));
-      break;
-
-    case CntPct:
-      DEBUG ((EFI_D_ERROR, "Can't write to Read Only Register: CNTPCT \n"));
-      break;
-
-    case CntkCtl:
-      ArmWriteCntkCtl (*((UINTN *)SrcBuf));
-      break;
-
-    case CntpTval:
-      ArmWriteCntpTval (*((UINTN *)SrcBuf));
-      break;
-
-    case CntpCtl:
-      ArmWriteCntpCtl (*((UINTN *)SrcBuf));
-      break;
-
-    case CntvTval:
-      ArmWriteCntvTval (*((UINTN *)SrcBuf));
-      break;
-
-    case CntvCtl:
-      ArmWriteCntvCtl (*((UINTN *)SrcBuf));
-      break;
-
-    case CntvCt:
-      DEBUG ((EFI_D_ERROR, "Can't write to Read Only Register: CNTVCT \n"));
-      break;
-
-    case CntpCval:
-      ArmWriteCntpCval (*((UINT64 *)SrcBuf) );
-      break;
-
-    case CntvCval:
-      ArmWriteCntvCval (*((UINT64 *)SrcBuf) );
-      break;
-
-    case CntvOff:
-      ArmWriteCntvOff (*((UINT64 *)SrcBuf));
-      break;
-
-    case CnthCtl:
-    case CnthpTval:
-    case CnthpCtl:
-    case CnthpCval:
-      DEBUG ((EFI_D_ERROR, "The register is related to Hypervisor Mode. Can't perform requested operation\n "));
-      break;
-
-    default:
-      DEBUG ((EFI_D_ERROR, "Unknown ARM Generic Timer register %x. \n ", Reg));
-    }
-  } else {
-    DEBUG ((EFI_D_ERROR, "Attempt to write to ARM Generic Timer registers. But ARM Generic Timer extension is not implemented \n "));
-    ASSERT (0);
-  }
-}
-
-VOID
-EFIAPI
-ArmArchTimerEnableTimer (
-    VOID
-    )
-{
-  UINTN TimerCtrlReg;
-
-  ArmArchTimerReadReg (CntpCtl, (VOID *)&TimerCtrlReg);
-  TimerCtrlReg |= ARM_ARCH_TIMER_ENABLE;
-  ArmArchTimerWriteReg (CntpCtl, (VOID *)&TimerCtrlReg);
-}
-
-VOID
-EFIAPI
-ArmArchTimerDisableTimer (
-    VOID
-    )
-{
-  UINTN TimerCtrlReg;
-
-  ArmArchTimerReadReg (CntpCtl, (VOID *)&TimerCtrlReg);
-  TimerCtrlReg &= ~ARM_ARCH_TIMER_ENABLE;
-  ArmArchTimerWriteReg (CntpCtl, (VOID *)&TimerCtrlReg);
-}
-
-VOID
-EFIAPI
-ArmArchTimerSetTimerFreq (
-    IN   UINTN  FreqInHz
-    )
-{
-  ArmArchTimerWriteReg (CntFrq, (VOID *)&FreqInHz);
-}
-
-UINTN
-EFIAPI
-ArmArchTimerGetTimerFreq (
-    VOID
-    )
-{
-  UINTN ArchTimerFreq = 0;
-  ArmArchTimerReadReg (CntFrq, (VOID *)&ArchTimerFreq);
-  return ArchTimerFreq;
-}
-
-UINTN
-EFIAPI
-ArmArchTimerGetTimerVal (
-    VOID
-    )
-{
-  UINTN ArchTimerVal;
-  ArmArchTimerReadReg (CntpTval, (VOID *)&ArchTimerVal);
-  return ArchTimerVal;
-}
-
-
-VOID
-EFIAPI
-ArmArchTimerSetTimerVal (
-    IN   UINTN   Val
-    )
-{
-  ArmArchTimerWriteReg (CntpTval, (VOID *)&Val);
-}
-
-UINT64
-EFIAPI
-ArmArchTimerGetSystemCount (
-    VOID
-    )
-{
-  UINT64 SystemCount;
-  ArmArchTimerReadReg (CntPct, (VOID *)&SystemCount);
-  return SystemCount;
-}
-
-UINTN
-EFIAPI
-ArmArchTimerGetTimerCtrlReg (
-    VOID
-    )
-{
-  UINTN  Val;
-  ArmArchTimerReadReg (CntpCtl, (VOID *)&Val);
-  return Val;
-}
-
-VOID
-EFIAPI
-ArmArchTimerSetTimerCtrlReg (
-    UINTN Val
-    )
-{
-  ArmArchTimerWriteReg (CntpCtl, (VOID *)&Val);
-}
-
-VOID
-EFIAPI
-ArmArchTimerSetCompareVal (
-    IN   UINT64   Val
-    )
-{
-  ArmArchTimerWriteReg (CntpCval, (VOID *)&Val);
-}
+/** @file

+*

+*  Copyright (c) 2011, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+#include <Uefi.h> 

+#include <Chipset/ArmV7.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/MemoryAllocationLib.h>

+#include <Library/ArmLib.h>

+#include <Library/BaseLib.h>

+#include <Library/DebugLib.h>

+#include "ArmV7Lib.h"

+#include "ArmLibPrivate.h"

+#include <Library/ArmV7ArchTimerLib.h>

+

+VOID

+EFIAPI

+ArmArchTimerReadReg (

+    IN   ARM_ARCH_TIMER_REGS   Reg,

+    OUT  VOID                  *DstBuf

+    )

+{

+  // Check if the Generic/Architecture timer is implemented

+  if (ArmIsArchTimerImplemented ()) {

+

+    switch (Reg) {

+

+    case CntFrq:

+      *((UINTN *)DstBuf) = ArmReadCntFrq ();

+      break;

+

+    case CntPct:

+      *((UINT64 *)DstBuf) = ArmReadCntPct ();

+      break;

+

+    case CntkCtl:

+      *((UINTN *)DstBuf) = ArmReadCntkCtl();

+      break;

+

+    case CntpTval:

+      *((UINTN *)DstBuf) = ArmReadCntpTval ();

+      break;

+

+    case CntpCtl:

+      *((UINTN *)DstBuf) = ArmReadCntpCtl ();

+      break;

+

+    case CntvTval:

+      *((UINTN *)DstBuf) = ArmReadCntvTval ();

+      break;

+

+    case CntvCtl:

+      *((UINTN *)DstBuf) = ArmReadCntvCtl ();

+      break;

+

+    case CntvCt:

+      *((UINT64 *)DstBuf) = ArmReadCntvCt ();

+      break;

+

+    case CntpCval:

+      *((UINT64 *)DstBuf) = ArmReadCntpCval ();

+      break;

+

+    case CntvCval:

+      *((UINT64 *)DstBuf) = ArmReadCntvCval ();

+      break;

+

+    case CntvOff:

+      *((UINT64 *)DstBuf) = ArmReadCntvOff ();

+      break;

+

+    case CnthCtl:

+    case CnthpTval:

+    case CnthpCtl:

+    case CnthpCval:

+    DEBUG ((EFI_D_ERROR, "The register is related to Hypervisor Mode. Can't perform requested operation\n "));

+      break;

+

+    default:

+      DEBUG ((EFI_D_ERROR, "Unknown ARM Generic Timer register %x. \n ", Reg));

+    }

+  } else {

+    DEBUG ((EFI_D_ERROR, "Attempt to read ARM Generic Timer registers. But ARM Generic Timer extension is not implemented \n "));

+    ASSERT (0);

+  }

+}

+

+VOID

+EFIAPI

+ArmArchTimerWriteReg (

+    IN   ARM_ARCH_TIMER_REGS   Reg,

+    IN   VOID                  *SrcBuf

+    )

+{

+  // Check if the Generic/Architecture timer is implemented

+  if (ArmIsArchTimerImplemented ()) {

+

+    switch (Reg) {

+

+    case CntFrq:

+      ArmWriteCntFrq (*((UINTN *)SrcBuf));

+      break;

+

+    case CntPct:

+      DEBUG ((EFI_D_ERROR, "Can't write to Read Only Register: CNTPCT \n"));

+      break;

+

+    case CntkCtl:

+      ArmWriteCntkCtl (*((UINTN *)SrcBuf));

+      break;

+

+    case CntpTval:

+      ArmWriteCntpTval (*((UINTN *)SrcBuf));

+      break;

+

+    case CntpCtl:

+      ArmWriteCntpCtl (*((UINTN *)SrcBuf));

+      break;

+

+    case CntvTval:

+      ArmWriteCntvTval (*((UINTN *)SrcBuf));

+      break;

+

+    case CntvCtl:

+      ArmWriteCntvCtl (*((UINTN *)SrcBuf));

+      break;

+

+    case CntvCt:

+      DEBUG ((EFI_D_ERROR, "Can't write to Read Only Register: CNTVCT \n"));

+      break;

+

+    case CntpCval:

+      ArmWriteCntpCval (*((UINT64 *)SrcBuf) );

+      break;

+

+    case CntvCval:

+      ArmWriteCntvCval (*((UINT64 *)SrcBuf) );

+      break;

+

+    case CntvOff:

+      ArmWriteCntvOff (*((UINT64 *)SrcBuf));

+      break;

+

+    case CnthCtl:

+    case CnthpTval:

+    case CnthpCtl:

+    case CnthpCval:

+      DEBUG ((EFI_D_ERROR, "The register is related to Hypervisor Mode. Can't perform requested operation\n "));

+      break;

+

+    default:

+      DEBUG ((EFI_D_ERROR, "Unknown ARM Generic Timer register %x. \n ", Reg));

+    }

+  } else {

+    DEBUG ((EFI_D_ERROR, "Attempt to write to ARM Generic Timer registers. But ARM Generic Timer extension is not implemented \n "));

+    ASSERT (0);

+  }

+}

+

+VOID

+EFIAPI

+ArmArchTimerEnableTimer (

+    VOID

+    )

+{

+  UINTN TimerCtrlReg;

+

+  ArmArchTimerReadReg (CntpCtl, (VOID *)&TimerCtrlReg);

+  TimerCtrlReg |= ARM_ARCH_TIMER_ENABLE;

+  ArmArchTimerWriteReg (CntpCtl, (VOID *)&TimerCtrlReg);

+}

+

+VOID

+EFIAPI

+ArmArchTimerDisableTimer (

+    VOID

+    )

+{

+  UINTN TimerCtrlReg;

+

+  ArmArchTimerReadReg (CntpCtl, (VOID *)&TimerCtrlReg);

+  TimerCtrlReg &= ~ARM_ARCH_TIMER_ENABLE;

+  ArmArchTimerWriteReg (CntpCtl, (VOID *)&TimerCtrlReg);

+}

+

+VOID

+EFIAPI

+ArmArchTimerSetTimerFreq (

+    IN   UINTN  FreqInHz

+    )

+{

+  ArmArchTimerWriteReg (CntFrq, (VOID *)&FreqInHz);

+}

+

+UINTN

+EFIAPI

+ArmArchTimerGetTimerFreq (

+    VOID

+    )

+{

+  UINTN ArchTimerFreq = 0;

+  ArmArchTimerReadReg (CntFrq, (VOID *)&ArchTimerFreq);

+  return ArchTimerFreq;

+}

+

+UINTN

+EFIAPI

+ArmArchTimerGetTimerVal (

+    VOID

+    )

+{

+  UINTN ArchTimerVal;

+  ArmArchTimerReadReg (CntpTval, (VOID *)&ArchTimerVal);

+  return ArchTimerVal;

+}

+

+

+VOID

+EFIAPI

+ArmArchTimerSetTimerVal (

+    IN   UINTN   Val

+    )

+{

+  ArmArchTimerWriteReg (CntpTval, (VOID *)&Val);

+}

+

+UINT64

+EFIAPI

+ArmArchTimerGetSystemCount (

+    VOID

+    )

+{

+  UINT64 SystemCount;

+  ArmArchTimerReadReg (CntPct, (VOID *)&SystemCount);

+  return SystemCount;

+}

+

+UINTN

+EFIAPI

+ArmArchTimerGetTimerCtrlReg (

+    VOID

+    )

+{

+  UINTN  Val;

+  ArmArchTimerReadReg (CntpCtl, (VOID *)&Val);

+  return Val;

+}

+

+VOID

+EFIAPI

+ArmArchTimerSetTimerCtrlReg (

+    UINTN Val

+    )

+{

+  ArmArchTimerWriteReg (CntpCtl, (VOID *)&Val);

+}

+

+VOID

+EFIAPI

+ArmArchTimerSetCompareVal (

+    IN   UINT64   Val

+    )

+{

+  ArmArchTimerWriteReg (CntpCval, (VOID *)&Val);

+}

diff --git a/ArmPkg/Library/ArmLib/ArmV7/ArmV7Lib.c b/ArmPkg/Library/ArmLib/ArmV7/ArmV7Lib.c
index d9cf8826..cc5074bf 100644
--- a/ArmPkg/Library/ArmLib/ArmV7/ArmV7Lib.c
+++ b/ArmPkg/Library/ArmLib/ArmV7/ArmV7Lib.c
@@ -1,264 +1,264 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-#include <Uefi.h>
-#include <Chipset/ArmV7.h>
-#include <Library/ArmLib.h>
-#include <Library/BaseLib.h>
-#include <Library/IoLib.h>
-#include "ArmV7Lib.h"
-#include "ArmLibPrivate.h"
-
-ARM_CACHE_TYPE
-EFIAPI
-ArmCacheType (
-  VOID
-  )
-{
-  return ARM_CACHE_TYPE_WRITE_BACK;
-}
-
-ARM_CACHE_ARCHITECTURE
-EFIAPI
-ArmCacheArchitecture (
-  VOID
-  )
-{
-  UINT32 CLIDR = ReadCLIDR ();
-
-  return (ARM_CACHE_ARCHITECTURE)CLIDR; // BugBug Fix Me
-}
-
-BOOLEAN
-EFIAPI
-ArmDataCachePresent (
-  VOID
-  )
-{
-  UINT32 CLIDR = ReadCLIDR ();
-  
-  if ((CLIDR & 0x2) == 0x2) {
-    // Instruction cache exists
-    return TRUE;
-  }
-  if ((CLIDR & 0x7) == 0x4) {
-    // Unified cache
-    return TRUE;
-  }
-  
-  return FALSE;
-}
-  
-UINTN
-EFIAPI
-ArmDataCacheSize (
-  VOID
-  )
-{
-  UINT32 NumSets;
-  UINT32 Associativity;
-  UINT32 LineSize;
-  UINT32 CCSIDR = ReadCCSIDR (0);
-  
-  LineSize      = (1 << ((CCSIDR & 0x7) + 2));
-  Associativity = ((CCSIDR >> 3) & 0x3ff) + 1;
-  NumSets       = ((CCSIDR >> 13) & 0x7fff) + 1;
-
-  // LineSize is in words (4 byte chunks)
-  return  NumSets * Associativity * LineSize * 4;      
-}
-  
-UINTN
-EFIAPI
-ArmDataCacheAssociativity (
-  VOID
-  )
-{
-  UINT32 CCSIDR = ReadCCSIDR (0);
-
-  return ((CCSIDR >> 3) & 0x3ff) + 1;
-}
-  
-UINTN
-ArmDataCacheSets (
-  VOID
-  )
-{
-  UINT32 CCSIDR = ReadCCSIDR (0);
-  
-  return ((CCSIDR >> 13) & 0x7fff) + 1;
-}
-
-UINTN
-EFIAPI
-ArmDataCacheLineLength (
-  VOID
-  )
-{
-  UINT32 CCSIDR = ReadCCSIDR (0) & 7;
-
-  // * 4 converts to bytes
-  return (1 << (CCSIDR + 2)) * 4;
-}
-  
-BOOLEAN
-EFIAPI
-ArmInstructionCachePresent (
-  VOID
-  )
-{
-  UINT32 CLIDR = ReadCLIDR ();
-  
-  if ((CLIDR & 1) == 1) {
-    // Instruction cache exists
-    return TRUE;
-  }
-  if ((CLIDR & 0x7) == 0x4) {
-    // Unified cache
-    return TRUE;
-  }
-  
-  return FALSE;
-}
-  
-UINTN
-EFIAPI
-ArmInstructionCacheSize (
-  VOID
-  )
-{
-  UINT32 NumSets;
-  UINT32 Associativity;
-  UINT32 LineSize;
-  UINT32 CCSIDR = ReadCCSIDR (1);
-  
-  LineSize      = (1 << ((CCSIDR & 0x7) + 2));
-  Associativity = ((CCSIDR >> 3) & 0x3ff) + 1;
-  NumSets       = ((CCSIDR >> 13) & 0x7fff) + 1;
-
-  // LineSize is in words (4 byte chunks)
-  return  NumSets * Associativity * LineSize * 4;      
-}
-  
-UINTN
-EFIAPI
-ArmInstructionCacheAssociativity (
-  VOID
-  )
-{
-  UINT32 CCSIDR = ReadCCSIDR (1);
-
-  return ((CCSIDR >> 3) & 0x3ff) + 1;
-//  return 4;
-}
-  
-UINTN
-EFIAPI
-ArmInstructionCacheSets (
-  VOID
-  )
-{
-  UINT32 CCSIDR = ReadCCSIDR (1);
-  
-  return ((CCSIDR >> 13) & 0x7fff) + 1;
-}
-
-UINTN
-EFIAPI
-ArmInstructionCacheLineLength (
-  VOID
-  )
-{
-  UINT32 CCSIDR = ReadCCSIDR (1) & 7;
-
-  // * 4 converts to bytes
-  return (1 << (CCSIDR + 2)) * 4;
-
-//  return 64;
-}
-
-
-VOID
-ArmV7DataCacheOperation (
-  IN  ARM_V7_CACHE_OPERATION  DataCacheOperation
-  )
-{
-  UINTN     SavedInterruptState;
-
-  SavedInterruptState = ArmGetInterruptState ();
-  ArmDisableInterrupts ();
-  
-  ArmV7AllDataCachesOperation (DataCacheOperation);
-  
-  ArmDrainWriteBuffer ();
-  
-  if (SavedInterruptState) {
-    ArmEnableInterrupts ();
-  }
-}
-
-
-VOID
-ArmV7PoUDataCacheOperation (
-  IN  ARM_V7_CACHE_OPERATION  DataCacheOperation
-  )
-{
-  UINTN     SavedInterruptState;
-
-  SavedInterruptState = ArmGetInterruptState ();
-  ArmDisableInterrupts ();
-  
-  ArmV7PerformPoUDataCacheOperation (DataCacheOperation);
-  
-  ArmDrainWriteBuffer ();
-  
-  if (SavedInterruptState) {
-    ArmEnableInterrupts ();
-  }
-}
-
-VOID
-EFIAPI
-ArmInvalidateDataCache (
-  VOID
-  )
-{
-  ArmV7DataCacheOperation (ArmInvalidateDataCacheEntryBySetWay);
-}
-
-VOID
-EFIAPI
-ArmCleanInvalidateDataCache (
-  VOID
-  )
-{
-  ArmV7DataCacheOperation (ArmCleanInvalidateDataCacheEntryBySetWay);
-}
-
-VOID
-EFIAPI
-ArmCleanDataCache (
-  VOID
-  )
-{
-  ArmV7DataCacheOperation (ArmCleanDataCacheEntryBySetWay);
-}
-
-VOID
-EFIAPI
-ArmCleanDataCacheToPoU (
-  VOID
-  )
-{
-  ArmV7PoUDataCacheOperation (ArmCleanDataCacheEntryBySetWay);
-}
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+#include <Uefi.h>

+#include <Chipset/ArmV7.h>

+#include <Library/ArmLib.h>

+#include <Library/BaseLib.h>

+#include <Library/IoLib.h>

+#include "ArmV7Lib.h"

+#include "ArmLibPrivate.h"

+

+ARM_CACHE_TYPE

+EFIAPI

+ArmCacheType (

+  VOID

+  )

+{

+  return ARM_CACHE_TYPE_WRITE_BACK;

+}

+

+ARM_CACHE_ARCHITECTURE

+EFIAPI

+ArmCacheArchitecture (

+  VOID

+  )

+{

+  UINT32 CLIDR = ReadCLIDR ();

+

+  return (ARM_CACHE_ARCHITECTURE)CLIDR; // BugBug Fix Me

+}

+

+BOOLEAN

+EFIAPI

+ArmDataCachePresent (

+  VOID

+  )

+{

+  UINT32 CLIDR = ReadCLIDR ();

+  

+  if ((CLIDR & 0x2) == 0x2) {

+    // Instruction cache exists

+    return TRUE;

+  }

+  if ((CLIDR & 0x7) == 0x4) {

+    // Unified cache

+    return TRUE;

+  }

+  

+  return FALSE;

+}

+  

+UINTN

+EFIAPI

+ArmDataCacheSize (

+  VOID

+  )

+{

+  UINT32 NumSets;

+  UINT32 Associativity;

+  UINT32 LineSize;

+  UINT32 CCSIDR = ReadCCSIDR (0);

+  

+  LineSize      = (1 << ((CCSIDR & 0x7) + 2));

+  Associativity = ((CCSIDR >> 3) & 0x3ff) + 1;

+  NumSets       = ((CCSIDR >> 13) & 0x7fff) + 1;

+

+  // LineSize is in words (4 byte chunks)

+  return  NumSets * Associativity * LineSize * 4;      

+}

+  

+UINTN

+EFIAPI

+ArmDataCacheAssociativity (

+  VOID

+  )

+{

+  UINT32 CCSIDR = ReadCCSIDR (0);

+

+  return ((CCSIDR >> 3) & 0x3ff) + 1;

+}

+  

+UINTN

+ArmDataCacheSets (

+  VOID

+  )

+{

+  UINT32 CCSIDR = ReadCCSIDR (0);

+  

+  return ((CCSIDR >> 13) & 0x7fff) + 1;

+}

+

+UINTN

+EFIAPI

+ArmDataCacheLineLength (

+  VOID

+  )

+{

+  UINT32 CCSIDR = ReadCCSIDR (0) & 7;

+

+  // * 4 converts to bytes

+  return (1 << (CCSIDR + 2)) * 4;

+}

+  

+BOOLEAN

+EFIAPI

+ArmInstructionCachePresent (

+  VOID

+  )

+{

+  UINT32 CLIDR = ReadCLIDR ();

+  

+  if ((CLIDR & 1) == 1) {

+    // Instruction cache exists

+    return TRUE;

+  }

+  if ((CLIDR & 0x7) == 0x4) {

+    // Unified cache

+    return TRUE;

+  }

+  

+  return FALSE;

+}

+  

+UINTN

+EFIAPI

+ArmInstructionCacheSize (

+  VOID

+  )

+{

+  UINT32 NumSets;

+  UINT32 Associativity;

+  UINT32 LineSize;

+  UINT32 CCSIDR = ReadCCSIDR (1);

+  

+  LineSize      = (1 << ((CCSIDR & 0x7) + 2));

+  Associativity = ((CCSIDR >> 3) & 0x3ff) + 1;

+  NumSets       = ((CCSIDR >> 13) & 0x7fff) + 1;

+

+  // LineSize is in words (4 byte chunks)

+  return  NumSets * Associativity * LineSize * 4;      

+}

+  

+UINTN

+EFIAPI

+ArmInstructionCacheAssociativity (

+  VOID

+  )

+{

+  UINT32 CCSIDR = ReadCCSIDR (1);

+

+  return ((CCSIDR >> 3) & 0x3ff) + 1;

+//  return 4;

+}

+  

+UINTN

+EFIAPI

+ArmInstructionCacheSets (

+  VOID

+  )

+{

+  UINT32 CCSIDR = ReadCCSIDR (1);

+  

+  return ((CCSIDR >> 13) & 0x7fff) + 1;

+}

+

+UINTN

+EFIAPI

+ArmInstructionCacheLineLength (

+  VOID

+  )

+{

+  UINT32 CCSIDR = ReadCCSIDR (1) & 7;

+

+  // * 4 converts to bytes

+  return (1 << (CCSIDR + 2)) * 4;

+

+//  return 64;

+}

+

+

+VOID

+ArmV7DataCacheOperation (

+  IN  ARM_V7_CACHE_OPERATION  DataCacheOperation

+  )

+{

+  UINTN     SavedInterruptState;

+

+  SavedInterruptState = ArmGetInterruptState ();

+  ArmDisableInterrupts ();

+  

+  ArmV7AllDataCachesOperation (DataCacheOperation);

+  

+  ArmDrainWriteBuffer ();

+  

+  if (SavedInterruptState) {

+    ArmEnableInterrupts ();

+  }

+}

+

+

+VOID

+ArmV7PoUDataCacheOperation (

+  IN  ARM_V7_CACHE_OPERATION  DataCacheOperation

+  )

+{

+  UINTN     SavedInterruptState;

+

+  SavedInterruptState = ArmGetInterruptState ();

+  ArmDisableInterrupts ();

+  

+  ArmV7PerformPoUDataCacheOperation (DataCacheOperation);

+  

+  ArmDrainWriteBuffer ();

+  

+  if (SavedInterruptState) {

+    ArmEnableInterrupts ();

+  }

+}

+

+VOID

+EFIAPI

+ArmInvalidateDataCache (

+  VOID

+  )

+{

+  ArmV7DataCacheOperation (ArmInvalidateDataCacheEntryBySetWay);

+}

+

+VOID

+EFIAPI

+ArmCleanInvalidateDataCache (

+  VOID

+  )

+{

+  ArmV7DataCacheOperation (ArmCleanInvalidateDataCacheEntryBySetWay);

+}

+

+VOID

+EFIAPI

+ArmCleanDataCache (

+  VOID

+  )

+{

+  ArmV7DataCacheOperation (ArmCleanDataCacheEntryBySetWay);

+}

+

+VOID

+EFIAPI

+ArmCleanDataCacheToPoU (

+  VOID

+  )

+{

+  ArmV7PoUDataCacheOperation (ArmCleanDataCacheEntryBySetWay);

+}

diff --git a/ArmPkg/Library/ArmLib/ArmV7/ArmV7Lib.h b/ArmPkg/Library/ArmLib/ArmV7/ArmV7Lib.h
index 66995c7b..88848da5 100644
--- a/ArmPkg/Library/ArmLib/ArmV7/ArmV7Lib.h
+++ b/ArmPkg/Library/ArmLib/ArmV7/ArmV7Lib.h
@@ -60,30 +60,6 @@ ArmDisableAsynchronousAbort (
   );

 

 VOID

-EFIAPI

-ArmEnableIrq (

-  VOID

-  );

-

-UINTN

-EFIAPI

-ArmDisableIrq (

-  VOID

-  );

-

-VOID

-EFIAPI

-ArmEnableFiq (

-  VOID

-  );

-

-UINTN

-EFIAPI

-ArmDisableFiq (

-  VOID

-  );

-

-VOID

 ArmV7PerformPoUDataCacheOperation (

   IN  ARM_V7_CACHE_OPERATION  DataCacheOperation

   );

diff --git a/ArmPkg/Library/ArmLib/ArmV7/ArmV7Lib.inf b/ArmPkg/Library/ArmLib/ArmV7/ArmV7Lib.inf
index 2bc01a99..ec2a0bae 100644
--- a/ArmPkg/Library/ArmLib/ArmV7/ArmV7Lib.inf
+++ b/ArmPkg/Library/ArmLib/ArmV7/ArmV7Lib.inf
@@ -25,8 +25,8 @@
   ArmLibSupportV7.S    | GCC

   ArmLibSupportV7.asm  | RVCT

 

-  ../Common/ArmLibSupport.S    | GCC

-  ../Common/ArmLibSupport.asm  | RVCT

+  ../Common/Arm/ArmLibSupport.S    | GCC

+  ../Common/Arm/ArmLibSupport.asm  | RVCT

   ../Common/ArmLib.c

   

   ArmV7Support.S    | GCC

diff --git a/ArmPkg/Library/ArmLib/ArmV7/ArmV7LibPrePi.inf b/ArmPkg/Library/ArmLib/ArmV7/ArmV7LibPrePi.inf
index 5fdb0449..be5b8e49 100644
--- a/ArmPkg/Library/ArmLib/ArmV7/ArmV7LibPrePi.inf
+++ b/ArmPkg/Library/ArmLib/ArmV7/ArmV7LibPrePi.inf
@@ -25,8 +25,8 @@
   ArmLibSupportV7.S    | GCC

   ArmLibSupportV7.asm  | RVCT

 

-  ../Common/ArmLibSupport.S    | GCC

-  ../Common/ArmLibSupport.asm  | RVCT

+  ../Common/Arm/ArmLibSupport.S    | GCC

+  ../Common/Arm/ArmLibSupport.asm  | RVCT

   ../Common/ArmLib.c

   

   ArmV7Support.S    | GCC

diff --git a/ArmPkg/Library/ArmLib/ArmV7/ArmV7LibSec.inf b/ArmPkg/Library/ArmLib/ArmV7/ArmV7LibSec.inf
index 9e6f17ec..c1f97bb1 100644
--- a/ArmPkg/Library/ArmLib/ArmV7/ArmV7LibSec.inf
+++ b/ArmPkg/Library/ArmLib/ArmV7/ArmV7LibSec.inf
@@ -23,8 +23,8 @@
   ArmLibSupportV7.S    | GCC

   ArmLibSupportV7.asm  | RVCT

 

-  ../Common/ArmLibSupport.S    | GCC

-  ../Common/ArmLibSupport.asm  | RVCT

+  ../Common/Arm/ArmLibSupport.S    | GCC

+  ../Common/Arm/ArmLibSupport.asm  | RVCT

   ../Common/ArmLib.c

   

   ArmV7Support.S    | GCC

diff --git a/ArmPkg/Library/ArmLib/Common/ArmLibSupport.S b/ArmPkg/Library/ArmLib/Common/Arm/ArmLibSupport.S
index b1918541..71aee430 100644
--- a/ArmPkg/Library/ArmLib/Common/ArmLibSupport.S
+++ b/ArmPkg/Library/ArmLib/Common/Arm/ArmLibSupport.S
@@ -1,7 +1,7 @@
 #------------------------------------------------------------------------------ 

 #

 # Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

-# Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+# Copyright (c) 2011-2013, ARM Limited. All rights reserved.

 #

 # This program and the accompanying materials

 # are licensed and made available under the terms and conditions of the BSD License

@@ -44,6 +44,8 @@ GCC_ASM_EXPORT(ArmReadScr)
 GCC_ASM_EXPORT(ArmWriteScr)

 GCC_ASM_EXPORT(ArmReadMVBar)

 GCC_ASM_EXPORT(ArmWriteMVBar)

+GCC_ASM_EXPORT(ArmReadHVBar)

+GCC_ASM_EXPORT(ArmWriteHVBar)

 GCC_ASM_EXPORT(ArmCallWFE)

 GCC_ASM_EXPORT(ArmCallSEV)

 GCC_ASM_EXPORT(ArmReadSctlr)

@@ -161,6 +163,15 @@ ASM_PFX(ArmWriteScr):
   mcr     p15, 0, r0, c1, c1, 0

   bx      lr

 

+ASM_PFX(ArmReadHVBar):

+  mrc     p15, 4, r0, c12, c0, 0

+  bx      lr

+

+ASM_PFX(ArmWriteHVBar):

+  mcr     p15, 4, r0, c12, c0, 0

+  bx      lr

+

+

 ASM_PFX(ArmReadMVBar):

   mrc     p15, 0, r0, c12, c0, 1

   bx      lr

diff --git a/ArmPkg/Library/ArmLib/Common/ArmLibSupport.asm b/ArmPkg/Library/ArmLib/Common/Arm/ArmLibSupport.asm
index fd0f332b..1636010e 100644
--- a/ArmPkg/Library/ArmLib/Common/ArmLibSupport.asm
+++ b/ArmPkg/Library/ArmLib/Common/Arm/ArmLibSupport.asm
@@ -1,7 +1,7 @@
 //------------------------------------------------------------------------------ 

 //

 // Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

-// Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+// Copyright (c) 2011-2013, ARM Limited. All rights reserved.

 //

 // This program and the accompanying materials

 // are licensed and made available under the terms and conditions of the BSD License

@@ -44,6 +44,8 @@
     EXPORT ArmWriteScr

     EXPORT ArmReadMVBar

     EXPORT ArmWriteMVBar

+    EXPORT ArmReadHVBar

+    EXPORT ArmWriteHVBar

     EXPORT ArmCallWFE

     EXPORT ArmCallSEV

     EXPORT ArmReadSctlr

@@ -161,6 +163,14 @@ ArmWriteScr
   mcr     p15, 0, r0, c1, c1, 0

   bx      lr

 

+ArmReadHVBar

+  mrc     p15, 4, r0, c12, c0, 0

+  bx      lr

+

+ArmWriteHVBar

+  mcr     p15, 4, r0, c12, c0, 0

+  bx      lr

+

 ArmReadMVBar

   mrc     p15, 0, r0, c12, c0, 1

   bx      lr

diff --git a/ArmPkg/Library/ArmLib/Null/NullArmLib.inf b/ArmPkg/Library/ArmLib/Null/NullArmLib.inf
index 33296204..d4371981 100644
--- a/ArmPkg/Library/ArmLib/Null/NullArmLib.inf
+++ b/ArmPkg/Library/ArmLib/Null/NullArmLib.inf
@@ -22,13 +22,15 @@
   LIBRARY_CLASS                  = ArmLib

 

 [Sources.common]

-  ../Common/ArmLibSupport.S    | GCC

-  ../Common/ArmLibSupport.asm  | RVCT

   ../Common/ArmLib.c

 

   NullArmLib.c

   NullArmCacheInformation.c

 

+[Sources.ARM]

+  ../Common/Arm/ArmLibSupport.S    | GCC

+  ../Common/Arm/ArmLibSupport.asm  | RVCT

+

 [Packages]

   ArmPkg/ArmPkg.dec

   MdePkg/MdePkg.dec

diff --git a/ArmPlatformPkg/Library/ArmSmcLib/ArmSmc.S b/ArmPkg/Library/ArmSmcLib/Arm/ArmSmc.S
index 13f51a91..c9c0740f 100644
--- a/ArmPlatformPkg/Library/ArmSmcLib/ArmSmc.S
+++ b/ArmPkg/Library/ArmSmcLib/Arm/ArmSmc.S
@@ -27,9 +27,8 @@ ASM_PFX(ArmCallSmc):
     smc     #0

     str     r0,[r1]

     pop     {r1}

-    blx     lr

+    bx      lr

 

-// Arg1 in R1

 ASM_PFX(ArmCallSmcArg1):

     push    {r2-r3}

     mov     r2, r0

@@ -40,7 +39,7 @@ ASM_PFX(ArmCallSmcArg1):
     str     r0,[r2]

     str     r1,[r3]

     pop     {r2-r3}

-    blx     lr

+    bx      lr

 

 ASM_PFX(ArmCallSmcArg2):

     push    {r3-r5}

@@ -55,7 +54,7 @@ ASM_PFX(ArmCallSmcArg2):
     str     r1,[r4]

     str     r2,[r5]

     pop     {r3-r5}

-    blx     lr

+    bx      lr

 

 ASM_PFX(ArmCallSmcArg3):

     push    {r4-r7}

@@ -73,4 +72,4 @@ ASM_PFX(ArmCallSmcArg3):
     str     r2,[r6]

     str     r3,[r7]

     pop     {r4-r7}

-    blx     lr

+    bx      lr

diff --git a/ArmPlatformPkg/Library/ArmSmcLib/ArmSmc.asm b/ArmPkg/Library/ArmSmcLib/Arm/ArmSmc.asm
index 0efb1770..f46bd7ec 100644
--- a/ArmPlatformPkg/Library/ArmSmcLib/ArmSmc.asm
+++ b/ArmPkg/Library/ArmSmcLib/Arm/ArmSmc.asm
@@ -25,9 +25,8 @@ ArmCallSmc
     smc     #0

     str     r0,[r1]

     pop     {r1}

-    blx     lr

+    bx      lr

 

-// Arg1 in R1

 ArmCallSmcArg1

     push    {r2-r3}

     mov     r2, r0

@@ -38,7 +37,7 @@ ArmCallSmcArg1
     str     r0,[r2]

     str     r1,[r3]

     pop     {r2-r3}

-    blx     lr

+    bx      lr

 

 ArmCallSmcArg2

     push    {r3-r5}

@@ -53,7 +52,7 @@ ArmCallSmcArg2
     str     r1,[r4]

     str     r2,[r5]

     pop     {r3-r5}

-    blx     lr

+    bx      lr

 

 ArmCallSmcArg3

     push    {r4-r7}

@@ -71,6 +70,6 @@ ArmCallSmcArg3
     str     r2,[r6]

     str     r3,[r7]

     pop     {r4-r7}

-    blx     lr

+    bx      lr

 

     END

diff --git a/ArmPlatformPkg/Library/ArmSmcLib/ArmSmcLib.inf b/ArmPkg/Library/ArmSmcLib/ArmSmcLib.inf
index 5df25484..a3e12d26 100644
--- a/ArmPlatformPkg/Library/ArmSmcLib/ArmSmcLib.inf
+++ b/ArmPkg/Library/ArmSmcLib/ArmSmcLib.inf
@@ -1,6 +1,6 @@
 #/** @file

 #  

-#  Copyright (c) 2012, ARM Ltd. All rights reserved.<BR>

+#  Copyright (c) 2012-2013, ARM Ltd. All rights reserved.<BR>

 #  This program and the accompanying materials

 #  are licensed and made available under the terms and conditions of the BSD License

 #  which accompanies this distribution.  The full text of the license may be found at

@@ -19,10 +19,10 @@
   VERSION_STRING                 = 1.0

   LIBRARY_CLASS                  = ArmSmcLib

   

-[Sources.common]

-  ArmSmc.asm    | RVCT

-  ArmSmc.S      | GCC

+[Sources.ARM]

+  Arm/ArmSmc.asm    | RVCT

+  Arm/ArmSmc.S      | GCC

 

 [Packages]

   MdePkg/MdePkg.dec

-  ArmPlatformPkg/ArmPlatformPkg.dec

+  ArmPkg/ArmPkg.dec

diff --git a/ArmPkg/Library/ArmSmcLibNull/Arm/ArmSmcNull.S b/ArmPkg/Library/ArmSmcLibNull/Arm/ArmSmcNull.S
new file mode 100644
index 00000000..4896dd0c
--- /dev/null
+++ b/ArmPkg/Library/ArmSmcLibNull/Arm/ArmSmcNull.S
@@ -0,0 +1,33 @@
+//

+//  Copyright (c) 2012-2013, ARM Limited. All rights reserved.

+//

+//  This program and the accompanying materials

+//  are licensed and made available under the terms and conditions of the BSD License

+//  which accompanies this distribution.  The full text of the license may be found at

+//  http://opensource.org/licenses/bsd-license.php

+//

+//  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+//  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+//

+//

+

+.text

+.align 3

+

+GCC_ASM_EXPORT(ArmCallSmc)

+GCC_ASM_EXPORT(ArmCallSmcArg1)

+GCC_ASM_EXPORT(ArmCallSmcArg2)

+GCC_ASM_EXPORT(ArmCallSmcArg3)

+

+ASM_PFX(ArmCallSmc):

+  bx     lr

+

+// Arg1 in R1

+ASM_PFX(ArmCallSmcArg1):

+  bx     lr

+

+ASM_PFX(ArmCallSmcArg2):

+  bx     lr

+

+ASM_PFX(ArmCallSmcArg3):

+  bx     lr

diff --git a/ArmPkg/Library/ArmSmcLibNull/Arm/ArmSmcNull.asm b/ArmPkg/Library/ArmSmcLibNull/Arm/ArmSmcNull.asm
new file mode 100644
index 00000000..24c20752
--- /dev/null
+++ b/ArmPkg/Library/ArmSmcLibNull/Arm/ArmSmcNull.asm
@@ -0,0 +1,34 @@
+//

+//  Copyright (c) 2012-2013, ARM Limited. All rights reserved.

+//

+//  This program and the accompanying materials

+//  are licensed and made available under the terms and conditions of the BSD License

+//  which accompanies this distribution.  The full text of the license may be found at

+//  http://opensource.org/licenses/bsd-license.php

+//

+//  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+//  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+//

+//

+

+    EXPORT ArmCallSmc

+    EXPORT ArmCallSmcArg1

+    EXPORT ArmCallSmcArg2

+    EXPORT ArmCallSmcArg3

+

+    AREA   ArmSmc, CODE, READONLY

+

+ArmCallSmc

+  bx     lr

+

+// Arg1 in R1

+ArmCallSmcArg1

+  bx     lr

+

+ArmCallSmcArg2

+  bx     lr

+

+ArmCallSmcArg3

+  bx     lr

+

+  END

diff --git a/ArmPkg/Library/ArmSmcLibNull/ArmSmcLibNull.inf b/ArmPkg/Library/ArmSmcLibNull/ArmSmcLibNull.inf
new file mode 100644
index 00000000..fed6e95d
--- /dev/null
+++ b/ArmPkg/Library/ArmSmcLibNull/ArmSmcLibNull.inf
@@ -0,0 +1,31 @@
+#/** @file

+#  

+#  ArmSmcLib when no SMC support is desired (might be the case for CPU without the

+#  Trustzone support / ARM Security Extension)

+#

+#  Copyright (c) 2012-2013, ARM Ltd. All rights reserved.<BR>

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = ArmSmcLibNull

+  FILE_GUID                      = 140e8004-16e1-4de1-a352-c6ef51110ecf

+  MODULE_TYPE                    = BASE

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = ArmSmcLib

+  

+[Sources.ARM]

+  Arm/ArmSmcNull.asm    | RVCT

+  Arm/ArmSmcNull.S      | GCC

+

+[Packages]

+  MdePkg/MdePkg.dec

+  ArmPkg/ArmPkg.dec

diff --git a/ArmPkg/Library/BaseMemoryLibStm/Arm/CopyMem.asm b/ArmPkg/Library/BaseMemoryLibStm/Arm/CopyMem.asm
index ca8d06a5..d0faa00d 100755
--- a/ArmPkg/Library/BaseMemoryLibStm/Arm/CopyMem.asm
+++ b/ArmPkg/Library/BaseMemoryLibStm/Arm/CopyMem.asm
@@ -38,16 +38,16 @@ InternalMemCopyMem (
   )

 **/

   EXPORT InternalMemCopyMem

-
-  AREA AsmMemStuff, CODE, READONLY
+

+  AREA AsmMemStuff, CODE, READONLY

 

 InternalMemCopyMem

-  stmfd  sp!, {r4-r11, lr}
-  // Save the input parameters in extra registers (r11 = destination, r14 = source, r12 = length)
-  mov  r11, r0
-  mov  r10, r0
-  mov  r12, r2
-  mov  r14, r1
+  stmfd  sp!, {r4-r11, lr}

+  // Save the input parameters in extra registers (r11 = destination, r14 = source, r12 = length)

+  mov  r11, r0

+  mov  r10, r0

+  mov  r12, r2

+  mov  r14, r1

   

 memcopy_check_overlapped

   cmp  r11, r1

@@ -70,42 +70,42 @@ memcopy_check_overlapped
 memcopy_check_optim_default

   // Check if we can use an optimized path ((length >= 32) && destination word-aligned && source word-aligned) for the memcopy (optimized path if r0 == 1)

   tst  r0, #0xF

-  movne  r0, #0
-  bne   memcopy_default
-  tst  r1, #0xF
-  movne  r3, #0
-  moveq  r3, #1
-  cmp  r2, #31
-  movls  r0, #0
-  andhi  r0, r3, #1
-  b     memcopy_default
-    
-memcopy_check_optim_overlap
-  // r10 = dest_end, r14 = source_end
-  add  r10, r11, r12
-  add  r14, r12, r1
-
-  // Are we in the optimized case ((length >= 32) && dest_end word-aligned && source_end word-aligned)
-  cmp  r2, #31
-  movls  r0, #0
-  movhi  r0, #1
-  tst  r10, #0xF
-  movne  r0, #0
-  tst  r14, #0xF
-  movne  r0, #0
+  movne  r0, #0

+  bne   memcopy_default

+  tst  r1, #0xF

+  movne  r3, #0

+  moveq  r3, #1

+  cmp  r2, #31

+  movls  r0, #0

+  andhi  r0, r3, #1

+  b     memcopy_default

+    

+memcopy_check_optim_overlap

+  // r10 = dest_end, r14 = source_end

+  add  r10, r11, r12

+  add  r14, r12, r1

+

+  // Are we in the optimized case ((length >= 32) && dest_end word-aligned && source_end word-aligned)

+  cmp  r2, #31

+  movls  r0, #0

+  movhi  r0, #1

+  tst  r10, #0xF

+  movne  r0, #0

+  tst  r14, #0xF

+  movne  r0, #0

   b  memcopy_overlapped

-  
+  

 memcopy_overlapped_non_optim

   // We read 1 byte from the end of the source buffer

-  sub  r3, r14, #1
-  sub  r12, r12, #1
-  ldrb  r3, [r3, #0]  
-  sub  r2, r10, #1
-  cmp  r12, #0
+  sub  r3, r14, #1

+  sub  r12, r12, #1

+  ldrb  r3, [r3, #0]  

+  sub  r2, r10, #1

+  cmp  r12, #0

   // We write 1 byte at the end of the dest buffer

-  sub  r10, r10, #1
-  sub  r14, r14, #1
-  strb  r3, [r2, #0]
+  sub  r10, r10, #1

+  sub  r14, r14, #1

+  strb  r3, [r2, #0]

   bne  memcopy_overlapped_non_optim

   b   memcopy_end

 

@@ -114,16 +114,16 @@ memcopy_overlapped
   // Are we in the optimized case ?

   cmp  r0, #0

   beq  memcopy_overlapped_non_optim

-  
+  

   // Optimized Overlapped - Read 32 bytes

   sub  r14, r14, #32

   sub  r12, r12, #32

   cmp  r12, #31

   ldmia  r14, {r2-r9}

-  
+  

   // If length is less than 32 then disable optim

   movls  r0, #0

-  
+  

   cmp  r12, #0

   

   // Optimized Overlapped - Write 32 bytes  

@@ -136,37 +136,37 @@ memcopy_overlapped
   

 memcopy_default_non_optim

   // Byte copy

-  ldrb  r3, [r14], #1  
-  sub  r12, r12, #1
-  strb  r3, [r10], #1
-  
+  ldrb  r3, [r14], #1  

+  sub  r12, r12, #1

+  strb  r3, [r10], #1

+  

 memcopy_default

-  cmp  r12, #0
-  beq  memcopy_end
-  
+  cmp  r12, #0

+  beq  memcopy_end

+  

 // r10 = dest, r14 = source

 memcopy_default_loop

-  cmp  r0, #0
+  cmp  r0, #0

   beq  memcopy_default_non_optim

-  
+  

   // Optimized memcopy - Read 32 Bytes

-  sub  r12, r12, #32
-  cmp  r12, #31
-  ldmia  r14!, {r2-r9}
+  sub  r12, r12, #32

+  cmp  r12, #31

+  ldmia  r14!, {r2-r9}

   

   // If length is less than 32 then disable optim

-  movls  r0, #0
+  movls  r0, #0

   

-  cmp  r12, #0
+  cmp  r12, #0

   

   // Optimized memcopy - Write 32 Bytes

-  stmia  r10!, {r2-r9}
-
+  stmia  r10!, {r2-r9}

+

   // while (length != 0)

   bne  memcopy_default_loop

-  
+  

 memcopy_end

-  mov  r0, r11
+  mov  r0, r11

   ldmfd  sp!, {r4-r11, pc}

   

   END

diff --git a/ArmPkg/Library/BaseMemoryLibVstm/Arm/CopyMem.asm b/ArmPkg/Library/BaseMemoryLibVstm/Arm/CopyMem.asm
index e7cbdf1e..5df7c6b7 100755
--- a/ArmPkg/Library/BaseMemoryLibVstm/Arm/CopyMem.asm
+++ b/ArmPkg/Library/BaseMemoryLibVstm/Arm/CopyMem.asm
@@ -38,78 +38,78 @@ InternalMemCopyMem (
   )

 **/

   EXPORT InternalMemCopyMem

-
-  AREA AsmMemStuff, CODE, READONLY
+

+  AREA AsmMemStuff, CODE, READONLY

 

 InternalMemCopyMem

-  stmfd  sp!, {r4, r9, lr}
-  tst  r0, #3
-  mov  r4, r0
-  mov  r9, r0
-  mov  ip, r2
-  mov  lr, r1
-  movne  r0, #0
-  bne  L4
-  tst  r1, #3
-  movne  r3, #0
-  moveq  r3, #1
-  cmp  r2, #127
-  movls  r0, #0
-  andhi  r0, r3, #1
-L4
-  cmp  r4, r1
-  bcc  L26
-  bls  L7
-  rsb  r3, r1, r4
-  cmp  ip, r3
-  bcc  L26
-  cmp  ip, #0
-  beq  L7
-  add  r9, r4, ip
-  add  lr, ip, r1
-  b  L16
-L29
-  sub  ip, ip, #8
-  cmp  ip, #7
-  ldrd  r2, [lr, #-8]!
-  movls  r0, #0
-  cmp  ip, #0
-  strd  r2, [r9, #-8]!
-  beq  L7
-L16
-  cmp  r0, #0
-  bne  L29
-  sub  r3, lr, #1
-  sub  ip, ip, #1
-  ldrb  r3, [r3, #0]  
-  sub  r2, r9, #1
-  cmp  ip, #0
-  sub  r9, r9, #1
-  sub  lr, lr, #1
-  strb  r3, [r2, #0]
-  bne  L16
-  b   L7
-L11
-  ldrb  r3, [lr], #1  
-  sub  ip, ip, #1
-  strb  r3, [r9], #1
-L26
-  cmp  ip, #0
-  beq  L7
-L30
-  cmp  r0, #0
-  beq  L11
-  sub  ip, ip, #128          // 32
-  cmp  ip, #127              // 31
-  vldm     lr!, {d0-d15}
-  movls  r0, #0
-  cmp  ip, #0
-  vstm  r9!, {d0-d15}
-  bne  L30
-L7
-  dsb
-  mov  r0, r4
-  ldmfd  sp!, {r4, r9, pc}
+  stmfd  sp!, {r4, r9, lr}

+  tst  r0, #3

+  mov  r4, r0

+  mov  r9, r0

+  mov  ip, r2

+  mov  lr, r1

+  movne  r0, #0

+  bne  L4

+  tst  r1, #3

+  movne  r3, #0

+  moveq  r3, #1

+  cmp  r2, #127

+  movls  r0, #0

+  andhi  r0, r3, #1

+L4

+  cmp  r4, r1

+  bcc  L26

+  bls  L7

+  rsb  r3, r1, r4

+  cmp  ip, r3

+  bcc  L26

+  cmp  ip, #0

+  beq  L7

+  add  r9, r4, ip

+  add  lr, ip, r1

+  b  L16

+L29

+  sub  ip, ip, #8

+  cmp  ip, #7

+  ldrd  r2, [lr, #-8]!

+  movls  r0, #0

+  cmp  ip, #0

+  strd  r2, [r9, #-8]!

+  beq  L7

+L16

+  cmp  r0, #0

+  bne  L29

+  sub  r3, lr, #1

+  sub  ip, ip, #1

+  ldrb  r3, [r3, #0]  

+  sub  r2, r9, #1

+  cmp  ip, #0

+  sub  r9, r9, #1

+  sub  lr, lr, #1

+  strb  r3, [r2, #0]

+  bne  L16

+  b   L7

+L11

+  ldrb  r3, [lr], #1  

+  sub  ip, ip, #1

+  strb  r3, [r9], #1

+L26

+  cmp  ip, #0

+  beq  L7

+L30

+  cmp  r0, #0

+  beq  L11

+  sub  ip, ip, #128          // 32

+  cmp  ip, #127              // 31

+  vldm     lr!, {d0-d15}

+  movls  r0, #0

+  cmp  ip, #0

+  vstm  r9!, {d0-d15}

+  bne  L30

+L7

+  dsb

+  mov  r0, r4

+  ldmfd  sp!, {r4, r9, pc}

 

   END

   

diff --git a/ArmPkg/Library/BaseMemoryLibVstm/Arm/SetMem.S b/ArmPkg/Library/BaseMemoryLibVstm/Arm/SetMem.S
index d5c50cbe..0415ed70 100755
--- a/ArmPkg/Library/BaseMemoryLibVstm/Arm/SetMem.S
+++ b/ArmPkg/Library/BaseMemoryLibVstm/Arm/SetMem.S
@@ -77,4 +77,4 @@ L43:
   cmp      r1, #0

   bne      L34

   ldmfd    sp!, {pc}

-  
\ No newline at end of file
+  
\ No newline at end of file
diff --git a/ArmPkg/Library/BaseMemoryLibVstm/Arm/SetMem.asm b/ArmPkg/Library/BaseMemoryLibVstm/Arm/SetMem.asm
index bbab580c..de438d6c 100755
--- a/ArmPkg/Library/BaseMemoryLibVstm/Arm/SetMem.asm
+++ b/ArmPkg/Library/BaseMemoryLibVstm/Arm/SetMem.asm
@@ -36,7 +36,7 @@ InternalMemSetMem (
   

   EXPORT InternalMemSetMem

   

-  AREA AsmMemStuff, CODE, READONLY
+  AREA AsmMemStuff, CODE, READONLY

 

 InternalMemSetMem

   stmfd  sp!, {lr}

@@ -77,4 +77,4 @@ L43
   ldmfd    sp!, {pc}

   

   END

-  
\ No newline at end of file
+  
\ No newline at end of file
diff --git a/ArmPkg/Library/BdsLib/BdsLinuxAtag.c b/ArmPkg/Library/BdsLib/Arm/BdsLinuxAtag.c
index b59df076..8946b142 100644
--- a/ArmPkg/Library/BdsLib/BdsLinuxAtag.c
+++ b/ArmPkg/Library/BdsLib/Arm/BdsLinuxAtag.c
@@ -1,173 +1,173 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-#include "BdsInternal.h"
-#include "BdsLinuxLoader.h"
-
-// Point to the current ATAG
-STATIC LINUX_ATAG *mLinuxKernelCurrentAtag;
-
-STATIC
-VOID
-SetupCoreTag (
-  IN UINT32 PageSize
-  )
-{
-  mLinuxKernelCurrentAtag->header.size = tag_size(LINUX_ATAG_CORE);
-  mLinuxKernelCurrentAtag->header.type = ATAG_CORE;
-
-  mLinuxKernelCurrentAtag->body.core_tag.flags    = 1;            /* ensure read-only */
-  mLinuxKernelCurrentAtag->body.core_tag.pagesize = PageSize;     /* systems PageSize (4k) */
-  mLinuxKernelCurrentAtag->body.core_tag.rootdev  = 0;            /* zero root device (typically overridden from kernel command line )*/
-
-  // move pointer to next tag
-  mLinuxKernelCurrentAtag = next_tag_address(mLinuxKernelCurrentAtag);
-}
-
-STATIC
-VOID
-SetupMemTag (
-  IN UINTN StartAddress,
-  IN UINT32 Size
-  )
-{
-  mLinuxKernelCurrentAtag->header.size = tag_size(LINUX_ATAG_MEM);
-  mLinuxKernelCurrentAtag->header.type = ATAG_MEM;
-
-  mLinuxKernelCurrentAtag->body.mem_tag.start = StartAddress;    /* Start of memory chunk for AtagMem */
-  mLinuxKernelCurrentAtag->body.mem_tag.size  = Size;             /* Size of memory chunk for AtagMem */
-
-  // move pointer to next tag
-  mLinuxKernelCurrentAtag = next_tag_address(mLinuxKernelCurrentAtag);
-}
-
-STATIC
-VOID
-SetupCmdlineTag (
-  IN CONST CHAR8 *CmdLine
-  )
-{
-  UINT32 LineLength;
-
-  // Increment the line length by 1 to account for the null string terminator character
-  LineLength = AsciiStrLen(CmdLine) + 1;
-
-  /* Check for NULL strings.
-   * Do not insert a tag for an empty CommandLine, don't even modify the tag address pointer.
-   * Remember, you have at least one null string terminator character.
-   */
-  if(LineLength > 1) {
-    mLinuxKernelCurrentAtag->header.size = ((UINT32)sizeof(LINUX_ATAG_HEADER) + LineLength + (UINT32)3) >> 2;
-    mLinuxKernelCurrentAtag->header.type = ATAG_CMDLINE;
-
-    /* place CommandLine into tag */
-    AsciiStrCpy(mLinuxKernelCurrentAtag->body.cmdline_tag.cmdline, CmdLine);
-
-    // move pointer to next tag
-    mLinuxKernelCurrentAtag = next_tag_address(mLinuxKernelCurrentAtag);
-  }
-}
-
-STATIC
-VOID
-SetupInitrdTag (
-  IN UINT32 InitrdImage,
-  IN UINT32 InitrdImageSize
-  )
-{
-  mLinuxKernelCurrentAtag->header.size = tag_size(LINUX_ATAG_INITRD2);
-  mLinuxKernelCurrentAtag->header.type = ATAG_INITRD2;
-
-  mLinuxKernelCurrentAtag->body.initrd2_tag.start = InitrdImage;
-  mLinuxKernelCurrentAtag->body.initrd2_tag.size = InitrdImageSize;
-
-  // Move pointer to next tag
-  mLinuxKernelCurrentAtag = next_tag_address(mLinuxKernelCurrentAtag);
-}
-STATIC
-VOID
-SetupEndTag (
-  VOID
-  )
-{
-  // Empty tag ends list; this has zero length and no body
-  mLinuxKernelCurrentAtag->header.type = ATAG_NONE;
-  mLinuxKernelCurrentAtag->header.size = 0;
-
-  /* We can not calculate the next address by using the standard macro:
-   * Params = next_tag_address(Params);
-   * because it relies on the header.size, which here it is 0 (zero).
-   * The easiest way is to add the sizeof(mLinuxKernelCurrentAtag->header).
-   */
-  mLinuxKernelCurrentAtag = (LINUX_ATAG*)((UINT32)mLinuxKernelCurrentAtag + sizeof(mLinuxKernelCurrentAtag->header));
-}
-
-EFI_STATUS
-PrepareAtagList (
-  IN  CONST CHAR8*          CommandLineString,
-  IN  EFI_PHYSICAL_ADDRESS  InitrdImage,
-  IN  UINTN                 InitrdImageSize,
-  OUT EFI_PHYSICAL_ADDRESS  *AtagBase,
-  OUT UINT32                *AtagSize
-  )
-{
-  EFI_STATUS                  Status;
-  LIST_ENTRY                  *ResourceLink;
-  LIST_ENTRY                  ResourceList;
-  EFI_PHYSICAL_ADDRESS        AtagStartAddress;
-  BDS_SYSTEM_MEMORY_RESOURCE  *Resource;
-
-  AtagStartAddress = LINUX_ATAG_MAX_OFFSET;
-  Status = gBS->AllocatePages (AllocateMaxAddress, EfiBootServicesData, EFI_SIZE_TO_PAGES(ATAG_MAX_SIZE), &AtagStartAddress);
-  if (EFI_ERROR(Status)) {
-    DEBUG ((EFI_D_WARN, "Warning: Failed to allocate Atag at 0x%lX (%r). The Atag will be allocated somewhere else in System Memory.\n", AtagStartAddress, Status));
-    Status = gBS->AllocatePages (AllocateAnyPages, EfiBootServicesData, EFI_SIZE_TO_PAGES(ATAG_MAX_SIZE), &AtagStartAddress);
-    ASSERT_EFI_ERROR(Status);
-  }
-
-  // Ready to setup the atag list
-  mLinuxKernelCurrentAtag = (LINUX_ATAG*)(UINTN)AtagStartAddress;
-
-  // Standard core tag 4k PageSize
-  SetupCoreTag( (UINT32)SIZE_4KB );
-
-  // Physical memory setup
-  GetSystemMemoryResources (&ResourceList);
-  ResourceLink = ResourceList.ForwardLink;
-  while (ResourceLink != NULL && ResourceLink != &ResourceList) {
-    Resource = (BDS_SYSTEM_MEMORY_RESOURCE*)ResourceLink;
-    DEBUG((EFI_D_INFO,"- [0x%08X,0x%08X]\n",(UINT32)Resource->PhysicalStart,(UINT32)Resource->PhysicalStart+(UINT32)Resource->ResourceLength));
-    SetupMemTag( (UINT32)Resource->PhysicalStart, (UINT32)Resource->ResourceLength );
-    ResourceLink = ResourceLink->ForwardLink;
-  }
-
-  // CommandLine setting root device
-  if (CommandLineString) {
-    SetupCmdlineTag (CommandLineString);
-  }
-
-  if (InitrdImageSize > 0 && InitrdImage != 0) {
-    SetupInitrdTag ((UINT32)InitrdImage, (UINT32)InitrdImageSize);
-  }
-
-  // End of tags
-  SetupEndTag();
-
-  // Calculate atag list size
-  *AtagBase = AtagStartAddress;
-  *AtagSize = (UINT32)mLinuxKernelCurrentAtag - (UINT32)AtagStartAddress + 1;
-
-  return EFI_SUCCESS;
-}
-
+/** @file

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+#include "BdsInternal.h"

+#include "BdsLinuxLoader.h"

+

+// Point to the current ATAG

+STATIC LINUX_ATAG *mLinuxKernelCurrentAtag;

+

+STATIC

+VOID

+SetupCoreTag (

+  IN UINT32 PageSize

+  )

+{

+  mLinuxKernelCurrentAtag->header.size = tag_size(LINUX_ATAG_CORE);

+  mLinuxKernelCurrentAtag->header.type = ATAG_CORE;

+

+  mLinuxKernelCurrentAtag->body.core_tag.flags    = 1;            /* ensure read-only */

+  mLinuxKernelCurrentAtag->body.core_tag.pagesize = PageSize;     /* systems PageSize (4k) */

+  mLinuxKernelCurrentAtag->body.core_tag.rootdev  = 0;            /* zero root device (typically overridden from kernel command line )*/

+

+  // move pointer to next tag

+  mLinuxKernelCurrentAtag = next_tag_address(mLinuxKernelCurrentAtag);

+}

+

+STATIC

+VOID

+SetupMemTag (

+  IN UINTN StartAddress,

+  IN UINT32 Size

+  )

+{

+  mLinuxKernelCurrentAtag->header.size = tag_size(LINUX_ATAG_MEM);

+  mLinuxKernelCurrentAtag->header.type = ATAG_MEM;

+

+  mLinuxKernelCurrentAtag->body.mem_tag.start = StartAddress;    /* Start of memory chunk for AtagMem */

+  mLinuxKernelCurrentAtag->body.mem_tag.size  = Size;             /* Size of memory chunk for AtagMem */

+

+  // move pointer to next tag

+  mLinuxKernelCurrentAtag = next_tag_address(mLinuxKernelCurrentAtag);

+}

+

+STATIC

+VOID

+SetupCmdlineTag (

+  IN CONST CHAR8 *CmdLine

+  )

+{

+  UINT32 LineLength;

+

+  // Increment the line length by 1 to account for the null string terminator character

+  LineLength = AsciiStrLen(CmdLine) + 1;

+

+  /* Check for NULL strings.

+   * Do not insert a tag for an empty CommandLine, don't even modify the tag address pointer.

+   * Remember, you have at least one null string terminator character.

+   */

+  if(LineLength > 1) {

+    mLinuxKernelCurrentAtag->header.size = ((UINT32)sizeof(LINUX_ATAG_HEADER) + LineLength + (UINT32)3) >> 2;

+    mLinuxKernelCurrentAtag->header.type = ATAG_CMDLINE;

+

+    /* place CommandLine into tag */

+    AsciiStrCpy(mLinuxKernelCurrentAtag->body.cmdline_tag.cmdline, CmdLine);

+

+    // move pointer to next tag

+    mLinuxKernelCurrentAtag = next_tag_address(mLinuxKernelCurrentAtag);

+  }

+}

+

+STATIC

+VOID

+SetupInitrdTag (

+  IN UINT32 InitrdImage,

+  IN UINT32 InitrdImageSize

+  )

+{

+  mLinuxKernelCurrentAtag->header.size = tag_size(LINUX_ATAG_INITRD2);

+  mLinuxKernelCurrentAtag->header.type = ATAG_INITRD2;

+

+  mLinuxKernelCurrentAtag->body.initrd2_tag.start = InitrdImage;

+  mLinuxKernelCurrentAtag->body.initrd2_tag.size = InitrdImageSize;

+

+  // Move pointer to next tag

+  mLinuxKernelCurrentAtag = next_tag_address(mLinuxKernelCurrentAtag);

+}

+STATIC

+VOID

+SetupEndTag (

+  VOID

+  )

+{

+  // Empty tag ends list; this has zero length and no body

+  mLinuxKernelCurrentAtag->header.type = ATAG_NONE;

+  mLinuxKernelCurrentAtag->header.size = 0;

+

+  /* We can not calculate the next address by using the standard macro:

+   * Params = next_tag_address(Params);

+   * because it relies on the header.size, which here it is 0 (zero).

+   * The easiest way is to add the sizeof(mLinuxKernelCurrentAtag->header).

+   */

+  mLinuxKernelCurrentAtag = (LINUX_ATAG*)((UINT32)mLinuxKernelCurrentAtag + sizeof(mLinuxKernelCurrentAtag->header));

+}

+

+EFI_STATUS

+PrepareAtagList (

+  IN  CONST CHAR8*          CommandLineString,

+  IN  EFI_PHYSICAL_ADDRESS  InitrdImage,

+  IN  UINTN                 InitrdImageSize,

+  OUT EFI_PHYSICAL_ADDRESS  *AtagBase,

+  OUT UINT32                *AtagSize

+  )

+{

+  EFI_STATUS                  Status;

+  LIST_ENTRY                  *ResourceLink;

+  LIST_ENTRY                  ResourceList;

+  EFI_PHYSICAL_ADDRESS        AtagStartAddress;

+  BDS_SYSTEM_MEMORY_RESOURCE  *Resource;

+

+  AtagStartAddress = LINUX_ATAG_MAX_OFFSET;

+  Status = gBS->AllocatePages (AllocateMaxAddress, EfiBootServicesData, EFI_SIZE_TO_PAGES(ATAG_MAX_SIZE), &AtagStartAddress);

+  if (EFI_ERROR(Status)) {

+    DEBUG ((EFI_D_WARN, "Warning: Failed to allocate Atag at 0x%lX (%r). The Atag will be allocated somewhere else in System Memory.\n", AtagStartAddress, Status));

+    Status = gBS->AllocatePages (AllocateAnyPages, EfiBootServicesData, EFI_SIZE_TO_PAGES(ATAG_MAX_SIZE), &AtagStartAddress);

+    ASSERT_EFI_ERROR(Status);

+  }

+

+  // Ready to setup the atag list

+  mLinuxKernelCurrentAtag = (LINUX_ATAG*)(UINTN)AtagStartAddress;

+

+  // Standard core tag 4k PageSize

+  SetupCoreTag( (UINT32)SIZE_4KB );

+

+  // Physical memory setup

+  GetSystemMemoryResources (&ResourceList);

+  ResourceLink = ResourceList.ForwardLink;

+  while (ResourceLink != NULL && ResourceLink != &ResourceList) {

+    Resource = (BDS_SYSTEM_MEMORY_RESOURCE*)ResourceLink;

+    DEBUG((EFI_D_INFO,"- [0x%08X,0x%08X]\n",(UINT32)Resource->PhysicalStart,(UINT32)Resource->PhysicalStart+(UINT32)Resource->ResourceLength));

+    SetupMemTag( (UINT32)Resource->PhysicalStart, (UINT32)Resource->ResourceLength );

+    ResourceLink = ResourceLink->ForwardLink;

+  }

+

+  // CommandLine setting root device

+  if (CommandLineString) {

+    SetupCmdlineTag (CommandLineString);

+  }

+

+  if (InitrdImageSize > 0 && InitrdImage != 0) {

+    SetupInitrdTag ((UINT32)InitrdImage, (UINT32)InitrdImageSize);

+  }

+

+  // End of tags

+  SetupEndTag();

+

+  // Calculate atag list size

+  *AtagBase = AtagStartAddress;

+  *AtagSize = (UINT32)mLinuxKernelCurrentAtag - (UINT32)AtagStartAddress + 1;

+

+  return EFI_SUCCESS;

+}

+

diff --git a/ArmPkg/Library/BdsLib/BdsLinuxLoader.c b/ArmPkg/Library/BdsLib/Arm/BdsLinuxLoader.c
index cc54343f..d0eb075c 100644
--- a/ArmPkg/Library/BdsLib/BdsLinuxLoader.c
+++ b/ArmPkg/Library/BdsLib/Arm/BdsLinuxLoader.c
@@ -1,274 +1,307 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-#include "BdsInternal.h"
-#include "BdsLinuxLoader.h"
-
-#define ALIGN32_BELOW(addr)   ALIGN_POINTER(addr - 32,32)
-
-STATIC
-EFI_STATUS
-PreparePlatformHardware (
-  VOID
-  )
-{
-  //Note: Interrupts will be disabled by the GIC driver when ExitBootServices() will be called.
-
-  // Clean, invalidate, disable data cache
-  ArmCleanInvalidateDataCache();
+/** @file

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+#include "BdsInternal.h"

+#include "BdsLinuxLoader.h"

+

+#define ALIGN32_BELOW(addr)   ALIGN_POINTER(addr - 32,32)

+

+STATIC

+EFI_STATUS

+PreparePlatformHardware (

+  VOID

+  )

+{

+  //Note: Interrupts will be disabled by the GIC driver when ExitBootServices() will be called.

+

+  // Clean, invalidate, disable data cache

+  ArmCleanInvalidateDataCache();

   ArmDisableDataCache();
-
-  // Invalidate and disable the Instruction cache
-  ArmDisableInstructionCache ();
-  ArmInvalidateInstructionCache ();
-
-  // Turn off MMU
-  ArmDisableMmu();
-
-  return EFI_SUCCESS;
-}
-
-STATIC
-EFI_STATUS
-StartLinux (
-  IN  EFI_PHYSICAL_ADDRESS  LinuxImage,
-  IN  UINTN                 LinuxImageSize,
-  IN  EFI_PHYSICAL_ADDRESS  KernelParamsAddress,
-  IN  UINTN                 KernelParamsSize,
-  IN  UINT32                MachineType
-  )
-{
-  EFI_STATUS            Status;
-  LINUX_KERNEL          LinuxKernel;
-
-  // Shut down UEFI boot services. ExitBootServices() will notify every driver that created an event on
-  // ExitBootServices event. Example the Interrupt DXE driver will disable the interrupts on this event.
-  Status = ShutdownUefiBootServices ();
-  if(EFI_ERROR(Status)) {
-    DEBUG((EFI_D_ERROR,"ERROR: Can not shutdown UEFI boot services. Status=0x%X\n", Status));
-    goto Exit;
-  }
-
-  // Move the kernel parameters to any address inside the first 1MB.
-  // This is necessary because the ARM Linux kernel requires
-  // the FTD / ATAG List to reside entirely inside the first 1MB of
-  // physical memory.
-  //Note: There is no requirement on the alignment
-  if (MachineType != ARM_FDT_MACHINE_TYPE) {
-    if (((UINTN)KernelParamsAddress > LINUX_ATAG_MAX_OFFSET) && (KernelParamsSize < PcdGet32(PcdArmLinuxAtagMaxOffset))) {
-      KernelParamsAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)CopyMem (ALIGN32_BELOW(LINUX_ATAG_MAX_OFFSET - KernelParamsSize), (VOID*)(UINTN)KernelParamsAddress, KernelParamsSize);
-    }
-  } else {
-    if (((UINTN)KernelParamsAddress > LINUX_FDT_MAX_OFFSET) && (KernelParamsSize < PcdGet32(PcdArmLinuxFdtMaxOffset))) {
-      KernelParamsAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)CopyMem (ALIGN32_BELOW(LINUX_FDT_MAX_OFFSET - KernelParamsSize), (VOID*)(UINTN)KernelParamsAddress, KernelParamsSize);
-    }
-  }
-
-  if ((UINTN)LinuxImage > LINUX_KERNEL_MAX_OFFSET) {
-    //Note: There is no requirement on the alignment
-    LinuxKernel = (LINUX_KERNEL)CopyMem (ALIGN32_BELOW(LINUX_KERNEL_MAX_OFFSET - LinuxImageSize), (VOID*)(UINTN)LinuxImage, LinuxImageSize);
-  } else {
-    LinuxKernel = (LINUX_KERNEL)(UINTN)LinuxImage;
-  }
-
-  // Check if the Linux Image is a uImage
-  if (*(UINT32*)LinuxKernel == LINUX_UIMAGE_SIGNATURE) {
-    // Assume the Image Entry Point is just after the uImage header (64-byte size)
-    LinuxKernel = (LINUX_KERNEL)((UINTN)LinuxKernel + 64);
-    LinuxImageSize -= 64;
-  }
-
-  //TODO: Check there is no overlapping between kernel and Atag
-
-  //
-  // Switch off interrupts, caches, mmu, etc
-  //
-  Status = PreparePlatformHardware ();
-  ASSERT_EFI_ERROR(Status);
-
-  // Register and print out performance information
-  PERF_END (NULL, "BDS", NULL, 0);
-  if (PerformanceMeasurementEnabled ()) {
-    PrintPerformance ();
-  }
-
-  //
-  // Start the Linux Kernel
-  //
-
-  // Outside BootServices, so can't use Print();
-  DEBUG((EFI_D_ERROR, "\nStarting the kernel:\n\n"));
-
-  // Jump to kernel with register set
-  LinuxKernel ((UINTN)0, MachineType, (UINTN)KernelParamsAddress);
-
-  // Kernel should never exit
-  // After Life services are not provided
-  ASSERT(FALSE);
-
-Exit:
-  // Only be here if we fail to start Linux
-  Print (L"ERROR  : Can not start the kernel. Status=0x%X\n", Status);
-
-  // Free Runtimee Memory (kernel and FDT)
-  return Status;
-}
-
-/**
-  Start a Linux kernel from a Device Path
-
-  @param  LinuxKernel           Device Path to the Linux Kernel
-  @param  Parameters            Linux kernel arguments
-  @param  Fdt                   Device Path to the Flat Device Tree
-
-  @retval EFI_SUCCESS           All drivers have been connected
-  @retval EFI_NOT_FOUND         The Linux kernel Device Path has not been found
-  @retval EFI_OUT_OF_RESOURCES  There is not enough resource memory to store the matching results.
-
-**/
-EFI_STATUS
-BdsBootLinuxAtag (
-  IN  EFI_DEVICE_PATH_PROTOCOL* LinuxKernelDevicePath,
-  IN  EFI_DEVICE_PATH_PROTOCOL* InitrdDevicePath,
-  IN  CONST CHAR8*              CommandLineArguments
-  )
-{
-  EFI_STATUS            Status;
-  UINT32                LinuxImageSize;
-  UINT32                InitrdImageSize = 0;
-  UINT32                AtagSize;
-  EFI_PHYSICAL_ADDRESS  AtagBase;
-  EFI_PHYSICAL_ADDRESS  LinuxImage;
-  EFI_PHYSICAL_ADDRESS  InitrdImage;
-
-  PERF_START (NULL, "BDS", NULL, 0);
-
-  // Load the Linux kernel from a device path
-  LinuxImage = LINUX_KERNEL_MAX_OFFSET;
-  Status = BdsLoadImage (LinuxKernelDevicePath, AllocateMaxAddress, &LinuxImage, &LinuxImageSize);
-  if (EFI_ERROR(Status)) {
-    Print (L"ERROR: Did not find Linux kernel.\n");
-    return Status;
-  }
-
-  if (InitrdDevicePath) {
-    // Load the initrd near to the Linux kernel
-    InitrdImage = LINUX_KERNEL_MAX_OFFSET;
-    Status = BdsLoadImage (InitrdDevicePath, AllocateMaxAddress, &InitrdImage, &InitrdImageSize);
-    if (Status == EFI_OUT_OF_RESOURCES) {
-      Status = BdsLoadImage (InitrdDevicePath, AllocateAnyPages, &InitrdImage, &InitrdImageSize);
-    }
-    if (EFI_ERROR(Status)) {
-      Print (L"ERROR: Did not find initrd image.\n");
-      return Status;
-    }
-    
-    // Check if the initrd is a uInitrd
-    if (*(UINT32*)((UINTN)InitrdImage) == LINUX_UIMAGE_SIGNATURE) {
-      // Skip the 64-byte image header
-      InitrdImage = (EFI_PHYSICAL_ADDRESS)((UINTN)InitrdImage + 64);
-      InitrdImageSize -= 64;
-    }
-  }
-
-  //
-  // Setup the Linux Kernel Parameters
-  //
- 
-  // By setting address=0 we leave the memory allocation to the function
-  Status = PrepareAtagList (CommandLineArguments, InitrdImage, InitrdImageSize, &AtagBase, &AtagSize);
-  if (EFI_ERROR(Status)) {
-    Print(L"ERROR: Can not prepare ATAG list. Status=0x%X\n", Status);
-    return Status;
-  }
-
-  return StartLinux (LinuxImage, LinuxImageSize, AtagBase, AtagSize, PcdGet32(PcdArmMachineType));
-}
-
-/**
-  Start a Linux kernel from a Device Path
-
-  @param  LinuxKernel           Device Path to the Linux Kernel
-  @param  Parameters            Linux kernel arguments
-  @param  Fdt                   Device Path to the Flat Device Tree
-
-  @retval EFI_SUCCESS           All drivers have been connected
-  @retval EFI_NOT_FOUND         The Linux kernel Device Path has not been found
-  @retval EFI_OUT_OF_RESOURCES  There is not enough resource memory to store the matching results.
-
-**/
-EFI_STATUS
-BdsBootLinuxFdt (
-  IN  EFI_DEVICE_PATH_PROTOCOL* LinuxKernelDevicePath,
-  IN  EFI_DEVICE_PATH_PROTOCOL* InitrdDevicePath,
-  IN  CONST CHAR8*              CommandLineArguments,
-  IN  EFI_DEVICE_PATH_PROTOCOL* FdtDevicePath
-  )
-{
-  EFI_STATUS            Status;
-  UINT32                LinuxImageSize;
-  UINT32                InitrdImageSize = 0;
-  UINT32                FdtBlobSize;
-  EFI_PHYSICAL_ADDRESS  FdtBlobBase;
-  EFI_PHYSICAL_ADDRESS  LinuxImage;
-  EFI_PHYSICAL_ADDRESS  InitrdImage;
-
-  PERF_START (NULL, "BDS", NULL, 0);
-
-  // Load the Linux kernel from a device path
-  LinuxImage = LINUX_KERNEL_MAX_OFFSET;
-  Status = BdsLoadImage (LinuxKernelDevicePath, AllocateMaxAddress, &LinuxImage, &LinuxImageSize);
-  if (EFI_ERROR(Status)) {
-    Print (L"ERROR: Did not find Linux kernel.\n");
-    return Status;
-  }
-
-  if (InitrdDevicePath) {
-    InitrdImage = LINUX_KERNEL_MAX_OFFSET;
-    Status = BdsLoadImage (InitrdDevicePath, AllocateMaxAddress, &InitrdImage, &InitrdImageSize);
-    if (Status == EFI_OUT_OF_RESOURCES) {
-      Status = BdsLoadImage (InitrdDevicePath, AllocateAnyPages, &InitrdImage, &InitrdImageSize);
-    }
-    if (EFI_ERROR(Status)) {
-      Print (L"ERROR: Did not find initrd image.\n");
-      return Status;
-    }
-
-    // Check if the initrd is a uInitrd
-    if (*(UINT32*)((UINTN)InitrdImage) == LINUX_UIMAGE_SIGNATURE) {
-      // Skip the 64-byte image header
-      InitrdImage = (EFI_PHYSICAL_ADDRESS)((UINTN)InitrdImage + 64);
-      InitrdImageSize -= 64;
-    }
-  }
-
-  // Load the FDT binary from a device path. The FDT will be reloaded later to a more appropriate location for the Linux kernel.
-  FdtBlobBase = 0;
-  Status = BdsLoadImage (FdtDevicePath, AllocateAnyPages, &FdtBlobBase, &FdtBlobSize);
-  if (EFI_ERROR(Status)) {
-    Print (L"ERROR: Did not find Device Tree blob.\n");
-    return Status;
-  }
-
-  // Update the Fdt with the Initrd information. The FDT will increase in size.
-  // By setting address=0 we leave the memory allocation to the function
-  Status = PrepareFdt (CommandLineArguments, InitrdImage, InitrdImageSize, &FdtBlobBase, &FdtBlobSize);
-  if (EFI_ERROR(Status)) {
-    Print(L"ERROR: Can not load kernel with FDT. Status=%r\n", Status);
-    return Status;
-  }
-
-  return StartLinux (LinuxImage, LinuxImageSize, FdtBlobBase, FdtBlobSize, ARM_FDT_MACHINE_TYPE);
-}
-
+

+  // Invalidate and disable the Instruction cache

+  ArmDisableInstructionCache ();

+  ArmInvalidateInstructionCache ();

+

+  // Turn off MMU

+  ArmDisableMmu();

+

+  return EFI_SUCCESS;

+}

+

+STATIC

+EFI_STATUS

+StartLinux (

+  IN  EFI_PHYSICAL_ADDRESS  LinuxImage,

+  IN  UINTN                 LinuxImageSize,

+  IN  EFI_PHYSICAL_ADDRESS  KernelParamsAddress,

+  IN  UINTN                 KernelParamsSize,

+  IN  UINT32                MachineType

+  )

+{

+  EFI_STATUS            Status;

+  LINUX_KERNEL          LinuxKernel;

+

+  // Shut down UEFI boot services. ExitBootServices() will notify every driver that created an event on

+  // ExitBootServices event. Example the Interrupt DXE driver will disable the interrupts on this event.

+  Status = ShutdownUefiBootServices ();

+  if(EFI_ERROR(Status)) {

+    DEBUG((EFI_D_ERROR,"ERROR: Can not shutdown UEFI boot services. Status=0x%X\n", Status));

+    goto Exit;

+  }

+

+  // Move the kernel parameters to any address inside the first 1MB.

+  // This is necessary because the ARM Linux kernel requires

+  // the FTD / ATAG List to reside entirely inside the first 1MB of

+  // physical memory.

+  //Note: There is no requirement on the alignment

+  if (MachineType != ARM_FDT_MACHINE_TYPE) {

+    if (((UINTN)KernelParamsAddress > LINUX_ATAG_MAX_OFFSET) && (KernelParamsSize < PcdGet32(PcdArmLinuxAtagMaxOffset))) {

+      KernelParamsAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)CopyMem (ALIGN32_BELOW(LINUX_ATAG_MAX_OFFSET - KernelParamsSize), (VOID*)(UINTN)KernelParamsAddress, KernelParamsSize);

+    }

+  } else {

+    if (((UINTN)KernelParamsAddress > LINUX_FDT_MAX_OFFSET) && (KernelParamsSize < PcdGet32(PcdArmLinuxFdtMaxOffset))) {

+      KernelParamsAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)CopyMem (ALIGN32_BELOW(LINUX_FDT_MAX_OFFSET - KernelParamsSize), (VOID*)(UINTN)KernelParamsAddress, KernelParamsSize);

+    }

+  }

+

+  if ((UINTN)LinuxImage > LINUX_KERNEL_MAX_OFFSET) {

+    //Note: There is no requirement on the alignment

+    LinuxKernel = (LINUX_KERNEL)CopyMem (ALIGN32_BELOW(LINUX_KERNEL_MAX_OFFSET - LinuxImageSize), (VOID*)(UINTN)LinuxImage, LinuxImageSize);

+  } else {

+    LinuxKernel = (LINUX_KERNEL)(UINTN)LinuxImage;

+  }

+

+  // Check if the Linux Image is a uImage

+  if (*(UINT32*)LinuxKernel == LINUX_UIMAGE_SIGNATURE) {

+    // Assume the Image Entry Point is just after the uImage header (64-byte size)

+    LinuxKernel = (LINUX_KERNEL)((UINTN)LinuxKernel + 64);

+    LinuxImageSize -= 64;

+  }

+

+  //TODO: Check there is no overlapping between kernel and Atag

+

+  //

+  // Switch off interrupts, caches, mmu, etc

+  //

+  Status = PreparePlatformHardware ();

+  ASSERT_EFI_ERROR(Status);

+

+  // Register and print out performance information

+  PERF_END (NULL, "BDS", NULL, 0);

+  if (PerformanceMeasurementEnabled ()) {

+    PrintPerformance ();

+  }

+

+  //

+  // Start the Linux Kernel

+  //

+

+  // Outside BootServices, so can't use Print();

+  DEBUG((EFI_D_ERROR, "\nStarting the kernel:\n\n"));

+

+  // Jump to kernel with register set

+  LinuxKernel ((UINTN)0, MachineType, (UINTN)KernelParamsAddress);

+

+  // Kernel should never exit

+  // After Life services are not provided

+  ASSERT(FALSE);

+

+Exit:

+  // Only be here if we fail to start Linux

+  Print (L"ERROR  : Can not start the kernel. Status=0x%X\n", Status);

+

+  // Free Runtimee Memory (kernel and FDT)

+  return Status;

+}

+

+/**

+  Start a Linux kernel from a Device Path

+

+  @param  LinuxKernel           Device Path to the Linux Kernel

+  @param  Parameters            Linux kernel arguments

+  @param  Fdt                   Device Path to the Flat Device Tree

+

+  @retval EFI_SUCCESS           All drivers have been connected

+  @retval EFI_NOT_FOUND         The Linux kernel Device Path has not been found

+  @retval EFI_OUT_OF_RESOURCES  There is not enough resource memory to store the matching results.

+

+**/

+EFI_STATUS

+BdsBootLinuxAtag (

+  IN  EFI_DEVICE_PATH_PROTOCOL* LinuxKernelDevicePath,

+  IN  EFI_DEVICE_PATH_PROTOCOL* InitrdDevicePath,

+  IN  CONST CHAR8*              CommandLineArguments

+  )

+{

+  EFI_STATUS            Status;

+  UINT32                LinuxImageSize;

+  UINT32                InitrdImageBaseSize = 0;

+  UINT32                InitrdImageSize = 0;

+  UINT32                AtagSize;

+  EFI_PHYSICAL_ADDRESS  AtagBase;

+  EFI_PHYSICAL_ADDRESS  LinuxImage;

+  EFI_PHYSICAL_ADDRESS  InitrdImageBase = 0;

+  EFI_PHYSICAL_ADDRESS  InitrdImage = 0;

+

+  PERF_START (NULL, "BDS", NULL, 0);

+

+  // Load the Linux kernel from a device path

+  LinuxImage = LINUX_KERNEL_MAX_OFFSET;

+  Status = BdsLoadImage (LinuxKernelDevicePath, AllocateMaxAddress, &LinuxImage, &LinuxImageSize);

+  if (EFI_ERROR(Status)) {

+    Print (L"ERROR: Did not find Linux kernel.\n");

+    return Status;

+  }

+

+  if (InitrdDevicePath) {

+    // Load the initrd near to the Linux kernel

+    InitrdImageBase = LINUX_KERNEL_MAX_OFFSET;

+    Status = BdsLoadImage (InitrdDevicePath, AllocateMaxAddress, &InitrdImageBase, &InitrdImageBaseSize);

+    if (Status == EFI_OUT_OF_RESOURCES) {

+      Status = BdsLoadImage (InitrdDevicePath, AllocateAnyPages, &InitrdImageBase, &InitrdImageBaseSize);

+    }

+    if (EFI_ERROR(Status)) {

+      Print (L"ERROR: Did not find initrd image.\n");

+      goto EXIT_FREE_LINUX;

+    }

+    

+    // Check if the initrd is a uInitrd

+    if (*(UINT32*)((UINTN)InitrdImageBase) == LINUX_UIMAGE_SIGNATURE) {

+      // Skip the 64-byte image header

+      InitrdImage = (EFI_PHYSICAL_ADDRESS)((UINTN)InitrdImageBase + 64);

+      InitrdImageSize = InitrdImageBaseSize - 64;

+    } else {

+      InitrdImage = InitrdImageBase;

+      InitrdImageSize = InitrdImageBaseSize;

+    }

+  }

+

+  //

+  // Setup the Linux Kernel Parameters

+  //

+ 

+  // By setting address=0 we leave the memory allocation to the function

+  Status = PrepareAtagList (CommandLineArguments, InitrdImage, InitrdImageSize, &AtagBase, &AtagSize);

+  if (EFI_ERROR(Status)) {

+    Print(L"ERROR: Can not prepare ATAG list. Status=0x%X\n", Status);

+    goto EXIT_FREE_INITRD;

+  }

+

+  return StartLinux (LinuxImage, LinuxImageSize, AtagBase, AtagSize, PcdGet32(PcdArmMachineType));

+

+EXIT_FREE_INITRD:

+  if (InitrdDevicePath) {

+    gBS->FreePages (InitrdImageBase, EFI_SIZE_TO_PAGES (InitrdImageBaseSize));

+  }

+

+EXIT_FREE_LINUX:

+  gBS->FreePages (LinuxImage, EFI_SIZE_TO_PAGES (LinuxImageSize));

+

+  return Status;

+}

+

+/**

+  Start a Linux kernel from a Device Path

+

+  @param  LinuxKernel           Device Path to the Linux Kernel

+  @param  Parameters            Linux kernel arguments

+  @param  Fdt                   Device Path to the Flat Device Tree

+

+  @retval EFI_SUCCESS           All drivers have been connected

+  @retval EFI_NOT_FOUND         The Linux kernel Device Path has not been found

+  @retval EFI_OUT_OF_RESOURCES  There is not enough resource memory to store the matching results.

+

+**/

+EFI_STATUS

+BdsBootLinuxFdt (

+  IN  EFI_DEVICE_PATH_PROTOCOL* LinuxKernelDevicePath,

+  IN  EFI_DEVICE_PATH_PROTOCOL* InitrdDevicePath,

+  IN  CONST CHAR8*              CommandLineArguments,

+  IN  EFI_DEVICE_PATH_PROTOCOL* FdtDevicePath

+  )

+{

+  EFI_STATUS            Status;

+  UINT32                LinuxImageSize;

+  UINT32                InitrdImageBaseSize = 0;

+  UINT32                InitrdImageSize = 0;

+  UINT32                FdtBlobSize;

+  EFI_PHYSICAL_ADDRESS  FdtBlobBase;

+  EFI_PHYSICAL_ADDRESS  LinuxImage;

+  EFI_PHYSICAL_ADDRESS  InitrdImageBase = 0;

+  EFI_PHYSICAL_ADDRESS  InitrdImage = 0;

+

+  PERF_START (NULL, "BDS", NULL, 0);

+

+  // Load the Linux kernel from a device path

+  LinuxImage = LINUX_KERNEL_MAX_OFFSET;

+  Status = BdsLoadImage (LinuxKernelDevicePath, AllocateMaxAddress, &LinuxImage, &LinuxImageSize);

+  if (EFI_ERROR(Status)) {

+    Print (L"ERROR: Did not find Linux kernel.\n");

+    return Status;

+  }

+

+  if (InitrdDevicePath) {

+    InitrdImageBase = LINUX_KERNEL_MAX_OFFSET;

+    Status = BdsLoadImage (InitrdDevicePath, AllocateMaxAddress, &InitrdImageBase, &InitrdImageBaseSize);

+    if (Status == EFI_OUT_OF_RESOURCES) {

+      Status = BdsLoadImage (InitrdDevicePath, AllocateAnyPages, &InitrdImageBase, &InitrdImageBaseSize);

+    }

+    if (EFI_ERROR(Status)) {

+      Print (L"ERROR: Did not find initrd image.\n");

+      goto EXIT_FREE_LINUX;

+    }

+

+    // Check if the initrd is a uInitrd

+    if (*(UINT32*)((UINTN)InitrdImageBase) == LINUX_UIMAGE_SIGNATURE) {

+      // Skip the 64-byte image header

+      InitrdImage = (EFI_PHYSICAL_ADDRESS)((UINTN)InitrdImageBase + 64);

+      InitrdImageSize = InitrdImageBaseSize - 64;

+    } else {

+      InitrdImage = InitrdImageBase;

+      InitrdImageSize = InitrdImageBaseSize;

+    }

+  }

+

+  // Load the FDT binary from a device path. The FDT will be reloaded later to a more appropriate location for the Linux kernel.

+  FdtBlobBase = 0;

+  Status = BdsLoadImage (FdtDevicePath, AllocateAnyPages, &FdtBlobBase, &FdtBlobSize);

+  if (EFI_ERROR(Status)) {

+    Print (L"ERROR: Did not find Device Tree blob.\n");

+    goto EXIT_FREE_INITRD;

+  }

+

+  // Update the Fdt with the Initrd information. The FDT will increase in size.

+  // By setting address=0 we leave the memory allocation to the function

+  Status = PrepareFdt (CommandLineArguments, InitrdImage, InitrdImageSize, &FdtBlobBase, &FdtBlobSize);

+  if (EFI_ERROR(Status)) {

+    Print(L"ERROR: Can not load kernel with FDT. Status=%r\n", Status);

+    goto EXIT_FREE_FDT;

+  }

+

+  return StartLinux (LinuxImage, LinuxImageSize, FdtBlobBase, FdtBlobSize, ARM_FDT_MACHINE_TYPE);

+

+EXIT_FREE_FDT:

+  gBS->FreePages (FdtBlobBase, EFI_SIZE_TO_PAGES (FdtBlobSize));

+

+EXIT_FREE_INITRD:

+  if (InitrdDevicePath) {

+    gBS->FreePages (InitrdImageBase, EFI_SIZE_TO_PAGES (InitrdImageBaseSize));

+  }

+

+EXIT_FREE_LINUX:

+  gBS->FreePages (LinuxImage, EFI_SIZE_TO_PAGES (LinuxImageSize));

+

+  return Status;

+}

+

diff --git a/ArmPkg/Library/BdsLib/BdsAppLoader.c b/ArmPkg/Library/BdsLib/BdsAppLoader.c
index 2d7f96e2..2b88bf1e 100644
--- a/ArmPkg/Library/BdsLib/BdsAppLoader.c
+++ b/ArmPkg/Library/BdsLib/BdsAppLoader.c
@@ -1,144 +1,144 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*
-*  This program and the accompanying materials
-*  are licensed and made available under the terms and conditions of the BSD License
-*  which accompanies this distribution.  The full text of the license may be found at
-*  http://opensource.org/licenses/bsd-license.php
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-*
-**/
-
-#include "BdsInternal.h"
-
-//#include <Library/DxeServicesLib.h>
-
-STATIC
-EFI_STATUS
-BdsLoadFileFromFirmwareVolume (
-  IN  EFI_HANDLE      FvHandle,
-  IN  CHAR16    *FilePath,
-  IN  EFI_FV_FILETYPE FileTypeFilter,
-  OUT EFI_DEVICE_PATH     **EfiAppDevicePath
-  )
-{
-  EFI_FIRMWARE_VOLUME2_PROTOCOL *FvProtocol;
-  VOID                          *Key;
-  EFI_STATUS                    Status, FileStatus;
-  EFI_GUID                      NameGuid;
-  EFI_FV_FILETYPE               FileType;
-  EFI_FV_FILE_ATTRIBUTES        Attributes;
-  UINTN                         Size;
-  UINTN                         UiStringLen;
-  CHAR16                        *UiSection;
-  UINT32                        Authentication;
-  EFI_DEVICE_PATH               *FvDevicePath;
-  MEDIA_FW_VOL_FILEPATH_DEVICE_PATH    FileDevicePath;
-
-  Status = gBS->HandleProtocol (FvHandle,&gEfiFirmwareVolume2ProtocolGuid, (VOID **)&FvProtocol);
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  // Length of FilePath
-  UiStringLen = StrLen (FilePath);
-
-  // Allocate Key
-  Key = AllocatePool (FvProtocol->KeySize);
-  ASSERT (Key != NULL);
-  ZeroMem (Key, FvProtocol->KeySize);
-
-  do {
-    // Search in all files
-    FileType = FileTypeFilter;
-
-    Status = FvProtocol->GetNextFile (FvProtocol, Key, &FileType, &NameGuid, &Attributes, &Size);
-    if (!EFI_ERROR (Status)) {
-      UiSection = NULL;
-      FileStatus = FvProtocol->ReadSection (
-                    FvProtocol,
-                    &NameGuid,
-                    EFI_SECTION_USER_INTERFACE,
-                    0,
-                    (VOID **)&UiSection,
-                    &Size,
-                    &Authentication
-                    );
-      if (!EFI_ERROR (FileStatus)) {
-        if (StrnCmp (FilePath, UiSection, UiStringLen) == 0) {
-          //
-          // We found a UiString match.
-          //
-          Status = gBS->HandleProtocol (FvHandle, &gEfiDevicePathProtocolGuid, (VOID **)&FvDevicePath);
-
-          // Generate the Device Path for the file
-          //DevicePath = DuplicateDevicePath(FvDevicePath);
-          EfiInitializeFwVolDevicepathNode (&FileDevicePath, &NameGuid);
-          *EfiAppDevicePath = AppendDevicePathNode (FvDevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&FileDevicePath);
-
-          FreePool (Key);
-          FreePool (UiSection);
-          return FileStatus;
-        }
-        FreePool (UiSection);
-      }
-    }
-  } while (!EFI_ERROR (Status));
-
-  FreePool(Key);
-  return Status;
-}
-
-/**
-  Start an EFI Application from any Firmware Volume
-
-  @param  EfiApp                EFI Application Name
-
-  @retval EFI_SUCCESS           All drivers have been connected
-  @retval EFI_NOT_FOUND         The Linux kernel Device Path has not been found
-  @retval EFI_OUT_OF_RESOURCES  There is not enough resource memory to store the matching results.
-
-**/
-EFI_STATUS
-BdsLoadApplication (
-  IN EFI_HANDLE                  ParentImageHandle,
-  IN CHAR16*                     EfiApp,
-  IN UINTN                       LoadOptionsSize,
-  IN VOID*                       LoadOptions
-  )
-{
-  EFI_STATUS                      Status;
-  UINTN                           NoHandles, HandleIndex;
-  EFI_HANDLE                      *Handles;
-  EFI_DEVICE_PATH                 *EfiAppDevicePath;
-
-  // Need to connect every drivers to ensure no dependencies are missing for the application
-  Status = BdsConnectAllDrivers();
-  if (EFI_ERROR(Status)) {
-    DEBUG ((EFI_D_ERROR, "FAIL to connect all drivers\n"));
-    return Status;
-  }
-
-  // Search the application in any Firmware Volume
-  Status = gBS->LocateHandleBuffer (ByProtocol, &gEfiFirmwareVolume2ProtocolGuid, NULL, &NoHandles, &Handles);
-  if (EFI_ERROR (Status) || (NoHandles == 0)) {
-    DEBUG ((EFI_D_ERROR, "FAIL to find Firmware Volume\n"));
-    return Status;
-  }
-
-  // Search in all Firmware Volume for the EFI Application
-  for (HandleIndex = 0; HandleIndex < NoHandles; HandleIndex++) {
-    EfiAppDevicePath = NULL;
-    Status = BdsLoadFileFromFirmwareVolume (Handles[HandleIndex], EfiApp, EFI_FV_FILETYPE_APPLICATION, &EfiAppDevicePath);
-    if (!EFI_ERROR (Status)) {
-      // Start the application
-      Status = BdsStartEfiApplication (ParentImageHandle, EfiAppDevicePath, LoadOptionsSize, LoadOptions);
-      return Status;
-    }
-  }
-
-  return Status;
-}
+/** @file

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*

+*  This program and the accompanying materials

+*  are licensed and made available under the terms and conditions of the BSD License

+*  which accompanies this distribution.  The full text of the license may be found at

+*  http://opensource.org/licenses/bsd-license.php

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+*

+**/

+

+#include "BdsInternal.h"

+

+//#include <Library/DxeServicesLib.h>

+

+STATIC

+EFI_STATUS

+BdsLoadFileFromFirmwareVolume (

+  IN  EFI_HANDLE      FvHandle,

+  IN  CHAR16    *FilePath,

+  IN  EFI_FV_FILETYPE FileTypeFilter,

+  OUT EFI_DEVICE_PATH     **EfiAppDevicePath

+  )

+{

+  EFI_FIRMWARE_VOLUME2_PROTOCOL *FvProtocol;

+  VOID                          *Key;

+  EFI_STATUS                    Status, FileStatus;

+  EFI_GUID                      NameGuid;

+  EFI_FV_FILETYPE               FileType;

+  EFI_FV_FILE_ATTRIBUTES        Attributes;

+  UINTN                         Size;

+  UINTN                         UiStringLen;

+  CHAR16                        *UiSection;

+  UINT32                        Authentication;

+  EFI_DEVICE_PATH               *FvDevicePath;

+  MEDIA_FW_VOL_FILEPATH_DEVICE_PATH    FileDevicePath;

+

+  Status = gBS->HandleProtocol (FvHandle,&gEfiFirmwareVolume2ProtocolGuid, (VOID **)&FvProtocol);

+  if (EFI_ERROR(Status)) {

+    return Status;

+  }

+

+  // Length of FilePath

+  UiStringLen = StrLen (FilePath);

+

+  // Allocate Key

+  Key = AllocatePool (FvProtocol->KeySize);

+  ASSERT (Key != NULL);

+  ZeroMem (Key, FvProtocol->KeySize);

+

+  do {

+    // Search in all files

+    FileType = FileTypeFilter;

+

+    Status = FvProtocol->GetNextFile (FvProtocol, Key, &FileType, &NameGuid, &Attributes, &Size);

+    if (!EFI_ERROR (Status)) {

+      UiSection = NULL;

+      FileStatus = FvProtocol->ReadSection (

+                    FvProtocol,

+                    &NameGuid,

+                    EFI_SECTION_USER_INTERFACE,

+                    0,

+                    (VOID **)&UiSection,

+                    &Size,

+                    &Authentication

+                    );

+      if (!EFI_ERROR (FileStatus)) {

+        if (StrnCmp (FilePath, UiSection, UiStringLen) == 0) {

+          //

+          // We found a UiString match.

+          //

+          Status = gBS->HandleProtocol (FvHandle, &gEfiDevicePathProtocolGuid, (VOID **)&FvDevicePath);

+

+          // Generate the Device Path for the file

+          //DevicePath = DuplicateDevicePath(FvDevicePath);

+          EfiInitializeFwVolDevicepathNode (&FileDevicePath, &NameGuid);

+          *EfiAppDevicePath = AppendDevicePathNode (FvDevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&FileDevicePath);

+

+          FreePool (Key);

+          FreePool (UiSection);

+          return FileStatus;

+        }

+        FreePool (UiSection);

+      }

+    }

+  } while (!EFI_ERROR (Status));

+

+  FreePool(Key);

+  return Status;

+}

+

+/**

+  Start an EFI Application from any Firmware Volume

+

+  @param  EfiApp                EFI Application Name

+

+  @retval EFI_SUCCESS           All drivers have been connected

+  @retval EFI_NOT_FOUND         The Linux kernel Device Path has not been found

+  @retval EFI_OUT_OF_RESOURCES  There is not enough resource memory to store the matching results.

+

+**/

+EFI_STATUS

+BdsLoadApplication (

+  IN EFI_HANDLE                  ParentImageHandle,

+  IN CHAR16*                     EfiApp,

+  IN UINTN                       LoadOptionsSize,

+  IN VOID*                       LoadOptions

+  )

+{

+  EFI_STATUS                      Status;

+  UINTN                           NoHandles, HandleIndex;

+  EFI_HANDLE                      *Handles;

+  EFI_DEVICE_PATH                 *EfiAppDevicePath;

+

+  // Need to connect every drivers to ensure no dependencies are missing for the application

+  Status = BdsConnectAllDrivers();

+  if (EFI_ERROR(Status)) {

+    DEBUG ((EFI_D_ERROR, "FAIL to connect all drivers\n"));

+    return Status;

+  }

+

+  // Search the application in any Firmware Volume

+  Status = gBS->LocateHandleBuffer (ByProtocol, &gEfiFirmwareVolume2ProtocolGuid, NULL, &NoHandles, &Handles);

+  if (EFI_ERROR (Status) || (NoHandles == 0)) {

+    DEBUG ((EFI_D_ERROR, "FAIL to find Firmware Volume\n"));

+    return Status;

+  }

+

+  // Search in all Firmware Volume for the EFI Application

+  for (HandleIndex = 0; HandleIndex < NoHandles; HandleIndex++) {

+    EfiAppDevicePath = NULL;

+    Status = BdsLoadFileFromFirmwareVolume (Handles[HandleIndex], EfiApp, EFI_FV_FILETYPE_APPLICATION, &EfiAppDevicePath);

+    if (!EFI_ERROR (Status)) {

+      // Start the application

+      Status = BdsStartEfiApplication (ParentImageHandle, EfiAppDevicePath, LoadOptionsSize, LoadOptions);

+      return Status;

+    }

+  }

+

+  return Status;

+}

diff --git a/ArmPkg/Library/BdsLib/BdsFilePath.c b/ArmPkg/Library/BdsLib/BdsFilePath.c
index a8b77a3d..25f92725 100644
--- a/ArmPkg/Library/BdsLib/BdsFilePath.c
+++ b/ArmPkg/Library/BdsLib/BdsFilePath.c
@@ -1,906 +1,953 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-#include "BdsInternal.h"
-
-#include <Protocol/UsbIo.h>
-#include <Protocol/DiskIo.h>
-#include <Protocol/LoadedImage.h>
-
-#define IS_DEVICE_PATH_NODE(node,type,subtype) (((node)->Type == (type)) && ((node)->SubType == (subtype)))
-
-// Extract the FilePath from the Device Path
-CHAR16*
-BdsExtractFilePathFromDevicePath (
-  IN  CONST CHAR16    *StrDevicePath,
-  IN  UINTN           NumberDevicePathNode
-  )
-{
-  UINTN       Node;
-  CHAR16      *Str;
-
-  Str = (CHAR16*)StrDevicePath;
-  Node = 0;
-  while ((Str != NULL) && (*Str != L'\0') && (Node < NumberDevicePathNode)) {
-    if ((*Str == L'/') || (*Str == L'\\')) {
-        Node++;
-    }
-    Str++;
-  }
-
-  if (*Str == L'\0') {
-    return NULL;
-  } else {
-    return Str;
-  }
-}
-
-BOOLEAN
-BdsIsRemovableUsb (
-  IN  EFI_DEVICE_PATH*  DevicePath
-  )
-{
-  return ((DevicePathType (DevicePath) == MESSAGING_DEVICE_PATH) &&
-          ((DevicePathSubType (DevicePath) == MSG_USB_CLASS_DP) ||
-           (DevicePathSubType (DevicePath) == MSG_USB_WWID_DP)));
-}
-
-EFI_STATUS
-BdsGetDeviceUsb (
-  IN  EFI_DEVICE_PATH*  RemovableDevicePath,
-  OUT EFI_HANDLE*       DeviceHandle,
-  OUT EFI_DEVICE_PATH** NewDevicePath
-  )
-{
-  EFI_STATUS                    Status;
-  UINTN                         Index;
-  UINTN                         UsbIoHandleCount;
-  EFI_HANDLE                    *UsbIoBuffer;
-  EFI_DEVICE_PATH*              UsbIoDevicePath;
-  EFI_DEVICE_PATH*              TmpDevicePath;
-  USB_WWID_DEVICE_PATH*         WwidDevicePath1;
-  USB_WWID_DEVICE_PATH*         WwidDevicePath2;
-  USB_CLASS_DEVICE_PATH*        UsbClassDevicePath1;
-  USB_CLASS_DEVICE_PATH*        UsbClassDevicePath2;
-
-  // Get all the UsbIo handles
-  UsbIoHandleCount = 0;
-  Status = gBS->LocateHandleBuffer (ByProtocol, &gEfiUsbIoProtocolGuid, NULL, &UsbIoHandleCount, &UsbIoBuffer);
-  if (EFI_ERROR(Status) || (UsbIoHandleCount == 0)) {
-    return Status;
-  }
-
-  // Check if one of the handles matches the USB description
-  for (Index = 0; Index < UsbIoHandleCount; Index++) {
-    Status = gBS->HandleProtocol (UsbIoBuffer[Index], &gEfiDevicePathProtocolGuid, (VOID **) &UsbIoDevicePath);
-    if (!EFI_ERROR(Status)) {
-      TmpDevicePath = UsbIoDevicePath;
-      while (!IsDevicePathEnd (TmpDevicePath)) {
-        // Check if the Device Path node is a USB Removable device Path node
-        if (BdsIsRemovableUsb (TmpDevicePath)) {
-          if (TmpDevicePath->SubType == MSG_USB_WWID_DP) {
-            WwidDevicePath1 = (USB_WWID_DEVICE_PATH*)RemovableDevicePath;
-            WwidDevicePath2 = (USB_WWID_DEVICE_PATH*)TmpDevicePath;
-            if ((WwidDevicePath1->VendorId == WwidDevicePath2->VendorId) &&
-                (WwidDevicePath1->ProductId == WwidDevicePath2->ProductId) &&
-                (CompareMem (WwidDevicePath1+1, WwidDevicePath2+1, DevicePathNodeLength(WwidDevicePath1)-sizeof(USB_WWID_DEVICE_PATH)) == 0))
-            {
-              *DeviceHandle = UsbIoBuffer[Index];
-              // Add the additional original Device Path Nodes (eg: FilePath Device Path Node) to the new Device Path
-              *NewDevicePath = AppendDevicePath (UsbIoDevicePath, NextDevicePathNode(RemovableDevicePath));
-              return EFI_SUCCESS;
-            }
-          } else {
-            UsbClassDevicePath1 = (USB_CLASS_DEVICE_PATH*)RemovableDevicePath;
-            UsbClassDevicePath2 = (USB_CLASS_DEVICE_PATH*)TmpDevicePath;
-            if ((UsbClassDevicePath1->VendorId != 0xFFFF) && (UsbClassDevicePath1->VendorId == UsbClassDevicePath2->VendorId) &&
-                (UsbClassDevicePath1->ProductId != 0xFFFF) && (UsbClassDevicePath1->ProductId == UsbClassDevicePath2->ProductId) &&
-                (UsbClassDevicePath1->DeviceClass != 0xFF) && (UsbClassDevicePath1->DeviceClass == UsbClassDevicePath2->DeviceClass) &&
-                (UsbClassDevicePath1->DeviceSubClass != 0xFF) && (UsbClassDevicePath1->DeviceSubClass == UsbClassDevicePath2->DeviceSubClass) &&
-                (UsbClassDevicePath1->DeviceProtocol != 0xFF) && (UsbClassDevicePath1->DeviceProtocol == UsbClassDevicePath2->DeviceProtocol))
-            {
-              *DeviceHandle = UsbIoBuffer[Index];
-              // Add the additional original Device Path Nodes (eg: FilePath Device Path Node) to the new Device Path
-              *NewDevicePath = AppendDevicePath (UsbIoDevicePath, NextDevicePathNode(RemovableDevicePath));
-              return EFI_SUCCESS;
-            }
-          }
-        }
-        TmpDevicePath = NextDevicePathNode (TmpDevicePath);
-      }
-
-    }
-  }
-
-  return EFI_NOT_FOUND;
-}
-
-BOOLEAN
-BdsIsRemovableHd (
-  IN  EFI_DEVICE_PATH*  DevicePath
-  )
-{
-  return IS_DEVICE_PATH_NODE(DevicePath, MEDIA_DEVICE_PATH, MEDIA_HARDDRIVE_DP);
-}
-
-EFI_STATUS
-BdsGetDeviceHd (
-  IN  EFI_DEVICE_PATH*  RemovableDevicePath,
-  OUT EFI_HANDLE*       DeviceHandle,
-  OUT EFI_DEVICE_PATH** NewDevicePath
-  )
-{
-  EFI_STATUS                    Status;
-  UINTN                         Index;
-  UINTN                         PartitionHandleCount;
-  EFI_HANDLE                    *PartitionBuffer;
-  EFI_DEVICE_PATH*              PartitionDevicePath;
-  EFI_DEVICE_PATH*              TmpDevicePath;
-  HARDDRIVE_DEVICE_PATH*        HardDriveDevicePath1;
-  HARDDRIVE_DEVICE_PATH*        HardDriveDevicePath2;
-
-  // Get all the DiskIo handles
-  PartitionHandleCount = 0;
-  Status = gBS->LocateHandleBuffer (ByProtocol, &gEfiDiskIoProtocolGuid, NULL, &PartitionHandleCount, &PartitionBuffer);
-  if (EFI_ERROR(Status) || (PartitionHandleCount == 0)) {
-    return Status;
-  }
-
-  // Check if one of the handles matches the Hard Disk Description
-  for (Index = 0; Index < PartitionHandleCount; Index++) {
-    Status = gBS->HandleProtocol (PartitionBuffer[Index], &gEfiDevicePathProtocolGuid, (VOID **) &PartitionDevicePath);
-    if (!EFI_ERROR(Status)) {
-      TmpDevicePath = PartitionDevicePath;
-      while (!IsDevicePathEnd (TmpDevicePath)) {
-        // Check if the Device Path node is a HD Removable device Path node
-        if (BdsIsRemovableHd (TmpDevicePath)) {
-          HardDriveDevicePath1 = (HARDDRIVE_DEVICE_PATH*)RemovableDevicePath;
-          HardDriveDevicePath2 = (HARDDRIVE_DEVICE_PATH*)TmpDevicePath;
-          if ((HardDriveDevicePath1->SignatureType == HardDriveDevicePath2->SignatureType) &&
-              (CompareGuid ((EFI_GUID *)HardDriveDevicePath1->Signature,(EFI_GUID *)HardDriveDevicePath2->Signature) == TRUE) &&
-              (HardDriveDevicePath1->PartitionNumber == HardDriveDevicePath2->PartitionNumber))
-          {
-            *DeviceHandle = PartitionBuffer[Index];
-            // Add the additional original Device Path Nodes (eg: FilePath Device Path Node) to the new Device Path
-            *NewDevicePath = AppendDevicePath (PartitionDevicePath, NextDevicePathNode(RemovableDevicePath));
-            return EFI_SUCCESS;
-          }
-        }
-        TmpDevicePath = NextDevicePathNode (TmpDevicePath);
-      }
-
-    }
-  }
-
-  return EFI_NOT_FOUND;
-}
-
-/*BOOLEAN
-BdsIsRemovableCdrom (
-  IN  EFI_DEVICE_PATH*  DevicePath
-  )
-{
-  return IS_DEVICE_PATH_NODE(DevicePath, MEDIA_DEVICE_PATH, MEDIA_CDROM_DP);
-}
-
-EFI_STATUS
-BdsGetDeviceCdrom (
-  IN  EFI_DEVICE_PATH*  RemovableDevicePath,
-  OUT EFI_HANDLE*       DeviceHandle,
-  OUT EFI_DEVICE_PATH** DevicePath
-  )
-{
-  ASSERT(0);
-  return EFI_UNSUPPORTED;
-}*/
-
-typedef BOOLEAN
-(*BDS_IS_REMOVABLE) (
-  IN  EFI_DEVICE_PATH*  DevicePath
-  );
-
-typedef EFI_STATUS
-(*BDS_GET_DEVICE) (
-  IN  EFI_DEVICE_PATH*  RemovableDevicePath,
-  OUT EFI_HANDLE*       DeviceHandle,
-  OUT EFI_DEVICE_PATH** DevicePath
-  );
-
-typedef struct {
-  BDS_IS_REMOVABLE    IsRemovable;
-  BDS_GET_DEVICE      GetDevice;
-} BDS_REMOVABLE_DEVICE_SUPPORT;
-
-BDS_REMOVABLE_DEVICE_SUPPORT  RemovableDeviceSupport[] = {
-  { BdsIsRemovableUsb, BdsGetDeviceUsb },
-  { BdsIsRemovableHd, BdsGetDeviceHd },
-  //{ BdsIsRemovableCdrom, BdsGetDeviceCdrom }
-};
-
-STATIC
-BOOLEAN
-IsRemovableDevice (
-  IN  EFI_DEVICE_PATH*  DevicePath
-  )
-{
-  UINTN             Index;
-  EFI_DEVICE_PATH*  TmpDevicePath;
-
-  TmpDevicePath = DevicePath;
-  while (!IsDevicePathEnd (TmpDevicePath)) {
-    for (Index = 0; Index < sizeof(RemovableDeviceSupport) / sizeof(BDS_REMOVABLE_DEVICE_SUPPORT); Index++) {
-      if (RemovableDeviceSupport[Index].IsRemovable(TmpDevicePath)) {
-        return TRUE;
-      }
-    }
-    TmpDevicePath = NextDevicePathNode (TmpDevicePath);
-  }
-
-  return FALSE;
-}
-
-STATIC
-EFI_STATUS
-TryRemovableDevice (
-  IN  EFI_DEVICE_PATH*  DevicePath,
-  OUT EFI_HANDLE*       DeviceHandle,
-  OUT EFI_DEVICE_PATH** NewDevicePath
-  )
-{
-  EFI_STATUS        Status;
-  UINTN             Index;
-  EFI_DEVICE_PATH*  TmpDevicePath;
-  BDS_REMOVABLE_DEVICE_SUPPORT* RemovableDevice;
-  EFI_DEVICE_PATH* RemovableDevicePath;
-  BOOLEAN         RemovableFound;
-
-  RemovableDevice     = NULL;
-  RemovableDevicePath = NULL;
-  RemovableFound      = FALSE;
-  TmpDevicePath       = DevicePath;
-
-  while (!IsDevicePathEnd (TmpDevicePath) && !RemovableFound) {
-    for (Index = 0; Index < sizeof(RemovableDeviceSupport) / sizeof(BDS_REMOVABLE_DEVICE_SUPPORT); Index++) {
-      RemovableDevice = &RemovableDeviceSupport[Index];
-      if (RemovableDevice->IsRemovable(TmpDevicePath)) {
-        RemovableDevicePath = TmpDevicePath;
-        RemovableFound = TRUE;
-        break;
-      }
-    }
-    TmpDevicePath = NextDevicePathNode (TmpDevicePath);
-  }
-
-  if (!RemovableFound) {
-    return EFI_NOT_FOUND;
-  }
-
-  // Search into the current started drivers
-  Status = RemovableDevice->GetDevice (RemovableDevicePath, DeviceHandle, NewDevicePath);
-  if (Status == EFI_NOT_FOUND) {
-    // Connect all the drivers
-    BdsConnectAllDrivers ();
-
-    // Search again into all the drivers
-    Status = RemovableDevice->GetDevice (RemovableDevicePath, DeviceHandle, NewDevicePath);
-  }
-
-  return Status;
-}
-
-/**
-  Connect a Device Path and return the handle of the driver that support this DevicePath
-
-  @param  DevicePath            Device Path of the File to connect
-  @param  Handle                Handle of the driver that support this DevicePath
-  @param  RemainingDevicePath   Remaining DevicePath nodes that do not match the driver DevicePath
-
-  @retval EFI_SUCCESS           A driver that matches the Device Path has been found
-  @retval EFI_NOT_FOUND         No handles match the search.
-  @retval EFI_INVALID_PARAMETER DevicePath or Handle is NULL
-
-**/
-EFI_STATUS
-BdsConnectDevicePath (
-  IN  EFI_DEVICE_PATH_PROTOCOL* DevicePath,
-  OUT EFI_HANDLE                *Handle,
-  OUT EFI_DEVICE_PATH_PROTOCOL  **RemainingDevicePath
-  )
-{
-  EFI_DEVICE_PATH*            Remaining;
-  EFI_DEVICE_PATH*            NewDevicePath;
-  EFI_STATUS                  Status;
-
-  if ((DevicePath == NULL) || (Handle == NULL)) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  do {
-    Remaining = DevicePath;
-    // The LocateDevicePath() function locates all devices on DevicePath that support Protocol and returns
-    // the handle to the device that is closest to DevicePath. On output, the device path pointer is modified
-    // to point to the remaining part of the device path
-    Status = gBS->LocateDevicePath (&gEfiDevicePathProtocolGuid, &Remaining, Handle);
-    if (!EFI_ERROR (Status)) {
-      // Recursive = FALSE: We do not want to start all the device tree
-      Status = gBS->ConnectController (*Handle, NULL, Remaining, FALSE);
-    }
-
-    /*// We need to check if RemainingDevicePath does not point on the last node. Otherwise, calling
-    // NextDevicePathNode() will return an undetermined Device Path Node
-    if (!IsDevicePathEnd (RemainingDevicePath)) {
-      RemainingDevicePath = NextDevicePathNode (RemainingDevicePath);
-    }*/
-  } while (!EFI_ERROR (Status) && !IsDevicePathEnd (Remaining));
-
-  if (!EFI_ERROR (Status)) {
-    // Now, we have got the whole Device Path connected, call again ConnectController to ensure all the supported Driver
-    // Binding Protocol are connected (such as DiskIo and SimpleFileSystem)
-    Remaining = DevicePath;
-    Status = gBS->LocateDevicePath (&gEfiDevicePathProtocolGuid,&Remaining,Handle);
-    if (!EFI_ERROR (Status)) {
-      Status = gBS->ConnectController (*Handle, NULL, Remaining, FALSE);
-      if (EFI_ERROR (Status)) {
-        // If the last node is a Memory Map Device Path just return EFI_SUCCESS.
-        if ((Remaining->Type == HARDWARE_DEVICE_PATH) && (Remaining->SubType == HW_MEMMAP_DP)) {
-            Status = EFI_SUCCESS;
-        }
-      }
-    }
-  } else if (!IsDevicePathEnd (Remaining) && !IsRemovableDevice (Remaining)) {
-
-    /*// If the remaining Device Path is a FilePath or MemoryMap then we consider the Device Path has been loaded correctly
-    if ((Remaining->Type == MEDIA_DEVICE_PATH) && (Remaining->SubType == MEDIA_FILEPATH_DP)) {
-      Status = EFI_SUCCESS;
-    } else if ((Remaining->Type == HARDWARE_DEVICE_PATH) && (Remaining->SubType == HW_MEMMAP_DP)) {
-      Status = EFI_SUCCESS;
-    }*/
-
-    //TODO: Should we just return success and leave the caller decide if it is the expected RemainingPath
-    Status = EFI_SUCCESS;
-  } else {
-    Status = TryRemovableDevice (DevicePath, Handle, &NewDevicePath);
-    if (!EFI_ERROR (Status)) {
-      return BdsConnectDevicePath (NewDevicePath, Handle, RemainingDevicePath);
-    }
-  }
-
-  if (RemainingDevicePath) {
-    *RemainingDevicePath = Remaining;
-  }
-
-  return Status;
-}
-
-BOOLEAN
-BdsFileSystemSupport (
-  IN EFI_DEVICE_PATH *DevicePath,
-  IN EFI_HANDLE Handle,
-  IN EFI_DEVICE_PATH *RemainingDevicePath
-  )
-{
-  EFI_STATUS  Status;
-  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL     *FsProtocol;
-
-  Status = gBS->HandleProtocol (Handle,&gEfiSimpleFileSystemProtocolGuid, (VOID **)&FsProtocol);
-
-  return (!EFI_ERROR(Status) && IS_DEVICE_PATH_NODE(RemainingDevicePath,MEDIA_DEVICE_PATH,MEDIA_FILEPATH_DP));
-}
-
-EFI_STATUS
-BdsFileSystemLoadImage (
-  IN     EFI_DEVICE_PATH *DevicePath,
-  IN     EFI_HANDLE Handle,
-  IN     EFI_DEVICE_PATH *RemainingDevicePath,
-  IN     EFI_ALLOCATE_TYPE     Type,
-  IN OUT EFI_PHYSICAL_ADDRESS* Image,
-  OUT    UINTN                 *ImageSize
-  )
-{
-  FILEPATH_DEVICE_PATH*             FilePathDevicePath;
-  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL     *FsProtocol;
-  EFI_FILE_PROTOCOL                   *Fs;
-  EFI_STATUS Status;
-  EFI_FILE_INFO       *FileInfo;
-  EFI_FILE_PROTOCOL   *File;
-  UINTN               Size;
-
-  ASSERT (IS_DEVICE_PATH_NODE(RemainingDevicePath,MEDIA_DEVICE_PATH,MEDIA_FILEPATH_DP));
-
-  FilePathDevicePath = (FILEPATH_DEVICE_PATH*)RemainingDevicePath;
-
-  Status = gBS->HandleProtocol(Handle,&gEfiSimpleFileSystemProtocolGuid, (VOID **)&FsProtocol);
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  // Try to Open the volume and get root directory
-  Status = FsProtocol->OpenVolume (FsProtocol, &Fs);
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  File = NULL;
-  Status = Fs->Open(Fs, &File, FilePathDevicePath->PathName, EFI_FILE_MODE_READ, 0);
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  Size = 0;
-  File->GetInfo(File, &gEfiFileInfoGuid, &Size, NULL);
-  FileInfo = AllocatePool (Size);
-  Status = File->GetInfo(File, &gEfiFileInfoGuid, &Size, FileInfo);
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  // Get the file size
-  Size = FileInfo->FileSize;
-  if (ImageSize) {
-    *ImageSize = Size;
-  }
-  FreePool(FileInfo);
-
-  Status = gBS->AllocatePages (Type, EfiBootServicesCode, EFI_SIZE_TO_PAGES(Size), Image);
-  // Try to allocate in any pages if failed to allocate memory at the defined location
-  if ((Status == EFI_OUT_OF_RESOURCES) && (Type != AllocateAnyPages)) {
-    Status = gBS->AllocatePages (AllocateAnyPages, EfiBootServicesCode, EFI_SIZE_TO_PAGES(Size), Image);
-  }
-  if (!EFI_ERROR(Status)) {
-    Status = File->Read (File, &Size, (VOID*)(UINTN)(*Image));
-  }
-
-  return Status;
-}
-
-BOOLEAN
-BdsMemoryMapSupport (
-  IN EFI_DEVICE_PATH *DevicePath,
-  IN EFI_HANDLE Handle,
-  IN EFI_DEVICE_PATH *RemainingDevicePath
-  )
-{
-  return IS_DEVICE_PATH_NODE(DevicePath,HARDWARE_DEVICE_PATH,HW_MEMMAP_DP) ||
-         IS_DEVICE_PATH_NODE(RemainingDevicePath,HARDWARE_DEVICE_PATH,HW_MEMMAP_DP);
-}
-
-EFI_STATUS
-BdsMemoryMapLoadImage (
-  IN     EFI_DEVICE_PATH *DevicePath,
-  IN     EFI_HANDLE Handle,
-  IN     EFI_DEVICE_PATH *RemainingDevicePath,
-  IN     EFI_ALLOCATE_TYPE     Type,
-  IN OUT EFI_PHYSICAL_ADDRESS* Image,
-  OUT    UINTN                 *ImageSize
-  )
-{
-  EFI_STATUS            Status;
-  MEMMAP_DEVICE_PATH*   MemMapPathDevicePath;
-  UINTN                 Size;
-
-  if (IS_DEVICE_PATH_NODE(RemainingDevicePath,HARDWARE_DEVICE_PATH,HW_MEMMAP_DP)) {
-    MemMapPathDevicePath = (MEMMAP_DEVICE_PATH*)RemainingDevicePath;
-  } else {
-    ASSERT (IS_DEVICE_PATH_NODE(DevicePath,HARDWARE_DEVICE_PATH,HW_MEMMAP_DP));
-    MemMapPathDevicePath = (MEMMAP_DEVICE_PATH*)DevicePath;
-  }
-
-  Size = MemMapPathDevicePath->EndingAddress - MemMapPathDevicePath->StartingAddress;
-  if (Size == 0) {
-      return EFI_INVALID_PARAMETER;
-  }
-
-  Status = gBS->AllocatePages (Type, EfiBootServicesCode, EFI_SIZE_TO_PAGES(Size), Image);
-  // Try to allocate in any pages if failed to allocate memory at the defined location
-  if ((Status == EFI_OUT_OF_RESOURCES) && (Type != AllocateAnyPages)) {
-    Status = gBS->AllocatePages (AllocateAnyPages, EfiBootServicesCode, EFI_SIZE_TO_PAGES(Size), Image);
-  }
-  if (!EFI_ERROR(Status)) {
-    CopyMem ((VOID*)(UINTN)(*Image), (CONST VOID*)(UINTN)MemMapPathDevicePath->StartingAddress, Size);
-
-    if (ImageSize != NULL) {
-        *ImageSize = Size;
-    }
-  }
-
-  return Status;
-}
-
-BOOLEAN
-BdsFirmwareVolumeSupport (
-  IN EFI_DEVICE_PATH *DevicePath,
-  IN EFI_HANDLE Handle,
-  IN EFI_DEVICE_PATH *RemainingDevicePath
-  )
-{
-  return IS_DEVICE_PATH_NODE(RemainingDevicePath, MEDIA_DEVICE_PATH, MEDIA_PIWG_FW_FILE_DP);
-}
-
-EFI_STATUS
-BdsFirmwareVolumeLoadImage (
-  IN     EFI_DEVICE_PATH *DevicePath,
-  IN     EFI_HANDLE Handle,
-  IN     EFI_DEVICE_PATH *RemainingDevicePath,
-  IN     EFI_ALLOCATE_TYPE     Type,
-  IN OUT EFI_PHYSICAL_ADDRESS* Image,
-  OUT    UINTN                 *ImageSize
-  )
-{
-  EFI_STATUS            Status;
-  EFI_FIRMWARE_VOLUME2_PROTOCOL     *FwVol;
-  EFI_GUID                          *FvNameGuid;
-  EFI_SECTION_TYPE                  SectionType;
-  EFI_FV_FILETYPE                   FvType;
-  EFI_FV_FILE_ATTRIBUTES            Attrib;
-  UINT32                            AuthenticationStatus;
-  VOID* ImageBuffer;
-
-  ASSERT (IS_DEVICE_PATH_NODE(RemainingDevicePath, MEDIA_DEVICE_PATH, MEDIA_PIWG_FW_FILE_DP));
-
-  Status = gBS->HandleProtocol(Handle,&gEfiFirmwareVolume2ProtocolGuid, (VOID **)&FwVol);
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  FvNameGuid = EfiGetNameGuidFromFwVolDevicePathNode ((CONST MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *)RemainingDevicePath);
-  if (FvNameGuid == NULL) {
-    Status = EFI_INVALID_PARAMETER;
-  }
-
-  SectionType = EFI_SECTION_PE32;
-  AuthenticationStatus = 0;
-  //Note: ReadSection at the opposite of ReadFile does not allow to pass ImageBuffer == NULL to get the size of the file.
-  ImageBuffer = NULL;
-  Status = FwVol->ReadSection (
-                    FwVol,
-                    FvNameGuid,
-                    SectionType,
-                    0,
-                    &ImageBuffer,
-                    ImageSize,
-                    &AuthenticationStatus
-                    );
-  if (!EFI_ERROR (Status)) {
-#if 0
-    // In case the buffer has some address requirements, we must copy the buffer to a buffer following the requirements
-    if (Type != AllocateAnyPages) {
-      Status = gBS->AllocatePages (Type, EfiBootServicesCode, EFI_SIZE_TO_PAGES(*ImageSize),Image);
-      if (!EFI_ERROR(Status)) {
-        CopyMem ((VOID*)(UINTN)(*Image), ImageBuffer, *ImageSize);
-        FreePool (ImageBuffer);
-      }
-    }
-#else
-    // We must copy the buffer into a page allocations. Otherwise, the caller could call gBS->FreePages() on the pool allocation
-    Status = gBS->AllocatePages (Type, EfiBootServicesCode, EFI_SIZE_TO_PAGES(*ImageSize), Image);
-    // Try to allocate in any pages if failed to allocate memory at the defined location
-    if ((Status == EFI_OUT_OF_RESOURCES) && (Type != AllocateAnyPages)) {
-      Status = gBS->AllocatePages (AllocateAnyPages, EfiBootServicesCode, EFI_SIZE_TO_PAGES(*ImageSize), Image);
-    }
-    if (!EFI_ERROR(Status)) {
-      CopyMem ((VOID*)(UINTN)(*Image), ImageBuffer, *ImageSize);
-      FreePool (ImageBuffer);
-    }
-#endif
-  } else {
-    // Try a raw file, since a PE32 SECTION does not exist
-    Status = FwVol->ReadFile (
-                        FwVol,
-                        FvNameGuid,
-                        NULL,
-                        ImageSize,
-                        &FvType,
-                        &Attrib,
-                        &AuthenticationStatus
-                        );
-    if (!EFI_ERROR(Status)) {
-      Status = gBS->AllocatePages (Type, EfiBootServicesCode, EFI_SIZE_TO_PAGES(*ImageSize), Image);
-      // Try to allocate in any pages if failed to allocate memory at the defined location
-      if ((Status == EFI_OUT_OF_RESOURCES) && (Type != AllocateAnyPages)) {
-        Status = gBS->AllocatePages (AllocateAnyPages, EfiBootServicesCode, EFI_SIZE_TO_PAGES(*ImageSize), Image);
-      }
-      if (!EFI_ERROR(Status)) {
-        Status = FwVol->ReadFile (
-                                FwVol,
-                                FvNameGuid,
-                                (VOID*)(UINTN)(*Image),
-                                ImageSize,
-                                &FvType,
-                                &Attrib,
-                                &AuthenticationStatus
-                                );
-      }
-    }
-  }
-  return Status;
-}
-
-BOOLEAN
-BdsPxeSupport (
-  IN EFI_DEVICE_PATH*           DevicePath,
-  IN EFI_HANDLE                 Handle,
-  IN EFI_DEVICE_PATH*           RemainingDevicePath
-  )
-{
-  EFI_STATUS                  Status;
-  EFI_PXE_BASE_CODE_PROTOCOL* PxeBcProtocol;
-
-  if (!IsDevicePathEnd(RemainingDevicePath)) {
-    return FALSE;
-  }
-
-  Status = gBS->HandleProtocol (Handle, &gEfiPxeBaseCodeProtocolGuid, (VOID **)&PxeBcProtocol);
-  if (EFI_ERROR (Status)) {
-    return FALSE;
-  } else {
-    return TRUE;
-  }
-}
-
-EFI_STATUS
-BdsPxeLoadImage (
-  IN     EFI_DEVICE_PATH*       DevicePath,
-  IN     EFI_HANDLE             Handle,
-  IN     EFI_DEVICE_PATH*       RemainingDevicePath,
-  IN     EFI_ALLOCATE_TYPE      Type,
-  IN OUT EFI_PHYSICAL_ADDRESS   *Image,
-  OUT    UINTN                  *ImageSize
-  )
-{
-  EFI_STATUS              Status;
-  EFI_LOAD_FILE_PROTOCOL  *LoadFileProtocol;
-  UINTN                   BufferSize;
-
-  // Get Load File Protocol attached to the PXE protocol
-  Status = gBS->HandleProtocol (Handle, &gEfiLoadFileProtocolGuid, (VOID **)&LoadFileProtocol);
-  if (EFI_ERROR (Status)) {
-    return Status;
-  }
-
-  Status = LoadFileProtocol->LoadFile (LoadFileProtocol, DevicePath, TRUE, &BufferSize, NULL);
-  if (Status == EFI_BUFFER_TOO_SMALL) {
-    Status = gBS->AllocatePages (Type, EfiBootServicesCode, EFI_SIZE_TO_PAGES(BufferSize), Image);
-    if (EFI_ERROR(Status)) {
-      return Status;
-    }
-
-    Status = LoadFileProtocol->LoadFile (LoadFileProtocol, DevicePath, TRUE, &BufferSize, (VOID*)(UINTN)(*Image));
-    if (!EFI_ERROR(Status) && (ImageSize != NULL)) {
-      *ImageSize = BufferSize;
-    }
-  }
-
-  return Status;
-}
-
-BOOLEAN
-BdsTftpSupport (
-  IN EFI_DEVICE_PATH*           DevicePath,
-  IN EFI_HANDLE                 Handle,
-  IN EFI_DEVICE_PATH*           RemainingDevicePath
-  )
-{
-  EFI_STATUS  Status;
-  EFI_DEVICE_PATH  *NextDevicePath;
-  EFI_PXE_BASE_CODE_PROTOCOL  *PxeBcProtocol;
-
-  // Validate the Remaining Device Path
-  if (IsDevicePathEnd(RemainingDevicePath)) {
-    return FALSE;
-  }
-  if (!IS_DEVICE_PATH_NODE(RemainingDevicePath,MESSAGING_DEVICE_PATH,MSG_IPv4_DP) &&
-      !IS_DEVICE_PATH_NODE(RemainingDevicePath,MESSAGING_DEVICE_PATH,MSG_IPv6_DP)) {
-    return FALSE;
-  }
-  NextDevicePath = NextDevicePathNode (RemainingDevicePath);
-  if (IsDevicePathEnd(NextDevicePath)) {
-    return FALSE;
-  }
-  if (!IS_DEVICE_PATH_NODE(NextDevicePath,MEDIA_DEVICE_PATH,MEDIA_FILEPATH_DP)) {
-    return FALSE;
-  }
-
-  Status = gBS->HandleProtocol (Handle, &gEfiPxeBaseCodeProtocolGuid, (VOID **)&PxeBcProtocol);
-  if (EFI_ERROR (Status)) {
-    return FALSE;
-  } else {
-    return TRUE;
-  }
-}
-
-EFI_STATUS
-BdsTftpLoadImage (
-  IN     EFI_DEVICE_PATH*       DevicePath,
-  IN     EFI_HANDLE             Handle,
-  IN     EFI_DEVICE_PATH*       RemainingDevicePath,
-  IN     EFI_ALLOCATE_TYPE      Type,
-  IN OUT EFI_PHYSICAL_ADDRESS   *Image,
-  OUT    UINTN                  *ImageSize
-  )
-{
-  EFI_STATUS                  Status;
-  EFI_PXE_BASE_CODE_PROTOCOL  *Pxe;
-  UINT64                      TftpBufferSize;
-  VOID*                       TftpBuffer;
-  EFI_IP_ADDRESS              ServerIp;
-  IPv4_DEVICE_PATH*           IPv4DevicePathNode;
-  FILEPATH_DEVICE_PATH*       FilePathDevicePath;
-  EFI_IP_ADDRESS              LocalIp;
-
-  ASSERT(IS_DEVICE_PATH_NODE(RemainingDevicePath,MESSAGING_DEVICE_PATH,MSG_IPv4_DP));
-
-  IPv4DevicePathNode = (IPv4_DEVICE_PATH*)RemainingDevicePath;
-  FilePathDevicePath = (FILEPATH_DEVICE_PATH*)(IPv4DevicePathNode + 1);
-
-  Status = gBS->LocateProtocol (&gEfiPxeBaseCodeProtocolGuid, NULL, (VOID **)&Pxe);
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  Status = Pxe->Start (Pxe, FALSE);
-  if (EFI_ERROR(Status) && (Status != EFI_ALREADY_STARTED)) {
-    return Status;
-  }
-
-  if (!IPv4DevicePathNode->StaticIpAddress) {
-    Status = Pxe->Dhcp(Pxe, TRUE);
-  } else {
-    CopyMem (&LocalIp.v4, &IPv4DevicePathNode->LocalIpAddress, sizeof (EFI_IPv4_ADDRESS));
-    Status = Pxe->SetStationIp (Pxe, &LocalIp, NULL);
-  }
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  CopyMem (&ServerIp.v4, &IPv4DevicePathNode->RemoteIpAddress, sizeof (EFI_IPv4_ADDRESS));
-
-  Status = Pxe->Mtftp (
-                  Pxe,
-                  EFI_PXE_BASE_CODE_TFTP_GET_FILE_SIZE,
-                  NULL,
-                  FALSE,
-                  &TftpBufferSize,
-                  NULL,
-                  &ServerIp,
-                  (UINT8 *)FilePathDevicePath->PathName,
-                  NULL,
-                  TRUE
-                  );
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  // Allocate a buffer to hold the whole file.
-  TftpBuffer = AllocatePool(TftpBufferSize);
-  if (TftpBuffer == NULL) {
-    return EFI_OUT_OF_RESOURCES;
-  }
-
-  Status = Pxe->Mtftp (
-                  Pxe,
-                  EFI_PXE_BASE_CODE_TFTP_READ_FILE,
-                  TftpBuffer,
-                  FALSE,
-                  &TftpBufferSize,
-                  NULL,
-                  &ServerIp,
-                  (UINT8 *)FilePathDevicePath->PathName,
-                  NULL,
-                  FALSE
-                  );
-  if (EFI_ERROR(Status)) {
-    FreePool(TftpBuffer);
-  } else if (ImageSize != NULL) {
-    *ImageSize = (UINTN)TftpBufferSize;
-  }
-
-  return Status;
-}
-
-BDS_FILE_LOADER FileLoaders[] = {
-    { BdsFileSystemSupport, BdsFileSystemLoadImage },
-    { BdsFirmwareVolumeSupport, BdsFirmwareVolumeLoadImage },
-    //{ BdsLoadFileSupport, BdsLoadFileLoadImage },
-    { BdsMemoryMapSupport, BdsMemoryMapLoadImage },
-    { BdsPxeSupport, BdsPxeLoadImage },
-    { BdsTftpSupport, BdsTftpLoadImage },
-    { NULL, NULL }
-};
-
-EFI_STATUS
-BdsLoadImage (
-  IN     EFI_DEVICE_PATH       *DevicePath,
-  IN     EFI_ALLOCATE_TYPE     Type,
-  IN OUT EFI_PHYSICAL_ADDRESS* Image,
-  OUT    UINTN                 *FileSize
-  )
-{
-  EFI_STATUS      Status;
-  EFI_HANDLE      Handle;
-  EFI_DEVICE_PATH *RemainingDevicePath;
-  BDS_FILE_LOADER*  FileLoader;
-
-  Status = BdsConnectDevicePath (DevicePath, &Handle, &RemainingDevicePath);
-  if (EFI_ERROR (Status)) {
-    return Status;
-  }
-
-  FileLoader = FileLoaders;
-  while (FileLoader->Support != NULL) {
-    if (FileLoader->Support (DevicePath, Handle, RemainingDevicePath)) {
-      return FileLoader->LoadImage (DevicePath, Handle, RemainingDevicePath, Type, Image, FileSize);
-    }
-    FileLoader++;
-  }
-
-  return EFI_UNSUPPORTED;
-}
-
-/**
-  Start an EFI Application from a Device Path
-
-  @param  ParentImageHandle     Handle of the calling image
-  @param  DevicePath            Location of the EFI Application
-
-  @retval EFI_SUCCESS           All drivers have been connected
-  @retval EFI_NOT_FOUND         The Linux kernel Device Path has not been found
-  @retval EFI_OUT_OF_RESOURCES  There is not enough resource memory to store the matching results.
-
-**/
-EFI_STATUS
-BdsStartEfiApplication (
-  IN EFI_HANDLE                  ParentImageHandle,
-  IN EFI_DEVICE_PATH_PROTOCOL    *DevicePath,
-  IN UINTN                       LoadOptionsSize,
-  IN VOID*                       LoadOptions
-  )
-{
-  EFI_STATUS                   Status;
-  EFI_HANDLE                   ImageHandle;
-  EFI_PHYSICAL_ADDRESS         BinaryBuffer;
-  UINTN                        BinarySize;
-  EFI_LOADED_IMAGE_PROTOCOL*   LoadedImage;
-
-  // Find the nearest supported file loader
-  Status = BdsLoadImage (DevicePath, AllocateAnyPages, &BinaryBuffer, &BinarySize);
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  // Load the image from the Buffer with Boot Services function
-  Status = gBS->LoadImage (TRUE, ParentImageHandle, DevicePath, (VOID*)(UINTN)BinaryBuffer, BinarySize, &ImageHandle);
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  // Passed LoadOptions to the EFI Application
-  if (LoadOptionsSize != 0) {
-    Status = gBS->HandleProtocol (ImageHandle, &gEfiLoadedImageProtocolGuid, (VOID **) &LoadedImage);
-    if (EFI_ERROR(Status)) {
-      return Status;
-    }
-
-    LoadedImage->LoadOptionsSize  = LoadOptionsSize;
-    LoadedImage->LoadOptions      = LoadOptions;
-  }
-
-  // Before calling the image, enable the Watchdog Timer for  the 5 Minute period
-  gBS->SetWatchdogTimer (5 * 60, 0x0000, 0x00, NULL);
-  // Start the image
-  Status = gBS->StartImage (ImageHandle, NULL, NULL);
-  // Clear the Watchdog Timer after the image returns
-  gBS->SetWatchdogTimer (0x0000, 0x0000, 0x0000, NULL);
-
-  return Status;
-}
+/** @file

+*

+*  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+#include "BdsInternal.h"

+

+#include <Protocol/UsbIo.h>

+#include <Protocol/DiskIo.h>

+#include <Protocol/LoadedImage.h>

+#include <Protocol/SimpleNetwork.h>

+

+#define IS_DEVICE_PATH_NODE(node,type,subtype) (((node)->Type == (type)) && ((node)->SubType == (subtype)))

+

+// Extract the FilePath from the Device Path

+CHAR16*

+BdsExtractFilePathFromDevicePath (

+  IN  CONST CHAR16    *StrDevicePath,

+  IN  UINTN           NumberDevicePathNode

+  )

+{

+  UINTN       Node;

+  CHAR16      *Str;

+

+  Str = (CHAR16*)StrDevicePath;

+  Node = 0;

+  while ((Str != NULL) && (*Str != L'\0') && (Node < NumberDevicePathNode)) {

+    if ((*Str == L'/') || (*Str == L'\\')) {

+        Node++;

+    }

+    Str++;

+  }

+

+  if (*Str == L'\0') {

+    return NULL;

+  } else {

+    return Str;

+  }

+}

+

+BOOLEAN

+BdsIsRemovableUsb (

+  IN  EFI_DEVICE_PATH*  DevicePath

+  )

+{

+  return ((DevicePathType (DevicePath) == MESSAGING_DEVICE_PATH) &&

+          ((DevicePathSubType (DevicePath) == MSG_USB_CLASS_DP) ||

+           (DevicePathSubType (DevicePath) == MSG_USB_WWID_DP)));

+}

+

+EFI_STATUS

+BdsGetDeviceUsb (

+  IN  EFI_DEVICE_PATH*  RemovableDevicePath,

+  OUT EFI_HANDLE*       DeviceHandle,

+  OUT EFI_DEVICE_PATH** NewDevicePath

+  )

+{

+  EFI_STATUS                    Status;

+  UINTN                         Index;

+  UINTN                         UsbIoHandleCount;

+  EFI_HANDLE                    *UsbIoBuffer;

+  EFI_DEVICE_PATH*              UsbIoDevicePath;

+  EFI_DEVICE_PATH*              TmpDevicePath;

+  USB_WWID_DEVICE_PATH*         WwidDevicePath1;

+  USB_WWID_DEVICE_PATH*         WwidDevicePath2;

+  USB_CLASS_DEVICE_PATH*        UsbClassDevicePath1;

+  USB_CLASS_DEVICE_PATH*        UsbClassDevicePath2;

+

+  // Get all the UsbIo handles

+  UsbIoHandleCount = 0;

+  Status = gBS->LocateHandleBuffer (ByProtocol, &gEfiUsbIoProtocolGuid, NULL, &UsbIoHandleCount, &UsbIoBuffer);

+  if (EFI_ERROR (Status) || (UsbIoHandleCount == 0)) {

+    return Status;

+  }

+

+  // Check if one of the handles matches the USB description

+  for (Index = 0; Index < UsbIoHandleCount; Index++) {

+    Status = gBS->HandleProtocol (UsbIoBuffer[Index], &gEfiDevicePathProtocolGuid, (VOID **) &UsbIoDevicePath);

+    if (!EFI_ERROR (Status)) {

+      TmpDevicePath = UsbIoDevicePath;

+      while (!IsDevicePathEnd (TmpDevicePath)) {

+        // Check if the Device Path node is a USB Removable device Path node

+        if (BdsIsRemovableUsb (TmpDevicePath)) {

+          if (TmpDevicePath->SubType == MSG_USB_WWID_DP) {

+            WwidDevicePath1 = (USB_WWID_DEVICE_PATH*)RemovableDevicePath;

+            WwidDevicePath2 = (USB_WWID_DEVICE_PATH*)TmpDevicePath;

+            if ((WwidDevicePath1->VendorId == WwidDevicePath2->VendorId) &&

+                (WwidDevicePath1->ProductId == WwidDevicePath2->ProductId) &&

+                (CompareMem (WwidDevicePath1+1, WwidDevicePath2+1, DevicePathNodeLength(WwidDevicePath1)-sizeof (USB_WWID_DEVICE_PATH)) == 0))

+            {

+              *DeviceHandle = UsbIoBuffer[Index];

+              // Add the additional original Device Path Nodes (eg: FilePath Device Path Node) to the new Device Path

+              *NewDevicePath = AppendDevicePath (UsbIoDevicePath, NextDevicePathNode (RemovableDevicePath));

+              return EFI_SUCCESS;

+            }

+          } else {

+            UsbClassDevicePath1 = (USB_CLASS_DEVICE_PATH*)RemovableDevicePath;

+            UsbClassDevicePath2 = (USB_CLASS_DEVICE_PATH*)TmpDevicePath;

+            if ((UsbClassDevicePath1->VendorId != 0xFFFF) && (UsbClassDevicePath1->VendorId == UsbClassDevicePath2->VendorId) &&

+                (UsbClassDevicePath1->ProductId != 0xFFFF) && (UsbClassDevicePath1->ProductId == UsbClassDevicePath2->ProductId) &&

+                (UsbClassDevicePath1->DeviceClass != 0xFF) && (UsbClassDevicePath1->DeviceClass == UsbClassDevicePath2->DeviceClass) &&

+                (UsbClassDevicePath1->DeviceSubClass != 0xFF) && (UsbClassDevicePath1->DeviceSubClass == UsbClassDevicePath2->DeviceSubClass) &&

+                (UsbClassDevicePath1->DeviceProtocol != 0xFF) && (UsbClassDevicePath1->DeviceProtocol == UsbClassDevicePath2->DeviceProtocol))

+            {

+              *DeviceHandle = UsbIoBuffer[Index];

+              // Add the additional original Device Path Nodes (eg: FilePath Device Path Node) to the new Device Path

+              *NewDevicePath = AppendDevicePath (UsbIoDevicePath, NextDevicePathNode (RemovableDevicePath));

+              return EFI_SUCCESS;

+            }

+          }

+        }

+        TmpDevicePath = NextDevicePathNode (TmpDevicePath);

+      }

+

+    }

+  }

+

+  return EFI_NOT_FOUND;

+}

+

+BOOLEAN

+BdsIsRemovableHd (

+  IN  EFI_DEVICE_PATH*  DevicePath

+  )

+{

+  return IS_DEVICE_PATH_NODE (DevicePath, MEDIA_DEVICE_PATH, MEDIA_HARDDRIVE_DP);

+}

+

+EFI_STATUS

+BdsGetDeviceHd (

+  IN  EFI_DEVICE_PATH*  RemovableDevicePath,

+  OUT EFI_HANDLE*       DeviceHandle,

+  OUT EFI_DEVICE_PATH** NewDevicePath

+  )

+{

+  EFI_STATUS                    Status;

+  UINTN                         Index;

+  UINTN                         PartitionHandleCount;

+  EFI_HANDLE                    *PartitionBuffer;

+  EFI_DEVICE_PATH*              PartitionDevicePath;

+  EFI_DEVICE_PATH*              TmpDevicePath;

+  HARDDRIVE_DEVICE_PATH*        HardDriveDevicePath1;

+  HARDDRIVE_DEVICE_PATH*        HardDriveDevicePath2;

+

+  // Get all the DiskIo handles

+  PartitionHandleCount = 0;

+  Status = gBS->LocateHandleBuffer (ByProtocol, &gEfiDiskIoProtocolGuid, NULL, &PartitionHandleCount, &PartitionBuffer);

+  if (EFI_ERROR (Status) || (PartitionHandleCount == 0)) {

+    return Status;

+  }

+

+  // Check if one of the handles matches the Hard Disk Description

+  for (Index = 0; Index < PartitionHandleCount; Index++) {

+    Status = gBS->HandleProtocol (PartitionBuffer[Index], &gEfiDevicePathProtocolGuid, (VOID **) &PartitionDevicePath);

+    if (!EFI_ERROR (Status)) {

+      TmpDevicePath = PartitionDevicePath;

+      while (!IsDevicePathEnd (TmpDevicePath)) {

+        // Check if the Device Path node is a HD Removable device Path node

+        if (BdsIsRemovableHd (TmpDevicePath)) {

+          HardDriveDevicePath1 = (HARDDRIVE_DEVICE_PATH*)RemovableDevicePath;

+          HardDriveDevicePath2 = (HARDDRIVE_DEVICE_PATH*)TmpDevicePath;

+          if ((HardDriveDevicePath1->SignatureType == HardDriveDevicePath2->SignatureType) &&

+              (CompareGuid ((EFI_GUID *)HardDriveDevicePath1->Signature, (EFI_GUID *)HardDriveDevicePath2->Signature) == TRUE) &&

+              (HardDriveDevicePath1->PartitionNumber == HardDriveDevicePath2->PartitionNumber))

+          {

+            *DeviceHandle = PartitionBuffer[Index];

+            // Add the additional original Device Path Nodes (eg: FilePath Device Path Node) to the new Device Path

+            *NewDevicePath = AppendDevicePath (PartitionDevicePath, NextDevicePathNode (RemovableDevicePath));

+            return EFI_SUCCESS;

+          }

+        }

+        TmpDevicePath = NextDevicePathNode (TmpDevicePath);

+      }

+

+    }

+  }

+

+  return EFI_NOT_FOUND;

+}

+

+/*BOOLEAN

+BdsIsRemovableCdrom (

+  IN  EFI_DEVICE_PATH*  DevicePath

+  )

+{

+  return IS_DEVICE_PATH_NODE (DevicePath, MEDIA_DEVICE_PATH, MEDIA_CDROM_DP);

+}

+

+EFI_STATUS

+BdsGetDeviceCdrom (

+  IN  EFI_DEVICE_PATH*  RemovableDevicePath,

+  OUT EFI_HANDLE*       DeviceHandle,

+  OUT EFI_DEVICE_PATH** DevicePath

+  )

+{

+  ASSERT(0);

+  return EFI_UNSUPPORTED;

+}*/

+

+typedef BOOLEAN

+(*BDS_IS_REMOVABLE) (

+  IN  EFI_DEVICE_PATH*  DevicePath

+  );

+

+typedef EFI_STATUS

+(*BDS_GET_DEVICE) (

+  IN  EFI_DEVICE_PATH*  RemovableDevicePath,

+  OUT EFI_HANDLE*       DeviceHandle,

+  OUT EFI_DEVICE_PATH** DevicePath

+  );

+

+typedef struct {

+  BDS_IS_REMOVABLE    IsRemovable;

+  BDS_GET_DEVICE      GetDevice;

+} BDS_REMOVABLE_DEVICE_SUPPORT;

+

+BDS_REMOVABLE_DEVICE_SUPPORT  RemovableDeviceSupport[] = {

+  { BdsIsRemovableUsb, BdsGetDeviceUsb },

+  { BdsIsRemovableHd, BdsGetDeviceHd },

+  //{ BdsIsRemovableCdrom, BdsGetDeviceCdrom }

+};

+

+STATIC

+BOOLEAN

+IsRemovableDevice (

+  IN  EFI_DEVICE_PATH*  DevicePath

+  )

+{

+  UINTN             Index;

+  EFI_DEVICE_PATH*  TmpDevicePath;

+

+  TmpDevicePath = DevicePath;

+  while (!IsDevicePathEnd (TmpDevicePath)) {

+    for (Index = 0; Index < sizeof (RemovableDeviceSupport) / sizeof (BDS_REMOVABLE_DEVICE_SUPPORT); Index++) {

+      if (RemovableDeviceSupport[Index].IsRemovable (TmpDevicePath)) {

+        return TRUE;

+      }

+    }

+    TmpDevicePath = NextDevicePathNode (TmpDevicePath);

+  }

+

+  return FALSE;

+}

+

+STATIC

+EFI_STATUS

+TryRemovableDevice (

+  IN  EFI_DEVICE_PATH*  DevicePath,

+  OUT EFI_HANDLE*       DeviceHandle,

+  OUT EFI_DEVICE_PATH** NewDevicePath

+  )

+{

+  EFI_STATUS        Status;

+  UINTN             Index;

+  EFI_DEVICE_PATH*  TmpDevicePath;

+  BDS_REMOVABLE_DEVICE_SUPPORT* RemovableDevice;

+  EFI_DEVICE_PATH* RemovableDevicePath;

+  BOOLEAN         RemovableFound;

+

+  RemovableDevice     = NULL;

+  RemovableDevicePath = NULL;

+  RemovableFound      = FALSE;

+  TmpDevicePath       = DevicePath;

+

+  while (!IsDevicePathEnd (TmpDevicePath) && !RemovableFound) {

+    for (Index = 0; Index < sizeof (RemovableDeviceSupport) / sizeof (BDS_REMOVABLE_DEVICE_SUPPORT); Index++) {

+      RemovableDevice = &RemovableDeviceSupport[Index];

+      if (RemovableDevice->IsRemovable (TmpDevicePath)) {

+        RemovableDevicePath = TmpDevicePath;

+        RemovableFound = TRUE;

+        break;

+      }

+    }

+    TmpDevicePath = NextDevicePathNode (TmpDevicePath);

+  }

+

+  if (!RemovableFound) {

+    return EFI_NOT_FOUND;

+  }

+

+  // Search into the current started drivers

+  Status = RemovableDevice->GetDevice (RemovableDevicePath, DeviceHandle, NewDevicePath);

+  if (Status == EFI_NOT_FOUND) {

+    // Connect all the drivers

+    BdsConnectAllDrivers ();

+

+    // Search again into all the drivers

+    Status = RemovableDevice->GetDevice (RemovableDevicePath, DeviceHandle, NewDevicePath);

+  }

+

+  return Status;

+}

+

+/**

+  Connect a Device Path and return the handle of the driver that support this DevicePath

+

+  @param  DevicePath            Device Path of the File to connect

+  @param  Handle                Handle of the driver that support this DevicePath

+  @param  RemainingDevicePath   Remaining DevicePath nodes that do not match the driver DevicePath

+

+  @retval EFI_SUCCESS           A driver that matches the Device Path has been found

+  @retval EFI_NOT_FOUND         No handles match the search.

+  @retval EFI_INVALID_PARAMETER DevicePath or Handle is NULL

+

+**/

+EFI_STATUS

+BdsConnectDevicePath (

+  IN  EFI_DEVICE_PATH_PROTOCOL* DevicePath,

+  OUT EFI_HANDLE                *Handle,

+  OUT EFI_DEVICE_PATH_PROTOCOL  **RemainingDevicePath

+  )

+{

+  EFI_DEVICE_PATH*            Remaining;

+  EFI_DEVICE_PATH*            NewDevicePath;

+  EFI_STATUS                  Status;

+

+  if ((DevicePath == NULL) || (Handle == NULL)) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  do {

+    Remaining = DevicePath;

+    // The LocateDevicePath() function locates all devices on DevicePath that support Protocol and returns

+    // the handle to the device that is closest to DevicePath. On output, the device path pointer is modified

+    // to point to the remaining part of the device path

+    Status = gBS->LocateDevicePath (&gEfiDevicePathProtocolGuid, &Remaining, Handle);

+    if (!EFI_ERROR (Status)) {

+      // Recursive = FALSE: We do not want to start all the device tree

+      Status = gBS->ConnectController (*Handle, NULL, Remaining, FALSE);

+    }

+

+    /*// We need to check if RemainingDevicePath does not point on the last node. Otherwise, calling

+    // NextDevicePathNode () will return an undetermined Device Path Node

+    if (!IsDevicePathEnd (RemainingDevicePath)) {

+      RemainingDevicePath = NextDevicePathNode (RemainingDevicePath);

+    }*/

+  } while (!EFI_ERROR (Status) && !IsDevicePathEnd (Remaining));

+

+  if (!EFI_ERROR (Status)) {

+    // Now, we have got the whole Device Path connected, call again ConnectController to ensure all the supported Driver

+    // Binding Protocol are connected (such as DiskIo and SimpleFileSystem)

+    Remaining = DevicePath;

+    Status = gBS->LocateDevicePath (&gEfiDevicePathProtocolGuid, &Remaining, Handle);

+    if (!EFI_ERROR (Status)) {

+      Status = gBS->ConnectController (*Handle, NULL, Remaining, FALSE);

+      if (EFI_ERROR (Status)) {

+        // If the last node is a Memory Map Device Path just return EFI_SUCCESS.

+        if ((Remaining->Type == HARDWARE_DEVICE_PATH) && (Remaining->SubType == HW_MEMMAP_DP)) {

+            Status = EFI_SUCCESS;

+        }

+      }

+    }

+  } else if (!IsDevicePathEnd (Remaining) && !IsRemovableDevice (Remaining)) {

+

+    /*// If the remaining Device Path is a FilePath or MemoryMap then we consider the Device Path has been loaded correctly

+    if ((Remaining->Type == MEDIA_DEVICE_PATH) && (Remaining->SubType == MEDIA_FILEPATH_DP)) {

+      Status = EFI_SUCCESS;

+    } else if ((Remaining->Type == HARDWARE_DEVICE_PATH) && (Remaining->SubType == HW_MEMMAP_DP)) {

+      Status = EFI_SUCCESS;

+    }*/

+

+    //TODO: Should we just return success and leave the caller decide if it is the expected RemainingPath

+    Status = EFI_SUCCESS;

+  } else {

+    Status = TryRemovableDevice (DevicePath, Handle, &NewDevicePath);

+    if (!EFI_ERROR (Status)) {

+      return BdsConnectDevicePath (NewDevicePath, Handle, RemainingDevicePath);

+    }

+  }

+

+  if (RemainingDevicePath) {

+    *RemainingDevicePath = Remaining;

+  }

+

+  return Status;

+}

+

+BOOLEAN

+BdsFileSystemSupport (

+  IN EFI_DEVICE_PATH *DevicePath,

+  IN EFI_HANDLE Handle,

+  IN EFI_DEVICE_PATH *RemainingDevicePath

+  )

+{

+  EFI_STATUS  Status;

+  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL     *FsProtocol;

+

+  Status = gBS->HandleProtocol (Handle, &gEfiSimpleFileSystemProtocolGuid, (VOID **)&FsProtocol);

+

+  return (!EFI_ERROR (Status) && IS_DEVICE_PATH_NODE (RemainingDevicePath, MEDIA_DEVICE_PATH, MEDIA_FILEPATH_DP));

+}

+

+EFI_STATUS

+BdsFileSystemLoadImage (

+  IN     EFI_DEVICE_PATH *DevicePath,

+  IN     EFI_HANDLE Handle,

+  IN     EFI_DEVICE_PATH *RemainingDevicePath,

+  IN     EFI_ALLOCATE_TYPE     Type,

+  IN OUT EFI_PHYSICAL_ADDRESS* Image,

+  OUT    UINTN                 *ImageSize

+  )

+{

+  FILEPATH_DEVICE_PATH*             FilePathDevicePath;

+  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL     *FsProtocol;

+  EFI_FILE_PROTOCOL                   *Fs;

+  EFI_STATUS Status;

+  EFI_FILE_INFO       *FileInfo;

+  EFI_FILE_PROTOCOL   *File;

+  UINTN               Size;

+

+  ASSERT (IS_DEVICE_PATH_NODE (RemainingDevicePath, MEDIA_DEVICE_PATH, MEDIA_FILEPATH_DP));

+

+  FilePathDevicePath = (FILEPATH_DEVICE_PATH*)RemainingDevicePath;

+

+  Status = gBS->HandleProtocol (Handle, &gEfiSimpleFileSystemProtocolGuid, (VOID **)&FsProtocol);

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+

+  // Try to Open the volume and get root directory

+  Status = FsProtocol->OpenVolume (FsProtocol, &Fs);

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+

+  File = NULL;

+  Status = Fs->Open (Fs, &File, FilePathDevicePath->PathName, EFI_FILE_MODE_READ, 0);

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+

+  Size = 0;

+  File->GetInfo (File, &gEfiFileInfoGuid, &Size, NULL);

+  FileInfo = AllocatePool (Size);

+  Status = File->GetInfo (File, &gEfiFileInfoGuid, &Size, FileInfo);

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+

+  // Get the file size

+  Size = FileInfo->FileSize;

+  if (ImageSize) {

+    *ImageSize = Size;

+  }

+  FreePool (FileInfo);

+

+  Status = gBS->AllocatePages (Type, EfiBootServicesCode, EFI_SIZE_TO_PAGES(Size), Image);

+  // Try to allocate in any pages if failed to allocate memory at the defined location

+  if ((Status == EFI_OUT_OF_RESOURCES) && (Type != AllocateAnyPages)) {

+    Status = gBS->AllocatePages (AllocateAnyPages, EfiBootServicesCode, EFI_SIZE_TO_PAGES(Size), Image);

+  }

+  if (!EFI_ERROR (Status)) {

+    Status = File->Read (File, &Size, (VOID*)(UINTN)(*Image));

+  }

+

+  return Status;

+}

+

+BOOLEAN

+BdsMemoryMapSupport (

+  IN EFI_DEVICE_PATH *DevicePath,

+  IN EFI_HANDLE Handle,

+  IN EFI_DEVICE_PATH *RemainingDevicePath

+  )

+{

+  return IS_DEVICE_PATH_NODE (DevicePath, HARDWARE_DEVICE_PATH, HW_MEMMAP_DP) ||

+         IS_DEVICE_PATH_NODE (RemainingDevicePath, HARDWARE_DEVICE_PATH, HW_MEMMAP_DP);

+}

+

+EFI_STATUS

+BdsMemoryMapLoadImage (

+  IN     EFI_DEVICE_PATH *DevicePath,

+  IN     EFI_HANDLE Handle,

+  IN     EFI_DEVICE_PATH *RemainingDevicePath,

+  IN     EFI_ALLOCATE_TYPE     Type,

+  IN OUT EFI_PHYSICAL_ADDRESS* Image,

+  OUT    UINTN                 *ImageSize

+  )

+{

+  EFI_STATUS            Status;

+  MEMMAP_DEVICE_PATH*   MemMapPathDevicePath;

+  UINTN                 Size;

+

+  if (IS_DEVICE_PATH_NODE (RemainingDevicePath, HARDWARE_DEVICE_PATH, HW_MEMMAP_DP)) {

+    MemMapPathDevicePath = (MEMMAP_DEVICE_PATH*)RemainingDevicePath;

+  } else {

+    ASSERT (IS_DEVICE_PATH_NODE (DevicePath, HARDWARE_DEVICE_PATH, HW_MEMMAP_DP));

+    MemMapPathDevicePath = (MEMMAP_DEVICE_PATH*)DevicePath;

+  }

+

+  Size = MemMapPathDevicePath->EndingAddress - MemMapPathDevicePath->StartingAddress;

+  if (Size == 0) {

+      return EFI_INVALID_PARAMETER;

+  }

+

+  Status = gBS->AllocatePages (Type, EfiBootServicesCode, EFI_SIZE_TO_PAGES(Size), Image);

+  // Try to allocate in any pages if failed to allocate memory at the defined location

+  if ((Status == EFI_OUT_OF_RESOURCES) && (Type != AllocateAnyPages)) {

+    Status = gBS->AllocatePages (AllocateAnyPages, EfiBootServicesCode, EFI_SIZE_TO_PAGES(Size), Image);

+  }

+  if (!EFI_ERROR (Status)) {

+    CopyMem ((VOID*)(UINTN)(*Image), (CONST VOID*)(UINTN)MemMapPathDevicePath->StartingAddress, Size);

+

+    if (ImageSize != NULL) {

+        *ImageSize = Size;

+    }

+  }

+

+  return Status;

+}

+

+BOOLEAN

+BdsFirmwareVolumeSupport (

+  IN EFI_DEVICE_PATH *DevicePath,

+  IN EFI_HANDLE Handle,

+  IN EFI_DEVICE_PATH *RemainingDevicePath

+  )

+{

+  return IS_DEVICE_PATH_NODE (RemainingDevicePath, MEDIA_DEVICE_PATH, MEDIA_PIWG_FW_FILE_DP);

+}

+

+EFI_STATUS

+BdsFirmwareVolumeLoadImage (

+  IN     EFI_DEVICE_PATH *DevicePath,

+  IN     EFI_HANDLE Handle,

+  IN     EFI_DEVICE_PATH *RemainingDevicePath,

+  IN     EFI_ALLOCATE_TYPE     Type,

+  IN OUT EFI_PHYSICAL_ADDRESS* Image,

+  OUT    UINTN                 *ImageSize

+  )

+{

+  EFI_STATUS            Status;

+  EFI_FIRMWARE_VOLUME2_PROTOCOL     *FwVol;

+  EFI_GUID                          *FvNameGuid;

+  EFI_SECTION_TYPE                  SectionType;

+  EFI_FV_FILETYPE                   FvType;

+  EFI_FV_FILE_ATTRIBUTES            Attrib;

+  UINT32                            AuthenticationStatus;

+  VOID* ImageBuffer;

+

+  ASSERT (IS_DEVICE_PATH_NODE (RemainingDevicePath, MEDIA_DEVICE_PATH, MEDIA_PIWG_FW_FILE_DP));

+

+  Status = gBS->HandleProtocol (Handle, &gEfiFirmwareVolume2ProtocolGuid, (VOID **)&FwVol);

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+

+  FvNameGuid = EfiGetNameGuidFromFwVolDevicePathNode ((CONST MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *)RemainingDevicePath);

+  if (FvNameGuid == NULL) {

+    Status = EFI_INVALID_PARAMETER;

+  }

+

+  SectionType = EFI_SECTION_PE32;

+  AuthenticationStatus = 0;

+  //Note: ReadSection at the opposite of ReadFile does not allow to pass ImageBuffer == NULL to get the size of the file.

+  ImageBuffer = NULL;

+  Status = FwVol->ReadSection (

+                    FwVol,

+                    FvNameGuid,

+                    SectionType,

+                    0,

+                    &ImageBuffer,

+                    ImageSize,

+                    &AuthenticationStatus

+                    );

+  if (!EFI_ERROR (Status)) {

+#if 0

+    // In case the buffer has some address requirements, we must copy the buffer to a buffer following the requirements

+    if (Type != AllocateAnyPages) {

+      Status = gBS->AllocatePages (Type, EfiBootServicesCode, EFI_SIZE_TO_PAGES(*ImageSize),Image);

+      if (!EFI_ERROR (Status)) {

+        CopyMem ((VOID*)(UINTN)(*Image), ImageBuffer, *ImageSize);

+        FreePool (ImageBuffer);

+      }

+    }

+#else

+    // We must copy the buffer into a page allocations. Otherwise, the caller could call gBS->FreePages() on the pool allocation

+    Status = gBS->AllocatePages (Type, EfiBootServicesCode, EFI_SIZE_TO_PAGES(*ImageSize), Image);

+    // Try to allocate in any pages if failed to allocate memory at the defined location

+    if ((Status == EFI_OUT_OF_RESOURCES) && (Type != AllocateAnyPages)) {

+      Status = gBS->AllocatePages (AllocateAnyPages, EfiBootServicesCode, EFI_SIZE_TO_PAGES(*ImageSize), Image);

+    }

+    if (!EFI_ERROR (Status)) {

+      CopyMem ((VOID*)(UINTN)(*Image), ImageBuffer, *ImageSize);

+      FreePool (ImageBuffer);

+    }

+#endif

+  } else {

+    // Try a raw file, since a PE32 SECTION does not exist

+    Status = FwVol->ReadFile (

+                        FwVol,

+                        FvNameGuid,

+                        NULL,

+                        ImageSize,

+                        &FvType,

+                        &Attrib,

+                        &AuthenticationStatus

+                        );

+    if (!EFI_ERROR (Status)) {

+      Status = gBS->AllocatePages (Type, EfiBootServicesCode, EFI_SIZE_TO_PAGES(*ImageSize), Image);

+      // Try to allocate in any pages if failed to allocate memory at the defined location

+      if ((Status == EFI_OUT_OF_RESOURCES) && (Type != AllocateAnyPages)) {

+        Status = gBS->AllocatePages (AllocateAnyPages, EfiBootServicesCode, EFI_SIZE_TO_PAGES(*ImageSize), Image);

+      }

+      if (!EFI_ERROR (Status)) {

+        Status = FwVol->ReadFile (

+                                FwVol,

+                                FvNameGuid,

+                                (VOID*)(UINTN)(*Image),

+                                ImageSize,

+                                &FvType,

+                                &Attrib,

+                                &AuthenticationStatus

+                                );

+      }

+    }

+  }

+  return Status;

+}

+

+BOOLEAN

+BdsPxeSupport (

+  IN EFI_DEVICE_PATH*           DevicePath,

+  IN EFI_HANDLE                 Handle,

+  IN EFI_DEVICE_PATH*           RemainingDevicePath

+  )

+{

+  EFI_STATUS                  Status;

+  EFI_PXE_BASE_CODE_PROTOCOL* PxeBcProtocol;

+

+  if (!IsDevicePathEnd (RemainingDevicePath)) {

+    return FALSE;

+  }

+

+  Status = gBS->HandleProtocol (Handle, &gEfiPxeBaseCodeProtocolGuid, (VOID **)&PxeBcProtocol);

+  if (EFI_ERROR (Status)) {

+    return FALSE;

+  } else {

+    return TRUE;

+  }

+}

+

+EFI_STATUS

+BdsPxeLoadImage (

+  IN     EFI_DEVICE_PATH*       DevicePath,

+  IN     EFI_HANDLE             Handle,

+  IN     EFI_DEVICE_PATH*       RemainingDevicePath,

+  IN     EFI_ALLOCATE_TYPE      Type,

+  IN OUT EFI_PHYSICAL_ADDRESS   *Image,

+  OUT    UINTN                  *ImageSize

+  )

+{

+  EFI_STATUS              Status;

+  EFI_LOAD_FILE_PROTOCOL  *LoadFileProtocol;

+  UINTN                   BufferSize;

+  EFI_PXE_BASE_CODE_PROTOCOL *Pxe;

+

+  // Get Load File Protocol attached to the PXE protocol

+  Status = gBS->HandleProtocol (Handle, &gEfiLoadFileProtocolGuid, (VOID **)&LoadFileProtocol);

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+

+  Status = LoadFileProtocol->LoadFile (LoadFileProtocol, DevicePath, TRUE, &BufferSize, NULL);

+  if (Status == EFI_BUFFER_TOO_SMALL) {

+    Status = gBS->AllocatePages (Type, EfiBootServicesCode, EFI_SIZE_TO_PAGES(BufferSize), Image);

+    if (EFI_ERROR (Status)) {

+      return Status;

+    }

+

+    Status = LoadFileProtocol->LoadFile (LoadFileProtocol, DevicePath, TRUE, &BufferSize, (VOID*)(UINTN)(*Image));

+    if (!EFI_ERROR (Status) && (ImageSize != NULL)) {

+      *ImageSize = BufferSize;

+    }

+  }

+

+  if (Status == EFI_ALREADY_STARTED) {

+    Status = gBS->LocateProtocol (&gEfiPxeBaseCodeProtocolGuid, NULL, (VOID **)&Pxe);

+    if (!EFI_ERROR(Status)) {

+      // If PXE is already started, we stop it

+      Pxe->Stop (Pxe);

+      // And we try again

+      return BdsPxeLoadImage (DevicePath, Handle, RemainingDevicePath, Type, Image, ImageSize);

+    }

+  }

+  return Status;

+}

+

+BOOLEAN

+BdsTftpSupport (

+  IN EFI_DEVICE_PATH*           DevicePath,

+  IN EFI_HANDLE                 Handle,

+  IN EFI_DEVICE_PATH*           RemainingDevicePath

+  )

+{

+  EFI_STATUS  Status;

+  EFI_DEVICE_PATH  *NextDevicePath;

+  EFI_PXE_BASE_CODE_PROTOCOL  *PxeBcProtocol;

+

+  // Validate the Remaining Device Path

+  if (IsDevicePathEnd (RemainingDevicePath)) {

+    return FALSE;

+  }

+  if (!IS_DEVICE_PATH_NODE (RemainingDevicePath, MESSAGING_DEVICE_PATH, MSG_IPv4_DP) &&

+      !IS_DEVICE_PATH_NODE (RemainingDevicePath, MESSAGING_DEVICE_PATH, MSG_IPv6_DP)) {

+    return FALSE;

+  }

+  NextDevicePath = NextDevicePathNode (RemainingDevicePath);

+  if (IsDevicePathEnd (NextDevicePath)) {

+    return FALSE;

+  }

+  if (!IS_DEVICE_PATH_NODE (NextDevicePath, MEDIA_DEVICE_PATH, MEDIA_FILEPATH_DP)) {

+    return FALSE;

+  }

+

+  Status = gBS->HandleProtocol (Handle, &gEfiPxeBaseCodeProtocolGuid, (VOID **)&PxeBcProtocol);

+  if (EFI_ERROR (Status)) {

+    return FALSE;

+  } else {

+    return TRUE;

+  }

+}

+

+EFI_STATUS

+BdsTftpLoadImage (

+  IN     EFI_DEVICE_PATH*       DevicePath,

+  IN     EFI_HANDLE             Handle,

+  IN     EFI_DEVICE_PATH*       RemainingDevicePath,

+  IN     EFI_ALLOCATE_TYPE      Type,

+  IN OUT EFI_PHYSICAL_ADDRESS   *Image,

+  OUT    UINTN                  *ImageSize

+  )

+{

+  EFI_STATUS                  Status;

+  EFI_PXE_BASE_CODE_PROTOCOL  *Pxe;

+  UINT64                      TftpBufferSize;

+  VOID*                       TftpBuffer;

+  EFI_IP_ADDRESS              ServerIp;

+  IPv4_DEVICE_PATH*           IPv4DevicePathNode;

+  FILEPATH_DEVICE_PATH*       FilePathDevicePath;

+  EFI_IP_ADDRESS              LocalIp;

+  CHAR8*                      AsciiPathName;

+  EFI_SIMPLE_NETWORK_PROTOCOL *Snp;

+

+  ASSERT(IS_DEVICE_PATH_NODE (RemainingDevicePath, MESSAGING_DEVICE_PATH, MSG_IPv4_DP));

+

+  IPv4DevicePathNode = (IPv4_DEVICE_PATH*)RemainingDevicePath;

+  FilePathDevicePath = (FILEPATH_DEVICE_PATH*)(IPv4DevicePathNode + 1);

+

+  Status = gBS->LocateProtocol (&gEfiPxeBaseCodeProtocolGuid, NULL, (VOID **)&Pxe);

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+

+  Status = Pxe->Start (Pxe, FALSE);

+  if (EFI_ERROR (Status) && (Status != EFI_ALREADY_STARTED)) {

+    return Status;

+  }

+

+  do {

+    if (!IPv4DevicePathNode->StaticIpAddress) {

+      Status = Pxe->Dhcp (Pxe, TRUE);

+    } else {

+      CopyMem (&LocalIp.v4, &IPv4DevicePathNode->LocalIpAddress, sizeof (EFI_IPv4_ADDRESS));

+      Status = Pxe->SetStationIp (Pxe, &LocalIp, NULL);

+    }

+

+    // If an IP Address has already been set and a different static IP address is requested then restart

+    // the Network service.

+    if (Status == EFI_ALREADY_STARTED) {

+      Status = gBS->LocateProtocol (&gEfiSimpleNetworkProtocolGuid, NULL, (VOID **)&Snp);

+      if (!EFI_ERROR (Status) && IPv4DevicePathNode->StaticIpAddress &&

+          (CompareMem (&Snp->Mode->CurrentAddress, &IPv4DevicePathNode->LocalIpAddress, sizeof(EFI_MAC_ADDRESS)) != 0))

+      {

+        Pxe->Stop (Pxe);

+        Status = Pxe->Start (Pxe, FALSE);

+        if (EFI_ERROR(Status)) {

+          break;

+        }

+        // After restarting the PXE protocol, we want to try again with our new IP Address

+        Status = EFI_ALREADY_STARTED;

+      }

+    }

+  } while (Status == EFI_ALREADY_STARTED);

+

+  if (EFI_ERROR(Status)) {

+    return Status;

+  }

+

+  CopyMem (&ServerIp.v4, &IPv4DevicePathNode->RemoteIpAddress, sizeof (EFI_IPv4_ADDRESS));

+

+  // Convert the Unicode PathName to Ascii

+  AsciiPathName = AllocatePool ((StrLen (FilePathDevicePath->PathName) + 1) * sizeof (CHAR8));

+  if (AsciiPathName == NULL) {

+    return EFI_OUT_OF_RESOURCES;

+  }

+  UnicodeStrToAsciiStr (FilePathDevicePath->PathName, AsciiPathName);

+

+  Status = Pxe->Mtftp (

+                  Pxe,

+                  EFI_PXE_BASE_CODE_TFTP_GET_FILE_SIZE,

+                  NULL,

+                  FALSE,

+                  &TftpBufferSize,

+                  NULL,

+                  &ServerIp,

+                  (UINT8*)AsciiPathName,

+                  NULL,

+                  FALSE

+                  );

+  if (EFI_ERROR(Status)) {

+    if (Status == EFI_TFTP_ERROR) {

+      DEBUG((EFI_D_ERROR, "TFTP Error: Fail to get the size of the file\n"));

+    }

+    goto EXIT;

+  }

+

+  // Allocate a buffer to hold the whole file.

+  TftpBuffer = AllocatePool (TftpBufferSize);

+  if (TftpBuffer == NULL) {

+    Status = EFI_OUT_OF_RESOURCES;

+    goto EXIT;

+  }

+

+  Status = Pxe->Mtftp (

+                  Pxe,

+                  EFI_PXE_BASE_CODE_TFTP_READ_FILE,

+                  TftpBuffer,

+                  FALSE,

+                  &TftpBufferSize,

+                  NULL,

+                  &ServerIp,

+                  (UINT8*)AsciiPathName,

+                  NULL,

+                  FALSE

+                  );

+  if (EFI_ERROR (Status)) {

+    FreePool (TftpBuffer);

+  } else if (ImageSize != NULL) {

+    *Image = (UINTN)TftpBuffer;

+    *ImageSize = (UINTN)TftpBufferSize;

+  }

+

+EXIT:

+  FreePool (AsciiPathName);

+  return Status;

+}

+

+BDS_FILE_LOADER FileLoaders[] = {

+    { BdsFileSystemSupport, BdsFileSystemLoadImage },

+    { BdsFirmwareVolumeSupport, BdsFirmwareVolumeLoadImage },

+    //{ BdsLoadFileSupport, BdsLoadFileLoadImage },

+    { BdsMemoryMapSupport, BdsMemoryMapLoadImage },

+    { BdsPxeSupport, BdsPxeLoadImage },

+    { BdsTftpSupport, BdsTftpLoadImage },

+    { NULL, NULL }

+};

+

+EFI_STATUS

+BdsLoadImage (

+  IN     EFI_DEVICE_PATH       *DevicePath,

+  IN     EFI_ALLOCATE_TYPE     Type,

+  IN OUT EFI_PHYSICAL_ADDRESS* Image,

+  OUT    UINTN                 *FileSize

+  )

+{

+  EFI_STATUS      Status;

+  EFI_HANDLE      Handle;

+  EFI_DEVICE_PATH *RemainingDevicePath;

+  BDS_FILE_LOADER*  FileLoader;

+

+  Status = BdsConnectDevicePath (DevicePath, &Handle, &RemainingDevicePath);

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+

+  FileLoader = FileLoaders;

+  while (FileLoader->Support != NULL) {

+    if (FileLoader->Support (DevicePath, Handle, RemainingDevicePath)) {

+      return FileLoader->LoadImage (DevicePath, Handle, RemainingDevicePath, Type, Image, FileSize);

+    }

+    FileLoader++;

+  }

+

+  return EFI_UNSUPPORTED;

+}

+

+/**

+  Start an EFI Application from a Device Path

+

+  @param  ParentImageHandle     Handle of the calling image

+  @param  DevicePath            Location of the EFI Application

+

+  @retval EFI_SUCCESS           All drivers have been connected

+  @retval EFI_NOT_FOUND         The Linux kernel Device Path has not been found

+  @retval EFI_OUT_OF_RESOURCES  There is not enough resource memory to store the matching results.

+

+**/

+EFI_STATUS

+BdsStartEfiApplication (

+  IN EFI_HANDLE                  ParentImageHandle,

+  IN EFI_DEVICE_PATH_PROTOCOL    *DevicePath,

+  IN UINTN                       LoadOptionsSize,

+  IN VOID*                       LoadOptions

+  )

+{

+  EFI_STATUS                   Status;

+  EFI_HANDLE                   ImageHandle;

+  EFI_PHYSICAL_ADDRESS         BinaryBuffer;

+  UINTN                        BinarySize;

+  EFI_LOADED_IMAGE_PROTOCOL*   LoadedImage;

+

+  // Find the nearest supported file loader

+  Status = BdsLoadImage (DevicePath, AllocateAnyPages, &BinaryBuffer, &BinarySize);

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+

+  // Load the image from the Buffer with Boot Services function

+  Status = gBS->LoadImage (TRUE, ParentImageHandle, DevicePath, (VOID*)(UINTN)BinaryBuffer, BinarySize, &ImageHandle);

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+

+  // Passed LoadOptions to the EFI Application

+  if (LoadOptionsSize != 0) {

+    Status = gBS->HandleProtocol (ImageHandle, &gEfiLoadedImageProtocolGuid, (VOID **) &LoadedImage);

+    if (EFI_ERROR (Status)) {

+      return Status;

+    }

+

+    LoadedImage->LoadOptionsSize  = LoadOptionsSize;

+    LoadedImage->LoadOptions      = LoadOptions;

+  }

+

+  // Before calling the image, enable the Watchdog Timer for  the 5 Minute period

+  gBS->SetWatchdogTimer (5 * 60, 0x0000, 0x00, NULL);

+  // Start the image

+  Status = gBS->StartImage (ImageHandle, NULL, NULL);

+  // Clear the Watchdog Timer after the image returns

+  gBS->SetWatchdogTimer (0x0000, 0x0000, 0x0000, NULL);

+

+  return Status;

+}

diff --git a/ArmPkg/Library/BdsLib/BdsHelper.c b/ArmPkg/Library/BdsLib/BdsHelper.c
index 29cc12bd..fb2ac9b8 100644
--- a/ArmPkg/Library/BdsLib/BdsHelper.c
+++ b/ArmPkg/Library/BdsLib/BdsHelper.c
@@ -1,347 +1,360 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-#include "BdsInternal.h"
-
-#include <Library/DxeServicesTableLib.h>
-#include <Library/HobLib.h>
-#include <Library/TimerLib.h>
-#include <Library/PrintLib.h>
-#include <Library/SerialPortLib.h>
-
-STATIC CHAR8 *mTokenList[] = {
-  /*"SEC",*/
-  "PEI",
-  "DXE",
-  "BDS",
-  NULL
-};
-
-EFI_STATUS
-ShutdownUefiBootServices (
-  VOID
-  )
-{
-  EFI_STATUS              Status;
-  UINTN                   MemoryMapSize;
-  EFI_MEMORY_DESCRIPTOR   *MemoryMap;
-  UINTN                   MapKey;
-  UINTN                   DescriptorSize;
-  UINT32                  DescriptorVersion;
-  UINTN                   Pages;
-
-  MemoryMap = NULL;
-  MemoryMapSize = 0;
-  Pages = 0;
-
-  do {
-    Status = gBS->GetMemoryMap (
-                    &MemoryMapSize,
-                    MemoryMap,
-                    &MapKey,
-                    &DescriptorSize,
-                    &DescriptorVersion
-                    );
-    if (Status == EFI_BUFFER_TOO_SMALL) {
-
-      Pages = EFI_SIZE_TO_PAGES (MemoryMapSize) + 1;
-      MemoryMap = AllocatePages (Pages);
-
-      //
-      // Get System MemoryMap
-      //
-      Status = gBS->GetMemoryMap (
-                      &MemoryMapSize,
-                      MemoryMap,
-                      &MapKey,
-                      &DescriptorSize,
-                      &DescriptorVersion
-                      );
-    }
-
-    // Don't do anything between the GetMemoryMap() and ExitBootServices()
-    if (!EFI_ERROR(Status)) {
-      Status = gBS->ExitBootServices (gImageHandle, MapKey);
-      if (EFI_ERROR(Status)) {
-        FreePages (MemoryMap, Pages);
-        MemoryMap = NULL;
-        MemoryMapSize = 0;
-      }
-    }
-  } while (EFI_ERROR(Status));
-
-  return Status;
-}
-
-/**
-  Connect all DXE drivers
-
-  @retval EFI_SUCCESS           All drivers have been connected
-  @retval EFI_NOT_FOUND         No handles match the search.
-  @retval EFI_OUT_OF_RESOURCES  There is not resource pool memory to store the matching results.
-
-**/
-EFI_STATUS
-BdsConnectAllDrivers (
-  VOID
-  )
-{
-  UINTN                     HandleCount, Index;
-  EFI_HANDLE                *HandleBuffer;
-  EFI_STATUS                Status;
-
-  do {
-    // Locate all the driver handles
-    Status = gBS->LocateHandleBuffer (
-                AllHandles,
-                NULL,
-                NULL,
-                &HandleCount,
-                &HandleBuffer
-                );
-    if (EFI_ERROR (Status)) {
-      break;
-    }
-
-    // Connect every handles
-    for (Index = 0; Index < HandleCount; Index++) {
-      gBS->ConnectController (HandleBuffer[Index], NULL, NULL, TRUE);
-    }
-
-    if (HandleBuffer != NULL) {
-      FreePool (HandleBuffer);
-    }
-
-    // Check if new handles have been created after the start of the previous handles
-    Status = gDS->Dispatch ();
-  } while (!EFI_ERROR(Status));
-
-  return EFI_SUCCESS;
-}
-
-STATIC
-EFI_STATUS
-InsertSystemMemoryResources (
-  LIST_ENTRY *ResourceList,
-  EFI_HOB_RESOURCE_DESCRIPTOR *ResHob
-  )
-{
-  BDS_SYSTEM_MEMORY_RESOURCE  *NewResource;
-  LIST_ENTRY                  *Link;
-  LIST_ENTRY                  *NextLink;
-  LIST_ENTRY                  AttachedResources;
-  BDS_SYSTEM_MEMORY_RESOURCE  *Resource;
-  EFI_PHYSICAL_ADDRESS        NewResourceEnd;
-
-  if (IsListEmpty (ResourceList)) {
-    NewResource = AllocateZeroPool (sizeof(BDS_SYSTEM_MEMORY_RESOURCE));
-    NewResource->PhysicalStart = ResHob->PhysicalStart;
-    NewResource->ResourceLength = ResHob->ResourceLength;
-    InsertTailList (ResourceList, &NewResource->Link);
-    return EFI_SUCCESS;
-  }
-
-  InitializeListHead (&AttachedResources);
-
-  Link = ResourceList->ForwardLink;
-  ASSERT (Link != NULL);
-  while (Link != ResourceList) {
-    Resource = (BDS_SYSTEM_MEMORY_RESOURCE*)Link;
-
-    // Sanity Check. The resources should not overlapped.
-    ASSERT(!((ResHob->PhysicalStart >= Resource->PhysicalStart) && (ResHob->PhysicalStart < (Resource->PhysicalStart + Resource->ResourceLength))));
-    ASSERT(!((ResHob->PhysicalStart + ResHob->ResourceLength - 1 >= Resource->PhysicalStart) &&
-        ((ResHob->PhysicalStart + ResHob->ResourceLength - 1) < (Resource->PhysicalStart + Resource->ResourceLength))));
-
-    // The new resource is attached after this resource descriptor
-    if (ResHob->PhysicalStart == Resource->PhysicalStart + Resource->ResourceLength) {
-      Resource->ResourceLength =  Resource->ResourceLength + ResHob->ResourceLength;
-
-      NextLink = RemoveEntryList (&Resource->Link);
-      InsertTailList (&AttachedResources, &Resource->Link);
-      Link = NextLink;
-    }
-    // The new resource is attached before this resource descriptor
-    else if (ResHob->PhysicalStart + ResHob->ResourceLength == Resource->PhysicalStart) {
-      Resource->PhysicalStart = ResHob->PhysicalStart;
-      Resource->ResourceLength =  Resource->ResourceLength + ResHob->ResourceLength;
-
-      NextLink = RemoveEntryList (&Resource->Link);
-      InsertTailList (&AttachedResources, &Resource->Link);
-      Link = NextLink;
-    } else {
-      Link = Link->ForwardLink;
-    }
-  }
-
-  if (!IsListEmpty (&AttachedResources)) {
-    // See if we can merge the attached resource with other resources
-
-    NewResource = (BDS_SYSTEM_MEMORY_RESOURCE*)GetFirstNode (&AttachedResources);
-    Link = RemoveEntryList (&NewResource->Link);
-    while (!IsListEmpty (&AttachedResources)) {
-      // Merge resources
-      Resource = (BDS_SYSTEM_MEMORY_RESOURCE*)Link;
-
-      // Ensure they overlap each other
-      ASSERT(
-          ((NewResource->PhysicalStart >= Resource->PhysicalStart) && (NewResource->PhysicalStart < (Resource->PhysicalStart + Resource->ResourceLength))) ||
-          (((NewResource->PhysicalStart + NewResource->ResourceLength) >= Resource->PhysicalStart) && ((NewResource->PhysicalStart + NewResource->ResourceLength) < (Resource->PhysicalStart + Resource->ResourceLength)))
-      );
-
-      NewResourceEnd = MAX (NewResource->PhysicalStart + NewResource->ResourceLength, Resource->PhysicalStart + Resource->ResourceLength);
-      NewResource->PhysicalStart = MIN (NewResource->PhysicalStart, Resource->PhysicalStart);
-      NewResource->ResourceLength = NewResourceEnd - NewResource->PhysicalStart;
-
-      Link = RemoveEntryList (Link);
-    }
-  } else {
-    // None of the Resource of the list is attached to this ResHob. Create a new entry for it
-    NewResource = AllocateZeroPool (sizeof(BDS_SYSTEM_MEMORY_RESOURCE));
-    NewResource->PhysicalStart = ResHob->PhysicalStart;
-    NewResource->ResourceLength = ResHob->ResourceLength;
-  }
-  InsertTailList (ResourceList, &NewResource->Link);
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-GetSystemMemoryResources (
-  IN  LIST_ENTRY *ResourceList
-  )
-{
-  EFI_HOB_RESOURCE_DESCRIPTOR *ResHob;
-
-  InitializeListHead (ResourceList);
-
-  // Find the first System Memory Resource Descriptor
-  ResHob = (EFI_HOB_RESOURCE_DESCRIPTOR *)GetFirstHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR);
-  while ((ResHob != NULL) && (ResHob->ResourceType != EFI_RESOURCE_SYSTEM_MEMORY)) {
-    ResHob = (EFI_HOB_RESOURCE_DESCRIPTOR *)GetNextHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR,(VOID *)((UINTN)ResHob + ResHob->Header.HobLength));
-  }
-
-  // Did not find any
-  if (ResHob == NULL) {
-    return EFI_NOT_FOUND;
-  } else {
-    InsertSystemMemoryResources (ResourceList, ResHob);
-  }
-
-  ResHob = (EFI_HOB_RESOURCE_DESCRIPTOR *)GetNextHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR,(VOID *)((UINTN)ResHob + ResHob->Header.HobLength));
-  while (ResHob != NULL) {
-    if (ResHob->ResourceType == EFI_RESOURCE_SYSTEM_MEMORY) {
-      InsertSystemMemoryResources (ResourceList, ResHob);
-    }
-    ResHob = (EFI_HOB_RESOURCE_DESCRIPTOR *)GetNextHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR,(VOID *)((UINTN)ResHob + ResHob->Header.HobLength));
-  }
-
-  return EFI_SUCCESS;
-}
-
-VOID
-PrintPerformance (
-  VOID
-  )
-{
-  UINTN       Key;
-  CONST VOID  *Handle;
-  CONST CHAR8 *Token, *Module;
-  UINT64      Start, Stop, TimeStamp;
-  UINT64      Delta, TicksPerSecond, Milliseconds;
-  UINTN       Index;
-  CHAR8       Buffer[100];
-  UINTN       CharCount;
-  BOOLEAN     CountUp;
-
-  TicksPerSecond = GetPerformanceCounterProperties (&Start, &Stop);
-  if (Start < Stop) {
-    CountUp = TRUE;
-  } else {
-    CountUp = FALSE;
-  }
-
-  TimeStamp = 0;
-  Key       = 0;
-  do {
-    Key = GetPerformanceMeasurement (Key, (CONST VOID **)&Handle, &Token, &Module, &Start, &Stop);
-    if (Key != 0) {
-      for (Index = 0; mTokenList[Index] != NULL; Index++) {
-        if (AsciiStriCmp (mTokenList[Index], Token) == 0) {
-          Delta = CountUp?(Stop - Start):(Start - Stop);
-          TimeStamp += Delta;
-          Milliseconds = DivU64x64Remainder (MultU64x32 (Delta, 1000), TicksPerSecond, NULL);
-          CharCount = AsciiSPrint (Buffer,sizeof (Buffer),"%6a %6ld ms\n", Token, Milliseconds);
-          SerialPortWrite ((UINT8 *) Buffer, CharCount);
-          break;
-        }
-      }
-    }
-  } while (Key != 0);
-
-  CharCount = AsciiSPrint (Buffer,sizeof (Buffer),"Total Time = %ld ms\n\n", DivU64x64Remainder (MultU64x32 (TimeStamp, 1000), TicksPerSecond, NULL));
-  SerialPortWrite ((UINT8 *) Buffer, CharCount);
-}
-
-EFI_STATUS
-GetEnvironmentVariable (
-  IN     CONST CHAR16*   VariableName,
-  IN     VOID*           DefaultValue,
-  IN OUT UINTN*          Size,
-  OUT    VOID**          Value
-  )
-{
-  EFI_STATUS  Status;
-  UINTN       VariableSize;
-
-  // Try to get the variable size.
-  *Value = NULL;
-  VariableSize = 0;
-  Status = gRT->GetVariable ((CHAR16 *) VariableName, &gEfiGlobalVariableGuid, NULL, &VariableSize, *Value);
-  if (Status == EFI_NOT_FOUND) {
-    if ((DefaultValue != NULL) && (Size != NULL) && (*Size != 0)) {
-      // If the environment variable does not exist yet then set it with the default value
-      Status = gRT->SetVariable (
-                    (CHAR16*)VariableName,
-                    &gEfiGlobalVariableGuid,
-                    EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
-                    *Size,
-                    DefaultValue
-                    );
-      *Value = DefaultValue;
-    } else {
-      return EFI_NOT_FOUND;
-    }
-  } else if (Status == EFI_BUFFER_TOO_SMALL) {
-    // Get the environment variable value
-    *Value = AllocatePool (VariableSize);
-    if (*Value == NULL) {
-      return EFI_OUT_OF_RESOURCES;
-    }
-
-    Status = gRT->GetVariable ((CHAR16 *)VariableName, &gEfiGlobalVariableGuid, NULL, &VariableSize, *Value);
-    if (EFI_ERROR (Status)) {
-      FreePool(*Value);
-      return EFI_INVALID_PARAMETER;
-    }
-
-    if (Size) {
-      *Size = VariableSize;
-    }
-  } else {
-    *Value = DefaultValue;
-    return Status;
-  }
-
-  return EFI_SUCCESS;
-}
+/** @file

+*

+*  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

+*

+*  This program and the accompanying materials

+*  are licensed and made available under the terms and conditions of the BSD License

+*  which accompanies this distribution.  The full text of the license may be found at

+*  http://opensource.org/licenses/bsd-license.php

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+*

+**/

+

+#include "BdsInternal.h"

+

+#include <Library/DxeServicesTableLib.h>

+#include <Library/HobLib.h>

+#include <Library/TimerLib.h>

+#include <Library/PrintLib.h>

+#include <Library/SerialPortLib.h>

+

+STATIC CHAR8 *mTokenList[] = {

+  /*"SEC",*/

+  "PEI",

+  "DXE",

+  "BDS",

+  NULL

+};

+

+EFI_STATUS

+ShutdownUefiBootServices (

+  VOID

+  )

+{

+  EFI_STATUS              Status;

+  UINTN                   MemoryMapSize;

+  EFI_MEMORY_DESCRIPTOR   *MemoryMap;

+  UINTN                   MapKey;

+  UINTN                   DescriptorSize;

+  UINT32                  DescriptorVersion;

+  UINTN                   Pages;

+

+  MemoryMap = NULL;

+  MemoryMapSize = 0;

+  Pages = 0;

+

+  do {

+    Status = gBS->GetMemoryMap (

+                    &MemoryMapSize,

+                    MemoryMap,

+                    &MapKey,

+                    &DescriptorSize,

+                    &DescriptorVersion

+                    );

+    if (Status == EFI_BUFFER_TOO_SMALL) {

+

+      Pages = EFI_SIZE_TO_PAGES (MemoryMapSize) + 1;

+      MemoryMap = AllocatePages (Pages);

+

+      //

+      // Get System MemoryMap

+      //

+      Status = gBS->GetMemoryMap (

+                      &MemoryMapSize,

+                      MemoryMap,

+                      &MapKey,

+                      &DescriptorSize,

+                      &DescriptorVersion

+                      );

+    }

+

+    // Don't do anything between the GetMemoryMap() and ExitBootServices()

+    if (!EFI_ERROR(Status)) {

+      Status = gBS->ExitBootServices (gImageHandle, MapKey);

+      if (EFI_ERROR(Status)) {

+        FreePages (MemoryMap, Pages);

+        MemoryMap = NULL;

+        MemoryMapSize = 0;

+      }

+    }

+  } while (EFI_ERROR(Status));

+

+  return Status;

+}

+

+/**

+  Connect all DXE drivers

+

+  @retval EFI_SUCCESS           All drivers have been connected

+  @retval EFI_NOT_FOUND         No handles match the search.

+  @retval EFI_OUT_OF_RESOURCES  There is not resource pool memory to store the matching results.

+

+**/

+EFI_STATUS

+BdsConnectAllDrivers (

+  VOID

+  )

+{

+  UINTN                     HandleCount, Index;

+  EFI_HANDLE                *HandleBuffer;

+  EFI_STATUS                Status;

+

+  do {

+    // Locate all the driver handles

+    Status = gBS->LocateHandleBuffer (

+                AllHandles,

+                NULL,

+                NULL,

+                &HandleCount,

+                &HandleBuffer

+                );

+    if (EFI_ERROR (Status)) {

+      break;

+    }

+

+    // Connect every handles

+    for (Index = 0; Index < HandleCount; Index++) {

+      gBS->ConnectController (HandleBuffer[Index], NULL, NULL, TRUE);

+    }

+

+    if (HandleBuffer != NULL) {

+      FreePool (HandleBuffer);

+    }

+

+    // Check if new handles have been created after the start of the previous handles

+    Status = gDS->Dispatch ();

+  } while (!EFI_ERROR(Status));

+

+  return EFI_SUCCESS;

+}

+

+STATIC

+EFI_STATUS

+InsertSystemMemoryResources (

+  LIST_ENTRY *ResourceList,

+  EFI_HOB_RESOURCE_DESCRIPTOR *ResHob

+  )

+{

+  BDS_SYSTEM_MEMORY_RESOURCE  *NewResource;

+  LIST_ENTRY                  *Link;

+  LIST_ENTRY                  *NextLink;

+  LIST_ENTRY                  AttachedResources;

+  BDS_SYSTEM_MEMORY_RESOURCE  *Resource;

+  EFI_PHYSICAL_ADDRESS        NewResourceEnd;

+

+  if (IsListEmpty (ResourceList)) {

+    NewResource = AllocateZeroPool (sizeof(BDS_SYSTEM_MEMORY_RESOURCE));

+    NewResource->PhysicalStart = ResHob->PhysicalStart;

+    NewResource->ResourceLength = ResHob->ResourceLength;

+    InsertTailList (ResourceList, &NewResource->Link);

+    return EFI_SUCCESS;

+  }

+

+  InitializeListHead (&AttachedResources);

+

+  Link = ResourceList->ForwardLink;

+  ASSERT (Link != NULL);

+  while (Link != ResourceList) {

+    Resource = (BDS_SYSTEM_MEMORY_RESOURCE*)Link;

+

+    // Sanity Check. The resources should not overlapped.

+    ASSERT(!((ResHob->PhysicalStart >= Resource->PhysicalStart) && (ResHob->PhysicalStart < (Resource->PhysicalStart + Resource->ResourceLength))));

+    ASSERT(!((ResHob->PhysicalStart + ResHob->ResourceLength - 1 >= Resource->PhysicalStart) &&

+        ((ResHob->PhysicalStart + ResHob->ResourceLength - 1) < (Resource->PhysicalStart + Resource->ResourceLength))));

+

+    // The new resource is attached after this resource descriptor

+    if (ResHob->PhysicalStart == Resource->PhysicalStart + Resource->ResourceLength) {

+      Resource->ResourceLength =  Resource->ResourceLength + ResHob->ResourceLength;

+

+      NextLink = RemoveEntryList (&Resource->Link);

+      InsertTailList (&AttachedResources, &Resource->Link);

+      Link = NextLink;

+    }

+    // The new resource is attached before this resource descriptor

+    else if (ResHob->PhysicalStart + ResHob->ResourceLength == Resource->PhysicalStart) {

+      Resource->PhysicalStart = ResHob->PhysicalStart;

+      Resource->ResourceLength =  Resource->ResourceLength + ResHob->ResourceLength;

+

+      NextLink = RemoveEntryList (&Resource->Link);

+      InsertTailList (&AttachedResources, &Resource->Link);

+      Link = NextLink;

+    } else {

+      Link = Link->ForwardLink;

+    }

+  }

+

+  if (!IsListEmpty (&AttachedResources)) {

+    // See if we can merge the attached resource with other resources

+

+    NewResource = (BDS_SYSTEM_MEMORY_RESOURCE*)GetFirstNode (&AttachedResources);

+    Link = RemoveEntryList (&NewResource->Link);

+    while (!IsListEmpty (&AttachedResources)) {

+      // Merge resources

+      Resource = (BDS_SYSTEM_MEMORY_RESOURCE*)Link;

+

+      // Ensure they overlap each other

+      ASSERT(

+          ((NewResource->PhysicalStart >= Resource->PhysicalStart) && (NewResource->PhysicalStart < (Resource->PhysicalStart + Resource->ResourceLength))) ||

+          (((NewResource->PhysicalStart + NewResource->ResourceLength) >= Resource->PhysicalStart) && ((NewResource->PhysicalStart + NewResource->ResourceLength) < (Resource->PhysicalStart + Resource->ResourceLength)))

+      );

+

+      NewResourceEnd = MAX (NewResource->PhysicalStart + NewResource->ResourceLength, Resource->PhysicalStart + Resource->ResourceLength);

+      NewResource->PhysicalStart = MIN (NewResource->PhysicalStart, Resource->PhysicalStart);

+      NewResource->ResourceLength = NewResourceEnd - NewResource->PhysicalStart;

+

+      Link = RemoveEntryList (Link);

+    }

+  } else {

+    // None of the Resource of the list is attached to this ResHob. Create a new entry for it

+    NewResource = AllocateZeroPool (sizeof(BDS_SYSTEM_MEMORY_RESOURCE));

+    NewResource->PhysicalStart = ResHob->PhysicalStart;

+    NewResource->ResourceLength = ResHob->ResourceLength;

+  }

+  InsertTailList (ResourceList, &NewResource->Link);

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+GetSystemMemoryResources (

+  IN  LIST_ENTRY *ResourceList

+  )

+{

+  EFI_HOB_RESOURCE_DESCRIPTOR *ResHob;

+

+  InitializeListHead (ResourceList);

+

+  // Find the first System Memory Resource Descriptor

+  ResHob = (EFI_HOB_RESOURCE_DESCRIPTOR *)GetFirstHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR);

+  while ((ResHob != NULL) && (ResHob->ResourceType != EFI_RESOURCE_SYSTEM_MEMORY)) {

+    ResHob = (EFI_HOB_RESOURCE_DESCRIPTOR *)GetNextHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR,(VOID *)((UINTN)ResHob + ResHob->Header.HobLength));

+  }

+

+  // Did not find any

+  if (ResHob == NULL) {

+    return EFI_NOT_FOUND;

+  } else {

+    InsertSystemMemoryResources (ResourceList, ResHob);

+  }

+

+  ResHob = (EFI_HOB_RESOURCE_DESCRIPTOR *)GetNextHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR,(VOID *)((UINTN)ResHob + ResHob->Header.HobLength));

+  while (ResHob != NULL) {

+    if (ResHob->ResourceType == EFI_RESOURCE_SYSTEM_MEMORY) {

+      InsertSystemMemoryResources (ResourceList, ResHob);

+    }

+    ResHob = (EFI_HOB_RESOURCE_DESCRIPTOR *)GetNextHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR,(VOID *)((UINTN)ResHob + ResHob->Header.HobLength));

+  }

+

+  return EFI_SUCCESS;

+}

+

+VOID

+PrintPerformance (

+  VOID

+  )

+{

+  UINTN       Key;

+  CONST VOID  *Handle;

+  CONST CHAR8 *Token, *Module;

+  UINT64      Start, Stop, TimeStamp;

+  UINT64      Delta, TicksPerSecond, Milliseconds;

+  UINTN       Index;

+  CHAR8       Buffer[100];

+  UINTN       CharCount;

+  BOOLEAN     CountUp;

+

+  TicksPerSecond = GetPerformanceCounterProperties (&Start, &Stop);

+  if (Start < Stop) {

+    CountUp = TRUE;

+  } else {

+    CountUp = FALSE;

+  }

+

+  TimeStamp = 0;

+  Key       = 0;

+  do {

+    Key = GetPerformanceMeasurement (Key, (CONST VOID **)&Handle, &Token, &Module, &Start, &Stop);

+    if (Key != 0) {

+      for (Index = 0; mTokenList[Index] != NULL; Index++) {

+        if (AsciiStriCmp (mTokenList[Index], Token) == 0) {

+          Delta = CountUp?(Stop - Start):(Start - Stop);

+          TimeStamp += Delta;

+          Milliseconds = DivU64x64Remainder (MultU64x32 (Delta, 1000), TicksPerSecond, NULL);

+          CharCount = AsciiSPrint (Buffer,sizeof (Buffer),"%6a %6ld ms\n", Token, Milliseconds);

+          SerialPortWrite ((UINT8 *) Buffer, CharCount);

+          break;

+        }

+      }

+    }

+  } while (Key != 0);

+

+  CharCount = AsciiSPrint (Buffer,sizeof (Buffer),"Total Time = %ld ms\n\n", DivU64x64Remainder (MultU64x32 (TimeStamp, 1000), TicksPerSecond, NULL));

+  SerialPortWrite ((UINT8 *) Buffer, CharCount);

+}

+

+EFI_STATUS

+GetGlobalEnvironmentVariable (

+  IN     CONST CHAR16*   VariableName,

+  IN     VOID*           DefaultValue,

+  IN OUT UINTN*          Size,

+  OUT    VOID**          Value

+  )

+{

+  return GetEnvironmentVariable (VariableName, &gEfiGlobalVariableGuid,

+           DefaultValue, Size, Value);

+}

+

+EFI_STATUS

+GetEnvironmentVariable (

+  IN     CONST CHAR16*   VariableName,

+  IN     EFI_GUID*       VendorGuid,

+  IN     VOID*           DefaultValue,

+  IN OUT UINTN*          Size,

+  OUT    VOID**          Value

+  )

+{

+  EFI_STATUS  Status;

+  UINTN       VariableSize;

+

+  // Try to get the variable size.

+  *Value = NULL;

+  VariableSize = 0;

+  Status = gRT->GetVariable ((CHAR16 *) VariableName, VendorGuid, NULL, &VariableSize, *Value);

+  if (Status == EFI_NOT_FOUND) {

+    if ((DefaultValue != NULL) && (Size != NULL) && (*Size != 0)) {

+      // If the environment variable does not exist yet then set it with the default value

+      Status = gRT->SetVariable (

+                    (CHAR16*)VariableName,

+                    VendorGuid,

+                    EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,

+                    *Size,

+                    DefaultValue

+                    );

+      *Value = DefaultValue;

+    } else {

+      return EFI_NOT_FOUND;

+    }

+  } else if (Status == EFI_BUFFER_TOO_SMALL) {

+    // Get the environment variable value

+    *Value = AllocatePool (VariableSize);

+    if (*Value == NULL) {

+      return EFI_OUT_OF_RESOURCES;

+    }

+

+    Status = gRT->GetVariable ((CHAR16 *)VariableName, VendorGuid, NULL, &VariableSize, *Value);

+    if (EFI_ERROR (Status)) {

+      FreePool(*Value);

+      return EFI_INVALID_PARAMETER;

+    }

+

+    if (Size) {

+      *Size = VariableSize;

+    }

+  } else {

+    *Value = DefaultValue;

+    return Status;

+  }

+

+  return EFI_SUCCESS;

+}

diff --git a/ArmPkg/Library/BdsLib/BdsInternal.h b/ArmPkg/Library/BdsLib/BdsInternal.h
index 85f9f415..5ae46f86 100644
--- a/ArmPkg/Library/BdsLib/BdsInternal.h
+++ b/ArmPkg/Library/BdsLib/BdsInternal.h
@@ -1,98 +1,98 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-#ifndef __BDS_INTERNAL_H__
-#define __BDS_INTERNAL_H__
-
-#include <PiDxe.h>
-#include <Library/ArmLib.h>
-#include <Library/BaseLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/HobLib.h>
-#include <Library/UefiBootServicesTableLib.h>
-#include <Library/UefiLib.h>
-#include <Library/DevicePathLib.h>
-#include <Library/MemoryAllocationLib.h>
-#include <Library/DebugLib.h>
-#include <Library/BdsLib.h>
-#include <Library/PcdLib.h>
-#include <Library/PerformanceLib.h>
-#include <Library/PrintLib.h>
-#include <Library/UefiRuntimeServicesTableLib.h>
-
-#include <Guid/ArmMpCoreInfo.h>
-#include <Guid/GlobalVariable.h>
-#include <Guid/FileInfo.h>
-
-#include <Protocol/DevicePath.h>
-#include <Protocol/DevicePathFromText.h>
-#include <Protocol/SimpleFileSystem.h>
-#include <Protocol/FirmwareVolume2.h>
-#include <Protocol/LoadFile.h>
-#include <Protocol/PxeBaseCode.h>
-
-#include <Uefi.h>
-
-typedef BOOLEAN (*BDS_FILE_LOADER_SUPPORT) (
-  IN EFI_DEVICE_PATH            *DevicePath,
-  IN EFI_HANDLE                 Handle,
-  IN EFI_DEVICE_PATH            *RemainingDevicePath
-  );
-
-typedef EFI_STATUS (*BDS_FILE_LOADER_LOAD_IMAGE) (
-  IN     EFI_DEVICE_PATH        *DevicePath,
-  IN     EFI_HANDLE             Handle,
-  IN     EFI_DEVICE_PATH        *RemainingDevicePath,
-  IN     EFI_ALLOCATE_TYPE      Type,
-  IN OUT EFI_PHYSICAL_ADDRESS*  Image,
-  OUT    UINTN                  *ImageSize
-  );
-
-typedef struct {
-  BDS_FILE_LOADER_SUPPORT     Support;
-  BDS_FILE_LOADER_LOAD_IMAGE  LoadImage;
-} BDS_FILE_LOADER;
-
-typedef struct _BDS_SYSTEM_MEMORY_RESOURCE {
-  LIST_ENTRY                  Link; // This attribute must be the first entry of this structure (to avoid pointer computation)
-  EFI_PHYSICAL_ADDRESS        PhysicalStart;
-  UINT64                      ResourceLength;
-} BDS_SYSTEM_MEMORY_RESOURCE;
-
-
-// BdsHelper.c
-EFI_STATUS
-ShutdownUefiBootServices (
-  VOID
-  );
-
-EFI_STATUS
-GetSystemMemoryResources (
-  LIST_ENTRY *ResourceList
-  );
-
-VOID
-PrintPerformance (
-  VOID
-  );
-
-EFI_STATUS
-BdsLoadImage (
-  IN     EFI_DEVICE_PATH       *DevicePath,
-  IN     EFI_ALLOCATE_TYPE     Type,
-  IN OUT EFI_PHYSICAL_ADDRESS* Image,
-  OUT    UINTN                 *FileSize
-  );
-
-#endif
+/** @file

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+#ifndef __BDS_INTERNAL_H__

+#define __BDS_INTERNAL_H__

+

+#include <PiDxe.h>

+#include <Library/ArmLib.h>

+#include <Library/BaseLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/HobLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/UefiLib.h>

+#include <Library/DevicePathLib.h>

+#include <Library/MemoryAllocationLib.h>

+#include <Library/DebugLib.h>

+#include <Library/BdsLib.h>

+#include <Library/PcdLib.h>

+#include <Library/PerformanceLib.h>

+#include <Library/PrintLib.h>

+#include <Library/UefiRuntimeServicesTableLib.h>

+

+#include <Guid/ArmMpCoreInfo.h>

+#include <Guid/GlobalVariable.h>

+#include <Guid/FileInfo.h>

+

+#include <Protocol/DevicePath.h>

+#include <Protocol/DevicePathFromText.h>

+#include <Protocol/SimpleFileSystem.h>

+#include <Protocol/FirmwareVolume2.h>

+#include <Protocol/LoadFile.h>

+#include <Protocol/PxeBaseCode.h>

+

+#include <Uefi.h>

+

+typedef BOOLEAN (*BDS_FILE_LOADER_SUPPORT) (

+  IN EFI_DEVICE_PATH            *DevicePath,

+  IN EFI_HANDLE                 Handle,

+  IN EFI_DEVICE_PATH            *RemainingDevicePath

+  );

+

+typedef EFI_STATUS (*BDS_FILE_LOADER_LOAD_IMAGE) (

+  IN     EFI_DEVICE_PATH        *DevicePath,

+  IN     EFI_HANDLE             Handle,

+  IN     EFI_DEVICE_PATH        *RemainingDevicePath,

+  IN     EFI_ALLOCATE_TYPE      Type,

+  IN OUT EFI_PHYSICAL_ADDRESS*  Image,

+  OUT    UINTN                  *ImageSize

+  );

+

+typedef struct {

+  BDS_FILE_LOADER_SUPPORT     Support;

+  BDS_FILE_LOADER_LOAD_IMAGE  LoadImage;

+} BDS_FILE_LOADER;

+

+typedef struct _BDS_SYSTEM_MEMORY_RESOURCE {

+  LIST_ENTRY                  Link; // This attribute must be the first entry of this structure (to avoid pointer computation)

+  EFI_PHYSICAL_ADDRESS        PhysicalStart;

+  UINT64                      ResourceLength;

+} BDS_SYSTEM_MEMORY_RESOURCE;

+

+

+// BdsHelper.c

+EFI_STATUS

+ShutdownUefiBootServices (

+  VOID

+  );

+

+EFI_STATUS

+GetSystemMemoryResources (

+  LIST_ENTRY *ResourceList

+  );

+

+VOID

+PrintPerformance (

+  VOID

+  );

+

+EFI_STATUS

+BdsLoadImage (

+  IN     EFI_DEVICE_PATH       *DevicePath,

+  IN     EFI_ALLOCATE_TYPE     Type,

+  IN OUT EFI_PHYSICAL_ADDRESS* Image,

+  OUT    UINTN                 *FileSize

+  );

+

+#endif

diff --git a/ArmPkg/Library/BdsLib/BdsLib.inf b/ArmPkg/Library/BdsLib/BdsLib.inf
index 9dee03a7..ccca39ab 100644
--- a/ArmPkg/Library/BdsLib/BdsLib.inf
+++ b/ArmPkg/Library/BdsLib/BdsLib.inf
@@ -1,77 +1,84 @@
-#/* @file
-#  
-#  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-#  
-#  This program and the accompanying materials                          
-#  are licensed and made available under the terms and conditions of the BSD License         
-#  which accompanies this distribution.  The full text of the license may be found at        
-#  http://opensource.org/licenses/bsd-license.php                                            
-#
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-#
-#*/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = BdsLib
-  FILE_GUID                      = ddbf73a0-bb25-11df-8e4e-0002a5d5c51b
-  MODULE_TYPE                    = DXE_DRIVER
-  VERSION_STRING                 = 1.0
-  LIBRARY_CLASS                  = BdsLib
-
-[Sources.common]
-  BdsFilePath.c
-  BdsAppLoader.c
-  BdsHelper.c
-  BdsLoadOption.c
-
-  BdsLinuxLoader.c
-  BdsLinuxAtag.c
-  BdsLinuxFdt.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  EmbeddedPkg/EmbeddedPkg.dec
-  ArmPkg/ArmPkg.dec
-
-[LibraryClasses]
-  ArmLib
-  BaseLib
-  DebugLib
-  DevicePathLib
-  HobLib
-  PerformanceLib
-  SerialPortLib
-  FdtLib
-
-[Guids]
-  gEfiFileInfoGuid
-  gArmMpCoreInfoGuid
-
-[Protocols]
-  gEfiBdsArchProtocolGuid                       
-  gEfiDevicePathProtocolGuid
-  gEfiDevicePathFromTextProtocolGuid
-  gEfiSimpleFileSystemProtocolGuid
-  gEfiFirmwareVolume2ProtocolGuid
-  gEfiLoadFileProtocolGuid
-  gEfiPxeBaseCodeProtocolGuid
-  gEfiDiskIoProtocolGuid
-  gEfiUsbIoProtocolGuid
-  gEfiLoadedImageProtocolGuid
-    
-[FeaturePcd]  
-
-[FixedPcd]
-  gArmTokenSpaceGuid.PcdSystemMemoryBase
-  gArmTokenSpaceGuid.PcdSystemMemorySize
-
-  gArmTokenSpaceGuid.PcdArmMachineType
-  gArmTokenSpaceGuid.PcdArmLinuxFdtMaxOffset
-  gArmTokenSpaceGuid.PcdArmLinuxKernelFixedOffset
-  gArmTokenSpaceGuid.PcdArmLinuxKernelMaxOffset
-  gArmTokenSpaceGuid.PcdArmLinuxAtagMaxOffset
-  
-[Depex]
-  TRUE
+#/* @file

+#  

+#  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

+#  

+#  This program and the accompanying materials                          

+#  are licensed and made available under the terms and conditions of the BSD License         

+#  which accompanies this distribution.  The full text of the license may be found at        

+#  http://opensource.org/licenses/bsd-license.php                                            

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+#

+#*/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = BdsLib

+  FILE_GUID                      = ddbf73a0-bb25-11df-8e4e-0002a5d5c51b

+  MODULE_TYPE                    = DXE_DRIVER

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = BdsLib

+

+[Sources.common]

+  BdsFilePath.c

+  BdsAppLoader.c

+  BdsHelper.c

+  BdsLoadOption.c

+  BdsLinuxFdt.c

+

+[Sources.ARM]

+  Arm/BdsLinuxLoader.c

+  Arm/BdsLinuxAtag.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  EmbeddedPkg/EmbeddedPkg.dec

+  ArmPkg/ArmPkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+

+[LibraryClasses]

+  ArmLib

+  ArmSmcLib

+  BaseLib

+  DebugLib

+  DevicePathLib

+  HobLib

+  PerformanceLib

+  SerialPortLib

+  FdtLib

+  TimerLib

+

+[Guids]

+  gEfiFileInfoGuid

+  gArmMpCoreInfoGuid

+  gArmGlobalVariableGuid

+

+[Protocols]

+  gEfiBdsArchProtocolGuid                       

+  gEfiDevicePathProtocolGuid

+  gEfiDevicePathFromTextProtocolGuid

+  gEfiSimpleFileSystemProtocolGuid

+  gEfiFirmwareVolume2ProtocolGuid

+  gEfiLoadFileProtocolGuid

+  gEfiPxeBaseCodeProtocolGuid

+  gEfiDiskIoProtocolGuid

+  gEfiUsbIoProtocolGuid

+  gEfiLoadedImageProtocolGuid

+  gEfiSimpleNetworkProtocolGuid

+    

+[FeaturePcd]

+  gArmTokenSpaceGuid.PcdArmPsciSupport

+

+[FixedPcd]

+  gArmTokenSpaceGuid.PcdSystemMemoryBase

+  gArmTokenSpaceGuid.PcdSystemMemorySize

+

+  gArmTokenSpaceGuid.PcdArmMachineType

+  gArmTokenSpaceGuid.PcdArmLinuxFdtMaxOffset

+  gArmTokenSpaceGuid.PcdArmLinuxKernelFixedOffset

+  gArmTokenSpaceGuid.PcdArmLinuxKernelMaxOffset

+  gArmTokenSpaceGuid.PcdArmLinuxAtagMaxOffset

+  

+[Depex]

+  TRUE

diff --git a/ArmPkg/Library/BdsLib/BdsLinuxFdt.c b/ArmPkg/Library/BdsLib/BdsLinuxFdt.c
index fa06287b..b5dd2371 100644
--- a/ArmPkg/Library/BdsLib/BdsLinuxFdt.c
+++ b/ArmPkg/Library/BdsLib/BdsLinuxFdt.c
@@ -1,20 +1,23 @@
 /** @file

 *

-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

-*  

-*  This program and the accompanying materials                          

-*  are licensed and made available under the terms and conditions of the BSD License         

-*  which accompanies this distribution.  The full text of the license may be found at        

-*  http://opensource.org/licenses/bsd-license.php                                            

+*  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

 *

-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*  This program and the accompanying materials

+*  are licensed and made available under the terms and conditions of the BSD License

+*  which accompanies this distribution.  The full text of the license may be found at

+*  http://opensource.org/licenses/bsd-license.php

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

 *

 **/

 

+#include <Library/ArmSmcLib.h>

 #include <Library/PcdLib.h>

 #include <libfdt.h>

 

+#include <IndustryStandard/ArmSmc.h>

+

 #include "BdsInternal.h"

 #include "BdsLinuxLoader.h"

 

@@ -104,6 +107,23 @@ DebugDumpFdt (
   UINTN shift;

   UINT32 version;

 

+  {

+    // Can 'memreserve' be printed by below code?

+    INTN num = fdt_num_mem_rsv(FdtBlob);

+    INTN i, err;

+    UINT64 addr = 0,size = 0;

+

+    for (i = 0; i < num; i++) {

+      err = fdt_get_mem_rsv(FdtBlob, i, &addr, &size);

+      if (err) {

+        DEBUG((EFI_D_ERROR, "Error (%d) : Cannot get memreserve section (%d)\n", err, i));

+      }

+      else {

+        Print(L"/memreserve/ \t0x%lx \t0x%lx;\n",addr,size);

+      }

+    }

+  }

+

   depth = 0;

   shift = 4;

 

@@ -159,6 +179,25 @@ DebugDumpFdt (
   }

 }

 

+STATIC

+BOOLEAN

+IsLinuxReservedRegion (

+  IN EFI_MEMORY_TYPE MemoryType

+  )

+{

+  switch(MemoryType) {

+  case EfiRuntimeServicesCode:

+  case EfiRuntimeServicesData:

+  case EfiUnusableMemory:

+  case EfiACPIReclaimMemory:

+  case EfiACPIMemoryNVS:

+    return TRUE;

+  default:

+    return FALSE;

+  }

+}

+

+

 typedef struct {

   UINTN   Base;

   UINTN   Size;

@@ -170,7 +209,7 @@ PrepareFdt (
   IN     EFI_PHYSICAL_ADDRESS InitrdImage,

   IN     UINTN                InitrdImageSize,

   IN OUT EFI_PHYSICAL_ADDRESS *FdtBlobBase,

-  IN OUT UINT32               *FdtBlobSize

+  IN OUT UINTN                *FdtBlobSize

   )

 {

   EFI_STATUS            Status;

@@ -182,6 +221,7 @@ PrepareFdt (
   INTN                  cpu_node;

   INTN                  lenp;

   CONST VOID*           BootArg;

+  CONST VOID*           Method;

   EFI_PHYSICAL_ADDRESS  InitrdImageStart;

   EFI_PHYSICAL_ADDRESS  InitrdImageEnd;

   FdtRegion             Region;

@@ -195,17 +235,65 @@ PrepareFdt (
   UINT32                ClusterId;

   UINT32                CoreId;

   UINT64                CpuReleaseAddr;

+  UINTN                 MemoryMapSize;

+  EFI_MEMORY_DESCRIPTOR *MemoryMap;

+  UINTN                 MapKey;

+  UINTN                 DescriptorSize;

+  UINT32                DescriptorVersion;

+  UINTN                 Pages;

+  BOOLEAN               PsciSmcSupported;

+  UINTN                 Rx;

+  UINTN                 OriginalFdtSize;

 

+  //

+  // Ensure the Power State Coordination Interface (PSCI) SMCs are there if supported

+  //

+  PsciSmcSupported = FALSE;

+  if (FeaturePcdGet (PcdArmPsciSupport) == TRUE) {

+    // Check the SMC response to the Presence SMC

+    Rx   = ARM_SMC_ID_PRESENCE;

+    ArmCallSmc (&Rx);

+    if (Rx == 1) {

+      // Check the SMC UID

+      Rx   = ARM_SMC_ID_UID;

+      ArmCallSmc (&Rx);

+      if (Rx == ARM_TRUSTZONE_UID_4LETTERID) {

+        Rx   = ARM_SMC_ID_UID + 1;

+        ArmCallSmc (&Rx);

+        //TODO: Replace ARM magic number

+        if (Rx == 0x40524d48) {

+          PsciSmcSupported = TRUE;

+        }

+      }

+      if (PsciSmcSupported == FALSE) {

+        DEBUG((EFI_D_ERROR,"Warning: The Power State Coordination Interface (PSCI) is not supported"

+                           "by your platform Trusted Firmware.\n"));

+      }

+    }

+  }

+

+  //

+  // Sanity checks on the original FDT blob.

+  //

   err = fdt_check_header ((VOID*)(UINTN)(*FdtBlobBase));

   if (err != 0) {

     Print (L"ERROR: Device Tree header not valid (err:%d)\n", err);

     return EFI_INVALID_PARAMETER;

   }

 

+  // The original FDT blob might have been loaded partially.

+  // Check that it is not the case.

+  OriginalFdtSize = (UINTN)fdt_totalsize ((VOID*)(UINTN)(*FdtBlobBase));

+  if (OriginalFdtSize > *FdtBlobSize) {

+    Print (L"ERROR: Incomplete FDT. Only %d/%d bytes have been loaded.\n",

+           *FdtBlobSize, OriginalFdtSize);

+    return EFI_INVALID_PARAMETER;

+  }

+

   //

   // Allocate memory for the new FDT

   //

-  NewFdtBlobSize = fdt_totalsize((VOID*)(UINTN)(*FdtBlobBase)) + FDT_ADDITIONAL_ENTRIES_SIZE;

+  NewFdtBlobSize = OriginalFdtSize + FDT_ADDITIONAL_ENTRIES_SIZE;

 

   // Try below a watermark address

   Status = EFI_NOT_FOUND;

@@ -222,7 +310,7 @@ PrepareFdt (
     Status = gBS->AllocatePages (AllocateAnyPages, EfiBootServicesData, EFI_SIZE_TO_PAGES(NewFdtBlobSize), &NewFdtBlobBase);

     if (EFI_ERROR(Status)) {

       ASSERT_EFI_ERROR(Status);

-      goto FAIL_NEW_FDT;

+      goto FAIL_ALLOCATE_NEW_FDT;

     } else {

       DEBUG ((EFI_D_WARN, "WARNING: Loaded FDT at random address 0x%lX.\nWARNING: There is a risk of accidental overwriting by other code/data.\n", NewFdtBlobBase));

     }

@@ -259,7 +347,9 @@ PrepareFdt (
     }

   DEBUG_CODE_END();

 

+  //

   // Set Linux CmdLine

+  //

   if ((CommandLineArguments != NULL) && (AsciiStrLen (CommandLineArguments) > 0)) {

     err = fdt_setprop(fdt, node, "bootargs", CommandLineArguments, AsciiStrSize(CommandLineArguments));

     if (err) {

@@ -267,7 +357,9 @@ PrepareFdt (
     }

   }

 

+  //

   // Set Linux Initrd

+  //

   if (InitrdImageSize != 0) {

     InitrdImageStart = cpu_to_fdt64 (InitrdImage);

     err = fdt_setprop(fdt, node, "linux,initrd-start", &InitrdImageStart, sizeof(EFI_PHYSICAL_ADDRESS));

@@ -281,7 +373,9 @@ PrepareFdt (
     }

   }

 

+  //

   // Set Physical memory setup if does not exist

+  //

   node = fdt_subnode_offset(fdt, 0, "memory");

   if (node < 0) {

     // The 'memory' node does not exist, create it

@@ -289,10 +383,10 @@ PrepareFdt (
     if (node >= 0) {

       fdt_setprop_string(fdt, node, "name", "memory");

       fdt_setprop_string(fdt, node, "device_type", "memory");

-      

+

       GetSystemMemoryResources (&ResourceList);

       Resource = (BDS_SYSTEM_MEMORY_RESOURCE*)ResourceList.ForwardLink;

-      

+

       if (sizeof(UINTN) == sizeof(UINT32)) {

         Region.Base = cpu_to_fdt32((UINTN)Resource->PhysicalStart);

         Region.Size = cpu_to_fdt32((UINTN)Resource->ResourceLength);

@@ -308,7 +402,39 @@ PrepareFdt (
     }

   }

 

+  //

+  // Add the memory regions reserved by the UEFI Firmware

+  //

+

+  // Retrieve the UEFI Memory Map

+  MemoryMap = NULL;

+  MemoryMapSize = 0;

+  Status = gBS->GetMemoryMap (&MemoryMapSize, MemoryMap, &MapKey, &DescriptorSize, &DescriptorVersion);

+  if (Status == EFI_BUFFER_TOO_SMALL) {

+    Pages = EFI_SIZE_TO_PAGES (MemoryMapSize) + 1;

+    MemoryMap = AllocatePages (Pages);

+    Status = gBS->GetMemoryMap (&MemoryMapSize, MemoryMap, &MapKey, &DescriptorSize, &DescriptorVersion);

+  }

+

+  // Go through the list and add the reserved region to the Device Tree

+  if (!EFI_ERROR(Status)) {

+    for (Index = 0; Index < (MemoryMapSize / sizeof(EFI_MEMORY_DESCRIPTOR)); Index++) {

+      if (IsLinuxReservedRegion ((EFI_MEMORY_TYPE)MemoryMap[Index].Type)) {

+        DEBUG((DEBUG_VERBOSE, "Reserved region of type %d [0x%X, 0x%X]\n",

+            MemoryMap[Index].Type,

+            (UINTN)MemoryMap[Index].PhysicalStart,

+            (UINTN)(MemoryMap[Index].PhysicalStart + MemoryMap[Index].NumberOfPages * EFI_PAGE_SIZE)));

+        err = fdt_add_mem_rsv(fdt, MemoryMap[Index].PhysicalStart, MemoryMap[Index].NumberOfPages * EFI_PAGE_SIZE);

+        if (err != 0) {

+          Print(L"Warning: Fail to add 'memreserve' (err:%d)\n", err);

+        }

+      }

+    }

+  }

+

+  //

   // Setup Arm Mpcore Info if it is a multi-core or multi-cluster platforms

+  //

   for (Index=0; Index < gST->NumberOfTableEntries; Index++) {

     // Check for correct GUID type

     if (CompareGuid (&gArmMpCoreInfoGuid, &(gST->ConfigurationTable[Index].VendorGuid))) {

@@ -338,28 +464,68 @@ PrepareFdt (
           fdt_setprop(fdt, cpu_node, "reg", &Index, sizeof(Index));

         }

 

-        fdt_setprop_string(fdt, cpu_node, "enable-method", "spin-table");

-        CpuReleaseAddr = cpu_to_fdt64(ArmCoreInfoTable[Index].MailboxSetAddress);

-        fdt_setprop(fdt, cpu_node, "cpu-release-addr", &CpuReleaseAddr, sizeof(CpuReleaseAddr));

-

-        // If it is not the primary core than the cpu should be disabled

-        if (((ArmCoreInfoTable[Index].ClusterId != ClusterId) || (ArmCoreInfoTable[Index].CoreId != CoreId))) {

-          fdt_setprop_string(fdt, cpu_node, "status", "disabled");

+        // If Power State Coordination Interface (PSCI) is not supported then it is expected the secondary

+        // cores are spinning waiting for the Operating System to release them

+        if (PsciSmcSupported == FALSE) {

+          // We as the bootloader are responsible for either creating or updating

+          // these entries. Do not trust the entries in the DT. We only know about

+          // 'spin-table' type. Do not try to update other types if defined.

+          Method = fdt_getprop(fdt, cpu_node, "enable-method", &lenp);

+          if ( (Method == NULL) || (!AsciiStrCmp((CHAR8 *)Method, "spin-table")) ) {

+            fdt_setprop_string(fdt, cpu_node, "enable-method", "spin-table");

+            CpuReleaseAddr = cpu_to_fdt64(ArmCoreInfoTable[Index].MailboxSetAddress);

+            fdt_setprop(fdt, cpu_node, "cpu-release-addr", &CpuReleaseAddr, sizeof(CpuReleaseAddr));

+

+            // If it is not the primary core than the cpu should be disabled

+            if (((ArmCoreInfoTable[Index].ClusterId != ClusterId) || (ArmCoreInfoTable[Index].CoreId != CoreId))) {

+              fdt_setprop_string(fdt, cpu_node, "status", "disabled");

+            }

+          } else {

+            Print(L"Warning: Unsupported enable-method type for CPU[%d] : %a\n", Index, (CHAR8 *)Method);

+          }

         }

       }

       break;

     }

   }

 

+  // If the Power State Coordination Interface is supported then we signal it in the Device Tree

+  if (PsciSmcSupported == TRUE) {

+    // Before to create it we check if the node is not already defined in the Device Tree

+    node = fdt_subnode_offset(fdt, 0, "psci");

+    if (node < 0) {

+      // The 'psci' node does not exist, create it

+      node = fdt_add_subnode(fdt, 0, "psci");

+      if (node < 0) {

+        DEBUG((EFI_D_ERROR,"Error on creating 'psci' node\n"));

+        Status = EFI_INVALID_PARAMETER;

+        goto FAIL_NEW_FDT;

+      } else {

+        fdt_setprop_string(fdt, node, "compatible", "arm,psci");

+        fdt_setprop_string(fdt, node, "method", "smc");

+        fdt_setprop_cell(fdt, node, "cpu_suspend", ARM_SMC_ARM_CPU_SUSPEND);

+        fdt_setprop_cell(fdt, node, "cpu_off", ARM_SMC_ARM_CPU_OFF);

+        fdt_setprop_cell(fdt, node, "cpu_on", ARM_SMC_ARM_CPU_ON);

+        fdt_setprop_cell(fdt, node, "cpu_migrate", ARM_SMC_ARM_MIGRATE);

+      }

+    }

+  }

+

   DEBUG_CODE_BEGIN();

     //DebugDumpFdt (fdt);

   DEBUG_CODE_END();

 

+  // If we succeeded to generate the new Device Tree then free the old Device Tree

+  gBS->FreePages (*FdtBlobBase, EFI_SIZE_TO_PAGES (*FdtBlobSize));

+

   *FdtBlobBase = NewFdtBlobBase;

   *FdtBlobSize = (UINTN)fdt_totalsize ((VOID*)(UINTN)(NewFdtBlobBase));

   return EFI_SUCCESS;

 

 FAIL_NEW_FDT:

+  gBS->FreePages (NewFdtBlobBase, EFI_SIZE_TO_PAGES (NewFdtBlobSize));

+

+FAIL_ALLOCATE_NEW_FDT:

   *FdtBlobSize = (UINTN)fdt_totalsize ((VOID*)(UINTN)(*FdtBlobBase));

   // Return success even if we failed to update the FDT blob. The original one is still valid.

   return EFI_SUCCESS;

diff --git a/ArmPkg/Library/BdsLib/BdsLinuxLoader.h b/ArmPkg/Library/BdsLib/BdsLinuxLoader.h
index a9b7037d..09b212f3 100644
--- a/ArmPkg/Library/BdsLib/BdsLinuxLoader.h
+++ b/ArmPkg/Library/BdsLib/BdsLinuxLoader.h
@@ -1,156 +1,156 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-#ifndef __BDSLINUXLOADER_H
-#define __BDSLINUXLOADER_H
-
-#define LINUX_UIMAGE_SIGNATURE    0x56190527
-#define LINUX_KERNEL_MAX_OFFSET   (PcdGet32(PcdSystemMemoryBase) + PcdGet32(PcdArmLinuxKernelMaxOffset))
-#define LINUX_ATAG_MAX_OFFSET     (PcdGet32(PcdSystemMemoryBase) + PcdGet32(PcdArmLinuxAtagMaxOffset))
-#define LINUX_FDT_MAX_OFFSET      (PcdGet32(PcdSystemMemoryBase) + PcdGet32(PcdArmLinuxFdtMaxOffset))
-
-// Additional size that could be used for FDT entries added by the UEFI OS Loader
-// Estimation based on: EDID (300bytes) + bootargs (200bytes) + initrd region (20bytes)
-//                      + system memory region (20bytes) + mp_core entries (200 bytes)
-#define FDT_ADDITIONAL_ENTRIES_SIZE     0x300
-
-#define ARM_FDT_MACHINE_TYPE            0xFFFFFFFF
-
-typedef VOID (*LINUX_KERNEL)(UINT32 Zero, UINT32 Arch, UINTN ParametersBase);
-
-//
-// ATAG Definitions
-//
-
-#define ATAG_MAX_SIZE        0x3000
-
-/* ATAG : list of possible tags */
-#define ATAG_NONE            0x00000000
-#define ATAG_CORE            0x54410001
-#define ATAG_MEM             0x54410002
-#define ATAG_VIDEOTEXT       0x54410003
-#define ATAG_RAMDISK         0x54410004
-#define ATAG_INITRD2         0x54420005
-#define ATAG_SERIAL          0x54410006
-#define ATAG_REVISION        0x54410007
-#define ATAG_VIDEOLFB        0x54410008
-#define ATAG_CMDLINE         0x54410009
-#define ATAG_ARM_MP_CORE     0x5441000A
-
-#define next_tag_address(t)  ((LINUX_ATAG*)((UINT32)(t) + (((t)->header.size) << 2) ))
-#define tag_size(type)       ((UINT32)((sizeof(LINUX_ATAG_HEADER) + sizeof(type)) >> 2))
-
-typedef struct {
-  UINT32  size; /* length of tag in words including this header */
-  UINT32  type;  /* tag type */
-} LINUX_ATAG_HEADER;
-
-typedef struct {
-  UINT32  flags;
-  UINT32  pagesize;
-  UINT32  rootdev;
-} LINUX_ATAG_CORE;
-
-typedef struct {
-  UINT32  size;
-  UINTN  start;
-} LINUX_ATAG_MEM;
-
-typedef struct {
-  UINT8   x;
-  UINT8   y;
-  UINT16  video_page;
-  UINT8   video_mode;
-  UINT8   video_cols;
-  UINT16  video_ega_bx;
-  UINT8   video_lines;
-  UINT8   video_isvga;
-  UINT16  video_points;
-} LINUX_ATAG_VIDEOTEXT;
-
-typedef struct {
-  UINT32  flags;
-  UINT32  size;
-  UINTN  start;
-} LINUX_ATAG_RAMDISK;
-
-typedef struct {
-  UINT32  start;
-  UINT32  size;
-} LINUX_ATAG_INITRD2;
-
-typedef struct {
-  UINT32  low;
-  UINT32  high;
-} LINUX_ATAG_SERIALNR;
-
-typedef struct {
-  UINT32  rev;
-} LINUX_ATAG_REVISION;
-
-typedef struct {
-  UINT16  lfb_width;
-  UINT16  lfb_height;
-  UINT16  lfb_depth;
-  UINT16  lfb_linelength;
-  UINT32  lfb_base;
-  UINT32  lfb_size;
-  UINT8   red_size;
-  UINT8   red_pos;
-  UINT8   green_size;
-  UINT8   green_pos;
-  UINT8   blue_size;
-  UINT8   blue_pos;
-  UINT8   rsvd_size;
-  UINT8   rsvd_pos;
-} LINUX_ATAG_VIDEOLFB;
-
-typedef struct {
-  CHAR8   cmdline[1];
-} LINUX_ATAG_CMDLINE;
-
-typedef struct {
-  LINUX_ATAG_HEADER header;
-  union {
-    LINUX_ATAG_CORE         core_tag;
-    LINUX_ATAG_MEM          mem_tag;
-    LINUX_ATAG_VIDEOTEXT    videotext_tag;
-    LINUX_ATAG_RAMDISK      ramdisk_tag;
-    LINUX_ATAG_INITRD2      initrd2_tag;
-    LINUX_ATAG_SERIALNR     serialnr_tag;
-    LINUX_ATAG_REVISION     revision_tag;
-    LINUX_ATAG_VIDEOLFB     videolfb_tag;
-    LINUX_ATAG_CMDLINE      cmdline_tag;
-  } body;
-} LINUX_ATAG;
-
-EFI_STATUS
-PrepareAtagList (
-  IN  CONST CHAR8*          CommandLineString,
-  IN  EFI_PHYSICAL_ADDRESS  InitrdImage,
-  IN  UINTN                 InitrdImageSize,
-  OUT EFI_PHYSICAL_ADDRESS  *AtagBase,
-  OUT UINT32                *AtagSize
-  );
-
-EFI_STATUS
-PrepareFdt (
-  IN     CONST CHAR8*         CommandLineArguments,
-  IN     EFI_PHYSICAL_ADDRESS InitrdImage,
-  IN     UINTN                InitrdImageSize,
-  IN OUT EFI_PHYSICAL_ADDRESS *FdtBlobBase,
-  IN OUT UINT32               *FdtBlobSize
-  );
-
-#endif
+/** @file

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+#ifndef __BDSLINUXLOADER_H

+#define __BDSLINUXLOADER_H

+

+#define LINUX_UIMAGE_SIGNATURE    0x56190527

+#define LINUX_KERNEL_MAX_OFFSET   (PcdGet32(PcdSystemMemoryBase) + PcdGet32(PcdArmLinuxKernelMaxOffset))

+#define LINUX_ATAG_MAX_OFFSET     (PcdGet32(PcdSystemMemoryBase) + PcdGet32(PcdArmLinuxAtagMaxOffset))

+#define LINUX_FDT_MAX_OFFSET      (PcdGet32(PcdSystemMemoryBase) + PcdGet32(PcdArmLinuxFdtMaxOffset))

+

+// Additional size that could be used for FDT entries added by the UEFI OS Loader

+// Estimation based on: EDID (300bytes) + bootargs (200bytes) + initrd region (20bytes)

+//                      + system memory region (20bytes) + mp_core entries (200 bytes)

+#define FDT_ADDITIONAL_ENTRIES_SIZE     0x300

+

+#define ARM_FDT_MACHINE_TYPE            0xFFFFFFFF

+

+typedef VOID (*LINUX_KERNEL)(UINT32 Zero, UINT32 Arch, UINTN ParametersBase);

+

+//

+// ATAG Definitions

+//

+

+#define ATAG_MAX_SIZE        0x3000

+

+/* ATAG : list of possible tags */

+#define ATAG_NONE            0x00000000

+#define ATAG_CORE            0x54410001

+#define ATAG_MEM             0x54410002

+#define ATAG_VIDEOTEXT       0x54410003

+#define ATAG_RAMDISK         0x54410004

+#define ATAG_INITRD2         0x54420005

+#define ATAG_SERIAL          0x54410006

+#define ATAG_REVISION        0x54410007

+#define ATAG_VIDEOLFB        0x54410008

+#define ATAG_CMDLINE         0x54410009

+#define ATAG_ARM_MP_CORE     0x5441000A

+

+#define next_tag_address(t)  ((LINUX_ATAG*)((UINT32)(t) + (((t)->header.size) << 2) ))

+#define tag_size(type)       ((UINT32)((sizeof(LINUX_ATAG_HEADER) + sizeof(type)) >> 2))

+

+typedef struct {

+  UINT32  size; /* length of tag in words including this header */

+  UINT32  type;  /* tag type */

+} LINUX_ATAG_HEADER;

+

+typedef struct {

+  UINT32  flags;

+  UINT32  pagesize;

+  UINT32  rootdev;

+} LINUX_ATAG_CORE;

+

+typedef struct {

+  UINT32  size;

+  UINTN  start;

+} LINUX_ATAG_MEM;

+

+typedef struct {

+  UINT8   x;

+  UINT8   y;

+  UINT16  video_page;

+  UINT8   video_mode;

+  UINT8   video_cols;

+  UINT16  video_ega_bx;

+  UINT8   video_lines;

+  UINT8   video_isvga;

+  UINT16  video_points;

+} LINUX_ATAG_VIDEOTEXT;

+

+typedef struct {

+  UINT32  flags;

+  UINT32  size;

+  UINTN  start;

+} LINUX_ATAG_RAMDISK;

+

+typedef struct {

+  UINT32  start;

+  UINT32  size;

+} LINUX_ATAG_INITRD2;

+

+typedef struct {

+  UINT32  low;

+  UINT32  high;

+} LINUX_ATAG_SERIALNR;

+

+typedef struct {

+  UINT32  rev;

+} LINUX_ATAG_REVISION;

+

+typedef struct {

+  UINT16  lfb_width;

+  UINT16  lfb_height;

+  UINT16  lfb_depth;

+  UINT16  lfb_linelength;

+  UINT32  lfb_base;

+  UINT32  lfb_size;

+  UINT8   red_size;

+  UINT8   red_pos;

+  UINT8   green_size;

+  UINT8   green_pos;

+  UINT8   blue_size;

+  UINT8   blue_pos;

+  UINT8   rsvd_size;

+  UINT8   rsvd_pos;

+} LINUX_ATAG_VIDEOLFB;

+

+typedef struct {

+  CHAR8   cmdline[1];

+} LINUX_ATAG_CMDLINE;

+

+typedef struct {

+  LINUX_ATAG_HEADER header;

+  union {

+    LINUX_ATAG_CORE         core_tag;

+    LINUX_ATAG_MEM          mem_tag;

+    LINUX_ATAG_VIDEOTEXT    videotext_tag;

+    LINUX_ATAG_RAMDISK      ramdisk_tag;

+    LINUX_ATAG_INITRD2      initrd2_tag;

+    LINUX_ATAG_SERIALNR     serialnr_tag;

+    LINUX_ATAG_REVISION     revision_tag;

+    LINUX_ATAG_VIDEOLFB     videolfb_tag;

+    LINUX_ATAG_CMDLINE      cmdline_tag;

+  } body;

+} LINUX_ATAG;

+

+EFI_STATUS

+PrepareAtagList (

+  IN  CONST CHAR8*          CommandLineString,

+  IN  EFI_PHYSICAL_ADDRESS  InitrdImage,

+  IN  UINTN                 InitrdImageSize,

+  OUT EFI_PHYSICAL_ADDRESS  *AtagBase,

+  OUT UINT32                *AtagSize

+  );

+

+EFI_STATUS

+PrepareFdt (

+  IN     CONST CHAR8*         CommandLineArguments,

+  IN     EFI_PHYSICAL_ADDRESS InitrdImage,

+  IN     UINTN                InitrdImageSize,

+  IN OUT EFI_PHYSICAL_ADDRESS *FdtBlobBase,

+  IN OUT UINTN                *FdtBlobSize

+  );

+

+#endif

diff --git a/ArmPkg/Library/BdsLib/BdsLoadOption.c b/ArmPkg/Library/BdsLib/BdsLoadOption.c
index 8abbc9b5..be5ed419 100644
--- a/ArmPkg/Library/BdsLib/BdsLoadOption.c
+++ b/ArmPkg/Library/BdsLib/BdsLoadOption.c
@@ -1,270 +1,270 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*
-*  This program and the accompanying materials
-*  are licensed and made available under the terms and conditions of the BSD License
-*  which accompanies this distribution.  The full text of the license may be found at
-*  http://opensource.org/licenses/bsd-license.php
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-*
-**/
-
-#include "BdsInternal.h"
-
-EFI_STATUS
-BootOptionParseLoadOption (
-  IN     EFI_LOAD_OPTION EfiLoadOption,
-  IN     UINTN           EfiLoadOptionSize,
-  IN OUT BDS_LOAD_OPTION **BdsLoadOption
-  )
-{
-  BDS_LOAD_OPTION *LoadOption;
-  UINTN           DescriptionLength;
-
-  if (EfiLoadOption == NULL) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  if (EfiLoadOptionSize < sizeof(UINT32) + sizeof(UINT16) + sizeof(CHAR16) + sizeof(EFI_DEVICE_PATH_PROTOCOL)) {
-    return EFI_BAD_BUFFER_SIZE;
-  }
-
-  if (*BdsLoadOption == NULL) {
-    LoadOption = (BDS_LOAD_OPTION*)AllocateZeroPool (sizeof(BDS_LOAD_OPTION));
-    if (LoadOption == NULL) {
-      return EFI_OUT_OF_RESOURCES;
-    }
-  } else {
-    LoadOption = *BdsLoadOption;
-  }
-
-  LoadOption->LoadOption     = EfiLoadOption;
-  LoadOption->LoadOptionSize = EfiLoadOptionSize;
-
-  LoadOption->Attributes         = *(UINT32*)EfiLoadOption;
-  LoadOption->FilePathListLength = *(UINT16*)(EfiLoadOption + sizeof(UINT32));
-  LoadOption->Description        = (CHAR16*)(EfiLoadOption + sizeof(UINT32) + sizeof(UINT16));
-  DescriptionLength              = StrSize (LoadOption->Description);
-  LoadOption->FilePathList       = (EFI_DEVICE_PATH_PROTOCOL*)(EfiLoadOption + sizeof(UINT32) + sizeof(UINT16) + DescriptionLength);
-
-  // If ((End of EfiLoadOptiony - Start of EfiLoadOption) == EfiLoadOptionSize) then No Optional Data
-  if ((UINTN)((UINTN)LoadOption->FilePathList + LoadOption->FilePathListLength - (UINTN)EfiLoadOption) == EfiLoadOptionSize) {
-    LoadOption->OptionalData     = NULL;
-    LoadOption->OptionalDataSize = 0;
-  } else {
-    LoadOption->OptionalData     = (VOID*)((UINTN)(LoadOption->FilePathList) + LoadOption->FilePathListLength);
-    LoadOption->OptionalDataSize = EfiLoadOptionSize - ((UINTN)LoadOption->OptionalData - (UINTN)EfiLoadOption);
-  }
-
-  if (*BdsLoadOption == NULL) {
-    *BdsLoadOption = LoadOption;
-  }
-
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-BootOptionFromLoadOptionVariable (
-  IN  CHAR16*           BootVariableName,
-  OUT BDS_LOAD_OPTION** BdsLoadOption
-  )
-{
-  EFI_STATUS            Status;
-  EFI_LOAD_OPTION       EfiLoadOption;
-  UINTN                 EfiLoadOptionSize;
-
-  Status = GetEnvironmentVariable (BootVariableName, NULL, &EfiLoadOptionSize, (VOID**)&EfiLoadOption);
-  if (!EFI_ERROR(Status)) {
-    *BdsLoadOption = NULL;
-    Status = BootOptionParseLoadOption (EfiLoadOption, EfiLoadOptionSize, BdsLoadOption);
-  }
-
-  return Status;
-}
-
-EFI_STATUS
-BootOptionFromLoadOptionIndex (
-  IN  UINT16            LoadOptionIndex,
-  OUT BDS_LOAD_OPTION **BdsLoadOption
-  )
-{
-  CHAR16        BootVariableName[9];
-  EFI_STATUS    Status;
-
-  UnicodeSPrint (BootVariableName, 9 * sizeof(CHAR16), L"Boot%04X", LoadOptionIndex);
-
-  Status = BootOptionFromLoadOptionVariable (BootVariableName, BdsLoadOption);
-  if (!EFI_ERROR(Status)) {
-    (*BdsLoadOption)->LoadOptionIndex = LoadOptionIndex;
-  }
-
-  return Status;
-}
-
-EFI_STATUS
-BootOptionToLoadOptionVariable (
-  IN BDS_LOAD_OPTION*   BdsLoadOption
-  )
-{
-  EFI_STATUS                    Status;
-  UINTN                         DescriptionSize;
-  //UINT16                        FilePathListLength;
-  EFI_DEVICE_PATH_PROTOCOL*     DevicePathNode;
-  UINTN                         NodeLength;
-  UINT8*                        EfiLoadOptionPtr;
-  VOID*                         OldLoadOption;
-  CHAR16                        BootVariableName[9];
-  UINTN                         BootOrderSize;
-  UINT16*                       BootOrder;
-
-  // If we are overwriting an existent Boot Option then we have to free previously allocated memory
-  if (BdsLoadOption->LoadOptionSize > 0) {
-    OldLoadOption = BdsLoadOption->LoadOption;
-  } else {
-    OldLoadOption = NULL;
-
-    // If this function is called at the creation of the Boot Device entry (not at the update) the
-    // BootOption->LoadOptionSize must be zero then we get a new BootIndex for this entry
-    BdsLoadOption->LoadOptionIndex = BootOptionAllocateBootIndex ();
-
-    //TODO: Add to the the Boot Entry List
-  }
-
-  DescriptionSize = StrSize(BdsLoadOption->Description);
-
-  // Ensure the FilePathListLength information is correct
-  ASSERT (GetDevicePathSize (BdsLoadOption->FilePathList) == BdsLoadOption->FilePathListLength);
-
-  // Allocate the memory for the EFI Load Option
-  BdsLoadOption->LoadOptionSize = sizeof(UINT32) + sizeof(UINT16) + DescriptionSize + BdsLoadOption->FilePathListLength + BdsLoadOption->OptionalDataSize;
-
-  BdsLoadOption->LoadOption = (EFI_LOAD_OPTION)AllocateZeroPool (BdsLoadOption->LoadOptionSize);
-  if (BdsLoadOption->LoadOption == NULL) {
-    return EFI_OUT_OF_RESOURCES;
-  }
-
-  EfiLoadOptionPtr = BdsLoadOption->LoadOption;
-
-  //
-  // Populate the EFI Load Option and BDS Boot Option structures
-  //
-
-  // Attributes fields
-  *(UINT32*)EfiLoadOptionPtr = BdsLoadOption->Attributes;
-  EfiLoadOptionPtr += sizeof(UINT32);
-
-  // FilePath List fields
-  *(UINT16*)EfiLoadOptionPtr = BdsLoadOption->FilePathListLength;
-  EfiLoadOptionPtr += sizeof(UINT16);
-
-  // Boot description fields
-  CopyMem (EfiLoadOptionPtr, BdsLoadOption->Description, DescriptionSize);
-  EfiLoadOptionPtr += DescriptionSize;
-
-  // File path fields
-  DevicePathNode = BdsLoadOption->FilePathList;
-  while (!IsDevicePathEndType (DevicePathNode)) {
-    NodeLength = DevicePathNodeLength(DevicePathNode);
-    CopyMem (EfiLoadOptionPtr, DevicePathNode, NodeLength);
-    EfiLoadOptionPtr += NodeLength;
-    DevicePathNode = NextDevicePathNode (DevicePathNode);
-  }
-
-  // Set the End Device Path Type
-  SetDevicePathEndNode (EfiLoadOptionPtr);
-  EfiLoadOptionPtr += sizeof(EFI_DEVICE_PATH);
-
-  // Fill the Optional Data
-  if (BdsLoadOption->OptionalDataSize > 0) {
-    CopyMem (EfiLoadOptionPtr, BdsLoadOption->OptionalData, BdsLoadOption->OptionalDataSize);
-  }
-
-  // Case where the fields have been updated
-  if (OldLoadOption) {
-    // Now, the old data has been copied to the new allocated packed structure, we need to update the pointers of BdsLoadOption
-    BootOptionParseLoadOption (BdsLoadOption->LoadOption, BdsLoadOption->LoadOptionSize, &BdsLoadOption);
-    // Free the old packed structure
-    FreePool (OldLoadOption);
-  }
-
-  // Create/Update Boot#### environment variable
-  UnicodeSPrint (BootVariableName, 9 * sizeof(CHAR16), L"Boot%04X", BdsLoadOption->LoadOptionIndex);
-  Status = gRT->SetVariable (
-      BootVariableName,
-      &gEfiGlobalVariableGuid,
-      EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
-      BdsLoadOption->LoadOptionSize,
-      BdsLoadOption->LoadOption
-      );
-
-  // When it is a new entry we must add the entry to the BootOrder
-  if (OldLoadOption == NULL) {
-    // Add the new Boot Index to the list
-    Status = GetEnvironmentVariable (L"BootOrder", NULL, &BootOrderSize, (VOID**)&BootOrder);
-    if (!EFI_ERROR(Status)) {
-      BootOrder = ReallocatePool (BootOrderSize, BootOrderSize + sizeof(UINT16), BootOrder);
-      // Add the new index at the end
-      BootOrder[BootOrderSize / sizeof(UINT16)] = BdsLoadOption->LoadOptionIndex;
-      BootOrderSize += sizeof(UINT16);
-    } else {
-      // BootOrder does not exist. Create it
-      BootOrderSize = sizeof(UINT16);
-      BootOrder = &(BdsLoadOption->LoadOptionIndex);
-    }
-
-    // Update (or Create) the BootOrder environment variable
-    gRT->SetVariable (
-        L"BootOrder",
-        &gEfiGlobalVariableGuid,
-        EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
-        BootOrderSize,
-        BootOrder
-        );
-    DEBUG((EFI_D_ERROR,"Create %s\n",BootVariableName));
-
-    // Free memory allocated by GetEnvironmentVariable
-    if (!EFI_ERROR(Status)) {
-      FreePool (BootOrder);
-    }
-  } else {
-    DEBUG((EFI_D_ERROR,"Update %s\n",BootVariableName));
-  }
-
-  return EFI_SUCCESS;
-}
-
-UINT16
-BootOptionAllocateBootIndex (
-  VOID
-  )
-{
-  EFI_STATUS        Status;
-  UINTN             Index;
-  UINT32            BootIndex;
-  UINT16            *BootOrder;
-  UINTN             BootOrderSize;
-  BOOLEAN           Found;
-
-  // Get the Boot Option Order from the environment variable
-  Status = GetEnvironmentVariable (L"BootOrder", NULL, &BootOrderSize, (VOID**)&BootOrder);
-  if (!EFI_ERROR(Status)) {
-    for (BootIndex = 0; BootIndex <= 0xFFFF; BootIndex++) {
-      Found = FALSE;
-      for (Index = 0; Index < BootOrderSize / sizeof (UINT16); Index++) {
-        if (BootOrder[Index] == BootIndex) {
-          Found = TRUE;
-          break;
-        }
-      }
-      if (!Found) {
-        return BootIndex;
-      }
-    }
-    FreePool (BootOrder);
-  }
-  // Return the first index
-  return 0;
-}
+/** @file

+*

+*  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

+*

+*  This program and the accompanying materials

+*  are licensed and made available under the terms and conditions of the BSD License

+*  which accompanies this distribution.  The full text of the license may be found at

+*  http://opensource.org/licenses/bsd-license.php

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+*

+**/

+

+#include "BdsInternal.h"

+

+EFI_STATUS

+BootOptionParseLoadOption (

+  IN     EFI_LOAD_OPTION EfiLoadOption,

+  IN     UINTN           EfiLoadOptionSize,

+  IN OUT BDS_LOAD_OPTION **BdsLoadOption

+  )

+{

+  BDS_LOAD_OPTION *LoadOption;

+  UINTN           DescriptionLength;

+

+  if (EfiLoadOption == NULL) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  if (EfiLoadOptionSize < sizeof(UINT32) + sizeof(UINT16) + sizeof(CHAR16) + sizeof(EFI_DEVICE_PATH_PROTOCOL)) {

+    return EFI_BAD_BUFFER_SIZE;

+  }

+

+  if (*BdsLoadOption == NULL) {

+    LoadOption = (BDS_LOAD_OPTION*)AllocateZeroPool (sizeof(BDS_LOAD_OPTION));

+    if (LoadOption == NULL) {

+      return EFI_OUT_OF_RESOURCES;

+    }

+  } else {

+    LoadOption = *BdsLoadOption;

+  }

+

+  LoadOption->LoadOption     = EfiLoadOption;

+  LoadOption->LoadOptionSize = EfiLoadOptionSize;

+

+  LoadOption->Attributes         = *(UINT32*)EfiLoadOption;

+  LoadOption->FilePathListLength = *(UINT16*)(EfiLoadOption + sizeof(UINT32));

+  LoadOption->Description        = (CHAR16*)(EfiLoadOption + sizeof(UINT32) + sizeof(UINT16));

+  DescriptionLength              = StrSize (LoadOption->Description);

+  LoadOption->FilePathList       = (EFI_DEVICE_PATH_PROTOCOL*)(EfiLoadOption + sizeof(UINT32) + sizeof(UINT16) + DescriptionLength);

+

+  // If ((End of EfiLoadOptiony - Start of EfiLoadOption) == EfiLoadOptionSize) then No Optional Data

+  if ((UINTN)((UINTN)LoadOption->FilePathList + LoadOption->FilePathListLength - (UINTN)EfiLoadOption) == EfiLoadOptionSize) {

+    LoadOption->OptionalData     = NULL;

+    LoadOption->OptionalDataSize = 0;

+  } else {

+    LoadOption->OptionalData     = (VOID*)((UINTN)(LoadOption->FilePathList) + LoadOption->FilePathListLength);

+    LoadOption->OptionalDataSize = EfiLoadOptionSize - ((UINTN)LoadOption->OptionalData - (UINTN)EfiLoadOption);

+  }

+

+  if (*BdsLoadOption == NULL) {

+    *BdsLoadOption = LoadOption;

+  }

+

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+BootOptionFromLoadOptionVariable (

+  IN  CHAR16*           BootVariableName,

+  OUT BDS_LOAD_OPTION** BdsLoadOption

+  )

+{

+  EFI_STATUS            Status;

+  EFI_LOAD_OPTION       EfiLoadOption;

+  UINTN                 EfiLoadOptionSize;

+

+  Status = GetGlobalEnvironmentVariable (BootVariableName, NULL, &EfiLoadOptionSize, (VOID**)&EfiLoadOption);

+  if (!EFI_ERROR(Status)) {

+    *BdsLoadOption = NULL;

+    Status = BootOptionParseLoadOption (EfiLoadOption, EfiLoadOptionSize, BdsLoadOption);

+  }

+

+  return Status;

+}

+

+EFI_STATUS

+BootOptionFromLoadOptionIndex (

+  IN  UINT16            LoadOptionIndex,

+  OUT BDS_LOAD_OPTION **BdsLoadOption

+  )

+{

+  CHAR16        BootVariableName[9];

+  EFI_STATUS    Status;

+

+  UnicodeSPrint (BootVariableName, 9 * sizeof(CHAR16), L"Boot%04X", LoadOptionIndex);

+

+  Status = BootOptionFromLoadOptionVariable (BootVariableName, BdsLoadOption);

+  if (!EFI_ERROR(Status)) {

+    (*BdsLoadOption)->LoadOptionIndex = LoadOptionIndex;

+  }

+

+  return Status;

+}

+

+EFI_STATUS

+BootOptionToLoadOptionVariable (

+  IN BDS_LOAD_OPTION*   BdsLoadOption

+  )

+{

+  EFI_STATUS                    Status;

+  UINTN                         DescriptionSize;

+  //UINT16                        FilePathListLength;

+  EFI_DEVICE_PATH_PROTOCOL*     DevicePathNode;

+  UINTN                         NodeLength;

+  UINT8*                        EfiLoadOptionPtr;

+  VOID*                         OldLoadOption;

+  CHAR16                        BootVariableName[9];

+  UINTN                         BootOrderSize;

+  UINT16*                       BootOrder;

+

+  // If we are overwriting an existent Boot Option then we have to free previously allocated memory

+  if (BdsLoadOption->LoadOptionSize > 0) {

+    OldLoadOption = BdsLoadOption->LoadOption;

+  } else {

+    OldLoadOption = NULL;

+

+    // If this function is called at the creation of the Boot Device entry (not at the update) the

+    // BootOption->LoadOptionSize must be zero then we get a new BootIndex for this entry

+    BdsLoadOption->LoadOptionIndex = BootOptionAllocateBootIndex ();

+

+    //TODO: Add to the the Boot Entry List

+  }

+

+  DescriptionSize = StrSize(BdsLoadOption->Description);

+

+  // Ensure the FilePathListLength information is correct

+  ASSERT (GetDevicePathSize (BdsLoadOption->FilePathList) == BdsLoadOption->FilePathListLength);

+

+  // Allocate the memory for the EFI Load Option

+  BdsLoadOption->LoadOptionSize = sizeof(UINT32) + sizeof(UINT16) + DescriptionSize + BdsLoadOption->FilePathListLength + BdsLoadOption->OptionalDataSize;

+

+  BdsLoadOption->LoadOption = (EFI_LOAD_OPTION)AllocateZeroPool (BdsLoadOption->LoadOptionSize);

+  if (BdsLoadOption->LoadOption == NULL) {

+    return EFI_OUT_OF_RESOURCES;

+  }

+

+  EfiLoadOptionPtr = BdsLoadOption->LoadOption;

+

+  //

+  // Populate the EFI Load Option and BDS Boot Option structures

+  //

+

+  // Attributes fields

+  *(UINT32*)EfiLoadOptionPtr = BdsLoadOption->Attributes;

+  EfiLoadOptionPtr += sizeof(UINT32);

+

+  // FilePath List fields

+  *(UINT16*)EfiLoadOptionPtr = BdsLoadOption->FilePathListLength;

+  EfiLoadOptionPtr += sizeof(UINT16);

+

+  // Boot description fields

+  CopyMem (EfiLoadOptionPtr, BdsLoadOption->Description, DescriptionSize);

+  EfiLoadOptionPtr += DescriptionSize;

+

+  // File path fields

+  DevicePathNode = BdsLoadOption->FilePathList;

+  while (!IsDevicePathEndType (DevicePathNode)) {

+    NodeLength = DevicePathNodeLength(DevicePathNode);

+    CopyMem (EfiLoadOptionPtr, DevicePathNode, NodeLength);

+    EfiLoadOptionPtr += NodeLength;

+    DevicePathNode = NextDevicePathNode (DevicePathNode);

+  }

+

+  // Set the End Device Path Type

+  SetDevicePathEndNode (EfiLoadOptionPtr);

+  EfiLoadOptionPtr += sizeof(EFI_DEVICE_PATH);

+

+  // Fill the Optional Data

+  if (BdsLoadOption->OptionalDataSize > 0) {

+    CopyMem (EfiLoadOptionPtr, BdsLoadOption->OptionalData, BdsLoadOption->OptionalDataSize);

+  }

+

+  // Case where the fields have been updated

+  if (OldLoadOption) {

+    // Now, the old data has been copied to the new allocated packed structure, we need to update the pointers of BdsLoadOption

+    BootOptionParseLoadOption (BdsLoadOption->LoadOption, BdsLoadOption->LoadOptionSize, &BdsLoadOption);

+    // Free the old packed structure

+    FreePool (OldLoadOption);

+  }

+

+  // Create/Update Boot#### environment variable

+  UnicodeSPrint (BootVariableName, 9 * sizeof(CHAR16), L"Boot%04X", BdsLoadOption->LoadOptionIndex);

+  Status = gRT->SetVariable (

+      BootVariableName,

+      &gEfiGlobalVariableGuid,

+      EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,

+      BdsLoadOption->LoadOptionSize,

+      BdsLoadOption->LoadOption

+      );

+

+  // When it is a new entry we must add the entry to the BootOrder

+  if (OldLoadOption == NULL) {

+    // Add the new Boot Index to the list

+    Status = GetGlobalEnvironmentVariable (L"BootOrder", NULL, &BootOrderSize, (VOID**)&BootOrder);

+    if (!EFI_ERROR(Status)) {

+      BootOrder = ReallocatePool (BootOrderSize, BootOrderSize + sizeof(UINT16), BootOrder);

+      // Add the new index at the end

+      BootOrder[BootOrderSize / sizeof(UINT16)] = BdsLoadOption->LoadOptionIndex;

+      BootOrderSize += sizeof(UINT16);

+    } else {

+      // BootOrder does not exist. Create it

+      BootOrderSize = sizeof(UINT16);

+      BootOrder = &(BdsLoadOption->LoadOptionIndex);

+    }

+

+    // Update (or Create) the BootOrder environment variable

+    gRT->SetVariable (

+        L"BootOrder",

+        &gEfiGlobalVariableGuid,

+        EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,

+        BootOrderSize,

+        BootOrder

+        );

+    DEBUG((EFI_D_ERROR,"Create %s\n",BootVariableName));

+

+    // Free memory allocated by GetGlobalEnvironmentVariable

+    if (!EFI_ERROR(Status)) {

+      FreePool (BootOrder);

+    }

+  } else {

+    DEBUG((EFI_D_ERROR,"Update %s\n",BootVariableName));

+  }

+

+  return EFI_SUCCESS;

+}

+

+UINT16

+BootOptionAllocateBootIndex (

+  VOID

+  )

+{

+  EFI_STATUS        Status;

+  UINTN             Index;

+  UINT32            BootIndex;

+  UINT16            *BootOrder;

+  UINTN             BootOrderSize;

+  BOOLEAN           Found;

+

+  // Get the Boot Option Order from the environment variable

+  Status = GetGlobalEnvironmentVariable (L"BootOrder", NULL, &BootOrderSize, (VOID**)&BootOrder);

+  if (!EFI_ERROR(Status)) {

+    for (BootIndex = 0; BootIndex <= 0xFFFF; BootIndex++) {

+      Found = FALSE;

+      for (Index = 0; Index < BootOrderSize / sizeof (UINT16); Index++) {

+        if (BootOrder[Index] == BootIndex) {

+          Found = TRUE;

+          break;

+        }

+      }

+      if (!Found) {

+        return BootIndex;

+      }

+    }

+    FreePool (BootOrder);

+  }

+  // Return the first index

+  return 0;

+}

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/Llvm_int_lib.h b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/Llvm_int_lib.h
index eb0a6506..6e42dcd1 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/Llvm_int_lib.h
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/Llvm_int_lib.h
@@ -1,99 +1,99 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-/**
-  University of Illinois/NCSA
-  Open Source License
-  
-  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.
-  All rights reserved.
-  
-  Developed by:
-  
-      LLVM Team
-  
-      University of Illinois at Urbana-Champaign
-  
-      http://llvm.org
-  
-  Permission is hereby granted, free of charge, to any person obtaining a copy of
-  this software and associated documentation files (the "Software"), to deal with
-  the Software without restriction, including without limitation the rights to
-  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-  of the Software, and to permit persons to whom the Software is furnished to do
-  so, subject to the following conditions:
-  
-      * Redistributions of source code must retain the above copyright notice,
-        this list of conditions and the following disclaimers.
-  
-      * Redistributions in binary form must reproduce the above copyright notice,
-        this list of conditions and the following disclaimers in the
-        documentation and/or other materials provided with the distribution.
-  
-      * Neither the names of the LLVM Team, University of Illinois at
-        Urbana-Champaign, nor the names of its contributors may be used to
-        endorse or promote products derived from this Software without specific
-        prior written permission.
-  
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
-  SOFTWARE.
-**/
-
-#include <Base.h>
-#include <Library/DebugLib.h>
-
-#define CHAR_BIT  8
-
-typedef union {
-    INT64   all;
-    struct {
-        UINT32 low;
-        INT32  high;
-    };
-} dwords;
-
-typedef union {
-    UINT64  all;
-    struct {
-        UINT32 low;
-        UINT32 high;
-    };
-} udwords;
-
-// __aeabi_ return values
-typedef struct {
-  UINT64  Quotent;
-  UINT64  Remainder;
-} ulldiv_t;
-
-typedef struct {
-  INT64   Quotent;
-  INT64   Remainder;
-} lldiv_t;
-
-typedef struct {
-  UINT32  Quotent;
-  UINT32  Remainder;
-} uidiv_return;
-
-#if __GNUC__
-  #define COUNT_LEADING_ZEROS(_a)   __builtin_clz((_a))
-  #define COUNT_TRAILING_ZEROS(_a)  __builtin_ctz((_a))
-#else
-#error COUNT_LEADING_ZEROS() and COUNT_TRAILING_ZEROS() macros not ported to your compiler
-#endif
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+/**

+  University of Illinois/NCSA

+  Open Source License

+  

+  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.

+  All rights reserved.

+  

+  Developed by:

+  

+      LLVM Team

+  

+      University of Illinois at Urbana-Champaign

+  

+      http://llvm.org

+  

+  Permission is hereby granted, free of charge, to any person obtaining a copy of

+  this software and associated documentation files (the "Software"), to deal with

+  the Software without restriction, including without limitation the rights to

+  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies

+  of the Software, and to permit persons to whom the Software is furnished to do

+  so, subject to the following conditions:

+  

+      * Redistributions of source code must retain the above copyright notice,

+        this list of conditions and the following disclaimers.

+  

+      * Redistributions in binary form must reproduce the above copyright notice,

+        this list of conditions and the following disclaimers in the

+        documentation and/or other materials provided with the distribution.

+  

+      * Neither the names of the LLVM Team, University of Illinois at

+        Urbana-Champaign, nor the names of its contributors may be used to

+        endorse or promote products derived from this Software without specific

+        prior written permission.

+  

+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE

+  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE

+  SOFTWARE.

+**/

+

+#include <Base.h>

+#include <Library/DebugLib.h>

+

+#define CHAR_BIT  8

+

+typedef union {

+    INT64   all;

+    struct {

+        UINT32 low;

+        INT32  high;

+    };

+} dwords;

+

+typedef union {

+    UINT64  all;

+    struct {

+        UINT32 low;

+        UINT32 high;

+    };

+} udwords;

+

+// __aeabi_ return values

+typedef struct {

+  UINT64  Quotent;

+  UINT64  Remainder;

+} ulldiv_t;

+

+typedef struct {

+  INT64   Quotent;

+  INT64   Remainder;

+} lldiv_t;

+

+typedef struct {

+  UINT32  Quotent;

+  UINT32  Remainder;

+} uidiv_return;

+

+#if __GNUC__

+  #define COUNT_LEADING_ZEROS(_a)   __builtin_clz((_a))

+  #define COUNT_TRAILING_ZEROS(_a)  __builtin_ctz((_a))

+#else

+#error COUNT_LEADING_ZEROS() and COUNT_TRAILING_ZEROS() macros not ported to your compiler

+#endif

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ashldi3.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ashldi3.S
index 55787971..cec0c55f 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ashldi3.S
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ashldi3.S
@@ -1,35 +1,35 @@
-#------------------------------------------------------------------------------ 
-#
-# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-#
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#------------------------------------------------------------------------------
-
-  .text
-  .align 2
-  GCC_ASM_EXPORT(__ashldi3)
-  
-ASM_PFX(__ashldi3):
-  cmp  r2, #31
-  bls  L2
-  cmp  r2, #63
-  subls  r2, r2, #32
-  movls  r2, r0, asl r2
-  movhi  r2, #0
-  mov  r1, r2
-  mov  r0, #0
-  bx  lr
-L2:
-  cmp  r2, #0
-  rsbne  r3, r2, #32
-  movne  r3, r0, lsr r3
-  movne  r0, r0, asl r2
-  orrne  r1, r3, r1, asl r2
-  bx  lr
+#------------------------------------------------------------------------------ 

+#

+# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+  .text

+  .align 2

+  GCC_ASM_EXPORT(__ashldi3)

+  

+ASM_PFX(__ashldi3):

+  cmp  r2, #31

+  bls  L2

+  cmp  r2, #63

+  subls  r2, r2, #32

+  movls  r2, r0, asl r2

+  movhi  r2, #0

+  mov  r1, r2

+  mov  r0, #0

+  bx  lr

+L2:

+  cmp  r2, #0

+  rsbne  r3, r2, #32

+  movne  r3, r0, lsr r3

+  movne  r0, r0, asl r2

+  orrne  r1, r3, r1, asl r2

+  bx  lr

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ashldi3.c b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ashldi3.c
index 80ec5a60..526fcab6 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ashldi3.c
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ashldi3.c
@@ -1,83 +1,83 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-/**
-  University of Illinois/NCSA
-  Open Source License
-  
-  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.
-  All rights reserved.
-  
-  Developed by:
-  
-      LLVM Team
-  
-      University of Illinois at Urbana-Champaign
-  
-      http://llvm.org
-  
-  Permission is hereby granted, free of charge, to any person obtaining a copy of
-  this software and associated documentation files (the "Software"), to deal with
-  the Software without restriction, including without limitation the rights to
-  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-  of the Software, and to permit persons to whom the Software is furnished to do
-  so, subject to the following conditions:
-  
-      * Redistributions of source code must retain the above copyright notice,
-        this list of conditions and the following disclaimers.
-  
-      * Redistributions in binary form must reproduce the above copyright notice,
-        this list of conditions and the following disclaimers in the
-        documentation and/or other materials provided with the distribution.
-  
-      * Neither the names of the LLVM Team, University of Illinois at
-        Urbana-Champaign, nor the names of its contributors may be used to
-        endorse or promote products derived from this Software without specific
-        prior written permission.
-  
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
-  SOFTWARE.
-**/
-
-#include "Llvm_int_lib.h"
-
-// Returns: a << b
-
-// Precondition:  0 <= b < bits_in_dword
-
-INT64
-__ashldi3(INT64 a, INT32 b)
-{
-    const int bits_in_word = (int)(sizeof(INT32) * CHAR_BIT);
-    dwords input;
-    dwords result;
-    input.all = a;
-    if (b & bits_in_word)  // bits_in_word <= b < bits_in_dword
-    {
-        result.low = 0;
-        result.high = input.low << (b - bits_in_word);
-    }
-    else  // 0 <= b < bits_in_word
-    {
-        if (b == 0)
-            return a;
-        result.low  = input.low << b;
-        result.high = (input.high << b) | (input.low >> (bits_in_word - b));
-    }
-    return result.all;
-}
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+/**

+  University of Illinois/NCSA

+  Open Source License

+  

+  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.

+  All rights reserved.

+  

+  Developed by:

+  

+      LLVM Team

+  

+      University of Illinois at Urbana-Champaign

+  

+      http://llvm.org

+  

+  Permission is hereby granted, free of charge, to any person obtaining a copy of

+  this software and associated documentation files (the "Software"), to deal with

+  the Software without restriction, including without limitation the rights to

+  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies

+  of the Software, and to permit persons to whom the Software is furnished to do

+  so, subject to the following conditions:

+  

+      * Redistributions of source code must retain the above copyright notice,

+        this list of conditions and the following disclaimers.

+  

+      * Redistributions in binary form must reproduce the above copyright notice,

+        this list of conditions and the following disclaimers in the

+        documentation and/or other materials provided with the distribution.

+  

+      * Neither the names of the LLVM Team, University of Illinois at

+        Urbana-Champaign, nor the names of its contributors may be used to

+        endorse or promote products derived from this Software without specific

+        prior written permission.

+  

+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE

+  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE

+  SOFTWARE.

+**/

+

+#include "Llvm_int_lib.h"

+

+// Returns: a << b

+

+// Precondition:  0 <= b < bits_in_dword

+

+INT64

+__ashldi3(INT64 a, INT32 b)

+{

+    const int bits_in_word = (int)(sizeof(INT32) * CHAR_BIT);

+    dwords input;

+    dwords result;

+    input.all = a;

+    if (b & bits_in_word)  // bits_in_word <= b < bits_in_dword

+    {

+        result.low = 0;

+        result.high = input.low << (b - bits_in_word);

+    }

+    else  // 0 <= b < bits_in_word

+    {

+        if (b == 0)

+            return a;

+        result.low  = input.low << b;

+        result.high = (input.high << b) | (input.low >> (bits_in_word - b));

+    }

+    return result.all;

+}

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ashrdi3.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ashrdi3.S
index defd1f08..09c927ca 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ashrdi3.S
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ashrdi3.S
@@ -1,36 +1,36 @@
-#------------------------------------------------------------------------------ 
-#
-# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-#
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#------------------------------------------------------------------------------
-
-  .text
-  .align 2
-  GCC_ASM_EXPORT(__ashrdi3)
-
-ASM_PFX(__ashrdi3):
-  cmp  r2, #31
-  bls  L2
-  cmp  r2, #63
-  subls  r2, r2, #32
-  mov  ip, r1, asr #31
-  movls  r2, r1, asr r2
-  movhi  r2, ip
-  mov  r0, r2
-  mov  r1, ip
-  bx  lr
-L2:
-  cmp  r2, #0
-  rsbne  r3, r2, #32
-  movne  r3, r1, asl r3
-  movne  r1, r1, asr r2
-  orrne  r0, r3, r0, lsr r2
-  bx  lr
+#------------------------------------------------------------------------------ 

+#

+# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+  .text

+  .align 2

+  GCC_ASM_EXPORT(__ashrdi3)

+

+ASM_PFX(__ashrdi3):

+  cmp  r2, #31

+  bls  L2

+  cmp  r2, #63

+  subls  r2, r2, #32

+  mov  ip, r1, asr #31

+  movls  r2, r1, asr r2

+  movhi  r2, ip

+  mov  r0, r2

+  mov  r1, ip

+  bx  lr

+L2:

+  cmp  r2, #0

+  rsbne  r3, r2, #32

+  movne  r3, r1, asl r3

+  movne  r1, r1, asr r2

+  orrne  r0, r3, r0, lsr r2

+  bx  lr

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ashrdi3.c b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ashrdi3.c
index 703a37fd..229531ed 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ashrdi3.c
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ashrdi3.c
@@ -1,84 +1,84 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-/**
-  University of Illinois/NCSA
-  Open Source License
-  
-  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.
-  All rights reserved.
-  
-  Developed by:
-  
-      LLVM Team
-  
-      University of Illinois at Urbana-Champaign
-  
-      http://llvm.org
-  
-  Permission is hereby granted, free of charge, to any person obtaining a copy of
-  this software and associated documentation files (the "Software"), to deal with
-  the Software without restriction, including without limitation the rights to
-  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-  of the Software, and to permit persons to whom the Software is furnished to do
-  so, subject to the following conditions:
-  
-      * Redistributions of source code must retain the above copyright notice,
-        this list of conditions and the following disclaimers.
-  
-      * Redistributions in binary form must reproduce the above copyright notice,
-        this list of conditions and the following disclaimers in the
-        documentation and/or other materials provided with the distribution.
-  
-      * Neither the names of the LLVM Team, University of Illinois at
-        Urbana-Champaign, nor the names of its contributors may be used to
-        endorse or promote products derived from this Software without specific
-        prior written permission.
-  
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
-  SOFTWARE.
-**/
-
-#include "Llvm_int_lib.h"
-
-// Returns: arithmetic a >> b
-
-// Precondition:  0 <= b < bits_in_dword
-
-INT64
-__ashrdi3(INT64 a, INT32 b)
-{
-    const int bits_in_word = (int)(sizeof(INT32) * CHAR_BIT);
-    dwords input;
-    dwords result;
-    input.all = a;
-    if (b & bits_in_word)  // bits_in_word <= b < bits_in_dword
-    {
-        // result.high = input.high < 0 ? -1 : 0
-        result.high = input.high >> (bits_in_word - 1);
-        result.low = input.high >> (b - bits_in_word);
-    }
-    else  // 0 <= b < bits_in_word
-    {
-        if (b == 0)
-            return a;
-        result.high  = input.high >> b;
-        result.low = (input.high << (bits_in_word - b)) | (input.low >> b);
-    }
-    return result.all;
-}
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+/**

+  University of Illinois/NCSA

+  Open Source License

+  

+  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.

+  All rights reserved.

+  

+  Developed by:

+  

+      LLVM Team

+  

+      University of Illinois at Urbana-Champaign

+  

+      http://llvm.org

+  

+  Permission is hereby granted, free of charge, to any person obtaining a copy of

+  this software and associated documentation files (the "Software"), to deal with

+  the Software without restriction, including without limitation the rights to

+  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies

+  of the Software, and to permit persons to whom the Software is furnished to do

+  so, subject to the following conditions:

+  

+      * Redistributions of source code must retain the above copyright notice,

+        this list of conditions and the following disclaimers.

+  

+      * Redistributions in binary form must reproduce the above copyright notice,

+        this list of conditions and the following disclaimers in the

+        documentation and/or other materials provided with the distribution.

+  

+      * Neither the names of the LLVM Team, University of Illinois at

+        Urbana-Champaign, nor the names of its contributors may be used to

+        endorse or promote products derived from this Software without specific

+        prior written permission.

+  

+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE

+  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE

+  SOFTWARE.

+**/

+

+#include "Llvm_int_lib.h"

+

+// Returns: arithmetic a >> b

+

+// Precondition:  0 <= b < bits_in_dword

+

+INT64

+__ashrdi3(INT64 a, INT32 b)

+{

+    const int bits_in_word = (int)(sizeof(INT32) * CHAR_BIT);

+    dwords input;

+    dwords result;

+    input.all = a;

+    if (b & bits_in_word)  // bits_in_word <= b < bits_in_dword

+    {

+        // result.high = input.high < 0 ? -1 : 0

+        result.high = input.high >> (bits_in_word - 1);

+        result.low = input.high >> (b - bits_in_word);

+    }

+    else  // 0 <= b < bits_in_word

+    {

+        if (b == 0)

+            return a;

+        result.high  = input.high >> b;

+        result.low = (input.high << (bits_in_word - b)) | (input.low >> b);

+    }

+    return result.all;

+}

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/clzsi2.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/clzsi2.S
index 11ea95ce..94234467 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/clzsi2.S
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/clzsi2.S
@@ -1,57 +1,57 @@
-#------------------------------------------------------------------------------ 
-#
-# Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-#
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#------------------------------------------------------------------------------
-
-  .text
-  .align 2
-  GCC_ASM_EXPORT(__clzsi2)
-
-ASM_PFX(__clzsi2):
-  @ frame_needed = 1, uses_anonymous_args = 0
-  stmfd  sp!, {r7, lr}
-  add  r7, sp, #0
-  movs  r3, r0, lsr #16
-  movne  r3, #16
-  moveq  r3, #0
-  movne  r9, #0
-  moveq  r9, #16
-  mov  r3, r0, lsr r3
-  tst  r3, #65280
-  movne  r0, #8
-  moveq  r0, #0
-  movne  lr, #0
-  moveq  lr, #8
-  mov  r3, r3, lsr r0
-  tst  r3, #240
-  movne  r0, #4
-  moveq  r0, #0
-  movne  ip, #0
-  moveq  ip, #4
-  mov  r3, r3, lsr r0
-  tst  r3, #12
-  movne  r0, #2
-  moveq  r0, #0
-  movne  r1, #0
-  moveq  r1, #2
-  mov  r2, r3, lsr r0
-  add  r3, lr, r9
-  add  r0, r3, ip
-  add  r1, r0, r1
-  mov  r0, r2, lsr #1
-  eor  r0, r0, #1
-  ands  r0, r0, #1
-  mvnne  r0, #0
-  rsb  r3, r2, #2
-  and  r0, r0, r3
-  add  r0, r1, r0
-  ldmfd  sp!, {r7, pc}
+#------------------------------------------------------------------------------ 

+#

+# Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+  .text

+  .align 2

+  GCC_ASM_EXPORT(__clzsi2)

+

+ASM_PFX(__clzsi2):

+  @ frame_needed = 1, uses_anonymous_args = 0

+  stmfd  sp!, {r7, lr}

+  add  r7, sp, #0

+  movs  r3, r0, lsr #16

+  movne  r3, #16

+  moveq  r3, #0

+  movne  r9, #0

+  moveq  r9, #16

+  mov  r3, r0, lsr r3

+  tst  r3, #65280

+  movne  r0, #8

+  moveq  r0, #0

+  movne  lr, #0

+  moveq  lr, #8

+  mov  r3, r3, lsr r0

+  tst  r3, #240

+  movne  r0, #4

+  moveq  r0, #0

+  movne  ip, #0

+  moveq  ip, #4

+  mov  r3, r3, lsr r0

+  tst  r3, #12

+  movne  r0, #2

+  moveq  r0, #0

+  movne  r1, #0

+  moveq  r1, #2

+  mov  r2, r3, lsr r0

+  add  r3, lr, r9

+  add  r0, r3, ip

+  add  r1, r0, r1

+  mov  r0, r2, lsr #1

+  eor  r0, r0, #1

+  ands  r0, r0, #1

+  mvnne  r0, #0

+  rsb  r3, r2, #2

+  and  r0, r0, r3

+  add  r0, r1, r0

+  ldmfd  sp!, {r7, pc}

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/clzsi2.c b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/clzsi2.c
index 196f23f8..50ae87a6 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/clzsi2.c
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/clzsi2.c
@@ -1,96 +1,96 @@
-/** @file
-  Compiler intrinsic to return the number of leading zeros, ported from LLVM code.
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-/**
-  University of Illinois/NCSA
-  Open Source License
-  
-  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.
-  All rights reserved.
-  
-  Developed by:
-  
-      LLVM Team
-  
-      University of Illinois at Urbana-Champaign
-  
-      http://llvm.org
-  
-  Permission is hereby granted, free of charge, to any person obtaining a copy of
-  this software and associated documentation files (the "Software"), to deal with
-  the Software without restriction, including without limitation the rights to
-  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-  of the Software, and to permit persons to whom the Software is furnished to do
-  so, subject to the following conditions:
-  
-      * Redistributions of source code must retain the above copyright notice,
-        this list of conditions and the following disclaimers.
-  
-      * Redistributions in binary form must reproduce the above copyright notice,
-        this list of conditions and the following disclaimers in the
-        documentation and/or other materials provided with the distribution.
-  
-      * Neither the names of the LLVM Team, University of Illinois at
-        Urbana-Champaign, nor the names of its contributors may be used to
-        endorse or promote products derived from this Software without specific
-        prior written permission.
-  
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
-  SOFTWARE.
-**/
-
-
-#include "Llvm_int_lib.h"
-
-// Returns: the number of leading 0-bits
-
-// Precondition: a != 0
-
-INT32
-__clzsi2(INT32 a)
-{
-    UINT32 x = (UINT32)a;
-    INT32 t = ((x & 0xFFFF0000) == 0) << 4;  // if (x is small) t = 16 else 0
-    x >>= 16 - t;      // x = [0 - 0xFFFF]
-    UINT32 r = t;       // r = [0, 16]
-    // return r + clz(x)
-    t = ((x & 0xFF00) == 0) << 3;
-    x >>= 8 - t;       // x = [0 - 0xFF]
-    r += t;            // r = [0, 8, 16, 24]
-    // return r + clz(x)
-    t = ((x & 0xF0) == 0) << 2;
-    x >>= 4 - t;       // x = [0 - 0xF]
-    r += t;            // r = [0, 4, 8, 12, 16, 20, 24, 28]
-    // return r + clz(x)
-    t = ((x & 0xC) == 0) << 1;
-    x >>= 2 - t;       // x = [0 - 3]
-    r += t;            // r = [0 - 30] and is even
-    // return r + clz(x)
-//     switch (x)
-//     {
-//     case 0:
-//         return r + 2;
-//     case 1:
-//         return r + 1;
-//     case 2:
-//     case 3:
-//         return r;
-//     }
-    return r + ((2 - x) & -((x & 2) == 0));
-}
+/** @file

+  Compiler intrinsic to return the number of leading zeros, ported from LLVM code.

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+/**

+  University of Illinois/NCSA

+  Open Source License

+  

+  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.

+  All rights reserved.

+  

+  Developed by:

+  

+      LLVM Team

+  

+      University of Illinois at Urbana-Champaign

+  

+      http://llvm.org

+  

+  Permission is hereby granted, free of charge, to any person obtaining a copy of

+  this software and associated documentation files (the "Software"), to deal with

+  the Software without restriction, including without limitation the rights to

+  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies

+  of the Software, and to permit persons to whom the Software is furnished to do

+  so, subject to the following conditions:

+  

+      * Redistributions of source code must retain the above copyright notice,

+        this list of conditions and the following disclaimers.

+  

+      * Redistributions in binary form must reproduce the above copyright notice,

+        this list of conditions and the following disclaimers in the

+        documentation and/or other materials provided with the distribution.

+  

+      * Neither the names of the LLVM Team, University of Illinois at

+        Urbana-Champaign, nor the names of its contributors may be used to

+        endorse or promote products derived from this Software without specific

+        prior written permission.

+  

+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE

+  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE

+  SOFTWARE.

+**/

+

+

+#include "Llvm_int_lib.h"

+

+// Returns: the number of leading 0-bits

+

+// Precondition: a != 0

+

+INT32

+__clzsi2(INT32 a)

+{

+    UINT32 x = (UINT32)a;

+    INT32 t = ((x & 0xFFFF0000) == 0) << 4;  // if (x is small) t = 16 else 0

+    x >>= 16 - t;      // x = [0 - 0xFFFF]

+    UINT32 r = t;       // r = [0, 16]

+    // return r + clz(x)

+    t = ((x & 0xFF00) == 0) << 3;

+    x >>= 8 - t;       // x = [0 - 0xFF]

+    r += t;            // r = [0, 8, 16, 24]

+    // return r + clz(x)

+    t = ((x & 0xF0) == 0) << 2;

+    x >>= 4 - t;       // x = [0 - 0xF]

+    r += t;            // r = [0, 4, 8, 12, 16, 20, 24, 28]

+    // return r + clz(x)

+    t = ((x & 0xC) == 0) << 1;

+    x >>= 2 - t;       // x = [0 - 3]

+    r += t;            // r = [0 - 30] and is even

+    // return r + clz(x)

+//     switch (x)

+//     {

+//     case 0:

+//         return r + 2;

+//     case 1:

+//         return r + 1;

+//     case 2:

+//     case 3:

+//         return r;

+//     }

+    return r + ((2 - x) & -((x & 2) == 0));

+}

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ctzsi2.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ctzsi2.S
index 0c8e78d9..d530025a 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ctzsi2.S
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ctzsi2.S
@@ -1,49 +1,49 @@
-#------------------------------------------------------------------------------ 
-#
-# Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-#
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#------------------------------------------------------------------------------
-
-  .text
-  .align 2
-  GCC_ASM_EXPORT(__ctzsi2)
-  
-ASM_PFX(__ctzsi2):
-  uxth  r3, r0
-  cmp  r3, #0
-  moveq  ip, #16
-  movne  ip, #0
-  @ lr needed for prologue
-  mov  r0, r0, lsr ip
-  tst  r0, #255
-  movne  r3, #0
-  moveq  r3, #8
-  mov  r0, r0, lsr r3
-  tst  r0, #15
-  movne  r1, #0
-  moveq  r1, #4
-  add  r3, r3, ip
-  mov  r0, r0, lsr r1
-  tst  r0, #3
-  movne  r2, #0
-  moveq  r2, #2
-  add  r3, r3, r1
-  mov  r0, r0, lsr r2
-  and  r0, r0, #3
-  add  r2, r3, r2
-  eor  r3, r0, #1
-  mov  r0, r0, lsr #1
-  ands  r3, r3, #1
-  mvnne  r3, #0
-  rsb  r0, r0, #2
-  and  r0, r3, r0
-  add  r0, r2, r0
-  bx  lr
+#------------------------------------------------------------------------------ 

+#

+# Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+  .text

+  .align 2

+  GCC_ASM_EXPORT(__ctzsi2)

+  

+ASM_PFX(__ctzsi2):

+  uxth  r3, r0

+  cmp  r3, #0

+  moveq  ip, #16

+  movne  ip, #0

+  @ lr needed for prologue

+  mov  r0, r0, lsr ip

+  tst  r0, #255

+  movne  r3, #0

+  moveq  r3, #8

+  mov  r0, r0, lsr r3

+  tst  r0, #15

+  movne  r1, #0

+  moveq  r1, #4

+  add  r3, r3, ip

+  mov  r0, r0, lsr r1

+  tst  r0, #3

+  movne  r2, #0

+  moveq  r2, #2

+  add  r3, r3, r1

+  mov  r0, r0, lsr r2

+  and  r0, r0, #3

+  add  r2, r3, r2

+  eor  r3, r0, #1

+  mov  r0, r0, lsr #1

+  ands  r3, r3, #1

+  mvnne  r3, #0

+  rsb  r0, r0, #2

+  and  r0, r3, r0

+  add  r0, r2, r0

+  bx  lr

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ctzsi2.c b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ctzsi2.c
index 425d8b9e..71f303b3 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ctzsi2.c
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ctzsi2.c
@@ -1,98 +1,98 @@
-/** @file
-  Compiler intrinsic to return the number of trailing zeros, ported from LLVM code.
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-/**
-  University of Illinois/NCSA
-  Open Source License
-  
-  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.
-  All rights reserved.
-  
-  Developed by:
-  
-      LLVM Team
-  
-      University of Illinois at Urbana-Champaign
-  
-      http://llvm.org
-  
-  Permission is hereby granted, free of charge, to any person obtaining a copy of
-  this software and associated documentation files (the "Software"), to deal with
-  the Software without restriction, including without limitation the rights to
-  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-  of the Software, and to permit persons to whom the Software is furnished to do
-  so, subject to the following conditions:
-  
-      * Redistributions of source code must retain the above copyright notice,
-        this list of conditions and the following disclaimers.
-  
-      * Redistributions in binary form must reproduce the above copyright notice,
-        this list of conditions and the following disclaimers in the
-        documentation and/or other materials provided with the distribution.
-  
-      * Neither the names of the LLVM Team, University of Illinois at
-        Urbana-Champaign, nor the names of its contributors may be used to
-        endorse or promote products derived from this Software without specific
-        prior written permission.
-  
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
-  SOFTWARE.
-**/
-
-
-#include "Llvm_int_lib.h"
-
-// Returns: the number of trailing 0-bits
-
-// Precondition: a != 0
-
-INT32
-__ctzsi2(INT32 a)
-{
-    UINT32 x = (UINT32)a;
-    INT32 t = ((x & 0x0000FFFF) == 0) << 4;  // if (x has no small bits) t = 16 else 0
-    x >>= t;           // x = [0 - 0xFFFF] + higher garbage bits
-    UINT32 r = t;       // r = [0, 16]
-    // return r + ctz(x)
-    t = ((x & 0x00FF) == 0) << 3;
-    x >>= t;           // x = [0 - 0xFF] + higher garbage bits
-    r += t;            // r = [0, 8, 16, 24]
-    // return r + ctz(x)
-    t = ((x & 0x0F) == 0) << 2;
-    x >>= t;           // x = [0 - 0xF] + higher garbage bits
-    r += t;            // r = [0, 4, 8, 12, 16, 20, 24, 28]
-    // return r + ctz(x)
-    t = ((x & 0x3) == 0) << 1;
-    x >>= t;
-    x &= 3;            // x = [0 - 3]
-    r += t;            // r = [0 - 30] and is even
-    // return r + ctz(x)
-//  The branch-less return statement below is equivalent
-//  to the following switch statement:
-//     switch (x)
-//     {
-//     case 0:
-//         return r + 2;
-//     case 2:
-//         return r + 1;
-//     case 1:
-//     case 3:
-//         return r;
-//     }
-    return r + ((2 - (x >> 1)) & -((x & 1) == 0));
-}
+/** @file

+  Compiler intrinsic to return the number of trailing zeros, ported from LLVM code.

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+/**

+  University of Illinois/NCSA

+  Open Source License

+  

+  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.

+  All rights reserved.

+  

+  Developed by:

+  

+      LLVM Team

+  

+      University of Illinois at Urbana-Champaign

+  

+      http://llvm.org

+  

+  Permission is hereby granted, free of charge, to any person obtaining a copy of

+  this software and associated documentation files (the "Software"), to deal with

+  the Software without restriction, including without limitation the rights to

+  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies

+  of the Software, and to permit persons to whom the Software is furnished to do

+  so, subject to the following conditions:

+  

+      * Redistributions of source code must retain the above copyright notice,

+        this list of conditions and the following disclaimers.

+  

+      * Redistributions in binary form must reproduce the above copyright notice,

+        this list of conditions and the following disclaimers in the

+        documentation and/or other materials provided with the distribution.

+  

+      * Neither the names of the LLVM Team, University of Illinois at

+        Urbana-Champaign, nor the names of its contributors may be used to

+        endorse or promote products derived from this Software without specific

+        prior written permission.

+  

+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE

+  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE

+  SOFTWARE.

+**/

+

+

+#include "Llvm_int_lib.h"

+

+// Returns: the number of trailing 0-bits

+

+// Precondition: a != 0

+

+INT32

+__ctzsi2(INT32 a)

+{

+    UINT32 x = (UINT32)a;

+    INT32 t = ((x & 0x0000FFFF) == 0) << 4;  // if (x has no small bits) t = 16 else 0

+    x >>= t;           // x = [0 - 0xFFFF] + higher garbage bits

+    UINT32 r = t;       // r = [0, 16]

+    // return r + ctz(x)

+    t = ((x & 0x00FF) == 0) << 3;

+    x >>= t;           // x = [0 - 0xFF] + higher garbage bits

+    r += t;            // r = [0, 8, 16, 24]

+    // return r + ctz(x)

+    t = ((x & 0x0F) == 0) << 2;

+    x >>= t;           // x = [0 - 0xF] + higher garbage bits

+    r += t;            // r = [0, 4, 8, 12, 16, 20, 24, 28]

+    // return r + ctz(x)

+    t = ((x & 0x3) == 0) << 1;

+    x >>= t;

+    x &= 3;            // x = [0 - 3]

+    r += t;            // r = [0 - 30] and is even

+    // return r + ctz(x)

+//  The branch-less return statement below is equivalent

+//  to the following switch statement:

+//     switch (x)

+//     {

+//     case 0:

+//         return r + 2;

+//     case 2:

+//         return r + 1;

+//     case 1:

+//     case 3:

+//         return r;

+//     }

+    return r + ((2 - (x >> 1)) & -((x & 1) == 0));

+}

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/div.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/div.S
index 3534eaba..faf70dbf 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/div.S
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/div.S
@@ -1,153 +1,153 @@
-#------------------------------------------------------------------------------
-#
-# Copyright (c) 2011, ARM. All rights reserved.<BR>
-#
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#------------------------------------------------------------------------------
-
-.text
-.align 2
-GCC_ASM_EXPORT(__aeabi_uidiv)
-GCC_ASM_EXPORT(__aeabi_uidivmod)
-GCC_ASM_EXPORT(__aeabi_idiv)
-GCC_ASM_EXPORT(__aeabi_idivmod)
-
-#    AREA  Math, CODE, READONLY
-
-#
-#UINT32
-#EFIAPI
-#__aeabi_uidivmode (
-#  IN UINT32  Dividen
-#  IN UINT32  Divisor
-#  );
-#
-
-ASM_PFX(__aeabi_uidiv):
-ASM_PFX(__aeabi_uidivmod):
-  rsbs    r12, r1, r0, LSR #4
-  mov     r2, #0
-  bcc     ASM_PFX(__arm_div4)
-  rsbs    r12, r1, r0, LSR #8
-  bcc     ASM_PFX(__arm_div8)
-  mov     r3, #0
-  b       ASM_PFX(__arm_div_large)
-
-#
-#INT32
-#EFIAPI
-#__aeabi_idivmode (
-#  IN INT32  Dividen
-#  IN INT32  Divisor
-#  );
-#
-ASM_PFX(__aeabi_idiv):
-ASM_PFX(__aeabi_idivmod):
-  orrs    r12, r0, r1
-  bmi     ASM_PFX(__arm_div_negative)
-  rsbs    r12, r1, r0, LSR #1
-  mov     r2, #0
-  bcc     ASM_PFX(__arm_div1)
-  rsbs    r12, r1, r0, LSR #4
-  bcc     ASM_PFX(__arm_div4)
-  rsbs    r12, r1, r0, LSR #8
-  bcc     ASM_PFX(__arm_div8)
-  mov     r3, #0
-  b       ASM_PFX(__arm_div_large)
-ASM_PFX(__arm_div8):
-  rsbs    r12, r1, r0, LSR #7
-  subcs   r0, r0, r1, LSL #7
-  adc     r2, r2, r2
-  rsbs    r12, r1, r0,LSR #6
-  subcs   r0, r0, r1, LSL #6
-  adc     r2, r2, r2
-  rsbs    r12, r1, r0, LSR #5
-  subcs   r0, r0, r1, LSL #5
-  adc     r2, r2, r2
-  rsbs    r12, r1, r0, LSR #4
-  subcs   r0, r0, r1, LSL #4
-  adc     r2, r2, r2
-ASM_PFX(__arm_div4):
-  rsbs    r12, r1, r0, LSR #3
-  subcs   r0, r0, r1, LSL #3
-  adc     r2, r2, r2
-  rsbs    r12, r1, r0, LSR #2
-  subcs   r0, r0, r1, LSL #2
-  adcs    r2, r2, r2
-  rsbs    r12, r1, r0, LSR #1
-  subcs   r0, r0, r1, LSL #1
-  adc     r2, r2, r2
-ASM_PFX(__arm_div1):
-  subs    r1, r0, r1
-  movcc   r1, r0
-  adc     r0, r2, r2
-  bx      r14
-ASM_PFX(__arm_div_negative):
-  ands    r2, r1, #0x80000000
-  rsbmi   r1, r1, #0
-  eors    r3, r2, r0, ASR #32
-  rsbcs   r0, r0, #0
-  rsbs    r12, r1, r0, LSR #4
-  bcc     label1
-  rsbs    r12, r1, r0, LSR #8
-  bcc     label2
-ASM_PFX(__arm_div_large):
-  lsl     r1, r1, #6
-  rsbs    r12, r1, r0, LSR #8
-  orr     r2, r2, #0xfc000000
-  bcc     label2
-  lsl     r1, r1, #6
-  rsbs    r12, r1, r0, LSR #8
-  orr     r2, r2, #0x3f00000
-  bcc     label2
-  lsl     r1, r1, #6
-  rsbs    r12, r1, r0, LSR #8
-  orr     r2, r2, #0xfc000
-  orrcs   r2, r2, #0x3f00
-  lslcs   r1, r1, #6
-  rsbs    r12, r1, #0
-  bcs     ASM_PFX(__aeabi_idiv0)
-label3:
-  lsrcs   r1, r1, #6
-label2:
-  rsbs    r12, r1, r0, LSR #7
-  subcs   r0, r0, r1, LSL #7
-  adc     r2, r2, r2
-  rsbs    r12, r1, r0, LSR #6
-  subcs   r0, r0, r1, LSL #6
-  adc     r2, r2, r2
-  rsbs    r12, r1, r0, LSR #5
-  subcs   r0, r0, r1, LSL #5
-  adc     r2, r2, r2
-  rsbs    r12, r1, r0, LSR #4
-  subcs   r0, r0, r1, LSL #4
-  adc     r2, r2, r2
-label1:
-  rsbs    r12, r1, r0, LSR #3
-  subcs   r0, r0, r1, LSL #3
-  adc     r2, r2, r2
-  rsbs    r12, r1, r0, LSR #2
-  subcs   r0, r0, r1, LSL #2
-  adcs    r2, r2, r2
-  bcs     label3
-  rsbs    r12, r1, r0, LSR #1
-  subcs   r0, r0, r1, LSL #1
-  adc     r2, r2, r2
-  subs    r1, r0, r1
-  movcc   r1, r0
-  adc     r0, r2, r2
-  asrs    r3, r3, #31
-  rsbmi   r0, r0, #0
-  rsbcs   r1, r1, #0
-  bx      r14
-
-  @ What to do about division by zero?  For now, just return.
-ASM_PFX(__aeabi_idiv0):
-  bx      r14
+#------------------------------------------------------------------------------

+#

+# Copyright (c) 2011, ARM. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+.text

+.align 2

+GCC_ASM_EXPORT(__aeabi_uidiv)

+GCC_ASM_EXPORT(__aeabi_uidivmod)

+GCC_ASM_EXPORT(__aeabi_idiv)

+GCC_ASM_EXPORT(__aeabi_idivmod)

+

+#    AREA  Math, CODE, READONLY

+

+#

+#UINT32

+#EFIAPI

+#__aeabi_uidivmode (

+#  IN UINT32  Dividen

+#  IN UINT32  Divisor

+#  );

+#

+

+ASM_PFX(__aeabi_uidiv):

+ASM_PFX(__aeabi_uidivmod):

+  rsbs    r12, r1, r0, LSR #4

+  mov     r2, #0

+  bcc     ASM_PFX(__arm_div4)

+  rsbs    r12, r1, r0, LSR #8

+  bcc     ASM_PFX(__arm_div8)

+  mov     r3, #0

+  b       ASM_PFX(__arm_div_large)

+

+#

+#INT32

+#EFIAPI

+#__aeabi_idivmode (

+#  IN INT32  Dividen

+#  IN INT32  Divisor

+#  );

+#

+ASM_PFX(__aeabi_idiv):

+ASM_PFX(__aeabi_idivmod):

+  orrs    r12, r0, r1

+  bmi     ASM_PFX(__arm_div_negative)

+  rsbs    r12, r1, r0, LSR #1

+  mov     r2, #0

+  bcc     ASM_PFX(__arm_div1)

+  rsbs    r12, r1, r0, LSR #4

+  bcc     ASM_PFX(__arm_div4)

+  rsbs    r12, r1, r0, LSR #8

+  bcc     ASM_PFX(__arm_div8)

+  mov     r3, #0

+  b       ASM_PFX(__arm_div_large)

+ASM_PFX(__arm_div8):

+  rsbs    r12, r1, r0, LSR #7

+  subcs   r0, r0, r1, LSL #7

+  adc     r2, r2, r2

+  rsbs    r12, r1, r0,LSR #6

+  subcs   r0, r0, r1, LSL #6

+  adc     r2, r2, r2

+  rsbs    r12, r1, r0, LSR #5

+  subcs   r0, r0, r1, LSL #5

+  adc     r2, r2, r2

+  rsbs    r12, r1, r0, LSR #4

+  subcs   r0, r0, r1, LSL #4

+  adc     r2, r2, r2

+ASM_PFX(__arm_div4):

+  rsbs    r12, r1, r0, LSR #3

+  subcs   r0, r0, r1, LSL #3

+  adc     r2, r2, r2

+  rsbs    r12, r1, r0, LSR #2

+  subcs   r0, r0, r1, LSL #2

+  adcs    r2, r2, r2

+  rsbs    r12, r1, r0, LSR #1

+  subcs   r0, r0, r1, LSL #1

+  adc     r2, r2, r2

+ASM_PFX(__arm_div1):

+  subs    r1, r0, r1

+  movcc   r1, r0

+  adc     r0, r2, r2

+  bx      r14

+ASM_PFX(__arm_div_negative):

+  ands    r2, r1, #0x80000000

+  rsbmi   r1, r1, #0

+  eors    r3, r2, r0, ASR #32

+  rsbcs   r0, r0, #0

+  rsbs    r12, r1, r0, LSR #4

+  bcc     label1

+  rsbs    r12, r1, r0, LSR #8

+  bcc     label2

+ASM_PFX(__arm_div_large):

+  lsl     r1, r1, #6

+  rsbs    r12, r1, r0, LSR #8

+  orr     r2, r2, #0xfc000000

+  bcc     label2

+  lsl     r1, r1, #6

+  rsbs    r12, r1, r0, LSR #8

+  orr     r2, r2, #0x3f00000

+  bcc     label2

+  lsl     r1, r1, #6

+  rsbs    r12, r1, r0, LSR #8

+  orr     r2, r2, #0xfc000

+  orrcs   r2, r2, #0x3f00

+  lslcs   r1, r1, #6

+  rsbs    r12, r1, #0

+  bcs     ASM_PFX(__aeabi_idiv0)

+label3:

+  lsrcs   r1, r1, #6

+label2:

+  rsbs    r12, r1, r0, LSR #7

+  subcs   r0, r0, r1, LSL #7

+  adc     r2, r2, r2

+  rsbs    r12, r1, r0, LSR #6

+  subcs   r0, r0, r1, LSL #6

+  adc     r2, r2, r2

+  rsbs    r12, r1, r0, LSR #5

+  subcs   r0, r0, r1, LSL #5

+  adc     r2, r2, r2

+  rsbs    r12, r1, r0, LSR #4

+  subcs   r0, r0, r1, LSL #4

+  adc     r2, r2, r2

+label1:

+  rsbs    r12, r1, r0, LSR #3

+  subcs   r0, r0, r1, LSL #3

+  adc     r2, r2, r2

+  rsbs    r12, r1, r0, LSR #2

+  subcs   r0, r0, r1, LSL #2

+  adcs    r2, r2, r2

+  bcs     label3

+  rsbs    r12, r1, r0, LSR #1

+  subcs   r0, r0, r1, LSL #1

+  adc     r2, r2, r2

+  subs    r1, r0, r1

+  movcc   r1, r0

+  adc     r0, r2, r2

+  asrs    r3, r3, #31

+  rsbmi   r0, r0, #0

+  rsbcs   r1, r1, #0

+  bx      r14

+

+  @ What to do about division by zero?  For now, just return.

+ASM_PFX(__aeabi_idiv0):

+  bx      r14

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/div.asm b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/div.asm
index e38105dd..13f70135 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/div.asm
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/div.asm
@@ -1,155 +1,155 @@
-//------------------------------------------------------------------------------ 
-//
-// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-//
-// This program and the accompanying materials
-// are licensed and made available under the terms and conditions of the BSD License
-// which accompanies this distribution.  The full text of the license may be found at
-// http://opensource.org/licenses/bsd-license.php
-//
-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-//
-//------------------------------------------------------------------------------
-
-
-    EXPORT  __aeabi_uidiv
-    EXPORT  __aeabi_uidivmod
-    EXPORT  __aeabi_idiv
-    EXPORT  __aeabi_idivmod
-           
-    AREA  Math, CODE, READONLY
-
-;
-;UINT32
-;EFIAPI
-;__aeabi_uidivmode (
-;  IN UINT32  Dividen
-;  IN UINT32  Divisor
-;  );
-;
-
-__aeabi_uidiv
-__aeabi_uidivmod
-    RSBS    r12, r1, r0, LSR #4
-    MOV     r2, #0
-    BCC     __arm_div4
-    RSBS    r12, r1, r0, LSR #8
-    BCC     __arm_div8
-    MOV     r3, #0
-    B       __arm_div_large
-
-;
-;INT32
-;EFIAPI
-;__aeabi_idivmode (
-;  IN INT32  Dividen
-;  IN INT32  Divisor
-;  );
-;
-__aeabi_idiv
-__aeabi_idivmod
-    ORRS    r12, r0, r1
-    BMI     __arm_div_negative
-    RSBS    r12, r1, r0, LSR #1
-    MOV     r2, #0
-    BCC     __arm_div1
-    RSBS    r12, r1, r0, LSR #4
-    BCC     __arm_div4
-    RSBS    r12, r1, r0, LSR #8
-    BCC     __arm_div8
-    MOV     r3, #0
-    B       __arm_div_large
-__arm_div8
-    RSBS    r12, r1, r0, LSR #7
-    SUBCS   r0, r0, r1, LSL #7
-    ADC     r2, r2, r2
-    RSBS    r12, r1, r0,LSR #6
-    SUBCS   r0, r0, r1, LSL #6
-    ADC     r2, r2, r2
-    RSBS    r12, r1, r0, LSR #5
-    SUBCS   r0, r0, r1, LSL #5
-    ADC     r2, r2, r2
-    RSBS    r12, r1, r0, LSR #4
-    SUBCS   r0, r0, r1, LSL #4
-    ADC     r2, r2, r2
-__arm_div4
-    RSBS    r12, r1, r0, LSR #3
-    SUBCS   r0, r0, r1, LSL #3
-    ADC     r2, r2, r2
-    RSBS    r12, r1, r0, LSR #2
-    SUBCS   r0, r0, r1, LSL #2
-    ADCS    r2, r2, r2
-    RSBS    r12, r1, r0, LSR #1
-    SUBCS   r0, r0, r1, LSL #1
-    ADC     r2, r2, r2
-__arm_div1
-    SUBS    r1, r0, r1
-    MOVCC   r1, r0
-    ADC     r0, r2, r2
-    BX      r14
-__arm_div_negative
-    ANDS    r2, r1, #0x80000000
-    RSBMI   r1, r1, #0
-    EORS    r3, r2, r0, ASR #32
-    RSBCS   r0, r0, #0
-    RSBS    r12, r1, r0, LSR #4
-    BCC     label1
-    RSBS    r12, r1, r0, LSR #8
-    BCC     label2
-__arm_div_large
-    LSL     r1, r1, #6
-    RSBS    r12, r1, r0, LSR #8
-    ORR     r2, r2, #0xfc000000
-    BCC     label2
-    LSL     r1, r1, #6
-    RSBS    r12, r1, r0, LSR #8
-    ORR     r2, r2, #0x3f00000
-    BCC     label2
-    LSL     r1, r1, #6
-    RSBS    r12, r1, r0, LSR #8
-    ORR     r2, r2, #0xfc000
-    ORRCS   r2, r2, #0x3f00
-    LSLCS   r1, r1, #6
-    RSBS    r12, r1, #0
-    BCS     __aeabi_idiv0
-label3
-    LSRCS   r1, r1, #6
-label2
-    RSBS    r12, r1, r0, LSR #7
-    SUBCS   r0, r0, r1, LSL #7
-    ADC     r2, r2, r2
-    RSBS    r12, r1, r0, LSR #6
-    SUBCS   r0, r0, r1, LSL #6
-    ADC     r2, r2, r2
-    RSBS    r12, r1, r0, LSR #5
-    SUBCS   r0, r0, r1, LSL #5
-    ADC     r2, r2, r2
-    RSBS    r12, r1, r0, LSR #4
-    SUBCS   r0, r0, r1, LSL #4
-    ADC     r2, r2, r2
-label1
-    RSBS    r12, r1, r0, LSR #3
-    SUBCS   r0, r0, r1, LSL #3
-    ADC     r2, r2, r2
-    RSBS    r12, r1, r0, LSR #2
-    SUBCS   r0, r0, r1, LSL #2
-    ADCS    r2, r2, r2
-    BCS     label3
-    RSBS    r12, r1, r0, LSR #1
-    SUBCS   r0, r0, r1, LSL #1
-    ADC     r2, r2, r2
-    SUBS    r1, r0, r1
-    MOVCC   r1, r0
-    ADC     r0, r2, r2
-    ASRS    r3, r3, #31
-    RSBMI   r0, r0, #0
-    RSBCS   r1, r1, #0
-    BX      r14
-
-    ; What to do about division by zero?  For now, just return.
-__aeabi_idiv0
-    BX      r14
- 
-    END
-
+//------------------------------------------------------------------------------ 

+//

+// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+//

+// This program and the accompanying materials

+// are licensed and made available under the terms and conditions of the BSD License

+// which accompanies this distribution.  The full text of the license may be found at

+// http://opensource.org/licenses/bsd-license.php

+//

+// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+//

+//------------------------------------------------------------------------------

+

+

+    EXPORT  __aeabi_uidiv

+    EXPORT  __aeabi_uidivmod

+    EXPORT  __aeabi_idiv

+    EXPORT  __aeabi_idivmod

+           

+    AREA  Math, CODE, READONLY

+

+;

+;UINT32

+;EFIAPI

+;__aeabi_uidivmode (

+;  IN UINT32  Dividen

+;  IN UINT32  Divisor

+;  );

+;

+

+__aeabi_uidiv

+__aeabi_uidivmod

+    RSBS    r12, r1, r0, LSR #4

+    MOV     r2, #0

+    BCC     __arm_div4

+    RSBS    r12, r1, r0, LSR #8

+    BCC     __arm_div8

+    MOV     r3, #0

+    B       __arm_div_large

+

+;

+;INT32

+;EFIAPI

+;__aeabi_idivmode (

+;  IN INT32  Dividen

+;  IN INT32  Divisor

+;  );

+;

+__aeabi_idiv

+__aeabi_idivmod

+    ORRS    r12, r0, r1

+    BMI     __arm_div_negative

+    RSBS    r12, r1, r0, LSR #1

+    MOV     r2, #0

+    BCC     __arm_div1

+    RSBS    r12, r1, r0, LSR #4

+    BCC     __arm_div4

+    RSBS    r12, r1, r0, LSR #8

+    BCC     __arm_div8

+    MOV     r3, #0

+    B       __arm_div_large

+__arm_div8

+    RSBS    r12, r1, r0, LSR #7

+    SUBCS   r0, r0, r1, LSL #7

+    ADC     r2, r2, r2

+    RSBS    r12, r1, r0,LSR #6

+    SUBCS   r0, r0, r1, LSL #6

+    ADC     r2, r2, r2

+    RSBS    r12, r1, r0, LSR #5

+    SUBCS   r0, r0, r1, LSL #5

+    ADC     r2, r2, r2

+    RSBS    r12, r1, r0, LSR #4

+    SUBCS   r0, r0, r1, LSL #4

+    ADC     r2, r2, r2

+__arm_div4

+    RSBS    r12, r1, r0, LSR #3

+    SUBCS   r0, r0, r1, LSL #3

+    ADC     r2, r2, r2

+    RSBS    r12, r1, r0, LSR #2

+    SUBCS   r0, r0, r1, LSL #2

+    ADCS    r2, r2, r2

+    RSBS    r12, r1, r0, LSR #1

+    SUBCS   r0, r0, r1, LSL #1

+    ADC     r2, r2, r2

+__arm_div1

+    SUBS    r1, r0, r1

+    MOVCC   r1, r0

+    ADC     r0, r2, r2

+    BX      r14

+__arm_div_negative

+    ANDS    r2, r1, #0x80000000

+    RSBMI   r1, r1, #0

+    EORS    r3, r2, r0, ASR #32

+    RSBCS   r0, r0, #0

+    RSBS    r12, r1, r0, LSR #4

+    BCC     label1

+    RSBS    r12, r1, r0, LSR #8

+    BCC     label2

+__arm_div_large

+    LSL     r1, r1, #6

+    RSBS    r12, r1, r0, LSR #8

+    ORR     r2, r2, #0xfc000000

+    BCC     label2

+    LSL     r1, r1, #6

+    RSBS    r12, r1, r0, LSR #8

+    ORR     r2, r2, #0x3f00000

+    BCC     label2

+    LSL     r1, r1, #6

+    RSBS    r12, r1, r0, LSR #8

+    ORR     r2, r2, #0xfc000

+    ORRCS   r2, r2, #0x3f00

+    LSLCS   r1, r1, #6

+    RSBS    r12, r1, #0

+    BCS     __aeabi_idiv0

+label3

+    LSRCS   r1, r1, #6

+label2

+    RSBS    r12, r1, r0, LSR #7

+    SUBCS   r0, r0, r1, LSL #7

+    ADC     r2, r2, r2

+    RSBS    r12, r1, r0, LSR #6

+    SUBCS   r0, r0, r1, LSL #6

+    ADC     r2, r2, r2

+    RSBS    r12, r1, r0, LSR #5

+    SUBCS   r0, r0, r1, LSL #5

+    ADC     r2, r2, r2

+    RSBS    r12, r1, r0, LSR #4

+    SUBCS   r0, r0, r1, LSL #4

+    ADC     r2, r2, r2

+label1

+    RSBS    r12, r1, r0, LSR #3

+    SUBCS   r0, r0, r1, LSL #3

+    ADC     r2, r2, r2

+    RSBS    r12, r1, r0, LSR #2

+    SUBCS   r0, r0, r1, LSL #2

+    ADCS    r2, r2, r2

+    BCS     label3

+    RSBS    r12, r1, r0, LSR #1

+    SUBCS   r0, r0, r1, LSL #1

+    ADC     r2, r2, r2

+    SUBS    r1, r0, r1

+    MOVCC   r1, r0

+    ADC     r0, r2, r2

+    ASRS    r3, r3, #31

+    RSBMI   r0, r0, #0

+    RSBCS   r1, r1, #0

+    BX      r14

+

+    ; What to do about division by zero?  For now, just return.

+__aeabi_idiv0

+    BX      r14

+ 

+    END

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/divdi3.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/divdi3.S
index 342f376b..7be2e288 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/divdi3.S
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/divdi3.S
@@ -1,49 +1,49 @@
-#------------------------------------------------------------------------------ 
-#
-# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-#
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#------------------------------------------------------------------------------
-
-  .text
-  .align 2
-  GCC_ASM_EXPORT(__divdi3)
-  
-ASM_PFX(__divdi3):
-  @ args = 0, pretend = 0, frame = 0
-  @ frame_needed = 1, uses_anonymous_args = 0
-  stmfd  sp!, {r4, r5, r7, lr}
-  mov  r4, r3, asr #31
-  add  r7, sp, #8
-  stmfd  sp!, {r10, r11}
-  mov  r10, r1, asr #31
-  sub  sp, sp, #8
-  mov  r11, r10
-  mov  r5, r4
-  eor  r0, r0, r10
-  eor  r1, r1, r10
-  eor  r2, r2, r4
-  eor  r3, r3, r4
-  subs  r2, r2, r4
-  sbc  r3, r3, r5
-  mov  ip, #0
-  subs  r0, r0, r10
-  sbc  r1, r1, r11
-  str  ip, [sp, #0]
-  bl  ASM_PFX(__udivmoddi4)
-  eor  r2, r10, r4
-  eor  r3, r10, r4
-  eor  r0, r0, r2
-  eor  r1, r1, r3
-  subs  r0, r0, r2
-  sbc  r1, r1, r3
-  sub  sp, r7, #16
-  ldmfd  sp!, {r10, r11}
-  ldmfd  sp!, {r4, r5, r7, pc}
+#------------------------------------------------------------------------------ 

+#

+# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+  .text

+  .align 2

+  GCC_ASM_EXPORT(__divdi3)

+  

+ASM_PFX(__divdi3):

+  @ args = 0, pretend = 0, frame = 0

+  @ frame_needed = 1, uses_anonymous_args = 0

+  stmfd  sp!, {r4, r5, r7, lr}

+  mov  r4, r3, asr #31

+  add  r7, sp, #8

+  stmfd  sp!, {r10, r11}

+  mov  r10, r1, asr #31

+  sub  sp, sp, #8

+  mov  r11, r10

+  mov  r5, r4

+  eor  r0, r0, r10

+  eor  r1, r1, r10

+  eor  r2, r2, r4

+  eor  r3, r3, r4

+  subs  r2, r2, r4

+  sbc  r3, r3, r5

+  mov  ip, #0

+  subs  r0, r0, r10

+  sbc  r1, r1, r11

+  str  ip, [sp, #0]

+  bl  ASM_PFX(__udivmoddi4)

+  eor  r2, r10, r4

+  eor  r3, r10, r4

+  eor  r0, r0, r2

+  eor  r1, r1, r3

+  subs  r0, r0, r2

+  sbc  r1, r1, r3

+  sub  sp, r7, #16

+  ldmfd  sp!, {r10, r11}

+  ldmfd  sp!, {r4, r5, r7, pc}

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/divdi3.c b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/divdi3.c
index 4d790b8f..e86bd136 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/divdi3.c
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/divdi3.c
@@ -1,77 +1,77 @@
-/** @file
-  Compiler intrinsic for 64-bit compare, ported from LLVM code.
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-/**
-  University of Illinois/NCSA
-  Open Source License
-  
-  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.
-  All rights reserved.
-  
-  Developed by:
-  
-      LLVM Team
-  
-      University of Illinois at Urbana-Champaign
-  
-      http://llvm.org
-  
-  Permission is hereby granted, free of charge, to any person obtaining a copy of
-  this software and associated documentation files (the "Software"), to deal with
-  the Software without restriction, including without limitation the rights to
-  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-  of the Software, and to permit persons to whom the Software is furnished to do
-  so, subject to the following conditions:
-  
-      * Redistributions of source code must retain the above copyright notice,
-        this list of conditions and the following disclaimers.
-  
-      * Redistributions in binary form must reproduce the above copyright notice,
-        this list of conditions and the following disclaimers in the
-        documentation and/or other materials provided with the distribution.
-  
-      * Neither the names of the LLVM Team, University of Illinois at
-        Urbana-Champaign, nor the names of its contributors may be used to
-        endorse or promote products derived from this Software without specific
-        prior written permission.
-  
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
-  SOFTWARE.
-**/
-
-
-#include "Llvm_int_lib.h"
-
-UINT64 __udivmoddi4(UINT64 a, UINT64 b, UINT64* rem);
-
-// Returns: a / b
-
-INT64
-__divdi3(INT64 a, INT64 b)
-{
-    const int bits_in_dword_m1 = (int)(sizeof(INT64) * CHAR_BIT) - 1;
-    INT64 s_a = a >> bits_in_dword_m1;           // s_a = a < 0 ? -1 : 0
-    INT64 s_b = b >> bits_in_dword_m1;           // s_b = b < 0 ? -1 : 0
-    a = (a ^ s_a) - s_a;                         // negate if s_a == -1
-    b = (b ^ s_b) - s_b;                         // negate if s_b == -1
-    s_a ^= s_b;                                  // sign of quotient
-    return (__udivmoddi4(a, b, (UINT64*)0) ^ s_a) - s_a;  // negate if s_a == -1
-}
-
-
+/** @file

+  Compiler intrinsic for 64-bit compare, ported from LLVM code.

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+/**

+  University of Illinois/NCSA

+  Open Source License

+  

+  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.

+  All rights reserved.

+  

+  Developed by:

+  

+      LLVM Team

+  

+      University of Illinois at Urbana-Champaign

+  

+      http://llvm.org

+  

+  Permission is hereby granted, free of charge, to any person obtaining a copy of

+  this software and associated documentation files (the "Software"), to deal with

+  the Software without restriction, including without limitation the rights to

+  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies

+  of the Software, and to permit persons to whom the Software is furnished to do

+  so, subject to the following conditions:

+  

+      * Redistributions of source code must retain the above copyright notice,

+        this list of conditions and the following disclaimers.

+  

+      * Redistributions in binary form must reproduce the above copyright notice,

+        this list of conditions and the following disclaimers in the

+        documentation and/or other materials provided with the distribution.

+  

+      * Neither the names of the LLVM Team, University of Illinois at

+        Urbana-Champaign, nor the names of its contributors may be used to

+        endorse or promote products derived from this Software without specific

+        prior written permission.

+  

+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE

+  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE

+  SOFTWARE.

+**/

+

+

+#include "Llvm_int_lib.h"

+

+UINT64 __udivmoddi4(UINT64 a, UINT64 b, UINT64* rem);

+

+// Returns: a / b

+

+INT64

+__divdi3(INT64 a, INT64 b)

+{

+    const int bits_in_dword_m1 = (int)(sizeof(INT64) * CHAR_BIT) - 1;

+    INT64 s_a = a >> bits_in_dword_m1;           // s_a = a < 0 ? -1 : 0

+    INT64 s_b = b >> bits_in_dword_m1;           // s_b = b < 0 ? -1 : 0

+    a = (a ^ s_a) - s_a;                         // negate if s_a == -1

+    b = (b ^ s_b) - s_b;                         // negate if s_b == -1

+    s_a ^= s_b;                                  // sign of quotient

+    return (__udivmoddi4(a, b, (UINT64*)0) ^ s_a) - s_a;  // negate if s_a == -1

+}

+

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/divsi3.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/divsi3.S
index 3976fda1..b74cbb64 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/divsi3.S
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/divsi3.S
@@ -1,32 +1,32 @@
-#------------------------------------------------------------------------------ 
-#
-# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-#
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#------------------------------------------------------------------------------
-
-  .text
-  .align 2
-  GCC_ASM_EXPORT(__divsi3)
-  
-ASM_PFX(__divsi3):
-  eor  r3, r0, r0, asr #31
-  eor  r2, r1, r1, asr #31
-  stmfd  sp!, {r4, r5, r7, lr}
-  mov  r5, r0, asr #31
-  add  r7, sp, #8
-  mov  r4, r1, asr #31
-  sub  r0, r3, r0, asr #31
-  sub  r1, r2, r1, asr #31
-  bl  ASM_PFX(__udivsi3)
-  eor  r1, r5, r4
-  eor  r0, r0, r1
-  rsb  r0, r1, r0
-  ldmfd  sp!, {r4, r5, r7, pc}
+#------------------------------------------------------------------------------ 

+#

+# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+  .text

+  .align 2

+  GCC_ASM_EXPORT(__divsi3)

+  

+ASM_PFX(__divsi3):

+  eor  r3, r0, r0, asr #31

+  eor  r2, r1, r1, asr #31

+  stmfd  sp!, {r4, r5, r7, lr}

+  mov  r5, r0, asr #31

+  add  r7, sp, #8

+  mov  r4, r1, asr #31

+  sub  r0, r3, r0, asr #31

+  sub  r1, r2, r1, asr #31

+  bl  ASM_PFX(__udivsi3)

+  eor  r1, r5, r4

+  eor  r0, r0, r1

+  rsb  r0, r1, r0

+  ldmfd  sp!, {r4, r5, r7, pc}

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/divsi3.c b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/divsi3.c
index 4a19e15a..b322f9a5 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/divsi3.c
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/divsi3.c
@@ -1,78 +1,78 @@
-/** @file
-  Compiler intrinsic for 32--bit unsigned division, ported from LLVM code.
-
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-/**
-  University of Illinois/NCSA
-  Open Source License
-  
-  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.
-  All rights reserved.
-  
-  Developed by:
-  
-      LLVM Team
-  
-      University of Illinois at Urbana-Champaign
-  
-      http://llvm.org
-  
-  Permission is hereby granted, free of charge, to any person obtaining a copy of
-  this software and associated documentation files (the "Software"), to deal with
-  the Software without restriction, including without limitation the rights to
-  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-  of the Software, and to permit persons to whom the Software is furnished to do
-  so, subject to the following conditions:
-  
-      * Redistributions of source code must retain the above copyright notice,
-        this list of conditions and the following disclaimers.
-  
-      * Redistributions in binary form must reproduce the above copyright notice,
-        this list of conditions and the following disclaimers in the
-        documentation and/or other materials provided with the distribution.
-  
-      * Neither the names of the LLVM Team, University of Illinois at
-        Urbana-Champaign, nor the names of its contributors may be used to
-        endorse or promote products derived from this Software without specific
-        prior written permission.
-  
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
-  SOFTWARE.
-**/
-
-
-#include "Llvm_int_lib.h"
-
-UINT32 __udivsi3(UINT32 n, UINT32 d);
-
-// Returns: a / b
-
-INT32
-__divsi3(INT32 a, INT32 b)
-{
-    const int bits_in_word_m1 = (int)(sizeof(INT32) * CHAR_BIT) - 1;
-    INT32 s_a = a >> bits_in_word_m1;           // s_a = a < 0 ? -1 : 0
-    INT32 s_b = b >> bits_in_word_m1;           // s_b = b < 0 ? -1 : 0
-    a = (a ^ s_a) - s_a;                         // negate if s_a == -1
-    b = (b ^ s_b) - s_b;                         // negate if s_b == -1
-    s_a ^= s_b;                                  // sign of quotient
-    return (__udivsi3(a, b) ^ s_a) - s_a;        // negate if s_a == -1
-}
-
-
+/** @file

+  Compiler intrinsic for 32--bit unsigned division, ported from LLVM code.

+

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+/**

+  University of Illinois/NCSA

+  Open Source License

+  

+  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.

+  All rights reserved.

+  

+  Developed by:

+  

+      LLVM Team

+  

+      University of Illinois at Urbana-Champaign

+  

+      http://llvm.org

+  

+  Permission is hereby granted, free of charge, to any person obtaining a copy of

+  this software and associated documentation files (the "Software"), to deal with

+  the Software without restriction, including without limitation the rights to

+  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies

+  of the Software, and to permit persons to whom the Software is furnished to do

+  so, subject to the following conditions:

+  

+      * Redistributions of source code must retain the above copyright notice,

+        this list of conditions and the following disclaimers.

+  

+      * Redistributions in binary form must reproduce the above copyright notice,

+        this list of conditions and the following disclaimers in the

+        documentation and/or other materials provided with the distribution.

+  

+      * Neither the names of the LLVM Team, University of Illinois at

+        Urbana-Champaign, nor the names of its contributors may be used to

+        endorse or promote products derived from this Software without specific

+        prior written permission.

+  

+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE

+  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE

+  SOFTWARE.

+**/

+

+

+#include "Llvm_int_lib.h"

+

+UINT32 __udivsi3(UINT32 n, UINT32 d);

+

+// Returns: a / b

+

+INT32

+__divsi3(INT32 a, INT32 b)

+{

+    const int bits_in_word_m1 = (int)(sizeof(INT32) * CHAR_BIT) - 1;

+    INT32 s_a = a >> bits_in_word_m1;           // s_a = a < 0 ? -1 : 0

+    INT32 s_b = b >> bits_in_word_m1;           // s_b = b < 0 ? -1 : 0

+    a = (a ^ s_a) - s_a;                         // negate if s_a == -1

+    b = (b ^ s_b) - s_b;                         // negate if s_b == -1

+    s_a ^= s_b;                                  // sign of quotient

+    return (__udivsi3(a, b) ^ s_a) - s_a;        // negate if s_a == -1

+}

+

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/lasr.asm b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/lasr.asm
index 1821816a..069438c9 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/lasr.asm
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/lasr.asm
@@ -1,41 +1,41 @@
-//------------------------------------------------------------------------------ 
-//
-// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-//
-// This program and the accompanying materials
-// are licensed and made available under the terms and conditions of the BSD License
-// which accompanies this distribution.  The full text of the license may be found at
-// http://opensource.org/licenses/bsd-license.php
-//
-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-//
-//------------------------------------------------------------------------------
-
-
-    EXPORT  __aeabi_lasr
-           
-    AREA    Math, CODE, READONLY
-
-;
-;UINT32
-;EFIAPI
-;__aeabi_lasr (
-;  IN UINT32  Dividen
-;  IN UINT32  Divisor
-;  );
-;
-__aeabi_lasr
-    SUBS     r3,r2,#0x20
-    BPL      {pc} + 0x18  ; 0x1c
-    RSB      r3,r2,#0x20
-    LSR      r0,r0,r2
-    ORR      r0,r0,r1,LSL r3
-    ASR      r1,r1,r2
-    BX       lr
-    ASR      r0,r1,r3
-    ASR      r1,r1,#31
-    BX       lr
-    
-    END
-
+//------------------------------------------------------------------------------ 

+//

+// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+//

+// This program and the accompanying materials

+// are licensed and made available under the terms and conditions of the BSD License

+// which accompanies this distribution.  The full text of the license may be found at

+// http://opensource.org/licenses/bsd-license.php

+//

+// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+//

+//------------------------------------------------------------------------------

+

+

+    EXPORT  __aeabi_lasr

+           

+    AREA    Math, CODE, READONLY

+

+;

+;UINT32

+;EFIAPI

+;__aeabi_lasr (

+;  IN UINT32  Dividen

+;  IN UINT32  Divisor

+;  );

+;

+__aeabi_lasr

+    SUBS     r3,r2,#0x20

+    BPL      {pc} + 0x18  ; 0x1c

+    RSB      r3,r2,#0x20

+    LSR      r0,r0,r2

+    ORR      r0,r0,r1,LSL r3

+    ASR      r1,r1,r2

+    BX       lr

+    ASR      r0,r1,r3

+    ASR      r1,r1,#31

+    BX       lr

+    

+    END

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ldivmod.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ldivmod.S
index 02ecdfe8..510778ab 100755
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ldivmod.S
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ldivmod.S
@@ -1,59 +1,59 @@
-//------------------------------------------------------------------------------ 
-//
-// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-//
-// This program and the accompanying materials
-// are licensed and made available under the terms and conditions of the BSD License
-// which accompanies this distribution.  The full text of the license may be found at
-// http://opensource.org/licenses/bsd-license.php
-//
-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-//
-//------------------------------------------------------------------------------
-
-
-  .text
-  .align 2
-  GCC_ASM_EXPORT(__aeabi_ldivmod)
-
-//
-// A pair of (unsigned) long longs is returned in {{r0, r1}, {r2, r3}}, 
-//  the quotient in {r0, r1}, and the remainder in {r2, r3}.
-//
-//__value_in_regs lldiv_t
-//EFIAPI
-//__aeabi_ldivmod (
-//  IN UINT64  Dividen
-//  IN UINT64  Divisor
-//  )//
-//
-
-ASM_PFX(__aeabi_ldivmod):
-    push     {r4,lr}
-    asrs     r4,r1,#1
-    eor      r4,r4,r3,LSR #1
-    bpl      L_Test1
-    rsbs     r0,r0,#0
-    rsc      r1,r1,#0
-L_Test1:
-    tst      r3,r3
-    bpl      L_Test2
-    rsbs     r2,r2,#0
-    rsc      r3,r3,#0
-L_Test2:
-    bl       ASM_PFX(__aeabi_uldivmod)  
-    tst      r4,#0x40000000
-    beq      L_Test3
-    rsbs     r0,r0,#0
-    rsc      r1,r1,#0
-L_Test3:
-    tst      r4,#0x80000000
-    beq      L_Exit
-    rsbs     r2,r2,#0
-    rsc      r3,r3,#0
-L_Exit:
-    pop      {r4,pc}
- 
-
-
+//------------------------------------------------------------------------------ 

+//

+// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+//

+// This program and the accompanying materials

+// are licensed and made available under the terms and conditions of the BSD License

+// which accompanies this distribution.  The full text of the license may be found at

+// http://opensource.org/licenses/bsd-license.php

+//

+// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+//

+//------------------------------------------------------------------------------

+

+

+  .text

+  .align 2

+  GCC_ASM_EXPORT(__aeabi_ldivmod)

+

+//

+// A pair of (unsigned) long longs is returned in {{r0, r1}, {r2, r3}}, 

+//  the quotient in {r0, r1}, and the remainder in {r2, r3}.

+//

+//__value_in_regs lldiv_t

+//EFIAPI

+//__aeabi_ldivmod (

+//  IN UINT64  Dividen

+//  IN UINT64  Divisor

+//  )//

+//

+

+ASM_PFX(__aeabi_ldivmod):

+    push     {r4,lr}

+    asrs     r4,r1,#1

+    eor      r4,r4,r3,LSR #1

+    bpl      L_Test1

+    rsbs     r0,r0,#0

+    rsc      r1,r1,#0

+L_Test1:

+    tst      r3,r3

+    bpl      L_Test2

+    rsbs     r2,r2,#0

+    rsc      r3,r3,#0

+L_Test2:

+    bl       ASM_PFX(__aeabi_uldivmod)  

+    tst      r4,#0x40000000

+    beq      L_Test3

+    rsbs     r0,r0,#0

+    rsc      r1,r1,#0

+L_Test3:

+    tst      r4,#0x80000000

+    beq      L_Exit

+    rsbs     r2,r2,#0

+    rsc      r3,r3,#0

+L_Exit:

+    pop      {r4,pc}

+ 

+

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ldivmod.asm b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ldivmod.asm
index 32b65df5..0059c2f6 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ldivmod.asm
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ldivmod.asm
@@ -1,58 +1,58 @@
-//------------------------------------------------------------------------------ 
-//
-// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-//
-// This program and the accompanying materials
-// are licensed and made available under the terms and conditions of the BSD License
-// which accompanies this distribution.  The full text of the license may be found at
-// http://opensource.org/licenses/bsd-license.php
-//
-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-//
-//------------------------------------------------------------------------------
-
-
-    EXPORT  __aeabi_ldivmod
-    EXTERN  __aeabi_uldivmod
-           
-    AREA    Math, CODE, READONLY
-
-;
-;UINT32
-;EFIAPI
-;__aeabi_uidivmode (
-;  IN UINT32  Dividen
-;  IN UINT32  Divisor
-;  );
-;
-
-__aeabi_ldivmod
-    PUSH     {r4,lr}
-    ASRS     r4,r1,#1
-    EOR      r4,r4,r3,LSR #1
-    BPL      L_Test1
-    RSBS     r0,r0,#0
-    RSC      r1,r1,#0
-L_Test1
-    TST      r3,r3
-    BPL      L_Test2
-    RSBS     r2,r2,#0
-    RSC      r3,r3,#0
-L_Test2
-    BL       __aeabi_uldivmod  ;
-    TST      r4,#0x40000000
-    BEQ      L_Test3
-    RSBS     r0,r0,#0
-    RSC      r1,r1,#0
-L_Test3
-    TST      r4,#0x80000000
-    BEQ      L_Exit
-    RSBS     r2,r2,#0
-    RSC      r3,r3,#0
-L_Exit
-    POP      {r4,pc}
- 
-    END
-
-
+//------------------------------------------------------------------------------ 

+//

+// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+//

+// This program and the accompanying materials

+// are licensed and made available under the terms and conditions of the BSD License

+// which accompanies this distribution.  The full text of the license may be found at

+// http://opensource.org/licenses/bsd-license.php

+//

+// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+//

+//------------------------------------------------------------------------------

+

+

+    EXPORT  __aeabi_ldivmod

+    EXTERN  __aeabi_uldivmod

+           

+    AREA    Math, CODE, READONLY

+

+;

+;UINT32

+;EFIAPI

+;__aeabi_uidivmode (

+;  IN UINT32  Dividen

+;  IN UINT32  Divisor

+;  );

+;

+

+__aeabi_ldivmod

+    PUSH     {r4,lr}

+    ASRS     r4,r1,#1

+    EOR      r4,r4,r3,LSR #1

+    BPL      L_Test1

+    RSBS     r0,r0,#0

+    RSC      r1,r1,#0

+L_Test1

+    TST      r3,r3

+    BPL      L_Test2

+    RSBS     r2,r2,#0

+    RSC      r3,r3,#0

+L_Test2

+    BL       __aeabi_uldivmod  ;

+    TST      r4,#0x40000000

+    BEQ      L_Test3

+    RSBS     r0,r0,#0

+    RSC      r1,r1,#0

+L_Test3

+    TST      r4,#0x80000000

+    BEQ      L_Exit

+    RSBS     r2,r2,#0

+    RSC      r3,r3,#0

+L_Exit

+    POP      {r4,pc}

+ 

+    END

+

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/llsl.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/llsl.S
new file mode 100644
index 00000000..ba8ab1cf
--- /dev/null
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/llsl.S
@@ -0,0 +1,40 @@
+#------------------------------------------------------------------------------

+#

+# Copyright (c) 2013, ARM. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+

+.text

+.align 2

+GCC_ASM_EXPORT(__aeabi_llsl)

+

+#

+#VOID

+#EFIAPI

+#__aeabi_llsl (

+# IN  VOID    *Destination,

+# IN  VOID    *Source,

+# IN  UINT32  Size

+# );

+#

+ASM_PFX(__aeabi_llsl):

+    subs     r3,r2,#0x20

+    bpl      1f

+    rsb      r3,r2,#0x20

+    lsl      r1,r1,r2

+    orr      r1,r1,r0,lsr r3

+    lsl      r0,r0,r2

+    bx       lr

+1:

+    lsl      r1,r0,r3

+    mov      r0,#0

+    bx       lr

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/llsl.asm b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/llsl.asm
index 09969394..43d9e729 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/llsl.asm
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/llsl.asm
@@ -1,43 +1,43 @@
-//------------------------------------------------------------------------------ 
-//
-// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-//
-// This program and the accompanying materials
-// are licensed and made available under the terms and conditions of the BSD License
-// which accompanies this distribution.  The full text of the license may be found at
-// http://opensource.org/licenses/bsd-license.php
-//
-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-//
-//------------------------------------------------------------------------------
-
-
-    EXPORT  __aeabi_llsl
-
-    AREA    Math, CODE, READONLY
-
-;
-;VOID
-;EFIAPI
-;__aeabi_llsl (
-; IN  VOID    *Destination,
-; IN  VOID    *Source,
-; IN  UINT32  Size
-; );
-;
-
-__aeabi_llsl
-    SUBS     r3,r2,#0x20
-    BPL      {pc} + 0x18  ; 0x1c
-    RSB      r3,r2,#0x20
-    LSL      r1,r1,r2
-    ORR      r1,r1,r0,LSR r3
-    LSL      r0,r0,r2
-    BX       lr
-    LSL      r1,r0,r3
-    MOV      r0,#0
-    BX       lr
-
-    END
-
+//------------------------------------------------------------------------------ 

+//

+// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+//

+// This program and the accompanying materials

+// are licensed and made available under the terms and conditions of the BSD License

+// which accompanies this distribution.  The full text of the license may be found at

+// http://opensource.org/licenses/bsd-license.php

+//

+// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+//

+//------------------------------------------------------------------------------

+

+

+    EXPORT  __aeabi_llsl

+

+    AREA    Math, CODE, READONLY

+

+;

+;VOID

+;EFIAPI

+;__aeabi_llsl (

+; IN  VOID    *Destination,

+; IN  VOID    *Source,

+; IN  UINT32  Size

+; );

+;

+

+__aeabi_llsl

+    SUBS     r3,r2,#0x20

+    BPL      {pc} + 0x18  ; 0x1c

+    RSB      r3,r2,#0x20

+    LSL      r1,r1,r2

+    ORR      r1,r1,r0,LSR r3

+    LSL      r0,r0,r2

+    BX       lr

+    LSL      r1,r0,r3

+    MOV      r0,#0

+    BX       lr

+

+    END

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/llsr.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/llsr.S
new file mode 100644
index 00000000..3d2c1062
--- /dev/null
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/llsr.S
@@ -0,0 +1,40 @@
+#------------------------------------------------------------------------------

+#

+# Copyright (c) 2013, ARM. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+

+.text

+.align 2

+GCC_ASM_EXPORT(__aeabi_llsr)

+

+#

+#VOID

+#EFIAPI

+#__aeabi_llsr (

+# IN  VOID    *Destination,

+# IN  VOID    *Source,

+# IN  UINT32  Size

+# );

+#

+ASM_PFX(__aeabi_llsr):

+    subs     r3,r2,#0x20

+    bpl      1f

+    rsb      r3,r2,#0x20

+    lsr      r0,r0,r2

+    orr      r0,r0,r1,lsl r3

+    lsr      r1,r1,r2

+    bx       lr

+1:

+    lsr      r0,r1,r3

+    mov      r1,#0

+    bx       lr

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/llsr.asm b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/llsr.asm
index 8f1af0ed..de9a2186 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/llsr.asm
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/llsr.asm
@@ -1,44 +1,44 @@
-//------------------------------------------------------------------------------ 
-//
-// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-//
-// This program and the accompanying materials
-// are licensed and made available under the terms and conditions of the BSD License
-// which accompanies this distribution.  The full text of the license may be found at
-// http://opensource.org/licenses/bsd-license.php
-//
-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-//
-//------------------------------------------------------------------------------
-
-
-    EXPORT  __aeabi_llsr
-
-    AREA    Math, CODE, READONLY
-
-;
-;VOID
-;EFIAPI
-;__aeabi_llsr (
-; IN  VOID    *Destination,
-; IN  VOID    *Source,
-; IN  UINT32  Size
-; );
-;
-__aeabi_llsr
-    SUBS     r3,r2,#0x20
-    BPL      {pc} + 0x18  ; 0x1c
-    RSB      r3,r2,#0x20
-    LSR      r0,r0,r2
-    ORR      r0,r0,r1,LSL r3
-    LSR      r1,r1,r2
-    BX       lr
-    LSR      r0,r1,r3
-    MOV      r1,#0
-    BX       lr
-
-    END
-
-
-
+//------------------------------------------------------------------------------ 

+//

+// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+//

+// This program and the accompanying materials

+// are licensed and made available under the terms and conditions of the BSD License

+// which accompanies this distribution.  The full text of the license may be found at

+// http://opensource.org/licenses/bsd-license.php

+//

+// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+//

+//------------------------------------------------------------------------------

+

+

+    EXPORT  __aeabi_llsr

+

+    AREA    Math, CODE, READONLY

+

+;

+;VOID

+;EFIAPI

+;__aeabi_llsr (

+; IN  VOID    *Destination,

+; IN  VOID    *Source,

+; IN  UINT32  Size

+; );

+;

+__aeabi_llsr

+    SUBS     r3,r2,#0x20

+    BPL      {pc} + 0x18  ; 0x1c

+    RSB      r3,r2,#0x20

+    LSR      r0,r0,r2

+    ORR      r0,r0,r1,LSL r3

+    LSR      r1,r1,r2

+    BX       lr

+    LSR      r0,r1,r3

+    MOV      r1,#0

+    BX       lr

+

+    END

+

+

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/lshrdi3.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/lshrdi3.S
index 73d83599..efec070c 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/lshrdi3.S
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/lshrdi3.S
@@ -1,35 +1,35 @@
-#------------------------------------------------------------------------------ 
-#
-# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-#
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#------------------------------------------------------------------------------
-
-  .text
-  .align 2
-  GCC_ASM_EXPORT(__lshrdi3)
-  
-ASM_PFX(__lshrdi3):
-  cmp  r2, #31
-  bls  L2
-  cmp  r2, #63
-  subls  r2, r2, #32
-  movls  r2, r1, lsr r2
-  movhi  r2, #0
-  mov  r0, r2
-  mov  r1, #0
-  bx  lr
-L2:
-  cmp  r2, #0
-  rsbne  r3, r2, #32
-  movne  r3, r1, asl r3
-  movne  r1, r1, lsr r2
-  orrne  r0, r3, r0, lsr r2
-  bx  lr
+#------------------------------------------------------------------------------ 

+#

+# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+  .text

+  .align 2

+  GCC_ASM_EXPORT(__lshrdi3)

+  

+ASM_PFX(__lshrdi3):

+  cmp  r2, #31

+  bls  L2

+  cmp  r2, #63

+  subls  r2, r2, #32

+  movls  r2, r1, lsr r2

+  movhi  r2, #0

+  mov  r0, r2

+  mov  r1, #0

+  bx  lr

+L2:

+  cmp  r2, #0

+  rsbne  r3, r2, #32

+  movne  r3, r1, asl r3

+  movne  r1, r1, lsr r2

+  orrne  r0, r3, r0, lsr r2

+  bx  lr

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/lshrdi3.c b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/lshrdi3.c
index 4353be9d..47c80c2d 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/lshrdi3.c
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/lshrdi3.c
@@ -1,83 +1,83 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-/**
-  University of Illinois/NCSA
-  Open Source License
-  
-  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.
-  All rights reserved.
-  
-  Developed by:
-  
-      LLVM Team
-  
-      University of Illinois at Urbana-Champaign
-  
-      http://llvm.org
-  
-  Permission is hereby granted, free of charge, to any person obtaining a copy of
-  this software and associated documentation files (the "Software"), to deal with
-  the Software without restriction, including without limitation the rights to
-  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-  of the Software, and to permit persons to whom the Software is furnished to do
-  so, subject to the following conditions:
-  
-      * Redistributions of source code must retain the above copyright notice,
-        this list of conditions and the following disclaimers.
-  
-      * Redistributions in binary form must reproduce the above copyright notice,
-        this list of conditions and the following disclaimers in the
-        documentation and/or other materials provided with the distribution.
-  
-      * Neither the names of the LLVM Team, University of Illinois at
-        Urbana-Champaign, nor the names of its contributors may be used to
-        endorse or promote products derived from this Software without specific
-        prior written permission.
-  
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
-  SOFTWARE.
-**/
-
-#include "Llvm_int_lib.h"
-
-// Returns: logical a >> b
-
-// Precondition:  0 <= b < bits_in_dword
-
-INT64
-__lshrdi3(INT64 a, INT32 b)
-{
-    const int bits_in_word = (int)(sizeof(INT32) * CHAR_BIT);
-    udwords input;
-    udwords result;
-    input.all = a;
-    if (b & bits_in_word)  // bits_in_word <= b < bits_in_dword
-    {
-        result.high = 0;
-        result.low = input.high >> (b - bits_in_word);
-    }
-    else  // 0 <= b < bits_in_word
-    {
-        if (b == 0)
-            return a;
-        result.high  = input.high >> b;
-        result.low = (input.high << (bits_in_word - b)) | (input.low >> b);
-    }
-    return result.all;
-}
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+/**

+  University of Illinois/NCSA

+  Open Source License

+  

+  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.

+  All rights reserved.

+  

+  Developed by:

+  

+      LLVM Team

+  

+      University of Illinois at Urbana-Champaign

+  

+      http://llvm.org

+  

+  Permission is hereby granted, free of charge, to any person obtaining a copy of

+  this software and associated documentation files (the "Software"), to deal with

+  the Software without restriction, including without limitation the rights to

+  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies

+  of the Software, and to permit persons to whom the Software is furnished to do

+  so, subject to the following conditions:

+  

+      * Redistributions of source code must retain the above copyright notice,

+        this list of conditions and the following disclaimers.

+  

+      * Redistributions in binary form must reproduce the above copyright notice,

+        this list of conditions and the following disclaimers in the

+        documentation and/or other materials provided with the distribution.

+  

+      * Neither the names of the LLVM Team, University of Illinois at

+        Urbana-Champaign, nor the names of its contributors may be used to

+        endorse or promote products derived from this Software without specific

+        prior written permission.

+  

+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE

+  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE

+  SOFTWARE.

+**/

+

+#include "Llvm_int_lib.h"

+

+// Returns: logical a >> b

+

+// Precondition:  0 <= b < bits_in_dword

+

+INT64

+__lshrdi3(INT64 a, INT32 b)

+{

+    const int bits_in_word = (int)(sizeof(INT32) * CHAR_BIT);

+    udwords input;

+    udwords result;

+    input.all = a;

+    if (b & bits_in_word)  // bits_in_word <= b < bits_in_dword

+    {

+        result.high = 0;

+        result.low = input.high >> (b - bits_in_word);

+    }

+    else  // 0 <= b < bits_in_word

+    {

+        if (b == 0)

+            return a;

+        result.high  = input.high >> b;

+        result.low = (input.high << (bits_in_word - b)) | (input.low >> b);

+    }

+    return result.all;

+}

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/memcpy.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/memcpy.S
index 18299326..07e0cd6b 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/memcpy.S
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/memcpy.S
@@ -1,34 +1,34 @@
-#------------------------------------------------------------------------------ 
-#
-# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-#
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#------------------------------------------------------------------------------
-
-  .text
-  .align 2
-  GCC_ASM_EXPORT(memcpy)
-
-ASM_PFX(memcpy):
-  stmfd  sp!, {r7, lr}
-  mov  ip, #0
-  add  r7, sp, #0
-  mov  lr, r0
-  b  L4
-L5:
-  ldrb  r3, [r1], #1  @ zero_extendqisi2
-  add  ip, ip, #1
-  and  r3, r3, #255
-  strb  r3, [lr], #1
-L4:
-  cmp  ip, r2
-  bne  L5
-  ldmfd  sp!, {r7, pc}
-
+#------------------------------------------------------------------------------ 

+#

+# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+  .text

+  .align 2

+  GCC_ASM_EXPORT(memcpy)

+

+ASM_PFX(memcpy):

+  stmfd  sp!, {r7, lr}

+  mov  ip, #0

+  add  r7, sp, #0

+  mov  lr, r0

+  b  L4

+L5:

+  ldrb  r3, [r1], #1  @ zero_extendqisi2

+  add  ip, ip, #1

+  and  r3, r3, #255

+  strb  r3, [lr], #1

+L4:

+  cmp  ip, r2

+  bne  L5

+  ldmfd  sp!, {r7, pc}

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/memcpy.asm b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/memcpy.asm
index aef8a5c1..e01b80d4 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/memcpy.asm
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/memcpy.asm
@@ -1,40 +1,40 @@
-//------------------------------------------------------------------------------ 
-//
-// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-//
-// This program and the accompanying materials
-// are licensed and made available under the terms and conditions of the BSD License
-// which accompanies this distribution.  The full text of the license may be found at
-// http://opensource.org/licenses/bsd-license.php
-//
-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-//
-//------------------------------------------------------------------------------
-
-
-    EXPORT  __aeabi_memcpy
-
-    AREA    Memcpy, CODE, READONLY
-
-;
-;VOID
-;EFIAPI
-;__aeabi_memcpy (
-; IN  VOID    *Destination,
-; IN  VOID    *Source,
-; IN  UINT32  Size
-; );
-;
-__aeabi_memcpy
-    CMP     r2, #0
-    BXEQ    r14
-loop
-    LDRB    r3, [r1], #1
-    STRB    r3, [r0], #1
-    SUBS    r2, r2, #1
-    BXEQ    r14
-    B       loop
-        
-    END
-
+//------------------------------------------------------------------------------ 

+//

+// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+//

+// This program and the accompanying materials

+// are licensed and made available under the terms and conditions of the BSD License

+// which accompanies this distribution.  The full text of the license may be found at

+// http://opensource.org/licenses/bsd-license.php

+//

+// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+//

+//------------------------------------------------------------------------------

+

+

+    EXPORT  __aeabi_memcpy

+

+    AREA    Memcpy, CODE, READONLY

+

+;

+;VOID

+;EFIAPI

+;__aeabi_memcpy (

+; IN  VOID    *Destination,

+; IN  VOID    *Source,

+; IN  UINT32  Size

+; );

+;

+__aeabi_memcpy

+    CMP     r2, #0

+    BXEQ    r14

+loop

+    LDRB    r3, [r1], #1

+    STRB    r3, [r0], #1

+    SUBS    r2, r2, #1

+    BXEQ    r14

+    B       loop

+        

+    END

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/memcpy4.asm b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/memcpy4.asm
index a3cd58ab..9780060c 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/memcpy4.asm
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/memcpy4.asm
@@ -1,61 +1,61 @@
-//------------------------------------------------------------------------------ 
-//
-// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-//
-// This program and the accompanying materials
-// are licensed and made available under the terms and conditions of the BSD License
-// which accompanies this distribution.  The full text of the license may be found at
-// http://opensource.org/licenses/bsd-license.php
-//
-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-//
-//------------------------------------------------------------------------------
-
-
-    EXPORT  __aeabi_memcpy4
-
-    AREA    Memcpy4, CODE, READONLY
-
-;
-;VOID
-;EFIAPI
-;__aeabi_memcpy (
-; IN  VOID    *Destination,
-; IN  VOID    *Source,
-; IN  UINT32  Size
-; );
-;
-__aeabi_memcpy4
-    stmdb   sp!, {r4, lr}
-    subs    r2, r2, #32     ; 0x20
-    bcc     memcpy4_label2
-memcpy4_label1
-    ldmcsia r1!, {r3, r4, ip, lr}
-    stmcsia r0!, {r3, r4, ip, lr}
-    ldmcsia r1!, {r3, r4, ip, lr}
-    stmcsia r0!, {r3, r4, ip, lr}
-    subcss  r2, r2, #32     ; 0x20
-    bcs     memcpy4_label1
-memcpy4_label2
-    movs    ip, r2, lsl #28
-    ldmcsia r1!, {r3, r4, ip, lr}
-    stmcsia r0!, {r3, r4, ip, lr}
-    ldmmiia r1!, {r3, r4}
-    stmmiia r0!, {r3, r4}
-    ldmia   sp!, {r4, lr}
-    movs    ip, r2, lsl #30
-    ldrcs   r3, [r1], #4
-    strcs   r3, [r0], #4
-    bxeq    lr
-
-_memcpy4_lastbytes_aligned
-    movs    r2, r2, lsl #31
-    ldrcsh  r3, [r1], #2
-    ldrmib  r2, [r1], #1
-    strcsh  r3, [r0], #2
-    strmib  r2, [r0], #1
-    bx      lr
-
-    END
-
+//------------------------------------------------------------------------------ 

+//

+// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+//

+// This program and the accompanying materials

+// are licensed and made available under the terms and conditions of the BSD License

+// which accompanies this distribution.  The full text of the license may be found at

+// http://opensource.org/licenses/bsd-license.php

+//

+// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+//

+//------------------------------------------------------------------------------

+

+

+    EXPORT  __aeabi_memcpy4

+

+    AREA    Memcpy4, CODE, READONLY

+

+;

+;VOID

+;EFIAPI

+;__aeabi_memcpy (

+; IN  VOID    *Destination,

+; IN  VOID    *Source,

+; IN  UINT32  Size

+; );

+;

+__aeabi_memcpy4

+    stmdb   sp!, {r4, lr}

+    subs    r2, r2, #32     ; 0x20

+    bcc     memcpy4_label2

+memcpy4_label1

+    ldmcsia r1!, {r3, r4, ip, lr}

+    stmcsia r0!, {r3, r4, ip, lr}

+    ldmcsia r1!, {r3, r4, ip, lr}

+    stmcsia r0!, {r3, r4, ip, lr}

+    subcss  r2, r2, #32     ; 0x20

+    bcs     memcpy4_label1

+memcpy4_label2

+    movs    ip, r2, lsl #28

+    ldmcsia r1!, {r3, r4, ip, lr}

+    stmcsia r0!, {r3, r4, ip, lr}

+    ldmmiia r1!, {r3, r4}

+    stmmiia r0!, {r3, r4}

+    ldmia   sp!, {r4, lr}

+    movs    ip, r2, lsl #30

+    ldrcs   r3, [r1], #4

+    strcs   r3, [r0], #4

+    bxeq    lr

+

+_memcpy4_lastbytes_aligned

+    movs    r2, r2, lsl #31

+    ldrcsh  r3, [r1], #2

+    ldrmib  r2, [r1], #1

+    strcsh  r3, [r0], #2

+    strmib  r2, [r0], #1

+    bx      lr

+

+    END

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/memmove.asm b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/memmove.asm
index d84429ef..ae5c990f 100755
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/memmove.asm
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/memmove.asm
@@ -1,54 +1,54 @@
-//------------------------------------------------------------------------------ 
-//
-// Copyright (c) 2011, ARM Limited. All rights reserved.
-//
-// This program and the accompanying materials
-// are licensed and made available under the terms and conditions of the BSD License
-// which accompanies this distribution.  The full text of the license may be found at
-// http://opensource.org/licenses/bsd-license.php
-//
-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-//
-//------------------------------------------------------------------------------
-
-
-    EXPORT  __aeabi_memmove
-
-    AREA    Memmove, CODE, READONLY
-
-;
-;VOID
-;EFIAPI
-;__aeabi_memmove (
-; IN  VOID          *Destination,
-; IN  CONST VOID    *Source,
-; IN  UINT32        Size
-; );
-;
-__aeabi_memmove
-  CMP     r2, #0
-  BXEQ    r14
-  CMP     r0, r1
-  BXEQ    r14
-  BHI     memmove_backward
-  BLS     memmove_forward
-
-memmove_forward
-  LDRB    r3, [r1], #1
-  STRB    r3, [r0], #1
-  SUBS    r2, r2, #1
-  BXEQ    r14
-  B       memmove_forward
-
-memmove_backward
-  add     r0, r2
-  add     r1, r2
-memmove_backward_loop
-  LDRB    r3, [r1], #-1
-  STRB    r3, [r0], #-1
-  SUBS    r2, r2, #-1
-  BXEQ    r14
-  B       memmove_backward_loop
-
-  END
+//------------------------------------------------------------------------------ 

+//

+// Copyright (c) 2011, ARM Limited. All rights reserved.

+//

+// This program and the accompanying materials

+// are licensed and made available under the terms and conditions of the BSD License

+// which accompanies this distribution.  The full text of the license may be found at

+// http://opensource.org/licenses/bsd-license.php

+//

+// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+//

+//------------------------------------------------------------------------------

+

+

+    EXPORT  __aeabi_memmove

+

+    AREA    Memmove, CODE, READONLY

+

+;

+;VOID

+;EFIAPI

+;__aeabi_memmove (

+; IN  VOID          *Destination,

+; IN  CONST VOID    *Source,

+; IN  UINT32        Size

+; );

+;

+__aeabi_memmove

+  CMP     r2, #0

+  BXEQ    r14

+  CMP     r0, r1

+  BXEQ    r14

+  BHI     memmove_backward

+  BLS     memmove_forward

+

+memmove_forward

+  LDRB    r3, [r1], #1

+  STRB    r3, [r0], #1

+  SUBS    r2, r2, #1

+  BXEQ    r14

+  B       memmove_forward

+

+memmove_backward

+  add     r0, r2

+  add     r1, r2

+memmove_backward_loop

+  LDRB    r3, [r1], #-1

+  STRB    r3, [r0], #-1

+  SUBS    r2, r2, #-1

+  BXEQ    r14

+  B       memmove_backward_loop

+

+  END

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/memset.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/memset.S
index 35783620..7b1cf8d9 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/memset.S
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/memset.S
@@ -1,38 +1,38 @@
-#------------------------------------------------------------------------------ 
-#
-# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-#
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#------------------------------------------------------------------------------
-
-
-  .text
-  .align 2
-  GCC_ASM_EXPORT (memset)
-
-
-ASM_PFX(memset):
-
-  @ args = 0, pretend = 0, frame = 0
-  @ frame_needed = 1, uses_anonymous_args = 0
-  stmfd  sp!, {r7, lr}
-  mov  ip, #0
-  add  r7, sp, #0
-  mov  lr, r0
-  b  L9
-L10:
-  and  r3, r1, #255
-  add  ip, ip, #1
-  strb  r3, [lr], #1
-L9:
-  cmp  ip, r2
-  bne  L10
-  ldmfd  sp!, {r7, pc}
-
+#------------------------------------------------------------------------------ 

+#

+# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+

+  .text

+  .align 2

+  GCC_ASM_EXPORT (memset)

+

+

+ASM_PFX(memset):

+

+  @ args = 0, pretend = 0, frame = 0

+  @ frame_needed = 1, uses_anonymous_args = 0

+  stmfd  sp!, {r7, lr}

+  mov  ip, #0

+  add  r7, sp, #0

+  mov  lr, r0

+  b  L9

+L10:

+  and  r3, r1, #255

+  add  ip, ip, #1

+  strb  r3, [lr], #1

+L9:

+  cmp  ip, r2

+  bne  L10

+  ldmfd  sp!, {r7, pc}

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/memset.asm b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/memset.asm
index d567cd54..74e02430 100755
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/memset.asm
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/memset.asm
@@ -1,59 +1,59 @@
-//------------------------------------------------------------------------------
-//
-// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-//
-// This program and the accompanying materials
-// are licensed and made available under the terms and conditions of the BSD License
-// which accompanies this distribution.  The full text of the license may be found at
-// http://opensource.org/licenses/bsd-license.php
-//
-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-//
-//------------------------------------------------------------------------------
-
-
-    EXPORT  __aeabi_memset
-    EXPORT  __aeabi_memclr
-    EXPORT  __aeabi_memclr4
-
-    AREA    Memset, CODE, READONLY
-
-;
-;VOID
-;EFIAPI
-;__aeabi_memset (
-; IN  VOID    *Destination,
-; IN  UINT32  Character,
-; IN  UINT32  Size
-; );
-;
-__aeabi_memset
-
-  ; args = 0, pretend = 0, frame = 0
-  ; frame_needed = 1, uses_anonymous_args = 0
-  stmfd  sp!, {r7, lr}
-  mov  ip, #0
-  add  r7, sp, #0
-  mov  lr, r0
-  b  L9
-L10
-  and  r3, r1, #255
-  add  ip, ip, #1
-  strb  r3, [lr], #1
-L9
-  cmp  ip, r2
-  bne  L10
-  ldmfd  sp!, {r7, pc}
-
-__aeabi_memclr
-  mov   r2, r1
-  mov   r1, #0
-  b     __aeabi_memset
-
-__aeabi_memclr4
-  mov   r2, r1
-  mov   r1, #0
-  b     __aeabi_memset
-
-  END
+//------------------------------------------------------------------------------

+//

+// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+//

+// This program and the accompanying materials

+// are licensed and made available under the terms and conditions of the BSD License

+// which accompanies this distribution.  The full text of the license may be found at

+// http://opensource.org/licenses/bsd-license.php

+//

+// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+//

+//------------------------------------------------------------------------------

+

+

+    EXPORT  __aeabi_memset

+    EXPORT  __aeabi_memclr

+    EXPORT  __aeabi_memclr4

+

+    AREA    Memset, CODE, READONLY

+

+;

+;VOID

+;EFIAPI

+;__aeabi_memset (

+; IN  VOID    *Destination,

+; IN  UINT32  Character,

+; IN  UINT32  Size

+; );

+;

+__aeabi_memset

+

+  ; args = 0, pretend = 0, frame = 0

+  ; frame_needed = 1, uses_anonymous_args = 0

+  stmfd  sp!, {r7, lr}

+  mov  ip, #0

+  add  r7, sp, #0

+  mov  lr, r0

+  b  L9

+L10

+  and  r3, r1, #255

+  add  ip, ip, #1

+  strb  r3, [lr], #1

+L9

+  cmp  ip, r2

+  bne  L10

+  ldmfd  sp!, {r7, pc}

+

+__aeabi_memclr

+  mov   r2, r1

+  mov   r1, #0

+  b     __aeabi_memset

+

+__aeabi_memclr4

+  mov   r2, r1

+  mov   r1, #0

+  b     __aeabi_memset

+

+  END

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/moddi3.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/moddi3.S
index 75572c82..e058ea44 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/moddi3.S
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/moddi3.S
@@ -1,46 +1,46 @@
-#------------------------------------------------------------------------------ 
-#
-# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-#
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#------------------------------------------------------------------------------
-
-  .text
-  .align 2
-  GCC_ASM_EXPORT(__moddi3)
-
-ASM_PFX(__moddi3):
-  stmfd  sp!, {r4, r5, r7, lr}
-  mov  r4, r1, asr #31
-  add  r7, sp, #8
-  stmfd  sp!, {r10, r11}
-  mov  r10, r3, asr #31
-  sub  sp, sp, #16
-  mov  r5, r4
-  mov  r11, r10
-  eor  r0, r0, r4
-  eor  r1, r1, r4
-  eor  r2, r2, r10
-  eor  r3, r3, r10
-  add  ip, sp, #8
-  subs  r0, r0, r4
-  sbc  r1, r1, r5
-  subs  r2, r2, r10
-  sbc  r3, r3, r11
-  str  ip, [sp, #0]
-  bl  ASM_PFX(__udivmoddi4)
-  ldrd  r0, [sp, #8]
-  eor  r0, r0, r4
-  eor  r1, r1, r4
-  subs  r0, r0, r4
-  sbc  r1, r1, r5
-  sub  sp, r7, #16
-  ldmfd  sp!, {r10, r11}
-  ldmfd  sp!, {r4, r5, r7, pc}
+#------------------------------------------------------------------------------ 

+#

+# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+  .text

+  .align 2

+  GCC_ASM_EXPORT(__moddi3)

+

+ASM_PFX(__moddi3):

+  stmfd  sp!, {r4, r5, r7, lr}

+  mov  r4, r1, asr #31

+  add  r7, sp, #8

+  stmfd  sp!, {r10, r11}

+  mov  r10, r3, asr #31

+  sub  sp, sp, #16

+  mov  r5, r4

+  mov  r11, r10

+  eor  r0, r0, r4

+  eor  r1, r1, r4

+  eor  r2, r2, r10

+  eor  r3, r3, r10

+  add  ip, sp, #8

+  subs  r0, r0, r4

+  sbc  r1, r1, r5

+  subs  r2, r2, r10

+  sbc  r3, r3, r11

+  str  ip, [sp, #0]

+  bl  ASM_PFX(__udivmoddi4)

+  ldrd  r0, [sp, #8]

+  eor  r0, r0, r4

+  eor  r1, r1, r4

+  subs  r0, r0, r4

+  sbc  r1, r1, r5

+  sub  sp, r7, #16

+  ldmfd  sp!, {r10, r11}

+  ldmfd  sp!, {r4, r5, r7, pc}

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/moddi3.c b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/moddi3.c
index f9e5afe9..972fc065 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/moddi3.c
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/moddi3.c
@@ -1,77 +1,77 @@
-/** @file
-  Compiler intrinsic for 64-bit mod, ported from LLVM code.
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-/**
-  University of Illinois/NCSA
-  Open Source License
-  
-  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.
-  All rights reserved.
-  
-  Developed by:
-  
-      LLVM Team
-  
-      University of Illinois at Urbana-Champaign
-  
-      http://llvm.org
-  
-  Permission is hereby granted, free of charge, to any person obtaining a copy of
-  this software and associated documentation files (the "Software"), to deal with
-  the Software without restriction, including without limitation the rights to
-  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-  of the Software, and to permit persons to whom the Software is furnished to do
-  so, subject to the following conditions:
-  
-      * Redistributions of source code must retain the above copyright notice,
-        this list of conditions and the following disclaimers.
-  
-      * Redistributions in binary form must reproduce the above copyright notice,
-        this list of conditions and the following disclaimers in the
-        documentation and/or other materials provided with the distribution.
-  
-      * Neither the names of the LLVM Team, University of Illinois at
-        Urbana-Champaign, nor the names of its contributors may be used to
-        endorse or promote products derived from this Software without specific
-        prior written permission.
-  
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
-  SOFTWARE.
-**/
-
-
-#include "Llvm_int_lib.h"
-
-UINT64 __udivmoddi4(UINT64 a, UINT64 b, UINT64* rem);
-
-// Returns: a % b
-
-INT64
-__moddi3(INT64 a, INT64 b)
-{
-    const int bits_in_dword_m1 = (int)(sizeof(INT64) * CHAR_BIT) - 1;
-    INT64 s = b >> bits_in_dword_m1;  // s = b < 0 ? -1 : 0
-    b = (b ^ s) - s;                   // negate if s == -1
-    s = a >> bits_in_dword_m1;         // s = a < 0 ? -1 : 0
-    a = (a ^ s) - s;                   // negate if s == -1
-    INT64 r;
-    __udivmoddi4(a, b, (UINT64*)&r);
-    return (r ^ s) - s;                // negate if s == -1
-}
-
+/** @file

+  Compiler intrinsic for 64-bit mod, ported from LLVM code.

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+/**

+  University of Illinois/NCSA

+  Open Source License

+  

+  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.

+  All rights reserved.

+  

+  Developed by:

+  

+      LLVM Team

+  

+      University of Illinois at Urbana-Champaign

+  

+      http://llvm.org

+  

+  Permission is hereby granted, free of charge, to any person obtaining a copy of

+  this software and associated documentation files (the "Software"), to deal with

+  the Software without restriction, including without limitation the rights to

+  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies

+  of the Software, and to permit persons to whom the Software is furnished to do

+  so, subject to the following conditions:

+  

+      * Redistributions of source code must retain the above copyright notice,

+        this list of conditions and the following disclaimers.

+  

+      * Redistributions in binary form must reproduce the above copyright notice,

+        this list of conditions and the following disclaimers in the

+        documentation and/or other materials provided with the distribution.

+  

+      * Neither the names of the LLVM Team, University of Illinois at

+        Urbana-Champaign, nor the names of its contributors may be used to

+        endorse or promote products derived from this Software without specific

+        prior written permission.

+  

+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE

+  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE

+  SOFTWARE.

+**/

+

+

+#include "Llvm_int_lib.h"

+

+UINT64 __udivmoddi4(UINT64 a, UINT64 b, UINT64* rem);

+

+// Returns: a % b

+

+INT64

+__moddi3(INT64 a, INT64 b)

+{

+    const int bits_in_dword_m1 = (int)(sizeof(INT64) * CHAR_BIT) - 1;

+    INT64 s = b >> bits_in_dword_m1;  // s = b < 0 ? -1 : 0

+    b = (b ^ s) - s;                   // negate if s == -1

+    s = a >> bits_in_dword_m1;         // s = a < 0 ? -1 : 0

+    a = (a ^ s) - s;                   // negate if s == -1

+    INT64 r;

+    __udivmoddi4(a, b, (UINT64*)&r);

+    return (r ^ s) - s;                // negate if s == -1

+}

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/modsi3.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/modsi3.S
index eb698d60..07f8ef72 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/modsi3.S
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/modsi3.S
@@ -1,27 +1,27 @@
-#------------------------------------------------------------------------------ 
-#
-# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-#
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#------------------------------------------------------------------------------
-
-  .text
-  .align 2
-  GCC_ASM_EXPORT(__modsi3)
-
-ASM_PFX(__modsi3):
-  stmfd  sp!, {r4, r5, r7, lr}
-  add  r7, sp, #8
-  mov  r5, r0
-  mov  r4, r1
-  bl  ___divsi3
-  mul  r0, r4, r0
-  rsb  r0, r0, r5
-  ldmfd  sp!, {r4, r5, r7, pc}
+#------------------------------------------------------------------------------ 

+#

+# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+  .text

+  .align 2

+  GCC_ASM_EXPORT(__modsi3)

+

+ASM_PFX(__modsi3):

+  stmfd  sp!, {r4, r5, r7, lr}

+  add  r7, sp, #8

+  mov  r5, r0

+  mov  r4, r1

+  bl  ___divsi3

+  mul  r0, r4, r0

+  rsb  r0, r0, r5

+  ldmfd  sp!, {r4, r5, r7, pc}

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/modsi3.c b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/modsi3.c
index 68373d9c..9bdf077f 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/modsi3.c
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/modsi3.c
@@ -1,70 +1,70 @@
-/** @file
-  Compiler intrinsic for 32-bit mod, ported from LLVM code.
-
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-/**
-  University of Illinois/NCSA
-  Open Source License
-  
-  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.
-  All rights reserved.
-  
-  Developed by:
-  
-      LLVM Team
-  
-      University of Illinois at Urbana-Champaign
-  
-      http://llvm.org
-  
-  Permission is hereby granted, free of charge, to any person obtaining a copy of
-  this software and associated documentation files (the "Software"), to deal with
-  the Software without restriction, including without limitation the rights to
-  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-  of the Software, and to permit persons to whom the Software is furnished to do
-  so, subject to the following conditions:
-  
-      * Redistributions of source code must retain the above copyright notice,
-        this list of conditions and the following disclaimers.
-  
-      * Redistributions in binary form must reproduce the above copyright notice,
-        this list of conditions and the following disclaimers in the
-        documentation and/or other materials provided with the distribution.
-  
-      * Neither the names of the LLVM Team, University of Illinois at
-        Urbana-Champaign, nor the names of its contributors may be used to
-        endorse or promote products derived from this Software without specific
-        prior written permission.
-  
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
-  SOFTWARE.
-**/
-
-
-#include "Llvm_int_lib.h"
-
-// Returns: a % b
-
-INT32
-__modsi3(INT32 a, INT32 b)
-{
-    return a - (a / b) * b;
-}
-
-
+/** @file

+  Compiler intrinsic for 32-bit mod, ported from LLVM code.

+

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+/**

+  University of Illinois/NCSA

+  Open Source License

+  

+  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.

+  All rights reserved.

+  

+  Developed by:

+  

+      LLVM Team

+  

+      University of Illinois at Urbana-Champaign

+  

+      http://llvm.org

+  

+  Permission is hereby granted, free of charge, to any person obtaining a copy of

+  this software and associated documentation files (the "Software"), to deal with

+  the Software without restriction, including without limitation the rights to

+  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies

+  of the Software, and to permit persons to whom the Software is furnished to do

+  so, subject to the following conditions:

+  

+      * Redistributions of source code must retain the above copyright notice,

+        this list of conditions and the following disclaimers.

+  

+      * Redistributions in binary form must reproduce the above copyright notice,

+        this list of conditions and the following disclaimers in the

+        documentation and/or other materials provided with the distribution.

+  

+      * Neither the names of the LLVM Team, University of Illinois at

+        Urbana-Champaign, nor the names of its contributors may be used to

+        endorse or promote products derived from this Software without specific

+        prior written permission.

+  

+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE

+  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE

+  SOFTWARE.

+**/

+

+

+#include "Llvm_int_lib.h"

+

+// Returns: a % b

+

+INT32

+__modsi3(INT32 a, INT32 b)

+{

+    return a - (a / b) * b;

+}

+

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/muldi3.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/muldi3.S
index 36956c24..e8ac1fff 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/muldi3.S
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/muldi3.S
@@ -1,58 +1,58 @@
-#------------------------------------------------------------------------------ 
-#
-# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-#
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#------------------------------------------------------------------------------
-
-  .text
-  .align 2
-  GCC_ASM_EXPORT(__muldi3)
-
-ASM_PFX(__muldi3):
-  stmfd  sp!, {r4, r5, r6, r7, lr}
-  add  r7, sp, #12
-  stmfd  sp!, {r8, r10, r11}
-  ldr  r11, L4
-  mov  r4, r0, lsr #16
-  and  r8, r0, r11
-  and  ip, r2, r11
-  mul  lr, ip, r8
-  mul  ip, r4, ip
-  sub  sp, sp, #8
-  add  r10, ip, lr, lsr #16
-  and  ip, r10, r11
-  and  lr, lr, r11
-  mov  r6, r2, lsr #16
-  str  r4, [sp, #4]
-  add  r4, lr, ip, asl #16
-  mul  ip, r8, r6
-  mov  r5, r10, lsr #16
-  add  r10, ip, r4, lsr #16
-  and  ip, r10, r11
-  and  lr, r4, r11
-  add  r4, lr, ip, asl #16
-  mul  r0, r3, r0
-  add  ip, r5, r10, lsr #16
-  ldr  r5, [sp, #4]
-  mla  r0, r2, r1, r0
-  mla  r5, r6, r5, ip
-  mov  r10, r4
-  add  r11, r0, r5
-  mov  r1, r11
-  mov  r0, r4
-  sub  sp, r7, #24
-  ldmfd  sp!, {r8, r10, r11}
-  ldmfd  sp!, {r4, r5, r6, r7, pc}
-  .p2align 2
-L5:
-  .align 2
-L4:
-  .long  65535
+#------------------------------------------------------------------------------ 

+#

+# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+  .text

+  .align 2

+  GCC_ASM_EXPORT(__muldi3)

+

+ASM_PFX(__muldi3):

+  stmfd  sp!, {r4, r5, r6, r7, lr}

+  add  r7, sp, #12

+  stmfd  sp!, {r8, r10, r11}

+  ldr  r11, L4

+  mov  r4, r0, lsr #16

+  and  r8, r0, r11

+  and  ip, r2, r11

+  mul  lr, ip, r8

+  mul  ip, r4, ip

+  sub  sp, sp, #8

+  add  r10, ip, lr, lsr #16

+  and  ip, r10, r11

+  and  lr, lr, r11

+  mov  r6, r2, lsr #16

+  str  r4, [sp, #4]

+  add  r4, lr, ip, asl #16

+  mul  ip, r8, r6

+  mov  r5, r10, lsr #16

+  add  r10, ip, r4, lsr #16

+  and  ip, r10, r11

+  and  lr, r4, r11

+  add  r4, lr, ip, asl #16

+  mul  r0, r3, r0

+  add  ip, r5, r10, lsr #16

+  ldr  r5, [sp, #4]

+  mla  r0, r2, r1, r0

+  mla  r5, r6, r5, ip

+  mov  r10, r4

+  add  r11, r0, r5

+  mov  r1, r11

+  mov  r0, r4

+  sub  sp, r7, #24

+  ldmfd  sp!, {r8, r10, r11}

+  ldmfd  sp!, {r4, r5, r6, r7, pc}

+  .p2align 2

+L5:

+  .align 2

+L4:

+  .long  65535

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/muldi3.c b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/muldi3.c
index d48bd22b..67d0e4ee 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/muldi3.c
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/muldi3.c
@@ -1,98 +1,98 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-/**
-  University of Illinois/NCSA
-  Open Source License
-  
-  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.
-  All rights reserved.
-  
-  Developed by:
-  
-      LLVM Team
-  
-      University of Illinois at Urbana-Champaign
-  
-      http://llvm.org
-  
-  Permission is hereby granted, free of charge, to any person obtaining a copy of
-  this software and associated documentation files (the "Software"), to deal with
-  the Software without restriction, including without limitation the rights to
-  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-  of the Software, and to permit persons to whom the Software is furnished to do
-  so, subject to the following conditions:
-  
-      * Redistributions of source code must retain the above copyright notice,
-        this list of conditions and the following disclaimers.
-  
-      * Redistributions in binary form must reproduce the above copyright notice,
-        this list of conditions and the following disclaimers in the
-        documentation and/or other materials provided with the distribution.
-  
-      * Neither the names of the LLVM Team, University of Illinois at
-        Urbana-Champaign, nor the names of its contributors may be used to
-        endorse or promote products derived from this Software without specific
-        prior written permission.
-  
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
-  SOFTWARE.
-**/
-
-#include <Base.h>
-#include "Llvm_int_lib.h"
-
-
-// Returns: a * b
-
-static
-INT64
-__muldsi3(UINT32 a, UINT32 b)
-{
-    dwords r;
-    const int bits_in_word_2 = (int)(sizeof(INT32) * CHAR_BIT) / 2;
-    const UINT32 lower_mask = (UINT32)~0 >> bits_in_word_2;
-    r.low = (a & lower_mask) * (b & lower_mask);
-    UINT32 t = r.low >> bits_in_word_2;
-    r.low &= lower_mask;
-    t += (a >> bits_in_word_2) * (b & lower_mask);
-    r.low += (t & lower_mask) << bits_in_word_2;
-    r.high = t >> bits_in_word_2;
-    t = r.low >> bits_in_word_2;
-    r.low &= lower_mask;
-    t += (b >> bits_in_word_2) * (a & lower_mask);
-    r.low += (t & lower_mask) << bits_in_word_2;
-    r.high += t >> bits_in_word_2;
-    r.high += (a >> bits_in_word_2) * (b >> bits_in_word_2);
-    return r.all;
-}
-
-// Returns: a * b
-
-INT64
-__muldi3(INT64 a, INT64 b)
-{
-    dwords x;
-    x.all = a;
-    dwords y;
-    y.all = b;
-    dwords r;
-    r.all = __muldsi3(x.low, y.low);
-    r.high += x.high * y.low + x.low * y.high;
-    return r.all;
-}
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+/**

+  University of Illinois/NCSA

+  Open Source License

+  

+  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.

+  All rights reserved.

+  

+  Developed by:

+  

+      LLVM Team

+  

+      University of Illinois at Urbana-Champaign

+  

+      http://llvm.org

+  

+  Permission is hereby granted, free of charge, to any person obtaining a copy of

+  this software and associated documentation files (the "Software"), to deal with

+  the Software without restriction, including without limitation the rights to

+  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies

+  of the Software, and to permit persons to whom the Software is furnished to do

+  so, subject to the following conditions:

+  

+      * Redistributions of source code must retain the above copyright notice,

+        this list of conditions and the following disclaimers.

+  

+      * Redistributions in binary form must reproduce the above copyright notice,

+        this list of conditions and the following disclaimers in the

+        documentation and/or other materials provided with the distribution.

+  

+      * Neither the names of the LLVM Team, University of Illinois at

+        Urbana-Champaign, nor the names of its contributors may be used to

+        endorse or promote products derived from this Software without specific

+        prior written permission.

+  

+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE

+  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE

+  SOFTWARE.

+**/

+

+#include <Base.h>

+#include "Llvm_int_lib.h"

+

+

+// Returns: a * b

+

+static

+INT64

+__muldsi3(UINT32 a, UINT32 b)

+{

+    dwords r;

+    const int bits_in_word_2 = (int)(sizeof(INT32) * CHAR_BIT) / 2;

+    const UINT32 lower_mask = (UINT32)~0 >> bits_in_word_2;

+    r.low = (a & lower_mask) * (b & lower_mask);

+    UINT32 t = r.low >> bits_in_word_2;

+    r.low &= lower_mask;

+    t += (a >> bits_in_word_2) * (b & lower_mask);

+    r.low += (t & lower_mask) << bits_in_word_2;

+    r.high = t >> bits_in_word_2;

+    t = r.low >> bits_in_word_2;

+    r.low &= lower_mask;

+    t += (b >> bits_in_word_2) * (a & lower_mask);

+    r.low += (t & lower_mask) << bits_in_word_2;

+    r.high += t >> bits_in_word_2;

+    r.high += (a >> bits_in_word_2) * (b >> bits_in_word_2);

+    return r.all;

+}

+

+// Returns: a * b

+

+INT64

+__muldi3(INT64 a, INT64 b)

+{

+    dwords x;

+    x.all = a;

+    dwords y;

+    y.all = b;

+    dwords r;

+    r.all = __muldsi3(x.low, y.low);

+    r.high += x.high * y.low + x.low * y.high;

+    return r.all;

+}

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/mullu.asm b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/mullu.asm
index 5d369e9a..48976364 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/mullu.asm
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/mullu.asm
@@ -1,49 +1,49 @@
-//------------------------------------------------------------------------------ 
-//
-// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-//
-// This program and the accompanying materials
-// are licensed and made available under the terms and conditions of the BSD License
-// which accompanies this distribution.  The full text of the license may be found at
-// http://opensource.org/licenses/bsd-license.php
-//
-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-//
-//------------------------------------------------------------------------------
-
-
-  EXPORT  __ARM_ll_mullu
-  EXPORT  __aeabi_lmul
-       
-  AREA  Math, CODE, READONLY
-
-;
-;INT64
-;EFIAPI
-;__aeabi_lmul (
-;  IN INT64   Multiplicand
-;  IN INT32   Multiplier
-;  );
-;
-__ARM_ll_mullu
-  mov     r3, #0
-// Make upper part of INT64 Multiplier 0 and use __aeabi_lmul
-
-;
-;INT64
-;EFIAPI
-;__aeabi_lmul (
-;  IN INT64   Multiplicand
-;  IN INT64   Multiplier
-;  );
-;
-__aeabi_lmul
-  stmdb   sp!, {lr}
-  mov     lr, r0
-  umull   r0, ip, r2, lr
-  mla     r1, r2, r1, ip
-  mla     r1, r3, lr, r1
-  ldmia   sp!, {pc}
-  
-  END
+//------------------------------------------------------------------------------ 

+//

+// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+//

+// This program and the accompanying materials

+// are licensed and made available under the terms and conditions of the BSD License

+// which accompanies this distribution.  The full text of the license may be found at

+// http://opensource.org/licenses/bsd-license.php

+//

+// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+//

+//------------------------------------------------------------------------------

+

+

+  EXPORT  __ARM_ll_mullu

+  EXPORT  __aeabi_lmul

+       

+  AREA  Math, CODE, READONLY

+

+;

+;INT64

+;EFIAPI

+;__aeabi_lmul (

+;  IN INT64   Multiplicand

+;  IN INT32   Multiplier

+;  );

+;

+__ARM_ll_mullu

+  mov     r3, #0

+// Make upper part of INT64 Multiplier 0 and use __aeabi_lmul

+

+;

+;INT64

+;EFIAPI

+;__aeabi_lmul (

+;  IN INT64   Multiplicand

+;  IN INT64   Multiplier

+;  );

+;

+__aeabi_lmul

+  stmdb   sp!, {lr}

+  mov     lr, r0

+  umull   r0, ip, r2, lr

+  mla     r1, r2, r1, ip

+  mla     r1, r3, lr, r1

+  ldmia   sp!, {pc}

+  

+  END

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/switch.asm b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/switch.asm
index 8d34c5de..2c8a0318 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/switch.asm
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/switch.asm
@@ -1,29 +1,29 @@
-///------------------------------------------------------------------------------ 
-//
-// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-//
-// This program and the accompanying materials
-// are licensed and made available under the terms and conditions of the BSD License
-// which accompanies this distribution.  The full text of the license may be found at
-// http://opensource.org/licenses/bsd-license.php
-//
-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-//
-//------------------------------------------------------------------------------
-
-
-
-    EXPORT  __ARM_switch8
-
-    AREA  ArmSwitch, CODE, READONLY
-  
-__ARM_switch8
-  LDRB    r12,[lr,#-1]
-  CMP      r3,r12
-  LDRBCC  r3,[lr,r3]
-  LDRBCS  r3,[lr,r12]
-  ADD      r12,lr,r3,LSL #1
-  BX      r12
-  
-    END
+///------------------------------------------------------------------------------ 

+//

+// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+//

+// This program and the accompanying materials

+// are licensed and made available under the terms and conditions of the BSD License

+// which accompanies this distribution.  The full text of the license may be found at

+// http://opensource.org/licenses/bsd-license.php

+//

+// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+//

+//------------------------------------------------------------------------------

+

+

+

+    EXPORT  __ARM_switch8

+

+    AREA  ArmSwitch, CODE, READONLY

+  

+__ARM_switch8

+  LDRB    r12,[lr,#-1]

+  CMP      r3,r12

+  LDRBCC  r3,[lr,r3]

+  LDRBCS  r3,[lr,r12]

+  ADD      r12,lr,r3,LSL #1

+  BX      r12

+  

+    END

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/switch16.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/switch16.S
index 97ebf793..ce6904e0 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/switch16.S
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/switch16.S
@@ -1,31 +1,31 @@
-#/** @file
-#  Compiler intrinsic for ARM compiler
-#
-#  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.;
-#
-#**/
-#        
-
-.text
-.p2align 2
-
-GCC_ASM_EXPORT(__switch16)
-
-ASM_PFX(__switch16):
-    ldrh      ip, [lr, #-1]
-    cmp       r0, ip
-    add       r0, lr, r0, lsl #1
-    ldrccsh   r0, [r0, #1]
-    add       ip, lr, ip, lsl #1
-    ldrcssh   r0, [ip, #1]
-    add       ip, lr, r0, lsl #1
-    bx        ip
-
-
+#/** @file

+#  Compiler intrinsic for ARM compiler

+#

+#  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.;

+#

+#**/

+#        

+

+.text

+.p2align 2

+

+GCC_ASM_EXPORT(__switch16)

+

+ASM_PFX(__switch16):

+    ldrh      ip, [lr, #-1]

+    cmp       r0, ip

+    add       r0, lr, r0, lsl #1

+    ldrccsh   r0, [r0, #1]

+    add       ip, lr, ip, lsl #1

+    ldrcssh   r0, [ip, #1]

+    add       ip, lr, r0, lsl #1

+    bx        ip

+

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/switch32.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/switch32.S
index e0fd100a..63aed6e6 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/switch32.S
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/switch32.S
@@ -1,30 +1,30 @@
-#/** @file
-#  Compiler intrinsic for ARM compiler
-#
-#  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.;
-#
-#**/
-#        
-
-.text
-.p2align 2
-
-GCC_ASM_EXPORT(__switch32)
-
-ASM_PFX(__switch32):    
-    ldr     ip, [lr, #-1]
-    cmp     r0, ip
-    add     r0, lr, r0, lsl #2
-    ldrcc   r0, [r0, #3]
-    add     ip, lr, ip, lsl #2
-    ldrcs   r0, [ip, #3]
-    add     ip, lr, r0
-    bx      ip
-
+#/** @file

+#  Compiler intrinsic for ARM compiler

+#

+#  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.;

+#

+#**/

+#        

+

+.text

+.p2align 2

+

+GCC_ASM_EXPORT(__switch32)

+

+ASM_PFX(__switch32):    

+    ldr     ip, [lr, #-1]

+    cmp     r0, ip

+    add     r0, lr, r0, lsl #2

+    ldrcc   r0, [r0, #3]

+    add     ip, lr, ip, lsl #2

+    ldrcs   r0, [ip, #3]

+    add     ip, lr, r0

+    bx      ip

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/switch8.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/switch8.S
index ea3340c9..688e106a 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/switch8.S
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/switch8.S
@@ -1,28 +1,28 @@
-#/** @file
-#  Compiler intrinsic for ARM compiler
-#
-#  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http)://opensource.org/licenses/bsd-license.php
-#
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.;
-#
-#**/
-#        
-
-.text
-.p2align 2
-
-GCC_ASM_EXPORT(__switch8)
-
-ASM_PFX(__switch8):
-    ldrb      ip, [lr, #-1]
-    cmp       r0, ip
-    ldrccsb   r0, [lr, r0]
-    ldrcssb   r0, [lr, ip]
-    add       ip, lr, r0, lsl #1
-    bx        ip
-
+#/** @file

+#  Compiler intrinsic for ARM compiler

+#

+#  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http)://opensource.org/licenses/bsd-license.php

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.;

+#

+#**/

+#        

+

+.text

+.p2align 2

+

+GCC_ASM_EXPORT(__switch8)

+

+ASM_PFX(__switch8):

+    ldrb      ip, [lr, #-1]

+    cmp       r0, ip

+    ldrccsb   r0, [lr, r0]

+    ldrcssb   r0, [lr, ip]

+    add       ip, lr, r0, lsl #1

+    bx        ip

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/switchu8.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/switchu8.S
index 83636e1f..254b0543 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/switchu8.S
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/switchu8.S
@@ -1,29 +1,29 @@
-#/** @file
-#  Compiler intrinsic for ARM compiler
-#
-#  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http)://opensource.org/licenses/bsd-license.php
-#
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.;
-#
-#**/
-#        
-
-.text
-.p2align 2
-
-GCC_ASM_EXPORT(__switchu8)
-
-
-ASM_PFX(__switchu8):
-    ldrb      ip,[lr,#-1]
-    cmp       r0,ip
-    ldrccb    r0,[lr,r0]
-    ldrcsb    r0,[lr,ip]
-    add       ip,lr,r0,LSL #1
-    bx        ip
-
+#/** @file

+#  Compiler intrinsic for ARM compiler

+#

+#  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http)://opensource.org/licenses/bsd-license.php

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.;

+#

+#**/

+#        

+

+.text

+.p2align 2

+

+GCC_ASM_EXPORT(__switchu8)

+

+

+ASM_PFX(__switchu8):

+    ldrb      ip,[lr,#-1]

+    cmp       r0,ip

+    ldrccb    r0,[lr,r0]

+    ldrcsb    r0,[lr,ip]

+    add       ip,lr,r0,LSL #1

+    bx        ip

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ucmpdi2.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ucmpdi2.S
index e85be6ca..f448ed58 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ucmpdi2.S
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ucmpdi2.S
@@ -1,38 +1,38 @@
-#------------------------------------------------------------------------------ 
-#
-# Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-#
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#------------------------------------------------------------------------------
-
-  .text
-  .align 2
-  GCC_ASM_EXPORT(__ucmpdi2)
-  
-ASM_PFX(__ucmpdi2):
-  stmfd  sp!, {r4, r5, r8, lr}
-  cmp  r1, r3
-  mov  r8, r0
-  mov  r4, r2
-  mov  r5, r3
-  bcc  L2
-  bhi  L4
-  cmp  r0, r2
-  bcc  L2
-  movls  r0, #1
-  bls  L8
-  b  L4
-L2:
-  mov  r0, #0
-  b  L8
-L4:
-  mov  r0, #2
-L8:
-  ldmfd  sp!, {r4, r5, r8, pc}
+#------------------------------------------------------------------------------ 

+#

+# Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+  .text

+  .align 2

+  GCC_ASM_EXPORT(__ucmpdi2)

+  

+ASM_PFX(__ucmpdi2):

+  stmfd  sp!, {r4, r5, r8, lr}

+  cmp  r1, r3

+  mov  r8, r0

+  mov  r4, r2

+  mov  r5, r3

+  bcc  L2

+  bhi  L4

+  cmp  r0, r2

+  bcc  L2

+  movls  r0, #1

+  bls  L8

+  b  L4

+L2:

+  mov  r0, #0

+  b  L8

+L4:

+  mov  r0, #2

+L8:

+  ldmfd  sp!, {r4, r5, r8, pc}

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ucmpdi2.c b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ucmpdi2.c
index 25a821ef..70d5a531 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ucmpdi2.c
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/ucmpdi2.c
@@ -1,82 +1,82 @@
-/** @file
-  Compiler intrinsic for 64-bit compare, ported from LLVM code.
-
-  Copyright (c) 2008-2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-/**
-  University of Illinois/NCSA
-  Open Source License
-  
-  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.
-  All rights reserved.
-  
-  Developed by:
-  
-      LLVM Team
-  
-      University of Illinois at Urbana-Champaign
-  
-      http://llvm.org
-  
-  Permission is hereby granted, free of charge, to any person obtaining a copy of
-  this software and associated documentation files (the "Software"), to deal with
-  the Software without restriction, including without limitation the rights to
-  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-  of the Software, and to permit persons to whom the Software is furnished to do
-  so, subject to the following conditions:
-  
-      * Redistributions of source code must retain the above copyright notice,
-        this list of conditions and the following disclaimers.
-  
-      * Redistributions in binary form must reproduce the above copyright notice,
-        this list of conditions and the following disclaimers in the
-        documentation and/or other materials provided with the distribution.
-  
-      * Neither the names of the LLVM Team, University of Illinois at
-        Urbana-Champaign, nor the names of its contributors may be used to
-        endorse or promote products derived from this Software without specific
-        prior written permission.
-  
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
-  SOFTWARE.
-**/
-
-
-#include "Llvm_int_lib.h"
-
-
-// Returns:  if (a <  b) returns 0
-//           if (a == b) returns 1
-//           if (a >  b) returns 2
-
-UINT32
-__ucmpdi2(UINT64 a, UINT64 b)
-{
-    udwords x;
-    x.all = a;
-    udwords y;
-    y.all = b;
-    if (x.high < y.high)
-        return 0;
-    if (x.high > y.high)
-        return 2;
-    if (x.low < y.low)
-        return 0;
-    if (x.low > y.low)
-        return 2;
-    return 1;
-}
+/** @file

+  Compiler intrinsic for 64-bit compare, ported from LLVM code.

+

+  Copyright (c) 2008-2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+/**

+  University of Illinois/NCSA

+  Open Source License

+  

+  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.

+  All rights reserved.

+  

+  Developed by:

+  

+      LLVM Team

+  

+      University of Illinois at Urbana-Champaign

+  

+      http://llvm.org

+  

+  Permission is hereby granted, free of charge, to any person obtaining a copy of

+  this software and associated documentation files (the "Software"), to deal with

+  the Software without restriction, including without limitation the rights to

+  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies

+  of the Software, and to permit persons to whom the Software is furnished to do

+  so, subject to the following conditions:

+  

+      * Redistributions of source code must retain the above copyright notice,

+        this list of conditions and the following disclaimers.

+  

+      * Redistributions in binary form must reproduce the above copyright notice,

+        this list of conditions and the following disclaimers in the

+        documentation and/or other materials provided with the distribution.

+  

+      * Neither the names of the LLVM Team, University of Illinois at

+        Urbana-Champaign, nor the names of its contributors may be used to

+        endorse or promote products derived from this Software without specific

+        prior written permission.

+  

+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE

+  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE

+  SOFTWARE.

+**/

+

+

+#include "Llvm_int_lib.h"

+

+

+// Returns:  if (a <  b) returns 0

+//           if (a == b) returns 1

+//           if (a >  b) returns 2

+

+UINT32

+__ucmpdi2(UINT64 a, UINT64 b)

+{

+    udwords x;

+    x.all = a;

+    udwords y;

+    y.all = b;

+    if (x.high < y.high)

+        return 0;

+    if (x.high > y.high)

+        return 2;

+    if (x.low < y.low)

+        return 0;

+    if (x.low > y.low)

+        return 2;

+    return 1;

+}

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/udivdi3.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/udivdi3.S
index a8b97027..f274901f 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/udivdi3.S
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/udivdi3.S
@@ -1,27 +1,27 @@
-#------------------------------------------------------------------------------ 
-#
-# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-#
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#------------------------------------------------------------------------------
-
-  .text
-  .align 2
-  GCC_ASM_EXPORT(__udivdi3)
-
-ASM_PFX(__udivdi3):
-  stmfd  sp!, {r7, lr}
-  add  r7, sp, #0
-  sub  sp, sp, #8
-  mov  ip, #0
-  str  ip, [sp, #0]
-  bl  ASM_PFX(__udivmoddi4)
-  sub  sp, r7, #0
-  ldmfd  sp!, {r7, pc}
+#------------------------------------------------------------------------------ 

+#

+# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+  .text

+  .align 2

+  GCC_ASM_EXPORT(__udivdi3)

+

+ASM_PFX(__udivdi3):

+  stmfd  sp!, {r7, lr}

+  add  r7, sp, #0

+  sub  sp, sp, #8

+  mov  ip, #0

+  str  ip, [sp, #0]

+  bl  ASM_PFX(__udivmoddi4)

+  sub  sp, r7, #0

+  ldmfd  sp!, {r7, pc}

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/udivdi3.c b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/udivdi3.c
index b24606f0..a8d9b096 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/udivdi3.c
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/udivdi3.c
@@ -1,71 +1,71 @@
-/** @file
-  Compiler intrinsic for 64-bit unisigned div, ported from LLVM code.
-
-  Copyright (c) 2008-2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-/**
-  University of Illinois/NCSA
-  Open Source License
-  
-  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.
-  All rights reserved.
-  
-  Developed by:
-  
-      LLVM Team
-  
-      University of Illinois at Urbana-Champaign
-  
-      http://llvm.org
-  
-  Permission is hereby granted, free of charge, to any person obtaining a copy of
-  this software and associated documentation files (the "Software"), to deal with
-  the Software without restriction, including without limitation the rights to
-  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-  of the Software, and to permit persons to whom the Software is furnished to do
-  so, subject to the following conditions:
-  
-      * Redistributions of source code must retain the above copyright notice,
-        this list of conditions and the following disclaimers.
-  
-      * Redistributions in binary form must reproduce the above copyright notice,
-        this list of conditions and the following disclaimers in the
-        documentation and/or other materials provided with the distribution.
-  
-      * Neither the names of the LLVM Team, University of Illinois at
-        Urbana-Champaign, nor the names of its contributors may be used to
-        endorse or promote products derived from this Software without specific
-        prior written permission.
-  
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
-  SOFTWARE.
-**/
-
-
-#include "Llvm_int_lib.h"
-
-UINT64 __udivmoddi4 (UINT64 a, UINT64 b, UINT64 *rem);
-
-// Returns: a / b
-
-UINT64
-__udivdi3(UINT64 a, UINT64 b)
-{
-    return __udivmoddi4(a, b, 0);
-}
-
-
+/** @file

+  Compiler intrinsic for 64-bit unisigned div, ported from LLVM code.

+

+  Copyright (c) 2008-2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+/**

+  University of Illinois/NCSA

+  Open Source License

+  

+  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.

+  All rights reserved.

+  

+  Developed by:

+  

+      LLVM Team

+  

+      University of Illinois at Urbana-Champaign

+  

+      http://llvm.org

+  

+  Permission is hereby granted, free of charge, to any person obtaining a copy of

+  this software and associated documentation files (the "Software"), to deal with

+  the Software without restriction, including without limitation the rights to

+  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies

+  of the Software, and to permit persons to whom the Software is furnished to do

+  so, subject to the following conditions:

+  

+      * Redistributions of source code must retain the above copyright notice,

+        this list of conditions and the following disclaimers.

+  

+      * Redistributions in binary form must reproduce the above copyright notice,

+        this list of conditions and the following disclaimers in the

+        documentation and/or other materials provided with the distribution.

+  

+      * Neither the names of the LLVM Team, University of Illinois at

+        Urbana-Champaign, nor the names of its contributors may be used to

+        endorse or promote products derived from this Software without specific

+        prior written permission.

+  

+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE

+  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE

+  SOFTWARE.

+**/

+

+

+#include "Llvm_int_lib.h"

+

+UINT64 __udivmoddi4 (UINT64 a, UINT64 b, UINT64 *rem);

+

+// Returns: a / b

+

+UINT64

+__udivdi3(UINT64 a, UINT64 b)

+{

+    return __udivmoddi4(a, b, 0);

+}

+

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/udivmoddi4.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/udivmoddi4.S
index cadc1d29..1c0f2eae 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/udivmoddi4.S
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/udivmoddi4.S
@@ -1,242 +1,242 @@
-#------------------------------------------------------------------------------ 
-#
-# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-#
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#------------------------------------------------------------------------------
-
-  .text
-  .align 2
-  GCC_ASM_EXPORT(__udivmoddi4)
-  
-ASM_PFX(__udivmoddi4):
-  stmfd  sp!, {r4, r5, r6, r7, lr}
-  add  r7, sp, #12
-  stmfd  sp!, {r10, r11}
-  sub  sp, sp, #20
-  stmia  sp, {r2-r3}
-  ldr  r6, [sp, #48]
-  orrs  r2, r2, r3
-  mov  r10, r0
-  mov  r11, r1
-  beq  L2
-  subs  ip, r1, #0
-  bne  L4
-  cmp  r3, #0
-  bne  L6
-  cmp  r6, #0
-  beq  L8
-  mov  r1, r2
-  bl  ASM_PFX(__umodsi3)
-  mov  r1, #0
-  stmia  r6, {r0-r1}
-L8:
-  ldr  r1, [sp, #0]
-  mov  r0, r10
-  b  L45
-L6:
-  cmp  r6, #0
-  movne  r1, #0
-  stmneia  r6, {r0-r1}
-  b  L2
-L4:
-  ldr  r1, [sp, #0]
-  cmp  r1, #0
-  bne  L12
-  ldr  r2, [sp, #4]
-  cmp  r2, #0
-  bne  L14
-  cmp  r6, #0
-  beq  L16
-  mov  r1, r2
-  mov  r0, r11
-  bl  ASM_PFX(__umodsi3)
-  mov  r1, #0
-  stmia  r6, {r0-r1}
-L16:
-  ldr  r1, [sp, #4]
-  mov  r0, r11
-L45:
-  bl  ASM_PFX(__udivsi3)
-L46:
-  mov  r10, r0
-  mov  r11, #0
-  b  L10
-L14:
-  subs  r1, r0, #0
-  bne  L18
-  cmp  r6, #0
-  beq  L16
-  ldr  r1, [sp, #4]
-  mov  r0, r11
-  bl  ASM_PFX(__umodsi3)
-  mov  r4, r10
-  mov  r5, r0
-  stmia  r6, {r4-r5}
-  b  L16
-L18:
-  sub  r3, r2, #1
-  tst  r2, r3
-  bne  L22
-  cmp  r6, #0
-  movne  r4, r0
-  andne  r5, ip, r3
-  stmneia  r6, {r4-r5}
-L24:
-  rsb  r3, r2, #0
-  and  r3, r2, r3
-  clz  r3, r3
-  rsb  r3, r3, #31
-  mov  r0, ip, lsr r3
-  b  L46
-L22:
-  clz  r2, r2
-  clz  r3, ip
-  rsb  r3, r3, r2
-  cmp  r3, #30
-  bhi  L48
-  rsb  r2, r3, #31
-  add  lr, r3, #1
-  mov  r3, r1, asl r2
-  str  r3, [sp, #12]
-  mov  r3, r1, lsr lr
-  ldr  r0, [sp, #0]
-  mov  r5, ip, lsr lr
-  orr  r4, r3, ip, asl r2
-  str  r0, [sp, #8]
-  b  L29
-L12:
-  ldr  r3, [sp, #4]
-  cmp  r3, #0
-  bne  L30
-  sub  r3, r1, #1
-  tst  r1, r3
-  bne  L32
-  cmp  r6, #0
-  andne  r3, r3, r0
-  movne  r2, r3
-  movne  r3, #0
-  stmneia  r6, {r2-r3}
-L34:
-  cmp  r1, #1
-  beq  L10
-  rsb  r3, r1, #0
-  and  r3, r1, r3
-  clz  r3, r3
-  rsb  r0, r3, #31
-  mov  r1, ip, lsr r0
-  rsb  r3, r0, #32
-  mov  r0, r10, lsr r0
-  orr  ip, r0, ip, asl r3
-  str  r1, [sp, #12]
-  str  ip, [sp, #8]
-  ldrd  r10, [sp, #8]
-  b  L10
-L32:
-  clz  r2, r1
-  clz  r3, ip
-  rsb  r3, r3, r2
-  rsb  r4, r3, #31
-  mov  r2, r0, asl r4
-  mvn  r1, r3
-  and  r2, r2, r1, asr #31
-  add  lr, r3, #33
-  str  r2, [sp, #8]
-  add  r2, r3, #1
-  mov  r3, r3, asr #31
-  and  r0, r3, r0, asl r1
-  mov  r3, r10, lsr r2
-  orr  r3, r3, ip, asl r4
-  and  r3, r3, r1, asr #31
-  orr  r0, r0, r3
-  mov  r3, ip, lsr lr
-  str  r0, [sp, #12]
-  mov  r0, r10, lsr lr
-  and  r5, r3, r2, asr #31
-  rsb  r3, lr, #31
-  mov  r3, r3, asr #31
-  orr  r0, r0, ip, asl r1
-  and  r3, r3, ip, lsr r2
-  and  r0, r0, r2, asr #31
-  orr  r4, r3, r0
-  b  L29
-L30:
-  clz  r2, r3
-  clz  r3, ip
-  rsb  r3, r3, r2
-  cmp  r3, #31
-  bls  L37
-L48:
-  cmp  r6, #0
-  stmneia  r6, {r10-r11}
-  b  L2
-L37:
-  rsb  r1, r3, #31
-  mov  r0, r0, asl r1
-  add  lr, r3, #1
-  mov  r2, #0
-  str  r0, [sp, #12]
-  mov  r0, r10, lsr lr
-  str  r2, [sp, #8]
-  sub  r2, r3, #31
-  and  r0, r0, r2, asr #31
-  mov  r3, ip, lsr lr
-  orr  r4, r0, ip, asl r1
-  and  r5, r3, r2, asr #31
-L29:
-  mov  ip, #0
-  mov  r10, ip
-  b  L40
-L41:
-  ldr  r1, [sp, #12]
-  ldr  r2, [sp, #8]
-  mov  r3, r4, lsr #31
-  orr  r5, r3, r5, asl #1
-  mov  r3, r1, lsr #31
-  orr  r4, r3, r4, asl #1
-  mov  r3, r2, lsr #31
-  orr  r0, r3, r1, asl #1
-  orr  r1, ip, r2, asl #1
-  ldmia  sp, {r2-r3}
-  str  r0, [sp, #12]
-  subs  r2, r2, r4
-  sbc  r3, r3, r5
-  str  r1, [sp, #8]
-  subs  r0, r2, #1
-  sbc  r1, r3, #0
-  mov  r2, r1, asr #31
-  ldmia  sp, {r0-r1}
-  mov  r3, r2
-  and  ip, r2, #1
-  and  r3, r3, r1
-  and  r2, r2, r0
-  subs  r4, r4, r2
-  sbc  r5, r5, r3
-  add  r10, r10, #1
-L40:
-  cmp  r10, lr
-  bne  L41
-  ldrd  r0, [sp, #8]
-  adds  r0, r0, r0
-  adc  r1, r1, r1
-  cmp  r6, #0
-  orr  r10, r0, ip
-  mov  r11, r1
-  stmneia  r6, {r4-r5}
-  b  L10
-L2:
-  mov  r10, #0
-  mov  r11, #0
-L10:
-  mov  r0, r10
-  mov  r1, r11
-  sub  sp, r7, #20
-  ldmfd  sp!, {r10, r11}
-  ldmfd  sp!, {r4, r5, r6, r7, pc}
+#------------------------------------------------------------------------------ 

+#

+# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+  .text

+  .align 2

+  GCC_ASM_EXPORT(__udivmoddi4)

+  

+ASM_PFX(__udivmoddi4):

+  stmfd  sp!, {r4, r5, r6, r7, lr}

+  add  r7, sp, #12

+  stmfd  sp!, {r10, r11}

+  sub  sp, sp, #20

+  stmia  sp, {r2-r3}

+  ldr  r6, [sp, #48]

+  orrs  r2, r2, r3

+  mov  r10, r0

+  mov  r11, r1

+  beq  L2

+  subs  ip, r1, #0

+  bne  L4

+  cmp  r3, #0

+  bne  L6

+  cmp  r6, #0

+  beq  L8

+  mov  r1, r2

+  bl  ASM_PFX(__umodsi3)

+  mov  r1, #0

+  stmia  r6, {r0-r1}

+L8:

+  ldr  r1, [sp, #0]

+  mov  r0, r10

+  b  L45

+L6:

+  cmp  r6, #0

+  movne  r1, #0

+  stmneia  r6, {r0-r1}

+  b  L2

+L4:

+  ldr  r1, [sp, #0]

+  cmp  r1, #0

+  bne  L12

+  ldr  r2, [sp, #4]

+  cmp  r2, #0

+  bne  L14

+  cmp  r6, #0

+  beq  L16

+  mov  r1, r2

+  mov  r0, r11

+  bl  ASM_PFX(__umodsi3)

+  mov  r1, #0

+  stmia  r6, {r0-r1}

+L16:

+  ldr  r1, [sp, #4]

+  mov  r0, r11

+L45:

+  bl  ASM_PFX(__udivsi3)

+L46:

+  mov  r10, r0

+  mov  r11, #0

+  b  L10

+L14:

+  subs  r1, r0, #0

+  bne  L18

+  cmp  r6, #0

+  beq  L16

+  ldr  r1, [sp, #4]

+  mov  r0, r11

+  bl  ASM_PFX(__umodsi3)

+  mov  r4, r10

+  mov  r5, r0

+  stmia  r6, {r4-r5}

+  b  L16

+L18:

+  sub  r3, r2, #1

+  tst  r2, r3

+  bne  L22

+  cmp  r6, #0

+  movne  r4, r0

+  andne  r5, ip, r3

+  stmneia  r6, {r4-r5}

+L24:

+  rsb  r3, r2, #0

+  and  r3, r2, r3

+  clz  r3, r3

+  rsb  r3, r3, #31

+  mov  r0, ip, lsr r3

+  b  L46

+L22:

+  clz  r2, r2

+  clz  r3, ip

+  rsb  r3, r3, r2

+  cmp  r3, #30

+  bhi  L48

+  rsb  r2, r3, #31

+  add  lr, r3, #1

+  mov  r3, r1, asl r2

+  str  r3, [sp, #12]

+  mov  r3, r1, lsr lr

+  ldr  r0, [sp, #0]

+  mov  r5, ip, lsr lr

+  orr  r4, r3, ip, asl r2

+  str  r0, [sp, #8]

+  b  L29

+L12:

+  ldr  r3, [sp, #4]

+  cmp  r3, #0

+  bne  L30

+  sub  r3, r1, #1

+  tst  r1, r3

+  bne  L32

+  cmp  r6, #0

+  andne  r3, r3, r0

+  movne  r2, r3

+  movne  r3, #0

+  stmneia  r6, {r2-r3}

+L34:

+  cmp  r1, #1

+  beq  L10

+  rsb  r3, r1, #0

+  and  r3, r1, r3

+  clz  r3, r3

+  rsb  r0, r3, #31

+  mov  r1, ip, lsr r0

+  rsb  r3, r0, #32

+  mov  r0, r10, lsr r0

+  orr  ip, r0, ip, asl r3

+  str  r1, [sp, #12]

+  str  ip, [sp, #8]

+  ldrd  r10, [sp, #8]

+  b  L10

+L32:

+  clz  r2, r1

+  clz  r3, ip

+  rsb  r3, r3, r2

+  rsb  r4, r3, #31

+  mov  r2, r0, asl r4

+  mvn  r1, r3

+  and  r2, r2, r1, asr #31

+  add  lr, r3, #33

+  str  r2, [sp, #8]

+  add  r2, r3, #1

+  mov  r3, r3, asr #31

+  and  r0, r3, r0, asl r1

+  mov  r3, r10, lsr r2

+  orr  r3, r3, ip, asl r4

+  and  r3, r3, r1, asr #31

+  orr  r0, r0, r3

+  mov  r3, ip, lsr lr

+  str  r0, [sp, #12]

+  mov  r0, r10, lsr lr

+  and  r5, r3, r2, asr #31

+  rsb  r3, lr, #31

+  mov  r3, r3, asr #31

+  orr  r0, r0, ip, asl r1

+  and  r3, r3, ip, lsr r2

+  and  r0, r0, r2, asr #31

+  orr  r4, r3, r0

+  b  L29

+L30:

+  clz  r2, r3

+  clz  r3, ip

+  rsb  r3, r3, r2

+  cmp  r3, #31

+  bls  L37

+L48:

+  cmp  r6, #0

+  stmneia  r6, {r10-r11}

+  b  L2

+L37:

+  rsb  r1, r3, #31

+  mov  r0, r0, asl r1

+  add  lr, r3, #1

+  mov  r2, #0

+  str  r0, [sp, #12]

+  mov  r0, r10, lsr lr

+  str  r2, [sp, #8]

+  sub  r2, r3, #31

+  and  r0, r0, r2, asr #31

+  mov  r3, ip, lsr lr

+  orr  r4, r0, ip, asl r1

+  and  r5, r3, r2, asr #31

+L29:

+  mov  ip, #0

+  mov  r10, ip

+  b  L40

+L41:

+  ldr  r1, [sp, #12]

+  ldr  r2, [sp, #8]

+  mov  r3, r4, lsr #31

+  orr  r5, r3, r5, asl #1

+  mov  r3, r1, lsr #31

+  orr  r4, r3, r4, asl #1

+  mov  r3, r2, lsr #31

+  orr  r0, r3, r1, asl #1

+  orr  r1, ip, r2, asl #1

+  ldmia  sp, {r2-r3}

+  str  r0, [sp, #12]

+  subs  r2, r2, r4

+  sbc  r3, r3, r5

+  str  r1, [sp, #8]

+  subs  r0, r2, #1

+  sbc  r1, r3, #0

+  mov  r2, r1, asr #31

+  ldmia  sp, {r0-r1}

+  mov  r3, r2

+  and  ip, r2, #1

+  and  r3, r3, r1

+  and  r2, r2, r0

+  subs  r4, r4, r2

+  sbc  r5, r5, r3

+  add  r10, r10, #1

+L40:

+  cmp  r10, lr

+  bne  L41

+  ldrd  r0, [sp, #8]

+  adds  r0, r0, r0

+  adc  r1, r1, r1

+  cmp  r6, #0

+  orr  r10, r0, ip

+  mov  r11, r1

+  stmneia  r6, {r4-r5}

+  b  L10

+L2:

+  mov  r10, #0

+  mov  r11, #0

+L10:

+  mov  r0, r10

+  mov  r1, r11

+  sub  sp, r7, #20

+  ldmfd  sp!, {r10, r11}

+  ldmfd  sp!, {r4, r5, r6, r7, pc}

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/udivmoddi4.c b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/udivmoddi4.c
index de226474..829482dd 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/udivmoddi4.c
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/udivmoddi4.c
@@ -1,287 +1,287 @@
-/** @file
-  Compiler intrinsic for 64-bit compare, ported from LLVM code.
-
-  Copyright (c) 2008-2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-/**
-  University of Illinois/NCSA
-  Open Source License
-  
-  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.
-  All rights reserved.
-  
-  Developed by:
-  
-      LLVM Team
-  
-      University of Illinois at Urbana-Champaign
-  
-      http://llvm.org
-  
-  Permission is hereby granted, free of charge, to any person obtaining a copy of
-  this software and associated documentation files (the "Software"), to deal with
-  the Software without restriction, including without limitation the rights to
-  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-  of the Software, and to permit persons to whom the Software is furnished to do
-  so, subject to the following conditions:
-  
-      * Redistributions of source code must retain the above copyright notice,
-        this list of conditions and the following disclaimers.
-  
-      * Redistributions in binary form must reproduce the above copyright notice,
-        this list of conditions and the following disclaimers in the
-        documentation and/or other materials provided with the distribution.
-  
-      * Neither the names of the LLVM Team, University of Illinois at
-        Urbana-Champaign, nor the names of its contributors may be used to
-        endorse or promote products derived from this Software without specific
-        prior written permission.
-  
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
-  SOFTWARE.
-**/
-
-
-#include "Llvm_int_lib.h"
-
-// Effects: if rem != 0, *rem = a % b
-// Returns: a / b
-
-// Translated from Figure 3-40 of The PowerPC Compiler Writer's Guide
-
-UINT64
-__udivmoddi4 (UINT64 a, UINT64 b, UINT64* rem)
-{
-    const unsigned n_uword_bits = sizeof(UINT32) * CHAR_BIT;
-    const unsigned n_udword_bits = sizeof(UINT64) * CHAR_BIT;
-    udwords n;
-    n.all = a;
-    udwords d;
-    d.all = b;
-    udwords q;
-    udwords r;
-    unsigned sr;
-    
-    if (b == 0) {
-//      ASSERT (FALSE);
-      return 0;
-    }
-    
-    // special cases, X is unknown, K != 0
-    if (n.high == 0)
-    {
-        if (d.high == 0)
-        {
-            // 0 X
-            // ---
-            // 0 X
-            if (rem)
-                *rem = n.low % d.low;
-            return n.low / d.low;
-        }
-        // 0 X
-        // ---
-        // K X
-        if (rem)
-            *rem = n.low;
-        return 0;
-    }
-    // n.high != 0
-    if (d.low == 0)
-    {
-        if (d.high == 0)
-        {
-            // K X
-            // ---
-            // 0 0
-            if (rem)
-                *rem = n.high % d.low;
-            return n.high / d.low;
-        }
-        // d.high != 0
-        if (n.low == 0)
-        {
-            // K 0
-            // ---
-            // K 0
-            if (rem)
-            {
-                r.high = n.high % d.high;
-                r.low = 0;
-                *rem = r.all;
-            }
-            return n.high / d.high;
-        }
-        // K K
-        // ---
-        // K 0
-        if ((d.high & (d.high - 1)) == 0)     // if d is a power of 2
-        {
-            if (rem)
-            {
-                r.low = n.low;
-                r.high = n.high & (d.high - 1);
-                *rem = r.all;
-            }
-            return n.high >> COUNT_TRAILING_ZEROS(d.high);
-        }
-        // K K
-        // ---
-        // K 0
-        sr = COUNT_LEADING_ZEROS(d.high) - COUNT_LEADING_ZEROS(n.high);
-        // 0 <= sr <= n_uword_bits - 2 or sr large
-        if (sr > n_uword_bits - 2)
-        {
-           if (rem)
-                *rem = n.all;
-            return 0;
-        }
-        ++sr;
-        // 1 <= sr <= n_uword_bits - 1
-        // q.all = n.all << (n_udword_bits - sr);
-        q.low = 0;
-        q.high = n.low << (n_uword_bits - sr);
-        // r.all = n.all >> sr;
-        r.high = n.high >> sr;
-        r.low = (n.high << (n_uword_bits - sr)) | (n.low >> sr);
-    }
-    else  // d.low != 0
-    {
-        if (d.high == 0)
-        {
-            // K X
-            // ---
-            // 0 K
-            if ((d.low & (d.low - 1)) == 0)     // if d is a power of 2
-            {
-                if (rem)
-                    *rem = n.low & (d.low - 1);
-                if (d.low == 1)
-                    return n.all;
-                unsigned sr = COUNT_TRAILING_ZEROS(d.low);
-                q.high = n.high >> sr;
-                q.low = (n.high << (n_uword_bits - sr)) | (n.low >> sr);
-                return q.all;
-            }
-            // K X
-            // ---
-            // 0 K
-            sr = 1 + n_uword_bits + COUNT_LEADING_ZEROS(d.low) - COUNT_LEADING_ZEROS(n.high);
-            // 2 <= sr <= n_udword_bits - 1
-            // q.all = n.all << (n_udword_bits - sr);
-            // r.all = n.all >> sr;
-            // if (sr == n_uword_bits)
-            // {
-            //     q.low = 0;
-            //     q.high = n.low;
-            //     r.high = 0;
-            //     r.low = n.high;
-            // }
-            // else if (sr < n_uword_bits)  // 2 <= sr <= n_uword_bits - 1
-            // {
-            //     q.low = 0;
-            //     q.high = n.low << (n_uword_bits - sr);
-            //     r.high = n.high >> sr;
-            //     r.low = (n.high << (n_uword_bits - sr)) | (n.low >> sr);
-            // }
-            // else              // n_uword_bits + 1 <= sr <= n_udword_bits - 1
-            // {
-            //     q.low = n.low << (n_udword_bits - sr);
-            //     q.high = (n.high << (n_udword_bits - sr)) |
-            //              (n.low >> (sr - n_uword_bits));
-            //     r.high = 0;
-            //     r.low = n.high >> (sr - n_uword_bits);
-            // }
-            q.low =  (n.low << (n_udword_bits - sr)) &
-                     ((INT32)(n_uword_bits - sr) >> (n_uword_bits-1));
-            q.high = ((n.low << ( n_uword_bits - sr))                       &
-                     ((INT32)(sr - n_uword_bits - 1) >> (n_uword_bits-1))) |
-                     (((n.high << (n_udword_bits - sr))                     |
-                     (n.low >> (sr - n_uword_bits)))                        &
-                     ((INT32)(n_uword_bits - sr) >> (n_uword_bits-1)));
-            r.high = (n.high >> sr) &
-                     ((INT32)(sr - n_uword_bits) >> (n_uword_bits-1));
-            r.low =  ((n.high >> (sr - n_uword_bits))                       &
-                     ((INT32)(n_uword_bits - sr - 1) >> (n_uword_bits-1))) |
-                     (((n.high << (n_uword_bits - sr))                      |
-                     (n.low >> sr))                                         &
-                     ((INT32)(sr - n_uword_bits) >> (n_uword_bits-1)));
-        }
-        else
-        {
-            // K X
-            // ---
-            // K K
-            sr = COUNT_LEADING_ZEROS(d.high) - COUNT_LEADING_ZEROS(n.high);
-            // 0 <= sr <= n_uword_bits - 1 or sr large
-            if (sr > n_uword_bits - 1)
-            {
-               if (rem)
-                    *rem = n.all;
-                return 0;
-            }
-            ++sr;
-            // 1 <= sr <= n_uword_bits
-            // q.all = n.all << (n_udword_bits - sr);
-            q.low = 0;
-            q.high = n.low << (n_uword_bits - sr);
-            // r.all = n.all >> sr;
-            // if (sr < n_uword_bits)
-            // {
-            //     r.high = n.high >> sr;
-            //     r.low = (n.high << (n_uword_bits - sr)) | (n.low >> sr);
-            // }
-            // else
-            // {
-            //     r.high = 0;
-            //     r.low = n.high;
-            // }
-            r.high = (n.high >> sr) &
-                     ((INT32)(sr - n_uword_bits) >> (n_uword_bits-1));
-            r.low = (n.high << (n_uword_bits - sr)) |
-                    ((n.low >> sr)                  &
-                    ((INT32)(sr - n_uword_bits) >> (n_uword_bits-1)));
-        }
-    }
-    // Not a special case
-    // q and r are initialized with:
-    // q.all = n.all << (n_udword_bits - sr);
-    // r.all = n.all >> sr;
-    // 1 <= sr <= n_udword_bits - 1
-    UINT32 carry = 0;
-    for (; sr > 0; --sr)
-    {
-        // r:q = ((r:q)  << 1) | carry
-        r.high = (r.high << 1) | (r.low  >> (n_uword_bits - 1));
-        r.low  = (r.low  << 1) | (q.high >> (n_uword_bits - 1));
-        q.high = (q.high << 1) | (q.low  >> (n_uword_bits - 1));
-        q.low  = (q.low  << 1) | carry;
-        // carry = 0;
-        // if (r.all >= d.all)
-        // {
-        //      r.all -= d.all;
-        //      carry = 1;
-        // }
-        const INT64 s = (INT64)(d.all - r.all - 1) >> (n_udword_bits - 1);
-        carry = s & 1;
-        r.all -= d.all & s;
-    }
-    q.all = (q.all << 1) | carry;
-    if (rem)
-        *rem = r.all;
-    return q.all;
-}
+/** @file

+  Compiler intrinsic for 64-bit compare, ported from LLVM code.

+

+  Copyright (c) 2008-2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+/**

+  University of Illinois/NCSA

+  Open Source License

+  

+  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.

+  All rights reserved.

+  

+  Developed by:

+  

+      LLVM Team

+  

+      University of Illinois at Urbana-Champaign

+  

+      http://llvm.org

+  

+  Permission is hereby granted, free of charge, to any person obtaining a copy of

+  this software and associated documentation files (the "Software"), to deal with

+  the Software without restriction, including without limitation the rights to

+  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies

+  of the Software, and to permit persons to whom the Software is furnished to do

+  so, subject to the following conditions:

+  

+      * Redistributions of source code must retain the above copyright notice,

+        this list of conditions and the following disclaimers.

+  

+      * Redistributions in binary form must reproduce the above copyright notice,

+        this list of conditions and the following disclaimers in the

+        documentation and/or other materials provided with the distribution.

+  

+      * Neither the names of the LLVM Team, University of Illinois at

+        Urbana-Champaign, nor the names of its contributors may be used to

+        endorse or promote products derived from this Software without specific

+        prior written permission.

+  

+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE

+  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE

+  SOFTWARE.

+**/

+

+

+#include "Llvm_int_lib.h"

+

+// Effects: if rem != 0, *rem = a % b

+// Returns: a / b

+

+// Translated from Figure 3-40 of The PowerPC Compiler Writer's Guide

+

+UINT64

+__udivmoddi4 (UINT64 a, UINT64 b, UINT64* rem)

+{

+    const unsigned n_uword_bits = sizeof(UINT32) * CHAR_BIT;

+    const unsigned n_udword_bits = sizeof(UINT64) * CHAR_BIT;

+    udwords n;

+    n.all = a;

+    udwords d;

+    d.all = b;

+    udwords q;

+    udwords r;

+    unsigned sr;

+    

+    if (b == 0) {

+//      ASSERT (FALSE);

+      return 0;

+    }

+    

+    // special cases, X is unknown, K != 0

+    if (n.high == 0)

+    {

+        if (d.high == 0)

+        {

+            // 0 X

+            // ---

+            // 0 X

+            if (rem)

+                *rem = n.low % d.low;

+            return n.low / d.low;

+        }

+        // 0 X

+        // ---

+        // K X

+        if (rem)

+            *rem = n.low;

+        return 0;

+    }

+    // n.high != 0

+    if (d.low == 0)

+    {

+        if (d.high == 0)

+        {

+            // K X

+            // ---

+            // 0 0

+            if (rem)

+                *rem = n.high % d.low;

+            return n.high / d.low;

+        }

+        // d.high != 0

+        if (n.low == 0)

+        {

+            // K 0

+            // ---

+            // K 0

+            if (rem)

+            {

+                r.high = n.high % d.high;

+                r.low = 0;

+                *rem = r.all;

+            }

+            return n.high / d.high;

+        }

+        // K K

+        // ---

+        // K 0

+        if ((d.high & (d.high - 1)) == 0)     // if d is a power of 2

+        {

+            if (rem)

+            {

+                r.low = n.low;

+                r.high = n.high & (d.high - 1);

+                *rem = r.all;

+            }

+            return n.high >> COUNT_TRAILING_ZEROS(d.high);

+        }

+        // K K

+        // ---

+        // K 0

+        sr = COUNT_LEADING_ZEROS(d.high) - COUNT_LEADING_ZEROS(n.high);

+        // 0 <= sr <= n_uword_bits - 2 or sr large

+        if (sr > n_uword_bits - 2)

+        {

+           if (rem)

+                *rem = n.all;

+            return 0;

+        }

+        ++sr;

+        // 1 <= sr <= n_uword_bits - 1

+        // q.all = n.all << (n_udword_bits - sr);

+        q.low = 0;

+        q.high = n.low << (n_uword_bits - sr);

+        // r.all = n.all >> sr;

+        r.high = n.high >> sr;

+        r.low = (n.high << (n_uword_bits - sr)) | (n.low >> sr);

+    }

+    else  // d.low != 0

+    {

+        if (d.high == 0)

+        {

+            // K X

+            // ---

+            // 0 K

+            if ((d.low & (d.low - 1)) == 0)     // if d is a power of 2

+            {

+                if (rem)

+                    *rem = n.low & (d.low - 1);

+                if (d.low == 1)

+                    return n.all;

+                unsigned sr = COUNT_TRAILING_ZEROS(d.low);

+                q.high = n.high >> sr;

+                q.low = (n.high << (n_uword_bits - sr)) | (n.low >> sr);

+                return q.all;

+            }

+            // K X

+            // ---

+            // 0 K

+            sr = 1 + n_uword_bits + COUNT_LEADING_ZEROS(d.low) - COUNT_LEADING_ZEROS(n.high);

+            // 2 <= sr <= n_udword_bits - 1

+            // q.all = n.all << (n_udword_bits - sr);

+            // r.all = n.all >> sr;

+            // if (sr == n_uword_bits)

+            // {

+            //     q.low = 0;

+            //     q.high = n.low;

+            //     r.high = 0;

+            //     r.low = n.high;

+            // }

+            // else if (sr < n_uword_bits)  // 2 <= sr <= n_uword_bits - 1

+            // {

+            //     q.low = 0;

+            //     q.high = n.low << (n_uword_bits - sr);

+            //     r.high = n.high >> sr;

+            //     r.low = (n.high << (n_uword_bits - sr)) | (n.low >> sr);

+            // }

+            // else              // n_uword_bits + 1 <= sr <= n_udword_bits - 1

+            // {

+            //     q.low = n.low << (n_udword_bits - sr);

+            //     q.high = (n.high << (n_udword_bits - sr)) |

+            //              (n.low >> (sr - n_uword_bits));

+            //     r.high = 0;

+            //     r.low = n.high >> (sr - n_uword_bits);

+            // }

+            q.low =  (n.low << (n_udword_bits - sr)) &

+                     ((INT32)(n_uword_bits - sr) >> (n_uword_bits-1));

+            q.high = ((n.low << ( n_uword_bits - sr))                       &

+                     ((INT32)(sr - n_uword_bits - 1) >> (n_uword_bits-1))) |

+                     (((n.high << (n_udword_bits - sr))                     |

+                     (n.low >> (sr - n_uword_bits)))                        &

+                     ((INT32)(n_uword_bits - sr) >> (n_uword_bits-1)));

+            r.high = (n.high >> sr) &

+                     ((INT32)(sr - n_uword_bits) >> (n_uword_bits-1));

+            r.low =  ((n.high >> (sr - n_uword_bits))                       &

+                     ((INT32)(n_uword_bits - sr - 1) >> (n_uword_bits-1))) |

+                     (((n.high << (n_uword_bits - sr))                      |

+                     (n.low >> sr))                                         &

+                     ((INT32)(sr - n_uword_bits) >> (n_uword_bits-1)));

+        }

+        else

+        {

+            // K X

+            // ---

+            // K K

+            sr = COUNT_LEADING_ZEROS(d.high) - COUNT_LEADING_ZEROS(n.high);

+            // 0 <= sr <= n_uword_bits - 1 or sr large

+            if (sr > n_uword_bits - 1)

+            {

+               if (rem)

+                    *rem = n.all;

+                return 0;

+            }

+            ++sr;

+            // 1 <= sr <= n_uword_bits

+            // q.all = n.all << (n_udword_bits - sr);

+            q.low = 0;

+            q.high = n.low << (n_uword_bits - sr);

+            // r.all = n.all >> sr;

+            // if (sr < n_uword_bits)

+            // {

+            //     r.high = n.high >> sr;

+            //     r.low = (n.high << (n_uword_bits - sr)) | (n.low >> sr);

+            // }

+            // else

+            // {

+            //     r.high = 0;

+            //     r.low = n.high;

+            // }

+            r.high = (n.high >> sr) &

+                     ((INT32)(sr - n_uword_bits) >> (n_uword_bits-1));

+            r.low = (n.high << (n_uword_bits - sr)) |

+                    ((n.low >> sr)                  &

+                    ((INT32)(sr - n_uword_bits) >> (n_uword_bits-1)));

+        }

+    }

+    // Not a special case

+    // q and r are initialized with:

+    // q.all = n.all << (n_udword_bits - sr);

+    // r.all = n.all >> sr;

+    // 1 <= sr <= n_udword_bits - 1

+    UINT32 carry = 0;

+    for (; sr > 0; --sr)

+    {

+        // r:q = ((r:q)  << 1) | carry

+        r.high = (r.high << 1) | (r.low  >> (n_uword_bits - 1));

+        r.low  = (r.low  << 1) | (q.high >> (n_uword_bits - 1));

+        q.high = (q.high << 1) | (q.low  >> (n_uword_bits - 1));

+        q.low  = (q.low  << 1) | carry;

+        // carry = 0;

+        // if (r.all >= d.all)

+        // {

+        //      r.all -= d.all;

+        //      carry = 1;

+        // }

+        const INT64 s = (INT64)(d.all - r.all - 1) >> (n_udword_bits - 1);

+        carry = s & 1;

+        r.all -= d.all & s;

+    }

+    q.all = (q.all << 1) | carry;

+    if (rem)

+        *rem = r.all;

+    return q.all;

+}

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/udivsi3.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/udivsi3.S
index 92c9cad9..a9223d7f 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/udivsi3.S
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/udivsi3.S
@@ -1,57 +1,57 @@
-#------------------------------------------------------------------------------ 
-#
-# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-#
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#------------------------------------------------------------------------------
-
-  .text
-  .align 2
-  GCC_ASM_EXPORT(__udivsi3)
-
-ASM_PFX(__udivsi3):
-  cmp  r1, #0
-  cmpne  r0, #0
-  stmfd  sp!, {r4, r5, r7, lr}
-  add  r7, sp, #8
-  beq  L2
-  clz  r2, r1
-  clz  r3, r0
-  rsb  r3, r3, r2
-  cmp  r3, #31
-  bhi  L2
-  ldmeqfd  sp!, {r4, r5, r7, pc}
-  add  r5, r3, #1
-  rsb  r3, r3, #31
-  mov  lr, #0
-  mov  r2, r0, asl r3
-  mov  ip, r0, lsr r5
-  mov  r4, lr
-  b  L8
-L9:
-  mov  r0, r2, lsr #31
-  orr  ip, r0, ip, asl #1
-  orr  r2, r3, lr
-  rsb  r3, ip, r1
-  sub  r3, r3, #1
-  and  r0, r1, r3, asr #31
-  mov  lr, r3, lsr #31
-  rsb  ip, r0, ip
-  add  r4, r4, #1
-L8:
-  cmp  r4, r5
-  mov  r3, r2, asl #1
-  bne  L9
-  orr  r0, r3, lr
-  ldmfd  sp!, {r4, r5, r7, pc}
-L2:
-  mov  r0, #0
-  ldmfd  sp!, {r4, r5, r7, pc}
-
+#------------------------------------------------------------------------------ 

+#

+# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+  .text

+  .align 2

+  GCC_ASM_EXPORT(__udivsi3)

+

+ASM_PFX(__udivsi3):

+  cmp  r1, #0

+  cmpne  r0, #0

+  stmfd  sp!, {r4, r5, r7, lr}

+  add  r7, sp, #8

+  beq  L2

+  clz  r2, r1

+  clz  r3, r0

+  rsb  r3, r3, r2

+  cmp  r3, #31

+  bhi  L2

+  ldmeqfd  sp!, {r4, r5, r7, pc}

+  add  r5, r3, #1

+  rsb  r3, r3, #31

+  mov  lr, #0

+  mov  r2, r0, asl r3

+  mov  ip, r0, lsr r5

+  mov  r4, lr

+  b  L8

+L9:

+  mov  r0, r2, lsr #31

+  orr  ip, r0, ip, asl #1

+  orr  r2, r3, lr

+  rsb  r3, ip, r1

+  sub  r3, r3, #1

+  and  r0, r1, r3, asr #31

+  mov  lr, r3, lsr #31

+  rsb  ip, r0, ip

+  add  r4, r4, #1

+L8:

+  cmp  r4, r5

+  mov  r3, r2, asl #1

+  bne  L9

+  orr  r0, r3, lr

+  ldmfd  sp!, {r4, r5, r7, pc}

+L2:

+  mov  r0, #0

+  ldmfd  sp!, {r4, r5, r7, pc}

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/udivsi3.c b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/udivsi3.c
index aec1a1cc..020b3fad 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/udivsi3.c
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/udivsi3.c
@@ -1,111 +1,111 @@
-/** @file
-  Compiler intrinsic for 32-bit unsigned div, ported from LLVM code.
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-/**
-  University of Illinois/NCSA
-  Open Source License
-  
-  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.
-  All rights reserved.
-  
-  Developed by:
-  
-      LLVM Team
-  
-      University of Illinois at Urbana-Champaign
-  
-      http://llvm.org
-  
-  Permission is hereby granted, free of charge, to any person obtaining a copy of
-  this software and associated documentation files (the "Software"), to deal with
-  the Software without restriction, including without limitation the rights to
-  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-  of the Software, and to permit persons to whom the Software is furnished to do
-  so, subject to the following conditions:
-  
-      * Redistributions of source code must retain the above copyright notice,
-        this list of conditions and the following disclaimers.
-  
-      * Redistributions in binary form must reproduce the above copyright notice,
-        this list of conditions and the following disclaimers in the
-        documentation and/or other materials provided with the distribution.
-  
-      * Neither the names of the LLVM Team, University of Illinois at
-        Urbana-Champaign, nor the names of its contributors may be used to
-        endorse or promote products derived from this Software without specific
-        prior written permission.
-  
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
-  SOFTWARE.
-**/
-
-
-#include "Llvm_int_lib.h"
-
-
-// Returns: n / d
-
-// Translated from Figure 3-40 of The PowerPC Compiler Writer's Guide
-
-UINT32
-__udivsi3(UINT32 n, UINT32 d)
-{
-    const unsigned n_uword_bits = sizeof(UINT32) * CHAR_BIT;
-    UINT32 q;
-    UINT32 r;
-    unsigned sr;
-
-    // special cases
-    if (d == 0) {
-//        ASSERT (FALSE);
-        return 0; // ?!
-        }
-    if (n == 0)
-        return 0;
-
-    sr = COUNT_LEADING_ZEROS(d) - COUNT_LEADING_ZEROS(n);
-    // 0 <= sr <= n_uword_bits - 1 or sr large
-    if (sr > n_uword_bits - 1)  // d > r
-        return 0;
-    if (sr == n_uword_bits - 1)  // d == 1
-        return n;
-    ++sr;
-    // 1 <= sr <= n_uword_bits - 1
-    // Not a special case
-    q = n << (n_uword_bits - sr);
-    r = n >> sr;
-    UINT32 carry = 0;
-    for (; sr > 0; --sr)
-    {
-        // r:q = ((r:q)  << 1) | carry
-        r = (r << 1) | (q >> (n_uword_bits - 1));
-        q = (q << 1) | carry;
-        // carry = 0;
-        // if (r.all >= d.all)
-        // {
-        //      r.all -= d.all;
-        //      carry = 1;
-        // }
-        const INT32 s = (INT32)(d - r - 1) >> (n_uword_bits - 1);
-        carry = s & 1;
-        r -= d & s;
-    }
-    q = (q << 1) | carry;
-    return q;
-}
+/** @file

+  Compiler intrinsic for 32-bit unsigned div, ported from LLVM code.

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+/**

+  University of Illinois/NCSA

+  Open Source License

+  

+  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.

+  All rights reserved.

+  

+  Developed by:

+  

+      LLVM Team

+  

+      University of Illinois at Urbana-Champaign

+  

+      http://llvm.org

+  

+  Permission is hereby granted, free of charge, to any person obtaining a copy of

+  this software and associated documentation files (the "Software"), to deal with

+  the Software without restriction, including without limitation the rights to

+  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies

+  of the Software, and to permit persons to whom the Software is furnished to do

+  so, subject to the following conditions:

+  

+      * Redistributions of source code must retain the above copyright notice,

+        this list of conditions and the following disclaimers.

+  

+      * Redistributions in binary form must reproduce the above copyright notice,

+        this list of conditions and the following disclaimers in the

+        documentation and/or other materials provided with the distribution.

+  

+      * Neither the names of the LLVM Team, University of Illinois at

+        Urbana-Champaign, nor the names of its contributors may be used to

+        endorse or promote products derived from this Software without specific

+        prior written permission.

+  

+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE

+  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE

+  SOFTWARE.

+**/

+

+

+#include "Llvm_int_lib.h"

+

+

+// Returns: n / d

+

+// Translated from Figure 3-40 of The PowerPC Compiler Writer's Guide

+

+UINT32

+__udivsi3(UINT32 n, UINT32 d)

+{

+    const unsigned n_uword_bits = sizeof(UINT32) * CHAR_BIT;

+    UINT32 q;

+    UINT32 r;

+    unsigned sr;

+

+    // special cases

+    if (d == 0) {

+//        ASSERT (FALSE);

+        return 0; // ?!

+        }

+    if (n == 0)

+        return 0;

+

+    sr = COUNT_LEADING_ZEROS(d) - COUNT_LEADING_ZEROS(n);

+    // 0 <= sr <= n_uword_bits - 1 or sr large

+    if (sr > n_uword_bits - 1)  // d > r

+        return 0;

+    if (sr == n_uword_bits - 1)  // d == 1

+        return n;

+    ++sr;

+    // 1 <= sr <= n_uword_bits - 1

+    // Not a special case

+    q = n << (n_uword_bits - sr);

+    r = n >> sr;

+    UINT32 carry = 0;

+    for (; sr > 0; --sr)

+    {

+        // r:q = ((r:q)  << 1) | carry

+        r = (r << 1) | (q >> (n_uword_bits - 1));

+        q = (q << 1) | carry;

+        // carry = 0;

+        // if (r.all >= d.all)

+        // {

+        //      r.all -= d.all;

+        //      carry = 1;

+        // }

+        const INT32 s = (INT32)(d - r - 1) >> (n_uword_bits - 1);

+        carry = s & 1;

+        r -= d & s;

+    }

+    q = (q << 1) | carry;

+    return q;

+}

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/uldiv.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/uldiv.S
index 6b55135f..75b0bb93 100755
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/uldiv.S
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/uldiv.S
@@ -1,267 +1,267 @@
-//------------------------------------------------------------------------------ 
-//
-// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-//
-// This program and the accompanying materials
-// are licensed and made available under the terms and conditions of the BSD License
-// which accompanies this distribution.  The full text of the license may be found at
-// http://opensource.org/licenses/bsd-license.php
-//
-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-//
-//------------------------------------------------------------------------------
-
-
-
-  .text
-  .align 2
-  GCC_ASM_EXPORT(__aeabi_uldivmod)
-
-//        
-//UINT64
-//EFIAPI
-//__aeabi_uldivmod (
-//  IN  UINT64   Dividend  
-//  IN  UINT64   Divisor
-//  )
-//
-ASM_PFX(__aeabi_uldivmod):
-  stmdb   sp!, {r4, r5, r6, lr}
-  mov     r4, r1
-  mov     r5, r0
-  mov     r6, #0  // 0x0
-  orrs    ip, r3, r2, lsr #31
-  bne     ASM_PFX(__aeabi_uldivmod_label1)
-  tst     r2, r2
-  beq     ASM_PFX(_ll_div0)
-  movs    ip, r2, lsr #15
-  addeq   r6, r6, #16     // 0x10
-  mov     ip, r2, lsl r6
-  movs    lr, ip, lsr #23
-  moveq   ip, ip, lsl #8
-  addeq   r6, r6, #8      // 0x8
-  movs    lr, ip, lsr #27
-  moveq   ip, ip, lsl #4
-  addeq   r6, r6, #4      // 0x4
-  movs    lr, ip, lsr #29
-  moveq   ip, ip, lsl #2
-  addeq   r6, r6, #2      // 0x2
-  movs    lr, ip, lsr #30
-  moveq   ip, ip, lsl #1
-  addeq   r6, r6, #1      // 0x1
-  b       ASM_PFX(_ll_udiv_small)
-ASM_PFX(__aeabi_uldivmod_label1):
-  tst     r3, #-2147483648        // 0x80000000
-  bne     ASM_PFX(__aeabi_uldivmod_label2)
-  movs    ip, r3, lsr #15
-  addeq   r6, r6, #16     // 0x10
-  mov     ip, r3, lsl r6
-  movs    lr, ip, lsr #23
-  moveq   ip, ip, lsl #8
-  addeq   r6, r6, #8      // 0x8
-  movs    lr, ip, lsr #27
-  moveq   ip, ip, lsl #4
-  addeq   r6, r6, #4      // 0x4
-  movs    lr, ip, lsr #29
-  moveq   ip, ip, lsl #2
-  addeq   r6, r6, #2      // 0x2
-  movs    lr, ip, lsr #30
-  addeq   r6, r6, #1      // 0x1
-  rsb     r3, r6, #32     // 0x20
-  moveq   ip, ip, lsl #1
-  orr     ip, ip, r2, lsr r3
-  mov     lr, r2, lsl r6
-  b       ASM_PFX(_ll_udiv_big)
-ASM_PFX(__aeabi_uldivmod_label2):
-  mov     ip, r3
-  mov     lr, r2
-  b       ASM_PFX(_ll_udiv_ginormous)
-  
-ASM_PFX(_ll_udiv_small):
-  cmp     r4, ip, lsl #1
-  mov     r3, #0  // 0x0
-  subcs   r4, r4, ip, lsl #1
-  addcs   r3, r3, #2      // 0x2
-  cmp     r4, ip
-  subcs   r4, r4, ip
-  adcs    r3, r3, #0      // 0x0
-  add     r2, r6, #32     // 0x20
-  cmp     r2, #32 // 0x20
-  rsb     ip, ip, #0      // 0x0
-  bcc     ASM_PFX(_ll_udiv_small_label1)
-  orrs    r0, r4, r5, lsr #30
-  moveq   r4, r5
-  moveq   r5, #0  // 0x0
-  subeq   r2, r2, #32     // 0x20
-ASM_PFX(_ll_udiv_small_label1):
-  mov     r1, #0  // 0x0
-  cmp     r2, #16 // 0x10
-  bcc     ASM_PFX(_ll_udiv_small_label2)
-  movs    r0, r4, lsr #14
-  moveq   r4, r4, lsl #16
-  addeq   r1, r1, #16     // 0x10
-ASM_PFX(_ll_udiv_small_label2):
-  sub     lr, r2, r1
-  cmp     lr, #8  // 0x8
-  bcc     ASM_PFX(_ll_udiv_small_label3)
-  movs    r0, r4, lsr #22
-  moveq   r4, r4, lsl #8
-  addeq   r1, r1, #8      // 0x8
-ASM_PFX(_ll_udiv_small_label3):
-  rsb     r0, r1, #32     // 0x20
-  sub     r2, r2, r1
-  orr     r4, r4, r5, lsr r0
-  mov     r5, r5, lsl r1
-  cmp     r2, #1  // 0x1
-  bcc     ASM_PFX(_ll_udiv_small_label5)
-  sub     r2, r2, #1      // 0x1
-  and     r0, r2, #7      // 0x7
-  eor     r0, r0, #7      // 0x7
-  adds    r0, r0, r0, lsl #1
-  add     pc, pc, r0, lsl #2
-  nop                     // (mov r0,r0)
-ASM_PFX(_ll_udiv_small_label4):
-  adcs    r5, r5, r5
-  adcs    r4, ip, r4, lsl #1
-  rsbcc   r4, ip, r4
-  adcs    r5, r5, r5
-  adcs    r4, ip, r4, lsl #1
-  rsbcc   r4, ip, r4
-  adcs    r5, r5, r5
-  adcs    r4, ip, r4, lsl #1
-  rsbcc   r4, ip, r4
-  adcs    r5, r5, r5
-  adcs    r4, ip, r4, lsl #1
-  rsbcc   r4, ip, r4
-  adcs    r5, r5, r5
-  adcs    r4, ip, r4, lsl #1
-  rsbcc   r4, ip, r4
-  adcs    r5, r5, r5
-  adcs    r4, ip, r4, lsl #1
-  rsbcc   r4, ip, r4
-  adcs    r5, r5, r5
-  adcs    r4, ip, r4, lsl #1
-  rsbcc   r4, ip, r4
-  adcs    r5, r5, r5
-  adcs    r4, ip, r4, lsl #1
-  sub     r2, r2, #8      // 0x8
-  tst     r2, r2
-  rsbcc   r4, ip, r4
-  bpl     ASM_PFX(_ll_udiv_small_label4)
-ASM_PFX(_ll_udiv_small_label5):
-  mov     r2, r4, lsr r6
-  bic     r4, r4, r2, lsl r6
-  adcs    r0, r5, r5
-  adc     r1, r4, r4
-  add     r1, r1, r3, lsl r6
-  mov     r3, #0  // 0x0
-  ldmia   sp!, {r4, r5, r6, pc}
-  
-ASM_PFX(_ll_udiv_big):
-  subs    r0, r5, lr
-  mov     r3, #0  // 0x0
-  sbcs    r1, r4, ip
-  movcs   r5, r0
-  movcs   r4, r1
-  adcs    r3, r3, #0      // 0x0
-  subs    r0, r5, lr
-  sbcs    r1, r4, ip
-  movcs   r5, r0
-  movcs   r4, r1
-  adcs    r3, r3, #0      // 0x0
-  subs    r0, r5, lr
-  sbcs    r1, r4, ip
-  movcs   r5, r0
-  movcs   r4, r1
-  adcs    r3, r3, #0      // 0x0
-  mov     r1, #0  // 0x0
-  rsbs    lr, lr, #0      // 0x0
-  rsc     ip, ip, #0      // 0x0
-  cmp     r6, #16 // 0x10
-  bcc     ASM_PFX(_ll_udiv_big_label1)
-  movs    r0, r4, lsr #14
-  moveq   r4, r4, lsl #16
-  addeq   r1, r1, #16     // 0x10
-ASM_PFX(_ll_udiv_big_label1):
-  sub     r2, r6, r1
-  cmp     r2, #8  // 0x8
-  bcc     ASM_PFX(_ll_udiv_big_label2)
-  movs    r0, r4, lsr #22
-  moveq   r4, r4, lsl #8
-  addeq   r1, r1, #8      // 0x8
-ASM_PFX(_ll_udiv_big_label2):
-  rsb     r0, r1, #32     // 0x20
-  sub     r2, r6, r1
-  orr     r4, r4, r5, lsr r0
-  mov     r5, r5, lsl r1
-  cmp     r2, #1  // 0x1
-  bcc     ASM_PFX(_ll_udiv_big_label4)
-  sub     r2, r2, #1      // 0x1
-  and     r0, r2, #3      // 0x3
-  rsb     r0, r0, #3      // 0x3
-  adds    r0, r0, r0, lsl #1
-  add     pc, pc, r0, lsl #3
-  nop                     // (mov r0,r0)
-ASM_PFX(_ll_udiv_big_label3):
-  adcs    r5, r5, r5
-  adcs    r4, r4, r4
-  adcs    r0, lr, r5
-  adcs    r1, ip, r4
-  movcs   r5, r0
-  movcs   r4, r1
-  adcs    r5, r5, r5
-  adcs    r4, r4, r4
-  adcs    r0, lr, r5
-  adcs    r1, ip, r4
-  movcs   r5, r0
-  movcs   r4, r1
-  adcs    r5, r5, r5
-  adcs    r4, r4, r4
-  adcs    r0, lr, r5
-  adcs    r1, ip, r4
-  movcs   r5, r0
-  movcs   r4, r1
-  sub     r2, r2, #4      // 0x4
-  adcs    r5, r5, r5
-  adcs    r4, r4, r4
-  adcs    r0, lr, r5
-  adcs    r1, ip, r4
-  tst     r2, r2
-  movcs   r5, r0
-  movcs   r4, r1
-  bpl     ASM_PFX(_ll_udiv_big_label3)
-ASM_PFX(_ll_udiv_big_label4):
-  mov     r1, #0  // 0x0
-  mov     r2, r5, lsr r6
-  bic     r5, r5, r2, lsl r6
-  adcs    r0, r5, r5
-  adc     r1, r1, #0      // 0x0
-  movs    lr, r3, lsl r6
-  mov     r3, r4, lsr r6
-  bic     r4, r4, r3, lsl r6
-  adc     r1, r1, #0      // 0x0
-  adds    r0, r0, lr
-  orr     r2, r2, r4, ror r6
-  adc     r1, r1, #0      // 0x0
-  ldmia   sp!, {r4, r5, r6, pc}
-  
-ASM_PFX(_ll_udiv_ginormous):
-  subs    r2, r5, lr
-  mov     r1, #0  // 0x0
-  sbcs    r3, r4, ip
-  adc     r0, r1, r1
-  movcc   r2, r5
-  movcc   r3, r4
-  ldmia   sp!, {r4, r5, r6, pc}
-  
-ASM_PFX(_ll_div0):
-  ldmia   sp!, {r4, r5, r6, lr}
-  mov     r0, #0  // 0x0
-  mov     r1, #0  // 0x0
-  b       ASM_PFX(__aeabi_ldiv0)
-  
-ASM_PFX(__aeabi_ldiv0):
-  bx      r14
-
-
+//------------------------------------------------------------------------------ 

+//

+// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+//

+// This program and the accompanying materials

+// are licensed and made available under the terms and conditions of the BSD License

+// which accompanies this distribution.  The full text of the license may be found at

+// http://opensource.org/licenses/bsd-license.php

+//

+// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+//

+//------------------------------------------------------------------------------

+

+

+

+  .text

+  .align 2

+  GCC_ASM_EXPORT(__aeabi_uldivmod)

+

+//        

+//UINT64

+//EFIAPI

+//__aeabi_uldivmod (

+//  IN  UINT64   Dividend  

+//  IN  UINT64   Divisor

+//  )

+//

+ASM_PFX(__aeabi_uldivmod):

+  stmdb   sp!, {r4, r5, r6, lr}

+  mov     r4, r1

+  mov     r5, r0

+  mov     r6, #0  // 0x0

+  orrs    ip, r3, r2, lsr #31

+  bne     ASM_PFX(__aeabi_uldivmod_label1)

+  tst     r2, r2

+  beq     ASM_PFX(_ll_div0)

+  movs    ip, r2, lsr #15

+  addeq   r6, r6, #16     // 0x10

+  mov     ip, r2, lsl r6

+  movs    lr, ip, lsr #23

+  moveq   ip, ip, lsl #8

+  addeq   r6, r6, #8      // 0x8

+  movs    lr, ip, lsr #27

+  moveq   ip, ip, lsl #4

+  addeq   r6, r6, #4      // 0x4

+  movs    lr, ip, lsr #29

+  moveq   ip, ip, lsl #2

+  addeq   r6, r6, #2      // 0x2

+  movs    lr, ip, lsr #30

+  moveq   ip, ip, lsl #1

+  addeq   r6, r6, #1      // 0x1

+  b       ASM_PFX(_ll_udiv_small)

+ASM_PFX(__aeabi_uldivmod_label1):

+  tst     r3, #-2147483648        // 0x80000000

+  bne     ASM_PFX(__aeabi_uldivmod_label2)

+  movs    ip, r3, lsr #15

+  addeq   r6, r6, #16     // 0x10

+  mov     ip, r3, lsl r6

+  movs    lr, ip, lsr #23

+  moveq   ip, ip, lsl #8

+  addeq   r6, r6, #8      // 0x8

+  movs    lr, ip, lsr #27

+  moveq   ip, ip, lsl #4

+  addeq   r6, r6, #4      // 0x4

+  movs    lr, ip, lsr #29

+  moveq   ip, ip, lsl #2

+  addeq   r6, r6, #2      // 0x2

+  movs    lr, ip, lsr #30

+  addeq   r6, r6, #1      // 0x1

+  rsb     r3, r6, #32     // 0x20

+  moveq   ip, ip, lsl #1

+  orr     ip, ip, r2, lsr r3

+  mov     lr, r2, lsl r6

+  b       ASM_PFX(_ll_udiv_big)

+ASM_PFX(__aeabi_uldivmod_label2):

+  mov     ip, r3

+  mov     lr, r2

+  b       ASM_PFX(_ll_udiv_ginormous)

+  

+ASM_PFX(_ll_udiv_small):

+  cmp     r4, ip, lsl #1

+  mov     r3, #0  // 0x0

+  subcs   r4, r4, ip, lsl #1

+  addcs   r3, r3, #2      // 0x2

+  cmp     r4, ip

+  subcs   r4, r4, ip

+  adcs    r3, r3, #0      // 0x0

+  add     r2, r6, #32     // 0x20

+  cmp     r2, #32 // 0x20

+  rsb     ip, ip, #0      // 0x0

+  bcc     ASM_PFX(_ll_udiv_small_label1)

+  orrs    r0, r4, r5, lsr #30

+  moveq   r4, r5

+  moveq   r5, #0  // 0x0

+  subeq   r2, r2, #32     // 0x20

+ASM_PFX(_ll_udiv_small_label1):

+  mov     r1, #0  // 0x0

+  cmp     r2, #16 // 0x10

+  bcc     ASM_PFX(_ll_udiv_small_label2)

+  movs    r0, r4, lsr #14

+  moveq   r4, r4, lsl #16

+  addeq   r1, r1, #16     // 0x10

+ASM_PFX(_ll_udiv_small_label2):

+  sub     lr, r2, r1

+  cmp     lr, #8  // 0x8

+  bcc     ASM_PFX(_ll_udiv_small_label3)

+  movs    r0, r4, lsr #22

+  moveq   r4, r4, lsl #8

+  addeq   r1, r1, #8      // 0x8

+ASM_PFX(_ll_udiv_small_label3):

+  rsb     r0, r1, #32     // 0x20

+  sub     r2, r2, r1

+  orr     r4, r4, r5, lsr r0

+  mov     r5, r5, lsl r1

+  cmp     r2, #1  // 0x1

+  bcc     ASM_PFX(_ll_udiv_small_label5)

+  sub     r2, r2, #1      // 0x1

+  and     r0, r2, #7      // 0x7

+  eor     r0, r0, #7      // 0x7

+  adds    r0, r0, r0, lsl #1

+  add     pc, pc, r0, lsl #2

+  nop                     // (mov r0,r0)

+ASM_PFX(_ll_udiv_small_label4):

+  adcs    r5, r5, r5

+  adcs    r4, ip, r4, lsl #1

+  rsbcc   r4, ip, r4

+  adcs    r5, r5, r5

+  adcs    r4, ip, r4, lsl #1

+  rsbcc   r4, ip, r4

+  adcs    r5, r5, r5

+  adcs    r4, ip, r4, lsl #1

+  rsbcc   r4, ip, r4

+  adcs    r5, r5, r5

+  adcs    r4, ip, r4, lsl #1

+  rsbcc   r4, ip, r4

+  adcs    r5, r5, r5

+  adcs    r4, ip, r4, lsl #1

+  rsbcc   r4, ip, r4

+  adcs    r5, r5, r5

+  adcs    r4, ip, r4, lsl #1

+  rsbcc   r4, ip, r4

+  adcs    r5, r5, r5

+  adcs    r4, ip, r4, lsl #1

+  rsbcc   r4, ip, r4

+  adcs    r5, r5, r5

+  adcs    r4, ip, r4, lsl #1

+  sub     r2, r2, #8      // 0x8

+  tst     r2, r2

+  rsbcc   r4, ip, r4

+  bpl     ASM_PFX(_ll_udiv_small_label4)

+ASM_PFX(_ll_udiv_small_label5):

+  mov     r2, r4, lsr r6

+  bic     r4, r4, r2, lsl r6

+  adcs    r0, r5, r5

+  adc     r1, r4, r4

+  add     r1, r1, r3, lsl r6

+  mov     r3, #0  // 0x0

+  ldmia   sp!, {r4, r5, r6, pc}

+  

+ASM_PFX(_ll_udiv_big):

+  subs    r0, r5, lr

+  mov     r3, #0  // 0x0

+  sbcs    r1, r4, ip

+  movcs   r5, r0

+  movcs   r4, r1

+  adcs    r3, r3, #0      // 0x0

+  subs    r0, r5, lr

+  sbcs    r1, r4, ip

+  movcs   r5, r0

+  movcs   r4, r1

+  adcs    r3, r3, #0      // 0x0

+  subs    r0, r5, lr

+  sbcs    r1, r4, ip

+  movcs   r5, r0

+  movcs   r4, r1

+  adcs    r3, r3, #0      // 0x0

+  mov     r1, #0  // 0x0

+  rsbs    lr, lr, #0      // 0x0

+  rsc     ip, ip, #0      // 0x0

+  cmp     r6, #16 // 0x10

+  bcc     ASM_PFX(_ll_udiv_big_label1)

+  movs    r0, r4, lsr #14

+  moveq   r4, r4, lsl #16

+  addeq   r1, r1, #16     // 0x10

+ASM_PFX(_ll_udiv_big_label1):

+  sub     r2, r6, r1

+  cmp     r2, #8  // 0x8

+  bcc     ASM_PFX(_ll_udiv_big_label2)

+  movs    r0, r4, lsr #22

+  moveq   r4, r4, lsl #8

+  addeq   r1, r1, #8      // 0x8

+ASM_PFX(_ll_udiv_big_label2):

+  rsb     r0, r1, #32     // 0x20

+  sub     r2, r6, r1

+  orr     r4, r4, r5, lsr r0

+  mov     r5, r5, lsl r1

+  cmp     r2, #1  // 0x1

+  bcc     ASM_PFX(_ll_udiv_big_label4)

+  sub     r2, r2, #1      // 0x1

+  and     r0, r2, #3      // 0x3

+  rsb     r0, r0, #3      // 0x3

+  adds    r0, r0, r0, lsl #1

+  add     pc, pc, r0, lsl #3

+  nop                     // (mov r0,r0)

+ASM_PFX(_ll_udiv_big_label3):

+  adcs    r5, r5, r5

+  adcs    r4, r4, r4

+  adcs    r0, lr, r5

+  adcs    r1, ip, r4

+  movcs   r5, r0

+  movcs   r4, r1

+  adcs    r5, r5, r5

+  adcs    r4, r4, r4

+  adcs    r0, lr, r5

+  adcs    r1, ip, r4

+  movcs   r5, r0

+  movcs   r4, r1

+  adcs    r5, r5, r5

+  adcs    r4, r4, r4

+  adcs    r0, lr, r5

+  adcs    r1, ip, r4

+  movcs   r5, r0

+  movcs   r4, r1

+  sub     r2, r2, #4      // 0x4

+  adcs    r5, r5, r5

+  adcs    r4, r4, r4

+  adcs    r0, lr, r5

+  adcs    r1, ip, r4

+  tst     r2, r2

+  movcs   r5, r0

+  movcs   r4, r1

+  bpl     ASM_PFX(_ll_udiv_big_label3)

+ASM_PFX(_ll_udiv_big_label4):

+  mov     r1, #0  // 0x0

+  mov     r2, r5, lsr r6

+  bic     r5, r5, r2, lsl r6

+  adcs    r0, r5, r5

+  adc     r1, r1, #0      // 0x0

+  movs    lr, r3, lsl r6

+  mov     r3, r4, lsr r6

+  bic     r4, r4, r3, lsl r6

+  adc     r1, r1, #0      // 0x0

+  adds    r0, r0, lr

+  orr     r2, r2, r4, ror r6

+  adc     r1, r1, #0      // 0x0

+  ldmia   sp!, {r4, r5, r6, pc}

+  

+ASM_PFX(_ll_udiv_ginormous):

+  subs    r2, r5, lr

+  mov     r1, #0  // 0x0

+  sbcs    r3, r4, ip

+  adc     r0, r1, r1

+  movcc   r2, r5

+  movcc   r3, r4

+  ldmia   sp!, {r4, r5, r6, pc}

+  

+ASM_PFX(_ll_div0):

+  ldmia   sp!, {r4, r5, r6, lr}

+  mov     r0, #0  // 0x0

+  mov     r1, #0  // 0x0

+  b       ASM_PFX(__aeabi_ldiv0)

+  

+ASM_PFX(__aeabi_ldiv0):

+  bx      r14

+

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/uldiv.asm b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/uldiv.asm
index d792342e..393794c1 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/uldiv.asm
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/uldiv.asm
@@ -1,268 +1,268 @@
-//------------------------------------------------------------------------------ 
-//
-// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-//
-// This program and the accompanying materials
-// are licensed and made available under the terms and conditions of the BSD License
-// which accompanies this distribution.  The full text of the license may be found at
-// http://opensource.org/licenses/bsd-license.php
-//
-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-//
-//------------------------------------------------------------------------------
-
-
-
-    EXPORT  __aeabi_uldivmod
-
-    AREA  Uldivmod, CODE, READONLY
-
-;        
-;UINT64
-;EFIAPI
-;__aeabi_uldivmod (
-;  IN  UINT64   Dividend  
-;  IN  UINT64   Divisor
-;  )
-;
-__aeabi_uldivmod
-  stmdb   sp!, {r4, r5, r6, lr}
-  mov     r4, r1
-  mov     r5, r0
-  mov     r6, #0  ; 0x0
-  orrs    ip, r3, r2, lsr #31
-  bne     __aeabi_uldivmod_label1
-  tst     r2, r2
-  beq     _ll_div0
-  movs    ip, r2, lsr #15
-  addeq   r6, r6, #16     ; 0x10
-  mov     ip, r2, lsl r6
-  movs    lr, ip, lsr #23
-  moveq   ip, ip, lsl #8
-  addeq   r6, r6, #8      ; 0x8
-  movs    lr, ip, lsr #27
-  moveq   ip, ip, lsl #4
-  addeq   r6, r6, #4      ; 0x4
-  movs    lr, ip, lsr #29
-  moveq   ip, ip, lsl #2
-  addeq   r6, r6, #2      ; 0x2
-  movs    lr, ip, lsr #30
-  moveq   ip, ip, lsl #1
-  addeq   r6, r6, #1      ; 0x1
-  b       _ll_udiv_small
-__aeabi_uldivmod_label1
-  tst     r3, #-2147483648        ; 0x80000000
-  bne     __aeabi_uldivmod_label2
-  movs    ip, r3, lsr #15
-  addeq   r6, r6, #16     ; 0x10
-  mov     ip, r3, lsl r6
-  movs    lr, ip, lsr #23
-  moveq   ip, ip, lsl #8
-  addeq   r6, r6, #8      ; 0x8
-  movs    lr, ip, lsr #27
-  moveq   ip, ip, lsl #4
-  addeq   r6, r6, #4      ; 0x4
-  movs    lr, ip, lsr #29
-  moveq   ip, ip, lsl #2
-  addeq   r6, r6, #2      ; 0x2
-  movs    lr, ip, lsr #30
-  addeq   r6, r6, #1      ; 0x1
-  rsb     r3, r6, #32     ; 0x20
-  moveq   ip, ip, lsl #1
-  orr     ip, ip, r2, lsr r3
-  mov     lr, r2, lsl r6
-  b       _ll_udiv_big
-__aeabi_uldivmod_label2
-  mov     ip, r3
-  mov     lr, r2
-  b       _ll_udiv_ginormous
-  
-_ll_udiv_small
-  cmp     r4, ip, lsl #1
-  mov     r3, #0  ; 0x0
-  subcs   r4, r4, ip, lsl #1
-  addcs   r3, r3, #2      ; 0x2
-  cmp     r4, ip
-  subcs   r4, r4, ip
-  adcs    r3, r3, #0      ; 0x0
-  add     r2, r6, #32     ; 0x20
-  cmp     r2, #32 ; 0x20
-  rsb     ip, ip, #0      ; 0x0
-  bcc     _ll_udiv_small_label1
-  orrs    r0, r4, r5, lsr #30
-  moveq   r4, r5
-  moveq   r5, #0  ; 0x0
-  subeq   r2, r2, #32     ; 0x20
-_ll_udiv_small_label1
-  mov     r1, #0  ; 0x0
-  cmp     r2, #16 ; 0x10
-  bcc     _ll_udiv_small_label2
-  movs    r0, r4, lsr #14
-  moveq   r4, r4, lsl #16
-  addeq   r1, r1, #16     ; 0x10
-_ll_udiv_small_label2
-  sub     lr, r2, r1
-  cmp     lr, #8  ; 0x8
-  bcc     _ll_udiv_small_label3
-  movs    r0, r4, lsr #22
-  moveq   r4, r4, lsl #8
-  addeq   r1, r1, #8      ; 0x8
-_ll_udiv_small_label3
-  rsb     r0, r1, #32     ; 0x20
-  sub     r2, r2, r1
-  orr     r4, r4, r5, lsr r0
-  mov     r5, r5, lsl r1
-  cmp     r2, #1  ; 0x1
-  bcc     _ll_udiv_small_label5
-  sub     r2, r2, #1      ; 0x1
-  and     r0, r2, #7      ; 0x7
-  eor     r0, r0, #7      ; 0x7
-  adds    r0, r0, r0, lsl #1
-  add     pc, pc, r0, lsl #2
-  nop                     ; (mov r0,r0)
-_ll_udiv_small_label4
-  adcs    r5, r5, r5
-  adcs    r4, ip, r4, lsl #1
-  rsbcc   r4, ip, r4
-  adcs    r5, r5, r5
-  adcs    r4, ip, r4, lsl #1
-  rsbcc   r4, ip, r4
-  adcs    r5, r5, r5
-  adcs    r4, ip, r4, lsl #1
-  rsbcc   r4, ip, r4
-  adcs    r5, r5, r5
-  adcs    r4, ip, r4, lsl #1
-  rsbcc   r4, ip, r4
-  adcs    r5, r5, r5
-  adcs    r4, ip, r4, lsl #1
-  rsbcc   r4, ip, r4
-  adcs    r5, r5, r5
-  adcs    r4, ip, r4, lsl #1
-  rsbcc   r4, ip, r4
-  adcs    r5, r5, r5
-  adcs    r4, ip, r4, lsl #1
-  rsbcc   r4, ip, r4
-  adcs    r5, r5, r5
-  adcs    r4, ip, r4, lsl #1
-  sub     r2, r2, #8      ; 0x8
-  tst     r2, r2
-  rsbcc   r4, ip, r4
-  bpl     _ll_udiv_small_label4
-_ll_udiv_small_label5
-  mov     r2, r4, lsr r6
-  bic     r4, r4, r2, lsl r6
-  adcs    r0, r5, r5
-  adc     r1, r4, r4
-  add     r1, r1, r3, lsl r6
-  mov     r3, #0  ; 0x0
-  ldmia   sp!, {r4, r5, r6, pc}
-  
-_ll_udiv_big
-  subs    r0, r5, lr
-  mov     r3, #0  ; 0x0
-  sbcs    r1, r4, ip
-  movcs   r5, r0
-  movcs   r4, r1
-  adcs    r3, r3, #0      ; 0x0
-  subs    r0, r5, lr
-  sbcs    r1, r4, ip
-  movcs   r5, r0
-  movcs   r4, r1
-  adcs    r3, r3, #0      ; 0x0
-  subs    r0, r5, lr
-  sbcs    r1, r4, ip
-  movcs   r5, r0
-  movcs   r4, r1
-  adcs    r3, r3, #0      ; 0x0
-  mov     r1, #0  ; 0x0
-  rsbs    lr, lr, #0      ; 0x0
-  rsc     ip, ip, #0      ; 0x0
-  cmp     r6, #16 ; 0x10
-  bcc     _ll_udiv_big_label1
-  movs    r0, r4, lsr #14
-  moveq   r4, r4, lsl #16
-  addeq   r1, r1, #16     ; 0x10
-_ll_udiv_big_label1
-  sub     r2, r6, r1
-  cmp     r2, #8  ; 0x8
-  bcc     _ll_udiv_big_label2
-  movs    r0, r4, lsr #22
-  moveq   r4, r4, lsl #8
-  addeq   r1, r1, #8      ; 0x8
-_ll_udiv_big_label2
-  rsb     r0, r1, #32     ; 0x20
-  sub     r2, r6, r1
-  orr     r4, r4, r5, lsr r0
-  mov     r5, r5, lsl r1
-  cmp     r2, #1  ; 0x1
-  bcc     _ll_udiv_big_label4
-  sub     r2, r2, #1      ; 0x1
-  and     r0, r2, #3      ; 0x3
-  rsb     r0, r0, #3      ; 0x3
-  adds    r0, r0, r0, lsl #1
-  add     pc, pc, r0, lsl #3
-  nop                     ; (mov r0,r0)
-_ll_udiv_big_label3
-  adcs    r5, r5, r5
-  adcs    r4, r4, r4
-  adcs    r0, lr, r5
-  adcs    r1, ip, r4
-  movcs   r5, r0
-  movcs   r4, r1
-  adcs    r5, r5, r5
-  adcs    r4, r4, r4
-  adcs    r0, lr, r5
-  adcs    r1, ip, r4
-  movcs   r5, r0
-  movcs   r4, r1
-  adcs    r5, r5, r5
-  adcs    r4, r4, r4
-  adcs    r0, lr, r5
-  adcs    r1, ip, r4
-  movcs   r5, r0
-  movcs   r4, r1
-  sub     r2, r2, #4      ; 0x4
-  adcs    r5, r5, r5
-  adcs    r4, r4, r4
-  adcs    r0, lr, r5
-  adcs    r1, ip, r4
-  tst     r2, r2
-  movcs   r5, r0
-  movcs   r4, r1
-  bpl     _ll_udiv_big_label3
-_ll_udiv_big_label4
-  mov     r1, #0  ; 0x0
-  mov     r2, r5, lsr r6
-  bic     r5, r5, r2, lsl r6
-  adcs    r0, r5, r5
-  adc     r1, r1, #0      ; 0x0
-  movs    lr, r3, lsl r6
-  mov     r3, r4, lsr r6
-  bic     r4, r4, r3, lsl r6
-  adc     r1, r1, #0      ; 0x0
-  adds    r0, r0, lr
-  orr     r2, r2, r4, ror r6
-  adc     r1, r1, #0      ; 0x0
-  ldmia   sp!, {r4, r5, r6, pc}
-  
-_ll_udiv_ginormous
-  subs    r2, r5, lr
-  mov     r1, #0  ; 0x0
-  sbcs    r3, r4, ip
-  adc     r0, r1, r1
-  movcc   r2, r5
-  movcc   r3, r4
-  ldmia   sp!, {r4, r5, r6, pc}
-  
-_ll_div0
-  ldmia   sp!, {r4, r5, r6, lr}
-  mov     r0, #0  ; 0x0
-  mov     r1, #0  ; 0x0
-  b       __aeabi_ldiv0
-  
-__aeabi_ldiv0
-  BX        r14
-
-  END
-
+//------------------------------------------------------------------------------ 

+//

+// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+//

+// This program and the accompanying materials

+// are licensed and made available under the terms and conditions of the BSD License

+// which accompanies this distribution.  The full text of the license may be found at

+// http://opensource.org/licenses/bsd-license.php

+//

+// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+//

+//------------------------------------------------------------------------------

+

+

+

+    EXPORT  __aeabi_uldivmod

+

+    AREA  Uldivmod, CODE, READONLY

+

+;        

+;UINT64

+;EFIAPI

+;__aeabi_uldivmod (

+;  IN  UINT64   Dividend  

+;  IN  UINT64   Divisor

+;  )

+;

+__aeabi_uldivmod

+  stmdb   sp!, {r4, r5, r6, lr}

+  mov     r4, r1

+  mov     r5, r0

+  mov     r6, #0  ; 0x0

+  orrs    ip, r3, r2, lsr #31

+  bne     __aeabi_uldivmod_label1

+  tst     r2, r2

+  beq     _ll_div0

+  movs    ip, r2, lsr #15

+  addeq   r6, r6, #16     ; 0x10

+  mov     ip, r2, lsl r6

+  movs    lr, ip, lsr #23

+  moveq   ip, ip, lsl #8

+  addeq   r6, r6, #8      ; 0x8

+  movs    lr, ip, lsr #27

+  moveq   ip, ip, lsl #4

+  addeq   r6, r6, #4      ; 0x4

+  movs    lr, ip, lsr #29

+  moveq   ip, ip, lsl #2

+  addeq   r6, r6, #2      ; 0x2

+  movs    lr, ip, lsr #30

+  moveq   ip, ip, lsl #1

+  addeq   r6, r6, #1      ; 0x1

+  b       _ll_udiv_small

+__aeabi_uldivmod_label1

+  tst     r3, #-2147483648        ; 0x80000000

+  bne     __aeabi_uldivmod_label2

+  movs    ip, r3, lsr #15

+  addeq   r6, r6, #16     ; 0x10

+  mov     ip, r3, lsl r6

+  movs    lr, ip, lsr #23

+  moveq   ip, ip, lsl #8

+  addeq   r6, r6, #8      ; 0x8

+  movs    lr, ip, lsr #27

+  moveq   ip, ip, lsl #4

+  addeq   r6, r6, #4      ; 0x4

+  movs    lr, ip, lsr #29

+  moveq   ip, ip, lsl #2

+  addeq   r6, r6, #2      ; 0x2

+  movs    lr, ip, lsr #30

+  addeq   r6, r6, #1      ; 0x1

+  rsb     r3, r6, #32     ; 0x20

+  moveq   ip, ip, lsl #1

+  orr     ip, ip, r2, lsr r3

+  mov     lr, r2, lsl r6

+  b       _ll_udiv_big

+__aeabi_uldivmod_label2

+  mov     ip, r3

+  mov     lr, r2

+  b       _ll_udiv_ginormous

+  

+_ll_udiv_small

+  cmp     r4, ip, lsl #1

+  mov     r3, #0  ; 0x0

+  subcs   r4, r4, ip, lsl #1

+  addcs   r3, r3, #2      ; 0x2

+  cmp     r4, ip

+  subcs   r4, r4, ip

+  adcs    r3, r3, #0      ; 0x0

+  add     r2, r6, #32     ; 0x20

+  cmp     r2, #32 ; 0x20

+  rsb     ip, ip, #0      ; 0x0

+  bcc     _ll_udiv_small_label1

+  orrs    r0, r4, r5, lsr #30

+  moveq   r4, r5

+  moveq   r5, #0  ; 0x0

+  subeq   r2, r2, #32     ; 0x20

+_ll_udiv_small_label1

+  mov     r1, #0  ; 0x0

+  cmp     r2, #16 ; 0x10

+  bcc     _ll_udiv_small_label2

+  movs    r0, r4, lsr #14

+  moveq   r4, r4, lsl #16

+  addeq   r1, r1, #16     ; 0x10

+_ll_udiv_small_label2

+  sub     lr, r2, r1

+  cmp     lr, #8  ; 0x8

+  bcc     _ll_udiv_small_label3

+  movs    r0, r4, lsr #22

+  moveq   r4, r4, lsl #8

+  addeq   r1, r1, #8      ; 0x8

+_ll_udiv_small_label3

+  rsb     r0, r1, #32     ; 0x20

+  sub     r2, r2, r1

+  orr     r4, r4, r5, lsr r0

+  mov     r5, r5, lsl r1

+  cmp     r2, #1  ; 0x1

+  bcc     _ll_udiv_small_label5

+  sub     r2, r2, #1      ; 0x1

+  and     r0, r2, #7      ; 0x7

+  eor     r0, r0, #7      ; 0x7

+  adds    r0, r0, r0, lsl #1

+  add     pc, pc, r0, lsl #2

+  nop                     ; (mov r0,r0)

+_ll_udiv_small_label4

+  adcs    r5, r5, r5

+  adcs    r4, ip, r4, lsl #1

+  rsbcc   r4, ip, r4

+  adcs    r5, r5, r5

+  adcs    r4, ip, r4, lsl #1

+  rsbcc   r4, ip, r4

+  adcs    r5, r5, r5

+  adcs    r4, ip, r4, lsl #1

+  rsbcc   r4, ip, r4

+  adcs    r5, r5, r5

+  adcs    r4, ip, r4, lsl #1

+  rsbcc   r4, ip, r4

+  adcs    r5, r5, r5

+  adcs    r4, ip, r4, lsl #1

+  rsbcc   r4, ip, r4

+  adcs    r5, r5, r5

+  adcs    r4, ip, r4, lsl #1

+  rsbcc   r4, ip, r4

+  adcs    r5, r5, r5

+  adcs    r4, ip, r4, lsl #1

+  rsbcc   r4, ip, r4

+  adcs    r5, r5, r5

+  adcs    r4, ip, r4, lsl #1

+  sub     r2, r2, #8      ; 0x8

+  tst     r2, r2

+  rsbcc   r4, ip, r4

+  bpl     _ll_udiv_small_label4

+_ll_udiv_small_label5

+  mov     r2, r4, lsr r6

+  bic     r4, r4, r2, lsl r6

+  adcs    r0, r5, r5

+  adc     r1, r4, r4

+  add     r1, r1, r3, lsl r6

+  mov     r3, #0  ; 0x0

+  ldmia   sp!, {r4, r5, r6, pc}

+  

+_ll_udiv_big

+  subs    r0, r5, lr

+  mov     r3, #0  ; 0x0

+  sbcs    r1, r4, ip

+  movcs   r5, r0

+  movcs   r4, r1

+  adcs    r3, r3, #0      ; 0x0

+  subs    r0, r5, lr

+  sbcs    r1, r4, ip

+  movcs   r5, r0

+  movcs   r4, r1

+  adcs    r3, r3, #0      ; 0x0

+  subs    r0, r5, lr

+  sbcs    r1, r4, ip

+  movcs   r5, r0

+  movcs   r4, r1

+  adcs    r3, r3, #0      ; 0x0

+  mov     r1, #0  ; 0x0

+  rsbs    lr, lr, #0      ; 0x0

+  rsc     ip, ip, #0      ; 0x0

+  cmp     r6, #16 ; 0x10

+  bcc     _ll_udiv_big_label1

+  movs    r0, r4, lsr #14

+  moveq   r4, r4, lsl #16

+  addeq   r1, r1, #16     ; 0x10

+_ll_udiv_big_label1

+  sub     r2, r6, r1

+  cmp     r2, #8  ; 0x8

+  bcc     _ll_udiv_big_label2

+  movs    r0, r4, lsr #22

+  moveq   r4, r4, lsl #8

+  addeq   r1, r1, #8      ; 0x8

+_ll_udiv_big_label2

+  rsb     r0, r1, #32     ; 0x20

+  sub     r2, r6, r1

+  orr     r4, r4, r5, lsr r0

+  mov     r5, r5, lsl r1

+  cmp     r2, #1  ; 0x1

+  bcc     _ll_udiv_big_label4

+  sub     r2, r2, #1      ; 0x1

+  and     r0, r2, #3      ; 0x3

+  rsb     r0, r0, #3      ; 0x3

+  adds    r0, r0, r0, lsl #1

+  add     pc, pc, r0, lsl #3

+  nop                     ; (mov r0,r0)

+_ll_udiv_big_label3

+  adcs    r5, r5, r5

+  adcs    r4, r4, r4

+  adcs    r0, lr, r5

+  adcs    r1, ip, r4

+  movcs   r5, r0

+  movcs   r4, r1

+  adcs    r5, r5, r5

+  adcs    r4, r4, r4

+  adcs    r0, lr, r5

+  adcs    r1, ip, r4

+  movcs   r5, r0

+  movcs   r4, r1

+  adcs    r5, r5, r5

+  adcs    r4, r4, r4

+  adcs    r0, lr, r5

+  adcs    r1, ip, r4

+  movcs   r5, r0

+  movcs   r4, r1

+  sub     r2, r2, #4      ; 0x4

+  adcs    r5, r5, r5

+  adcs    r4, r4, r4

+  adcs    r0, lr, r5

+  adcs    r1, ip, r4

+  tst     r2, r2

+  movcs   r5, r0

+  movcs   r4, r1

+  bpl     _ll_udiv_big_label3

+_ll_udiv_big_label4

+  mov     r1, #0  ; 0x0

+  mov     r2, r5, lsr r6

+  bic     r5, r5, r2, lsl r6

+  adcs    r0, r5, r5

+  adc     r1, r1, #0      ; 0x0

+  movs    lr, r3, lsl r6

+  mov     r3, r4, lsr r6

+  bic     r4, r4, r3, lsl r6

+  adc     r1, r1, #0      ; 0x0

+  adds    r0, r0, lr

+  orr     r2, r2, r4, ror r6

+  adc     r1, r1, #0      ; 0x0

+  ldmia   sp!, {r4, r5, r6, pc}

+  

+_ll_udiv_ginormous

+  subs    r2, r5, lr

+  mov     r1, #0  ; 0x0

+  sbcs    r3, r4, ip

+  adc     r0, r1, r1

+  movcc   r2, r5

+  movcc   r3, r4

+  ldmia   sp!, {r4, r5, r6, pc}

+  

+_ll_div0

+  ldmia   sp!, {r4, r5, r6, lr}

+  mov     r0, #0  ; 0x0

+  mov     r1, #0  ; 0x0

+  b       __aeabi_ldiv0

+  

+__aeabi_ldiv0

+  BX        r14

+

+  END

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/uldivmod.c b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/uldivmod.c
index 48767433..feac6019 100755
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/uldivmod.c
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/uldivmod.c
@@ -1,43 +1,43 @@
-/** @file
-
-  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include "Llvm_int_lib.h"
-#include <Library/BaseLib.h>
-
-
-UINT32 __udivsi3(UINT32 n, UINT32 d);
-UINT32 __umodsi3(UINT32 a, UINT32 b);
-
-
-UINT64 
-__aeabi_uidivmod(unsigned numerator, unsigned denominator)
-{
-  UINT64  Return;
-
-  Return = __udivsi3 (numerator, denominator);
-  Return |= LShiftU64 (__umodsi3 (numerator, denominator), 32);
-
-  return Return;
-}
-
-unsigned
-__aeabi_uidiv (unsigned n, unsigned d) 
-{
-  return __udivsi3 (n, d);
-}
-
-
-
-
-
+/** @file

+

+  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include "Llvm_int_lib.h"

+#include <Library/BaseLib.h>

+

+

+UINT32 __udivsi3(UINT32 n, UINT32 d);

+UINT32 __umodsi3(UINT32 a, UINT32 b);

+

+

+UINT64 

+__aeabi_uidivmod(unsigned numerator, unsigned denominator)

+{

+  UINT64  Return;

+

+  Return = __udivsi3 (numerator, denominator);

+  Return |= LShiftU64 (__umodsi3 (numerator, denominator), 32);

+

+  return Return;

+}

+

+unsigned

+__aeabi_uidiv (unsigned n, unsigned d) 

+{

+  return __udivsi3 (n, d);

+}

+

+

+

+

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/umoddi3.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/umoddi3.S
index 75bb2408..6e23057c 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/umoddi3.S
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/umoddi3.S
@@ -1,29 +1,29 @@
-#------------------------------------------------------------------------------ 
-#
-# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-#
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#------------------------------------------------------------------------------
-
-  .text
-  .align 2
-  GCC_ASM_EXPORT(__umoddi3)
-  
-ASM_PFX(__umoddi3):
-  stmfd  sp!, {r7, lr}
-  add  r7, sp, #0
-  sub  sp, sp, #16
-  add  ip, sp, #8
-  str  ip, [sp, #0]
-  bl  ASM_PFX(__udivmoddi4)
-  ldrd  r0, [sp, #8]
-  sub  sp, r7, #0
-  ldmfd  sp!, {r7, pc}
-
+#------------------------------------------------------------------------------ 

+#

+# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+  .text

+  .align 2

+  GCC_ASM_EXPORT(__umoddi3)

+  

+ASM_PFX(__umoddi3):

+  stmfd  sp!, {r7, lr}

+  add  r7, sp, #0

+  sub  sp, sp, #16

+  add  ip, sp, #8

+  str  ip, [sp, #0]

+  bl  ASM_PFX(__udivmoddi4)

+  ldrd  r0, [sp, #8]

+  sub  sp, r7, #0

+  ldmfd  sp!, {r7, pc}

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/umoddi3.c b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/umoddi3.c
index 125af09b..ebd76975 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/umoddi3.c
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/umoddi3.c
@@ -1,72 +1,72 @@
-/** @file
-  Compiler intrinsic for 64-bit unsigned mod, ported from LLVM code.
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-/**
-  University of Illinois/NCSA
-  Open Source License
-  
-  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.
-  All rights reserved.
-  
-  Developed by:
-  
-      LLVM Team
-  
-      University of Illinois at Urbana-Champaign
-  
-      http://llvm.org
-  
-  Permission is hereby granted, free of charge, to any person obtaining a copy of
-  this software and associated documentation files (the "Software"), to deal with
-  the Software without restriction, including without limitation the rights to
-  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-  of the Software, and to permit persons to whom the Software is furnished to do
-  so, subject to the following conditions:
-  
-      * Redistributions of source code must retain the above copyright notice,
-        this list of conditions and the following disclaimers.
-  
-      * Redistributions in binary form must reproduce the above copyright notice,
-        this list of conditions and the following disclaimers in the
-        documentation and/or other materials provided with the distribution.
-  
-      * Neither the names of the LLVM Team, University of Illinois at
-        Urbana-Champaign, nor the names of its contributors may be used to
-        endorse or promote products derived from this Software without specific
-        prior written permission.
-  
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
-  SOFTWARE.
-**/
-
-
-#include "Llvm_int_lib.h"
-
-UINT64 __udivmoddi4(UINT64 a, UINT64 b, UINT64* rem);
-
-// Returns: a % b
-
-UINT64
-__umoddi3(UINT64 a, UINT64 b)
-{
-    UINT64 r;
-    __udivmoddi4(a, b, &r);
-    return r;
-}
-
+/** @file

+  Compiler intrinsic for 64-bit unsigned mod, ported from LLVM code.

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+/**

+  University of Illinois/NCSA

+  Open Source License

+  

+  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.

+  All rights reserved.

+  

+  Developed by:

+  

+      LLVM Team

+  

+      University of Illinois at Urbana-Champaign

+  

+      http://llvm.org

+  

+  Permission is hereby granted, free of charge, to any person obtaining a copy of

+  this software and associated documentation files (the "Software"), to deal with

+  the Software without restriction, including without limitation the rights to

+  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies

+  of the Software, and to permit persons to whom the Software is furnished to do

+  so, subject to the following conditions:

+  

+      * Redistributions of source code must retain the above copyright notice,

+        this list of conditions and the following disclaimers.

+  

+      * Redistributions in binary form must reproduce the above copyright notice,

+        this list of conditions and the following disclaimers in the

+        documentation and/or other materials provided with the distribution.

+  

+      * Neither the names of the LLVM Team, University of Illinois at

+        Urbana-Champaign, nor the names of its contributors may be used to

+        endorse or promote products derived from this Software without specific

+        prior written permission.

+  

+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE

+  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE

+  SOFTWARE.

+**/

+

+

+#include "Llvm_int_lib.h"

+

+UINT64 __udivmoddi4(UINT64 a, UINT64 b, UINT64* rem);

+

+// Returns: a % b

+

+UINT64

+__umoddi3(UINT64 a, UINT64 b)

+{

+    UINT64 r;

+    __udivmoddi4(a, b, &r);

+    return r;

+}

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/umodsi3.S b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/umodsi3.S
index 9d0f17e6..bd32fd12 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/umodsi3.S
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/umodsi3.S
@@ -1,28 +1,28 @@
-#------------------------------------------------------------------------------ 
-#
-# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-#
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#------------------------------------------------------------------------------
-
-  .text
-  .align 2
-  GCC_ASM_EXPORT(__umodsi3)
-  
-ASM_PFX(__umodsi3):
-  stmfd  sp!, {r4, r5, r7, lr}
-  add  r7, sp, #8
-  mov  r5, r0
-  mov  r4, r1
-  bl   ASM_PFX(__udivsi3)
-  mul  r0, r4, r0
-  rsb  r0, r0, r5
-  ldmfd  sp!, {r4, r5, r7, pc}
-
+#------------------------------------------------------------------------------ 

+#

+# Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+  .text

+  .align 2

+  GCC_ASM_EXPORT(__umodsi3)

+  

+ASM_PFX(__umodsi3):

+  stmfd  sp!, {r4, r5, r7, lr}

+  add  r7, sp, #8

+  mov  r5, r0

+  mov  r4, r1

+  bl   ASM_PFX(__udivsi3)

+  mul  r0, r4, r0

+  rsb  r0, r0, r5

+  ldmfd  sp!, {r4, r5, r7, pc}

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/umodsi3.c b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/umodsi3.c
index 5e302d61..e3aa4da8 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/umodsi3.c
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/umodsi3.c
@@ -1,68 +1,68 @@
-/** @file
-  Compiler intrinsic for 32-bit unsigned mod, ported from LLVM code.
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-/**
-  University of Illinois/NCSA
-  Open Source License
-  
-  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.
-  All rights reserved.
-  
-  Developed by:
-  
-      LLVM Team
-  
-      University of Illinois at Urbana-Champaign
-  
-      http://llvm.org
-  
-  Permission is hereby granted, free of charge, to any person obtaining a copy of
-  this software and associated documentation files (the "Software"), to deal with
-  the Software without restriction, including without limitation the rights to
-  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-  of the Software, and to permit persons to whom the Software is furnished to do
-  so, subject to the following conditions:
-  
-      * Redistributions of source code must retain the above copyright notice,
-        this list of conditions and the following disclaimers.
-  
-      * Redistributions in binary form must reproduce the above copyright notice,
-        this list of conditions and the following disclaimers in the
-        documentation and/or other materials provided with the distribution.
-  
-      * Neither the names of the LLVM Team, University of Illinois at
-        Urbana-Champaign, nor the names of its contributors may be used to
-        endorse or promote products derived from this Software without specific
-        prior written permission.
-  
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
-  SOFTWARE.
-**/
-
-
-#include "Llvm_int_lib.h"
-
-
-// Returns: a % b
-
-UINT32
-__umodsi3(UINT32 a, UINT32 b)
-{
-    return a - (a / b) * b;
-}
+/** @file

+  Compiler intrinsic for 32-bit unsigned mod, ported from LLVM code.

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+/**

+  University of Illinois/NCSA

+  Open Source License

+  

+  Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign.

+  All rights reserved.

+  

+  Developed by:

+  

+      LLVM Team

+  

+      University of Illinois at Urbana-Champaign

+  

+      http://llvm.org

+  

+  Permission is hereby granted, free of charge, to any person obtaining a copy of

+  this software and associated documentation files (the "Software"), to deal with

+  the Software without restriction, including without limitation the rights to

+  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies

+  of the Software, and to permit persons to whom the Software is furnished to do

+  so, subject to the following conditions:

+  

+      * Redistributions of source code must retain the above copyright notice,

+        this list of conditions and the following disclaimers.

+  

+      * Redistributions in binary form must reproduce the above copyright notice,

+        this list of conditions and the following disclaimers in the

+        documentation and/or other materials provided with the distribution.

+  

+      * Neither the names of the LLVM Team, University of Illinois at

+        Urbana-Champaign, nor the names of its contributors may be used to

+        endorse or promote products derived from this Software without specific

+        prior written permission.

+  

+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE

+  CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE

+  SOFTWARE.

+**/

+

+

+#include "Llvm_int_lib.h"

+

+

+// Returns: a % b

+

+UINT32

+__umodsi3(UINT32 a, UINT32 b)

+{

+    return a - (a / b) * b;

+}

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/uwrite.asm b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/uwrite.asm
index a456ea25..0b79e341 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/Arm/uwrite.asm
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/Arm/uwrite.asm
@@ -1,68 +1,68 @@
-//------------------------------------------------------------------------------ 
-//
-// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-//
-// This program and the accompanying materials
-// are licensed and made available under the terms and conditions of the BSD License
-// which accompanies this distribution.  The full text of the license may be found at
-// http://opensource.org/licenses/bsd-license.php
-//
-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-//
-//------------------------------------------------------------------------------
-
-
-    EXPORT  __aeabi_uwrite4
-    EXPORT  __aeabi_uwrite8
-
-    AREA  Uwrite4, CODE, READONLY
-
-;
-;UINT32
-;EFIAPI
-;__aeabi_uwrite4 (
-;  IN UINT32 Data,
-;  IN VOID   *Pointer
-;  );
-;
-;
-__aeabi_uwrite4
-    mov     r2, r0, lsr #8
-    strb    r0, [r1]
-    strb    r2, [r1, #1]
-    mov     r2, r0, lsr #16
-    strb    r2, [r1, #2]
-    mov     r2, r0, lsr #24
-    strb    r2, [r1, #3]
-    bx      lr
-
-;
-;UINT64
-;EFIAPI
-;__aeabi_uwrite8 (
-;  IN UINT64 Data,    //r0-r1
-;  IN VOID   *Pointer //r2
-;  );
-;
-;
-__aeabi_uwrite8
-    mov     r3, r0, lsr #8
-    strb    r0, [r2]
-    strb    r3, [r2, #1]
-    mov     r3, r0, lsr #16
-    strb    r3, [r2, #2]
-    mov     r3, r0, lsr #24
-    strb    r3, [r2, #3]
-
-    mov     r3, r1, lsr #8
-    strb    r1, [r2, #4]
-    strb    r3, [r2, #5]
-    mov     r3, r1, lsr #16
-    strb    r3, [r2, #6]
-    mov     r3, r1, lsr #24
-    strb    r3, [r2, #7]
-    bx      lr
-
-    END
-
+//------------------------------------------------------------------------------ 

+//

+// Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+//

+// This program and the accompanying materials

+// are licensed and made available under the terms and conditions of the BSD License

+// which accompanies this distribution.  The full text of the license may be found at

+// http://opensource.org/licenses/bsd-license.php

+//

+// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+//

+//------------------------------------------------------------------------------

+

+

+    EXPORT  __aeabi_uwrite4

+    EXPORT  __aeabi_uwrite8

+

+    AREA  Uwrite4, CODE, READONLY

+

+;

+;UINT32

+;EFIAPI

+;__aeabi_uwrite4 (

+;  IN UINT32 Data,

+;  IN VOID   *Pointer

+;  );

+;

+;

+__aeabi_uwrite4

+    mov     r2, r0, lsr #8

+    strb    r0, [r1]

+    strb    r2, [r1, #1]

+    mov     r2, r0, lsr #16

+    strb    r2, [r1, #2]

+    mov     r2, r0, lsr #24

+    strb    r2, [r1, #3]

+    bx      lr

+

+;

+;UINT64

+;EFIAPI

+;__aeabi_uwrite8 (

+;  IN UINT64 Data,    //r0-r1

+;  IN VOID   *Pointer //r2

+;  );

+;

+;

+__aeabi_uwrite8

+    mov     r3, r0, lsr #8

+    strb    r0, [r2]

+    strb    r3, [r2, #1]

+    mov     r3, r0, lsr #16

+    strb    r3, [r2, #2]

+    mov     r3, r0, lsr #24

+    strb    r3, [r2, #3]

+

+    mov     r3, r1, lsr #8

+    strb    r1, [r2, #4]

+    strb    r3, [r2, #5]

+    mov     r3, r1, lsr #16

+    strb    r3, [r2, #6]

+    mov     r3, r1, lsr #24

+    strb    r3, [r2, #7]

+    bx      lr

+

+    END

+

diff --git a/ArmPkg/Library/CompilerIntrinsicsLib/CompilerIntrinsicsLib.inf b/ArmPkg/Library/CompilerIntrinsicsLib/CompilerIntrinsicsLib.inf
index 9b116f89..53b1b15c 100644
--- a/ArmPkg/Library/CompilerIntrinsicsLib/CompilerIntrinsicsLib.inf
+++ b/ArmPkg/Library/CompilerIntrinsicsLib/CompilerIntrinsicsLib.inf
@@ -1,102 +1,106 @@
-#/** @file
-#  Base Library implementation.
-#
-#  Copyright (c) 2009, Apple Inc. All rights reserved.<BR>
-#  Copyright (c) 2011, ARM Limited. All rights reserved.
-#
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution. The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = CompilerIntrinsicsLib
-  FILE_GUID                      = 855274FA-3575-4C20-9709-C031DC5589FA
-  MODULE_TYPE                    = BASE
-  VERSION_STRING                 = 1.0
-  LIBRARY_CLASS                  = CompilerIntrinsicsLib 
-
-
-[Sources.common]
-
-
-[Sources.ARM]
-  Arm/mullu.asm        | RVCT
-  Arm/switch.asm       | RVCT
-  Arm/llsr.asm         | RVCT
-  Arm/memcpy.asm       | RVCT
-  Arm/memcpy4.asm      | RVCT
-  Arm/memset.asm       | RVCT
-  Arm/memmove.asm      | RVCT
-  Arm/uread.asm        | RVCT
-  Arm/uwrite.asm       | RVCT
-  Arm/lasr.asm         | RVCT
-  Arm/llsl.asm         | RVCT
-  Arm/div.asm          | RVCT
-  Arm/uldiv.asm        | RVCT
-  Arm/ldivmod.asm      | RVCT
-  
-
-#
-# Move .c to .s to work around LLVM issues
-#
-#  Arm/ashrdi3.c    | GCC
-#  Arm/ashldi3.c    | GCC
-#  Arm/divdi3.c     | GCC
-#  Arm/divsi3.c     | GCC
-#  Arm/lshrdi3.c    | GCC
-  Arm/ashrdi3.S    | GCC
-  Arm/ashldi3.S    | GCC
-  Arm/div.S        | GCC
-  Arm/divdi3.S     | GCC
-  Arm/divsi3.S     | GCC
-  Arm/lshrdi3.S    | GCC
-
-  Arm/memcpy.S     | GCC
-  Arm/memset.S     | GCC
-  
-#  Arm/modsi3.c     | GCC
-#  Arm/moddi3.c     | GCC
-#  Arm/muldi3.c     | GCC  
-  Arm/modsi3.S     | GCC
-  Arm/moddi3.S     | GCC
-  Arm/muldi3.S     | GCC
-  Arm/mullu.S      | GCC  
-
-#  Arm/udivsi3.c    | GCC
-#  Arm/umodsi3.c    | GCC
-#  Arm/udivdi3.c    | GCC
-#  Arm/umoddi3.c    | GCC
-#  Arm/udivmoddi4.c | GCC
-  Arm/udivsi3.S    | GCC
-  Arm/umodsi3.S    | GCC
-  Arm/udivdi3.S    | GCC
-  Arm/umoddi3.S    | GCC
-  Arm/udivmoddi4.S | GCC
-
-#  Arm/clzsi2.c     | GCC
-#  Arm/ctzsi2.c     | GCC
-#  Arm/ucmpdi2.c    | GCC
-  Arm/clzsi2.S     | GCC
-  Arm/ctzsi2.S     | GCC
-  Arm/ucmpdi2.S    | GCC
-  Arm/switch8.S    | GCC
-  Arm/switchu8.S   | GCC
-  Arm/switch16.S   | GCC
-  Arm/switch32.S   | GCC
-
-  Arm/sourcery.S   | GCC
-  Arm/uldiv.S      | GCC
-  Arm/ldivmod.S    | GCC
-
-[Packages]
-  MdePkg/MdePkg.dec
-
-[LibraryClasses]
-
+#/** @file

+#  Base Library implementation.

+#

+#  Copyright (c) 2009, Apple Inc. All rights reserved.<BR>

+#  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

+#

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution. The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = CompilerIntrinsicsLib

+  FILE_GUID                      = 855274FA-3575-4C20-9709-C031DC5589FA

+  MODULE_TYPE                    = BASE

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = CompilerIntrinsicsLib 

+

+

+[Sources.common]

+

+

+[Sources.ARM]

+  Arm/mullu.asm        | RVCT

+  Arm/switch.asm       | RVCT

+  Arm/llsr.asm         | RVCT

+  Arm/memcpy.asm       | RVCT

+  Arm/memcpy4.asm      | RVCT

+  Arm/memset.asm       | RVCT

+  Arm/memmove.asm      | RVCT

+  Arm/uread.asm        | RVCT

+  Arm/uwrite.asm       | RVCT

+  Arm/lasr.asm         | RVCT

+  Arm/llsl.asm         | RVCT

+  Arm/div.asm          | RVCT

+  Arm/uldiv.asm        | RVCT

+  Arm/ldivmod.asm      | RVCT

+  

+

+#

+# Move .c to .s to work around LLVM issues

+#

+#  Arm/ashrdi3.c    | GCC

+#  Arm/ashldi3.c    | GCC

+#  Arm/divdi3.c     | GCC

+#  Arm/divsi3.c     | GCC

+#  Arm/lshrdi3.c    | GCC

+  Arm/ashrdi3.S    | GCC

+  Arm/ashldi3.S    | GCC

+  Arm/div.S        | GCC

+  Arm/divdi3.S     | GCC

+  Arm/divsi3.S     | GCC

+  Arm/lshrdi3.S    | GCC

+

+  Arm/memcpy.S     | GCC

+  Arm/memset.S     | GCC

+  

+#  Arm/modsi3.c     | GCC

+#  Arm/moddi3.c     | GCC

+#  Arm/muldi3.c     | GCC  

+  Arm/modsi3.S     | GCC

+  Arm/moddi3.S     | GCC

+  Arm/muldi3.S     | GCC

+  Arm/mullu.S      | GCC  

+

+#  Arm/udivsi3.c    | GCC

+#  Arm/umodsi3.c    | GCC

+#  Arm/udivdi3.c    | GCC

+#  Arm/umoddi3.c    | GCC

+#  Arm/udivmoddi4.c | GCC

+  Arm/udivsi3.S    | GCC

+  Arm/umodsi3.S    | GCC

+  Arm/udivdi3.S    | GCC

+  Arm/umoddi3.S    | GCC

+  Arm/udivmoddi4.S | GCC

+

+#  Arm/clzsi2.c     | GCC

+#  Arm/ctzsi2.c     | GCC

+#  Arm/ucmpdi2.c    | GCC

+  Arm/clzsi2.S     | GCC

+  Arm/ctzsi2.S     | GCC

+  Arm/ucmpdi2.S    | GCC

+  Arm/switch8.S    | GCC

+  Arm/switchu8.S   | GCC

+  Arm/switch16.S   | GCC

+  Arm/switch32.S   | GCC

+

+  Arm/sourcery.S   | GCC

+  Arm/uldiv.S      | GCC

+  Arm/ldivmod.S    | GCC

+

+  Arm/llsr.S       | GCC

+  Arm/llsl.S       | GCC

+

+

+[Packages]

+  MdePkg/MdePkg.dec

+

+[LibraryClasses]

+

diff --git a/ArmPkg/Library/DebugAgentSymbolsBaseLib/DebugAgentException.S b/ArmPkg/Library/DebugAgentSymbolsBaseLib/Arm/DebugAgentException.S
index 3c173867..d92acfea 100644
--- a/ArmPkg/Library/DebugAgentSymbolsBaseLib/DebugAgentException.S
+++ b/ArmPkg/Library/DebugAgentSymbolsBaseLib/Arm/DebugAgentException.S
@@ -1,276 +1,276 @@
-#------------------------------------------------------------------------------
-#
-# Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-# Copyright (c) 2011 - 2012, ARM Ltd. All rights reserved.<BR>
-#
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#------------------------------------------------------------------------------
-
-#include <Library/PcdLib.h>
-
-/*
-
-This is the stack constructed by the exception handler (low address to high address)
-                # R0 - IFAR is EFI_SYSTEM_CONTEXT for ARM
-  Reg   Offset
-  ===   ======
-  R0    0x00    # stmfd     SP!,{R0-R12}
-  R1    0x04
-  R2    0x08
-  R3    0x0c
-  R4    0x10
-  R5    0x14
-  R6    0x18
-  R7    0x1c
-  R8    0x20
-  R9    0x24
-  R10   0x28
-  R11   0x2c
-  R12   0x30
-  SP    0x34    # reserved via adding 0x20 (32) to the SP
-  LR    0x38
-  PC    0x3c
-  CPSR  0x40
-  DFSR  0x44
-  DFAR  0x48
-  IFSR  0x4c
-  IFAR  0x50
-
-  LR    0x54    # SVC Link register (we need to restore it)
-
-  LR    0x58    # pushed by srsfd
-  CPSR  0x5c
-
- */
-
-GCC_ASM_EXPORT(DebugAgentVectorTable)
-GCC_ASM_IMPORT(DefaultExceptionHandler)
-
-.text
-#if !defined(__APPLE__)
-.fpu neon    @ makes vpush/vpop assemble
-#endif
-.align 5
-
-
-//
-// This code gets copied to the ARM vector table
-// ExceptionHandlersStart - ExceptionHandlersEnd gets copied
-//
-ASM_PFX(DebugAgentVectorTable):
-  b ASM_PFX(ResetEntry)
-  b ASM_PFX(UndefinedInstructionEntry)
-  b ASM_PFX(SoftwareInterruptEntry)
-  b ASM_PFX(PrefetchAbortEntry)
-  b ASM_PFX(DataAbortEntry)
-  b ASM_PFX(ReservedExceptionEntry)
-  b ASM_PFX(IrqEntry)
-  b ASM_PFX(FiqEntry)
-
-ASM_PFX(ResetEntry):
-  srsdb     #0x13!                    @ Store return state on SVC stack
-                                      @ We are already in SVC mode
-
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-  
-  mov       R0,#0                     @ ExceptionType
-  ldr       R1,ASM_PFX(CommonExceptionEntry)
-  bx        R1
-
-ASM_PFX(UndefinedInstructionEntry):
-  sub       LR, LR, #4                @ Only -2 for Thumb, adjust in CommonExceptionEntry
-  srsdb     #0x13!                    @ Store return state on SVC stack
-  cps       #0x13                     @ Switch to SVC for common stack
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-
-  mov       R0,#1                     @ ExceptionType
-  ldr       R1,ASM_PFX(CommonExceptionEntry)
-  bx        R1
-
-ASM_PFX(SoftwareInterruptEntry):
-  sub       LR, LR, #4                @ Only -2 for Thumb, adjust in CommonExceptionEntry
-  srsdb     #0x13!                    @ Store return state on SVC stack
-                                      @ We are already in SVC mode
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-
-  mov       R0,#2                     @ ExceptionType
-  ldr       R1,ASM_PFX(CommonExceptionEntry)
-  bx        R1
-
-ASM_PFX(PrefetchAbortEntry):
-  sub       LR,LR,#4
-  srsdb     #0x13!                    @ Store return state on SVC stack
-  cps       #0x13                     @ Switch to SVC for common stack
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-
-  mov       R0,#3                     @ ExceptionType
-  ldr       R1,ASM_PFX(CommonExceptionEntry)
-  bx        R1
-
-ASM_PFX(DataAbortEntry):
-  sub       LR,LR,#8
-  srsdb     #0x13!                    @ Store return state on SVC stack
-  cps       #0x13                     @ Switch to SVC for common stack
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-
-  mov       R0,#4
-  ldr       R1,ASM_PFX(CommonExceptionEntry)
-  bx        R1
-
-ASM_PFX(ReservedExceptionEntry):
-  srsdb     #0x13!                    @ Store return state on SVC stack
-  cps       #0x13                     @ Switch to SVC for common stack
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-
-  mov       R0,#5
-  ldr       R1,ASM_PFX(CommonExceptionEntry)
-  bx        R1
-
-ASM_PFX(IrqEntry):
-  sub       LR,LR,#4
-  srsdb     #0x13!                    @ Store return state on SVC stack
-  cps       #0x13                     @ Switch to SVC for common stack
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-
-  mov       R0,#6                     @ ExceptionType
-  ldr       R1,ASM_PFX(CommonExceptionEntry)
-  bx        R1
-
-ASM_PFX(FiqEntry):
-  sub       LR,LR,#4
-  srsdb     #0x13!                    @ Store return state on SVC stack
-  cps       #0x13                     @ Switch to SVC for common stack
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-                                      @ Since we have already switch to SVC R8_fiq - R12_fiq
-                                      @ never get used or saved
-  mov       R0,#7                     @ ExceptionType
-  ldr       R1,ASM_PFX(CommonExceptionEntry)
-  bx        R1
-
-//
-// This gets patched by the C code that patches in the vector table
-//
-ASM_PFX(CommonExceptionEntry):
-  .word       ASM_PFX(AsmCommonExceptionEntry)
-
-ASM_PFX(ExceptionHandlersEnd):
-
-//
-// This code runs from CpuDxe driver loaded address. It is patched into
-// CommonExceptionEntry.
-//
-ASM_PFX(AsmCommonExceptionEntry):
-  mrc       p15, 0, R1, c6, c0, 2   @ Read IFAR
-  str       R1, [SP, #0x50]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.IFAR
-
-  mrc       p15, 0, R1, c5, c0, 1   @ Read IFSR
-  str       R1, [SP, #0x4c]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.IFSR
-
-  mrc       p15, 0, R1, c6, c0, 0   @ Read DFAR
-  str       R1, [SP, #0x48]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.DFAR
-
-  mrc       p15, 0, R1, c5, c0, 0   @ Read DFSR
-  str       R1, [SP, #0x44]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.DFSR
-
-  ldr       R1, [SP, #0x5c]         @ srsdb saved pre-exception CPSR on the stack
-  str       R1, [SP, #0x40]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.CPSR
-
-  add       R2, SP, #0x38           @ Make R2 point to EFI_SYSTEM_CONTEXT_ARM.LR
-  and       R3, R1, #0x1f           @ Check CPSR to see if User or System Mode
-  cmp       R3, #0x1f               @ if ((CPSR == 0x10) || (CPSR == 0x1df))
-  cmpne     R3, #0x10               @
-  stmeqed   R2, {lr}^               @   save unbanked lr
-                                    @ else
-  stmneed   R2, {lr}                @   save SVC lr
-
-
-  ldr       R5, [SP, #0x58]         @ PC is the LR pushed by srsfd
-                                    @ Check to see if we have to adjust for Thumb entry
-  sub       r4, r0, #1              @ if (ExceptionType == 1 || ExceptionType ==2)) {
-  cmp       r4, #1                  @   // UND & SVC have differnt LR adjust for Thumb
-  bhi       NoAdjustNeeded
-
-  tst       r1, #0x20               @   if ((CPSR & T)) == T) {  // Thumb Mode on entry
-  addne     R5, R5, #2              @     PC += 2@
-  str       R5,[SP,#0x58]           @ Update LR value pused by srsfd
-
-NoAdjustNeeded:
-
-  str       R5, [SP, #0x3c]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.PC
-
-  sub       R1, SP, #0x60           @ We pused 0x60 bytes on the stack
-  str       R1, [SP, #0x34]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.SP
-
-                                    @ R0 is ExceptionType
-  mov       R1,SP                   @ R1 is SystemContext
-
-#if (FixedPcdGet32(PcdVFPEnabled))
-  vpush     {d0-d15}                @ save vstm registers in case they are used in optimizations
-#endif
-
-/*
-VOID
-EFIAPI
-DefaultExceptionHandler (
-  IN     EFI_EXCEPTION_TYPE           ExceptionType,   R0
-  IN OUT EFI_SYSTEM_CONTEXT           SystemContext    R1
-  )
-
-*/
-  blx       ASM_PFX(DefaultExceptionHandler)  @ Call exception handler
-
-#if (FixedPcdGet32(PcdVFPEnabled))
-  vpop      {d0-d15}
-#endif
-
-  ldr       R1, [SP, #0x4c]         @ Restore EFI_SYSTEM_CONTEXT_ARM.IFSR
-  mcr       p15, 0, R1, c5, c0, 1   @ Write IFSR
-
-  ldr       R1, [SP, #0x44]         @ sRestore EFI_SYSTEM_CONTEXT_ARM.DFSR
-  mcr       p15, 0, R1, c5, c0, 0   @ Write DFSR
-
-  ldr       R1,[SP,#0x3c]           @ EFI_SYSTEM_CONTEXT_ARM.PC
-  str       R1,[SP,#0x58]           @ Store it back to srsfd stack slot so it can be restored
-
-  ldr       R1,[SP,#0x40]           @ EFI_SYSTEM_CONTEXT_ARM.CPSR
-  str       R1,[SP,#0x5c]           @ Store it back to srsfd stack slot so it can be restored
-
-  add       R3, SP, #0x54           @ Make R3 point to SVC LR saved on entry
-  add       R2, SP, #0x38           @ Make R2 point to EFI_SYSTEM_CONTEXT_ARM.LR
-  and       R1, R1, #0x1f           @ Check to see if User or System Mode
-  cmp       R1, #0x1f               @ if ((CPSR == 0x10) || (CPSR == 0x1f))
-  cmpne     R1, #0x10               @
-  ldmeqed   R2, {lr}^               @   restore unbanked lr
-                                    @ else
-  ldmneed   R3, {lr}                @   restore SVC lr, via ldmfd SP!, {LR}
-
-  ldmfd     SP!,{R0-R12}            @ Restore general purpose registers
-                                    @ Exception handler can not change SP
-
-  add       SP,SP,#0x20             @ Clear out the remaining stack space
-  ldmfd     SP!,{LR}                @ restore the link register for this context
-  rfefd     SP!                     @ return from exception via srsfd stack slot
-
+#------------------------------------------------------------------------------

+#

+# Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+# Copyright (c) 2011 - 2012, ARM Ltd. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+#include <Library/PcdLib.h>

+

+/*

+

+This is the stack constructed by the exception handler (low address to high address)

+                # R0 - IFAR is EFI_SYSTEM_CONTEXT for ARM

+  Reg   Offset

+  ===   ======

+  R0    0x00    # stmfd     SP!,{R0-R12}

+  R1    0x04

+  R2    0x08

+  R3    0x0c

+  R4    0x10

+  R5    0x14

+  R6    0x18

+  R7    0x1c

+  R8    0x20

+  R9    0x24

+  R10   0x28

+  R11   0x2c

+  R12   0x30

+  SP    0x34    # reserved via adding 0x20 (32) to the SP

+  LR    0x38

+  PC    0x3c

+  CPSR  0x40

+  DFSR  0x44

+  DFAR  0x48

+  IFSR  0x4c

+  IFAR  0x50

+

+  LR    0x54    # SVC Link register (we need to restore it)

+

+  LR    0x58    # pushed by srsfd

+  CPSR  0x5c

+

+ */

+

+GCC_ASM_EXPORT(DebugAgentVectorTable)

+GCC_ASM_IMPORT(DefaultExceptionHandler)

+

+.text

+#if !defined(__APPLE__)

+.fpu neon    @ makes vpush/vpop assemble

+#endif

+.align 5

+

+

+//

+// This code gets copied to the ARM vector table

+// ExceptionHandlersStart - ExceptionHandlersEnd gets copied

+//

+ASM_PFX(DebugAgentVectorTable):

+  b ASM_PFX(ResetEntry)

+  b ASM_PFX(UndefinedInstructionEntry)

+  b ASM_PFX(SoftwareInterruptEntry)

+  b ASM_PFX(PrefetchAbortEntry)

+  b ASM_PFX(DataAbortEntry)

+  b ASM_PFX(ReservedExceptionEntry)

+  b ASM_PFX(IrqEntry)

+  b ASM_PFX(FiqEntry)

+

+ASM_PFX(ResetEntry):

+  srsdb     #0x13!                    @ Store return state on SVC stack

+                                      @ We are already in SVC mode

+

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+  

+  mov       R0,#0                     @ ExceptionType

+  ldr       R1,ASM_PFX(CommonExceptionEntry)

+  bx        R1

+

+ASM_PFX(UndefinedInstructionEntry):

+  sub       LR, LR, #4                @ Only -2 for Thumb, adjust in CommonExceptionEntry

+  srsdb     #0x13!                    @ Store return state on SVC stack

+  cps       #0x13                     @ Switch to SVC for common stack

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+

+  mov       R0,#1                     @ ExceptionType

+  ldr       R1,ASM_PFX(CommonExceptionEntry)

+  bx        R1

+

+ASM_PFX(SoftwareInterruptEntry):

+  sub       LR, LR, #4                @ Only -2 for Thumb, adjust in CommonExceptionEntry

+  srsdb     #0x13!                    @ Store return state on SVC stack

+                                      @ We are already in SVC mode

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+

+  mov       R0,#2                     @ ExceptionType

+  ldr       R1,ASM_PFX(CommonExceptionEntry)

+  bx        R1

+

+ASM_PFX(PrefetchAbortEntry):

+  sub       LR,LR,#4

+  srsdb     #0x13!                    @ Store return state on SVC stack

+  cps       #0x13                     @ Switch to SVC for common stack

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+

+  mov       R0,#3                     @ ExceptionType

+  ldr       R1,ASM_PFX(CommonExceptionEntry)

+  bx        R1

+

+ASM_PFX(DataAbortEntry):

+  sub       LR,LR,#8

+  srsdb     #0x13!                    @ Store return state on SVC stack

+  cps       #0x13                     @ Switch to SVC for common stack

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+

+  mov       R0,#4

+  ldr       R1,ASM_PFX(CommonExceptionEntry)

+  bx        R1

+

+ASM_PFX(ReservedExceptionEntry):

+  srsdb     #0x13!                    @ Store return state on SVC stack

+  cps       #0x13                     @ Switch to SVC for common stack

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+

+  mov       R0,#5

+  ldr       R1,ASM_PFX(CommonExceptionEntry)

+  bx        R1

+

+ASM_PFX(IrqEntry):

+  sub       LR,LR,#4

+  srsdb     #0x13!                    @ Store return state on SVC stack

+  cps       #0x13                     @ Switch to SVC for common stack

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+

+  mov       R0,#6                     @ ExceptionType

+  ldr       R1,ASM_PFX(CommonExceptionEntry)

+  bx        R1

+

+ASM_PFX(FiqEntry):

+  sub       LR,LR,#4

+  srsdb     #0x13!                    @ Store return state on SVC stack

+  cps       #0x13                     @ Switch to SVC for common stack

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+                                      @ Since we have already switch to SVC R8_fiq - R12_fiq

+                                      @ never get used or saved

+  mov       R0,#7                     @ ExceptionType

+  ldr       R1,ASM_PFX(CommonExceptionEntry)

+  bx        R1

+

+//

+// This gets patched by the C code that patches in the vector table

+//

+ASM_PFX(CommonExceptionEntry):

+  .word       ASM_PFX(AsmCommonExceptionEntry)

+

+ASM_PFX(ExceptionHandlersEnd):

+

+//

+// This code runs from CpuDxe driver loaded address. It is patched into

+// CommonExceptionEntry.

+//

+ASM_PFX(AsmCommonExceptionEntry):

+  mrc       p15, 0, R1, c6, c0, 2   @ Read IFAR

+  str       R1, [SP, #0x50]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.IFAR

+

+  mrc       p15, 0, R1, c5, c0, 1   @ Read IFSR

+  str       R1, [SP, #0x4c]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.IFSR

+

+  mrc       p15, 0, R1, c6, c0, 0   @ Read DFAR

+  str       R1, [SP, #0x48]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.DFAR

+

+  mrc       p15, 0, R1, c5, c0, 0   @ Read DFSR

+  str       R1, [SP, #0x44]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.DFSR

+

+  ldr       R1, [SP, #0x5c]         @ srsdb saved pre-exception CPSR on the stack

+  str       R1, [SP, #0x40]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.CPSR

+

+  add       R2, SP, #0x38           @ Make R2 point to EFI_SYSTEM_CONTEXT_ARM.LR

+  and       R3, R1, #0x1f           @ Check CPSR to see if User or System Mode

+  cmp       R3, #0x1f               @ if ((CPSR == 0x10) || (CPSR == 0x1df))

+  cmpne     R3, #0x10               @

+  stmeqed   R2, {lr}^               @   save unbanked lr

+                                    @ else

+  stmneed   R2, {lr}                @   save SVC lr

+

+

+  ldr       R5, [SP, #0x58]         @ PC is the LR pushed by srsfd

+                                    @ Check to see if we have to adjust for Thumb entry

+  sub       r4, r0, #1              @ if (ExceptionType == 1 || ExceptionType ==2)) {

+  cmp       r4, #1                  @   // UND & SVC have differnt LR adjust for Thumb

+  bhi       NoAdjustNeeded

+

+  tst       r1, #0x20               @   if ((CPSR & T)) == T) {  // Thumb Mode on entry

+  addne     R5, R5, #2              @     PC += 2@

+  str       R5,[SP,#0x58]           @ Update LR value pused by srsfd

+

+NoAdjustNeeded:

+

+  str       R5, [SP, #0x3c]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.PC

+

+  sub       R1, SP, #0x60           @ We pused 0x60 bytes on the stack

+  str       R1, [SP, #0x34]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.SP

+

+                                    @ R0 is ExceptionType

+  mov       R1,SP                   @ R1 is SystemContext

+

+#if (FixedPcdGet32(PcdVFPEnabled))

+  vpush     {d0-d15}                @ save vstm registers in case they are used in optimizations

+#endif

+

+/*

+VOID

+EFIAPI

+DefaultExceptionHandler (

+  IN     EFI_EXCEPTION_TYPE           ExceptionType,   R0

+  IN OUT EFI_SYSTEM_CONTEXT           SystemContext    R1

+  )

+

+*/

+  blx       ASM_PFX(DefaultExceptionHandler)  @ Call exception handler

+

+#if (FixedPcdGet32(PcdVFPEnabled))

+  vpop      {d0-d15}

+#endif

+

+  ldr       R1, [SP, #0x4c]         @ Restore EFI_SYSTEM_CONTEXT_ARM.IFSR

+  mcr       p15, 0, R1, c5, c0, 1   @ Write IFSR

+

+  ldr       R1, [SP, #0x44]         @ sRestore EFI_SYSTEM_CONTEXT_ARM.DFSR

+  mcr       p15, 0, R1, c5, c0, 0   @ Write DFSR

+

+  ldr       R1,[SP,#0x3c]           @ EFI_SYSTEM_CONTEXT_ARM.PC

+  str       R1,[SP,#0x58]           @ Store it back to srsfd stack slot so it can be restored

+

+  ldr       R1,[SP,#0x40]           @ EFI_SYSTEM_CONTEXT_ARM.CPSR

+  str       R1,[SP,#0x5c]           @ Store it back to srsfd stack slot so it can be restored

+

+  add       R3, SP, #0x54           @ Make R3 point to SVC LR saved on entry

+  add       R2, SP, #0x38           @ Make R2 point to EFI_SYSTEM_CONTEXT_ARM.LR

+  and       R1, R1, #0x1f           @ Check to see if User or System Mode

+  cmp       R1, #0x1f               @ if ((CPSR == 0x10) || (CPSR == 0x1f))

+  cmpne     R1, #0x10               @

+  ldmeqed   R2, {lr}^               @   restore unbanked lr

+                                    @ else

+  ldmneed   R3, {lr}                @   restore SVC lr, via ldmfd SP!, {LR}

+

+  ldmfd     SP!,{R0-R12}            @ Restore general purpose registers

+                                    @ Exception handler can not change SP

+

+  add       SP,SP,#0x20             @ Clear out the remaining stack space

+  ldmfd     SP!,{LR}                @ restore the link register for this context

+  rfefd     SP!                     @ return from exception via srsfd stack slot

+

diff --git a/ArmPkg/Library/DebugAgentSymbolsBaseLib/DebugAgentException.asm b/ArmPkg/Library/DebugAgentSymbolsBaseLib/Arm/DebugAgentException.asm
index f281c060..f281c060 100644
--- a/ArmPkg/Library/DebugAgentSymbolsBaseLib/DebugAgentException.asm
+++ b/ArmPkg/Library/DebugAgentSymbolsBaseLib/Arm/DebugAgentException.asm
diff --git a/ArmPkg/Library/DebugAgentSymbolsBaseLib/DebugAgentSymbolsBaseLib.c b/ArmPkg/Library/DebugAgentSymbolsBaseLib/DebugAgentSymbolsBaseLib.c
index c27d8e7d..25a904e3 100644
--- a/ArmPkg/Library/DebugAgentSymbolsBaseLib/DebugAgentSymbolsBaseLib.c
+++ b/ArmPkg/Library/DebugAgentSymbolsBaseLib/DebugAgentSymbolsBaseLib.c
@@ -221,7 +221,7 @@ GetImageContext (
   ImageContext->ImageRead = PeCoffLoaderImageReadFromMemory;

 

   Status =  PeCoffLoaderGetImageInfo (ImageContext);

-  if (!EFI_ERROR(Status) && ((VOID*)ImageContext->DebugDirectoryEntryRva != NULL)) {

+  if (!EFI_ERROR(Status) && ((VOID*)(UINTN)ImageContext->DebugDirectoryEntryRva != NULL)) {

     ImageAddress = ImageContext->ImageAddress;

     if (ImageContext->IsTeImage) {

       ImageAddress += sizeof (EFI_TE_IMAGE_HEADER) - ((EFI_TE_IMAGE_HEADER*)EfiImage)->StrippedSize;

@@ -285,8 +285,8 @@ InitializeDebugAgent (
 

   // Now we've got UART, make the check:

   // - The Vector table must be 32-byte aligned

-  ASSERT(((UINT32)DebugAgentVectorTable & ARM_VECTOR_TABLE_ALIGNMENT) == 0);

-  ArmWriteVBar ((UINT32)DebugAgentVectorTable);

+  ASSERT(((UINTN)DebugAgentVectorTable & ARM_VECTOR_TABLE_ALIGNMENT) == 0);

+  ArmWriteVBar ((UINTN)DebugAgentVectorTable);

 

   // We use InitFlag to know if DebugAgent has been intialized from

   // Sec (DEBUG_AGENT_INIT_PREMEM_SEC) or PrePi (DEBUG_AGENT_INIT_POSTMEM_SEC)

@@ -295,7 +295,7 @@ InitializeDebugAgent (
     //

     // Get the Sec or PrePeiCore module (defined as SEC type module)

     //

-    Status = GetFfsFile ((EFI_FIRMWARE_VOLUME_HEADER*)PcdGet32(PcdSecureFvBaseAddress), EFI_FV_FILETYPE_SECURITY_CORE, &FfsHeader);

+    Status = GetFfsFile ((EFI_FIRMWARE_VOLUME_HEADER*)(UINTN)PcdGet32(PcdSecureFvBaseAddress), EFI_FV_FILETYPE_SECURITY_CORE, &FfsHeader);

     if (!EFI_ERROR(Status)) {

       Status = GetImageContext (FfsHeader,&ImageContext);

       if (!EFI_ERROR(Status)) {

@@ -306,7 +306,7 @@ InitializeDebugAgent (
     //

     // Get the PrePi or PrePeiCore module (defined as SEC type module)

     //

-    Status = GetFfsFile ((EFI_FIRMWARE_VOLUME_HEADER*)PcdGet32(PcdFvBaseAddress), EFI_FV_FILETYPE_SECURITY_CORE, &FfsHeader);

+    Status = GetFfsFile ((EFI_FIRMWARE_VOLUME_HEADER*)(UINTN)PcdGet32(PcdFvBaseAddress), EFI_FV_FILETYPE_SECURITY_CORE, &FfsHeader);

     if (!EFI_ERROR(Status)) {

       Status = GetImageContext (FfsHeader,&ImageContext);

       if (!EFI_ERROR(Status)) {

@@ -317,7 +317,7 @@ InitializeDebugAgent (
     //

     // Get the PeiCore module (defined as PEI_CORE type module)

     //

-    Status = GetFfsFile ((EFI_FIRMWARE_VOLUME_HEADER*)PcdGet32(PcdFvBaseAddress), EFI_FV_FILETYPE_PEI_CORE, &FfsHeader);

+    Status = GetFfsFile ((EFI_FIRMWARE_VOLUME_HEADER*)(UINTN)PcdGet32(PcdFvBaseAddress), EFI_FV_FILETYPE_PEI_CORE, &FfsHeader);

     if (!EFI_ERROR(Status)) {

       Status = GetImageContext (FfsHeader,&ImageContext);

       if (!EFI_ERROR(Status)) {

diff --git a/ArmPkg/Library/DebugAgentSymbolsBaseLib/DebugAgentSymbolsBaseLib.inf b/ArmPkg/Library/DebugAgentSymbolsBaseLib/DebugAgentSymbolsBaseLib.inf
index 1cf0b335..f6a0ec29 100644
--- a/ArmPkg/Library/DebugAgentSymbolsBaseLib/DebugAgentSymbolsBaseLib.inf
+++ b/ArmPkg/Library/DebugAgentSymbolsBaseLib/DebugAgentSymbolsBaseLib.inf
@@ -21,9 +21,11 @@
 

 [Sources.common]

   DebugAgentSymbolsBaseLib.c

-  DebugAgentException.asm        | RVCT

-  DebugAgentException.S          | GCC

-  

+

+[Sources.ARM]

+  Arm/DebugAgentException.asm        | RVCT

+  Arm/DebugAgentException.S          | GCC

+

 [Packages]

   MdePkg/MdePkg.dec

   MdeModulePkg/MdeModulePkg.dec

diff --git a/ArmPkg/Library/DebugPeCoffExtraActionLib/DebugPeCoffExtraActionLib.c b/ArmPkg/Library/DebugPeCoffExtraActionLib/DebugPeCoffExtraActionLib.c
index 0cf03561..6d0bb988 100755
--- a/ArmPkg/Library/DebugPeCoffExtraActionLib/DebugPeCoffExtraActionLib.c
+++ b/ArmPkg/Library/DebugPeCoffExtraActionLib/DebugPeCoffExtraActionLib.c
@@ -83,22 +83,24 @@ PeCoffLoaderRelocateImageExtraAction (
   CHAR8 Temp[512];

 #endif

 

-  if (ImageContext->PdbPointer)
+  if (ImageContext->PdbPointer) {

 #ifdef __CC_ARM

 #if (__ARMCC_VERSION < 500000)

-  // Print out the command for the RVD debugger to load symbols for this image

-  DEBUG ((EFI_D_ERROR, "load /a /ni /np %a &0x%08x\n", DeCygwinPathIfNeeded (ImageContext->PdbPointer, Temp, sizeof (Temp)), (UINTN)(ImageContext->ImageAddress + ImageContext->SizeOfHeaders)));

+    // Print out the command for the RVD debugger to load symbols for this image

+    DEBUG ((EFI_D_ERROR, "load /a /ni /np %a &0x%08x\n", DeCygwinPathIfNeeded (ImageContext->PdbPointer, Temp, sizeof (Temp)), (UINTN)(ImageContext->ImageAddress + ImageContext->SizeOfHeaders)));

 #else

-  // Print out the command for the DS-5 to load symbols for this image

-  DEBUG ((EFI_D_ERROR, "add-symbol-file %a 0x%08x\n", DeCygwinPathIfNeeded (ImageContext->PdbPointer, Temp, sizeof (Temp)), (UINTN)(ImageContext->ImageAddress + ImageContext->SizeOfHeaders)));

+    // Print out the command for the DS-5 to load symbols for this image

+    DEBUG ((EFI_D_ERROR, "add-symbol-file %a 0x%08x\n", DeCygwinPathIfNeeded (ImageContext->PdbPointer, Temp, sizeof (Temp)), (UINTN)(ImageContext->ImageAddress + ImageContext->SizeOfHeaders)));

 #endif

 #elif __GNUC__

-  // This may not work correctly if you generate PE/COFF directlyas then the Offset would not be required

-  DEBUG ((EFI_D_ERROR, "add-symbol-file %a 0x%08x\n", DeCygwinPathIfNeeded (ImageContext->PdbPointer, Temp, sizeof (Temp)), (UINTN)(ImageContext->ImageAddress + ImageContext->SizeOfHeaders)));

+    // This may not work correctly if you generate PE/COFF directlyas then the Offset would not be required

+    DEBUG ((EFI_D_ERROR, "add-symbol-file %a 0x%08x\n", DeCygwinPathIfNeeded (ImageContext->PdbPointer, Temp, sizeof (Temp)), (UINTN)(ImageContext->ImageAddress + ImageContext->SizeOfHeaders)));

 #else

-  do {} while (0);
-  DEBUG ((EFI_D_ERROR, "Loading driver at 0x%11p EntryPoint=0x%11p\n", (VOID *)(UINTN) ImageContext->ImageAddress, FUNCTION_ENTRY_POINT (ImageContext->EntryPoint)));

+    DEBUG ((EFI_D_ERROR, "Loading driver at 0x%11p EntryPoint=0x%11p\n", (VOID *)(UINTN) ImageContext->ImageAddress, FUNCTION_ENTRY_POINT (ImageContext->EntryPoint)));

 #endif

+  } else {

+    DEBUG ((EFI_D_ERROR, "Loading driver at 0x%11p EntryPoint=0x%11p\n", (VOID *)(UINTN) ImageContext->ImageAddress, FUNCTION_ENTRY_POINT (ImageContext->EntryPoint)));

+  }

 }

 

 

@@ -123,16 +125,17 @@ PeCoffLoaderUnloadImageExtraAction (
   CHAR8 Temp[512];

 #endif

   

-  if (ImageContext->PdbPointer)
+  if (ImageContext->PdbPointer) {

 #ifdef __CC_ARM

-  {  

-  // Print out the command for the RVD debugger to load symbols for this image

+    // Print out the command for the RVD debugger to load symbols for this image

     DEBUG ((EFI_D_ERROR, "unload symbols_only %a\n", DeCygwinPathIfNeeded (ImageContext->PdbPointer, Temp, sizeof (Temp))));

-  }

 #elif __GNUC__

-  // This may not work correctly if you generate PE/COFF directlyas then the Offset would not be required

-  DEBUG ((EFI_D_ERROR, "remove-symbol-file %a 0x%08x\n", DeCygwinPathIfNeeded (ImageContext->PdbPointer, Temp, sizeof (Temp)), (UINTN)(ImageContext->ImageAddress + ImageContext->SizeOfHeaders)));

+    // This may not work correctly if you generate PE/COFF directlyas then the Offset would not be required

+    DEBUG ((EFI_D_ERROR, "remove-symbol-file %a 0x%08x\n", DeCygwinPathIfNeeded (ImageContext->PdbPointer, Temp, sizeof (Temp)), (UINTN)(ImageContext->ImageAddress + ImageContext->SizeOfHeaders)));

 #else

-  DEBUG ((EFI_D_ERROR, "Unloading %a\n", ImageContext->PdbPointer));

+    DEBUG ((EFI_D_ERROR, "Unloading %a\n", ImageContext->PdbPointer));

 #endif

+  } else {

+    DEBUG ((EFI_D_ERROR, "Unloading driver at 0x%11p\n", (VOID *)(UINTN) ImageContext->ImageAddress));

+  }

 }

diff --git a/ArmPkg/Library/DebugPeCoffExtraActionLib/DebugPeCoffExtraActionLib.inf b/ArmPkg/Library/DebugPeCoffExtraActionLib/DebugPeCoffExtraActionLib.inf
index ab57bbd5..c1f717e5 100755
--- a/ArmPkg/Library/DebugPeCoffExtraActionLib/DebugPeCoffExtraActionLib.inf
+++ b/ArmPkg/Library/DebugPeCoffExtraActionLib/DebugPeCoffExtraActionLib.inf
@@ -1,39 +1,39 @@
-#/** @file
-# PeCoff extra action libary for DXE phase that run Unix emulator.
-#
-# Lib to provide memory journal status code reporting Routines
-# Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
-# Portions copyright (c) 2010, Apple Inc. All rights reserved.<BR>
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = DebugUnixPeCoffExtraActionLib
-  FILE_GUID                      = C3E9448E-1726-42fb-9368-41F75B038C0C
-  MODULE_TYPE                    = BASE
-  VERSION_STRING                 = 1.0
-  LIBRARY_CLASS                  = PeCoffExtraActionLib
-
-#
-# The following information is for reference only and not required by the build tools.
-#
-#  VALID_ARCHITECTURES           = ARM
-#
-
-[Sources.common]
-  DebugPeCoffExtraActionLib.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-
-[LibraryClasses]
-  DebugLib
+#/** @file

+# PeCoff extra action libary for DXE phase that run Unix emulator.

+#

+# Lib to provide memory journal status code reporting Routines

+# Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>

+# Portions copyright (c) 2010, Apple Inc. All rights reserved.<BR>

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = DebugUnixPeCoffExtraActionLib

+  FILE_GUID                      = C3E9448E-1726-42fb-9368-41F75B038C0C

+  MODULE_TYPE                    = BASE

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = PeCoffExtraActionLib

+

+#

+# The following information is for reference only and not required by the build tools.

+#

+#  VALID_ARCHITECTURES           = ARM

+#

+

+[Sources.common]

+  DebugPeCoffExtraActionLib.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+

+[LibraryClasses]

+  DebugLib

diff --git a/ArmPkg/Library/DebugUncachedMemoryAllocationLib/DebugUncachedMemoryAllocationLib.inf b/ArmPkg/Library/DebugUncachedMemoryAllocationLib/DebugUncachedMemoryAllocationLib.inf
index d1f81582..b5e9fd8e 100644
--- a/ArmPkg/Library/DebugUncachedMemoryAllocationLib/DebugUncachedMemoryAllocationLib.inf
+++ b/ArmPkg/Library/DebugUncachedMemoryAllocationLib/DebugUncachedMemoryAllocationLib.inf
@@ -44,4 +44,4 @@
   

   

 [Depex]

-  gEfiCpuArchProtocolGuid AND gVirtualUncachedPagesProtocolGuid
\ No newline at end of file
+  gEfiCpuArchProtocolGuid AND gVirtualUncachedPagesProtocolGuid
\ No newline at end of file
diff --git a/ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandler.c b/ArmPkg/Library/DefaultExceptionHandlerLib/Arm/DefaultExceptionHandler.c
index bb29b95d..74e2a760 100644
--- a/ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandler.c
+++ b/ArmPkg/Library/DefaultExceptionHandlerLib/Arm/DefaultExceptionHandler.c
@@ -36,9 +36,9 @@ typedef struct {
 

 CHAR8 *

 GetImageName (

-  IN  UINT32  FaultAddress,

-  OUT UINT32  *ImageBase,

-  OUT UINT32  *PeCoffSizeOfHeaders

+  IN  UINTN  FaultAddress,

+  OUT UINTN  *ImageBase,

+  OUT UINTN  *PeCoffSizeOfHeaders

   );

 

 /**

diff --git a/ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandlerBase.c b/ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandlerBase.c
index e68617e1..4a54298b 100644
--- a/ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandlerBase.c
+++ b/ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandlerBase.c
@@ -26,9 +26,9 @@
 **/

 CHAR8 *

 GetImageName (

-  IN  UINT32  FaultAddress,

-  OUT UINT32  *ImageBase,

-  OUT UINT32  *PeCoffSizeOfHeaders

+  IN  UINTN  FaultAddress,

+  OUT UINTN  *ImageBase,

+  OUT UINTN  *PeCoffSizeOfHeaders

   )

 {

   return NULL;

diff --git a/ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandlerLib.inf b/ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandlerLib.inf
index 120e2de2..61dabf48 100644
--- a/ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandlerLib.inf
+++ b/ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandlerLib.inf
@@ -21,11 +21,12 @@
   LIBRARY_CLASS                  = DefaultExceptionHandlerLib

   CONSTRUCTOR                    = DefaultExceptionHandlerConstructor

 

-

 [Sources.common]

-  DefaultExceptionHandler.c

   DefaultExceptionHandlerUefi.c

 

+[Sources.ARM]

+  Arm/DefaultExceptionHandler.c

+

 [Packages]

   MdePkg/MdePkg.dec

   ArmPkg/ArmPkg.dec

diff --git a/ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandlerLibBase.inf b/ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandlerLibBase.inf
index f51d3a0e..39b2775f 100644
--- a/ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandlerLibBase.inf
+++ b/ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandlerLibBase.inf
@@ -21,9 +21,11 @@
   LIBRARY_CLASS                  = DefaultExceptionHandlerLib

 

 [Sources.common]

-  DefaultExceptionHandler.c

   DefaultExceptionHandlerBase.c

 

+[Sources.ARM]

+  Arm/DefaultExceptionHandler.c

+

 [Packages]

   MdePkg/MdePkg.dec

   ArmPkg/ArmPkg.dec

diff --git a/ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandlerUefi.c b/ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandlerUefi.c
index 8543ade9..b2d630cb 100644
--- a/ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandlerUefi.c
+++ b/ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandlerUefi.c
@@ -62,9 +62,9 @@ DefaultExceptionHandlerConstructor (
 **/

 CHAR8 *

 GetImageName (

-  IN  UINT32  FaultAddress,

-  OUT UINT32  *ImageBase,

-  OUT UINT32  *PeCoffSizeOfHeaders

+  IN  UINTN  FaultAddress,

+  OUT UINTN  *ImageBase,

+  OUT UINTN  *PeCoffSizeOfHeaders

   )

 {

   EFI_DEBUG_IMAGE_INFO  *DebugTable;

@@ -83,7 +83,7 @@ GetImageName (
           (DebugTable->NormalImage->LoadedImageProtocolInstance != NULL)) {

         if ((Address >= (CHAR8 *)DebugTable->NormalImage->LoadedImageProtocolInstance->ImageBase) &&

             (Address <= ((CHAR8 *)DebugTable->NormalImage->LoadedImageProtocolInstance->ImageBase + DebugTable->NormalImage->LoadedImageProtocolInstance->ImageSize))) {

-          *ImageBase = (UINT32)DebugTable->NormalImage->LoadedImageProtocolInstance->ImageBase;

+          *ImageBase = (UINTN)DebugTable->NormalImage->LoadedImageProtocolInstance->ImageBase;

           *PeCoffSizeOfHeaders = PeCoffGetSizeOfHeaders ((VOID *)(UINTN)*ImageBase);

           return PeCoffLoaderGetPdbPointer (DebugTable->NormalImage->LoadedImageProtocolInstance->ImageBase);

         }

@@ -93,3 +93,4 @@ GetImageName (
 

   return NULL;

 }

+

diff --git a/ArmPkg/Library/RvdPeCoffExtraActionLib/RvdPeCoffExtraActionLib.inf b/ArmPkg/Library/RvdPeCoffExtraActionLib/RvdPeCoffExtraActionLib.inf
index e634d39b..3be0237a 100644
--- a/ArmPkg/Library/RvdPeCoffExtraActionLib/RvdPeCoffExtraActionLib.inf
+++ b/ArmPkg/Library/RvdPeCoffExtraActionLib/RvdPeCoffExtraActionLib.inf
@@ -1,41 +1,41 @@
-#/** @file
-# PeCoff extra action libary for DXE phase that run Unix emulator.
-#
-# Lib to provide memory journal status code reporting Routines
-# Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
-# Portions copyright (c) 2010, Apple Inc. All rights reserved.<BR>
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = RvdUnixPeCoffExtraActionLib
-  FILE_GUID                      = 5EDEB7E7-EA55-4E92-8216-335AC98A3B11
-  MODULE_TYPE                    = BASE
-  VERSION_STRING                 = 1.0
-  LIBRARY_CLASS                  = PeCoffExtraActionLib
-
-#
-# The following information is for reference only and not required by the build tools.
-#
-#  VALID_ARCHITECTURES           = ARM
-#
-
-[Sources.common]
-  RvdPeCoffExtraActionLib.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  ArmPkg/ArmPkg.dec
-
-[LibraryClasses]
-  DebugLib
-  SemihostLib
+#/** @file

+# PeCoff extra action libary for DXE phase that run Unix emulator.

+#

+# Lib to provide memory journal status code reporting Routines

+# Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>

+# Portions copyright (c) 2010, Apple Inc. All rights reserved.<BR>

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = RvdUnixPeCoffExtraActionLib

+  FILE_GUID                      = 5EDEB7E7-EA55-4E92-8216-335AC98A3B11

+  MODULE_TYPE                    = BASE

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = PeCoffExtraActionLib

+

+#

+# The following information is for reference only and not required by the build tools.

+#

+#  VALID_ARCHITECTURES           = ARM

+#

+

+[Sources.common]

+  RvdPeCoffExtraActionLib.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  ArmPkg/ArmPkg.dec

+

+[LibraryClasses]

+  DebugLib

+  SemihostLib

diff --git a/ArmPkg/Library/SemihostLib/Arm/GccSemihost.S b/ArmPkg/Library/SemihostLib/Arm/GccSemihost.S
index 2d33664f..4aa88618 100755
--- a/ArmPkg/Library/SemihostLib/Arm/GccSemihost.S
+++ b/ArmPkg/Library/SemihostLib/Arm/GccSemihost.S
@@ -1,41 +1,41 @@
-#------------------------------------------------------------------------------ 
-#
-# Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-#
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#------------------------------------------------------------------------------
-
-.text
-.align 2
-
-.globl ASM_PFX(GccSemihostCall)
-INTERWORK_FUNC(GccSemihostCall)
-
-/*
-  Semihosting operation request mechanism
-  
-  SVC  0x123456  in ARM state (for all architectures)
-  SVC  0xAB in Thumb state (excluding ARMv7-M)
-  BKPT 0xAB for ARMv7-M (Thumb-2 only)
-  
-  R0 - operation type 
-  R1 - block containing all other parametes
-  
-  lr - must be saved as svc instruction will cause an svc exception and write 
-       the svc lr register. That happens to be the one we are using, so we must
-       save it or we will not be able to return. 
- */
-ASM_PFX(GccSemihostCall):
+#------------------------------------------------------------------------------ 

+#

+# Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+.text

+.align 2

+

+.globl ASM_PFX(GccSemihostCall)

+INTERWORK_FUNC(GccSemihostCall)

+

+/*

+  Semihosting operation request mechanism

+  

+  SVC  0x123456  in ARM state (for all architectures)

+  SVC  0xAB in Thumb state (excluding ARMv7-M)

+  BKPT 0xAB for ARMv7-M (Thumb-2 only)

+  

+  R0 - operation type 

+  R1 - block containing all other parametes

+  

+  lr - must be saved as svc instruction will cause an svc exception and write 

+       the svc lr register. That happens to be the one we are using, so we must

+       save it or we will not be able to return. 

+ */

+ASM_PFX(GccSemihostCall):

   stmfd   sp!, {lr} 

-  svc     #0x123456  
+  svc     #0x123456  

   ldmfd   sp!, {lr}

-  bx      lr
-
-
+  bx      lr

+

+

diff --git a/ArmPkg/Library/SemihostLib/Arm/SemihostLib.c b/ArmPkg/Library/SemihostLib/SemihostLib.c
index 01b6dc33..87c0379d 100644
--- a/ArmPkg/Library/SemihostLib/Arm/SemihostLib.c
+++ b/ArmPkg/Library/SemihostLib/SemihostLib.c
@@ -30,7 +30,7 @@ RETURN_STATUS
 SemihostFileOpen (

   IN  CHAR8  *FileName,

   IN  UINT32 Mode,

-  OUT UINT32 *FileHandle

+  OUT UINTN  *FileHandle

   )

 {

   SEMIHOST_FILE_OPEN_BLOCK  OpenBlock;

@@ -40,6 +40,11 @@ SemihostFileOpen (
     return RETURN_INVALID_PARAMETER;

   }

 

+  // Remove any leading separator (e.g.: '\'). EFI Shell adds one.

+  if (*FileName == '\\') {

+    FileName++;

+  }

+

   OpenBlock.FileName    = FileName;

   OpenBlock.Mode        = Mode;

   OpenBlock.NameLength  = AsciiStrLen(FileName);

@@ -56,8 +61,8 @@ SemihostFileOpen (
 

 RETURN_STATUS

 SemihostFileSeek (

-  IN UINT32 FileHandle,

-  IN UINT32 Offset

+  IN UINTN  FileHandle,

+  IN UINTN  Offset

   )

 {

   SEMIHOST_FILE_SEEK_BLOCK  SeekBlock;

@@ -77,8 +82,8 @@ SemihostFileSeek (
 

 RETURN_STATUS

 SemihostFileRead (

-  IN     UINT32 FileHandle,

-  IN OUT UINT32 *Length,

+  IN     UINTN  FileHandle,

+  IN OUT UINTN  *Length,

   OUT    VOID   *Buffer

   )

 {

@@ -105,8 +110,8 @@ SemihostFileRead (
 

 RETURN_STATUS

 SemihostFileWrite (

-  IN     UINT32 FileHandle,

-  IN OUT UINT32 *Length,

+  IN     UINTN  FileHandle,

+  IN OUT UINTN  *Length,

   IN     VOID   *Buffer

   )

 {

@@ -127,7 +132,7 @@ SemihostFileWrite (
 

 RETURN_STATUS

 SemihostFileClose (

-  IN UINT32 FileHandle

+  IN UINTN  FileHandle

   )

 {

   INT32 Result = Semihost_SYS_CLOSE(&FileHandle);

@@ -141,8 +146,8 @@ SemihostFileClose (
 

 RETURN_STATUS

 SemihostFileLength (

-  IN  UINT32 FileHandle,

-  OUT UINT32 *Length

+  IN  UINTN  FileHandle,

+  OUT UINTN  *Length

   )

 {

   INT32       Result;

diff --git a/ArmPkg/Library/SemihostLib/SemihostLib.inf b/ArmPkg/Library/SemihostLib/SemihostLib.inf
index f575a35f..a0a68717 100644
--- a/ArmPkg/Library/SemihostLib/SemihostLib.inf
+++ b/ArmPkg/Library/SemihostLib/SemihostLib.inf
@@ -27,21 +27,16 @@
 #

 #  VALID_ARCHITECTURES           = ARM

 #

+[Sources.common]

+  SemihostLib.c

+

 [Sources.ARM]

   Arm/GccSemihost.S | GCC

-  Arm/SemihostLib.c

-

 

-[Packages]
+[Packages]

   MdePkg/MdePkg.dec

   ArmPkg/ArmPkg.dec

 

-[LibraryClasses]
+[LibraryClasses]

   BaseLib

-  

-[Protocols]

-  

-[Guids]

- 

-[Pcd]

- 
\ No newline at end of file
+ 


diff --git a/ArmPkg/Library/SemihostLib/Arm/SemihostPrivate.h b/ArmPkg/Library/SemihostLib/SemihostPrivate.h
index f8a76528..02836ca2 100644
--- a/ArmPkg/Library/SemihostLib/Arm/SemihostPrivate.h
+++ b/ArmPkg/Library/SemihostLib/SemihostPrivate.h
@@ -1,184 +1,184 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __SEMIHOST_PRIVATE_H__
-#define __SEMIHOST_PRIVATE_H__
-
-typedef struct {
-  CHAR8   *FileName;
-  UINT32  Mode;
-  UINT32  NameLength;
-} SEMIHOST_FILE_OPEN_BLOCK;
-
-typedef struct {
-  UINT32  Handle;
-  VOID    *Buffer;
-  UINT32  Length;
-} SEMIHOST_FILE_READ_WRITE_BLOCK;
-
-typedef struct {
-  UINT32  Handle;
-  UINT32  Location;
-} SEMIHOST_FILE_SEEK_BLOCK;
-
-typedef struct {
-  CHAR8   *FileName;
-  UINT32  NameLength;
-} SEMIHOST_FILE_REMOVE_BLOCK;
-
-typedef struct {
-  CHAR8   *CommandLine;
-  UINT32  CommandLength;
-} SEMIHOST_SYSTEM_BLOCK;
-
-#if defined(__CC_ARM) 
-
-#if defined(__thumb__)
-#define SWI 0xAB
-#else
-#define SWI 0x123456
-#endif
-
-#define SEMIHOST_SUPPORTED  TRUE
-
-__swi(SWI)
-INT32
-_Semihost_SYS_OPEN(
-  IN UINTN                    SWI_0x01,
-  IN SEMIHOST_FILE_OPEN_BLOCK *OpenBlock
-  );
-
-__swi(SWI)
-INT32
-_Semihost_SYS_CLOSE(
-  IN UINTN  SWI_0x02,
-  IN UINT32 *Handle
-  );
-
-__swi(SWI)
-VOID
-_Semihost_SYS_WRITEC(
-  IN UINTN    SWI_0x03,
-  IN CHAR8    *Character
-  );
-
-__swi(SWI)
-VOID
-_Semihost_SYS_WRITE0(
-  IN UINTN SWI_0x04,
-  IN CHAR8 *String
-  );
-
-__swi(SWI)
-UINT32
-_Semihost_SYS_WRITE(
-  IN     UINTN                          SWI_0x05,
-  IN OUT SEMIHOST_FILE_READ_WRITE_BLOCK *WriteBlock
-  );
-
-__swi(SWI)
-UINT32
-_Semihost_SYS_READ(
-  IN     UINTN                          SWI_0x06,
-  IN OUT SEMIHOST_FILE_READ_WRITE_BLOCK *ReadBlock
-  );
-
-__swi(SWI)
-CHAR8
-_Semihost_SYS_READC(
-  IN     UINTN SWI_0x07,
-  IN     UINTN Zero
-  );
-
-__swi(SWI)
-INT32
-_Semihost_SYS_SEEK(
-  IN UINTN                    SWI_0x0A,
-  IN SEMIHOST_FILE_SEEK_BLOCK *SeekBlock
-  );
-
-__swi(SWI)
-INT32
-_Semihost_SYS_FLEN(
-  IN UINTN  SWI_0x0C,
-  IN UINT32 *Handle
-  );
-
-__swi(SWI)
-UINT32
-_Semihost_SYS_REMOVE(
-  IN UINTN                      SWI_0x0E,
-  IN SEMIHOST_FILE_REMOVE_BLOCK *RemoveBlock
-  );
-
-__swi(SWI)
-UINT32
-_Semihost_SYS_SYSTEM(
-  IN UINTN                 SWI_0x12,
-  IN SEMIHOST_SYSTEM_BLOCK *SystemBlock
-  );
-
-#define Semihost_SYS_OPEN(OpenBlock)        _Semihost_SYS_OPEN(0x01, OpenBlock)
-#define Semihost_SYS_CLOSE(Handle)          _Semihost_SYS_CLOSE(0x02, Handle)
-#define Semihost_SYS_WRITE0(String)         _Semihost_SYS_WRITE0(0x04, String)
-#define Semihost_SYS_WRITEC(Character)      _Semihost_SYS_WRITEC(0x03, Character)
-#define Semihost_SYS_WRITE(WriteBlock)      _Semihost_SYS_WRITE(0x05, WriteBlock)
-#define Semihost_SYS_READ(ReadBlock)        _Semihost_SYS_READ(0x06, ReadBlock)
-#define Semihost_SYS_READC()                _Semihost_SYS_READC(0x07, 0)
-#define Semihost_SYS_SEEK(SeekBlock)        _Semihost_SYS_SEEK(0x0A, SeekBlock)
-#define Semihost_SYS_FLEN(Handle)           _Semihost_SYS_FLEN(0x0C, Handle)
-#define Semihost_SYS_REMOVE(RemoveBlock)    _Semihost_SYS_REMOVE(0x0E, RemoveBlock)
-#define Semihost_SYS_SYSTEM(SystemBlock)    _Semihost_SYS_SYSTEM(0x12, SystemBlock)
-
-#elif defined(__GNUC__) // __CC_ARM
-
-#define SEMIHOST_SUPPORTED  TRUE
-
-UINT32
-GccSemihostCall (
-  IN UINT32   Operation,
-  IN UINTN    SystemBlockAddress
-  ); // __attribute__ ((interrupt ("SVC")));
-
-#define Semihost_SYS_OPEN(OpenBlock)        GccSemihostCall(0x01, (UINTN)(OpenBlock))
-#define Semihost_SYS_CLOSE(Handle)          GccSemihostCall(0x02, (UINTN)(Handle))
-#define Semihost_SYS_WRITE0(String)         GccSemihostCall(0x04, (UINTN)(String))
-#define Semihost_SYS_WRITEC(Character)      GccSemihostCall(0x03, (UINTN)(Character))
-#define Semihost_SYS_WRITE(WriteBlock)      GccSemihostCall(0x05, (UINTN)(WriteBlock))
-#define Semihost_SYS_READ(ReadBlock)        GccSemihostCall(0x06, (UINTN)(ReadBlock))
-#define Semihost_SYS_READC()                GccSemihostCall(0x07, (UINTN)(0))
-#define Semihost_SYS_SEEK(SeekBlock)        GccSemihostCall(0x0A, (UINTN)(SeekBlock))
-#define Semihost_SYS_FLEN(Handle)           GccSemihostCall(0x0C, (UINTN)(Handle))
-#define Semihost_SYS_REMOVE(RemoveBlock)    GccSemihostCall(0x0E, (UINTN)(RemoveBlock))
-#define Semihost_SYS_SYSTEM(SystemBlock)    GccSemihostCall(0x12, (UINTN)(SystemBlock))
-
-#else // __CC_ARM
-
-#define SEMIHOST_SUPPORTED  FALSE
-
-#define Semihost_SYS_OPEN(OpenBlock)        (-1)
-#define Semihost_SYS_CLOSE(Handle)          (-1)
-#define Semihost_SYS_WRITE0(String)
-#define Semihost_SYS_WRITEC(Character)
-#define Semihost_SYS_WRITE(WriteBlock)      (0)
-#define Semihost_SYS_READ(ReadBlock)        ((ReadBlock)->Length)
-#define Semihost_SYS_READC()                ('x')
-#define Semihost_SYS_SEEK(SeekBlock)        (-1)
-#define Semihost_SYS_FLEN(Handle)           (-1)
-#define Semihost_SYS_REMOVE(RemoveBlock)    (-1)
-#define Semihost_SYS_SYSTEM(SystemBlock)    (-1)
-
-#endif // __CC_ARM
-
-#endif //__SEMIHOST_PRIVATE_H__
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __SEMIHOST_PRIVATE_H__

+#define __SEMIHOST_PRIVATE_H__

+

+typedef struct {

+  CHAR8   *FileName;

+  UINT32  Mode;

+  UINT32  NameLength;

+} SEMIHOST_FILE_OPEN_BLOCK;

+

+typedef struct {

+  UINT32  Handle;

+  VOID    *Buffer;

+  UINT32  Length;

+} SEMIHOST_FILE_READ_WRITE_BLOCK;

+

+typedef struct {

+  UINT32  Handle;

+  UINT32  Location;

+} SEMIHOST_FILE_SEEK_BLOCK;

+

+typedef struct {

+  CHAR8   *FileName;

+  UINT32  NameLength;

+} SEMIHOST_FILE_REMOVE_BLOCK;

+

+typedef struct {

+  CHAR8   *CommandLine;

+  UINT32  CommandLength;

+} SEMIHOST_SYSTEM_BLOCK;

+

+#if defined(__CC_ARM) 

+

+#if defined(__thumb__)

+#define SWI 0xAB

+#else

+#define SWI 0x123456

+#endif

+

+#define SEMIHOST_SUPPORTED  TRUE

+

+__swi(SWI)

+INT32

+_Semihost_SYS_OPEN(

+  IN UINTN                    SWI_0x01,

+  IN SEMIHOST_FILE_OPEN_BLOCK *OpenBlock

+  );

+

+__swi(SWI)

+INT32

+_Semihost_SYS_CLOSE(

+  IN UINTN  SWI_0x02,

+  IN UINT32 *Handle

+  );

+

+__swi(SWI)

+VOID

+_Semihost_SYS_WRITEC(

+  IN UINTN    SWI_0x03,

+  IN CHAR8    *Character

+  );

+

+__swi(SWI)

+VOID

+_Semihost_SYS_WRITE0(

+  IN UINTN SWI_0x04,

+  IN CHAR8 *String

+  );

+

+__swi(SWI)

+UINT32

+_Semihost_SYS_WRITE(

+  IN     UINTN                          SWI_0x05,

+  IN OUT SEMIHOST_FILE_READ_WRITE_BLOCK *WriteBlock

+  );

+

+__swi(SWI)

+UINT32

+_Semihost_SYS_READ(

+  IN     UINTN                          SWI_0x06,

+  IN OUT SEMIHOST_FILE_READ_WRITE_BLOCK *ReadBlock

+  );

+

+__swi(SWI)

+CHAR8

+_Semihost_SYS_READC(

+  IN     UINTN SWI_0x07,

+  IN     UINTN Zero

+  );

+

+__swi(SWI)

+INT32

+_Semihost_SYS_SEEK(

+  IN UINTN                    SWI_0x0A,

+  IN SEMIHOST_FILE_SEEK_BLOCK *SeekBlock

+  );

+

+__swi(SWI)

+INT32

+_Semihost_SYS_FLEN(

+  IN UINTN  SWI_0x0C,

+  IN UINT32 *Handle

+  );

+

+__swi(SWI)

+UINT32

+_Semihost_SYS_REMOVE(

+  IN UINTN                      SWI_0x0E,

+  IN SEMIHOST_FILE_REMOVE_BLOCK *RemoveBlock

+  );

+

+__swi(SWI)

+UINT32

+_Semihost_SYS_SYSTEM(

+  IN UINTN                 SWI_0x12,

+  IN SEMIHOST_SYSTEM_BLOCK *SystemBlock

+  );

+

+#define Semihost_SYS_OPEN(OpenBlock)        _Semihost_SYS_OPEN(0x01, OpenBlock)

+#define Semihost_SYS_CLOSE(Handle)          _Semihost_SYS_CLOSE(0x02, Handle)

+#define Semihost_SYS_WRITE0(String)         _Semihost_SYS_WRITE0(0x04, String)

+#define Semihost_SYS_WRITEC(Character)      _Semihost_SYS_WRITEC(0x03, Character)

+#define Semihost_SYS_WRITE(WriteBlock)      _Semihost_SYS_WRITE(0x05, WriteBlock)

+#define Semihost_SYS_READ(ReadBlock)        _Semihost_SYS_READ(0x06, ReadBlock)

+#define Semihost_SYS_READC()                _Semihost_SYS_READC(0x07, 0)

+#define Semihost_SYS_SEEK(SeekBlock)        _Semihost_SYS_SEEK(0x0A, SeekBlock)

+#define Semihost_SYS_FLEN(Handle)           _Semihost_SYS_FLEN(0x0C, Handle)

+#define Semihost_SYS_REMOVE(RemoveBlock)    _Semihost_SYS_REMOVE(0x0E, RemoveBlock)

+#define Semihost_SYS_SYSTEM(SystemBlock)    _Semihost_SYS_SYSTEM(0x12, SystemBlock)

+

+#elif defined(__GNUC__) // __CC_ARM

+

+#define SEMIHOST_SUPPORTED  TRUE

+

+UINT32

+GccSemihostCall (

+  IN UINT32   Operation,

+  IN UINTN    SystemBlockAddress

+  ); // __attribute__ ((interrupt ("SVC")));

+

+#define Semihost_SYS_OPEN(OpenBlock)        GccSemihostCall(0x01, (UINTN)(OpenBlock))

+#define Semihost_SYS_CLOSE(Handle)          GccSemihostCall(0x02, (UINTN)(Handle))

+#define Semihost_SYS_WRITE0(String)         GccSemihostCall(0x04, (UINTN)(String))

+#define Semihost_SYS_WRITEC(Character)      GccSemihostCall(0x03, (UINTN)(Character))

+#define Semihost_SYS_WRITE(WriteBlock)      GccSemihostCall(0x05, (UINTN)(WriteBlock))

+#define Semihost_SYS_READ(ReadBlock)        GccSemihostCall(0x06, (UINTN)(ReadBlock))

+#define Semihost_SYS_READC()                GccSemihostCall(0x07, (UINTN)(0))

+#define Semihost_SYS_SEEK(SeekBlock)        GccSemihostCall(0x0A, (UINTN)(SeekBlock))

+#define Semihost_SYS_FLEN(Handle)           GccSemihostCall(0x0C, (UINTN)(Handle))

+#define Semihost_SYS_REMOVE(RemoveBlock)    GccSemihostCall(0x0E, (UINTN)(RemoveBlock))

+#define Semihost_SYS_SYSTEM(SystemBlock)    GccSemihostCall(0x12, (UINTN)(SystemBlock))

+

+#else // __CC_ARM

+

+#define SEMIHOST_SUPPORTED  FALSE

+

+#define Semihost_SYS_OPEN(OpenBlock)        (-1)

+#define Semihost_SYS_CLOSE(Handle)          (-1)

+#define Semihost_SYS_WRITE0(String)

+#define Semihost_SYS_WRITEC(Character)

+#define Semihost_SYS_WRITE(WriteBlock)      (0)

+#define Semihost_SYS_READ(ReadBlock)        ((ReadBlock)->Length)

+#define Semihost_SYS_READC()                ('x')

+#define Semihost_SYS_SEEK(SeekBlock)        (-1)

+#define Semihost_SYS_FLEN(Handle)           (-1)

+#define Semihost_SYS_REMOVE(RemoveBlock)    (-1)

+#define Semihost_SYS_SYSTEM(SystemBlock)    (-1)

+

+#endif // __CC_ARM

+

+#endif //__SEMIHOST_PRIVATE_H__

diff --git a/ArmPkg/Library/UncachedMemoryAllocationLib/UncachedMemoryAllocationLib.inf b/ArmPkg/Library/UncachedMemoryAllocationLib/UncachedMemoryAllocationLib.inf
index 4037b779..a48d94ee 100644
--- a/ArmPkg/Library/UncachedMemoryAllocationLib/UncachedMemoryAllocationLib.inf
+++ b/ArmPkg/Library/UncachedMemoryAllocationLib/UncachedMemoryAllocationLib.inf
@@ -39,4 +39,4 @@
   DxeServicesTableLib

 

 [Depex]

-  gEfiCpuArchProtocolGuid    
\ No newline at end of file
+  gEfiCpuArchProtocolGuid    
\ No newline at end of file
diff --git a/ArmPlatformPkg/ArmPlatformPkg-2ndstage.dsc b/ArmPlatformPkg/ArmPlatformPkg-2ndstage.dsc
index 02778a80..126fb364 100644
--- a/ArmPlatformPkg/ArmPlatformPkg-2ndstage.dsc
+++ b/ArmPlatformPkg/ArmPlatformPkg-2ndstage.dsc
@@ -1,357 +1,359 @@
-#
-#  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-#  
-#  This program and the accompanying materials                          
-#  are licensed and made available under the terms and conditions of the BSD License         
-#  which accompanies this distribution.  The full text of the license may be found at        
-#  http://opensource.org/licenses/bsd-license.php                                            
-#
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-#
-#
-################################################################################
-#
-# Defines Section - statements that will be processed to create a Makefile.
-#
-################################################################################
-[Defines]
-  PLATFORM_NAME                  = ArmPlatform
-  PLATFORM_GUID                  = 4fe82b83-9315-4ff3-8cc0-ab77ca93cb7f 
-  PLATFORM_VERSION               = 0.1
-  DSC_SPECIFICATION              = 0x00010005
-  OUTPUT_DIRECTORY               = Build/$(PLATFORM_NAME)
-  SUPPORTED_ARCHITECTURES        = ARM
-  BUILD_TARGETS                  = DEBUG|RELEASE
-  SKUID_IDENTIFIER               = DEFAULT
-  FLASH_DEFINITION               = ArmPlatformPkg/ArmPlatformPkg-2ndstage.fdf
-
-[LibraryClasses.common]
-  ArmLib|ArmPkg/Library/ArmLib/ArmV7/ArmV7Lib.inf
-  ArmCpuLib|ArmPkg/Drivers/ArmCpuLib/ArmCortexA9Lib/ArmCortexA9Lib.inf
-  ArmPlatformLib|ArmPlatformPkg/Library/ArmPlatformLibNull/ArmPlatformLibNull.inf
-
-!if $(TARGET) == RELEASE
-  DebugLib|MdePkg/Library/BaseDebugLibNull/BaseDebugLibNull.inf
-  UncachedMemoryAllocationLib|ArmPkg/Library/UncachedMemoryAllocationLib/UncachedMemoryAllocationLib.inf
-!else
-  DebugLib|MdePkg/Library/BaseDebugLibSerialPort/BaseDebugLibSerialPort.inf
-  UncachedMemoryAllocationLib|ArmPkg/Library/UncachedMemoryAllocationLib/UncachedMemoryAllocationLib.inf
-#  UncachedMemoryAllocationLib|ArmPkg/Library/DebugUncachedMemoryAllocationLib/DebugUncachedMemoryAllocationLib.inf
-!endif
-  DebugPrintErrorLevelLib|MdePkg/Library/BaseDebugPrintErrorLevelLib/BaseDebugPrintErrorLevelLib.inf
-  
-  BaseLib|MdePkg/Library/BaseLib/BaseLib.inf
-  SynchronizationLib|MdePkg/Library/BaseSynchronizationLib/BaseSynchronizationLib.inf
-  PerformanceLib|MdePkg/Library/BasePerformanceLibNull/BasePerformanceLibNull.inf
-  PrintLib|MdePkg/Library/BasePrintLib/BasePrintLib.inf
-  PeCoffGetEntryPointLib|MdePkg/Library/BasePeCoffGetEntryPointLib/BasePeCoffGetEntryPointLib.inf
-  PeCoffLib|MdePkg/Library/BasePeCoffLib/BasePeCoffLib.inf
-  IoLib|MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.inf
-  UefiDecompressLib|MdePkg/Library/BaseUefiDecompressLib/BaseUefiDecompressLib.inf
-  CpuLib|MdePkg/Library/BaseCpuLib/BaseCpuLib.inf
-
-  UefiLib|MdePkg/Library/UefiLib/UefiLib.inf
-  HobLib|MdePkg/Library/DxeHobLib/DxeHobLib.inf
-  UefiRuntimeServicesTableLib|MdePkg/Library/UefiRuntimeServicesTableLib/UefiRuntimeServicesTableLib.inf
-  DevicePathLib|MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.inf
-  UefiBootServicesTableLib|MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.inf
-  DxeServicesTableLib|MdePkg/Library/DxeServicesTableLib/DxeServicesTableLib.inf
-  UefiDriverEntryPoint|MdePkg/Library/UefiDriverEntryPoint/UefiDriverEntryPoint.inf
-  UefiApplicationEntryPoint|MdePkg/Library/UefiApplicationEntryPoint/UefiApplicationEntryPoint.inf
-  HiiLib|MdeModulePkg/Library/UefiHiiLib/UefiHiiLib.inf
-  UefiHiiServicesLib|MdeModulePkg/Library/UefiHiiServicesLib/UefiHiiServicesLib.inf  
-
-  UefiRuntimeLib|MdePkg/Library/UefiRuntimeLib/UefiRuntimeLib.inf
-
-  #
-  # Assume everything is fixed at build
-  #
-  PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf
-  
-  # 1/123 faster than Stm or Vstm version
-  #BaseMemoryLib|MdePkg/Library/BaseMemoryLib/BaseMemoryLib.inf
-  BaseMemoryLib|ArmPkg/Library/BaseMemoryLibStm/BaseMemoryLibStm.inf
-
-  # ARM Architectural Libraries
-  CacheMaintenanceLib|ArmPkg/Library/ArmCacheMaintenanceLib/ArmCacheMaintenanceLib.inf
-  DefaultExceptionHandlerLib|ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandlerLib.inf
-  CpuExceptionHandlerLib|MdeModulePkg/Library/CpuExceptionHandlerLibNull/CpuExceptionHandlerLibNull.inf
-  ArmDisassemblerLib|ArmPkg/Library/ArmDisassemblerLib/ArmDisassemblerLib.inf
-  DmaLib|ArmPkg/Library/ArmDmaLib/ArmDmaLib.inf
-  ArmGicLib|ArmPkg/Drivers/PL390Gic/PL390GicLib.inf
-
-  SerialPortLib|MdePkg/Library/BaseSerialPortLibNull/BaseSerialPortLibNull.inf
-  TimerLib|MdePkg/Library/BaseTimerLibNullTemplate/BaseTimerLibNullTemplate.inf
-  EfiResetSystemLib|EmbeddedPkg/Library/TemplateResetSystemLib/TemplateResetSystemLib.inf
-  RealTimeClockLib|EmbeddedPkg/Library/TemplateRealTimeClockLib/TemplateRealTimeClockLib.inf
-
-  # EBL Related Libraries  
-  EblCmdLib|ArmPlatformPkg/Library/EblCmdLib/EblCmdLib.inf
-  EfiFileLib|EmbeddedPkg/Library/EfiFileLib/EfiFileLib.inf
-  EblAddExternalCommandLib|EmbeddedPkg/Library/EblAddExternalCommandLib/EblAddExternalCommandLib.inf
-  EblNetworkLib|EmbeddedPkg/Library/EblNetworkLib/EblNetworkLib.inf
-  
-  #
-  # Uncomment (and comment out the next line) For RealView Debugger. The Standard IO window 
-  # in the debugger will show load and unload commands for symbols. You can cut and paste this
-  # into the command window to load symbols. We should be able to use a script to do this, but
-  # the version of RVD I have does not support scripts accessing system memory.
-  #
-  #PeCoffExtraActionLib|ArmPkg/Library/RvdPeCoffExtraActionLib/RvdPeCoffExtraActionLib.inf
-  PeCoffExtraActionLib|ArmPkg/Library/DebugPeCoffExtraActionLib/DebugPeCoffExtraActionLib.inf
-  #PeCoffExtraActionLib|MdePkg/Library/BasePeCoffExtraActionLibNull/BasePeCoffExtraActionLibNull.inf
-    
-  DebugAgentLib|MdeModulePkg/Library/DebugAgentLibNull/DebugAgentLibNull.inf
-  DebugAgentTimerLib|EmbeddedPkg/Library/DebugAgentTimerLibNull/DebugAgentTimerLibNull.inf
-
-  SemihostLib|ArmPkg/Library/SemihostLib/SemihostLib.inf  
-
-  # BDS Libraries
-  BdsLib|ArmPkg/Library/BdsLib/BdsLib.inf
-  FdtLib|EmbeddedPkg/Library/FdtLib/FdtLib.inf
-
-[LibraryClasses.common.SEC]
-  ArmPlatformGlobalVariableLib|ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/PrePi/PrePiArmPlatformGlobalVariableLib.inf
-
-  ArmPlatformSecExtraActionLib|ArmPlatformPkg/Library/DebugSecExtraActionLib/DebugSecExtraActionLib.inf  
-  DebugAgentLib|ArmPkg/Library/DebugAgentSymbolsBaseLib/DebugAgentSymbolsBaseLib.inf
-  
-  PrePiLib|EmbeddedPkg/Library/PrePiLib/PrePiLib.inf
-  ExtractGuidedSectionLib|EmbeddedPkg/Library/PrePiExtractGuidedSectionLib/PrePiExtractGuidedSectionLib.inf
-  LzmaDecompressLib|IntelFrameworkModulePkg/Library/LzmaCustomDecompressLib/LzmaCustomDecompressLib.inf
-  MemoryAllocationLib|EmbeddedPkg/Library/PrePiMemoryAllocationLib/PrePiMemoryAllocationLib.inf
-  HobLib|EmbeddedPkg/Library/PrePiHobLib/PrePiHobLib.inf
-  PrePiHobListPointerLib|ArmPlatformPkg/Library/PrePiHobListPointerLib/PrePiHobListPointerLib.inf
-  PerformanceLib|MdeModulePkg/Library/PeiPerformanceLib/PeiPerformanceLib.inf
-  PlatformPeiLib|ArmPlatformPkg/PlatformPei/PlatformPeiLib.inf
-  MemoryInitPeiLib|ArmPlatformPkg/MemoryInitPei/MemoryInitPeiLib.inf
-
-[LibraryClasses.common.DXE_CORE]
-  HobLib|MdePkg/Library/DxeCoreHobLib/DxeCoreHobLib.inf
-  MemoryAllocationLib|MdeModulePkg/Library/DxeCoreMemoryAllocationLib/DxeCoreMemoryAllocationLib.inf
-  DxeCoreEntryPoint|MdePkg/Library/DxeCoreEntryPoint/DxeCoreEntryPoint.inf
-  ReportStatusCodeLib|IntelFrameworkModulePkg/Library/DxeReportStatusCodeLibFramework/DxeReportStatusCodeLib.inf
-  ExtractGuidedSectionLib|MdePkg/Library/DxeExtractGuidedSectionLib/DxeExtractGuidedSectionLib.inf
-  UefiDecompressLib|MdePkg/Library/BaseUefiDecompressLib/BaseUefiDecompressLib.inf
-  DxeServicesLib|MdePkg/Library/DxeServicesLib/DxeServicesLib.inf
-  PerformanceLib|MdeModulePkg/Library/DxeCorePerformanceLib/DxeCorePerformanceLib.inf
-
-[LibraryClasses.common.DXE_DRIVER]
-  ReportStatusCodeLib|IntelFrameworkModulePkg/Library/DxeReportStatusCodeLibFramework/DxeReportStatusCodeLib.inf
-  DxeServicesLib|MdePkg/Library/DxeServicesLib/DxeServicesLib.inf
-  SecurityManagementLib|MdeModulePkg/Library/DxeSecurityManagementLib/DxeSecurityManagementLib.inf
-  PerformanceLib|MdeModulePkg/Library/DxePerformanceLib/DxePerformanceLib.inf
-  MemoryAllocationLib|MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf
-  ArmPlatformGlobalVariableLib|ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/Dxe/DxeArmPlatformGlobalVariableLib.inf
-
-[LibraryClasses.common.UEFI_APPLICATION]
-  UefiDecompressLib|IntelFrameworkModulePkg/Library/BaseUefiTianoCustomDecompressLib/BaseUefiTianoCustomDecompressLib.inf
-  PerformanceLib|MdeModulePkg/Library/DxePerformanceLib/DxePerformanceLib.inf
-  MemoryAllocationLib|MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf
-  HiiLib|MdeModulePkg/Library/UefiHiiLib/UefiHiiLib.inf
-
-[LibraryClasses.common.UEFI_DRIVER]
-  ReportStatusCodeLib|IntelFrameworkModulePkg/Library/DxeReportStatusCodeLibFramework/DxeReportStatusCodeLib.inf
-  UefiDecompressLib|IntelFrameworkModulePkg/Library/BaseUefiTianoCustomDecompressLib/BaseUefiTianoCustomDecompressLib.inf
-  ExtractGuidedSectionLib|MdePkg/Library/DxeExtractGuidedSectionLib/DxeExtractGuidedSectionLib.inf
-  PerformanceLib|MdeModulePkg/Library/DxePerformanceLib/DxePerformanceLib.inf
-  MemoryAllocationLib|MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf
-
-[LibraryClasses.common.DXE_RUNTIME_DRIVER]
-  HobLib|MdePkg/Library/DxeHobLib/DxeHobLib.inf
-  MemoryAllocationLib|MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf
-  ReportStatusCodeLib|IntelFrameworkModulePkg/Library/DxeReportStatusCodeLibFramework/DxeReportStatusCodeLib.inf
-  CapsuleLib|MdeModulePkg/Library/DxeCapsuleLibNull/DxeCapsuleLibNull.inf
-
-[LibraryClasses.ARM]
-  #
-  # It is not possible to prevent the ARM compiler for generic intrinsic functions.
-  # This library provides the instrinsic functions generate by a given compiler.
-  # [LibraryClasses.ARM] and NULL mean link this library into all ARM images.
-  #
-  NULL|ArmPkg/Library/CompilerIntrinsicsLib/CompilerIntrinsicsLib.inf
-
-[BuildOptions]
-  XCODE:*_*_ARM_PLATFORM_FLAGS == -arch armv7
-
-  GCC:*_*_ARM_PLATFORM_FLAGS == -march=armv7-a
-
-  RVCT:*_*_ARM_PLATFORM_FLAGS == --cpu Cortex-A8
-
-################################################################################
-#
-# Pcd Section - list of all EDK II PCD Entries defined by this Platform
-#
-################################################################################
-
-[PcdsFeatureFlag.common]
-  gEfiMdePkgTokenSpaceGuid.PcdComponentNameDisable|TRUE
-  gEfiMdePkgTokenSpaceGuid.PcdDriverDiagnosticsDisable|TRUE
-  gEfiMdePkgTokenSpaceGuid.PcdComponentName2Disable|TRUE
-  gEfiMdePkgTokenSpaceGuid.PcdDriverDiagnostics2Disable|TRUE
-  
-  #
-  # Control what commands are supported from the UI
-  # Turn these on and off to add features or save size
-  #  
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedMacBoot|TRUE
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedDirCmd|TRUE
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedHobCmd|TRUE
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedHwDebugCmd|TRUE
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedPciDebugCmd|TRUE
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedIoEnable|FALSE
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedScriptCmd|FALSE
-
-  gEmbeddedTokenSpaceGuid.PcdCacheEnable|TRUE
-  
-  # Use the Vector Table location in CpuDxe. We will not copy the Vector Table at PcdCpuVectorBaseAddress
-  gArmTokenSpaceGuid.PcdRelocateVectorTable|FALSE
-  
-  gEmbeddedTokenSpaceGuid.PcdPrePiProduceMemoryTypeInformationHob|TRUE
-  
-  gEfiMdeModulePkgTokenSpaceGuid.PcdTurnOffUsbLegacySupport|TRUE
-
-[PcdsFixedAtBuild.common]
-  gArmPlatformTokenSpaceGuid.PcdFirmwareVendor|"ARM Platform"
-  
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedPrompt|"ArmPlatform"
-  gEmbeddedTokenSpaceGuid.PcdPrePiCpuMemorySize|32
-  gEmbeddedTokenSpaceGuid.PcdPrePiCpuIoSize|0
-  gEfiMdePkgTokenSpaceGuid.PcdMaximumUnicodeStringLength|1000000
-  gEfiMdePkgTokenSpaceGuid.PcdMaximumAsciiStringLength|1000000
-  gEfiMdePkgTokenSpaceGuid.PcdMaximumLinkedListLength|1000000
-  gEfiMdePkgTokenSpaceGuid.PcdSpinLockTimeout|10000000
-  gEfiMdePkgTokenSpaceGuid.PcdDebugClearMemoryValue|0xAF
-  gEfiMdePkgTokenSpaceGuid.PcdPerformanceLibraryPropertyMask|1
-  gEfiMdePkgTokenSpaceGuid.PcdPostCodePropertyMask|0
-  gEfiMdePkgTokenSpaceGuid.PcdUefiLibMaxPrintBufferSize|320
-
-  # DEBUG_ASSERT_ENABLED       0x01
-  # DEBUG_PRINT_ENABLED        0x02
-  # DEBUG_CODE_ENABLED         0x04
-  # CLEAR_MEMORY_ENABLED       0x08
-  # ASSERT_BREAKPOINT_ENABLED  0x10
-  # ASSERT_DEADLOOP_ENABLED    0x20
-!if $(TARGET) == RELEASE
-  gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask|0x21
-!else
-  gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask|0x2f
-!endif
-
-  #  DEBUG_INIT      0x00000001  // Initialization
-  #  DEBUG_WARN      0x00000002  // Warnings
-  #  DEBUG_LOAD      0x00000004  // Load events
-  #  DEBUG_FS        0x00000008  // EFI File system
-  #  DEBUG_POOL      0x00000010  // Alloc & Free's
-  #  DEBUG_PAGE      0x00000020  // Alloc & Free's
-  #  DEBUG_INFO      0x00000040  // Verbose
-  #  DEBUG_DISPATCH  0x00000080  // PEI/DXE Dispatchers
-  #  DEBUG_VARIABLE  0x00000100  // Variable
-  #  DEBUG_BM        0x00000400  // Boot Manager
-  #  DEBUG_BLKIO     0x00001000  // BlkIo Driver
-  #  DEBUG_NET       0x00004000  // SNI Driver
-  #  DEBUG_UNDI      0x00010000  // UNDI Driver
-  #  DEBUG_LOADFILE  0x00020000  // UNDI Driver
-  #  DEBUG_EVENT     0x00080000  // Event messages
-  #  DEBUG_ERROR     0x80000000  // Error
-  gEfiMdePkgTokenSpaceGuid.PcdDebugPrintErrorLevel|0x8000000F
-
-  gEfiMdePkgTokenSpaceGuid.PcdReportStatusCodePropertyMask|0x07
-
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedAutomaticBootCommand|""
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedDefaultTextColor|0x07
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedMemVariableStoreSize|0x10000
-  
-  #
-  # Optional feature to help prevent EFI memory map fragments
-  # Turned on and off via: PcdPrePiProduceMemoryTypeInformationHob
-  # Values are in EFI Pages (4K). DXE Core will make sure that 
-  # at least this much of each type of memory can be allocated 
-  # from a single memory range. This way you only end up with
-  # maximum of two fragements for each type in the memory map
-  # (the memory used, and the free memory that was prereserved
-  # but not used).
-  #
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiACPIReclaimMemory|0
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiACPIMemoryNVS|0
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiReservedMemoryType|0
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiRuntimeServicesData|50
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiRuntimeServicesCode|20
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiBootServicesCode|400
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiBootServicesData|20000
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiLoaderCode|20
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiLoaderData|0
-    
-  #
-  # ARM Pcds
-  #
-  gArmTokenSpaceGuid.PcdArmUncachedMemoryMask|0x0000000000000000
-  
-  gArmTokenSpaceGuid.PcdSystemMemoryBase|0
-  gArmTokenSpaceGuid.PcdSystemMemorySize|0
-
-################################################################################
-#
-# Components Section - list of all EDK II Modules needed by this Platform
-#
-################################################################################
-[Components.common]
-  
-  #
-  # PEI Phase modules
-  #
-  ArmPlatformPkg/PrePi/PeiUniCore.inf
-
-  #
-  # DXE
-  #
-  MdeModulePkg/Core/Dxe/DxeMain.inf {
-    <LibraryClasses>
-      PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf
-      NULL|MdeModulePkg/Library/DxeCrc32GuidedSectionExtractLib/DxeCrc32GuidedSectionExtractLib.inf
-  }
-
-  #
-  # Architectural Protocols
-  #
-  ArmPkg/Drivers/CpuDxe/CpuDxe.inf  
-  MdeModulePkg/Core/RuntimeDxe/RuntimeDxe.inf
-  MdeModulePkg/Universal/SecurityStubDxe/SecurityStubDxe.inf
-  MdeModulePkg/Universal/WatchdogTimerDxe/WatchdogTimer.inf
-  MdeModulePkg/Universal/CapsuleRuntimeDxe/CapsuleRuntimeDxe.inf
-  MdeModulePkg/Universal/Variable/EmuRuntimeDxe/EmuVariableRuntimeDxe.inf
-  EmbeddedPkg/EmbeddedMonotonicCounter/EmbeddedMonotonicCounter.inf  
-  
-  EmbeddedPkg/ResetRuntimeDxe/ResetRuntimeDxe.inf
-  EmbeddedPkg/RealTimeClockRuntimeDxe/RealTimeClockRuntimeDxe.inf
-  EmbeddedPkg/MetronomeDxe/MetronomeDxe.inf
-  
-  # Simple TextIn/TextOut for UEFI Terminal
-  EmbeddedPkg/SimpleTextInOutSerial/SimpleTextInOutSerial.inf
-  
-  #
-  #
-  # Semi-hosting filesystem
-  #
-  ArmPkg/Filesystem/SemihostFs/SemihostFs.inf
-  
-  #
-  # FAT filesystem + GPT/MBR partitioning
-  #
-  MdeModulePkg/Universal/Disk/DiskIoDxe/DiskIoDxe.inf
-  MdeModulePkg/Universal/Disk/PartitionDxe/PartitionDxe.inf
-  FatPkg/EnhancedFatDxe/Fat.inf
-  MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf
-  
-  #
-  # Application
-  #  
-  EmbeddedPkg/Ebl/Ebl.inf
-
-  #
-  # Bds
-  #
-  MdeModulePkg/Universal/DevicePathDxe/DevicePathDxe.inf
-  ArmPlatformPkg/Bds/Bds.inf
-  
+#

+#  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

+#  

+#  This program and the accompanying materials                          

+#  are licensed and made available under the terms and conditions of the BSD License         

+#  which accompanies this distribution.  The full text of the license may be found at        

+#  http://opensource.org/licenses/bsd-license.php                                            

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+#

+#

+################################################################################

+#

+# Defines Section - statements that will be processed to create a Makefile.

+#

+################################################################################

+[Defines]

+  PLATFORM_NAME                  = ArmPlatform

+  PLATFORM_GUID                  = 4fe82b83-9315-4ff3-8cc0-ab77ca93cb7f 

+  PLATFORM_VERSION               = 0.1

+  DSC_SPECIFICATION              = 0x00010005

+  OUTPUT_DIRECTORY               = Build/$(PLATFORM_NAME)

+  SUPPORTED_ARCHITECTURES        = ARM

+  BUILD_TARGETS                  = DEBUG|RELEASE

+  SKUID_IDENTIFIER               = DEFAULT

+  FLASH_DEFINITION               = ArmPlatformPkg/ArmPlatformPkg-2ndstage.fdf

+

+[LibraryClasses.common]

+  ArmLib|ArmPkg/Library/ArmLib/ArmV7/ArmV7Lib.inf

+  ArmCpuLib|ArmPkg/Drivers/ArmCpuLib/ArmCortexA9Lib/ArmCortexA9Lib.inf

+  ArmPlatformLib|ArmPlatformPkg/Library/ArmPlatformLibNull/ArmPlatformLibNull.inf

+

+!if $(TARGET) == RELEASE

+  DebugLib|MdePkg/Library/BaseDebugLibNull/BaseDebugLibNull.inf

+  UncachedMemoryAllocationLib|ArmPkg/Library/UncachedMemoryAllocationLib/UncachedMemoryAllocationLib.inf

+!else

+  DebugLib|MdePkg/Library/BaseDebugLibSerialPort/BaseDebugLibSerialPort.inf

+  UncachedMemoryAllocationLib|ArmPkg/Library/UncachedMemoryAllocationLib/UncachedMemoryAllocationLib.inf

+#  UncachedMemoryAllocationLib|ArmPkg/Library/DebugUncachedMemoryAllocationLib/DebugUncachedMemoryAllocationLib.inf

+!endif

+  DebugPrintErrorLevelLib|MdePkg/Library/BaseDebugPrintErrorLevelLib/BaseDebugPrintErrorLevelLib.inf

+  

+  BaseLib|MdePkg/Library/BaseLib/BaseLib.inf

+  SynchronizationLib|MdePkg/Library/BaseSynchronizationLib/BaseSynchronizationLib.inf

+  PerformanceLib|MdePkg/Library/BasePerformanceLibNull/BasePerformanceLibNull.inf

+  PrintLib|MdePkg/Library/BasePrintLib/BasePrintLib.inf

+  PeCoffGetEntryPointLib|MdePkg/Library/BasePeCoffGetEntryPointLib/BasePeCoffGetEntryPointLib.inf

+  PeCoffLib|MdePkg/Library/BasePeCoffLib/BasePeCoffLib.inf

+  IoLib|MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.inf

+  UefiDecompressLib|MdePkg/Library/BaseUefiDecompressLib/BaseUefiDecompressLib.inf

+  CpuLib|MdePkg/Library/BaseCpuLib/BaseCpuLib.inf

+

+  UefiLib|MdePkg/Library/UefiLib/UefiLib.inf

+  HobLib|MdePkg/Library/DxeHobLib/DxeHobLib.inf

+  UefiRuntimeServicesTableLib|MdePkg/Library/UefiRuntimeServicesTableLib/UefiRuntimeServicesTableLib.inf

+  DevicePathLib|MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.inf

+  UefiBootServicesTableLib|MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.inf

+  DxeServicesTableLib|MdePkg/Library/DxeServicesTableLib/DxeServicesTableLib.inf

+  UefiDriverEntryPoint|MdePkg/Library/UefiDriverEntryPoint/UefiDriverEntryPoint.inf

+  UefiApplicationEntryPoint|MdePkg/Library/UefiApplicationEntryPoint/UefiApplicationEntryPoint.inf

+  HiiLib|MdeModulePkg/Library/UefiHiiLib/UefiHiiLib.inf

+  UefiHiiServicesLib|MdeModulePkg/Library/UefiHiiServicesLib/UefiHiiServicesLib.inf  

+

+  UefiRuntimeLib|MdePkg/Library/UefiRuntimeLib/UefiRuntimeLib.inf

+

+  #

+  # Assume everything is fixed at build

+  #

+  PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf

+  

+  # 1/123 faster than Stm or Vstm version

+  #BaseMemoryLib|MdePkg/Library/BaseMemoryLib/BaseMemoryLib.inf

+  BaseMemoryLib|ArmPkg/Library/BaseMemoryLibStm/BaseMemoryLibStm.inf

+

+  # ARM Architectural Libraries

+  CacheMaintenanceLib|ArmPkg/Library/ArmCacheMaintenanceLib/ArmCacheMaintenanceLib.inf

+  DefaultExceptionHandlerLib|ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandlerLib.inf

+  CpuExceptionHandlerLib|MdeModulePkg/Library/CpuExceptionHandlerLibNull/CpuExceptionHandlerLibNull.inf

+  ArmDisassemblerLib|ArmPkg/Library/ArmDisassemblerLib/ArmDisassemblerLib.inf

+  DmaLib|ArmPkg/Library/ArmDmaLib/ArmDmaLib.inf

+  ArmGicLib|ArmPkg/Drivers/PL390Gic/PL390GicLib.inf

+  ArmPlatformStackLib|ArmPlatformPkg/Library/ArmPlatformStackLib/ArmPlatformStackLib.inf

+  ArmSmcLib|ArmPkg/Library/ArmSmcLib/ArmSmcLib.inf

+

+  SerialPortLib|MdePkg/Library/BaseSerialPortLibNull/BaseSerialPortLibNull.inf

+  TimerLib|MdePkg/Library/BaseTimerLibNullTemplate/BaseTimerLibNullTemplate.inf

+  EfiResetSystemLib|EmbeddedPkg/Library/TemplateResetSystemLib/TemplateResetSystemLib.inf

+  RealTimeClockLib|EmbeddedPkg/Library/TemplateRealTimeClockLib/TemplateRealTimeClockLib.inf

+

+  # EBL Related Libraries  

+  EblCmdLib|ArmPlatformPkg/Library/EblCmdLib/EblCmdLib.inf

+  EfiFileLib|EmbeddedPkg/Library/EfiFileLib/EfiFileLib.inf

+  EblAddExternalCommandLib|EmbeddedPkg/Library/EblAddExternalCommandLib/EblAddExternalCommandLib.inf

+  EblNetworkLib|EmbeddedPkg/Library/EblNetworkLib/EblNetworkLib.inf

+  

+  #

+  # Uncomment (and comment out the next line) For RealView Debugger. The Standard IO window 

+  # in the debugger will show load and unload commands for symbols. You can cut and paste this

+  # into the command window to load symbols. We should be able to use a script to do this, but

+  # the version of RVD I have does not support scripts accessing system memory.

+  #

+  #PeCoffExtraActionLib|ArmPkg/Library/RvdPeCoffExtraActionLib/RvdPeCoffExtraActionLib.inf

+  PeCoffExtraActionLib|ArmPkg/Library/DebugPeCoffExtraActionLib/DebugPeCoffExtraActionLib.inf

+  #PeCoffExtraActionLib|MdePkg/Library/BasePeCoffExtraActionLibNull/BasePeCoffExtraActionLibNull.inf

+    

+  DebugAgentLib|MdeModulePkg/Library/DebugAgentLibNull/DebugAgentLibNull.inf

+  DebugAgentTimerLib|EmbeddedPkg/Library/DebugAgentTimerLibNull/DebugAgentTimerLibNull.inf

+

+  SemihostLib|ArmPkg/Library/SemihostLib/SemihostLib.inf  

+

+  # BDS Libraries

+  BdsLib|ArmPkg/Library/BdsLib/BdsLib.inf

+  FdtLib|EmbeddedPkg/Library/FdtLib/FdtLib.inf

+

+[LibraryClasses.common.SEC]

+  ArmPlatformGlobalVariableLib|ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/PrePi/PrePiArmPlatformGlobalVariableLib.inf

+

+  ArmPlatformSecExtraActionLib|ArmPlatformPkg/Library/DebugSecExtraActionLib/DebugSecExtraActionLib.inf  

+  DebugAgentLib|ArmPkg/Library/DebugAgentSymbolsBaseLib/DebugAgentSymbolsBaseLib.inf

+  DefaultExceptionHandlerLib|ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandlerLibBase.inf

+  

+  PrePiLib|EmbeddedPkg/Library/PrePiLib/PrePiLib.inf

+  ExtractGuidedSectionLib|EmbeddedPkg/Library/PrePiExtractGuidedSectionLib/PrePiExtractGuidedSectionLib.inf

+  LzmaDecompressLib|IntelFrameworkModulePkg/Library/LzmaCustomDecompressLib/LzmaCustomDecompressLib.inf

+  MemoryAllocationLib|EmbeddedPkg/Library/PrePiMemoryAllocationLib/PrePiMemoryAllocationLib.inf

+  HobLib|EmbeddedPkg/Library/PrePiHobLib/PrePiHobLib.inf

+  PrePiHobListPointerLib|ArmPlatformPkg/Library/PrePiHobListPointerLib/PrePiHobListPointerLib.inf

+  PerformanceLib|MdeModulePkg/Library/PeiPerformanceLib/PeiPerformanceLib.inf

+  PlatformPeiLib|ArmPlatformPkg/PlatformPei/PlatformPeiLib.inf

+  MemoryInitPeiLib|ArmPlatformPkg/MemoryInitPei/MemoryInitPeiLib.inf

+

+[LibraryClasses.common.DXE_CORE]

+  HobLib|MdePkg/Library/DxeCoreHobLib/DxeCoreHobLib.inf

+  MemoryAllocationLib|MdeModulePkg/Library/DxeCoreMemoryAllocationLib/DxeCoreMemoryAllocationLib.inf

+  DxeCoreEntryPoint|MdePkg/Library/DxeCoreEntryPoint/DxeCoreEntryPoint.inf

+  ReportStatusCodeLib|IntelFrameworkModulePkg/Library/DxeReportStatusCodeLibFramework/DxeReportStatusCodeLib.inf

+  ExtractGuidedSectionLib|MdePkg/Library/DxeExtractGuidedSectionLib/DxeExtractGuidedSectionLib.inf

+  UefiDecompressLib|MdePkg/Library/BaseUefiDecompressLib/BaseUefiDecompressLib.inf

+  DxeServicesLib|MdePkg/Library/DxeServicesLib/DxeServicesLib.inf

+  PerformanceLib|MdeModulePkg/Library/DxeCorePerformanceLib/DxeCorePerformanceLib.inf

+

+[LibraryClasses.common.DXE_DRIVER]

+  ReportStatusCodeLib|IntelFrameworkModulePkg/Library/DxeReportStatusCodeLibFramework/DxeReportStatusCodeLib.inf

+  DxeServicesLib|MdePkg/Library/DxeServicesLib/DxeServicesLib.inf

+  SecurityManagementLib|MdeModulePkg/Library/DxeSecurityManagementLib/DxeSecurityManagementLib.inf

+  PerformanceLib|MdeModulePkg/Library/DxePerformanceLib/DxePerformanceLib.inf

+  MemoryAllocationLib|MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf

+  ArmPlatformGlobalVariableLib|ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/Dxe/DxeArmPlatformGlobalVariableLib.inf

+

+[LibraryClasses.common.UEFI_APPLICATION]

+  UefiDecompressLib|IntelFrameworkModulePkg/Library/BaseUefiTianoCustomDecompressLib/BaseUefiTianoCustomDecompressLib.inf

+  PerformanceLib|MdeModulePkg/Library/DxePerformanceLib/DxePerformanceLib.inf

+  MemoryAllocationLib|MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf

+  HiiLib|MdeModulePkg/Library/UefiHiiLib/UefiHiiLib.inf

+

+[LibraryClasses.common.UEFI_DRIVER]

+  ReportStatusCodeLib|IntelFrameworkModulePkg/Library/DxeReportStatusCodeLibFramework/DxeReportStatusCodeLib.inf

+  UefiDecompressLib|IntelFrameworkModulePkg/Library/BaseUefiTianoCustomDecompressLib/BaseUefiTianoCustomDecompressLib.inf

+  ExtractGuidedSectionLib|MdePkg/Library/DxeExtractGuidedSectionLib/DxeExtractGuidedSectionLib.inf

+  PerformanceLib|MdeModulePkg/Library/DxePerformanceLib/DxePerformanceLib.inf

+  MemoryAllocationLib|MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf

+

+[LibraryClasses.common.DXE_RUNTIME_DRIVER]

+  HobLib|MdePkg/Library/DxeHobLib/DxeHobLib.inf

+  MemoryAllocationLib|MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf

+  ReportStatusCodeLib|IntelFrameworkModulePkg/Library/DxeReportStatusCodeLibFramework/DxeReportStatusCodeLib.inf

+  CapsuleLib|MdeModulePkg/Library/DxeCapsuleLibNull/DxeCapsuleLibNull.inf

+

+[LibraryClasses.ARM]

+  #

+  # It is not possible to prevent the ARM compiler for generic intrinsic functions.

+  # This library provides the instrinsic functions generate by a given compiler.

+  # [LibraryClasses.ARM] and NULL mean link this library into all ARM images.

+  #

+  NULL|ArmPkg/Library/CompilerIntrinsicsLib/CompilerIntrinsicsLib.inf

+

+[BuildOptions]

+  XCODE:*_*_ARM_PLATFORM_FLAGS == -arch armv7

+

+  GCC:*_*_ARM_PLATFORM_FLAGS == -march=armv7-a

+

+  RVCT:*_*_ARM_PLATFORM_FLAGS == --cpu Cortex-A8

+

+################################################################################

+#

+# Pcd Section - list of all EDK II PCD Entries defined by this Platform

+#

+################################################################################

+

+[PcdsFeatureFlag.common]

+  gEfiMdePkgTokenSpaceGuid.PcdComponentNameDisable|TRUE

+  gEfiMdePkgTokenSpaceGuid.PcdDriverDiagnosticsDisable|TRUE

+  gEfiMdePkgTokenSpaceGuid.PcdComponentName2Disable|TRUE

+  gEfiMdePkgTokenSpaceGuid.PcdDriverDiagnostics2Disable|TRUE

+  

+  #

+  # Control what commands are supported from the UI

+  # Turn these on and off to add features or save size

+  #  

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedMacBoot|TRUE

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedDirCmd|TRUE

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedHobCmd|TRUE

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedHwDebugCmd|TRUE

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedPciDebugCmd|TRUE

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedIoEnable|FALSE

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedScriptCmd|FALSE

+

+  gEmbeddedTokenSpaceGuid.PcdCacheEnable|TRUE

+  

+  # Use the Vector Table location in CpuDxe. We will not copy the Vector Table at PcdCpuVectorBaseAddress

+  gArmTokenSpaceGuid.PcdRelocateVectorTable|FALSE

+  

+  gEmbeddedTokenSpaceGuid.PcdPrePiProduceMemoryTypeInformationHob|TRUE

+  

+  gEfiMdeModulePkgTokenSpaceGuid.PcdTurnOffUsbLegacySupport|TRUE

+

+[PcdsFixedAtBuild.common]

+  gArmPlatformTokenSpaceGuid.PcdFirmwareVendor|"ARM Platform"

+  

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedPrompt|"ArmPlatform"

+  gEmbeddedTokenSpaceGuid.PcdPrePiCpuMemorySize|32

+  gEmbeddedTokenSpaceGuid.PcdPrePiCpuIoSize|0

+  gEfiMdePkgTokenSpaceGuid.PcdMaximumUnicodeStringLength|1000000

+  gEfiMdePkgTokenSpaceGuid.PcdMaximumAsciiStringLength|1000000

+  gEfiMdePkgTokenSpaceGuid.PcdMaximumLinkedListLength|1000000

+  gEfiMdePkgTokenSpaceGuid.PcdSpinLockTimeout|10000000

+  gEfiMdePkgTokenSpaceGuid.PcdDebugClearMemoryValue|0xAF

+  gEfiMdePkgTokenSpaceGuid.PcdPerformanceLibraryPropertyMask|1

+  gEfiMdePkgTokenSpaceGuid.PcdPostCodePropertyMask|0

+  gEfiMdePkgTokenSpaceGuid.PcdUefiLibMaxPrintBufferSize|320

+

+  # DEBUG_ASSERT_ENABLED       0x01

+  # DEBUG_PRINT_ENABLED        0x02

+  # DEBUG_CODE_ENABLED         0x04

+  # CLEAR_MEMORY_ENABLED       0x08

+  # ASSERT_BREAKPOINT_ENABLED  0x10

+  # ASSERT_DEADLOOP_ENABLED    0x20

+!if $(TARGET) == RELEASE

+  gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask|0x21

+!else

+  gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask|0x2f

+!endif

+

+  #  DEBUG_INIT      0x00000001  // Initialization

+  #  DEBUG_WARN      0x00000002  // Warnings

+  #  DEBUG_LOAD      0x00000004  // Load events

+  #  DEBUG_FS        0x00000008  // EFI File system

+  #  DEBUG_POOL      0x00000010  // Alloc & Free's

+  #  DEBUG_PAGE      0x00000020  // Alloc & Free's

+  #  DEBUG_INFO      0x00000040  // Verbose

+  #  DEBUG_DISPATCH  0x00000080  // PEI/DXE Dispatchers

+  #  DEBUG_VARIABLE  0x00000100  // Variable

+  #  DEBUG_BM        0x00000400  // Boot Manager

+  #  DEBUG_BLKIO     0x00001000  // BlkIo Driver

+  #  DEBUG_NET       0x00004000  // SNI Driver

+  #  DEBUG_UNDI      0x00010000  // UNDI Driver

+  #  DEBUG_LOADFILE  0x00020000  // UNDI Driver

+  #  DEBUG_EVENT     0x00080000  // Event messages

+  #  DEBUG_ERROR     0x80000000  // Error

+  gEfiMdePkgTokenSpaceGuid.PcdDebugPrintErrorLevel|0x8000000F

+

+  gEfiMdePkgTokenSpaceGuid.PcdReportStatusCodePropertyMask|0x07

+

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedAutomaticBootCommand|""

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedDefaultTextColor|0x07

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedMemVariableStoreSize|0x10000

+  

+  #

+  # Optional feature to help prevent EFI memory map fragments

+  # Turned on and off via: PcdPrePiProduceMemoryTypeInformationHob

+  # Values are in EFI Pages (4K). DXE Core will make sure that 

+  # at least this much of each type of memory can be allocated 

+  # from a single memory range. This way you only end up with

+  # maximum of two fragements for each type in the memory map

+  # (the memory used, and the free memory that was prereserved

+  # but not used).

+  #

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiACPIReclaimMemory|0

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiACPIMemoryNVS|0

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiReservedMemoryType|0

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiRuntimeServicesData|50

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiRuntimeServicesCode|20

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiBootServicesCode|400

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiBootServicesData|20000

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiLoaderCode|20

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiLoaderData|0

+    

+  #

+  # ARM Pcds

+  #

+  gArmTokenSpaceGuid.PcdArmUncachedMemoryMask|0x0000000000000000

+  

+  gArmTokenSpaceGuid.PcdSystemMemoryBase|0

+  gArmTokenSpaceGuid.PcdSystemMemorySize|0

+

+################################################################################

+#

+# Components Section - list of all EDK II Modules needed by this Platform

+#

+################################################################################

+[Components.common]

+  

+  #

+  # PEI Phase modules

+  #

+  ArmPlatformPkg/PrePi/PeiUniCore.inf

+

+  #

+  # DXE

+  #

+  MdeModulePkg/Core/Dxe/DxeMain.inf {

+    <LibraryClasses>

+      PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf

+      NULL|MdeModulePkg/Library/DxeCrc32GuidedSectionExtractLib/DxeCrc32GuidedSectionExtractLib.inf

+  }

+

+  #

+  # Architectural Protocols

+  #

+  ArmPkg/Drivers/CpuDxe/CpuDxe.inf  

+  MdeModulePkg/Core/RuntimeDxe/RuntimeDxe.inf

+  MdeModulePkg/Universal/SecurityStubDxe/SecurityStubDxe.inf

+  MdeModulePkg/Universal/WatchdogTimerDxe/WatchdogTimer.inf

+  MdeModulePkg/Universal/CapsuleRuntimeDxe/CapsuleRuntimeDxe.inf

+  MdeModulePkg/Universal/Variable/EmuRuntimeDxe/EmuVariableRuntimeDxe.inf

+  EmbeddedPkg/EmbeddedMonotonicCounter/EmbeddedMonotonicCounter.inf  

+  

+  EmbeddedPkg/ResetRuntimeDxe/ResetRuntimeDxe.inf

+  EmbeddedPkg/RealTimeClockRuntimeDxe/RealTimeClockRuntimeDxe.inf

+  EmbeddedPkg/MetronomeDxe/MetronomeDxe.inf

+  

+  # Simple TextIn/TextOut for UEFI Terminal

+  EmbeddedPkg/SimpleTextInOutSerial/SimpleTextInOutSerial.inf

+  

+  #

+  #

+  # Semi-hosting filesystem

+  #

+  ArmPkg/Filesystem/SemihostFs/SemihostFs.inf

+  

+  #

+  # FAT filesystem + GPT/MBR partitioning

+  #

+  MdeModulePkg/Universal/Disk/DiskIoDxe/DiskIoDxe.inf

+  MdeModulePkg/Universal/Disk/PartitionDxe/PartitionDxe.inf

+  MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf

+  

+  #

+  # Application

+  #  

+  EmbeddedPkg/Ebl/Ebl.inf

+

+  #

+  # Bds

+  #

+  MdeModulePkg/Universal/DevicePathDxe/DevicePathDxe.inf

+  ArmPlatformPkg/Bds/Bds.inf

+  

diff --git a/ArmPlatformPkg/ArmPlatformPkg-2ndstage.fdf b/ArmPlatformPkg/ArmPlatformPkg-2ndstage.fdf
index b6699471..afc2fff4 100644
--- a/ArmPlatformPkg/ArmPlatformPkg-2ndstage.fdf
+++ b/ArmPlatformPkg/ArmPlatformPkg-2ndstage.fdf
@@ -1,245 +1,253 @@
-#
-#  Copyright (c) 2011, ARM Limited. All rights reserved.
-#  
-#  This program and the accompanying materials                          
-#  are licensed and made available under the terms and conditions of the BSD License         
-#  which accompanies this distribution.  The full text of the license may be found at        
-#  http://opensource.org/licenses/bsd-license.php                                            
-#
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-#
-
-################################################################################
-#
-# FD Section
-# The [FD] Section is made up of the definition statements and a
-# description of what goes into  the Flash Device Image.  Each FD section
-# defines one flash "device" image.  A flash device image may be one of
-# the following: Removable media bootable image (like a boot floppy
-# image,) an Option ROM image (that would be "flashed" into an add-in
-# card,) a System "Flash"  image (that would be burned into a system's
-# flash) or an Update ("Capsule") image that will be used to update and
-# existing system flash.
-#
-################################################################################
-
-[FD.ArmPlatform_EFI]
-BaseAddress   = 0xEC200000|gArmTokenSpaceGuid.PcdFdBaseAddress  # The base address of the Firmware in NOR Flash.
-Size          = 0x00200000|gArmTokenSpaceGuid.PcdFdSize         # The size in bytes of the FLASH Device
-ErasePolarity = 1
-
-# This one is tricky, it must be: BlockSize * NumBlocks = Size
-BlockSize     = 0x00001000
-NumBlocks     = 0x200
-
-################################################################################
-#
-# Following are lists of FD Region layout which correspond to the locations of different
-# images within the flash device.
-#
-# Regions must be defined in ascending order and may not overlap.
-#
-# A Layout Region start with a eight digit hex offset (leading "0x" required) followed by
-# the pipe "|" character, followed by the size of the region, also in hex with the leading
-# "0x" characters. Like:
-# Offset|Size
-# PcdOffsetCName|PcdSizeCName
-# RegionType <FV, DATA, or FILE>
-#
-################################################################################
-
-0x00000000|0x00200000
-gArmTokenSpaceGuid.PcdFvBaseAddress|gArmTokenSpaceGuid.PcdFvSize
-FV = FVMAIN_COMPACT
-
-
-################################################################################
-#
-# FV Section
-#
-# [FV] section is used to define what components or modules are placed within a flash
-# device file.  This section also defines order the components and modules are positioned
-# within the image.  The [FV] section consists of define statements, set statements and
-# module statements.
-#
-################################################################################
-
-[FV.FvMain]
-BlockSize          = 0x40
-NumBlocks          = 0         # This FV gets compressed so make it just big enough
-FvAlignment        = 8         # FV alignment and FV attributes setting.
-ERASE_POLARITY     = 1
-MEMORY_MAPPED      = TRUE
-STICKY_WRITE       = TRUE
-LOCK_CAP           = TRUE
-LOCK_STATUS        = TRUE
-WRITE_DISABLED_CAP = TRUE
-WRITE_ENABLED_CAP  = TRUE
-WRITE_STATUS       = TRUE
-WRITE_LOCK_CAP     = TRUE
-WRITE_LOCK_STATUS  = TRUE
-READ_DISABLED_CAP  = TRUE
-READ_ENABLED_CAP   = TRUE
-READ_STATUS        = TRUE
-READ_LOCK_CAP      = TRUE
-READ_LOCK_STATUS   = TRUE
-
-  INF MdeModulePkg/Core/Dxe/DxeMain.inf 
-
-  #
-  # PI DXE Drivers producing Architectural Protocols (EFI Services) 
-  #
-  INF ArmPkg/Drivers/CpuDxe/CpuDxe.inf
-  INF MdeModulePkg/Core/RuntimeDxe/RuntimeDxe.inf
-  INF MdeModulePkg/Universal/SecurityStubDxe/SecurityStubDxe.inf
-  INF MdeModulePkg/Universal/WatchdogTimerDxe/WatchdogTimer.inf
-  INF MdeModulePkg/Universal/CapsuleRuntimeDxe/CapsuleRuntimeDxe.inf
-  INF MdeModulePkg/Universal/Variable/EmuRuntimeDxe/EmuVariableRuntimeDxe.inf
-  INF EmbeddedPkg/EmbeddedMonotonicCounter/EmbeddedMonotonicCounter.inf
-  INF EmbeddedPkg/ResetRuntimeDxe/ResetRuntimeDxe.inf
-  INF EmbeddedPkg/RealTimeClockRuntimeDxe/RealTimeClockRuntimeDxe.inf
-  INF EmbeddedPkg/MetronomeDxe/MetronomeDxe.inf
-
-  # Simple TextIn/TextOut for UEFI Terminal
-  INF EmbeddedPkg/SimpleTextInOutSerial/SimpleTextInOutSerial.inf
-  
-  #
-  # Semi-hosting filesystem (Required the Hardware Debugger to be connected)
-  #
-  INF ArmPkg/Filesystem/SemihostFs/SemihostFs.inf
-  
-  #
-  # FAT filesystem + GPT/MBR partitioning
-  #
-  INF MdeModulePkg/Universal/Disk/DiskIoDxe/DiskIoDxe.inf
-  INF MdeModulePkg/Universal/Disk/PartitionDxe/PartitionDxe.inf
-  INF FatPkg/EnhancedFatDxe/Fat.inf
-  INF MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf
-  
-  #
-  # UEFI application (Shell Embedded Boot Loader) 
-  #  
-  INF EmbeddedPkg/Ebl/Ebl.inf
-    
-  #
-  # Bds
-  #
-  INF MdeModulePkg/Universal/DevicePathDxe/DevicePathDxe.inf
-  INF ArmPlatformPkg/Bds/Bds.inf
-
-
-[FV.FVMAIN_COMPACT]
-FvAlignment        = 8
-ERASE_POLARITY     = 1
-MEMORY_MAPPED      = TRUE
-STICKY_WRITE       = TRUE
-LOCK_CAP           = TRUE
-LOCK_STATUS        = TRUE
-WRITE_DISABLED_CAP = TRUE
-WRITE_ENABLED_CAP  = TRUE
-WRITE_STATUS       = TRUE
-WRITE_LOCK_CAP     = TRUE
-WRITE_LOCK_STATUS  = TRUE
-READ_DISABLED_CAP  = TRUE
-READ_ENABLED_CAP   = TRUE
-READ_STATUS        = TRUE
-READ_LOCK_CAP      = TRUE
-READ_LOCK_STATUS   = TRUE
-
-  INF ArmPlatformPkg/PrePi/PeiUniCore.inf
-  
-  FILE FV_IMAGE = 9E21FD93-9C72-4c15-8C4B-E77F1DB2D792 {
-    SECTION GUIDED EE4E5898-3914-4259-9D6E-DC7BD79403CF PROCESSING_REQUIRED = TRUE {
-      SECTION FV_IMAGE = FVMAIN
-    }
-  }
-
-
-################################################################################
-#
-# Rules are use with the [FV] section's module INF type to define
-# how an FFS file is created for a given INF file. The following Rule are the default
-# rules for the different module type. User can add the customized rules to define the
-# content of the FFS file.
-#
-################################################################################
-
-
-############################################################################
-# Example of a DXE_DRIVER FFS file with a Checksum encapsulation section   # 
-############################################################################
-#
-#[Rule.Common.DXE_DRIVER]
-#  FILE DRIVER = $(NAMED_GUID) {
-#    DXE_DEPEX    DXE_DEPEX               Optional $(INF_OUTPUT)/$(MODULE_NAME).depex
-#    COMPRESS PI_STD {
-#      GUIDED {
-#        PE32     PE32                    $(INF_OUTPUT)/$(MODULE_NAME).efi
-#        UI       STRING="$(MODULE_NAME)" Optional
-#        VERSION  STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)
-#      }
-#    }
-#  }
-#
-############################################################################
-
-[Rule.Common.SEC]
-  FILE SEC = $(NAMED_GUID) RELOCS_STRIPPED {
-    TE  TE    Align = 32                $(INF_OUTPUT)/$(MODULE_NAME).efi
-  }
-
-[Rule.Common.PEI_CORE]
-  FILE PEI_CORE = $(NAMED_GUID) {
-    TE     TE                           $(INF_OUTPUT)/$(MODULE_NAME).efi
-    UI     STRING ="$(MODULE_NAME)" Optional         
-  }
-
-[Rule.Common.PEIM]
-  FILE PEIM = $(NAMED_GUID) {
-     PEI_DEPEX PEI_DEPEX Optional       $(INF_OUTPUT)/$(MODULE_NAME).depex
-     TE       TE                        $(INF_OUTPUT)/$(MODULE_NAME).efi
-     UI       STRING="$(MODULE_NAME)" Optional         
-  }
-
-[Rule.Common.PEIM.TIANOCOMPRESSED]
-  FILE PEIM = $(NAMED_GUID) DEBUG_MYTOOLS_IA32 {
-    PEI_DEPEX PEI_DEPEX Optional        $(INF_OUTPUT)/$(MODULE_NAME).depex
-    GUIDED A31280AD-481E-41B6-95E8-127F4C984779 PROCESSING_REQUIRED = TRUE {
-      PE32      PE32                    $(INF_OUTPUT)/$(MODULE_NAME).efi
-      UI        STRING="$(MODULE_NAME)" Optional
-    }
-  }
-
-[Rule.Common.DXE_CORE]
-  FILE DXE_CORE = $(NAMED_GUID) {
-    PE32     PE32                       $(INF_OUTPUT)/$(MODULE_NAME).efi
-    UI       STRING="$(MODULE_NAME)" Optional
-  }
-
-[Rule.Common.UEFI_DRIVER]
-  FILE DRIVER = $(NAMED_GUID) {
-    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex
-    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi
-    UI           STRING="$(MODULE_NAME)" Optional
-  }
-
-[Rule.Common.DXE_DRIVER]
-  FILE DRIVER = $(NAMED_GUID) {
-    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex
-    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi
-    UI           STRING="$(MODULE_NAME)" Optional
-  }
-
-[Rule.Common.DXE_RUNTIME_DRIVER]
-  FILE DRIVER = $(NAMED_GUID) {
-    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex
-    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi
-    UI           STRING="$(MODULE_NAME)" Optional
-  }
-
-[Rule.Common.UEFI_APPLICATION]
-  FILE APPLICATION = $(NAMED_GUID) {
-    UI     STRING ="$(MODULE_NAME)" Optional         
-    PE32   PE32                         $(INF_OUTPUT)/$(MODULE_NAME).efi
-  }
+#

+#  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

+#  

+#  This program and the accompanying materials                          

+#  are licensed and made available under the terms and conditions of the BSD License         

+#  which accompanies this distribution.  The full text of the license may be found at        

+#  http://opensource.org/licenses/bsd-license.php                                            

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+#

+

+################################################################################

+#

+# FD Section

+# The [FD] Section is made up of the definition statements and a

+# description of what goes into  the Flash Device Image.  Each FD section

+# defines one flash "device" image.  A flash device image may be one of

+# the following: Removable media bootable image (like a boot floppy

+# image,) an Option ROM image (that would be "flashed" into an add-in

+# card,) a System "Flash"  image (that would be burned into a system's

+# flash) or an Update ("Capsule") image that will be used to update and

+# existing system flash.

+#

+################################################################################

+

+[FD.ArmPlatform_EFI]

+BaseAddress   = 0xEC200000|gArmTokenSpaceGuid.PcdFdBaseAddress  # The base address of the Firmware in NOR Flash.

+Size          = 0x00200000|gArmTokenSpaceGuid.PcdFdSize         # The size in bytes of the FLASH Device

+ErasePolarity = 1

+

+# This one is tricky, it must be: BlockSize * NumBlocks = Size

+BlockSize     = 0x00001000

+NumBlocks     = 0x200

+

+################################################################################

+#

+# Following are lists of FD Region layout which correspond to the locations of different

+# images within the flash device.

+#

+# Regions must be defined in ascending order and may not overlap.

+#

+# A Layout Region start with a eight digit hex offset (leading "0x" required) followed by

+# the pipe "|" character, followed by the size of the region, also in hex with the leading

+# "0x" characters. Like:

+# Offset|Size

+# PcdOffsetCName|PcdSizeCName

+# RegionType <FV, DATA, or FILE>

+#

+################################################################################

+

+0x00000000|0x00200000

+gArmTokenSpaceGuid.PcdFvBaseAddress|gArmTokenSpaceGuid.PcdFvSize

+FV = FVMAIN_COMPACT

+

+

+################################################################################

+#

+# FV Section

+#

+# [FV] section is used to define what components or modules are placed within a flash

+# device file.  This section also defines order the components and modules are positioned

+# within the image.  The [FV] section consists of define statements, set statements and

+# module statements.

+#

+################################################################################

+

+[FV.FvMain]

+BlockSize          = 0x40

+NumBlocks          = 0         # This FV gets compressed so make it just big enough

+FvAlignment        = 8         # FV alignment and FV attributes setting.

+ERASE_POLARITY     = 1

+MEMORY_MAPPED      = TRUE

+STICKY_WRITE       = TRUE

+LOCK_CAP           = TRUE

+LOCK_STATUS        = TRUE

+WRITE_DISABLED_CAP = TRUE

+WRITE_ENABLED_CAP  = TRUE

+WRITE_STATUS       = TRUE

+WRITE_LOCK_CAP     = TRUE

+WRITE_LOCK_STATUS  = TRUE

+READ_DISABLED_CAP  = TRUE

+READ_ENABLED_CAP   = TRUE

+READ_STATUS        = TRUE

+READ_LOCK_CAP      = TRUE

+READ_LOCK_STATUS   = TRUE

+

+  INF MdeModulePkg/Core/Dxe/DxeMain.inf 

+

+  #

+  # PI DXE Drivers producing Architectural Protocols (EFI Services) 

+  #

+  INF ArmPkg/Drivers/CpuDxe/CpuDxe.inf

+  INF MdeModulePkg/Core/RuntimeDxe/RuntimeDxe.inf

+  INF MdeModulePkg/Universal/SecurityStubDxe/SecurityStubDxe.inf

+  INF MdeModulePkg/Universal/WatchdogTimerDxe/WatchdogTimer.inf

+  INF MdeModulePkg/Universal/CapsuleRuntimeDxe/CapsuleRuntimeDxe.inf

+  INF MdeModulePkg/Universal/Variable/EmuRuntimeDxe/EmuVariableRuntimeDxe.inf

+  INF EmbeddedPkg/EmbeddedMonotonicCounter/EmbeddedMonotonicCounter.inf

+  INF EmbeddedPkg/ResetRuntimeDxe/ResetRuntimeDxe.inf

+  INF EmbeddedPkg/RealTimeClockRuntimeDxe/RealTimeClockRuntimeDxe.inf

+  INF EmbeddedPkg/MetronomeDxe/MetronomeDxe.inf

+

+  # Simple TextIn/TextOut for UEFI Terminal

+  INF EmbeddedPkg/SimpleTextInOutSerial/SimpleTextInOutSerial.inf

+  

+  #

+  # Semi-hosting filesystem (Required the Hardware Debugger to be connected)

+  #

+  INF ArmPkg/Filesystem/SemihostFs/SemihostFs.inf

+  

+  #

+  # FAT filesystem + GPT/MBR partitioning

+  #

+  INF MdeModulePkg/Universal/Disk/DiskIoDxe/DiskIoDxe.inf

+  INF MdeModulePkg/Universal/Disk/PartitionDxe/PartitionDxe.inf

+  INF FatBinPkg/EnhancedFatDxe/Fat.inf

+  INF MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf

+  

+  #

+  # UEFI application (Shell Embedded Boot Loader) 

+  #  

+  INF EmbeddedPkg/Ebl/Ebl.inf

+    

+  #

+  # Bds

+  #

+  INF MdeModulePkg/Universal/DevicePathDxe/DevicePathDxe.inf

+  INF ArmPlatformPkg/Bds/Bds.inf

+

+

+[FV.FVMAIN_COMPACT]

+FvAlignment        = 8

+ERASE_POLARITY     = 1

+MEMORY_MAPPED      = TRUE

+STICKY_WRITE       = TRUE

+LOCK_CAP           = TRUE

+LOCK_STATUS        = TRUE

+WRITE_DISABLED_CAP = TRUE

+WRITE_ENABLED_CAP  = TRUE

+WRITE_STATUS       = TRUE

+WRITE_LOCK_CAP     = TRUE

+WRITE_LOCK_STATUS  = TRUE

+READ_DISABLED_CAP  = TRUE

+READ_ENABLED_CAP   = TRUE

+READ_STATUS        = TRUE

+READ_LOCK_CAP      = TRUE

+READ_LOCK_STATUS   = TRUE

+

+  INF ArmPlatformPkg/PrePi/PeiUniCore.inf

+  

+  FILE FV_IMAGE = 9E21FD93-9C72-4c15-8C4B-E77F1DB2D792 {

+    SECTION GUIDED EE4E5898-3914-4259-9D6E-DC7BD79403CF PROCESSING_REQUIRED = TRUE {

+      SECTION FV_IMAGE = FVMAIN

+    }

+  }

+

+

+################################################################################

+#

+# Rules are use with the [FV] section's module INF type to define

+# how an FFS file is created for a given INF file. The following Rule are the default

+# rules for the different module type. User can add the customized rules to define the

+# content of the FFS file.

+#

+################################################################################

+

+

+############################################################################

+# Example of a DXE_DRIVER FFS file with a Checksum encapsulation section   # 

+############################################################################

+#

+#[Rule.Common.DXE_DRIVER]

+#  FILE DRIVER = $(NAMED_GUID) {

+#    DXE_DEPEX    DXE_DEPEX               Optional $(INF_OUTPUT)/$(MODULE_NAME).depex

+#    COMPRESS PI_STD {

+#      GUIDED {

+#        PE32     PE32                    $(INF_OUTPUT)/$(MODULE_NAME).efi

+#        UI       STRING="$(MODULE_NAME)" Optional

+#        VERSION  STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)

+#      }

+#    }

+#  }

+#

+############################################################################

+

+[Rule.Common.SEC]

+  FILE SEC = $(NAMED_GUID) RELOCS_STRIPPED {

+    TE  TE    Align = 32                $(INF_OUTPUT)/$(MODULE_NAME).efi

+  }

+

+[Rule.Common.PEI_CORE]

+  FILE PEI_CORE = $(NAMED_GUID) {

+    TE     TE                           $(INF_OUTPUT)/$(MODULE_NAME).efi

+    UI     STRING ="$(MODULE_NAME)" Optional         

+  }

+

+[Rule.Common.PEIM]

+  FILE PEIM = $(NAMED_GUID) {

+     PEI_DEPEX PEI_DEPEX Optional       $(INF_OUTPUT)/$(MODULE_NAME).depex

+     TE       TE                        $(INF_OUTPUT)/$(MODULE_NAME).efi

+     UI       STRING="$(MODULE_NAME)" Optional         

+  }

+

+[Rule.Common.PEIM.TIANOCOMPRESSED]

+  FILE PEIM = $(NAMED_GUID) DEBUG_MYTOOLS_IA32 {

+    PEI_DEPEX PEI_DEPEX Optional        $(INF_OUTPUT)/$(MODULE_NAME).depex

+    GUIDED A31280AD-481E-41B6-95E8-127F4C984779 PROCESSING_REQUIRED = TRUE {

+      PE32      PE32                    $(INF_OUTPUT)/$(MODULE_NAME).efi

+      UI        STRING="$(MODULE_NAME)" Optional

+    }

+  }

+

+[Rule.Common.DXE_CORE]

+  FILE DXE_CORE = $(NAMED_GUID) {

+    PE32     PE32                       $(INF_OUTPUT)/$(MODULE_NAME).efi

+    UI       STRING="$(MODULE_NAME)" Optional

+  }

+

+[Rule.Common.UEFI_DRIVER]

+  FILE DRIVER = $(NAMED_GUID) {

+    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex

+    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi

+    UI           STRING="$(MODULE_NAME)" Optional

+  }

+

+[Rule.Common.UEFI_DRIVER.BINARY]

+  FILE DRIVER = $(NAMED_GUID) {

+    DXE_DEPEX DXE_DEPEX Optional      |.depex

+    PE32      PE32                    |.efi

+    UI        STRING="$(MODULE_NAME)" Optional

+    VERSION   STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)

+  }

+

+[Rule.Common.DXE_DRIVER]

+  FILE DRIVER = $(NAMED_GUID) {

+    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex

+    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi

+    UI           STRING="$(MODULE_NAME)" Optional

+  }

+

+[Rule.Common.DXE_RUNTIME_DRIVER]

+  FILE DRIVER = $(NAMED_GUID) {

+    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex

+    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi

+    UI           STRING="$(MODULE_NAME)" Optional

+  }

+

+[Rule.Common.UEFI_APPLICATION]

+  FILE APPLICATION = $(NAMED_GUID) {

+    UI     STRING ="$(MODULE_NAME)" Optional         

+    PE32   PE32                         $(INF_OUTPUT)/$(MODULE_NAME).efi

+  }

diff --git a/ArmPlatformPkg/ArmPlatformPkg.dec b/ArmPlatformPkg/ArmPlatformPkg.dec
index 07205273..e672ce2e 100644
--- a/ArmPlatformPkg/ArmPlatformPkg.dec
+++ b/ArmPlatformPkg/ArmPlatformPkg.dec
@@ -135,8 +135,9 @@
   #  - 2 = a Linux kernel with FDT support

   gArmPlatformTokenSpaceGuid.PcdDefaultBootType|0|UINT32|0x00000010

   gArmPlatformTokenSpaceGuid.PcdFdtDevicePath|L""|VOID*|0x00000011

-  gArmPlatformTokenSpaceGuid.PcdFdtLocalDevicePath|L""|VOID*|0x0000002E
-
+  

+  gArmPlatformTokenSpaceGuid.PcdDefaultFdtLocalDevicePath|L""|VOID*|0x0000002E

+

   ## Timeout value for displaying progressing bar in before boot OS.

   #  According to UEFI 2.0 spec, the default TimeOut should be 0xffff.

   gArmPlatformTokenSpaceGuid.PcdPlatformBootTimeOut|0xffff|UINT16|0x0000001A

diff --git a/ArmPlatformPkg/ArmPlatformPkg.dsc b/ArmPlatformPkg/ArmPlatformPkg.dsc
index c9ef3851..495896c8 100644
--- a/ArmPlatformPkg/ArmPlatformPkg.dsc
+++ b/ArmPlatformPkg/ArmPlatformPkg.dsc
@@ -1,5 +1,5 @@
 #

-#  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+#  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

 #  

 #  This program and the accompanying materials                          

 #  are licensed and made available under the terms and conditions of the BSD License         

@@ -80,6 +80,7 @@
   ArmDisassemblerLib|ArmPkg/Library/ArmDisassemblerLib/ArmDisassemblerLib.inf

   DmaLib|ArmPkg/Library/ArmDmaLib/ArmDmaLib.inf

   ArmGicLib|ArmPkg/Drivers/PL390Gic/PL390GicLib.inf

+  ArmSmcLib|ArmPkg/Library/ArmSmcLib/ArmSmcLib.inf

 

   SerialPortLib|MdePkg/Library/BaseSerialPortLibNull/BaseSerialPortLibNull.inf

   TimerLib|MdePkg/Library/BaseTimerLibNullTemplate/BaseTimerLibNullTemplate.inf

@@ -121,6 +122,7 @@
   ArmPlatformGlobalVariableLib|ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/Sec/SecArmPlatformGlobalVariableLib.inf

   

   DebugAgentLib|ArmPkg/Library/DebugAgentSymbolsBaseLib/DebugAgentSymbolsBaseLib.inf

+  DefaultExceptionHandlerLib|ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandlerLibBase.inf

 

 [LibraryClasses.common.PEI_CORE]

   HobLib|MdePkg/Library/PeiHobLib/PeiHobLib.inf

@@ -400,7 +402,6 @@
   #

   MdeModulePkg/Universal/Disk/DiskIoDxe/DiskIoDxe.inf

   MdeModulePkg/Universal/Disk/PartitionDxe/PartitionDxe.inf

-  FatPkg/EnhancedFatDxe/Fat.inf

   MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf

   

   #

diff --git a/ArmPlatformPkg/ArmPlatformPkg.fdf b/ArmPlatformPkg/ArmPlatformPkg.fdf
index d829d404..41f6256e 100644
--- a/ArmPlatformPkg/ArmPlatformPkg.fdf
+++ b/ArmPlatformPkg/ArmPlatformPkg.fdf
@@ -1,302 +1,310 @@
-#
-#  Copyright (c) 2011, ARM Limited. All rights reserved.
-#  
-#  This program and the accompanying materials                          
-#  are licensed and made available under the terms and conditions of the BSD License         
-#  which accompanies this distribution.  The full text of the license may be found at        
-#  http://opensource.org/licenses/bsd-license.php                                            
-#
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-#
-
-################################################################################
-#
-# FD Section
-# The [FD] Section is made up of the definition statements and a
-# description of what goes into  the Flash Device Image.  Each FD section
-# defines one flash "device" image.  A flash device image may be one of
-# the following: Removable media bootable image (like a boot floppy
-# image,) an Option ROM image (that would be "flashed" into an add-in
-# card,) a System "Flash"  image (that would be burned into a system's
-# flash) or an Update ("Capsule") image that will be used to update and
-# existing system flash.
-#
-################################################################################
-
-[FD.Sec_ArmPlatform_EFI]
-BaseAddress   = 0xEC000000|gArmTokenSpaceGuid.PcdSecureFdBaseAddress  #The base address of the Secure FLASH Device.
-Size          = 0x00010000|gArmTokenSpaceGuid.PcdSecureFdSize         #The size in bytes of the Secure FLASH Device
-ErasePolarity = 1
-BlockSize     = 0x00001000
-NumBlocks     = 0x10
-
-################################################################################
-#
-# Following are lists of FD Region layout which correspond to the locations of different
-# images within the flash device.
-#
-# Regions must be defined in ascending order and may not overlap.
-#
-# A Layout Region start with a eight digit hex offset (leading "0x" required) followed by
-# the pipe "|" character, followed by the size of the region, also in hex with the leading
-# "0x" characters. Like:
-# Offset|Size
-# PcdOffsetCName|PcdSizeCName
-# RegionType <FV, DATA, or FILE>
-#
-################################################################################
-
-0x00000000|0x00010000
-gArmTokenSpaceGuid.PcdSecureFvBaseAddress|gArmTokenSpaceGuid.PcdSecureFvSize
-FV = FVMAIN_SEC
-
-
-[FD.ArmPlatform_EFI]
-BaseAddress   = 0xEC200000|gArmTokenSpaceGuid.PcdFdBaseAddress  # The base address of the Firmware in NOR Flash.
-Size          = 0x00200000|gArmTokenSpaceGuid.PcdFdSize         # The size in bytes of the FLASH Device
-ErasePolarity = 1
-
-# This one is tricky, it must be: BlockSize * NumBlocks = Size
-BlockSize     = 0x00001000
-NumBlocks     = 0x200
-
-################################################################################
-#
-# Following are lists of FD Region layout which correspond to the locations of different
-# images within the flash device.
-#
-# Regions must be defined in ascending order and may not overlap.
-#
-# A Layout Region start with a eight digit hex offset (leading "0x" required) followed by
-# the pipe "|" character, followed by the size of the region, also in hex with the leading
-# "0x" characters. Like:
-# Offset|Size
-# PcdOffsetCName|PcdSizeCName
-# RegionType <FV, DATA, or FILE>
-#
-################################################################################
-
-0x00000000|0x00200000
-gArmTokenSpaceGuid.PcdFvBaseAddress|gArmTokenSpaceGuid.PcdFvSize
-FV = FVMAIN_COMPACT
-
-
-################################################################################
-#
-# FV Section
-#
-# [FV] section is used to define what components or modules are placed within a flash
-# device file.  This section also defines order the components and modules are positioned
-# within the image.  The [FV] section consists of define statements, set statements and
-# module statements.
-#
-################################################################################
-
-[FV.FVMAIN_SEC]
-FvAlignment        = 8
-ERASE_POLARITY     = 1
-MEMORY_MAPPED      = TRUE
-STICKY_WRITE       = TRUE
-LOCK_CAP           = TRUE
-LOCK_STATUS        = TRUE
-WRITE_DISABLED_CAP = TRUE
-WRITE_ENABLED_CAP  = TRUE
-WRITE_STATUS       = TRUE
-WRITE_LOCK_CAP     = TRUE
-WRITE_LOCK_STATUS  = TRUE
-READ_DISABLED_CAP  = TRUE
-READ_ENABLED_CAP   = TRUE
-READ_STATUS        = TRUE
-READ_LOCK_CAP      = TRUE
-READ_LOCK_STATUS   = TRUE
-
-  INF ArmPlatformPkg/Sec/Sec.inf
-
-
-[FV.FvMain]
-BlockSize          = 0x40
-NumBlocks          = 0         # This FV gets compressed so make it just big enough
-FvAlignment        = 8         # FV alignment and FV attributes setting.
-ERASE_POLARITY     = 1
-MEMORY_MAPPED      = TRUE
-STICKY_WRITE       = TRUE
-LOCK_CAP           = TRUE
-LOCK_STATUS        = TRUE
-WRITE_DISABLED_CAP = TRUE
-WRITE_ENABLED_CAP  = TRUE
-WRITE_STATUS       = TRUE
-WRITE_LOCK_CAP     = TRUE
-WRITE_LOCK_STATUS  = TRUE
-READ_DISABLED_CAP  = TRUE
-READ_ENABLED_CAP   = TRUE
-READ_STATUS        = TRUE
-READ_LOCK_CAP      = TRUE
-READ_LOCK_STATUS   = TRUE
-
-  INF MdeModulePkg/Core/Dxe/DxeMain.inf 
-
-  #
-  # PI DXE Drivers producing Architectural Protocols (EFI Services) 
-  #
-  INF ArmPkg/Drivers/CpuDxe/CpuDxe.inf
-  INF MdeModulePkg/Core/RuntimeDxe/RuntimeDxe.inf
-  INF MdeModulePkg/Universal/SecurityStubDxe/SecurityStubDxe.inf
-  INF MdeModulePkg/Universal/WatchdogTimerDxe/WatchdogTimer.inf
-  INF MdeModulePkg/Universal/CapsuleRuntimeDxe/CapsuleRuntimeDxe.inf
-  INF MdeModulePkg/Universal/Variable/EmuRuntimeDxe/EmuVariableRuntimeDxe.inf
-  INF EmbeddedPkg/EmbeddedMonotonicCounter/EmbeddedMonotonicCounter.inf
-  INF EmbeddedPkg/ResetRuntimeDxe/ResetRuntimeDxe.inf
-  INF EmbeddedPkg/RealTimeClockRuntimeDxe/RealTimeClockRuntimeDxe.inf
-  INF EmbeddedPkg/MetronomeDxe/MetronomeDxe.inf
-
-  # Simple TextIn/TextOut for UEFI Terminal
-  INF EmbeddedPkg/SimpleTextInOutSerial/SimpleTextInOutSerial.inf
-  
-  #
-  # Semi-hosting filesystem (Required the Hardware Debugger to be connected)
-  #
-  INF ArmPkg/Filesystem/SemihostFs/SemihostFs.inf
-  
-  #
-  # FAT filesystem + GPT/MBR partitioning
-  #
-  INF MdeModulePkg/Universal/Disk/DiskIoDxe/DiskIoDxe.inf
-  INF MdeModulePkg/Universal/Disk/PartitionDxe/PartitionDxe.inf
-  INF FatPkg/EnhancedFatDxe/Fat.inf
-  INF MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf
-  
-  #
-  # UEFI application (Shell Embedded Boot Loader) 
-  #  
-  INF EmbeddedPkg/Ebl/Ebl.inf
-    
-  #
-  # Bds
-  #
-  INF MdeModulePkg/Universal/DevicePathDxe/DevicePathDxe.inf
-  INF ArmPlatformPkg/Bds/Bds.inf
-
-
-[FV.FVMAIN_COMPACT]
-FvAlignment        = 8
-ERASE_POLARITY     = 1
-MEMORY_MAPPED      = TRUE
-STICKY_WRITE       = TRUE
-LOCK_CAP           = TRUE
-LOCK_STATUS        = TRUE
-WRITE_DISABLED_CAP = TRUE
-WRITE_ENABLED_CAP  = TRUE
-WRITE_STATUS       = TRUE
-WRITE_LOCK_CAP     = TRUE
-WRITE_LOCK_STATUS  = TRUE
-READ_DISABLED_CAP  = TRUE
-READ_ENABLED_CAP   = TRUE
-READ_STATUS        = TRUE
-READ_LOCK_CAP      = TRUE
-READ_LOCK_STATUS   = TRUE
-
-  INF ArmPlatformPkg/PrePeiCore/PrePeiCoreUniCore.inf
-  INF MdeModulePkg/Core/Pei/PeiMain.inf
-  INF ArmPlatformPkg/PlatformPei/PlatformPeim.inf
-  INF ArmPlatformPkg/MemoryInitPei/MemoryInitPeim.inf
-  INF ArmPkg/Drivers/CpuPei/CpuPei.inf
-  INF MdeModulePkg/Universal/PCD/Pei/Pcd.inf
-  INF IntelFrameworkModulePkg/Universal/StatusCode/Pei/StatusCodePei.inf
-  INF MdeModulePkg/Universal/Variable/Pei/VariablePei.inf
-  INF MdeModulePkg/Core/DxeIplPeim/DxeIpl.inf
-  
-  FILE FV_IMAGE = 9E21FD93-9C72-4c15-8C4B-E77F1DB2D792 {
-    SECTION GUIDED EE4E5898-3914-4259-9D6E-DC7BD79403CF PROCESSING_REQUIRED = TRUE {
-      SECTION FV_IMAGE = FVMAIN
-    }
-  }
-
-
-################################################################################
-#
-# Rules are use with the [FV] section's module INF type to define
-# how an FFS file is created for a given INF file. The following Rule are the default
-# rules for the different module type. User can add the customized rules to define the
-# content of the FFS file.
-#
-################################################################################
-
-
-############################################################################
-# Example of a DXE_DRIVER FFS file with a Checksum encapsulation section   # 
-############################################################################
-#
-#[Rule.Common.DXE_DRIVER]
-#  FILE DRIVER = $(NAMED_GUID) {
-#    DXE_DEPEX    DXE_DEPEX               Optional $(INF_OUTPUT)/$(MODULE_NAME).depex
-#    COMPRESS PI_STD {
-#      GUIDED {
-#        PE32     PE32                    $(INF_OUTPUT)/$(MODULE_NAME).efi
-#        UI       STRING="$(MODULE_NAME)" Optional
-#        VERSION  STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)
-#      }
-#    }
-#  }
-#
-############################################################################
-
-[Rule.Common.SEC]
-  FILE SEC = $(NAMED_GUID) RELOCS_STRIPPED {
-    TE  TE    Align = 32                $(INF_OUTPUT)/$(MODULE_NAME).efi
-  }
-
-[Rule.Common.PEI_CORE]
-  FILE PEI_CORE = $(NAMED_GUID) {
-    TE     TE                           $(INF_OUTPUT)/$(MODULE_NAME).efi
-    UI     STRING ="$(MODULE_NAME)" Optional         
-  }
-
-[Rule.Common.PEIM]
-  FILE PEIM = $(NAMED_GUID) {
-     PEI_DEPEX PEI_DEPEX Optional       $(INF_OUTPUT)/$(MODULE_NAME).depex
-     TE       TE                        $(INF_OUTPUT)/$(MODULE_NAME).efi
-     UI       STRING="$(MODULE_NAME)" Optional         
-  }
-
-[Rule.Common.PEIM.TIANOCOMPRESSED]
-  FILE PEIM = $(NAMED_GUID) DEBUG_MYTOOLS_IA32 {
-    PEI_DEPEX PEI_DEPEX Optional        $(INF_OUTPUT)/$(MODULE_NAME).depex
-    GUIDED A31280AD-481E-41B6-95E8-127F4C984779 PROCESSING_REQUIRED = TRUE {
-      PE32      PE32                    $(INF_OUTPUT)/$(MODULE_NAME).efi
-      UI        STRING="$(MODULE_NAME)" Optional
-    }
-  }
-
-[Rule.Common.DXE_CORE]
-  FILE DXE_CORE = $(NAMED_GUID) {
-    PE32     PE32                       $(INF_OUTPUT)/$(MODULE_NAME).efi
-    UI       STRING="$(MODULE_NAME)" Optional
-  }
-
-[Rule.Common.UEFI_DRIVER]
-  FILE DRIVER = $(NAMED_GUID) {
-    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex
-    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi
-    UI           STRING="$(MODULE_NAME)" Optional
-  }
-
-[Rule.Common.DXE_DRIVER]
-  FILE DRIVER = $(NAMED_GUID) {
-    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex
-    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi
-    UI           STRING="$(MODULE_NAME)" Optional
-  }
-
-[Rule.Common.DXE_RUNTIME_DRIVER]
-  FILE DRIVER = $(NAMED_GUID) {
-    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex
-    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi
-    UI           STRING="$(MODULE_NAME)" Optional
-  }
-
-[Rule.Common.UEFI_APPLICATION]
-  FILE APPLICATION = $(NAMED_GUID) {
-    UI     STRING ="$(MODULE_NAME)" Optional         
-    PE32   PE32                         $(INF_OUTPUT)/$(MODULE_NAME).efi
-  }
+#

+#  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

+#  

+#  This program and the accompanying materials                          

+#  are licensed and made available under the terms and conditions of the BSD License         

+#  which accompanies this distribution.  The full text of the license may be found at        

+#  http://opensource.org/licenses/bsd-license.php                                            

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+#

+

+################################################################################

+#

+# FD Section

+# The [FD] Section is made up of the definition statements and a

+# description of what goes into  the Flash Device Image.  Each FD section

+# defines one flash "device" image.  A flash device image may be one of

+# the following: Removable media bootable image (like a boot floppy

+# image,) an Option ROM image (that would be "flashed" into an add-in

+# card,) a System "Flash"  image (that would be burned into a system's

+# flash) or an Update ("Capsule") image that will be used to update and

+# existing system flash.

+#

+################################################################################

+

+[FD.Sec_ArmPlatform_EFI]

+BaseAddress   = 0xEC000000|gArmTokenSpaceGuid.PcdSecureFdBaseAddress  #The base address of the Secure FLASH Device.

+Size          = 0x00015000|gArmTokenSpaceGuid.PcdSecureFdSize         #The size in bytes of the Secure FLASH Device

+ErasePolarity = 1

+BlockSize     = 0x00001500

+NumBlocks     = 0x10

+

+################################################################################

+#

+# Following are lists of FD Region layout which correspond to the locations of different

+# images within the flash device.

+#

+# Regions must be defined in ascending order and may not overlap.

+#

+# A Layout Region start with a eight digit hex offset (leading "0x" required) followed by

+# the pipe "|" character, followed by the size of the region, also in hex with the leading

+# "0x" characters. Like:

+# Offset|Size

+# PcdOffsetCName|PcdSizeCName

+# RegionType <FV, DATA, or FILE>

+#

+################################################################################

+

+0x00000000|0x00015000

+gArmTokenSpaceGuid.PcdSecureFvBaseAddress|gArmTokenSpaceGuid.PcdSecureFvSize

+FV = FVMAIN_SEC

+

+

+[FD.ArmPlatform_EFI]

+BaseAddress   = 0xEC200000|gArmTokenSpaceGuid.PcdFdBaseAddress  # The base address of the Firmware in NOR Flash.

+Size          = 0x00200000|gArmTokenSpaceGuid.PcdFdSize         # The size in bytes of the FLASH Device

+ErasePolarity = 1

+

+# This one is tricky, it must be: BlockSize * NumBlocks = Size

+BlockSize     = 0x00001000

+NumBlocks     = 0x200

+

+################################################################################

+#

+# Following are lists of FD Region layout which correspond to the locations of different

+# images within the flash device.

+#

+# Regions must be defined in ascending order and may not overlap.

+#

+# A Layout Region start with a eight digit hex offset (leading "0x" required) followed by

+# the pipe "|" character, followed by the size of the region, also in hex with the leading

+# "0x" characters. Like:

+# Offset|Size

+# PcdOffsetCName|PcdSizeCName

+# RegionType <FV, DATA, or FILE>

+#

+################################################################################

+

+0x00000000|0x00200000

+gArmTokenSpaceGuid.PcdFvBaseAddress|gArmTokenSpaceGuid.PcdFvSize

+FV = FVMAIN_COMPACT

+

+

+################################################################################

+#

+# FV Section

+#

+# [FV] section is used to define what components or modules are placed within a flash

+# device file.  This section also defines order the components and modules are positioned

+# within the image.  The [FV] section consists of define statements, set statements and

+# module statements.

+#

+################################################################################

+

+[FV.FVMAIN_SEC]

+FvAlignment        = 8

+ERASE_POLARITY     = 1

+MEMORY_MAPPED      = TRUE

+STICKY_WRITE       = TRUE

+LOCK_CAP           = TRUE

+LOCK_STATUS        = TRUE

+WRITE_DISABLED_CAP = TRUE

+WRITE_ENABLED_CAP  = TRUE

+WRITE_STATUS       = TRUE

+WRITE_LOCK_CAP     = TRUE

+WRITE_LOCK_STATUS  = TRUE

+READ_DISABLED_CAP  = TRUE

+READ_ENABLED_CAP   = TRUE

+READ_STATUS        = TRUE

+READ_LOCK_CAP      = TRUE

+READ_LOCK_STATUS   = TRUE

+

+  INF ArmPlatformPkg/Sec/Sec.inf

+

+

+[FV.FvMain]

+BlockSize          = 0x40

+NumBlocks          = 0         # This FV gets compressed so make it just big enough

+FvAlignment        = 8         # FV alignment and FV attributes setting.

+ERASE_POLARITY     = 1

+MEMORY_MAPPED      = TRUE

+STICKY_WRITE       = TRUE

+LOCK_CAP           = TRUE

+LOCK_STATUS        = TRUE

+WRITE_DISABLED_CAP = TRUE

+WRITE_ENABLED_CAP  = TRUE

+WRITE_STATUS       = TRUE

+WRITE_LOCK_CAP     = TRUE

+WRITE_LOCK_STATUS  = TRUE

+READ_DISABLED_CAP  = TRUE

+READ_ENABLED_CAP   = TRUE

+READ_STATUS        = TRUE

+READ_LOCK_CAP      = TRUE

+READ_LOCK_STATUS   = TRUE

+

+  INF MdeModulePkg/Core/Dxe/DxeMain.inf 

+

+  #

+  # PI DXE Drivers producing Architectural Protocols (EFI Services) 

+  #

+  INF ArmPkg/Drivers/CpuDxe/CpuDxe.inf

+  INF MdeModulePkg/Core/RuntimeDxe/RuntimeDxe.inf

+  INF MdeModulePkg/Universal/SecurityStubDxe/SecurityStubDxe.inf

+  INF MdeModulePkg/Universal/WatchdogTimerDxe/WatchdogTimer.inf

+  INF MdeModulePkg/Universal/CapsuleRuntimeDxe/CapsuleRuntimeDxe.inf

+  INF MdeModulePkg/Universal/Variable/EmuRuntimeDxe/EmuVariableRuntimeDxe.inf

+  INF EmbeddedPkg/EmbeddedMonotonicCounter/EmbeddedMonotonicCounter.inf

+  INF EmbeddedPkg/ResetRuntimeDxe/ResetRuntimeDxe.inf

+  INF EmbeddedPkg/RealTimeClockRuntimeDxe/RealTimeClockRuntimeDxe.inf

+  INF EmbeddedPkg/MetronomeDxe/MetronomeDxe.inf

+

+  # Simple TextIn/TextOut for UEFI Terminal

+  INF EmbeddedPkg/SimpleTextInOutSerial/SimpleTextInOutSerial.inf

+  

+  #

+  # Semi-hosting filesystem (Required the Hardware Debugger to be connected)

+  #

+  INF ArmPkg/Filesystem/SemihostFs/SemihostFs.inf

+  

+  #

+  # FAT filesystem + GPT/MBR partitioning

+  #

+  INF MdeModulePkg/Universal/Disk/DiskIoDxe/DiskIoDxe.inf

+  INF MdeModulePkg/Universal/Disk/PartitionDxe/PartitionDxe.inf

+  INF FatBinPkg/EnhancedFatDxe/Fat.inf

+  INF MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf

+  

+  #

+  # UEFI application (Shell Embedded Boot Loader) 

+  #  

+  INF EmbeddedPkg/Ebl/Ebl.inf

+    

+  #

+  # Bds

+  #

+  INF MdeModulePkg/Universal/DevicePathDxe/DevicePathDxe.inf

+  INF ArmPlatformPkg/Bds/Bds.inf

+

+

+[FV.FVMAIN_COMPACT]

+FvAlignment        = 8

+ERASE_POLARITY     = 1

+MEMORY_MAPPED      = TRUE

+STICKY_WRITE       = TRUE

+LOCK_CAP           = TRUE

+LOCK_STATUS        = TRUE

+WRITE_DISABLED_CAP = TRUE

+WRITE_ENABLED_CAP  = TRUE

+WRITE_STATUS       = TRUE

+WRITE_LOCK_CAP     = TRUE

+WRITE_LOCK_STATUS  = TRUE

+READ_DISABLED_CAP  = TRUE

+READ_ENABLED_CAP   = TRUE

+READ_STATUS        = TRUE

+READ_LOCK_CAP      = TRUE

+READ_LOCK_STATUS   = TRUE

+

+  INF ArmPlatformPkg/PrePeiCore/PrePeiCoreUniCore.inf

+  INF MdeModulePkg/Core/Pei/PeiMain.inf

+  INF ArmPlatformPkg/PlatformPei/PlatformPeim.inf

+  INF ArmPlatformPkg/MemoryInitPei/MemoryInitPeim.inf

+  INF ArmPkg/Drivers/CpuPei/CpuPei.inf

+  INF MdeModulePkg/Universal/PCD/Pei/Pcd.inf

+  INF IntelFrameworkModulePkg/Universal/StatusCode/Pei/StatusCodePei.inf

+  INF MdeModulePkg/Universal/Variable/Pei/VariablePei.inf

+  INF MdeModulePkg/Core/DxeIplPeim/DxeIpl.inf

+  

+  FILE FV_IMAGE = 9E21FD93-9C72-4c15-8C4B-E77F1DB2D792 {

+    SECTION GUIDED EE4E5898-3914-4259-9D6E-DC7BD79403CF PROCESSING_REQUIRED = TRUE {

+      SECTION FV_IMAGE = FVMAIN

+    }

+  }

+

+

+################################################################################

+#

+# Rules are use with the [FV] section's module INF type to define

+# how an FFS file is created for a given INF file. The following Rule are the default

+# rules for the different module type. User can add the customized rules to define the

+# content of the FFS file.

+#

+################################################################################

+

+

+############################################################################

+# Example of a DXE_DRIVER FFS file with a Checksum encapsulation section   # 

+############################################################################

+#

+#[Rule.Common.DXE_DRIVER]

+#  FILE DRIVER = $(NAMED_GUID) {

+#    DXE_DEPEX    DXE_DEPEX               Optional $(INF_OUTPUT)/$(MODULE_NAME).depex

+#    COMPRESS PI_STD {

+#      GUIDED {

+#        PE32     PE32                    $(INF_OUTPUT)/$(MODULE_NAME).efi

+#        UI       STRING="$(MODULE_NAME)" Optional

+#        VERSION  STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)

+#      }

+#    }

+#  }

+#

+############################################################################

+

+[Rule.Common.SEC]

+  FILE SEC = $(NAMED_GUID) RELOCS_STRIPPED {

+    TE  TE    Align = 32                $(INF_OUTPUT)/$(MODULE_NAME).efi

+  }

+

+[Rule.Common.PEI_CORE]

+  FILE PEI_CORE = $(NAMED_GUID) {

+    TE     TE                           $(INF_OUTPUT)/$(MODULE_NAME).efi

+    UI     STRING ="$(MODULE_NAME)" Optional         

+  }

+

+[Rule.Common.PEIM]

+  FILE PEIM = $(NAMED_GUID) {

+     PEI_DEPEX PEI_DEPEX Optional       $(INF_OUTPUT)/$(MODULE_NAME).depex

+     TE       TE                        $(INF_OUTPUT)/$(MODULE_NAME).efi

+     UI       STRING="$(MODULE_NAME)" Optional         

+  }

+

+[Rule.Common.PEIM.TIANOCOMPRESSED]

+  FILE PEIM = $(NAMED_GUID) DEBUG_MYTOOLS_IA32 {

+    PEI_DEPEX PEI_DEPEX Optional        $(INF_OUTPUT)/$(MODULE_NAME).depex

+    GUIDED A31280AD-481E-41B6-95E8-127F4C984779 PROCESSING_REQUIRED = TRUE {

+      PE32      PE32                    $(INF_OUTPUT)/$(MODULE_NAME).efi

+      UI        STRING="$(MODULE_NAME)" Optional

+    }

+  }

+

+[Rule.Common.DXE_CORE]

+  FILE DXE_CORE = $(NAMED_GUID) {

+    PE32     PE32                       $(INF_OUTPUT)/$(MODULE_NAME).efi

+    UI       STRING="$(MODULE_NAME)" Optional

+  }

+

+[Rule.Common.UEFI_DRIVER]

+  FILE DRIVER = $(NAMED_GUID) {

+    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex

+    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi

+    UI           STRING="$(MODULE_NAME)" Optional

+  }

+

+[Rule.Common.UEFI_DRIVER.BINARY]

+  FILE DRIVER = $(NAMED_GUID) {

+    DXE_DEPEX DXE_DEPEX Optional      |.depex

+    PE32      PE32                    |.efi

+    UI        STRING="$(MODULE_NAME)" Optional

+    VERSION   STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)

+  }

+

+[Rule.Common.DXE_DRIVER]

+  FILE DRIVER = $(NAMED_GUID) {

+    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex

+    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi

+    UI           STRING="$(MODULE_NAME)" Optional

+  }

+

+[Rule.Common.DXE_RUNTIME_DRIVER]

+  FILE DRIVER = $(NAMED_GUID) {

+    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex

+    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi

+    UI           STRING="$(MODULE_NAME)" Optional

+  }

+

+[Rule.Common.UEFI_APPLICATION]

+  FILE APPLICATION = $(NAMED_GUID) {

+    UI     STRING ="$(MODULE_NAME)" Optional         

+    PE32   PE32                         $(INF_OUTPUT)/$(MODULE_NAME).efi

+  }

diff --git a/ArmPlatformPkg/ArmRealViewEbPkg/ArmRealViewEb-RTSM-MPCore.fdf b/ArmPlatformPkg/ArmRealViewEbPkg/ArmRealViewEb-RTSM-MPCore.fdf
index 558e304f..70fc87bc 100644
--- a/ArmPlatformPkg/ArmRealViewEbPkg/ArmRealViewEb-RTSM-MPCore.fdf
+++ b/ArmPlatformPkg/ArmRealViewEbPkg/ArmRealViewEb-RTSM-MPCore.fdf
@@ -1,310 +1,310 @@
-# FLASH layout file for ARM VE.
-#
-#  Copyright (c) 2011, ARM Limited. All rights reserved.
-#  
-#  This program and the accompanying materials                          
-#  are licensed and made available under the terms and conditions of the BSD License         
-#  which accompanies this distribution.  The full text of the license may be found at        
-#  http://opensource.org/licenses/bsd-license.php                                            
-#
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-#
-
-################################################################################
-#
-# FD Section
-# The [FD] Section is made up of the definition statements and a
-# description of what goes into  the Flash Device Image.  Each FD section
-# defines one flash "device" image.  A flash device image may be one of
-# the following: Removable media bootable image (like a boot floppy
-# image,) an Option ROM image (that would be "flashed" into an add-in
-# card,) a System "Flash"  image (that would be burned into a system's
-# flash) or an Update ("Capsule") image that will be used to update and
-# existing system flash.
-#
-################################################################################
-
-
-[FD.ArmRealViewEb_EFI]
-BaseAddress   = 0x40000000|gArmTokenSpaceGuid.PcdFdBaseAddress
-Size          = 0x00200000|gArmTokenSpaceGuid.PcdFdSize
-ErasePolarity = 1
-BlockSize     = 0x00010000
-NumBlocks     = 0x20
-
-################################################################################
-#
-# Following are lists of FD Region layout which correspond to the locations of different
-# images within the flash device.
-#
-# Regions must be defined in ascending order and may not overlap.
-#
-# A Layout Region start with a eight digit hex offset (leading "0x" required) followed by
-# the pipe "|" character, followed by the size of the region, also in hex with the leading
-# "0x" characters. Like:
-# Offset|Size
-# PcdOffsetCName|PcdSizeCName
-# RegionType <FV, DATA, or FILE>
-#
-################################################################################
-
-0x00000000|0x00050000
-gArmTokenSpaceGuid.PcdSecureFvBaseAddress|gArmTokenSpaceGuid.PcdSecureFvSize
-FV = FVMAIN_SEC
-
-0x00050000|0x00100000
-gArmTokenSpaceGuid.PcdFvBaseAddress|gArmTokenSpaceGuid.PcdFvSize
-FV = FVMAIN_COMPACT
-
-################################################################################
-#
-# FV Section
-#
-# [FV] section is used to define what components or modules are placed within a flash
-# device file.  This section also defines order the components and modules are positioned
-# within the image.  The [FV] section consists of define statements, set statements and
-# module statements.
-#
-################################################################################
-
-[FV.FVMAIN_SEC]
-FvAlignment        = 8
-ERASE_POLARITY     = 1
-MEMORY_MAPPED      = TRUE
-STICKY_WRITE       = TRUE
-LOCK_CAP           = TRUE
-LOCK_STATUS        = TRUE
-WRITE_DISABLED_CAP = TRUE
-WRITE_ENABLED_CAP  = TRUE
-WRITE_STATUS       = TRUE
-WRITE_LOCK_CAP     = TRUE
-WRITE_LOCK_STATUS  = TRUE
-READ_DISABLED_CAP  = TRUE
-READ_ENABLED_CAP   = TRUE
-READ_STATUS        = TRUE
-READ_LOCK_CAP      = TRUE
-READ_LOCK_STATUS   = TRUE
-
-  INF ArmPlatformPkg/Sec/Sec.inf
-
-
-[FV.FvMain]
-BlockSize          = 0x40
-NumBlocks          = 0         # This FV gets compressed so make it just big enough
-FvAlignment        = 8         # FV alignment and FV attributes setting.
-ERASE_POLARITY     = 1
-MEMORY_MAPPED      = TRUE
-STICKY_WRITE       = TRUE
-LOCK_CAP           = TRUE
-LOCK_STATUS        = TRUE
-WRITE_DISABLED_CAP = TRUE
-WRITE_ENABLED_CAP  = TRUE
-WRITE_STATUS       = TRUE
-WRITE_LOCK_CAP     = TRUE
-WRITE_LOCK_STATUS  = TRUE
-READ_DISABLED_CAP  = TRUE
-READ_ENABLED_CAP   = TRUE
-READ_STATUS        = TRUE
-READ_LOCK_CAP      = TRUE
-READ_LOCK_STATUS   = TRUE
-
-  INF MdeModulePkg/Core/Dxe/DxeMain.inf 
-
-  #
-  # PI DXE Drivers producing Architectural Protocols (EFI Services) 
-  #
-  INF ArmPkg/Drivers/CpuDxe/CpuDxe.inf
-  INF MdeModulePkg/Core/RuntimeDxe/RuntimeDxe.inf
-  INF MdeModulePkg/Universal/SecurityStubDxe/SecurityStubDxe.inf
-  INF MdeModulePkg/Universal/WatchdogTimerDxe/WatchdogTimer.inf
-  INF MdeModulePkg/Universal/CapsuleRuntimeDxe/CapsuleRuntimeDxe.inf
-  INF MdeModulePkg/Universal/Variable/RuntimeDxe/VariableRuntimeDxe.inf
-  INF MdeModulePkg/Universal/FaultTolerantWriteDxe/FaultTolerantWriteDxe.inf
-  INF EmbeddedPkg/EmbeddedMonotonicCounter/EmbeddedMonotonicCounter.inf
-  INF EmbeddedPkg/ResetRuntimeDxe/ResetRuntimeDxe.inf
-  INF EmbeddedPkg/RealTimeClockRuntimeDxe/RealTimeClockRuntimeDxe.inf
-  INF EmbeddedPkg/MetronomeDxe/MetronomeDxe.inf
-
-  INF MdeModulePkg/Universal/HiiDatabaseDxe/HiiDatabaseDxe.inf
-  INF ArmPlatformPkg/Drivers/LcdGraphicsOutputDxe/PL111LcdGraphicsOutputDxe.inf
-
-  #
-  # Multiple Console IO support
-  #
-  INF MdeModulePkg/Universal/Console/ConPlatformDxe/ConPlatformDxe.inf
-  INF MdeModulePkg/Universal/Console/ConSplitterDxe/ConSplitterDxe.inf
-  INF MdeModulePkg/Universal/Console/GraphicsConsoleDxe/GraphicsConsoleDxe.inf
-  INF MdeModulePkg/Universal/Console/TerminalDxe/TerminalDxe.inf
-  INF EmbeddedPkg/SerialDxe/SerialDxe.inf
-  
-  INF ArmPkg/Drivers/PL390Gic/PL390GicDxe.inf
-  INF ArmPlatformPkg/Drivers/SP804TimerDxe/SP804TimerDxe.inf
-  
-  INF ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashDxe.inf
-
-  #
-  # Semi-hosting filesystem
-  #
-  INF ArmPkg/Filesystem/SemihostFs/SemihostFs.inf
-  
-  #
-  # FAT filesystem + GPT/MBR partitioning
-  #
-  INF MdeModulePkg/Universal/Disk/DiskIoDxe/DiskIoDxe.inf
-  INF MdeModulePkg/Universal/Disk/PartitionDxe/PartitionDxe.inf
-  INF FatBinPkg/EnhancedFatDxe/Fat.inf
-  INF MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf
-
-  #
-  # UEFI application (Shell Embedded Boot Loader) 
-  #  
-  INF ShellBinPkg/UefiShell/UefiShell.inf 
-
-  #
-  # Bds
-  #
-  INF MdeModulePkg/Universal/DevicePathDxe/DevicePathDxe.inf
-  INF ArmPlatformPkg/Bds/Bds.inf
-
-
-[FV.FVMAIN_COMPACT]
-FvAlignment        = 8
-ERASE_POLARITY     = 1
-MEMORY_MAPPED      = TRUE
-STICKY_WRITE       = TRUE
-LOCK_CAP           = TRUE
-LOCK_STATUS        = TRUE
-WRITE_DISABLED_CAP = TRUE
-WRITE_ENABLED_CAP  = TRUE
-WRITE_STATUS       = TRUE
-WRITE_LOCK_CAP     = TRUE
-WRITE_LOCK_STATUS  = TRUE
-READ_DISABLED_CAP  = TRUE
-READ_ENABLED_CAP   = TRUE
-READ_STATUS        = TRUE
-READ_LOCK_CAP      = TRUE
-READ_LOCK_STATUS   = TRUE
-
-!if $(EDK2_SKIP_PEICORE) == 1
-  INF ArmPlatformPkg/PrePi/PeiMPCore.inf
-!else
-  INF ArmPlatformPkg/PrePeiCore/PrePeiCoreMPCore.inf
-  INF MdeModulePkg/Core/Pei/PeiMain.inf
-  INF ArmPlatformPkg/PlatformPei/PlatformPeim.inf
-  INF ArmPlatformPkg/MemoryInitPei/MemoryInitPeim.inf
-  INF ArmPkg/Drivers/CpuPei/CpuPei.inf
-  INF MdeModulePkg/Universal/PCD/Pei/Pcd.inf
-  INF IntelFrameworkModulePkg/Universal/StatusCode/Pei/StatusCodePei.inf
-  INF MdeModulePkg/Universal/Variable/Pei/VariablePei.inf
-  INF MdeModulePkg/Core/DxeIplPeim/DxeIpl.inf
-!endif
-
-  FILE FV_IMAGE = 9E21FD93-9C72-4c15-8C4B-E77F1DB2D792 {
-    SECTION GUIDED EE4E5898-3914-4259-9D6E-DC7BD79403CF PROCESSING_REQUIRED = TRUE {
-      SECTION FV_IMAGE = FVMAIN
-    }
-  }
-
-################################################################################
-#
-# Rules are use with the [FV] section's module INF type to define
-# how an FFS file is created for a given INF file. The following Rule are the default
-# rules for the different module type. User can add the customized rules to define the
-# content of the FFS file.
-#
-################################################################################
-
-
-############################################################################
-# Example of a DXE_DRIVER FFS file with a Checksum encapsulation section   # 
-############################################################################
-#
-#[Rule.Common.DXE_DRIVER]
-#  FILE DRIVER = $(NAMED_GUID) {
-#    DXE_DEPEX    DXE_DEPEX               Optional $(INF_OUTPUT)/$(MODULE_NAME).depex
-#    COMPRESS PI_STD {
-#      GUIDED {
-#        PE32     PE32                    $(INF_OUTPUT)/$(MODULE_NAME).efi
-#        UI       STRING="$(MODULE_NAME)" Optional
-#        VERSION  STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)
-#      }
-#    }
-#  }
-#
-############################################################################
-
-[Rule.Common.SEC]
-  FILE SEC = $(NAMED_GUID) RELOCS_STRIPPED {
-    TE  TE    Align = 32                $(INF_OUTPUT)/$(MODULE_NAME).efi
-  }
-
-[Rule.Common.PEI_CORE]
-  FILE PEI_CORE = $(NAMED_GUID) {
-    TE     TE                           $(INF_OUTPUT)/$(MODULE_NAME).efi
-    UI     STRING ="$(MODULE_NAME)" Optional         
-  }
-
-[Rule.Common.PEIM]
-  FILE PEIM = $(NAMED_GUID) {
-     PEI_DEPEX PEI_DEPEX Optional       $(INF_OUTPUT)/$(MODULE_NAME).depex
-     TE       TE                        $(INF_OUTPUT)/$(MODULE_NAME).efi
-     UI       STRING="$(MODULE_NAME)" Optional         
-  }
-
-[Rule.Common.PEIM.TIANOCOMPRESSED]
-  FILE PEIM = $(NAMED_GUID) DEBUG_MYTOOLS_IA32 {
-    PEI_DEPEX PEI_DEPEX Optional        $(INF_OUTPUT)/$(MODULE_NAME).depex
-    GUIDED A31280AD-481E-41B6-95E8-127F4C984779 PROCESSING_REQUIRED = TRUE {
-      PE32      PE32                    $(INF_OUTPUT)/$(MODULE_NAME).efi
-      UI        STRING="$(MODULE_NAME)" Optional
-    }
-  }
-
-[Rule.Common.DXE_CORE]
-  FILE DXE_CORE = $(NAMED_GUID) {
-    PE32     PE32                       $(INF_OUTPUT)/$(MODULE_NAME).efi
-    UI       STRING="$(MODULE_NAME)" Optional
-  }
-
-[Rule.Common.UEFI_DRIVER]
-  FILE DRIVER = $(NAMED_GUID) {
-    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex
-    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi
-    UI           STRING="$(MODULE_NAME)" Optional
-  }
-
-[Rule.Common.DXE_DRIVER]
-  FILE DRIVER = $(NAMED_GUID) {
-    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex
-    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi
-    UI           STRING="$(MODULE_NAME)" Optional
-  }
-
-[Rule.Common.DXE_RUNTIME_DRIVER]
-  FILE DRIVER = $(NAMED_GUID) {
-    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex
-    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi
-    UI           STRING="$(MODULE_NAME)" Optional
-  }
-
-[Rule.Common.UEFI_APPLICATION]
-  FILE APPLICATION = $(NAMED_GUID) {
-    UI     STRING ="$(MODULE_NAME)" Optional         
-    PE32   PE32                         $(INF_OUTPUT)/$(MODULE_NAME).efi
-  }
-
-[Rule.Common.UEFI_DRIVER.BINARY]
-  FILE DRIVER = $(NAMED_GUID) {
-    DXE_DEPEX DXE_DEPEX Optional      |.depex
-    PE32      PE32                    |.efi
-    UI        STRING="$(MODULE_NAME)" Optional
-    VERSION   STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)
-  }
-
-[Rule.Common.UEFI_APPLICATION.BINARY]
-  FILE APPLICATION = $(NAMED_GUID) {
-    PE32      PE32                    |.efi
-    UI        STRING="$(MODULE_NAME)" Optional
-    VERSION   STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)
-  }
+# FLASH layout file for ARM VE.

+#

+#  Copyright (c) 2011, ARM Limited. All rights reserved.

+#  

+#  This program and the accompanying materials                          

+#  are licensed and made available under the terms and conditions of the BSD License         

+#  which accompanies this distribution.  The full text of the license may be found at        

+#  http://opensource.org/licenses/bsd-license.php                                            

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+#

+

+################################################################################

+#

+# FD Section

+# The [FD] Section is made up of the definition statements and a

+# description of what goes into  the Flash Device Image.  Each FD section

+# defines one flash "device" image.  A flash device image may be one of

+# the following: Removable media bootable image (like a boot floppy

+# image,) an Option ROM image (that would be "flashed" into an add-in

+# card,) a System "Flash"  image (that would be burned into a system's

+# flash) or an Update ("Capsule") image that will be used to update and

+# existing system flash.

+#

+################################################################################

+

+

+[FD.ArmRealViewEb_EFI]

+BaseAddress   = 0x40000000|gArmTokenSpaceGuid.PcdFdBaseAddress

+Size          = 0x00200000|gArmTokenSpaceGuid.PcdFdSize

+ErasePolarity = 1

+BlockSize     = 0x00010000

+NumBlocks     = 0x20

+

+################################################################################

+#

+# Following are lists of FD Region layout which correspond to the locations of different

+# images within the flash device.

+#

+# Regions must be defined in ascending order and may not overlap.

+#

+# A Layout Region start with a eight digit hex offset (leading "0x" required) followed by

+# the pipe "|" character, followed by the size of the region, also in hex with the leading

+# "0x" characters. Like:

+# Offset|Size

+# PcdOffsetCName|PcdSizeCName

+# RegionType <FV, DATA, or FILE>

+#

+################################################################################

+

+0x00000000|0x00050000

+gArmTokenSpaceGuid.PcdSecureFvBaseAddress|gArmTokenSpaceGuid.PcdSecureFvSize

+FV = FVMAIN_SEC

+

+0x00050000|0x00100000

+gArmTokenSpaceGuid.PcdFvBaseAddress|gArmTokenSpaceGuid.PcdFvSize

+FV = FVMAIN_COMPACT

+

+################################################################################

+#

+# FV Section

+#

+# [FV] section is used to define what components or modules are placed within a flash

+# device file.  This section also defines order the components and modules are positioned

+# within the image.  The [FV] section consists of define statements, set statements and

+# module statements.

+#

+################################################################################

+

+[FV.FVMAIN_SEC]

+FvAlignment        = 8

+ERASE_POLARITY     = 1

+MEMORY_MAPPED      = TRUE

+STICKY_WRITE       = TRUE

+LOCK_CAP           = TRUE

+LOCK_STATUS        = TRUE

+WRITE_DISABLED_CAP = TRUE

+WRITE_ENABLED_CAP  = TRUE

+WRITE_STATUS       = TRUE

+WRITE_LOCK_CAP     = TRUE

+WRITE_LOCK_STATUS  = TRUE

+READ_DISABLED_CAP  = TRUE

+READ_ENABLED_CAP   = TRUE

+READ_STATUS        = TRUE

+READ_LOCK_CAP      = TRUE

+READ_LOCK_STATUS   = TRUE

+

+  INF ArmPlatformPkg/Sec/Sec.inf

+

+

+[FV.FvMain]

+BlockSize          = 0x40

+NumBlocks          = 0         # This FV gets compressed so make it just big enough

+FvAlignment        = 8         # FV alignment and FV attributes setting.

+ERASE_POLARITY     = 1

+MEMORY_MAPPED      = TRUE

+STICKY_WRITE       = TRUE

+LOCK_CAP           = TRUE

+LOCK_STATUS        = TRUE

+WRITE_DISABLED_CAP = TRUE

+WRITE_ENABLED_CAP  = TRUE

+WRITE_STATUS       = TRUE

+WRITE_LOCK_CAP     = TRUE

+WRITE_LOCK_STATUS  = TRUE

+READ_DISABLED_CAP  = TRUE

+READ_ENABLED_CAP   = TRUE

+READ_STATUS        = TRUE

+READ_LOCK_CAP      = TRUE

+READ_LOCK_STATUS   = TRUE

+

+  INF MdeModulePkg/Core/Dxe/DxeMain.inf 

+

+  #

+  # PI DXE Drivers producing Architectural Protocols (EFI Services) 

+  #

+  INF ArmPkg/Drivers/CpuDxe/CpuDxe.inf

+  INF MdeModulePkg/Core/RuntimeDxe/RuntimeDxe.inf

+  INF MdeModulePkg/Universal/SecurityStubDxe/SecurityStubDxe.inf

+  INF MdeModulePkg/Universal/WatchdogTimerDxe/WatchdogTimer.inf

+  INF MdeModulePkg/Universal/CapsuleRuntimeDxe/CapsuleRuntimeDxe.inf

+  INF MdeModulePkg/Universal/Variable/RuntimeDxe/VariableRuntimeDxe.inf

+  INF MdeModulePkg/Universal/FaultTolerantWriteDxe/FaultTolerantWriteDxe.inf

+  INF EmbeddedPkg/EmbeddedMonotonicCounter/EmbeddedMonotonicCounter.inf

+  INF EmbeddedPkg/ResetRuntimeDxe/ResetRuntimeDxe.inf

+  INF EmbeddedPkg/RealTimeClockRuntimeDxe/RealTimeClockRuntimeDxe.inf

+  INF EmbeddedPkg/MetronomeDxe/MetronomeDxe.inf

+

+  INF MdeModulePkg/Universal/HiiDatabaseDxe/HiiDatabaseDxe.inf

+  INF ArmPlatformPkg/Drivers/LcdGraphicsOutputDxe/PL111LcdGraphicsOutputDxe.inf

+

+  #

+  # Multiple Console IO support

+  #

+  INF MdeModulePkg/Universal/Console/ConPlatformDxe/ConPlatformDxe.inf

+  INF MdeModulePkg/Universal/Console/ConSplitterDxe/ConSplitterDxe.inf

+  INF MdeModulePkg/Universal/Console/GraphicsConsoleDxe/GraphicsConsoleDxe.inf

+  INF MdeModulePkg/Universal/Console/TerminalDxe/TerminalDxe.inf

+  INF EmbeddedPkg/SerialDxe/SerialDxe.inf

+  

+  INF ArmPkg/Drivers/PL390Gic/PL390GicDxe.inf

+  INF ArmPlatformPkg/Drivers/SP804TimerDxe/SP804TimerDxe.inf

+  

+  INF ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashDxe.inf

+

+  #

+  # Semi-hosting filesystem

+  #

+  INF ArmPkg/Filesystem/SemihostFs/SemihostFs.inf

+  

+  #

+  # FAT filesystem + GPT/MBR partitioning

+  #

+  INF MdeModulePkg/Universal/Disk/DiskIoDxe/DiskIoDxe.inf

+  INF MdeModulePkg/Universal/Disk/PartitionDxe/PartitionDxe.inf

+  INF FatBinPkg/EnhancedFatDxe/Fat.inf

+  INF MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf

+

+  #

+  # UEFI application (Shell Embedded Boot Loader) 

+  #  

+  INF ShellBinPkg/UefiShell/UefiShell.inf 

+

+  #

+  # Bds

+  #

+  INF MdeModulePkg/Universal/DevicePathDxe/DevicePathDxe.inf

+  INF ArmPlatformPkg/Bds/Bds.inf

+

+

+[FV.FVMAIN_COMPACT]

+FvAlignment        = 8

+ERASE_POLARITY     = 1

+MEMORY_MAPPED      = TRUE

+STICKY_WRITE       = TRUE

+LOCK_CAP           = TRUE

+LOCK_STATUS        = TRUE

+WRITE_DISABLED_CAP = TRUE

+WRITE_ENABLED_CAP  = TRUE

+WRITE_STATUS       = TRUE

+WRITE_LOCK_CAP     = TRUE

+WRITE_LOCK_STATUS  = TRUE

+READ_DISABLED_CAP  = TRUE

+READ_ENABLED_CAP   = TRUE

+READ_STATUS        = TRUE

+READ_LOCK_CAP      = TRUE

+READ_LOCK_STATUS   = TRUE

+

+!if $(EDK2_SKIP_PEICORE) == 1

+  INF ArmPlatformPkg/PrePi/PeiMPCore.inf

+!else

+  INF ArmPlatformPkg/PrePeiCore/PrePeiCoreMPCore.inf

+  INF MdeModulePkg/Core/Pei/PeiMain.inf

+  INF ArmPlatformPkg/PlatformPei/PlatformPeim.inf

+  INF ArmPlatformPkg/MemoryInitPei/MemoryInitPeim.inf

+  INF ArmPkg/Drivers/CpuPei/CpuPei.inf

+  INF MdeModulePkg/Universal/PCD/Pei/Pcd.inf

+  INF IntelFrameworkModulePkg/Universal/StatusCode/Pei/StatusCodePei.inf

+  INF MdeModulePkg/Universal/Variable/Pei/VariablePei.inf

+  INF MdeModulePkg/Core/DxeIplPeim/DxeIpl.inf

+!endif

+

+  FILE FV_IMAGE = 9E21FD93-9C72-4c15-8C4B-E77F1DB2D792 {

+    SECTION GUIDED EE4E5898-3914-4259-9D6E-DC7BD79403CF PROCESSING_REQUIRED = TRUE {

+      SECTION FV_IMAGE = FVMAIN

+    }

+  }

+

+################################################################################

+#

+# Rules are use with the [FV] section's module INF type to define

+# how an FFS file is created for a given INF file. The following Rule are the default

+# rules for the different module type. User can add the customized rules to define the

+# content of the FFS file.

+#

+################################################################################

+

+

+############################################################################

+# Example of a DXE_DRIVER FFS file with a Checksum encapsulation section   # 

+############################################################################

+#

+#[Rule.Common.DXE_DRIVER]

+#  FILE DRIVER = $(NAMED_GUID) {

+#    DXE_DEPEX    DXE_DEPEX               Optional $(INF_OUTPUT)/$(MODULE_NAME).depex

+#    COMPRESS PI_STD {

+#      GUIDED {

+#        PE32     PE32                    $(INF_OUTPUT)/$(MODULE_NAME).efi

+#        UI       STRING="$(MODULE_NAME)" Optional

+#        VERSION  STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)

+#      }

+#    }

+#  }

+#

+############################################################################

+

+[Rule.Common.SEC]

+  FILE SEC = $(NAMED_GUID) RELOCS_STRIPPED {

+    TE  TE    Align = 32                $(INF_OUTPUT)/$(MODULE_NAME).efi

+  }

+

+[Rule.Common.PEI_CORE]

+  FILE PEI_CORE = $(NAMED_GUID) {

+    TE     TE                           $(INF_OUTPUT)/$(MODULE_NAME).efi

+    UI     STRING ="$(MODULE_NAME)" Optional         

+  }

+

+[Rule.Common.PEIM]

+  FILE PEIM = $(NAMED_GUID) {

+     PEI_DEPEX PEI_DEPEX Optional       $(INF_OUTPUT)/$(MODULE_NAME).depex

+     TE       TE                        $(INF_OUTPUT)/$(MODULE_NAME).efi

+     UI       STRING="$(MODULE_NAME)" Optional         

+  }

+

+[Rule.Common.PEIM.TIANOCOMPRESSED]

+  FILE PEIM = $(NAMED_GUID) DEBUG_MYTOOLS_IA32 {

+    PEI_DEPEX PEI_DEPEX Optional        $(INF_OUTPUT)/$(MODULE_NAME).depex

+    GUIDED A31280AD-481E-41B6-95E8-127F4C984779 PROCESSING_REQUIRED = TRUE {

+      PE32      PE32                    $(INF_OUTPUT)/$(MODULE_NAME).efi

+      UI        STRING="$(MODULE_NAME)" Optional

+    }

+  }

+

+[Rule.Common.DXE_CORE]

+  FILE DXE_CORE = $(NAMED_GUID) {

+    PE32     PE32                       $(INF_OUTPUT)/$(MODULE_NAME).efi

+    UI       STRING="$(MODULE_NAME)" Optional

+  }

+

+[Rule.Common.UEFI_DRIVER]

+  FILE DRIVER = $(NAMED_GUID) {

+    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex

+    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi

+    UI           STRING="$(MODULE_NAME)" Optional

+  }

+

+[Rule.Common.DXE_DRIVER]

+  FILE DRIVER = $(NAMED_GUID) {

+    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex

+    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi

+    UI           STRING="$(MODULE_NAME)" Optional

+  }

+

+[Rule.Common.DXE_RUNTIME_DRIVER]

+  FILE DRIVER = $(NAMED_GUID) {

+    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex

+    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi

+    UI           STRING="$(MODULE_NAME)" Optional

+  }

+

+[Rule.Common.UEFI_APPLICATION]

+  FILE APPLICATION = $(NAMED_GUID) {

+    UI     STRING ="$(MODULE_NAME)" Optional         

+    PE32   PE32                         $(INF_OUTPUT)/$(MODULE_NAME).efi

+  }

+

+[Rule.Common.UEFI_DRIVER.BINARY]

+  FILE DRIVER = $(NAMED_GUID) {

+    DXE_DEPEX DXE_DEPEX Optional      |.depex

+    PE32      PE32                    |.efi

+    UI        STRING="$(MODULE_NAME)" Optional

+    VERSION   STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)

+  }

+

+[Rule.Common.UEFI_APPLICATION.BINARY]

+  FILE APPLICATION = $(NAMED_GUID) {

+    PE32      PE32                    |.efi

+    UI        STRING="$(MODULE_NAME)" Optional

+    VERSION   STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)

+  }

diff --git a/ArmPlatformPkg/ArmRealViewEbPkg/ArmRealViewEb.dsc.inc b/ArmPlatformPkg/ArmRealViewEbPkg/ArmRealViewEb.dsc.inc
index 385d296d..bc4807f3 100644
--- a/ArmPlatformPkg/ArmRealViewEbPkg/ArmRealViewEb.dsc.inc
+++ b/ArmPlatformPkg/ArmRealViewEbPkg/ArmRealViewEb.dsc.inc
@@ -61,11 +61,13 @@
   ArmDisassemblerLib|ArmPkg/Library/ArmDisassemblerLib/ArmDisassemblerLib.inf

   DmaLib|ArmPkg/Library/ArmDmaLib/ArmDmaLib.inf

   ArmGicLib|ArmPkg/Drivers/PL390Gic/PL390GicLib.inf

+  ArmSmcLib|ArmPkg/Library/ArmSmcLib/ArmSmcLib.inf

 

   # RealView Emulation Board Specific Libraries

   EfiResetSystemLib|ArmPlatformPkg/ArmRealViewEbPkg/Library/ResetSystemLib/ResetSystemLib.inf

   RealTimeClockLib|ArmPlatformPkg/Library/PL031RealTimeClockLib/PL031RealTimeClockLib.inf

   SerialPortLib|ArmPlatformPkg/Library/PL011SerialPortLib/PL011SerialPortLib.inf

+  SerialPortExtLib|ArmPlatformPkg/Library/PL011SerialPortLib/PL011SerialPortExtLib.inf

   TimerLib|ArmPlatformPkg/Library/SP804TimerLib/SP804TimerLib.inf  

   # ARM PL011 UART Driver

   PL011UartLib|ArmPlatformPkg/Drivers/PL011Uart/PL011Uart.inf

diff --git a/ArmPlatformPkg/ArmRealViewEbPkg/Library/ArmRealViewEbLibRTSM/ArmRealViewEb.c b/ArmPlatformPkg/ArmRealViewEbPkg/Library/ArmRealViewEbLibRTSM/ArmRealViewEb.c
index a5fb26a3..77d48acc 100644
--- a/ArmPlatformPkg/ArmRealViewEbPkg/Library/ArmRealViewEbLibRTSM/ArmRealViewEb.c
+++ b/ArmPlatformPkg/ArmRealViewEbPkg/Library/ArmRealViewEbLibRTSM/ArmRealViewEb.c
@@ -1,146 +1,146 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-#include <Library/IoLib.h>
-#include <Library/ArmLib.h>
-#include <Library/ArmPlatformLib.h>
-#include <Library/DebugLib.h>
-#include <Library/PcdLib.h>
-
-#include <Drivers/PL341Dmc.h>
-#include <Drivers/SP804Timer.h>
-
-#include <Ppi/ArmMpCoreInfo.h>
-
-#include <ArmPlatform.h>
-
-ARM_CORE_INFO mRealViewEbMpCoreInfoTable[] = {
-  {
-    // Cluster 0, Core 0
-    0x0, 0x0,
-
-    // MP Core MailBox Set/Get/Clear Addresses and Clear Value
-    (EFI_PHYSICAL_ADDRESS)ARM_EB_SYS_FLAGS_REG,
-    (EFI_PHYSICAL_ADDRESS)ARM_EB_SYS_FLAGS_SET_REG,
-    (EFI_PHYSICAL_ADDRESS)ARM_EB_SYS_FLAGS_CLR_REG,
-    (UINT64)0xFFFFFFFF
-  },
-  {
-    // Cluster 0, Core 1
-    0x0, 0x1,
-
-    // MP Core MailBox Set/Get/Clear Addresses and Clear Value
-    (EFI_PHYSICAL_ADDRESS)ARM_EB_SYS_FLAGS_REG,
-    (EFI_PHYSICAL_ADDRESS)ARM_EB_SYS_FLAGS_SET_REG,
-    (EFI_PHYSICAL_ADDRESS)ARM_EB_SYS_FLAGS_CLR_REG,
-    (UINT64)0xFFFFFFFF
-  }
-};
-
-/**
-  Return the current Boot Mode
-
-  This function returns the boot reason on the platform
-
-**/
-EFI_BOOT_MODE
-ArmPlatformGetBootMode (
-  VOID
-  )
-{
-  return BOOT_WITH_FULL_CONFIGURATION;
-}
-
-/**
-  Initialize controllers that must setup in the normal world
-
-  This function is called by the ArmPlatformPkg/PrePi or ArmPlatformPkg/PlatformPei
-  in the PEI phase.
-
-**/
-RETURN_STATUS
-ArmPlatformInitialize (
-  IN  UINTN                     MpId
-  )
-{
-  if (!IS_PRIMARY_CORE(MpId)) {
-    return RETURN_SUCCESS;
-  }
-
-  // Disable memory remapping and return to normal mapping
-  MmioOr32 (ARM_EB_SYSCTRL, BIT8); //EB_SP810_CTRL_BASE
-
-  // Configure periodic timer (TIMER0) for 1MHz operation
-  MmioOr32 (SP810_CTRL_BASE + SP810_SYS_CTRL_REG, SP810_SYS_CTRL_TIMER0_TIMCLK);
-  // Configure 1MHz clock
-  MmioOr32 (SP810_CTRL_BASE + SP810_SYS_CTRL_REG, SP810_SYS_CTRL_TIMER1_TIMCLK);
-  // configure SP810 to use 1MHz clock and disable
-  MmioAndThenOr32 (SP810_CTRL_BASE + SP810_SYS_CTRL_REG, ~SP810_SYS_CTRL_TIMER2_EN, SP810_SYS_CTRL_TIMER2_TIMCLK);
-  // Configure SP810 to use 1MHz clock and disable
-  MmioAndThenOr32 (SP810_CTRL_BASE + SP810_SYS_CTRL_REG, ~SP810_SYS_CTRL_TIMER3_EN, SP810_SYS_CTRL_TIMER3_TIMCLK);
-
-  return RETURN_SUCCESS;
-}
-
-/**
-  Initialize the system (or sometimes called permanent) memory
-
-  This memory is generally represented by the DRAM.
-
-**/
-VOID
-ArmPlatformInitializeSystemMemory (
-  VOID
-  )
-{
-  // We do not need to initialize the System Memory on RTSM
-}
-
-EFI_STATUS
-PrePeiCoreGetMpCoreInfo (
-  OUT UINTN                   *CoreCount,
-  OUT ARM_CORE_INFO           **ArmCoreTable
-  )
-{
-  if ((MmioRead32 (ARM_EB_SYS_PROCID0_REG) & ARM_EB_SYS_PROC_ID_MASK) == ARM_EB_SYS_PROC_ID_CORTEX_A9) {
-    *CoreCount    = sizeof(mRealViewEbMpCoreInfoTable) / sizeof(ARM_CORE_INFO);
-    *ArmCoreTable = mRealViewEbMpCoreInfoTable;
-    return EFI_SUCCESS;
-  } else {
-    return EFI_UNSUPPORTED;
-  }
-}
-
-// Needs to be declared in the file. Otherwise gArmMpCoreInfoPpiGuid is undefined in the contect of PrePeiCore
-EFI_GUID mArmMpCoreInfoPpiGuid = ARM_MP_CORE_INFO_PPI_GUID;
-ARM_MP_CORE_INFO_PPI mMpCoreInfoPpi = { PrePeiCoreGetMpCoreInfo };
-
-EFI_PEI_PPI_DESCRIPTOR      gPlatformPpiTable[] = {
-  {
-    EFI_PEI_PPI_DESCRIPTOR_PPI,
-    &mArmMpCoreInfoPpiGuid,
-    &mMpCoreInfoPpi
-  }
-};
-
-VOID
-ArmPlatformGetPlatformPpiList (
-  OUT UINTN                   *PpiListSize,
-  OUT EFI_PEI_PPI_DESCRIPTOR  **PpiList
-  )
-{
-  *PpiListSize = sizeof(gPlatformPpiTable);
-  *PpiList = gPlatformPpiTable;
-}
-
+/** @file

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+#include <Library/IoLib.h>

+#include <Library/ArmLib.h>

+#include <Library/ArmPlatformLib.h>

+#include <Library/DebugLib.h>

+#include <Library/PcdLib.h>

+

+#include <Drivers/PL341Dmc.h>

+#include <Drivers/SP804Timer.h>

+

+#include <Ppi/ArmMpCoreInfo.h>

+

+#include <ArmPlatform.h>

+

+ARM_CORE_INFO mRealViewEbMpCoreInfoTable[] = {

+  {

+    // Cluster 0, Core 0

+    0x0, 0x0,

+

+    // MP Core MailBox Set/Get/Clear Addresses and Clear Value

+    (EFI_PHYSICAL_ADDRESS)ARM_EB_SYS_FLAGS_REG,

+    (EFI_PHYSICAL_ADDRESS)ARM_EB_SYS_FLAGS_SET_REG,

+    (EFI_PHYSICAL_ADDRESS)ARM_EB_SYS_FLAGS_CLR_REG,

+    (UINT64)0xFFFFFFFF

+  },

+  {

+    // Cluster 0, Core 1

+    0x0, 0x1,

+

+    // MP Core MailBox Set/Get/Clear Addresses and Clear Value

+    (EFI_PHYSICAL_ADDRESS)ARM_EB_SYS_FLAGS_REG,

+    (EFI_PHYSICAL_ADDRESS)ARM_EB_SYS_FLAGS_SET_REG,

+    (EFI_PHYSICAL_ADDRESS)ARM_EB_SYS_FLAGS_CLR_REG,

+    (UINT64)0xFFFFFFFF

+  }

+};

+

+/**

+  Return the current Boot Mode

+

+  This function returns the boot reason on the platform

+

+**/

+EFI_BOOT_MODE

+ArmPlatformGetBootMode (

+  VOID

+  )

+{

+  return BOOT_WITH_FULL_CONFIGURATION;

+}

+

+/**

+  Initialize controllers that must setup in the normal world

+

+  This function is called by the ArmPlatformPkg/PrePi or ArmPlatformPkg/PlatformPei

+  in the PEI phase.

+

+**/

+RETURN_STATUS

+ArmPlatformInitialize (

+  IN  UINTN                     MpId

+  )

+{

+  if (!IS_PRIMARY_CORE(MpId)) {

+    return RETURN_SUCCESS;

+  }

+

+  // Disable memory remapping and return to normal mapping

+  MmioOr32 (ARM_EB_SYSCTRL, BIT8); //EB_SP810_CTRL_BASE

+

+  // Configure periodic timer (TIMER0) for 1MHz operation

+  MmioOr32 (SP810_CTRL_BASE + SP810_SYS_CTRL_REG, SP810_SYS_CTRL_TIMER0_TIMCLK);

+  // Configure 1MHz clock

+  MmioOr32 (SP810_CTRL_BASE + SP810_SYS_CTRL_REG, SP810_SYS_CTRL_TIMER1_TIMCLK);

+  // configure SP810 to use 1MHz clock and disable

+  MmioAndThenOr32 (SP810_CTRL_BASE + SP810_SYS_CTRL_REG, ~SP810_SYS_CTRL_TIMER2_EN, SP810_SYS_CTRL_TIMER2_TIMCLK);

+  // Configure SP810 to use 1MHz clock and disable

+  MmioAndThenOr32 (SP810_CTRL_BASE + SP810_SYS_CTRL_REG, ~SP810_SYS_CTRL_TIMER3_EN, SP810_SYS_CTRL_TIMER3_TIMCLK);

+

+  return RETURN_SUCCESS;

+}

+

+/**

+  Initialize the system (or sometimes called permanent) memory

+

+  This memory is generally represented by the DRAM.

+

+**/

+VOID

+ArmPlatformInitializeSystemMemory (

+  VOID

+  )

+{

+  // We do not need to initialize the System Memory on RTSM

+}

+

+EFI_STATUS

+PrePeiCoreGetMpCoreInfo (

+  OUT UINTN                   *CoreCount,

+  OUT ARM_CORE_INFO           **ArmCoreTable

+  )

+{

+  if ((MmioRead32 (ARM_EB_SYS_PROCID0_REG) & ARM_EB_SYS_PROC_ID_MASK) == ARM_EB_SYS_PROC_ID_CORTEX_A9) {

+    *CoreCount    = sizeof(mRealViewEbMpCoreInfoTable) / sizeof(ARM_CORE_INFO);

+    *ArmCoreTable = mRealViewEbMpCoreInfoTable;

+    return EFI_SUCCESS;

+  } else {

+    return EFI_UNSUPPORTED;

+  }

+}

+

+// Needs to be declared in the file. Otherwise gArmMpCoreInfoPpiGuid is undefined in the contect of PrePeiCore

+EFI_GUID mArmMpCoreInfoPpiGuid = ARM_MP_CORE_INFO_PPI_GUID;

+ARM_MP_CORE_INFO_PPI mMpCoreInfoPpi = { PrePeiCoreGetMpCoreInfo };

+

+EFI_PEI_PPI_DESCRIPTOR      gPlatformPpiTable[] = {

+  {

+    EFI_PEI_PPI_DESCRIPTOR_PPI,

+    &mArmMpCoreInfoPpiGuid,

+    &mMpCoreInfoPpi

+  }

+};

+

+VOID

+ArmPlatformGetPlatformPpiList (

+  OUT UINTN                   *PpiListSize,

+  OUT EFI_PEI_PPI_DESCRIPTOR  **PpiList

+  )

+{

+  *PpiListSize = sizeof(gPlatformPpiTable);

+  *PpiList = gPlatformPpiTable;

+}

+

diff --git a/ArmPlatformPkg/ArmRealViewEbPkg/Library/ArmRealViewEbSecLibRTSM/ArmRealViewEbSec.c b/ArmPlatformPkg/ArmRealViewEbPkg/Library/ArmRealViewEbSecLibRTSM/ArmRealViewEbSec.c
index 10dcef92..033c9d7e 100644
--- a/ArmPlatformPkg/ArmRealViewEbPkg/Library/ArmRealViewEbSecLibRTSM/ArmRealViewEbSec.c
+++ b/ArmPlatformPkg/ArmRealViewEbPkg/Library/ArmRealViewEbSecLibRTSM/ArmRealViewEbSec.c
@@ -1,76 +1,76 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-#include <Library/IoLib.h>
-#include <Library/ArmLib.h>
-#include <Library/ArmPlatformSecLib.h>
-#include <Library/DebugLib.h>
-#include <Library/PcdLib.h>
-
-#include <Drivers/PL341Dmc.h>
-#include <Drivers/SP804Timer.h>
-
-#include <ArmPlatform.h>
-
-/**
-  Initialize the Secure peripherals and memory regions
-
-  If Trustzone is supported by your platform then this function makes the required initialization
-  of the secure peripherals and memory regions.
-
-**/
-VOID
-ArmPlatformSecTrustzoneInit (
-  IN  UINTN                     MpId
-  )
-{
-  ASSERT(FALSE);
-}
-
-/**
-  Initialize controllers that must setup at the early stage
-
-  Some peripherals must be initialized in Secure World.
-  For example, some L2x0 requires to be initialized in Secure World
-
-**/
-RETURN_STATUS
-ArmPlatformSecInitialize (
-  IN  UINTN                     MpId
-  )
-{
-  // If it is not the primary core then there is nothing to do
-  if (!IS_PRIMARY_CORE(MpId)) {
-    return RETURN_SUCCESS;
-  }
-
-  // Do nothing yet
-  return RETURN_SUCCESS;
-}
-
-/**
-  Call before jumping to Normal World
-
-  This function allows the firmware platform to do extra actions before
-  jumping to the Normal World
-
-**/
-VOID
-ArmPlatformSecExtraAction (
-  IN  UINTN         MpId,
-  OUT UINTN*        JumpAddress
-  )
-{
-  *JumpAddress = PcdGet32(PcdFvBaseAddress);
-}
+/** @file

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+#include <Library/IoLib.h>

+#include <Library/ArmLib.h>

+#include <Library/ArmPlatformSecLib.h>

+#include <Library/DebugLib.h>

+#include <Library/PcdLib.h>

+

+#include <Drivers/PL341Dmc.h>

+#include <Drivers/SP804Timer.h>

+

+#include <ArmPlatform.h>

+

+/**

+  Initialize the Secure peripherals and memory regions

+

+  If Trustzone is supported by your platform then this function makes the required initialization

+  of the secure peripherals and memory regions.

+

+**/

+VOID

+ArmPlatformSecTrustzoneInit (

+  IN  UINTN                     MpId

+  )

+{

+  ASSERT(FALSE);

+}

+

+/**

+  Initialize controllers that must setup at the early stage

+

+  Some peripherals must be initialized in Secure World.

+  For example, some L2x0 requires to be initialized in Secure World

+

+**/

+RETURN_STATUS

+ArmPlatformSecInitialize (

+  IN  UINTN                     MpId

+  )

+{

+  // If it is not the primary core then there is nothing to do

+  if (!IS_PRIMARY_CORE(MpId)) {

+    return RETURN_SUCCESS;

+  }

+

+  // Do nothing yet

+  return RETURN_SUCCESS;

+}

+

+/**

+  Call before jumping to Normal World

+

+  This function allows the firmware platform to do extra actions before

+  jumping to the Normal World

+

+**/

+VOID

+ArmPlatformSecExtraAction (

+  IN  UINTN         MpId,

+  OUT UINTN*        JumpAddress

+  )

+{

+  *JumpAddress = PcdGet32(PcdFvBaseAddress);

+}

diff --git a/ArmPlatformPkg/ArmRealViewEbPkg/Library/NorFlashArmRealViewEbLib/NorFlashArmRealViewEbLib.inf b/ArmPlatformPkg/ArmRealViewEbPkg/Library/NorFlashArmRealViewEbLib/NorFlashArmRealViewEbLib.inf
index 9a68da96..48dd960c 100644
--- a/ArmPlatformPkg/ArmRealViewEbPkg/Library/NorFlashArmRealViewEbLib/NorFlashArmRealViewEbLib.inf
+++ b/ArmPlatformPkg/ArmRealViewEbPkg/Library/NorFlashArmRealViewEbLib/NorFlashArmRealViewEbLib.inf
@@ -1,35 +1,35 @@
-#/** @file
-#  
-#  Component description file for NorFlashArmRealViewEbLib module
-#  
-#  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>
-#
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = NorFlashArmRealViewEbLib
-  FILE_GUID                      = a3a49a60-7597-11e0-b07c-0002a5d5c51b
-  MODULE_TYPE                    = DXE_DRIVER
-  VERSION_STRING                 = 1.0
-  LIBRARY_CLASS                  = NorFlashPlatformLib
-  
-[Sources.common]
-  NorFlashArmRealViewEb.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  ArmPlatformPkg/ArmPlatformPkg.dec
-
-[LibraryClasses]
-  BaseLib
-  DebugLib
-  IoLib
+#/** @file

+#  

+#  Component description file for NorFlashArmRealViewEbLib module

+#  

+#  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>

+#

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = NorFlashArmRealViewEbLib

+  FILE_GUID                      = a3a49a60-7597-11e0-b07c-0002a5d5c51b

+  MODULE_TYPE                    = DXE_DRIVER

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = NorFlashPlatformLib

+  

+[Sources.common]

+  NorFlashArmRealViewEb.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+

+[LibraryClasses]

+  BaseLib

+  DebugLib

+  IoLib

diff --git a/ArmPlatformPkg/ArmRealViewEbPkg/Library/PL111LcdArmRealViewEbLib/PL111LcdArmRealViewEbLib.inf b/ArmPlatformPkg/ArmRealViewEbPkg/Library/PL111LcdArmRealViewEbLib/PL111LcdArmRealViewEbLib.inf
index fda59de7..b44e868c 100644
--- a/ArmPlatformPkg/ArmRealViewEbPkg/Library/PL111LcdArmRealViewEbLib/PL111LcdArmRealViewEbLib.inf
+++ b/ArmPlatformPkg/ArmRealViewEbPkg/Library/PL111LcdArmRealViewEbLib/PL111LcdArmRealViewEbLib.inf
@@ -1,65 +1,65 @@
-#/** @file
-#  
-#  Component description file for ArmRealViewGraphicsDxe module
-#  
-#  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = PL111LcdArmRealViewEbLib
-  FILE_GUID                      = 51396ee0-4973-11e0-868a-0002a5d5c51b
-  MODULE_TYPE                    = DXE_DRIVER
-  VERSION_STRING                 = 1.0
-  LIBRARY_CLASS                  = PL111LcdPlatformLib
-  
-[Sources.common]
-  PL111LcdArmRealViewEb.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  ArmPlatformPkg/ArmPlatformPkg.dec
-
-[LibraryClasses]
-  BaseLib
-  DebugLib
-  IoLib
-
-[Guids]
-
-[Protocols]
-  gEfiEdidDiscoveredProtocolGuid                # Produced
-  gEfiEdidActiveProtocolGuid                    # Produced
-
-[FixedPcd.common]
-
-  #
-  # The following modes are supported by PL111
-  #
-  #    0 :  640 x 480 x 24 bpp
-  #    1 :  800 x 600 x 24 bpp
-  #    2 : 1024 x 768 x 24 bpp
-  #    3 :  640 x 480 x 16 bpp (565 RGB Mode)
-  #    4 :  800 x 600 x 16 bpp (565 RGB Mode) 
-  #    5 : 1024 x 768 x 16 bpp (565 RGB Mode)
-  #    6 :  640 x 480 x 15 bpp (555 RGB Mode)
-  #    7 :  800 x 600 x 15 bpp (555 RGB Mode) 
-  #    8 : 1024 x 768 x 15 bpp (555 RGB Mode)
-  #    9 : 1024 x 768 x 15 bpp (555 RGB Mode) - Linux driver settings
-  #   10 :  640 x 480 x 12 bpp (444 RGB Mode)
-  #   11 :  800 x 600 x 12 bpp (444 RGB Mode) 
-  #   12 : 1024 x 768 x 12 bpp (444 RGB Mode)
-  #
-
-[Pcd.common]
-
-[Depex]
- # gEfiCpuArchProtocolGuid
+#/** @file

+#  

+#  Component description file for ArmRealViewGraphicsDxe module

+#  

+#  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = PL111LcdArmRealViewEbLib

+  FILE_GUID                      = 51396ee0-4973-11e0-868a-0002a5d5c51b

+  MODULE_TYPE                    = DXE_DRIVER

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = PL111LcdPlatformLib

+  

+[Sources.common]

+  PL111LcdArmRealViewEb.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+

+[LibraryClasses]

+  BaseLib

+  DebugLib

+  IoLib

+

+[Guids]

+

+[Protocols]

+  gEfiEdidDiscoveredProtocolGuid                # Produced

+  gEfiEdidActiveProtocolGuid                    # Produced

+

+[FixedPcd.common]

+

+  #

+  # The following modes are supported by PL111

+  #

+  #    0 :  640 x 480 x 24 bpp

+  #    1 :  800 x 600 x 24 bpp

+  #    2 : 1024 x 768 x 24 bpp

+  #    3 :  640 x 480 x 16 bpp (565 RGB Mode)

+  #    4 :  800 x 600 x 16 bpp (565 RGB Mode) 

+  #    5 : 1024 x 768 x 16 bpp (565 RGB Mode)

+  #    6 :  640 x 480 x 15 bpp (555 RGB Mode)

+  #    7 :  800 x 600 x 15 bpp (555 RGB Mode) 

+  #    8 : 1024 x 768 x 15 bpp (555 RGB Mode)

+  #    9 : 1024 x 768 x 15 bpp (555 RGB Mode) - Linux driver settings

+  #   10 :  640 x 480 x 12 bpp (444 RGB Mode)

+  #   11 :  800 x 600 x 12 bpp (444 RGB Mode) 

+  #   12 : 1024 x 768 x 12 bpp (444 RGB Mode)

+  #

+

+[Pcd.common]

+

+[Depex]

+ # gEfiCpuArchProtocolGuid

diff --git a/ArmPlatformPkg/ArmRealViewEbPkg/Library/SysConfigArmRealViewEbLib/SysConfigArmRealViewEbLib.inf b/ArmPlatformPkg/ArmRealViewEbPkg/Library/SysConfigArmRealViewEbLib/SysConfigArmRealViewEbLib.inf
index b45c20b5..e1a73534 100644
--- a/ArmPlatformPkg/ArmRealViewEbPkg/Library/SysConfigArmRealViewEbLib/SysConfigArmRealViewEbLib.inf
+++ b/ArmPlatformPkg/ArmRealViewEbPkg/Library/SysConfigArmRealViewEbLib/SysConfigArmRealViewEbLib.inf
@@ -1,34 +1,34 @@
-#/** @file
-#  
-#  Component description file for SysConfigArmRealViewEbLib module
-#  
-#  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>
-#
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = SysConfigArmRealViewEbLib
-  FILE_GUID                      = 46eddfa0-8de0-11e0-944b-0002a5d5c51b
-  MODULE_TYPE                    = BASE
-  VERSION_STRING                 = 1.0
-  LIBRARY_CLASS                  = ArmPlatformSysConfigLib
-  
-[Sources.common]
-  SysConfigArmRealViewEb.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  ArmPlatformPkg/ArmVExpressPkg/ArmVExpressPkg.dec
-  ArmPlatformPkg/ArmPlatformPkg.dec
-
-[LibraryClasses]
-  BaseLib
+#/** @file

+#  

+#  Component description file for SysConfigArmRealViewEbLib module

+#  

+#  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>

+#

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = SysConfigArmRealViewEbLib

+  FILE_GUID                      = 46eddfa0-8de0-11e0-944b-0002a5d5c51b

+  MODULE_TYPE                    = BASE

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = ArmPlatformSysConfigLib

+  

+[Sources.common]

+  SysConfigArmRealViewEb.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  ArmPlatformPkg/ArmVExpressPkg/ArmVExpressPkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+

+[LibraryClasses]

+  BaseLib

diff --git a/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress-CTA15-A7.dsc b/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress-CTA15-A7.dsc
index cbacd315..4b0666f3 100644
--- a/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress-CTA15-A7.dsc
+++ b/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress-CTA15-A7.dsc
@@ -51,7 +51,7 @@
   LcdPlatformLib|ArmPlatformPkg/ArmVExpressPkg/Library/HdLcdArmVExpressLib/HdLcdArmVExpressLib.inf

   

   TimerLib|ArmPkg/Library/ArmArchTimerLib/ArmArchTimerLib.inf 

-  ArmSmcLib|ArmPlatformPkg/Library/ArmSmcLib/ArmSmcLib.inf

+  ArmSmcLib|ArmPkg/Library/ArmSmcLib/ArmSmcLib.inf

 

 [BuildOptions]

 !ifdef $(ARM_BIGLITTLE_TC2)

@@ -127,8 +127,8 @@
   #  A7_0 = 0x100, GicCoreId = 2

   #  A7_1 = 0x101, GicCoreId = 3

   #  A7_2 = 0x102, GicCoreId = 4

-  gArmTokenSpaceGuid.PcdArmPrimaryCore|0
-  gArmTokenSpaceGuid.PcdGicPrimaryCoreId|0
+  gArmTokenSpaceGuid.PcdArmPrimaryCore|0x100
+  gArmTokenSpaceGuid.PcdGicPrimaryCoreId|0x100
 !endif

   

   #

@@ -180,11 +180,13 @@
   #

   # Versatile Express machine type (ARM VERSATILE EXPRESS = 2272) required for ARM Linux: 

   gArmTokenSpaceGuid.PcdArmMachineType|2272

-  gArmPlatformTokenSpaceGuid.PcdDefaultBootDescription|L"Linux from NorFlash"

-  gArmPlatformTokenSpaceGuid.PcdDefaultBootDevicePath|L"VenHw(1F15DA3C-37FF-4070-B471-BB4AF12A724A)/MemoryMapped(0x0,0xE000000,0xE800000)"

-  gArmPlatformTokenSpaceGuid.PcdDefaultBootArgument|"console=ttyAMA0,38400 earlyprintk debug verbose"

-  gArmPlatformTokenSpaceGuid.PcdDefaultBootType|2

-  gArmPlatformTokenSpaceGuid.PcdFdtDevicePath|L"VenHw(1F15DA3C-37FF-4070-B471-BB4AF12A724A)/MemoryMapped(0x0,0x0E800000,0x0E803000)"

+  gArmPlatformTokenSpaceGuid.PcdDefaultBootDescription|L"Linaro image on SD card"
+  gArmPlatformTokenSpaceGuid.PcdDefaultBootDevicePath|L"VenHw(09831032-6FA3-4484-AF4F-0A000A8D3A82)/HD(1,MBR,0x00000000,0x3F,0x19FC0)/uImage"
+  gArmPlatformTokenSpaceGuid.PcdDefaultBootInitrdPath|L"VenHw(09831032-6FA3-4484-AF4F-0A000A8D3A82)/HD(1,MBR,0x00000000,0x3F,0x19FC0)/uInitrd"
+  gArmPlatformTokenSpaceGuid.PcdDefaultFdtLocalDevicePath|L"VenHw(09831032-6FA3-4484-AF4F-0A000A8D3A82)/HD(1,MBR,0x00000000,0x3F,0x19FC0)/v2p-ca15-tc2.dtb"
+  gArmPlatformTokenSpaceGuid.PcdDefaultBootArgument|"console=tty0 console=ttyAMA0,38400n8 root=/dev/mmcblk0p2 rootwait ro androidboot.console=ttyAMA0 mmci.fmax=12000000"
+  gArmPlatformTokenSpaceGuid.PcdDefaultBootType|3
+  gArmPlatformTokenSpaceGuid.PcdFdtDevicePath|L"VenHw(09831032-6FA3-4484-AF4F-0A000A8D3A82)/HD(1,MBR,0x00000000,0x3F,0x19FC0)/v2p-ca15-tc2.dtb"
 

   # Use the serial console (ConIn & ConOut) and the Graphic driver (ConOut)

   # PL111 - CLCD

diff --git a/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress-CTA15x2.dsc b/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress-CTA15x2.dsc
index d785eb3d..0feee1f8 100644
--- a/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress-CTA15x2.dsc
+++ b/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress-CTA15x2.dsc
@@ -179,10 +179,13 @@
   #
   # Versatile Express machine type (ARM VERSATILE EXPRESS = 2272) required for ARM Linux: 
   gArmTokenSpaceGuid.PcdArmMachineType|2272
-  gArmPlatformTokenSpaceGuid.PcdDefaultBootDescription|L"NorFlash"
-  gArmPlatformTokenSpaceGuid.PcdDefaultBootDevicePath|L"VenHw(1F15DA3C-37FF-4070-B471-BB4AF12A724A)/MemoryMapped(0x0,0x46000000,0x46400000)"
-  gArmPlatformTokenSpaceGuid.PcdDefaultBootArgument|""
-  gArmPlatformTokenSpaceGuid.PcdDefaultBootType|1
+  gArmPlatformTokenSpaceGuid.PcdDefaultBootDescription|L"Linaro image on SD card"
+  gArmPlatformTokenSpaceGuid.PcdDefaultBootDevicePath|L"VenHw(09831032-6FA3-4484-AF4F-0A000A8D3A82)/HD(1,MBR,0x00000000,0x3F,0x19FC0)/uImage"
+  gArmPlatformTokenSpaceGuid.PcdDefaultBootInitrdPath|L"VenHw(09831032-6FA3-4484-AF4F-0A000A8D3A82)/HD(1,MBR,0x00000000,0x3F,0x19FC0)/uInitrd"
+  gArmPlatformTokenSpaceGuid.PcdDefaultFdtLocalDevicePath|L"VenHw(09831032-6FA3-4484-AF4F-0A000A8D3A82)/HD(1,MBR,0x00000000,0x3F,0x19FC0)/v2p-ca15-tc1.dtb"
+  gArmPlatformTokenSpaceGuid.PcdDefaultBootArgument|"console=tty0 console=ttyAMA0,38400n8 root=/dev/mmcblk0p2 rootwait ro androidboot.console=ttyAMA0 mmci.fmax=12000000"
+  gArmPlatformTokenSpaceGuid.PcdDefaultBootType|3
+  gArmPlatformTokenSpaceGuid.PcdFdtDevicePath|L"VenHw(09831032-6FA3-4484-AF4F-0A000A8D3A82)/HD(1,MBR,0x00000000,0x3F,0x19FC0)/v2p-ca15-tc1.dtb"
 
   # Use the serial console (ConIn & ConOut) and the Graphic driver (ConOut)
   gArmPlatformTokenSpaceGuid.PcdDefaultConOutPaths|L"VenHw(D3987D4B-971A-435F-8CAF-4967EB627241)/Uart(38400,8,N,1)/VenPcAnsi();VenHw(407B4008-BF5B-11DF-9547-CF16E0D72085)"
diff --git a/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress-CTA5s.dsc b/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress-CTA5s.dsc
index a41680d2..03d1d095 100644
--- a/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress-CTA5s.dsc
+++ b/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress-CTA5s.dsc
@@ -179,10 +179,13 @@
   #
   # Versatile Express machine type (ARM VERSATILE EXPRESS = 2272) required for ARM Linux: 
   gArmTokenSpaceGuid.PcdArmMachineType|2272
-  gArmPlatformTokenSpaceGuid.PcdDefaultBootDescription|L"NorFlash"
-  gArmPlatformTokenSpaceGuid.PcdDefaultBootDevicePath|L"VenHw(1F15DA3C-37FF-4070-B471-BB4AF12A724A)/MemoryMapped(0x0,0x46000000,0x46400000)"
-  gArmPlatformTokenSpaceGuid.PcdDefaultBootArgument|""
-  gArmPlatformTokenSpaceGuid.PcdDefaultBootType|1
+  gArmPlatformTokenSpaceGuid.PcdDefaultBootDescription|L"Linaro image on SD card"
+  gArmPlatformTokenSpaceGuid.PcdDefaultBootDevicePath|L"VenHw(09831032-6FA3-4484-AF4F-0A000A8D3A82)/HD(1,MBR,0x00000000,0x3F,0x19FC0)/uImage"
+  gArmPlatformTokenSpaceGuid.PcdDefaultBootInitrdPath|L"VenHw(09831032-6FA3-4484-AF4F-0A000A8D3A82)/HD(1,MBR,0x00000000,0x3F,0x19FC0)/uInitrd"
+  gArmPlatformTokenSpaceGuid.PcdDefaultFdtLocalDevicePath|L"VenHw(09831032-6FA3-4484-AF4F-0A000A8D3A82)/HD(1,MBR,0x00000000,0x3F,0x19FC0)/v2p-ca5s.dtb"
+  gArmPlatformTokenSpaceGuid.PcdDefaultBootArgument|"console=tty0 console=ttyAMA0,38400n8 root=/dev/mmcblk0p2 rootwait ro androidboot.console=ttyAMA0 mmci.fmax=12000000"
+  gArmPlatformTokenSpaceGuid.PcdDefaultBootType|3
+  gArmPlatformTokenSpaceGuid.PcdFdtDevicePath|L"VenHw(09831032-6FA3-4484-AF4F-0A000A8D3A82)/HD(1,MBR,0x00000000,0x3F,0x19FC0)/v2p-ca5s.dtb"
 
   # Use the serial console (ConIn & ConOut) and the Graphic driver (ConOut)
   gArmPlatformTokenSpaceGuid.PcdDefaultConOutPaths|L"VenHw(D3987D4B-971A-435F-8CAF-4967EB627241)/Uart(38400,8,N,1)/VenPcAnsi();VenHw(407B4008-BF5B-11DF-9547-CF16E0D72085)"
diff --git a/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress-CTA9x4.dsc b/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress-CTA9x4.dsc
index 11eba89d..1171e90f 100644
--- a/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress-CTA9x4.dsc
+++ b/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress-CTA9x4.dsc
@@ -176,10 +176,12 @@
   #

   # Versatile Express machine type (ARM VERSATILE EXPRESS = 2272) required for ARM Linux: 

   gArmTokenSpaceGuid.PcdArmMachineType|2272

-  gArmPlatformTokenSpaceGuid.PcdDefaultBootDescription|L"NorFlash"

-  gArmPlatformTokenSpaceGuid.PcdDefaultBootDevicePath|L"VenHw(1F15DA3C-37FF-4070-B471-BB4AF12A724A)/MemoryMapped(0x0,0x46000000,0x46400000)"

-  gArmPlatformTokenSpaceGuid.PcdDefaultBootArgument|""

+  gArmPlatformTokenSpaceGuid.PcdDefaultBootDescription|L"Linaro image on SD card"

+  gArmPlatformTokenSpaceGuid.PcdDefaultBootDevicePath|L"VenHw(09831032-6FA3-4484-AF4F-0A000A8D3A82)/HD(1,MBR,0x00000000,0x3F,0x19FC0)/uImage"
+  gArmPlatformTokenSpaceGuid.PcdDefaultBootInitrdPath|L"VenHw(09831032-6FA3-4484-AF4F-0A000A8D3A82)/HD(1,MBR,0x00000000,0x3F,0x19FC0)/uInitrd"
+  gArmPlatformTokenSpaceGuid.PcdDefaultBootArgument|"console=tty0 console=ttyAMA0,38400n8 root=/dev/mmcblk0p2 rootwait ro androidboot.console=ttyAMA0 mmci.fmax=12000000"
   gArmPlatformTokenSpaceGuid.PcdDefaultBootType|1

+  gArmPlatformTokenSpaceGuid.PcdFdtDevicePath|L"VenHw(09831032-6FA3-4484-AF4F-0A000A8D3A82)/HD(1,MBR,0x00000000,0x3F,0x19FC0)/v2p-ca9.dtb"
 

   # Use the serial console (ConIn & ConOut) and the Graphic driver (ConOut)

   gArmPlatformTokenSpaceGuid.PcdDefaultConOutPaths|L"VenHw(D3987D4B-971A-435F-8CAF-4967EB627241)/Uart(38400,8,N,1)/VenPcAnsi();VenHw(407B4008-BF5B-11DF-9547-CF16E0D72085)"

diff --git a/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress-RTSM-A15.fdf b/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress-RTSM-A15.fdf
index 4be620c3..c961897d 100644
--- a/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress-RTSM-A15.fdf
+++ b/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress-RTSM-A15.fdf
@@ -1,318 +1,318 @@
-# FLASH layout file for ARM VE.
-#
-#  Copyright (c) 2011, ARM Limited. All rights reserved.
-#  
-#  This program and the accompanying materials                          
-#  are licensed and made available under the terms and conditions of the BSD License         
-#  which accompanies this distribution.  The full text of the license may be found at        
-#  http://opensource.org/licenses/bsd-license.php                                            
-#
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-#
-
-################################################################################
-#
-# FD Section
-# The [FD] Section is made up of the definition statements and a
-# description of what goes into  the Flash Device Image.  Each FD section
-# defines one flash "device" image.  A flash device image may be one of
-# the following: Removable media bootable image (like a boot floppy
-# image,) an Option ROM image (that would be "flashed" into an add-in
-# card,) a System "Flash"  image (that would be burned into a system's
-# flash) or an Update ("Capsule") image that will be used to update and
-# existing system flash.
-#
-################################################################################
-
-[FD.RTSM_VE_Cortex-A15_EFI]
-BaseAddress   = 0x08000000|gArmTokenSpaceGuid.PcdFdBaseAddress  # The base address of the Firmware in NOR Flash.
-Size          = 0x00280000|gArmTokenSpaceGuid.PcdFdSize         # The size in bytes of the FLASH Device
-ErasePolarity = 1
-
-# This one is tricky, it must be: BlockSize * NumBlocks = Size
-BlockSize     = 0x00001000
-NumBlocks     = 0x280
-
-################################################################################
-#
-# Following are lists of FD Region layout which correspond to the locations of different
-# images within the flash device.
-#
-# Regions must be defined in ascending order and may not overlap.
-#
-# A Layout Region start with a eight digit hex offset (leading "0x" required) followed by
-# the pipe "|" character, followed by the size of the region, also in hex with the leading
-# "0x" characters. Like:
-# Offset|Size
-# PcdOffsetCName|PcdSizeCName
-# RegionType <FV, DATA, or FILE>
-#
-################################################################################
-
-0x00000000|0x00080000
-gArmTokenSpaceGuid.PcdSecureFvBaseAddress|gArmTokenSpaceGuid.PcdSecureFvSize
-FV = FVMAIN_SEC
-
-0x00080000|0x00280000
-gArmTokenSpaceGuid.PcdFvBaseAddress|gArmTokenSpaceGuid.PcdFvSize
-FV = FVMAIN_COMPACT
-
-
-################################################################################
-#
-# FV Section
-#
-# [FV] section is used to define what components or modules are placed within a flash
-# device file.  This section also defines order the components and modules are positioned
-# within the image.  The [FV] section consists of define statements, set statements and
-# module statements.
-#
-################################################################################
-
-[FV.FVMAIN_SEC]
-FvAlignment        = 8
-ERASE_POLARITY     = 1
-MEMORY_MAPPED      = TRUE
-STICKY_WRITE       = TRUE
-LOCK_CAP           = TRUE
-LOCK_STATUS        = TRUE
-WRITE_DISABLED_CAP = TRUE
-WRITE_ENABLED_CAP  = TRUE
-WRITE_STATUS       = TRUE
-WRITE_LOCK_CAP     = TRUE
-WRITE_LOCK_STATUS  = TRUE
-READ_DISABLED_CAP  = TRUE
-READ_ENABLED_CAP   = TRUE
-READ_STATUS        = TRUE
-READ_LOCK_CAP      = TRUE
-READ_LOCK_STATUS   = TRUE
-
-  INF ArmPlatformPkg/Sec/Sec.inf
-
-
-[FV.FvMain]
-BlockSize          = 0x40
-NumBlocks          = 0         # This FV gets compressed so make it just big enough
-FvAlignment        = 8         # FV alignment and FV attributes setting.
-ERASE_POLARITY     = 1
-MEMORY_MAPPED      = TRUE
-STICKY_WRITE       = TRUE
-LOCK_CAP           = TRUE
-LOCK_STATUS        = TRUE
-WRITE_DISABLED_CAP = TRUE
-WRITE_ENABLED_CAP  = TRUE
-WRITE_STATUS       = TRUE
-WRITE_LOCK_CAP     = TRUE
-WRITE_LOCK_STATUS  = TRUE
-READ_DISABLED_CAP  = TRUE
-READ_ENABLED_CAP   = TRUE
-READ_STATUS        = TRUE
-READ_LOCK_CAP      = TRUE
-READ_LOCK_STATUS   = TRUE
-
-  INF MdeModulePkg/Core/Dxe/DxeMain.inf 
-
-  #
-  # PI DXE Drivers producing Architectural Protocols (EFI Services) 
-  #
-  INF ArmPkg/Drivers/CpuDxe/CpuDxe.inf
-  INF MdeModulePkg/Core/RuntimeDxe/RuntimeDxe.inf
-  INF MdeModulePkg/Universal/SecurityStubDxe/SecurityStubDxe.inf
-  INF MdeModulePkg/Universal/CapsuleRuntimeDxe/CapsuleRuntimeDxe.inf
-  INF MdeModulePkg/Universal/Variable/RuntimeDxe/VariableRuntimeDxe.inf
-  INF MdeModulePkg/Universal/FaultTolerantWriteDxe/FaultTolerantWriteDxe.inf
-  INF MdeModulePkg/Universal/MonotonicCounterRuntimeDxe/MonotonicCounterRuntimeDxe.inf
-  INF EmbeddedPkg/ResetRuntimeDxe/ResetRuntimeDxe.inf
-  INF EmbeddedPkg/RealTimeClockRuntimeDxe/RealTimeClockRuntimeDxe.inf
-  INF EmbeddedPkg/MetronomeDxe/MetronomeDxe.inf
-
-  INF MdeModulePkg/Universal/HiiDatabaseDxe/HiiDatabaseDxe.inf
-  
-  #
-  # Multiple Console IO support
-  #
-  INF MdeModulePkg/Universal/Console/ConPlatformDxe/ConPlatformDxe.inf
-  INF MdeModulePkg/Universal/Console/ConSplitterDxe/ConSplitterDxe.inf
-  INF MdeModulePkg/Universal/Console/GraphicsConsoleDxe/GraphicsConsoleDxe.inf
-  INF MdeModulePkg/Universal/Console/TerminalDxe/TerminalDxe.inf
-  INF EmbeddedPkg/SerialDxe/SerialDxe.inf
-
-  INF ArmPkg/Drivers/PL390Gic/PL390GicDxe.inf
-  INF ArmPkg/Drivers/TimerDxe/TimerDxe.inf
-  INF ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashDxe.inf
-  INF ArmPlatformPkg/Drivers/LcdGraphicsOutputDxe/PL111LcdGraphicsOutputDxe.inf
-  INF ArmPlatformPkg/Drivers/SP805WatchdogDxe/SP805WatchdogDxe.inf
-
-  #
-  # Semi-hosting filesystem
-  #
-  INF ArmPkg/Filesystem/SemihostFs/SemihostFs.inf
-  
-  #
-  # FAT filesystem + GPT/MBR partitioning
-  #
-  INF MdeModulePkg/Universal/Disk/DiskIoDxe/DiskIoDxe.inf
-  INF MdeModulePkg/Universal/Disk/PartitionDxe/PartitionDxe.inf
-  INF FatBinPkg/EnhancedFatDxe/Fat.inf
-  INF MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf
-
-  #
-  # Multimedia Card Interface
-  #
-  INF EmbeddedPkg/Universal/MmcDxe/MmcDxe.inf
-  INF ArmPlatformPkg/Drivers/PL180MciDxe/PL180MciDxe.inf
-
-  #
-  # UEFI application (Shell Embedded Boot Loader) 
-  #  
-  INF ShellBinPkg/UefiShell/UefiShell.inf 
-  
-  #
-  # Bds
-  #
-  INF MdeModulePkg/Universal/DevicePathDxe/DevicePathDxe.inf
-  INF ArmPlatformPkg/Bds/Bds.inf
-
-
-[FV.FVMAIN_COMPACT]
-FvAlignment        = 8
-ERASE_POLARITY     = 1
-MEMORY_MAPPED      = TRUE
-STICKY_WRITE       = TRUE
-LOCK_CAP           = TRUE
-LOCK_STATUS        = TRUE
-WRITE_DISABLED_CAP = TRUE
-WRITE_ENABLED_CAP  = TRUE
-WRITE_STATUS       = TRUE
-WRITE_LOCK_CAP     = TRUE
-WRITE_LOCK_STATUS  = TRUE
-READ_DISABLED_CAP  = TRUE
-READ_ENABLED_CAP   = TRUE
-READ_STATUS        = TRUE
-READ_LOCK_CAP      = TRUE
-READ_LOCK_STATUS   = TRUE
-
-!if $(EDK2_SKIP_PEICORE) == 1
-  INF ArmPlatformPkg/PrePi/PeiUniCore.inf
-!else
-  INF ArmPlatformPkg/PrePeiCore/PrePeiCoreUniCore.inf
-  INF MdeModulePkg/Core/Pei/PeiMain.inf
-  INF ArmPlatformPkg/PlatformPei/PlatformPeim.inf
-  INF ArmPlatformPkg/MemoryInitPei/MemoryInitPeim.inf
-  INF ArmPkg/Drivers/CpuPei/CpuPei.inf
-  INF MdeModulePkg/Universal/PCD/Pei/Pcd.inf
-  INF IntelFrameworkModulePkg/Universal/StatusCode/Pei/StatusCodePei.inf
-  INF MdeModulePkg/Universal/Variable/Pei/VariablePei.inf
-  INF MdeModulePkg/Core/DxeIplPeim/DxeIpl.inf
-!endif
-  
-  FILE FV_IMAGE = 9E21FD93-9C72-4c15-8C4B-E77F1DB2D792 {
-    SECTION GUIDED EE4E5898-3914-4259-9D6E-DC7BD79403CF PROCESSING_REQUIRED = TRUE {
-      SECTION FV_IMAGE = FVMAIN
-    }
-  }
-
-
-################################################################################
-#
-# Rules are use with the [FV] section's module INF type to define
-# how an FFS file is created for a given INF file. The following Rule are the default
-# rules for the different module type. User can add the customized rules to define the
-# content of the FFS file.
-#
-################################################################################
-
-
-############################################################################
-# Example of a DXE_DRIVER FFS file with a Checksum encapsulation section   # 
-############################################################################
-#
-#[Rule.Common.DXE_DRIVER]
-#  FILE DRIVER = $(NAMED_GUID) {
-#    DXE_DEPEX    DXE_DEPEX               Optional $(INF_OUTPUT)/$(MODULE_NAME).depex
-#    COMPRESS PI_STD {
-#      GUIDED {
-#        PE32     PE32                    $(INF_OUTPUT)/$(MODULE_NAME).efi
-#        UI       STRING="$(MODULE_NAME)" Optional
-#        VERSION  STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)
-#      }
-#    }
-#  }
-#
-############################################################################
-
-[Rule.Common.SEC]
-  FILE SEC = $(NAMED_GUID) RELOCS_STRIPPED {
-    TE  TE    Align = 32                $(INF_OUTPUT)/$(MODULE_NAME).efi
-  }
-
-[Rule.Common.PEI_CORE]
-  FILE PEI_CORE = $(NAMED_GUID) {
-    TE     TE                           $(INF_OUTPUT)/$(MODULE_NAME).efi
-    UI     STRING ="$(MODULE_NAME)" Optional         
-  }
-
-[Rule.Common.PEIM]
-  FILE PEIM = $(NAMED_GUID) {
-     PEI_DEPEX PEI_DEPEX Optional       $(INF_OUTPUT)/$(MODULE_NAME).depex
-     TE       TE                        $(INF_OUTPUT)/$(MODULE_NAME).efi
-     UI       STRING="$(MODULE_NAME)" Optional         
-  }
-
-[Rule.Common.PEIM.TIANOCOMPRESSED]
-  FILE PEIM = $(NAMED_GUID) DEBUG_MYTOOLS_IA32 {
-    PEI_DEPEX PEI_DEPEX Optional        $(INF_OUTPUT)/$(MODULE_NAME).depex
-    GUIDED A31280AD-481E-41B6-95E8-127F4C984779 PROCESSING_REQUIRED = TRUE {
-      PE32      PE32                    $(INF_OUTPUT)/$(MODULE_NAME).efi
-      UI        STRING="$(MODULE_NAME)" Optional
-    }
-  }
-
-[Rule.Common.DXE_CORE]
-  FILE DXE_CORE = $(NAMED_GUID) {
-    PE32     PE32                       $(INF_OUTPUT)/$(MODULE_NAME).efi
-    UI       STRING="$(MODULE_NAME)" Optional
-  }
-
-[Rule.Common.UEFI_DRIVER]
-  FILE DRIVER = $(NAMED_GUID) {
-    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex
-    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi
-    UI           STRING="$(MODULE_NAME)" Optional
-  }
-
-[Rule.Common.DXE_DRIVER]
-  FILE DRIVER = $(NAMED_GUID) {
-    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex
-    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi
-    UI           STRING="$(MODULE_NAME)" Optional
-  }
-
-[Rule.Common.DXE_RUNTIME_DRIVER]
-  FILE DRIVER = $(NAMED_GUID) {
-    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex
-    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi
-    UI           STRING="$(MODULE_NAME)" Optional
-  }
-
-[Rule.Common.UEFI_APPLICATION]
-  FILE APPLICATION = $(NAMED_GUID) {
-    UI     STRING ="$(MODULE_NAME)" Optional         
-    PE32   PE32                         $(INF_OUTPUT)/$(MODULE_NAME).efi
-  }
-
-[Rule.Common.UEFI_DRIVER.BINARY]
-  FILE DRIVER = $(NAMED_GUID) {
-    DXE_DEPEX DXE_DEPEX Optional      |.depex
-    PE32      PE32                    |.efi
-    UI        STRING="$(MODULE_NAME)" Optional
-    VERSION   STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)
-  }
-
-[Rule.Common.UEFI_APPLICATION.BINARY]
-  FILE APPLICATION = $(NAMED_GUID) {
-    PE32      PE32                    |.efi
-    UI        STRING="$(MODULE_NAME)" Optional
-    VERSION   STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)
-  }
+# FLASH layout file for ARM VE.

+#

+#  Copyright (c) 2011, ARM Limited. All rights reserved.

+#  

+#  This program and the accompanying materials                          

+#  are licensed and made available under the terms and conditions of the BSD License         

+#  which accompanies this distribution.  The full text of the license may be found at        

+#  http://opensource.org/licenses/bsd-license.php                                            

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+#

+

+################################################################################

+#

+# FD Section

+# The [FD] Section is made up of the definition statements and a

+# description of what goes into  the Flash Device Image.  Each FD section

+# defines one flash "device" image.  A flash device image may be one of

+# the following: Removable media bootable image (like a boot floppy

+# image,) an Option ROM image (that would be "flashed" into an add-in

+# card,) a System "Flash"  image (that would be burned into a system's

+# flash) or an Update ("Capsule") image that will be used to update and

+# existing system flash.

+#

+################################################################################

+

+[FD.RTSM_VE_Cortex-A15_EFI]

+BaseAddress   = 0x08000000|gArmTokenSpaceGuid.PcdFdBaseAddress  # The base address of the Firmware in NOR Flash.

+Size          = 0x00280000|gArmTokenSpaceGuid.PcdFdSize         # The size in bytes of the FLASH Device

+ErasePolarity = 1

+

+# This one is tricky, it must be: BlockSize * NumBlocks = Size

+BlockSize     = 0x00001000

+NumBlocks     = 0x280

+

+################################################################################

+#

+# Following are lists of FD Region layout which correspond to the locations of different

+# images within the flash device.

+#

+# Regions must be defined in ascending order and may not overlap.

+#

+# A Layout Region start with a eight digit hex offset (leading "0x" required) followed by

+# the pipe "|" character, followed by the size of the region, also in hex with the leading

+# "0x" characters. Like:

+# Offset|Size

+# PcdOffsetCName|PcdSizeCName

+# RegionType <FV, DATA, or FILE>

+#

+################################################################################

+

+0x00000000|0x00080000

+gArmTokenSpaceGuid.PcdSecureFvBaseAddress|gArmTokenSpaceGuid.PcdSecureFvSize

+FV = FVMAIN_SEC

+

+0x00080000|0x00280000

+gArmTokenSpaceGuid.PcdFvBaseAddress|gArmTokenSpaceGuid.PcdFvSize

+FV = FVMAIN_COMPACT

+

+

+################################################################################

+#

+# FV Section

+#

+# [FV] section is used to define what components or modules are placed within a flash

+# device file.  This section also defines order the components and modules are positioned

+# within the image.  The [FV] section consists of define statements, set statements and

+# module statements.

+#

+################################################################################

+

+[FV.FVMAIN_SEC]

+FvAlignment        = 8

+ERASE_POLARITY     = 1

+MEMORY_MAPPED      = TRUE

+STICKY_WRITE       = TRUE

+LOCK_CAP           = TRUE

+LOCK_STATUS        = TRUE

+WRITE_DISABLED_CAP = TRUE

+WRITE_ENABLED_CAP  = TRUE

+WRITE_STATUS       = TRUE

+WRITE_LOCK_CAP     = TRUE

+WRITE_LOCK_STATUS  = TRUE

+READ_DISABLED_CAP  = TRUE

+READ_ENABLED_CAP   = TRUE

+READ_STATUS        = TRUE

+READ_LOCK_CAP      = TRUE

+READ_LOCK_STATUS   = TRUE

+

+  INF ArmPlatformPkg/Sec/Sec.inf

+

+

+[FV.FvMain]

+BlockSize          = 0x40

+NumBlocks          = 0         # This FV gets compressed so make it just big enough

+FvAlignment        = 8         # FV alignment and FV attributes setting.

+ERASE_POLARITY     = 1

+MEMORY_MAPPED      = TRUE

+STICKY_WRITE       = TRUE

+LOCK_CAP           = TRUE

+LOCK_STATUS        = TRUE

+WRITE_DISABLED_CAP = TRUE

+WRITE_ENABLED_CAP  = TRUE

+WRITE_STATUS       = TRUE

+WRITE_LOCK_CAP     = TRUE

+WRITE_LOCK_STATUS  = TRUE

+READ_DISABLED_CAP  = TRUE

+READ_ENABLED_CAP   = TRUE

+READ_STATUS        = TRUE

+READ_LOCK_CAP      = TRUE

+READ_LOCK_STATUS   = TRUE

+

+  INF MdeModulePkg/Core/Dxe/DxeMain.inf 

+

+  #

+  # PI DXE Drivers producing Architectural Protocols (EFI Services) 

+  #

+  INF ArmPkg/Drivers/CpuDxe/CpuDxe.inf

+  INF MdeModulePkg/Core/RuntimeDxe/RuntimeDxe.inf

+  INF MdeModulePkg/Universal/SecurityStubDxe/SecurityStubDxe.inf

+  INF MdeModulePkg/Universal/CapsuleRuntimeDxe/CapsuleRuntimeDxe.inf

+  INF MdeModulePkg/Universal/Variable/RuntimeDxe/VariableRuntimeDxe.inf

+  INF MdeModulePkg/Universal/FaultTolerantWriteDxe/FaultTolerantWriteDxe.inf

+  INF MdeModulePkg/Universal/MonotonicCounterRuntimeDxe/MonotonicCounterRuntimeDxe.inf

+  INF EmbeddedPkg/ResetRuntimeDxe/ResetRuntimeDxe.inf

+  INF EmbeddedPkg/RealTimeClockRuntimeDxe/RealTimeClockRuntimeDxe.inf

+  INF EmbeddedPkg/MetronomeDxe/MetronomeDxe.inf

+

+  INF MdeModulePkg/Universal/HiiDatabaseDxe/HiiDatabaseDxe.inf

+  

+  #

+  # Multiple Console IO support

+  #

+  INF MdeModulePkg/Universal/Console/ConPlatformDxe/ConPlatformDxe.inf

+  INF MdeModulePkg/Universal/Console/ConSplitterDxe/ConSplitterDxe.inf

+  INF MdeModulePkg/Universal/Console/GraphicsConsoleDxe/GraphicsConsoleDxe.inf

+  INF MdeModulePkg/Universal/Console/TerminalDxe/TerminalDxe.inf

+  INF EmbeddedPkg/SerialDxe/SerialDxe.inf

+

+  INF ArmPkg/Drivers/PL390Gic/PL390GicDxe.inf

+  INF ArmPkg/Drivers/TimerDxe/TimerDxe.inf

+  INF ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashDxe.inf

+  INF ArmPlatformPkg/Drivers/LcdGraphicsOutputDxe/PL111LcdGraphicsOutputDxe.inf

+  INF ArmPlatformPkg/Drivers/SP805WatchdogDxe/SP805WatchdogDxe.inf

+

+  #

+  # Semi-hosting filesystem

+  #

+  INF ArmPkg/Filesystem/SemihostFs/SemihostFs.inf

+  

+  #

+  # FAT filesystem + GPT/MBR partitioning

+  #

+  INF MdeModulePkg/Universal/Disk/DiskIoDxe/DiskIoDxe.inf

+  INF MdeModulePkg/Universal/Disk/PartitionDxe/PartitionDxe.inf

+  INF FatBinPkg/EnhancedFatDxe/Fat.inf

+  INF MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf

+

+  #

+  # Multimedia Card Interface

+  #

+  INF EmbeddedPkg/Universal/MmcDxe/MmcDxe.inf

+  INF ArmPlatformPkg/Drivers/PL180MciDxe/PL180MciDxe.inf

+

+  #

+  # UEFI application (Shell Embedded Boot Loader) 

+  #  

+  INF ShellBinPkg/UefiShell/UefiShell.inf 

+  

+  #

+  # Bds

+  #

+  INF MdeModulePkg/Universal/DevicePathDxe/DevicePathDxe.inf

+  INF ArmPlatformPkg/Bds/Bds.inf

+

+

+[FV.FVMAIN_COMPACT]

+FvAlignment        = 8

+ERASE_POLARITY     = 1

+MEMORY_MAPPED      = TRUE

+STICKY_WRITE       = TRUE

+LOCK_CAP           = TRUE

+LOCK_STATUS        = TRUE

+WRITE_DISABLED_CAP = TRUE

+WRITE_ENABLED_CAP  = TRUE

+WRITE_STATUS       = TRUE

+WRITE_LOCK_CAP     = TRUE

+WRITE_LOCK_STATUS  = TRUE

+READ_DISABLED_CAP  = TRUE

+READ_ENABLED_CAP   = TRUE

+READ_STATUS        = TRUE

+READ_LOCK_CAP      = TRUE

+READ_LOCK_STATUS   = TRUE

+

+!if $(EDK2_SKIP_PEICORE) == 1

+  INF ArmPlatformPkg/PrePi/PeiUniCore.inf

+!else

+  INF ArmPlatformPkg/PrePeiCore/PrePeiCoreUniCore.inf

+  INF MdeModulePkg/Core/Pei/PeiMain.inf

+  INF ArmPlatformPkg/PlatformPei/PlatformPeim.inf

+  INF ArmPlatformPkg/MemoryInitPei/MemoryInitPeim.inf

+  INF ArmPkg/Drivers/CpuPei/CpuPei.inf

+  INF MdeModulePkg/Universal/PCD/Pei/Pcd.inf

+  INF IntelFrameworkModulePkg/Universal/StatusCode/Pei/StatusCodePei.inf

+  INF MdeModulePkg/Universal/Variable/Pei/VariablePei.inf

+  INF MdeModulePkg/Core/DxeIplPeim/DxeIpl.inf

+!endif

+  

+  FILE FV_IMAGE = 9E21FD93-9C72-4c15-8C4B-E77F1DB2D792 {

+    SECTION GUIDED EE4E5898-3914-4259-9D6E-DC7BD79403CF PROCESSING_REQUIRED = TRUE {

+      SECTION FV_IMAGE = FVMAIN

+    }

+  }

+

+

+################################################################################

+#

+# Rules are use with the [FV] section's module INF type to define

+# how an FFS file is created for a given INF file. The following Rule are the default

+# rules for the different module type. User can add the customized rules to define the

+# content of the FFS file.

+#

+################################################################################

+

+

+############################################################################

+# Example of a DXE_DRIVER FFS file with a Checksum encapsulation section   # 

+############################################################################

+#

+#[Rule.Common.DXE_DRIVER]

+#  FILE DRIVER = $(NAMED_GUID) {

+#    DXE_DEPEX    DXE_DEPEX               Optional $(INF_OUTPUT)/$(MODULE_NAME).depex

+#    COMPRESS PI_STD {

+#      GUIDED {

+#        PE32     PE32                    $(INF_OUTPUT)/$(MODULE_NAME).efi

+#        UI       STRING="$(MODULE_NAME)" Optional

+#        VERSION  STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)

+#      }

+#    }

+#  }

+#

+############################################################################

+

+[Rule.Common.SEC]

+  FILE SEC = $(NAMED_GUID) RELOCS_STRIPPED {

+    TE  TE    Align = 32                $(INF_OUTPUT)/$(MODULE_NAME).efi

+  }

+

+[Rule.Common.PEI_CORE]

+  FILE PEI_CORE = $(NAMED_GUID) {

+    TE     TE                           $(INF_OUTPUT)/$(MODULE_NAME).efi

+    UI     STRING ="$(MODULE_NAME)" Optional         

+  }

+

+[Rule.Common.PEIM]

+  FILE PEIM = $(NAMED_GUID) {

+     PEI_DEPEX PEI_DEPEX Optional       $(INF_OUTPUT)/$(MODULE_NAME).depex

+     TE       TE                        $(INF_OUTPUT)/$(MODULE_NAME).efi

+     UI       STRING="$(MODULE_NAME)" Optional         

+  }

+

+[Rule.Common.PEIM.TIANOCOMPRESSED]

+  FILE PEIM = $(NAMED_GUID) DEBUG_MYTOOLS_IA32 {

+    PEI_DEPEX PEI_DEPEX Optional        $(INF_OUTPUT)/$(MODULE_NAME).depex

+    GUIDED A31280AD-481E-41B6-95E8-127F4C984779 PROCESSING_REQUIRED = TRUE {

+      PE32      PE32                    $(INF_OUTPUT)/$(MODULE_NAME).efi

+      UI        STRING="$(MODULE_NAME)" Optional

+    }

+  }

+

+[Rule.Common.DXE_CORE]

+  FILE DXE_CORE = $(NAMED_GUID) {

+    PE32     PE32                       $(INF_OUTPUT)/$(MODULE_NAME).efi

+    UI       STRING="$(MODULE_NAME)" Optional

+  }

+

+[Rule.Common.UEFI_DRIVER]

+  FILE DRIVER = $(NAMED_GUID) {

+    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex

+    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi

+    UI           STRING="$(MODULE_NAME)" Optional

+  }

+

+[Rule.Common.DXE_DRIVER]

+  FILE DRIVER = $(NAMED_GUID) {

+    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex

+    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi

+    UI           STRING="$(MODULE_NAME)" Optional

+  }

+

+[Rule.Common.DXE_RUNTIME_DRIVER]

+  FILE DRIVER = $(NAMED_GUID) {

+    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex

+    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi

+    UI           STRING="$(MODULE_NAME)" Optional

+  }

+

+[Rule.Common.UEFI_APPLICATION]

+  FILE APPLICATION = $(NAMED_GUID) {

+    UI     STRING ="$(MODULE_NAME)" Optional         

+    PE32   PE32                         $(INF_OUTPUT)/$(MODULE_NAME).efi

+  }

+

+[Rule.Common.UEFI_DRIVER.BINARY]

+  FILE DRIVER = $(NAMED_GUID) {

+    DXE_DEPEX DXE_DEPEX Optional      |.depex

+    PE32      PE32                    |.efi

+    UI        STRING="$(MODULE_NAME)" Optional

+    VERSION   STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)

+  }

+

+[Rule.Common.UEFI_APPLICATION.BINARY]

+  FILE APPLICATION = $(NAMED_GUID) {

+    PE32      PE32                    |.efi

+    UI        STRING="$(MODULE_NAME)" Optional

+    VERSION   STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)

+  }

diff --git a/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress-RTSM-A15_MPCore.fdf b/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress-RTSM-A15_MPCore.fdf
index 4718c185..58170490 100644
--- a/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress-RTSM-A15_MPCore.fdf
+++ b/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress-RTSM-A15_MPCore.fdf
@@ -1,318 +1,318 @@
-# FLASH layout file for ARM VE.
-#
-#  Copyright (c) 2011, ARM Limited. All rights reserved.
-#  
-#  This program and the accompanying materials                          
-#  are licensed and made available under the terms and conditions of the BSD License         
-#  which accompanies this distribution.  The full text of the license may be found at        
-#  http://opensource.org/licenses/bsd-license.php                                            
-#
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-#
-
-################################################################################
-#
-# FD Section
-# The [FD] Section is made up of the definition statements and a
-# description of what goes into  the Flash Device Image.  Each FD section
-# defines one flash "device" image.  A flash device image may be one of
-# the following: Removable media bootable image (like a boot floppy
-# image,) an Option ROM image (that would be "flashed" into an add-in
-# card,) a System "Flash"  image (that would be burned into a system's
-# flash) or an Update ("Capsule") image that will be used to update and
-# existing system flash.
-#
-################################################################################
-
-[FD.RTSM_VE_Cortex-A15_MPCore_EFI]
-BaseAddress   = 0x08000000|gArmTokenSpaceGuid.PcdFdBaseAddress  # The base address of the Firmware in NOR Flash.
-Size          = 0x00280000|gArmTokenSpaceGuid.PcdFdSize         # The size in bytes of the FLASH Device
-ErasePolarity = 1
-
-# This one is tricky, it must be: BlockSize * NumBlocks = Size
-BlockSize     = 0x00001000
-NumBlocks     = 0x280
-
-################################################################################
-#
-# Following are lists of FD Region layout which correspond to the locations of different
-# images within the flash device.
-#
-# Regions must be defined in ascending order and may not overlap.
-#
-# A Layout Region start with a eight digit hex offset (leading "0x" required) followed by
-# the pipe "|" character, followed by the size of the region, also in hex with the leading
-# "0x" characters. Like:
-# Offset|Size
-# PcdOffsetCName|PcdSizeCName
-# RegionType <FV, DATA, or FILE>
-#
-################################################################################
-
-0x00000000|0x00080000
-gArmTokenSpaceGuid.PcdSecureFvBaseAddress|gArmTokenSpaceGuid.PcdSecureFvSize
-FV = FVMAIN_SEC
-
-0x00080000|0x00280000
-gArmTokenSpaceGuid.PcdFvBaseAddress|gArmTokenSpaceGuid.PcdFvSize
-FV = FVMAIN_COMPACT
-
-
-################################################################################
-#
-# FV Section
-#
-# [FV] section is used to define what components or modules are placed within a flash
-# device file.  This section also defines order the components and modules are positioned
-# within the image.  The [FV] section consists of define statements, set statements and
-# module statements.
-#
-################################################################################
-
-[FV.FVMAIN_SEC]
-FvAlignment        = 8
-ERASE_POLARITY     = 1
-MEMORY_MAPPED      = TRUE
-STICKY_WRITE       = TRUE
-LOCK_CAP           = TRUE
-LOCK_STATUS        = TRUE
-WRITE_DISABLED_CAP = TRUE
-WRITE_ENABLED_CAP  = TRUE
-WRITE_STATUS       = TRUE
-WRITE_LOCK_CAP     = TRUE
-WRITE_LOCK_STATUS  = TRUE
-READ_DISABLED_CAP  = TRUE
-READ_ENABLED_CAP   = TRUE
-READ_STATUS        = TRUE
-READ_LOCK_CAP      = TRUE
-READ_LOCK_STATUS   = TRUE
-
-  INF ArmPlatformPkg/Sec/Sec.inf
-
-
-[FV.FvMain]
-BlockSize          = 0x40
-NumBlocks          = 0         # This FV gets compressed so make it just big enough
-FvAlignment        = 8         # FV alignment and FV attributes setting.
-ERASE_POLARITY     = 1
-MEMORY_MAPPED      = TRUE
-STICKY_WRITE       = TRUE
-LOCK_CAP           = TRUE
-LOCK_STATUS        = TRUE
-WRITE_DISABLED_CAP = TRUE
-WRITE_ENABLED_CAP  = TRUE
-WRITE_STATUS       = TRUE
-WRITE_LOCK_CAP     = TRUE
-WRITE_LOCK_STATUS  = TRUE
-READ_DISABLED_CAP  = TRUE
-READ_ENABLED_CAP   = TRUE
-READ_STATUS        = TRUE
-READ_LOCK_CAP      = TRUE
-READ_LOCK_STATUS   = TRUE
-
-  INF MdeModulePkg/Core/Dxe/DxeMain.inf 
-
-  #
-  # PI DXE Drivers producing Architectural Protocols (EFI Services) 
-  #
-  INF ArmPkg/Drivers/CpuDxe/CpuDxe.inf
-  INF MdeModulePkg/Core/RuntimeDxe/RuntimeDxe.inf
-  INF MdeModulePkg/Universal/SecurityStubDxe/SecurityStubDxe.inf
-  INF MdeModulePkg/Universal/CapsuleRuntimeDxe/CapsuleRuntimeDxe.inf
-  INF MdeModulePkg/Universal/Variable/RuntimeDxe/VariableRuntimeDxe.inf
-  INF MdeModulePkg/Universal/FaultTolerantWriteDxe/FaultTolerantWriteDxe.inf
-  INF MdeModulePkg/Universal/MonotonicCounterRuntimeDxe/MonotonicCounterRuntimeDxe.inf
-  INF EmbeddedPkg/ResetRuntimeDxe/ResetRuntimeDxe.inf
-  INF EmbeddedPkg/RealTimeClockRuntimeDxe/RealTimeClockRuntimeDxe.inf
-  INF EmbeddedPkg/MetronomeDxe/MetronomeDxe.inf
-
-  INF MdeModulePkg/Universal/HiiDatabaseDxe/HiiDatabaseDxe.inf
-  
-  #
-  # Multiple Console IO support
-  #
-  INF MdeModulePkg/Universal/Console/ConPlatformDxe/ConPlatformDxe.inf
-  INF MdeModulePkg/Universal/Console/ConSplitterDxe/ConSplitterDxe.inf
-  INF MdeModulePkg/Universal/Console/GraphicsConsoleDxe/GraphicsConsoleDxe.inf
-  INF MdeModulePkg/Universal/Console/TerminalDxe/TerminalDxe.inf
-  INF EmbeddedPkg/SerialDxe/SerialDxe.inf
-
-  INF ArmPkg/Drivers/PL390Gic/PL390GicDxe.inf
-  INF ArmPkg/Drivers/TimerDxe/TimerDxe.inf
-  INF ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashDxe.inf
-  INF ArmPlatformPkg/Drivers/LcdGraphicsOutputDxe/PL111LcdGraphicsOutputDxe.inf
-  INF ArmPlatformPkg/Drivers/SP805WatchdogDxe/SP805WatchdogDxe.inf
-
-  #
-  # Semi-hosting filesystem
-  #
-  INF ArmPkg/Filesystem/SemihostFs/SemihostFs.inf
-  
-  #
-  # FAT filesystem + GPT/MBR partitioning
-  #
-  INF MdeModulePkg/Universal/Disk/DiskIoDxe/DiskIoDxe.inf
-  INF MdeModulePkg/Universal/Disk/PartitionDxe/PartitionDxe.inf
-  INF FatBinPkg/EnhancedFatDxe/Fat.inf
-  INF MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf
-
-  #
-  # Multimedia Card Interface
-  #
-  INF EmbeddedPkg/Universal/MmcDxe/MmcDxe.inf
-  INF ArmPlatformPkg/Drivers/PL180MciDxe/PL180MciDxe.inf
-
-  #
-  # UEFI application (Shell Embedded Boot Loader) 
-  #  
-  INF ShellBinPkg/UefiShell/UefiShell.inf 
-  
-  #
-  # Bds
-  #
-  INF MdeModulePkg/Universal/DevicePathDxe/DevicePathDxe.inf
-  INF ArmPlatformPkg/Bds/Bds.inf
-
-
-[FV.FVMAIN_COMPACT]
-FvAlignment        = 8
-ERASE_POLARITY     = 1
-MEMORY_MAPPED      = TRUE
-STICKY_WRITE       = TRUE
-LOCK_CAP           = TRUE
-LOCK_STATUS        = TRUE
-WRITE_DISABLED_CAP = TRUE
-WRITE_ENABLED_CAP  = TRUE
-WRITE_STATUS       = TRUE
-WRITE_LOCK_CAP     = TRUE
-WRITE_LOCK_STATUS  = TRUE
-READ_DISABLED_CAP  = TRUE
-READ_ENABLED_CAP   = TRUE
-READ_STATUS        = TRUE
-READ_LOCK_CAP      = TRUE
-READ_LOCK_STATUS   = TRUE
-
-!if $(EDK2_SKIP_PEICORE) == 1
-  INF ArmPlatformPkg/PrePi/PeiMPCore.inf
-!else
-  INF ArmPlatformPkg/PrePeiCore/PrePeiCoreMPCore.inf
-  INF MdeModulePkg/Core/Pei/PeiMain.inf
-  INF ArmPlatformPkg/PlatformPei/PlatformPeim.inf
-  INF ArmPlatformPkg/MemoryInitPei/MemoryInitPeim.inf
-  INF ArmPkg/Drivers/CpuPei/CpuPei.inf
-  INF MdeModulePkg/Universal/PCD/Pei/Pcd.inf
-  INF IntelFrameworkModulePkg/Universal/StatusCode/Pei/StatusCodePei.inf
-  INF MdeModulePkg/Universal/Variable/Pei/VariablePei.inf
-  INF MdeModulePkg/Core/DxeIplPeim/DxeIpl.inf
-!endif
-  
-  FILE FV_IMAGE = 9E21FD93-9C72-4c15-8C4B-E77F1DB2D792 {
-    SECTION GUIDED EE4E5898-3914-4259-9D6E-DC7BD79403CF PROCESSING_REQUIRED = TRUE {
-      SECTION FV_IMAGE = FVMAIN
-    }
-  }
-
-
-################################################################################
-#
-# Rules are use with the [FV] section's module INF type to define
-# how an FFS file is created for a given INF file. The following Rule are the default
-# rules for the different module type. User can add the customized rules to define the
-# content of the FFS file.
-#
-################################################################################
-
-
-############################################################################
-# Example of a DXE_DRIVER FFS file with a Checksum encapsulation section   # 
-############################################################################
-#
-#[Rule.Common.DXE_DRIVER]
-#  FILE DRIVER = $(NAMED_GUID) {
-#    DXE_DEPEX    DXE_DEPEX               Optional $(INF_OUTPUT)/$(MODULE_NAME).depex
-#    COMPRESS PI_STD {
-#      GUIDED {
-#        PE32     PE32                    $(INF_OUTPUT)/$(MODULE_NAME).efi
-#        UI       STRING="$(MODULE_NAME)" Optional
-#        VERSION  STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)
-#      }
-#    }
-#  }
-#
-############################################################################
-
-[Rule.Common.SEC]
-  FILE SEC = $(NAMED_GUID) RELOCS_STRIPPED {
-    TE  TE    Align = 32                $(INF_OUTPUT)/$(MODULE_NAME).efi
-  }
-
-[Rule.Common.PEI_CORE]
-  FILE PEI_CORE = $(NAMED_GUID) {
-    TE     TE                           $(INF_OUTPUT)/$(MODULE_NAME).efi
-    UI     STRING ="$(MODULE_NAME)" Optional         
-  }
-
-[Rule.Common.PEIM]
-  FILE PEIM = $(NAMED_GUID) {
-     PEI_DEPEX PEI_DEPEX Optional       $(INF_OUTPUT)/$(MODULE_NAME).depex
-     TE       TE                        $(INF_OUTPUT)/$(MODULE_NAME).efi
-     UI       STRING="$(MODULE_NAME)" Optional         
-  }
-
-[Rule.Common.PEIM.TIANOCOMPRESSED]
-  FILE PEIM = $(NAMED_GUID) DEBUG_MYTOOLS_IA32 {
-    PEI_DEPEX PEI_DEPEX Optional        $(INF_OUTPUT)/$(MODULE_NAME).depex
-    GUIDED A31280AD-481E-41B6-95E8-127F4C984779 PROCESSING_REQUIRED = TRUE {
-      PE32      PE32                    $(INF_OUTPUT)/$(MODULE_NAME).efi
-      UI        STRING="$(MODULE_NAME)" Optional
-    }
-  }
-
-[Rule.Common.DXE_CORE]
-  FILE DXE_CORE = $(NAMED_GUID) {
-    PE32     PE32                       $(INF_OUTPUT)/$(MODULE_NAME).efi
-    UI       STRING="$(MODULE_NAME)" Optional
-  }
-
-[Rule.Common.UEFI_DRIVER]
-  FILE DRIVER = $(NAMED_GUID) {
-    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex
-    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi
-    UI           STRING="$(MODULE_NAME)" Optional
-  }
-
-[Rule.Common.DXE_DRIVER]
-  FILE DRIVER = $(NAMED_GUID) {
-    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex
-    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi
-    UI           STRING="$(MODULE_NAME)" Optional
-  }
-
-[Rule.Common.DXE_RUNTIME_DRIVER]
-  FILE DRIVER = $(NAMED_GUID) {
-    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex
-    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi
-    UI           STRING="$(MODULE_NAME)" Optional
-  }
-
-[Rule.Common.UEFI_APPLICATION]
-  FILE APPLICATION = $(NAMED_GUID) {
-    UI     STRING ="$(MODULE_NAME)" Optional         
-    PE32   PE32                         $(INF_OUTPUT)/$(MODULE_NAME).efi
-  }
-
-[Rule.Common.UEFI_DRIVER.BINARY]
-  FILE DRIVER = $(NAMED_GUID) {
-    DXE_DEPEX DXE_DEPEX Optional      |.depex
-    PE32      PE32                    |.efi
-    UI        STRING="$(MODULE_NAME)" Optional
-    VERSION   STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)
-  }
-
-[Rule.Common.UEFI_APPLICATION.BINARY]
-  FILE APPLICATION = $(NAMED_GUID) {
-    PE32      PE32                    |.efi
-    UI        STRING="$(MODULE_NAME)" Optional
-    VERSION   STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)
-  }
+# FLASH layout file for ARM VE.

+#

+#  Copyright (c) 2011, ARM Limited. All rights reserved.

+#  

+#  This program and the accompanying materials                          

+#  are licensed and made available under the terms and conditions of the BSD License         

+#  which accompanies this distribution.  The full text of the license may be found at        

+#  http://opensource.org/licenses/bsd-license.php                                            

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+#

+

+################################################################################

+#

+# FD Section

+# The [FD] Section is made up of the definition statements and a

+# description of what goes into  the Flash Device Image.  Each FD section

+# defines one flash "device" image.  A flash device image may be one of

+# the following: Removable media bootable image (like a boot floppy

+# image,) an Option ROM image (that would be "flashed" into an add-in

+# card,) a System "Flash"  image (that would be burned into a system's

+# flash) or an Update ("Capsule") image that will be used to update and

+# existing system flash.

+#

+################################################################################

+

+[FD.RTSM_VE_Cortex-A15_MPCore_EFI]

+BaseAddress   = 0x08000000|gArmTokenSpaceGuid.PcdFdBaseAddress  # The base address of the Firmware in NOR Flash.

+Size          = 0x00280000|gArmTokenSpaceGuid.PcdFdSize         # The size in bytes of the FLASH Device

+ErasePolarity = 1

+

+# This one is tricky, it must be: BlockSize * NumBlocks = Size

+BlockSize     = 0x00001000

+NumBlocks     = 0x280

+

+################################################################################

+#

+# Following are lists of FD Region layout which correspond to the locations of different

+# images within the flash device.

+#

+# Regions must be defined in ascending order and may not overlap.

+#

+# A Layout Region start with a eight digit hex offset (leading "0x" required) followed by

+# the pipe "|" character, followed by the size of the region, also in hex with the leading

+# "0x" characters. Like:

+# Offset|Size

+# PcdOffsetCName|PcdSizeCName

+# RegionType <FV, DATA, or FILE>

+#

+################################################################################

+

+0x00000000|0x00080000

+gArmTokenSpaceGuid.PcdSecureFvBaseAddress|gArmTokenSpaceGuid.PcdSecureFvSize

+FV = FVMAIN_SEC

+

+0x00080000|0x00280000

+gArmTokenSpaceGuid.PcdFvBaseAddress|gArmTokenSpaceGuid.PcdFvSize

+FV = FVMAIN_COMPACT

+

+

+################################################################################

+#

+# FV Section

+#

+# [FV] section is used to define what components or modules are placed within a flash

+# device file.  This section also defines order the components and modules are positioned

+# within the image.  The [FV] section consists of define statements, set statements and

+# module statements.

+#

+################################################################################

+

+[FV.FVMAIN_SEC]

+FvAlignment        = 8

+ERASE_POLARITY     = 1

+MEMORY_MAPPED      = TRUE

+STICKY_WRITE       = TRUE

+LOCK_CAP           = TRUE

+LOCK_STATUS        = TRUE

+WRITE_DISABLED_CAP = TRUE

+WRITE_ENABLED_CAP  = TRUE

+WRITE_STATUS       = TRUE

+WRITE_LOCK_CAP     = TRUE

+WRITE_LOCK_STATUS  = TRUE

+READ_DISABLED_CAP  = TRUE

+READ_ENABLED_CAP   = TRUE

+READ_STATUS        = TRUE

+READ_LOCK_CAP      = TRUE

+READ_LOCK_STATUS   = TRUE

+

+  INF ArmPlatformPkg/Sec/Sec.inf

+

+

+[FV.FvMain]

+BlockSize          = 0x40

+NumBlocks          = 0         # This FV gets compressed so make it just big enough

+FvAlignment        = 8         # FV alignment and FV attributes setting.

+ERASE_POLARITY     = 1

+MEMORY_MAPPED      = TRUE

+STICKY_WRITE       = TRUE

+LOCK_CAP           = TRUE

+LOCK_STATUS        = TRUE

+WRITE_DISABLED_CAP = TRUE

+WRITE_ENABLED_CAP  = TRUE

+WRITE_STATUS       = TRUE

+WRITE_LOCK_CAP     = TRUE

+WRITE_LOCK_STATUS  = TRUE

+READ_DISABLED_CAP  = TRUE

+READ_ENABLED_CAP   = TRUE

+READ_STATUS        = TRUE

+READ_LOCK_CAP      = TRUE

+READ_LOCK_STATUS   = TRUE

+

+  INF MdeModulePkg/Core/Dxe/DxeMain.inf 

+

+  #

+  # PI DXE Drivers producing Architectural Protocols (EFI Services) 

+  #

+  INF ArmPkg/Drivers/CpuDxe/CpuDxe.inf

+  INF MdeModulePkg/Core/RuntimeDxe/RuntimeDxe.inf

+  INF MdeModulePkg/Universal/SecurityStubDxe/SecurityStubDxe.inf

+  INF MdeModulePkg/Universal/CapsuleRuntimeDxe/CapsuleRuntimeDxe.inf

+  INF MdeModulePkg/Universal/Variable/RuntimeDxe/VariableRuntimeDxe.inf

+  INF MdeModulePkg/Universal/FaultTolerantWriteDxe/FaultTolerantWriteDxe.inf

+  INF MdeModulePkg/Universal/MonotonicCounterRuntimeDxe/MonotonicCounterRuntimeDxe.inf

+  INF EmbeddedPkg/ResetRuntimeDxe/ResetRuntimeDxe.inf

+  INF EmbeddedPkg/RealTimeClockRuntimeDxe/RealTimeClockRuntimeDxe.inf

+  INF EmbeddedPkg/MetronomeDxe/MetronomeDxe.inf

+

+  INF MdeModulePkg/Universal/HiiDatabaseDxe/HiiDatabaseDxe.inf

+  

+  #

+  # Multiple Console IO support

+  #

+  INF MdeModulePkg/Universal/Console/ConPlatformDxe/ConPlatformDxe.inf

+  INF MdeModulePkg/Universal/Console/ConSplitterDxe/ConSplitterDxe.inf

+  INF MdeModulePkg/Universal/Console/GraphicsConsoleDxe/GraphicsConsoleDxe.inf

+  INF MdeModulePkg/Universal/Console/TerminalDxe/TerminalDxe.inf

+  INF EmbeddedPkg/SerialDxe/SerialDxe.inf

+

+  INF ArmPkg/Drivers/PL390Gic/PL390GicDxe.inf

+  INF ArmPkg/Drivers/TimerDxe/TimerDxe.inf

+  INF ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashDxe.inf

+  INF ArmPlatformPkg/Drivers/LcdGraphicsOutputDxe/PL111LcdGraphicsOutputDxe.inf

+  INF ArmPlatformPkg/Drivers/SP805WatchdogDxe/SP805WatchdogDxe.inf

+

+  #

+  # Semi-hosting filesystem

+  #

+  INF ArmPkg/Filesystem/SemihostFs/SemihostFs.inf

+  

+  #

+  # FAT filesystem + GPT/MBR partitioning

+  #

+  INF MdeModulePkg/Universal/Disk/DiskIoDxe/DiskIoDxe.inf

+  INF MdeModulePkg/Universal/Disk/PartitionDxe/PartitionDxe.inf

+  INF FatBinPkg/EnhancedFatDxe/Fat.inf

+  INF MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf

+

+  #

+  # Multimedia Card Interface

+  #

+  INF EmbeddedPkg/Universal/MmcDxe/MmcDxe.inf

+  INF ArmPlatformPkg/Drivers/PL180MciDxe/PL180MciDxe.inf

+

+  #

+  # UEFI application (Shell Embedded Boot Loader) 

+  #  

+  INF ShellBinPkg/UefiShell/UefiShell.inf 

+  

+  #

+  # Bds

+  #

+  INF MdeModulePkg/Universal/DevicePathDxe/DevicePathDxe.inf

+  INF ArmPlatformPkg/Bds/Bds.inf

+

+

+[FV.FVMAIN_COMPACT]

+FvAlignment        = 8

+ERASE_POLARITY     = 1

+MEMORY_MAPPED      = TRUE

+STICKY_WRITE       = TRUE

+LOCK_CAP           = TRUE

+LOCK_STATUS        = TRUE

+WRITE_DISABLED_CAP = TRUE

+WRITE_ENABLED_CAP  = TRUE

+WRITE_STATUS       = TRUE

+WRITE_LOCK_CAP     = TRUE

+WRITE_LOCK_STATUS  = TRUE

+READ_DISABLED_CAP  = TRUE

+READ_ENABLED_CAP   = TRUE

+READ_STATUS        = TRUE

+READ_LOCK_CAP      = TRUE

+READ_LOCK_STATUS   = TRUE

+

+!if $(EDK2_SKIP_PEICORE) == 1

+  INF ArmPlatformPkg/PrePi/PeiMPCore.inf

+!else

+  INF ArmPlatformPkg/PrePeiCore/PrePeiCoreMPCore.inf

+  INF MdeModulePkg/Core/Pei/PeiMain.inf

+  INF ArmPlatformPkg/PlatformPei/PlatformPeim.inf

+  INF ArmPlatformPkg/MemoryInitPei/MemoryInitPeim.inf

+  INF ArmPkg/Drivers/CpuPei/CpuPei.inf

+  INF MdeModulePkg/Universal/PCD/Pei/Pcd.inf

+  INF IntelFrameworkModulePkg/Universal/StatusCode/Pei/StatusCodePei.inf

+  INF MdeModulePkg/Universal/Variable/Pei/VariablePei.inf

+  INF MdeModulePkg/Core/DxeIplPeim/DxeIpl.inf

+!endif

+  

+  FILE FV_IMAGE = 9E21FD93-9C72-4c15-8C4B-E77F1DB2D792 {

+    SECTION GUIDED EE4E5898-3914-4259-9D6E-DC7BD79403CF PROCESSING_REQUIRED = TRUE {

+      SECTION FV_IMAGE = FVMAIN

+    }

+  }

+

+

+################################################################################

+#

+# Rules are use with the [FV] section's module INF type to define

+# how an FFS file is created for a given INF file. The following Rule are the default

+# rules for the different module type. User can add the customized rules to define the

+# content of the FFS file.

+#

+################################################################################

+

+

+############################################################################

+# Example of a DXE_DRIVER FFS file with a Checksum encapsulation section   # 

+############################################################################

+#

+#[Rule.Common.DXE_DRIVER]

+#  FILE DRIVER = $(NAMED_GUID) {

+#    DXE_DEPEX    DXE_DEPEX               Optional $(INF_OUTPUT)/$(MODULE_NAME).depex

+#    COMPRESS PI_STD {

+#      GUIDED {

+#        PE32     PE32                    $(INF_OUTPUT)/$(MODULE_NAME).efi

+#        UI       STRING="$(MODULE_NAME)" Optional

+#        VERSION  STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)

+#      }

+#    }

+#  }

+#

+############################################################################

+

+[Rule.Common.SEC]

+  FILE SEC = $(NAMED_GUID) RELOCS_STRIPPED {

+    TE  TE    Align = 32                $(INF_OUTPUT)/$(MODULE_NAME).efi

+  }

+

+[Rule.Common.PEI_CORE]

+  FILE PEI_CORE = $(NAMED_GUID) {

+    TE     TE                           $(INF_OUTPUT)/$(MODULE_NAME).efi

+    UI     STRING ="$(MODULE_NAME)" Optional         

+  }

+

+[Rule.Common.PEIM]

+  FILE PEIM = $(NAMED_GUID) {

+     PEI_DEPEX PEI_DEPEX Optional       $(INF_OUTPUT)/$(MODULE_NAME).depex

+     TE       TE                        $(INF_OUTPUT)/$(MODULE_NAME).efi

+     UI       STRING="$(MODULE_NAME)" Optional         

+  }

+

+[Rule.Common.PEIM.TIANOCOMPRESSED]

+  FILE PEIM = $(NAMED_GUID) DEBUG_MYTOOLS_IA32 {

+    PEI_DEPEX PEI_DEPEX Optional        $(INF_OUTPUT)/$(MODULE_NAME).depex

+    GUIDED A31280AD-481E-41B6-95E8-127F4C984779 PROCESSING_REQUIRED = TRUE {

+      PE32      PE32                    $(INF_OUTPUT)/$(MODULE_NAME).efi

+      UI        STRING="$(MODULE_NAME)" Optional

+    }

+  }

+

+[Rule.Common.DXE_CORE]

+  FILE DXE_CORE = $(NAMED_GUID) {

+    PE32     PE32                       $(INF_OUTPUT)/$(MODULE_NAME).efi

+    UI       STRING="$(MODULE_NAME)" Optional

+  }

+

+[Rule.Common.UEFI_DRIVER]

+  FILE DRIVER = $(NAMED_GUID) {

+    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex

+    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi

+    UI           STRING="$(MODULE_NAME)" Optional

+  }

+

+[Rule.Common.DXE_DRIVER]

+  FILE DRIVER = $(NAMED_GUID) {

+    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex

+    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi

+    UI           STRING="$(MODULE_NAME)" Optional

+  }

+

+[Rule.Common.DXE_RUNTIME_DRIVER]

+  FILE DRIVER = $(NAMED_GUID) {

+    DXE_DEPEX    DXE_DEPEX              Optional $(INF_OUTPUT)/$(MODULE_NAME).depex

+    PE32         PE32                   $(INF_OUTPUT)/$(MODULE_NAME).efi

+    UI           STRING="$(MODULE_NAME)" Optional

+  }

+

+[Rule.Common.UEFI_APPLICATION]

+  FILE APPLICATION = $(NAMED_GUID) {

+    UI     STRING ="$(MODULE_NAME)" Optional         

+    PE32   PE32                         $(INF_OUTPUT)/$(MODULE_NAME).efi

+  }

+

+[Rule.Common.UEFI_DRIVER.BINARY]

+  FILE DRIVER = $(NAMED_GUID) {

+    DXE_DEPEX DXE_DEPEX Optional      |.depex

+    PE32      PE32                    |.efi

+    UI        STRING="$(MODULE_NAME)" Optional

+    VERSION   STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)

+  }

+

+[Rule.Common.UEFI_APPLICATION.BINARY]

+  FILE APPLICATION = $(NAMED_GUID) {

+    PE32      PE32                    |.efi

+    UI        STRING="$(MODULE_NAME)" Optional

+    VERSION   STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)

+  }

diff --git a/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress.dsc.inc b/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress.dsc.inc
index 8672993b..47dc0ff7 100644
--- a/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress.dsc.inc
+++ b/ArmPlatformPkg/ArmVExpressPkg/ArmVExpress.dsc.inc
@@ -62,6 +62,7 @@
   DmaLib|ArmPkg/Library/ArmDmaLib/ArmDmaLib.inf

   ArmGicLib|ArmPkg/Drivers/PL390Gic/PL390GicLib.inf

   ArmPlatformStackLib|ArmPlatformPkg/Library/ArmPlatformStackLib/ArmPlatformStackLib.inf

+  ArmSmcLib|ArmPkg/Library/ArmSmcLib/ArmSmcLib.inf

 

   # Versatile Express Specific Libraries

   ArmPlatformSysConfigLib|ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressSysConfigLib/ArmVExpressSysConfigLib.inf

@@ -76,6 +77,7 @@
   # ARM PL011 UART Driver

   PL011UartLib|ArmPlatformPkg/Drivers/PL011Uart/PL011Uart.inf

   SerialPortLib|ArmPlatformPkg/Library/PL011SerialPortLib/PL011SerialPortLib.inf

+  SerialPortExtLib|ArmPlatformPkg/Library/PL011SerialPortLib/PL011SerialPortExtLib.inf

   # ARM SP804 Dual Timer Driver

   TimerLib|ArmPlatformPkg/Library/SP804TimerLib/SP804TimerLib.inf

 

diff --git a/ArmPlatformPkg/ArmVExpressPkg/Include/Platform/CTA15-A7/ArmPlatform.h b/ArmPlatformPkg/ArmVExpressPkg/Include/Platform/CTA15-A7/ArmPlatform.h
index 365f0600..b52f89a5 100644
--- a/ArmPlatformPkg/ArmVExpressPkg/Include/Platform/CTA15-A7/ArmPlatform.h
+++ b/ArmPlatformPkg/ArmVExpressPkg/Include/Platform/CTA15-A7/ArmPlatform.h
@@ -97,10 +97,11 @@
 

 #define ARM_CTA15A7_SCC_SYSINFO                 ARM_CTA15A7_SCC_CFGREG48

 

-#define ARM_CTA15A7_SCC_SYSINFO_CLUSTER_A7_NUM_CPU(val)   (((val) >> 20) & 0xF)

-#define ARM_CTA15A7_SCC_SYSINFO_CLUSTER_A15_NUM_CPU(val)  (((val) >> 16) & 0xF)

-#define ARM_CTA15A7_SCC_SYSINFO_ACTIVE_CLUSTER_A15        (1 << 0)

-#define ARM_CTA15A7_SCC_SYSINFO_ACTIVE_CLUSTER_A7         (1 << 1)

+#define ARM_CTA15A7_SCC_SYSINFO_CLUSTER_A7_NUM_CPU(val)         (((val) >> 20) & 0xF)

+#define ARM_CTA15A7_SCC_SYSINFO_CLUSTER_A15_NUM_CPU(val)        (((val) >> 16) & 0xF)

+#define ARM_CTA15A7_SCC_SYSINFO_ACTIVE_CLUSTER_A15              (1 << 0)

+#define ARM_CTA15A7_SCC_SYSINFO_ACTIVE_CLUSTER_A7               (1 << 1)

+#define ARM_CTA15A7_SCC_SYSINFO_UEFI_RESTORE_DEFAULT_NORFLASH   (1 << 4)

 

 #define ARM_CTA15A7_SPC_BASE                    0x7FFF0B00

 #define ARM_CTA15A7_SPC_WAKE_INT_MASK           (ARM_CTA15A7_SPC_BASE + 0x24)

diff --git a/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressLibCTA15-A7/CTA15-A7.c b/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressLibCTA15-A7/CTA15-A7.c
index c650a6e3..87f41c7a 100644
--- a/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressLibCTA15-A7/CTA15-A7.c
+++ b/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressLibCTA15-A7/CTA15-A7.c
@@ -121,7 +121,11 @@ ArmPlatformGetBootMode (
   VOID

   )

 {

-  return BOOT_WITH_FULL_CONFIGURATION;

+  if (MmioRead32(ARM_CTA15A7_SCC_SYSINFO) & ARM_CTA15A7_SCC_SYSINFO_UEFI_RESTORE_DEFAULT_NORFLASH) {

+    return BOOT_WITH_DEFAULT_SETTINGS;

+  } else {

+    return BOOT_WITH_FULL_CONFIGURATION;

+  }

 }

 

 /**

diff --git a/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressLibCTA9x4/ArmVExpressLib.inf b/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressLibCTA9x4/ArmVExpressLib.inf
index f20db58d..a255c40b 100644
--- a/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressLibCTA9x4/ArmVExpressLib.inf
+++ b/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressLibCTA9x4/ArmVExpressLib.inf
@@ -1,55 +1,55 @@
-#/* @file
-#  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-#  
-#  This program and the accompanying materials                          
-#  are licensed and made available under the terms and conditions of the BSD License         
-#  which accompanies this distribution.  The full text of the license may be found at        
-#  http://opensource.org/licenses/bsd-license.php                                            
-#
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-#
-#*/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = CTA9x4ArmVExpressLib
-  FILE_GUID                      = b16c63a0-f417-11df-b3af-0002a5d5c51b
-  MODULE_TYPE                    = BASE
-  VERSION_STRING                 = 1.0
-  LIBRARY_CLASS                  = ArmPlatformLib
-
-[Packages]
-  MdePkg/MdePkg.dec
-  MdeModulePkg/MdeModulePkg.dec
-  EmbeddedPkg/EmbeddedPkg.dec
-  ArmPkg/ArmPkg.dec
-  ArmPlatformPkg/ArmPlatformPkg.dec
-
-[LibraryClasses]
-  IoLib
-  ArmLib
-  ArmTrustZoneLib
-  MemoryAllocationLib
-  PL341DmcLib
-  PL301AxiLib
-  L2X0CacheLib
-  SerialPortLib
-
-[Sources.common]
-  CTA9x4.c
-  CTA9x4Mem.c
-
-[FeaturePcd]
-  gEmbeddedTokenSpaceGuid.PcdCacheEnable
-  gArmPlatformTokenSpaceGuid.PcdNorFlashRemapping
-
-[FixedPcd]
-  gArmTokenSpaceGuid.PcdTrustzoneSupport
-  gArmTokenSpaceGuid.PcdSystemMemoryBase
-  gArmTokenSpaceGuid.PcdSystemMemorySize
-
-  gArmTokenSpaceGuid.PcdL2x0ControllerBase
-
-  gArmTokenSpaceGuid.PcdArmPrimaryCoreMask
-  gArmTokenSpaceGuid.PcdArmPrimaryCore
+#/* @file

+#  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+#  

+#  This program and the accompanying materials                          

+#  are licensed and made available under the terms and conditions of the BSD License         

+#  which accompanies this distribution.  The full text of the license may be found at        

+#  http://opensource.org/licenses/bsd-license.php                                            

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+#

+#*/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = CTA9x4ArmVExpressLib

+  FILE_GUID                      = b16c63a0-f417-11df-b3af-0002a5d5c51b

+  MODULE_TYPE                    = BASE

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = ArmPlatformLib

+

+[Packages]

+  MdePkg/MdePkg.dec

+  MdeModulePkg/MdeModulePkg.dec

+  EmbeddedPkg/EmbeddedPkg.dec

+  ArmPkg/ArmPkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+

+[LibraryClasses]

+  IoLib

+  ArmLib

+  ArmTrustZoneLib

+  MemoryAllocationLib

+  PL341DmcLib

+  PL301AxiLib

+  L2X0CacheLib

+  SerialPortLib

+

+[Sources.common]

+  CTA9x4.c

+  CTA9x4Mem.c

+

+[FeaturePcd]

+  gEmbeddedTokenSpaceGuid.PcdCacheEnable

+  gArmPlatformTokenSpaceGuid.PcdNorFlashRemapping

+

+[FixedPcd]

+  gArmTokenSpaceGuid.PcdTrustzoneSupport

+  gArmTokenSpaceGuid.PcdSystemMemoryBase

+  gArmTokenSpaceGuid.PcdSystemMemorySize

+

+  gArmTokenSpaceGuid.PcdL2x0ControllerBase

+

+  gArmTokenSpaceGuid.PcdArmPrimaryCoreMask

+  gArmTokenSpaceGuid.PcdArmPrimaryCore

diff --git a/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressLibCTA9x4/CTA9x4.c b/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressLibCTA9x4/CTA9x4.c
index 98604415..fb920aa4 100644
--- a/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressLibCTA9x4/CTA9x4.c
+++ b/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressLibCTA9x4/CTA9x4.c
@@ -1,222 +1,213 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-#include <Library/IoLib.h>
-#include <Library/ArmPlatformLib.h>
-#include <Library/DebugLib.h>
-#include <Library/PcdLib.h>
-#include <Library/SerialPortLib.h>
-
-#include <Drivers/PL341Dmc.h>
-#include <Drivers/PL301Axi.h>
-#include <Drivers/SP804Timer.h>
-
-#include <Ppi/ArmMpCoreInfo.h>
-
-#include <ArmPlatform.h>
-
-#define SerialPrint(txt)  SerialPortWrite ((UINT8*)(txt), AsciiStrLen(txt)+1);
-
-ARM_CORE_INFO mVersatileExpressMpCoreInfoCTA9x4[] = {
-  {
-    // Cluster 0, Core 0
-    0x0, 0x0,
-
-    // MP Core MailBox Set/Get/Clear Addresses and Clear Value
-    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_REG,
-    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_SET_REG,
-    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_CLR_REG,
-    (UINT64)0xFFFFFFFF
-  },
-  {
-    // Cluster 0, Core 1
-    0x0, 0x1,
-
-    // MP Core MailBox Set/Get/Clear Addresses and Clear Value
-    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_REG,
-    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_SET_REG,
-    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_CLR_REG,
-    (UINT64)0xFFFFFFFF
-  },
-  {
-    // Cluster 0, Core 2
-    0x0, 0x2,
-
-    // MP Core MailBox Set/Get/Clear Addresses and Clear Value
-    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_REG,
-    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_SET_REG,
-    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_CLR_REG,
-    (UINT64)0xFFFFFFFF
-  },
-  {
-    // Cluster 0, Core 3
-    0x0, 0x3,
-
-    // MP Core MailBox Set/Get/Clear Addresses and Clear Value
-    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_REG,
-    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_SET_REG,
-    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_CLR_REG,
-    (UINT64)0xFFFFFFFF
-  }
-};
-
-// DDR2 timings
-PL341_DMC_CONFIG DDRTimings = {
-  .MaxChip   = 1,
-  .IsUserCfg = TRUE,
-  .User0Cfg = 0x7C924924,
-  .User2Cfg = (TC_UIOLHXC_VALUE << TC_UIOLHNC_SHIFT) | (TC_UIOLHXC_VALUE << TC_UIOLHPC_SHIFT) | (0x1 << TC_UIOHOCT_SHIFT) | (0x1 << TC_UIOHSTOP_SHIFT),
-  .HasQos    = TRUE,
-  .RefreshPeriod  = 0x3D0,
-  .CasLatency  = 0x8,
-  .WriteLatency  = 0x3,
-  .t_mrd    = 0x2,
-  .t_ras    = 0xA,
-  .t_rc   = 0xE,
-  .t_rcd    = 0x104,
-  .t_rfc    = 0x2f32,
-  .t_rp   = 0x14,
-  .t_rrd    = 0x2,
-  .t_wr   = 0x4,
-  .t_wtr    = 0x2,
-  .t_xp   = 0x2,
-  .t_xsr    = 0xC8,
-  .t_esr    = 0x14,
-  .MemoryCfg   = DMC_MEMORY_CONFIG_ACTIVE_CHIP_1 | DMC_MEMORY_CONFIG_BURST_4 |
-                        DMC_MEMORY_CONFIG_ROW_ADDRESS_15 | DMC_MEMORY_CONFIG_COLUMN_ADDRESS_10,
-  .MemoryCfg2  = DMC_MEMORY_CFG2_DQM_INIT | DMC_MEMORY_CFG2_CKE_INIT |
-            DMC_MEMORY_CFG2_BANK_BITS_3 | DMC_MEMORY_CFG2_MEM_WIDTH_32,
-  .MemoryCfg3  = 0x00000001,
-  .ChipCfg0    = 0x00010000,
-  .t_faw    = 0x00000A0D,
-  .ModeReg = DDR2_MR_BURST_LENGTH_4 | DDR2_MR_CAS_LATENCY_4 | DDR2_MR_WR_CYCLES_4,
-  .ExtModeReg = DDR_EMR_RTT_50R | (DDR_EMR_ODS_VAL << DDR_EMR_ODS_MASK),
-};
-
-/**
-  Return the current Boot Mode
-
-  This function returns the boot reason on the platform
-
-  @return   Return the current Boot Mode of the platform
-
-**/
-EFI_BOOT_MODE
-ArmPlatformGetBootMode (
-  VOID
-  )
-{
-  if (MmioRead32(ARM_VE_SYS_FLAGS_NV_REG) == 0) {
-    return BOOT_WITH_FULL_CONFIGURATION;
-  } else {
-    return BOOT_ON_S2_RESUME;
-  }
-}
-
-/**
-  Initialize controllers that must setup in the normal world
-
-  This function is called by the ArmPlatformPkg/PrePi or ArmPlatformPkg/PlatformPei
-  in the PEI phase.
-
-**/
-RETURN_STATUS
-ArmPlatformInitialize (
-  IN  UINTN                     MpId
-  )
-{
-  if (!IS_PRIMARY_CORE(MpId)) {
-    return RETURN_SUCCESS;
-  }
-
-  // Configure periodic timer (TIMER0) for 1MHz operation
-  MmioOr32 (SP810_CTRL_BASE + SP810_SYS_CTRL_REG, SP810_SYS_CTRL_TIMER0_TIMCLK);
-  // Configure 1MHz clock
-  MmioOr32 (SP810_CTRL_BASE + SP810_SYS_CTRL_REG, SP810_SYS_CTRL_TIMER1_TIMCLK);
-  // configure SP810 to use 1MHz clock and disable
-  MmioAndThenOr32 (SP810_CTRL_BASE + SP810_SYS_CTRL_REG, ~SP810_SYS_CTRL_TIMER2_EN, SP810_SYS_CTRL_TIMER2_TIMCLK);
-  // Configure SP810 to use 1MHz clock and disable
-  MmioAndThenOr32 (SP810_CTRL_BASE + SP810_SYS_CTRL_REG, ~SP810_SYS_CTRL_TIMER3_EN, SP810_SYS_CTRL_TIMER3_TIMCLK);
-
-  return RETURN_SUCCESS;
-}
-
-/**
-  Initialize the system (or sometimes called permanent) memory
-
-  This memory is generally represented by the DRAM.
-
-**/
-VOID
-ArmPlatformInitializeSystemMemory (
-  VOID
-  )
-{
-  UINT32 Value;
-
-  // Memory Map remapping
-  if (FeaturePcdGet(PcdNorFlashRemapping)) {
-    SerialPrint ("Secure ROM at 0x0\n\r");
-  } else {
-    Value = MmioRead32(ARM_VE_SYS_CFGRW1_REG); //Scc - CFGRW1
-    // Remap the DRAM to 0x0
-    MmioWrite32(ARM_VE_SYS_CFGRW1_REG, (Value & 0x0FFFFFFF) | ARM_VE_CFGRW1_REMAP_DRAM);
-  }
-
-  PL341DmcInit(ARM_VE_DMC_BASE, &DDRTimings);
-  PL301AxiInit(ARM_VE_FAXI_BASE);
-}
-
-EFI_STATUS
-PrePeiCoreGetMpCoreInfo (
-  OUT UINTN                   *CoreCount,
-  OUT ARM_CORE_INFO           **ArmCoreTable
-  )
-{
-  *CoreCount    = sizeof(mVersatileExpressMpCoreInfoCTA9x4) / sizeof(ARM_CORE_INFO);
-  *ArmCoreTable = mVersatileExpressMpCoreInfoCTA9x4;
-
-  return EFI_SUCCESS;
-}
-
-// Needs to be declared in the file. Otherwise gArmMpCoreInfoPpiGuid is undefined in the contect of PrePeiCore
-EFI_GUID mArmMpCoreInfoPpiGuid = ARM_MP_CORE_INFO_PPI_GUID;
-ARM_MP_CORE_INFO_PPI mMpCoreInfoPpi = { PrePeiCoreGetMpCoreInfo };
-
-EFI_PEI_PPI_DESCRIPTOR      gPlatformPpiTable[] = {
-  {
-    EFI_PEI_PPI_DESCRIPTOR_PPI,
-    &mArmMpCoreInfoPpiGuid,
-    &mMpCoreInfoPpi
-  }
-};
-
-VOID
-ArmPlatformGetPlatformPpiList (
-  OUT UINTN                   *PpiListSize,
-  OUT EFI_PEI_PPI_DESCRIPTOR  **PpiList
-  )
-{
-  *PpiListSize = sizeof(gPlatformPpiTable);
-  *PpiList = gPlatformPpiTable;
-}
-
-UINTN
-ArmPlatformGetCorePosition (
-  IN UINTN MpId
-  )
-{
-  return 1;
-}
-
+/** @file

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+#include <Library/IoLib.h>

+#include <Library/ArmPlatformLib.h>

+#include <Library/DebugLib.h>

+#include <Library/PcdLib.h>

+#include <Library/SerialPortLib.h>

+

+#include <Drivers/PL341Dmc.h>

+#include <Drivers/PL301Axi.h>

+#include <Drivers/SP804Timer.h>

+

+#include <Ppi/ArmMpCoreInfo.h>

+

+#include <ArmPlatform.h>

+

+#define SerialPrint(txt)  SerialPortWrite ((UINT8*)(txt), AsciiStrLen(txt)+1);

+

+ARM_CORE_INFO mVersatileExpressMpCoreInfoCTA9x4[] = {

+  {

+    // Cluster 0, Core 0

+    0x0, 0x0,

+

+    // MP Core MailBox Set/Get/Clear Addresses and Clear Value

+    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_REG,

+    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_SET_REG,

+    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_CLR_REG,

+    (UINT64)0xFFFFFFFF

+  },

+  {

+    // Cluster 0, Core 1

+    0x0, 0x1,

+

+    // MP Core MailBox Set/Get/Clear Addresses and Clear Value

+    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_REG,

+    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_SET_REG,

+    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_CLR_REG,

+    (UINT64)0xFFFFFFFF

+  },

+  {

+    // Cluster 0, Core 2

+    0x0, 0x2,

+

+    // MP Core MailBox Set/Get/Clear Addresses and Clear Value

+    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_REG,

+    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_SET_REG,

+    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_CLR_REG,

+    (UINT64)0xFFFFFFFF

+  },

+  {

+    // Cluster 0, Core 3

+    0x0, 0x3,

+

+    // MP Core MailBox Set/Get/Clear Addresses and Clear Value

+    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_REG,

+    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_SET_REG,

+    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_CLR_REG,

+    (UINT64)0xFFFFFFFF

+  }

+};

+

+// DDR2 timings

+PL341_DMC_CONFIG DDRTimings = {

+  .MaxChip   = 1,

+  .IsUserCfg = TRUE,

+  .User0Cfg = 0x7C924924,

+  .User2Cfg = (TC_UIOLHXC_VALUE << TC_UIOLHNC_SHIFT) | (TC_UIOLHXC_VALUE << TC_UIOLHPC_SHIFT) | (0x1 << TC_UIOHOCT_SHIFT) | (0x1 << TC_UIOHSTOP_SHIFT),

+  .HasQos    = TRUE,

+  .RefreshPeriod  = 0x3D0,

+  .CasLatency  = 0x8,

+  .WriteLatency  = 0x3,

+  .t_mrd    = 0x2,

+  .t_ras    = 0xA,

+  .t_rc   = 0xE,

+  .t_rcd    = 0x104,

+  .t_rfc    = 0x2f32,

+  .t_rp   = 0x14,

+  .t_rrd    = 0x2,

+  .t_wr   = 0x4,

+  .t_wtr    = 0x2,

+  .t_xp   = 0x2,

+  .t_xsr    = 0xC8,

+  .t_esr    = 0x14,

+  .MemoryCfg   = DMC_MEMORY_CONFIG_ACTIVE_CHIP_1 | DMC_MEMORY_CONFIG_BURST_4 |

+                        DMC_MEMORY_CONFIG_ROW_ADDRESS_15 | DMC_MEMORY_CONFIG_COLUMN_ADDRESS_10,

+  .MemoryCfg2  = DMC_MEMORY_CFG2_DQM_INIT | DMC_MEMORY_CFG2_CKE_INIT |

+            DMC_MEMORY_CFG2_BANK_BITS_3 | DMC_MEMORY_CFG2_MEM_WIDTH_32,

+  .MemoryCfg3  = 0x00000001,

+  .ChipCfg0    = 0x00010000,

+  .t_faw    = 0x00000A0D,

+  .ModeReg = DDR2_MR_BURST_LENGTH_4 | DDR2_MR_CAS_LATENCY_4 | DDR2_MR_WR_CYCLES_4,

+  .ExtModeReg = DDR_EMR_RTT_50R | (DDR_EMR_ODS_VAL << DDR_EMR_ODS_MASK),

+};

+

+/**

+  Return the current Boot Mode

+

+  This function returns the boot reason on the platform

+

+  @return   Return the current Boot Mode of the platform

+

+**/

+EFI_BOOT_MODE

+ArmPlatformGetBootMode (

+  VOID

+  )

+{

+  if (MmioRead32(ARM_VE_SYS_FLAGS_NV_REG) == 0) {

+    return BOOT_WITH_FULL_CONFIGURATION;

+  } else {

+    return BOOT_ON_S2_RESUME;

+  }

+}

+

+/**

+  Initialize controllers that must setup in the normal world

+

+  This function is called by the ArmPlatformPkg/PrePi or ArmPlatformPkg/PlatformPei

+  in the PEI phase.

+

+**/

+RETURN_STATUS

+ArmPlatformInitialize (

+  IN  UINTN                     MpId

+  )

+{

+  if (!IS_PRIMARY_CORE(MpId)) {

+    return RETURN_SUCCESS;

+  }

+

+  // Configure periodic timer (TIMER0) for 1MHz operation

+  MmioOr32 (SP810_CTRL_BASE + SP810_SYS_CTRL_REG, SP810_SYS_CTRL_TIMER0_TIMCLK);

+  // Configure 1MHz clock

+  MmioOr32 (SP810_CTRL_BASE + SP810_SYS_CTRL_REG, SP810_SYS_CTRL_TIMER1_TIMCLK);

+  // configure SP810 to use 1MHz clock and disable

+  MmioAndThenOr32 (SP810_CTRL_BASE + SP810_SYS_CTRL_REG, ~SP810_SYS_CTRL_TIMER2_EN, SP810_SYS_CTRL_TIMER2_TIMCLK);

+  // Configure SP810 to use 1MHz clock and disable

+  MmioAndThenOr32 (SP810_CTRL_BASE + SP810_SYS_CTRL_REG, ~SP810_SYS_CTRL_TIMER3_EN, SP810_SYS_CTRL_TIMER3_TIMCLK);

+

+  return RETURN_SUCCESS;

+}

+

+/**

+  Initialize the system (or sometimes called permanent) memory

+

+  This memory is generally represented by the DRAM.

+

+**/

+VOID

+ArmPlatformInitializeSystemMemory (

+  VOID

+  )

+{

+  UINT32 Value;

+

+  // Memory Map remapping

+  if (FeaturePcdGet(PcdNorFlashRemapping)) {

+    SerialPrint ("Secure ROM at 0x0\n\r");

+  } else {

+    Value = MmioRead32(ARM_VE_SYS_CFGRW1_REG); //Scc - CFGRW1

+    // Remap the DRAM to 0x0

+    MmioWrite32(ARM_VE_SYS_CFGRW1_REG, (Value & 0x0FFFFFFF) | ARM_VE_CFGRW1_REMAP_DRAM);

+  }

+

+  PL341DmcInit(ARM_VE_DMC_BASE, &DDRTimings);

+  PL301AxiInit(ARM_VE_FAXI_BASE);

+}

+

+EFI_STATUS

+PrePeiCoreGetMpCoreInfo (

+  OUT UINTN                   *CoreCount,

+  OUT ARM_CORE_INFO           **ArmCoreTable

+  )

+{

+  *CoreCount    = sizeof(mVersatileExpressMpCoreInfoCTA9x4) / sizeof(ARM_CORE_INFO);

+  *ArmCoreTable = mVersatileExpressMpCoreInfoCTA9x4;

+

+  return EFI_SUCCESS;

+}

+

+// Needs to be declared in the file. Otherwise gArmMpCoreInfoPpiGuid is undefined in the contect of PrePeiCore

+EFI_GUID mArmMpCoreInfoPpiGuid = ARM_MP_CORE_INFO_PPI_GUID;

+ARM_MP_CORE_INFO_PPI mMpCoreInfoPpi = { PrePeiCoreGetMpCoreInfo };

+

+EFI_PEI_PPI_DESCRIPTOR      gPlatformPpiTable[] = {

+  {

+    EFI_PEI_PPI_DESCRIPTOR_PPI,

+    &mArmMpCoreInfoPpiGuid,

+    &mMpCoreInfoPpi

+  }

+};

+

+VOID

+ArmPlatformGetPlatformPpiList (

+  OUT UINTN                   *PpiListSize,

+  OUT EFI_PEI_PPI_DESCRIPTOR  **PpiList

+  )

+{

+  *PpiListSize = sizeof(gPlatformPpiTable);

+  *PpiList = gPlatformPpiTable;

+}

diff --git a/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressLibRTSM/RTSM.c b/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressLibRTSM/RTSM.c
index 69ffd45f..f055608a 100644
--- a/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressLibRTSM/RTSM.c
+++ b/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressLibRTSM/RTSM.c
@@ -1,163 +1,163 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-#include <Library/IoLib.h>
-#include <Library/ArmPlatformLib.h>
-#include <Library/DebugLib.h>
-#include <Library/PcdLib.h>
-
-#include <Ppi/ArmMpCoreInfo.h>
-
-#include <ArmPlatform.h>
-
-UINTN
-ArmGetCpuCountPerCluster (
-  VOID
-  );
-
-ARM_CORE_INFO mVersatileExpressMpCoreInfoTable[] = {
-  {
-    // Cluster 0, Core 0
-    0x0, 0x0,
-
-    // MP Core MailBox Set/Get/Clear Addresses and Clear Value
-    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_REG,
-    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_SET_REG,
-    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_CLR_REG,
-    (UINT64)0xFFFFFFFF
-  },
-  {
-    // Cluster 0, Core 1
-    0x0, 0x1,
-
-    // MP Core MailBox Set/Get/Clear Addresses and Clear Value
-    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_REG,
-    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_SET_REG,
-    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_CLR_REG,
-    (UINT64)0xFFFFFFFF
-  },
-  {
-    // Cluster 0, Core 2
-    0x0, 0x2,
-
-    // MP Core MailBox Set/Get/Clear Addresses and Clear Value
-    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_REG,
-    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_SET_REG,
-    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_CLR_REG,
-    (UINT64)0xFFFFFFFF
-  },
-  {
-    // Cluster 0, Core 3
-    0x0, 0x3,
-
-    // MP Core MailBox Set/Get/Clear Addresses and Clear Value
-    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_REG,
-    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_SET_REG,
-    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_CLR_REG,
-    (UINT64)0xFFFFFFFF
-  }
-};
-
-/**
-  Return the current Boot Mode
-
-  This function returns the boot reason on the platform
-
-  @return   Return the current Boot Mode of the platform
-
-**/
-EFI_BOOT_MODE
-ArmPlatformGetBootMode (
-  VOID
-  )
-{
-  return BOOT_WITH_FULL_CONFIGURATION;
-}
-
-/**
-  Initialize controllers that must setup in the normal world
-
-  This function is called by the ArmPlatformPkg/Pei or ArmPlatformPkg/Pei/PlatformPeim
-  in the PEI phase.
-
-**/
-RETURN_STATUS
-ArmPlatformInitialize (
-  IN  UINTN                     MpId
-  )
-{
-  if (!IS_PRIMARY_CORE(MpId)) {
-    return RETURN_SUCCESS;
-  }
-
-  // Disable memory remapping and return to normal mapping
-  MmioOr32 (SP810_CTRL_BASE, BIT8);
-
-  return RETURN_SUCCESS;
-}
-
-/**
-  Initialize the system (or sometimes called permanent) memory
-
-  This memory is generally represented by the DRAM.
-
-**/
-VOID
-ArmPlatformInitializeSystemMemory (
-  VOID
-  )
-{
-  // Nothing to do here
-}
-
-EFI_STATUS
-PrePeiCoreGetMpCoreInfo (
-  OUT UINTN                   *CoreCount,
-  OUT ARM_CORE_INFO           **ArmCoreTable
-  )
-{
-  UINT32   ProcType;
-
-  ProcType = MmioRead32 (ARM_VE_SYS_PROCID0_REG) & ARM_VE_SYS_PROC_ID_MASK;
-  if ((ProcType == ARM_VE_SYS_PROC_ID_CORTEX_A9) || (ProcType == ARM_VE_SYS_PROC_ID_CORTEX_A15)) {
-    // Only support one cluster
-    *CoreCount    = ArmGetCpuCountPerCluster ();
-    *ArmCoreTable = mVersatileExpressMpCoreInfoTable;
-    return EFI_SUCCESS;
-  } else {
-    return EFI_UNSUPPORTED;
-  }
-}
-
-// Needs to be declared in the file. Otherwise gArmMpCoreInfoPpiGuid is undefined in the contect of PrePeiCore
-EFI_GUID mArmMpCoreInfoPpiGuid = ARM_MP_CORE_INFO_PPI_GUID;
-ARM_MP_CORE_INFO_PPI mMpCoreInfoPpi = { PrePeiCoreGetMpCoreInfo };
-
-EFI_PEI_PPI_DESCRIPTOR      gPlatformPpiTable[] = {
-  {
-    EFI_PEI_PPI_DESCRIPTOR_PPI,
-    &mArmMpCoreInfoPpiGuid,
-    &mMpCoreInfoPpi
-  }
-};
-
-VOID
-ArmPlatformGetPlatformPpiList (
-  OUT UINTN                   *PpiListSize,
-  OUT EFI_PEI_PPI_DESCRIPTOR  **PpiList
-  )
-{
-  *PpiListSize = sizeof(gPlatformPpiTable);
-  *PpiList = gPlatformPpiTable;
-}
+/** @file

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+#include <Library/IoLib.h>

+#include <Library/ArmPlatformLib.h>

+#include <Library/DebugLib.h>

+#include <Library/PcdLib.h>

+

+#include <Ppi/ArmMpCoreInfo.h>

+

+#include <ArmPlatform.h>

+

+UINTN

+ArmGetCpuCountPerCluster (

+  VOID

+  );

+

+ARM_CORE_INFO mVersatileExpressMpCoreInfoTable[] = {

+  {

+    // Cluster 0, Core 0

+    0x0, 0x0,

+

+    // MP Core MailBox Set/Get/Clear Addresses and Clear Value

+    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_REG,

+    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_SET_REG,

+    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_CLR_REG,

+    (UINT64)0xFFFFFFFF

+  },

+  {

+    // Cluster 0, Core 1

+    0x0, 0x1,

+

+    // MP Core MailBox Set/Get/Clear Addresses and Clear Value

+    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_REG,

+    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_SET_REG,

+    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_CLR_REG,

+    (UINT64)0xFFFFFFFF

+  },

+  {

+    // Cluster 0, Core 2

+    0x0, 0x2,

+

+    // MP Core MailBox Set/Get/Clear Addresses and Clear Value

+    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_REG,

+    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_SET_REG,

+    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_CLR_REG,

+    (UINT64)0xFFFFFFFF

+  },

+  {

+    // Cluster 0, Core 3

+    0x0, 0x3,

+

+    // MP Core MailBox Set/Get/Clear Addresses and Clear Value

+    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_REG,

+    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_SET_REG,

+    (EFI_PHYSICAL_ADDRESS)ARM_VE_SYS_FLAGS_CLR_REG,

+    (UINT64)0xFFFFFFFF

+  }

+};

+

+/**

+  Return the current Boot Mode

+

+  This function returns the boot reason on the platform

+

+  @return   Return the current Boot Mode of the platform

+

+**/

+EFI_BOOT_MODE

+ArmPlatformGetBootMode (

+  VOID

+  )

+{

+  return BOOT_WITH_FULL_CONFIGURATION;

+}

+

+/**

+  Initialize controllers that must setup in the normal world

+

+  This function is called by the ArmPlatformPkg/Pei or ArmPlatformPkg/Pei/PlatformPeim

+  in the PEI phase.

+

+**/

+RETURN_STATUS

+ArmPlatformInitialize (

+  IN  UINTN                     MpId

+  )

+{

+  if (!IS_PRIMARY_CORE(MpId)) {

+    return RETURN_SUCCESS;

+  }

+

+  // Disable memory remapping and return to normal mapping

+  MmioOr32 (SP810_CTRL_BASE, BIT8);

+

+  return RETURN_SUCCESS;

+}

+

+/**

+  Initialize the system (or sometimes called permanent) memory

+

+  This memory is generally represented by the DRAM.

+

+**/

+VOID

+ArmPlatformInitializeSystemMemory (

+  VOID

+  )

+{

+  // Nothing to do here

+}

+

+EFI_STATUS

+PrePeiCoreGetMpCoreInfo (

+  OUT UINTN                   *CoreCount,

+  OUT ARM_CORE_INFO           **ArmCoreTable

+  )

+{

+  UINT32   ProcType;

+

+  ProcType = MmioRead32 (ARM_VE_SYS_PROCID0_REG) & ARM_VE_SYS_PROC_ID_MASK;

+  if ((ProcType == ARM_VE_SYS_PROC_ID_CORTEX_A9) || (ProcType == ARM_VE_SYS_PROC_ID_CORTEX_A15)) {

+    // Only support one cluster

+    *CoreCount    = ArmGetCpuCountPerCluster ();

+    *ArmCoreTable = mVersatileExpressMpCoreInfoTable;

+    return EFI_SUCCESS;

+  } else {

+    return EFI_UNSUPPORTED;

+  }

+}

+

+// Needs to be declared in the file. Otherwise gArmMpCoreInfoPpiGuid is undefined in the contect of PrePeiCore

+EFI_GUID mArmMpCoreInfoPpiGuid = ARM_MP_CORE_INFO_PPI_GUID;

+ARM_MP_CORE_INFO_PPI mMpCoreInfoPpi = { PrePeiCoreGetMpCoreInfo };

+

+EFI_PEI_PPI_DESCRIPTOR      gPlatformPpiTable[] = {

+  {

+    EFI_PEI_PPI_DESCRIPTOR_PPI,

+    &mArmMpCoreInfoPpiGuid,

+    &mMpCoreInfoPpi

+  }

+};

+

+VOID

+ArmPlatformGetPlatformPpiList (

+  OUT UINTN                   *PpiListSize,

+  OUT EFI_PEI_PPI_DESCRIPTOR  **PpiList

+  )

+{

+  *PpiListSize = sizeof(gPlatformPpiTable);

+  *PpiList = gPlatformPpiTable;

+}

diff --git a/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressLibRTSM/RTSMMem.c b/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressLibRTSM/RTSMMem.c
index f3e8cafc..cb6376f6 100644
--- a/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressLibRTSM/RTSMMem.c
+++ b/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressLibRTSM/RTSMMem.c
@@ -103,7 +103,7 @@ ArmPlatformGetVirtualMemoryMap (
   VirtualMemoryTable[++Index].PhysicalBase = ARM_VE_SMB_PERIPH_BASE;

   VirtualMemoryTable[Index].VirtualBase  = ARM_VE_SMB_PERIPH_BASE;

   VirtualMemoryTable[Index].Length       = 2 * ARM_VE_SMB_PERIPH_SZ;

-  VirtualMemoryTable[Index].Attributes   = ARM_MEMORY_REGION_ATTRIBUTE_DEVICE;
+  VirtualMemoryTable[Index].Attributes   = ARM_MEMORY_REGION_ATTRIBUTE_DEVICE;

 

 //TODO:This should be enabled for final release. Right now, ARM VE RTSM crashes.

 //  // If a Logic Tile is connected to The ARM Versatile Express Motherboard

diff --git a/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressSecLibCTA9x4/CTA9x4Sec.c b/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressSecLibCTA9x4/CTA9x4Sec.c
index ce9bc8b2..228a0fb0 100644
--- a/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressSecLibCTA9x4/CTA9x4Sec.c
+++ b/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressSecLibCTA9x4/CTA9x4Sec.c
@@ -1,148 +1,148 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-#include <Library/ArmPlatformLib.h>
-#include <Library/ArmPlatformSysConfigLib.h>
-#include <Library/DebugLib.h>
-#include <Library/IoLib.h>
-#include <Library/PcdLib.h>
-
-#include <Drivers/ArmTrustzone.h>
-#include <Drivers/PL310L2Cache.h>
-
-#include <ArmPlatform.h>
-
-/**
-  Initialize the Secure peripherals and memory regions
-
-  If Trustzone is supported by your platform then this function makes the required initialization
-  of the secure peripherals and memory regions.
-
-**/
-VOID
-ArmPlatformSecTrustzoneInit (
-  IN  UINTN                     MpId
-  )
-{
-  // Nothing to do
-  if (!IS_PRIMARY_CORE(MpId)) {
-    return;
-  }
-
-  //
-  // Setup TZ Protection Controller
-  //
-
-  if (MmioRead32(ARM_VE_SYS_CFGRW1_REG) & ARM_VE_CFGRW1_TZASC_EN_BIT_MASK) {
-    ASSERT (PcdGetBool (PcdTrustzoneSupport) == TRUE);
-  } else {
-    ASSERT (PcdGetBool (PcdTrustzoneSupport) == FALSE);
-  }
-
-  // Set Non Secure access for all devices
-  TZPCSetDecProtBits(ARM_VE_TZPC_BASE, TZPC_DECPROT_0, 0xFFFFFFFF);
-  TZPCSetDecProtBits(ARM_VE_TZPC_BASE, TZPC_DECPROT_1, 0xFFFFFFFF);
-  TZPCSetDecProtBits(ARM_VE_TZPC_BASE, TZPC_DECPROT_2, 0xFFFFFFFF);
-
-  // Remove Non secure access to secure devices
-  TZPCClearDecProtBits(ARM_VE_TZPC_BASE, TZPC_DECPROT_0,
-       ARM_VE_DECPROT_BIT_TZPC | ARM_VE_DECPROT_BIT_DMC_TZASC | ARM_VE_DECPROT_BIT_NMC_TZASC | ARM_VE_DECPROT_BIT_SMC_TZASC);
-
-  TZPCClearDecProtBits(ARM_VE_TZPC_BASE, TZPC_DECPROT_2,
-       ARM_VE_DECPROT_BIT_EXT_MAST_TZ | ARM_VE_DECPROT_BIT_DMC_TZASC_LOCK | ARM_VE_DECPROT_BIT_NMC_TZASC_LOCK | ARM_VE_DECPROT_BIT_SMC_TZASC_LOCK);
-
-  //
-  // Setup TZ Address Space Controller for the SMC. Create 5 Non Secure regions (NOR0, NOR1, SRAM, SMC Peripheral regions)
-  //
-
-  // NOR Flash 0 non secure (BootMon)
-  TZASCSetRegion(ARM_VE_TZASC_BASE,1,TZASC_REGION_ENABLED,
-      ARM_VE_SMB_NOR0_BASE,0,
-      TZASC_REGION_SIZE_64MB, TZASC_REGION_SECURITY_NSRW);
-
-  // NOR Flash 1. The first half of the NOR Flash1 must be secure for the secure firmware (sec_uefi.bin)
-  if (PcdGetBool (PcdTrustzoneSupport) == TRUE) {
-    //Note: Your OS Kernel must be aware of the secure regions before to enable this region
-    TZASCSetRegion(ARM_VE_TZASC_BASE,2,TZASC_REGION_ENABLED,
-        ARM_VE_SMB_NOR1_BASE + SIZE_32MB,0,
-        TZASC_REGION_SIZE_32MB, TZASC_REGION_SECURITY_NSRW);
-  } else {
-    TZASCSetRegion(ARM_VE_TZASC_BASE,2,TZASC_REGION_ENABLED,
-        ARM_VE_SMB_NOR1_BASE,0,
-        TZASC_REGION_SIZE_64MB, TZASC_REGION_SECURITY_NSRW);
-  }
-
-  // Base of SRAM. Only half of SRAM in Non Secure world
-  // First half non secure (16MB) + Second Half secure (16MB) = 32MB of SRAM
-  if (PcdGetBool (PcdTrustzoneSupport) == TRUE) {
-    //Note: Your OS Kernel must be aware of the secure regions before to enable this region
-    TZASCSetRegion(ARM_VE_TZASC_BASE,3,TZASC_REGION_ENABLED,
-        ARM_VE_SMB_SRAM_BASE,0,
-        TZASC_REGION_SIZE_16MB, TZASC_REGION_SECURITY_NSRW);
-  } else {
-    TZASCSetRegion(ARM_VE_TZASC_BASE,3,TZASC_REGION_ENABLED,
-        ARM_VE_SMB_SRAM_BASE,0,
-        TZASC_REGION_SIZE_32MB, TZASC_REGION_SECURITY_NSRW);
-  }
-
-  // Memory Mapped Peripherals. All in non secure world
-  TZASCSetRegion(ARM_VE_TZASC_BASE,4,TZASC_REGION_ENABLED,
-      ARM_VE_SMB_PERIPH_BASE,0,
-      TZASC_REGION_SIZE_64MB, TZASC_REGION_SECURITY_NSRW);
-
-  // MotherBoard Peripherals and On-chip peripherals.
-  TZASCSetRegion(ARM_VE_TZASC_BASE,5,TZASC_REGION_ENABLED,
-      ARM_VE_SMB_MB_ON_CHIP_PERIPH_BASE,0,
-      TZASC_REGION_SIZE_256MB, TZASC_REGION_SECURITY_NSRW);
-}
-
-/**
-  Initialize controllers that must setup at the early stage
-
-  Some peripherals must be initialized in Secure World.
-  For example, some L2x0 requires to be initialized in Secure World
-
-**/
-RETURN_STATUS
-ArmPlatformSecInitialize (
-  IN  UINTN                     MpId
-  )
-{
-  // If it is not the primary core then there is nothing to do
-  if (!IS_PRIMARY_CORE(MpId)) {
-    return RETURN_SUCCESS;
-  }
-
-  // The L2x0 controller must be intialize in Secure World
-  L2x0CacheInit(PcdGet32(PcdL2x0ControllerBase),
-      PL310_TAG_LATENCIES(L2x0_LATENCY_8_CYCLES,L2x0_LATENCY_8_CYCLES,L2x0_LATENCY_8_CYCLES),
-      PL310_DATA_LATENCIES(L2x0_LATENCY_8_CYCLES,L2x0_LATENCY_8_CYCLES,L2x0_LATENCY_8_CYCLES),
-      0,~0, // Use default setting for the Auxiliary Control Register
-      FALSE);
-
-  // Initialize the System Configuration
-  ArmPlatformSysConfigInitialize ();
-
-  // If we skip the PEI Core we could want to initialize the DRAM in the SEC phase.
-  // If we are in standalone, we need the initialization to copy the UEFI firmware into DRAM
-  if ((FeaturePcdGet (PcdSystemMemoryInitializeInSec)) || (FeaturePcdGet (PcdStandalone) == FALSE)) {
-    // If it is not a standalone build ensure the PcdSystemMemoryInitializeInSec has been set
-    ASSERT(FeaturePcdGet (PcdSystemMemoryInitializeInSec) == TRUE);
-
-    // Initialize system memory (DRAM)
-    ArmPlatformInitializeSystemMemory ();
-  }
-
-  return RETURN_SUCCESS;
-}
+/** @file

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+#include <Library/ArmPlatformLib.h>

+#include <Library/ArmPlatformSysConfigLib.h>

+#include <Library/DebugLib.h>

+#include <Library/IoLib.h>

+#include <Library/PcdLib.h>

+

+#include <Drivers/ArmTrustzone.h>

+#include <Drivers/PL310L2Cache.h>

+

+#include <ArmPlatform.h>

+

+/**

+  Initialize the Secure peripherals and memory regions

+

+  If Trustzone is supported by your platform then this function makes the required initialization

+  of the secure peripherals and memory regions.

+

+**/

+VOID

+ArmPlatformSecTrustzoneInit (

+  IN  UINTN                     MpId

+  )

+{

+  // Nothing to do

+  if (!IS_PRIMARY_CORE(MpId)) {

+    return;

+  }

+

+  //

+  // Setup TZ Protection Controller

+  //

+

+  if (MmioRead32(ARM_VE_SYS_CFGRW1_REG) & ARM_VE_CFGRW1_TZASC_EN_BIT_MASK) {

+    ASSERT (PcdGetBool (PcdTrustzoneSupport) == TRUE);

+  } else {

+    ASSERT (PcdGetBool (PcdTrustzoneSupport) == FALSE);

+  }

+

+  // Set Non Secure access for all devices

+  TZPCSetDecProtBits(ARM_VE_TZPC_BASE, TZPC_DECPROT_0, 0xFFFFFFFF);

+  TZPCSetDecProtBits(ARM_VE_TZPC_BASE, TZPC_DECPROT_1, 0xFFFFFFFF);

+  TZPCSetDecProtBits(ARM_VE_TZPC_BASE, TZPC_DECPROT_2, 0xFFFFFFFF);

+

+  // Remove Non secure access to secure devices

+  TZPCClearDecProtBits(ARM_VE_TZPC_BASE, TZPC_DECPROT_0,

+       ARM_VE_DECPROT_BIT_TZPC | ARM_VE_DECPROT_BIT_DMC_TZASC | ARM_VE_DECPROT_BIT_NMC_TZASC | ARM_VE_DECPROT_BIT_SMC_TZASC);

+

+  TZPCClearDecProtBits(ARM_VE_TZPC_BASE, TZPC_DECPROT_2,

+       ARM_VE_DECPROT_BIT_EXT_MAST_TZ | ARM_VE_DECPROT_BIT_DMC_TZASC_LOCK | ARM_VE_DECPROT_BIT_NMC_TZASC_LOCK | ARM_VE_DECPROT_BIT_SMC_TZASC_LOCK);

+

+  //

+  // Setup TZ Address Space Controller for the SMC. Create 5 Non Secure regions (NOR0, NOR1, SRAM, SMC Peripheral regions)

+  //

+

+  // NOR Flash 0 non secure (BootMon)

+  TZASCSetRegion(ARM_VE_TZASC_BASE,1,TZASC_REGION_ENABLED,

+      ARM_VE_SMB_NOR0_BASE,0,

+      TZASC_REGION_SIZE_64MB, TZASC_REGION_SECURITY_NSRW);

+

+  // NOR Flash 1. The first half of the NOR Flash1 must be secure for the secure firmware (sec_uefi.bin)

+  if (PcdGetBool (PcdTrustzoneSupport) == TRUE) {

+    //Note: Your OS Kernel must be aware of the secure regions before to enable this region

+    TZASCSetRegion(ARM_VE_TZASC_BASE,2,TZASC_REGION_ENABLED,

+        ARM_VE_SMB_NOR1_BASE + SIZE_32MB,0,

+        TZASC_REGION_SIZE_32MB, TZASC_REGION_SECURITY_NSRW);

+  } else {

+    TZASCSetRegion(ARM_VE_TZASC_BASE,2,TZASC_REGION_ENABLED,

+        ARM_VE_SMB_NOR1_BASE,0,

+        TZASC_REGION_SIZE_64MB, TZASC_REGION_SECURITY_NSRW);

+  }

+

+  // Base of SRAM. Only half of SRAM in Non Secure world

+  // First half non secure (16MB) + Second Half secure (16MB) = 32MB of SRAM

+  if (PcdGetBool (PcdTrustzoneSupport) == TRUE) {

+    //Note: Your OS Kernel must be aware of the secure regions before to enable this region

+    TZASCSetRegion(ARM_VE_TZASC_BASE,3,TZASC_REGION_ENABLED,

+        ARM_VE_SMB_SRAM_BASE,0,

+        TZASC_REGION_SIZE_16MB, TZASC_REGION_SECURITY_NSRW);

+  } else {

+    TZASCSetRegion(ARM_VE_TZASC_BASE,3,TZASC_REGION_ENABLED,

+        ARM_VE_SMB_SRAM_BASE,0,

+        TZASC_REGION_SIZE_32MB, TZASC_REGION_SECURITY_NSRW);

+  }

+

+  // Memory Mapped Peripherals. All in non secure world

+  TZASCSetRegion(ARM_VE_TZASC_BASE,4,TZASC_REGION_ENABLED,

+      ARM_VE_SMB_PERIPH_BASE,0,

+      TZASC_REGION_SIZE_64MB, TZASC_REGION_SECURITY_NSRW);

+

+  // MotherBoard Peripherals and On-chip peripherals.

+  TZASCSetRegion(ARM_VE_TZASC_BASE,5,TZASC_REGION_ENABLED,

+      ARM_VE_SMB_MB_ON_CHIP_PERIPH_BASE,0,

+      TZASC_REGION_SIZE_256MB, TZASC_REGION_SECURITY_NSRW);

+}

+

+/**

+  Initialize controllers that must setup at the early stage

+

+  Some peripherals must be initialized in Secure World.

+  For example, some L2x0 requires to be initialized in Secure World

+

+**/

+RETURN_STATUS

+ArmPlatformSecInitialize (

+  IN  UINTN                     MpId

+  )

+{

+  // If it is not the primary core then there is nothing to do

+  if (!IS_PRIMARY_CORE(MpId)) {

+    return RETURN_SUCCESS;

+  }

+

+  // The L2x0 controller must be intialize in Secure World

+  L2x0CacheInit(PcdGet32(PcdL2x0ControllerBase),

+      PL310_TAG_LATENCIES(L2x0_LATENCY_8_CYCLES,L2x0_LATENCY_8_CYCLES,L2x0_LATENCY_8_CYCLES),

+      PL310_DATA_LATENCIES(L2x0_LATENCY_8_CYCLES,L2x0_LATENCY_8_CYCLES,L2x0_LATENCY_8_CYCLES),

+      0,~0, // Use default setting for the Auxiliary Control Register

+      FALSE);

+

+  // Initialize the System Configuration

+  ArmPlatformSysConfigInitialize ();

+

+  // If we skip the PEI Core we could want to initialize the DRAM in the SEC phase.

+  // If we are in standalone, we need the initialization to copy the UEFI firmware into DRAM

+  if ((FeaturePcdGet (PcdSystemMemoryInitializeInSec)) || (FeaturePcdGet (PcdStandalone) == FALSE)) {

+    // If it is not a standalone build ensure the PcdSystemMemoryInitializeInSec has been set

+    ASSERT(FeaturePcdGet (PcdSystemMemoryInitializeInSec) == TRUE);

+

+    // Initialize system memory (DRAM)

+    ArmPlatformInitializeSystemMemory ();

+  }

+

+  return RETURN_SUCCESS;

+}

diff --git a/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressSecLibRTSM/ArmVExpressSecLib.inf b/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressSecLibRTSM/ArmVExpressSecLib.inf
index 4a1e056a..ff847671 100644
--- a/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressSecLibRTSM/ArmVExpressSecLib.inf
+++ b/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressSecLibRTSM/ArmVExpressSecLib.inf
@@ -1,52 +1,52 @@
-#/* @file
-#  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-#  
-#  This program and the accompanying materials                          
-#  are licensed and made available under the terms and conditions of the BSD License         
-#  which accompanies this distribution.  The full text of the license may be found at        
-#  http://opensource.org/licenses/bsd-license.php                                            
-#
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-#
-#*/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = RTSMArmVExpressSecLib
-  FILE_GUID                      = 1fdaabb0-ab7d-480c-91ff-428dc1546f3a
-  MODULE_TYPE                    = BASE
-  VERSION_STRING                 = 1.0
-  LIBRARY_CLASS                  = ArmPlatformSecLib
-
-[Packages]
-  MdePkg/MdePkg.dec
-  MdeModulePkg/MdeModulePkg.dec
-  EmbeddedPkg/EmbeddedPkg.dec
-  ArmPkg/ArmPkg.dec
-  ArmPlatformPkg/ArmPlatformPkg.dec
-
-[LibraryClasses]
-  IoLib
-  ArmLib
-  SerialPortLib
-
-[Sources.common]
-  RTSMSec.c
-
-[Sources.ARM]
-  Arm/RTSMBoot.asm     | RVCT
-  Arm/RTSMBoot.S       | GCC
-  Arm/RTSMHelper.asm   | RVCT
-  Arm/RTSMHelper.S     | GCC
-
-[FeaturePcd]
-  gEmbeddedTokenSpaceGuid.PcdCacheEnable
-  gArmPlatformTokenSpaceGuid.PcdNorFlashRemapping
-  gArmPlatformTokenSpaceGuid.PcdStandalone
-
-[FixedPcd]
-  gArmTokenSpaceGuid.PcdFvBaseAddress
-
-  gArmTokenSpaceGuid.PcdArmPrimaryCoreMask
-  gArmTokenSpaceGuid.PcdArmPrimaryCore
+#/* @file

+#  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+#  

+#  This program and the accompanying materials                          

+#  are licensed and made available under the terms and conditions of the BSD License         

+#  which accompanies this distribution.  The full text of the license may be found at        

+#  http://opensource.org/licenses/bsd-license.php                                            

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+#

+#*/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = RTSMArmVExpressSecLib

+  FILE_GUID                      = 1fdaabb0-ab7d-480c-91ff-428dc1546f3a

+  MODULE_TYPE                    = BASE

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = ArmPlatformSecLib

+

+[Packages]

+  MdePkg/MdePkg.dec

+  MdeModulePkg/MdeModulePkg.dec

+  EmbeddedPkg/EmbeddedPkg.dec

+  ArmPkg/ArmPkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+

+[LibraryClasses]

+  IoLib

+  ArmLib

+  SerialPortLib

+

+[Sources.common]

+  RTSMSec.c

+

+[Sources.ARM]

+  Arm/RTSMBoot.asm     | RVCT

+  Arm/RTSMBoot.S       | GCC

+  Arm/RTSMHelper.asm   | RVCT

+  Arm/RTSMHelper.S     | GCC

+

+[FeaturePcd]

+  gEmbeddedTokenSpaceGuid.PcdCacheEnable

+  gArmPlatformTokenSpaceGuid.PcdNorFlashRemapping

+  gArmPlatformTokenSpaceGuid.PcdStandalone

+

+[FixedPcd]

+  gArmTokenSpaceGuid.PcdFvBaseAddress

+

+  gArmTokenSpaceGuid.PcdArmPrimaryCoreMask

+  gArmTokenSpaceGuid.PcdArmPrimaryCore

diff --git a/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressSecLibRTSM/RTSMSec.c b/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressSecLibRTSM/RTSMSec.c
index 4ae63016..92df56cd 100644
--- a/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressSecLibRTSM/RTSMSec.c
+++ b/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressSecLibRTSM/RTSMSec.c
@@ -1,83 +1,83 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-#include <Library/IoLib.h>
-#include <Library/ArmPlatformLib.h>
-#include <Library/DebugLib.h>
-#include <Library/PcdLib.h>
-
-#include <Drivers/PL310L2Cache.h>
-#include <Drivers/SP804Timer.h>
-
-#include <ArmPlatform.h>
-
-/**
-  Initialize the Secure peripherals and memory regions
-
-  If Trustzone is supported by your platform then this function makes the required initialization
-  of the secure peripherals and memory regions.
-
-**/
-VOID
-ArmPlatformSecTrustzoneInit (
-  IN  UINTN                     MpId
-  )
-{
-  // No TZPC or TZASC on RTSM to initialize
-}
-
-/**
-  Initialize controllers that must setup at the early stage
-
-  Some peripherals must be initialized in Secure World.
-  For example, some L2x0 requires to be initialized in Secure World
-
-**/
-RETURN_STATUS
-ArmPlatformSecInitialize (
-  IN  UINTN                     MpId
-  )
-{
-  // If it is not the primary core then there is nothing to do
-  if (!IS_PRIMARY_CORE(MpId)) {
-    return RETURN_SUCCESS;
-  }
-
-  // Configure periodic timer (TIMER0) for 1MHz operation
-  MmioOr32 (SP810_CTRL_BASE + SP810_SYS_CTRL_REG, SP810_SYS_CTRL_TIMER0_TIMCLK);
-  // Configure 1MHz clock
-  MmioOr32 (SP810_CTRL_BASE + SP810_SYS_CTRL_REG, SP810_SYS_CTRL_TIMER1_TIMCLK);
-  // Configure SP810 to use 1MHz clock and disable
-  MmioAndThenOr32 (SP810_CTRL_BASE + SP810_SYS_CTRL_REG, ~SP810_SYS_CTRL_TIMER2_EN, SP810_SYS_CTRL_TIMER2_TIMCLK);
-  // Configure SP810 to use 1MHz clock and disable
-  MmioAndThenOr32 (SP810_CTRL_BASE + SP810_SYS_CTRL_REG, ~SP810_SYS_CTRL_TIMER3_EN, SP810_SYS_CTRL_TIMER3_TIMCLK);
-
-  return RETURN_SUCCESS;
-}
-
-/**
-  Call before jumping to Normal World
-
-  This function allows the firmware platform to do extra actions before
-  jumping to the Normal World
-
-**/
-VOID
-ArmPlatformSecExtraAction (
-  IN  UINTN         MpId,
-  OUT UINTN*        JumpAddress
-  )
-{
-  *JumpAddress = PcdGet32(PcdFvBaseAddress);
-}
+/** @file

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+#include <Library/IoLib.h>

+#include <Library/ArmPlatformLib.h>

+#include <Library/DebugLib.h>

+#include <Library/PcdLib.h>

+

+#include <Drivers/PL310L2Cache.h>

+#include <Drivers/SP804Timer.h>

+

+#include <ArmPlatform.h>

+

+/**

+  Initialize the Secure peripherals and memory regions

+

+  If Trustzone is supported by your platform then this function makes the required initialization

+  of the secure peripherals and memory regions.

+

+**/

+VOID

+ArmPlatformSecTrustzoneInit (

+  IN  UINTN                     MpId

+  )

+{

+  // No TZPC or TZASC on RTSM to initialize

+}

+

+/**

+  Initialize controllers that must setup at the early stage

+

+  Some peripherals must be initialized in Secure World.

+  For example, some L2x0 requires to be initialized in Secure World

+

+**/

+RETURN_STATUS

+ArmPlatformSecInitialize (

+  IN  UINTN                     MpId

+  )

+{

+  // If it is not the primary core then there is nothing to do

+  if (!IS_PRIMARY_CORE(MpId)) {

+    return RETURN_SUCCESS;

+  }

+

+  // Configure periodic timer (TIMER0) for 1MHz operation

+  MmioOr32 (SP810_CTRL_BASE + SP810_SYS_CTRL_REG, SP810_SYS_CTRL_TIMER0_TIMCLK);

+  // Configure 1MHz clock

+  MmioOr32 (SP810_CTRL_BASE + SP810_SYS_CTRL_REG, SP810_SYS_CTRL_TIMER1_TIMCLK);

+  // Configure SP810 to use 1MHz clock and disable

+  MmioAndThenOr32 (SP810_CTRL_BASE + SP810_SYS_CTRL_REG, ~SP810_SYS_CTRL_TIMER2_EN, SP810_SYS_CTRL_TIMER2_TIMCLK);

+  // Configure SP810 to use 1MHz clock and disable

+  MmioAndThenOr32 (SP810_CTRL_BASE + SP810_SYS_CTRL_REG, ~SP810_SYS_CTRL_TIMER3_EN, SP810_SYS_CTRL_TIMER3_TIMCLK);

+

+  return RETURN_SUCCESS;

+}

+

+/**

+  Call before jumping to Normal World

+

+  This function allows the firmware platform to do extra actions before

+  jumping to the Normal World

+

+**/

+VOID

+ArmPlatformSecExtraAction (

+  IN  UINTN         MpId,

+  OUT UINTN*        JumpAddress

+  )

+{

+  *JumpAddress = PcdGet32(PcdFvBaseAddress);

+}

diff --git a/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressSysConfigLib/ArmVExpressSysConfigLib.inf b/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressSysConfigLib/ArmVExpressSysConfigLib.inf
index 3dfa756d..8d4f52c5 100644
--- a/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressSysConfigLib/ArmVExpressSysConfigLib.inf
+++ b/ArmPlatformPkg/ArmVExpressPkg/Library/ArmVExpressSysConfigLib/ArmVExpressSysConfigLib.inf
@@ -1,35 +1,35 @@
-#/** @file
-#  
-#  Component description file for ArmVExpressSysConfigLib module
-#  
-#  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>
-#
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = ArmVExpressSysConfigLib
-  FILE_GUID                      = a05b5cc0-82d2-11e0-82cb-0002a5d5c51b
-  MODULE_TYPE                    = BASE
-  VERSION_STRING                 = 1.0
-  LIBRARY_CLASS                  = ArmPlatformSysConfigLib
-  
-[Sources.common]
-  ArmVExpressSysConfig.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  ArmPlatformPkg/ArmVExpressPkg/ArmVExpressPkg.dec
-  ArmPlatformPkg/ArmPlatformPkg.dec
-
-[LibraryClasses]
-  BaseLib
-  IoLib
+#/** @file

+#  

+#  Component description file for ArmVExpressSysConfigLib module

+#  

+#  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>

+#

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = ArmVExpressSysConfigLib

+  FILE_GUID                      = a05b5cc0-82d2-11e0-82cb-0002a5d5c51b

+  MODULE_TYPE                    = BASE

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = ArmPlatformSysConfigLib

+  

+[Sources.common]

+  ArmVExpressSysConfig.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  ArmPlatformPkg/ArmVExpressPkg/ArmVExpressPkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+

+[LibraryClasses]

+  BaseLib

+  IoLib

diff --git a/ArmPlatformPkg/ArmVExpressPkg/Library/HdLcdArmVExpressLib/HdLcdArmVExpressLib.inf b/ArmPlatformPkg/ArmVExpressPkg/Library/HdLcdArmVExpressLib/HdLcdArmVExpressLib.inf
index 73a17fb8..6a1814e0 100644
--- a/ArmPlatformPkg/ArmVExpressPkg/Library/HdLcdArmVExpressLib/HdLcdArmVExpressLib.inf
+++ b/ArmPlatformPkg/ArmVExpressPkg/Library/HdLcdArmVExpressLib/HdLcdArmVExpressLib.inf
@@ -41,4 +41,4 @@ HdLcdArmVExpress.c
 

 [Pcd]

   gArmVExpressTokenSpaceGuid.PcdPL111LcdMaxMode

-  gArmVExpressTokenSpaceGuid.PcdHdLcdVideoModeOscId
\ No newline at end of file
+  gArmVExpressTokenSpaceGuid.PcdHdLcdVideoModeOscId
\ No newline at end of file
diff --git a/ArmPlatformPkg/ArmVExpressPkg/Library/NorFlashArmVExpressLib/NorFlashArmVExpressLib.inf b/ArmPlatformPkg/ArmVExpressPkg/Library/NorFlashArmVExpressLib/NorFlashArmVExpressLib.inf
index 45af9212..af227d5e 100644
--- a/ArmPlatformPkg/ArmVExpressPkg/Library/NorFlashArmVExpressLib/NorFlashArmVExpressLib.inf
+++ b/ArmPlatformPkg/ArmVExpressPkg/Library/NorFlashArmVExpressLib/NorFlashArmVExpressLib.inf
@@ -1,32 +1,32 @@
-#/** @file
-#  
-#  Copyright (c) 2011, ARM Ltd. All rights reserved.<BR>
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = NorFlashArmVExpressLib
-  FILE_GUID                      = c0f5dfa0-7599-11e0-9665-0002a5d5c51b
-  MODULE_TYPE                    = DXE_DRIVER
-  VERSION_STRING                 = 1.0
-  LIBRARY_CLASS                  = NorFlashPlatformLib
-  
-[Sources.common]
-  NorFlashArmVExpress.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  ArmPlatformPkg/ArmPlatformPkg.dec
-
-[LibraryClasses]
-  BaseLib
-  DebugLib
-  IoLib
+#/** @file

+#  

+#  Copyright (c) 2011, ARM Ltd. All rights reserved.<BR>

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = NorFlashArmVExpressLib

+  FILE_GUID                      = c0f5dfa0-7599-11e0-9665-0002a5d5c51b

+  MODULE_TYPE                    = DXE_DRIVER

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = NorFlashPlatformLib

+  

+[Sources.common]

+  NorFlashArmVExpress.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+

+[LibraryClasses]

+  BaseLib

+  DebugLib

+  IoLib

diff --git a/ArmPlatformPkg/ArmVExpressPkg/Library/PL111LcdArmVExpressLib/PL111LcdArmVExpressLib.inf b/ArmPlatformPkg/ArmVExpressPkg/Library/PL111LcdArmVExpressLib/PL111LcdArmVExpressLib.inf
index c9b6a98c..2440ea99 100644
--- a/ArmPlatformPkg/ArmVExpressPkg/Library/PL111LcdArmVExpressLib/PL111LcdArmVExpressLib.inf
+++ b/ArmPlatformPkg/ArmVExpressPkg/Library/PL111LcdArmVExpressLib/PL111LcdArmVExpressLib.inf
@@ -1,43 +1,43 @@
-#/** @file
-#  
-#  Component description file for ArmVeGraphicsDxe module
-#  
-#  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>
-#
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = PL111LcdArmVExpressLib
-  FILE_GUID                      = b7f06f20-496f-11e0-a8e8-0002a5d5c51b
-  MODULE_TYPE                    = DXE_DRIVER
-  VERSION_STRING                 = 1.0
-  LIBRARY_CLASS                  = LcdPlatformLib
-  
-[Sources.common]
-  PL111LcdArmVExpress.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  ArmPlatformPkg/ArmVExpressPkg/ArmVExpressPkg.dec
-  ArmPlatformPkg/ArmPlatformPkg.dec
-
-[LibraryClasses]
-  BaseLib
-  ArmPlatformSysConfigLib
-
-[Protocols]
-  gEfiEdidDiscoveredProtocolGuid                # Produced
-  gEfiEdidActiveProtocolGuid                    # Produced
-
-[Pcd]
-  gArmVExpressTokenSpaceGuid.PcdPL111LcdMaxMode
-  gArmVExpressTokenSpaceGuid.PcdPL111LcdVideoModeOscId
+#/** @file

+#  

+#  Component description file for ArmVeGraphicsDxe module

+#  

+#  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>

+#

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = PL111LcdArmVExpressLib

+  FILE_GUID                      = b7f06f20-496f-11e0-a8e8-0002a5d5c51b

+  MODULE_TYPE                    = DXE_DRIVER

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = LcdPlatformLib

+  

+[Sources.common]

+  PL111LcdArmVExpress.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  ArmPlatformPkg/ArmVExpressPkg/ArmVExpressPkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+

+[LibraryClasses]

+  BaseLib

+  ArmPlatformSysConfigLib

+

+[Protocols]

+  gEfiEdidDiscoveredProtocolGuid                # Produced

+  gEfiEdidActiveProtocolGuid                    # Produced

+

+[Pcd]

+  gArmVExpressTokenSpaceGuid.PcdPL111LcdMaxMode

+  gArmVExpressTokenSpaceGuid.PcdPL111LcdVideoModeOscId

diff --git a/ArmPlatformPkg/ArmVExpressPkg/Library/ResetSystemLib/ResetSystemLib.c b/ArmPlatformPkg/ArmVExpressPkg/Library/ResetSystemLib/ResetSystemLib.c
index a471eb26..f8583175 100644
--- a/ArmPlatformPkg/ArmVExpressPkg/Library/ResetSystemLib/ResetSystemLib.c
+++ b/ArmPlatformPkg/ArmVExpressPkg/Library/ResetSystemLib/ResetSystemLib.c
@@ -1,81 +1,81 @@
-/** @file
-  Template library implementation to support ResetSystem Runtime call.
-  
-  Fill in the templates with what ever makes you system reset.
-
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include <PiDxe.h>
-
-#include <Library/BaseLib.h>
-#include <Library/DebugLib.h>
-#include <Library/EfiResetSystemLib.h>
-#include <Library/ArmPlatformSysConfigLib.h>
-
-#include <ArmPlatform.h>
-
-/**
-  Resets the entire platform.
-
-  @param  ResetType             The type of reset to perform.
-  @param  ResetStatus           The status code for the reset.
-  @param  DataSize              The size, in bytes, of WatchdogData.
-  @param  ResetData             For a ResetType of EfiResetCold, EfiResetWarm, or
-                                EfiResetShutdown the data buffer starts with a Null-terminated
-                                Unicode string, optionally followed by additional binary data.
-
-**/
-EFI_STATUS
-EFIAPI
-LibResetSystem (
-  IN EFI_RESET_TYPE   ResetType,
-  IN EFI_STATUS       ResetStatus,
-  IN UINTN            DataSize,
-  IN CHAR16           *ResetData OPTIONAL
-  )
-{
-  switch (ResetType) {
-  case EfiResetWarm:
-    // Map a warm reset into a cold reset
-  case EfiResetCold:
-  case EfiResetShutdown:
-    // Send the REBOOT function to the platform microcontroller
-    ArmPlatformSysConfigSet (SYS_CFG_REBOOT, 0);
-
-    // We should never be here
-    while(1);
-  }
-
-  ASSERT(FALSE);
-  return EFI_UNSUPPORTED;
-}
-
-/**
-  Initialize any infrastructure required for LibResetSystem () to function.
-
-  @param  ImageHandle   The firmware allocated handle for the EFI image.
-  @param  SystemTable   A pointer to the EFI System Table.
-  
-  @retval EFI_SUCCESS   The constructor always returns EFI_SUCCESS.
-
-**/
-EFI_STATUS
-EFIAPI
-LibInitializeResetSystem (
-  IN EFI_HANDLE        ImageHandle,
-  IN EFI_SYSTEM_TABLE  *SystemTable
-  )
-{
-  return EFI_SUCCESS;
-}
+/** @file

+  Template library implementation to support ResetSystem Runtime call.

+  

+  Fill in the templates with what ever makes you system reset.

+

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include <PiDxe.h>

+

+#include <Library/BaseLib.h>

+#include <Library/DebugLib.h>

+#include <Library/EfiResetSystemLib.h>

+#include <Library/ArmPlatformSysConfigLib.h>

+

+#include <ArmPlatform.h>

+

+/**

+  Resets the entire platform.

+

+  @param  ResetType             The type of reset to perform.

+  @param  ResetStatus           The status code for the reset.

+  @param  DataSize              The size, in bytes, of WatchdogData.

+  @param  ResetData             For a ResetType of EfiResetCold, EfiResetWarm, or

+                                EfiResetShutdown the data buffer starts with a Null-terminated

+                                Unicode string, optionally followed by additional binary data.

+

+**/

+EFI_STATUS

+EFIAPI

+LibResetSystem (

+  IN EFI_RESET_TYPE   ResetType,

+  IN EFI_STATUS       ResetStatus,

+  IN UINTN            DataSize,

+  IN CHAR16           *ResetData OPTIONAL

+  )

+{

+  switch (ResetType) {

+  case EfiResetWarm:

+    // Map a warm reset into a cold reset

+  case EfiResetCold:

+  case EfiResetShutdown:

+    // Send the REBOOT function to the platform microcontroller

+    ArmPlatformSysConfigSet (SYS_CFG_REBOOT, 0);

+

+    // We should never be here

+    while(1);

+  }

+

+  ASSERT(FALSE);

+  return EFI_UNSUPPORTED;

+}

+

+/**

+  Initialize any infrastructure required for LibResetSystem () to function.

+

+  @param  ImageHandle   The firmware allocated handle for the EFI image.

+  @param  SystemTable   A pointer to the EFI System Table.

+  

+  @retval EFI_SUCCESS   The constructor always returns EFI_SUCCESS.

+

+**/

+EFI_STATUS

+EFIAPI

+LibInitializeResetSystem (

+  IN EFI_HANDLE        ImageHandle,

+  IN EFI_SYSTEM_TABLE  *SystemTable

+  )

+{

+  return EFI_SUCCESS;

+}

diff --git a/ArmPlatformPkg/ArmVExpressPkg/Library/ResetSystemLib/ResetSystemLib.inf b/ArmPlatformPkg/ArmVExpressPkg/Library/ResetSystemLib/ResetSystemLib.inf
index 3965e211..8dbd1c86 100644
--- a/ArmPlatformPkg/ArmVExpressPkg/Library/ResetSystemLib/ResetSystemLib.inf
+++ b/ArmPlatformPkg/ArmVExpressPkg/Library/ResetSystemLib/ResetSystemLib.inf
@@ -1,35 +1,35 @@
-#/** @file
-# Reset System lib to make it easy to port new platforms
-#
-# Copyright (c) 2008, Apple Inc. All rights reserved.<BR>
-#
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution. The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = ArmVeResetSystemLib
-  FILE_GUID                      = 36885202-0854-4373-bfd2-95d229b44d44 
-  MODULE_TYPE                    = BASE
-  VERSION_STRING                 = 1.0
-  LIBRARY_CLASS                  = EfiResetSystemLib
-
-[Sources.common]
-  ResetSystemLib.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  EmbeddedPkg/EmbeddedPkg.dec
-  ArmPlatformPkg/ArmPlatformPkg.dec
-
-[LibraryClasses]
-  DebugLib
-  BaseLib
-  ArmPlatformSysConfigLib
+#/** @file

+# Reset System lib to make it easy to port new platforms

+#

+# Copyright (c) 2008, Apple Inc. All rights reserved.<BR>

+#

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution. The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = ArmVeResetSystemLib

+  FILE_GUID                      = 36885202-0854-4373-bfd2-95d229b44d44 

+  MODULE_TYPE                    = BASE

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = EfiResetSystemLib

+

+[Sources.common]

+  ResetSystemLib.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  EmbeddedPkg/EmbeddedPkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+

+[LibraryClasses]

+  DebugLib

+  BaseLib

+  ArmPlatformSysConfigLib

diff --git a/ArmPlatformPkg/Bds/Bds.c b/ArmPlatformPkg/Bds/Bds.c
index fe463774..d1a17f1a 100644
--- a/ArmPlatformPkg/Bds/Bds.c
+++ b/ArmPlatformPkg/Bds/Bds.c
@@ -1,14 +1,14 @@
 /** @file

 *

-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

-*  

-*  This program and the accompanying materials                          

-*  are licensed and made available under the terms and conditions of the BSD License         

-*  which accompanies this distribution.  The full text of the license may be found at        

-*  http://opensource.org/licenses/bsd-license.php                                            

+*  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

 *

-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*  This program and the accompanying materials

+*  are licensed and made available under the terms and conditions of the BSD License

+*  which accompanies this distribution.  The full text of the license may be found at

+*  http://opensource.org/licenses/bsd-license.php

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

 *

 **/

 

@@ -39,7 +39,7 @@ GetConsoleDevicePathFromVariable (
   CHAR16*                   NextDevicePathStr;

   EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL  *EfiDevicePathFromTextProtocol;

 

-  Status = GetEnvironmentVariable (ConsoleVarName, NULL, NULL, (VOID**)&DevicePathInstances);

+  Status = GetGlobalEnvironmentVariable (ConsoleVarName, NULL, NULL, (VOID**)&DevicePathInstances);

   if (EFI_ERROR(Status)) {

     // In case no default console device path has been defined we assume a driver handles the console (eg: SimpleTextInOutSerial)

     if ((DefaultConsolePaths == NULL) || (DefaultConsolePaths[0] == L'\0')) {

@@ -124,7 +124,7 @@ InitializeConsolePipe (
         EFI_DEVICE_PATH_TO_TEXT_PROTOCOL* DevicePathToTextProtocol;

         CHAR16* DevicePathTxt;

         EFI_STATUS Status;

-	

+

         Status = gBS->LocateProtocol(&gEfiDevicePathToTextProtocolGuid, NULL, (VOID **)&DevicePathToTextProtocol);

         if (!EFI_ERROR(Status)) {

           DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (DevicePath, TRUE, TRUE);

@@ -223,10 +223,10 @@ DefineDefaultBootEntries (
   ARM_BDS_LOADER_ARGUMENTS*           BootArguments;

   ARM_BDS_LOADER_TYPE                 BootType;

   EFI_DEVICE_PATH*                    InitrdPath;

-  EFI_DEVICE_PATH*                    FdtLocalPath;
+  EFI_DEVICE_PATH*                    FdtLocalPath;

   UINTN                               CmdLineSize;

   UINTN                               InitrdSize;

-  UINTN                               FdtLocalSize;
+  UINTN                               FdtLocalSize;

 

   //

   // If Boot Order does not exist then create a default entry

@@ -264,21 +264,26 @@ DefineDefaultBootEntries (
     if (BootDevicePath != NULL) {

       BootType = (ARM_BDS_LOADER_TYPE)PcdGet32 (PcdDefaultBootType);

 

-      if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) || (BootType == BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT) || (BootType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT)) {
+      if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) || (BootType == BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT) || (BootType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT)) {

         CmdLineSize = AsciiStrSize ((CHAR8*)PcdGetPtr(PcdDefaultBootArgument));

         InitrdPath = EfiDevicePathFromTextProtocol->ConvertTextToDevicePath ((CHAR16*)PcdGetPtr(PcdDefaultBootInitrdPath));

         InitrdSize = GetDevicePathSize (InitrdPath);

-        FdtLocalPath = EfiDevicePathFromTextProtocol->ConvertTextToDevicePath ((CHAR16*)PcdGetPtr(PcdFdtLocalDevicePath));
-        FdtLocalSize = GetDevicePathSize (FdtLocalPath);
+        if (BootType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT) {

+          FdtLocalPath = EfiDevicePathFromTextProtocol->ConvertTextToDevicePath ((CHAR16*)PcdGetPtr(PcdDefaultFdtLocalDevicePath));

+          FdtLocalSize = GetDevicePathSize (FdtLocalPath);

+        } else {

+          FdtLocalPath = NULL;

+          FdtLocalSize = 0;

+        }

 

-        BootArguments = (ARM_BDS_LOADER_ARGUMENTS*)AllocatePool (sizeof(ARM_BDS_LOADER_ARGUMENTS) + CmdLineSize + InitrdSize + FdtLocalSize);
+        BootArguments = (ARM_BDS_LOADER_ARGUMENTS*)AllocatePool (sizeof(ARM_BDS_LOADER_ARGUMENTS) + CmdLineSize + InitrdSize + FdtLocalSize);

         BootArguments->LinuxArguments.CmdLineSize = CmdLineSize;

         BootArguments->LinuxArguments.InitrdSize = InitrdSize;

-        BootArguments->LinuxArguments.FdtLocalSize = FdtLocalSize;
+        BootArguments->LinuxArguments.FdtLocalSize = FdtLocalSize;

 

         CopyMem ((VOID*)(BootArguments + 1), (CHAR8*)PcdGetPtr(PcdDefaultBootArgument), CmdLineSize);

         CopyMem ((VOID*)((UINTN)(BootArguments + 1) + CmdLineSize), InitrdPath, InitrdSize);

-        CopyMem ((VOID*)((UINTN)(BootArguments + 1) + CmdLineSize + InitrdSize), FdtLocalPath, FdtLocalSize);
+        CopyMem ((VOID*)((UINTN)(BootArguments + 1) + CmdLineSize + InitrdSize), FdtLocalPath, FdtLocalSize);

       } else {

         BootArguments = NULL;

       }

@@ -319,7 +324,7 @@ StartDefaultBootOnTimeout (
   Size = sizeof(UINT16);

   Timeout = (UINT16)PcdGet16 (PcdPlatformBootTimeOut);

   TimeoutPtr = &Timeout;

-  GetEnvironmentVariable (L"Timeout", &Timeout, &Size, (VOID**)&TimeoutPtr);

+  GetGlobalEnvironmentVariable (L"Timeout", &Timeout, &Size, (VOID**)&TimeoutPtr);

 

   if (Timeout != 0xFFFF) {

     if (Timeout > 0) {

@@ -350,7 +355,7 @@ StartDefaultBootOnTimeout (
     // In case of Timeout we start the default boot selection

     if (Timeout == 0) {

       // Get the Boot Option Order from the environment variable (a default value should have been created)

-      GetEnvironmentVariable (L"BootOrder", NULL, &BootOrderSize, (VOID**)&BootOrder);

+      GetGlobalEnvironmentVariable (L"BootOrder", NULL, &BootOrderSize, (VOID**)&BootOrder);

 

       for (Index = 0; Index < BootOrderSize / sizeof (UINT16); Index++) {

         UnicodeSPrint (BootVariableName, 9 * sizeof(CHAR16), L"Boot%04X", BootOrder[Index]);

@@ -368,19 +373,19 @@ StartDefaultBootOnTimeout (
 }

 

 /**

-  This function uses policy data from the platform to determine what operating 

-  system or system utility should be loaded and invoked.  This function call 

-  also optionally make the use of user input to determine the operating system 

-  or system utility to be loaded and invoked.  When the DXE Core has dispatched 

-  all the drivers on the dispatch queue, this function is called.  This 

-  function will attempt to connect the boot devices required to load and invoke 

-  the selected operating system or system utility.  During this process, 

-  additional firmware volumes may be discovered that may contain addition DXE 

-  drivers that can be dispatched by the DXE Core.   If a boot device cannot be 

-  fully connected, this function calls the DXE Service Dispatch() to allow the 

-  DXE drivers from any newly discovered firmware volumes to be dispatched.  

-  Then the boot device connection can be attempted again.  If the same boot 

-  device connection operation fails twice in a row, then that boot device has 

+  This function uses policy data from the platform to determine what operating

+  system or system utility should be loaded and invoked.  This function call

+  also optionally make the use of user input to determine the operating system

+  or system utility to be loaded and invoked.  When the DXE Core has dispatched

+  all the drivers on the dispatch queue, this function is called.  This

+  function will attempt to connect the boot devices required to load and invoke

+  the selected operating system or system utility.  During this process,

+  additional firmware volumes may be discovered that may contain addition DXE

+  drivers that can be dispatched by the DXE Core.   If a boot device cannot be

+  fully connected, this function calls the DXE Service Dispatch() to allow the

+  DXE drivers from any newly discovered firmware volumes to be dispatched.

+  Then the boot device connection can be attempted again.  If the same boot

+  device connection operation fails twice in a row, then that boot device has

   failed, and should be skipped.  This function should never return.

 

   @param  This             The EFI_BDS_ARCH_PROTOCOL instance.

@@ -414,7 +419,7 @@ BdsEntry (
 

   // If BootNext environment variable is defined then we just load it !

   BootNextSize = sizeof(UINT16);

-  Status = GetEnvironmentVariable (L"BootNext", NULL, &BootNextSize, (VOID**)&BootNext);

+  Status = GetGlobalEnvironmentVariable (L"BootNext", NULL, &BootNextSize, (VOID**)&BootNext);

   if (!EFI_ERROR(Status)) {

     ASSERT(BootNextSize == sizeof(UINT16));

 

diff --git a/ArmPlatformPkg/Bds/Bds.inf b/ArmPlatformPkg/Bds/Bds.inf
index f4887936..8b3f1d2e 100644
--- a/ArmPlatformPkg/Bds/Bds.inf
+++ b/ArmPlatformPkg/Bds/Bds.inf
@@ -1,76 +1,77 @@
-#/** @file
-#  
-#  Component description file for Bds module
-#  
-#  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>
-#
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = ArmPlatformBds
-  FILE_GUID                      = 5a50aa81-c3ae-4608-a0e3-41a2e69baf94 
-  MODULE_TYPE                    = DXE_DRIVER
-  VERSION_STRING                 = 1.0
-
-  ENTRY_POINT                    = BdsInitialize
-
-[Sources.common]
-  Bds.c
-  BdsHelper.c
-  BootMenu.c
-  BootOption.c
-  BootOptionSupport.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  MdeModulePkg/MdeModulePkg.dec
-  ArmPkg/ArmPkg.dec
-  ArmPlatformPkg/ArmPlatformPkg.dec
-
-[LibraryClasses]
-  BdsLib
-  TimerLib
-  PerformanceLib
-  UefiBootServicesTableLib
-  DxeServicesTableLib
-  UefiDriverEntryPoint
-  DebugLib
-  PrintLib
-  BaseLib
-  
-[Guids]
-  gEfiFileSystemInfoGuid
-  
-[Protocols]
-  gEfiBdsArchProtocolGuid
-  gEfiBlockIoProtocolGuid
-  gEfiSimpleTextInProtocolGuid
-  gEfiPxeBaseCodeProtocolGuid
-  gEfiSimpleNetworkProtocolGuid
-  gEfiDevicePathToTextProtocolGuid
-
-[Pcd]
-  gArmPlatformTokenSpaceGuid.PcdFirmwareVendor
-  gArmPlatformTokenSpaceGuid.PcdDefaultBootDescription
-  gArmPlatformTokenSpaceGuid.PcdDefaultBootDevicePath
-  gArmPlatformTokenSpaceGuid.PcdDefaultBootInitrdPath
-  gArmPlatformTokenSpaceGuid.PcdDefaultBootArgument
-  gArmPlatformTokenSpaceGuid.PcdDefaultBootType
-  gArmPlatformTokenSpaceGuid.PcdFdtDevicePath
-  gArmPlatformTokenSpaceGuid.PcdFdtLocalDevicePath
-  gArmPlatformTokenSpaceGuid.PcdPlatformBootTimeOut
-  gArmPlatformTokenSpaceGuid.PcdDefaultConInPaths
-  gArmPlatformTokenSpaceGuid.PcdDefaultConOutPaths
-  
-[Depex]
-  TRUE
+#/** @file

+#

+#  Component description file for Bds module

+#

+#  Copyright (c) 2011-2013, ARM Ltd. All rights reserved.<BR>

+#

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#**/

+

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = ArmPlatformBds

+  FILE_GUID                      = 5a50aa81-c3ae-4608-a0e3-41a2e69baf94

+  MODULE_TYPE                    = DXE_DRIVER

+  VERSION_STRING                 = 1.0

+

+  ENTRY_POINT                    = BdsInitialize

+

+[Sources.common]

+  Bds.c

+  BdsHelper.c

+  BootMenu.c

+  BootOption.c

+  BootOptionSupport.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  MdeModulePkg/MdeModulePkg.dec

+  ArmPkg/ArmPkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+

+[LibraryClasses]

+  BdsLib

+  TimerLib

+  PerformanceLib

+  UefiBootServicesTableLib

+  DxeServicesTableLib

+  UefiDriverEntryPoint

+  DebugLib

+  PrintLib

+  BaseLib

+

+[Guids]

+  gEfiFileSystemInfoGuid

+  gArmGlobalVariableGuid

+

+[Protocols]

+  gEfiBdsArchProtocolGuid

+  gEfiBlockIoProtocolGuid

+  gEfiSimpleTextInProtocolGuid

+  gEfiPxeBaseCodeProtocolGuid

+  gEfiSimpleNetworkProtocolGuid

+  gEfiDevicePathToTextProtocolGuid

+

+[Pcd]

+  gArmPlatformTokenSpaceGuid.PcdFirmwareVendor

+  gArmPlatformTokenSpaceGuid.PcdDefaultBootDescription

+  gArmPlatformTokenSpaceGuid.PcdDefaultBootDevicePath

+  gArmPlatformTokenSpaceGuid.PcdDefaultBootInitrdPath

+  gArmPlatformTokenSpaceGuid.PcdDefaultBootArgument

+  gArmPlatformTokenSpaceGuid.PcdDefaultBootType

+  gArmPlatformTokenSpaceGuid.PcdFdtDevicePath

+  gArmPlatformTokenSpaceGuid.PcdDefaultFdtLocalDevicePath

+  gArmPlatformTokenSpaceGuid.PcdPlatformBootTimeOut

+  gArmPlatformTokenSpaceGuid.PcdDefaultConInPaths

+  gArmPlatformTokenSpaceGuid.PcdDefaultConOutPaths

+

+[Depex]

+  TRUE

diff --git a/ArmPlatformPkg/Bds/BdsHelper.c b/ArmPlatformPkg/Bds/BdsHelper.c
index 84988f04..cd7c8a58 100644
--- a/ArmPlatformPkg/Bds/BdsHelper.c
+++ b/ArmPlatformPkg/Bds/BdsHelper.c
@@ -1,320 +1,320 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-#include "BdsInternal.h"
-
-EFI_STATUS
-EditHIInputStr (
-  IN OUT CHAR16  *CmdLine,
-  IN     UINTN   MaxCmdLine
-  )
-{
-  UINTN           CmdLineIndex;
-  UINTN           WaitIndex;
-  CHAR8           Char;
-  EFI_INPUT_KEY   Key;
-  EFI_STATUS      Status;
-
-  Print (CmdLine);
-
-  for (CmdLineIndex = StrLen (CmdLine); CmdLineIndex < MaxCmdLine; ) {
-    Status = gBS->WaitForEvent (1, &gST->ConIn->WaitForKey, &WaitIndex);
-    ASSERT_EFI_ERROR (Status);
-
-    Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
-    ASSERT_EFI_ERROR (Status);
-
-    // Unicode character is valid when Scancode is NUll
-    if (Key.ScanCode == SCAN_NULL) {
-      // Scan code is NUll, hence read Unicode character
-      Char = (CHAR8)Key.UnicodeChar;
-    } else {
-      Char = CHAR_NULL;
-    }
-
-    if ((Char == CHAR_LINEFEED) || (Char == CHAR_CARRIAGE_RETURN) || (Char == 0x7f)) {
-      CmdLine[CmdLineIndex] = '\0';
-      Print (L"\n\r");
-
-      return EFI_SUCCESS;
-    } else if ((Key.UnicodeChar == L'\b') || (Key.ScanCode == SCAN_LEFT) || (Key.ScanCode == SCAN_DELETE)){
-      if (CmdLineIndex != 0) {
-        CmdLineIndex--;
-        Print (L"\b \b");
-      }
-    } else if ((Key.ScanCode == SCAN_ESC) || (Char == 0x1B) || (Char == 0x0)) {
-      return EFI_INVALID_PARAMETER;
-    } else {
-      CmdLine[CmdLineIndex++] = Key.UnicodeChar;
-      Print (L"%c", Key.UnicodeChar);
-    }
-  }
-
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-GetHIInputStr (
-  IN OUT CHAR16  *CmdLine,
-  IN     UINTN   MaxCmdLine
-  )
-{
-  EFI_STATUS  Status;
-
-  // For a new input just passed an empty string
-  CmdLine[0] = L'\0';
-
-  Status = EditHIInputStr (CmdLine, MaxCmdLine);
-
-  return Status;
-}
-
-EFI_STATUS
-EditHIInputAscii (
-  IN OUT CHAR8   *CmdLine,
-  IN     UINTN   MaxCmdLine
-  )
-{
-  CHAR16*     Str;
-  EFI_STATUS  Status;
-
-  Str = (CHAR16*)AllocatePool (MaxCmdLine * sizeof(CHAR16));
-  AsciiStrToUnicodeStr (CmdLine, Str);
-
-  Status = EditHIInputStr (Str, MaxCmdLine);
-  if (!EFI_ERROR(Status)) {
-    UnicodeStrToAsciiStr (Str, CmdLine);
-  }
-  FreePool (Str);
-
-  return Status;
-}
-
-EFI_STATUS
-GetHIInputAscii (
-  IN OUT CHAR8   *CmdLine,
-  IN     UINTN   MaxCmdLine
-  )
-{
-  // For a new input just passed an empty string
-  CmdLine[0] = '\0';
-
-  return EditHIInputAscii (CmdLine,MaxCmdLine);
-}
-
-EFI_STATUS
-GetHIInputInteger (
-  OUT UINTN   *Integer
-  )
-{
-  CHAR16      CmdLine[255];
-  EFI_STATUS  Status;
-
-  CmdLine[0] = '\0';
-  Status = EditHIInputStr (CmdLine, 255);
-  if (!EFI_ERROR(Status)) {
-    *Integer = StrDecimalToUintn (CmdLine);
-  }
-
-  return Status;
-}
-
-EFI_STATUS
-GetHIInputIP (
-  OUT EFI_IP_ADDRESS   *Ip
-  )
-{
-  CHAR16  CmdLine[255];
-  CHAR16  *Str;
-  EFI_STATUS  Status;
-
-  CmdLine[0] = '\0';
-  Status = EditHIInputStr (CmdLine,255);
-  if (!EFI_ERROR(Status)) {
-    Str = CmdLine;
-    Ip->v4.Addr[0] = (UINT8)StrDecimalToUintn (Str);
-
-    Str = StrStr (Str, L".");
-    if (Str == NULL) {
-      return EFI_INVALID_PARAMETER;
-    }
-
-    Ip->v4.Addr[1] = (UINT8)StrDecimalToUintn (++Str);
-
-    Str = StrStr (Str, L".");
-    if (Str == NULL) {
-      return EFI_INVALID_PARAMETER;
-    }
-
-    Ip->v4.Addr[2] = (UINT8)StrDecimalToUintn (++Str);
-
-    Str = StrStr (Str, L".");
-    if (Str == NULL) {
-      return EFI_INVALID_PARAMETER;
-    }
-
-    Ip->v4.Addr[3] = (UINT8)StrDecimalToUintn (++Str);
-  }
-
-  return Status;
-}
-
-EFI_STATUS
-GetHIInputBoolean (
-  OUT BOOLEAN *Value
-  )
-{
-  CHAR16      CmdBoolean[2];
-  EFI_STATUS  Status;
-
-  while(1) {
-    Print (L"[y/n] ");
-    Status = GetHIInputStr (CmdBoolean, 2);
-    if (EFI_ERROR(Status)) {
-      return Status;
-    } else if ((CmdBoolean[0] == L'y') || (CmdBoolean[0] == L'Y')) {
-      if (Value) *Value = TRUE;
-      return EFI_SUCCESS;
-    } else if ((CmdBoolean[0] == L'n') || (CmdBoolean[0] == L'N')) {
-      if (Value) *Value = FALSE;
-      return EFI_SUCCESS;
-    }
-  }
-}
-
-BOOLEAN
-HasFilePathEfiExtension (
-  IN CHAR16* FilePath
-  )
-{
+/** @file

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+#include "BdsInternal.h"

+

+EFI_STATUS

+EditHIInputStr (

+  IN OUT CHAR16  *CmdLine,

+  IN     UINTN   MaxCmdLine

+  )

+{

+  UINTN           CmdLineIndex;

+  UINTN           WaitIndex;

+  CHAR8           Char;

+  EFI_INPUT_KEY   Key;

+  EFI_STATUS      Status;

+

+  Print (CmdLine);

+

+  for (CmdLineIndex = StrLen (CmdLine); CmdLineIndex < MaxCmdLine; ) {

+    Status = gBS->WaitForEvent (1, &gST->ConIn->WaitForKey, &WaitIndex);

+    ASSERT_EFI_ERROR (Status);

+

+    Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);

+    ASSERT_EFI_ERROR (Status);

+

+    // Unicode character is valid when Scancode is NUll

+    if (Key.ScanCode == SCAN_NULL) {

+      // Scan code is NUll, hence read Unicode character

+      Char = (CHAR8)Key.UnicodeChar;

+    } else {

+      Char = CHAR_NULL;

+    }

+

+    if ((Char == CHAR_LINEFEED) || (Char == CHAR_CARRIAGE_RETURN) || (Char == 0x7f)) {

+      CmdLine[CmdLineIndex] = '\0';

+      Print (L"\n\r");

+

+      return EFI_SUCCESS;

+    } else if ((Key.UnicodeChar == L'\b') || (Key.ScanCode == SCAN_LEFT) || (Key.ScanCode == SCAN_DELETE)){

+      if (CmdLineIndex != 0) {

+        CmdLineIndex--;

+        Print (L"\b \b");

+      }

+    } else if ((Key.ScanCode == SCAN_ESC) || (Char == 0x1B) || (Char == 0x0)) {

+      return EFI_INVALID_PARAMETER;

+    } else {

+      CmdLine[CmdLineIndex++] = Key.UnicodeChar;

+      Print (L"%c", Key.UnicodeChar);

+    }

+  }

+

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+GetHIInputStr (

+  IN OUT CHAR16  *CmdLine,

+  IN     UINTN   MaxCmdLine

+  )

+{

+  EFI_STATUS  Status;

+

+  // For a new input just passed an empty string

+  CmdLine[0] = L'\0';

+

+  Status = EditHIInputStr (CmdLine, MaxCmdLine);

+

+  return Status;

+}

+

+EFI_STATUS

+EditHIInputAscii (

+  IN OUT CHAR8   *CmdLine,

+  IN     UINTN   MaxCmdLine

+  )

+{

+  CHAR16*     Str;

+  EFI_STATUS  Status;

+

+  Str = (CHAR16*)AllocatePool (MaxCmdLine * sizeof(CHAR16));

+  AsciiStrToUnicodeStr (CmdLine, Str);

+

+  Status = EditHIInputStr (Str, MaxCmdLine);

+  if (!EFI_ERROR(Status)) {

+    UnicodeStrToAsciiStr (Str, CmdLine);

+  }

+  FreePool (Str);

+

+  return Status;

+}

+

+EFI_STATUS

+GetHIInputAscii (

+  IN OUT CHAR8   *CmdLine,

+  IN     UINTN   MaxCmdLine

+  )

+{

+  // For a new input just passed an empty string

+  CmdLine[0] = '\0';

+

+  return EditHIInputAscii (CmdLine,MaxCmdLine);

+}

+

+EFI_STATUS

+GetHIInputInteger (

+  OUT UINTN   *Integer

+  )

+{

+  CHAR16      CmdLine[255];

+  EFI_STATUS  Status;

+

+  CmdLine[0] = '\0';

+  Status = EditHIInputStr (CmdLine, 255);

+  if (!EFI_ERROR(Status)) {

+    *Integer = StrDecimalToUintn (CmdLine);

+  }

+

+  return Status;

+}

+

+EFI_STATUS

+GetHIInputIP (

+  OUT EFI_IP_ADDRESS   *Ip

+  )

+{

+  CHAR16  CmdLine[255];

+  CHAR16  *Str;

+  EFI_STATUS  Status;

+

+  CmdLine[0] = '\0';

+  Status = EditHIInputStr (CmdLine,255);

+  if (!EFI_ERROR(Status)) {

+    Str = CmdLine;

+    Ip->v4.Addr[0] = (UINT8)StrDecimalToUintn (Str);

+

+    Str = StrStr (Str, L".");

+    if (Str == NULL) {

+      return EFI_INVALID_PARAMETER;

+    }

+

+    Ip->v4.Addr[1] = (UINT8)StrDecimalToUintn (++Str);

+

+    Str = StrStr (Str, L".");

+    if (Str == NULL) {

+      return EFI_INVALID_PARAMETER;

+    }

+

+    Ip->v4.Addr[2] = (UINT8)StrDecimalToUintn (++Str);

+

+    Str = StrStr (Str, L".");

+    if (Str == NULL) {

+      return EFI_INVALID_PARAMETER;

+    }

+

+    Ip->v4.Addr[3] = (UINT8)StrDecimalToUintn (++Str);

+  }

+

+  return Status;

+}

+

+EFI_STATUS

+GetHIInputBoolean (

+  OUT BOOLEAN *Value

+  )

+{

+  CHAR16      CmdBoolean[2];

+  EFI_STATUS  Status;

+

+  while(1) {

+    Print (L"[y/n] ");

+    Status = GetHIInputStr (CmdBoolean, 2);

+    if (EFI_ERROR(Status)) {

+      return Status;

+    } else if ((CmdBoolean[0] == L'y') || (CmdBoolean[0] == L'Y')) {

+      if (Value) *Value = TRUE;

+      return EFI_SUCCESS;

+    } else if ((CmdBoolean[0] == L'n') || (CmdBoolean[0] == L'N')) {

+      if (Value) *Value = FALSE;

+      return EFI_SUCCESS;

+    }

+  }

+}

+

+BOOLEAN

+HasFilePathEfiExtension (

+  IN CHAR16* FilePath

+  )

+{

   if (StrCmp (FilePath + (StrSize(FilePath)/sizeof(CHAR16)) - 5, L".EFI") == 0)
     return 1;
 
-  return (StrCmp (FilePath + (StrSize(FilePath)/sizeof(CHAR16)) - 5, L".efi") == 0);
-}
-
-// Return the last non end-type Device Path Node from a Device Path
-EFI_DEVICE_PATH*
-GetLastDevicePathNode (
-  IN EFI_DEVICE_PATH*  DevicePath
-  )
-{
-  EFI_DEVICE_PATH*     PrevDevicePathNode;
-
-  PrevDevicePathNode = DevicePath;
-  while (!IsDevicePathEndType (DevicePath)) {
-    PrevDevicePathNode = DevicePath;
-    DevicePath = NextDevicePathNode (DevicePath);
-  }
-
-  return PrevDevicePathNode;
-}
-
-EFI_STATUS
-GenerateDeviceDescriptionName (
-  IN  EFI_HANDLE  Handle,
-  IN OUT CHAR16*  Description
-  )
-{
-  EFI_STATUS                        Status;
-  EFI_COMPONENT_NAME_PROTOCOL*      ComponentName2Protocol;
-  EFI_DEVICE_PATH_TO_TEXT_PROTOCOL* DevicePathToTextProtocol;
-  EFI_DEVICE_PATH_PROTOCOL*         DevicePathProtocol;
-  CHAR16*                           DriverName;
-  CHAR16*                           DevicePathTxt;
-  EFI_DEVICE_PATH*                  DevicePathNode;
-
-  ComponentName2Protocol = NULL;
-  Status = gBS->HandleProtocol (Handle, &gEfiComponentName2ProtocolGuid, (VOID **)&ComponentName2Protocol);
-  if (!EFI_ERROR(Status)) {
-    //TODO: Fixme. we must find the best langague
-    Status = ComponentName2Protocol->GetDriverName (ComponentName2Protocol,"en",&DriverName);
-    if (!EFI_ERROR(Status)) {
-      StrnCpy (Description, DriverName, BOOT_DEVICE_DESCRIPTION_MAX);
-    }
-  }
-
-  if (EFI_ERROR(Status)) {
-    // Use the lastest non null entry of the Device path as a description
-    Status = gBS->HandleProtocol (Handle, &gEfiDevicePathProtocolGuid, (VOID **)&DevicePathProtocol);
-    if (EFI_ERROR(Status)) {
-      return Status;
-    }
-
-    // Convert the last non end-type Device Path Node in text for the description
-    DevicePathNode = GetLastDevicePathNode (DevicePathProtocol);
-    Status = gBS->LocateProtocol (&gEfiDevicePathToTextProtocolGuid, NULL, (VOID **)&DevicePathToTextProtocol);
-    ASSERT_EFI_ERROR(Status);
-    DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (DevicePathNode, TRUE, TRUE);
-    StrnCpy (Description, DevicePathTxt, BOOT_DEVICE_DESCRIPTION_MAX);
-    FreePool (DevicePathTxt);
-  }
-
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-BdsStartBootOption (
-  IN CHAR16* BootOption
-  )
-{
-  EFI_STATUS          Status;
-  BDS_LOAD_OPTION     *BdsLoadOption;
-
-  Status = BootOptionFromLoadOptionVariable (BootOption, &BdsLoadOption);
-  if (!EFI_ERROR(Status)) {
-    Status = BootOptionStart (BdsLoadOption);
-    FreePool (BdsLoadOption);
-
-    if (!EFI_ERROR(Status)) {
-      Status = EFI_SUCCESS;
-    } else {
-      Status = EFI_NOT_STARTED;
-    }
-  } else {
-    Status = EFI_NOT_FOUND;
-  }
-  return Status;
-}
-
-UINTN
-GetUnalignedDevicePathSize (
-  IN EFI_DEVICE_PATH* DevicePath
-  )
-{
-  UINTN Size;
-  EFI_DEVICE_PATH* AlignedDevicePath;
-
-  if ((UINTN)DevicePath & 0x1) {
-    AlignedDevicePath = DuplicateDevicePath (DevicePath);
-    Size = GetDevicePathSize (AlignedDevicePath);
-    FreePool (AlignedDevicePath);
-  } else {
-    Size = GetDevicePathSize (DevicePath);
-  }
-  return Size;
-}
-
-EFI_DEVICE_PATH*
-GetAlignedDevicePath (
-  IN EFI_DEVICE_PATH* DevicePath
-  )
-{
-  if ((UINTN)DevicePath & 0x1) {
-    return DuplicateDevicePath (DevicePath);
-  } else {
-    return DevicePath;
-  }
-}
-
+  return (StrCmp (FilePath + (StrSize(FilePath)/sizeof(CHAR16)) - 5, L".efi") == 0);

+}

+

+// Return the last non end-type Device Path Node from a Device Path

+EFI_DEVICE_PATH*

+GetLastDevicePathNode (

+  IN EFI_DEVICE_PATH*  DevicePath

+  )

+{

+  EFI_DEVICE_PATH*     PrevDevicePathNode;

+

+  PrevDevicePathNode = DevicePath;

+  while (!IsDevicePathEndType (DevicePath)) {

+    PrevDevicePathNode = DevicePath;

+    DevicePath = NextDevicePathNode (DevicePath);

+  }

+

+  return PrevDevicePathNode;

+}

+

+EFI_STATUS

+GenerateDeviceDescriptionName (

+  IN  EFI_HANDLE  Handle,

+  IN OUT CHAR16*  Description

+  )

+{

+  EFI_STATUS                        Status;

+  EFI_COMPONENT_NAME_PROTOCOL*      ComponentName2Protocol;

+  EFI_DEVICE_PATH_TO_TEXT_PROTOCOL* DevicePathToTextProtocol;

+  EFI_DEVICE_PATH_PROTOCOL*         DevicePathProtocol;

+  CHAR16*                           DriverName;

+  CHAR16*                           DevicePathTxt;

+  EFI_DEVICE_PATH*                  DevicePathNode;

+

+  ComponentName2Protocol = NULL;

+  Status = gBS->HandleProtocol (Handle, &gEfiComponentName2ProtocolGuid, (VOID **)&ComponentName2Protocol);

+  if (!EFI_ERROR(Status)) {

+    //TODO: Fixme. we must find the best langague

+    Status = ComponentName2Protocol->GetDriverName (ComponentName2Protocol,"en",&DriverName);

+    if (!EFI_ERROR(Status)) {

+      StrnCpy (Description, DriverName, BOOT_DEVICE_DESCRIPTION_MAX);

+    }

+  }

+

+  if (EFI_ERROR(Status)) {

+    // Use the lastest non null entry of the Device path as a description

+    Status = gBS->HandleProtocol (Handle, &gEfiDevicePathProtocolGuid, (VOID **)&DevicePathProtocol);

+    if (EFI_ERROR(Status)) {

+      return Status;

+    }

+

+    // Convert the last non end-type Device Path Node in text for the description

+    DevicePathNode = GetLastDevicePathNode (DevicePathProtocol);

+    Status = gBS->LocateProtocol (&gEfiDevicePathToTextProtocolGuid, NULL, (VOID **)&DevicePathToTextProtocol);

+    ASSERT_EFI_ERROR(Status);

+    DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (DevicePathNode, TRUE, TRUE);

+    StrnCpy (Description, DevicePathTxt, BOOT_DEVICE_DESCRIPTION_MAX);

+    FreePool (DevicePathTxt);

+  }

+

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+BdsStartBootOption (

+  IN CHAR16* BootOption

+  )

+{

+  EFI_STATUS          Status;

+  BDS_LOAD_OPTION     *BdsLoadOption;

+

+  Status = BootOptionFromLoadOptionVariable (BootOption, &BdsLoadOption);

+  if (!EFI_ERROR(Status)) {

+    Status = BootOptionStart (BdsLoadOption);

+    FreePool (BdsLoadOption);

+

+    if (!EFI_ERROR(Status)) {

+      Status = EFI_SUCCESS;

+    } else {

+      Status = EFI_NOT_STARTED;

+    }

+  } else {

+    Status = EFI_NOT_FOUND;

+  }

+  return Status;

+}

+

+UINTN

+GetUnalignedDevicePathSize (

+  IN EFI_DEVICE_PATH* DevicePath

+  )

+{

+  UINTN Size;

+  EFI_DEVICE_PATH* AlignedDevicePath;

+

+  if ((UINTN)DevicePath & 0x1) {

+    AlignedDevicePath = DuplicateDevicePath (DevicePath);

+    Size = GetDevicePathSize (AlignedDevicePath);

+    FreePool (AlignedDevicePath);

+  } else {

+    Size = GetDevicePathSize (DevicePath);

+  }

+  return Size;

+}

+

+EFI_DEVICE_PATH*

+GetAlignedDevicePath (

+  IN EFI_DEVICE_PATH* DevicePath

+  )

+{

+  if ((UINTN)DevicePath & 0x1) {

+    return DuplicateDevicePath (DevicePath);

+  } else {

+    return DevicePath;

+  }

+}

+

diff --git a/ArmPlatformPkg/Bds/BdsInternal.h b/ArmPlatformPkg/Bds/BdsInternal.h
index 9bc8229d..aab37d0e 100644
--- a/ArmPlatformPkg/Bds/BdsInternal.h
+++ b/ArmPlatformPkg/Bds/BdsInternal.h
@@ -1,6 +1,6 @@
 /** @file

 *

-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

 *

 *  This program and the accompanying materials

 *  are licensed and made available under the terms and conditions of the BSD License

@@ -48,19 +48,20 @@
 typedef enum {

     BDS_LOADER_EFI_APPLICATION = 0,

     BDS_LOADER_KERNEL_LINUX_ATAG,

-    BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT,
-    BDS_LOADER_KERNEL_LINUX_LOCAL_FDT,
+    BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT,

+    BDS_LOADER_KERNEL_LINUX_LOCAL_FDT,

 } ARM_BDS_LOADER_TYPE;

 

 typedef struct {

   UINT16                     CmdLineSize;

   UINT16                     InitrdSize;

-  UINT16                     FdtLocalSize;
-
+

+  UINT16                     FdtLocalSize;

+

   // These following fields have variable length and are packed:

   //CHAR8                      *CmdLine;

   //EFI_DEVICE_PATH_PROTOCOL   *InitrdPathList;

-  //EFI_DEVICE_PATH_PROTOCOL   *FdtLocalPathList;
+  //EFI_DEVICE_PATH_PROTOCOL   *FdtLocalPathList;

 } ARM_BDS_LINUX_ARGUMENTS;

 

 typedef union {

@@ -103,7 +104,7 @@ typedef struct _BDS_LOAD_OPTION_SUPPORT {
   BDS_SUPPORTED_DEVICE_TYPE   Type;

   EFI_STATUS    (*ListDevices)(IN OUT LIST_ENTRY* BdsLoadOptionList);

   BOOLEAN       (*IsSupported)(IN  EFI_DEVICE_PATH *DevicePath);

-  EFI_STATUS    (*CreateDevicePathNode)(IN CHAR16* FileName, OUT EFI_DEVICE_PATH_PROTOCOL **DevicePathNode, OUT ARM_BDS_LOADER_TYPE *BootType, OUT UINT32 *Attributes);

+  EFI_STATUS    (*CreateDevicePathNode)(IN CHAR16* FileName, OUT EFI_DEVICE_PATH_PROTOCOL **DevicePathNodes, OUT ARM_BDS_LOADER_TYPE *BootType, OUT UINT32 *Attributes);

   EFI_STATUS    (*UpdateDevicePathNode)(IN EFI_DEVICE_PATH *OldDevicePath, IN CHAR16* FileName, OUT EFI_DEVICE_PATH_PROTOCOL** NewDevicePath, OUT ARM_BDS_LOADER_TYPE *BootType, OUT UINT32 *Attributes);

 } BDS_LOAD_OPTION_SUPPORT;

 

@@ -111,14 +112,6 @@ typedef struct _BDS_LOAD_OPTION_SUPPORT {
 #define LOAD_OPTION_FROM_LINK(a)        ((BDS_LOAD_OPTION_ENTRY*)BASE_CR(a, BDS_LOAD_OPTION_ENTRY, Link))->BdsLoadOption

 

 EFI_STATUS

-GetEnvironmentVariable (

-  IN     CONST CHAR16*   VariableName,

-  IN     VOID*           DefaultValue,

-  IN OUT UINTN*          Size,

-  OUT    VOID**          Value

-  );

-

-EFI_STATUS

 BootDeviceListSupportedInit (

   IN OUT LIST_ENTRY *SupportedDeviceList

   );

diff --git a/ArmPlatformPkg/Bds/BootMenu.c b/ArmPlatformPkg/Bds/BootMenu.c
index 114f159b..2280e8c3 100644
--- a/ArmPlatformPkg/Bds/BootMenu.c
+++ b/ArmPlatformPkg/Bds/BootMenu.c
@@ -1,6 +1,6 @@
 /** @file

 *

-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

 *

 *  This program and the accompanying materials

 *  are licensed and made available under the terms and conditions of the BSD License

@@ -14,9 +14,12 @@
 

 #include "BdsInternal.h"

 

+#include <Guid/ArmGlobalVariableHob.h>

+

 extern EFI_HANDLE mImageHandle;

 extern BDS_LOAD_OPTION_SUPPORT *BdsLoadOptionSupportList;

 

+

 EFI_STATUS

 SelectBootDevice (

   OUT BDS_SUPPORTED_DEVICE** SupportedBootDevice

@@ -102,7 +105,7 @@ SelectBootDevice (
     }

     Index++;

   }

-  

+

 EXIT:

   BootDeviceListSupportedFree (&SupportedDeviceList, *SupportedBootDevice);

   return Status;

@@ -122,15 +125,15 @@ BootMenuAddBootOption (
   ARM_BDS_LOADER_TYPE       BootType;

   BDS_LOAD_OPTION_ENTRY     *BdsLoadOptionEntry;

   EFI_DEVICE_PATH           *DevicePath;

-  EFI_DEVICE_PATH_PROTOCOL  *DevicePathNode;

-  EFI_DEVICE_PATH_PROTOCOL  *InitrdPathNode;

+  EFI_DEVICE_PATH_PROTOCOL  *DevicePathNodes;

+  EFI_DEVICE_PATH_PROTOCOL  *InitrdPathNodes;

   EFI_DEVICE_PATH_PROTOCOL  *InitrdPath;

-  EFI_DEVICE_PATH_PROTOCOL  *FdtLocalPathNode;
-  EFI_DEVICE_PATH_PROTOCOL  *FdtLocalPath;
+  EFI_DEVICE_PATH_PROTOCOL  *FdtLocalPathNode;

+  EFI_DEVICE_PATH_PROTOCOL  *FdtLocalPath;

   UINTN                     CmdLineSize;

   BOOLEAN                   InitrdSupport;

   UINTN                     InitrdSize;

-  UINTN                     FdtLocalSize;
+  UINTN                     FdtLocalSize;

 

   Attributes                = 0;

   SupportedBootDevice = NULL;

@@ -143,15 +146,19 @@ BootMenuAddBootOption (
   }

 

   // Create the specific device path node

-  Status = SupportedBootDevice->Support->CreateDevicePathNode (L"EFI Application or the kernel", &DevicePathNode, &BootType, &Attributes);

+  Status = SupportedBootDevice->Support->CreateDevicePathNode (L"EFI Application or the kernel", &DevicePathNodes, &BootType, &Attributes);

   if (EFI_ERROR(Status)) {

     Status = EFI_ABORTED;

     goto EXIT;

   }

-  // Append the Device Path node to the select device path

-  DevicePath = AppendDevicePathNode (SupportedBootDevice->DevicePathProtocol, (CONST EFI_DEVICE_PATH_PROTOCOL *)DevicePathNode);

+  // Append the Device Path to the selected device path

+  DevicePath = AppendDevicePath (SupportedBootDevice->DevicePathProtocol, (CONST EFI_DEVICE_PATH_PROTOCOL *)DevicePathNodes);

+  if (DevicePath == NULL) {

+    Status = EFI_OUT_OF_RESOURCES;

+    goto EXIT;

+  }

 

-  if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) || (BootType == BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT) || (BootType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT)) {
+  if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) || (BootType == BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT) || (BootType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT)) {

     Print(L"Add an initrd: ");

     Status = GetHIInputBoolean (&InitrdSupport);

     if (EFI_ERROR(Status)) {

@@ -161,15 +168,19 @@ BootMenuAddBootOption (
 

     if (InitrdSupport) {

       // Create the specific device path node

-      Status = SupportedBootDevice->Support->CreateDevicePathNode (L"initrd", &InitrdPathNode, NULL, NULL);

+      Status = SupportedBootDevice->Support->CreateDevicePathNode (L"initrd", &InitrdPathNodes, NULL, NULL);

       if (EFI_ERROR(Status) && Status != EFI_NOT_FOUND) { // EFI_NOT_FOUND is returned on empty input string, but we can boot without an initrd

         Status = EFI_ABORTED;

         goto EXIT;

       }

 

-      if (InitrdPathNode != NULL) {

-        // Append the Device Path node to the select device path

-        InitrdPath = AppendDevicePathNode (SupportedBootDevice->DevicePathProtocol, (CONST EFI_DEVICE_PATH_PROTOCOL *)InitrdPathNode);

+      if (InitrdPathNodes != NULL) {

+        // Append the Device Path to the selected device path

+        InitrdPath = AppendDevicePath (SupportedBootDevice->DevicePathProtocol, (CONST EFI_DEVICE_PATH_PROTOCOL *)InitrdPathNodes);

+        if (InitrdPath == NULL) {

+          Status = EFI_OUT_OF_RESOURCES;

+          goto EXIT;

+        }

       } else {

         InitrdPath = NULL;

       }

@@ -184,36 +195,36 @@ BootMenuAddBootOption (
       goto FREE_DEVICE_PATH;

     }

 

-    if (BootType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT) {
-      // Create the specific device path node
-      Status = SupportedBootDevice->Support->CreateDevicePathNode (L"local FDT", &FdtLocalPathNode, NULL, NULL);
-      if (EFI_ERROR(Status) && Status != EFI_NOT_FOUND) { // EFI_NOT_FOUND is returned on empty input string, but we can boot without an initrd
-        Status = EFI_ABORTED;
-        goto EXIT;
-      }
-
-      if (FdtLocalPathNode != NULL) {
-        // Append the Device Path node to the select device path
-        FdtLocalPath = AppendDevicePathNode (SupportedBootDevice->DevicePathProtocol, (CONST EFI_DEVICE_PATH_PROTOCOL *)FdtLocalPathNode);
-      } else {
-        FdtLocalPath = NULL;
-      }
-    } else {
-      FdtLocalPath = NULL;
-    }
-
+    if (BootType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT) {

+      // Create the specific device path node

+      Status = SupportedBootDevice->Support->CreateDevicePathNode (L"local FDT", &FdtLocalPathNode, NULL, NULL);

+      if (EFI_ERROR(Status) || (FdtLocalPathNode == NULL)) {

+        Status = EFI_ABORTED;

+        goto EXIT;

+      }

+

+      if (FdtLocalPathNode != NULL) {

+        // Append the Device Path node to the select device path

+        FdtLocalPath = AppendDevicePathNode (SupportedBootDevice->DevicePathProtocol, (CONST EFI_DEVICE_PATH_PROTOCOL *)FdtLocalPathNode);

+      } else {

+        FdtLocalPath = NULL;

+      }

+    } else {

+      FdtLocalPath = NULL;

+    }

+

     CmdLineSize = AsciiStrSize (CmdLine);

     InitrdSize = GetDevicePathSize (InitrdPath);

-    FdtLocalSize = GetDevicePathSize (FdtLocalPath);
+    FdtLocalSize = GetDevicePathSize (FdtLocalPath);

+

+    BootArguments = (ARM_BDS_LOADER_ARGUMENTS*)AllocatePool (sizeof(ARM_BDS_LOADER_ARGUMENTS) + CmdLineSize + InitrdSize + FdtLocalSize);

 

-    BootArguments = (ARM_BDS_LOADER_ARGUMENTS*)AllocatePool (sizeof(ARM_BDS_LOADER_ARGUMENTS) + CmdLineSize + InitrdSize + FdtLocalSize);
-    

     BootArguments->LinuxArguments.CmdLineSize = CmdLineSize;

     BootArguments->LinuxArguments.InitrdSize = InitrdSize;

-    BootArguments->LinuxArguments.FdtLocalSize = FdtLocalSize;
+    BootArguments->LinuxArguments.FdtLocalSize = FdtLocalSize;

     CopyMem ((VOID*)(&BootArguments->LinuxArguments + 1), CmdLine, CmdLineSize);

     CopyMem ((VOID*)((UINTN)(&BootArguments->LinuxArguments + 1) + CmdLineSize), InitrdPath, InitrdSize);

-    CopyMem ((VOID*)((UINTN)(&BootArguments->LinuxArguments + 1) + CmdLineSize + InitrdSize), FdtLocalPath, FdtLocalSize);
+    CopyMem ((VOID*)((UINTN)(&BootArguments->LinuxArguments + 1) + CmdLineSize + InitrdSize), FdtLocalPath, FdtLocalSize);

   } else {

     BootArguments = NULL;

   }

@@ -235,7 +246,6 @@ BootMenuAddBootOption (
 FREE_DEVICE_PATH:

   FreePool (DevicePath);

 

-  

 EXIT:

   if (Status == EFI_ABORTED) {

     Print(L"\n");

@@ -288,7 +298,7 @@ BootMenuSelectBootOption (
       Print(L"\t- %s\n",DevicePathTxt);

       OptionalData = BdsLoadOption->OptionalData;

       LoaderType = (ARM_BDS_LOADER_TYPE)ReadUnaligned32 ((CONST UINT32*)&OptionalData->Header.LoaderType);

-      if ((LoaderType == BDS_LOADER_KERNEL_LINUX_ATAG) || (LoaderType == BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT) || (LoaderType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT)) {
+      if ((LoaderType == BDS_LOADER_KERNEL_LINUX_ATAG) || (LoaderType == BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT) || (LoaderType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT)) {

         Print (L"\t- Arguments: %a\n",&OptionalData->Arguments.LinuxArguments + 1);

       }

 

@@ -302,7 +312,7 @@ BootMenuSelectBootOption (
   if (BootOptionCount == 0) {

     if (StrCmp (InputStatement, DELETE_BOOT_ENTRY) == 0) {

       Print (L"Nothing to remove!\n");

-    }else if (StrCmp (InputStatement, UPDATE_BOOT_ENTRY) == 0) {

+    } else if (StrCmp (InputStatement, UPDATE_BOOT_ENTRY) == 0) {

       Print (L"Couldn't find valid boot entries\n");

     } else{

       Print (L"No supported Boot Entry.\n");

@@ -380,19 +390,19 @@ BootMenuUpdateBootOption (
   CHAR8                         CmdLine[BOOT_DEVICE_OPTION_MAX];

   EFI_DEVICE_PATH               *DevicePath;

   EFI_DEVICE_PATH               *TempInitrdPath;

-  EFI_DEVICE_PATH               *TempFdtLocalPath;
+  EFI_DEVICE_PATH               *TempFdtLocalPath;

   ARM_BDS_LOADER_TYPE           BootType;

   ARM_BDS_LOADER_OPTIONAL_DATA* OptionalData;

   ARM_BDS_LINUX_ARGUMENTS*      LinuxArguments;

-  EFI_DEVICE_PATH               *InitrdPathNode;

+  EFI_DEVICE_PATH               *InitrdPathNodes;

   EFI_DEVICE_PATH               *InitrdPath;

   UINTN                         InitrdSize;

-  EFI_DEVICE_PATH               *FdtLocalPathNode;
-  EFI_DEVICE_PATH               *FdtLocalPath;
-  UINTN                         FdtLocalSize;
+  EFI_DEVICE_PATH               *FdtLocalPathNode;

+  EFI_DEVICE_PATH               *FdtLocalPath;

+  UINTN                         FdtLocalSize;

   UINTN                         CmdLineSize;

   BOOLEAN                       InitrdSupport;

-  BOOLEAN                       FdtLocalSupport;
+  BOOLEAN                       FdtLocalSupport;

 

   Status = BootMenuSelectBootOption (BootOptionsList, UPDATE_BOOT_ENTRY, TRUE, &BootOptionEntry);

   if (EFI_ERROR(Status)) {

@@ -416,12 +426,63 @@ BootMenuUpdateBootOption (
   OptionalData = BootOption->OptionalData;

   BootType = (ARM_BDS_LOADER_TYPE)ReadUnaligned32 ((UINT32 *)(&OptionalData->Header.LoaderType));

 

-  if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) || (BootType == BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT) || (BootType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT)) {
+  if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) || (BootType == BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT) || (BootType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT)) {

     LinuxArguments = &OptionalData->Arguments.LinuxArguments;

 

     CmdLineSize = ReadUnaligned16 ((CONST UINT16*)&LinuxArguments->CmdLineSize);

 

     InitrdSize = ReadUnaligned16 ((CONST UINT16*)&LinuxArguments->InitrdSize);

+    FdtLocalSize = ReadUnaligned16 ((CONST UINT16*)&LinuxArguments->FdtLocalSize);

+

+    if (BootType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT) {

+      if (FdtLocalSize > 0) {

+        Print(L"Keep the local FDT: ");

+      } else {

+        Print(L"Add a local FDT: ");

+      }

+      Status = GetHIInputBoolean (&FdtLocalSupport);

+      if (EFI_ERROR(Status)) {

+        Status = EFI_ABORTED;

+        goto EXIT;

+      }

+      if (FdtLocalSupport && BootType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT) {

+        if (FdtLocalSize > 0) {

+          // Case we update the FDT local device path

+          Status = DeviceSupport->UpdateDevicePathNode ((EFI_DEVICE_PATH*)((UINTN)(LinuxArguments + 1) + CmdLineSize + InitrdSize), L"local FDT", &FdtLocalPath, NULL, NULL);

+          if (EFI_ERROR(Status) && Status != EFI_NOT_FOUND) {// EFI_NOT_FOUND is returned on empty input string

+            Status = EFI_ABORTED;

+            goto EXIT;

+          }

+          FdtLocalSize = GetDevicePathSize (FdtLocalPath);

+        } else {

+          // Case we create the FdtLocal device path

+

+          Status = DeviceSupport->CreateDevicePathNode (L"local FDT", &FdtLocalPathNode, NULL, NULL);

+          if (EFI_ERROR(Status) || (FdtLocalPathNode == NULL)) {

+            Status = EFI_ABORTED;

+            goto EXIT;

+          }

+

+          if (FdtLocalPathNode != NULL) {

+            // Duplicate Linux kernel Device Path

+            TempFdtLocalPath = DuplicateDevicePath (BootOption->FilePathList);

+            // Replace Linux kernel Node by EndNode

+            SetDevicePathEndNode (GetLastDevicePathNode (TempFdtLocalPath));

+            // Append the Device Path node to the select device path

+            FdtLocalPath = AppendDevicePathNode (TempFdtLocalPath, (CONST EFI_DEVICE_PATH_PROTOCOL *)FdtLocalPathNode);

+            FreePool (TempFdtLocalPath);

+            FdtLocalSize = GetDevicePathSize (FdtLocalPath);

+          } else {

+            FdtLocalPath = NULL;

+          }

+        }

+      } else {

+        FdtLocalSize = 0;

+      }

+    } else {

+      FdtLocalSupport = FALSE;

+    }

+

     if (InitrdSize > 0) {

       Print(L"Keep the initrd: ");

     } else {

@@ -445,20 +506,24 @@ BootMenuUpdateBootOption (
       } else {

         // Case we create the initrd device path

 

-        Status = DeviceSupport->CreateDevicePathNode (L"initrd", &InitrdPathNode, NULL, NULL);

+        Status = DeviceSupport->CreateDevicePathNode (L"initrd", &InitrdPathNodes, NULL, NULL);

         if (EFI_ERROR(Status) && Status != EFI_NOT_FOUND) { // EFI_NOT_FOUND is returned on empty input string, but we can boot without an initrd

           Status = EFI_ABORTED;

           goto EXIT;

         }

 

-        if (InitrdPathNode != NULL) {

+        if (InitrdPathNodes != NULL) {

           // Duplicate Linux kernel Device Path

           TempInitrdPath = DuplicateDevicePath (BootOption->FilePathList);

           // Replace Linux kernel Node by EndNode

           SetDevicePathEndNode (GetLastDevicePathNode (TempInitrdPath));

-          // Append the Device Path node to the select device path

-          InitrdPath = AppendDevicePathNode (TempInitrdPath, (CONST EFI_DEVICE_PATH_PROTOCOL *)InitrdPathNode);

+          // Append the Device Path to the selected device path

+          InitrdPath = AppendDevicePath (TempInitrdPath, (CONST EFI_DEVICE_PATH_PROTOCOL *)InitrdPathNodes);

           FreePool (TempInitrdPath);

+          if (InitrdPath == NULL) {

+            Status = EFI_OUT_OF_RESOURCES;

+            goto EXIT;

+          }

           InitrdSize = GetDevicePathSize (InitrdPath);

         } else {

           InitrdPath = NULL;

@@ -468,7 +533,7 @@ BootMenuUpdateBootOption (
       InitrdSize = 0;

     }

 

-    Print(L"Arguments to pass to the binary: "); 

+    Print(L"Arguments to pass to the binary: ");

     if (CmdLineSize > 0) {

       AsciiStrnCpy(CmdLine, (CONST CHAR8*)(LinuxArguments + 1), CmdLineSize);

     } else {

@@ -480,65 +545,15 @@ BootMenuUpdateBootOption (
       goto FREE_DEVICE_PATH;

     }

 

-    FdtLocalSize = ReadUnaligned16 ((CONST UINT16*)&LinuxArguments->FdtLocalSize);
-    if (BootType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT) {
-      if (FdtLocalSize > 0) {
-        Print(L"Keep the local FDT: ");
-      } else {
-        Print(L"Add a local FDT: ");
-      }
-      Status = GetHIInputBoolean (&FdtLocalSupport);
-      if (EFI_ERROR(Status)) {
-        Status = EFI_ABORTED;
-        goto EXIT;
-      }
-      if (FdtLocalSupport && BootType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT) {
-        if (FdtLocalSize > 0) {
-          // Case we update the FDT local device path
-          Status = DeviceSupport->UpdateDevicePathNode ((EFI_DEVICE_PATH*)((UINTN)(LinuxArguments + 1) + CmdLineSize + InitrdSize), L"local FDT", &FdtLocalPath, NULL, NULL);
-          if (EFI_ERROR(Status) && Status != EFI_NOT_FOUND) {// EFI_NOT_FOUND is returned on empty input string
-            Status = EFI_ABORTED;
-            goto EXIT;
-          }
-          FdtLocalSize = GetDevicePathSize (FdtLocalPath);
-        } else {
-          // Case we create the FdtLocal device path
-
-          Status = DeviceSupport->CreateDevicePathNode (L"local FDT", &FdtLocalPathNode, NULL, NULL);
-          if (EFI_ERROR(Status) && Status != EFI_NOT_FOUND) { // EFI_NOT_FOUND is returned on empty input string
-            Status = EFI_ABORTED;
-            goto EXIT;
-          }
-
-          if (FdtLocalPathNode != NULL) {
-            // Duplicate Linux kernel Device Path
-            TempFdtLocalPath = DuplicateDevicePath (BootOption->FilePathList);
-            // Replace Linux kernel Node by EndNode
-            SetDevicePathEndNode (GetLastDevicePathNode (TempFdtLocalPath));
-            // Append the Device Path node to the select device path
-            FdtLocalPath = AppendDevicePathNode (TempFdtLocalPath, (CONST EFI_DEVICE_PATH_PROTOCOL *)FdtLocalPathNode);
-            FreePool (TempFdtLocalPath);
-            FdtLocalSize = GetDevicePathSize (FdtLocalPath);
-          } else {
-            FdtLocalPath = NULL;
-          }
-        }
-      } else {
-        FdtLocalSize = 0;
-      }
-    } else {
-      FdtLocalSupport = FALSE;
-    }
-
     CmdLineSize = AsciiStrSize (CmdLine);

 

-    BootArguments = (ARM_BDS_LOADER_ARGUMENTS*)AllocatePool(sizeof(ARM_BDS_LOADER_ARGUMENTS) + CmdLineSize + InitrdSize + FdtLocalSize);
+    BootArguments = (ARM_BDS_LOADER_ARGUMENTS*)AllocatePool(sizeof(ARM_BDS_LOADER_ARGUMENTS) + CmdLineSize + InitrdSize + FdtLocalSize);

     BootArguments->LinuxArguments.CmdLineSize = CmdLineSize;

     BootArguments->LinuxArguments.InitrdSize = InitrdSize;

-    BootArguments->LinuxArguments.FdtLocalSize = FdtLocalSize;
+    BootArguments->LinuxArguments.FdtLocalSize = FdtLocalSize;

     CopyMem (&BootArguments->LinuxArguments + 1, CmdLine, CmdLineSize);

     CopyMem ((VOID*)((UINTN)(&BootArguments->LinuxArguments + 1) + CmdLineSize), InitrdPath, InitrdSize);

-    CopyMem ((VOID*)((UINTN)(&BootArguments->LinuxArguments + 1) + CmdLineSize + InitrdSize), FdtLocalPath, FdtLocalSize);
+    CopyMem ((VOID*)((UINTN)(&BootArguments->LinuxArguments + 1) + CmdLineSize + InitrdSize), FdtLocalPath, FdtLocalSize);

   } else {

     BootArguments = NULL;

   }

@@ -572,7 +587,7 @@ UpdateFdtPath (
   EFI_STATUS                Status;

   UINTN                     FdtDevicePathSize;

   BDS_SUPPORTED_DEVICE      *SupportedBootDevice;

-  EFI_DEVICE_PATH_PROTOCOL  *FdtDevicePathNode;

+  EFI_DEVICE_PATH_PROTOCOL  *FdtDevicePathNodes;

   EFI_DEVICE_PATH_PROTOCOL  *FdtDevicePath;

 

   Status = SelectBootDevice (&SupportedBootDevice);

@@ -582,20 +597,32 @@ UpdateFdtPath (
   }

 

   // Create the specific device path node

-  Status = SupportedBootDevice->Support->CreateDevicePathNode (L"FDT blob", &FdtDevicePathNode, NULL, NULL);

+  Status = SupportedBootDevice->Support->CreateDevicePathNode (L"FDT blob", &FdtDevicePathNodes, NULL, NULL);

   if (EFI_ERROR(Status)) {

     Status = EFI_ABORTED;

     goto EXIT;

   }

 

-  if (FdtDevicePathNode != NULL) {

+  if (FdtDevicePathNodes != NULL) {

     // Append the Device Path node to the select device path

-    FdtDevicePath = AppendDevicePathNode (SupportedBootDevice->DevicePathProtocol, FdtDevicePathNode);

+    FdtDevicePath = AppendDevicePath (SupportedBootDevice->DevicePathProtocol, FdtDevicePathNodes);

     FdtDevicePathSize = GetDevicePathSize (FdtDevicePath);

-    Status = gRT->SetVariable ((CHAR16*)L"Fdt", &gEfiGlobalVariableGuid, (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS ), FdtDevicePathSize, FdtDevicePath);

+    Status = gRT->SetVariable (

+                    (CHAR16*)L"Fdt",

+                    &gArmGlobalVariableGuid,

+                    EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,

+                    FdtDevicePathSize,

+                    FdtDevicePath

+                    );

     ASSERT_EFI_ERROR(Status);

   } else {

-    gRT->SetVariable ((CHAR16*)L"Fdt", &gEfiGlobalVariableGuid, (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS ), 0, NULL);

+    gRT->SetVariable (

+           (CHAR16*)L"Fdt",

+           &gArmGlobalVariableGuid,

+           EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,

+           0,

+           NULL

+           );

     ASSERT_EFI_ERROR(Status);

   }

 

@@ -717,65 +744,69 @@ BootMenuMain (
 

       Print(L"[%d] %s\n", OptionCount, BootOption->Description);

 

-      CHAR16*                           DevicePathTxt;
-      EFI_DEVICE_PATH_TO_TEXT_PROTOCOL* DevicePathToTextProtocol;
-      ARM_BDS_LOADER_OPTIONAL_DATA*     OptionalData;
-      UINTN                             CmdLineSize;
-      UINTN                             InitrdSize;
-      ARM_BDS_LOADER_TYPE               LoaderType;
-
-     Status = gBS->LocateProtocol (&gEfiDevicePathToTextProtocolGuid, NULL, (VOID **)&DevicePathToTextProtocol);
-     if (EFI_ERROR(Status)) {
-       // You must provide an implementation of DevicePathToTextProtocol in your firmware (eg: DevicePathDxe)
-       DEBUG((EFI_D_ERROR,"Error: Bds requires DevicePathToTextProtocol\n"));
-       return Status;
-     }
-     DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (BootOption->FilePathList, TRUE, TRUE);
-
-     Print(L"\t- %s\n",DevicePathTxt);
-
-      // If it is a supported BootEntry then print its details
-      if (IS_ARM_BDS_BOOTENTRY (BootOption)) {
-        OptionalData = BootOption->OptionalData;
-        LoaderType = (ARM_BDS_LOADER_TYPE)ReadUnaligned32 ((CONST UINT32*)&OptionalData->Header.LoaderType);
-        if ((LoaderType == BDS_LOADER_KERNEL_LINUX_ATAG) || (LoaderType == BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT) || (LoaderType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT)) {
-          if (ReadUnaligned16 (&OptionalData->Arguments.LinuxArguments.InitrdSize) > 0) {
-            CmdLineSize = ReadUnaligned16 (&OptionalData->Arguments.LinuxArguments.CmdLineSize);
-            DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (
-                GetAlignedDevicePath ((EFI_DEVICE_PATH*)((UINTN)(&OptionalData->Arguments.LinuxArguments + 1) + CmdLineSize)), TRUE, TRUE);
-            Print(L"\t- Initrd: %s\n", DevicePathTxt);
+      //DEBUG_CODE_BEGIN();

+        CHAR16*                           DevicePathTxt;

+        EFI_DEVICE_PATH_TO_TEXT_PROTOCOL* DevicePathToTextProtocol;

+        ARM_BDS_LOADER_OPTIONAL_DATA*     OptionalData;

+        UINTN                             CmdLineSize;

+        UINTN                             InitrdSize;

+        ARM_BDS_LOADER_TYPE               LoaderType;

+

+        Status = gBS->LocateProtocol (&gEfiDevicePathToTextProtocolGuid, NULL, (VOID **)&DevicePathToTextProtocol);

+        if (EFI_ERROR(Status)) {

+          // You must provide an implementation of DevicePathToTextProtocol in your firmware (eg: DevicePathDxe)

+          DEBUG((EFI_D_ERROR,"Error: Bds requires DevicePathToTextProtocol\n"));

+          return Status;

+        }

+        DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (BootOption->FilePathList, TRUE, TRUE);

+

+        Print(L"\t- %s\n",DevicePathTxt);

+

+        // If it is a supported BootEntry then print its details

+        if (IS_ARM_BDS_BOOTENTRY (BootOption)) {

+          OptionalData = BootOption->OptionalData;

+          LoaderType = (ARM_BDS_LOADER_TYPE)ReadUnaligned32 ((CONST UINT32*)&OptionalData->Header.LoaderType);

+          if ((LoaderType == BDS_LOADER_KERNEL_LINUX_ATAG) || (LoaderType == BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT) || (LoaderType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT)) {

+            if (ReadUnaligned16 (&OptionalData->Arguments.LinuxArguments.InitrdSize) > 0) {

+              CmdLineSize = ReadUnaligned16 (&OptionalData->Arguments.LinuxArguments.CmdLineSize);

+              DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (

+                  GetAlignedDevicePath ((EFI_DEVICE_PATH*)((UINTN)(&OptionalData->Arguments.LinuxArguments + 1) + CmdLineSize)), TRUE, TRUE);

+              Print(L"\t- Initrd: %s\n", DevicePathTxt);

+            }

+            Print(L"\t- Arguments: %a\n", (&OptionalData->Arguments.LinuxArguments + 1));

+          }

+

+          switch (LoaderType) {

+            case BDS_LOADER_EFI_APPLICATION:

+              Print(L"\t- LoaderType: EFI Application\n");

+              break;

+

+            case BDS_LOADER_KERNEL_LINUX_ATAG:

+              Print(L"\t- LoaderType: Linux kernel with ATAG support\n");

+              break;

+

+            case BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT:

+              Print(L"\t- LoaderType: Linux kernel with global FDT support\n");

+              break;

+            case BDS_LOADER_KERNEL_LINUX_LOCAL_FDT:

+              if (ReadUnaligned16 (&OptionalData->Arguments.LinuxArguments.FdtLocalSize) > 0) {

+                CmdLineSize = ReadUnaligned16 (&OptionalData->Arguments.LinuxArguments.CmdLineSize);

+                InitrdSize  = ReadUnaligned16 (&OptionalData->Arguments.LinuxArguments.InitrdSize);

+                DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (

+                    GetAlignedDevicePath ((EFI_DEVICE_PATH*)((UINTN)(&OptionalData->Arguments.LinuxArguments + 1) + CmdLineSize + InitrdSize)), TRUE, TRUE);

+                Print(L"\t- FDT: %s\n", DevicePathTxt);

+              } else {

+                Print(L"\t- FDT: error, local FDT not specified, using global FDT\n");

+              }

+              Print(L"\t- LoaderType: Linux kernel with Local FDT\n");

+              break;

+            default:

+              Print(L"\t- LoaderType: Not recognized (%d)\n", LoaderType);

+              break;

           }

-          Print(L"\t- Arguments: %a\n", (&OptionalData->Arguments.LinuxArguments + 1));
         }

-
-        switch (LoaderType) {
-          case BDS_LOADER_EFI_APPLICATION:
-            Print(L"\t- LoaderType: EFI Application\n");
-            break;
-          case BDS_LOADER_KERNEL_LINUX_ATAG:
-            Print(L"\t- LoaderType: Linux kernel with ATAG data\n");
-            break;
-          case BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT:
-            Print(L"\t- LoaderType: Linux kernel with global FDT\n");
-            break;
-          case BDS_LOADER_KERNEL_LINUX_LOCAL_FDT:
-            if (ReadUnaligned16 (&OptionalData->Arguments.LinuxArguments.FdtLocalSize) > 0) {
-              CmdLineSize = ReadUnaligned16 (&OptionalData->Arguments.LinuxArguments.CmdLineSize);
-              InitrdSize  = ReadUnaligned16 (&OptionalData->Arguments.LinuxArguments.InitrdSize);
-              DevicePathTxt = DevicePathToTextProtocol->ConvertDevicePathToText (
-                  GetAlignedDevicePath ((EFI_DEVICE_PATH*)((UINTN)(&OptionalData->Arguments.LinuxArguments + 1) + CmdLineSize + InitrdSize)), TRUE, TRUE);
-              Print(L"\t- FDT: %s\n", DevicePathTxt);
-            } else {
-              Print(L"\t- FDT: error, local FDT not specified, using global FDT\n");
-            }
-            Print(L"\t- LoaderType: Linux kernel with Local FDT\n");
-            break;
-          default:
-            Print(L"unknown\n");
-            break;
-        }
-      }
-     FreePool(DevicePathTxt);
+        FreePool(DevicePathTxt);

+      //DEBUG_CODE_END();

 

       OptionCount++;

     }

@@ -796,7 +827,7 @@ BootMenuMain (
 
         // Get the FDT device path
         FdtDevicePathSize = GetDevicePathSize (DefaultFdtDevicePath);
-        Status = GetEnvironmentVariable ((CHAR16 *)L"Fdt", DefaultFdtDevicePath, &FdtDevicePathSize, (VOID **)&FdtDevicePath);
+        Status = GetEnvironmentVariable ((CHAR16 *)L"Fdt", &gArmGlobalVariableGuid, DefaultFdtDevicePath, &FdtDevicePathSize, (VOID **)&FdtDevicePath);
 
         // Convert FdtDevicePath to text
         if (EFI_ERROR(Status)) {
diff --git a/ArmPlatformPkg/Bds/BootOption.c b/ArmPlatformPkg/Bds/BootOption.c
index 364ad408..0ecccd31 100644
--- a/ArmPlatformPkg/Bds/BootOption.c
+++ b/ArmPlatformPkg/Bds/BootOption.c
@@ -1,6 +1,6 @@
 /** @file

 *

-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

 *

 *  This program and the accompanying materials

 *  are licensed and made available under the terms and conditions of the BSD License

@@ -12,6 +12,7 @@
 *

 **/

 

+#include <Guid/ArmGlobalVariableHob.h>

 #include "BdsInternal.h"

 

 extern EFI_HANDLE mImageHandle;

@@ -32,7 +33,7 @@ BootOptionStart (
   UINTN                                 CmdLineSize;

   UINTN                                 InitrdSize;

   EFI_DEVICE_PATH*                      Initrd;

-  UINTN                                 FdtLocalSize;
+  UINTN                                 FdtLocalSize;

   UINT16                                LoadOptionIndexSize;

 

   if (IS_ARM_BDS_BOOTENTRY (BootOption)) {

@@ -59,7 +60,7 @@ BootOptionStart (
       Status = BdsBootLinuxAtag (BootOption->FilePathList,

                                  Initrd, // Initrd

                                  (CHAR8*)(LinuxArguments + 1)); // CmdLine

-    } else if ((LoaderType == BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT) || (LoaderType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT)) {
+    } else if ((LoaderType == BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT) || (LoaderType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT)) {

       LinuxArguments = &(OptionalData->Arguments.LinuxArguments);

       CmdLineSize = ReadUnaligned16 ((CONST UINT16*)&LinuxArguments->CmdLineSize);

       InitrdSize = ReadUnaligned16 ((CONST UINT16*)&LinuxArguments->InitrdSize);

@@ -70,26 +71,26 @@ BootOptionStart (
         Initrd = NULL;

       }

 

-      if (LoaderType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT) {
-        FdtLocalSize = ReadUnaligned16 ((CONST UINT16*)&LinuxArguments->FdtLocalSize);
-
-        if (FdtLocalSize > 0) {
-          FdtDevicePath = GetAlignedDevicePath ((EFI_DEVICE_PATH*)((UINTN)(LinuxArguments + 1) + CmdLineSize + InitrdSize));
-        } else {
-          FdtDevicePath = NULL;
-        }
-      } else  {
-        // Get the default FDT device path
-        Status = gBS->LocateProtocol (&gEfiDevicePathFromTextProtocolGuid, NULL, (VOID **)&EfiDevicePathFromTextProtocol);
-        ASSERT_EFI_ERROR(Status);
-        DefaultFdtDevicePath = EfiDevicePathFromTextProtocol->ConvertTextToDevicePath ((CHAR16*)PcdGetPtr(PcdFdtDevicePath));
-
-        // Get the FDT device path
-        FdtDevicePathSize = GetDevicePathSize (DefaultFdtDevicePath);
-        Status = GetEnvironmentVariable ((CHAR16 *)L"Fdt", DefaultFdtDevicePath, &FdtDevicePathSize, (VOID **)&FdtDevicePath);
-        ASSERT_EFI_ERROR(Status);
-      }
+      if (LoaderType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT) {

+        FdtLocalSize = ReadUnaligned16 ((CONST UINT16*)&LinuxArguments->FdtLocalSize);

 

+        if (FdtLocalSize > 0) {

+          FdtDevicePath = GetAlignedDevicePath ((EFI_DEVICE_PATH*)((UINTN)(LinuxArguments + 1) + CmdLineSize + InitrdSize));

+        } else {

+          FdtDevicePath = NULL;

+        }

+      } else  {

+        // Get the default FDT device path

+        Status = gBS->LocateProtocol (&gEfiDevicePathFromTextProtocolGuid, NULL, (VOID **)&EfiDevicePathFromTextProtocol);

+        ASSERT_EFI_ERROR(Status);

+        DefaultFdtDevicePath = EfiDevicePathFromTextProtocol->ConvertTextToDevicePath ((CHAR16*)PcdGetPtr(PcdFdtDevicePath));

+

+        // Get the FDT device path

+        FdtDevicePathSize = GetDevicePathSize (DefaultFdtDevicePath);

+        Status = GetEnvironmentVariable ((CHAR16 *)L"Fdt", &gArmGlobalVariableGuid,

+                   DefaultFdtDevicePath, &FdtDevicePathSize, (VOID **)&FdtDevicePath);

+        ASSERT_EFI_ERROR(Status);

+      }

       Status = BdsBootLinuxFdt (BootOption->FilePathList,

                                 Initrd, // Initrd

                                 (CHAR8*)(LinuxArguments + 1),

@@ -131,7 +132,7 @@ BootOptionList (
   InitializeListHead (BootOptionList);

 

   // Get the Boot Option Order from the environment variable

-  Status = GetEnvironmentVariable (L"BootOrder", NULL, &BootOrderSize, (VOID**)&BootOrder);

+  Status = GetGlobalEnvironmentVariable (L"BootOrder", NULL, &BootOrderSize, (VOID**)&BootOrder);

   if (EFI_ERROR(Status)) {

     return Status;

   }

@@ -168,7 +169,7 @@ BootOptionSetFields (
   UINT16                        FilePathListLength;

   UINT8*                        EfiLoadOptionPtr;

   UINT8*                        InitrdPathListPtr;

-  UINT8*                        FdtLocalPathListPtr;
+  UINT8*                        FdtLocalPathListPtr;

   UINTN                         OptionalDataSize;

   ARM_BDS_LINUX_ARGUMENTS*      DestLinuxArguments;

   ARM_BDS_LINUX_ARGUMENTS*      SrcLinuxArguments;

@@ -180,8 +181,8 @@ BootOptionSetFields (
 

   BootDescriptionSize = StrSize (BootDescription);

   BootOptionalDataSize = sizeof(ARM_BDS_LOADER_OPTIONAL_DATA_HEADER);

-  if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) || (BootType == BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT) || (BootType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT)) {
-    BootOptionalDataSize += sizeof(ARM_BDS_LINUX_ARGUMENTS) + BootArguments->LinuxArguments.CmdLineSize + BootArguments->LinuxArguments.InitrdSize + BootArguments->LinuxArguments.FdtLocalSize;
+  if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) || (BootType == BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT) || (BootType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT)) {

+    BootOptionalDataSize += sizeof(ARM_BDS_LINUX_ARGUMENTS) + BootArguments->LinuxArguments.CmdLineSize + BootArguments->LinuxArguments.InitrdSize + BootArguments->LinuxArguments.FdtLocalSize;

   }

 

   // Compute the size of the FilePath list

@@ -223,13 +224,13 @@ BootOptionSetFields (
 

   OptionalDataSize = sizeof(ARM_BDS_LOADER_OPTIONAL_DATA_HEADER);

 

-  if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) || (BootType == BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT) || (BootType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT)) {
+  if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) || (BootType == BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT) || (BootType == BDS_LOADER_KERNEL_LINUX_LOCAL_FDT)) {

     SrcLinuxArguments = &(BootArguments->LinuxArguments);

     DestLinuxArguments = &((ARM_BDS_LOADER_OPTIONAL_DATA*)EfiLoadOptionPtr)->Arguments.LinuxArguments;

 

     WriteUnaligned16 ((UINT16 *)&(DestLinuxArguments->CmdLineSize), SrcLinuxArguments->CmdLineSize);

     WriteUnaligned16 ((UINT16 *)&(DestLinuxArguments->InitrdSize), SrcLinuxArguments->InitrdSize);

-    WriteUnaligned16 ((UINT16 *)&(DestLinuxArguments->FdtLocalSize), SrcLinuxArguments->FdtLocalSize);
+    WriteUnaligned16 ((UINT16 *)&(DestLinuxArguments->FdtLocalSize), SrcLinuxArguments->FdtLocalSize);

     OptionalDataSize += sizeof (ARM_BDS_LINUX_ARGUMENTS);

 

     if (SrcLinuxArguments->CmdLineSize > 0) {

@@ -241,11 +242,11 @@ BootOptionSetFields (
       InitrdPathListPtr = (UINT8*)((UINTN)(DestLinuxArguments + 1) + SrcLinuxArguments->CmdLineSize);

       CopyMem (InitrdPathListPtr, (VOID*)((UINTN)(SrcLinuxArguments + 1) + SrcLinuxArguments->CmdLineSize), SrcLinuxArguments->InitrdSize);

     }

-
-    if (SrcLinuxArguments->FdtLocalSize > 0) {
-      FdtLocalPathListPtr = (UINT8*)((UINTN)(DestLinuxArguments + 1) + SrcLinuxArguments->CmdLineSize + SrcLinuxArguments->InitrdSize);
-      CopyMem (FdtLocalPathListPtr, (VOID*)((UINTN)(SrcLinuxArguments + 1) + SrcLinuxArguments->CmdLineSize + SrcLinuxArguments->InitrdSize), SrcLinuxArguments->FdtLocalSize);
-    }
+

+    if (SrcLinuxArguments->FdtLocalSize > 0) {

+      FdtLocalPathListPtr = (UINT8*)((UINTN)(DestLinuxArguments + 1) + SrcLinuxArguments->CmdLineSize + SrcLinuxArguments->InitrdSize);

+      CopyMem (FdtLocalPathListPtr, (VOID*)((UINTN)(SrcLinuxArguments + 1) + SrcLinuxArguments->CmdLineSize + SrcLinuxArguments->InitrdSize), SrcLinuxArguments->FdtLocalSize);

+    }

   }

   BootOption->OptionalDataSize = OptionalDataSize;

 

@@ -304,7 +305,7 @@ BootOptionCreate (
       );

 

   // Add the new Boot Index to the list

-  Status = GetEnvironmentVariable (L"BootOrder", NULL, &BootOrderSize, (VOID**)&BootOrder);

+  Status = GetGlobalEnvironmentVariable (L"BootOrder", NULL, &BootOrderSize, (VOID**)&BootOrder);

   if (!EFI_ERROR(Status)) {

     BootOrder = ReallocatePool (BootOrderSize, BootOrderSize + sizeof(UINT16), BootOrder);

     // Add the new index at the end

@@ -376,7 +377,7 @@ BootOptionDelete (
   EFI_STATUS    Status;

 

   // Remove the entry from the BootOrder environment variable

-  Status = GetEnvironmentVariable (L"BootOrder", NULL, &BootOrderSize, (VOID**)&BootOrder);

+  Status = GetGlobalEnvironmentVariable (L"BootOrder", NULL, &BootOrderSize, (VOID**)&BootOrder);

   if (!EFI_ERROR(Status)) {

     BootOrderCount = BootOrderSize / sizeof(UINT16);

 

@@ -385,7 +386,11 @@ BootOptionDelete (
       if (BootOrder[Index] == BootOption->LoadOptionIndex) {

         // If it the last entry we do not need to rearrange the BootOrder list

         if (Index + 1 != BootOrderCount) {

-          CopyMem (&BootOrder[Index],&BootOrder[Index+1], BootOrderCount - (Index + 1));

+          CopyMem (

+            &BootOrder[Index],

+            &BootOrder[Index + 1],

+            (BootOrderCount - (Index + 1)) * sizeof(UINT16)

+            );

         }

         break;

       }

diff --git a/ArmPlatformPkg/Bds/BootOptionSupport.c b/ArmPlatformPkg/Bds/BootOptionSupport.c
index 897786f5..cf69175d 100644
--- a/ArmPlatformPkg/Bds/BootOptionSupport.c
+++ b/ArmPlatformPkg/Bds/BootOptionSupport.c
@@ -25,6 +25,7 @@
 #include <Guid/FileSystemInfo.h>

 

 #define IS_DEVICE_PATH_NODE(node,type,subtype) (((node)->Type == (type)) && ((node)->SubType == (subtype)))

+#define LOCAL_FDT_RESPONSE_LEN 2	// 1 character, plus carriage return

 

 EFI_STATUS

 BdsLoadOptionFileSystemList (

@@ -34,7 +35,7 @@ BdsLoadOptionFileSystemList (
 EFI_STATUS

 BdsLoadOptionFileSystemCreateDevicePath (

   IN CHAR16*                    FileName,

-  OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePathNode,

+  OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePathNodes,

   OUT ARM_BDS_LOADER_TYPE       *BootType,

   OUT UINT32                    *Attributes

   );

@@ -61,7 +62,7 @@ BdsLoadOptionMemMapList (
 EFI_STATUS

 BdsLoadOptionMemMapCreateDevicePath (

   IN CHAR16*                    FileName,

-  OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePathNode,

+  OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePathNodes,

   OUT ARM_BDS_LOADER_TYPE       *BootType,

   OUT UINT32                    *Attributes

   );

@@ -88,7 +89,7 @@ BdsLoadOptionPxeList (
 EFI_STATUS

 BdsLoadOptionPxeCreateDevicePath (

   IN CHAR16*                    FileName,

-  OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePathNode,

+  OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePathNodes,

   OUT ARM_BDS_LOADER_TYPE       *BootType,

   OUT UINT32                    *Attributes

   );

@@ -115,7 +116,7 @@ BdsLoadOptionTftpList (
 EFI_STATUS

 BdsLoadOptionTftpCreateDevicePath (

   IN CHAR16*                    FileName,

-  OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePathNode,

+  OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePathNodes,

   OUT ARM_BDS_LOADER_TYPE       *BootType,

   OUT UINT32                    *Attributes

   );

@@ -233,7 +234,7 @@ BootDeviceGetType (
   EFI_STATUS Status;

   BOOLEAN IsEfiApp;

   BOOLEAN IsBootLoader;

-  CHAR16  FDTType[16];
+  CHAR16  FDTType[ LOCAL_FDT_RESPONSE_LEN ];

 

   if (FileName == NULL) {

     Print(L"Is an EFI Application? ");

@@ -258,20 +259,20 @@ BootDeviceGetType (
     }

     *BootType = BDS_LOADER_EFI_APPLICATION;

   } else {

-    Print(L"Boot Type: [a] ATAGS, [g] Global FDT or [l] Local FDT? [a/g/l] ");
-    Status = GetHIInputStr (FDTType, 16);
+    Print(L"Boot Type: [a] ATAGS, [g] Global FDT or [l] Local FDT? [a/g/l] ");

+    Status = GetHIInputStr (FDTType, LOCAL_FDT_RESPONSE_LEN );

     if (EFI_ERROR(Status)) {

       return EFI_ABORTED;

     }

-	if (StrCmp(FDTType, L"g") == 0) {
-      *BootType = BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT;
-	} else if (StrCmp(FDTType, L"l") == 0) {
-      *BootType = BDS_LOADER_KERNEL_LINUX_LOCAL_FDT;
-	} else if (StrCmp(FDTType, L"a") == 0) {
+    if (StrCmp(FDTType, L"g") == 0) {

+      *BootType = BDS_LOADER_KERNEL_LINUX_GLOBAL_FDT;

+    } else if (StrCmp(FDTType, L"l") == 0) {

+      *BootType = BDS_LOADER_KERNEL_LINUX_LOCAL_FDT;

+    } else if (StrCmp(FDTType, L"a") == 0) {

       *BootType = BDS_LOADER_KERNEL_LINUX_ATAG;

-	} else {
-		return EFI_ABORTED;
-	}
+    } else {

+      return EFI_ABORTED;

+    }

   }

 

   return EFI_SUCCESS;

@@ -336,7 +337,7 @@ BdsLoadOptionFileSystemList (
 EFI_STATUS

 BdsLoadOptionFileSystemCreateDevicePath (

   IN CHAR16*                    FileName,

-  OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePathNode,

+  OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePathNodes,

   OUT ARM_BDS_LOADER_TYPE       *BootType,

   OUT UINT32                    *Attributes

   )

@@ -354,16 +355,17 @@ BdsLoadOptionFileSystemCreateDevicePath (
 

   BootFilePathSize = StrSize (BootFilePath);

   if (BootFilePathSize == 2) {

-    *DevicePathNode = NULL;

+    *DevicePathNodes = NULL;

     return EFI_NOT_FOUND;

   }

 

   // Create the FilePath Device Path node

-  FilePathDevicePath = (FILEPATH_DEVICE_PATH*)AllocatePool(SIZE_OF_FILEPATH_DEVICE_PATH + BootFilePathSize);

+  FilePathDevicePath = (FILEPATH_DEVICE_PATH*)AllocatePool(SIZE_OF_FILEPATH_DEVICE_PATH + BootFilePathSize + END_DEVICE_PATH_LENGTH);

   FilePathDevicePath->Header.Type = MEDIA_DEVICE_PATH;

   FilePathDevicePath->Header.SubType = MEDIA_FILEPATH_DP;

   SetDevicePathNodeLength (FilePathDevicePath, SIZE_OF_FILEPATH_DEVICE_PATH + BootFilePathSize);

   CopyMem (FilePathDevicePath->PathName, BootFilePath, BootFilePathSize);

+  SetDevicePathEndNode ((VOID*)((UINTN)FilePathDevicePath + SIZE_OF_FILEPATH_DEVICE_PATH + BootFilePathSize));

 

   if (BootType != NULL || Attributes != NULL) {

     Status = BootDeviceGetType (FilePathDevicePath->PathName, BootType, Attributes);

@@ -372,7 +374,7 @@ BdsLoadOptionFileSystemCreateDevicePath (
   if (EFI_ERROR(Status)) {

     FreePool (FilePathDevicePath);

   } else {

-    *DevicePathNode = (EFI_DEVICE_PATH_PROTOCOL*)FilePathDevicePath;

+    *DevicePathNodes = (EFI_DEVICE_PATH_PROTOCOL*)FilePathDevicePath;

   }

 

   return Status;

@@ -537,7 +539,7 @@ BdsLoadOptionMemMapList (
 EFI_STATUS

 BdsLoadOptionMemMapCreateDevicePath (

   IN CHAR16*                    FileName,

-  OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePathNode,

+  OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePathNodes,

   OUT ARM_BDS_LOADER_TYPE       *BootType,

   OUT UINT32                    *Attributes

   )

@@ -578,7 +580,7 @@ BdsLoadOptionMemMapCreateDevicePath (
   if (EFI_ERROR(Status)) {

     FreePool (MemMapDevicePath);

   } else {

-    *DevicePathNode = (EFI_DEVICE_PATH_PROTOCOL*)MemMapDevicePath;

+    *DevicePathNodes = (EFI_DEVICE_PATH_PROTOCOL*)MemMapDevicePath;

   }

 

   return Status;

@@ -695,13 +697,13 @@ BdsLoadOptionPxeList (
 EFI_STATUS

 BdsLoadOptionPxeCreateDevicePath (

   IN CHAR16*                    FileName,

-  OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePathNode,

+  OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePathNodes,

   OUT ARM_BDS_LOADER_TYPE       *BootType,

   OUT UINT32                    *Attributes

   )

 {

-  *DevicePathNode = (EFI_DEVICE_PATH_PROTOCOL *) AllocatePool (END_DEVICE_PATH_LENGTH);

-  SetDevicePathEndNode (*DevicePathNode);

+  *DevicePathNodes = (EFI_DEVICE_PATH_PROTOCOL *) AllocatePool (END_DEVICE_PATH_LENGTH);

+  SetDevicePathEndNode (*DevicePathNodes);

   *BootType = BDS_LOADER_EFI_APPLICATION;

   return EFI_SUCCESS;

 }

@@ -797,7 +799,7 @@ BdsLoadOptionTftpList (
 EFI_STATUS

 BdsLoadOptionTftpCreateDevicePath (

   IN CHAR16*                    FileName,

-  OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePathNode,

+  OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePathNodes,

   OUT ARM_BDS_LOADER_TYPE       *BootType,

   OUT UINT32                    *Attributes

   )

@@ -843,7 +845,7 @@ BdsLoadOptionTftpCreateDevicePath (
   }

 

   // Allocate the memory for the IPv4 + File Path Device Path Nodes

-  IPv4DevicePathNode = (IPv4_DEVICE_PATH*)AllocatePool(sizeof(IPv4_DEVICE_PATH) + SIZE_OF_FILEPATH_DEVICE_PATH + BootFilePathSize);

+  IPv4DevicePathNode = (IPv4_DEVICE_PATH*)AllocatePool(sizeof(IPv4_DEVICE_PATH) + SIZE_OF_FILEPATH_DEVICE_PATH + BootFilePathSize + END_DEVICE_PATH_LENGTH);

 

   // Create the IPv4 Device Path

   IPv4DevicePathNode->Header.Type    = MESSAGING_DEVICE_PATH;

@@ -863,6 +865,9 @@ BdsLoadOptionTftpCreateDevicePath (
   SetDevicePathNodeLength (FilePathDevicePath, SIZE_OF_FILEPATH_DEVICE_PATH + BootFilePathSize);

   CopyMem (FilePathDevicePath->PathName, BootFilePath, BootFilePathSize);

 

+  // Set the End Device Path Node

+  SetDevicePathEndNode ((VOID*)((UINTN)FilePathDevicePath + SIZE_OF_FILEPATH_DEVICE_PATH + BootFilePathSize));

+

   if (BootType != NULL || Attributes != NULL) {

     Status = BootDeviceGetType (NULL, BootType, Attributes);

   }

@@ -870,7 +875,7 @@ BdsLoadOptionTftpCreateDevicePath (
   if (EFI_ERROR(Status)) {

     FreePool (IPv4DevicePathNode);

   } else {

-    *DevicePathNode = (EFI_DEVICE_PATH_PROTOCOL*)IPv4DevicePathNode;

+    *DevicePathNodes = (EFI_DEVICE_PATH_PROTOCOL*)IPv4DevicePathNode;

   }

 

   return Status;

diff --git a/ArmPlatformPkg/Drivers/LcdGraphicsOutputDxe/LcdGraphicsOutputBlt.c b/ArmPlatformPkg/Drivers/LcdGraphicsOutputDxe/LcdGraphicsOutputBlt.c
index 3c267df4..ef85e712 100644
--- a/ArmPlatformPkg/Drivers/LcdGraphicsOutputDxe/LcdGraphicsOutputBlt.c
+++ b/ArmPlatformPkg/Drivers/LcdGraphicsOutputDxe/LcdGraphicsOutputBlt.c
@@ -1,882 +1,882 @@
-/** @file
-
- Copyright (c) 2011, ARM Ltd. All rights reserved.<BR>
- This program and the accompanying materials
- are licensed and made available under the terms and conditions of the BSD License
- which accompanies this distribution.  The full text of the license may be found at
- http://opensource.org/licenses/bsd-license.php
-
- THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
- WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
- **/
-
-#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 = EFI_SUCCESS;
-  UINTN         SourceLine;
-  UINTN         DestinationLine;
-  UINTN         WidthInBytes;
-  UINTN         LineCount;
-  INTN          Step;
-  VOID          *SourceAddr;
-  VOID          *DestinationAddr;
-
-  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 LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_16_555:
-  case LCD_BITS_PER_PIXEL_16_565:
-  case LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_8:
-  case LCD_BITS_PER_PIXEL_4:
-  case LCD_BITS_PER_PIXEL_2:
-  case LCD_BITS_PER_PIXEL_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 = EFI_SUCCESS;
-
-  UINT32 *PixelBuffer32bit;
-  UINT32 *SourcePixel32bit;
-  UINT32 *DestinationPixel32bit;
-
-  UINT16 *PixelBuffer16bit;
-  UINT16 *SourcePixel16bit;
-  UINT16 *DestinationPixel16bit;
-
-  UINT32          SourcePixelY;
-  UINT32          DestinationPixelY;
-  UINTN           SizeIn32Bits;
-  UINTN           SizeIn16Bits;
-
-  switch (BitsPerPixel) {
-
-  case LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_16_555:
-  case LCD_BITS_PER_PIXEL_16_565:
-  case LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_8:
-  case LCD_BITS_PER_PIXEL_4:
-  case LCD_BITS_PER_PIXEL_2:
-  case LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_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
-      SetMemN( DestinationAddr, WidthInBytes, *((UINTN *)EfiSourcePixel));
-    }
-    break;
-
-  case LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_8:
-  case LCD_BITS_PER_PIXEL_4:
-  case LCD_BITS_PER_PIXEL_2:
-  case LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_8:
-  case LCD_BITS_PER_PIXEL_4:
-  case LCD_BITS_PER_PIXEL_2:
-  case LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_8:
-  case LCD_BITS_PER_PIXEL_4:
-  case LCD_BITS_PER_PIXEL_2:
-  case LCD_BITS_PER_PIXEL_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;
-
-  DEBUG((DEBUG_INFO, "LcdGraphicsBlt (BltOperation:%d,DestX:%d,DestY:%d,Width:%d,Height:%d) res(%d,%d)\n",
-      BltOperation,DestinationX,DestinationY,Width,Height,HorizontalResolution,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;
-}
+/** @file

+

+ Copyright (c) 2011-2013, ARM Ltd. All rights reserved.<BR>

+ This program and the accompanying materials

+ are licensed and made available under the terms and conditions of the BSD License

+ which accompanies this distribution.  The full text of the license may be found at

+ http://opensource.org/licenses/bsd-license.php

+

+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+ **/

+

+#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 = EFI_SUCCESS;

+  UINTN         SourceLine;

+  UINTN         DestinationLine;

+  UINTN         WidthInBytes;

+  UINTN         LineCount;

+  INTN          Step;

+  VOID          *SourceAddr;

+  VOID          *DestinationAddr;

+

+  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 LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_16_555:

+  case LCD_BITS_PER_PIXEL_16_565:

+  case LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_8:

+  case LCD_BITS_PER_PIXEL_4:

+  case LCD_BITS_PER_PIXEL_2:

+  case LCD_BITS_PER_PIXEL_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 = EFI_SUCCESS;

+

+  UINT32 *PixelBuffer32bit;

+  UINT32 *SourcePixel32bit;

+  UINT32 *DestinationPixel32bit;

+

+  UINT16 *PixelBuffer16bit;

+  UINT16 *SourcePixel16bit;

+  UINT16 *DestinationPixel16bit;

+

+  UINT32          SourcePixelY;

+  UINT32          DestinationPixelY;

+  UINTN           SizeIn32Bits;

+  UINTN           SizeIn16Bits;

+

+  switch (BitsPerPixel) {

+

+  case LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_16_555:

+  case LCD_BITS_PER_PIXEL_16_565:

+  case LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_8:

+  case LCD_BITS_PER_PIXEL_4:

+  case LCD_BITS_PER_PIXEL_2:

+  case LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_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

+      SetMemN( DestinationAddr, WidthInBytes, *((UINT32 *)EfiSourcePixel));

+    }

+    break;

+

+  case LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_8:

+  case LCD_BITS_PER_PIXEL_4:

+  case LCD_BITS_PER_PIXEL_2:

+  case LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_8:

+  case LCD_BITS_PER_PIXEL_4:

+  case LCD_BITS_PER_PIXEL_2:

+  case LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_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 LCD_BITS_PER_PIXEL_8:

+  case LCD_BITS_PER_PIXEL_4:

+  case LCD_BITS_PER_PIXEL_2:

+  case LCD_BITS_PER_PIXEL_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;

+

+  DEBUG((DEBUG_INFO, "LcdGraphicsBlt (BltOperation:%d,DestX:%d,DestY:%d,Width:%d,Height:%d) res(%d,%d)\n",

+      BltOperation,DestinationX,DestinationY,Width,Height,HorizontalResolution,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;

+}

diff --git a/ArmPlatformPkg/Drivers/LcdGraphicsOutputDxe/LcdGraphicsOutputDxe.c b/ArmPlatformPkg/Drivers/LcdGraphicsOutputDxe/LcdGraphicsOutputDxe.c
index 229d2a6a..34a56b3d 100644
--- a/ArmPlatformPkg/Drivers/LcdGraphicsOutputDxe/LcdGraphicsOutputDxe.c
+++ b/ArmPlatformPkg/Drivers/LcdGraphicsOutputDxe/LcdGraphicsOutputDxe.c
@@ -1,376 +1,376 @@
-/** @file
-
- Copyright (c) 2011, ARM Ltd. All rights reserved.<BR>
- This program and the accompanying materials
- are licensed and made available under the terms and conditions of the BSD License
- which accompanies this distribution.  The full text of the license may be found at
- http://opensource.org/licenses/bsd-license.php
-
- THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
- WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
- **/
-
-#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"
-
-/**********************************************************************
- *
- *  This file implements the Graphics Output protocol on ArmVersatileExpress
- *  using the Lcd controller
- *
- **********************************************************************/
-
-//
-// Global variables
-//
-
-BOOLEAN mDisplayInitialized = FALSE;
-
-LCD_INSTANCE mLcdTemplate = {
-  LCD_INSTANCE_SIGNATURE,
-  NULL, // Handle
-  { // ModeInfo
-    0, // Version
-    0, // HorizontalResolution
-    0, // VerticalResolution
-    PixelBltOnly, // PixelFormat
-    0, // PixelInformation
-    0, // PixelsPerScanLine
-  },
-  {
-    0, // MaxMode;
-    0, // Mode;
-    NULL, // Info;
-    0, // SizeOfInfo;
-    0, // FrameBufferBase;
-    0 // FrameBufferSize;
-  },
-  { // Gop
-    LcdGraphicsQueryMode,  // QueryMode
-    LcdGraphicsSetMode,    // SetMode
-    LcdGraphicsBlt,        // Blt
-    NULL                     // *Mode
-  },
-  { // DevicePath
-    {
-      {
-        HARDWARE_DEVICE_PATH, HW_VENDOR_DP,
-        (UINT8) (sizeof(VENDOR_DEVICE_PATH)),
-        (UINT8) ((sizeof(VENDOR_DEVICE_PATH)) >> 8),
-      },
-      // Hardware Device Path for Lcd
-      EFI_CALLER_ID_GUID // Use the driver's GUID
-    },
-
-    {
-      END_DEVICE_PATH_TYPE,
-      END_ENTIRE_DEVICE_PATH_SUBTYPE,
-      sizeof(EFI_DEVICE_PATH_PROTOCOL),
-      0
-    }
-  },
-  (EFI_EVENT) NULL // ExitBootServicesEvent
-};
-
-EFI_STATUS
-LcdInstanceContructor (
-  OUT LCD_INSTANCE** NewInstance
-  )
-{
-  LCD_INSTANCE* Instance;
-
-  Instance = AllocateCopyPool (sizeof(LCD_INSTANCE), &mLcdTemplate);
-  if (Instance == NULL) {
-    return EFI_OUT_OF_RESOURCES;
-  }
-
-  Instance->Gop.Mode          = &Instance->Mode;
-  Instance->Gop.Mode->MaxMode = LcdPlatformGetMaxMode ();
-  Instance->Mode.Info         = &Instance->ModeInfo;
-
-  *NewInstance = Instance;
-  return EFI_SUCCESS;
-}
-
-//
-// Function Definitions
-//
-
-EFI_STATUS
-InitializeDisplay (
-  IN LCD_INSTANCE* Instance
-  )
-{
-  EFI_STATUS             Status = EFI_SUCCESS;
-  EFI_PHYSICAL_ADDRESS   VramBaseAddress;
-  UINTN                  VramSize;
-
-  Status = LcdPlatformGetVram (&VramBaseAddress, &VramSize);
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  // Setup the LCD
-  Status = LcdInitialize (VramBaseAddress);
-  if (EFI_ERROR(Status)) {
-    goto EXIT_ERROR_LCD_SHUTDOWN;
-  }
-
-  Status = LcdPlatformInitializeDisplay (Instance->Handle);
-  if (EFI_ERROR(Status)) {
-    goto EXIT_ERROR_LCD_SHUTDOWN;
-  }
-
-  // Setup all the relevant mode information
-  Instance->Gop.Mode->SizeOfInfo      = sizeof(EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);
-  Instance->Gop.Mode->FrameBufferBase = VramBaseAddress;
-  Instance->Gop.Mode->FrameBufferSize = VramSize;
-
-  // Set the flag before changing the mode, to avoid infinite loops
-  mDisplayInitialized = TRUE;
-
-  // All is ok, so don't deal with any errors
-  goto EXIT;
-
-EXIT_ERROR_LCD_SHUTDOWN:
-  DEBUG((DEBUG_ERROR, "InitializeDisplay: ERROR - Can not initialise the display. Exit Status=%r\n", Status));
-  LcdShutdown ();
-
-EXIT:
-  return Status;
-}
-
-EFI_STATUS
-EFIAPI
-LcdGraphicsOutputDxeInitialize (
-  IN EFI_HANDLE         ImageHandle,
-  IN EFI_SYSTEM_TABLE   *SystemTable
-  )
-{
-  EFI_STATUS  Status = EFI_SUCCESS;
-  LCD_INSTANCE* Instance;
-
-  Status = LcdInstanceContructor (&Instance);
-  if (EFI_ERROR(Status)) {
-    goto EXIT;
-  }
-
-	// Install the Graphics Output Protocol and the Device Path
-	Status = gBS->InstallMultipleProtocolInterfaces(
-			&Instance->Handle,
-			&gEfiGraphicsOutputProtocolGuid, &Instance->Gop,
-			&gEfiDevicePathProtocolGuid,     &Instance->DevicePath,
-			NULL
-	   );
-
-	if (EFI_ERROR(Status)) {
-	  DEBUG((DEBUG_ERROR, "GraphicsOutputDxeInitialize: Can not install the protocol. Exit Status=%r\n", Status));
-		goto EXIT;
-	}
-
-	// Register for an ExitBootServicesEvent
-	// When ExitBootServices starts, this function here will make sure that the graphics driver will shut down properly,
-	// i.e. it will free up all allocated memory and perform any necessary hardware re-configuration.
-	Status = gBS->CreateEvent (
-	    EVT_SIGNAL_EXIT_BOOT_SERVICES,
-	    TPL_NOTIFY,
-	    LcdGraphicsExitBootServicesEvent, NULL,
-			&Instance->ExitBootServicesEvent
-			);
-
-	if (EFI_ERROR(Status)) {
-	  DEBUG((DEBUG_ERROR, "GraphicsOutputDxeInitialize: Can not install the ExitBootServicesEvent handler. Exit Status=%r\n", Status));
-		goto EXIT_ERROR_UNINSTALL_PROTOCOL;
-	}
-
-	// To get here, everything must be fine, so just exit
-	goto EXIT;
-
-EXIT_ERROR_UNINSTALL_PROTOCOL:
-	/* The following function could return an error message,
-	 * however, to get here something must have gone wrong already,
-	 * so preserve the original error, i.e. don't change
-	 * the Status variable, even it fails to uninstall the protocol.
-	 */
-	gBS->UninstallMultipleProtocolInterfaces (
-	    Instance->Handle,
-	    &gEfiGraphicsOutputProtocolGuid, &Instance->Gop, // Uninstall Graphics Output protocol
-	    &gEfiDevicePathProtocolGuid,     &Instance->DevicePath,     // Uninstall device path
-	    NULL
-	    );
-
-EXIT:
-	return Status;
-
-}
-
-/***************************************
- * This function should be called
- * on Event: ExitBootServices
- * to free up memory, stop the driver
- * and uninstall the protocols
- ***************************************/
-VOID
-LcdGraphicsExitBootServicesEvent (
-  IN EFI_EVENT  Event,
-  IN VOID       *Context
-  )
-{
-	//TODO: Implement me
-}
-
-/***************************************
- * GraphicsOutput Protocol function, mapping to
- * EFI_GRAPHICS_OUTPUT_PROTOCOL.QueryMode
- ***************************************/
-EFI_STATUS
-EFIAPI
-LcdGraphicsQueryMode (
-  IN EFI_GRAPHICS_OUTPUT_PROTOCOL            *This,
-	IN UINT32                                  ModeNumber,
-	OUT UINTN                                  *SizeOfInfo,
-	OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION   **Info
-	)
-{
-	EFI_STATUS Status = EFI_SUCCESS;
-	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;
-    }
-  }
-
-	// Error checking
-	if ( (This == NULL) || (Info == NULL) || (SizeOfInfo == NULL) || (ModeNumber >= This->Mode->MaxMode) ) {
-	  DEBUG((DEBUG_ERROR, "LcdGraphicsQueryMode: ERROR - For mode number %d : Invalid Parameter.\n", ModeNumber ));
-		Status = EFI_INVALID_PARAMETER;
-		goto EXIT;
-	}
-
-	*Info = AllocatePool (sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION));
-  if (*Info == NULL) {
-    Status = EFI_OUT_OF_RESOURCES;
-    goto EXIT;
-  }
-
-  *SizeOfInfo = sizeof( EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);
-
-  Status = LcdPlatformQueryMode (ModeNumber,*Info);
-  if (EFI_ERROR(Status)) {
-    FreePool(*Info);
-  }
-
-EXIT:
-	return Status;
-}
-
-/***************************************
- * GraphicsOutput Protocol function, mapping to
- * EFI_GRAPHICS_OUTPUT_PROTOCOL.SetMode
- ***************************************/
-EFI_STATUS
-EFIAPI
-LcdGraphicsSetMode (
-  IN EFI_GRAPHICS_OUTPUT_PROTOCOL   *This,
-	IN UINT32                         ModeNumber
-	)
-{
-	EFI_STATUS                      Status               = EFI_SUCCESS;
-	EFI_GRAPHICS_OUTPUT_BLT_PIXEL   FillColour;
-	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;
-    }
-  }
-
-  // Check if this mode is supported
-  if( ModeNumber >= This->Mode->MaxMode ) {
-    DEBUG((DEBUG_ERROR, "LcdGraphicsSetMode: ERROR - Unsupported mode number %d .\n", ModeNumber ));
-    Status = EFI_UNSUPPORTED;
-    goto EXIT;
-  }
-
-	// Set the oscillator frequency to support the new mode
-  Status = LcdPlatformSetMode (ModeNumber);
-  if (EFI_ERROR(Status)) {
-    Status = EFI_DEVICE_ERROR;
-    goto EXIT;
-  }
-
-	// Update the UEFI mode information
-	This->Mode->Mode = ModeNumber;
-	LcdPlatformQueryMode (ModeNumber,&Instance->ModeInfo);
-
-  // Set the hardware to the new mode
-	Status = LcdSetMode (ModeNumber);
-  if (EFI_ERROR(Status)) {
-    Status = EFI_DEVICE_ERROR;
-    goto EXIT;
-  }
-
-	// The UEFI spec requires that we now clear the visible portions of the output display to black.
-
-  // Set the fill colour to black
-  SetMem (&FillColour, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0x0);
-
-  // Fill the entire visible area with the same colour.
-  Status = This->Blt (
-      This,
-      &FillColour,
-      EfiBltVideoFill,
-      0,
-      0,
-      0,
-      0,
-      This->Mode->Info->HorizontalResolution,
-      This->Mode->Info->VerticalResolution,
-      0);
-
-EXIT:
-	return Status;
-}
-
-UINTN
-GetBytesPerPixel (
-  IN  LCD_BPP       Bpp
-  )
-{
-  switch(Bpp) {
-  case LCD_BITS_PER_PIXEL_24:
-    return 4;
-
-  case LCD_BITS_PER_PIXEL_16_565:
-  case LCD_BITS_PER_PIXEL_16_555:
-  case LCD_BITS_PER_PIXEL_12_444:
-    return 2;
-
-  case LCD_BITS_PER_PIXEL_8:
-  case LCD_BITS_PER_PIXEL_4:
-  case LCD_BITS_PER_PIXEL_2:
-  case LCD_BITS_PER_PIXEL_1:
-    return 1;
-
-  default:
-    return 0;
-  }
-}
+/** @file

+

+ Copyright (c) 2011, ARM Ltd. All rights reserved.<BR>

+ This program and the accompanying materials

+ are licensed and made available under the terms and conditions of the BSD License

+ which accompanies this distribution.  The full text of the license may be found at

+ http://opensource.org/licenses/bsd-license.php

+

+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+ **/

+

+#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"

+

+/**********************************************************************

+ *

+ *  This file implements the Graphics Output protocol on ArmVersatileExpress

+ *  using the Lcd controller

+ *

+ **********************************************************************/

+

+//

+// Global variables

+//

+

+BOOLEAN mDisplayInitialized = FALSE;

+

+LCD_INSTANCE mLcdTemplate = {

+  LCD_INSTANCE_SIGNATURE,

+  NULL, // Handle

+  { // ModeInfo

+    0, // Version

+    0, // HorizontalResolution

+    0, // VerticalResolution

+    PixelBltOnly, // PixelFormat

+    0, // PixelInformation

+    0, // PixelsPerScanLine

+  },

+  {

+    0, // MaxMode;

+    0, // Mode;

+    NULL, // Info;

+    0, // SizeOfInfo;

+    0, // FrameBufferBase;

+    0 // FrameBufferSize;

+  },

+  { // Gop

+    LcdGraphicsQueryMode,  // QueryMode

+    LcdGraphicsSetMode,    // SetMode

+    LcdGraphicsBlt,        // Blt

+    NULL                     // *Mode

+  },

+  { // DevicePath

+    {

+      {

+        HARDWARE_DEVICE_PATH, HW_VENDOR_DP,

+        (UINT8) (sizeof(VENDOR_DEVICE_PATH)),

+        (UINT8) ((sizeof(VENDOR_DEVICE_PATH)) >> 8),

+      },

+      // Hardware Device Path for Lcd

+      EFI_CALLER_ID_GUID // Use the driver's GUID

+    },

+

+    {

+      END_DEVICE_PATH_TYPE,

+      END_ENTIRE_DEVICE_PATH_SUBTYPE,

+      sizeof(EFI_DEVICE_PATH_PROTOCOL),

+      0

+    }

+  },

+  (EFI_EVENT) NULL // ExitBootServicesEvent

+};

+

+EFI_STATUS

+LcdInstanceContructor (

+  OUT LCD_INSTANCE** NewInstance

+  )

+{

+  LCD_INSTANCE* Instance;

+

+  Instance = AllocateCopyPool (sizeof(LCD_INSTANCE), &mLcdTemplate);

+  if (Instance == NULL) {

+    return EFI_OUT_OF_RESOURCES;

+  }

+

+  Instance->Gop.Mode          = &Instance->Mode;

+  Instance->Gop.Mode->MaxMode = LcdPlatformGetMaxMode ();

+  Instance->Mode.Info         = &Instance->ModeInfo;

+

+  *NewInstance = Instance;

+  return EFI_SUCCESS;

+}

+

+//

+// Function Definitions

+//

+

+EFI_STATUS

+InitializeDisplay (

+  IN LCD_INSTANCE* Instance

+  )

+{

+  EFI_STATUS             Status = EFI_SUCCESS;

+  EFI_PHYSICAL_ADDRESS   VramBaseAddress;

+  UINTN                  VramSize;

+

+  Status = LcdPlatformGetVram (&VramBaseAddress, &VramSize);

+  if (EFI_ERROR(Status)) {

+    return Status;

+  }

+

+  // Setup the LCD

+  Status = LcdInitialize (VramBaseAddress);

+  if (EFI_ERROR(Status)) {

+    goto EXIT_ERROR_LCD_SHUTDOWN;

+  }

+

+  Status = LcdPlatformInitializeDisplay (Instance->Handle);

+  if (EFI_ERROR(Status)) {

+    goto EXIT_ERROR_LCD_SHUTDOWN;

+  }

+

+  // Setup all the relevant mode information

+  Instance->Gop.Mode->SizeOfInfo      = sizeof(EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);

+  Instance->Gop.Mode->FrameBufferBase = VramBaseAddress;

+  Instance->Gop.Mode->FrameBufferSize = VramSize;

+

+  // Set the flag before changing the mode, to avoid infinite loops

+  mDisplayInitialized = TRUE;

+

+  // All is ok, so don't deal with any errors

+  goto EXIT;

+

+EXIT_ERROR_LCD_SHUTDOWN:

+  DEBUG((DEBUG_ERROR, "InitializeDisplay: ERROR - Can not initialise the display. Exit Status=%r\n", Status));

+  LcdShutdown ();

+

+EXIT:

+  return Status;

+}

+

+EFI_STATUS

+EFIAPI

+LcdGraphicsOutputDxeInitialize (

+  IN EFI_HANDLE         ImageHandle,

+  IN EFI_SYSTEM_TABLE   *SystemTable

+  )

+{

+  EFI_STATUS  Status = EFI_SUCCESS;

+  LCD_INSTANCE* Instance;

+

+  Status = LcdInstanceContructor (&Instance);

+  if (EFI_ERROR(Status)) {

+    goto EXIT;

+  }

+

+	// Install the Graphics Output Protocol and the Device Path

+	Status = gBS->InstallMultipleProtocolInterfaces(

+			&Instance->Handle,

+			&gEfiGraphicsOutputProtocolGuid, &Instance->Gop,

+			&gEfiDevicePathProtocolGuid,     &Instance->DevicePath,

+			NULL

+	   );

+

+	if (EFI_ERROR(Status)) {

+	  DEBUG((DEBUG_ERROR, "GraphicsOutputDxeInitialize: Can not install the protocol. Exit Status=%r\n", Status));

+		goto EXIT;

+	}

+

+	// Register for an ExitBootServicesEvent

+	// When ExitBootServices starts, this function here will make sure that the graphics driver will shut down properly,

+	// i.e. it will free up all allocated memory and perform any necessary hardware re-configuration.

+	Status = gBS->CreateEvent (

+	    EVT_SIGNAL_EXIT_BOOT_SERVICES,

+	    TPL_NOTIFY,

+	    LcdGraphicsExitBootServicesEvent, NULL,

+			&Instance->ExitBootServicesEvent

+			);

+

+	if (EFI_ERROR(Status)) {

+	  DEBUG((DEBUG_ERROR, "GraphicsOutputDxeInitialize: Can not install the ExitBootServicesEvent handler. Exit Status=%r\n", Status));

+		goto EXIT_ERROR_UNINSTALL_PROTOCOL;

+	}

+

+	// To get here, everything must be fine, so just exit

+	goto EXIT;

+

+EXIT_ERROR_UNINSTALL_PROTOCOL:

+	/* The following function could return an error message,

+	 * however, to get here something must have gone wrong already,

+	 * so preserve the original error, i.e. don't change

+	 * the Status variable, even it fails to uninstall the protocol.

+	 */

+	gBS->UninstallMultipleProtocolInterfaces (

+	    Instance->Handle,

+	    &gEfiGraphicsOutputProtocolGuid, &Instance->Gop, // Uninstall Graphics Output protocol

+	    &gEfiDevicePathProtocolGuid,     &Instance->DevicePath,     // Uninstall device path

+	    NULL

+	    );

+

+EXIT:

+	return Status;

+

+}

+

+/***************************************

+ * This function should be called

+ * on Event: ExitBootServices

+ * to free up memory, stop the driver

+ * and uninstall the protocols

+ ***************************************/

+VOID

+LcdGraphicsExitBootServicesEvent (

+  IN EFI_EVENT  Event,

+  IN VOID       *Context

+  )

+{

+	//TODO: Implement me

+}

+

+/***************************************

+ * GraphicsOutput Protocol function, mapping to

+ * EFI_GRAPHICS_OUTPUT_PROTOCOL.QueryMode

+ ***************************************/

+EFI_STATUS

+EFIAPI

+LcdGraphicsQueryMode (

+  IN EFI_GRAPHICS_OUTPUT_PROTOCOL            *This,

+	IN UINT32                                  ModeNumber,

+	OUT UINTN                                  *SizeOfInfo,

+	OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION   **Info

+	)

+{

+	EFI_STATUS Status = EFI_SUCCESS;

+	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;

+    }

+  }

+

+	// Error checking

+	if ( (This == NULL) || (Info == NULL) || (SizeOfInfo == NULL) || (ModeNumber >= This->Mode->MaxMode) ) {

+	  DEBUG((DEBUG_ERROR, "LcdGraphicsQueryMode: ERROR - For mode number %d : Invalid Parameter.\n", ModeNumber ));

+		Status = EFI_INVALID_PARAMETER;

+		goto EXIT;

+	}

+

+	*Info = AllocatePool (sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION));

+  if (*Info == NULL) {

+    Status = EFI_OUT_OF_RESOURCES;

+    goto EXIT;

+  }

+

+  *SizeOfInfo = sizeof( EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);

+

+  Status = LcdPlatformQueryMode (ModeNumber,*Info);

+  if (EFI_ERROR(Status)) {

+    FreePool(*Info);

+  }

+

+EXIT:

+	return Status;

+}

+

+/***************************************

+ * GraphicsOutput Protocol function, mapping to

+ * EFI_GRAPHICS_OUTPUT_PROTOCOL.SetMode

+ ***************************************/

+EFI_STATUS

+EFIAPI

+LcdGraphicsSetMode (

+  IN EFI_GRAPHICS_OUTPUT_PROTOCOL   *This,

+	IN UINT32                         ModeNumber

+	)

+{

+	EFI_STATUS                      Status               = EFI_SUCCESS;

+	EFI_GRAPHICS_OUTPUT_BLT_PIXEL   FillColour;

+	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;

+    }

+  }

+

+  // Check if this mode is supported

+  if( ModeNumber >= This->Mode->MaxMode ) {

+    DEBUG((DEBUG_ERROR, "LcdGraphicsSetMode: ERROR - Unsupported mode number %d .\n", ModeNumber ));

+    Status = EFI_UNSUPPORTED;

+    goto EXIT;

+  }

+

+	// Set the oscillator frequency to support the new mode

+  Status = LcdPlatformSetMode (ModeNumber);

+  if (EFI_ERROR(Status)) {

+    Status = EFI_DEVICE_ERROR;

+    goto EXIT;

+  }

+

+	// Update the UEFI mode information

+	This->Mode->Mode = ModeNumber;

+	LcdPlatformQueryMode (ModeNumber,&Instance->ModeInfo);

+

+  // Set the hardware to the new mode

+	Status = LcdSetMode (ModeNumber);

+  if (EFI_ERROR(Status)) {

+    Status = EFI_DEVICE_ERROR;

+    goto EXIT;

+  }

+

+	// The UEFI spec requires that we now clear the visible portions of the output display to black.

+

+  // Set the fill colour to black

+  SetMem (&FillColour, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0x0);

+

+  // Fill the entire visible area with the same colour.

+  Status = This->Blt (

+      This,

+      &FillColour,

+      EfiBltVideoFill,

+      0,

+      0,

+      0,

+      0,

+      This->Mode->Info->HorizontalResolution,

+      This->Mode->Info->VerticalResolution,

+      0);

+

+EXIT:

+	return Status;

+}

+

+UINTN

+GetBytesPerPixel (

+  IN  LCD_BPP       Bpp

+  )

+{

+  switch(Bpp) {

+  case LCD_BITS_PER_PIXEL_24:

+    return 4;

+

+  case LCD_BITS_PER_PIXEL_16_565:

+  case LCD_BITS_PER_PIXEL_16_555:

+  case LCD_BITS_PER_PIXEL_12_444:

+    return 2;

+

+  case LCD_BITS_PER_PIXEL_8:

+  case LCD_BITS_PER_PIXEL_4:

+  case LCD_BITS_PER_PIXEL_2:

+  case LCD_BITS_PER_PIXEL_1:

+    return 1;

+

+  default:

+    return 0;

+  }

+}

diff --git a/ArmPlatformPkg/Drivers/LcdGraphicsOutputDxe/LcdGraphicsOutputDxe.h b/ArmPlatformPkg/Drivers/LcdGraphicsOutputDxe/LcdGraphicsOutputDxe.h
index 1e66a428..dfbf2ed6 100644
--- a/ArmPlatformPkg/Drivers/LcdGraphicsOutputDxe/LcdGraphicsOutputDxe.h
+++ b/ArmPlatformPkg/Drivers/LcdGraphicsOutputDxe/LcdGraphicsOutputDxe.h
@@ -34,7 +34,7 @@ typedef struct {
 } LCD_GRAPHICS_DEVICE_PATH;

 

 typedef struct {

-  UINTN                                 Signature;

+  UINT32                                Signature;

   EFI_HANDLE                            Handle;

   EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  ModeInfo;

   EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE     Mode;

diff --git a/ArmPlatformPkg/Drivers/LcdGraphicsOutputDxe/PL111LcdGraphicsOutputDxe.inf b/ArmPlatformPkg/Drivers/LcdGraphicsOutputDxe/PL111LcdGraphicsOutputDxe.inf
index a267a538..5387e53c 100644
--- a/ArmPlatformPkg/Drivers/LcdGraphicsOutputDxe/PL111LcdGraphicsOutputDxe.inf
+++ b/ArmPlatformPkg/Drivers/LcdGraphicsOutputDxe/PL111LcdGraphicsOutputDxe.inf
@@ -1,56 +1,56 @@
-#/** @file
-#  
-#  Component description file for PL111LcdGraphicsOutputDxe module
-#  
-#  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = PL111LcdGraphicsDxe
-  FILE_GUID                      = 407B4008-BF5B-11DF-9547-CF16E0D72085
-  MODULE_TYPE                    = DXE_DRIVER
-  VERSION_STRING                 = 1.0
-  ENTRY_POINT                    = LcdGraphicsOutputDxeInitialize
-
-[Sources.common]
-  LcdGraphicsOutputDxe.c
-  LcdGraphicsOutputBlt.c
-  PL111Lcd.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  MdeModulePkg/MdeModulePkg.dec
-  ArmPkg/ArmPkg.dec
-  ArmPlatformPkg/ArmVExpressPkg/ArmVExpressPkg.dec
-  ArmPlatformPkg/ArmPlatformPkg.dec
-
-[LibraryClasses]
-  ArmLib
-  UefiLib
-  BaseLib
-  DebugLib
-  TimerLib
-  UefiDriverEntryPoint
-  UefiBootServicesTableLib
-  IoLib
-  BaseMemoryLib
-  LcdPlatformLib
-
-[Protocols]
-  gEfiDevicePathProtocolGuid
-  gEfiGraphicsOutputProtocolGuid
-
-[FixedPcd]
-  gArmPlatformTokenSpaceGuid.PcdPL111LcdBase
-
-[Depex]
-  gEfiCpuArchProtocolGuid
+#/** @file

+#  

+#  Component description file for PL111LcdGraphicsOutputDxe module

+#  

+#  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = PL111LcdGraphicsDxe

+  FILE_GUID                      = 407B4008-BF5B-11DF-9547-CF16E0D72085

+  MODULE_TYPE                    = DXE_DRIVER

+  VERSION_STRING                 = 1.0

+  ENTRY_POINT                    = LcdGraphicsOutputDxeInitialize

+

+[Sources.common]

+  LcdGraphicsOutputDxe.c

+  LcdGraphicsOutputBlt.c

+  PL111Lcd.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  MdeModulePkg/MdeModulePkg.dec

+  ArmPkg/ArmPkg.dec

+  ArmPlatformPkg/ArmVExpressPkg/ArmVExpressPkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+

+[LibraryClasses]

+  ArmLib

+  UefiLib

+  BaseLib

+  DebugLib

+  TimerLib

+  UefiDriverEntryPoint

+  UefiBootServicesTableLib

+  IoLib

+  BaseMemoryLib

+  LcdPlatformLib

+

+[Protocols]

+  gEfiDevicePathProtocolGuid

+  gEfiGraphicsOutputProtocolGuid

+

+[FixedPcd]

+  gArmPlatformTokenSpaceGuid.PcdPL111LcdBase

+

+[Depex]

+  gEfiCpuArchProtocolGuid

diff --git a/ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashBlockIoDxe.c b/ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashBlockIoDxe.c
index d4dabeae..21fceac1 100644
--- a/ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashBlockIoDxe.c
+++ b/ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashBlockIoDxe.c
@@ -1,119 +1,119 @@
-/** @file  NorFlashBlockIoDxe.c
-
-  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include <Library/BaseMemoryLib.h>
-#include <Library/UefiBootServicesTableLib.h>
-
-#include "NorFlashDxe.h"
-
-//
-// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.Reset
-//
-EFI_STATUS
-EFIAPI
-NorFlashBlockIoReset (
-  IN EFI_BLOCK_IO_PROTOCOL  *This,
-  IN BOOLEAN                ExtendedVerification
-  )
-{
-  NOR_FLASH_INSTANCE *Instance;
-
-  Instance = INSTANCE_FROM_BLKIO_THIS(This);
-
-  DEBUG ((DEBUG_BLKIO, "NorFlashBlockIoReset(MediaId=0x%x)\n", This->Media->MediaId));
-
-  return NorFlashReset (Instance);
-}
-
-//
-// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.ReadBlocks
-//
-EFI_STATUS
-EFIAPI
-NorFlashBlockIoReadBlocks (
-  IN  EFI_BLOCK_IO_PROTOCOL   *This,
-  IN  UINT32                  MediaId,
-  IN  EFI_LBA                 Lba,
-  IN  UINTN                   BufferSizeInBytes,
-  OUT VOID                    *Buffer
-  )
-{
-  NOR_FLASH_INSTANCE  *Instance;
-  EFI_STATUS          Status;
-
-  Instance = INSTANCE_FROM_BLKIO_THIS(This);
-
-  DEBUG ((DEBUG_BLKIO, "NorFlashBlockIoReadBlocks(MediaId=0x%x, Lba=%ld, BufferSize=0x%x bytes (%d kB), BufferPtr @ 0x%08x)\n", MediaId, Lba, BufferSizeInBytes, Buffer));
-
-  if( !This->Media->MediaPresent ) {
-    Status = EFI_NO_MEDIA;
-  } else if( This->Media->MediaId != MediaId ) {
-    Status = EFI_MEDIA_CHANGED;
-  } else {
-    Status = NorFlashReadBlocks (Instance,Lba,BufferSizeInBytes,Buffer);
-  }
-
-  return Status;
-}
-
-//
-// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.WriteBlocks
-//
-EFI_STATUS
-EFIAPI
-NorFlashBlockIoWriteBlocks (
-  IN  EFI_BLOCK_IO_PROTOCOL   *This,
-  IN  UINT32                  MediaId,
-  IN  EFI_LBA                 Lba,
-  IN  UINTN                   BufferSizeInBytes,
-  IN  VOID                    *Buffer
-  )
-{
-  NOR_FLASH_INSTANCE  *Instance;
-  EFI_STATUS          Status;
-
-  Instance = INSTANCE_FROM_BLKIO_THIS(This);
-
-  DEBUG ((DEBUG_BLKIO, "NorFlashBlockIoWriteBlocks(MediaId=0x%x, Lba=%ld, BufferSize=0x%x bytes (%d kB), BufferPtr @ 0x%08x)\n", MediaId, Lba, BufferSizeInBytes, Buffer));
-
-  if( !This->Media->MediaPresent ) {
-    Status = EFI_NO_MEDIA;
-  } else if( This->Media->MediaId != MediaId ) {
-    Status = EFI_MEDIA_CHANGED;
-  } else if( This->Media->ReadOnly ) {
-    Status = EFI_WRITE_PROTECTED;
-  } else {
-    Status = NorFlashWriteBlocks (Instance,Lba,BufferSizeInBytes,Buffer);
-  }
-
-  return Status;
-}
-
-//
-// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.FlushBlocks
-//
-EFI_STATUS
-EFIAPI
-NorFlashBlockIoFlushBlocks (
-  IN EFI_BLOCK_IO_PROTOCOL  *This
-  )
-{
-  // No Flush required for the NOR Flash driver
-  // because cache operations are not permitted.
-
-  DEBUG ((DEBUG_BLKIO, "NorFlashBlockIoFlushBlocks: Function NOT IMPLEMENTED (not required).\n"));
-
-  // Nothing to do so just return without error
-  return EFI_SUCCESS;
-}
+/** @file  NorFlashBlockIoDxe.c

+

+  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include <Library/BaseMemoryLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+

+#include "NorFlashDxe.h"

+

+//

+// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.Reset

+//

+EFI_STATUS

+EFIAPI

+NorFlashBlockIoReset (

+  IN EFI_BLOCK_IO_PROTOCOL  *This,

+  IN BOOLEAN                ExtendedVerification

+  )

+{

+  NOR_FLASH_INSTANCE *Instance;

+

+  Instance = INSTANCE_FROM_BLKIO_THIS(This);

+

+  DEBUG ((DEBUG_BLKIO, "NorFlashBlockIoReset(MediaId=0x%x)\n", This->Media->MediaId));

+

+  return NorFlashReset (Instance);

+}

+

+//

+// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.ReadBlocks

+//

+EFI_STATUS

+EFIAPI

+NorFlashBlockIoReadBlocks (

+  IN  EFI_BLOCK_IO_PROTOCOL   *This,

+  IN  UINT32                  MediaId,

+  IN  EFI_LBA                 Lba,

+  IN  UINTN                   BufferSizeInBytes,

+  OUT VOID                    *Buffer

+  )

+{

+  NOR_FLASH_INSTANCE  *Instance;

+  EFI_STATUS          Status;

+

+  Instance = INSTANCE_FROM_BLKIO_THIS(This);

+

+  DEBUG ((DEBUG_BLKIO, "NorFlashBlockIoReadBlocks(MediaId=0x%x, Lba=%ld, BufferSize=0x%x bytes (%d kB), BufferPtr @ 0x%08x)\n", MediaId, Lba, BufferSizeInBytes, Buffer));

+

+  if( !This->Media->MediaPresent ) {

+    Status = EFI_NO_MEDIA;

+  } else if( This->Media->MediaId != MediaId ) {

+    Status = EFI_MEDIA_CHANGED;

+  } else {

+    Status = NorFlashReadBlocks (Instance,Lba,BufferSizeInBytes,Buffer);

+  }

+

+  return Status;

+}

+

+//

+// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.WriteBlocks

+//

+EFI_STATUS

+EFIAPI

+NorFlashBlockIoWriteBlocks (

+  IN  EFI_BLOCK_IO_PROTOCOL   *This,

+  IN  UINT32                  MediaId,

+  IN  EFI_LBA                 Lba,

+  IN  UINTN                   BufferSizeInBytes,

+  IN  VOID                    *Buffer

+  )

+{

+  NOR_FLASH_INSTANCE  *Instance;

+  EFI_STATUS          Status;

+

+  Instance = INSTANCE_FROM_BLKIO_THIS(This);

+

+  DEBUG ((DEBUG_BLKIO, "NorFlashBlockIoWriteBlocks(MediaId=0x%x, Lba=%ld, BufferSize=0x%x bytes (%d kB), BufferPtr @ 0x%08x)\n", MediaId, Lba, BufferSizeInBytes, Buffer));

+

+  if( !This->Media->MediaPresent ) {

+    Status = EFI_NO_MEDIA;

+  } else if( This->Media->MediaId != MediaId ) {

+    Status = EFI_MEDIA_CHANGED;

+  } else if( This->Media->ReadOnly ) {

+    Status = EFI_WRITE_PROTECTED;

+  } else {

+    Status = NorFlashWriteBlocks (Instance,Lba,BufferSizeInBytes,Buffer);

+  }

+

+  return Status;

+}

+

+//

+// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.FlushBlocks

+//

+EFI_STATUS

+EFIAPI

+NorFlashBlockIoFlushBlocks (

+  IN EFI_BLOCK_IO_PROTOCOL  *This

+  )

+{

+  // No Flush required for the NOR Flash driver

+  // because cache operations are not permitted.

+

+  DEBUG ((DEBUG_BLKIO, "NorFlashBlockIoFlushBlocks: Function NOT IMPLEMENTED (not required).\n"));

+

+  // Nothing to do so just return without error

+  return EFI_SUCCESS;

+}

diff --git a/ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashDxe.c b/ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashDxe.c
index 8464a98f..a9c589b7 100644
--- a/ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashDxe.c
+++ b/ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashDxe.c
@@ -1,52 +1,52 @@
-/** @file  NorFlashDxe.c
-
-  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include <Library/UefiLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/MemoryAllocationLib.h>
-#include <Library/UefiBootServicesTableLib.h>
-#include <Library/PcdLib.h>
-
-#include "NorFlashDxe.h"
-
-
-//
-// Global variable declarations
-//
-NOR_FLASH_INSTANCE **mNorFlashInstances;
-
-NOR_FLASH_INSTANCE  mNorFlashInstanceTemplate = {
-  NOR_FLASH_SIGNATURE, // Signature
-  NULL, // Handle ... NEED TO BE FILLED
-
-  FALSE, // Initialized
-  NULL, // Initialize
-
-  0, // DeviceBaseAddress ... NEED TO BE FILLED
-  0, // RegionBaseAddress ... NEED TO BE FILLED
-  0, // Size ... NEED TO BE FILLED
-  0, // StartLba
-
+/** @file  NorFlashDxe.c

+

+  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include <Library/UefiLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/MemoryAllocationLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/PcdLib.h>

+

+#include "NorFlashDxe.h"

+

+

+//

+// Global variable declarations

+//

+NOR_FLASH_INSTANCE **mNorFlashInstances;

+

+NOR_FLASH_INSTANCE  mNorFlashInstanceTemplate = {

+  NOR_FLASH_SIGNATURE, // Signature

+  NULL, // Handle ... NEED TO BE FILLED

+

+  FALSE, // Initialized

+  NULL, // Initialize

+

+  0, // DeviceBaseAddress ... NEED TO BE FILLED

+  0, // RegionBaseAddress ... NEED TO BE FILLED

+  0, // Size ... NEED TO BE FILLED

+  0, // StartLba

+

   {

     EFI_BLOCK_IO_PROTOCOL_REVISION2, // Revision

     NULL, // Media ... NEED TO BE FILLED

     NorFlashBlockIoReset, // Reset;

-    NorFlashBlockIoReadBlocks,          // ReadBlocks
-    NorFlashBlockIoWriteBlocks,         // WriteBlocks
+    NorFlashBlockIoReadBlocks,          // ReadBlocks

+    NorFlashBlockIoWriteBlocks,         // WriteBlocks

     NorFlashBlockIoFlushBlocks          // FlushBlocks

-  }, // BlockIoProtocol
-
+  }, // BlockIoProtocol

+

   {

     0, // MediaId ... NEED TO BE FILLED

     FALSE, // RemovableMedia

@@ -59,767 +59,767 @@ NOR_FLASH_INSTANCE  mNorFlashInstanceTemplate = {
     0, // LastBlock ... NEED TO BE FILLED

     0, // LowestAlignedLba

     1, // LogicalBlocksPerPhysicalBlock

-  }, //Media;
-
-  FALSE, // SupportFvb ... NEED TO BE FILLED
+  }, //Media;

+

+  FALSE, // SupportFvb ... NEED TO BE FILLED

   {

-    FvbGetAttributes, // GetAttributes
-    FvbSetAttributes, // SetAttributes
-    FvbGetPhysicalAddress,  // GetPhysicalAddress
-    FvbGetBlockSize,  // GetBlockSize
-    FvbRead,  // Read
-    FvbWrite, // Write
+    FvbGetAttributes, // GetAttributes

+    FvbSetAttributes, // SetAttributes

+    FvbGetPhysicalAddress,  // GetPhysicalAddress

+    FvbGetBlockSize,  // GetBlockSize

+    FvbRead,  // Read

+    FvbWrite, // Write

     FvbEraseBlocks, // EraseBlocks

     NULL, //ParentHandle

-  }, //  FvbProtoccol;
-
-  {
-    {
-      {
-        HARDWARE_DEVICE_PATH,
-        HW_VENDOR_DP,
-        (UINT8)( sizeof(VENDOR_DEVICE_PATH)      ),
-        (UINT8)((sizeof(VENDOR_DEVICE_PATH)) >> 8),
-      },
-      { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }, // GUID ... NEED TO BE FILLED
-    },
-    {
-      END_DEVICE_PATH_TYPE,
-      END_ENTIRE_DEVICE_PATH_SUBTYPE,
-      sizeof (EFI_DEVICE_PATH_PROTOCOL),
-      0
-    }
-    } // DevicePath
-};
-
-EFI_STATUS
-NorFlashCreateInstance (
-  IN UINTN                  NorFlashDeviceBase,
-  IN UINTN                  NorFlashRegionBase,
-  IN UINTN                  NorFlashSize,
-  IN UINT32                 MediaId,
-  IN UINT32                 BlockSize,
-  IN BOOLEAN                SupportFvb,
-  IN CONST GUID             *NorFlashGuid,
-  OUT NOR_FLASH_INSTANCE**  NorFlashInstance
-  )
-{
-  EFI_STATUS Status;
-  NOR_FLASH_INSTANCE* Instance;
-
-  ASSERT(NorFlashInstance != NULL);
-
-  Instance = AllocateCopyPool (sizeof(NOR_FLASH_INSTANCE),&mNorFlashInstanceTemplate);
-  if (Instance == NULL) {
-    return EFI_OUT_OF_RESOURCES;
-  }
-
-  Instance->DeviceBaseAddress = NorFlashDeviceBase;
-  Instance->RegionBaseAddress = NorFlashRegionBase;
-  Instance->Size = NorFlashSize;
-
-  Instance->BlockIoProtocol.Media = &Instance->Media;
-  Instance->Media.MediaId = MediaId;
-  Instance->Media.BlockSize = BlockSize;
-  Instance->Media.LastBlock = (NorFlashSize / BlockSize)-1;
+  }, //  FvbProtoccol;

+

+  {

+    {

+      {

+        HARDWARE_DEVICE_PATH,

+        HW_VENDOR_DP,

+        (UINT8)( sizeof(VENDOR_DEVICE_PATH)      ),

+        (UINT8)((sizeof(VENDOR_DEVICE_PATH)) >> 8),

+      },

+      { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }, // GUID ... NEED TO BE FILLED

+    },

+    {

+      END_DEVICE_PATH_TYPE,

+      END_ENTIRE_DEVICE_PATH_SUBTYPE,

+      sizeof (EFI_DEVICE_PATH_PROTOCOL),

+      0

+    }

+    } // DevicePath

+};

+

+EFI_STATUS

+NorFlashCreateInstance (

+  IN UINTN                  NorFlashDeviceBase,

+  IN UINTN                  NorFlashRegionBase,

+  IN UINTN                  NorFlashSize,

+  IN UINT32                 MediaId,

+  IN UINT32                 BlockSize,

+  IN BOOLEAN                SupportFvb,

+  IN CONST GUID             *NorFlashGuid,

+  OUT NOR_FLASH_INSTANCE**  NorFlashInstance

+  )

+{

+  EFI_STATUS Status;

+  NOR_FLASH_INSTANCE* Instance;

+

+  ASSERT(NorFlashInstance != NULL);

+

+  Instance = AllocateCopyPool (sizeof(NOR_FLASH_INSTANCE),&mNorFlashInstanceTemplate);

+  if (Instance == NULL) {

+    return EFI_OUT_OF_RESOURCES;

+  }

+

+  Instance->DeviceBaseAddress = NorFlashDeviceBase;

+  Instance->RegionBaseAddress = NorFlashRegionBase;

+  Instance->Size = NorFlashSize;

+

+  Instance->BlockIoProtocol.Media = &Instance->Media;

+  Instance->Media.MediaId = MediaId;

+  Instance->Media.BlockSize = BlockSize;

+  Instance->Media.LastBlock = (NorFlashSize / BlockSize)-1;

 

   CopyGuid (&Instance->DevicePath.Vendor.Guid,NorFlashGuid);

-
-  if (SupportFvb) {
-    Instance->SupportFvb = TRUE;
-    Instance->Initialize = NorFlashFvbInitialize;
-
-    Status = gBS->InstallMultipleProtocolInterfaces (
-                  &Instance->Handle,
-                  &gEfiDevicePathProtocolGuid, &Instance->DevicePath,
-                  &gEfiBlockIoProtocolGuid,  &Instance->BlockIoProtocol,
-                  &gEfiFirmwareVolumeBlockProtocolGuid, &Instance->FvbProtocol,
-                  NULL
-                  );
-    if (EFI_ERROR(Status)) {
-      FreePool(Instance);
-      return Status;
-    }
-  } else {
-    Instance->Initialized = TRUE;
-
-    Status = gBS->InstallMultipleProtocolInterfaces (
-                    &Instance->Handle,
-                    &gEfiDevicePathProtocolGuid, &Instance->DevicePath,
-                    &gEfiBlockIoProtocolGuid,  &Instance->BlockIoProtocol,
-                    NULL
-                    );
-    if (EFI_ERROR(Status)) {
-      FreePool(Instance);
-      return Status;
-    }
-  }
+

+  if (SupportFvb) {

+    Instance->SupportFvb = TRUE;

+    Instance->Initialize = NorFlashFvbInitialize;

+

+    Status = gBS->InstallMultipleProtocolInterfaces (

+                  &Instance->Handle,

+                  &gEfiDevicePathProtocolGuid, &Instance->DevicePath,

+                  &gEfiBlockIoProtocolGuid,  &Instance->BlockIoProtocol,

+                  &gEfiFirmwareVolumeBlockProtocolGuid, &Instance->FvbProtocol,

+                  NULL

+                  );

+    if (EFI_ERROR(Status)) {

+      FreePool(Instance);

+      return Status;

+    }

+  } else {

+    Instance->Initialized = TRUE;

+

+    Status = gBS->InstallMultipleProtocolInterfaces (

+                    &Instance->Handle,

+                    &gEfiDevicePathProtocolGuid, &Instance->DevicePath,

+                    &gEfiBlockIoProtocolGuid,  &Instance->BlockIoProtocol,

+                    NULL

+                    );

+    if (EFI_ERROR(Status)) {

+      FreePool(Instance);

+      return Status;

+    }

+  }

 

   *NorFlashInstance = Instance;

-  return Status;
-}
-
-UINT32
-NorFlashReadStatusRegister (
-  IN NOR_FLASH_INSTANCE     *Instance,
-  IN UINTN                  SR_Address
-  )
-{
-  // Prepare to read the status register
-  SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_STATUS_REGISTER);
-  return MmioRead32 (Instance->DeviceBaseAddress);
-}
-
-
-BOOLEAN
-NorFlashBlockIsLocked (
-  IN NOR_FLASH_INSTANCE     *Instance,
-  IN UINTN                  BlockAddress
-  )
-{
-  UINT32                LockStatus;
-  BOOLEAN               BlockIsLocked;
-
-  BlockIsLocked = TRUE;
-
-  // Send command for reading device id
-  SEND_NOR_COMMAND (BlockAddress, 2, P30_CMD_READ_DEVICE_ID);
-
-  // Read block lock status
-  LockStatus = MmioRead32 (CREATE_NOR_ADDRESS(BlockAddress, 2));
-
-  // Decode block lock status
-  LockStatus = FOLD_32BIT_INTO_16BIT(LockStatus);
-
-  if ((LockStatus & 0x2) != 0) {
-    DEBUG((EFI_D_ERROR, "NorFlashBlockIsLocked: WARNING: Block LOCKED DOWN\n"));
-  }
-
-  if ((LockStatus & 0x1) == 0) {
-    // This means the block is unlocked
-    DEBUG((DEBUG_BLKIO, "UnlockSingleBlock: Block 0x%08x unlocked\n", BlockAddress));
-    BlockIsLocked = FALSE;
-  }
-
-  return BlockIsLocked;
-}
-
-
-EFI_STATUS
-NorFlashUnlockSingleBlock (
-  IN NOR_FLASH_INSTANCE     *Instance,
-  IN UINTN                  BlockAddress
-  )
-{
-  EFI_STATUS            Status = EFI_SUCCESS;
-  UINT32                LockStatus;
-
-  // Raise the Task Priority Level to TPL_NOTIFY to serialise all its operations
-  // and to protect shared data structures.
-
-  if (FeaturePcdGet (PcdNorFlashCheckBlockLocked) == TRUE) {
-    do {
-      // Request a lock setup
-      SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_LOCK_BLOCK_SETUP);
-
-      // Request an unlock
-      SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_UNLOCK_BLOCK);
-
-      // Send command for reading device id
-      SEND_NOR_COMMAND (BlockAddress, 2, P30_CMD_READ_DEVICE_ID);
-
-      // Read block lock status
-      LockStatus = MmioRead32 (CREATE_NOR_ADDRESS(BlockAddress, 2));
-
-      // Decode block lock status
-      LockStatus = FOLD_32BIT_INTO_16BIT(LockStatus);
-    } while ((LockStatus & 0x1) == 1);
-  } else {
-    // Request a lock setup
-    SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_LOCK_BLOCK_SETUP);
-
-    // Request an unlock
-    SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_UNLOCK_BLOCK);
-
-    // Wait until the status register gives us the all clear
-    do {
-      LockStatus = NorFlashReadStatusRegister (Instance, BlockAddress);
-    } while ((LockStatus & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);
-  }
-
-  // Put device back into Read Array mode
-  SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_READ_ARRAY);
-
-  DEBUG((DEBUG_BLKIO, "UnlockSingleBlock: BlockAddress=0x%08x, Exit Status = \"%r\".\n", BlockAddress, Status));
-
-  return Status;
-}
-
-
-EFI_STATUS
-NorFlashUnlockSingleBlockIfNecessary (
-  IN NOR_FLASH_INSTANCE     *Instance,
-  IN UINTN                  BlockAddress
-  )
-{
-  EFI_STATUS Status = EFI_SUCCESS;
-
-  if (NorFlashBlockIsLocked (Instance, BlockAddress) == TRUE) {
-    Status = NorFlashUnlockSingleBlock (Instance, BlockAddress);
-  }
-
-  return Status;
-}
-
-
-/**
- * The following function presumes that the block has already been unlocked.
- **/
-EFI_STATUS
-NorFlashEraseSingleBlock (
-  IN NOR_FLASH_INSTANCE     *Instance,
-  IN UINTN                  BlockAddress
-  )
-{
-  EFI_STATUS            Status;
-  UINT32                StatusRegister;
-
-  Status = EFI_SUCCESS;
-
-  // Request a block erase and then confirm it
-  SEND_NOR_COMMAND(BlockAddress, 0, P30_CMD_BLOCK_ERASE_SETUP);
-  SEND_NOR_COMMAND(BlockAddress, 0, P30_CMD_BLOCK_ERASE_CONFIRM);
-
-  // Wait until the status register gives us the all clear
-  do {
-    StatusRegister = NorFlashReadStatusRegister (Instance, BlockAddress);
-  } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);
-
-  if (StatusRegister & P30_SR_BIT_VPP) {
-    DEBUG((EFI_D_ERROR,"EraseSingleBlock(BlockAddress=0x%08x: VPP Range Error\n", BlockAddress));
-    Status = EFI_DEVICE_ERROR;
-  }
-
-  if ((StatusRegister & (P30_SR_BIT_ERASE | P30_SR_BIT_PROGRAM)) == (P30_SR_BIT_ERASE | P30_SR_BIT_PROGRAM)) {
-    DEBUG((EFI_D_ERROR,"EraseSingleBlock(BlockAddress=0x%08x: Command Sequence Error\n", BlockAddress));
-    Status = EFI_DEVICE_ERROR;
-  }
-
-  if (StatusRegister & P30_SR_BIT_ERASE) {
-    DEBUG((EFI_D_ERROR,"EraseSingleBlock(BlockAddress=0x%08x: Block Erase Error StatusRegister:0x%X\n", BlockAddress, StatusRegister));
-    Status = EFI_DEVICE_ERROR;
-  }
-
-  if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) {
-    // The debug level message has been reduced because a device lock might happen. In this case we just retry it ...
-    DEBUG((EFI_D_INFO,"EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error\n", BlockAddress));
-    Status = EFI_WRITE_PROTECTED;
-  }
-
-  if (EFI_ERROR(Status)) {
-    // Clear the Status Register
-    SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER);
-  }
-
-  // Put device back into Read Array mode
-  SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);
-
-  return Status;
-}
-
-/**
- * The following function presumes that the block has already been unlocked.
- **/
-EFI_STATUS
-NorFlashUnlockAndEraseSingleBlock (
-  IN NOR_FLASH_INSTANCE     *Instance,
-  IN UINTN                  BlockAddress
-  )
-{
-  EFI_STATUS      Status;
-  UINTN           Index;
-  EFI_TPL         OriginalTPL;
-
-  // Raise TPL to TPL_HIGH to stop anyone from interrupting us.
-  OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);
-
-  Index = 0;
-  // The block erase might fail a first time (SW bug ?). Retry it ...
-  do {
-    // Unlock the block if we have to
-    Status = NorFlashUnlockSingleBlockIfNecessary (Instance, BlockAddress);
-    if (!EFI_ERROR(Status)) {
-      Status = NorFlashEraseSingleBlock (Instance, BlockAddress);
-    }
-    Index++;
-  } while ((Index < NOR_FLASH_ERASE_RETRY) && (Status == EFI_WRITE_PROTECTED));
-
-  if (Index == NOR_FLASH_ERASE_RETRY) {
-    DEBUG((EFI_D_ERROR,"EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error (try to erase %d times)\n", BlockAddress,Index));
-  }
-
-  // Interruptions can resume.
-  gBS->RestoreTPL (OriginalTPL);
-
-  return Status;
-}
-
-
-EFI_STATUS
-NorFlashWriteSingleWord (
-  IN NOR_FLASH_INSTANCE     *Instance,
-  IN UINTN                  WordAddress,
-  IN UINT32                 WriteData
-  )
-{
-  EFI_STATUS            Status;
-  UINT32                StatusRegister;
-
-  Status = EFI_SUCCESS;
-
-  // Request a write single word command
-  SEND_NOR_COMMAND(WordAddress, 0, P30_CMD_WORD_PROGRAM_SETUP);
-
-  // Store the word into NOR Flash;
-  MmioWrite32 (WordAddress, WriteData);
-
-  // Wait for the write to complete and then check for any errors; i.e. check the Status Register
-  do {
-    // Prepare to read the status register
-    StatusRegister = NorFlashReadStatusRegister (Instance, WordAddress);
-    // The chip is busy while the WRITE bit is not asserted
-  } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);
-
-
-  // Perform a full status check:
-  // Mask the relevant bits of Status Register.
-  // Everything should be zero, if not, we have a problem
-
-  if (StatusRegister & P30_SR_BIT_VPP) {
-    DEBUG((EFI_D_ERROR,"NorFlashWriteSingleWord(WordAddress:0x%X): VPP Range Error\n",WordAddress));
-    Status = EFI_DEVICE_ERROR;
-  }
-
-  if (StatusRegister & P30_SR_BIT_PROGRAM) {
-    DEBUG((EFI_D_ERROR,"NorFlashWriteSingleWord(WordAddress:0x%X): Program Error\n",WordAddress));
-    Status = EFI_DEVICE_ERROR;
-  }
-
-  if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) {
-    DEBUG((EFI_D_ERROR,"NorFlashWriteSingleWord(WordAddress:0x%X): Device Protect Error\n",WordAddress));
-    Status = EFI_DEVICE_ERROR;
-  }
-
-  if (!EFI_ERROR(Status)) {
-    // Clear the Status Register
-    SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER);
-  }
-
-  // Put device back into Read Array mode
-  SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);
-
-  return Status;
-}
-
-/*
- * Writes data to the NOR Flash using the Buffered Programming method.
- *
- * The maximum size of the on-chip buffer is 32-words, because of hardware restrictions.
- * Therefore this function will only handle buffers up to 32 words or 128 bytes.
- * To deal with larger buffers, call this function again.
- *
- * This function presumes that both the TargetAddress and the TargetAddress+BufferSize
- * exist entirely within the NOR Flash. Therefore these conditions will not be checked here.
- *
- * In buffered programming, if the target address not at the beginning of a 32-bit word boundary,
- * then programming time is doubled and power consumption is increased.
- * Therefore, it is a requirement to align buffer writes to 32-bit word boundaries.
- * i.e. the last 4 bits of the target start address must be zero: 0x......00
- */
-EFI_STATUS
-NorFlashWriteBuffer (
-  IN NOR_FLASH_INSTANCE     *Instance,
-  IN UINTN                  TargetAddress,
-  IN UINTN                  BufferSizeInBytes,
-  IN UINT32                 *Buffer
-  )
-{
-  EFI_STATUS            Status;
-  UINTN                 BufferSizeInWords;
-  UINTN                 Count;
-  volatile UINT32       *Data;
-  UINTN                 WaitForBuffer;
-  BOOLEAN               BufferAvailable;
-  UINT32                StatusRegister;
-
-  WaitForBuffer   = MAX_BUFFERED_PROG_ITERATIONS;
-  BufferAvailable = FALSE;
-
-  // Check that the target address does not cross a 32-word boundary.
-  if ((TargetAddress & BOUNDARY_OF_32_WORDS) != 0) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  // Check there are some data to program
-  if (BufferSizeInBytes == 0) {
-    return EFI_BUFFER_TOO_SMALL;
-  }
-
-  // Check that the buffer size does not exceed the maximum hardware buffer size on chip.
-  if (BufferSizeInBytes > P30_MAX_BUFFER_SIZE_IN_BYTES) {
-    return EFI_BAD_BUFFER_SIZE;
-  }
-
-  // Check that the buffer size is a multiple of 32-bit words
-  if ((BufferSizeInBytes % 4) != 0) {
-    return EFI_BAD_BUFFER_SIZE;
-  }
-
-  // Pre-programming conditions checked, now start the algorithm.
-
-  // Prepare the data destination address
-  Data = (UINT32 *)TargetAddress;
-
-  // Check the availability of the buffer
-  do {
-    // Issue the Buffered Program Setup command
-    SEND_NOR_COMMAND(TargetAddress, 0, P30_CMD_BUFFERED_PROGRAM_SETUP);
-
-    // Read back the status register bit#7 from the same address
-    if (((*Data) & P30_SR_BIT_WRITE) == P30_SR_BIT_WRITE) {
-      BufferAvailable = TRUE;
-    }
-
-    // Update the loop counter
-    WaitForBuffer--;
-
-  } while ((WaitForBuffer > 0) && (BufferAvailable == FALSE));
-
-  // The buffer was not available for writing
-  if (WaitForBuffer == 0) {
-    Status = EFI_DEVICE_ERROR;
-    goto EXIT;
-  }
-
-  // From now on we work in 32-bit words
-  BufferSizeInWords = BufferSizeInBytes / (UINTN)4;
-
-  // Write the word count, which is (buffer_size_in_words - 1),
-  // because word count 0 means one word.
-  SEND_NOR_COMMAND(TargetAddress, 0, (BufferSizeInWords - 1));
-
-  // Write the data to the NOR Flash, advancing each address by 4 bytes
-  for(Count=0; Count < BufferSizeInWords; Count++, Data++, Buffer++) {
-    *Data = *Buffer;
-  }
-
-  // Issue the Buffered Program Confirm command, to start the programming operation
-  SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_BUFFERED_PROGRAM_CONFIRM);
-
-  // Wait for the write to complete and then check for any errors; i.e. check the Status Register
-  do {
-    StatusRegister = NorFlashReadStatusRegister (Instance, TargetAddress);
-    // The chip is busy while the WRITE bit is not asserted
-  } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);
-
-
-  // Perform a full status check:
-  // Mask the relevant bits of Status Register.
-  // Everything should be zero, if not, we have a problem
-
-  Status          = EFI_SUCCESS;
-
-  if (StatusRegister & P30_SR_BIT_VPP) {
-    DEBUG((EFI_D_ERROR,"NorFlashWriteBuffer(TargetAddress:0x%X): VPP Range Error\n", TargetAddress));
-    Status = EFI_DEVICE_ERROR;
-  }
-
-  if (StatusRegister & P30_SR_BIT_PROGRAM) {
-    DEBUG((EFI_D_ERROR,"NorFlashWriteBuffer(TargetAddress:0x%X): Program Error\n", TargetAddress));
-    Status = EFI_DEVICE_ERROR;
-  }
-
-  if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) {
-    DEBUG((EFI_D_ERROR,"NorFlashWriteBuffer(TargetAddress:0x%X): Device Protect Error\n",TargetAddress));
-    Status = EFI_DEVICE_ERROR;
-  }
-
-  if (!EFI_ERROR(Status)) {
-    // Clear the Status Register
-    SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER);
-  }
-
-EXIT:
-  // Put device back into Read Array mode
-  SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);
-
-  return Status;
-}
-
-EFI_STATUS
-NorFlashWriteSingleBlock (
-  IN NOR_FLASH_INSTANCE     *Instance,
-  IN EFI_LBA                Lba,
-  IN UINT32                 *DataBuffer,
-  IN UINT32                 BlockSizeInWords
-  )
-{
-  EFI_STATUS    Status;
-  UINTN         WordAddress;
-  UINT32        WordIndex;
-  UINTN         BufferIndex;
-  UINTN         BlockAddress;
-  UINTN         BuffersInBlock;
-  UINTN         RemainingWords;
-  EFI_TPL       OriginalTPL;
-
-  Status = EFI_SUCCESS;
-
-  // Get the physical address of the block
-  BlockAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, Lba, BlockSizeInWords * 4);
-
-  // Start writing from the first address at the start of the block
-  WordAddress = BlockAddress;
-
-  // Raise TPL to TPL_HIGH to stop anyone from interrupting us.
-  OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);
-
-  Status = NorFlashUnlockAndEraseSingleBlock (Instance, BlockAddress);
-  if (EFI_ERROR(Status)) {
-    DEBUG((EFI_D_ERROR, "WriteSingleBlock: ERROR - Failed to Unlock and Erase the single block at 0x%X\n", BlockAddress));
-    goto EXIT;
-  }
-
-  // To speed up the programming operation, NOR Flash is programmed using the Buffered Programming method.
-
-  // Check that the address starts at a 32-word boundary, i.e. last 7 bits must be zero
-  if ((WordAddress & BOUNDARY_OF_32_WORDS) == 0x00) {
-
-    // First, break the entire block into buffer-sized chunks.
-    BuffersInBlock = (UINTN)BlockSizeInWords / P30_MAX_BUFFER_SIZE_IN_BYTES;
-
-    // Then feed each buffer chunk to the NOR Flash
-    for(BufferIndex=0;
-         BufferIndex < BuffersInBlock;
-         BufferIndex++, WordAddress += P30_MAX_BUFFER_SIZE_IN_BYTES, DataBuffer += P30_MAX_BUFFER_SIZE_IN_WORDS
-      ) {
-      Status = NorFlashWriteBuffer (Instance, WordAddress, P30_MAX_BUFFER_SIZE_IN_BYTES, DataBuffer);
-      if (EFI_ERROR(Status)) {
-        goto EXIT;
-      }
-    }
-
-    // Finally, finish off any remaining words that are less than the maximum size of the buffer
-    RemainingWords = BlockSizeInWords % P30_MAX_BUFFER_SIZE_IN_WORDS;
-
-    if(RemainingWords != 0) {
-      Status = NorFlashWriteBuffer (Instance, WordAddress, (RemainingWords * 4), DataBuffer);
-      if (EFI_ERROR(Status)) {
-        goto EXIT;
-      }
-    }
-
-  } else {
-    // For now, use the single word programming algorithm
-    // It is unlikely that the NOR Flash will exist in an address which falls within a 32 word boundary range,
-    // i.e. which ends in the range 0x......01 - 0x......7F.
-    for(WordIndex=0; WordIndex<BlockSizeInWords; WordIndex++, DataBuffer++, WordAddress = WordAddress + 4) {
-      Status = NorFlashWriteSingleWord (Instance, WordAddress, *DataBuffer);
-      if (EFI_ERROR(Status)) {
-        goto EXIT;
-      }
-    }
-  }
-
-EXIT:
-  // Interruptions can resume.
-  gBS->RestoreTPL (OriginalTPL);
-
-  if (EFI_ERROR(Status)) {
-    DEBUG((EFI_D_ERROR, "NOR FLASH Programming [WriteSingleBlock] failed at address 0x%08x. Exit Status = \"%r\".\n", WordAddress, Status));
-  }
-  return Status;
-}
-
-
-EFI_STATUS
-NorFlashWriteBlocks (
-  IN NOR_FLASH_INSTANCE     *Instance,
-  IN EFI_LBA                Lba,
-  IN UINTN                  BufferSizeInBytes,
-  IN VOID                   *Buffer
-  )
-{
-  UINT32          *pWriteBuffer;
-  EFI_STATUS      Status = EFI_SUCCESS;
-  EFI_LBA         CurrentBlock;
-  UINT32          BlockSizeInWords;
-  UINT32          NumBlocks;
-  UINT32          BlockCount;
-
-  // The buffer must be valid
-  if (Buffer == NULL) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  if(Instance->Media.ReadOnly == TRUE) {
-    return EFI_WRITE_PROTECTED;
-  }
-
-  // We must have some bytes to read
-  DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: BufferSizeInBytes=0x%x\n", BufferSizeInBytes));
-  if(BufferSizeInBytes == 0) {
-    return EFI_BAD_BUFFER_SIZE;
-  }
-
-  // The size of the buffer must be a multiple of the block size
-  DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: BlockSize in bytes =0x%x\n", Instance->Media.BlockSize));
-  if ((BufferSizeInBytes % Instance->Media.BlockSize) != 0) {
-    return EFI_BAD_BUFFER_SIZE;
-  }
-
-  // All blocks must be within the device
-  NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->Media.BlockSize ;
-
-  DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: NumBlocks=%d, LastBlock=%ld, Lba=%ld.\n", NumBlocks, Instance->Media.LastBlock, Lba));
-
-  if ((Lba + NumBlocks) > (Instance->Media.LastBlock + 1)) {
-    DEBUG((EFI_D_ERROR, "NorFlashWriteBlocks: ERROR - Write will exceed last block.\n"));
-    return EFI_INVALID_PARAMETER;
-  }
-
-  BlockSizeInWords = Instance->Media.BlockSize / 4;
-
-  // Because the target *Buffer is a pointer to VOID, we must put all the data into a pointer
-  // to a proper data type, so use *ReadBuffer
-  pWriteBuffer = (UINT32 *)Buffer;
-
-  CurrentBlock = Lba;
-  for (BlockCount=0; BlockCount < NumBlocks; BlockCount++, CurrentBlock++, pWriteBuffer = pWriteBuffer + BlockSizeInWords) {
-
-    DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: Writing block #%d\n", (UINTN)CurrentBlock));
-
-    Status = NorFlashWriteSingleBlock (Instance, CurrentBlock, pWriteBuffer, BlockSizeInWords);
-
-    if (EFI_ERROR(Status)) {
-      break;
-    }
-  }
-
-  DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: Exit Status = \"%r\".\n", Status));
-  return Status;
-}
-
-EFI_STATUS
-NorFlashReadBlocks (
-  IN NOR_FLASH_INSTANCE   *Instance,
-  IN EFI_LBA              Lba,
-  IN UINTN                BufferSizeInBytes,
-  OUT VOID                *Buffer
-  )
-{
-  UINT32              NumBlocks;
-  UINTN               StartAddress;
-
-  // The buffer must be valid
-  if (Buffer == NULL) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  // We must have some bytes to read
-  DEBUG((DEBUG_BLKIO, "NorFlashReadBlocks: BufferSize=0x%x bytes.\n", BufferSizeInBytes));
-  if(BufferSizeInBytes == 0) {
-    return EFI_BAD_BUFFER_SIZE;
-  }
-
-  // The size of the buffer must be a multiple of the block size
-  DEBUG((DEBUG_BLKIO, "NorFlashReadBlocks: BlockSize=0x%x bytes.\n", Instance->Media.BlockSize));
-  if ((BufferSizeInBytes % Instance->Media.BlockSize) != 0) {
-    return EFI_BAD_BUFFER_SIZE;
-  }
-
-  // All blocks must be within the device
-  NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->Media.BlockSize ;
-
-  DEBUG((DEBUG_BLKIO, "NorFlashReadBlocks: NumBlocks=%d, LastBlock=%ld, Lba=%ld\n", NumBlocks, Instance->Media.LastBlock, Lba));
-
-  if ((Lba + NumBlocks) > (Instance->Media.LastBlock + 1)) {
-    DEBUG((EFI_D_ERROR, "NorFlashReadBlocks: ERROR - Read will exceed last block\n"));
-    return EFI_INVALID_PARAMETER;
-  }
-
-  // Get the address to start reading from
-  StartAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress,
-                                        Lba,
-                                        Instance->Media.BlockSize
-                                       );
-
-  // Put the device into Read Array mode
-  SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);
-
-  // Readout the data
-  CopyMem(Buffer, (UINTN *)StartAddress, BufferSizeInBytes);
-
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-NorFlashReset (
-  IN  NOR_FLASH_INSTANCE *Instance
-  )
-{
-  // As there is no specific RESET to perform, ensure that the devices is in the default Read Array mode
-  SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-EFIAPI
-NorFlashInitialise (
-  IN EFI_HANDLE         ImageHandle,
-  IN EFI_SYSTEM_TABLE   *SystemTable
-  )
-{
-  EFI_STATUS              Status;
-  UINT32                  Index;
-  NOR_FLASH_DESCRIPTION*  NorFlashDevices;
-  UINT32                  NorFlashDeviceCount;
-  BOOLEAN                 ContainVariableStorage;
-
-  Status = NorFlashPlatformInitialization ();
-  if (EFI_ERROR(Status)) {
-    DEBUG((EFI_D_ERROR,"NorFlashInitialise: Fail to initialize Nor Flash devices\n"));
-    return Status;
-  }
-
-  Status = NorFlashPlatformGetDevices (&NorFlashDevices,&NorFlashDeviceCount);
-  if (EFI_ERROR(Status)) {
-    DEBUG((EFI_D_ERROR,"NorFlashInitialise: Fail to get Nor Flash devices\n"));
-    return Status;
-  }
-
-  mNorFlashInstances = AllocatePool (sizeof(NOR_FLASH_INSTANCE*) * NorFlashDeviceCount);
-
-  for (Index = 0; Index < NorFlashDeviceCount; Index++) {
-    // Check if this NOR Flash device contain the variable storage region
-    ContainVariableStorage =
-        (NorFlashDevices[Index].RegionBaseAddress <= PcdGet32 (PcdFlashNvStorageVariableBase)) &&
-        (PcdGet32 (PcdFlashNvStorageVariableBase) + PcdGet32 (PcdFlashNvStorageVariableSize) <= NorFlashDevices[Index].RegionBaseAddress + NorFlashDevices[Index].Size);
-
-    Status = NorFlashCreateInstance (
-      NorFlashDevices[Index].DeviceBaseAddress,
-      NorFlashDevices[Index].RegionBaseAddress,
-      NorFlashDevices[Index].Size,
-      Index,
-      NorFlashDevices[Index].BlockSize,
-      ContainVariableStorage,
-      &NorFlashDevices[Index].Guid,
-      &mNorFlashInstances[Index]
-    );
-    if (EFI_ERROR(Status)) {
-      DEBUG((EFI_D_ERROR,"NorFlashInitialise: Fail to create instance for NorFlash[%d]\n",Index));
-    }
-  }
-
-  return Status;
-}
+  return Status;

+}

+

+UINT32

+NorFlashReadStatusRegister (

+  IN NOR_FLASH_INSTANCE     *Instance,

+  IN UINTN                  SR_Address

+  )

+{

+  // Prepare to read the status register

+  SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_STATUS_REGISTER);

+  return MmioRead32 (Instance->DeviceBaseAddress);

+}

+

+

+BOOLEAN

+NorFlashBlockIsLocked (

+  IN NOR_FLASH_INSTANCE     *Instance,

+  IN UINTN                  BlockAddress

+  )

+{

+  UINT32                LockStatus;

+  BOOLEAN               BlockIsLocked;

+

+  BlockIsLocked = TRUE;

+

+  // Send command for reading device id

+  SEND_NOR_COMMAND (BlockAddress, 2, P30_CMD_READ_DEVICE_ID);

+

+  // Read block lock status

+  LockStatus = MmioRead32 (CREATE_NOR_ADDRESS(BlockAddress, 2));

+

+  // Decode block lock status

+  LockStatus = FOLD_32BIT_INTO_16BIT(LockStatus);

+

+  if ((LockStatus & 0x2) != 0) {

+    DEBUG((EFI_D_ERROR, "NorFlashBlockIsLocked: WARNING: Block LOCKED DOWN\n"));

+  }

+

+  if ((LockStatus & 0x1) == 0) {

+    // This means the block is unlocked

+    DEBUG((DEBUG_BLKIO, "UnlockSingleBlock: Block 0x%08x unlocked\n", BlockAddress));

+    BlockIsLocked = FALSE;

+  }

+

+  return BlockIsLocked;

+}

+

+

+EFI_STATUS

+NorFlashUnlockSingleBlock (

+  IN NOR_FLASH_INSTANCE     *Instance,

+  IN UINTN                  BlockAddress

+  )

+{

+  EFI_STATUS            Status = EFI_SUCCESS;

+  UINT32                LockStatus;

+

+  // Raise the Task Priority Level to TPL_NOTIFY to serialise all its operations

+  // and to protect shared data structures.

+

+  if (FeaturePcdGet (PcdNorFlashCheckBlockLocked) == TRUE) {

+    do {

+      // Request a lock setup

+      SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_LOCK_BLOCK_SETUP);

+

+      // Request an unlock

+      SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_UNLOCK_BLOCK);

+

+      // Send command for reading device id

+      SEND_NOR_COMMAND (BlockAddress, 2, P30_CMD_READ_DEVICE_ID);

+

+      // Read block lock status

+      LockStatus = MmioRead32 (CREATE_NOR_ADDRESS(BlockAddress, 2));

+

+      // Decode block lock status

+      LockStatus = FOLD_32BIT_INTO_16BIT(LockStatus);

+    } while ((LockStatus & 0x1) == 1);

+  } else {

+    // Request a lock setup

+    SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_LOCK_BLOCK_SETUP);

+

+    // Request an unlock

+    SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_UNLOCK_BLOCK);

+

+    // Wait until the status register gives us the all clear

+    do {

+      LockStatus = NorFlashReadStatusRegister (Instance, BlockAddress);

+    } while ((LockStatus & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);

+  }

+

+  // Put device back into Read Array mode

+  SEND_NOR_COMMAND (BlockAddress, 0, P30_CMD_READ_ARRAY);

+

+  DEBUG((DEBUG_BLKIO, "UnlockSingleBlock: BlockAddress=0x%08x, Exit Status = \"%r\".\n", BlockAddress, Status));

+

+  return Status;

+}

+

+

+EFI_STATUS

+NorFlashUnlockSingleBlockIfNecessary (

+  IN NOR_FLASH_INSTANCE     *Instance,

+  IN UINTN                  BlockAddress

+  )

+{

+  EFI_STATUS Status = EFI_SUCCESS;

+

+  if (NorFlashBlockIsLocked (Instance, BlockAddress) == TRUE) {

+    Status = NorFlashUnlockSingleBlock (Instance, BlockAddress);

+  }

+

+  return Status;

+}

+

+

+/**

+ * The following function presumes that the block has already been unlocked.

+ **/

+EFI_STATUS

+NorFlashEraseSingleBlock (

+  IN NOR_FLASH_INSTANCE     *Instance,

+  IN UINTN                  BlockAddress

+  )

+{

+  EFI_STATUS            Status;

+  UINT32                StatusRegister;

+

+  Status = EFI_SUCCESS;

+

+  // Request a block erase and then confirm it

+  SEND_NOR_COMMAND(BlockAddress, 0, P30_CMD_BLOCK_ERASE_SETUP);

+  SEND_NOR_COMMAND(BlockAddress, 0, P30_CMD_BLOCK_ERASE_CONFIRM);

+

+  // Wait until the status register gives us the all clear

+  do {

+    StatusRegister = NorFlashReadStatusRegister (Instance, BlockAddress);

+  } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);

+

+  if (StatusRegister & P30_SR_BIT_VPP) {

+    DEBUG((EFI_D_ERROR,"EraseSingleBlock(BlockAddress=0x%08x: VPP Range Error\n", BlockAddress));

+    Status = EFI_DEVICE_ERROR;

+  }

+

+  if ((StatusRegister & (P30_SR_BIT_ERASE | P30_SR_BIT_PROGRAM)) == (P30_SR_BIT_ERASE | P30_SR_BIT_PROGRAM)) {

+    DEBUG((EFI_D_ERROR,"EraseSingleBlock(BlockAddress=0x%08x: Command Sequence Error\n", BlockAddress));

+    Status = EFI_DEVICE_ERROR;

+  }

+

+  if (StatusRegister & P30_SR_BIT_ERASE) {

+    DEBUG((EFI_D_ERROR,"EraseSingleBlock(BlockAddress=0x%08x: Block Erase Error StatusRegister:0x%X\n", BlockAddress, StatusRegister));

+    Status = EFI_DEVICE_ERROR;

+  }

+

+  if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) {

+    // The debug level message has been reduced because a device lock might happen. In this case we just retry it ...

+    DEBUG((EFI_D_INFO,"EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error\n", BlockAddress));

+    Status = EFI_WRITE_PROTECTED;

+  }

+

+  if (EFI_ERROR(Status)) {

+    // Clear the Status Register

+    SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER);

+  }

+

+  // Put device back into Read Array mode

+  SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);

+

+  return Status;

+}

+

+/**

+ * The following function presumes that the block has already been unlocked.

+ **/

+EFI_STATUS

+NorFlashUnlockAndEraseSingleBlock (

+  IN NOR_FLASH_INSTANCE     *Instance,

+  IN UINTN                  BlockAddress

+  )

+{

+  EFI_STATUS      Status;

+  UINTN           Index;

+  EFI_TPL         OriginalTPL;

+

+  // Raise TPL to TPL_HIGH to stop anyone from interrupting us.

+  OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);

+

+  Index = 0;

+  // The block erase might fail a first time (SW bug ?). Retry it ...

+  do {

+    // Unlock the block if we have to

+    Status = NorFlashUnlockSingleBlockIfNecessary (Instance, BlockAddress);

+    if (!EFI_ERROR(Status)) {

+      Status = NorFlashEraseSingleBlock (Instance, BlockAddress);

+    }

+    Index++;

+  } while ((Index < NOR_FLASH_ERASE_RETRY) && (Status == EFI_WRITE_PROTECTED));

+

+  if (Index == NOR_FLASH_ERASE_RETRY) {

+    DEBUG((EFI_D_ERROR,"EraseSingleBlock(BlockAddress=0x%08x: Block Locked Error (try to erase %d times)\n", BlockAddress,Index));

+  }

+

+  // Interruptions can resume.

+  gBS->RestoreTPL (OriginalTPL);

+

+  return Status;

+}

+

+

+EFI_STATUS

+NorFlashWriteSingleWord (

+  IN NOR_FLASH_INSTANCE     *Instance,

+  IN UINTN                  WordAddress,

+  IN UINT32                 WriteData

+  )

+{

+  EFI_STATUS            Status;

+  UINT32                StatusRegister;

+

+  Status = EFI_SUCCESS;

+

+  // Request a write single word command

+  SEND_NOR_COMMAND(WordAddress, 0, P30_CMD_WORD_PROGRAM_SETUP);

+

+  // Store the word into NOR Flash;

+  MmioWrite32 (WordAddress, WriteData);

+

+  // Wait for the write to complete and then check for any errors; i.e. check the Status Register

+  do {

+    // Prepare to read the status register

+    StatusRegister = NorFlashReadStatusRegister (Instance, WordAddress);

+    // The chip is busy while the WRITE bit is not asserted

+  } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);

+

+

+  // Perform a full status check:

+  // Mask the relevant bits of Status Register.

+  // Everything should be zero, if not, we have a problem

+

+  if (StatusRegister & P30_SR_BIT_VPP) {

+    DEBUG((EFI_D_ERROR,"NorFlashWriteSingleWord(WordAddress:0x%X): VPP Range Error\n",WordAddress));

+    Status = EFI_DEVICE_ERROR;

+  }

+

+  if (StatusRegister & P30_SR_BIT_PROGRAM) {

+    DEBUG((EFI_D_ERROR,"NorFlashWriteSingleWord(WordAddress:0x%X): Program Error\n",WordAddress));

+    Status = EFI_DEVICE_ERROR;

+  }

+

+  if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) {

+    DEBUG((EFI_D_ERROR,"NorFlashWriteSingleWord(WordAddress:0x%X): Device Protect Error\n",WordAddress));

+    Status = EFI_DEVICE_ERROR;

+  }

+

+  if (!EFI_ERROR(Status)) {

+    // Clear the Status Register

+    SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER);

+  }

+

+  // Put device back into Read Array mode

+  SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);

+

+  return Status;

+}

+

+/*

+ * Writes data to the NOR Flash using the Buffered Programming method.

+ *

+ * The maximum size of the on-chip buffer is 32-words, because of hardware restrictions.

+ * Therefore this function will only handle buffers up to 32 words or 128 bytes.

+ * To deal with larger buffers, call this function again.

+ *

+ * This function presumes that both the TargetAddress and the TargetAddress+BufferSize

+ * exist entirely within the NOR Flash. Therefore these conditions will not be checked here.

+ *

+ * In buffered programming, if the target address not at the beginning of a 32-bit word boundary,

+ * then programming time is doubled and power consumption is increased.

+ * Therefore, it is a requirement to align buffer writes to 32-bit word boundaries.

+ * i.e. the last 4 bits of the target start address must be zero: 0x......00

+ */

+EFI_STATUS

+NorFlashWriteBuffer (

+  IN NOR_FLASH_INSTANCE     *Instance,

+  IN UINTN                  TargetAddress,

+  IN UINTN                  BufferSizeInBytes,

+  IN UINT32                 *Buffer

+  )

+{

+  EFI_STATUS            Status;

+  UINTN                 BufferSizeInWords;

+  UINTN                 Count;

+  volatile UINT32       *Data;

+  UINTN                 WaitForBuffer;

+  BOOLEAN               BufferAvailable;

+  UINT32                StatusRegister;

+

+  WaitForBuffer   = MAX_BUFFERED_PROG_ITERATIONS;

+  BufferAvailable = FALSE;

+

+  // Check that the target address does not cross a 32-word boundary.

+  if ((TargetAddress & BOUNDARY_OF_32_WORDS) != 0) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  // Check there are some data to program

+  if (BufferSizeInBytes == 0) {

+    return EFI_BUFFER_TOO_SMALL;

+  }

+

+  // Check that the buffer size does not exceed the maximum hardware buffer size on chip.

+  if (BufferSizeInBytes > P30_MAX_BUFFER_SIZE_IN_BYTES) {

+    return EFI_BAD_BUFFER_SIZE;

+  }

+

+  // Check that the buffer size is a multiple of 32-bit words

+  if ((BufferSizeInBytes % 4) != 0) {

+    return EFI_BAD_BUFFER_SIZE;

+  }

+

+  // Pre-programming conditions checked, now start the algorithm.

+

+  // Prepare the data destination address

+  Data = (UINT32 *)TargetAddress;

+

+  // Check the availability of the buffer

+  do {

+    // Issue the Buffered Program Setup command

+    SEND_NOR_COMMAND(TargetAddress, 0, P30_CMD_BUFFERED_PROGRAM_SETUP);

+

+    // Read back the status register bit#7 from the same address

+    if (((*Data) & P30_SR_BIT_WRITE) == P30_SR_BIT_WRITE) {

+      BufferAvailable = TRUE;

+    }

+

+    // Update the loop counter

+    WaitForBuffer--;

+

+  } while ((WaitForBuffer > 0) && (BufferAvailable == FALSE));

+

+  // The buffer was not available for writing

+  if (WaitForBuffer == 0) {

+    Status = EFI_DEVICE_ERROR;

+    goto EXIT;

+  }

+

+  // From now on we work in 32-bit words

+  BufferSizeInWords = BufferSizeInBytes / (UINTN)4;

+

+  // Write the word count, which is (buffer_size_in_words - 1),

+  // because word count 0 means one word.

+  SEND_NOR_COMMAND(TargetAddress, 0, (BufferSizeInWords - 1));

+

+  // Write the data to the NOR Flash, advancing each address by 4 bytes

+  for(Count=0; Count < BufferSizeInWords; Count++, Data++, Buffer++) {

+    *Data = *Buffer;

+  }

+

+  // Issue the Buffered Program Confirm command, to start the programming operation

+  SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_BUFFERED_PROGRAM_CONFIRM);

+

+  // Wait for the write to complete and then check for any errors; i.e. check the Status Register

+  do {

+    StatusRegister = NorFlashReadStatusRegister (Instance, TargetAddress);

+    // The chip is busy while the WRITE bit is not asserted

+  } while ((StatusRegister & P30_SR_BIT_WRITE) != P30_SR_BIT_WRITE);

+

+

+  // Perform a full status check:

+  // Mask the relevant bits of Status Register.

+  // Everything should be zero, if not, we have a problem

+

+  Status          = EFI_SUCCESS;

+

+  if (StatusRegister & P30_SR_BIT_VPP) {

+    DEBUG((EFI_D_ERROR,"NorFlashWriteBuffer(TargetAddress:0x%X): VPP Range Error\n", TargetAddress));

+    Status = EFI_DEVICE_ERROR;

+  }

+

+  if (StatusRegister & P30_SR_BIT_PROGRAM) {

+    DEBUG((EFI_D_ERROR,"NorFlashWriteBuffer(TargetAddress:0x%X): Program Error\n", TargetAddress));

+    Status = EFI_DEVICE_ERROR;

+  }

+

+  if (StatusRegister & P30_SR_BIT_BLOCK_LOCKED) {

+    DEBUG((EFI_D_ERROR,"NorFlashWriteBuffer(TargetAddress:0x%X): Device Protect Error\n",TargetAddress));

+    Status = EFI_DEVICE_ERROR;

+  }

+

+  if (!EFI_ERROR(Status)) {

+    // Clear the Status Register

+    SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_CLEAR_STATUS_REGISTER);

+  }

+

+EXIT:

+  // Put device back into Read Array mode

+  SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);

+

+  return Status;

+}

+

+EFI_STATUS

+NorFlashWriteSingleBlock (

+  IN NOR_FLASH_INSTANCE     *Instance,

+  IN EFI_LBA                Lba,

+  IN UINT32                 *DataBuffer,

+  IN UINT32                 BlockSizeInWords

+  )

+{

+  EFI_STATUS    Status;

+  UINTN         WordAddress;

+  UINT32        WordIndex;

+  UINTN         BufferIndex;

+  UINTN         BlockAddress;

+  UINTN         BuffersInBlock;

+  UINTN         RemainingWords;

+  EFI_TPL       OriginalTPL;

+

+  Status = EFI_SUCCESS;

+

+  // Get the physical address of the block

+  BlockAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress, Lba, BlockSizeInWords * 4);

+

+  // Start writing from the first address at the start of the block

+  WordAddress = BlockAddress;

+

+  // Raise TPL to TPL_HIGH to stop anyone from interrupting us.

+  OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);

+

+  Status = NorFlashUnlockAndEraseSingleBlock (Instance, BlockAddress);

+  if (EFI_ERROR(Status)) {

+    DEBUG((EFI_D_ERROR, "WriteSingleBlock: ERROR - Failed to Unlock and Erase the single block at 0x%X\n", BlockAddress));

+    goto EXIT;

+  }

+

+  // To speed up the programming operation, NOR Flash is programmed using the Buffered Programming method.

+

+  // Check that the address starts at a 32-word boundary, i.e. last 7 bits must be zero

+  if ((WordAddress & BOUNDARY_OF_32_WORDS) == 0x00) {

+

+    // First, break the entire block into buffer-sized chunks.

+    BuffersInBlock = (UINTN)(BlockSizeInWords * 4) / P30_MAX_BUFFER_SIZE_IN_BYTES;

+

+    // Then feed each buffer chunk to the NOR Flash

+    for(BufferIndex=0;

+         BufferIndex < BuffersInBlock;

+         BufferIndex++, WordAddress += P30_MAX_BUFFER_SIZE_IN_BYTES, DataBuffer += P30_MAX_BUFFER_SIZE_IN_WORDS

+      ) {

+      Status = NorFlashWriteBuffer (Instance, WordAddress, P30_MAX_BUFFER_SIZE_IN_BYTES, DataBuffer);

+      if (EFI_ERROR(Status)) {

+        goto EXIT;

+      }

+    }

+

+    // Finally, finish off any remaining words that are less than the maximum size of the buffer

+    RemainingWords = BlockSizeInWords % P30_MAX_BUFFER_SIZE_IN_WORDS;

+

+    if(RemainingWords != 0) {

+      Status = NorFlashWriteBuffer (Instance, WordAddress, (RemainingWords * 4), DataBuffer);

+      if (EFI_ERROR(Status)) {

+        goto EXIT;

+      }

+    }

+

+  } else {

+    // For now, use the single word programming algorithm

+    // It is unlikely that the NOR Flash will exist in an address which falls within a 32 word boundary range,

+    // i.e. which ends in the range 0x......01 - 0x......7F.

+    for(WordIndex=0; WordIndex<BlockSizeInWords; WordIndex++, DataBuffer++, WordAddress = WordAddress + 4) {

+      Status = NorFlashWriteSingleWord (Instance, WordAddress, *DataBuffer);

+      if (EFI_ERROR(Status)) {

+        goto EXIT;

+      }

+    }

+  }

+

+EXIT:

+  // Interruptions can resume.

+  gBS->RestoreTPL (OriginalTPL);

+

+  if (EFI_ERROR(Status)) {

+    DEBUG((EFI_D_ERROR, "NOR FLASH Programming [WriteSingleBlock] failed at address 0x%08x. Exit Status = \"%r\".\n", WordAddress, Status));

+  }

+  return Status;

+}

+

+

+EFI_STATUS

+NorFlashWriteBlocks (

+  IN NOR_FLASH_INSTANCE     *Instance,

+  IN EFI_LBA                Lba,

+  IN UINTN                  BufferSizeInBytes,

+  IN VOID                   *Buffer

+  )

+{

+  UINT32          *pWriteBuffer;

+  EFI_STATUS      Status = EFI_SUCCESS;

+  EFI_LBA         CurrentBlock;

+  UINT32          BlockSizeInWords;

+  UINT32          NumBlocks;

+  UINT32          BlockCount;

+

+  // The buffer must be valid

+  if (Buffer == NULL) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  if(Instance->Media.ReadOnly == TRUE) {

+    return EFI_WRITE_PROTECTED;

+  }

+

+  // We must have some bytes to read

+  DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: BufferSizeInBytes=0x%x\n", BufferSizeInBytes));

+  if(BufferSizeInBytes == 0) {

+    return EFI_BAD_BUFFER_SIZE;

+  }

+

+  // The size of the buffer must be a multiple of the block size

+  DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: BlockSize in bytes =0x%x\n", Instance->Media.BlockSize));

+  if ((BufferSizeInBytes % Instance->Media.BlockSize) != 0) {

+    return EFI_BAD_BUFFER_SIZE;

+  }

+

+  // All blocks must be within the device

+  NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->Media.BlockSize ;

+

+  DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: NumBlocks=%d, LastBlock=%ld, Lba=%ld.\n", NumBlocks, Instance->Media.LastBlock, Lba));

+

+  if ((Lba + NumBlocks) > (Instance->Media.LastBlock + 1)) {

+    DEBUG((EFI_D_ERROR, "NorFlashWriteBlocks: ERROR - Write will exceed last block.\n"));

+    return EFI_INVALID_PARAMETER;

+  }

+

+  BlockSizeInWords = Instance->Media.BlockSize / 4;

+

+  // Because the target *Buffer is a pointer to VOID, we must put all the data into a pointer

+  // to a proper data type, so use *ReadBuffer

+  pWriteBuffer = (UINT32 *)Buffer;

+

+  CurrentBlock = Lba;

+  for (BlockCount=0; BlockCount < NumBlocks; BlockCount++, CurrentBlock++, pWriteBuffer = pWriteBuffer + BlockSizeInWords) {

+

+    DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: Writing block #%d\n", (UINTN)CurrentBlock));

+

+    Status = NorFlashWriteSingleBlock (Instance, CurrentBlock, pWriteBuffer, BlockSizeInWords);

+

+    if (EFI_ERROR(Status)) {

+      break;

+    }

+  }

+

+  DEBUG((DEBUG_BLKIO, "NorFlashWriteBlocks: Exit Status = \"%r\".\n", Status));

+  return Status;

+}

+

+EFI_STATUS

+NorFlashReadBlocks (

+  IN NOR_FLASH_INSTANCE   *Instance,

+  IN EFI_LBA              Lba,

+  IN UINTN                BufferSizeInBytes,

+  OUT VOID                *Buffer

+  )

+{

+  UINT32              NumBlocks;

+  UINTN               StartAddress;

+

+  // The buffer must be valid

+  if (Buffer == NULL) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  // We must have some bytes to read

+  DEBUG((DEBUG_BLKIO, "NorFlashReadBlocks: BufferSize=0x%x bytes.\n", BufferSizeInBytes));

+  if(BufferSizeInBytes == 0) {

+    return EFI_BAD_BUFFER_SIZE;

+  }

+

+  // The size of the buffer must be a multiple of the block size

+  DEBUG((DEBUG_BLKIO, "NorFlashReadBlocks: BlockSize=0x%x bytes.\n", Instance->Media.BlockSize));

+  if ((BufferSizeInBytes % Instance->Media.BlockSize) != 0) {

+    return EFI_BAD_BUFFER_SIZE;

+  }

+

+  // All blocks must be within the device

+  NumBlocks = ((UINT32)BufferSizeInBytes) / Instance->Media.BlockSize ;

+

+  DEBUG((DEBUG_BLKIO, "NorFlashReadBlocks: NumBlocks=%d, LastBlock=%ld, Lba=%ld\n", NumBlocks, Instance->Media.LastBlock, Lba));

+

+  if ((Lba + NumBlocks) > (Instance->Media.LastBlock + 1)) {

+    DEBUG((EFI_D_ERROR, "NorFlashReadBlocks: ERROR - Read will exceed last block\n"));

+    return EFI_INVALID_PARAMETER;

+  }

+

+  // Get the address to start reading from

+  StartAddress = GET_NOR_BLOCK_ADDRESS (Instance->RegionBaseAddress,

+                                        Lba,

+                                        Instance->Media.BlockSize

+                                       );

+

+  // Put the device into Read Array mode

+  SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);

+

+  // Readout the data

+  CopyMem(Buffer, (UINTN *)StartAddress, BufferSizeInBytes);

+

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+NorFlashReset (

+  IN  NOR_FLASH_INSTANCE *Instance

+  )

+{

+  // As there is no specific RESET to perform, ensure that the devices is in the default Read Array mode

+  SEND_NOR_COMMAND (Instance->DeviceBaseAddress, 0, P30_CMD_READ_ARRAY);

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+EFIAPI

+NorFlashInitialise (

+  IN EFI_HANDLE         ImageHandle,

+  IN EFI_SYSTEM_TABLE   *SystemTable

+  )

+{

+  EFI_STATUS              Status;

+  UINT32                  Index;

+  NOR_FLASH_DESCRIPTION*  NorFlashDevices;

+  UINT32                  NorFlashDeviceCount;

+  BOOLEAN                 ContainVariableStorage;

+

+  Status = NorFlashPlatformInitialization ();

+  if (EFI_ERROR(Status)) {

+    DEBUG((EFI_D_ERROR,"NorFlashInitialise: Fail to initialize Nor Flash devices\n"));

+    return Status;

+  }

+

+  Status = NorFlashPlatformGetDevices (&NorFlashDevices,&NorFlashDeviceCount);

+  if (EFI_ERROR(Status)) {

+    DEBUG((EFI_D_ERROR,"NorFlashInitialise: Fail to get Nor Flash devices\n"));

+    return Status;

+  }

+

+  mNorFlashInstances = AllocatePool (sizeof(NOR_FLASH_INSTANCE*) * NorFlashDeviceCount);

+

+  for (Index = 0; Index < NorFlashDeviceCount; Index++) {

+    // Check if this NOR Flash device contain the variable storage region

+    ContainVariableStorage =

+        (NorFlashDevices[Index].RegionBaseAddress <= PcdGet32 (PcdFlashNvStorageVariableBase)) &&

+        (PcdGet32 (PcdFlashNvStorageVariableBase) + PcdGet32 (PcdFlashNvStorageVariableSize) <= NorFlashDevices[Index].RegionBaseAddress + NorFlashDevices[Index].Size);

+

+    Status = NorFlashCreateInstance (

+      NorFlashDevices[Index].DeviceBaseAddress,

+      NorFlashDevices[Index].RegionBaseAddress,

+      NorFlashDevices[Index].Size,

+      Index,

+      NorFlashDevices[Index].BlockSize,

+      ContainVariableStorage,

+      &NorFlashDevices[Index].Guid,

+      &mNorFlashInstances[Index]

+    );

+    if (EFI_ERROR(Status)) {

+      DEBUG((EFI_D_ERROR,"NorFlashInitialise: Fail to create instance for NorFlash[%d]\n",Index));

+    }

+  }

+

+  return Status;

+}

diff --git a/ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashDxe.h b/ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashDxe.h
index a284c151..959c0c19 100644
--- a/ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashDxe.h
+++ b/ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashDxe.h
@@ -1,316 +1,316 @@
-/** @file  NorFlashDxe.h
-
-  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __NOR_FLASH_DXE_H__
-#define __NOR_FLASH_DXE_H__
-
-
-#include <Base.h>
-#include <PiDxe.h>
-
-#include <Protocol/BlockIo.h>
-#include <Protocol/FirmwareVolumeBlock.h>
-
-#include <Library/DebugLib.h>
-#include <Library/IoLib.h>
-#include <Library/NorFlashPlatformLib.h>
-#include <Library/UefiLib.h>
-
-#define NOR_FLASH_ERASE_RETRY                     10
-
-// Device access macros
-// These are necessary because we use 2 x 16bit parts to make up 32bit data
-
-#define HIGH_16_BITS                              0xFFFF0000
-#define LOW_16_BITS                               0x0000FFFF
-#define LOW_8_BITS                                0x000000FF
-
-#define FOLD_32BIT_INTO_16BIT(value)              ( ( value >> 16 ) | ( value & LOW_16_BITS ) )
-
-#define GET_LOW_BYTE(value)                       ( value & LOW_8_BITS )
-#define GET_HIGH_BYTE(value)                      ( GET_LOW_BYTE( value >> 16 ) )
-
-// Each command must be sent simultaneously to both chips,
-// i.e. at the lower 16 bits AND at the higher 16 bits
-#define CREATE_NOR_ADDRESS(BaseAddr,OffsetAddr)   ((BaseAddr) + ((OffsetAddr) << 2))
-#define CREATE_DUAL_CMD(Cmd)                      ( ( Cmd << 16) | ( Cmd & LOW_16_BITS) )
-#define SEND_NOR_COMMAND(BaseAddr,Offset,Cmd) MmioWrite32 (CREATE_NOR_ADDRESS(BaseAddr,Offset), CREATE_DUAL_CMD(Cmd))
-#define GET_NOR_BLOCK_ADDRESS(BaseAddr,Lba,LbaSize)( BaseAddr + (UINTN)((Lba) * LbaSize) )
-
-// Status Register Bits
-#define P30_SR_BIT_WRITE                          (BIT7 << 16 | BIT7)
-#define P30_SR_BIT_ERASE_SUSPEND                  (BIT6 << 16 | BIT6)
-#define P30_SR_BIT_ERASE                          (BIT5 << 16 | BIT5)
-#define P30_SR_BIT_PROGRAM                        (BIT4 << 16 | BIT4)
-#define P30_SR_BIT_VPP                            (BIT3 << 16 | BIT3)
-#define P30_SR_BIT_PROGRAM_SUSPEND                (BIT2 << 16 | BIT2)
-#define P30_SR_BIT_BLOCK_LOCKED                   (BIT1 << 16 | BIT1)
-#define P30_SR_BIT_BEFP                           (BIT0 << 16 | BIT0)
-
-// Device Commands for Intel StrataFlash(R) Embedded Memory (P30) Family
-
-// On chip buffer size for buffered programming operations
-// There are 2 chips, each chip can buffer up to 32 (16-bit)words, and each word is 2 bytes.
-// Therefore the total size of the buffer is 2 x 32 x 2 = 128 bytes
-#define P30_MAX_BUFFER_SIZE_IN_BYTES              ((UINTN)128)
-#define P30_MAX_BUFFER_SIZE_IN_WORDS              (P30_MAX_BUFFER_SIZE_IN_BYTES/((UINTN)4))
-#define MAX_BUFFERED_PROG_ITERATIONS              10000000
-#define BOUNDARY_OF_32_WORDS                      0x7F
-
-// CFI Addresses
-#define P30_CFI_ADDR_QUERY_UNIQUE_QRY             0x10
-#define P30_CFI_ADDR_VENDOR_ID                    0x13
-
-// CFI Data
-#define CFI_QRY                                   0x00595251
-
-// READ Commands
-#define P30_CMD_READ_DEVICE_ID                    0x0090
-#define P30_CMD_READ_STATUS_REGISTER              0x0070
-#define P30_CMD_CLEAR_STATUS_REGISTER             0x0050
-#define P30_CMD_READ_ARRAY                        0x00FF
-#define P30_CMD_READ_CFI_QUERY                    0x0098
-
-// WRITE Commands
-#define P30_CMD_WORD_PROGRAM_SETUP                0x0040
-#define P30_CMD_ALTERNATE_WORD_PROGRAM_SETUP      0x0010
-#define P30_CMD_BUFFERED_PROGRAM_SETUP            0x00E8
-#define P30_CMD_BUFFERED_PROGRAM_CONFIRM          0x00D0
-#define P30_CMD_BEFP_SETUP                        0x0080
-#define P30_CMD_BEFP_CONFIRM                      0x00D0
-
-// ERASE Commands
-#define P30_CMD_BLOCK_ERASE_SETUP                 0x0020
-#define P30_CMD_BLOCK_ERASE_CONFIRM               0x00D0
-
-// SUSPEND Commands
-#define P30_CMD_PROGRAM_OR_ERASE_SUSPEND          0x00B0
-#define P30_CMD_SUSPEND_RESUME                    0x00D0
-
-// BLOCK LOCKING / UNLOCKING Commands
-#define P30_CMD_LOCK_BLOCK_SETUP                  0x0060
-#define P30_CMD_LOCK_BLOCK                        0x0001
-#define P30_CMD_UNLOCK_BLOCK                      0x00D0
-#define P30_CMD_LOCK_DOWN_BLOCK                   0x002F
-
-// PROTECTION Commands
-#define P30_CMD_PROGRAM_PROTECTION_REGISTER_SETUP 0x00C0
-
-// CONFIGURATION Commands
-#define P30_CMD_READ_CONFIGURATION_REGISTER_SETUP 0x0060
-#define P30_CMD_READ_CONFIGURATION_REGISTER       0x0003
-
-#define NOR_FLASH_SIGNATURE                       SIGNATURE_32('n', 'o', 'r', '0')
-#define INSTANCE_FROM_FVB_THIS(a)                 CR(a, NOR_FLASH_INSTANCE, FvbProtocol, NOR_FLASH_SIGNATURE)
-#define INSTANCE_FROM_BLKIO_THIS(a)               CR(a, NOR_FLASH_INSTANCE, BlockIoProtocol, NOR_FLASH_SIGNATURE)
-
-typedef struct _NOR_FLASH_INSTANCE                NOR_FLASH_INSTANCE;
-
-typedef EFI_STATUS (*NOR_FLASH_INITIALIZE)        (NOR_FLASH_INSTANCE* Instance);
-
-typedef struct {
-  VENDOR_DEVICE_PATH                  Vendor;
-  EFI_DEVICE_PATH_PROTOCOL            End;
-} NOR_FLASH_DEVICE_PATH;
-
-struct _NOR_FLASH_INSTANCE {
-  UINT32                              Signature;
-  EFI_HANDLE                          Handle;
-
-  BOOLEAN                             Initialized;
-  NOR_FLASH_INITIALIZE                Initialize;
-
-  UINTN                               DeviceBaseAddress;
-  UINTN                               RegionBaseAddress;
-  UINTN                               Size;
-  EFI_LBA                             StartLba;
-
-  EFI_BLOCK_IO_PROTOCOL               BlockIoProtocol;
-  EFI_BLOCK_IO_MEDIA                  Media;
-
-  BOOLEAN                             SupportFvb;
-  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL FvbProtocol;
-
-  NOR_FLASH_DEVICE_PATH	              DevicePath;
-};
-
-EFI_STATUS
-NorFlashReadCfiData (
-  IN  UINTN                   DeviceBaseAddress,
-  IN  UINTN                   CFI_Offset,
-  IN  UINT32                  NumberOfBytes,
-  OUT UINT32                  *Data
-  );
-
-EFI_STATUS
-NorFlashWriteBuffer (
-  IN NOR_FLASH_INSTANCE     *Instance,
-  IN UINTN                  TargetAddress,
-  IN UINTN                  BufferSizeInBytes,
-  IN UINT32                 *Buffer
-  );
-
-//
-// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.Reset
-//
-EFI_STATUS
-EFIAPI
-NorFlashBlockIoReset (
-  IN EFI_BLOCK_IO_PROTOCOL    *This,
-  IN BOOLEAN                  ExtendedVerification
-  );
-
-//
-// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.ReadBlocks
-//
-EFI_STATUS
-EFIAPI
-NorFlashBlockIoReadBlocks (
-  IN  EFI_BLOCK_IO_PROTOCOL   *This,
-  IN  UINT32                  MediaId,
-  IN  EFI_LBA                 Lba,
-  IN  UINTN                   BufferSizeInBytes,
-  OUT VOID                    *Buffer
-);
-
-//
-// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.WriteBlocks
-//
-EFI_STATUS
-EFIAPI
-NorFlashBlockIoWriteBlocks (
-  IN  EFI_BLOCK_IO_PROTOCOL   *This,
-  IN  UINT32                  MediaId,
-  IN  EFI_LBA                 Lba,
-  IN  UINTN                   BufferSizeInBytes,
-  IN  VOID                    *Buffer
-);
-
-//
-// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.FlushBlocks
-//
-EFI_STATUS
-EFIAPI
-NorFlashBlockIoFlushBlocks (
-  IN EFI_BLOCK_IO_PROTOCOL    *This
-);
-
-
-//
-// NorFlashFvbDxe.c
-//
-
-EFI_STATUS
-EFIAPI
-NorFlashFvbInitialize (
-  IN NOR_FLASH_INSTANCE*                            Instance
-  );
-
-EFI_STATUS
-EFIAPI
-FvbGetAttributes(
-  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL     *This,
-  OUT       EFI_FVB_ATTRIBUTES_2                    *Attributes
-  );
-
-EFI_STATUS
-EFIAPI
-FvbSetAttributes(
-  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL     *This,
-  IN OUT    EFI_FVB_ATTRIBUTES_2                    *Attributes
-  );
-
-EFI_STATUS
-EFIAPI
-FvbGetPhysicalAddress(
-  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL     *This,
-  OUT       EFI_PHYSICAL_ADDRESS                    *Address
-  );
-
-EFI_STATUS
-EFIAPI
-FvbGetBlockSize(
-  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL     *This,
-  IN        EFI_LBA                                 Lba,
-  OUT       UINTN                                   *BlockSize,
-  OUT       UINTN                                   *NumberOfBlocks
-  );
-
-EFI_STATUS
-EFIAPI
-FvbRead(
-  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL     *This,
-  IN        EFI_LBA                                 Lba,
-  IN        UINTN                                   Offset,
-  IN OUT    UINTN                                   *NumBytes,
-  IN OUT    UINT8                                   *Buffer
-  );
-
-EFI_STATUS
-EFIAPI
-FvbWrite(
-  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL     *This,
-  IN        EFI_LBA                                 Lba,
-  IN        UINTN                                   Offset,
-  IN OUT    UINTN                                   *NumBytes,
-  IN        UINT8                                   *Buffer
-  );
-
-EFI_STATUS
-EFIAPI
-FvbEraseBlocks(
-  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL     *This,
-  ...
-  );
-
-//
-// NorFlashDxe.c
-//
-
-EFI_STATUS
-NorFlashUnlockAndEraseSingleBlock (
-  IN NOR_FLASH_INSTANCE     *Instance,
-  IN UINTN                  BlockAddress
-  );
-
-EFI_STATUS
-NorFlashWriteSingleBlock (
-  IN NOR_FLASH_INSTANCE     *Instance,
-  IN EFI_LBA                Lba,
-  IN UINT32                 *DataBuffer,
-  IN UINT32                 BlockSizeInWords
-  );
-
-EFI_STATUS
-NorFlashWriteBlocks (
-  IN  NOR_FLASH_INSTANCE *Instance,
-  IN  EFI_LBA           Lba,
-  IN  UINTN             BufferSizeInBytes,
-  IN  VOID              *Buffer
-  );
-
-EFI_STATUS
-NorFlashReadBlocks (
-  IN NOR_FLASH_INSTANCE   *Instance,
-  IN EFI_LBA              Lba,
-  IN UINTN                BufferSizeInBytes,
-  OUT VOID                *Buffer
-  );
-
-EFI_STATUS
-NorFlashReset (
-  IN  NOR_FLASH_INSTANCE *Instance
-  );
-
-#endif /* __NOR_FLASH_DXE_H__ */
+/** @file  NorFlashDxe.h

+

+  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __NOR_FLASH_DXE_H__

+#define __NOR_FLASH_DXE_H__

+

+

+#include <Base.h>

+#include <PiDxe.h>

+

+#include <Protocol/BlockIo.h>

+#include <Protocol/FirmwareVolumeBlock.h>

+

+#include <Library/DebugLib.h>

+#include <Library/IoLib.h>

+#include <Library/NorFlashPlatformLib.h>

+#include <Library/UefiLib.h>

+

+#define NOR_FLASH_ERASE_RETRY                     10

+

+// Device access macros

+// These are necessary because we use 2 x 16bit parts to make up 32bit data

+

+#define HIGH_16_BITS                              0xFFFF0000

+#define LOW_16_BITS                               0x0000FFFF

+#define LOW_8_BITS                                0x000000FF

+

+#define FOLD_32BIT_INTO_16BIT(value)              ( ( value >> 16 ) | ( value & LOW_16_BITS ) )

+

+#define GET_LOW_BYTE(value)                       ( value & LOW_8_BITS )

+#define GET_HIGH_BYTE(value)                      ( GET_LOW_BYTE( value >> 16 ) )

+

+// Each command must be sent simultaneously to both chips,

+// i.e. at the lower 16 bits AND at the higher 16 bits

+#define CREATE_NOR_ADDRESS(BaseAddr,OffsetAddr)   ((BaseAddr) + ((OffsetAddr) << 2))

+#define CREATE_DUAL_CMD(Cmd)                      ( ( Cmd << 16) | ( Cmd & LOW_16_BITS) )

+#define SEND_NOR_COMMAND(BaseAddr,Offset,Cmd) MmioWrite32 (CREATE_NOR_ADDRESS(BaseAddr,Offset), CREATE_DUAL_CMD(Cmd))

+#define GET_NOR_BLOCK_ADDRESS(BaseAddr,Lba,LbaSize)( BaseAddr + (UINTN)((Lba) * LbaSize) )

+

+// Status Register Bits

+#define P30_SR_BIT_WRITE                          (BIT7 << 16 | BIT7)

+#define P30_SR_BIT_ERASE_SUSPEND                  (BIT6 << 16 | BIT6)

+#define P30_SR_BIT_ERASE                          (BIT5 << 16 | BIT5)

+#define P30_SR_BIT_PROGRAM                        (BIT4 << 16 | BIT4)

+#define P30_SR_BIT_VPP                            (BIT3 << 16 | BIT3)

+#define P30_SR_BIT_PROGRAM_SUSPEND                (BIT2 << 16 | BIT2)

+#define P30_SR_BIT_BLOCK_LOCKED                   (BIT1 << 16 | BIT1)

+#define P30_SR_BIT_BEFP                           (BIT0 << 16 | BIT0)

+

+// Device Commands for Intel StrataFlash(R) Embedded Memory (P30) Family

+

+// On chip buffer size for buffered programming operations

+// There are 2 chips, each chip can buffer up to 32 (16-bit)words, and each word is 2 bytes.

+// Therefore the total size of the buffer is 2 x 32 x 2 = 128 bytes

+#define P30_MAX_BUFFER_SIZE_IN_BYTES              ((UINTN)128)

+#define P30_MAX_BUFFER_SIZE_IN_WORDS              (P30_MAX_BUFFER_SIZE_IN_BYTES/((UINTN)4))

+#define MAX_BUFFERED_PROG_ITERATIONS              10000000

+#define BOUNDARY_OF_32_WORDS                      0x7F

+

+// CFI Addresses

+#define P30_CFI_ADDR_QUERY_UNIQUE_QRY             0x10

+#define P30_CFI_ADDR_VENDOR_ID                    0x13

+

+// CFI Data

+#define CFI_QRY                                   0x00595251

+

+// READ Commands

+#define P30_CMD_READ_DEVICE_ID                    0x0090

+#define P30_CMD_READ_STATUS_REGISTER              0x0070

+#define P30_CMD_CLEAR_STATUS_REGISTER             0x0050

+#define P30_CMD_READ_ARRAY                        0x00FF

+#define P30_CMD_READ_CFI_QUERY                    0x0098

+

+// WRITE Commands

+#define P30_CMD_WORD_PROGRAM_SETUP                0x0040

+#define P30_CMD_ALTERNATE_WORD_PROGRAM_SETUP      0x0010

+#define P30_CMD_BUFFERED_PROGRAM_SETUP            0x00E8

+#define P30_CMD_BUFFERED_PROGRAM_CONFIRM          0x00D0

+#define P30_CMD_BEFP_SETUP                        0x0080

+#define P30_CMD_BEFP_CONFIRM                      0x00D0

+

+// ERASE Commands

+#define P30_CMD_BLOCK_ERASE_SETUP                 0x0020

+#define P30_CMD_BLOCK_ERASE_CONFIRM               0x00D0

+

+// SUSPEND Commands

+#define P30_CMD_PROGRAM_OR_ERASE_SUSPEND          0x00B0

+#define P30_CMD_SUSPEND_RESUME                    0x00D0

+

+// BLOCK LOCKING / UNLOCKING Commands

+#define P30_CMD_LOCK_BLOCK_SETUP                  0x0060

+#define P30_CMD_LOCK_BLOCK                        0x0001

+#define P30_CMD_UNLOCK_BLOCK                      0x00D0

+#define P30_CMD_LOCK_DOWN_BLOCK                   0x002F

+

+// PROTECTION Commands

+#define P30_CMD_PROGRAM_PROTECTION_REGISTER_SETUP 0x00C0

+

+// CONFIGURATION Commands

+#define P30_CMD_READ_CONFIGURATION_REGISTER_SETUP 0x0060

+#define P30_CMD_READ_CONFIGURATION_REGISTER       0x0003

+

+#define NOR_FLASH_SIGNATURE                       SIGNATURE_32('n', 'o', 'r', '0')

+#define INSTANCE_FROM_FVB_THIS(a)                 CR(a, NOR_FLASH_INSTANCE, FvbProtocol, NOR_FLASH_SIGNATURE)

+#define INSTANCE_FROM_BLKIO_THIS(a)               CR(a, NOR_FLASH_INSTANCE, BlockIoProtocol, NOR_FLASH_SIGNATURE)

+

+typedef struct _NOR_FLASH_INSTANCE                NOR_FLASH_INSTANCE;

+

+typedef EFI_STATUS (*NOR_FLASH_INITIALIZE)        (NOR_FLASH_INSTANCE* Instance);

+

+typedef struct {

+  VENDOR_DEVICE_PATH                  Vendor;

+  EFI_DEVICE_PATH_PROTOCOL            End;

+} NOR_FLASH_DEVICE_PATH;

+

+struct _NOR_FLASH_INSTANCE {

+  UINT32                              Signature;

+  EFI_HANDLE                          Handle;

+

+  BOOLEAN                             Initialized;

+  NOR_FLASH_INITIALIZE                Initialize;

+

+  UINTN                               DeviceBaseAddress;

+  UINTN                               RegionBaseAddress;

+  UINTN                               Size;

+  EFI_LBA                             StartLba;

+

+  EFI_BLOCK_IO_PROTOCOL               BlockIoProtocol;

+  EFI_BLOCK_IO_MEDIA                  Media;

+

+  BOOLEAN                             SupportFvb;

+  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL FvbProtocol;

+

+  NOR_FLASH_DEVICE_PATH	              DevicePath;

+};

+

+EFI_STATUS

+NorFlashReadCfiData (

+  IN  UINTN                   DeviceBaseAddress,

+  IN  UINTN                   CFI_Offset,

+  IN  UINT32                  NumberOfBytes,

+  OUT UINT32                  *Data

+  );

+

+EFI_STATUS

+NorFlashWriteBuffer (

+  IN NOR_FLASH_INSTANCE     *Instance,

+  IN UINTN                  TargetAddress,

+  IN UINTN                  BufferSizeInBytes,

+  IN UINT32                 *Buffer

+  );

+

+//

+// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.Reset

+//

+EFI_STATUS

+EFIAPI

+NorFlashBlockIoReset (

+  IN EFI_BLOCK_IO_PROTOCOL    *This,

+  IN BOOLEAN                  ExtendedVerification

+  );

+

+//

+// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.ReadBlocks

+//

+EFI_STATUS

+EFIAPI

+NorFlashBlockIoReadBlocks (

+  IN  EFI_BLOCK_IO_PROTOCOL   *This,

+  IN  UINT32                  MediaId,

+  IN  EFI_LBA                 Lba,

+  IN  UINTN                   BufferSizeInBytes,

+  OUT VOID                    *Buffer

+);

+

+//

+// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.WriteBlocks

+//

+EFI_STATUS

+EFIAPI

+NorFlashBlockIoWriteBlocks (

+  IN  EFI_BLOCK_IO_PROTOCOL   *This,

+  IN  UINT32                  MediaId,

+  IN  EFI_LBA                 Lba,

+  IN  UINTN                   BufferSizeInBytes,

+  IN  VOID                    *Buffer

+);

+

+//

+// BlockIO Protocol function EFI_BLOCK_IO_PROTOCOL.FlushBlocks

+//

+EFI_STATUS

+EFIAPI

+NorFlashBlockIoFlushBlocks (

+  IN EFI_BLOCK_IO_PROTOCOL    *This

+);

+

+

+//

+// NorFlashFvbDxe.c

+//

+

+EFI_STATUS

+EFIAPI

+NorFlashFvbInitialize (

+  IN NOR_FLASH_INSTANCE*                            Instance

+  );

+

+EFI_STATUS

+EFIAPI

+FvbGetAttributes(

+  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL     *This,

+  OUT       EFI_FVB_ATTRIBUTES_2                    *Attributes

+  );

+

+EFI_STATUS

+EFIAPI

+FvbSetAttributes(

+  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL     *This,

+  IN OUT    EFI_FVB_ATTRIBUTES_2                    *Attributes

+  );

+

+EFI_STATUS

+EFIAPI

+FvbGetPhysicalAddress(

+  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL     *This,

+  OUT       EFI_PHYSICAL_ADDRESS                    *Address

+  );

+

+EFI_STATUS

+EFIAPI

+FvbGetBlockSize(

+  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL     *This,

+  IN        EFI_LBA                                 Lba,

+  OUT       UINTN                                   *BlockSize,

+  OUT       UINTN                                   *NumberOfBlocks

+  );

+

+EFI_STATUS

+EFIAPI

+FvbRead(

+  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL     *This,

+  IN        EFI_LBA                                 Lba,

+  IN        UINTN                                   Offset,

+  IN OUT    UINTN                                   *NumBytes,

+  IN OUT    UINT8                                   *Buffer

+  );

+

+EFI_STATUS

+EFIAPI

+FvbWrite(

+  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL     *This,

+  IN        EFI_LBA                                 Lba,

+  IN        UINTN                                   Offset,

+  IN OUT    UINTN                                   *NumBytes,

+  IN        UINT8                                   *Buffer

+  );

+

+EFI_STATUS

+EFIAPI

+FvbEraseBlocks(

+  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL     *This,

+  ...

+  );

+

+//

+// NorFlashDxe.c

+//

+

+EFI_STATUS

+NorFlashUnlockAndEraseSingleBlock (

+  IN NOR_FLASH_INSTANCE     *Instance,

+  IN UINTN                  BlockAddress

+  );

+

+EFI_STATUS

+NorFlashWriteSingleBlock (

+  IN NOR_FLASH_INSTANCE     *Instance,

+  IN EFI_LBA                Lba,

+  IN UINT32                 *DataBuffer,

+  IN UINT32                 BlockSizeInWords

+  );

+

+EFI_STATUS

+NorFlashWriteBlocks (

+  IN  NOR_FLASH_INSTANCE *Instance,

+  IN  EFI_LBA           Lba,

+  IN  UINTN             BufferSizeInBytes,

+  IN  VOID              *Buffer

+  );

+

+EFI_STATUS

+NorFlashReadBlocks (

+  IN NOR_FLASH_INSTANCE   *Instance,

+  IN EFI_LBA              Lba,

+  IN UINTN                BufferSizeInBytes,

+  OUT VOID                *Buffer

+  );

+

+EFI_STATUS

+NorFlashReset (

+  IN  NOR_FLASH_INSTANCE *Instance

+  );

+

+#endif /* __NOR_FLASH_DXE_H__ */

diff --git a/ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashDxe.inf b/ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashDxe.inf
index d32f0f79..97c66008 100644
--- a/ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashDxe.inf
+++ b/ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashDxe.inf
@@ -1,68 +1,68 @@
-#/** @file
-#  
-#  Component description file for NorFlashDxe module
-#  
-#  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>
-#  
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = ArmVeNorFlashDxe
-  FILE_GUID                      = 93E34C7E-B50E-11DF-9223-2443DFD72085
-  MODULE_TYPE                    = DXE_DRIVER
-  VERSION_STRING                 = 1.0
-  ENTRY_POINT                    = NorFlashInitialise
-
-[Sources.common]
-  NorFlashDxe.c
-  NorFlashFvbDxe.c
-  NorFlashBlockIoDxe.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  MdeModulePkg/MdeModulePkg.dec
-  ArmPlatformPkg/ArmPlatformPkg.dec
-
-[LibraryClasses]
-  IoLib
-  BaseLib
-  DebugLib
-  HobLib
-  NorFlashPlatformLib
-  UefiLib
-  UefiDriverEntryPoint
-  UefiBootServicesTableLib
-
-[Guids]
-  gEfiSystemNvDataFvGuid
-  gEfiVariableGuid
-
-[Protocols]
-  gEfiBlockIoProtocolGuid
-  gEfiDevicePathProtocolGuid
-  gEfiFirmwareVolumeBlockProtocolGuid
-  
-[Pcd.common]
-  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase
-  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableSize
-  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingBase
-  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingSize
-  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareBase
-  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareSize
-  
-  gArmPlatformTokenSpaceGuid.PcdNorFlashCheckBlockLocked
-
-[Depex]
-  #
-  # NorFlashDxe must be loaded before VariableRuntimeDxe in case empty flash needs populating with default values
-  # 
-  BEFORE gVariableRuntimeDxeFileGuid 
+#/** @file

+#  

+#  Component description file for NorFlashDxe module

+#  

+#  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>

+#  

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = ArmVeNorFlashDxe

+  FILE_GUID                      = 93E34C7E-B50E-11DF-9223-2443DFD72085

+  MODULE_TYPE                    = DXE_DRIVER

+  VERSION_STRING                 = 1.0

+  ENTRY_POINT                    = NorFlashInitialise

+

+[Sources.common]

+  NorFlashDxe.c

+  NorFlashFvbDxe.c

+  NorFlashBlockIoDxe.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  MdeModulePkg/MdeModulePkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+

+[LibraryClasses]

+  IoLib

+  BaseLib

+  DebugLib

+  HobLib

+  NorFlashPlatformLib

+  UefiLib

+  UefiDriverEntryPoint

+  UefiBootServicesTableLib

+

+[Guids]

+  gEfiSystemNvDataFvGuid

+  gEfiVariableGuid

+

+[Protocols]

+  gEfiBlockIoProtocolGuid

+  gEfiDevicePathProtocolGuid

+  gEfiFirmwareVolumeBlockProtocolGuid

+  

+[Pcd.common]

+  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase

+  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableSize

+  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingBase

+  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingSize

+  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareBase

+  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareSize

+  

+  gArmPlatformTokenSpaceGuid.PcdNorFlashCheckBlockLocked

+

+[Depex]

+  #

+  # NorFlashDxe must be loaded before VariableRuntimeDxe in case empty flash needs populating with default values

+  # 

+  BEFORE gVariableRuntimeDxeFileGuid 

diff --git a/ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashFvbDxe.c b/ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashFvbDxe.c
index 29de9648..ab6304ba 100644
--- a/ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashFvbDxe.c
+++ b/ArmPlatformPkg/Drivers/NorFlashDxe/NorFlashFvbDxe.c
@@ -1,812 +1,812 @@
-/*++ @file  NorFlashFvbDxe.c
-
- Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>
-
- This program and the accompanying materials
- are licensed and made available under the terms and conditions of the BSD License
- which accompanies this distribution.  The full text of the license may be found at
- http://opensource.org/licenses/bsd-license.php
-
- THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
- WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
- --*/
-
-#include <PiDxe.h>
-
-#include <Library/PcdLib.h>
-#include <Library/BaseLib.h>
-#include <Library/HobLib.h>
-#include <Library/UefiLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/MemoryAllocationLib.h>
-#include <Library/UefiBootServicesTableLib.h>
-
-#include <Guid/VariableFormat.h>
-#include <Guid/SystemNvDataGuid.h>
-
-#include "NorFlashDxe.h"
-
-
-///
-/// The Firmware Volume Block Protocol is the low-level interface
-/// to a firmware volume. File-level access to a firmware volume
-/// should not be done using the Firmware Volume Block Protocol.
-/// Normal access to a firmware volume must use the Firmware
-/// Volume Protocol. Typically, only the file system driver that
-/// produces the Firmware Volume Protocol will bind to the
-/// Firmware Volume Block Protocol.
-///
-
-/**
-  Initialises the FV Header and Variable Store Header
-  to support variable operations.
-
-  @param[in]  Ptr - Location to initialise the headers
-
-**/
-EFI_STATUS
-InitializeFvAndVariableStoreHeaders (
-  IN NOR_FLASH_INSTANCE *Instance
-  )
-{
-  EFI_STATUS                          Status;
-  VOID*                               Headers;
-  UINTN                               HeadersLength;
-  EFI_FIRMWARE_VOLUME_HEADER          *FirmwareVolumeHeader;
-  VARIABLE_STORE_HEADER               *VariableStoreHeader;
-
-  if (!Instance->Initialized && Instance->Initialize) {
-    Instance->Initialize (Instance);
-  }
-
-  HeadersLength = sizeof(EFI_FIRMWARE_VOLUME_HEADER) + sizeof(EFI_FV_BLOCK_MAP_ENTRY) + sizeof(VARIABLE_STORE_HEADER);
-  Headers = AllocateZeroPool(HeadersLength);
-
-  // FirmwareVolumeHeader->FvLength is declared to have the Variable area AND the FTW working area AND the FTW Spare contiguous.
-  ASSERT(PcdGet32(PcdFlashNvStorageVariableBase) + PcdGet32(PcdFlashNvStorageVariableSize) == PcdGet32(PcdFlashNvStorageFtwWorkingBase));
-  ASSERT(PcdGet32(PcdFlashNvStorageFtwWorkingBase) + PcdGet32(PcdFlashNvStorageFtwWorkingSize) == PcdGet32(PcdFlashNvStorageFtwSpareBase));
-
-  // Check if the size of the area is at least one block size
-  ASSERT((PcdGet32(PcdFlashNvStorageVariableSize) > 0) && (PcdGet32(PcdFlashNvStorageVariableSize) / Instance->Media.BlockSize > 0));
-  ASSERT((PcdGet32(PcdFlashNvStorageFtwWorkingSize) > 0) && (PcdGet32(PcdFlashNvStorageFtwWorkingSize) / Instance->Media.BlockSize > 0));
-  ASSERT((PcdGet32(PcdFlashNvStorageFtwSpareSize) > 0) && (PcdGet32(PcdFlashNvStorageFtwSpareSize) / Instance->Media.BlockSize > 0));
-
-  // Ensure the Variable area Base Addresses are aligned on a block size boundaries
-  ASSERT(PcdGet32(PcdFlashNvStorageVariableBase) % Instance->Media.BlockSize == 0);
-  ASSERT(PcdGet32(PcdFlashNvStorageFtwWorkingBase) % Instance->Media.BlockSize == 0);
-  ASSERT(PcdGet32(PcdFlashNvStorageFtwSpareBase) % Instance->Media.BlockSize == 0);
-
-  //
-  // EFI_FIRMWARE_VOLUME_HEADER
-  //
-  FirmwareVolumeHeader = (EFI_FIRMWARE_VOLUME_HEADER*)Headers;
-  CopyGuid (&FirmwareVolumeHeader->FileSystemGuid, &gEfiSystemNvDataFvGuid);
-  FirmwareVolumeHeader->FvLength =
-      PcdGet32(PcdFlashNvStorageVariableSize) +
-      PcdGet32(PcdFlashNvStorageFtwWorkingSize) +
-      PcdGet32(PcdFlashNvStorageFtwSpareSize);
-  FirmwareVolumeHeader->Signature = EFI_FVH_SIGNATURE;
-  FirmwareVolumeHeader->Attributes = (EFI_FVB_ATTRIBUTES_2) (
-                                          EFI_FVB2_READ_ENABLED_CAP   | // Reads may be enabled
-                                          EFI_FVB2_READ_STATUS        | // Reads are currently enabled
-                                          EFI_FVB2_STICKY_WRITE       | // A block erase is required to flip bits into EFI_FVB2_ERASE_POLARITY
-                                          EFI_FVB2_MEMORY_MAPPED      | // It is memory mapped
-                                          EFI_FVB2_ERASE_POLARITY     | // After erasure all bits take this value (i.e. '1')
-                                          EFI_FVB2_WRITE_STATUS       | // Writes are currently enabled
-                                          EFI_FVB2_WRITE_ENABLED_CAP    // Writes may be enabled
-                                      );
-  FirmwareVolumeHeader->HeaderLength = sizeof(EFI_FIRMWARE_VOLUME_HEADER) + sizeof(EFI_FV_BLOCK_MAP_ENTRY);
-  FirmwareVolumeHeader->Revision = EFI_FVH_REVISION;
-  FirmwareVolumeHeader->BlockMap[0].NumBlocks = Instance->Media.LastBlock + 1;
-  FirmwareVolumeHeader->BlockMap[0].Length      = Instance->Media.BlockSize;
-  FirmwareVolumeHeader->BlockMap[1].NumBlocks = 0;
-  FirmwareVolumeHeader->BlockMap[1].Length      = 0;
-  FirmwareVolumeHeader->Checksum = CalculateCheckSum16 ((UINT16*)FirmwareVolumeHeader,FirmwareVolumeHeader->HeaderLength);
-
-  //
-  // VARIABLE_STORE_HEADER
-  //
-  VariableStoreHeader = (VARIABLE_STORE_HEADER*)((UINT32)Headers + FirmwareVolumeHeader->HeaderLength);
-  CopyGuid (&VariableStoreHeader->Signature, &gEfiVariableGuid);
-  VariableStoreHeader->Size = PcdGet32(PcdFlashNvStorageVariableSize) - FirmwareVolumeHeader->HeaderLength;
-  VariableStoreHeader->Format            = VARIABLE_STORE_FORMATTED;
-  VariableStoreHeader->State             = VARIABLE_STORE_HEALTHY;
-
-  // Install the combined super-header in the NorFlash
-  Status = FvbWrite (&Instance->FvbProtocol, 0, 0, &HeadersLength, Headers);
-
-  FreePool (Headers);
-  return Status;
-}
-
-/**
-  Check the integrity of firmware volume header.
-
-  @param[in] FwVolHeader - A pointer to a firmware volume header
-
-  @retval  EFI_SUCCESS   - The firmware volume is consistent
-  @retval  EFI_NOT_FOUND - The firmware volume has been corrupted.
-
-**/
-EFI_STATUS
-ValidateFvHeader (
-  IN  NOR_FLASH_INSTANCE *Instance
-  )
-{
-  UINT16                      Checksum;
-  EFI_FIRMWARE_VOLUME_HEADER  *FwVolHeader;
-  VARIABLE_STORE_HEADER       *VariableStoreHeader;
-  UINTN                       VariableStoreLength;
-  UINTN						  FvLength;
-
-  FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER*)Instance->RegionBaseAddress;
-
-  FvLength = PcdGet32(PcdFlashNvStorageVariableSize) + PcdGet32(PcdFlashNvStorageFtwWorkingSize) +
-      PcdGet32(PcdFlashNvStorageFtwSpareSize);
-
-  //
-  // Verify the header revision, header signature, length
-  // Length of FvBlock cannot be 2**64-1
-  // HeaderLength cannot be an odd number
-  //
-  if (   (FwVolHeader->Revision  != EFI_FVH_REVISION)
-      || (FwVolHeader->Signature != EFI_FVH_SIGNATURE)
-      || (FwVolHeader->FvLength  != FvLength)
-      )
-  {
-    DEBUG ((EFI_D_ERROR, "ValidateFvHeader: No Firmware Volume header present\n"));
-    return EFI_NOT_FOUND;
-  }
-
-  // Check the Firmware Volume Guid
-  if( CompareGuid (&FwVolHeader->FileSystemGuid, &gEfiSystemNvDataFvGuid) == FALSE ) {
-    DEBUG ((EFI_D_ERROR, "ValidateFvHeader: Firmware Volume Guid non-compatible\n"));
-    return EFI_NOT_FOUND;
-  }
-
-  // Verify the header checksum
-  Checksum = CalculateSum16((UINT16*)FwVolHeader, FwVolHeader->HeaderLength);
-  if (Checksum != 0) {
-    DEBUG ((EFI_D_ERROR, "ValidateFvHeader: FV checksum is invalid (Checksum:0x%X)\n",Checksum));
-    return EFI_NOT_FOUND;
-  }
-
-  VariableStoreHeader = (VARIABLE_STORE_HEADER*)((UINT32)FwVolHeader + FwVolHeader->HeaderLength);
-
-  // Check the Variable Store Guid
-  if( CompareGuid (&VariableStoreHeader->Signature, &gEfiVariableGuid) == FALSE ) {
-    DEBUG ((EFI_D_ERROR, "ValidateFvHeader: Variable Store Guid non-compatible\n"));
-    return EFI_NOT_FOUND;
-  }
-
-  VariableStoreLength = PcdGet32 (PcdFlashNvStorageVariableSize) - FwVolHeader->HeaderLength;
-  if (VariableStoreHeader->Size != VariableStoreLength) {
-    DEBUG ((EFI_D_ERROR, "ValidateFvHeader: Variable Store Length does not match\n"));
-    return EFI_NOT_FOUND;
-  }
-
-  return EFI_SUCCESS;
-}
-
-/**
- The GetAttributes() function retrieves the attributes and
- current settings of the block.
-
- @param This         Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.
-
- @param Attributes   Pointer to EFI_FVB_ATTRIBUTES_2 in which the attributes and
-                     current settings are returned.
-                     Type EFI_FVB_ATTRIBUTES_2 is defined in EFI_FIRMWARE_VOLUME_HEADER.
-
- @retval EFI_SUCCESS The firmware volume attributes were returned.
-
- **/
-EFI_STATUS
-EFIAPI
-FvbGetAttributes(
-  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL    *This,
-  OUT       EFI_FVB_ATTRIBUTES_2                   *Attributes
-  )
-{
-  EFI_FVB_ATTRIBUTES_2  FlashFvbAttributes;
-  NOR_FLASH_INSTANCE *Instance;
-
-  Instance = INSTANCE_FROM_FVB_THIS(This);
-
-  FlashFvbAttributes = (EFI_FVB_ATTRIBUTES_2) (
-
-      EFI_FVB2_READ_ENABLED_CAP | // Reads may be enabled
-      EFI_FVB2_READ_STATUS      | // Reads are currently enabled
-      EFI_FVB2_STICKY_WRITE     | // A block erase is required to flip bits into EFI_FVB2_ERASE_POLARITY
-      EFI_FVB2_MEMORY_MAPPED    | // It is memory mapped
-      EFI_FVB2_ERASE_POLARITY     // After erasure all bits take this value (i.e. '1')
-
-      );
-
-  // Check if it is write protected
-  if (Instance->Media.ReadOnly != TRUE) {
-
-    FlashFvbAttributes = FlashFvbAttributes         |
-                         EFI_FVB2_WRITE_STATUS      | // Writes are currently enabled
-                         EFI_FVB2_WRITE_ENABLED_CAP;  // Writes may be enabled
-  }
-
-  *Attributes = FlashFvbAttributes;
-
-  DEBUG ((DEBUG_BLKIO, "FvbGetAttributes(0x%X)\n", *Attributes));
-
-  return EFI_SUCCESS;
-}
-
-/**
- The SetAttributes() function sets configurable firmware volume attributes
- and returns the new settings of the firmware volume.
-
-
- @param This                     Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.
-
- @param Attributes               On input, Attributes is a pointer to EFI_FVB_ATTRIBUTES_2
-                                 that contains the desired firmware volume settings.
-                                 On successful return, it contains the new settings of
-                                 the firmware volume.
-                                 Type EFI_FVB_ATTRIBUTES_2 is defined in EFI_FIRMWARE_VOLUME_HEADER.
-
- @retval EFI_SUCCESS             The firmware volume attributes were returned.
-
- @retval EFI_INVALID_PARAMETER   The attributes requested are in conflict with the capabilities
-                                 as declared in the firmware volume header.
-
- **/
-EFI_STATUS
-EFIAPI
-FvbSetAttributes(
-  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL  *This,
-  IN OUT    EFI_FVB_ATTRIBUTES_2                 *Attributes
-  )
-{
-  DEBUG ((DEBUG_BLKIO, "FvbSetAttributes(0x%X) is not supported\n",*Attributes));
-  return EFI_UNSUPPORTED;
-}
-
-/**
- The GetPhysicalAddress() function retrieves the base address of
- a memory-mapped firmware volume. This function should be called
- only for memory-mapped firmware volumes.
-
- @param This               Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.
-
- @param Address            Pointer to a caller-allocated
-                           EFI_PHYSICAL_ADDRESS that, on successful
-                           return from GetPhysicalAddress(), contains the
-                           base address of the firmware volume.
-
- @retval EFI_SUCCESS       The firmware volume base address was returned.
-
- @retval EFI_NOT_SUPPORTED The firmware volume is not memory mapped.
-
- **/
-EFI_STATUS
-EFIAPI
-FvbGetPhysicalAddress (
-  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL  *This,
-  OUT       EFI_PHYSICAL_ADDRESS                 *Address
-  )
-{
-  NOR_FLASH_INSTANCE *Instance;
-
-  Instance = INSTANCE_FROM_FVB_THIS(This);
-
-  DEBUG ((DEBUG_BLKIO, "FvbGetPhysicalAddress(BaseAddress=0x%08x)\n", Instance->RegionBaseAddress));
-
-  ASSERT(Address != NULL);
-
-  *Address = PcdGet32 (PcdFlashNvStorageVariableBase);
-  return EFI_SUCCESS;
-}
-
-/**
- The GetBlockSize() function retrieves the size of the requested
- block. It also returns the number of additional blocks with
- the identical size. The GetBlockSize() function is used to
- retrieve the block map (see EFI_FIRMWARE_VOLUME_HEADER).
-
-
- @param This                     Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.
-
- @param Lba                      Indicates the block for which to return the size.
-
- @param BlockSize                Pointer to a caller-allocated UINTN in which
-                                 the size of the block is returned.
-
- @param NumberOfBlocks           Pointer to a caller-allocated UINTN in
-                                 which the number of consecutive blocks,
-                                 starting with Lba, is returned. All
-                                 blocks in this range have a size of
-                                 BlockSize.
-
-
- @retval EFI_SUCCESS             The firmware volume base address was returned.
-
- @retval EFI_INVALID_PARAMETER   The requested LBA is out of range.
-
- **/
-EFI_STATUS
-EFIAPI
-FvbGetBlockSize (
-  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL  *This,
-  IN        EFI_LBA                              Lba,
-  OUT       UINTN                                *BlockSize,
-  OUT       UINTN                                *NumberOfBlocks
-  )
-{
-  EFI_STATUS Status;
-  NOR_FLASH_INSTANCE *Instance;
-
-  Instance = INSTANCE_FROM_FVB_THIS(This);
-
-  DEBUG ((DEBUG_BLKIO, "FvbGetBlockSize(Lba=%ld, BlockSize=0x%x, LastBlock=%ld)\n", Lba, Instance->Media.BlockSize, Instance->Media.LastBlock));
-
-  if (Lba > Instance->Media.LastBlock) {
-    DEBUG ((EFI_D_ERROR, "FvbGetBlockSize: ERROR - Parameter LBA %ld is beyond the last Lba (%ld).\n", Lba, Instance->Media.LastBlock));
-    Status = EFI_INVALID_PARAMETER;
-  } else {
-    // This is easy because in this platform each NorFlash device has equal sized blocks.
-    *BlockSize = (UINTN) Instance->Media.BlockSize;
-    *NumberOfBlocks = (UINTN) (Instance->Media.LastBlock - Lba + 1);
-
-    DEBUG ((DEBUG_BLKIO, "FvbGetBlockSize: *BlockSize=0x%x, *NumberOfBlocks=0x%x.\n", *BlockSize, *NumberOfBlocks));
-
-    Status = EFI_SUCCESS;
-  }
-
-  return Status;
-}
-
-/**
- Reads the specified number of bytes into a buffer from the specified block.
-
- The Read() function reads the requested number of bytes from the
- requested block and stores them in the provided buffer.
- Implementations should be mindful that the firmware volume
- might be in the ReadDisabled state. If it is in this state,
- the Read() function must return the status code
- EFI_ACCESS_DENIED without modifying the contents of the
- buffer. The Read() function must also prevent spanning block
- boundaries. If a read is requested that would span a block
- boundary, the read must read up to the boundary but not
- beyond. The output parameter NumBytes must be set to correctly
- indicate the number of bytes actually read. The caller must be
- aware that a read may be partially completed.
-
- @param This                 Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.
-
- @param Lba                  The starting logical block index from which to read.
-
- @param Offset               Offset into the block at which to begin reading.
-
- @param NumBytes             Pointer to a UINTN.
-                             At entry, *NumBytes contains the total size of the buffer.
-                             At exit, *NumBytes contains the total number of bytes read.
-
- @param Buffer               Pointer to a caller-allocated buffer that will be used
-                             to hold the data that is read.
-
- @retval EFI_SUCCESS         The firmware volume was read successfully,  and contents are
-                             in Buffer.
-
- @retval EFI_BAD_BUFFER_SIZE Read attempted across an LBA boundary.
-                             On output, NumBytes contains the total number of bytes
-                             returned in Buffer.
-
- @retval EFI_ACCESS_DENIED   The firmware volume is in the ReadDisabled state.
-
- @retval EFI_DEVICE_ERROR    The block device is not functioning correctly and could not be read.
-
- **/
-EFI_STATUS
-EFIAPI
-FvbRead (
-  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL   *This,
-  IN        EFI_LBA                               Lba,
-  IN        UINTN                                 Offset,
-  IN OUT    UINTN                                 *NumBytes,
-  IN OUT    UINT8                                 *Buffer
-  )
-{
-  EFI_STATUS    Status;
-  EFI_STATUS    TempStatus;
-  UINTN         BlockSize;
-  UINT8         *BlockBuffer;
-  NOR_FLASH_INSTANCE *Instance;
-
-  Instance = INSTANCE_FROM_FVB_THIS(This);
-
-  DEBUG ((DEBUG_BLKIO, "FvbRead(Parameters: Lba=%ld, Offset=0x%x, *NumBytes=0x%x, Buffer @ 0x%08x)\n", Instance->StartLba + Lba, Offset, *NumBytes, Buffer));
-
-  if (!Instance->Initialized && Instance->Initialize) {
-    Instance->Initialize(Instance);
-  }
-
-  Status = EFI_SUCCESS;
-  TempStatus = Status;
-
-  // Cache the block size to avoid de-referencing pointers all the time
-  BlockSize = Instance->Media.BlockSize;
-
-  DEBUG ((DEBUG_BLKIO, "FvbRead: Check if (Offset=0x%x + NumBytes=0x%x) <= BlockSize=0x%x\n", Offset, *NumBytes, BlockSize ));
-
-  // The read must not span block boundaries.
-  // We need to check each variable individually because adding two large values together overflows.
-  if ((Offset               >= BlockSize) ||
-      (*NumBytes            >  BlockSize) ||
-      ((Offset + *NumBytes) >  BlockSize)) {
-    DEBUG ((EFI_D_ERROR, "FvbRead: ERROR - EFI_BAD_BUFFER_SIZE: (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", Offset, *NumBytes, BlockSize ));
-    return EFI_BAD_BUFFER_SIZE;
-  }
-
-  // We must have some bytes to read
-  if (*NumBytes == 0) {
-    return EFI_BAD_BUFFER_SIZE;
-  }
-
-  // FixMe: Allow an arbitrary number of bytes to be read out, not just a multiple of block size.
-
-  // Allocate runtime memory to read in the NOR Flash data. Variable Services are runtime.
-  BlockBuffer = AllocateRuntimePool (BlockSize);
-
-  // Check if the memory allocation was successful
-  if (BlockBuffer == NULL) {
-    DEBUG ((EFI_D_ERROR, "FvbRead: ERROR - Could not allocate BlockBuffer @ 0x%08x.\n", BlockBuffer));
-    return EFI_DEVICE_ERROR;
-  }
-
-  // Read NOR Flash data into shadow buffer
-  TempStatus = NorFlashReadBlocks (Instance, Instance->StartLba + Lba, BlockSize, BlockBuffer);
-  if (EFI_ERROR (TempStatus)) {
-    // Return one of the pre-approved error statuses
-    Status = EFI_DEVICE_ERROR;
-    goto FREE_MEMORY;
-  }
-
-  // Put the data at the appropriate location inside the buffer area
-  DEBUG ((DEBUG_BLKIO, "FvbRead: CopyMem( Dst=0x%08x, Src=0x%08x, Size=0x%x ).\n", Buffer, BlockBuffer + Offset, *NumBytes));
-
-  CopyMem(Buffer, BlockBuffer + Offset, *NumBytes);
-
-FREE_MEMORY:
-  FreePool(BlockBuffer);
-  return Status;
-}
-
-/**
- Writes the specified number of bytes from the input buffer to the block.
-
- The Write() function writes the specified number of bytes from
- the provided buffer to the specified block and offset. If the
- firmware volume is sticky write, the caller must ensure that
- all the bits of the specified range to write are in the
- EFI_FVB_ERASE_POLARITY state before calling the Write()
- function, or else the result will be unpredictable. This
- unpredictability arises because, for a sticky-write firmware
- volume, a write may negate a bit in the EFI_FVB_ERASE_POLARITY
- state but cannot flip it back again.  Before calling the
- Write() function,  it is recommended for the caller to first call
- the EraseBlocks() function to erase the specified block to
- write. A block erase cycle will transition bits from the
- (NOT)EFI_FVB_ERASE_POLARITY state back to the
- EFI_FVB_ERASE_POLARITY state. Implementations should be
- mindful that the firmware volume might be in the WriteDisabled
- state. If it is in this state, the Write() function must
- return the status code EFI_ACCESS_DENIED without modifying the
- contents of the firmware volume. The Write() function must
- also prevent spanning block boundaries. If a write is
- requested that spans a block boundary, the write must store up
- to the boundary but not beyond. The output parameter NumBytes
- must be set to correctly indicate the number of bytes actually
- written. The caller must be aware that a write may be
- partially completed. All writes, partial or otherwise, must be
- fully flushed to the hardware before the Write() service
- returns.
-
- @param This                 Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.
-
- @param Lba                  The starting logical block index to write to.
-
- @param Offset               Offset into the block at which to begin writing.
-
- @param NumBytes             The pointer to a UINTN.
-                             At entry, *NumBytes contains the total size of the buffer.
-                             At exit, *NumBytes contains the total number of bytes actually written.
-
- @param Buffer               The pointer to a caller-allocated buffer that contains the source for the write.
-
- @retval EFI_SUCCESS         The firmware volume was written successfully.
-
- @retval EFI_BAD_BUFFER_SIZE The write was attempted across an LBA boundary.
-                             On output, NumBytes contains the total number of bytes
-                             actually written.
-
- @retval EFI_ACCESS_DENIED   The firmware volume is in the WriteDisabled state.
-
- @retval EFI_DEVICE_ERROR    The block device is malfunctioning and could not be written.
-
-
- **/
-EFI_STATUS
-EFIAPI
-FvbWrite (
-  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL   *This,
-  IN        EFI_LBA                               Lba,
-  IN        UINTN                                 Offset,
-  IN OUT    UINTN                                 *NumBytes,
-  IN        UINT8                                 *Buffer
-  )
-{
-  EFI_STATUS  Status;
-  EFI_STATUS  TempStatus;
-  UINTN       BlockSize;
-  UINT8       *BlockBuffer;
-  NOR_FLASH_INSTANCE *Instance;
-
-  Instance = INSTANCE_FROM_FVB_THIS(This);
-
-  if (!Instance->Initialized && Instance->Initialize) {
-    Instance->Initialize(Instance);
-  }
-
-  DEBUG ((DEBUG_BLKIO, "FvbWrite(Parameters: Lba=%ld, Offset=0x%x, *NumBytes=0x%x, Buffer @ 0x%08x)\n", Instance->StartLba + Lba, Offset, *NumBytes, Buffer));
-
-  Status = EFI_SUCCESS;
-  TempStatus = Status;
-
-  // Detect WriteDisabled state
-  if (Instance->Media.ReadOnly == TRUE) {
-    DEBUG ((EFI_D_ERROR, "FvbWrite: ERROR - Can not write: Device is in WriteDisabled state.\n"));
-    // It is in WriteDisabled state, return an error right away
-    return EFI_ACCESS_DENIED;
-  }
-
-  // Cache the block size to avoid de-referencing pointers all the time
-  BlockSize = Instance->Media.BlockSize;
-
-  // The write must not span block boundaries.
-  // We need to check each variable individually because adding two large values together overflows.
-  if ( ( Offset               >= BlockSize ) ||
-       ( *NumBytes            >  BlockSize ) ||
-       ( (Offset + *NumBytes) >  BlockSize )    ) {
-    DEBUG ((EFI_D_ERROR, "FvbWrite: ERROR - EFI_BAD_BUFFER_SIZE: (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", Offset, *NumBytes, BlockSize ));
-    return EFI_BAD_BUFFER_SIZE;
-  }
-
-  // We must have some bytes to write
-  if (*NumBytes == 0) {
-    DEBUG ((EFI_D_ERROR, "FvbWrite: ERROR - EFI_BAD_BUFFER_SIZE: (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", Offset, *NumBytes, BlockSize ));
-    return EFI_BAD_BUFFER_SIZE;
-  }
-
-  // Allocate runtime memory to read in the NOR Flash data.
-  // Since the intention is to use this with Variable Services and since these are runtime,
-  // allocate the memory from the runtime pool.
-  BlockBuffer = AllocateRuntimePool (BlockSize);
-
-  // Check we did get some memory
-  if( BlockBuffer == NULL ) {
-    DEBUG ((EFI_D_ERROR, "FvbWrite: ERROR - Can not allocate BlockBuffer @ 0x%08x.\n", BlockBuffer));
-    return EFI_DEVICE_ERROR;
-  }
-
-  // Read NOR Flash data into shadow buffer
-  TempStatus = NorFlashReadBlocks (Instance, Instance->StartLba + Lba, BlockSize, BlockBuffer);
-  if (EFI_ERROR (TempStatus)) {
-    // Return one of the pre-approved error statuses
-    Status = EFI_DEVICE_ERROR;
-    goto FREE_MEMORY;
-  }
-
-  // Put the data at the appropriate location inside the buffer area
-  CopyMem((BlockBuffer + Offset), Buffer, *NumBytes);
-
-  // Write the modified buffer back to the NorFlash
-  Status = NorFlashWriteBlocks (Instance, Instance->StartLba + Lba, BlockSize, BlockBuffer);
-  if (EFI_ERROR (TempStatus)) {
-    // Return one of the pre-approved error statuses
-    Status = EFI_DEVICE_ERROR;
-    goto FREE_MEMORY;
-  }
-
-FREE_MEMORY:
-  FreePool(BlockBuffer);
-  return Status;
-}
-
-/**
- Erases and initialises a firmware volume block.
-
- The EraseBlocks() function erases one or more blocks as denoted
- by the variable argument list. The entire parameter list of
- blocks must be verified before erasing any blocks. If a block is
- requested that does not exist within the associated firmware
- volume (it has a larger index than the last block of the
- firmware volume), the EraseBlocks() function must return the
- status code EFI_INVALID_PARAMETER without modifying the contents
- of the firmware volume. Implementations should be mindful that
- the firmware volume might be in the WriteDisabled state. If it
- is in this state, the EraseBlocks() function must return the
- status code EFI_ACCESS_DENIED without modifying the contents of
- the firmware volume. All calls to EraseBlocks() must be fully
- flushed to the hardware before the EraseBlocks() service
- returns.
-
- @param This                     Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL
- instance.
-
- @param ...                      The variable argument list is a list of tuples.
-                                 Each tuple describes a range of LBAs to erase
-                                 and consists of the following:
-                                 - An EFI_LBA that indicates the starting LBA
-                                 - A UINTN that indicates the number of blocks to erase.
-
-                                 The list is terminated with an EFI_LBA_LIST_TERMINATOR.
-                                 For example, the following indicates that two ranges of blocks
-                                 (5-7 and 10-11) are to be erased:
-                                 EraseBlocks (This, 5, 3, 10, 2, EFI_LBA_LIST_TERMINATOR);
-
- @retval EFI_SUCCESS             The erase request successfully completed.
-
- @retval EFI_ACCESS_DENIED       The firmware volume is in the WriteDisabled state.
-
- @retval EFI_DEVICE_ERROR        The block device is not functioning correctly and could not be written.
-                                 The firmware device may have been partially erased.
-
- @retval EFI_INVALID_PARAMETER   One or more of the LBAs listed in the variable argument list do
-                                 not exist in the firmware volume.
-
- **/
-EFI_STATUS
-EFIAPI
-FvbEraseBlocks (
-  IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,
-  ...
-  )
-{
-  EFI_STATUS  Status;
-  VA_LIST     Args;
-  UINTN       BlockAddress; // Physical address of Lba to erase
-  EFI_LBA     StartingLba; // Lba from which we start erasing
-  UINTN       NumOfLba; // Number of Lba blocks to erase
-  NOR_FLASH_INSTANCE *Instance;
-
-  Instance = INSTANCE_FROM_FVB_THIS(This);
-
-  DEBUG ((DEBUG_BLKIO, "FvbEraseBlocks()\n"));
-
-  Status = EFI_SUCCESS;
-
-  // Detect WriteDisabled state
-  if (Instance->Media.ReadOnly == TRUE) {
-    // Firmware volume is in WriteDisabled state
-    DEBUG ((EFI_D_ERROR, "FvbEraseBlocks: ERROR - Device is in WriteDisabled state.\n"));
-    return EFI_ACCESS_DENIED;
-  }
-
-  // Before erasing, check the entire list of parameters to ensure all specified blocks are valid
-
-  VA_START (Args, This);
-  do {
-    // Get the Lba from which we start erasing
-    StartingLba = VA_ARG (Args, EFI_LBA);
-
-    // Have we reached the end of the list?
-    if (StartingLba == EFI_LBA_LIST_TERMINATOR) {
-      //Exit the while loop
-      break;
-    }
-
-    // How many Lba blocks are we requested to erase?
-    NumOfLba = VA_ARG (Args, UINT32);
-
-    // All blocks must be within range
-    DEBUG ((DEBUG_BLKIO, "FvbEraseBlocks: Check if: ( StartingLba=%ld + NumOfLba=%d - 1 ) > LastBlock=%ld.\n", Instance->StartLba + StartingLba, NumOfLba, Instance->Media.LastBlock));
-    if ((NumOfLba == 0) || ((Instance->StartLba + StartingLba + NumOfLba - 1) > Instance->Media.LastBlock)) {
-      VA_END (Args);
-      DEBUG ((EFI_D_ERROR, "FvbEraseBlocks: ERROR - Lba range goes past the last Lba.\n"));
-      Status = EFI_INVALID_PARAMETER;
-      goto EXIT;
-    }
-  } while (TRUE);
-  VA_END (Args);
-
-  //
-  // To get here, all must be ok, so start erasing
-  //
-  VA_START (Args, This);
-  do {
-    // Get the Lba from which we start erasing
-    StartingLba = VA_ARG (Args, EFI_LBA);
-
-    // Have we reached the end of the list?
-    if (StartingLba == EFI_LBA_LIST_TERMINATOR) {
-      // Exit the while loop
-      break;
-    }
-
-    // How many Lba blocks are we requested to erase?
-    NumOfLba = VA_ARG (Args, UINT32);
-
-    // Go through each one and erase it
-    while (NumOfLba > 0) {
-
-      // Get the physical address of Lba to erase
-      BlockAddress = GET_NOR_BLOCK_ADDRESS (
-          Instance->RegionBaseAddress,
-          Instance->StartLba + StartingLba,
-          Instance->Media.BlockSize
-      );
-
-      // Erase it
-      DEBUG ((DEBUG_BLKIO, "FvbEraseBlocks: Erasing Lba=%ld @ 0x%08x.\n", Instance->StartLba + StartingLba, BlockAddress));
-      Status = NorFlashUnlockAndEraseSingleBlock (Instance, BlockAddress);
-      if (EFI_ERROR(Status)) {
-        VA_END (Args);
-        Status = EFI_DEVICE_ERROR;
-        goto EXIT;
-      }
-
-      // Move to the next Lba
-      StartingLba++;
-      NumOfLba--;
-    }
-  } while (TRUE);
-  VA_END (Args);
-
-EXIT:
-  return Status;
-}
-
-EFI_STATUS
-EFIAPI
-NorFlashFvbInitialize (
-  IN NOR_FLASH_INSTANCE* Instance
-  )
-{
-  EFI_STATUS  Status;
-  UINT32      FvbNumLba;
-  EFI_BOOT_MODE BootMode;
-
-  DEBUG((DEBUG_BLKIO,"NorFlashFvbInitialize\n"));
-
-  Instance->Initialized = TRUE;
-
-  // Set the index of the first LBA for the FVB
-  Instance->StartLba = (PcdGet32 (PcdFlashNvStorageVariableBase) - Instance->RegionBaseAddress) / Instance->Media.BlockSize;
-
-  BootMode = GetBootModeHob ();
-  if (BootMode == BOOT_WITH_DEFAULT_SETTINGS) {
-    Status = EFI_INVALID_PARAMETER;
-  } else {
-    // Determine if there is a valid header at the beginning of the NorFlash
-    Status = ValidateFvHeader (Instance);
-  }
-
-  // Install the Default FVB header if required  
-  if (EFI_ERROR(Status)) {
-    // There is no valid header, so time to install one.
-    DEBUG((EFI_D_ERROR,"NorFlashFvbInitialize: ERROR - The FVB Header is not valid. Installing a correct one for this volume.\n"));
-
-    // Erase all the NorFlash that is reserved for variable storage
-    FvbNumLba = (PcdGet32(PcdFlashNvStorageVariableSize) + PcdGet32(PcdFlashNvStorageFtwWorkingSize) + PcdGet32(PcdFlashNvStorageFtwSpareSize)) / Instance->Media.BlockSize;
-
-    Status = FvbEraseBlocks (&Instance->FvbProtocol, (EFI_LBA)0, FvbNumLba, EFI_LBA_LIST_TERMINATOR);
-    if (EFI_ERROR(Status)) {
-      return Status;
-    }
-
-    // Install all appropriate headers
-    Status = InitializeFvAndVariableStoreHeaders (Instance);
-    if (EFI_ERROR(Status)) {
-      return Status;
-    }
-  }
-  return Status;
-}
+/*++ @file  NorFlashFvbDxe.c

+

+ Copyright (c) 2011-201333, ARM Ltd. All rights reserved.<BR>

+

+ This program and the accompanying materials

+ are licensed and made available under the terms and conditions of the BSD License

+ which accompanies this distribution.  The full text of the license may be found at

+ http://opensource.org/licenses/bsd-license.php

+

+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+ --*/

+

+#include <PiDxe.h>

+

+#include <Library/PcdLib.h>

+#include <Library/BaseLib.h>

+#include <Library/HobLib.h>

+#include <Library/UefiLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/MemoryAllocationLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+

+#include <Guid/VariableFormat.h>

+#include <Guid/SystemNvDataGuid.h>

+

+#include "NorFlashDxe.h"

+

+

+///

+/// The Firmware Volume Block Protocol is the low-level interface

+/// to a firmware volume. File-level access to a firmware volume

+/// should not be done using the Firmware Volume Block Protocol.

+/// Normal access to a firmware volume must use the Firmware

+/// Volume Protocol. Typically, only the file system driver that

+/// produces the Firmware Volume Protocol will bind to the

+/// Firmware Volume Block Protocol.

+///

+

+/**

+  Initialises the FV Header and Variable Store Header

+  to support variable operations.

+

+  @param[in]  Ptr - Location to initialise the headers

+

+**/

+EFI_STATUS

+InitializeFvAndVariableStoreHeaders (

+  IN NOR_FLASH_INSTANCE *Instance

+  )

+{

+  EFI_STATUS                          Status;

+  VOID*                               Headers;

+  UINTN                               HeadersLength;

+  EFI_FIRMWARE_VOLUME_HEADER          *FirmwareVolumeHeader;

+  VARIABLE_STORE_HEADER               *VariableStoreHeader;

+

+  if (!Instance->Initialized && Instance->Initialize) {

+    Instance->Initialize (Instance);

+  }

+

+  HeadersLength = sizeof(EFI_FIRMWARE_VOLUME_HEADER) + sizeof(EFI_FV_BLOCK_MAP_ENTRY) + sizeof(VARIABLE_STORE_HEADER);

+  Headers = AllocateZeroPool(HeadersLength);

+

+  // FirmwareVolumeHeader->FvLength is declared to have the Variable area AND the FTW working area AND the FTW Spare contiguous.

+  ASSERT(PcdGet32(PcdFlashNvStorageVariableBase) + PcdGet32(PcdFlashNvStorageVariableSize) == PcdGet32(PcdFlashNvStorageFtwWorkingBase));

+  ASSERT(PcdGet32(PcdFlashNvStorageFtwWorkingBase) + PcdGet32(PcdFlashNvStorageFtwWorkingSize) == PcdGet32(PcdFlashNvStorageFtwSpareBase));

+

+  // Check if the size of the area is at least one block size

+  ASSERT((PcdGet32(PcdFlashNvStorageVariableSize) > 0) && (PcdGet32(PcdFlashNvStorageVariableSize) / Instance->Media.BlockSize > 0));

+  ASSERT((PcdGet32(PcdFlashNvStorageFtwWorkingSize) > 0) && (PcdGet32(PcdFlashNvStorageFtwWorkingSize) / Instance->Media.BlockSize > 0));

+  ASSERT((PcdGet32(PcdFlashNvStorageFtwSpareSize) > 0) && (PcdGet32(PcdFlashNvStorageFtwSpareSize) / Instance->Media.BlockSize > 0));

+

+  // Ensure the Variable area Base Addresses are aligned on a block size boundaries

+  ASSERT(PcdGet32(PcdFlashNvStorageVariableBase) % Instance->Media.BlockSize == 0);

+  ASSERT(PcdGet32(PcdFlashNvStorageFtwWorkingBase) % Instance->Media.BlockSize == 0);

+  ASSERT(PcdGet32(PcdFlashNvStorageFtwSpareBase) % Instance->Media.BlockSize == 0);

+

+  //

+  // EFI_FIRMWARE_VOLUME_HEADER

+  //

+  FirmwareVolumeHeader = (EFI_FIRMWARE_VOLUME_HEADER*)Headers;

+  CopyGuid (&FirmwareVolumeHeader->FileSystemGuid, &gEfiSystemNvDataFvGuid);

+  FirmwareVolumeHeader->FvLength =

+      PcdGet32(PcdFlashNvStorageVariableSize) +

+      PcdGet32(PcdFlashNvStorageFtwWorkingSize) +

+      PcdGet32(PcdFlashNvStorageFtwSpareSize);

+  FirmwareVolumeHeader->Signature = EFI_FVH_SIGNATURE;

+  FirmwareVolumeHeader->Attributes = (EFI_FVB_ATTRIBUTES_2) (

+                                          EFI_FVB2_READ_ENABLED_CAP   | // Reads may be enabled

+                                          EFI_FVB2_READ_STATUS        | // Reads are currently enabled

+                                          EFI_FVB2_STICKY_WRITE       | // A block erase is required to flip bits into EFI_FVB2_ERASE_POLARITY

+                                          EFI_FVB2_MEMORY_MAPPED      | // It is memory mapped

+                                          EFI_FVB2_ERASE_POLARITY     | // After erasure all bits take this value (i.e. '1')

+                                          EFI_FVB2_WRITE_STATUS       | // Writes are currently enabled

+                                          EFI_FVB2_WRITE_ENABLED_CAP    // Writes may be enabled

+                                      );

+  FirmwareVolumeHeader->HeaderLength = sizeof(EFI_FIRMWARE_VOLUME_HEADER) + sizeof(EFI_FV_BLOCK_MAP_ENTRY);

+  FirmwareVolumeHeader->Revision = EFI_FVH_REVISION;

+  FirmwareVolumeHeader->BlockMap[0].NumBlocks = Instance->Media.LastBlock + 1;

+  FirmwareVolumeHeader->BlockMap[0].Length      = Instance->Media.BlockSize;

+  FirmwareVolumeHeader->BlockMap[1].NumBlocks = 0;

+  FirmwareVolumeHeader->BlockMap[1].Length      = 0;

+  FirmwareVolumeHeader->Checksum = CalculateCheckSum16 ((UINT16*)FirmwareVolumeHeader,FirmwareVolumeHeader->HeaderLength);

+

+  //

+  // VARIABLE_STORE_HEADER

+  //

+  VariableStoreHeader = (VARIABLE_STORE_HEADER*)((UINTN)Headers + FirmwareVolumeHeader->HeaderLength);

+  CopyGuid (&VariableStoreHeader->Signature, &gEfiVariableGuid);

+  VariableStoreHeader->Size = PcdGet32(PcdFlashNvStorageVariableSize) - FirmwareVolumeHeader->HeaderLength;

+  VariableStoreHeader->Format            = VARIABLE_STORE_FORMATTED;

+  VariableStoreHeader->State             = VARIABLE_STORE_HEALTHY;

+

+  // Install the combined super-header in the NorFlash

+  Status = FvbWrite (&Instance->FvbProtocol, 0, 0, &HeadersLength, Headers);

+

+  FreePool (Headers);

+  return Status;

+}

+

+/**

+  Check the integrity of firmware volume header.

+

+  @param[in] FwVolHeader - A pointer to a firmware volume header

+

+  @retval  EFI_SUCCESS   - The firmware volume is consistent

+  @retval  EFI_NOT_FOUND - The firmware volume has been corrupted.

+

+**/

+EFI_STATUS

+ValidateFvHeader (

+  IN  NOR_FLASH_INSTANCE *Instance

+  )

+{

+  UINT16                      Checksum;

+  EFI_FIRMWARE_VOLUME_HEADER  *FwVolHeader;

+  VARIABLE_STORE_HEADER       *VariableStoreHeader;

+  UINTN                       VariableStoreLength;

+  UINTN						  FvLength;

+

+  FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER*)Instance->RegionBaseAddress;

+

+  FvLength = PcdGet32(PcdFlashNvStorageVariableSize) + PcdGet32(PcdFlashNvStorageFtwWorkingSize) +

+      PcdGet32(PcdFlashNvStorageFtwSpareSize);

+

+  //

+  // Verify the header revision, header signature, length

+  // Length of FvBlock cannot be 2**64-1

+  // HeaderLength cannot be an odd number

+  //

+  if (   (FwVolHeader->Revision  != EFI_FVH_REVISION)

+      || (FwVolHeader->Signature != EFI_FVH_SIGNATURE)

+      || (FwVolHeader->FvLength  != FvLength)

+      )

+  {

+    DEBUG ((EFI_D_ERROR, "ValidateFvHeader: No Firmware Volume header present\n"));

+    return EFI_NOT_FOUND;

+  }

+

+  // Check the Firmware Volume Guid

+  if( CompareGuid (&FwVolHeader->FileSystemGuid, &gEfiSystemNvDataFvGuid) == FALSE ) {

+    DEBUG ((EFI_D_ERROR, "ValidateFvHeader: Firmware Volume Guid non-compatible\n"));

+    return EFI_NOT_FOUND;

+  }

+

+  // Verify the header checksum

+  Checksum = CalculateSum16((UINT16*)FwVolHeader, FwVolHeader->HeaderLength);

+  if (Checksum != 0) {

+    DEBUG ((EFI_D_ERROR, "ValidateFvHeader: FV checksum is invalid (Checksum:0x%X)\n",Checksum));

+    return EFI_NOT_FOUND;

+  }

+

+  VariableStoreHeader = (VARIABLE_STORE_HEADER*)((UINTN)FwVolHeader + FwVolHeader->HeaderLength);

+

+  // Check the Variable Store Guid

+  if( CompareGuid (&VariableStoreHeader->Signature, &gEfiVariableGuid) == FALSE ) {

+    DEBUG ((EFI_D_ERROR, "ValidateFvHeader: Variable Store Guid non-compatible\n"));

+    return EFI_NOT_FOUND;

+  }

+

+  VariableStoreLength = PcdGet32 (PcdFlashNvStorageVariableSize) - FwVolHeader->HeaderLength;

+  if (VariableStoreHeader->Size != VariableStoreLength) {

+    DEBUG ((EFI_D_ERROR, "ValidateFvHeader: Variable Store Length does not match\n"));

+    return EFI_NOT_FOUND;

+  }

+

+  return EFI_SUCCESS;

+}

+

+/**

+ The GetAttributes() function retrieves the attributes and

+ current settings of the block.

+

+ @param This         Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.

+

+ @param Attributes   Pointer to EFI_FVB_ATTRIBUTES_2 in which the attributes and

+                     current settings are returned.

+                     Type EFI_FVB_ATTRIBUTES_2 is defined in EFI_FIRMWARE_VOLUME_HEADER.

+

+ @retval EFI_SUCCESS The firmware volume attributes were returned.

+

+ **/

+EFI_STATUS

+EFIAPI

+FvbGetAttributes(

+  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL    *This,

+  OUT       EFI_FVB_ATTRIBUTES_2                   *Attributes

+  )

+{

+  EFI_FVB_ATTRIBUTES_2  FlashFvbAttributes;

+  NOR_FLASH_INSTANCE *Instance;

+

+  Instance = INSTANCE_FROM_FVB_THIS(This);

+

+  FlashFvbAttributes = (EFI_FVB_ATTRIBUTES_2) (

+

+      EFI_FVB2_READ_ENABLED_CAP | // Reads may be enabled

+      EFI_FVB2_READ_STATUS      | // Reads are currently enabled

+      EFI_FVB2_STICKY_WRITE     | // A block erase is required to flip bits into EFI_FVB2_ERASE_POLARITY

+      EFI_FVB2_MEMORY_MAPPED    | // It is memory mapped

+      EFI_FVB2_ERASE_POLARITY     // After erasure all bits take this value (i.e. '1')

+

+      );

+

+  // Check if it is write protected

+  if (Instance->Media.ReadOnly != TRUE) {

+

+    FlashFvbAttributes = FlashFvbAttributes         |

+                         EFI_FVB2_WRITE_STATUS      | // Writes are currently enabled

+                         EFI_FVB2_WRITE_ENABLED_CAP;  // Writes may be enabled

+  }

+

+  *Attributes = FlashFvbAttributes;

+

+  DEBUG ((DEBUG_BLKIO, "FvbGetAttributes(0x%X)\n", *Attributes));

+

+  return EFI_SUCCESS;

+}

+

+/**

+ The SetAttributes() function sets configurable firmware volume attributes

+ and returns the new settings of the firmware volume.

+

+

+ @param This                     Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.

+

+ @param Attributes               On input, Attributes is a pointer to EFI_FVB_ATTRIBUTES_2

+                                 that contains the desired firmware volume settings.

+                                 On successful return, it contains the new settings of

+                                 the firmware volume.

+                                 Type EFI_FVB_ATTRIBUTES_2 is defined in EFI_FIRMWARE_VOLUME_HEADER.

+

+ @retval EFI_SUCCESS             The firmware volume attributes were returned.

+

+ @retval EFI_INVALID_PARAMETER   The attributes requested are in conflict with the capabilities

+                                 as declared in the firmware volume header.

+

+ **/

+EFI_STATUS

+EFIAPI

+FvbSetAttributes(

+  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL  *This,

+  IN OUT    EFI_FVB_ATTRIBUTES_2                 *Attributes

+  )

+{

+  DEBUG ((DEBUG_BLKIO, "FvbSetAttributes(0x%X) is not supported\n",*Attributes));

+  return EFI_UNSUPPORTED;

+}

+

+/**

+ The GetPhysicalAddress() function retrieves the base address of

+ a memory-mapped firmware volume. This function should be called

+ only for memory-mapped firmware volumes.

+

+ @param This               Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.

+

+ @param Address            Pointer to a caller-allocated

+                           EFI_PHYSICAL_ADDRESS that, on successful

+                           return from GetPhysicalAddress(), contains the

+                           base address of the firmware volume.

+

+ @retval EFI_SUCCESS       The firmware volume base address was returned.

+

+ @retval EFI_NOT_SUPPORTED The firmware volume is not memory mapped.

+

+ **/

+EFI_STATUS

+EFIAPI

+FvbGetPhysicalAddress (

+  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL  *This,

+  OUT       EFI_PHYSICAL_ADDRESS                 *Address

+  )

+{

+  NOR_FLASH_INSTANCE *Instance;

+

+  Instance = INSTANCE_FROM_FVB_THIS(This);

+

+  DEBUG ((DEBUG_BLKIO, "FvbGetPhysicalAddress(BaseAddress=0x%08x)\n", Instance->RegionBaseAddress));

+

+  ASSERT(Address != NULL);

+

+  *Address = PcdGet32 (PcdFlashNvStorageVariableBase);

+  return EFI_SUCCESS;

+}

+

+/**

+ The GetBlockSize() function retrieves the size of the requested

+ block. It also returns the number of additional blocks with

+ the identical size. The GetBlockSize() function is used to

+ retrieve the block map (see EFI_FIRMWARE_VOLUME_HEADER).

+

+

+ @param This                     Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.

+

+ @param Lba                      Indicates the block for which to return the size.

+

+ @param BlockSize                Pointer to a caller-allocated UINTN in which

+                                 the size of the block is returned.

+

+ @param NumberOfBlocks           Pointer to a caller-allocated UINTN in

+                                 which the number of consecutive blocks,

+                                 starting with Lba, is returned. All

+                                 blocks in this range have a size of

+                                 BlockSize.

+

+

+ @retval EFI_SUCCESS             The firmware volume base address was returned.

+

+ @retval EFI_INVALID_PARAMETER   The requested LBA is out of range.

+

+ **/

+EFI_STATUS

+EFIAPI

+FvbGetBlockSize (

+  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL  *This,

+  IN        EFI_LBA                              Lba,

+  OUT       UINTN                                *BlockSize,

+  OUT       UINTN                                *NumberOfBlocks

+  )

+{

+  EFI_STATUS Status;

+  NOR_FLASH_INSTANCE *Instance;

+

+  Instance = INSTANCE_FROM_FVB_THIS(This);

+

+  DEBUG ((DEBUG_BLKIO, "FvbGetBlockSize(Lba=%ld, BlockSize=0x%x, LastBlock=%ld)\n", Lba, Instance->Media.BlockSize, Instance->Media.LastBlock));

+

+  if (Lba > Instance->Media.LastBlock) {

+    DEBUG ((EFI_D_ERROR, "FvbGetBlockSize: ERROR - Parameter LBA %ld is beyond the last Lba (%ld).\n", Lba, Instance->Media.LastBlock));

+    Status = EFI_INVALID_PARAMETER;

+  } else {

+    // This is easy because in this platform each NorFlash device has equal sized blocks.

+    *BlockSize = (UINTN) Instance->Media.BlockSize;

+    *NumberOfBlocks = (UINTN) (Instance->Media.LastBlock - Lba + 1);

+

+    DEBUG ((DEBUG_BLKIO, "FvbGetBlockSize: *BlockSize=0x%x, *NumberOfBlocks=0x%x.\n", *BlockSize, *NumberOfBlocks));

+

+    Status = EFI_SUCCESS;

+  }

+

+  return Status;

+}

+

+/**

+ Reads the specified number of bytes into a buffer from the specified block.

+

+ The Read() function reads the requested number of bytes from the

+ requested block and stores them in the provided buffer.

+ Implementations should be mindful that the firmware volume

+ might be in the ReadDisabled state. If it is in this state,

+ the Read() function must return the status code

+ EFI_ACCESS_DENIED without modifying the contents of the

+ buffer. The Read() function must also prevent spanning block

+ boundaries. If a read is requested that would span a block

+ boundary, the read must read up to the boundary but not

+ beyond. The output parameter NumBytes must be set to correctly

+ indicate the number of bytes actually read. The caller must be

+ aware that a read may be partially completed.

+

+ @param This                 Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.

+

+ @param Lba                  The starting logical block index from which to read.

+

+ @param Offset               Offset into the block at which to begin reading.

+

+ @param NumBytes             Pointer to a UINTN.

+                             At entry, *NumBytes contains the total size of the buffer.

+                             At exit, *NumBytes contains the total number of bytes read.

+

+ @param Buffer               Pointer to a caller-allocated buffer that will be used

+                             to hold the data that is read.

+

+ @retval EFI_SUCCESS         The firmware volume was read successfully,  and contents are

+                             in Buffer.

+

+ @retval EFI_BAD_BUFFER_SIZE Read attempted across an LBA boundary.

+                             On output, NumBytes contains the total number of bytes

+                             returned in Buffer.

+

+ @retval EFI_ACCESS_DENIED   The firmware volume is in the ReadDisabled state.

+

+ @retval EFI_DEVICE_ERROR    The block device is not functioning correctly and could not be read.

+

+ **/

+EFI_STATUS

+EFIAPI

+FvbRead (

+  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL   *This,

+  IN        EFI_LBA                               Lba,

+  IN        UINTN                                 Offset,

+  IN OUT    UINTN                                 *NumBytes,

+  IN OUT    UINT8                                 *Buffer

+  )

+{

+  EFI_STATUS    Status;

+  EFI_STATUS    TempStatus;

+  UINTN         BlockSize;

+  UINT8         *BlockBuffer;

+  NOR_FLASH_INSTANCE *Instance;

+

+  Instance = INSTANCE_FROM_FVB_THIS(This);

+

+  DEBUG ((DEBUG_BLKIO, "FvbRead(Parameters: Lba=%ld, Offset=0x%x, *NumBytes=0x%x, Buffer @ 0x%08x)\n", Instance->StartLba + Lba, Offset, *NumBytes, Buffer));

+

+  if (!Instance->Initialized && Instance->Initialize) {

+    Instance->Initialize(Instance);

+  }

+

+  Status = EFI_SUCCESS;

+  TempStatus = Status;

+

+  // Cache the block size to avoid de-referencing pointers all the time

+  BlockSize = Instance->Media.BlockSize;

+

+  DEBUG ((DEBUG_BLKIO, "FvbRead: Check if (Offset=0x%x + NumBytes=0x%x) <= BlockSize=0x%x\n", Offset, *NumBytes, BlockSize ));

+

+  // The read must not span block boundaries.

+  // We need to check each variable individually because adding two large values together overflows.

+  if ((Offset               >= BlockSize) ||

+      (*NumBytes            >  BlockSize) ||

+      ((Offset + *NumBytes) >  BlockSize)) {

+    DEBUG ((EFI_D_ERROR, "FvbRead: ERROR - EFI_BAD_BUFFER_SIZE: (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", Offset, *NumBytes, BlockSize ));

+    return EFI_BAD_BUFFER_SIZE;

+  }

+

+  // We must have some bytes to read

+  if (*NumBytes == 0) {

+    return EFI_BAD_BUFFER_SIZE;

+  }

+

+  // FixMe: Allow an arbitrary number of bytes to be read out, not just a multiple of block size.

+

+  // Allocate runtime memory to read in the NOR Flash data. Variable Services are runtime.

+  BlockBuffer = AllocateRuntimePool (BlockSize);

+

+  // Check if the memory allocation was successful

+  if (BlockBuffer == NULL) {

+    DEBUG ((EFI_D_ERROR, "FvbRead: ERROR - Could not allocate BlockBuffer @ 0x%08x.\n", BlockBuffer));

+    return EFI_DEVICE_ERROR;

+  }

+

+  // Read NOR Flash data into shadow buffer

+  TempStatus = NorFlashReadBlocks (Instance, Instance->StartLba + Lba, BlockSize, BlockBuffer);

+  if (EFI_ERROR (TempStatus)) {

+    // Return one of the pre-approved error statuses

+    Status = EFI_DEVICE_ERROR;

+    goto FREE_MEMORY;

+  }

+

+  // Put the data at the appropriate location inside the buffer area

+  DEBUG ((DEBUG_BLKIO, "FvbRead: CopyMem( Dst=0x%08x, Src=0x%08x, Size=0x%x ).\n", Buffer, BlockBuffer + Offset, *NumBytes));

+

+  CopyMem(Buffer, BlockBuffer + Offset, *NumBytes);

+

+FREE_MEMORY:

+  FreePool(BlockBuffer);

+  return Status;

+}

+

+/**

+ Writes the specified number of bytes from the input buffer to the block.

+

+ The Write() function writes the specified number of bytes from

+ the provided buffer to the specified block and offset. If the

+ firmware volume is sticky write, the caller must ensure that

+ all the bits of the specified range to write are in the

+ EFI_FVB_ERASE_POLARITY state before calling the Write()

+ function, or else the result will be unpredictable. This

+ unpredictability arises because, for a sticky-write firmware

+ volume, a write may negate a bit in the EFI_FVB_ERASE_POLARITY

+ state but cannot flip it back again.  Before calling the

+ Write() function,  it is recommended for the caller to first call

+ the EraseBlocks() function to erase the specified block to

+ write. A block erase cycle will transition bits from the

+ (NOT)EFI_FVB_ERASE_POLARITY state back to the

+ EFI_FVB_ERASE_POLARITY state. Implementations should be

+ mindful that the firmware volume might be in the WriteDisabled

+ state. If it is in this state, the Write() function must

+ return the status code EFI_ACCESS_DENIED without modifying the

+ contents of the firmware volume. The Write() function must

+ also prevent spanning block boundaries. If a write is

+ requested that spans a block boundary, the write must store up

+ to the boundary but not beyond. The output parameter NumBytes

+ must be set to correctly indicate the number of bytes actually

+ written. The caller must be aware that a write may be

+ partially completed. All writes, partial or otherwise, must be

+ fully flushed to the hardware before the Write() service

+ returns.

+

+ @param This                 Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.

+

+ @param Lba                  The starting logical block index to write to.

+

+ @param Offset               Offset into the block at which to begin writing.

+

+ @param NumBytes             The pointer to a UINTN.

+                             At entry, *NumBytes contains the total size of the buffer.

+                             At exit, *NumBytes contains the total number of bytes actually written.

+

+ @param Buffer               The pointer to a caller-allocated buffer that contains the source for the write.

+

+ @retval EFI_SUCCESS         The firmware volume was written successfully.

+

+ @retval EFI_BAD_BUFFER_SIZE The write was attempted across an LBA boundary.

+                             On output, NumBytes contains the total number of bytes

+                             actually written.

+

+ @retval EFI_ACCESS_DENIED   The firmware volume is in the WriteDisabled state.

+

+ @retval EFI_DEVICE_ERROR    The block device is malfunctioning and could not be written.

+

+

+ **/

+EFI_STATUS

+EFIAPI

+FvbWrite (

+  IN CONST  EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL   *This,

+  IN        EFI_LBA                               Lba,

+  IN        UINTN                                 Offset,

+  IN OUT    UINTN                                 *NumBytes,

+  IN        UINT8                                 *Buffer

+  )

+{

+  EFI_STATUS  Status;

+  EFI_STATUS  TempStatus;

+  UINTN       BlockSize;

+  UINT8       *BlockBuffer;

+  NOR_FLASH_INSTANCE *Instance;

+

+  Instance = INSTANCE_FROM_FVB_THIS(This);

+

+  if (!Instance->Initialized && Instance->Initialize) {

+    Instance->Initialize(Instance);

+  }

+

+  DEBUG ((DEBUG_BLKIO, "FvbWrite(Parameters: Lba=%ld, Offset=0x%x, *NumBytes=0x%x, Buffer @ 0x%08x)\n", Instance->StartLba + Lba, Offset, *NumBytes, Buffer));

+

+  Status = EFI_SUCCESS;

+  TempStatus = Status;

+

+  // Detect WriteDisabled state

+  if (Instance->Media.ReadOnly == TRUE) {

+    DEBUG ((EFI_D_ERROR, "FvbWrite: ERROR - Can not write: Device is in WriteDisabled state.\n"));

+    // It is in WriteDisabled state, return an error right away

+    return EFI_ACCESS_DENIED;

+  }

+

+  // Cache the block size to avoid de-referencing pointers all the time

+  BlockSize = Instance->Media.BlockSize;

+

+  // The write must not span block boundaries.

+  // We need to check each variable individually because adding two large values together overflows.

+  if ( ( Offset               >= BlockSize ) ||

+       ( *NumBytes            >  BlockSize ) ||

+       ( (Offset + *NumBytes) >  BlockSize )    ) {

+    DEBUG ((EFI_D_ERROR, "FvbWrite: ERROR - EFI_BAD_BUFFER_SIZE: (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", Offset, *NumBytes, BlockSize ));

+    return EFI_BAD_BUFFER_SIZE;

+  }

+

+  // We must have some bytes to write

+  if (*NumBytes == 0) {

+    DEBUG ((EFI_D_ERROR, "FvbWrite: ERROR - EFI_BAD_BUFFER_SIZE: (Offset=0x%x + NumBytes=0x%x) > BlockSize=0x%x\n", Offset, *NumBytes, BlockSize ));

+    return EFI_BAD_BUFFER_SIZE;

+  }

+

+  // Allocate runtime memory to read in the NOR Flash data.

+  // Since the intention is to use this with Variable Services and since these are runtime,

+  // allocate the memory from the runtime pool.

+  BlockBuffer = AllocateRuntimePool (BlockSize);

+

+  // Check we did get some memory

+  if( BlockBuffer == NULL ) {

+    DEBUG ((EFI_D_ERROR, "FvbWrite: ERROR - Can not allocate BlockBuffer @ 0x%08x.\n", BlockBuffer));

+    return EFI_DEVICE_ERROR;

+  }

+

+  // Read NOR Flash data into shadow buffer

+  TempStatus = NorFlashReadBlocks (Instance, Instance->StartLba + Lba, BlockSize, BlockBuffer);

+  if (EFI_ERROR (TempStatus)) {

+    // Return one of the pre-approved error statuses

+    Status = EFI_DEVICE_ERROR;

+    goto FREE_MEMORY;

+  }

+

+  // Put the data at the appropriate location inside the buffer area

+  CopyMem((BlockBuffer + Offset), Buffer, *NumBytes);

+

+  // Write the modified buffer back to the NorFlash

+  Status = NorFlashWriteBlocks (Instance, Instance->StartLba + Lba, BlockSize, BlockBuffer);

+  if (EFI_ERROR (TempStatus)) {

+    // Return one of the pre-approved error statuses

+    Status = EFI_DEVICE_ERROR;

+    goto FREE_MEMORY;

+  }

+

+FREE_MEMORY:

+  FreePool(BlockBuffer);

+  return Status;

+}

+

+/**

+ Erases and initialises a firmware volume block.

+

+ The EraseBlocks() function erases one or more blocks as denoted

+ by the variable argument list. The entire parameter list of

+ blocks must be verified before erasing any blocks. If a block is

+ requested that does not exist within the associated firmware

+ volume (it has a larger index than the last block of the

+ firmware volume), the EraseBlocks() function must return the

+ status code EFI_INVALID_PARAMETER without modifying the contents

+ of the firmware volume. Implementations should be mindful that

+ the firmware volume might be in the WriteDisabled state. If it

+ is in this state, the EraseBlocks() function must return the

+ status code EFI_ACCESS_DENIED without modifying the contents of

+ the firmware volume. All calls to EraseBlocks() must be fully

+ flushed to the hardware before the EraseBlocks() service

+ returns.

+

+ @param This                     Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL

+ instance.

+

+ @param ...                      The variable argument list is a list of tuples.

+                                 Each tuple describes a range of LBAs to erase

+                                 and consists of the following:

+                                 - An EFI_LBA that indicates the starting LBA

+                                 - A UINTN that indicates the number of blocks to erase.

+

+                                 The list is terminated with an EFI_LBA_LIST_TERMINATOR.

+                                 For example, the following indicates that two ranges of blocks

+                                 (5-7 and 10-11) are to be erased:

+                                 EraseBlocks (This, 5, 3, 10, 2, EFI_LBA_LIST_TERMINATOR);

+

+ @retval EFI_SUCCESS             The erase request successfully completed.

+

+ @retval EFI_ACCESS_DENIED       The firmware volume is in the WriteDisabled state.

+

+ @retval EFI_DEVICE_ERROR        The block device is not functioning correctly and could not be written.

+                                 The firmware device may have been partially erased.

+

+ @retval EFI_INVALID_PARAMETER   One or more of the LBAs listed in the variable argument list do

+                                 not exist in the firmware volume.

+

+ **/

+EFI_STATUS

+EFIAPI

+FvbEraseBlocks (

+  IN CONST EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL *This,

+  ...

+  )

+{

+  EFI_STATUS  Status;

+  VA_LIST     Args;

+  UINTN       BlockAddress; // Physical address of Lba to erase

+  EFI_LBA     StartingLba; // Lba from which we start erasing

+  UINTN       NumOfLba; // Number of Lba blocks to erase

+  NOR_FLASH_INSTANCE *Instance;

+

+  Instance = INSTANCE_FROM_FVB_THIS(This);

+

+  DEBUG ((DEBUG_BLKIO, "FvbEraseBlocks()\n"));

+

+  Status = EFI_SUCCESS;

+

+  // Detect WriteDisabled state

+  if (Instance->Media.ReadOnly == TRUE) {

+    // Firmware volume is in WriteDisabled state

+    DEBUG ((EFI_D_ERROR, "FvbEraseBlocks: ERROR - Device is in WriteDisabled state.\n"));

+    return EFI_ACCESS_DENIED;

+  }

+

+  // Before erasing, check the entire list of parameters to ensure all specified blocks are valid

+

+  VA_START (Args, This);

+  do {

+    // Get the Lba from which we start erasing

+    StartingLba = VA_ARG (Args, EFI_LBA);

+

+    // Have we reached the end of the list?

+    if (StartingLba == EFI_LBA_LIST_TERMINATOR) {

+      //Exit the while loop

+      break;

+    }

+

+    // How many Lba blocks are we requested to erase?

+    NumOfLba = VA_ARG (Args, UINT32);

+

+    // All blocks must be within range

+    DEBUG ((DEBUG_BLKIO, "FvbEraseBlocks: Check if: ( StartingLba=%ld + NumOfLba=%d - 1 ) > LastBlock=%ld.\n", Instance->StartLba + StartingLba, NumOfLba, Instance->Media.LastBlock));

+    if ((NumOfLba == 0) || ((Instance->StartLba + StartingLba + NumOfLba - 1) > Instance->Media.LastBlock)) {

+      VA_END (Args);

+      DEBUG ((EFI_D_ERROR, "FvbEraseBlocks: ERROR - Lba range goes past the last Lba.\n"));

+      Status = EFI_INVALID_PARAMETER;

+      goto EXIT;

+    }

+  } while (TRUE);

+  VA_END (Args);

+

+  //

+  // To get here, all must be ok, so start erasing

+  //

+  VA_START (Args, This);

+  do {

+    // Get the Lba from which we start erasing

+    StartingLba = VA_ARG (Args, EFI_LBA);

+

+    // Have we reached the end of the list?

+    if (StartingLba == EFI_LBA_LIST_TERMINATOR) {

+      // Exit the while loop

+      break;

+    }

+

+    // How many Lba blocks are we requested to erase?

+    NumOfLba = VA_ARG (Args, UINT32);

+

+    // Go through each one and erase it

+    while (NumOfLba > 0) {

+

+      // Get the physical address of Lba to erase

+      BlockAddress = GET_NOR_BLOCK_ADDRESS (

+          Instance->RegionBaseAddress,

+          Instance->StartLba + StartingLba,

+          Instance->Media.BlockSize

+      );

+

+      // Erase it

+      DEBUG ((DEBUG_BLKIO, "FvbEraseBlocks: Erasing Lba=%ld @ 0x%08x.\n", Instance->StartLba + StartingLba, BlockAddress));

+      Status = NorFlashUnlockAndEraseSingleBlock (Instance, BlockAddress);

+      if (EFI_ERROR(Status)) {

+        VA_END (Args);

+        Status = EFI_DEVICE_ERROR;

+        goto EXIT;

+      }

+

+      // Move to the next Lba

+      StartingLba++;

+      NumOfLba--;

+    }

+  } while (TRUE);

+  VA_END (Args);

+

+EXIT:

+  return Status;

+}

+

+EFI_STATUS

+EFIAPI

+NorFlashFvbInitialize (

+  IN NOR_FLASH_INSTANCE* Instance

+  )

+{

+  EFI_STATUS  Status;

+  UINT32      FvbNumLba;

+  EFI_BOOT_MODE BootMode;

+

+  DEBUG((DEBUG_BLKIO,"NorFlashFvbInitialize\n"));

+

+  Instance->Initialized = TRUE;

+

+  // Set the index of the first LBA for the FVB

+  Instance->StartLba = (PcdGet32 (PcdFlashNvStorageVariableBase) - Instance->RegionBaseAddress) / Instance->Media.BlockSize;

+

+  BootMode = GetBootModeHob ();

+  if (BootMode == BOOT_WITH_DEFAULT_SETTINGS) {

+    Status = EFI_INVALID_PARAMETER;

+  } else {

+    // Determine if there is a valid header at the beginning of the NorFlash

+    Status = ValidateFvHeader (Instance);

+  }

+

+  // Install the Default FVB header if required  

+  if (EFI_ERROR(Status)) {

+    // There is no valid header, so time to install one.

+    DEBUG((EFI_D_ERROR,"NorFlashFvbInitialize: ERROR - The FVB Header is not valid. Installing a correct one for this volume.\n"));

+

+    // Erase all the NorFlash that is reserved for variable storage

+    FvbNumLba = (PcdGet32(PcdFlashNvStorageVariableSize) + PcdGet32(PcdFlashNvStorageFtwWorkingSize) + PcdGet32(PcdFlashNvStorageFtwSpareSize)) / Instance->Media.BlockSize;

+

+    Status = FvbEraseBlocks (&Instance->FvbProtocol, (EFI_LBA)0, FvbNumLba, EFI_LBA_LIST_TERMINATOR);

+    if (EFI_ERROR(Status)) {

+      return Status;

+    }

+

+    // Install all appropriate headers

+    Status = InitializeFvAndVariableStoreHeaders (Instance);

+    if (EFI_ERROR(Status)) {

+      return Status;

+    }

+  }

+  return Status;

+}

diff --git a/ArmPlatformPkg/Drivers/PL061GpioDxe/PL061Gpio.c b/ArmPlatformPkg/Drivers/PL061GpioDxe/PL061Gpio.c
index cb811d89..ff05662b 100644
--- a/ArmPlatformPkg/Drivers/PL061GpioDxe/PL061Gpio.c
+++ b/ArmPlatformPkg/Drivers/PL061GpioDxe/PL061Gpio.c
@@ -1,344 +1,344 @@
-/** @file
-*
-*  Copyright (c) 2011, ARM Limited. All rights reserved.
-*
-*  This program and the accompanying materials
-*  are licensed and made available under the terms and conditions of the BSD License
-*  which accompanies this distribution.  The full text of the license may be found at
-*  http://opensource.org/licenses/bsd-license.php
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-*
-**/
-
-
-#include <PiDxe.h>
-
-#include <Library/BaseLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/DebugLib.h>
-#include <Library/IoLib.h>
-#include <Library/PcdLib.h>
-#include <Library/UefiBootServicesTableLib.h>
-#include <Library/UefiLib.h>
-#include <Library/UefiRuntimeServicesTableLib.h>
-
-#include <Protocol/EmbeddedGpio.h>
-#include <Drivers/PL061Gpio.h>
-
-BOOLEAN     mPL061Initialized = FALSE;
-
-/**
-  Function implementations
-**/
-
-EFI_STATUS
-PL061Identify (
-  VOID
-  )
-{
-  // Check if this is a PrimeCell Peripheral
-  if (    (MmioRead8 (PL061_GPIO_PCELL_ID0) != 0x0D)
-      ||  (MmioRead8 (PL061_GPIO_PCELL_ID1) != 0xF0)
-      ||  (MmioRead8 (PL061_GPIO_PCELL_ID2) != 0x05)
-      ||  (MmioRead8 (PL061_GPIO_PCELL_ID3) != 0xB1)) {
-    return EFI_NOT_FOUND;
-  }
-
-  // Check if this PrimeCell Peripheral is the PL061 GPIO
-  if (    (MmioRead8 (PL061_GPIO_PERIPH_ID0) != 0x61)
-      ||  (MmioRead8 (PL061_GPIO_PERIPH_ID1) != 0x10)
-      ||  ((MmioRead8 (PL061_GPIO_PERIPH_ID2) & 0xF) != 0x04)
-      ||  (MmioRead8 (PL061_GPIO_PERIPH_ID3) != 0x00)) {
-    return EFI_NOT_FOUND;
-  }
-
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-PL061Initialize (
-  VOID
-  )
-{
-  EFI_STATUS  Status;
-
-  // Check if the PL061 GPIO module exists on board
-  Status = PL061Identify();
-  if (EFI_ERROR (Status)) {
-    Status = EFI_DEVICE_ERROR;
-    goto EXIT;
-  }
-
-  // Do other hardware initialisation things here as required
-
-  // Disable Interrupts
-  //if (MmioRead8 (PL061_GPIO_IE_REG) != 0) {
-  //   // Ensure interrupts are disabled
-  //}
-
-  mPL061Initialized = TRUE;
-
-  EXIT:
-  return Status;
-}
-
-/**
-
-Routine Description:
-
-  Gets the state of a GPIO pin
-
-Arguments:
-
-  This  - pointer to protocol
-  Gpio  - which pin to read
-  Value - state of the pin
-
-Returns:
-
-  EFI_SUCCESS           - GPIO state returned in Value
-  EFI_INVALID_PARAMETER - Value is NULL pointer or Gpio pin is out of range
-**/
-EFI_STATUS
-EFIAPI
-Get (
-  IN  EMBEDDED_GPIO     *This,
-  IN  EMBEDDED_GPIO_PIN Gpio,
-  OUT UINTN             *Value
-  )
-{
-  EFI_STATUS    Status = EFI_SUCCESS;
-
-  if (    (Value == NULL)
-      ||  (Gpio > LAST_GPIO_PIN))
-  {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  // Initialize the hardware if not already done
-  if (!mPL061Initialized) {
-    Status = PL061Initialize();
-    if (EFI_ERROR(Status)) {
-      goto EXIT;
-    }
-  }
-
-  if (MmioRead8 (PL061_GPIO_DATA_REG) & GPIO_PIN_MASK_HIGH_8BIT(Gpio)) {
-    *Value = 1;
-  } else {
-    *Value = 0;
-  }
-
-  EXIT:
-  return Status;
-}
-
-/**
-
-Routine Description:
-
-  Sets the state of a GPIO pin
-
-Arguments:
-
-  This  - pointer to protocol
-  Gpio  - which pin to modify
-  Mode  - mode to set
-
-Returns:
-
-  EFI_SUCCESS           - GPIO set as requested
-  EFI_UNSUPPORTED       - Mode is not supported
-  EFI_INVALID_PARAMETER - Gpio pin is out of range
-**/
-EFI_STATUS
-EFIAPI
-Set (
-  IN  EMBEDDED_GPIO       *This,
-  IN  EMBEDDED_GPIO_PIN   Gpio,
-  IN  EMBEDDED_GPIO_MODE  Mode
-  )
-{
-  EFI_STATUS    Status = EFI_SUCCESS;
-
-  // Check for errors
-  if (Gpio > LAST_GPIO_PIN) {
-    Status = EFI_INVALID_PARAMETER;
-    goto EXIT;
-  }
-
-  // Initialize the hardware if not already done
-  if (!mPL061Initialized) {
-    Status = PL061Initialize();
-    if (EFI_ERROR(Status)) {
-      goto EXIT;
-    }
-  }
-
-  switch (Mode)
-  {
-    case GPIO_MODE_INPUT:
-      // Set the corresponding direction bit to LOW for input
-      MmioAnd8 (PL061_GPIO_DIR_REG, GPIO_PIN_MASK_LOW_8BIT(Gpio));
-      break;
-
-    case GPIO_MODE_OUTPUT_0:
-      // Set the corresponding data bit to LOW for 0
-      MmioAnd8 (PL061_GPIO_DATA_REG, GPIO_PIN_MASK_LOW_8BIT(Gpio));
-      // Set the corresponding direction bit to HIGH for output
-      MmioOr8 (PL061_GPIO_DIR_REG, GPIO_PIN_MASK_HIGH_8BIT(Gpio));
-      break;
-
-    case GPIO_MODE_OUTPUT_1:
-      // Set the corresponding data bit to HIGH for 1
-      MmioOr8 (PL061_GPIO_DATA_REG, GPIO_PIN_MASK_HIGH_8BIT(Gpio));
-      // Set the corresponding direction bit to HIGH for output
-      MmioOr8 (PL061_GPIO_DIR_REG, GPIO_PIN_MASK_HIGH_8BIT(Gpio));
-      break;
-
-    default:
-      // Other modes are not supported
-      return EFI_UNSUPPORTED;
-  }
-
-EXIT:
-  return Status;
-}
-
-/**
-
-Routine Description:
-
-  Gets the mode (function) of a GPIO pin
-
-Arguments:
-
-  This  - pointer to protocol
-  Gpio  - which pin
-  Mode  - pointer to output mode value
-
-Returns:
-
-  EFI_SUCCESS           - mode value retrieved
-  EFI_INVALID_PARAMETER - Mode is a null pointer or Gpio pin is out of range
-
-**/
-EFI_STATUS
-EFIAPI
-GetMode (
-  IN  EMBEDDED_GPIO       *This,
-  IN  EMBEDDED_GPIO_PIN   Gpio,
-  OUT EMBEDDED_GPIO_MODE  *Mode
-  )
-{
-  EFI_STATUS Status;
-
-  // Check for errors
-  if (    (Mode == NULL)
-      ||  (Gpio > LAST_GPIO_PIN)) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  // Initialize the hardware if not already done
-  if (!mPL061Initialized) {
-    Status = PL061Initialize();
-    if (EFI_ERROR(Status)) {
-      return Status;
-    }
-  }
-
-  // Check if it is input or output
-  if (MmioRead8 (PL061_GPIO_DIR_REG) & GPIO_PIN_MASK_HIGH_8BIT(Gpio)) {
-    // Pin set to output
-    if (MmioRead8 (PL061_GPIO_DATA_REG) & GPIO_PIN_MASK_HIGH_8BIT(Gpio)) {
-      *Mode = GPIO_MODE_OUTPUT_1;
-    } else {
-      *Mode = GPIO_MODE_OUTPUT_0;
-    }
-  } else {
-    // Pin set to input
-    *Mode = GPIO_MODE_INPUT;
-  }
-
-  return EFI_SUCCESS;
-}
-
-/**
-
-Routine Description:
-
-  Sets the pull-up / pull-down resistor of a GPIO pin
-
-Arguments:
-
-  This  - pointer to protocol
-  Gpio  - which pin
-  Direction - pull-up, pull-down, or none
-
-Returns:
-
-  EFI_UNSUPPORTED - Can not perform the requested operation
-
-**/
-EFI_STATUS
-EFIAPI
-SetPull (
-  IN  EMBEDDED_GPIO       *This,
-  IN  EMBEDDED_GPIO_PIN   Gpio,
-  IN  EMBEDDED_GPIO_PULL  Direction
-  )
-{
-  return EFI_UNSUPPORTED;
-}
-
-/**
- Protocol variable definition
- **/
-EMBEDDED_GPIO gGpio = {
-  Get,
-  Set,
-  GetMode,
-  SetPull
-};
-
-/**
-  Initialize the state information for the Embedded Gpio protocol.
-
-  @param  ImageHandle   of the loaded driver
-  @param  SystemTable   Pointer to the System Table
-
-  @retval EFI_SUCCESS           Protocol registered
-  @retval EFI_OUT_OF_RESOURCES  Cannot allocate protocol data structure
-  @retval EFI_DEVICE_ERROR      Hardware problems
-
-**/
-EFI_STATUS
-EFIAPI
-PL061InstallProtocol (
-  IN EFI_HANDLE         ImageHandle,
-  IN EFI_SYSTEM_TABLE   *SystemTable
-  )
-{
-  EFI_STATUS  Status;
-  EFI_HANDLE  Handle;
-
-  //
-  // Make sure the Gpio protocol has not been installed in the system yet.
-  //
-  ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL, &gEmbeddedGpioProtocolGuid);
-
-  // Install the Embedded GPIO Protocol onto a new handle
-  Handle = NULL;
-  Status = gBS->InstallMultipleProtocolInterfaces(
-                  &Handle,
-                  &gEmbeddedGpioProtocolGuid, &gGpio,
-                  NULL
-                 );
-  if (EFI_ERROR(Status)) {
-    Status = EFI_OUT_OF_RESOURCES;
-  }
-
-  return Status;
-}
+/** @file

+*

+*  Copyright (c) 2011, ARM Limited. All rights reserved.

+*

+*  This program and the accompanying materials

+*  are licensed and made available under the terms and conditions of the BSD License

+*  which accompanies this distribution.  The full text of the license may be found at

+*  http://opensource.org/licenses/bsd-license.php

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+*

+**/

+

+

+#include <PiDxe.h>

+

+#include <Library/BaseLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/DebugLib.h>

+#include <Library/IoLib.h>

+#include <Library/PcdLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/UefiLib.h>

+#include <Library/UefiRuntimeServicesTableLib.h>

+

+#include <Protocol/EmbeddedGpio.h>

+#include <Drivers/PL061Gpio.h>

+

+BOOLEAN     mPL061Initialized = FALSE;

+

+/**

+  Function implementations

+**/

+

+EFI_STATUS

+PL061Identify (

+  VOID

+  )

+{

+  // Check if this is a PrimeCell Peripheral

+  if (    (MmioRead8 (PL061_GPIO_PCELL_ID0) != 0x0D)

+      ||  (MmioRead8 (PL061_GPIO_PCELL_ID1) != 0xF0)

+      ||  (MmioRead8 (PL061_GPIO_PCELL_ID2) != 0x05)

+      ||  (MmioRead8 (PL061_GPIO_PCELL_ID3) != 0xB1)) {

+    return EFI_NOT_FOUND;

+  }

+

+  // Check if this PrimeCell Peripheral is the PL061 GPIO

+  if (    (MmioRead8 (PL061_GPIO_PERIPH_ID0) != 0x61)

+      ||  (MmioRead8 (PL061_GPIO_PERIPH_ID1) != 0x10)

+      ||  ((MmioRead8 (PL061_GPIO_PERIPH_ID2) & 0xF) != 0x04)

+      ||  (MmioRead8 (PL061_GPIO_PERIPH_ID3) != 0x00)) {

+    return EFI_NOT_FOUND;

+  }

+

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+PL061Initialize (

+  VOID

+  )

+{

+  EFI_STATUS  Status;

+

+  // Check if the PL061 GPIO module exists on board

+  Status = PL061Identify();

+  if (EFI_ERROR (Status)) {

+    Status = EFI_DEVICE_ERROR;

+    goto EXIT;

+  }

+

+  // Do other hardware initialisation things here as required

+

+  // Disable Interrupts

+  //if (MmioRead8 (PL061_GPIO_IE_REG) != 0) {

+  //   // Ensure interrupts are disabled

+  //}

+

+  mPL061Initialized = TRUE;

+

+  EXIT:

+  return Status;

+}

+

+/**

+

+Routine Description:

+

+  Gets the state of a GPIO pin

+

+Arguments:

+

+  This  - pointer to protocol

+  Gpio  - which pin to read

+  Value - state of the pin

+

+Returns:

+

+  EFI_SUCCESS           - GPIO state returned in Value

+  EFI_INVALID_PARAMETER - Value is NULL pointer or Gpio pin is out of range

+**/

+EFI_STATUS

+EFIAPI

+Get (

+  IN  EMBEDDED_GPIO     *This,

+  IN  EMBEDDED_GPIO_PIN Gpio,

+  OUT UINTN             *Value

+  )

+{

+  EFI_STATUS    Status = EFI_SUCCESS;

+

+  if (    (Value == NULL)

+      ||  (Gpio > LAST_GPIO_PIN))

+  {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  // Initialize the hardware if not already done

+  if (!mPL061Initialized) {

+    Status = PL061Initialize();

+    if (EFI_ERROR(Status)) {

+      goto EXIT;

+    }

+  }

+

+  if (MmioRead8 (PL061_GPIO_DATA_REG) & GPIO_PIN_MASK_HIGH_8BIT(Gpio)) {

+    *Value = 1;

+  } else {

+    *Value = 0;

+  }

+

+  EXIT:

+  return Status;

+}

+

+/**

+

+Routine Description:

+

+  Sets the state of a GPIO pin

+

+Arguments:

+

+  This  - pointer to protocol

+  Gpio  - which pin to modify

+  Mode  - mode to set

+

+Returns:

+

+  EFI_SUCCESS           - GPIO set as requested

+  EFI_UNSUPPORTED       - Mode is not supported

+  EFI_INVALID_PARAMETER - Gpio pin is out of range

+**/

+EFI_STATUS

+EFIAPI

+Set (

+  IN  EMBEDDED_GPIO       *This,

+  IN  EMBEDDED_GPIO_PIN   Gpio,

+  IN  EMBEDDED_GPIO_MODE  Mode

+  )

+{

+  EFI_STATUS    Status = EFI_SUCCESS;

+

+  // Check for errors

+  if (Gpio > LAST_GPIO_PIN) {

+    Status = EFI_INVALID_PARAMETER;

+    goto EXIT;

+  }

+

+  // Initialize the hardware if not already done

+  if (!mPL061Initialized) {

+    Status = PL061Initialize();

+    if (EFI_ERROR(Status)) {

+      goto EXIT;

+    }

+  }

+

+  switch (Mode)

+  {

+    case GPIO_MODE_INPUT:

+      // Set the corresponding direction bit to LOW for input

+      MmioAnd8 (PL061_GPIO_DIR_REG, GPIO_PIN_MASK_LOW_8BIT(Gpio));

+      break;

+

+    case GPIO_MODE_OUTPUT_0:

+      // Set the corresponding data bit to LOW for 0

+      MmioAnd8 (PL061_GPIO_DATA_REG, GPIO_PIN_MASK_LOW_8BIT(Gpio));

+      // Set the corresponding direction bit to HIGH for output

+      MmioOr8 (PL061_GPIO_DIR_REG, GPIO_PIN_MASK_HIGH_8BIT(Gpio));

+      break;

+

+    case GPIO_MODE_OUTPUT_1:

+      // Set the corresponding data bit to HIGH for 1

+      MmioOr8 (PL061_GPIO_DATA_REG, GPIO_PIN_MASK_HIGH_8BIT(Gpio));

+      // Set the corresponding direction bit to HIGH for output

+      MmioOr8 (PL061_GPIO_DIR_REG, GPIO_PIN_MASK_HIGH_8BIT(Gpio));

+      break;

+

+    default:

+      // Other modes are not supported

+      return EFI_UNSUPPORTED;

+  }

+

+EXIT:

+  return Status;

+}

+

+/**

+

+Routine Description:

+

+  Gets the mode (function) of a GPIO pin

+

+Arguments:

+

+  This  - pointer to protocol

+  Gpio  - which pin

+  Mode  - pointer to output mode value

+

+Returns:

+

+  EFI_SUCCESS           - mode value retrieved

+  EFI_INVALID_PARAMETER - Mode is a null pointer or Gpio pin is out of range

+

+**/

+EFI_STATUS

+EFIAPI

+GetMode (

+  IN  EMBEDDED_GPIO       *This,

+  IN  EMBEDDED_GPIO_PIN   Gpio,

+  OUT EMBEDDED_GPIO_MODE  *Mode

+  )

+{

+  EFI_STATUS Status;

+

+  // Check for errors

+  if (    (Mode == NULL)

+      ||  (Gpio > LAST_GPIO_PIN)) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  // Initialize the hardware if not already done

+  if (!mPL061Initialized) {

+    Status = PL061Initialize();

+    if (EFI_ERROR(Status)) {

+      return Status;

+    }

+  }

+

+  // Check if it is input or output

+  if (MmioRead8 (PL061_GPIO_DIR_REG) & GPIO_PIN_MASK_HIGH_8BIT(Gpio)) {

+    // Pin set to output

+    if (MmioRead8 (PL061_GPIO_DATA_REG) & GPIO_PIN_MASK_HIGH_8BIT(Gpio)) {

+      *Mode = GPIO_MODE_OUTPUT_1;

+    } else {

+      *Mode = GPIO_MODE_OUTPUT_0;

+    }

+  } else {

+    // Pin set to input

+    *Mode = GPIO_MODE_INPUT;

+  }

+

+  return EFI_SUCCESS;

+}

+

+/**

+

+Routine Description:

+

+  Sets the pull-up / pull-down resistor of a GPIO pin

+

+Arguments:

+

+  This  - pointer to protocol

+  Gpio  - which pin

+  Direction - pull-up, pull-down, or none

+

+Returns:

+

+  EFI_UNSUPPORTED - Can not perform the requested operation

+

+**/

+EFI_STATUS

+EFIAPI

+SetPull (

+  IN  EMBEDDED_GPIO       *This,

+  IN  EMBEDDED_GPIO_PIN   Gpio,

+  IN  EMBEDDED_GPIO_PULL  Direction

+  )

+{

+  return EFI_UNSUPPORTED;

+}

+

+/**

+ Protocol variable definition

+ **/

+EMBEDDED_GPIO gGpio = {

+  Get,

+  Set,

+  GetMode,

+  SetPull

+};

+

+/**

+  Initialize the state information for the Embedded Gpio protocol.

+

+  @param  ImageHandle   of the loaded driver

+  @param  SystemTable   Pointer to the System Table

+

+  @retval EFI_SUCCESS           Protocol registered

+  @retval EFI_OUT_OF_RESOURCES  Cannot allocate protocol data structure

+  @retval EFI_DEVICE_ERROR      Hardware problems

+

+**/

+EFI_STATUS

+EFIAPI

+PL061InstallProtocol (

+  IN EFI_HANDLE         ImageHandle,

+  IN EFI_SYSTEM_TABLE   *SystemTable

+  )

+{

+  EFI_STATUS  Status;

+  EFI_HANDLE  Handle;

+

+  //

+  // Make sure the Gpio protocol has not been installed in the system yet.

+  //

+  ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL, &gEmbeddedGpioProtocolGuid);

+

+  // Install the Embedded GPIO Protocol onto a new handle

+  Handle = NULL;

+  Status = gBS->InstallMultipleProtocolInterfaces(

+                  &Handle,

+                  &gEmbeddedGpioProtocolGuid, &gGpio,

+                  NULL

+                 );

+  if (EFI_ERROR(Status)) {

+    Status = EFI_OUT_OF_RESOURCES;

+  }

+

+  return Status;

+}

diff --git a/ArmPlatformPkg/Drivers/PL061GpioDxe/PL061GpioDxe.inf b/ArmPlatformPkg/Drivers/PL061GpioDxe/PL061GpioDxe.inf
index b5adda3a..49284d0a 100644
--- a/ArmPlatformPkg/Drivers/PL061GpioDxe/PL061GpioDxe.inf
+++ b/ArmPlatformPkg/Drivers/PL061GpioDxe/PL061GpioDxe.inf
@@ -1,50 +1,50 @@
-/** @file
-*
-*  Copyright (c) 2011, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = PL061GpioDxe
-  FILE_GUID                      = 5c1997d7-8d45-4f21-af3c-2206b8ed8bec
-  MODULE_TYPE                    = DXE_DRIVER
-  VERSION_STRING                 = 1.0
-
-  ENTRY_POINT                    = PL061InstallProtocol
-[Sources.common]
-  PL061Gpio.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  EmbeddedPkg/EmbeddedPkg.dec
-  ArmPkg/ArmPkg.dec
-  ArmPlatformPkg/ArmPlatformPkg.dec
-
-[LibraryClasses]
-  BaseLib
-  BaseMemoryLib
-  DebugLib
-  IoLib
-  PcdLib
-  UefiBootServicesTableLib
-  UefiDriverEntryPoint
-  UefiLib
-  UefiRuntimeServicesTableLib
-
-[Pcd]
-  gArmPlatformTokenSpaceGuid.PcdPL061GpioBase
-
-[Protocols]
-  gEmbeddedGpioProtocolGuid  
-
-[Depex]
-  TRUE
+/** @file

+*

+*  Copyright (c) 2011, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = PL061GpioDxe

+  FILE_GUID                      = 5c1997d7-8d45-4f21-af3c-2206b8ed8bec

+  MODULE_TYPE                    = DXE_DRIVER

+  VERSION_STRING                 = 1.0

+

+  ENTRY_POINT                    = PL061InstallProtocol

+[Sources.common]

+  PL061Gpio.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  EmbeddedPkg/EmbeddedPkg.dec

+  ArmPkg/ArmPkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+

+[LibraryClasses]

+  BaseLib

+  BaseMemoryLib

+  DebugLib

+  IoLib

+  PcdLib

+  UefiBootServicesTableLib

+  UefiDriverEntryPoint

+  UefiLib

+  UefiRuntimeServicesTableLib

+

+[Pcd]

+  gArmPlatformTokenSpaceGuid.PcdPL061GpioBase

+

+[Protocols]

+  gEmbeddedGpioProtocolGuid  

+

+[Depex]

+  TRUE

diff --git a/ArmPlatformPkg/Drivers/SP804TimerDxe/SP804Timer.c b/ArmPlatformPkg/Drivers/SP804TimerDxe/SP804Timer.c
index 71b7a32d..839d34d4 100644
--- a/ArmPlatformPkg/Drivers/SP804TimerDxe/SP804Timer.c
+++ b/ArmPlatformPkg/Drivers/SP804TimerDxe/SP804Timer.c
@@ -1,395 +1,395 @@
-/** @file
-  Template for Timer Architecture Protocol driver of the ARM flavor
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  Copyright (c) 2011 - 2012, ARM Ltd. All rights reserved.<BR>
-  
-  This program and the accompanying materials                          
-  are licensed and made available under the terms and conditions of the BSD License         
-  which accompanies this distribution.  The full text of the license may be found at        
-  http://opensource.org/licenses/bsd-license.php                                            
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-
-**/
-
-
-#include <PiDxe.h>
-
-#include <Library/BaseLib.h>
-#include <Library/DebugLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/UefiBootServicesTableLib.h>
-#include <Library/UefiLib.h>
-#include <Library/PcdLib.h>
-#include <Library/IoLib.h>
-
-#include <Protocol/Timer.h>
-#include <Protocol/HardwareInterrupt.h>
-
-#include <Drivers/SP804Timer.h>
-
-#define SP804_TIMER_PERIODIC_BASE     ((UINTN)PcdGet32 (PcdSP804TimerPeriodicBase))
-#define SP804_TIMER_METRONOME_BASE    ((UINTN)PcdGet32 (PcdSP804TimerMetronomeBase))
-#define SP804_TIMER_PERFORMANCE_BASE  ((UINTN)PcdGet32 (PcdSP804TimerPerformanceBase))
-
-// The notification function to call on every timer interrupt.
-EFI_TIMER_NOTIFY      mTimerNotifyFunction     = (EFI_TIMER_NOTIFY)NULL;
-EFI_EVENT             EfiExitBootServicesEvent = (EFI_EVENT)NULL;
-
-// The current period of the timer interrupt
-UINT64 mTimerPeriod = 0;
-
-// Cached copy of the Hardware Interrupt protocol instance
-EFI_HARDWARE_INTERRUPT_PROTOCOL *gInterrupt = NULL;
-
-// Cached interrupt vector
-UINTN  gVector;
-
-
-/**
-
-  C Interrupt Handler called in the interrupt context when Source interrupt is active.
-
-
-  @param Source         Source of the interrupt. Hardware routing off a specific platform defines
-                        what source means.
-
-  @param SystemContext  Pointer to system register context. Mostly used by debuggers and will
-                        update the system context after the return from the interrupt if 
-                        modified. Don't change these values unless you know what you are doing
-
-**/
-VOID
-EFIAPI
-TimerInterruptHandler (
-  IN  HARDWARE_INTERRUPT_SOURCE   Source,
-  IN  EFI_SYSTEM_CONTEXT          SystemContext       
-  )
-{
-  EFI_TPL OriginalTPL;
-
-  //
-  // DXE core uses this callback for the EFI timer tick. The DXE core uses locks 
-  // that raise to TPL_HIGH and then restore back to current level. Thus we need
-  // to make sure TPL level is set to TPL_HIGH while we are handling the timer tick. 
-  //
-  OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);
-
-  // If the interrupt is shared then we must check if this interrupt source is the one associated to this Timer
-  if (MmioRead32 (SP804_TIMER_PERIODIC_BASE + SP804_TIMER_MSK_INT_STS_REG) != 0) {
-    // Clear the periodic interrupt
-    MmioWrite32 (SP804_TIMER_PERIODIC_BASE + SP804_TIMER_INT_CLR_REG, 0);
-
-    // Signal end of interrupt early to help avoid losing subsequent ticks from long duration handlers
-    gInterrupt->EndOfInterrupt (gInterrupt, Source);
-
-    if (mTimerNotifyFunction) {
-      mTimerNotifyFunction (mTimerPeriod);
-    }
-  }
-
-  gBS->RestoreTPL (OriginalTPL);
-}
-
-/**
-  This function registers the handler NotifyFunction so it is called every time 
-  the timer interrupt fires.  It also passes the amount of time since the last 
-  handler call to the NotifyFunction.  If NotifyFunction is NULL, then the 
-  handler is unregistered.  If the handler is registered, then EFI_SUCCESS is 
-  returned.  If the CPU does not support registering a timer interrupt handler, 
-  then EFI_UNSUPPORTED is returned.  If an attempt is made to register a handler 
-  when a handler is already registered, then EFI_ALREADY_STARTED is returned.  
-  If an attempt is made to unregister a handler when a handler is not registered, 
-  then EFI_INVALID_PARAMETER is returned.  If an error occurs attempting to 
-  register the NotifyFunction with the timer interrupt, then EFI_DEVICE_ERROR 
-  is returned.
-
-  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
-  @param  NotifyFunction   The function to call when a timer interrupt fires. This
-                           function executes at TPL_HIGH_LEVEL. The DXE Core will
-                           register a handler for the timer interrupt, so it can know
-                           how much time has passed. This information is used to
-                           signal timer based events. NULL will unregister the handler.
-  @retval EFI_SUCCESS           The timer handler was registered.
-  @retval EFI_UNSUPPORTED       The platform does not support timer interrupts.
-  @retval EFI_ALREADY_STARTED   NotifyFunction is not NULL, and a handler is already
-                                registered.
-  @retval EFI_INVALID_PARAMETER NotifyFunction is NULL, and a handler was not
-                                previously registered.
-  @retval EFI_DEVICE_ERROR      The timer handler could not be registered.
-
-**/
-EFI_STATUS
-EFIAPI
-TimerDriverRegisterHandler (
-  IN EFI_TIMER_ARCH_PROTOCOL  *This,
-  IN EFI_TIMER_NOTIFY         NotifyFunction
-  )
-{
-  if ((NotifyFunction == NULL) && (mTimerNotifyFunction == NULL)) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  if ((NotifyFunction != NULL) && (mTimerNotifyFunction != NULL)) {
-    return EFI_ALREADY_STARTED;
-  }
-
-  mTimerNotifyFunction = NotifyFunction;
-
-  return EFI_SUCCESS;
-}
-
-/**
-    Make sure all Dual Timers are disabled
-**/
-VOID
-EFIAPI
-ExitBootServicesEvent (
-  IN EFI_EVENT  Event,
-  IN VOID       *Context
-  )
-{
-  // Disable 'Periodic Operation' timer if enabled
-  if (MmioRead32(SP804_TIMER_PERIODIC_BASE + SP804_TIMER_CONTROL_REG) & SP804_TIMER_CTRL_ENABLE) {
-    MmioAnd32 (SP804_TIMER_PERIODIC_BASE + SP804_TIMER_CONTROL_REG, 0);
-  }
-
-  // Disable 'Metronome/Delay' timer if enabled
-  if (MmioRead32(SP804_TIMER_METRONOME_BASE + SP804_TIMER_CONTROL_REG) & SP804_TIMER_CTRL_ENABLE) {
-    MmioAnd32 (SP804_TIMER_METRONOME_BASE + SP804_TIMER_CONTROL_REG, 0);
-  }
-
-  // Disable 'Performance' timer if enabled
-  if (MmioRead32(SP804_TIMER_PERFORMANCE_BASE + SP804_TIMER_CONTROL_REG) & SP804_TIMER_CTRL_ENABLE) {
-    MmioAnd32 (SP804_TIMER_PERFORMANCE_BASE + SP804_TIMER_CONTROL_REG, 0);
-  }
-}
-
-/**
-
-  This function adjusts the period of timer interrupts to the value specified 
-  by TimerPeriod.  If the timer period is updated, then the selected timer 
-  period is stored in EFI_TIMER.TimerPeriod, and EFI_SUCCESS is returned.  If 
-  the timer hardware is not programmable, then EFI_UNSUPPORTED is returned.  
-  If an error occurs while attempting to update the timer period, then the 
-  timer hardware will be put back in its state prior to this call, and 
-  EFI_DEVICE_ERROR is returned.  If TimerPeriod is 0, then the timer interrupt 
-  is disabled.  This is not the same as disabling the CPU's interrupts.  
-  Instead, it must either turn off the timer hardware, or it must adjust the 
-  interrupt controller so that a CPU interrupt is not generated when the timer 
-  interrupt fires. 
-
-  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
-  @param  TimerPeriod      The rate to program the timer interrupt in 100 nS units. If
-                           the timer hardware is not programmable, then EFI_UNSUPPORTED is
-                           returned. If the timer is programmable, then the timer period
-                           will be rounded up to the nearest timer period that is supported
-                           by the timer hardware. If TimerPeriod is set to 0, then the
-                           timer interrupts will be disabled.
-
-
-  @retval EFI_SUCCESS           The timer period was changed.
-  @retval EFI_UNSUPPORTED       The platform cannot change the period of the timer interrupt.
-  @retval EFI_DEVICE_ERROR      The timer period could not be changed due to a device error.
-
-**/
-EFI_STATUS
-EFIAPI
-TimerDriverSetTimerPeriod (
-  IN EFI_TIMER_ARCH_PROTOCOL  *This,
-  IN UINT64                   TimerPeriod
-  )
-{
-  EFI_STATUS  Status;
-  UINT64      TimerTicks;
-  
-  // always disable the timer
-  MmioAnd32 (SP804_TIMER_PERIODIC_BASE + SP804_TIMER_CONTROL_REG, ~SP804_TIMER_CTRL_ENABLE);
-
-  if (TimerPeriod == 0) {
-    // Leave timer disabled from above, and...
-
-    // Disable timer 0/1 interrupt for a TimerPeriod of 0
-    Status = gInterrupt->DisableInterruptSource (gInterrupt, gVector);    
-  } else {  
-    // Convert TimerPeriod into 1MHz clock counts (us units = 100ns units * 10)
-    TimerTicks = DivU64x32 (TimerPeriod, 10);
-    TimerTicks = MultU64x32 (TimerTicks, PcdGet32(PcdSP804TimerFrequencyInMHz));
-
-    // if it's larger than 32-bits, pin to highest value
-    if (TimerTicks > 0xffffffff) {
-      TimerTicks = 0xffffffff;
-    }
-
-    // Program the SP804 timer with the new count value
-    MmioWrite32 (SP804_TIMER_PERIODIC_BASE + SP804_TIMER_LOAD_REG, TimerTicks);
-
-    // enable the timer
-    MmioOr32 (SP804_TIMER_PERIODIC_BASE + SP804_TIMER_CONTROL_REG, SP804_TIMER_CTRL_ENABLE);
-
-    // enable timer 0/1 interrupts
-    Status = gInterrupt->EnableInterruptSource (gInterrupt, gVector);    
-  }
-
-  // Save the new timer period
-  mTimerPeriod = TimerPeriod;
-  return Status;
-}
-
-/**
-  This function retrieves the period of timer interrupts in 100 ns units, 
-  returns that value in TimerPeriod, and returns EFI_SUCCESS.  If TimerPeriod 
-  is NULL, then EFI_INVALID_PARAMETER is returned.  If a TimerPeriod of 0 is 
-  returned, then the timer is currently disabled.
-
-  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
-  @param  TimerPeriod      A pointer to the timer period to retrieve in 100 ns units. If
-                           0 is returned, then the timer is currently disabled.
-
-
-  @retval EFI_SUCCESS           The timer period was returned in TimerPeriod.
-  @retval EFI_INVALID_PARAMETER TimerPeriod is NULL.
-
-**/
-EFI_STATUS
-EFIAPI
-TimerDriverGetTimerPeriod (
-  IN EFI_TIMER_ARCH_PROTOCOL   *This,
-  OUT UINT64                   *TimerPeriod
-  )
-{
-  if (TimerPeriod == NULL) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  *TimerPeriod = mTimerPeriod;
-  return EFI_SUCCESS;
-}
-
-/**
-  This function generates a soft timer interrupt. If the platform does not support soft 
-  timer interrupts, then EFI_UNSUPPORTED is returned. Otherwise, EFI_SUCCESS is returned. 
-  If a handler has been registered through the EFI_TIMER_ARCH_PROTOCOL.RegisterHandler() 
-  service, then a soft timer interrupt will be generated. If the timer interrupt is 
-  enabled when this service is called, then the registered handler will be invoked. The 
-  registered handler should not be able to distinguish a hardware-generated timer 
-  interrupt from a software-generated timer interrupt.
-
-  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
-
-  @retval EFI_SUCCESS           The soft timer interrupt was generated.
-  @retval EFI_UNSUPPORTED       The platform does not support the generation of soft timer interrupts.
-
-**/
-EFI_STATUS
-EFIAPI
-TimerDriverGenerateSoftInterrupt (
-  IN EFI_TIMER_ARCH_PROTOCOL  *This
-  )
-{
-  return EFI_UNSUPPORTED;
-}
-
-/**
-  Interface structure for the Timer Architectural Protocol.
-
-  @par Protocol Description:
-  This protocol provides the services to initialize a periodic timer 
-  interrupt, and to register a handler that is called each time the timer
-  interrupt fires.  It may also provide a service to adjust the rate of the
-  periodic timer interrupt.  When a timer interrupt occurs, the handler is 
-  passed the amount of time that has passed since the previous timer 
-  interrupt.
-
-  @param RegisterHandler
-  Registers a handler that will be called each time the 
-  timer interrupt fires.  TimerPeriod defines the minimum 
-  time between timer interrupts, so TimerPeriod will also 
-  be the minimum time between calls to the registered 
-  handler.
-
-  @param SetTimerPeriod
-  Sets the period of the timer interrupt in 100 nS units.  
-  This function is optional, and may return EFI_UNSUPPORTED.  
-  If this function is supported, then the timer period will 
-  be rounded up to the nearest supported timer period.
-
-
-  @param GetTimerPeriod
-  Retrieves the period of the timer interrupt in 100 nS units.
-
-  @param GenerateSoftInterrupt
-  Generates a soft timer interrupt that simulates the firing of 
-  the timer interrupt. This service can be used to invoke the   registered handler if the timer interrupt has been masked for 
-  a period of time.
-
-**/
-EFI_TIMER_ARCH_PROTOCOL   gTimer = {
-  TimerDriverRegisterHandler,
-  TimerDriverSetTimerPeriod,
-  TimerDriverGetTimerPeriod,
-  TimerDriverGenerateSoftInterrupt
-};
-
-
-/**
-  Initialize the state information for the Timer Architectural Protocol and
-  the Timer Debug support protocol that allows the debugger to break into a
-  running program.
-
-  @param  ImageHandle   of the loaded driver
-  @param  SystemTable   Pointer to the System Table
-
-  @retval EFI_SUCCESS           Protocol registered
-  @retval EFI_OUT_OF_RESOURCES  Cannot allocate protocol data structure
-  @retval EFI_DEVICE_ERROR      Hardware problems
-
-**/
-EFI_STATUS
-EFIAPI
-TimerInitialize (
-  IN EFI_HANDLE         ImageHandle,
-  IN EFI_SYSTEM_TABLE   *SystemTable
-  )
-{
-  EFI_HANDLE  Handle = NULL;
-  EFI_STATUS  Status;
-
-  // Set the interrupt timer number
-  gVector = PcdGet32(PcdSP804TimerPeriodicInterruptNum);
-
-  // Find the interrupt controller protocol.  ASSERT if not found.
-  Status = gBS->LocateProtocol (&gHardwareInterruptProtocolGuid, NULL, (VOID **)&gInterrupt);
-  ASSERT_EFI_ERROR (Status);
-
-  // Disable the timer
-  Status = TimerDriverSetTimerPeriod (&gTimer, 0);
-  ASSERT_EFI_ERROR (Status);
-
-  // Install interrupt handler
-  Status = gInterrupt->RegisterInterruptSource (gInterrupt, gVector, TimerInterruptHandler);
-  ASSERT_EFI_ERROR (Status);
-
-  // configure timer 0 for periodic operation, 32 bits, no prescaler, and interrupt enabled
-  MmioWrite32 (SP804_TIMER_PERIODIC_BASE + SP804_TIMER_CONTROL_REG, SP804_TIMER_CTRL_PERIODIC | SP804_TIMER_CTRL_32BIT | SP804_PRESCALE_DIV_1 | SP804_TIMER_CTRL_INT_ENABLE);
-
-  // Set up default timer
-  Status = TimerDriverSetTimerPeriod (&gTimer, FixedPcdGet32(PcdTimerPeriod)); // TIMER_DEFAULT_PERIOD
-  ASSERT_EFI_ERROR (Status);
-
-  // Install the Timer Architectural Protocol onto a new handle
-  Status = gBS->InstallMultipleProtocolInterfaces(
-                  &Handle,
-                  &gEfiTimerArchProtocolGuid,      &gTimer,
-                  NULL
-                  );
-  ASSERT_EFI_ERROR(Status);
-
-  // Register for an ExitBootServicesEvent
-  Status = gBS->CreateEvent (EVT_SIGNAL_EXIT_BOOT_SERVICES, TPL_NOTIFY, ExitBootServicesEvent, NULL, &EfiExitBootServicesEvent);
-  ASSERT_EFI_ERROR (Status);
-
-  return Status;
-}
+/** @file

+  Template for Timer Architecture Protocol driver of the ARM flavor

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  Copyright (c) 2011 - 2012, ARM Ltd. All rights reserved.<BR>

+  

+  This program and the accompanying materials                          

+  are licensed and made available under the terms and conditions of the BSD License         

+  which accompanies this distribution.  The full text of the license may be found at        

+  http://opensource.org/licenses/bsd-license.php                                            

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+

+**/

+

+

+#include <PiDxe.h>

+

+#include <Library/BaseLib.h>

+#include <Library/DebugLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/UefiLib.h>

+#include <Library/PcdLib.h>

+#include <Library/IoLib.h>

+

+#include <Protocol/Timer.h>

+#include <Protocol/HardwareInterrupt.h>

+

+#include <Drivers/SP804Timer.h>

+

+#define SP804_TIMER_PERIODIC_BASE     ((UINTN)PcdGet32 (PcdSP804TimerPeriodicBase))

+#define SP804_TIMER_METRONOME_BASE    ((UINTN)PcdGet32 (PcdSP804TimerMetronomeBase))

+#define SP804_TIMER_PERFORMANCE_BASE  ((UINTN)PcdGet32 (PcdSP804TimerPerformanceBase))

+

+// The notification function to call on every timer interrupt.

+EFI_TIMER_NOTIFY      mTimerNotifyFunction     = (EFI_TIMER_NOTIFY)NULL;

+EFI_EVENT             EfiExitBootServicesEvent = (EFI_EVENT)NULL;

+

+// The current period of the timer interrupt

+UINT64 mTimerPeriod = 0;

+

+// Cached copy of the Hardware Interrupt protocol instance

+EFI_HARDWARE_INTERRUPT_PROTOCOL *gInterrupt = NULL;

+

+// Cached interrupt vector

+UINTN  gVector;

+

+

+/**

+

+  C Interrupt Handler called in the interrupt context when Source interrupt is active.

+

+

+  @param Source         Source of the interrupt. Hardware routing off a specific platform defines

+                        what source means.

+

+  @param SystemContext  Pointer to system register context. Mostly used by debuggers and will

+                        update the system context after the return from the interrupt if 

+                        modified. Don't change these values unless you know what you are doing

+

+**/

+VOID

+EFIAPI

+TimerInterruptHandler (

+  IN  HARDWARE_INTERRUPT_SOURCE   Source,

+  IN  EFI_SYSTEM_CONTEXT          SystemContext       

+  )

+{

+  EFI_TPL OriginalTPL;

+

+  //

+  // DXE core uses this callback for the EFI timer tick. The DXE core uses locks 

+  // that raise to TPL_HIGH and then restore back to current level. Thus we need

+  // to make sure TPL level is set to TPL_HIGH while we are handling the timer tick. 

+  //

+  OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);

+

+  // If the interrupt is shared then we must check if this interrupt source is the one associated to this Timer

+  if (MmioRead32 (SP804_TIMER_PERIODIC_BASE + SP804_TIMER_MSK_INT_STS_REG) != 0) {

+    // Clear the periodic interrupt

+    MmioWrite32 (SP804_TIMER_PERIODIC_BASE + SP804_TIMER_INT_CLR_REG, 0);

+

+    // Signal end of interrupt early to help avoid losing subsequent ticks from long duration handlers

+    gInterrupt->EndOfInterrupt (gInterrupt, Source);

+

+    if (mTimerNotifyFunction) {

+      mTimerNotifyFunction (mTimerPeriod);

+    }

+  }

+

+  gBS->RestoreTPL (OriginalTPL);

+}

+

+/**

+  This function registers the handler NotifyFunction so it is called every time 

+  the timer interrupt fires.  It also passes the amount of time since the last 

+  handler call to the NotifyFunction.  If NotifyFunction is NULL, then the 

+  handler is unregistered.  If the handler is registered, then EFI_SUCCESS is 

+  returned.  If the CPU does not support registering a timer interrupt handler, 

+  then EFI_UNSUPPORTED is returned.  If an attempt is made to register a handler 

+  when a handler is already registered, then EFI_ALREADY_STARTED is returned.  

+  If an attempt is made to unregister a handler when a handler is not registered, 

+  then EFI_INVALID_PARAMETER is returned.  If an error occurs attempting to 

+  register the NotifyFunction with the timer interrupt, then EFI_DEVICE_ERROR 

+  is returned.

+

+  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.

+  @param  NotifyFunction   The function to call when a timer interrupt fires. This

+                           function executes at TPL_HIGH_LEVEL. The DXE Core will

+                           register a handler for the timer interrupt, so it can know

+                           how much time has passed. This information is used to

+                           signal timer based events. NULL will unregister the handler.

+  @retval EFI_SUCCESS           The timer handler was registered.

+  @retval EFI_UNSUPPORTED       The platform does not support timer interrupts.

+  @retval EFI_ALREADY_STARTED   NotifyFunction is not NULL, and a handler is already

+                                registered.

+  @retval EFI_INVALID_PARAMETER NotifyFunction is NULL, and a handler was not

+                                previously registered.

+  @retval EFI_DEVICE_ERROR      The timer handler could not be registered.

+

+**/

+EFI_STATUS

+EFIAPI

+TimerDriverRegisterHandler (

+  IN EFI_TIMER_ARCH_PROTOCOL  *This,

+  IN EFI_TIMER_NOTIFY         NotifyFunction

+  )

+{

+  if ((NotifyFunction == NULL) && (mTimerNotifyFunction == NULL)) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  if ((NotifyFunction != NULL) && (mTimerNotifyFunction != NULL)) {

+    return EFI_ALREADY_STARTED;

+  }

+

+  mTimerNotifyFunction = NotifyFunction;

+

+  return EFI_SUCCESS;

+}

+

+/**

+    Make sure all Dual Timers are disabled

+**/

+VOID

+EFIAPI

+ExitBootServicesEvent (

+  IN EFI_EVENT  Event,

+  IN VOID       *Context

+  )

+{

+  // Disable 'Periodic Operation' timer if enabled

+  if (MmioRead32(SP804_TIMER_PERIODIC_BASE + SP804_TIMER_CONTROL_REG) & SP804_TIMER_CTRL_ENABLE) {

+    MmioAnd32 (SP804_TIMER_PERIODIC_BASE + SP804_TIMER_CONTROL_REG, 0);

+  }

+

+  // Disable 'Metronome/Delay' timer if enabled

+  if (MmioRead32(SP804_TIMER_METRONOME_BASE + SP804_TIMER_CONTROL_REG) & SP804_TIMER_CTRL_ENABLE) {

+    MmioAnd32 (SP804_TIMER_METRONOME_BASE + SP804_TIMER_CONTROL_REG, 0);

+  }

+

+  // Disable 'Performance' timer if enabled

+  if (MmioRead32(SP804_TIMER_PERFORMANCE_BASE + SP804_TIMER_CONTROL_REG) & SP804_TIMER_CTRL_ENABLE) {

+    MmioAnd32 (SP804_TIMER_PERFORMANCE_BASE + SP804_TIMER_CONTROL_REG, 0);

+  }

+}

+

+/**

+

+  This function adjusts the period of timer interrupts to the value specified 

+  by TimerPeriod.  If the timer period is updated, then the selected timer 

+  period is stored in EFI_TIMER.TimerPeriod, and EFI_SUCCESS is returned.  If 

+  the timer hardware is not programmable, then EFI_UNSUPPORTED is returned.  

+  If an error occurs while attempting to update the timer period, then the 

+  timer hardware will be put back in its state prior to this call, and 

+  EFI_DEVICE_ERROR is returned.  If TimerPeriod is 0, then the timer interrupt 

+  is disabled.  This is not the same as disabling the CPU's interrupts.  

+  Instead, it must either turn off the timer hardware, or it must adjust the 

+  interrupt controller so that a CPU interrupt is not generated when the timer 

+  interrupt fires. 

+

+  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.

+  @param  TimerPeriod      The rate to program the timer interrupt in 100 nS units. If

+                           the timer hardware is not programmable, then EFI_UNSUPPORTED is

+                           returned. If the timer is programmable, then the timer period

+                           will be rounded up to the nearest timer period that is supported

+                           by the timer hardware. If TimerPeriod is set to 0, then the

+                           timer interrupts will be disabled.

+

+

+  @retval EFI_SUCCESS           The timer period was changed.

+  @retval EFI_UNSUPPORTED       The platform cannot change the period of the timer interrupt.

+  @retval EFI_DEVICE_ERROR      The timer period could not be changed due to a device error.

+

+**/

+EFI_STATUS

+EFIAPI

+TimerDriverSetTimerPeriod (

+  IN EFI_TIMER_ARCH_PROTOCOL  *This,

+  IN UINT64                   TimerPeriod

+  )

+{

+  EFI_STATUS  Status;

+  UINT64      TimerTicks;

+  

+  // always disable the timer

+  MmioAnd32 (SP804_TIMER_PERIODIC_BASE + SP804_TIMER_CONTROL_REG, ~SP804_TIMER_CTRL_ENABLE);

+

+  if (TimerPeriod == 0) {

+    // Leave timer disabled from above, and...

+

+    // Disable timer 0/1 interrupt for a TimerPeriod of 0

+    Status = gInterrupt->DisableInterruptSource (gInterrupt, gVector);    

+  } else {  

+    // Convert TimerPeriod into 1MHz clock counts (us units = 100ns units * 10)

+    TimerTicks = DivU64x32 (TimerPeriod, 10);

+    TimerTicks = MultU64x32 (TimerTicks, PcdGet32(PcdSP804TimerFrequencyInMHz));

+

+    // if it's larger than 32-bits, pin to highest value

+    if (TimerTicks > 0xffffffff) {

+      TimerTicks = 0xffffffff;

+    }

+

+    // Program the SP804 timer with the new count value

+    MmioWrite32 (SP804_TIMER_PERIODIC_BASE + SP804_TIMER_LOAD_REG, TimerTicks);

+

+    // enable the timer

+    MmioOr32 (SP804_TIMER_PERIODIC_BASE + SP804_TIMER_CONTROL_REG, SP804_TIMER_CTRL_ENABLE);

+

+    // enable timer 0/1 interrupts

+    Status = gInterrupt->EnableInterruptSource (gInterrupt, gVector);    

+  }

+

+  // Save the new timer period

+  mTimerPeriod = TimerPeriod;

+  return Status;

+}

+

+/**

+  This function retrieves the period of timer interrupts in 100 ns units, 

+  returns that value in TimerPeriod, and returns EFI_SUCCESS.  If TimerPeriod 

+  is NULL, then EFI_INVALID_PARAMETER is returned.  If a TimerPeriod of 0 is 

+  returned, then the timer is currently disabled.

+

+  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.

+  @param  TimerPeriod      A pointer to the timer period to retrieve in 100 ns units. If

+                           0 is returned, then the timer is currently disabled.

+

+

+  @retval EFI_SUCCESS           The timer period was returned in TimerPeriod.

+  @retval EFI_INVALID_PARAMETER TimerPeriod is NULL.

+

+**/

+EFI_STATUS

+EFIAPI

+TimerDriverGetTimerPeriod (

+  IN EFI_TIMER_ARCH_PROTOCOL   *This,

+  OUT UINT64                   *TimerPeriod

+  )

+{

+  if (TimerPeriod == NULL) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  *TimerPeriod = mTimerPeriod;

+  return EFI_SUCCESS;

+}

+

+/**

+  This function generates a soft timer interrupt. If the platform does not support soft 

+  timer interrupts, then EFI_UNSUPPORTED is returned. Otherwise, EFI_SUCCESS is returned. 

+  If a handler has been registered through the EFI_TIMER_ARCH_PROTOCOL.RegisterHandler() 

+  service, then a soft timer interrupt will be generated. If the timer interrupt is 

+  enabled when this service is called, then the registered handler will be invoked. The 

+  registered handler should not be able to distinguish a hardware-generated timer 

+  interrupt from a software-generated timer interrupt.

+

+  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.

+

+  @retval EFI_SUCCESS           The soft timer interrupt was generated.

+  @retval EFI_UNSUPPORTED       The platform does not support the generation of soft timer interrupts.

+

+**/

+EFI_STATUS

+EFIAPI

+TimerDriverGenerateSoftInterrupt (

+  IN EFI_TIMER_ARCH_PROTOCOL  *This

+  )

+{

+  return EFI_UNSUPPORTED;

+}

+

+/**

+  Interface structure for the Timer Architectural Protocol.

+

+  @par Protocol Description:

+  This protocol provides the services to initialize a periodic timer 

+  interrupt, and to register a handler that is called each time the timer

+  interrupt fires.  It may also provide a service to adjust the rate of the

+  periodic timer interrupt.  When a timer interrupt occurs, the handler is 

+  passed the amount of time that has passed since the previous timer 

+  interrupt.

+

+  @param RegisterHandler

+  Registers a handler that will be called each time the 

+  timer interrupt fires.  TimerPeriod defines the minimum 

+  time between timer interrupts, so TimerPeriod will also 

+  be the minimum time between calls to the registered 

+  handler.

+

+  @param SetTimerPeriod

+  Sets the period of the timer interrupt in 100 nS units.  

+  This function is optional, and may return EFI_UNSUPPORTED.  

+  If this function is supported, then the timer period will 

+  be rounded up to the nearest supported timer period.

+

+

+  @param GetTimerPeriod

+  Retrieves the period of the timer interrupt in 100 nS units.

+

+  @param GenerateSoftInterrupt

+  Generates a soft timer interrupt that simulates the firing of 

+  the timer interrupt. This service can be used to invoke the   registered handler if the timer interrupt has been masked for 

+  a period of time.

+

+**/

+EFI_TIMER_ARCH_PROTOCOL   gTimer = {

+  TimerDriverRegisterHandler,

+  TimerDriverSetTimerPeriod,

+  TimerDriverGetTimerPeriod,

+  TimerDriverGenerateSoftInterrupt

+};

+

+

+/**

+  Initialize the state information for the Timer Architectural Protocol and

+  the Timer Debug support protocol that allows the debugger to break into a

+  running program.

+

+  @param  ImageHandle   of the loaded driver

+  @param  SystemTable   Pointer to the System Table

+

+  @retval EFI_SUCCESS           Protocol registered

+  @retval EFI_OUT_OF_RESOURCES  Cannot allocate protocol data structure

+  @retval EFI_DEVICE_ERROR      Hardware problems

+

+**/

+EFI_STATUS

+EFIAPI

+TimerInitialize (

+  IN EFI_HANDLE         ImageHandle,

+  IN EFI_SYSTEM_TABLE   *SystemTable

+  )

+{

+  EFI_HANDLE  Handle = NULL;

+  EFI_STATUS  Status;

+

+  // Set the interrupt timer number

+  gVector = PcdGet32(PcdSP804TimerPeriodicInterruptNum);

+

+  // Find the interrupt controller protocol.  ASSERT if not found.

+  Status = gBS->LocateProtocol (&gHardwareInterruptProtocolGuid, NULL, (VOID **)&gInterrupt);

+  ASSERT_EFI_ERROR (Status);

+

+  // Disable the timer

+  Status = TimerDriverSetTimerPeriod (&gTimer, 0);

+  ASSERT_EFI_ERROR (Status);

+

+  // Install interrupt handler

+  Status = gInterrupt->RegisterInterruptSource (gInterrupt, gVector, TimerInterruptHandler);

+  ASSERT_EFI_ERROR (Status);

+

+  // configure timer 0 for periodic operation, 32 bits, no prescaler, and interrupt enabled

+  MmioWrite32 (SP804_TIMER_PERIODIC_BASE + SP804_TIMER_CONTROL_REG, SP804_TIMER_CTRL_PERIODIC | SP804_TIMER_CTRL_32BIT | SP804_PRESCALE_DIV_1 | SP804_TIMER_CTRL_INT_ENABLE);

+

+  // Set up default timer

+  Status = TimerDriverSetTimerPeriod (&gTimer, FixedPcdGet32(PcdTimerPeriod)); // TIMER_DEFAULT_PERIOD

+  ASSERT_EFI_ERROR (Status);

+

+  // Install the Timer Architectural Protocol onto a new handle

+  Status = gBS->InstallMultipleProtocolInterfaces(

+                  &Handle,

+                  &gEfiTimerArchProtocolGuid,      &gTimer,

+                  NULL

+                  );

+  ASSERT_EFI_ERROR(Status);

+

+  // Register for an ExitBootServicesEvent

+  Status = gBS->CreateEvent (EVT_SIGNAL_EXIT_BOOT_SERVICES, TPL_NOTIFY, ExitBootServicesEvent, NULL, &EfiExitBootServicesEvent);

+  ASSERT_EFI_ERROR (Status);

+

+  return Status;

+}

diff --git a/ArmPlatformPkg/Drivers/SP804TimerDxe/SP804TimerDxe.inf b/ArmPlatformPkg/Drivers/SP804TimerDxe/SP804TimerDxe.inf
index 405563b8..8e87adcf 100644
--- a/ArmPlatformPkg/Drivers/SP804TimerDxe/SP804TimerDxe.inf
+++ b/ArmPlatformPkg/Drivers/SP804TimerDxe/SP804TimerDxe.inf
@@ -1,59 +1,59 @@
-#/** @file
-#  
-#    Component description file for Timer module
-#  
-#  Copyright (c) 2009 - 2010, Apple Inc. All rights reserved.<BR>
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = ArmVeTimerDxe
-  FILE_GUID                      = a73d663d-a491-4278-9a69-9521be3379f2 
-  MODULE_TYPE                    = DXE_DRIVER
-  VERSION_STRING                 = 1.0
-
-  ENTRY_POINT                    = TimerInitialize
-
-[Sources.common]
-  SP804Timer.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  EmbeddedPkg/EmbeddedPkg.dec
-  ArmPkg/ArmPkg.dec
-  ArmPlatformPkg/ArmPlatformPkg.dec
-
-[LibraryClasses]
-  BaseLib
-  UefiRuntimeServicesTableLib
-  UefiLib
-  UefiBootServicesTableLib
-  BaseMemoryLib
-  DebugLib
-  UefiDriverEntryPoint
-  IoLib
-
-[Guids]
-
-[Protocols]
-  gEfiTimerArchProtocolGuid  
-  gHardwareInterruptProtocolGuid
-
-[Pcd.common]
-  gArmPlatformTokenSpaceGuid.PcdSP804TimerFrequencyInMHz
-  gArmPlatformTokenSpaceGuid.PcdSP804TimerPeriodicInterruptNum
-  gArmPlatformTokenSpaceGuid.PcdSP804TimerPeriodicBase
-  gArmPlatformTokenSpaceGuid.PcdSP804TimerPerformanceBase
-  gArmPlatformTokenSpaceGuid.PcdSP804TimerMetronomeBase
-  gEmbeddedTokenSpaceGuid.PcdTimerPeriod
-
-[Depex]
-  gHardwareInterruptProtocolGuid
+#/** @file

+#  

+#    Component description file for Timer module

+#  

+#  Copyright (c) 2009 - 2010, Apple Inc. All rights reserved.<BR>

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = ArmVeTimerDxe

+  FILE_GUID                      = a73d663d-a491-4278-9a69-9521be3379f2 

+  MODULE_TYPE                    = DXE_DRIVER

+  VERSION_STRING                 = 1.0

+

+  ENTRY_POINT                    = TimerInitialize

+

+[Sources.common]

+  SP804Timer.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  EmbeddedPkg/EmbeddedPkg.dec

+  ArmPkg/ArmPkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+

+[LibraryClasses]

+  BaseLib

+  UefiRuntimeServicesTableLib

+  UefiLib

+  UefiBootServicesTableLib

+  BaseMemoryLib

+  DebugLib

+  UefiDriverEntryPoint

+  IoLib

+

+[Guids]

+

+[Protocols]

+  gEfiTimerArchProtocolGuid  

+  gHardwareInterruptProtocolGuid

+

+[Pcd.common]

+  gArmPlatformTokenSpaceGuid.PcdSP804TimerFrequencyInMHz

+  gArmPlatformTokenSpaceGuid.PcdSP804TimerPeriodicInterruptNum

+  gArmPlatformTokenSpaceGuid.PcdSP804TimerPeriodicBase

+  gArmPlatformTokenSpaceGuid.PcdSP804TimerPerformanceBase

+  gArmPlatformTokenSpaceGuid.PcdSP804TimerMetronomeBase

+  gEmbeddedTokenSpaceGuid.PcdTimerPeriod

+

+[Depex]

+  gHardwareInterruptProtocolGuid

diff --git a/ArmPlatformPkg/Drivers/SP805WatchdogDxe/SP805Watchdog.c b/ArmPlatformPkg/Drivers/SP805WatchdogDxe/SP805Watchdog.c
index 5b78b2b3..d1da60b5 100644
--- a/ArmPlatformPkg/Drivers/SP805WatchdogDxe/SP805Watchdog.c
+++ b/ArmPlatformPkg/Drivers/SP805WatchdogDxe/SP805Watchdog.c
@@ -1,387 +1,387 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*
-*  This program and the accompanying materials
-*  are licensed and made available under the terms and conditions of the BSD License
-*  which accompanies this distribution.  The full text of the license may be found at
-*  http://opensource.org/licenses/bsd-license.php
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-*
-**/
-
-
-#include <PiDxe.h>
-
-#include <Library/BaseLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/DebugLib.h>
-#include <Library/IoLib.h>
-#include <Library/PcdLib.h>
-#include <Library/UefiBootServicesTableLib.h>
-#include <Library/UefiRuntimeServicesTableLib.h>
-#include <Library/UefiLib.h>
-
-#include <Protocol/WatchdogTimer.h>
-#include <Drivers/SP805Watchdog.h>
-
-EFI_EVENT                           EfiExitBootServicesEvent = (EFI_EVENT)NULL;
-
-/**
-  Make sure the SP805 registers are unlocked for writing.
-
-  Note: The SP805 Watchdog Timer supports locking of its registers,
-  i.e. it inhibits all writes to avoid rogue software accidentally
-  corrupting their contents.
-**/
-inline
-VOID
-SP805Unlock (
-  VOID
-  )
-{
-  if( MmioRead32(SP805_WDOG_LOCK_REG) == SP805_WDOG_LOCK_IS_LOCKED ) {
-    MmioWrite32(SP805_WDOG_LOCK_REG, SP805_WDOG_SPECIAL_UNLOCK_CODE);
-  }
-}
-
-/**
-  Make sure the SP805 registers are locked and can not be overwritten.
-
-  Note: The SP805 Watchdog Timer supports locking of its registers,
-  i.e. it inhibits all writes to avoid rogue software accidentally
-  corrupting their contents.
-**/
-inline
-VOID
-SP805Lock (
-  VOID
-  )
-{
-  if( MmioRead32(SP805_WDOG_LOCK_REG) == SP805_WDOG_LOCK_IS_UNLOCKED ) {
-    // To lock it, just write in any number (except the special unlock code).
-    MmioWrite32(SP805_WDOG_LOCK_REG, SP805_WDOG_LOCK_IS_LOCKED);
-  }
-}
-
-/**
-  Stop the SP805 watchdog timer from counting down by disabling interrupts.
-**/
-inline
-VOID
-SP805Stop (
-  VOID
-  )
-{
-  // Disable interrupts
-  if ( (MmioRead32(SP805_WDOG_CONTROL_REG) & SP805_WDOG_CTRL_INTEN) != 0 ) {
-    MmioAnd32(SP805_WDOG_CONTROL_REG, ~SP805_WDOG_CTRL_INTEN);
-  }
-}
-
-/**
-  Starts the SP805 counting down by enabling interrupts.
-  The count down will start from the value stored in the Load register,
-  not from the value where it was previously stopped.
-**/
-inline
-VOID
-SP805Start (
-  VOID
-  )
-{
-  // Enable interrupts
-  if ( (MmioRead32(SP805_WDOG_CONTROL_REG) & SP805_WDOG_CTRL_INTEN) == 0 ) {
-    MmioOr32(SP805_WDOG_CONTROL_REG, SP805_WDOG_CTRL_INTEN);
-  }
-}
-
-/**
-    On exiting boot services we must make sure the SP805 Watchdog Timer
-    is stopped.
-**/
-VOID
-EFIAPI
-ExitBootServicesEvent (
-  IN EFI_EVENT  Event,
-  IN VOID       *Context
-  )
-{
-  SP805Unlock();
-  SP805Stop();
-  SP805Lock();
-}
-
-/**
-  This function registers the handler NotifyFunction so it is called every time
-  the watchdog timer expires.  It also passes the amount of time since the last
-  handler call to the NotifyFunction.
-  If NotifyFunction is not NULL and a handler is not already registered,
-  then the new handler is registered and EFI_SUCCESS is returned.
-  If NotifyFunction is NULL, and a handler is already registered,
-  then that handler is unregistered.
-  If an attempt is made to register a handler when a handler is already registered,
-  then EFI_ALREADY_STARTED is returned.
-  If an attempt is made to unregister a handler when a handler is not registered,
-  then EFI_INVALID_PARAMETER is returned.
-
-  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
-  @param  NotifyFunction   The function to call when a timer interrupt fires. This
-                           function executes at TPL_HIGH_LEVEL. The DXE Core will
-                           register a handler for the timer interrupt, so it can know
-                           how much time has passed. This information is used to
-                           signal timer based events. NULL will unregister the handler.
-
-  @retval EFI_SUCCESS           The watchdog timer handler was registered.
-  @retval EFI_ALREADY_STARTED   NotifyFunction is not NULL, and a handler is already
-                                registered.
-  @retval EFI_INVALID_PARAMETER NotifyFunction is NULL, and a handler was not
-                                previously registered.
-
-**/
-EFI_STATUS
-EFIAPI
-SP805RegisterHandler (
-  IN CONST EFI_WATCHDOG_TIMER_ARCH_PROTOCOL   *This,
-  IN EFI_WATCHDOG_TIMER_NOTIFY                NotifyFunction
-  )
-{
-  // ERROR: This function is not supported.
-  // The hardware watchdog will reset the board
-  return EFI_INVALID_PARAMETER;
-}
-
-/**
-
-  This function adjusts the period of timer interrupts to the value specified
-  by TimerPeriod.  If the timer period is updated, then the selected timer
-  period is stored in EFI_TIMER.TimerPeriod, and EFI_SUCCESS is returned.  If
-  the timer hardware is not programmable, then EFI_UNSUPPORTED is returned.
-  If an error occurs while attempting to update the timer period, then the
-  timer hardware will be put back in its state prior to this call, and
-  EFI_DEVICE_ERROR is returned.  If TimerPeriod is 0, then the timer interrupt
-  is disabled.  This is not the same as disabling the CPU's interrupts.
-  Instead, it must either turn off the timer hardware, or it must adjust the
-  interrupt controller so that a CPU interrupt is not generated when the timer
-  interrupt fires.
-
-  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
-  @param  TimerPeriod      The rate to program the timer interrupt in 100 nS units. If
-                           the timer hardware is not programmable, then EFI_UNSUPPORTED is
-                           returned. If the timer is programmable, then the timer period
-                           will be rounded up to the nearest timer period that is supported
-                           by the timer hardware. If TimerPeriod is set to 0, then the
-                           timer interrupts will be disabled.
-
-
-  @retval EFI_SUCCESS           The timer period was changed.
-  @retval EFI_UNSUPPORTED       The platform cannot change the period of the timer interrupt.
-  @retval EFI_DEVICE_ERROR      The timer period could not be changed due to a device error.
-
-**/
-EFI_STATUS
-EFIAPI
-SP805SetTimerPeriod (
-  IN CONST EFI_WATCHDOG_TIMER_ARCH_PROTOCOL   *This,
-  IN UINT64                                   TimerPeriod   // In 100ns units
-  )
-{
-  EFI_STATUS  Status = EFI_SUCCESS;
-  UINT64      Ticks64bit;
-
-  SP805Unlock();
-
-  if( TimerPeriod == 0 ) {
-    // This is a watchdog stop request
-    SP805Stop();
-    goto EXIT;
-  } else {
-    // Calculate the Watchdog ticks required for a delay of (TimerTicks * 100) nanoseconds
-    // The SP805 will count down to ZERO once, generate an interrupt and
-    // then it will again reload the initial value and start again.
-    // On the second time when it reaches ZERO, it will actually reset the board.
-    // Therefore, we need to load half the required delay.
-    //
-    // WatchdogTicks = ((TimerPeriod * 100 * SP805_CLOCK_FREQUENCY) / 1GHz) / 2 ;
-    //
-    // i.e.:
-    //
-    // WatchdogTicks = (TimerPeriod * SP805_CLOCK_FREQUENCY) / 20 MHz ;
-
-    Ticks64bit = DivU64x32(MultU64x32(TimerPeriod, (UINTN)PcdGet32(PcdSP805WatchdogClockFrequencyInHz)), 20000000);
-
-    // The registers in the SP805 are only 32 bits
-    if(Ticks64bit > (UINT64)0xFFFFFFFF) {
-      // We could load the watchdog with the maximum supported value but
-      // if a smaller value was requested, this could have the watchdog
-      // triggering before it was intended.
-      // Better generate an error to let the caller know.
-      Status = EFI_DEVICE_ERROR;
-      goto EXIT;
-    }
-
-    // Update the watchdog with a 32-bit value.
-    MmioWrite32(SP805_WDOG_LOAD_REG, (UINT32)Ticks64bit);
-
-    // Start the watchdog
-    SP805Start();
-  }
-
-  EXIT:
-  // Ensure the watchdog is locked before exiting.
-  SP805Lock();
-  return Status;
-}
-
-/**
-  This function retrieves the period of timer interrupts in 100 ns units,
-  returns that value in TimerPeriod, and returns EFI_SUCCESS.  If TimerPeriod
-  is NULL, then EFI_INVALID_PARAMETER is returned.  If a TimerPeriod of 0 is
-  returned, then the timer is currently disabled.
-
-  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
-  @param  TimerPeriod      A pointer to the timer period to retrieve in 100 ns units. If
-                           0 is returned, then the timer is currently disabled.
-
-
-  @retval EFI_SUCCESS           The timer period was returned in TimerPeriod.
-  @retval EFI_INVALID_PARAMETER TimerPeriod is NULL.
-
-**/
-EFI_STATUS
-EFIAPI
-SP805GetTimerPeriod (
-  IN CONST EFI_WATCHDOG_TIMER_ARCH_PROTOCOL   *This,
-  OUT UINT64                                  *TimerPeriod
-  )
-{
-  EFI_STATUS  Status = EFI_SUCCESS;
-  UINT64      ReturnValue;
-
-  if (TimerPeriod == NULL) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  // Check if the watchdog is stopped
-  if ( (MmioRead32(SP805_WDOG_CONTROL_REG) & SP805_WDOG_CTRL_INTEN) == 0 ) {
-    // It is stopped, so return zero.
-    ReturnValue = 0;
-  } else {
-    // Convert the Watchdog ticks into TimerPeriod
-    // Ensure 64bit arithmetic throughout because the Watchdog ticks may already
-    // be at the maximum 32 bit value and we still need to multiply that by 600.
-    ReturnValue = MultU64x32( MmioRead32(SP805_WDOG_LOAD_REG), 600 );
-  }
-
-  *TimerPeriod = ReturnValue;
-
-  return Status;
-}
-
-/**
-  Interface structure for the Watchdog Architectural Protocol.
-
-  @par Protocol Description:
-  This protocol provides a service to set the amount of time to wait
-  before firing the watchdog timer, and it also provides a service to
-  register a handler that is invoked when the watchdog timer fires.
-
-  @par When the watchdog timer fires, control will be passed to a handler
-  if one has been registered.  If no handler has been registered,
-  or the registered handler returns, then the system will be
-  reset by calling the Runtime Service ResetSystem().
-
-  @param RegisterHandler
-  Registers a handler that will be called each time the
-  watchdogtimer interrupt fires.  TimerPeriod defines the minimum
-  time between timer interrupts, so TimerPeriod will also
-  be the minimum time between calls to the registered
-  handler.
-  NOTE: If the watchdog resets the system in hardware, then
-        this function will not have any chance of executing.
-
-  @param SetTimerPeriod
-  Sets the period of the timer interrupt in 100 nS units.
-  This function is optional, and may return EFI_UNSUPPORTED.
-  If this function is supported, then the timer period will
-  be rounded up to the nearest supported timer period.
-
-  @param GetTimerPeriod
-  Retrieves the period of the timer interrupt in 100 nS units.
-
-**/
-EFI_WATCHDOG_TIMER_ARCH_PROTOCOL    gWatchdogTimer = {
-  (EFI_WATCHDOG_TIMER_REGISTER_HANDLER) SP805RegisterHandler,
-  (EFI_WATCHDOG_TIMER_SET_TIMER_PERIOD) SP805SetTimerPeriod,
-  (EFI_WATCHDOG_TIMER_GET_TIMER_PERIOD) SP805GetTimerPeriod
-};
-
-/**
-  Initialize the state information for the Watchdog Timer Architectural Protocol.
-
-  @param  ImageHandle   of the loaded driver
-  @param  SystemTable   Pointer to the System Table
-
-  @retval EFI_SUCCESS           Protocol registered
-  @retval EFI_OUT_OF_RESOURCES  Cannot allocate protocol data structure
-  @retval EFI_DEVICE_ERROR      Hardware problems
-
-**/
-EFI_STATUS
-EFIAPI
-SP805Initialize (
-  IN EFI_HANDLE         ImageHandle,
-  IN EFI_SYSTEM_TABLE   *SystemTable
-  )
-{
-  EFI_STATUS  Status;
-  EFI_HANDLE  Handle;
-
-  // Unlock access to the SP805 registers
-  SP805Unlock ();
-
-  // Stop the watchdog from triggering unexpectedly
-  SP805Stop ();
-
-  // Set the watchdog to reset the board when triggered
-  if ((MmioRead32(SP805_WDOG_CONTROL_REG) & SP805_WDOG_CTRL_RESEN) == 0) {
-    MmioOr32 (SP805_WDOG_CONTROL_REG, SP805_WDOG_CTRL_RESEN);
-  }
-
-  // Prohibit any rogue access to SP805 registers
-  SP805Lock();
-  
-  //
-  // Make sure the Watchdog Timer Architectural Protocol has not been installed in the system yet.
-  // This will avoid conflicts with the universal watchdog
-  //
-  ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL, &gEfiWatchdogTimerArchProtocolGuid);
-
-  // Register for an ExitBootServicesEvent
-  Status = gBS->CreateEvent (EVT_SIGNAL_EXIT_BOOT_SERVICES, TPL_NOTIFY, ExitBootServicesEvent, NULL, &EfiExitBootServicesEvent);
-  if (EFI_ERROR(Status)) {
-    Status = EFI_OUT_OF_RESOURCES;
-    goto EXIT;
-  }
-
-  // Install the Timer Architectural Protocol onto a new handle
-  Handle = NULL;
-  Status = gBS->InstallMultipleProtocolInterfaces(
-                  &Handle,
-                  &gEfiWatchdogTimerArchProtocolGuid, &gWatchdogTimer,
-                  NULL
-                  );
-  if (EFI_ERROR(Status)) {
-    Status = EFI_OUT_OF_RESOURCES;
-    goto EXIT;
-  }
-
-EXIT:
-  if(EFI_ERROR(Status)) {
-    // The watchdog failed to initialize
-    ASSERT(FALSE);
-  }
-  return Status;
-}
+/** @file

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*

+*  This program and the accompanying materials

+*  are licensed and made available under the terms and conditions of the BSD License

+*  which accompanies this distribution.  The full text of the license may be found at

+*  http://opensource.org/licenses/bsd-license.php

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+*

+**/

+

+

+#include <PiDxe.h>

+

+#include <Library/BaseLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/DebugLib.h>

+#include <Library/IoLib.h>

+#include <Library/PcdLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/UefiRuntimeServicesTableLib.h>

+#include <Library/UefiLib.h>

+

+#include <Protocol/WatchdogTimer.h>

+#include <Drivers/SP805Watchdog.h>

+

+EFI_EVENT                           EfiExitBootServicesEvent = (EFI_EVENT)NULL;

+

+/**

+  Make sure the SP805 registers are unlocked for writing.

+

+  Note: The SP805 Watchdog Timer supports locking of its registers,

+  i.e. it inhibits all writes to avoid rogue software accidentally

+  corrupting their contents.

+**/

+inline

+VOID

+SP805Unlock (

+  VOID

+  )

+{

+  if( MmioRead32(SP805_WDOG_LOCK_REG) == SP805_WDOG_LOCK_IS_LOCKED ) {

+    MmioWrite32(SP805_WDOG_LOCK_REG, SP805_WDOG_SPECIAL_UNLOCK_CODE);

+  }

+}

+

+/**

+  Make sure the SP805 registers are locked and can not be overwritten.

+

+  Note: The SP805 Watchdog Timer supports locking of its registers,

+  i.e. it inhibits all writes to avoid rogue software accidentally

+  corrupting their contents.

+**/

+inline

+VOID

+SP805Lock (

+  VOID

+  )

+{

+  if( MmioRead32(SP805_WDOG_LOCK_REG) == SP805_WDOG_LOCK_IS_UNLOCKED ) {

+    // To lock it, just write in any number (except the special unlock code).

+    MmioWrite32(SP805_WDOG_LOCK_REG, SP805_WDOG_LOCK_IS_LOCKED);

+  }

+}

+

+/**

+  Stop the SP805 watchdog timer from counting down by disabling interrupts.

+**/

+inline

+VOID

+SP805Stop (

+  VOID

+  )

+{

+  // Disable interrupts

+  if ( (MmioRead32(SP805_WDOG_CONTROL_REG) & SP805_WDOG_CTRL_INTEN) != 0 ) {

+    MmioAnd32(SP805_WDOG_CONTROL_REG, ~SP805_WDOG_CTRL_INTEN);

+  }

+}

+

+/**

+  Starts the SP805 counting down by enabling interrupts.

+  The count down will start from the value stored in the Load register,

+  not from the value where it was previously stopped.

+**/

+inline

+VOID

+SP805Start (

+  VOID

+  )

+{

+  // Enable interrupts

+  if ( (MmioRead32(SP805_WDOG_CONTROL_REG) & SP805_WDOG_CTRL_INTEN) == 0 ) {

+    MmioOr32(SP805_WDOG_CONTROL_REG, SP805_WDOG_CTRL_INTEN);

+  }

+}

+

+/**

+    On exiting boot services we must make sure the SP805 Watchdog Timer

+    is stopped.

+**/

+VOID

+EFIAPI

+ExitBootServicesEvent (

+  IN EFI_EVENT  Event,

+  IN VOID       *Context

+  )

+{

+  SP805Unlock();

+  SP805Stop();

+  SP805Lock();

+}

+

+/**

+  This function registers the handler NotifyFunction so it is called every time

+  the watchdog timer expires.  It also passes the amount of time since the last

+  handler call to the NotifyFunction.

+  If NotifyFunction is not NULL and a handler is not already registered,

+  then the new handler is registered and EFI_SUCCESS is returned.

+  If NotifyFunction is NULL, and a handler is already registered,

+  then that handler is unregistered.

+  If an attempt is made to register a handler when a handler is already registered,

+  then EFI_ALREADY_STARTED is returned.

+  If an attempt is made to unregister a handler when a handler is not registered,

+  then EFI_INVALID_PARAMETER is returned.

+

+  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.

+  @param  NotifyFunction   The function to call when a timer interrupt fires. This

+                           function executes at TPL_HIGH_LEVEL. The DXE Core will

+                           register a handler for the timer interrupt, so it can know

+                           how much time has passed. This information is used to

+                           signal timer based events. NULL will unregister the handler.

+

+  @retval EFI_SUCCESS           The watchdog timer handler was registered.

+  @retval EFI_ALREADY_STARTED   NotifyFunction is not NULL, and a handler is already

+                                registered.

+  @retval EFI_INVALID_PARAMETER NotifyFunction is NULL, and a handler was not

+                                previously registered.

+

+**/

+EFI_STATUS

+EFIAPI

+SP805RegisterHandler (

+  IN CONST EFI_WATCHDOG_TIMER_ARCH_PROTOCOL   *This,

+  IN EFI_WATCHDOG_TIMER_NOTIFY                NotifyFunction

+  )

+{

+  // ERROR: This function is not supported.

+  // The hardware watchdog will reset the board

+  return EFI_INVALID_PARAMETER;

+}

+

+/**

+

+  This function adjusts the period of timer interrupts to the value specified

+  by TimerPeriod.  If the timer period is updated, then the selected timer

+  period is stored in EFI_TIMER.TimerPeriod, and EFI_SUCCESS is returned.  If

+  the timer hardware is not programmable, then EFI_UNSUPPORTED is returned.

+  If an error occurs while attempting to update the timer period, then the

+  timer hardware will be put back in its state prior to this call, and

+  EFI_DEVICE_ERROR is returned.  If TimerPeriod is 0, then the timer interrupt

+  is disabled.  This is not the same as disabling the CPU's interrupts.

+  Instead, it must either turn off the timer hardware, or it must adjust the

+  interrupt controller so that a CPU interrupt is not generated when the timer

+  interrupt fires.

+

+  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.

+  @param  TimerPeriod      The rate to program the timer interrupt in 100 nS units. If

+                           the timer hardware is not programmable, then EFI_UNSUPPORTED is

+                           returned. If the timer is programmable, then the timer period

+                           will be rounded up to the nearest timer period that is supported

+                           by the timer hardware. If TimerPeriod is set to 0, then the

+                           timer interrupts will be disabled.

+

+

+  @retval EFI_SUCCESS           The timer period was changed.

+  @retval EFI_UNSUPPORTED       The platform cannot change the period of the timer interrupt.

+  @retval EFI_DEVICE_ERROR      The timer period could not be changed due to a device error.

+

+**/

+EFI_STATUS

+EFIAPI

+SP805SetTimerPeriod (

+  IN CONST EFI_WATCHDOG_TIMER_ARCH_PROTOCOL   *This,

+  IN UINT64                                   TimerPeriod   // In 100ns units

+  )

+{

+  EFI_STATUS  Status = EFI_SUCCESS;

+  UINT64      Ticks64bit;

+

+  SP805Unlock();

+

+  if( TimerPeriod == 0 ) {

+    // This is a watchdog stop request

+    SP805Stop();

+    goto EXIT;

+  } else {

+    // Calculate the Watchdog ticks required for a delay of (TimerTicks * 100) nanoseconds

+    // The SP805 will count down to ZERO once, generate an interrupt and

+    // then it will again reload the initial value and start again.

+    // On the second time when it reaches ZERO, it will actually reset the board.

+    // Therefore, we need to load half the required delay.

+    //

+    // WatchdogTicks = ((TimerPeriod * 100 * SP805_CLOCK_FREQUENCY) / 1GHz) / 2 ;

+    //

+    // i.e.:

+    //

+    // WatchdogTicks = (TimerPeriod * SP805_CLOCK_FREQUENCY) / 20 MHz ;

+

+    Ticks64bit = DivU64x32(MultU64x32(TimerPeriod, (UINTN)PcdGet32(PcdSP805WatchdogClockFrequencyInHz)), 20000000);

+

+    // The registers in the SP805 are only 32 bits

+    if(Ticks64bit > (UINT64)0xFFFFFFFF) {

+      // We could load the watchdog with the maximum supported value but

+      // if a smaller value was requested, this could have the watchdog

+      // triggering before it was intended.

+      // Better generate an error to let the caller know.

+      Status = EFI_DEVICE_ERROR;

+      goto EXIT;

+    }

+

+    // Update the watchdog with a 32-bit value.

+    MmioWrite32(SP805_WDOG_LOAD_REG, (UINT32)Ticks64bit);

+

+    // Start the watchdog

+    SP805Start();

+  }

+

+  EXIT:

+  // Ensure the watchdog is locked before exiting.

+  SP805Lock();

+  return Status;

+}

+

+/**

+  This function retrieves the period of timer interrupts in 100 ns units,

+  returns that value in TimerPeriod, and returns EFI_SUCCESS.  If TimerPeriod

+  is NULL, then EFI_INVALID_PARAMETER is returned.  If a TimerPeriod of 0 is

+  returned, then the timer is currently disabled.

+

+  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.

+  @param  TimerPeriod      A pointer to the timer period to retrieve in 100 ns units. If

+                           0 is returned, then the timer is currently disabled.

+

+

+  @retval EFI_SUCCESS           The timer period was returned in TimerPeriod.

+  @retval EFI_INVALID_PARAMETER TimerPeriod is NULL.

+

+**/

+EFI_STATUS

+EFIAPI

+SP805GetTimerPeriod (

+  IN CONST EFI_WATCHDOG_TIMER_ARCH_PROTOCOL   *This,

+  OUT UINT64                                  *TimerPeriod

+  )

+{

+  EFI_STATUS  Status = EFI_SUCCESS;

+  UINT64      ReturnValue;

+

+  if (TimerPeriod == NULL) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  // Check if the watchdog is stopped

+  if ( (MmioRead32(SP805_WDOG_CONTROL_REG) & SP805_WDOG_CTRL_INTEN) == 0 ) {

+    // It is stopped, so return zero.

+    ReturnValue = 0;

+  } else {

+    // Convert the Watchdog ticks into TimerPeriod

+    // Ensure 64bit arithmetic throughout because the Watchdog ticks may already

+    // be at the maximum 32 bit value and we still need to multiply that by 600.

+    ReturnValue = MultU64x32( MmioRead32(SP805_WDOG_LOAD_REG), 600 );

+  }

+

+  *TimerPeriod = ReturnValue;

+

+  return Status;

+}

+

+/**

+  Interface structure for the Watchdog Architectural Protocol.

+

+  @par Protocol Description:

+  This protocol provides a service to set the amount of time to wait

+  before firing the watchdog timer, and it also provides a service to

+  register a handler that is invoked when the watchdog timer fires.

+

+  @par When the watchdog timer fires, control will be passed to a handler

+  if one has been registered.  If no handler has been registered,

+  or the registered handler returns, then the system will be

+  reset by calling the Runtime Service ResetSystem().

+

+  @param RegisterHandler

+  Registers a handler that will be called each time the

+  watchdogtimer interrupt fires.  TimerPeriod defines the minimum

+  time between timer interrupts, so TimerPeriod will also

+  be the minimum time between calls to the registered

+  handler.

+  NOTE: If the watchdog resets the system in hardware, then

+        this function will not have any chance of executing.

+

+  @param SetTimerPeriod

+  Sets the period of the timer interrupt in 100 nS units.

+  This function is optional, and may return EFI_UNSUPPORTED.

+  If this function is supported, then the timer period will

+  be rounded up to the nearest supported timer period.

+

+  @param GetTimerPeriod

+  Retrieves the period of the timer interrupt in 100 nS units.

+

+**/

+EFI_WATCHDOG_TIMER_ARCH_PROTOCOL    gWatchdogTimer = {

+  (EFI_WATCHDOG_TIMER_REGISTER_HANDLER) SP805RegisterHandler,

+  (EFI_WATCHDOG_TIMER_SET_TIMER_PERIOD) SP805SetTimerPeriod,

+  (EFI_WATCHDOG_TIMER_GET_TIMER_PERIOD) SP805GetTimerPeriod

+};

+

+/**

+  Initialize the state information for the Watchdog Timer Architectural Protocol.

+

+  @param  ImageHandle   of the loaded driver

+  @param  SystemTable   Pointer to the System Table

+

+  @retval EFI_SUCCESS           Protocol registered

+  @retval EFI_OUT_OF_RESOURCES  Cannot allocate protocol data structure

+  @retval EFI_DEVICE_ERROR      Hardware problems

+

+**/

+EFI_STATUS

+EFIAPI

+SP805Initialize (

+  IN EFI_HANDLE         ImageHandle,

+  IN EFI_SYSTEM_TABLE   *SystemTable

+  )

+{

+  EFI_STATUS  Status;

+  EFI_HANDLE  Handle;

+

+  // Unlock access to the SP805 registers

+  SP805Unlock ();

+

+  // Stop the watchdog from triggering unexpectedly

+  SP805Stop ();

+

+  // Set the watchdog to reset the board when triggered

+  if ((MmioRead32(SP805_WDOG_CONTROL_REG) & SP805_WDOG_CTRL_RESEN) == 0) {

+    MmioOr32 (SP805_WDOG_CONTROL_REG, SP805_WDOG_CTRL_RESEN);

+  }

+

+  // Prohibit any rogue access to SP805 registers

+  SP805Lock();

+  

+  //

+  // Make sure the Watchdog Timer Architectural Protocol has not been installed in the system yet.

+  // This will avoid conflicts with the universal watchdog

+  //

+  ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL, &gEfiWatchdogTimerArchProtocolGuid);

+

+  // Register for an ExitBootServicesEvent

+  Status = gBS->CreateEvent (EVT_SIGNAL_EXIT_BOOT_SERVICES, TPL_NOTIFY, ExitBootServicesEvent, NULL, &EfiExitBootServicesEvent);

+  if (EFI_ERROR(Status)) {

+    Status = EFI_OUT_OF_RESOURCES;

+    goto EXIT;

+  }

+

+  // Install the Timer Architectural Protocol onto a new handle

+  Handle = NULL;

+  Status = gBS->InstallMultipleProtocolInterfaces(

+                  &Handle,

+                  &gEfiWatchdogTimerArchProtocolGuid, &gWatchdogTimer,

+                  NULL

+                  );

+  if (EFI_ERROR(Status)) {

+    Status = EFI_OUT_OF_RESOURCES;

+    goto EXIT;

+  }

+

+EXIT:

+  if(EFI_ERROR(Status)) {

+    // The watchdog failed to initialize

+    ASSERT(FALSE);

+  }

+  return Status;

+}

diff --git a/ArmPlatformPkg/Drivers/SP805WatchdogDxe/SP805WatchdogDxe.inf b/ArmPlatformPkg/Drivers/SP805WatchdogDxe/SP805WatchdogDxe.inf
index ffcd501a..5ec35188 100644
--- a/ArmPlatformPkg/Drivers/SP805WatchdogDxe/SP805WatchdogDxe.inf
+++ b/ArmPlatformPkg/Drivers/SP805WatchdogDxe/SP805WatchdogDxe.inf
@@ -1,52 +1,52 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = SP805WatchdogDxe
-  FILE_GUID                      = ebd705fb-fa92-46a7-b32b-7f566d944614 
-  MODULE_TYPE                    = DXE_DRIVER
-  VERSION_STRING                 = 1.0
-
-  ENTRY_POINT                    = SP805Initialize
-
-[Sources.common]
-  SP805Watchdog.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  EmbeddedPkg/EmbeddedPkg.dec
-  ArmPkg/ArmPkg.dec
-  ArmPlatformPkg/ArmPlatformPkg.dec
-
-[LibraryClasses]
-  BaseLib
-  BaseMemoryLib
-  DebugLib
-  IoLib
-  PcdLib
-  UefiLib
-  UefiBootServicesTableLib
-  UefiDriverEntryPoint
-  UefiRuntimeServicesTableLib
-
-[Pcd]
-  gArmPlatformTokenSpaceGuid.PcdSP805WatchdogBase
-  gArmPlatformTokenSpaceGuid.PcdSP805WatchdogClockFrequencyInHz
-
-[Protocols]
-  gEfiWatchdogTimerArchProtocolGuid  
-
-[Depex]
-  TRUE
+/** @file

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = SP805WatchdogDxe

+  FILE_GUID                      = ebd705fb-fa92-46a7-b32b-7f566d944614 

+  MODULE_TYPE                    = DXE_DRIVER

+  VERSION_STRING                 = 1.0

+

+  ENTRY_POINT                    = SP805Initialize

+

+[Sources.common]

+  SP805Watchdog.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  EmbeddedPkg/EmbeddedPkg.dec

+  ArmPkg/ArmPkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+

+[LibraryClasses]

+  BaseLib

+  BaseMemoryLib

+  DebugLib

+  IoLib

+  PcdLib

+  UefiLib

+  UefiBootServicesTableLib

+  UefiDriverEntryPoint

+  UefiRuntimeServicesTableLib

+

+[Pcd]

+  gArmPlatformTokenSpaceGuid.PcdSP805WatchdogBase

+  gArmPlatformTokenSpaceGuid.PcdSP805WatchdogClockFrequencyInHz

+

+[Protocols]

+  gEfiWatchdogTimerArchProtocolGuid  

+

+[Depex]

+  TRUE

diff --git a/ArmPlatformPkg/Include/Drivers/PL111Lcd.h b/ArmPlatformPkg/Include/Drivers/PL111Lcd.h
index d68acd83..8c1c29de 100644
--- a/ArmPlatformPkg/Include/Drivers/PL111Lcd.h
+++ b/ArmPlatformPkg/Include/Drivers/PL111Lcd.h
@@ -1,140 +1,140 @@
-/** @file  PL111Lcd.h
-
- Copyright (c) 2011, ARM Ltd. All rights reserved.<BR>
- This program and the accompanying materials
- are licensed and made available under the terms and conditions of the BSD License
- which accompanies this distribution.  The full text of the license may be found at
- http://opensource.org/licenses/bsd-license.php
-
- THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
- WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
- **/
-
-#ifndef _PL111LCD_H__
-#define _PL111LCD_H__
-
-/**********************************************************************
- *
- *  This header file contains all the bits of the PL111 that are
- *  platform independent.
- *
- **********************************************************************/
-
-// Controller Register Offsets
-#define PL111_REG_LCD_TIMING_0            ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x000)
-#define PL111_REG_LCD_TIMING_1            ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x004)
-#define PL111_REG_LCD_TIMING_2            ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x008)
-#define PL111_REG_LCD_TIMING_3            ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x00C)
-#define PL111_REG_LCD_UP_BASE             ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x010)
-#define PL111_REG_LCD_LP_BASE             ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x014)
-#define PL111_REG_LCD_CONTROL             ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x018)
-#define PL111_REG_LCD_IMSC                ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x01C)
-#define PL111_REG_LCD_RIS                 ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x020)
-#define PL111_REG_LCD_MIS                 ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x024)
-#define PL111_REG_LCD_ICR                 ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x028)
-#define PL111_REG_LCD_UP_CURR             ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x02C)
-#define PL111_REG_LCD_LP_CURR             ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x030)
-#define PL111_REG_LCD_PALETTE             ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x200)
-
-// Identification Register Offsets
-#define PL111_REG_CLCD_PERIPH_ID_0        ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0xFE0)
-#define PL111_REG_CLCD_PERIPH_ID_1        ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0xFE4)
-#define PL111_REG_CLCD_PERIPH_ID_2        ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0xFE8)
-#define PL111_REG_CLCD_PERIPH_ID_3        ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0xFEC)
-#define PL111_REG_CLCD_P_CELL_ID_0        ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0xFF0)
-#define PL111_REG_CLCD_P_CELL_ID_1        ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0xFF4)
-#define PL111_REG_CLCD_P_CELL_ID_2        ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0xFF8)
-#define PL111_REG_CLCD_P_CELL_ID_3        ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0xFFC)
-
-/**********************************************************************/
-
-// Register components (register bits)
-
-// This should make life easier to program specific settings in the different registers
-// by simplifying the setting up of the individual bits of each register
-// and then assembling the final register value.
-
-/**********************************************************************/
-
-// Register: PL111_REG_LCD_TIMING_0
-#define HOR_AXIS_PANEL(hbp,hfp,hsw,hor_res) (UINT32)(((UINT32)(hbp) << 24) | ((UINT32)(hfp) << 16) | ((UINT32)(hsw) << 8) | (((UINT32)((hor_res)/16)-1) << 2))
-
-// Register: PL111_REG_LCD_TIMING_1
-#define VER_AXIS_PANEL(vbp,vfp,vsw,ver_res) (UINT32)(((UINT32)(vbp) << 24) | ((UINT32)(vfp) << 16) | ((UINT32)(vsw) << 10) | ((ver_res)-1))
-
-// Register: PL111_REG_LCD_TIMING_2
-#define PL111_BIT_SHIFT_PCD_HI            27
-#define PL111_BIT_SHIFT_BCD               26
-#define PL111_BIT_SHIFT_CPL               16
-#define PL111_BIT_SHIFT_IOE               14
-#define PL111_BIT_SHIFT_IPC               13
-#define PL111_BIT_SHIFT_IHS               12
-#define PL111_BIT_SHIFT_IVS               11
-#define PL111_BIT_SHIFT_ACB               6
-#define PL111_BIT_SHIFT_CLKSEL            5
-#define PL111_BIT_SHIFT_PCD_LO            0
-
-#define PL111_BCD                         (1 << 26)
-#define PL111_IPC                         (1 << 13)
-#define PL111_IHS                         (1 << 12)
-#define PL111_IVS                         (1 << 11)
-
-#define CLK_SIG_POLARITY(hor_res)         (UINT32)(PL111_BCD | PL111_IPC | PL111_IHS | PL111_IVS | (((hor_res)-1) << 16))
-
-// Register: PL111_REG_LCD_TIMING_3
-#define PL111_BIT_SHIFT_LEE               16
-#define PL111_BIT_SHIFT_LED               0
-
-#define PL111_CTRL_WATERMARK              (1 << 16)
-#define PL111_CTRL_LCD_V_COMP             (1 << 12)
-#define PL111_CTRL_LCD_PWR                (1 << 11)
-#define PL111_CTRL_BEPO                   (1 << 10)
-#define PL111_CTRL_BEBO                   (1 << 9)
-#define PL111_CTRL_BGR                    (1 << 8)
-#define PL111_CTRL_LCD_DUAL               (1 << 7)
-#define PL111_CTRL_LCD_MONO_8             (1 << 6)
-#define PL111_CTRL_LCD_TFT                (1 << 5)
-#define PL111_CTRL_LCD_BW                 (1 << 4)
-#define PL111_CTRL_LCD_1BPP               (0 << 1)
-#define PL111_CTRL_LCD_2BPP               (1 << 1)
-#define PL111_CTRL_LCD_4BPP               (2 << 1)
-#define PL111_CTRL_LCD_8BPP               (3 << 1)
-#define PL111_CTRL_LCD_16BPP              (4 << 1)
-#define PL111_CTRL_LCD_24BPP              (5 << 1)
-#define PL111_CTRL_LCD_16BPP_565          (6 << 1)
-#define PL111_CTRL_LCD_12BPP_444          (7 << 1)
-#define PL111_CTRL_LCD_BPP(Bpp)           ((Bpp) << 1)
-#define PL111_CTRL_LCD_EN                 1
-
-/**********************************************************************/
-
-// Register: PL111_REG_LCD_TIMING_0
-#define PL111_LCD_TIMING_0_HBP(hbp)       (((hbp) & 0xFF) << 24)
-#define PL111_LCD_TIMING_0_HFP(hfp)       (((hfp) & 0xFF) << 16)
-#define PL111_LCD_TIMING_0_HSW(hsw)       (((hsw) & 0xFF) << 8)
-#define PL111_LCD_TIMING_0_PPL(ppl)       (((hsw) & 0x3F) << 2)
-
-// Register: PL111_REG_LCD_TIMING_1
-#define PL111_LCD_TIMING_1_VBP(vbp)       (((vbp) & 0xFF) << 24)
-#define PL111_LCD_TIMING_1_VFP(vfp)       (((vfp) & 0xFF) << 16)
-#define PL111_LCD_TIMING_1_VSW(vsw)       (((vsw) & 0x3F) << 10)
-#define PL111_LCD_TIMING_1_LPP(lpp)        ((lpp) & 0xFC)
-
-// Register: PL111_REG_LCD_TIMING_2
-#define PL111_BIT_MASK_PCD_HI             0xF8000000
-#define PL111_BIT_MASK_BCD                0x04000000
-#define PL111_BIT_MASK_CPL                0x03FF0000
-#define PL111_BIT_MASK_IOE                0x00004000
-#define PL111_BIT_MASK_IPC                0x00002000
-#define PL111_BIT_MASK_IHS                0x00001000
-#define PL111_BIT_MASK_IVS                0x00000800
-#define PL111_BIT_MASK_ACB                0x000007C0
-#define PL111_BIT_MASK_CLKSEL             0x00000020
-#define PL111_BIT_MASK_PCD_LO             0x0000001F
-
-// Register: PL111_REG_LCD_TIMING_3
-#define PL111_BIT_MASK_LEE                0x00010000
-#define PL111_BIT_MASK_LED                0x0000007F
-
-#endif /* _PL111LCD_H__ */
+/** @file  PL111Lcd.h

+

+ Copyright (c) 2011, ARM Ltd. All rights reserved.<BR>

+ This program and the accompanying materials

+ are licensed and made available under the terms and conditions of the BSD License

+ which accompanies this distribution.  The full text of the license may be found at

+ http://opensource.org/licenses/bsd-license.php

+

+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+ **/

+

+#ifndef _PL111LCD_H__

+#define _PL111LCD_H__

+

+/**********************************************************************

+ *

+ *  This header file contains all the bits of the PL111 that are

+ *  platform independent.

+ *

+ **********************************************************************/

+

+// Controller Register Offsets

+#define PL111_REG_LCD_TIMING_0            ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x000)

+#define PL111_REG_LCD_TIMING_1            ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x004)

+#define PL111_REG_LCD_TIMING_2            ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x008)

+#define PL111_REG_LCD_TIMING_3            ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x00C)

+#define PL111_REG_LCD_UP_BASE             ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x010)

+#define PL111_REG_LCD_LP_BASE             ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x014)

+#define PL111_REG_LCD_CONTROL             ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x018)

+#define PL111_REG_LCD_IMSC                ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x01C)

+#define PL111_REG_LCD_RIS                 ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x020)

+#define PL111_REG_LCD_MIS                 ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x024)

+#define PL111_REG_LCD_ICR                 ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x028)

+#define PL111_REG_LCD_UP_CURR             ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x02C)

+#define PL111_REG_LCD_LP_CURR             ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x030)

+#define PL111_REG_LCD_PALETTE             ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0x200)

+

+// Identification Register Offsets

+#define PL111_REG_CLCD_PERIPH_ID_0        ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0xFE0)

+#define PL111_REG_CLCD_PERIPH_ID_1        ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0xFE4)

+#define PL111_REG_CLCD_PERIPH_ID_2        ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0xFE8)

+#define PL111_REG_CLCD_PERIPH_ID_3        ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0xFEC)

+#define PL111_REG_CLCD_P_CELL_ID_0        ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0xFF0)

+#define PL111_REG_CLCD_P_CELL_ID_1        ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0xFF4)

+#define PL111_REG_CLCD_P_CELL_ID_2        ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0xFF8)

+#define PL111_REG_CLCD_P_CELL_ID_3        ((UINTN)PcdGet32 (PcdPL111LcdBase) + 0xFFC)

+

+/**********************************************************************/

+

+// Register components (register bits)

+

+// This should make life easier to program specific settings in the different registers

+// by simplifying the setting up of the individual bits of each register

+// and then assembling the final register value.

+

+/**********************************************************************/

+

+// Register: PL111_REG_LCD_TIMING_0

+#define HOR_AXIS_PANEL(hbp,hfp,hsw,hor_res) (UINT32)(((UINT32)(hbp) << 24) | ((UINT32)(hfp) << 16) | ((UINT32)(hsw) << 8) | (((UINT32)((hor_res)/16)-1) << 2))

+

+// Register: PL111_REG_LCD_TIMING_1

+#define VER_AXIS_PANEL(vbp,vfp,vsw,ver_res) (UINT32)(((UINT32)(vbp) << 24) | ((UINT32)(vfp) << 16) | ((UINT32)(vsw) << 10) | ((ver_res)-1))

+

+// Register: PL111_REG_LCD_TIMING_2

+#define PL111_BIT_SHIFT_PCD_HI            27

+#define PL111_BIT_SHIFT_BCD               26

+#define PL111_BIT_SHIFT_CPL               16

+#define PL111_BIT_SHIFT_IOE               14

+#define PL111_BIT_SHIFT_IPC               13

+#define PL111_BIT_SHIFT_IHS               12

+#define PL111_BIT_SHIFT_IVS               11

+#define PL111_BIT_SHIFT_ACB               6

+#define PL111_BIT_SHIFT_CLKSEL            5

+#define PL111_BIT_SHIFT_PCD_LO            0

+

+#define PL111_BCD                         (1 << 26)

+#define PL111_IPC                         (1 << 13)

+#define PL111_IHS                         (1 << 12)

+#define PL111_IVS                         (1 << 11)

+

+#define CLK_SIG_POLARITY(hor_res)         (UINT32)(PL111_BCD | PL111_IPC | PL111_IHS | PL111_IVS | (((hor_res)-1) << 16))

+

+// Register: PL111_REG_LCD_TIMING_3

+#define PL111_BIT_SHIFT_LEE               16

+#define PL111_BIT_SHIFT_LED               0

+

+#define PL111_CTRL_WATERMARK              (1 << 16)

+#define PL111_CTRL_LCD_V_COMP             (1 << 12)

+#define PL111_CTRL_LCD_PWR                (1 << 11)

+#define PL111_CTRL_BEPO                   (1 << 10)

+#define PL111_CTRL_BEBO                   (1 << 9)

+#define PL111_CTRL_BGR                    (1 << 8)

+#define PL111_CTRL_LCD_DUAL               (1 << 7)

+#define PL111_CTRL_LCD_MONO_8             (1 << 6)

+#define PL111_CTRL_LCD_TFT                (1 << 5)

+#define PL111_CTRL_LCD_BW                 (1 << 4)

+#define PL111_CTRL_LCD_1BPP               (0 << 1)

+#define PL111_CTRL_LCD_2BPP               (1 << 1)

+#define PL111_CTRL_LCD_4BPP               (2 << 1)

+#define PL111_CTRL_LCD_8BPP               (3 << 1)

+#define PL111_CTRL_LCD_16BPP              (4 << 1)

+#define PL111_CTRL_LCD_24BPP              (5 << 1)

+#define PL111_CTRL_LCD_16BPP_565          (6 << 1)

+#define PL111_CTRL_LCD_12BPP_444          (7 << 1)

+#define PL111_CTRL_LCD_BPP(Bpp)           ((Bpp) << 1)

+#define PL111_CTRL_LCD_EN                 1

+

+/**********************************************************************/

+

+// Register: PL111_REG_LCD_TIMING_0

+#define PL111_LCD_TIMING_0_HBP(hbp)       (((hbp) & 0xFF) << 24)

+#define PL111_LCD_TIMING_0_HFP(hfp)       (((hfp) & 0xFF) << 16)

+#define PL111_LCD_TIMING_0_HSW(hsw)       (((hsw) & 0xFF) << 8)

+#define PL111_LCD_TIMING_0_PPL(ppl)       (((hsw) & 0x3F) << 2)

+

+// Register: PL111_REG_LCD_TIMING_1

+#define PL111_LCD_TIMING_1_VBP(vbp)       (((vbp) & 0xFF) << 24)

+#define PL111_LCD_TIMING_1_VFP(vfp)       (((vfp) & 0xFF) << 16)

+#define PL111_LCD_TIMING_1_VSW(vsw)       (((vsw) & 0x3F) << 10)

+#define PL111_LCD_TIMING_1_LPP(lpp)        ((lpp) & 0xFC)

+

+// Register: PL111_REG_LCD_TIMING_2

+#define PL111_BIT_MASK_PCD_HI             0xF8000000

+#define PL111_BIT_MASK_BCD                0x04000000

+#define PL111_BIT_MASK_CPL                0x03FF0000

+#define PL111_BIT_MASK_IOE                0x00004000

+#define PL111_BIT_MASK_IPC                0x00002000

+#define PL111_BIT_MASK_IHS                0x00001000

+#define PL111_BIT_MASK_IVS                0x00000800

+#define PL111_BIT_MASK_ACB                0x000007C0

+#define PL111_BIT_MASK_CLKSEL             0x00000020

+#define PL111_BIT_MASK_PCD_LO             0x0000001F

+

+// Register: PL111_REG_LCD_TIMING_3

+#define PL111_BIT_MASK_LEE                0x00010000

+#define PL111_BIT_MASK_LED                0x0000007F

+

+#endif /* _PL111LCD_H__ */

diff --git a/ArmPlatformPkg/Include/Drivers/PL301Axi.h b/ArmPlatformPkg/Include/Drivers/PL301Axi.h
index 1bf936ff..ae941839 100644
--- a/ArmPlatformPkg/Include/Drivers/PL301Axi.h
+++ b/ArmPlatformPkg/Include/Drivers/PL301Axi.h
@@ -1,21 +1,21 @@
-/** @file
-*
-*  Copyright (c) 2011, ARM Limited. All rights reserved.
-*
-*  This program and the accompanying materials
-*  are licensed and made available under the terms and conditions of the BSD License
-*  which accompanies this distribution.  The full text of the license may be found at
-*  http://opensource.org/licenses/bsd-license.php
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-*
-**/
-
-#ifndef PL301AXI_H_
-#define PL301AXI_H_
-
-VOID PL301AxiInit(UINTN FAxiBase);
-
-
-#endif /* PL301AXI_H_ */
+/** @file

+*

+*  Copyright (c) 2011, ARM Limited. All rights reserved.

+*

+*  This program and the accompanying materials

+*  are licensed and made available under the terms and conditions of the BSD License

+*  which accompanies this distribution.  The full text of the license may be found at

+*  http://opensource.org/licenses/bsd-license.php

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+*

+**/

+

+#ifndef PL301AXI_H_

+#define PL301AXI_H_

+

+VOID PL301AxiInit(UINTN FAxiBase);

+

+

+#endif /* PL301AXI_H_ */

diff --git a/ArmPlatformPkg/Include/Drivers/PL341Dmc.h b/ArmPlatformPkg/Include/Drivers/PL341Dmc.h
index 0227ced4..268b6da5 100644
--- a/ArmPlatformPkg/Include/Drivers/PL341Dmc.h
+++ b/ArmPlatformPkg/Include/Drivers/PL341Dmc.h
@@ -1,336 +1,336 @@
-/** @file
-*
-*  Copyright (c) 2011, ARM Limited. All rights reserved.
-*
-*  This program and the accompanying materials
-*  are licensed and made available under the terms and conditions of the BSD License
-*  which accompanies this distribution.  The full text of the license may be found at
-*  http://opensource.org/licenses/bsd-license.php
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-*
-**/
-
-#ifndef _PL341DMC_H_
-#define _PL341DMC_H_
-
-
-typedef struct  {
-    UINTN	HasQos;        // has QoS registers
-    UINTN	MaxChip;       // number of memory chips accessible
-    BOOLEAN  IsUserCfg;
-    UINT32  User0Cfg;
-    UINT32  User2Cfg;
-    UINT32	RefreshPeriod;
-    UINT32	CasLatency;
-    UINT32	WriteLatency;
-    UINT32	t_mrd;
-    UINT32	t_ras;
-    UINT32	t_rc;
-    UINT32	t_rcd;
-    UINT32	t_rfc;
-    UINT32	t_rp;
-    UINT32	t_rrd;
-    UINT32	t_wr;
-    UINT32	t_wtr;
-    UINT32	t_xp;
-    UINT32	t_xsr;
-    UINT32	t_esr;
-    UINT32	MemoryCfg;
-    UINT32	MemoryCfg2;
-    UINT32	MemoryCfg3;
-    UINT32	ChipCfg0;
-    UINT32	ChipCfg1;
-    UINT32	ChipCfg2;
-    UINT32	ChipCfg3;
-    UINT32	t_faw;
-    UINT32	t_data_en;
-    UINT32	t_wdata_en;
-    UINT32  ModeReg;
-    UINT32  ExtModeReg;
-} PL341_DMC_CONFIG;
-
-/* Memory config bit fields */
-#define DMC_MEMORY_CONFIG_COLUMN_ADDRESS_9      0x1
-#define DMC_MEMORY_CONFIG_COLUMN_ADDRESS_10     0x2
-#define DMC_MEMORY_CONFIG_COLUMN_ADDRESS_11     0x3
-#define DMC_MEMORY_CONFIG_COLUMN_ADDRESS_12     0x4
-#define DMC_MEMORY_CONFIG_ROW_ADDRESS_11        (0x0 << 3)
-#define DMC_MEMORY_CONFIG_ROW_ADDRESS_12        (0x1 << 3)
-#define DMC_MEMORY_CONFIG_ROW_ADDRESS_13        (0x2 << 3)
-#define DMC_MEMORY_CONFIG_ROW_ADDRESS_14        (0x3 << 3)
-#define DMC_MEMORY_CONFIG_ROW_ADDRESS_15        (0x4 << 3)
-#define DMC_MEMORY_CONFIG_ROW_ADDRESS_16        (0x5 << 3)
-#define DMC_MEMORY_CONFIG_BURST_2               (0x1 << 15)
-#define DMC_MEMORY_CONFIG_BURST_4               (0x2 << 15)
-#define DMC_MEMORY_CONFIG_BURST_8               (0x3 << 15)
-#define DMC_MEMORY_CONFIG_BURST_16              (0x4 << 15)
-#define DMC_MEMORY_CONFIG_ACTIVE_CHIP_1    (0x0 << 21)
-#define DMC_MEMORY_CONFIG_ACTIVE_CHIP_2    (0x1 << 21)
-#define DMC_MEMORY_CONFIG_ACTIVE_CHIP_3    (0x2 << 21)
-#define DMC_MEMORY_CONFIG_ACTIVE_CHIP_4    (0x3 << 21)
-
-#define DMC_MEMORY_CFG2_CLK_ASYNC    (0x0 << 0)
-#define DMC_MEMORY_CFG2_CLK_SYNC    (0x1 << 0)
-#define DMC_MEMORY_CFG2_DQM_INIT    (0x1 << 2)
-#define DMC_MEMORY_CFG2_CKE_INIT    (0x1 << 3)
-#define DMC_MEMORY_CFG2_BANK_BITS_2    (0x0 << 4)
-#define DMC_MEMORY_CFG2_BANK_BITS_3    (0x3 << 4)
-#define DMC_MEMORY_CFG2_MEM_WIDTH_16    (0x0 << 6)
-#define DMC_MEMORY_CFG2_MEM_WIDTH_32    (0x1 << 6)
-#define DMC_MEMORY_CFG2_MEM_WIDTH_64    (0x2 << 6)
-#define DMC_MEMORY_CFG2_MEM_WIDTH_RESERVED  (0x3 << 6)
-
-//
-// DMC Configuration Register Map
-//
-#define DMC_STATUS_REG              0x00
-#define DMC_COMMAND_REG             0x04
-#define DMC_DIRECT_CMD_REG          0x08
-#define DMC_MEMORY_CONFIG_REG       0x0C
-#define DMC_REFRESH_PRD_REG         0x10
-#define DMC_CAS_LATENCY_REG         0x14
-#define DMC_WRITE_LATENCY_REG       0x18
-#define DMC_T_MRD_REG               0x1C
-#define DMC_T_RAS_REG               0x20
-#define DMC_T_RC_REG                0x24
-#define DMC_T_RCD_REG               0x28
-#define DMC_T_RFC_REG               0x2C
-#define DMC_T_RP_REG                0x30
-#define DMC_T_RRD_REG               0x34
-#define DMC_T_WR_REG                0x38
-#define DMC_T_WTR_REG               0x3C
-#define DMC_T_XP_REG                0x40
-#define DMC_T_XSR_REG               0x44
-#define DMC_T_ESR_REG               0x48
-#define DMC_MEMORY_CFG2_REG         0x4C
-#define DMC_MEMORY_CFG3_REG         0x50
-#define DMC_T_FAW_REG               0x54
-#define DMC_T_RDATA_EN              0x5C	/* DFI read data enable register */
-#define DMC_T_WRLAT_DIFF            0x60        /* DFI write data enable register */
-
-// Returns the state of the memory controller:
-#define DMC_STATUS_CONFIG       0x0
-#define DMC_STATUS_READY        0x1
-#define DMC_STATUS_PAUSED       0x2
-#define DMC_STATUS_LOWPOWER     0x3
-
-// Changes the state of the memory controller:
-#define DMC_COMMAND_GO              0x0
-#define DMC_COMMAND_SLEEP           0x1
-#define DMC_COMMAND_WAKEUP          0x2
-#define DMC_COMMAND_PAUSE           0x3
-#define DMC_COMMAND_CONFIGURE       0x4
-#define DMC_COMMAND_ACTIVEPAUSE     0x7
-
-// Determines the command required
-#define DMC_DIRECT_CMD_MEMCMD_PRECHARGEALL      0x0
-#define DMC_DIRECT_CMD_MEMCMD_AUTOREFRESH       (0x1 << 18)
-#define DMC_DIRECT_CMD_MEMCMD_MODEREG           (0x2 << 18)
-#define DMC_DIRECT_CMD_MEMCMD_EXTMODEREG        (0x2 << 18)
-#define DMC_DIRECT_CMD_MEMCMD_NOP               (0x3 << 18)
-#define DMC_DIRECT_CMD_MEMCMD_DPD               (0x1 << 22)
-#define DMC_DIRECT_CMD_BANKADDR(n)              ((n & 0x3) << 16)
-#define DMC_DIRECT_CMD_CHIP_ADDR(n)             ((n & 0x3) << 20)
-
-
-//
-// AXI ID configuration register map
-//
-#define DMC_ID_0_CFG_REG            0x100
-#define DMC_ID_1_CFG_REG            0x104
-#define DMC_ID_2_CFG_REG            0x108
-#define DMC_ID_3_CFG_REG            0x10C
-#define DMC_ID_4_CFG_REG            0x110
-#define DMC_ID_5_CFG_REG            0x114
-#define DMC_ID_6_CFG_REG            0x118
-#define DMC_ID_7_CFG_REG            0x11C
-#define DMC_ID_8_CFG_REG            0x120
-#define DMC_ID_9_CFG_REG            0x124
-#define DMC_ID_10_CFG_REG           0x128
-#define DMC_ID_11_CFG_REG           0x12C
-#define DMC_ID_12_CFG_REG           0x130
-#define DMC_ID_13_CFG_REG           0x134
-#define DMC_ID_14_CFG_REG           0x138
-#define DMC_ID_15_CFG_REG           0x13C
-
-// Set the QoS
-#define DMC_ID_CFG_QOS_DISABLE      0
-#define DMC_ID_CFG_QOS_ENABLE       1
-#define DMC_ID_CFG_QOS_MIN          2
-
-
-//
-// Chip configuration register map
-//
-#define DMC_CHIP_0_CFG_REG          0x200
-#define DMC_CHIP_1_CFG_REG          0x204
-#define DMC_CHIP_2_CFG_REG          0x208
-#define DMC_CHIP_3_CFG_REG          0x20C
-
-//
-// User Defined Pins
-//
-#define DMC_USER_STATUS_REG         0x300
-#define DMC_USER_0_CFG_REG          0x304
-#define DMC_USER_1_CFG_REG          0x308
-#define DMC_FEATURE_CRTL_REG        0x30C
-#define DMC_USER_2_CFG_REG          0x310
-
-
-//
-// PHY Register Settings
-//
-#define PHY_PTM_DFI_CLK_RANGE					0xE00		// DDR2 PHY PTM register offset
-#define PHY_PTM_IOTERM							0xE04
-#define PHY_PTM_PLL_EN          				0xe0c
-#define PHY_PTM_PLL_RANGE       				0xe18
-#define PHY_PTM_FEEBACK_DIV     				0xe1c
-#define PHY_PTM_RCLK_DIV        				0xe20
-#define PHY_PTM_LOCK_STATUS     				0xe28
-#define PHY_PTM_INIT_DONE	     				0xe34
-#define PHY_PTM_ADDCOM_IOSTR_OFF				0xec8
-#define PHY_PTM_SQU_TRAINING    				0xee8
-#define PHY_PTM_SQU_STAT        				0xeec
-
-// ==============================================================================
-// PIPD 40G DDR2/DDR3 PHY Register definitions
-//
-// Offsets from APB Base Address
-// ==============================================================================
-#define PHY_BYTE0_OFFSET					0x000
-#define PHY_BYTE1_OFFSET					0x200
-#define PHY_BYTE2_OFFSET					0x400
-#define PHY_BYTE3_OFFSET					0x600
-
-#define PHY_BYTE0_COARSE_SQADJ_INIT			0x064	;// Coarse squelch adjust
-#define PHY_BYTE1_COARSE_SQADJ_INIT			0x264	;// Coarse squelch adjust
-#define PHY_BYTE2_COARSE_SQADJ_INIT			0x464	;// Coarse squelch adjust
-#define PHY_BYTE3_COARSE_SQADJ_INIT			0x664	;// Coarse squelch adjust
-
-#define PHY_BYTE0_IOSTR_OFFSET				0x004
-#define PHY_BYTE1_IOSTR_OFFSET				0x204
-#define PHY_BYTE2_IOSTR_OFFSET				0x404
-#define PHY_BYTE3_IOSTR_OFFSET				0x604
-
-
-;//--------------------------------------------------------------------------
-
-// DFI Clock ranges:
-
-#define PHY_PTM_DFI_CLK_RANGE_200MHz   		0x0
-#define PHY_PTM_DFI_CLK_RANGE_201_267MHz	0x1
-#define PHY_PTM_DFI_CLK_RANGE_268_333MHz	0x2
-#define PHY_PTM_DFI_CLK_RANGE_334_400MHz	0x3
-#define PHY_PTM_DFI_CLK_RANGE_401_533MHz	0x4
-#define PHY_PTM_DFI_CLK_RANGE_534_667MHz	0x5
-#define PHY_PTM_DFI_CLK_RANGE_668_800MHz	0x6
-
-
-
-#define  PHY_PTM_DFI_CLK_RANGE_VAL			PHY_PTM_DFI_CLK_RANGE_334_400MHz
-
-//--------------------------------------------------------------------------
-
-
-// PLL Range
-
-#define PHY_PTM_PLL_RANGE_200_400MHz		0x0	// b0 = frequency >= 200 MHz and < 400 MHz
-#define PHY_PTM_PLL_RANGE_400_800MHz		0x1	// b1 = frequency >= 400 MHz.
-#define PHY_PTM_FEEBACK_DIV_200_400MHz		0x0	// b0 = frequency >= 200 MHz and < 400 MHz
-#define PHY_PTM_FEEBACK_DIV_400_800MHz		0x1	// b1 = frequency >= 400 MHz.
-#define PHY_PTM_REFCLK_DIV_200_400MHz		0x0
-#define PHY_PTM_REFCLK_DIV_400_800MHz		0x1
-
-#define TC_UIOLHNC_MASK                         0x000003C0
-#define TC_UIOLHNC_SHIFT                        0x6
-#define TC_UIOLHPC_MASK                         0x0000003F
-#define TC_UIOLHPC_SHIFT                        0x2
-#define TC_UIOHOCT_MASK                         0x2
-#define TC_UIOHOCT_SHIFT                        0x1
-#define TC_UIOHSTOP_SHIFT                       0x0
-#define TC_UIOLHXC_VALUE                        0x4
-
-#define PHY_PTM_SQU_TRAINING_ENABLE				0x1
-#define PHY_PTM_SQU_TRAINING_DISABLE				0x0
-
-
-//--------------------------------------
-// JEDEC DDR2 Device Register definitions and settings
-//--------------------------------------
-#define DDR_MODESET_SHFT						14
-#define DDR_MODESET_MR							0x0		;// Mode register
-#define DDR_MODESET_EMR							0x1		;// Extended Mode register
-#define DDR_MODESET_EMR2						0x2
-#define DDR_MODESET_EMR3						0x3
-
-//
-// Extended Mode Register settings
-//
-#define DDR_EMR_OCD_MASK                        0x0000380
-#define DDR_EMR_OCD_SHIFT                       0x7
-#define DDR_EMR_RTT_MASK                        0x00000044                  // DDR2 Device RTT (ODT) settings
-#define DDR_EMR_RTT_SHIFT                       0x2
-#define DDR_EMR_ODS_MASK                        0x00000002                  // DDR2 Output Drive Strength
-#define DDR_EMR_ODS_SHIFT                       0x0001
-
-// Termination Values:
-#define DDR_EMR_RTT_50R                         0x00000044                  // DDR2 50 Ohm termination
-#define DDR_EMR_RTT_75R                         0x00000004                  // DDR2 75 Ohm termination
-#define DDR_EMR_RTT_150                         0x00000040                  // DDR2 150 Ohm termination
-
-// Output Drive Strength Values:
-#define DDR_EMR_ODS_FULL                        0x0                         // DDR2 Full Drive Strength
-#define DDR_EMR_ODS_HALF                        0x1                         // DDR2 Half Drive Strength
-
-// OCD values
-#define DDR_EMR_OCD_DEFAULT                     0x7
-#define DDR_EMR_OCD_NS                          0x0
-
-#define DDR_EMR_ODS_VAL                         DDR_EMR_ODS_FULL
-
-#define DDR_SDRAM_START_ADDR					0x10000000
-
-
-// ----------------------------------------
-// PHY IOTERM values
-// ----------------------------------------
-#define PHY_PTM_IOTERM_OFF					0x0
-#define PHY_PTM_IOTERM_150R					0x1
-#define PHY_PTM_IOTERM_75R					0x2
-#define PHY_PTM_IOTERM_50R					0x3
-
-#define PHY_BYTE_IOSTR_60OHM				0x0
-#define PHY_BYTE_IOSTR_40OHM				0x1
-#define PHY_BYTE_IOSTR_30OHM				0x2
-#define PHY_BYTE_IOSTR_30AOHM				0x3
-
-#define DDR2_MR_BURST_LENGTH_4     (2)
-#define DDR2_MR_BURST_LENGTH_8     (3)
-#define DDR2_MR_DLL_RESET          (1 << 8)
-#define DDR2_MR_CAS_LATENCY_4      (4 << 4)
-#define DDR2_MR_CAS_LATENCY_5      (5 << 4)
-#define DDR2_MR_CAS_LATENCY_6      (6 << 4)
-#define DDR2_MR_WR_CYCLES_2        (1 << 9)
-#define DDR2_MR_WR_CYCLES_3        (2 << 9)
-#define DDR2_MR_WR_CYCLES_4        (3 << 9)
-#define DDR2_MR_WR_CYCLES_5        (4 << 9)
-#define DDR2_MR_WR_CYCLES_6        (5 << 9)
-
-
-VOID
-PL341DmcInit (
-  IN  UINTN             DmcBase,
-  IN  PL341_DMC_CONFIG* DmcConfig
-  );
-
-VOID PL341DmcPhyInit (
-  IN UINTN   DmcPhyBase
-  );
-
-VOID PL341DmcTrainPHY (
-  IN UINTN   DmcPhyBase
-  );
-
-#endif /* _PL341DMC_H_ */
+/** @file

+*

+*  Copyright (c) 2011, ARM Limited. All rights reserved.

+*

+*  This program and the accompanying materials

+*  are licensed and made available under the terms and conditions of the BSD License

+*  which accompanies this distribution.  The full text of the license may be found at

+*  http://opensource.org/licenses/bsd-license.php

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+*

+**/

+

+#ifndef _PL341DMC_H_

+#define _PL341DMC_H_

+

+

+typedef struct  {

+    UINTN	HasQos;        // has QoS registers

+    UINTN	MaxChip;       // number of memory chips accessible

+    BOOLEAN  IsUserCfg;

+    UINT32  User0Cfg;

+    UINT32  User2Cfg;

+    UINT32	RefreshPeriod;

+    UINT32	CasLatency;

+    UINT32	WriteLatency;

+    UINT32	t_mrd;

+    UINT32	t_ras;

+    UINT32	t_rc;

+    UINT32	t_rcd;

+    UINT32	t_rfc;

+    UINT32	t_rp;

+    UINT32	t_rrd;

+    UINT32	t_wr;

+    UINT32	t_wtr;

+    UINT32	t_xp;

+    UINT32	t_xsr;

+    UINT32	t_esr;

+    UINT32	MemoryCfg;

+    UINT32	MemoryCfg2;

+    UINT32	MemoryCfg3;

+    UINT32	ChipCfg0;

+    UINT32	ChipCfg1;

+    UINT32	ChipCfg2;

+    UINT32	ChipCfg3;

+    UINT32	t_faw;

+    UINT32	t_data_en;

+    UINT32	t_wdata_en;

+    UINT32  ModeReg;

+    UINT32  ExtModeReg;

+} PL341_DMC_CONFIG;

+

+/* Memory config bit fields */

+#define DMC_MEMORY_CONFIG_COLUMN_ADDRESS_9      0x1

+#define DMC_MEMORY_CONFIG_COLUMN_ADDRESS_10     0x2

+#define DMC_MEMORY_CONFIG_COLUMN_ADDRESS_11     0x3

+#define DMC_MEMORY_CONFIG_COLUMN_ADDRESS_12     0x4

+#define DMC_MEMORY_CONFIG_ROW_ADDRESS_11        (0x0 << 3)

+#define DMC_MEMORY_CONFIG_ROW_ADDRESS_12        (0x1 << 3)

+#define DMC_MEMORY_CONFIG_ROW_ADDRESS_13        (0x2 << 3)

+#define DMC_MEMORY_CONFIG_ROW_ADDRESS_14        (0x3 << 3)

+#define DMC_MEMORY_CONFIG_ROW_ADDRESS_15        (0x4 << 3)

+#define DMC_MEMORY_CONFIG_ROW_ADDRESS_16        (0x5 << 3)

+#define DMC_MEMORY_CONFIG_BURST_2               (0x1 << 15)

+#define DMC_MEMORY_CONFIG_BURST_4               (0x2 << 15)

+#define DMC_MEMORY_CONFIG_BURST_8               (0x3 << 15)

+#define DMC_MEMORY_CONFIG_BURST_16              (0x4 << 15)

+#define DMC_MEMORY_CONFIG_ACTIVE_CHIP_1    (0x0 << 21)

+#define DMC_MEMORY_CONFIG_ACTIVE_CHIP_2    (0x1 << 21)

+#define DMC_MEMORY_CONFIG_ACTIVE_CHIP_3    (0x2 << 21)

+#define DMC_MEMORY_CONFIG_ACTIVE_CHIP_4    (0x3 << 21)

+

+#define DMC_MEMORY_CFG2_CLK_ASYNC    (0x0 << 0)

+#define DMC_MEMORY_CFG2_CLK_SYNC    (0x1 << 0)

+#define DMC_MEMORY_CFG2_DQM_INIT    (0x1 << 2)

+#define DMC_MEMORY_CFG2_CKE_INIT    (0x1 << 3)

+#define DMC_MEMORY_CFG2_BANK_BITS_2    (0x0 << 4)

+#define DMC_MEMORY_CFG2_BANK_BITS_3    (0x3 << 4)

+#define DMC_MEMORY_CFG2_MEM_WIDTH_16    (0x0 << 6)

+#define DMC_MEMORY_CFG2_MEM_WIDTH_32    (0x1 << 6)

+#define DMC_MEMORY_CFG2_MEM_WIDTH_64    (0x2 << 6)

+#define DMC_MEMORY_CFG2_MEM_WIDTH_RESERVED  (0x3 << 6)

+

+//

+// DMC Configuration Register Map

+//

+#define DMC_STATUS_REG              0x00

+#define DMC_COMMAND_REG             0x04

+#define DMC_DIRECT_CMD_REG          0x08

+#define DMC_MEMORY_CONFIG_REG       0x0C

+#define DMC_REFRESH_PRD_REG         0x10

+#define DMC_CAS_LATENCY_REG         0x14

+#define DMC_WRITE_LATENCY_REG       0x18

+#define DMC_T_MRD_REG               0x1C

+#define DMC_T_RAS_REG               0x20

+#define DMC_T_RC_REG                0x24

+#define DMC_T_RCD_REG               0x28

+#define DMC_T_RFC_REG               0x2C

+#define DMC_T_RP_REG                0x30

+#define DMC_T_RRD_REG               0x34

+#define DMC_T_WR_REG                0x38

+#define DMC_T_WTR_REG               0x3C

+#define DMC_T_XP_REG                0x40

+#define DMC_T_XSR_REG               0x44

+#define DMC_T_ESR_REG               0x48

+#define DMC_MEMORY_CFG2_REG         0x4C

+#define DMC_MEMORY_CFG3_REG         0x50

+#define DMC_T_FAW_REG               0x54

+#define DMC_T_RDATA_EN              0x5C	/* DFI read data enable register */

+#define DMC_T_WRLAT_DIFF            0x60        /* DFI write data enable register */

+

+// Returns the state of the memory controller:

+#define DMC_STATUS_CONFIG       0x0

+#define DMC_STATUS_READY        0x1

+#define DMC_STATUS_PAUSED       0x2

+#define DMC_STATUS_LOWPOWER     0x3

+

+// Changes the state of the memory controller:

+#define DMC_COMMAND_GO              0x0

+#define DMC_COMMAND_SLEEP           0x1

+#define DMC_COMMAND_WAKEUP          0x2

+#define DMC_COMMAND_PAUSE           0x3

+#define DMC_COMMAND_CONFIGURE       0x4

+#define DMC_COMMAND_ACTIVEPAUSE     0x7

+

+// Determines the command required

+#define DMC_DIRECT_CMD_MEMCMD_PRECHARGEALL      0x0

+#define DMC_DIRECT_CMD_MEMCMD_AUTOREFRESH       (0x1 << 18)

+#define DMC_DIRECT_CMD_MEMCMD_MODEREG           (0x2 << 18)

+#define DMC_DIRECT_CMD_MEMCMD_EXTMODEREG        (0x2 << 18)

+#define DMC_DIRECT_CMD_MEMCMD_NOP               (0x3 << 18)

+#define DMC_DIRECT_CMD_MEMCMD_DPD               (0x1 << 22)

+#define DMC_DIRECT_CMD_BANKADDR(n)              ((n & 0x3) << 16)

+#define DMC_DIRECT_CMD_CHIP_ADDR(n)             ((n & 0x3) << 20)

+

+

+//

+// AXI ID configuration register map

+//

+#define DMC_ID_0_CFG_REG            0x100

+#define DMC_ID_1_CFG_REG            0x104

+#define DMC_ID_2_CFG_REG            0x108

+#define DMC_ID_3_CFG_REG            0x10C

+#define DMC_ID_4_CFG_REG            0x110

+#define DMC_ID_5_CFG_REG            0x114

+#define DMC_ID_6_CFG_REG            0x118

+#define DMC_ID_7_CFG_REG            0x11C

+#define DMC_ID_8_CFG_REG            0x120

+#define DMC_ID_9_CFG_REG            0x124

+#define DMC_ID_10_CFG_REG           0x128

+#define DMC_ID_11_CFG_REG           0x12C

+#define DMC_ID_12_CFG_REG           0x130

+#define DMC_ID_13_CFG_REG           0x134

+#define DMC_ID_14_CFG_REG           0x138

+#define DMC_ID_15_CFG_REG           0x13C

+

+// Set the QoS

+#define DMC_ID_CFG_QOS_DISABLE      0

+#define DMC_ID_CFG_QOS_ENABLE       1

+#define DMC_ID_CFG_QOS_MIN          2

+

+

+//

+// Chip configuration register map

+//

+#define DMC_CHIP_0_CFG_REG          0x200

+#define DMC_CHIP_1_CFG_REG          0x204

+#define DMC_CHIP_2_CFG_REG          0x208

+#define DMC_CHIP_3_CFG_REG          0x20C

+

+//

+// User Defined Pins

+//

+#define DMC_USER_STATUS_REG         0x300

+#define DMC_USER_0_CFG_REG          0x304

+#define DMC_USER_1_CFG_REG          0x308

+#define DMC_FEATURE_CRTL_REG        0x30C

+#define DMC_USER_2_CFG_REG          0x310

+

+

+//

+// PHY Register Settings

+//

+#define PHY_PTM_DFI_CLK_RANGE					0xE00		// DDR2 PHY PTM register offset

+#define PHY_PTM_IOTERM							0xE04

+#define PHY_PTM_PLL_EN          				0xe0c

+#define PHY_PTM_PLL_RANGE       				0xe18

+#define PHY_PTM_FEEBACK_DIV     				0xe1c

+#define PHY_PTM_RCLK_DIV        				0xe20

+#define PHY_PTM_LOCK_STATUS     				0xe28

+#define PHY_PTM_INIT_DONE	     				0xe34

+#define PHY_PTM_ADDCOM_IOSTR_OFF				0xec8

+#define PHY_PTM_SQU_TRAINING    				0xee8

+#define PHY_PTM_SQU_STAT        				0xeec

+

+// ==============================================================================

+// PIPD 40G DDR2/DDR3 PHY Register definitions

+//

+// Offsets from APB Base Address

+// ==============================================================================

+#define PHY_BYTE0_OFFSET					0x000

+#define PHY_BYTE1_OFFSET					0x200

+#define PHY_BYTE2_OFFSET					0x400

+#define PHY_BYTE3_OFFSET					0x600

+

+#define PHY_BYTE0_COARSE_SQADJ_INIT			0x064	;// Coarse squelch adjust

+#define PHY_BYTE1_COARSE_SQADJ_INIT			0x264	;// Coarse squelch adjust

+#define PHY_BYTE2_COARSE_SQADJ_INIT			0x464	;// Coarse squelch adjust

+#define PHY_BYTE3_COARSE_SQADJ_INIT			0x664	;// Coarse squelch adjust

+

+#define PHY_BYTE0_IOSTR_OFFSET				0x004

+#define PHY_BYTE1_IOSTR_OFFSET				0x204

+#define PHY_BYTE2_IOSTR_OFFSET				0x404

+#define PHY_BYTE3_IOSTR_OFFSET				0x604

+

+

+;//--------------------------------------------------------------------------

+

+// DFI Clock ranges:

+

+#define PHY_PTM_DFI_CLK_RANGE_200MHz   		0x0

+#define PHY_PTM_DFI_CLK_RANGE_201_267MHz	0x1

+#define PHY_PTM_DFI_CLK_RANGE_268_333MHz	0x2

+#define PHY_PTM_DFI_CLK_RANGE_334_400MHz	0x3

+#define PHY_PTM_DFI_CLK_RANGE_401_533MHz	0x4

+#define PHY_PTM_DFI_CLK_RANGE_534_667MHz	0x5

+#define PHY_PTM_DFI_CLK_RANGE_668_800MHz	0x6

+

+

+

+#define  PHY_PTM_DFI_CLK_RANGE_VAL			PHY_PTM_DFI_CLK_RANGE_334_400MHz

+

+//--------------------------------------------------------------------------

+

+

+// PLL Range

+

+#define PHY_PTM_PLL_RANGE_200_400MHz		0x0	// b0 = frequency >= 200 MHz and < 400 MHz

+#define PHY_PTM_PLL_RANGE_400_800MHz		0x1	// b1 = frequency >= 400 MHz.

+#define PHY_PTM_FEEBACK_DIV_200_400MHz		0x0	// b0 = frequency >= 200 MHz and < 400 MHz

+#define PHY_PTM_FEEBACK_DIV_400_800MHz		0x1	// b1 = frequency >= 400 MHz.

+#define PHY_PTM_REFCLK_DIV_200_400MHz		0x0

+#define PHY_PTM_REFCLK_DIV_400_800MHz		0x1

+

+#define TC_UIOLHNC_MASK                         0x000003C0

+#define TC_UIOLHNC_SHIFT                        0x6

+#define TC_UIOLHPC_MASK                         0x0000003F

+#define TC_UIOLHPC_SHIFT                        0x2

+#define TC_UIOHOCT_MASK                         0x2

+#define TC_UIOHOCT_SHIFT                        0x1

+#define TC_UIOHSTOP_SHIFT                       0x0

+#define TC_UIOLHXC_VALUE                        0x4

+

+#define PHY_PTM_SQU_TRAINING_ENABLE				0x1

+#define PHY_PTM_SQU_TRAINING_DISABLE				0x0

+

+

+//--------------------------------------

+// JEDEC DDR2 Device Register definitions and settings

+//--------------------------------------

+#define DDR_MODESET_SHFT						14

+#define DDR_MODESET_MR							0x0		;// Mode register

+#define DDR_MODESET_EMR							0x1		;// Extended Mode register

+#define DDR_MODESET_EMR2						0x2

+#define DDR_MODESET_EMR3						0x3

+

+//

+// Extended Mode Register settings

+//

+#define DDR_EMR_OCD_MASK                        0x0000380

+#define DDR_EMR_OCD_SHIFT                       0x7

+#define DDR_EMR_RTT_MASK                        0x00000044                  // DDR2 Device RTT (ODT) settings

+#define DDR_EMR_RTT_SHIFT                       0x2

+#define DDR_EMR_ODS_MASK                        0x00000002                  // DDR2 Output Drive Strength

+#define DDR_EMR_ODS_SHIFT                       0x0001

+

+// Termination Values:

+#define DDR_EMR_RTT_50R                         0x00000044                  // DDR2 50 Ohm termination

+#define DDR_EMR_RTT_75R                         0x00000004                  // DDR2 75 Ohm termination

+#define DDR_EMR_RTT_150                         0x00000040                  // DDR2 150 Ohm termination

+

+// Output Drive Strength Values:

+#define DDR_EMR_ODS_FULL                        0x0                         // DDR2 Full Drive Strength

+#define DDR_EMR_ODS_HALF                        0x1                         // DDR2 Half Drive Strength

+

+// OCD values

+#define DDR_EMR_OCD_DEFAULT                     0x7

+#define DDR_EMR_OCD_NS                          0x0

+

+#define DDR_EMR_ODS_VAL                         DDR_EMR_ODS_FULL

+

+#define DDR_SDRAM_START_ADDR					0x10000000

+

+

+// ----------------------------------------

+// PHY IOTERM values

+// ----------------------------------------

+#define PHY_PTM_IOTERM_OFF					0x0

+#define PHY_PTM_IOTERM_150R					0x1

+#define PHY_PTM_IOTERM_75R					0x2

+#define PHY_PTM_IOTERM_50R					0x3

+

+#define PHY_BYTE_IOSTR_60OHM				0x0

+#define PHY_BYTE_IOSTR_40OHM				0x1

+#define PHY_BYTE_IOSTR_30OHM				0x2

+#define PHY_BYTE_IOSTR_30AOHM				0x3

+

+#define DDR2_MR_BURST_LENGTH_4     (2)

+#define DDR2_MR_BURST_LENGTH_8     (3)

+#define DDR2_MR_DLL_RESET          (1 << 8)

+#define DDR2_MR_CAS_LATENCY_4      (4 << 4)

+#define DDR2_MR_CAS_LATENCY_5      (5 << 4)

+#define DDR2_MR_CAS_LATENCY_6      (6 << 4)

+#define DDR2_MR_WR_CYCLES_2        (1 << 9)

+#define DDR2_MR_WR_CYCLES_3        (2 << 9)

+#define DDR2_MR_WR_CYCLES_4        (3 << 9)

+#define DDR2_MR_WR_CYCLES_5        (4 << 9)

+#define DDR2_MR_WR_CYCLES_6        (5 << 9)

+

+

+VOID

+PL341DmcInit (

+  IN  UINTN             DmcBase,

+  IN  PL341_DMC_CONFIG* DmcConfig

+  );

+

+VOID PL341DmcPhyInit (

+  IN UINTN   DmcPhyBase

+  );

+

+VOID PL341DmcTrainPHY (

+  IN UINTN   DmcPhyBase

+  );

+

+#endif /* _PL341DMC_H_ */

diff --git a/ArmPlatformPkg/Include/Guid/ArmGlobalVariableHob.h b/ArmPlatformPkg/Include/Guid/ArmGlobalVariableHob.h
index 7414b100..c175cee6 100644
--- a/ArmPlatformPkg/Include/Guid/ArmGlobalVariableHob.h
+++ b/ArmPlatformPkg/Include/Guid/ArmGlobalVariableHob.h
@@ -1,48 +1,51 @@
-/** @file
-*
-*  Copyright (c) 2011, ARM Limited. All rights reserved.
-*
-*  This program and the accompanying materials
-*  are licensed and made available under the terms and conditions of the BSD License
-*  which accompanies this distribution.  The full text of the license may be found at
-*  http://opensource.org/licenses/bsd-license.php
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-*
-**/
-
-#ifndef __ARM_GLOBAL_VARIABLE_GUID_H__
-#define __ARM_GLOBAL_VARIABLE_GUID_H__
-
-#define ARM_HOB_GLOBAL_VARIABLE_GUID  \
-  { 0xc3253c90, 0xa24f, 0x4599, { 0xa6, 0x64, 0x1f, 0x88, 0x13, 0x77, 0x8f, 0xc9} };
-
-extern EFI_GUID gArmGlobalVariableGuid;
-
-///
-/// Describes all memory ranges used during the HOB producer 
-/// phase that exist outside the HOB list. This HOB type 
-/// describes how memory is used, not the physical attributes of memory.
-///
-typedef struct {
-  ///
-  /// The Guid HOB header. Header.HobType = EFI_HOB_TYPE_GUID_EXTENSION
-  ///                 and  Header.Name    = gArmGlobalVariableGuid
-  ///
-  EFI_HOB_GUID_TYPE            Header;
-
-  ///
-  /// The base address of memory allocated by this HOB. Type
-  /// EFI_PHYSICAL_ADDRESS is defined in AllocatePages() in the UEFI 2.0
-  /// specification.
-  ///
-  EFI_PHYSICAL_ADDRESS        GlobalVariableBase;
-
-  /// 
-  /// The length in bytes of memory allocated by this HOB.
-  /// 
-  UINT32                      GlobalVariableSize;
-} ARM_HOB_GLOBAL_VARIABLE;
-
-#endif
+/** @file

+*

+*  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

+*

+*  This program and the accompanying materials

+*  are licensed and made available under the terms and conditions of the BSD License

+*  which accompanies this distribution.  The full text of the license may be found at

+*  http://opensource.org/licenses/bsd-license.php

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+*

+**/

+

+#ifndef __ARM_GLOBAL_VARIABLE_GUID_H__

+#define __ARM_GLOBAL_VARIABLE_GUID_H__

+

+#include <Pi/PiBootMode.h>

+#include <Pi/PiHob.h>

+

+#define ARM_HOB_GLOBAL_VARIABLE_GUID  \

+  { 0xc3253c90, 0xa24f, 0x4599, { 0xa6, 0x64, 0x1f, 0x88, 0x13, 0x77, 0x8f, 0xc9} };

+

+extern EFI_GUID gArmGlobalVariableGuid;

+

+///

+/// Describes all memory ranges used during the HOB producer 

+/// phase that exist outside the HOB list. This HOB type 

+/// describes how memory is used, not the physical attributes of memory.

+///

+typedef struct {

+  ///

+  /// The Guid HOB header. Header.HobType = EFI_HOB_TYPE_GUID_EXTENSION

+  ///                 and  Header.Name    = gArmGlobalVariableGuid

+  ///

+  EFI_HOB_GUID_TYPE            Header;

+

+  ///

+  /// The base address of memory allocated by this HOB. Type

+  /// EFI_PHYSICAL_ADDRESS is defined in AllocatePages() in the UEFI 2.0

+  /// specification.

+  ///

+  EFI_PHYSICAL_ADDRESS        GlobalVariableBase;

+

+  /// 

+  /// The length in bytes of memory allocated by this HOB.

+  /// 

+  UINT32                      GlobalVariableSize;

+} ARM_HOB_GLOBAL_VARIABLE;

+

+#endif

diff --git a/ArmPlatformPkg/Include/Library/ArmPlatformGlobalVariableLib.h b/ArmPlatformPkg/Include/Library/ArmPlatformGlobalVariableLib.h
index 02ef1ea8..b1a080c0 100644
--- a/ArmPlatformPkg/Include/Library/ArmPlatformGlobalVariableLib.h
+++ b/ArmPlatformPkg/Include/Library/ArmPlatformGlobalVariableLib.h
@@ -1,38 +1,38 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*
-*  This program and the accompanying materials
-*  are licensed and made available under the terms and conditions of the BSD License
-*  which accompanies this distribution.  The full text of the license may be found at
-*  http://opensource.org/licenses/bsd-license.php
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-*
-**/
-
-#ifndef __ARM_PLATFORM_GLOBAL_VARIABLE_LIB_H_
-#define __ARM_PLATFORM_GLOBAL_VARIABLE_LIB_H_
-
-VOID
-ArmPlatformGetGlobalVariable (
-  IN  UINTN     VariableOffset,
-  IN  UINTN     VariableSize,
-  OUT VOID*     Variable
-  );
-
-VOID
-ArmPlatformSetGlobalVariable (
-  IN  UINTN     VariableOffset,
-  IN  UINTN     VariableSize,
-  OUT VOID*     Variable
-  );
-
-VOID*
-ArmPlatformGetGlobalVariableAddress (
-  IN  UINTN     VariableOffset
-  );
-
-#endif
-
+/** @file

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*

+*  This program and the accompanying materials

+*  are licensed and made available under the terms and conditions of the BSD License

+*  which accompanies this distribution.  The full text of the license may be found at

+*  http://opensource.org/licenses/bsd-license.php

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+*

+**/

+

+#ifndef __ARM_PLATFORM_GLOBAL_VARIABLE_LIB_H_

+#define __ARM_PLATFORM_GLOBAL_VARIABLE_LIB_H_

+

+VOID

+ArmPlatformGetGlobalVariable (

+  IN  UINTN     VariableOffset,

+  IN  UINTN     VariableSize,

+  OUT VOID*     Variable

+  );

+

+VOID

+ArmPlatformSetGlobalVariable (

+  IN  UINTN     VariableOffset,

+  IN  UINTN     VariableSize,

+  OUT VOID*     Variable

+  );

+

+VOID*

+ArmPlatformGetGlobalVariableAddress (

+  IN  UINTN     VariableOffset

+  );

+

+#endif

+

diff --git a/ArmPlatformPkg/Include/Library/ArmPlatformLib.h b/ArmPlatformPkg/Include/Library/ArmPlatformLib.h
index 9f2de60a..7bbd9664 100644
--- a/ArmPlatformPkg/Include/Library/ArmPlatformLib.h
+++ b/ArmPlatformPkg/Include/Library/ArmPlatformLib.h
@@ -1,131 +1,131 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-#ifndef _ARMPLATFORMLIB_H_
-#define _ARMPLATFORMLIB_H_
-
-//
-// The package level header files this module uses
-//
-#include <PiPei.h>
-//
-// The protocols, PPI and GUID defintions for this module
-//
-#include <Ppi/MasterBootMode.h>
-#include <Ppi/BootInRecoveryMode.h>
-#include <Guid/MemoryTypeInformation.h>
-
-#include <Library/ArmLib.h>
-
-/**
-  This structure is used to describe a region of the EFI memory map
-
-  Every EFI regions of the system memory described by their physical start address and their size
-  can have different attributes. Some regions can be tested and other untested.
-
-**/
-typedef struct {
-  EFI_RESOURCE_ATTRIBUTE_TYPE  ResourceAttribute;
-  EFI_PHYSICAL_ADDRESS         PhysicalStart;
-  UINT64                       NumberOfBytes;
-} ARM_SYSTEM_MEMORY_REGION_DESCRIPTOR;
-
-UINTN
-ArmPlatformGetCorePosition (
-  IN UINTN MpId
-  );
-
-/**
-  Return the current Boot Mode
-
-  This function returns the boot reason on the platform
-
-  @return   Return the current Boot Mode of the platform
-
-**/
-EFI_BOOT_MODE
-ArmPlatformGetBootMode (
-  VOID
-  );
-
-/**
-  Initialize controllers that must setup in the normal world
-
-  This function is called by the ArmPlatformPkg/PrePi or ArmPlatformPkg/PlatformPei
-  in the PEI phase.
-
-**/
-RETURN_STATUS
-ArmPlatformInitialize (
-  IN  UINTN                     MpId
-  );
-
-/**
-  Initialize the system (or sometimes called permanent) memory
-
-  This memory is generally represented by the DRAM.
-
-**/
-VOID
-ArmPlatformInitializeSystemMemory (
-  VOID
-  );
-
-/**
-  Return the Virtual Memory Map of your platform
-
-  This Virtual Memory Map is used by MemoryInitPei Module to initialize the MMU on your platform.
-
-  @param[out]   VirtualMemoryMap    Array of ARM_MEMORY_REGION_DESCRIPTOR describing a Physical-to-
-                                    Virtual Memory mapping. This array must be ended by a zero-filled
-                                    entry
-
-**/
-VOID
-ArmPlatformGetVirtualMemoryMap (
-  OUT ARM_MEMORY_REGION_DESCRIPTOR** VirtualMemoryMap
-  );
-
-/**
-  Return the EFI Memory Map of your platform
-
-  This EFI Memory Map of the System Memory is used by MemoryInitPei module to create the Resource
-  Descriptor HOBs used by DXE core.
-
-  @param[out]   EfiMemoryMap        Array of ARM_SYSTEM_MEMORY_REGION_DESCRIPTOR describing an
-                                    EFI Memory region. This array must be ended by a zero-filled entry
-
-**/
-EFI_STATUS
-ArmPlatformGetAdditionalSystemMemory (
-  OUT ARM_SYSTEM_MEMORY_REGION_DESCRIPTOR** EfiMemoryMap
-  );
-
-/**
-  Return the Platform specific PPIs
-
-  This function exposes the Platform Specific PPIs. They can be used by any PrePi modules or passed
-  to the PeiCore by PrePeiCore.
-
-  @param[out]   PpiListSize         Size in Bytes of the Platform PPI List
-  @param[out]   PpiList             Platform PPI List
-
-**/
-VOID
-ArmPlatformGetPlatformPpiList (
-  OUT UINTN                   *PpiListSize,
-  OUT EFI_PEI_PPI_DESCRIPTOR  **PpiList
-  );
-
-#endif
+/** @file

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+#ifndef _ARMPLATFORMLIB_H_

+#define _ARMPLATFORMLIB_H_

+

+//

+// The package level header files this module uses

+//

+#include <PiPei.h>

+//

+// The protocols, PPI and GUID defintions for this module

+//

+#include <Ppi/MasterBootMode.h>

+#include <Ppi/BootInRecoveryMode.h>

+#include <Guid/MemoryTypeInformation.h>

+

+#include <Library/ArmLib.h>

+

+/**

+  This structure is used to describe a region of the EFI memory map

+

+  Every EFI regions of the system memory described by their physical start address and their size

+  can have different attributes. Some regions can be tested and other untested.

+

+**/

+typedef struct {

+  EFI_RESOURCE_ATTRIBUTE_TYPE  ResourceAttribute;

+  EFI_PHYSICAL_ADDRESS         PhysicalStart;

+  UINT64                       NumberOfBytes;

+} ARM_SYSTEM_MEMORY_REGION_DESCRIPTOR;

+

+UINTN

+ArmPlatformGetCorePosition (

+  IN UINTN MpId

+  );

+

+/**

+  Return the current Boot Mode

+

+  This function returns the boot reason on the platform

+

+  @return   Return the current Boot Mode of the platform

+

+**/

+EFI_BOOT_MODE

+ArmPlatformGetBootMode (

+  VOID

+  );

+

+/**

+  Initialize controllers that must setup in the normal world

+

+  This function is called by the ArmPlatformPkg/PrePi or ArmPlatformPkg/PlatformPei

+  in the PEI phase.

+

+**/

+RETURN_STATUS

+ArmPlatformInitialize (

+  IN  UINTN                     MpId

+  );

+

+/**

+  Initialize the system (or sometimes called permanent) memory

+

+  This memory is generally represented by the DRAM.

+

+**/

+VOID

+ArmPlatformInitializeSystemMemory (

+  VOID

+  );

+

+/**

+  Return the Virtual Memory Map of your platform

+

+  This Virtual Memory Map is used by MemoryInitPei Module to initialize the MMU on your platform.

+

+  @param[out]   VirtualMemoryMap    Array of ARM_MEMORY_REGION_DESCRIPTOR describing a Physical-to-

+                                    Virtual Memory mapping. This array must be ended by a zero-filled

+                                    entry

+

+**/

+VOID

+ArmPlatformGetVirtualMemoryMap (

+  OUT ARM_MEMORY_REGION_DESCRIPTOR** VirtualMemoryMap

+  );

+

+/**

+  Return the EFI Memory Map of your platform

+

+  This EFI Memory Map of the System Memory is used by MemoryInitPei module to create the Resource

+  Descriptor HOBs used by DXE core.

+

+  @param[out]   EfiMemoryMap        Array of ARM_SYSTEM_MEMORY_REGION_DESCRIPTOR describing an

+                                    EFI Memory region. This array must be ended by a zero-filled entry

+

+**/

+EFI_STATUS

+ArmPlatformGetAdditionalSystemMemory (

+  OUT ARM_SYSTEM_MEMORY_REGION_DESCRIPTOR** EfiMemoryMap

+  );

+

+/**

+  Return the Platform specific PPIs

+

+  This function exposes the Platform Specific PPIs. They can be used by any PrePi modules or passed

+  to the PeiCore by PrePeiCore.

+

+  @param[out]   PpiListSize         Size in Bytes of the Platform PPI List

+  @param[out]   PpiList             Platform PPI List

+

+**/

+VOID

+ArmPlatformGetPlatformPpiList (

+  OUT UINTN                   *PpiListSize,

+  OUT EFI_PEI_PPI_DESCRIPTOR  **PpiList

+  );

+

+#endif

diff --git a/ArmPlatformPkg/Include/Library/ArmPlatformSecLib.h b/ArmPlatformPkg/Include/Library/ArmPlatformSecLib.h
index 32f1eb50..ece80649 100644
--- a/ArmPlatformPkg/Include/Library/ArmPlatformSecLib.h
+++ b/ArmPlatformPkg/Include/Library/ArmPlatformSecLib.h
@@ -1,88 +1,88 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-#ifndef _ARMPLATFORMSECLIB_H_
-#define _ARMPLATFORMSECLIB_H_
-
-#define ARM_SEC_BOOT_MASK                 ~0
-#define ARM_SEC_COLD_BOOT                 (1 << 0)
-#define ARM_SEC_SECONDARY_COLD_BOOT       (1 << 1)
-
-/**
-  Initialize the memory where the initial stacks will reside
-
-  This memory can contain the initial stacks (Secure and Secure Monitor stacks).
-  In some platform, this region is already initialized and the implementation of this function can
-  do nothing. This memory can also represent the Secure RAM.
-  This function is called before the satck has been set up. Its implementation must ensure the stack
-  pointer is not used (probably required to use assembly language)
-
-**/
-VOID
-ArmPlatformSecBootMemoryInit (
-  VOID
-  );
-
-/**
-  Call at the beginning of the platform boot up
-
-  This function allows the firmware platform to do extra actions at the early
-  stage of the platform power up.
-
-  Note: This function must be implemented in assembler as there is no stack set up yet
-
-**/
-VOID
-ArmPlatformSecBootAction (
-  VOID
-  );
-
-/**
-  Initialize controllers that must setup at the early stage
-
-  Some peripherals must be initialized in Secure World.
-  For example: Some L2 controller, interconnect, clock, DMC, etc
-
-**/
-RETURN_STATUS
-ArmPlatformSecInitialize (
-  IN  UINTN                     MpId
-  );
-
-/**
-  Call before jumping to Normal World
-
-  This function allows the firmware platform to do extra actions before
-  jumping to the Normal World
-
-**/
-VOID
-ArmPlatformSecExtraAction (
-  IN  UINTN         MpId,
-  OUT UINTN*        JumpAddress
-  );
-
-/**
-  Initialize the Secure peripherals and memory regions
-
-  If Trustzone is supported by your platform then this function makes the required initialization
-  of the secure peripherals and memory regions.
-
-**/
-VOID
-ArmPlatformSecTrustzoneInit (
-  IN  UINTN                     MpId
-  );
-
-#endif
+/** @file

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+#ifndef _ARMPLATFORMSECLIB_H_

+#define _ARMPLATFORMSECLIB_H_

+

+#define ARM_SEC_BOOT_MASK                 ~0

+#define ARM_SEC_COLD_BOOT                 (1 << 0)

+#define ARM_SEC_SECONDARY_COLD_BOOT       (1 << 1)

+

+/**

+  Initialize the memory where the initial stacks will reside

+

+  This memory can contain the initial stacks (Secure and Secure Monitor stacks).

+  In some platform, this region is already initialized and the implementation of this function can

+  do nothing. This memory can also represent the Secure RAM.

+  This function is called before the satck has been set up. Its implementation must ensure the stack

+  pointer is not used (probably required to use assembly language)

+

+**/

+VOID

+ArmPlatformSecBootMemoryInit (

+  VOID

+  );

+

+/**

+  Call at the beginning of the platform boot up

+

+  This function allows the firmware platform to do extra actions at the early

+  stage of the platform power up.

+

+  Note: This function must be implemented in assembler as there is no stack set up yet

+

+**/

+VOID

+ArmPlatformSecBootAction (

+  VOID

+  );

+

+/**

+  Initialize controllers that must setup at the early stage

+

+  Some peripherals must be initialized in Secure World.

+  For example: Some L2 controller, interconnect, clock, DMC, etc

+

+**/

+RETURN_STATUS

+ArmPlatformSecInitialize (

+  IN  UINTN                     MpId

+  );

+

+/**

+  Call before jumping to Normal World

+

+  This function allows the firmware platform to do extra actions before

+  jumping to the Normal World

+

+**/

+VOID

+ArmPlatformSecExtraAction (

+  IN  UINTN         MpId,

+  OUT UINTN*        JumpAddress

+  );

+

+/**

+  Initialize the Secure peripherals and memory regions

+

+  If Trustzone is supported by your platform then this function makes the required initialization

+  of the secure peripherals and memory regions.

+

+**/

+VOID

+ArmPlatformSecTrustzoneInit (

+  IN  UINTN                     MpId

+  );

+

+#endif

diff --git a/ArmPlatformPkg/Include/Library/ArmPlatformSysConfigLib.h b/ArmPlatformPkg/Include/Library/ArmPlatformSysConfigLib.h
index 3c59bcc3..39a0cc7f 100644
--- a/ArmPlatformPkg/Include/Library/ArmPlatformSysConfigLib.h
+++ b/ArmPlatformPkg/Include/Library/ArmPlatformSysConfigLib.h
@@ -1,63 +1,63 @@
-/** @file  ArmPlatformSysConfigLib.h
-
-  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __ARM_PLATFORM_SYS_CONFIG_H__
-#define __ARM_PLATFORM_SYS_CONFIG_H__
-
-#include <Base.h>
-
-/* This header file makes it easier to access the System Configuration Registers
- * in the ARM Versatile Express motherboard.
- */
-
-//
-// Typedef
-//
-typedef UINT32  SYS_CONFIG_FUNCTION;
-
-//
-// Functions
-//
-RETURN_STATUS
-ArmPlatformSysConfigInitialize (
-  VOID
-  );
-
-RETURN_STATUS
-ArmPlatformSysConfigGet (
-  IN  SYS_CONFIG_FUNCTION   Function,
-  OUT UINT32*               Value
-  );
-
-RETURN_STATUS
-ArmPlatformSysConfigGetValues (
-  IN  SYS_CONFIG_FUNCTION   Function,
-  IN  UINTN                 Size,
-  OUT UINT32*               Values
-  );
-
-RETURN_STATUS
-ArmPlatformSysConfigSet (
-  IN  SYS_CONFIG_FUNCTION   Function,
-  IN  UINT32                Value
-  );
-
-RETURN_STATUS
-ArmPlatformSysConfigSetDevice (
-  IN  SYS_CONFIG_FUNCTION   Function,
-  IN  UINT32                Device,
-  IN  UINT32                Value
-  );
-
-#endif /* __SYS_CFG_REGISTERS_H__ */
+/** @file  ArmPlatformSysConfigLib.h

+

+  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __ARM_PLATFORM_SYS_CONFIG_H__

+#define __ARM_PLATFORM_SYS_CONFIG_H__

+

+#include <Base.h>

+

+/* This header file makes it easier to access the System Configuration Registers

+ * in the ARM Versatile Express motherboard.

+ */

+

+//

+// Typedef

+//

+typedef UINT32  SYS_CONFIG_FUNCTION;

+

+//

+// Functions

+//

+RETURN_STATUS

+ArmPlatformSysConfigInitialize (

+  VOID

+  );

+

+RETURN_STATUS

+ArmPlatformSysConfigGet (

+  IN  SYS_CONFIG_FUNCTION   Function,

+  OUT UINT32*               Value

+  );

+

+RETURN_STATUS

+ArmPlatformSysConfigGetValues (

+  IN  SYS_CONFIG_FUNCTION   Function,

+  IN  UINTN                 Size,

+  OUT UINT32*               Values

+  );

+

+RETURN_STATUS

+ArmPlatformSysConfigSet (

+  IN  SYS_CONFIG_FUNCTION   Function,

+  IN  UINT32                Value

+  );

+

+RETURN_STATUS

+ArmPlatformSysConfigSetDevice (

+  IN  SYS_CONFIG_FUNCTION   Function,

+  IN  UINT32                Device,

+  IN  UINT32                Value

+  );

+

+#endif /* __SYS_CFG_REGISTERS_H__ */

diff --git a/ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/Dxe/DxeArmPlatformGlobalVariableLib.c b/ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/Dxe/DxeArmPlatformGlobalVariableLib.c
index 27813875..511d0f69 100644
--- a/ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/Dxe/DxeArmPlatformGlobalVariableLib.c
+++ b/ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/Dxe/DxeArmPlatformGlobalVariableLib.c
@@ -1,76 +1,76 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*
-*  This program and the accompanying materials
-*  are licensed and made available under the terms and conditions of the BSD License
-*  which accompanies this distribution.  The full text of the license may be found at
-*  http://opensource.org/licenses/bsd-license.php
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-*
-**/
-
-#include <PiDxe.h>
-#include <Library/ArmPlatformGlobalVariableLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/DebugLib.h>
-#include <Library/HobLib.h>
-#include <Library/PcdLib.h>
-
-#include <Guid/ArmGlobalVariableHob.h>
-
-UINTN  mGlobalVariableBase = 0;
-
-RETURN_STATUS
-EFIAPI
-ArmPlatformGlobalVariableConstructor (
-  VOID
-  )
-{
-  ARM_HOB_GLOBAL_VARIABLE  *Hob;
-
-  Hob = GetFirstGuidHob (&gArmGlobalVariableGuid);
-  ASSERT (Hob != NULL);
-
-  mGlobalVariableBase = Hob->GlobalVariableBase;
-
-  return EFI_SUCCESS;
-}
-
-VOID
-ArmPlatformGetGlobalVariable (
-  IN  UINTN     VariableOffset,
-  IN  UINTN     VariableSize,
-  OUT VOID*     Variable
-  )
-{
-  if (mGlobalVariableBase == 0) {
-    ArmPlatformGlobalVariableConstructor ();
-  }
-
-  CopyMem (Variable, (VOID*)(mGlobalVariableBase + VariableOffset), VariableSize);
-}
-
-VOID
-ArmPlatformSetGlobalVariable (
-  IN  UINTN     VariableOffset,
-  IN  UINTN     VariableSize,
-  OUT VOID*     Variable
-  )
-{
-  if (mGlobalVariableBase == 0) {
-    ArmPlatformGlobalVariableConstructor ();
-  }
-
-  CopyMem ((VOID*)(mGlobalVariableBase + VariableOffset), Variable, VariableSize);
-}
-
-VOID*
-ArmPlatformGetGlobalVariableAddress (
-  IN  UINTN     VariableOffset
-  )
-{
-  return (VOID*)(mGlobalVariableBase + VariableOffset);
-}
+/** @file

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*

+*  This program and the accompanying materials

+*  are licensed and made available under the terms and conditions of the BSD License

+*  which accompanies this distribution.  The full text of the license may be found at

+*  http://opensource.org/licenses/bsd-license.php

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+*

+**/

+

+#include <PiDxe.h>

+#include <Library/ArmPlatformGlobalVariableLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/DebugLib.h>

+#include <Library/HobLib.h>

+#include <Library/PcdLib.h>

+

+#include <Guid/ArmGlobalVariableHob.h>

+

+UINTN  mGlobalVariableBase = 0;

+

+RETURN_STATUS

+EFIAPI

+ArmPlatformGlobalVariableConstructor (

+  VOID

+  )

+{

+  ARM_HOB_GLOBAL_VARIABLE  *Hob;

+

+  Hob = GetFirstGuidHob (&gArmGlobalVariableGuid);

+  ASSERT (Hob != NULL);

+

+  mGlobalVariableBase = Hob->GlobalVariableBase;

+

+  return EFI_SUCCESS;

+}

+

+VOID

+ArmPlatformGetGlobalVariable (

+  IN  UINTN     VariableOffset,

+  IN  UINTN     VariableSize,

+  OUT VOID*     Variable

+  )

+{

+  if (mGlobalVariableBase == 0) {

+    ArmPlatformGlobalVariableConstructor ();

+  }

+

+  CopyMem (Variable, (VOID*)(mGlobalVariableBase + VariableOffset), VariableSize);

+}

+

+VOID

+ArmPlatformSetGlobalVariable (

+  IN  UINTN     VariableOffset,

+  IN  UINTN     VariableSize,

+  OUT VOID*     Variable

+  )

+{

+  if (mGlobalVariableBase == 0) {

+    ArmPlatformGlobalVariableConstructor ();

+  }

+

+  CopyMem ((VOID*)(mGlobalVariableBase + VariableOffset), Variable, VariableSize);

+}

+

+VOID*

+ArmPlatformGetGlobalVariableAddress (

+  IN  UINTN     VariableOffset

+  )

+{

+  return (VOID*)(mGlobalVariableBase + VariableOffset);

+}

diff --git a/ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/Dxe/DxeArmPlatformGlobalVariableLib.inf b/ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/Dxe/DxeArmPlatformGlobalVariableLib.inf
index f2284ce4..a0835d25 100644
--- a/ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/Dxe/DxeArmPlatformGlobalVariableLib.inf
+++ b/ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/Dxe/DxeArmPlatformGlobalVariableLib.inf
@@ -1,44 +1,44 @@
-#/** @file
-# Timer library implementation
-#  
-#  
-#  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>
-#
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = DxeArmPlatformGlobalVariableLib
-  FILE_GUID                      = 53fa3cc3-23b7-4ec2-9bfa-30257d7e1135 
-  MODULE_TYPE                    = BASE
-  VERSION_STRING                 = 1.0
-  LIBRARY_CLASS                  = ArmPlatformGlobalVariableLib
-  
-  CONSTRUCTOR                    = ArmPlatformGlobalVariableConstructor
-
-[Sources.common]
-  DxeArmPlatformGlobalVariableLib.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  ArmPlatformPkg/ArmPlatformPkg.dec
-
-[LibraryClasses]
-  BaseLib
-  DebugLib
-  HobLib
-
-[Guids]
-  gArmGlobalVariableGuid
-
-[FixedPcd]
-  gArmPlatformTokenSpaceGuid.PcdPeiGlobalVariableSize
-
+#/** @file

+# Timer library implementation

+#  

+#  

+#  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>

+#

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = DxeArmPlatformGlobalVariableLib

+  FILE_GUID                      = 53fa3cc3-23b7-4ec2-9bfa-30257d7e1135 

+  MODULE_TYPE                    = BASE

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = ArmPlatformGlobalVariableLib

+  

+  CONSTRUCTOR                    = ArmPlatformGlobalVariableConstructor

+

+[Sources.common]

+  DxeArmPlatformGlobalVariableLib.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+

+[LibraryClasses]

+  BaseLib

+  DebugLib

+  HobLib

+

+[Guids]

+  gArmGlobalVariableGuid

+

+[FixedPcd]

+  gArmPlatformTokenSpaceGuid.PcdPeiGlobalVariableSize

+

diff --git a/ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/Pei/PeiArmPlatformGlobalVariableLib.c b/ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/Pei/PeiArmPlatformGlobalVariableLib.c
index 63aa3199..df3e1294 100644
--- a/ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/Pei/PeiArmPlatformGlobalVariableLib.c
+++ b/ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/Pei/PeiArmPlatformGlobalVariableLib.c
@@ -1,84 +1,84 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*
-*  This program and the accompanying materials
-*  are licensed and made available under the terms and conditions of the BSD License
-*  which accompanies this distribution.  The full text of the license may be found at
-*  http://opensource.org/licenses/bsd-license.php
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-*
-**/
-
-#include <Uefi.h>
-#include <Library/ArmPlatformGlobalVariableLib.h>
-#include <Library/BaseLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/PcdLib.h>
-#include <Library/DebugLib.h>
-
-// Declared by ArmPlatformPkg/PrePi Module
-extern UINTN mGlobalVariableBase;
-
-VOID
-ArmPlatformGetGlobalVariable (
-  IN  UINTN     VariableOffset,
-  IN  UINTN     VariableSize,
-  OUT VOID*     Variable
-  )
-{
-  UINTN  GlobalVariableBase;
-
-  // Ensure the Global Variable Size have been initialized
-  ASSERT (VariableOffset < PcdGet32 (PcdPeiGlobalVariableSize));
-
-  GlobalVariableBase = PcdGet32 (PcdCPUCoresStackBase) + PcdGet32 (PcdCPUCorePrimaryStackSize) - PcdGet32 (PcdPeiGlobalVariableSize);
-
-  if (VariableSize == 4) {
-    *(UINT32*)Variable = ReadUnaligned32 ((CONST UINT32*)(GlobalVariableBase + VariableOffset));
-  } else if (VariableSize == 8) {
-    *(UINT64*)Variable = ReadUnaligned64 ((CONST UINT64*)(GlobalVariableBase + VariableOffset));
-  } else {
-    CopyMem (Variable, (VOID*)(GlobalVariableBase + VariableOffset), VariableSize);
-  }
-}
-
-VOID
-ArmPlatformSetGlobalVariable (
-  IN  UINTN     VariableOffset,
-  IN  UINTN     VariableSize,
-  OUT VOID*     Variable
-  )
-{
-  UINTN  GlobalVariableBase;
-
-  // Ensure the Global Variable Size have been initialized
-  ASSERT (VariableOffset < PcdGet32 (PcdPeiGlobalVariableSize));
-
-  GlobalVariableBase = PcdGet32 (PcdCPUCoresStackBase) + PcdGet32 (PcdCPUCorePrimaryStackSize) - PcdGet32 (PcdPeiGlobalVariableSize);
-
-  if (VariableSize == 4) {
-    WriteUnaligned32 ((UINT32*)(GlobalVariableBase + VariableOffset), *(UINT32*)Variable);
-  } else if (VariableSize == 8) {
-    WriteUnaligned64 ((UINT64*)(GlobalVariableBase + VariableOffset), *(UINT64*)Variable);
-  } else {
-    CopyMem ((VOID*)(GlobalVariableBase + VariableOffset), Variable, VariableSize);
-  }
-}
-
-VOID*
-ArmPlatformGetGlobalVariableAddress (
-  IN  UINTN     VariableOffset
-  )
-{
-  UINTN  GlobalVariableBase;
-
-  // Ensure the Global Variable Size have been initialized
-  ASSERT (VariableOffset < PcdGet32 (PcdPeiGlobalVariableSize));
-
-  GlobalVariableBase = PcdGet32 (PcdCPUCoresStackBase) + PcdGet32 (PcdCPUCorePrimaryStackSize) - PcdGet32 (PcdPeiGlobalVariableSize);
-
-  return (VOID*)(GlobalVariableBase + VariableOffset);
-}
+/** @file

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*

+*  This program and the accompanying materials

+*  are licensed and made available under the terms and conditions of the BSD License

+*  which accompanies this distribution.  The full text of the license may be found at

+*  http://opensource.org/licenses/bsd-license.php

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+*

+**/

+

+#include <Uefi.h>

+#include <Library/ArmPlatformGlobalVariableLib.h>

+#include <Library/BaseLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/PcdLib.h>

+#include <Library/DebugLib.h>

+

+// Declared by ArmPlatformPkg/PrePi Module

+extern UINTN mGlobalVariableBase;

+

+VOID

+ArmPlatformGetGlobalVariable (

+  IN  UINTN     VariableOffset,

+  IN  UINTN     VariableSize,

+  OUT VOID*     Variable

+  )

+{

+  UINTN  GlobalVariableBase;

+

+  // Ensure the Global Variable Size have been initialized

+  ASSERT (VariableOffset < PcdGet32 (PcdPeiGlobalVariableSize));

+

+  GlobalVariableBase = PcdGet32 (PcdCPUCoresStackBase) + PcdGet32 (PcdCPUCorePrimaryStackSize) - PcdGet32 (PcdPeiGlobalVariableSize);

+

+  if (VariableSize == 4) {

+    *(UINT32*)Variable = ReadUnaligned32 ((CONST UINT32*)(GlobalVariableBase + VariableOffset));

+  } else if (VariableSize == 8) {

+    *(UINT64*)Variable = ReadUnaligned64 ((CONST UINT64*)(GlobalVariableBase + VariableOffset));

+  } else {

+    CopyMem (Variable, (VOID*)(GlobalVariableBase + VariableOffset), VariableSize);

+  }

+}

+

+VOID

+ArmPlatformSetGlobalVariable (

+  IN  UINTN     VariableOffset,

+  IN  UINTN     VariableSize,

+  OUT VOID*     Variable

+  )

+{

+  UINTN  GlobalVariableBase;

+

+  // Ensure the Global Variable Size have been initialized

+  ASSERT (VariableOffset < PcdGet32 (PcdPeiGlobalVariableSize));

+

+  GlobalVariableBase = PcdGet32 (PcdCPUCoresStackBase) + PcdGet32 (PcdCPUCorePrimaryStackSize) - PcdGet32 (PcdPeiGlobalVariableSize);

+

+  if (VariableSize == 4) {

+    WriteUnaligned32 ((UINT32*)(GlobalVariableBase + VariableOffset), *(UINT32*)Variable);

+  } else if (VariableSize == 8) {

+    WriteUnaligned64 ((UINT64*)(GlobalVariableBase + VariableOffset), *(UINT64*)Variable);

+  } else {

+    CopyMem ((VOID*)(GlobalVariableBase + VariableOffset), Variable, VariableSize);

+  }

+}

+

+VOID*

+ArmPlatformGetGlobalVariableAddress (

+  IN  UINTN     VariableOffset

+  )

+{

+  UINTN  GlobalVariableBase;

+

+  // Ensure the Global Variable Size have been initialized

+  ASSERT (VariableOffset < PcdGet32 (PcdPeiGlobalVariableSize));

+

+  GlobalVariableBase = PcdGet32 (PcdCPUCoresStackBase) + PcdGet32 (PcdCPUCorePrimaryStackSize) - PcdGet32 (PcdPeiGlobalVariableSize);

+

+  return (VOID*)(GlobalVariableBase + VariableOffset);

+}

diff --git a/ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/Pei/PeiArmPlatformGlobalVariableLib.inf b/ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/Pei/PeiArmPlatformGlobalVariableLib.inf
index a14f9332..8eea9d38 100644
--- a/ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/Pei/PeiArmPlatformGlobalVariableLib.inf
+++ b/ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/Pei/PeiArmPlatformGlobalVariableLib.inf
@@ -1,40 +1,40 @@
-#/** @file
-# ArmPlatformGlobalVariableLib library implementation
-#  
-#  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>
-#  
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = PeiArmPlatformGlobalVariableLib
-  FILE_GUID                      = 3e03daf2-b7b4-45f7-80b2-12aba043391f
-  MODULE_TYPE                    = BASE
-  VERSION_STRING                 = 1.0
-  LIBRARY_CLASS                  = ArmPlatformGlobalVariableLib
-
-[Sources.common]
-  PeiArmPlatformGlobalVariableLib.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  ArmPlatformPkg/ArmPlatformPkg.dec
-
-[LibraryClasses]
-  BaseLib
-  DebugLib
-  PcdLib
-
-[FixedPcd]
-  gArmPlatformTokenSpaceGuid.PcdCPUCoresStackBase
-  gArmPlatformTokenSpaceGuid.PcdCPUCorePrimaryStackSize
-  gArmPlatformTokenSpaceGuid.PcdPeiGlobalVariableSize
-
+#/** @file

+# ArmPlatformGlobalVariableLib library implementation

+#  

+#  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>

+#  

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = PeiArmPlatformGlobalVariableLib

+  FILE_GUID                      = 3e03daf2-b7b4-45f7-80b2-12aba043391f

+  MODULE_TYPE                    = BASE

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = ArmPlatformGlobalVariableLib

+

+[Sources.common]

+  PeiArmPlatformGlobalVariableLib.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+

+[LibraryClasses]

+  BaseLib

+  DebugLib

+  PcdLib

+

+[FixedPcd]

+  gArmPlatformTokenSpaceGuid.PcdCPUCoresStackBase

+  gArmPlatformTokenSpaceGuid.PcdCPUCorePrimaryStackSize

+  gArmPlatformTokenSpaceGuid.PcdPeiGlobalVariableSize

+

diff --git a/ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/PrePi/PrePiArmPlatformGlobalVariableLib.c b/ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/PrePi/PrePiArmPlatformGlobalVariableLib.c
index 563e405f..47430e30 100644
--- a/ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/PrePi/PrePiArmPlatformGlobalVariableLib.c
+++ b/ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/PrePi/PrePiArmPlatformGlobalVariableLib.c
@@ -1,105 +1,105 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*
-*  This program and the accompanying materials
-*  are licensed and made available under the terms and conditions of the BSD License
-*  which accompanies this distribution.  The full text of the license may be found at
-*  http://opensource.org/licenses/bsd-license.php
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-*
-**/
-
-#include <Uefi.h>
-#include <Library/ArmPlatformGlobalVariableLib.h>
-#include <Library/BaseLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/PcdLib.h>
-#include <Library/DebugLib.h>
-
-#define IS_XIP() (((UINT32)PcdGet32 (PcdFdBaseAddress) > (UINT32)(PcdGet32 (PcdSystemMemoryBase) + PcdGet32 (PcdSystemMemorySize))) || \
-                  ((PcdGet32 (PcdFdBaseAddress) + PcdGet32 (PcdFdSize)) < PcdGet32 (PcdSystemMemoryBase)))
-
-// Declared by ArmPlatformPkg/PrePi Module
-extern UINTN mGlobalVariableBase;
-
-VOID
-ArmPlatformGetGlobalVariable (
-  IN  UINTN     VariableOffset,
-  IN  UINTN     VariableSize,
-  OUT VOID*     Variable
-  )
-{
-  UINTN  GlobalVariableBase;
-
-  // Ensure the Global Variable Size have been initialized
-  ASSERT (VariableOffset < PcdGet32 (PcdPeiGlobalVariableSize));
-
-  if (IS_XIP()) {
-    // In Case of XIP, we expect the Primary Stack at the top of the System Memory
-    // The size must be 64bit aligned to allow 64bit variable to be aligned
-    GlobalVariableBase = PcdGet32 (PcdSystemMemoryBase) + PcdGet32 (PcdSystemMemorySize) - ALIGN_VALUE(PcdGet32 (PcdPeiGlobalVariableSize),0x8);
-  } else {
-    GlobalVariableBase = mGlobalVariableBase;
-  }
-
-  if (VariableSize == 4) {
-    *(UINT32*)Variable = ReadUnaligned32 ((CONST UINT32*)(GlobalVariableBase + VariableOffset));
-  } else if (VariableSize == 8) {
-    *(UINT64*)Variable = ReadUnaligned64 ((CONST UINT64*)(GlobalVariableBase + VariableOffset));
-  } else {
-    CopyMem (Variable, (VOID*)(GlobalVariableBase + VariableOffset), VariableSize);
-  }
-}
-
-VOID
-ArmPlatformSetGlobalVariable (
-  IN  UINTN     VariableOffset,
-  IN  UINTN     VariableSize,
-  OUT VOID*     Variable
-  )
-{
-  UINTN  GlobalVariableBase;
-
-  // Ensure the Global Variable Size have been initialized
-  ASSERT (VariableOffset < PcdGet32 (PcdPeiGlobalVariableSize));
-
-  if (IS_XIP()) {
-    // In Case of XIP, we expect the Primary Stack at the top of the System Memory
-    // The size must be 64bit aligned to allow 64bit variable to be aligned
-    GlobalVariableBase = PcdGet32 (PcdSystemMemoryBase) + PcdGet32 (PcdSystemMemorySize) - ALIGN_VALUE(PcdGet32 (PcdPeiGlobalVariableSize),0x8);
-  } else {
-    GlobalVariableBase = mGlobalVariableBase;
-  }
-
-  if (VariableSize == 4) {
-    WriteUnaligned32 ((UINT32*)(GlobalVariableBase + VariableOffset), *(UINT32*)Variable);
-  } else if (VariableSize == 8) {
-    WriteUnaligned64 ((UINT64*)(GlobalVariableBase + VariableOffset), *(UINT64*)Variable);
-  } else {
-    CopyMem ((VOID*)(GlobalVariableBase + VariableOffset), Variable, VariableSize);
-  }
-}
-
-VOID*
-ArmPlatformGetGlobalVariableAddress (
-  IN  UINTN     VariableOffset
-  )
-{
-  UINTN  GlobalVariableBase;
-
-  // Ensure the Global Variable Size have been initialized
-  ASSERT (VariableOffset < PcdGet32 (PcdPeiGlobalVariableSize));
-
-  if (IS_XIP()) {
-    // In Case of XIP, we expect the Primary Stack at the top of the System Memory
-    // The size must be 64bit aligned to allow 64bit variable to be aligned
-    GlobalVariableBase = PcdGet32 (PcdSystemMemoryBase) + PcdGet32 (PcdSystemMemorySize) - ALIGN_VALUE(PcdGet32 (PcdPeiGlobalVariableSize),0x8);
-  } else {
-    GlobalVariableBase = mGlobalVariableBase;
-  }
-
-  return (VOID*)(GlobalVariableBase + VariableOffset);
-}
+/** @file

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*

+*  This program and the accompanying materials

+*  are licensed and made available under the terms and conditions of the BSD License

+*  which accompanies this distribution.  The full text of the license may be found at

+*  http://opensource.org/licenses/bsd-license.php

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+*

+**/

+

+#include <Uefi.h>

+#include <Library/ArmPlatformGlobalVariableLib.h>

+#include <Library/BaseLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/PcdLib.h>

+#include <Library/DebugLib.h>

+

+#define IS_XIP() (((UINT32)PcdGet32 (PcdFdBaseAddress) > (UINT32)(PcdGet32 (PcdSystemMemoryBase) + PcdGet32 (PcdSystemMemorySize))) || \

+                  ((PcdGet32 (PcdFdBaseAddress) + PcdGet32 (PcdFdSize)) < PcdGet32 (PcdSystemMemoryBase)))

+

+// Declared by ArmPlatformPkg/PrePi Module

+extern UINTN mGlobalVariableBase;

+

+VOID

+ArmPlatformGetGlobalVariable (

+  IN  UINTN     VariableOffset,

+  IN  UINTN     VariableSize,

+  OUT VOID*     Variable

+  )

+{

+  UINTN  GlobalVariableBase;

+

+  // Ensure the Global Variable Size have been initialized

+  ASSERT (VariableOffset < PcdGet32 (PcdPeiGlobalVariableSize));

+

+  if (IS_XIP()) {

+    // In Case of XIP, we expect the Primary Stack at the top of the System Memory

+    // The size must be 64bit aligned to allow 64bit variable to be aligned

+    GlobalVariableBase = PcdGet32 (PcdSystemMemoryBase) + PcdGet32 (PcdSystemMemorySize) - ALIGN_VALUE(PcdGet32 (PcdPeiGlobalVariableSize),0x8);

+  } else {

+    GlobalVariableBase = mGlobalVariableBase;

+  }

+

+  if (VariableSize == 4) {

+    *(UINT32*)Variable = ReadUnaligned32 ((CONST UINT32*)(GlobalVariableBase + VariableOffset));

+  } else if (VariableSize == 8) {

+    *(UINT64*)Variable = ReadUnaligned64 ((CONST UINT64*)(GlobalVariableBase + VariableOffset));

+  } else {

+    CopyMem (Variable, (VOID*)(GlobalVariableBase + VariableOffset), VariableSize);

+  }

+}

+

+VOID

+ArmPlatformSetGlobalVariable (

+  IN  UINTN     VariableOffset,

+  IN  UINTN     VariableSize,

+  OUT VOID*     Variable

+  )

+{

+  UINTN  GlobalVariableBase;

+

+  // Ensure the Global Variable Size have been initialized

+  ASSERT (VariableOffset < PcdGet32 (PcdPeiGlobalVariableSize));

+

+  if (IS_XIP()) {

+    // In Case of XIP, we expect the Primary Stack at the top of the System Memory

+    // The size must be 64bit aligned to allow 64bit variable to be aligned

+    GlobalVariableBase = PcdGet32 (PcdSystemMemoryBase) + PcdGet32 (PcdSystemMemorySize) - ALIGN_VALUE(PcdGet32 (PcdPeiGlobalVariableSize),0x8);

+  } else {

+    GlobalVariableBase = mGlobalVariableBase;

+  }

+

+  if (VariableSize == 4) {

+    WriteUnaligned32 ((UINT32*)(GlobalVariableBase + VariableOffset), *(UINT32*)Variable);

+  } else if (VariableSize == 8) {

+    WriteUnaligned64 ((UINT64*)(GlobalVariableBase + VariableOffset), *(UINT64*)Variable);

+  } else {

+    CopyMem ((VOID*)(GlobalVariableBase + VariableOffset), Variable, VariableSize);

+  }

+}

+

+VOID*

+ArmPlatformGetGlobalVariableAddress (

+  IN  UINTN     VariableOffset

+  )

+{

+  UINTN  GlobalVariableBase;

+

+  // Ensure the Global Variable Size have been initialized

+  ASSERT (VariableOffset < PcdGet32 (PcdPeiGlobalVariableSize));

+

+  if (IS_XIP()) {

+    // In Case of XIP, we expect the Primary Stack at the top of the System Memory

+    // The size must be 64bit aligned to allow 64bit variable to be aligned

+    GlobalVariableBase = PcdGet32 (PcdSystemMemoryBase) + PcdGet32 (PcdSystemMemorySize) - ALIGN_VALUE(PcdGet32 (PcdPeiGlobalVariableSize),0x8);

+  } else {

+    GlobalVariableBase = mGlobalVariableBase;

+  }

+

+  return (VOID*)(GlobalVariableBase + VariableOffset);

+}

diff --git a/ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/Sec/SecArmPlatformGlobalVariableLib.c b/ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/Sec/SecArmPlatformGlobalVariableLib.c
index 42d903f3..978ba333 100644
--- a/ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/Sec/SecArmPlatformGlobalVariableLib.c
+++ b/ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/Sec/SecArmPlatformGlobalVariableLib.c
@@ -1,81 +1,81 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*
-*  This program and the accompanying materials
-*  are licensed and made available under the terms and conditions of the BSD License
-*  which accompanies this distribution.  The full text of the license may be found at
-*  http://opensource.org/licenses/bsd-license.php
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-*
-**/
-
-#include <Uefi.h>
-#include <Library/ArmPlatformGlobalVariableLib.h>
-#include <Library/BaseLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/PcdLib.h>
-#include <Library/DebugLib.h>
-
-VOID
-ArmPlatformGetGlobalVariable (
-  IN  UINTN     VariableOffset,
-  IN  UINTN     VariableSize,
-  OUT VOID*     Variable
-  )
-{
-  UINTN  GlobalVariableBase;
-
-  // Ensure the Global Variable Size have been initialized
-  ASSERT (VariableOffset < PcdGet32 (PcdSecGlobalVariableSize));
-
-  GlobalVariableBase = PcdGet32 (PcdCPUCoresSecStackBase) + PcdGet32 (PcdCPUCoreSecPrimaryStackSize) - PcdGet32 (PcdSecGlobalVariableSize);
-  
-  if (VariableSize == 4) {
-    *(UINT32*)Variable = ReadUnaligned32 ((CONST UINT32*)(GlobalVariableBase + VariableOffset));
-  } else if (VariableSize == 8) {
-    *(UINT64*)Variable = ReadUnaligned64 ((CONST UINT64*)(GlobalVariableBase + VariableOffset));
-  } else {
-    CopyMem (Variable, (VOID*)(GlobalVariableBase + VariableOffset), VariableSize);
-  }
-}
-
-VOID
-ArmPlatformSetGlobalVariable (
-  IN  UINTN     VariableOffset,
-  IN  UINTN     VariableSize,
-  OUT VOID*     Variable
-  )
-{
-  UINTN  GlobalVariableBase;
-
-  // Ensure the Global Variable Size have been initialized
-  ASSERT (VariableOffset < PcdGet32 (PcdSecGlobalVariableSize));
-
-  GlobalVariableBase = PcdGet32 (PcdCPUCoresSecStackBase) + PcdGet32 (PcdCPUCoreSecPrimaryStackSize) - PcdGet32 (PcdSecGlobalVariableSize);
-
-  if (VariableSize == 4) {
-    WriteUnaligned32 ((UINT32*)(GlobalVariableBase + VariableOffset), *(UINT32*)Variable);
-  } else if (VariableSize == 8) {
-    WriteUnaligned64 ((UINT64*)(GlobalVariableBase + VariableOffset), *(UINT64*)Variable);
-  } else {
-    CopyMem ((VOID*)(GlobalVariableBase + VariableOffset), Variable, VariableSize);
-  }
-}
-
-VOID*
-ArmPlatformGetGlobalVariableAddress (
-  IN  UINTN     VariableOffset
-  )
-{
-  UINTN  GlobalVariableBase;
-
-  // Ensure the Global Variable Size have been initialized
-  ASSERT (VariableOffset < PcdGet32 (PcdSecGlobalVariableSize));
-
-  GlobalVariableBase = PcdGet32 (PcdCPUCoresSecStackBase) + PcdGet32 (PcdCPUCoreSecPrimaryStackSize) - PcdGet32 (PcdSecGlobalVariableSize);
-
-  return (VOID*)(GlobalVariableBase + VariableOffset);
-}
+/** @file

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*

+*  This program and the accompanying materials

+*  are licensed and made available under the terms and conditions of the BSD License

+*  which accompanies this distribution.  The full text of the license may be found at

+*  http://opensource.org/licenses/bsd-license.php

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+*

+**/

+

+#include <Uefi.h>

+#include <Library/ArmPlatformGlobalVariableLib.h>

+#include <Library/BaseLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/PcdLib.h>

+#include <Library/DebugLib.h>

+

+VOID

+ArmPlatformGetGlobalVariable (

+  IN  UINTN     VariableOffset,

+  IN  UINTN     VariableSize,

+  OUT VOID*     Variable

+  )

+{

+  UINTN  GlobalVariableBase;

+

+  // Ensure the Global Variable Size have been initialized

+  ASSERT (VariableOffset < PcdGet32 (PcdSecGlobalVariableSize));

+

+  GlobalVariableBase = PcdGet32 (PcdCPUCoresSecStackBase) + PcdGet32 (PcdCPUCoreSecPrimaryStackSize) - PcdGet32 (PcdSecGlobalVariableSize);

+  

+  if (VariableSize == 4) {

+    *(UINT32*)Variable = ReadUnaligned32 ((CONST UINT32*)(GlobalVariableBase + VariableOffset));

+  } else if (VariableSize == 8) {

+    *(UINT64*)Variable = ReadUnaligned64 ((CONST UINT64*)(GlobalVariableBase + VariableOffset));

+  } else {

+    CopyMem (Variable, (VOID*)(GlobalVariableBase + VariableOffset), VariableSize);

+  }

+}

+

+VOID

+ArmPlatformSetGlobalVariable (

+  IN  UINTN     VariableOffset,

+  IN  UINTN     VariableSize,

+  OUT VOID*     Variable

+  )

+{

+  UINTN  GlobalVariableBase;

+

+  // Ensure the Global Variable Size have been initialized

+  ASSERT (VariableOffset < PcdGet32 (PcdSecGlobalVariableSize));

+

+  GlobalVariableBase = PcdGet32 (PcdCPUCoresSecStackBase) + PcdGet32 (PcdCPUCoreSecPrimaryStackSize) - PcdGet32 (PcdSecGlobalVariableSize);

+

+  if (VariableSize == 4) {

+    WriteUnaligned32 ((UINT32*)(GlobalVariableBase + VariableOffset), *(UINT32*)Variable);

+  } else if (VariableSize == 8) {

+    WriteUnaligned64 ((UINT64*)(GlobalVariableBase + VariableOffset), *(UINT64*)Variable);

+  } else {

+    CopyMem ((VOID*)(GlobalVariableBase + VariableOffset), Variable, VariableSize);

+  }

+}

+

+VOID*

+ArmPlatformGetGlobalVariableAddress (

+  IN  UINTN     VariableOffset

+  )

+{

+  UINTN  GlobalVariableBase;

+

+  // Ensure the Global Variable Size have been initialized

+  ASSERT (VariableOffset < PcdGet32 (PcdSecGlobalVariableSize));

+

+  GlobalVariableBase = PcdGet32 (PcdCPUCoresSecStackBase) + PcdGet32 (PcdCPUCoreSecPrimaryStackSize) - PcdGet32 (PcdSecGlobalVariableSize);

+

+  return (VOID*)(GlobalVariableBase + VariableOffset);

+}

diff --git a/ArmPlatformPkg/Library/ArmPlatformLibNull/Arm/ArmPlatformHelper.S b/ArmPlatformPkg/Library/ArmPlatformLibNull/Arm/ArmPlatformHelper.S
new file mode 100644
index 00000000..28632795
--- /dev/null
+++ b/ArmPlatformPkg/Library/ArmPlatformLibNull/Arm/ArmPlatformHelper.S
@@ -0,0 +1,30 @@
+//

+//  Copyright (c) 2012, ARM Limited. All rights reserved.

+//

+//  This program and the accompanying materials

+//  are licensed and made available under the terms and conditions of the BSD License

+//  which accompanies this distribution.  The full text of the license may be found at

+//  http://opensource.org/licenses/bsd-license.php

+//

+//  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+//  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+//

+//

+

+#include <Library/ArmLib.h>

+

+.text 

+.align 3

+

+GCC_ASM_EXPORT(ArmPlatformGetCorePosition)

+

+//UINTN

+//ArmPlatformGetCorePosition (

+//  IN UINTN MpId

+//  );

+ASM_PFX(ArmPlatformGetCorePosition):

+  and	r1, r0, #ARM_CORE_MASK

+  and	r0, r0, #ARM_CLUSTER_MASK

+  add	r0, r1, r0, LSR #7

+  bx 	lr

+

diff --git a/ArmPlatformPkg/Library/ArmPlatformLibNull/Arm/ArmPlatformHelper.asm b/ArmPlatformPkg/Library/ArmPlatformLibNull/Arm/ArmPlatformHelper.asm
new file mode 100644
index 00000000..62056213
--- /dev/null
+++ b/ArmPlatformPkg/Library/ArmPlatformLibNull/Arm/ArmPlatformHelper.asm
@@ -0,0 +1,36 @@
+//

+//  Copyright (c) 2012, ARM Limited. All rights reserved.

+//

+//  This program and the accompanying materials

+//  are licensed and made available under the terms and conditions of the BSD License

+//  which accompanies this distribution.  The full text of the license may be found at

+//  http://opensource.org/licenses/bsd-license.php

+//

+//  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+//  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+//

+//

+

+#include <AsmMacroIoLib.h>

+#include <Library/ArmLib.h>

+

+  INCLUDE AsmMacroIoLib.inc

+

+  EXPORT  ArmPlatformGetCorePosition

+

+  PRESERVE8

+  AREA    ArmPlatformNullHelper, CODE, READONLY

+

+//UINTN

+//ArmPlatformGetCorePosition (

+//  IN UINTN MpId

+//  );

+ArmPlatformGetCorePosition FUNCTION

+  and	r1, r0, #ARM_CORE_MASK

+  and	r0, r0, #ARM_CLUSTER_MASK

+  add	r0, r1, r0, LSR #7

+  bx 	lr

+  ENDFUNC

+

+  END

+

diff --git a/ArmPlatformPkg/Library/ArmPlatformLibNull/ArmPlatformLibNull.c b/ArmPlatformPkg/Library/ArmPlatformLibNull/ArmPlatformLibNull.c
index 235eb673..f3a7efca 100644
--- a/ArmPlatformPkg/Library/ArmPlatformLibNull/ArmPlatformLibNull.c
+++ b/ArmPlatformPkg/Library/ArmPlatformLibNull/ArmPlatformLibNull.c
@@ -1,164 +1,164 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-#include <Library/ArmLib.h>
-#include <Library/ArmPlatformLib.h>
-
-#include <Ppi/ArmMpCoreInfo.h>
-
-
-ARM_CORE_INFO mArmPlatformNullMpCoreInfoTable[] = {
-  {
-    // Cluster 0, Core 0
-    0x0, 0x0,
-
-    // MP Core MailBox Set/Get/Clear Addresses and Clear Value
-    (EFI_PHYSICAL_ADDRESS)0,
-    (EFI_PHYSICAL_ADDRESS)0,
-    (EFI_PHYSICAL_ADDRESS)0,
-    (UINT64)0xFFFFFFFF
-  },
-  {
-    // Cluster 0, Core 1
-    0x0, 0x1,
-
-    // MP Core MailBox Set/Get/Clear Addresses and Clear Value
-    (EFI_PHYSICAL_ADDRESS)0,
-    (EFI_PHYSICAL_ADDRESS)0,
-    (EFI_PHYSICAL_ADDRESS)0,
-    (UINT64)0xFFFFFFFF
-  },
-  {
-    // Cluster 0, Core 2
-    0x0, 0x2,
-
-    // MP Core MailBox Set/Get/Clear Addresses and Clear Value
-    (EFI_PHYSICAL_ADDRESS)0,
-    (EFI_PHYSICAL_ADDRESS)0,
-    (EFI_PHYSICAL_ADDRESS)0,
-    (UINT64)0xFFFFFFFF
-  },
-  {
-    // Cluster 0, Core 3
-    0x0, 0x3,
-
-    // MP Core MailBox Set/Get/Clear Addresses and Clear Value
-    (EFI_PHYSICAL_ADDRESS)0,
-    (EFI_PHYSICAL_ADDRESS)0,
-    (EFI_PHYSICAL_ADDRESS)0,
-    (UINT64)0xFFFFFFFF
-  }
-};
-
-// This function should be better located into TimerLib implementation
-RETURN_STATUS
-EFIAPI
-TimerConstructor (
-  VOID
-  )
-{
-  return EFI_SUCCESS;
-}
-
-/**
-  Return the current Boot Mode
-
-  This function returns the boot reason on the platform
-
-**/
-EFI_BOOT_MODE
-ArmPlatformGetBootMode (
-  VOID
-  )
-{
-  return BOOT_WITH_FULL_CONFIGURATION;
-}
-
-/**
-  Initialize controllers that must setup in the normal world
-
-  This function is called by the ArmPlatformPkg/PrePi or ArmPlatformPkg/PlatformPei
-  in the PEI phase.
-
-**/
-RETURN_STATUS
-ArmPlatformInitialize (
-  IN  UINTN                     MpId
-  )
-{
-  if (!IS_PRIMARY_CORE(MpId)) {
-    return RETURN_SUCCESS;
-  }
-
-  //TODO: Implement me
-
-  return RETURN_SUCCESS;
-}
-
-/**
-  Initialize the system (or sometimes called permanent) memory
-
-  This memory is generally represented by the DRAM.
-
-**/
-VOID
-ArmPlatformInitializeSystemMemory (
-  VOID
-  )
-{
-  //TODO: Implement me
-}
-
-EFI_STATUS
-PrePeiCoreGetMpCoreInfo (
-  OUT UINTN                   *CoreCount,
-  OUT ARM_CORE_INFO           **ArmCoreTable
-  )
-{
-  if (ArmIsMpCore()) {
-    *CoreCount    = sizeof(mArmPlatformNullMpCoreInfoTable) / sizeof(ARM_CORE_INFO);
-    *ArmCoreTable = mArmPlatformNullMpCoreInfoTable;
-    return EFI_SUCCESS;
-  } else {
-    return EFI_UNSUPPORTED;
-  }
-}
-
-// Needs to be declared in the file. Otherwise gArmMpCoreInfoPpiGuid is undefined in the contect of PrePeiCore
-EFI_GUID mArmMpCoreInfoPpiGuid = ARM_MP_CORE_INFO_PPI_GUID;
-ARM_MP_CORE_INFO_PPI mMpCoreInfoPpi = { PrePeiCoreGetMpCoreInfo };
-
-EFI_PEI_PPI_DESCRIPTOR      gPlatformPpiTable[] = {
-  {
-    EFI_PEI_PPI_DESCRIPTOR_PPI,
-    &mArmMpCoreInfoPpiGuid,
-    &mMpCoreInfoPpi
-  }
-};
-
-VOID
-ArmPlatformGetPlatformPpiList (
-  OUT UINTN                   *PpiListSize,
-  OUT EFI_PEI_PPI_DESCRIPTOR  **PpiList
-  )
-{
-  if (ArmIsMpCore()) {
-    *PpiListSize = sizeof(gPlatformPpiTable);
-    *PpiList = gPlatformPpiTable;
-  } else {
-    *PpiListSize = 0;
-    *PpiList = NULL;
-  }
-}
-
+/** @file

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+#include <Library/ArmLib.h>

+#include <Library/ArmPlatformLib.h>

+

+#include <Ppi/ArmMpCoreInfo.h>

+

+

+ARM_CORE_INFO mArmPlatformNullMpCoreInfoTable[] = {

+  {

+    // Cluster 0, Core 0

+    0x0, 0x0,

+

+    // MP Core MailBox Set/Get/Clear Addresses and Clear Value

+    (EFI_PHYSICAL_ADDRESS)0,

+    (EFI_PHYSICAL_ADDRESS)0,

+    (EFI_PHYSICAL_ADDRESS)0,

+    (UINT64)0xFFFFFFFF

+  },

+  {

+    // Cluster 0, Core 1

+    0x0, 0x1,

+

+    // MP Core MailBox Set/Get/Clear Addresses and Clear Value

+    (EFI_PHYSICAL_ADDRESS)0,

+    (EFI_PHYSICAL_ADDRESS)0,

+    (EFI_PHYSICAL_ADDRESS)0,

+    (UINT64)0xFFFFFFFF

+  },

+  {

+    // Cluster 0, Core 2

+    0x0, 0x2,

+

+    // MP Core MailBox Set/Get/Clear Addresses and Clear Value

+    (EFI_PHYSICAL_ADDRESS)0,

+    (EFI_PHYSICAL_ADDRESS)0,

+    (EFI_PHYSICAL_ADDRESS)0,

+    (UINT64)0xFFFFFFFF

+  },

+  {

+    // Cluster 0, Core 3

+    0x0, 0x3,

+

+    // MP Core MailBox Set/Get/Clear Addresses and Clear Value

+    (EFI_PHYSICAL_ADDRESS)0,

+    (EFI_PHYSICAL_ADDRESS)0,

+    (EFI_PHYSICAL_ADDRESS)0,

+    (UINT64)0xFFFFFFFF

+  }

+};

+

+// This function should be better located into TimerLib implementation

+RETURN_STATUS

+EFIAPI

+TimerConstructor (

+  VOID

+  )

+{

+  return EFI_SUCCESS;

+}

+

+/**

+  Return the current Boot Mode

+

+  This function returns the boot reason on the platform

+

+**/

+EFI_BOOT_MODE

+ArmPlatformGetBootMode (

+  VOID

+  )

+{

+  return BOOT_WITH_FULL_CONFIGURATION;

+}

+

+/**

+  Initialize controllers that must setup in the normal world

+

+  This function is called by the ArmPlatformPkg/PrePi or ArmPlatformPkg/PlatformPei

+  in the PEI phase.

+

+**/

+RETURN_STATUS

+ArmPlatformInitialize (

+  IN  UINTN                     MpId

+  )

+{

+  if (!IS_PRIMARY_CORE(MpId)) {

+    return RETURN_SUCCESS;

+  }

+

+  //TODO: Implement me

+

+  return RETURN_SUCCESS;

+}

+

+/**

+  Initialize the system (or sometimes called permanent) memory

+

+  This memory is generally represented by the DRAM.

+

+**/

+VOID

+ArmPlatformInitializeSystemMemory (

+  VOID

+  )

+{

+  //TODO: Implement me

+}

+

+EFI_STATUS

+PrePeiCoreGetMpCoreInfo (

+  OUT UINTN                   *CoreCount,

+  OUT ARM_CORE_INFO           **ArmCoreTable

+  )

+{

+  if (ArmIsMpCore()) {

+    *CoreCount    = sizeof(mArmPlatformNullMpCoreInfoTable) / sizeof(ARM_CORE_INFO);

+    *ArmCoreTable = mArmPlatformNullMpCoreInfoTable;

+    return EFI_SUCCESS;

+  } else {

+    return EFI_UNSUPPORTED;

+  }

+}

+

+// Needs to be declared in the file. Otherwise gArmMpCoreInfoPpiGuid is undefined in the contect of PrePeiCore

+EFI_GUID mArmMpCoreInfoPpiGuid = ARM_MP_CORE_INFO_PPI_GUID;

+ARM_MP_CORE_INFO_PPI mMpCoreInfoPpi = { PrePeiCoreGetMpCoreInfo };

+

+EFI_PEI_PPI_DESCRIPTOR      gPlatformPpiTable[] = {

+  {

+    EFI_PEI_PPI_DESCRIPTOR_PPI,

+    &mArmMpCoreInfoPpiGuid,

+    &mMpCoreInfoPpi

+  }

+};

+

+VOID

+ArmPlatformGetPlatformPpiList (

+  OUT UINTN                   *PpiListSize,

+  OUT EFI_PEI_PPI_DESCRIPTOR  **PpiList

+  )

+{

+  if (ArmIsMpCore()) {

+    *PpiListSize = sizeof(gPlatformPpiTable);

+    *PpiList = gPlatformPpiTable;

+  } else {

+    *PpiListSize = 0;

+    *PpiList = NULL;

+  }

+}

+

diff --git a/ArmPlatformPkg/Library/ArmPlatformLibNull/ArmPlatformLibNull.inf b/ArmPlatformPkg/Library/ArmPlatformLibNull/ArmPlatformLibNull.inf
index 13c62a60..a6c2e8f4 100644
--- a/ArmPlatformPkg/Library/ArmPlatformLibNull/ArmPlatformLibNull.inf
+++ b/ArmPlatformPkg/Library/ArmPlatformLibNull/ArmPlatformLibNull.inf
@@ -33,6 +33,10 @@
   ArmPlatformLibNull.c

   ArmPlatformLibNullMem.c

 

+[Sources.Arm]

+  Arm/ArmPlatformHelper.S    | GCC

+  Arm/ArmPlatformHelper.asm  | RVCT

+

 [FixedPcd]

   gArmTokenSpaceGuid.PcdSystemMemoryBase

   gArmTokenSpaceGuid.PcdSystemMemorySize

diff --git a/ArmPlatformPkg/Library/ArmPlatformLibNull/ArmPlatformLibNullSec.inf b/ArmPlatformPkg/Library/ArmPlatformLibNull/ArmPlatformLibNullSec.inf
new file mode 100644
index 00000000..128b0b59
--- /dev/null
+++ b/ArmPlatformPkg/Library/ArmPlatformLibNull/ArmPlatformLibNullSec.inf
@@ -0,0 +1,44 @@
+#/* @file

+#  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+#  

+#  This program and the accompanying materials                          

+#  are licensed and made available under the terms and conditions of the BSD License         

+#  which accompanies this distribution.  The full text of the license may be found at        

+#  http://opensource.org/licenses/bsd-license.php                                            

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+#

+#*/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = ArmPlatformLibNull

+  FILE_GUID                      = cb494bad-23ff-427e-8608-d7e138d3363b

+  MODULE_TYPE                    = BASE

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = ArmPlatformLib

+

+[Packages]

+  MdePkg/MdePkg.dec

+  MdeModulePkg/MdeModulePkg.dec

+  ArmPkg/ArmPkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+

+[LibraryClasses]

+  ArmLib

+  DebugLib

+

+[Sources.common]

+  ArmPlatformLibNull.c

+

+[Sources.Arm]

+  Arm/ArmPlatformHelper.S    | GCC

+  Arm/ArmPlatformHelper.asm  | RVCT

+

+[FixedPcd]

+  gArmTokenSpaceGuid.PcdSystemMemoryBase

+  gArmTokenSpaceGuid.PcdSystemMemorySize

+

+  gArmTokenSpaceGuid.PcdArmPrimaryCoreMask

+  gArmTokenSpaceGuid.PcdArmPrimaryCore

diff --git a/ArmPlatformPkg/Library/ArmPlatformSecLibNull/ArmPlatformLibNullBoot.S b/ArmPlatformPkg/Library/ArmPlatformSecLibNull/Arm/ArmPlatformLibNullBoot.S
index a00fac4f..a00fac4f 100644
--- a/ArmPlatformPkg/Library/ArmPlatformSecLibNull/ArmPlatformLibNullBoot.S
+++ b/ArmPlatformPkg/Library/ArmPlatformSecLibNull/Arm/ArmPlatformLibNullBoot.S
diff --git a/ArmPlatformPkg/Library/ArmPlatformSecLibNull/ArmPlatformLibNullBoot.asm b/ArmPlatformPkg/Library/ArmPlatformSecLibNull/Arm/ArmPlatformLibNullBoot.asm
index ead08687..ead08687 100644
--- a/ArmPlatformPkg/Library/ArmPlatformSecLibNull/ArmPlatformLibNullBoot.asm
+++ b/ArmPlatformPkg/Library/ArmPlatformSecLibNull/Arm/ArmPlatformLibNullBoot.asm
diff --git a/ArmPlatformPkg/Library/ArmPlatformSecLibNull/ArmPlatformLibNullSec.c b/ArmPlatformPkg/Library/ArmPlatformSecLibNull/ArmPlatformLibNullSec.c
index c548d8b3..1a838820 100644
--- a/ArmPlatformPkg/Library/ArmPlatformSecLibNull/ArmPlatformLibNullSec.c
+++ b/ArmPlatformPkg/Library/ArmPlatformSecLibNull/ArmPlatformLibNullSec.c
@@ -1,74 +1,74 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-#include <Library/ArmPlatformLib.h>
-#include <Library/DebugLib.h>
-#include <Library/PcdLib.h>
-
-/**
-  Initialize the Secure peripherals and memory regions
-
-  If Trustzone is supported by your platform then this function makes the required initialization
-  of the secure peripherals and memory regions.
-
-**/
-VOID
-ArmPlatformSecTrustzoneInit (
-  IN  UINTN                     MpId
-  )
-{
-  // Secondary cores might have to set the Secure SGIs into the GICD_IGROUPR0
-  if (!IS_PRIMARY_CORE(MpId)) {
-    return;
-  }
-
-  ASSERT(FALSE);
-}
-
-/**
-  Initialize controllers that must setup at the early stage
-
-  Some peripherals must be initialized in Secure World.
-  For example, some L2x0 requires to be initialized in Secure World
-
-**/
-RETURN_STATUS
-ArmPlatformSecInitialize (
-  IN  UINTN                     MpId
-  )
-{
-  // If it is not the primary core then there is nothing to do
-  if (!IS_PRIMARY_CORE(MpId)) {
-    return RETURN_SUCCESS;
-  }
-
-  // Do nothing yet
-  return RETURN_SUCCESS;
-}
-
-/**
-  Call before jumping to Normal World
-
-  This function allows the firmware platform to do extra actions before
-  jumping to the Normal World
-
-**/
-VOID
-ArmPlatformSecExtraAction (
-  IN  UINTN         MpId,
-  OUT UINTN*        JumpAddress
-  )
-{
-  *JumpAddress = PcdGet32(PcdFvBaseAddress);
-}
+/** @file

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+#include <Library/ArmPlatformLib.h>

+#include <Library/DebugLib.h>

+#include <Library/PcdLib.h>

+

+/**

+  Initialize the Secure peripherals and memory regions

+

+  If Trustzone is supported by your platform then this function makes the required initialization

+  of the secure peripherals and memory regions.

+

+**/

+VOID

+ArmPlatformSecTrustzoneInit (

+  IN  UINTN                     MpId

+  )

+{

+  // Secondary cores might have to set the Secure SGIs into the GICD_IGROUPR0

+  if (!IS_PRIMARY_CORE(MpId)) {

+    return;

+  }

+

+  ASSERT(FALSE);

+}

+

+/**

+  Initialize controllers that must setup at the early stage

+

+  Some peripherals must be initialized in Secure World.

+  For example, some L2x0 requires to be initialized in Secure World

+

+**/

+RETURN_STATUS

+ArmPlatformSecInitialize (

+  IN  UINTN                     MpId

+  )

+{

+  // If it is not the primary core then there is nothing to do

+  if (!IS_PRIMARY_CORE(MpId)) {

+    return RETURN_SUCCESS;

+  }

+

+  // Do nothing yet

+  return RETURN_SUCCESS;

+}

+

+/**

+  Call before jumping to Normal World

+

+  This function allows the firmware platform to do extra actions before

+  jumping to the Normal World

+

+**/

+VOID

+ArmPlatformSecExtraAction (

+  IN  UINTN         MpId,

+  OUT UINTN*        JumpAddress

+  )

+{

+  *JumpAddress = PcdGet32(PcdFvBaseAddress);

+}

diff --git a/ArmPlatformPkg/Library/ArmPlatformSecLibNull/ArmPlatformLibNullSec.inf b/ArmPlatformPkg/Library/ArmPlatformSecLibNull/ArmPlatformLibNullSec.inf
index ba55ed51..f3995475 100644
--- a/ArmPlatformPkg/Library/ArmPlatformSecLibNull/ArmPlatformLibNullSec.inf
+++ b/ArmPlatformPkg/Library/ArmPlatformSecLibNull/ArmPlatformLibNullSec.inf
@@ -33,8 +33,8 @@
   ArmPlatformLibNullSec.c

 

 [Sources.ARM]

-  ArmPlatformLibNullBoot.asm     | RVCT

-  ArmPlatformLibNullBoot.S       | GCC

+  Arm/ArmPlatformLibNullBoot.asm     | RVCT

+  Arm/ArmPlatformLibNullBoot.S       | GCC

 

 [FixedPcd]

   gArmTokenSpaceGuid.PcdFvBaseAddress

diff --git a/ArmPlatformPkg/Library/ArmPlatformStackLib/ArmPlatformStackLib.S b/ArmPlatformPkg/Library/ArmPlatformStackLib/Arm/ArmPlatformStackLib.S
index 94660c97..94660c97 100644
--- a/ArmPlatformPkg/Library/ArmPlatformStackLib/ArmPlatformStackLib.S
+++ b/ArmPlatformPkg/Library/ArmPlatformStackLib/Arm/ArmPlatformStackLib.S
diff --git a/ArmPlatformPkg/Library/ArmPlatformStackLib/ArmPlatformStackLib.asm b/ArmPlatformPkg/Library/ArmPlatformStackLib/Arm/ArmPlatformStackLib.asm
index db920239..db920239 100644
--- a/ArmPlatformPkg/Library/ArmPlatformStackLib/ArmPlatformStackLib.asm
+++ b/ArmPlatformPkg/Library/ArmPlatformStackLib/Arm/ArmPlatformStackLib.asm
diff --git a/ArmPlatformPkg/Library/ArmPlatformStackLib/ArmPlatformStackLib.inf b/ArmPlatformPkg/Library/ArmPlatformStackLib/ArmPlatformStackLib.inf
index a41dae2b..e48a6580 100644
--- a/ArmPlatformPkg/Library/ArmPlatformStackLib/ArmPlatformStackLib.inf
+++ b/ArmPlatformPkg/Library/ArmPlatformStackLib/ArmPlatformStackLib.inf
@@ -26,9 +26,9 @@
   ArmPkg/ArmPkg.dec

   ArmPlatformPkg/ArmPlatformPkg.dec

 

-[Sources.common]

-  ArmPlatformStackLib.asm     | RVCT

-  ArmPlatformStackLib.S       | GCC

+[Sources.ARM]

+  Arm/ArmPlatformStackLib.asm     | RVCT

+  Arm/ArmPlatformStackLib.S       | GCC

 

 [FixedPcd]

   gArmPlatformTokenSpaceGuid.PcdCoreCount

diff --git a/ArmPlatformPkg/Library/ArmTrustedMonitorLibNull/ArmTrustedMonitorLibNull.c b/ArmPlatformPkg/Library/ArmTrustedMonitorLibNull/ArmTrustedMonitorLibNull.c
index 6d3250e3..1f950d78 100644
--- a/ArmPlatformPkg/Library/ArmTrustedMonitorLibNull/ArmTrustedMonitorLibNull.c
+++ b/ArmPlatformPkg/Library/ArmTrustedMonitorLibNull/ArmTrustedMonitorLibNull.c
@@ -1,7 +1,7 @@
 /** @file

 *  Main file supporting the Monitor World on ARM PLatforms

 *

-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

 *

 *  This program and the accompanying materials

 *  are licensed and made available under the terms and conditions of the BSD License

@@ -30,8 +30,9 @@ ArmSecureMonitorWorldInitialize (
   )

 {

   // Ensure the Monitor Table is 32bit aligned

-  ASSERT (IS_ALIGNED(MonitorVectorTable, BIT5));

+  ASSERT (((UINTN)&MonitorVectorTable & ARM_VECTOR_TABLE_ALIGNMENT) == 0);

 

   // Write the Monitor Mode Vector Table Address

-  ArmWriteMVBar ((UINT32) &MonitorVectorTable);

+  ArmWriteMVBar ((UINTN) &MonitorVectorTable);

 }

+

diff --git a/ArmPlatformPkg/Library/DebugSecExtraActionLib/DebugSecExtraActionLib.inf b/ArmPlatformPkg/Library/DebugSecExtraActionLib/DebugSecExtraActionLib.inf
index 2962ffe5..26afb34b 100755
--- a/ArmPlatformPkg/Library/DebugSecExtraActionLib/DebugSecExtraActionLib.inf
+++ b/ArmPlatformPkg/Library/DebugSecExtraActionLib/DebugSecExtraActionLib.inf
@@ -1,55 +1,55 @@
-#/* @file
-#  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-#  
-#  This program and the accompanying materials                          
-#  are licensed and made available under the terms and conditions of the BSD License         
-#  which accompanies this distribution.  The full text of the license may be found at        
-#  http://opensource.org/licenses/bsd-license.php                                            
-#
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-#
-#*/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = DebugSecExtraActionLib
-  FILE_GUID                      = 8fff7a60-a6f8-11e0-990a-0002a5d5c51b
-  MODULE_TYPE                    = BASE
-  VERSION_STRING                 = 1.0
-  LIBRARY_CLASS                  = ArmPlatformSecExtraActionLib
-
-#
-# The following information is for reference only and not required by the build tools.
-#
-#  VALID_ARCHITECTURES           = ARM
-#
-
-[Sources.common]
-  DebugSecExtraActionLib.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  ArmPkg/ArmPkg.dec
-  ArmPlatformPkg/ArmPlatformPkg.dec
-
-[LibraryClasses]
-  DebugLib
-  PcdLib
-  ArmGicLib
-  PrintLib
-  SerialPortLib
-
-[FeaturePcd]
-  gArmPlatformTokenSpaceGuid.PcdStandalone
-  gArmPlatformTokenSpaceGuid.PcdSystemMemoryInitializeInSec
-
-[FixedPcd]
-  gArmTokenSpaceGuid.PcdFvBaseAddress
-  
-  gArmTokenSpaceGuid.PcdArmPrimaryCoreMask
-  gArmTokenSpaceGuid.PcdArmPrimaryCore
-
-  gArmTokenSpaceGuid.PcdGicDistributorBase
-  gArmTokenSpaceGuid.PcdGicInterruptInterfaceBase
-  gArmTokenSpaceGuid.PcdGicSgiIntId
+#/* @file

+#  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+#  

+#  This program and the accompanying materials                          

+#  are licensed and made available under the terms and conditions of the BSD License         

+#  which accompanies this distribution.  The full text of the license may be found at        

+#  http://opensource.org/licenses/bsd-license.php                                            

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+#

+#*/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = DebugSecExtraActionLib

+  FILE_GUID                      = 8fff7a60-a6f8-11e0-990a-0002a5d5c51b

+  MODULE_TYPE                    = BASE

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = ArmPlatformSecExtraActionLib

+

+#

+# The following information is for reference only and not required by the build tools.

+#

+#  VALID_ARCHITECTURES           = ARM

+#

+

+[Sources.common]

+  DebugSecExtraActionLib.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  ArmPkg/ArmPkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+

+[LibraryClasses]

+  DebugLib

+  PcdLib

+  ArmGicLib

+  PrintLib

+  SerialPortLib

+

+[FeaturePcd]

+  gArmPlatformTokenSpaceGuid.PcdStandalone

+  gArmPlatformTokenSpaceGuid.PcdSystemMemoryInitializeInSec

+

+[FixedPcd]

+  gArmTokenSpaceGuid.PcdFvBaseAddress

+  

+  gArmTokenSpaceGuid.PcdArmPrimaryCoreMask

+  gArmTokenSpaceGuid.PcdArmPrimaryCore

+

+  gArmTokenSpaceGuid.PcdGicDistributorBase

+  gArmTokenSpaceGuid.PcdGicInterruptInterfaceBase

+  gArmTokenSpaceGuid.PcdGicSgiIntId

diff --git a/ArmPlatformPkg/Library/EblCmdLib/EblCmdMmu.c b/ArmPlatformPkg/Library/EblCmdLib/Arm/EblCmdMmu.c
index 138216e9..138216e9 100644
--- a/ArmPlatformPkg/Library/EblCmdLib/EblCmdMmu.c
+++ b/ArmPlatformPkg/Library/EblCmdLib/Arm/EblCmdMmu.c
diff --git a/ArmPlatformPkg/Library/EblCmdLib/EblCmdFdt.c b/ArmPlatformPkg/Library/EblCmdLib/EblCmdFdt.c
index 5da71cff..dcd7c410 100644
--- a/ArmPlatformPkg/Library/EblCmdLib/EblCmdFdt.c
+++ b/ArmPlatformPkg/Library/EblCmdLib/EblCmdFdt.c
@@ -1,14 +1,14 @@
 /** @file

 *

-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

-*  

-*  This program and the accompanying materials                          

-*  are licensed and made available under the terms and conditions of the BSD License         

-*  which accompanies this distribution.  The full text of the license may be found at        

-*  http://opensource.org/licenses/bsd-license.php                                            

+*  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

 *

-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*  This program and the accompanying materials

+*  are licensed and made available under the terms and conditions of the BSD License

+*  which accompanies this distribution.  The full text of the license may be found at

+*  http://opensource.org/licenses/bsd-license.php

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

 *

 **/

 

@@ -26,7 +26,7 @@
 

 #include <Protocol/DevicePathFromText.h>

 

-#include <Guid/GlobalVariable.h>

+#include <Guid/ArmGlobalVariableHob.h>

 

 #include <libfdt.h>

 

@@ -187,7 +187,7 @@ EblDumpFdt (
 

   // If no FDT file is passed to the argument then get the one from the platform

   if (Argc < 2) {

-    Status = GetEnvironmentVariable (L"Fdt",NULL,NULL,(VOID**)&FdtDevicePath);

+    Status = GetEnvironmentVariable (L"Fdt", &gArmGlobalVariableGuid, NULL, NULL, (VOID**)&FdtDevicePath);

     if (Status == EFI_NOT_FOUND) {

       // No set yet, get the Default Device Path

       Status = gBS->LocateProtocol (&gEfiDevicePathFromTextProtocolGuid, NULL, (VOID **)&EfiDevicePathFromTextProtocol);

diff --git a/ArmPlatformPkg/Library/EblCmdLib/EblCmdLib.c b/ArmPlatformPkg/Library/EblCmdLib/EblCmdLib.c
index 8f7ea65e..b45e85d9 100644
--- a/ArmPlatformPkg/Library/EblCmdLib/EblCmdLib.c
+++ b/ArmPlatformPkg/Library/EblCmdLib/EblCmdLib.c
@@ -1,6 +1,6 @@
 /** @file

 *

-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

 *  

 *  This program and the accompanying materials                          

 *  are licensed and made available under the terms and conditions of the BSD License         

@@ -101,7 +101,7 @@ EblSymbolTable (
   for (Entry = 0; Entry < DebugImageTableHeader->TableSize; Entry++, DebugTable++) {

     if (DebugTable->NormalImage != NULL) {

       if ((DebugTable->NormalImage->ImageInfoType == EFI_DEBUG_IMAGE_INFO_TYPE_NORMAL) && (DebugTable->NormalImage->LoadedImageProtocolInstance != NULL)) {

-        ImageBase = (UINT32)DebugTable->NormalImage->LoadedImageProtocolInstance->ImageBase;

+        ImageBase = (UINTN)DebugTable->NormalImage->LoadedImageProtocolInstance->ImageBase;

         PeCoffSizeOfHeaders = PeCoffGetSizeOfHeaders ((VOID *)(UINTN)ImageBase);

         Pdb = PeCoffLoaderGetPdbPointer (DebugTable->NormalImage->LoadedImageProtocolInstance->ImageBase);

         if (Pdb != NULL) {

@@ -389,7 +389,7 @@ EblDevicePaths (
   for (Index = 0; Index < HandleCount; Index++) {

     Status = gBS->HandleProtocol (HandleBuffer[Index], &gEfiDevicePathProtocolGuid, (VOID **)&DevicePathProtocol);

     String = DevicePathToTextProtocol->ConvertDevicePathToText(DevicePathProtocol,TRUE,TRUE);

-    Print (L"[0x%X] %s\n",(UINT32)HandleBuffer[Index], String);

+    Print (L"[0x%X] %s\n",(UINTN)HandleBuffer[Index], String);

   }

 

   return EFI_SUCCESS;

diff --git a/ArmPlatformPkg/Library/EblCmdLib/EblCmdLib.inf b/ArmPlatformPkg/Library/EblCmdLib/EblCmdLib.inf
index 9ddc9e82..33508c26 100644
--- a/ArmPlatformPkg/Library/EblCmdLib/EblCmdLib.inf
+++ b/ArmPlatformPkg/Library/EblCmdLib/EblCmdLib.inf
@@ -29,9 +29,11 @@
 

 [Sources.common]

   EblCmdLib.c

-  EblCmdMmu.c

   EblCmdFdt.c

 

+[Sources.ARM]

+  Arm/EblCmdMmu.c

+

 [Packages]

   MdePkg/MdePkg.dec

   MdeModulePkg/MdeModulePkg.dec

diff --git a/ArmPlatformPkg/Library/PL011SerialPortLib/PL011SerialPortExtLib.c b/ArmPlatformPkg/Library/PL011SerialPortLib/PL011SerialPortExtLib.c
new file mode 100644
index 00000000..9bfe42e6
--- /dev/null
+++ b/ArmPlatformPkg/Library/PL011SerialPortLib/PL011SerialPortExtLib.c
@@ -0,0 +1,103 @@
+/** @file

+  Serial I/O Port library functions with no library constructor/destructor

+

+  Copyright (c) 2012, ARM Ltd. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include <Base.h>

+

+#include <Library/IoLib.h>

+#include <Library/PcdLib.h>

+#include <Library/SerialPortExtLib.h>

+

+#include <Drivers/PL011Uart.h>

+

+/**

+  Set new attributes to PL011.

+

+  @param  BaudRate                The baud rate of the serial device. If the baud rate is not supported,

+                                  the speed will be reduced down to the nearest supported one and the

+                                  variable's value will be updated accordingly.

+  @param  ReceiveFifoDepth        The number of characters the device will buffer on input. If the specified

+                                  value is not supported, the variable's value will be reduced down to the

+                                  nearest supported one.

+  @param  Timeout                 If applicable, the number of microseconds the device will wait

+                                  before timing out a Read or a Write operation.

+  @param  Parity                  If applicable, this is the EFI_PARITY_TYPE that is computed or checked

+                                  as each character is transmitted or received. If the device does not

+                                  support parity, the value is the default parity value.

+  @param  DataBits                The number of data bits in each character

+  @param  StopBits                If applicable, the EFI_STOP_BITS_TYPE number of stop bits per character.

+                                  If the device does not support stop bits, the value is the default stop

+                                  bit value.

+

+  @retval EFI_SUCCESS             All attributes were set correctly on the serial device.

+  @retval EFI_INVALID_PARAMETERS  One or more of the attributes has an unsupported value.

+

+**/

+RETURN_STATUS

+EFIAPI

+SerialPortSetAttributes (

+  IN UINT64              BaudRate,

+  IN UINT32              ReceiveFifoDepth,

+  IN UINT32              Timeout,

+  IN EFI_PARITY_TYPE     Parity,

+  IN UINT8               DataBits,

+  IN EFI_STOP_BITS_TYPE  StopBits

+  )

+{

+  return PL011UartInitializePort (

+        (UINTN)PcdGet64 (PcdSerialRegisterBase),

+        BaudRate,

+        ReceiveFifoDepth,

+        Parity,

+        DataBits,

+        StopBits);

+}

+

+/**

+  Set the serial device control bits.

+

+  @param  Control                 Control bits which are to be set on the serial device.

+

+  @retval EFI_SUCCESS             The new control bits were set on the serial device.

+  @retval EFI_UNSUPPORTED         The serial device does not support this operation.

+  @retval EFI_DEVICE_ERROR        The serial device is not functioning correctly.

+

+**/

+RETURN_STATUS

+EFIAPI

+SerialPortSetControl (

+  IN UINT32                  Control

+  )

+{

+  return PL011UartSetControl ((UINTN)PcdGet64 (PcdSerialRegisterBase), Control);

+}

+

+/**

+  Get the serial device control bits.

+

+  @param  Control                 Control signals read from the serial device.

+

+  @retval EFI_SUCCESS             The control bits were read from the serial device.

+  @retval EFI_DEVICE_ERROR        The serial device is not functioning correctly.

+

+**/

+RETURN_STATUS

+EFIAPI

+SerialPortGetControl (

+  OUT UINT32                  *Control

+  )

+{

+  return PL011UartGetControl ((UINTN)PcdGet64 (PcdSerialRegisterBase), Control);

+}

+

diff --git a/ArmPlatformPkg/Library/PL011SerialPortLib/PL011SerialPortExtLib.inf b/ArmPlatformPkg/Library/PL011SerialPortLib/PL011SerialPortExtLib.inf
new file mode 100644
index 00000000..89c8c9c1
--- /dev/null
+++ b/ArmPlatformPkg/Library/PL011SerialPortLib/PL011SerialPortExtLib.inf
@@ -0,0 +1,43 @@
+#/** @file

+#  

+#  Component description file for PL011SerialPortLib module

+#  

+#  Copyright (c) 2011-2012, ARM Ltd. All rights reserved.<BR>

+#  

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = PL011SerialPortExtLib

+  FILE_GUID                      = 2be281f1-c506-4558-bd98-d6930e6de9d6

+  MODULE_TYPE                    = BASE

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = SerialPortExtLib

+

+[Sources.common]

+  PL011SerialPortExtLib.c

+

+[LibraryClasses]

+  PL011UartLib

+  PcdLib

+

+[Packages]

+  EmbeddedPkg/EmbeddedPkg.dec

+  MdePkg/MdePkg.dec

+  MdeModulePkg/MdeModulePkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+

+[Pcd]

+  gEfiMdeModulePkgTokenSpaceGuid.PcdSerialRegisterBase

+  gEfiMdePkgTokenSpaceGuid.PcdUartDefaultBaudRate

+  gEfiMdePkgTokenSpaceGuid.PcdUartDefaultDataBits

+  gEfiMdePkgTokenSpaceGuid.PcdUartDefaultParity

+  gEfiMdePkgTokenSpaceGuid.PcdUartDefaultStopBits

diff --git a/ArmPlatformPkg/Library/PL011SerialPortLib/PL011SerialPortLib.c b/ArmPlatformPkg/Library/PL011SerialPortLib/PL011SerialPortLib.c
index 7ccd09bd..09033dbd 100644
--- a/ArmPlatformPkg/Library/PL011SerialPortLib/PL011SerialPortLib.c
+++ b/ArmPlatformPkg/Library/PL011SerialPortLib/PL011SerialPortLib.c
@@ -1,184 +1,105 @@
-/** @file
-  Serial I/O Port library functions with no library constructor/destructor
-
-  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-  Copyright (c) 2012, ARM Ltd. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include <Base.h>
-
-#include <Library/IoLib.h>
-#include <Library/PcdLib.h>
-#include <Library/SerialPortLib.h>
-#include <Library/SerialPortExtLib.h>
-
-#include <Drivers/PL011Uart.h>
-
-
-/**
-
-  Programmed hardware of Serial port.
-
-  @return    Always return RETURN_UNSUPPORTED.
-
-**/
-RETURN_STATUS
-EFIAPI
-SerialPortInitialize (
-  VOID
-  )
-{
-  return PL011UartInitializePort (
-      (UINTN)PcdGet64 (PcdSerialRegisterBase),
-      (UINTN)PcdGet64 (PcdUartDefaultBaudRate),
-      0, // Use the default value for Fifo depth
-      (EFI_PARITY_TYPE)PcdGet8 (PcdUartDefaultParity),
-      PcdGet8 (PcdUartDefaultDataBits),
-      (EFI_STOP_BITS_TYPE) PcdGet8 (PcdUartDefaultStopBits));
-}
-
-/**
-  Write data to serial device.
-
-  @param  Buffer           Point of data buffer which need to be written.
-  @param  NumberOfBytes    Number of output bytes which are cached in Buffer.
-
-  @retval 0                Write data failed.
-  @retval !0               Actual number of bytes written to serial device.
-
-**/
-UINTN
-EFIAPI
-SerialPortWrite (
-  IN UINT8     *Buffer,
-  IN UINTN     NumberOfBytes
-  )
-{
-  return PL011UartWrite ((UINTN)PcdGet64 (PcdSerialRegisterBase), Buffer, NumberOfBytes);
-}
-
-/**
-  Read data from serial device and save the data in buffer.
-
-  @param  Buffer           Point of data buffer which need to be written.
-  @param  NumberOfBytes    Number of output bytes which are cached in Buffer.
-
-  @retval 0                Read data failed.
-  @retval !0               Actual number of bytes read from serial device.
-
-**/
-UINTN
-EFIAPI
-SerialPortRead (
-  OUT UINT8     *Buffer,
-  IN  UINTN     NumberOfBytes
-)
-{
-  return PL011UartRead ((UINTN)PcdGet64 (PcdSerialRegisterBase), Buffer, NumberOfBytes);
-}
-
-/**
-  Check to see if any data is available to be read from the debug device.
-
-  @retval EFI_SUCCESS       At least one byte of data is available to be read
-  @retval EFI_NOT_READY     No data is available to be read
-  @retval EFI_DEVICE_ERROR  The serial device is not functioning properly
-
-**/
-BOOLEAN
-EFIAPI
-SerialPortPoll (
-  VOID
-  )
-{
-  return PL011UartPoll ((UINTN)PcdGet64 (PcdSerialRegisterBase));
-}
-
-/**
-  Set new attributes to PL011.
-
-  @param  BaudRate                The baud rate of the serial device. If the baud rate is not supported,
-                                  the speed will be reduced down to the nearest supported one and the
-                                  variable's value will be updated accordingly.
-  @param  ReceiveFifoDepth        The number of characters the device will buffer on input. If the specified
-                                  value is not supported, the variable's value will be reduced down to the
-                                  nearest supported one.
-  @param  Timeout                 If applicable, the number of microseconds the device will wait
-                                  before timing out a Read or a Write operation.
-  @param  Parity                  If applicable, this is the EFI_PARITY_TYPE that is computer or checked
-                                  as each character is transmitted or received. If the device does not
-                                  support parity, the value is the default parity value.
-  @param  DataBits                The number of data bits in each character
-  @param  StopBits                If applicable, the EFI_STOP_BITS_TYPE number of stop bits per character.
-                                  If the device does not support stop bits, the value is the default stop
-                                  bit value.
-
-  @retval EFI_SUCCESS             All attributes were set correctly on the serial device.
-  @retval EFI_INVALID_PARAMETERS  One or more of the attributes has an unsupported value.
-
-**/
-RETURN_STATUS
-EFIAPI
-SerialPortSetAttributes (
-  IN UINT64              BaudRate,
-  IN UINT32              ReceiveFifoDepth,
-  IN UINT32              Timeout,
-  IN EFI_PARITY_TYPE     Parity,
-  IN UINT8               DataBits,
-  IN EFI_STOP_BITS_TYPE  StopBits
-  )
-{
-  return PL011UartInitializePort (
-        (UINTN)PcdGet64 (PcdSerialRegisterBase),
-        BaudRate,
-        ReceiveFifoDepth,
-        Parity,
-        DataBits,
-        StopBits);
-}
-
-/**
-  Set the serial device control bits.
-
-  @param  Control                 Control bits which are to be set on the serial device.
-
-  @retval EFI_SUCCESS             The new control bits were set on the serial device.
-  @retval EFI_UNSUPPORTED         The serial device does not support this operation.
-  @retval EFI_DEVICE_ERROR        The serial device is not functioning correctly.
-
-**/
-RETURN_STATUS
-EFIAPI
-SerialPortSetControl (
-  IN UINT32                  Control
-  )
-{
-  return PL011UartSetControl((UINTN)PcdGet64 (PcdSerialRegisterBase), Control);
-}
-
-/**
-  Get the serial device control bits.
-
-  @param  Control                 Control signals read from the serial device.
-
-  @retval EFI_SUCCESS             The control bits were read from the serial device.
-  @retval EFI_DEVICE_ERROR        The serial device is not functioning correctly.
-
-**/
-RETURN_STATUS
-EFIAPI
-SerialPortGetControl (
-  OUT UINT32                  *Control
-  )
-{
-  return PL011UartGetControl((UINTN)PcdGet64 (PcdSerialRegisterBase), Control);
-}
+/** @file

+  Serial I/O Port library functions with no library constructor/destructor

+

+  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+  Copyright (c) 2012, ARM Ltd. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include <Base.h>

+

+#include <Library/IoLib.h>

+#include <Library/PcdLib.h>

+#include <Library/SerialPortLib.h>

+#include <Library/SerialPortExtLib.h>

+

+#include <Drivers/PL011Uart.h>

+

+

+/**

+

+  Programmed hardware of Serial port.

+

+  @return    Always return RETURN_UNSUPPORTED.

+

+**/

+RETURN_STATUS

+EFIAPI

+SerialPortInitialize (

+  VOID

+  )

+{

+  return PL011UartInitializePort (

+      (UINTN)PcdGet64 (PcdSerialRegisterBase),

+      (UINTN)PcdGet64 (PcdUartDefaultBaudRate),

+      0, // Use the default value for Fifo depth

+      (EFI_PARITY_TYPE)PcdGet8 (PcdUartDefaultParity),

+      PcdGet8 (PcdUartDefaultDataBits),

+      (EFI_STOP_BITS_TYPE) PcdGet8 (PcdUartDefaultStopBits));

+}

+

+/**

+  Write data to serial device.

+

+  @param  Buffer           Point of data buffer which need to be written.

+  @param  NumberOfBytes    Number of output bytes which are cached in Buffer.

+

+  @retval 0                Write data failed.

+  @retval !0               Actual number of bytes written to serial device.

+

+**/

+UINTN

+EFIAPI

+SerialPortWrite (

+  IN UINT8     *Buffer,

+  IN UINTN     NumberOfBytes

+  )

+{

+  return PL011UartWrite ((UINTN)PcdGet64 (PcdSerialRegisterBase), Buffer, NumberOfBytes);

+}

+

+/**

+  Read data from serial device and save the data in buffer.

+

+  @param  Buffer           Point of data buffer which need to be written.

+  @param  NumberOfBytes    Number of output bytes which are cached in Buffer.

+

+  @retval 0                Read data failed.

+  @retval !0               Actual number of bytes read from serial device.

+

+**/

+UINTN

+EFIAPI

+SerialPortRead (

+  OUT UINT8     *Buffer,

+  IN  UINTN     NumberOfBytes

+)

+{

+  return PL011UartRead ((UINTN)PcdGet64 (PcdSerialRegisterBase), Buffer, NumberOfBytes);

+}

+

+/**

+  Check to see if any data is available to be read from the debug device.

+

+  @retval EFI_SUCCESS       At least one byte of data is available to be read

+  @retval EFI_NOT_READY     No data is available to be read

+  @retval EFI_DEVICE_ERROR  The serial device is not functioning properly

+

+**/

+BOOLEAN

+EFIAPI

+SerialPortPoll (

+  VOID

+  )

+{

+  return PL011UartPoll ((UINTN)PcdGet64 (PcdSerialRegisterBase));

+}

+

diff --git a/ArmPlatformPkg/Library/PL031RealTimeClockLib/PL031RealTimeClockLib.c b/ArmPlatformPkg/Library/PL031RealTimeClockLib/PL031RealTimeClockLib.c
index ec3091b9..b7dba087 100644
--- a/ArmPlatformPkg/Library/PL031RealTimeClockLib/PL031RealTimeClockLib.c
+++ b/ArmPlatformPkg/Library/PL031RealTimeClockLib/PL031RealTimeClockLib.c
@@ -4,6 +4,7 @@
   Currently this driver does not support runtime virtual calling.

 

   Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+  Copyright (c) 2011-2013, ARM Ltd. All rights reserved.<BR>

 

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

@@ -33,9 +34,9 @@
 

 #include <ArmPlatform.h>

 

-CHAR16        mTimeZoneVariableName[] = L"PL031_TimeZone";

-CHAR16        mDaylightVariableName[] = L"PL031_Daylight";

-BOOLEAN       mPL031Initialized = FALSE;

+STATIC CONST CHAR16  mTimeZoneVariableName[] = L"PL031RtcTimeZone";

+STATIC CONST CHAR16  mDaylightVariableName[] = L"PL031RtcDaylight";

+STATIC BOOLEAN       mPL031Initialized = FALSE;

 

 EFI_STATUS

 IdentifyPL031 (

@@ -128,10 +129,6 @@ EpochToEfiTime (
   UINTN         ss;

   UINTN         J;

 

-  if (Time->Daylight == TRUE) {

-

-  }

-

   J  = (EpochSeconds / 86400) + 2440588;

   j  = J + 32044;

   g  = j / 146097;

@@ -233,13 +230,14 @@ DayValid (
   Returns the current time and date information, and the time-keeping capabilities

   of the hardware platform.

 

-  @param  Time                  A pointer to storage to receive a snapshot of the current time.

-  @param  Capabilities          An optional pointer to a buffer to receive the real time clock

-                                device's capabilities.

+  @param  Time                   A pointer to storage to receive a snapshot of the current time.

+  @param  Capabilities           An optional pointer to a buffer to receive the real time clock

+                                 device's capabilities.

 

-  @retval EFI_SUCCESS           The operation completed successfully.

-  @retval EFI_INVALID_PARAMETER Time is NULL.

-  @retval EFI_DEVICE_ERROR      The time could not be retrieved due to hardware error.

+  @retval EFI_SUCCESS            The operation completed successfully.

+  @retval EFI_INVALID_PARAMETER  Time is NULL.

+  @retval EFI_DEVICE_ERROR       The time could not be retrieved due to hardware error.

+  @retval EFI_SECURITY_VIOLATION The time could not be retrieved due to an authentication failure.

 

 **/

 EFI_STATUS

@@ -250,9 +248,10 @@ LibGetTime (
   )

 {

   EFI_STATUS  Status = EFI_SUCCESS;

-  UINTN       EpochSeconds;

-  INT16       *TimeZone = 0;

-  UINTN       *Daylight = 0;

+  UINT32      EpochSeconds;

+  INT16       TimeZone;

+  UINT8       Daylight;

+  UINTN       Size;

 

   // Initialize the hardware if not already done

   if (!mPL031Initialized) {

@@ -286,27 +285,44 @@ LibGetTime (
   }

 

   // Get the current time zone information from non-volatile storage

-  TimeZone = (INT16 *)GetVariable(mTimeZoneVariableName, &gEfiGlobalVariableGuid);

+  Size = sizeof (TimeZone);

+  Status = gRT->GetVariable (

+                  (CHAR16 *)mTimeZoneVariableName,

+                  &gEfiCallerIdGuid,

+                  NULL,

+                  &Size,

+                  (VOID *)&TimeZone

+                  );

+

+  if (EFI_ERROR (Status)) {

+    ASSERT(Status != EFI_INVALID_PARAMETER);

+    ASSERT(Status != EFI_BUFFER_TOO_SMALL);

+

+    if (Status != EFI_NOT_FOUND)

+      goto EXIT;

 

-  if (TimeZone == NULL) {

     // The time zone variable does not exist in non-volatile storage, so create it.

     Time->TimeZone = EFI_UNSPECIFIED_TIMEZONE;

     // Store it

     Status = gRT->SetVariable (

-                                mTimeZoneVariableName,

-                                &gEfiGlobalVariableGuid,

-                                EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,

-                                sizeof(Time->TimeZone),

-                                &(Time->TimeZone)

-                             );

+                    (CHAR16 *)mTimeZoneVariableName,

+                    &gEfiCallerIdGuid,

+                    EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,

+                    Size,

+                    (VOID *)&(Time->TimeZone)

+                    );

     if (EFI_ERROR (Status)) {

-      DEBUG((EFI_D_ERROR,"LibGetTime: ERROR: TimeZone\n"));

+      DEBUG ((

+        EFI_D_ERROR,

+        "LibGetTime: Failed to save %s variable to non-volatile storage, Status = %r\n",

+        mTimeZoneVariableName,

+        Status

+        ));

       goto EXIT;

     }

   } else {

     // Got the time zone

-    Time->TimeZone = *TimeZone;

-    FreePool(TimeZone);

+    Time->TimeZone = TimeZone;

 

     // Check TimeZone bounds:   -1440 to 1440 or 2047

     if (((Time->TimeZone < -1440) || (Time->TimeZone > 1440))

@@ -321,27 +337,44 @@ LibGetTime (
   }

 

   // Get the current daylight information from non-volatile storage

-  Daylight = (UINTN *)GetVariable(mDaylightVariableName, &gEfiGlobalVariableGuid);

+  Size = sizeof (Daylight);

+  Status = gRT->GetVariable (

+                  (CHAR16 *)mDaylightVariableName,

+                  &gEfiCallerIdGuid,

+                  NULL,

+                  &Size,

+                  (VOID *)&Daylight

+                  );

+

+  if (EFI_ERROR (Status)) {

+    ASSERT(Status != EFI_INVALID_PARAMETER);

+    ASSERT(Status != EFI_BUFFER_TOO_SMALL);

+

+    if (Status != EFI_NOT_FOUND)

+      goto EXIT;

 

-  if (Daylight == NULL) {

     // The daylight variable does not exist in non-volatile storage, so create it.

     Time->Daylight = 0;

     // Store it

     Status = gRT->SetVariable (

-                                mDaylightVariableName,

-                                &gEfiGlobalVariableGuid,

-                                EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,

-                                sizeof(Time->Daylight),

-                                &(Time->Daylight)

-                             );

+                    (CHAR16 *)mDaylightVariableName,

+                    &gEfiCallerIdGuid,

+                    EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,

+                    Size,

+                    (VOID *)&(Time->Daylight)

+                    );

     if (EFI_ERROR (Status)) {

-      DEBUG((EFI_D_ERROR,"LibGetTime: ERROR: Daylight\n"));

+      DEBUG ((

+        EFI_D_ERROR,

+        "LibGetTime: Failed to save %s variable to non-volatile storage, Status = %r\n",

+        mDaylightVariableName,

+        Status

+        ));

       goto EXIT;

     }

   } else {

     // Got the daylight information

-    Time->Daylight = *Daylight;

-    FreePool(Daylight);

+    Time->Daylight = Daylight;

 

     // Adjust for the correct period

     if ((Time->Daylight & EFI_TIME_IN_DAYLIGHT) == EFI_TIME_IN_DAYLIGHT) {

@@ -456,27 +489,37 @@ LibSetTime (
 

   // Save the current time zone information into non-volatile storage

   Status = gRT->SetVariable (

-                              mTimeZoneVariableName,

-                              &gEfiGlobalVariableGuid,

-                              EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,

-                              sizeof(Time->TimeZone),

-                              &(Time->TimeZone)

-                           );

+                  (CHAR16 *)mTimeZoneVariableName,

+                  &gEfiCallerIdGuid,

+                  EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,

+                  sizeof (Time->TimeZone),

+                  (VOID *)&(Time->TimeZone)

+                  );

   if (EFI_ERROR (Status)) {

-    DEBUG((EFI_D_ERROR,"LibSetTime: ERROR: TimeZone\n"));

+      DEBUG ((

+        EFI_D_ERROR,

+        "LibSetTime: Failed to save %s variable to non-volatile storage, Status = %r\n",

+        mTimeZoneVariableName,

+        Status

+        ));

     goto EXIT;

   }

 

   // Save the current daylight information into non-volatile storage

   Status = gRT->SetVariable (

-                              mDaylightVariableName,

-                              &gEfiGlobalVariableGuid,

-                              EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,

-                              sizeof(Time->Daylight),

-                              &(Time->Daylight)

-                           );

+                  (CHAR16 *)mDaylightVariableName,

+                  &gEfiCallerIdGuid,

+                  EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,

+                  sizeof(Time->Daylight),

+                  (VOID *)&(Time->Daylight)

+                  );

   if (EFI_ERROR (Status)) {

-    DEBUG((EFI_D_ERROR,"LibSetTime: ERROR: Daylight\n"));

+    DEBUG ((

+      EFI_D_ERROR,

+      "LibSetTime: Failed to save %s variable to non-volatile storage, Status = %r\n",

+      mDaylightVariableName,

+      Status

+      ));

     goto EXIT;

   }

 

diff --git a/ArmPlatformPkg/Library/PL031RealTimeClockLib/PL031RealTimeClockLib.inf b/ArmPlatformPkg/Library/PL031RealTimeClockLib/PL031RealTimeClockLib.inf
index 24c74d2d..add982ce 100644
--- a/ArmPlatformPkg/Library/PL031RealTimeClockLib/PL031RealTimeClockLib.inf
+++ b/ArmPlatformPkg/Library/PL031RealTimeClockLib/PL031RealTimeClockLib.inf
@@ -1,8 +1,7 @@
 #/** @file

-# Memory Status Code Library for UEFI drivers

 #

-# Lib to provide memory journal status code reporting Routines

 # Copyright (c) 2006, Intel Corporation. All rights reserved.<BR>

+# Copyright (c) 2011-2013, ARM Ltd. All rights reserved.<BR>

 #

 #  This program and the accompanying materials

 #  are licensed and made available under the terms and conditions of the BSD License

@@ -25,7 +24,6 @@
 [Sources.common]

   PL031RealTimeClockLib.c

 

-

 [Packages]

   MdePkg/MdePkg.dec

   EmbeddedPkg/EmbeddedPkg.dec

@@ -37,7 +35,7 @@
   DebugLib

   PcdLib

   ArmPlatformSysConfigLib

-  

+

 [Pcd]

   gArmPlatformTokenSpaceGuid.PcdPL031RtcBase

   gArmPlatformTokenSpaceGuid.PcdPL031RtcPpmAccuracy

diff --git a/ArmPlatformPkg/Library/SP804TimerLib/SP804TimerLib.c b/ArmPlatformPkg/Library/SP804TimerLib/SP804TimerLib.c
index fcaa23ed..a042dac9 100644
--- a/ArmPlatformPkg/Library/SP804TimerLib/SP804TimerLib.c
+++ b/ArmPlatformPkg/Library/SP804TimerLib/SP804TimerLib.c
@@ -1,260 +1,260 @@
-/** @file
-
-  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-  Copyright (c) 2011, ARM Limited. All rights reserved.
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include <Base.h>
-
-#include <Library/BaseLib.h>
-#include <Library/TimerLib.h>
-#include <Library/DebugLib.h>
-#include <Library/PcdLib.h>
-#include <Library/IoLib.h>
-#include <Drivers/SP804Timer.h>
-
-#define SP804_TIMER_METRONOME_BASE    ((UINTN)PcdGet32 (PcdSP804TimerMetronomeBase))
-#define SP804_TIMER_PERFORMANCE_BASE  ((UINTN)PcdGet32 (PcdSP804TimerPerformanceBase))
-
-// Setup SP810's Timer2 for managing delay functions. And Timer3 for Performance counter
-// Note: ArmVE's Timer0 and Timer1 are used by TimerDxe.
-RETURN_STATUS
-EFIAPI
-TimerConstructor (
-  VOID
-  )
-{
-  // Check if the Metronome Timer is already initialized
-  if (MmioRead32(SP804_TIMER_METRONOME_BASE + SP804_TIMER_CONTROL_REG) & SP804_TIMER_CTRL_ENABLE) {
-    return RETURN_SUCCESS;
-  } else {
-    // Configure the Metronome Timer for free running operation, 32 bits, no prescaler, and interrupt disabled
-    MmioWrite32 (SP804_TIMER_METRONOME_BASE + SP804_TIMER_CONTROL_REG, SP804_TIMER_CTRL_32BIT | SP804_PRESCALE_DIV_1);
-
-    // Start the Metronome Timer ticking
-    MmioOr32 (SP804_TIMER_METRONOME_BASE + SP804_TIMER_CONTROL_REG, SP804_TIMER_CTRL_ENABLE);
-  }
-
-  // Check if the Performance Timer is already initialized
-  if (MmioRead32(SP804_TIMER_PERFORMANCE_BASE + SP804_TIMER_CONTROL_REG) & SP804_TIMER_CTRL_ENABLE) {
-    return RETURN_SUCCESS;
-  } else {
-    // Configure the Performance timer for free running operation, 32 bits, no prescaler, interrupt disabled
-    MmioWrite32 (SP804_TIMER_PERFORMANCE_BASE + SP804_TIMER_CONTROL_REG, SP804_TIMER_CTRL_32BIT | SP804_PRESCALE_DIV_1);
-
-    // Start the Performance Timer ticking
-    MmioOr32 (SP804_TIMER_PERFORMANCE_BASE + SP804_TIMER_CONTROL_REG, SP804_TIMER_CTRL_ENABLE);
-  }
-
-  return RETURN_SUCCESS;
-}
-
-/**
-  Stalls the CPU for at least the given number of microseconds.
-
-  Stalls the CPU for the number of microseconds specified by MicroSeconds.
-  The hardware timer is 32 bits.
-  The maximum possible delay is (0xFFFFFFFF / TimerFrequencyMHz), i.e. ([32bits] / FreqInMHz)
-  For example:
-  +----------------+------------+----------+----------+
-  | TimerFrequency |  MaxDelay  | MaxDelay | MaxDelay |
-  |     (MHz)      |    (us)    |   (s)    |  (min)   |
-  +----------------+------------+----------+----------+
-  |        1       | 0xFFFFFFFF |   4294   |   71.5   |
-  |        5       | 0x33333333 |    859   |   14.3   |
-  |       10       | 0x19999999 |    429   |    7.2   |
-  |       50       | 0x051EB851 |     86   |    1.4   |
-  +----------------+------------+----------+----------+
-  If it becomes necessary to support higher delays, then consider using the
-  real time clock.
-
-  During this delay, the cpu is not yielded to any other process, with one exception:
-  events that are triggered off a timer and which execute at a higher TPL than
-  this function. These events may call MicroSecondDelay (or NanoSecondDelay) to
-  fulfil their own needs.
-  Therefore, this function must be re-entrant, as it may be interrupted and re-started.
-
-  @param  MicroSeconds  The minimum number of microseconds to delay.
-
-  @return The value of MicroSeconds inputted.
-
-**/
-UINTN
-EFIAPI
-MicroSecondDelay (
-  IN  UINTN MicroSeconds
-  )
-{
-  UINT64    DelayTicks64;         // Convert from microseconds to timer ticks, more bits to detect over-range conditions.
-  UINTN     DelayTicks;           // Convert from microseconds to timer ticks, native size for general calculations.
-  UINTN     StartTicks;           // Timer value snapshot at the start of the delay
-  UINTN     TargetTicks;          // Timer value to signal the end of the delay
-  UINTN     CurrentTicks;         // Current value of the 64-bit timer value at any given moment
-
-  // If we snapshot the timer at the start of the delay function then we minimise unaccounted overheads.
-  StartTicks = MmioRead32 (SP804_TIMER_METRONOME_BASE + SP804_TIMER_CURRENT_REG);
-
-  // We are operating at the limit of 32bits. For the range checking work in 64 bits to avoid overflows.
-  DelayTicks64 = MultU64x32((UINT64)MicroSeconds, PcdGet32(PcdSP804TimerFrequencyInMHz));
-
-  // We are limited to 32 bits.
-  // If the specified delay is exactly equal to the max range of the timer,
-  // then the start will be equal to the stop plus one timer overflow (wrap-around).
-  // To avoid having to check for that, reduce the maximum acceptable range by 1 tick,
-  // i.e. reject delays equal or greater than the max range of the timer.
-  if (DelayTicks64 >= (UINT64)SP804_MAX_TICKS) {
-    DEBUG((EFI_D_ERROR,"MicroSecondDelay: ERROR: MicroSeconds=%d exceed SP804 count range. Max MicroSeconds=%d\n",
-      MicroSeconds,
-      ((UINTN)SP804_MAX_TICKS/PcdGet32(PcdSP804TimerFrequencyInMHz))));
-  }
-  ASSERT(DelayTicks64 < (UINT64)SP804_MAX_TICKS);
-
-  // From now on do calculations only in native bit size.
-  DelayTicks = (UINTN)DelayTicks64;
-
-  // Calculate the target value of the timer.
-
-  //Note: SP804 timer is counting down
-  if (StartTicks >= DelayTicks) {
-    // In this case we do not expect a wrap-around of the timer to occur.
-    // CurrentTicks must be less than StartTicks and higher than TargetTicks.
-    // If this is not the case, then the delay has been reached and may even have been exceeded if this
-    // function was suspended by a higher priority interrupt.
-
-    TargetTicks = StartTicks - DelayTicks;
-
-    do {
-      CurrentTicks = MmioRead32 (SP804_TIMER_METRONOME_BASE + SP804_TIMER_CURRENT_REG);
-    } while ((CurrentTicks > TargetTicks) && (CurrentTicks <= StartTicks));
-
-  } else {
-    // In this case TargetTicks is larger than StartTicks.
-    // This means we expect a wrap-around of the timer to occur and we must wait for it.
-    // Before the wrap-around, CurrentTicks must be less than StartTicks and less than TargetTicks.
-    // After the wrap-around, CurrentTicks must be larger than StartTicks and larger than TargetTicks.
-    // If this is not the case, then the delay has been reached and may even have been exceeded if this
-    // function was suspended by a higher priority interrupt.
-
-    // The order of operations is essential to avoid arithmetic overflow problems
-    TargetTicks = ((UINTN)SP804_MAX_TICKS - DelayTicks) + StartTicks;
-
-    // First wait for the wrap-around to occur
-    do {
-      CurrentTicks = MmioRead32 (SP804_TIMER_METRONOME_BASE + SP804_TIMER_CURRENT_REG);
-    } while (CurrentTicks <= StartTicks);
-
-    // Then wait for the target
-    do {
-      CurrentTicks = MmioRead32 (SP804_TIMER_METRONOME_BASE + SP804_TIMER_CURRENT_REG);
-    } while (CurrentTicks > TargetTicks);
-  }
-
-  return MicroSeconds;
-}
-
-/**
-  Stalls the CPU for at least the given number of nanoseconds.
-
-  Stalls the CPU for the number of nanoseconds specified by NanoSeconds.
-
-  When the timer frequency is 1MHz, each tick corresponds to 1 microsecond.
-  Therefore, the nanosecond delay will be rounded up to the nearest 1 microsecond.
-
-  @param  NanoSeconds The minimum number of nanoseconds to delay.
-
-  @return The value of NanoSeconds inputted.
-
-**/
-UINTN
-EFIAPI
-NanoSecondDelay (
-  IN  UINTN NanoSeconds
-  )
-{
-  UINTN  MicroSeconds;
-
-  // Round up to 1us Tick Number
-  MicroSeconds = NanoSeconds / 1000;
-  MicroSeconds += ((NanoSeconds % 1000) == 0) ? 0 : 1;
-
-  MicroSecondDelay (MicroSeconds);
-
-  return NanoSeconds;
-}
-
-/**
-  Retrieves the current value of a 64-bit free running performance counter.
-
-  The counter can either count up by 1 or count down by 1. If the physical
-  performance counter counts by a larger increment, then the counter values
-  must be translated. The properties of the counter can be retrieved from
-  GetPerformanceCounterProperties().
-
-  @return The current value of the free running performance counter.
-
-**/
-UINT64
-EFIAPI
-GetPerformanceCounter (
-  VOID
-  )
-{ 
-  // Free running 64-bit/32-bit counter is needed here.
-  // Don't think we need this to boot, just to do performance profile
-  UINT64 Value;
-  Value = MmioRead32 (SP804_TIMER_PERFORMANCE_BASE + SP804_TIMER_CURRENT_REG);
-  return Value;
-}
-
-
-/**
-  Retrieves the 64-bit frequency in Hz and the range of performance counter
-  values.
-
-  If StartValue is not NULL, then the value that the performance counter starts
-  with immediately after is it rolls over is returned in StartValue. If
-  EndValue is not NULL, then the value that the performance counter end with
-  immediately before it rolls over is returned in EndValue. The 64-bit
-  frequency of the performance counter in Hz is always returned. If StartValue
-  is less than EndValue, then the performance counter counts up. If StartValue
-  is greater than EndValue, then the performance counter counts down. For
-  example, a 64-bit free running counter that counts up would have a StartValue
-  of 0 and an EndValue of 0xFFFFFFFFFFFFFFFF. A 24-bit free running counter
-  that counts down would have a StartValue of 0xFFFFFF and an EndValue of 0.
-
-  @param  StartValue  The value the performance counter starts with when it
-                      rolls over.
-  @param  EndValue    The value that the performance counter ends with before
-                      it rolls over.
-
-  @return The frequency in Hz.
-
-**/
-UINT64
-EFIAPI
-GetPerformanceCounterProperties (
-  OUT UINT64  *StartValue,  OPTIONAL
-  OUT UINT64  *EndValue     OPTIONAL
-  )
-{
-  if (StartValue != NULL) {
-    // Timer starts with the reload value
-    *StartValue = 0xFFFFFFFF;
-  }
-  
-  if (EndValue != NULL) {
-    // Timer counts down to 0x0
-    *EndValue = (UINT64)0ULL;
-  }
-  
-  return PcdGet64 (PcdEmbeddedPerformanceCounterFrequencyInHz);
-}
+/** @file

+

+  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+  Copyright (c) 2011, ARM Limited. All rights reserved.

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include <Base.h>

+

+#include <Library/BaseLib.h>

+#include <Library/TimerLib.h>

+#include <Library/DebugLib.h>

+#include <Library/PcdLib.h>

+#include <Library/IoLib.h>

+#include <Drivers/SP804Timer.h>

+

+#define SP804_TIMER_METRONOME_BASE    ((UINTN)PcdGet32 (PcdSP804TimerMetronomeBase))

+#define SP804_TIMER_PERFORMANCE_BASE  ((UINTN)PcdGet32 (PcdSP804TimerPerformanceBase))

+

+// Setup SP810's Timer2 for managing delay functions. And Timer3 for Performance counter

+// Note: ArmVE's Timer0 and Timer1 are used by TimerDxe.

+RETURN_STATUS

+EFIAPI

+TimerConstructor (

+  VOID

+  )

+{

+  // Check if the Metronome Timer is already initialized

+  if (MmioRead32(SP804_TIMER_METRONOME_BASE + SP804_TIMER_CONTROL_REG) & SP804_TIMER_CTRL_ENABLE) {

+    return RETURN_SUCCESS;

+  } else {

+    // Configure the Metronome Timer for free running operation, 32 bits, no prescaler, and interrupt disabled

+    MmioWrite32 (SP804_TIMER_METRONOME_BASE + SP804_TIMER_CONTROL_REG, SP804_TIMER_CTRL_32BIT | SP804_PRESCALE_DIV_1);

+

+    // Start the Metronome Timer ticking

+    MmioOr32 (SP804_TIMER_METRONOME_BASE + SP804_TIMER_CONTROL_REG, SP804_TIMER_CTRL_ENABLE);

+  }

+

+  // Check if the Performance Timer is already initialized

+  if (MmioRead32(SP804_TIMER_PERFORMANCE_BASE + SP804_TIMER_CONTROL_REG) & SP804_TIMER_CTRL_ENABLE) {

+    return RETURN_SUCCESS;

+  } else {

+    // Configure the Performance timer for free running operation, 32 bits, no prescaler, interrupt disabled

+    MmioWrite32 (SP804_TIMER_PERFORMANCE_BASE + SP804_TIMER_CONTROL_REG, SP804_TIMER_CTRL_32BIT | SP804_PRESCALE_DIV_1);

+

+    // Start the Performance Timer ticking

+    MmioOr32 (SP804_TIMER_PERFORMANCE_BASE + SP804_TIMER_CONTROL_REG, SP804_TIMER_CTRL_ENABLE);

+  }

+

+  return RETURN_SUCCESS;

+}

+

+/**

+  Stalls the CPU for at least the given number of microseconds.

+

+  Stalls the CPU for the number of microseconds specified by MicroSeconds.

+  The hardware timer is 32 bits.

+  The maximum possible delay is (0xFFFFFFFF / TimerFrequencyMHz), i.e. ([32bits] / FreqInMHz)

+  For example:

+  +----------------+------------+----------+----------+

+  | TimerFrequency |  MaxDelay  | MaxDelay | MaxDelay |

+  |     (MHz)      |    (us)    |   (s)    |  (min)   |

+  +----------------+------------+----------+----------+

+  |        1       | 0xFFFFFFFF |   4294   |   71.5   |

+  |        5       | 0x33333333 |    859   |   14.3   |

+  |       10       | 0x19999999 |    429   |    7.2   |

+  |       50       | 0x051EB851 |     86   |    1.4   |

+  +----------------+------------+----------+----------+

+  If it becomes necessary to support higher delays, then consider using the

+  real time clock.

+

+  During this delay, the cpu is not yielded to any other process, with one exception:

+  events that are triggered off a timer and which execute at a higher TPL than

+  this function. These events may call MicroSecondDelay (or NanoSecondDelay) to

+  fulfil their own needs.

+  Therefore, this function must be re-entrant, as it may be interrupted and re-started.

+

+  @param  MicroSeconds  The minimum number of microseconds to delay.

+

+  @return The value of MicroSeconds inputted.

+

+**/

+UINTN

+EFIAPI

+MicroSecondDelay (

+  IN  UINTN MicroSeconds

+  )

+{

+  UINT64    DelayTicks64;         // Convert from microseconds to timer ticks, more bits to detect over-range conditions.

+  UINTN     DelayTicks;           // Convert from microseconds to timer ticks, native size for general calculations.

+  UINTN     StartTicks;           // Timer value snapshot at the start of the delay

+  UINTN     TargetTicks;          // Timer value to signal the end of the delay

+  UINTN     CurrentTicks;         // Current value of the 64-bit timer value at any given moment

+

+  // If we snapshot the timer at the start of the delay function then we minimise unaccounted overheads.

+  StartTicks = MmioRead32 (SP804_TIMER_METRONOME_BASE + SP804_TIMER_CURRENT_REG);

+

+  // We are operating at the limit of 32bits. For the range checking work in 64 bits to avoid overflows.

+  DelayTicks64 = MultU64x32((UINT64)MicroSeconds, PcdGet32(PcdSP804TimerFrequencyInMHz));

+

+  // We are limited to 32 bits.

+  // If the specified delay is exactly equal to the max range of the timer,

+  // then the start will be equal to the stop plus one timer overflow (wrap-around).

+  // To avoid having to check for that, reduce the maximum acceptable range by 1 tick,

+  // i.e. reject delays equal or greater than the max range of the timer.

+  if (DelayTicks64 >= (UINT64)SP804_MAX_TICKS) {

+    DEBUG((EFI_D_ERROR,"MicroSecondDelay: ERROR: MicroSeconds=%d exceed SP804 count range. Max MicroSeconds=%d\n",

+      MicroSeconds,

+      ((UINTN)SP804_MAX_TICKS/PcdGet32(PcdSP804TimerFrequencyInMHz))));

+  }

+  ASSERT(DelayTicks64 < (UINT64)SP804_MAX_TICKS);

+

+  // From now on do calculations only in native bit size.

+  DelayTicks = (UINTN)DelayTicks64;

+

+  // Calculate the target value of the timer.

+

+  //Note: SP804 timer is counting down

+  if (StartTicks >= DelayTicks) {

+    // In this case we do not expect a wrap-around of the timer to occur.

+    // CurrentTicks must be less than StartTicks and higher than TargetTicks.

+    // If this is not the case, then the delay has been reached and may even have been exceeded if this

+    // function was suspended by a higher priority interrupt.

+

+    TargetTicks = StartTicks - DelayTicks;

+

+    do {

+      CurrentTicks = MmioRead32 (SP804_TIMER_METRONOME_BASE + SP804_TIMER_CURRENT_REG);

+    } while ((CurrentTicks > TargetTicks) && (CurrentTicks <= StartTicks));

+

+  } else {

+    // In this case TargetTicks is larger than StartTicks.

+    // This means we expect a wrap-around of the timer to occur and we must wait for it.

+    // Before the wrap-around, CurrentTicks must be less than StartTicks and less than TargetTicks.

+    // After the wrap-around, CurrentTicks must be larger than StartTicks and larger than TargetTicks.

+    // If this is not the case, then the delay has been reached and may even have been exceeded if this

+    // function was suspended by a higher priority interrupt.

+

+    // The order of operations is essential to avoid arithmetic overflow problems

+    TargetTicks = ((UINTN)SP804_MAX_TICKS - DelayTicks) + StartTicks;

+

+    // First wait for the wrap-around to occur

+    do {

+      CurrentTicks = MmioRead32 (SP804_TIMER_METRONOME_BASE + SP804_TIMER_CURRENT_REG);

+    } while (CurrentTicks <= StartTicks);

+

+    // Then wait for the target

+    do {

+      CurrentTicks = MmioRead32 (SP804_TIMER_METRONOME_BASE + SP804_TIMER_CURRENT_REG);

+    } while (CurrentTicks > TargetTicks);

+  }

+

+  return MicroSeconds;

+}

+

+/**

+  Stalls the CPU for at least the given number of nanoseconds.

+

+  Stalls the CPU for the number of nanoseconds specified by NanoSeconds.

+

+  When the timer frequency is 1MHz, each tick corresponds to 1 microsecond.

+  Therefore, the nanosecond delay will be rounded up to the nearest 1 microsecond.

+

+  @param  NanoSeconds The minimum number of nanoseconds to delay.

+

+  @return The value of NanoSeconds inputted.

+

+**/

+UINTN

+EFIAPI

+NanoSecondDelay (

+  IN  UINTN NanoSeconds

+  )

+{

+  UINTN  MicroSeconds;

+

+  // Round up to 1us Tick Number

+  MicroSeconds = NanoSeconds / 1000;

+  MicroSeconds += ((NanoSeconds % 1000) == 0) ? 0 : 1;

+

+  MicroSecondDelay (MicroSeconds);

+

+  return NanoSeconds;

+}

+

+/**

+  Retrieves the current value of a 64-bit free running performance counter.

+

+  The counter can either count up by 1 or count down by 1. If the physical

+  performance counter counts by a larger increment, then the counter values

+  must be translated. The properties of the counter can be retrieved from

+  GetPerformanceCounterProperties().

+

+  @return The current value of the free running performance counter.

+

+**/

+UINT64

+EFIAPI

+GetPerformanceCounter (

+  VOID

+  )

+{ 

+  // Free running 64-bit/32-bit counter is needed here.

+  // Don't think we need this to boot, just to do performance profile

+  UINT64 Value;

+  Value = MmioRead32 (SP804_TIMER_PERFORMANCE_BASE + SP804_TIMER_CURRENT_REG);

+  return Value;

+}

+

+

+/**

+  Retrieves the 64-bit frequency in Hz and the range of performance counter

+  values.

+

+  If StartValue is not NULL, then the value that the performance counter starts

+  with immediately after is it rolls over is returned in StartValue. If

+  EndValue is not NULL, then the value that the performance counter end with

+  immediately before it rolls over is returned in EndValue. The 64-bit

+  frequency of the performance counter in Hz is always returned. If StartValue

+  is less than EndValue, then the performance counter counts up. If StartValue

+  is greater than EndValue, then the performance counter counts down. For

+  example, a 64-bit free running counter that counts up would have a StartValue

+  of 0 and an EndValue of 0xFFFFFFFFFFFFFFFF. A 24-bit free running counter

+  that counts down would have a StartValue of 0xFFFFFF and an EndValue of 0.

+

+  @param  StartValue  The value the performance counter starts with when it

+                      rolls over.

+  @param  EndValue    The value that the performance counter ends with before

+                      it rolls over.

+

+  @return The frequency in Hz.

+

+**/

+UINT64

+EFIAPI

+GetPerformanceCounterProperties (

+  OUT UINT64  *StartValue,  OPTIONAL

+  OUT UINT64  *EndValue     OPTIONAL

+  )

+{

+  if (StartValue != NULL) {

+    // Timer starts with the reload value

+    *StartValue = 0xFFFFFFFF;

+  }

+  

+  if (EndValue != NULL) {

+    // Timer counts down to 0x0

+    *EndValue = (UINT64)0ULL;

+  }

+  

+  return PcdGet64 (PcdEmbeddedPerformanceCounterFrequencyInHz);

+}

diff --git a/ArmPlatformPkg/Library/SP804TimerLib/SP804TimerLib.inf b/ArmPlatformPkg/Library/SP804TimerLib/SP804TimerLib.inf
index 0928cae5..d9bce48b 100644
--- a/ArmPlatformPkg/Library/SP804TimerLib/SP804TimerLib.inf
+++ b/ArmPlatformPkg/Library/SP804TimerLib/SP804TimerLib.inf
@@ -1,44 +1,44 @@
-#/** @file
-# Timer library implementation
-#  
-#  
-#  Copyright (c) 2011, ARM Ltd. All rights reserved.<BR>
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = SP804TimerLib
-  FILE_GUID                      = 09cefa99-0d07-487f-a651-fb44f094b1c7 
-  MODULE_TYPE                    = BASE
-  VERSION_STRING                 = 1.0
-  LIBRARY_CLASS                  = TimerLib
-  
-  CONSTRUCTOR                    = TimerConstructor
-
-[Sources.common]
-  SP804TimerLib.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  ArmPkg/ArmPkg.dec
-  ArmPlatformPkg/ArmPlatformPkg.dec
-  EmbeddedPkg/EmbeddedPkg.dec
-
-[LibraryClasses]
-  DebugLib
-  IoLib
-  BaseLib
-
-[Pcd]
-  gArmPlatformTokenSpaceGuid.PcdSP804TimerFrequencyInMHz
-  gArmPlatformTokenSpaceGuid.PcdSP804TimerPerformanceBase
-  gArmPlatformTokenSpaceGuid.PcdSP804TimerMetronomeBase
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedPerformanceCounterFrequencyInHz
+#/** @file

+# Timer library implementation

+#  

+#  

+#  Copyright (c) 2011, ARM Ltd. All rights reserved.<BR>

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = SP804TimerLib

+  FILE_GUID                      = 09cefa99-0d07-487f-a651-fb44f094b1c7 

+  MODULE_TYPE                    = BASE

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = TimerLib

+  

+  CONSTRUCTOR                    = TimerConstructor

+

+[Sources.common]

+  SP804TimerLib.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  ArmPkg/ArmPkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+  EmbeddedPkg/EmbeddedPkg.dec

+

+[LibraryClasses]

+  DebugLib

+  IoLib

+  BaseLib

+

+[Pcd]

+  gArmPlatformTokenSpaceGuid.PcdSP804TimerFrequencyInMHz

+  gArmPlatformTokenSpaceGuid.PcdSP804TimerPerformanceBase

+  gArmPlatformTokenSpaceGuid.PcdSP804TimerMetronomeBase

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedPerformanceCounterFrequencyInHz

diff --git a/ArmPlatformPkg/MemoryInitPei/MemoryInitPeiLib.inf b/ArmPlatformPkg/MemoryInitPei/MemoryInitPeiLib.inf
index 8c8d6108..fb77e4db 100755
--- a/ArmPlatformPkg/MemoryInitPei/MemoryInitPeiLib.inf
+++ b/ArmPlatformPkg/MemoryInitPei/MemoryInitPeiLib.inf
@@ -1,66 +1,66 @@
-#/** @file
-#  
-#  Copyright (c) 2011, ARM Ltd. All rights reserved.<BR>
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = ArmMemoryInitPeiLib
-  FILE_GUID                      = 55ddb6e0-70b5-11e0-b33e-0002a5d5c51b
-  MODULE_TYPE                    = SEC
-  VERSION_STRING                 = 1.0
-  LIBRARY_CLASS                  = PlatformPeiLib
-
-[Sources]
-  MemoryInitPeiLib.c
-
-
-[Packages]
-  MdePkg/MdePkg.dec
-  MdeModulePkg/MdeModulePkg.dec
-  EmbeddedPkg/EmbeddedPkg.dec
-  ArmPkg/ArmPkg.dec
-  ArmPlatformPkg/ArmPlatformPkg.dec
-  
-[LibraryClasses]
-  DebugLib
-  HobLib
-  ArmLib
-  ArmPlatformLib
-
-[Guids]
-  gEfiMemoryTypeInformationGuid
-
-[Ppis]
-
-[FeaturePcd]
-  gEmbeddedTokenSpaceGuid.PcdPrePiProduceMemoryTypeInformationHob
-
-[FixedPcd]
-  gArmTokenSpaceGuid.PcdFdBaseAddress
-  gArmTokenSpaceGuid.PcdFdSize
-
-  gArmTokenSpaceGuid.PcdSystemMemoryBase
-  gArmTokenSpaceGuid.PcdSystemMemorySize
-  gArmPlatformTokenSpaceGuid.PcdSystemMemoryUefiRegionSize
-  
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiACPIReclaimMemory
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiACPIMemoryNVS
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiReservedMemoryType
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiRuntimeServicesData
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiRuntimeServicesCode
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiBootServicesCode
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiBootServicesData
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiLoaderCode
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiLoaderData
-   
-[depex]
-  TRUE
+#/** @file

+#  

+#  Copyright (c) 2011, ARM Ltd. All rights reserved.<BR>

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = ArmMemoryInitPeiLib

+  FILE_GUID                      = 55ddb6e0-70b5-11e0-b33e-0002a5d5c51b

+  MODULE_TYPE                    = SEC

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = PlatformPeiLib

+

+[Sources]

+  MemoryInitPeiLib.c

+

+

+[Packages]

+  MdePkg/MdePkg.dec

+  MdeModulePkg/MdeModulePkg.dec

+  EmbeddedPkg/EmbeddedPkg.dec

+  ArmPkg/ArmPkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+  

+[LibraryClasses]

+  DebugLib

+  HobLib

+  ArmLib

+  ArmPlatformLib

+

+[Guids]

+  gEfiMemoryTypeInformationGuid

+

+[Ppis]

+

+[FeaturePcd]

+  gEmbeddedTokenSpaceGuid.PcdPrePiProduceMemoryTypeInformationHob

+

+[FixedPcd]

+  gArmTokenSpaceGuid.PcdFdBaseAddress

+  gArmTokenSpaceGuid.PcdFdSize

+

+  gArmTokenSpaceGuid.PcdSystemMemoryBase

+  gArmTokenSpaceGuid.PcdSystemMemorySize

+  gArmPlatformTokenSpaceGuid.PcdSystemMemoryUefiRegionSize

+  

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiACPIReclaimMemory

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiACPIMemoryNVS

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiReservedMemoryType

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiRuntimeServicesData

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiRuntimeServicesCode

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiBootServicesCode

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiBootServicesData

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiLoaderCode

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiLoaderData

+   

+[depex]

+  TRUE

diff --git a/ArmPlatformPkg/PlatformPei/PlatformPeiLib.inf b/ArmPlatformPkg/PlatformPei/PlatformPeiLib.inf
index 01f93595..5cddeccb 100755
--- a/ArmPlatformPkg/PlatformPei/PlatformPeiLib.inf
+++ b/ArmPlatformPkg/PlatformPei/PlatformPeiLib.inf
@@ -1,53 +1,53 @@
-#/** @file
-#
-#  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-#  
-#  This program and the accompanying materials                          
-#  are licensed and made available under the terms and conditions of the BSD License         
-#  which accompanies this distribution.  The full text of the license may be found at        
-#  http://opensource.org/licenses/bsd-license.php                                            
-#
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-#
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = ArmPlatformPeiLib
-  FILE_GUID                      = 49d37060-70b5-11e0-aa2d-0002a5d5c51b
-  MODULE_TYPE                    = SEC
-  VERSION_STRING                 = 1.0
-  LIBRARY_CLASS                  = PlatformPeiLib
-
-[Sources]
-  PlatformPeiLib.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  MdeModulePkg/MdeModulePkg.dec
-  EmbeddedPkg/EmbeddedPkg.dec
-  ArmPkg/ArmPkg.dec
-  ArmPlatformPkg/ArmPlatformPkg.dec
-
-[LibraryClasses]
-  DebugLib
-  HobLib
-  ArmPlatformLib
-
-[Ppis]
-  gEfiPeiMasterBootModePpiGuid                  # PPI ALWAYS_PRODUCED
-  gEfiPeiBootInRecoveryModePpiGuid              # PPI SOMETIMES_PRODUCED
-
-[FixedPcd]
-  gArmTokenSpaceGuid.PcdFdBaseAddress
-  gArmTokenSpaceGuid.PcdFdSize
-  
-  gArmTokenSpaceGuid.PcdFvBaseAddress
-  gArmTokenSpaceGuid.PcdFvSize
-  
-  gEmbeddedTokenSpaceGuid.PcdPrePiCpuMemorySize
-  gEmbeddedTokenSpaceGuid.PcdPrePiCpuIoSize
-  
-[depex]
-  TRUE
+#/** @file

+#

+#  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+#  

+#  This program and the accompanying materials                          

+#  are licensed and made available under the terms and conditions of the BSD License         

+#  which accompanies this distribution.  The full text of the license may be found at        

+#  http://opensource.org/licenses/bsd-license.php                                            

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+#

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = ArmPlatformPeiLib

+  FILE_GUID                      = 49d37060-70b5-11e0-aa2d-0002a5d5c51b

+  MODULE_TYPE                    = SEC

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = PlatformPeiLib

+

+[Sources]

+  PlatformPeiLib.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  MdeModulePkg/MdeModulePkg.dec

+  EmbeddedPkg/EmbeddedPkg.dec

+  ArmPkg/ArmPkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+

+[LibraryClasses]

+  DebugLib

+  HobLib

+  ArmPlatformLib

+

+[Ppis]

+  gEfiPeiMasterBootModePpiGuid                  # PPI ALWAYS_PRODUCED

+  gEfiPeiBootInRecoveryModePpiGuid              # PPI SOMETIMES_PRODUCED

+

+[FixedPcd]

+  gArmTokenSpaceGuid.PcdFdBaseAddress

+  gArmTokenSpaceGuid.PcdFdSize

+  

+  gArmTokenSpaceGuid.PcdFvBaseAddress

+  gArmTokenSpaceGuid.PcdFvSize

+  

+  gEmbeddedTokenSpaceGuid.PcdPrePiCpuMemorySize

+  gEmbeddedTokenSpaceGuid.PcdPrePiCpuIoSize

+  

+[depex]

+  TRUE

diff --git a/ArmPlatformPkg/PrePeiCore/Arm/ArchPrePeiCore.c b/ArmPlatformPkg/PrePeiCore/Arm/ArchPrePeiCore.c
new file mode 100644
index 00000000..b0594ae2
--- /dev/null
+++ b/ArmPlatformPkg/PrePeiCore/Arm/ArchPrePeiCore.c
@@ -0,0 +1,62 @@
+/** @file

+*  Main file supporting the transition to PEI Core in Normal World for Versatile Express

+*

+*  Copyright (c) 2012, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+#include <Library/PrintLib.h>

+#include <Library/SerialPortLib.h>

+

+#include "PrePeiCore.h"

+

+VOID

+PeiCommonExceptionEntry (

+  IN UINT32 Entry,

+  IN UINTN LR

+  )

+{

+  CHAR8           Buffer[100];

+  UINTN           CharCount;

+

+  switch (Entry) {

+  case 0:

+    CharCount = AsciiSPrint (Buffer,sizeof (Buffer),"Reset Exception at 0x%X\n\r",LR);

+    break;

+  case 1:

+    CharCount = AsciiSPrint (Buffer,sizeof (Buffer),"Undefined Exception at 0x%X\n\r",LR);

+    break;

+  case 2:

+    CharCount = AsciiSPrint (Buffer,sizeof (Buffer),"SWI Exception at 0x%X\n\r",LR);

+    break;

+  case 3:

+    CharCount = AsciiSPrint (Buffer,sizeof (Buffer),"PrefetchAbort Exception at 0x%X\n\r",LR);

+    break;

+  case 4:

+    CharCount = AsciiSPrint (Buffer,sizeof (Buffer),"DataAbort Exception at 0x%X\n\r",LR);

+    break;

+  case 5:

+    CharCount = AsciiSPrint (Buffer,sizeof (Buffer),"Reserved Exception at 0x%X\n\r",LR);

+    break;

+  case 6:

+    CharCount = AsciiSPrint (Buffer,sizeof (Buffer),"IRQ Exception at 0x%X\n\r",LR);

+    break;

+  case 7:

+    CharCount = AsciiSPrint (Buffer,sizeof (Buffer),"FIQ Exception at 0x%X\n\r",LR);

+    break;

+  default:

+    CharCount = AsciiSPrint (Buffer,sizeof (Buffer),"Unknown Exception at 0x%X\n\r",LR);

+    break;

+  }

+  SerialPortWrite ((UINT8 *) Buffer, CharCount);

+  while(1);

+}

+

diff --git a/ArmPlatformPkg/PrePeiCore/Exception.S b/ArmPlatformPkg/PrePeiCore/Arm/Exception.S
index abce21d0..abce21d0 100644
--- a/ArmPlatformPkg/PrePeiCore/Exception.S
+++ b/ArmPlatformPkg/PrePeiCore/Arm/Exception.S
diff --git a/ArmPlatformPkg/PrePeiCore/Exception.asm b/ArmPlatformPkg/PrePeiCore/Arm/Exception.asm
index 55bd4af1..55bd4af1 100644
--- a/ArmPlatformPkg/PrePeiCore/Exception.asm
+++ b/ArmPlatformPkg/PrePeiCore/Arm/Exception.asm
diff --git a/ArmPlatformPkg/PrePeiCore/PrePeiCoreEntryPoint.S b/ArmPlatformPkg/PrePeiCore/Arm/PrePeiCoreEntryPoint.S
index f902a251..f902a251 100644
--- a/ArmPlatformPkg/PrePeiCore/PrePeiCoreEntryPoint.S
+++ b/ArmPlatformPkg/PrePeiCore/Arm/PrePeiCoreEntryPoint.S
diff --git a/ArmPlatformPkg/PrePeiCore/PrePeiCoreEntryPoint.asm b/ArmPlatformPkg/PrePeiCore/Arm/PrePeiCoreEntryPoint.asm
index a3dd1fb2..a3dd1fb2 100644
--- a/ArmPlatformPkg/PrePeiCore/PrePeiCoreEntryPoint.asm
+++ b/ArmPlatformPkg/PrePeiCore/Arm/PrePeiCoreEntryPoint.asm
diff --git a/ArmPlatformPkg/PrePeiCore/SwitchStack.S b/ArmPlatformPkg/PrePeiCore/Arm/SwitchStack.S
index 2543f584..2543f584 100644
--- a/ArmPlatformPkg/PrePeiCore/SwitchStack.S
+++ b/ArmPlatformPkg/PrePeiCore/Arm/SwitchStack.S
diff --git a/ArmPlatformPkg/PrePeiCore/SwitchStack.asm b/ArmPlatformPkg/PrePeiCore/Arm/SwitchStack.asm
index 10da81d6..10da81d6 100644
--- a/ArmPlatformPkg/PrePeiCore/SwitchStack.asm
+++ b/ArmPlatformPkg/PrePeiCore/Arm/SwitchStack.asm
diff --git a/ArmPlatformPkg/PrePeiCore/MainMPCore.c b/ArmPlatformPkg/PrePeiCore/MainMPCore.c
index aeea8f5b..afe36a75 100644
--- a/ArmPlatformPkg/PrePeiCore/MainMPCore.c
+++ b/ArmPlatformPkg/PrePeiCore/MainMPCore.c
@@ -121,7 +121,7 @@ PrimaryMain (
   CreatePpiList (&PpiListSize, &PpiList);

 

   // Enable the GIC Distributor

-  ArmGicEnableDistributor(PcdGet32(PcdGicDistributorBase));

+  ArmGicEnableDistributor (PcdGet32(PcdGicDistributorBase));

 

   // If ArmVe has not been built as Standalone then we need to wake up the secondary cores

   if (FeaturePcdGet (PcdSendSgiToBringUpSecondaryCores)) {

@@ -155,5 +155,5 @@ PrimaryMain (
   SecCoreData.StackSize              = (TemporaryRamBase + TemporaryRamSize) - (UINTN)SecCoreData.StackBase;

 

   // Jump to PEI core entry point

-  (PeiCoreEntryPoint)(&SecCoreData, PpiList);

+  PeiCoreEntryPoint (&SecCoreData, PpiList);

 }

diff --git a/ArmPlatformPkg/PrePeiCore/PrePeiCore.c b/ArmPlatformPkg/PrePeiCore/PrePeiCore.c
index f1300e0e..fdd8697e 100644
--- a/ArmPlatformPkg/PrePeiCore/PrePeiCore.c
+++ b/ArmPlatformPkg/PrePeiCore/PrePeiCore.c
@@ -1,7 +1,7 @@
 /** @file

 *  Main file supporting the transition to PEI Core in Normal World for Versatile Express

 *

-*  Copyright (c) 2011, ARM Limited. All rights reserved.

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

 *  

 *  This program and the accompanying materials                          

 *  are licensed and made available under the terms and conditions of the BSD License         

@@ -15,9 +15,7 @@
 

 #include <Library/BaseLib.h>

 #include <Library/DebugAgentLib.h>

-#include <Library/PrintLib.h>

 #include <Library/ArmLib.h>

-#include <Library/SerialPortLib.h>

 

 #include <Ppi/ArmGlobalVariable.h>

 

@@ -74,10 +72,10 @@ CEntryPoint (
   )

 {

   //Clean Data cache

-  ArmCleanInvalidateDataCache();

+  ArmCleanInvalidateDataCache ();

 

   //Invalidate instruction cache

-  ArmInvalidateInstructionCache();

+  ArmInvalidateInstructionCache ();

 

   // Enable Instruction & Data caches

   ArmEnableDataCache ();

@@ -88,9 +86,9 @@ CEntryPoint (
   // as Non-secure interface is already enabled in Secure world.

   //

 

-  // Write VBAR - The Vector table must be 32-byte aligned

-  ASSERT(((UINT32)PeiVectorTable & ((1 << 5)-1)) == 0);

-  ArmWriteVBar((UINT32)PeiVectorTable);

+  // Write VBAR - The Exception Vector table must be aligned to its requirement

+  ASSERT (((UINTN)PeiVectorTable & ARM_VECTOR_TABLE_ALIGNMENT) == 0);

+  ArmWriteVBar ((UINTN)PeiVectorTable);

 

   //Note: The MMU will be enabled by MemoryPeim. Only the primary core will have the MMU on.

 

@@ -162,44 +160,3 @@ PrePeiCoreGetGlobalVariableMemory (
   return EFI_SUCCESS;

 }

 

-VOID

-PeiCommonExceptionEntry (

-  IN UINT32 Entry,

-  IN UINT32 LR

-  )

-{

-  CHAR8           Buffer[100];

-  UINTN           CharCount;

-

-  switch (Entry) {

-  case 0:

-    CharCount = AsciiSPrint (Buffer,sizeof (Buffer),"Reset Exception at 0x%X\n\r",LR);

-    break;

-  case 1:

-    CharCount = AsciiSPrint (Buffer,sizeof (Buffer),"Undefined Exception at 0x%X\n\r",LR);

-    break;

-  case 2:

-    CharCount = AsciiSPrint (Buffer,sizeof (Buffer),"SWI Exception at 0x%X\n\r",LR);

-    break;

-  case 3:

-    CharCount = AsciiSPrint (Buffer,sizeof (Buffer),"PrefetchAbort Exception at 0x%X\n\r",LR);

-    break;

-  case 4:

-    CharCount = AsciiSPrint (Buffer,sizeof (Buffer),"DataAbort Exception at 0x%X\n\r",LR);

-    break;

-  case 5:

-    CharCount = AsciiSPrint (Buffer,sizeof (Buffer),"Reserved Exception at 0x%X\n\r",LR);

-    break;

-  case 6:

-    CharCount = AsciiSPrint (Buffer,sizeof (Buffer),"IRQ Exception at 0x%X\n\r",LR);

-    break;

-  case 7:

-    CharCount = AsciiSPrint (Buffer,sizeof (Buffer),"FIQ Exception at 0x%X\n\r",LR);

-    break;

-  default:

-    CharCount = AsciiSPrint (Buffer,sizeof (Buffer),"Unknown Exception at 0x%X\n\r",LR);

-    break;

-  }

-  SerialPortWrite ((UINT8 *) Buffer, CharCount);

-  while(1);

-}

diff --git a/ArmPlatformPkg/PrePeiCore/PrePeiCore.h b/ArmPlatformPkg/PrePeiCore/PrePeiCore.h
index 9f7c9c33..20684e2f 100644
--- a/ArmPlatformPkg/PrePeiCore/PrePeiCore.h
+++ b/ArmPlatformPkg/PrePeiCore/PrePeiCore.h
@@ -74,4 +74,10 @@ SecondaryMain (
   IN UINTN MpId

   );

 

+VOID

+PeiCommonExceptionEntry (

+  IN UINT32 Entry,

+  IN UINTN LR

+  );

+

 #endif

diff --git a/ArmPlatformPkg/PrePeiCore/PrePeiCoreMPCore.inf b/ArmPlatformPkg/PrePeiCore/PrePeiCoreMPCore.inf
index efdc4b75..91f9b3a7 100644
--- a/ArmPlatformPkg/PrePeiCore/PrePeiCoreMPCore.inf
+++ b/ArmPlatformPkg/PrePeiCore/PrePeiCoreMPCore.inf
@@ -20,16 +20,19 @@
   MODULE_TYPE                    = SEC

   VERSION_STRING                 = 1.0

 

-[Sources.ARM]

-  PrePeiCoreEntryPoint.asm | RVCT

-  PrePeiCoreEntryPoint.S   | GCC

-  PrePeiCore.c

+[Sources.common]

   MainMPCore.c

-  SwitchStack.asm      | RVCT

-  SwitchStack.S        | GCC

-  Exception.asm        | RVCT

-  Exception.S          | GCC

-  

+  PrePeiCore.c

+

+[Sources.ARM]

+  Arm/ArchPrePeiCore.c

+  Arm/PrePeiCoreEntryPoint.asm | RVCT

+  Arm/PrePeiCoreEntryPoint.S   | GCC

+  Arm/SwitchStack.asm      | RVCT

+  Arm/SwitchStack.S        | GCC

+  Arm/Exception.asm        | RVCT

+  Arm/Exception.S          | GCC

+

 [Packages]

   MdePkg/MdePkg.dec

   MdeModulePkg/MdeModulePkg.dec

diff --git a/ArmPlatformPkg/PrePeiCore/PrePeiCoreUniCore.inf b/ArmPlatformPkg/PrePeiCore/PrePeiCoreUniCore.inf
index 90582d89..bf590dba 100644
--- a/ArmPlatformPkg/PrePeiCore/PrePeiCoreUniCore.inf
+++ b/ArmPlatformPkg/PrePeiCore/PrePeiCoreUniCore.inf
@@ -20,15 +20,18 @@
   MODULE_TYPE                    = SEC

   VERSION_STRING                 = 1.0

 

-[Sources.ARM]

-  PrePeiCoreEntryPoint.asm | RVCT

-  PrePeiCoreEntryPoint.S   | GCC

+[Sources.common]

   PrePeiCore.c

   MainUniCore.c

-  SwitchStack.asm      | RVCT

-  SwitchStack.S        | GCC

-  Exception.asm        | RVCT

-  Exception.S          | GCC

+

+[Sources.ARM]

+  Arm/ArchPrePeiCore.c

+  Arm/PrePeiCoreEntryPoint.asm | RVCT

+  Arm/PrePeiCoreEntryPoint.S   | GCC

+  Arm/SwitchStack.asm      | RVCT

+  Arm/SwitchStack.S        | GCC

+  Arm/Exception.asm        | RVCT

+  Arm/Exception.S          | GCC

   

 [Packages]

   MdePkg/MdePkg.dec

diff --git a/ArmPlatformPkg/PrePi/ModuleEntryPoint.S b/ArmPlatformPkg/PrePi/Arm/ModuleEntryPoint.S
index 9215198d..c0c20a92 100755..100644
--- a/ArmPlatformPkg/PrePi/ModuleEntryPoint.S
+++ b/ArmPlatformPkg/PrePi/Arm/ModuleEntryPoint.S
@@ -1,5 +1,5 @@
 //

-//  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+//  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

 //

 //  This program and the accompanying materials

 //  are licensed and made available under the terms and conditions of the BSD License

@@ -16,6 +16,8 @@
 #include <Library/PcdLib.h>

 #include <AutoGen.h>

 

+#include <Chipset/ArmV7.h>

+

 .text

 .align 3

 

@@ -35,8 +37,7 @@ ASM_PFX(_ModuleEntryPoint):
 

 _SetSVCMode:

   // Enter SVC mode, Disable FIQ and IRQ

-  //TODO: remove hardcoded values

-  mov     r1, #0x13|0x80|0x40

+  mov     r1, #(CPSR_MODE_SVC | CPSR_IRQ | CPSR_FIQ)

   msr     CPSR_c, r1

 

 // Check if we can install the stack at the top of the System Memory or if we need

diff --git a/ArmPlatformPkg/PrePi/ModuleEntryPoint.asm b/ArmPlatformPkg/PrePi/Arm/ModuleEntryPoint.asm
index 0dea1c32..5efdb532 100644
--- a/ArmPlatformPkg/PrePi/ModuleEntryPoint.asm
+++ b/ArmPlatformPkg/PrePi/Arm/ModuleEntryPoint.asm
@@ -1,5 +1,5 @@
 //

-//  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+//  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

 //

 //  This program and the accompanying materials

 //  are licensed and made available under the terms and conditions of the BSD License

@@ -16,6 +16,8 @@
 #include <Library/PcdLib.h>

 #include <AutoGen.h>

 

+#include <Chipset/ArmV7.h>

+

   INCLUDE AsmMacroIoLib.inc

   

   IMPORT  CEntryPoint

@@ -37,8 +39,7 @@ _ModuleEntryPoint
 

 _SetSVCMode

   // Enter SVC mode, Disable FIQ and IRQ

-  //TODO: remove hardcoded values

-  mov     r1, #0x13 :OR: 0x80 :OR: 0x40

+  mov     r1, #(CPSR_MODE_SVC :OR: CPSR_IRQ :OR: CPSR_FIQ)

   msr     CPSR_c, r1

 

 // Check if we can install the stack at the top of the System Memory or if we need

diff --git a/ArmPlatformPkg/PrePi/PeiMPCore.inf b/ArmPlatformPkg/PrePi/PeiMPCore.inf
index f4cec0d6..3a361419 100755
--- a/ArmPlatformPkg/PrePi/PeiMPCore.inf
+++ b/ArmPlatformPkg/PrePi/PeiMPCore.inf
@@ -19,11 +19,13 @@
   MODULE_TYPE                    = SEC

   VERSION_STRING                 = 1.0

 

-[Sources.ARM]

+[Sources]

   PrePi.c

-  ModuleEntryPoint.S   | GCC

-  ModuleEntryPoint.asm | RVCT

   MainMPCore.c

+

+[Sources.ARM]

+  Arm/ModuleEntryPoint.S   | GCC

+  Arm/ModuleEntryPoint.asm | RVCT

   

 [Packages]

   MdePkg/MdePkg.dec

diff --git a/ArmPlatformPkg/PrePi/PeiUniCore.inf b/ArmPlatformPkg/PrePi/PeiUniCore.inf
index 34a06863..823a9560 100755
--- a/ArmPlatformPkg/PrePi/PeiUniCore.inf
+++ b/ArmPlatformPkg/PrePi/PeiUniCore.inf
@@ -19,11 +19,13 @@
   MODULE_TYPE                    = SEC

   VERSION_STRING                 = 1.0

 

-[Sources.ARM]

+[Sources]

   PrePi.c

-  ModuleEntryPoint.S   | GCC

-  ModuleEntryPoint.asm | RVCT

   MainUniCore.c

+

+[Sources.ARM]

+  Arm/ModuleEntryPoint.S   | GCC

+  Arm/ModuleEntryPoint.asm | RVCT

   

 [Packages]

   MdePkg/MdePkg.dec

diff --git a/ArmPlatformPkg/Scripts/Ds5/build_report.py b/ArmPlatformPkg/Scripts/Ds5/build_report.py
index 3805c0b4..e5923009 100644
--- a/ArmPlatformPkg/Scripts/Ds5/build_report.py
+++ b/ArmPlatformPkg/Scripts/Ds5/build_report.py
@@ -1,54 +1,54 @@
-#
-#  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-#  
-#  This program and the accompanying materials                          
-#  are licensed and made available under the terms and conditions of the BSD License         
-#  which accompanies this distribution.  The full text of the license may be found at        
-#  http://opensource.org/licenses/bsd-license.php                                            
-#
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-#
-
-import re
-
-class BuildReport:
-    PCDs = {}
-    
-    def parse_platform_summary(self, file):
-        pass
-    
-    def parse_pcd_report(self, report_file):
-        pcd_reg = re.compile(" (\*P|\*F|\*M|  ) (\w+)(\ +)\: (.*) \((\w+)\) = (.*)\n")
-        
-        for line in report_file.xreadlines():
-            stripped_line = line.strip()
-            if re.match("\<=+\>", stripped_line):
-                return
-            elif re.match("g.*Guid", stripped_line):
-                guid = stripped_line
-                self.PCDs[guid] = {}
-            else:
-                m = pcd_reg.match(line)
-                if m:
-                    self.PCDs[guid][m.group(2)] = (m.group(6).strip(),m.group(5))
-                
-    def parse_firmware_device(self, file):
-        pass
-        
-    def parse_module_summary(self, file):
-        #print "Module Summary"
-        pass
-    
-    CONST_SECTION_HEADERS = [('Platform Summary', parse_platform_summary),
-                             ('Platform Configuration Database Report',parse_pcd_report),
-                             ('Firmware Device (FD)',parse_firmware_device),
-                             ('Module Summary',parse_module_summary)]
-    
-    def __init__(self, filename = 'report.log'):
-        report_file = open(filename, 'r')
-        for line in report_file.xreadlines():
-            for section_header in BuildReport.CONST_SECTION_HEADERS:
-                if line.strip() == section_header[0]:
-                    section_header[1](self, report_file)
-        #print self.PCDs
+#

+#  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+#  

+#  This program and the accompanying materials                          

+#  are licensed and made available under the terms and conditions of the BSD License         

+#  which accompanies this distribution.  The full text of the license may be found at        

+#  http://opensource.org/licenses/bsd-license.php                                            

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+#

+

+import re

+

+class BuildReport:

+    PCDs = {}

+    

+    def parse_platform_summary(self, file):

+        pass

+    

+    def parse_pcd_report(self, report_file):

+        pcd_reg = re.compile(" (\*P|\*F|\*M|  ) (\w+)(\ +)\: (.*) \((\w+)\) = (.*)\n")

+        

+        for line in report_file.xreadlines():

+            stripped_line = line.strip()

+            if re.match("\<=+\>", stripped_line):

+                return

+            elif re.match("g.*Guid", stripped_line):

+                guid = stripped_line

+                self.PCDs[guid] = {}

+            else:

+                m = pcd_reg.match(line)

+                if m:

+                    self.PCDs[guid][m.group(2)] = (m.group(6).strip(),m.group(5))

+                

+    def parse_firmware_device(self, file):

+        pass

+        

+    def parse_module_summary(self, file):

+        #print "Module Summary"

+        pass

+    

+    CONST_SECTION_HEADERS = [('Platform Summary', parse_platform_summary),

+                             ('Platform Configuration Database Report',parse_pcd_report),

+                             ('Firmware Device (FD)',parse_firmware_device),

+                             ('Module Summary',parse_module_summary)]

+    

+    def __init__(self, filename = 'report.log'):

+        report_file = open(filename, 'r')

+        for line in report_file.xreadlines():

+            for section_header in BuildReport.CONST_SECTION_HEADERS:

+                if line.strip() == section_header[0]:

+                    section_header[1](self, report_file)

+        #print self.PCDs

diff --git a/ArmPlatformPkg/Scripts/Ds5/cmd_load_symbols.py b/ArmPlatformPkg/Scripts/Ds5/cmd_load_symbols.py
index 424eb63c..994a475c 100644
--- a/ArmPlatformPkg/Scripts/Ds5/cmd_load_symbols.py
+++ b/ArmPlatformPkg/Scripts/Ds5/cmd_load_symbols.py
@@ -1,5 +1,5 @@
 #

-#  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+#  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

 #  

 #  This program and the accompanying materials                          

 #  are licensed and made available under the terms and conditions of the BSD License         

@@ -21,16 +21,18 @@ import edk2_debugger
 reload(edk2_debugger)

 

 def usage():

+    print "-v,--verbose"

     print "-a,--all: Load all symbols"

     print "-l,--report=: Filename for the EDK2 report log"

     print "-m,--sysmem=(base,size): System Memory region"

     print "-f,--fv=(base,size): Firmware region"

     print "-r,--rom=(base,size): ROM region"

 

+verbose = False

 load_all = False

 report_file = None

 regions = []

-opts,args = getopt.getopt(sys.argv[1:], "har:vm:vr:vf:v", ["help","all","report=","sysmem=","rom=","fv="])

+opts,args = getopt.getopt(sys.argv[1:], "hvar:vm:vr:vf:v", ["help","verbose","all","report=","sysmem=","rom=","fv="])

 if (opts is None) or (not opts):

     report_file = '../../../report.log'

 else:

@@ -44,6 +46,8 @@ else:
         if o in ("-h","--help"):

             usage()

             sys.exit()

+        elif o in ("-v","--verbose"):

+            verbose = True

         elif o in ("-a","--all"):

             load_all = True

         elif o in ("-l","--report"):

@@ -58,7 +62,7 @@ else:
             region_type = edk2_debugger.ArmPlatformDebugger.REGION_TYPE_ROM

             regex = region_reg

         else:

-            assert False, "Unhandled option"

+            assert False, "Unhandled option (%s)" % o

             

         if region_type:

             m = regex.match(a)

@@ -83,10 +87,8 @@ ec.getExecutionService().waitForStop()
 # in case the execution context reference is out of date

 ec = debugger.getExecutionContext(0)

 

-armplatform_debugger = edk2_debugger.ArmPlatformDebugger(ec, report_file, regions)

-

 try:

-    armplatform_debugger = edk2_debugger.ArmPlatformDebugger(ec, report_file, regions)

+    armplatform_debugger = edk2_debugger.ArmPlatformDebugger(ec, report_file, regions, verbose)

     

     if load_all:

         armplatform_debugger.load_all_symbols()

diff --git a/ArmPlatformPkg/Scripts/Ds5/edk2_debugger.py b/ArmPlatformPkg/Scripts/Ds5/edk2_debugger.py
index 71e5a3cc..4867af19 100644
--- a/ArmPlatformPkg/Scripts/Ds5/edk2_debugger.py
+++ b/ArmPlatformPkg/Scripts/Ds5/edk2_debugger.py
@@ -1,217 +1,221 @@
-#
-#  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-#  
-#  This program and the accompanying materials                          
-#  are licensed and made available under the terms and conditions of the BSD License         
-#  which accompanies this distribution.  The full text of the license may be found at        
-#  http://opensource.org/licenses/bsd-license.php                                            
-#
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-#
-
-import os
-
-import firmware_volume
-import build_report
-import system_table
-
-# Reload external classes
-reload(firmware_volume)
-reload(build_report)
-reload(system_table)
-
-def readMem32(executionContext, address):
-    bytes = executionContext.getMemoryService().read(address, 4, 32)
-    return struct.unpack('<I',bytes)[0]
-
-def dump_fv(ec, fv_base, fv_size):
-    fv = firmware_volume.FirmwareVolume(ec,
-                                        int(build.PCDs['gArmTokenSpaceGuid']['PcdFvBaseAddress'][0],16),
-                                        int(build.PCDs['gArmTokenSpaceGuid']['PcdFvSize'][0],16))
-    
-    ffs = fv.get_next_ffs()
-    while ffs != None:    
-        print "# %s" % ffs
-    
-        section = ffs.get_next_section()
-        while section != None:
-            print "\t%s" % section
-            try:
-                print "\t\t- %s" % section.get_debug_filepath()
-            except Exception:
-                pass
-            section = ffs.get_next_section(section)
-            
-        ffs = fv.get_next_ffs(ffs)
-
-def dump_system_table(ec, mem_base, mem_size):
-    st = system_table.SystemTable(ec, mem_base, mem_size)
-    
-    debug_info_table_base = st.get_configuration_table(system_table.DebugInfoTable.CONST_DEBUG_INFO_TABLE_GUID)
-    
-    debug_info_table = system_table.DebugInfoTable(ec, debug_info_table_base)
-    debug_info_table.dump()
-
-def load_symbol_from_file(ec, filename, address):
-    try:
-        ec.getImageService().addSymbols(filename, address)
-    except:
-        try:
-            # We could get an exception if the symbols are already loaded
-            ec.getImageService().unloadSymbols(filename)
-            ec.getImageService().addSymbols(filename, address)
-        except:
-            print "Warning: not possible to load symbols from %s" % filename
-            pass
-
-class ArmPlatform:
-    def __init__(self, sysmembase=None, sysmemsize=None, fvs={}):
-        self.sysmembase = sysmembase
-        self.sysmemsize = sysmemsize
-        self.fvs = fvs
-        
-class ArmPlatformDebugger:
-    system_table = None
-    firmware_volumes = {}
-    
-    REGION_TYPE_SYSMEM = 1
-    REGION_TYPE_ROM    = 2
-    REGION_TYPE_FV     = 3
-    
-    def __init__(self, ec, report_log, regions):
-        self.ec = ec
-        fvs = []
-        sysmem_base = None
-        sysmem_size = None
-        
-        if report_log and os.path.isfile(report_log):
-            try:
-                self.build = build_report.BuildReport(report_log)
-            except IOError:
-                raise IOError(2, 'Report \'%s\' isnot valid' % report_log)
-            
-            # Generate list of supported Firmware Volumes
-            if self.build.PCDs['gArmTokenSpaceGuid'].has_key('PcdFvSize') and int(self.build.PCDs['gArmTokenSpaceGuid']['PcdFvSize'][0],16) != 0:
-                fvs.append((int(self.build.PCDs['gArmTokenSpaceGuid']['PcdFvBaseAddress'][0],16),int(self.build.PCDs['gArmTokenSpaceGuid']['PcdFvSize'][0],16)))
-            if self.build.PCDs['gArmTokenSpaceGuid'].has_key('PcdSecureFvSize') and int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSecureFvSize'][0],16) != 0:
-                fvs.append((int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSecureFvBaseAddress'][0],16),int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSecureFvSize'][0],16)))
-            if self.build.PCDs['gArmTokenSpaceGuid'].has_key('PcdHypFvSize') and int(self.build.PCDs['gArmTokenSpaceGuid']['PcdHypFvSize'][0],16) != 0:
-                fvs.append((int(self.build.PCDs['gArmTokenSpaceGuid']['PcdHypFvBaseAddress'][0],16),int(self.build.PCDs['gArmTokenSpaceGuid']['PcdHypFvSize'][0],16)))
-            
-            sysmem_base = int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSystemMemoryBase'][0],16)
-            sysmem_size = int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSystemMemorySize'][0],16)
-        else:
-            for region in regions:
-                if region[0] == ArmPlatformDebugger.REGION_TYPE_SYSMEM:
-                    sysmem_base = region[1]
-                    sysmem_size = region[2]
-                elif region[0] == ArmPlatformDebugger.REGION_TYPE_FV:
-                    fvs.append((region[1],region[2]))
-                elif region[0] == ArmPlatformDebugger.REGION_TYPE_ROM:
-                    for base in xrange(region[1], region[1] + region[2], 0x400000):
-                        signature = struct.unpack("cccc", self.ec.getMemoryService().read(base, 4, 32))
-                        if signature == FirmwareVolume.CONST_FV_SIGNATURE:
-                            fvs.append((base,0))
-                else:
-                    print "Region type '%d' Not Supported" % region[0]
-                    
-        self.platform = ArmPlatform(sysmem_base, sysmem_size, fvs)
-        
-    def in_sysmem(self, addr):
-        return (self.platform.sysmembase is not None) and (self.platform.sysmembase <= addr) and (addr < self.platform.sysmembase + self.platform.sysmemsize)
-
-    def in_fv(self, addr):
-        return (self.get_fv_at(addr) != None)
-
-    def get_fv_at(self, addr):
-        for fv in self.platform.fvs:
-            if (fv[0] <= addr) and (addr < fv[0] + fv[1]):
-                return fv
-        return None
-
-    def load_current_symbols(self):
-        pc = int(self.ec.getRegisterService().getValue('PC')) & 0xFFFFFFFF
-        if self.in_fv(pc):
-            debug_infos = []
-            
-            (fv_base, fv_size) = self.get_fv_at(pc)
-            
-            if self.firmware_volumes.has_key(fv_base) == False:
-                self.firmware_volumes[fv_base] = firmware_volume.FirmwareVolume(self.ec, fv_base, fv_size)
-                
-            stack_frame = self.ec.getTopLevelStackFrame()
-            info = self.firmware_volumes[fv_base].load_symbols_at(int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF)
-            debug_infos.append(info)
-            while stack_frame.next() is not None:
-                stack_frame = stack_frame.next()
-                
-                # Stack frame attached to 'PC'
-                pc = int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF
-                
-                # Check if the symbols for this stack frame have already been loaded
-                found = False
-                for debug_info in debug_infos:
-                    if (pc >= debug_info[0]) and (pc < debug_info[0] + debug_info[1]):
-                        found = True
-                if found == False:
-                    info = self.firmware_volumes[fv_base].load_symbols_at(pc)
-                    debug_infos.append(info)
-                    
-            #self.firmware_volumes[fv_base].load_symbols_at(pc)
-        elif self.in_sysmem(pc):
-            debug_infos = []
-            
-            if self.system_table is None:
-                # Find the System Table
-                self.system_table = system_table.SystemTable(self.ec, self.platform.sysmembase, self.platform.sysmemsize)
-                
-                # Find the Debug Info Table
-                debug_info_table_base = self.system_table.get_configuration_table(system_table.DebugInfoTable.CONST_DEBUG_INFO_TABLE_GUID)
-                self.debug_info_table = system_table.DebugInfoTable(self.ec, debug_info_table_base)
-                
-            stack_frame = self.ec.getTopLevelStackFrame()
-            info = self.debug_info_table.load_symbols_at(int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF)
-            debug_infos.append(info)
-            while stack_frame.next() is not None:
-                stack_frame = stack_frame.next()
-                
-                # Stack frame attached to 'PC'
-                pc = int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF
-                
-                # Check if the symbols for this stack frame have already been loaded
-                found = False
-                for debug_info in debug_infos:
-                    if (pc >= debug_info[0]) and (pc < debug_info[0] + debug_info[1]):
-                        found = True
-                if found == False:
-                    info = self.debug_info_table.load_symbols_at(pc)
-                    debug_infos.append(info)
-                
-            #self.debug_info_table.load_symbols_at(pc)
-        else:
-            raise Exception('ArmPlatformDebugger', "Not supported region")
-        
-    def load_all_symbols(self):
-        # Load all the XIP symbols attached to the Firmware Volume
-        for (fv_base, fv_size) in self.platform.fvs:
-            if self.firmware_volumes.has_key(fv_base) == False:
-                self.firmware_volumes[fv_base] = firmware_volume.FirmwareVolume(self.ec, fv_base, fv_size)    
-            self.firmware_volumes[fv_base].load_all_symbols()
-
-        try:
-            # Load all symbols of module loaded into System Memory
-            if self.system_table is None:
-                # Find the System Table
-                self.system_table = system_table.SystemTable(self.ec, self.platform.sysmembase, self.platform.sysmemsize)
-        
-                
-                # Find the Debug Info Table
-                debug_info_table_base = self.system_table.get_configuration_table(system_table.DebugInfoTable.CONST_DEBUG_INFO_TABLE_GUID)
-                self.debug_info_table = system_table.DebugInfoTable(self.ec, debug_info_table_base)
-            
-            self.debug_info_table.load_all_symbols()
-        except:
-            # Debugger exception could be excepted if DRAM has not been initialized or if we have not started to run from DRAM yet
-            print "Note: no symbols have been found in System Memory (possible cause: the UEFI permanent memory has been installed yet)"
-            pass
+#

+#  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

+#  

+#  This program and the accompanying materials                          

+#  are licensed and made available under the terms and conditions of the BSD License         

+#  which accompanies this distribution.  The full text of the license may be found at        

+#  http://opensource.org/licenses/bsd-license.php                                            

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+#

+

+import os

+

+import firmware_volume

+import build_report

+import system_table

+

+# Reload external classes

+reload(firmware_volume)

+reload(build_report)

+reload(system_table)

+

+def readMem32(executionContext, address):

+    bytes = executionContext.getMemoryService().read(address, 4, 32)

+    return struct.unpack('<I',bytes)[0]

+

+def dump_fv(ec, fv_base, fv_size):

+    fv = firmware_volume.FirmwareVolume(ec,

+                                        int(build.PCDs['gArmTokenSpaceGuid']['PcdFvBaseAddress'][0],16),

+                                        int(build.PCDs['gArmTokenSpaceGuid']['PcdFvSize'][0],16))

+    

+    ffs = fv.get_next_ffs()

+    while ffs != None:    

+        print "# %s" % ffs

+    

+        section = ffs.get_next_section()

+        while section != None:

+            print "\t%s" % section

+            try:

+                print "\t\t- %s" % section.get_debug_filepath()

+            except Exception:

+                pass

+            section = ffs.get_next_section(section)

+            

+        ffs = fv.get_next_ffs(ffs)

+

+def dump_system_table(ec, mem_base, mem_size):

+    st = system_table.SystemTable(ec, mem_base, mem_size)

+    

+    debug_info_table_base = st.get_configuration_table(system_table.DebugInfoTable.CONST_DEBUG_INFO_TABLE_GUID)

+    

+    debug_info_table = system_table.DebugInfoTable(ec, debug_info_table_base)

+    debug_info_table.dump()

+

+def load_symbol_from_file(ec, filename, address, verbose = False):

+    if verbose:

+        print "Add symbols of %s at 0x%x" % (filename, address)

+        

+    try:

+        ec.getImageService().addSymbols(filename, address)

+    except:

+        try:

+            # We could get an exception if the symbols are already loaded

+            ec.getImageService().unloadSymbols(filename)

+            ec.getImageService().addSymbols(filename, address)

+        except:

+            print "Warning: not possible to load symbols from %s at 0x%x" % (filename, address)

+            pass

+

+class ArmPlatform:

+    def __init__(self, sysmembase=None, sysmemsize=None, fvs={}):

+        self.sysmembase = sysmembase

+        self.sysmemsize = sysmemsize

+        self.fvs = fvs

+        

+class ArmPlatformDebugger:

+    system_table = None

+    firmware_volumes = {}

+    

+    REGION_TYPE_SYSMEM = 1

+    REGION_TYPE_ROM    = 2

+    REGION_TYPE_FV     = 3

+    

+    def __init__(self, ec, report_log, regions, verbose = False):

+        self.ec = ec

+        self.verbose = verbose

+        fvs = []

+        sysmem_base = None

+        sysmem_size = None

+        

+        if report_log and os.path.isfile(report_log):

+            try:

+                self.build = build_report.BuildReport(report_log)

+            except IOError:

+                raise IOError(2, 'Report \'%s\' is not valid' % report_log)

+            

+            # Generate list of supported Firmware Volumes

+            if self.build.PCDs['gArmTokenSpaceGuid'].has_key('PcdFvSize') and int(self.build.PCDs['gArmTokenSpaceGuid']['PcdFvSize'][0],16) != 0:

+                fvs.append((int(self.build.PCDs['gArmTokenSpaceGuid']['PcdFvBaseAddress'][0],16),int(self.build.PCDs['gArmTokenSpaceGuid']['PcdFvSize'][0],16)))

+            if self.build.PCDs['gArmTokenSpaceGuid'].has_key('PcdSecureFvSize') and int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSecureFvSize'][0],16) != 0:

+                fvs.append((int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSecureFvBaseAddress'][0],16),int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSecureFvSize'][0],16)))

+            if self.build.PCDs['gArmTokenSpaceGuid'].has_key('PcdHypFvSize') and int(self.build.PCDs['gArmTokenSpaceGuid']['PcdHypFvSize'][0],16) != 0:

+                fvs.append((int(self.build.PCDs['gArmTokenSpaceGuid']['PcdHypFvBaseAddress'][0],16),int(self.build.PCDs['gArmTokenSpaceGuid']['PcdHypFvSize'][0],16)))

+            

+            sysmem_base = int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSystemMemoryBase'][0],16)

+            sysmem_size = int(self.build.PCDs['gArmTokenSpaceGuid']['PcdSystemMemorySize'][0],16)

+        else:

+            for region in regions:

+                if region[0] == ArmPlatformDebugger.REGION_TYPE_SYSMEM:

+                    sysmem_base = region[1]

+                    sysmem_size = region[2]

+                elif region[0] == ArmPlatformDebugger.REGION_TYPE_FV:

+                    fvs.append((region[1],region[2]))

+                elif region[0] == ArmPlatformDebugger.REGION_TYPE_ROM:

+                    for base in xrange(region[1], region[1] + region[2], 0x400000):

+                        signature = struct.unpack("cccc", self.ec.getMemoryService().read(base, 4, 32))

+                        if signature == FirmwareVolume.CONST_FV_SIGNATURE:

+                            fvs.append((base,0))

+                else:

+                    print "Region type '%d' Not Supported" % region[0]

+                    

+        self.platform = ArmPlatform(sysmem_base, sysmem_size, fvs)

+        

+    def in_sysmem(self, addr):

+        return (self.platform.sysmembase is not None) and (self.platform.sysmembase <= addr) and (addr < self.platform.sysmembase + self.platform.sysmemsize)

+

+    def in_fv(self, addr):

+        return (self.get_fv_at(addr) != None)

+

+    def get_fv_at(self, addr):

+        for fv in self.platform.fvs:

+            if (fv[0] <= addr) and (addr < fv[0] + fv[1]):

+                return fv

+        return None

+

+    def load_current_symbols(self):

+        pc = int(self.ec.getRegisterService().getValue('PC')) & 0xFFFFFFFF

+        if self.in_fv(pc):

+            debug_infos = []

+            

+            (fv_base, fv_size) = self.get_fv_at(pc)

+            

+            if self.firmware_volumes.has_key(fv_base) == False:

+                self.firmware_volumes[fv_base] = firmware_volume.FirmwareVolume(self.ec, fv_base, fv_size)

+                

+            stack_frame = self.ec.getTopLevelStackFrame()

+            info = self.firmware_volumes[fv_base].load_symbols_at(int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF, self.verbose)

+            debug_infos.append(info)

+            while stack_frame.next() is not None:

+                stack_frame = stack_frame.next()

+                

+                # Stack frame attached to 'PC'

+                pc = int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF

+                

+                # Check if the symbols for this stack frame have already been loaded

+                found = False

+                for debug_info in debug_infos:

+                    if (pc >= debug_info[0]) and (pc < debug_info[0] + debug_info[1]):

+                        found = True

+                if found == False:

+                    info = self.firmware_volumes[fv_base].load_symbols_at(pc)

+                    debug_infos.append(info)

+                    

+            #self.firmware_volumes[fv_base].load_symbols_at(pc)

+        elif self.in_sysmem(pc):

+            debug_infos = []

+            

+            if self.system_table is None:

+                # Find the System Table

+                self.system_table = system_table.SystemTable(self.ec, self.platform.sysmembase, self.platform.sysmemsize)

+                

+                # Find the Debug Info Table

+                debug_info_table_base = self.system_table.get_configuration_table(system_table.DebugInfoTable.CONST_DEBUG_INFO_TABLE_GUID)

+                self.debug_info_table = system_table.DebugInfoTable(self.ec, debug_info_table_base)

+                

+            stack_frame = self.ec.getTopLevelStackFrame()

+            info = self.debug_info_table.load_symbols_at(int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF, self.verbose)

+            debug_infos.append(info)

+            while stack_frame.next() is not None:

+                stack_frame = stack_frame.next()

+                

+                # Stack frame attached to 'PC'

+                pc = int(stack_frame.getRegisterService().getValue('PC')) & 0xFFFFFFFF

+                

+                # Check if the symbols for this stack frame have already been loaded

+                found = False

+                for debug_info in debug_infos:

+                    if (pc >= debug_info[0]) and (pc < debug_info[0] + debug_info[1]):

+                        found = True

+                if found == False:

+                    info = self.debug_info_table.load_symbols_at(pc)

+                    debug_infos.append(info)

+                

+            #self.debug_info_table.load_symbols_at(pc)

+        else:

+            raise Exception('ArmPlatformDebugger', "Not supported region")

+        

+    def load_all_symbols(self):

+        # Load all the XIP symbols attached to the Firmware Volume

+        for (fv_base, fv_size) in self.platform.fvs:

+            if self.firmware_volumes.has_key(fv_base) == False:

+                self.firmware_volumes[fv_base] = firmware_volume.FirmwareVolume(self.ec, fv_base, fv_size)    

+            self.firmware_volumes[fv_base].load_all_symbols(self.verbose)

+

+        try:

+            # Load all symbols of module loaded into System Memory

+            if self.system_table is None:

+                # Find the System Table

+                self.system_table = system_table.SystemTable(self.ec, self.platform.sysmembase, self.platform.sysmemsize)

+        

+                

+                # Find the Debug Info Table

+                debug_info_table_base = self.system_table.get_configuration_table(system_table.DebugInfoTable.CONST_DEBUG_INFO_TABLE_GUID)

+                self.debug_info_table = system_table.DebugInfoTable(self.ec, debug_info_table_base)

+            

+            self.debug_info_table.load_all_symbols(self.verbose)

+        except:

+            # Debugger exception could be excepted if DRAM has not been initialized or if we have not started to run from DRAM yet

+            print "Note: no symbols have been found in System Memory (possible cause: the UEFI permanent memory has been installed yet)"

+            pass

diff --git a/ArmPlatformPkg/Scripts/Ds5/firmware_volume.py b/ArmPlatformPkg/Scripts/Ds5/firmware_volume.py
index c4e02ece..651c748a 100644
--- a/ArmPlatformPkg/Scripts/Ds5/firmware_volume.py
+++ b/ArmPlatformPkg/Scripts/Ds5/firmware_volume.py
@@ -1,301 +1,312 @@
-#
-#  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-#  
-#  This program and the accompanying materials                          
-#  are licensed and made available under the terms and conditions of the BSD License         
-#  which accompanies this distribution.  The full text of the license may be found at        
-#  http://opensource.org/licenses/bsd-license.php                                            
-#
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-#
-
-from arm_ds.debugger_v1 import DebugException
-
-import struct
-import string
-
-import edk2_debugger
-    
-class EfiFileSection(object):
-    EFI_SECTION_PE32                  = 0x10
-    EFI_SECTION_PIC                   = 0x11
-    EFI_SECTION_TE                    = 0x12
-    
-    EFI_IMAGE_DEBUG_TYPE_CODEVIEW     = 0x2
-    
-    SIZEOF_EFI_FFS_FILE_HEADER        = 0x28
-
-    def __init__(self, ec, base):
-        self.base = base
-        self.ec = ec
-        
-    def __str__(self):
-        return "FileSection(type:0x%X, size:0x%x)" % (self.get_type(), self.get_size())
-        
-    def get_base(self):
-        return self.base
- 
-    def get_type(self):
-        return struct.unpack("B", self.ec.getMemoryService().read(self.base + 0x3, 1, 8))[0]
-       
-    def get_size(self):
-        return (struct.unpack("<I", self.ec.getMemoryService().read(self.base, 4, 32))[0] & 0x00ffffff)
-
-    def get_debug_filepath(self):
-        type = self.get_type()
-        if type == EfiFileSection.EFI_SECTION_TE:
-            section = EfiSectionTE(self, ec, self.base + 0x4)
-        elif type == EfiFileSection.EFI_SECTION_PE32:
-            section = EfiSectionPE32(self, ec, self.base + 0x4)
-        else:
-            raise Exception("EfiFileSection", "No debug section")
-        return section.get_debug_filepath()
-
-class EfiSectionTE:
-    SIZEOF_EFI_TE_IMAGE_HEADER        = 0x28
-    EFI_TE_IMAGE_SIGNATURE            = ('V','Z')
-    
-    def __init__(self, ec, base_te):
-        self.ec = ec
-        self.base_te = int(base_te)
-        te_sig = struct.unpack("cc", self.ec.getMemoryService().read(self.base_te, 2, 32))
-        if te_sig != EfiSectionTE.EFI_TE_IMAGE_SIGNATURE:
-            raise Exception("EfiFileSectionTE","TE Signature incorrect")
-        
-    def get_debug_filepath(self):
-        stripped_size = struct.unpack("<H", self.ec.getMemoryService().read(self.base_te + 0x6, 2, 32))[0]
-        stripped_size -= EfiSectionTE.SIZEOF_EFI_TE_IMAGE_HEADER
-        
-        debug_dir_entry_rva = self.ec.getMemoryService().readMemory32(self.base_te + 0x20)
-        if debug_dir_entry_rva == 0:
-            raise Exception("EfiFileSectionTE","No debug directory for image")
-        debug_dir_entry_rva -= stripped_size
-        
-        debug_type = self.ec.getMemoryService().readMemory32(self.base_te + debug_dir_entry_rva + 0xC)
-        if (debug_type != 0xdf) and (debug_type != EfiFileSection.EFI_IMAGE_DEBUG_TYPE_CODEVIEW):
-            raise Exception("EfiFileSectionTE","Debug type is not dwarf")
-
-        debug_rva = self.ec.getMemoryService().readMemory32(self.base_te + debug_dir_entry_rva + 0x14)
-        debug_rva -= stripped_size
-
-        dwarf_sig = struct.unpack("cccc", self.ec.getMemoryService().read(self.base_te + debug_rva, 4, 32))
-        if (dwarf_sig != 0x66727764) and (dwarf_sig != FirmwareFile.CONST_NB10_SIGNATURE):
-            raise Exception("EfiFileSectionTE","Dwarf debug signature not found")
-        
-        if dwarf_sig == 0x66727764:
-            filename = self.base_te + debug_rva + 0xc
-        else:
-            filename = self.base_te + debug_rva + 0x10
-        filename = struct.unpack("200s", self.ec.getMemoryService().read(filename, 200, 32))[0]
-        return filename[0:string.find(filename,'\0')]
-        
-    def get_debug_elfbase(self):
-        stripped_size = struct.unpack("<H", self.ec.getMemoryService().read(self.base_te + 0x6, 2, 32))[0]
-        stripped_size -= EfiSectionTE.SIZEOF_EFI_TE_IMAGE_HEADER
-        
-        base_of_code = self.ec.getMemoryService().readMemory32(self.base_te + 0xC)
-        
-        return self.base_te + base_of_code - stripped_size
-
-class EfiSectionPE32:
-    def __init__(self, ec, base_pe32):
-        self.ec = ec
-        self.base_pe32 = base_pe32
-
-    def get_debug_filepath(self):
-        # Offset from dos hdr to PE file hdr
-        file_header_offset = self.ec.getMemoryService().readMemory32(self.base_pe32 + 0x3C)
-
-        # Offset to debug dir in PE hdrs
-        debug_dir_entry_rva = self.ec.getMemoryService().readMemory32(self.base_pe32 + file_header_offset + 0xA8)
-        if debug_dir_entry_rva == 0:
-            raise Exception("EfiFileSectionPE32","No Debug Directory")
-
-        debug_type = self.ec.getMemoryService().readMemory32(self.base_pe32 + debug_dir_entry_rva + 0xC)
-        if (debug_type != 0xdf) and (debug_type != EfiFileSection.EFI_IMAGE_DEBUG_TYPE_CODEVIEW):
-            raise Exception("EfiFileSectionPE32","Debug type is not dwarf")
-        
-        
-        debug_rva = self.ec.getMemoryService().readMemory32(self.base_pe32 + debug_dir_entry_rva + 0x14)
-        
-        dwarf_sig = struct.unpack("cccc", self.ec.getMemoryService().read(str(self.base_pe32 + debug_rva), 4, 32))
-        if (dwarf_sig != 0x66727764) and (dwarf_sig != FirmwareFile.CONST_NB10_SIGNATURE):
-            raise Exception("EfiFileSectionPE32","Dwarf debug signature not found")
-    
-        if dwarf_sig == 0x66727764:
-            filename = self.base_pe32 + debug_rva + 0xc
-        else:
-            filename = self.base_pe32 + debug_rva + 0x10
-        filename = struct.unpack("200s", self.ec.getMemoryService().read(str(filename), 200, 32))[0]
-        return filename[0:string.find(filename,'\0')]
-    
-    def get_debug_elfbase(self):
-        # Offset from dos hdr to PE file hdr
-        pe_file_header = self.base_pe32 + self.ec.getMemoryService().readMemory32(self.base_pe32 + 0x3C)
-        
-        base_of_code = self.base_pe32 + self.ec.getMemoryService().readMemory32(pe_file_header + 0x28)
-        base_of_data = self.base_pe32 + self.ec.getMemoryService().readMemory32(pe_file_header + 0x2C)
-        
-        if (base_of_code < base_of_data) and (base_of_code != 0):
-            return base_of_code
-        else:
-            return base_of_data       
-    
-class FirmwareFile:
-    EFI_FV_FILETYPE_RAW                   = 0x01
-    EFI_FV_FILETYPE_FREEFORM              = 0x02
-    EFI_FV_FILETYPE_SECURITY_CORE         = 0x03
-    EFI_FV_FILETYPE_PEI_CORE              = 0x04
-    EFI_FV_FILETYPE_DXE_CORE              = 0x05
-    EFI_FV_FILETYPE_PEIM                  = 0x06
-    EFI_FV_FILETYPE_DRIVER                = 0x07
-    EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER  = 0x08
-    EFI_FV_FILETYPE_APPLICATION           = 0x09
-    EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE = 0x0B
-    EFI_FV_FILETYPE_FFS_MIN               = 0xF0
-    
-    CONST_NB10_SIGNATURE = ('N','B','1','0')
-    
-    def __init__(self, fv, base, ec):
-        self.fv = fv
-        self.base = base
-        self.ec = ec
-        
-    def __str__(self):
-        return "FFS(state:0x%x, type:0x%X, size:0x%x)" % (self.get_state(), self.get_type(), self.get_size())
-    
-    def get_base(self):
-        return self.base
-    
-    def get_size(self):
-        size = (self.ec.getMemoryService().readMemory32(self.base + 0x14) & 0x00ffffff)
-
-        # Occupied size is the size considering the alignment
-        return size + ((0x8 - (size & 0x7)) & 0x7)
-    
-    def get_type(self):
-        return self.ec.getMemoryService().readMemory8(self.base + 0x12)
-     
-    def get_state(self):
-        state = self.ec.getMemoryService().readMemory8(self.base + 0x17)
-        
-        polarity = self.fv.get_polarity()
-        if polarity:
-            state = ~state
-            
-        highest_bit = 0x80;
-        while (highest_bit != 0) and ((highest_bit & state) == 0):
-            highest_bit >>= 1
-            
-        return highest_bit
-    
-    def get_next_section(self, section=None):
-        if section == None:
-            if self.get_type() != FirmwareFile.EFI_FV_FILETYPE_FFS_MIN:
-                section_base = self.get_base() + 0x18;
-            else:
-                return None
-        else:
-            section_base = int(section.get_base() + section.get_size())
-            
-            # Align to next 4 byte boundary
-            if (section_base & 0x3) != 0:
-                section_base = section_base + 0x4 - (section_base & 0x3)
-
-        if section_base < self.get_base() + self.get_size():
-            return EfiFileSection(self.ec, section_base)
-        else:
-            return None
-    
-class FirmwareVolume:
-    CONST_FV_SIGNATURE = ('_','F','V','H')
-    EFI_FVB2_ERASE_POLARITY = 0x800
-    
-    DebugInfos = []
-    
-    def __init__(self, ec, fv_base, fv_size):
-        self.ec = ec
-        self.fv_base = fv_base
-        self.fv_size = fv_size
-        
-        try:
-            signature = struct.unpack("cccc", self.ec.getMemoryService().read(fv_base + 0x28, 4, 32))
-        except DebugException:
-            raise Exception("FirmwareVolume", "Not possible to access the defined firmware volume at [0x%X,0x%X]. Could be the used build report does not correspond to your current debugging context." % (int(fv_base),int(fv_base+fv_size)))
-        if signature != FirmwareVolume.CONST_FV_SIGNATURE:
-            raise Exception("FirmwareVolume", "This is not a valid firmware volume")
-      
-    def get_size(self):
-        return self.ec.getMemoryService().readMemory32(self.fv_base + 0x20)
-    
-    def get_attributes(self):
-        return self.ec.getMemoryService().readMemory32(self.fv_base + 0x2C)
-    
-    def get_polarity(self):
-        attributes = self.get_attributes()
-        if attributes & FirmwareVolume.EFI_FVB2_ERASE_POLARITY:
-            return 1
-        else:
-            return 0
-    
-    def get_next_ffs(self, ffs=None):
-        if ffs == None:
-            # Get the offset of the first FFS file from the FV header
-            ffs_base = self.fv_base +  self.ec.getMemoryService().readMemory16(self.fv_base + 0x30)
-        else:
-            # Goto the next FFS file
-            ffs_base = int(ffs.get_base() + ffs.get_size())
-            
-            # Align to next 8 byte boundary
-            if (ffs_base & 0x7) != 0:
-                ffs_base = ffs_base + 0x8 - (ffs_base & 0x7)
-                
-        if ffs_base < self.fv_base + self.get_size():
-            return FirmwareFile(self, ffs_base, self.ec)
-        else:
-            return None
-        
-    def get_debug_info(self):        
-        self.DebugInfos = []
-        
-        ffs = self.get_next_ffs()
-        while ffs != None:            
-            section = ffs.get_next_section()
-            while section != None:
-                type = section.get_type()
-                if (type == EfiFileSection.EFI_SECTION_TE) or (type == EfiFileSection.EFI_SECTION_PE32):
-                    self.DebugInfos.append((section.get_base(), section.get_size(), section.get_type()))
-                section = ffs.get_next_section(section)
-            ffs = self.get_next_ffs(ffs)
-
-    def load_symbols_at(self, addr):
-        if self.DebugInfos == []:
-            self.get_debug_info()
-        
-        for debug_info in self.DebugInfos:
-            if (addr >= debug_info[0]) and (addr < debug_info[0] + debug_info[1]):
-                if debug_info[2] == EfiFileSection.EFI_SECTION_TE:
-                    section = EfiSectionTE(self.ec, debug_info[0] + 0x4)
-                elif debug_info[2] == EfiFileSection.EFI_SECTION_PE32:
-                    section = EfiSectionPE32(self.ec, debug_info[0] + 0x4)
-                else:
-                    raise Exception('FirmwareVolume','Section Type not supported')
-                
-                edk2_debugger.load_symbol_from_file(self.ec, section.get_debug_filepath(), section.get_debug_elfbase())
-
-                return debug_info
-
-    def load_all_symbols(self):
-        if self.DebugInfos == []:
-            self.get_debug_info()
-        
-        for debug_info in self.DebugInfos:
-            if debug_info[2] == EfiFileSection.EFI_SECTION_TE:
-                section = EfiSectionTE(self.ec, debug_info[0] + 0x4)
-            elif debug_info[2] == EfiFileSection.EFI_SECTION_PE32:
-                section = EfiSectionPE32(self.ec, debug_info[0] + 0x4)
-            else:
-                continue
-            
-            edk2_debugger.load_symbol_from_file(self.ec, section.get_debug_filepath(), section.get_debug_elfbase())
+#

+#  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

+#  

+#  This program and the accompanying materials                          

+#  are licensed and made available under the terms and conditions of the BSD License         

+#  which accompanies this distribution.  The full text of the license may be found at        

+#  http://opensource.org/licenses/bsd-license.php                                            

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+#

+

+from arm_ds.debugger_v1 import DebugException

+

+import struct

+import string

+

+import edk2_debugger

+    

+class EfiFileSection(object):

+    EFI_SECTION_PE32                  = 0x10

+    EFI_SECTION_PIC                   = 0x11

+    EFI_SECTION_TE                    = 0x12

+    

+    EFI_IMAGE_DEBUG_TYPE_CODEVIEW     = 0x2

+    

+    SIZEOF_EFI_FFS_FILE_HEADER        = 0x28

+

+    def __init__(self, ec, base):

+        self.base = base

+        self.ec = ec

+        

+    def __str__(self):

+        return "FileSection(type:0x%X, size:0x%x)" % (self.get_type(), self.get_size())

+        

+    def get_base(self):

+        return self.base

+ 

+    def get_type(self):

+        return struct.unpack("B", self.ec.getMemoryService().read(self.base + 0x3, 1, 8))[0]

+       

+    def get_size(self):

+        return (struct.unpack("<I", self.ec.getMemoryService().read(self.base, 4, 32))[0] & 0x00ffffff)

+

+    def get_debug_filepath(self):

+        type = self.get_type()

+        if type == EfiFileSection.EFI_SECTION_TE:

+            section = EfiSectionTE(self, ec, self.base + 0x4)

+        elif type == EfiFileSection.EFI_SECTION_PE32:

+            section = EfiSectionPE32(self, ec, self.base + 0x4)

+        else:

+            raise Exception("EfiFileSection", "No debug section")

+        return section.get_debug_filepath()

+

+class EfiSectionTE:

+    SIZEOF_EFI_TE_IMAGE_HEADER        = 0x28

+    EFI_TE_IMAGE_SIGNATURE            = ('V','Z')

+    

+    def __init__(self, ec, base_te):

+        self.ec = ec

+        self.base_te = int(base_te)

+        te_sig = struct.unpack("cc", self.ec.getMemoryService().read(self.base_te, 2, 32))

+        if te_sig != EfiSectionTE.EFI_TE_IMAGE_SIGNATURE:

+            raise Exception("EfiFileSectionTE","TE Signature incorrect")

+        

+    def get_debug_filepath(self):

+        stripped_size = struct.unpack("<H", self.ec.getMemoryService().read(self.base_te + 0x6, 2, 32))[0]

+        stripped_size -= EfiSectionTE.SIZEOF_EFI_TE_IMAGE_HEADER

+        

+        debug_dir_entry_rva = self.ec.getMemoryService().readMemory32(self.base_te + 0x20)

+        if debug_dir_entry_rva == 0:

+            raise Exception("EfiFileSectionTE","No debug directory for image")

+        debug_dir_entry_rva -= stripped_size

+        

+        debug_type = self.ec.getMemoryService().readMemory32(self.base_te + debug_dir_entry_rva + 0xC)

+        if (debug_type != 0xdf) and (debug_type != EfiFileSection.EFI_IMAGE_DEBUG_TYPE_CODEVIEW):

+            raise Exception("EfiFileSectionTE","Debug type is not dwarf")

+

+        debug_rva = self.ec.getMemoryService().readMemory32(self.base_te + debug_dir_entry_rva + 0x14)

+        debug_rva -= stripped_size

+

+        dwarf_sig = struct.unpack("cccc", self.ec.getMemoryService().read(self.base_te + debug_rva, 4, 32))

+        if (dwarf_sig != 0x66727764) and (dwarf_sig != FirmwareFile.CONST_NB10_SIGNATURE):

+            raise Exception("EfiFileSectionTE","Dwarf debug signature not found")

+        

+        if dwarf_sig == 0x66727764:

+            filename = self.base_te + debug_rva + 0xc

+        else:

+            filename = self.base_te + debug_rva + 0x10

+        filename = struct.unpack("200s", self.ec.getMemoryService().read(filename, 200, 32))[0]

+        return filename[0:string.find(filename,'\0')]

+        

+    def get_debug_elfbase(self):

+        stripped_size = struct.unpack("<H", self.ec.getMemoryService().read(self.base_te + 0x6, 2, 32))[0]

+        stripped_size -= EfiSectionTE.SIZEOF_EFI_TE_IMAGE_HEADER

+        

+        base_of_code = self.ec.getMemoryService().readMemory32(self.base_te + 0xC)

+        

+        return self.base_te + base_of_code - stripped_size

+

+class EfiSectionPE32:

+    def __init__(self, ec, base_pe32):

+        self.ec = ec

+        self.base_pe32 = base_pe32

+

+    def get_debug_filepath(self):

+        # Offset from dos hdr to PE file hdr

+        file_header_offset = self.ec.getMemoryService().readMemory32(self.base_pe32 + 0x3C)

+

+        # Offset to debug dir in PE hdrs

+        debug_dir_entry_rva = self.ec.getMemoryService().readMemory32(self.base_pe32 + file_header_offset + 0xA8)

+        if debug_dir_entry_rva == 0:

+            raise Exception("EfiFileSectionPE32","No Debug Directory")

+

+        debug_type = self.ec.getMemoryService().readMemory32(self.base_pe32 + debug_dir_entry_rva + 0xC)

+        if (debug_type != 0xdf) and (debug_type != EfiFileSection.EFI_IMAGE_DEBUG_TYPE_CODEVIEW):

+            raise Exception("EfiFileSectionPE32","Debug type is not dwarf")

+        

+        

+        debug_rva = self.ec.getMemoryService().readMemory32(self.base_pe32 + debug_dir_entry_rva + 0x14)

+        

+        dwarf_sig = struct.unpack("cccc", self.ec.getMemoryService().read(str(self.base_pe32 + debug_rva), 4, 32))

+        if (dwarf_sig != 0x66727764) and (dwarf_sig != FirmwareFile.CONST_NB10_SIGNATURE):

+            raise Exception("EfiFileSectionPE32","Dwarf debug signature not found")

+    

+        if dwarf_sig == 0x66727764:

+            filename = self.base_pe32 + debug_rva + 0xc

+        else:

+            filename = self.base_pe32 + debug_rva + 0x10

+        filename = struct.unpack("200s", self.ec.getMemoryService().read(str(filename), 200, 32))[0]

+        return filename[0:string.find(filename,'\0')]

+    

+    def get_debug_elfbase(self):

+        # Offset from dos hdr to PE file hdr

+        pe_file_header = self.base_pe32 + self.ec.getMemoryService().readMemory32(self.base_pe32 + 0x3C)

+        

+        base_of_code = self.base_pe32 + self.ec.getMemoryService().readMemory32(pe_file_header + 0x28)

+        base_of_data = self.base_pe32 + self.ec.getMemoryService().readMemory32(pe_file_header + 0x2C)

+        

+        if (base_of_code < base_of_data) and (base_of_code != 0):

+            return base_of_code

+        else:

+            return base_of_data       

+    

+class FirmwareFile:

+    EFI_FV_FILETYPE_RAW                   = 0x01

+    EFI_FV_FILETYPE_FREEFORM              = 0x02

+    EFI_FV_FILETYPE_SECURITY_CORE         = 0x03

+    EFI_FV_FILETYPE_PEI_CORE              = 0x04

+    EFI_FV_FILETYPE_DXE_CORE              = 0x05

+    EFI_FV_FILETYPE_PEIM                  = 0x06

+    EFI_FV_FILETYPE_DRIVER                = 0x07

+    EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER  = 0x08

+    EFI_FV_FILETYPE_APPLICATION           = 0x09

+    EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE = 0x0B

+    EFI_FV_FILETYPE_FFS_MIN               = 0xF0

+    

+    CONST_NB10_SIGNATURE = ('N','B','1','0')

+    

+    def __init__(self, fv, base, ec):

+        self.fv = fv

+        self.base = base

+        self.ec = ec

+        

+    def __str__(self):

+        return "FFS(state:0x%x, type:0x%X, size:0x%x)" % (self.get_state(), self.get_type(), self.get_size())

+    

+    def get_base(self):

+        return self.base

+    

+    def get_size(self):

+        size = (self.ec.getMemoryService().readMemory32(self.base + 0x14) & 0x00ffffff)

+

+        # Occupied size is the size considering the alignment

+        return size + ((0x8 - (size & 0x7)) & 0x7)

+    

+    def get_type(self):

+        return self.ec.getMemoryService().readMemory8(self.base + 0x12)

+     

+    def get_state(self):

+        state = self.ec.getMemoryService().readMemory8(self.base + 0x17)

+        

+        polarity = self.fv.get_polarity()

+        if polarity:

+            state = ~state

+            

+        highest_bit = 0x80;

+        while (highest_bit != 0) and ((highest_bit & state) == 0):

+            highest_bit >>= 1

+            

+        return highest_bit

+    

+    def get_next_section(self, section=None):

+        if section == None:

+            if self.get_type() != FirmwareFile.EFI_FV_FILETYPE_FFS_MIN:

+                section_base = self.get_base() + 0x18;

+            else:

+                return None

+        else:

+            section_base = int(section.get_base() + section.get_size())

+            

+            # Align to next 4 byte boundary

+            if (section_base & 0x3) != 0:

+                section_base = section_base + 0x4 - (section_base & 0x3)

+

+        if section_base < self.get_base() + self.get_size():

+            return EfiFileSection(self.ec, section_base)

+        else:

+            return None

+    

+class FirmwareVolume:

+    CONST_FV_SIGNATURE = ('_','F','V','H')

+    EFI_FVB2_ERASE_POLARITY = 0x800

+    

+    DebugInfos = []

+    

+    def __init__(self, ec, fv_base, fv_size):

+        self.ec = ec

+        self.fv_base = fv_base

+        self.fv_size = fv_size

+        

+        try:

+            signature = struct.unpack("cccc", self.ec.getMemoryService().read(fv_base + 0x28, 4, 32))

+        except DebugException:

+            raise Exception("FirmwareVolume", "Not possible to access the defined firmware volume at [0x%X,0x%X]. Could be the used build report does not correspond to your current debugging context." % (int(fv_base),int(fv_base+fv_size)))

+        if signature != FirmwareVolume.CONST_FV_SIGNATURE:

+            raise Exception("FirmwareVolume", "This is not a valid firmware volume")

+      

+    def get_size(self):

+        return self.ec.getMemoryService().readMemory32(self.fv_base + 0x20)

+    

+    def get_attributes(self):

+        return self.ec.getMemoryService().readMemory32(self.fv_base + 0x2C)

+    

+    def get_polarity(self):

+        attributes = self.get_attributes()

+        if attributes & FirmwareVolume.EFI_FVB2_ERASE_POLARITY:

+            return 1

+        else:

+            return 0

+    

+    def get_next_ffs(self, ffs=None):

+        if ffs == None:

+            # Get the offset of the first FFS file from the FV header

+            ffs_base = self.fv_base +  self.ec.getMemoryService().readMemory16(self.fv_base + 0x30)

+        else:

+            # Goto the next FFS file

+            ffs_base = int(ffs.get_base() + ffs.get_size())

+            

+            # Align to next 8 byte boundary

+            if (ffs_base & 0x7) != 0:

+                ffs_base = ffs_base + 0x8 - (ffs_base & 0x7)

+                

+        if ffs_base < self.fv_base + self.get_size():

+            return FirmwareFile(self, ffs_base, self.ec)

+        else:

+            return None

+        

+    def get_debug_info(self):        

+        self.DebugInfos = []

+        

+        ffs = self.get_next_ffs()

+        while ffs != None:            

+            section = ffs.get_next_section()

+            while section != None:

+                type = section.get_type()

+                if (type == EfiFileSection.EFI_SECTION_TE) or (type == EfiFileSection.EFI_SECTION_PE32):

+                    self.DebugInfos.append((section.get_base(), section.get_size(), section.get_type()))

+                section = ffs.get_next_section(section)

+            ffs = self.get_next_ffs(ffs)

+

+    def load_symbols_at(self, addr, verbose = False):

+        if self.DebugInfos == []:

+            self.get_debug_info()

+        

+        for debug_info in self.DebugInfos:

+            if (addr >= debug_info[0]) and (addr < debug_info[0] + debug_info[1]):

+                if debug_info[2] == EfiFileSection.EFI_SECTION_TE:

+                    section = EfiSectionTE(self.ec, debug_info[0] + 0x4)

+                elif debug_info[2] == EfiFileSection.EFI_SECTION_PE32:

+                    section = EfiSectionPE32(self.ec, debug_info[0] + 0x4)

+                else:

+                    raise Exception('FirmwareVolume','Section Type not supported')

+                

+                try:

+                    edk2_debugger.load_symbol_from_file(self.ec, section.get_debug_filepath(), section.get_debug_elfbase(), verbose)

+                except Exception, (ErrorClass, ErrorMessage):

+                    if verbose:

+                        print "Error while loading a symbol file (%s: %s)" % (ErrorClass, ErrorMessage)

+                    pass

+

+                return debug_info

+

+    def load_all_symbols(self, verbose = False):

+        if self.DebugInfos == []:

+            self.get_debug_info()

+        

+        for debug_info in self.DebugInfos:

+            if debug_info[2] == EfiFileSection.EFI_SECTION_TE:

+                section = EfiSectionTE(self.ec, debug_info[0] + 0x4)

+            elif debug_info[2] == EfiFileSection.EFI_SECTION_PE32:

+                section = EfiSectionPE32(self.ec, debug_info[0] + 0x4)

+            else:

+                continue

+            

+            try:

+                edk2_debugger.load_symbol_from_file(self.ec, section.get_debug_filepath(), section.get_debug_elfbase(), verbose)

+            except Exception, (ErrorClass, ErrorMessage):

+                if verbose:

+                    print "Error while loading a symbol file (%s: %s)" % (ErrorClass, ErrorMessage)

+                pass

+

diff --git a/ArmPlatformPkg/Scripts/Ds5/system_table.py b/ArmPlatformPkg/Scripts/Ds5/system_table.py
index f489e466..3e7f6ab0 100644
--- a/ArmPlatformPkg/Scripts/Ds5/system_table.py
+++ b/ArmPlatformPkg/Scripts/Ds5/system_table.py
@@ -1,129 +1,139 @@
-#
-#  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-#  
-#  This program and the accompanying materials                          
-#  are licensed and made available under the terms and conditions of the BSD License         
-#  which accompanies this distribution.  The full text of the license may be found at        
-#  http://opensource.org/licenses/bsd-license.php                                            
-#
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-#
-
-from arm_ds.debugger_v1 import DebugException
-
-import struct
-
-import edk2_debugger
-import firmware_volume
-
-class DebugInfoTable:
-    CONST_DEBUG_INFO_TABLE_GUID = ( 0x49152E77L, 0x47641ADAL, 0xFE7AA2B7L, 0x8B5ED9FEL)
-    
-    DebugInfos = []
-    
-    def __init__(self, ec, debug_info_table_header_offset):
-        self.ec = ec
-        self.base = debug_info_table_header_offset
-        
-    def get_debug_info(self):
-        count = self.ec.getMemoryService().readMemory32(self.base + 0x4)
-        debug_info_table_base = self.ec.getMemoryService().readMemory32(self.base + 0x8)
-        
-        self.DebugInfos = []
-        
-        for i in range(0, count):
-            # Get the address of the structure EFI_DEBUG_IMAGE_INFO
-            debug_info = self.ec.getMemoryService().readMemory32(debug_info_table_base + (i * 4))
-            if debug_info:
-                debug_info_type = self.ec.getMemoryService().readMemory32(debug_info)
-                # Normal Debug Info Type
-                if debug_info_type == 1:
-                    # Get the base address of the structure EFI_LOADED_IMAGE_PROTOCOL
-                    loaded_image_protocol = self.ec.getMemoryService().readMemory32(debug_info + 0x4)
-                    
-                    image_base = self.ec.getMemoryService().readMemory32(loaded_image_protocol + 0x20)
-                    image_size = self.ec.getMemoryService().readMemory32(loaded_image_protocol + 0x28)
-                    
-                    self.DebugInfos.append((image_base,image_size))
-    
-    # Return (base, size)
-    def load_symbols_at(self, addr):
-        if self.DebugInfos == []:
-            self.get_debug_info()
-        
-        found = False
-        for debug_info in self.DebugInfos:
-            if (addr >= debug_info[0]) and (addr < debug_info[0] + debug_info[1]):
-                section = firmware_volume.EfiSectionPE32(self.ec, debug_info[0])
-                
-                edk2_debugger.load_symbol_from_file(self.ec, section.get_debug_filepath(), section.get_debug_elfbase())
-
-                found = True
-                return debug_info
-
-        if found == False:
-            raise Exception('DebugInfoTable','No symbol found at 0x%x' % addr)
-
-    def load_all_symbols(self):
-        if self.DebugInfos == []:
-            self.get_debug_info()
-        
-        for debug_info in self.DebugInfos:
-            section = firmware_volume.EfiSectionPE32(self.ec, debug_info[0])
-           
-            edk2_debugger.load_symbol_from_file(self.ec, section.get_debug_filepath(), section.get_debug_elfbase())
-
-    def dump(self):
-        self.get_debug_info()
-        for debug_info in self.DebugInfos:
-            base_pe32 = debug_info[0]
-            section = firmware_volume.EfiSectionPE32(self.ec, base_pe32)
-            print section.get_debug_filepath()
-        
-class SystemTable:
-    CONST_ST_SIGNATURE = ('I','B','I',' ','S','Y','S','T')
-    
-    def __init__(self, ec, membase, memsize):
-        self.membase = membase
-        self.memsize = memsize
-        self.ec = ec
-        
-        found = False
-        
-        # Start from the top of the memory
-        offset = self.membase + self.memsize
-        # Align to highest 4MB boundary
-        offset = offset & ~0x3FFFFF
-        # We should not have a System Table at the top of the System Memory
-        offset = offset - 0x400000
-        
-        # Start at top and look on 4MB boundaries for system table ptr structure
-        while offset > self.membase:
-            try:
-                signature = struct.unpack("cccccccc", self.ec.getMemoryService().read(str(offset), 8, 32))
-            except DebugException:
-                raise Exception('SystemTable','Fail to access System Memory. Ensure all the memory in the region [0x%x;0x%X] is accessible.' % (membase,membase+memsize))
-            if signature == SystemTable.CONST_ST_SIGNATURE:
-                found = True
-                self.system_table_base = self.ec.getMemoryService().readMemory32(offset + 0x8)
-                break
-            offset = offset - 0x400000
-            
-        if not found:
-            raise Exception('SystemTable','System Table not found in System Memory [0x%x;0x%X]' % (membase,membase+memsize))
-        
-    def get_configuration_table(self, conf_table_guid):
-        # Number of configuration Table entry
-        conf_table_entry_count = self.ec.getMemoryService().readMemory32(self.system_table_base + 0x40)
-        
-        # Get location of the Configuration Table entries
-        conf_table_offset = self.ec.getMemoryService().readMemory32(self.system_table_base + 0x44)
-        
-        for i in range(0, conf_table_entry_count):
-            offset = conf_table_offset + (i * 0x14)
-            guid = struct.unpack("<IIII", self.ec.getMemoryService().read(str(offset), 16, 32))
-            if guid == conf_table_guid:
-                return self.ec.getMemoryService().readMemory32(offset + 0x10)
-            
-        raise Exception('SystemTable','Configuration Table not found')
+#

+#  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

+#  

+#  This program and the accompanying materials                          

+#  are licensed and made available under the terms and conditions of the BSD License         

+#  which accompanies this distribution.  The full text of the license may be found at        

+#  http://opensource.org/licenses/bsd-license.php                                            

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+#

+

+from arm_ds.debugger_v1 import DebugException

+

+import struct

+

+import edk2_debugger

+import firmware_volume

+

+class DebugInfoTable:

+    CONST_DEBUG_INFO_TABLE_GUID = ( 0x49152E77L, 0x47641ADAL, 0xFE7AA2B7L, 0x8B5ED9FEL)

+    

+    DebugInfos = []

+    

+    def __init__(self, ec, debug_info_table_header_offset):

+        self.ec = ec

+        self.base = debug_info_table_header_offset

+        

+    def get_debug_info(self):

+        count = self.ec.getMemoryService().readMemory32(self.base + 0x4)

+        debug_info_table_base = self.ec.getMemoryService().readMemory32(self.base + 0x8)

+        

+        self.DebugInfos = []

+        

+        for i in range(0, count):

+            # Get the address of the structure EFI_DEBUG_IMAGE_INFO

+            debug_info = self.ec.getMemoryService().readMemory32(debug_info_table_base + (i * 4))

+            if debug_info:

+                debug_info_type = self.ec.getMemoryService().readMemory32(debug_info)

+                # Normal Debug Info Type

+                if debug_info_type == 1:

+                    # Get the base address of the structure EFI_LOADED_IMAGE_PROTOCOL

+                    loaded_image_protocol = self.ec.getMemoryService().readMemory32(debug_info + 0x4)

+                    

+                    image_base = self.ec.getMemoryService().readMemory32(loaded_image_protocol + 0x20)

+                    image_size = self.ec.getMemoryService().readMemory32(loaded_image_protocol + 0x28)

+                    

+                    self.DebugInfos.append((image_base,image_size))

+    

+    # Return (base, size)

+    def load_symbols_at(self, addr, verbose = False):

+        if self.DebugInfos == []:

+            self.get_debug_info()

+        

+        found = False

+        for debug_info in self.DebugInfos:

+            if (addr >= debug_info[0]) and (addr < debug_info[0] + debug_info[1]):

+                section = firmware_volume.EfiSectionPE32(self.ec, debug_info[0])

+                

+                try:

+                    edk2_debugger.load_symbol_from_file(self.ec, section.get_debug_filepath(), section.get_debug_elfbase(), verbose)

+                except Exception, (ErrorClass, ErrorMessage):

+                    if verbose:

+                        print "Error while loading a symbol file (%s: %s)" % (ErrorClass, ErrorMessage)

+                    pass

+

+                found = True

+                return debug_info

+

+        if found == False:

+            raise Exception('DebugInfoTable','No symbol found at 0x%x' % addr)

+

+    def load_all_symbols(self, verbose = False):

+        if self.DebugInfos == []:

+            self.get_debug_info()

+        

+        for debug_info in self.DebugInfos:

+            section = firmware_volume.EfiSectionPE32(self.ec, debug_info[0])

+           

+            try:

+                edk2_debugger.load_symbol_from_file(self.ec, section.get_debug_filepath(), section.get_debug_elfbase(), verbose)

+            except Exception, (ErrorClass, ErrorMessage):

+                if verbose:

+                    print "Error while loading a symbol file (%s: %s)" % (ErrorClass, ErrorMessage)

+                pass

+

+    def dump(self):

+        self.get_debug_info()

+        for debug_info in self.DebugInfos:

+            base_pe32 = debug_info[0]

+            section = firmware_volume.EfiSectionPE32(self.ec, base_pe32)

+            print section.get_debug_filepath()

+        

+class SystemTable:

+    CONST_ST_SIGNATURE = ('I','B','I',' ','S','Y','S','T')

+    

+    def __init__(self, ec, membase, memsize):

+        self.membase = membase

+        self.memsize = memsize

+        self.ec = ec

+        

+        found = False

+        

+        # Start from the top of the memory

+        offset = self.membase + self.memsize

+        # Align to highest 4MB boundary

+        offset = offset & ~0x3FFFFF

+        # We should not have a System Table at the top of the System Memory

+        offset = offset - 0x400000

+        

+        # Start at top and look on 4MB boundaries for system table ptr structure

+        while offset > self.membase:

+            try:

+                signature = struct.unpack("cccccccc", self.ec.getMemoryService().read(str(offset), 8, 32))

+            except DebugException:

+                raise Exception('SystemTable','Fail to access System Memory. Ensure all the memory in the region [0x%x;0x%X] is accessible.' % (membase,membase+memsize))

+            if signature == SystemTable.CONST_ST_SIGNATURE:

+                found = True

+                self.system_table_base = self.ec.getMemoryService().readMemory32(offset + 0x8)

+                break

+            offset = offset - 0x400000

+            

+        if not found:

+            raise Exception('SystemTable','System Table not found in System Memory [0x%x;0x%X]' % (membase,membase+memsize))

+        

+    def get_configuration_table(self, conf_table_guid):

+        # Number of configuration Table entry

+        conf_table_entry_count = self.ec.getMemoryService().readMemory32(self.system_table_base + 0x40)

+        

+        # Get location of the Configuration Table entries

+        conf_table_offset = self.ec.getMemoryService().readMemory32(self.system_table_base + 0x44)

+        

+        for i in range(0, conf_table_entry_count):

+            offset = conf_table_offset + (i * 0x14)

+            guid = struct.unpack("<IIII", self.ec.getMemoryService().read(str(offset), 16, 32))

+            if guid == conf_table_guid:

+                return self.ec.getMemoryService().readMemory32(offset + 0x10)

+            

+        raise Exception('SystemTable','Configuration Table not found')

diff --git a/ArmPlatformPkg/Sec/Helper.S b/ArmPlatformPkg/Sec/Arm/Helper.S
index 4eede5fa..4eede5fa 100644
--- a/ArmPlatformPkg/Sec/Helper.S
+++ b/ArmPlatformPkg/Sec/Arm/Helper.S
diff --git a/ArmPlatformPkg/Sec/Helper.asm b/ArmPlatformPkg/Sec/Arm/Helper.asm
index b31cc31a..b31cc31a 100644
--- a/ArmPlatformPkg/Sec/Helper.asm
+++ b/ArmPlatformPkg/Sec/Arm/Helper.asm
diff --git a/ArmPlatformPkg/Sec/SecEntryPoint.S b/ArmPlatformPkg/Sec/Arm/SecEntryPoint.S
index 92035a1f..92035a1f 100644
--- a/ArmPlatformPkg/Sec/SecEntryPoint.S
+++ b/ArmPlatformPkg/Sec/Arm/SecEntryPoint.S
diff --git a/ArmPlatformPkg/Sec/SecEntryPoint.asm b/ArmPlatformPkg/Sec/Arm/SecEntryPoint.asm
index 42d2b026..42d2b026 100644
--- a/ArmPlatformPkg/Sec/SecEntryPoint.asm
+++ b/ArmPlatformPkg/Sec/Arm/SecEntryPoint.asm
diff --git a/ArmPlatformPkg/Sec/Sec.c b/ArmPlatformPkg/Sec/Sec.c
index 55807ec9..52fa53a6 100644
--- a/ArmPlatformPkg/Sec/Sec.c
+++ b/ArmPlatformPkg/Sec/Sec.c
@@ -1,195 +1,195 @@
-/** @file
-*  Main file supporting the SEC Phase on ARM Platforms
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-#include <Library/ArmTrustedMonitorLib.h>
-#include <Library/DebugAgentLib.h>
-#include <Library/PrintLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/SerialPortLib.h>
-#include <Library/ArmGicLib.h>
-
-#include "SecInternal.h"
-
-#define SerialPrint(txt)  SerialPortWrite ((UINT8*)txt, AsciiStrLen(txt)+1);
-
-VOID
-CEntryPoint (
-  IN  UINTN                     MpId,
-  IN  UINTN                     SecBootMode
-  )
-{
-  CHAR8           Buffer[100];
-  UINTN           CharCount;
-  UINTN           JumpAddress;
-
-  // Invalidate the data cache. Doesn't have to do the Data cache clean.
-  ArmInvalidateDataCache();
-
-  // Invalidate Instruction Cache
-  ArmInvalidateInstructionCache();
-
-  // Invalidate I & D TLBs
-  ArmInvalidateInstructionAndDataTlb();
-
-  // CPU specific settings
-  ArmCpuSetup (MpId);
-
-  // Enable Floating Point Coprocessor if supported by the platform
-  if (FixedPcdGet32 (PcdVFPEnabled)) {
-    ArmEnableVFP();
-  }
-
-  // Initialize peripherals that must be done at the early stage
-  // Example: Some L2 controller, interconnect, clock, DMC, etc
-  ArmPlatformSecInitialize (MpId);
-
-  // Primary CPU clears out the SCU tag RAMs, secondaries wait
-  if (IS_PRIMARY_CORE(MpId) && (SecBootMode == ARM_SEC_COLD_BOOT)) {
-    if (ArmIsMpCore()) {
-      // Signal for the initial memory is configured (event: BOOT_MEM_INIT)
-      ArmCallSEV ();
-    }
-
-    // SEC phase needs to run library constructors by hand. This assumes we are linked against the SerialLib
-    // In non SEC modules the init call is in autogenerated code.
-    SerialPortInitialize ();
-
-    // Start talking
-    if (FixedPcdGetBool (PcdTrustzoneSupport)) {
-      CharCount = AsciiSPrint (Buffer,sizeof (Buffer),"Secure firmware (version %s built at %a on %a)\n\r",
-          (CHAR16*)PcdGetPtr(PcdFirmwareVersionString), __TIME__, __DATE__);
-    } else {
-      CharCount = AsciiSPrint (Buffer,sizeof (Buffer),"Boot firmware (version %s built at %a on %a)\n\r",
-          (CHAR16*)PcdGetPtr(PcdFirmwareVersionString), __TIME__, __DATE__);
-    }
-    SerialPortWrite ((UINT8 *) Buffer, CharCount);
-
-    // Initialize the Debug Agent for Source Level Debugging
-    InitializeDebugAgent (DEBUG_AGENT_INIT_PREMEM_SEC, NULL, NULL);
-    SaveAndSetDebugTimerInterrupt (TRUE);
-
-    // Enable the GIC distributor and CPU Interface
-    // - no other Interrupts are enabled,  doesn't have to worry about the priority.
-    // - all the cores are in secure state, use secure SGI's
-    ArmGicEnableDistributor (PcdGet32(PcdGicDistributorBase));
-    ArmGicEnableInterruptInterface (PcdGet32(PcdGicInterruptInterfaceBase));
-  } else {
-    // Enable the GIC CPU Interface
-    ArmGicEnableInterruptInterface (PcdGet32(PcdGicInterruptInterfaceBase));
-  }
-
-  // Enable Full Access to CoProcessors
-  ArmWriteCpacr (CPACR_CP_FULL_ACCESS);
-
-  // Test if Trustzone is supported on this platform
-  if (FixedPcdGetBool (PcdTrustzoneSupport)) {
-    if (ArmIsMpCore()) {
-      // Setup SMP in Non Secure world
-      ArmCpuSetupSmpNonSecure (GET_CORE_ID(MpId));
-    }
-
-    // Either we use the Secure Stacks for Secure Monitor (in this case (Base == 0) && (Size == 0))
-    // Or we use separate Secure Monitor stacks (but (Base != 0) && (Size != 0))
-    ASSERT (((PcdGet32(PcdCPUCoresSecMonStackBase) == 0) && (PcdGet32(PcdCPUCoreSecMonStackSize) == 0)) ||
-            ((PcdGet32(PcdCPUCoresSecMonStackBase) != 0) && (PcdGet32(PcdCPUCoreSecMonStackSize) != 0)));
-
-    // Enter Monitor Mode
-    enter_monitor_mode ((UINTN)TrustedWorldInitialization, MpId, SecBootMode, (VOID*)(PcdGet32(PcdCPUCoresSecMonStackBase) + (PcdGet32(PcdCPUCoreSecMonStackSize) * (GET_CORE_POS(MpId) + 1))));
-  } else {
-    if (IS_PRIMARY_CORE(MpId)) {
-      SerialPrint ("Trust Zone Configuration is disabled\n\r");
-    }
-
-    // With Trustzone support the transition from Sec to Normal world is done by return_from_exception().
-    // If we want to keep this function call we need to ensure the SVC's SPSR point to the same Program
-    // Status Register as the the current one (CPSR).
-    copy_cpsr_into_spsr ();
-
-    // Call the Platform specific function to execute additional actions if required
-    JumpAddress = PcdGet32 (PcdFvBaseAddress);
-    ArmPlatformSecExtraAction (MpId, &JumpAddress);
-
-    NonTrustedWorldTransition (MpId, JumpAddress);
-  }
-  ASSERT (0); // We must never return from the above function
-}
-
-VOID
-TrustedWorldInitialization (
-  IN  UINTN                     MpId,
-  IN  UINTN                     SecBootMode
-  )
-{
-  UINTN   JumpAddress;
-
-  //-------------------- Monitor Mode ---------------------
-
-  // Set up Monitor World (Vector Table, etc)
-  ArmSecureMonitorWorldInitialize ();
-
-  // Transfer the interrupt to Non-secure World
-  ArmGicSetupNonSecure (MpId, PcdGet32(PcdGicDistributorBase), PcdGet32(PcdGicInterruptInterfaceBase));
-
-  // Initialize platform specific security policy
-  ArmPlatformSecTrustzoneInit (MpId);
-
-  // Setup the Trustzone Chipsets
-  if (SecBootMode == ARM_SEC_COLD_BOOT) {
-    if (IS_PRIMARY_CORE(MpId)) {
-      if (ArmIsMpCore()) {
-        // Signal the secondary core the Security settings is done (event: EVENT_SECURE_INIT)
-        ArmCallSEV ();
-      }
-    } else {
-      // The secondary cores need to wait until the Trustzone chipsets configuration is done
-      // before switching to Non Secure World
-
-      // Wait for the Primary Core to finish the initialization of the Secure World (event: EVENT_SECURE_INIT)
-      ArmCallWFE ();
-    }
-  }
-
-  // Call the Platform specific function to execute additional actions if required
-  JumpAddress = PcdGet32 (PcdFvBaseAddress);
-  ArmPlatformSecExtraAction (MpId, &JumpAddress);
-
-  // Write to CP15 Non-secure Access Control Register
-  ArmWriteNsacr (PcdGet32 (PcdArmNsacr));
-
-  // CP15 Secure Configuration Register
-  ArmWriteScr (PcdGet32 (PcdArmScr));
-
-  NonTrustedWorldTransition (MpId, JumpAddress);
-}
-
-VOID
-NonTrustedWorldTransition (
-  IN  UINTN                     MpId,
-  IN  UINTN                     JumpAddress
-  )
-{
-  // If PcdArmNonSecModeTransition is defined then set this specific mode to CPSR before the transition
-  // By not set, the mode for Non Secure World is SVC
-  if (PcdGet32 (PcdArmNonSecModeTransition) != 0) {
-    set_non_secure_mode ((ARM_PROCESSOR_MODE)PcdGet32 (PcdArmNonSecModeTransition));
-  }
-
-  return_from_exception (JumpAddress);
-  //-------------------- Non Secure Mode ---------------------
-
-  // PEI Core should always load and never return
-  ASSERT (FALSE);
-}
-
+/** @file

+*  Main file supporting the SEC Phase on ARM Platforms

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+#include <Library/ArmTrustedMonitorLib.h>

+#include <Library/DebugAgentLib.h>

+#include <Library/PrintLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/SerialPortLib.h>

+#include <Library/ArmGicLib.h>

+

+#include "SecInternal.h"

+

+#define SerialPrint(txt)  SerialPortWrite ((UINT8*)txt, AsciiStrLen(txt)+1);

+

+VOID

+CEntryPoint (

+  IN  UINTN                     MpId,

+  IN  UINTN                     SecBootMode

+  )

+{

+  CHAR8           Buffer[100];

+  UINTN           CharCount;

+  UINTN           JumpAddress;

+

+  // Invalidate the data cache. Doesn't have to do the Data cache clean.

+  ArmInvalidateDataCache ();

+

+  // Invalidate Instruction Cache

+  ArmInvalidateInstructionCache ();

+

+  // Invalidate I & D TLBs

+  ArmInvalidateInstructionAndDataTlb ();

+

+  // CPU specific settings

+  ArmCpuSetup (MpId);

+

+  // Enable Floating Point Coprocessor if supported by the platform

+  if (FixedPcdGet32 (PcdVFPEnabled)) {

+    ArmEnableVFP ();

+  }

+

+  // Initialize peripherals that must be done at the early stage

+  // Example: Some L2 controller, interconnect, clock, DMC, etc

+  ArmPlatformSecInitialize (MpId);

+

+  // Primary CPU clears out the SCU tag RAMs, secondaries wait

+  if (IS_PRIMARY_CORE(MpId) && (SecBootMode == ARM_SEC_COLD_BOOT)) {

+    if (ArmIsMpCore()) {

+      // Signal for the initial memory is configured (event: BOOT_MEM_INIT)

+      ArmCallSEV ();

+    }

+

+    // SEC phase needs to run library constructors by hand. This assumes we are linked against the SerialLib

+    // In non SEC modules the init call is in autogenerated code.

+    SerialPortInitialize ();

+

+    // Start talking

+    if (FixedPcdGetBool (PcdTrustzoneSupport)) {

+      CharCount = AsciiSPrint (Buffer,sizeof (Buffer),"Secure firmware (version %s built at %a on %a)\n\r",

+          (CHAR16*)PcdGetPtr(PcdFirmwareVersionString), __TIME__, __DATE__);

+    } else {

+      CharCount = AsciiSPrint (Buffer,sizeof (Buffer),"Boot firmware (version %s built at %a on %a)\n\r",

+          (CHAR16*)PcdGetPtr(PcdFirmwareVersionString), __TIME__, __DATE__);

+    }

+    SerialPortWrite ((UINT8 *) Buffer, CharCount);

+

+    // Initialize the Debug Agent for Source Level Debugging

+    InitializeDebugAgent (DEBUG_AGENT_INIT_PREMEM_SEC, NULL, NULL);

+    SaveAndSetDebugTimerInterrupt (TRUE);

+

+    // Enable the GIC distributor and CPU Interface

+    // - no other Interrupts are enabled,  doesn't have to worry about the priority.

+    // - all the cores are in secure state, use secure SGI's

+    ArmGicEnableDistributor (PcdGet32(PcdGicDistributorBase));

+    ArmGicEnableInterruptInterface (PcdGet32(PcdGicInterruptInterfaceBase));

+  } else {

+    // Enable the GIC CPU Interface

+    ArmGicEnableInterruptInterface (PcdGet32(PcdGicInterruptInterfaceBase));

+  }

+

+  // Enable Full Access to CoProcessors

+  ArmWriteCpacr (CPACR_CP_FULL_ACCESS);

+

+  // Test if Trustzone is supported on this platform

+  if (FixedPcdGetBool (PcdTrustzoneSupport)) {

+    if (ArmIsMpCore ()) {

+      // Setup SMP in Non Secure world

+      ArmCpuSetupSmpNonSecure (GET_CORE_ID(MpId));

+    }

+

+    // Either we use the Secure Stacks for Secure Monitor (in this case (Base == 0) && (Size == 0))

+    // Or we use separate Secure Monitor stacks (but (Base != 0) && (Size != 0))

+    ASSERT (((PcdGet32(PcdCPUCoresSecMonStackBase) == 0) && (PcdGet32(PcdCPUCoreSecMonStackSize) == 0)) ||

+            ((PcdGet32(PcdCPUCoresSecMonStackBase) != 0) && (PcdGet32(PcdCPUCoreSecMonStackSize) != 0)));

+

+    // Enter Monitor Mode

+    enter_monitor_mode ((UINTN)TrustedWorldInitialization, MpId, SecBootMode, (VOID*)(PcdGet32(PcdCPUCoresSecMonStackBase) + (PcdGet32(PcdCPUCoreSecMonStackSize) * (GET_CORE_POS(MpId) + 1))));

+  } else {

+    if (IS_PRIMARY_CORE(MpId)) {

+      SerialPrint ("Trust Zone Configuration is disabled\n\r");

+    }

+

+    // With Trustzone support the transition from Sec to Normal world is done by return_from_exception().

+    // If we want to keep this function call we need to ensure the SVC's SPSR point to the same Program

+    // Status Register as the the current one (CPSR).

+    copy_cpsr_into_spsr ();

+

+    // Call the Platform specific function to execute additional actions if required

+    JumpAddress = PcdGet32 (PcdFvBaseAddress);

+    ArmPlatformSecExtraAction (MpId, &JumpAddress);

+

+    NonTrustedWorldTransition (MpId, JumpAddress);

+  }

+  ASSERT (0); // We must never return from the above function

+}

+

+VOID

+TrustedWorldInitialization (

+  IN  UINTN                     MpId,

+  IN  UINTN                     SecBootMode

+  )

+{

+  UINTN   JumpAddress;

+

+  //-------------------- Monitor Mode ---------------------

+

+  // Set up Monitor World (Vector Table, etc)

+  ArmSecureMonitorWorldInitialize ();

+

+  // Transfer the interrupt to Non-secure World

+  ArmGicSetupNonSecure (MpId, PcdGet32(PcdGicDistributorBase), PcdGet32(PcdGicInterruptInterfaceBase));

+

+  // Initialize platform specific security policy

+  ArmPlatformSecTrustzoneInit (MpId);

+

+  // Setup the Trustzone Chipsets

+  if (SecBootMode == ARM_SEC_COLD_BOOT) {

+    if (IS_PRIMARY_CORE(MpId)) {

+      if (ArmIsMpCore()) {

+        // Signal the secondary core the Security settings is done (event: EVENT_SECURE_INIT)

+        ArmCallSEV ();

+      }

+    } else {

+      // The secondary cores need to wait until the Trustzone chipsets configuration is done

+      // before switching to Non Secure World

+

+      // Wait for the Primary Core to finish the initialization of the Secure World (event: EVENT_SECURE_INIT)

+      ArmCallWFE ();

+    }

+  }

+

+  // Call the Platform specific function to execute additional actions if required

+  JumpAddress = PcdGet32 (PcdFvBaseAddress);

+  ArmPlatformSecExtraAction (MpId, &JumpAddress);

+

+  // Write to CP15 Non-secure Access Control Register

+  ArmWriteNsacr (PcdGet32 (PcdArmNsacr));

+

+  // CP15 Secure Configuration Register

+  ArmWriteScr (PcdGet32 (PcdArmScr));

+

+  NonTrustedWorldTransition (MpId, JumpAddress);

+}

+

+VOID

+NonTrustedWorldTransition (

+  IN  UINTN                     MpId,

+  IN  UINTN                     JumpAddress

+  )

+{

+  // If PcdArmNonSecModeTransition is defined then set this specific mode to CPSR before the transition

+  // By not set, the mode for Non Secure World is SVC

+  if (PcdGet32 (PcdArmNonSecModeTransition) != 0) {

+    set_non_secure_mode ((ARM_PROCESSOR_MODE)PcdGet32 (PcdArmNonSecModeTransition));

+  }

+

+  return_from_exception (JumpAddress);

+  //-------------------- Non Secure Mode ---------------------

+

+  // PEI Core should always load and never return

+  ASSERT (FALSE);

+}

+

diff --git a/ArmPlatformPkg/Sec/Sec.inf b/ArmPlatformPkg/Sec/Sec.inf
index 55ad0074..3cf9f339 100644
--- a/ArmPlatformPkg/Sec/Sec.inf
+++ b/ArmPlatformPkg/Sec/Sec.inf
@@ -20,12 +20,14 @@
   MODULE_TYPE                    = SEC

   VERSION_STRING                 = 1.0

 

-[Sources.ARM]

-  Helper.asm           | RVCT

-  Helper.S             | GCC

+[Sources]

   Sec.c

-  SecEntryPoint.S      | GCC

-  SecEntryPoint.asm    | RVCT

+

+[Sources.ARM]

+  Arm/Helper.asm           | RVCT

+  Arm/Helper.S             | GCC

+  Arm/SecEntryPoint.S      | GCC

+  Arm/SecEntryPoint.asm    | RVCT

   

 [Packages]

   MdePkg/MdePkg.dec

diff --git a/ArmPlatformPkg/Sec/SecInternal.h b/ArmPlatformPkg/Sec/SecInternal.h
index 8bc21389..eeaf40c0 100644
--- a/ArmPlatformPkg/Sec/SecInternal.h
+++ b/ArmPlatformPkg/Sec/SecInternal.h
@@ -1,7 +1,7 @@
 /** @file

 *  Main file supporting the SEC Phase on ARM PLatforms

 *

-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

 *

 *  This program and the accompanying materials

 *  are licensed and made available under the terms and conditions of the BSD License

@@ -70,7 +70,7 @@ set_non_secure_mode (
 VOID

 SecCommonExceptionEntry (

   IN UINT32 Entry,

-  IN UINT32 LR

+  IN UINTN  LR

   );

 

 #endif

diff --git a/BaseTools/Contributions.txt b/BaseTools/Contributions.txt
new file mode 100644
index 00000000..667ca103
--- /dev/null
+++ b/BaseTools/Contributions.txt
@@ -0,0 +1,188 @@
+

+======================

+= Code Contributions =

+======================

+

+To make a contribution to a TianoCore project, follow these steps.

+1. Create a change description in the format specified below to

+   use in the source control commit log.

+2. Your commit message must include your "Signed-off-by" signature,

+   and "Contributed-under" message.

+3. Your "Contributed-under" message explicitly states that the

+   contribution is made under the terms of the specified

+   contribution agreement.  Your "Contributed-under" message

+   must include the name of contribution agreement and version.

+   For example: Contributed-under: TianoCore Contribution Agreement 1.0

+   The "TianoCore Contribution Agreement" is included below in

+   this document.

+4. Submit your code to the TianoCore project using the process

+   that the project documents on its web page.  If the process is

+   not documented, then submit the code on development email list

+   for the project.

+

+=======================================

+= Change Description / Commit Message =

+=======================================

+

+Your change description should use the standard format for a

+commit message, and must include your "Signed-off-by" signature

+and the "Contributed-under" message.

+

+== Sample Change Description / Commit Message =

+

+=== Definitions for sample change description ===

+

+* "CodeModule" is a short idenfier for the affected code.  For

+  example MdePkg, or MdeModulePkg UsbBusDxe.

+* "Brief-single-line-summary" is a short summary of the change.

+* The entire first line should be less than ~70 characters.

+* "Full-commit-message" a verbose multiple line comment describing

+  the change.  Each line should be less than ~70 characters.

+* "Contributed-under" explicitely states that the contribution is

+  made under the terms of the contribtion agreement.  This

+  agreement is included below in this document.

+* "Signed-off-by" is the contributor's signature identifying them

+  by their real/legal name and their email address.

+

+=== Start of sample change description / commit message ===

+CodeModule: Brief-single-line-summary

+

+Full-commit-message

+

+Contributed-under: TianoCore Contribution Agreement 1.0

+Signed-off-by: Contributor Name <contributor@email.server>

+=== End of sample change description / commit message ===

+

+========================================

+= TianoCore Contribution Agreement 1.0 =

+========================================

+

+INTEL CORPORATION ("INTEL") MAKES AVAILABLE SOFTWARE, DOCUMENTATION,

+INFORMATION AND/OR OTHER MATERIALS FOR USE IN THE TIANOCORE OPEN SOURCE

+PROJECT (COLLECTIVELY "CONTENT"). USE OF THE CONTENT IS GOVERNED BY THE

+TERMS AND CONDITIONS OF THIS AGREEMENT BETWEEN YOU AND INTEL AND/OR THE

+TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR

+REFERENCED BELOW. BY USING THE CONTENT, YOU AGREE THAT YOUR USE OF THE

+CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS

+OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED

+BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS

+AGREEMENT AND THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE

+AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT

+USE THE CONTENT.

+

+Unless otherwise indicated, all Content made available on the TianoCore

+site is provided to you under the terms and conditions of the BSD

+License ("BSD"). A copy of the BSD License is available at

+http://opensource.org/licenses/bsd-license.php

+or when applicable, in the associated License.txt file.

+

+Certain other content may be made available under other licenses as

+indicated in or with such Content. (For example, in a License.txt file.)

+

+You accept and agree to the following terms and conditions for Your

+present and future Contributions submitted to TianoCore site. Except

+for the license granted to Intel hereunder, You reserve all right,

+title, and interest in and to Your Contributions.

+

+== SECTION 1: Definitions ==

+* "You" or "Contributor" shall mean the copyright owner or legal

+  entity authorized by the copyright owner that is making a

+  Contribution hereunder. All other entities that control, are

+  controlled by, or are under common control with that entity are

+  considered to be a single Contributor. For the purposes of this

+  definition, "control" means (i) the power, direct or indirect, to

+  cause the direction or management of such entity, whether by

+  contract or otherwise, or (ii) ownership of fifty percent (50%)

+  or more of the outstanding shares, or (iii) beneficial ownership

+  of such entity.

+* "Contribution" shall mean any original work of authorship,

+  including any modifications or additions to an existing work,

+  that is intentionally submitted by You to the TinaoCore site for

+  inclusion in, or documentation of, any of the Content. For the

+  purposes of this definition, "submitted" means any form of

+  electronic, verbal, or written communication sent to the

+  TianoCore site or its representatives, including but not limited

+  to communication on electronic mailing lists, source code

+  control systems, and issue tracking systems that are managed by,

+  or on behalf of, the TianoCore site for the purpose of

+  discussing and improving the Content, but excluding

+  communication that is conspicuously marked or otherwise

+  designated in writing by You as "Not a Contribution."

+

+== SECTION 2: License for Contributions ==

+* Contributor hereby agrees that redistribution and use of the

+  Contribution in source and binary forms, with or without

+  modification, are permitted provided that the following

+  conditions are met:

+** Redistributions of source code must retain the Contributor's

+   copyright notice, this list of conditions and the following

+   disclaimer.

+** Redistributions in binary form must reproduce the Contributor's

+   copyright notice, this list of conditions and the following

+   disclaimer in the documentation and/or other materials provided

+   with the distribution.

+* Disclaimer. None of the names of Contributor, Intel, or the names

+  of their respective contributors may be used to endorse or

+  promote products derived from this software without specific

+  prior written permission.

+* Contributor grants a license (with the right to sublicense) under

+  claims of Contributor's patents that Contributor can license that

+  are infringed by the Contribution (as delivered by Contributor) to

+  make, use, distribute, sell, offer for sale, and import the

+  Contribution and derivative works thereof solely to the minimum

+  extent necessary for licensee to exercise the granted copyright

+  license; this patent license applies solely to those portions of

+  the Contribution that are unmodified. No hardware per se is

+  licensed.

+* EXCEPT AS EXPRESSLY SET FORTH IN SECTION 3 BELOW, THE

+  CONTRIBUTION IS PROVIDED BY THE CONTRIBUTOR "AS IS" AND ANY

+  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A

+  PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE

+  CONTRIBUTOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

+  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

+  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

+  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

+  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE

+  CONTRIBUTION, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH

+  DAMAGE.

+

+== SECTION 3: Representations ==

+* You represent that You are legally entitled to grant the above

+  license. If your employer(s) has rights to intellectual property

+  that You create that includes Your Contributions, You represent

+  that You have received permission to make Contributions on behalf

+  of that employer, that Your employer has waived such rights for

+  Your Contributions.

+* You represent that each of Your Contributions is Your original

+  creation (see Section 4 for submissions on behalf of others).

+  You represent that Your Contribution submissions include complete

+  details of any third-party license or other restriction

+  (including, but not limited to, related patents and trademarks)

+  of which You are personally aware and which are associated with

+  any part of Your Contributions.

+

+== SECTION 4: Third Party Contributions ==

+* Should You wish to submit work that is not Your original creation,

+  You may submit it to TianoCore site separately from any

+  Contribution, identifying the complete details of its source

+  and of any license or other restriction (including, but not

+  limited to, related patents, trademarks, and license agreements)

+  of which You are personally aware, and conspicuously marking the

+  work as "Submitted on behalf of a third-party: [named here]".

+

+== SECTION 5: Miscellaneous ==

+* Applicable Laws. Any claims arising under or relating to this

+  Agreement shall be governed by the internal substantive laws of

+  the State of Delaware or federal courts located in Delaware,

+  without regard to principles of conflict of laws.

+* Language. This Agreement is in the English language only, which

+  language shall be controlling in all respects, and all versions

+  of this Agreement in any other language shall be for accommodation

+  only and shall not be binding. All communications and notices made

+  or given pursuant to this Agreement, and all documentation and

+  support to be provided, unless otherwise noted, shall be in the

+  English language.

+

diff --git a/BaseTools/License.txt b/BaseTools/License.txt
new file mode 100644
index 00000000..160be01d
--- /dev/null
+++ b/BaseTools/License.txt
@@ -0,0 +1,25 @@
+Copyright (c) 2013, Intel Corporation. All rights reserved.

+

+Redistribution and use in source and binary forms, with or without

+modification, are permitted provided that the following conditions

+are met:

+

+* Redistributions of source code must retain the above copyright

+  notice, this list of conditions and the following disclaimer.

+* Redistributions in binary form must reproduce the above copyright

+  notice, this list of conditions and the following disclaimer in

+  the documentation and/or other materials provided with the

+  distribution.

+

+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

+FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE

+COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,

+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,

+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

+POSSIBILITY OF SUCH DAMAGE.

diff --git a/BaseTools/Source/C/GenBootSector/GenBootSector.c b/BaseTools/Source/C/GenBootSector/GenBootSector.c
index 169d81e0..f102ee13 100644
--- a/BaseTools/Source/C/GenBootSector/GenBootSector.c
+++ b/BaseTools/Source/C/GenBootSector/GenBootSector.c
@@ -1,6 +1,6 @@
 /** @file

 

-Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials                          

 are licensed and made available under the terms and conditions of the BSD License         

 which accompanies this distribution.  The full text of the license may be found at        

@@ -542,8 +542,7 @@ Returns:
 

 --*/

 {

-  printf ("%s v%d.%d %s -Utility to retrieve and update the boot sector or MBR.\n", UTILITY_NAME, UTILITY_MAJOR_VERSION, UTILITY_MINOR_VERSION, __BUILD_VERSION);

-  printf ("Copyright (c) 2009 - 2010 Intel Corporation. All rights reserved.\n");

+  printf ("%s Version %d.%d Build%s\n", UTILITY_NAME, UTILITY_MAJOR_VERSION, UTILITY_MINOR_VERSION, __BUILD_VERSION);

 }

 

 VOID

@@ -551,18 +550,27 @@ PrintUsage (
   void

   )

 {

-  Version();

-  printf ("\nUsage: \n\

-   GenBootSector\n\

-     [-l, --list list disks]\n\

-     [-i, --input Filename]\n\

-     [-o, --output Filename]\n\

-     [-m, --mbr process the MBR also]\n\

-     [-v, --verbose]\n\

-     [--version]\n\

-     [-q, --quiet disable all messages except fatal errors]\n\

-     [-d, --debug[#]\n\

-     [-h, --help]\n");

+  printf ("Usage: GenBootSector [options] --cfg-file CFG_FILE\n\n\

+Copyright (c) 2009 - 2013, Intel Corporation.  All rights reserved.\n\n\

+  Utility to retrieve and update the boot sector or MBR.\n\n\

+optional arguments:\n\

+  -h, --help            Show this help message and exit\n\

+  --version             Show program's version number and exit\n\

+  -d [DEBUG], --debug [DEBUG]\n\

+                        Output DEBUG statements, where DEBUG_LEVEL is 0 (min)\n\

+                        - 9 (max)\n\

+  -v, --verbose         Print informational statements\n\

+  -q, --quiet           Returns the exit code, error messages will be\n\

+                        displayed\n\

+  -s, --silent          Returns only the exit code; informational and error\n\

+                        messages are not displayed\n\

+  -l, --list            List disk drives\n\

+  -i INPUT_FILENAME, --input INPUT_FILENAME\n\

+                        Input file name\n\

+  -o OUTPUT_FILENAME, --output OUTPUT_FILENAME\n\

+                        Output file name\n\

+  -m, --mbr             Also process the MBR\n\

+  --sfo                 Reserved for future use\n");

 

 }

 

diff --git a/BaseTools/Source/C/GenCrc32/GenCrc32.c b/BaseTools/Source/C/GenCrc32/GenCrc32.c
index 681fe4f1..8ece9a84 100644
--- a/BaseTools/Source/C/GenCrc32/GenCrc32.c
+++ b/BaseTools/Source/C/GenCrc32/GenCrc32.c
@@ -1,6 +1,6 @@
 /** @file

 

-Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials                          

 are licensed and made available under the terms and conditions of the BSD License         

 which accompanies this distribution.  The full text of the license may be found at        

@@ -55,7 +55,7 @@ Returns:
 

 --*/

 {

-  fprintf (stdout, "%s Version %d.%d %s \n", UTILITY_NAME, UTILITY_MAJOR_VERSION, UTILITY_MINOR_VERSION, __BUILD_VERSION);

+  fprintf (stdout, "%s Version %d.%d Build %s \n", UTILITY_NAME, UTILITY_MAJOR_VERSION, UTILITY_MINOR_VERSION, __BUILD_VERSION);

 }

 

 VOID

@@ -81,26 +81,32 @@ Returns:
   //

   // Summary usage

   //

-  fprintf (stdout, "\nUsage: %s -e|-d [options] <input_file>\n\n", UTILITY_NAME);

+  fprintf (stdout, "Usage: GenCrc32 -e|-d [options] <input_file>\n\n");

   

   //

   // Copyright declaration

   // 

-  fprintf (stdout, "Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.\n\n");

+  fprintf (stdout, "Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.\n\n");

 

   //

   // Details Option

   //

-  fprintf (stdout, "Options:\n");

-  fprintf (stdout, "  -o FileName, --output FileName\n\

-                        File will be created to store the ouput content.\n");

-  fprintf (stdout, "  -e, --encode          Calculate CRC32 value for the input file.\n");

-  fprintf (stdout, "  -d, --decode          Verify CRC32 value for the input file.\n");

-  fprintf (stdout, "  -v, --verbose         Turn on verbose output with informational messages.\n");

-  fprintf (stdout, "  -q, --quiet           Disable all messages except key message and fatal error\n");

-  fprintf (stdout, "  --debug level         Enable debug messages, at input debug level.\n");

-  fprintf (stdout, "  --version             Show program's version number and exit.\n");

-  fprintf (stdout, "  -h, --help            Show this help message and exit.\n"); 

+  fprintf (stdout, "optional arguments:\n");

+  fprintf (stdout, "  -h, --help            Show this help message and exit\n");

+  fprintf (stdout, "  --version             Show program's version number and exit\n");

+  fprintf (stdout, "  --debug [DEBUG]       Output DEBUG statements, where DEBUG_LEVEL is 0 (min)\n\

+                        - 9 (max)\n");

+  fprintf (stdout, "  -v, --verbose         Print informational statements\n");

+  fprintf (stdout, "  -q, --quiet           Returns the exit code, error messages will be\n\

+                        displayed\n");

+  fprintf (stdout, "  -s, --silent          Returns only the exit code; informational and error\n\

+                        messages are not displayed\n");

+  fprintf (stdout, "  -e, --encode          Calculate CRC32 value for the input file\n");

+  fprintf (stdout, "  -d, --decode          Verify CRC32 value for the input file\n");

+  fprintf (stdout, "  -o OUTPUT_FILENAME, --output OUTPUT_FILENAME\n\

+                        Output file name\n");

+  fprintf (stdout, "  --sfo                 Reserved for future use\n");

+  

 }

 

 int

@@ -164,7 +170,6 @@ Returns:
   argv ++;

 

   if ((stricmp (argv[0], "-h") == 0) || (stricmp (argv[0], "--help") == 0)) {

-    Version ();

     Usage ();

     return STATUS_SUCCESS;    

   }

diff --git a/BaseTools/Source/C/GenPage/GenPage.c b/BaseTools/Source/C/GenPage/GenPage.c
index 6c24a2f9..78047ba9 100644
--- a/BaseTools/Source/C/GenPage/GenPage.c
+++ b/BaseTools/Source/C/GenPage/GenPage.c
@@ -1,6 +1,6 @@
 /** @file

 

-Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials                          

 are licensed and made available under the terms and conditions of the BSD License         

 which accompanies this distribution.  The full text of the license may be found at        

@@ -91,8 +91,7 @@ Returns:
 

 --*/

 {

-  printf ("%s v%d.%d %s -Utility to generate the EfiLoader image containing page table.\n", UTILITY_NAME, UTILITY_MAJOR_VERSION, UTILITY_MINOR_VERSION, __BUILD_VERSION);

-  printf ("Copyright (c) 2008 - 2011 Intel Corporation. All rights reserved.\n");

+  printf ("%s Version %d.%d Build %s\n", UTILITY_NAME, UTILITY_MAJOR_VERSION, UTILITY_MINOR_VERSION, __BUILD_VERSION);

 }

 

 VOID

@@ -100,25 +99,29 @@ Usage (
   void

   )

 {

-  Version();

-  printf ("\nUsage: \n\

-   GenPage\n\

-     -o, --output Filename\n\

-                        The file that contains both non-page table part and\n\

-                        page table\n\

-     [-b, --baseaddr baseaddress]\n\

+  printf ("Usage: GenPage.exe [options] EfiLoaderImageName \n\n\

+Copyright (c) 2008 - 2013, Intel Corporation.  All rights reserved.\n\n\

+  Utility to generate the EfiLoader image containing a page table.\n\n\

+optional arguments:\n\

+  -h, --help            Show this help message and exit\n\

+  --version             Show program's version number and exit\n\

+  -d [DEBUG], --debug [DEBUG]\n\

+                        Output DEBUG statements, where DEBUG_LEVEL is 0 (min)\n\

+                        - 9 (max)\n\

+  -v, --verbose         Print informational statements\n\

+  -q, --quiet           Returns the exit code, error messages will be\n\

+                        displayed\n\

+  -s, --silent          Returns only the exit code; informational and error\n\

+                        messages are not displayed\n\

+  -o OUTPUT_FILENAME, --output OUTPUT_FILENAME\n\

+                        Output file contain both the non-page table part and\n\

+                        the page table\n\

+  -b BASE_ADDRESS, --baseaddr BASE_ADDRESS\n\

                         The page table location\n\

-     [-f, --offset offset]\n\

+  -f OFFSET, --offset OFFSET\n\

                         The position that the page table will appear in the\n\

                         output file\n\

-     [-v, --verbose]    Turn on verbose output with informational messages\n\

-                        printed\n\

-     [--version]        Print version and copyright of this program and exit\n\

-     [-q, --quiet]      Disable all messages except unrecoverable errors\n\

-     [-d, --debug[#]]   Enable debug messages, at level #\n\

-     [-h, --help]       Print copyright, version and usage of this program\n\

-                        and exit\n\

-     EfiLoaderImageName\n");

+  --sfo                 Reserved for future use\n");

 

 }

 

diff --git a/BaseTools/Source/C/VfrCompile/VfrError.cpp b/BaseTools/Source/C/VfrCompile/VfrError.cpp
index b0f9197e..ba1bec06 100644
--- a/BaseTools/Source/C/VfrCompile/VfrError.cpp
+++ b/BaseTools/Source/C/VfrCompile/VfrError.cpp
@@ -2,7 +2,7 @@
   

   VfrCompiler error handler.

 

-Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials                          

 are licensed and made available under the terms and conditions of the BSD License         

 which accompanies this distribution.  The full text of the license may be found at        

@@ -45,6 +45,7 @@ static SVFR_ERROR_HANDLE VFR_ERROR_HANDLE_TABLE [] = {
   { VFR_RETURN_DATA_STRING_ERROR, ": data field string error or not support"},

   { VFR_RETURN_DEFAULT_VALUE_REDEFINED, ": default value re-defined with different value"},

   { VFR_RETURN_CONSTANT_ONLY, ": only constant is allowed in the expression"},

+  { VFR_RETURN_VARSTORE_NAME_REDEFINED_ERROR, ": Varstore name is defined by more than one varstores, it can't be referred as varstore, only varstore strucure name could be used."},

   { VFR_RETURN_CODEUNDEFINED, ": undefined Error Code" }

 };

 

diff --git a/BaseTools/Source/C/VfrCompile/VfrError.h b/BaseTools/Source/C/VfrCompile/VfrError.h
index 258ae9b8..4a4af172 100644
--- a/BaseTools/Source/C/VfrCompile/VfrError.h
+++ b/BaseTools/Source/C/VfrCompile/VfrError.h
@@ -2,7 +2,7 @@
   

   VfrCompiler Error definition

 

-Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials                          

 are licensed and made available under the terms and conditions of the BSD License         

 which accompanies this distribution.  The full text of the license may be found at        

@@ -43,6 +43,7 @@ typedef enum {
   VFR_RETURN_DATA_STRING_ERROR,

   VFR_RETURN_DEFAULT_VALUE_REDEFINED,

   VFR_RETURN_CONSTANT_ONLY,

+  VFR_RETURN_VARSTORE_NAME_REDEFINED_ERROR,

   VFR_RETURN_CODEUNDEFINED

 } EFI_VFR_RETURN_CODE;

 

diff --git a/BaseTools/Source/C/VfrCompile/VfrFormPkg.cpp b/BaseTools/Source/C/VfrCompile/VfrFormPkg.cpp
index 867f9caf..7cadf0f4 100644
--- a/BaseTools/Source/C/VfrCompile/VfrFormPkg.cpp
+++ b/BaseTools/Source/C/VfrCompile/VfrFormPkg.cpp
@@ -2,7 +2,7 @@
   

   The definition of CFormPkg's member function

 

-Copyright (c) 2004 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials                          

 are licensed and made available under the terms and conditions of the BSD License         

 which accompanies this distribution.  The full text of the license may be found at        

@@ -803,8 +803,10 @@ CFormPkg::DeclarePendingQuestion (
   CHAR8          FName[MAX_NAME_LEN];

   CHAR8          *SName;

   CHAR8          *NewStr;

+  UINT32         ShrinkSize;

   EFI_VFR_RETURN_CODE  ReturnCode;

   EFI_VFR_VARSTORE_TYPE VarStoreType  = EFI_VFR_VARSTORE_INVALID;

+  EFI_VARSTORE_ID       VarStoreId    = EFI_VARSTORE_ID_INVALID;

 

   //

   // Declare all questions as Numeric in DisableIf True

@@ -822,7 +824,7 @@ CFormPkg::DeclarePendingQuestion (
     if (pNode->mFlag == PENDING) {

       CIfrNumeric CNObj;

       EFI_VARSTORE_INFO Info; 

-  	  EFI_QUESTION_ID   QId   = EFI_QUESTION_ID_INVALID;

+      EFI_QUESTION_ID   QId   = EFI_QUESTION_ID_INVALID;

 

       CNObj.SetLineNo (LineNo);

       CNObj.SetPrompt (0x0);

@@ -852,7 +854,7 @@ CFormPkg::DeclarePendingQuestion (
       //

       // Get VarStoreType

       //

-      ReturnCode = lCVfrDataStorage.GetVarStoreType (FName, VarStoreType);

+      ReturnCode = lCVfrDataStorage.GetVarStoreId (FName, &Info.mVarStoreId);

       if (ReturnCode == VFR_RETURN_UNDEFINED) {

         lCVfrDataStorage.DeclareBufferVarStore (

                            FName, 

@@ -862,18 +864,13 @@ CFormPkg::DeclarePendingQuestion (
                            EFI_VARSTORE_ID_INVALID,

                            FALSE

                            );

-        ReturnCode = lCVfrDataStorage.GetVarStoreType (FName, VarStoreType);  

-      }

-      if (ReturnCode != VFR_RETURN_SUCCESS) {

-        gCVfrErrorHandle.PrintMsg (pNode->mLineNo, FName, "Error", "Var Store Type is not defined");

-        return ReturnCode;

+        ReturnCode = lCVfrDataStorage.GetVarStoreId (FName, &Info.mVarStoreId, LocalFormSetGuid); 

       }

-      

-      ReturnCode = lCVfrDataStorage.GetVarStoreId (FName, &Info.mVarStoreId);

       if (ReturnCode != VFR_RETURN_SUCCESS) {

         gCVfrErrorHandle.PrintMsg (pNode->mLineNo, FName, "Error", "Var Store Type is not defined");

         return ReturnCode;

       }

+      VarStoreType = lCVfrDataStorage.GetVarStoreType (Info.mVarStoreId); 

 

       if (*VarStr == '\0' && ArrayIdx != INVALID_ARRAY_INDEX) {

         ReturnCode = lCVfrDataStorage.GetNameVarStoreInfo (&Info, ArrayIdx);

@@ -883,7 +880,7 @@ CFormPkg::DeclarePendingQuestion (
         } else if (VarStoreType == EFI_VFR_VARSTORE_BUFFER) {

           VarStr = pNode->mKey;

           //convert VarStr with store name to VarStr with structure name

-          ReturnCode = lCVfrDataStorage.GetBufferVarStoreDataTypeName (FName, &SName);

+          ReturnCode = lCVfrDataStorage.GetBufferVarStoreDataTypeName (Info.mVarStoreId, &SName);

           if (ReturnCode == VFR_RETURN_SUCCESS) {

             NewStr = new CHAR8[strlen (VarStr) + strlen (SName) + 1];

             NewStr[0] = '\0';

@@ -917,19 +914,24 @@ CFormPkg::DeclarePendingQuestion (
       switch (Info.mVarType) {

       case EFI_IFR_TYPE_NUM_SIZE_64:

         CNObj.SetMinMaxStepData ((UINT64) 0, (UINT64) -1 , (UINT64) 0);

+        ShrinkSize = 0;

         break;

       case EFI_IFR_TYPE_NUM_SIZE_32:

         CNObj.SetMinMaxStepData ((UINT32) 0, (UINT32) -1 , (UINT32) 0);

+        ShrinkSize = 12;

         break;

       case EFI_IFR_TYPE_NUM_SIZE_16:

         CNObj.SetMinMaxStepData ((UINT16) 0, (UINT16) -1 , (UINT16) 0);

+        ShrinkSize = 18;

         break;

       case EFI_IFR_TYPE_NUM_SIZE_8:

         CNObj.SetMinMaxStepData ((UINT8) 0, (UINT8) -1 , (UINT8) 0);

+        ShrinkSize = 21;

         break;

       default:

         break;

       }

+      CNObj.ShrinkBinSize (ShrinkSize);

 

       //

       // For undefined Efi VarStore type question

@@ -939,7 +941,7 @@ CFormPkg::DeclarePendingQuestion (
         CIfrVarEqName CVNObj (QId, Info.mInfo.mVarName);

         CVNObj.SetLineNo (LineNo);

       }

-      

+

       //

       // End for Numeric

       //

@@ -1240,6 +1242,18 @@ CIfrRecordInfoDB::GetRecordInfoFromOffset (
   return pNode;

 }

 

+/*

+  Add just the op code position.

+

+  From

+  

+  | form end opcode + end of if opcode for form ... + Dynamic opcode + form set end opcode |

+  

+  To

+  

+  | Dynamic opcode + form end opcode + end of if opcode for form ... + form set end opcode |

+

+*/

 BOOLEAN

 CIfrRecordInfoDB::IfrAdjustDynamicOpcodeInRecords (

   VOID

diff --git a/BaseTools/Source/C/VfrCompile/VfrSyntax.g b/BaseTools/Source/C/VfrCompile/VfrSyntax.g
index 76d15790..65f0421c 100644
--- a/BaseTools/Source/C/VfrCompile/VfrSyntax.g
+++ b/BaseTools/Source/C/VfrCompile/VfrSyntax.g
@@ -604,6 +604,10 @@ vfrFormSetDefinition :
 

                                                       CRT_END_OP (E);

 

+                                                      //

+                                                      // Adjust the pending question position.

+                                                      // Move the position from current to before the end of the last form in the form set.

+                                                      //

                                                       if (gNeedAdjustOpcode) {

                                                         gCFormPkg.AdjustDynamicInsertOpcode (

                                                           mLastFormEndAddr,

@@ -894,7 +898,7 @@ vfrStatementVarStoreLinear :
                                                                                   VarStoreId

                                                                                   ), LineNum);

                                                        VSObj.SetGuid (&Guid);

-                                                       _PCATCH(mCVfrDataStorage.GetVarStoreId(StoreName, &VarStoreId), SN);

+                                                       _PCATCH(mCVfrDataStorage.GetVarStoreId(StoreName, &VarStoreId, &Guid), SN);

                                                        VSObj.SetVarStoreId (VarStoreId);

                                                        _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize(TypeName, &Size), LineNum);

                                                        VSObj.SetSize ((UINT16) Size);

@@ -980,7 +984,7 @@ vfrStatementVarStoreEfi :
                                                                                   TypeName,

                                                                                   VarStoreId

                                                                                   ), LineNum);                                                        

-                                                         _PCATCH(mCVfrDataStorage.GetVarStoreId(StoreName, &VarStoreId), SN);

+                                                         _PCATCH(mCVfrDataStorage.GetVarStoreId(StoreName, &VarStoreId, &Guid), SN);

                                                          _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize(TypeName, &Size), LineNum);

                                                        } else {

                                                         _PCATCH(mCVfrDataStorage.DeclareBufferVarStore (

@@ -990,7 +994,7 @@ vfrStatementVarStoreEfi :
                                                                                   TypeName,

                                                                                   VarStoreId

                                                                                   ), LineNum);                                                      

-                                                         _PCATCH(mCVfrDataStorage.GetVarStoreId(TN->getText(), &VarStoreId), VN);

+                                                         _PCATCH(mCVfrDataStorage.GetVarStoreId(TN->getText(), &VarStoreId, &Guid), VN);

                                                          _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize(TypeName, &Size), N->getLine());

                                                        }

                                                        VSEObj.SetGuid (&Guid);                                                       

@@ -1023,7 +1027,7 @@ vfrStatementVarStoreNameValue :
   Uuid "=" guidDefinition[Guid]                     << _PCATCH(mCVfrDataStorage.DeclareNameVarStoreEnd (&Guid), SN); >>

                                                     <<

                                                        VSNVObj.SetGuid (&Guid);

-                                                       _PCATCH(mCVfrDataStorage.GetVarStoreId(SN->getText(), &VarStoreId), SN);

+                                                       _PCATCH(mCVfrDataStorage.GetVarStoreId(SN->getText(), &VarStoreId, &Guid), SN);

                                                        VSNVObj.SetVarStoreId (VarStoreId);

                                                     >>

   ";"

@@ -1097,6 +1101,10 @@ vfrStatementHeader[CIfrStatementHeader *SHObj] :
 vfrQuestionHeader[CIfrQuestionHeader & QHObj, EFI_QUESION_TYPE QType = QUESTION_NORMAL]:

   <<

      EFI_VARSTORE_INFO Info;

+     Info.mVarType               = EFI_IFR_TYPE_OTHER;

+     Info.mVarTotalSize          = 0;

+     Info.mInfo.mVarOffset       = EFI_VAROFFSET_INVALID;

+     Info.mVarStoreId            = EFI_VARSTORE_ID_INVALID;

      EFI_QUESTION_ID   QId       = EFI_QUESTION_ID_INVALID;

      CHAR8             *QName    = NULL;

      CHAR8             *VarIdStr = NULL;

@@ -1147,8 +1155,8 @@ vfrQuestionHeader[CIfrQuestionHeader & QHObj, EFI_QUESION_TYPE QType = QUESTION_
                                                     << 

                                                        if (VarIdStr != NULL) {

                                                          delete VarIdStr; 

-                                                         _SAVE_CURRQEST_VARINFO (Info);

                                                        }

+                                                       _SAVE_CURRQEST_VARINFO (Info);

                                                     >>

   ;

 

@@ -1172,6 +1180,7 @@ vfrStorageVarId[EFI_VARSTORE_INFO & Info, CHAR8 *&QuestVarIdStr, BOOLEAN CheckFl
      CHAR8                 *TName       = NULL;

      EFI_VFR_RETURN_CODE   VfrReturnCode = VFR_RETURN_SUCCESS;

      EFI_IFR_TYPE_VALUE    Dummy        = gZeroEfiIfrTypeValue;

+     EFI_GUID              *VarGuid     = NULL;

   >>

   (

     SN1:StringIdentifier                            << SName = SN1->getText(); _STRCAT(&VarIdStr, SN1->getText()); >>

@@ -1182,7 +1191,7 @@ vfrStorageVarId[EFI_VARSTORE_INFO & Info, CHAR8 *&QuestVarIdStr, BOOLEAN CheckFl
                                                        _STRCAT(&VarIdStr, "]");

                                                     >>

                                                     <<

-                                                       VfrReturnCode = mCVfrDataStorage.GetVarStoreType (SName, VarStoreType);

+                                                       VfrReturnCode = mCVfrDataStorage.GetVarStoreId(SName, &$Info.mVarStoreId);

                                                        if (mCompatibleMode && VfrReturnCode == VFR_RETURN_UNDEFINED) {

                                                           mCVfrDataStorage.DeclareBufferVarStore (

                                                                              SName,

@@ -1192,11 +1201,10 @@ vfrStorageVarId[EFI_VARSTORE_INFO & Info, CHAR8 *&QuestVarIdStr, BOOLEAN CheckFl
                                                                              EFI_VARSTORE_ID_INVALID,

                                                                              FALSE

                                                                              );

-                                                          VfrReturnCode = mCVfrDataStorage.GetVarStoreType (SName, VarStoreType);

+                                                          VfrReturnCode = mCVfrDataStorage.GetVarStoreId(SName, &$Info.mVarStoreId, &mFormsetGuid);

                                                        }

                                                        if (CheckFlag || VfrReturnCode == VFR_RETURN_SUCCESS) {

                                                          _PCATCH(VfrReturnCode, SN1);

-                                                         _PCATCH(mCVfrDataStorage.GetVarStoreId (SName, &$Info.mVarStoreId), SN1);

                                                          _PCATCH(mCVfrDataStorage.GetNameVarStoreInfo (&$Info, Idx), SN1);

                                                        }

 

@@ -1207,7 +1215,7 @@ vfrStorageVarId[EFI_VARSTORE_INFO & Info, CHAR8 *&QuestVarIdStr, BOOLEAN CheckFl
   (

     SN2:StringIdentifier                            << SName = SN2->getText(); _STRCAT(&VarIdStr, SName); >>

                                                     <<

-                                                       VfrReturnCode = mCVfrDataStorage.GetVarStoreType (SName, VarStoreType);

+                                                       VfrReturnCode = mCVfrDataStorage.GetVarStoreId(SName, &$Info.mVarStoreId);

                                                        if (mCompatibleMode && VfrReturnCode == VFR_RETURN_UNDEFINED) {

                                                           mCVfrDataStorage.DeclareBufferVarStore (

                                                                              SName,

@@ -1217,13 +1225,13 @@ vfrStorageVarId[EFI_VARSTORE_INFO & Info, CHAR8 *&QuestVarIdStr, BOOLEAN CheckFl
                                                                              EFI_VARSTORE_ID_INVALID,

                                                                              FALSE

                                                                              );

-                                                          VfrReturnCode = mCVfrDataStorage.GetVarStoreType (SName, VarStoreType);

+                                                          VfrReturnCode = mCVfrDataStorage.GetVarStoreId(SName, &$Info.mVarStoreId, &mFormsetGuid);

                                                        }

                                                        if (CheckFlag || VfrReturnCode == VFR_RETURN_SUCCESS) {

                                                          _PCATCH(VfrReturnCode, SN2);

-                                                         _PCATCH(mCVfrDataStorage.GetVarStoreId (SName, &$Info.mVarStoreId), SN2);

+                                                         VarStoreType = mCVfrDataStorage.GetVarStoreType ($Info.mVarStoreId);

                                                          if (VarStoreType == EFI_VFR_VARSTORE_BUFFER) {

-                                                           _PCATCH(mCVfrDataStorage.GetBufferVarStoreDataTypeName(SName, &TName), SN2);

+                                                           _PCATCH(mCVfrDataStorage.GetBufferVarStoreDataTypeName(Info.mVarStoreId, &TName), SN2);

                                                            _STRCAT(&VarStr, TName);

                                                          }

                                                        }

@@ -1262,13 +1270,16 @@ vfrStorageVarId[EFI_VARSTORE_INFO & Info, CHAR8 *&QuestVarIdStr, BOOLEAN CheckFl
                                                          break;

                                                        case EFI_VFR_VARSTORE_BUFFER:

                                                          _PCATCH(gCVfrVarDataTypeDB.GetDataFieldInfo (VarStr, $Info.mInfo.mVarOffset, $Info.mVarType, $Info.mVarTotalSize), SN2->getLine(), VarStr);

+                                                         VarGuid = mCVfrDataStorage.GetVarStoreGuid($Info.mVarStoreId);

                                                          _PCATCH((EFI_VFR_RETURN_CODE)gCVfrBufferConfig.Register (

                                                                     SName,

+                                                                    VarGuid,

                                                                     NULL),

                                                                  SN2->getLine());

                                                          _PCATCH((EFI_VFR_RETURN_CODE)gCVfrBufferConfig.Write (

                                                                     'a',

                                                                     SName,

+                                                                    VarGuid,

                                                                     NULL,

                                                                     $Info.mVarType,

                                                                     $Info.mInfo.mVarOffset,

@@ -1472,8 +1483,8 @@ vfrStatementDefault :
      EFI_DEFAULT_ID        DefaultId     = EFI_HII_DEFAULT_CLASS_STANDARD;

      CHAR8                 *VarStoreName = NULL;

      EFI_VFR_VARSTORE_TYPE VarStoreType  = EFI_VFR_VARSTORE_INVALID;

-     UINT8                 Size          = 0;

-     BOOLEAN               TypeError     = FALSE;

+     UINT32                Size          = 0;

+     EFI_GUID              *VarGuid      = NULL;

   >>

   D:Default                                         

   (

@@ -1486,53 +1497,14 @@ vfrStatementDefault :
                                                             _PCATCH (VFR_RETURN_INVALID_PARAMETER, D->getLine(), "Numeric default value must be between MinValue and MaxValue.");

                                                           }

                                                         }

-                                                        switch (_GET_CURRQEST_DATATYPE()) {

-                                                         case EFI_IFR_TYPE_NUM_SIZE_8:

-                                                           Size = 1;

-                                                           break;

-

-                                                         case EFI_IFR_TYPE_NUM_SIZE_16:

-                                                           Size = 2;

-                                                           break;

-

-                                                         case EFI_IFR_TYPE_NUM_SIZE_32:

-                                                           Size = 4;

-                                                           break;

-

-                                                         case EFI_IFR_TYPE_NUM_SIZE_64:

-                                                           Size = 8;

-                                                           break;

-

-                                                         case EFI_IFR_TYPE_DATE:

-                                                           Size = 4;

-                                                           break;

-

-                                                         case EFI_IFR_TYPE_TIME:

-                                                           Size = 3;

-                                                           break;

-

-                                                         case EFI_IFR_TYPE_REF:

-                                                           Size = 22;

-                                                           break;

-

-                                                         case EFI_IFR_TYPE_STRING:

-                                                           Size = 2;

-                                                           break;

-

-                                                         case EFI_IFR_TYPE_BOOLEAN:

-                                                           Size = 1;

-                                                           break;

-

-                                                         default:

-                                                           TypeError = TRUE;

-                                                           Size = sizeof (EFI_IFR_TYPE_VALUE);

-                                                           break;

-                                                         }

-                                                        if (TypeError) {

+                                                        if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) {

                                                           _PCATCH (VFR_RETURN_FATAL_ERROR, D->getLine(), "Default data type error.");

+                                                          Size = sizeof (EFI_IFR_TYPE_VALUE);

+                                                        } else {

+                                                          _PCATCH (gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &Size), D->getLine());

                                                         }

                                                         Size += OFFSET_OF (EFI_IFR_DEFAULT, Value);

-                                                        DObj = new CIfrDefault (Size);

+                                                        DObj = new CIfrDefault ((UINT8)Size);

                                                         DObj->SetLineNo(D->getLine());

                                                         DObj->SetType (_GET_CURRQEST_DATATYPE()); 

                                                         DObj->SetValue(Val);

@@ -1553,19 +1525,22 @@ vfrStatementDefault :
                                                     >>

     }

                                                     <<

+                                                      if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) {

                                                        _PCATCH(mCVfrDataStorage.GetVarStoreName (_GET_CURRQEST_VARTINFO().mVarStoreId, &VarStoreName), D->getLine());

-                                                       _PCATCH(mCVfrDataStorage.GetVarStoreType (VarStoreName, VarStoreType), D->getLine());

+                                                       VarGuid = mCVfrDataStorage.GetVarStoreGuid(_GET_CURRQEST_VARTINFO().mVarStoreId);

+                                                       VarStoreType = mCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId);

                                                        if ((IsExp == FALSE) && (VarStoreType == EFI_VFR_VARSTORE_BUFFER)) {

                                                          _PCATCH(mCVfrDefaultStore.BufferVarStoreAltConfigAdd (

                                                                    DefaultId,

                                                                    _GET_CURRQEST_VARTINFO(),

                                                                    VarStoreName,

+                                                                   VarGuid,

                                                                    _GET_CURRQEST_DATATYPE (),

-                                                                   Val),

-                                                                   D->getLine()

-                                                                   );

+                                                                     Val),

+                                                                     D->getLine()

+                                                                     );

+                                                         }

                                                        }

-

                                                        if (DObj  != NULL) {delete DObj;} 

                                                        if (DObj2 != NULL) {delete DObj2;} 

                                                     >>

@@ -1832,7 +1807,11 @@ vfrStatementGoto :
                                                           default: break;

                                                           }

                                                        >>

-  vfrQuestionHeader[*QHObj, QUESTION_REF]

+  vfrQuestionHeader[*QHObj, QUESTION_REF]              <<

+                                                          if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) {

+                                                            _GET_CURRQEST_VARTINFO().mVarType = EFI_IFR_TYPE_REF;

+                                                          }

+                                                       >>

   { "," F:FLAGS  "=" vfrGotoFlags[QHObj, F->getLine()] }

   {

     "," Key "=" KN:Number                              << AssignQuestionKey (*QHObj, KN); >>

@@ -1901,9 +1880,13 @@ vfrStatementCheckBox :
      EFI_IFR_TYPE_VALUE Val = gZeroEfiIfrTypeValue;

      CHAR8              *VarStoreName = NULL;

      UINT32             DataTypeSize;

+     EFI_GUID           *VarStoreGuid = NULL;

   >>

   L:CheckBox                                           << CBObj.SetLineNo(L->getLine()); >>

   vfrQuestionHeader[CBObj] ","                         << //check data type

+                                                          if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) {

+                                                            _GET_CURRQEST_VARTINFO().mVarType = EFI_IFR_TYPE_BOOLEAN;

+                                                          }

                                                           _PCATCH (gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize), L->getLine(), "CheckBox varid is not the valid data type");

                                                           if (DataTypeSize != 0 && DataTypeSize != _GET_CURRQEST_VARSIZE()) {

                                                             _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "CheckBox varid doesn't support array");

@@ -1916,6 +1899,7 @@ vfrStatementCheckBox :
     F:FLAGS "=" vfrCheckBoxFlags[CBObj, F->getLine()] ","

                                                        <<

                                                           _PCATCH(mCVfrDataStorage.GetVarStoreName (_GET_CURRQEST_VARTINFO().mVarStoreId, &VarStoreName), VFR_RETURN_SUCCESS, L, "Failed to retrieve varstore name");

+                                                          VarStoreGuid = mCVfrDataStorage.GetVarStoreGuid(_GET_CURRQEST_VARTINFO().mVarStoreId);

                                                           Val.b = TRUE;

                                                           if (CBObj.GetFlags () & 0x01) {

                                                             _PCATCH(

@@ -1923,6 +1907,7 @@ vfrStatementCheckBox :
                                                                                   EFI_HII_DEFAULT_CLASS_STANDARD,

                                                                                   _GET_CURRQEST_VARTINFO(),

                                                                                   VarStoreName,

+                                                                                  VarStoreGuid,

                                                                                   _GET_CURRQEST_DATATYPE (),

                                                                                   Val

                                                                                   ),

@@ -1937,6 +1922,7 @@ vfrStatementCheckBox :
                                                                                   EFI_HII_DEFAULT_CLASS_MANUFACTURING,

                                                                                   _GET_CURRQEST_VARTINFO(),

                                                                                   VarStoreName,

+                                                                                  VarStoreGuid,

                                                                                   _GET_CURRQEST_DATATYPE (),

                                                                                   Val

                                                                                   ),

@@ -2044,7 +2030,11 @@ vfrStatementDate :
   L:Date                                               << DObj.SetLineNo(L->getLine()); >>

   (

     (

-      vfrQuestionHeader[DObj, QUESTION_DATE] ","

+      vfrQuestionHeader[DObj, QUESTION_DATE] ","       <<

+                                                          if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) {

+                                                            _GET_CURRQEST_VARTINFO().mVarType = EFI_IFR_TYPE_DATE;

+                                                          }

+                                                       >>

     { F:FLAGS "=" vfrDateFlags[DObj, F->getLine()] "," }

       vfrStatementQuestionOptionList

     )

@@ -2517,7 +2507,11 @@ vfrStatementTime :
   L:Time                                               << TObj.SetLineNo(L->getLine()); >>

   (

     (

-      vfrQuestionHeader[TObj, QUESTION_TIME] ","

+      vfrQuestionHeader[TObj, QUESTION_TIME] ","       <<

+                                                          if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) {

+                                                            _GET_CURRQEST_VARTINFO().mVarType = EFI_IFR_TYPE_TIME;

+                                                          }

+                                                       >>

     { F:FLAGS "=" vfrTimeFlags[TObj, F->getLine()] "," }

       vfrStatementQuestionOptionList

     )

@@ -2866,32 +2860,29 @@ vfrStatementOneOfOption :
   <<

      EFI_IFR_TYPE_VALUE Val           = gZeroEfiIfrTypeValue;

      CHAR8              *VarStoreName = NULL;

+     UINT32             Size          = 0;

      BOOLEAN            TypeError     = FALSE;

-     UINT8              Size          = 0;

-

-     switch (_GET_CURRQEST_DATATYPE()) {

-     case EFI_IFR_TYPE_NUM_SIZE_8:  Size = 1; break;

-     case EFI_IFR_TYPE_NUM_SIZE_16: Size = 2; break;

-     case EFI_IFR_TYPE_NUM_SIZE_32: Size = 4; break;

-     case EFI_IFR_TYPE_NUM_SIZE_64: Size = 8; break;

-     case EFI_IFR_TYPE_DATE:        Size = 4; break;

-     case EFI_IFR_TYPE_TIME:        Size = 3; break;

-     case EFI_IFR_TYPE_REF:         Size = 22;break;

-     case EFI_IFR_TYPE_STRING:      Size = 2; break;

-     case EFI_IFR_TYPE_BOOLEAN:     Size = 1; break;

-     default:

+     EFI_VFR_RETURN_CODE ReturnCode   = VFR_RETURN_SUCCESS;

+     EFI_GUID           *VarStoreGuid = NULL;

+     

+     if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) {

        TypeError = TRUE;

        Size = sizeof (EFI_IFR_TYPE_VALUE);

-       break;

+     } else {

+       ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &Size);

      }

+

      Size += OFFSET_OF (EFI_IFR_ONE_OF_OPTION, Value);

-     CIfrOneOfOption    OOOObj (Size);

+     CIfrOneOfOption    OOOObj ((UINT8)Size);

   >>

-  L:Option                                             << 

+  L:Option                                             <<      

                                                           OOOObj.SetLineNo(L->getLine());

                                                           if (TypeError) {

                                                             _PCATCH (VFR_RETURN_FATAL_ERROR, L->getLine(), "Get data type error.");

                                                           }

+                                                          if (ReturnCode != VFR_RETURN_SUCCESS) {

+                                                            _PCATCH (ReturnCode, L->getLine());

+                                                          }

                                                        >>

   Text  "=" "STRING_TOKEN" "\(" S:Number "\)" ","      << OOOObj.SetOption (_STOSID(S->getText())); >>

   Value "=" vfrConstantValueField[_GET_CURRQEST_DATATYPE()] >[Val] ","    

@@ -2922,11 +2913,13 @@ vfrStatementOneOfOption :
   F:FLAGS "=" vfrOneOfOptionFlags[OOOObj, F->getLine()]

                                                        <<

                                                           _PCATCH(mCVfrDataStorage.GetVarStoreName (_GET_CURRQEST_VARTINFO().mVarStoreId, &VarStoreName), L->getLine());

+                                                          VarStoreGuid = mCVfrDataStorage.GetVarStoreGuid(_GET_CURRQEST_VARTINFO().mVarStoreId);

                                                           if (OOOObj.GetFlags () & 0x10) {

                                                             _PCATCH(mCVfrDefaultStore.BufferVarStoreAltConfigAdd (

                                                                       EFI_HII_DEFAULT_CLASS_STANDARD,

                                                                        _GET_CURRQEST_VARTINFO(),

                                                                       VarStoreName,

+                                                                      VarStoreGuid,

                                                                       _GET_CURRQEST_DATATYPE (),

                                                                       Val

                                                                       ), L->getLine());

@@ -2936,6 +2929,7 @@ vfrStatementOneOfOption :
                                                                       EFI_HII_DEFAULT_CLASS_MANUFACTURING,

                                                                        _GET_CURRQEST_VARTINFO(),

                                                                       VarStoreName,

+                                                                      VarStoreGuid,

                                                                       _GET_CURRQEST_DATATYPE (),

                                                                       Val

                                                                       ), L->getLine());

@@ -3351,8 +3345,8 @@ vareqvalExp [UINT32 & RootLevel, UINT32 & ExpOpCount] :
      UINT16          ConstVal;

      CHAR8           *VarIdStr;

      UINT32          LineNo;

-     EFI_VFR_VARSTORE_TYPE VarStoreType = EFI_VFR_VARSTORE_INVALID;

      EFI_VFR_RETURN_CODE   VfrReturnCode = VFR_RETURN_SUCCESS;

+     EFI_VARSTORE_ID       VarStoreId   = EFI_VARSTORE_ID_INVALID;

   >>

   L:VarEqVal                                          <<

                                                         if (!mCompatibleMode) {

@@ -3363,7 +3357,7 @@ vareqvalExp [UINT32 & RootLevel, UINT32 & ExpOpCount] :
   OpenParen

   VN:Number                                           <<

                                                           VarIdStr = NULL; _STRCAT(&VarIdStr, VK->getText()); _STRCAT(&VarIdStr, VN->getText());

-                                                          VfrReturnCode = mCVfrDataStorage.GetVarStoreType (VarIdStr, VarStoreType);

+                                                          VfrReturnCode = mCVfrDataStorage.GetVarStoreId (VarIdStr, &VarStoreId);

                                                           if (VfrReturnCode == VFR_RETURN_UNDEFINED) {

                                                             _PCATCH (mCVfrDataStorage.DeclareEfiVarStore (

                                                                                         VarIdStr,

@@ -4600,7 +4594,7 @@ EfiVfrParser::_DeclareDefaultLinearVarStore (
                        TypeNameList[Index],

                        EFI_VARSTORE_ID_INVALID

                        );

-    mCVfrDataStorage.GetVarStoreId(TypeNameList[Index], &VarStoreId);

+    mCVfrDataStorage.GetVarStoreId(TypeNameList[Index], &VarStoreId, &mFormsetGuid);

     VSObj.SetVarStoreId (VarStoreId);

     gCVfrVarDataTypeDB.GetDataTypeSize(TypeNameList[Index], &Size);

     VSObj.SetSize ((UINT16) Size);

@@ -4625,7 +4619,7 @@ EfiVfrParser::_DeclareDefaultLinearVarStore (
                        (CHAR8 *) DateType,

                        EFI_VARSTORE_ID_INVALID

                        );

-    mCVfrDataStorage.GetVarStoreId((CHAR8 *) DateName, &VarStoreId);

+    mCVfrDataStorage.GetVarStoreId((CHAR8 *) DateName, &VarStoreId, &mFormsetGuid);

     VSObj.SetVarStoreId (VarStoreId);

     gCVfrVarDataTypeDB.GetDataTypeSize((CHAR8 *) DateType, &Size);

     VSObj.SetSize ((UINT16) Size);

@@ -4646,7 +4640,7 @@ EfiVfrParser::_DeclareDefaultLinearVarStore (
                        (CHAR8 *) TimeType,

                        EFI_VARSTORE_ID_INVALID

                        );

-    mCVfrDataStorage.GetVarStoreId((CHAR8 *) TimeName, &VarStoreId);

+    mCVfrDataStorage.GetVarStoreId((CHAR8 *) TimeName, &VarStoreId, &mFormsetGuid);

     VSObj.SetVarStoreId (VarStoreId);

     gCVfrVarDataTypeDB.GetDataTypeSize((CHAR8 *) TimeType, &Size);

     VSObj.SetSize ((UINT16) Size);

diff --git a/BaseTools/Source/C/VfrCompile/VfrUtilityLib.cpp b/BaseTools/Source/C/VfrCompile/VfrUtilityLib.cpp
index 0444677e..f42df6e3 100644
--- a/BaseTools/Source/C/VfrCompile/VfrUtilityLib.cpp
+++ b/BaseTools/Source/C/VfrCompile/VfrUtilityLib.cpp
@@ -2,7 +2,7 @@
   

   Vfr common library functions.

 

-Copyright (c) 2004 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials                          

 are licensed and made available under the terms and conditions of the BSD License         

 which accompanies this distribution.  The full text of the license may be found at        

@@ -123,11 +123,13 @@ SConfigInfo::~SConfigInfo (
 

 SConfigItem::SConfigItem (

   IN CHAR8               *Name,

+  IN EFI_GUID            *Guid,

   IN CHAR8               *Id

   )

 {

   mName          = NULL;

-  mId            = 0;

+  mGuid          = NULL;

+  mId            = NULL;

   mInfoStrList = NULL;

   mNext        = NULL;

 

@@ -137,6 +139,12 @@ SConfigItem::SConfigItem (
     }

   }

 

+  if (Guid != NULL) {

+    if ((mGuid = (EFI_GUID *) new CHAR8[sizeof (EFI_GUID)]) != NULL) {

+      memcpy (mGuid, Guid, sizeof (EFI_GUID));

+    }

+  }

+

   if (Id != NULL) {

     if ((mId = new CHAR8[strlen (Id) + 1]) != NULL) {

       strcpy (mId, Id);

@@ -146,6 +154,7 @@ SConfigItem::SConfigItem (
 

 SConfigItem::SConfigItem (

   IN CHAR8               *Name,

+  IN EFI_GUID            *Guid,

   IN CHAR8               *Id,

   IN UINT8               Type,

   IN UINT16              Offset,

@@ -154,6 +163,7 @@ SConfigItem::SConfigItem (
   )

 {

   mName        = NULL;

+  mGuid        = NULL;

   mId          = NULL;

   mInfoStrList = NULL;

   mNext        = NULL;

@@ -164,6 +174,12 @@ SConfigItem::SConfigItem (
     }

   }

 

+  if (Guid != NULL) {

+    if ((mGuid = (EFI_GUID *) new CHAR8[sizeof (EFI_GUID)]) != NULL) {

+      memcpy (mGuid, Guid, sizeof (EFI_GUID));

+    }

+  }

+

   if (Id != NULL) {

     if ((mId = new CHAR8[strlen (Id) + 1]) != NULL) {

       strcpy (mId, Id);

@@ -180,6 +196,7 @@ SConfigItem::~SConfigItem (
   SConfigInfo  *Info;

 

   BUFFER_SAFE_FREE (mName);

+  BUFFER_SAFE_FREE (mGuid);

   BUFFER_SAFE_FREE (mId);

   while (mInfoStrList != NULL) {

     Info = mInfoStrList;

@@ -192,18 +209,20 @@ SConfigItem::~SConfigItem (
 UINT8

 CVfrBufferConfig::Register (

   IN CHAR8               *Name,

+  IN EFI_GUID            *Guid,

   IN CHAR8               *Id

   )

 {

   SConfigItem *pNew;

 

-  if (Select (Name) == 0) {

+  if (Select (Name, Guid) == 0) {

     return 1;

   }

 

-  if ((pNew = new SConfigItem (Name, Id)) == NULL) {

+  if ((pNew = new SConfigItem (Name, Guid, Id)) == NULL) {

     return 2;

   }

+

   if (mItemListHead == NULL) {

     mItemListHead = pNew;

     mItemListTail = pNew;

@@ -234,18 +253,19 @@ CVfrBufferConfig::Eof(
 

 UINT8

 CVfrBufferConfig::Select (

-  IN CHAR8 *Name,

-  IN CHAR8 *Id

+  IN CHAR8    *Name,

+  IN EFI_GUID *Guid,

+  IN CHAR8    *Id

   )

 {

   SConfigItem *p;

 

-  if (Name == NULL) {

+  if (Name == NULL || Guid == NULL) {

     mItemListPos = mItemListHead;

     return 0;

   } else {

     for (p = mItemListHead; p != NULL; p = p->mNext) {

-      if (strcmp (p->mName, Name) != 0) {

+      if ((strcmp (p->mName, Name) != 0) || (memcmp (p->mGuid, Guid, sizeof (EFI_GUID)) != 0)) {

         continue;

       }

 

@@ -269,6 +289,7 @@ UINT8
 CVfrBufferConfig::Write (

   IN CONST CHAR8         Mode,

   IN CHAR8               *Name,

+  IN EFI_GUID            *Guid,

   IN CHAR8               *Id,

   IN UINT8               Type,

   IN UINT16              Offset,

@@ -280,14 +301,14 @@ CVfrBufferConfig::Write (
   SConfigItem   *pItem;

   SConfigInfo   *pInfo;

 

-  if ((Ret = Select (Name)) != 0) {

+  if ((Ret = Select (Name, Guid)) != 0) {

     return Ret;

   }

 

   switch (Mode) {

   case 'a' : // add

-    if (Select (Name, Id) != 0) {

-      if ((pItem = new SConfigItem (Name, Id, Type, Offset, (UINT16) Width, Value)) == NULL) {

+    if (Select (Name, Guid, Id) != 0) {

+      if ((pItem = new SConfigItem (Name, Guid, Id, Type, Offset, (UINT16) Width, Value)) == NULL) {

         return 2;

       }

       if (mItemListHead == NULL) {

@@ -1578,7 +1599,7 @@ CVfrDataStorage::DeclareEfiVarStore (
     return VFR_RETURN_EFIVARSTORE_SIZE_ERROR;

   }

 

-  if (GetVarStoreId (StoreName, &VarStoreId) == VFR_RETURN_SUCCESS) {

+  if (GetVarStoreId (StoreName, &VarStoreId, Guid) == VFR_RETURN_SUCCESS) {

     return VFR_RETURN_REDEFINED;

   }

 

@@ -1611,7 +1632,7 @@ CVfrDataStorage::DeclareBufferVarStore (
     return VFR_RETURN_FATAL_ERROR;

   }

 

-  if (GetVarStoreId (StoreName, &TempVarStoreId) == VFR_RETURN_SUCCESS) {

+  if (GetVarStoreId (StoreName, &TempVarStoreId, Guid) == VFR_RETURN_SUCCESS) {

     return VFR_RETURN_REDEFINED;

   }

 

@@ -1633,7 +1654,7 @@ CVfrDataStorage::DeclareBufferVarStore (
   pNew->mNext         = mBufferVarStoreList;

   mBufferVarStoreList = pNew;

 

-  if (gCVfrBufferConfig.Register(StoreName) != 0) {

+  if (gCVfrBufferConfig.Register(StoreName, Guid) != 0) {

     return VFR_RETURN_FATAL_ERROR;

   }

 

@@ -1643,7 +1664,8 @@ CVfrDataStorage::DeclareBufferVarStore (
 EFI_VFR_RETURN_CODE 

 CVfrDataStorage::GetVarStoreByDataType (

   IN  CHAR8              *DataTypeName,

-  OUT SVfrVarStorageNode **VarNode

+  OUT SVfrVarStorageNode **VarNode,

+  IN  EFI_GUID           *VarGuid

   )

 {

   SVfrVarStorageNode    *pNode;

@@ -1658,7 +1680,16 @@ CVfrDataStorage::GetVarStoreByDataType (
 

   MatchNode = NULL;

   for (pNode = mBufferVarStoreList; pNode != NULL; pNode = pNode->mNext) {

-    if (strcmp (pNode->mStorageInfo.mDataType->mTypeName, DataTypeName) == 0) {

+    if (strcmp (pNode->mStorageInfo.mDataType->mTypeName, DataTypeName) != 0) {

+      continue;

+    }

+

+    if ((VarGuid != NULL)) {

+      if (memcmp (VarGuid, &pNode->mGuid, sizeof (EFI_GUID)) == 0) {

+        *VarNode = pNode;

+        return VFR_RETURN_SUCCESS;

+      }

+    } else {

       if (MatchNode == NULL) {

         MatchNode = pNode;

       } else {

@@ -1678,46 +1709,108 @@ CVfrDataStorage::GetVarStoreByDataType (
   return VFR_RETURN_SUCCESS;

 }

 

+EFI_VARSTORE_ID 

+CVfrDataStorage::CheckGuidField (

+  IN  SVfrVarStorageNode   *pNode,

+  IN  EFI_GUID             *StoreGuid,

+  IN  BOOLEAN              *HasFoundOne,

+  OUT EFI_VFR_RETURN_CODE  *ReturnCode

+  )

+{

+  if (StoreGuid != NULL) {

+    //

+    // If has guid info, compare the guid filed.

+    //

+    if (memcmp (StoreGuid, &pNode->mGuid, sizeof (EFI_GUID)) == 0) {

+      //

+      // Both name and guid are same, this this varstore.

+      //

+      mCurrVarStorageNode = pNode;

+      *ReturnCode = VFR_RETURN_SUCCESS;

+      return TRUE;

+    }

+  } else {

+    //

+    // Not has Guid field, check whether this name is the only one.

+    //

+    if (*HasFoundOne) {

+      //

+      // The name has conflict, return name redefined.

+      //

+      *ReturnCode = VFR_RETURN_VARSTORE_NAME_REDEFINED_ERROR;

+      return TRUE;

+    }

+

+    *HasFoundOne = TRUE;

+    mCurrVarStorageNode = pNode;

+  }

+

+  return FALSE;

+}

+

+/**

+  Base on the input store name and guid to find the varstore id. 

+

+  If both name and guid are inputed, base on the name and guid to

+  found the varstore. If only name inputed, base on the name to

+  found the varstore and go on to check whether more than one varstore

+  has the same name. If only has found one varstore, return this

+  varstore; if more than one varstore has same name, return varstore

+  name redefined error. If no varstore found by varstore name, call

+  function GetVarStoreByDataType and use inputed varstore name as 

+  data type name to search.

+**/

 EFI_VFR_RETURN_CODE 

 CVfrDataStorage::GetVarStoreId (

   IN  CHAR8           *StoreName,

-  OUT EFI_VARSTORE_ID *VarStoreId

+  OUT EFI_VARSTORE_ID *VarStoreId,

+  IN  EFI_GUID        *StoreGuid

   )

 {

   EFI_VFR_RETURN_CODE   ReturnCode;

   SVfrVarStorageNode    *pNode;

+  BOOLEAN               HasFoundOne = FALSE;

+

+  mCurrVarStorageNode = NULL;

 

   for (pNode = mBufferVarStoreList; pNode != NULL; pNode = pNode->mNext) {

     if (strcmp (pNode->mVarStoreName, StoreName) == 0) {

-      mCurrVarStorageNode = pNode;

-      *VarStoreId = pNode->mVarStoreId;

-      return VFR_RETURN_SUCCESS;

+      if (CheckGuidField(pNode, StoreGuid, &HasFoundOne, &ReturnCode)) {

+        *VarStoreId = mCurrVarStorageNode->mVarStoreId;

+        return ReturnCode;

+      }

     }

   }

 

   for (pNode = mEfiVarStoreList; pNode != NULL; pNode = pNode->mNext) {

     if (strcmp (pNode->mVarStoreName, StoreName) == 0) {

-      mCurrVarStorageNode = pNode;

-      *VarStoreId = pNode->mVarStoreId;

-      return VFR_RETURN_SUCCESS;

+      if (CheckGuidField(pNode, StoreGuid, &HasFoundOne, &ReturnCode)) {

+        *VarStoreId = mCurrVarStorageNode->mVarStoreId;

+        return ReturnCode;

+      }

     }

   }

 

   for (pNode = mNameVarStoreList; pNode != NULL; pNode = pNode->mNext) {

     if (strcmp (pNode->mVarStoreName, StoreName) == 0) {

-      mCurrVarStorageNode = pNode;

-      *VarStoreId = pNode->mVarStoreId;

-      return VFR_RETURN_SUCCESS;

+      if (CheckGuidField(pNode, StoreGuid, &HasFoundOne, &ReturnCode)) {

+        *VarStoreId = mCurrVarStorageNode->mVarStoreId;

+        return ReturnCode;

+      }

     }

   }

 

-  mCurrVarStorageNode = NULL;

+  if (HasFoundOne) {

+    *VarStoreId = mCurrVarStorageNode->mVarStoreId;

+    return VFR_RETURN_SUCCESS;

+  }

+

   *VarStoreId         = EFI_VARSTORE_ID_INVALID;

 

   //

   // Assume that Data strucutre name is used as StoreName, and check again. 

   //

-  ReturnCode = GetVarStoreByDataType (StoreName, &pNode);

+  ReturnCode = GetVarStoreByDataType (StoreName, &pNode, StoreGuid);

   if (pNode != NULL) {

     mCurrVarStorageNode = pNode;

     *VarStoreId = pNode->mVarStoreId;

@@ -1728,126 +1821,100 @@ CVfrDataStorage::GetVarStoreId (
 

 EFI_VFR_RETURN_CODE

 CVfrDataStorage::GetBufferVarStoreDataTypeName (

-  IN  CHAR8                  *StoreName,

+  IN  EFI_VARSTORE_ID        VarStoreId,

   OUT CHAR8                  **DataTypeName

   )

 {

   SVfrVarStorageNode    *pNode;

-  EFI_VFR_RETURN_CODE   ReturnCode;

 

-  if ((StoreName == NULL) || (DataTypeName == NULL)) {

+  if (VarStoreId == EFI_VARSTORE_ID_INVALID) {

     return VFR_RETURN_FATAL_ERROR;

   }

 

   for (pNode = mBufferVarStoreList; pNode != NULL; pNode = pNode->mNext) {

-    if (strcmp (pNode->mVarStoreName, StoreName) == 0) {

-      break;

+    if (pNode->mVarStoreId == VarStoreId) {

+      *DataTypeName = pNode->mStorageInfo.mDataType->mTypeName;

+      return VFR_RETURN_SUCCESS;

     }

   }

 

-  ReturnCode = VFR_RETURN_UNDEFINED;

-  //

-  // Assume that Data strucutre name is used as StoreName, and check again. 

-  //

-  if (pNode == NULL) {

-    ReturnCode = GetVarStoreByDataType (StoreName, &pNode);

-  }

-

-  if (pNode == NULL) {

-    return ReturnCode;

-  }

-

-  if (pNode->mStorageInfo.mDataType == NULL) {

-    return VFR_RETURN_FATAL_ERROR;

-  }

-

-  *DataTypeName = pNode->mStorageInfo.mDataType->mTypeName;

-  return VFR_RETURN_SUCCESS;

+  return VFR_RETURN_UNDEFINED;

 }

 

-EFI_VFR_RETURN_CODE

+EFI_VFR_VARSTORE_TYPE

 CVfrDataStorage::GetVarStoreType (

-  IN  CHAR8                  *StoreName,

-  OUT EFI_VFR_VARSTORE_TYPE  &VarStoreType

+  IN  EFI_VARSTORE_ID        VarStoreId

   )

 {

   SVfrVarStorageNode    *pNode;

-  EFI_VFR_RETURN_CODE   ReturnCode;

+  EFI_VFR_VARSTORE_TYPE VarStoreType;

 

-  if (StoreName == NULL) {

-    return VFR_RETURN_FATAL_ERROR;

+  VarStoreType = EFI_VFR_VARSTORE_INVALID;

+

+  if (VarStoreId == EFI_VARSTORE_ID_INVALID) {

+    return VarStoreType;

   }

 

   for (pNode = mBufferVarStoreList; pNode != NULL; pNode = pNode->mNext) {

-    if (strcmp (pNode->mVarStoreName, StoreName) == 0) {

+    if (pNode->mVarStoreId == VarStoreId) {

       VarStoreType = pNode->mVarStoreType;

-      return VFR_RETURN_SUCCESS;

+      return VarStoreType;

     }

   }

 

   for (pNode = mEfiVarStoreList; pNode != NULL; pNode = pNode->mNext) {

-    if (strcmp (pNode->mVarStoreName, StoreName) == 0) {

+    if (pNode->mVarStoreId == VarStoreId) {

       VarStoreType = pNode->mVarStoreType;

-      return VFR_RETURN_SUCCESS;

+      return VarStoreType;

     }

   }

 

   for (pNode = mNameVarStoreList; pNode != NULL; pNode = pNode->mNext) {

-    if (strcmp (pNode->mVarStoreName, StoreName) == 0) {

+    if (pNode->mVarStoreId == VarStoreId) {

       VarStoreType = pNode->mVarStoreType;

-      return VFR_RETURN_SUCCESS;

+      return VarStoreType;

     }

   }

 

-  VarStoreType = EFI_VFR_VARSTORE_INVALID;

-

-  //

-  // Assume that Data strucutre name is used as StoreName, and check again. 

-  //

-  ReturnCode = GetVarStoreByDataType (StoreName, &pNode);

-  if (pNode != NULL) {

-    VarStoreType = pNode->mVarStoreType;

-  }

-  

-  return ReturnCode;

+  return VarStoreType;

 }

 

-EFI_VFR_VARSTORE_TYPE

-CVfrDataStorage::GetVarStoreType (

+EFI_GUID *

+CVfrDataStorage::GetVarStoreGuid (

   IN  EFI_VARSTORE_ID        VarStoreId

   )

 {

   SVfrVarStorageNode    *pNode;

-  EFI_VFR_VARSTORE_TYPE VarStoreType;

+  EFI_GUID              *VarGuid;

 

-  VarStoreType = EFI_VFR_VARSTORE_INVALID;

+  VarGuid = NULL;

 

   if (VarStoreId == EFI_VARSTORE_ID_INVALID) {

-    return VarStoreType;

+    return VarGuid;

   }

 

   for (pNode = mBufferVarStoreList; pNode != NULL; pNode = pNode->mNext) {

     if (pNode->mVarStoreId == VarStoreId) {

-      VarStoreType = pNode->mVarStoreType;

-      return VarStoreType;

+      VarGuid = &pNode->mGuid;

+      return VarGuid;

     }

   }

 

   for (pNode = mEfiVarStoreList; pNode != NULL; pNode = pNode->mNext) {

     if (pNode->mVarStoreId == VarStoreId) {

-      VarStoreType = pNode->mVarStoreType;

-      return VarStoreType;

+      VarGuid = &pNode->mGuid;

+      return VarGuid;

     }

   }

 

   for (pNode = mNameVarStoreList; pNode != NULL; pNode = pNode->mNext) {

     if (pNode->mVarStoreId == VarStoreId) {

-      VarStoreType = pNode->mVarStoreType;

-      return VarStoreType;

+      VarGuid = &pNode->mGuid;

+      return VarGuid;

     }

   }

 

-  return VarStoreType;

+  return VarGuid;

 }

 

 EFI_VFR_RETURN_CODE

@@ -1951,44 +2018,6 @@ CVfrDataStorage::GetNameVarStoreInfo (
   return VFR_RETURN_SUCCESS;

 }

 

-EFI_VFR_RETURN_CODE

-CVfrDataStorage::BufferVarStoreRequestElementAdd (

-  IN CHAR8             *StoreName,

-  IN EFI_VARSTORE_INFO &Info

-  )

-{

-  SVfrVarStorageNode    *pNode = NULL;

-  EFI_IFR_TYPE_VALUE    Value = gZeroEfiIfrTypeValue;

-  EFI_VFR_RETURN_CODE   ReturnCode;

-

-  for (pNode = mBufferVarStoreList; pNode != NULL; pNode = pNode->mNext) {

-    if (strcmp (pNode->mVarStoreName, StoreName) == 0) {

-      break;

-    }

-  }

-

-  ReturnCode = VFR_RETURN_UNDEFINED;

-  //

-  // Assume that Data strucutre name is used as StoreName, and check again. 

-  //

-  if (pNode == NULL) {

-    ReturnCode = GetVarStoreByDataType (StoreName, &pNode);

-  }

-

-  if (pNode == NULL) {

-    return ReturnCode;

-  }

-

-  gCVfrBufferConfig.Open ();

-  Value.u8 = 0;

-  if (gCVfrBufferConfig.Write ('a', StoreName, NULL, EFI_IFR_TYPE_NUM_SIZE_8, Info.mInfo.mVarOffset, Info.mVarTotalSize, Value) != 0) {

-    return VFR_RETURN_FATAL_ERROR;

-  }

-  gCVfrBufferConfig.Close ();

-

-  return VFR_RETURN_SUCCESS;

-}

-

 SVfrDefaultStoreNode::SVfrDefaultStoreNode (

   IN EFI_IFR_DEFAULTSTORE *ObjBinAddr,

   IN CHAR8                *RefName, 

@@ -2155,6 +2184,7 @@ CVfrDefaultStore::BufferVarStoreAltConfigAdd (
   IN EFI_VARSTORE_ID    DefaultId,

   IN EFI_VARSTORE_INFO  &Info,

   IN CHAR8              *VarStoreName,

+  IN EFI_GUID           *VarStoreGuid,

   IN UINT8              Type,

   IN EFI_IFR_TYPE_VALUE Value

   )

@@ -2180,8 +2210,8 @@ CVfrDefaultStore::BufferVarStoreAltConfigAdd (
   gCVfrBufferConfig.Open ();

 

   sprintf (NewAltCfg, "%04x", pNode->mDefaultId);

-  if ((Returnvalue = gCVfrBufferConfig.Select(VarStoreName)) == 0) {

-    if ((Returnvalue = gCVfrBufferConfig.Write ('a', VarStoreName, NewAltCfg, Type, Info.mInfo.mVarOffset, Info.mVarTotalSize, Value)) != 0) {

+  if ((Returnvalue = gCVfrBufferConfig.Select(VarStoreName, VarStoreGuid)) == 0) {

+    if ((Returnvalue = gCVfrBufferConfig.Write ('a', VarStoreName, VarStoreGuid, NewAltCfg, Type, Info.mInfo.mVarOffset, Info.mVarTotalSize, Value)) != 0) {

       goto WriteError;

     }

   }

@@ -2592,26 +2622,46 @@ CVfrQuestionDB::RegisterNewDateQuestion (
   CHAR8                *VarIdStr[3] = {NULL, };

   CHAR8                 Index;

 

-  if (BaseVarId == NULL) {

+  if (BaseVarId == NULL && Name == NULL) {

     return;

   }

 

-  Len = strlen (BaseVarId);

+  if (BaseVarId != NULL) {

+    Len = strlen (BaseVarId);

 

-  VarIdStr[0] = new CHAR8[Len + strlen (".Year") + 1];

-  if (VarIdStr[0] != NULL) {

-    strcpy (VarIdStr[0], BaseVarId);

-    strcat (VarIdStr[0], ".Year");

-  }

-  VarIdStr[1] = new CHAR8[Len + strlen (".Month") + 1];

-  if (VarIdStr[1] != NULL) {

-    strcpy (VarIdStr[1], BaseVarId);

-    strcat (VarIdStr[1], ".Month");

-  }

-  VarIdStr[2] = new CHAR8[Len + strlen (".Day") + 1];

-  if (VarIdStr[2] != NULL) {

-    strcpy (VarIdStr[2], BaseVarId);

-    strcat (VarIdStr[2], ".Day");

+    VarIdStr[0] = new CHAR8[Len + strlen (".Year") + 1];

+    if (VarIdStr[0] != NULL) {

+      strcpy (VarIdStr[0], BaseVarId);

+      strcat (VarIdStr[0], ".Year");

+    }

+    VarIdStr[1] = new CHAR8[Len + strlen (".Month") + 1];

+    if (VarIdStr[1] != NULL) {

+      strcpy (VarIdStr[1], BaseVarId);

+      strcat (VarIdStr[1], ".Month");

+    }

+    VarIdStr[2] = new CHAR8[Len + strlen (".Day") + 1];

+    if (VarIdStr[2] != NULL) {

+      strcpy (VarIdStr[2], BaseVarId);

+      strcat (VarIdStr[2], ".Day");

+    }

+  } else {

+    Len = strlen (Name);

+

+    VarIdStr[0] = new CHAR8[Len + strlen (".Year") + 1];

+    if (VarIdStr[0] != NULL) {

+      strcpy (VarIdStr[0], Name);

+      strcat (VarIdStr[0], ".Year");

+    }

+    VarIdStr[1] = new CHAR8[Len + strlen (".Month") + 1];

+    if (VarIdStr[1] != NULL) {

+      strcpy (VarIdStr[1], Name);

+      strcat (VarIdStr[1], ".Month");

+    }

+    VarIdStr[2] = new CHAR8[Len + strlen (".Day") + 1];

+    if (VarIdStr[2] != NULL) {

+      strcpy (VarIdStr[2], Name);

+      strcat (VarIdStr[2], ".Day");

+    }

   }

 

   if ((pNode[0] = new SVfrQuestionNode (Name, VarIdStr[0], DATE_YEAR_BITMASK)) == NULL) {

@@ -2740,26 +2790,46 @@ CVfrQuestionDB::RegisterNewTimeQuestion (
   CHAR8                *VarIdStr[3] = {NULL, };

   CHAR8                 Index;

 

-  if (BaseVarId == NULL) {

+  if (BaseVarId == NULL && Name == NULL) {

     return;

   }

 

-  Len = strlen (BaseVarId);

+  if (BaseVarId != NULL) {

+    Len = strlen (BaseVarId);

 

-  VarIdStr[0] = new CHAR8[Len + strlen (".Hour") + 1];

-  if (VarIdStr[0] != NULL) {

-    strcpy (VarIdStr[0], BaseVarId);

-    strcat (VarIdStr[0], ".Hour");

-  }

-  VarIdStr[1] = new CHAR8[Len + strlen (".Minute") + 1];

-  if (VarIdStr[1] != NULL) {

-    strcpy (VarIdStr[1], BaseVarId);

-    strcat (VarIdStr[1], ".Minute");

-  }

-  VarIdStr[2] = new CHAR8[Len + strlen (".Second") + 1];

-  if (VarIdStr[2] != NULL) {

-    strcpy (VarIdStr[2], BaseVarId);

-    strcat (VarIdStr[2], ".Second");

+    VarIdStr[0] = new CHAR8[Len + strlen (".Hour") + 1];

+    if (VarIdStr[0] != NULL) {

+      strcpy (VarIdStr[0], BaseVarId);

+      strcat (VarIdStr[0], ".Hour");

+    }

+    VarIdStr[1] = new CHAR8[Len + strlen (".Minute") + 1];

+    if (VarIdStr[1] != NULL) {

+      strcpy (VarIdStr[1], BaseVarId);

+      strcat (VarIdStr[1], ".Minute");

+    }

+    VarIdStr[2] = new CHAR8[Len + strlen (".Second") + 1];

+    if (VarIdStr[2] != NULL) {

+      strcpy (VarIdStr[2], BaseVarId);

+      strcat (VarIdStr[2], ".Second");

+    }

+  } else {

+    Len = strlen (Name);

+

+    VarIdStr[0] = new CHAR8[Len + strlen (".Hour") + 1];

+    if (VarIdStr[0] != NULL) {

+      strcpy (VarIdStr[0], Name);

+      strcat (VarIdStr[0], ".Hour");

+    }

+    VarIdStr[1] = new CHAR8[Len + strlen (".Minute") + 1];

+    if (VarIdStr[1] != NULL) {

+      strcpy (VarIdStr[1], Name);

+      strcat (VarIdStr[1], ".Minute");

+    }

+    VarIdStr[2] = new CHAR8[Len + strlen (".Second") + 1];

+    if (VarIdStr[2] != NULL) {

+      strcpy (VarIdStr[2], Name);

+      strcat (VarIdStr[2], ".Second");

+    }

   }

 

   if ((pNode[0] = new SVfrQuestionNode (Name, VarIdStr[0], TIME_HOUR_BITMASK)) == NULL) {

@@ -2828,31 +2898,56 @@ CVfrQuestionDB::RegisterRefQuestion (
   CHAR8                *VarIdStr[4] = {NULL, };

   CHAR8                 Index;

 

-  if (BaseVarId == NULL) {

+  if (BaseVarId == NULL && Name == NULL) {

     return;

   }

 

-  Len = strlen (BaseVarId);

+  if (BaseVarId != NULL) {

+    Len = strlen (BaseVarId);

 

-  VarIdStr[0] = new CHAR8[Len + strlen (".QuestionId") + 1];

-  if (VarIdStr[0] != NULL) {

-    strcpy (VarIdStr[0], BaseVarId);

-    strcat (VarIdStr[0], ".QuestionId");

-  }

-  VarIdStr[1] = new CHAR8[Len + strlen (".FormId") + 1];

-  if (VarIdStr[1] != NULL) {

-    strcpy (VarIdStr[1], BaseVarId);

-    strcat (VarIdStr[1], ".FormId");

-  }

-  VarIdStr[2] = new CHAR8[Len + strlen (".FormSetGuid") + 1];

-  if (VarIdStr[2] != NULL) {

-    strcpy (VarIdStr[2], BaseVarId);

-    strcat (VarIdStr[2], ".FormSetGuid");

-  }

-  VarIdStr[3] = new CHAR8[Len + strlen (".DevicePath") + 1];

-  if (VarIdStr[3] != NULL) {

-    strcpy (VarIdStr[3], BaseVarId);

-    strcat (VarIdStr[3], ".DevicePath");

+    VarIdStr[0] = new CHAR8[Len + strlen (".QuestionId") + 1];

+    if (VarIdStr[0] != NULL) {

+      strcpy (VarIdStr[0], BaseVarId);

+      strcat (VarIdStr[0], ".QuestionId");

+    }

+    VarIdStr[1] = new CHAR8[Len + strlen (".FormId") + 1];

+    if (VarIdStr[1] != NULL) {

+      strcpy (VarIdStr[1], BaseVarId);

+      strcat (VarIdStr[1], ".FormId");

+    }

+    VarIdStr[2] = new CHAR8[Len + strlen (".FormSetGuid") + 1];

+    if (VarIdStr[2] != NULL) {

+      strcpy (VarIdStr[2], BaseVarId);

+      strcat (VarIdStr[2], ".FormSetGuid");

+    }

+    VarIdStr[3] = new CHAR8[Len + strlen (".DevicePath") + 1];

+    if (VarIdStr[3] != NULL) {

+      strcpy (VarIdStr[3], BaseVarId);

+      strcat (VarIdStr[3], ".DevicePath");

+    }

+  } else {

+    Len = strlen (Name);

+

+    VarIdStr[0] = new CHAR8[Len + strlen (".QuestionId") + 1];

+    if (VarIdStr[0] != NULL) {

+      strcpy (VarIdStr[0], Name);

+      strcat (VarIdStr[0], ".QuestionId");

+    }

+    VarIdStr[1] = new CHAR8[Len + strlen (".FormId") + 1];

+    if (VarIdStr[1] != NULL) {

+      strcpy (VarIdStr[1], Name);

+      strcat (VarIdStr[1], ".FormId");

+    }

+    VarIdStr[2] = new CHAR8[Len + strlen (".FormSetGuid") + 1];

+    if (VarIdStr[2] != NULL) {

+      strcpy (VarIdStr[2], Name);

+      strcat (VarIdStr[2], ".FormSetGuid");

+    }

+    VarIdStr[3] = new CHAR8[Len + strlen (".DevicePath") + 1];

+    if (VarIdStr[3] != NULL) {

+      strcpy (VarIdStr[3], Name);

+      strcat (VarIdStr[3], ".DevicePath");

+    }

   }

 

   if ((pNode[0] = new SVfrQuestionNode (Name, VarIdStr[0])) == NULL) {

diff --git a/BaseTools/Source/C/VfrCompile/VfrUtilityLib.h b/BaseTools/Source/C/VfrCompile/VfrUtilityLib.h
index 2c0ed7bd..2847a74a 100644
--- a/BaseTools/Source/C/VfrCompile/VfrUtilityLib.h
+++ b/BaseTools/Source/C/VfrCompile/VfrUtilityLib.h
@@ -2,7 +2,7 @@
   

   Vfr common library functions.

 

-Copyright (c) 2004 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials                          

 are licensed and made available under the terms and conditions of the BSD License         

 which accompanies this distribution.  The full text of the license may be found at        

@@ -57,13 +57,14 @@ struct SConfigInfo {
 

 struct SConfigItem {

   CHAR8         *mName;         // varstore name

-  CHAR8         *mId;           // varstore ID

+  EFI_GUID      *mGuid;         // varstore guid, varstore name + guid deside one varstore

+  CHAR8         *mId;           // default ID

   SConfigInfo   *mInfoStrList;  // list of Offset/Value in the varstore

   SConfigItem   *mNext;

 

 public:

-  SConfigItem (IN CHAR8 *, IN CHAR8 *);

-  SConfigItem (IN CHAR8 *, IN CHAR8 *, IN UINT8, IN UINT16, IN UINT16, IN EFI_IFR_TYPE_VALUE);

+  SConfigItem (IN CHAR8 *, IN EFI_GUID *, IN CHAR8 *);

+  SConfigItem (IN CHAR8 *, IN EFI_GUID *, IN CHAR8 *, IN UINT8, IN UINT16, IN UINT16, IN EFI_IFR_TYPE_VALUE);

   virtual ~SConfigItem ();

 };

 

@@ -77,11 +78,11 @@ public:
   CVfrBufferConfig (VOID);

   virtual ~CVfrBufferConfig (VOID);

 

-  virtual UINT8   Register (IN CHAR8 *, IN CHAR8 *Info = NULL);

+  virtual UINT8   Register (IN CHAR8 *, IN EFI_GUID *,IN CHAR8 *Info = NULL);

   virtual VOID    Open (VOID);

   virtual BOOLEAN Eof(VOID);

-  virtual UINT8   Select (IN CHAR8 *, IN CHAR8 *Info = NULL);

-  virtual UINT8   Write (IN CONST CHAR8, IN CHAR8 *, IN CHAR8 *, IN UINT8, IN UINT16, IN UINT32, IN EFI_IFR_TYPE_VALUE);

+  virtual UINT8   Select (IN CHAR8 *, IN EFI_GUID *, IN CHAR8 *Info = NULL);

+  virtual UINT8   Write (IN CONST CHAR8, IN CHAR8 *, IN EFI_GUID *, IN CHAR8 *, IN UINT8, IN UINT16, IN UINT32, IN EFI_IFR_TYPE_VALUE);

 #if 0

   virtual UINT8   Read (OUT CHAR8 **, OUT CHAR8 **, OUT CHAR8 **, OUT CHAR8 **, OUT CHAR8 **);

 #endif

@@ -284,6 +285,10 @@ private:
   BOOLEAN         ChekVarStoreIdFree (IN EFI_VARSTORE_ID);

   VOID            MarkVarStoreIdUsed (IN EFI_VARSTORE_ID);

   VOID            MarkVarStoreIdUnused (IN EFI_VARSTORE_ID);

+  EFI_VARSTORE_ID CheckGuidField (IN SVfrVarStorageNode *, 

+                                  IN EFI_GUID *, 

+                                  IN BOOLEAN *, 

+                                  OUT EFI_VFR_RETURN_CODE *);

 

 public:

   CVfrDataStorage ();

@@ -303,17 +308,15 @@ public:
 

   EFI_VFR_RETURN_CODE DeclareBufferVarStore (IN CHAR8 *, IN EFI_GUID *, IN CVfrVarDataTypeDB *, IN CHAR8 *, IN EFI_VARSTORE_ID, IN BOOLEAN Flag = TRUE);

 

-  EFI_VFR_RETURN_CODE GetVarStoreId (IN CHAR8 *, OUT EFI_VARSTORE_ID *);

-  EFI_VFR_RETURN_CODE GetVarStoreType (IN CHAR8 *, OUT EFI_VFR_VARSTORE_TYPE &);

+  EFI_VFR_RETURN_CODE GetVarStoreId (IN CHAR8 *, OUT EFI_VARSTORE_ID *, IN EFI_GUID *VarGuid = NULL);

   EFI_VFR_VARSTORE_TYPE GetVarStoreType (IN EFI_VARSTORE_ID);

+  EFI_GUID *          GetVarStoreGuid (IN  EFI_VARSTORE_ID);

   EFI_VFR_RETURN_CODE GetVarStoreName (IN EFI_VARSTORE_ID, OUT CHAR8 **);

-  EFI_VFR_RETURN_CODE GetVarStoreByDataType (IN CHAR8 *, OUT SVfrVarStorageNode **);

+  EFI_VFR_RETURN_CODE GetVarStoreByDataType (IN CHAR8 *, OUT SVfrVarStorageNode **, IN EFI_GUID *VarGuid = NULL);

 

-  EFI_VFR_RETURN_CODE GetBufferVarStoreDataTypeName (IN CHAR8 *, OUT CHAR8 **);

+  EFI_VFR_RETURN_CODE GetBufferVarStoreDataTypeName (IN EFI_VARSTORE_ID, OUT CHAR8 **);

   EFI_VFR_RETURN_CODE GetEfiVarStoreInfo (IN EFI_VARSTORE_INFO *);

   EFI_VFR_RETURN_CODE GetNameVarStoreInfo (IN EFI_VARSTORE_INFO *, IN UINT32);

-

-  EFI_VFR_RETURN_CODE BufferVarStoreRequestElementAdd (IN CHAR8 *, IN EFI_VARSTORE_INFO &);

 };

 

 #define EFI_QUESTION_ID_MAX              0xFFFF

@@ -396,7 +399,7 @@ public:
   EFI_VFR_RETURN_CODE ReRegisterDefaultStoreById (IN UINT16, IN CHAR8 *, IN EFI_STRING_ID);

   BOOLEAN             DefaultIdRegistered (IN UINT16);

   EFI_VFR_RETURN_CODE GetDefaultId (IN CHAR8 *, OUT UINT16 *);

-  EFI_VFR_RETURN_CODE BufferVarStoreAltConfigAdd (IN EFI_VARSTORE_ID, IN EFI_VARSTORE_INFO &, IN CHAR8 *, IN UINT8, IN EFI_IFR_TYPE_VALUE);

+  EFI_VFR_RETURN_CODE BufferVarStoreAltConfigAdd (IN EFI_VARSTORE_ID, IN EFI_VARSTORE_INFO &, IN CHAR8 *, IN EFI_GUID *, IN UINT8, IN EFI_IFR_TYPE_VALUE);

 };

 

 #define EFI_RULE_ID_START    0x01

diff --git a/BaseTools/Source/Python/AutoGen/UniClassObject.py b/BaseTools/Source/Python/AutoGen/UniClassObject.py
index 49816832..7b1ce72e 100644
--- a/BaseTools/Source/Python/AutoGen/UniClassObject.py
+++ b/BaseTools/Source/Python/AutoGen/UniClassObject.py
@@ -38,6 +38,9 @@ LF = u'\u000A'
 NULL = u'\u0000'

 TAB = u'\t'

 BACK_SPLASH = u'\\'

+DOBULE_QUOTED_SPLASH = u'\\"'

+SIGLE_QUOTED_SPLASH = u"\\'"

+TAB_BACK_SLASH = u"\\/"

 

 gIncludePattern = re.compile("^#include +[\"<]+([^\"< >]+)[>\"]+$", re.MULTILINE | re.UNICODE)

 

@@ -346,7 +349,10 @@ class UniFileClassObject(object):
             Line = Line.replace(u'''\"''', u'''"''')

             Line = Line.replace(u'\t', u' ')

             Line = Line.replace(u'\u0006', u'\\')

-            

+            Line = Line.replace(DOBULE_QUOTED_SPLASH, u'"')

+            Line = Line.replace(SIGLE_QUOTED_SPLASH, u"'")

+            Line = Line.replace(TAB_BACK_SLASH, u"/")

+

 #           if Line.find(u'\\x'):

 #               hex = Line[Line.find(u'\\x') + 2 : Line.find(u'\\x') + 6]

 #               hex = "u'\\u" + hex + "'"

diff --git a/BaseTools/Source/Python/GenFds/FdfParser.py b/BaseTools/Source/Python/GenFds/FdfParser.py
index c9c620d8..547271d5 100644
--- a/BaseTools/Source/Python/GenFds/FdfParser.py
+++ b/BaseTools/Source/Python/GenFds/FdfParser.py
@@ -2503,16 +2503,16 @@ class FdfParser:
         self.__GetFileOpts( FfsFileObj)

 

         if not self.__IsToken("{"):

-#            if self.__IsKeyword('RELOCS_STRIPPED') or self.__IsKeyword('RELOCS_RETAINED'):

-#                if self.__FileCouldHaveRelocFlag(FfsFileObj.FvFileType):

-#                    if self.__Token == 'RELOCS_STRIPPED':

-#                        FfsFileObj.KeepReloc = False

-#                    else:

-#                        FfsFileObj.KeepReloc = True

-#                else:

-#                    raise Warning("File type %s could not have reloc strip flag%d" % (FfsFileObj.FvFileType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)

-#

-#            if not self.__IsToken("{"):

+            if self.__IsKeyword('RELOCS_STRIPPED') or self.__IsKeyword('RELOCS_RETAINED'):

+                if self.__FileCouldHaveRelocFlag(FfsFileObj.FvFileType):

+                    if self.__Token == 'RELOCS_STRIPPED':

+                        FfsFileObj.KeepReloc = False

+                    else:

+                        FfsFileObj.KeepReloc = True

+                else:

+                    raise Warning("File type %s could not have reloc strip flag%d" % (FfsFileObj.FvFileType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)

+

+            if not self.__IsToken("{"):

                 raise Warning("expected '{'", self.FileName, self.CurrentLineNumber)

 

         if not self.__GetNextToken():

diff --git a/BaseTools/Source/Python/GenFds/FfsFileStatement.py b/BaseTools/Source/Python/GenFds/FfsFileStatement.py
index 04527fe0..d0dec380 100755
--- a/BaseTools/Source/Python/GenFds/FfsFileStatement.py
+++ b/BaseTools/Source/Python/GenFds/FfsFileStatement.py
@@ -110,6 +110,8 @@ class FileStatement (FileStatementClassObject) :
                 if FvParentAddr != None and isinstance(section, GuidSection):

                     section.FvParentAddr = FvParentAddr

 

+                if self.KeepReloc == False:

+                    section.KeepReloc = False

                 sectList, align = section.GenSection(OutputDir, self.NameGuid, SecIndex, self.KeyStringList, None, Dict)

                 if sectList != []:

                     for sect in sectList:

diff --git a/BaseTools/Source/Python/GenFds/GenFdsGlobalVariable.py b/BaseTools/Source/Python/GenFds/GenFdsGlobalVariable.py
index b4579376..2fa4cb8c 100644
--- a/BaseTools/Source/Python/GenFds/GenFdsGlobalVariable.py
+++ b/BaseTools/Source/Python/GenFds/GenFdsGlobalVariable.py
@@ -345,7 +345,7 @@ class GenFdsGlobalVariable:
 
     @staticmethod
     def GenerateSection(Output, Input, Type=None, CompressionType=None, Guid=None,
-                        GuidHdrLen=None, GuidAttr=[], Ui=None, Ver=None, InputAlign=None):
+                        GuidHdrLen=None, GuidAttr=[], Ui=None, Ver=None, InputAlign=None, BuildNumber=None):
         Cmd = ["GenSec"]
         if Type not in [None, '']:
             Cmd += ["-s", Type]
@@ -364,6 +364,7 @@ class GenFdsGlobalVariable:
             for SecAlign in InputAlign:
                 Cmd += ["--sectionalign", SecAlign]
 
+        CommandFile = Output + '.txt'
         if Ui not in [None, '']:
             #Cmd += ["-n", '"' + Ui + '"']
             SectionData = array.array('B', [0,0,0,0])
@@ -374,19 +375,20 @@ class GenFdsGlobalVariable:
             GenFdsGlobalVariable.SectionHeader.pack_into(SectionData, 0, Len & 0xff, (Len >> 8) & 0xff, (Len >> 16) & 0xff, 0x15)
             SaveFileOnChange(Output,  SectionData.tostring())
         elif Ver not in [None, '']:
-            #Cmd += ["-j", Ver]
-            SectionData = array.array('B', [0,0,0,0])
-            SectionData.fromstring(Ver.encode("utf_16_le"))
-            SectionData.append(0)
-            SectionData.append(0)
-            Len = len(SectionData)
-            GenFdsGlobalVariable.SectionHeader.pack_into(SectionData, 0, Len & 0xff, (Len >> 8) & 0xff, (Len >> 16) & 0xff, 0x14)
-            SaveFileOnChange(Output,  SectionData.tostring())
+            Cmd += ["-n", Ver]
+            if BuildNumber:
+                Cmd += ["-j", BuildNumber]
+            Cmd += ["-o", Output]
+
+            SaveFileOnChange(CommandFile, ' '.join(Cmd), False)
+            if not GenFdsGlobalVariable.NeedsUpdate(Output, list(Input) + [CommandFile]):
+                return
+
+            GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate section")
         else:
             Cmd += ["-o", Output]
             Cmd += Input
 
-            CommandFile = Output + '.txt'
             SaveFileOnChange(CommandFile, ' '.join(Cmd), False)
             if not GenFdsGlobalVariable.NeedsUpdate(Output, list(Input) + [CommandFile]):
                 return
diff --git a/BaseTools/Source/Python/GenFds/VerSection.py b/BaseTools/Source/Python/GenFds/VerSection.py
index 3fca4064..8f6da962 100644
--- a/BaseTools/Source/Python/GenFds/VerSection.py
+++ b/BaseTools/Source/Python/GenFds/VerSection.py
@@ -76,7 +76,7 @@ class VerSection (VerSectionClassObject):
             StringData = ''

 

         GenFdsGlobalVariable.GenerateSection(OutputFile, None, 'EFI_SECTION_VERSION',

-                                             Ui=StringData, Ver=self.BuildNum)

+                                             Ver=StringData, BuildNumber=self.BuildNum)

         OutputFileList = []

         OutputFileList.append(OutputFile)

         return OutputFileList, self.Alignment

diff --git a/BaseTools/Source/Python/UPT/Library/GlobalData.py b/BaseTools/Source/Python/UPT/Library/GlobalData.py
index fedd9815..3f72f227 100644
--- a/BaseTools/Source/Python/UPT/Library/GlobalData.py
+++ b/BaseTools/Source/Python/UPT/Library/GlobalData.py
@@ -92,3 +92,8 @@ gUNPACK_DIR = None
 # Flag used to mark whether the INF file is Binary INF or not.
 #
 gIS_BINARY_INF = False
+#
+# Used by Library instance parser
+# {FilePath: FileObj}
+#
+gLIBINSTANCEDICT = {}
\ No newline at end of file
diff --git a/BaseTools/Source/Python/UPT/Object/Parser/InfUserExtensionObject.py b/BaseTools/Source/Python/UPT/Object/Parser/InfUserExtensionObject.py
index d576cffb..27a1c6ad 100644
--- a/BaseTools/Source/Python/UPT/Object/Parser/InfUserExtensionObject.py
+++ b/BaseTools/Source/Python/UPT/Object/Parser/InfUserExtensionObject.py
@@ -89,19 +89,19 @@ class InfUserExtensionObject():
             InfUserExtensionItemObj.SetContent(UserExtensionCont)

             InfUserExtensionItemObj.SetSupArchList(IdContentItem[2]) 

             

-            for CheckItem in self.UserExtension:

-                if IdContentItem[0] == CheckItem[0] and IdContentItem[1] == CheckItem[1]:

-                    if IdContentItem[2].upper() == 'COMMON' or CheckItem[2].upper() == 'COMMON':

-                        #

-                        # For COMMON ARCH type, do special check.

-                        #

-                        Logger.Error('InfParser', 

-                            ToolError.FORMAT_INVALID,

-                            ST.ERR_INF_PARSER_UE_SECTION_DUPLICATE_ERROR%\

-                            (IdContentItem[0] + '.' + IdContentItem[1] + '.' + IdContentItem[2]),

-                            File=GlobalData.gINF_MODULE_NAME, 

-                            Line=LineNo,

-                            ExtraData=None)

+#            for CheckItem in self.UserExtension:

+#                if IdContentItem[0] == CheckItem[0] and IdContentItem[1] == CheckItem[1]:

+#                    if IdContentItem[2].upper() == 'COMMON' or CheckItem[2].upper() == 'COMMON':

+#                        #

+#                        # For COMMON ARCH type, do special check.

+#                        #

+#                        Logger.Error('InfParser', 

+#                            ToolError.FORMAT_INVALID,

+#                            ST.ERR_INF_PARSER_UE_SECTION_DUPLICATE_ERROR%\

+#                            (IdContentItem[0] + '.' + IdContentItem[1] + '.' + IdContentItem[2]),

+#                            File=GlobalData.gINF_MODULE_NAME, 

+#                            Line=LineNo,

+#                            ExtraData=None)

             

             if self.UserExtension.has_key(IdContentItem):           

                 #

diff --git a/BaseTools/Source/Python/UPT/Parser/InfAsBuiltProcess.py b/BaseTools/Source/Python/UPT/Parser/InfAsBuiltProcess.py
index 12c46f19..6bf070be 100644
--- a/BaseTools/Source/Python/UPT/Parser/InfAsBuiltProcess.py
+++ b/BaseTools/Source/Python/UPT/Parser/InfAsBuiltProcess.py
@@ -42,12 +42,12 @@ from Library import DataType as DT
 # @param WorkSpace. The WorkSpace directory used to combined with INF file path.

 #

 # @return GUID, Version

-def GetLibInstanceInfo(String, WorkSpace, LineNo):

-    

+def GetLibInstanceInfo(String, WorkSpace, LineNo, CurrentInfFileName):

+

     FileGuidString = ""

     VerString = ""

-    

-    OrignalString = String 

+

+    OrignalString = String

     String = String.strip()

     if not String:

         return None, None

@@ -56,28 +56,48 @@ def GetLibInstanceInfo(String, WorkSpace, LineNo):
     #

     String = GetHelpStringByRemoveHashKey(String)

     String = String.strip()

-    

+

+    #

+    # To deal with library instance specified by GUID and version

+    #

+    RegFormatGuidPattern = re.compile("\s*([0-9a-fA-F]){8}-"

+                                       "([0-9a-fA-F]){4}-"

+                                       "([0-9a-fA-F]){4}-"

+                                       "([0-9a-fA-F]){4}-"

+                                       "([0-9a-fA-F]){12}\s*")

+    VersionPattern = re.compile('[\t\s]*\d+(\.\d+)?[\t\s]*')

+    GuidMatchedObj = RegFormatGuidPattern.search(String)

+

+    if String.upper().startswith('GUID') and GuidMatchedObj and 'Version' in String:

+        VersionStr = String[String.upper().find('VERSION') + 8:]

+        VersionMatchedObj = VersionPattern.search(VersionStr)

+        if VersionMatchedObj:

+            Guid = GuidMatchedObj.group().strip()

+            Version = VersionMatchedObj.group().strip()

+            return GetGuidVerFormLibInstance(Guid, Version, WorkSpace, CurrentInfFileName)

+

+    #

+    # To deal with library instance specified by file name

+    #

     FileLinesList = GetFileLineContent(String, WorkSpace, LineNo, OrignalString)

 

-        

+

     ReFindFileGuidPattern = re.compile("^\s*FILE_GUID\s*=.*$")

     ReFindVerStringPattern = re.compile("^\s*VERSION_STRING\s*=.*$")

-    

-    FileLinesList = ProcessLineExtender(FileLinesList)

 

     for Line in FileLinesList:

         if ReFindFileGuidPattern.match(Line):

             FileGuidString = Line

         if ReFindVerStringPattern.match(Line):

             VerString = Line

-    

+

     if FileGuidString:

         FileGuidString = GetSplitValueList(FileGuidString, '=', 1)[1]

     if VerString:

         VerString = GetSplitValueList(VerString, '=', 1)[1]

-        

+

     return FileGuidString, VerString

-    

+

 ## GetPackageListInfo

 #

 # Get the package information from INF file.

@@ -184,36 +204,97 @@ def GetFileLineContent(FileName, WorkSpace, LineNo, OriginalString):
     #

     # Validate file exist/format.

     #

-    if IsValidPath(FileName, WorkSpace):

-        IsValidFileFlag = True

-    else:

+    if not IsValidPath(FileName, WorkSpace):

         Logger.Error("InfParser", 

                      ToolError.FORMAT_INVALID,

                      ST.ERR_INF_PARSER_FILE_NOT_EXIST_OR_NAME_INVALID%(FileName),

                      File=GlobalData.gINF_MODULE_NAME, 

                      Line=LineNo, 

                      ExtraData=OriginalString)

-        return False

     

     FileLinesList = []

     

-    if IsValidFileFlag:  

+    try:

+        FullFileName = FullFileName.replace('\\', '/')

+        Inputfile = open(FullFileName, "rb", 0)

         try:

-            FullFileName = FullFileName.replace('\\', '/')

-            Inputfile = open(FullFileName, "rb", 0)

-            try:

-                FileLinesList = Inputfile.readlines()

-            except BaseException:

-                Logger.Error("InfParser", ToolError.FILE_READ_FAILURE, ST.ERR_FILE_OPEN_FAILURE, File=FullFileName)

-            finally:

-                Inputfile.close()

+            FileLinesList = Inputfile.readlines()

         except BaseException:

-            Logger.Error("InfParser", 

-                         ToolError.FILE_READ_FAILURE, 

-                         ST.ERR_FILE_OPEN_FAILURE,

-                         File=FullFileName)

-        

-        FileLinesList = ProcessLineExtender(FileLinesList)

+            Logger.Error("InfParser", ToolError.FILE_READ_FAILURE, ST.ERR_FILE_OPEN_FAILURE, File=FullFileName)

+        finally:

+            Inputfile.close()

+    except BaseException:

+        Logger.Error("InfParser",

+                     ToolError.FILE_READ_FAILURE,

+                     ST.ERR_FILE_OPEN_FAILURE,

+                     File=FullFileName)

+    

+    FileLinesList = ProcessLineExtender(FileLinesList)

     

     return FileLinesList

-    
\ No newline at end of file
+

+##

+# Get all INF files from current workspace

+#

+#

+def GetInfsFromWorkSpace(WorkSpace):

+    InfFiles = []

+    for top, dirs, files in os.walk(WorkSpace):

+        dirs = dirs # just for pylint

+        for File in files:

+            if File.upper().endswith(".INF"):

+                InfFiles.append(os.path.join(top, File))

+

+    return InfFiles

+

+##

+# Get GUID and version from library instance file

+#

+#

+def GetGuidVerFormLibInstance(Guid, Version, WorkSpace, CurrentInfFileName):

+    for InfFile in GetInfsFromWorkSpace(WorkSpace):

+        try:

+            if InfFile.strip().upper() == CurrentInfFileName.strip().upper():

+                continue

+            InfFile = InfFile.replace('\\', '/')

+            if InfFile not in GlobalData.gLIBINSTANCEDICT:

+                InfFileObj = open(InfFile, "rb", 0)

+                GlobalData.gLIBINSTANCEDICT[InfFile] = InfFileObj

+            else:

+                InfFileObj = GlobalData.gLIBINSTANCEDICT[InfFile]

+

+        except BaseException:

+            Logger.Error("InfParser",

+                         ToolError.FILE_READ_FAILURE,

+                         ST.ERR_FILE_OPEN_FAILURE,

+                         File=InfFile)

+        try:

+            FileLinesList = InfFileObj.readlines()

+            FileLinesList = ProcessLineExtender(FileLinesList)

+

+            ReFindFileGuidPattern = re.compile("^\s*FILE_GUID\s*=.*$")

+            ReFindVerStringPattern = re.compile("^\s*VERSION_STRING\s*=.*$")

+

+            for Line in FileLinesList:

+                if ReFindFileGuidPattern.match(Line):

+                    FileGuidString = Line

+                if ReFindVerStringPattern.match(Line):

+                    VerString = Line

+

+            if FileGuidString:

+                FileGuidString = GetSplitValueList(FileGuidString, '=', 1)[1]

+            if VerString:

+                VerString = GetSplitValueList(VerString, '=', 1)[1]

+

+            if FileGuidString.strip().upper() == Guid.upper() and \

+                VerString.strip().upper() == Version.upper():

+                return Guid, Version

+

+        except BaseException:

+            Logger.Error("InfParser", ToolError.FILE_READ_FAILURE, ST.ERR_FILE_OPEN_FAILURE, File=InfFile)

+        finally:

+            InfFileObj.close()

+

+    return '', ''

+

+

diff --git a/BaseTools/Source/Python/UPT/Parser/InfLibrarySectionParser.py b/BaseTools/Source/Python/UPT/Parser/InfLibrarySectionParser.py
index 8f9427cf..4540fe27 100644
--- a/BaseTools/Source/Python/UPT/Parser/InfLibrarySectionParser.py
+++ b/BaseTools/Source/Python/UPT/Parser/InfLibrarySectionParser.py
@@ -170,28 +170,29 @@ class InfLibrarySectionParser(InfParserSectionRoot):
                             File=FileName, 

                             Line=LineNo, 

                             ExtraData=LineContent)

-            

+

             if IsLibInstanceInfo(LineContent):

                 LibInsFlag = True

                 continue

-            

+

             if LibInsFlag:

-                LibGuid, LibVer = GetLibInstanceInfo(LineContent, GlobalData.gWORKSPACE, LineNo)

+                LibGuid, LibVer = GetLibInstanceInfo(LineContent, GlobalData.gWORKSPACE, LineNo, FileName)

                 #

                 # If the VERSION_STRING is missing from the INF file, tool should default to "0".

                 #

                 if LibVer == '':

                     LibVer = '0'

                 if LibGuid != '':

-                    LibraryList.append((LibGuid, LibVer))

+                    if (LibGuid, LibVer) not in LibraryList:

+                        LibraryList.append((LibGuid, LibVer))

                 else:

-                    Logger.Error('InfParser', 

+                    Logger.Error('InfParser',

                             FORMAT_INVALID,

-                            ST.ERR_LIB_INSTANCE_MISS_GUID, 

-                            File=FileName, 

-                            Line=LineNo, 

-                            ExtraData=LineContent)                    

-                

+                            ST.ERR_LIB_INSTANCE_MISS_GUID,

+                            File=FileName,

+                            Line=LineNo,

+                            ExtraData=LineContent)

+

         #

         # Current section archs

         #    

diff --git a/BaseTools/Source/Python/Workspace/MetaFileParser.py b/BaseTools/Source/Python/Workspace/MetaFileParser.py
index 92cf3614..b2e98633 100644
--- a/BaseTools/Source/Python/Workspace/MetaFileParser.py
+++ b/BaseTools/Source/Python/Workspace/MetaFileParser.py
@@ -286,15 +286,15 @@ class MetaFileParser(object):
             self._SectionName = ItemList[0].upper()
             if self._SectionName in self.DataType:
                 self._SectionType = self.DataType[self._SectionName]
-            else:
-                self._SectionType = MODEL_UNKNOWN
-                EdkLogger.error("Parser", FORMAT_UNKNOWN_ERROR, "%s is not a valid section name" % Item,
-                                self.MetaFile, self._LineIndex + 1, self._CurrentLine)
-
-            # Check if the section name is valid
-            if self._SectionName not in SECTIONS_HAVE_ITEM_AFTER_ARCH and len(ItemList) > 2:
+                # Check if the section name is valid
+                if self._SectionName not in SECTIONS_HAVE_ITEM_AFTER_ARCH and len(ItemList) > 2:
+                    EdkLogger.error("Parser", FORMAT_UNKNOWN_ERROR, "%s is not a valid section name" % Item,
+                                    self.MetaFile, self._LineIndex + 1, self._CurrentLine)
+            elif self._Version >= 0x00010005:
                 EdkLogger.error("Parser", FORMAT_UNKNOWN_ERROR, "%s is not a valid section name" % Item,
                                 self.MetaFile, self._LineIndex + 1, self._CurrentLine)
+            else:
+                self._SectionType = MODEL_UNKNOWN
 
             # S1 is always Arch
             if len(ItemList) > 1:
diff --git a/BaseTools/Source/Python/build/BuildReport.py b/BaseTools/Source/Python/build/BuildReport.py
index 34393515..f35b7699 100755
--- a/BaseTools/Source/Python/build/BuildReport.py
+++ b/BaseTools/Source/Python/build/BuildReport.py
@@ -699,7 +699,8 @@ class PcdReport(object):
         # Collect PCDs defined in DSC common section
         #
         self.DscPcdDefault = {}
-        for Platform in Wa.BuildDatabase.WorkspaceDb.PlatformList:
+        for Arch in Wa.ArchList:
+            Platform = Wa.BuildDatabase[Wa.MetaFile, Arch, Wa.BuildTarget, Wa.ToolChain]
             for (TokenCName, TokenSpaceGuidCName) in Platform.Pcds:
                 DscDefaultValue = Platform.Pcds[(TokenCName, TokenSpaceGuidCName)].DefaultValue
                 if DscDefaultValue:
diff --git a/BeagleBoardPkg/BeagleBoardPkg.dec b/BeagleBoardPkg/BeagleBoardPkg.dec
index a6ee2740..496442a6 100644
--- a/BeagleBoardPkg/BeagleBoardPkg.dec
+++ b/BeagleBoardPkg/BeagleBoardPkg.dec
@@ -1,36 +1,36 @@
-#/** @file
-# Beagle board package.
-#
-# Copyright (c) 2009, Apple Inc. All rights reserved.<BR>
-#
-#    This program and the accompanying materials are licensed and made available under
-#    the terms and conditions of the BSD License which accompanies this distribution.
-#    The full text of the license may be found at
-#    http://opensource.org/licenses/bsd-license.php
-#
-#    THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#**/
-
-[Defines]
-  DEC_SPECIFICATION              = 0x00010005
-  PACKAGE_NAME                   = BeagleBoardPkg
-  PACKAGE_GUID                   = 6eba6648-d853-4eb3-9761-528b82d5ab04
-  PACKAGE_VERSION                = 0.1
-
-################################################################################
-#
-# Include Section - list of Include Paths that are provided by this package.
-#                   Comments are used for Keywords and Module Types.
-#
-# Supported Module Types:
-#  BASE SEC PEI_CORE PEIM DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SMM_DRIVER DXE_SAL_DRIVER UEFI_DRIVER UEFI_APPLICATION
-#
-################################################################################
-[Includes.common]
-  Include                        # Root include for the package
-
-[Guids.common]
-  gBeagleBoardTokenSpaceGuid    =  { 0x6834fe45, 0x4aee, 0x4fc6, { 0xbc, 0xb5, 0xff, 0x45, 0xb7, 0xa8, 0x71, 0xe2 } }
-
+#/** @file

+# Beagle board package.

+#

+# Copyright (c) 2009, Apple Inc. All rights reserved.<BR>

+#

+#    This program and the accompanying materials are licensed and made available under

+#    the terms and conditions of the BSD License which accompanies this distribution.

+#    The full text of the license may be found at

+#    http://opensource.org/licenses/bsd-license.php

+#

+#    THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#    WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#**/

+

+[Defines]

+  DEC_SPECIFICATION              = 0x00010005

+  PACKAGE_NAME                   = BeagleBoardPkg

+  PACKAGE_GUID                   = 6eba6648-d853-4eb3-9761-528b82d5ab04

+  PACKAGE_VERSION                = 0.1

+

+################################################################################

+#

+# Include Section - list of Include Paths that are provided by this package.

+#                   Comments are used for Keywords and Module Types.

+#

+# Supported Module Types:

+#  BASE SEC PEI_CORE PEIM DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SMM_DRIVER DXE_SAL_DRIVER UEFI_DRIVER UEFI_APPLICATION

+#

+################################################################################

+[Includes.common]

+  Include                        # Root include for the package

+

+[Guids.common]

+  gBeagleBoardTokenSpaceGuid    =  { 0x6834fe45, 0x4aee, 0x4fc6, { 0xbc, 0xb5, 0xff, 0x45, 0xb7, 0xa8, 0x71, 0xe2 } }

+

diff --git a/BeagleBoardPkg/BeagleBoardPkg.dsc b/BeagleBoardPkg/BeagleBoardPkg.dsc
index e7b739e0..1223944b 100644
--- a/BeagleBoardPkg/BeagleBoardPkg.dsc
+++ b/BeagleBoardPkg/BeagleBoardPkg.dsc
@@ -35,6 +35,7 @@
   ArmPlatformLib|BeagleBoardPkg/Library/BeagleBoardLib/BeagleBoardLib.inf

   ArmCpuLib|ArmPkg/Drivers/ArmCpuLib/ArmCortexA8Lib/ArmCortexA8Lib.inf

   ArmPlatformStackLib|ArmPlatformPkg/Library/ArmPlatformStackLib/ArmPlatformStackLib.inf

+  ArmSmcLib|ArmPkg/Library/ArmSmcLib/ArmSmcLib.inf

   

   HiiLib|MdeModulePkg/Library/UefiHiiLib/UefiHiiLib.inf

   UefiHiiServicesLib|MdeModulePkg/Library/UefiHiiServicesLib/UefiHiiServicesLib.inf

@@ -82,6 +83,7 @@
   PrePiLib|EmbeddedPkg/Library/PrePiLib/PrePiLib.inf

   

   SerialPortLib|Omap35xxPkg/Library/SerialPortLib/SerialPortLib.inf

+  SerialPortExtLib|EmbeddedPkg/Library/TemplateSerialPortExtLib/TemplateSerialPortExtLib.inf 

   SemihostLib|ArmPkg/Library/SemihostLib/SemihostLib.inf

   

   RealTimeClockLib|Omap35xxPkg/Library/RealTimeClockLib/RealTimeClockLib.inf

@@ -430,8 +432,6 @@
   #

   Omap35xxPkg/PciEmulation/PciEmulation.inf

 

-  #NOTE: Open source EHCI stack doesn't work on Beagleboard.

-  #NOTE: UsbBus and UsbMassStorage don't work using iPhone SDK tool chain.

   MdeModulePkg/Bus/Pci/EhciDxe/EhciDxe.inf {

     <PcdsFixedAtBuild>

       gEfiMdePkgTokenSpaceGuid.PcdDebugPrintErrorLevel|0x800fffff

diff --git a/BeagleBoardPkg/Library/BeagleBoardLib/BeagleBoard.c b/BeagleBoardPkg/Library/BeagleBoardLib/BeagleBoard.c
index ff4c5568..4e58f360 100755
--- a/BeagleBoardPkg/Library/BeagleBoardLib/BeagleBoard.c
+++ b/BeagleBoardPkg/Library/BeagleBoardLib/BeagleBoard.c
@@ -1,135 +1,135 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-#include <Library/IoLib.h>
-#include <Library/ArmPlatformLib.h>
-#include <Library/DebugLib.h>
-#include <Library/PcdLib.h>
-
-#include <Omap3530/Omap3530.h>
-#include <BeagleBoard.h>
-
-VOID
-PadConfiguration (
-  BEAGLEBOARD_REVISION Revision
-  );
-
-VOID
-ClockInit (
-  VOID
-  );
-
-/**
-  Detect board revision
-
-  @return Board revision
-**/
-BEAGLEBOARD_REVISION
-BeagleBoardGetRevision (
-  VOID
-  )
-{
-  UINT32 OldPinDir;
-  UINT32 Revision;
-
-  // Read GPIO 171, 172, 173
-  OldPinDir = MmioRead32 (GPIO6_BASE + GPIO_OE);
-  MmioWrite32(GPIO6_BASE + GPIO_OE, (OldPinDir | BIT11 | BIT12 | BIT13));
-  Revision = MmioRead32 (GPIO6_BASE + GPIO_DATAIN);
-  
-  // Restore I/O settings
-  MmioWrite32 (GPIO6_BASE + GPIO_OE, OldPinDir);
-  
-  return (BEAGLEBOARD_REVISION)((Revision >> 11) & 0x7);
-}
-
-/**
-  Return the current Boot Mode
-
-  This function returns the boot reason on the platform
-
-**/
-EFI_BOOT_MODE
-ArmPlatformGetBootMode (
-  VOID
-  )
-{
-  return BOOT_WITH_FULL_CONFIGURATION;
-}
-
-/**
-  Initialize controllers that must setup at the early stage
-
-  Some peripherals must be initialized in Secure World.
-  For example, some L2x0 requires to be initialized in Secure World
-
-**/
-RETURN_STATUS
-ArmPlatformInitialize (
-  IN  UINTN                     MpId
-  )
-{
-  BEAGLEBOARD_REVISION Revision;
-
-  Revision = BeagleBoardGetRevision();
-
-  // Set up Pin muxing.
-  PadConfiguration (Revision);
-
-  // Set up system clocking
-  ClockInit ();
-
-  // Turn off the functional clock for Timer 3
-  MmioAnd32 (CM_FCLKEN_PER, 0xFFFFFFFF ^ CM_ICLKEN_PER_EN_GPT3_ENABLE );
-  ArmDataSyncronizationBarrier ();
-
-  // Clear IRQs
-  MmioWrite32 (INTCPS_CONTROL, INTCPS_CONTROL_NEWIRQAGR);
-  ArmDataSyncronizationBarrier ();
-
-  return RETURN_SUCCESS;
-}
-
-/**
-  Initialize the system (or sometimes called permanent) memory
-
-  This memory is generally represented by the DRAM.
-
-**/
-VOID
-ArmPlatformInitializeSystemMemory (
-  VOID
-  )
-{
-  // We do not need to initialize the System Memory on RTSM
-}
-
-VOID
-ArmPlatformGetPlatformPpiList (
-  OUT UINTN                   *PpiListSize,
-  OUT EFI_PEI_PPI_DESCRIPTOR  **PpiList
-  )
-{
-  *PpiListSize = 0;
-  *PpiList = NULL;
-}
-
-UINTN
-ArmPlatformGetCorePosition (
-  IN UINTN MpId
-  )
-{
-  return 1;
-}
-
+/** @file

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+#include <Library/IoLib.h>

+#include <Library/ArmPlatformLib.h>

+#include <Library/DebugLib.h>

+#include <Library/PcdLib.h>

+

+#include <Omap3530/Omap3530.h>

+#include <BeagleBoard.h>

+

+VOID

+PadConfiguration (

+  BEAGLEBOARD_REVISION Revision

+  );

+

+VOID

+ClockInit (

+  VOID

+  );

+

+/**

+  Detect board revision

+

+  @return Board revision

+**/

+BEAGLEBOARD_REVISION

+BeagleBoardGetRevision (

+  VOID

+  )

+{

+  UINT32 OldPinDir;

+  UINT32 Revision;

+

+  // Read GPIO 171, 172, 173

+  OldPinDir = MmioRead32 (GPIO6_BASE + GPIO_OE);

+  MmioWrite32(GPIO6_BASE + GPIO_OE, (OldPinDir | BIT11 | BIT12 | BIT13));

+  Revision = MmioRead32 (GPIO6_BASE + GPIO_DATAIN);

+  

+  // Restore I/O settings

+  MmioWrite32 (GPIO6_BASE + GPIO_OE, OldPinDir);

+  

+  return (BEAGLEBOARD_REVISION)((Revision >> 11) & 0x7);

+}

+

+/**

+  Return the current Boot Mode

+

+  This function returns the boot reason on the platform

+

+**/

+EFI_BOOT_MODE

+ArmPlatformGetBootMode (

+  VOID

+  )

+{

+  return BOOT_WITH_FULL_CONFIGURATION;

+}

+

+/**

+  Initialize controllers that must setup at the early stage

+

+  Some peripherals must be initialized in Secure World.

+  For example, some L2x0 requires to be initialized in Secure World

+

+**/

+RETURN_STATUS

+ArmPlatformInitialize (

+  IN  UINTN                     MpId

+  )

+{

+  BEAGLEBOARD_REVISION Revision;

+

+  Revision = BeagleBoardGetRevision();

+

+  // Set up Pin muxing.

+  PadConfiguration (Revision);

+

+  // Set up system clocking

+  ClockInit ();

+

+  // Turn off the functional clock for Timer 3

+  MmioAnd32 (CM_FCLKEN_PER, 0xFFFFFFFF ^ CM_ICLKEN_PER_EN_GPT3_ENABLE );

+  ArmDataSyncronizationBarrier ();

+

+  // Clear IRQs

+  MmioWrite32 (INTCPS_CONTROL, INTCPS_CONTROL_NEWIRQAGR);

+  ArmDataSyncronizationBarrier ();

+

+  return RETURN_SUCCESS;

+}

+

+/**

+  Initialize the system (or sometimes called permanent) memory

+

+  This memory is generally represented by the DRAM.

+

+**/

+VOID

+ArmPlatformInitializeSystemMemory (

+  VOID

+  )

+{

+  // We do not need to initialize the System Memory on RTSM

+}

+

+VOID

+ArmPlatformGetPlatformPpiList (

+  OUT UINTN                   *PpiListSize,

+  OUT EFI_PEI_PPI_DESCRIPTOR  **PpiList

+  )

+{

+  *PpiListSize = 0;

+  *PpiList = NULL;

+}

+

+UINTN

+ArmPlatformGetCorePosition (

+  IN UINTN MpId

+  )

+{

+  return 1;

+}

+

diff --git a/BeagleBoardPkg/Library/BeagleBoardLib/BeagleBoardLib.inf b/BeagleBoardPkg/Library/BeagleBoardLib/BeagleBoardLib.inf
index e076500b..7ca98c2b 100755
--- a/BeagleBoardPkg/Library/BeagleBoardLib/BeagleBoardLib.inf
+++ b/BeagleBoardPkg/Library/BeagleBoardLib/BeagleBoardLib.inf
@@ -1,53 +1,53 @@
-#/* @file
-#  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-#  
-#  This program and the accompanying materials                          
-#  are licensed and made available under the terms and conditions of the BSD License         
-#  which accompanies this distribution.  The full text of the license may be found at        
-#  http://opensource.org/licenses/bsd-license.php                                            
-#
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-#
-#*/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = BeagleBoardLib
-  FILE_GUID                      = 736343a0-1d96-11e0-aaaa-0002a5d5c51b
-  MODULE_TYPE                    = BASE
-  VERSION_STRING                 = 1.0
-  LIBRARY_CLASS                  = ArmPlatformLib
-
-[Packages]
-  MdePkg/MdePkg.dec
-  MdeModulePkg/MdeModulePkg.dec
-  EmbeddedPkg/EmbeddedPkg.dec
-  ArmPkg/ArmPkg.dec
-  ArmPlatformPkg/ArmPlatformPkg.dec
-  Omap35xxPkg/Omap35xxPkg.dec
-  BeagleBoardPkg/BeagleBoardPkg.dec
-
-[LibraryClasses]
-  IoLib
-  ArmLib
-#  OmapLib
-  MemoryAllocationLib
-
-[Sources.common]
-  BeagleBoard.c
-  BeagleBoardMem.c
-  PadConfiguration.c
-  Clock.c
-
-[Protocols]
-
-[FeaturePcd]
-  gEmbeddedTokenSpaceGuid.PcdCacheEnable
-
-[FixedPcd]
-  gArmTokenSpaceGuid.PcdFdBaseAddress
-  gArmTokenSpaceGuid.PcdFdSize
-
-  gArmTokenSpaceGuid.PcdSystemMemoryBase
-  gArmTokenSpaceGuid.PcdSystemMemorySize
+#/* @file

+#  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+#  

+#  This program and the accompanying materials                          

+#  are licensed and made available under the terms and conditions of the BSD License         

+#  which accompanies this distribution.  The full text of the license may be found at        

+#  http://opensource.org/licenses/bsd-license.php                                            

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+#

+#*/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = BeagleBoardLib

+  FILE_GUID                      = 736343a0-1d96-11e0-aaaa-0002a5d5c51b

+  MODULE_TYPE                    = BASE

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = ArmPlatformLib

+

+[Packages]

+  MdePkg/MdePkg.dec

+  MdeModulePkg/MdeModulePkg.dec

+  EmbeddedPkg/EmbeddedPkg.dec

+  ArmPkg/ArmPkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+  Omap35xxPkg/Omap35xxPkg.dec

+  BeagleBoardPkg/BeagleBoardPkg.dec

+

+[LibraryClasses]

+  IoLib

+  ArmLib

+#  OmapLib

+  MemoryAllocationLib

+

+[Sources.common]

+  BeagleBoard.c

+  BeagleBoardMem.c

+  PadConfiguration.c

+  Clock.c

+

+[Protocols]

+

+[FeaturePcd]

+  gEmbeddedTokenSpaceGuid.PcdCacheEnable

+

+[FixedPcd]

+  gArmTokenSpaceGuid.PcdFdBaseAddress

+  gArmTokenSpaceGuid.PcdFdSize

+

+  gArmTokenSpaceGuid.PcdSystemMemoryBase

+  gArmTokenSpaceGuid.PcdSystemMemorySize

diff --git a/BeagleBoardPkg/Library/GdbSerialLib/GdbSerialLib.c b/BeagleBoardPkg/Library/GdbSerialLib/GdbSerialLib.c
index 2f9a3202..7634ee17 100644
--- a/BeagleBoardPkg/Library/GdbSerialLib/GdbSerialLib.c
+++ b/BeagleBoardPkg/Library/GdbSerialLib/GdbSerialLib.c
@@ -1,103 +1,103 @@
-/** @file
-  Basic serial IO abstaction for GDB
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include <Uefi.h>
-#include <Library/GdbSerialLib.h>
-#include <Library/PcdLib.h>
-#include <Library/IoLib.h>
-#include <Library/DebugLib.h>
-#include <Library/OmapLib.h>
-#include <Omap3530/Omap3530.h>
-
-RETURN_STATUS
-EFIAPI
-GdbSerialLibConstructor (
-  IN EFI_HANDLE        ImageHandle,
-  IN EFI_SYSTEM_TABLE  *SystemTable
-  )
-{
-  return RETURN_SUCCESS;
-}
-
-RETURN_STATUS
-EFIAPI
-GdbSerialInit (
-  IN UINT64     BaudRate, 
-  IN UINT8      Parity, 
-  IN UINT8      DataBits, 
-  IN UINT8      StopBits 
-  )
-{
-  return RETURN_SUCCESS;
-}
-
-BOOLEAN
-EFIAPI
-GdbIsCharAvailable (
-  VOID
-  )  
-{
-  UINT32 LSR = UartBase(PcdGet32(PcdOmap35xxConsoleUart)) + UART_LSR_REG;
-
-  if ((MmioRead8(LSR) & UART_LSR_RX_FIFO_E_MASK) == UART_LSR_RX_FIFO_E_NOT_EMPTY) {
-    return TRUE;
-  } else {
-    return FALSE;
-  }
-}
-
-CHAR8
-EFIAPI
-GdbGetChar (
-  VOID
-  )
-{
-  UINT32  LSR = UartBase(PcdGet32(PcdOmap35xxConsoleUart)) + UART_LSR_REG;
-  UINT32  RBR = UartBase(PcdGet32(PcdOmap35xxConsoleUart)) + UART_RBR_REG;
-  CHAR8   Char;
-    
-  while ((MmioRead8(LSR) & UART_LSR_RX_FIFO_E_MASK) == UART_LSR_RX_FIFO_E_EMPTY);
-  Char = MmioRead8(RBR);
-
-  return Char;
-}
-
-VOID
-EFIAPI
-GdbPutChar (
-  IN  CHAR8   Char
-  )
-{
-  UINT32  LSR = UartBase(PcdGet32(PcdOmap35xxConsoleUart)) + UART_LSR_REG;
-  UINT32  THR = UartBase(PcdGet32(PcdOmap35xxConsoleUart)) + UART_THR_REG;
-    
-  while ((MmioRead8(LSR) & UART_LSR_TX_FIFO_E_MASK) == UART_LSR_TX_FIFO_E_NOT_EMPTY);
-  MmioWrite8(THR, Char);
-}
-
-VOID
-GdbPutString (
-  IN CHAR8  *String
-  )
-{
-  while (*String != '\0') {
-    GdbPutChar (*String);
-    String++;
-  }
-}
-
-
-
-
+/** @file

+  Basic serial IO abstaction for GDB

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include <Uefi.h>

+#include <Library/GdbSerialLib.h>

+#include <Library/PcdLib.h>

+#include <Library/IoLib.h>

+#include <Library/DebugLib.h>

+#include <Library/OmapLib.h>

+#include <Omap3530/Omap3530.h>

+

+RETURN_STATUS

+EFIAPI

+GdbSerialLibConstructor (

+  IN EFI_HANDLE        ImageHandle,

+  IN EFI_SYSTEM_TABLE  *SystemTable

+  )

+{

+  return RETURN_SUCCESS;

+}

+

+RETURN_STATUS

+EFIAPI

+GdbSerialInit (

+  IN UINT64     BaudRate, 

+  IN UINT8      Parity, 

+  IN UINT8      DataBits, 

+  IN UINT8      StopBits 

+  )

+{

+  return RETURN_SUCCESS;

+}

+

+BOOLEAN

+EFIAPI

+GdbIsCharAvailable (

+  VOID

+  )  

+{

+  UINT32 LSR = UartBase(PcdGet32(PcdOmap35xxConsoleUart)) + UART_LSR_REG;

+

+  if ((MmioRead8(LSR) & UART_LSR_RX_FIFO_E_MASK) == UART_LSR_RX_FIFO_E_NOT_EMPTY) {

+    return TRUE;

+  } else {

+    return FALSE;

+  }

+}

+

+CHAR8

+EFIAPI

+GdbGetChar (

+  VOID

+  )

+{

+  UINT32  LSR = UartBase(PcdGet32(PcdOmap35xxConsoleUart)) + UART_LSR_REG;

+  UINT32  RBR = UartBase(PcdGet32(PcdOmap35xxConsoleUart)) + UART_RBR_REG;

+  CHAR8   Char;

+    

+  while ((MmioRead8(LSR) & UART_LSR_RX_FIFO_E_MASK) == UART_LSR_RX_FIFO_E_EMPTY);

+  Char = MmioRead8(RBR);

+

+  return Char;

+}

+

+VOID

+EFIAPI

+GdbPutChar (

+  IN  CHAR8   Char

+  )

+{

+  UINT32  LSR = UartBase(PcdGet32(PcdOmap35xxConsoleUart)) + UART_LSR_REG;

+  UINT32  THR = UartBase(PcdGet32(PcdOmap35xxConsoleUart)) + UART_THR_REG;

+    

+  while ((MmioRead8(LSR) & UART_LSR_TX_FIFO_E_MASK) == UART_LSR_TX_FIFO_E_NOT_EMPTY);

+  MmioWrite8(THR, Char);

+}

+

+VOID

+GdbPutString (

+  IN CHAR8  *String

+  )

+{

+  while (*String != '\0') {

+    GdbPutChar (*String);

+    String++;

+  }

+}

+

+

+

+

diff --git a/BeagleBoardPkg/Library/GdbSerialLib/GdbSerialLib.inf b/BeagleBoardPkg/Library/GdbSerialLib/GdbSerialLib.inf
index 8627442e..df96e8b7 100644
--- a/BeagleBoardPkg/Library/GdbSerialLib/GdbSerialLib.inf
+++ b/BeagleBoardPkg/Library/GdbSerialLib/GdbSerialLib.inf
@@ -1,41 +1,41 @@
-#/** @file
-#  
-#  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = GdbSerialLib
-  FILE_GUID                      = E2423349-EF5D-439B-95F5-8B8D8E3B443F
-  MODULE_TYPE                    = UEFI_DRIVER
-  VERSION_STRING                 = 1.0
-  LIBRARY_CLASS                  = GdbSerialLib
-
-  CONSTRUCTOR                    = GdbSerialLibConstructor
-
-
-[Sources.common]
-  GdbSerialLib.c
-
-
-[Packages]
-  MdePkg/MdePkg.dec
-  EmbeddedPkg/EmbeddedPkg.dec
-  Omap35xxPkg/Omap35xxPkg.dec
-
-[LibraryClasses]
-  DebugLib
-  IoLib
-  OmapLib    
-
-[FixedPcd]
-  gOmap35xxTokenSpaceGuid.PcdOmap35xxConsoleUart
-
+#/** @file

+#  

+#  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = GdbSerialLib

+  FILE_GUID                      = E2423349-EF5D-439B-95F5-8B8D8E3B443F

+  MODULE_TYPE                    = UEFI_DRIVER

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = GdbSerialLib

+

+  CONSTRUCTOR                    = GdbSerialLibConstructor

+

+

+[Sources.common]

+  GdbSerialLib.c

+

+

+[Packages]

+  MdePkg/MdePkg.dec

+  EmbeddedPkg/EmbeddedPkg.dec

+  Omap35xxPkg/Omap35xxPkg.dec

+

+[LibraryClasses]

+  DebugLib

+  IoLib

+  OmapLib    

+

+[FixedPcd]

+  gOmap35xxTokenSpaceGuid.PcdOmap35xxConsoleUart

+

diff --git a/BeagleBoardPkg/Sec/Cache.c b/BeagleBoardPkg/Sec/Cache.c
index 4256b0e9..193004a8 100644
--- a/BeagleBoardPkg/Sec/Cache.c
+++ b/BeagleBoardPkg/Sec/Cache.c
@@ -75,5 +75,5 @@ InitCache (
   

   ArmConfigureMmu (MemoryTable, &TranslationTableBase, &TranslationTableSize);

   

-  BuildMemoryAllocationHob((EFI_PHYSICAL_ADDRESS)(UINTN)TranslationTableBase, TranslationTableSize, EfiBootServicesData);
+  BuildMemoryAllocationHob((EFI_PHYSICAL_ADDRESS)(UINTN)TranslationTableBase, TranslationTableSize, EfiBootServicesData);

 }

diff --git a/BeagleBoardPkg/Sec/Sec.inf b/BeagleBoardPkg/Sec/Sec.inf
index a3fc192c..7fc4ec12 100644
--- a/BeagleBoardPkg/Sec/Sec.inf
+++ b/BeagleBoardPkg/Sec/Sec.inf
@@ -1,73 +1,73 @@
-
-#/** @file
-#  SEC - Reset vector code that jumps to C and loads DXE core
-#  
-#  Copyright (c) 2008, Apple Inc. All rights reserved.<BR>
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = BeagleBoardSec
-  FILE_GUID                      = d959e387-7b91-452c-90e0-a1dbac90ddb8
-  MODULE_TYPE                    = SEC
-  VERSION_STRING                 = 1.0
-
-
-[Sources.ARM]
-  Arm/ModuleEntryPoint.S   | GCC
-  Arm/ModuleEntryPoint.asm | RVCT
-
-[Sources.ARM]
-  Sec.c
-  Cache.c
-  PadConfiguration.c
-  Clock.c
-  
-[Packages]
-  MdePkg/MdePkg.dec
-  MdeModulePkg/MdeModulePkg.dec
-  EmbeddedPkg/EmbeddedPkg.dec
-  ArmPkg/ArmPkg.dec
-  Omap35xxPkg/Omap35xxPkg.dec
-  IntelFrameworkModulePkg/IntelFrameworkModulePkg.dec
-
-[LibraryClasses]
-  BaseLib
-  DebugLib
-  ArmLib
-  IoLib
-  ExtractGuidedSectionLib
-  LzmaDecompressLib
-  OmapLib
-  PeCoffGetEntryPointLib
-  DebugAgentLib
-  MemoryAllocationLib
-  PrePiHobListPointerLib
-
-[FeaturePcd]  
-  gEmbeddedTokenSpaceGuid.PcdCacheEnable
-
-[FixedPcd]
-  gEfiMdePkgTokenSpaceGuid.PcdUartDefaultBaudRate
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedFdBaseAddress
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedFdSize
-  gEmbeddedTokenSpaceGuid.PcdFlashFvMainBase
-  gEmbeddedTokenSpaceGuid.PcdFlashFvMainSize
-  gEmbeddedTokenSpaceGuid.PcdPrePiStackSize
-  gEmbeddedTokenSpaceGuid.PcdPrePiStackBase
-  gEmbeddedTokenSpaceGuid.PcdMemoryBase
-  gEmbeddedTokenSpaceGuid.PcdMemorySize
-  
-  gOmap35xxTokenSpaceGuid.PcdOmap35xxConsoleUart
-  gOmap35xxTokenSpaceGuid.PcdOmap35xxFreeTimer
-  
-  gArmTokenSpaceGuid.PcdCpuVectorBaseAddress
-
+

+#/** @file

+#  SEC - Reset vector code that jumps to C and loads DXE core

+#  

+#  Copyright (c) 2008, Apple Inc. All rights reserved.<BR>

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = BeagleBoardSec

+  FILE_GUID                      = d959e387-7b91-452c-90e0-a1dbac90ddb8

+  MODULE_TYPE                    = SEC

+  VERSION_STRING                 = 1.0

+

+

+[Sources.ARM]

+  Arm/ModuleEntryPoint.S   | GCC

+  Arm/ModuleEntryPoint.asm | RVCT

+

+[Sources.ARM]

+  Sec.c

+  Cache.c

+  PadConfiguration.c

+  Clock.c

+  

+[Packages]

+  MdePkg/MdePkg.dec

+  MdeModulePkg/MdeModulePkg.dec

+  EmbeddedPkg/EmbeddedPkg.dec

+  ArmPkg/ArmPkg.dec

+  Omap35xxPkg/Omap35xxPkg.dec

+  IntelFrameworkModulePkg/IntelFrameworkModulePkg.dec

+

+[LibraryClasses]

+  BaseLib

+  DebugLib

+  ArmLib

+  IoLib

+  ExtractGuidedSectionLib

+  LzmaDecompressLib

+  OmapLib

+  PeCoffGetEntryPointLib

+  DebugAgentLib

+  MemoryAllocationLib

+  PrePiHobListPointerLib

+

+[FeaturePcd]  

+  gEmbeddedTokenSpaceGuid.PcdCacheEnable

+

+[FixedPcd]

+  gEfiMdePkgTokenSpaceGuid.PcdUartDefaultBaudRate

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedFdBaseAddress

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedFdSize

+  gEmbeddedTokenSpaceGuid.PcdFlashFvMainBase

+  gEmbeddedTokenSpaceGuid.PcdFlashFvMainSize

+  gEmbeddedTokenSpaceGuid.PcdPrePiStackSize

+  gEmbeddedTokenSpaceGuid.PcdPrePiStackBase

+  gEmbeddedTokenSpaceGuid.PcdMemoryBase

+  gEmbeddedTokenSpaceGuid.PcdMemorySize

+  

+  gOmap35xxTokenSpaceGuid.PcdOmap35xxConsoleUart

+  gOmap35xxTokenSpaceGuid.PcdOmap35xxFreeTimer

+  

+  gArmTokenSpaceGuid.PcdCpuVectorBaseAddress

+

diff --git a/BeagleBoardPkg/Tools/generate_image.c b/BeagleBoardPkg/Tools/generate_image.c
index fa4cdcc4..9426ca33 100644
--- a/BeagleBoardPkg/Tools/generate_image.c
+++ b/BeagleBoardPkg/Tools/generate_image.c
@@ -1,408 +1,408 @@
-/** @file
- The data structures in this code come from:
- OMAP35x Applications Processor Technical Reference Manual chapter 25
- OMAP34xx Multimedia Device Technical Reference Manual chapter 26.4.8.
- 
- You should use the OMAP35x manual when possible. Some things, like SectionKey, 
- are not defined in the OMAP35x manual and you have to use the OMAP34xx manual
- to find the data. 
-
-  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <errno.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-
-
-
-//TOC structure as defined by OMAP35XX TRM.
-typedef struct {
-  unsigned int  Start;
-  unsigned int  Size;
-  unsigned int  Reserved1;
-  unsigned int  Reserved2;
-  unsigned int  Reserved3;
-  unsigned char Filename[12];
-} TOC_DATA;
-
-//NOTE: OMAP3430 TRM has CHSETTINGS and CHRAM structures.
-typedef struct {
-  unsigned int   SectionKey;
-  unsigned char  Valid;
-  unsigned char  Version;
-  unsigned short Reserved;
-  unsigned int   Flags;
-  unsigned int   PRM_CLKSRC_CTRL; 
-  unsigned int   PRM_CLKSEL; 
-  unsigned int   CM_CLKSEL1_EMU;
-  unsigned int   CM_CLKSEL_CORE;
-  unsigned int   CM_CLKSEL_WKUP;
-  unsigned int   CM_CLKEN_PLL_DPLL3;
-  unsigned int   CM_AUTOIDLE_PLL_DPLL3; 
-  unsigned int   CM_CLKSEL1_PLL; 
-  unsigned int   CM_CLKEN_PLL_DPLL4;
-  unsigned int   CM_AUTOIDLE_PLL_DPLL4;
-  unsigned int   CM_CLKSEL2_PLL;
-  unsigned int   CM_CLKSEL3_PLL; 
-  unsigned int   CM_CLKEN_PLL_MPU; 
-  unsigned int   CM_AUTOIDLE_PLL_MPU; 
-  unsigned int   CM_CLKSEL1_PLL_MPU; 
-  unsigned int   CM_CLKSEL2_PLL_MPU; 
-  unsigned int   CM_CLKSTCTRL_MPU;
-} CHSETTINGS_DATA;
-
-typedef struct {
-  unsigned int   SectionKey;
-  unsigned char  Valid;
-  unsigned char  Reserved1;
-  unsigned char  Reserved2;
-  unsigned char  Reserved3;
-  unsigned short SDRC_SYSCONFIG_LSB;
-  unsigned short SDRC_CS_CFG_LSB;
-  unsigned short SDRC_SHARING_LSB;
-  unsigned short SDRC_ERR_TYPE_LSB;
-  unsigned int   SDRC_DLLA_CTRL;
-  unsigned short Reserved4;
-  unsigned short Reserved5;
-  unsigned int   SDRC_POWER;
-  unsigned short MEMORY_TYPE_CS0;
-  unsigned short Reserved6;
-  unsigned int   SDRC_MCFG_0;
-  unsigned short SDRC_MR_0_LSB;
-  unsigned short SDRC_EMR1_0_LSB;
-  unsigned short SDRC_EMR2_0_LSB;
-  unsigned short SDRC_EMR3_0_LSB;
-  unsigned int   SDRC_ACTIM_CTRLA_0;
-  unsigned int   SDRC_ACTIM_CTRLB_0;
-  unsigned int   SDRC_RFRCTRL_0;
-  unsigned short MEMORY_TYPE_CS1;
-  unsigned short Reserved7;
-  unsigned int   SDRC_MCFG_1;
-  unsigned short SDRC_MR_1_LSB;
-  unsigned short SDRC_EMR1_1_LSB;
-  unsigned short SDRC_EMR2_1_LSB;
-  unsigned short SDRC_EMR3_1_LSB;
-  unsigned int   SDRC_ACTIM_CTRLA_1;
-  unsigned int   SDRC_ACTIM_CTRLB_1;
-  unsigned int   SDRC_RFRCTRL_1;
-  unsigned int   Reserved8;
-  unsigned short Flags;
-  unsigned short Reserved9;
-} CHRAM_DATA;
-
-#define CHSETTINGS_START      0xA0
-#define CHSETTINGS_SIZE       0x50
-#define CHRAM_START           0xF0
-#define CHRAM_SIZE            0x5C
-#define CLOSING_TOC_ITEM_SIZE 4
-
-unsigned char gConfigurationHeader[512];
-unsigned int  gImageExecutionAddress;
-char          *gInputImageFile = NULL;
-char          *gOutputImageFile = NULL;
-char          *gDataFile = NULL;
-
-static
-void
-PrintUsage (
-  void
-  )
-{
-  printf("Usage..\n");
-}
-
-static
-void
-PopulateCHSETTINGSData (
-  FILE            *DataFile,
-  CHSETTINGS_DATA *CHSETTINGSData
-  )
-{
-  unsigned int Value;
-  
-  CHSETTINGSData->SectionKey            = 0xC0C0C0C1;
-  CHSETTINGSData->Valid                 = 0x1;
-  CHSETTINGSData->Version               = 0x1;
-  CHSETTINGSData->Reserved              = 0x00;
-  CHSETTINGSData->Flags                 = 0x050001FD;
-
-  //General clock settings.
-  fscanf(DataFile, "PRM_CLKSRC_CTRL=0x%08x\n", &Value);
-  CHSETTINGSData->PRM_CLKSRC_CTRL = Value;
-  fscanf(DataFile, "PRM_CLKSEL=0x%08x\n", &Value);
-  CHSETTINGSData->PRM_CLKSEL = Value;
-  fscanf(DataFile, "CM_CLKSEL1_EMU=0x%08x\n", &Value);
-  CHSETTINGSData->CM_CLKSEL1_EMU = Value;
-
-  //Clock configuration
-  fscanf(DataFile, "CM_CLKSEL_CORE=0x%08x\n", &Value);
-  CHSETTINGSData->CM_CLKSEL_CORE = Value;
-  fscanf(DataFile, "CM_CLKSEL_WKUP=0x%08x\n", &Value);
-  CHSETTINGSData->CM_CLKSEL_WKUP = Value;
-
-  //DPLL3 (Core) settings
-  fscanf(DataFile, "CM_CLKEN_PLL_DPLL3=0x%08x\n", &Value);
-  CHSETTINGSData->CM_CLKEN_PLL_DPLL3 = Value;
-  fscanf(DataFile, "CM_AUTOIDLE_PLL_DPLL3=0x%08x\n", &Value);
-  CHSETTINGSData->CM_AUTOIDLE_PLL_DPLL3 = Value;
-  fscanf(DataFile, "CM_CLKSEL1_PLL=0x%08x\n", &Value);
-  CHSETTINGSData->CM_CLKSEL1_PLL = Value;
-
-  //DPLL4 (Peripheral) settings
-  fscanf(DataFile, "CM_CLKEN_PLL_DPLL4=0x%08x\n", &Value);
-  CHSETTINGSData->CM_CLKEN_PLL_DPLL4 = Value;
-  fscanf(DataFile, "CM_AUTOIDLE_PLL_DPLL4=0x%08x\n", &Value);
-  CHSETTINGSData->CM_AUTOIDLE_PLL_DPLL4 = Value;
-  fscanf(DataFile, "CM_CLKSEL2_PLL=0x%08x\n", &Value);
-  CHSETTINGSData->CM_CLKSEL2_PLL = Value;
-  fscanf(DataFile, "CM_CLKSEL3_PLL=0x%08x\n", &Value);
-  CHSETTINGSData->CM_CLKSEL3_PLL = Value;
-
-  //DPLL1 (MPU) settings
-  fscanf(DataFile, "CM_CLKEN_PLL_MPU=0x%08x\n", &Value);
-  CHSETTINGSData->CM_CLKEN_PLL_MPU = Value;
-  fscanf(DataFile, "CM_AUTOIDLE_PLL_MPU=0x%08x\n", &Value);
-  CHSETTINGSData->CM_AUTOIDLE_PLL_MPU = Value;
-  fscanf(DataFile, "CM_CLKSEL1_PLL_MPU=0x%08x\n", &Value);
-  CHSETTINGSData->CM_CLKSEL1_PLL_MPU = Value;
-  fscanf(DataFile, "CM_CLKSEL2_PLL_MPU=0x%08x\n", &Value);
-  CHSETTINGSData->CM_CLKSEL2_PLL_MPU = Value;
-  fscanf(DataFile, "CM_CLKSTCTRL_MPU=0x%08x\n", &Value);
-  CHSETTINGSData->CM_CLKSTCTRL_MPU = Value;
-}
-
-static
-void
-PopulateCHRAMData (
-  FILE       *DataFile,
-  CHRAM_DATA *CHRAMData
-  )
-{
-  unsigned int Value;
-  
-  CHRAMData->SectionKey         = 0xC0C0C0C2;
-  CHRAMData->Valid              = 0x1;
-  
-  fscanf(DataFile, "SDRC_SYSCONFIG_LSB=0x%04x\n", &Value);
-  CHRAMData->SDRC_SYSCONFIG_LSB = Value;
-  fscanf(DataFile, "SDRC_CS_CFG_LSB=0x%04x\n", &Value);
-  CHRAMData->SDRC_CS_CFG_LSB    = Value;
-  fscanf(DataFile, "SDRC_SHARING_LSB=0x%04x\n", &Value);
-  CHRAMData->SDRC_SHARING_LSB   = Value;
-  fscanf(DataFile, "SDRC_ERR_TYPE_LSB=0x%04x\n", &Value);
-  CHRAMData->SDRC_ERR_TYPE_LSB  = Value;
-  fscanf(DataFile, "SDRC_DLLA_CTRL=0x%08x\n", &Value);
-  CHRAMData->SDRC_DLLA_CTRL     = Value;
-  fscanf(DataFile, "SDRC_POWER=0x%08x\n", &Value);
-  CHRAMData->SDRC_POWER         = Value;
-  fscanf(DataFile, "MEMORY_TYPE_CS0=0x%04x\n", &Value);
-  CHRAMData->MEMORY_TYPE_CS0    = Value;
-  fscanf(DataFile, "SDRC_MCFG_0=0x%08x\n", &Value);
-  CHRAMData->SDRC_MCFG_0        = Value;
-  fscanf(DataFile, "SDRC_MR_0_LSB=0x%04x\n", &Value);
-  CHRAMData->SDRC_MR_0_LSB      = Value;
-  fscanf(DataFile, "SDRC_EMR1_0_LSB=0x%04x\n", &Value);
-  CHRAMData->SDRC_EMR1_0_LSB    = Value;
-  fscanf(DataFile, "SDRC_EMR2_0_LSB=0x%04x\n", &Value);
-  CHRAMData->SDRC_EMR2_0_LSB    = Value;
-  fscanf(DataFile, "SDRC_EMR3_0_LSB=0x%04x\n", &Value);
-  CHRAMData->SDRC_EMR3_0_LSB    = Value;
-  fscanf(DataFile, "SDRC_ACTIM_CTRLA_0=0x%08x\n", &Value);
-  CHRAMData->SDRC_ACTIM_CTRLA_0 = Value;
-  fscanf(DataFile, "SDRC_ACTIM_CTRLB_0=0x%08x\n", &Value);
-  CHRAMData->SDRC_ACTIM_CTRLB_0 = Value;
-  fscanf(DataFile, "SDRC_RFRCTRL_0=0x%08x\n", &Value);
-  CHRAMData->SDRC_RFRCTRL_0     = Value;
-  fscanf(DataFile, "MEMORY_TYPE_CS1=0x%04x\n", &Value);
-  CHRAMData->MEMORY_TYPE_CS1    = Value;
-  fscanf(DataFile, "SDRC_MCFG_1=0x%08x\n", &Value);
-  CHRAMData->SDRC_MCFG_1        = Value;
-  fscanf(DataFile, "SDRC_MR_1_LSB=0x%04x\n", &Value);
-  CHRAMData->SDRC_MR_1_LSB      = Value;
-  fscanf(DataFile, "SDRC_EMR1_1_LSB=0x%04x\n", &Value);
-  CHRAMData->SDRC_EMR1_1_LSB    = Value;
-  fscanf(DataFile, "SDRC_EMR2_1_LSB=0x%04x\n", &Value);
-  CHRAMData->SDRC_EMR2_1_LSB    = Value;
-  fscanf(DataFile, "SDRC_EMR3_1_LSB=0x%04x\n", &Value);
-  CHRAMData->SDRC_EMR3_1_LSB    = Value;
-  fscanf(DataFile, "SDRC_ACTIM_CTRLA_1=0x%08x\n", &Value);
-  CHRAMData->SDRC_ACTIM_CTRLA_1 = Value;
-  fscanf(DataFile, "SDRC_ACTIM_CTRLB_1=0x%08x\n", &Value);
-  CHRAMData->SDRC_ACTIM_CTRLB_1 = Value;
-  fscanf(DataFile, "SDRC_RFRCTRL_1=0x%08x\n", &Value);
-  CHRAMData->SDRC_RFRCTRL_1     = Value;
-
-  CHRAMData->Flags              = 0x0003;
-}
-
-static 
-void 
-PrepareConfigurationHeader (
-  void
-  )
-{
-  TOC_DATA        Toc;
-  CHSETTINGS_DATA CHSETTINGSData;
-  CHRAM_DATA      CHRAMData;
-  unsigned int    ConfigurationHdrOffset = 0;
-  FILE            *DataFile;
-  
-  // Open data file
-  DataFile = fopen(gDataFile, "rb");
-  if (DataFile == NULL) {
-    fprintf(stderr, "Can't open data file %s.\n", gDataFile);
-    exit(1);
-  }
-  
-  //Initialize configuration header.
-  memset(gConfigurationHeader, 0x00, sizeof(gConfigurationHeader));
-
-  //CHSETTINGS TOC
-  memset(&Toc, 0x00, sizeof(TOC_DATA));
-  Toc.Start = CHSETTINGS_START;
-  Toc.Size = CHSETTINGS_SIZE;
-  strcpy((char *)Toc.Filename, (const char *)"CHSETTINGS");
-  memcpy(gConfigurationHeader + ConfigurationHdrOffset, &Toc, sizeof(TOC_DATA));
-
-  //Populate CHSETTINGS Data
-  memset(&CHSETTINGSData, 0x00, sizeof(CHSETTINGS_DATA));
-  PopulateCHSETTINGSData(DataFile, &CHSETTINGSData);
-  memcpy(gConfigurationHeader + Toc.Start, &CHSETTINGSData, Toc.Size);
-
-  //Adjust ConfigurationHdrOffset to point to next TOC
-  ConfigurationHdrOffset += sizeof(TOC_DATA);
-
-  //CHRAM TOC
-  memset(&Toc, 0x00, sizeof(TOC_DATA));
-  Toc.Start = CHRAM_START;
-  Toc.Size = CHRAM_SIZE;
-  strcpy((char *)Toc.Filename, (const char *)"CHRAM");
-  memcpy(gConfigurationHeader + ConfigurationHdrOffset, &Toc, sizeof(TOC_DATA));
-
-  //Populate CHRAM Data
-  memset(&CHRAMData, 0x00, sizeof(CHRAM_DATA));
-  PopulateCHRAMData(DataFile, &CHRAMData);
-  memcpy(gConfigurationHeader + Toc.Start, &CHRAMData, Toc.Size);
-  
-  //Adjust ConfigurationHdrOffset to point to next TOC
-  ConfigurationHdrOffset += sizeof(TOC_DATA);
-
-  //Closing TOC item
-  memset(gConfigurationHeader + ConfigurationHdrOffset, 0xFF, CLOSING_TOC_ITEM_SIZE);
-  ConfigurationHdrOffset += CLOSING_TOC_ITEM_SIZE;
-  
-  // Close data file
-  fclose(DataFile);
-}
-
-static 
-void
-ConstructImage (
-  void
-  )
-{
-  FILE         *InputFile;
-  FILE         *OutputFile;
-  unsigned int InputImageFileSize;
-  struct       stat FileStat;
-  char         Ch;
-  unsigned int i;
-
-  InputFile = fopen(gInputImageFile, "rb");
-  if (InputFile == NULL) {
-    fprintf(stderr, "Can't open input file.\n");
-    exit(0);
-  } 
-
-  // Get the size of the input image.
-  fstat(fileno(InputFile), &FileStat);
-  InputImageFileSize = FileStat.st_size;
-  
-  OutputFile = fopen(gOutputImageFile, "wb");
-  if (OutputFile == NULL) {
-    fprintf(stderr, "Can't open output file %s.\n", gOutputImageFile);
-    exit(0);
-  }
-
-  // Write Configuration header 
-  fwrite(gConfigurationHeader, 1, sizeof(gConfigurationHeader), OutputFile);
-
-  // Write image header (Input image size, execution address)
-  fwrite(&InputImageFileSize, 1, 4, OutputFile);
-  fwrite(&gImageExecutionAddress, 1, 4, OutputFile);
-
-  // Copy input image to the output file.
-  for (i = 0; i < InputImageFileSize; i++) {
-    fread(&Ch, 1, 1, InputFile);
-    fwrite(&Ch, 1, 1, OutputFile);
-  }
-
-  fclose(InputFile);
-  fclose(OutputFile);
-}
-
-
-int 
-main (
-  int    argc, 
-  char** argv
-  )
-{
-  char          Ch;
-  unsigned char *ptr;
-  int           i;
-  int           TwoArg;  
-
-  if (argc == 1) {
-    PrintUsage ();
-    exit(1);
-  }
-
-  for (i=1; i < argc; i++) {
-    if (argv[i][0] == '-') {
-      // TwoArg TRUE -E 0x123, FALSE -E0x1234
-      TwoArg = (argv[i][2] != ' ');
-      switch (argv[i][1]) {
-        case 'E': /* Image execution address */
-          gImageExecutionAddress = strtoul (TwoArg ? argv[i+1] : &argv[i][2], (char **)&ptr, 16);
-          break;
-        
-        case 'I': /* Input image file */
-          gInputImageFile = TwoArg ? argv[i+1] : &argv[i][2];
-          break;
-
-        case 'O': /* Output image file */
-          gOutputImageFile = TwoArg ? argv[i+1] : &argv[i][2];
-          break;
-        
-        case 'D': /* Data file */
-          gDataFile = TwoArg ? argv[i+1] : &argv[i][2];
-          break;
-
-        default:
-          abort ();
-      }
-    }
-  }
-
- 
-  //Prepare configuration header
-  PrepareConfigurationHeader ();
-
-  //Build image with configuration header + image header + image
-  ConstructImage ();
-
-  return 0;
-}
+/** @file

+ The data structures in this code come from:

+ OMAP35x Applications Processor Technical Reference Manual chapter 25

+ OMAP34xx Multimedia Device Technical Reference Manual chapter 26.4.8.

+ 

+ You should use the OMAP35x manual when possible. Some things, like SectionKey, 

+ are not defined in the OMAP35x manual and you have to use the OMAP34xx manual

+ to find the data. 

+

+  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+#include <errno.h>

+#include <sys/types.h>

+#include <sys/stat.h>

+

+

+

+//TOC structure as defined by OMAP35XX TRM.

+typedef struct {

+  unsigned int  Start;

+  unsigned int  Size;

+  unsigned int  Reserved1;

+  unsigned int  Reserved2;

+  unsigned int  Reserved3;

+  unsigned char Filename[12];

+} TOC_DATA;

+

+//NOTE: OMAP3430 TRM has CHSETTINGS and CHRAM structures.

+typedef struct {

+  unsigned int   SectionKey;

+  unsigned char  Valid;

+  unsigned char  Version;

+  unsigned short Reserved;

+  unsigned int   Flags;

+  unsigned int   PRM_CLKSRC_CTRL; 

+  unsigned int   PRM_CLKSEL; 

+  unsigned int   CM_CLKSEL1_EMU;

+  unsigned int   CM_CLKSEL_CORE;

+  unsigned int   CM_CLKSEL_WKUP;

+  unsigned int   CM_CLKEN_PLL_DPLL3;

+  unsigned int   CM_AUTOIDLE_PLL_DPLL3; 

+  unsigned int   CM_CLKSEL1_PLL; 

+  unsigned int   CM_CLKEN_PLL_DPLL4;

+  unsigned int   CM_AUTOIDLE_PLL_DPLL4;

+  unsigned int   CM_CLKSEL2_PLL;

+  unsigned int   CM_CLKSEL3_PLL; 

+  unsigned int   CM_CLKEN_PLL_MPU; 

+  unsigned int   CM_AUTOIDLE_PLL_MPU; 

+  unsigned int   CM_CLKSEL1_PLL_MPU; 

+  unsigned int   CM_CLKSEL2_PLL_MPU; 

+  unsigned int   CM_CLKSTCTRL_MPU;

+} CHSETTINGS_DATA;

+

+typedef struct {

+  unsigned int   SectionKey;

+  unsigned char  Valid;

+  unsigned char  Reserved1;

+  unsigned char  Reserved2;

+  unsigned char  Reserved3;

+  unsigned short SDRC_SYSCONFIG_LSB;

+  unsigned short SDRC_CS_CFG_LSB;

+  unsigned short SDRC_SHARING_LSB;

+  unsigned short SDRC_ERR_TYPE_LSB;

+  unsigned int   SDRC_DLLA_CTRL;

+  unsigned short Reserved4;

+  unsigned short Reserved5;

+  unsigned int   SDRC_POWER;

+  unsigned short MEMORY_TYPE_CS0;

+  unsigned short Reserved6;

+  unsigned int   SDRC_MCFG_0;

+  unsigned short SDRC_MR_0_LSB;

+  unsigned short SDRC_EMR1_0_LSB;

+  unsigned short SDRC_EMR2_0_LSB;

+  unsigned short SDRC_EMR3_0_LSB;

+  unsigned int   SDRC_ACTIM_CTRLA_0;

+  unsigned int   SDRC_ACTIM_CTRLB_0;

+  unsigned int   SDRC_RFRCTRL_0;

+  unsigned short MEMORY_TYPE_CS1;

+  unsigned short Reserved7;

+  unsigned int   SDRC_MCFG_1;

+  unsigned short SDRC_MR_1_LSB;

+  unsigned short SDRC_EMR1_1_LSB;

+  unsigned short SDRC_EMR2_1_LSB;

+  unsigned short SDRC_EMR3_1_LSB;

+  unsigned int   SDRC_ACTIM_CTRLA_1;

+  unsigned int   SDRC_ACTIM_CTRLB_1;

+  unsigned int   SDRC_RFRCTRL_1;

+  unsigned int   Reserved8;

+  unsigned short Flags;

+  unsigned short Reserved9;

+} CHRAM_DATA;

+

+#define CHSETTINGS_START      0xA0

+#define CHSETTINGS_SIZE       0x50

+#define CHRAM_START           0xF0

+#define CHRAM_SIZE            0x5C

+#define CLOSING_TOC_ITEM_SIZE 4

+

+unsigned char gConfigurationHeader[512];

+unsigned int  gImageExecutionAddress;

+char          *gInputImageFile = NULL;

+char          *gOutputImageFile = NULL;

+char          *gDataFile = NULL;

+

+static

+void

+PrintUsage (

+  void

+  )

+{

+  printf("Usage..\n");

+}

+

+static

+void

+PopulateCHSETTINGSData (

+  FILE            *DataFile,

+  CHSETTINGS_DATA *CHSETTINGSData

+  )

+{

+  unsigned int Value;

+  

+  CHSETTINGSData->SectionKey            = 0xC0C0C0C1;

+  CHSETTINGSData->Valid                 = 0x1;

+  CHSETTINGSData->Version               = 0x1;

+  CHSETTINGSData->Reserved              = 0x00;

+  CHSETTINGSData->Flags                 = 0x050001FD;

+

+  //General clock settings.

+  fscanf(DataFile, "PRM_CLKSRC_CTRL=0x%08x\n", &Value);

+  CHSETTINGSData->PRM_CLKSRC_CTRL = Value;

+  fscanf(DataFile, "PRM_CLKSEL=0x%08x\n", &Value);

+  CHSETTINGSData->PRM_CLKSEL = Value;

+  fscanf(DataFile, "CM_CLKSEL1_EMU=0x%08x\n", &Value);

+  CHSETTINGSData->CM_CLKSEL1_EMU = Value;

+

+  //Clock configuration

+  fscanf(DataFile, "CM_CLKSEL_CORE=0x%08x\n", &Value);

+  CHSETTINGSData->CM_CLKSEL_CORE = Value;

+  fscanf(DataFile, "CM_CLKSEL_WKUP=0x%08x\n", &Value);

+  CHSETTINGSData->CM_CLKSEL_WKUP = Value;

+

+  //DPLL3 (Core) settings

+  fscanf(DataFile, "CM_CLKEN_PLL_DPLL3=0x%08x\n", &Value);

+  CHSETTINGSData->CM_CLKEN_PLL_DPLL3 = Value;

+  fscanf(DataFile, "CM_AUTOIDLE_PLL_DPLL3=0x%08x\n", &Value);

+  CHSETTINGSData->CM_AUTOIDLE_PLL_DPLL3 = Value;

+  fscanf(DataFile, "CM_CLKSEL1_PLL=0x%08x\n", &Value);

+  CHSETTINGSData->CM_CLKSEL1_PLL = Value;

+

+  //DPLL4 (Peripheral) settings

+  fscanf(DataFile, "CM_CLKEN_PLL_DPLL4=0x%08x\n", &Value);

+  CHSETTINGSData->CM_CLKEN_PLL_DPLL4 = Value;

+  fscanf(DataFile, "CM_AUTOIDLE_PLL_DPLL4=0x%08x\n", &Value);

+  CHSETTINGSData->CM_AUTOIDLE_PLL_DPLL4 = Value;

+  fscanf(DataFile, "CM_CLKSEL2_PLL=0x%08x\n", &Value);

+  CHSETTINGSData->CM_CLKSEL2_PLL = Value;

+  fscanf(DataFile, "CM_CLKSEL3_PLL=0x%08x\n", &Value);

+  CHSETTINGSData->CM_CLKSEL3_PLL = Value;

+

+  //DPLL1 (MPU) settings

+  fscanf(DataFile, "CM_CLKEN_PLL_MPU=0x%08x\n", &Value);

+  CHSETTINGSData->CM_CLKEN_PLL_MPU = Value;

+  fscanf(DataFile, "CM_AUTOIDLE_PLL_MPU=0x%08x\n", &Value);

+  CHSETTINGSData->CM_AUTOIDLE_PLL_MPU = Value;

+  fscanf(DataFile, "CM_CLKSEL1_PLL_MPU=0x%08x\n", &Value);

+  CHSETTINGSData->CM_CLKSEL1_PLL_MPU = Value;

+  fscanf(DataFile, "CM_CLKSEL2_PLL_MPU=0x%08x\n", &Value);

+  CHSETTINGSData->CM_CLKSEL2_PLL_MPU = Value;

+  fscanf(DataFile, "CM_CLKSTCTRL_MPU=0x%08x\n", &Value);

+  CHSETTINGSData->CM_CLKSTCTRL_MPU = Value;

+}

+

+static

+void

+PopulateCHRAMData (

+  FILE       *DataFile,

+  CHRAM_DATA *CHRAMData

+  )

+{

+  unsigned int Value;

+  

+  CHRAMData->SectionKey         = 0xC0C0C0C2;

+  CHRAMData->Valid              = 0x1;

+  

+  fscanf(DataFile, "SDRC_SYSCONFIG_LSB=0x%04x\n", &Value);

+  CHRAMData->SDRC_SYSCONFIG_LSB = Value;

+  fscanf(DataFile, "SDRC_CS_CFG_LSB=0x%04x\n", &Value);

+  CHRAMData->SDRC_CS_CFG_LSB    = Value;

+  fscanf(DataFile, "SDRC_SHARING_LSB=0x%04x\n", &Value);

+  CHRAMData->SDRC_SHARING_LSB   = Value;

+  fscanf(DataFile, "SDRC_ERR_TYPE_LSB=0x%04x\n", &Value);

+  CHRAMData->SDRC_ERR_TYPE_LSB  = Value;

+  fscanf(DataFile, "SDRC_DLLA_CTRL=0x%08x\n", &Value);

+  CHRAMData->SDRC_DLLA_CTRL     = Value;

+  fscanf(DataFile, "SDRC_POWER=0x%08x\n", &Value);

+  CHRAMData->SDRC_POWER         = Value;

+  fscanf(DataFile, "MEMORY_TYPE_CS0=0x%04x\n", &Value);

+  CHRAMData->MEMORY_TYPE_CS0    = Value;

+  fscanf(DataFile, "SDRC_MCFG_0=0x%08x\n", &Value);

+  CHRAMData->SDRC_MCFG_0        = Value;

+  fscanf(DataFile, "SDRC_MR_0_LSB=0x%04x\n", &Value);

+  CHRAMData->SDRC_MR_0_LSB      = Value;

+  fscanf(DataFile, "SDRC_EMR1_0_LSB=0x%04x\n", &Value);

+  CHRAMData->SDRC_EMR1_0_LSB    = Value;

+  fscanf(DataFile, "SDRC_EMR2_0_LSB=0x%04x\n", &Value);

+  CHRAMData->SDRC_EMR2_0_LSB    = Value;

+  fscanf(DataFile, "SDRC_EMR3_0_LSB=0x%04x\n", &Value);

+  CHRAMData->SDRC_EMR3_0_LSB    = Value;

+  fscanf(DataFile, "SDRC_ACTIM_CTRLA_0=0x%08x\n", &Value);

+  CHRAMData->SDRC_ACTIM_CTRLA_0 = Value;

+  fscanf(DataFile, "SDRC_ACTIM_CTRLB_0=0x%08x\n", &Value);

+  CHRAMData->SDRC_ACTIM_CTRLB_0 = Value;

+  fscanf(DataFile, "SDRC_RFRCTRL_0=0x%08x\n", &Value);

+  CHRAMData->SDRC_RFRCTRL_0     = Value;

+  fscanf(DataFile, "MEMORY_TYPE_CS1=0x%04x\n", &Value);

+  CHRAMData->MEMORY_TYPE_CS1    = Value;

+  fscanf(DataFile, "SDRC_MCFG_1=0x%08x\n", &Value);

+  CHRAMData->SDRC_MCFG_1        = Value;

+  fscanf(DataFile, "SDRC_MR_1_LSB=0x%04x\n", &Value);

+  CHRAMData->SDRC_MR_1_LSB      = Value;

+  fscanf(DataFile, "SDRC_EMR1_1_LSB=0x%04x\n", &Value);

+  CHRAMData->SDRC_EMR1_1_LSB    = Value;

+  fscanf(DataFile, "SDRC_EMR2_1_LSB=0x%04x\n", &Value);

+  CHRAMData->SDRC_EMR2_1_LSB    = Value;

+  fscanf(DataFile, "SDRC_EMR3_1_LSB=0x%04x\n", &Value);

+  CHRAMData->SDRC_EMR3_1_LSB    = Value;

+  fscanf(DataFile, "SDRC_ACTIM_CTRLA_1=0x%08x\n", &Value);

+  CHRAMData->SDRC_ACTIM_CTRLA_1 = Value;

+  fscanf(DataFile, "SDRC_ACTIM_CTRLB_1=0x%08x\n", &Value);

+  CHRAMData->SDRC_ACTIM_CTRLB_1 = Value;

+  fscanf(DataFile, "SDRC_RFRCTRL_1=0x%08x\n", &Value);

+  CHRAMData->SDRC_RFRCTRL_1     = Value;

+

+  CHRAMData->Flags              = 0x0003;

+}

+

+static 

+void 

+PrepareConfigurationHeader (

+  void

+  )

+{

+  TOC_DATA        Toc;

+  CHSETTINGS_DATA CHSETTINGSData;

+  CHRAM_DATA      CHRAMData;

+  unsigned int    ConfigurationHdrOffset = 0;

+  FILE            *DataFile;

+  

+  // Open data file

+  DataFile = fopen(gDataFile, "rb");

+  if (DataFile == NULL) {

+    fprintf(stderr, "Can't open data file %s.\n", gDataFile);

+    exit(1);

+  }

+  

+  //Initialize configuration header.

+  memset(gConfigurationHeader, 0x00, sizeof(gConfigurationHeader));

+

+  //CHSETTINGS TOC

+  memset(&Toc, 0x00, sizeof(TOC_DATA));

+  Toc.Start = CHSETTINGS_START;

+  Toc.Size = CHSETTINGS_SIZE;

+  strcpy((char *)Toc.Filename, (const char *)"CHSETTINGS");

+  memcpy(gConfigurationHeader + ConfigurationHdrOffset, &Toc, sizeof(TOC_DATA));

+

+  //Populate CHSETTINGS Data

+  memset(&CHSETTINGSData, 0x00, sizeof(CHSETTINGS_DATA));

+  PopulateCHSETTINGSData(DataFile, &CHSETTINGSData);

+  memcpy(gConfigurationHeader + Toc.Start, &CHSETTINGSData, Toc.Size);

+

+  //Adjust ConfigurationHdrOffset to point to next TOC

+  ConfigurationHdrOffset += sizeof(TOC_DATA);

+

+  //CHRAM TOC

+  memset(&Toc, 0x00, sizeof(TOC_DATA));

+  Toc.Start = CHRAM_START;

+  Toc.Size = CHRAM_SIZE;

+  strcpy((char *)Toc.Filename, (const char *)"CHRAM");

+  memcpy(gConfigurationHeader + ConfigurationHdrOffset, &Toc, sizeof(TOC_DATA));

+

+  //Populate CHRAM Data

+  memset(&CHRAMData, 0x00, sizeof(CHRAM_DATA));

+  PopulateCHRAMData(DataFile, &CHRAMData);

+  memcpy(gConfigurationHeader + Toc.Start, &CHRAMData, Toc.Size);

+  

+  //Adjust ConfigurationHdrOffset to point to next TOC

+  ConfigurationHdrOffset += sizeof(TOC_DATA);

+

+  //Closing TOC item

+  memset(gConfigurationHeader + ConfigurationHdrOffset, 0xFF, CLOSING_TOC_ITEM_SIZE);

+  ConfigurationHdrOffset += CLOSING_TOC_ITEM_SIZE;

+  

+  // Close data file

+  fclose(DataFile);

+}

+

+static 

+void

+ConstructImage (

+  void

+  )

+{

+  FILE         *InputFile;

+  FILE         *OutputFile;

+  unsigned int InputImageFileSize;

+  struct       stat FileStat;

+  char         Ch;

+  unsigned int i;

+

+  InputFile = fopen(gInputImageFile, "rb");

+  if (InputFile == NULL) {

+    fprintf(stderr, "Can't open input file.\n");

+    exit(0);

+  } 

+

+  // Get the size of the input image.

+  fstat(fileno(InputFile), &FileStat);

+  InputImageFileSize = FileStat.st_size;

+  

+  OutputFile = fopen(gOutputImageFile, "wb");

+  if (OutputFile == NULL) {

+    fprintf(stderr, "Can't open output file %s.\n", gOutputImageFile);

+    exit(0);

+  }

+

+  // Write Configuration header 

+  fwrite(gConfigurationHeader, 1, sizeof(gConfigurationHeader), OutputFile);

+

+  // Write image header (Input image size, execution address)

+  fwrite(&InputImageFileSize, 1, 4, OutputFile);

+  fwrite(&gImageExecutionAddress, 1, 4, OutputFile);

+

+  // Copy input image to the output file.

+  for (i = 0; i < InputImageFileSize; i++) {

+    fread(&Ch, 1, 1, InputFile);

+    fwrite(&Ch, 1, 1, OutputFile);

+  }

+

+  fclose(InputFile);

+  fclose(OutputFile);

+}

+

+

+int 

+main (

+  int    argc, 

+  char** argv

+  )

+{

+  char          Ch;

+  unsigned char *ptr;

+  int           i;

+  int           TwoArg;  

+

+  if (argc == 1) {

+    PrintUsage ();

+    exit(1);

+  }

+

+  for (i=1; i < argc; i++) {

+    if (argv[i][0] == '-') {

+      // TwoArg TRUE -E 0x123, FALSE -E0x1234

+      TwoArg = (argv[i][2] != ' ');

+      switch (argv[i][1]) {

+        case 'E': /* Image execution address */

+          gImageExecutionAddress = strtoul (TwoArg ? argv[i+1] : &argv[i][2], (char **)&ptr, 16);

+          break;

+        

+        case 'I': /* Input image file */

+          gInputImageFile = TwoArg ? argv[i+1] : &argv[i][2];

+          break;

+

+        case 'O': /* Output image file */

+          gOutputImageFile = TwoArg ? argv[i+1] : &argv[i][2];

+          break;

+        

+        case 'D': /* Data file */

+          gDataFile = TwoArg ? argv[i+1] : &argv[i][2];

+          break;

+

+        default:

+          abort ();

+      }

+    }

+  }

+

+ 

+  //Prepare configuration header

+  PrepareConfigurationHeader ();

+

+  //Build image with configuration header + image header + image

+  ConstructImage ();

+

+  return 0;

+}

diff --git a/EdkShellBinPkg/Bin/Ia32/Apps/Devices.efi b/EdkShellBinPkg/Bin/Ia32/Apps/Devices.efi
index 9af9ca54..312cebde 100644
--- a/EdkShellBinPkg/Bin/Ia32/Apps/Devices.efi
+++ b/EdkShellBinPkg/Bin/Ia32/Apps/Devices.efi
diff --git a/EdkShellBinPkg/Bin/Ia32/Apps/Devtree.efi b/EdkShellBinPkg/Bin/Ia32/Apps/Devtree.efi
index d01ab962..577d2d6c 100644
--- a/EdkShellBinPkg/Bin/Ia32/Apps/Devtree.efi
+++ b/EdkShellBinPkg/Bin/Ia32/Apps/Devtree.efi
diff --git a/EdkShellBinPkg/Bin/Ia32/Apps/LoadPciRom.efi b/EdkShellBinPkg/Bin/Ia32/Apps/LoadPciRom.efi
index 14209d18..ede448e4 100644
--- a/EdkShellBinPkg/Bin/Ia32/Apps/LoadPciRom.efi
+++ b/EdkShellBinPkg/Bin/Ia32/Apps/LoadPciRom.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/Dblk.efi b/EdkShellBinPkg/Bin/Ipf/Apps/Dblk.efi
index 13067154..59ccd648 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/Dblk.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/Dblk.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/Devices.efi b/EdkShellBinPkg/Bin/Ipf/Apps/Devices.efi
index 0c2e397e..c1691a38 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/Devices.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/Devices.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/Devtree.efi b/EdkShellBinPkg/Bin/Ipf/Apps/Devtree.efi
index 7daf57c8..6a93793a 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/Devtree.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/Devtree.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/Guid.efi b/EdkShellBinPkg/Bin/Ipf/Apps/Guid.efi
index 67113d9c..d04b7d61 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/Guid.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/Guid.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/IfConfig.efi b/EdkShellBinPkg/Bin/Ipf/Apps/IfConfig.efi
index f5620ea9..c30d1890 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/IfConfig.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/IfConfig.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/IpConfig.efi b/EdkShellBinPkg/Bin/Ipf/Apps/IpConfig.efi
index 99f6607f..95bfd72b 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/IpConfig.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/IpConfig.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/LoadPciRom.efi b/EdkShellBinPkg/Bin/Ipf/Apps/LoadPciRom.efi
index 3e738256..dc4f652a 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/LoadPciRom.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/LoadPciRom.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/Mount.efi b/EdkShellBinPkg/Bin/Ipf/Apps/Mount.efi
index 697ba690..e86fe15e 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/Mount.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/Mount.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/Openinfo.efi b/EdkShellBinPkg/Bin/Ipf/Apps/Openinfo.efi
index 1a5e68a5..8f7e1c19 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/Openinfo.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/Openinfo.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/Ping.efi b/EdkShellBinPkg/Bin/Ipf/Apps/Ping.efi
index 7ae0c217..9dc09c39 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/Ping.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/Ping.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/SmbiosView.efi b/EdkShellBinPkg/Bin/Ipf/Apps/SmbiosView.efi
index 1568bec7..85795dd6 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/SmbiosView.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/SmbiosView.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/TelnetMgmt.efi b/EdkShellBinPkg/Bin/Ipf/Apps/TelnetMgmt.efi
index 618c6681..3f1ac5d5 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/TelnetMgmt.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/TelnetMgmt.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/comp.efi b/EdkShellBinPkg/Bin/Ipf/Apps/comp.efi
index 4b76559f..5bc0775e 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/comp.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/comp.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/dmem.efi b/EdkShellBinPkg/Bin/Ipf/Apps/dmem.efi
index 3f93e7d3..45176045 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/dmem.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/dmem.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/dmpstore.efi b/EdkShellBinPkg/Bin/Ipf/Apps/dmpstore.efi
index 30a23430..ea657c89 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/dmpstore.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/dmpstore.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/edit.efi b/EdkShellBinPkg/Bin/Ipf/Apps/edit.efi
index 9f836a55..48af2a20 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/edit.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/edit.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/eficompress.efi b/EdkShellBinPkg/Bin/Ipf/Apps/eficompress.efi
index 87ffe3b1..b4845aa1 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/eficompress.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/eficompress.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/efidecompress.efi b/EdkShellBinPkg/Bin/Ipf/Apps/efidecompress.efi
index d0866911..66587b49 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/efidecompress.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/efidecompress.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/err.efi b/EdkShellBinPkg/Bin/Ipf/Apps/err.efi
index 18bdcf54..15b85241 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/err.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/err.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/hexedit.efi b/EdkShellBinPkg/Bin/Ipf/Apps/hexedit.efi
index e52aa025..f3b270a9 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/hexedit.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/hexedit.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/mem.efi b/EdkShellBinPkg/Bin/Ipf/Apps/mem.efi
index 8c50cbb8..347cd380 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/mem.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/mem.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/memmap.efi b/EdkShellBinPkg/Bin/Ipf/Apps/memmap.efi
index 0c0242b9..268e5485 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/memmap.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/memmap.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/mm.efi b/EdkShellBinPkg/Bin/Ipf/Apps/mm.efi
index 8342350b..f5a504b9 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/mm.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/mm.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/mode.efi b/EdkShellBinPkg/Bin/Ipf/Apps/mode.efi
index 21743d7e..c8b083f6 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/mode.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/mode.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/pci.efi b/EdkShellBinPkg/Bin/Ipf/Apps/pci.efi
index 27191b9d..78661de6 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/pci.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/pci.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/sermode.efi b/EdkShellBinPkg/Bin/Ipf/Apps/sermode.efi
index abf374ad..04034ce0 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/sermode.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/sermode.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/stall.efi b/EdkShellBinPkg/Bin/Ipf/Apps/stall.efi
index 935814fc..693d67fa 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/stall.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/stall.efi
diff --git a/EdkShellBinPkg/Bin/Ipf/Apps/timezone.efi b/EdkShellBinPkg/Bin/Ipf/Apps/timezone.efi
index 5af35cbb..7dc4cd8a 100644
--- a/EdkShellBinPkg/Bin/Ipf/Apps/timezone.efi
+++ b/EdkShellBinPkg/Bin/Ipf/Apps/timezone.efi
diff --git a/EdkShellBinPkg/Bin/X64/Apps/Devices.efi b/EdkShellBinPkg/Bin/X64/Apps/Devices.efi
index 317f2fa5..7e8650d7 100644
--- a/EdkShellBinPkg/Bin/X64/Apps/Devices.efi
+++ b/EdkShellBinPkg/Bin/X64/Apps/Devices.efi
diff --git a/EdkShellBinPkg/Bin/X64/Apps/Devtree.efi b/EdkShellBinPkg/Bin/X64/Apps/Devtree.efi
index 34a13744..d477c8e1 100644
--- a/EdkShellBinPkg/Bin/X64/Apps/Devtree.efi
+++ b/EdkShellBinPkg/Bin/X64/Apps/Devtree.efi
diff --git a/EdkShellBinPkg/Bin/X64/Apps/LoadPciRom.efi b/EdkShellBinPkg/Bin/X64/Apps/LoadPciRom.efi
index f6d26363..778417fe 100644
--- a/EdkShellBinPkg/Bin/X64/Apps/LoadPciRom.efi
+++ b/EdkShellBinPkg/Bin/X64/Apps/LoadPciRom.efi
diff --git a/EdkShellBinPkg/ReadMe.txt b/EdkShellBinPkg/ReadMe.txt
index fd18e181..3ff50678 100644
--- a/EdkShellBinPkg/ReadMe.txt
+++ b/EdkShellBinPkg/ReadMe.txt
@@ -1,9 +1,9 @@
-The Ia32/Ipf/X64 binaries of EdkShellBinPkg are generated with EFI shell project (svn r59) and build with Edk Compatibility & BaseTools Package (r12898). The binaries are built with no debug information by building with "RELEASE" target.

+The Ia32/Ipf/X64 binaries of EdkShellBinPkg are generated with EFI shell project (svn r62) and build with Edk Compatibility & BaseTools Package (r12898). The binaries are built with no debug information by building with "RELEASE" target.

 

 The following steps can help to re-generate these binaries for customization:

 1. Check out EdkCompatibilityPkg (r12898) to $(WORKSPACE)\EdkCompatibilityPkg (svn https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2/EdkCompatibilityPkg).

 2. Check out EdkShellPkg (r12898) to $(WORKSPACE)\EdkShellPkg (svn https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2/EdkShellPkg).

-3. Check out Edk Shell project source (r59) to $(WORKSPACE)\Shell (svn https://efi-shell.svn.sourceforge.net/svnroot/efi-shell/trunk/Shell). 

+3. Check out Edk Shell project source (r62) to $(WORKSPACE)\Shell (svn https://efi-shell.svn.sourceforge.net/svnroot/efi-shell/trunk/Shell). 

 4. Check out BaseTools (r12898) to $(WORKSPACE)\BaseTools (svn https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2/BaseTools).

 5. Under $(WORKSPACE) directory (i.e. c:\EdkII),

    To generate Minimum Shell, execute: "build -a IA32 -a X64 -a IPF -p EdkShellPkg\EdkShellPkg.dsc -m Shell\Shell.inf -b RELEASE".

diff --git a/EmbeddedPkg/Ebl/Ebl.h b/EmbeddedPkg/Ebl/Ebl.h
index 03b4ba29..44c44fb0 100644
--- a/EmbeddedPkg/Ebl/Ebl.h
+++ b/EmbeddedPkg/Ebl/Ebl.h
@@ -1,207 +1,207 @@
-/** @file
-  Include file for basic command line parser for EBL (Embedded Boot Loader)
-
-  Copyright (c) 2007, Intel Corporation. All rights reserved.<BR>
-  Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __EBL_H__
-#define __EBL_H__
-
-#include <PiDxe.h>
-#include <Protocol/BlockIo.h>             
-#include <Protocol/SimpleFileSystem.h>      
-#include <Protocol/FirmwareVolume2.h>        
-#include <Protocol/LoadFile.h>              
-#include <Protocol/FirmwareVolumeBlock.h> 
-#include <Protocol/PxeBaseCode.h> 
-#include <Protocol/LoadedImage.h> 
-#include <Protocol/EblAddCommand.h>
-#include <Protocol/PciIo.h>
-#include <Protocol/DevicePath.h>
-
-#include <Guid/FileInfo.h>
-#include <Guid/DxeServices.h>
-#include <Guid/MemoryTypeInformation.h>
-#include <Guid/MemoryAllocationHob.h>
-#include <Library/BaseLib.h>
-#include <Library/MemoryAllocationLib.h>
-#include <Library/DevicePathLib.h>
-#include <Library/PrintLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/UefiLib.h>   
-#include <Library/UefiBootServicesTableLib.h>
-#include <Library/UefiRuntimeServicesTableLib.h>
-#include <Library/DebugLib.h>
-#include <Library/EfiFileLib.h>
-#include <Library/HobLib.h>
-#include <Library/DebugLib.h>
-#include <Library/IoLib.h>
-#include <Library/PcdLib.h>
-#include <Library/EblCmdLib.h>
-#include <Library/DevicePathLib.h>
-#include <Library/UefiLib.h>
-#include <Library/EblNetworkLib.h>
-#include <Library/TimerLib.h>
-
-#include <IndustryStandard/Pci.h>
-
-//
-// Prompt for the command line
-//
-#define CMD_SEPARATOR             ';'
-#define EBL_MAX_COMMAND_COUNT     0x100
-#define MAX_CMD_HISTORY           16
-#define MAX_CMD_LINE              256
-#define MAX_ARGS                  32
-
-#define EBL_CR                    0x0a
-#define EBL_LF                    0x0d
-
-#define EFI_SET_TIMER_TO_SECOND   10000000
-
-
-
-EBL_COMMAND_TABLE *
-EblGetCommand (
-  IN CHAR8                        *CommandName
-  );
-
-
-EFI_STATUS
-EblPathToDevice (
-  IN  CHAR8                       *Path,
-  OUT EFI_HANDLE                  *DeviceHandle,
-  OUT EFI_DEVICE_PATH_PROTOCOL    **PathDevicePath,
-  OUT VOID                        **Buffer,
-  OUT UINTN                       *BufferSize
-  );
-
-BOOLEAN
-EblAnyKeyToContinueQtoQuit (
-  IN  UINTN                       *CurrentRow,
-  IN  BOOLEAN                     PrefixNewline
-  );
-
-VOID
-EblUpdateDeviceLists (
-  VOID
-  );
-
-VOID
-EblInitializeCmdTable (
-  VOID
-  );
-
-VOID
-EblShutdownExternalCmdTable (
-  VOID
-  );
-
-VOID
-EblSetTextColor (
-  UINTN                           Attribute
-  );
-
-
-EFI_STATUS
-EblGetCharKey (
-  IN OUT EFI_INPUT_KEY            *Key,
-  IN     UINTN                    TimoutInSec,
-  IN     EBL_GET_CHAR_CALL_BACK   CallBack   OPTIONAL
-  );
-
-// BugBug: Move me to a library
-INTN
-EFIAPI
-AsciiStrniCmp (
-  IN      CONST CHAR8             *FirstString,
-  IN      CONST CHAR8             *SecondString,
-  IN      UINTN                   Length
-  );
-
-
-VOID
-EblInitializeDeviceCmd (
-  VOID
-  );
-
-VOID
-EblInitializemdHwDebugCmds (
-  VOID
-  );
-
-VOID
-EblInitializeDirCmd (
-  VOID
-  );
-
-VOID
-EblInitializeHobCmd (
-  VOID
-  );
-
-VOID
-EblInitializemdHwIoDebugCmds (
-  VOID
-  );
-
-VOID
-EblInitializeScriptCmd (
-  VOID
-  );
-
-VOID
-EblInitializeNetworkCmd (
-  VOID
-  );
-
-VOID
-EblInitializeVariableCmds (
-  VOID
-  );
-
-CHAR8 *
-ParseArguments (
-  IN  CHAR8                       *CmdLine,
-  OUT UINTN                       *Argc,
-  OUT CHAR8                       **Argv
-  );
-
-EFI_STATUS
-ProcessCmdLine (
-  IN CHAR8                        *CmdLine,
-  IN UINTN                        MaxCmdLineSize
-  );
-
-EFI_STATUS
-OutputData (
-  IN UINT8                        *Address,
-  IN UINTN                        Length,
-  IN UINTN                         Width,
-  IN UINTN                        Offset
-  );
-  
-UINTN
-WidthFromCommandName (
-  IN CHAR8                        *Argv,
-  IN UINTN                        Default
-  );
-
-
-extern UINTN                      gScreenColumns;
-extern UINTN                      gScreenRows;
-extern BOOLEAN                    gPageBreak;
-extern CHAR8                      *gMemMapType[];
-
-#endif
-
+/** @file

+  Include file for basic command line parser for EBL (Embedded Boot Loader)

+

+  Copyright (c) 2007, Intel Corporation. All rights reserved.<BR>

+  Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __EBL_H__

+#define __EBL_H__

+

+#include <PiDxe.h>

+#include <Protocol/BlockIo.h>             

+#include <Protocol/SimpleFileSystem.h>      

+#include <Protocol/FirmwareVolume2.h>        

+#include <Protocol/LoadFile.h>              

+#include <Protocol/FirmwareVolumeBlock.h> 

+#include <Protocol/PxeBaseCode.h> 

+#include <Protocol/LoadedImage.h> 

+#include <Protocol/EblAddCommand.h>

+#include <Protocol/PciIo.h>

+#include <Protocol/DevicePath.h>

+

+#include <Guid/FileInfo.h>

+#include <Guid/DxeServices.h>

+#include <Guid/MemoryTypeInformation.h>

+#include <Guid/MemoryAllocationHob.h>

+#include <Library/BaseLib.h>

+#include <Library/MemoryAllocationLib.h>

+#include <Library/DevicePathLib.h>

+#include <Library/PrintLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/UefiLib.h>   

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/UefiRuntimeServicesTableLib.h>

+#include <Library/DebugLib.h>

+#include <Library/EfiFileLib.h>

+#include <Library/HobLib.h>

+#include <Library/DebugLib.h>

+#include <Library/IoLib.h>

+#include <Library/PcdLib.h>

+#include <Library/EblCmdLib.h>

+#include <Library/DevicePathLib.h>

+#include <Library/UefiLib.h>

+#include <Library/EblNetworkLib.h>

+#include <Library/TimerLib.h>

+

+#include <IndustryStandard/Pci.h>

+

+//

+// Prompt for the command line

+//

+#define CMD_SEPARATOR             ';'

+#define EBL_MAX_COMMAND_COUNT     0x100

+#define MAX_CMD_HISTORY           16

+#define MAX_CMD_LINE              256

+#define MAX_ARGS                  32

+

+#define EBL_CR                    0x0a

+#define EBL_LF                    0x0d

+

+#define EFI_SET_TIMER_TO_SECOND   10000000

+

+

+

+EBL_COMMAND_TABLE *

+EblGetCommand (

+  IN CHAR8                        *CommandName

+  );

+

+

+EFI_STATUS

+EblPathToDevice (

+  IN  CHAR8                       *Path,

+  OUT EFI_HANDLE                  *DeviceHandle,

+  OUT EFI_DEVICE_PATH_PROTOCOL    **PathDevicePath,

+  OUT VOID                        **Buffer,

+  OUT UINTN                       *BufferSize

+  );

+

+BOOLEAN

+EblAnyKeyToContinueQtoQuit (

+  IN  UINTN                       *CurrentRow,

+  IN  BOOLEAN                     PrefixNewline

+  );

+

+VOID

+EblUpdateDeviceLists (

+  VOID

+  );

+

+VOID

+EblInitializeCmdTable (

+  VOID

+  );

+

+VOID

+EblShutdownExternalCmdTable (

+  VOID

+  );

+

+VOID

+EblSetTextColor (

+  UINTN                           Attribute

+  );

+

+

+EFI_STATUS

+EblGetCharKey (

+  IN OUT EFI_INPUT_KEY            *Key,

+  IN     UINTN                    TimoutInSec,

+  IN     EBL_GET_CHAR_CALL_BACK   CallBack   OPTIONAL

+  );

+

+// BugBug: Move me to a library

+INTN

+EFIAPI

+AsciiStrniCmp (

+  IN      CONST CHAR8             *FirstString,

+  IN      CONST CHAR8             *SecondString,

+  IN      UINTN                   Length

+  );

+

+

+VOID

+EblInitializeDeviceCmd (

+  VOID

+  );

+

+VOID

+EblInitializemdHwDebugCmds (

+  VOID

+  );

+

+VOID

+EblInitializeDirCmd (

+  VOID

+  );

+

+VOID

+EblInitializeHobCmd (

+  VOID

+  );

+

+VOID

+EblInitializemdHwIoDebugCmds (

+  VOID

+  );

+

+VOID

+EblInitializeScriptCmd (

+  VOID

+  );

+

+VOID

+EblInitializeNetworkCmd (

+  VOID

+  );

+

+VOID

+EblInitializeVariableCmds (

+  VOID

+  );

+

+CHAR8 *

+ParseArguments (

+  IN  CHAR8                       *CmdLine,

+  OUT UINTN                       *Argc,

+  OUT CHAR8                       **Argv

+  );

+

+EFI_STATUS

+ProcessCmdLine (

+  IN CHAR8                        *CmdLine,

+  IN UINTN                        MaxCmdLineSize

+  );

+

+EFI_STATUS

+OutputData (

+  IN UINT8                        *Address,

+  IN UINTN                        Length,

+  IN UINTN                         Width,

+  IN UINTN                        Offset

+  );

+  

+UINTN

+WidthFromCommandName (

+  IN CHAR8                        *Argv,

+  IN UINTN                        Default

+  );

+

+

+extern UINTN                      gScreenColumns;

+extern UINTN                      gScreenRows;

+extern BOOLEAN                    gPageBreak;

+extern CHAR8                      *gMemMapType[];

+

+#endif

+

diff --git a/EmbeddedPkg/EmbeddedPkg.dsc b/EmbeddedPkg/EmbeddedPkg.dsc
index 8862f3d1..64b220c3 100644
--- a/EmbeddedPkg/EmbeddedPkg.dsc
+++ b/EmbeddedPkg/EmbeddedPkg.dsc
@@ -1,262 +1,264 @@
-#/** @file
-# Embedded Package
-#
-#
-# Copyright (c) 2007, Intel Corporation. All rights reserved.<BR>
-#
-#    This program and the accompanying materials
-#    are licensed and made available under the terms and conditions of the BSD License
-#    which accompanies this distribution. The full text of the license may be found at
-#    http://opensource.org/licenses/bsd-license.php
-#
-#    THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#**/
-
-################################################################################
-#
-# Defines Section - statements that will be processed to create a Makefile.
-#
-################################################################################
-[Defines]
-  PLATFORM_NAME                  = Embedded
-  PLATFORM_GUID                  = 8DBB580B-CF89-4D57-95C6-DFE96C44686E
-  PLATFORM_VERSION               = 0.1
-  DSC_SPECIFICATION              = 0x00010005
-  OUTPUT_DIRECTORY               = Build/Embedded
-  SUPPORTED_ARCHITECTURES        = IA32|X64|IPF|ARM
-  BUILD_TARGETS                  = DEBUG|RELEASE
-  SKUID_IDENTIFIER               = DEFAULT
-  FLASH_DEFINITION               = EmbeddedPkg/EmbeddedPkg.fdf
-
-
-################################################################################
-#
-# SKU Identification section - list of all SKU IDs supported by this
-#                              Platform.
-#
-################################################################################
-[SkuIds]
-  0|DEFAULT              # The entry: 0|DEFAULT is reserved and always required.
-
-################################################################################
-#
-# Library Class section - list of all Library Classes needed by this Platform.
-#
-################################################################################
-[LibraryClasses.common]
-#  DebugLib|MdePkg/Library/UefiDebugLibConOut/UefiDebugLibConOut.inf
-  DebugLib|MdePkg/Library/BaseDebugLibNull/BaseDebugLibNull.inf
-
-  
-  BaseLib|MdePkg/Library/BaseLib/BaseLib.inf
-  BaseMemoryLib|MdePkg/Library/BaseMemoryLib/BaseMemoryLib.inf
-  PciLib|MdePkg/Library/BasePciLibCf8/BasePciLibCf8.inf
-  PerformanceLib|MdePkg/Library/BasePerformanceLibNull/BasePerformanceLibNull.inf
-  PrintLib|MdePkg/Library/BasePrintLib/BasePrintLib.inf
-  UefiDecompressLib|MdePkg/Library/BaseUefiDecompressLib/BaseUefiDecompressLib.inf
-  EfiFileLib|EmbeddedPkg/Library/EfiFileLib/EfiFileLib.inf
-  
-  TimerLib|MdePkg/Library/BaseTimerLibNullTemplate/BaseTimerLibNullTemplate.inf
-  
-  ReportStatusCodeLib|IntelFrameworkModulePkg/Library/PeiDxeDebugLibReportStatusCode/PeiDxeDebugLibReportStatusCode.inf
-  
-  PeCoffGetEntryPointLib|MdePkg/Library/BasePeCoffGetEntryPointLib/BasePeCoffGetEntryPointLib.inf
-  PeCoffLib|MdePkg/Library/BasePeCoffLib/BasePeCoffLib.inf
-  PeCoffExtraActionLib|MdePkg/Library/BasePeCoffExtraActionLibNull/BasePeCoffExtraActionLibNull.inf
-  CacheMaintenanceLib|MdePkg/Library/BaseCacheMaintenanceLib/BaseCacheMaintenanceLib.inf
-  PrePiLib|EmbeddedPkg/Library/PrePiLib/PrePiLib.inf
-  
-  SerialPortLib|EmbeddedPkg/Library/TemplateSerialPortLib/TemplateSerialPortLib.inf
-  RealTimeClockLib|EmbeddedPkg/Library/TemplateRealTimeClockLib/TemplateRealTimeClockLib.inf
-  EfiResetSystemLib|EmbeddedPkg/Library/TemplateResetSystemLib/TemplateResetSystemLib.inf
-  GdbSerialLib|EmbeddedPkg/Library/GdbSerialLib/GdbSerialLib.inf
-
-
- #
- # Need to change this for IPF
- #
-  IoLib|MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.inf
-  
-  MemoryAllocationLib|MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf
-  UefiLib|MdePkg/Library/UefiLib/UefiLib.inf
-  HobLib|MdePkg/Library/DxeHobLib/DxeHobLib.inf
-  UefiRuntimeServicesTableLib|MdePkg/Library/UefiRuntimeServicesTableLib/UefiRuntimeServicesTableLib.inf
-  DevicePathLib|MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.inf
-  UefiBootServicesTableLib|MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.inf
-  ExtractGuidedSectionLib|MdePkg/Library/DxeExtractGuidedSectionLib/DxeExtractGuidedSectionLib.inf
-
-  DxeServicesTableLib|MdePkg/Library/DxeServicesTableLib/DxeServicesTableLib.inf
-  UefiDriverEntryPoint|MdePkg/Library/UefiDriverEntryPoint/UefiDriverEntryPoint.inf
-  UefiApplicationEntryPoint|MdePkg/Library/UefiApplicationEntryPoint/UefiApplicationEntryPoint.inf
-
-
-  PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf
-  EblCmdLib|EmbeddedPkg/Library/EblCmdLibNull/EblCmdLibNull.inf
-  
-  EblNetworkLib|EmbeddedPkg/Library/EblNetworkLib/EblNetworkLib.inf
-  
-
-[LibraryClasses.common.DXE_DRIVER]
-  PcdLib|MdePkg/Library/DxePcdLib/DxePcdLib.inf
-  ReportStatusCodeLib|IntelFrameworkModulePkg/Library/DxeReportStatusCodeLibFramework/DxeReportStatusCodeLib.inf
-
-
-[LibraryClasses.common.UEFI_APPLICATION]
-  PcdLib|MdePkg/Library/DxePcdLib/DxePcdLib.inf
-  ReportStatusCodeLib|IntelFrameworkModulePkg/Library/DxeReportStatusCodeLibFramework/DxeReportStatusCodeLib.inf
-
-[LibraryClasses.common.UEFI_DRIVER]
-  PcdLib|MdePkg/Library/DxePcdLib/DxePcdLib.inf
-  ReportStatusCodeLib|IntelFrameworkModulePkg/Library/DxeReportStatusCodeLibFramework/DxeReportStatusCodeLib.inf
-  
-[LibraryClasses.common.SEC]
-  ExtractGuidedSectionLib|EmbeddedPkg/Library/PrePiExtractGuidedSectionLib/PrePiExtractGuidedSectionLib.inf
-
-[LibraryClasses.ARM]
-  SemihostLib|ArmPkg/Library/SemihostLib/SemihostLib.inf
-
-[LibraryClasses.ARM]
-  NULL|ArmPkg/Library/CompilerIntrinsicsLib/CompilerIntrinsicsLib.inf
-
-
-################################################################################
-#
-# Pcd Section - list of all PCD Entries defined by this Platform
-#
-################################################################################
-
-[PcdsFeatureFlag.common]
-  gEfiMdePkgTokenSpaceGuid.PcdComponentNameDisable|FALSE
-  gEfiMdePkgTokenSpaceGuid.PcdDriverDiagnosticsDisable|FALSE
-  gEfiMdePkgTokenSpaceGuid.PcdComponentName2Disable|FALSE
-  gEfiMdePkgTokenSpaceGuid.PcdDriverDiagnostics2Disable|FALSE
-  
-  #
-  # Control what commands are supported from the UI
-  # Turn these on and off to add features or save size
-  #  
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedMacBoot|TRUE
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedDirCmd|TRUE
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedHobCmd|TRUE
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedHwDebugCmd|TRUE
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedIoEnable|FALSE
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedScriptCmd|FALSE
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedPciDebugCmd|TRUE
-  
-  gEmbeddedTokenSpaceGuid.PcdPrePiProduceMemoryTypeInformationHob|FALSE
-
-
-[PcdsFixedAtBuild.common]
-  gEfiMdePkgTokenSpaceGuid.PcdMaximumUnicodeStringLength|1000000
-  gEfiMdePkgTokenSpaceGuid.PcdMaximumAsciiStringLength|1000000
-  gEfiMdePkgTokenSpaceGuid.PcdMaximumLinkedListLength|1000000
-  gEfiMdePkgTokenSpaceGuid.PcdSpinLockTimeout|10000000
-  gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask|0x0f
-  gEfiMdePkgTokenSpaceGuid.PcdDebugPrintErrorLevel|0x80000000
-  gEfiMdePkgTokenSpaceGuid.PcdReportStatusCodePropertyMask|0x06
-  gEfiMdePkgTokenSpaceGuid.PcdDebugClearMemoryValue|0xAF
-  gEfiMdePkgTokenSpaceGuid.PcdPerformanceLibraryPropertyMask|0
-  gEfiMdePkgTokenSpaceGuid.PcdPostCodePropertyMask|0
-  gEfiMdePkgTokenSpaceGuid.PcdPciExpressBaseAddress|0xE0000000
-  gEfiMdePkgTokenSpaceGuid.PcdFSBClock|200000000
-  gEfiMdePkgTokenSpaceGuid.PcdUefiLibMaxPrintBufferSize|320
-  gEfiMdePkgTokenSpaceGuid.PcdDebugPrintErrorLevel|0x80000000
-  gEfiMdePkgTokenSpaceGuid.PcdPciExpressBaseAddress|0xE0000000
-  gEfiMdePkgTokenSpaceGuid.PcdFSBClock|200000000
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedAutomaticBootCommand|L""|VOID*|2
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedDefaultTextColor|0x07
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedMemVariableStoreSize|0x10000
-  
-  gEmbeddedTokenSpaceGuid.PcdPrePiHobBase|0
-  gEmbeddedTokenSpaceGuid.PcdPrePiStackBase|0
-  gEmbeddedTokenSpaceGuid.PcdPrePiStackSize|0
-
-#
-# Optinal feature to help prevent EFI memory map fragments
-# Turned on and off via: PcdPrePiProduceMemoryTypeInformationHob
-# Values are in EFI Pages (4K). DXE Core will make sure that 
-# at least this much of each type of memory can be allocated 
-# from a single memory range. This way you only end up with
-# maximum of two fragements for each type in the memory map
-# (the memory used, and the free memory that was prereserved
-# but not used).
-#
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiACPIReclaimMemory|0
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiACPIMemoryNVS|0
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiReservedMemoryType|0
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiRuntimeServicesData|0
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiRuntimeServicesCode|0
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiBootServicesCode|0
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiBootServicesData|0
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiLoaderCode|0
-  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiLoaderData|0
-
-#
-# Timer config for this platform
-#
-  gEmbeddedTokenSpaceGuid.PcdTimerBaseAddress|0x3c700000
-  gEmbeddedTokenSpaceGuid.PcdTimerVector|7
-  gEmbeddedTokenSpaceGuid.PcdTimerPeriod|100000
-
-
-[PcdsFixedAtBuild.ARM]
-  gEmbeddedTokenSpaceGuid.PcdPrePiCpuMemorySize|32
-  gEmbeddedTokenSpaceGuid.PcdPrePiCpuIoSize|0
-
-[PcdsFixedAtBuild.IA32]
-  gEmbeddedTokenSpaceGuid.PcdPrePiCpuMemorySize|36
-  gEmbeddedTokenSpaceGuid.PcdPrePiCpuIoSize|16
-
-[PcdsFixedAtBuild.X64]
-  gEmbeddedTokenSpaceGuid.PcdPrePiCpuMemorySize|52
-  gEmbeddedTokenSpaceGuid.PcdPrePiCpuIoSize|16
-
-
-
-[PcdsFixedAtBuild.IPF]
-  gEfiMdePkgTokenSpaceGuid.PcdIoBlockBaseAddressForIpf|0x0ffffc000000
-
-#
-# This makes it so you can source level debug with NT32. VC++ debugger limitiation!
-#
-#[BuildOptions]
-#  DEBUG_*_IA32_DLINK_FLAGS = /EXPORT:InitializeDriver=$(IMAGE_ENTRY_POINT) /ALIGN:4096 /SUBSYSTEM:CONSOLE
-#  RELEASE_*_IA32_DLINK_FLAGS = /ALIGN:4096
-#  *_*_IA32_CC_FLAGS = /D EFI_SPECIFICATION_VERSION=0x0002000A /D TIANO_RELEASE_VERSION=0x00080006
-
-
-################################################################################
-#
-# Components Section - list of all Modules needed by this Platform
-#
-################################################################################
-[Components.common]
-  EmbeddedPkg/Library/EblAddExternalCommandLib/EblAddExternalCommandLib.inf 
-  EmbeddedPkg/Library/EblCmdLibNull/EblCmdLibNull.inf
-  EmbeddedPkg/Library/EfiFileLib/EfiFileLib.inf
-  EmbeddedPkg/Library/GdbSerialDebugPortLib/GdbSerialDebugPortLib.inf  
-  EmbeddedPkg/Library/GdbSerialLib/GdbSerialLib.inf                    
-  EmbeddedPkg/Library/PrePiExtractGuidedSectionLib/PrePiExtractGuidedSectionLib.inf
-  EmbeddedPkg/Library/PrePiLib/PrePiLib.inf
-  EmbeddedPkg/Library/TemplateSerialPortLib/TemplateSerialPortLib.inf
-  EmbeddedPkg/Library/TemplateResetSystemLib/TemplateResetSystemLib.inf
-  EmbeddedPkg/Library/TemplateRealTimeClockLib/TemplateRealTimeClockLib.inf
-  EmbeddedPkg/Library/LzmaHobCustomDecompressLib/LzmaHobCustomDecompressLib.inf
-  EmbeddedPkg/Library/NullDmaLib/NullDmaLib.inf
-
-  EmbeddedPkg/Ebl/Ebl.inf
-####  EmbeddedPkg/EblExternCmd/EblExternCmd.inf
-  EmbeddedPkg/EmbeddedMonotonicCounter/EmbeddedMonotonicCounter.inf
-  EmbeddedPkg/GdbStub/GdbStub.inf
-  EmbeddedPkg/RealTimeClockRuntimeDxe/RealTimeClockRuntimeDxe.inf
-  EmbeddedPkg/ResetRuntimeDxe/ResetRuntimeDxe.inf
-  EmbeddedPkg/SerialDxe/SerialDxe.inf
-  EmbeddedPkg/SimpleTextInOutSerial/SimpleTextInOutSerial.inf
-  EmbeddedPkg/MetronomeDxe/MetronomeDxe.inf
-
-  EmbeddedPkg/Universal/MmcDxe/MmcDxe.inf
-  
-  
-
+#/** @file

+# Embedded Package

+#

+#

+# Copyright (c) 2007, Intel Corporation. All rights reserved.<BR>

+# Copyright (c) 2012, ARM Ltd. All rights reserved.<BR>

+#

+#    This program and the accompanying materials

+#    are licensed and made available under the terms and conditions of the BSD License

+#    which accompanies this distribution. The full text of the license may be found at

+#    http://opensource.org/licenses/bsd-license.php

+#

+#    THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#    WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#**/

+

+################################################################################

+#

+# Defines Section - statements that will be processed to create a Makefile.

+#

+################################################################################

+[Defines]

+  PLATFORM_NAME                  = Embedded

+  PLATFORM_GUID                  = 8DBB580B-CF89-4D57-95C6-DFE96C44686E

+  PLATFORM_VERSION               = 0.1

+  DSC_SPECIFICATION              = 0x00010005

+  OUTPUT_DIRECTORY               = Build/Embedded

+  SUPPORTED_ARCHITECTURES        = IA32|X64|IPF|ARM

+  BUILD_TARGETS                  = DEBUG|RELEASE

+  SKUID_IDENTIFIER               = DEFAULT

+  FLASH_DEFINITION               = EmbeddedPkg/EmbeddedPkg.fdf

+

+

+################################################################################

+#

+# SKU Identification section - list of all SKU IDs supported by this

+#                              Platform.

+#

+################################################################################

+[SkuIds]

+  0|DEFAULT              # The entry: 0|DEFAULT is reserved and always required.

+

+################################################################################

+#

+# Library Class section - list of all Library Classes needed by this Platform.

+#

+################################################################################

+[LibraryClasses.common]

+#  DebugLib|MdePkg/Library/UefiDebugLibConOut/UefiDebugLibConOut.inf

+  DebugLib|MdePkg/Library/BaseDebugLibNull/BaseDebugLibNull.inf

+

+  

+  BaseLib|MdePkg/Library/BaseLib/BaseLib.inf

+  BaseMemoryLib|MdePkg/Library/BaseMemoryLib/BaseMemoryLib.inf

+  PciLib|MdePkg/Library/BasePciLibCf8/BasePciLibCf8.inf

+  PerformanceLib|MdePkg/Library/BasePerformanceLibNull/BasePerformanceLibNull.inf

+  PrintLib|MdePkg/Library/BasePrintLib/BasePrintLib.inf

+  UefiDecompressLib|MdePkg/Library/BaseUefiDecompressLib/BaseUefiDecompressLib.inf

+  EfiFileLib|EmbeddedPkg/Library/EfiFileLib/EfiFileLib.inf

+  

+  TimerLib|MdePkg/Library/BaseTimerLibNullTemplate/BaseTimerLibNullTemplate.inf

+  

+  ReportStatusCodeLib|IntelFrameworkModulePkg/Library/PeiDxeDebugLibReportStatusCode/PeiDxeDebugLibReportStatusCode.inf

+  

+  PeCoffGetEntryPointLib|MdePkg/Library/BasePeCoffGetEntryPointLib/BasePeCoffGetEntryPointLib.inf

+  PeCoffLib|MdePkg/Library/BasePeCoffLib/BasePeCoffLib.inf

+  PeCoffExtraActionLib|MdePkg/Library/BasePeCoffExtraActionLibNull/BasePeCoffExtraActionLibNull.inf

+  CacheMaintenanceLib|MdePkg/Library/BaseCacheMaintenanceLib/BaseCacheMaintenanceLib.inf

+  PrePiLib|EmbeddedPkg/Library/PrePiLib/PrePiLib.inf

+  

+  SerialPortLib|EmbeddedPkg/Library/TemplateSerialPortLib/TemplateSerialPortLib.inf

+  SerialPortExtLib|EmbeddedPkg/Library/TemplateSerialPortExtLib/TemplateSerialPortExtLib.inf

+  RealTimeClockLib|EmbeddedPkg/Library/TemplateRealTimeClockLib/TemplateRealTimeClockLib.inf

+  EfiResetSystemLib|EmbeddedPkg/Library/TemplateResetSystemLib/TemplateResetSystemLib.inf

+  GdbSerialLib|EmbeddedPkg/Library/GdbSerialLib/GdbSerialLib.inf

+

+

+ #

+ # Need to change this for IPF

+ #

+  IoLib|MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.inf

+  

+  MemoryAllocationLib|MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf

+  UefiLib|MdePkg/Library/UefiLib/UefiLib.inf

+  HobLib|MdePkg/Library/DxeHobLib/DxeHobLib.inf

+  UefiRuntimeServicesTableLib|MdePkg/Library/UefiRuntimeServicesTableLib/UefiRuntimeServicesTableLib.inf

+  DevicePathLib|MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.inf

+  UefiBootServicesTableLib|MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.inf

+  ExtractGuidedSectionLib|MdePkg/Library/DxeExtractGuidedSectionLib/DxeExtractGuidedSectionLib.inf

+

+  DxeServicesTableLib|MdePkg/Library/DxeServicesTableLib/DxeServicesTableLib.inf

+  UefiDriverEntryPoint|MdePkg/Library/UefiDriverEntryPoint/UefiDriverEntryPoint.inf

+  UefiApplicationEntryPoint|MdePkg/Library/UefiApplicationEntryPoint/UefiApplicationEntryPoint.inf

+

+

+  PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf

+  EblCmdLib|EmbeddedPkg/Library/EblCmdLibNull/EblCmdLibNull.inf

+  

+  EblNetworkLib|EmbeddedPkg/Library/EblNetworkLib/EblNetworkLib.inf

+  

+

+[LibraryClasses.common.DXE_DRIVER]

+  PcdLib|MdePkg/Library/DxePcdLib/DxePcdLib.inf

+  ReportStatusCodeLib|IntelFrameworkModulePkg/Library/DxeReportStatusCodeLibFramework/DxeReportStatusCodeLib.inf

+

+

+[LibraryClasses.common.UEFI_APPLICATION]

+  PcdLib|MdePkg/Library/DxePcdLib/DxePcdLib.inf

+  ReportStatusCodeLib|IntelFrameworkModulePkg/Library/DxeReportStatusCodeLibFramework/DxeReportStatusCodeLib.inf

+

+[LibraryClasses.common.UEFI_DRIVER]

+  PcdLib|MdePkg/Library/DxePcdLib/DxePcdLib.inf

+  ReportStatusCodeLib|IntelFrameworkModulePkg/Library/DxeReportStatusCodeLibFramework/DxeReportStatusCodeLib.inf

+  

+[LibraryClasses.common.SEC]

+  ExtractGuidedSectionLib|EmbeddedPkg/Library/PrePiExtractGuidedSectionLib/PrePiExtractGuidedSectionLib.inf

+

+[LibraryClasses.ARM]

+  SemihostLib|ArmPkg/Library/SemihostLib/SemihostLib.inf

+

+[LibraryClasses.ARM]

+  NULL|ArmPkg/Library/CompilerIntrinsicsLib/CompilerIntrinsicsLib.inf

+

+

+################################################################################

+#

+# Pcd Section - list of all PCD Entries defined by this Platform

+#

+################################################################################

+

+[PcdsFeatureFlag.common]

+  gEfiMdePkgTokenSpaceGuid.PcdComponentNameDisable|FALSE

+  gEfiMdePkgTokenSpaceGuid.PcdDriverDiagnosticsDisable|FALSE

+  gEfiMdePkgTokenSpaceGuid.PcdComponentName2Disable|FALSE

+  gEfiMdePkgTokenSpaceGuid.PcdDriverDiagnostics2Disable|FALSE

+  

+  #

+  # Control what commands are supported from the UI

+  # Turn these on and off to add features or save size

+  #  

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedMacBoot|TRUE

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedDirCmd|TRUE

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedHobCmd|TRUE

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedHwDebugCmd|TRUE

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedIoEnable|FALSE

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedScriptCmd|FALSE

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedPciDebugCmd|TRUE

+  

+  gEmbeddedTokenSpaceGuid.PcdPrePiProduceMemoryTypeInformationHob|FALSE

+

+

+[PcdsFixedAtBuild.common]

+  gEfiMdePkgTokenSpaceGuid.PcdMaximumUnicodeStringLength|1000000

+  gEfiMdePkgTokenSpaceGuid.PcdMaximumAsciiStringLength|1000000

+  gEfiMdePkgTokenSpaceGuid.PcdMaximumLinkedListLength|1000000

+  gEfiMdePkgTokenSpaceGuid.PcdSpinLockTimeout|10000000

+  gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask|0x0f

+  gEfiMdePkgTokenSpaceGuid.PcdDebugPrintErrorLevel|0x80000000

+  gEfiMdePkgTokenSpaceGuid.PcdReportStatusCodePropertyMask|0x06

+  gEfiMdePkgTokenSpaceGuid.PcdDebugClearMemoryValue|0xAF

+  gEfiMdePkgTokenSpaceGuid.PcdPerformanceLibraryPropertyMask|0

+  gEfiMdePkgTokenSpaceGuid.PcdPostCodePropertyMask|0

+  gEfiMdePkgTokenSpaceGuid.PcdPciExpressBaseAddress|0xE0000000

+  gEfiMdePkgTokenSpaceGuid.PcdFSBClock|200000000

+  gEfiMdePkgTokenSpaceGuid.PcdUefiLibMaxPrintBufferSize|320

+  gEfiMdePkgTokenSpaceGuid.PcdDebugPrintErrorLevel|0x80000000

+  gEfiMdePkgTokenSpaceGuid.PcdPciExpressBaseAddress|0xE0000000

+  gEfiMdePkgTokenSpaceGuid.PcdFSBClock|200000000

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedAutomaticBootCommand|L""|VOID*|2

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedDefaultTextColor|0x07

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedMemVariableStoreSize|0x10000

+  

+  gEmbeddedTokenSpaceGuid.PcdPrePiHobBase|0

+  gEmbeddedTokenSpaceGuid.PcdPrePiStackBase|0

+  gEmbeddedTokenSpaceGuid.PcdPrePiStackSize|0

+

+#

+# Optinal feature to help prevent EFI memory map fragments

+# Turned on and off via: PcdPrePiProduceMemoryTypeInformationHob

+# Values are in EFI Pages (4K). DXE Core will make sure that 

+# at least this much of each type of memory can be allocated 

+# from a single memory range. This way you only end up with

+# maximum of two fragements for each type in the memory map

+# (the memory used, and the free memory that was prereserved

+# but not used).

+#

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiACPIReclaimMemory|0

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiACPIMemoryNVS|0

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiReservedMemoryType|0

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiRuntimeServicesData|0

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiRuntimeServicesCode|0

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiBootServicesCode|0

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiBootServicesData|0

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiLoaderCode|0

+  gEmbeddedTokenSpaceGuid.PcdMemoryTypeEfiLoaderData|0

+

+#

+# Timer config for this platform

+#

+  gEmbeddedTokenSpaceGuid.PcdTimerBaseAddress|0x3c700000

+  gEmbeddedTokenSpaceGuid.PcdTimerVector|7

+  gEmbeddedTokenSpaceGuid.PcdTimerPeriod|100000

+

+

+[PcdsFixedAtBuild.ARM]

+  gEmbeddedTokenSpaceGuid.PcdPrePiCpuMemorySize|32

+  gEmbeddedTokenSpaceGuid.PcdPrePiCpuIoSize|0

+

+[PcdsFixedAtBuild.IA32]

+  gEmbeddedTokenSpaceGuid.PcdPrePiCpuMemorySize|36

+  gEmbeddedTokenSpaceGuid.PcdPrePiCpuIoSize|16

+

+[PcdsFixedAtBuild.X64]

+  gEmbeddedTokenSpaceGuid.PcdPrePiCpuMemorySize|52

+  gEmbeddedTokenSpaceGuid.PcdPrePiCpuIoSize|16

+

+

+

+[PcdsFixedAtBuild.IPF]

+  gEfiMdePkgTokenSpaceGuid.PcdIoBlockBaseAddressForIpf|0x0ffffc000000

+

+#

+# This makes it so you can source level debug with NT32. VC++ debugger limitiation!

+#

+#[BuildOptions]

+#  DEBUG_*_IA32_DLINK_FLAGS = /EXPORT:InitializeDriver=$(IMAGE_ENTRY_POINT) /ALIGN:4096 /SUBSYSTEM:CONSOLE

+#  RELEASE_*_IA32_DLINK_FLAGS = /ALIGN:4096

+#  *_*_IA32_CC_FLAGS = /D EFI_SPECIFICATION_VERSION=0x0002000A /D TIANO_RELEASE_VERSION=0x00080006

+

+

+################################################################################

+#

+# Components Section - list of all Modules needed by this Platform

+#

+################################################################################

+[Components.common]

+  EmbeddedPkg/Library/EblAddExternalCommandLib/EblAddExternalCommandLib.inf 

+  EmbeddedPkg/Library/EblCmdLibNull/EblCmdLibNull.inf

+  EmbeddedPkg/Library/EfiFileLib/EfiFileLib.inf

+  EmbeddedPkg/Library/GdbSerialDebugPortLib/GdbSerialDebugPortLib.inf  

+  EmbeddedPkg/Library/GdbSerialLib/GdbSerialLib.inf                    

+  EmbeddedPkg/Library/PrePiExtractGuidedSectionLib/PrePiExtractGuidedSectionLib.inf

+  EmbeddedPkg/Library/PrePiLib/PrePiLib.inf

+  EmbeddedPkg/Library/TemplateSerialPortLib/TemplateSerialPortLib.inf

+  EmbeddedPkg/Library/TemplateResetSystemLib/TemplateResetSystemLib.inf

+  EmbeddedPkg/Library/TemplateRealTimeClockLib/TemplateRealTimeClockLib.inf

+  EmbeddedPkg/Library/LzmaHobCustomDecompressLib/LzmaHobCustomDecompressLib.inf

+  EmbeddedPkg/Library/NullDmaLib/NullDmaLib.inf

+

+  EmbeddedPkg/Ebl/Ebl.inf

+####  EmbeddedPkg/EblExternCmd/EblExternCmd.inf

+  EmbeddedPkg/EmbeddedMonotonicCounter/EmbeddedMonotonicCounter.inf

+  EmbeddedPkg/GdbStub/GdbStub.inf

+  EmbeddedPkg/RealTimeClockRuntimeDxe/RealTimeClockRuntimeDxe.inf

+  EmbeddedPkg/ResetRuntimeDxe/ResetRuntimeDxe.inf

+  EmbeddedPkg/SerialDxe/SerialDxe.inf

+  EmbeddedPkg/SimpleTextInOutSerial/SimpleTextInOutSerial.inf

+  EmbeddedPkg/MetronomeDxe/MetronomeDxe.inf

+

+  EmbeddedPkg/Universal/MmcDxe/MmcDxe.inf

+  

+  

+

diff --git a/EmbeddedPkg/GdbStub/Arm/Processor.c b/EmbeddedPkg/GdbStub/Arm/Processor.c
index 2d33d972..38abb69d 100644
--- a/EmbeddedPkg/GdbStub/Arm/Processor.c
+++ b/EmbeddedPkg/GdbStub/Arm/Processor.c
@@ -94,7 +94,7 @@ MaxEfiException (
   VOID

   )

 {

-  return sizeof (gExceptionType)/sizeof (EFI_EXCEPTION_TYPE_ENTRY);

+  return sizeof (gExceptionType) / sizeof (EFI_EXCEPTION_TYPE_ENTRY);

 }

 

 

@@ -108,7 +108,7 @@ MaxRegisterCount (
   VOID

   )

 {

-  return sizeof (gRegisterOffsets)/sizeof (UINTN);

+  return sizeof (gRegisterOffsets) / sizeof (UINTN);

 }

 

 

@@ -140,7 +140,7 @@ CheckIsa (
  @retval  the pointer to the RegNumber-th pointer

  **/ 

 UINTN *

-FindPointerToRegister(

+FindPointerToRegister (

   IN  EFI_SYSTEM_CONTEXT      SystemContext,

   IN  UINTN           RegNumber  

   )

@@ -170,20 +170,20 @@ BasicReadRegister (
   CHAR8 Char;

   

   if (gRegisterOffsets[RegNumber] > 0xF00) {

-    AsciiSPrint(OutBufPtr, 9, "00000000");

+    AsciiSPrint (OutBufPtr, 9, "00000000");

     OutBufPtr += 8;

     return OutBufPtr;

   }

 

   RegSize = 0;

   while (RegSize < 32) {

-    Char = mHexToStr[(UINT8)((*FindPointerToRegister(SystemContext, RegNumber) >> (RegSize+4)) & 0xf)];

+    Char = mHexToStr[(UINT8)((*FindPointerToRegister (SystemContext, RegNumber) >> (RegSize+4)) & 0xf)];

     if ((Char >= 'A') && (Char <= 'F')) {

       Char = Char - 'A' + 'a';

     }

     *OutBufPtr++ = Char;

     

-    Char = mHexToStr[(UINT8)((*FindPointerToRegister(SystemContext, RegNumber) >> RegSize) & 0xf)];

+    Char = mHexToStr[(UINT8)((*FindPointerToRegister (SystemContext, RegNumber) >> RegSize) & 0xf)];

     if ((Char >= 'A') && (Char <= 'F')) {

       Char = Char - 'A' + 'a';

     }

@@ -212,7 +212,7 @@ ReadNthRegister (
   

   RegNumber = AsciiStrHexToUintn (&InBuffer[1]);

   

-  if (RegNumber >= MaxRegisterCount()) {

+  if (RegNumber >= MaxRegisterCount ()) {

     SendError (GDB_EINVALIDREGNUM); 

     return;

   }

@@ -221,7 +221,7 @@ ReadNthRegister (
   OutBufPtr = BasicReadRegister (SystemContext, RegNumber, OutBufPtr);

   

   *OutBufPtr = '\0';  // the end of the buffer

-  SendPacket(OutBuffer);

+  SendPacket (OutBuffer);

 }

 

 

@@ -238,18 +238,18 @@ ReadGeneralRegisters (
   UINTN   Index;

   CHAR8   *OutBuffer;

   CHAR8   *OutBufPtr;

-  UINTN   RegisterCount = MaxRegisterCount();

+  UINTN   RegisterCount = MaxRegisterCount ();

   

   // It is not safe to allocate pool here....

-  OutBuffer = AllocatePool((RegisterCount * 8) + 1); // 8 bytes per register in string format plus a null to terminate

+  OutBuffer = AllocatePool ((RegisterCount * 8) + 1); // 8 bytes per register in string format plus a null to terminate

   OutBufPtr = OutBuffer;

   for (Index = 0; Index < RegisterCount; Index++) {

     OutBufPtr = BasicReadRegister (SystemContext, Index, OutBufPtr);

   }

   

   *OutBufPtr = '\0';

-  SendPacket(OutBuffer);

-  FreePool(OutBuffer);

+  SendPacket (OutBuffer);

+  FreePool (OutBuffer);

 }

 

 

@@ -278,7 +278,7 @@ CHAR8
   NewValue = 0;

   RegSize = 0;

   while (RegSize < 32) {

-    TempValue = HexCharToInt(*InBufPtr++);

+    TempValue = HexCharToInt (*InBufPtr++);

     

     if ((INTN)TempValue < 0) {

       SendError (GDB_EBADMEMDATA); 

@@ -286,7 +286,7 @@ CHAR8
     }

     

     NewValue += (TempValue << (RegSize+4));

-    TempValue = HexCharToInt(*InBufPtr++);

+    TempValue = HexCharToInt (*InBufPtr++);

     

     if ((INTN)TempValue < 0) {

       SendError (GDB_EBADMEMDATA); 

@@ -296,7 +296,7 @@ CHAR8
     NewValue += (TempValue << RegSize); 

     RegSize = RegSize + 8;

   }

-  *(FindPointerToRegister(SystemContext, RegNumber)) = NewValue;

+  *(FindPointerToRegister (SystemContext, RegNumber)) = NewValue;

   return InBufPtr;

 }

 

@@ -327,7 +327,7 @@ WriteNthRegister (
   RegNumber = AsciiStrHexToUintn (RegNumBuffer); 

   

   // check if this is a valid Register Number

-  if (RegNumber >= MaxRegisterCount()) {

+  if (RegNumber >= MaxRegisterCount ()) {

     SendError (GDB_EINVALIDREGNUM); 

     return;

   }

@@ -353,11 +353,11 @@ WriteGeneralRegisters (
   UINTN  i;

   CHAR8  *InBufPtr; /// pointer to the input buffer

   UINTN  MinLength;

-  UINTN  RegisterCount = MaxRegisterCount();

+  UINTN  RegisterCount = MaxRegisterCount ();

 

   MinLength = (RegisterCount * 8) + 1;  // 'G' plus the registers in ASCII format

   

-  if (AsciiStrLen(InBuffer) < MinLength) {

+  if (AsciiStrLen (InBuffer) < MinLength) {

     //Bad message. Message is not the right length 

     SendError (GDB_EBADBUFSIZE); 

     return;

@@ -367,7 +367,7 @@ WriteGeneralRegisters (
   

   // Read the new values for the registers from the input buffer to an array, NewValueArray.

   // The values in the array are in the gdb ordering

-  for(i = 0; i < RegisterCount; i++) {

+  for (i = 0; i < RegisterCount; i++) {

     InBufPtr = BasicWriteRegister (SystemContext, i, InBufPtr);

   }

   

@@ -421,7 +421,7 @@ AddSingleStep (
     mSingleStepActive = FALSE;

   }

 

-  InvalidateInstructionCacheRange((VOID *)mSingleStepPC, mSingleStepDataSize);

+  InvalidateInstructionCacheRange ((VOID *)mSingleStepPC, mSingleStepDataSize);

   //DEBUG((EFI_D_ERROR, "AddSingleStep at 0x%08x (was: 0x%08x is:0x%08x)\n", SystemContext.SystemContextArm->PC, mSingleStepData, *(UINT32 *)mSingleStepPC));

 }

 

@@ -446,7 +446,7 @@ RemoveSingleStep (
     //DEBUG((EFI_D_ERROR, "RemoveSingleStep at 0x%08x (was: 0x%08x is:0x%08x)\n", SystemContext.SystemContextArm->PC, *(UINT32 *)mSingleStepPC, mSingleStepData));

     *(UINT32 *)mSingleStepPC = mSingleStepData;

   }

-  InvalidateInstructionCacheRange((VOID *)mSingleStepPC, mSingleStepDataSize);

+  InvalidateInstructionCacheRange ((VOID *)mSingleStepPC, mSingleStepDataSize);

   mSingleStepActive = FALSE;

 }

 

@@ -466,7 +466,7 @@ ContinueAtAddress (
   )

 {

   if (PacketData[1] != '\0') {

-    SystemContext.SystemContextArm->PC = AsciiStrHexToUintn(&PacketData[1]);

+    SystemContext.SystemContextArm->PC = AsciiStrHexToUintn (&PacketData[1]);

   } 

 }

 

@@ -484,7 +484,7 @@ SingleStep (
   IN    CHAR8                       *PacketData

   )

 {

-  SendNotSupported();

+  SendNotSupported ();

 }

 

 UINTN

@@ -521,15 +521,15 @@ SearchBreakpointList (
   LIST_ENTRY              *Current;

   ARM_SOFTWARE_BREAKPOINT *Breakpoint;

 

-  Current = GetFirstNode(&BreakpointList);

-  while (!IsNull(&BreakpointList, Current)) {

+  Current = GetFirstNode (&BreakpointList);

+  while (!IsNull (&BreakpointList, Current)) {

     Breakpoint = ARM_SOFTWARE_BREAKPOINT_FROM_LINK(Current);

 

     if (Address == Breakpoint->Address) {

       return Breakpoint;

     }

 

-    Current = GetNextNode(&BreakpointList, Current);

+    Current = GetNextNode (&BreakpointList, Current);

   }

 

   return NULL;

@@ -542,25 +542,25 @@ SetBreakpoint (
 {

   ARM_SOFTWARE_BREAKPOINT *Breakpoint;

 

-  Breakpoint = SearchBreakpointList(Address);

+  Breakpoint = SearchBreakpointList (Address);

 

   if (Breakpoint != NULL) {

     return;

   }

 

   // create and fill breakpoint structure

-  Breakpoint = AllocatePool(sizeof(ARM_SOFTWARE_BREAKPOINT));

+  Breakpoint = AllocatePool (sizeof(ARM_SOFTWARE_BREAKPOINT));

 

   Breakpoint->Signature   = ARM_SOFTWARE_BREAKPOINT_SIGNATURE;

   Breakpoint->Address     = Address;

   Breakpoint->Instruction = *(UINT32 *)Address;

   

   // Add it to the list

-  InsertTailList(&BreakpointList, &Breakpoint->Link);

+  InsertTailList (&BreakpointList, &Breakpoint->Link);

 

   // Insert the software breakpoint

   *(UINT32 *)Address = GDB_ARM_BKPT;

-  InvalidateInstructionCacheRange((VOID *)Address, 4);

+  InvalidateInstructionCacheRange ((VOID *)Address, 4);

 

   //DEBUG((EFI_D_ERROR, "SetBreakpoint at 0x%08x (was: 0x%08x is:0x%08x)\n", Address, Breakpoint->Instruction, *(UINT32 *)Address));

 }

@@ -572,22 +572,22 @@ ClearBreakpoint (
 {

   ARM_SOFTWARE_BREAKPOINT *Breakpoint;

 

-  Breakpoint = SearchBreakpointList(Address);

+  Breakpoint = SearchBreakpointList (Address);

 

   if (Breakpoint == NULL) {

     return;

   }

 

   // Add it to the list

-  RemoveEntryList(&Breakpoint->Link);

+  RemoveEntryList (&Breakpoint->Link);

 

   // Restore the original instruction

   *(UINT32 *)Address = Breakpoint->Instruction;

-  InvalidateInstructionCacheRange((VOID *)Address, 4);

+  InvalidateInstructionCacheRange ((VOID *)Address, 4);

 

   //DEBUG((EFI_D_ERROR, "ClearBreakpoint at 0x%08x (was: 0x%08x is:0x%08x)\n", Address, GDB_ARM_BKPT, *(UINT32 *)Address));

 

-  FreePool(Breakpoint);

+  FreePool (Breakpoint);

 }

 

 VOID

@@ -602,7 +602,7 @@ InsertBreakPoint (
   UINTN Length;

   UINTN ErrorCode;

 

-  ErrorCode = ParseBreakpointPacket(PacketData, &Type, &Address, &Length);

+  ErrorCode = ParseBreakpointPacket (PacketData, &Type, &Address, &Length);

   if (ErrorCode > 0) {

     SendError ((UINT8)ErrorCode);

     return;

@@ -618,7 +618,7 @@ InsertBreakPoint (
       return;

   }

 

-  SetBreakpoint(Address);

+  SetBreakpoint (Address);

 

   SendSuccess ();

 }

@@ -651,7 +651,7 @@ RemoveBreakPoint (
       return;

   }

 

-  ClearBreakpoint(Address);

+  ClearBreakpoint (Address);

 

   SendSuccess ();

 }

@@ -662,7 +662,7 @@ InitializeProcessor (
   )

 {

   // Initialize breakpoint list

-  InitializeListHead(&BreakpointList);

+  InitializeListHead (&BreakpointList);

 }

 

 BOOLEAN

diff --git a/EmbeddedPkg/GdbStub/GdbStub.c b/EmbeddedPkg/GdbStub/GdbStub.c
index 742de505..9136c14b 100644
--- a/EmbeddedPkg/GdbStub/GdbStub.c
+++ b/EmbeddedPkg/GdbStub/GdbStub.c
@@ -1,1263 +1,1257 @@
-/** @file
-  UEFI driver that implements a GDB stub
-  
-  Note: Any code in the path of the Serial IO output can not call DEBUG as will
-  will blow out the stack. Serial IO calls DEBUG, debug calls Serail IO, ...
-  
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include <GdbStubInternal.h>
-#include <Protocol/DebugPort.h>
-
-
-UINTN     gMaxProcessorIndex = 0;
-
-//
-// Buffers for basic gdb communication
-//
-CHAR8 gInBuffer[MAX_BUF_SIZE];
-CHAR8 gOutBuffer[MAX_BUF_SIZE];
-
-// Assume gdb does a "qXfer:libraries:read::offset,length" when it connects so we can default 
-// this value to FALSE. Since gdb can reconnect its self a global default is not good enough
-BOOLEAN   gSymbolTableUpdate = FALSE;
-EFI_EVENT gEvent;
-VOID      *gGdbSymbolEventHandlerRegistration = NULL;
-
-//
-// Globals for returning XML from qXfer:libraries:read packet
-//
-UINTN                             gPacketqXferLibraryOffset = 0;
-UINTN                             gEfiDebugImageTableEntry = 0;
-EFI_DEBUG_IMAGE_INFO_TABLE_HEADER *gDebugImageTableHeader = NULL;
-EFI_DEBUG_IMAGE_INFO              *gDebugTable = NULL;
-CHAR8                             gXferLibraryBuffer[2000];
-
-GLOBAL_REMOVE_IF_UNREFERENCED CONST CHAR8 mHexToStr[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
-
-
-VOID
-EFIAPI
-GdbSymbolEventHandler (
-  IN  EFI_EVENT       Event,
-  IN  VOID            *Context
-  )
-{
-}
-
-
-/**
-  The user Entry Point for Application. The user code starts with this function
-  as the real entry point for the image goes into a library that calls this 
-  function.
-
-  @param[in] ImageHandle    The firmware allocated handle for the EFI image.  
-  @param[in] SystemTable    A pointer to the EFI System Table.
-  
-  @retval EFI_SUCCESS       The entry point is executed successfully.
-  @retval other             Some error occurs when executing this entry point.
-
-**/
-EFI_STATUS
-EFIAPI
-GdbStubEntry (
-  IN EFI_HANDLE        ImageHandle,
-  IN EFI_SYSTEM_TABLE  *SystemTable
-  )
-
-{
-  EFI_STATUS                  Status;  
-  EFI_DEBUG_SUPPORT_PROTOCOL  *DebugSupport;
-  UINTN                       HandleCount;
-  EFI_HANDLE                  *Handles;
-  UINTN                       Index;
-  UINTN                       Processor;
-  BOOLEAN                     IsaSupported;
- 
-   
-  Status = EfiGetSystemConfigurationTable (&gEfiDebugImageInfoTableGuid, (VOID **)&gDebugImageTableHeader);
-  if (EFI_ERROR (Status)) {
-    gDebugImageTableHeader = NULL;
-  }
-
-  Status = gBS->LocateHandleBuffer (
-                  ByProtocol,
-                  &gEfiDebugSupportProtocolGuid,
-                  NULL,
-                  &HandleCount,
-                  &Handles
-                  );
-  if (EFI_ERROR (Status)) {
-    DEBUG ((EFI_D_ERROR, "Debug Support Protocol not found\n"));
-
-    return Status;
-  }
-  
-  DebugSupport = NULL;
-  IsaSupported = FALSE;
-  do {
-    HandleCount--;
-    Status = gBS->HandleProtocol (
-                    Handles[HandleCount],
-                    &gEfiDebugSupportProtocolGuid,
-                    (VOID **) &DebugSupport
-                    );
-    if (!EFI_ERROR (Status)) {
-      if (CheckIsa (DebugSupport->Isa)) {
-        // We found what we are looking for so break out of the loop
-        IsaSupported = TRUE;
-        break;
-      }
-    }
-  } while (HandleCount > 0);
-  FreePool (Handles);
-  
-  if (!IsaSupported) {
-    DEBUG ((EFI_D_ERROR, "Debug Support Protocol does not support our ISA\n"));
-
-    return EFI_NOT_FOUND;
-  }
-  
-  Status = DebugSupport->GetMaximumProcessorIndex (DebugSupport, &gMaxProcessorIndex);
-  ASSERT_EFI_ERROR (Status);
-  
-  DEBUG ((EFI_D_INFO, "Debug Support Protocol ISA %x\n", DebugSupport->Isa));
-  DEBUG ((EFI_D_INFO, "Debug Support Protocol Processor Index %d\n", gMaxProcessorIndex));
-  
-  // Call processor-specific init routine
-  InitializeProcessor();
-
-  for (Processor = 0; Processor <= gMaxProcessorIndex; Processor++) {
-    
-    for (Index = 0; Index < MaxEfiException (); Index++) {
-      Status = DebugSupport->RegisterExceptionCallback (DebugSupport, Processor,  GdbExceptionHandler, gExceptionType[Index].Exception);
-      ASSERT_EFI_ERROR (Status);
-    }
-    //
-    // Current edk2 DebugPort is not interrupt context safe so we can not use it
-    //
-    Status = DebugSupport->RegisterPeriodicCallback (DebugSupport, Processor, GdbPeriodicCallBack);
-    ASSERT_EFI_ERROR (Status);
-  }
- 
-  //
-  // This even fires every time an image is added. This allows the stub to know when gdb needs
-  // to update the symbol table. 
-  //
-  Status = gBS->CreateEvent (
-                  EVT_NOTIFY_SIGNAL,
-                  TPL_CALLBACK,
-                  GdbSymbolEventHandler,
-                  NULL,
-                  &gEvent
-                  );
-  ASSERT_EFI_ERROR (Status);
-
-  //
-  // Register for protocol notifactions on this event
-  //
-  Status = gBS->RegisterProtocolNotify (
-                  &gEfiLoadedImageProtocolGuid,
-                  gEvent,
-                  &gGdbSymbolEventHandlerRegistration
-                  );
-  ASSERT_EFI_ERROR (Status);
-
- 
- if (PcdGetBool (PcdGdbSerial)) {
-   GdbInitializeSerialConsole ();
- }
-   
-  return EFI_SUCCESS;
-}
-
-
-
-/**
- Transfer length bytes of input buffer, starting at Address, to memory.
-
- @param     length                  the number of the bytes to be transferred/written
- @param     *address                the start address of the transferring/writing the memory
- @param     *new_data               the new data to be written to memory
- **/
-
-VOID
-TransferFromInBufToMem (
-  IN    UINTN                       Length,
-  IN    unsigned char               *Address,
-  IN    CHAR8                       *NewData
-  )
-{
-  CHAR8 c1;
-  CHAR8 c2;
-   
-  while (Length-- > 0) {
-    c1 = (CHAR8)HexCharToInt (*NewData++);
-    c2 = (CHAR8)HexCharToInt (*NewData++);
-
-    if ((c1 < 0) || (c2 < 0)) {
-      Print ((CHAR16 *)L"Bad message from write to memory..\n");
-      SendError (GDB_EBADMEMDATA); 
-      return;
-    }
-    *Address++ = (UINT8)((c1 << 4) + c2);
-  }
-
-  SendSuccess();
-}
-
-
-/**
- Transfer Length bytes of memory starting at Address to an output buffer, OutBuffer. This function will finally send the buffer
- as a packet.
-
- @param     Length                  the number of the bytes to be transferred/read
- @param     *address                pointer to the start address of the transferring/reading the memory
- **/
-
-VOID
-TransferFromMemToOutBufAndSend (
-  IN    UINTN                       Length,
-  IN    unsigned char               *Address
-  )
-{
-  // there are Length bytes and every byte is represented as 2 hex chars
-  CHAR8   OutBuffer[MAX_BUF_SIZE];
-  CHAR8   *OutBufPtr;             // pointer to the output buffer
-  CHAR8   Char;
-
-  if (ValidateAddress(Address) == FALSE) {
-    SendError(14);
-    return;
-  }
-
-  OutBufPtr = OutBuffer;
-  while (Length > 0) {
-    
-    Char = mHexToStr[*Address >> 4];
-    if ((Char >= 'A') && (Char <= 'F')) {
-      Char = Char - 'A' + 'a';
-    }
-    *OutBufPtr++ = Char;
-
-    Char = mHexToStr[*Address & 0x0f];
-    if ((Char >= 'A') && (Char <= 'F')) {
-      Char = Char - 'A' + 'a';
-    }
-    *OutBufPtr++ = Char;
-
-    Address++;
-    Length--;
-  }
-
-  *OutBufPtr = '\0' ;  // the end of the buffer
-  SendPacket (OutBuffer);
-}
-
-
-
-/**
-  Send a GDB Remote Serial Protocol Packet
-  
-  $PacketData#checksum PacketData is passed in and this function adds the packet prefix '$', 
-  the packet teminating character '#' and the two digit checksum.
-  
-  If an ack '+' is not sent resend the packet, but timeout eventually so we don't end up 
-  in an infinit loop. This is so if you unplug the debugger code just keeps running
-
-  @param PacketData   Payload data for the packet  
-
-  
-  @retval             Number of bytes of packet data sent.
-
-**/
-UINTN
-SendPacket (
-  IN  CHAR8 *PacketData
-  )
-{
-  UINT8 CheckSum;
-  UINTN Timeout;
-  CHAR8 *Ptr;
-  CHAR8 TestChar;
-  UINTN Count;
-  
-  Timeout = PcdGet32 (PcdGdbMaxPacketRetryCount);
-
-  Count = 0;
-  do {
-
-    Ptr = PacketData;
-
-    if (Timeout-- == 0) {
-      // Only try a finite number of times so we don't get stuck in the loop
-      return Count;
-    }
-  
-    // Packet prefix
-    GdbPutChar ('$');
-  
-    for (CheckSum = 0, Count =0 ; *Ptr != '\0'; Ptr++, Count++) {
-      GdbPutChar (*Ptr);
-      CheckSum = CheckSum + *Ptr;
-    }
-  
-    // Packet terminating character and checksum 
-    GdbPutChar ('#');
-    GdbPutChar (mHexToStr[CheckSum >> 4]);
-    GdbPutChar (mHexToStr[CheckSum & 0x0F]);
-    
-    TestChar =  GdbGetChar ();
-  } while (TestChar != '+');
-  
-  return Count;
-}
-
-/**
-  Receive a GDB Remote Serial Protocol Packet
-  
-  $PacketData#checksum PacketData is passed in and this function adds the packet prefix '$', 
-  the packet teminating character '#' and the two digit checksum.
- 
-  If host re-starts sending a packet without ending the previous packet, only the last valid packet is proccessed.
-  (In other words, if received packet is '$12345$12345$123456#checksum', only '$123456#checksum' will be processed.)
- 
-  If an ack '+' is not sent resend the packet
-
-  @param PacketData   Payload data for the packet  
-
-  @retval             Number of bytes of packet data received.
-
-**/
-UINTN
-ReceivePacket (
-  OUT  CHAR8 *PacketData,
-  IN   UINTN PacketDataSize
- )
-{
-  UINT8 CheckSum;
-  UINTN Index;
-  CHAR8 Char;
-  CHAR8 SumString[3];
-  CHAR8 TestChar;
-  
-  ZeroMem (PacketData, PacketDataSize);
-  
-  for (;;) {
-      // wait for the start of a packet
-    TestChar = GdbGetChar ();
-    while (TestChar != '$') {
-      TestChar = GdbGetChar ();
-    };
-    
-  retry:
-    for (Index = 0, CheckSum = 0; Index < (PacketDataSize - 1); Index++) {
-      Char = GdbGetChar ();
-      if (Char == '$') {
-        goto retry;
-      }
-      if (Char == '#') {
-        break;
-      }
-
-      PacketData[Index] = Char;
-      CheckSum = CheckSum + Char;
-    }
-    PacketData[Index] = '\0';
-
-    if (Index == PacketDataSize) {
-      continue;
-    }
-
-    SumString[0] = GdbGetChar ();  
-    SumString[1] = GdbGetChar ();
-    SumString[2] = '\0';
-    
-    if (AsciiStrHexToUintn (SumString) == CheckSum) {
-      // Ack: Success
-      GdbPutChar ('+');
-  
-      // Null terminate the callers string
-      PacketData[Index] = '\0';
-      return Index;
-    } else {
-      // Ack: Failure
-      GdbPutChar ('-');
-    }
-  }
-  
-  //return 0;
-}
-
-
-/**
- Empties the given buffer 
- @param   Buf          pointer to the first element in buffer to be emptied
- **/
-VOID
-EmptyBuffer ( 
-  IN  CHAR8           *Buf
-  )
-{ 
-  *Buf = '\0';
-}
-
-
-/**
- Converts an 8-bit Hex Char into a INTN.
- 
- @param   Char the hex character to be converted into UINTN
- @retval  a INTN, from 0 to 15, that corressponds to Char
- -1 if Char is not a hex character
- **/
-INTN
-HexCharToInt (
-  IN  CHAR8           Char
-  )
-{
-  if ((Char >= 'A') && (Char <= 'F')) {
-    return Char - 'A' + 10;
-  } else if ((Char >= 'a') && (Char <= 'f')) {
-    return Char - 'a' + 10;
-  } else if ((Char >= '0') && (Char <= '9')) {
-    return Char - '0';
-  } else { // if not a hex value, return a negative value
-    return -1; 
-  }
-}
-
-  // 'E' + the biggest error number is 255, so its 2 hex digits + buffer end
-CHAR8 *gError = "E__";
-
-/** 'E NN'
- Send an error with the given error number after converting to hex.
- The error number is put into the buffer in hex. '255' is the biggest errno we can send.
- ex: 162 will be sent as A2.
- 
- @param   errno           the error number that will be sent
- **/
-VOID
-EFIAPI
-SendError (
-  IN  UINT8              ErrorNum
-  )
-{
-  //
-  // Replace _, or old data, with current errno
-  //
-  gError[1] = mHexToStr [ErrorNum >> 4];
-  gError[2] = mHexToStr [ErrorNum & 0x0f];
-    
-  SendPacket (gError); // send buffer
-}
-
-
-
-/**
- Send 'OK' when the function is done executing successfully.
- **/
-VOID
-EFIAPI
-SendSuccess (
-  VOID
-  ) 
-{
-  SendPacket ("OK"); // send buffer
-}
-
-
-/**
- Send empty packet to specify that particular command/functionality is not supported.
- **/
-VOID        
-EFIAPI      
-SendNotSupported (
-  VOID          
-  )             
-{       
-  SendPacket ("");
-}
-
-
-
-/**
- Send the T signal with the given exception type (in gdb order) and possibly with n:r pairs related to the watchpoints
- 
- @param  SystemContext        Register content at time of the exception
- @param  GdbExceptionType     GDB exception type
- **/
-VOID
-GdbSendTSignal (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  UINT8               GdbExceptionType
-  )
-{
-  CHAR8 TSignalBuffer[128];
-  CHAR8 *TSignalPtr;
-  UINTN BreakpointDetected;
-  BREAK_TYPE BreakType;
-  UINTN DataAddress;
-  CHAR8 *WatchStrPtr = NULL;
-  UINTN RegSize;
-
-  TSignalPtr = &TSignalBuffer[0];
-
-  //Construct TSignal packet
-  *TSignalPtr++ = 'T';
-
-  //
-  // replace _, or previous value, with Exception type
-  //
-  *TSignalPtr++ = mHexToStr [GdbExceptionType >> 4]; 
-  *TSignalPtr++ = mHexToStr [GdbExceptionType & 0x0f];
-  
-  if (GdbExceptionType == GDB_SIGTRAP) {
-    if (gSymbolTableUpdate) {
-      //
-      // We can only send back on reason code. So if the flag is set it means the breakpoint is from our event handler
-      //
-      WatchStrPtr = "library:;";
-      while (*WatchStrPtr != '\0') {
-        *TSignalPtr++ = *WatchStrPtr++;
-      }
-      gSymbolTableUpdate = FALSE;
-    } else {
-
-
-      //
-      // possible n:r pairs
-      // 
-
-      //Retrieve the breakpoint number
-      BreakpointDetected = GetBreakpointDetected (SystemContext);
-
-      //Figure out if the exception is happend due to watch, rwatch or awatch.
-      BreakType = GetBreakpointType (SystemContext, BreakpointDetected); 
-
-      //INFO: rwatch is not supported due to the way IA32 debug registers work
-      if ((BreakType == DataWrite) || (BreakType == DataRead) || (BreakType == DataReadWrite)) {
-        
-        //Construct n:r pair
-        DataAddress = GetBreakpointDataAddress (SystemContext, BreakpointDetected);
-
-        //Assign appropriate buffer to print particular watchpoint type
-        if (BreakType == DataWrite) {
-          WatchStrPtr = "watch";
-        } else if (BreakType == DataRead) {
-          WatchStrPtr = "rwatch";
-        } else if (BreakType == DataReadWrite) {
-          WatchStrPtr = "awatch";
-        }
-
-        while (*WatchStrPtr != '\0') {
-          *TSignalPtr++ = *WatchStrPtr++;
-        }
-
-        *TSignalPtr++ = ':';
-        
-        //Set up series of bytes in big-endian byte order. "awatch" won't work with little-endian byte order.
-        RegSize = REG_SIZE;
-        while (RegSize > 0) {
-          RegSize = RegSize-4;
-          *TSignalPtr++ = mHexToStr[(UINT8)(DataAddress >> RegSize) & 0xf];
-        }
-
-        //Always end n:r pair with ';'
-        *TSignalPtr++ = ';';
-      }
-    }
-  }
-
-  *TSignalPtr = '\0';
-
-  SendPacket (TSignalBuffer); 
-}
-
-
-/**
- Translates the EFI mapping to GDB mapping
- 
- @param   EFIExceptionType    EFI Exception that is being processed
- @retval  UINTN that corresponds to EFIExceptionType's GDB exception type number
- **/
-UINT8
-ConvertEFItoGDBtype ( 
-  IN  EFI_EXCEPTION_TYPE      EFIExceptionType
-  )
-{ 
-  UINTN i;
-  
-  for (i=0; i < MaxEfiException() ; i++) {
-    if (gExceptionType[i].Exception == EFIExceptionType) {
-      return gExceptionType[i].SignalNo;
-    }
-  }
-  return GDB_SIGTRAP; // this is a GDB trap
-}
-
-
-/** "m addr,length"
- Find the Length of the area to read and the start addres. Finally, pass them to 
- another function, TransferFromMemToOutBufAndSend, that will read from that memory space and 
- send it as a packet.
- **/
-
-VOID
-EFIAPI
-ReadFromMemory (
-  CHAR8 *PacketData
-  )
-{
-  UINTN Address;
-  UINTN Length;
-  CHAR8 AddressBuffer[MAX_ADDR_SIZE]; // the buffer that will hold the address in hex chars
-  CHAR8 *AddrBufPtr; // pointer to the address buffer
-  CHAR8 *InBufPtr; /// pointer to the input buffer
-  
-  AddrBufPtr = AddressBuffer;
-  InBufPtr = &PacketData[1];
-  while (*InBufPtr != ',') {
-    *AddrBufPtr++ = *InBufPtr++;
-  }
-  *AddrBufPtr = '\0';
-  
-  InBufPtr++; // this skips ',' in the buffer
-  
-  /* Error checking */
-  if (AsciiStrLen(AddressBuffer) >= MAX_ADDR_SIZE) {
-    Print((CHAR16 *)L"Address is too long\n");
-    SendError (GDB_EBADMEMADDRBUFSIZE); 
-    return;
-  }
-  
-  // 2 = 'm' + ','
-  if (AsciiStrLen(PacketData) - AsciiStrLen(AddressBuffer) - 2 >= MAX_LENGTH_SIZE) {
-    Print((CHAR16 *)L"Length is too long\n");
-    SendError (GDB_EBADMEMLENGTH); 
-    return;
-  }
-  
-  Address = AsciiStrHexToUintn (AddressBuffer);
-  Length = AsciiStrHexToUintn (InBufPtr);
-  
-  TransferFromMemToOutBufAndSend (Length, (unsigned char *)Address);
-}
-
-
-/** "M addr,length :XX..."
- Find the Length of the area in bytes to write and the start addres. Finally, pass them to 
- another function, TransferFromInBufToMem, that will write to that memory space the info in
- the input buffer.
- **/
-VOID
-EFIAPI
-WriteToMemory (
-  IN CHAR8 *PacketData
-  )
-{
-  UINTN Address;
-  UINTN Length;
-  UINTN MessageLength;
-  CHAR8 AddressBuffer[MAX_ADDR_SIZE]; // the buffer that will hold the Address in hex chars
-  CHAR8 LengthBuffer[MAX_LENGTH_SIZE]; // the buffer that will hold the Length in hex chars
-  CHAR8 *AddrBufPtr; // pointer to the Address buffer
-  CHAR8 *LengthBufPtr; // pointer to the Length buffer
-  CHAR8 *InBufPtr; /// pointer to the input buffer
-  
-  AddrBufPtr = AddressBuffer;
-  LengthBufPtr = LengthBuffer;
-  InBufPtr = &PacketData[1];
-  
-  while (*InBufPtr != ',') {
-    *AddrBufPtr++ = *InBufPtr++;
-  }
-  *AddrBufPtr = '\0';
-  
-  InBufPtr++; // this skips ',' in the buffer
-  
-  while (*InBufPtr != ':') {
-    *LengthBufPtr++ = *InBufPtr++;
-  }
-  *LengthBufPtr = '\0';
-  
-  InBufPtr++; // this skips ':' in the buffer
-  
-  Address = AsciiStrHexToUintn (AddressBuffer);
-  Length = AsciiStrHexToUintn (LengthBuffer);
-  
-  /* Error checking */
-  
-  //Check if Address is not too long.
-  if (AsciiStrLen(AddressBuffer) >= MAX_ADDR_SIZE) {
-    Print ((CHAR16 *)L"Address too long..\n");
-    SendError (GDB_EBADMEMADDRBUFSIZE); 
-    return;
-  }
-  
-  //Check if message length is not too long
-  if (AsciiStrLen(LengthBuffer) >= MAX_LENGTH_SIZE) {
-    Print ((CHAR16 *)L"Length too long..\n");
-    SendError (GDB_EBADMEMLENGBUFSIZE); 
-    return;
-  }
-  
-  // Check if Message is not too long/short.
-  // 3 = 'M' + ',' + ':'
-  MessageLength = (AsciiStrLen(PacketData) - AsciiStrLen(AddressBuffer) - AsciiStrLen(LengthBuffer) - 3);
-  if (MessageLength != (2*Length)) {
-    //Message too long/short. New data is not the right size.
-    SendError (GDB_EBADMEMDATASIZE);   
-    return;
-  }
-  TransferFromInBufToMem (Length, (unsigned char *)Address, InBufPtr);
-}
-
-/**
-  Parses breakpoint packet data and captures Breakpoint type, Address and length.
-  In case of an error, function returns particular error code. Returning 0 meaning
-  no error.
-
-  @param  PacketData  Pointer to the payload data for the packet.
-  @param  Type        Breakpoint type
-  @param  Address     Breakpoint address
-  @param  Length      Breakpoint length in Bytes (1 byte, 2 byte, 4 byte)
-
-  @retval 1           Success
-  @retval {other}     Particular error code
-
-**/
-UINTN
-ParseBreakpointPacket (
-  IN  CHAR8 *PacketData,
-  OUT UINTN *Type,
-  OUT UINTN *Address,
-  OUT UINTN *Length
-  )
-{
-  CHAR8 AddressBuffer[MAX_ADDR_SIZE];
-  CHAR8 *AddressBufferPtr;
-  CHAR8 *PacketDataPtr;
-
-  PacketDataPtr = &PacketData[1];
-  AddressBufferPtr = AddressBuffer;
-
-  *Type = AsciiStrHexToUintn (PacketDataPtr);
-
-  //Breakpoint/watchpoint type should be between 0 to 4
-  if (*Type > 4) {
-    Print ((CHAR16 *)L"Type is invalid\n");
-    return 22; //EINVAL: Invalid argument.
-  }
-
-  //Skip ',' in the buffer.
-  while (*PacketDataPtr++ != ',');
-
-  //Parse Address information
-  while (*PacketDataPtr != ',') {
-    *AddressBufferPtr++ = *PacketDataPtr++;
-  }
-  *AddressBufferPtr = '\0';
-
-  //Check if Address is not too long.
-  if (AsciiStrLen(AddressBuffer) >= MAX_ADDR_SIZE) {
-    Print ((CHAR16 *)L"Address too long..\n");
-    return 40; //EMSGSIZE: Message size too long.
-  }
-
-  *Address = AsciiStrHexToUintn (AddressBuffer);
-
-  PacketDataPtr++; //This skips , in the buffer
-
-  //Parse Length information
-  *Length = AsciiStrHexToUintn (PacketDataPtr);
-
-  //Length should be 1, 2 or 4 bytes
-  if (*Length > 4) {
-    Print ((CHAR16 *)L"Length is invalid\n");
-    return 22; //EINVAL: Invalid argument
-  }
-
-  return 0; //0 = No error
-}
-
-UINTN
-gXferObjectReadResponse (
-  IN  CHAR8         Type,
-  IN  CHAR8         *Str
-  )
-{
-  CHAR8   *OutBufPtr;             // pointer to the output buffer
-  CHAR8   Char;
-  UINTN   Count;
-
-  // responce starts with 'm' or 'l' if it is the end
-  OutBufPtr = gOutBuffer;
-  *OutBufPtr++ = Type;
-  Count = 1;
-
-  // Binary data encoding 
-  OutBufPtr = gOutBuffer;
-  while (*Str != '\0') {
-    Char = *Str++;
-    if ((Char == 0x7d) || (Char == 0x23) || (Char == 0x24) || (Char == 0x2a)) {
-      // escape character
-      *OutBufPtr++ = 0x7d;
-
-      Char ^= 0x20;
-    }
-    *OutBufPtr++ = Char;
-    Count++;
-  }
-
-  *OutBufPtr = '\0' ;  // the end of the buffer
-  SendPacket (gOutBuffer);
-  
-  return Count;
-}
-
-
-/**
-  Note: This should be a library function.  In the Apple case you have to add 
-  the size of the PE/COFF header into the starting address to make things work 
-  right as there is no way to pad the Mach-O for the size of the PE/COFF header.
-  
-  
-  Returns a pointer to the PDB file name for a PE/COFF image that has been
-  loaded into system memory with the PE/COFF Loader Library functions.
-
-  Returns the PDB file name for the PE/COFF image specified by Pe32Data.  If
-  the PE/COFF image specified by Pe32Data is not a valid, then NULL is
-  returned.  If the PE/COFF image specified by Pe32Data does not contain a
-  debug directory entry, then NULL is returned.  If the debug directory entry
-  in the PE/COFF image specified by Pe32Data does not contain a PDB file name,
-  then NULL is returned.
-  If Pe32Data is NULL, then ASSERT().
-
-  @param  Pe32Data   Pointer to the PE/COFF image that is loaded in system
-                     memory.
-  @param  DebugBase  Address that the debugger would use as the base of the image
-
-  @return The PDB file name for the PE/COFF image specified by Pe32Data or NULL
-          if it cannot be retrieved. DebugBase is only valid if PDB file name is
-          valid. 
-
-**/
-VOID *
-EFIAPI
-PeCoffLoaderGetDebuggerInfo (
-  IN VOID     *Pe32Data,
-  OUT VOID    **DebugBase
-  )
-{
-  EFI_IMAGE_DOS_HEADER                  *DosHdr;
-  EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION   Hdr;
-  EFI_IMAGE_DATA_DIRECTORY              *DirectoryEntry;
-  EFI_IMAGE_DEBUG_DIRECTORY_ENTRY       *DebugEntry;
-  UINTN                                 DirCount;
-  VOID                                  *CodeViewEntryPointer;
-  INTN                                  TEImageAdjust;
-  UINT32                                NumberOfRvaAndSizes;
-  UINT16                                Magic;
-  UINTN                                 SizeOfHeaders;
-
-  ASSERT (Pe32Data   != NULL);
-
-  TEImageAdjust       = 0;
-  DirectoryEntry      = NULL;
-  DebugEntry          = NULL;
-  NumberOfRvaAndSizes = 0;
-  SizeOfHeaders       = 0;
-
-  DosHdr = (EFI_IMAGE_DOS_HEADER *)Pe32Data;
-  if (DosHdr->e_magic == EFI_IMAGE_DOS_SIGNATURE) {
-    //
-    // DOS image header is present, so read the PE header after the DOS image header.
-    //
-    Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINTN) Pe32Data + (UINTN) ((DosHdr->e_lfanew) & 0x0ffff));
-  } else {
-    //
-    // DOS image header is not present, so PE header is at the image base.
-    //
-    Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)Pe32Data;
-  }
-
-  if (Hdr.Te->Signature == EFI_TE_IMAGE_HEADER_SIGNATURE) {
-    if (Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress != 0) {
-      DirectoryEntry  = &Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG];
-      TEImageAdjust   = sizeof (EFI_TE_IMAGE_HEADER) - Hdr.Te->StrippedSize;
-      DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *)((UINTN) Hdr.Te +
-                    Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress +
-                    TEImageAdjust);
-    }
-    SizeOfHeaders = sizeof (EFI_TE_IMAGE_HEADER) + (UINTN)Hdr.Te->BaseOfCode - (UINTN)Hdr.Te->StrippedSize;
-    
-    // __APPLE__ check this math...
-    *DebugBase = ((CHAR8 *)Pe32Data) -  TEImageAdjust;
-  } else if (Hdr.Pe32->Signature == EFI_IMAGE_NT_SIGNATURE) {
-    
-    *DebugBase = Pe32Data;
-    
-    
-    //
-    // NOTE: We use Machine field to identify PE32/PE32+, instead of Magic.
-    //       It is due to backward-compatibility, for some system might
-    //       generate PE32+ image with PE32 Magic.
-    //
-    switch (Hdr.Pe32->FileHeader.Machine) {
-    case EFI_IMAGE_MACHINE_IA32:
-      //
-      // Assume PE32 image with IA32 Machine field.
-      //
-      Magic = EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC;
-      break;
-    case EFI_IMAGE_MACHINE_X64:
-    case EFI_IMAGE_MACHINE_IA64:
-      //
-      // Assume PE32+ image with X64 or IPF Machine field
-      //
-      Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC;
-      break;
-    default:
-      //
-      // For unknow Machine field, use Magic in optional Header
-      //
-      Magic = Hdr.Pe32->OptionalHeader.Magic;
-    }
-
-    if (Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
-      //
-      // Use PE32 offset get Debug Directory Entry
-      //
-      SizeOfHeaders = Hdr.Pe32->OptionalHeader.SizeOfHeaders;
-      NumberOfRvaAndSizes = Hdr.Pe32->OptionalHeader.NumberOfRvaAndSizes;
-      DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(Hdr.Pe32->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);
-      DebugEntry     = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *) ((UINTN) Pe32Data + DirectoryEntry->VirtualAddress);
-    } else if (Hdr.Pe32->OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
-      //
-      // Use PE32+ offset get Debug Directory Entry
-      //
-      SizeOfHeaders = Hdr.Pe32Plus->OptionalHeader.SizeOfHeaders;
-      NumberOfRvaAndSizes = Hdr.Pe32Plus->OptionalHeader.NumberOfRvaAndSizes;
-      DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(Hdr.Pe32Plus->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);
-      DebugEntry     = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *) ((UINTN) Pe32Data + DirectoryEntry->VirtualAddress);
-    }
-
-    if (NumberOfRvaAndSizes <= EFI_IMAGE_DIRECTORY_ENTRY_DEBUG) {
-      DirectoryEntry = NULL;
-      DebugEntry = NULL;
-    }
-  } else {
-    return NULL;
-  }
-
-  if (DebugEntry == NULL || DirectoryEntry == NULL) {
-    return NULL;
-  }
-
-  for (DirCount = 0; DirCount < DirectoryEntry->Size; DirCount += sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY), DebugEntry++) {
-    if (DebugEntry->Type == EFI_IMAGE_DEBUG_TYPE_CODEVIEW) {
-      if (DebugEntry->SizeOfData > 0) {
-        CodeViewEntryPointer = (VOID *) ((UINTN) DebugEntry->RVA + ((UINTN)Pe32Data) + (UINTN)TEImageAdjust);
-        switch (* (UINT32 *) CodeViewEntryPointer) {
-        case CODEVIEW_SIGNATURE_NB10:
-          return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY));
-        case CODEVIEW_SIGNATURE_RSDS:
-          return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_RSDS_ENTRY));
-        case CODEVIEW_SIGNATURE_MTOC:
-          *DebugBase = (VOID *)(UINTN)((UINTN)DebugBase - SizeOfHeaders);
-          return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_MTOC_ENTRY));
-        default:
-          break;
-        }
-      }
-    }
-  }
-
-  (void)SizeOfHeaders;
-  return NULL;
-}
-
-
-
-/** 
-  Process "qXfer:object:read:annex:offset,length" request.
-  
-  Returns an XML document that contains loaded libraries. In our case it is 
-  infomration in the EFI Debug Inmage Table converted into an XML document.
-  
-  GDB will call with an arbitrary length (it can't know the real length and 
-  will reply with chunks of XML that are easy for us to deal with. Gdb will 
-  keep calling until we say we are done. XML doc looks like:
-  
-  <library-list>
-    <library name="/a/a/c/d.dSYM"><segment address="0x10000000"/></library>
-    <library name="/a/m/e/e.pdb"><segment address="0x20000000"/></library>
-    <library name="/a/l/f/f.dll"><segment address="0x30000000"/></library>
-  </library-list>
-  
-  Since we can not allocate memory in interupt context this module has 
-  assumptions about how it will get called:
-  1) Length will generally be max remote packet size (big enough)
-  2) First Offset of an XML document read needs to be 0
-  3) This code will return back small chunks of the XML document on every read.
-     Each subseqent call will ask for the next availble part of the document.
-     
-  Note: The only variable size element in the XML is:
-  "  <library name=\"%s\"><segment address=\"%p\"/></library>\n" and it is 
-  based on the file path and name of the symbol file. If the symbol file name
-  is bigger than the max gdb remote packet size we could update this code
-  to respond back in chunks.
-
- @param Offset  offset into special data area
- @param Length  number of bytes to read starting at Offset  
-  
- **/
-VOID
-QxferLibrary (
-  IN  UINTN   Offset,
-  IN  UINTN   Length
-  )
-{
-  VOID                              *LoadAddress;
-  CHAR8                             *Pdb;
-  UINTN                             Size;
-
-  if (Offset != gPacketqXferLibraryOffset) {
-    SendError (GDB_EINVALIDARG);
-    Print (L"\nqXferLibrary (%d, %d) != %d\n", Offset, Length, gPacketqXferLibraryOffset);
-    
-    // Force a retry from the beginning 
-    gPacketqXferLibraryOffset = 0;
-    return;
-  }
-
-  if (Offset == 0) {
-    gPacketqXferLibraryOffset += gXferObjectReadResponse ('m', "<library-list>\n");
-    
-    // The owner of the table may have had to ralloc it so grab a fresh copy every time
-    // we assume qXferLibrary will get called over and over again until the entire XML table is 
-    // returned in a tight loop. Since we are in the debugger the table should not get updated
-    gDebugTable = gDebugImageTableHeader->EfiDebugImageInfoTable;
-    gEfiDebugImageTableEntry = 0;
-    return;
-  }
-  
-  if (gDebugTable != NULL) {
-    for (; gEfiDebugImageTableEntry < gDebugImageTableHeader->TableSize; gEfiDebugImageTableEntry++, gDebugTable++) {
-      if (gDebugTable->NormalImage != NULL) {
-        if ((gDebugTable->NormalImage->ImageInfoType == EFI_DEBUG_IMAGE_INFO_TYPE_NORMAL) && 
-            (gDebugTable->NormalImage->LoadedImageProtocolInstance != NULL)) {
-          Pdb = PeCoffLoaderGetDebuggerInfo (
-                 gDebugTable->NormalImage->LoadedImageProtocolInstance->ImageBase, 
-                 &LoadAddress
-                 );
-          if (Pdb != NULL) {
-            Size = AsciiSPrint (
-                    gXferLibraryBuffer, 
-                    sizeof (gXferLibraryBuffer), 
-                    "  <library name=\"%a\"><segment address=\"0x%p\"/></library>\n", 
-                    Pdb,
-                    LoadAddress
-                    );
-            if ((Size != 0) && (Size != (sizeof (gXferLibraryBuffer) - 1))) {
-              gPacketqXferLibraryOffset += gXferObjectReadResponse ('m', gXferLibraryBuffer);
-              
-              // Update loop variables so we are in the right place when we get back
-              gEfiDebugImageTableEntry++;
-              gDebugTable++;
-              return;
-            } else {
-              // We could handle <library> entires larger than sizeof (gXferLibraryBuffer) here if 
-              // needed by breaking up into N packets
-              // "<library name=\"%s
-              // the rest of the string (as many packets as required
-              // \"><segment address=\"%d\"/></library> (fixed size)
-              //
-              // But right now we just skip any entry that is too big
-            }
-          }           
-        }
-      }  
-    }
-  }
-  
-  
-  gXferObjectReadResponse ('l', "</library-list>\n");
-  gPacketqXferLibraryOffset = 0;
-  return;
-}
-
-
-/**
- Exception Hanldler for GDB. It will be called for all exceptions
- registered via the gExceptionType[] array.
- 
- @param ExceptionType     Exception that is being processed
- @param SystemContext     Register content at time of the exception  
- **/
-VOID
-EFIAPI
-GdbExceptionHandler ( 
-  IN  EFI_EXCEPTION_TYPE        ExceptionType, 
-  IN OUT EFI_SYSTEM_CONTEXT     SystemContext 
-  )
-{
-  UINT8   GdbExceptionType;
-  CHAR8   *Ptr;
-      
-  
-  if (ValidateException(ExceptionType, SystemContext) == FALSE) {
-    return;
-  }
-
-  RemoveSingleStep (SystemContext);
-  
-  GdbExceptionType = ConvertEFItoGDBtype (ExceptionType);
-  GdbSendTSignal (SystemContext, GdbExceptionType);
-  
-  for( ; ; ) {
-    ReceivePacket (gInBuffer, MAX_BUF_SIZE);
-    
-    switch (gInBuffer[0]) {
-      case '?':
-        GdbSendTSignal (SystemContext, GdbExceptionType);
-        break;
-          
-      case 'c':
-        ContinueAtAddress (SystemContext, gInBuffer);          
-        return;
-
-      case 'g':
-        ReadGeneralRegisters (SystemContext);
-        break;
-          
-      case 'G':
-        WriteGeneralRegisters (SystemContext, gInBuffer);
-        break;
-          
-      case 'H':
-        //Return "OK" packet since we don't have more than one thread. 
-        SendSuccess ();
-        break;
-          
-      case 'm':
-        ReadFromMemory (gInBuffer);
-        break;
-
-      case 'M':
-        WriteToMemory (gInBuffer);
-        break;
-
-      case 'P':
-        WriteNthRegister (SystemContext, gInBuffer);
-        break;
-
-      //
-      // Still debugging this code. Not used in Darwin
-      //
-      case 'q': 
-        // General Query Packets
-        if (AsciiStrnCmp (gInBuffer, "qSupported", 10) == 0) {
-          // return what we currently support, we don't parse what gdb suports
-          AsciiSPrint (gOutBuffer, MAX_BUF_SIZE, "qXfer:libraries:read+;PacketSize=%d", MAX_BUF_SIZE);
-          SendPacket (gOutBuffer);
-        } else if (AsciiStrnCmp (gInBuffer, "qXfer:libraries:read::", 22) == 0) {
-          // ‘qXfer:libraries:read::offset,length
-          // gInBuffer[22] is offset string, ++Ptr is length string’
-          for (Ptr = &gInBuffer[22]; *Ptr != ','; Ptr++);
-        
-          // Not sure if multi-radix support is required. Currently only support decimal
-          QxferLibrary (AsciiStrHexToUintn (&gInBuffer[22]), AsciiStrHexToUintn (++Ptr));
-        } if (AsciiStrnCmp (gInBuffer, "qOffsets", 10) == 0) {
-          AsciiSPrint (gOutBuffer, MAX_BUF_SIZE, "Text=1000;Data=f000;Bss=f000");
-          SendPacket (gOutBuffer);
-        } else {
-          //Send empty packet
-          SendNotSupported ();
-        }
-        break;
-
-      case 's':
-        SingleStep (SystemContext, gInBuffer);          
-        return;
-          
-      case 'z':
-        RemoveBreakPoint (SystemContext, gInBuffer);
-        break;
-  
-      case 'Z':
-        InsertBreakPoint (SystemContext, gInBuffer);
-        break;
-                  
-      default:  
-        //Send empty packet
-        SendNotSupported ();
-        break;
-    }
-  }
-}
-
-
-/**
- Periodic callback for GDB. This function is used to catch a ctrl-c or other 
- break in type command from GDB.
- 
- @param SystemContext     Register content at time of the call  
- **/
-VOID
-EFIAPI
-GdbPeriodicCallBack ( 
-  IN OUT EFI_SYSTEM_CONTEXT     SystemContext 
-  )
-{
-  //
-  // gCtrlCBreakFlag may have been set from a previous F response package 
-  // and we set the global as we need to process it at a point where we 
-  // can update the system context. If we are in the middle of processing
-  // a F Packet it is not safe to read the GDB serial stream so we need
-  // to skip it on this check
-  //
-  if (!gCtrlCBreakFlag && !gProcessingFPacket) {
-    //
-    // Ctrl-C was not pending so grab any pending characters and see if they 
-    // are a Ctrl-c (0x03). If so set the Ctrl-C global. 
-    //
-    while (TRUE) {
-      if (!GdbIsCharAvailable ()) {
-        //
-        // No characters are pending so exit the loop
-        //
-        break;
-      }
-      
-      if (GdbGetChar () == 0x03) {
-        gCtrlCBreakFlag = TRUE;
-        //
-        // We have a ctrl-c so exit the loop
-        //
-        break;
-      }
-    }
-  }
-  
-  if (gCtrlCBreakFlag) {
-    //
-    // Update the context to force a single step trap when we exit the GDB
-    // stub. This will trasfer control to GdbExceptionHandler () and let
-    // us break into the program. We don't want to break into the GDB stub.
-    //
-    AddSingleStep (SystemContext);
-    gCtrlCBreakFlag = FALSE;
-  }
-}
+/** @file

+  UEFI driver that implements a GDB stub

+  

+  Note: Any code in the path of the Serial IO output can not call DEBUG as will

+  will blow out the stack. Serial IO calls DEBUG, debug calls Serail IO, ...

+  

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include <GdbStubInternal.h>

+#include <Protocol/DebugPort.h>

+

+

+UINTN     gMaxProcessorIndex = 0;

+

+//

+// Buffers for basic gdb communication

+//

+CHAR8 gInBuffer[MAX_BUF_SIZE];

+CHAR8 gOutBuffer[MAX_BUF_SIZE];

+

+// Assume gdb does a "qXfer:libraries:read::offset,length" when it connects so we can default 

+// this value to FALSE. Since gdb can reconnect its self a global default is not good enough

+BOOLEAN   gSymbolTableUpdate = FALSE;

+EFI_EVENT gEvent;

+VOID      *gGdbSymbolEventHandlerRegistration = NULL;

+

+//

+// Globals for returning XML from qXfer:libraries:read packet

+//

+UINTN                             gPacketqXferLibraryOffset = 0;

+UINTN                             gEfiDebugImageTableEntry = 0;

+EFI_DEBUG_IMAGE_INFO_TABLE_HEADER *gDebugImageTableHeader = NULL;

+EFI_DEBUG_IMAGE_INFO              *gDebugTable = NULL;

+CHAR8                             gXferLibraryBuffer[2000];

+

+GLOBAL_REMOVE_IF_UNREFERENCED CONST CHAR8 mHexToStr[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};

+

+

+VOID

+EFIAPI

+GdbSymbolEventHandler (

+  IN  EFI_EVENT       Event,

+  IN  VOID            *Context

+  )

+{

+}

+

+

+/**

+  The user Entry Point for Application. The user code starts with this function

+  as the real entry point for the image goes into a library that calls this 

+  function.

+

+  @param[in] ImageHandle    The firmware allocated handle for the EFI image.  

+  @param[in] SystemTable    A pointer to the EFI System Table.

+  

+  @retval EFI_SUCCESS       The entry point is executed successfully.

+  @retval other             Some error occurs when executing this entry point.

+

+**/

+EFI_STATUS

+EFIAPI

+GdbStubEntry (

+  IN EFI_HANDLE        ImageHandle,

+  IN EFI_SYSTEM_TABLE  *SystemTable

+  )

+{

+  EFI_STATUS                  Status;  

+  EFI_DEBUG_SUPPORT_PROTOCOL  *DebugSupport;

+  UINTN                       HandleCount;

+  EFI_HANDLE                  *Handles;

+  UINTN                       Index;

+  UINTN                       Processor;

+  BOOLEAN                     IsaSupported;

+

+  Status = EfiGetSystemConfigurationTable (&gEfiDebugImageInfoTableGuid, (VOID **)&gDebugImageTableHeader);

+  if (EFI_ERROR (Status)) {

+    gDebugImageTableHeader = NULL;

+  }

+

+  Status = gBS->LocateHandleBuffer (

+                  ByProtocol,

+                  &gEfiDebugSupportProtocolGuid,

+                  NULL,

+                  &HandleCount,

+                  &Handles

+                  );

+  if (EFI_ERROR (Status)) {

+    DEBUG ((EFI_D_ERROR, "Debug Support Protocol not found\n"));

+

+    return Status;

+  }

+  

+  DebugSupport = NULL;

+  IsaSupported = FALSE;

+  do {

+    HandleCount--;

+    Status = gBS->HandleProtocol (

+                    Handles[HandleCount],

+                    &gEfiDebugSupportProtocolGuid,

+                    (VOID **) &DebugSupport

+                    );

+    if (!EFI_ERROR (Status)) {

+      if (CheckIsa (DebugSupport->Isa)) {

+        // We found what we are looking for so break out of the loop

+        IsaSupported = TRUE;

+        break;

+      }

+    }

+  } while (HandleCount > 0);

+  FreePool (Handles);

+  

+  if (!IsaSupported) {

+    DEBUG ((EFI_D_ERROR, "Debug Support Protocol does not support our ISA\n"));

+

+    return EFI_NOT_FOUND;

+  }

+  

+  Status = DebugSupport->GetMaximumProcessorIndex (DebugSupport, &gMaxProcessorIndex);

+  ASSERT_EFI_ERROR (Status);

+  

+  DEBUG ((EFI_D_INFO, "Debug Support Protocol ISA %x\n", DebugSupport->Isa));

+  DEBUG ((EFI_D_INFO, "Debug Support Protocol Processor Index %d\n", gMaxProcessorIndex));

+  

+  // Call processor-specific init routine

+  InitializeProcessor ();

+

+  for (Processor = 0; Processor <= gMaxProcessorIndex; Processor++) {

+    for (Index = 0; Index < MaxEfiException (); Index++) {

+      Status = DebugSupport->RegisterExceptionCallback (DebugSupport, Processor,  GdbExceptionHandler, gExceptionType[Index].Exception);

+      ASSERT_EFI_ERROR (Status);

+    }

+    //

+    // Current edk2 DebugPort is not interrupt context safe so we can not use it

+    //

+    Status = DebugSupport->RegisterPeriodicCallback (DebugSupport, Processor, GdbPeriodicCallBack);

+    ASSERT_EFI_ERROR (Status);

+  }

+ 

+  //

+  // This even fires every time an image is added. This allows the stub to know when gdb needs

+  // to update the symbol table. 

+  //

+  Status = gBS->CreateEvent (

+                  EVT_NOTIFY_SIGNAL,

+                  TPL_CALLBACK,

+                  GdbSymbolEventHandler,

+                  NULL,

+                  &gEvent

+                  );

+  ASSERT_EFI_ERROR (Status);

+

+  //

+  // Register for protocol notifications on this event

+  //

+  Status = gBS->RegisterProtocolNotify (

+                  &gEfiLoadedImageProtocolGuid,

+                  gEvent,

+                  &gGdbSymbolEventHandlerRegistration

+                  );

+  ASSERT_EFI_ERROR (Status);

+

+ 

+ if (PcdGetBool (PcdGdbSerial)) {

+   GdbInitializeSerialConsole ();

+ }

+   

+  return EFI_SUCCESS;

+}

+

+/**

+ Transfer length bytes of input buffer, starting at Address, to memory.

+

+ @param     length                  the number of the bytes to be transferred/written

+ @param     *address                the start address of the transferring/writing the memory

+ @param     *new_data               the new data to be written to memory

+ **/

+

+VOID

+TransferFromInBufToMem (

+  IN    UINTN                       Length,

+  IN    unsigned char               *Address,

+  IN    CHAR8                       *NewData

+  )

+{

+  CHAR8 c1;

+  CHAR8 c2;

+   

+  while (Length-- > 0) {

+    c1 = (CHAR8)HexCharToInt (*NewData++);

+    c2 = (CHAR8)HexCharToInt (*NewData++);

+

+    if ((c1 < 0) || (c2 < 0)) {

+      Print ((CHAR16 *)L"Bad message from write to memory..\n");

+      SendError (GDB_EBADMEMDATA); 

+      return;

+    }

+    *Address++ = (UINT8)((c1 << 4) + c2);

+  }

+

+  SendSuccess();

+}

+

+

+/**

+ Transfer Length bytes of memory starting at Address to an output buffer, OutBuffer. This function will finally send the buffer

+ as a packet.

+

+ @param     Length                  the number of the bytes to be transferred/read

+ @param     *address                pointer to the start address of the transferring/reading the memory

+ **/

+

+VOID

+TransferFromMemToOutBufAndSend (

+  IN    UINTN                       Length,

+  IN    unsigned char               *Address

+  )

+{

+  // there are Length bytes and every byte is represented as 2 hex chars

+  CHAR8   OutBuffer[MAX_BUF_SIZE];

+  CHAR8   *OutBufPtr;             // pointer to the output buffer

+  CHAR8   Char;

+

+  if (ValidateAddress(Address) == FALSE) {

+    SendError(14);

+    return;

+  }

+

+  OutBufPtr = OutBuffer;

+  while (Length > 0) {

+    

+    Char = mHexToStr[*Address >> 4];

+    if ((Char >= 'A') && (Char <= 'F')) {

+      Char = Char - 'A' + 'a';

+    }

+    *OutBufPtr++ = Char;

+

+    Char = mHexToStr[*Address & 0x0f];

+    if ((Char >= 'A') && (Char <= 'F')) {

+      Char = Char - 'A' + 'a';

+    }

+    *OutBufPtr++ = Char;

+

+    Address++;

+    Length--;

+  }

+

+  *OutBufPtr = '\0' ;  // the end of the buffer

+  SendPacket (OutBuffer);

+}

+

+

+

+/**

+  Send a GDB Remote Serial Protocol Packet

+  

+  $PacketData#checksum PacketData is passed in and this function adds the packet prefix '$', 

+  the packet teminating character '#' and the two digit checksum.

+  

+  If an ack '+' is not sent resend the packet, but timeout eventually so we don't end up 

+  in an infinit loop. This is so if you unplug the debugger code just keeps running

+

+  @param PacketData   Payload data for the packet  

+

+  

+  @retval             Number of bytes of packet data sent.

+

+**/

+UINTN

+SendPacket (

+  IN  CHAR8 *PacketData

+  )

+{

+  UINT8 CheckSum;

+  UINTN Timeout;

+  CHAR8 *Ptr;

+  CHAR8 TestChar;

+  UINTN Count;

+  

+  Timeout = PcdGet32 (PcdGdbMaxPacketRetryCount);

+

+  Count = 0;

+  do {

+

+    Ptr = PacketData;

+

+    if (Timeout-- == 0) {

+      // Only try a finite number of times so we don't get stuck in the loop

+      return Count;

+    }

+  

+    // Packet prefix

+    GdbPutChar ('$');

+  

+    for (CheckSum = 0, Count =0 ; *Ptr != '\0'; Ptr++, Count++) {

+      GdbPutChar (*Ptr);

+      CheckSum = CheckSum + *Ptr;

+    }

+  

+    // Packet terminating character and checksum 

+    GdbPutChar ('#');

+    GdbPutChar (mHexToStr[CheckSum >> 4]);

+    GdbPutChar (mHexToStr[CheckSum & 0x0F]);

+    

+    TestChar =  GdbGetChar ();

+  } while (TestChar != '+');

+  

+  return Count;

+}

+

+/**

+  Receive a GDB Remote Serial Protocol Packet

+  

+  $PacketData#checksum PacketData is passed in and this function adds the packet prefix '$', 

+  the packet teminating character '#' and the two digit checksum.

+ 

+  If host re-starts sending a packet without ending the previous packet, only the last valid packet is proccessed.

+  (In other words, if received packet is '$12345$12345$123456#checksum', only '$123456#checksum' will be processed.)

+ 

+  If an ack '+' is not sent resend the packet

+

+  @param PacketData   Payload data for the packet  

+

+  @retval             Number of bytes of packet data received.

+

+**/

+UINTN

+ReceivePacket (

+  OUT  CHAR8 *PacketData,

+  IN   UINTN PacketDataSize

+ )

+{

+  UINT8 CheckSum;

+  UINTN Index;

+  CHAR8 Char;

+  CHAR8 SumString[3];

+  CHAR8 TestChar;

+  

+  ZeroMem (PacketData, PacketDataSize);

+  

+  for (;;) {

+      // wait for the start of a packet

+    TestChar = GdbGetChar ();

+    while (TestChar != '$') {

+      TestChar = GdbGetChar ();

+    };

+    

+  retry:

+    for (Index = 0, CheckSum = 0; Index < (PacketDataSize - 1); Index++) {

+      Char = GdbGetChar ();

+      if (Char == '$') {

+        goto retry;

+      }

+      if (Char == '#') {

+        break;

+      }

+

+      PacketData[Index] = Char;

+      CheckSum = CheckSum + Char;

+    }

+    PacketData[Index] = '\0';

+

+    if (Index == PacketDataSize) {

+      continue;

+    }

+

+    SumString[0] = GdbGetChar ();  

+    SumString[1] = GdbGetChar ();

+    SumString[2] = '\0';

+    

+    if (AsciiStrHexToUintn (SumString) == CheckSum) {

+      // Ack: Success

+      GdbPutChar ('+');

+  

+      // Null terminate the callers string

+      PacketData[Index] = '\0';

+      return Index;

+    } else {

+      // Ack: Failure

+      GdbPutChar ('-');

+    }

+  }

+  

+  //return 0;

+}

+

+

+/**

+ Empties the given buffer 

+ @param   Buf          pointer to the first element in buffer to be emptied

+ **/

+VOID

+EmptyBuffer ( 

+  IN  CHAR8           *Buf

+  )

+{ 

+  *Buf = '\0';

+}

+

+

+/**

+ Converts an 8-bit Hex Char into a INTN.

+ 

+ @param   Char the hex character to be converted into UINTN

+ @retval  a INTN, from 0 to 15, that corressponds to Char

+ -1 if Char is not a hex character

+ **/

+INTN

+HexCharToInt (

+  IN  CHAR8           Char

+  )

+{

+  if ((Char >= 'A') && (Char <= 'F')) {

+    return Char - 'A' + 10;

+  } else if ((Char >= 'a') && (Char <= 'f')) {

+    return Char - 'a' + 10;

+  } else if ((Char >= '0') && (Char <= '9')) {

+    return Char - '0';

+  } else { // if not a hex value, return a negative value

+    return -1; 

+  }

+}

+

+  // 'E' + the biggest error number is 255, so its 2 hex digits + buffer end

+CHAR8 *gError = "E__";

+

+/** 'E NN'

+ Send an error with the given error number after converting to hex.

+ The error number is put into the buffer in hex. '255' is the biggest errno we can send.

+ ex: 162 will be sent as A2.

+ 

+ @param   errno           the error number that will be sent

+ **/

+VOID

+EFIAPI

+SendError (

+  IN  UINT8              ErrorNum

+  )

+{

+  //

+  // Replace _, or old data, with current errno

+  //

+  gError[1] = mHexToStr [ErrorNum >> 4];

+  gError[2] = mHexToStr [ErrorNum & 0x0f];

+    

+  SendPacket (gError); // send buffer

+}

+

+

+

+/**

+ Send 'OK' when the function is done executing successfully.

+ **/

+VOID

+EFIAPI

+SendSuccess (

+  VOID

+  ) 

+{

+  SendPacket ("OK"); // send buffer

+}

+

+

+/**

+ Send empty packet to specify that particular command/functionality is not supported.

+ **/

+VOID        

+EFIAPI      

+SendNotSupported (

+  VOID          

+  )             

+{

+  SendPacket ("");

+}

+

+

+/**

+ Send the T signal with the given exception type (in gdb order) and possibly with n:r pairs related to the watchpoints

+ 

+ @param  SystemContext        Register content at time of the exception

+ @param  GdbExceptionType     GDB exception type

+ **/

+VOID

+GdbSendTSignal (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  UINT8               GdbExceptionType

+  )

+{

+  CHAR8 TSignalBuffer[128];

+  CHAR8 *TSignalPtr;

+  UINTN BreakpointDetected;

+  BREAK_TYPE BreakType;

+  UINTN DataAddress;

+  CHAR8 *WatchStrPtr = NULL;

+  UINTN RegSize;

+

+  TSignalPtr = &TSignalBuffer[0];

+

+  //Construct TSignal packet

+  *TSignalPtr++ = 'T';

+

+  //

+  // replace _, or previous value, with Exception type

+  //

+  *TSignalPtr++ = mHexToStr [GdbExceptionType >> 4]; 

+  *TSignalPtr++ = mHexToStr [GdbExceptionType & 0x0f];

+  

+  if (GdbExceptionType == GDB_SIGTRAP) {

+    if (gSymbolTableUpdate) {

+      //

+      // We can only send back on reason code. So if the flag is set it means the breakpoint is from our event handler

+      //

+      WatchStrPtr = "library:;";

+      while (*WatchStrPtr != '\0') {

+        *TSignalPtr++ = *WatchStrPtr++;

+      }

+      gSymbolTableUpdate = FALSE;

+    } else {

+

+

+      //

+      // possible n:r pairs

+      // 

+

+      //Retrieve the breakpoint number

+      BreakpointDetected = GetBreakpointDetected (SystemContext);

+

+      //Figure out if the exception is happend due to watch, rwatch or awatch.

+      BreakType = GetBreakpointType (SystemContext, BreakpointDetected); 

+

+      //INFO: rwatch is not supported due to the way IA32 debug registers work

+      if ((BreakType == DataWrite) || (BreakType == DataRead) || (BreakType == DataReadWrite)) {

+        

+        //Construct n:r pair

+        DataAddress = GetBreakpointDataAddress (SystemContext, BreakpointDetected);

+

+        //Assign appropriate buffer to print particular watchpoint type

+        if (BreakType == DataWrite) {

+          WatchStrPtr = "watch";

+        } else if (BreakType == DataRead) {

+          WatchStrPtr = "rwatch";

+        } else if (BreakType == DataReadWrite) {

+          WatchStrPtr = "awatch";

+        }

+

+        while (*WatchStrPtr != '\0') {

+          *TSignalPtr++ = *WatchStrPtr++;

+        }

+

+        *TSignalPtr++ = ':';

+        

+        //Set up series of bytes in big-endian byte order. "awatch" won't work with little-endian byte order.

+        RegSize = REG_SIZE;

+        while (RegSize > 0) {

+          RegSize = RegSize-4;

+          *TSignalPtr++ = mHexToStr[(UINT8)(DataAddress >> RegSize) & 0xf];

+        }

+

+        //Always end n:r pair with ';'

+        *TSignalPtr++ = ';';

+      }

+    }

+  }

+

+  *TSignalPtr = '\0';

+

+  SendPacket (TSignalBuffer); 

+}

+

+

+/**

+ Translates the EFI mapping to GDB mapping

+ 

+ @param   EFIExceptionType    EFI Exception that is being processed

+ @retval  UINTN that corresponds to EFIExceptionType's GDB exception type number

+ **/

+UINT8

+ConvertEFItoGDBtype ( 

+  IN  EFI_EXCEPTION_TYPE      EFIExceptionType

+  )

+{ 

+  UINTN Index;

+  

+  for (Index = 0; Index < MaxEfiException () ; Index++) {

+    if (gExceptionType[Index].Exception == EFIExceptionType) {

+      return gExceptionType[Index].SignalNo;

+    }

+  }

+  return GDB_SIGTRAP; // this is a GDB trap

+}

+

+

+/** "m addr,length"

+ Find the Length of the area to read and the start addres. Finally, pass them to 

+ another function, TransferFromMemToOutBufAndSend, that will read from that memory space and 

+ send it as a packet.

+ **/

+

+VOID

+EFIAPI

+ReadFromMemory (

+  CHAR8 *PacketData

+  )

+{

+  UINTN Address;

+  UINTN Length;

+  CHAR8 AddressBuffer[MAX_ADDR_SIZE]; // the buffer that will hold the address in hex chars

+  CHAR8 *AddrBufPtr; // pointer to the address buffer

+  CHAR8 *InBufPtr; /// pointer to the input buffer

+  

+  AddrBufPtr = AddressBuffer;

+  InBufPtr = &PacketData[1];

+  while (*InBufPtr != ',') {

+    *AddrBufPtr++ = *InBufPtr++;

+  }

+  *AddrBufPtr = '\0';

+  

+  InBufPtr++; // this skips ',' in the buffer

+  

+  /* Error checking */

+  if (AsciiStrLen (AddressBuffer) >= MAX_ADDR_SIZE) {

+    Print((CHAR16 *)L"Address is too long\n");

+    SendError (GDB_EBADMEMADDRBUFSIZE); 

+    return;

+  }

+  

+  // 2 = 'm' + ','

+  if (AsciiStrLen (PacketData) - AsciiStrLen (AddressBuffer) - 2 >= MAX_LENGTH_SIZE) {

+    Print((CHAR16 *)L"Length is too long\n");

+    SendError (GDB_EBADMEMLENGTH); 

+    return;

+  }

+  

+  Address = AsciiStrHexToUintn (AddressBuffer);

+  Length = AsciiStrHexToUintn (InBufPtr);

+  

+  TransferFromMemToOutBufAndSend (Length, (unsigned char *)Address);

+}

+

+

+/** "M addr,length :XX..."

+ Find the Length of the area in bytes to write and the start addres. Finally, pass them to 

+ another function, TransferFromInBufToMem, that will write to that memory space the info in

+ the input buffer.

+ **/

+VOID

+EFIAPI

+WriteToMemory (

+  IN CHAR8 *PacketData

+  )

+{

+  UINTN Address;

+  UINTN Length;

+  UINTN MessageLength;

+  CHAR8 AddressBuffer[MAX_ADDR_SIZE]; // the buffer that will hold the Address in hex chars

+  CHAR8 LengthBuffer[MAX_LENGTH_SIZE]; // the buffer that will hold the Length in hex chars

+  CHAR8 *AddrBufPtr; // pointer to the Address buffer

+  CHAR8 *LengthBufPtr; // pointer to the Length buffer

+  CHAR8 *InBufPtr; /// pointer to the input buffer

+  

+  AddrBufPtr = AddressBuffer;

+  LengthBufPtr = LengthBuffer;

+  InBufPtr = &PacketData[1];

+  

+  while (*InBufPtr != ',') {

+    *AddrBufPtr++ = *InBufPtr++;

+  }

+  *AddrBufPtr = '\0';

+  

+  InBufPtr++; // this skips ',' in the buffer

+  

+  while (*InBufPtr != ':') {

+    *LengthBufPtr++ = *InBufPtr++;

+  }

+  *LengthBufPtr = '\0';

+  

+  InBufPtr++; // this skips ':' in the buffer

+  

+  Address = AsciiStrHexToUintn (AddressBuffer);

+  Length = AsciiStrHexToUintn (LengthBuffer);

+  

+  /* Error checking */

+  

+  //Check if Address is not too long.

+  if (AsciiStrLen (AddressBuffer) >= MAX_ADDR_SIZE) {

+    Print ((CHAR16 *)L"Address too long..\n");

+    SendError (GDB_EBADMEMADDRBUFSIZE); 

+    return;

+  }

+  

+  //Check if message length is not too long

+  if (AsciiStrLen (LengthBuffer) >= MAX_LENGTH_SIZE) {

+    Print ((CHAR16 *)L"Length too long..\n");

+    SendError (GDB_EBADMEMLENGBUFSIZE); 

+    return;

+  }

+  

+  // Check if Message is not too long/short.

+  // 3 = 'M' + ',' + ':'

+  MessageLength = (AsciiStrLen (PacketData) - AsciiStrLen (AddressBuffer) - AsciiStrLen (LengthBuffer) - 3);

+  if (MessageLength != (2*Length)) {

+    //Message too long/short. New data is not the right size.

+    SendError (GDB_EBADMEMDATASIZE);   

+    return;

+  }

+  TransferFromInBufToMem (Length, (unsigned char *)Address, InBufPtr);

+}

+

+/**

+  Parses breakpoint packet data and captures Breakpoint type, Address and length.

+  In case of an error, function returns particular error code. Returning 0 meaning

+  no error.

+

+  @param  PacketData  Pointer to the payload data for the packet.

+  @param  Type        Breakpoint type

+  @param  Address     Breakpoint address

+  @param  Length      Breakpoint length in Bytes (1 byte, 2 byte, 4 byte)

+

+  @retval 1           Success

+  @retval {other}     Particular error code

+

+**/

+UINTN

+ParseBreakpointPacket (

+  IN  CHAR8 *PacketData,

+  OUT UINTN *Type,

+  OUT UINTN *Address,

+  OUT UINTN *Length

+  )

+{

+  CHAR8 AddressBuffer[MAX_ADDR_SIZE];

+  CHAR8 *AddressBufferPtr;

+  CHAR8 *PacketDataPtr;

+

+  PacketDataPtr = &PacketData[1];

+  AddressBufferPtr = AddressBuffer;

+

+  *Type = AsciiStrHexToUintn (PacketDataPtr);

+

+  //Breakpoint/watchpoint type should be between 0 to 4

+  if (*Type > 4) {

+    Print ((CHAR16 *)L"Type is invalid\n");

+    return 22; //EINVAL: Invalid argument.

+  }

+

+  //Skip ',' in the buffer.

+  while (*PacketDataPtr++ != ',');

+

+  //Parse Address information

+  while (*PacketDataPtr != ',') {

+    *AddressBufferPtr++ = *PacketDataPtr++;

+  }

+  *AddressBufferPtr = '\0';

+

+  //Check if Address is not too long.

+  if (AsciiStrLen (AddressBuffer) >= MAX_ADDR_SIZE) {

+    Print ((CHAR16 *)L"Address too long..\n");

+    return 40; //EMSGSIZE: Message size too long.

+  }

+

+  *Address = AsciiStrHexToUintn (AddressBuffer);

+

+  PacketDataPtr++; //This skips , in the buffer

+

+  //Parse Length information

+  *Length = AsciiStrHexToUintn (PacketDataPtr);

+

+  //Length should be 1, 2 or 4 bytes

+  if (*Length > 4) {

+    Print ((CHAR16 *)L"Length is invalid\n");

+    return 22; //EINVAL: Invalid argument

+  }

+

+  return 0; //0 = No error

+}

+

+UINTN

+gXferObjectReadResponse (

+  IN  CHAR8         Type,

+  IN  CHAR8         *Str

+  )

+{

+  CHAR8   *OutBufPtr;             // pointer to the output buffer

+  CHAR8   Char;

+  UINTN   Count;

+

+  // Response starts with 'm' or 'l' if it is the end

+  OutBufPtr = gOutBuffer;

+  *OutBufPtr++ = Type;

+  Count = 1;

+

+  // Binary data encoding 

+  OutBufPtr = gOutBuffer;

+  while (*Str != '\0') {

+    Char = *Str++;

+    if ((Char == 0x7d) || (Char == 0x23) || (Char == 0x24) || (Char == 0x2a)) {

+      // escape character

+      *OutBufPtr++ = 0x7d;

+

+      Char ^= 0x20;

+    }

+    *OutBufPtr++ = Char;

+    Count++;

+  }

+

+  *OutBufPtr = '\0' ;  // the end of the buffer

+  SendPacket (gOutBuffer);

+  

+  return Count;

+}

+

+

+/**

+  Note: This should be a library function.  In the Apple case you have to add 

+  the size of the PE/COFF header into the starting address to make things work 

+  right as there is no way to pad the Mach-O for the size of the PE/COFF header.

+  

+  

+  Returns a pointer to the PDB file name for a PE/COFF image that has been

+  loaded into system memory with the PE/COFF Loader Library functions.

+

+  Returns the PDB file name for the PE/COFF image specified by Pe32Data.  If

+  the PE/COFF image specified by Pe32Data is not a valid, then NULL is

+  returned.  If the PE/COFF image specified by Pe32Data does not contain a

+  debug directory entry, then NULL is returned.  If the debug directory entry

+  in the PE/COFF image specified by Pe32Data does not contain a PDB file name,

+  then NULL is returned.

+  If Pe32Data is NULL, then ASSERT().

+

+  @param  Pe32Data   Pointer to the PE/COFF image that is loaded in system

+                     memory.

+  @param  DebugBase  Address that the debugger would use as the base of the image

+

+  @return The PDB file name for the PE/COFF image specified by Pe32Data or NULL

+          if it cannot be retrieved. DebugBase is only valid if PDB file name is

+          valid. 

+

+**/

+VOID *

+EFIAPI

+PeCoffLoaderGetDebuggerInfo (

+  IN VOID     *Pe32Data,

+  OUT VOID    **DebugBase

+  )

+{

+  EFI_IMAGE_DOS_HEADER                  *DosHdr;

+  EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION   Hdr;

+  EFI_IMAGE_DATA_DIRECTORY              *DirectoryEntry;

+  EFI_IMAGE_DEBUG_DIRECTORY_ENTRY       *DebugEntry;

+  UINTN                                 DirCount;

+  VOID                                  *CodeViewEntryPointer;

+  INTN                                  TEImageAdjust;

+  UINT32                                NumberOfRvaAndSizes;

+  UINT16                                Magic;

+  UINTN                                 SizeOfHeaders;

+

+  ASSERT (Pe32Data   != NULL);

+

+  TEImageAdjust       = 0;

+  DirectoryEntry      = NULL;

+  DebugEntry          = NULL;

+  NumberOfRvaAndSizes = 0;

+  SizeOfHeaders       = 0;

+

+  DosHdr = (EFI_IMAGE_DOS_HEADER *)Pe32Data;

+  if (DosHdr->e_magic == EFI_IMAGE_DOS_SIGNATURE) {

+    //

+    // DOS image header is present, so read the PE header after the DOS image header.

+    //

+    Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINTN) Pe32Data + (UINTN) ((DosHdr->e_lfanew) & 0x0ffff));

+  } else {

+    //

+    // DOS image header is not present, so PE header is at the image base.

+    //

+    Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)Pe32Data;

+  }

+

+  if (Hdr.Te->Signature == EFI_TE_IMAGE_HEADER_SIGNATURE) {

+    if (Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress != 0) {

+      DirectoryEntry  = &Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG];

+      TEImageAdjust   = sizeof (EFI_TE_IMAGE_HEADER) - Hdr.Te->StrippedSize;

+      DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *)((UINTN) Hdr.Te +

+                    Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress +

+                    TEImageAdjust);

+    }

+    SizeOfHeaders = sizeof (EFI_TE_IMAGE_HEADER) + (UINTN)Hdr.Te->BaseOfCode - (UINTN)Hdr.Te->StrippedSize;

+    

+    // __APPLE__ check this math...

+    *DebugBase = ((CHAR8 *)Pe32Data) -  TEImageAdjust;

+  } else if (Hdr.Pe32->Signature == EFI_IMAGE_NT_SIGNATURE) {

+    

+    *DebugBase = Pe32Data;

+    

+    

+    //

+    // NOTE: We use Machine field to identify PE32/PE32+, instead of Magic.

+    //       It is due to backward-compatibility, for some system might

+    //       generate PE32+ image with PE32 Magic.

+    //

+    switch (Hdr.Pe32->FileHeader.Machine) {

+    case EFI_IMAGE_MACHINE_IA32:

+      //

+      // Assume PE32 image with IA32 Machine field.

+      //

+      Magic = EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC;

+      break;

+    case EFI_IMAGE_MACHINE_X64:

+    case EFI_IMAGE_MACHINE_IA64:

+      //

+      // Assume PE32+ image with X64 or IPF Machine field

+      //

+      Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC;

+      break;

+    default:

+      //

+      // For unknow Machine field, use Magic in optional Header

+      //

+      Magic = Hdr.Pe32->OptionalHeader.Magic;

+    }

+

+    if (Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {

+      //

+      // Use PE32 offset get Debug Directory Entry

+      //

+      SizeOfHeaders = Hdr.Pe32->OptionalHeader.SizeOfHeaders;

+      NumberOfRvaAndSizes = Hdr.Pe32->OptionalHeader.NumberOfRvaAndSizes;

+      DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(Hdr.Pe32->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);

+      DebugEntry     = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *) ((UINTN) Pe32Data + DirectoryEntry->VirtualAddress);

+    } else if (Hdr.Pe32->OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) {

+      //

+      // Use PE32+ offset get Debug Directory Entry

+      //

+      SizeOfHeaders = Hdr.Pe32Plus->OptionalHeader.SizeOfHeaders;

+      NumberOfRvaAndSizes = Hdr.Pe32Plus->OptionalHeader.NumberOfRvaAndSizes;

+      DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(Hdr.Pe32Plus->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);

+      DebugEntry     = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *) ((UINTN) Pe32Data + DirectoryEntry->VirtualAddress);

+    }

+

+    if (NumberOfRvaAndSizes <= EFI_IMAGE_DIRECTORY_ENTRY_DEBUG) {

+      DirectoryEntry = NULL;

+      DebugEntry = NULL;

+    }

+  } else {

+    return NULL;

+  }

+

+  if (DebugEntry == NULL || DirectoryEntry == NULL) {

+    return NULL;

+  }

+

+  for (DirCount = 0; DirCount < DirectoryEntry->Size; DirCount += sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY), DebugEntry++) {

+    if (DebugEntry->Type == EFI_IMAGE_DEBUG_TYPE_CODEVIEW) {

+      if (DebugEntry->SizeOfData > 0) {

+        CodeViewEntryPointer = (VOID *) ((UINTN) DebugEntry->RVA + ((UINTN)Pe32Data) + (UINTN)TEImageAdjust);

+        switch (* (UINT32 *) CodeViewEntryPointer) {

+        case CODEVIEW_SIGNATURE_NB10:

+          return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY));

+        case CODEVIEW_SIGNATURE_RSDS:

+          return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_RSDS_ENTRY));

+        case CODEVIEW_SIGNATURE_MTOC:

+          *DebugBase = (VOID *)(UINTN)((UINTN)DebugBase - SizeOfHeaders);

+          return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_MTOC_ENTRY));

+        default:

+          break;

+        }

+      }

+    }

+  }

+

+  (void)SizeOfHeaders;

+  return NULL;

+}

+

+

+/** 

+  Process "qXfer:object:read:annex:offset,length" request.

+  

+  Returns an XML document that contains loaded libraries. In our case it is 

+  information in the EFI Debug Image Table converted into an XML document.

+  

+  GDB will call with an arbitrary length (it can't know the real length and 

+  will reply with chunks of XML that are easy for us to deal with. Gdb will 

+  keep calling until we say we are done. XML doc looks like:

+  

+  <library-list>

+    <library name="/a/a/c/d.dSYM"><segment address="0x10000000"/></library>

+    <library name="/a/m/e/e.pdb"><segment address="0x20000000"/></library>

+    <library name="/a/l/f/f.dll"><segment address="0x30000000"/></library>

+  </library-list>

+  

+  Since we can not allocate memory in interrupt context this module has

+  assumptions about how it will get called:

+  1) Length will generally be max remote packet size (big enough)

+  2) First Offset of an XML document read needs to be 0

+  3) This code will return back small chunks of the XML document on every read.

+     Each subsequent call will ask for the next available part of the document.

+     

+  Note: The only variable size element in the XML is:

+  "  <library name=\"%s\"><segment address=\"%p\"/></library>\n" and it is 

+  based on the file path and name of the symbol file. If the symbol file name

+  is bigger than the max gdb remote packet size we could update this code

+  to respond back in chunks.

+

+ @param Offset  offset into special data area

+ @param Length  number of bytes to read starting at Offset  

+  

+ **/

+VOID

+QxferLibrary (

+  IN  UINTN   Offset,

+  IN  UINTN   Length

+  )

+{

+  VOID                              *LoadAddress;

+  CHAR8                             *Pdb;

+  UINTN                             Size;

+

+  if (Offset != gPacketqXferLibraryOffset) {

+    SendError (GDB_EINVALIDARG);

+    Print (L"\nqXferLibrary (%d, %d) != %d\n", Offset, Length, gPacketqXferLibraryOffset);

+    

+    // Force a retry from the beginning 

+    gPacketqXferLibraryOffset = 0;

+

+    return;

+  }

+

+  if (Offset == 0) {

+    gPacketqXferLibraryOffset += gXferObjectReadResponse ('m', "<library-list>\n");

+    

+    // The owner of the table may have had to ralloc it so grab a fresh copy every time

+    // we assume qXferLibrary will get called over and over again until the entire XML table is 

+    // returned in a tight loop. Since we are in the debugger the table should not get updated

+    gDebugTable = gDebugImageTableHeader->EfiDebugImageInfoTable;

+    gEfiDebugImageTableEntry = 0;

+    return;

+  }

+  

+  if (gDebugTable != NULL) {

+    for (; gEfiDebugImageTableEntry < gDebugImageTableHeader->TableSize; gEfiDebugImageTableEntry++, gDebugTable++) {

+      if (gDebugTable->NormalImage != NULL) {

+        if ((gDebugTable->NormalImage->ImageInfoType == EFI_DEBUG_IMAGE_INFO_TYPE_NORMAL) && 

+            (gDebugTable->NormalImage->LoadedImageProtocolInstance != NULL)) {

+          Pdb = PeCoffLoaderGetDebuggerInfo (

+                 gDebugTable->NormalImage->LoadedImageProtocolInstance->ImageBase, 

+                 &LoadAddress

+                 );

+          if (Pdb != NULL) {

+            Size = AsciiSPrint (

+                    gXferLibraryBuffer, 

+                    sizeof (gXferLibraryBuffer), 

+                    "  <library name=\"%a\"><segment address=\"0x%p\"/></library>\n", 

+                    Pdb,

+                    LoadAddress

+                    );

+            if ((Size != 0) && (Size != (sizeof (gXferLibraryBuffer) - 1))) {

+              gPacketqXferLibraryOffset += gXferObjectReadResponse ('m', gXferLibraryBuffer);

+              

+              // Update loop variables so we are in the right place when we get back

+              gEfiDebugImageTableEntry++;

+              gDebugTable++;

+              return;

+            } else {

+              // We could handle <library> entires larger than sizeof (gXferLibraryBuffer) here if 

+              // needed by breaking up into N packets

+              // "<library name=\"%s

+              // the rest of the string (as many packets as required

+              // \"><segment address=\"%d\"/></library> (fixed size)

+              //

+              // But right now we just skip any entry that is too big

+            }

+          }           

+        }

+      }  

+    }

+  }

+  

+  

+  gXferObjectReadResponse ('l', "</library-list>\n");

+  gPacketqXferLibraryOffset = 0;

+  return;

+}

+

+

+/**

+ Exception Hanldler for GDB. It will be called for all exceptions

+ registered via the gExceptionType[] array.

+ 

+ @param ExceptionType     Exception that is being processed

+ @param SystemContext     Register content at time of the exception  

+ **/

+VOID

+EFIAPI

+GdbExceptionHandler ( 

+  IN  EFI_EXCEPTION_TYPE        ExceptionType, 

+  IN OUT EFI_SYSTEM_CONTEXT     SystemContext 

+  )

+{

+  UINT8   GdbExceptionType;

+  CHAR8   *Ptr;

+      

+  

+  if (ValidateException (ExceptionType, SystemContext) == FALSE) {

+    return;

+  }

+

+  RemoveSingleStep (SystemContext);

+  

+  GdbExceptionType = ConvertEFItoGDBtype (ExceptionType);

+  GdbSendTSignal (SystemContext, GdbExceptionType);

+  

+  for( ; ; ) {

+    ReceivePacket (gInBuffer, MAX_BUF_SIZE);

+    

+    switch (gInBuffer[0]) {

+      case '?':

+        GdbSendTSignal (SystemContext, GdbExceptionType);

+        break;

+          

+      case 'c':

+        ContinueAtAddress (SystemContext, gInBuffer);          

+        return;

+

+      case 'g':

+        ReadGeneralRegisters (SystemContext);

+        break;

+          

+      case 'G':

+        WriteGeneralRegisters (SystemContext, gInBuffer);

+        break;

+          

+      case 'H':

+        //Return "OK" packet since we don't have more than one thread. 

+        SendSuccess ();

+        break;

+          

+      case 'm':

+        ReadFromMemory (gInBuffer);

+        break;

+

+      case 'M':

+        WriteToMemory (gInBuffer);

+        break;

+

+      case 'P':

+        WriteNthRegister (SystemContext, gInBuffer);

+        break;

+

+      //

+      // Still debugging this code. Not used in Darwin

+      //

+      case 'q': 

+        // General Query Packets

+        if (AsciiStrnCmp (gInBuffer, "qSupported", 10) == 0) {

+          // return what we currently support, we don't parse what gdb suports

+          AsciiSPrint (gOutBuffer, MAX_BUF_SIZE, "qXfer:libraries:read+;PacketSize=%d", MAX_BUF_SIZE);

+          SendPacket (gOutBuffer);

+        } else if (AsciiStrnCmp (gInBuffer, "qXfer:libraries:read::", 22) == 0) {

+          // ‘qXfer:libraries:read::offset,length

+          // gInBuffer[22] is offset string, ++Ptr is length string’

+          for (Ptr = &gInBuffer[22]; *Ptr != ','; Ptr++);

+        

+          // Not sure if multi-radix support is required. Currently only support decimal

+          QxferLibrary (AsciiStrHexToUintn (&gInBuffer[22]), AsciiStrHexToUintn (++Ptr));

+        } if (AsciiStrnCmp (gInBuffer, "qOffsets", 10) == 0) {

+          AsciiSPrint (gOutBuffer, MAX_BUF_SIZE, "Text=1000;Data=f000;Bss=f000");

+          SendPacket (gOutBuffer);

+        } else {

+          //Send empty packet

+          SendNotSupported ();

+        }

+        break;

+

+      case 's':

+        SingleStep (SystemContext, gInBuffer);          

+        return;

+          

+      case 'z':

+        RemoveBreakPoint (SystemContext, gInBuffer);

+        break;

+  

+      case 'Z':

+        InsertBreakPoint (SystemContext, gInBuffer);

+        break;

+                  

+      default:  

+        //Send empty packet

+        SendNotSupported ();

+        break;

+    }

+  }

+}

+

+

+/**

+ Periodic callback for GDB. This function is used to catch a ctrl-c or other 

+ break in type command from GDB.

+ 

+ @param SystemContext     Register content at time of the call  

+ **/

+VOID

+EFIAPI

+GdbPeriodicCallBack ( 

+  IN OUT EFI_SYSTEM_CONTEXT     SystemContext 

+  )

+{

+  //

+  // gCtrlCBreakFlag may have been set from a previous F response package 

+  // and we set the global as we need to process it at a point where we 

+  // can update the system context. If we are in the middle of processing

+  // a F Packet it is not safe to read the GDB serial stream so we need

+  // to skip it on this check

+  //

+  if (!gCtrlCBreakFlag && !gProcessingFPacket) {

+    //

+    // Ctrl-C was not pending so grab any pending characters and see if they 

+    // are a Ctrl-c (0x03). If so set the Ctrl-C global. 

+    //

+    while (TRUE) {

+      if (!GdbIsCharAvailable ()) {

+        //

+        // No characters are pending so exit the loop

+        //

+        break;

+      }

+      

+      if (GdbGetChar () == 0x03) {

+        gCtrlCBreakFlag = TRUE;

+        //

+        // We have a ctrl-c so exit the loop

+        //

+        break;

+      }

+    }

+  }

+  

+  if (gCtrlCBreakFlag) {

+    //

+    // Update the context to force a single step trap when we exit the GDB

+    // stub. This will transfer control to GdbExceptionHandler () and let

+    // us break into the program. We don't want to break into the GDB stub.

+    //

+    AddSingleStep (SystemContext);

+    gCtrlCBreakFlag = FALSE;

+  }

+}

diff --git a/EmbeddedPkg/GdbStub/GdbStubInternal.h b/EmbeddedPkg/GdbStub/GdbStubInternal.h
index ac04d7b9..e84ca3a0 100644
--- a/EmbeddedPkg/GdbStub/GdbStubInternal.h
+++ b/EmbeddedPkg/GdbStub/GdbStubInternal.h
@@ -1,746 +1,746 @@
-/** @file
-  Private include file for GDB stub
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __GDB_STUB_INTERNAL__
-#define __GDB_STUB_INTERNAL__
-
-#include <Uefi.h>
-#include <Library/BaseLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/MemoryAllocationLib.h>
-#include <Library/DebugLib.h>
-#include <Library/UefiLib.h>
-#include <Library/UefiBootServicesTableLib.h>
-#include <Library/PcdLib.h>
-#include <Library/GdbSerialLib.h>
-#include <Library/PrintLib.h>
-
-#include <Protocol/DebugSupport.h>
-#include <Protocol/SerialIo.h>
-#include <Protocol/LoadedImage.h>
-#include <Protocol/LoadedImage.h>
-#include <Guid/DebugImageInfoTable.h>
-#include <IndustryStandard/PeImage.h>
-
-extern CONST CHAR8 mHexToStr[];
-
-// maximum size of input and output buffers
-// This value came from the show remote command of the gdb we tested against 
-#define MAX_BUF_SIZE 2000
-
-// maximum size of address buffer
-#define MAX_ADDR_SIZE 32
-
-// maximum size of register number buffer
-#define MAX_REG_NUM_BUF_SIZE 32
-
-// maximum size of length buffer
-#define MAX_LENGTH_SIZE 32
-
-// maximum size of T signal members
-#define MAX_T_SIGNAL_SIZE 64
-
-// the mask used to clear all the cache
-#define TF_BIT 0x00000100
-
-
-//
-// GDB Signal definitions - generic names for interrupts
-//
-#define GDB_SIGILL      4  // Illegal instruction       
-#define GDB_SIGTRAP     5  // Trace Trap (Breakpoint and SingleStep)
-#define GDB_SIGEMT      7  // Emulator Trap
-#define GDB_SIGFPE      8  // Floating point exception
-#define GDB_SIGSEGV     11 // Setgment violation, page fault 
-
-
-//
-// GDB File I/O Error values, zero means no error
-// Includes all general GDB Unix like error values
-//
-#define GDB_EBADMEMADDRBUFSIZE   11  // the buffer that stores memory Address to be read from/written to is not the right size
-#define GDB_EBADMEMLENGBUFSIZE   12  // the buffer that stores Length is not the right size 
-#define GDB_EBADMEMLENGTH        13  // Length, the given number of bytes to read or write, is not the right size
-#define GDB_EBADMEMDATA          14  // one of the bytes or nibbles of the memory is leess than 0 
-#define GDB_EBADMEMDATASIZE      15  // the memory data, 'XX..', is too short or too long
-#define GDB_EBADBUFSIZE          21  // the buffer created is not the correct size
-#define GDB_EINVALIDARG          31  // argument is invalid
-#define GDB_ENOSPACE             41  //
-#define GDB_EINVALIDBRKPOINTTYPE 51  // the breakpoint type is not recognized
-#define GDB_EINVALIDREGNUM       61  // given register number is not valid: either <0 or >=Number of Registers
-#define GDB_EUNKNOWN             255 // unknown
-
-
-//
-// These devices are open by GDB so we can just read and write to them
-//
-#define GDB_STDIN   0x00
-#define GDB_STDOUT  0x01
-#define GDB_STDERR  0x02
-
-//
-//Define Register size for different architectures
-//
-#if defined (MDE_CPU_IA32) 
-#define REG_SIZE  32
-#elif defined (MDE_CPU_X64)
-#define REG_SIZE  64
-#elif defined (MDE_CPU_ARM)
-#define REG_SIZE  32
-#endif
-
-#define GDB_SERIAL_DEV_SIGNATURE    SIGNATURE_32 ('g', 'd', 'b', 's')
-
-typedef struct {
-  VENDOR_DEVICE_PATH                     VendorDevice;
-  UINT32                                 Index;         // Suport more than one
-  EFI_DEVICE_PATH_PROTOCOL               End;
-} GDB_SERIAL_DEVICE_PATH;
-
-//
-//  Name:   SERIAL_DEV
-//  Purpose:  To provide device specific information
-//  Fields:
-//      Signature UINTN: The identity of the serial device
-//      SerialIo  SERIAL_IO_PROTOCOL: Serial I/O protocol interface
-//      SerialMode  SERIAL_IO_MODE:
-//      DevicePath  EFI_DEVICE_PATH_PROTOCOL *: Device path of the serial device
-//
-typedef struct {
-  UINTN                                  Signature;
-  EFI_HANDLE                             Handle;
-  EFI_SERIAL_IO_PROTOCOL                 SerialIo;
-  EFI_SERIAL_IO_MODE                     SerialMode;
-  GDB_SERIAL_DEVICE_PATH                 DevicePath;
-  INTN                                   InFileDescriptor;
-  INTN                                   OutFileDescriptor;
-} GDB_SERIAL_DEV;
-
-
-#define GDB_SERIAL_DEV_FROM_THIS(a) CR (a, GDB_SERIAL_DEV, SerialIo, GDB_SERIAL_DEV_SIGNATURE)
-
-
-typedef struct {
-    EFI_EXCEPTION_TYPE  Exception;
-    UINT8               SignalNo;
-} EFI_EXCEPTION_TYPE_ENTRY;
-
-
-#if defined (MDE_CPU_IA32) || defined (MDE_CPU_X64)
-
-//
-// Byte packed structure for DR6
-// 32-bits on IA-32
-// 64-bits on X64.  The upper 32-bits on X64 are reserved
-//
-typedef union {
-  struct {
-    UINT32  B0:1;           // Breakpoint condition detected
-    UINT32  B1:1;           // Breakpoint condition detected
-    UINT32  B2:1;           // Breakpoint condition detected
-    UINT32  B3:1;           // Breakpoint condition detected
-    UINT32  Reserved_1:9;   // Reserved 
-    UINT32  BD:1;           // Debug register access detected
-    UINT32  BS:1;           // Single step
-    UINT32  BT:1;           // Task switch
-    UINT32  Reserved_2:16;  // Reserved
-  } Bits;
-  UINTN     UintN;
-} IA32_DR6;
-
-//
-// Byte packed structure for DR7
-// 32-bits on IA-32
-// 64-bits on X64.  The upper 32-bits on X64 are reserved
-//
-typedef union {
-  struct {
-    UINT32  L0:1;           // Local breakpoint enable
-    UINT32  G0:1;           // Global breakpoint enable
-    UINT32  L1:1;           // Local breakpoint enable
-    UINT32  G1:1;           // Global breakpoint enable
-    UINT32  L2:1;           // Local breakpoint enable
-    UINT32  G2:1;           // Global breakpoint enable
-    UINT32  L3:1;           // Local breakpoint enable
-    UINT32  G3:1;           // Global breakpoint enable
-    UINT32  LE:1;           // Local exact breakpoint enable
-    UINT32  GE:1;           // Global exact breakpoint enable
-    UINT32  Reserved_1:3;   // Reserved
-    UINT32  GD:1;           // Global detect enable
-    UINT32  Reserved_2:2;   // Reserved
-    UINT32  RW0:2;          // Read/Write field
-    UINT32  LEN0:2;         // Length field
-    UINT32  RW1:2;          // Read/Write field
-    UINT32  LEN1:2;         // Length field
-    UINT32  RW2:2;          // Read/Write field
-    UINT32  LEN2:2;         // Length field
-    UINT32  RW3:2;          // Read/Write field
-    UINT32  LEN3:2;         // Length field
-  } Bits;
-  UINTN     UintN;
-} IA32_DR7;
-
-#endif /* if defined (MDE_CPU_IA32) || defined (MDE_CPU_X64) */
-
-typedef enum {
-  InstructionExecution,   //Hardware breakpoint
-  DataWrite,              //watch
-  DataRead,               //rwatch
-  DataReadWrite,          //awatch
-  SoftwareBreakpoint,     //Software breakpoint
-  NotSupported
-} BREAK_TYPE;
-
-//
-// Array of exception types that need to be hooked by the debugger
-//
-extern EFI_EXCEPTION_TYPE_ENTRY gExceptionType[];
-
-//
-// Set TRUE if F Reply package signals a ctrl-c. We can not process the Ctrl-c
-// here we need to wait for the periodic callback to do this. 
-//
-extern BOOLEAN gCtrlCBreakFlag;
-
-//
-// If the periodic callback is called while we are processing an F packet we need
-// to let the callback know to not read from the serail stream as it could steal
-// characters from the F reponse packet
-//
-extern BOOLEAN gProcessingFPacket;
-
-
-// The offsets of registers SystemContext.
-// The fields in the array are in the gdb ordering.
-//
-extern UINTN    gRegisterOffsets[];
-
-/**
- Return the number of entries in the gExceptionType[]
- 
- @retval    UINTN, the number of entries in the gExceptionType[] array.    
- **/
-UINTN
-MaxEfiException (
-  VOID
-  );
-
-
-/**
- Return the number of entries in the gRegisters[]
- 
- @retval    UINTN, the number of entries (registers) in the gRegisters[] array.    
- **/
-UINTN
-MaxRegisterCount (
-  VOID
-  );
-
-
-/**
- Check to see if the ISA is supported. 
- ISA = Instruction Set Architecture
- 
- @retval    TRUE if Isa is supported,
- FALSE otherwise.
- **/
-BOOLEAN
-CheckIsa (
-  IN    EFI_INSTRUCTION_SET_ARCHITECTURE    Isa
-  );
-
-
-/**
- Send the T signal with the given exception type (in gdb order) and possibly with n:r pairs related to the watchpoints
- 
- @param  SystemContext        Register content at time of the exception
- @param  GdbExceptionType     GDB exception type
- **/
-
-VOID
-GdbSendTSignal (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  UINT8	              GdbExceptionType
-  );
-
-
-/**
- Translates the EFI mapping to GDB mapping
- 
- @param     EFIExceptionType        EFI Exception that is being processed
- @retval    UINTN that corresponds to EFIExceptionType's GDB exception type number
- **/
-UINT8
-ConvertEFItoGDBtype ( 
-  IN  EFI_EXCEPTION_TYPE EFIExceptionType
-  );
-
-
-/**
- Empties the given buffer 
- @param *Buf pointer to the first element in buffer to be emptied
- **/
-VOID
-EmptyBuffer ( 
-  IN CHAR8  *Buf
-  );
-
-
-/**
- Converts an 8-bit Hex Char into a INTN.
- 
- @param     Char  - the hex character to be converted into UINTN
- @retval    a INTN, from 0 to 15, that corressponds to Char
- -1 if Char is not a hex character
- **/
-INTN
-HexCharToInt (
-  IN  CHAR8 Char
-  );
-
-
-/** 'E NN'
- Send an error with the given error number after converting to hex.
- The error number is put into the buffer in hex. '255' is the biggest errno we can send.
- ex: 162 will be sent as A2.
- 
- @param   errno    the error number that will be sent
- **/
-VOID
-EFIAPI
-SendError (
-  IN  UINT8     ErrorNum
-  );
-
-
-/**
- Send 'OK' when the function is done executing successfully.
- **/
-VOID
-SendSuccess (
-  VOID
-  );
-
-
-/**
- Send empty packet to specify that particular command/functionality is not supported.
- **/
-VOID
-SendNotSupported (
-  VOID
-  );
-
-/** ‘p n’ 
- Reads the n-th register's value into an output buffer and sends it as a packet 
- @param     SystemContext       Register content at time of the exception
- @param     InBuffer            This is the input buffer received from gdb server
- **/
-VOID
-ReadNthRegister (
-  IN    EFI_SYSTEM_CONTEXT  SystemContext,
-  IN    CHAR8               *InBuffer
-  );
-
-
-/** ‘g’ 
- Reads the general registers into an output buffer  and sends it as a packet 
- @param     SystemContext           Register content at time of the exception
- **/
-VOID
-ReadGeneralRegisters (  
-  IN    EFI_SYSTEM_CONTEXT  SystemContext
-  );
-
-
-/** ‘P n...=r...’
- Writes the new value of n-th register received into the input buffer to the n-th register
- @param     SystemContext       Register content at time of the exception
- @param     InBuffer            This is the input buffer received from gdb server
- **/
-VOID
-WriteNthRegister (
-  IN    EFI_SYSTEM_CONTEXT  SystemContext,
-  IN    CHAR8               *InBuffer
-  );
-
-
-/** ‘G XX...’
- Writes the new values received into the input buffer to the general registers
- @param     SystemContext               Register content at time of the exception
- @param     InBuffer                    Pointer to the input buffer received from gdb server
- **/
-
-VOID
-WriteGeneralRegisters (
-  IN    EFI_SYSTEM_CONTEXT  SystemContext,
-  IN    CHAR8               *InBuffer
-  );
-
-
-/** ‘m addr,length ’
- Find the Length of the area to read and the start addres. Finally, pass them to 
- another function, TransferFromMemToOutBufAndSend, that will read from that memory space and 
- send it as a packet.
- 
- @param  *PacketData  Pointer to Payload data for the packet
- **/
-VOID
-ReadFromMemory (
-  IN  CHAR8  *PacketData
-  );
-
-
-/** ‘M addr,length :XX...’
- Find the Length of the area in bytes to write and the start addres. Finally, pass them to 
- another function, TransferFromInBufToMem, that will write to that memory space the info in
- the input buffer.
- 
- @param   PacketData     Pointer to Payload data for the packet
- **/
-VOID
-WriteToMemory (
-  IN CHAR8 *PacketData
-  );
-
-
-/** ‘c [addr ]’ 
- Continue. addr is Address to resume. If addr is omitted, resume at current 
- Address.
- 
- @param SystemContext Register content at time of the exception  
- @param *PacketData   Pointer to PacketData
- **/
-
-VOID
-ContinueAtAddress (
-  IN  EFI_SYSTEM_CONTEXT   SystemContext,
-  IN  CHAR8                *PacketData
-  );
-
-
-/** ‘s [addr ]’
- Single step. addr is the Address at which to resume. If addr is omitted, resume 
- at same Address.
- 
- @param SystemContext   Register content at time of the exception
- @param PacketData      Pointer to Payload data for the packet
- **/
-VOID
-SingleStep (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  CHAR8               *PacketData
-  );
-
-/** 
- Insert Single Step in the SystemContext
- 
- @param SystemContext   Register content at time of the exception
- **/
-VOID
-AddSingleStep (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext
-  );
-  
-/** 
- Remove Single Step in the SystemContext
- 
- @param SystemContext   Register content at time of the exception
- **/
-VOID
-RemoveSingleStep (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext
-  );
-  
-  
-/**
-  ‘Z1, [addr], [length]’
-  ‘Z2, [addr], [length]’
-  ‘Z3, [addr], [length]’
-  ‘Z4, [addr], [length]’
-
-  Insert hardware breakpoint/watchpoint at address addr of size length
-
-  @param SystemContext  Register content at time of the exception
-  @param *PacketData    Pointer to the Payload data for the packet
-
-**/
-VOID
-EFIAPI
-InsertBreakPoint(
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  CHAR8               *PacketData
-  );
-
-
-/**
-  ‘z1, [addr], [length]’
-  ‘z2, [addr], [length]’
-  ‘z3, [addr], [length]’
-  ‘z4, [addr], [length]’
-
-  Remove hardware breakpoint/watchpoint at address addr of size length
-
-  @param SystemContext  Register content at time of the exception
-  @param *PacketData    Pointer to the Payload data for the packet
-
-**/
-VOID
-EFIAPI
-RemoveBreakPoint(
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  CHAR8               *PacketData
-  );
-
-
-/**
- Exception Hanldler for GDB. It will be called for all exceptions
- registered via the gExceptionType[] array.
- 
- @param ExceptionType   Exception that is being processed
- @param SystemContext   Register content at time of the exception  
- 
- **/
-VOID
-EFIAPI
-GdbExceptionHandler ( 
-  IN     EFI_EXCEPTION_TYPE  ExceptionType, 
-  IN OUT EFI_SYSTEM_CONTEXT  SystemContext 
-  );
-
-
-/**
- Periodic callback for GDB. This function is used to catch a ctrl-c or other 
- break in type command from GDB.
- 
- @param SystemContext           Register content at time of the call
- 
- **/
-VOID
-EFIAPI
-GdbPeriodicCallBack ( 
-  IN OUT EFI_SYSTEM_CONTEXT  SystemContext 
-  );
-
-
-/**
-  Make two serail consoles: 1) StdIn and StdOut via GDB. 2) StdErr via GDB.
-  
-  These console show up on the remote system running GDB
-
-**/
-
-VOID
-GdbInitializeSerialConsole (
-  VOID
-  );
-
-
-/**
-  Send a GDB Remote Serial Protocol Packet
-  
-  $PacketData#checksum PacketData is passed in and this function adds the packet prefix '$', 
-  the packet teminating character '#' and the two digit checksum.
-  
-  If an ack '+' is not sent resend the packet, but timeout eventually so we don't end up 
-  in an infinit loop. This is so if you unplug the debugger code just keeps running
-
-  @param PacketData   Payload data for the packet  
-  
-  @retval             Number of bytes of packet data sent.
-
-**/
-UINTN
-SendPacket (
-  IN  CHAR8 *PacketData
-  );
-  
-
-/**
- Receive a GDB Remote Serial Protocol Packet
- 
- $PacketData#checksum PacketData is passed in and this function adds the packet prefix '$', 
- the packet teminating character '#' and the two digit checksum.
- 
- If host re-starts sending a packet without ending the previous packet, only the last valid packet is proccessed.
- (In other words, if received packet is '$12345$12345$123456#checksum', only '$123456#checksum' will be processed.)
- 
- If an ack '+' is not sent resend the packet
- 
- @param PacketData   Payload data for the packet  
- 
- @retval             Number of bytes of packet data received.
-
- **/
-UINTN
-ReceivePacket (
- OUT  CHAR8 *PacketData,
- IN   UINTN PacketDataSize
- );
-  
-
-/**
-  Read data from a FileDescriptor. On success number of bytes read is returned. Zero indicates 
-  the end of a file. On error -1 is returned. If count is zero, GdbRead returns zero.
-
-  @param  FileDescriptor   Device to talk to.
-  @param  Buffer           Buffer to hold Count bytes that were read
-  @param  Count            Number of bytes to transfer. 
-
-  @retval -1               Error
-  @retval {other}          Number of bytes read.
-
-**/
-INTN
-GdbRead (
-  IN  INTN    FileDescriptor,
-  OUT VOID    *Buffer,
-  IN  UINTN   Count
-  );
-  
-
-/**
-  Write data to a FileDescriptor. On success number of bytes written is returned. Zero indicates 
-  nothing was written. On error -1 is returned. 
-
-  @param  FileDescriptor   Device to talk to.
-  @param  Buffer           Buffer to hold Count bytes that are to be written
-  @param  Count            Number of bytes to transfer. 
-
-  @retval -1               Error
-  @retval {other}          Number of bytes written.
-
-**/
-INTN
-GdbWrite (
-  IN  INTN          FileDescriptor,
-  OUT CONST VOID    *Buffer,
-  IN  UINTN         Count
-  );
-
-UINTN *  
-FindPointerToRegister (
-  IN  EFI_SYSTEM_CONTEXT    SystemContext,
-  IN  UINTN                 RegNumber  
-  );
-
-CHAR8 * 
-BasicReadRegister (
-  IN  EFI_SYSTEM_CONTEXT      SystemContext,
-  IN  UINTN                   RegNumber,
-  IN  CHAR8                   *OutBufPtr
-  );
-
-VOID
-TransferFromInBufToMem (
-  IN  UINTN   Length,
-  IN  UINT8   *Address,
-  IN  CHAR8   *NewData
-  );
-
-VOID
-TransferFromMemToOutBufAndSend (
-  IN  UINTN  Length,
-  IN  UINT8  *Address
-  );
-
-CHAR8 *
-BasicWriteRegister (
-  IN  EFI_SYSTEM_CONTEXT    SystemContext,
-  IN  UINTN                 RegNumber,
-  IN  CHAR8                 *InBufPtr
-  );
-
-VOID  
-PrintReg (
-  EFI_SYSTEM_CONTEXT SystemContext
-  );
-
-UINTN
-ParseBreakpointPacket (
-  IN  CHAR8 *PacketData,
-  OUT UINTN *Type,
-  OUT UINTN *Address,
-  OUT UINTN *Length
-  );
-
-UINTN
-GetBreakpointDataAddress (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  UINTN               BreakpointNumber 
-  );
-
-UINTN
-GetBreakpointDetected (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext
-  );
-
-BREAK_TYPE
-GetBreakpointType (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  UINTN               BreakpointNumber  
-  );
-
-UINTN
-ConvertLengthData (
-  IN  UINTN  Length
-  );
-
-EFI_STATUS
-FindNextFreeDebugRegister (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  OUT UINTN               *Register
-  );
-
-EFI_STATUS
-EnableDebugRegister (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  UINTN               Register,
-  IN  UINTN               Address,
-  IN  UINTN               Length,
-  IN  UINTN               Type
-  );
-
-EFI_STATUS
-FindMatchingDebugRegister (
- IN  EFI_SYSTEM_CONTEXT  SystemContext,
- IN  UINTN               Address,
- IN  UINTN               Length,
- IN  UINTN               Type,
- OUT UINTN               *Register
- );
-
-EFI_STATUS
-DisableDebugRegister (
- IN  EFI_SYSTEM_CONTEXT  SystemContext,
- IN  UINTN               Register
- );
-
-VOID
-InitializeProcessor (
-  VOID
-  );
-
-BOOLEAN
-ValidateAddress (
-  IN  VOID  *Address
-  );
-
-BOOLEAN
-ValidateException (
-  IN  EFI_EXCEPTION_TYPE    ExceptionType, 
-  IN OUT EFI_SYSTEM_CONTEXT SystemContext 
-  );
-
-#endif
+/** @file

+  Private include file for GDB stub

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __GDB_STUB_INTERNAL__

+#define __GDB_STUB_INTERNAL__

+

+#include <Uefi.h>

+#include <Library/BaseLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/MemoryAllocationLib.h>

+#include <Library/DebugLib.h>

+#include <Library/UefiLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/PcdLib.h>

+#include <Library/GdbSerialLib.h>

+#include <Library/PrintLib.h>

+

+#include <Protocol/DebugSupport.h>

+#include <Protocol/SerialIo.h>

+#include <Protocol/LoadedImage.h>

+#include <Protocol/LoadedImage.h>

+#include <Guid/DebugImageInfoTable.h>

+#include <IndustryStandard/PeImage.h>

+

+extern CONST CHAR8 mHexToStr[];

+

+// maximum size of input and output buffers

+// This value came from the show remote command of the gdb we tested against 

+#define MAX_BUF_SIZE 2000

+

+// maximum size of address buffer

+#define MAX_ADDR_SIZE 32

+

+// maximum size of register number buffer

+#define MAX_REG_NUM_BUF_SIZE 32

+

+// maximum size of length buffer

+#define MAX_LENGTH_SIZE 32

+

+// maximum size of T signal members

+#define MAX_T_SIGNAL_SIZE 64

+

+// the mask used to clear all the cache

+#define TF_BIT 0x00000100

+

+

+//

+// GDB Signal definitions - generic names for interrupts

+//

+#define GDB_SIGILL      4  // Illegal instruction       

+#define GDB_SIGTRAP     5  // Trace Trap (Breakpoint and SingleStep)

+#define GDB_SIGEMT      7  // Emulator Trap

+#define GDB_SIGFPE      8  // Floating point exception

+#define GDB_SIGSEGV     11 // Segment violation, page fault

+

+

+//

+// GDB File I/O Error values, zero means no error

+// Includes all general GDB Unix like error values

+//

+#define GDB_EBADMEMADDRBUFSIZE   11  // the buffer that stores memory Address to be read from/written to is not the right size

+#define GDB_EBADMEMLENGBUFSIZE   12  // the buffer that stores Length is not the right size 

+#define GDB_EBADMEMLENGTH        13  // Length, the given number of bytes to read or write, is not the right size

+#define GDB_EBADMEMDATA          14  // one of the bytes or nibbles of the memory is leess than 0 

+#define GDB_EBADMEMDATASIZE      15  // the memory data, 'XX..', is too short or too long

+#define GDB_EBADBUFSIZE          21  // the buffer created is not the correct size

+#define GDB_EINVALIDARG          31  // argument is invalid

+#define GDB_ENOSPACE             41  //

+#define GDB_EINVALIDBRKPOINTTYPE 51  // the breakpoint type is not recognized

+#define GDB_EINVALIDREGNUM       61  // given register number is not valid: either <0 or >=Number of Registers

+#define GDB_EUNKNOWN             255 // unknown

+

+

+//

+// These devices are open by GDB so we can just read and write to them

+//

+#define GDB_STDIN   0x00

+#define GDB_STDOUT  0x01

+#define GDB_STDERR  0x02

+

+//

+//Define Register size for different architectures

+//

+#if defined (MDE_CPU_IA32) 

+#define REG_SIZE  32

+#elif defined (MDE_CPU_X64)

+#define REG_SIZE  64

+#elif defined (MDE_CPU_ARM)

+#define REG_SIZE  32

+#endif

+

+#define GDB_SERIAL_DEV_SIGNATURE    SIGNATURE_32 ('g', 'd', 'b', 's')

+

+typedef struct {

+  VENDOR_DEVICE_PATH                     VendorDevice;

+  UINT32                                 Index;         // Suport more than one

+  EFI_DEVICE_PATH_PROTOCOL               End;

+} GDB_SERIAL_DEVICE_PATH;

+

+//

+//  Name:   SERIAL_DEV

+//  Purpose:  To provide device specific information

+//  Fields:

+//      Signature UINTN: The identity of the serial device

+//      SerialIo  SERIAL_IO_PROTOCOL: Serial I/O protocol interface

+//      SerialMode  SERIAL_IO_MODE:

+//      DevicePath  EFI_DEVICE_PATH_PROTOCOL *: Device path of the serial device

+//

+typedef struct {

+  UINTN                                  Signature;

+  EFI_HANDLE                             Handle;

+  EFI_SERIAL_IO_PROTOCOL                 SerialIo;

+  EFI_SERIAL_IO_MODE                     SerialMode;

+  GDB_SERIAL_DEVICE_PATH                 DevicePath;

+  INTN                                   InFileDescriptor;

+  INTN                                   OutFileDescriptor;

+} GDB_SERIAL_DEV;

+

+

+#define GDB_SERIAL_DEV_FROM_THIS(a) CR (a, GDB_SERIAL_DEV, SerialIo, GDB_SERIAL_DEV_SIGNATURE)

+

+

+typedef struct {

+    EFI_EXCEPTION_TYPE  Exception;

+    UINT8               SignalNo;

+} EFI_EXCEPTION_TYPE_ENTRY;

+

+

+#if defined (MDE_CPU_IA32) || defined (MDE_CPU_X64)

+

+//

+// Byte packed structure for DR6

+// 32-bits on IA-32

+// 64-bits on X64.  The upper 32-bits on X64 are reserved

+//

+typedef union {

+  struct {

+    UINT32  B0:1;           // Breakpoint condition detected

+    UINT32  B1:1;           // Breakpoint condition detected

+    UINT32  B2:1;           // Breakpoint condition detected

+    UINT32  B3:1;           // Breakpoint condition detected

+    UINT32  Reserved_1:9;   // Reserved 

+    UINT32  BD:1;           // Debug register access detected

+    UINT32  BS:1;           // Single step

+    UINT32  BT:1;           // Task switch

+    UINT32  Reserved_2:16;  // Reserved

+  } Bits;

+  UINTN     UintN;

+} IA32_DR6;

+

+//

+// Byte packed structure for DR7

+// 32-bits on IA-32

+// 64-bits on X64.  The upper 32-bits on X64 are reserved

+//

+typedef union {

+  struct {

+    UINT32  L0:1;           // Local breakpoint enable

+    UINT32  G0:1;           // Global breakpoint enable

+    UINT32  L1:1;           // Local breakpoint enable

+    UINT32  G1:1;           // Global breakpoint enable

+    UINT32  L2:1;           // Local breakpoint enable

+    UINT32  G2:1;           // Global breakpoint enable

+    UINT32  L3:1;           // Local breakpoint enable

+    UINT32  G3:1;           // Global breakpoint enable

+    UINT32  LE:1;           // Local exact breakpoint enable

+    UINT32  GE:1;           // Global exact breakpoint enable

+    UINT32  Reserved_1:3;   // Reserved

+    UINT32  GD:1;           // Global detect enable

+    UINT32  Reserved_2:2;   // Reserved

+    UINT32  RW0:2;          // Read/Write field

+    UINT32  LEN0:2;         // Length field

+    UINT32  RW1:2;          // Read/Write field

+    UINT32  LEN1:2;         // Length field

+    UINT32  RW2:2;          // Read/Write field

+    UINT32  LEN2:2;         // Length field

+    UINT32  RW3:2;          // Read/Write field

+    UINT32  LEN3:2;         // Length field

+  } Bits;

+  UINTN     UintN;

+} IA32_DR7;

+

+#endif /* if defined (MDE_CPU_IA32) || defined (MDE_CPU_X64) */

+

+typedef enum {

+  InstructionExecution,   //Hardware breakpoint

+  DataWrite,              //watch

+  DataRead,               //rwatch

+  DataReadWrite,          //awatch

+  SoftwareBreakpoint,     //Software breakpoint

+  NotSupported

+} BREAK_TYPE;

+

+//

+// Array of exception types that need to be hooked by the debugger

+//

+extern EFI_EXCEPTION_TYPE_ENTRY gExceptionType[];

+

+//

+// Set TRUE if F Reply package signals a ctrl-c. We can not process the Ctrl-c

+// here we need to wait for the periodic callback to do this. 

+//

+extern BOOLEAN gCtrlCBreakFlag;

+

+//

+// If the periodic callback is called while we are processing an F packet we need

+// to let the callback know to not read from the serail stream as it could steal

+// characters from the F reponse packet

+//

+extern BOOLEAN gProcessingFPacket;

+

+

+// The offsets of registers SystemContext.

+// The fields in the array are in the gdb ordering.

+//

+extern UINTN    gRegisterOffsets[];

+

+/**

+ Return the number of entries in the gExceptionType[]

+ 

+ @retval    UINTN, the number of entries in the gExceptionType[] array.    

+ **/

+UINTN

+MaxEfiException (

+  VOID

+  );

+

+

+/**

+ Return the number of entries in the gRegisters[]

+ 

+ @retval    UINTN, the number of entries (registers) in the gRegisters[] array.    

+ **/

+UINTN

+MaxRegisterCount (

+  VOID

+  );

+

+

+/**

+ Check to see if the ISA is supported. 

+ ISA = Instruction Set Architecture

+ 

+ @retval    TRUE if Isa is supported,

+ FALSE otherwise.

+ **/

+BOOLEAN

+CheckIsa (

+  IN    EFI_INSTRUCTION_SET_ARCHITECTURE    Isa

+  );

+

+

+/**

+ Send the T signal with the given exception type (in gdb order) and possibly with n:r pairs related to the watchpoints

+ 

+ @param  SystemContext        Register content at time of the exception

+ @param  GdbExceptionType     GDB exception type

+ **/

+

+VOID

+GdbSendTSignal (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  UINT8	              GdbExceptionType

+  );

+

+

+/**

+ Translates the EFI mapping to GDB mapping

+ 

+ @param     EFIExceptionType        EFI Exception that is being processed

+ @retval    UINTN that corresponds to EFIExceptionType's GDB exception type number

+ **/

+UINT8

+ConvertEFItoGDBtype ( 

+  IN  EFI_EXCEPTION_TYPE EFIExceptionType

+  );

+

+

+/**

+ Empties the given buffer 

+ @param *Buf pointer to the first element in buffer to be emptied

+ **/

+VOID

+EmptyBuffer ( 

+  IN CHAR8  *Buf

+  );

+

+

+/**

+ Converts an 8-bit Hex Char into a INTN.

+ 

+ @param     Char  - the hex character to be converted into UINTN

+ @retval    a INTN, from 0 to 15, that corressponds to Char

+ -1 if Char is not a hex character

+ **/

+INTN

+HexCharToInt (

+  IN  CHAR8 Char

+  );

+

+

+/** 'E NN'

+ Send an error with the given error number after converting to hex.

+ The error number is put into the buffer in hex. '255' is the biggest errno we can send.

+ ex: 162 will be sent as A2.

+ 

+ @param   errno    the error number that will be sent

+ **/

+VOID

+EFIAPI

+SendError (

+  IN  UINT8     ErrorNum

+  );

+

+

+/**

+ Send 'OK' when the function is done executing successfully.

+ **/

+VOID

+SendSuccess (

+  VOID

+  );

+

+

+/**

+ Send empty packet to specify that particular command/functionality is not supported.

+ **/

+VOID

+SendNotSupported (

+  VOID

+  );

+

+/** ‘p n’ 

+ Reads the n-th register's value into an output buffer and sends it as a packet 

+ @param     SystemContext       Register content at time of the exception

+ @param     InBuffer            This is the input buffer received from gdb server

+ **/

+VOID

+ReadNthRegister (

+  IN    EFI_SYSTEM_CONTEXT  SystemContext,

+  IN    CHAR8               *InBuffer

+  );

+

+

+/** ‘g’ 

+ Reads the general registers into an output buffer  and sends it as a packet 

+ @param     SystemContext           Register content at time of the exception

+ **/

+VOID

+ReadGeneralRegisters (  

+  IN    EFI_SYSTEM_CONTEXT  SystemContext

+  );

+

+

+/** ‘P n...=r...’

+ Writes the new value of n-th register received into the input buffer to the n-th register

+ @param     SystemContext       Register content at time of the exception

+ @param     InBuffer            This is the input buffer received from gdb server

+ **/

+VOID

+WriteNthRegister (

+  IN    EFI_SYSTEM_CONTEXT  SystemContext,

+  IN    CHAR8               *InBuffer

+  );

+

+

+/** ‘G XX...’

+ Writes the new values received into the input buffer to the general registers

+ @param     SystemContext               Register content at time of the exception

+ @param     InBuffer                    Pointer to the input buffer received from gdb server

+ **/

+

+VOID

+WriteGeneralRegisters (

+  IN    EFI_SYSTEM_CONTEXT  SystemContext,

+  IN    CHAR8               *InBuffer

+  );

+

+

+/** ‘m addr,length ’

+ Find the Length of the area to read and the start addres. Finally, pass them to 

+ another function, TransferFromMemToOutBufAndSend, that will read from that memory space and 

+ send it as a packet.

+ 

+ @param  *PacketData  Pointer to Payload data for the packet

+ **/

+VOID

+ReadFromMemory (

+  IN  CHAR8  *PacketData

+  );

+

+

+/** ‘M addr,length :XX...’

+ Find the Length of the area in bytes to write and the start addres. Finally, pass them to 

+ another function, TransferFromInBufToMem, that will write to that memory space the info in

+ the input buffer.

+ 

+ @param   PacketData     Pointer to Payload data for the packet

+ **/

+VOID

+WriteToMemory (

+  IN CHAR8 *PacketData

+  );

+

+

+/** ‘c [addr ]’ 

+ Continue. addr is Address to resume. If addr is omitted, resume at current 

+ Address.

+ 

+ @param SystemContext Register content at time of the exception  

+ @param *PacketData   Pointer to PacketData

+ **/

+

+VOID

+ContinueAtAddress (

+  IN  EFI_SYSTEM_CONTEXT   SystemContext,

+  IN  CHAR8                *PacketData

+  );

+

+

+/** ‘s [addr ]’

+ Single step. addr is the Address at which to resume. If addr is omitted, resume 

+ at same Address.

+ 

+ @param SystemContext   Register content at time of the exception

+ @param PacketData      Pointer to Payload data for the packet

+ **/

+VOID

+SingleStep (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  CHAR8               *PacketData

+  );

+

+/** 

+ Insert Single Step in the SystemContext

+ 

+ @param SystemContext   Register content at time of the exception

+ **/

+VOID

+AddSingleStep (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext

+  );

+  

+/** 

+ Remove Single Step in the SystemContext

+ 

+ @param SystemContext   Register content at time of the exception

+ **/

+VOID

+RemoveSingleStep (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext

+  );

+  

+  

+/**

+  ‘Z1, [addr], [length]’

+  ‘Z2, [addr], [length]’

+  ‘Z3, [addr], [length]’

+  ‘Z4, [addr], [length]’

+

+  Insert hardware breakpoint/watchpoint at address addr of size length

+

+  @param SystemContext  Register content at time of the exception

+  @param *PacketData    Pointer to the Payload data for the packet

+

+**/

+VOID

+EFIAPI

+InsertBreakPoint(

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  CHAR8               *PacketData

+  );

+

+

+/**

+  ‘z1, [addr], [length]’

+  ‘z2, [addr], [length]’

+  ‘z3, [addr], [length]’

+  ‘z4, [addr], [length]’

+

+  Remove hardware breakpoint/watchpoint at address addr of size length

+

+  @param SystemContext  Register content at time of the exception

+  @param *PacketData    Pointer to the Payload data for the packet

+

+**/

+VOID

+EFIAPI

+RemoveBreakPoint(

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  CHAR8               *PacketData

+  );

+

+

+/**

+ Exception Hanldler for GDB. It will be called for all exceptions

+ registered via the gExceptionType[] array.

+ 

+ @param ExceptionType   Exception that is being processed

+ @param SystemContext   Register content at time of the exception  

+ 

+ **/

+VOID

+EFIAPI

+GdbExceptionHandler ( 

+  IN     EFI_EXCEPTION_TYPE  ExceptionType, 

+  IN OUT EFI_SYSTEM_CONTEXT  SystemContext 

+  );

+

+

+/**

+ Periodic callback for GDB. This function is used to catch a ctrl-c or other 

+ break in type command from GDB.

+ 

+ @param SystemContext           Register content at time of the call

+ 

+ **/

+VOID

+EFIAPI

+GdbPeriodicCallBack ( 

+  IN OUT EFI_SYSTEM_CONTEXT  SystemContext 

+  );

+

+

+/**

+  Make two serail consoles: 1) StdIn and StdOut via GDB. 2) StdErr via GDB.

+  

+  These console show up on the remote system running GDB

+

+**/

+

+VOID

+GdbInitializeSerialConsole (

+  VOID

+  );

+

+

+/**

+  Send a GDB Remote Serial Protocol Packet

+  

+  $PacketData#checksum PacketData is passed in and this function adds the packet prefix '$', 

+  the packet teminating character '#' and the two digit checksum.

+  

+  If an ack '+' is not sent resend the packet, but timeout eventually so we don't end up 

+  in an infinit loop. This is so if you unplug the debugger code just keeps running

+

+  @param PacketData   Payload data for the packet  

+  

+  @retval             Number of bytes of packet data sent.

+

+**/

+UINTN

+SendPacket (

+  IN  CHAR8 *PacketData

+  );

+  

+

+/**

+ Receive a GDB Remote Serial Protocol Packet

+ 

+ $PacketData#checksum PacketData is passed in and this function adds the packet prefix '$', 

+ the packet teminating character '#' and the two digit checksum.

+ 

+ If host re-starts sending a packet without ending the previous packet, only the last valid packet is proccessed.

+ (In other words, if received packet is '$12345$12345$123456#checksum', only '$123456#checksum' will be processed.)

+ 

+ If an ack '+' is not sent resend the packet

+ 

+ @param PacketData   Payload data for the packet  

+ 

+ @retval             Number of bytes of packet data received.

+

+ **/

+UINTN

+ReceivePacket (

+ OUT  CHAR8 *PacketData,

+ IN   UINTN PacketDataSize

+ );

+  

+

+/**

+  Read data from a FileDescriptor. On success number of bytes read is returned. Zero indicates 

+  the end of a file. On error -1 is returned. If count is zero, GdbRead returns zero.

+

+  @param  FileDescriptor   Device to talk to.

+  @param  Buffer           Buffer to hold Count bytes that were read

+  @param  Count            Number of bytes to transfer. 

+

+  @retval -1               Error

+  @retval {other}          Number of bytes read.

+

+**/

+INTN

+GdbRead (

+  IN  INTN    FileDescriptor,

+  OUT VOID    *Buffer,

+  IN  UINTN   Count

+  );

+  

+

+/**

+  Write data to a FileDescriptor. On success number of bytes written is returned. Zero indicates 

+  nothing was written. On error -1 is returned. 

+

+  @param  FileDescriptor   Device to talk to.

+  @param  Buffer           Buffer to hold Count bytes that are to be written

+  @param  Count            Number of bytes to transfer. 

+

+  @retval -1               Error

+  @retval {other}          Number of bytes written.

+

+**/

+INTN

+GdbWrite (

+  IN  INTN          FileDescriptor,

+  OUT CONST VOID    *Buffer,

+  IN  UINTN         Count

+  );

+

+UINTN *  

+FindPointerToRegister (

+  IN  EFI_SYSTEM_CONTEXT    SystemContext,

+  IN  UINTN                 RegNumber  

+  );

+

+CHAR8 * 

+BasicReadRegister (

+  IN  EFI_SYSTEM_CONTEXT      SystemContext,

+  IN  UINTN                   RegNumber,

+  IN  CHAR8                   *OutBufPtr

+  );

+

+VOID

+TransferFromInBufToMem (

+  IN  UINTN   Length,

+  IN  UINT8   *Address,

+  IN  CHAR8   *NewData

+  );

+

+VOID

+TransferFromMemToOutBufAndSend (

+  IN  UINTN  Length,

+  IN  UINT8  *Address

+  );

+

+CHAR8 *

+BasicWriteRegister (

+  IN  EFI_SYSTEM_CONTEXT    SystemContext,

+  IN  UINTN                 RegNumber,

+  IN  CHAR8                 *InBufPtr

+  );

+

+VOID  

+PrintReg (

+  EFI_SYSTEM_CONTEXT SystemContext

+  );

+

+UINTN

+ParseBreakpointPacket (

+  IN  CHAR8 *PacketData,

+  OUT UINTN *Type,

+  OUT UINTN *Address,

+  OUT UINTN *Length

+  );

+

+UINTN

+GetBreakpointDataAddress (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  UINTN               BreakpointNumber 

+  );

+

+UINTN

+GetBreakpointDetected (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext

+  );

+

+BREAK_TYPE

+GetBreakpointType (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  UINTN               BreakpointNumber  

+  );

+

+UINTN

+ConvertLengthData (

+  IN  UINTN  Length

+  );

+

+EFI_STATUS

+FindNextFreeDebugRegister (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  OUT UINTN               *Register

+  );

+

+EFI_STATUS

+EnableDebugRegister (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  UINTN               Register,

+  IN  UINTN               Address,

+  IN  UINTN               Length,

+  IN  UINTN               Type

+  );

+

+EFI_STATUS

+FindMatchingDebugRegister (

+ IN  EFI_SYSTEM_CONTEXT  SystemContext,

+ IN  UINTN               Address,

+ IN  UINTN               Length,

+ IN  UINTN               Type,

+ OUT UINTN               *Register

+ );

+

+EFI_STATUS

+DisableDebugRegister (

+ IN  EFI_SYSTEM_CONTEXT  SystemContext,

+ IN  UINTN               Register

+ );

+

+VOID

+InitializeProcessor (

+  VOID

+  );

+

+BOOLEAN

+ValidateAddress (

+  IN  VOID  *Address

+  );

+

+BOOLEAN

+ValidateException (

+  IN  EFI_EXCEPTION_TYPE    ExceptionType, 

+  IN OUT EFI_SYSTEM_CONTEXT SystemContext 

+  );

+

+#endif

diff --git a/EmbeddedPkg/GdbStub/Ia32/Processor.c b/EmbeddedPkg/GdbStub/Ia32/Processor.c
index 442faea0..e327b3e6 100644
--- a/EmbeddedPkg/GdbStub/Ia32/Processor.c
+++ b/EmbeddedPkg/GdbStub/Ia32/Processor.c
@@ -1,993 +1,993 @@
-/** @file
-  Processor specific parts of the GDB stub
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include <GdbStubInternal.h>
-
-//
-// Array of exception types that need to be hooked by the debugger
-// {EFI mapping, GDB mapping}
-//
-EFI_EXCEPTION_TYPE_ENTRY gExceptionType[] = {
-  { EXCEPT_IA32_DIVIDE_ERROR,     GDB_SIGFPE  }, 
-  { EXCEPT_IA32_DEBUG,            GDB_SIGTRAP },
-  { EXCEPT_IA32_NMI,              GDB_SIGEMT  },
-  { EXCEPT_IA32_BREAKPOINT,       GDB_SIGTRAP },
-  { EXCEPT_IA32_OVERFLOW,         GDB_SIGSEGV },
-  { EXCEPT_IA32_BOUND,            GDB_SIGSEGV },
-  { EXCEPT_IA32_INVALID_OPCODE,   GDB_SIGILL  },
-  { EXCEPT_IA32_DOUBLE_FAULT,     GDB_SIGEMT  },
-  { EXCEPT_IA32_STACK_FAULT,      GDB_SIGSEGV },
-  { EXCEPT_IA32_GP_FAULT,         GDB_SIGSEGV },
-  { EXCEPT_IA32_PAGE_FAULT,       GDB_SIGSEGV },
-  { EXCEPT_IA32_FP_ERROR,         GDB_SIGEMT  },
-  { EXCEPT_IA32_ALIGNMENT_CHECK,  GDB_SIGEMT  },
-  { EXCEPT_IA32_MACHINE_CHECK,    GDB_SIGEMT  }
-};
-
-
-// The offsets of registers SystemContext.
-// The fields in the array are in the gdb ordering.
-//
-//16 regs
-UINTN gRegisterOffsets[] = {
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Eax),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Ecx),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Edx),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Ebx),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Esp),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Ebp),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Esi),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Edi),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Eip),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Eflags),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Cs),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Ss),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Ds),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Es),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Fs),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Gs)
-};
-
-
-//Debug only..
-VOID 
-PrintReg (
-  IN EFI_SYSTEM_CONTEXT SystemContext
-  )
-{
-  Print ((CHAR16 *)L"EAX: %x ", SystemContext.SystemContextIa32->Eax);
-  Print ((CHAR16 *)L"ECX: %x ", SystemContext.SystemContextIa32->Ecx);
-  Print ((CHAR16 *)L"EDX: %x ", SystemContext.SystemContextIa32->Edx);
-  Print ((CHAR16 *)L"EBX: %x ", SystemContext.SystemContextIa32->Ebx);
-  Print ((CHAR16 *)L"ESP: %x ", SystemContext.SystemContextIa32->Esp);
-  Print ((CHAR16 *)L"EBP: %x ", SystemContext.SystemContextIa32->Ebp);
-  Print ((CHAR16 *)L"ESI: %x ", SystemContext.SystemContextIa32->Esi);
-  Print ((CHAR16 *)L"EDI: %x ", SystemContext.SystemContextIa32->Edi);
-  Print ((CHAR16 *)L"EIP: %x\n", SystemContext.SystemContextIa32->Eip);
-  Print ((CHAR16 *)L"EFlags: %x\n", SystemContext.SystemContextIa32->Eflags);
-}
-
-//Debug only..
-VOID 
-PrintDRreg (
-  IN EFI_SYSTEM_CONTEXT SystemContext
-  )
-{
-  Print ((CHAR16 *)L"DR0: %x ", SystemContext.SystemContextIa32->Dr0);
-  Print ((CHAR16 *)L"DR1: %x ", SystemContext.SystemContextIa32->Dr1);
-  Print ((CHAR16 *)L"DR2: %x ", SystemContext.SystemContextIa32->Dr2);
-  Print ((CHAR16 *)L"DR3: %x ", SystemContext.SystemContextIa32->Dr3);
-  Print ((CHAR16 *)L"DR6: %x ", SystemContext.SystemContextIa32->Dr6);
-  Print ((CHAR16 *)L"DR7: %x\n", SystemContext.SystemContextIa32->Dr7);
-}
-
-
-/**
- Return the number of entries in the gExceptionType[]
- 
- @retval  UINTN, the number of entries in the gExceptionType[] array.    
- **/
-UINTN
-MaxEfiException (
-  VOID
-  )
-{
-  return sizeof (gExceptionType)/sizeof (EFI_EXCEPTION_TYPE_ENTRY);
-}
-
-
-/**
- Return the number of entries in the gRegisters[]
- 
- @retval  UINTN, the number of entries (registers) in the gRegisters[] array.    
- **/
-UINTN
-MaxRegisterCount (
-  VOID
-  )
-{
-  return sizeof (gRegisterOffsets)/sizeof (UINTN);
-}
-
-
-/**
-  Check to see if the ISA is supported. 
-  ISA = Instruction Set Architecture
- 
-  @retval TRUE if Isa is supported,
-      FALSE otherwise.
-**/
-BOOLEAN
-CheckIsa (
-  IN  EFI_INSTRUCTION_SET_ARCHITECTURE  Isa
-  )
-{
-  return (BOOLEAN)(Isa == IsaIa32);
-}
-
-
-/**
- This takes in the register number and the System Context, and returns a pointer to the RegNumber-th register in gdb ordering
- It is, by default, set to find the register pointer of the IA32 member
-
- @param   SystemContext     Register content at time of the exception 
- @param   RegNumber       The register to which we want to find a pointer
- @retval  the pointer to the RegNumber-th pointer
- **/
-UINTN *
-FindPointerToRegister(
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  UINTN               RegNumber  
-  )
-{
-  UINT8 *TempPtr;
-  TempPtr = ((UINT8 *)SystemContext.SystemContextIa32) + gRegisterOffsets[RegNumber];
-  return (UINTN *)TempPtr;
-}
-
-
-/**
- Adds the RegNumber-th register's value to the output buffer, starting at the given OutBufPtr
-
- @param SystemContext     Register content at time of the exception
- @param   RegNumber       the number of the register that we want to read
- @param   OutBufPtr       pointer to the output buffer's end. the new data will be added from this point on.
- @retval  the pointer to the next character of the output buffer that is available to be written on.
- **/
-CHAR8 *
-BasicReadRegister (
-  IN  EFI_SYSTEM_CONTEXT      SystemContext,
-  IN  UINTN           RegNumber,
-  IN  CHAR8           *OutBufPtr
-  )
-{
-  UINTN RegSize;
-  
-  RegSize = 0;
-  while (RegSize < REG_SIZE) {
-    *OutBufPtr++ = mHexToStr[((*FindPointerToRegister(SystemContext, RegNumber) >> (RegSize+4)) & 0xf)];
-    *OutBufPtr++ = mHexToStr[((*FindPointerToRegister(SystemContext, RegNumber) >> RegSize) & 0xf)];
-    RegSize = RegSize + 8;
-  }
-  return OutBufPtr;
-}
-
-
-/** ‘p n’ 
- Reads the n-th register's value into an output buffer and sends it as a packet 
-
- @param   SystemContext   Register content at time of the exception
- @param   InBuffer      Pointer to the input buffer received from gdb server
- **/
-VOID
-EFIAPI
-ReadNthRegister (
-  IN  EFI_SYSTEM_CONTEXT   SystemContext,
-  IN  CHAR8                *InBuffer
-  )
-{
-  UINTN RegNumber;
-  CHAR8 OutBuffer[9]; // 1 reg=8 hex chars, and the end '\0' (escape seq)
-  CHAR8 *OutBufPtr;   // pointer to the output buffer
-  
-  RegNumber = AsciiStrHexToUintn (&InBuffer[1]);
-
-  if ((RegNumber < 0) || (RegNumber >= MaxRegisterCount())) {
-    SendError (GDB_EINVALIDREGNUM);
-    return;
-  }
-
-  OutBufPtr = OutBuffer;
-  OutBufPtr = BasicReadRegister(SystemContext, RegNumber, OutBufPtr);
-
-  *OutBufPtr = '\0';  // the end of the buffer
-  SendPacket(OutBuffer);
-}
-
-
-/** ‘g’ 
- Reads the general registers into an output buffer  and sends it as a packet 
-
- @param   SystemContext     Register content at time of the exception
- **/
-VOID
-EFIAPI
-ReadGeneralRegisters (  
-  IN  EFI_SYSTEM_CONTEXT      SystemContext
-  )
-{
-  UINTN   i;
-  CHAR8 OutBuffer[129]; // 16 regs, 8 hex chars each, and the end '\0' (escape seq)
-  CHAR8 *OutBufPtr;   // pointer to the output buffer
-
-  OutBufPtr = OutBuffer;
-  for(i = 0 ; i < MaxRegisterCount() ; i++) {  // there are only 16 registers to read   
-    OutBufPtr = BasicReadRegister(SystemContext, i, OutBufPtr);
-  }
-
-  *OutBufPtr = '\0';  // the end of the buffer
-  SendPacket(OutBuffer);
-}
-
-
-/**
- Adds the RegNumber-th register's value to the output buffer, starting at the given OutBufPtr
-
- @param   SystemContext       Register content at time of the exception
- @param   RegNumber         the number of the register that we want to write
- @param   InBufPtr          pointer to the output buffer. the new data will be extracted from the input buffer from this point on.
- @retval  the pointer to the next character of the input buffer that can be used
- **/
-CHAR8 *
-BasicWriteRegister (
-  IN  EFI_SYSTEM_CONTEXT      SystemContext,
-  IN  UINTN           RegNumber,
-  IN  CHAR8           *InBufPtr
-  )
-{
-  UINTN RegSize;
-  UINTN TempValue; // the value transferred from a hex char
-  UINT32 NewValue; // the new value of the RegNumber-th Register
-  
-  NewValue = 0;
-  RegSize = 0;
-  while (RegSize < REG_SIZE) {
-    TempValue = HexCharToInt(*InBufPtr++);
-    
-   if (TempValue < 0) {
-      SendError (GDB_EBADMEMDATA); 
-      return NULL;
-    }
-
-    NewValue += (TempValue << (RegSize+4));
-    TempValue = HexCharToInt(*InBufPtr++);
-    
-    if (TempValue < 0) {
-      SendError (GDB_EBADMEMDATA); 
-      return NULL;
-    }
-    
-    NewValue += (TempValue << RegSize); 
-    RegSize = RegSize + 8;
-  }
-  *(FindPointerToRegister(SystemContext, RegNumber)) = NewValue;
-  return InBufPtr;
-}
-
-
-/** ‘P n...=r...’
- Writes the new value of n-th register received into the input buffer to the n-th register
-
- @param   SystemContext   Register content at time of the exception
- @param   InBuffer      Ponter to the input buffer received from gdb server
- **/
-VOID
-EFIAPI
-WriteNthRegister (
-  IN  EFI_SYSTEM_CONTEXT      SystemContext,
-  IN  CHAR8           *InBuffer
-  )
-{
-  UINTN RegNumber;
-  CHAR8 RegNumBuffer[MAX_REG_NUM_BUF_SIZE];  // put the 'n..' part of the message into this array
-  CHAR8 *RegNumBufPtr;
-  CHAR8 *InBufPtr; // pointer to the input buffer
-  
-  // find the register number to write
-  InBufPtr = &InBuffer[1];
-  RegNumBufPtr = RegNumBuffer;
-  while (*InBufPtr != '=') {
-    *RegNumBufPtr++ = *InBufPtr++;
-  } 
-  *RegNumBufPtr = '\0';
-  RegNumber = AsciiStrHexToUintn (RegNumBuffer); 
-
-  // check if this is a valid Register Number
-  if ((RegNumber < 0) || (RegNumber >= MaxRegisterCount())) {
-	SendError (GDB_EINVALIDREGNUM); 
-    return;
-  }
-  InBufPtr++;  // skips the '=' character
-  BasicWriteRegister (SystemContext, RegNumber, InBufPtr);
-  SendSuccess();
-}
-
-
-/** ‘G XX...’
- Writes the new values received into the input buffer to the general registers
-
- @param   SystemContext       Register content at time of the exception
- @param   InBuffer          Pointer to the input buffer received from gdb server
- **/
-VOID
-EFIAPI
-WriteGeneralRegisters (
-  IN  EFI_SYSTEM_CONTEXT        SystemContext,
-  IN  CHAR8             *InBuffer
-  )
-{
-  UINTN  i;
-  CHAR8 *InBufPtr; /// pointer to the input buffer
-
-  // check to see if the buffer is the right size which is 
-  // 1 (for 'G') + 16 (for 16 registers) * 8 ( for 8 hex chars each) = 129 
-  if (AsciiStrLen(InBuffer) != 129) { // 16 regs, 8 hex chars each, and the end '\0' (escape seq)
-	//Bad message. Message is not the right length 
-    SendError (GDB_EBADBUFSIZE); 
-    return;
-  }
-
-  InBufPtr = &InBuffer[1];
-  
-  // Read the new values for the registers from the input buffer to an array, NewValueArray.
-  // The values in the array are in the gdb ordering
-  for(i=0; i < MaxRegisterCount(); i++) {  // there are only 16 registers to write
-    InBufPtr = BasicWriteRegister(SystemContext, i, InBufPtr);
-  }
-
-  SendSuccess();
-}
-
-
-/** 
- Insert Single Step in the SystemContext
- 
- @param SystemContext Register content at time of the exception
- **/
-VOID
-AddSingleStep (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext
-  )
-{
-  SystemContext.SystemContextIa32->Eflags |= TF_BIT; //Setting the TF bit.
-}
-
-  
-/** 
- Remove Single Step in the SystemContext
- 
- @param SystemContext Register content at time of the exception
- **/
-VOID
-RemoveSingleStep (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext
-  )
-{
-  SystemContext.SystemContextIa32->Eflags &= ~TF_BIT;  // clearing the TF bit.
-}
-
-
-
-/** ‘c [addr ]’ 
- Continue. addr is Address to resume. If addr is omitted, resume at current 
- Address.
- 
- @param   SystemContext     Register content at time of the exception  
- **/
-VOID
-EFIAPI
-ContinueAtAddress (
-  IN  EFI_SYSTEM_CONTEXT      SystemContext,
-  IN    CHAR8                 *PacketData
-  )
-{
-  if (PacketData[1] != '\0') {
-    SystemContext.SystemContextIa32->Eip = AsciiStrHexToUintn (&PacketData[1]);
-  } 
-}
-
-
-/** ‘s [addr ]’
- Single step. addr is the Address at which to resume. If addr is omitted, resume 
- at same Address.
- 
- @param   SystemContext     Register content at time of the exception  
- **/
-VOID
-EFIAPI
-SingleStep (
-  IN  EFI_SYSTEM_CONTEXT      SystemContext,
-  IN    CHAR8                 *PacketData
-  )
-{
-  if (PacketData[1] != '\0') {
-    SystemContext.SystemContextIa32->Eip = AsciiStrHexToUintn (&PacketData[1]);
-  }
-  
-  AddSingleStep (SystemContext);
-}
-
-
-/**
-  Returns breakpoint data address from DR0-DR3 based on the input breakpoint number
-
-  @param  SystemContext      Register content at time of the exception
-  @param  BreakpointNumber   Breakpoint number
-
-  @retval Address            Data address from DR0-DR3 based on the breakpoint number.
-
-**/
-UINTN
-GetBreakpointDataAddress (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  UINTN               BreakpointNumber
-  )
-{
-  UINTN Address;
-
-  if (BreakpointNumber == 1) {
-    Address = SystemContext.SystemContextIa32->Dr0;
-  } else if (BreakpointNumber == 2) {
-    Address = SystemContext.SystemContextIa32->Dr1;
-  } else if (BreakpointNumber == 3) {
-    Address = SystemContext.SystemContextIa32->Dr2;
-  } else if (BreakpointNumber == 4) {
-    Address = SystemContext.SystemContextIa32->Dr3;
-  } else {
-    Address = 0;
-  }
-
-  return Address;
-}
-
-
-/**
-  Returns currently detected breakpoint value based on the register DR6 B0-B3 field.
-  If no breakpoint is detected then it returns 0.
-
-  @param  SystemContext  Register content at time of the exception
-
-  @retval {1-4}          Currently detected breakpoint value   
-  @retval 0              No breakpoint detected.
- 
-**/
-UINTN
-GetBreakpointDetected (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext
-  )
-{
-  IA32_DR6 Dr6;
-  UINTN BreakpointNumber;
-
-  Dr6.UintN = SystemContext.SystemContextIa32->Dr6;
-
-  if (Dr6.Bits.B0 == 1) {
-    BreakpointNumber = 1;
-  } else if (Dr6.Bits.B1 == 1) {
-    BreakpointNumber = 2;
-  } else if (Dr6.Bits.B2 == 1) {
-    BreakpointNumber = 3;
-  } else if (Dr6.Bits.B3 == 1) {
-    BreakpointNumber = 4;
-  } else {
-    BreakpointNumber = 0;  //No breakpoint detected 
-  }
-
-  return BreakpointNumber;
-}
-
-
-/**
-  Returns Breakpoint type (InstructionExecution, DataWrite, DataRead or DataReadWrite)
-  based on the Breakpoint number
-  
-  @param  SystemContext        Register content at time of the exception
-  @param  BreakpointNumber     Breakpoint number
-  
-  @retval BREAK_TYPE           Breakpoint type value read from register DR7 RWn field
-                               For unknown value, it returns NotSupported.
-  
-**/
-BREAK_TYPE
-GetBreakpointType (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  UINTN               BreakpointNumber
-  )
-{
-  IA32_DR7 Dr7;
-  BREAK_TYPE Type = NotSupported;  //Default is NotSupported type
-
-  Dr7.UintN = SystemContext.SystemContextIa32->Dr7;
-
-  if (BreakpointNumber == 1) {
-    Type = (BREAK_TYPE) Dr7.Bits.RW0;  
-  } else if (BreakpointNumber == 2) {
-    Type = (BREAK_TYPE) Dr7.Bits.RW1;  
-  } else if (BreakpointNumber == 3) {
-    Type = (BREAK_TYPE) Dr7.Bits.RW2;  
-  } else if (BreakpointNumber == 4) {
-    Type = (BREAK_TYPE) Dr7.Bits.RW3;  
-  }
-
-  return Type;
-}
-
-
-/** 
-  Parses Length and returns the length which DR7 LENn field accepts.
-  For example: If we receive 1-Byte length then we should return 0. 
-               Zero gets written to DR7 LENn field.
-
-  @param  Length  Breakpoint length in Bytes (1 byte, 2 byte, 4 byte)
-
-  @retval Length  Appropriate converted values which DR7 LENn field accepts.
-
-**/
-UINTN
-ConvertLengthData (
-  IN     UINTN   Length
-  )
-{
-  if (Length == 1) {         //1-Byte length 
-    return 0;
-  } else if (Length == 2) {  //2-Byte length
-    return 1;
-  } else if (Length == 4) {  //4-Byte length
-    return 3;
-  } else {                   //Undefined or 8-byte length
-    return 2;
-  }
-}
-
-
-/**
-  Finds the next free debug register. If all the registers are occupied then 
-  EFI_OUT_OF_RESOURCES is returned.  
-
-  @param  SystemContext   Register content at time of the exception
-  @param  Register        Register value (0 - 3 for the first free debug register)
-
-  @retval EFI_STATUS      Appropriate status value.
-
-**/
-EFI_STATUS
-FindNextFreeDebugRegister (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  OUT UINTN               *Register
-  )
-{
-  IA32_DR7 Dr7;
-
-  Dr7.UintN = SystemContext.SystemContextIa32->Dr7;
-
-  if (Dr7.Bits.G0 == 0) {
-    *Register = 0;
-  } else if (Dr7.Bits.G1 == 0) {
-    *Register = 1;
-  } else if (Dr7.Bits.G2 == 0) {
-    *Register = 2;
-  } else if (Dr7.Bits.G3 == 0) {
-    *Register = 3;
-  } else {
-    return EFI_OUT_OF_RESOURCES;
-  }
-
-  return EFI_SUCCESS;
-}
-
-
-/**
-  Enables the debug register. Writes Address value to appropriate DR0-3 register.
-  Sets LENn, Gn, RWn bits in DR7 register.
- 
-  @param  SystemContext   Register content at time of the exception
-  @param  Register        Register value (0 - 3) 
-  @param  Address         Breakpoint address value
-  @param  Type            Breakpoint type (Instruction, Data write, Data read 
-                          or write etc.)
-
-  @retval EFI_STATUS      Appropriate status value.
-
-**/
-EFI_STATUS
-EnableDebugRegister (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  UINTN               Register,
-  IN  UINTN               Address,
-  IN  UINTN               Length,
-  IN  UINTN               Type
-  )
-{
-  IA32_DR7  Dr7;
-
-  //Convert length data
-  Length = ConvertLengthData (Length);
-
-  //For Instruction execution, length should be 0 
-  //(Ref. Intel reference manual 18.2.4)
-  if ((Type == 0) && (Length != 0)) {
-    return EFI_INVALID_PARAMETER;
-  }
- 
-  //Hardware doesn't support ReadWatch (z3 packet) type. GDB can handle
-  //software breakpoint. We should send empty packet in both these cases.
-  if ((Type == (BREAK_TYPE)DataRead) || 
-      (Type == (BREAK_TYPE)SoftwareBreakpoint)) {
-    return EFI_UNSUPPORTED;
-  }
-
-  //Read DR7 so appropriate Gn, RWn and LENn bits can be modified.
-  Dr7.UintN = SystemContext.SystemContextIa32->Dr7;
-
-  if (Register == 0) {
-    SystemContext.SystemContextIa32->Dr0 = Address;
-    Dr7.Bits.G0 = 1;
-    Dr7.Bits.RW0 = Type;
-    Dr7.Bits.LEN0 = Length;
-  } else if (Register == 1) {
-    SystemContext.SystemContextIa32->Dr1 = Address;
-    Dr7.Bits.G1 = 1;
-    Dr7.Bits.RW1 = Type;
-    Dr7.Bits.LEN1 = Length;
-  } else if (Register == 2) {
-    SystemContext.SystemContextIa32->Dr2 = Address;
-    Dr7.Bits.G2 = 1;
-    Dr7.Bits.RW2 = Type;
-    Dr7.Bits.LEN2 = Length;
-  } else if (Register == 3) {
-    SystemContext.SystemContextIa32->Dr3 = Address;
-    Dr7.Bits.G3 = 1;
-    Dr7.Bits.RW3 = Type;
-    Dr7.Bits.LEN3 = Length;
-  } else {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  //Update Dr7 with appropriate Gn, RWn and LENn bits 
-  SystemContext.SystemContextIa32->Dr7 = Dr7.UintN;
-
-  return EFI_SUCCESS;
-}
-
-
-/**
-  Returns register number 0 - 3 for the maching debug register.
-  This function compares incoming Address, Type, Length and
-  if there is a match then it returns the appropriate register number.
-  In case of mismatch, function returns EFI_NOT_FOUND message.
-
-  @param  SystemContext  Register content at time of the exception
-  @param  Address        Breakpoint address value
-  @param  Length         Breakpoint length value
-  @param  Type           Breakpoint type (Instruction, Data write, 
-                         Data read or write etc.)
-  @param  Register       Register value to be returned
-
-  @retval EFI_STATUS     Appropriate status value.
-
-**/
-EFI_STATUS
-FindMatchingDebugRegister (
- IN  EFI_SYSTEM_CONTEXT  SystemContext,
- IN  UINTN               Address,
- IN  UINTN               Length,
- IN  UINTN               Type,
- OUT UINTN               *Register
- )
-{
-  IA32_DR7 Dr7;
-
-  //Hardware doesn't support ReadWatch (z3 packet) type. GDB can handle
-  //software breakpoint. We should send empty packet in both these cases.
-  if ((Type == (BREAK_TYPE)DataRead) || 
-      (Type == (BREAK_TYPE)SoftwareBreakpoint)) {
-    return EFI_UNSUPPORTED;
-  }
-
-  //Convert length data
-  Length = ConvertLengthData(Length);
-
-  Dr7.UintN = SystemContext.SystemContextIa32->Dr7;
-
-  if ((Dr7.Bits.G0 == 1) && 
-      (Dr7.Bits.LEN0 == Length) &&
-      (Dr7.Bits.RW0 == Type) && 
-      (Address == SystemContext.SystemContextIa32->Dr0)) {
-    *Register = 0;
-  } else if ((Dr7.Bits.G1 == 1) && 
-             (Dr7.Bits.LEN1 == Length) &&
-             (Dr7.Bits.RW1 == Type) && 
-             (Address == SystemContext.SystemContextIa32->Dr1)) {
-    *Register = 1;
-  } else if ((Dr7.Bits.G2 == 1) && 
-             (Dr7.Bits.LEN2 == Length) &&
-             (Dr7.Bits.RW2 == Type) && 
-             (Address == SystemContext.SystemContextIa32->Dr2)) {
-    *Register = 2;
-  } else if ((Dr7.Bits.G3 == 1) && 
-             (Dr7.Bits.LEN3 == Length) &&
-             (Dr7.Bits.RW3 == Type) && 
-             (Address == SystemContext.SystemContextIa32->Dr3)) {
-    *Register = 3;
-  } else {
-    Print ((CHAR16 *)L"No match found..\n");
-    return EFI_NOT_FOUND;
-  }
-
-  return EFI_SUCCESS;
-}
-
-
-/**
-  Disables the particular debug register.
-
-  @param  SystemContext   Register content at time of the exception
-  @param  Register        Register to be disabled
-
-  @retval EFI_STATUS      Appropriate status value.
-
-**/
-EFI_STATUS
-DisableDebugRegister (
- IN  EFI_SYSTEM_CONTEXT  SystemContext,
- IN  UINTN               Register  
- )
-{
-  IA32_DR7  Dr7;
-  UINTN Address = 0;
- 
-  //Read DR7 register so appropriate Gn, RWn and LENn bits can be turned off.
-  Dr7.UintN = SystemContext.SystemContextIa32->Dr7;
-
-  if (Register == 0) {
-    SystemContext.SystemContextIa32->Dr0 = Address;
-    Dr7.Bits.G0 = 0;
-    Dr7.Bits.RW0 = 0;
-    Dr7.Bits.LEN0 = 0;
-  } else if (Register == 1) {
-    SystemContext.SystemContextIa32->Dr1 = Address;
-    Dr7.Bits.G1 = 0;
-    Dr7.Bits.RW1 = 0;
-    Dr7.Bits.LEN1 = 0;
-  } else if (Register == 2) {
-    SystemContext.SystemContextIa32->Dr2 = Address;
-    Dr7.Bits.G2 = 0;
-    Dr7.Bits.RW2 = 0;
-    Dr7.Bits.LEN2 = 0;
-  } else if (Register == 3) {
-    SystemContext.SystemContextIa32->Dr3 = Address;
-    Dr7.Bits.G3 = 0;
-    Dr7.Bits.RW3 = 0;
-    Dr7.Bits.LEN3 = 0;
-  } else {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  //Update DR7 register so appropriate Gn, RWn and LENn bits can be turned off.
-  SystemContext.SystemContextIa32->Dr7 = Dr7.UintN;
-
-  return EFI_SUCCESS;
-}
-
-
-/**
-  ‘Z1, [addr], [length]’
-  ‘Z2, [addr], [length]’
-  ‘Z3, [addr], [length]’
-  ‘Z4, [addr], [length]’
-
-  Insert hardware breakpoint/watchpoint at address addr of size length
-
-  @param SystemContext  Register content at time of the exception
-  @param *PacketData    Pointer to the Payload data for the packet
-
-**/
-VOID
-EFIAPI
-InsertBreakPoint (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  CHAR8              *PacketData
-  )
-{
-  UINTN Type;
-  UINTN Address;
-  UINTN Length;
-  UINTN Register;
-  EFI_STATUS Status;
-  BREAK_TYPE BreakType = NotSupported;
-  UINTN ErrorCode;
-
-  ErrorCode = ParseBreakpointPacket (PacketData, &Type, &Address, &Length);
-  if (ErrorCode > 0) {
-    SendError ((UINT8)ErrorCode);
-    return;
-  }
-
-  switch (Type) {
-
-    case    0:   //Software breakpoint
-      BreakType = SoftwareBreakpoint;
-      break;
-
-    case    1:   //Hardware breakpoint
-      BreakType = InstructionExecution;
-      break;
-
-    case    2:   //Write watchpoint
-      BreakType = DataWrite;
-      break;
-
-    case    3:   //Read watchpoint
-      BreakType = DataRead;
-      break;
-
-    case    4:   //Access watchpoint
-      BreakType = DataReadWrite;
-      break;
-
-    default  :
-      Print ((CHAR16 *)L"Insert breakpoint default: %x\n", Type);
-      SendError (GDB_EINVALIDBRKPOINTTYPE);
-      return;
-  }
-
-  // Find next free debug register
-  Status = FindNextFreeDebugRegister (SystemContext, &Register);
-  if (EFI_ERROR(Status)) {
-    Print ((CHAR16 *)L"No space left on device\n");
-    SendError (GDB_ENOSPACE);
-    return;
-  }
-
-  // Write Address, length data at particular DR register
-  Status = EnableDebugRegister (SystemContext, Register, Address, Length, (UINTN)BreakType);
-  if (EFI_ERROR(Status)) {
-
-    if (Status == EFI_UNSUPPORTED) {
-      Print ((CHAR16 *)L"Not supported\n");
-      SendNotSupported();
-      return;
-    }
-
-    Print ((CHAR16 *)L"Invalid argument\n");
-    SendError (GDB_EINVALIDARG);
-    return;
-  }
-
-  SendSuccess ();
-}
-
-
-/**
-  ‘z1, [addr], [length]’
-  ‘z2, [addr], [length]’
-  ‘z3, [addr], [length]’
-  ‘z4, [addr], [length]’
-
-  Remove hardware breakpoint/watchpoint at address addr of size length
-
-  @param *PacketData    Pointer to the Payload data for the packet
-
-**/
-VOID
-EFIAPI
-RemoveBreakPoint (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  CHAR8               *PacketData
-  )
-{
-  UINTN      Type;
-  UINTN      Address;
-  UINTN      Length;
-  UINTN      Register;
-  BREAK_TYPE BreakType = NotSupported;
-  EFI_STATUS Status;
-  UINTN      ErrorCode;
-
-  //Parse breakpoint packet data
-  ErrorCode = ParseBreakpointPacket (PacketData, &Type, &Address, &Length);
-  if (ErrorCode > 0) {
-    SendError ((UINT8)ErrorCode);
-    return;
-  }
-
-  switch (Type) {
-  
-    case    0:   //Software breakpoint
-      BreakType = SoftwareBreakpoint;
-      break;
-      
-    case    1:   //Hardware breakpoint
-      BreakType = InstructionExecution;
-      break;
-      
-    case    2:   //Write watchpoint
-      BreakType = DataWrite;
-      break;
-
-    case    3:   //Read watchpoint
-      BreakType = DataRead;
-      break;
-
-    case    4:   //Access watchpoint
-      BreakType = DataReadWrite;
-      break;
-
-    default  :
-      SendError (GDB_EINVALIDBRKPOINTTYPE);
-      return;
-  }
-
-  //Find matching debug register
-  Status = FindMatchingDebugRegister (SystemContext, Address, Length, (UINTN)BreakType, &Register);
-  if (EFI_ERROR(Status)) {
-
-    if (Status == EFI_UNSUPPORTED) {
-      Print ((CHAR16 *)L"Not supported.\n");
-      SendNotSupported();
-      return;
-    }
-
-    Print ((CHAR16 *)L"No matching register found.\n");
-    SendError (GDB_ENOSPACE);
-    return;
-  }
-
-  //Remove breakpoint
-  Status = DisableDebugRegister(SystemContext, Register);
-  if (EFI_ERROR(Status)) {
-    Print ((CHAR16 *)L"Invalid argument.\n");
-    SendError (GDB_EINVALIDARG);
-    return;
-  }
-
-  SendSuccess ();
-}
-
-
-VOID
-InitializeProcessor (
-  VOID
-  )
-{
-}
-
-BOOLEAN
-ValidateAddress (
-  IN  VOID  *Address
-  )
-{
-  return TRUE;
-}
-
-BOOLEAN
-ValidateException (
-  IN  EFI_EXCEPTION_TYPE    ExceptionType, 
-  IN OUT EFI_SYSTEM_CONTEXT SystemContext 
-  )
-{
-  return TRUE;
-}
-
+/** @file

+  Processor specific parts of the GDB stub

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include <GdbStubInternal.h>

+

+//

+// Array of exception types that need to be hooked by the debugger

+// {EFI mapping, GDB mapping}

+//

+EFI_EXCEPTION_TYPE_ENTRY gExceptionType[] = {

+  { EXCEPT_IA32_DIVIDE_ERROR,     GDB_SIGFPE  }, 

+  { EXCEPT_IA32_DEBUG,            GDB_SIGTRAP },

+  { EXCEPT_IA32_NMI,              GDB_SIGEMT  },

+  { EXCEPT_IA32_BREAKPOINT,       GDB_SIGTRAP },

+  { EXCEPT_IA32_OVERFLOW,         GDB_SIGSEGV },

+  { EXCEPT_IA32_BOUND,            GDB_SIGSEGV },

+  { EXCEPT_IA32_INVALID_OPCODE,   GDB_SIGILL  },

+  { EXCEPT_IA32_DOUBLE_FAULT,     GDB_SIGEMT  },

+  { EXCEPT_IA32_STACK_FAULT,      GDB_SIGSEGV },

+  { EXCEPT_IA32_GP_FAULT,         GDB_SIGSEGV },

+  { EXCEPT_IA32_PAGE_FAULT,       GDB_SIGSEGV },

+  { EXCEPT_IA32_FP_ERROR,         GDB_SIGEMT  },

+  { EXCEPT_IA32_ALIGNMENT_CHECK,  GDB_SIGEMT  },

+  { EXCEPT_IA32_MACHINE_CHECK,    GDB_SIGEMT  }

+};

+

+

+// The offsets of registers SystemContext.

+// The fields in the array are in the gdb ordering.

+//

+//16 regs

+UINTN gRegisterOffsets[] = {

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Eax),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Ecx),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Edx),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Ebx),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Esp),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Ebp),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Esi),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Edi),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Eip),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Eflags),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Cs),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Ss),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Ds),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Es),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Fs),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Gs)

+};

+

+

+//Debug only..

+VOID 

+PrintReg (

+  IN EFI_SYSTEM_CONTEXT SystemContext

+  )

+{

+  Print ((CHAR16 *)L"EAX: %x ", SystemContext.SystemContextIa32->Eax);

+  Print ((CHAR16 *)L"ECX: %x ", SystemContext.SystemContextIa32->Ecx);

+  Print ((CHAR16 *)L"EDX: %x ", SystemContext.SystemContextIa32->Edx);

+  Print ((CHAR16 *)L"EBX: %x ", SystemContext.SystemContextIa32->Ebx);

+  Print ((CHAR16 *)L"ESP: %x ", SystemContext.SystemContextIa32->Esp);

+  Print ((CHAR16 *)L"EBP: %x ", SystemContext.SystemContextIa32->Ebp);

+  Print ((CHAR16 *)L"ESI: %x ", SystemContext.SystemContextIa32->Esi);

+  Print ((CHAR16 *)L"EDI: %x ", SystemContext.SystemContextIa32->Edi);

+  Print ((CHAR16 *)L"EIP: %x\n", SystemContext.SystemContextIa32->Eip);

+  Print ((CHAR16 *)L"EFlags: %x\n", SystemContext.SystemContextIa32->Eflags);

+}

+

+//Debug only..

+VOID 

+PrintDRreg (

+  IN EFI_SYSTEM_CONTEXT SystemContext

+  )

+{

+  Print ((CHAR16 *)L"DR0: %x ", SystemContext.SystemContextIa32->Dr0);

+  Print ((CHAR16 *)L"DR1: %x ", SystemContext.SystemContextIa32->Dr1);

+  Print ((CHAR16 *)L"DR2: %x ", SystemContext.SystemContextIa32->Dr2);

+  Print ((CHAR16 *)L"DR3: %x ", SystemContext.SystemContextIa32->Dr3);

+  Print ((CHAR16 *)L"DR6: %x ", SystemContext.SystemContextIa32->Dr6);

+  Print ((CHAR16 *)L"DR7: %x\n", SystemContext.SystemContextIa32->Dr7);

+}

+

+

+/**

+ Return the number of entries in the gExceptionType[]

+ 

+ @retval  UINTN, the number of entries in the gExceptionType[] array.    

+ **/

+UINTN

+MaxEfiException (

+  VOID

+  )

+{

+  return sizeof (gExceptionType)/sizeof (EFI_EXCEPTION_TYPE_ENTRY);

+}

+

+

+/**

+ Return the number of entries in the gRegisters[]

+ 

+ @retval  UINTN, the number of entries (registers) in the gRegisters[] array.    

+ **/

+UINTN

+MaxRegisterCount (

+  VOID

+  )

+{

+  return sizeof (gRegisterOffsets)/sizeof (UINTN);

+}

+

+

+/**

+  Check to see if the ISA is supported. 

+  ISA = Instruction Set Architecture

+ 

+  @retval TRUE if Isa is supported,

+      FALSE otherwise.

+**/

+BOOLEAN

+CheckIsa (

+  IN  EFI_INSTRUCTION_SET_ARCHITECTURE  Isa

+  )

+{

+  return (BOOLEAN)(Isa == IsaIa32);

+}

+

+

+/**

+ This takes in the register number and the System Context, and returns a pointer to the RegNumber-th register in gdb ordering

+ It is, by default, set to find the register pointer of the IA32 member

+

+ @param   SystemContext     Register content at time of the exception 

+ @param   RegNumber       The register to which we want to find a pointer

+ @retval  the pointer to the RegNumber-th pointer

+ **/

+UINTN *

+FindPointerToRegister (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  UINTN               RegNumber  

+  )

+{

+  UINT8 *TempPtr;

+  TempPtr = ((UINT8 *)SystemContext.SystemContextIa32) + gRegisterOffsets[RegNumber];

+  return (UINTN *)TempPtr;

+}

+

+

+/**

+ Adds the RegNumber-th register's value to the output buffer, starting at the given OutBufPtr

+

+ @param SystemContext     Register content at time of the exception

+ @param   RegNumber       the number of the register that we want to read

+ @param   OutBufPtr       pointer to the output buffer's end. the new data will be added from this point on.

+ @retval  the pointer to the next character of the output buffer that is available to be written on.

+ **/

+CHAR8 *

+BasicReadRegister (

+  IN  EFI_SYSTEM_CONTEXT      SystemContext,

+  IN  UINTN           RegNumber,

+  IN  CHAR8           *OutBufPtr

+  )

+{

+  UINTN RegSize;

+  

+  RegSize = 0;

+  while (RegSize < REG_SIZE) {

+    *OutBufPtr++ = mHexToStr[((*FindPointerToRegister (SystemContext, RegNumber) >> (RegSize+4)) & 0xf)];

+    *OutBufPtr++ = mHexToStr[((*FindPointerToRegister (SystemContext, RegNumber) >> RegSize) & 0xf)];

+    RegSize = RegSize + 8;

+  }

+  return OutBufPtr;

+}

+

+

+/** ‘p n’ 

+ Reads the n-th register's value into an output buffer and sends it as a packet 

+

+ @param   SystemContext   Register content at time of the exception

+ @param   InBuffer      Pointer to the input buffer received from gdb server

+ **/

+VOID

+EFIAPI

+ReadNthRegister (

+  IN  EFI_SYSTEM_CONTEXT   SystemContext,

+  IN  CHAR8                *InBuffer

+  )

+{

+  UINTN RegNumber;

+  CHAR8 OutBuffer[9]; // 1 reg=8 hex chars, and the end '\0' (escape seq)

+  CHAR8 *OutBufPtr;   // pointer to the output buffer

+  

+  RegNumber = AsciiStrHexToUintn (&InBuffer[1]);

+

+  if ((RegNumber < 0) || (RegNumber >= MaxRegisterCount())) {

+    SendError (GDB_EINVALIDREGNUM);

+    return;

+  }

+

+  OutBufPtr = OutBuffer;

+  OutBufPtr = BasicReadRegister (SystemContext, RegNumber, OutBufPtr);

+

+  *OutBufPtr = '\0';  // the end of the buffer

+  SendPacket(OutBuffer);

+}

+

+

+/** ‘g’ 

+ Reads the general registers into an output buffer  and sends it as a packet 

+

+ @param   SystemContext     Register content at time of the exception

+ **/

+VOID

+EFIAPI

+ReadGeneralRegisters (  

+  IN  EFI_SYSTEM_CONTEXT      SystemContext

+  )

+{

+  UINTN   i;

+  CHAR8 OutBuffer[129]; // 16 regs, 8 hex chars each, and the end '\0' (escape seq)

+  CHAR8 *OutBufPtr;   // pointer to the output buffer

+

+  OutBufPtr = OutBuffer;

+  for (i = 0 ; i < MaxRegisterCount() ; i++) {  // there are only 16 registers to read   

+    OutBufPtr = BasicReadRegister (SystemContext, i, OutBufPtr);

+  }

+

+  *OutBufPtr = '\0';  // the end of the buffer

+  SendPacket(OutBuffer);

+}

+

+

+/**

+ Adds the RegNumber-th register's value to the output buffer, starting at the given OutBufPtr

+

+ @param   SystemContext       Register content at time of the exception

+ @param   RegNumber         the number of the register that we want to write

+ @param   InBufPtr          pointer to the output buffer. the new data will be extracted from the input buffer from this point on.

+ @retval  the pointer to the next character of the input buffer that can be used

+ **/

+CHAR8 *

+BasicWriteRegister (

+  IN  EFI_SYSTEM_CONTEXT      SystemContext,

+  IN  UINTN           RegNumber,

+  IN  CHAR8           *InBufPtr

+  )

+{

+  UINTN RegSize;

+  UINTN TempValue; // the value transferred from a hex char

+  UINT32 NewValue; // the new value of the RegNumber-th Register

+  

+  NewValue = 0;

+  RegSize = 0;

+  while (RegSize < REG_SIZE) {

+    TempValue = HexCharToInt(*InBufPtr++);

+    

+   if (TempValue < 0) {

+      SendError (GDB_EBADMEMDATA); 

+      return NULL;

+    }

+

+    NewValue += (TempValue << (RegSize+4));

+    TempValue = HexCharToInt(*InBufPtr++);

+    

+    if (TempValue < 0) {

+      SendError (GDB_EBADMEMDATA); 

+      return NULL;

+    }

+    

+    NewValue += (TempValue << RegSize); 

+    RegSize = RegSize + 8;

+  }

+  *(FindPointerToRegister (SystemContext, RegNumber)) = NewValue;

+  return InBufPtr;

+}

+

+

+/** ‘P n...=r...’

+ Writes the new value of n-th register received into the input buffer to the n-th register

+

+ @param   SystemContext   Register content at time of the exception

+ @param   InBuffer      Ponter to the input buffer received from gdb server

+ **/

+VOID

+EFIAPI

+WriteNthRegister (

+  IN  EFI_SYSTEM_CONTEXT      SystemContext,

+  IN  CHAR8           *InBuffer

+  )

+{

+  UINTN RegNumber;

+  CHAR8 RegNumBuffer[MAX_REG_NUM_BUF_SIZE];  // put the 'n..' part of the message into this array

+  CHAR8 *RegNumBufPtr;

+  CHAR8 *InBufPtr; // pointer to the input buffer

+  

+  // find the register number to write

+  InBufPtr = &InBuffer[1];

+  RegNumBufPtr = RegNumBuffer;

+  while (*InBufPtr != '=') {

+    *RegNumBufPtr++ = *InBufPtr++;

+  } 

+  *RegNumBufPtr = '\0';

+  RegNumber = AsciiStrHexToUintn (RegNumBuffer); 

+

+  // check if this is a valid Register Number

+  if ((RegNumber < 0) || (RegNumber >= MaxRegisterCount())) {

+	SendError (GDB_EINVALIDREGNUM); 

+    return;

+  }

+  InBufPtr++;  // skips the '=' character

+  BasicWriteRegister (SystemContext, RegNumber, InBufPtr);

+  SendSuccess();

+}

+

+

+/** ‘G XX...’

+ Writes the new values received into the input buffer to the general registers

+

+ @param   SystemContext       Register content at time of the exception

+ @param   InBuffer          Pointer to the input buffer received from gdb server

+ **/

+VOID

+EFIAPI

+WriteGeneralRegisters (

+  IN  EFI_SYSTEM_CONTEXT        SystemContext,

+  IN  CHAR8             *InBuffer

+  )

+{

+  UINTN  i;

+  CHAR8 *InBufPtr; /// pointer to the input buffer

+

+  // check to see if the buffer is the right size which is 

+  // 1 (for 'G') + 16 (for 16 registers) * 8 ( for 8 hex chars each) = 129 

+  if (AsciiStrLen(InBuffer) != 129) { // 16 regs, 8 hex chars each, and the end '\0' (escape seq)

+	//Bad message. Message is not the right length 

+    SendError (GDB_EBADBUFSIZE); 

+    return;

+  }

+

+  InBufPtr = &InBuffer[1];

+  

+  // Read the new values for the registers from the input buffer to an array, NewValueArray.

+  // The values in the array are in the gdb ordering

+  for (i=0; i < MaxRegisterCount(); i++) {  // there are only 16 registers to write

+    InBufPtr = BasicWriteRegister (SystemContext, i, InBufPtr);

+  }

+

+  SendSuccess();

+}

+

+

+/** 

+ Insert Single Step in the SystemContext

+ 

+ @param SystemContext Register content at time of the exception

+ **/

+VOID

+AddSingleStep (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext

+  )

+{

+  SystemContext.SystemContextIa32->Eflags |= TF_BIT; //Setting the TF bit.

+}

+

+  

+/** 

+ Remove Single Step in the SystemContext

+ 

+ @param SystemContext Register content at time of the exception

+ **/

+VOID

+RemoveSingleStep (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext

+  )

+{

+  SystemContext.SystemContextIa32->Eflags &= ~TF_BIT;  // clearing the TF bit.

+}

+

+

+

+/** ‘c [addr ]’ 

+ Continue. addr is Address to resume. If addr is omitted, resume at current 

+ Address.

+ 

+ @param   SystemContext     Register content at time of the exception  

+ **/

+VOID

+EFIAPI

+ContinueAtAddress (

+  IN  EFI_SYSTEM_CONTEXT      SystemContext,

+  IN    CHAR8                 *PacketData

+  )

+{

+  if (PacketData[1] != '\0') {

+    SystemContext.SystemContextIa32->Eip = AsciiStrHexToUintn (&PacketData[1]);

+  } 

+}

+

+

+/** ‘s [addr ]’

+ Single step. addr is the Address at which to resume. If addr is omitted, resume 

+ at same Address.

+ 

+ @param   SystemContext     Register content at time of the exception  

+ **/

+VOID

+EFIAPI

+SingleStep (

+  IN  EFI_SYSTEM_CONTEXT      SystemContext,

+  IN    CHAR8                 *PacketData

+  )

+{

+  if (PacketData[1] != '\0') {

+    SystemContext.SystemContextIa32->Eip = AsciiStrHexToUintn (&PacketData[1]);

+  }

+  

+  AddSingleStep (SystemContext);

+}

+

+

+/**

+  Returns breakpoint data address from DR0-DR3 based on the input breakpoint number

+

+  @param  SystemContext      Register content at time of the exception

+  @param  BreakpointNumber   Breakpoint number

+

+  @retval Address            Data address from DR0-DR3 based on the breakpoint number.

+

+**/

+UINTN

+GetBreakpointDataAddress (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  UINTN               BreakpointNumber

+  )

+{

+  UINTN Address;

+

+  if (BreakpointNumber == 1) {

+    Address = SystemContext.SystemContextIa32->Dr0;

+  } else if (BreakpointNumber == 2) {

+    Address = SystemContext.SystemContextIa32->Dr1;

+  } else if (BreakpointNumber == 3) {

+    Address = SystemContext.SystemContextIa32->Dr2;

+  } else if (BreakpointNumber == 4) {

+    Address = SystemContext.SystemContextIa32->Dr3;

+  } else {

+    Address = 0;

+  }

+

+  return Address;

+}

+

+

+/**

+  Returns currently detected breakpoint value based on the register DR6 B0-B3 field.

+  If no breakpoint is detected then it returns 0.

+

+  @param  SystemContext  Register content at time of the exception

+

+  @retval {1-4}          Currently detected breakpoint value   

+  @retval 0              No breakpoint detected.

+ 

+**/

+UINTN

+GetBreakpointDetected (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext

+  )

+{

+  IA32_DR6 Dr6;

+  UINTN BreakpointNumber;

+

+  Dr6.UintN = SystemContext.SystemContextIa32->Dr6;

+

+  if (Dr6.Bits.B0 == 1) {

+    BreakpointNumber = 1;

+  } else if (Dr6.Bits.B1 == 1) {

+    BreakpointNumber = 2;

+  } else if (Dr6.Bits.B2 == 1) {

+    BreakpointNumber = 3;

+  } else if (Dr6.Bits.B3 == 1) {

+    BreakpointNumber = 4;

+  } else {

+    BreakpointNumber = 0;  //No breakpoint detected 

+  }

+

+  return BreakpointNumber;

+}

+

+

+/**

+  Returns Breakpoint type (InstructionExecution, DataWrite, DataRead or DataReadWrite)

+  based on the Breakpoint number

+  

+  @param  SystemContext        Register content at time of the exception

+  @param  BreakpointNumber     Breakpoint number

+  

+  @retval BREAK_TYPE           Breakpoint type value read from register DR7 RWn field

+                               For unknown value, it returns NotSupported.

+  

+**/

+BREAK_TYPE

+GetBreakpointType (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  UINTN               BreakpointNumber

+  )

+{

+  IA32_DR7 Dr7;

+  BREAK_TYPE Type = NotSupported;  //Default is NotSupported type

+

+  Dr7.UintN = SystemContext.SystemContextIa32->Dr7;

+

+  if (BreakpointNumber == 1) {

+    Type = (BREAK_TYPE) Dr7.Bits.RW0;  

+  } else if (BreakpointNumber == 2) {

+    Type = (BREAK_TYPE) Dr7.Bits.RW1;  

+  } else if (BreakpointNumber == 3) {

+    Type = (BREAK_TYPE) Dr7.Bits.RW2;  

+  } else if (BreakpointNumber == 4) {

+    Type = (BREAK_TYPE) Dr7.Bits.RW3;  

+  }

+

+  return Type;

+}

+

+

+/** 

+  Parses Length and returns the length which DR7 LENn field accepts.

+  For example: If we receive 1-Byte length then we should return 0. 

+               Zero gets written to DR7 LENn field.

+

+  @param  Length  Breakpoint length in Bytes (1 byte, 2 byte, 4 byte)

+

+  @retval Length  Appropriate converted values which DR7 LENn field accepts.

+

+**/

+UINTN

+ConvertLengthData (

+  IN     UINTN   Length

+  )

+{

+  if (Length == 1) {         //1-Byte length 

+    return 0;

+  } else if (Length == 2) {  //2-Byte length

+    return 1;

+  } else if (Length == 4) {  //4-Byte length

+    return 3;

+  } else {                   //Undefined or 8-byte length

+    return 2;

+  }

+}

+

+

+/**

+  Finds the next free debug register. If all the registers are occupied then 

+  EFI_OUT_OF_RESOURCES is returned.  

+

+  @param  SystemContext   Register content at time of the exception

+  @param  Register        Register value (0 - 3 for the first free debug register)

+

+  @retval EFI_STATUS      Appropriate status value.

+

+**/

+EFI_STATUS

+FindNextFreeDebugRegister (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  OUT UINTN               *Register

+  )

+{

+  IA32_DR7 Dr7;

+

+  Dr7.UintN = SystemContext.SystemContextIa32->Dr7;

+

+  if (Dr7.Bits.G0 == 0) {

+    *Register = 0;

+  } else if (Dr7.Bits.G1 == 0) {

+    *Register = 1;

+  } else if (Dr7.Bits.G2 == 0) {

+    *Register = 2;

+  } else if (Dr7.Bits.G3 == 0) {

+    *Register = 3;

+  } else {

+    return EFI_OUT_OF_RESOURCES;

+  }

+

+  return EFI_SUCCESS;

+}

+

+

+/**

+  Enables the debug register. Writes Address value to appropriate DR0-3 register.

+  Sets LENn, Gn, RWn bits in DR7 register.

+ 

+  @param  SystemContext   Register content at time of the exception

+  @param  Register        Register value (0 - 3) 

+  @param  Address         Breakpoint address value

+  @param  Type            Breakpoint type (Instruction, Data write, Data read 

+                          or write etc.)

+

+  @retval EFI_STATUS      Appropriate status value.

+

+**/

+EFI_STATUS

+EnableDebugRegister (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  UINTN               Register,

+  IN  UINTN               Address,

+  IN  UINTN               Length,

+  IN  UINTN               Type

+  )

+{

+  IA32_DR7  Dr7;

+

+  //Convert length data

+  Length = ConvertLengthData (Length);

+

+  //For Instruction execution, length should be 0 

+  //(Ref. Intel reference manual 18.2.4)

+  if ((Type == 0) && (Length != 0)) {

+    return EFI_INVALID_PARAMETER;

+  }

+ 

+  //Hardware doesn't support ReadWatch (z3 packet) type. GDB can handle

+  //software breakpoint. We should send empty packet in both these cases.

+  if ((Type == (BREAK_TYPE)DataRead) || 

+      (Type == (BREAK_TYPE)SoftwareBreakpoint)) {

+    return EFI_UNSUPPORTED;

+  }

+

+  //Read DR7 so appropriate Gn, RWn and LENn bits can be modified.

+  Dr7.UintN = SystemContext.SystemContextIa32->Dr7;

+

+  if (Register == 0) {

+    SystemContext.SystemContextIa32->Dr0 = Address;

+    Dr7.Bits.G0 = 1;

+    Dr7.Bits.RW0 = Type;

+    Dr7.Bits.LEN0 = Length;

+  } else if (Register == 1) {

+    SystemContext.SystemContextIa32->Dr1 = Address;

+    Dr7.Bits.G1 = 1;

+    Dr7.Bits.RW1 = Type;

+    Dr7.Bits.LEN1 = Length;

+  } else if (Register == 2) {

+    SystemContext.SystemContextIa32->Dr2 = Address;

+    Dr7.Bits.G2 = 1;

+    Dr7.Bits.RW2 = Type;

+    Dr7.Bits.LEN2 = Length;

+  } else if (Register == 3) {

+    SystemContext.SystemContextIa32->Dr3 = Address;

+    Dr7.Bits.G3 = 1;

+    Dr7.Bits.RW3 = Type;

+    Dr7.Bits.LEN3 = Length;

+  } else {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  //Update Dr7 with appropriate Gn, RWn and LENn bits 

+  SystemContext.SystemContextIa32->Dr7 = Dr7.UintN;

+

+  return EFI_SUCCESS;

+}

+

+

+/**

+  Returns register number 0 - 3 for the maching debug register.

+  This function compares incoming Address, Type, Length and

+  if there is a match then it returns the appropriate register number.

+  In case of mismatch, function returns EFI_NOT_FOUND message.

+

+  @param  SystemContext  Register content at time of the exception

+  @param  Address        Breakpoint address value

+  @param  Length         Breakpoint length value

+  @param  Type           Breakpoint type (Instruction, Data write, 

+                         Data read or write etc.)

+  @param  Register       Register value to be returned

+

+  @retval EFI_STATUS     Appropriate status value.

+

+**/

+EFI_STATUS

+FindMatchingDebugRegister (

+ IN  EFI_SYSTEM_CONTEXT  SystemContext,

+ IN  UINTN               Address,

+ IN  UINTN               Length,

+ IN  UINTN               Type,

+ OUT UINTN               *Register

+ )

+{

+  IA32_DR7 Dr7;

+

+  //Hardware doesn't support ReadWatch (z3 packet) type. GDB can handle

+  //software breakpoint. We should send empty packet in both these cases.

+  if ((Type == (BREAK_TYPE)DataRead) || 

+      (Type == (BREAK_TYPE)SoftwareBreakpoint)) {

+    return EFI_UNSUPPORTED;

+  }

+

+  //Convert length data

+  Length = ConvertLengthData(Length);

+

+  Dr7.UintN = SystemContext.SystemContextIa32->Dr7;

+

+  if ((Dr7.Bits.G0 == 1) && 

+      (Dr7.Bits.LEN0 == Length) &&

+      (Dr7.Bits.RW0 == Type) && 

+      (Address == SystemContext.SystemContextIa32->Dr0)) {

+    *Register = 0;

+  } else if ((Dr7.Bits.G1 == 1) && 

+             (Dr7.Bits.LEN1 == Length) &&

+             (Dr7.Bits.RW1 == Type) && 

+             (Address == SystemContext.SystemContextIa32->Dr1)) {

+    *Register = 1;

+  } else if ((Dr7.Bits.G2 == 1) && 

+             (Dr7.Bits.LEN2 == Length) &&

+             (Dr7.Bits.RW2 == Type) && 

+             (Address == SystemContext.SystemContextIa32->Dr2)) {

+    *Register = 2;

+  } else if ((Dr7.Bits.G3 == 1) && 

+             (Dr7.Bits.LEN3 == Length) &&

+             (Dr7.Bits.RW3 == Type) && 

+             (Address == SystemContext.SystemContextIa32->Dr3)) {

+    *Register = 3;

+  } else {

+    Print ((CHAR16 *)L"No match found..\n");

+    return EFI_NOT_FOUND;

+  }

+

+  return EFI_SUCCESS;

+}

+

+

+/**

+  Disables the particular debug register.

+

+  @param  SystemContext   Register content at time of the exception

+  @param  Register        Register to be disabled

+

+  @retval EFI_STATUS      Appropriate status value.

+

+**/

+EFI_STATUS

+DisableDebugRegister (

+ IN  EFI_SYSTEM_CONTEXT  SystemContext,

+ IN  UINTN               Register  

+ )

+{

+  IA32_DR7  Dr7;

+  UINTN Address = 0;

+ 

+  //Read DR7 register so appropriate Gn, RWn and LENn bits can be turned off.

+  Dr7.UintN = SystemContext.SystemContextIa32->Dr7;

+

+  if (Register == 0) {

+    SystemContext.SystemContextIa32->Dr0 = Address;

+    Dr7.Bits.G0 = 0;

+    Dr7.Bits.RW0 = 0;

+    Dr7.Bits.LEN0 = 0;

+  } else if (Register == 1) {

+    SystemContext.SystemContextIa32->Dr1 = Address;

+    Dr7.Bits.G1 = 0;

+    Dr7.Bits.RW1 = 0;

+    Dr7.Bits.LEN1 = 0;

+  } else if (Register == 2) {

+    SystemContext.SystemContextIa32->Dr2 = Address;

+    Dr7.Bits.G2 = 0;

+    Dr7.Bits.RW2 = 0;

+    Dr7.Bits.LEN2 = 0;

+  } else if (Register == 3) {

+    SystemContext.SystemContextIa32->Dr3 = Address;

+    Dr7.Bits.G3 = 0;

+    Dr7.Bits.RW3 = 0;

+    Dr7.Bits.LEN3 = 0;

+  } else {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  //Update DR7 register so appropriate Gn, RWn and LENn bits can be turned off.

+  SystemContext.SystemContextIa32->Dr7 = Dr7.UintN;

+

+  return EFI_SUCCESS;

+}

+

+

+/**

+  ‘Z1, [addr], [length]’

+  ‘Z2, [addr], [length]’

+  ‘Z3, [addr], [length]’

+  ‘Z4, [addr], [length]’

+

+  Insert hardware breakpoint/watchpoint at address addr of size length

+

+  @param SystemContext  Register content at time of the exception

+  @param *PacketData    Pointer to the Payload data for the packet

+

+**/

+VOID

+EFIAPI

+InsertBreakPoint (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  CHAR8              *PacketData

+  )

+{

+  UINTN Type;

+  UINTN Address;

+  UINTN Length;

+  UINTN Register;

+  EFI_STATUS Status;

+  BREAK_TYPE BreakType = NotSupported;

+  UINTN ErrorCode;

+

+  ErrorCode = ParseBreakpointPacket (PacketData, &Type, &Address, &Length);

+  if (ErrorCode > 0) {

+    SendError ((UINT8)ErrorCode);

+    return;

+  }

+

+  switch (Type) {

+

+    case    0:   //Software breakpoint

+      BreakType = SoftwareBreakpoint;

+      break;

+

+    case    1:   //Hardware breakpoint

+      BreakType = InstructionExecution;

+      break;

+

+    case    2:   //Write watchpoint

+      BreakType = DataWrite;

+      break;

+

+    case    3:   //Read watchpoint

+      BreakType = DataRead;

+      break;

+

+    case    4:   //Access watchpoint

+      BreakType = DataReadWrite;

+      break;

+

+    default  :

+      Print ((CHAR16 *)L"Insert breakpoint default: %x\n", Type);

+      SendError (GDB_EINVALIDBRKPOINTTYPE);

+      return;

+  }

+

+  // Find next free debug register

+  Status = FindNextFreeDebugRegister (SystemContext, &Register);

+  if (EFI_ERROR(Status)) {

+    Print ((CHAR16 *)L"No space left on device\n");

+    SendError (GDB_ENOSPACE);

+    return;

+  }

+

+  // Write Address, length data at particular DR register

+  Status = EnableDebugRegister (SystemContext, Register, Address, Length, (UINTN)BreakType);

+  if (EFI_ERROR(Status)) {

+

+    if (Status == EFI_UNSUPPORTED) {

+      Print ((CHAR16 *)L"Not supported\n");

+      SendNotSupported ();

+      return;

+    }

+

+    Print ((CHAR16 *)L"Invalid argument\n");

+    SendError (GDB_EINVALIDARG);

+    return;

+  }

+

+  SendSuccess ();

+}

+

+

+/**

+  ‘z1, [addr], [length]’

+  ‘z2, [addr], [length]’

+  ‘z3, [addr], [length]’

+  ‘z4, [addr], [length]’

+

+  Remove hardware breakpoint/watchpoint at address addr of size length

+

+  @param *PacketData    Pointer to the Payload data for the packet

+

+**/

+VOID

+EFIAPI

+RemoveBreakPoint (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  CHAR8               *PacketData

+  )

+{

+  UINTN      Type;

+  UINTN      Address;

+  UINTN      Length;

+  UINTN      Register;

+  BREAK_TYPE BreakType = NotSupported;

+  EFI_STATUS Status;

+  UINTN      ErrorCode;

+

+  //Parse breakpoint packet data

+  ErrorCode = ParseBreakpointPacket (PacketData, &Type, &Address, &Length);

+  if (ErrorCode > 0) {

+    SendError ((UINT8)ErrorCode);

+    return;

+  }

+

+  switch (Type) {

+  

+    case    0:   //Software breakpoint

+      BreakType = SoftwareBreakpoint;

+      break;

+      

+    case    1:   //Hardware breakpoint

+      BreakType = InstructionExecution;

+      break;

+      

+    case    2:   //Write watchpoint

+      BreakType = DataWrite;

+      break;

+

+    case    3:   //Read watchpoint

+      BreakType = DataRead;

+      break;

+

+    case    4:   //Access watchpoint

+      BreakType = DataReadWrite;

+      break;

+

+    default  :

+      SendError (GDB_EINVALIDBRKPOINTTYPE);

+      return;

+  }

+

+  //Find matching debug register

+  Status = FindMatchingDebugRegister (SystemContext, Address, Length, (UINTN)BreakType, &Register);

+  if (EFI_ERROR(Status)) {

+

+    if (Status == EFI_UNSUPPORTED) {

+      Print ((CHAR16 *)L"Not supported.\n");

+      SendNotSupported ();

+      return;

+    }

+

+    Print ((CHAR16 *)L"No matching register found.\n");

+    SendError (GDB_ENOSPACE);

+    return;

+  }

+

+  //Remove breakpoint

+  Status = DisableDebugRegister (SystemContext, Register);

+  if (EFI_ERROR(Status)) {

+    Print ((CHAR16 *)L"Invalid argument.\n");

+    SendError (GDB_EINVALIDARG);

+    return;

+  }

+

+  SendSuccess ();

+}

+

+

+VOID

+InitializeProcessor (

+  VOID

+  )

+{

+}

+

+BOOLEAN

+ValidateAddress (

+  IN  VOID  *Address

+  )

+{

+  return TRUE;

+}

+

+BOOLEAN

+ValidateException (

+  IN  EFI_EXCEPTION_TYPE    ExceptionType, 

+  IN OUT EFI_SYSTEM_CONTEXT SystemContext 

+  )

+{

+  return TRUE;

+}

+

diff --git a/EmbeddedPkg/GdbStub/SerialIo.c b/EmbeddedPkg/GdbStub/SerialIo.c
index 8fb86108..2df967a5 100644
--- a/EmbeddedPkg/GdbStub/SerialIo.c
+++ b/EmbeddedPkg/GdbStub/SerialIo.c
@@ -1,551 +1,551 @@
-/** @file
-  Serial IO Abstraction for GDB stub. This allows an EFI consoles that shows up on the system 
-  running GDB. One consle for error information and another console for user input/output.
-  
-  Basic packet format is $packet-data#checksum. So every comand has 4 bytes of overhead: $, 
-  #, 0, 0. The 0 and 0 are the ascii characters for the checksum. 
-  
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include <GdbStubInternal.h>
-
-//
-// Set TRUE if F Reply package signals a ctrl-c. We can not process the Ctrl-c
-// here we need to wait for the periodic callback to do this. 
-//
-BOOLEAN gCtrlCBreakFlag = FALSE;
-
-//
-// If the periodic callback is called while we are processing an F packet we need
-// to let the callback know to not read from the serail stream as it could steal
-// characters from the F reponse packet
-//
-BOOLEAN gProcessingFPacket = FALSE;
-
-/**
-  Process a control-C break message. 
-  
-  Currently a place holder, remove the ASSERT when it gets implemented. 
-
-  @param  ErrNo   Error infomration from the F reply packet or other source
-
-**/
-
-VOID
-GdbCtrlCBreakMessage (
-  IN  UINTN ErrNo
-  )
-{
-  // See D.10.5 of gdb.pdf
-  // This should look like a break message. Should look like SIGINT
-
-  /* TODO: Make sure if we should do anything with ErrNo */
-  //Turn on the global Ctrl-C flag.
-  gCtrlCBreakFlag = TRUE;
-}
-
-
-/**
-  Parse the F reply packet and extract the return value and an ErrNo if it exists.
-
-  @param  Packet  Packet to parse like an F reply packet
-  @param  ErrNo   Buffer to hold Count bytes that were read
-
-  @retval -1      Error, not a valid F reply packet 
-  @retval other   Return the return code from the F reply packet 
-
-**/
-INTN
-GdbParseFReplyPacket (
-  IN  CHAR8   *Packet,
-  OUT UINTN   *ErrNo   
-  )
-{
-  INTN   RetCode;
-   
-  if (Packet[0] != 'F') {
-    // A valid responce would be an F packet
-    return -1;
-  }
-  
-  RetCode = AsciiStrHexToUintn (&Packet[1]);
-  
-  // Find 1st comma 
-  for (;*Packet != '\0' && *Packet != ',';  Packet++);  
-  if (*Packet == '\0') {
-    *ErrNo = 0;
-    return RetCode;
-  }
-  
-  *ErrNo = AsciiStrHexToUintn (++Packet);
-
-  // Find 2nd comma 
-  for (;*Packet != '\0' && *Packet != ',';  Packet++);  
-  if (*Packet == '\0') {
-    return RetCode;
-  }
-  
-  if (*(++Packet) == 'C') {
-    GdbCtrlCBreakMessage (*ErrNo);  
-  }
-  
-  return RetCode;
-}
-
-
-/**
-  Read data from a FileDescriptor. On success number of bytes read is returned. Zero indicates 
-  the end of a file. On error -1 is returned. If count is zero, GdbRead returns zero.
-
-  @param  FileDescriptor   Device to talk to.
-  @param  Buffer           Buffer to hold Count bytes that were read
-  @param  Count            Number of bytes to transfer. 
-
-  @retval -1               Error
-  @retval {other}          Number of bytes read.
-
-**/
-INTN
-GdbRead (
-  IN  INTN    FileDescriptor,
-  OUT VOID    *Buffer,
-  IN  UINTN   Count
-  )
-{
-  CHAR8   Packet[128];
-  UINTN   Size;
-  INTN    RetCode;
-  UINTN   ErrNo;
-  BOOLEAN ReceiveDone = FALSE;
-   
-  // Send:
-  // "Fread,XX,YYYYYYYY,XX
-  //
-  // XX - FileDescriptor in ASCII
-  // YYYYYYYY - Buffer address in ASCII 
-  // XX - Count in ASCII
-  // SS - check sum
-  //
-  Size = AsciiSPrint (Packet, sizeof (Packet), "Fread,%x,%x,%x", FileDescriptor, Buffer, Count);
-  // Packet array is too small if you got this ASSERT
-  ASSERT (Size < sizeof (Packet));
-  
-  gProcessingFPacket = TRUE;
-  SendPacket (Packet);
-  Print ((CHAR16 *)L"Packet sent..\n");
-
-  do {
-    // Reply:
-    ReceivePacket (Packet, sizeof (Packet));
-    Print ((CHAR16 *)L"Command received..%c\n", Packet[0]);
-
-    // Process GDB commands
-    switch (Packet[0]) {
-      //Write memory command.
-      //M addr,length:XX...
-      case    'M':
-        WriteToMemory (Packet);
-        break;
-
-      //Fretcode, errno, Ctrl-C flag
-      //retcode - Count read
-      case    'F':
-        //Once target receives F reply packet that means the previous
-        //transactions are finished.
-        ReceiveDone = TRUE;
-        break;
-
-      //Send empty buffer
-      default    :
-        SendNotSupported();
-        break;
-    }
-  } while (ReceiveDone == FALSE);
-
-  RetCode = GdbParseFReplyPacket (Packet, &ErrNo);
-  Print ((CHAR16 *)L"RetCode: %x..ErrNo: %x..\n", RetCode, ErrNo);
-  
-  if (ErrNo > 0) {
-    //Send error to the host if there is any.
-    SendError ((UINT8)ErrNo);
-  }
-  
-  gProcessingFPacket = FALSE;
-
-  return RetCode;
-}  
-  
-
-/**
-  Write data to a FileDescriptor. On success number of bytes written is returned. Zero indicates 
-  nothing was written. On error -1 is returned. 
-
-  @param  FileDescriptor   Device to talk to.
-  @param  Buffer           Buffer to hold Count bytes that are to be written
-  @param  Count            Number of bytes to transfer. 
-
-  @retval -1               Error
-  @retval {other}          Number of bytes written.
-
-**/
-INTN
-GdbWrite (
-  IN  INTN          FileDescriptor,
-  OUT CONST VOID    *Buffer,
-  IN  UINTN         Count
-  )
-{
-  CHAR8   Packet[128];
-  UINTN   Size;
-  INTN    RetCode;
-  UINTN   ErrNo;
-  BOOLEAN ReceiveDone = FALSE;
-
-  // Send:
-  // #Fwrite,XX,YYYYYYYY,XX$SS
-  //
-  // XX - FileDescriptor in ASCII
-  // YYYYYYYY - Buffer address in ASCII 
-  // XX - Count in ASCII
-  // SS - check sum
-  //
-  Size = AsciiSPrint (Packet, sizeof (Packet), "Fwrite,%x,%x,%x", FileDescriptor, Buffer, Count);
-  // Packet array is too small if you got this ASSERT
-  ASSERT (Size < sizeof (Packet));
-  
-  SendPacket (Packet);
-  Print ((CHAR16 *)L"Packet sent..\n");
-
-  do {
-    // Reply:
-    ReceivePacket (Packet, sizeof (Packet));
-    Print ((CHAR16 *)L"Command received..%c\n", Packet[0]);
-
-    // Process GDB commands
-    switch (Packet[0]) {
-      //Read memory command.
-      //m addr,length. 
-      case    'm':
-        ReadFromMemory (Packet);
-        break;
-
-      //Fretcode, errno, Ctrl-C flag
-      //retcode - Count read
-      case    'F':
-        //Once target receives F reply packet that means the previous 
-        //transactions are finished.
-        ReceiveDone = TRUE;
-        break;
-      
-      //Send empty buffer
-      default    :  
-        SendNotSupported();
-        break;
-    }
-  } while (ReceiveDone == FALSE);
-
-  RetCode = GdbParseFReplyPacket (Packet, &ErrNo);
-  Print ((CHAR16 *)L"RetCode: %x..ErrNo: %x..\n", RetCode, ErrNo);
-
-  //Send error to the host if there is any.
-  if (ErrNo > 0) {
-    SendError((UINT8)ErrNo);
-  }
- 
-  return RetCode;
-}
-
-
-/**
-  Reset the serial device.
-
-  @param  This              Protocol instance pointer.
-                            
-  @retval EFI_SUCCESS       The device was reset.
-  @retval EFI_DEVICE_ERROR  The serial device could not be reset.
-
-**/
-EFI_STATUS
-EFIAPI
-GdbSerialReset (
-  IN EFI_SERIAL_IO_PROTOCOL  *This
-  )
-{
-  return EFI_SUCCESS;
-}
-
-
-/**
-  Sets the baud rate, receive FIFO depth, transmit/receice time out, parity, 
-  data buts, and stop bits on a serial device.
-
-  @param  This             Protocol instance pointer.
-  @param  BaudRate         The requested baud rate. A BaudRate value of 0 will use the the
-                           device's default interface speed.
-  @param  ReveiveFifoDepth The requested depth of the FIFO on the receive side of the
-                           serial interface. A ReceiveFifoDepth value of 0 will use
-                           the device's dfault FIFO depth.
-  @param  Timeout          The requested time out for a single character in microseconds.
-                           This timeout applies to both the transmit and receive side of the
-                           interface. A Timeout value of 0 will use the device's default time
-                           out value.
-  @param  Parity           The type of parity to use on this serial device. A Parity value of
-                           DefaultParity will use the device's default parity value.
-  @param  DataBits         The number of data bits to use on the serial device. A DataBits
-                           vaule of 0 will use the device's default data bit setting.
-  @param  StopBits         The number of stop bits to use on this serial device. A StopBits
-                           value of DefaultStopBits will use the device's default number of
-                           stop bits.
-
-  @retval EFI_SUCCESS      The device was reset.
-  @retval EFI_DEVICE_ERROR The serial device could not be reset.
-
-**/
-EFI_STATUS
-EFIAPI
-GdbSerialSetAttributes (
-  IN EFI_SERIAL_IO_PROTOCOL  *This,
-  IN UINT64                  BaudRate,
-  IN UINT32                  ReceiveFifoDepth,
-  IN UINT32                  Timeout,
-  IN EFI_PARITY_TYPE         Parity,
-  IN UINT8                   DataBits,
-  IN EFI_STOP_BITS_TYPE      StopBits
-  )
-{
-  return EFI_UNSUPPORTED;
-}
-
-
-/**
-  Set the control bits on a serial device
-
-  @param  This             Protocol instance pointer.
-  @param  Control          Set the bits of Control that are settable.
-
-  @retval EFI_SUCCESS      The new control bits were set on the serial device.
-  @retval EFI_UNSUPPORTED  The serial device does not support this operation.
-  @retval EFI_DEVICE_ERROR The serial device is not functioning correctly.
-
-**/
-EFI_STATUS
-EFIAPI
-GdbSerialSetControl (
-  IN EFI_SERIAL_IO_PROTOCOL  *This,
-  IN UINT32                  Control
-  )
-{
-  return EFI_UNSUPPORTED;
-}
-
-
-/**
-  Retrieves the status of thecontrol bits on a serial device
-
-  @param  This              Protocol instance pointer.
-  @param  Control           A pointer to return the current Control signals from the serial device.
-                            
-  @retval EFI_SUCCESS       The control bits were read from the serial device.
-  @retval EFI_DEVICE_ERROR  The serial device is not functioning correctly.
-
-**/
-EFI_STATUS
-EFIAPI
-GdbSerialGetControl (
-  IN EFI_SERIAL_IO_PROTOCOL  *This,
-  OUT UINT32                 *Control
-  )
-{
-  return EFI_UNSUPPORTED;
-}
-
-
-/**
-  Writes data to a serial device.
-
-  @param  This              Protocol instance pointer.
-  @param  BufferSize        On input, the size of the Buffer. On output, the amount of
-                            data actually written.
-  @param  Buffer            The buffer of data to write
-
-  @retval EFI_SUCCESS       The data was written.
-  @retval EFI_DEVICE_ERROR  The device reported an error.
-  @retval EFI_TIMEOUT       The data write was stopped due to a timeout.
-
-**/
-EFI_STATUS
-EFIAPI
-GdbSerialWrite (
-  IN EFI_SERIAL_IO_PROTOCOL  *This,
-  IN OUT UINTN               *BufferSize,
-  IN VOID                    *Buffer
-  )
-{
-  GDB_SERIAL_DEV  *SerialDev;
-  UINTN            Return;
-
-  SerialDev = GDB_SERIAL_DEV_FROM_THIS (This);
-  
-  Return = GdbWrite (SerialDev->OutFileDescriptor, Buffer, *BufferSize);
-  if (Return == (UINTN)-1) {
-    return EFI_DEVICE_ERROR;
-  }
-  
-  if (Return != *BufferSize) {
-    *BufferSize = Return;
-  }
-  
-  return EFI_SUCCESS;
-}
-
-/**
-  Writes data to a serial device.
-
-  @param  This              Protocol instance pointer.
-  @param  BufferSize        On input, the size of the Buffer. On output, the amount of
-                            data returned in Buffer.
-  @param  Buffer            The buffer to return the data into.
-
-  @retval EFI_SUCCESS       The data was read.
-  @retval EFI_DEVICE_ERROR  The device reported an error.
-  @retval EFI_TIMEOUT       The data write was stopped due to a timeout.
-
-**/
-
-EFI_STATUS
-EFIAPI
-GdbSerialRead (
-  IN EFI_SERIAL_IO_PROTOCOL  *This,
-  IN OUT UINTN               *BufferSize,
-  OUT VOID                   *Buffer
-  )
-{
-  GDB_SERIAL_DEV  *SerialDev;
-  UINTN            Return;
-
-  SerialDev = GDB_SERIAL_DEV_FROM_THIS (This);
-  
-  Return = GdbRead (SerialDev->InFileDescriptor, Buffer, *BufferSize);
-  if (Return == (UINTN)-1) {
-    return EFI_DEVICE_ERROR;
-  }
-  
-  if (Return != *BufferSize) {
-    *BufferSize = Return;
-  }
-  
-  return EFI_SUCCESS;
-}
-
-
-// 
-// Template used to initailize the GDB Serial IO protocols
-//
-GDB_SERIAL_DEV gdbSerialDevTemplate = {
-  GDB_SERIAL_DEV_SIGNATURE,
-  NULL,
-  
-  { // SerialIo
-    SERIAL_IO_INTERFACE_REVISION,
-    GdbSerialReset,
-    GdbSerialSetAttributes,
-    GdbSerialSetControl,
-    GdbSerialGetControl,
-    GdbSerialWrite,
-    GdbSerialRead,
-    NULL
-  },
-  { // SerialMode
-    0,      // ControlMask
-    0,      // Timeout
-    0,      // BaudRate
-    1,      // RceiveFifoDepth
-    0,      // DataBits
-    0,      // Parity
-    0       // StopBits
-  },
-  { 
-    {
-      HARDWARE_DEVICE_PATH,
-      HW_VENDOR_DP,
-      {
-        (UINT8) (sizeof (VENDOR_DEVICE_PATH) + sizeof (UINT32)),
-        (UINT8) ((sizeof (VENDOR_DEVICE_PATH) + sizeof (UINT32)) >> 8)
-      },
-      EFI_SERIAL_IO_PROTOCOL_GUID,
-    },
-    0,
-    {
-      END_DEVICE_PATH_TYPE,
-      END_ENTIRE_DEVICE_PATH_SUBTYPE,
-      {
-        (UINT8) (sizeof (EFI_DEVICE_PATH_PROTOCOL)),
-        (UINT8) (sizeof (EFI_DEVICE_PATH_PROTOCOL) >> 8)
-      }
-    },
-  },
-  GDB_STDIN,
-  GDB_STDOUT
-};
-
-
-/**
-  Make two serial consoles: 1) StdIn and StdOut via GDB. 2) StdErr via GDB.
-  
-  These console show up on the remote system running GDB
-
-**/
-VOID
-GdbInitializeSerialConsole (
-  VOID
-  )
-{
-  EFI_STATUS      Status;
-  GDB_SERIAL_DEV  *StdOutSerialDev;
-  GDB_SERIAL_DEV  *StdErrSerialDev;
-
-  // Use the template to make a copy of the Serial Console private data structure.
-  StdOutSerialDev = AllocateCopyPool (sizeof (GDB_SERIAL_DEV),  &gdbSerialDevTemplate);
-  ASSERT (StdOutSerialDev != NULL);
-  
-  // Fixup pointer after the copy
-  StdOutSerialDev->SerialIo.Mode = &StdOutSerialDev->SerialMode;
-  
-  StdErrSerialDev = AllocateCopyPool (sizeof (GDB_SERIAL_DEV),  &gdbSerialDevTemplate);
-  ASSERT (StdErrSerialDev != NULL);
-
-  // Fixup pointer and modify stuff that is different for StdError
-  StdErrSerialDev->SerialIo.Mode = &StdErrSerialDev->SerialMode;  
-  StdErrSerialDev->DevicePath.Index = 1;
-  StdErrSerialDev->OutFileDescriptor = GDB_STDERR;
-  
-  // Make a new handle with Serial IO protocol and its device path on it.
-  Status = gBS->InstallMultipleProtocolInterfaces (
-                  &StdOutSerialDev->Handle, 
-                  &gEfiSerialIoProtocolGuid,   &StdOutSerialDev->SerialIo,
-                  &gEfiDevicePathProtocolGuid, &StdOutSerialDev->DevicePath,
-                  NULL
-                  );
-  ASSERT_EFI_ERROR (Status);
-
-  // Make a new handle with Serial IO protocol and its device path on it.
-  Status = gBS->InstallMultipleProtocolInterfaces (
-                  &StdErrSerialDev->Handle, 
-                  &gEfiSerialIoProtocolGuid,   &StdErrSerialDev->SerialIo,
-                  &gEfiDevicePathProtocolGuid, &StdErrSerialDev->DevicePath,
-                  NULL
-                  );
-  ASSERT_EFI_ERROR (Status);
-}
-
+/** @file

+  Serial IO Abstraction for GDB stub. This allows an EFI consoles that shows up on the system 

+  running GDB. One consle for error information and another console for user input/output.

+  

+  Basic packet format is $packet-data#checksum. So every comand has 4 bytes of overhead: $, 

+  #, 0, 0. The 0 and 0 are the ascii characters for the checksum. 

+  

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include <GdbStubInternal.h>

+

+//

+// Set TRUE if F Reply package signals a ctrl-c. We can not process the Ctrl-c

+// here we need to wait for the periodic callback to do this. 

+//

+BOOLEAN gCtrlCBreakFlag = FALSE;

+

+//

+// If the periodic callback is called while we are processing an F packet we need

+// to let the callback know to not read from the serail stream as it could steal

+// characters from the F reponse packet

+//

+BOOLEAN gProcessingFPacket = FALSE;

+

+/**

+  Process a control-C break message. 

+  

+  Currently a place holder, remove the ASSERT when it gets implemented. 

+

+  @param  ErrNo   Error infomration from the F reply packet or other source

+

+**/

+

+VOID

+GdbCtrlCBreakMessage (

+  IN  UINTN ErrNo

+  )

+{

+  // See D.10.5 of gdb.pdf

+  // This should look like a break message. Should look like SIGINT

+

+  /* TODO: Make sure if we should do anything with ErrNo */

+  //Turn on the global Ctrl-C flag.

+  gCtrlCBreakFlag = TRUE;

+}

+

+

+/**

+  Parse the F reply packet and extract the return value and an ErrNo if it exists.

+

+  @param  Packet  Packet to parse like an F reply packet

+  @param  ErrNo   Buffer to hold Count bytes that were read

+

+  @retval -1      Error, not a valid F reply packet 

+  @retval other   Return the return code from the F reply packet 

+

+**/

+INTN

+GdbParseFReplyPacket (

+  IN  CHAR8   *Packet,

+  OUT UINTN   *ErrNo   

+  )

+{

+  INTN   RetCode;

+   

+  if (Packet[0] != 'F') {

+    // A valid responce would be an F packet

+    return -1;

+  }

+  

+  RetCode = AsciiStrHexToUintn (&Packet[1]);

+  

+  // Find 1st comma 

+  for (;*Packet != '\0' && *Packet != ',';  Packet++);  

+  if (*Packet == '\0') {

+    *ErrNo = 0;

+    return RetCode;

+  }

+  

+  *ErrNo = AsciiStrHexToUintn (++Packet);

+

+  // Find 2nd comma 

+  for (;*Packet != '\0' && *Packet != ',';  Packet++);  

+  if (*Packet == '\0') {

+    return RetCode;

+  }

+  

+  if (*(++Packet) == 'C') {

+    GdbCtrlCBreakMessage (*ErrNo);  

+  }

+  

+  return RetCode;

+}

+

+

+/**

+  Read data from a FileDescriptor. On success number of bytes read is returned. Zero indicates 

+  the end of a file. On error -1 is returned. If count is zero, GdbRead returns zero.

+

+  @param  FileDescriptor   Device to talk to.

+  @param  Buffer           Buffer to hold Count bytes that were read

+  @param  Count            Number of bytes to transfer. 

+

+  @retval -1               Error

+  @retval {other}          Number of bytes read.

+

+**/

+INTN

+GdbRead (

+  IN  INTN    FileDescriptor,

+  OUT VOID    *Buffer,

+  IN  UINTN   Count

+  )

+{

+  CHAR8   Packet[128];

+  UINTN   Size;

+  INTN    RetCode;

+  UINTN   ErrNo;

+  BOOLEAN ReceiveDone = FALSE;

+   

+  // Send:

+  // "Fread,XX,YYYYYYYY,XX

+  //

+  // XX - FileDescriptor in ASCII

+  // YYYYYYYY - Buffer address in ASCII 

+  // XX - Count in ASCII

+  // SS - check sum

+  //

+  Size = AsciiSPrint (Packet, sizeof (Packet), "Fread,%x,%x,%x", FileDescriptor, Buffer, Count);

+  // Packet array is too small if you got this ASSERT

+  ASSERT (Size < sizeof (Packet));

+  

+  gProcessingFPacket = TRUE;

+  SendPacket (Packet);

+  Print ((CHAR16 *)L"Packet sent..\n");

+

+  do {

+    // Reply:

+    ReceivePacket (Packet, sizeof (Packet));

+    Print ((CHAR16 *)L"Command received..%c\n", Packet[0]);

+

+    // Process GDB commands

+    switch (Packet[0]) {

+      //Write memory command.

+      //M addr,length:XX...

+      case    'M':

+        WriteToMemory (Packet);

+        break;

+

+      //Fretcode, errno, Ctrl-C flag

+      //retcode - Count read

+      case    'F':

+        //Once target receives F reply packet that means the previous

+        //transactions are finished.

+        ReceiveDone = TRUE;

+        break;

+

+      //Send empty buffer

+      default    :

+        SendNotSupported();

+        break;

+    }

+  } while (ReceiveDone == FALSE);

+

+  RetCode = GdbParseFReplyPacket (Packet, &ErrNo);

+  Print ((CHAR16 *)L"RetCode: %x..ErrNo: %x..\n", RetCode, ErrNo);

+  

+  if (ErrNo > 0) {

+    //Send error to the host if there is any.

+    SendError ((UINT8)ErrNo);

+  }

+  

+  gProcessingFPacket = FALSE;

+

+  return RetCode;

+}  

+  

+

+/**

+  Write data to a FileDescriptor. On success number of bytes written is returned. Zero indicates 

+  nothing was written. On error -1 is returned. 

+

+  @param  FileDescriptor   Device to talk to.

+  @param  Buffer           Buffer to hold Count bytes that are to be written

+  @param  Count            Number of bytes to transfer. 

+

+  @retval -1               Error

+  @retval {other}          Number of bytes written.

+

+**/

+INTN

+GdbWrite (

+  IN  INTN          FileDescriptor,

+  OUT CONST VOID    *Buffer,

+  IN  UINTN         Count

+  )

+{

+  CHAR8   Packet[128];

+  UINTN   Size;

+  INTN    RetCode;

+  UINTN   ErrNo;

+  BOOLEAN ReceiveDone = FALSE;

+

+  // Send:

+  // #Fwrite,XX,YYYYYYYY,XX$SS

+  //

+  // XX - FileDescriptor in ASCII

+  // YYYYYYYY - Buffer address in ASCII 

+  // XX - Count in ASCII

+  // SS - check sum

+  //

+  Size = AsciiSPrint (Packet, sizeof (Packet), "Fwrite,%x,%x,%x", FileDescriptor, Buffer, Count);

+  // Packet array is too small if you got this ASSERT

+  ASSERT (Size < sizeof (Packet));

+  

+  SendPacket (Packet);

+  Print ((CHAR16 *)L"Packet sent..\n");

+

+  do {

+    // Reply:

+    ReceivePacket (Packet, sizeof (Packet));

+    Print ((CHAR16 *)L"Command received..%c\n", Packet[0]);

+

+    // Process GDB commands

+    switch (Packet[0]) {

+      //Read memory command.

+      //m addr,length. 

+      case    'm':

+        ReadFromMemory (Packet);

+        break;

+

+      //Fretcode, errno, Ctrl-C flag

+      //retcode - Count read

+      case    'F':

+        //Once target receives F reply packet that means the previous 

+        //transactions are finished.

+        ReceiveDone = TRUE;

+        break;

+      

+      //Send empty buffer

+      default    :  

+        SendNotSupported();

+        break;

+    }

+  } while (ReceiveDone == FALSE);

+

+  RetCode = GdbParseFReplyPacket (Packet, &ErrNo);

+  Print ((CHAR16 *)L"RetCode: %x..ErrNo: %x..\n", RetCode, ErrNo);

+

+  //Send error to the host if there is any.

+  if (ErrNo > 0) {

+    SendError((UINT8)ErrNo);

+  }

+ 

+  return RetCode;

+}

+

+

+/**

+  Reset the serial device.

+

+  @param  This              Protocol instance pointer.

+                            

+  @retval EFI_SUCCESS       The device was reset.

+  @retval EFI_DEVICE_ERROR  The serial device could not be reset.

+

+**/

+EFI_STATUS

+EFIAPI

+GdbSerialReset (

+  IN EFI_SERIAL_IO_PROTOCOL  *This

+  )

+{

+  return EFI_SUCCESS;

+}

+

+

+/**

+  Sets the baud rate, receive FIFO depth, transmit/receice time out, parity, 

+  data buts, and stop bits on a serial device.

+

+  @param  This             Protocol instance pointer.

+  @param  BaudRate         The requested baud rate. A BaudRate value of 0 will use the the

+                           device's default interface speed.

+  @param  ReveiveFifoDepth The requested depth of the FIFO on the receive side of the

+                           serial interface. A ReceiveFifoDepth value of 0 will use

+                           the device's dfault FIFO depth.

+  @param  Timeout          The requested time out for a single character in microseconds.

+                           This timeout applies to both the transmit and receive side of the

+                           interface. A Timeout value of 0 will use the device's default time

+                           out value.

+  @param  Parity           The type of parity to use on this serial device. A Parity value of

+                           DefaultParity will use the device's default parity value.

+  @param  DataBits         The number of data bits to use on the serial device. A DataBits

+                           vaule of 0 will use the device's default data bit setting.

+  @param  StopBits         The number of stop bits to use on this serial device. A StopBits

+                           value of DefaultStopBits will use the device's default number of

+                           stop bits.

+

+  @retval EFI_SUCCESS      The device was reset.

+  @retval EFI_DEVICE_ERROR The serial device could not be reset.

+

+**/

+EFI_STATUS

+EFIAPI

+GdbSerialSetAttributes (

+  IN EFI_SERIAL_IO_PROTOCOL  *This,

+  IN UINT64                  BaudRate,

+  IN UINT32                  ReceiveFifoDepth,

+  IN UINT32                  Timeout,

+  IN EFI_PARITY_TYPE         Parity,

+  IN UINT8                   DataBits,

+  IN EFI_STOP_BITS_TYPE      StopBits

+  )

+{

+  return EFI_UNSUPPORTED;

+}

+

+

+/**

+  Set the control bits on a serial device

+

+  @param  This             Protocol instance pointer.

+  @param  Control          Set the bits of Control that are settable.

+

+  @retval EFI_SUCCESS      The new control bits were set on the serial device.

+  @retval EFI_UNSUPPORTED  The serial device does not support this operation.

+  @retval EFI_DEVICE_ERROR The serial device is not functioning correctly.

+

+**/

+EFI_STATUS

+EFIAPI

+GdbSerialSetControl (

+  IN EFI_SERIAL_IO_PROTOCOL  *This,

+  IN UINT32                  Control

+  )

+{

+  return EFI_UNSUPPORTED;

+}

+

+

+/**

+  Retrieves the status of thecontrol bits on a serial device

+

+  @param  This              Protocol instance pointer.

+  @param  Control           A pointer to return the current Control signals from the serial device.

+                            

+  @retval EFI_SUCCESS       The control bits were read from the serial device.

+  @retval EFI_DEVICE_ERROR  The serial device is not functioning correctly.

+

+**/

+EFI_STATUS

+EFIAPI

+GdbSerialGetControl (

+  IN EFI_SERIAL_IO_PROTOCOL  *This,

+  OUT UINT32                 *Control

+  )

+{

+  return EFI_UNSUPPORTED;

+}

+

+

+/**

+  Writes data to a serial device.

+

+  @param  This              Protocol instance pointer.

+  @param  BufferSize        On input, the size of the Buffer. On output, the amount of

+                            data actually written.

+  @param  Buffer            The buffer of data to write

+

+  @retval EFI_SUCCESS       The data was written.

+  @retval EFI_DEVICE_ERROR  The device reported an error.

+  @retval EFI_TIMEOUT       The data write was stopped due to a timeout.

+

+**/

+EFI_STATUS

+EFIAPI

+GdbSerialWrite (

+  IN EFI_SERIAL_IO_PROTOCOL  *This,

+  IN OUT UINTN               *BufferSize,

+  IN VOID                    *Buffer

+  )

+{

+  GDB_SERIAL_DEV  *SerialDev;

+  UINTN            Return;

+

+  SerialDev = GDB_SERIAL_DEV_FROM_THIS (This);

+  

+  Return = GdbWrite (SerialDev->OutFileDescriptor, Buffer, *BufferSize);

+  if (Return == (UINTN)-1) {

+    return EFI_DEVICE_ERROR;

+  }

+  

+  if (Return != *BufferSize) {

+    *BufferSize = Return;

+  }

+  

+  return EFI_SUCCESS;

+}

+

+/**

+  Writes data to a serial device.

+

+  @param  This              Protocol instance pointer.

+  @param  BufferSize        On input, the size of the Buffer. On output, the amount of

+                            data returned in Buffer.

+  @param  Buffer            The buffer to return the data into.

+

+  @retval EFI_SUCCESS       The data was read.

+  @retval EFI_DEVICE_ERROR  The device reported an error.

+  @retval EFI_TIMEOUT       The data write was stopped due to a timeout.

+

+**/

+

+EFI_STATUS

+EFIAPI

+GdbSerialRead (

+  IN EFI_SERIAL_IO_PROTOCOL  *This,

+  IN OUT UINTN               *BufferSize,

+  OUT VOID                   *Buffer

+  )

+{

+  GDB_SERIAL_DEV  *SerialDev;

+  UINTN            Return;

+

+  SerialDev = GDB_SERIAL_DEV_FROM_THIS (This);

+  

+  Return = GdbRead (SerialDev->InFileDescriptor, Buffer, *BufferSize);

+  if (Return == (UINTN)-1) {

+    return EFI_DEVICE_ERROR;

+  }

+  

+  if (Return != *BufferSize) {

+    *BufferSize = Return;

+  }

+  

+  return EFI_SUCCESS;

+}

+

+

+// 

+// Template used to initailize the GDB Serial IO protocols

+//

+GDB_SERIAL_DEV gdbSerialDevTemplate = {

+  GDB_SERIAL_DEV_SIGNATURE,

+  NULL,

+  

+  { // SerialIo

+    SERIAL_IO_INTERFACE_REVISION,

+    GdbSerialReset,

+    GdbSerialSetAttributes,

+    GdbSerialSetControl,

+    GdbSerialGetControl,

+    GdbSerialWrite,

+    GdbSerialRead,

+    NULL

+  },

+  { // SerialMode

+    0,      // ControlMask

+    0,      // Timeout

+    0,      // BaudRate

+    1,      // RceiveFifoDepth

+    0,      // DataBits

+    0,      // Parity

+    0       // StopBits

+  },

+  { 

+    {

+      HARDWARE_DEVICE_PATH,

+      HW_VENDOR_DP,

+      {

+        (UINT8) (sizeof (VENDOR_DEVICE_PATH) + sizeof (UINT32)),

+        (UINT8) ((sizeof (VENDOR_DEVICE_PATH) + sizeof (UINT32)) >> 8)

+      },

+      EFI_SERIAL_IO_PROTOCOL_GUID,

+    },

+    0,

+    {

+      END_DEVICE_PATH_TYPE,

+      END_ENTIRE_DEVICE_PATH_SUBTYPE,

+      {

+        (UINT8) (sizeof (EFI_DEVICE_PATH_PROTOCOL)),

+        (UINT8) (sizeof (EFI_DEVICE_PATH_PROTOCOL) >> 8)

+      }

+    },

+  },

+  GDB_STDIN,

+  GDB_STDOUT

+};

+

+

+/**

+  Make two serial consoles: 1) StdIn and StdOut via GDB. 2) StdErr via GDB.

+  

+  These console show up on the remote system running GDB

+

+**/

+VOID

+GdbInitializeSerialConsole (

+  VOID

+  )

+{

+  EFI_STATUS      Status;

+  GDB_SERIAL_DEV  *StdOutSerialDev;

+  GDB_SERIAL_DEV  *StdErrSerialDev;

+

+  // Use the template to make a copy of the Serial Console private data structure.

+  StdOutSerialDev = AllocateCopyPool (sizeof (GDB_SERIAL_DEV),  &gdbSerialDevTemplate);

+  ASSERT (StdOutSerialDev != NULL);

+  

+  // Fixup pointer after the copy

+  StdOutSerialDev->SerialIo.Mode = &StdOutSerialDev->SerialMode;

+  

+  StdErrSerialDev = AllocateCopyPool (sizeof (GDB_SERIAL_DEV),  &gdbSerialDevTemplate);

+  ASSERT (StdErrSerialDev != NULL);

+

+  // Fixup pointer and modify stuff that is different for StdError

+  StdErrSerialDev->SerialIo.Mode = &StdErrSerialDev->SerialMode;  

+  StdErrSerialDev->DevicePath.Index = 1;

+  StdErrSerialDev->OutFileDescriptor = GDB_STDERR;

+  

+  // Make a new handle with Serial IO protocol and its device path on it.

+  Status = gBS->InstallMultipleProtocolInterfaces (

+                  &StdOutSerialDev->Handle, 

+                  &gEfiSerialIoProtocolGuid,   &StdOutSerialDev->SerialIo,

+                  &gEfiDevicePathProtocolGuid, &StdOutSerialDev->DevicePath,

+                  NULL

+                  );

+  ASSERT_EFI_ERROR (Status);

+

+  // Make a new handle with Serial IO protocol and its device path on it.

+  Status = gBS->InstallMultipleProtocolInterfaces (

+                  &StdErrSerialDev->Handle, 

+                  &gEfiSerialIoProtocolGuid,   &StdErrSerialDev->SerialIo,

+                  &gEfiDevicePathProtocolGuid, &StdErrSerialDev->DevicePath,

+                  NULL

+                  );

+  ASSERT_EFI_ERROR (Status);

+}

+

diff --git a/EmbeddedPkg/Include/Library/DebugAgentTimerLib.h b/EmbeddedPkg/Include/Library/DebugAgentTimerLib.h
index 6a363e00..1b976950 100755
--- a/EmbeddedPkg/Include/Library/DebugAgentTimerLib.h
+++ b/EmbeddedPkg/Include/Library/DebugAgentTimerLib.h
@@ -60,4 +60,4 @@ DebugAgentTimerEndOfInterrupt (
 #endif

 

 

-  
\ No newline at end of file
+  
\ No newline at end of file
diff --git a/EmbeddedPkg/Include/Library/DmaLib.h b/EmbeddedPkg/Include/Library/DmaLib.h
index badaf213..6e876dd2 100755
--- a/EmbeddedPkg/Include/Library/DmaLib.h
+++ b/EmbeddedPkg/Include/Library/DmaLib.h
@@ -1,45 +1,45 @@
-/** @file
-  DMA abstraction library APIs. Based on UEFI PCI IO protocol DMA abstractions.
-  At some point these functions will probably end up in a non PCI protocol 
-  for embedded systems.
-
+/** @file

+  DMA abstraction library APIs. Based on UEFI PCI IO protocol DMA abstractions.

+  At some point these functions will probably end up in a non PCI protocol 

+  for embedded systems.

+

   DMA Bus Master Read Operation:

-    Call DmaMap() for MapOperationBusMasterRead. 
-    Program the DMA Bus Master with the DeviceAddress returned by DmaMap(). 
-    Start the DMA Bus Master. 
-    Wait for DMA Bus Master to complete the read operation. 
-    Call DmaUnmap().
-
-  DMA Bus Master Write Operation:
+    Call DmaMap() for MapOperationBusMasterRead. 

+    Program the DMA Bus Master with the DeviceAddress returned by DmaMap(). 

+    Start the DMA Bus Master. 

+    Wait for DMA Bus Master to complete the read operation. 

+    Call DmaUnmap().

+

+  DMA Bus Master Write Operation:

     Call DmaMap() for MapOperationBusMasterWrite.

     Program the DMA Bus Master with the DeviceAddress returned by DmaMap().

     Start the DMA Bus Master.

     Wait for DMA Bus Master to complete the write operation.

-    Call DmaUnmap().
-
-  DMA Bus Master Common Buffer Operation:
-    Call DmaAllocateBuffer() to allocate a common buffer. 
-    Call DmaMap() for MapOperationBusMasterCommonBuffer. 
-    Program the DMA Bus Master with the DeviceAddress returned by DmaMap(). 
-    The common buffer can now be accessed equally by the processor and the DMA bus master. 
-    Call DmaUnmap(). 
-    Call DmaFreeBuffer().
-
-  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __DMA_LIB_H__
-#define __DMA_LIB_H__
-
+    Call DmaUnmap().

+

+  DMA Bus Master Common Buffer Operation:

+    Call DmaAllocateBuffer() to allocate a common buffer. 

+    Call DmaMap() for MapOperationBusMasterCommonBuffer. 

+    Program the DMA Bus Master with the DeviceAddress returned by DmaMap(). 

+    The common buffer can now be accessed equally by the processor and the DMA bus master. 

+    Call DmaUnmap(). 

+    Call DmaFreeBuffer().

+

+  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __DMA_LIB_H__

+#define __DMA_LIB_H__

+

 typedef enum {

   ///

   /// A read operation from system memory by a bus master.

@@ -56,10 +56,10 @@ typedef enum {
   MapOperationBusMasterCommonBuffer,

   MapOperationMaximum

 } DMA_MAP_OPERATION;

-
-
-
-
+

+

+

+

 /**                                                                 

   Provides the DMA controller-specific addresses needed to access system memory.

   

@@ -79,20 +79,20 @@ typedef enum {
   @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.

   @retval EFI_DEVICE_ERROR      The system hardware could not map the requested address.

                                    

-**/
-EFI_STATUS
-EFIAPI
-DmaMap (
-  IN     DMA_MAP_OPERATION              Operation,
+**/

+EFI_STATUS

+EFIAPI

+DmaMap (

+  IN     DMA_MAP_OPERATION              Operation,

   IN     VOID                           *HostAddress,

   IN OUT UINTN                          *NumberOfBytes,

   OUT    PHYSICAL_ADDRESS               *DeviceAddress,

   OUT    VOID                           **Mapping

-  );
-
-
-
-
+  );

+

+

+

+

 /**                                                                 

   Completes the DmaMapBusMasterRead, DmaMapBusMasterWrite, or DmaMapBusMasterCommonBuffer

   operation and releases any corresponding resources.

@@ -102,14 +102,14 @@ DmaMap (
   @retval EFI_SUCCESS           The range was unmapped.

   @retval EFI_DEVICE_ERROR      The data was not committed to the target system memory.

                                    

-**/
-EFI_STATUS
-EFIAPI
-DmaUnmap (
+**/

+EFI_STATUS

+EFIAPI

+DmaUnmap (

   IN  VOID                         *Mapping

-  );
-
-
+  );

+

+

 /**                                                                 

   Allocates pages that are suitable for an DmaMap() of type MapOperationBusMasterCommonBuffer.

   mapping.                                                                       

@@ -126,16 +126,16 @@ DmaUnmap (
   @retval EFI_INVALID_PARAMETER One or more parameters are invalid.

   @retval EFI_OUT_OF_RESOURCES  The memory pages could not be allocated.  

                                    

-**/
-EFI_STATUS
-EFIAPI
-DmaAllocateBuffer (
-  IN  EFI_MEMORY_TYPE              MemoryType,
+**/

+EFI_STATUS

+EFIAPI

+DmaAllocateBuffer (

+  IN  EFI_MEMORY_TYPE              MemoryType,

   IN  UINTN                        Pages,

   OUT VOID                         **HostAddress

   );

-
-
+

+

 /**                                                                 

   Frees memory that was allocated with DmaAllocateBuffer().

             

@@ -147,13 +147,13 @@ DmaAllocateBuffer (
                                 was not allocated with DmaAllocateBuffer().

                                      

 **/

-EFI_STATUS
-EFIAPI
-DmaFreeBuffer (
+EFI_STATUS

+EFIAPI

+DmaFreeBuffer (

   IN  UINTN                        Pages,

   IN  VOID                         *HostAddress

   );

-
-
-#endif 
-
+

+

+#endif 

+

diff --git a/EmbeddedPkg/Include/Library/EblAddExternalCommandLib.h b/EmbeddedPkg/Include/Library/EblAddExternalCommandLib.h
index c00d04f4..f760f8e2 100644
--- a/EmbeddedPkg/Include/Library/EblAddExternalCommandLib.h
+++ b/EmbeddedPkg/Include/Library/EblAddExternalCommandLib.h
@@ -1,122 +1,122 @@
-/** @file
-  Include file for basic command line parser for EBL (Embedded Boot Loader)
-
-  Copyright (c) 2007, Intel Corporation. All rights reserved.<BR>
-  Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __EBL_ADD_EXTERNAL_COMMAND_LIB_H__
-#define __EBL_ADD_EXTERNAL_COMMAND_LIB_H__
-
-#include <PiDxe.h>
-#include <Protocol/EblAddCommand.h>
-
-
-EFI_STATUS
-EFIAPI
-EblAddExternalCommands (
-  IN const EBL_COMMAND_TABLE   *EntryArray,
-  IN UINTN                     ArrayCount
-  );
-
-/**
-
-  Return a keypress or optionally timeout if a timeout value was passed in.
-
-  An optional callback function is called every second when waiting for a
-
-  timeout.
-
-
-
-  @param  Key           EFI Key information returned
-
-  @param  TimeoutInSec  Number of seconds to wait to timeout
-
-  @param  CallBack      Callback called every second during the timeout wait 
-
-
-
-  @return EFI_SUCCESS  Key was returned
-
-  @return EFI_TIMEOUT  If the TimoutInSec expired
-
-
-
-**/
-
-EFI_STATUS
-
-EFIAPI
-
-EblGetCharKey (
-
-  IN OUT EFI_INPUT_KEY            *Key,
-
-  IN     UINTN                    TimeoutInSec,
-
-  IN     EBL_GET_CHAR_CALL_BACK   CallBack   OPTIONAL
-
-  );
-
-
-
-
-
-/**
-
-  This routine is used prevent command output data from scrolling off the end
-
-  of the screen. The global gPageBreak is used to turn on or off this feature.
-
-  If the CurrentRow is near the end of the screen pause and print out a prompt
-
-  If the use hits Q to quit return TRUE else for any other key return FALSE.
-
-  PrefixNewline is used to figure out if a newline is needed before the prompt
-
-  string. This depends on the last print done before calling this function.
-
-  CurrentRow is updated by one on a call or set back to zero if a prompt is 
-
-  needed.
-
-
-
-  @param  CurrentRow  Used to figure out if its the end of the page and updated
-
-  @param  PrefixNewline  Did previous print issue a newline
-
-
-
-  @return TRUE if Q was hit to quit, FALSE in all other cases.
-
-
-
-**/
-
-BOOLEAN
-
-EFIAPI
-
-EblAnyKeyToContinueQtoQuit (
-
-  IN  UINTN   *CurrentRow,
-
-  IN  BOOLEAN PrefixNewline
-
-  );
-
-
-
-#endif
-
+/** @file

+  Include file for basic command line parser for EBL (Embedded Boot Loader)

+

+  Copyright (c) 2007, Intel Corporation. All rights reserved.<BR>

+  Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __EBL_ADD_EXTERNAL_COMMAND_LIB_H__

+#define __EBL_ADD_EXTERNAL_COMMAND_LIB_H__

+

+#include <PiDxe.h>

+#include <Protocol/EblAddCommand.h>

+

+

+EFI_STATUS

+EFIAPI

+EblAddExternalCommands (

+  IN const EBL_COMMAND_TABLE   *EntryArray,

+  IN UINTN                     ArrayCount

+  );

+

+/**

+

+  Return a keypress or optionally timeout if a timeout value was passed in.

+

+  An optional callback function is called every second when waiting for a

+

+  timeout.

+

+

+

+  @param  Key           EFI Key information returned

+

+  @param  TimeoutInSec  Number of seconds to wait to timeout

+

+  @param  CallBack      Callback called every second during the timeout wait 

+

+

+

+  @return EFI_SUCCESS  Key was returned

+

+  @return EFI_TIMEOUT  If the TimoutInSec expired

+

+

+

+**/

+

+EFI_STATUS

+

+EFIAPI

+

+EblGetCharKey (

+

+  IN OUT EFI_INPUT_KEY            *Key,

+

+  IN     UINTN                    TimeoutInSec,

+

+  IN     EBL_GET_CHAR_CALL_BACK   CallBack   OPTIONAL

+

+  );

+

+

+

+

+

+/**

+

+  This routine is used prevent command output data from scrolling off the end

+

+  of the screen. The global gPageBreak is used to turn on or off this feature.

+

+  If the CurrentRow is near the end of the screen pause and print out a prompt

+

+  If the use hits Q to quit return TRUE else for any other key return FALSE.

+

+  PrefixNewline is used to figure out if a newline is needed before the prompt

+

+  string. This depends on the last print done before calling this function.

+

+  CurrentRow is updated by one on a call or set back to zero if a prompt is 

+

+  needed.

+

+

+

+  @param  CurrentRow  Used to figure out if its the end of the page and updated

+

+  @param  PrefixNewline  Did previous print issue a newline

+

+

+

+  @return TRUE if Q was hit to quit, FALSE in all other cases.

+

+

+

+**/

+

+BOOLEAN

+

+EFIAPI

+

+EblAnyKeyToContinueQtoQuit (

+

+  IN  UINTN   *CurrentRow,

+

+  IN  BOOLEAN PrefixNewline

+

+  );

+

+

+

+#endif

+

diff --git a/EmbeddedPkg/Include/Library/EblCmdLib.h b/EmbeddedPkg/Include/Library/EblCmdLib.h
index 8974463c..5c21d05f 100644
--- a/EmbeddedPkg/Include/Library/EblCmdLib.h
+++ b/EmbeddedPkg/Include/Library/EblCmdLib.h
@@ -1,48 +1,48 @@
-/** @file
-  Include file for basic command line parser for EBL (Embedded Boot Loader)
-
-  Copyright (c) 2007, Intel Corporation. All rights reserved.<BR>
-  Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __EBL_LIB_H__
-#define __EBL_LIB_H__
-
-#include <PiDxe.h>
-#include <Protocol/EblAddCommand.h>
-
-
-VOID
-EblAddCommand (
-  IN const EBL_COMMAND_TABLE   *Entry
-  );
-
-VOID
-EblAddCommands (
-  IN const EBL_COMMAND_TABLE   *EntryArray,
-  IN UINTN                     ArrayCount
-  );
-
-
-//
-// LIbrary constructor called directly from Ebl Code. 
-// This module calls EblAddCommand () or EblAddCommands () to register new commands
-//
-VOID
-EblInitializeExternalCmd (
-  VOID
-  );
-
-
-
-#endif
-
+/** @file

+  Include file for basic command line parser for EBL (Embedded Boot Loader)

+

+  Copyright (c) 2007, Intel Corporation. All rights reserved.<BR>

+  Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __EBL_LIB_H__

+#define __EBL_LIB_H__

+

+#include <PiDxe.h>

+#include <Protocol/EblAddCommand.h>

+

+

+VOID

+EblAddCommand (

+  IN const EBL_COMMAND_TABLE   *Entry

+  );

+

+VOID

+EblAddCommands (

+  IN const EBL_COMMAND_TABLE   *EntryArray,

+  IN UINTN                     ArrayCount

+  );

+

+

+//

+// LIbrary constructor called directly from Ebl Code. 

+// This module calls EblAddCommand () or EblAddCommands () to register new commands

+//

+VOID

+EblInitializeExternalCmd (

+  VOID

+  );

+

+

+

+#endif

+

diff --git a/EmbeddedPkg/Include/Library/EblNetworkLib.h b/EmbeddedPkg/Include/Library/EblNetworkLib.h
index c72973b7..9292cf9b 100644
--- a/EmbeddedPkg/Include/Library/EblNetworkLib.h
+++ b/EmbeddedPkg/Include/Library/EblNetworkLib.h
@@ -1,68 +1,68 @@
-/** @file
-  Abstractions for Ebl network accesses.
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __EBL_NETWORK_LIB_H__
-#define __EBL_NETWORK_LIB_H__
-
-#include <Protocol/PxeBaseCode.h>
-
-
-EFI_STATUS
-EFIAPI
-EblGetCurrentIpAddress (
-  IN OUT EFI_IP_ADDRESS *Ip
-  );
-
-EFI_STATUS
-EFIAPI
-EblGetCurrentMacAddress (
-  IN OUT  EFI_MAC_ADDRESS *Mac
-  );
-
-CHAR8 *
-EFIAPI
-EblLoadFileBootTypeString (
-  IN  EFI_HANDLE Handle
-  );
-
-EFI_STATUS
-EFIAPI
-EblPerformDHCP (
-  IN  BOOLEAN  SortOffers
-  );
-
-EFI_STATUS
-EFIAPI
-EblSetStationIp (
-  IN EFI_IP_ADDRESS *NewStationIp,  OPTIONAL
-  IN EFI_IP_ADDRESS *NewSubnetMask  OPTIONAL
-  );
-  
-EFI_STATUS
-EFIAPI
-EblMtftp (
-  IN EFI_PXE_BASE_CODE_TFTP_OPCODE             Operation,
-  IN OUT VOID                                  *BufferPtr OPTIONAL,
-  IN BOOLEAN                                   Overwrite,
-  IN OUT UINT64                                *BufferSize,
-  IN UINTN                                     *BlockSize OPTIONAL,
-  IN EFI_IP_ADDRESS                            *ServerIp,
-  IN UINT8                                     *Filename  OPTIONAL,
-  IN EFI_PXE_BASE_CODE_MTFTP_INFO              *Info      OPTIONAL,
-  IN BOOLEAN                                   DontUseBuffer
-  );
-  
-#endif
-
+/** @file

+  Abstractions for Ebl network accesses.

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __EBL_NETWORK_LIB_H__

+#define __EBL_NETWORK_LIB_H__

+

+#include <Protocol/PxeBaseCode.h>

+

+

+EFI_STATUS

+EFIAPI

+EblGetCurrentIpAddress (

+  IN OUT EFI_IP_ADDRESS *Ip

+  );

+

+EFI_STATUS

+EFIAPI

+EblGetCurrentMacAddress (

+  IN OUT  EFI_MAC_ADDRESS *Mac

+  );

+

+CHAR8 *

+EFIAPI

+EblLoadFileBootTypeString (

+  IN  EFI_HANDLE Handle

+  );

+

+EFI_STATUS

+EFIAPI

+EblPerformDHCP (

+  IN  BOOLEAN  SortOffers

+  );

+

+EFI_STATUS

+EFIAPI

+EblSetStationIp (

+  IN EFI_IP_ADDRESS *NewStationIp,  OPTIONAL

+  IN EFI_IP_ADDRESS *NewSubnetMask  OPTIONAL

+  );

+  

+EFI_STATUS

+EFIAPI

+EblMtftp (

+  IN EFI_PXE_BASE_CODE_TFTP_OPCODE             Operation,

+  IN OUT VOID                                  *BufferPtr OPTIONAL,

+  IN BOOLEAN                                   Overwrite,

+  IN OUT UINT64                                *BufferSize,

+  IN UINTN                                     *BlockSize OPTIONAL,

+  IN EFI_IP_ADDRESS                            *ServerIp,

+  IN UINT8                                     *Filename  OPTIONAL,

+  IN EFI_PXE_BASE_CODE_MTFTP_INFO              *Info      OPTIONAL,

+  IN BOOLEAN                                   DontUseBuffer

+  );

+  

+#endif

+

diff --git a/EmbeddedPkg/Include/Library/GdbSerialLib.h b/EmbeddedPkg/Include/Library/GdbSerialLib.h
index 55800b9f..6e8eeb4e 100644
--- a/EmbeddedPkg/Include/Library/GdbSerialLib.h
+++ b/EmbeddedPkg/Include/Library/GdbSerialLib.h
@@ -1,107 +1,107 @@
-/** @file
-  Basic serial IO abstaction for GDB
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __GDB_SERIAL_LIB_H__
-#define __GDB_SERIAL_LIB_H__
-
-
-
-/**
-  Sets the baud rate, receive FIFO depth, transmit/receice time out, parity, 
-  data buts, and stop bits on a serial device. This call is optional as the serial
-  port will be set up with defaults base on PCD values.
-
-  @param  BaudRate         The requested baud rate. A BaudRate value of 0 will use the the
-                           device's default interface speed.
-  @param  Parity           The type of parity to use on this serial device. A Parity value of
-                           DefaultParity will use the device's default parity value.
-  @param  DataBits         The number of data bits to use on the serial device. A DataBits
-                           vaule of 0 will use the device's default data bit setting.
-  @param  StopBits         The number of stop bits to use on this serial device. A StopBits
-                           value of DefaultStopBits will use the device's default number of
-                           stop bits.
-
-  @retval EFI_SUCCESS      The device was configured.
-  @retval EFI_DEVICE_ERROR The serial device could not be coonfigured.
-
-**/
-RETURN_STATUS
-EFIAPI
-GdbSerialInit (
-  IN UINT64     BaudRate, 
-  IN UINT8      Parity, 
-  IN UINT8      DataBits, 
-  IN UINT8      StopBits 
-  ); 
-
-
-/**
-  Check to see if a character is available from GDB. Do not read the character as that is
-  done via GdbGetChar().
-
-  @return TRUE  - Character availible
-  @return FALSE - Character not availible
-  
-**/
-BOOLEAN
-EFIAPI
-GdbIsCharAvailable (
-  VOID
-  );
-
-/**
-  Get a character from GDB. This function must be able to run in interrupt context.
-
-  @return A character from GDB
-  
-**/
-CHAR8
-EFIAPI
-GdbGetChar (
-  VOID
-  );
-
-
-/**
-  Send a character to GDB. This function must be able to run in interrupt context.
-
-
-  @param  Char    Send a character to GDB
-
-**/
-
-VOID
-EFIAPI
-GdbPutChar (
-  IN  CHAR8   Char
-  );
-
-
-/**
-  Send an ASCII string to GDB. This function must be able to run in interrupt context.
-
-
-  @param  String    Send a string to GDB
-
-**/
-
-VOID
-GdbPutString (
-  IN CHAR8  *String
-  );
-
-
-#endif
-
+/** @file

+  Basic serial IO abstaction for GDB

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __GDB_SERIAL_LIB_H__

+#define __GDB_SERIAL_LIB_H__

+

+

+

+/**

+  Sets the baud rate, receive FIFO depth, transmit/receice time out, parity, 

+  data buts, and stop bits on a serial device. This call is optional as the serial

+  port will be set up with defaults base on PCD values.

+

+  @param  BaudRate         The requested baud rate. A BaudRate value of 0 will use the the

+                           device's default interface speed.

+  @param  Parity           The type of parity to use on this serial device. A Parity value of

+                           DefaultParity will use the device's default parity value.

+  @param  DataBits         The number of data bits to use on the serial device. A DataBits

+                           vaule of 0 will use the device's default data bit setting.

+  @param  StopBits         The number of stop bits to use on this serial device. A StopBits

+                           value of DefaultStopBits will use the device's default number of

+                           stop bits.

+

+  @retval EFI_SUCCESS      The device was configured.

+  @retval EFI_DEVICE_ERROR The serial device could not be coonfigured.

+

+**/

+RETURN_STATUS

+EFIAPI

+GdbSerialInit (

+  IN UINT64     BaudRate, 

+  IN UINT8      Parity, 

+  IN UINT8      DataBits, 

+  IN UINT8      StopBits 

+  ); 

+

+

+/**

+  Check to see if a character is available from GDB. Do not read the character as that is

+  done via GdbGetChar().

+

+  @return TRUE  - Character availible

+  @return FALSE - Character not availible

+  

+**/

+BOOLEAN

+EFIAPI

+GdbIsCharAvailable (

+  VOID

+  );

+

+/**

+  Get a character from GDB. This function must be able to run in interrupt context.

+

+  @return A character from GDB

+  

+**/

+CHAR8

+EFIAPI

+GdbGetChar (

+  VOID

+  );

+

+

+/**

+  Send a character to GDB. This function must be able to run in interrupt context.

+

+

+  @param  Char    Send a character to GDB

+

+**/

+

+VOID

+EFIAPI

+GdbPutChar (

+  IN  CHAR8   Char

+  );

+

+

+/**

+  Send an ASCII string to GDB. This function must be able to run in interrupt context.

+

+

+  @param  String    Send a string to GDB

+

+**/

+

+VOID

+GdbPutString (

+  IN CHAR8  *String

+  );

+

+

+#endif

+

diff --git a/EmbeddedPkg/Include/Library/PrePiLib.h b/EmbeddedPkg/Include/Library/PrePiLib.h
index 444d7e28..6144513a 100644
--- a/EmbeddedPkg/Include/Library/PrePiLib.h
+++ b/EmbeddedPkg/Include/Library/PrePiLib.h
@@ -1,790 +1,790 @@
-/** @file
-  Library that helps implement monolithic PEI. (SEC goes to DXE)
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __PRE_PI_LIB_H__
-#define __PRE_PI_LIB_H__
-
-#include <Guid/ExtractSection.h>
-
-/**
-  This service enables discovery of additional firmware volumes.
-
-  @param  Instance              This instance of the firmware volume to find.  The value 0 is the
-                                Boot Firmware Volume (BFV).
-  @param  FwVolHeader           Pointer to the firmware volume header of the volume to return.
-
-  @retval EFI_SUCCESS           The volume was found.
-  @retval EFI_NOT_FOUND         The volume was not found.
-  @retval EFI_INVALID_PARAMETER FwVolHeader is NULL.
-
-**/
-EFI_STATUS
-EFIAPI
-FfsFindNextVolume (
-  IN UINTN                          Instance,
-  IN OUT EFI_PEI_FV_HANDLE          *VolumeHandle
-  );
-
-
-/**
-  This service enables discovery of additional firmware files.
-
-  @param  SearchType            A filter to find files only of this type.
-  @param  FwVolHeader           Pointer to the firmware volume header of the volume to search.
-                                This parameter must point to a valid FFS volume.
-  @param  FileHeader            Pointer to the current file from which to begin searching.
-
-  @retval EFI_SUCCESS           The file was found.
-  @retval EFI_NOT_FOUND         The file was not found.
-  @retval EFI_NOT_FOUND         The header checksum was not zero.
-
-**/
-EFI_STATUS
-EFIAPI
-FfsFindNextFile (
-  IN EFI_FV_FILETYPE            SearchType,
-  IN EFI_PEI_FV_HANDLE          VolumeHandle,
-  IN OUT EFI_PEI_FILE_HANDLE    *FileHandle
-  );
-
-
-/**
-  This service enables discovery sections of a given type within a valid FFS file.
-
-  @param  SearchType            The value of the section type to find.
-  @param  FfsFileHeader         A pointer to the file header that contains the set of sections to
-                                be searched.
-  @param  SectionData           A pointer to the discovered section, if successful.
-
-  @retval EFI_SUCCESS           The section was found.
-  @retval EFI_NOT_FOUND         The section was not found.
-
-**/
-EFI_STATUS
-EFIAPI
-FfsFindSectionData (
-  IN EFI_SECTION_TYPE           SectionType,
-  IN EFI_PEI_FILE_HANDLE        FileHandle,
-  OUT VOID                      **SectionData
-  );
-
-
-/**
-  Find a file in the volume by name
-  
-  @param FileName       A pointer to the name of the file to
-                        find within the firmware volume.
-
-  @param VolumeHandle   The firmware volume to search FileHandle
-                        Upon exit, points to the found file's
-                        handle or NULL if it could not be found.
-
-  @retval EFI_SUCCESS             File was found.
-
-  @retval EFI_NOT_FOUND           File was not found.
-
-  @retval EFI_INVALID_PARAMETER   VolumeHandle or FileHandle or
-                                  FileName was NULL.
-
-**/
-EFI_STATUS
-EFIAPI
-FfsFindByName (
-  IN CONST  EFI_GUID            *FileName,
-  IN CONST  EFI_PEI_FV_HANDLE   VolumeHandle,
-  OUT       EFI_PEI_FILE_HANDLE *FileHandle
-  );
-
-
-/**
-  Get information about the file by name.
-
-  @param FileHandle   Handle of the file.
-
-  @param FileInfo     Upon exit, points to the file's
-                      information.
-
-  @retval EFI_SUCCESS             File information returned.
-  
-  @retval EFI_INVALID_PARAMETER   If FileHandle does not
-                                  represent a valid file.
-  
-  @retval EFI_INVALID_PARAMETER   If FileInfo is NULL.
-  
-**/
-EFI_STATUS
-EFIAPI 
-FfsGetFileInfo (
-  IN CONST  EFI_PEI_FILE_HANDLE   FileHandle,
-  OUT EFI_FV_FILE_INFO            *FileInfo
-  );
-
-
-/**
-  Get Information about the volume by name
-
-  @param VolumeHandle   Handle of the volume.
-
-  @param VolumeInfo     Upon exit, points to the volume's
-                        information.
-
-  @retval EFI_SUCCESS             File information returned.
-  
-  @retval EFI_INVALID_PARAMETER   If FileHandle does not
-                                  represent a valid file.
-  
-  @retval EFI_INVALID_PARAMETER   If FileInfo is NULL.
-
-**/
-EFI_STATUS
-EFIAPI
-FfsGetVolumeInfo (
-  IN  EFI_PEI_FV_HANDLE       VolumeHandle,
-  OUT EFI_FV_INFO             *VolumeInfo
-  );
-
-
-
-/**
-  Get Fv image from the FV type file, then add FV & FV2 Hob.
-
-	@param FileHandle  	        File handle of a Fv type file.
-
-
-  @retval EFI_NOT_FOUND  				FV image can't be found.
-  @retval EFI_SUCCESS						Successfully to process it.
-
-**/
-EFI_STATUS
-EFIAPI
-FfsProcessFvFile (
-  IN  EFI_PEI_FILE_HANDLE   FvFileHandle
-  );
-
-
-/**
-  Search through every FV until you find a file of type FileType
-
-	@param FileType  	    File handle of a Fv type file.
-  @param Volumehandle   On succes Volume Handle of the match
-  @param FileHandle     On success File Handle of the match
-  
-  @retval EFI_NOT_FOUND  				FV image can't be found.
-  @retval EFI_SUCCESS						Successfully found FileType
-
-**/
-EFI_STATUS
-EFIAPI
-FfsAnyFvFindFirstFile (
-  IN  EFI_FV_FILETYPE       FileType,
-  OUT EFI_PEI_FV_HANDLE     *VolumeHandle,
-  OUT EFI_PEI_FILE_HANDLE   *FileHandle
-  );
-
-
-/**
-  Get Fv image from the FV type file, then add FV & FV2 Hob.
-
-	@param FileHandle  	        File handle of a Fv type file.
-
-
-  @retval EFI_NOT_FOUND  				FV image can't be found.
-  @retval EFI_SUCCESS						Successfully to process it.
-
-**/
-EFI_STATUS
-EFIAPI
-FfsProcessFvFile (
-  IN  EFI_PEI_FILE_HANDLE   FvFileHandle
-  );
-
-
-/**
-  This service enables PEIMs to ascertain the present value of the boot mode.  
-
-
-  @retval BootMode           
-
-**/
-EFI_BOOT_MODE
-EFIAPI
-GetBootMode (
-  VOID
-  );
-
-
-/**
-  This service enables PEIMs to update the boot mode variable.    
-
-  @param  BootMode              The value of the boot mode to set.
-
-  @retval EFI_SUCCESS           The value was successfully updated
-
-**/
-EFI_STATUS
-EFIAPI
-SetBootMode (
-  IN EFI_BOOT_MODE              BootMode
-  );
-
-/**
-  This service enables a PEIM to ascertain the address of the list of HOBs in memory.
-
-  @param  HobList               A pointer to the list of HOBs that the PEI Foundation will initialize.
-
-  @retval EFI_SUCCESS           The list was successfully returned.
-  @retval EFI_NOT_AVAILABLE_YET The HOB list is not yet published.
-
-**/
-VOID *
-EFIAPI
-GetHobList (
-  VOID         
-  );
-
-
-/**
-  Updates the pointer to the HOB list.
-
-  @param  HobList       Hob list pointer to store
-  
-**/
-EFI_STATUS
-EFIAPI
-SetHobList (
-  IN  VOID      *HobList
-  );
-
-EFI_HOB_HANDOFF_INFO_TABLE*
-HobConstructor (
-  IN VOID   *EfiMemoryBegin,
-  IN UINTN  EfiMemoryLength,
-  IN VOID   *EfiFreeMemoryBottom,
-  IN VOID   *EfiFreeMemoryTop
-  );
-
-/**
-  Retrieves the magic value from the PE/COFF header.
-
-  @param  Hdr             The buffer in which to return the PE32, PE32+, or TE header.
-
-  @return EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC - Image is PE32
-  @return EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC - Image is PE32+
-
-**/
-VOID
-CreateHobList (
-  IN VOID   *MemoryBegin,
-  IN UINTN  MemoryLength,
-  IN VOID   *HobBase,
-  IN VOID   *StackBase
-  );
-
-
-/**
-  This service enables PEIMs to create various types of HOBs.
-
-  @param  Type                  The type of HOB to be installed.
-  @param  Length                The length of the HOB to be added.
-
-  @retval !NULL                 The HOB was successfully created.
-  @retval NULL                  There is no additional space for HOB creation.
-
-**/
-VOID *
-CreateHob (
-  IN  UINT16    HobType,
-  IN  UINT16    HobLenght
-  );
-
-
-/**
-  Returns the next instance of a HOB type from the starting HOB.
-
-  This function searches the first instance of a HOB type from the starting HOB pointer. 
-  If there does not exist such HOB type from the starting HOB pointer, it will return NULL.
-  In contrast with macro GET_NEXT_HOB(), this function does not skip the starting HOB pointer
-  unconditionally: it returns HobStart back if HobStart itself meets the requirement;
-  caller is required to use GET_NEXT_HOB() if it wishes to skip current HobStart.
-  If HobStart is NULL, then ASSERT().
-
-  @param  Type          The HOB type to return.
-  @param  HobStart      The starting HOB pointer to search from.
-
-  @return The next instance of a HOB type from the starting HOB.
-
-**/
-VOID *
-EFIAPI
-GetNextHob (
-  IN UINT16                 Type,
-  IN CONST VOID             *HobStart
-  );
-
-/**
-  Returns the first instance of a HOB type among the whole HOB list.
-
-  This function searches the first instance of a HOB type among the whole HOB list. 
-  If there does not exist such HOB type in the HOB list, it will return NULL. 
-
-  @param  Type          The HOB type to return.
-
-  @return The next instance of a HOB type from the starting HOB.
-
-**/
-VOID *
-EFIAPI
-GetFirstHob (
-  IN UINT16                 Type
-  );
-
-/**
-  This function searches the first instance of a HOB from the starting HOB pointer. 
-  Such HOB should satisfy two conditions: 
-  its HOB type is EFI_HOB_TYPE_GUID_EXTENSION and its GUID Name equals to the input Guid. 
-  If there does not exist such HOB from the starting HOB pointer, it will return NULL. 
-  Caller is required to apply GET_GUID_HOB_DATA () and GET_GUID_HOB_DATA_SIZE ()
-  to extract the data section and its size info respectively.
-  In contrast with macro GET_NEXT_HOB(), this function does not skip the starting HOB pointer
-  unconditionally: it returns HobStart back if HobStart itself meets the requirement;
-  caller is required to use GET_NEXT_HOB() if it wishes to skip current HobStart.
-  If Guid is NULL, then ASSERT().
-  If HobStart is NULL, then ASSERT().
-
-  @param  Guid          The GUID to match with in the HOB list.
-  @param  HobStart      A pointer to a Guid.
-
-  @return The next instance of the matched GUID HOB from the starting HOB.
-
-**/
-VOID *
-EFIAPI
-GetNextGuidHob (
-  IN CONST EFI_GUID         *Guid,
-  IN CONST VOID             *HobStart
-  );
-
-/**
-  This function searches the first instance of a HOB among the whole HOB list. 
-  Such HOB should satisfy two conditions:
-  its HOB type is EFI_HOB_TYPE_GUID_EXTENSION and its GUID Name equals to the input Guid.
-  If there does not exist such HOB from the starting HOB pointer, it will return NULL.
-  Caller is required to apply GET_GUID_HOB_DATA () and GET_GUID_HOB_DATA_SIZE ()
-  to extract the data section and its size info respectively.
-  If Guid is NULL, then ASSERT().
-
-  @param  Guid          The GUID to match with in the HOB list.
-
-  @return The first instance of the matched GUID HOB among the whole HOB list.
-
-**/
-VOID *
-EFIAPI
-GetFirstGuidHob (
-  IN CONST EFI_GUID         *Guid
-  );
-
-
-/**
-  Builds a HOB for a loaded PE32 module.
-
-  This function builds a HOB for a loaded PE32 module.
-  It can only be invoked during PEI phase;
-  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
-  If ModuleName is NULL, then ASSERT().
-  If there is no additional space for HOB creation, then ASSERT().
-
-  @param  ModuleName              The GUID File Name of the module.
-  @param  MemoryAllocationModule  The 64 bit physical address of the module.
-  @param  ModuleLength            The length of the module in bytes.
-  @param  EntryPoint              The 64 bit physical address of the module entry point.
-
-**/
-VOID
-EFIAPI
-BuildModuleHob (
-  IN CONST EFI_GUID         *ModuleName,
-  IN EFI_PHYSICAL_ADDRESS   MemoryAllocationModule,
-  IN UINT64                 ModuleLength,
-  IN EFI_PHYSICAL_ADDRESS   EntryPoint
-  );
-
-/**
-  Builds a HOB that describes a chunk of system memory.
-
-  This function builds a HOB that describes a chunk of system memory.
-  It can only be invoked during PEI phase;
-  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
-  If there is no additional space for HOB creation, then ASSERT().
-
-  @param  ResourceType        The type of resource described by this HOB.
-  @param  ResourceAttribute   The resource attributes of the memory described by this HOB.
-  @param  PhysicalStart       The 64 bit physical address of memory described by this HOB.
-  @param  NumberOfBytes       The length of the memory described by this HOB in bytes.
-
-**/
-VOID
-EFIAPI
-BuildResourceDescriptorHob (
-  IN EFI_RESOURCE_TYPE            ResourceType,
-  IN EFI_RESOURCE_ATTRIBUTE_TYPE  ResourceAttribute,
-  IN EFI_PHYSICAL_ADDRESS         PhysicalStart,
-  IN UINT64                       NumberOfBytes
-  );
-
-/**
-  Builds a GUID HOB with a certain data length.
-
-  This function builds a customized HOB tagged with a GUID for identification 
-  and returns the start address of GUID HOB data so that caller can fill the customized data. 
-  The HOB Header and Name field is already stripped.
-  It can only be invoked during PEI phase;
-  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
-  If Guid is NULL, then ASSERT().
-  If there is no additional space for HOB creation, then ASSERT().
-  If DataLength >= (0x10000 - sizeof (EFI_HOB_GUID_TYPE)), then ASSERT().
-
-  @param  Guid          The GUID to tag the customized HOB.
-  @param  DataLength    The size of the data payload for the GUID HOB.
-
-  @return The start address of GUID HOB data.
-
-**/
-VOID *
-EFIAPI
-BuildGuidHob (
-  IN CONST EFI_GUID              *Guid,
-  IN UINTN                       DataLength
-  );
-
-/**
-  Copies a data buffer to a newly-built HOB.
-
-  This function builds a customized HOB tagged with a GUID for identification,
-  copies the input data to the HOB data field and returns the start address of the GUID HOB data.
-  The HOB Header and Name field is already stripped.
-  It can only be invoked during PEI phase;
-  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
-  If Guid is NULL, then ASSERT().
-  If Data is NULL and DataLength > 0, then ASSERT().
-  If there is no additional space for HOB creation, then ASSERT().
-  If DataLength >= (0x10000 - sizeof (EFI_HOB_GUID_TYPE)), then ASSERT().
-
-  @param  Guid          The GUID to tag the customized HOB.
-  @param  Data          The data to be copied into the data field of the GUID HOB.
-  @param  DataLength    The size of the data payload for the GUID HOB.
-
-  @return The start address of GUID HOB data.
-
-**/
-VOID *
-EFIAPI
-BuildGuidDataHob (
-  IN CONST EFI_GUID              *Guid,
-  IN VOID                        *Data,
-  IN UINTN                       DataLength
-  );
-
-/**
-  Builds a Firmware Volume HOB.
-
-  This function builds a Firmware Volume HOB.
-  It can only be invoked during PEI phase;
-  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
-  If there is no additional space for HOB creation, then ASSERT().
-
-  @param  BaseAddress   The base address of the Firmware Volume.
-  @param  Length        The size of the Firmware Volume in bytes.
-
-**/
-VOID
-EFIAPI
-BuildFvHob (
-  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
-  IN UINT64                      Length
-  );
-
-/**
-  Builds a Firmware Volume HOB and a resrouce descriptor hob 
-
-  This function builds a Firmware Volume HOB.
-  It can only be invoked during PEI phase;
-  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
-  If there is no additional space for HOB creation, then ASSERT().
-
-  @param  BaseAddress   The base address of the Firmware Volume.
-  @param  Length        The size of the Firmware Volume in bytes.
-
-**/
-VOID
-EFIAPI
-BuildFvHobs (  
-  IN EFI_PHYSICAL_ADDRESS         PhysicalStart,
-  IN UINT64                       NumberOfBytes,
-  IN EFI_RESOURCE_ATTRIBUTE_TYPE  *ResourceAttribute  OPTIONAL
-  ); 
-
-
-/**
-  Builds a EFI_HOB_TYPE_FV2 HOB.
-
-  This function builds a EFI_HOB_TYPE_FV2 HOB.
-  It can only be invoked during PEI phase;
-  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
-  If there is no additional space for HOB creation, then ASSERT().
-
-  @param  BaseAddress   The base address of the Firmware Volume.
-  @param  Length        The size of the Firmware Volume in bytes.
-  @param  FvName       The name of the Firmware Volume.
-  @param  FileName      The name of the file.
-  
-**/
-VOID
-EFIAPI
-BuildFv2Hob (
-  IN          EFI_PHYSICAL_ADDRESS        BaseAddress,
-  IN          UINT64                      Length,
-  IN CONST    EFI_GUID                    *FvName,
-  IN CONST    EFI_GUID                    *FileName
-  );
-
-/**
-  Builds a Capsule Volume HOB.
-
-  This function builds a Capsule Volume HOB.
-  It can only be invoked during PEI phase;
-  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
-  If there is no additional space for HOB creation, then ASSERT().
-
-  @param  BaseAddress   The base address of the Capsule Volume.
-  @param  Length        The size of the Capsule Volume in bytes.
-
-**/
-VOID
-EFIAPI
-BuildCvHob (
-  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
-  IN UINT64                      Length
-  );
-
-/**
-  Builds a HOB for the CPU.
-
-  This function builds a HOB for the CPU.
-  It can only be invoked during PEI phase;
-  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
-  If there is no additional space for HOB creation, then ASSERT().
-
-  @param  SizeOfMemorySpace   The maximum physical memory addressability of the processor.
-  @param  SizeOfIoSpace       The maximum physical I/O addressability of the processor.
-
-**/
-VOID
-EFIAPI
-BuildCpuHob (
-  IN UINT8                       SizeOfMemorySpace,
-  IN UINT8                       SizeOfIoSpace
-  );
-
-/**
-  Builds a HOB for the Stack.
-
-  This function builds a HOB for the stack.
-  It can only be invoked during PEI phase;
-  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
-  If there is no additional space for HOB creation, then ASSERT().
-
-  @param  BaseAddress   The 64 bit physical address of the Stack.
-  @param  Length        The length of the stack in bytes.
-
-**/
-VOID
-EFIAPI
-BuildStackHob (
-  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
-  IN UINT64                      Length
-  );
-
-/**
-  Update the Stack Hob if the stack has been moved
-
-  @param  BaseAddress   The 64 bit physical address of the Stack.
-  @param  Length        The length of the stack in bytes.
-
-**/
-VOID
-UpdateStackHob (
-  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
-  IN UINT64                      Length
-  );
-
-
-/**
-  Builds a HOB for the BSP store.
-
-  This function builds a HOB for BSP store.
-  It can only be invoked during PEI phase;
-  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
-  If there is no additional space for HOB creation, then ASSERT().
-
-  @param  BaseAddress   The 64 bit physical address of the BSP.
-  @param  Length        The length of the BSP store in bytes.
-  @param  MemoryType    Type of memory allocated by this HOB.
-
-**/
-VOID
-EFIAPI
-BuildBspStoreHob (
-  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
-  IN UINT64                      Length,
-  IN EFI_MEMORY_TYPE             MemoryType
-  );
-
-/**
-  Builds a HOB for the memory allocation.
-
-  This function builds a HOB for the memory allocation.
-  It can only be invoked during PEI phase;
-  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
-  If there is no additional space for HOB creation, then ASSERT().
-
-  @param  BaseAddress   The 64 bit physical address of the memory.
-  @param  Length        The length of the memory allocation in bytes.
-  @param  MemoryType    Type of memory allocated by this HOB.
-
-**/
-VOID
-EFIAPI
-BuildMemoryAllocationHob (
-  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
-  IN UINT64                      Length,
-  IN EFI_MEMORY_TYPE             MemoryType
-  );
-
-
-VOID
-EFIAPI
-BuildExtractSectionHob (
-  IN  EFI_GUID                                  *Guid,
-  IN  EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER   SectionGetInfo,
-  IN  EXTRACT_GUIDED_SECTION_DECODE_HANDLER     SectionExtraction
-  );
-
-VOID
-EFIAPI
-BuildPeCoffLoaderHob (
-  VOID
-  );
-
-
-/**
-  Allocates one or more 4KB pages of type EfiBootServicesData.
-
-  Allocates the number of 4KB pages of MemoryType and returns a pointer to the
-  allocated buffer.  The buffer returned is aligned on a 4KB boundary.  If Pages is 0, then NULL
-  is returned.  If there is not enough memory remaining to satisfy the request, then NULL is
-  returned.
-
-  @param  Pages                 The number of 4 KB pages to allocate.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID * 
-EFIAPI
-AllocatePages (
-  IN UINTN            Pages
-  );
-  
-/**
-  Allocates a buffer of type EfiBootServicesData.
-
-  Allocates the number bytes specified by AllocationSize of type EfiBootServicesData and returns a
-  pointer to the allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is
-  returned.  If there is not enough memory remaining to satisfy the request, then NULL is returned.
-
-  @param  AllocationSize        The number of bytes to allocate.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID *
-EFIAPI
-AllocatePool (
-  IN UINTN  AllocationSize
-  );
-  
-  
-/**
-  Allocates one or more 4KB pages of type EfiBootServicesData at a specified alignment.
-
-  Allocates the number of 4KB pages specified by Pages of type EfiBootServicesData with an
-  alignment specified by Alignment.  The allocated buffer is returned.  If Pages is 0, then NULL is
-  returned.  If there is not enough memory at the specified alignment remaining to satisfy the
-  request, then NULL is returned.
-  If Alignment is not a power of two and Alignment is not zero, then ASSERT().
-
-  @param  Pages                 The number of 4 KB pages to allocate.
-  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.
-                                If Alignment is zero, then byte alignment is used.
-
-  @return A pointer to the allocated buffer or NULL if allocation fails.
-
-**/
-VOID *
-EFIAPI
-AllocateAlignedPages (
-  IN UINTN  Pages,
-  IN UINTN  Alignment
-  );
-
-
-EFI_STATUS
-EFIAPI
-LoadPeCoffImage (
-  IN  VOID                                      *PeCoffImage,
-  OUT EFI_PHYSICAL_ADDRESS                      *ImageAddress,
-  OUT UINT64                                    *ImageSize,
-  OUT EFI_PHYSICAL_ADDRESS                      *EntryPoint
-  );
-
-EFI_STATUS
-EFIAPI
-LoadDxeCoreFromFfsFile (
-  IN EFI_PEI_FILE_HANDLE  FileHandle,
-  IN UINTN                StackSize
-  );
-
-EFI_STATUS
-EFIAPI
-LoadDxeCoreFromFv (
-  IN UINTN  *FvInstance,   OPTIONAL
-  IN UINTN  StackSize
-  );
-
-EFI_STATUS
-EFIAPI
-DecompressFirstFv (
-  VOID
-  );
-
-VOID
-EFIAPI
-AddDxeCoreReportStatusCodeCallback (
-  VOID
-  );
-
-
-#endif
+/** @file

+  Library that helps implement monolithic PEI. (SEC goes to DXE)

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __PRE_PI_LIB_H__

+#define __PRE_PI_LIB_H__

+

+#include <Guid/ExtractSection.h>

+

+/**

+  This service enables discovery of additional firmware volumes.

+

+  @param  Instance              This instance of the firmware volume to find.  The value 0 is the

+                                Boot Firmware Volume (BFV).

+  @param  FwVolHeader           Pointer to the firmware volume header of the volume to return.

+

+  @retval EFI_SUCCESS           The volume was found.

+  @retval EFI_NOT_FOUND         The volume was not found.

+  @retval EFI_INVALID_PARAMETER FwVolHeader is NULL.

+

+**/

+EFI_STATUS

+EFIAPI

+FfsFindNextVolume (

+  IN UINTN                          Instance,

+  IN OUT EFI_PEI_FV_HANDLE          *VolumeHandle

+  );

+

+

+/**

+  This service enables discovery of additional firmware files.

+

+  @param  SearchType            A filter to find files only of this type.

+  @param  FwVolHeader           Pointer to the firmware volume header of the volume to search.

+                                This parameter must point to a valid FFS volume.

+  @param  FileHeader            Pointer to the current file from which to begin searching.

+

+  @retval EFI_SUCCESS           The file was found.

+  @retval EFI_NOT_FOUND         The file was not found.

+  @retval EFI_NOT_FOUND         The header checksum was not zero.

+

+**/

+EFI_STATUS

+EFIAPI

+FfsFindNextFile (

+  IN EFI_FV_FILETYPE            SearchType,

+  IN EFI_PEI_FV_HANDLE          VolumeHandle,

+  IN OUT EFI_PEI_FILE_HANDLE    *FileHandle

+  );

+

+

+/**

+  This service enables discovery sections of a given type within a valid FFS file.

+

+  @param  SearchType            The value of the section type to find.

+  @param  FfsFileHeader         A pointer to the file header that contains the set of sections to

+                                be searched.

+  @param  SectionData           A pointer to the discovered section, if successful.

+

+  @retval EFI_SUCCESS           The section was found.

+  @retval EFI_NOT_FOUND         The section was not found.

+

+**/

+EFI_STATUS

+EFIAPI

+FfsFindSectionData (

+  IN EFI_SECTION_TYPE           SectionType,

+  IN EFI_PEI_FILE_HANDLE        FileHandle,

+  OUT VOID                      **SectionData

+  );

+

+

+/**

+  Find a file in the volume by name

+  

+  @param FileName       A pointer to the name of the file to

+                        find within the firmware volume.

+

+  @param VolumeHandle   The firmware volume to search FileHandle

+                        Upon exit, points to the found file's

+                        handle or NULL if it could not be found.

+

+  @retval EFI_SUCCESS             File was found.

+

+  @retval EFI_NOT_FOUND           File was not found.

+

+  @retval EFI_INVALID_PARAMETER   VolumeHandle or FileHandle or

+                                  FileName was NULL.

+

+**/

+EFI_STATUS

+EFIAPI

+FfsFindByName (

+  IN CONST  EFI_GUID            *FileName,

+  IN CONST  EFI_PEI_FV_HANDLE   VolumeHandle,

+  OUT       EFI_PEI_FILE_HANDLE *FileHandle

+  );

+

+

+/**

+  Get information about the file by name.

+

+  @param FileHandle   Handle of the file.

+

+  @param FileInfo     Upon exit, points to the file's

+                      information.

+

+  @retval EFI_SUCCESS             File information returned.

+  

+  @retval EFI_INVALID_PARAMETER   If FileHandle does not

+                                  represent a valid file.

+  

+  @retval EFI_INVALID_PARAMETER   If FileInfo is NULL.

+  

+**/

+EFI_STATUS

+EFIAPI 

+FfsGetFileInfo (

+  IN CONST  EFI_PEI_FILE_HANDLE   FileHandle,

+  OUT EFI_FV_FILE_INFO            *FileInfo

+  );

+

+

+/**

+  Get Information about the volume by name

+

+  @param VolumeHandle   Handle of the volume.

+

+  @param VolumeInfo     Upon exit, points to the volume's

+                        information.

+

+  @retval EFI_SUCCESS             File information returned.

+  

+  @retval EFI_INVALID_PARAMETER   If FileHandle does not

+                                  represent a valid file.

+  

+  @retval EFI_INVALID_PARAMETER   If FileInfo is NULL.

+

+**/

+EFI_STATUS

+EFIAPI

+FfsGetVolumeInfo (

+  IN  EFI_PEI_FV_HANDLE       VolumeHandle,

+  OUT EFI_FV_INFO             *VolumeInfo

+  );

+

+

+

+/**

+  Get Fv image from the FV type file, then add FV & FV2 Hob.

+

+	@param FileHandle  	        File handle of a Fv type file.

+

+

+  @retval EFI_NOT_FOUND  				FV image can't be found.

+  @retval EFI_SUCCESS						Successfully to process it.

+

+**/

+EFI_STATUS

+EFIAPI

+FfsProcessFvFile (

+  IN  EFI_PEI_FILE_HANDLE   FvFileHandle

+  );

+

+

+/**

+  Search through every FV until you find a file of type FileType

+

+	@param FileType  	    File handle of a Fv type file.

+  @param Volumehandle   On succes Volume Handle of the match

+  @param FileHandle     On success File Handle of the match

+  

+  @retval EFI_NOT_FOUND  				FV image can't be found.

+  @retval EFI_SUCCESS						Successfully found FileType

+

+**/

+EFI_STATUS

+EFIAPI

+FfsAnyFvFindFirstFile (

+  IN  EFI_FV_FILETYPE       FileType,

+  OUT EFI_PEI_FV_HANDLE     *VolumeHandle,

+  OUT EFI_PEI_FILE_HANDLE   *FileHandle

+  );

+

+

+/**

+  Get Fv image from the FV type file, then add FV & FV2 Hob.

+

+	@param FileHandle  	        File handle of a Fv type file.

+

+

+  @retval EFI_NOT_FOUND  				FV image can't be found.

+  @retval EFI_SUCCESS						Successfully to process it.

+

+**/

+EFI_STATUS

+EFIAPI

+FfsProcessFvFile (

+  IN  EFI_PEI_FILE_HANDLE   FvFileHandle

+  );

+

+

+/**

+  This service enables PEIMs to ascertain the present value of the boot mode.  

+

+

+  @retval BootMode           

+

+**/

+EFI_BOOT_MODE

+EFIAPI

+GetBootMode (

+  VOID

+  );

+

+

+/**

+  This service enables PEIMs to update the boot mode variable.    

+

+  @param  BootMode              The value of the boot mode to set.

+

+  @retval EFI_SUCCESS           The value was successfully updated

+

+**/

+EFI_STATUS

+EFIAPI

+SetBootMode (

+  IN EFI_BOOT_MODE              BootMode

+  );

+

+/**

+  This service enables a PEIM to ascertain the address of the list of HOBs in memory.

+

+  @param  HobList               A pointer to the list of HOBs that the PEI Foundation will initialize.

+

+  @retval EFI_SUCCESS           The list was successfully returned.

+  @retval EFI_NOT_AVAILABLE_YET The HOB list is not yet published.

+

+**/

+VOID *

+EFIAPI

+GetHobList (

+  VOID         

+  );

+

+

+/**

+  Updates the pointer to the HOB list.

+

+  @param  HobList       Hob list pointer to store

+  

+**/

+EFI_STATUS

+EFIAPI

+SetHobList (

+  IN  VOID      *HobList

+  );

+

+EFI_HOB_HANDOFF_INFO_TABLE*

+HobConstructor (

+  IN VOID   *EfiMemoryBegin,

+  IN UINTN  EfiMemoryLength,

+  IN VOID   *EfiFreeMemoryBottom,

+  IN VOID   *EfiFreeMemoryTop

+  );

+

+/**

+  Retrieves the magic value from the PE/COFF header.

+

+  @param  Hdr             The buffer in which to return the PE32, PE32+, or TE header.

+

+  @return EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC - Image is PE32

+  @return EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC - Image is PE32+

+

+**/

+VOID

+CreateHobList (

+  IN VOID   *MemoryBegin,

+  IN UINTN  MemoryLength,

+  IN VOID   *HobBase,

+  IN VOID   *StackBase

+  );

+

+

+/**

+  This service enables PEIMs to create various types of HOBs.

+

+  @param  Type                  The type of HOB to be installed.

+  @param  Length                The length of the HOB to be added.

+

+  @retval !NULL                 The HOB was successfully created.

+  @retval NULL                  There is no additional space for HOB creation.

+

+**/

+VOID *

+CreateHob (

+  IN  UINT16    HobType,

+  IN  UINT16    HobLenght

+  );

+

+

+/**

+  Returns the next instance of a HOB type from the starting HOB.

+

+  This function searches the first instance of a HOB type from the starting HOB pointer. 

+  If there does not exist such HOB type from the starting HOB pointer, it will return NULL.

+  In contrast with macro GET_NEXT_HOB(), this function does not skip the starting HOB pointer

+  unconditionally: it returns HobStart back if HobStart itself meets the requirement;

+  caller is required to use GET_NEXT_HOB() if it wishes to skip current HobStart.

+  If HobStart is NULL, then ASSERT().

+

+  @param  Type          The HOB type to return.

+  @param  HobStart      The starting HOB pointer to search from.

+

+  @return The next instance of a HOB type from the starting HOB.

+

+**/

+VOID *

+EFIAPI

+GetNextHob (

+  IN UINT16                 Type,

+  IN CONST VOID             *HobStart

+  );

+

+/**

+  Returns the first instance of a HOB type among the whole HOB list.

+

+  This function searches the first instance of a HOB type among the whole HOB list. 

+  If there does not exist such HOB type in the HOB list, it will return NULL. 

+

+  @param  Type          The HOB type to return.

+

+  @return The next instance of a HOB type from the starting HOB.

+

+**/

+VOID *

+EFIAPI

+GetFirstHob (

+  IN UINT16                 Type

+  );

+

+/**

+  This function searches the first instance of a HOB from the starting HOB pointer. 

+  Such HOB should satisfy two conditions: 

+  its HOB type is EFI_HOB_TYPE_GUID_EXTENSION and its GUID Name equals to the input Guid. 

+  If there does not exist such HOB from the starting HOB pointer, it will return NULL. 

+  Caller is required to apply GET_GUID_HOB_DATA () and GET_GUID_HOB_DATA_SIZE ()

+  to extract the data section and its size info respectively.

+  In contrast with macro GET_NEXT_HOB(), this function does not skip the starting HOB pointer

+  unconditionally: it returns HobStart back if HobStart itself meets the requirement;

+  caller is required to use GET_NEXT_HOB() if it wishes to skip current HobStart.

+  If Guid is NULL, then ASSERT().

+  If HobStart is NULL, then ASSERT().

+

+  @param  Guid          The GUID to match with in the HOB list.

+  @param  HobStart      A pointer to a Guid.

+

+  @return The next instance of the matched GUID HOB from the starting HOB.

+

+**/

+VOID *

+EFIAPI

+GetNextGuidHob (

+  IN CONST EFI_GUID         *Guid,

+  IN CONST VOID             *HobStart

+  );

+

+/**

+  This function searches the first instance of a HOB among the whole HOB list. 

+  Such HOB should satisfy two conditions:

+  its HOB type is EFI_HOB_TYPE_GUID_EXTENSION and its GUID Name equals to the input Guid.

+  If there does not exist such HOB from the starting HOB pointer, it will return NULL.

+  Caller is required to apply GET_GUID_HOB_DATA () and GET_GUID_HOB_DATA_SIZE ()

+  to extract the data section and its size info respectively.

+  If Guid is NULL, then ASSERT().

+

+  @param  Guid          The GUID to match with in the HOB list.

+

+  @return The first instance of the matched GUID HOB among the whole HOB list.

+

+**/

+VOID *

+EFIAPI

+GetFirstGuidHob (

+  IN CONST EFI_GUID         *Guid

+  );

+

+

+/**

+  Builds a HOB for a loaded PE32 module.

+

+  This function builds a HOB for a loaded PE32 module.

+  It can only be invoked during PEI phase;

+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.

+  If ModuleName is NULL, then ASSERT().

+  If there is no additional space for HOB creation, then ASSERT().

+

+  @param  ModuleName              The GUID File Name of the module.

+  @param  MemoryAllocationModule  The 64 bit physical address of the module.

+  @param  ModuleLength            The length of the module in bytes.

+  @param  EntryPoint              The 64 bit physical address of the module entry point.

+

+**/

+VOID

+EFIAPI

+BuildModuleHob (

+  IN CONST EFI_GUID         *ModuleName,

+  IN EFI_PHYSICAL_ADDRESS   MemoryAllocationModule,

+  IN UINT64                 ModuleLength,

+  IN EFI_PHYSICAL_ADDRESS   EntryPoint

+  );

+

+/**

+  Builds a HOB that describes a chunk of system memory.

+

+  This function builds a HOB that describes a chunk of system memory.

+  It can only be invoked during PEI phase;

+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.

+  If there is no additional space for HOB creation, then ASSERT().

+

+  @param  ResourceType        The type of resource described by this HOB.

+  @param  ResourceAttribute   The resource attributes of the memory described by this HOB.

+  @param  PhysicalStart       The 64 bit physical address of memory described by this HOB.

+  @param  NumberOfBytes       The length of the memory described by this HOB in bytes.

+

+**/

+VOID

+EFIAPI

+BuildResourceDescriptorHob (

+  IN EFI_RESOURCE_TYPE            ResourceType,

+  IN EFI_RESOURCE_ATTRIBUTE_TYPE  ResourceAttribute,

+  IN EFI_PHYSICAL_ADDRESS         PhysicalStart,

+  IN UINT64                       NumberOfBytes

+  );

+

+/**

+  Builds a GUID HOB with a certain data length.

+

+  This function builds a customized HOB tagged with a GUID for identification 

+  and returns the start address of GUID HOB data so that caller can fill the customized data. 

+  The HOB Header and Name field is already stripped.

+  It can only be invoked during PEI phase;

+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.

+  If Guid is NULL, then ASSERT().

+  If there is no additional space for HOB creation, then ASSERT().

+  If DataLength >= (0x10000 - sizeof (EFI_HOB_GUID_TYPE)), then ASSERT().

+

+  @param  Guid          The GUID to tag the customized HOB.

+  @param  DataLength    The size of the data payload for the GUID HOB.

+

+  @return The start address of GUID HOB data.

+

+**/

+VOID *

+EFIAPI

+BuildGuidHob (

+  IN CONST EFI_GUID              *Guid,

+  IN UINTN                       DataLength

+  );

+

+/**

+  Copies a data buffer to a newly-built HOB.

+

+  This function builds a customized HOB tagged with a GUID for identification,

+  copies the input data to the HOB data field and returns the start address of the GUID HOB data.

+  The HOB Header and Name field is already stripped.

+  It can only be invoked during PEI phase;

+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.

+  If Guid is NULL, then ASSERT().

+  If Data is NULL and DataLength > 0, then ASSERT().

+  If there is no additional space for HOB creation, then ASSERT().

+  If DataLength >= (0x10000 - sizeof (EFI_HOB_GUID_TYPE)), then ASSERT().

+

+  @param  Guid          The GUID to tag the customized HOB.

+  @param  Data          The data to be copied into the data field of the GUID HOB.

+  @param  DataLength    The size of the data payload for the GUID HOB.

+

+  @return The start address of GUID HOB data.

+

+**/

+VOID *

+EFIAPI

+BuildGuidDataHob (

+  IN CONST EFI_GUID              *Guid,

+  IN VOID                        *Data,

+  IN UINTN                       DataLength

+  );

+

+/**

+  Builds a Firmware Volume HOB.

+

+  This function builds a Firmware Volume HOB.

+  It can only be invoked during PEI phase;

+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.

+  If there is no additional space for HOB creation, then ASSERT().

+

+  @param  BaseAddress   The base address of the Firmware Volume.

+  @param  Length        The size of the Firmware Volume in bytes.

+

+**/

+VOID

+EFIAPI

+BuildFvHob (

+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,

+  IN UINT64                      Length

+  );

+

+/**

+  Builds a Firmware Volume HOB and a resrouce descriptor hob 

+

+  This function builds a Firmware Volume HOB.

+  It can only be invoked during PEI phase;

+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.

+  If there is no additional space for HOB creation, then ASSERT().

+

+  @param  BaseAddress   The base address of the Firmware Volume.

+  @param  Length        The size of the Firmware Volume in bytes.

+

+**/

+VOID

+EFIAPI

+BuildFvHobs (  

+  IN EFI_PHYSICAL_ADDRESS         PhysicalStart,

+  IN UINT64                       NumberOfBytes,

+  IN EFI_RESOURCE_ATTRIBUTE_TYPE  *ResourceAttribute  OPTIONAL

+  ); 

+

+

+/**

+  Builds a EFI_HOB_TYPE_FV2 HOB.

+

+  This function builds a EFI_HOB_TYPE_FV2 HOB.

+  It can only be invoked during PEI phase;

+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.

+  If there is no additional space for HOB creation, then ASSERT().

+

+  @param  BaseAddress   The base address of the Firmware Volume.

+  @param  Length        The size of the Firmware Volume in bytes.

+  @param  FvName       The name of the Firmware Volume.

+  @param  FileName      The name of the file.

+  

+**/

+VOID

+EFIAPI

+BuildFv2Hob (

+  IN          EFI_PHYSICAL_ADDRESS        BaseAddress,

+  IN          UINT64                      Length,

+  IN CONST    EFI_GUID                    *FvName,

+  IN CONST    EFI_GUID                    *FileName

+  );

+

+/**

+  Builds a Capsule Volume HOB.

+

+  This function builds a Capsule Volume HOB.

+  It can only be invoked during PEI phase;

+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.

+  If there is no additional space for HOB creation, then ASSERT().

+

+  @param  BaseAddress   The base address of the Capsule Volume.

+  @param  Length        The size of the Capsule Volume in bytes.

+

+**/

+VOID

+EFIAPI

+BuildCvHob (

+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,

+  IN UINT64                      Length

+  );

+

+/**

+  Builds a HOB for the CPU.

+

+  This function builds a HOB for the CPU.

+  It can only be invoked during PEI phase;

+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.

+  If there is no additional space for HOB creation, then ASSERT().

+

+  @param  SizeOfMemorySpace   The maximum physical memory addressability of the processor.

+  @param  SizeOfIoSpace       The maximum physical I/O addressability of the processor.

+

+**/

+VOID

+EFIAPI

+BuildCpuHob (

+  IN UINT8                       SizeOfMemorySpace,

+  IN UINT8                       SizeOfIoSpace

+  );

+

+/**

+  Builds a HOB for the Stack.

+

+  This function builds a HOB for the stack.

+  It can only be invoked during PEI phase;

+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.

+  If there is no additional space for HOB creation, then ASSERT().

+

+  @param  BaseAddress   The 64 bit physical address of the Stack.

+  @param  Length        The length of the stack in bytes.

+

+**/

+VOID

+EFIAPI

+BuildStackHob (

+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,

+  IN UINT64                      Length

+  );

+

+/**

+  Update the Stack Hob if the stack has been moved

+

+  @param  BaseAddress   The 64 bit physical address of the Stack.

+  @param  Length        The length of the stack in bytes.

+

+**/

+VOID

+UpdateStackHob (

+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,

+  IN UINT64                      Length

+  );

+

+

+/**

+  Builds a HOB for the BSP store.

+

+  This function builds a HOB for BSP store.

+  It can only be invoked during PEI phase;

+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.

+  If there is no additional space for HOB creation, then ASSERT().

+

+  @param  BaseAddress   The 64 bit physical address of the BSP.

+  @param  Length        The length of the BSP store in bytes.

+  @param  MemoryType    Type of memory allocated by this HOB.

+

+**/

+VOID

+EFIAPI

+BuildBspStoreHob (

+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,

+  IN UINT64                      Length,

+  IN EFI_MEMORY_TYPE             MemoryType

+  );

+

+/**

+  Builds a HOB for the memory allocation.

+

+  This function builds a HOB for the memory allocation.

+  It can only be invoked during PEI phase;

+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.

+  If there is no additional space for HOB creation, then ASSERT().

+

+  @param  BaseAddress   The 64 bit physical address of the memory.

+  @param  Length        The length of the memory allocation in bytes.

+  @param  MemoryType    Type of memory allocated by this HOB.

+

+**/

+VOID

+EFIAPI

+BuildMemoryAllocationHob (

+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,

+  IN UINT64                      Length,

+  IN EFI_MEMORY_TYPE             MemoryType

+  );

+

+

+VOID

+EFIAPI

+BuildExtractSectionHob (

+  IN  EFI_GUID                                  *Guid,

+  IN  EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER   SectionGetInfo,

+  IN  EXTRACT_GUIDED_SECTION_DECODE_HANDLER     SectionExtraction

+  );

+

+VOID

+EFIAPI

+BuildPeCoffLoaderHob (

+  VOID

+  );

+

+

+/**

+  Allocates one or more 4KB pages of type EfiBootServicesData.

+

+  Allocates the number of 4KB pages of MemoryType and returns a pointer to the

+  allocated buffer.  The buffer returned is aligned on a 4KB boundary.  If Pages is 0, then NULL

+  is returned.  If there is not enough memory remaining to satisfy the request, then NULL is

+  returned.

+

+  @param  Pages                 The number of 4 KB pages to allocate.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID * 

+EFIAPI

+AllocatePages (

+  IN UINTN            Pages

+  );

+  

+/**

+  Allocates a buffer of type EfiBootServicesData.

+

+  Allocates the number bytes specified by AllocationSize of type EfiBootServicesData and returns a

+  pointer to the allocated buffer.  If AllocationSize is 0, then a valid buffer of 0 size is

+  returned.  If there is not enough memory remaining to satisfy the request, then NULL is returned.

+

+  @param  AllocationSize        The number of bytes to allocate.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID *

+EFIAPI

+AllocatePool (

+  IN UINTN  AllocationSize

+  );

+  

+  

+/**

+  Allocates one or more 4KB pages of type EfiBootServicesData at a specified alignment.

+

+  Allocates the number of 4KB pages specified by Pages of type EfiBootServicesData with an

+  alignment specified by Alignment.  The allocated buffer is returned.  If Pages is 0, then NULL is

+  returned.  If there is not enough memory at the specified alignment remaining to satisfy the

+  request, then NULL is returned.

+  If Alignment is not a power of two and Alignment is not zero, then ASSERT().

+

+  @param  Pages                 The number of 4 KB pages to allocate.

+  @param  Alignment             The requested alignment of the allocation.  Must be a power of two.

+                                If Alignment is zero, then byte alignment is used.

+

+  @return A pointer to the allocated buffer or NULL if allocation fails.

+

+**/

+VOID *

+EFIAPI

+AllocateAlignedPages (

+  IN UINTN  Pages,

+  IN UINTN  Alignment

+  );

+

+

+EFI_STATUS

+EFIAPI

+LoadPeCoffImage (

+  IN  VOID                                      *PeCoffImage,

+  OUT EFI_PHYSICAL_ADDRESS                      *ImageAddress,

+  OUT UINT64                                    *ImageSize,

+  OUT EFI_PHYSICAL_ADDRESS                      *EntryPoint

+  );

+

+EFI_STATUS

+EFIAPI

+LoadDxeCoreFromFfsFile (

+  IN EFI_PEI_FILE_HANDLE  FileHandle,

+  IN UINTN                StackSize

+  );

+

+EFI_STATUS

+EFIAPI

+LoadDxeCoreFromFv (

+  IN UINTN  *FvInstance,   OPTIONAL

+  IN UINTN  StackSize

+  );

+

+EFI_STATUS

+EFIAPI

+DecompressFirstFv (

+  VOID

+  );

+

+VOID

+EFIAPI

+AddDxeCoreReportStatusCodeCallback (

+  VOID

+  );

+

+

+#endif

diff --git a/EmbeddedPkg/Include/Library/SerialPortExtLib.h b/EmbeddedPkg/Include/Library/SerialPortExtLib.h
index 74f5e4c5..a12847ca 100644
--- a/EmbeddedPkg/Include/Library/SerialPortExtLib.h
+++ b/EmbeddedPkg/Include/Library/SerialPortExtLib.h
@@ -1,66 +1,66 @@
-/** @file
-
-  Copyright (c) 2012, ARM Ltd. All rights reserved.
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __SERIAL_PORT_EXT_LIB_H__
-#define __SERIAL_PORT_EXT_LIB_H__
-
-#include <Uefi/UefiBaseType.h>
-#include <Protocol/SerialIo.h>
-
-/**
-  Set the serial device control bits.
-
-  @return    Always return EFI_UNSUPPORTED.
-
-**/
-RETURN_STATUS
-EFIAPI
-SerialPortSetControl (
-  IN UINT32                   Control
-  );
-
-/**
-  Get the serial device control bits.
-
-  @param  Control                 Control signals read from the serial device.
-
-  @retval EFI_SUCCESS             The control bits were read from the serial device.
-  @retval EFI_DEVICE_ERROR        The serial device is not functioning correctly.
-
-**/
-RETURN_STATUS
-EFIAPI
-SerialPortGetControl (
-  OUT UINT32                  *Control
-  );
-
-/**
-  Set the serial device attributes.
-
-  @return    Always return EFI_UNSUPPORTED.
-
-**/
-RETURN_STATUS
-EFIAPI
-SerialPortSetAttributes (
-  IN UINT64              BaudRate,
-  IN UINT32              ReceiveFifoDepth,
-  IN UINT32              Timeout,
-  IN EFI_PARITY_TYPE     Parity,
-  IN UINT8               DataBits,
-  IN EFI_STOP_BITS_TYPE  StopBits
-  );
-
-#endif
-
+/** @file

+

+  Copyright (c) 2012, ARM Ltd. All rights reserved.

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __SERIAL_PORT_EXT_LIB_H__

+#define __SERIAL_PORT_EXT_LIB_H__

+

+#include <Uefi/UefiBaseType.h>

+#include <Protocol/SerialIo.h>

+

+/**

+  Set the serial device control bits.

+

+  @return    Always return EFI_UNSUPPORTED.

+

+**/

+RETURN_STATUS

+EFIAPI

+SerialPortSetControl (

+  IN UINT32                   Control

+  );

+

+/**

+  Get the serial device control bits.

+

+  @param  Control                 Control signals read from the serial device.

+

+  @retval EFI_SUCCESS             The control bits were read from the serial device.

+  @retval EFI_DEVICE_ERROR        The serial device is not functioning correctly.

+

+**/

+RETURN_STATUS

+EFIAPI

+SerialPortGetControl (

+  OUT UINT32                  *Control

+  );

+

+/**

+  Set the serial device attributes.

+

+  @return    Always return EFI_UNSUPPORTED.

+

+**/

+RETURN_STATUS

+EFIAPI

+SerialPortSetAttributes (

+  IN UINT64              BaudRate,

+  IN UINT32              ReceiveFifoDepth,

+  IN UINT32              Timeout,

+  IN EFI_PARITY_TYPE     Parity,

+  IN UINT8               DataBits,

+  IN EFI_STOP_BITS_TYPE  StopBits

+  );

+

+#endif

+

diff --git a/EmbeddedPkg/Include/Protocol/EblAddCommand.h b/EmbeddedPkg/Include/Protocol/EblAddCommand.h
index 1ce5a8f3..a7809b27 100644
--- a/EmbeddedPkg/Include/Protocol/EblAddCommand.h
+++ b/EmbeddedPkg/Include/Protocol/EblAddCommand.h
@@ -73,11 +73,11 @@ VOID
   );

 

 

-typedef 
-VOID
-(EFIAPI *EBL_GET_CHAR_CALL_BACK) (
-  IN  UINTN   ElapsedTime
-  );
+typedef 

+VOID

+(EFIAPI *EBL_GET_CHAR_CALL_BACK) (

+  IN  UINTN   ElapsedTime

+  );

 

 /**

   Return a keypress or optionally timeout if a timeout value was passed in.

diff --git a/EmbeddedPkg/Include/Protocol/EmbeddedExternalDevice.h b/EmbeddedPkg/Include/Protocol/EmbeddedExternalDevice.h
index 17188f04..603dc5ed 100644
--- a/EmbeddedPkg/Include/Protocol/EmbeddedExternalDevice.h
+++ b/EmbeddedPkg/Include/Protocol/EmbeddedExternalDevice.h
@@ -1,94 +1,94 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __EMBEDDED_EXTERNAL_DEVICE_H__
-#define __EMBEDDED_EXTERNAL_DEVICE_H__
-
-//
-// Protocol GUID
-//
-#define EMBEDDED_EXTERNAL_DEVICE_PROTOCOL_GUID { 0x735F8C64, 0xD696, 0x44D0, { 0xBD, 0xF2, 0x44, 0x7F, 0xD0, 0x5A, 0x54, 0x06 }}
-
-//
-// Protocol interface structure
-//
-typedef struct _EMBEDDED_EXTERNAL_DEVICE EMBEDDED_EXTERNAL_DEVICE;
-
-//
-// Function Prototypes
-//
-typedef
-EFI_STATUS
-(EFIAPI *EMBEDDED_EXTERNAL_DEVICE_READ) (
-    IN  EMBEDDED_EXTERNAL_DEVICE  *This,
-    IN  UINTN                       Register,
-    IN  UINTN                       Length,
-    OUT VOID                        *Buffer
-    )
-/*++
-
-Routine Description:
-
-  Read a set of contiguous external device registers.
-
-Arguments:
-
-  This        - pointer to protocol
-  Offset      - starting register number
-  Length      - number of bytes to read
-  Buffer      - destination buffer
-  
-Returns:
-
-  EFI_SUCCESS - registers read successfully
-
---*/
-;
-
-typedef
-EFI_STATUS
-(EFIAPI *EMBEDDED_EXTERNAL_DEVICE_WRITE) (
-    IN EMBEDDED_EXTERNAL_DEVICE *This,
-    IN UINTN                      Register,
-    IN UINTN                      Length,
-    IN VOID                       *Buffer
-    )
-/*++
-
-Routine Description:
-
-  Write to a set of contiguous external device registers.
-
-Arguments:
-
-  This        - pointer to protocol
-  Offset      - starting register number
-  Length      - number of bytes to write
-  Buffer      - source buffer
-  
-Returns:
-
-  EFI_SUCCESS - registers written successfully
-
---*/
-;
-
-struct _EMBEDDED_EXTERNAL_DEVICE {
-  EMBEDDED_EXTERNAL_DEVICE_READ      Read;
-  EMBEDDED_EXTERNAL_DEVICE_WRITE     Write;
-};
-
-extern EFI_GUID gEmbeddedExternalDeviceProtocolGuid;
-
-#endif	// __EMBEDDED_EXTERNAL_DEVICE_H__
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __EMBEDDED_EXTERNAL_DEVICE_H__

+#define __EMBEDDED_EXTERNAL_DEVICE_H__

+

+//

+// Protocol GUID

+//

+#define EMBEDDED_EXTERNAL_DEVICE_PROTOCOL_GUID { 0x735F8C64, 0xD696, 0x44D0, { 0xBD, 0xF2, 0x44, 0x7F, 0xD0, 0x5A, 0x54, 0x06 }}

+

+//

+// Protocol interface structure

+//

+typedef struct _EMBEDDED_EXTERNAL_DEVICE EMBEDDED_EXTERNAL_DEVICE;

+

+//

+// Function Prototypes

+//

+typedef

+EFI_STATUS

+(EFIAPI *EMBEDDED_EXTERNAL_DEVICE_READ) (

+    IN  EMBEDDED_EXTERNAL_DEVICE  *This,

+    IN  UINTN                       Register,

+    IN  UINTN                       Length,

+    OUT VOID                        *Buffer

+    )

+/*++

+

+Routine Description:

+

+  Read a set of contiguous external device registers.

+

+Arguments:

+

+  This        - pointer to protocol

+  Offset      - starting register number

+  Length      - number of bytes to read

+  Buffer      - destination buffer

+  

+Returns:

+

+  EFI_SUCCESS - registers read successfully

+

+--*/

+;

+

+typedef

+EFI_STATUS

+(EFIAPI *EMBEDDED_EXTERNAL_DEVICE_WRITE) (

+    IN EMBEDDED_EXTERNAL_DEVICE *This,

+    IN UINTN                      Register,

+    IN UINTN                      Length,

+    IN VOID                       *Buffer

+    )

+/*++

+

+Routine Description:

+

+  Write to a set of contiguous external device registers.

+

+Arguments:

+

+  This        - pointer to protocol

+  Offset      - starting register number

+  Length      - number of bytes to write

+  Buffer      - source buffer

+  

+Returns:

+

+  EFI_SUCCESS - registers written successfully

+

+--*/

+;

+

+struct _EMBEDDED_EXTERNAL_DEVICE {

+  EMBEDDED_EXTERNAL_DEVICE_READ      Read;

+  EMBEDDED_EXTERNAL_DEVICE_WRITE     Write;

+};

+

+extern EFI_GUID gEmbeddedExternalDeviceProtocolGuid;

+

+#endif	// __EMBEDDED_EXTERNAL_DEVICE_H__

diff --git a/EmbeddedPkg/Include/Protocol/EmbeddedGpio.h b/EmbeddedPkg/Include/Protocol/EmbeddedGpio.h
index 97a9a8bd..77ea7ad0 100644
--- a/EmbeddedPkg/Include/Protocol/EmbeddedGpio.h
+++ b/EmbeddedPkg/Include/Protocol/EmbeddedGpio.h
@@ -1,167 +1,167 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __EMBEDDED_GPIO_H__
-#define __EMBEDDED_GPIO_H__
-
-//
-// Protocol interface structure
-//
-typedef struct _EMBEDDED_GPIO   EMBEDDED_GPIO;
-
-//
-// Data Types
-//
-typedef UINTN EMBEDDED_GPIO_PIN;
-
-#define GPIO(Port, Pin) ((EMBEDDED_GPIO_PIN)(((Port) << (16)) | (Pin)))
-#define GPIO_PIN(x)     ((EMBEDDED_GPIO_PIN)(x) & (0xFFFF))
-#define GPIO_PORT(x)    ((EMBEDDED_GPIO_PIN)(x) >> (16))
-
-typedef enum {
-  GPIO_MODE_INPUT                 = 0x00,
-  GPIO_MODE_OUTPUT_0              = 0x0E,
-  GPIO_MODE_OUTPUT_1              = 0x0F,
-  GPIO_MODE_SPECIAL_FUNCTION_2    = 0x02,
-  GPIO_MODE_SPECIAL_FUNCTION_3    = 0x03,
-  GPIO_MODE_SPECIAL_FUNCTION_4    = 0x04,
-  GPIO_MODE_SPECIAL_FUNCTION_5    = 0x05,
-  GPIO_MODE_SPECIAL_FUNCTION_6    = 0x06,
-  GPIO_MODE_SPECIAL_FUNCTION_7    = 0x07
-} EMBEDDED_GPIO_MODE;
-
-typedef enum {
-  GPIO_PULL_NONE,
-  GPIO_PULL_UP,
-  GPIO_PULL_DOWN
-} EMBEDDED_GPIO_PULL;
-
-//
-// Function Prototypes
-//
-typedef
-EFI_STATUS
-(EFIAPI *EMBEDDED_GPIO_GET) (
-  IN  EMBEDDED_GPIO       *This,
-  IN  EMBEDDED_GPIO_PIN   Gpio,
-  OUT UINTN               *Value
-  );
-/*++
-
-Routine Description:
-
-  Gets the state of a GPIO pin
-
-Arguments:
-
-  This  - pointer to protocol
-  Gpio  - which pin to read
-  Value - state of the pin
-  
-Returns:
-
-  EFI_SUCCESS - GPIO state returned in Value
-
---*/
-
-
-typedef
-EFI_STATUS
-(EFIAPI *EMBEDDED_GPIO_SET) (
-    IN EMBEDDED_GPIO      *This,
-    IN EMBEDDED_GPIO_PIN  Gpio,
-    IN EMBEDDED_GPIO_MODE Mode
-    );
-/*++
-
-Routine Description:
-
-  Sets the state of a GPIO pin
-
-Arguments:
-
-  This  - pointer to protocol
-  Gpio  - which pin to modify
-  Mode  - mode to set
-  
-Returns:
-
-  EFI_SUCCESS - GPIO set as requested
-
---*/
-
-
-typedef
-EFI_STATUS
-(EFIAPI *EMBEDDED_GPIO_GET_MODE) (
-    IN  EMBEDDED_GPIO         *This,
-    IN  EMBEDDED_GPIO_PIN     Gpio,
-    OUT EMBEDDED_GPIO_MODE    *Mode
-    );
-/*++
-
-Routine Description:
-
-  Gets the mode (function) of a GPIO pin
-
-Arguments:
-
-  This  - pointer to protocol
-  Gpio  - which pin
-  Mode  - pointer to output mode value
-  
-Returns:
-
-  EFI_SUCCESS - mode value retrieved
-
---*/
-
-
-typedef
-EFI_STATUS
-(EFIAPI *EMBEDDED_GPIO_SET_PULL) (
-    IN  EMBEDDED_GPIO      *This,
-    IN  EMBEDDED_GPIO_PIN  Gpio,
-    IN  EMBEDDED_GPIO_PULL Direction
-    );
-/*++
-
-Routine Description:
-
-  Sets the pull-up / pull-down resistor of a GPIO pin
-
-Arguments:
-
-  This  - pointer to protocol
-  Gpio  - which pin
-  Direction - pull-up, pull-down, or none
-  
-Returns:
-
-  EFI_SUCCESS - pin was set
-
---*/
-
-
-
-struct _EMBEDDED_GPIO {
-  EMBEDDED_GPIO_GET       Get;
-  EMBEDDED_GPIO_SET       Set;
-  EMBEDDED_GPIO_GET_MODE  GetMode;
-  EMBEDDED_GPIO_SET_PULL  SetPull;
-};
-
-extern EFI_GUID gEmbeddedGpioProtocolGuid;
-
-#endif	
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __EMBEDDED_GPIO_H__

+#define __EMBEDDED_GPIO_H__

+

+//

+// Protocol interface structure

+//

+typedef struct _EMBEDDED_GPIO   EMBEDDED_GPIO;

+

+//

+// Data Types

+//

+typedef UINTN EMBEDDED_GPIO_PIN;

+

+#define GPIO(Port, Pin) ((EMBEDDED_GPIO_PIN)(((Port) << (16)) | (Pin)))

+#define GPIO_PIN(x)     ((EMBEDDED_GPIO_PIN)(x) & (0xFFFF))

+#define GPIO_PORT(x)    ((EMBEDDED_GPIO_PIN)(x) >> (16))

+

+typedef enum {

+  GPIO_MODE_INPUT                 = 0x00,

+  GPIO_MODE_OUTPUT_0              = 0x0E,

+  GPIO_MODE_OUTPUT_1              = 0x0F,

+  GPIO_MODE_SPECIAL_FUNCTION_2    = 0x02,

+  GPIO_MODE_SPECIAL_FUNCTION_3    = 0x03,

+  GPIO_MODE_SPECIAL_FUNCTION_4    = 0x04,

+  GPIO_MODE_SPECIAL_FUNCTION_5    = 0x05,

+  GPIO_MODE_SPECIAL_FUNCTION_6    = 0x06,

+  GPIO_MODE_SPECIAL_FUNCTION_7    = 0x07

+} EMBEDDED_GPIO_MODE;

+

+typedef enum {

+  GPIO_PULL_NONE,

+  GPIO_PULL_UP,

+  GPIO_PULL_DOWN

+} EMBEDDED_GPIO_PULL;

+

+//

+// Function Prototypes

+//

+typedef

+EFI_STATUS

+(EFIAPI *EMBEDDED_GPIO_GET) (

+  IN  EMBEDDED_GPIO       *This,

+  IN  EMBEDDED_GPIO_PIN   Gpio,

+  OUT UINTN               *Value

+  );

+/*++

+

+Routine Description:

+

+  Gets the state of a GPIO pin

+

+Arguments:

+

+  This  - pointer to protocol

+  Gpio  - which pin to read

+  Value - state of the pin

+  

+Returns:

+

+  EFI_SUCCESS - GPIO state returned in Value

+

+--*/

+

+

+typedef

+EFI_STATUS

+(EFIAPI *EMBEDDED_GPIO_SET) (

+    IN EMBEDDED_GPIO      *This,

+    IN EMBEDDED_GPIO_PIN  Gpio,

+    IN EMBEDDED_GPIO_MODE Mode

+    );

+/*++

+

+Routine Description:

+

+  Sets the state of a GPIO pin

+

+Arguments:

+

+  This  - pointer to protocol

+  Gpio  - which pin to modify

+  Mode  - mode to set

+  

+Returns:

+

+  EFI_SUCCESS - GPIO set as requested

+

+--*/

+

+

+typedef

+EFI_STATUS

+(EFIAPI *EMBEDDED_GPIO_GET_MODE) (

+    IN  EMBEDDED_GPIO         *This,

+    IN  EMBEDDED_GPIO_PIN     Gpio,

+    OUT EMBEDDED_GPIO_MODE    *Mode

+    );

+/*++

+

+Routine Description:

+

+  Gets the mode (function) of a GPIO pin

+

+Arguments:

+

+  This  - pointer to protocol

+  Gpio  - which pin

+  Mode  - pointer to output mode value

+  

+Returns:

+

+  EFI_SUCCESS - mode value retrieved

+

+--*/

+

+

+typedef

+EFI_STATUS

+(EFIAPI *EMBEDDED_GPIO_SET_PULL) (

+    IN  EMBEDDED_GPIO      *This,

+    IN  EMBEDDED_GPIO_PIN  Gpio,

+    IN  EMBEDDED_GPIO_PULL Direction

+    );

+/*++

+

+Routine Description:

+

+  Sets the pull-up / pull-down resistor of a GPIO pin

+

+Arguments:

+

+  This  - pointer to protocol

+  Gpio  - which pin

+  Direction - pull-up, pull-down, or none

+  

+Returns:

+

+  EFI_SUCCESS - pin was set

+

+--*/

+

+

+

+struct _EMBEDDED_GPIO {

+  EMBEDDED_GPIO_GET       Get;

+  EMBEDDED_GPIO_SET       Set;

+  EMBEDDED_GPIO_GET_MODE  GetMode;

+  EMBEDDED_GPIO_SET_PULL  SetPull;

+};

+

+extern EFI_GUID gEmbeddedGpioProtocolGuid;

+

+#endif	

diff --git a/EmbeddedPkg/Include/fdt.h b/EmbeddedPkg/Include/fdt.h
index 6e7a8b39..3b7c3710 100644
--- a/EmbeddedPkg/Include/fdt.h
+++ b/EmbeddedPkg/Include/fdt.h
@@ -1,74 +1,74 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-#ifndef _FDT_H
-#define _FDT_H
-
-#ifndef __ASSEMBLY__
-
-struct fdt_header {
-	uint32_t magic;			 /* magic word FDT_MAGIC */
-	uint32_t totalsize;		 /* total size of DT block */
-	uint32_t off_dt_struct;		 /* offset to structure */
-	uint32_t off_dt_strings;	 /* offset to strings */
-	uint32_t off_mem_rsvmap;	 /* offset to memory reserve map */
-	uint32_t version;		 /* format version */
-	uint32_t last_comp_version;	 /* last compatible version */
-
-	/* version 2 fields below */
-	uint32_t boot_cpuid_phys;	 /* Which physical CPU id we're
-					    booting on */
-	/* version 3 fields below */
-	uint32_t size_dt_strings;	 /* size of the strings block */
-
-	/* version 17 fields below */
-	uint32_t size_dt_struct;	 /* size of the structure block */
-};
-
-struct fdt_reserve_entry {
-	uint64_t address;
-	uint64_t size;
-};
-
-struct fdt_node_header {
-	uint32_t tag;
-	char name[0];
-};
-
-struct fdt_property {
-	uint32_t tag;
-	uint32_t len;
-	uint32_t nameoff;
-	char data[0];
-};
-
-#endif /* !__ASSEMBLY */
-
-#define FDT_MAGIC	0xd00dfeed	/* 4: version, 4: total size */
-#define FDT_TAGSIZE	sizeof(uint32_t)
-
-#define FDT_BEGIN_NODE	0x1		/* Start node: full name */
-#define FDT_END_NODE	0x2		/* End node */
-#define FDT_PROP	0x3		/* Property: name off,
-					   size, content */
-#define FDT_NOP		0x4		/* nop */
-#define FDT_END		0x9
-
-#define FDT_V1_SIZE	(7*sizeof(uint32_t))
-#define FDT_V2_SIZE	(FDT_V1_SIZE + sizeof(uint32_t))
-#define FDT_V3_SIZE	(FDT_V2_SIZE + sizeof(uint32_t))
-#define FDT_V16_SIZE	FDT_V3_SIZE
-#define FDT_V17_SIZE	(FDT_V16_SIZE + sizeof(uint32_t))
-
-#endif /* _FDT_H */
+/** @file

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+#ifndef _FDT_H

+#define _FDT_H

+

+#ifndef __ASSEMBLY__

+

+struct fdt_header {

+	uint32_t magic;			 /* magic word FDT_MAGIC */

+	uint32_t totalsize;		 /* total size of DT block */

+	uint32_t off_dt_struct;		 /* offset to structure */

+	uint32_t off_dt_strings;	 /* offset to strings */

+	uint32_t off_mem_rsvmap;	 /* offset to memory reserve map */

+	uint32_t version;		 /* format version */

+	uint32_t last_comp_version;	 /* last compatible version */

+

+	/* version 2 fields below */

+	uint32_t boot_cpuid_phys;	 /* Which physical CPU id we're

+					    booting on */

+	/* version 3 fields below */

+	uint32_t size_dt_strings;	 /* size of the strings block */

+

+	/* version 17 fields below */

+	uint32_t size_dt_struct;	 /* size of the structure block */

+};

+

+struct fdt_reserve_entry {

+	uint64_t address;

+	uint64_t size;

+};

+

+struct fdt_node_header {

+	uint32_t tag;

+	char name[0];

+};

+

+struct fdt_property {

+	uint32_t tag;

+	uint32_t len;

+	uint32_t nameoff;

+	char data[0];

+};

+

+#endif /* !__ASSEMBLY */

+

+#define FDT_MAGIC	0xd00dfeed	/* 4: version, 4: total size */

+#define FDT_TAGSIZE	sizeof(uint32_t)

+

+#define FDT_BEGIN_NODE	0x1		/* Start node: full name */

+#define FDT_END_NODE	0x2		/* End node */

+#define FDT_PROP	0x3		/* Property: name off,

+					   size, content */

+#define FDT_NOP		0x4		/* nop */

+#define FDT_END		0x9

+

+#define FDT_V1_SIZE	(7*sizeof(uint32_t))

+#define FDT_V2_SIZE	(FDT_V1_SIZE + sizeof(uint32_t))

+#define FDT_V3_SIZE	(FDT_V2_SIZE + sizeof(uint32_t))

+#define FDT_V16_SIZE	FDT_V3_SIZE

+#define FDT_V17_SIZE	(FDT_V16_SIZE + sizeof(uint32_t))

+

+#endif /* _FDT_H */

diff --git a/EmbeddedPkg/Include/libfdt.h b/EmbeddedPkg/Include/libfdt.h
index 73f49759..85fe324c 100644
--- a/EmbeddedPkg/Include/libfdt.h
+++ b/EmbeddedPkg/Include/libfdt.h
@@ -1,1478 +1,1478 @@
-#ifndef _LIBFDT_H
-#define _LIBFDT_H
-/*
- * libfdt - Flat Device Tree manipulation
- * Copyright (C) 2006 David Gibson, IBM Corporation.
- *
- * libfdt is dual licensed: you can use it either under the terms of
- * the GPL, or the BSD license, at your option.
- *
- *  a) This library is free software; you can redistribute it and/or
- *     modify it under the terms of the GNU General Public License as
- *     published by the Free Software Foundation; either version 2 of the
- *     License, or (at your option) any later version.
- *
- *     This library is distributed in the hope that it will be useful,
- *     but WITHOUT ANY WARRANTY; without even the implied warranty of
- *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *     GNU General Public License for more details.
- *
- *     You should have received a copy of the GNU General Public
- *     License along with this library; if not, write to the Free
- *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
- *     MA 02110-1301 USA
- *
- * Alternatively,
- *
- *  b) Redistribution and use in source and binary forms, with or
- *     without modification, are permitted provided that the following
- *     conditions are met:
- *
- *     1. Redistributions of source code must retain the above
- *        copyright notice, this list of conditions and the following
- *        disclaimer.
- *     2. Redistributions in binary form must reproduce the above
- *        copyright notice, this list of conditions and the following
- *        disclaimer in the documentation and/or other materials
- *        provided with the distribution.
- *
- *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
- *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
- *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include <libfdt_env.h>
-#include <fdt.h>
-
-#define FDT_FIRST_SUPPORTED_VERSION	0x10
-#define FDT_LAST_SUPPORTED_VERSION	0x11
-
-/* Error codes: informative error codes */
-#define FDT_ERR_NOTFOUND	1
-	/* FDT_ERR_NOTFOUND: The requested node or property does not exist */
-#define FDT_ERR_EXISTS		2
-	/* FDT_ERR_EXISTS: Attemped to create a node or property which
-	 * already exists */
-#define FDT_ERR_NOSPACE		3
-	/* FDT_ERR_NOSPACE: Operation needed to expand the device
-	 * tree, but its buffer did not have sufficient space to
-	 * contain the expanded tree. Use fdt_open_into() to move the
-	 * device tree to a buffer with more space. */
-
-/* Error codes: codes for bad parameters */
-#define FDT_ERR_BADOFFSET	4
-	/* FDT_ERR_BADOFFSET: Function was passed a structure block
-	 * offset which is out-of-bounds, or which points to an
-	 * unsuitable part of the structure for the operation. */
-#define FDT_ERR_BADPATH		5
-	/* FDT_ERR_BADPATH: Function was passed a badly formatted path
-	 * (e.g. missing a leading / for a function which requires an
-	 * absolute path) */
-#define FDT_ERR_BADPHANDLE	6
-	/* FDT_ERR_BADPHANDLE: Function was passed an invalid phandle
-	 * value.  phandle values of 0 and -1 are not permitted. */
-#define FDT_ERR_BADSTATE	7
-	/* FDT_ERR_BADSTATE: Function was passed an incomplete device
-	 * tree created by the sequential-write functions, which is
-	 * not sufficiently complete for the requested operation. */
-
-/* Error codes: codes for bad device tree blobs */
-#define FDT_ERR_TRUNCATED	8
-	/* FDT_ERR_TRUNCATED: Structure block of the given device tree
-	 * ends without an FDT_END tag. */
-#define FDT_ERR_BADMAGIC	9
-	/* FDT_ERR_BADMAGIC: Given "device tree" appears not to be a
-	 * device tree at all - it is missing the flattened device
-	 * tree magic number. */
-#define FDT_ERR_BADVERSION	10
-	/* FDT_ERR_BADVERSION: Given device tree has a version which
-	 * can't be handled by the requested operation.  For
-	 * read-write functions, this may mean that fdt_open_into() is
-	 * required to convert the tree to the expected version. */
-#define FDT_ERR_BADSTRUCTURE	11
-	/* FDT_ERR_BADSTRUCTURE: Given device tree has a corrupt
-	 * structure block or other serious error (e.g. misnested
-	 * nodes, or subnodes preceding properties). */
-#define FDT_ERR_BADLAYOUT	12
-	/* FDT_ERR_BADLAYOUT: For read-write functions, the given
-	 * device tree has it's sub-blocks in an order that the
-	 * function can't handle (memory reserve map, then structure,
-	 * then strings).  Use fdt_open_into() to reorganize the tree
-	 * into a form suitable for the read-write operations. */
-
-/* "Can't happen" error indicating a bug in libfdt */
-#define FDT_ERR_INTERNAL	13
-	/* FDT_ERR_INTERNAL: libfdt has failed an internal assertion.
-	 * Should never be returned, if it is, it indicates a bug in
-	 * libfdt itself. */
-
-#define FDT_ERR_MAX		13
-
-/**********************************************************************/
-/* Low-level functions (you probably don't need these)                */
-/**********************************************************************/
-
-const void *fdt_offset_ptr(const void *fdt, int offset, unsigned int checklen);
-static inline void *fdt_offset_ptr_w(void *fdt, int offset, int checklen)
-{
-	return (void *)(uintptr_t)fdt_offset_ptr(fdt, offset, checklen);
-}
-
-uint32_t fdt_next_tag(const void *fdt, int offset, int *nextoffset);
-
-/**********************************************************************/
-/* Traversal functions                                                */
-/**********************************************************************/
-
-int fdt_next_node(const void *fdt, int offset, int *depth);
-
-/**********************************************************************/
-/* General functions                                                  */
-/**********************************************************************/
-
-#define fdt_get_header(fdt, field) \
-	(fdt32_to_cpu(((const struct fdt_header *)(fdt))->field))
-#define fdt_magic(fdt) 			(fdt_get_header(fdt, magic))
-#define fdt_totalsize(fdt)		(fdt_get_header(fdt, totalsize))
-#define fdt_off_dt_struct(fdt)		(fdt_get_header(fdt, off_dt_struct))
-#define fdt_off_dt_strings(fdt)		(fdt_get_header(fdt, off_dt_strings))
-#define fdt_off_mem_rsvmap(fdt)		(fdt_get_header(fdt, off_mem_rsvmap))
-#define fdt_version(fdt)		(fdt_get_header(fdt, version))
-#define fdt_last_comp_version(fdt) 	(fdt_get_header(fdt, last_comp_version))
-#define fdt_boot_cpuid_phys(fdt) 	(fdt_get_header(fdt, boot_cpuid_phys))
-#define fdt_size_dt_strings(fdt) 	(fdt_get_header(fdt, size_dt_strings))
-#define fdt_size_dt_struct(fdt)		(fdt_get_header(fdt, size_dt_struct))
-
-#define __fdt_set_hdr(name) \
-	static inline void fdt_set_##name(void *fdt, uint32_t val) \
-	{ \
-		struct fdt_header *fdth = (struct fdt_header*)fdt; \
-		fdth->name = cpu_to_fdt32(val); \
-	}
-__fdt_set_hdr(magic);
-__fdt_set_hdr(totalsize);
-__fdt_set_hdr(off_dt_struct);
-__fdt_set_hdr(off_dt_strings);
-__fdt_set_hdr(off_mem_rsvmap);
-__fdt_set_hdr(version);
-__fdt_set_hdr(last_comp_version);
-__fdt_set_hdr(boot_cpuid_phys);
-__fdt_set_hdr(size_dt_strings);
-__fdt_set_hdr(size_dt_struct);
-#undef __fdt_set_hdr
-
-/**
- * fdt_check_header - sanity check a device tree or possible device tree
- * @fdt: pointer to data which might be a flattened device tree
- *
- * fdt_check_header() checks that the given buffer contains what
- * appears to be a flattened device tree with sane information in its
- * header.
- *
- * returns:
- *     0, if the buffer appears to contain a valid device tree
- *     -FDT_ERR_BADMAGIC,
- *     -FDT_ERR_BADVERSION,
- *     -FDT_ERR_BADSTATE, standard meanings, as above
- */
-int fdt_check_header(const void *fdt);
-
-/**
- * fdt_move - move a device tree around in memory
- * @fdt: pointer to the device tree to move
- * @buf: pointer to memory where the device is to be moved
- * @bufsize: size of the memory space at buf
- *
- * fdt_move() relocates, if possible, the device tree blob located at
- * fdt to the buffer at buf of size bufsize.  The buffer may overlap
- * with the existing device tree blob at fdt.  Therefore,
- *     fdt_move(fdt, fdt, fdt_totalsize(fdt))
- * should always succeed.
- *
- * returns:
- *     0, on success
- *     -FDT_ERR_NOSPACE, bufsize is insufficient to contain the device tree
- *     -FDT_ERR_BADMAGIC,
- *     -FDT_ERR_BADVERSION,
- *     -FDT_ERR_BADSTATE, standard meanings
- */
-int fdt_move(const void *fdt, void *buf, int bufsize);
-
-/**********************************************************************/
-/* Read-only functions                                                */
-/**********************************************************************/
-
-/**
- * fdt_string - retrieve a string from the strings block of a device tree
- * @fdt: pointer to the device tree blob
- * @stroffset: offset of the string within the strings block (native endian)
- *
- * fdt_string() retrieves a pointer to a single string from the
- * strings block of the device tree blob at fdt.
- *
- * returns:
- *     a pointer to the string, on success
- *     NULL, if stroffset is out of bounds
- */
-const char *fdt_string(const void *fdt, int stroffset);
-
-/**
- * fdt_num_mem_rsv - retrieve the number of memory reserve map entries
- * @fdt: pointer to the device tree blob
- *
- * Returns the number of entries in the device tree blob's memory
- * reservation map.  This does not include the terminating 0,0 entry
- * or any other (0,0) entries reserved for expansion.
- *
- * returns:
- *     the number of entries
- */
-int fdt_num_mem_rsv(const void *fdt);
-
-/**
- * fdt_get_mem_rsv - retrieve one memory reserve map entry
- * @fdt: pointer to the device tree blob
- * @address, @size: pointers to 64-bit variables
- *
- * On success, *address and *size will contain the address and size of
- * the n-th reserve map entry from the device tree blob, in
- * native-endian format.
- *
- * returns:
- *     0, on success
- *     -FDT_ERR_BADMAGIC,
- *     -FDT_ERR_BADVERSION,
- *     -FDT_ERR_BADSTATE, standard meanings
- */
-int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size);
-
-/**
- * fdt_subnode_offset_namelen - find a subnode based on substring
- * @fdt: pointer to the device tree blob
- * @parentoffset: structure block offset of a node
- * @name: name of the subnode to locate
- * @namelen: number of characters of name to consider
- *
- * Identical to fdt_subnode_offset(), but only examine the first
- * namelen characters of name for matching the subnode name.  This is
- * useful for finding subnodes based on a portion of a larger string,
- * such as a full path.
- */
-int fdt_subnode_offset_namelen(const void *fdt, int parentoffset,
-			       const char *name, int namelen);
-/**
- * fdt_subnode_offset - find a subnode of a given node
- * @fdt: pointer to the device tree blob
- * @parentoffset: structure block offset of a node
- * @name: name of the subnode to locate
- *
- * fdt_subnode_offset() finds a subnode of the node at structure block
- * offset parentoffset with the given name.  name may include a unit
- * address, in which case fdt_subnode_offset() will find the subnode
- * with that unit address, or the unit address may be omitted, in
- * which case fdt_subnode_offset() will find an arbitrary subnode
- * whose name excluding unit address matches the given name.
- *
- * returns:
- *	structure block offset of the requested subnode (>=0), on success
- *	-FDT_ERR_NOTFOUND, if the requested subnode does not exist
- *	-FDT_ERR_BADOFFSET, if parentoffset did not point to an FDT_BEGIN_NODE tag
- *      -FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_TRUNCATED, standard meanings.
- */
-int fdt_subnode_offset(const void *fdt, int parentoffset, const char *name);
-
-/**
- * fdt_path_offset - find a tree node by its full path
- * @fdt: pointer to the device tree blob
- * @path: full path of the node to locate
- *
- * fdt_path_offset() finds a node of a given path in the device tree.
- * Each path component may omit the unit address portion, but the
- * results of this are undefined if any such path component is
- * ambiguous (that is if there are multiple nodes at the relevant
- * level matching the given component, differentiated only by unit
- * address).
- *
- * returns:
- *	structure block offset of the node with the requested path (>=0), on success
- *	-FDT_ERR_BADPATH, given path does not begin with '/' or is invalid
- *	-FDT_ERR_NOTFOUND, if the requested node does not exist
- *      -FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_TRUNCATED, standard meanings.
- */
-int fdt_path_offset(const void *fdt, const char *path);
-
-/**
- * fdt_get_name - retrieve the name of a given node
- * @fdt: pointer to the device tree blob
- * @nodeoffset: structure block offset of the starting node
- * @lenp: pointer to an integer variable (will be overwritten) or NULL
- *
- * fdt_get_name() retrieves the name (including unit address) of the
- * device tree node at structure block offset nodeoffset.  If lenp is
- * non-NULL, the length of this name is also returned, in the integer
- * pointed to by lenp.
- *
- * returns:
- *	pointer to the node's name, on success
- *		If lenp is non-NULL, *lenp contains the length of that name (>=0)
- *	NULL, on error
- *		if lenp is non-NULL *lenp contains an error code (<0):
- *		-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *		-FDT_ERR_BADMAGIC,
- *		-FDT_ERR_BADVERSION,
- *		-FDT_ERR_BADSTATE, standard meanings
- */
-const char *fdt_get_name(const void *fdt, int nodeoffset, int *lenp);
-
-/**
- * fdt_first_property_offset - find the offset of a node's first property
- * @fdt: pointer to the device tree blob
- * @nodeoffset: structure block offset of a node
- *
- * fdt_first_property_offset() finds the first property of the node at
- * the given structure block offset.
- *
- * returns:
- *	structure block offset of the property (>=0), on success
- *	-FDT_ERR_NOTFOUND, if the requested node has no properties
- *	-FDT_ERR_BADOFFSET, if nodeoffset did not point to an FDT_BEGIN_NODE tag
- *      -FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_TRUNCATED, standard meanings.
- */
-int fdt_first_property_offset(const void *fdt, int nodeoffset);
-
-/**
- * fdt_next_property_offset - step through a node's properties
- * @fdt: pointer to the device tree blob
- * @offset: structure block offset of a property
- *
- * fdt_next_property_offset() finds the property immediately after the
- * one at the given structure block offset.  This will be a property
- * of the same node as the given property.
- *
- * returns:
- *	structure block offset of the next property (>=0), on success
- *	-FDT_ERR_NOTFOUND, if the given property is the last in its node
- *	-FDT_ERR_BADOFFSET, if nodeoffset did not point to an FDT_PROP tag
- *      -FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_TRUNCATED, standard meanings.
- */
-int fdt_next_property_offset(const void *fdt, int offset);
-
-/**
- * fdt_get_property_by_offset - retrieve the property at a given offset
- * @fdt: pointer to the device tree blob
- * @offset: offset of the property to retrieve
- * @lenp: pointer to an integer variable (will be overwritten) or NULL
- *
- * fdt_get_property_by_offset() retrieves a pointer to the
- * fdt_property structure within the device tree blob at the given
- * offset.  If lenp is non-NULL, the length of the property value is
- * also returned, in the integer pointed to by lenp.
- *
- * returns:
- *	pointer to the structure representing the property
- *		if lenp is non-NULL, *lenp contains the length of the property
- *		value (>=0)
- *	NULL, on error
- *		if lenp is non-NULL, *lenp contains an error code (<0):
- *		-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_PROP tag
- *		-FDT_ERR_BADMAGIC,
- *		-FDT_ERR_BADVERSION,
- *		-FDT_ERR_BADSTATE,
- *		-FDT_ERR_BADSTRUCTURE,
- *		-FDT_ERR_TRUNCATED, standard meanings
- */
-const struct fdt_property *fdt_get_property_by_offset(const void *fdt,
-						      int offset,
-						      int *lenp);
-
-/**
- * fdt_get_property_namelen - find a property based on substring
- * @fdt: pointer to the device tree blob
- * @nodeoffset: offset of the node whose property to find
- * @name: name of the property to find
- * @namelen: number of characters of name to consider
- * @lenp: pointer to an integer variable (will be overwritten) or NULL
- *
- * Identical to fdt_get_property_namelen(), but only examine the first
- * namelen characters of name for matching the property name.
- */
-const struct fdt_property *fdt_get_property_namelen(const void *fdt,
-						    int nodeoffset,
-						    const char *name,
-						    int namelen, int *lenp);
-
-/**
- * fdt_get_property - find a given property in a given node
- * @fdt: pointer to the device tree blob
- * @nodeoffset: offset of the node whose property to find
- * @name: name of the property to find
- * @lenp: pointer to an integer variable (will be overwritten) or NULL
- *
- * fdt_get_property() retrieves a pointer to the fdt_property
- * structure within the device tree blob corresponding to the property
- * named 'name' of the node at offset nodeoffset.  If lenp is
- * non-NULL, the length of the property value is also returned, in the
- * integer pointed to by lenp.
- *
- * returns:
- *	pointer to the structure representing the property
- *		if lenp is non-NULL, *lenp contains the length of the property
- *		value (>=0)
- *	NULL, on error
- *		if lenp is non-NULL, *lenp contains an error code (<0):
- *		-FDT_ERR_NOTFOUND, node does not have named property
- *		-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *		-FDT_ERR_BADMAGIC,
- *		-FDT_ERR_BADVERSION,
- *		-FDT_ERR_BADSTATE,
- *		-FDT_ERR_BADSTRUCTURE,
- *		-FDT_ERR_TRUNCATED, standard meanings
- */
-const struct fdt_property *fdt_get_property(const void *fdt, int nodeoffset,
-					    const char *name, int *lenp);
-static inline struct fdt_property *fdt_get_property_w(void *fdt, int nodeoffset,
-						      const char *name,
-						      int *lenp)
-{
-	return (struct fdt_property *)(uintptr_t)
-		fdt_get_property(fdt, nodeoffset, name, lenp);
-}
-
-/**
- * fdt_getprop_by_offset - retrieve the value of a property at a given offset
- * @fdt: pointer to the device tree blob
- * @ffset: offset of the property to read
- * @namep: pointer to a string variable (will be overwritten) or NULL
- * @lenp: pointer to an integer variable (will be overwritten) or NULL
- *
- * fdt_getprop_by_offset() retrieves a pointer to the value of the
- * property at structure block offset 'offset' (this will be a pointer
- * to within the device blob itself, not a copy of the value).  If
- * lenp is non-NULL, the length of the property value is also
- * returned, in the integer pointed to by lenp.  If namep is non-NULL,
- * the property's namne will also be returned in the char * pointed to
- * by namep (this will be a pointer to within the device tree's string
- * block, not a new copy of the name).
- *
- * returns:
- *	pointer to the property's value
- *		if lenp is non-NULL, *lenp contains the length of the property
- *		value (>=0)
- *		if namep is non-NULL *namep contiains a pointer to the property
- *		name.
- *	NULL, on error
- *		if lenp is non-NULL, *lenp contains an error code (<0):
- *		-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_PROP tag
- *		-FDT_ERR_BADMAGIC,
- *		-FDT_ERR_BADVERSION,
- *		-FDT_ERR_BADSTATE,
- *		-FDT_ERR_BADSTRUCTURE,
- *		-FDT_ERR_TRUNCATED, standard meanings
- */
-const void *fdt_getprop_by_offset(const void *fdt, int offset,
-				  const char **namep, int *lenp);
-
-/**
- * fdt_getprop_namelen - get property value based on substring
- * @fdt: pointer to the device tree blob
- * @nodeoffset: offset of the node whose property to find
- * @name: name of the property to find
- * @namelen: number of characters of name to consider
- * @lenp: pointer to an integer variable (will be overwritten) or NULL
- *
- * Identical to fdt_getprop(), but only examine the first namelen
- * characters of name for matching the property name.
- */
-const void *fdt_getprop_namelen(const void *fdt, int nodeoffset,
-				const char *name, int namelen, int *lenp);
-
-/**
- * fdt_getprop - retrieve the value of a given property
- * @fdt: pointer to the device tree blob
- * @nodeoffset: offset of the node whose property to find
- * @name: name of the property to find
- * @lenp: pointer to an integer variable (will be overwritten) or NULL
- *
- * fdt_getprop() retrieves a pointer to the value of the property
- * named 'name' of the node at offset nodeoffset (this will be a
- * pointer to within the device blob itself, not a copy of the value).
- * If lenp is non-NULL, the length of the property value is also
- * returned, in the integer pointed to by lenp.
- *
- * returns:
- *	pointer to the property's value
- *		if lenp is non-NULL, *lenp contains the length of the property
- *		value (>=0)
- *	NULL, on error
- *		if lenp is non-NULL, *lenp contains an error code (<0):
- *		-FDT_ERR_NOTFOUND, node does not have named property
- *		-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *		-FDT_ERR_BADMAGIC,
- *		-FDT_ERR_BADVERSION,
- *		-FDT_ERR_BADSTATE,
- *		-FDT_ERR_BADSTRUCTURE,
- *		-FDT_ERR_TRUNCATED, standard meanings
- */
-const void *fdt_getprop(const void *fdt, int nodeoffset,
-			const char *name, int *lenp);
-static inline void *fdt_getprop_w(void *fdt, int nodeoffset,
-				  const char *name, int *lenp)
-{
-	return (void *)(uintptr_t)fdt_getprop(fdt, nodeoffset, name, lenp);
-}
-
-/**
- * fdt_get_phandle - retrieve the phandle of a given node
- * @fdt: pointer to the device tree blob
- * @nodeoffset: structure block offset of the node
- *
- * fdt_get_phandle() retrieves the phandle of the device tree node at
- * structure block offset nodeoffset.
- *
- * returns:
- *	the phandle of the node at nodeoffset, on success (!= 0, != -1)
- *	0, if the node has no phandle, or another error occurs
- */
-uint32_t fdt_get_phandle(const void *fdt, int nodeoffset);
-
-/**
- * fdt_get_alias_namelen - get alias based on substring
- * @fdt: pointer to the device tree blob
- * @name: name of the alias th look up
- * @namelen: number of characters of name to consider
- *
- * Identical to fdt_get_alias(), but only examine the first namelen
- * characters of name for matching the alias name.
- */
-const char *fdt_get_alias_namelen(const void *fdt,
-				  const char *name, int namelen);
-
-/**
- * fdt_get_alias - retreive the path referenced by a given alias
- * @fdt: pointer to the device tree blob
- * @name: name of the alias th look up
- *
- * fdt_get_alias() retrieves the value of a given alias.  That is, the
- * value of the property named 'name' in the node /aliases.
- *
- * returns:
- *	a pointer to the expansion of the alias named 'name', of it exists
- *	NULL, if the given alias or the /aliases node does not exist
- */
-const char *fdt_get_alias(const void *fdt, const char *name);
-
-/**
- * fdt_get_path - determine the full path of a node
- * @fdt: pointer to the device tree blob
- * @nodeoffset: offset of the node whose path to find
- * @buf: character buffer to contain the returned path (will be overwritten)
- * @buflen: size of the character buffer at buf
- *
- * fdt_get_path() computes the full path of the node at offset
- * nodeoffset, and records that path in the buffer at buf.
- *
- * NOTE: This function is expensive, as it must scan the device tree
- * structure from the start to nodeoffset.
- *
- * returns:
- *	0, on success
- *		buf contains the absolute path of the node at
- *		nodeoffset, as a NUL-terminated string.
- * 	-FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
- *	-FDT_ERR_NOSPACE, the path of the given node is longer than (bufsize-1)
- *		characters and will not fit in the given buffer.
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE, standard meanings
- */
-int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen);
-
-/**
- * fdt_supernode_atdepth_offset - find a specific ancestor of a node
- * @fdt: pointer to the device tree blob
- * @nodeoffset: offset of the node whose parent to find
- * @supernodedepth: depth of the ancestor to find
- * @nodedepth: pointer to an integer variable (will be overwritten) or NULL
- *
- * fdt_supernode_atdepth_offset() finds an ancestor of the given node
- * at a specific depth from the root (where the root itself has depth
- * 0, its immediate subnodes depth 1 and so forth).  So
- *	fdt_supernode_atdepth_offset(fdt, nodeoffset, 0, NULL);
- * will always return 0, the offset of the root node.  If the node at
- * nodeoffset has depth D, then:
- *	fdt_supernode_atdepth_offset(fdt, nodeoffset, D, NULL);
- * will return nodeoffset itself.
- *
- * NOTE: This function is expensive, as it must scan the device tree
- * structure from the start to nodeoffset.
- *
- * returns:
-
- *	structure block offset of the node at node offset's ancestor
- *		of depth supernodedepth (>=0), on success
- * 	-FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
-*	-FDT_ERR_NOTFOUND, supernodedepth was greater than the depth of nodeoffset
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE, standard meanings
- */
-int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset,
-				 int supernodedepth, int *nodedepth);
-
-/**
- * fdt_node_depth - find the depth of a given node
- * @fdt: pointer to the device tree blob
- * @nodeoffset: offset of the node whose parent to find
- *
- * fdt_node_depth() finds the depth of a given node.  The root node
- * has depth 0, its immediate subnodes depth 1 and so forth.
- *
- * NOTE: This function is expensive, as it must scan the device tree
- * structure from the start to nodeoffset.
- *
- * returns:
- *	depth of the node at nodeoffset (>=0), on success
- * 	-FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE, standard meanings
- */
-int fdt_node_depth(const void *fdt, int nodeoffset);
-
-/**
- * fdt_parent_offset - find the parent of a given node
- * @fdt: pointer to the device tree blob
- * @nodeoffset: offset of the node whose parent to find
- *
- * fdt_parent_offset() locates the parent node of a given node (that
- * is, it finds the offset of the node which contains the node at
- * nodeoffset as a subnode).
- *
- * NOTE: This function is expensive, as it must scan the device tree
- * structure from the start to nodeoffset, *twice*.
- *
- * returns:
- *	structure block offset of the parent of the node at nodeoffset
- *		(>=0), on success
- * 	-FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE, standard meanings
- */
-int fdt_parent_offset(const void *fdt, int nodeoffset);
-
-/**
- * fdt_node_offset_by_prop_value - find nodes with a given property value
- * @fdt: pointer to the device tree blob
- * @startoffset: only find nodes after this offset
- * @propname: property name to check
- * @propval: property value to search for
- * @proplen: length of the value in propval
- *
- * fdt_node_offset_by_prop_value() returns the offset of the first
- * node after startoffset, which has a property named propname whose
- * value is of length proplen and has value equal to propval; or if
- * startoffset is -1, the very first such node in the tree.
- *
- * To iterate through all nodes matching the criterion, the following
- * idiom can be used:
- *	offset = fdt_node_offset_by_prop_value(fdt, -1, propname,
- *					       propval, proplen);
- *	while (offset != -FDT_ERR_NOTFOUND) {
- *		// other code here
- *		offset = fdt_node_offset_by_prop_value(fdt, offset, propname,
- *						       propval, proplen);
- *	}
- *
- * Note the -1 in the first call to the function, if 0 is used here
- * instead, the function will never locate the root node, even if it
- * matches the criterion.
- *
- * returns:
- *	structure block offset of the located node (>= 0, >startoffset),
- *		 on success
- *	-FDT_ERR_NOTFOUND, no node matching the criterion exists in the
- *		tree after startoffset
- * 	-FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE, standard meanings
- */
-int fdt_node_offset_by_prop_value(const void *fdt, int startoffset,
-				  const char *propname,
-				  const void *propval, int proplen);
-
-/**
- * fdt_node_offset_by_phandle - find the node with a given phandle
- * @fdt: pointer to the device tree blob
- * @phandle: phandle value
- *
- * fdt_node_offset_by_phandle() returns the offset of the node
- * which has the given phandle value.  If there is more than one node
- * in the tree with the given phandle (an invalid tree), results are
- * undefined.
- *
- * returns:
- *	structure block offset of the located node (>= 0), on success
- *	-FDT_ERR_NOTFOUND, no node with that phandle exists
- *	-FDT_ERR_BADPHANDLE, given phandle value was invalid (0 or -1)
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE, standard meanings
- */
-int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle);
-
-/**
- * fdt_node_check_compatible: check a node's compatible property
- * @fdt: pointer to the device tree blob
- * @nodeoffset: offset of a tree node
- * @compatible: string to match against
- *
- *
- * fdt_node_check_compatible() returns 0 if the given node contains a
- * 'compatible' property with the given string as one of its elements,
- * it returns non-zero otherwise, or on error.
- *
- * returns:
- *	0, if the node has a 'compatible' property listing the given string
- *	1, if the node has a 'compatible' property, but it does not list
- *		the given string
- *	-FDT_ERR_NOTFOUND, if the given node has no 'compatible' property
- * 	-FDT_ERR_BADOFFSET, if nodeoffset does not refer to a BEGIN_NODE tag
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE, standard meanings
- */
-int fdt_node_check_compatible(const void *fdt, int nodeoffset,
-			      const char *compatible);
-
-/**
- * fdt_node_offset_by_compatible - find nodes with a given 'compatible' value
- * @fdt: pointer to the device tree blob
- * @startoffset: only find nodes after this offset
- * @compatible: 'compatible' string to match against
- *
- * fdt_node_offset_by_compatible() returns the offset of the first
- * node after startoffset, which has a 'compatible' property which
- * lists the given compatible string; or if startoffset is -1, the
- * very first such node in the tree.
- *
- * To iterate through all nodes matching the criterion, the following
- * idiom can be used:
- *	offset = fdt_node_offset_by_compatible(fdt, -1, compatible);
- *	while (offset != -FDT_ERR_NOTFOUND) {
- *		// other code here
- *		offset = fdt_node_offset_by_compatible(fdt, offset, compatible);
- *	}
- *
- * Note the -1 in the first call to the function, if 0 is used here
- * instead, the function will never locate the root node, even if it
- * matches the criterion.
- *
- * returns:
- *	structure block offset of the located node (>= 0, >startoffset),
- *		 on success
- *	-FDT_ERR_NOTFOUND, no node matching the criterion exists in the
- *		tree after startoffset
- * 	-FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE, standard meanings
- */
-int fdt_node_offset_by_compatible(const void *fdt, int startoffset,
-				  const char *compatible);
-
-/**********************************************************************/
-/* Write-in-place functions                                           */
-/**********************************************************************/
-
-/**
- * fdt_setprop_inplace - change a property's value, but not its size
- * @fdt: pointer to the device tree blob
- * @nodeoffset: offset of the node whose property to change
- * @name: name of the property to change
- * @val: pointer to data to replace the property value with
- * @len: length of the property value
- *
- * fdt_setprop_inplace() replaces the value of a given property with
- * the data in val, of length len.  This function cannot change the
- * size of a property, and so will only work if len is equal to the
- * current length of the property.
- *
- * This function will alter only the bytes in the blob which contain
- * the given property value, and will not alter or move any other part
- * of the tree.
- *
- * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, if len is not equal to the property's current length
- *	-FDT_ERR_NOTFOUND, node does not have the named property
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_TRUNCATED, standard meanings
- */
-int fdt_setprop_inplace(void *fdt, int nodeoffset, const char *name,
-			const void *val, int len);
-
-/**
- * fdt_setprop_inplace_u32 - change the value of a 32-bit integer property
- * @fdt: pointer to the device tree blob
- * @nodeoffset: offset of the node whose property to change
- * @name: name of the property to change
- * @val: 32-bit integer value to replace the property with
- *
- * fdt_setprop_inplace_u32() replaces the value of a given property
- * with the 32-bit integer value in val, converting val to big-endian
- * if necessary.  This function cannot change the size of a property,
- * and so will only work if the property already exists and has length
- * 4.
- *
- * This function will alter only the bytes in the blob which contain
- * the given property value, and will not alter or move any other part
- * of the tree.
- *
- * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, if the property's length is not equal to 4
- *	-FDT_ERR_NOTFOUND, node does not have the named property
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_TRUNCATED, standard meanings
- */
-static inline int fdt_setprop_inplace_u32(void *fdt, int nodeoffset,
-					  const char *name, uint32_t val)
-{
-	val = cpu_to_fdt32(val);
-	return fdt_setprop_inplace(fdt, nodeoffset, name, &val, sizeof(val));
-}
-
-/**
- * fdt_setprop_inplace_u64 - change the value of a 64-bit integer property
- * @fdt: pointer to the device tree blob
- * @nodeoffset: offset of the node whose property to change
- * @name: name of the property to change
- * @val: 64-bit integer value to replace the property with
- *
- * fdt_setprop_inplace_u64() replaces the value of a given property
- * with the 64-bit integer value in val, converting val to big-endian
- * if necessary.  This function cannot change the size of a property,
- * and so will only work if the property already exists and has length
- * 8.
- *
- * This function will alter only the bytes in the blob which contain
- * the given property value, and will not alter or move any other part
- * of the tree.
- *
- * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, if the property's length is not equal to 8
- *	-FDT_ERR_NOTFOUND, node does not have the named property
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_TRUNCATED, standard meanings
- */
-static inline int fdt_setprop_inplace_u64(void *fdt, int nodeoffset,
-					  const char *name, uint64_t val)
-{
-	val = cpu_to_fdt64(val);
-	return fdt_setprop_inplace(fdt, nodeoffset, name, &val, sizeof(val));
-}
-
-/**
- * fdt_setprop_inplace_cell - change the value of a single-cell property
- *
- * This is an alternative name for fdt_setprop_inplace_u32()
- */
-static inline int fdt_setprop_inplace_cell(void *fdt, int nodeoffset,
-					   const char *name, uint32_t val)
-{
-	return fdt_setprop_inplace_u32(fdt, nodeoffset, name, val);
-}
-
-/**
- * fdt_nop_property - replace a property with nop tags
- * @fdt: pointer to the device tree blob
- * @nodeoffset: offset of the node whose property to nop
- * @name: name of the property to nop
- *
- * fdt_nop_property() will replace a given property's representation
- * in the blob with FDT_NOP tags, effectively removing it from the
- * tree.
- *
- * This function will alter only the bytes in the blob which contain
- * the property, and will not alter or move any other part of the
- * tree.
- *
- * returns:
- *	0, on success
- *	-FDT_ERR_NOTFOUND, node does not have the named property
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_TRUNCATED, standard meanings
- */
-int fdt_nop_property(void *fdt, int nodeoffset, const char *name);
-
-/**
- * fdt_nop_node - replace a node (subtree) with nop tags
- * @fdt: pointer to the device tree blob
- * @nodeoffset: offset of the node to nop
- *
- * fdt_nop_node() will replace a given node's representation in the
- * blob, including all its subnodes, if any, with FDT_NOP tags,
- * effectively removing it from the tree.
- *
- * This function will alter only the bytes in the blob which contain
- * the node and its properties and subnodes, and will not alter or
- * move any other part of the tree.
- *
- * returns:
- *	0, on success
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_TRUNCATED, standard meanings
- */
-int fdt_nop_node(void *fdt, int nodeoffset);
-
-/**********************************************************************/
-/* Sequential write functions                                         */
-/**********************************************************************/
-
-int fdt_create(void *buf, int bufsize);
-int fdt_add_reservemap_entry(void *fdt, uint64_t addr, uint64_t size);
-int fdt_finish_reservemap(void *fdt);
-int fdt_begin_node(void *fdt, const char *name);
-int fdt_property(void *fdt, const char *name, const void *val, int len);
-static inline int fdt_property_u32(void *fdt, const char *name, uint32_t val)
-{
-	val = cpu_to_fdt32(val);
-	return fdt_property(fdt, name, &val, sizeof(val));
-}
-static inline int fdt_property_u64(void *fdt, const char *name, uint64_t val)
-{
-	val = cpu_to_fdt64(val);
-	return fdt_property(fdt, name, &val, sizeof(val));
-}
-static inline int fdt_property_cell(void *fdt, const char *name, uint32_t val)
-{
-	return fdt_property_u32(fdt, name, val);
-}
-#define fdt_property_string(fdt, name, str) \
-	fdt_property(fdt, name, str, strlen(str)+1)
-int fdt_end_node(void *fdt);
-int fdt_finish(void *fdt);
-
-/**********************************************************************/
-/* Read-write functions                                               */
-/**********************************************************************/
-
-int fdt_create_empty_tree(void *buf, int bufsize);
-int fdt_open_into(const void *fdt, void *buf, int bufsize);
-int fdt_pack(void *fdt);
-
-/**
- * fdt_add_mem_rsv - add one memory reserve map entry
- * @fdt: pointer to the device tree blob
- * @address, @size: 64-bit values (native endian)
- *
- * Adds a reserve map entry to the given blob reserving a region at
- * address address of length size.
- *
- * This function will insert data into the reserve map and will
- * therefore change the indexes of some entries in the table.
- *
- * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
- *		contain the new reservation entry
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_TRUNCATED, standard meanings
- */
-int fdt_add_mem_rsv(void *fdt, uint64_t address, uint64_t size);
-
-/**
- * fdt_del_mem_rsv - remove a memory reserve map entry
- * @fdt: pointer to the device tree blob
- * @n: entry to remove
- *
- * fdt_del_mem_rsv() removes the n-th memory reserve map entry from
- * the blob.
- *
- * This function will delete data from the reservation table and will
- * therefore change the indexes of some entries in the table.
- *
- * returns:
- *	0, on success
- *	-FDT_ERR_NOTFOUND, there is no entry of the given index (i.e. there
- *		are less than n+1 reserve map entries)
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_TRUNCATED, standard meanings
- */
-int fdt_del_mem_rsv(void *fdt, int n);
-
-/**
- * fdt_set_name - change the name of a given node
- * @fdt: pointer to the device tree blob
- * @nodeoffset: structure block offset of a node
- * @name: name to give the node
- *
- * fdt_set_name() replaces the name (including unit address, if any)
- * of the given node with the given string.  NOTE: this function can't
- * efficiently check if the new name is unique amongst the given
- * node's siblings; results are undefined if this function is invoked
- * with a name equal to one of the given node's siblings.
- *
- * This function may insert or delete data from the blob, and will
- * therefore change the offsets of some existing nodes.
- *
- * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob
- *		to contain the new name
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE, standard meanings
- */
-int fdt_set_name(void *fdt, int nodeoffset, const char *name);
-
-/**
- * fdt_setprop - create or change a property
- * @fdt: pointer to the device tree blob
- * @nodeoffset: offset of the node whose property to change
- * @name: name of the property to change
- * @val: pointer to data to set the property value to
- * @len: length of the property value
- *
- * fdt_setprop() sets the value of the named property in the given
- * node to the given value and length, creating the property if it
- * does not already exist.
- *
- * This function may insert or delete data from the blob, and will
- * therefore change the offsets of some existing nodes.
- *
- * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
- *		contain the new property value
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_TRUNCATED, standard meanings
- */
-int fdt_setprop(void *fdt, int nodeoffset, const char *name,
-		const void *val, int len);
-
-/**
- * fdt_setprop_u32 - set a property to a 32-bit integer
- * @fdt: pointer to the device tree blob
- * @nodeoffset: offset of the node whose property to change
- * @name: name of the property to change
- * @val: 32-bit integer value for the property (native endian)
- *
- * fdt_setprop_u32() sets the value of the named property in the given
- * node to the given 32-bit integer value (converting to big-endian if
- * necessary), or creates a new property with that value if it does
- * not already exist.
- *
- * This function may insert or delete data from the blob, and will
- * therefore change the offsets of some existing nodes.
- *
- * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
- *		contain the new property value
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_TRUNCATED, standard meanings
- */
-static inline int fdt_setprop_u32(void *fdt, int nodeoffset, const char *name,
-				  uint32_t val)
-{
-	val = cpu_to_fdt32(val);
-	return fdt_setprop(fdt, nodeoffset, name, &val, sizeof(val));
-}
-
-/**
- * fdt_setprop_u64 - set a property to a 64-bit integer
- * @fdt: pointer to the device tree blob
- * @nodeoffset: offset of the node whose property to change
- * @name: name of the property to change
- * @val: 64-bit integer value for the property (native endian)
- *
- * fdt_setprop_u64() sets the value of the named property in the given
- * node to the given 64-bit integer value (converting to big-endian if
- * necessary), or creates a new property with that value if it does
- * not already exist.
- *
- * This function may insert or delete data from the blob, and will
- * therefore change the offsets of some existing nodes.
- *
- * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
- *		contain the new property value
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_TRUNCATED, standard meanings
- */
-static inline int fdt_setprop_u64(void *fdt, int nodeoffset, const char *name,
-				  uint64_t val)
-{
-	val = cpu_to_fdt64(val);
-	return fdt_setprop(fdt, nodeoffset, name, &val, sizeof(val));
-}
-
-/**
- * fdt_setprop_cell - set a property to a single cell value
- *
- * This is an alternative name for fdt_setprop_u32()
- */
-static inline int fdt_setprop_cell(void *fdt, int nodeoffset, const char *name,
-				   uint32_t val)
-{
-	return fdt_setprop_u32(fdt, nodeoffset, name, val);
-}
-
-/**
- * fdt_setprop_string - set a property to a string value
- * @fdt: pointer to the device tree blob
- * @nodeoffset: offset of the node whose property to change
- * @name: name of the property to change
- * @str: string value for the property
- *
- * fdt_setprop_string() sets the value of the named property in the
- * given node to the given string value (using the length of the
- * string to determine the new length of the property), or creates a
- * new property with that value if it does not already exist.
- *
- * This function may insert or delete data from the blob, and will
- * therefore change the offsets of some existing nodes.
- *
- * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
- *		contain the new property value
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_TRUNCATED, standard meanings
- */
-#define fdt_setprop_string(fdt, nodeoffset, name, str) \
-	fdt_setprop((fdt), (nodeoffset), (name), (str), strlen(str)+1)
-
-/**
- * fdt_appendprop - append to or create a property
- * @fdt: pointer to the device tree blob
- * @nodeoffset: offset of the node whose property to change
- * @name: name of the property to append to
- * @val: pointer to data to append to the property value
- * @len: length of the data to append to the property value
- *
- * fdt_appendprop() appends the value to the named property in the
- * given node, creating the property if it does not already exist.
- *
- * This function may insert data into the blob, and will therefore
- * change the offsets of some existing nodes.
- *
- * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
- *		contain the new property value
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_TRUNCATED, standard meanings
- */
-int fdt_appendprop(void *fdt, int nodeoffset, const char *name,
-		   const void *val, int len);
-
-/**
- * fdt_appendprop_u32 - append a 32-bit integer value to a property
- * @fdt: pointer to the device tree blob
- * @nodeoffset: offset of the node whose property to change
- * @name: name of the property to change
- * @val: 32-bit integer value to append to the property (native endian)
- *
- * fdt_appendprop_u32() appends the given 32-bit integer value
- * (converting to big-endian if necessary) to the value of the named
- * property in the given node, or creates a new property with that
- * value if it does not already exist.
- *
- * This function may insert data into the blob, and will therefore
- * change the offsets of some existing nodes.
- *
- * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
- *		contain the new property value
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_TRUNCATED, standard meanings
- */
-static inline int fdt_appendprop_u32(void *fdt, int nodeoffset,
-				     const char *name, uint32_t val)
-{
-	val = cpu_to_fdt32(val);
-	return fdt_appendprop(fdt, nodeoffset, name, &val, sizeof(val));
-}
-
-/**
- * fdt_appendprop_u64 - append a 64-bit integer value to a property
- * @fdt: pointer to the device tree blob
- * @nodeoffset: offset of the node whose property to change
- * @name: name of the property to change
- * @val: 64-bit integer value to append to the property (native endian)
- *
- * fdt_appendprop_u64() appends the given 64-bit integer value
- * (converting to big-endian if necessary) to the value of the named
- * property in the given node, or creates a new property with that
- * value if it does not already exist.
- *
- * This function may insert data into the blob, and will therefore
- * change the offsets of some existing nodes.
- *
- * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
- *		contain the new property value
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_TRUNCATED, standard meanings
- */
-static inline int fdt_appendprop_u64(void *fdt, int nodeoffset,
-				     const char *name, uint64_t val)
-{
-	val = cpu_to_fdt64(val);
-	return fdt_appendprop(fdt, nodeoffset, name, &val, sizeof(val));
-}
-
-/**
- * fdt_appendprop_cell - append a single cell value to a property
- *
- * This is an alternative name for fdt_appendprop_u32()
- */
-static inline int fdt_appendprop_cell(void *fdt, int nodeoffset,
-				      const char *name, uint32_t val)
-{
-	return fdt_appendprop_u32(fdt, nodeoffset, name, val);
-}
-
-/**
- * fdt_appendprop_string - append a string to a property
- * @fdt: pointer to the device tree blob
- * @nodeoffset: offset of the node whose property to change
- * @name: name of the property to change
- * @str: string value to append to the property
- *
- * fdt_appendprop_string() appends the given string to the value of
- * the named property in the given node, or creates a new property
- * with that value if it does not already exist.
- *
- * This function may insert data into the blob, and will therefore
- * change the offsets of some existing nodes.
- *
- * returns:
- *	0, on success
- *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to
- *		contain the new property value
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_TRUNCATED, standard meanings
- */
-#define fdt_appendprop_string(fdt, nodeoffset, name, str) \
-	fdt_appendprop((fdt), (nodeoffset), (name), (str), strlen(str)+1)
-
-/**
- * fdt_delprop - delete a property
- * @fdt: pointer to the device tree blob
- * @nodeoffset: offset of the node whose property to nop
- * @name: name of the property to nop
- *
- * fdt_del_property() will delete the given property.
- *
- * This function will delete data from the blob, and will therefore
- * change the offsets of some existing nodes.
- *
- * returns:
- *	0, on success
- *	-FDT_ERR_NOTFOUND, node does not have the named property
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_TRUNCATED, standard meanings
- */
-int fdt_delprop(void *fdt, int nodeoffset, const char *name);
-
-/**
- * fdt_add_subnode_namelen - creates a new node based on substring
- * @fdt: pointer to the device tree blob
- * @parentoffset: structure block offset of a node
- * @name: name of the subnode to locate
- * @namelen: number of characters of name to consider
- *
- * Identical to fdt_add_subnode(), but use only the first namelen
- * characters of name as the name of the new node.  This is useful for
- * creating subnodes based on a portion of a larger string, such as a
- * full path.
- */
-int fdt_add_subnode_namelen(void *fdt, int parentoffset,
-			    const char *name, int namelen);
-
-/**
- * fdt_add_subnode - creates a new node
- * @fdt: pointer to the device tree blob
- * @parentoffset: structure block offset of a node
- * @name: name of the subnode to locate
- *
- * fdt_add_subnode() creates a new node as a subnode of the node at
- * structure block offset parentoffset, with the given name (which
- * should include the unit address, if any).
- *
- * This function will insert data into the blob, and will therefore
- * change the offsets of some existing nodes.
-
- * returns:
- *	structure block offset of the created nodeequested subnode (>=0), on success
- *	-FDT_ERR_NOTFOUND, if the requested subnode does not exist
- *	-FDT_ERR_BADOFFSET, if parentoffset did not point to an FDT_BEGIN_NODE tag
- *	-FDT_ERR_EXISTS, if the node at parentoffset already has a subnode of
- *		the given name
- *	-FDT_ERR_NOSPACE, if there is insufficient free space in the
- *		blob to contain the new node
- *	-FDT_ERR_NOSPACE
- *	-FDT_ERR_BADLAYOUT
- *      -FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_TRUNCATED, standard meanings.
- */
-int fdt_add_subnode(void *fdt, int parentoffset, const char *name);
-
-/**
- * fdt_del_node - delete a node (subtree)
- * @fdt: pointer to the device tree blob
- * @nodeoffset: offset of the node to nop
- *
- * fdt_del_node() will remove the given node, including all its
- * subnodes if any, from the blob.
- *
- * This function will delete data from the blob, and will therefore
- * change the offsets of some existing nodes.
- *
- * returns:
- *	0, on success
- *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag
- *	-FDT_ERR_BADLAYOUT,
- *	-FDT_ERR_BADMAGIC,
- *	-FDT_ERR_BADVERSION,
- *	-FDT_ERR_BADSTATE,
- *	-FDT_ERR_BADSTRUCTURE,
- *	-FDT_ERR_TRUNCATED, standard meanings
- */
-int fdt_del_node(void *fdt, int nodeoffset);
-
-/**********************************************************************/
-/* Debugging / informational functions                                */
-/**********************************************************************/
-
-const char *fdt_strerror(int errval);
-
-#endif /* _LIBFDT_H */
+#ifndef _LIBFDT_H

+#define _LIBFDT_H

+/*

+ * libfdt - Flat Device Tree manipulation

+ * Copyright (C) 2006 David Gibson, IBM Corporation.

+ *

+ * libfdt is dual licensed: you can use it either under the terms of

+ * the GPL, or the BSD license, at your option.

+ *

+ *  a) This library is free software; you can redistribute it and/or

+ *     modify it under the terms of the GNU General Public License as

+ *     published by the Free Software Foundation; either version 2 of the

+ *     License, or (at your option) any later version.

+ *

+ *     This library is distributed in the hope that it will be useful,

+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of

+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ *     GNU General Public License for more details.

+ *

+ *     You should have received a copy of the GNU General Public

+ *     License along with this library; if not, write to the Free

+ *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,

+ *     MA 02110-1301 USA

+ *

+ * Alternatively,

+ *

+ *  b) Redistribution and use in source and binary forms, with or

+ *     without modification, are permitted provided that the following

+ *     conditions are met:

+ *

+ *     1. Redistributions of source code must retain the above

+ *        copyright notice, this list of conditions and the following

+ *        disclaimer.

+ *     2. Redistributions in binary form must reproduce the above

+ *        copyright notice, this list of conditions and the following

+ *        disclaimer in the documentation and/or other materials

+ *        provided with the distribution.

+ *

+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND

+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,

+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,

+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ */

+

+#include <libfdt_env.h>

+#include <fdt.h>

+

+#define FDT_FIRST_SUPPORTED_VERSION	0x10

+#define FDT_LAST_SUPPORTED_VERSION	0x11

+

+/* Error codes: informative error codes */

+#define FDT_ERR_NOTFOUND	1

+	/* FDT_ERR_NOTFOUND: The requested node or property does not exist */

+#define FDT_ERR_EXISTS		2

+	/* FDT_ERR_EXISTS: Attemped to create a node or property which

+	 * already exists */

+#define FDT_ERR_NOSPACE		3

+	/* FDT_ERR_NOSPACE: Operation needed to expand the device

+	 * tree, but its buffer did not have sufficient space to

+	 * contain the expanded tree. Use fdt_open_into() to move the

+	 * device tree to a buffer with more space. */

+

+/* Error codes: codes for bad parameters */

+#define FDT_ERR_BADOFFSET	4

+	/* FDT_ERR_BADOFFSET: Function was passed a structure block

+	 * offset which is out-of-bounds, or which points to an

+	 * unsuitable part of the structure for the operation. */

+#define FDT_ERR_BADPATH		5

+	/* FDT_ERR_BADPATH: Function was passed a badly formatted path

+	 * (e.g. missing a leading / for a function which requires an

+	 * absolute path) */

+#define FDT_ERR_BADPHANDLE	6

+	/* FDT_ERR_BADPHANDLE: Function was passed an invalid phandle

+	 * value.  phandle values of 0 and -1 are not permitted. */

+#define FDT_ERR_BADSTATE	7

+	/* FDT_ERR_BADSTATE: Function was passed an incomplete device

+	 * tree created by the sequential-write functions, which is

+	 * not sufficiently complete for the requested operation. */

+

+/* Error codes: codes for bad device tree blobs */

+#define FDT_ERR_TRUNCATED	8

+	/* FDT_ERR_TRUNCATED: Structure block of the given device tree

+	 * ends without an FDT_END tag. */

+#define FDT_ERR_BADMAGIC	9

+	/* FDT_ERR_BADMAGIC: Given "device tree" appears not to be a

+	 * device tree at all - it is missing the flattened device

+	 * tree magic number. */

+#define FDT_ERR_BADVERSION	10

+	/* FDT_ERR_BADVERSION: Given device tree has a version which

+	 * can't be handled by the requested operation.  For

+	 * read-write functions, this may mean that fdt_open_into() is

+	 * required to convert the tree to the expected version. */

+#define FDT_ERR_BADSTRUCTURE	11

+	/* FDT_ERR_BADSTRUCTURE: Given device tree has a corrupt

+	 * structure block or other serious error (e.g. misnested

+	 * nodes, or subnodes preceding properties). */

+#define FDT_ERR_BADLAYOUT	12

+	/* FDT_ERR_BADLAYOUT: For read-write functions, the given

+	 * device tree has it's sub-blocks in an order that the

+	 * function can't handle (memory reserve map, then structure,

+	 * then strings).  Use fdt_open_into() to reorganize the tree

+	 * into a form suitable for the read-write operations. */

+

+/* "Can't happen" error indicating a bug in libfdt */

+#define FDT_ERR_INTERNAL	13

+	/* FDT_ERR_INTERNAL: libfdt has failed an internal assertion.

+	 * Should never be returned, if it is, it indicates a bug in

+	 * libfdt itself. */

+

+#define FDT_ERR_MAX		13

+

+/**********************************************************************/

+/* Low-level functions (you probably don't need these)                */

+/**********************************************************************/

+

+const void *fdt_offset_ptr(const void *fdt, int offset, unsigned int checklen);

+static inline void *fdt_offset_ptr_w(void *fdt, int offset, int checklen)

+{

+	return (void *)(uintptr_t)fdt_offset_ptr(fdt, offset, checklen);

+}

+

+uint32_t fdt_next_tag(const void *fdt, int offset, int *nextoffset);

+

+/**********************************************************************/

+/* Traversal functions                                                */

+/**********************************************************************/

+

+int fdt_next_node(const void *fdt, int offset, int *depth);

+

+/**********************************************************************/

+/* General functions                                                  */

+/**********************************************************************/

+

+#define fdt_get_header(fdt, field) \

+	(fdt32_to_cpu(((const struct fdt_header *)(fdt))->field))

+#define fdt_magic(fdt) 			(fdt_get_header(fdt, magic))

+#define fdt_totalsize(fdt)		(fdt_get_header(fdt, totalsize))

+#define fdt_off_dt_struct(fdt)		(fdt_get_header(fdt, off_dt_struct))

+#define fdt_off_dt_strings(fdt)		(fdt_get_header(fdt, off_dt_strings))

+#define fdt_off_mem_rsvmap(fdt)		(fdt_get_header(fdt, off_mem_rsvmap))

+#define fdt_version(fdt)		(fdt_get_header(fdt, version))

+#define fdt_last_comp_version(fdt) 	(fdt_get_header(fdt, last_comp_version))

+#define fdt_boot_cpuid_phys(fdt) 	(fdt_get_header(fdt, boot_cpuid_phys))

+#define fdt_size_dt_strings(fdt) 	(fdt_get_header(fdt, size_dt_strings))

+#define fdt_size_dt_struct(fdt)		(fdt_get_header(fdt, size_dt_struct))

+

+#define __fdt_set_hdr(name) \

+	static inline void fdt_set_##name(void *fdt, uint32_t val) \

+	{ \

+		struct fdt_header *fdth = (struct fdt_header*)fdt; \

+		fdth->name = cpu_to_fdt32(val); \

+	}

+__fdt_set_hdr(magic);

+__fdt_set_hdr(totalsize);

+__fdt_set_hdr(off_dt_struct);

+__fdt_set_hdr(off_dt_strings);

+__fdt_set_hdr(off_mem_rsvmap);

+__fdt_set_hdr(version);

+__fdt_set_hdr(last_comp_version);

+__fdt_set_hdr(boot_cpuid_phys);

+__fdt_set_hdr(size_dt_strings);

+__fdt_set_hdr(size_dt_struct);

+#undef __fdt_set_hdr

+

+/**

+ * fdt_check_header - sanity check a device tree or possible device tree

+ * @fdt: pointer to data which might be a flattened device tree

+ *

+ * fdt_check_header() checks that the given buffer contains what

+ * appears to be a flattened device tree with sane information in its

+ * header.

+ *

+ * returns:

+ *     0, if the buffer appears to contain a valid device tree

+ *     -FDT_ERR_BADMAGIC,

+ *     -FDT_ERR_BADVERSION,

+ *     -FDT_ERR_BADSTATE, standard meanings, as above

+ */

+int fdt_check_header(const void *fdt);

+

+/**

+ * fdt_move - move a device tree around in memory

+ * @fdt: pointer to the device tree to move

+ * @buf: pointer to memory where the device is to be moved

+ * @bufsize: size of the memory space at buf

+ *

+ * fdt_move() relocates, if possible, the device tree blob located at

+ * fdt to the buffer at buf of size bufsize.  The buffer may overlap

+ * with the existing device tree blob at fdt.  Therefore,

+ *     fdt_move(fdt, fdt, fdt_totalsize(fdt))

+ * should always succeed.

+ *

+ * returns:

+ *     0, on success

+ *     -FDT_ERR_NOSPACE, bufsize is insufficient to contain the device tree

+ *     -FDT_ERR_BADMAGIC,

+ *     -FDT_ERR_BADVERSION,

+ *     -FDT_ERR_BADSTATE, standard meanings

+ */

+int fdt_move(const void *fdt, void *buf, int bufsize);

+

+/**********************************************************************/

+/* Read-only functions                                                */

+/**********************************************************************/

+

+/**

+ * fdt_string - retrieve a string from the strings block of a device tree

+ * @fdt: pointer to the device tree blob

+ * @stroffset: offset of the string within the strings block (native endian)

+ *

+ * fdt_string() retrieves a pointer to a single string from the

+ * strings block of the device tree blob at fdt.

+ *

+ * returns:

+ *     a pointer to the string, on success

+ *     NULL, if stroffset is out of bounds

+ */

+const char *fdt_string(const void *fdt, int stroffset);

+

+/**

+ * fdt_num_mem_rsv - retrieve the number of memory reserve map entries

+ * @fdt: pointer to the device tree blob

+ *

+ * Returns the number of entries in the device tree blob's memory

+ * reservation map.  This does not include the terminating 0,0 entry

+ * or any other (0,0) entries reserved for expansion.

+ *

+ * returns:

+ *     the number of entries

+ */

+int fdt_num_mem_rsv(const void *fdt);

+

+/**

+ * fdt_get_mem_rsv - retrieve one memory reserve map entry

+ * @fdt: pointer to the device tree blob

+ * @address, @size: pointers to 64-bit variables

+ *

+ * On success, *address and *size will contain the address and size of

+ * the n-th reserve map entry from the device tree blob, in

+ * native-endian format.

+ *

+ * returns:

+ *     0, on success

+ *     -FDT_ERR_BADMAGIC,

+ *     -FDT_ERR_BADVERSION,

+ *     -FDT_ERR_BADSTATE, standard meanings

+ */

+int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size);

+

+/**

+ * fdt_subnode_offset_namelen - find a subnode based on substring

+ * @fdt: pointer to the device tree blob

+ * @parentoffset: structure block offset of a node

+ * @name: name of the subnode to locate

+ * @namelen: number of characters of name to consider

+ *

+ * Identical to fdt_subnode_offset(), but only examine the first

+ * namelen characters of name for matching the subnode name.  This is

+ * useful for finding subnodes based on a portion of a larger string,

+ * such as a full path.

+ */

+int fdt_subnode_offset_namelen(const void *fdt, int parentoffset,

+			       const char *name, int namelen);

+/**

+ * fdt_subnode_offset - find a subnode of a given node

+ * @fdt: pointer to the device tree blob

+ * @parentoffset: structure block offset of a node

+ * @name: name of the subnode to locate

+ *

+ * fdt_subnode_offset() finds a subnode of the node at structure block

+ * offset parentoffset with the given name.  name may include a unit

+ * address, in which case fdt_subnode_offset() will find the subnode

+ * with that unit address, or the unit address may be omitted, in

+ * which case fdt_subnode_offset() will find an arbitrary subnode

+ * whose name excluding unit address matches the given name.

+ *

+ * returns:

+ *	structure block offset of the requested subnode (>=0), on success

+ *	-FDT_ERR_NOTFOUND, if the requested subnode does not exist

+ *	-FDT_ERR_BADOFFSET, if parentoffset did not point to an FDT_BEGIN_NODE tag

+ *      -FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE,

+ *	-FDT_ERR_TRUNCATED, standard meanings.

+ */

+int fdt_subnode_offset(const void *fdt, int parentoffset, const char *name);

+

+/**

+ * fdt_path_offset - find a tree node by its full path

+ * @fdt: pointer to the device tree blob

+ * @path: full path of the node to locate

+ *

+ * fdt_path_offset() finds a node of a given path in the device tree.

+ * Each path component may omit the unit address portion, but the

+ * results of this are undefined if any such path component is

+ * ambiguous (that is if there are multiple nodes at the relevant

+ * level matching the given component, differentiated only by unit

+ * address).

+ *

+ * returns:

+ *	structure block offset of the node with the requested path (>=0), on success

+ *	-FDT_ERR_BADPATH, given path does not begin with '/' or is invalid

+ *	-FDT_ERR_NOTFOUND, if the requested node does not exist

+ *      -FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE,

+ *	-FDT_ERR_TRUNCATED, standard meanings.

+ */

+int fdt_path_offset(const void *fdt, const char *path);

+

+/**

+ * fdt_get_name - retrieve the name of a given node

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: structure block offset of the starting node

+ * @lenp: pointer to an integer variable (will be overwritten) or NULL

+ *

+ * fdt_get_name() retrieves the name (including unit address) of the

+ * device tree node at structure block offset nodeoffset.  If lenp is

+ * non-NULL, the length of this name is also returned, in the integer

+ * pointed to by lenp.

+ *

+ * returns:

+ *	pointer to the node's name, on success

+ *		If lenp is non-NULL, *lenp contains the length of that name (>=0)

+ *	NULL, on error

+ *		if lenp is non-NULL *lenp contains an error code (<0):

+ *		-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag

+ *		-FDT_ERR_BADMAGIC,

+ *		-FDT_ERR_BADVERSION,

+ *		-FDT_ERR_BADSTATE, standard meanings

+ */

+const char *fdt_get_name(const void *fdt, int nodeoffset, int *lenp);

+

+/**

+ * fdt_first_property_offset - find the offset of a node's first property

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: structure block offset of a node

+ *

+ * fdt_first_property_offset() finds the first property of the node at

+ * the given structure block offset.

+ *

+ * returns:

+ *	structure block offset of the property (>=0), on success

+ *	-FDT_ERR_NOTFOUND, if the requested node has no properties

+ *	-FDT_ERR_BADOFFSET, if nodeoffset did not point to an FDT_BEGIN_NODE tag

+ *      -FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE,

+ *	-FDT_ERR_TRUNCATED, standard meanings.

+ */

+int fdt_first_property_offset(const void *fdt, int nodeoffset);

+

+/**

+ * fdt_next_property_offset - step through a node's properties

+ * @fdt: pointer to the device tree blob

+ * @offset: structure block offset of a property

+ *

+ * fdt_next_property_offset() finds the property immediately after the

+ * one at the given structure block offset.  This will be a property

+ * of the same node as the given property.

+ *

+ * returns:

+ *	structure block offset of the next property (>=0), on success

+ *	-FDT_ERR_NOTFOUND, if the given property is the last in its node

+ *	-FDT_ERR_BADOFFSET, if nodeoffset did not point to an FDT_PROP tag

+ *      -FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE,

+ *	-FDT_ERR_TRUNCATED, standard meanings.

+ */

+int fdt_next_property_offset(const void *fdt, int offset);

+

+/**

+ * fdt_get_property_by_offset - retrieve the property at a given offset

+ * @fdt: pointer to the device tree blob

+ * @offset: offset of the property to retrieve

+ * @lenp: pointer to an integer variable (will be overwritten) or NULL

+ *

+ * fdt_get_property_by_offset() retrieves a pointer to the

+ * fdt_property structure within the device tree blob at the given

+ * offset.  If lenp is non-NULL, the length of the property value is

+ * also returned, in the integer pointed to by lenp.

+ *

+ * returns:

+ *	pointer to the structure representing the property

+ *		if lenp is non-NULL, *lenp contains the length of the property

+ *		value (>=0)

+ *	NULL, on error

+ *		if lenp is non-NULL, *lenp contains an error code (<0):

+ *		-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_PROP tag

+ *		-FDT_ERR_BADMAGIC,

+ *		-FDT_ERR_BADVERSION,

+ *		-FDT_ERR_BADSTATE,

+ *		-FDT_ERR_BADSTRUCTURE,

+ *		-FDT_ERR_TRUNCATED, standard meanings

+ */

+const struct fdt_property *fdt_get_property_by_offset(const void *fdt,

+						      int offset,

+						      int *lenp);

+

+/**

+ * fdt_get_property_namelen - find a property based on substring

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: offset of the node whose property to find

+ * @name: name of the property to find

+ * @namelen: number of characters of name to consider

+ * @lenp: pointer to an integer variable (will be overwritten) or NULL

+ *

+ * Identical to fdt_get_property_namelen(), but only examine the first

+ * namelen characters of name for matching the property name.

+ */

+const struct fdt_property *fdt_get_property_namelen(const void *fdt,

+						    int nodeoffset,

+						    const char *name,

+						    int namelen, int *lenp);

+

+/**

+ * fdt_get_property - find a given property in a given node

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: offset of the node whose property to find

+ * @name: name of the property to find

+ * @lenp: pointer to an integer variable (will be overwritten) or NULL

+ *

+ * fdt_get_property() retrieves a pointer to the fdt_property

+ * structure within the device tree blob corresponding to the property

+ * named 'name' of the node at offset nodeoffset.  If lenp is

+ * non-NULL, the length of the property value is also returned, in the

+ * integer pointed to by lenp.

+ *

+ * returns:

+ *	pointer to the structure representing the property

+ *		if lenp is non-NULL, *lenp contains the length of the property

+ *		value (>=0)

+ *	NULL, on error

+ *		if lenp is non-NULL, *lenp contains an error code (<0):

+ *		-FDT_ERR_NOTFOUND, node does not have named property

+ *		-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag

+ *		-FDT_ERR_BADMAGIC,

+ *		-FDT_ERR_BADVERSION,

+ *		-FDT_ERR_BADSTATE,

+ *		-FDT_ERR_BADSTRUCTURE,

+ *		-FDT_ERR_TRUNCATED, standard meanings

+ */

+const struct fdt_property *fdt_get_property(const void *fdt, int nodeoffset,

+					    const char *name, int *lenp);

+static inline struct fdt_property *fdt_get_property_w(void *fdt, int nodeoffset,

+						      const char *name,

+						      int *lenp)

+{

+	return (struct fdt_property *)(uintptr_t)

+		fdt_get_property(fdt, nodeoffset, name, lenp);

+}

+

+/**

+ * fdt_getprop_by_offset - retrieve the value of a property at a given offset

+ * @fdt: pointer to the device tree blob

+ * @ffset: offset of the property to read

+ * @namep: pointer to a string variable (will be overwritten) or NULL

+ * @lenp: pointer to an integer variable (will be overwritten) or NULL

+ *

+ * fdt_getprop_by_offset() retrieves a pointer to the value of the

+ * property at structure block offset 'offset' (this will be a pointer

+ * to within the device blob itself, not a copy of the value).  If

+ * lenp is non-NULL, the length of the property value is also

+ * returned, in the integer pointed to by lenp.  If namep is non-NULL,

+ * the property's namne will also be returned in the char * pointed to

+ * by namep (this will be a pointer to within the device tree's string

+ * block, not a new copy of the name).

+ *

+ * returns:

+ *	pointer to the property's value

+ *		if lenp is non-NULL, *lenp contains the length of the property

+ *		value (>=0)

+ *		if namep is non-NULL *namep contiains a pointer to the property

+ *		name.

+ *	NULL, on error

+ *		if lenp is non-NULL, *lenp contains an error code (<0):

+ *		-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_PROP tag

+ *		-FDT_ERR_BADMAGIC,

+ *		-FDT_ERR_BADVERSION,

+ *		-FDT_ERR_BADSTATE,

+ *		-FDT_ERR_BADSTRUCTURE,

+ *		-FDT_ERR_TRUNCATED, standard meanings

+ */

+const void *fdt_getprop_by_offset(const void *fdt, int offset,

+				  const char **namep, int *lenp);

+

+/**

+ * fdt_getprop_namelen - get property value based on substring

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: offset of the node whose property to find

+ * @name: name of the property to find

+ * @namelen: number of characters of name to consider

+ * @lenp: pointer to an integer variable (will be overwritten) or NULL

+ *

+ * Identical to fdt_getprop(), but only examine the first namelen

+ * characters of name for matching the property name.

+ */

+const void *fdt_getprop_namelen(const void *fdt, int nodeoffset,

+				const char *name, int namelen, int *lenp);

+

+/**

+ * fdt_getprop - retrieve the value of a given property

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: offset of the node whose property to find

+ * @name: name of the property to find

+ * @lenp: pointer to an integer variable (will be overwritten) or NULL

+ *

+ * fdt_getprop() retrieves a pointer to the value of the property

+ * named 'name' of the node at offset nodeoffset (this will be a

+ * pointer to within the device blob itself, not a copy of the value).

+ * If lenp is non-NULL, the length of the property value is also

+ * returned, in the integer pointed to by lenp.

+ *

+ * returns:

+ *	pointer to the property's value

+ *		if lenp is non-NULL, *lenp contains the length of the property

+ *		value (>=0)

+ *	NULL, on error

+ *		if lenp is non-NULL, *lenp contains an error code (<0):

+ *		-FDT_ERR_NOTFOUND, node does not have named property

+ *		-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag

+ *		-FDT_ERR_BADMAGIC,

+ *		-FDT_ERR_BADVERSION,

+ *		-FDT_ERR_BADSTATE,

+ *		-FDT_ERR_BADSTRUCTURE,

+ *		-FDT_ERR_TRUNCATED, standard meanings

+ */

+const void *fdt_getprop(const void *fdt, int nodeoffset,

+			const char *name, int *lenp);

+static inline void *fdt_getprop_w(void *fdt, int nodeoffset,

+				  const char *name, int *lenp)

+{

+	return (void *)(uintptr_t)fdt_getprop(fdt, nodeoffset, name, lenp);

+}

+

+/**

+ * fdt_get_phandle - retrieve the phandle of a given node

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: structure block offset of the node

+ *

+ * fdt_get_phandle() retrieves the phandle of the device tree node at

+ * structure block offset nodeoffset.

+ *

+ * returns:

+ *	the phandle of the node at nodeoffset, on success (!= 0, != -1)

+ *	0, if the node has no phandle, or another error occurs

+ */

+uint32_t fdt_get_phandle(const void *fdt, int nodeoffset);

+

+/**

+ * fdt_get_alias_namelen - get alias based on substring

+ * @fdt: pointer to the device tree blob

+ * @name: name of the alias th look up

+ * @namelen: number of characters of name to consider

+ *

+ * Identical to fdt_get_alias(), but only examine the first namelen

+ * characters of name for matching the alias name.

+ */

+const char *fdt_get_alias_namelen(const void *fdt,

+				  const char *name, int namelen);

+

+/**

+ * fdt_get_alias - retreive the path referenced by a given alias

+ * @fdt: pointer to the device tree blob

+ * @name: name of the alias th look up

+ *

+ * fdt_get_alias() retrieves the value of a given alias.  That is, the

+ * value of the property named 'name' in the node /aliases.

+ *

+ * returns:

+ *	a pointer to the expansion of the alias named 'name', of it exists

+ *	NULL, if the given alias or the /aliases node does not exist

+ */

+const char *fdt_get_alias(const void *fdt, const char *name);

+

+/**

+ * fdt_get_path - determine the full path of a node

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: offset of the node whose path to find

+ * @buf: character buffer to contain the returned path (will be overwritten)

+ * @buflen: size of the character buffer at buf

+ *

+ * fdt_get_path() computes the full path of the node at offset

+ * nodeoffset, and records that path in the buffer at buf.

+ *

+ * NOTE: This function is expensive, as it must scan the device tree

+ * structure from the start to nodeoffset.

+ *

+ * returns:

+ *	0, on success

+ *		buf contains the absolute path of the node at

+ *		nodeoffset, as a NUL-terminated string.

+ * 	-FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag

+ *	-FDT_ERR_NOSPACE, the path of the given node is longer than (bufsize-1)

+ *		characters and will not fit in the given buffer.

+ *	-FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE, standard meanings

+ */

+int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen);

+

+/**

+ * fdt_supernode_atdepth_offset - find a specific ancestor of a node

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: offset of the node whose parent to find

+ * @supernodedepth: depth of the ancestor to find

+ * @nodedepth: pointer to an integer variable (will be overwritten) or NULL

+ *

+ * fdt_supernode_atdepth_offset() finds an ancestor of the given node

+ * at a specific depth from the root (where the root itself has depth

+ * 0, its immediate subnodes depth 1 and so forth).  So

+ *	fdt_supernode_atdepth_offset(fdt, nodeoffset, 0, NULL);

+ * will always return 0, the offset of the root node.  If the node at

+ * nodeoffset has depth D, then:

+ *	fdt_supernode_atdepth_offset(fdt, nodeoffset, D, NULL);

+ * will return nodeoffset itself.

+ *

+ * NOTE: This function is expensive, as it must scan the device tree

+ * structure from the start to nodeoffset.

+ *

+ * returns:

+

+ *	structure block offset of the node at node offset's ancestor

+ *		of depth supernodedepth (>=0), on success

+ * 	-FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag

+*	-FDT_ERR_NOTFOUND, supernodedepth was greater than the depth of nodeoffset

+ *	-FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE, standard meanings

+ */

+int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset,

+				 int supernodedepth, int *nodedepth);

+

+/**

+ * fdt_node_depth - find the depth of a given node

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: offset of the node whose parent to find

+ *

+ * fdt_node_depth() finds the depth of a given node.  The root node

+ * has depth 0, its immediate subnodes depth 1 and so forth.

+ *

+ * NOTE: This function is expensive, as it must scan the device tree

+ * structure from the start to nodeoffset.

+ *

+ * returns:

+ *	depth of the node at nodeoffset (>=0), on success

+ * 	-FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag

+ *	-FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE, standard meanings

+ */

+int fdt_node_depth(const void *fdt, int nodeoffset);

+

+/**

+ * fdt_parent_offset - find the parent of a given node

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: offset of the node whose parent to find

+ *

+ * fdt_parent_offset() locates the parent node of a given node (that

+ * is, it finds the offset of the node which contains the node at

+ * nodeoffset as a subnode).

+ *

+ * NOTE: This function is expensive, as it must scan the device tree

+ * structure from the start to nodeoffset, *twice*.

+ *

+ * returns:

+ *	structure block offset of the parent of the node at nodeoffset

+ *		(>=0), on success

+ * 	-FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag

+ *	-FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE, standard meanings

+ */

+int fdt_parent_offset(const void *fdt, int nodeoffset);

+

+/**

+ * fdt_node_offset_by_prop_value - find nodes with a given property value

+ * @fdt: pointer to the device tree blob

+ * @startoffset: only find nodes after this offset

+ * @propname: property name to check

+ * @propval: property value to search for

+ * @proplen: length of the value in propval

+ *

+ * fdt_node_offset_by_prop_value() returns the offset of the first

+ * node after startoffset, which has a property named propname whose

+ * value is of length proplen and has value equal to propval; or if

+ * startoffset is -1, the very first such node in the tree.

+ *

+ * To iterate through all nodes matching the criterion, the following

+ * idiom can be used:

+ *	offset = fdt_node_offset_by_prop_value(fdt, -1, propname,

+ *					       propval, proplen);

+ *	while (offset != -FDT_ERR_NOTFOUND) {

+ *		// other code here

+ *		offset = fdt_node_offset_by_prop_value(fdt, offset, propname,

+ *						       propval, proplen);

+ *	}

+ *

+ * Note the -1 in the first call to the function, if 0 is used here

+ * instead, the function will never locate the root node, even if it

+ * matches the criterion.

+ *

+ * returns:

+ *	structure block offset of the located node (>= 0, >startoffset),

+ *		 on success

+ *	-FDT_ERR_NOTFOUND, no node matching the criterion exists in the

+ *		tree after startoffset

+ * 	-FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag

+ *	-FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE, standard meanings

+ */

+int fdt_node_offset_by_prop_value(const void *fdt, int startoffset,

+				  const char *propname,

+				  const void *propval, int proplen);

+

+/**

+ * fdt_node_offset_by_phandle - find the node with a given phandle

+ * @fdt: pointer to the device tree blob

+ * @phandle: phandle value

+ *

+ * fdt_node_offset_by_phandle() returns the offset of the node

+ * which has the given phandle value.  If there is more than one node

+ * in the tree with the given phandle (an invalid tree), results are

+ * undefined.

+ *

+ * returns:

+ *	structure block offset of the located node (>= 0), on success

+ *	-FDT_ERR_NOTFOUND, no node with that phandle exists

+ *	-FDT_ERR_BADPHANDLE, given phandle value was invalid (0 or -1)

+ *	-FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE, standard meanings

+ */

+int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle);

+

+/**

+ * fdt_node_check_compatible: check a node's compatible property

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: offset of a tree node

+ * @compatible: string to match against

+ *

+ *

+ * fdt_node_check_compatible() returns 0 if the given node contains a

+ * 'compatible' property with the given string as one of its elements,

+ * it returns non-zero otherwise, or on error.

+ *

+ * returns:

+ *	0, if the node has a 'compatible' property listing the given string

+ *	1, if the node has a 'compatible' property, but it does not list

+ *		the given string

+ *	-FDT_ERR_NOTFOUND, if the given node has no 'compatible' property

+ * 	-FDT_ERR_BADOFFSET, if nodeoffset does not refer to a BEGIN_NODE tag

+ *	-FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE, standard meanings

+ */

+int fdt_node_check_compatible(const void *fdt, int nodeoffset,

+			      const char *compatible);

+

+/**

+ * fdt_node_offset_by_compatible - find nodes with a given 'compatible' value

+ * @fdt: pointer to the device tree blob

+ * @startoffset: only find nodes after this offset

+ * @compatible: 'compatible' string to match against

+ *

+ * fdt_node_offset_by_compatible() returns the offset of the first

+ * node after startoffset, which has a 'compatible' property which

+ * lists the given compatible string; or if startoffset is -1, the

+ * very first such node in the tree.

+ *

+ * To iterate through all nodes matching the criterion, the following

+ * idiom can be used:

+ *	offset = fdt_node_offset_by_compatible(fdt, -1, compatible);

+ *	while (offset != -FDT_ERR_NOTFOUND) {

+ *		// other code here

+ *		offset = fdt_node_offset_by_compatible(fdt, offset, compatible);

+ *	}

+ *

+ * Note the -1 in the first call to the function, if 0 is used here

+ * instead, the function will never locate the root node, even if it

+ * matches the criterion.

+ *

+ * returns:

+ *	structure block offset of the located node (>= 0, >startoffset),

+ *		 on success

+ *	-FDT_ERR_NOTFOUND, no node matching the criterion exists in the

+ *		tree after startoffset

+ * 	-FDT_ERR_BADOFFSET, nodeoffset does not refer to a BEGIN_NODE tag

+ *	-FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE, standard meanings

+ */

+int fdt_node_offset_by_compatible(const void *fdt, int startoffset,

+				  const char *compatible);

+

+/**********************************************************************/

+/* Write-in-place functions                                           */

+/**********************************************************************/

+

+/**

+ * fdt_setprop_inplace - change a property's value, but not its size

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: offset of the node whose property to change

+ * @name: name of the property to change

+ * @val: pointer to data to replace the property value with

+ * @len: length of the property value

+ *

+ * fdt_setprop_inplace() replaces the value of a given property with

+ * the data in val, of length len.  This function cannot change the

+ * size of a property, and so will only work if len is equal to the

+ * current length of the property.

+ *

+ * This function will alter only the bytes in the blob which contain

+ * the given property value, and will not alter or move any other part

+ * of the tree.

+ *

+ * returns:

+ *	0, on success

+ *	-FDT_ERR_NOSPACE, if len is not equal to the property's current length

+ *	-FDT_ERR_NOTFOUND, node does not have the named property

+ *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag

+ *	-FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE,

+ *	-FDT_ERR_TRUNCATED, standard meanings

+ */

+int fdt_setprop_inplace(void *fdt, int nodeoffset, const char *name,

+			const void *val, int len);

+

+/**

+ * fdt_setprop_inplace_u32 - change the value of a 32-bit integer property

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: offset of the node whose property to change

+ * @name: name of the property to change

+ * @val: 32-bit integer value to replace the property with

+ *

+ * fdt_setprop_inplace_u32() replaces the value of a given property

+ * with the 32-bit integer value in val, converting val to big-endian

+ * if necessary.  This function cannot change the size of a property,

+ * and so will only work if the property already exists and has length

+ * 4.

+ *

+ * This function will alter only the bytes in the blob which contain

+ * the given property value, and will not alter or move any other part

+ * of the tree.

+ *

+ * returns:

+ *	0, on success

+ *	-FDT_ERR_NOSPACE, if the property's length is not equal to 4

+ *	-FDT_ERR_NOTFOUND, node does not have the named property

+ *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag

+ *	-FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE,

+ *	-FDT_ERR_TRUNCATED, standard meanings

+ */

+static inline int fdt_setprop_inplace_u32(void *fdt, int nodeoffset,

+					  const char *name, uint32_t val)

+{

+	val = cpu_to_fdt32(val);

+	return fdt_setprop_inplace(fdt, nodeoffset, name, &val, sizeof(val));

+}

+

+/**

+ * fdt_setprop_inplace_u64 - change the value of a 64-bit integer property

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: offset of the node whose property to change

+ * @name: name of the property to change

+ * @val: 64-bit integer value to replace the property with

+ *

+ * fdt_setprop_inplace_u64() replaces the value of a given property

+ * with the 64-bit integer value in val, converting val to big-endian

+ * if necessary.  This function cannot change the size of a property,

+ * and so will only work if the property already exists and has length

+ * 8.

+ *

+ * This function will alter only the bytes in the blob which contain

+ * the given property value, and will not alter or move any other part

+ * of the tree.

+ *

+ * returns:

+ *	0, on success

+ *	-FDT_ERR_NOSPACE, if the property's length is not equal to 8

+ *	-FDT_ERR_NOTFOUND, node does not have the named property

+ *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag

+ *	-FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE,

+ *	-FDT_ERR_TRUNCATED, standard meanings

+ */

+static inline int fdt_setprop_inplace_u64(void *fdt, int nodeoffset,

+					  const char *name, uint64_t val)

+{

+	val = cpu_to_fdt64(val);

+	return fdt_setprop_inplace(fdt, nodeoffset, name, &val, sizeof(val));

+}

+

+/**

+ * fdt_setprop_inplace_cell - change the value of a single-cell property

+ *

+ * This is an alternative name for fdt_setprop_inplace_u32()

+ */

+static inline int fdt_setprop_inplace_cell(void *fdt, int nodeoffset,

+					   const char *name, uint32_t val)

+{

+	return fdt_setprop_inplace_u32(fdt, nodeoffset, name, val);

+}

+

+/**

+ * fdt_nop_property - replace a property with nop tags

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: offset of the node whose property to nop

+ * @name: name of the property to nop

+ *

+ * fdt_nop_property() will replace a given property's representation

+ * in the blob with FDT_NOP tags, effectively removing it from the

+ * tree.

+ *

+ * This function will alter only the bytes in the blob which contain

+ * the property, and will not alter or move any other part of the

+ * tree.

+ *

+ * returns:

+ *	0, on success

+ *	-FDT_ERR_NOTFOUND, node does not have the named property

+ *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag

+ *	-FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE,

+ *	-FDT_ERR_TRUNCATED, standard meanings

+ */

+int fdt_nop_property(void *fdt, int nodeoffset, const char *name);

+

+/**

+ * fdt_nop_node - replace a node (subtree) with nop tags

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: offset of the node to nop

+ *

+ * fdt_nop_node() will replace a given node's representation in the

+ * blob, including all its subnodes, if any, with FDT_NOP tags,

+ * effectively removing it from the tree.

+ *

+ * This function will alter only the bytes in the blob which contain

+ * the node and its properties and subnodes, and will not alter or

+ * move any other part of the tree.

+ *

+ * returns:

+ *	0, on success

+ *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag

+ *	-FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE,

+ *	-FDT_ERR_TRUNCATED, standard meanings

+ */

+int fdt_nop_node(void *fdt, int nodeoffset);

+

+/**********************************************************************/

+/* Sequential write functions                                         */

+/**********************************************************************/

+

+int fdt_create(void *buf, int bufsize);

+int fdt_add_reservemap_entry(void *fdt, uint64_t addr, uint64_t size);

+int fdt_finish_reservemap(void *fdt);

+int fdt_begin_node(void *fdt, const char *name);

+int fdt_property(void *fdt, const char *name, const void *val, int len);

+static inline int fdt_property_u32(void *fdt, const char *name, uint32_t val)

+{

+	val = cpu_to_fdt32(val);

+	return fdt_property(fdt, name, &val, sizeof(val));

+}

+static inline int fdt_property_u64(void *fdt, const char *name, uint64_t val)

+{

+	val = cpu_to_fdt64(val);

+	return fdt_property(fdt, name, &val, sizeof(val));

+}

+static inline int fdt_property_cell(void *fdt, const char *name, uint32_t val)

+{

+	return fdt_property_u32(fdt, name, val);

+}

+#define fdt_property_string(fdt, name, str) \

+	fdt_property(fdt, name, str, strlen(str)+1)

+int fdt_end_node(void *fdt);

+int fdt_finish(void *fdt);

+

+/**********************************************************************/

+/* Read-write functions                                               */

+/**********************************************************************/

+

+int fdt_create_empty_tree(void *buf, int bufsize);

+int fdt_open_into(const void *fdt, void *buf, int bufsize);

+int fdt_pack(void *fdt);

+

+/**

+ * fdt_add_mem_rsv - add one memory reserve map entry

+ * @fdt: pointer to the device tree blob

+ * @address, @size: 64-bit values (native endian)

+ *

+ * Adds a reserve map entry to the given blob reserving a region at

+ * address address of length size.

+ *

+ * This function will insert data into the reserve map and will

+ * therefore change the indexes of some entries in the table.

+ *

+ * returns:

+ *	0, on success

+ *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to

+ *		contain the new reservation entry

+ *	-FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE,

+ *	-FDT_ERR_BADLAYOUT,

+ *	-FDT_ERR_TRUNCATED, standard meanings

+ */

+int fdt_add_mem_rsv(void *fdt, uint64_t address, uint64_t size);

+

+/**

+ * fdt_del_mem_rsv - remove a memory reserve map entry

+ * @fdt: pointer to the device tree blob

+ * @n: entry to remove

+ *

+ * fdt_del_mem_rsv() removes the n-th memory reserve map entry from

+ * the blob.

+ *

+ * This function will delete data from the reservation table and will

+ * therefore change the indexes of some entries in the table.

+ *

+ * returns:

+ *	0, on success

+ *	-FDT_ERR_NOTFOUND, there is no entry of the given index (i.e. there

+ *		are less than n+1 reserve map entries)

+ *	-FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE,

+ *	-FDT_ERR_BADLAYOUT,

+ *	-FDT_ERR_TRUNCATED, standard meanings

+ */

+int fdt_del_mem_rsv(void *fdt, int n);

+

+/**

+ * fdt_set_name - change the name of a given node

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: structure block offset of a node

+ * @name: name to give the node

+ *

+ * fdt_set_name() replaces the name (including unit address, if any)

+ * of the given node with the given string.  NOTE: this function can't

+ * efficiently check if the new name is unique amongst the given

+ * node's siblings; results are undefined if this function is invoked

+ * with a name equal to one of the given node's siblings.

+ *

+ * This function may insert or delete data from the blob, and will

+ * therefore change the offsets of some existing nodes.

+ *

+ * returns:

+ *	0, on success

+ *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob

+ *		to contain the new name

+ *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag

+ *	-FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE, standard meanings

+ */

+int fdt_set_name(void *fdt, int nodeoffset, const char *name);

+

+/**

+ * fdt_setprop - create or change a property

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: offset of the node whose property to change

+ * @name: name of the property to change

+ * @val: pointer to data to set the property value to

+ * @len: length of the property value

+ *

+ * fdt_setprop() sets the value of the named property in the given

+ * node to the given value and length, creating the property if it

+ * does not already exist.

+ *

+ * This function may insert or delete data from the blob, and will

+ * therefore change the offsets of some existing nodes.

+ *

+ * returns:

+ *	0, on success

+ *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to

+ *		contain the new property value

+ *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag

+ *	-FDT_ERR_BADLAYOUT,

+ *	-FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE,

+ *	-FDT_ERR_BADLAYOUT,

+ *	-FDT_ERR_TRUNCATED, standard meanings

+ */

+int fdt_setprop(void *fdt, int nodeoffset, const char *name,

+		const void *val, int len);

+

+/**

+ * fdt_setprop_u32 - set a property to a 32-bit integer

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: offset of the node whose property to change

+ * @name: name of the property to change

+ * @val: 32-bit integer value for the property (native endian)

+ *

+ * fdt_setprop_u32() sets the value of the named property in the given

+ * node to the given 32-bit integer value (converting to big-endian if

+ * necessary), or creates a new property with that value if it does

+ * not already exist.

+ *

+ * This function may insert or delete data from the blob, and will

+ * therefore change the offsets of some existing nodes.

+ *

+ * returns:

+ *	0, on success

+ *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to

+ *		contain the new property value

+ *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag

+ *	-FDT_ERR_BADLAYOUT,

+ *	-FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE,

+ *	-FDT_ERR_BADLAYOUT,

+ *	-FDT_ERR_TRUNCATED, standard meanings

+ */

+static inline int fdt_setprop_u32(void *fdt, int nodeoffset, const char *name,

+				  uint32_t val)

+{

+	val = cpu_to_fdt32(val);

+	return fdt_setprop(fdt, nodeoffset, name, &val, sizeof(val));

+}

+

+/**

+ * fdt_setprop_u64 - set a property to a 64-bit integer

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: offset of the node whose property to change

+ * @name: name of the property to change

+ * @val: 64-bit integer value for the property (native endian)

+ *

+ * fdt_setprop_u64() sets the value of the named property in the given

+ * node to the given 64-bit integer value (converting to big-endian if

+ * necessary), or creates a new property with that value if it does

+ * not already exist.

+ *

+ * This function may insert or delete data from the blob, and will

+ * therefore change the offsets of some existing nodes.

+ *

+ * returns:

+ *	0, on success

+ *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to

+ *		contain the new property value

+ *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag

+ *	-FDT_ERR_BADLAYOUT,

+ *	-FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE,

+ *	-FDT_ERR_BADLAYOUT,

+ *	-FDT_ERR_TRUNCATED, standard meanings

+ */

+static inline int fdt_setprop_u64(void *fdt, int nodeoffset, const char *name,

+				  uint64_t val)

+{

+	val = cpu_to_fdt64(val);

+	return fdt_setprop(fdt, nodeoffset, name, &val, sizeof(val));

+}

+

+/**

+ * fdt_setprop_cell - set a property to a single cell value

+ *

+ * This is an alternative name for fdt_setprop_u32()

+ */

+static inline int fdt_setprop_cell(void *fdt, int nodeoffset, const char *name,

+				   uint32_t val)

+{

+	return fdt_setprop_u32(fdt, nodeoffset, name, val);

+}

+

+/**

+ * fdt_setprop_string - set a property to a string value

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: offset of the node whose property to change

+ * @name: name of the property to change

+ * @str: string value for the property

+ *

+ * fdt_setprop_string() sets the value of the named property in the

+ * given node to the given string value (using the length of the

+ * string to determine the new length of the property), or creates a

+ * new property with that value if it does not already exist.

+ *

+ * This function may insert or delete data from the blob, and will

+ * therefore change the offsets of some existing nodes.

+ *

+ * returns:

+ *	0, on success

+ *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to

+ *		contain the new property value

+ *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag

+ *	-FDT_ERR_BADLAYOUT,

+ *	-FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE,

+ *	-FDT_ERR_BADLAYOUT,

+ *	-FDT_ERR_TRUNCATED, standard meanings

+ */

+#define fdt_setprop_string(fdt, nodeoffset, name, str) \

+	fdt_setprop((fdt), (nodeoffset), (name), (str), strlen(str)+1)

+

+/**

+ * fdt_appendprop - append to or create a property

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: offset of the node whose property to change

+ * @name: name of the property to append to

+ * @val: pointer to data to append to the property value

+ * @len: length of the data to append to the property value

+ *

+ * fdt_appendprop() appends the value to the named property in the

+ * given node, creating the property if it does not already exist.

+ *

+ * This function may insert data into the blob, and will therefore

+ * change the offsets of some existing nodes.

+ *

+ * returns:

+ *	0, on success

+ *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to

+ *		contain the new property value

+ *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag

+ *	-FDT_ERR_BADLAYOUT,

+ *	-FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE,

+ *	-FDT_ERR_BADLAYOUT,

+ *	-FDT_ERR_TRUNCATED, standard meanings

+ */

+int fdt_appendprop(void *fdt, int nodeoffset, const char *name,

+		   const void *val, int len);

+

+/**

+ * fdt_appendprop_u32 - append a 32-bit integer value to a property

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: offset of the node whose property to change

+ * @name: name of the property to change

+ * @val: 32-bit integer value to append to the property (native endian)

+ *

+ * fdt_appendprop_u32() appends the given 32-bit integer value

+ * (converting to big-endian if necessary) to the value of the named

+ * property in the given node, or creates a new property with that

+ * value if it does not already exist.

+ *

+ * This function may insert data into the blob, and will therefore

+ * change the offsets of some existing nodes.

+ *

+ * returns:

+ *	0, on success

+ *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to

+ *		contain the new property value

+ *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag

+ *	-FDT_ERR_BADLAYOUT,

+ *	-FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE,

+ *	-FDT_ERR_BADLAYOUT,

+ *	-FDT_ERR_TRUNCATED, standard meanings

+ */

+static inline int fdt_appendprop_u32(void *fdt, int nodeoffset,

+				     const char *name, uint32_t val)

+{

+	val = cpu_to_fdt32(val);

+	return fdt_appendprop(fdt, nodeoffset, name, &val, sizeof(val));

+}

+

+/**

+ * fdt_appendprop_u64 - append a 64-bit integer value to a property

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: offset of the node whose property to change

+ * @name: name of the property to change

+ * @val: 64-bit integer value to append to the property (native endian)

+ *

+ * fdt_appendprop_u64() appends the given 64-bit integer value

+ * (converting to big-endian if necessary) to the value of the named

+ * property in the given node, or creates a new property with that

+ * value if it does not already exist.

+ *

+ * This function may insert data into the blob, and will therefore

+ * change the offsets of some existing nodes.

+ *

+ * returns:

+ *	0, on success

+ *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to

+ *		contain the new property value

+ *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag

+ *	-FDT_ERR_BADLAYOUT,

+ *	-FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE,

+ *	-FDT_ERR_BADLAYOUT,

+ *	-FDT_ERR_TRUNCATED, standard meanings

+ */

+static inline int fdt_appendprop_u64(void *fdt, int nodeoffset,

+				     const char *name, uint64_t val)

+{

+	val = cpu_to_fdt64(val);

+	return fdt_appendprop(fdt, nodeoffset, name, &val, sizeof(val));

+}

+

+/**

+ * fdt_appendprop_cell - append a single cell value to a property

+ *

+ * This is an alternative name for fdt_appendprop_u32()

+ */

+static inline int fdt_appendprop_cell(void *fdt, int nodeoffset,

+				      const char *name, uint32_t val)

+{

+	return fdt_appendprop_u32(fdt, nodeoffset, name, val);

+}

+

+/**

+ * fdt_appendprop_string - append a string to a property

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: offset of the node whose property to change

+ * @name: name of the property to change

+ * @str: string value to append to the property

+ *

+ * fdt_appendprop_string() appends the given string to the value of

+ * the named property in the given node, or creates a new property

+ * with that value if it does not already exist.

+ *

+ * This function may insert data into the blob, and will therefore

+ * change the offsets of some existing nodes.

+ *

+ * returns:

+ *	0, on success

+ *	-FDT_ERR_NOSPACE, there is insufficient free space in the blob to

+ *		contain the new property value

+ *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag

+ *	-FDT_ERR_BADLAYOUT,

+ *	-FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE,

+ *	-FDT_ERR_BADLAYOUT,

+ *	-FDT_ERR_TRUNCATED, standard meanings

+ */

+#define fdt_appendprop_string(fdt, nodeoffset, name, str) \

+	fdt_appendprop((fdt), (nodeoffset), (name), (str), strlen(str)+1)

+

+/**

+ * fdt_delprop - delete a property

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: offset of the node whose property to nop

+ * @name: name of the property to nop

+ *

+ * fdt_del_property() will delete the given property.

+ *

+ * This function will delete data from the blob, and will therefore

+ * change the offsets of some existing nodes.

+ *

+ * returns:

+ *	0, on success

+ *	-FDT_ERR_NOTFOUND, node does not have the named property

+ *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag

+ *	-FDT_ERR_BADLAYOUT,

+ *	-FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE,

+ *	-FDT_ERR_TRUNCATED, standard meanings

+ */

+int fdt_delprop(void *fdt, int nodeoffset, const char *name);

+

+/**

+ * fdt_add_subnode_namelen - creates a new node based on substring

+ * @fdt: pointer to the device tree blob

+ * @parentoffset: structure block offset of a node

+ * @name: name of the subnode to locate

+ * @namelen: number of characters of name to consider

+ *

+ * Identical to fdt_add_subnode(), but use only the first namelen

+ * characters of name as the name of the new node.  This is useful for

+ * creating subnodes based on a portion of a larger string, such as a

+ * full path.

+ */

+int fdt_add_subnode_namelen(void *fdt, int parentoffset,

+			    const char *name, int namelen);

+

+/**

+ * fdt_add_subnode - creates a new node

+ * @fdt: pointer to the device tree blob

+ * @parentoffset: structure block offset of a node

+ * @name: name of the subnode to locate

+ *

+ * fdt_add_subnode() creates a new node as a subnode of the node at

+ * structure block offset parentoffset, with the given name (which

+ * should include the unit address, if any).

+ *

+ * This function will insert data into the blob, and will therefore

+ * change the offsets of some existing nodes.

+

+ * returns:

+ *	structure block offset of the created nodeequested subnode (>=0), on success

+ *	-FDT_ERR_NOTFOUND, if the requested subnode does not exist

+ *	-FDT_ERR_BADOFFSET, if parentoffset did not point to an FDT_BEGIN_NODE tag

+ *	-FDT_ERR_EXISTS, if the node at parentoffset already has a subnode of

+ *		the given name

+ *	-FDT_ERR_NOSPACE, if there is insufficient free space in the

+ *		blob to contain the new node

+ *	-FDT_ERR_NOSPACE

+ *	-FDT_ERR_BADLAYOUT

+ *      -FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE,

+ *	-FDT_ERR_TRUNCATED, standard meanings.

+ */

+int fdt_add_subnode(void *fdt, int parentoffset, const char *name);

+

+/**

+ * fdt_del_node - delete a node (subtree)

+ * @fdt: pointer to the device tree blob

+ * @nodeoffset: offset of the node to nop

+ *

+ * fdt_del_node() will remove the given node, including all its

+ * subnodes if any, from the blob.

+ *

+ * This function will delete data from the blob, and will therefore

+ * change the offsets of some existing nodes.

+ *

+ * returns:

+ *	0, on success

+ *	-FDT_ERR_BADOFFSET, nodeoffset did not point to FDT_BEGIN_NODE tag

+ *	-FDT_ERR_BADLAYOUT,

+ *	-FDT_ERR_BADMAGIC,

+ *	-FDT_ERR_BADVERSION,

+ *	-FDT_ERR_BADSTATE,

+ *	-FDT_ERR_BADSTRUCTURE,

+ *	-FDT_ERR_TRUNCATED, standard meanings

+ */

+int fdt_del_node(void *fdt, int nodeoffset);

+

+/**********************************************************************/

+/* Debugging / informational functions                                */

+/**********************************************************************/

+

+const char *fdt_strerror(int errval);

+

+#endif /* _LIBFDT_H */

diff --git a/EmbeddedPkg/Include/libfdt_env.h b/EmbeddedPkg/Include/libfdt_env.h
index d35b8692..6cc311fe 100644
--- a/EmbeddedPkg/Include/libfdt_env.h
+++ b/EmbeddedPkg/Include/libfdt_env.h
@@ -1,77 +1,77 @@
-/** @file
-*
-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-#ifndef _LIBFDT_ENV_H
-#define _LIBFDT_ENV_H
-
-#include <Library/BaseLib.h>
-#include <Library/BaseMemoryLib.h>
-
-typedef UINT8 uint8_t;
-typedef UINT16 uint16_t;
-typedef UINT32 uint32_t;
-typedef UINT64 uint64_t;
-typedef UINTN uintptr_t;
-typedef UINTN size_t;
-
-static inline uint16_t fdt16_to_cpu(uint16_t x)
-{
-  return SwapBytes16 (x);
-}
-#define cpu_to_fdt16(x) fdt16_to_cpu(x)
-
-static inline uint32_t fdt32_to_cpu(uint32_t x)
-{
-  return SwapBytes32 (x);
-}
-#define cpu_to_fdt32(x) fdt32_to_cpu(x)
-
-static inline uint64_t fdt64_to_cpu(uint64_t x)
-{
-  return SwapBytes64 (x);
-}
-#define cpu_to_fdt64(x) fdt64_to_cpu(x)
-
-static inline void* memcpy(void* dest, const void* src, size_t len) {
-  return CopyMem (dest, src, len);
-}
-
-static inline void *memmove(void *dest, const void *src, size_t n) {
-  return CopyMem (dest, src, n);
-}
-
-static inline void *memset(void *s, int c, size_t n) {
-  return SetMem (s, n, c);
-}
-
-static inline int memcmp(const void* dest, const void* src, int len) {
-  return CompareMem (dest, src, len);
-}
-
-static inline void *memchr(const void *s, int c, size_t n) {
-  return ScanMem8 (s, n, c);
-}
-
-static inline size_t strlen (const char* str) {
-  return AsciiStrLen (str);
-}
-
-static inline char *strchr(const char *s, int c) {
-  char pattern[2];
-  pattern[0] = c;
-  pattern[1] = 0;
-  return AsciiStrStr (s, pattern);
-}
-
-#endif /* _LIBFDT_ENV_H */
+/** @file

+*

+*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+#ifndef _LIBFDT_ENV_H

+#define _LIBFDT_ENV_H

+

+#include <Library/BaseLib.h>

+#include <Library/BaseMemoryLib.h>

+

+typedef UINT8 uint8_t;

+typedef UINT16 uint16_t;

+typedef UINT32 uint32_t;

+typedef UINT64 uint64_t;

+typedef UINTN uintptr_t;

+typedef UINTN size_t;

+

+static inline uint16_t fdt16_to_cpu(uint16_t x)

+{

+  return SwapBytes16 (x);

+}

+#define cpu_to_fdt16(x) fdt16_to_cpu(x)

+

+static inline uint32_t fdt32_to_cpu(uint32_t x)

+{

+  return SwapBytes32 (x);

+}

+#define cpu_to_fdt32(x) fdt32_to_cpu(x)

+

+static inline uint64_t fdt64_to_cpu(uint64_t x)

+{

+  return SwapBytes64 (x);

+}

+#define cpu_to_fdt64(x) fdt64_to_cpu(x)

+

+static inline void* memcpy(void* dest, const void* src, size_t len) {

+  return CopyMem (dest, src, len);

+}

+

+static inline void *memmove(void *dest, const void *src, size_t n) {

+  return CopyMem (dest, src, n);

+}

+

+static inline void *memset(void *s, int c, size_t n) {

+  return SetMem (s, n, c);

+}

+

+static inline int memcmp(const void* dest, const void* src, int len) {

+  return CompareMem (dest, src, len);

+}

+

+static inline void *memchr(const void *s, int c, size_t n) {

+  return ScanMem8 (s, n, c);

+}

+

+static inline size_t strlen (const char* str) {

+  return AsciiStrLen (str);

+}

+

+static inline char *strchr(const char *s, int c) {

+  char pattern[2];

+  pattern[0] = c;

+  pattern[1] = 0;

+  return AsciiStrStr (s, pattern);

+}

+

+#endif /* _LIBFDT_ENV_H */

diff --git a/EmbeddedPkg/Library/DebugAgentTimerLibNull/DebugAgentTimerLib.c b/EmbeddedPkg/Library/DebugAgentTimerLibNull/DebugAgentTimerLib.c
index 7ee5609c..7fab09ba 100755
--- a/EmbeddedPkg/Library/DebugAgentTimerLibNull/DebugAgentTimerLib.c
+++ b/EmbeddedPkg/Library/DebugAgentTimerLibNull/DebugAgentTimerLib.c
@@ -61,4 +61,4 @@ DebugAgentTimerEndOfInterrupt (
 {

 }

   

-  
\ No newline at end of file
+  
\ No newline at end of file
diff --git a/EmbeddedPkg/Library/EblAddExternalCommandLib/EblAddExternalCommandLib.inf b/EmbeddedPkg/Library/EblAddExternalCommandLib/EblAddExternalCommandLib.inf
index 1429c37f..03258751 100644
--- a/EmbeddedPkg/Library/EblAddExternalCommandLib/EblAddExternalCommandLib.inf
+++ b/EmbeddedPkg/Library/EblAddExternalCommandLib/EblAddExternalCommandLib.inf
@@ -45,4 +45,4 @@
   gEfiEblAddCommandProtocolGuid

   

 [Guids]

- 
\ No newline at end of file
+ 
\ No newline at end of file
diff --git a/EmbeddedPkg/Library/EblCmdLibNull/EblCmdLibNull.inf b/EmbeddedPkg/Library/EblCmdLibNull/EblCmdLibNull.inf
index 3fd8e92d..52e34399 100644
--- a/EmbeddedPkg/Library/EblCmdLibNull/EblCmdLibNull.inf
+++ b/EmbeddedPkg/Library/EblCmdLibNull/EblCmdLibNull.inf
@@ -41,4 +41,4 @@
 [Protocols]

   

 [Guids]

- 
\ No newline at end of file
+ 
\ No newline at end of file
diff --git a/EmbeddedPkg/Library/EblNetworkLib/EblNetworkLib.c b/EmbeddedPkg/Library/EblNetworkLib/EblNetworkLib.c
index 0edd5d01..3b0f6a1c 100644
--- a/EmbeddedPkg/Library/EblNetworkLib/EblNetworkLib.c
+++ b/EmbeddedPkg/Library/EblNetworkLib/EblNetworkLib.c
@@ -1,173 +1,173 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include <Uefi.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/DebugLib.h>
-#include <Library/UefiRuntimeServicesTableLib.h>
-#include <Library/UefiBootServicesTableLib.h>
-
-#include <Protocol/SimpleNetwork.h>
-#include <Protocol/PxeBaseCode.h>
-
-
-BOOLEAN   gUseIpv6 = FALSE;
-
-EFI_STATUS
-EFIAPI
-EblGetCurrentIpAddress (
-  IN OUT   EFI_IP_ADDRESS *Ip
-  )
-{
-  EFI_STATUS                  Status;
-  EFI_PXE_BASE_CODE_PROTOCOL  *Pxe;
-  
-  Status = gBS->LocateProtocol (&gEfiPxeBaseCodeProtocolGuid, NULL, (VOID **)&Pxe);
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  Status = Pxe->Start (Pxe, gUseIpv6);
-  if (EFI_ERROR(Status) && (Status != EFI_ALREADY_STARTED)) {
-    return Status;
-  }
-
-  CopyMem (Ip, &Pxe->Mode->StationIp, sizeof (EFI_IP_ADDRESS));
-
-  return EFI_SUCCESS;
-}
-
-
-EFI_STATUS
-EFIAPI
-EblGetCurrentMacAddress (
-  IN OUT  EFI_MAC_ADDRESS *Mac
-  )
-{
-  EFI_STATUS                    Status;
-  EFI_SIMPLE_NETWORK_PROTOCOL   *SimpleNet;
-
-  Status = gBS->LocateProtocol (&gEfiSimpleNetworkProtocolGuid, NULL, (VOID **)&SimpleNet);
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  CopyMem (Mac, SimpleNet->Mode->CurrentAddress.Addr, sizeof (EFI_MAC_ADDRESS));
-  return Status;
-}
-
-
-CHAR8 *
-EFIAPI
-EblLoadFileBootTypeString (
-  IN  EFI_HANDLE Handle
-  )
-{
-  EFI_STATUS    Status;
-  VOID          *NullPtr;
-  
-  Status = gBS->HandleProtocol (Handle, &gEfiPxeBaseCodeProtocolGuid, &NullPtr);
-  if (!EFI_ERROR (Status)) {
-    return "EFI PXE Network Boot";
-  }
-  
-  return ""; 
-}
-
-EFI_STATUS
-EFIAPI
-EblPerformDHCP (
-  IN  BOOLEAN  SortOffers
-  )
-{
-  EFI_STATUS                  Status;
-  EFI_PXE_BASE_CODE_PROTOCOL  *Pxe;
-  
-  Status = gBS->LocateProtocol (&gEfiPxeBaseCodeProtocolGuid, NULL, (VOID **)&Pxe);
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  Status = Pxe->Start (Pxe, gUseIpv6);
-  if (EFI_ERROR(Status) && (Status != EFI_ALREADY_STARTED)) {
-    return Status;
-  }
-
-  Status = Pxe->Dhcp(Pxe, TRUE);
-  return Status;
-}
-
-
-EFI_STATUS
-EFIAPI
-EblSetStationIp (
-  IN EFI_IP_ADDRESS *NewStationIp,  OPTIONAL
-  IN EFI_IP_ADDRESS *NewSubnetMask  OPTIONAL
-  )
-{
-  EFI_STATUS                  Status;
-  EFI_PXE_BASE_CODE_PROTOCOL  *Pxe;
-  
-  Status = gBS->LocateProtocol (&gEfiPxeBaseCodeProtocolGuid, NULL, (VOID **)&Pxe);
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  Status = Pxe->Start (Pxe, gUseIpv6);
-  if (EFI_ERROR(Status) && (Status != EFI_ALREADY_STARTED)) {
-    return Status;
-  }
-     
-  Status = Pxe->SetStationIp (Pxe, NewStationIp, NewSubnetMask);
-  return Status;
-}
-
-  
-EFI_STATUS
-EFIAPI
-EblMtftp (
-  IN EFI_PXE_BASE_CODE_TFTP_OPCODE             Operation,
-  IN OUT VOID                                  *BufferPtr OPTIONAL,
-  IN BOOLEAN                                   Overwrite,
-  IN OUT UINT64                                *BufferSize,
-  IN UINTN                                     *BlockSize OPTIONAL,
-  IN EFI_IP_ADDRESS                            *ServerIp,
-  IN UINT8                                     *Filename  OPTIONAL,
-  IN EFI_PXE_BASE_CODE_MTFTP_INFO              *Info      OPTIONAL,
-  IN BOOLEAN                                   DontUseBuffer
-  )
-{
-  EFI_STATUS                  Status;
-  EFI_PXE_BASE_CODE_PROTOCOL  *Pxe;
-  
-  Status = gBS->LocateProtocol (&gEfiPxeBaseCodeProtocolGuid, NULL, (VOID **)&Pxe);
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-  
-  Status = Pxe->Mtftp (
-                  Pxe,
-                  Operation,
-                  BufferPtr,
-                  Overwrite,
-                  BufferSize,
-                  BlockSize,
-                  ServerIp,
-                  Filename,
-                  Info,
-                  DontUseBuffer
-                  );
-  return Status;
-}
-  
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include <Uefi.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/DebugLib.h>

+#include <Library/UefiRuntimeServicesTableLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+

+#include <Protocol/SimpleNetwork.h>

+#include <Protocol/PxeBaseCode.h>

+

+

+BOOLEAN   gUseIpv6 = FALSE;

+

+EFI_STATUS

+EFIAPI

+EblGetCurrentIpAddress (

+  IN OUT   EFI_IP_ADDRESS *Ip

+  )

+{

+  EFI_STATUS                  Status;

+  EFI_PXE_BASE_CODE_PROTOCOL  *Pxe;

+  

+  Status = gBS->LocateProtocol (&gEfiPxeBaseCodeProtocolGuid, NULL, (VOID **)&Pxe);

+  if (EFI_ERROR(Status)) {

+    return Status;

+  }

+

+  Status = Pxe->Start (Pxe, gUseIpv6);

+  if (EFI_ERROR(Status) && (Status != EFI_ALREADY_STARTED)) {

+    return Status;

+  }

+

+  CopyMem (Ip, &Pxe->Mode->StationIp, sizeof (EFI_IP_ADDRESS));

+

+  return EFI_SUCCESS;

+}

+

+

+EFI_STATUS

+EFIAPI

+EblGetCurrentMacAddress (

+  IN OUT  EFI_MAC_ADDRESS *Mac

+  )

+{

+  EFI_STATUS                    Status;

+  EFI_SIMPLE_NETWORK_PROTOCOL   *SimpleNet;

+

+  Status = gBS->LocateProtocol (&gEfiSimpleNetworkProtocolGuid, NULL, (VOID **)&SimpleNet);

+  if (EFI_ERROR(Status)) {

+    return Status;

+  }

+

+  CopyMem (Mac, SimpleNet->Mode->CurrentAddress.Addr, sizeof (EFI_MAC_ADDRESS));

+  return Status;

+}

+

+

+CHAR8 *

+EFIAPI

+EblLoadFileBootTypeString (

+  IN  EFI_HANDLE Handle

+  )

+{

+  EFI_STATUS    Status;

+  VOID          *NullPtr;

+  

+  Status = gBS->HandleProtocol (Handle, &gEfiPxeBaseCodeProtocolGuid, &NullPtr);

+  if (!EFI_ERROR (Status)) {

+    return "EFI PXE Network Boot";

+  }

+  

+  return ""; 

+}

+

+EFI_STATUS

+EFIAPI

+EblPerformDHCP (

+  IN  BOOLEAN  SortOffers

+  )

+{

+  EFI_STATUS                  Status;

+  EFI_PXE_BASE_CODE_PROTOCOL  *Pxe;

+  

+  Status = gBS->LocateProtocol (&gEfiPxeBaseCodeProtocolGuid, NULL, (VOID **)&Pxe);

+  if (EFI_ERROR(Status)) {

+    return Status;

+  }

+

+  Status = Pxe->Start (Pxe, gUseIpv6);

+  if (EFI_ERROR(Status) && (Status != EFI_ALREADY_STARTED)) {

+    return Status;

+  }

+

+  Status = Pxe->Dhcp(Pxe, TRUE);

+  return Status;

+}

+

+

+EFI_STATUS

+EFIAPI

+EblSetStationIp (

+  IN EFI_IP_ADDRESS *NewStationIp,  OPTIONAL

+  IN EFI_IP_ADDRESS *NewSubnetMask  OPTIONAL

+  )

+{

+  EFI_STATUS                  Status;

+  EFI_PXE_BASE_CODE_PROTOCOL  *Pxe;

+  

+  Status = gBS->LocateProtocol (&gEfiPxeBaseCodeProtocolGuid, NULL, (VOID **)&Pxe);

+  if (EFI_ERROR(Status)) {

+    return Status;

+  }

+

+  Status = Pxe->Start (Pxe, gUseIpv6);

+  if (EFI_ERROR(Status) && (Status != EFI_ALREADY_STARTED)) {

+    return Status;

+  }

+     

+  Status = Pxe->SetStationIp (Pxe, NewStationIp, NewSubnetMask);

+  return Status;

+}

+

+  

+EFI_STATUS

+EFIAPI

+EblMtftp (

+  IN EFI_PXE_BASE_CODE_TFTP_OPCODE             Operation,

+  IN OUT VOID                                  *BufferPtr OPTIONAL,

+  IN BOOLEAN                                   Overwrite,

+  IN OUT UINT64                                *BufferSize,

+  IN UINTN                                     *BlockSize OPTIONAL,

+  IN EFI_IP_ADDRESS                            *ServerIp,

+  IN UINT8                                     *Filename  OPTIONAL,

+  IN EFI_PXE_BASE_CODE_MTFTP_INFO              *Info      OPTIONAL,

+  IN BOOLEAN                                   DontUseBuffer

+  )

+{

+  EFI_STATUS                  Status;

+  EFI_PXE_BASE_CODE_PROTOCOL  *Pxe;

+  

+  Status = gBS->LocateProtocol (&gEfiPxeBaseCodeProtocolGuid, NULL, (VOID **)&Pxe);

+  if (EFI_ERROR(Status)) {

+    return Status;

+  }

+  

+  Status = Pxe->Mtftp (

+                  Pxe,

+                  Operation,

+                  BufferPtr,

+                  Overwrite,

+                  BufferSize,

+                  BlockSize,

+                  ServerIp,

+                  Filename,

+                  Info,

+                  DontUseBuffer

+                  );

+  return Status;

+}

+  

diff --git a/EmbeddedPkg/Library/EblNetworkLib/EblNetworkLib.inf b/EmbeddedPkg/Library/EblNetworkLib/EblNetworkLib.inf
index b0d6e80a..4d66bacb 100644
--- a/EmbeddedPkg/Library/EblNetworkLib/EblNetworkLib.inf
+++ b/EmbeddedPkg/Library/EblNetworkLib/EblNetworkLib.inf
@@ -31,4 +31,4 @@
   gEfiPxeBaseCodeProtocolGuid

 

 [Depex]

-  TRUE
\ No newline at end of file
+  TRUE
\ No newline at end of file
diff --git a/EmbeddedPkg/Library/EfiFileLib/EfiFileLib.c b/EmbeddedPkg/Library/EfiFileLib/EfiFileLib.c
index 5e0f9ca1..83a3b784 100644
--- a/EmbeddedPkg/Library/EfiFileLib/EfiFileLib.c
+++ b/EmbeddedPkg/Library/EfiFileLib/EfiFileLib.c
@@ -1,1778 +1,1778 @@
-/** @file
-File IO routines inspired by Streams with an EFI flavor
-
-Copyright (c) 2007, Intel Corporation. All rights reserved.<BR>
-Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-This program and the accompanying materials
-are licensed and made available under the terms and conditions of the BSD License
-which accompanies this distribution.  The full text of the license may be found at
-http://opensource.org/licenses/bsd-license.php
-
-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-Basic support for opening files on different device types. The device string
-is in the form of DevType:Path. Current DevType is required as there is no
-current mounted device concept of current working directory concept implement
-by this library.
-
-Device names are case insensitive and only check the leading characters for
-unique matches. Thus the following are all the same:
-LoadFile0:
-l0:
-L0:
-Lo0:
-
-Supported Device Names:
-A0x1234:0x12 - A memory buffer starting at address 0x1234 for 0x12 bytes
-l1:          - EFI LoadFile device one.
-B0:          - EFI BlockIo zero.
-fs3:         - EFI Simple File System device 3
-Fv2:         - EFI Firmware VOlume device 2
-10.0.1.102:  - TFTP service IP followed by the file name
-**/
-
-#include <PiDxe.h>
-#include <Protocol/BlockIo.h>             
-#include <Protocol/DiskIo.h>             
-#include <Protocol/SimpleFileSystem.h>      
-#include <Protocol/FirmwareVolume2.h>        
-#include <Protocol/LoadFile.h>
-#include <Protocol/FirmwareVolumeBlock.h>  
-#include <Guid/FileInfo.h>
-#include <Library/BaseLib.h>
-#include <Library/MemoryAllocationLib.h>
-#include <Library/DevicePathLib.h>
-#include <Library/PrintLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/UefiLib.h>   
-#include <Library/UefiBootServicesTableLib.h>
-#include <Library/UefiRuntimeServicesTableLib.h>
-#include <Library/DebugLib.h>
-#include <Library/EfiFileLib.h>
-#include <Library/PcdLib.h>
-#include <Library/EblNetworkLib.h>
-
-
-CHAR8 *gCwd = NULL;
-
-CONST EFI_GUID gZeroGuid  = { 0, 0, 0, { 0, 0, 0, 0, 0, 0, 0, 0 } };
-
-#define EFI_OPEN_FILE_GUARD_HEADER  0x4B4D4641
-#define EFI_OPEN_FILE_GUARD_FOOTER  0x444D5A56
-
-// Need to defend against this overflowing
-#define MAX_CMD_LINE  0x200
-
-typedef struct {
-  UINT32            Header;
-  EFI_OPEN_FILE     File;
-  UINT32            Footer;
-} EFI_OPEN_FILE_GUARD;
-
-
-// globals to store current open device info
-EFI_HANDLE            *mBlkIo = NULL;
-UINTN                 mBlkIoCount = 0;
-
-EFI_HANDLE            *mFs = NULL;
-UINTN                 mFsCount = 0;
-// mFsInfo[] array entries must match mFs[] handles
-EFI_FILE_SYSTEM_INFO  **mFsInfo = NULL;
-
-EFI_HANDLE            *mFv = NULL;
-UINTN                 mFvCount = 0;
-EFI_HANDLE            *mLoadFile = NULL;
-UINTN                 mLoadFileCount = 0;
-
-
-
-/**
-Internal worker function to validate a File handle.
-
-@param  File    Open File Handle
-
-@return TRUE    File is valid
-@return FALSE   File is not valid
-
-
-**/
-BOOLEAN
-FileHandleValid (
-  IN EFI_OPEN_FILE  *File
-  )
-{
-  EFI_OPEN_FILE_GUARD  *GuardFile;
-
-  // Look right before and after file structure for the correct signatures
-  GuardFile = BASE_CR (File, EFI_OPEN_FILE_GUARD, File);
-  if ((GuardFile->Header != EFI_OPEN_FILE_GUARD_HEADER) ||
-    (GuardFile->Footer != EFI_OPEN_FILE_GUARD_FOOTER) ) {
-      return FALSE;
-    }
-
-    return TRUE;
-}
-
-/**
-Internal worker function. If Buffer is not NULL free it.
-
-@param  Buffer    Buffer to FreePool()
-
-**/
-VOID
-EblFreePool (
-  IN  VOID  *Buffer
-  )
-{
-  if (Buffer != NULL) {
-    FreePool (Buffer);
-  }
-}
-
-/**
-Update Device List Global Variables
-
-**/
-VOID
-EblUpdateDeviceLists (
-  VOID
-  )
-{
-  EFI_STATUS                        Status;
-  UINTN                             Size;
-  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL   *Fs;
-  EFI_FILE_HANDLE                   Root;
-  UINTN                             Index;
-
-  if (mBlkIo != NULL) {
-    FreePool (mBlkIo);
-  }
-  gBS->LocateHandleBuffer (ByProtocol, &gEfiBlockIoProtocolGuid, NULL, &mBlkIoCount, &mBlkIo);
-
-
-
-  if (mFv != NULL) {
-    FreePool (mFv);
-  }
-  gBS->LocateHandleBuffer (ByProtocol, &gEfiFirmwareVolume2ProtocolGuid, NULL, &mFvCount, &mFv);
-
-  if (mLoadFile != NULL) {
-    FreePool (mLoadFile);
-  }
-  gBS->LocateHandleBuffer (ByProtocol, &gEfiLoadFileProtocolGuid, NULL, &mLoadFileCount, &mLoadFile);
-
-  if (mFs != NULL) {
-    FreePool (mFs);
-  }
-
-  if (&mFsInfo[0] != NULL) {
-    // Need to Free the mFsInfo prior to recalculating mFsCount so don't move this code
-    for (Index = 0; Index < mFsCount; Index++) {
-      if (mFsInfo[Index] != NULL) {
-        FreePool (mFsInfo[Index]);
-      }
-    }
-    FreePool (mFsInfo);
-  }
-
-  gBS->LocateHandleBuffer (ByProtocol, &gEfiSimpleFileSystemProtocolGuid, NULL, &mFsCount, &mFs);
-
-
-  mFsInfo = AllocateZeroPool (mFsCount * sizeof (EFI_FILE_SYSTEM_INFO *));
-  if (mFsInfo == NULL) {
-    // If we can't do this then we can't support file system entries
-    mFsCount = 0;
-  } else {
-    // Loop through all the file system structures and cache the file system info data
-    for (Index =0; Index < mFsCount; Index++) {
-      Status = gBS->HandleProtocol (mFs[Index], &gEfiSimpleFileSystemProtocolGuid, (VOID **)&Fs);
-      if (!EFI_ERROR (Status)) {
-        Status = Fs->OpenVolume (Fs, &Root);
-        if (!EFI_ERROR (Status)) {
-          // Get information about the volume
-          Size = 0;
-          Status = Root->GetInfo (Root, &gEfiFileSystemInfoGuid, &Size, mFsInfo[Index]);
-          if (Status == EFI_BUFFER_TOO_SMALL) {
-            mFsInfo[Index] = AllocatePool (Size);
-            Status = Root->GetInfo (Root, &gEfiFileSystemInfoGuid, &Size, mFsInfo[Index]);
-          }
-
-          Root->Close (Root);
-        }
-      }
-    }
-  }
-}
-
-
-/**
-PathName is in the form <device name>:<path> for example fs1:\ or ROOT:\.
-Return TRUE if the <devce name> prefix of PathName matches a file system
-Volume Name. MatchIndex is the array  index in mFsInfo[] of the match, 
-and it can be used with mFs[] to find the handle that needs to be opened
-
-@param  PathName      PathName to check
-@param  FileStart     Index of the first character of the <path>
-@param  MatchIndex    Index in mFsInfo[] that matches
-
-@return TRUE      PathName matches a Volume Label and MatchIndex is valid
-@return FALSE     PathName does not match a Volume Label MatchIndex undefined
-
-**/
-BOOLEAN
-EblMatchVolumeName (
-  IN  CHAR8   *PathName,
-  IN  UINTN   FileStart,
-  OUT UINTN   *MatchIndex
-  )
-{
-  UINTN   Index;
-  UINTN   Compare;
-  UINTN   VolStrLen;
-  BOOLEAN Match;
-
-  for (Index =0; Index < mFsCount; Index++) {
-    if (mFsInfo[Index] == NULL) {
-      // FsInfo is not valid so skip it
-      continue;
-    }
-    VolStrLen = StrLen (mFsInfo[Index]->VolumeLabel);
-    for (Compare = 0, Match = TRUE; Compare < (FileStart - 1); Compare++) {
-      if (Compare > VolStrLen) {
-        Match = FALSE;
-        break;
-      }
-      if (PathName[Compare] != (CHAR8)mFsInfo[Index]->VolumeLabel[Compare]) {
-        // If the VolumeLabel has a space allow a _ to match with it in addition to ' '
-        if (!((PathName[Compare] == '_') && (mFsInfo[Index]->VolumeLabel[Compare] == L' '))) {
-          Match = FALSE;
-          break;
-        }
-      }
-    }
-    if (Match) {
-      *MatchIndex = Index;
-      return TRUE;
-    }
-  }
-
-  return FALSE;
-}
-
-
-/**
-Return the number of devices of the current type active in the system
-
-@param  Type      Device type to check
-
-@return 0         Invalid type
-
-**/
-UINTN
-EfiGetDeviceCounts (
-  IN  EFI_OPEN_FILE_TYPE     DeviceType
-  )
-{
-  switch (DeviceType) {
-  case EfiOpenLoadFile:
-    return mLoadFileCount;
-  case EfiOpenFirmwareVolume:
-    return mFvCount;
-  case EfiOpenFileSystem:
-    return mFsCount;
-  case EfiOpenBlockIo:
-    return mBlkIoCount;
-  default:
-    return 0;
-  }
-}
-
-EFI_STATUS
-ConvertIpStringToEfiIp (
-  IN  CHAR8           *PathName, 
-  OUT EFI_IP_ADDRESS  *ServerIp
-  )
-{
-  CHAR8     *Str;
-
-  Str = PathName;
-  ServerIp->v4.Addr[0] = (UINT8)AsciiStrDecimalToUintn (Str);
-
-  Str = AsciiStrStr (Str, ".");
-  if (Str == NULL) {
-    return EFI_DEVICE_ERROR;
-  }
-
-  ServerIp->v4.Addr[1] = (UINT8)AsciiStrDecimalToUintn (++Str);
-
-  Str = AsciiStrStr (Str, ".");
-  if (Str == NULL) {
-    return EFI_DEVICE_ERROR;
-  }
-
-  ServerIp->v4.Addr[2] = (UINT8)AsciiStrDecimalToUintn (++Str);
-
-  Str = AsciiStrStr (Str, ".");
-  if (Str == NULL) {
-    return EFI_DEVICE_ERROR;
-  }
-
-  ServerIp->v4.Addr[3] = (UINT8)AsciiStrDecimalToUintn (++Str);
-
-  return EFI_SUCCESS;
-}
-
-
-/**
-Internal work function to extract a device number from a string skipping 
-text. Easy way to extract numbers from strings like blk7:.
-
-@param  Str   String to extract device number form
-
-@return -1    Device string is not valid
-@return       Device #
-
-**/
-UINTN
-EblConvertDevStringToNumber (
-  IN  CHAR8   *Str
-  )
-{
-  UINTN   Max;
-  UINTN   Index;
-
-
-  // Find the first digit 
-  Max = AsciiStrLen (Str);
-  for  (Index = 0; !((*Str >= '0') && (*Str <= '9')) && (Index < Max); Index++) {
-    Str++;
-  }
-  if (Index == Max) {
-    return (UINTN)-1;
-  }
-
-  return AsciiStrDecimalToUintn (Str);
-}
-
-
-/**
-Internal work function to fill in EFI_OPEN_FILE information for the Fs and BlkIo
-
-@param  File        Open file handle
-@param  FileName    Name of file after device stripped off
-
-
-**/
-EFI_STATUS
-EblFileDevicePath (
-  IN OUT EFI_OPEN_FILE  *File,
-  IN  CHAR8             *FileName,
-  IN  CONST UINT64      OpenMode
-  )
-{
-  EFI_STATUS                        Status;
-  UINTN                             Size;
-  FILEPATH_DEVICE_PATH              *FilePath;
-  EFI_DEVICE_PATH_PROTOCOL          *FileDevicePath;
-  CHAR16                            UnicodeFileName[MAX_PATHNAME];
-  EFI_BLOCK_IO_PROTOCOL             *BlkIo;
-  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL   *Fs;
-  EFI_FILE_HANDLE                   Root;
-
-
-  if ( *FileName != 0 ) {
-    AsciiStrToUnicodeStr (FileName, UnicodeFileName);
-  } else {
-    AsciiStrToUnicodeStr ("\\", UnicodeFileName);
-  }
-
-  Size = StrSize (UnicodeFileName);
-  FileDevicePath = AllocatePool (Size + SIZE_OF_FILEPATH_DEVICE_PATH + sizeof (EFI_DEVICE_PATH_PROTOCOL));
-  if (FileDevicePath != NULL) {
-    FilePath = (FILEPATH_DEVICE_PATH *) FileDevicePath;
-    FilePath->Header.Type    = MEDIA_DEVICE_PATH;
-    FilePath->Header.SubType = MEDIA_FILEPATH_DP;
-    CopyMem (&FilePath->PathName, UnicodeFileName, Size);
-    SetDevicePathNodeLength (&FilePath->Header, Size + SIZE_OF_FILEPATH_DEVICE_PATH);
-    SetDevicePathEndNode (NextDevicePathNode (&FilePath->Header));
-
-    if (File->EfiHandle != NULL) {
-      File->DevicePath = DevicePathFromHandle (File->EfiHandle);
-    }
-
-    File->DevicePath = AppendDevicePath (File->DevicePath, FileDevicePath);
-    FreePool (FileDevicePath);
-  }
-
-  Status = gBS->HandleProtocol (File->EfiHandle, &gEfiBlockIoProtocolGuid, (VOID **)&BlkIo);
-  if (!EFI_ERROR (Status)) {
-    File->FsBlockIoMedia = BlkIo->Media;
-    File->FsBlockIo = BlkIo;
-
-    // If we are not opening the device this will get over written with file info
-    File->MaxPosition = MultU64x32 (BlkIo->Media->LastBlock + 1, BlkIo->Media->BlockSize);
-  }
-
-  if (File->Type == EfiOpenFileSystem) {
-    Status = gBS->HandleProtocol (File->EfiHandle, &gEfiSimpleFileSystemProtocolGuid, (VOID **)&Fs);
-    if (!EFI_ERROR (Status)) {
-      Status = Fs->OpenVolume (Fs, &Root);
-      if (!EFI_ERROR (Status)) {
-        // Get information about the volume
-        Size = 0;
-        Status = Root->GetInfo (Root, &gEfiFileSystemInfoGuid, &Size, File->FsInfo);
-        if (Status == EFI_BUFFER_TOO_SMALL) {
-          File->FsInfo = AllocatePool (Size);
-          Status = Root->GetInfo (Root, &gEfiFileSystemInfoGuid, &Size, File->FsInfo);
-        }
-
-        // Get information about the file
-        Status = Root->Open (Root, &File->FsFileHandle, UnicodeFileName, OpenMode, 0);
-        if (!EFI_ERROR (Status)) {
-          Size = 0;
-          Status = File->FsFileHandle->GetInfo (File->FsFileHandle, &gEfiFileInfoGuid, &Size, NULL);
-          if (Status == EFI_BUFFER_TOO_SMALL) {
-            File->FsFileInfo = AllocatePool (Size);
-            Status = File->FsFileHandle->GetInfo (File->FsFileHandle, &gEfiFileInfoGuid, &Size, File->FsFileInfo);
-            if (!EFI_ERROR (Status)) {
-              File->Size = (UINTN)File->FsFileInfo->FileSize;
-              File->MaxPosition = (UINT64)File->Size;
-            }
-          }
-        }
-
-        Root->Close (Root);
-      }
-    }
-  } else if (File->Type == EfiOpenBlockIo) {
-    File->Size = (UINTN)File->MaxPosition;
-  }
-
-  return Status;
-}
-
-#define ToUpper(a)  ((((a) >= 'a') && ((a) <= 'z')) ? ((a) - 'a' + 'A') : (a))
-
-EFI_STATUS
-CompareGuidToString (
-  IN  EFI_GUID    *Guid,
-  IN  CHAR8       *String
-  )
-{
-  CHAR8       AsciiGuid[64];
-  CHAR8       *StringPtr;
-  CHAR8       *GuidPtr;
-
-  AsciiSPrint (AsciiGuid, sizeof(AsciiGuid), "%g", Guid);
-
-  StringPtr = String;
-  GuidPtr   = AsciiGuid;
-
-  while ((*StringPtr != '\0') && (*GuidPtr != '\0')) {
-    // Skip dashes
-    if (*StringPtr == '-') {
-      StringPtr++;
-      continue;
-    }
-
-    if (*GuidPtr == '-') {
-      GuidPtr++;
-      continue;
-    }
-
-    if (ToUpper(*StringPtr) != ToUpper(*GuidPtr)) {
-      return EFI_NOT_FOUND;
-    }
-
-    StringPtr++;
-    GuidPtr++;
-  }
-
-  return EFI_SUCCESS;
-}
-
-
-/**
-Internal work function to fill in EFI_OPEN_FILE information for the FV
-
-@param  File        Open file handle
-@param  FileName    Name of file after device stripped off
-
-
-**/
-EFI_STATUS
-EblFvFileDevicePath (
-  IN OUT EFI_OPEN_FILE  *File,
-  IN  CHAR8             *FileName,
-  IN  CONST UINT64      OpenMode
-  )
-{
-  EFI_STATUS                          Status;
-  EFI_STATUS                          GetNextFileStatus;
-  MEDIA_FW_VOL_FILEPATH_DEVICE_PATH   DevicePathNode;
-  EFI_DEVICE_PATH_PROTOCOL            *DevicePath;
-  UINTN                               Key;
-  UINT32                              AuthenticationStatus;
-  CHAR8                               AsciiSection[MAX_PATHNAME];
-  VOID                                *Section;
-  UINTN                               SectionSize;
-  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *Fvb;
-  EFI_LBA                             Lba;
-  UINTN                               BlockSize;
-  UINTN                               NumberOfBlocks;
-  EFI_FIRMWARE_VOLUME_HEADER          *FvHeader = NULL;
-  UINTN                               Index;
-
-
-  Status = gBS->HandleProtocol (File->EfiHandle, &gEfiFirmwareVolume2ProtocolGuid, (VOID **)&File->Fv);
-  if (EFI_ERROR (Status)) {
-    return Status;
-  }
-
-  // Get FVB Info about the handle
-  Status = gBS->HandleProtocol (File->EfiHandle, &gEfiFirmwareVolumeBlockProtocolGuid, (VOID **)&Fvb);
-  if (!EFI_ERROR (Status)) {
-    Status = Fvb->GetPhysicalAddress (Fvb, &File->FvStart);
-    if (!EFI_ERROR (Status)) {
-      FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *)(UINTN)File->FvStart;
-      File->FvHeaderSize = sizeof (EFI_FIRMWARE_VOLUME_HEADER);
-      for (Index = 0; FvHeader->BlockMap[Index].Length !=0; Index++) {
-        File->FvHeaderSize += sizeof (EFI_FV_BLOCK_MAP_ENTRY);
-      }
-
-      for (Lba = 0, File->FvSize = 0, NumberOfBlocks = 0; ; File->FvSize += (BlockSize * NumberOfBlocks), Lba += NumberOfBlocks) {
-        Status = Fvb->GetBlockSize (Fvb, Lba, &BlockSize, &NumberOfBlocks);
-        if (EFI_ERROR (Status)) {
-          break;
-        }
-      }
-    }
-  }
-
-
-  DevicePath = DevicePathFromHandle (File->EfiHandle);
-
-  if (*FileName == '\0') {
-    File->DevicePath = DuplicateDevicePath (DevicePath);
-    File->Size = File->FvSize;
-    File->MaxPosition = File->Size;
-  } else {
-    Key = 0;
-    do {
-      File->FvType = EFI_FV_FILETYPE_ALL;
-      GetNextFileStatus = File->Fv->GetNextFile (
-        File->Fv, 
-        &Key,
-        &File->FvType,  
-        &File->FvNameGuid, 
-        &File->FvAttributes, 
-        &File->Size
-        );
-      if (!EFI_ERROR (GetNextFileStatus)) {
-        // Compare GUID first
-        Status = CompareGuidToString (&File->FvNameGuid, FileName);
-        if (!EFI_ERROR(Status)) {
-          break;
-        }
-
-        Section = NULL;
-        Status = File->Fv->ReadSection (
-          File->Fv,
-          &File->FvNameGuid,
-          EFI_SECTION_USER_INTERFACE,
-          0,
-          &Section,
-          &SectionSize,
-          &AuthenticationStatus
-          );
-        if (!EFI_ERROR (Status)) {
-          UnicodeStrToAsciiStr (Section, AsciiSection);
-          if (AsciiStriCmp (FileName, AsciiSection) == 0) {
-            FreePool (Section);
-            break;
-          }
-          FreePool (Section);
-        }
-      }
-    } while (!EFI_ERROR (GetNextFileStatus));
-
-    if (EFI_ERROR (GetNextFileStatus)) {
-      return GetNextFileStatus;
-    }
-
-    if (OpenMode != EFI_SECTION_ALL) {
-      // Calculate the size of the section we are targeting
-      Section = NULL;
-      File->Size = 0;
-      Status = File->Fv->ReadSection (
-        File->Fv,
-        &File->FvNameGuid,
-        (EFI_SECTION_TYPE)OpenMode,
-        0,
-        &Section,
-        &File->Size,
-        &AuthenticationStatus
-        );
-      if (EFI_ERROR (Status)) {
-        return Status;
-      }
-    }
-
-    File->MaxPosition = File->Size;
-    EfiInitializeFwVolDevicepathNode (&DevicePathNode, &File->FvNameGuid);
-    File->DevicePath = AppendDevicePathNode (DevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&DevicePathNode);
-  }
-
-
-  // FVB not required if FV was soft loaded...
-  return EFI_SUCCESS;
-}
-
-
-
-
-/**
-Open a device named by PathName. The PathName includes a device name and 
-path separated by a :. See file header for more details on the PathName
-syntax. There is no checking to prevent a file from being opened more than
-one type. 
-
-SectionType is only used to open an FV. Each file in an FV contains multiple
-sections and only the SectionType section is opened.
-
-For any file that is opened with EfiOpen() must be closed with EfiClose().
-
-@param  PathName    Path to parse to open 
-@param  OpenMode    Same as EFI_FILE.Open()
-@param  SectionType Section in FV to open.
-
-@return NULL  Open failed
-@return Valid EFI_OPEN_FILE handle
-
-**/
-EFI_OPEN_FILE *
-EfiOpen (
-  IN        CHAR8               *PathName,
-  IN  CONST UINT64              OpenMode,
-  IN  CONST EFI_SECTION_TYPE    SectionType
-  )
-{
-  EFI_STATUS                Status;
-  EFI_OPEN_FILE             *File;
-  EFI_OPEN_FILE             FileData;
-  UINTN                     StrLen;
-  UINTN                     FileStart;
-  UINTN                     DevNumber = 0;
-  EFI_OPEN_FILE_GUARD       *GuardFile;
-  BOOLEAN                   VolumeNameMatch;
-  EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
-  UINTN                     Size;
-  EFI_IP_ADDRESS            Ip;
-  CHAR8                     *CwdPlusPathName;
-  UINTN                     Index;
-  EFI_SECTION_TYPE          ModifiedSectionType;
-
-  EblUpdateDeviceLists ();
-
-  File = &FileData;
-  ZeroMem (File, sizeof (EFI_OPEN_FILE));
-
-  StrLen = AsciiStrSize (PathName);
-  if (StrLen <= 1) {
-    // Smallest valid path is 1 char and a null
-    return NULL;
-  }
-
-  for (FileStart = 0; FileStart < StrLen; FileStart++) {
-    if (PathName[FileStart] == ':') {
-      FileStart++;
-      break;
-    }
-  }
-
-  //
-  // Matching volume name has precedence over handle based names
-  //
-  VolumeNameMatch = EblMatchVolumeName (PathName, FileStart, &DevNumber);
-  if (!VolumeNameMatch) {
-    if (FileStart == StrLen) {
-      // No Volume name or device name, so try Current Working Directory
-      if (gCwd == NULL) {
-        // No CWD
-        return NULL;
-      }
-
-      // We could add a current working directory concept
-      CwdPlusPathName = AllocatePool (AsciiStrSize (gCwd) + AsciiStrSize (PathName));
-      if (CwdPlusPathName == NULL) {
-        return NULL;
-      }
-
-      if ((PathName[0] == '/') || (PathName[0] == '\\')) {
-        // PathName starts in / so this means we go to the root of the device in the CWD. 
-        CwdPlusPathName[0] = '\0';
-        for (FileStart = 0; gCwd[FileStart] != '\0'; FileStart++) {
-          CwdPlusPathName[FileStart] = gCwd[FileStart];
-          if (gCwd[FileStart] == ':') {
-            FileStart++;
-            CwdPlusPathName[FileStart] = '\0';
-            break;
-          }
-        }
-      } else {
-        AsciiStrCpy (CwdPlusPathName, gCwd);
-        StrLen = AsciiStrLen (gCwd);
-        if ((*PathName != '/') && (*PathName != '\\') && (gCwd[StrLen-1] != '/') && (gCwd[StrLen-1] != '\\')) {
-          AsciiStrCat (CwdPlusPathName, "\\");
-        }
-      }
-
-      AsciiStrCat (CwdPlusPathName, PathName);
-      if (AsciiStrStr (CwdPlusPathName, ":") == NULL) {
-        // Extra error check to make sure we don't recurse and blow stack
-        return NULL;
-      }
-
-      File = EfiOpen (CwdPlusPathName, OpenMode, SectionType);
-      FreePool (CwdPlusPathName);
-      return File;
-    }
-
-    DevNumber = EblConvertDevStringToNumber ((CHAR8 *)PathName); 
-  }
-
-  File->DeviceName = AllocatePool (StrLen);
-  AsciiStrCpy (File->DeviceName, PathName);
-  File->DeviceName[FileStart - 1] = '\0';
-  File->FileName = &File->DeviceName[FileStart];
-  if (File->FileName[0] == '\0') {
-    // if it is just a file name use / as root
-    File->FileName = "\\";
-  } 
-
-  //
-  // Use best match algorithm on the dev names so we only need to look at the
-  // first few charters to match the full device name. Short name forms are 
-  // legal from the caller.
-  //
-  Status = EFI_SUCCESS;
-  if (*PathName == 'f' || *PathName == 'F' || VolumeNameMatch) {
-    if (PathName[1] == 's' || PathName[1] == 'S' || VolumeNameMatch) {
-      if (DevNumber >= mFsCount) {
-        goto ErrorExit;
-      }
-      File->Type = EfiOpenFileSystem;
-      File->EfiHandle = mFs[DevNumber];
-      Status = EblFileDevicePath (File, &PathName[FileStart], OpenMode);
-
-    } else if (PathName[1] == 'v' || PathName[1] == 'V') { 
-      if (DevNumber >= mFvCount) {
-        goto ErrorExit;
-      }
-      File->Type = EfiOpenFirmwareVolume;
-      File->EfiHandle = mFv[DevNumber];
-
-      if ((PathName[FileStart] == '/') || (PathName[FileStart] == '\\')) {
-        // Skip leading / as its not really needed for the FV since no directories are supported
-        FileStart++;
-      }
-
-      // Check for 2nd :
-      ModifiedSectionType = SectionType;
-      for (Index = FileStart; PathName[Index] != '\0'; Index++) {
-        if (PathName[Index] == ':') {
-          // Support fv0:\DxeCore:0x10
-          // This means open the PE32 Section of the file 
-          ModifiedSectionType = (EFI_SECTION_TYPE)AsciiStrHexToUintn (&PathName[Index + 1]);
-          PathName[Index] = '\0';
-        }
-      }
-      File->FvSectionType = ModifiedSectionType;
-      Status = EblFvFileDevicePath (File, &PathName[FileStart], ModifiedSectionType);
-    }
-  } else if ((*PathName == 'A') || (*PathName == 'a')) {
-    // Handle a:0x10000000:0x1234 address form a:ADDRESS:SIZE
-    File->Type = EfiOpenMemoryBuffer;
-    // 1st colon is at PathName[FileStart - 1]
-    File->Buffer = (VOID *)AsciiStrHexToUintn (&PathName[FileStart]);
-
-    // Find 2nd colon
-    while ((PathName[FileStart] != ':') && (PathName[FileStart] != '\0')) {
-      FileStart++;
-    }
-
-    // If we ran out of string, there's no extra data
-    if (PathName[FileStart] == '\0') {
-      File->Size = 0;
-    } else {
-      File->Size = AsciiStrHexToUintn (&PathName[FileStart + 1]);
-    }
-
-    // if there's no number after the second colon, default
-    // the end of memory
-    if (File->Size == 0) {
-      File->Size =  (UINTN)(0 - (UINTN)File->Buffer);
-    }
-
-    File->MaxPosition = File->Size;
-    File->BaseOffset = (UINTN)File->Buffer;
-
-  } else if (*PathName== 'l' || *PathName == 'L') {
-    if (DevNumber >= mLoadFileCount) {
-      goto ErrorExit;
-    }
-    File->Type = EfiOpenLoadFile;
-    File->EfiHandle = mLoadFile[DevNumber];
-
-    Status = gBS->HandleProtocol (File->EfiHandle, &gEfiLoadFileProtocolGuid, (VOID **)&File->LoadFile);
-    if (EFI_ERROR (Status)) {
-      goto ErrorExit;
-    }
-
-    Status = gBS->HandleProtocol (File->EfiHandle, &gEfiDevicePathProtocolGuid, (VOID **)&DevicePath);
-    if (EFI_ERROR (Status)) {
-      goto ErrorExit;
-    }
-    File->DevicePath = DuplicateDevicePath (DevicePath);
-
-  } else if (*PathName == 'b' || *PathName == 'B') {
-    // Handle b#:0x10000000:0x1234 address form b#:ADDRESS:SIZE
-    if (DevNumber >= mBlkIoCount) {
-      goto ErrorExit;
-    }
-    File->Type = EfiOpenBlockIo;
-    File->EfiHandle = mBlkIo[DevNumber];
-    EblFileDevicePath (File, "", OpenMode);
-
-    // 1st colon is at PathName[FileStart - 1]
-    File->DiskOffset = AsciiStrHexToUintn (&PathName[FileStart]);
-
-    // Find 2nd colon
-    while ((PathName[FileStart] != ':') && (PathName[FileStart] != '\0')) {
-      FileStart++;
-    }
-
-    // If we ran out of string, there's no extra data
-    if (PathName[FileStart] == '\0') {
-      Size = 0;
-    } else {
-      Size = AsciiStrHexToUintn (&PathName[FileStart + 1]);
-    }
-
-    // if a zero size is passed in (or the size is left out entirely),
-    // go to the end of the device.
-    if (Size == 0) {
-      File->Size = File->Size - File->DiskOffset;
-    } else {
-      File->Size = Size;
-    }
-
-    File->MaxPosition = File->Size;
-    File->BaseOffset = File->DiskOffset;
-  } else if ((*PathName) >= '0' && (*PathName <= '9')) {
-
-    // Get current IP address
-    Status = EblGetCurrentIpAddress (&Ip);
-    if (EFI_ERROR(Status)) {
-      AsciiPrint("Device IP Address is not configured.\n");
-      goto ErrorExit;
-    }
-
-
-    // Parse X.X.X.X:Filename, only support IPv4 TFTP for now...
-    File->Type = EfiOpenTftp;
-    File->IsDirty = FALSE;
-    File->IsBufferValid = FALSE;
-
-    Status = ConvertIpStringToEfiIp (PathName, &File->ServerIp);
-  }
-
-  if (EFI_ERROR (Status)) {
-    goto ErrorExit;
-  }
-
-  GuardFile = (EFI_OPEN_FILE_GUARD *)AllocateZeroPool (sizeof (EFI_OPEN_FILE_GUARD));
-  if (GuardFile == NULL) {
-    goto ErrorExit;
-  }
-
-  GuardFile->Header = EFI_OPEN_FILE_GUARD_HEADER;
-  CopyMem (&(GuardFile->File), &FileData, sizeof (EFI_OPEN_FILE));
-  GuardFile->Footer = EFI_OPEN_FILE_GUARD_FOOTER;
-
-  return &(GuardFile->File);
-
-ErrorExit:
-  FreePool (File->DeviceName);
-  return NULL;
-}
-
-#define FILE_COPY_CHUNK 0x01000000
-
-EFI_STATUS
-EfiCopyFile (
-  IN        CHAR8               *DestinationFile,
-  IN        CHAR8               *SourceFile
-  )
-{
-  EFI_OPEN_FILE *Source      = NULL;
-  EFI_OPEN_FILE *Destination = NULL;
-  EFI_STATUS    Status       = EFI_SUCCESS;
-  VOID          *Buffer      = NULL;
-  UINTN         Size;
-  UINTN         Offset;
-  UINTN         Chunk = FILE_COPY_CHUNK;
-
-  Source = EfiOpen (SourceFile, EFI_FILE_MODE_READ, 0);
-  if (Source == NULL) {
-    AsciiPrint("Source file open error.\n");
-    Status = EFI_NOT_FOUND;
-    goto Exit;
-  }
-
-  Destination = EfiOpen (DestinationFile, EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE, 0);
-  if (Destination == NULL) {
-    AsciiPrint("Destination file open error.\n");
-    Status = EFI_NOT_FOUND;
-    goto Exit;
-  }
-
-  Buffer = AllocatePool(FILE_COPY_CHUNK);
-  if (Buffer == NULL) {
-    Status = EFI_OUT_OF_RESOURCES;
-    goto Exit;
-  }
-
-  Size = EfiTell(Source, NULL);
-
-  for (Offset = 0; Offset + FILE_COPY_CHUNK <= Size; Offset += Chunk) {
-    Chunk = FILE_COPY_CHUNK;
-
-    Status = EfiRead(Source, Buffer, &Chunk);
-    if (EFI_ERROR(Status)) {
-      AsciiPrint("Read file error %r\n", Status);
-      goto Exit;
-    }
-
-    Status = EfiWrite(Destination, Buffer, &Chunk);
-    if (EFI_ERROR(Status)) {
-      AsciiPrint("Write file error %r\n", Status);
-      goto Exit;
-    }    
-  }
-
-  // Any left over?
-  if (Offset < Size) {
-    Chunk = Size - Offset;
-
-    Status = EfiRead(Source, Buffer, &Chunk);
-    if (EFI_ERROR(Status)) {
-      AsciiPrint("Read file error\n");
-      goto Exit;
-    }
-
-    Status = EfiWrite(Destination, Buffer, &Chunk);
-    if (EFI_ERROR(Status)) {
-      AsciiPrint("Write file error\n");
-      goto Exit;
-    }    
-  }
-
-Exit:
-  if (Source != NULL) {
-    Status = EfiClose(Source);
-    if (EFI_ERROR(Status)) {
-      AsciiPrint("Source close error");
-    }
-  }
-
-  if (Destination != NULL) {
-    Status = EfiClose(Destination);
-    if (EFI_ERROR(Status)) {
-      AsciiPrint("Destination close error");
-    }
-  }
-
-  if (Buffer != NULL) {
-    FreePool(Buffer);
-  }
-
-  return Status;
-}
-
-/**
-Use DeviceType and Index to form a valid PathName and try and open it.
-
-@param  DeviceType  Device type to open
-@param  Index       Device Index to use. Zero relative.
-
-@return NULL  Open failed
-@return Valid EFI_OPEN_FILE handle
-
-**/
-EFI_OPEN_FILE  *
-EfiDeviceOpenByType (
-  IN  EFI_OPEN_FILE_TYPE    DeviceType,
-  IN  UINTN                 Index
-  )
-{
-  CHAR8   *DevStr;
-  CHAR8   Path[MAX_CMD_LINE];
-
-  switch (DeviceType) {
-  case EfiOpenLoadFile:
-    DevStr = "loadfile%d:";
-    break;
-  case EfiOpenFirmwareVolume:
-    DevStr = "fv%d:";    
-    break;
-  case EfiOpenFileSystem:
-    DevStr = "fs%d:";    
-    break;
-  case EfiOpenBlockIo:
-    DevStr = "blk%d:";    
-    break;
-  case EfiOpenMemoryBuffer:
-    DevStr = "a%d:";    
-    break;
-  default:
-    return NULL;
-  }
-
-  AsciiSPrint (Path, MAX_PATHNAME, DevStr, Index);
-
-  return EfiOpen (Path, EFI_FILE_MODE_READ, 0);
-}
-
-
-/**
-Close a file handle opened by EfiOpen() and free all resources allocated by
-EfiOpen().
-
-@param  Stream    Open File Handle
-
-@return EFI_INVALID_PARAMETER  Stream is not an Open File
-@return EFI_SUCCESS            Steam closed
-
-**/
-EFI_STATUS
-EfiClose (
-  IN  EFI_OPEN_FILE     *File
-  )
-{
-  EFI_STATUS          Status;
-  UINT64              TftpBufferSize;
-
-  if (!FileHandleValid (File)) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  //Write the buffer contents to TFTP file.
-  if ((File->Type == EfiOpenTftp) && (File->IsDirty)) {
-
-    TftpBufferSize = File->Size;
-    Status = EblMtftp (
-      EFI_PXE_BASE_CODE_TFTP_WRITE_FILE, 
-      File->Buffer, 
-      TRUE, 
-      &TftpBufferSize, 
-      NULL, 
-      &File->ServerIp, 
-      (UINT8 *)File->FileName, 
-      NULL, 
-      FALSE
-      );
-    if (EFI_ERROR(Status)) {
-      AsciiPrint("TFTP error during APPLE_NSP_TFTP_WRITE_FILE: %r\n", Status);
-      return Status;
-    }
-  }
-
-  if ((File->Type == EfiOpenLoadFile) || 
-    ((File->Type == EfiOpenTftp) && (File->IsBufferValid == TRUE)) ||
-    ((File->Type == EfiOpenFirmwareVolume) && (File->IsBufferValid == TRUE))) {
-    EblFreePool(File->Buffer);
-  }
-
-  EblFreePool (File->DevicePath);
-  EblFreePool (File->DeviceName);
-  EblFreePool (File->FsFileInfo);
-  EblFreePool (File->FsInfo);
-
-  if (File->FsFileHandle != NULL) {
-    File->FsFileHandle->Close (File->FsFileHandle);
-  }
-
-  // Need to free File and it's Guard structures
-  EblFreePool (BASE_CR (File, EFI_OPEN_FILE_GUARD, File));
-  return EFI_SUCCESS;
-}
-
-
-/**
-Return the size of the file represented by Stream. Also return the current 
-Seek position. Opening a file will enable a valid file size to be returned.
-LoadFile is an exception as a load file size is set to zero. 
-
-@param  Stream    Open File Handle
-
-@return 0         Stream is not an Open File or a valid LoadFile handle
-
-**/
-UINTN
-EfiTell (
-  IN  EFI_OPEN_FILE     *File,
-  OUT EFI_LBA           *CurrentPosition    OPTIONAL
-  )
-{
-  EFI_STATUS Status;
-  UINT64     BufferSize = 0;
-
-  if (!FileHandleValid (File)) {
-    return 0;
-  }
-
-  if (CurrentPosition != NULL) {
-    *CurrentPosition = File->CurrentPosition;
-  }
-
-  if (File->Type == EfiOpenLoadFile) {
-    // Figure out the File->Size
-    File->Buffer = NULL;
-    File->Size   = 0;
-    Status = File->LoadFile->LoadFile (File->LoadFile, File->DevicePath, FALSE, &File->Size, File->Buffer);
-    if (Status != EFI_BUFFER_TOO_SMALL) {
-      return 0;
-    }
-
-    File->MaxPosition = (UINT64)File->Size;
-  } else if (File->Type == EfiOpenTftp) {
-
-    Status = EblMtftp (
-      EFI_PXE_BASE_CODE_TFTP_GET_FILE_SIZE,
-      NULL,
-      FALSE,
-      &BufferSize,
-      NULL,
-      &File->ServerIp,
-      (UINT8 *)File->FileName,
-      NULL,
-      TRUE
-      );
-    if (EFI_ERROR(Status)) {
-      AsciiPrint("TFTP error during APPLE_NSP_TFTP_GET_FILE_SIZE: %r\n", Status);
-      return 0;
-    }
-
-    File->Size        = (UINTN)BufferSize;
-    File->MaxPosition = File->Size;
-  }
-
-  return File->Size;
-}
-
-
-/**
-Seek to the Offset location in the file. LoadFile and FV device types do
-not support EfiSeek(). It is not possible to grow the file size using 
-EfiSeek().
-
-SeekType defines how use Offset to calculate the new file position:
-EfiSeekStart  : Position = Offset
-EfiSeekCurrent: Position is Offset bytes from the current position
-EfiSeekEnd    : Only supported if Offset is zero to seek to end of file.
-
-@param  Stream    Open File Handle
-@param  Offset    Offset to seek too. 
-@param  SeekType  Type of seek to perform
-
-
-@return EFI_INVALID_PARAMETER  Stream is not an Open File
-@return EFI_UNSUPPORTED        LoadFile and FV do not support Seek
-@return EFI_NOT_FOUND          Seek past the end of the file.
-@return EFI_SUCCESS            Steam closed
-
-**/
-EFI_STATUS
-EfiSeek (
-  IN  EFI_OPEN_FILE     *File,
-  IN  EFI_LBA           Offset,
-  IN  EFI_SEEK_TYPE     SeekType
-  )
-{
-  EFI_STATUS    Status;
-  UINT64        CurrentPosition;
-
-  if (!FileHandleValid (File)) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  if (File->Type == EfiOpenLoadFile) {
-    // LoadFile does not support Seek
-    return EFI_UNSUPPORTED;
-  }
-
-  CurrentPosition = File->CurrentPosition;
-  switch (SeekType) {
-  case EfiSeekStart:
-    if (Offset > File->MaxPosition) {
-      return EFI_NOT_FOUND;
-    }
-    CurrentPosition = Offset;
-    break;
-
-  case EfiSeekCurrent:
-    if ((File->CurrentPosition + Offset) > File->MaxPosition) {
-      return EFI_NOT_FOUND;
-    }
-    CurrentPosition += Offset;
-    break;
-
-  case EfiSeekEnd:
-    if (Offset != 0) {
-      // We don't support growing file size via seeking past end of file
-      return EFI_UNSUPPORTED;
-    }
-    CurrentPosition = File->MaxPosition;
-    break;
-
-  default:
-    return EFI_NOT_FOUND;
-  }
-
-  Status = EFI_SUCCESS;
-  if (File->FsFileHandle != NULL) {
-    Status = File->FsFileHandle->SetPosition (File->FsFileHandle, CurrentPosition);
-  }
-
-  if (!EFI_ERROR (Status)) {
-    File->CurrentPosition = CurrentPosition;
-  }
-
-  return Status;
-}
-
-EFI_STATUS
-CacheTftpFile (
-  IN OUT  EFI_OPEN_FILE *File
-  )
-{
-  EFI_STATUS          Status;
-  UINT64              TftpBufferSize;
-
-  if (File->IsBufferValid) {
-    return EFI_SUCCESS;
-  }
-
-  // Make sure the file size is set.
-  EfiTell (File, NULL);
-
-  //Allocate a buffer to hold the whole file.
-  File->Buffer = AllocatePool(File->Size);
-  if (File->Buffer == NULL) {
-    return EFI_OUT_OF_RESOURCES;
-  }
-
-  TftpBufferSize = File->Size;
-
-  Status = EblMtftp (
-    EFI_PXE_BASE_CODE_TFTP_READ_FILE, 
-    File->Buffer, 
-    FALSE, 
-    &TftpBufferSize, 
-    NULL, 
-    &File->ServerIp, 
-    (UINT8 *)File->FileName, 
-    NULL, 
-    FALSE);
-  if (EFI_ERROR(Status)) {
-    AsciiPrint("TFTP error during APPLE_NSP_TFTP_READ_FILE: %r\n", Status);
-    FreePool(File->Buffer);
-    return Status;
-  }
-
-  // Set the buffer valid flag.
-  File->IsBufferValid = TRUE;
-
-  return Status;
-}
-
-/**
-Read BufferSize bytes from the current location in the file. For load file,
-FV, and TFTP case you must read the entire file. 
-
-@param  Stream      Open File Handle
-@param  Buffer      Caller allocated buffer. 
-@param  BufferSize  Size of buffer in bytes.
-
-
-@return EFI_SUCCESS           Stream is not an Open File
-@return EFI_END_OF_FILE Tried to read past the end of the file
-@return EFI_INVALID_PARAMETER Stream is not an open file handle
-@return EFI_BUFFER_TOO_SMALL  Buffer is not big enough to do the read
-@return "other"               Error returned from device read
-
-**/
-EFI_STATUS
-EfiRead (
-  IN  EFI_OPEN_FILE       *File,
-  OUT VOID                *Buffer,
-  OUT UINTN               *BufferSize
-  )
-{
-  EFI_STATUS            Status;
-  UINT32                AuthenticationStatus;
-  EFI_DISK_IO_PROTOCOL  *DiskIo;
-
-  if (!FileHandleValid (File)) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  // Don't read past the end of the file.
-  if ((File->CurrentPosition + *BufferSize) > File->MaxPosition) {
-    return EFI_END_OF_FILE;
-  }
-
-  switch (File->Type) {
-  case EfiOpenLoadFile:
-    // Figure out the File->Size
-    EfiTell (File, NULL);
-
-    Status = File->LoadFile->LoadFile (File->LoadFile, File->DevicePath, FALSE, BufferSize, Buffer);
-    break;
-
-  case EfiOpenFirmwareVolume:
-    if (CompareGuid (&File->FvNameGuid, &gZeroGuid)) {
-      // This is the entire FV device, so treat like a memory buffer 
-      CopyMem (Buffer, (VOID *)(UINTN)(File->FvStart + File->CurrentPosition), *BufferSize);
-      File->CurrentPosition += *BufferSize;
-      Status = EFI_SUCCESS;
-    } else {
-      if (File->Buffer == NULL) {
-        if (File->FvSectionType == EFI_SECTION_ALL) {
-          Status = File->Fv->ReadFile (
-            File->Fv,
-            &File->FvNameGuid,
-            (VOID **)&File->Buffer,
-            &File->Size,
-            &File->FvType,
-            &File->FvAttributes,
-            &AuthenticationStatus
-            );
-        } else {
-          Status = File->Fv->ReadSection (
-            File->Fv,
-            &File->FvNameGuid,
-            File->FvSectionType,
-            0,
-            (VOID **)&File->Buffer,
-            &File->Size,
-            &AuthenticationStatus
-            );
-        }
-        if (EFI_ERROR (Status)) {
-          return Status;
-        }
-        File->IsBufferValid = TRUE;
-      }
-      // Operate on the cached buffer so Seek will work
-      CopyMem (Buffer, File->Buffer + File->CurrentPosition, *BufferSize);
-      File->CurrentPosition += *BufferSize;
-      Status = EFI_SUCCESS;
-    }
-    break;
-
-  case EfiOpenMemoryBuffer:
-    CopyMem (Buffer, File->Buffer + File->CurrentPosition, *BufferSize);
-    File->CurrentPosition += *BufferSize;
-    Status = EFI_SUCCESS;
-    break;
-
-  case EfiOpenFileSystem:
-    Status = File->FsFileHandle->Read (File->FsFileHandle, BufferSize, Buffer);
-    File->CurrentPosition += *BufferSize;
-    break;
-
-  case EfiOpenBlockIo:
-    Status = gBS->HandleProtocol(File->EfiHandle, &gEfiDiskIoProtocolGuid, (VOID **)&DiskIo);
-    if (!EFI_ERROR(Status)) {
-      Status = DiskIo->ReadDisk(DiskIo, File->FsBlockIoMedia->MediaId, File->DiskOffset + File->CurrentPosition, *BufferSize, Buffer);
-    }
-    File->CurrentPosition += *BufferSize;
-    break;
-
-  case EfiOpenTftp:
-    // Cache the file if it hasn't been cached yet.
-    if (File->IsBufferValid == FALSE) {
-      Status = CacheTftpFile (File);
-      if (EFI_ERROR (Status)) {
-        return Status;
-      }
-    }
-
-    // Copy out the requested data
-    CopyMem (Buffer, File->Buffer + File->CurrentPosition, *BufferSize);
-    File->CurrentPosition += *BufferSize;
-
-    Status = EFI_SUCCESS;
-    break;
-
-  default:
-    return EFI_INVALID_PARAMETER;
-  };
-
-  return Status;
-}
-
-
-/**
-Read the entire file into a buffer. This routine allocates the buffer and
-returns it to the user full of the read data. 
-
-This is very useful for load file where it's hard to know how big the buffer
-must be.
-
-@param  Stream      Open File Handle
-@param  Buffer      Pointer to buffer to return. 
-@param  BufferSize  Pointer to Size of buffer return..
-
-
-@return EFI_SUCCESS           Stream is not an Open File
-@return EFI_END_OF_FILE       Tried to read past the end of the file
-@return EFI_INVALID_PARAMETER Stream is not an open file handle
-@return EFI_BUFFER_TOO_SMALL  Buffer is not big enough to do the read
-@return "other"               Error returned from device read
-
-**/
-EFI_STATUS
-EfiReadAllocatePool (
-  IN  EFI_OPEN_FILE     *File,
-  OUT VOID              **Buffer,
-  OUT UINTN             *BufferSize
-  )
-{
-  if (!FileHandleValid (File)) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  // Loadfile defers file size determination on Open so use tell to find it
-  EfiTell (File, NULL);
-
-  *BufferSize = File->Size;
-  *Buffer = AllocatePool (*BufferSize);
-  if (*Buffer == NULL) {
-    return EFI_NOT_FOUND;
-  }
-
-  return EfiRead (File, *Buffer, BufferSize);
-}
-
-
-/**
-Write data back to the file. For TFTP case you must write the entire file. 
-
-@param  Stream      Open File Handle
-@param  Buffer      Pointer to buffer to return. 
-@param  BufferSize  Pointer to Size of buffer return..
-
-
-@return EFI_SUCCESS           Stream is not an Open File
-@return EFI_END_OF_FILE       Tried to read past the end of the file
-@return EFI_INVALID_PARAMETER Stream is not an open file handle
-@return EFI_BUFFER_TOO_SMALL  Buffer is not big enough to do the read
-@return "other"               Error returned from device write
-
-**/
-EFI_STATUS
-EfiWrite (
-  IN  EFI_OPEN_FILE   *File,
-  OUT VOID            *Buffer,
-  OUT UINTN           *BufferSize
-  )
-{
-  EFI_STATUS              Status;
-  EFI_FV_WRITE_FILE_DATA  FileData;
-  EFI_DISK_IO_PROTOCOL    *DiskIo;  
-
-  if (!FileHandleValid (File)) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  switch (File->Type) {
-  case EfiOpenMemoryBuffer:
-    if ((File->CurrentPosition + *BufferSize) > File->MaxPosition) {
-      return EFI_END_OF_FILE;
-    }
-
-    CopyMem (File->Buffer + File->CurrentPosition, Buffer, *BufferSize);
-    File->CurrentPosition += *BufferSize;
-    Status = EFI_SUCCESS;
-
-  case EfiOpenLoadFile:
-    // LoadFile device is read only be definition
-    Status = EFI_UNSUPPORTED;
-
-  case EfiOpenFirmwareVolume:
-    if (File->FvSectionType != EFI_SECTION_ALL) {
-      // Writes not support to a specific section. You have to update entire file
-      return EFI_UNSUPPORTED;
-    }
-
-    FileData.NameGuid       = &(File->FvNameGuid);
-    FileData.Type           = File->FvType;
-    FileData.FileAttributes = File->FvAttributes;
-    FileData.Buffer         = Buffer;
-    FileData.BufferSize     = (UINT32)*BufferSize;
-    Status = File->Fv->WriteFile (File->Fv, 1, EFI_FV_UNRELIABLE_WRITE, &FileData);
-    break;
-
-  case EfiOpenFileSystem:
-    Status = File->FsFileHandle->Write (File->FsFileHandle, BufferSize, Buffer);
-    File->CurrentPosition += *BufferSize;
-    break;
-
-  case EfiOpenBlockIo:
-    if ((File->CurrentPosition + *BufferSize) > File->MaxPosition) {
-      return EFI_END_OF_FILE;
-    }
-
-    Status = gBS->HandleProtocol (File->EfiHandle, &gEfiDiskIoProtocolGuid, (VOID **)&DiskIo);
-    if (!EFI_ERROR(Status)) {
-      Status = DiskIo->WriteDisk (DiskIo, File->FsBlockIoMedia->MediaId, File->DiskOffset + File->CurrentPosition, *BufferSize, Buffer);
-    }
-    File->CurrentPosition += *BufferSize;
-    break;
-
-  case EfiOpenTftp:
-    // Cache the file if it hasn't been cached yet.
-    if (File->IsBufferValid == FALSE) {
-      Status = CacheTftpFile(File);
-      if (EFI_ERROR(Status)) {
-        return Status;
-      }
-    }
-
-    // Don't overwrite the buffer
-    if ((File->CurrentPosition + *BufferSize) > File->MaxPosition) {
-      UINT8 *TempBuffer;
-
-      TempBuffer = File->Buffer;
-
-      File->Buffer = AllocatePool ((UINTN)(File->CurrentPosition + *BufferSize));
-      if (File->Buffer == NULL) {
-        return EFI_OUT_OF_RESOURCES;
-      }
-
-      CopyMem (File->Buffer, TempBuffer, File->Size);
-
-      FreePool (TempBuffer);
-
-      File->Size = (UINTN)(File->CurrentPosition + *BufferSize);
-      File->MaxPosition = (UINT64)File->Size;
-    }
-
-    // Copy in the requested data
-    CopyMem (File->Buffer + File->CurrentPosition, Buffer, *BufferSize);
-    File->CurrentPosition += *BufferSize;
-
-    // Mark the file dirty
-    File->IsDirty = TRUE;
-
-    Status = EFI_SUCCESS;
-    break;
-
-  default:
-    Status = EFI_INVALID_PARAMETER;
-  };
-
-  return Status;
-}
-
-
-/**
-Given Cwd expand Path to remove .. and replace them with real 
-directory names.
-
-@param  Cwd     Current Working Directory
-@param  Path    Path to expand
-
-@return NULL     Cwd or Path are not valid
-@return 'other'  Path with .. expanded
-
-**/
-CHAR8 *
-ExpandPath (
-  IN CHAR8    *Cwd,
-  IN CHAR8    *Path
-  )
-{
-  CHAR8   *NewPath;
-  CHAR8   *Work, *Start, *End;
-  UINTN   StrLen;
-  INTN    i;
-
-  if (Cwd == NULL || Path == NULL) {
-    return NULL;
-  }
-
-  StrLen = AsciiStrSize (Cwd);
-  if (StrLen <= 2) {
-    // Smallest valid path is 1 char and a null
-    return NULL;
-  }
-
-  StrLen = AsciiStrSize (Path);
-  NewPath = AllocatePool (AsciiStrSize (Cwd) + StrLen + 1);
-  if (NewPath == NULL) {
-    return NULL;
-  }
-  AsciiStrCpy (NewPath, Cwd);
-
-  End = Path + StrLen;
-  for (Start = Path ;;) {
-    Work = AsciiStrStr (Start, "..") ;
-    if (Work == NULL) {
-      // Remaining part of Path contains no more ..
-      break;
-    } 
-
-    // append path prior to .. 
-    AsciiStrnCat (NewPath, Start, Work - Start);
-    StrLen = AsciiStrLen (NewPath);
-    for (i = StrLen; i >= 0; i--) {
-      if (NewPath[i] == ':') {
-        // too many ..
-        return NULL;
-      }
-      if (NewPath[i] == '/' || NewPath[i] == '\\') {
-        if ((i > 0) && (NewPath[i-1] == ':')) {
-          // leave the / before a :
-          NewPath[i+1] = '\0';
-        } else {
-          // replace / will Null to remove trailing file/dir reference
-          NewPath[i] = '\0';
-        }
-        break;
-      }
-    }
-
-    Start = Work + 3;
-  } 
-
-  // Handle the path that remains after the ..
-  AsciiStrnCat (NewPath, Start, End - Start);
-
-  return NewPath;
-}
-
-
-/**
-Set the Current Working Directory (CWD). If a call is made to EfiOpen () and
-the path does not contain a device name, The CWD is prepended to the path.
-
-@param  Cwd     Current Working Directory to set
-
-
-@return EFI_SUCCESS           CWD is set
-@return EFI_INVALID_PARAMETER Cwd is not a valid device:path
-
-**/
-EFI_STATUS
-EfiSetCwd (
-  IN  CHAR8   *Cwd
-  ) 
-{
-  EFI_OPEN_FILE *File;
-  UINTN         Len;
-  CHAR8         *Path;
-
-  if (Cwd == NULL) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  if (AsciiStrCmp (Cwd, ".") == 0) {
-    // cd . is a no-op
-    return EFI_SUCCESS;
-  }
-
-  Path = Cwd;
-  if (AsciiStrStr (Cwd, "..") != NULL) {
-    if (gCwd == NULL) {
-      // no parent 
-      return EFI_SUCCESS;
-    }
-
-    Len = AsciiStrLen (gCwd);
-    if ((gCwd[Len-2] == ':') && ((gCwd[Len-1] == '/') || (gCwd[Len-1] == '\\'))) {
-      // parent is device so nothing to do
-      return EFI_SUCCESS;
-    }
-
-    // Expand .. in Cwd, given we know current working directory
-    Path = ExpandPath (gCwd, Cwd);
-    if (Path == NULL) {
-      return EFI_NOT_FOUND;
-    }
-  }
-
-  File = EfiOpen (Path, EFI_FILE_MODE_READ, 0);
-  if (File == NULL) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  if (gCwd != NULL) {
-    FreePool (gCwd);
-  }
-
-  // Use the info returned from EfiOpen as it can add in CWD if needed. So Cwd could be
-  // relative to the current gCwd or not.
-  gCwd = AllocatePool (AsciiStrSize (File->DeviceName) + AsciiStrSize (File->FileName) + 10);
-  if (gCwd == NULL) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  AsciiStrCpy (gCwd, File->DeviceName);
-  if (File->FileName == NULL) {
-    AsciiStrCat (gCwd, ":\\");
-  } else {
-    AsciiStrCat (gCwd, ":");
-    AsciiStrCat (gCwd, File->FileName);
-  }
-
-
-  EfiClose (File);
-  if (Path != Cwd) {
-    FreePool (Path);
-  }
-  return EFI_SUCCESS;
-}
-
-
-/**
-Set the Current Working Directory (CWD). If a call is made to EfiOpen () and
-the path does not contain a device name, The CWD is prepended to the path.
-The CWD buffer is only valid until a new call is made to EfiSetCwd(). After
-a call to EfiSetCwd() it is not legal to use the pointer returned by 
-this function.
-
-@param  Cwd     Current Working Directory 
-
-
-@return ""      No CWD set
-@return 'other' Returns buffer that contains CWD.
-
-**/
-CHAR8 *
-EfiGetCwd (
-  VOID
-  )
-{
-  if (gCwd == NULL) {
-    return "";
-  }
-  return gCwd;
-}
-
-
+/** @file

+File IO routines inspired by Streams with an EFI flavor

+

+Copyright (c) 2007, Intel Corporation. All rights reserved.<BR>

+Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+This program and the accompanying materials

+are licensed and made available under the terms and conditions of the BSD License

+which accompanies this distribution.  The full text of the license may be found at

+http://opensource.org/licenses/bsd-license.php

+

+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+Basic support for opening files on different device types. The device string

+is in the form of DevType:Path. Current DevType is required as there is no

+current mounted device concept of current working directory concept implement

+by this library.

+

+Device names are case insensitive and only check the leading characters for

+unique matches. Thus the following are all the same:

+LoadFile0:

+l0:

+L0:

+Lo0:

+

+Supported Device Names:

+A0x1234:0x12 - A memory buffer starting at address 0x1234 for 0x12 bytes

+l1:          - EFI LoadFile device one.

+B0:          - EFI BlockIo zero.

+fs3:         - EFI Simple File System device 3

+Fv2:         - EFI Firmware VOlume device 2

+10.0.1.102:  - TFTP service IP followed by the file name

+**/

+

+#include <PiDxe.h>

+#include <Protocol/BlockIo.h>             

+#include <Protocol/DiskIo.h>             

+#include <Protocol/SimpleFileSystem.h>      

+#include <Protocol/FirmwareVolume2.h>        

+#include <Protocol/LoadFile.h>

+#include <Protocol/FirmwareVolumeBlock.h>  

+#include <Guid/FileInfo.h>

+#include <Library/BaseLib.h>

+#include <Library/MemoryAllocationLib.h>

+#include <Library/DevicePathLib.h>

+#include <Library/PrintLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/UefiLib.h>   

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/UefiRuntimeServicesTableLib.h>

+#include <Library/DebugLib.h>

+#include <Library/EfiFileLib.h>

+#include <Library/PcdLib.h>

+#include <Library/EblNetworkLib.h>

+

+

+CHAR8 *gCwd = NULL;

+

+CONST EFI_GUID gZeroGuid  = { 0, 0, 0, { 0, 0, 0, 0, 0, 0, 0, 0 } };

+

+#define EFI_OPEN_FILE_GUARD_HEADER  0x4B4D4641

+#define EFI_OPEN_FILE_GUARD_FOOTER  0x444D5A56

+

+// Need to defend against this overflowing

+#define MAX_CMD_LINE  0x200

+

+typedef struct {

+  UINT32            Header;

+  EFI_OPEN_FILE     File;

+  UINT32            Footer;

+} EFI_OPEN_FILE_GUARD;

+

+

+// globals to store current open device info

+EFI_HANDLE            *mBlkIo = NULL;

+UINTN                 mBlkIoCount = 0;

+

+EFI_HANDLE            *mFs = NULL;

+UINTN                 mFsCount = 0;

+// mFsInfo[] array entries must match mFs[] handles

+EFI_FILE_SYSTEM_INFO  **mFsInfo = NULL;

+

+EFI_HANDLE            *mFv = NULL;

+UINTN                 mFvCount = 0;

+EFI_HANDLE            *mLoadFile = NULL;

+UINTN                 mLoadFileCount = 0;

+

+

+

+/**

+Internal worker function to validate a File handle.

+

+@param  File    Open File Handle

+

+@return TRUE    File is valid

+@return FALSE   File is not valid

+

+

+**/

+BOOLEAN

+FileHandleValid (

+  IN EFI_OPEN_FILE  *File

+  )

+{

+  EFI_OPEN_FILE_GUARD  *GuardFile;

+

+  // Look right before and after file structure for the correct signatures

+  GuardFile = BASE_CR (File, EFI_OPEN_FILE_GUARD, File);

+  if ((GuardFile->Header != EFI_OPEN_FILE_GUARD_HEADER) ||

+    (GuardFile->Footer != EFI_OPEN_FILE_GUARD_FOOTER) ) {

+      return FALSE;

+    }

+

+    return TRUE;

+}

+

+/**

+Internal worker function. If Buffer is not NULL free it.

+

+@param  Buffer    Buffer to FreePool()

+

+**/

+VOID

+EblFreePool (

+  IN  VOID  *Buffer

+  )

+{

+  if (Buffer != NULL) {

+    FreePool (Buffer);

+  }

+}

+

+/**

+Update Device List Global Variables

+

+**/

+VOID

+EblUpdateDeviceLists (

+  VOID

+  )

+{

+  EFI_STATUS                        Status;

+  UINTN                             Size;

+  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL   *Fs;

+  EFI_FILE_HANDLE                   Root;

+  UINTN                             Index;

+

+  if (mBlkIo != NULL) {

+    FreePool (mBlkIo);

+  }

+  gBS->LocateHandleBuffer (ByProtocol, &gEfiBlockIoProtocolGuid, NULL, &mBlkIoCount, &mBlkIo);

+

+

+

+  if (mFv != NULL) {

+    FreePool (mFv);

+  }

+  gBS->LocateHandleBuffer (ByProtocol, &gEfiFirmwareVolume2ProtocolGuid, NULL, &mFvCount, &mFv);

+

+  if (mLoadFile != NULL) {

+    FreePool (mLoadFile);

+  }

+  gBS->LocateHandleBuffer (ByProtocol, &gEfiLoadFileProtocolGuid, NULL, &mLoadFileCount, &mLoadFile);

+

+  if (mFs != NULL) {

+    FreePool (mFs);

+  }

+

+  if (&mFsInfo[0] != NULL) {

+    // Need to Free the mFsInfo prior to recalculating mFsCount so don't move this code

+    for (Index = 0; Index < mFsCount; Index++) {

+      if (mFsInfo[Index] != NULL) {

+        FreePool (mFsInfo[Index]);

+      }

+    }

+    FreePool (mFsInfo);

+  }

+

+  gBS->LocateHandleBuffer (ByProtocol, &gEfiSimpleFileSystemProtocolGuid, NULL, &mFsCount, &mFs);

+

+

+  mFsInfo = AllocateZeroPool (mFsCount * sizeof (EFI_FILE_SYSTEM_INFO *));

+  if (mFsInfo == NULL) {

+    // If we can't do this then we can't support file system entries

+    mFsCount = 0;

+  } else {

+    // Loop through all the file system structures and cache the file system info data

+    for (Index =0; Index < mFsCount; Index++) {

+      Status = gBS->HandleProtocol (mFs[Index], &gEfiSimpleFileSystemProtocolGuid, (VOID **)&Fs);

+      if (!EFI_ERROR (Status)) {

+        Status = Fs->OpenVolume (Fs, &Root);

+        if (!EFI_ERROR (Status)) {

+          // Get information about the volume

+          Size = 0;

+          Status = Root->GetInfo (Root, &gEfiFileSystemInfoGuid, &Size, mFsInfo[Index]);

+          if (Status == EFI_BUFFER_TOO_SMALL) {

+            mFsInfo[Index] = AllocatePool (Size);

+            Status = Root->GetInfo (Root, &gEfiFileSystemInfoGuid, &Size, mFsInfo[Index]);

+          }

+

+          Root->Close (Root);

+        }

+      }

+    }

+  }

+}

+

+

+/**

+PathName is in the form <device name>:<path> for example fs1:\ or ROOT:\.

+Return TRUE if the <devce name> prefix of PathName matches a file system

+Volume Name. MatchIndex is the array  index in mFsInfo[] of the match, 

+and it can be used with mFs[] to find the handle that needs to be opened

+

+@param  PathName      PathName to check

+@param  FileStart     Index of the first character of the <path>

+@param  MatchIndex    Index in mFsInfo[] that matches

+

+@return TRUE      PathName matches a Volume Label and MatchIndex is valid

+@return FALSE     PathName does not match a Volume Label MatchIndex undefined

+

+**/

+BOOLEAN

+EblMatchVolumeName (

+  IN  CHAR8   *PathName,

+  IN  UINTN   FileStart,

+  OUT UINTN   *MatchIndex

+  )

+{

+  UINTN   Index;

+  UINTN   Compare;

+  UINTN   VolStrLen;

+  BOOLEAN Match;

+

+  for (Index =0; Index < mFsCount; Index++) {

+    if (mFsInfo[Index] == NULL) {

+      // FsInfo is not valid so skip it

+      continue;

+    }

+    VolStrLen = StrLen (mFsInfo[Index]->VolumeLabel);

+    for (Compare = 0, Match = TRUE; Compare < (FileStart - 1); Compare++) {

+      if (Compare > VolStrLen) {

+        Match = FALSE;

+        break;

+      }

+      if (PathName[Compare] != (CHAR8)mFsInfo[Index]->VolumeLabel[Compare]) {

+        // If the VolumeLabel has a space allow a _ to match with it in addition to ' '

+        if (!((PathName[Compare] == '_') && (mFsInfo[Index]->VolumeLabel[Compare] == L' '))) {

+          Match = FALSE;

+          break;

+        }

+      }

+    }

+    if (Match) {

+      *MatchIndex = Index;

+      return TRUE;

+    }

+  }

+

+  return FALSE;

+}

+

+

+/**

+Return the number of devices of the current type active in the system

+

+@param  Type      Device type to check

+

+@return 0         Invalid type

+

+**/

+UINTN

+EfiGetDeviceCounts (

+  IN  EFI_OPEN_FILE_TYPE     DeviceType

+  )

+{

+  switch (DeviceType) {

+  case EfiOpenLoadFile:

+    return mLoadFileCount;

+  case EfiOpenFirmwareVolume:

+    return mFvCount;

+  case EfiOpenFileSystem:

+    return mFsCount;

+  case EfiOpenBlockIo:

+    return mBlkIoCount;

+  default:

+    return 0;

+  }

+}

+

+EFI_STATUS

+ConvertIpStringToEfiIp (

+  IN  CHAR8           *PathName, 

+  OUT EFI_IP_ADDRESS  *ServerIp

+  )

+{

+  CHAR8     *Str;

+

+  Str = PathName;

+  ServerIp->v4.Addr[0] = (UINT8)AsciiStrDecimalToUintn (Str);

+

+  Str = AsciiStrStr (Str, ".");

+  if (Str == NULL) {

+    return EFI_DEVICE_ERROR;

+  }

+

+  ServerIp->v4.Addr[1] = (UINT8)AsciiStrDecimalToUintn (++Str);

+

+  Str = AsciiStrStr (Str, ".");

+  if (Str == NULL) {

+    return EFI_DEVICE_ERROR;

+  }

+

+  ServerIp->v4.Addr[2] = (UINT8)AsciiStrDecimalToUintn (++Str);

+

+  Str = AsciiStrStr (Str, ".");

+  if (Str == NULL) {

+    return EFI_DEVICE_ERROR;

+  }

+

+  ServerIp->v4.Addr[3] = (UINT8)AsciiStrDecimalToUintn (++Str);

+

+  return EFI_SUCCESS;

+}

+

+

+/**

+Internal work function to extract a device number from a string skipping 

+text. Easy way to extract numbers from strings like blk7:.

+

+@param  Str   String to extract device number form

+

+@return -1    Device string is not valid

+@return       Device #

+

+**/

+UINTN

+EblConvertDevStringToNumber (

+  IN  CHAR8   *Str

+  )

+{

+  UINTN   Max;

+  UINTN   Index;

+

+

+  // Find the first digit 

+  Max = AsciiStrLen (Str);

+  for  (Index = 0; !((*Str >= '0') && (*Str <= '9')) && (Index < Max); Index++) {

+    Str++;

+  }

+  if (Index == Max) {

+    return (UINTN)-1;

+  }

+

+  return AsciiStrDecimalToUintn (Str);

+}

+

+

+/**

+Internal work function to fill in EFI_OPEN_FILE information for the Fs and BlkIo

+

+@param  File        Open file handle

+@param  FileName    Name of file after device stripped off

+

+

+**/

+EFI_STATUS

+EblFileDevicePath (

+  IN OUT EFI_OPEN_FILE  *File,

+  IN  CHAR8             *FileName,

+  IN  CONST UINT64      OpenMode

+  )

+{

+  EFI_STATUS                        Status;

+  UINTN                             Size;

+  FILEPATH_DEVICE_PATH              *FilePath;

+  EFI_DEVICE_PATH_PROTOCOL          *FileDevicePath;

+  CHAR16                            UnicodeFileName[MAX_PATHNAME];

+  EFI_BLOCK_IO_PROTOCOL             *BlkIo;

+  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL   *Fs;

+  EFI_FILE_HANDLE                   Root;

+

+

+  if ( *FileName != 0 ) {

+    AsciiStrToUnicodeStr (FileName, UnicodeFileName);

+  } else {

+    AsciiStrToUnicodeStr ("\\", UnicodeFileName);

+  }

+

+  Size = StrSize (UnicodeFileName);

+  FileDevicePath = AllocatePool (Size + SIZE_OF_FILEPATH_DEVICE_PATH + sizeof (EFI_DEVICE_PATH_PROTOCOL));

+  if (FileDevicePath != NULL) {

+    FilePath = (FILEPATH_DEVICE_PATH *) FileDevicePath;

+    FilePath->Header.Type    = MEDIA_DEVICE_PATH;

+    FilePath->Header.SubType = MEDIA_FILEPATH_DP;

+    CopyMem (&FilePath->PathName, UnicodeFileName, Size);

+    SetDevicePathNodeLength (&FilePath->Header, Size + SIZE_OF_FILEPATH_DEVICE_PATH);

+    SetDevicePathEndNode (NextDevicePathNode (&FilePath->Header));

+

+    if (File->EfiHandle != NULL) {

+      File->DevicePath = DevicePathFromHandle (File->EfiHandle);

+    }

+

+    File->DevicePath = AppendDevicePath (File->DevicePath, FileDevicePath);

+    FreePool (FileDevicePath);

+  }

+

+  Status = gBS->HandleProtocol (File->EfiHandle, &gEfiBlockIoProtocolGuid, (VOID **)&BlkIo);

+  if (!EFI_ERROR (Status)) {

+    File->FsBlockIoMedia = BlkIo->Media;

+    File->FsBlockIo = BlkIo;

+

+    // If we are not opening the device this will get over written with file info

+    File->MaxPosition = MultU64x32 (BlkIo->Media->LastBlock + 1, BlkIo->Media->BlockSize);

+  }

+

+  if (File->Type == EfiOpenFileSystem) {

+    Status = gBS->HandleProtocol (File->EfiHandle, &gEfiSimpleFileSystemProtocolGuid, (VOID **)&Fs);

+    if (!EFI_ERROR (Status)) {

+      Status = Fs->OpenVolume (Fs, &Root);

+      if (!EFI_ERROR (Status)) {

+        // Get information about the volume

+        Size = 0;

+        Status = Root->GetInfo (Root, &gEfiFileSystemInfoGuid, &Size, File->FsInfo);

+        if (Status == EFI_BUFFER_TOO_SMALL) {

+          File->FsInfo = AllocatePool (Size);

+          Status = Root->GetInfo (Root, &gEfiFileSystemInfoGuid, &Size, File->FsInfo);

+        }

+

+        // Get information about the file

+        Status = Root->Open (Root, &File->FsFileHandle, UnicodeFileName, OpenMode, 0);

+        if (!EFI_ERROR (Status)) {

+          Size = 0;

+          Status = File->FsFileHandle->GetInfo (File->FsFileHandle, &gEfiFileInfoGuid, &Size, NULL);

+          if (Status == EFI_BUFFER_TOO_SMALL) {

+            File->FsFileInfo = AllocatePool (Size);

+            Status = File->FsFileHandle->GetInfo (File->FsFileHandle, &gEfiFileInfoGuid, &Size, File->FsFileInfo);

+            if (!EFI_ERROR (Status)) {

+              File->Size = (UINTN)File->FsFileInfo->FileSize;

+              File->MaxPosition = (UINT64)File->Size;

+            }

+          }

+        }

+

+        Root->Close (Root);

+      }

+    }

+  } else if (File->Type == EfiOpenBlockIo) {

+    File->Size = (UINTN)File->MaxPosition;

+  }

+

+  return Status;

+}

+

+#define ToUpper(a)  ((((a) >= 'a') && ((a) <= 'z')) ? ((a) - 'a' + 'A') : (a))

+

+EFI_STATUS

+CompareGuidToString (

+  IN  EFI_GUID    *Guid,

+  IN  CHAR8       *String

+  )

+{

+  CHAR8       AsciiGuid[64];

+  CHAR8       *StringPtr;

+  CHAR8       *GuidPtr;

+

+  AsciiSPrint (AsciiGuid, sizeof(AsciiGuid), "%g", Guid);

+

+  StringPtr = String;

+  GuidPtr   = AsciiGuid;

+

+  while ((*StringPtr != '\0') && (*GuidPtr != '\0')) {

+    // Skip dashes

+    if (*StringPtr == '-') {

+      StringPtr++;

+      continue;

+    }

+

+    if (*GuidPtr == '-') {

+      GuidPtr++;

+      continue;

+    }

+

+    if (ToUpper(*StringPtr) != ToUpper(*GuidPtr)) {

+      return EFI_NOT_FOUND;

+    }

+

+    StringPtr++;

+    GuidPtr++;

+  }

+

+  return EFI_SUCCESS;

+}

+

+

+/**

+Internal work function to fill in EFI_OPEN_FILE information for the FV

+

+@param  File        Open file handle

+@param  FileName    Name of file after device stripped off

+

+

+**/

+EFI_STATUS

+EblFvFileDevicePath (

+  IN OUT EFI_OPEN_FILE  *File,

+  IN  CHAR8             *FileName,

+  IN  CONST UINT64      OpenMode

+  )

+{

+  EFI_STATUS                          Status;

+  EFI_STATUS                          GetNextFileStatus;

+  MEDIA_FW_VOL_FILEPATH_DEVICE_PATH   DevicePathNode;

+  EFI_DEVICE_PATH_PROTOCOL            *DevicePath;

+  UINTN                               Key;

+  UINT32                              AuthenticationStatus;

+  CHAR8                               AsciiSection[MAX_PATHNAME];

+  VOID                                *Section;

+  UINTN                               SectionSize;

+  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *Fvb;

+  EFI_LBA                             Lba;

+  UINTN                               BlockSize;

+  UINTN                               NumberOfBlocks;

+  EFI_FIRMWARE_VOLUME_HEADER          *FvHeader = NULL;

+  UINTN                               Index;

+

+

+  Status = gBS->HandleProtocol (File->EfiHandle, &gEfiFirmwareVolume2ProtocolGuid, (VOID **)&File->Fv);

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+

+  // Get FVB Info about the handle

+  Status = gBS->HandleProtocol (File->EfiHandle, &gEfiFirmwareVolumeBlockProtocolGuid, (VOID **)&Fvb);

+  if (!EFI_ERROR (Status)) {

+    Status = Fvb->GetPhysicalAddress (Fvb, &File->FvStart);

+    if (!EFI_ERROR (Status)) {

+      FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *)(UINTN)File->FvStart;

+      File->FvHeaderSize = sizeof (EFI_FIRMWARE_VOLUME_HEADER);

+      for (Index = 0; FvHeader->BlockMap[Index].Length !=0; Index++) {

+        File->FvHeaderSize += sizeof (EFI_FV_BLOCK_MAP_ENTRY);

+      }

+

+      for (Lba = 0, File->FvSize = 0, NumberOfBlocks = 0; ; File->FvSize += (BlockSize * NumberOfBlocks), Lba += NumberOfBlocks) {

+        Status = Fvb->GetBlockSize (Fvb, Lba, &BlockSize, &NumberOfBlocks);

+        if (EFI_ERROR (Status)) {

+          break;

+        }

+      }

+    }

+  }

+

+

+  DevicePath = DevicePathFromHandle (File->EfiHandle);

+

+  if (*FileName == '\0') {

+    File->DevicePath = DuplicateDevicePath (DevicePath);

+    File->Size = File->FvSize;

+    File->MaxPosition = File->Size;

+  } else {

+    Key = 0;

+    do {

+      File->FvType = EFI_FV_FILETYPE_ALL;

+      GetNextFileStatus = File->Fv->GetNextFile (

+        File->Fv, 

+        &Key,

+        &File->FvType,  

+        &File->FvNameGuid, 

+        &File->FvAttributes, 

+        &File->Size

+        );

+      if (!EFI_ERROR (GetNextFileStatus)) {

+        // Compare GUID first

+        Status = CompareGuidToString (&File->FvNameGuid, FileName);

+        if (!EFI_ERROR(Status)) {

+          break;

+        }

+

+        Section = NULL;

+        Status = File->Fv->ReadSection (

+          File->Fv,

+          &File->FvNameGuid,

+          EFI_SECTION_USER_INTERFACE,

+          0,

+          &Section,

+          &SectionSize,

+          &AuthenticationStatus

+          );

+        if (!EFI_ERROR (Status)) {

+          UnicodeStrToAsciiStr (Section, AsciiSection);

+          if (AsciiStriCmp (FileName, AsciiSection) == 0) {

+            FreePool (Section);

+            break;

+          }

+          FreePool (Section);

+        }

+      }

+    } while (!EFI_ERROR (GetNextFileStatus));

+

+    if (EFI_ERROR (GetNextFileStatus)) {

+      return GetNextFileStatus;

+    }

+

+    if (OpenMode != EFI_SECTION_ALL) {

+      // Calculate the size of the section we are targeting

+      Section = NULL;

+      File->Size = 0;

+      Status = File->Fv->ReadSection (

+        File->Fv,

+        &File->FvNameGuid,

+        (EFI_SECTION_TYPE)OpenMode,

+        0,

+        &Section,

+        &File->Size,

+        &AuthenticationStatus

+        );

+      if (EFI_ERROR (Status)) {

+        return Status;

+      }

+    }

+

+    File->MaxPosition = File->Size;

+    EfiInitializeFwVolDevicepathNode (&DevicePathNode, &File->FvNameGuid);

+    File->DevicePath = AppendDevicePathNode (DevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&DevicePathNode);

+  }

+

+

+  // FVB not required if FV was soft loaded...

+  return EFI_SUCCESS;

+}

+

+

+

+

+/**

+Open a device named by PathName. The PathName includes a device name and 

+path separated by a :. See file header for more details on the PathName

+syntax. There is no checking to prevent a file from being opened more than

+one type. 

+

+SectionType is only used to open an FV. Each file in an FV contains multiple

+sections and only the SectionType section is opened.

+

+For any file that is opened with EfiOpen() must be closed with EfiClose().

+

+@param  PathName    Path to parse to open 

+@param  OpenMode    Same as EFI_FILE.Open()

+@param  SectionType Section in FV to open.

+

+@return NULL  Open failed

+@return Valid EFI_OPEN_FILE handle

+

+**/

+EFI_OPEN_FILE *

+EfiOpen (

+  IN        CHAR8               *PathName,

+  IN  CONST UINT64              OpenMode,

+  IN  CONST EFI_SECTION_TYPE    SectionType

+  )

+{

+  EFI_STATUS                Status;

+  EFI_OPEN_FILE             *File;

+  EFI_OPEN_FILE             FileData;

+  UINTN                     StrLen;

+  UINTN                     FileStart;

+  UINTN                     DevNumber = 0;

+  EFI_OPEN_FILE_GUARD       *GuardFile;

+  BOOLEAN                   VolumeNameMatch;

+  EFI_DEVICE_PATH_PROTOCOL  *DevicePath;

+  UINTN                     Size;

+  EFI_IP_ADDRESS            Ip;

+  CHAR8                     *CwdPlusPathName;

+  UINTN                     Index;

+  EFI_SECTION_TYPE          ModifiedSectionType;

+

+  EblUpdateDeviceLists ();

+

+  File = &FileData;

+  ZeroMem (File, sizeof (EFI_OPEN_FILE));

+

+  StrLen = AsciiStrSize (PathName);

+  if (StrLen <= 1) {

+    // Smallest valid path is 1 char and a null

+    return NULL;

+  }

+

+  for (FileStart = 0; FileStart < StrLen; FileStart++) {

+    if (PathName[FileStart] == ':') {

+      FileStart++;

+      break;

+    }

+  }

+

+  //

+  // Matching volume name has precedence over handle based names

+  //

+  VolumeNameMatch = EblMatchVolumeName (PathName, FileStart, &DevNumber);

+  if (!VolumeNameMatch) {

+    if (FileStart == StrLen) {

+      // No Volume name or device name, so try Current Working Directory

+      if (gCwd == NULL) {

+        // No CWD

+        return NULL;

+      }

+

+      // We could add a current working directory concept

+      CwdPlusPathName = AllocatePool (AsciiStrSize (gCwd) + AsciiStrSize (PathName));

+      if (CwdPlusPathName == NULL) {

+        return NULL;

+      }

+

+      if ((PathName[0] == '/') || (PathName[0] == '\\')) {

+        // PathName starts in / so this means we go to the root of the device in the CWD. 

+        CwdPlusPathName[0] = '\0';

+        for (FileStart = 0; gCwd[FileStart] != '\0'; FileStart++) {

+          CwdPlusPathName[FileStart] = gCwd[FileStart];

+          if (gCwd[FileStart] == ':') {

+            FileStart++;

+            CwdPlusPathName[FileStart] = '\0';

+            break;

+          }

+        }

+      } else {

+        AsciiStrCpy (CwdPlusPathName, gCwd);

+        StrLen = AsciiStrLen (gCwd);

+        if ((*PathName != '/') && (*PathName != '\\') && (gCwd[StrLen-1] != '/') && (gCwd[StrLen-1] != '\\')) {

+          AsciiStrCat (CwdPlusPathName, "\\");

+        }

+      }

+

+      AsciiStrCat (CwdPlusPathName, PathName);

+      if (AsciiStrStr (CwdPlusPathName, ":") == NULL) {

+        // Extra error check to make sure we don't recurse and blow stack

+        return NULL;

+      }

+

+      File = EfiOpen (CwdPlusPathName, OpenMode, SectionType);

+      FreePool (CwdPlusPathName);

+      return File;

+    }

+

+    DevNumber = EblConvertDevStringToNumber ((CHAR8 *)PathName); 

+  }

+

+  File->DeviceName = AllocatePool (StrLen);

+  AsciiStrCpy (File->DeviceName, PathName);

+  File->DeviceName[FileStart - 1] = '\0';

+  File->FileName = &File->DeviceName[FileStart];

+  if (File->FileName[0] == '\0') {

+    // if it is just a file name use / as root

+    File->FileName = "\\";

+  } 

+

+  //

+  // Use best match algorithm on the dev names so we only need to look at the

+  // first few charters to match the full device name. Short name forms are 

+  // legal from the caller.

+  //

+  Status = EFI_SUCCESS;

+  if (*PathName == 'f' || *PathName == 'F' || VolumeNameMatch) {

+    if (PathName[1] == 's' || PathName[1] == 'S' || VolumeNameMatch) {

+      if (DevNumber >= mFsCount) {

+        goto ErrorExit;

+      }

+      File->Type = EfiOpenFileSystem;

+      File->EfiHandle = mFs[DevNumber];

+      Status = EblFileDevicePath (File, &PathName[FileStart], OpenMode);

+

+    } else if (PathName[1] == 'v' || PathName[1] == 'V') { 

+      if (DevNumber >= mFvCount) {

+        goto ErrorExit;

+      }

+      File->Type = EfiOpenFirmwareVolume;

+      File->EfiHandle = mFv[DevNumber];

+

+      if ((PathName[FileStart] == '/') || (PathName[FileStart] == '\\')) {

+        // Skip leading / as its not really needed for the FV since no directories are supported

+        FileStart++;

+      }

+

+      // Check for 2nd :

+      ModifiedSectionType = SectionType;

+      for (Index = FileStart; PathName[Index] != '\0'; Index++) {

+        if (PathName[Index] == ':') {

+          // Support fv0:\DxeCore:0x10

+          // This means open the PE32 Section of the file 

+          ModifiedSectionType = (EFI_SECTION_TYPE)AsciiStrHexToUintn (&PathName[Index + 1]);

+          PathName[Index] = '\0';

+        }

+      }

+      File->FvSectionType = ModifiedSectionType;

+      Status = EblFvFileDevicePath (File, &PathName[FileStart], ModifiedSectionType);

+    }

+  } else if ((*PathName == 'A') || (*PathName == 'a')) {

+    // Handle a:0x10000000:0x1234 address form a:ADDRESS:SIZE

+    File->Type = EfiOpenMemoryBuffer;

+    // 1st colon is at PathName[FileStart - 1]

+    File->Buffer = (VOID *)AsciiStrHexToUintn (&PathName[FileStart]);

+

+    // Find 2nd colon

+    while ((PathName[FileStart] != ':') && (PathName[FileStart] != '\0')) {

+      FileStart++;

+    }

+

+    // If we ran out of string, there's no extra data

+    if (PathName[FileStart] == '\0') {

+      File->Size = 0;

+    } else {

+      File->Size = AsciiStrHexToUintn (&PathName[FileStart + 1]);

+    }

+

+    // if there's no number after the second colon, default

+    // the end of memory

+    if (File->Size == 0) {

+      File->Size =  (UINTN)(0 - (UINTN)File->Buffer);

+    }

+

+    File->MaxPosition = File->Size;

+    File->BaseOffset = (UINTN)File->Buffer;

+

+  } else if (*PathName== 'l' || *PathName == 'L') {

+    if (DevNumber >= mLoadFileCount) {

+      goto ErrorExit;

+    }

+    File->Type = EfiOpenLoadFile;

+    File->EfiHandle = mLoadFile[DevNumber];

+

+    Status = gBS->HandleProtocol (File->EfiHandle, &gEfiLoadFileProtocolGuid, (VOID **)&File->LoadFile);

+    if (EFI_ERROR (Status)) {

+      goto ErrorExit;

+    }

+

+    Status = gBS->HandleProtocol (File->EfiHandle, &gEfiDevicePathProtocolGuid, (VOID **)&DevicePath);

+    if (EFI_ERROR (Status)) {

+      goto ErrorExit;

+    }

+    File->DevicePath = DuplicateDevicePath (DevicePath);

+

+  } else if (*PathName == 'b' || *PathName == 'B') {

+    // Handle b#:0x10000000:0x1234 address form b#:ADDRESS:SIZE

+    if (DevNumber >= mBlkIoCount) {

+      goto ErrorExit;

+    }

+    File->Type = EfiOpenBlockIo;

+    File->EfiHandle = mBlkIo[DevNumber];

+    EblFileDevicePath (File, "", OpenMode);

+

+    // 1st colon is at PathName[FileStart - 1]

+    File->DiskOffset = AsciiStrHexToUintn (&PathName[FileStart]);

+

+    // Find 2nd colon

+    while ((PathName[FileStart] != ':') && (PathName[FileStart] != '\0')) {

+      FileStart++;

+    }

+

+    // If we ran out of string, there's no extra data

+    if (PathName[FileStart] == '\0') {

+      Size = 0;

+    } else {

+      Size = AsciiStrHexToUintn (&PathName[FileStart + 1]);

+    }

+

+    // if a zero size is passed in (or the size is left out entirely),

+    // go to the end of the device.

+    if (Size == 0) {

+      File->Size = File->Size - File->DiskOffset;

+    } else {

+      File->Size = Size;

+    }

+

+    File->MaxPosition = File->Size;

+    File->BaseOffset = File->DiskOffset;

+  } else if ((*PathName) >= '0' && (*PathName <= '9')) {

+

+    // Get current IP address

+    Status = EblGetCurrentIpAddress (&Ip);

+    if (EFI_ERROR(Status)) {

+      AsciiPrint("Device IP Address is not configured.\n");

+      goto ErrorExit;

+    }

+

+

+    // Parse X.X.X.X:Filename, only support IPv4 TFTP for now...

+    File->Type = EfiOpenTftp;

+    File->IsDirty = FALSE;

+    File->IsBufferValid = FALSE;

+

+    Status = ConvertIpStringToEfiIp (PathName, &File->ServerIp);

+  }

+

+  if (EFI_ERROR (Status)) {

+    goto ErrorExit;

+  }

+

+  GuardFile = (EFI_OPEN_FILE_GUARD *)AllocateZeroPool (sizeof (EFI_OPEN_FILE_GUARD));

+  if (GuardFile == NULL) {

+    goto ErrorExit;

+  }

+

+  GuardFile->Header = EFI_OPEN_FILE_GUARD_HEADER;

+  CopyMem (&(GuardFile->File), &FileData, sizeof (EFI_OPEN_FILE));

+  GuardFile->Footer = EFI_OPEN_FILE_GUARD_FOOTER;

+

+  return &(GuardFile->File);

+

+ErrorExit:

+  FreePool (File->DeviceName);

+  return NULL;

+}

+

+#define FILE_COPY_CHUNK 0x01000000

+

+EFI_STATUS

+EfiCopyFile (

+  IN        CHAR8               *DestinationFile,

+  IN        CHAR8               *SourceFile

+  )

+{

+  EFI_OPEN_FILE *Source      = NULL;

+  EFI_OPEN_FILE *Destination = NULL;

+  EFI_STATUS    Status       = EFI_SUCCESS;

+  VOID          *Buffer      = NULL;

+  UINTN         Size;

+  UINTN         Offset;

+  UINTN         Chunk = FILE_COPY_CHUNK;

+

+  Source = EfiOpen (SourceFile, EFI_FILE_MODE_READ, 0);

+  if (Source == NULL) {

+    AsciiPrint("Source file open error.\n");

+    Status = EFI_NOT_FOUND;

+    goto Exit;

+  }

+

+  Destination = EfiOpen (DestinationFile, EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE, 0);

+  if (Destination == NULL) {

+    AsciiPrint("Destination file open error.\n");

+    Status = EFI_NOT_FOUND;

+    goto Exit;

+  }

+

+  Buffer = AllocatePool(FILE_COPY_CHUNK);

+  if (Buffer == NULL) {

+    Status = EFI_OUT_OF_RESOURCES;

+    goto Exit;

+  }

+

+  Size = EfiTell(Source, NULL);

+

+  for (Offset = 0; Offset + FILE_COPY_CHUNK <= Size; Offset += Chunk) {

+    Chunk = FILE_COPY_CHUNK;

+

+    Status = EfiRead(Source, Buffer, &Chunk);

+    if (EFI_ERROR(Status)) {

+      AsciiPrint("Read file error %r\n", Status);

+      goto Exit;

+    }

+

+    Status = EfiWrite(Destination, Buffer, &Chunk);

+    if (EFI_ERROR(Status)) {

+      AsciiPrint("Write file error %r\n", Status);

+      goto Exit;

+    }    

+  }

+

+  // Any left over?

+  if (Offset < Size) {

+    Chunk = Size - Offset;

+

+    Status = EfiRead(Source, Buffer, &Chunk);

+    if (EFI_ERROR(Status)) {

+      AsciiPrint("Read file error\n");

+      goto Exit;

+    }

+

+    Status = EfiWrite(Destination, Buffer, &Chunk);

+    if (EFI_ERROR(Status)) {

+      AsciiPrint("Write file error\n");

+      goto Exit;

+    }    

+  }

+

+Exit:

+  if (Source != NULL) {

+    Status = EfiClose(Source);

+    if (EFI_ERROR(Status)) {

+      AsciiPrint("Source close error");

+    }

+  }

+

+  if (Destination != NULL) {

+    Status = EfiClose(Destination);

+    if (EFI_ERROR(Status)) {

+      AsciiPrint("Destination close error");

+    }

+  }

+

+  if (Buffer != NULL) {

+    FreePool(Buffer);

+  }

+

+  return Status;

+}

+

+/**

+Use DeviceType and Index to form a valid PathName and try and open it.

+

+@param  DeviceType  Device type to open

+@param  Index       Device Index to use. Zero relative.

+

+@return NULL  Open failed

+@return Valid EFI_OPEN_FILE handle

+

+**/

+EFI_OPEN_FILE  *

+EfiDeviceOpenByType (

+  IN  EFI_OPEN_FILE_TYPE    DeviceType,

+  IN  UINTN                 Index

+  )

+{

+  CHAR8   *DevStr;

+  CHAR8   Path[MAX_CMD_LINE];

+

+  switch (DeviceType) {

+  case EfiOpenLoadFile:

+    DevStr = "loadfile%d:";

+    break;

+  case EfiOpenFirmwareVolume:

+    DevStr = "fv%d:";    

+    break;

+  case EfiOpenFileSystem:

+    DevStr = "fs%d:";    

+    break;

+  case EfiOpenBlockIo:

+    DevStr = "blk%d:";    

+    break;

+  case EfiOpenMemoryBuffer:

+    DevStr = "a%d:";    

+    break;

+  default:

+    return NULL;

+  }

+

+  AsciiSPrint (Path, MAX_PATHNAME, DevStr, Index);

+

+  return EfiOpen (Path, EFI_FILE_MODE_READ, 0);

+}

+

+

+/**

+Close a file handle opened by EfiOpen() and free all resources allocated by

+EfiOpen().

+

+@param  Stream    Open File Handle

+

+@return EFI_INVALID_PARAMETER  Stream is not an Open File

+@return EFI_SUCCESS            Steam closed

+

+**/

+EFI_STATUS

+EfiClose (

+  IN  EFI_OPEN_FILE     *File

+  )

+{

+  EFI_STATUS          Status;

+  UINT64              TftpBufferSize;

+

+  if (!FileHandleValid (File)) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  //Write the buffer contents to TFTP file.

+  if ((File->Type == EfiOpenTftp) && (File->IsDirty)) {

+

+    TftpBufferSize = File->Size;

+    Status = EblMtftp (

+      EFI_PXE_BASE_CODE_TFTP_WRITE_FILE, 

+      File->Buffer, 

+      TRUE, 

+      &TftpBufferSize, 

+      NULL, 

+      &File->ServerIp, 

+      (UINT8 *)File->FileName, 

+      NULL, 

+      FALSE

+      );

+    if (EFI_ERROR(Status)) {

+      AsciiPrint("TFTP error during APPLE_NSP_TFTP_WRITE_FILE: %r\n", Status);

+      return Status;

+    }

+  }

+

+  if ((File->Type == EfiOpenLoadFile) || 

+    ((File->Type == EfiOpenTftp) && (File->IsBufferValid == TRUE)) ||

+    ((File->Type == EfiOpenFirmwareVolume) && (File->IsBufferValid == TRUE))) {

+    EblFreePool(File->Buffer);

+  }

+

+  EblFreePool (File->DevicePath);

+  EblFreePool (File->DeviceName);

+  EblFreePool (File->FsFileInfo);

+  EblFreePool (File->FsInfo);

+

+  if (File->FsFileHandle != NULL) {

+    File->FsFileHandle->Close (File->FsFileHandle);

+  }

+

+  // Need to free File and it's Guard structures

+  EblFreePool (BASE_CR (File, EFI_OPEN_FILE_GUARD, File));

+  return EFI_SUCCESS;

+}

+

+

+/**

+Return the size of the file represented by Stream. Also return the current 

+Seek position. Opening a file will enable a valid file size to be returned.

+LoadFile is an exception as a load file size is set to zero. 

+

+@param  Stream    Open File Handle

+

+@return 0         Stream is not an Open File or a valid LoadFile handle

+

+**/

+UINTN

+EfiTell (

+  IN  EFI_OPEN_FILE     *File,

+  OUT EFI_LBA           *CurrentPosition    OPTIONAL

+  )

+{

+  EFI_STATUS Status;

+  UINT64     BufferSize = 0;

+

+  if (!FileHandleValid (File)) {

+    return 0;

+  }

+

+  if (CurrentPosition != NULL) {

+    *CurrentPosition = File->CurrentPosition;

+  }

+

+  if (File->Type == EfiOpenLoadFile) {

+    // Figure out the File->Size

+    File->Buffer = NULL;

+    File->Size   = 0;

+    Status = File->LoadFile->LoadFile (File->LoadFile, File->DevicePath, FALSE, &File->Size, File->Buffer);

+    if (Status != EFI_BUFFER_TOO_SMALL) {

+      return 0;

+    }

+

+    File->MaxPosition = (UINT64)File->Size;

+  } else if (File->Type == EfiOpenTftp) {

+

+    Status = EblMtftp (

+      EFI_PXE_BASE_CODE_TFTP_GET_FILE_SIZE,

+      NULL,

+      FALSE,

+      &BufferSize,

+      NULL,

+      &File->ServerIp,

+      (UINT8 *)File->FileName,

+      NULL,

+      TRUE

+      );

+    if (EFI_ERROR(Status)) {

+      AsciiPrint("TFTP error during APPLE_NSP_TFTP_GET_FILE_SIZE: %r\n", Status);

+      return 0;

+    }

+

+    File->Size        = (UINTN)BufferSize;

+    File->MaxPosition = File->Size;

+  }

+

+  return File->Size;

+}

+

+

+/**

+Seek to the Offset location in the file. LoadFile and FV device types do

+not support EfiSeek(). It is not possible to grow the file size using 

+EfiSeek().

+

+SeekType defines how use Offset to calculate the new file position:

+EfiSeekStart  : Position = Offset

+EfiSeekCurrent: Position is Offset bytes from the current position

+EfiSeekEnd    : Only supported if Offset is zero to seek to end of file.

+

+@param  Stream    Open File Handle

+@param  Offset    Offset to seek too. 

+@param  SeekType  Type of seek to perform

+

+

+@return EFI_INVALID_PARAMETER  Stream is not an Open File

+@return EFI_UNSUPPORTED        LoadFile and FV do not support Seek

+@return EFI_NOT_FOUND          Seek past the end of the file.

+@return EFI_SUCCESS            Steam closed

+

+**/

+EFI_STATUS

+EfiSeek (

+  IN  EFI_OPEN_FILE     *File,

+  IN  EFI_LBA           Offset,

+  IN  EFI_SEEK_TYPE     SeekType

+  )

+{

+  EFI_STATUS    Status;

+  UINT64        CurrentPosition;

+

+  if (!FileHandleValid (File)) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  if (File->Type == EfiOpenLoadFile) {

+    // LoadFile does not support Seek

+    return EFI_UNSUPPORTED;

+  }

+

+  CurrentPosition = File->CurrentPosition;

+  switch (SeekType) {

+  case EfiSeekStart:

+    if (Offset > File->MaxPosition) {

+      return EFI_NOT_FOUND;

+    }

+    CurrentPosition = Offset;

+    break;

+

+  case EfiSeekCurrent:

+    if ((File->CurrentPosition + Offset) > File->MaxPosition) {

+      return EFI_NOT_FOUND;

+    }

+    CurrentPosition += Offset;

+    break;

+

+  case EfiSeekEnd:

+    if (Offset != 0) {

+      // We don't support growing file size via seeking past end of file

+      return EFI_UNSUPPORTED;

+    }

+    CurrentPosition = File->MaxPosition;

+    break;

+

+  default:

+    return EFI_NOT_FOUND;

+  }

+

+  Status = EFI_SUCCESS;

+  if (File->FsFileHandle != NULL) {

+    Status = File->FsFileHandle->SetPosition (File->FsFileHandle, CurrentPosition);

+  }

+

+  if (!EFI_ERROR (Status)) {

+    File->CurrentPosition = CurrentPosition;

+  }

+

+  return Status;

+}

+

+EFI_STATUS

+CacheTftpFile (

+  IN OUT  EFI_OPEN_FILE *File

+  )

+{

+  EFI_STATUS          Status;

+  UINT64              TftpBufferSize;

+

+  if (File->IsBufferValid) {

+    return EFI_SUCCESS;

+  }

+

+  // Make sure the file size is set.

+  EfiTell (File, NULL);

+

+  //Allocate a buffer to hold the whole file.

+  File->Buffer = AllocatePool(File->Size);

+  if (File->Buffer == NULL) {

+    return EFI_OUT_OF_RESOURCES;

+  }

+

+  TftpBufferSize = File->Size;

+

+  Status = EblMtftp (

+    EFI_PXE_BASE_CODE_TFTP_READ_FILE, 

+    File->Buffer, 

+    FALSE, 

+    &TftpBufferSize, 

+    NULL, 

+    &File->ServerIp, 

+    (UINT8 *)File->FileName, 

+    NULL, 

+    FALSE);

+  if (EFI_ERROR(Status)) {

+    AsciiPrint("TFTP error during APPLE_NSP_TFTP_READ_FILE: %r\n", Status);

+    FreePool(File->Buffer);

+    return Status;

+  }

+

+  // Set the buffer valid flag.

+  File->IsBufferValid = TRUE;

+

+  return Status;

+}

+

+/**

+Read BufferSize bytes from the current location in the file. For load file,

+FV, and TFTP case you must read the entire file. 

+

+@param  Stream      Open File Handle

+@param  Buffer      Caller allocated buffer. 

+@param  BufferSize  Size of buffer in bytes.

+

+

+@return EFI_SUCCESS           Stream is not an Open File

+@return EFI_END_OF_FILE Tried to read past the end of the file

+@return EFI_INVALID_PARAMETER Stream is not an open file handle

+@return EFI_BUFFER_TOO_SMALL  Buffer is not big enough to do the read

+@return "other"               Error returned from device read

+

+**/

+EFI_STATUS

+EfiRead (

+  IN  EFI_OPEN_FILE       *File,

+  OUT VOID                *Buffer,

+  OUT UINTN               *BufferSize

+  )

+{

+  EFI_STATUS            Status;

+  UINT32                AuthenticationStatus;

+  EFI_DISK_IO_PROTOCOL  *DiskIo;

+

+  if (!FileHandleValid (File)) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  // Don't read past the end of the file.

+  if ((File->CurrentPosition + *BufferSize) > File->MaxPosition) {

+    return EFI_END_OF_FILE;

+  }

+

+  switch (File->Type) {

+  case EfiOpenLoadFile:

+    // Figure out the File->Size

+    EfiTell (File, NULL);

+

+    Status = File->LoadFile->LoadFile (File->LoadFile, File->DevicePath, FALSE, BufferSize, Buffer);

+    break;

+

+  case EfiOpenFirmwareVolume:

+    if (CompareGuid (&File->FvNameGuid, &gZeroGuid)) {

+      // This is the entire FV device, so treat like a memory buffer 

+      CopyMem (Buffer, (VOID *)(UINTN)(File->FvStart + File->CurrentPosition), *BufferSize);

+      File->CurrentPosition += *BufferSize;

+      Status = EFI_SUCCESS;

+    } else {

+      if (File->Buffer == NULL) {

+        if (File->FvSectionType == EFI_SECTION_ALL) {

+          Status = File->Fv->ReadFile (

+            File->Fv,

+            &File->FvNameGuid,

+            (VOID **)&File->Buffer,

+            &File->Size,

+            &File->FvType,

+            &File->FvAttributes,

+            &AuthenticationStatus

+            );

+        } else {

+          Status = File->Fv->ReadSection (

+            File->Fv,

+            &File->FvNameGuid,

+            File->FvSectionType,

+            0,

+            (VOID **)&File->Buffer,

+            &File->Size,

+            &AuthenticationStatus

+            );

+        }

+        if (EFI_ERROR (Status)) {

+          return Status;

+        }

+        File->IsBufferValid = TRUE;

+      }

+      // Operate on the cached buffer so Seek will work

+      CopyMem (Buffer, File->Buffer + File->CurrentPosition, *BufferSize);

+      File->CurrentPosition += *BufferSize;

+      Status = EFI_SUCCESS;

+    }

+    break;

+

+  case EfiOpenMemoryBuffer:

+    CopyMem (Buffer, File->Buffer + File->CurrentPosition, *BufferSize);

+    File->CurrentPosition += *BufferSize;

+    Status = EFI_SUCCESS;

+    break;

+

+  case EfiOpenFileSystem:

+    Status = File->FsFileHandle->Read (File->FsFileHandle, BufferSize, Buffer);

+    File->CurrentPosition += *BufferSize;

+    break;

+

+  case EfiOpenBlockIo:

+    Status = gBS->HandleProtocol(File->EfiHandle, &gEfiDiskIoProtocolGuid, (VOID **)&DiskIo);

+    if (!EFI_ERROR(Status)) {

+      Status = DiskIo->ReadDisk(DiskIo, File->FsBlockIoMedia->MediaId, File->DiskOffset + File->CurrentPosition, *BufferSize, Buffer);

+    }

+    File->CurrentPosition += *BufferSize;

+    break;

+

+  case EfiOpenTftp:

+    // Cache the file if it hasn't been cached yet.

+    if (File->IsBufferValid == FALSE) {

+      Status = CacheTftpFile (File);

+      if (EFI_ERROR (Status)) {

+        return Status;

+      }

+    }

+

+    // Copy out the requested data

+    CopyMem (Buffer, File->Buffer + File->CurrentPosition, *BufferSize);

+    File->CurrentPosition += *BufferSize;

+

+    Status = EFI_SUCCESS;

+    break;

+

+  default:

+    return EFI_INVALID_PARAMETER;

+  };

+

+  return Status;

+}

+

+

+/**

+Read the entire file into a buffer. This routine allocates the buffer and

+returns it to the user full of the read data. 

+

+This is very useful for load file where it's hard to know how big the buffer

+must be.

+

+@param  Stream      Open File Handle

+@param  Buffer      Pointer to buffer to return. 

+@param  BufferSize  Pointer to Size of buffer return..

+

+

+@return EFI_SUCCESS           Stream is not an Open File

+@return EFI_END_OF_FILE       Tried to read past the end of the file

+@return EFI_INVALID_PARAMETER Stream is not an open file handle

+@return EFI_BUFFER_TOO_SMALL  Buffer is not big enough to do the read

+@return "other"               Error returned from device read

+

+**/

+EFI_STATUS

+EfiReadAllocatePool (

+  IN  EFI_OPEN_FILE     *File,

+  OUT VOID              **Buffer,

+  OUT UINTN             *BufferSize

+  )

+{

+  if (!FileHandleValid (File)) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  // Loadfile defers file size determination on Open so use tell to find it

+  EfiTell (File, NULL);

+

+  *BufferSize = File->Size;

+  *Buffer = AllocatePool (*BufferSize);

+  if (*Buffer == NULL) {

+    return EFI_NOT_FOUND;

+  }

+

+  return EfiRead (File, *Buffer, BufferSize);

+}

+

+

+/**

+Write data back to the file. For TFTP case you must write the entire file. 

+

+@param  Stream      Open File Handle

+@param  Buffer      Pointer to buffer to return. 

+@param  BufferSize  Pointer to Size of buffer return..

+

+

+@return EFI_SUCCESS           Stream is not an Open File

+@return EFI_END_OF_FILE       Tried to read past the end of the file

+@return EFI_INVALID_PARAMETER Stream is not an open file handle

+@return EFI_BUFFER_TOO_SMALL  Buffer is not big enough to do the read

+@return "other"               Error returned from device write

+

+**/

+EFI_STATUS

+EfiWrite (

+  IN  EFI_OPEN_FILE   *File,

+  OUT VOID            *Buffer,

+  OUT UINTN           *BufferSize

+  )

+{

+  EFI_STATUS              Status;

+  EFI_FV_WRITE_FILE_DATA  FileData;

+  EFI_DISK_IO_PROTOCOL    *DiskIo;  

+

+  if (!FileHandleValid (File)) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  switch (File->Type) {

+  case EfiOpenMemoryBuffer:

+    if ((File->CurrentPosition + *BufferSize) > File->MaxPosition) {

+      return EFI_END_OF_FILE;

+    }

+

+    CopyMem (File->Buffer + File->CurrentPosition, Buffer, *BufferSize);

+    File->CurrentPosition += *BufferSize;

+    Status = EFI_SUCCESS;

+

+  case EfiOpenLoadFile:

+    // LoadFile device is read only be definition

+    Status = EFI_UNSUPPORTED;

+

+  case EfiOpenFirmwareVolume:

+    if (File->FvSectionType != EFI_SECTION_ALL) {

+      // Writes not support to a specific section. You have to update entire file

+      return EFI_UNSUPPORTED;

+    }

+

+    FileData.NameGuid       = &(File->FvNameGuid);

+    FileData.Type           = File->FvType;

+    FileData.FileAttributes = File->FvAttributes;

+    FileData.Buffer         = Buffer;

+    FileData.BufferSize     = (UINT32)*BufferSize;

+    Status = File->Fv->WriteFile (File->Fv, 1, EFI_FV_UNRELIABLE_WRITE, &FileData);

+    break;

+

+  case EfiOpenFileSystem:

+    Status = File->FsFileHandle->Write (File->FsFileHandle, BufferSize, Buffer);

+    File->CurrentPosition += *BufferSize;

+    break;

+

+  case EfiOpenBlockIo:

+    if ((File->CurrentPosition + *BufferSize) > File->MaxPosition) {

+      return EFI_END_OF_FILE;

+    }

+

+    Status = gBS->HandleProtocol (File->EfiHandle, &gEfiDiskIoProtocolGuid, (VOID **)&DiskIo);

+    if (!EFI_ERROR(Status)) {

+      Status = DiskIo->WriteDisk (DiskIo, File->FsBlockIoMedia->MediaId, File->DiskOffset + File->CurrentPosition, *BufferSize, Buffer);

+    }

+    File->CurrentPosition += *BufferSize;

+    break;

+

+  case EfiOpenTftp:

+    // Cache the file if it hasn't been cached yet.

+    if (File->IsBufferValid == FALSE) {

+      Status = CacheTftpFile(File);

+      if (EFI_ERROR(Status)) {

+        return Status;

+      }

+    }

+

+    // Don't overwrite the buffer

+    if ((File->CurrentPosition + *BufferSize) > File->MaxPosition) {

+      UINT8 *TempBuffer;

+

+      TempBuffer = File->Buffer;

+

+      File->Buffer = AllocatePool ((UINTN)(File->CurrentPosition + *BufferSize));

+      if (File->Buffer == NULL) {

+        return EFI_OUT_OF_RESOURCES;

+      }

+

+      CopyMem (File->Buffer, TempBuffer, File->Size);

+

+      FreePool (TempBuffer);

+

+      File->Size = (UINTN)(File->CurrentPosition + *BufferSize);

+      File->MaxPosition = (UINT64)File->Size;

+    }

+

+    // Copy in the requested data

+    CopyMem (File->Buffer + File->CurrentPosition, Buffer, *BufferSize);

+    File->CurrentPosition += *BufferSize;

+

+    // Mark the file dirty

+    File->IsDirty = TRUE;

+

+    Status = EFI_SUCCESS;

+    break;

+

+  default:

+    Status = EFI_INVALID_PARAMETER;

+  };

+

+  return Status;

+}

+

+

+/**

+Given Cwd expand Path to remove .. and replace them with real 

+directory names.

+

+@param  Cwd     Current Working Directory

+@param  Path    Path to expand

+

+@return NULL     Cwd or Path are not valid

+@return 'other'  Path with .. expanded

+

+**/

+CHAR8 *

+ExpandPath (

+  IN CHAR8    *Cwd,

+  IN CHAR8    *Path

+  )

+{

+  CHAR8   *NewPath;

+  CHAR8   *Work, *Start, *End;

+  UINTN   StrLen;

+  INTN    i;

+

+  if (Cwd == NULL || Path == NULL) {

+    return NULL;

+  }

+

+  StrLen = AsciiStrSize (Cwd);

+  if (StrLen <= 2) {

+    // Smallest valid path is 1 char and a null

+    return NULL;

+  }

+

+  StrLen = AsciiStrSize (Path);

+  NewPath = AllocatePool (AsciiStrSize (Cwd) + StrLen + 1);

+  if (NewPath == NULL) {

+    return NULL;

+  }

+  AsciiStrCpy (NewPath, Cwd);

+

+  End = Path + StrLen;

+  for (Start = Path ;;) {

+    Work = AsciiStrStr (Start, "..") ;

+    if (Work == NULL) {

+      // Remaining part of Path contains no more ..

+      break;

+    } 

+

+    // append path prior to .. 

+    AsciiStrnCat (NewPath, Start, Work - Start);

+    StrLen = AsciiStrLen (NewPath);

+    for (i = StrLen; i >= 0; i--) {

+      if (NewPath[i] == ':') {

+        // too many ..

+        return NULL;

+      }

+      if (NewPath[i] == '/' || NewPath[i] == '\\') {

+        if ((i > 0) && (NewPath[i-1] == ':')) {

+          // leave the / before a :

+          NewPath[i+1] = '\0';

+        } else {

+          // replace / will Null to remove trailing file/dir reference

+          NewPath[i] = '\0';

+        }

+        break;

+      }

+    }

+

+    Start = Work + 3;

+  } 

+

+  // Handle the path that remains after the ..

+  AsciiStrnCat (NewPath, Start, End - Start);

+

+  return NewPath;

+}

+

+

+/**

+Set the Current Working Directory (CWD). If a call is made to EfiOpen () and

+the path does not contain a device name, The CWD is prepended to the path.

+

+@param  Cwd     Current Working Directory to set

+

+

+@return EFI_SUCCESS           CWD is set

+@return EFI_INVALID_PARAMETER Cwd is not a valid device:path

+

+**/

+EFI_STATUS

+EfiSetCwd (

+  IN  CHAR8   *Cwd

+  ) 

+{

+  EFI_OPEN_FILE *File;

+  UINTN         Len;

+  CHAR8         *Path;

+

+  if (Cwd == NULL) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  if (AsciiStrCmp (Cwd, ".") == 0) {

+    // cd . is a no-op

+    return EFI_SUCCESS;

+  }

+

+  Path = Cwd;

+  if (AsciiStrStr (Cwd, "..") != NULL) {

+    if (gCwd == NULL) {

+      // no parent 

+      return EFI_SUCCESS;

+    }

+

+    Len = AsciiStrLen (gCwd);

+    if ((gCwd[Len-2] == ':') && ((gCwd[Len-1] == '/') || (gCwd[Len-1] == '\\'))) {

+      // parent is device so nothing to do

+      return EFI_SUCCESS;

+    }

+

+    // Expand .. in Cwd, given we know current working directory

+    Path = ExpandPath (gCwd, Cwd);

+    if (Path == NULL) {

+      return EFI_NOT_FOUND;

+    }

+  }

+

+  File = EfiOpen (Path, EFI_FILE_MODE_READ, 0);

+  if (File == NULL) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  if (gCwd != NULL) {

+    FreePool (gCwd);

+  }

+

+  // Use the info returned from EfiOpen as it can add in CWD if needed. So Cwd could be

+  // relative to the current gCwd or not.

+  gCwd = AllocatePool (AsciiStrSize (File->DeviceName) + AsciiStrSize (File->FileName) + 10);

+  if (gCwd == NULL) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  AsciiStrCpy (gCwd, File->DeviceName);

+  if (File->FileName == NULL) {

+    AsciiStrCat (gCwd, ":\\");

+  } else {

+    AsciiStrCat (gCwd, ":");

+    AsciiStrCat (gCwd, File->FileName);

+  }

+

+

+  EfiClose (File);

+  if (Path != Cwd) {

+    FreePool (Path);

+  }

+  return EFI_SUCCESS;

+}

+

+

+/**

+Set the Current Working Directory (CWD). If a call is made to EfiOpen () and

+the path does not contain a device name, The CWD is prepended to the path.

+The CWD buffer is only valid until a new call is made to EfiSetCwd(). After

+a call to EfiSetCwd() it is not legal to use the pointer returned by 

+this function.

+

+@param  Cwd     Current Working Directory 

+

+

+@return ""      No CWD set

+@return 'other' Returns buffer that contains CWD.

+

+**/

+CHAR8 *

+EfiGetCwd (

+  VOID

+  )

+{

+  if (gCwd == NULL) {

+    return "";

+  }

+  return gCwd;

+}

+

+

diff --git a/EmbeddedPkg/Library/FdtLib/fdt.c b/EmbeddedPkg/Library/FdtLib/fdt.c
index e56833ae..151fcb2a 100644
--- a/EmbeddedPkg/Library/FdtLib/fdt.c
+++ b/EmbeddedPkg/Library/FdtLib/fdt.c
@@ -1,222 +1,222 @@
-/*
- * libfdt - Flat Device Tree manipulation
- * Copyright (C) 2006 David Gibson, IBM Corporation.
- *
- * libfdt is dual licensed: you can use it either under the terms of
- * the GPL, or the BSD license, at your option.
- *
- *  a) This library is free software; you can redistribute it and/or
- *     modify it under the terms of the GNU General Public License as
- *     published by the Free Software Foundation; either version 2 of the
- *     License, or (at your option) any later version.
- *
- *     This library is distributed in the hope that it will be useful,
- *     but WITHOUT ANY WARRANTY; without even the implied warranty of
- *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *     GNU General Public License for more details.
- *
- *     You should have received a copy of the GNU General Public
- *     License along with this library; if not, write to the Free
- *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
- *     MA 02110-1301 USA
- *
- * Alternatively,
- *
- *  b) Redistribution and use in source and binary forms, with or
- *     without modification, are permitted provided that the following
- *     conditions are met:
- *
- *     1. Redistributions of source code must retain the above
- *        copyright notice, this list of conditions and the following
- *        disclaimer.
- *     2. Redistributions in binary form must reproduce the above
- *        copyright notice, this list of conditions and the following
- *        disclaimer in the documentation and/or other materials
- *        provided with the distribution.
- *
- *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
- *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
- *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include "libfdt_env.h"
-
-#include <fdt.h>
-#include <libfdt.h>
-
-#include "libfdt_internal.h"
-
-int fdt_check_header(const void *fdt)
-{
-	if (fdt_magic(fdt) == FDT_MAGIC) {
-		/* Complete tree */
-		if (fdt_version(fdt) < FDT_FIRST_SUPPORTED_VERSION)
-			return -FDT_ERR_BADVERSION;
-		if (fdt_last_comp_version(fdt) > FDT_LAST_SUPPORTED_VERSION)
-			return -FDT_ERR_BADVERSION;
-	} else if (fdt_magic(fdt) == FDT_SW_MAGIC) {
-		/* Unfinished sequential-write blob */
-		if (fdt_size_dt_struct(fdt) == 0)
-			return -FDT_ERR_BADSTATE;
-	} else {
-		return -FDT_ERR_BADMAGIC;
-	}
-
-	return 0;
-}
-
-const void *fdt_offset_ptr(const void *fdt, int offset, unsigned int len)
-{
-	const char *p;
-
-	if (fdt_version(fdt) >= 0x11)
-		if (((offset + len) < offset)
-		    || ((offset + len) > fdt_size_dt_struct(fdt)))
-			return NULL;
-
-	p = _fdt_offset_ptr(fdt, offset);
-
-	if (p + len < p)
-		return NULL;
-	return p;
-}
-
-uint32_t fdt_next_tag(const void *fdt, int startoffset, int *nextoffset)
-{
-	const uint32_t *tagp, *lenp;
-	uint32_t tag;
-	int offset = startoffset;
-	const char *p;
-
-	*nextoffset = -FDT_ERR_TRUNCATED;
-	tagp = fdt_offset_ptr(fdt, offset, FDT_TAGSIZE);
-	if (!tagp)
-		return FDT_END; /* premature end */
-	tag = fdt32_to_cpu(*tagp);
-	offset += FDT_TAGSIZE;
-
-	*nextoffset = -FDT_ERR_BADSTRUCTURE;
-	switch (tag) {
-	case FDT_BEGIN_NODE:
-		/* skip name */
-		do {
-			p = fdt_offset_ptr(fdt, offset++, 1);
-		} while (p && (*p != '\0'));
-		if (!p)
-			return FDT_END; /* premature end */
-		break;
-
-	case FDT_PROP:
-		lenp = fdt_offset_ptr(fdt, offset, sizeof(*lenp));
-		if (!lenp)
-			return FDT_END; /* premature end */
-		/* skip-name offset, length and value */
-		offset += sizeof(struct fdt_property) - FDT_TAGSIZE
-			+ fdt32_to_cpu(*lenp);
-		break;
-
-	case FDT_END:
-	case FDT_END_NODE:
-	case FDT_NOP:
-		break;
-
-	default:
-		return FDT_END;
-	}
-
-	if (!fdt_offset_ptr(fdt, startoffset, offset - startoffset))
-		return FDT_END; /* premature end */
-
-	*nextoffset = FDT_TAGALIGN(offset);
-	return tag;
-}
-
-int _fdt_check_node_offset(const void *fdt, int offset)
-{
-	if ((offset < 0) || (offset % FDT_TAGSIZE)
-	    || (fdt_next_tag(fdt, offset, &offset) != FDT_BEGIN_NODE))
-		return -FDT_ERR_BADOFFSET;
-
-	return offset;
-}
-
-int _fdt_check_prop_offset(const void *fdt, int offset)
-{
-	if ((offset < 0) || (offset % FDT_TAGSIZE)
-	    || (fdt_next_tag(fdt, offset, &offset) != FDT_PROP))
-		return -FDT_ERR_BADOFFSET;
-
-	return offset;
-}
-
-int fdt_next_node(const void *fdt, int offset, int *depth)
-{
-	int nextoffset = 0;
-	uint32_t tag;
-
-	if (offset >= 0)
-		if ((nextoffset = _fdt_check_node_offset(fdt, offset)) < 0)
-			return nextoffset;
-
-	do {
-		offset = nextoffset;
-		tag = fdt_next_tag(fdt, offset, &nextoffset);
-
-		switch (tag) {
-		case FDT_PROP:
-		case FDT_NOP:
-			break;
-
-		case FDT_BEGIN_NODE:
-			if (depth)
-				(*depth)++;
-			break;
-
-		case FDT_END_NODE:
-			if (depth && ((--(*depth)) < 0))
-				return nextoffset;
-			break;
-
-		case FDT_END:
-			if ((nextoffset >= 0)
-			    || ((nextoffset == -FDT_ERR_TRUNCATED) && !depth))
-				return -FDT_ERR_NOTFOUND;
-			else
-				return nextoffset;
-		}
-	} while (tag != FDT_BEGIN_NODE);
-
-	return offset;
-}
-
-const char *_fdt_find_string(const char *strtab, int tabsize, const char *s)
-{
-	int len = strlen(s) + 1;
-	const char *last = strtab + tabsize - len;
-	const char *p;
-
-	for (p = strtab; p <= last; p++)
-		if (memcmp(p, s, len) == 0)
-			return p;
-	return NULL;
-}
-
-int fdt_move(const void *fdt, void *buf, int bufsize)
-{
-	FDT_CHECK_HEADER(fdt);
-
-	if (fdt_totalsize(fdt) > bufsize)
-		return -FDT_ERR_NOSPACE;
-
-	memmove(buf, fdt, fdt_totalsize(fdt));
-	return 0;
-}
+/*

+ * libfdt - Flat Device Tree manipulation

+ * Copyright (C) 2006 David Gibson, IBM Corporation.

+ *

+ * libfdt is dual licensed: you can use it either under the terms of

+ * the GPL, or the BSD license, at your option.

+ *

+ *  a) This library is free software; you can redistribute it and/or

+ *     modify it under the terms of the GNU General Public License as

+ *     published by the Free Software Foundation; either version 2 of the

+ *     License, or (at your option) any later version.

+ *

+ *     This library is distributed in the hope that it will be useful,

+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of

+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ *     GNU General Public License for more details.

+ *

+ *     You should have received a copy of the GNU General Public

+ *     License along with this library; if not, write to the Free

+ *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,

+ *     MA 02110-1301 USA

+ *

+ * Alternatively,

+ *

+ *  b) Redistribution and use in source and binary forms, with or

+ *     without modification, are permitted provided that the following

+ *     conditions are met:

+ *

+ *     1. Redistributions of source code must retain the above

+ *        copyright notice, this list of conditions and the following

+ *        disclaimer.

+ *     2. Redistributions in binary form must reproduce the above

+ *        copyright notice, this list of conditions and the following

+ *        disclaimer in the documentation and/or other materials

+ *        provided with the distribution.

+ *

+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND

+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,

+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,

+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ */

+#include "libfdt_env.h"

+

+#include <fdt.h>

+#include <libfdt.h>

+

+#include "libfdt_internal.h"

+

+int fdt_check_header(const void *fdt)

+{

+	if (fdt_magic(fdt) == FDT_MAGIC) {

+		/* Complete tree */

+		if (fdt_version(fdt) < FDT_FIRST_SUPPORTED_VERSION)

+			return -FDT_ERR_BADVERSION;

+		if (fdt_last_comp_version(fdt) > FDT_LAST_SUPPORTED_VERSION)

+			return -FDT_ERR_BADVERSION;

+	} else if (fdt_magic(fdt) == FDT_SW_MAGIC) {

+		/* Unfinished sequential-write blob */

+		if (fdt_size_dt_struct(fdt) == 0)

+			return -FDT_ERR_BADSTATE;

+	} else {

+		return -FDT_ERR_BADMAGIC;

+	}

+

+	return 0;

+}

+

+const void *fdt_offset_ptr(const void *fdt, int offset, unsigned int len)

+{

+	const char *p;

+

+	if (fdt_version(fdt) >= 0x11)

+		if (((offset + len) < offset)

+		    || ((offset + len) > fdt_size_dt_struct(fdt)))

+			return NULL;

+

+	p = _fdt_offset_ptr(fdt, offset);

+

+	if (p + len < p)

+		return NULL;

+	return p;

+}

+

+uint32_t fdt_next_tag(const void *fdt, int startoffset, int *nextoffset)

+{

+	const uint32_t *tagp, *lenp;

+	uint32_t tag;

+	int offset = startoffset;

+	const char *p;

+

+	*nextoffset = -FDT_ERR_TRUNCATED;

+	tagp = fdt_offset_ptr(fdt, offset, FDT_TAGSIZE);

+	if (!tagp)

+		return FDT_END; /* premature end */

+	tag = fdt32_to_cpu(*tagp);

+	offset += FDT_TAGSIZE;

+

+	*nextoffset = -FDT_ERR_BADSTRUCTURE;

+	switch (tag) {

+	case FDT_BEGIN_NODE:

+		/* skip name */

+		do {

+			p = fdt_offset_ptr(fdt, offset++, 1);

+		} while (p && (*p != '\0'));

+		if (!p)

+			return FDT_END; /* premature end */

+		break;

+

+	case FDT_PROP:

+		lenp = fdt_offset_ptr(fdt, offset, sizeof(*lenp));

+		if (!lenp)

+			return FDT_END; /* premature end */

+		/* skip-name offset, length and value */

+		offset += sizeof(struct fdt_property) - FDT_TAGSIZE

+			+ fdt32_to_cpu(*lenp);

+		break;

+

+	case FDT_END:

+	case FDT_END_NODE:

+	case FDT_NOP:

+		break;

+

+	default:

+		return FDT_END;

+	}

+

+	if (!fdt_offset_ptr(fdt, startoffset, offset - startoffset))

+		return FDT_END; /* premature end */

+

+	*nextoffset = FDT_TAGALIGN(offset);

+	return tag;

+}

+

+int _fdt_check_node_offset(const void *fdt, int offset)

+{

+	if ((offset < 0) || (offset % FDT_TAGSIZE)

+	    || (fdt_next_tag(fdt, offset, &offset) != FDT_BEGIN_NODE))

+		return -FDT_ERR_BADOFFSET;

+

+	return offset;

+}

+

+int _fdt_check_prop_offset(const void *fdt, int offset)

+{

+	if ((offset < 0) || (offset % FDT_TAGSIZE)

+	    || (fdt_next_tag(fdt, offset, &offset) != FDT_PROP))

+		return -FDT_ERR_BADOFFSET;

+

+	return offset;

+}

+

+int fdt_next_node(const void *fdt, int offset, int *depth)

+{

+	int nextoffset = 0;

+	uint32_t tag;

+

+	if (offset >= 0)

+		if ((nextoffset = _fdt_check_node_offset(fdt, offset)) < 0)

+			return nextoffset;

+

+	do {

+		offset = nextoffset;

+		tag = fdt_next_tag(fdt, offset, &nextoffset);

+

+		switch (tag) {

+		case FDT_PROP:

+		case FDT_NOP:

+			break;

+

+		case FDT_BEGIN_NODE:

+			if (depth)

+				(*depth)++;

+			break;

+

+		case FDT_END_NODE:

+			if (depth && ((--(*depth)) < 0))

+				return nextoffset;

+			break;

+

+		case FDT_END:

+			if ((nextoffset >= 0)

+			    || ((nextoffset == -FDT_ERR_TRUNCATED) && !depth))

+				return -FDT_ERR_NOTFOUND;

+			else

+				return nextoffset;

+		}

+	} while (tag != FDT_BEGIN_NODE);

+

+	return offset;

+}

+

+const char *_fdt_find_string(const char *strtab, int tabsize, const char *s)

+{

+	int len = strlen(s) + 1;

+	const char *last = strtab + tabsize - len;

+	const char *p;

+

+	for (p = strtab; p <= last; p++)

+		if (memcmp(p, s, len) == 0)

+			return p;

+	return NULL;

+}

+

+int fdt_move(const void *fdt, void *buf, int bufsize)

+{

+	FDT_CHECK_HEADER(fdt);

+

+	if (fdt_totalsize(fdt) > bufsize)

+		return -FDT_ERR_NOSPACE;

+

+	memmove(buf, fdt, fdt_totalsize(fdt));

+	return 0;

+}

diff --git a/EmbeddedPkg/Library/FdtLib/fdt_empty_tree.c b/EmbeddedPkg/Library/FdtLib/fdt_empty_tree.c
index f72d13b1..f00a8991 100644
--- a/EmbeddedPkg/Library/FdtLib/fdt_empty_tree.c
+++ b/EmbeddedPkg/Library/FdtLib/fdt_empty_tree.c
@@ -1,84 +1,84 @@
-/*
- * libfdt - Flat Device Tree manipulation
- * Copyright (C) 2012 David Gibson, IBM Corporation.
- *
- * libfdt is dual licensed: you can use it either under the terms of
- * the GPL, or the BSD license, at your option.
- *
- *  a) This library is free software; you can redistribute it and/or
- *     modify it under the terms of the GNU General Public License as
- *     published by the Free Software Foundation; either version 2 of the
- *     License, or (at your option) any later version.
- *
- *     This library is distributed in the hope that it will be useful,
- *     but WITHOUT ANY WARRANTY; without even the implied warranty of
- *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *     GNU General Public License for more details.
- *
- *     You should have received a copy of the GNU General Public
- *     License along with this library; if not, write to the Free
- *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
- *     MA 02110-1301 USA
- *
- * Alternatively,
- *
- *  b) Redistribution and use in source and binary forms, with or
- *     without modification, are permitted provided that the following
- *     conditions are met:
- *
- *     1. Redistributions of source code must retain the above
- *        copyright notice, this list of conditions and the following
- *        disclaimer.
- *     2. Redistributions in binary form must reproduce the above
- *        copyright notice, this list of conditions and the following
- *        disclaimer in the documentation and/or other materials
- *        provided with the distribution.
- *
- *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
- *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
- *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include "libfdt_env.h"
-
-#include <fdt.h>
-#include <libfdt.h>
-
-#include "libfdt_internal.h"
-
-int fdt_create_empty_tree(void *buf, int bufsize)
-{
-	int err;
-
-	err = fdt_create(buf, bufsize);
-	if (err)
-		return err;
-
-	err = fdt_finish_reservemap(buf);
-	if (err)
-		return err;
-
-	err = fdt_begin_node(buf, "");
-	if (err)
-		return err;
-
-	err =  fdt_end_node(buf);
-	if (err)
-		return err;
-
-	err = fdt_finish(buf);
-	if (err)
-		return err;
-
-	return fdt_open_into(buf, buf, bufsize);
-}
-
+/*

+ * libfdt - Flat Device Tree manipulation

+ * Copyright (C) 2012 David Gibson, IBM Corporation.

+ *

+ * libfdt is dual licensed: you can use it either under the terms of

+ * the GPL, or the BSD license, at your option.

+ *

+ *  a) This library is free software; you can redistribute it and/or

+ *     modify it under the terms of the GNU General Public License as

+ *     published by the Free Software Foundation; either version 2 of the

+ *     License, or (at your option) any later version.

+ *

+ *     This library is distributed in the hope that it will be useful,

+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of

+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ *     GNU General Public License for more details.

+ *

+ *     You should have received a copy of the GNU General Public

+ *     License along with this library; if not, write to the Free

+ *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,

+ *     MA 02110-1301 USA

+ *

+ * Alternatively,

+ *

+ *  b) Redistribution and use in source and binary forms, with or

+ *     without modification, are permitted provided that the following

+ *     conditions are met:

+ *

+ *     1. Redistributions of source code must retain the above

+ *        copyright notice, this list of conditions and the following

+ *        disclaimer.

+ *     2. Redistributions in binary form must reproduce the above

+ *        copyright notice, this list of conditions and the following

+ *        disclaimer in the documentation and/or other materials

+ *        provided with the distribution.

+ *

+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND

+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,

+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,

+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ */

+#include "libfdt_env.h"

+

+#include <fdt.h>

+#include <libfdt.h>

+

+#include "libfdt_internal.h"

+

+int fdt_create_empty_tree(void *buf, int bufsize)

+{

+	int err;

+

+	err = fdt_create(buf, bufsize);

+	if (err)

+		return err;

+

+	err = fdt_finish_reservemap(buf);

+	if (err)

+		return err;

+

+	err = fdt_begin_node(buf, "");

+	if (err)

+		return err;

+

+	err =  fdt_end_node(buf);

+	if (err)

+		return err;

+

+	err = fdt_finish(buf);

+	if (err)

+		return err;

+

+	return fdt_open_into(buf, buf, bufsize);

+}

+

diff --git a/EmbeddedPkg/Library/FdtLib/fdt_ro.c b/EmbeddedPkg/Library/FdtLib/fdt_ro.c
index 95fdbead..9ae6b5ec 100644
--- a/EmbeddedPkg/Library/FdtLib/fdt_ro.c
+++ b/EmbeddedPkg/Library/FdtLib/fdt_ro.c
@@ -1,575 +1,575 @@
-/*
- * libfdt - Flat Device Tree manipulation
- * Copyright (C) 2006 David Gibson, IBM Corporation.
- *
- * libfdt is dual licensed: you can use it either under the terms of
- * the GPL, or the BSD license, at your option.
- *
- *  a) This library is free software; you can redistribute it and/or
- *     modify it under the terms of the GNU General Public License as
- *     published by the Free Software Foundation; either version 2 of the
- *     License, or (at your option) any later version.
- *
- *     This library is distributed in the hope that it will be useful,
- *     but WITHOUT ANY WARRANTY; without even the implied warranty of
- *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *     GNU General Public License for more details.
- *
- *     You should have received a copy of the GNU General Public
- *     License along with this library; if not, write to the Free
- *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
- *     MA 02110-1301 USA
- *
- * Alternatively,
- *
- *  b) Redistribution and use in source and binary forms, with or
- *     without modification, are permitted provided that the following
- *     conditions are met:
- *
- *     1. Redistributions of source code must retain the above
- *        copyright notice, this list of conditions and the following
- *        disclaimer.
- *     2. Redistributions in binary form must reproduce the above
- *        copyright notice, this list of conditions and the following
- *        disclaimer in the documentation and/or other materials
- *        provided with the distribution.
- *
- *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
- *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
- *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include "libfdt_env.h"
-
-#include <fdt.h>
-#include <libfdt.h>
-
-#include "libfdt_internal.h"
-
-static int _fdt_nodename_eq(const void *fdt, int offset,
-			    const char *s, int len)
-{
-	const char *p = fdt_offset_ptr(fdt, offset + FDT_TAGSIZE, len+1);
-
-	if (! p)
-		/* short match */
-		return 0;
-
-	if (memcmp(p, s, len) != 0)
-		return 0;
-
-	if (p[len] == '\0')
-		return 1;
-	else if (!memchr(s, '@', len) && (p[len] == '@'))
-		return 1;
-	else
-		return 0;
-}
-
-const char *fdt_string(const void *fdt, int stroffset)
-{
-	return (const char *)fdt + fdt_off_dt_strings(fdt) + stroffset;
-}
-
-static int _fdt_string_eq(const void *fdt, int stroffset,
-			  const char *s, int len)
-{
-	const char *p = fdt_string(fdt, stroffset);
-
-	return (strlen(p) == len) && (memcmp(p, s, len) == 0);
-}
-
-int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size)
-{
-	FDT_CHECK_HEADER(fdt);
-	*address = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->address);
-	*size = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->size);
-	return 0;
-}
-
-int fdt_num_mem_rsv(const void *fdt)
-{
-	int i = 0;
-
-	while (fdt64_to_cpu(_fdt_mem_rsv(fdt, i)->size) != 0)
-		i++;
-	return i;
-}
-
-static int _nextprop(const void *fdt, int offset)
-{
-	uint32_t tag;
-	int nextoffset;
-
-	do {
-		tag = fdt_next_tag(fdt, offset, &nextoffset);
-
-		switch (tag) {
-		case FDT_END:
-			if (nextoffset >= 0)
-				return -FDT_ERR_BADSTRUCTURE;
-			else
-				return nextoffset;
-
-		case FDT_PROP:
-			return offset;
-		}
-		offset = nextoffset;
-	} while (tag == FDT_NOP);
-
-	return -FDT_ERR_NOTFOUND;
-}
-
-int fdt_subnode_offset_namelen(const void *fdt, int offset,
-			       const char *name, int namelen)
-{
-	int depth;
-
-	FDT_CHECK_HEADER(fdt);
-
-	for (depth = 0;
-	     (offset >= 0) && (depth >= 0);
-	     offset = fdt_next_node(fdt, offset, &depth))
-		if ((depth == 1)
-		    && _fdt_nodename_eq(fdt, offset, name, namelen))
-			return offset;
-
-	if (depth < 0)
-		return -FDT_ERR_NOTFOUND;
-	return offset; /* error */
-}
-
-int fdt_subnode_offset(const void *fdt, int parentoffset,
-		       const char *name)
-{
-	return fdt_subnode_offset_namelen(fdt, parentoffset, name, strlen(name));
-}
-
-int fdt_path_offset(const void *fdt, const char *path)
-{
-	const char *end = path + strlen(path);
-	const char *p = path;
-	int offset = 0;
-
-	FDT_CHECK_HEADER(fdt);
-
-	/* see if we have an alias */
-	if (*path != '/') {
-		const char *q = strchr(path, '/');
-
-		if (!q)
-			q = end;
-
-		p = fdt_get_alias_namelen(fdt, p, q - p);
-		if (!p)
-			return -FDT_ERR_BADPATH;
-		offset = fdt_path_offset(fdt, p);
-
-		p = q;
-	}
-
-	while (*p) {
-		const char *q;
-
-		while (*p == '/')
-			p++;
-		if (! *p)
-			return offset;
-		q = strchr(p, '/');
-		if (! q)
-			q = end;
-
-		offset = fdt_subnode_offset_namelen(fdt, offset, p, q-p);
-		if (offset < 0)
-			return offset;
-
-		p = q;
-	}
-
-	return offset;
-}
-
-const char *fdt_get_name(const void *fdt, int nodeoffset, int *len)
-{
-	const struct fdt_node_header *nh = _fdt_offset_ptr(fdt, nodeoffset);
-	int err;
-
-	if (((err = fdt_check_header(fdt)) != 0)
-	    || ((err = _fdt_check_node_offset(fdt, nodeoffset)) < 0))
-			goto fail;
-
-	if (len)
-		*len = strlen(nh->name);
-
-	return nh->name;
-
- fail:
-	if (len)
-		*len = err;
-	return NULL;
-}
-
-int fdt_first_property_offset(const void *fdt, int nodeoffset)
-{
-	int offset;
-
-	if ((offset = _fdt_check_node_offset(fdt, nodeoffset)) < 0)
-		return offset;
-
-	return _nextprop(fdt, offset);
-}
-
-int fdt_next_property_offset(const void *fdt, int offset)
-{
-	if ((offset = _fdt_check_prop_offset(fdt, offset)) < 0)
-		return offset;
-
-	return _nextprop(fdt, offset);
-}
-
-const struct fdt_property *fdt_get_property_by_offset(const void *fdt,
-						      int offset,
-						      int *lenp)
-{
-	int err;
-	const struct fdt_property *prop;
-
-	if ((err = _fdt_check_prop_offset(fdt, offset)) < 0) {
-		if (lenp)
-			*lenp = err;
-		return NULL;
-	}
-
-	prop = _fdt_offset_ptr(fdt, offset);
-
-	if (lenp)
-		*lenp = fdt32_to_cpu(prop->len);
-
-	return prop;
-}
-
-const struct fdt_property *fdt_get_property_namelen(const void *fdt,
-						    int offset,
-						    const char *name,
-						    int namelen, int *lenp)
-{
-	for (offset = fdt_first_property_offset(fdt, offset);
-	     (offset >= 0);
-	     (offset = fdt_next_property_offset(fdt, offset))) {
-		const struct fdt_property *prop;
-
-		prop = fdt_get_property_by_offset(fdt, offset, lenp);
-		if (!prop) {
-			offset = -FDT_ERR_INTERNAL;
-			break;
-		}
-		if (_fdt_string_eq(fdt, fdt32_to_cpu(prop->nameoff),
-				   name, namelen))
-			return prop;
-	}
-
-	if (lenp)
-		*lenp = offset;
-	return NULL;
-}
-
-const struct fdt_property *fdt_get_property(const void *fdt,
-					    int nodeoffset,
-					    const char *name, int *lenp)
-{
-	return fdt_get_property_namelen(fdt, nodeoffset, name,
-					strlen(name), lenp);
-}
-
-const void *fdt_getprop_namelen(const void *fdt, int nodeoffset,
-				const char *name, int namelen, int *lenp)
-{
-	const struct fdt_property *prop;
-
-	prop = fdt_get_property_namelen(fdt, nodeoffset, name, namelen, lenp);
-	if (! prop)
-		return NULL;
-
-	return prop->data;
-}
-
-const void *fdt_getprop_by_offset(const void *fdt, int offset,
-				  const char **namep, int *lenp)
-{
-	const struct fdt_property *prop;
-
-	prop = fdt_get_property_by_offset(fdt, offset, lenp);
-	if (!prop)
-		return NULL;
-	if (namep)
-		*namep = fdt_string(fdt, fdt32_to_cpu(prop->nameoff));
-	return prop->data;
-}
-
-const void *fdt_getprop(const void *fdt, int nodeoffset,
-			const char *name, int *lenp)
-{
-	return fdt_getprop_namelen(fdt, nodeoffset, name, strlen(name), lenp);
-}
-
-uint32_t fdt_get_phandle(const void *fdt, int nodeoffset)
-{
-	const uint32_t *php;
-	int len;
-
-	/* FIXME: This is a bit sub-optimal, since we potentially scan
-	 * over all the properties twice. */
-	php = fdt_getprop(fdt, nodeoffset, "phandle", &len);
-	if (!php || (len != sizeof(*php))) {
-		php = fdt_getprop(fdt, nodeoffset, "linux,phandle", &len);
-		if (!php || (len != sizeof(*php)))
-			return 0;
-	}
-
-	return fdt32_to_cpu(*php);
-}
-
-const char *fdt_get_alias_namelen(const void *fdt,
-				  const char *name, int namelen)
-{
-	int aliasoffset;
-
-	aliasoffset = fdt_path_offset(fdt, "/aliases");
-	if (aliasoffset < 0)
-		return NULL;
-
-	return fdt_getprop_namelen(fdt, aliasoffset, name, namelen, NULL);
-}
-
-const char *fdt_get_alias(const void *fdt, const char *name)
-{
-	return fdt_get_alias_namelen(fdt, name, strlen(name));
-}
-
-int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen)
-{
-	int pdepth = 0, p = 0;
-	int offset, depth, namelen;
-	const char *name;
-
-	FDT_CHECK_HEADER(fdt);
-
-	if (buflen < 2)
-		return -FDT_ERR_NOSPACE;
-
-	for (offset = 0, depth = 0;
-	     (offset >= 0) && (offset <= nodeoffset);
-	     offset = fdt_next_node(fdt, offset, &depth)) {
-		while (pdepth > depth) {
-			do {
-				p--;
-			} while (buf[p-1] != '/');
-			pdepth--;
-		}
-
-		if (pdepth >= depth) {
-			name = fdt_get_name(fdt, offset, &namelen);
-			if (!name)
-				return namelen;
-			if ((p + namelen + 1) <= buflen) {
-				memcpy(buf + p, name, namelen);
-				p += namelen;
-				buf[p++] = '/';
-				pdepth++;
-			}
-		}
-
-		if (offset == nodeoffset) {
-			if (pdepth < (depth + 1))
-				return -FDT_ERR_NOSPACE;
-
-			if (p > 1) /* special case so that root path is "/", not "" */
-				p--;
-			buf[p] = '\0';
-			return 0;
-		}
-	}
-
-	if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))
-		return -FDT_ERR_BADOFFSET;
-	else if (offset == -FDT_ERR_BADOFFSET)
-		return -FDT_ERR_BADSTRUCTURE;
-
-	return offset; /* error from fdt_next_node() */
-}
-
-int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset,
-				 int supernodedepth, int *nodedepth)
-{
-	int offset, depth;
-	int supernodeoffset = -FDT_ERR_INTERNAL;
-
-	FDT_CHECK_HEADER(fdt);
-
-	if (supernodedepth < 0)
-		return -FDT_ERR_NOTFOUND;
-
-	for (offset = 0, depth = 0;
-	     (offset >= 0) && (offset <= nodeoffset);
-	     offset = fdt_next_node(fdt, offset, &depth)) {
-		if (depth == supernodedepth)
-			supernodeoffset = offset;
-
-		if (offset == nodeoffset) {
-			if (nodedepth)
-				*nodedepth = depth;
-
-			if (supernodedepth > depth)
-				return -FDT_ERR_NOTFOUND;
-			else
-				return supernodeoffset;
-		}
-	}
-
-	if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))
-		return -FDT_ERR_BADOFFSET;
-	else if (offset == -FDT_ERR_BADOFFSET)
-		return -FDT_ERR_BADSTRUCTURE;
-
-	return offset; /* error from fdt_next_node() */
-}
-
-int fdt_node_depth(const void *fdt, int nodeoffset)
-{
-	int nodedepth;
-	int err;
-
-	err = fdt_supernode_atdepth_offset(fdt, nodeoffset, 0, &nodedepth);
-	if (err)
-		return (err < 0) ? err : -FDT_ERR_INTERNAL;
-	return nodedepth;
-}
-
-int fdt_parent_offset(const void *fdt, int nodeoffset)
-{
-	int nodedepth = fdt_node_depth(fdt, nodeoffset);
-
-	if (nodedepth < 0)
-		return nodedepth;
-	return fdt_supernode_atdepth_offset(fdt, nodeoffset,
-					    nodedepth - 1, NULL);
-}
-
-int fdt_node_offset_by_prop_value(const void *fdt, int startoffset,
-				  const char *propname,
-				  const void *propval, int proplen)
-{
-	int offset;
-	const void *val;
-	int len;
-
-	FDT_CHECK_HEADER(fdt);
-
-	/* FIXME: The algorithm here is pretty horrible: we scan each
-	 * property of a node in fdt_getprop(), then if that didn't
-	 * find what we want, we scan over them again making our way
-	 * to the next node.  Still it's the easiest to implement
-	 * approach; performance can come later. */
-	for (offset = fdt_next_node(fdt, startoffset, NULL);
-	     offset >= 0;
-	     offset = fdt_next_node(fdt, offset, NULL)) {
-		val = fdt_getprop(fdt, offset, propname, &len);
-		if (val && (len == proplen)
-		    && (memcmp(val, propval, len) == 0))
-			return offset;
-	}
-
-	return offset; /* error from fdt_next_node() */
-}
-
-int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle)
-{
-	int offset;
-
-	if ((phandle == 0) || (phandle == (uint32_t)-1))
-		return -FDT_ERR_BADPHANDLE;
-
-	FDT_CHECK_HEADER(fdt);
-
-	/* FIXME: The algorithm here is pretty horrible: we
-	 * potentially scan each property of a node in
-	 * fdt_get_phandle(), then if that didn't find what
-	 * we want, we scan over them again making our way to the next
-	 * node.  Still it's the easiest to implement approach;
-	 * performance can come later. */
-	for (offset = fdt_next_node(fdt, -1, NULL);
-	     offset >= 0;
-	     offset = fdt_next_node(fdt, offset, NULL)) {
-		if (fdt_get_phandle(fdt, offset) == phandle)
-			return offset;
-	}
-
-	return offset; /* error from fdt_next_node() */
-}
-
-static int _fdt_stringlist_contains(const char *strlist, int listlen,
-				    const char *str)
-{
-	int len = strlen(str);
-	const char *p;
-
-	while (listlen >= len) {
-		if (memcmp(str, strlist, len+1) == 0)
-			return 1;
-		p = memchr(strlist, '\0', listlen);
-		if (!p)
-			return 0; /* malformed strlist.. */
-		listlen -= (p-strlist) + 1;
-		strlist = p + 1;
-	}
-	return 0;
-}
-
-int fdt_node_check_compatible(const void *fdt, int nodeoffset,
-			      const char *compatible)
-{
-	const void *prop;
-	int len;
-
-	prop = fdt_getprop(fdt, nodeoffset, "compatible", &len);
-	if (!prop)
-		return len;
-	if (_fdt_stringlist_contains(prop, len, compatible))
-		return 0;
-	else
-		return 1;
-}
-
-int fdt_node_offset_by_compatible(const void *fdt, int startoffset,
-				  const char *compatible)
-{
-	int offset, err;
-
-	FDT_CHECK_HEADER(fdt);
-
-	/* FIXME: The algorithm here is pretty horrible: we scan each
-	 * property of a node in fdt_node_check_compatible(), then if
-	 * that didn't find what we want, we scan over them again
-	 * making our way to the next node.  Still it's the easiest to
-	 * implement approach; performance can come later. */
-	for (offset = fdt_next_node(fdt, startoffset, NULL);
-	     offset >= 0;
-	     offset = fdt_next_node(fdt, offset, NULL)) {
-		err = fdt_node_check_compatible(fdt, offset, compatible);
-		if ((err < 0) && (err != -FDT_ERR_NOTFOUND))
-			return err;
-		else if (err == 0)
-			return offset;
-	}
-
-	return offset; /* error from fdt_next_node() */
-}
+/*

+ * libfdt - Flat Device Tree manipulation

+ * Copyright (C) 2006 David Gibson, IBM Corporation.

+ *

+ * libfdt is dual licensed: you can use it either under the terms of

+ * the GPL, or the BSD license, at your option.

+ *

+ *  a) This library is free software; you can redistribute it and/or

+ *     modify it under the terms of the GNU General Public License as

+ *     published by the Free Software Foundation; either version 2 of the

+ *     License, or (at your option) any later version.

+ *

+ *     This library is distributed in the hope that it will be useful,

+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of

+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ *     GNU General Public License for more details.

+ *

+ *     You should have received a copy of the GNU General Public

+ *     License along with this library; if not, write to the Free

+ *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,

+ *     MA 02110-1301 USA

+ *

+ * Alternatively,

+ *

+ *  b) Redistribution and use in source and binary forms, with or

+ *     without modification, are permitted provided that the following

+ *     conditions are met:

+ *

+ *     1. Redistributions of source code must retain the above

+ *        copyright notice, this list of conditions and the following

+ *        disclaimer.

+ *     2. Redistributions in binary form must reproduce the above

+ *        copyright notice, this list of conditions and the following

+ *        disclaimer in the documentation and/or other materials

+ *        provided with the distribution.

+ *

+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND

+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,

+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,

+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ */

+#include "libfdt_env.h"

+

+#include <fdt.h>

+#include <libfdt.h>

+

+#include "libfdt_internal.h"

+

+static int _fdt_nodename_eq(const void *fdt, int offset,

+			    const char *s, int len)

+{

+	const char *p = fdt_offset_ptr(fdt, offset + FDT_TAGSIZE, len+1);

+

+	if (! p)

+		/* short match */

+		return 0;

+

+	if (memcmp(p, s, len) != 0)

+		return 0;

+

+	if (p[len] == '\0')

+		return 1;

+	else if (!memchr(s, '@', len) && (p[len] == '@'))

+		return 1;

+	else

+		return 0;

+}

+

+const char *fdt_string(const void *fdt, int stroffset)

+{

+	return (const char *)fdt + fdt_off_dt_strings(fdt) + stroffset;

+}

+

+static int _fdt_string_eq(const void *fdt, int stroffset,

+			  const char *s, int len)

+{

+	const char *p = fdt_string(fdt, stroffset);

+

+	return (strlen(p) == len) && (memcmp(p, s, len) == 0);

+}

+

+int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size)

+{

+	FDT_CHECK_HEADER(fdt);

+	*address = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->address);

+	*size = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->size);

+	return 0;

+}

+

+int fdt_num_mem_rsv(const void *fdt)

+{

+	int i = 0;

+

+	while (fdt64_to_cpu(_fdt_mem_rsv(fdt, i)->size) != 0)

+		i++;

+	return i;

+}

+

+static int _nextprop(const void *fdt, int offset)

+{

+	uint32_t tag;

+	int nextoffset;

+

+	do {

+		tag = fdt_next_tag(fdt, offset, &nextoffset);

+

+		switch (tag) {

+		case FDT_END:

+			if (nextoffset >= 0)

+				return -FDT_ERR_BADSTRUCTURE;

+			else

+				return nextoffset;

+

+		case FDT_PROP:

+			return offset;

+		}

+		offset = nextoffset;

+	} while (tag == FDT_NOP);

+

+	return -FDT_ERR_NOTFOUND;

+}

+

+int fdt_subnode_offset_namelen(const void *fdt, int offset,

+			       const char *name, int namelen)

+{

+	int depth;

+

+	FDT_CHECK_HEADER(fdt);

+

+	for (depth = 0;

+	     (offset >= 0) && (depth >= 0);

+	     offset = fdt_next_node(fdt, offset, &depth))

+		if ((depth == 1)

+		    && _fdt_nodename_eq(fdt, offset, name, namelen))

+			return offset;

+

+	if (depth < 0)

+		return -FDT_ERR_NOTFOUND;

+	return offset; /* error */

+}

+

+int fdt_subnode_offset(const void *fdt, int parentoffset,

+		       const char *name)

+{

+	return fdt_subnode_offset_namelen(fdt, parentoffset, name, strlen(name));

+}

+

+int fdt_path_offset(const void *fdt, const char *path)

+{

+	const char *end = path + strlen(path);

+	const char *p = path;

+	int offset = 0;

+

+	FDT_CHECK_HEADER(fdt);

+

+	/* see if we have an alias */

+	if (*path != '/') {

+		const char *q = strchr(path, '/');

+

+		if (!q)

+			q = end;

+

+		p = fdt_get_alias_namelen(fdt, p, q - p);

+		if (!p)

+			return -FDT_ERR_BADPATH;

+		offset = fdt_path_offset(fdt, p);

+

+		p = q;

+	}

+

+	while (*p) {

+		const char *q;

+

+		while (*p == '/')

+			p++;

+		if (! *p)

+			return offset;

+		q = strchr(p, '/');

+		if (! q)

+			q = end;

+

+		offset = fdt_subnode_offset_namelen(fdt, offset, p, q-p);

+		if (offset < 0)

+			return offset;

+

+		p = q;

+	}

+

+	return offset;

+}

+

+const char *fdt_get_name(const void *fdt, int nodeoffset, int *len)

+{

+	const struct fdt_node_header *nh = _fdt_offset_ptr(fdt, nodeoffset);

+	int err;

+

+	if (((err = fdt_check_header(fdt)) != 0)

+	    || ((err = _fdt_check_node_offset(fdt, nodeoffset)) < 0))

+			goto fail;

+

+	if (len)

+		*len = strlen(nh->name);

+

+	return nh->name;

+

+ fail:

+	if (len)

+		*len = err;

+	return NULL;

+}

+

+int fdt_first_property_offset(const void *fdt, int nodeoffset)

+{

+	int offset;

+

+	if ((offset = _fdt_check_node_offset(fdt, nodeoffset)) < 0)

+		return offset;

+

+	return _nextprop(fdt, offset);

+}

+

+int fdt_next_property_offset(const void *fdt, int offset)

+{

+	if ((offset = _fdt_check_prop_offset(fdt, offset)) < 0)

+		return offset;

+

+	return _nextprop(fdt, offset);

+}

+

+const struct fdt_property *fdt_get_property_by_offset(const void *fdt,

+						      int offset,

+						      int *lenp)

+{

+	int err;

+	const struct fdt_property *prop;

+

+	if ((err = _fdt_check_prop_offset(fdt, offset)) < 0) {

+		if (lenp)

+			*lenp = err;

+		return NULL;

+	}

+

+	prop = _fdt_offset_ptr(fdt, offset);

+

+	if (lenp)

+		*lenp = fdt32_to_cpu(prop->len);

+

+	return prop;

+}

+

+const struct fdt_property *fdt_get_property_namelen(const void *fdt,

+						    int offset,

+						    const char *name,

+						    int namelen, int *lenp)

+{

+	for (offset = fdt_first_property_offset(fdt, offset);

+	     (offset >= 0);

+	     (offset = fdt_next_property_offset(fdt, offset))) {

+		const struct fdt_property *prop;

+

+		prop = fdt_get_property_by_offset(fdt, offset, lenp);

+		if (!prop) {

+			offset = -FDT_ERR_INTERNAL;

+			break;

+		}

+		if (_fdt_string_eq(fdt, fdt32_to_cpu(prop->nameoff),

+				   name, namelen))

+			return prop;

+	}

+

+	if (lenp)

+		*lenp = offset;

+	return NULL;

+}

+

+const struct fdt_property *fdt_get_property(const void *fdt,

+					    int nodeoffset,

+					    const char *name, int *lenp)

+{

+	return fdt_get_property_namelen(fdt, nodeoffset, name,

+					strlen(name), lenp);

+}

+

+const void *fdt_getprop_namelen(const void *fdt, int nodeoffset,

+				const char *name, int namelen, int *lenp)

+{

+	const struct fdt_property *prop;

+

+	prop = fdt_get_property_namelen(fdt, nodeoffset, name, namelen, lenp);

+	if (! prop)

+		return NULL;

+

+	return prop->data;

+}

+

+const void *fdt_getprop_by_offset(const void *fdt, int offset,

+				  const char **namep, int *lenp)

+{

+	const struct fdt_property *prop;

+

+	prop = fdt_get_property_by_offset(fdt, offset, lenp);

+	if (!prop)

+		return NULL;

+	if (namep)

+		*namep = fdt_string(fdt, fdt32_to_cpu(prop->nameoff));

+	return prop->data;

+}

+

+const void *fdt_getprop(const void *fdt, int nodeoffset,

+			const char *name, int *lenp)

+{

+	return fdt_getprop_namelen(fdt, nodeoffset, name, strlen(name), lenp);

+}

+

+uint32_t fdt_get_phandle(const void *fdt, int nodeoffset)

+{

+	const uint32_t *php;

+	int len;

+

+	/* FIXME: This is a bit sub-optimal, since we potentially scan

+	 * over all the properties twice. */

+	php = fdt_getprop(fdt, nodeoffset, "phandle", &len);

+	if (!php || (len != sizeof(*php))) {

+		php = fdt_getprop(fdt, nodeoffset, "linux,phandle", &len);

+		if (!php || (len != sizeof(*php)))

+			return 0;

+	}

+

+	return fdt32_to_cpu(*php);

+}

+

+const char *fdt_get_alias_namelen(const void *fdt,

+				  const char *name, int namelen)

+{

+	int aliasoffset;

+

+	aliasoffset = fdt_path_offset(fdt, "/aliases");

+	if (aliasoffset < 0)

+		return NULL;

+

+	return fdt_getprop_namelen(fdt, aliasoffset, name, namelen, NULL);

+}

+

+const char *fdt_get_alias(const void *fdt, const char *name)

+{

+	return fdt_get_alias_namelen(fdt, name, strlen(name));

+}

+

+int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen)

+{

+	int pdepth = 0, p = 0;

+	int offset, depth, namelen;

+	const char *name;

+

+	FDT_CHECK_HEADER(fdt);

+

+	if (buflen < 2)

+		return -FDT_ERR_NOSPACE;

+

+	for (offset = 0, depth = 0;

+	     (offset >= 0) && (offset <= nodeoffset);

+	     offset = fdt_next_node(fdt, offset, &depth)) {

+		while (pdepth > depth) {

+			do {

+				p--;

+			} while (buf[p-1] != '/');

+			pdepth--;

+		}

+

+		if (pdepth >= depth) {

+			name = fdt_get_name(fdt, offset, &namelen);

+			if (!name)

+				return namelen;

+			if ((p + namelen + 1) <= buflen) {

+				memcpy(buf + p, name, namelen);

+				p += namelen;

+				buf[p++] = '/';

+				pdepth++;

+			}

+		}

+

+		if (offset == nodeoffset) {

+			if (pdepth < (depth + 1))

+				return -FDT_ERR_NOSPACE;

+

+			if (p > 1) /* special case so that root path is "/", not "" */

+				p--;

+			buf[p] = '\0';

+			return 0;

+		}

+	}

+

+	if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))

+		return -FDT_ERR_BADOFFSET;

+	else if (offset == -FDT_ERR_BADOFFSET)

+		return -FDT_ERR_BADSTRUCTURE;

+

+	return offset; /* error from fdt_next_node() */

+}

+

+int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset,

+				 int supernodedepth, int *nodedepth)

+{

+	int offset, depth;

+	int supernodeoffset = -FDT_ERR_INTERNAL;

+

+	FDT_CHECK_HEADER(fdt);

+

+	if (supernodedepth < 0)

+		return -FDT_ERR_NOTFOUND;

+

+	for (offset = 0, depth = 0;

+	     (offset >= 0) && (offset <= nodeoffset);

+	     offset = fdt_next_node(fdt, offset, &depth)) {

+		if (depth == supernodedepth)

+			supernodeoffset = offset;

+

+		if (offset == nodeoffset) {

+			if (nodedepth)

+				*nodedepth = depth;

+

+			if (supernodedepth > depth)

+				return -FDT_ERR_NOTFOUND;

+			else

+				return supernodeoffset;

+		}

+	}

+

+	if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))

+		return -FDT_ERR_BADOFFSET;

+	else if (offset == -FDT_ERR_BADOFFSET)

+		return -FDT_ERR_BADSTRUCTURE;

+

+	return offset; /* error from fdt_next_node() */

+}

+

+int fdt_node_depth(const void *fdt, int nodeoffset)

+{

+	int nodedepth;

+	int err;

+

+	err = fdt_supernode_atdepth_offset(fdt, nodeoffset, 0, &nodedepth);

+	if (err)

+		return (err < 0) ? err : -FDT_ERR_INTERNAL;

+	return nodedepth;

+}

+

+int fdt_parent_offset(const void *fdt, int nodeoffset)

+{

+	int nodedepth = fdt_node_depth(fdt, nodeoffset);

+

+	if (nodedepth < 0)

+		return nodedepth;

+	return fdt_supernode_atdepth_offset(fdt, nodeoffset,

+					    nodedepth - 1, NULL);

+}

+

+int fdt_node_offset_by_prop_value(const void *fdt, int startoffset,

+				  const char *propname,

+				  const void *propval, int proplen)

+{

+	int offset;

+	const void *val;

+	int len;

+

+	FDT_CHECK_HEADER(fdt);

+

+	/* FIXME: The algorithm here is pretty horrible: we scan each

+	 * property of a node in fdt_getprop(), then if that didn't

+	 * find what we want, we scan over them again making our way

+	 * to the next node.  Still it's the easiest to implement

+	 * approach; performance can come later. */

+	for (offset = fdt_next_node(fdt, startoffset, NULL);

+	     offset >= 0;

+	     offset = fdt_next_node(fdt, offset, NULL)) {

+		val = fdt_getprop(fdt, offset, propname, &len);

+		if (val && (len == proplen)

+		    && (memcmp(val, propval, len) == 0))

+			return offset;

+	}

+

+	return offset; /* error from fdt_next_node() */

+}

+

+int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle)

+{

+	int offset;

+

+	if ((phandle == 0) || (phandle == (uint32_t)-1))

+		return -FDT_ERR_BADPHANDLE;

+

+	FDT_CHECK_HEADER(fdt);

+

+	/* FIXME: The algorithm here is pretty horrible: we

+	 * potentially scan each property of a node in

+	 * fdt_get_phandle(), then if that didn't find what

+	 * we want, we scan over them again making our way to the next

+	 * node.  Still it's the easiest to implement approach;

+	 * performance can come later. */

+	for (offset = fdt_next_node(fdt, -1, NULL);

+	     offset >= 0;

+	     offset = fdt_next_node(fdt, offset, NULL)) {

+		if (fdt_get_phandle(fdt, offset) == phandle)

+			return offset;

+	}

+

+	return offset; /* error from fdt_next_node() */

+}

+

+static int _fdt_stringlist_contains(const char *strlist, int listlen,

+				    const char *str)

+{

+	int len = strlen(str);

+	const char *p;

+

+	while (listlen >= len) {

+		if (memcmp(str, strlist, len+1) == 0)

+			return 1;

+		p = memchr(strlist, '\0', listlen);

+		if (!p)

+			return 0; /* malformed strlist.. */

+		listlen -= (p-strlist) + 1;

+		strlist = p + 1;

+	}

+	return 0;

+}

+

+int fdt_node_check_compatible(const void *fdt, int nodeoffset,

+			      const char *compatible)

+{

+	const void *prop;

+	int len;

+

+	prop = fdt_getprop(fdt, nodeoffset, "compatible", &len);

+	if (!prop)

+		return len;

+	if (_fdt_stringlist_contains(prop, len, compatible))

+		return 0;

+	else

+		return 1;

+}

+

+int fdt_node_offset_by_compatible(const void *fdt, int startoffset,

+				  const char *compatible)

+{

+	int offset, err;

+

+	FDT_CHECK_HEADER(fdt);

+

+	/* FIXME: The algorithm here is pretty horrible: we scan each

+	 * property of a node in fdt_node_check_compatible(), then if

+	 * that didn't find what we want, we scan over them again

+	 * making our way to the next node.  Still it's the easiest to

+	 * implement approach; performance can come later. */

+	for (offset = fdt_next_node(fdt, startoffset, NULL);

+	     offset >= 0;

+	     offset = fdt_next_node(fdt, offset, NULL)) {

+		err = fdt_node_check_compatible(fdt, offset, compatible);

+		if ((err < 0) && (err != -FDT_ERR_NOTFOUND))

+			return err;

+		else if (err == 0)

+			return offset;

+	}

+

+	return offset; /* error from fdt_next_node() */

+}

diff --git a/EmbeddedPkg/Library/FdtLib/fdt_rw.c b/EmbeddedPkg/Library/FdtLib/fdt_rw.c
index 878a775a..1d95a73e 100644
--- a/EmbeddedPkg/Library/FdtLib/fdt_rw.c
+++ b/EmbeddedPkg/Library/FdtLib/fdt_rw.c
@@ -1,495 +1,495 @@
-/*
- * libfdt - Flat Device Tree manipulation
- * Copyright (C) 2006 David Gibson, IBM Corporation.
- *
- * libfdt is dual licensed: you can use it either under the terms of
- * the GPL, or the BSD license, at your option.
- *
- *  a) This library is free software; you can redistribute it and/or
- *     modify it under the terms of the GNU General Public License as
- *     published by the Free Software Foundation; either version 2 of the
- *     License, or (at your option) any later version.
- *
- *     This library is distributed in the hope that it will be useful,
- *     but WITHOUT ANY WARRANTY; without even the implied warranty of
- *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *     GNU General Public License for more details.
- *
- *     You should have received a copy of the GNU General Public
- *     License along with this library; if not, write to the Free
- *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
- *     MA 02110-1301 USA
- *
- * Alternatively,
- *
- *  b) Redistribution and use in source and binary forms, with or
- *     without modification, are permitted provided that the following
- *     conditions are met:
- *
- *     1. Redistributions of source code must retain the above
- *        copyright notice, this list of conditions and the following
- *        disclaimer.
- *     2. Redistributions in binary form must reproduce the above
- *        copyright notice, this list of conditions and the following
- *        disclaimer in the documentation and/or other materials
- *        provided with the distribution.
- *
- *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
- *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
- *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include "libfdt_env.h"
-
-#include <fdt.h>
-#include <libfdt.h>
-
-#include "libfdt_internal.h"
-
-static int _fdt_blocks_misordered(const void *fdt,
-			      int mem_rsv_size, int struct_size)
-{
-	return (fdt_off_mem_rsvmap(fdt) < FDT_ALIGN(sizeof(struct fdt_header), 8))
-		|| (fdt_off_dt_struct(fdt) <
-		    (fdt_off_mem_rsvmap(fdt) + mem_rsv_size))
-		|| (fdt_off_dt_strings(fdt) <
-		    (fdt_off_dt_struct(fdt) + struct_size))
-		|| (fdt_totalsize(fdt) <
-		    (fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt)));
-}
-
-static int _fdt_rw_check_header(void *fdt)
-{
-	FDT_CHECK_HEADER(fdt);
-
-	if (fdt_version(fdt) < 17)
-		return -FDT_ERR_BADVERSION;
-	if (_fdt_blocks_misordered(fdt, sizeof(struct fdt_reserve_entry),
-				   fdt_size_dt_struct(fdt)))
-		return -FDT_ERR_BADLAYOUT;
-	if (fdt_version(fdt) > 17)
-		fdt_set_version(fdt, 17);
-
-	return 0;
-}
-
-#define FDT_RW_CHECK_HEADER(fdt) \
-	{ \
-		int err; \
-		if ((err = _fdt_rw_check_header(fdt)) != 0) \
-			return err; \
-	}
-
-static inline int _fdt_data_size(void *fdt)
-{
-	return fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt);
-}
-
-static int _fdt_splice(void *fdt, void *splicepoint, int oldlen, int newlen)
-{
-	char *p = splicepoint;
-	char *end = (char *)fdt + _fdt_data_size(fdt);
-
-	if (((p + oldlen) < p) || ((p + oldlen) > end))
-		return -FDT_ERR_BADOFFSET;
-	if ((end - oldlen + newlen) > ((char *)fdt + fdt_totalsize(fdt)))
-		return -FDT_ERR_NOSPACE;
-	memmove(p + newlen, p + oldlen, end - p - oldlen);
-	return 0;
-}
-
-static int _fdt_splice_mem_rsv(void *fdt, struct fdt_reserve_entry *p,
-			       int oldn, int newn)
-{
-	int delta = (newn - oldn) * sizeof(*p);
-	int err;
-	err = _fdt_splice(fdt, p, oldn * sizeof(*p), newn * sizeof(*p));
-	if (err)
-		return err;
-	fdt_set_off_dt_struct(fdt, fdt_off_dt_struct(fdt) + delta);
-	fdt_set_off_dt_strings(fdt, fdt_off_dt_strings(fdt) + delta);
-	return 0;
-}
-
-static int _fdt_splice_struct(void *fdt, void *p,
-			      int oldlen, int newlen)
-{
-	int delta = newlen - oldlen;
-	int err;
-
-	err = _fdt_splice(fdt, p, oldlen, newlen);
-	if (err)
-		return err;
-
-	fdt_set_size_dt_struct(fdt, fdt_size_dt_struct(fdt) + delta);
-	fdt_set_off_dt_strings(fdt, fdt_off_dt_strings(fdt) + delta);
-	return 0;
-}
-
-static int _fdt_splice_string(void *fdt, int newlen)
-{
-	void *p = (char *)fdt
-		+ fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt);
-	int err;
-
-	err = _fdt_splice(fdt, p, 0, newlen);
-	if (err)
-		return err;
-
-	fdt_set_size_dt_strings(fdt, fdt_size_dt_strings(fdt) + newlen);
-	return 0;
-}
-
-static int _fdt_find_add_string(void *fdt, const char *s)
-{
-	char *strtab = (char *)fdt + fdt_off_dt_strings(fdt);
-	const char *p;
-	char *new;
-	int len = strlen(s) + 1;
-	int err;
-
-	p = _fdt_find_string(strtab, fdt_size_dt_strings(fdt), s);
-	if (p)
-		/* found it */
-		return (p - strtab);
-
-	new = strtab + fdt_size_dt_strings(fdt);
-	err = _fdt_splice_string(fdt, len);
-	if (err)
-		return err;
-
-	memcpy(new, s, len);
-	return (new - strtab);
-}
-
-int fdt_add_mem_rsv(void *fdt, uint64_t address, uint64_t size)
-{
-	struct fdt_reserve_entry *re;
-	int err;
-
-	FDT_RW_CHECK_HEADER(fdt);
-
-	re = _fdt_mem_rsv_w(fdt, fdt_num_mem_rsv(fdt));
-	err = _fdt_splice_mem_rsv(fdt, re, 0, 1);
-	if (err)
-		return err;
-
-	re->address = cpu_to_fdt64(address);
-	re->size = cpu_to_fdt64(size);
-	return 0;
-}
-
-int fdt_del_mem_rsv(void *fdt, int n)
-{
-	struct fdt_reserve_entry *re = _fdt_mem_rsv_w(fdt, n);
-	int err;
-
-	FDT_RW_CHECK_HEADER(fdt);
-
-	if (n >= fdt_num_mem_rsv(fdt))
-		return -FDT_ERR_NOTFOUND;
-
-	err = _fdt_splice_mem_rsv(fdt, re, 1, 0);
-	if (err)
-		return err;
-	return 0;
-}
-
-static int _fdt_resize_property(void *fdt, int nodeoffset, const char *name,
-				int len, struct fdt_property **prop)
-{
-	int oldlen;
-	int err;
-
-	*prop = fdt_get_property_w(fdt, nodeoffset, name, &oldlen);
-	if (! (*prop))
-		return oldlen;
-
-	err = _fdt_splice_struct(fdt, (*prop)->data, FDT_TAGALIGN(oldlen),
-	              FDT_TAGALIGN(len));
-	if (err)
-		return err;
-
-	(*prop)->len = cpu_to_fdt32(len);
-	return 0;
-}
-
-static int _fdt_add_property(void *fdt, int nodeoffset, const char *name,
-			     int len, struct fdt_property **prop)
-{
-	int proplen;
-	int nextoffset;
-	int namestroff;
-	int err;
-
-	if ((nextoffset = _fdt_check_node_offset(fdt, nodeoffset)) < 0)
-		return nextoffset;
-
-	namestroff = _fdt_find_add_string(fdt, name);
-	if (namestroff < 0)
-		return namestroff;
-
-	*prop = _fdt_offset_ptr_w(fdt, nextoffset);
-	proplen = sizeof(**prop) + FDT_TAGALIGN(len);
-
-	err = _fdt_splice_struct(fdt, *prop, 0, proplen);
-	if (err)
-		return err;
-
-	(*prop)->tag = cpu_to_fdt32(FDT_PROP);
-	(*prop)->nameoff = cpu_to_fdt32(namestroff);
-	(*prop)->len = cpu_to_fdt32(len);
-	return 0;
-}
-
-int fdt_set_name(void *fdt, int nodeoffset, const char *name)
-{
-	char *namep;
-	int oldlen, newlen;
-	int err;
-
-	FDT_RW_CHECK_HEADER(fdt);
-
-	namep = (char *)(uintptr_t)fdt_get_name(fdt, nodeoffset, &oldlen);
-	if (!namep)
-		return oldlen;
-
-	newlen = strlen(name);
-
-	err = _fdt_splice_struct(fdt, namep, FDT_TAGALIGN(oldlen+1),
-				 FDT_TAGALIGN(newlen+1));
-	if (err)
-		return err;
-
-	memcpy(namep, name, newlen+1);
-	return 0;
-}
-
-int fdt_setprop(void *fdt, int nodeoffset, const char *name,
-		const void *val, int len)
-{
-	struct fdt_property *prop;
-	int err;
-
-	FDT_RW_CHECK_HEADER(fdt);
-
-	err = _fdt_resize_property(fdt, nodeoffset, name, len, &prop);
-	if (err == -FDT_ERR_NOTFOUND)
-		err = _fdt_add_property(fdt, nodeoffset, name, len, &prop);
-	if (err)
-		return err;
-
-	memcpy(prop->data, val, len);
-	return 0;
-}
-
-int fdt_appendprop(void *fdt, int nodeoffset, const char *name,
-		   const void *val, int len)
-{
-	struct fdt_property *prop;
-	int err, oldlen, newlen;
-
-	FDT_RW_CHECK_HEADER(fdt);
-
-	prop = fdt_get_property_w(fdt, nodeoffset, name, &oldlen);
-	if (prop) {
-		newlen = len + oldlen;
-		err = _fdt_splice_struct(fdt, prop->data,
-					 FDT_TAGALIGN(oldlen),
-					 FDT_TAGALIGN(newlen));
-		if (err)
-			return err;
-		prop->len = cpu_to_fdt32(newlen);
-		memcpy(prop->data + oldlen, val, len);
-	} else {
-		err = _fdt_add_property(fdt, nodeoffset, name, len, &prop);
-		if (err)
-			return err;
-		memcpy(prop->data, val, len);
-	}
-	return 0;
-}
-
-int fdt_delprop(void *fdt, int nodeoffset, const char *name)
-{
-	struct fdt_property *prop;
-	int len, proplen;
-
-	FDT_RW_CHECK_HEADER(fdt);
-
-	prop = fdt_get_property_w(fdt, nodeoffset, name, &len);
-	if (! prop)
-		return len;
-
-	proplen = sizeof(*prop) + FDT_TAGALIGN(len);
-	return _fdt_splice_struct(fdt, prop, proplen, 0);
-}
-
-int fdt_add_subnode_namelen(void *fdt, int parentoffset,
-			    const char *name, int namelen)
-{
-	struct fdt_node_header *nh;
-	int offset, nextoffset;
-	int nodelen;
-	int err;
-	uint32_t tag;
-	uint32_t *endtag;
-
-	FDT_RW_CHECK_HEADER(fdt);
-
-	offset = fdt_subnode_offset_namelen(fdt, parentoffset, name, namelen);
-	if (offset >= 0)
-		return -FDT_ERR_EXISTS;
-	else if (offset != -FDT_ERR_NOTFOUND)
-		return offset;
-
-	/* Try to place the new node after the parent's properties */
-	fdt_next_tag(fdt, parentoffset, &nextoffset); /* skip the BEGIN_NODE */
-	do {
-		offset = nextoffset;
-		tag = fdt_next_tag(fdt, offset, &nextoffset);
-	} while ((tag == FDT_PROP) || (tag == FDT_NOP));
-
-	nh = _fdt_offset_ptr_w(fdt, offset);
-	nodelen = sizeof(*nh) + FDT_TAGALIGN(namelen+1) + FDT_TAGSIZE;
-
-	err = _fdt_splice_struct(fdt, nh, 0, nodelen);
-	if (err)
-		return err;
-
-	nh->tag = cpu_to_fdt32(FDT_BEGIN_NODE);
-	memset(nh->name, 0, FDT_TAGALIGN(namelen+1));
-	memcpy(nh->name, name, namelen);
-	endtag = (uint32_t *)((char *)nh + nodelen - FDT_TAGSIZE);
-	*endtag = cpu_to_fdt32(FDT_END_NODE);
-
-	return offset;
-}
-
-int fdt_add_subnode(void *fdt, int parentoffset, const char *name)
-{
-	return fdt_add_subnode_namelen(fdt, parentoffset, name, strlen(name));
-}
-
-int fdt_del_node(void *fdt, int nodeoffset)
-{
-	int endoffset;
-
-	FDT_RW_CHECK_HEADER(fdt);
-
-	endoffset = _fdt_node_end_offset(fdt, nodeoffset);
-	if (endoffset < 0)
-		return endoffset;
-
-	return _fdt_splice_struct(fdt, _fdt_offset_ptr_w(fdt, nodeoffset),
-				  endoffset - nodeoffset, 0);
-}
-
-static void _fdt_packblocks(const char *old, char *new,
-			    int mem_rsv_size, int struct_size)
-{
-	int mem_rsv_off, struct_off, strings_off;
-
-	mem_rsv_off = FDT_ALIGN(sizeof(struct fdt_header), 8);
-	struct_off = mem_rsv_off + mem_rsv_size;
-	strings_off = struct_off + struct_size;
-
-	memmove(new + mem_rsv_off, old + fdt_off_mem_rsvmap(old), mem_rsv_size);
-	fdt_set_off_mem_rsvmap(new, mem_rsv_off);
-
-	memmove(new + struct_off, old + fdt_off_dt_struct(old), struct_size);
-	fdt_set_off_dt_struct(new, struct_off);
-	fdt_set_size_dt_struct(new, struct_size);
-
-	memmove(new + strings_off, old + fdt_off_dt_strings(old),
-		fdt_size_dt_strings(old));
-	fdt_set_off_dt_strings(new, strings_off);
-	fdt_set_size_dt_strings(new, fdt_size_dt_strings(old));
-}
-
-int fdt_open_into(const void *fdt, void *buf, int bufsize)
-{
-	int err;
-	int mem_rsv_size, struct_size;
-	int newsize;
-	const char *fdtstart = fdt;
-	const char *fdtend = fdtstart + fdt_totalsize(fdt);
-	char *tmp;
-
-	FDT_CHECK_HEADER(fdt);
-
-	mem_rsv_size = (fdt_num_mem_rsv(fdt)+1)
-		* sizeof(struct fdt_reserve_entry);
-
-	if (fdt_version(fdt) >= 17) {
-		struct_size = fdt_size_dt_struct(fdt);
-	} else {
-		struct_size = 0;
-		while (fdt_next_tag(fdt, struct_size, &struct_size) != FDT_END)
-			;
-		if (struct_size < 0)
-			return struct_size;
-	}
-
-	if (!_fdt_blocks_misordered(fdt, mem_rsv_size, struct_size)) {
-		/* no further work necessary */
-		err = fdt_move(fdt, buf, bufsize);
-		if (err)
-			return err;
-		fdt_set_version(buf, 17);
-		fdt_set_size_dt_struct(buf, struct_size);
-		fdt_set_totalsize(buf, bufsize);
-		return 0;
-	}
-
-	/* Need to reorder */
-	newsize = FDT_ALIGN(sizeof(struct fdt_header), 8) + mem_rsv_size
-		+ struct_size + fdt_size_dt_strings(fdt);
-
-	if (bufsize < newsize)
-		return -FDT_ERR_NOSPACE;
-
-	/* First attempt to build converted tree at beginning of buffer */
-	tmp = buf;
-	/* But if that overlaps with the old tree... */
-	if (((tmp + newsize) > fdtstart) && (tmp < fdtend)) {
-		/* Try right after the old tree instead */
-		tmp = (char *)(uintptr_t)fdtend;
-		if ((tmp + newsize) > ((char *)buf + bufsize))
-			return -FDT_ERR_NOSPACE;
-	}
-
-	_fdt_packblocks(fdt, tmp, mem_rsv_size, struct_size);
-	memmove(buf, tmp, newsize);
-
-	fdt_set_magic(buf, FDT_MAGIC);
-	fdt_set_totalsize(buf, bufsize);
-	fdt_set_version(buf, 17);
-	fdt_set_last_comp_version(buf, 16);
-	fdt_set_boot_cpuid_phys(buf, fdt_boot_cpuid_phys(fdt));
-
-	return 0;
-}
-
-int fdt_pack(void *fdt)
-{
-	int mem_rsv_size;
-
-	FDT_RW_CHECK_HEADER(fdt);
-
-	mem_rsv_size = (fdt_num_mem_rsv(fdt)+1)
-		* sizeof(struct fdt_reserve_entry);
-	_fdt_packblocks(fdt, fdt, mem_rsv_size, fdt_size_dt_struct(fdt));
-	fdt_set_totalsize(fdt, _fdt_data_size(fdt));
-
-	return 0;
-}
+/*

+ * libfdt - Flat Device Tree manipulation

+ * Copyright (C) 2006 David Gibson, IBM Corporation.

+ *

+ * libfdt is dual licensed: you can use it either under the terms of

+ * the GPL, or the BSD license, at your option.

+ *

+ *  a) This library is free software; you can redistribute it and/or

+ *     modify it under the terms of the GNU General Public License as

+ *     published by the Free Software Foundation; either version 2 of the

+ *     License, or (at your option) any later version.

+ *

+ *     This library is distributed in the hope that it will be useful,

+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of

+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ *     GNU General Public License for more details.

+ *

+ *     You should have received a copy of the GNU General Public

+ *     License along with this library; if not, write to the Free

+ *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,

+ *     MA 02110-1301 USA

+ *

+ * Alternatively,

+ *

+ *  b) Redistribution and use in source and binary forms, with or

+ *     without modification, are permitted provided that the following

+ *     conditions are met:

+ *

+ *     1. Redistributions of source code must retain the above

+ *        copyright notice, this list of conditions and the following

+ *        disclaimer.

+ *     2. Redistributions in binary form must reproduce the above

+ *        copyright notice, this list of conditions and the following

+ *        disclaimer in the documentation and/or other materials

+ *        provided with the distribution.

+ *

+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND

+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,

+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,

+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ */

+#include "libfdt_env.h"

+

+#include <fdt.h>

+#include <libfdt.h>

+

+#include "libfdt_internal.h"

+

+static int _fdt_blocks_misordered(const void *fdt,

+			      int mem_rsv_size, int struct_size)

+{

+	return (fdt_off_mem_rsvmap(fdt) < FDT_ALIGN(sizeof(struct fdt_header), 8))

+		|| (fdt_off_dt_struct(fdt) <

+		    (fdt_off_mem_rsvmap(fdt) + mem_rsv_size))

+		|| (fdt_off_dt_strings(fdt) <

+		    (fdt_off_dt_struct(fdt) + struct_size))

+		|| (fdt_totalsize(fdt) <

+		    (fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt)));

+}

+

+static int _fdt_rw_check_header(void *fdt)

+{

+	FDT_CHECK_HEADER(fdt);

+

+	if (fdt_version(fdt) < 17)

+		return -FDT_ERR_BADVERSION;

+	if (_fdt_blocks_misordered(fdt, sizeof(struct fdt_reserve_entry),

+				   fdt_size_dt_struct(fdt)))

+		return -FDT_ERR_BADLAYOUT;

+	if (fdt_version(fdt) > 17)

+		fdt_set_version(fdt, 17);

+

+	return 0;

+}

+

+#define FDT_RW_CHECK_HEADER(fdt) \

+	{ \

+		int err; \

+		if ((err = _fdt_rw_check_header(fdt)) != 0) \

+			return err; \

+	}

+

+static inline int _fdt_data_size(void *fdt)

+{

+	return fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt);

+}

+

+static int _fdt_splice(void *fdt, void *splicepoint, int oldlen, int newlen)

+{

+	char *p = splicepoint;

+	char *end = (char *)fdt + _fdt_data_size(fdt);

+

+	if (((p + oldlen) < p) || ((p + oldlen) > end))

+		return -FDT_ERR_BADOFFSET;

+	if ((end - oldlen + newlen) > ((char *)fdt + fdt_totalsize(fdt)))

+		return -FDT_ERR_NOSPACE;

+	memmove(p + newlen, p + oldlen, end - p - oldlen);

+	return 0;

+}

+

+static int _fdt_splice_mem_rsv(void *fdt, struct fdt_reserve_entry *p,

+			       int oldn, int newn)

+{

+	int delta = (newn - oldn) * sizeof(*p);

+	int err;

+	err = _fdt_splice(fdt, p, oldn * sizeof(*p), newn * sizeof(*p));

+	if (err)

+		return err;

+	fdt_set_off_dt_struct(fdt, fdt_off_dt_struct(fdt) + delta);

+	fdt_set_off_dt_strings(fdt, fdt_off_dt_strings(fdt) + delta);

+	return 0;

+}

+

+static int _fdt_splice_struct(void *fdt, void *p,

+			      int oldlen, int newlen)

+{

+	int delta = newlen - oldlen;

+	int err;

+

+	err = _fdt_splice(fdt, p, oldlen, newlen);

+	if (err)

+		return err;

+

+	fdt_set_size_dt_struct(fdt, fdt_size_dt_struct(fdt) + delta);

+	fdt_set_off_dt_strings(fdt, fdt_off_dt_strings(fdt) + delta);

+	return 0;

+}

+

+static int _fdt_splice_string(void *fdt, int newlen)

+{

+	void *p = (char *)fdt

+		+ fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt);

+	int err;

+

+	err = _fdt_splice(fdt, p, 0, newlen);

+	if (err)

+		return err;

+

+	fdt_set_size_dt_strings(fdt, fdt_size_dt_strings(fdt) + newlen);

+	return 0;

+}

+

+static int _fdt_find_add_string(void *fdt, const char *s)

+{

+	char *strtab = (char *)fdt + fdt_off_dt_strings(fdt);

+	const char *p;

+	char *new;

+	int len = strlen(s) + 1;

+	int err;

+

+	p = _fdt_find_string(strtab, fdt_size_dt_strings(fdt), s);

+	if (p)

+		/* found it */

+		return (p - strtab);

+

+	new = strtab + fdt_size_dt_strings(fdt);

+	err = _fdt_splice_string(fdt, len);

+	if (err)

+		return err;

+

+	memcpy(new, s, len);

+	return (new - strtab);

+}

+

+int fdt_add_mem_rsv(void *fdt, uint64_t address, uint64_t size)

+{

+	struct fdt_reserve_entry *re;

+	int err;

+

+	FDT_RW_CHECK_HEADER(fdt);

+

+	re = _fdt_mem_rsv_w(fdt, fdt_num_mem_rsv(fdt));

+	err = _fdt_splice_mem_rsv(fdt, re, 0, 1);

+	if (err)

+		return err;

+

+	re->address = cpu_to_fdt64(address);

+	re->size = cpu_to_fdt64(size);

+	return 0;

+}

+

+int fdt_del_mem_rsv(void *fdt, int n)

+{

+	struct fdt_reserve_entry *re = _fdt_mem_rsv_w(fdt, n);

+	int err;

+

+	FDT_RW_CHECK_HEADER(fdt);

+

+	if (n >= fdt_num_mem_rsv(fdt))

+		return -FDT_ERR_NOTFOUND;

+

+	err = _fdt_splice_mem_rsv(fdt, re, 1, 0);

+	if (err)

+		return err;

+	return 0;

+}

+

+static int _fdt_resize_property(void *fdt, int nodeoffset, const char *name,

+				int len, struct fdt_property **prop)

+{

+	int oldlen;

+	int err;

+

+	*prop = fdt_get_property_w(fdt, nodeoffset, name, &oldlen);

+	if (! (*prop))

+		return oldlen;

+

+	err = _fdt_splice_struct(fdt, (*prop)->data, FDT_TAGALIGN(oldlen),

+	              FDT_TAGALIGN(len));

+	if (err)

+		return err;

+

+	(*prop)->len = cpu_to_fdt32(len);

+	return 0;

+}

+

+static int _fdt_add_property(void *fdt, int nodeoffset, const char *name,

+			     int len, struct fdt_property **prop)

+{

+	int proplen;

+	int nextoffset;

+	int namestroff;

+	int err;

+

+	if ((nextoffset = _fdt_check_node_offset(fdt, nodeoffset)) < 0)

+		return nextoffset;

+

+	namestroff = _fdt_find_add_string(fdt, name);

+	if (namestroff < 0)

+		return namestroff;

+

+	*prop = _fdt_offset_ptr_w(fdt, nextoffset);

+	proplen = sizeof(**prop) + FDT_TAGALIGN(len);

+

+	err = _fdt_splice_struct(fdt, *prop, 0, proplen);

+	if (err)

+		return err;

+

+	(*prop)->tag = cpu_to_fdt32(FDT_PROP);

+	(*prop)->nameoff = cpu_to_fdt32(namestroff);

+	(*prop)->len = cpu_to_fdt32(len);

+	return 0;

+}

+

+int fdt_set_name(void *fdt, int nodeoffset, const char *name)

+{

+	char *namep;

+	int oldlen, newlen;

+	int err;

+

+	FDT_RW_CHECK_HEADER(fdt);

+

+	namep = (char *)(uintptr_t)fdt_get_name(fdt, nodeoffset, &oldlen);

+	if (!namep)

+		return oldlen;

+

+	newlen = strlen(name);

+

+	err = _fdt_splice_struct(fdt, namep, FDT_TAGALIGN(oldlen+1),

+				 FDT_TAGALIGN(newlen+1));

+	if (err)

+		return err;

+

+	memcpy(namep, name, newlen+1);

+	return 0;

+}

+

+int fdt_setprop(void *fdt, int nodeoffset, const char *name,

+		const void *val, int len)

+{

+	struct fdt_property *prop;

+	int err;

+

+	FDT_RW_CHECK_HEADER(fdt);

+

+	err = _fdt_resize_property(fdt, nodeoffset, name, len, &prop);

+	if (err == -FDT_ERR_NOTFOUND)

+		err = _fdt_add_property(fdt, nodeoffset, name, len, &prop);

+	if (err)

+		return err;

+

+	memcpy(prop->data, val, len);

+	return 0;

+}

+

+int fdt_appendprop(void *fdt, int nodeoffset, const char *name,

+		   const void *val, int len)

+{

+	struct fdt_property *prop;

+	int err, oldlen, newlen;

+

+	FDT_RW_CHECK_HEADER(fdt);

+

+	prop = fdt_get_property_w(fdt, nodeoffset, name, &oldlen);

+	if (prop) {

+		newlen = len + oldlen;

+		err = _fdt_splice_struct(fdt, prop->data,

+					 FDT_TAGALIGN(oldlen),

+					 FDT_TAGALIGN(newlen));

+		if (err)

+			return err;

+		prop->len = cpu_to_fdt32(newlen);

+		memcpy(prop->data + oldlen, val, len);

+	} else {

+		err = _fdt_add_property(fdt, nodeoffset, name, len, &prop);

+		if (err)

+			return err;

+		memcpy(prop->data, val, len);

+	}

+	return 0;

+}

+

+int fdt_delprop(void *fdt, int nodeoffset, const char *name)

+{

+	struct fdt_property *prop;

+	int len, proplen;

+

+	FDT_RW_CHECK_HEADER(fdt);

+

+	prop = fdt_get_property_w(fdt, nodeoffset, name, &len);

+	if (! prop)

+		return len;

+

+	proplen = sizeof(*prop) + FDT_TAGALIGN(len);

+	return _fdt_splice_struct(fdt, prop, proplen, 0);

+}

+

+int fdt_add_subnode_namelen(void *fdt, int parentoffset,

+			    const char *name, int namelen)

+{

+	struct fdt_node_header *nh;

+	int offset, nextoffset;

+	int nodelen;

+	int err;

+	uint32_t tag;

+	uint32_t *endtag;

+

+	FDT_RW_CHECK_HEADER(fdt);

+

+	offset = fdt_subnode_offset_namelen(fdt, parentoffset, name, namelen);

+	if (offset >= 0)

+		return -FDT_ERR_EXISTS;

+	else if (offset != -FDT_ERR_NOTFOUND)

+		return offset;

+

+	/* Try to place the new node after the parent's properties */

+	fdt_next_tag(fdt, parentoffset, &nextoffset); /* skip the BEGIN_NODE */

+	do {

+		offset = nextoffset;

+		tag = fdt_next_tag(fdt, offset, &nextoffset);

+	} while ((tag == FDT_PROP) || (tag == FDT_NOP));

+

+	nh = _fdt_offset_ptr_w(fdt, offset);

+	nodelen = sizeof(*nh) + FDT_TAGALIGN(namelen+1) + FDT_TAGSIZE;

+

+	err = _fdt_splice_struct(fdt, nh, 0, nodelen);

+	if (err)

+		return err;

+

+	nh->tag = cpu_to_fdt32(FDT_BEGIN_NODE);

+	memset(nh->name, 0, FDT_TAGALIGN(namelen+1));

+	memcpy(nh->name, name, namelen);

+	endtag = (uint32_t *)((char *)nh + nodelen - FDT_TAGSIZE);

+	*endtag = cpu_to_fdt32(FDT_END_NODE);

+

+	return offset;

+}

+

+int fdt_add_subnode(void *fdt, int parentoffset, const char *name)

+{

+	return fdt_add_subnode_namelen(fdt, parentoffset, name, strlen(name));

+}

+

+int fdt_del_node(void *fdt, int nodeoffset)

+{

+	int endoffset;

+

+	FDT_RW_CHECK_HEADER(fdt);

+

+	endoffset = _fdt_node_end_offset(fdt, nodeoffset);

+	if (endoffset < 0)

+		return endoffset;

+

+	return _fdt_splice_struct(fdt, _fdt_offset_ptr_w(fdt, nodeoffset),

+				  endoffset - nodeoffset, 0);

+}

+

+static void _fdt_packblocks(const char *old, char *new,

+			    int mem_rsv_size, int struct_size)

+{

+	int mem_rsv_off, struct_off, strings_off;

+

+	mem_rsv_off = FDT_ALIGN(sizeof(struct fdt_header), 8);

+	struct_off = mem_rsv_off + mem_rsv_size;

+	strings_off = struct_off + struct_size;

+

+	memmove(new + mem_rsv_off, old + fdt_off_mem_rsvmap(old), mem_rsv_size);

+	fdt_set_off_mem_rsvmap(new, mem_rsv_off);

+

+	memmove(new + struct_off, old + fdt_off_dt_struct(old), struct_size);

+	fdt_set_off_dt_struct(new, struct_off);

+	fdt_set_size_dt_struct(new, struct_size);

+

+	memmove(new + strings_off, old + fdt_off_dt_strings(old),

+		fdt_size_dt_strings(old));

+	fdt_set_off_dt_strings(new, strings_off);

+	fdt_set_size_dt_strings(new, fdt_size_dt_strings(old));

+}

+

+int fdt_open_into(const void *fdt, void *buf, int bufsize)

+{

+	int err;

+	int mem_rsv_size, struct_size;

+	int newsize;

+	const char *fdtstart = fdt;

+	const char *fdtend = fdtstart + fdt_totalsize(fdt);

+	char *tmp;

+

+	FDT_CHECK_HEADER(fdt);

+

+	mem_rsv_size = (fdt_num_mem_rsv(fdt)+1)

+		* sizeof(struct fdt_reserve_entry);

+

+	if (fdt_version(fdt) >= 17) {

+		struct_size = fdt_size_dt_struct(fdt);

+	} else {

+		struct_size = 0;

+		while (fdt_next_tag(fdt, struct_size, &struct_size) != FDT_END)

+			;

+		if (struct_size < 0)

+			return struct_size;

+	}

+

+	if (!_fdt_blocks_misordered(fdt, mem_rsv_size, struct_size)) {

+		/* no further work necessary */

+		err = fdt_move(fdt, buf, bufsize);

+		if (err)

+			return err;

+		fdt_set_version(buf, 17);

+		fdt_set_size_dt_struct(buf, struct_size);

+		fdt_set_totalsize(buf, bufsize);

+		return 0;

+	}

+

+	/* Need to reorder */

+	newsize = FDT_ALIGN(sizeof(struct fdt_header), 8) + mem_rsv_size

+		+ struct_size + fdt_size_dt_strings(fdt);

+

+	if (bufsize < newsize)

+		return -FDT_ERR_NOSPACE;

+

+	/* First attempt to build converted tree at beginning of buffer */

+	tmp = buf;

+	/* But if that overlaps with the old tree... */

+	if (((tmp + newsize) > fdtstart) && (tmp < fdtend)) {

+		/* Try right after the old tree instead */

+		tmp = (char *)(uintptr_t)fdtend;

+		if ((tmp + newsize) > ((char *)buf + bufsize))

+			return -FDT_ERR_NOSPACE;

+	}

+

+	_fdt_packblocks(fdt, tmp, mem_rsv_size, struct_size);

+	memmove(buf, tmp, newsize);

+

+	fdt_set_magic(buf, FDT_MAGIC);

+	fdt_set_totalsize(buf, bufsize);

+	fdt_set_version(buf, 17);

+	fdt_set_last_comp_version(buf, 16);

+	fdt_set_boot_cpuid_phys(buf, fdt_boot_cpuid_phys(fdt));

+

+	return 0;

+}

+

+int fdt_pack(void *fdt)

+{

+	int mem_rsv_size;

+

+	FDT_RW_CHECK_HEADER(fdt);

+

+	mem_rsv_size = (fdt_num_mem_rsv(fdt)+1)

+		* sizeof(struct fdt_reserve_entry);

+	_fdt_packblocks(fdt, fdt, mem_rsv_size, fdt_size_dt_struct(fdt));

+	fdt_set_totalsize(fdt, _fdt_data_size(fdt));

+

+	return 0;

+}

diff --git a/EmbeddedPkg/Library/FdtLib/fdt_strerror.c b/EmbeddedPkg/Library/FdtLib/fdt_strerror.c
index e6c3ceee..a49793d9 100644
--- a/EmbeddedPkg/Library/FdtLib/fdt_strerror.c
+++ b/EmbeddedPkg/Library/FdtLib/fdt_strerror.c
@@ -1,96 +1,96 @@
-/*
- * libfdt - Flat Device Tree manipulation
- * Copyright (C) 2006 David Gibson, IBM Corporation.
- *
- * libfdt is dual licensed: you can use it either under the terms of
- * the GPL, or the BSD license, at your option.
- *
- *  a) This library is free software; you can redistribute it and/or
- *     modify it under the terms of the GNU General Public License as
- *     published by the Free Software Foundation; either version 2 of the
- *     License, or (at your option) any later version.
- *
- *     This library is distributed in the hope that it will be useful,
- *     but WITHOUT ANY WARRANTY; without even the implied warranty of
- *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *     GNU General Public License for more details.
- *
- *     You should have received a copy of the GNU General Public
- *     License along with this library; if not, write to the Free
- *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
- *     MA 02110-1301 USA
- *
- * Alternatively,
- *
- *  b) Redistribution and use in source and binary forms, with or
- *     without modification, are permitted provided that the following
- *     conditions are met:
- *
- *     1. Redistributions of source code must retain the above
- *        copyright notice, this list of conditions and the following
- *        disclaimer.
- *     2. Redistributions in binary form must reproduce the above
- *        copyright notice, this list of conditions and the following
- *        disclaimer in the documentation and/or other materials
- *        provided with the distribution.
- *
- *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
- *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
- *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include "libfdt_env.h"
-
-#include <fdt.h>
-#include <libfdt.h>
-
-#include "libfdt_internal.h"
-
-struct fdt_errtabent {
-	const char *str;
-};
-
-#define FDT_ERRTABENT(val) \
-	[(val)] = { .str = #val, }
-
-static struct fdt_errtabent fdt_errtable[] = {
-	FDT_ERRTABENT(FDT_ERR_NOTFOUND),
-	FDT_ERRTABENT(FDT_ERR_EXISTS),
-	FDT_ERRTABENT(FDT_ERR_NOSPACE),
-
-	FDT_ERRTABENT(FDT_ERR_BADOFFSET),
-	FDT_ERRTABENT(FDT_ERR_BADPATH),
-	FDT_ERRTABENT(FDT_ERR_BADSTATE),
-
-	FDT_ERRTABENT(FDT_ERR_TRUNCATED),
-	FDT_ERRTABENT(FDT_ERR_BADMAGIC),
-	FDT_ERRTABENT(FDT_ERR_BADVERSION),
-	FDT_ERRTABENT(FDT_ERR_BADSTRUCTURE),
-	FDT_ERRTABENT(FDT_ERR_BADLAYOUT),
-};
-#define FDT_ERRTABSIZE	(sizeof(fdt_errtable) / sizeof(fdt_errtable[0]))
-
-const char *fdt_strerror(int errval)
-{
-	if (errval > 0)
-		return "<valid offset/length>";
-	else if (errval == 0)
-		return "<no error>";
-	else if (errval > -FDT_ERRTABSIZE) {
-		const char *s = fdt_errtable[-errval].str;
-
-		if (s)
-			return s;
-	}
-
-	return "<unknown error>";
-}
+/*

+ * libfdt - Flat Device Tree manipulation

+ * Copyright (C) 2006 David Gibson, IBM Corporation.

+ *

+ * libfdt is dual licensed: you can use it either under the terms of

+ * the GPL, or the BSD license, at your option.

+ *

+ *  a) This library is free software; you can redistribute it and/or

+ *     modify it under the terms of the GNU General Public License as

+ *     published by the Free Software Foundation; either version 2 of the

+ *     License, or (at your option) any later version.

+ *

+ *     This library is distributed in the hope that it will be useful,

+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of

+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ *     GNU General Public License for more details.

+ *

+ *     You should have received a copy of the GNU General Public

+ *     License along with this library; if not, write to the Free

+ *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,

+ *     MA 02110-1301 USA

+ *

+ * Alternatively,

+ *

+ *  b) Redistribution and use in source and binary forms, with or

+ *     without modification, are permitted provided that the following

+ *     conditions are met:

+ *

+ *     1. Redistributions of source code must retain the above

+ *        copyright notice, this list of conditions and the following

+ *        disclaimer.

+ *     2. Redistributions in binary form must reproduce the above

+ *        copyright notice, this list of conditions and the following

+ *        disclaimer in the documentation and/or other materials

+ *        provided with the distribution.

+ *

+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND

+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,

+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,

+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ */

+#include "libfdt_env.h"

+

+#include <fdt.h>

+#include <libfdt.h>

+

+#include "libfdt_internal.h"

+

+struct fdt_errtabent {

+	const char *str;

+};

+

+#define FDT_ERRTABENT(val) \

+	[(val)] = { .str = #val, }

+

+static struct fdt_errtabent fdt_errtable[] = {

+	FDT_ERRTABENT(FDT_ERR_NOTFOUND),

+	FDT_ERRTABENT(FDT_ERR_EXISTS),

+	FDT_ERRTABENT(FDT_ERR_NOSPACE),

+

+	FDT_ERRTABENT(FDT_ERR_BADOFFSET),

+	FDT_ERRTABENT(FDT_ERR_BADPATH),

+	FDT_ERRTABENT(FDT_ERR_BADSTATE),

+

+	FDT_ERRTABENT(FDT_ERR_TRUNCATED),

+	FDT_ERRTABENT(FDT_ERR_BADMAGIC),

+	FDT_ERRTABENT(FDT_ERR_BADVERSION),

+	FDT_ERRTABENT(FDT_ERR_BADSTRUCTURE),

+	FDT_ERRTABENT(FDT_ERR_BADLAYOUT),

+};

+#define FDT_ERRTABSIZE	(sizeof(fdt_errtable) / sizeof(fdt_errtable[0]))

+

+const char *fdt_strerror(int errval)

+{

+	if (errval > 0)

+		return "<valid offset/length>";

+	else if (errval == 0)

+		return "<no error>";

+	else if (errval > -FDT_ERRTABSIZE) {

+		const char *s = fdt_errtable[-errval].str;

+

+		if (s)

+			return s;

+	}

+

+	return "<unknown error>";

+}

diff --git a/EmbeddedPkg/Library/FdtLib/fdt_sw.c b/EmbeddedPkg/Library/FdtLib/fdt_sw.c
index 55ebebf1..240fabc5 100644
--- a/EmbeddedPkg/Library/FdtLib/fdt_sw.c
+++ b/EmbeddedPkg/Library/FdtLib/fdt_sw.c
@@ -1,256 +1,256 @@
-/*
- * libfdt - Flat Device Tree manipulation
- * Copyright (C) 2006 David Gibson, IBM Corporation.
- *
- * libfdt is dual licensed: you can use it either under the terms of
- * the GPL, or the BSD license, at your option.
- *
- *  a) This library is free software; you can redistribute it and/or
- *     modify it under the terms of the GNU General Public License as
- *     published by the Free Software Foundation; either version 2 of the
- *     License, or (at your option) any later version.
- *
- *     This library is distributed in the hope that it will be useful,
- *     but WITHOUT ANY WARRANTY; without even the implied warranty of
- *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *     GNU General Public License for more details.
- *
- *     You should have received a copy of the GNU General Public
- *     License along with this library; if not, write to the Free
- *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
- *     MA 02110-1301 USA
- *
- * Alternatively,
- *
- *  b) Redistribution and use in source and binary forms, with or
- *     without modification, are permitted provided that the following
- *     conditions are met:
- *
- *     1. Redistributions of source code must retain the above
- *        copyright notice, this list of conditions and the following
- *        disclaimer.
- *     2. Redistributions in binary form must reproduce the above
- *        copyright notice, this list of conditions and the following
- *        disclaimer in the documentation and/or other materials
- *        provided with the distribution.
- *
- *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
- *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
- *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include "libfdt_env.h"
-
-#include <fdt.h>
-#include <libfdt.h>
-
-#include "libfdt_internal.h"
-
-static int _fdt_sw_check_header(void *fdt)
-{
-	if (fdt_magic(fdt) != FDT_SW_MAGIC)
-		return -FDT_ERR_BADMAGIC;
-	/* FIXME: should check more details about the header state */
-	return 0;
-}
-
-#define FDT_SW_CHECK_HEADER(fdt) \
-	{ \
-		int err; \
-		if ((err = _fdt_sw_check_header(fdt)) != 0) \
-			return err; \
-	}
-
-static void *_fdt_grab_space(void *fdt, size_t len)
-{
-	int offset = fdt_size_dt_struct(fdt);
-	int spaceleft;
-
-	spaceleft = fdt_totalsize(fdt) - fdt_off_dt_struct(fdt)
-		- fdt_size_dt_strings(fdt);
-
-	if ((offset + len < offset) || (offset + len > spaceleft))
-		return NULL;
-
-	fdt_set_size_dt_struct(fdt, offset + len);
-	return _fdt_offset_ptr_w(fdt, offset);
-}
-
-int fdt_create(void *buf, int bufsize)
-{
-	void *fdt = buf;
-
-	if (bufsize < sizeof(struct fdt_header))
-		return -FDT_ERR_NOSPACE;
-
-	memset(buf, 0, bufsize);
-
-	fdt_set_magic(fdt, FDT_SW_MAGIC);
-	fdt_set_version(fdt, FDT_LAST_SUPPORTED_VERSION);
-	fdt_set_last_comp_version(fdt, FDT_FIRST_SUPPORTED_VERSION);
-	fdt_set_totalsize(fdt,  bufsize);
-
-	fdt_set_off_mem_rsvmap(fdt, FDT_ALIGN(sizeof(struct fdt_header),
-					      sizeof(struct fdt_reserve_entry)));
-	fdt_set_off_dt_struct(fdt, fdt_off_mem_rsvmap(fdt));
-	fdt_set_off_dt_strings(fdt, bufsize);
-
-	return 0;
-}
-
-int fdt_add_reservemap_entry(void *fdt, uint64_t addr, uint64_t size)
-{
-	struct fdt_reserve_entry *re;
-	int offset;
-
-	FDT_SW_CHECK_HEADER(fdt);
-
-	if (fdt_size_dt_struct(fdt))
-		return -FDT_ERR_BADSTATE;
-
-	offset = fdt_off_dt_struct(fdt);
-	if ((offset + sizeof(*re)) > fdt_totalsize(fdt))
-		return -FDT_ERR_NOSPACE;
-
-	re = (struct fdt_reserve_entry *)((char *)fdt + offset);
-	re->address = cpu_to_fdt64(addr);
-	re->size = cpu_to_fdt64(size);
-
-	fdt_set_off_dt_struct(fdt, offset + sizeof(*re));
-
-	return 0;
-}
-
-int fdt_finish_reservemap(void *fdt)
-{
-	return fdt_add_reservemap_entry(fdt, 0, 0);
-}
-
-int fdt_begin_node(void *fdt, const char *name)
-{
-	struct fdt_node_header *nh;
-	int namelen = strlen(name) + 1;
-
-	FDT_SW_CHECK_HEADER(fdt);
-
-	nh = _fdt_grab_space(fdt, sizeof(*nh) + FDT_TAGALIGN(namelen));
-	if (! nh)
-		return -FDT_ERR_NOSPACE;
-
-	nh->tag = cpu_to_fdt32(FDT_BEGIN_NODE);
-	memcpy(nh->name, name, namelen);
-	return 0;
-}
-
-int fdt_end_node(void *fdt)
-{
-	uint32_t *en;
-
-	FDT_SW_CHECK_HEADER(fdt);
-
-	en = _fdt_grab_space(fdt, FDT_TAGSIZE);
-	if (! en)
-		return -FDT_ERR_NOSPACE;
-
-	*en = cpu_to_fdt32(FDT_END_NODE);
-	return 0;
-}
-
-static int _fdt_find_add_string(void *fdt, const char *s)
-{
-	char *strtab = (char *)fdt + fdt_totalsize(fdt);
-	const char *p;
-	int strtabsize = fdt_size_dt_strings(fdt);
-	int len = strlen(s) + 1;
-	int struct_top, offset;
-
-	p = _fdt_find_string(strtab - strtabsize, strtabsize, s);
-	if (p)
-		return p - strtab;
-
-	/* Add it */
-	offset = -strtabsize - len;
-	struct_top = fdt_off_dt_struct(fdt) + fdt_size_dt_struct(fdt);
-	if (fdt_totalsize(fdt) + offset < struct_top)
-		return 0; /* no more room :( */
-
-	memcpy(strtab + offset, s, len);
-	fdt_set_size_dt_strings(fdt, strtabsize + len);
-	return offset;
-}
-
-int fdt_property(void *fdt, const char *name, const void *val, int len)
-{
-	struct fdt_property *prop;
-	int nameoff;
-
-	FDT_SW_CHECK_HEADER(fdt);
-
-	nameoff = _fdt_find_add_string(fdt, name);
-	if (nameoff == 0)
-		return -FDT_ERR_NOSPACE;
-
-	prop = _fdt_grab_space(fdt, sizeof(*prop) + FDT_TAGALIGN(len));
-	if (! prop)
-		return -FDT_ERR_NOSPACE;
-
-	prop->tag = cpu_to_fdt32(FDT_PROP);
-	prop->nameoff = cpu_to_fdt32(nameoff);
-	prop->len = cpu_to_fdt32(len);
-	memcpy(prop->data, val, len);
-	return 0;
-}
-
-int fdt_finish(void *fdt)
-{
-	char *p = (char *)fdt;
-	uint32_t *end;
-	int oldstroffset, newstroffset;
-	uint32_t tag;
-	int offset, nextoffset;
-
-	FDT_SW_CHECK_HEADER(fdt);
-
-	/* Add terminator */
-	end = _fdt_grab_space(fdt, sizeof(*end));
-	if (! end)
-		return -FDT_ERR_NOSPACE;
-	*end = cpu_to_fdt32(FDT_END);
-
-	/* Relocate the string table */
-	oldstroffset = fdt_totalsize(fdt) - fdt_size_dt_strings(fdt);
-	newstroffset = fdt_off_dt_struct(fdt) + fdt_size_dt_struct(fdt);
-	memmove(p + newstroffset, p + oldstroffset, fdt_size_dt_strings(fdt));
-	fdt_set_off_dt_strings(fdt, newstroffset);
-
-	/* Walk the structure, correcting string offsets */
-	offset = 0;
-	while ((tag = fdt_next_tag(fdt, offset, &nextoffset)) != FDT_END) {
-		if (tag == FDT_PROP) {
-			struct fdt_property *prop =
-				_fdt_offset_ptr_w(fdt, offset);
-			int nameoff;
-
-			nameoff = fdt32_to_cpu(prop->nameoff);
-			nameoff += fdt_size_dt_strings(fdt);
-			prop->nameoff = cpu_to_fdt32(nameoff);
-		}
-		offset = nextoffset;
-	}
-	if (nextoffset < 0)
-		return nextoffset;
-
-	/* Finally, adjust the header */
-	fdt_set_totalsize(fdt, newstroffset + fdt_size_dt_strings(fdt));
-	fdt_set_magic(fdt, FDT_MAGIC);
-	return 0;
-}
+/*

+ * libfdt - Flat Device Tree manipulation

+ * Copyright (C) 2006 David Gibson, IBM Corporation.

+ *

+ * libfdt is dual licensed: you can use it either under the terms of

+ * the GPL, or the BSD license, at your option.

+ *

+ *  a) This library is free software; you can redistribute it and/or

+ *     modify it under the terms of the GNU General Public License as

+ *     published by the Free Software Foundation; either version 2 of the

+ *     License, or (at your option) any later version.

+ *

+ *     This library is distributed in the hope that it will be useful,

+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of

+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ *     GNU General Public License for more details.

+ *

+ *     You should have received a copy of the GNU General Public

+ *     License along with this library; if not, write to the Free

+ *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,

+ *     MA 02110-1301 USA

+ *

+ * Alternatively,

+ *

+ *  b) Redistribution and use in source and binary forms, with or

+ *     without modification, are permitted provided that the following

+ *     conditions are met:

+ *

+ *     1. Redistributions of source code must retain the above

+ *        copyright notice, this list of conditions and the following

+ *        disclaimer.

+ *     2. Redistributions in binary form must reproduce the above

+ *        copyright notice, this list of conditions and the following

+ *        disclaimer in the documentation and/or other materials

+ *        provided with the distribution.

+ *

+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND

+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,

+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,

+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ */

+#include "libfdt_env.h"

+

+#include <fdt.h>

+#include <libfdt.h>

+

+#include "libfdt_internal.h"

+

+static int _fdt_sw_check_header(void *fdt)

+{

+	if (fdt_magic(fdt) != FDT_SW_MAGIC)

+		return -FDT_ERR_BADMAGIC;

+	/* FIXME: should check more details about the header state */

+	return 0;

+}

+

+#define FDT_SW_CHECK_HEADER(fdt) \

+	{ \

+		int err; \

+		if ((err = _fdt_sw_check_header(fdt)) != 0) \

+			return err; \

+	}

+

+static void *_fdt_grab_space(void *fdt, size_t len)

+{

+	int offset = fdt_size_dt_struct(fdt);

+	int spaceleft;

+

+	spaceleft = fdt_totalsize(fdt) - fdt_off_dt_struct(fdt)

+		- fdt_size_dt_strings(fdt);

+

+	if ((offset + len < offset) || (offset + len > spaceleft))

+		return NULL;

+

+	fdt_set_size_dt_struct(fdt, offset + len);

+	return _fdt_offset_ptr_w(fdt, offset);

+}

+

+int fdt_create(void *buf, int bufsize)

+{

+	void *fdt = buf;

+

+	if (bufsize < sizeof(struct fdt_header))

+		return -FDT_ERR_NOSPACE;

+

+	memset(buf, 0, bufsize);

+

+	fdt_set_magic(fdt, FDT_SW_MAGIC);

+	fdt_set_version(fdt, FDT_LAST_SUPPORTED_VERSION);

+	fdt_set_last_comp_version(fdt, FDT_FIRST_SUPPORTED_VERSION);

+	fdt_set_totalsize(fdt,  bufsize);

+

+	fdt_set_off_mem_rsvmap(fdt, FDT_ALIGN(sizeof(struct fdt_header),

+					      sizeof(struct fdt_reserve_entry)));

+	fdt_set_off_dt_struct(fdt, fdt_off_mem_rsvmap(fdt));

+	fdt_set_off_dt_strings(fdt, bufsize);

+

+	return 0;

+}

+

+int fdt_add_reservemap_entry(void *fdt, uint64_t addr, uint64_t size)

+{

+	struct fdt_reserve_entry *re;

+	int offset;

+

+	FDT_SW_CHECK_HEADER(fdt);

+

+	if (fdt_size_dt_struct(fdt))

+		return -FDT_ERR_BADSTATE;

+

+	offset = fdt_off_dt_struct(fdt);

+	if ((offset + sizeof(*re)) > fdt_totalsize(fdt))

+		return -FDT_ERR_NOSPACE;

+

+	re = (struct fdt_reserve_entry *)((char *)fdt + offset);

+	re->address = cpu_to_fdt64(addr);

+	re->size = cpu_to_fdt64(size);

+

+	fdt_set_off_dt_struct(fdt, offset + sizeof(*re));

+

+	return 0;

+}

+

+int fdt_finish_reservemap(void *fdt)

+{

+	return fdt_add_reservemap_entry(fdt, 0, 0);

+}

+

+int fdt_begin_node(void *fdt, const char *name)

+{

+	struct fdt_node_header *nh;

+	int namelen = strlen(name) + 1;

+

+	FDT_SW_CHECK_HEADER(fdt);

+

+	nh = _fdt_grab_space(fdt, sizeof(*nh) + FDT_TAGALIGN(namelen));

+	if (! nh)

+		return -FDT_ERR_NOSPACE;

+

+	nh->tag = cpu_to_fdt32(FDT_BEGIN_NODE);

+	memcpy(nh->name, name, namelen);

+	return 0;

+}

+

+int fdt_end_node(void *fdt)

+{

+	uint32_t *en;

+

+	FDT_SW_CHECK_HEADER(fdt);

+

+	en = _fdt_grab_space(fdt, FDT_TAGSIZE);

+	if (! en)

+		return -FDT_ERR_NOSPACE;

+

+	*en = cpu_to_fdt32(FDT_END_NODE);

+	return 0;

+}

+

+static int _fdt_find_add_string(void *fdt, const char *s)

+{

+	char *strtab = (char *)fdt + fdt_totalsize(fdt);

+	const char *p;

+	int strtabsize = fdt_size_dt_strings(fdt);

+	int len = strlen(s) + 1;

+	int struct_top, offset;

+

+	p = _fdt_find_string(strtab - strtabsize, strtabsize, s);

+	if (p)

+		return p - strtab;

+

+	/* Add it */

+	offset = -strtabsize - len;

+	struct_top = fdt_off_dt_struct(fdt) + fdt_size_dt_struct(fdt);

+	if (fdt_totalsize(fdt) + offset < struct_top)

+		return 0; /* no more room :( */

+

+	memcpy(strtab + offset, s, len);

+	fdt_set_size_dt_strings(fdt, strtabsize + len);

+	return offset;

+}

+

+int fdt_property(void *fdt, const char *name, const void *val, int len)

+{

+	struct fdt_property *prop;

+	int nameoff;

+

+	FDT_SW_CHECK_HEADER(fdt);

+

+	nameoff = _fdt_find_add_string(fdt, name);

+	if (nameoff == 0)

+		return -FDT_ERR_NOSPACE;

+

+	prop = _fdt_grab_space(fdt, sizeof(*prop) + FDT_TAGALIGN(len));

+	if (! prop)

+		return -FDT_ERR_NOSPACE;

+

+	prop->tag = cpu_to_fdt32(FDT_PROP);

+	prop->nameoff = cpu_to_fdt32(nameoff);

+	prop->len = cpu_to_fdt32(len);

+	memcpy(prop->data, val, len);

+	return 0;

+}

+

+int fdt_finish(void *fdt)

+{

+	char *p = (char *)fdt;

+	uint32_t *end;

+	int oldstroffset, newstroffset;

+	uint32_t tag;

+	int offset, nextoffset;

+

+	FDT_SW_CHECK_HEADER(fdt);

+

+	/* Add terminator */

+	end = _fdt_grab_space(fdt, sizeof(*end));

+	if (! end)

+		return -FDT_ERR_NOSPACE;

+	*end = cpu_to_fdt32(FDT_END);

+

+	/* Relocate the string table */

+	oldstroffset = fdt_totalsize(fdt) - fdt_size_dt_strings(fdt);

+	newstroffset = fdt_off_dt_struct(fdt) + fdt_size_dt_struct(fdt);

+	memmove(p + newstroffset, p + oldstroffset, fdt_size_dt_strings(fdt));

+	fdt_set_off_dt_strings(fdt, newstroffset);

+

+	/* Walk the structure, correcting string offsets */

+	offset = 0;

+	while ((tag = fdt_next_tag(fdt, offset, &nextoffset)) != FDT_END) {

+		if (tag == FDT_PROP) {

+			struct fdt_property *prop =

+				_fdt_offset_ptr_w(fdt, offset);

+			int nameoff;

+

+			nameoff = fdt32_to_cpu(prop->nameoff);

+			nameoff += fdt_size_dt_strings(fdt);

+			prop->nameoff = cpu_to_fdt32(nameoff);

+		}

+		offset = nextoffset;

+	}

+	if (nextoffset < 0)

+		return nextoffset;

+

+	/* Finally, adjust the header */

+	fdt_set_totalsize(fdt, newstroffset + fdt_size_dt_strings(fdt));

+	fdt_set_magic(fdt, FDT_MAGIC);

+	return 0;

+}

diff --git a/EmbeddedPkg/Library/FdtLib/fdt_wip.c b/EmbeddedPkg/Library/FdtLib/fdt_wip.c
index 6025fa1f..e009a88f 100644
--- a/EmbeddedPkg/Library/FdtLib/fdt_wip.c
+++ b/EmbeddedPkg/Library/FdtLib/fdt_wip.c
@@ -1,118 +1,118 @@
-/*
- * libfdt - Flat Device Tree manipulation
- * Copyright (C) 2006 David Gibson, IBM Corporation.
- *
- * libfdt is dual licensed: you can use it either under the terms of
- * the GPL, or the BSD license, at your option.
- *
- *  a) This library is free software; you can redistribute it and/or
- *     modify it under the terms of the GNU General Public License as
- *     published by the Free Software Foundation; either version 2 of the
- *     License, or (at your option) any later version.
- *
- *     This library is distributed in the hope that it will be useful,
- *     but WITHOUT ANY WARRANTY; without even the implied warranty of
- *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *     GNU General Public License for more details.
- *
- *     You should have received a copy of the GNU General Public
- *     License along with this library; if not, write to the Free
- *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
- *     MA 02110-1301 USA
- *
- * Alternatively,
- *
- *  b) Redistribution and use in source and binary forms, with or
- *     without modification, are permitted provided that the following
- *     conditions are met:
- *
- *     1. Redistributions of source code must retain the above
- *        copyright notice, this list of conditions and the following
- *        disclaimer.
- *     2. Redistributions in binary form must reproduce the above
- *        copyright notice, this list of conditions and the following
- *        disclaimer in the documentation and/or other materials
- *        provided with the distribution.
- *
- *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
- *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
- *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include "libfdt_env.h"
-
-#include <fdt.h>
-#include <libfdt.h>
-
-#include "libfdt_internal.h"
-
-int fdt_setprop_inplace(void *fdt, int nodeoffset, const char *name,
-			const void *val, int len)
-{
-	void *propval;
-	int proplen;
-
-	propval = fdt_getprop_w(fdt, nodeoffset, name, &proplen);
-	if (! propval)
-		return proplen;
-
-	if (proplen != len)
-		return -FDT_ERR_NOSPACE;
-
-	memcpy(propval, val, len);
-	return 0;
-}
-
-static void _fdt_nop_region(void *start, int len)
-{
-	uint32_t *p;
-
-	for (p = start; (char *)p < ((char *)start + len); p++)
-		*p = cpu_to_fdt32(FDT_NOP);
-}
-
-int fdt_nop_property(void *fdt, int nodeoffset, const char *name)
-{
-	struct fdt_property *prop;
-	int len;
-
-	prop = fdt_get_property_w(fdt, nodeoffset, name, &len);
-	if (! prop)
-		return len;
-
-	_fdt_nop_region(prop, len + sizeof(*prop));
-
-	return 0;
-}
-
-int _fdt_node_end_offset(void *fdt, int offset)
-{
-	int depth = 0;
-
-	while ((offset >= 0) && (depth >= 0))
-		offset = fdt_next_node(fdt, offset, &depth);
-
-	return offset;
-}
-
-int fdt_nop_node(void *fdt, int nodeoffset)
-{
-	int endoffset;
-
-	endoffset = _fdt_node_end_offset(fdt, nodeoffset);
-	if (endoffset < 0)
-		return endoffset;
-
-	_fdt_nop_region(fdt_offset_ptr_w(fdt, nodeoffset, 0),
-			endoffset - nodeoffset);
-	return 0;
-}
+/*

+ * libfdt - Flat Device Tree manipulation

+ * Copyright (C) 2006 David Gibson, IBM Corporation.

+ *

+ * libfdt is dual licensed: you can use it either under the terms of

+ * the GPL, or the BSD license, at your option.

+ *

+ *  a) This library is free software; you can redistribute it and/or

+ *     modify it under the terms of the GNU General Public License as

+ *     published by the Free Software Foundation; either version 2 of the

+ *     License, or (at your option) any later version.

+ *

+ *     This library is distributed in the hope that it will be useful,

+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of

+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ *     GNU General Public License for more details.

+ *

+ *     You should have received a copy of the GNU General Public

+ *     License along with this library; if not, write to the Free

+ *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,

+ *     MA 02110-1301 USA

+ *

+ * Alternatively,

+ *

+ *  b) Redistribution and use in source and binary forms, with or

+ *     without modification, are permitted provided that the following

+ *     conditions are met:

+ *

+ *     1. Redistributions of source code must retain the above

+ *        copyright notice, this list of conditions and the following

+ *        disclaimer.

+ *     2. Redistributions in binary form must reproduce the above

+ *        copyright notice, this list of conditions and the following

+ *        disclaimer in the documentation and/or other materials

+ *        provided with the distribution.

+ *

+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND

+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,

+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,

+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ */

+#include "libfdt_env.h"

+

+#include <fdt.h>

+#include <libfdt.h>

+

+#include "libfdt_internal.h"

+

+int fdt_setprop_inplace(void *fdt, int nodeoffset, const char *name,

+			const void *val, int len)

+{

+	void *propval;

+	int proplen;

+

+	propval = fdt_getprop_w(fdt, nodeoffset, name, &proplen);

+	if (! propval)

+		return proplen;

+

+	if (proplen != len)

+		return -FDT_ERR_NOSPACE;

+

+	memcpy(propval, val, len);

+	return 0;

+}

+

+static void _fdt_nop_region(void *start, int len)

+{

+	uint32_t *p;

+

+	for (p = start; (char *)p < ((char *)start + len); p++)

+		*p = cpu_to_fdt32(FDT_NOP);

+}

+

+int fdt_nop_property(void *fdt, int nodeoffset, const char *name)

+{

+	struct fdt_property *prop;

+	int len;

+

+	prop = fdt_get_property_w(fdt, nodeoffset, name, &len);

+	if (! prop)

+		return len;

+

+	_fdt_nop_region(prop, len + sizeof(*prop));

+

+	return 0;

+}

+

+int _fdt_node_end_offset(void *fdt, int offset)

+{

+	int depth = 0;

+

+	while ((offset >= 0) && (depth >= 0))

+		offset = fdt_next_node(fdt, offset, &depth);

+

+	return offset;

+}

+

+int fdt_nop_node(void *fdt, int nodeoffset)

+{

+	int endoffset;

+

+	endoffset = _fdt_node_end_offset(fdt, nodeoffset);

+	if (endoffset < 0)

+		return endoffset;

+

+	_fdt_nop_region(fdt_offset_ptr_w(fdt, nodeoffset, 0),

+			endoffset - nodeoffset);

+	return 0;

+}

diff --git a/EmbeddedPkg/Library/FdtLib/libfdt_internal.h b/EmbeddedPkg/Library/FdtLib/libfdt_internal.h
index 381133ba..15456110 100644
--- a/EmbeddedPkg/Library/FdtLib/libfdt_internal.h
+++ b/EmbeddedPkg/Library/FdtLib/libfdt_internal.h
@@ -1,95 +1,95 @@
-#ifndef _LIBFDT_INTERNAL_H
-#define _LIBFDT_INTERNAL_H
-/*
- * libfdt - Flat Device Tree manipulation
- * Copyright (C) 2006 David Gibson, IBM Corporation.
- *
- * libfdt is dual licensed: you can use it either under the terms of
- * the GPL, or the BSD license, at your option.
- *
- *  a) This library is free software; you can redistribute it and/or
- *     modify it under the terms of the GNU General Public License as
- *     published by the Free Software Foundation; either version 2 of the
- *     License, or (at your option) any later version.
- *
- *     This library is distributed in the hope that it will be useful,
- *     but WITHOUT ANY WARRANTY; without even the implied warranty of
- *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *     GNU General Public License for more details.
- *
- *     You should have received a copy of the GNU General Public
- *     License along with this library; if not, write to the Free
- *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
- *     MA 02110-1301 USA
- *
- * Alternatively,
- *
- *  b) Redistribution and use in source and binary forms, with or
- *     without modification, are permitted provided that the following
- *     conditions are met:
- *
- *     1. Redistributions of source code must retain the above
- *        copyright notice, this list of conditions and the following
- *        disclaimer.
- *     2. Redistributions in binary form must reproduce the above
- *        copyright notice, this list of conditions and the following
- *        disclaimer in the documentation and/or other materials
- *        provided with the distribution.
- *
- *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
- *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
- *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include <fdt.h>
-
-#define FDT_ALIGN(x, a)		(((x) + (a) - 1) & ~((a) - 1))
-#define FDT_TAGALIGN(x)		(FDT_ALIGN((x), FDT_TAGSIZE))
-
-#define FDT_CHECK_HEADER(fdt) \
-	{ \
-		int err; \
-		if ((err = fdt_check_header(fdt)) != 0) \
-			return err; \
-	}
-
-int _fdt_check_node_offset(const void *fdt, int offset);
-int _fdt_check_prop_offset(const void *fdt, int offset);
-const char *_fdt_find_string(const char *strtab, int tabsize, const char *s);
-int _fdt_node_end_offset(void *fdt, int nodeoffset);
-
-static inline const void *_fdt_offset_ptr(const void *fdt, int offset)
-{
-	return (const char *)fdt + fdt_off_dt_struct(fdt) + offset;
-}
-
-static inline void *_fdt_offset_ptr_w(void *fdt, int offset)
-{
-	return (void *)(uintptr_t)_fdt_offset_ptr(fdt, offset);
-}
-
-static inline const struct fdt_reserve_entry *_fdt_mem_rsv(const void *fdt, int n)
-{
-	const struct fdt_reserve_entry *rsv_table =
-		(const struct fdt_reserve_entry *)
-		((const char *)fdt + fdt_off_mem_rsvmap(fdt));
-
-	return rsv_table + n;
-}
-static inline struct fdt_reserve_entry *_fdt_mem_rsv_w(void *fdt, int n)
-{
-	return (void *)(uintptr_t)_fdt_mem_rsv(fdt, n);
-}
-
-#define FDT_SW_MAGIC		(~FDT_MAGIC)
-
-#endif /* _LIBFDT_INTERNAL_H */
+#ifndef _LIBFDT_INTERNAL_H

+#define _LIBFDT_INTERNAL_H

+/*

+ * libfdt - Flat Device Tree manipulation

+ * Copyright (C) 2006 David Gibson, IBM Corporation.

+ *

+ * libfdt is dual licensed: you can use it either under the terms of

+ * the GPL, or the BSD license, at your option.

+ *

+ *  a) This library is free software; you can redistribute it and/or

+ *     modify it under the terms of the GNU General Public License as

+ *     published by the Free Software Foundation; either version 2 of the

+ *     License, or (at your option) any later version.

+ *

+ *     This library is distributed in the hope that it will be useful,

+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of

+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ *     GNU General Public License for more details.

+ *

+ *     You should have received a copy of the GNU General Public

+ *     License along with this library; if not, write to the Free

+ *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,

+ *     MA 02110-1301 USA

+ *

+ * Alternatively,

+ *

+ *  b) Redistribution and use in source and binary forms, with or

+ *     without modification, are permitted provided that the following

+ *     conditions are met:

+ *

+ *     1. Redistributions of source code must retain the above

+ *        copyright notice, this list of conditions and the following

+ *        disclaimer.

+ *     2. Redistributions in binary form must reproduce the above

+ *        copyright notice, this list of conditions and the following

+ *        disclaimer in the documentation and/or other materials

+ *        provided with the distribution.

+ *

+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND

+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,

+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,

+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ */

+#include <fdt.h>

+

+#define FDT_ALIGN(x, a)		(((x) + (a) - 1) & ~((a) - 1))

+#define FDT_TAGALIGN(x)		(FDT_ALIGN((x), FDT_TAGSIZE))

+

+#define FDT_CHECK_HEADER(fdt) \

+	{ \

+		int err; \

+		if ((err = fdt_check_header(fdt)) != 0) \

+			return err; \

+	}

+

+int _fdt_check_node_offset(const void *fdt, int offset);

+int _fdt_check_prop_offset(const void *fdt, int offset);

+const char *_fdt_find_string(const char *strtab, int tabsize, const char *s);

+int _fdt_node_end_offset(void *fdt, int nodeoffset);

+

+static inline const void *_fdt_offset_ptr(const void *fdt, int offset)

+{

+	return (const char *)fdt + fdt_off_dt_struct(fdt) + offset;

+}

+

+static inline void *_fdt_offset_ptr_w(void *fdt, int offset)

+{

+	return (void *)(uintptr_t)_fdt_offset_ptr(fdt, offset);

+}

+

+static inline const struct fdt_reserve_entry *_fdt_mem_rsv(const void *fdt, int n)

+{

+	const struct fdt_reserve_entry *rsv_table =

+		(const struct fdt_reserve_entry *)

+		((const char *)fdt + fdt_off_mem_rsvmap(fdt));

+

+	return rsv_table + n;

+}

+static inline struct fdt_reserve_entry *_fdt_mem_rsv_w(void *fdt, int n)

+{

+	return (void *)(uintptr_t)_fdt_mem_rsv(fdt, n);

+}

+

+#define FDT_SW_MAGIC		(~FDT_MAGIC)

+

+#endif /* _LIBFDT_INTERNAL_H */

diff --git a/EmbeddedPkg/Library/GdbDebugAgent/Arm/ExceptionSupport.ARMv6.S b/EmbeddedPkg/Library/GdbDebugAgent/Arm/ExceptionSupport.ARMv6.S
index f8c4e296..9c3cc3ce 100755
--- a/EmbeddedPkg/Library/GdbDebugAgent/Arm/ExceptionSupport.ARMv6.S
+++ b/EmbeddedPkg/Library/GdbDebugAgent/Arm/ExceptionSupport.ARMv6.S
@@ -1,258 +1,258 @@
-#------------------------------------------------------------------------------ 
-#
-# Use ARMv6 instruction to operate on a single stack
-#
-# Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-#
-# This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#------------------------------------------------------------------------------
-
-/*
-
-This is the stack constructed by the exception handler (low address to high address)
-                # R0 - IFAR is EFI_SYSTEM_CONTEXT for ARM
-  Reg   Offset
-  ===   ======              
-  R0    0x00    # stmfd     SP!,{R0-R12}
-  R1    0x04
-  R2    0x08
-  R3    0x0c
-  R4    0x10
-  R5    0x14
-  R6    0x18
-  R7    0x1c
-  R8    0x20
-  R9    0x24
-  R10   0x28
-  R11   0x2c
-  R12   0x30
-  SP    0x34    # reserved via adding 0x20 (32) to the SP
-  LR    0x38
-  PC    0x3c
-  CPSR  0x40
-  DFSR  0x44
-  DFAR  0x48
-  IFSR  0x4c
-  IFAR  0x50
-  
-  LR    0x54    # SVC Link register (we need to restore it)
-  
-  LR    0x58    # pushed by srsfd    
-  CPSR  0x5c    
-
- */
- 
-
-GCC_ASM_EXPORT(ExceptionHandlersStart)
-GCC_ASM_EXPORT(ExceptionHandlersEnd)
-GCC_ASM_EXPORT(CommonExceptionEntry)
-GCC_ASM_EXPORT(AsmCommonExceptionEntry)
-GCC_ASM_EXPORT(GdbExceptionHandler)
-
-.text
-.align 3
-
-
-//
-// This code gets copied to the ARM vector table
-// ExceptionHandlersStart - ExceptionHandlersEnd gets copied
-//
-ASM_PFX(ExceptionHandlersStart):
-
-ASM_PFX(Reset):
-  b ASM_PFX(Reset)
-
-ASM_PFX(UndefinedInstruction):
-  b ASM_PFX(UndefinedInstructionEntry)
-
-ASM_PFX(SoftwareInterrupt):
-  b ASM_PFX(SoftwareInterruptEntry)
-
-ASM_PFX(PrefetchAbort):
-  b ASM_PFX(PrefetchAbortEntry)
-
-ASM_PFX(DataAbort):
-  b ASM_PFX(DataAbortEntry)
-
-ASM_PFX(ReservedException):
-  b ASM_PFX(ReservedExceptionEntry)
-
-ASM_PFX(Irq):
-  b ASM_PFX(Irq)
-
-ASM_PFX(Fiq):
-  b ASM_PFX(FiqEntry)
-
-
-ASM_PFX(UndefinedInstructionEntry):
-  sub       LR, LR, #4                @ Only -2 for Thumb, adjust in CommonExceptionEntry
-  srsdb     #0x13!                    @ Store return state on SVC stack
-  cpsid     f,#0x13                   @ Switch to SVC for common stack
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-
-  mov       R0,#1                     @ ExceptionType
-  ldr       R1,ASM_PFX(CommonExceptionEntry)
-  bx        R1
-
-ASM_PFX(SoftwareInterruptEntry):
-  sub       LR, LR, #4                @ Only -2 for Thumb, adjust in CommonExceptionEntry
-  srsdb     #0x13!                    @ Store return state on SVC stack
-  cpsid     f                         @ We are already in SVC mode
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-
-  mov       R0,#2                     @ ExceptionType
-  ldr       R1,ASM_PFX(CommonExceptionEntry)
-  bx        R1
-
-ASM_PFX(PrefetchAbortEntry):
-  sub       LR,LR,#4
-  srsdb     #0x13!                    @ Store return state on SVC stack
-  cpsid     f,#0x13                   @ Switch to SVC for common stack
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-
-  mov       R0,#3                     @ ExceptionType
-  ldr       R1,ASM_PFX(CommonExceptionEntry)
-  bx        R1
-
-ASM_PFX(DataAbortEntry):
-  sub       LR,LR,#8
-  srsdb     #0x13!                    @ Store return state on SVC stack
-  cpsid     f,#0x13                   @ Switch to SVC for common stack
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-
-  mov       R0,#4
-  ldr       R1,ASM_PFX(CommonExceptionEntry)
-  bx        R1
-
-ASM_PFX(ReservedExceptionEntry):
-  srsdb     #0x13!                    @ Store return state on SVC stack
-  cpsid     f,#0x13                   @ Switch to SVC for common stack
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-
-  mov       R0,#5
-  ldr       R1,ASM_PFX(CommonExceptionEntry)
-  bx        R1
-
-ASM_PFX(FiqEntry):
-  sub       LR,LR,#4
-  srsdb     #0x13!                    @ Store return state on SVC stack
-  cps       #0x13                     @ Switch to SVC for common stack
-  stmfd     SP!,{LR}                  @ Store the link register for the current mode
-  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              @ Store the register state
-                                      @ Since we have already switch to SVC R8_fiq - R12_fiq
-                                      @ never get used or saved
-  mov       R0,#7                     @ ExceptionType
-  ldr       R1,ASM_PFX(CommonExceptionEntry)
-  bx        R1
-
-//
-// This gets patched by the C code that patches in the vector table
-//
-ASM_PFX(CommonExceptionEntry):
-  .byte       0x12
-  .byte       0x34
-  .byte       0x56
-  .byte       0x78
-
-ASM_PFX(ExceptionHandlersEnd):
-
-//
-// This code runs from CpuDxe driver loaded address. It is patched into 
-// CommonExceptionEntry.
-//
-ASM_PFX(AsmCommonExceptionEntry):
-  mrc       p15, 0, R1, c6, c0, 2   @ Read IFAR
-  str       R1, [SP, #0x50]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.IFAR 
-  
-  mrc       p15, 0, R1, c5, c0, 1   @ Read IFSR
-  str       R1, [SP, #0x4c]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.IFSR
-  
-  mrc       p15, 0, R1, c6, c0, 0   @ Read DFAR
-  str       R1, [SP, #0x48]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.DFAR
-  
-  mrc       p15, 0, R1, c5, c0, 0   @ Read DFSR
-  str       R1, [SP, #0x44]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.DFSR
-  
-  ldr       R1, [SP, #0x5c]         @ srsdb saved pre-exception CPSR on the stack 
-  str       R1, [SP, #0x40]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.CPSR
-
-  add       R2, SP, #0x38           @ Make R2 point to EFI_SYSTEM_CONTEXT_ARM.LR
-  and       R3, R1, #0x1f           @ Check CPSR to see if User or System Mode
-  cmp       R3, #0x1f               @ if ((CPSR == 0x10) || (CPSR == 0x1df))
-  cmpne     R3, #0x10               @   
-  stmeqed   R2, {lr}^               @   save unbanked lr
-                                    @ else 
-  stmneed   R2, {lr}                @   save SVC lr
-
-
-  ldr       R5, [SP, #0x58]         @ PC is the LR pushed by srsfd 
-                                    @ Check to see if we have to adjust for Thumb entry
-  sub       r4, r0, #1              @ if (ExceptionType == 1 || ExceptionType ==2)) {
-  cmp       r4, #1                  @   // UND & SVC have differnt LR adjust for Thumb 
-  bhi       NoAdjustNeeded
-  
-  tst       r1, #0x20               @   if ((CPSR & T)) == T) {  // Thumb Mode on entry 
-  addne     R5, R5, #2              @     PC += 2@
-  str       R5,[SP,#0x58]           @ Update LR value pused by srsfd 
-  
-NoAdjustNeeded:
-
-  str       R5, [SP, #0x3c]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.PC
-  
-  sub       R1, SP, #0x60           @ We pused 0x60 bytes on the stack 
-  str       R1, [SP, #0x34]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.SP
-  
-                                    @ R0 is ExceptionType 
-  mov       R1,SP                   @ R1 is SystemContext 
-
-/* 
-VOID
-EFIAPI
-GdbExceptionHandler (
-  IN     EFI_EXCEPTION_TYPE           ExceptionType,   R0
-  IN OUT EFI_SYSTEM_CONTEXT           SystemContext    R1
-  )
-
-*/  
-  blx       ASM_PFX(GdbExceptionHandler)  @ Call exception handler
-  
-  ldr       R1,[SP,#0x3c]           @ EFI_SYSTEM_CONTEXT_ARM.PC
-  str       R1,[SP,#0x58]           @ Store it back to srsfd stack slot so it can be restored 
-
-  ldr       R1,[SP,#0x40]           @ EFI_SYSTEM_CONTEXT_ARM.CPSR
-  str       R1,[SP,#0x5c]           @ Store it back to srsfd stack slot so it can be restored 
-  
-  add       R3, SP, #0x54           @ Make R3 point to SVC LR saved on entry
-  add       R2, SP, #0x38           @ Make R2 point to EFI_SYSTEM_CONTEXT_ARM.LR
-  and       R1, R1, #0x1f           @ Check to see if User or System Mode
-  cmp       R1, #0x1f               @ if ((CPSR == 0x10) || (CPSR == 0x1f))
-  cmpne     R1, #0x10               @   
-  ldmeqed   R2, {lr}^               @   restore unbanked lr
-                                    @ else
-  ldmneed   R3, {lr}                @   restore SVC lr, via ldmfd SP!, {LR}
-  
-  ldmfd     SP!,{R0-R12}            @ Restore general purpose registers
-                                    @ Exception handler can not change SP
-                                    
-  add       SP,SP,#0x20             @ Clear out the remaining stack space
-  ldmfd     SP!,{LR}                @ restore the link register for this context
-  rfefd     SP!                     @ return from exception via srsfd stack slot
-  
+#------------------------------------------------------------------------------ 

+#

+# Use ARMv6 instruction to operate on a single stack

+#

+# Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+#

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#------------------------------------------------------------------------------

+

+/*

+

+This is the stack constructed by the exception handler (low address to high address)

+                # R0 - IFAR is EFI_SYSTEM_CONTEXT for ARM

+  Reg   Offset

+  ===   ======              

+  R0    0x00    # stmfd     SP!,{R0-R12}

+  R1    0x04

+  R2    0x08

+  R3    0x0c

+  R4    0x10

+  R5    0x14

+  R6    0x18

+  R7    0x1c

+  R8    0x20

+  R9    0x24

+  R10   0x28

+  R11   0x2c

+  R12   0x30

+  SP    0x34    # reserved via adding 0x20 (32) to the SP

+  LR    0x38

+  PC    0x3c

+  CPSR  0x40

+  DFSR  0x44

+  DFAR  0x48

+  IFSR  0x4c

+  IFAR  0x50

+  

+  LR    0x54    # SVC Link register (we need to restore it)

+  

+  LR    0x58    # pushed by srsfd    

+  CPSR  0x5c    

+

+ */

+ 

+

+GCC_ASM_EXPORT(ExceptionHandlersStart)

+GCC_ASM_EXPORT(ExceptionHandlersEnd)

+GCC_ASM_EXPORT(CommonExceptionEntry)

+GCC_ASM_EXPORT(AsmCommonExceptionEntry)

+GCC_ASM_EXPORT(GdbExceptionHandler)

+

+.text

+.align 3

+

+

+//

+// This code gets copied to the ARM vector table

+// ExceptionHandlersStart - ExceptionHandlersEnd gets copied

+//

+ASM_PFX(ExceptionHandlersStart):

+

+ASM_PFX(Reset):

+  b ASM_PFX(Reset)

+

+ASM_PFX(UndefinedInstruction):

+  b ASM_PFX(UndefinedInstructionEntry)

+

+ASM_PFX(SoftwareInterrupt):

+  b ASM_PFX(SoftwareInterruptEntry)

+

+ASM_PFX(PrefetchAbort):

+  b ASM_PFX(PrefetchAbortEntry)

+

+ASM_PFX(DataAbort):

+  b ASM_PFX(DataAbortEntry)

+

+ASM_PFX(ReservedException):

+  b ASM_PFX(ReservedExceptionEntry)

+

+ASM_PFX(Irq):

+  b ASM_PFX(Irq)

+

+ASM_PFX(Fiq):

+  b ASM_PFX(FiqEntry)

+

+

+ASM_PFX(UndefinedInstructionEntry):

+  sub       LR, LR, #4                @ Only -2 for Thumb, adjust in CommonExceptionEntry

+  srsdb     #0x13!                    @ Store return state on SVC stack

+  cpsid     f,#0x13                   @ Switch to SVC for common stack

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+

+  mov       R0,#1                     @ ExceptionType

+  ldr       R1,ASM_PFX(CommonExceptionEntry)

+  bx        R1

+

+ASM_PFX(SoftwareInterruptEntry):

+  sub       LR, LR, #4                @ Only -2 for Thumb, adjust in CommonExceptionEntry

+  srsdb     #0x13!                    @ Store return state on SVC stack

+  cpsid     f                         @ We are already in SVC mode

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+

+  mov       R0,#2                     @ ExceptionType

+  ldr       R1,ASM_PFX(CommonExceptionEntry)

+  bx        R1

+

+ASM_PFX(PrefetchAbortEntry):

+  sub       LR,LR,#4

+  srsdb     #0x13!                    @ Store return state on SVC stack

+  cpsid     f,#0x13                   @ Switch to SVC for common stack

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+

+  mov       R0,#3                     @ ExceptionType

+  ldr       R1,ASM_PFX(CommonExceptionEntry)

+  bx        R1

+

+ASM_PFX(DataAbortEntry):

+  sub       LR,LR,#8

+  srsdb     #0x13!                    @ Store return state on SVC stack

+  cpsid     f,#0x13                   @ Switch to SVC for common stack

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+

+  mov       R0,#4

+  ldr       R1,ASM_PFX(CommonExceptionEntry)

+  bx        R1

+

+ASM_PFX(ReservedExceptionEntry):

+  srsdb     #0x13!                    @ Store return state on SVC stack

+  cpsid     f,#0x13                   @ Switch to SVC for common stack

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+

+  mov       R0,#5

+  ldr       R1,ASM_PFX(CommonExceptionEntry)

+  bx        R1

+

+ASM_PFX(FiqEntry):

+  sub       LR,LR,#4

+  srsdb     #0x13!                    @ Store return state on SVC stack

+  cps       #0x13                     @ Switch to SVC for common stack

+  stmfd     SP!,{LR}                  @ Store the link register for the current mode

+  sub       SP,SP,#0x20               @ Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              @ Store the register state

+                                      @ Since we have already switch to SVC R8_fiq - R12_fiq

+                                      @ never get used or saved

+  mov       R0,#7                     @ ExceptionType

+  ldr       R1,ASM_PFX(CommonExceptionEntry)

+  bx        R1

+

+//

+// This gets patched by the C code that patches in the vector table

+//

+ASM_PFX(CommonExceptionEntry):

+  .byte       0x12

+  .byte       0x34

+  .byte       0x56

+  .byte       0x78

+

+ASM_PFX(ExceptionHandlersEnd):

+

+//

+// This code runs from CpuDxe driver loaded address. It is patched into 

+// CommonExceptionEntry.

+//

+ASM_PFX(AsmCommonExceptionEntry):

+  mrc       p15, 0, R1, c6, c0, 2   @ Read IFAR

+  str       R1, [SP, #0x50]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.IFAR 

+  

+  mrc       p15, 0, R1, c5, c0, 1   @ Read IFSR

+  str       R1, [SP, #0x4c]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.IFSR

+  

+  mrc       p15, 0, R1, c6, c0, 0   @ Read DFAR

+  str       R1, [SP, #0x48]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.DFAR

+  

+  mrc       p15, 0, R1, c5, c0, 0   @ Read DFSR

+  str       R1, [SP, #0x44]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.DFSR

+  

+  ldr       R1, [SP, #0x5c]         @ srsdb saved pre-exception CPSR on the stack 

+  str       R1, [SP, #0x40]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.CPSR

+

+  add       R2, SP, #0x38           @ Make R2 point to EFI_SYSTEM_CONTEXT_ARM.LR

+  and       R3, R1, #0x1f           @ Check CPSR to see if User or System Mode

+  cmp       R3, #0x1f               @ if ((CPSR == 0x10) || (CPSR == 0x1df))

+  cmpne     R3, #0x10               @   

+  stmeqed   R2, {lr}^               @   save unbanked lr

+                                    @ else 

+  stmneed   R2, {lr}                @   save SVC lr

+

+

+  ldr       R5, [SP, #0x58]         @ PC is the LR pushed by srsfd 

+                                    @ Check to see if we have to adjust for Thumb entry

+  sub       r4, r0, #1              @ if (ExceptionType == 1 || ExceptionType ==2)) {

+  cmp       r4, #1                  @   // UND & SVC have differnt LR adjust for Thumb 

+  bhi       NoAdjustNeeded

+  

+  tst       r1, #0x20               @   if ((CPSR & T)) == T) {  // Thumb Mode on entry 

+  addne     R5, R5, #2              @     PC += 2@

+  str       R5,[SP,#0x58]           @ Update LR value pused by srsfd 

+  

+NoAdjustNeeded:

+

+  str       R5, [SP, #0x3c]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.PC

+  

+  sub       R1, SP, #0x60           @ We pused 0x60 bytes on the stack 

+  str       R1, [SP, #0x34]         @ Store it in EFI_SYSTEM_CONTEXT_ARM.SP

+  

+                                    @ R0 is ExceptionType 

+  mov       R1,SP                   @ R1 is SystemContext 

+

+/* 

+VOID

+EFIAPI

+GdbExceptionHandler (

+  IN     EFI_EXCEPTION_TYPE           ExceptionType,   R0

+  IN OUT EFI_SYSTEM_CONTEXT           SystemContext    R1

+  )

+

+*/  

+  blx       ASM_PFX(GdbExceptionHandler)  @ Call exception handler

+  

+  ldr       R1,[SP,#0x3c]           @ EFI_SYSTEM_CONTEXT_ARM.PC

+  str       R1,[SP,#0x58]           @ Store it back to srsfd stack slot so it can be restored 

+

+  ldr       R1,[SP,#0x40]           @ EFI_SYSTEM_CONTEXT_ARM.CPSR

+  str       R1,[SP,#0x5c]           @ Store it back to srsfd stack slot so it can be restored 

+  

+  add       R3, SP, #0x54           @ Make R3 point to SVC LR saved on entry

+  add       R2, SP, #0x38           @ Make R2 point to EFI_SYSTEM_CONTEXT_ARM.LR

+  and       R1, R1, #0x1f           @ Check to see if User or System Mode

+  cmp       R1, #0x1f               @ if ((CPSR == 0x10) || (CPSR == 0x1f))

+  cmpne     R1, #0x10               @   

+  ldmeqed   R2, {lr}^               @   restore unbanked lr

+                                    @ else

+  ldmneed   R3, {lr}                @   restore SVC lr, via ldmfd SP!, {LR}

+  

+  ldmfd     SP!,{R0-R12}            @ Restore general purpose registers

+                                    @ Exception handler can not change SP

+                                    

+  add       SP,SP,#0x20             @ Clear out the remaining stack space

+  ldmfd     SP!,{LR}                @ restore the link register for this context

+  rfefd     SP!                     @ return from exception via srsfd stack slot

+  

diff --git a/EmbeddedPkg/Library/GdbDebugAgent/Arm/ExceptionSupport.ARMv6.asm b/EmbeddedPkg/Library/GdbDebugAgent/Arm/ExceptionSupport.ARMv6.asm
index c133073f..c70fb924 100755
--- a/EmbeddedPkg/Library/GdbDebugAgent/Arm/ExceptionSupport.ARMv6.asm
+++ b/EmbeddedPkg/Library/GdbDebugAgent/Arm/ExceptionSupport.ARMv6.asm
@@ -1,259 +1,259 @@
-//------------------------------------------------------------------------------ 
-//
-// Use ARMv6 instruction to operate on a single stack
-//
-// Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-//
-// This program and the accompanying materials
-// are licensed and made available under the terms and conditions of the BSD License
-// which accompanies this distribution.  The full text of the license may be found at
-// http://opensource.org/licenses/bsd-license.php
-//
-// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-//
-//------------------------------------------------------------------------------
-
-
-
-/*
-
-This is the stack constructed by the exception handler (low address to high address)
-                # R0 - IFAR is EFI_SYSTEM_CONTEXT for ARM
-  Reg   Offset
-  ===   ======              
-  R0    0x00    # stmfd     SP!,{R0-R12}
-  R1    0x04
-  R2    0x08
-  R3    0x0c
-  R4    0x10
-  R5    0x14
-  R6    0x18
-  R7    0x1c
-  R8    0x20
-  R9    0x24
-  R10   0x28
-  R11   0x2c
-  R12   0x30
-  SP    0x34    # reserved via adding 0x20 (32) to the SP
-  LR    0x38
-  PC    0x3c
-  CPSR  0x40
-  DFSR  0x44
-  DFAR  0x48
-  IFSR  0x4c
-  IFAR  0x50
-  
-  LR    0x54    # SVC Link register (we need to restore it)
-  
-  LR    0x58    # pushed by srsfd    
-  CPSR  0x5c    
-
- */
- 
- 
-  EXPORT  ExceptionHandlersStart
-  EXPORT  ExceptionHandlersEnd
-  EXPORT  CommonExceptionEntry
-  EXPORT  AsmCommonExceptionEntry
-  IMPORT  GdbExceptionHandler
-
-  PRESERVE8
-  AREA  DxeExceptionHandlers, CODE, READONLY
-  
-//
-// This code gets copied to the ARM vector table
-// ExceptionHandlersStart - ExceptionHandlersEnd gets copied
-//
-ExceptionHandlersStart
-
-Reset
-  b   Reset
-
-UndefinedInstruction
-  b   UndefinedInstructionEntry
-
-SoftwareInterrupt
-  b   SoftwareInterruptEntry
-
-PrefetchAbort
-  b   PrefetchAbortEntry
-
-DataAbort
-  b   DataAbortEntry
-
-ReservedException
-  b   ReservedExceptionEntry
-
-Irq
-  b   Irq
-
-Fiq
-  b   FiqEntry
-
-
-UndefinedInstructionEntry
-  sub       LR, LR, #4                ; Only -2 for Thumb, adjust in CommonExceptionEntry
-  srsfd     #0x13!                    ; Store return state on SVC stack
-  cpsid     f, #0x13                  ; Switch to SVC for common stack
-  stmfd     SP!,{LR}                  ; Store the link register for the current mode
-  sub       SP,SP,#0x20               ; Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              ; Store the register state
-
-  mov       R0,#1                     ; ExceptionType
-  ldr       R1,CommonExceptionEntry; 
-  bx        R1
-
-SoftwareInterruptEntry
-  sub       LR, LR, #4                ; Only -2 for Thumb, adjust in CommonExceptionEntry
-  srsfd     #0x13!                    ; Store return state on SVC stack
-  cpsid     f                         ; We are already in SVC mode
-  stmfd     SP!,{LR}                  ; Store the link register for the current mode
-  sub       SP,SP,#0x20               ; Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              ; Store the register state
-
-  mov       R0,#2                     ; ExceptionType
-  ldr       R1,CommonExceptionEntry
-  bx        R1
-
-PrefetchAbortEntry
-  sub       LR,LR,#4
-  srsfd     #0x13!                    ; Store return state on SVC stack
-  cpsid     f, #0x13                  ; Switch to SVC for common stack
-  stmfd     SP!,{LR}                  ; Store the link register for the current mode
-  sub       SP,SP,#0x20               ; Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              ; Store the register state
-
-  mov       R0,#3                     ; ExceptionType
-  ldr       R1,CommonExceptionEntry
-  bx        R1
-
-DataAbortEntry
-  sub       LR,LR,#8
-  srsfd     #0x13!                    ; Store return state on SVC stack
-  cpsid     f, #0x13                  ; Switch to SVC for common stack
-  stmfd     SP!,{LR}                  ; Store the link register for the current mode
-  sub       SP,SP,#0x20               ; Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              ; Store the register state
-
-  mov       R0,#4                     ; ExceptionType
-  ldr       R1,CommonExceptionEntry
-  bx        R1
-
-ReservedExceptionEntry
-  srsfd     #0x13!                    ; Store return state on SVC stack
-  cpsid     f, #0x13                  ; Switch to SVC for common stack
-  stmfd     SP!,{LR}                  ; Store the link register for the current mode
-  sub       SP,SP,#0x20               ; Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              ; Store the register state
-
-  mov       R0,#5                     ; ExceptionType
-  ldr       R1,CommonExceptionEntry
-  bx        R1
-
-FiqEntry
-  sub       LR,LR,#4
-  srsfd     #0x13!                    ; Store return state on SVC stack
-  cps       #0x13                     ; Switch to SVC for common stack
-  stmfd     SP!,{LR}                  ; Store the link register for the current mode
-  sub       SP,SP,#0x20               ; Save space for SP, LR, PC, IFAR - CPSR
-  stmfd     SP!,{R0-R12}              ; Store the register state
-                                      ; Since we have already switch to SVC R8_fiq - R12_fiq
-                                      ; never get used or saved
-  mov       R0,#7                     ; ExceptionType
-  ldr       R1,CommonExceptionEntry
-  bx        R1
-
-//
-// This gets patched by the C code that patches in the vector table
-//
-CommonExceptionEntry
-  dcd       0x12345678
-
-ExceptionHandlersEnd
-
-//
-// This code runs from CpuDxe driver loaded address. It is patched into 
-// CommonExceptionEntry.
-//
-AsmCommonExceptionEntry
-  mrc       p15, 0, R1, c6, c0, 2   ; Read IFAR
-  str       R1, [SP, #0x50]         ; Store it in EFI_SYSTEM_CONTEXT_ARM.IFAR 
-  
-  mrc       p15, 0, R1, c5, c0, 1   ; Read IFSR
-  str       R1, [SP, #0x4c]         ; Store it in EFI_SYSTEM_CONTEXT_ARM.IFSR
-  
-  mrc       p15, 0, R1, c6, c0, 0   ; Read DFAR
-  str       R1, [SP, #0x48]         ; Store it in EFI_SYSTEM_CONTEXT_ARM.DFAR
-  
-  mrc       p15, 0, R1, c5, c0, 0   ; Read DFSR
-  str       R1, [SP, #0x44]         ; Store it in EFI_SYSTEM_CONTEXT_ARM.DFSR
-  
-  ldr       R1, [SP, #0x5c]         ; srsfd saved pre-exception CPSR on the stack 
-  str       R1, [SP, #0x40]         ; Store it in EFI_SYSTEM_CONTEXT_ARM.CPSR
-
-  add       R2, SP, #0x38           ; Make R2 point to EFI_SYSTEM_CONTEXT_ARM.LR
-  and       R3, R1, #0x1f           ; Check CPSR to see if User or System Mode
-  cmp       R3, #0x1f               ; if ((CPSR == 0x10) || (CPSR == 0x1df))
-  cmpne     R3, #0x10               ;   
-  stmeqed   R2, {lr}^               ;   save unbanked lr
-                                    ; else 
-  stmneed   R2, {lr}                ;   save SVC lr
-
-
-  ldr       R5, [SP, #0x58]         ; PC is the LR pushed by srsfd 
-                                    ; Check to see if we have to adjust for Thumb entry
-  sub       r4, r0, #1              ; if (ExceptionType == 1 || ExceptionType ==2)) {
-  cmp       r4, #1                  ;   // UND & SVC have differnt LR adjust for Thumb 
-  bhi       NoAdjustNeeded
-  
-  tst       r1, #0x20               ;   if ((CPSR & T)) == T) {  // Thumb Mode on entry 
-  addne     R5, R5, #2              ;     PC += 2;
-  str       R5,[SP,#0x58]           ; Update LR value pused by srsfd 
-  
-NoAdjustNeeded
-
-  str       R5, [SP, #0x3c]         ; Store it in EFI_SYSTEM_CONTEXT_ARM.PC
-  
-  sub       R1, SP, #0x60           ; We pused 0x60 bytes on the stack 
-  str       R1, [SP, #0x34]         ; Store it in EFI_SYSTEM_CONTEXT_ARM.SP
-  
-                                    ; R0 is ExceptionType 
-  mov       R1,SP                   ; R1 is SystemContext 
-
-/* 
-VOID
-EFIAPI
-GdbExceptionHandler (
-  IN     EFI_EXCEPTION_TYPE           ExceptionType,   R0
-  IN OUT EFI_SYSTEM_CONTEXT           SystemContext    R1
-  )
-
-*/
-  blx       GdbExceptionHandler     ; Call exception handler
-  
-  ldr       R1,[SP,#0x3c]           ; EFI_SYSTEM_CONTEXT_ARM.PC
-  str       R1,[SP,#0x58]           ; Store it back to srsfd stack slot so it can be restored 
-
-  ldr       R1,[SP,#0x40]           ; EFI_SYSTEM_CONTEXT_ARM.CPSR
-  str       R1,[SP,#0x5c]           ; Store it back to srsfd stack slot so it can be restored 
-  
-  add       R3, SP, #0x54           ; Make R3 point to SVC LR saved on entry
-  add       R2, SP, #0x38           ; Make R2 point to EFI_SYSTEM_CONTEXT_ARM.LR
-  and       R1, R1, #0x1f           ; Check to see if User or System Mode
-  cmp       R1, #0x1f               ; if ((CPSR == 0x10) || (CPSR == 0x1f))
-  cmpne     R1, #0x10               ;   
-  ldmeqed   R2, {lr}^               ;   restore unbanked lr
-                                    ; else
-  ldmneed   R3, {lr}                ;   restore SVC lr, via ldmfd SP!, {LR}
-  
-  ldmfd     SP!,{R0-R12}            ; Restore general purpose registers
-                                    ; Exception handler can not change SP
-                                    
-  add       SP,SP,#0x20             ; Clear out the remaining stack space
-  ldmfd     SP!,{LR}                ; restore the link register for this context
-  rfefd     SP!                     ; return from exception via srsfd stack slot
-  
-  END
-
-
+//------------------------------------------------------------------------------ 

+//

+// Use ARMv6 instruction to operate on a single stack

+//

+// Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+//

+// This program and the accompanying materials

+// are licensed and made available under the terms and conditions of the BSD License

+// which accompanies this distribution.  The full text of the license may be found at

+// http://opensource.org/licenses/bsd-license.php

+//

+// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+//

+//------------------------------------------------------------------------------

+

+

+

+/*

+

+This is the stack constructed by the exception handler (low address to high address)

+                # R0 - IFAR is EFI_SYSTEM_CONTEXT for ARM

+  Reg   Offset

+  ===   ======              

+  R0    0x00    # stmfd     SP!,{R0-R12}

+  R1    0x04

+  R2    0x08

+  R3    0x0c

+  R4    0x10

+  R5    0x14

+  R6    0x18

+  R7    0x1c

+  R8    0x20

+  R9    0x24

+  R10   0x28

+  R11   0x2c

+  R12   0x30

+  SP    0x34    # reserved via adding 0x20 (32) to the SP

+  LR    0x38

+  PC    0x3c

+  CPSR  0x40

+  DFSR  0x44

+  DFAR  0x48

+  IFSR  0x4c

+  IFAR  0x50

+  

+  LR    0x54    # SVC Link register (we need to restore it)

+  

+  LR    0x58    # pushed by srsfd    

+  CPSR  0x5c    

+

+ */

+ 

+ 

+  EXPORT  ExceptionHandlersStart

+  EXPORT  ExceptionHandlersEnd

+  EXPORT  CommonExceptionEntry

+  EXPORT  AsmCommonExceptionEntry

+  IMPORT  GdbExceptionHandler

+

+  PRESERVE8

+  AREA  DxeExceptionHandlers, CODE, READONLY

+  

+//

+// This code gets copied to the ARM vector table

+// ExceptionHandlersStart - ExceptionHandlersEnd gets copied

+//

+ExceptionHandlersStart

+

+Reset

+  b   Reset

+

+UndefinedInstruction

+  b   UndefinedInstructionEntry

+

+SoftwareInterrupt

+  b   SoftwareInterruptEntry

+

+PrefetchAbort

+  b   PrefetchAbortEntry

+

+DataAbort

+  b   DataAbortEntry

+

+ReservedException

+  b   ReservedExceptionEntry

+

+Irq

+  b   Irq

+

+Fiq

+  b   FiqEntry

+

+

+UndefinedInstructionEntry

+  sub       LR, LR, #4                ; Only -2 for Thumb, adjust in CommonExceptionEntry

+  srsfd     #0x13!                    ; Store return state on SVC stack

+  cpsid     f, #0x13                  ; Switch to SVC for common stack

+  stmfd     SP!,{LR}                  ; Store the link register for the current mode

+  sub       SP,SP,#0x20               ; Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              ; Store the register state

+

+  mov       R0,#1                     ; ExceptionType

+  ldr       R1,CommonExceptionEntry; 

+  bx        R1

+

+SoftwareInterruptEntry

+  sub       LR, LR, #4                ; Only -2 for Thumb, adjust in CommonExceptionEntry

+  srsfd     #0x13!                    ; Store return state on SVC stack

+  cpsid     f                         ; We are already in SVC mode

+  stmfd     SP!,{LR}                  ; Store the link register for the current mode

+  sub       SP,SP,#0x20               ; Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              ; Store the register state

+

+  mov       R0,#2                     ; ExceptionType

+  ldr       R1,CommonExceptionEntry

+  bx        R1

+

+PrefetchAbortEntry

+  sub       LR,LR,#4

+  srsfd     #0x13!                    ; Store return state on SVC stack

+  cpsid     f, #0x13                  ; Switch to SVC for common stack

+  stmfd     SP!,{LR}                  ; Store the link register for the current mode

+  sub       SP,SP,#0x20               ; Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              ; Store the register state

+

+  mov       R0,#3                     ; ExceptionType

+  ldr       R1,CommonExceptionEntry

+  bx        R1

+

+DataAbortEntry

+  sub       LR,LR,#8

+  srsfd     #0x13!                    ; Store return state on SVC stack

+  cpsid     f, #0x13                  ; Switch to SVC for common stack

+  stmfd     SP!,{LR}                  ; Store the link register for the current mode

+  sub       SP,SP,#0x20               ; Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              ; Store the register state

+

+  mov       R0,#4                     ; ExceptionType

+  ldr       R1,CommonExceptionEntry

+  bx        R1

+

+ReservedExceptionEntry

+  srsfd     #0x13!                    ; Store return state on SVC stack

+  cpsid     f, #0x13                  ; Switch to SVC for common stack

+  stmfd     SP!,{LR}                  ; Store the link register for the current mode

+  sub       SP,SP,#0x20               ; Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              ; Store the register state

+

+  mov       R0,#5                     ; ExceptionType

+  ldr       R1,CommonExceptionEntry

+  bx        R1

+

+FiqEntry

+  sub       LR,LR,#4

+  srsfd     #0x13!                    ; Store return state on SVC stack

+  cps       #0x13                     ; Switch to SVC for common stack

+  stmfd     SP!,{LR}                  ; Store the link register for the current mode

+  sub       SP,SP,#0x20               ; Save space for SP, LR, PC, IFAR - CPSR

+  stmfd     SP!,{R0-R12}              ; Store the register state

+                                      ; Since we have already switch to SVC R8_fiq - R12_fiq

+                                      ; never get used or saved

+  mov       R0,#7                     ; ExceptionType

+  ldr       R1,CommonExceptionEntry

+  bx        R1

+

+//

+// This gets patched by the C code that patches in the vector table

+//

+CommonExceptionEntry

+  dcd       0x12345678

+

+ExceptionHandlersEnd

+

+//

+// This code runs from CpuDxe driver loaded address. It is patched into 

+// CommonExceptionEntry.

+//

+AsmCommonExceptionEntry

+  mrc       p15, 0, R1, c6, c0, 2   ; Read IFAR

+  str       R1, [SP, #0x50]         ; Store it in EFI_SYSTEM_CONTEXT_ARM.IFAR 

+  

+  mrc       p15, 0, R1, c5, c0, 1   ; Read IFSR

+  str       R1, [SP, #0x4c]         ; Store it in EFI_SYSTEM_CONTEXT_ARM.IFSR

+  

+  mrc       p15, 0, R1, c6, c0, 0   ; Read DFAR

+  str       R1, [SP, #0x48]         ; Store it in EFI_SYSTEM_CONTEXT_ARM.DFAR

+  

+  mrc       p15, 0, R1, c5, c0, 0   ; Read DFSR

+  str       R1, [SP, #0x44]         ; Store it in EFI_SYSTEM_CONTEXT_ARM.DFSR

+  

+  ldr       R1, [SP, #0x5c]         ; srsfd saved pre-exception CPSR on the stack 

+  str       R1, [SP, #0x40]         ; Store it in EFI_SYSTEM_CONTEXT_ARM.CPSR

+

+  add       R2, SP, #0x38           ; Make R2 point to EFI_SYSTEM_CONTEXT_ARM.LR

+  and       R3, R1, #0x1f           ; Check CPSR to see if User or System Mode

+  cmp       R3, #0x1f               ; if ((CPSR == 0x10) || (CPSR == 0x1df))

+  cmpne     R3, #0x10               ;   

+  stmeqed   R2, {lr}^               ;   save unbanked lr

+                                    ; else 

+  stmneed   R2, {lr}                ;   save SVC lr

+

+

+  ldr       R5, [SP, #0x58]         ; PC is the LR pushed by srsfd 

+                                    ; Check to see if we have to adjust for Thumb entry

+  sub       r4, r0, #1              ; if (ExceptionType == 1 || ExceptionType ==2)) {

+  cmp       r4, #1                  ;   // UND & SVC have differnt LR adjust for Thumb 

+  bhi       NoAdjustNeeded

+  

+  tst       r1, #0x20               ;   if ((CPSR & T)) == T) {  // Thumb Mode on entry 

+  addne     R5, R5, #2              ;     PC += 2;

+  str       R5,[SP,#0x58]           ; Update LR value pused by srsfd 

+  

+NoAdjustNeeded

+

+  str       R5, [SP, #0x3c]         ; Store it in EFI_SYSTEM_CONTEXT_ARM.PC

+  

+  sub       R1, SP, #0x60           ; We pused 0x60 bytes on the stack 

+  str       R1, [SP, #0x34]         ; Store it in EFI_SYSTEM_CONTEXT_ARM.SP

+  

+                                    ; R0 is ExceptionType 

+  mov       R1,SP                   ; R1 is SystemContext 

+

+/* 

+VOID

+EFIAPI

+GdbExceptionHandler (

+  IN     EFI_EXCEPTION_TYPE           ExceptionType,   R0

+  IN OUT EFI_SYSTEM_CONTEXT           SystemContext    R1

+  )

+

+*/

+  blx       GdbExceptionHandler     ; Call exception handler

+  

+  ldr       R1,[SP,#0x3c]           ; EFI_SYSTEM_CONTEXT_ARM.PC

+  str       R1,[SP,#0x58]           ; Store it back to srsfd stack slot so it can be restored 

+

+  ldr       R1,[SP,#0x40]           ; EFI_SYSTEM_CONTEXT_ARM.CPSR

+  str       R1,[SP,#0x5c]           ; Store it back to srsfd stack slot so it can be restored 

+  

+  add       R3, SP, #0x54           ; Make R3 point to SVC LR saved on entry

+  add       R2, SP, #0x38           ; Make R2 point to EFI_SYSTEM_CONTEXT_ARM.LR

+  and       R1, R1, #0x1f           ; Check to see if User or System Mode

+  cmp       R1, #0x1f               ; if ((CPSR == 0x10) || (CPSR == 0x1f))

+  cmpne     R1, #0x10               ;   

+  ldmeqed   R2, {lr}^               ;   restore unbanked lr

+                                    ; else

+  ldmneed   R3, {lr}                ;   restore SVC lr, via ldmfd SP!, {LR}

+  

+  ldmfd     SP!,{R0-R12}            ; Restore general purpose registers

+                                    ; Exception handler can not change SP

+                                    

+  add       SP,SP,#0x20             ; Clear out the remaining stack space

+  ldmfd     SP!,{LR}                ; restore the link register for this context

+  rfefd     SP!                     ; return from exception via srsfd stack slot

+  

+  END

+

+

diff --git a/EmbeddedPkg/Library/GdbDebugAgent/Arm/Processor.c b/EmbeddedPkg/Library/GdbDebugAgent/Arm/Processor.c
index e6aabf94..f22a19dd 100755
--- a/EmbeddedPkg/Library/GdbDebugAgent/Arm/Processor.c
+++ b/EmbeddedPkg/Library/GdbDebugAgent/Arm/Processor.c
@@ -447,23 +447,23 @@ RemoveBreakPoint (
 }

 

 

-/**
- Send the T signal with the given exception type (in gdb order) and possibly 
- with n:r pairs related to the watchpoints
- 
- @param  SystemContext        Register content at time of the exception
- @param  GdbExceptionType     GDB exception type
- **/
-VOID
-ProcessorSendTSignal (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  UINT8               GdbExceptionType,
-  IN  OUT CHAR8           *TSignalPtr,
-  IN  UINTN               SizeOfBuffer
-  )
-{
-  *TSignalPtr = '\0';
-}
+/**

+ Send the T signal with the given exception type (in gdb order) and possibly 

+ with n:r pairs related to the watchpoints

+ 

+ @param  SystemContext        Register content at time of the exception

+ @param  GdbExceptionType     GDB exception type

+ **/

+VOID

+ProcessorSendTSignal (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  UINT8               GdbExceptionType,

+  IN  OUT CHAR8           *TSignalPtr,

+  IN  UINTN               SizeOfBuffer

+  )

+{

+  *TSignalPtr = '\0';

+}

 

 /**

  FIQ state is only changed by FIQ exception. We don't want to take FIQ

@@ -475,21 +475,21 @@ ProcessorSendTSignal (
 

  @return  TRUE  We are in the GDB stub exception preamble 

  @return  FALSE We are not in GDB stub code

- **/
-BOOLEAN
-InFiqCrack (
-  IN UINT32 PC
-  )
-{
-  UINT32 VectorBase = PcdGet32 (PcdCpuVectorBaseAddress);
-  UINT32 Length     = (UINTN)ExceptionHandlersEnd - (UINTN)ExceptionHandlersStart;
-
-  if ((PC >= VectorBase) && (PC <= (VectorBase + Length))) {
-    return TRUE;
-  }
-
-  return FALSE;
-}
+ **/

+BOOLEAN

+InFiqCrack (

+  IN UINT32 PC

+  )

+{

+  UINT32 VectorBase = PcdGet32 (PcdCpuVectorBaseAddress);

+  UINT32 Length     = (UINTN)ExceptionHandlersEnd - (UINTN)ExceptionHandlersStart;

+

+  if ((PC >= VectorBase) && (PC <= (VectorBase + Length))) {

+    return TRUE;

+  }

+

+  return FALSE;

+}

 

 

 /**

@@ -526,24 +526,24 @@ ProcessorControlC (
     return FALSE;

   }

 

-  while (TRUE) {
-    if (!GdbIsCharAvailable ()) {
-      //
-      // No characters are pending so exit the loop
-      //
-      Return = TRUE;
-      break;
-    }
-    
-    Char = GdbGetChar ();
-    if (Char == 0x03) {
-      //
-      // We have a ctrl-c so exit and process exception for ctrl-c
-      //
-      Return = FALSE;
-      break;
-    }
-  }
+  while (TRUE) {

+    if (!GdbIsCharAvailable ()) {

+      //

+      // No characters are pending so exit the loop

+      //

+      Return = TRUE;

+      break;

+    }

+    

+    Char = GdbGetChar ();

+    if (Char == 0x03) {

+      //

+      // We have a ctrl-c so exit and process exception for ctrl-c

+      //

+      Return = FALSE;

+      break;

+    }

+  }

 

   DebugAgentTimerEndOfInterrupt ();

 

@@ -622,13 +622,13 @@ InitializeDebugAgent (
   IN VOID                  *Context, OPTIONAL

   IN DEBUG_AGENT_CONTINUE  Function  OPTIONAL

   )

-{  
+{  

   UINTN                Offset;

   UINTN                Length;

   BOOLEAN              IrqEnabled;

   UINT32               *VectorBase;

 

-
+

   //

   // Disable interrupts

   //

diff --git a/EmbeddedPkg/Library/GdbDebugAgent/GdbDebugAgent.h b/EmbeddedPkg/Library/GdbDebugAgent/GdbDebugAgent.h
index 2d0570e3..44c82f34 100755
--- a/EmbeddedPkg/Library/GdbDebugAgent/GdbDebugAgent.h
+++ b/EmbeddedPkg/Library/GdbDebugAgent/GdbDebugAgent.h
@@ -1,697 +1,697 @@
-/** @file
-  Private include file for GDB stub
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __GCC_DEBUG_AGENT_INTERNAL__
-#define __GCC_DEBUG_AGENT_INTERNAL__
-
-#include <Uefi.h>
-#include <Library/BaseLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/MemoryAllocationLib.h>
-#include <Library/DebugLib.h>
-#include <Library/PcdLib.h>
-#include <Library/GdbSerialLib.h>
-#include <Library/PrintLib.h>
-#include <Library/CacheMaintenanceLib.h>
-#include <Library/DebugAgentTimerLib.h>
+/** @file

+  Private include file for GDB stub

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __GCC_DEBUG_AGENT_INTERNAL__

+#define __GCC_DEBUG_AGENT_INTERNAL__

+

+#include <Uefi.h>

+#include <Library/BaseLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/MemoryAllocationLib.h>

+#include <Library/DebugLib.h>

+#include <Library/PcdLib.h>

+#include <Library/GdbSerialLib.h>

+#include <Library/PrintLib.h>

+#include <Library/CacheMaintenanceLib.h>

+#include <Library/DebugAgentTimerLib.h>

 #include <Library/DebugAgentLib.h>

-
-#include <IndustryStandard/PeImage.h>
-#include <Protocol/DebugSupport.h>
-
-extern CONST CHAR8 mHexToStr[];
-
-// maximum size of input and output buffers
-// This value came from the show remote command of the gdb we tested against 
-#define MAX_BUF_SIZE 2000
-
-// maximum size of address buffer
-#define MAX_ADDR_SIZE 32
-
-// maximum size of register number buffer
-#define MAX_REG_NUM_BUF_SIZE 32
-
-// maximum size of length buffer
-#define MAX_LENGTH_SIZE 32
-
-// maximum size of T signal members
-#define MAX_T_SIGNAL_SIZE 64
-
-// the mask used to clear all the cache
-#define TF_BIT 0x00000100
-
-
-//
-// GDB Signal definitions - generic names for interrupts
-//
-#define GDB_SIGINT      2  // Interrupt process via ctrl-c
-#define GDB_SIGILL      4  // Illegal instruction       
-#define GDB_SIGTRAP     5  // Trace Trap (Breakpoint and SingleStep)
-#define GDB_SIGEMT      7  // Emulator Trap
-#define GDB_SIGFPE      8  // Floating point exception
-#define GDB_SIGSEGV     11 // Setgment violation, page fault 
-
-
-//
-// GDB File I/O Error values, zero means no error
-// Includes all general GDB Unix like error values
-//
-#define GDB_EBADMEMADDRBUFSIZE   11  // the buffer that stores memory Address to be read from/written to is not the right size
-#define GDB_EBADMEMLENGBUFSIZE   12  // the buffer that stores Length is not the right size 
-#define GDB_EBADMEMLENGTH        13  // Length, the given number of bytes to read or write, is not the right size
-#define GDB_EBADMEMDATA          14  // one of the bytes or nibbles of the memory is leess than 0 
-#define GDB_EBADMEMDATASIZE      15  // the memory data, 'XX..', is too short or too long
-#define GDB_EBADBUFSIZE          21  // the buffer created is not the correct size
-#define GDB_EINVALIDARG          31  // argument is invalid
-#define GDB_ENOSPACE             41  //
-#define GDB_EINVALIDBRKPOINTTYPE 51  // the breakpoint type is not recognized
-#define GDB_EINVALIDREGNUM       61  // given register number is not valid: either <0 or >=Number of Registers
-#define GDB_EUNKNOWN             255 // unknown
-
-
-//
-// These devices are open by GDB so we can just read and write to them
-//
-#define GDB_STDIN   0x00
-#define GDB_STDOUT  0x01
-#define GDB_STDERR  0x02
-
-//
-//Define Register size for different architectures
-//
-#if defined (MDE_CPU_IA32) 
-#define REG_SIZE  32
-#elif defined (MDE_CPU_X64)
-#define REG_SIZE  64
-#elif defined (MDE_CPU_ARM)
-#define REG_SIZE  32
-#endif
-
-
-typedef struct {
-  EFI_EXCEPTION_TYPE  Exception;
-  UINT8               SignalNo;
-} EFI_EXCEPTION_TYPE_ENTRY;
-
-
-#if defined (MDE_CPU_IA32) || defined (MDE_CPU_X64)
-
-//
-// Byte packed structure for DR6
-// 32-bits on IA-32
-// 64-bits on X64.  The upper 32-bits on X64 are reserved
-//
-typedef union {
-  struct {
-    UINT32  B0:1;           // Breakpoint condition detected
-    UINT32  B1:1;           // Breakpoint condition detected
-    UINT32  B2:1;           // Breakpoint condition detected
-    UINT32  B3:1;           // Breakpoint condition detected
-    UINT32  Reserved_1:9;   // Reserved 
-    UINT32  BD:1;           // Debug register access detected
-    UINT32  BS:1;           // Single step
-    UINT32  BT:1;           // Task switch
-    UINT32  Reserved_2:16;  // Reserved
-  } Bits;
-  UINTN     UintN;
-} IA32_DR6;
-
-//
-// Byte packed structure for DR7
-// 32-bits on IA-32
-// 64-bits on X64.  The upper 32-bits on X64 are reserved
-//
-typedef union {
-  struct {
-    UINT32  L0:1;           // Local breakpoint enable
-    UINT32  G0:1;           // Global breakpoint enable
-    UINT32  L1:1;           // Local breakpoint enable
-    UINT32  G1:1;           // Global breakpoint enable
-    UINT32  L2:1;           // Local breakpoint enable
-    UINT32  G2:1;           // Global breakpoint enable
-    UINT32  L3:1;           // Local breakpoint enable
-    UINT32  G3:1;           // Global breakpoint enable
-    UINT32  LE:1;           // Local exact breakpoint enable
-    UINT32  GE:1;           // Global exact breakpoint enable
-    UINT32  Reserved_1:3;   // Reserved
-    UINT32  GD:1;           // Global detect enable
-    UINT32  Reserved_2:2;   // Reserved
-    UINT32  RW0:2;          // Read/Write field
-    UINT32  LEN0:2;         // Length field
-    UINT32  RW1:2;          // Read/Write field
-    UINT32  LEN1:2;         // Length field
-    UINT32  RW2:2;          // Read/Write field
-    UINT32  LEN2:2;         // Length field
-    UINT32  RW3:2;          // Read/Write field
-    UINT32  LEN3:2;         // Length field
-  } Bits;
-  UINTN     UintN;
-} IA32_DR7;
-
-#endif /* if defined (MDE_CPU_IA32) || defined (MDE_CPU_X64) */
-
-typedef enum {
-  InstructionExecution,   //Hardware breakpoint
-  DataWrite,              //watch
-  DataRead,               //rwatch
-  DataReadWrite,          //awatch
-  SoftwareBreakpoint,     //Software breakpoint
-  NotSupported
-} BREAK_TYPE;
-
-//
-// Array of exception types that need to be hooked by the debugger
-//
-extern EFI_EXCEPTION_TYPE_ENTRY gExceptionType[];
-
-//
-// If the periodic callback is called while we are processing an F packet we need
-// to let the callback know to not read from the serail stream as it could steal
-// characters from the F reponse packet
-//
-extern BOOLEAN gProcessingFPacket;
-
-
-/**
- Return the number of entries in the gExceptionType[]
- 
- @retval    UINTN, the number of entries in the gExceptionType[] array.    
- **/
-UINTN
-MaxEfiException (
-  VOID
-  );
-
-
-/**
- Check to see if the ISA is supported. 
- ISA = Instruction Set Architecture
- 
- @retval    TRUE if Isa is supported,
- FALSE otherwise.
- **/
-BOOLEAN
-CheckIsa (
-  IN    EFI_INSTRUCTION_SET_ARCHITECTURE    Isa
-  );
-
-
-/**
- Send the T signal with the given exception type (in gdb order) and possibly with n:r pairs related to the watchpoints
- 
- @param  SystemContext        Register content at time of the exception
- @param  GdbExceptionType     GDB exception type
- **/
-
-VOID
-GdbSendTSignal (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  UINT8	              GdbExceptionType
-  );
-
-
-/**
- Translates the EFI mapping to GDB mapping
- 
- @param     EFIExceptionType        EFI Exception that is being processed
- @retval    UINTN that corresponds to EFIExceptionType's GDB exception type number
- **/
-UINT8
-ConvertEFItoGDBtype ( 
-  IN  EFI_EXCEPTION_TYPE EFIExceptionType
-  );
-
-
-/**
- Empties the given buffer 
- @param *Buf pointer to the first element in buffer to be emptied
- **/
-VOID
-EmptyBuffer ( 
-  IN CHAR8  *Buf
-  );
-
-
-/**
- Converts an 8-bit Hex Char into a INTN.
- 
- @param     Char  - the hex character to be converted into UINTN
- @retval    a INTN, from 0 to 15, that corressponds to Char
- -1 if Char is not a hex character
- **/
-INTN
-HexCharToInt (
-  IN  CHAR8 Char
-  );
-
-
-/** 'E NN'
- Send an error with the given error number after converting to hex.
- The error number is put into the buffer in hex. '255' is the biggest errno we can send.
- ex: 162 will be sent as A2.
- 
- @param   errno    the error number that will be sent
- **/
-VOID
-EFIAPI
-SendError (
-  IN  UINT8     ErrorNum
-  );
-
-
-/**
- Send 'OK' when the function is done executing successfully.
- **/
-VOID
-SendSuccess (
-  VOID
-  );
-
-
-/**
- Send empty packet to specify that particular command/functionality is not supported.
- **/
-VOID
-SendNotSupported (
-  VOID
-  );
-
-/** ‘p n’ 
- Reads the n-th register's value into an output buffer and sends it as a packet 
- @param     SystemContext       Register content at time of the exception
- @param     InBuffer            This is the input buffer received from gdb server
- **/
-VOID
-ReadNthRegister (
-  IN    EFI_SYSTEM_CONTEXT  SystemContext,
-  IN    CHAR8               *InBuffer
-  );
-
-
-/** ‘g’ 
- Reads the general registers into an output buffer  and sends it as a packet 
- @param     SystemContext           Register content at time of the exception
- **/
-VOID
-ReadGeneralRegisters (  
-  IN    EFI_SYSTEM_CONTEXT  SystemContext
-  );
-
-
-/** ‘P n...=r...’
- Writes the new value of n-th register received into the input buffer to the n-th register
- @param     SystemContext       Register content at time of the exception
- @param     InBuffer            This is the input buffer received from gdb server
- **/
-VOID
-WriteNthRegister (
-  IN    EFI_SYSTEM_CONTEXT  SystemContext,
-  IN    CHAR8               *InBuffer
-  );
-
-
-/** ‘G XX...’
- Writes the new values received into the input buffer to the general registers
- @param     SystemContext               Register content at time of the exception
- @param     InBuffer                    Pointer to the input buffer received from gdb server
- **/
-
-VOID
-WriteGeneralRegisters (
-  IN    EFI_SYSTEM_CONTEXT  SystemContext,
-  IN    CHAR8               *InBuffer
-  );
-
-
-/** ‘m addr,length ’
- Find the Length of the area to read and the start addres. Finally, pass them to 
- another function, TransferFromMemToOutBufAndSend, that will read from that memory space and 
- send it as a packet.
- 
- @param  *PacketData  Pointer to Payload data for the packet
- **/
-VOID
-ReadFromMemory (
-  IN  CHAR8  *PacketData
-  );
-
-
-/** ‘M addr,length :XX...’
- Find the Length of the area in bytes to write and the start addres. Finally, pass them to 
- another function, TransferFromInBufToMem, that will write to that memory space the info in
- the input buffer.
- 
- @param   PacketData     Pointer to Payload data for the packet
- **/
-VOID
-WriteToMemory (
-  IN CHAR8 *PacketData
-  );
-
-
-/** ‘c [addr ]’ 
- Continue. addr is Address to resume. If addr is omitted, resume at current 
- Address.
- 
- @param SystemContext Register content at time of the exception  
- @param *PacketData   Pointer to PacketData
- **/
-
-VOID
-ContinueAtAddress (
-  IN  EFI_SYSTEM_CONTEXT   SystemContext,
-  IN  CHAR8                *PacketData
-  );
-
-
-/** ‘s [addr ]’
- Single step. addr is the Address at which to resume. If addr is omitted, resume 
- at same Address.
- 
- @param SystemContext   Register content at time of the exception
- @param PacketData      Pointer to Payload data for the packet
- **/
-VOID
-SingleStep (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  CHAR8               *PacketData
-  );
-
-/** 
- Insert Single Step in the SystemContext
- 
- @param SystemContext   Register content at time of the exception
- **/
-VOID
-AddSingleStep (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext
-  );
-  
-/** 
- Remove Single Step in the SystemContext
- 
- @param SystemContext   Register content at time of the exception
- **/
-VOID
-RemoveSingleStep (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext
-  );
-  
-  
-/**
-  ‘Z1, [addr], [length]’
-  ‘Z2, [addr], [length]’
-  ‘Z3, [addr], [length]’
-  ‘Z4, [addr], [length]’
-
-  Insert hardware breakpoint/watchpoint at address addr of size length
-
-  @param SystemContext  Register content at time of the exception
-  @param *PacketData    Pointer to the Payload data for the packet
-
-**/
-VOID
-EFIAPI
-InsertBreakPoint(
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  CHAR8               *PacketData
-  );
-
-
-/**
-  ‘z1, [addr], [length]’
-  ‘z2, [addr], [length]’
-  ‘z3, [addr], [length]’
-  ‘z4, [addr], [length]’
-
-  Remove hardware breakpoint/watchpoint at address addr of size length
-
-  @param SystemContext  Register content at time of the exception
-  @param *PacketData    Pointer to the Payload data for the packet
-
-**/
-VOID
-EFIAPI
-RemoveBreakPoint(
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  CHAR8               *PacketData
-  );
-
-
-/**
- Exception Hanldler for GDB. It will be called for all exceptions
- registered via the gExceptionType[] array.
- 
- @param ExceptionType   Exception that is being processed
- @param SystemContext   Register content at time of the exception  
- 
- **/
-VOID
-EFIAPI
-GdbExceptionHandler ( 
-  IN     EFI_EXCEPTION_TYPE  ExceptionType, 
-  IN OUT EFI_SYSTEM_CONTEXT  SystemContext 
-  );
-
-
-/**
- Periodic callback for GDB. This function is used to catch a ctrl-c or other 
- break in type command from GDB.
- 
- @param SystemContext           Register content at time of the call
- 
- **/
-VOID
-EFIAPI
-GdbPeriodicCallBack ( 
-  IN OUT EFI_SYSTEM_CONTEXT  SystemContext 
-  );
-
-
-/**
-  Make two serail consoles: 1) StdIn and StdOut via GDB. 2) StdErr via GDB.
-  
-  These console show up on the remote system running GDB
-
-**/
-
-VOID
-GdbInitializeSerialConsole (
-  VOID
-  );
-
-
-/**
-  Send a GDB Remote Serial Protocol Packet
-  
-  $PacketData#checksum PacketData is passed in and this function adds the packet prefix '$', 
-  the packet teminating character '#' and the two digit checksum.
-  
-  If an ack '+' is not sent resend the packet, but timeout eventually so we don't end up 
-  in an infinit loop. This is so if you unplug the debugger code just keeps running
-
-  @param PacketData   Payload data for the packet  
-  
-  @retval             Number of bytes of packet data sent.
-
-**/
-UINTN
-SendPacket (
-  IN  CHAR8 *PacketData
-  );
-  
-
-/**
- Receive a GDB Remote Serial Protocol Packet
- 
- $PacketData#checksum PacketData is passed in and this function adds the packet prefix '$', 
- the packet teminating character '#' and the two digit checksum.
- 
- If host re-starts sending a packet without ending the previous packet, only the last valid packet is proccessed.
- (In other words, if received packet is '$12345$12345$123456#checksum', only '$123456#checksum' will be processed.)
- 
- If an ack '+' is not sent resend the packet
- 
- @param PacketData   Payload data for the packet  
- 
- @retval             Number of bytes of packet data received.
-
- **/
-UINTN
-ReceivePacket (
- OUT  CHAR8 *PacketData,
- IN   UINTN PacketDataSize
- );
-  
-
-/**
-  Read data from a FileDescriptor. On success number of bytes read is returned. Zero indicates 
-  the end of a file. On error -1 is returned. If count is zero, GdbRead returns zero.
-
-  @param  FileDescriptor   Device to talk to.
-  @param  Buffer           Buffer to hold Count bytes that were read
-  @param  Count            Number of bytes to transfer. 
-
-  @retval -1               Error
-  @retval {other}          Number of bytes read.
-
-**/
-INTN
-GdbRead (
-  IN  INTN    FileDescriptor,
-  OUT VOID    *Buffer,
-  IN  UINTN   Count
-  );
-  
-
-/**
-  Write data to a FileDescriptor. On success number of bytes written is returned. Zero indicates 
-  nothing was written. On error -1 is returned. 
-
-  @param  FileDescriptor   Device to talk to.
-  @param  Buffer           Buffer to hold Count bytes that are to be written
-  @param  Count            Number of bytes to transfer. 
-
-  @retval -1               Error
-  @retval {other}          Number of bytes written.
-
-**/
-INTN
-GdbWrite (
-  IN  INTN          FileDescriptor,
-  OUT CONST VOID    *Buffer,
-  IN  UINTN         Count
-  );
-
-UINTN *  
-FindPointerToRegister (
-  IN  EFI_SYSTEM_CONTEXT    SystemContext,
-  IN  UINTN                 RegNumber  
-  );
-
-CHAR8 * 
-BasicReadRegister (
-  IN  EFI_SYSTEM_CONTEXT      SystemContext,
-  IN  UINTN                   RegNumber,
-  IN  CHAR8                   *OutBufPtr
-  );
-
-VOID
-TransferFromInBufToMem (
-  IN  UINTN   Length,
-  IN  UINT8   *Address,
-  IN  CHAR8   *NewData
-  );
-
-VOID
-TransferFromMemToOutBufAndSend (
-  IN  UINTN  Length,
-  IN  UINT8  *Address
-  );
-
-CHAR8 *
-BasicWriteRegister (
-  IN  EFI_SYSTEM_CONTEXT    SystemContext,
-  IN  UINTN                 RegNumber,
-  IN  CHAR8                 *InBufPtr
-  );
-
-VOID  
-PrintReg (
-  EFI_SYSTEM_CONTEXT SystemContext
-  );
-
-UINTN
-ParseBreakpointPacket (
-  IN  CHAR8 *PacketData,
-  OUT UINTN *Type,
-  OUT UINTN *Address,
-  OUT UINTN *Length
-  );
-
-UINTN
-GetBreakpointDataAddress (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  UINTN               BreakpointNumber 
-  );
-
-UINTN
-GetBreakpointDetected (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext
-  );
-
-BREAK_TYPE
-GetBreakpointType (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  UINTN               BreakpointNumber  
-  );
-
-UINTN
-ConvertLengthData (
-  IN  UINTN  Length
-  );
-
-EFI_STATUS
-FindNextFreeDebugRegister (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  OUT UINTN               *Register
-  );
-
-EFI_STATUS
-EnableDebugRegister (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  UINTN               Register,
-  IN  UINTN               Address,
-  IN  UINTN               Length,
-  IN  UINTN               Type
-  );
-
-EFI_STATUS
-FindMatchingDebugRegister (
- IN  EFI_SYSTEM_CONTEXT  SystemContext,
- IN  UINTN               Address,
- IN  UINTN               Length,
- IN  UINTN               Type,
- OUT UINTN               *Register
- );
-
-EFI_STATUS
-DisableDebugRegister (
- IN  EFI_SYSTEM_CONTEXT  SystemContext,
- IN  UINTN               Register
- );
-
-VOID
-InitializeProcessor (
-  VOID
-  );
-
-/**
- Send the T signal with the given exception type (in gdb order) and possibly with n:r pairs related to the watchpoints
- 
- @param  SystemContext        Register content at time of the exception
- @param  GdbExceptionType     GDB exception type
- **/
-VOID
-ProcessorSendTSignal (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  UINT8               GdbExceptionType,
-  IN  OUT CHAR8           *TSignalPtr,
-  IN  UINTN               SizeOfBuffer
-  );
-
+

+#include <IndustryStandard/PeImage.h>

+#include <Protocol/DebugSupport.h>

+

+extern CONST CHAR8 mHexToStr[];

+

+// maximum size of input and output buffers

+// This value came from the show remote command of the gdb we tested against 

+#define MAX_BUF_SIZE 2000

+

+// maximum size of address buffer

+#define MAX_ADDR_SIZE 32

+

+// maximum size of register number buffer

+#define MAX_REG_NUM_BUF_SIZE 32

+

+// maximum size of length buffer

+#define MAX_LENGTH_SIZE 32

+

+// maximum size of T signal members

+#define MAX_T_SIGNAL_SIZE 64

+

+// the mask used to clear all the cache

+#define TF_BIT 0x00000100

+

+

+//

+// GDB Signal definitions - generic names for interrupts

+//

+#define GDB_SIGINT      2  // Interrupt process via ctrl-c

+#define GDB_SIGILL      4  // Illegal instruction       

+#define GDB_SIGTRAP     5  // Trace Trap (Breakpoint and SingleStep)

+#define GDB_SIGEMT      7  // Emulator Trap

+#define GDB_SIGFPE      8  // Floating point exception

+#define GDB_SIGSEGV     11 // Setgment violation, page fault 

+

+

+//

+// GDB File I/O Error values, zero means no error

+// Includes all general GDB Unix like error values

+//

+#define GDB_EBADMEMADDRBUFSIZE   11  // the buffer that stores memory Address to be read from/written to is not the right size

+#define GDB_EBADMEMLENGBUFSIZE   12  // the buffer that stores Length is not the right size 

+#define GDB_EBADMEMLENGTH        13  // Length, the given number of bytes to read or write, is not the right size

+#define GDB_EBADMEMDATA          14  // one of the bytes or nibbles of the memory is leess than 0 

+#define GDB_EBADMEMDATASIZE      15  // the memory data, 'XX..', is too short or too long

+#define GDB_EBADBUFSIZE          21  // the buffer created is not the correct size

+#define GDB_EINVALIDARG          31  // argument is invalid

+#define GDB_ENOSPACE             41  //

+#define GDB_EINVALIDBRKPOINTTYPE 51  // the breakpoint type is not recognized

+#define GDB_EINVALIDREGNUM       61  // given register number is not valid: either <0 or >=Number of Registers

+#define GDB_EUNKNOWN             255 // unknown

+

+

+//

+// These devices are open by GDB so we can just read and write to them

+//

+#define GDB_STDIN   0x00

+#define GDB_STDOUT  0x01

+#define GDB_STDERR  0x02

+

+//

+//Define Register size for different architectures

+//

+#if defined (MDE_CPU_IA32) 

+#define REG_SIZE  32

+#elif defined (MDE_CPU_X64)

+#define REG_SIZE  64

+#elif defined (MDE_CPU_ARM)

+#define REG_SIZE  32

+#endif

+

+

+typedef struct {

+  EFI_EXCEPTION_TYPE  Exception;

+  UINT8               SignalNo;

+} EFI_EXCEPTION_TYPE_ENTRY;

+

+

+#if defined (MDE_CPU_IA32) || defined (MDE_CPU_X64)

+

+//

+// Byte packed structure for DR6

+// 32-bits on IA-32

+// 64-bits on X64.  The upper 32-bits on X64 are reserved

+//

+typedef union {

+  struct {

+    UINT32  B0:1;           // Breakpoint condition detected

+    UINT32  B1:1;           // Breakpoint condition detected

+    UINT32  B2:1;           // Breakpoint condition detected

+    UINT32  B3:1;           // Breakpoint condition detected

+    UINT32  Reserved_1:9;   // Reserved 

+    UINT32  BD:1;           // Debug register access detected

+    UINT32  BS:1;           // Single step

+    UINT32  BT:1;           // Task switch

+    UINT32  Reserved_2:16;  // Reserved

+  } Bits;

+  UINTN     UintN;

+} IA32_DR6;

+

+//

+// Byte packed structure for DR7

+// 32-bits on IA-32

+// 64-bits on X64.  The upper 32-bits on X64 are reserved

+//

+typedef union {

+  struct {

+    UINT32  L0:1;           // Local breakpoint enable

+    UINT32  G0:1;           // Global breakpoint enable

+    UINT32  L1:1;           // Local breakpoint enable

+    UINT32  G1:1;           // Global breakpoint enable

+    UINT32  L2:1;           // Local breakpoint enable

+    UINT32  G2:1;           // Global breakpoint enable

+    UINT32  L3:1;           // Local breakpoint enable

+    UINT32  G3:1;           // Global breakpoint enable

+    UINT32  LE:1;           // Local exact breakpoint enable

+    UINT32  GE:1;           // Global exact breakpoint enable

+    UINT32  Reserved_1:3;   // Reserved

+    UINT32  GD:1;           // Global detect enable

+    UINT32  Reserved_2:2;   // Reserved

+    UINT32  RW0:2;          // Read/Write field

+    UINT32  LEN0:2;         // Length field

+    UINT32  RW1:2;          // Read/Write field

+    UINT32  LEN1:2;         // Length field

+    UINT32  RW2:2;          // Read/Write field

+    UINT32  LEN2:2;         // Length field

+    UINT32  RW3:2;          // Read/Write field

+    UINT32  LEN3:2;         // Length field

+  } Bits;

+  UINTN     UintN;

+} IA32_DR7;

+

+#endif /* if defined (MDE_CPU_IA32) || defined (MDE_CPU_X64) */

+

+typedef enum {

+  InstructionExecution,   //Hardware breakpoint

+  DataWrite,              //watch

+  DataRead,               //rwatch

+  DataReadWrite,          //awatch

+  SoftwareBreakpoint,     //Software breakpoint

+  NotSupported

+} BREAK_TYPE;

+

+//

+// Array of exception types that need to be hooked by the debugger

+//

+extern EFI_EXCEPTION_TYPE_ENTRY gExceptionType[];

+

+//

+// If the periodic callback is called while we are processing an F packet we need

+// to let the callback know to not read from the serail stream as it could steal

+// characters from the F reponse packet

+//

+extern BOOLEAN gProcessingFPacket;

+

+

+/**

+ Return the number of entries in the gExceptionType[]

+ 

+ @retval    UINTN, the number of entries in the gExceptionType[] array.    

+ **/

+UINTN

+MaxEfiException (

+  VOID

+  );

+

+

+/**

+ Check to see if the ISA is supported. 

+ ISA = Instruction Set Architecture

+ 

+ @retval    TRUE if Isa is supported,

+ FALSE otherwise.

+ **/

+BOOLEAN

+CheckIsa (

+  IN    EFI_INSTRUCTION_SET_ARCHITECTURE    Isa

+  );

+

+

+/**

+ Send the T signal with the given exception type (in gdb order) and possibly with n:r pairs related to the watchpoints

+ 

+ @param  SystemContext        Register content at time of the exception

+ @param  GdbExceptionType     GDB exception type

+ **/

+

+VOID

+GdbSendTSignal (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  UINT8	              GdbExceptionType

+  );

+

+

+/**

+ Translates the EFI mapping to GDB mapping

+ 

+ @param     EFIExceptionType        EFI Exception that is being processed

+ @retval    UINTN that corresponds to EFIExceptionType's GDB exception type number

+ **/

+UINT8

+ConvertEFItoGDBtype ( 

+  IN  EFI_EXCEPTION_TYPE EFIExceptionType

+  );

+

+

+/**

+ Empties the given buffer 

+ @param *Buf pointer to the first element in buffer to be emptied

+ **/

+VOID

+EmptyBuffer ( 

+  IN CHAR8  *Buf

+  );

+

+

+/**

+ Converts an 8-bit Hex Char into a INTN.

+ 

+ @param     Char  - the hex character to be converted into UINTN

+ @retval    a INTN, from 0 to 15, that corressponds to Char

+ -1 if Char is not a hex character

+ **/

+INTN

+HexCharToInt (

+  IN  CHAR8 Char

+  );

+

+

+/** 'E NN'

+ Send an error with the given error number after converting to hex.

+ The error number is put into the buffer in hex. '255' is the biggest errno we can send.

+ ex: 162 will be sent as A2.

+ 

+ @param   errno    the error number that will be sent

+ **/

+VOID

+EFIAPI

+SendError (

+  IN  UINT8     ErrorNum

+  );

+

+

+/**

+ Send 'OK' when the function is done executing successfully.

+ **/

+VOID

+SendSuccess (

+  VOID

+  );

+

+

+/**

+ Send empty packet to specify that particular command/functionality is not supported.

+ **/

+VOID

+SendNotSupported (

+  VOID

+  );

+

+/** ‘p n’ 

+ Reads the n-th register's value into an output buffer and sends it as a packet 

+ @param     SystemContext       Register content at time of the exception

+ @param     InBuffer            This is the input buffer received from gdb server

+ **/

+VOID

+ReadNthRegister (

+  IN    EFI_SYSTEM_CONTEXT  SystemContext,

+  IN    CHAR8               *InBuffer

+  );

+

+

+/** ‘g’ 

+ Reads the general registers into an output buffer  and sends it as a packet 

+ @param     SystemContext           Register content at time of the exception

+ **/

+VOID

+ReadGeneralRegisters (  

+  IN    EFI_SYSTEM_CONTEXT  SystemContext

+  );

+

+

+/** ‘P n...=r...’

+ Writes the new value of n-th register received into the input buffer to the n-th register

+ @param     SystemContext       Register content at time of the exception

+ @param     InBuffer            This is the input buffer received from gdb server

+ **/

+VOID

+WriteNthRegister (

+  IN    EFI_SYSTEM_CONTEXT  SystemContext,

+  IN    CHAR8               *InBuffer

+  );

+

+

+/** ‘G XX...’

+ Writes the new values received into the input buffer to the general registers

+ @param     SystemContext               Register content at time of the exception

+ @param     InBuffer                    Pointer to the input buffer received from gdb server

+ **/

+

+VOID

+WriteGeneralRegisters (

+  IN    EFI_SYSTEM_CONTEXT  SystemContext,

+  IN    CHAR8               *InBuffer

+  );

+

+

+/** ‘m addr,length ’

+ Find the Length of the area to read and the start addres. Finally, pass them to 

+ another function, TransferFromMemToOutBufAndSend, that will read from that memory space and 

+ send it as a packet.

+ 

+ @param  *PacketData  Pointer to Payload data for the packet

+ **/

+VOID

+ReadFromMemory (

+  IN  CHAR8  *PacketData

+  );

+

+

+/** ‘M addr,length :XX...’

+ Find the Length of the area in bytes to write and the start addres. Finally, pass them to 

+ another function, TransferFromInBufToMem, that will write to that memory space the info in

+ the input buffer.

+ 

+ @param   PacketData     Pointer to Payload data for the packet

+ **/

+VOID

+WriteToMemory (

+  IN CHAR8 *PacketData

+  );

+

+

+/** ‘c [addr ]’ 

+ Continue. addr is Address to resume. If addr is omitted, resume at current 

+ Address.

+ 

+ @param SystemContext Register content at time of the exception  

+ @param *PacketData   Pointer to PacketData

+ **/

+

+VOID

+ContinueAtAddress (

+  IN  EFI_SYSTEM_CONTEXT   SystemContext,

+  IN  CHAR8                *PacketData

+  );

+

+

+/** ‘s [addr ]’

+ Single step. addr is the Address at which to resume. If addr is omitted, resume 

+ at same Address.

+ 

+ @param SystemContext   Register content at time of the exception

+ @param PacketData      Pointer to Payload data for the packet

+ **/

+VOID

+SingleStep (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  CHAR8               *PacketData

+  );

+

+/** 

+ Insert Single Step in the SystemContext

+ 

+ @param SystemContext   Register content at time of the exception

+ **/

+VOID

+AddSingleStep (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext

+  );

+  

+/** 

+ Remove Single Step in the SystemContext

+ 

+ @param SystemContext   Register content at time of the exception

+ **/

+VOID

+RemoveSingleStep (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext

+  );

+  

+  

+/**

+  ‘Z1, [addr], [length]’

+  ‘Z2, [addr], [length]’

+  ‘Z3, [addr], [length]’

+  ‘Z4, [addr], [length]’

+

+  Insert hardware breakpoint/watchpoint at address addr of size length

+

+  @param SystemContext  Register content at time of the exception

+  @param *PacketData    Pointer to the Payload data for the packet

+

+**/

+VOID

+EFIAPI

+InsertBreakPoint(

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  CHAR8               *PacketData

+  );

+

+

+/**

+  ‘z1, [addr], [length]’

+  ‘z2, [addr], [length]’

+  ‘z3, [addr], [length]’

+  ‘z4, [addr], [length]’

+

+  Remove hardware breakpoint/watchpoint at address addr of size length

+

+  @param SystemContext  Register content at time of the exception

+  @param *PacketData    Pointer to the Payload data for the packet

+

+**/

+VOID

+EFIAPI

+RemoveBreakPoint(

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  CHAR8               *PacketData

+  );

+

+

+/**

+ Exception Hanldler for GDB. It will be called for all exceptions

+ registered via the gExceptionType[] array.

+ 

+ @param ExceptionType   Exception that is being processed

+ @param SystemContext   Register content at time of the exception  

+ 

+ **/

+VOID

+EFIAPI

+GdbExceptionHandler ( 

+  IN     EFI_EXCEPTION_TYPE  ExceptionType, 

+  IN OUT EFI_SYSTEM_CONTEXT  SystemContext 

+  );

+

+

+/**

+ Periodic callback for GDB. This function is used to catch a ctrl-c or other 

+ break in type command from GDB.

+ 

+ @param SystemContext           Register content at time of the call

+ 

+ **/

+VOID

+EFIAPI

+GdbPeriodicCallBack ( 

+  IN OUT EFI_SYSTEM_CONTEXT  SystemContext 

+  );

+

+

+/**

+  Make two serail consoles: 1) StdIn and StdOut via GDB. 2) StdErr via GDB.

+  

+  These console show up on the remote system running GDB

+

+**/

+

+VOID

+GdbInitializeSerialConsole (

+  VOID

+  );

+

+

+/**

+  Send a GDB Remote Serial Protocol Packet

+  

+  $PacketData#checksum PacketData is passed in and this function adds the packet prefix '$', 

+  the packet teminating character '#' and the two digit checksum.

+  

+  If an ack '+' is not sent resend the packet, but timeout eventually so we don't end up 

+  in an infinit loop. This is so if you unplug the debugger code just keeps running

+

+  @param PacketData   Payload data for the packet  

+  

+  @retval             Number of bytes of packet data sent.

+

+**/

+UINTN

+SendPacket (

+  IN  CHAR8 *PacketData

+  );

+  

+

+/**

+ Receive a GDB Remote Serial Protocol Packet

+ 

+ $PacketData#checksum PacketData is passed in and this function adds the packet prefix '$', 

+ the packet teminating character '#' and the two digit checksum.

+ 

+ If host re-starts sending a packet without ending the previous packet, only the last valid packet is proccessed.

+ (In other words, if received packet is '$12345$12345$123456#checksum', only '$123456#checksum' will be processed.)

+ 

+ If an ack '+' is not sent resend the packet

+ 

+ @param PacketData   Payload data for the packet  

+ 

+ @retval             Number of bytes of packet data received.

+

+ **/

+UINTN

+ReceivePacket (

+ OUT  CHAR8 *PacketData,

+ IN   UINTN PacketDataSize

+ );

+  

+

+/**

+  Read data from a FileDescriptor. On success number of bytes read is returned. Zero indicates 

+  the end of a file. On error -1 is returned. If count is zero, GdbRead returns zero.

+

+  @param  FileDescriptor   Device to talk to.

+  @param  Buffer           Buffer to hold Count bytes that were read

+  @param  Count            Number of bytes to transfer. 

+

+  @retval -1               Error

+  @retval {other}          Number of bytes read.

+

+**/

+INTN

+GdbRead (

+  IN  INTN    FileDescriptor,

+  OUT VOID    *Buffer,

+  IN  UINTN   Count

+  );

+  

+

+/**

+  Write data to a FileDescriptor. On success number of bytes written is returned. Zero indicates 

+  nothing was written. On error -1 is returned. 

+

+  @param  FileDescriptor   Device to talk to.

+  @param  Buffer           Buffer to hold Count bytes that are to be written

+  @param  Count            Number of bytes to transfer. 

+

+  @retval -1               Error

+  @retval {other}          Number of bytes written.

+

+**/

+INTN

+GdbWrite (

+  IN  INTN          FileDescriptor,

+  OUT CONST VOID    *Buffer,

+  IN  UINTN         Count

+  );

+

+UINTN *  

+FindPointerToRegister (

+  IN  EFI_SYSTEM_CONTEXT    SystemContext,

+  IN  UINTN                 RegNumber  

+  );

+

+CHAR8 * 

+BasicReadRegister (

+  IN  EFI_SYSTEM_CONTEXT      SystemContext,

+  IN  UINTN                   RegNumber,

+  IN  CHAR8                   *OutBufPtr

+  );

+

+VOID

+TransferFromInBufToMem (

+  IN  UINTN   Length,

+  IN  UINT8   *Address,

+  IN  CHAR8   *NewData

+  );

+

+VOID

+TransferFromMemToOutBufAndSend (

+  IN  UINTN  Length,

+  IN  UINT8  *Address

+  );

+

+CHAR8 *

+BasicWriteRegister (

+  IN  EFI_SYSTEM_CONTEXT    SystemContext,

+  IN  UINTN                 RegNumber,

+  IN  CHAR8                 *InBufPtr

+  );

+

+VOID  

+PrintReg (

+  EFI_SYSTEM_CONTEXT SystemContext

+  );

+

+UINTN

+ParseBreakpointPacket (

+  IN  CHAR8 *PacketData,

+  OUT UINTN *Type,

+  OUT UINTN *Address,

+  OUT UINTN *Length

+  );

+

+UINTN

+GetBreakpointDataAddress (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  UINTN               BreakpointNumber 

+  );

+

+UINTN

+GetBreakpointDetected (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext

+  );

+

+BREAK_TYPE

+GetBreakpointType (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  UINTN               BreakpointNumber  

+  );

+

+UINTN

+ConvertLengthData (

+  IN  UINTN  Length

+  );

+

+EFI_STATUS

+FindNextFreeDebugRegister (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  OUT UINTN               *Register

+  );

+

+EFI_STATUS

+EnableDebugRegister (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  UINTN               Register,

+  IN  UINTN               Address,

+  IN  UINTN               Length,

+  IN  UINTN               Type

+  );

+

+EFI_STATUS

+FindMatchingDebugRegister (

+ IN  EFI_SYSTEM_CONTEXT  SystemContext,

+ IN  UINTN               Address,

+ IN  UINTN               Length,

+ IN  UINTN               Type,

+ OUT UINTN               *Register

+ );

+

+EFI_STATUS

+DisableDebugRegister (

+ IN  EFI_SYSTEM_CONTEXT  SystemContext,

+ IN  UINTN               Register

+ );

+

+VOID

+InitializeProcessor (

+  VOID

+  );

+

+/**

+ Send the T signal with the given exception type (in gdb order) and possibly with n:r pairs related to the watchpoints

+ 

+ @param  SystemContext        Register content at time of the exception

+ @param  GdbExceptionType     GDB exception type

+ **/

+VOID

+ProcessorSendTSignal (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  UINT8               GdbExceptionType,

+  IN  OUT CHAR8           *TSignalPtr,

+  IN  UINTN               SizeOfBuffer

+  );

+

 /**

  Check to see if this exception is related to ctrl-c handling.

  

@@ -705,9 +705,9 @@ BOOLEAN
 ProcessorControlC ( 

   IN  EFI_EXCEPTION_TYPE        ExceptionType, 

   IN OUT EFI_SYSTEM_CONTEXT     SystemContext 

-  );
-
-
+  );

+

+

 /**

   Initialize debug agent.

 

@@ -723,6 +723,6 @@ DebugAgentHookExceptions (
   IN UINT32                InitFlag,

   IN VOID                  *Context  OPTIONAL

   );

-
-
-#endif
+

+

+#endif

diff --git a/EmbeddedPkg/Library/GdbDebugAgent/Ia32/Processor.c b/EmbeddedPkg/Library/GdbDebugAgent/Ia32/Processor.c
index 96a1a596..4e4350a0 100755
--- a/EmbeddedPkg/Library/GdbDebugAgent/Ia32/Processor.c
+++ b/EmbeddedPkg/Library/GdbDebugAgent/Ia32/Processor.c
@@ -1,917 +1,917 @@
-/** @file
-  Processor specific parts of the GDB stub
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
+/** @file

+  Processor specific parts of the GDB stub

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

 #include <GdbDebugAgent.h>

-
-//
-// Array of exception types that need to be hooked by the debugger
-// {EFI mapping, GDB mapping}
-//
-EFI_EXCEPTION_TYPE_ENTRY gExceptionType[] = {
-  { EXCEPT_IA32_DIVIDE_ERROR,     GDB_SIGFPE  }, 
-  { EXCEPT_IA32_DEBUG,            GDB_SIGTRAP },
-  { EXCEPT_IA32_NMI,              GDB_SIGEMT  },
-  { EXCEPT_IA32_BREAKPOINT,       GDB_SIGTRAP },
-  { EXCEPT_IA32_OVERFLOW,         GDB_SIGSEGV },
-  { EXCEPT_IA32_BOUND,            GDB_SIGSEGV },
-  { EXCEPT_IA32_INVALID_OPCODE,   GDB_SIGILL  },
-  { EXCEPT_IA32_DOUBLE_FAULT,     GDB_SIGEMT  },
-  { EXCEPT_IA32_STACK_FAULT,      GDB_SIGSEGV },
-  { EXCEPT_IA32_GP_FAULT,         GDB_SIGSEGV },
-  { EXCEPT_IA32_PAGE_FAULT,       GDB_SIGSEGV },
-  { EXCEPT_IA32_FP_ERROR,         GDB_SIGEMT  },
-  { EXCEPT_IA32_ALIGNMENT_CHECK,  GDB_SIGEMT  },
-  { EXCEPT_IA32_MACHINE_CHECK,    GDB_SIGEMT  }
-};
-
-
-// The offsets of registers SystemContext.
-// The fields in the array are in the gdb ordering.
-//
-//16 regs
-UINTN gRegisterOffsets[] = {
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Eax),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Ecx),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Edx),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Ebx),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Esp),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Ebp),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Esi),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Edi),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Eip),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Eflags),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Cs),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Ss),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Ds),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Es),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Fs),
-  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Gs)
-};
-
-
-//Debug only..
-VOID 
-PrintReg (
-  IN EFI_SYSTEM_CONTEXT SystemContext
-  )
-{
-  Print ((CHAR16 *)L"EAX: %x ", SystemContext.SystemContextIa32->Eax);
-  Print ((CHAR16 *)L"ECX: %x ", SystemContext.SystemContextIa32->Ecx);
-  Print ((CHAR16 *)L"EDX: %x ", SystemContext.SystemContextIa32->Edx);
-  Print ((CHAR16 *)L"EBX: %x ", SystemContext.SystemContextIa32->Ebx);
-  Print ((CHAR16 *)L"ESP: %x ", SystemContext.SystemContextIa32->Esp);
-  Print ((CHAR16 *)L"EBP: %x ", SystemContext.SystemContextIa32->Ebp);
-  Print ((CHAR16 *)L"ESI: %x ", SystemContext.SystemContextIa32->Esi);
-  Print ((CHAR16 *)L"EDI: %x ", SystemContext.SystemContextIa32->Edi);
-  Print ((CHAR16 *)L"EIP: %x\n", SystemContext.SystemContextIa32->Eip);
-  Print ((CHAR16 *)L"EFlags: %x\n", SystemContext.SystemContextIa32->Eflags);
-}
-
-//Debug only..
-VOID 
-PrintDRreg (
-  IN EFI_SYSTEM_CONTEXT SystemContext
-  )
-{
-  Print ((CHAR16 *)L"DR0: %x ", SystemContext.SystemContextIa32->Dr0);
-  Print ((CHAR16 *)L"DR1: %x ", SystemContext.SystemContextIa32->Dr1);
-  Print ((CHAR16 *)L"DR2: %x ", SystemContext.SystemContextIa32->Dr2);
-  Print ((CHAR16 *)L"DR3: %x ", SystemContext.SystemContextIa32->Dr3);
-  Print ((CHAR16 *)L"DR6: %x ", SystemContext.SystemContextIa32->Dr6);
-  Print ((CHAR16 *)L"DR7: %x\n", SystemContext.SystemContextIa32->Dr7);
-}
-
-
-/**
- Return the number of entries in the gExceptionType[]
- 
- @retval  UINTN, the number of entries in the gExceptionType[] array.    
- **/
-UINTN
-MaxEfiException (
-  VOID
-  )
-{
-  return sizeof (gExceptionType)/sizeof (EFI_EXCEPTION_TYPE_ENTRY);
-}
-
-
-/**
-  Check to see if the ISA is supported. 
-  ISA = Instruction Set Architecture
- 
-  @retval TRUE if Isa is supported,
-      FALSE otherwise.
-**/
-BOOLEAN
-CheckIsa (
-  IN  EFI_INSTRUCTION_SET_ARCHITECTURE  Isa
-  )
-{
-  return (BOOLEAN)(Isa == IsaIa32);
-}
-
-
-/**
- This takes in the register number and the System Context, and returns a pointer to the RegNumber-th register in gdb ordering
- It is, by default, set to find the register pointer of the IA32 member
-
- @param   SystemContext     Register content at time of the exception 
- @param   RegNumber       The register to which we want to find a pointer
- @retval  the pointer to the RegNumber-th pointer
- **/
-UINTN *
-FindPointerToRegister(
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  UINTN               RegNumber  
-  )
-{
-  UINT8 *TempPtr;
-  TempPtr = ((UINT8 *)SystemContext.SystemContextIa32) + gRegisterOffsets[RegNumber];
-  return (UINTN *)TempPtr;
-}
-
-
-/**
- Adds the RegNumber-th register's value to the output buffer, starting at the given OutBufPtr
-
- @param SystemContext     Register content at time of the exception
- @param   RegNumber       the number of the register that we want to read
- @param   OutBufPtr       pointer to the output buffer's end. the new data will be added from this point on.
- @retval  the pointer to the next character of the output buffer that is available to be written on.
- **/
-CHAR8 *
-BasicReadRegister (
-  IN  EFI_SYSTEM_CONTEXT      SystemContext,
-  IN  UINTN           RegNumber,
-  IN  CHAR8           *OutBufPtr
-  )
-{
-  UINTN RegSize;
-  
-  RegSize = 0;
-  while (RegSize < REG_SIZE) {
-    *OutBufPtr++ = mHexToStr[((*FindPointerToRegister(SystemContext, RegNumber) >> (RegSize+4)) & 0xf)];
-    *OutBufPtr++ = mHexToStr[((*FindPointerToRegister(SystemContext, RegNumber) >> RegSize) & 0xf)];
-    RegSize = RegSize + 8;
-  }
-  return OutBufPtr;
-}
-
-
-/** ‘p n’ 
- Reads the n-th register's value into an output buffer and sends it as a packet 
-
- @param   SystemContext   Register content at time of the exception
- @param   InBuffer      Pointer to the input buffer received from gdb server
- **/
-VOID
-EFIAPI
-ReadNthRegister (
-  IN  EFI_SYSTEM_CONTEXT   SystemContext,
-  IN  CHAR8                *InBuffer
-  )
-{
-  UINTN RegNumber;
-  CHAR8 OutBuffer[9]; // 1 reg=8 hex chars, and the end '\0' (escape seq)
-  CHAR8 *OutBufPtr;   // pointer to the output buffer
-  
-  RegNumber = AsciiStrHexToUintn (&InBuffer[1]);
-
-  if ((RegNumber < 0) || (RegNumber >= sizeof (gRegisterOffsets)/sizeof (UINTN))) {
-    SendError (GDB_EINVALIDREGNUM);
-    return;
-  }
-
-  OutBufPtr = OutBuffer;
-  OutBufPtr = BasicReadRegister(SystemContext, RegNumber, OutBufPtr);
-
-  *OutBufPtr = '\0';  // the end of the buffer
-  SendPacket(OutBuffer);
-}
-
-
-/** ‘g’ 
- Reads the general registers into an output buffer  and sends it as a packet 
-
- @param   SystemContext     Register content at time of the exception
- **/
-VOID
-EFIAPI
-ReadGeneralRegisters (  
-  IN  EFI_SYSTEM_CONTEXT      SystemContext
-  )
-{
-  UINTN   i;
-  CHAR8 OutBuffer[129]; // 16 regs, 8 hex chars each, and the end '\0' (escape seq)
-  CHAR8 *OutBufPtr;   // pointer to the output buffer
-
-  OutBufPtr = OutBuffer;
-  for(i = 0 ; i < sizeof (gRegisterOffsets)/sizeof (UINTN) ; i++) {  // there are only 16 registers to read   
-    OutBufPtr = BasicReadRegister(SystemContext, i, OutBufPtr);
-  }
-
-  *OutBufPtr = '\0';  // the end of the buffer
-  SendPacket(OutBuffer);
-}
-
-
-/**
- Adds the RegNumber-th register's value to the output buffer, starting at the given OutBufPtr
-
- @param   SystemContext       Register content at time of the exception
- @param   RegNumber         the number of the register that we want to write
- @param   InBufPtr          pointer to the output buffer. the new data will be extracted from the input buffer from this point on.
- @retval  the pointer to the next character of the input buffer that can be used
- **/
-CHAR8 *
-BasicWriteRegister (
-  IN  EFI_SYSTEM_CONTEXT      SystemContext,
-  IN  UINTN           RegNumber,
-  IN  CHAR8           *InBufPtr
-  )
-{
-  UINTN RegSize;
-  UINTN TempValue; // the value transferred from a hex char
-  UINT32 NewValue; // the new value of the RegNumber-th Register
-  
-  NewValue = 0;
-  RegSize = 0;
-  while (RegSize < REG_SIZE) {
-    TempValue = HexCharToInt(*InBufPtr++);
-    
-   if (TempValue < 0) {
-      SendError (GDB_EBADMEMDATA); 
-      return NULL;
-    }
-
-    NewValue += (TempValue << (RegSize+4));
-    TempValue = HexCharToInt(*InBufPtr++);
-    
-    if (TempValue < 0) {
-      SendError (GDB_EBADMEMDATA); 
-      return NULL;
-    }
-    
-    NewValue += (TempValue << RegSize); 
-    RegSize = RegSize + 8;
-  }
-  *(FindPointerToRegister(SystemContext, RegNumber)) = NewValue;
-  return InBufPtr;
-}
-
-
-/** ‘P n...=r...’
- Writes the new value of n-th register received into the input buffer to the n-th register
-
- @param   SystemContext   Register content at time of the exception
- @param   InBuffer      Ponter to the input buffer received from gdb server
- **/
-VOID
-EFIAPI
-WriteNthRegister (
-  IN  EFI_SYSTEM_CONTEXT      SystemContext,
-  IN  CHAR8           *InBuffer
-  )
-{
-  UINTN RegNumber;
-  CHAR8 RegNumBuffer[MAX_REG_NUM_BUF_SIZE];  // put the 'n..' part of the message into this array
-  CHAR8 *RegNumBufPtr;
-  CHAR8 *InBufPtr; // pointer to the input buffer
-  
-  // find the register number to write
-  InBufPtr = &InBuffer[1];
-  RegNumBufPtr = RegNumBuffer;
-  while (*InBufPtr != '=') {
-    *RegNumBufPtr++ = *InBufPtr++;
-  } 
-  *RegNumBufPtr = '\0';
-  RegNumber = AsciiStrHexToUintn (RegNumBuffer); 
-
-  // check if this is a valid Register Number
-  if ((RegNumber < 0) || (RegNumber >= sizeof (gRegisterOffsets)/sizeof (UINTN))) {
-	SendError (GDB_EINVALIDREGNUM); 
-    return;
-  }
-  InBufPtr++;  // skips the '=' character
-  BasicWriteRegister (SystemContext, RegNumber, InBufPtr);
-  SendSuccess();
-}
-
-
-/** ‘G XX...’
- Writes the new values received into the input buffer to the general registers
-
- @param   SystemContext       Register content at time of the exception
- @param   InBuffer          Pointer to the input buffer received from gdb server
- **/
-VOID
-EFIAPI
-WriteGeneralRegisters (
-  IN  EFI_SYSTEM_CONTEXT        SystemContext,
-  IN  CHAR8             *InBuffer
-  )
-{
-  UINTN  i;
-  CHAR8 *InBufPtr; /// pointer to the input buffer
-
-  // check to see if the buffer is the right size which is 
-  // 1 (for 'G') + 16 (for 16 registers) * 8 ( for 8 hex chars each) = 129 
-  if (AsciiStrLen(InBuffer) != 129) { // 16 regs, 8 hex chars each, and the end '\0' (escape seq)
-	//Bad message. Message is not the right length 
-    SendError (GDB_EBADBUFSIZE); 
-    return;
-  }
-
-  InBufPtr = &InBuffer[1];
-  
-  // Read the new values for the registers from the input buffer to an array, NewValueArray.
-  // The values in the array are in the gdb ordering
-  for(i=0; i < sizeof (gRegisterOffsets)/sizeof (UINTN); i++) {  // there are only 16 registers to write
-    InBufPtr = BasicWriteRegister(SystemContext, i, InBufPtr);
-  }
-
-  SendSuccess();
-}
-
-/** ‘c [addr ]’ 
- Continue. addr is Address to resume. If addr is omitted, resume at current 
- Address.
- 
- @param   SystemContext     Register content at time of the exception  
- **/
-VOID
-EFIAPI
-ContinueAtAddress (
-  IN  EFI_SYSTEM_CONTEXT      SystemContext,
-  IN    CHAR8                 *PacketData
-  )
-{
-  if (PacketData[1] != '\0') {
-    SystemContext.SystemContextIa32->Eip = AsciiStrHexToUintn (&PacketData[1]);
-  } 
-}
-
-
-/** ‘s [addr ]’
- Single step. addr is the Address at which to resume. If addr is omitted, resume 
- at same Address.
- 
- @param   SystemContext     Register content at time of the exception  
- **/
-VOID
-EFIAPI
-SingleStep (
-  IN  EFI_SYSTEM_CONTEXT      SystemContext,
-  IN    CHAR8                 *PacketData
-  )
-{
+

+//

+// Array of exception types that need to be hooked by the debugger

+// {EFI mapping, GDB mapping}

+//

+EFI_EXCEPTION_TYPE_ENTRY gExceptionType[] = {

+  { EXCEPT_IA32_DIVIDE_ERROR,     GDB_SIGFPE  }, 

+  { EXCEPT_IA32_DEBUG,            GDB_SIGTRAP },

+  { EXCEPT_IA32_NMI,              GDB_SIGEMT  },

+  { EXCEPT_IA32_BREAKPOINT,       GDB_SIGTRAP },

+  { EXCEPT_IA32_OVERFLOW,         GDB_SIGSEGV },

+  { EXCEPT_IA32_BOUND,            GDB_SIGSEGV },

+  { EXCEPT_IA32_INVALID_OPCODE,   GDB_SIGILL  },

+  { EXCEPT_IA32_DOUBLE_FAULT,     GDB_SIGEMT  },

+  { EXCEPT_IA32_STACK_FAULT,      GDB_SIGSEGV },

+  { EXCEPT_IA32_GP_FAULT,         GDB_SIGSEGV },

+  { EXCEPT_IA32_PAGE_FAULT,       GDB_SIGSEGV },

+  { EXCEPT_IA32_FP_ERROR,         GDB_SIGEMT  },

+  { EXCEPT_IA32_ALIGNMENT_CHECK,  GDB_SIGEMT  },

+  { EXCEPT_IA32_MACHINE_CHECK,    GDB_SIGEMT  }

+};

+

+

+// The offsets of registers SystemContext.

+// The fields in the array are in the gdb ordering.

+//

+//16 regs

+UINTN gRegisterOffsets[] = {

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Eax),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Ecx),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Edx),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Ebx),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Esp),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Ebp),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Esi),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Edi),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Eip),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Eflags),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Cs),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Ss),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Ds),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Es),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Fs),

+  OFFSET_OF(EFI_SYSTEM_CONTEXT_IA32, Gs)

+};

+

+

+//Debug only..

+VOID 

+PrintReg (

+  IN EFI_SYSTEM_CONTEXT SystemContext

+  )

+{

+  Print ((CHAR16 *)L"EAX: %x ", SystemContext.SystemContextIa32->Eax);

+  Print ((CHAR16 *)L"ECX: %x ", SystemContext.SystemContextIa32->Ecx);

+  Print ((CHAR16 *)L"EDX: %x ", SystemContext.SystemContextIa32->Edx);

+  Print ((CHAR16 *)L"EBX: %x ", SystemContext.SystemContextIa32->Ebx);

+  Print ((CHAR16 *)L"ESP: %x ", SystemContext.SystemContextIa32->Esp);

+  Print ((CHAR16 *)L"EBP: %x ", SystemContext.SystemContextIa32->Ebp);

+  Print ((CHAR16 *)L"ESI: %x ", SystemContext.SystemContextIa32->Esi);

+  Print ((CHAR16 *)L"EDI: %x ", SystemContext.SystemContextIa32->Edi);

+  Print ((CHAR16 *)L"EIP: %x\n", SystemContext.SystemContextIa32->Eip);

+  Print ((CHAR16 *)L"EFlags: %x\n", SystemContext.SystemContextIa32->Eflags);

+}

+

+//Debug only..

+VOID 

+PrintDRreg (

+  IN EFI_SYSTEM_CONTEXT SystemContext

+  )

+{

+  Print ((CHAR16 *)L"DR0: %x ", SystemContext.SystemContextIa32->Dr0);

+  Print ((CHAR16 *)L"DR1: %x ", SystemContext.SystemContextIa32->Dr1);

+  Print ((CHAR16 *)L"DR2: %x ", SystemContext.SystemContextIa32->Dr2);

+  Print ((CHAR16 *)L"DR3: %x ", SystemContext.SystemContextIa32->Dr3);

+  Print ((CHAR16 *)L"DR6: %x ", SystemContext.SystemContextIa32->Dr6);

+  Print ((CHAR16 *)L"DR7: %x\n", SystemContext.SystemContextIa32->Dr7);

+}

+

+

+/**

+ Return the number of entries in the gExceptionType[]

+ 

+ @retval  UINTN, the number of entries in the gExceptionType[] array.    

+ **/

+UINTN

+MaxEfiException (

+  VOID

+  )

+{

+  return sizeof (gExceptionType)/sizeof (EFI_EXCEPTION_TYPE_ENTRY);

+}

+

+

+/**

+  Check to see if the ISA is supported. 

+  ISA = Instruction Set Architecture

+ 

+  @retval TRUE if Isa is supported,

+      FALSE otherwise.

+**/

+BOOLEAN

+CheckIsa (

+  IN  EFI_INSTRUCTION_SET_ARCHITECTURE  Isa

+  )

+{

+  return (BOOLEAN)(Isa == IsaIa32);

+}

+

+

+/**

+ This takes in the register number and the System Context, and returns a pointer to the RegNumber-th register in gdb ordering

+ It is, by default, set to find the register pointer of the IA32 member

+

+ @param   SystemContext     Register content at time of the exception 

+ @param   RegNumber       The register to which we want to find a pointer

+ @retval  the pointer to the RegNumber-th pointer

+ **/

+UINTN *

+FindPointerToRegister(

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  UINTN               RegNumber  

+  )

+{

+  UINT8 *TempPtr;

+  TempPtr = ((UINT8 *)SystemContext.SystemContextIa32) + gRegisterOffsets[RegNumber];

+  return (UINTN *)TempPtr;

+}

+

+

+/**

+ Adds the RegNumber-th register's value to the output buffer, starting at the given OutBufPtr

+

+ @param SystemContext     Register content at time of the exception

+ @param   RegNumber       the number of the register that we want to read

+ @param   OutBufPtr       pointer to the output buffer's end. the new data will be added from this point on.

+ @retval  the pointer to the next character of the output buffer that is available to be written on.

+ **/

+CHAR8 *

+BasicReadRegister (

+  IN  EFI_SYSTEM_CONTEXT      SystemContext,

+  IN  UINTN           RegNumber,

+  IN  CHAR8           *OutBufPtr

+  )

+{

+  UINTN RegSize;

+  

+  RegSize = 0;

+  while (RegSize < REG_SIZE) {

+    *OutBufPtr++ = mHexToStr[((*FindPointerToRegister(SystemContext, RegNumber) >> (RegSize+4)) & 0xf)];

+    *OutBufPtr++ = mHexToStr[((*FindPointerToRegister(SystemContext, RegNumber) >> RegSize) & 0xf)];

+    RegSize = RegSize + 8;

+  }

+  return OutBufPtr;

+}

+

+

+/** ‘p n’ 

+ Reads the n-th register's value into an output buffer and sends it as a packet 

+

+ @param   SystemContext   Register content at time of the exception

+ @param   InBuffer      Pointer to the input buffer received from gdb server

+ **/

+VOID

+EFIAPI

+ReadNthRegister (

+  IN  EFI_SYSTEM_CONTEXT   SystemContext,

+  IN  CHAR8                *InBuffer

+  )

+{

+  UINTN RegNumber;

+  CHAR8 OutBuffer[9]; // 1 reg=8 hex chars, and the end '\0' (escape seq)

+  CHAR8 *OutBufPtr;   // pointer to the output buffer

+  

+  RegNumber = AsciiStrHexToUintn (&InBuffer[1]);

+

+  if ((RegNumber < 0) || (RegNumber >= sizeof (gRegisterOffsets)/sizeof (UINTN))) {

+    SendError (GDB_EINVALIDREGNUM);

+    return;

+  }

+

+  OutBufPtr = OutBuffer;

+  OutBufPtr = BasicReadRegister(SystemContext, RegNumber, OutBufPtr);

+

+  *OutBufPtr = '\0';  // the end of the buffer

+  SendPacket(OutBuffer);

+}

+

+

+/** ‘g’ 

+ Reads the general registers into an output buffer  and sends it as a packet 

+

+ @param   SystemContext     Register content at time of the exception

+ **/

+VOID

+EFIAPI

+ReadGeneralRegisters (  

+  IN  EFI_SYSTEM_CONTEXT      SystemContext

+  )

+{

+  UINTN   i;

+  CHAR8 OutBuffer[129]; // 16 regs, 8 hex chars each, and the end '\0' (escape seq)

+  CHAR8 *OutBufPtr;   // pointer to the output buffer

+

+  OutBufPtr = OutBuffer;

+  for(i = 0 ; i < sizeof (gRegisterOffsets)/sizeof (UINTN) ; i++) {  // there are only 16 registers to read   

+    OutBufPtr = BasicReadRegister(SystemContext, i, OutBufPtr);

+  }

+

+  *OutBufPtr = '\0';  // the end of the buffer

+  SendPacket(OutBuffer);

+}

+

+

+/**

+ Adds the RegNumber-th register's value to the output buffer, starting at the given OutBufPtr

+

+ @param   SystemContext       Register content at time of the exception

+ @param   RegNumber         the number of the register that we want to write

+ @param   InBufPtr          pointer to the output buffer. the new data will be extracted from the input buffer from this point on.

+ @retval  the pointer to the next character of the input buffer that can be used

+ **/

+CHAR8 *

+BasicWriteRegister (

+  IN  EFI_SYSTEM_CONTEXT      SystemContext,

+  IN  UINTN           RegNumber,

+  IN  CHAR8           *InBufPtr

+  )

+{

+  UINTN RegSize;

+  UINTN TempValue; // the value transferred from a hex char

+  UINT32 NewValue; // the new value of the RegNumber-th Register

+  

+  NewValue = 0;

+  RegSize = 0;

+  while (RegSize < REG_SIZE) {

+    TempValue = HexCharToInt(*InBufPtr++);

+    

+   if (TempValue < 0) {

+      SendError (GDB_EBADMEMDATA); 

+      return NULL;

+    }

+

+    NewValue += (TempValue << (RegSize+4));

+    TempValue = HexCharToInt(*InBufPtr++);

+    

+    if (TempValue < 0) {

+      SendError (GDB_EBADMEMDATA); 

+      return NULL;

+    }

+    

+    NewValue += (TempValue << RegSize); 

+    RegSize = RegSize + 8;

+  }

+  *(FindPointerToRegister(SystemContext, RegNumber)) = NewValue;

+  return InBufPtr;

+}

+

+

+/** ‘P n...=r...’

+ Writes the new value of n-th register received into the input buffer to the n-th register

+

+ @param   SystemContext   Register content at time of the exception

+ @param   InBuffer      Ponter to the input buffer received from gdb server

+ **/

+VOID

+EFIAPI

+WriteNthRegister (

+  IN  EFI_SYSTEM_CONTEXT      SystemContext,

+  IN  CHAR8           *InBuffer

+  )

+{

+  UINTN RegNumber;

+  CHAR8 RegNumBuffer[MAX_REG_NUM_BUF_SIZE];  // put the 'n..' part of the message into this array

+  CHAR8 *RegNumBufPtr;

+  CHAR8 *InBufPtr; // pointer to the input buffer

+  

+  // find the register number to write

+  InBufPtr = &InBuffer[1];

+  RegNumBufPtr = RegNumBuffer;

+  while (*InBufPtr != '=') {

+    *RegNumBufPtr++ = *InBufPtr++;

+  } 

+  *RegNumBufPtr = '\0';

+  RegNumber = AsciiStrHexToUintn (RegNumBuffer); 

+

+  // check if this is a valid Register Number

+  if ((RegNumber < 0) || (RegNumber >= sizeof (gRegisterOffsets)/sizeof (UINTN))) {

+	SendError (GDB_EINVALIDREGNUM); 

+    return;

+  }

+  InBufPtr++;  // skips the '=' character

+  BasicWriteRegister (SystemContext, RegNumber, InBufPtr);

+  SendSuccess();

+}

+

+

+/** ‘G XX...’

+ Writes the new values received into the input buffer to the general registers

+

+ @param   SystemContext       Register content at time of the exception

+ @param   InBuffer          Pointer to the input buffer received from gdb server

+ **/

+VOID

+EFIAPI

+WriteGeneralRegisters (

+  IN  EFI_SYSTEM_CONTEXT        SystemContext,

+  IN  CHAR8             *InBuffer

+  )

+{

+  UINTN  i;

+  CHAR8 *InBufPtr; /// pointer to the input buffer

+

+  // check to see if the buffer is the right size which is 

+  // 1 (for 'G') + 16 (for 16 registers) * 8 ( for 8 hex chars each) = 129 

+  if (AsciiStrLen(InBuffer) != 129) { // 16 regs, 8 hex chars each, and the end '\0' (escape seq)

+	//Bad message. Message is not the right length 

+    SendError (GDB_EBADBUFSIZE); 

+    return;

+  }

+

+  InBufPtr = &InBuffer[1];

+  

+  // Read the new values for the registers from the input buffer to an array, NewValueArray.

+  // The values in the array are in the gdb ordering

+  for(i=0; i < sizeof (gRegisterOffsets)/sizeof (UINTN); i++) {  // there are only 16 registers to write

+    InBufPtr = BasicWriteRegister(SystemContext, i, InBufPtr);

+  }

+

+  SendSuccess();

+}

+

+/** ‘c [addr ]’ 

+ Continue. addr is Address to resume. If addr is omitted, resume at current 

+ Address.

+ 

+ @param   SystemContext     Register content at time of the exception  

+ **/

+VOID

+EFIAPI

+ContinueAtAddress (

+  IN  EFI_SYSTEM_CONTEXT      SystemContext,

+  IN    CHAR8                 *PacketData

+  )

+{

+  if (PacketData[1] != '\0') {

+    SystemContext.SystemContextIa32->Eip = AsciiStrHexToUintn (&PacketData[1]);

+  } 

+}

+

+

+/** ‘s [addr ]’

+ Single step. addr is the Address at which to resume. If addr is omitted, resume 

+ at same Address.

+ 

+ @param   SystemContext     Register content at time of the exception  

+ **/

+VOID

+EFIAPI

+SingleStep (

+  IN  EFI_SYSTEM_CONTEXT      SystemContext,

+  IN    CHAR8                 *PacketData

+  )

+{

   SendNotSupported();

-}
-
-
-/**
-  Returns breakpoint data address from DR0-DR3 based on the input breakpoint number
-
-  @param  SystemContext      Register content at time of the exception
-  @param  BreakpointNumber   Breakpoint number
-
-  @retval Address            Data address from DR0-DR3 based on the breakpoint number.
-
-**/
-UINTN
-GetBreakpointDataAddress (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  UINTN               BreakpointNumber
-  )
-{
-  UINTN Address;
-
-  if (BreakpointNumber == 1) {
-    Address = SystemContext.SystemContextIa32->Dr0;
-  } else if (BreakpointNumber == 2) {
-    Address = SystemContext.SystemContextIa32->Dr1;
-  } else if (BreakpointNumber == 3) {
-    Address = SystemContext.SystemContextIa32->Dr2;
-  } else if (BreakpointNumber == 4) {
-    Address = SystemContext.SystemContextIa32->Dr3;
-  } else {
-    Address = 0;
-  }
-
-  return Address;
-}
-
-
-/**
-  Returns currently detected breakpoint value based on the register DR6 B0-B3 field.
-  If no breakpoint is detected then it returns 0.
-
-  @param  SystemContext  Register content at time of the exception
-
-  @retval {1-4}          Currently detected breakpoint value   
-  @retval 0              No breakpoint detected.
- 
-**/
-UINTN
-GetBreakpointDetected (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext
-  )
-{
-  IA32_DR6 Dr6;
-  UINTN BreakpointNumber;
-
-  Dr6.UintN = SystemContext.SystemContextIa32->Dr6;
-
-  if (Dr6.Bits.B0 == 1) {
-    BreakpointNumber = 1;
-  } else if (Dr6.Bits.B1 == 1) {
-    BreakpointNumber = 2;
-  } else if (Dr6.Bits.B2 == 1) {
-    BreakpointNumber = 3;
-  } else if (Dr6.Bits.B3 == 1) {
-    BreakpointNumber = 4;
-  } else {
-    BreakpointNumber = 0;  //No breakpoint detected 
-  }
-
-  return BreakpointNumber;
-}
-
-
-/**
-  Returns Breakpoint type (InstructionExecution, DataWrite, DataRead or DataReadWrite)
-  based on the Breakpoint number
-  
-  @param  SystemContext        Register content at time of the exception
-  @param  BreakpointNumber     Breakpoint number
-  
-  @retval BREAK_TYPE           Breakpoint type value read from register DR7 RWn field
-                               For unknown value, it returns NotSupported.
-  
-**/
-BREAK_TYPE
-GetBreakpointType (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  UINTN               BreakpointNumber
-  )
-{
-  IA32_DR7 Dr7;
-  BREAK_TYPE Type = NotSupported;  //Default is NotSupported type
-
-  Dr7.UintN = SystemContext.SystemContextIa32->Dr7;
-
-  if (BreakpointNumber == 1) {
-    Type = (BREAK_TYPE) Dr7.Bits.RW0;  
-  } else if (BreakpointNumber == 2) {
-    Type = (BREAK_TYPE) Dr7.Bits.RW1;  
-  } else if (BreakpointNumber == 3) {
-    Type = (BREAK_TYPE) Dr7.Bits.RW2;  
-  } else if (BreakpointNumber == 4) {
-    Type = (BREAK_TYPE) Dr7.Bits.RW3;  
-  }
-
-  return Type;
-}
-
-
-/** 
-  Parses Length and returns the length which DR7 LENn field accepts.
-  For example: If we receive 1-Byte length then we should return 0. 
-               Zero gets written to DR7 LENn field.
-
-  @param  Length  Breakpoint length in Bytes (1 byte, 2 byte, 4 byte)
-
-  @retval Length  Appropriate converted values which DR7 LENn field accepts.
-
-**/
-UINTN
-ConvertLengthData (
-  IN     UINTN   Length
-  )
-{
-  if (Length == 1) {         //1-Byte length 
-    return 0;
-  } else if (Length == 2) {  //2-Byte length
-    return 1;
-  } else if (Length == 4) {  //4-Byte length
-    return 3;
-  } else {                   //Undefined or 8-byte length
-    return 2;
-  }
-}
-
-
-/**
-  Finds the next free debug register. If all the registers are occupied then 
-  EFI_OUT_OF_RESOURCES is returned.  
-
-  @param  SystemContext   Register content at time of the exception
-  @param  Register        Register value (0 - 3 for the first free debug register)
-
-  @retval EFI_STATUS      Appropriate status value.
-
-**/
-EFI_STATUS
-FindNextFreeDebugRegister (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  OUT UINTN               *Register
-  )
-{
-  IA32_DR7 Dr7;
-
-  Dr7.UintN = SystemContext.SystemContextIa32->Dr7;
-
-  if (Dr7.Bits.G0 == 0) {
-    *Register = 0;
-  } else if (Dr7.Bits.G1 == 0) {
-    *Register = 1;
-  } else if (Dr7.Bits.G2 == 0) {
-    *Register = 2;
-  } else if (Dr7.Bits.G3 == 0) {
-    *Register = 3;
-  } else {
-    return EFI_OUT_OF_RESOURCES;
-  }
-
-  return EFI_SUCCESS;
-}
-
-
-/**
-  Enables the debug register. Writes Address value to appropriate DR0-3 register.
-  Sets LENn, Gn, RWn bits in DR7 register.
- 
-  @param  SystemContext   Register content at time of the exception
-  @param  Register        Register value (0 - 3) 
-  @param  Address         Breakpoint address value
-  @param  Type            Breakpoint type (Instruction, Data write, Data read 
-                          or write etc.)
-
-  @retval EFI_STATUS      Appropriate status value.
-
-**/
-EFI_STATUS
-EnableDebugRegister (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  UINTN               Register,
-  IN  UINTN               Address,
-  IN  UINTN               Length,
-  IN  UINTN               Type
-  )
-{
-  IA32_DR7  Dr7;
-
-  //Convert length data
-  Length = ConvertLengthData (Length);
-
-  //For Instruction execution, length should be 0 
-  //(Ref. Intel reference manual 18.2.4)
-  if ((Type == 0) && (Length != 0)) {
-    return EFI_INVALID_PARAMETER;
-  }
- 
-  //Hardware doesn't support ReadWatch (z3 packet) type. GDB can handle
-  //software breakpoint. We should send empty packet in both these cases.
-  if ((Type == (BREAK_TYPE)DataRead) || 
-      (Type == (BREAK_TYPE)SoftwareBreakpoint)) {
-    return EFI_UNSUPPORTED;
-  }
-
-  //Read DR7 so appropriate Gn, RWn and LENn bits can be modified.
-  Dr7.UintN = SystemContext.SystemContextIa32->Dr7;
-
-  if (Register == 0) {
-    SystemContext.SystemContextIa32->Dr0 = Address;
-    Dr7.Bits.G0 = 1;
-    Dr7.Bits.RW0 = Type;
-    Dr7.Bits.LEN0 = Length;
-  } else if (Register == 1) {
-    SystemContext.SystemContextIa32->Dr1 = Address;
-    Dr7.Bits.G1 = 1;
-    Dr7.Bits.RW1 = Type;
-    Dr7.Bits.LEN1 = Length;
-  } else if (Register == 2) {
-    SystemContext.SystemContextIa32->Dr2 = Address;
-    Dr7.Bits.G2 = 1;
-    Dr7.Bits.RW2 = Type;
-    Dr7.Bits.LEN2 = Length;
-  } else if (Register == 3) {
-    SystemContext.SystemContextIa32->Dr3 = Address;
-    Dr7.Bits.G3 = 1;
-    Dr7.Bits.RW3 = Type;
-    Dr7.Bits.LEN3 = Length;
-  } else {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  //Update Dr7 with appropriate Gn, RWn and LENn bits 
-  SystemContext.SystemContextIa32->Dr7 = Dr7.UintN;
-
-  return EFI_SUCCESS;
-}
-
-
-/**
-  Returns register number 0 - 3 for the maching debug register.
-  This function compares incoming Address, Type, Length and
-  if there is a match then it returns the appropriate register number.
-  In case of mismatch, function returns EFI_NOT_FOUND message.
-
-  @param  SystemContext  Register content at time of the exception
-  @param  Address        Breakpoint address value
-  @param  Length         Breakpoint length value
-  @param  Type           Breakpoint type (Instruction, Data write, 
-                         Data read or write etc.)
-  @param  Register       Register value to be returned
-
-  @retval EFI_STATUS     Appropriate status value.
-
-**/
-EFI_STATUS
-FindMatchingDebugRegister (
- IN  EFI_SYSTEM_CONTEXT  SystemContext,
- IN  UINTN               Address,
- IN  UINTN               Length,
- IN  UINTN               Type,
- OUT UINTN               *Register
- )
-{
-  IA32_DR7 Dr7;
-
-  //Hardware doesn't support ReadWatch (z3 packet) type. GDB can handle
-  //software breakpoint. We should send empty packet in both these cases.
-  if ((Type == (BREAK_TYPE)DataRead) || 
-      (Type == (BREAK_TYPE)SoftwareBreakpoint)) {
-    return EFI_UNSUPPORTED;
-  }
-
-  //Convert length data
-  Length = ConvertLengthData(Length);
-
-  Dr7.UintN = SystemContext.SystemContextIa32->Dr7;
-
-  if ((Dr7.Bits.G0 == 1) && 
-      (Dr7.Bits.LEN0 == Length) &&
-      (Dr7.Bits.RW0 == Type) && 
-      (Address == SystemContext.SystemContextIa32->Dr0)) {
-    *Register = 0;
-  } else if ((Dr7.Bits.G1 == 1) && 
-             (Dr7.Bits.LEN1 == Length) &&
-             (Dr7.Bits.RW1 == Type) && 
-             (Address == SystemContext.SystemContextIa32->Dr1)) {
-    *Register = 1;
-  } else if ((Dr7.Bits.G2 == 1) && 
-             (Dr7.Bits.LEN2 == Length) &&
-             (Dr7.Bits.RW2 == Type) && 
-             (Address == SystemContext.SystemContextIa32->Dr2)) {
-    *Register = 2;
-  } else if ((Dr7.Bits.G3 == 1) && 
-             (Dr7.Bits.LEN3 == Length) &&
-             (Dr7.Bits.RW3 == Type) && 
-             (Address == SystemContext.SystemContextIa32->Dr3)) {
-    *Register = 3;
-  } else {
-    Print ((CHAR16 *)L"No match found..\n");
-    return EFI_NOT_FOUND;
-  }
-
-  return EFI_SUCCESS;
-}
-
-
-/**
-  Disables the particular debug register.
-
-  @param  SystemContext   Register content at time of the exception
-  @param  Register        Register to be disabled
-
-  @retval EFI_STATUS      Appropriate status value.
-
-**/
-EFI_STATUS
-DisableDebugRegister (
- IN  EFI_SYSTEM_CONTEXT  SystemContext,
- IN  UINTN               Register  
- )
-{
-  IA32_DR7  Dr7;
-  UINTN Address = 0;
- 
-  //Read DR7 register so appropriate Gn, RWn and LENn bits can be turned off.
-  Dr7.UintN = SystemContext.SystemContextIa32->Dr7;
-
-  if (Register == 0) {
-    SystemContext.SystemContextIa32->Dr0 = Address;
-    Dr7.Bits.G0 = 0;
-    Dr7.Bits.RW0 = 0;
-    Dr7.Bits.LEN0 = 0;
-  } else if (Register == 1) {
-    SystemContext.SystemContextIa32->Dr1 = Address;
-    Dr7.Bits.G1 = 0;
-    Dr7.Bits.RW1 = 0;
-    Dr7.Bits.LEN1 = 0;
-  } else if (Register == 2) {
-    SystemContext.SystemContextIa32->Dr2 = Address;
-    Dr7.Bits.G2 = 0;
-    Dr7.Bits.RW2 = 0;
-    Dr7.Bits.LEN2 = 0;
-  } else if (Register == 3) {
-    SystemContext.SystemContextIa32->Dr3 = Address;
-    Dr7.Bits.G3 = 0;
-    Dr7.Bits.RW3 = 0;
-    Dr7.Bits.LEN3 = 0;
-  } else {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  //Update DR7 register so appropriate Gn, RWn and LENn bits can be turned off.
-  SystemContext.SystemContextIa32->Dr7 = Dr7.UintN;
-
-  return EFI_SUCCESS;
-}
-
-
-/**
-  ‘Z1, [addr], [length]’
-  ‘Z2, [addr], [length]’
-  ‘Z3, [addr], [length]’
-  ‘Z4, [addr], [length]’
-
-  Insert hardware breakpoint/watchpoint at address addr of size length
-
-  @param SystemContext  Register content at time of the exception
-  @param *PacketData    Pointer to the Payload data for the packet
-
-**/
-VOID
-EFIAPI
-InsertBreakPoint (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  CHAR8              *PacketData
-  )
-{
-  UINTN Type;
-  UINTN Address;
-  UINTN Length;
-  UINTN Register;
-  EFI_STATUS Status;
-  BREAK_TYPE BreakType = NotSupported;
-  UINTN ErrorCode;
-
-  ErrorCode = ParseBreakpointPacket (PacketData, &Type, &Address, &Length);
-  if (ErrorCode > 0) {
-    SendError ((UINT8)ErrorCode);
-    return;
-  }
-
-  switch (Type) {
-
-    case    0:   //Software breakpoint
-      BreakType = SoftwareBreakpoint;
-      break;
-
-    case    1:   //Hardware breakpoint
-      BreakType = InstructionExecution;
-      break;
-
-    case    2:   //Write watchpoint
-      BreakType = DataWrite;
-      break;
-
-    case    3:   //Read watchpoint
-      BreakType = DataRead;
-      break;
-
-    case    4:   //Access watchpoint
-      BreakType = DataReadWrite;
-      break;
-
-    default  :
-      Print ((CHAR16 *)L"Insert breakpoint default: %x\n", Type);
-      SendError (GDB_EINVALIDBRKPOINTTYPE);
-      return;
-  }
-
-  // Find next free debug register
-  Status = FindNextFreeDebugRegister (SystemContext, &Register);
-  if (EFI_ERROR(Status)) {
-    Print ((CHAR16 *)L"No space left on device\n");
-    SendError (GDB_ENOSPACE);
-    return;
-  }
-
-  // Write Address, length data at particular DR register
-  Status = EnableDebugRegister (SystemContext, Register, Address, Length, (UINTN)BreakType);
-  if (EFI_ERROR(Status)) {
-    if (Status == EFI_UNSUPPORTED) {
-      SendNotSupported();
-      return;
-    }
-
-    SendError (GDB_EINVALIDARG);
-    return;
-  }
-
-  SendSuccess ();
-}
-
-
-/**
-  ‘z1, [addr], [length]’
-  ‘z2, [addr], [length]’
-  ‘z3, [addr], [length]’
-  ‘z4, [addr], [length]’
-
-  Remove hardware breakpoint/watchpoint at address addr of size length
-
-  @param *PacketData    Pointer to the Payload data for the packet
-
-**/
-VOID
-EFIAPI
-RemoveBreakPoint (
-  IN  EFI_SYSTEM_CONTEXT  SystemContext,
-  IN  CHAR8               *PacketData
-  )
-{
-  UINTN      Type;
-  UINTN      Address;
-  UINTN      Length;
-  UINTN      Register;
-  BREAK_TYPE BreakType = NotSupported;
-  EFI_STATUS Status;
-  UINTN      ErrorCode;
-
-  //Parse breakpoint packet data
-  ErrorCode = ParseBreakpointPacket (PacketData, &Type, &Address, &Length);
-  if (ErrorCode > 0) {
-    SendError ((UINT8)ErrorCode);
-    return;
-  }
-
-  switch (Type) {
-  
-    case    0:   //Software breakpoint
-      BreakType = SoftwareBreakpoint;
-      break;
-      
-    case    1:   //Hardware breakpoint
-      BreakType = InstructionExecution;
-      break;
-      
-    case    2:   //Write watchpoint
-      BreakType = DataWrite;
-      break;
-
-    case    3:   //Read watchpoint
-      BreakType = DataRead;
-      break;
-
-    case    4:   //Access watchpoint
-      BreakType = DataReadWrite;
-      break;
-
-    default  :
-      SendError (GDB_EINVALIDBRKPOINTTYPE);
-      return;
-  }
-
-  //Find matching debug register
-  Status = FindMatchingDebugRegister (SystemContext, Address, Length, (UINTN)BreakType, &Register);
-  if (EFI_ERROR(Status)) {
-    if (Status == EFI_UNSUPPORTED) {
-      SendNotSupported();
-      return;
-    }
-
-    SendError (GDB_ENOSPACE);
-    return;
-  }
-
-  //Remove breakpoint
-  Status = DisableDebugRegister(SystemContext, Register);
-  if (EFI_ERROR(Status)) {
-    SendError (GDB_EINVALIDARG);
-    return;
-  }
-
-  SendSuccess ();
-}
-
-
+}

+

+

+/**

+  Returns breakpoint data address from DR0-DR3 based on the input breakpoint number

+

+  @param  SystemContext      Register content at time of the exception

+  @param  BreakpointNumber   Breakpoint number

+

+  @retval Address            Data address from DR0-DR3 based on the breakpoint number.

+

+**/

+UINTN

+GetBreakpointDataAddress (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  UINTN               BreakpointNumber

+  )

+{

+  UINTN Address;

+

+  if (BreakpointNumber == 1) {

+    Address = SystemContext.SystemContextIa32->Dr0;

+  } else if (BreakpointNumber == 2) {

+    Address = SystemContext.SystemContextIa32->Dr1;

+  } else if (BreakpointNumber == 3) {

+    Address = SystemContext.SystemContextIa32->Dr2;

+  } else if (BreakpointNumber == 4) {

+    Address = SystemContext.SystemContextIa32->Dr3;

+  } else {

+    Address = 0;

+  }

+

+  return Address;

+}

+

+

+/**

+  Returns currently detected breakpoint value based on the register DR6 B0-B3 field.

+  If no breakpoint is detected then it returns 0.

+

+  @param  SystemContext  Register content at time of the exception

+

+  @retval {1-4}          Currently detected breakpoint value   

+  @retval 0              No breakpoint detected.

+ 

+**/

+UINTN

+GetBreakpointDetected (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext

+  )

+{

+  IA32_DR6 Dr6;

+  UINTN BreakpointNumber;

+

+  Dr6.UintN = SystemContext.SystemContextIa32->Dr6;

+

+  if (Dr6.Bits.B0 == 1) {

+    BreakpointNumber = 1;

+  } else if (Dr6.Bits.B1 == 1) {

+    BreakpointNumber = 2;

+  } else if (Dr6.Bits.B2 == 1) {

+    BreakpointNumber = 3;

+  } else if (Dr6.Bits.B3 == 1) {

+    BreakpointNumber = 4;

+  } else {

+    BreakpointNumber = 0;  //No breakpoint detected 

+  }

+

+  return BreakpointNumber;

+}

+

+

+/**

+  Returns Breakpoint type (InstructionExecution, DataWrite, DataRead or DataReadWrite)

+  based on the Breakpoint number

+  

+  @param  SystemContext        Register content at time of the exception

+  @param  BreakpointNumber     Breakpoint number

+  

+  @retval BREAK_TYPE           Breakpoint type value read from register DR7 RWn field

+                               For unknown value, it returns NotSupported.

+  

+**/

+BREAK_TYPE

+GetBreakpointType (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  UINTN               BreakpointNumber

+  )

+{

+  IA32_DR7 Dr7;

+  BREAK_TYPE Type = NotSupported;  //Default is NotSupported type

+

+  Dr7.UintN = SystemContext.SystemContextIa32->Dr7;

+

+  if (BreakpointNumber == 1) {

+    Type = (BREAK_TYPE) Dr7.Bits.RW0;  

+  } else if (BreakpointNumber == 2) {

+    Type = (BREAK_TYPE) Dr7.Bits.RW1;  

+  } else if (BreakpointNumber == 3) {

+    Type = (BREAK_TYPE) Dr7.Bits.RW2;  

+  } else if (BreakpointNumber == 4) {

+    Type = (BREAK_TYPE) Dr7.Bits.RW3;  

+  }

+

+  return Type;

+}

+

+

+/** 

+  Parses Length and returns the length which DR7 LENn field accepts.

+  For example: If we receive 1-Byte length then we should return 0. 

+               Zero gets written to DR7 LENn field.

+

+  @param  Length  Breakpoint length in Bytes (1 byte, 2 byte, 4 byte)

+

+  @retval Length  Appropriate converted values which DR7 LENn field accepts.

+

+**/

+UINTN

+ConvertLengthData (

+  IN     UINTN   Length

+  )

+{

+  if (Length == 1) {         //1-Byte length 

+    return 0;

+  } else if (Length == 2) {  //2-Byte length

+    return 1;

+  } else if (Length == 4) {  //4-Byte length

+    return 3;

+  } else {                   //Undefined or 8-byte length

+    return 2;

+  }

+}

+

+

+/**

+  Finds the next free debug register. If all the registers are occupied then 

+  EFI_OUT_OF_RESOURCES is returned.  

+

+  @param  SystemContext   Register content at time of the exception

+  @param  Register        Register value (0 - 3 for the first free debug register)

+

+  @retval EFI_STATUS      Appropriate status value.

+

+**/

+EFI_STATUS

+FindNextFreeDebugRegister (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  OUT UINTN               *Register

+  )

+{

+  IA32_DR7 Dr7;

+

+  Dr7.UintN = SystemContext.SystemContextIa32->Dr7;

+

+  if (Dr7.Bits.G0 == 0) {

+    *Register = 0;

+  } else if (Dr7.Bits.G1 == 0) {

+    *Register = 1;

+  } else if (Dr7.Bits.G2 == 0) {

+    *Register = 2;

+  } else if (Dr7.Bits.G3 == 0) {

+    *Register = 3;

+  } else {

+    return EFI_OUT_OF_RESOURCES;

+  }

+

+  return EFI_SUCCESS;

+}

+

+

+/**

+  Enables the debug register. Writes Address value to appropriate DR0-3 register.

+  Sets LENn, Gn, RWn bits in DR7 register.

+ 

+  @param  SystemContext   Register content at time of the exception

+  @param  Register        Register value (0 - 3) 

+  @param  Address         Breakpoint address value

+  @param  Type            Breakpoint type (Instruction, Data write, Data read 

+                          or write etc.)

+

+  @retval EFI_STATUS      Appropriate status value.

+

+**/

+EFI_STATUS

+EnableDebugRegister (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  UINTN               Register,

+  IN  UINTN               Address,

+  IN  UINTN               Length,

+  IN  UINTN               Type

+  )

+{

+  IA32_DR7  Dr7;

+

+  //Convert length data

+  Length = ConvertLengthData (Length);

+

+  //For Instruction execution, length should be 0 

+  //(Ref. Intel reference manual 18.2.4)

+  if ((Type == 0) && (Length != 0)) {

+    return EFI_INVALID_PARAMETER;

+  }

+ 

+  //Hardware doesn't support ReadWatch (z3 packet) type. GDB can handle

+  //software breakpoint. We should send empty packet in both these cases.

+  if ((Type == (BREAK_TYPE)DataRead) || 

+      (Type == (BREAK_TYPE)SoftwareBreakpoint)) {

+    return EFI_UNSUPPORTED;

+  }

+

+  //Read DR7 so appropriate Gn, RWn and LENn bits can be modified.

+  Dr7.UintN = SystemContext.SystemContextIa32->Dr7;

+

+  if (Register == 0) {

+    SystemContext.SystemContextIa32->Dr0 = Address;

+    Dr7.Bits.G0 = 1;

+    Dr7.Bits.RW0 = Type;

+    Dr7.Bits.LEN0 = Length;

+  } else if (Register == 1) {

+    SystemContext.SystemContextIa32->Dr1 = Address;

+    Dr7.Bits.G1 = 1;

+    Dr7.Bits.RW1 = Type;

+    Dr7.Bits.LEN1 = Length;

+  } else if (Register == 2) {

+    SystemContext.SystemContextIa32->Dr2 = Address;

+    Dr7.Bits.G2 = 1;

+    Dr7.Bits.RW2 = Type;

+    Dr7.Bits.LEN2 = Length;

+  } else if (Register == 3) {

+    SystemContext.SystemContextIa32->Dr3 = Address;

+    Dr7.Bits.G3 = 1;

+    Dr7.Bits.RW3 = Type;

+    Dr7.Bits.LEN3 = Length;

+  } else {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  //Update Dr7 with appropriate Gn, RWn and LENn bits 

+  SystemContext.SystemContextIa32->Dr7 = Dr7.UintN;

+

+  return EFI_SUCCESS;

+}

+

+

+/**

+  Returns register number 0 - 3 for the maching debug register.

+  This function compares incoming Address, Type, Length and

+  if there is a match then it returns the appropriate register number.

+  In case of mismatch, function returns EFI_NOT_FOUND message.

+

+  @param  SystemContext  Register content at time of the exception

+  @param  Address        Breakpoint address value

+  @param  Length         Breakpoint length value

+  @param  Type           Breakpoint type (Instruction, Data write, 

+                         Data read or write etc.)

+  @param  Register       Register value to be returned

+

+  @retval EFI_STATUS     Appropriate status value.

+

+**/

+EFI_STATUS

+FindMatchingDebugRegister (

+ IN  EFI_SYSTEM_CONTEXT  SystemContext,

+ IN  UINTN               Address,

+ IN  UINTN               Length,

+ IN  UINTN               Type,

+ OUT UINTN               *Register

+ )

+{

+  IA32_DR7 Dr7;

+

+  //Hardware doesn't support ReadWatch (z3 packet) type. GDB can handle

+  //software breakpoint. We should send empty packet in both these cases.

+  if ((Type == (BREAK_TYPE)DataRead) || 

+      (Type == (BREAK_TYPE)SoftwareBreakpoint)) {

+    return EFI_UNSUPPORTED;

+  }

+

+  //Convert length data

+  Length = ConvertLengthData(Length);

+

+  Dr7.UintN = SystemContext.SystemContextIa32->Dr7;

+

+  if ((Dr7.Bits.G0 == 1) && 

+      (Dr7.Bits.LEN0 == Length) &&

+      (Dr7.Bits.RW0 == Type) && 

+      (Address == SystemContext.SystemContextIa32->Dr0)) {

+    *Register = 0;

+  } else if ((Dr7.Bits.G1 == 1) && 

+             (Dr7.Bits.LEN1 == Length) &&

+             (Dr7.Bits.RW1 == Type) && 

+             (Address == SystemContext.SystemContextIa32->Dr1)) {

+    *Register = 1;

+  } else if ((Dr7.Bits.G2 == 1) && 

+             (Dr7.Bits.LEN2 == Length) &&

+             (Dr7.Bits.RW2 == Type) && 

+             (Address == SystemContext.SystemContextIa32->Dr2)) {

+    *Register = 2;

+  } else if ((Dr7.Bits.G3 == 1) && 

+             (Dr7.Bits.LEN3 == Length) &&

+             (Dr7.Bits.RW3 == Type) && 

+             (Address == SystemContext.SystemContextIa32->Dr3)) {

+    *Register = 3;

+  } else {

+    Print ((CHAR16 *)L"No match found..\n");

+    return EFI_NOT_FOUND;

+  }

+

+  return EFI_SUCCESS;

+}

+

+

+/**

+  Disables the particular debug register.

+

+  @param  SystemContext   Register content at time of the exception

+  @param  Register        Register to be disabled

+

+  @retval EFI_STATUS      Appropriate status value.

+

+**/

+EFI_STATUS

+DisableDebugRegister (

+ IN  EFI_SYSTEM_CONTEXT  SystemContext,

+ IN  UINTN               Register  

+ )

+{

+  IA32_DR7  Dr7;

+  UINTN Address = 0;

+ 

+  //Read DR7 register so appropriate Gn, RWn and LENn bits can be turned off.

+  Dr7.UintN = SystemContext.SystemContextIa32->Dr7;

+

+  if (Register == 0) {

+    SystemContext.SystemContextIa32->Dr0 = Address;

+    Dr7.Bits.G0 = 0;

+    Dr7.Bits.RW0 = 0;

+    Dr7.Bits.LEN0 = 0;

+  } else if (Register == 1) {

+    SystemContext.SystemContextIa32->Dr1 = Address;

+    Dr7.Bits.G1 = 0;

+    Dr7.Bits.RW1 = 0;

+    Dr7.Bits.LEN1 = 0;

+  } else if (Register == 2) {

+    SystemContext.SystemContextIa32->Dr2 = Address;

+    Dr7.Bits.G2 = 0;

+    Dr7.Bits.RW2 = 0;

+    Dr7.Bits.LEN2 = 0;

+  } else if (Register == 3) {

+    SystemContext.SystemContextIa32->Dr3 = Address;

+    Dr7.Bits.G3 = 0;

+    Dr7.Bits.RW3 = 0;

+    Dr7.Bits.LEN3 = 0;

+  } else {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  //Update DR7 register so appropriate Gn, RWn and LENn bits can be turned off.

+  SystemContext.SystemContextIa32->Dr7 = Dr7.UintN;

+

+  return EFI_SUCCESS;

+}

+

+

+/**

+  ‘Z1, [addr], [length]’

+  ‘Z2, [addr], [length]’

+  ‘Z3, [addr], [length]’

+  ‘Z4, [addr], [length]’

+

+  Insert hardware breakpoint/watchpoint at address addr of size length

+

+  @param SystemContext  Register content at time of the exception

+  @param *PacketData    Pointer to the Payload data for the packet

+

+**/

+VOID

+EFIAPI

+InsertBreakPoint (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  CHAR8              *PacketData

+  )

+{

+  UINTN Type;

+  UINTN Address;

+  UINTN Length;

+  UINTN Register;

+  EFI_STATUS Status;

+  BREAK_TYPE BreakType = NotSupported;

+  UINTN ErrorCode;

+

+  ErrorCode = ParseBreakpointPacket (PacketData, &Type, &Address, &Length);

+  if (ErrorCode > 0) {

+    SendError ((UINT8)ErrorCode);

+    return;

+  }

+

+  switch (Type) {

+

+    case    0:   //Software breakpoint

+      BreakType = SoftwareBreakpoint;

+      break;

+

+    case    1:   //Hardware breakpoint

+      BreakType = InstructionExecution;

+      break;

+

+    case    2:   //Write watchpoint

+      BreakType = DataWrite;

+      break;

+

+    case    3:   //Read watchpoint

+      BreakType = DataRead;

+      break;

+

+    case    4:   //Access watchpoint

+      BreakType = DataReadWrite;

+      break;

+

+    default  :

+      Print ((CHAR16 *)L"Insert breakpoint default: %x\n", Type);

+      SendError (GDB_EINVALIDBRKPOINTTYPE);

+      return;

+  }

+

+  // Find next free debug register

+  Status = FindNextFreeDebugRegister (SystemContext, &Register);

+  if (EFI_ERROR(Status)) {

+    Print ((CHAR16 *)L"No space left on device\n");

+    SendError (GDB_ENOSPACE);

+    return;

+  }

+

+  // Write Address, length data at particular DR register

+  Status = EnableDebugRegister (SystemContext, Register, Address, Length, (UINTN)BreakType);

+  if (EFI_ERROR(Status)) {

+    if (Status == EFI_UNSUPPORTED) {

+      SendNotSupported();

+      return;

+    }

+

+    SendError (GDB_EINVALIDARG);

+    return;

+  }

+

+  SendSuccess ();

+}

+

+

+/**

+  ‘z1, [addr], [length]’

+  ‘z2, [addr], [length]’

+  ‘z3, [addr], [length]’

+  ‘z4, [addr], [length]’

+

+  Remove hardware breakpoint/watchpoint at address addr of size length

+

+  @param *PacketData    Pointer to the Payload data for the packet

+

+**/

+VOID

+EFIAPI

+RemoveBreakPoint (

+  IN  EFI_SYSTEM_CONTEXT  SystemContext,

+  IN  CHAR8               *PacketData

+  )

+{

+  UINTN      Type;

+  UINTN      Address;

+  UINTN      Length;

+  UINTN      Register;

+  BREAK_TYPE BreakType = NotSupported;

+  EFI_STATUS Status;

+  UINTN      ErrorCode;

+

+  //Parse breakpoint packet data

+  ErrorCode = ParseBreakpointPacket (PacketData, &Type, &Address, &Length);

+  if (ErrorCode > 0) {

+    SendError ((UINT8)ErrorCode);

+    return;

+  }

+

+  switch (Type) {

+  

+    case    0:   //Software breakpoint

+      BreakType = SoftwareBreakpoint;

+      break;

+      

+    case    1:   //Hardware breakpoint

+      BreakType = InstructionExecution;

+      break;

+      

+    case    2:   //Write watchpoint

+      BreakType = DataWrite;

+      break;

+

+    case    3:   //Read watchpoint

+      BreakType = DataRead;

+      break;

+

+    case    4:   //Access watchpoint

+      BreakType = DataReadWrite;

+      break;

+

+    default  :

+      SendError (GDB_EINVALIDBRKPOINTTYPE);

+      return;

+  }

+

+  //Find matching debug register

+  Status = FindMatchingDebugRegister (SystemContext, Address, Length, (UINTN)BreakType, &Register);

+  if (EFI_ERROR(Status)) {

+    if (Status == EFI_UNSUPPORTED) {

+      SendNotSupported();

+      return;

+    }

+

+    SendError (GDB_ENOSPACE);

+    return;

+  }

+

+  //Remove breakpoint

+  Status = DisableDebugRegister(SystemContext, Register);

+  if (EFI_ERROR(Status)) {

+    SendError (GDB_EINVALIDARG);

+    return;

+  }

+

+  SendSuccess ();

+}

+

+

 /**

   Initialize debug agent.

 

diff --git a/EmbeddedPkg/Library/NullDmaLib/NullDmaLib.inf b/EmbeddedPkg/Library/NullDmaLib/NullDmaLib.inf
index 4897a8a9..8e8ccaee 100755
--- a/EmbeddedPkg/Library/NullDmaLib/NullDmaLib.inf
+++ b/EmbeddedPkg/Library/NullDmaLib/NullDmaLib.inf
@@ -38,4 +38,4 @@
 [Pcd]

 

 [Depex]

-  TRUE
\ No newline at end of file
+  TRUE
\ No newline at end of file
diff --git a/EmbeddedPkg/Library/PrePiHobLib/Hob.c b/EmbeddedPkg/Library/PrePiHobLib/Hob.c
index a92a1de5..320dddfc 100644
--- a/EmbeddedPkg/Library/PrePiHobLib/Hob.c
+++ b/EmbeddedPkg/Library/PrePiHobLib/Hob.c
@@ -1,852 +1,852 @@
-/** @file
-
-  Copyright (c) 2010, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include <PiPei.h>
-
-#include <Library/BaseLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/DebugLib.h>
-#include <Library/PeCoffLib.h>
-#include <Library/HobLib.h>
-#include <Library/PcdLib.h>
-#include <Library/PrePiHobListPointerLib.h>
-
-#include <Protocol/PeCoffLoader.h>
-#include <Guid/ExtractSection.h>
-#include <Guid/MemoryTypeInformation.h>
-#include <Guid/MemoryAllocationHob.h>
-
-VOID
-BuildMemoryTypeInformationHob (
-  VOID
-  );
-
-/**
-  Returns the pointer to the HOB list.
-
-  This function returns the pointer to first HOB in the list.
-
-  @return The pointer to the HOB list.
-
-**/
-VOID *
-EFIAPI
-GetHobList (
-  VOID
-  )
-{
-  return PrePeiGetHobList ();
-}
-
-
-
-/**
-  Updates the pointer to the HOB list.
-
-  @param  HobList       Hob list pointer to store
-
-**/
-EFI_STATUS
-EFIAPI
-SetHobList (
-  IN  VOID      *HobList
-  )
-{
-  return PrePeiSetHobList (HobList);
-}
-
-/**
-
-
-**/
-EFI_HOB_HANDOFF_INFO_TABLE*
-HobConstructor (
-  IN VOID   *EfiMemoryBegin,
-  IN UINTN  EfiMemoryLength,
-  IN VOID   *EfiFreeMemoryBottom,
-  IN VOID   *EfiFreeMemoryTop
-  )
-{
-  EFI_HOB_HANDOFF_INFO_TABLE  *Hob;
-  EFI_HOB_GENERIC_HEADER      *HobEnd;
-
-  Hob    = EfiFreeMemoryBottom;
-  HobEnd = (EFI_HOB_GENERIC_HEADER *)(Hob+1);
-
-  Hob->Header.HobType     = EFI_HOB_TYPE_HANDOFF;
-  Hob->Header.HobLength   = sizeof(EFI_HOB_HANDOFF_INFO_TABLE);
-  Hob->Header.Reserved    = 0;
-
-  HobEnd->HobType     = EFI_HOB_TYPE_END_OF_HOB_LIST;
-  HobEnd->HobLength   = sizeof(EFI_HOB_GENERIC_HEADER);
-  HobEnd->Reserved    = 0;
-
-  Hob->Version             = EFI_HOB_HANDOFF_TABLE_VERSION;
-  Hob->BootMode            = BOOT_WITH_FULL_CONFIGURATION;
-
-  Hob->EfiMemoryTop        = (UINTN)EfiMemoryBegin + EfiMemoryLength;
-  Hob->EfiMemoryBottom     = (UINTN)EfiMemoryBegin;
-  Hob->EfiFreeMemoryTop    = (UINTN)EfiFreeMemoryTop;
-  Hob->EfiFreeMemoryBottom = (EFI_PHYSICAL_ADDRESS)(UINTN)(HobEnd+1);
-  Hob->EfiEndOfHobList     = (EFI_PHYSICAL_ADDRESS)(UINTN)HobEnd;
-
-  return Hob;
-}
-
-VOID *
-CreateHob (
-  IN  UINT16    HobType,
-  IN  UINT16    HobLength
-  )
-{
-  EFI_HOB_HANDOFF_INFO_TABLE  *HandOffHob;
-  EFI_HOB_GENERIC_HEADER      *HobEnd;
-  EFI_PHYSICAL_ADDRESS        FreeMemory;
-  VOID                        *Hob;
-
-  HandOffHob = GetHobList ();
-
-  HobLength = (UINT16)((HobLength + 0x7) & (~0x7));
-
-  FreeMemory = HandOffHob->EfiFreeMemoryTop - HandOffHob->EfiFreeMemoryBottom;
-
-  if (FreeMemory < HobLength) {
-      return NULL;
-  }
-
-  Hob = (VOID*) (UINTN) HandOffHob->EfiEndOfHobList;
-  ((EFI_HOB_GENERIC_HEADER*) Hob)->HobType = HobType;
-  ((EFI_HOB_GENERIC_HEADER*) Hob)->HobLength = HobLength;
-  ((EFI_HOB_GENERIC_HEADER*) Hob)->Reserved = 0;
-
-  HobEnd = (EFI_HOB_GENERIC_HEADER*) ((UINTN)Hob + HobLength);
-  HandOffHob->EfiEndOfHobList = (EFI_PHYSICAL_ADDRESS) (UINTN) HobEnd;
-
-  HobEnd->HobType   = EFI_HOB_TYPE_END_OF_HOB_LIST;
-  HobEnd->HobLength = sizeof(EFI_HOB_GENERIC_HEADER);
-  HobEnd->Reserved  = 0;
-  HobEnd++;
-  HandOffHob->EfiFreeMemoryBottom = (EFI_PHYSICAL_ADDRESS) (UINTN) HobEnd;
-
-  return Hob;
-}
-
-/**
-  Builds a HOB that describes a chunk of system memory.
-
-  This function builds a HOB that describes a chunk of system memory.
-  If there is no additional space for HOB creation, then ASSERT().
-
-  @param  ResourceType        The type of resource described by this HOB.
-  @param  ResourceAttribute   The resource attributes of the memory described by this HOB.
-  @param  PhysicalStart       The 64 bit physical address of memory described by this HOB.
-  @param  NumberOfBytes       The length of the memory described by this HOB in bytes.
-
-**/
-VOID
-EFIAPI
-BuildResourceDescriptorHob (
-  IN EFI_RESOURCE_TYPE            ResourceType,
-  IN EFI_RESOURCE_ATTRIBUTE_TYPE  ResourceAttribute,
-  IN EFI_PHYSICAL_ADDRESS         PhysicalStart,
-  IN UINT64                       NumberOfBytes
-  )
-{
-  EFI_HOB_RESOURCE_DESCRIPTOR  *Hob;
-
-  Hob = CreateHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, sizeof (EFI_HOB_RESOURCE_DESCRIPTOR));
-  ASSERT(Hob != NULL);
-
-  Hob->ResourceType      = ResourceType;
-  Hob->ResourceAttribute = ResourceAttribute;
-  Hob->PhysicalStart     = PhysicalStart;
-  Hob->ResourceLength    = NumberOfBytes;
-}
-
-/**
-
-
-**/
-VOID
-CreateHobList (
-  IN VOID   *MemoryBegin,
-  IN UINTN  MemoryLength,
-  IN VOID   *HobBase,
-  IN VOID   *StackBase
-  )
-{
-  EFI_HOB_HANDOFF_INFO_TABLE  *Hob;
-  EFI_RESOURCE_ATTRIBUTE_TYPE Attributes;
-
-  Hob = HobConstructor (MemoryBegin,MemoryLength,HobBase,StackBase);
-  SetHobList (Hob);
-
-  BuildCpuHob (PcdGet8 (PcdPrePiCpuMemorySize), PcdGet8 (PcdPrePiCpuIoSize));
-  
-  Attributes =(
-    EFI_RESOURCE_ATTRIBUTE_PRESENT |
-    EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
-    EFI_RESOURCE_ATTRIBUTE_TESTED |
-    EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE |
-    EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE |
-    EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE |
-    EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE
-  );
-
-  BuildResourceDescriptorHob (EFI_RESOURCE_SYSTEM_MEMORY, Attributes, (UINTN)MemoryBegin, MemoryLength);
-
-  BuildStackHob ((EFI_PHYSICAL_ADDRESS)(UINTN)StackBase, ((UINTN)MemoryBegin + MemoryLength) - (UINTN)StackBase);
-
-  if (FeaturePcdGet (PcdPrePiProduceMemoryTypeInformationHob)) {
-    // Optional feature that helps prevent EFI memory map fragmentation. 
-    BuildMemoryTypeInformationHob ();
-  }
-}  
-  
-
-VOID
-EFIAPI
-BuildFvHobs (  
-  IN EFI_PHYSICAL_ADDRESS         PhysicalStart,
-  IN UINT64                       NumberOfBytes,
-  IN EFI_RESOURCE_ATTRIBUTE_TYPE  *ResourceAttribute
-  ) 
-{
-
-  EFI_RESOURCE_ATTRIBUTE_TYPE Resource;
-  
-  BuildFvHob (PhysicalStart, NumberOfBytes);
-  
-  if (ResourceAttribute == NULL) {
-    Resource = (EFI_RESOURCE_ATTRIBUTE_PRESENT    |
-                EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
-                EFI_RESOURCE_ATTRIBUTE_TESTED |
-                EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE);
-  } else {
-    Resource = *ResourceAttribute;
-  }
-  
-  BuildResourceDescriptorHob (EFI_RESOURCE_FIRMWARE_DEVICE, Resource, PhysicalStart, NumberOfBytes);
-}
-
-/**
-  Returns the next instance of a HOB type from the starting HOB.
-
-  This function searches the first instance of a HOB type from the starting HOB pointer. 
-  If there does not exist such HOB type from the starting HOB pointer, it will return NULL.
-  In contrast with macro GET_NEXT_HOB(), this function does not skip the starting HOB pointer
-  unconditionally: it returns HobStart back if HobStart itself meets the requirement;
-  caller is required to use GET_NEXT_HOB() if it wishes to skip current HobStart.
-  If HobStart is NULL, then ASSERT().
-
-  @param  Type          The HOB type to return.
-  @param  HobStart      The starting HOB pointer to search from.
-
-  @return The next instance of a HOB type from the starting HOB.
-
-**/
-VOID *
-EFIAPI
-GetNextHob (
-  IN UINT16                 Type,
-  IN CONST VOID             *HobStart
-  )
-{
-  EFI_PEI_HOB_POINTERS  Hob;
-
-  ASSERT (HobStart != NULL);
-   
-  Hob.Raw = (UINT8 *) HobStart;
-  //
-  // Parse the HOB list until end of list or matching type is found.
-  //
-  while (!END_OF_HOB_LIST (Hob)) {
-    if (Hob.Header->HobType == Type) {
-      return Hob.Raw;
-    }
-    Hob.Raw = GET_NEXT_HOB (Hob);
-  }
-  return NULL;
-}
-  
-  
-
-/**
-  Returns the first instance of a HOB type among the whole HOB list.
-
-  This function searches the first instance of a HOB type among the whole HOB list. 
-  If there does not exist such HOB type in the HOB list, it will return NULL. 
-
-  @param  Type          The HOB type to return.
-
-  @return The next instance of a HOB type from the starting HOB.
-
-**/
-VOID *
-EFIAPI
-GetFirstHob (
-  IN UINT16                 Type
-  )
-{
-  VOID      *HobList;
-
-  HobList = GetHobList ();
-  return GetNextHob (Type, HobList);
-}
-
-
-/**
-  This function searches the first instance of a HOB from the starting HOB pointer. 
-  Such HOB should satisfy two conditions: 
-  its HOB type is EFI_HOB_TYPE_GUID_EXTENSION and its GUID Name equals to the input Guid. 
-  If there does not exist such HOB from the starting HOB pointer, it will return NULL. 
-  Caller is required to apply GET_GUID_HOB_DATA () and GET_GUID_HOB_DATA_SIZE ()
-  to extract the data section and its size info respectively.
-  In contrast with macro GET_NEXT_HOB(), this function does not skip the starting HOB pointer
-  unconditionally: it returns HobStart back if HobStart itself meets the requirement;
-  caller is required to use GET_NEXT_HOB() if it wishes to skip current HobStart.
-  If Guid is NULL, then ASSERT().
-  If HobStart is NULL, then ASSERT().
-
-  @param  Guid          The GUID to match with in the HOB list.
-  @param  HobStart      A pointer to a Guid.
-
-  @return The next instance of the matched GUID HOB from the starting HOB.
-
-**/
-VOID *
-EFIAPI
-GetNextGuidHob (
-  IN CONST EFI_GUID         *Guid,
-  IN CONST VOID             *HobStart
-  ){
-  EFI_PEI_HOB_POINTERS  GuidHob;
-
-  GuidHob.Raw = (UINT8 *) HobStart;
-  while ((GuidHob.Raw = GetNextHob (EFI_HOB_TYPE_GUID_EXTENSION, GuidHob.Raw)) != NULL) {
-    if (CompareGuid (Guid, &GuidHob.Guid->Name)) {
-      break;
-    }
-    GuidHob.Raw = GET_NEXT_HOB (GuidHob);
-  }
-  return GuidHob.Raw;
-}
-
-
-/**
-  This function searches the first instance of a HOB among the whole HOB list. 
-  Such HOB should satisfy two conditions:
-  its HOB type is EFI_HOB_TYPE_GUID_EXTENSION and its GUID Name equals to the input Guid.
-  If there does not exist such HOB from the starting HOB pointer, it will return NULL.
-  Caller is required to apply GET_GUID_HOB_DATA () and GET_GUID_HOB_DATA_SIZE ()
-  to extract the data section and its size info respectively.
-  If Guid is NULL, then ASSERT().
-
-  @param  Guid          The GUID to match with in the HOB list.
-
-  @return The first instance of the matched GUID HOB among the whole HOB list.
-
-**/
-VOID *
-EFIAPI
-GetFirstGuidHob (
-  IN CONST EFI_GUID         *Guid
-  )
-{
-  VOID      *HobList;
-
-  HobList = GetHobList ();
-  return GetNextGuidHob (Guid, HobList);
-}
-
-
-/**
-  Get the Boot Mode from the HOB list.
-
-  This function returns the system boot mode information from the 
-  PHIT HOB in HOB list.
-
-  @param  VOID
-
-  @return The Boot Mode.
-
-**/
-EFI_BOOT_MODE
-EFIAPI
-GetBootMode (
-  VOID
-  )
-{
-  EFI_PEI_HOB_POINTERS  Hob;
-
-  Hob.Raw = GetHobList ();
-  return Hob.HandoffInformationTable->BootMode;
-}
-
-
-/**
-  Get the Boot Mode from the HOB list.
-
-  This function returns the system boot mode information from the 
-  PHIT HOB in HOB list.
-
-  @param  VOID
-
-  @return The Boot Mode.
-
-**/
-EFI_STATUS
-EFIAPI
-SetBootMode (
-  IN  EFI_BOOT_MODE   BootMode
-  )
-{
-  EFI_PEI_HOB_POINTERS  Hob;
-
-  Hob.Raw = GetHobList ();
-  Hob.HandoffInformationTable->BootMode = BootMode;
-  return BootMode;
-}
-
-/**
-  Builds a HOB for a loaded PE32 module.
-
-  This function builds a HOB for a loaded PE32 module.
-  It can only be invoked during PEI phase;
-  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
-  If ModuleName is NULL, then ASSERT().
-  If there is no additional space for HOB creation, then ASSERT().
-
-  @param  ModuleName              The GUID File Name of the module.
-  @param  MemoryAllocationModule  The 64 bit physical address of the module.
-  @param  ModuleLength            The length of the module in bytes.
-  @param  EntryPoint              The 64 bit physical address of the module entry point.
-
-**/
-VOID
-EFIAPI
-BuildModuleHob (
-  IN CONST EFI_GUID         *ModuleName,
-  IN EFI_PHYSICAL_ADDRESS   MemoryAllocationModule,
-  IN UINT64                 ModuleLength,
-  IN EFI_PHYSICAL_ADDRESS   EntryPoint
-  )
-{
-  EFI_HOB_MEMORY_ALLOCATION_MODULE  *Hob;
-
-  ASSERT (((MemoryAllocationModule & (EFI_PAGE_SIZE - 1)) == 0) &&
-          ((ModuleLength & (EFI_PAGE_SIZE - 1)) == 0));
-
-  Hob = CreateHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, sizeof (EFI_HOB_MEMORY_ALLOCATION_MODULE));
-
-  CopyGuid (&(Hob->MemoryAllocationHeader.Name), &gEfiHobMemoryAllocModuleGuid);
-  Hob->MemoryAllocationHeader.MemoryBaseAddress = MemoryAllocationModule;
-  Hob->MemoryAllocationHeader.MemoryLength      = ModuleLength;
-  Hob->MemoryAllocationHeader.MemoryType        = EfiBootServicesCode;
-
-  //
-  // Zero the reserved space to match HOB spec
-  //
-  ZeroMem (Hob->MemoryAllocationHeader.Reserved, sizeof (Hob->MemoryAllocationHeader.Reserved));
-  
-  CopyGuid (&Hob->ModuleName, ModuleName);
-  Hob->EntryPoint = EntryPoint;
-}
-
-/**
-  Builds a GUID HOB with a certain data length.
-
-  This function builds a customized HOB tagged with a GUID for identification 
-  and returns the start address of GUID HOB data so that caller can fill the customized data. 
-  The HOB Header and Name field is already stripped.
-  It can only be invoked during PEI phase;
-  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
-  If Guid is NULL, then ASSERT().
-  If there is no additional space for HOB creation, then ASSERT().
-  If DataLength >= (0x10000 - sizeof (EFI_HOB_GUID_TYPE)), then ASSERT().
-
-  @param  Guid          The GUID to tag the customized HOB.
-  @param  DataLength    The size of the data payload for the GUID HOB.
-
-  @return The start address of GUID HOB data.
-
-**/
-VOID *
-EFIAPI
-BuildGuidHob (
-  IN CONST EFI_GUID              *Guid,
-  IN UINTN                       DataLength
-  )
-{
-  EFI_HOB_GUID_TYPE *Hob;
-
-  //
-  // Make sure that data length is not too long.
-  //
-  ASSERT (DataLength <= (0xffff - sizeof (EFI_HOB_GUID_TYPE)));
-
-  Hob = CreateHob (EFI_HOB_TYPE_GUID_EXTENSION, (UINT16) (sizeof (EFI_HOB_GUID_TYPE) + DataLength));
-  CopyGuid (&Hob->Name, Guid);
-  return Hob + 1;
-}
-
-
-/**
-  Copies a data buffer to a newly-built HOB.
-
-  This function builds a customized HOB tagged with a GUID for identification,
-  copies the input data to the HOB data field and returns the start address of the GUID HOB data.
-  The HOB Header and Name field is already stripped.
-  It can only be invoked during PEI phase;
-  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
-  If Guid is NULL, then ASSERT().
-  If Data is NULL and DataLength > 0, then ASSERT().
-  If there is no additional space for HOB creation, then ASSERT().
-  If DataLength >= (0x10000 - sizeof (EFI_HOB_GUID_TYPE)), then ASSERT().
-
-  @param  Guid          The GUID to tag the customized HOB.
-  @param  Data          The data to be copied into the data field of the GUID HOB.
-  @param  DataLength    The size of the data payload for the GUID HOB.
-
-  @return The start address of GUID HOB data.
-
-**/
-VOID *
-EFIAPI
-BuildGuidDataHob (
-  IN CONST EFI_GUID              *Guid,
-  IN VOID                        *Data,
-  IN UINTN                       DataLength
-  )
-{
-  VOID  *HobData;
-
-  ASSERT (Data != NULL || DataLength == 0);
-
-  HobData = BuildGuidHob (Guid, DataLength);
-
-  return CopyMem (HobData, Data, DataLength);
-}
-
-
-/**
-  Builds a Firmware Volume HOB.
-
-  This function builds a Firmware Volume HOB.
-  It can only be invoked during PEI phase;
-  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
-  If there is no additional space for HOB creation, then ASSERT().
-
-  @param  BaseAddress   The base address of the Firmware Volume.
-  @param  Length        The size of the Firmware Volume in bytes.
-
-**/
-VOID
-EFIAPI
-BuildFvHob (
-  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
-  IN UINT64                      Length
-  )
-{
-  EFI_HOB_FIRMWARE_VOLUME  *Hob;
-
-  Hob = CreateHob (EFI_HOB_TYPE_FV, sizeof (EFI_HOB_FIRMWARE_VOLUME));
-
-  Hob->BaseAddress = BaseAddress;
-  Hob->Length      = Length;
-}
-
-
-/**
-  Builds a EFI_HOB_TYPE_FV2 HOB.
-
-  This function builds a EFI_HOB_TYPE_FV2 HOB.
-  It can only be invoked during PEI phase;
-  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
-  If there is no additional space for HOB creation, then ASSERT().
-
-  @param  BaseAddress   The base address of the Firmware Volume.
-  @param  Length        The size of the Firmware Volume in bytes.
-  @param  FvName       The name of the Firmware Volume.
-  @param  FileName      The name of the file.
-  
-**/
-VOID
-EFIAPI
-BuildFv2Hob (
-  IN          EFI_PHYSICAL_ADDRESS        BaseAddress,
-  IN          UINT64                      Length,
-  IN CONST    EFI_GUID                    *FvName,
-  IN CONST    EFI_GUID                    *FileName
-  )
-{
-  EFI_HOB_FIRMWARE_VOLUME2  *Hob;
-
-  Hob = CreateHob (EFI_HOB_TYPE_FV2, sizeof (EFI_HOB_FIRMWARE_VOLUME2));
-
-  Hob->BaseAddress = BaseAddress;
-  Hob->Length      = Length;
-  CopyGuid (&Hob->FvName, FvName);
-  CopyGuid (&Hob->FileName, FileName);
-}
-
-
-
-/**
-  Builds a Capsule Volume HOB.
-
-  This function builds a Capsule Volume HOB.
-  It can only be invoked during PEI phase;
-  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
-  If there is no additional space for HOB creation, then ASSERT().
-
-  @param  BaseAddress   The base address of the Capsule Volume.
-  @param  Length        The size of the Capsule Volume in bytes.
-
-**/
-VOID
-EFIAPI
-BuildCvHob (
-  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
-  IN UINT64                      Length
-  )
-{
-  ASSERT (FALSE);
-}
-
-
-/**
-  Builds a HOB for the CPU.
-
-  This function builds a HOB for the CPU.
-  It can only be invoked during PEI phase;
-  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
-  If there is no additional space for HOB creation, then ASSERT().
-
-  @param  SizeOfMemorySpace   The maximum physical memory addressability of the processor.
-  @param  SizeOfIoSpace       The maximum physical I/O addressability of the processor.
-
-**/
-VOID
-EFIAPI
-BuildCpuHob (
-  IN UINT8                       SizeOfMemorySpace,
-  IN UINT8                       SizeOfIoSpace
-  )
-{
-  EFI_HOB_CPU  *Hob;
-
-  Hob = CreateHob (EFI_HOB_TYPE_CPU, sizeof (EFI_HOB_CPU));
-
-  Hob->SizeOfMemorySpace = SizeOfMemorySpace;
-  Hob->SizeOfIoSpace     = SizeOfIoSpace;
-
-  //
-  // Zero the reserved space to match HOB spec
-  //
-  ZeroMem (Hob->Reserved, sizeof (Hob->Reserved)); 
-}
-
-
-/**
-  Builds a HOB for the Stack.
-
-  This function builds a HOB for the stack.
-  It can only be invoked during PEI phase;
-  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
-  If there is no additional space for HOB creation, then ASSERT().
-
-  @param  BaseAddress   The 64 bit physical address of the Stack.
-  @param  Length        The length of the stack in bytes.
-
-**/
-VOID
-EFIAPI
-BuildStackHob (
-  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
-  IN UINT64                      Length
-  )
-{
-  EFI_HOB_MEMORY_ALLOCATION_STACK  *Hob;
-
-  ASSERT (((BaseAddress & (EFI_PAGE_SIZE - 1)) == 0) &&
-          ((Length & (EFI_PAGE_SIZE - 1)) == 0));
-
-  Hob = CreateHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, sizeof (EFI_HOB_MEMORY_ALLOCATION_STACK));
-
-  CopyGuid (&(Hob->AllocDescriptor.Name), &gEfiHobMemoryAllocStackGuid);
-  Hob->AllocDescriptor.MemoryBaseAddress = BaseAddress;
-  Hob->AllocDescriptor.MemoryLength      = Length;
-  Hob->AllocDescriptor.MemoryType        = EfiBootServicesData;
-
-  //
-  // Zero the reserved space to match HOB spec
-  //
-  ZeroMem (Hob->AllocDescriptor.Reserved, sizeof (Hob->AllocDescriptor.Reserved));
-}
-
-
-/**
-  Update the Stack Hob if the stack has been moved
-
-  @param  BaseAddress   The 64 bit physical address of the Stack.
-  @param  Length        The length of the stack in bytes.
-
-**/
-VOID
-UpdateStackHob (
-  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
-  IN UINT64                      Length
-  )
-{
-  EFI_PEI_HOB_POINTERS           Hob;
-
-  Hob.Raw = GetHobList ();
-  while ((Hob.Raw = GetNextHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, Hob.Raw)) != NULL) {
-    if (CompareGuid (&gEfiHobMemoryAllocStackGuid, &(Hob.MemoryAllocationStack->AllocDescriptor.Name))) {
-      //
-      // Build a new memory allocation HOB with old stack info with EfiConventionalMemory type
-      // to be reclaimed by DXE core.
-      //
-      BuildMemoryAllocationHob (
-        Hob.MemoryAllocationStack->AllocDescriptor.MemoryBaseAddress,
-        Hob.MemoryAllocationStack->AllocDescriptor.MemoryLength,
-        EfiConventionalMemory
-        );
-      //
-      // Update the BSP Stack Hob to reflect the new stack info.
-      //
-      Hob.MemoryAllocationStack->AllocDescriptor.MemoryBaseAddress = BaseAddress;
-      Hob.MemoryAllocationStack->AllocDescriptor.MemoryLength = Length;
-      break;
-    }
-    Hob.Raw = GET_NEXT_HOB (Hob);
-  }
-}
-
-
-
-/**
-  Builds a HOB for the memory allocation.
-
-  This function builds a HOB for the memory allocation.
-  It can only be invoked during PEI phase;
-  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.
-  If there is no additional space for HOB creation, then ASSERT().
-
-  @param  BaseAddress   The 64 bit physical address of the memory.
-  @param  Length        The length of the memory allocation in bytes.
-  @param  MemoryType    Type of memory allocated by this HOB.
-
-**/
-VOID
-EFIAPI
-BuildMemoryAllocationHob (
-  IN EFI_PHYSICAL_ADDRESS        BaseAddress,
-  IN UINT64                      Length,
-  IN EFI_MEMORY_TYPE             MemoryType
-  )
-{
-  EFI_HOB_MEMORY_ALLOCATION  *Hob;
-
-  ASSERT (((BaseAddress & (EFI_PAGE_SIZE - 1)) == 0) &&
-          ((Length & (EFI_PAGE_SIZE - 1)) == 0));
-  
-  Hob = CreateHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, sizeof (EFI_HOB_MEMORY_ALLOCATION));
-  
-  ZeroMem (&(Hob->AllocDescriptor.Name), sizeof (EFI_GUID));
-  Hob->AllocDescriptor.MemoryBaseAddress = BaseAddress;
-  Hob->AllocDescriptor.MemoryLength      = Length;
-  Hob->AllocDescriptor.MemoryType        = MemoryType;
-  //
-  // Zero the reserved space to match HOB spec
-  //
-  ZeroMem (Hob->AllocDescriptor.Reserved, sizeof (Hob->AllocDescriptor.Reserved));
-}
-
-
-
-VOID
-EFIAPI
-BuildExtractSectionHob (
-  IN  EFI_GUID                                  *Guid,
-  IN  EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER   SectionGetInfo,
-  IN  EXTRACT_GUIDED_SECTION_DECODE_HANDLER     SectionExtraction
-  )
-{
-  EXTRACT_SECTION_DATA Data;
-  
-  Data.SectionGetInfo    = SectionGetInfo;
-  Data.SectionExtraction = SectionExtraction;
-  BuildGuidDataHob (Guid, &Data, sizeof (Data));
-}
-
-PE_COFF_LOADER_PROTOCOL gPeCoffProtocol = {
-  PeCoffLoaderGetImageInfo,
-  PeCoffLoaderLoadImage,
-  PeCoffLoaderRelocateImage,
-  PeCoffLoaderImageReadFromMemory,
-  PeCoffLoaderRelocateImageForRuntime,
-  PeCoffLoaderUnloadImage
-};
-
-
-
-VOID
-EFIAPI
-BuildPeCoffLoaderHob (
-  VOID
-  )
-{
-  VOID  *Ptr;      
-  
-  Ptr = &gPeCoffProtocol;
-  BuildGuidDataHob (&gPeCoffLoaderProtocolGuid, &Ptr, sizeof (VOID *));  
-}
-
-// May want to put this into a library so you only need the PCD setings if you are using the feature?
-VOID
-BuildMemoryTypeInformationHob (
-  VOID
-  )
-{
-  EFI_MEMORY_TYPE_INFORMATION   Info[10];
-
-  Info[0].Type          = EfiACPIReclaimMemory;
-  Info[0].NumberOfPages = PcdGet32 (PcdMemoryTypeEfiACPIReclaimMemory);
-  Info[1].Type          = EfiACPIMemoryNVS;
-  Info[1].NumberOfPages = PcdGet32 (PcdMemoryTypeEfiACPIMemoryNVS);
-  Info[2].Type          = EfiReservedMemoryType;
-  Info[2].NumberOfPages = PcdGet32 (PcdMemoryTypeEfiReservedMemoryType);
-  Info[3].Type          = EfiRuntimeServicesData;
-  Info[3].NumberOfPages = PcdGet32 (PcdMemoryTypeEfiRuntimeServicesData);
-  Info[4].Type          = EfiRuntimeServicesCode;
-  Info[4].NumberOfPages = PcdGet32 (PcdMemoryTypeEfiRuntimeServicesCode);
-  Info[5].Type          = EfiBootServicesCode;
-  Info[5].NumberOfPages = PcdGet32 (PcdMemoryTypeEfiBootServicesCode);
-  Info[6].Type          = EfiBootServicesData;
-  Info[6].NumberOfPages = PcdGet32 (PcdMemoryTypeEfiBootServicesData);
-  Info[7].Type          = EfiLoaderCode;
-  Info[7].NumberOfPages = PcdGet32 (PcdMemoryTypeEfiLoaderCode);
-  Info[8].Type          = EfiLoaderData;
-  Info[8].NumberOfPages = PcdGet32 (PcdMemoryTypeEfiLoaderData);
-
-  // Terminator for the list
-  Info[9].Type          = EfiMaxMemoryType;
-  Info[9].NumberOfPages = 0;
-
-
-  BuildGuidDataHob (&gEfiMemoryTypeInformationGuid, &Info, sizeof (Info));
-}
-
+/** @file

+

+  Copyright (c) 2010, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include <PiPei.h>

+

+#include <Library/BaseLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/DebugLib.h>

+#include <Library/PeCoffLib.h>

+#include <Library/HobLib.h>

+#include <Library/PcdLib.h>

+#include <Library/PrePiHobListPointerLib.h>

+

+#include <Protocol/PeCoffLoader.h>

+#include <Guid/ExtractSection.h>

+#include <Guid/MemoryTypeInformation.h>

+#include <Guid/MemoryAllocationHob.h>

+

+VOID

+BuildMemoryTypeInformationHob (

+  VOID

+  );

+

+/**

+  Returns the pointer to the HOB list.

+

+  This function returns the pointer to first HOB in the list.

+

+  @return The pointer to the HOB list.

+

+**/

+VOID *

+EFIAPI

+GetHobList (

+  VOID

+  )

+{

+  return PrePeiGetHobList ();

+}

+

+

+

+/**

+  Updates the pointer to the HOB list.

+

+  @param  HobList       Hob list pointer to store

+

+**/

+EFI_STATUS

+EFIAPI

+SetHobList (

+  IN  VOID      *HobList

+  )

+{

+  return PrePeiSetHobList (HobList);

+}

+

+/**

+

+

+**/

+EFI_HOB_HANDOFF_INFO_TABLE*

+HobConstructor (

+  IN VOID   *EfiMemoryBegin,

+  IN UINTN  EfiMemoryLength,

+  IN VOID   *EfiFreeMemoryBottom,

+  IN VOID   *EfiFreeMemoryTop

+  )

+{

+  EFI_HOB_HANDOFF_INFO_TABLE  *Hob;

+  EFI_HOB_GENERIC_HEADER      *HobEnd;

+

+  Hob    = EfiFreeMemoryBottom;

+  HobEnd = (EFI_HOB_GENERIC_HEADER *)(Hob+1);

+

+  Hob->Header.HobType     = EFI_HOB_TYPE_HANDOFF;

+  Hob->Header.HobLength   = sizeof(EFI_HOB_HANDOFF_INFO_TABLE);

+  Hob->Header.Reserved    = 0;

+

+  HobEnd->HobType     = EFI_HOB_TYPE_END_OF_HOB_LIST;

+  HobEnd->HobLength   = sizeof(EFI_HOB_GENERIC_HEADER);

+  HobEnd->Reserved    = 0;

+

+  Hob->Version             = EFI_HOB_HANDOFF_TABLE_VERSION;

+  Hob->BootMode            = BOOT_WITH_FULL_CONFIGURATION;

+

+  Hob->EfiMemoryTop        = (UINTN)EfiMemoryBegin + EfiMemoryLength;

+  Hob->EfiMemoryBottom     = (UINTN)EfiMemoryBegin;

+  Hob->EfiFreeMemoryTop    = (UINTN)EfiFreeMemoryTop;

+  Hob->EfiFreeMemoryBottom = (EFI_PHYSICAL_ADDRESS)(UINTN)(HobEnd+1);

+  Hob->EfiEndOfHobList     = (EFI_PHYSICAL_ADDRESS)(UINTN)HobEnd;

+

+  return Hob;

+}

+

+VOID *

+CreateHob (

+  IN  UINT16    HobType,

+  IN  UINT16    HobLength

+  )

+{

+  EFI_HOB_HANDOFF_INFO_TABLE  *HandOffHob;

+  EFI_HOB_GENERIC_HEADER      *HobEnd;

+  EFI_PHYSICAL_ADDRESS        FreeMemory;

+  VOID                        *Hob;

+

+  HandOffHob = GetHobList ();

+

+  HobLength = (UINT16)((HobLength + 0x7) & (~0x7));

+

+  FreeMemory = HandOffHob->EfiFreeMemoryTop - HandOffHob->EfiFreeMemoryBottom;

+

+  if (FreeMemory < HobLength) {

+      return NULL;

+  }

+

+  Hob = (VOID*) (UINTN) HandOffHob->EfiEndOfHobList;

+  ((EFI_HOB_GENERIC_HEADER*) Hob)->HobType = HobType;

+  ((EFI_HOB_GENERIC_HEADER*) Hob)->HobLength = HobLength;

+  ((EFI_HOB_GENERIC_HEADER*) Hob)->Reserved = 0;

+

+  HobEnd = (EFI_HOB_GENERIC_HEADER*) ((UINTN)Hob + HobLength);

+  HandOffHob->EfiEndOfHobList = (EFI_PHYSICAL_ADDRESS) (UINTN) HobEnd;

+

+  HobEnd->HobType   = EFI_HOB_TYPE_END_OF_HOB_LIST;

+  HobEnd->HobLength = sizeof(EFI_HOB_GENERIC_HEADER);

+  HobEnd->Reserved  = 0;

+  HobEnd++;

+  HandOffHob->EfiFreeMemoryBottom = (EFI_PHYSICAL_ADDRESS) (UINTN) HobEnd;

+

+  return Hob;

+}

+

+/**

+  Builds a HOB that describes a chunk of system memory.

+

+  This function builds a HOB that describes a chunk of system memory.

+  If there is no additional space for HOB creation, then ASSERT().

+

+  @param  ResourceType        The type of resource described by this HOB.

+  @param  ResourceAttribute   The resource attributes of the memory described by this HOB.

+  @param  PhysicalStart       The 64 bit physical address of memory described by this HOB.

+  @param  NumberOfBytes       The length of the memory described by this HOB in bytes.

+

+**/

+VOID

+EFIAPI

+BuildResourceDescriptorHob (

+  IN EFI_RESOURCE_TYPE            ResourceType,

+  IN EFI_RESOURCE_ATTRIBUTE_TYPE  ResourceAttribute,

+  IN EFI_PHYSICAL_ADDRESS         PhysicalStart,

+  IN UINT64                       NumberOfBytes

+  )

+{

+  EFI_HOB_RESOURCE_DESCRIPTOR  *Hob;

+

+  Hob = CreateHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, sizeof (EFI_HOB_RESOURCE_DESCRIPTOR));

+  ASSERT(Hob != NULL);

+

+  Hob->ResourceType      = ResourceType;

+  Hob->ResourceAttribute = ResourceAttribute;

+  Hob->PhysicalStart     = PhysicalStart;

+  Hob->ResourceLength    = NumberOfBytes;

+}

+

+/**

+

+

+**/

+VOID

+CreateHobList (

+  IN VOID   *MemoryBegin,

+  IN UINTN  MemoryLength,

+  IN VOID   *HobBase,

+  IN VOID   *StackBase

+  )

+{

+  EFI_HOB_HANDOFF_INFO_TABLE  *Hob;

+  EFI_RESOURCE_ATTRIBUTE_TYPE Attributes;

+

+  Hob = HobConstructor (MemoryBegin,MemoryLength,HobBase,StackBase);

+  SetHobList (Hob);

+

+  BuildCpuHob (PcdGet8 (PcdPrePiCpuMemorySize), PcdGet8 (PcdPrePiCpuIoSize));

+  

+  Attributes =(

+    EFI_RESOURCE_ATTRIBUTE_PRESENT |

+    EFI_RESOURCE_ATTRIBUTE_INITIALIZED |

+    EFI_RESOURCE_ATTRIBUTE_TESTED |

+    EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE |

+    EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE |

+    EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE |

+    EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE

+  );

+

+  BuildResourceDescriptorHob (EFI_RESOURCE_SYSTEM_MEMORY, Attributes, (UINTN)MemoryBegin, MemoryLength);

+

+  BuildStackHob ((EFI_PHYSICAL_ADDRESS)(UINTN)StackBase, ((UINTN)MemoryBegin + MemoryLength) - (UINTN)StackBase);

+

+  if (FeaturePcdGet (PcdPrePiProduceMemoryTypeInformationHob)) {

+    // Optional feature that helps prevent EFI memory map fragmentation. 

+    BuildMemoryTypeInformationHob ();

+  }

+}  

+  

+

+VOID

+EFIAPI

+BuildFvHobs (  

+  IN EFI_PHYSICAL_ADDRESS         PhysicalStart,

+  IN UINT64                       NumberOfBytes,

+  IN EFI_RESOURCE_ATTRIBUTE_TYPE  *ResourceAttribute

+  ) 

+{

+

+  EFI_RESOURCE_ATTRIBUTE_TYPE Resource;

+  

+  BuildFvHob (PhysicalStart, NumberOfBytes);

+  

+  if (ResourceAttribute == NULL) {

+    Resource = (EFI_RESOURCE_ATTRIBUTE_PRESENT    |

+                EFI_RESOURCE_ATTRIBUTE_INITIALIZED |

+                EFI_RESOURCE_ATTRIBUTE_TESTED |

+                EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE);

+  } else {

+    Resource = *ResourceAttribute;

+  }

+  

+  BuildResourceDescriptorHob (EFI_RESOURCE_FIRMWARE_DEVICE, Resource, PhysicalStart, NumberOfBytes);

+}

+

+/**

+  Returns the next instance of a HOB type from the starting HOB.

+

+  This function searches the first instance of a HOB type from the starting HOB pointer. 

+  If there does not exist such HOB type from the starting HOB pointer, it will return NULL.

+  In contrast with macro GET_NEXT_HOB(), this function does not skip the starting HOB pointer

+  unconditionally: it returns HobStart back if HobStart itself meets the requirement;

+  caller is required to use GET_NEXT_HOB() if it wishes to skip current HobStart.

+  If HobStart is NULL, then ASSERT().

+

+  @param  Type          The HOB type to return.

+  @param  HobStart      The starting HOB pointer to search from.

+

+  @return The next instance of a HOB type from the starting HOB.

+

+**/

+VOID *

+EFIAPI

+GetNextHob (

+  IN UINT16                 Type,

+  IN CONST VOID             *HobStart

+  )

+{

+  EFI_PEI_HOB_POINTERS  Hob;

+

+  ASSERT (HobStart != NULL);

+   

+  Hob.Raw = (UINT8 *) HobStart;

+  //

+  // Parse the HOB list until end of list or matching type is found.

+  //

+  while (!END_OF_HOB_LIST (Hob)) {

+    if (Hob.Header->HobType == Type) {

+      return Hob.Raw;

+    }

+    Hob.Raw = GET_NEXT_HOB (Hob);

+  }

+  return NULL;

+}

+  

+  

+

+/**

+  Returns the first instance of a HOB type among the whole HOB list.

+

+  This function searches the first instance of a HOB type among the whole HOB list. 

+  If there does not exist such HOB type in the HOB list, it will return NULL. 

+

+  @param  Type          The HOB type to return.

+

+  @return The next instance of a HOB type from the starting HOB.

+

+**/

+VOID *

+EFIAPI

+GetFirstHob (

+  IN UINT16                 Type

+  )

+{

+  VOID      *HobList;

+

+  HobList = GetHobList ();

+  return GetNextHob (Type, HobList);

+}

+

+

+/**

+  This function searches the first instance of a HOB from the starting HOB pointer. 

+  Such HOB should satisfy two conditions: 

+  its HOB type is EFI_HOB_TYPE_GUID_EXTENSION and its GUID Name equals to the input Guid. 

+  If there does not exist such HOB from the starting HOB pointer, it will return NULL. 

+  Caller is required to apply GET_GUID_HOB_DATA () and GET_GUID_HOB_DATA_SIZE ()

+  to extract the data section and its size info respectively.

+  In contrast with macro GET_NEXT_HOB(), this function does not skip the starting HOB pointer

+  unconditionally: it returns HobStart back if HobStart itself meets the requirement;

+  caller is required to use GET_NEXT_HOB() if it wishes to skip current HobStart.

+  If Guid is NULL, then ASSERT().

+  If HobStart is NULL, then ASSERT().

+

+  @param  Guid          The GUID to match with in the HOB list.

+  @param  HobStart      A pointer to a Guid.

+

+  @return The next instance of the matched GUID HOB from the starting HOB.

+

+**/

+VOID *

+EFIAPI

+GetNextGuidHob (

+  IN CONST EFI_GUID         *Guid,

+  IN CONST VOID             *HobStart

+  ){

+  EFI_PEI_HOB_POINTERS  GuidHob;

+

+  GuidHob.Raw = (UINT8 *) HobStart;

+  while ((GuidHob.Raw = GetNextHob (EFI_HOB_TYPE_GUID_EXTENSION, GuidHob.Raw)) != NULL) {

+    if (CompareGuid (Guid, &GuidHob.Guid->Name)) {

+      break;

+    }

+    GuidHob.Raw = GET_NEXT_HOB (GuidHob);

+  }

+  return GuidHob.Raw;

+}

+

+

+/**

+  This function searches the first instance of a HOB among the whole HOB list. 

+  Such HOB should satisfy two conditions:

+  its HOB type is EFI_HOB_TYPE_GUID_EXTENSION and its GUID Name equals to the input Guid.

+  If there does not exist such HOB from the starting HOB pointer, it will return NULL.

+  Caller is required to apply GET_GUID_HOB_DATA () and GET_GUID_HOB_DATA_SIZE ()

+  to extract the data section and its size info respectively.

+  If Guid is NULL, then ASSERT().

+

+  @param  Guid          The GUID to match with in the HOB list.

+

+  @return The first instance of the matched GUID HOB among the whole HOB list.

+

+**/

+VOID *

+EFIAPI

+GetFirstGuidHob (

+  IN CONST EFI_GUID         *Guid

+  )

+{

+  VOID      *HobList;

+

+  HobList = GetHobList ();

+  return GetNextGuidHob (Guid, HobList);

+}

+

+

+/**

+  Get the Boot Mode from the HOB list.

+

+  This function returns the system boot mode information from the 

+  PHIT HOB in HOB list.

+

+  @param  VOID

+

+  @return The Boot Mode.

+

+**/

+EFI_BOOT_MODE

+EFIAPI

+GetBootMode (

+  VOID

+  )

+{

+  EFI_PEI_HOB_POINTERS  Hob;

+

+  Hob.Raw = GetHobList ();

+  return Hob.HandoffInformationTable->BootMode;

+}

+

+

+/**

+  Get the Boot Mode from the HOB list.

+

+  This function returns the system boot mode information from the 

+  PHIT HOB in HOB list.

+

+  @param  VOID

+

+  @return The Boot Mode.

+

+**/

+EFI_STATUS

+EFIAPI

+SetBootMode (

+  IN  EFI_BOOT_MODE   BootMode

+  )

+{

+  EFI_PEI_HOB_POINTERS  Hob;

+

+  Hob.Raw = GetHobList ();

+  Hob.HandoffInformationTable->BootMode = BootMode;

+  return BootMode;

+}

+

+/**

+  Builds a HOB for a loaded PE32 module.

+

+  This function builds a HOB for a loaded PE32 module.

+  It can only be invoked during PEI phase;

+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.

+  If ModuleName is NULL, then ASSERT().

+  If there is no additional space for HOB creation, then ASSERT().

+

+  @param  ModuleName              The GUID File Name of the module.

+  @param  MemoryAllocationModule  The 64 bit physical address of the module.

+  @param  ModuleLength            The length of the module in bytes.

+  @param  EntryPoint              The 64 bit physical address of the module entry point.

+

+**/

+VOID

+EFIAPI

+BuildModuleHob (

+  IN CONST EFI_GUID         *ModuleName,

+  IN EFI_PHYSICAL_ADDRESS   MemoryAllocationModule,

+  IN UINT64                 ModuleLength,

+  IN EFI_PHYSICAL_ADDRESS   EntryPoint

+  )

+{

+  EFI_HOB_MEMORY_ALLOCATION_MODULE  *Hob;

+

+  ASSERT (((MemoryAllocationModule & (EFI_PAGE_SIZE - 1)) == 0) &&

+          ((ModuleLength & (EFI_PAGE_SIZE - 1)) == 0));

+

+  Hob = CreateHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, sizeof (EFI_HOB_MEMORY_ALLOCATION_MODULE));

+

+  CopyGuid (&(Hob->MemoryAllocationHeader.Name), &gEfiHobMemoryAllocModuleGuid);

+  Hob->MemoryAllocationHeader.MemoryBaseAddress = MemoryAllocationModule;

+  Hob->MemoryAllocationHeader.MemoryLength      = ModuleLength;

+  Hob->MemoryAllocationHeader.MemoryType        = EfiBootServicesCode;

+

+  //

+  // Zero the reserved space to match HOB spec

+  //

+  ZeroMem (Hob->MemoryAllocationHeader.Reserved, sizeof (Hob->MemoryAllocationHeader.Reserved));

+  

+  CopyGuid (&Hob->ModuleName, ModuleName);

+  Hob->EntryPoint = EntryPoint;

+}

+

+/**

+  Builds a GUID HOB with a certain data length.

+

+  This function builds a customized HOB tagged with a GUID for identification 

+  and returns the start address of GUID HOB data so that caller can fill the customized data. 

+  The HOB Header and Name field is already stripped.

+  It can only be invoked during PEI phase;

+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.

+  If Guid is NULL, then ASSERT().

+  If there is no additional space for HOB creation, then ASSERT().

+  If DataLength >= (0x10000 - sizeof (EFI_HOB_GUID_TYPE)), then ASSERT().

+

+  @param  Guid          The GUID to tag the customized HOB.

+  @param  DataLength    The size of the data payload for the GUID HOB.

+

+  @return The start address of GUID HOB data.

+

+**/

+VOID *

+EFIAPI

+BuildGuidHob (

+  IN CONST EFI_GUID              *Guid,

+  IN UINTN                       DataLength

+  )

+{

+  EFI_HOB_GUID_TYPE *Hob;

+

+  //

+  // Make sure that data length is not too long.

+  //

+  ASSERT (DataLength <= (0xffff - sizeof (EFI_HOB_GUID_TYPE)));

+

+  Hob = CreateHob (EFI_HOB_TYPE_GUID_EXTENSION, (UINT16) (sizeof (EFI_HOB_GUID_TYPE) + DataLength));

+  CopyGuid (&Hob->Name, Guid);

+  return Hob + 1;

+}

+

+

+/**

+  Copies a data buffer to a newly-built HOB.

+

+  This function builds a customized HOB tagged with a GUID for identification,

+  copies the input data to the HOB data field and returns the start address of the GUID HOB data.

+  The HOB Header and Name field is already stripped.

+  It can only be invoked during PEI phase;

+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.

+  If Guid is NULL, then ASSERT().

+  If Data is NULL and DataLength > 0, then ASSERT().

+  If there is no additional space for HOB creation, then ASSERT().

+  If DataLength >= (0x10000 - sizeof (EFI_HOB_GUID_TYPE)), then ASSERT().

+

+  @param  Guid          The GUID to tag the customized HOB.

+  @param  Data          The data to be copied into the data field of the GUID HOB.

+  @param  DataLength    The size of the data payload for the GUID HOB.

+

+  @return The start address of GUID HOB data.

+

+**/

+VOID *

+EFIAPI

+BuildGuidDataHob (

+  IN CONST EFI_GUID              *Guid,

+  IN VOID                        *Data,

+  IN UINTN                       DataLength

+  )

+{

+  VOID  *HobData;

+

+  ASSERT (Data != NULL || DataLength == 0);

+

+  HobData = BuildGuidHob (Guid, DataLength);

+

+  return CopyMem (HobData, Data, DataLength);

+}

+

+

+/**

+  Builds a Firmware Volume HOB.

+

+  This function builds a Firmware Volume HOB.

+  It can only be invoked during PEI phase;

+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.

+  If there is no additional space for HOB creation, then ASSERT().

+

+  @param  BaseAddress   The base address of the Firmware Volume.

+  @param  Length        The size of the Firmware Volume in bytes.

+

+**/

+VOID

+EFIAPI

+BuildFvHob (

+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,

+  IN UINT64                      Length

+  )

+{

+  EFI_HOB_FIRMWARE_VOLUME  *Hob;

+

+  Hob = CreateHob (EFI_HOB_TYPE_FV, sizeof (EFI_HOB_FIRMWARE_VOLUME));

+

+  Hob->BaseAddress = BaseAddress;

+  Hob->Length      = Length;

+}

+

+

+/**

+  Builds a EFI_HOB_TYPE_FV2 HOB.

+

+  This function builds a EFI_HOB_TYPE_FV2 HOB.

+  It can only be invoked during PEI phase;

+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.

+  If there is no additional space for HOB creation, then ASSERT().

+

+  @param  BaseAddress   The base address of the Firmware Volume.

+  @param  Length        The size of the Firmware Volume in bytes.

+  @param  FvName       The name of the Firmware Volume.

+  @param  FileName      The name of the file.

+  

+**/

+VOID

+EFIAPI

+BuildFv2Hob (

+  IN          EFI_PHYSICAL_ADDRESS        BaseAddress,

+  IN          UINT64                      Length,

+  IN CONST    EFI_GUID                    *FvName,

+  IN CONST    EFI_GUID                    *FileName

+  )

+{

+  EFI_HOB_FIRMWARE_VOLUME2  *Hob;

+

+  Hob = CreateHob (EFI_HOB_TYPE_FV2, sizeof (EFI_HOB_FIRMWARE_VOLUME2));

+

+  Hob->BaseAddress = BaseAddress;

+  Hob->Length      = Length;

+  CopyGuid (&Hob->FvName, FvName);

+  CopyGuid (&Hob->FileName, FileName);

+}

+

+

+

+/**

+  Builds a Capsule Volume HOB.

+

+  This function builds a Capsule Volume HOB.

+  It can only be invoked during PEI phase;

+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.

+  If there is no additional space for HOB creation, then ASSERT().

+

+  @param  BaseAddress   The base address of the Capsule Volume.

+  @param  Length        The size of the Capsule Volume in bytes.

+

+**/

+VOID

+EFIAPI

+BuildCvHob (

+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,

+  IN UINT64                      Length

+  )

+{

+  ASSERT (FALSE);

+}

+

+

+/**

+  Builds a HOB for the CPU.

+

+  This function builds a HOB for the CPU.

+  It can only be invoked during PEI phase;

+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.

+  If there is no additional space for HOB creation, then ASSERT().

+

+  @param  SizeOfMemorySpace   The maximum physical memory addressability of the processor.

+  @param  SizeOfIoSpace       The maximum physical I/O addressability of the processor.

+

+**/

+VOID

+EFIAPI

+BuildCpuHob (

+  IN UINT8                       SizeOfMemorySpace,

+  IN UINT8                       SizeOfIoSpace

+  )

+{

+  EFI_HOB_CPU  *Hob;

+

+  Hob = CreateHob (EFI_HOB_TYPE_CPU, sizeof (EFI_HOB_CPU));

+

+  Hob->SizeOfMemorySpace = SizeOfMemorySpace;

+  Hob->SizeOfIoSpace     = SizeOfIoSpace;

+

+  //

+  // Zero the reserved space to match HOB spec

+  //

+  ZeroMem (Hob->Reserved, sizeof (Hob->Reserved)); 

+}

+

+

+/**

+  Builds a HOB for the Stack.

+

+  This function builds a HOB for the stack.

+  It can only be invoked during PEI phase;

+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.

+  If there is no additional space for HOB creation, then ASSERT().

+

+  @param  BaseAddress   The 64 bit physical address of the Stack.

+  @param  Length        The length of the stack in bytes.

+

+**/

+VOID

+EFIAPI

+BuildStackHob (

+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,

+  IN UINT64                      Length

+  )

+{

+  EFI_HOB_MEMORY_ALLOCATION_STACK  *Hob;

+

+  ASSERT (((BaseAddress & (EFI_PAGE_SIZE - 1)) == 0) &&

+          ((Length & (EFI_PAGE_SIZE - 1)) == 0));

+

+  Hob = CreateHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, sizeof (EFI_HOB_MEMORY_ALLOCATION_STACK));

+

+  CopyGuid (&(Hob->AllocDescriptor.Name), &gEfiHobMemoryAllocStackGuid);

+  Hob->AllocDescriptor.MemoryBaseAddress = BaseAddress;

+  Hob->AllocDescriptor.MemoryLength      = Length;

+  Hob->AllocDescriptor.MemoryType        = EfiBootServicesData;

+

+  //

+  // Zero the reserved space to match HOB spec

+  //

+  ZeroMem (Hob->AllocDescriptor.Reserved, sizeof (Hob->AllocDescriptor.Reserved));

+}

+

+

+/**

+  Update the Stack Hob if the stack has been moved

+

+  @param  BaseAddress   The 64 bit physical address of the Stack.

+  @param  Length        The length of the stack in bytes.

+

+**/

+VOID

+UpdateStackHob (

+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,

+  IN UINT64                      Length

+  )

+{

+  EFI_PEI_HOB_POINTERS           Hob;

+

+  Hob.Raw = GetHobList ();

+  while ((Hob.Raw = GetNextHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, Hob.Raw)) != NULL) {

+    if (CompareGuid (&gEfiHobMemoryAllocStackGuid, &(Hob.MemoryAllocationStack->AllocDescriptor.Name))) {

+      //

+      // Build a new memory allocation HOB with old stack info with EfiConventionalMemory type

+      // to be reclaimed by DXE core.

+      //

+      BuildMemoryAllocationHob (

+        Hob.MemoryAllocationStack->AllocDescriptor.MemoryBaseAddress,

+        Hob.MemoryAllocationStack->AllocDescriptor.MemoryLength,

+        EfiConventionalMemory

+        );

+      //

+      // Update the BSP Stack Hob to reflect the new stack info.

+      //

+      Hob.MemoryAllocationStack->AllocDescriptor.MemoryBaseAddress = BaseAddress;

+      Hob.MemoryAllocationStack->AllocDescriptor.MemoryLength = Length;

+      break;

+    }

+    Hob.Raw = GET_NEXT_HOB (Hob);

+  }

+}

+

+

+

+/**

+  Builds a HOB for the memory allocation.

+

+  This function builds a HOB for the memory allocation.

+  It can only be invoked during PEI phase;

+  for DXE phase, it will ASSERT() since PEI HOB is read-only for DXE phase.

+  If there is no additional space for HOB creation, then ASSERT().

+

+  @param  BaseAddress   The 64 bit physical address of the memory.

+  @param  Length        The length of the memory allocation in bytes.

+  @param  MemoryType    Type of memory allocated by this HOB.

+

+**/

+VOID

+EFIAPI

+BuildMemoryAllocationHob (

+  IN EFI_PHYSICAL_ADDRESS        BaseAddress,

+  IN UINT64                      Length,

+  IN EFI_MEMORY_TYPE             MemoryType

+  )

+{

+  EFI_HOB_MEMORY_ALLOCATION  *Hob;

+

+  ASSERT (((BaseAddress & (EFI_PAGE_SIZE - 1)) == 0) &&

+          ((Length & (EFI_PAGE_SIZE - 1)) == 0));

+  

+  Hob = CreateHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, sizeof (EFI_HOB_MEMORY_ALLOCATION));

+  

+  ZeroMem (&(Hob->AllocDescriptor.Name), sizeof (EFI_GUID));

+  Hob->AllocDescriptor.MemoryBaseAddress = BaseAddress;

+  Hob->AllocDescriptor.MemoryLength      = Length;

+  Hob->AllocDescriptor.MemoryType        = MemoryType;

+  //

+  // Zero the reserved space to match HOB spec

+  //

+  ZeroMem (Hob->AllocDescriptor.Reserved, sizeof (Hob->AllocDescriptor.Reserved));

+}

+

+

+

+VOID

+EFIAPI

+BuildExtractSectionHob (

+  IN  EFI_GUID                                  *Guid,

+  IN  EXTRACT_GUIDED_SECTION_GET_INFO_HANDLER   SectionGetInfo,

+  IN  EXTRACT_GUIDED_SECTION_DECODE_HANDLER     SectionExtraction

+  )

+{

+  EXTRACT_SECTION_DATA Data;

+  

+  Data.SectionGetInfo    = SectionGetInfo;

+  Data.SectionExtraction = SectionExtraction;

+  BuildGuidDataHob (Guid, &Data, sizeof (Data));

+}

+

+PE_COFF_LOADER_PROTOCOL gPeCoffProtocol = {

+  PeCoffLoaderGetImageInfo,

+  PeCoffLoaderLoadImage,

+  PeCoffLoaderRelocateImage,

+  PeCoffLoaderImageReadFromMemory,

+  PeCoffLoaderRelocateImageForRuntime,

+  PeCoffLoaderUnloadImage

+};

+

+

+

+VOID

+EFIAPI

+BuildPeCoffLoaderHob (

+  VOID

+  )

+{

+  VOID  *Ptr;      

+  

+  Ptr = &gPeCoffProtocol;

+  BuildGuidDataHob (&gPeCoffLoaderProtocolGuid, &Ptr, sizeof (VOID *));  

+}

+

+// May want to put this into a library so you only need the PCD setings if you are using the feature?

+VOID

+BuildMemoryTypeInformationHob (

+  VOID

+  )

+{

+  EFI_MEMORY_TYPE_INFORMATION   Info[10];

+

+  Info[0].Type          = EfiACPIReclaimMemory;

+  Info[0].NumberOfPages = PcdGet32 (PcdMemoryTypeEfiACPIReclaimMemory);

+  Info[1].Type          = EfiACPIMemoryNVS;

+  Info[1].NumberOfPages = PcdGet32 (PcdMemoryTypeEfiACPIMemoryNVS);

+  Info[2].Type          = EfiReservedMemoryType;

+  Info[2].NumberOfPages = PcdGet32 (PcdMemoryTypeEfiReservedMemoryType);

+  Info[3].Type          = EfiRuntimeServicesData;

+  Info[3].NumberOfPages = PcdGet32 (PcdMemoryTypeEfiRuntimeServicesData);

+  Info[4].Type          = EfiRuntimeServicesCode;

+  Info[4].NumberOfPages = PcdGet32 (PcdMemoryTypeEfiRuntimeServicesCode);

+  Info[5].Type          = EfiBootServicesCode;

+  Info[5].NumberOfPages = PcdGet32 (PcdMemoryTypeEfiBootServicesCode);

+  Info[6].Type          = EfiBootServicesData;

+  Info[6].NumberOfPages = PcdGet32 (PcdMemoryTypeEfiBootServicesData);

+  Info[7].Type          = EfiLoaderCode;

+  Info[7].NumberOfPages = PcdGet32 (PcdMemoryTypeEfiLoaderCode);

+  Info[8].Type          = EfiLoaderData;

+  Info[8].NumberOfPages = PcdGet32 (PcdMemoryTypeEfiLoaderData);

+

+  // Terminator for the list

+  Info[9].Type          = EfiMaxMemoryType;

+  Info[9].NumberOfPages = 0;

+

+

+  BuildGuidDataHob (&gEfiMemoryTypeInformationGuid, &Info, sizeof (Info));

+}

+

diff --git a/EmbeddedPkg/Library/PrePiHobListPointerLib/PrePiHobListPointer.c b/EmbeddedPkg/Library/PrePiHobListPointerLib/PrePiHobListPointer.c
index 9f9e9c7d..bf4f80f4 100644
--- a/EmbeddedPkg/Library/PrePiHobListPointerLib/PrePiHobListPointer.c
+++ b/EmbeddedPkg/Library/PrePiHobListPointerLib/PrePiHobListPointer.c
@@ -17,11 +17,11 @@
 #include <Library/DebugLib.h>

 #include <Library/PcdLib.h>

 

-//
-// Have to use build system to set the original value in case we are running
-// from FLASH and globals don't work. So if you do a GetHobList() and gHobList
-// and gHobList is NULL the PCD default values are used.
-//
+//

+// Have to use build system to set the original value in case we are running

+// from FLASH and globals don't work. So if you do a GetHobList() and gHobList

+// and gHobList is NULL the PCD default values are used.

+//

 VOID *gHobList = NULL;

 

 

diff --git a/EmbeddedPkg/Library/PrePiHobListPointerLib/PrePiHobListPointerLib.inf b/EmbeddedPkg/Library/PrePiHobListPointerLib/PrePiHobListPointerLib.inf
index 1ba97678..fea8f436 100644
--- a/EmbeddedPkg/Library/PrePiHobListPointerLib/PrePiHobListPointerLib.inf
+++ b/EmbeddedPkg/Library/PrePiHobListPointerLib/PrePiHobListPointerLib.inf
@@ -36,4 +36,4 @@
   

 [FixedPcd.common]

   gEmbeddedTokenSpaceGuid.PcdPrePiHobBase

-  
\ No newline at end of file
+  
\ No newline at end of file
diff --git a/EmbeddedPkg/Library/PrePiLib/FwVol.c b/EmbeddedPkg/Library/PrePiLib/FwVol.c
index 75d28a72..9e4cdd00 100644
--- a/EmbeddedPkg/Library/PrePiLib/FwVol.c
+++ b/EmbeddedPkg/Library/PrePiLib/FwVol.c
@@ -1,842 +1,842 @@
-/** @file
-  Implementation of the 6 PEI Ffs (FV) APIs in library form.
-  
-  This code only knows about a FV if it has a EFI_HOB_TYPE_FV entry in the HOB list
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include <PrePi.h>
-#include <Library/ExtractGuidedSectionLib.h>
-
-
-#define GET_OCCUPIED_SIZE(ActualSize, Alignment) \
-  (ActualSize) + (((Alignment) - ((ActualSize) & ((Alignment) - 1))) & ((Alignment) - 1))
-
-
-/**
-  Returns the highest bit set of the State field
-  
-  @param ErasePolarity   Erase Polarity  as defined by EFI_FVB2_ERASE_POLARITY
-                         in the Attributes field.
-  @param FfsHeader       Pointer to FFS File Header
-                      
-
-  @retval the highest bit in the State field
-
-**/
-STATIC
-EFI_FFS_FILE_STATE
-GetFileState(
-  IN UINT8                ErasePolarity,
-  IN EFI_FFS_FILE_HEADER  *FfsHeader
-  )
-{
-  EFI_FFS_FILE_STATE  FileState;
-  EFI_FFS_FILE_STATE  HighestBit;
-
-  FileState = FfsHeader->State;
-
-  if (ErasePolarity != 0) {
-    FileState = (EFI_FFS_FILE_STATE)~FileState;
-  }
-
-  HighestBit = 0x80;
-  while (HighestBit != 0 && (HighestBit & FileState) == 0) {
-    HighestBit >>= 1;
-  }
-
-  return HighestBit;
-} 
-
-
-/**
-  Calculates the checksum of the header of a file.
-  The header is a zero byte checksum, so zero means header is good
-  
-  @param FfsHeader       Pointer to FFS File Header
-                      
-  @retval Checksum of the header
-
-**/
-STATIC
-UINT8
-CalculateHeaderChecksum (
-  IN EFI_FFS_FILE_HEADER  *FileHeader
-  )
-{
-  UINT8   *Ptr;
-  UINTN   Index;
-  UINT8   Sum;
-  
-  Sum = 0;
-  Ptr = (UINT8 *)FileHeader;
-
-  for (Index = 0; Index < sizeof(EFI_FFS_FILE_HEADER) - 3; Index += 4) {
-    Sum = (UINT8)(Sum + Ptr[Index]);
-    Sum = (UINT8)(Sum + Ptr[Index+1]);
-    Sum = (UINT8)(Sum + Ptr[Index+2]);
-    Sum = (UINT8)(Sum + Ptr[Index+3]);
-  }
-
-  for (; Index < sizeof(EFI_FFS_FILE_HEADER); Index++) {
-    Sum = (UINT8)(Sum + Ptr[Index]);
-  }
-  
-  //
-  // State field (since this indicates the different state of file). 
-  //
-  Sum = (UINT8)(Sum - FileHeader->State);
-  //
-  // Checksum field of the file is not part of the header checksum.
-  //
-  Sum = (UINT8)(Sum - FileHeader->IntegrityCheck.Checksum.File);
-
-  return Sum;
-}
-
-
-/**
-  Given a FileHandle return the VolumeHandle
-  
-  @param FileHandle   File handle to look up
-  @param VolumeHandle Match for FileHandle
-                      
-  @retval TRUE  VolumeHandle is valid
-
-**/
-STATIC
-BOOLEAN
-EFIAPI
-FileHandleToVolume (
-  IN   EFI_PEI_FILE_HANDLE     FileHandle,
-  OUT  EFI_PEI_FV_HANDLE       *VolumeHandle
-  )
-{
-  EFI_FIRMWARE_VOLUME_HEADER  *FwVolHeader;
-  EFI_PEI_HOB_POINTERS        Hob;
-
-  Hob.Raw = GetHobList ();
-  if (Hob.Raw == NULL) {
-    return FALSE;
-  }
-  
-  do {
-    Hob.Raw = GetNextHob (EFI_HOB_TYPE_FV, Hob.Raw);
-    if (Hob.Raw != NULL) {
-      FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *)(UINTN)(Hob.FirmwareVolume->BaseAddress);
-      if (((UINT64) (UINTN) FileHandle > (UINT64) (UINTN) FwVolHeader ) &&   \
-          ((UINT64) (UINTN) FileHandle <= ((UINT64) (UINTN) FwVolHeader + FwVolHeader->FvLength - 1))) {
-        *VolumeHandle = (EFI_PEI_FV_HANDLE)FwVolHeader;
-        return TRUE;
-      }
-
-      Hob.Raw = GetNextHob (EFI_HOB_TYPE_FV, GET_NEXT_HOB (Hob));
-    }
-  } while (Hob.Raw != NULL);
-    
-  return FALSE;
-}
-
-
-
-/**
-  Given the input file pointer, search for the next matching file in the
-  FFS volume as defined by SearchType. The search starts from FileHeader inside
-  the Firmware Volume defined by FwVolHeader.
-  
-  @param FileHandle   File handle to look up
-  @param VolumeHandle Match for FileHandle
-                      
-
-**/
-EFI_STATUS
-FindFileEx (
-  IN  CONST EFI_PEI_FV_HANDLE        FvHandle,
-  IN  CONST EFI_GUID                 *FileName,   OPTIONAL
-  IN        EFI_FV_FILETYPE          SearchType,
-  IN OUT    EFI_PEI_FILE_HANDLE      *FileHandle
-  )
-{
-  EFI_FIRMWARE_VOLUME_HEADER           *FwVolHeader;
-  EFI_FFS_FILE_HEADER                   **FileHeader;
-  EFI_FFS_FILE_HEADER                   *FfsFileHeader;
-  EFI_FIRMWARE_VOLUME_EXT_HEADER        *FwVolExHeaderInfo;
-  UINT32                                FileLength;
-  UINT32                                FileOccupiedSize;
-  UINT32                                FileOffset;
-  UINT64                                FvLength;
-  UINT8                                 ErasePolarity;
-  UINT8                                 FileState;
-
-  FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *)FvHandle;
-  FileHeader  = (EFI_FFS_FILE_HEADER **)FileHandle;
-
-  FvLength = FwVolHeader->FvLength;
-  if (FwVolHeader->Attributes & EFI_FVB2_ERASE_POLARITY) {
-    ErasePolarity = 1;
-  } else {
-    ErasePolarity = 0;
-  }
-
-  //
-  // If FileHeader is not specified (NULL) or FileName is not NULL,
-  // start with the first file in the firmware volume.  Otherwise,
-  // start from the FileHeader.
-  //
-  if ((*FileHeader == NULL) || (FileName != NULL)) {
-    FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)FwVolHeader + FwVolHeader->HeaderLength);
-    if (FwVolHeader->ExtHeaderOffset != 0) {
-      FwVolExHeaderInfo = (EFI_FIRMWARE_VOLUME_EXT_HEADER *)(((UINT8 *)FwVolHeader) + FwVolHeader->ExtHeaderOffset);
-      FfsFileHeader = (EFI_FFS_FILE_HEADER *)(((UINT8 *)FwVolExHeaderInfo) + FwVolExHeaderInfo->ExtHeaderSize);
-    }
-  } else {
-    //
-    // Length is 24 bits wide so mask upper 8 bits
-    // FileLength is adjusted to FileOccupiedSize as it is 8 byte aligned.
-    //
-    FileLength = *(UINT32 *)(*FileHeader)->Size & 0x00FFFFFF;
-    FileOccupiedSize = GET_OCCUPIED_SIZE (FileLength, 8);
-    FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)*FileHeader + FileOccupiedSize);
-  }
-  
-  FileOffset = (UINT32) ((UINT8 *)FfsFileHeader - (UINT8 *)FwVolHeader);
-  ASSERT (FileOffset <= 0xFFFFFFFF);
-
-  while (FileOffset < (FvLength - sizeof (EFI_FFS_FILE_HEADER))) {
-    //
-    // Get FileState which is the highest bit of the State 
-    //
-    FileState = GetFileState (ErasePolarity, FfsFileHeader);
-
-    switch (FileState) {
-
-    case EFI_FILE_HEADER_INVALID:
-      FileOffset += sizeof(EFI_FFS_FILE_HEADER);
-      FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)FfsFileHeader + sizeof(EFI_FFS_FILE_HEADER));
-      break;
-        
-    case EFI_FILE_DATA_VALID:
-    case EFI_FILE_MARKED_FOR_UPDATE:
-      if (CalculateHeaderChecksum (FfsFileHeader) != 0) {
-        ASSERT (FALSE);
-        *FileHeader = NULL;
-        return EFI_NOT_FOUND;
-      }
-
-      FileLength = *(UINT32 *)(FfsFileHeader->Size) & 0x00FFFFFF;
-      FileOccupiedSize = GET_OCCUPIED_SIZE(FileLength, 8);
-
-      if (FileName != NULL) {
-        if (CompareGuid (&FfsFileHeader->Name, (EFI_GUID*)FileName)) {
-          *FileHeader = FfsFileHeader;
-          return EFI_SUCCESS;
-        }
-      } else if (((SearchType == FfsFileHeader->Type) || (SearchType == EFI_FV_FILETYPE_ALL)) && 
-                 (FfsFileHeader->Type != EFI_FV_FILETYPE_FFS_PAD)) { 
-        *FileHeader = FfsFileHeader;
-        return EFI_SUCCESS;
-      }
-
-      FileOffset += FileOccupiedSize; 
-      FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)FfsFileHeader + FileOccupiedSize);
-      break;
-    
-    case EFI_FILE_DELETED:
-      FileLength = *(UINT32 *)(FfsFileHeader->Size) & 0x00FFFFFF;
-      FileOccupiedSize = GET_OCCUPIED_SIZE(FileLength, 8);
-      FileOffset += FileOccupiedSize;
-      FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)FfsFileHeader + FileOccupiedSize);
-      break;
-
-    default:
-      *FileHeader = NULL;
-      return EFI_NOT_FOUND;
-    } 
-  }
-
-  
-  *FileHeader = NULL;
-  return EFI_NOT_FOUND;  
-}
-
-
-/**
-  Go through the file to search SectionType section,
-  when meeting an encapsuled section. 
-  
-  @param  SectionType  - Filter to find only section of this type.
-  @param  Section      - From where to search.
-  @param  SectionSize  - The file size to search.
-  @param  OutputBuffer - Pointer to the section to search.
-                      
-  @retval EFI_SUCCESS
-**/
-EFI_STATUS
-FfsProcessSection (
-  IN EFI_SECTION_TYPE           SectionType,
-  IN EFI_COMMON_SECTION_HEADER  *Section,
-  IN UINTN                      SectionSize,
-  OUT VOID                      **OutputBuffer
-  )
-{
-  EFI_STATUS                              Status;
-  UINT32                                  SectionLength;
-  UINT32                                  ParsedLength;
-  EFI_COMPRESSION_SECTION                 *CompressionSection;
-  UINTN                                   DstBufferSize;
-  VOID                                    *ScratchBuffer;
-  UINT32                                  ScratchBufferSize;
-  VOID                                    *DstBuffer;
-  UINT16                                  SectionAttribute;
-  UINT32                                  AuthenticationStatus;
-
-
-  *OutputBuffer = NULL;
-  ParsedLength  = 0;
-  Status        = EFI_NOT_FOUND;
-  while (ParsedLength < SectionSize) {
-    if (Section->Type == SectionType) {
-      *OutputBuffer = (VOID *)(Section + 1);
-
-      return EFI_SUCCESS;
-    } else if ((Section->Type == EFI_SECTION_COMPRESSION) || (Section->Type == EFI_SECTION_GUID_DEFINED)) {
-    
-      if (Section->Type == EFI_SECTION_COMPRESSION) {
-        CompressionSection  = (EFI_COMPRESSION_SECTION *) Section;
-        SectionLength       = *(UINT32 *)Section->Size & 0x00FFFFFF;
-        
-        if (CompressionSection->CompressionType != EFI_STANDARD_COMPRESSION) {
-          return EFI_UNSUPPORTED;
-        }
-
-        Status = UefiDecompressGetInfo (
-                   (UINT8 *) ((EFI_COMPRESSION_SECTION *) Section + 1),
-                   (UINT32) SectionLength - sizeof (EFI_COMPRESSION_SECTION),
-                   (UINT32 *) &DstBufferSize,
-                   &ScratchBufferSize
-                   );
-      } else if (Section->Type == EFI_SECTION_GUID_DEFINED) {
-        Status = ExtractGuidedSectionGetInfo (
-                   Section,
-                   (UINT32 *) &DstBufferSize,
-                   &ScratchBufferSize,
-                   &SectionAttribute
-                   );
-      }
-      
-      if (EFI_ERROR (Status)) {
-        //
-        // GetInfo failed
-        //
-        DEBUG ((EFI_D_ERROR, "Decompress GetInfo Failed - %r\n", Status));
-        return EFI_NOT_FOUND;
-      }
-      //
-      // Allocate scratch buffer
-      //
-      ScratchBuffer = (VOID *)(UINTN)AllocatePages (EFI_SIZE_TO_PAGES (ScratchBufferSize));
-      if (ScratchBuffer == NULL) {
-        return EFI_OUT_OF_RESOURCES;
-      }
-      //
-      // Allocate destination buffer, extra one page for adjustment 
-      //
-      DstBuffer = (VOID *)(UINTN)AllocatePages (EFI_SIZE_TO_PAGES (DstBufferSize) + 1);
-      if (DstBuffer == NULL) {
-        return EFI_OUT_OF_RESOURCES;
-      }
-      //
-      // DstBuffer still is one section. Adjust DstBuffer offset, skip EFI section header
-      // to make section data at page alignment.
-      //
-      DstBuffer = (UINT8 *)DstBuffer + EFI_PAGE_SIZE - sizeof (EFI_COMMON_SECTION_HEADER);
-      //
-      // Call decompress function
-      //
-      if (Section->Type == EFI_SECTION_COMPRESSION) {
-        Status = UefiDecompress (
-                    (CHAR8 *) ((EFI_COMPRESSION_SECTION *) Section + 1),
-                    DstBuffer,
-                    ScratchBuffer
-                    );
-      } else if (Section->Type == EFI_SECTION_GUID_DEFINED) {
-        Status = ExtractGuidedSectionDecode (
-                    Section,
-                    &DstBuffer,
-                    ScratchBuffer,
-                    &AuthenticationStatus
-                    );
-      }
-      
-      if (EFI_ERROR (Status)) {
-        //
-        // Decompress failed
-        //
-        DEBUG ((EFI_D_ERROR, "Decompress Failed - %r\n", Status));
-        return EFI_NOT_FOUND;
-      } else {
-        return FfsProcessSection (
-                SectionType, 
-                DstBuffer, 
-                DstBufferSize, 
-                OutputBuffer 
-                );
-       }        
-    }
-
-    //
-    // Size is 24 bits wide so mask upper 8 bits. 
-    // SectionLength is adjusted it is 4 byte aligned.
-    // Go to the next section
-    //
-    SectionLength = *(UINT32 *)Section->Size & 0x00FFFFFF;
-    SectionLength = GET_OCCUPIED_SIZE (SectionLength, 4);
-    ASSERT (SectionLength != 0);
-    ParsedLength += SectionLength;
-    Section = (EFI_COMMON_SECTION_HEADER *)((UINT8 *)Section + SectionLength);
-  }
-  
-  return EFI_NOT_FOUND;
-}
-
-
-
-/**
-  This service enables discovery sections of a given type within a valid FFS file.
-
-  @param  SearchType            The value of the section type to find.
-  @param  FfsFileHeader         A pointer to the file header that contains the set of sections to
-                                be searched.
-  @param  SectionData           A pointer to the discovered section, if successful.
-
-  @retval EFI_SUCCESS           The section was found.
-  @retval EFI_NOT_FOUND         The section was not found.
-
-**/
-EFI_STATUS
-EFIAPI
-FfsFindSectionData (
-  IN EFI_SECTION_TYPE           SectionType,
-  IN EFI_PEI_FILE_HANDLE        FileHandle,
-  OUT VOID                      **SectionData
-  )
-{
-  EFI_FFS_FILE_HEADER                     *FfsFileHeader;
-  UINT32                                  FileSize;
-  EFI_COMMON_SECTION_HEADER               *Section;
-
-  FfsFileHeader = (EFI_FFS_FILE_HEADER *)(FileHandle);
-
-  //
-  // Size is 24 bits wide so mask upper 8 bits. 
-  // Does not include FfsFileHeader header size
-  // FileSize is adjusted to FileOccupiedSize as it is 8 byte aligned.
-  //
-  Section = (EFI_COMMON_SECTION_HEADER *)(FfsFileHeader + 1);
-  FileSize = *(UINT32 *)(FfsFileHeader->Size) & 0x00FFFFFF;
-  FileSize -= sizeof (EFI_FFS_FILE_HEADER);
-
-  return FfsProcessSection (
-          SectionType, 
-          Section, 
-          FileSize, 
-          SectionData
-          );
-}
-
-
-
-
-
-
-/**
-  This service enables discovery of additional firmware files.
-
-  @param  SearchType            A filter to find files only of this type.
-  @param  FwVolHeader           Pointer to the firmware volume header of the volume to search.
-                                This parameter must point to a valid FFS volume.
-  @param  FileHeader            Pointer to the current file from which to begin searching.
-
-  @retval EFI_SUCCESS           The file was found.
-  @retval EFI_NOT_FOUND         The file was not found.
-  @retval EFI_NOT_FOUND         The header checksum was not zero.
-
-**/
-EFI_STATUS
-EFIAPI
-FfsFindNextFile (
-  IN UINT8                       SearchType,
-  IN EFI_PEI_FV_HANDLE           VolumeHandle,
-  IN OUT EFI_PEI_FILE_HANDLE     *FileHandle
-  )
-{
-  return FindFileEx (VolumeHandle, NULL, SearchType, FileHandle);
-}
-
-
-/**
-  This service enables discovery of additional firmware volumes.
-
-  @param  Instance              This instance of the firmware volume to find.  The value 0 is the
-                                Boot Firmware Volume (BFV).
-  @param  FwVolHeader           Pointer to the firmware volume header of the volume to return.
-
-  @retval EFI_SUCCESS           The volume was found.
-  @retval EFI_NOT_FOUND         The volume was not found.
-
-**/
-EFI_STATUS
-EFIAPI
-FfsFindNextVolume (
-  IN UINTN                          Instance,
-  IN OUT EFI_PEI_FV_HANDLE          *VolumeHandle
-  )
-{
-  EFI_PEI_HOB_POINTERS        Hob;
-  
-
-  Hob.Raw = GetHobList ();
-  if (Hob.Raw == NULL) {
-    return EFI_NOT_FOUND;
-  }
-  
-  do {
-    Hob.Raw = GetNextHob (EFI_HOB_TYPE_FV, Hob.Raw);
-    if (Hob.Raw != NULL) {
-      if (Instance-- == 0) {
-        *VolumeHandle = (EFI_PEI_FV_HANDLE)(UINTN)(Hob.FirmwareVolume->BaseAddress);
-        return EFI_SUCCESS;
-      }
-
-      Hob.Raw = GetNextHob (EFI_HOB_TYPE_FV, GET_NEXT_HOB (Hob));
-    }
-  } while (Hob.Raw != NULL);
-    
-  return EFI_NOT_FOUND;
-
-}
-
-
-/**
-  Find a file in the volume by name
-  
-  @param FileName       A pointer to the name of the file to
-                        find within the firmware volume.
-
-  @param VolumeHandle   The firmware volume to search FileHandle
-                        Upon exit, points to the found file's
-                        handle or NULL if it could not be found.
-
-  @retval EFI_SUCCESS             File was found.
-
-  @retval EFI_NOT_FOUND           File was not found.
-
-  @retval EFI_INVALID_PARAMETER   VolumeHandle or FileHandle or
-                                  FileName was NULL.
-
-**/
-EFI_STATUS
-EFIAPI 
-FfsFindFileByName (
-  IN  CONST EFI_GUID        *FileName,
-  IN  EFI_PEI_FV_HANDLE     VolumeHandle,
-  OUT EFI_PEI_FILE_HANDLE   *FileHandle
-  )
-{
-  EFI_STATUS  Status;
-  if ((VolumeHandle == NULL) || (FileName == NULL) || (FileHandle == NULL)) {
-    return EFI_INVALID_PARAMETER;
-  }
-  Status = FindFileEx (VolumeHandle, FileName, 0, FileHandle);
-  if (Status == EFI_NOT_FOUND) {
-    *FileHandle = NULL;
-  }
-  return Status;
-}
-
-
-
-
-/**
-  Get information about the file by name.
-
-  @param FileHandle   Handle of the file.
-
-  @param FileInfo     Upon exit, points to the file's
-                      information.
-
-  @retval EFI_SUCCESS             File information returned.
-  
-  @retval EFI_INVALID_PARAMETER   If FileHandle does not
-                                  represent a valid file.
-  
-  @retval EFI_INVALID_PARAMETER   If FileInfo is NULL.
-  
-**/
-EFI_STATUS
-EFIAPI 
-FfsGetFileInfo (
-  IN EFI_PEI_FILE_HANDLE  FileHandle,
-  OUT EFI_FV_FILE_INFO    *FileInfo
-  )
-{
-  UINT8                       FileState;
-  UINT8                       ErasePolarity;
-  EFI_FFS_FILE_HEADER         *FileHeader;
-  EFI_PEI_FV_HANDLE           VolumeHandle;
-
-  if ((FileHandle == NULL) || (FileInfo == NULL)) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  VolumeHandle = 0;
-  //
-  // Retrieve the FirmwareVolume which the file resides in.
-  //
-  if (!FileHandleToVolume(FileHandle, &VolumeHandle)) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  if (((EFI_FIRMWARE_VOLUME_HEADER*)VolumeHandle)->Attributes & EFI_FVB2_ERASE_POLARITY) {
-    ErasePolarity = 1;
-  } else {
-    ErasePolarity = 0;
-  }
-
-  //
-  // Get FileState which is the highest bit of the State 
-  //
-  FileState = GetFileState (ErasePolarity, (EFI_FFS_FILE_HEADER*)FileHandle);
-
-  switch (FileState) {
-    case EFI_FILE_DATA_VALID:
-    case EFI_FILE_MARKED_FOR_UPDATE:
-      break;  
-    default:
-      return EFI_INVALID_PARAMETER;
-    }
-
-  FileHeader = (EFI_FFS_FILE_HEADER *)FileHandle;
-  CopyMem (&FileInfo->FileName, &FileHeader->Name, sizeof(EFI_GUID));
-  FileInfo->FileType = FileHeader->Type;
-  FileInfo->FileAttributes = FileHeader->Attributes;
-  FileInfo->BufferSize = ((*(UINT32 *)FileHeader->Size) & 0x00FFFFFF) -  sizeof (EFI_FFS_FILE_HEADER);
-  FileInfo->Buffer = (FileHeader + 1);
-  return EFI_SUCCESS;
-}
-
-
-/**
-  Get Information about the volume by name
-
-  @param VolumeHandle   Handle of the volume.
-
-  @param VolumeInfo     Upon exit, points to the volume's
-                        information.
-
-  @retval EFI_SUCCESS             File information returned.
-  
-  @retval EFI_INVALID_PARAMETER   If FileHandle does not
-                                  represent a valid file.
-  
-  @retval EFI_INVALID_PARAMETER   If FileInfo is NULL.
-
-**/
-EFI_STATUS
-EFIAPI 
-FfsGetVolumeInfo (
-  IN EFI_PEI_FV_HANDLE  VolumeHandle,
-  OUT EFI_FV_INFO       *VolumeInfo
-  )
-{
-  EFI_FIRMWARE_VOLUME_HEADER             FwVolHeader;
-  EFI_FIRMWARE_VOLUME_EXT_HEADER         *FwVolExHeaderInfo;
-
-  if (VolumeInfo == NULL) {
-    return EFI_INVALID_PARAMETER;
-  }
-  
-  //
-  // VolumeHandle may not align at 8 byte, 
-  // but FvLength is UINT64 type, which requires FvHeader align at least 8 byte. 
-  // So, Copy FvHeader into the local FvHeader structure.
-  //
-  CopyMem (&FwVolHeader, VolumeHandle, sizeof (EFI_FIRMWARE_VOLUME_HEADER));
-  //
-  // Check Fv Image Signature
-  //
-  if (FwVolHeader.Signature != EFI_FVH_SIGNATURE) {
-    return EFI_INVALID_PARAMETER;
-  }
-  VolumeInfo->FvAttributes = FwVolHeader.Attributes;
-  VolumeInfo->FvStart = (VOID *) VolumeHandle;
-  VolumeInfo->FvSize = FwVolHeader.FvLength;
-  CopyMem (&VolumeInfo->FvFormat, &FwVolHeader.FileSystemGuid, sizeof(EFI_GUID));
-
-  if (FwVolHeader.ExtHeaderOffset != 0) {
-    FwVolExHeaderInfo = (EFI_FIRMWARE_VOLUME_EXT_HEADER*)(((UINT8 *)VolumeHandle) + FwVolHeader.ExtHeaderOffset);
-    CopyMem (&VolumeInfo->FvName, &FwVolExHeaderInfo->FvName, sizeof(EFI_GUID));
-  }
-  return EFI_SUCCESS;
-}
-
-
-
-/**
-  Search through every FV until you find a file of type FileType
-
-	@param FileType  	    File handle of a Fv type file.
-  @param Volumehandle   On succes Volume Handle of the match
-  @param FileHandle     On success File Handle of the match
-  
-  @retval EFI_NOT_FOUND  				FV image can't be found.
-  @retval EFI_SUCCESS						Successfully found FileType
-
-**/
-EFI_STATUS
-EFIAPI
-FfsAnyFvFindFirstFile (
-  IN  EFI_FV_FILETYPE       FileType,
-  OUT EFI_PEI_FV_HANDLE     *VolumeHandle,
-  OUT EFI_PEI_FILE_HANDLE   *FileHandle
-  )
-{
-  EFI_STATUS        Status;
-  UINTN             Instance;
-
-  //
-  // Search every FV for the DXE Core
-  //
-  Instance    = 0;
-  *FileHandle = NULL;
-
-  while (1)
-  {
-    Status = FfsFindNextVolume (Instance++, VolumeHandle);
-    if (EFI_ERROR (Status))
-    {
-      break;
-    }
-
-    Status = FfsFindNextFile (FileType, *VolumeHandle, FileHandle);
-    if (!EFI_ERROR (Status))
-    {
-      break;
-    }
-  }
-  
-  return Status;
-}
-
-
-
-/**
-  Get Fv image from the FV type file, then add FV & FV2 Hob.
-
-	@param FileHandle  	        File handle of a Fv type file.
-
-
-  @retval EFI_NOT_FOUND  				FV image can't be found.
-  @retval EFI_SUCCESS						Successfully to process it.
-
-**/
-EFI_STATUS
-EFIAPI
-FfsProcessFvFile (
-  IN  EFI_PEI_FILE_HANDLE   FvFileHandle
-  )
-{
-  EFI_STATUS            Status;
-  EFI_PEI_FV_HANDLE     FvImageHandle;
-  EFI_FV_INFO           FvImageInfo;
-  UINT32                FvAlignment;
-  VOID                  *FvBuffer;
-  EFI_PEI_HOB_POINTERS  HobFv2;
-
-  FvBuffer             = NULL;
-
-
-  //
-  // Check if this EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE file has already
-  // been extracted.
-  //
-  HobFv2.Raw = GetHobList ();
-  while ((HobFv2.Raw = GetNextHob (EFI_HOB_TYPE_FV2, HobFv2.Raw)) != NULL) {
-    if (CompareGuid (&(((EFI_FFS_FILE_HEADER *)FvFileHandle)->Name), &HobFv2.FirmwareVolume2->FileName)) {
-      //
-      // this FILE has been dispatched, it will not be dispatched again.
-      //
-      return EFI_SUCCESS;
-    }
-    HobFv2.Raw = GET_NEXT_HOB (HobFv2);
-  }
-
-  //
-  // Find FvImage in FvFile
-  //
-  Status = FfsFindSectionData (EFI_SECTION_FIRMWARE_VOLUME_IMAGE, FvFileHandle, (VOID **)&FvImageHandle);
-  if (EFI_ERROR (Status)) {
-    return Status;
-  }
-  
-  //
-  // Collect FvImage Info.
-  //
-  ZeroMem (&FvImageInfo, sizeof (FvImageInfo));
-  Status = FfsGetVolumeInfo (FvImageHandle, &FvImageInfo);
-  ASSERT_EFI_ERROR (Status);
-  
-  //
-  // FvAlignment must be more than 8 bytes required by FvHeader structure.
-  //
-  FvAlignment = 1 << ((FvImageInfo.FvAttributes & EFI_FVB2_ALIGNMENT) >> 16);
-  if (FvAlignment < 8) {
-    FvAlignment = 8;
-  }
-  
-  //
-  // Check FvImage
-  //
-  if ((UINTN) FvImageInfo.FvStart % FvAlignment != 0) {
-    FvBuffer = AllocateAlignedPages (EFI_SIZE_TO_PAGES ((UINT32) FvImageInfo.FvSize), FvAlignment);
-    if (FvBuffer == NULL) {
-      return EFI_OUT_OF_RESOURCES;
-    }
-    CopyMem (FvBuffer, FvImageInfo.FvStart, (UINTN) FvImageInfo.FvSize);
-    //
-    // Update FvImageInfo after reload FvImage to new aligned memory
-    //
-    FfsGetVolumeInfo ((EFI_PEI_FV_HANDLE) FvBuffer, &FvImageInfo);
-  }
-
-
-  //
-  // Inform HOB consumer phase, i.e. DXE core, the existance of this FV
-  //
-  BuildFvHob ((EFI_PHYSICAL_ADDRESS) (UINTN) FvImageInfo.FvStart, FvImageInfo.FvSize);
-  
-  //
-  // Makes the encapsulated volume show up in DXE phase to skip processing of
-  // encapsulated file again.
-  //
-  BuildFv2Hob (
-    (EFI_PHYSICAL_ADDRESS) (UINTN) FvImageInfo.FvStart,
-    FvImageInfo.FvSize,
-    &FvImageInfo.FvName,
-    &(((EFI_FFS_FILE_HEADER *)FvFileHandle)->Name)
-    );
-
-  return EFI_SUCCESS;
-}
-
-
+/** @file

+  Implementation of the 6 PEI Ffs (FV) APIs in library form.

+  

+  This code only knows about a FV if it has a EFI_HOB_TYPE_FV entry in the HOB list

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include <PrePi.h>

+#include <Library/ExtractGuidedSectionLib.h>

+

+

+#define GET_OCCUPIED_SIZE(ActualSize, Alignment) \

+  (ActualSize) + (((Alignment) - ((ActualSize) & ((Alignment) - 1))) & ((Alignment) - 1))

+

+

+/**

+  Returns the highest bit set of the State field

+  

+  @param ErasePolarity   Erase Polarity  as defined by EFI_FVB2_ERASE_POLARITY

+                         in the Attributes field.

+  @param FfsHeader       Pointer to FFS File Header

+                      

+

+  @retval the highest bit in the State field

+

+**/

+STATIC

+EFI_FFS_FILE_STATE

+GetFileState(

+  IN UINT8                ErasePolarity,

+  IN EFI_FFS_FILE_HEADER  *FfsHeader

+  )

+{

+  EFI_FFS_FILE_STATE  FileState;

+  EFI_FFS_FILE_STATE  HighestBit;

+

+  FileState = FfsHeader->State;

+

+  if (ErasePolarity != 0) {

+    FileState = (EFI_FFS_FILE_STATE)~FileState;

+  }

+

+  HighestBit = 0x80;

+  while (HighestBit != 0 && (HighestBit & FileState) == 0) {

+    HighestBit >>= 1;

+  }

+

+  return HighestBit;

+} 

+

+

+/**

+  Calculates the checksum of the header of a file.

+  The header is a zero byte checksum, so zero means header is good

+  

+  @param FfsHeader       Pointer to FFS File Header

+                      

+  @retval Checksum of the header

+

+**/

+STATIC

+UINT8

+CalculateHeaderChecksum (

+  IN EFI_FFS_FILE_HEADER  *FileHeader

+  )

+{

+  UINT8   *Ptr;

+  UINTN   Index;

+  UINT8   Sum;

+  

+  Sum = 0;

+  Ptr = (UINT8 *)FileHeader;

+

+  for (Index = 0; Index < sizeof(EFI_FFS_FILE_HEADER) - 3; Index += 4) {

+    Sum = (UINT8)(Sum + Ptr[Index]);

+    Sum = (UINT8)(Sum + Ptr[Index+1]);

+    Sum = (UINT8)(Sum + Ptr[Index+2]);

+    Sum = (UINT8)(Sum + Ptr[Index+3]);

+  }

+

+  for (; Index < sizeof(EFI_FFS_FILE_HEADER); Index++) {

+    Sum = (UINT8)(Sum + Ptr[Index]);

+  }

+  

+  //

+  // State field (since this indicates the different state of file). 

+  //

+  Sum = (UINT8)(Sum - FileHeader->State);

+  //

+  // Checksum field of the file is not part of the header checksum.

+  //

+  Sum = (UINT8)(Sum - FileHeader->IntegrityCheck.Checksum.File);

+

+  return Sum;

+}

+

+

+/**

+  Given a FileHandle return the VolumeHandle

+  

+  @param FileHandle   File handle to look up

+  @param VolumeHandle Match for FileHandle

+                      

+  @retval TRUE  VolumeHandle is valid

+

+**/

+STATIC

+BOOLEAN

+EFIAPI

+FileHandleToVolume (

+  IN   EFI_PEI_FILE_HANDLE     FileHandle,

+  OUT  EFI_PEI_FV_HANDLE       *VolumeHandle

+  )

+{

+  EFI_FIRMWARE_VOLUME_HEADER  *FwVolHeader;

+  EFI_PEI_HOB_POINTERS        Hob;

+

+  Hob.Raw = GetHobList ();

+  if (Hob.Raw == NULL) {

+    return FALSE;

+  }

+  

+  do {

+    Hob.Raw = GetNextHob (EFI_HOB_TYPE_FV, Hob.Raw);

+    if (Hob.Raw != NULL) {

+      FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *)(UINTN)(Hob.FirmwareVolume->BaseAddress);

+      if (((UINT64) (UINTN) FileHandle > (UINT64) (UINTN) FwVolHeader ) &&   \

+          ((UINT64) (UINTN) FileHandle <= ((UINT64) (UINTN) FwVolHeader + FwVolHeader->FvLength - 1))) {

+        *VolumeHandle = (EFI_PEI_FV_HANDLE)FwVolHeader;

+        return TRUE;

+      }

+

+      Hob.Raw = GetNextHob (EFI_HOB_TYPE_FV, GET_NEXT_HOB (Hob));

+    }

+  } while (Hob.Raw != NULL);

+    

+  return FALSE;

+}

+

+

+

+/**

+  Given the input file pointer, search for the next matching file in the

+  FFS volume as defined by SearchType. The search starts from FileHeader inside

+  the Firmware Volume defined by FwVolHeader.

+  

+  @param FileHandle   File handle to look up

+  @param VolumeHandle Match for FileHandle

+                      

+

+**/

+EFI_STATUS

+FindFileEx (

+  IN  CONST EFI_PEI_FV_HANDLE        FvHandle,

+  IN  CONST EFI_GUID                 *FileName,   OPTIONAL

+  IN        EFI_FV_FILETYPE          SearchType,

+  IN OUT    EFI_PEI_FILE_HANDLE      *FileHandle

+  )

+{

+  EFI_FIRMWARE_VOLUME_HEADER           *FwVolHeader;

+  EFI_FFS_FILE_HEADER                   **FileHeader;

+  EFI_FFS_FILE_HEADER                   *FfsFileHeader;

+  EFI_FIRMWARE_VOLUME_EXT_HEADER        *FwVolExHeaderInfo;

+  UINT32                                FileLength;

+  UINT32                                FileOccupiedSize;

+  UINT32                                FileOffset;

+  UINT64                                FvLength;

+  UINT8                                 ErasePolarity;

+  UINT8                                 FileState;

+

+  FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *)FvHandle;

+  FileHeader  = (EFI_FFS_FILE_HEADER **)FileHandle;

+

+  FvLength = FwVolHeader->FvLength;

+  if (FwVolHeader->Attributes & EFI_FVB2_ERASE_POLARITY) {

+    ErasePolarity = 1;

+  } else {

+    ErasePolarity = 0;

+  }

+

+  //

+  // If FileHeader is not specified (NULL) or FileName is not NULL,

+  // start with the first file in the firmware volume.  Otherwise,

+  // start from the FileHeader.

+  //

+  if ((*FileHeader == NULL) || (FileName != NULL)) {

+    FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)FwVolHeader + FwVolHeader->HeaderLength);

+    if (FwVolHeader->ExtHeaderOffset != 0) {

+      FwVolExHeaderInfo = (EFI_FIRMWARE_VOLUME_EXT_HEADER *)(((UINT8 *)FwVolHeader) + FwVolHeader->ExtHeaderOffset);

+      FfsFileHeader = (EFI_FFS_FILE_HEADER *)(((UINT8 *)FwVolExHeaderInfo) + FwVolExHeaderInfo->ExtHeaderSize);

+    }

+  } else {

+    //

+    // Length is 24 bits wide so mask upper 8 bits

+    // FileLength is adjusted to FileOccupiedSize as it is 8 byte aligned.

+    //

+    FileLength = *(UINT32 *)(*FileHeader)->Size & 0x00FFFFFF;

+    FileOccupiedSize = GET_OCCUPIED_SIZE (FileLength, 8);

+    FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)*FileHeader + FileOccupiedSize);

+  }

+  

+  FileOffset = (UINT32) ((UINT8 *)FfsFileHeader - (UINT8 *)FwVolHeader);

+  ASSERT (FileOffset <= 0xFFFFFFFF);

+

+  while (FileOffset < (FvLength - sizeof (EFI_FFS_FILE_HEADER))) {

+    //

+    // Get FileState which is the highest bit of the State 

+    //

+    FileState = GetFileState (ErasePolarity, FfsFileHeader);

+

+    switch (FileState) {

+

+    case EFI_FILE_HEADER_INVALID:

+      FileOffset += sizeof(EFI_FFS_FILE_HEADER);

+      FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)FfsFileHeader + sizeof(EFI_FFS_FILE_HEADER));

+      break;

+        

+    case EFI_FILE_DATA_VALID:

+    case EFI_FILE_MARKED_FOR_UPDATE:

+      if (CalculateHeaderChecksum (FfsFileHeader) != 0) {

+        ASSERT (FALSE);

+        *FileHeader = NULL;

+        return EFI_NOT_FOUND;

+      }

+

+      FileLength = *(UINT32 *)(FfsFileHeader->Size) & 0x00FFFFFF;

+      FileOccupiedSize = GET_OCCUPIED_SIZE(FileLength, 8);

+

+      if (FileName != NULL) {

+        if (CompareGuid (&FfsFileHeader->Name, (EFI_GUID*)FileName)) {

+          *FileHeader = FfsFileHeader;

+          return EFI_SUCCESS;

+        }

+      } else if (((SearchType == FfsFileHeader->Type) || (SearchType == EFI_FV_FILETYPE_ALL)) && 

+                 (FfsFileHeader->Type != EFI_FV_FILETYPE_FFS_PAD)) { 

+        *FileHeader = FfsFileHeader;

+        return EFI_SUCCESS;

+      }

+

+      FileOffset += FileOccupiedSize; 

+      FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)FfsFileHeader + FileOccupiedSize);

+      break;

+    

+    case EFI_FILE_DELETED:

+      FileLength = *(UINT32 *)(FfsFileHeader->Size) & 0x00FFFFFF;

+      FileOccupiedSize = GET_OCCUPIED_SIZE(FileLength, 8);

+      FileOffset += FileOccupiedSize;

+      FfsFileHeader = (EFI_FFS_FILE_HEADER *)((UINT8 *)FfsFileHeader + FileOccupiedSize);

+      break;

+

+    default:

+      *FileHeader = NULL;

+      return EFI_NOT_FOUND;

+    } 

+  }

+

+  

+  *FileHeader = NULL;

+  return EFI_NOT_FOUND;  

+}

+

+

+/**

+  Go through the file to search SectionType section,

+  when meeting an encapsuled section. 

+  

+  @param  SectionType  - Filter to find only section of this type.

+  @param  Section      - From where to search.

+  @param  SectionSize  - The file size to search.

+  @param  OutputBuffer - Pointer to the section to search.

+                      

+  @retval EFI_SUCCESS

+**/

+EFI_STATUS

+FfsProcessSection (

+  IN EFI_SECTION_TYPE           SectionType,

+  IN EFI_COMMON_SECTION_HEADER  *Section,

+  IN UINTN                      SectionSize,

+  OUT VOID                      **OutputBuffer

+  )

+{

+  EFI_STATUS                              Status;

+  UINT32                                  SectionLength;

+  UINT32                                  ParsedLength;

+  EFI_COMPRESSION_SECTION                 *CompressionSection;

+  UINTN                                   DstBufferSize;

+  VOID                                    *ScratchBuffer;

+  UINT32                                  ScratchBufferSize;

+  VOID                                    *DstBuffer;

+  UINT16                                  SectionAttribute;

+  UINT32                                  AuthenticationStatus;

+

+

+  *OutputBuffer = NULL;

+  ParsedLength  = 0;

+  Status        = EFI_NOT_FOUND;

+  while (ParsedLength < SectionSize) {

+    if (Section->Type == SectionType) {

+      *OutputBuffer = (VOID *)(Section + 1);

+

+      return EFI_SUCCESS;

+    } else if ((Section->Type == EFI_SECTION_COMPRESSION) || (Section->Type == EFI_SECTION_GUID_DEFINED)) {

+    

+      if (Section->Type == EFI_SECTION_COMPRESSION) {

+        CompressionSection  = (EFI_COMPRESSION_SECTION *) Section;

+        SectionLength       = *(UINT32 *)Section->Size & 0x00FFFFFF;

+        

+        if (CompressionSection->CompressionType != EFI_STANDARD_COMPRESSION) {

+          return EFI_UNSUPPORTED;

+        }

+

+        Status = UefiDecompressGetInfo (

+                   (UINT8 *) ((EFI_COMPRESSION_SECTION *) Section + 1),

+                   (UINT32) SectionLength - sizeof (EFI_COMPRESSION_SECTION),

+                   (UINT32 *) &DstBufferSize,

+                   &ScratchBufferSize

+                   );

+      } else if (Section->Type == EFI_SECTION_GUID_DEFINED) {

+        Status = ExtractGuidedSectionGetInfo (

+                   Section,

+                   (UINT32 *) &DstBufferSize,

+                   &ScratchBufferSize,

+                   &SectionAttribute

+                   );

+      }

+      

+      if (EFI_ERROR (Status)) {

+        //

+        // GetInfo failed

+        //

+        DEBUG ((EFI_D_ERROR, "Decompress GetInfo Failed - %r\n", Status));

+        return EFI_NOT_FOUND;

+      }

+      //

+      // Allocate scratch buffer

+      //

+      ScratchBuffer = (VOID *)(UINTN)AllocatePages (EFI_SIZE_TO_PAGES (ScratchBufferSize));

+      if (ScratchBuffer == NULL) {

+        return EFI_OUT_OF_RESOURCES;

+      }

+      //

+      // Allocate destination buffer, extra one page for adjustment 

+      //

+      DstBuffer = (VOID *)(UINTN)AllocatePages (EFI_SIZE_TO_PAGES (DstBufferSize) + 1);

+      if (DstBuffer == NULL) {

+        return EFI_OUT_OF_RESOURCES;

+      }

+      //

+      // DstBuffer still is one section. Adjust DstBuffer offset, skip EFI section header

+      // to make section data at page alignment.

+      //

+      DstBuffer = (UINT8 *)DstBuffer + EFI_PAGE_SIZE - sizeof (EFI_COMMON_SECTION_HEADER);

+      //

+      // Call decompress function

+      //

+      if (Section->Type == EFI_SECTION_COMPRESSION) {

+        Status = UefiDecompress (

+                    (CHAR8 *) ((EFI_COMPRESSION_SECTION *) Section + 1),

+                    DstBuffer,

+                    ScratchBuffer

+                    );

+      } else if (Section->Type == EFI_SECTION_GUID_DEFINED) {

+        Status = ExtractGuidedSectionDecode (

+                    Section,

+                    &DstBuffer,

+                    ScratchBuffer,

+                    &AuthenticationStatus

+                    );

+      }

+      

+      if (EFI_ERROR (Status)) {

+        //

+        // Decompress failed

+        //

+        DEBUG ((EFI_D_ERROR, "Decompress Failed - %r\n", Status));

+        return EFI_NOT_FOUND;

+      } else {

+        return FfsProcessSection (

+                SectionType, 

+                DstBuffer, 

+                DstBufferSize, 

+                OutputBuffer 

+                );

+       }        

+    }

+

+    //

+    // Size is 24 bits wide so mask upper 8 bits. 

+    // SectionLength is adjusted it is 4 byte aligned.

+    // Go to the next section

+    //

+    SectionLength = *(UINT32 *)Section->Size & 0x00FFFFFF;

+    SectionLength = GET_OCCUPIED_SIZE (SectionLength, 4);

+    ASSERT (SectionLength != 0);

+    ParsedLength += SectionLength;

+    Section = (EFI_COMMON_SECTION_HEADER *)((UINT8 *)Section + SectionLength);

+  }

+  

+  return EFI_NOT_FOUND;

+}

+

+

+

+/**

+  This service enables discovery sections of a given type within a valid FFS file.

+

+  @param  SearchType            The value of the section type to find.

+  @param  FfsFileHeader         A pointer to the file header that contains the set of sections to

+                                be searched.

+  @param  SectionData           A pointer to the discovered section, if successful.

+

+  @retval EFI_SUCCESS           The section was found.

+  @retval EFI_NOT_FOUND         The section was not found.

+

+**/

+EFI_STATUS

+EFIAPI

+FfsFindSectionData (

+  IN EFI_SECTION_TYPE           SectionType,

+  IN EFI_PEI_FILE_HANDLE        FileHandle,

+  OUT VOID                      **SectionData

+  )

+{

+  EFI_FFS_FILE_HEADER                     *FfsFileHeader;

+  UINT32                                  FileSize;

+  EFI_COMMON_SECTION_HEADER               *Section;

+

+  FfsFileHeader = (EFI_FFS_FILE_HEADER *)(FileHandle);

+

+  //

+  // Size is 24 bits wide so mask upper 8 bits. 

+  // Does not include FfsFileHeader header size

+  // FileSize is adjusted to FileOccupiedSize as it is 8 byte aligned.

+  //

+  Section = (EFI_COMMON_SECTION_HEADER *)(FfsFileHeader + 1);

+  FileSize = *(UINT32 *)(FfsFileHeader->Size) & 0x00FFFFFF;

+  FileSize -= sizeof (EFI_FFS_FILE_HEADER);

+

+  return FfsProcessSection (

+          SectionType, 

+          Section, 

+          FileSize, 

+          SectionData

+          );

+}

+

+

+

+

+

+

+/**

+  This service enables discovery of additional firmware files.

+

+  @param  SearchType            A filter to find files only of this type.

+  @param  FwVolHeader           Pointer to the firmware volume header of the volume to search.

+                                This parameter must point to a valid FFS volume.

+  @param  FileHeader            Pointer to the current file from which to begin searching.

+

+  @retval EFI_SUCCESS           The file was found.

+  @retval EFI_NOT_FOUND         The file was not found.

+  @retval EFI_NOT_FOUND         The header checksum was not zero.

+

+**/

+EFI_STATUS

+EFIAPI

+FfsFindNextFile (

+  IN UINT8                       SearchType,

+  IN EFI_PEI_FV_HANDLE           VolumeHandle,

+  IN OUT EFI_PEI_FILE_HANDLE     *FileHandle

+  )

+{

+  return FindFileEx (VolumeHandle, NULL, SearchType, FileHandle);

+}

+

+

+/**

+  This service enables discovery of additional firmware volumes.

+

+  @param  Instance              This instance of the firmware volume to find.  The value 0 is the

+                                Boot Firmware Volume (BFV).

+  @param  FwVolHeader           Pointer to the firmware volume header of the volume to return.

+

+  @retval EFI_SUCCESS           The volume was found.

+  @retval EFI_NOT_FOUND         The volume was not found.

+

+**/

+EFI_STATUS

+EFIAPI

+FfsFindNextVolume (

+  IN UINTN                          Instance,

+  IN OUT EFI_PEI_FV_HANDLE          *VolumeHandle

+  )

+{

+  EFI_PEI_HOB_POINTERS        Hob;

+  

+

+  Hob.Raw = GetHobList ();

+  if (Hob.Raw == NULL) {

+    return EFI_NOT_FOUND;

+  }

+  

+  do {

+    Hob.Raw = GetNextHob (EFI_HOB_TYPE_FV, Hob.Raw);

+    if (Hob.Raw != NULL) {

+      if (Instance-- == 0) {

+        *VolumeHandle = (EFI_PEI_FV_HANDLE)(UINTN)(Hob.FirmwareVolume->BaseAddress);

+        return EFI_SUCCESS;

+      }

+

+      Hob.Raw = GetNextHob (EFI_HOB_TYPE_FV, GET_NEXT_HOB (Hob));

+    }

+  } while (Hob.Raw != NULL);

+    

+  return EFI_NOT_FOUND;

+

+}

+

+

+/**

+  Find a file in the volume by name

+  

+  @param FileName       A pointer to the name of the file to

+                        find within the firmware volume.

+

+  @param VolumeHandle   The firmware volume to search FileHandle

+                        Upon exit, points to the found file's

+                        handle or NULL if it could not be found.

+

+  @retval EFI_SUCCESS             File was found.

+

+  @retval EFI_NOT_FOUND           File was not found.

+

+  @retval EFI_INVALID_PARAMETER   VolumeHandle or FileHandle or

+                                  FileName was NULL.

+

+**/

+EFI_STATUS

+EFIAPI 

+FfsFindFileByName (

+  IN  CONST EFI_GUID        *FileName,

+  IN  EFI_PEI_FV_HANDLE     VolumeHandle,

+  OUT EFI_PEI_FILE_HANDLE   *FileHandle

+  )

+{

+  EFI_STATUS  Status;

+  if ((VolumeHandle == NULL) || (FileName == NULL) || (FileHandle == NULL)) {

+    return EFI_INVALID_PARAMETER;

+  }

+  Status = FindFileEx (VolumeHandle, FileName, 0, FileHandle);

+  if (Status == EFI_NOT_FOUND) {

+    *FileHandle = NULL;

+  }

+  return Status;

+}

+

+

+

+

+/**

+  Get information about the file by name.

+

+  @param FileHandle   Handle of the file.

+

+  @param FileInfo     Upon exit, points to the file's

+                      information.

+

+  @retval EFI_SUCCESS             File information returned.

+  

+  @retval EFI_INVALID_PARAMETER   If FileHandle does not

+                                  represent a valid file.

+  

+  @retval EFI_INVALID_PARAMETER   If FileInfo is NULL.

+  

+**/

+EFI_STATUS

+EFIAPI 

+FfsGetFileInfo (

+  IN EFI_PEI_FILE_HANDLE  FileHandle,

+  OUT EFI_FV_FILE_INFO    *FileInfo

+  )

+{

+  UINT8                       FileState;

+  UINT8                       ErasePolarity;

+  EFI_FFS_FILE_HEADER         *FileHeader;

+  EFI_PEI_FV_HANDLE           VolumeHandle;

+

+  if ((FileHandle == NULL) || (FileInfo == NULL)) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  VolumeHandle = 0;

+  //

+  // Retrieve the FirmwareVolume which the file resides in.

+  //

+  if (!FileHandleToVolume(FileHandle, &VolumeHandle)) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  if (((EFI_FIRMWARE_VOLUME_HEADER*)VolumeHandle)->Attributes & EFI_FVB2_ERASE_POLARITY) {

+    ErasePolarity = 1;

+  } else {

+    ErasePolarity = 0;

+  }

+

+  //

+  // Get FileState which is the highest bit of the State 

+  //

+  FileState = GetFileState (ErasePolarity, (EFI_FFS_FILE_HEADER*)FileHandle);

+

+  switch (FileState) {

+    case EFI_FILE_DATA_VALID:

+    case EFI_FILE_MARKED_FOR_UPDATE:

+      break;  

+    default:

+      return EFI_INVALID_PARAMETER;

+    }

+

+  FileHeader = (EFI_FFS_FILE_HEADER *)FileHandle;

+  CopyMem (&FileInfo->FileName, &FileHeader->Name, sizeof(EFI_GUID));

+  FileInfo->FileType = FileHeader->Type;

+  FileInfo->FileAttributes = FileHeader->Attributes;

+  FileInfo->BufferSize = ((*(UINT32 *)FileHeader->Size) & 0x00FFFFFF) -  sizeof (EFI_FFS_FILE_HEADER);

+  FileInfo->Buffer = (FileHeader + 1);

+  return EFI_SUCCESS;

+}

+

+

+/**

+  Get Information about the volume by name

+

+  @param VolumeHandle   Handle of the volume.

+

+  @param VolumeInfo     Upon exit, points to the volume's

+                        information.

+

+  @retval EFI_SUCCESS             File information returned.

+  

+  @retval EFI_INVALID_PARAMETER   If FileHandle does not

+                                  represent a valid file.

+  

+  @retval EFI_INVALID_PARAMETER   If FileInfo is NULL.

+

+**/

+EFI_STATUS

+EFIAPI 

+FfsGetVolumeInfo (

+  IN EFI_PEI_FV_HANDLE  VolumeHandle,

+  OUT EFI_FV_INFO       *VolumeInfo

+  )

+{

+  EFI_FIRMWARE_VOLUME_HEADER             FwVolHeader;

+  EFI_FIRMWARE_VOLUME_EXT_HEADER         *FwVolExHeaderInfo;

+

+  if (VolumeInfo == NULL) {

+    return EFI_INVALID_PARAMETER;

+  }

+  

+  //

+  // VolumeHandle may not align at 8 byte, 

+  // but FvLength is UINT64 type, which requires FvHeader align at least 8 byte. 

+  // So, Copy FvHeader into the local FvHeader structure.

+  //

+  CopyMem (&FwVolHeader, VolumeHandle, sizeof (EFI_FIRMWARE_VOLUME_HEADER));

+  //

+  // Check Fv Image Signature

+  //

+  if (FwVolHeader.Signature != EFI_FVH_SIGNATURE) {

+    return EFI_INVALID_PARAMETER;

+  }

+  VolumeInfo->FvAttributes = FwVolHeader.Attributes;

+  VolumeInfo->FvStart = (VOID *) VolumeHandle;

+  VolumeInfo->FvSize = FwVolHeader.FvLength;

+  CopyMem (&VolumeInfo->FvFormat, &FwVolHeader.FileSystemGuid, sizeof(EFI_GUID));

+

+  if (FwVolHeader.ExtHeaderOffset != 0) {

+    FwVolExHeaderInfo = (EFI_FIRMWARE_VOLUME_EXT_HEADER*)(((UINT8 *)VolumeHandle) + FwVolHeader.ExtHeaderOffset);

+    CopyMem (&VolumeInfo->FvName, &FwVolExHeaderInfo->FvName, sizeof(EFI_GUID));

+  }

+  return EFI_SUCCESS;

+}

+

+

+

+/**

+  Search through every FV until you find a file of type FileType

+

+	@param FileType  	    File handle of a Fv type file.

+  @param Volumehandle   On succes Volume Handle of the match

+  @param FileHandle     On success File Handle of the match

+  

+  @retval EFI_NOT_FOUND  				FV image can't be found.

+  @retval EFI_SUCCESS						Successfully found FileType

+

+**/

+EFI_STATUS

+EFIAPI

+FfsAnyFvFindFirstFile (

+  IN  EFI_FV_FILETYPE       FileType,

+  OUT EFI_PEI_FV_HANDLE     *VolumeHandle,

+  OUT EFI_PEI_FILE_HANDLE   *FileHandle

+  )

+{

+  EFI_STATUS        Status;

+  UINTN             Instance;

+

+  //

+  // Search every FV for the DXE Core

+  //

+  Instance    = 0;

+  *FileHandle = NULL;

+

+  while (1)

+  {

+    Status = FfsFindNextVolume (Instance++, VolumeHandle);

+    if (EFI_ERROR (Status))

+    {

+      break;

+    }

+

+    Status = FfsFindNextFile (FileType, *VolumeHandle, FileHandle);

+    if (!EFI_ERROR (Status))

+    {

+      break;

+    }

+  }

+  

+  return Status;

+}

+

+

+

+/**

+  Get Fv image from the FV type file, then add FV & FV2 Hob.

+

+	@param FileHandle  	        File handle of a Fv type file.

+

+

+  @retval EFI_NOT_FOUND  				FV image can't be found.

+  @retval EFI_SUCCESS						Successfully to process it.

+

+**/

+EFI_STATUS

+EFIAPI

+FfsProcessFvFile (

+  IN  EFI_PEI_FILE_HANDLE   FvFileHandle

+  )

+{

+  EFI_STATUS            Status;

+  EFI_PEI_FV_HANDLE     FvImageHandle;

+  EFI_FV_INFO           FvImageInfo;

+  UINT32                FvAlignment;

+  VOID                  *FvBuffer;

+  EFI_PEI_HOB_POINTERS  HobFv2;

+

+  FvBuffer             = NULL;

+

+

+  //

+  // Check if this EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE file has already

+  // been extracted.

+  //

+  HobFv2.Raw = GetHobList ();

+  while ((HobFv2.Raw = GetNextHob (EFI_HOB_TYPE_FV2, HobFv2.Raw)) != NULL) {

+    if (CompareGuid (&(((EFI_FFS_FILE_HEADER *)FvFileHandle)->Name), &HobFv2.FirmwareVolume2->FileName)) {

+      //

+      // this FILE has been dispatched, it will not be dispatched again.

+      //

+      return EFI_SUCCESS;

+    }

+    HobFv2.Raw = GET_NEXT_HOB (HobFv2);

+  }

+

+  //

+  // Find FvImage in FvFile

+  //

+  Status = FfsFindSectionData (EFI_SECTION_FIRMWARE_VOLUME_IMAGE, FvFileHandle, (VOID **)&FvImageHandle);

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+  

+  //

+  // Collect FvImage Info.

+  //

+  ZeroMem (&FvImageInfo, sizeof (FvImageInfo));

+  Status = FfsGetVolumeInfo (FvImageHandle, &FvImageInfo);

+  ASSERT_EFI_ERROR (Status);

+  

+  //

+  // FvAlignment must be more than 8 bytes required by FvHeader structure.

+  //

+  FvAlignment = 1 << ((FvImageInfo.FvAttributes & EFI_FVB2_ALIGNMENT) >> 16);

+  if (FvAlignment < 8) {

+    FvAlignment = 8;

+  }

+  

+  //

+  // Check FvImage

+  //

+  if ((UINTN) FvImageInfo.FvStart % FvAlignment != 0) {

+    FvBuffer = AllocateAlignedPages (EFI_SIZE_TO_PAGES ((UINT32) FvImageInfo.FvSize), FvAlignment);

+    if (FvBuffer == NULL) {

+      return EFI_OUT_OF_RESOURCES;

+    }

+    CopyMem (FvBuffer, FvImageInfo.FvStart, (UINTN) FvImageInfo.FvSize);

+    //

+    // Update FvImageInfo after reload FvImage to new aligned memory

+    //

+    FfsGetVolumeInfo ((EFI_PEI_FV_HANDLE) FvBuffer, &FvImageInfo);

+  }

+

+

+  //

+  // Inform HOB consumer phase, i.e. DXE core, the existance of this FV

+  //

+  BuildFvHob ((EFI_PHYSICAL_ADDRESS) (UINTN) FvImageInfo.FvStart, FvImageInfo.FvSize);

+  

+  //

+  // Makes the encapsulated volume show up in DXE phase to skip processing of

+  // encapsulated file again.

+  //

+  BuildFv2Hob (

+    (EFI_PHYSICAL_ADDRESS) (UINTN) FvImageInfo.FvStart,

+    FvImageInfo.FvSize,

+    &FvImageInfo.FvName,

+    &(((EFI_FFS_FILE_HEADER *)FvFileHandle)->Name)

+    );

+

+  return EFI_SUCCESS;

+}

+

+

diff --git a/EmbeddedPkg/Library/PrePiLib/PrePi.h b/EmbeddedPkg/Library/PrePiLib/PrePi.h
index 77fe3289..d637277d 100644
--- a/EmbeddedPkg/Library/PrePiLib/PrePi.h
+++ b/EmbeddedPkg/Library/PrePiLib/PrePi.h
@@ -1,46 +1,46 @@
-/** @file
-  Library that helps implement monolithic PEI (i.e. PEI part of SEC)
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef _PI_PEI_H_
-#define _PI_PEI_H_
-
-#include <PiPei.h>
-
-#include <Library/BaseLib.h>
-#include <Library/PrePiLib.h>
-#include <Library/PcdLib.h>
-#include <Library/DebugLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/UefiDecompressLib.h>
-#include <Library/PeCoffLib.h>
-#include <Library/CacheMaintenanceLib.h>
-#include <Library/TimerLib.h>
-#include <Library/PerformanceLib.h>
-
-#include <Guid/MemoryAllocationHob.h>
-
-
-#define GET_HOB_TYPE(Hob)     ((Hob).Header->HobType)
-#define GET_HOB_LENGTH(Hob)   ((Hob).Header->HobLength)
-#define GET_NEXT_HOB(Hob)     ((Hob).Raw + GET_HOB_LENGTH (Hob))
-#define END_OF_HOB_LIST(Hob)  (GET_HOB_TYPE (Hob) == EFI_HOB_TYPE_END_OF_HOB_LIST)
-
-//
-// Get the data and data size field of GUID 
-//
-#define GET_GUID_HOB_DATA(GuidHob)      ((VOID *) (((UINT8 *) &((GuidHob)->Name)) + sizeof (EFI_GUID)))
-#define GET_GUID_HOB_DATA_SIZE(GuidHob) (((GuidHob)->Header).HobLength - sizeof (EFI_HOB_GUID_TYPE))
-
-#endif
+/** @file

+  Library that helps implement monolithic PEI (i.e. PEI part of SEC)

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef _PI_PEI_H_

+#define _PI_PEI_H_

+

+#include <PiPei.h>

+

+#include <Library/BaseLib.h>

+#include <Library/PrePiLib.h>

+#include <Library/PcdLib.h>

+#include <Library/DebugLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/UefiDecompressLib.h>

+#include <Library/PeCoffLib.h>

+#include <Library/CacheMaintenanceLib.h>

+#include <Library/TimerLib.h>

+#include <Library/PerformanceLib.h>

+

+#include <Guid/MemoryAllocationHob.h>

+

+

+#define GET_HOB_TYPE(Hob)     ((Hob).Header->HobType)

+#define GET_HOB_LENGTH(Hob)   ((Hob).Header->HobLength)

+#define GET_NEXT_HOB(Hob)     ((Hob).Raw + GET_HOB_LENGTH (Hob))

+#define END_OF_HOB_LIST(Hob)  (GET_HOB_TYPE (Hob) == EFI_HOB_TYPE_END_OF_HOB_LIST)

+

+//

+// Get the data and data size field of GUID 

+//

+#define GET_GUID_HOB_DATA(GuidHob)      ((VOID *) (((UINT8 *) &((GuidHob)->Name)) + sizeof (EFI_GUID)))

+#define GET_GUID_HOB_DATA_SIZE(GuidHob) (((GuidHob)->Header).HobLength - sizeof (EFI_HOB_GUID_TYPE))

+

+#endif

diff --git a/EmbeddedPkg/Library/PrePiLib/PrePiLib.c b/EmbeddedPkg/Library/PrePiLib/PrePiLib.c
index e46cafec..4cc974f1 100644
--- a/EmbeddedPkg/Library/PrePiLib/PrePiLib.c
+++ b/EmbeddedPkg/Library/PrePiLib/PrePiLib.c
@@ -1,226 +1,226 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include <PrePi.h>
-
-//
-// Hack to work in NT32
-//
-EFI_STATUS
-
-EFIAPI
-
-SecWinNtPeiLoadFile (
-  IN  VOID                    *Pe32Data,
-  IN  EFI_PHYSICAL_ADDRESS    *ImageAddress,
-  IN  UINT64                  *ImageSize,
-  IN  EFI_PHYSICAL_ADDRESS    *EntryPoint
-  );
-
-
-EFI_STATUS
-EFIAPI
-LoadPeCoffImage (
-  IN  VOID                                      *PeCoffImage,
-  OUT EFI_PHYSICAL_ADDRESS                      *ImageAddress,
-  OUT UINT64                                    *ImageSize,
-  OUT EFI_PHYSICAL_ADDRESS                      *EntryPoint
-  )
-{
-  RETURN_STATUS                 Status;
-  PE_COFF_LOADER_IMAGE_CONTEXT  ImageContext;
-  VOID                           *Buffer;
-
-  ZeroMem (&ImageContext, sizeof (ImageContext));
-    
-  ImageContext.Handle    = PeCoffImage;
-  ImageContext.ImageRead = PeCoffLoaderImageReadFromMemory;
-
-  Status = PeCoffLoaderGetImageInfo (&ImageContext);
-  ASSERT_EFI_ERROR (Status);
-  
-
-  //
-  // Allocate Memory for the image
-  //
-  Buffer = AllocatePages (EFI_SIZE_TO_PAGES((UINT32)ImageContext.ImageSize));
-  ASSERT (Buffer != 0);
-
-
-  ImageContext.ImageAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)Buffer;
-
-  //
-  // Load the image to our new buffer
-  //
-  Status = PeCoffLoaderLoadImage (&ImageContext);
-  ASSERT_EFI_ERROR (Status);
-
-  //
-  // Relocate the image in our new buffer
-  //
-  Status = PeCoffLoaderRelocateImage (&ImageContext);
-  ASSERT_EFI_ERROR (Status);
-
-
-  *ImageAddress = ImageContext.ImageAddress;
-  *ImageSize    = ImageContext.ImageSize;
-  *EntryPoint   = ImageContext.EntryPoint;
-
-  //
-  // Flush not needed for all architectures. We could have a processor specific
-  // function in this library that does the no-op if needed.
-  //
-  InvalidateInstructionCacheRange ((VOID *)(UINTN)*ImageAddress, (UINTN)*ImageSize);
-
-  return Status;
-}
-
-
-
-typedef 
-VOID
-(EFIAPI *DXE_CORE_ENTRY_POINT) (
-  IN  VOID *HobStart
-  );
-
-EFI_STATUS
-EFIAPI
-LoadDxeCoreFromFfsFile (
-  IN EFI_PEI_FILE_HANDLE  FileHandle,
-  IN UINTN                StackSize
-  )
-{
-  EFI_STATUS              Status;
-  VOID                    *PeCoffImage;
-  EFI_PHYSICAL_ADDRESS    ImageAddress;
-  UINT64                  ImageSize;
-  EFI_PHYSICAL_ADDRESS    EntryPoint;
-  VOID                    *BaseOfStack;
-  VOID                    *TopOfStack;
-  VOID                    *Hob;
-  EFI_FV_FILE_INFO        FvFileInfo;
-
-  Status = FfsFindSectionData (EFI_SECTION_PE32, FileHandle, &PeCoffImage);
-  if (EFI_ERROR  (Status)) {
-    return Status;
-  }
-
-  
-  Status = LoadPeCoffImage (PeCoffImage, &ImageAddress, &ImageSize, &EntryPoint);
-// For NT32 Debug  Status = SecWinNtPeiLoadFile (PeCoffImage, &ImageAddress, &ImageSize, &EntryPoint);
-  ASSERT_EFI_ERROR (Status);
-
-  //
-  // Extract the DxeCore GUID file name.
-  //
-  Status = FfsGetFileInfo (FileHandle, &FvFileInfo);
-  ASSERT_EFI_ERROR (Status);
-
-  BuildModuleHob (&FvFileInfo.FileName, (EFI_PHYSICAL_ADDRESS)(UINTN)ImageAddress, EFI_SIZE_TO_PAGES ((UINT32) ImageSize) * EFI_PAGE_SIZE, EntryPoint);
-  
-  DEBUG ((EFI_D_INFO | EFI_D_LOAD, "Loading DxeCore at 0x%10p EntryPoint=0x%10p\n", (VOID *)(UINTN)ImageAddress, (VOID *)(UINTN)EntryPoint));
-
-  Hob = GetHobList ();
-  if (StackSize == 0) {
-    // User the current stack
-  
-    ((DXE_CORE_ENTRY_POINT)(UINTN)EntryPoint) (Hob);
-  } else {
-    
-    //
-    // Allocate 128KB for the Stack
-    //
-    BaseOfStack = AllocatePages (EFI_SIZE_TO_PAGES (StackSize));
-    ASSERT (BaseOfStack != NULL);
-  
-    //
-    // Compute the top of the stack we were allocated. Pre-allocate a UINTN
-    // for safety.
-    //
-    TopOfStack = (VOID *) ((UINTN) BaseOfStack + EFI_SIZE_TO_PAGES (StackSize) * EFI_PAGE_SIZE - CPU_STACK_ALIGNMENT);
-    TopOfStack = ALIGN_POINTER (TopOfStack, CPU_STACK_ALIGNMENT);
-
-    //
-    // Update the contents of BSP stack HOB to reflect the real stack info passed to DxeCore.
-    //    
-    UpdateStackHob ((EFI_PHYSICAL_ADDRESS)(UINTN) BaseOfStack, StackSize);
-
-    SwitchStack (
-      (SWITCH_STACK_ENTRY_POINT)(UINTN)EntryPoint,
-      Hob,
-      NULL,
-      TopOfStack
-      );
-
-  }
-  
-  // Should never get here as DXE Core does not return
-  DEBUG ((EFI_D_ERROR, "DxeCore returned\n"));
-  ASSERT (FALSE);
-  
-  return EFI_DEVICE_ERROR;
-}
-
-
-
-EFI_STATUS
-EFIAPI
-LoadDxeCoreFromFv (
-  IN UINTN  *FvInstance,   OPTIONAL
-  IN UINTN  StackSize
-  )
-{
-  EFI_STATUS          Status;
-  EFI_PEI_FV_HANDLE   VolumeHandle;
-  EFI_PEI_FILE_HANDLE FileHandle = NULL;
-
-  if (FvInstance != NULL) {
-    //
-    // Caller passed in a specific FV to try, so only try that one
-    //
-    Status = FfsFindNextVolume (*FvInstance, &VolumeHandle);
-    if (!EFI_ERROR (Status)) {
-      Status = FfsFindNextFile (EFI_FV_FILETYPE_DXE_CORE, VolumeHandle, &FileHandle);
-    }
-  } else {
-    Status = FfsAnyFvFindFirstFile (EFI_FV_FILETYPE_DXE_CORE, &VolumeHandle, &FileHandle);
-  }
-
-  if (!EFI_ERROR (Status)) {
-    return LoadDxeCoreFromFfsFile (FileHandle, StackSize);
-  } 
-  
-  return Status;  
-}
-
-
-EFI_STATUS
-EFIAPI
-DecompressFirstFv (
-  VOID
-  )
-{
-  EFI_STATUS          Status;
-  EFI_PEI_FV_HANDLE   VolumeHandle;
-  EFI_PEI_FILE_HANDLE FileHandle;
-
-  Status = FfsAnyFvFindFirstFile (EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE, &VolumeHandle, &FileHandle);
-  if (!EFI_ERROR (Status)) {
-    Status = FfsProcessFvFile (FileHandle);
-  }
-  
-  return Status;
-}
-
-
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include <PrePi.h>

+

+//

+// Hack to work in NT32

+//

+EFI_STATUS

+

+EFIAPI

+

+SecWinNtPeiLoadFile (

+  IN  VOID                    *Pe32Data,

+  IN  EFI_PHYSICAL_ADDRESS    *ImageAddress,

+  IN  UINT64                  *ImageSize,

+  IN  EFI_PHYSICAL_ADDRESS    *EntryPoint

+  );

+

+

+EFI_STATUS

+EFIAPI

+LoadPeCoffImage (

+  IN  VOID                                      *PeCoffImage,

+  OUT EFI_PHYSICAL_ADDRESS                      *ImageAddress,

+  OUT UINT64                                    *ImageSize,

+  OUT EFI_PHYSICAL_ADDRESS                      *EntryPoint

+  )

+{

+  RETURN_STATUS                 Status;

+  PE_COFF_LOADER_IMAGE_CONTEXT  ImageContext;

+  VOID                           *Buffer;

+

+  ZeroMem (&ImageContext, sizeof (ImageContext));

+    

+  ImageContext.Handle    = PeCoffImage;

+  ImageContext.ImageRead = PeCoffLoaderImageReadFromMemory;

+

+  Status = PeCoffLoaderGetImageInfo (&ImageContext);

+  ASSERT_EFI_ERROR (Status);

+  

+

+  //

+  // Allocate Memory for the image

+  //

+  Buffer = AllocatePages (EFI_SIZE_TO_PAGES((UINT32)ImageContext.ImageSize));

+  ASSERT (Buffer != 0);

+

+

+  ImageContext.ImageAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)Buffer;

+

+  //

+  // Load the image to our new buffer

+  //

+  Status = PeCoffLoaderLoadImage (&ImageContext);

+  ASSERT_EFI_ERROR (Status);

+

+  //

+  // Relocate the image in our new buffer

+  //

+  Status = PeCoffLoaderRelocateImage (&ImageContext);

+  ASSERT_EFI_ERROR (Status);

+

+

+  *ImageAddress = ImageContext.ImageAddress;

+  *ImageSize    = ImageContext.ImageSize;

+  *EntryPoint   = ImageContext.EntryPoint;

+

+  //

+  // Flush not needed for all architectures. We could have a processor specific

+  // function in this library that does the no-op if needed.

+  //

+  InvalidateInstructionCacheRange ((VOID *)(UINTN)*ImageAddress, (UINTN)*ImageSize);

+

+  return Status;

+}

+

+

+

+typedef 

+VOID

+(EFIAPI *DXE_CORE_ENTRY_POINT) (

+  IN  VOID *HobStart

+  );

+

+EFI_STATUS

+EFIAPI

+LoadDxeCoreFromFfsFile (

+  IN EFI_PEI_FILE_HANDLE  FileHandle,

+  IN UINTN                StackSize

+  )

+{

+  EFI_STATUS              Status;

+  VOID                    *PeCoffImage;

+  EFI_PHYSICAL_ADDRESS    ImageAddress;

+  UINT64                  ImageSize;

+  EFI_PHYSICAL_ADDRESS    EntryPoint;

+  VOID                    *BaseOfStack;

+  VOID                    *TopOfStack;

+  VOID                    *Hob;

+  EFI_FV_FILE_INFO        FvFileInfo;

+

+  Status = FfsFindSectionData (EFI_SECTION_PE32, FileHandle, &PeCoffImage);

+  if (EFI_ERROR  (Status)) {

+    return Status;

+  }

+

+  

+  Status = LoadPeCoffImage (PeCoffImage, &ImageAddress, &ImageSize, &EntryPoint);

+// For NT32 Debug  Status = SecWinNtPeiLoadFile (PeCoffImage, &ImageAddress, &ImageSize, &EntryPoint);

+  ASSERT_EFI_ERROR (Status);

+

+  //

+  // Extract the DxeCore GUID file name.

+  //

+  Status = FfsGetFileInfo (FileHandle, &FvFileInfo);

+  ASSERT_EFI_ERROR (Status);

+

+  BuildModuleHob (&FvFileInfo.FileName, (EFI_PHYSICAL_ADDRESS)(UINTN)ImageAddress, EFI_SIZE_TO_PAGES ((UINT32) ImageSize) * EFI_PAGE_SIZE, EntryPoint);

+  

+  DEBUG ((EFI_D_INFO | EFI_D_LOAD, "Loading DxeCore at 0x%10p EntryPoint=0x%10p\n", (VOID *)(UINTN)ImageAddress, (VOID *)(UINTN)EntryPoint));

+

+  Hob = GetHobList ();

+  if (StackSize == 0) {

+    // User the current stack

+  

+    ((DXE_CORE_ENTRY_POINT)(UINTN)EntryPoint) (Hob);

+  } else {

+    

+    //

+    // Allocate 128KB for the Stack

+    //

+    BaseOfStack = AllocatePages (EFI_SIZE_TO_PAGES (StackSize));

+    ASSERT (BaseOfStack != NULL);

+  

+    //

+    // Compute the top of the stack we were allocated. Pre-allocate a UINTN

+    // for safety.

+    //

+    TopOfStack = (VOID *) ((UINTN) BaseOfStack + EFI_SIZE_TO_PAGES (StackSize) * EFI_PAGE_SIZE - CPU_STACK_ALIGNMENT);

+    TopOfStack = ALIGN_POINTER (TopOfStack, CPU_STACK_ALIGNMENT);

+

+    //

+    // Update the contents of BSP stack HOB to reflect the real stack info passed to DxeCore.

+    //    

+    UpdateStackHob ((EFI_PHYSICAL_ADDRESS)(UINTN) BaseOfStack, StackSize);

+

+    SwitchStack (

+      (SWITCH_STACK_ENTRY_POINT)(UINTN)EntryPoint,

+      Hob,

+      NULL,

+      TopOfStack

+      );

+

+  }

+  

+  // Should never get here as DXE Core does not return

+  DEBUG ((EFI_D_ERROR, "DxeCore returned\n"));

+  ASSERT (FALSE);

+  

+  return EFI_DEVICE_ERROR;

+}

+

+

+

+EFI_STATUS

+EFIAPI

+LoadDxeCoreFromFv (

+  IN UINTN  *FvInstance,   OPTIONAL

+  IN UINTN  StackSize

+  )

+{

+  EFI_STATUS          Status;

+  EFI_PEI_FV_HANDLE   VolumeHandle;

+  EFI_PEI_FILE_HANDLE FileHandle = NULL;

+

+  if (FvInstance != NULL) {

+    //

+    // Caller passed in a specific FV to try, so only try that one

+    //

+    Status = FfsFindNextVolume (*FvInstance, &VolumeHandle);

+    if (!EFI_ERROR (Status)) {

+      Status = FfsFindNextFile (EFI_FV_FILETYPE_DXE_CORE, VolumeHandle, &FileHandle);

+    }

+  } else {

+    Status = FfsAnyFvFindFirstFile (EFI_FV_FILETYPE_DXE_CORE, &VolumeHandle, &FileHandle);

+  }

+

+  if (!EFI_ERROR (Status)) {

+    return LoadDxeCoreFromFfsFile (FileHandle, StackSize);

+  } 

+  

+  return Status;  

+}

+

+

+EFI_STATUS

+EFIAPI

+DecompressFirstFv (

+  VOID

+  )

+{

+  EFI_STATUS          Status;

+  EFI_PEI_FV_HANDLE   VolumeHandle;

+  EFI_PEI_FILE_HANDLE FileHandle;

+

+  Status = FfsAnyFvFindFirstFile (EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE, &VolumeHandle, &FileHandle);

+  if (!EFI_ERROR (Status)) {

+    Status = FfsProcessFvFile (FileHandle);

+  }

+  

+  return Status;

+}

+

+

diff --git a/EmbeddedPkg/Library/PrePiLib/ReportStatusCode.c b/EmbeddedPkg/Library/PrePiLib/ReportStatusCode.c
index f898808d..8d60d5ab 100644
--- a/EmbeddedPkg/Library/PrePiLib/ReportStatusCode.c
+++ b/EmbeddedPkg/Library/PrePiLib/ReportStatusCode.c
@@ -1,327 +1,327 @@
-/** @file
-  Library that helps implement monolithic PEI
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include <PrePi.h>
-#include <Library/ReportStatusCodeLib.h>
-#include <Library/SerialPortLib.h>
-#include <Library/PrintLib.h>
-
-#include <Protocol/StatusCode.h>
-#include <Guid/StatusCodeDataTypeId.h>
-#include <Guid/StatusCodeDataTypeDebug.h>
-#include <FrameworkPei.h>
-
-#define EFI_STATUS_CODE_DATA_MAX_SIZE 200
-
-EFI_STATUS
-EFIAPI
-SerialReportStatusCode (
-  IN EFI_STATUS_CODE_TYPE             CodeType,
-  IN EFI_STATUS_CODE_VALUE            Value,
-  IN UINT32                           Instance,
-  IN CONST EFI_GUID                   *CallerId,
-  IN CONST EFI_STATUS_CODE_DATA       *Data OPTIONAL
-  );
-
-
-EFI_STATUS_CODE_PROTOCOL gStatusCode = { 
-  (EFI_REPORT_STATUS_CODE)SerialReportStatusCode 
-};
-
-/**
-  Extracts ASSERT() information from a status code structure.
-
-  Converts the status code specified by CodeType, Value, and Data to the ASSERT()
-  arguments specified by Filename, Description, and LineNumber.  If CodeType is
-  an EFI_ERROR_CODE, and CodeType has a severity of EFI_ERROR_UNRECOVERED, and
-  Value has an operation mask of EFI_SW_EC_ILLEGAL_SOFTWARE_STATE, extract
-  Filename, Description, and LineNumber from the optional data area of the
-  status code buffer specified by Data.  The optional data area of Data contains
-  a Null-terminated ASCII string for the FileName, followed by a Null-terminated
-  ASCII string for the Description, followed by a 32-bit LineNumber.  If the
-  ASSERT() information could be extracted from Data, then return TRUE.
-  Otherwise, FALSE is returned.
-
-  If Data is NULL, then ASSERT().
-  If Filename is NULL, then ASSERT().
-  If Description is NULL, then ASSERT().
-  If LineNumber is NULL, then ASSERT().
-
-  @param  CodeType     The type of status code being converted.
-  @param  Value        The status code value being converted.
-  @param  Data         Pointer to status code data buffer.
-  @param  Filename     Pointer to the source file name that generated the ASSERT().
-  @param  Description  Pointer to the description of the ASSERT().
-  @param  LineNumber   Pointer to source line number that generated the ASSERT().
-
-  @retval  TRUE   The status code specified by CodeType, Value, and Data was
-                  converted ASSERT() arguments specified by Filename, Description,
-                  and LineNumber.
-  @retval  FALSE  The status code specified by CodeType, Value, and Data could
-                  not be converted to ASSERT() arguments.
-
-**/
-BOOLEAN
-EFIAPI
-ReportStatusCodeExtractAssertInfo (
-  IN EFI_STATUS_CODE_TYPE        CodeType,
-  IN EFI_STATUS_CODE_VALUE       Value,
-  IN CONST EFI_STATUS_CODE_DATA  *Data,
-  OUT CHAR8                      **Filename,
-  OUT CHAR8                      **Description,
-  OUT UINT32                     *LineNumber
-  )
-{
-  EFI_DEBUG_ASSERT_DATA  *AssertData;
-
-  ASSERT (Data        != NULL);
-  ASSERT (Filename    != NULL);
-  ASSERT (Description != NULL);
-  ASSERT (LineNumber  != NULL);
-
-  if (((CodeType & EFI_STATUS_CODE_TYPE_MASK)      == EFI_ERROR_CODE) &&
-      ((CodeType & EFI_STATUS_CODE_SEVERITY_MASK)  == EFI_ERROR_UNRECOVERED) &&
-      ((Value    & EFI_STATUS_CODE_OPERATION_MASK) == EFI_SW_EC_ILLEGAL_SOFTWARE_STATE)) {
-    AssertData   = (EFI_DEBUG_ASSERT_DATA *)(Data + 1);
-    *Filename    = (CHAR8 *)(AssertData + 1);
-    *Description = *Filename + AsciiStrLen (*Filename) + 1;
-    *LineNumber  = AssertData->LineNumber;
-    return TRUE;
-  }
-  return FALSE;
-}
-
-
-/**
-  Extracts DEBUG() information from a status code structure.
-
-  Converts the status code specified by Data to the DEBUG() arguments specified
-  by ErrorLevel, Marker, and Format.  If type GUID in Data is
-  EFI_STATUS_CODE_DATA_TYPE_DEBUG_GUID, then extract ErrorLevel, Marker, and
-  Format from the optional data area of the status code buffer specified by Data.
-  The optional data area of Data contains a 32-bit ErrorLevel followed by Marker
-  which is 12 UINTN parameters, followed by a Null-terminated ASCII string for
-  the Format.  If the DEBUG() information could be extracted from Data, then
-  return TRUE.  Otherwise, FALSE is returned.
-
-  If Data is NULL, then ASSERT().
-  If ErrorLevel is NULL, then ASSERT().
-  If Marker is NULL, then ASSERT().
-  If Format is NULL, then ASSERT().
-
-  @param  Data        Pointer to status code data buffer.
-  @param  ErrorLevel  Pointer to error level mask for a debug message.
-  @param  Marker      Pointer to the variable argument list associated with Format.
-  @param  Format      Pointer to a Null-terminated ASCII format string of a
-                      debug message.
-
-  @retval  TRUE   The status code specified by Data was converted DEBUG() arguments
-                  specified by ErrorLevel, Marker, and Format.
-  @retval  FALSE  The status code specified by Data could not be converted to
-                  DEBUG() arguments.
-
-**/
-BOOLEAN
-EFIAPI
-ReportStatusCodeExtractDebugInfo (
-  IN CONST EFI_STATUS_CODE_DATA  *Data,
-  OUT UINT32                     *ErrorLevel,
-  OUT BASE_LIST                  *Marker,
-  OUT CHAR8                      **Format
-  )
-{
-  EFI_DEBUG_INFO  *DebugInfo;
-
-  ASSERT (Data          != NULL);
-  ASSERT (ErrorLevel    != NULL);
-  ASSERT (Marker     != NULL);
-  ASSERT (Format     != NULL);
-
-  //
-  // If the GUID type is not EFI_STATUS_CODE_DATA_TYPE_DEBUG_GUID then return FALSE
-  //
-  if (!CompareGuid (&Data->Type, &gEfiStatusCodeDataTypeDebugGuid)) {
-    return FALSE;
-  }
-
-  //
-  // Retrieve the debug information from the status code record
-  //
-  DebugInfo = (EFI_DEBUG_INFO *)(Data + 1);
-
-  *ErrorLevel = DebugInfo->ErrorLevel;
-
-  //
-  // The first 12 * UINTN bytes of the string are really an
-  // argument stack to support varargs on the Format string.
-  //
-  *Marker = (BASE_LIST) (DebugInfo + 1);
-  *Format = (CHAR8 *)(((UINT64 *)*Marker) + 12);
-
-  return TRUE;
-}
-
-
-
-
-EFI_STATUS
-EFIAPI
-SerialReportStatusCode (
-  IN EFI_STATUS_CODE_TYPE             CodeType,
-  IN EFI_STATUS_CODE_VALUE            Value,
-  IN UINT32                           Instance,
-  IN CONST EFI_GUID                   *CallerId,
-  IN CONST EFI_STATUS_CODE_DATA       *Data OPTIONAL
-  )
-{
-  CHAR8           *Filename;
-  CHAR8           *Description;
-  CHAR8           *Format;
-  CHAR8           Buffer[EFI_STATUS_CODE_DATA_MAX_SIZE];
-  UINT32          ErrorLevel;
-  UINT32          LineNumber;
-  UINTN           CharCount;
-  BASE_LIST       Marker;
-  EFI_DEBUG_INFO  *DebugInfo;
-
-  Buffer[0] = '\0';
-
-
-  if (Data != NULL &&
-    ReportStatusCodeExtractAssertInfo (CodeType, Value, Data, &Filename, &Description, &LineNumber)) {
-
-    //
-    // Print ASSERT() information into output buffer.
-    //
-    CharCount = AsciiSPrint (
-                  Buffer,
-                  EFI_STATUS_CODE_DATA_MAX_SIZE,
-                  "\n\rASSERT!: %a (%d): %a\n\r",
-                  Filename,
-                  LineNumber,
-                  Description
-                  );
-
-
-    //
-    // Callout to standard output.
-    //
-    SerialPortWrite ((UINT8 *)Buffer, CharCount);
-    return EFI_SUCCESS;
-
-  } else if (Data != NULL &&
-    ReportStatusCodeExtractDebugInfo (Data, &ErrorLevel, &Marker, &Format)) {
-    
-    //
-    // Print DEBUG() information into output buffer.
-    //
-    CharCount = AsciiBSPrint (
-                  Buffer,
-                  EFI_STATUS_CODE_DATA_MAX_SIZE,
-                  Format,
-                  Marker
-                  );
-
-  } else if (Data != NULL &&
-             CompareGuid (&Data->Type, &gEfiStatusCodeSpecificDataGuid) &&
-             (CodeType & EFI_STATUS_CODE_TYPE_MASK) == EFI_DEBUG_CODE) {
-
-    //
-    // Print specific data into output buffer.
-    //
-    DebugInfo = (EFI_DEBUG_INFO *) (Data + 1);
-    Marker    = (BASE_LIST) (DebugInfo + 1);
-    Format    = (CHAR8 *) (((UINT64 *) (DebugInfo + 1)) + 12);
-
-    CharCount = AsciiBSPrint (Buffer, EFI_STATUS_CODE_DATA_MAX_SIZE, Format, Marker);
-
-  } else if ((CodeType & EFI_STATUS_CODE_TYPE_MASK) == EFI_ERROR_CODE) {
-    //
-    // Print ERROR information into output buffer.
-    //
-
-    CharCount = AsciiSPrint (
-                  Buffer,
-                  EFI_STATUS_CODE_DATA_MAX_SIZE,
-                  "ERROR: C%x:V%x I%x",
-                  CodeType,
-                  Value,
-                  Instance
-                  );
-
-    //
-    // Make sure we don't try to print values that weren't intended to be printed, especially NULL GUID pointers.
-    //
-    if (CallerId != NULL) {
-      CharCount += AsciiSPrint (
-                     &Buffer[CharCount - 1],
-                     (EFI_STATUS_CODE_DATA_MAX_SIZE - (sizeof (Buffer[0]) * CharCount)),
-                     " %g",
-                     CallerId
-                     );
-    }
-
-    if (Data != NULL) {
-      CharCount += AsciiSPrint (
-                     &Buffer[CharCount - 1],
-                     (EFI_STATUS_CODE_DATA_MAX_SIZE - (sizeof (Buffer[0]) * CharCount)),
-                     " %x",
-                     Data
-                     );
-
-    }
-
-
-    CharCount += AsciiSPrint (
-                   &Buffer[CharCount - 1],
-                   (EFI_STATUS_CODE_DATA_MAX_SIZE - (sizeof (Buffer[0]) * CharCount)),
-                   "\n\r"
-                   );
-
-  } else if ((CodeType & EFI_STATUS_CODE_TYPE_MASK) == EFI_PROGRESS_CODE) {
-    CharCount = AsciiSPrint (
-                  Buffer,
-                  EFI_STATUS_CODE_DATA_MAX_SIZE,
-                  "PROGRESS CODE: V%x I%x\n\r",
-                  Value,
-                  Instance
-                  );
-  } else {
-    CharCount = AsciiSPrint (
-                  Buffer,
-                  EFI_STATUS_CODE_DATA_MAX_SIZE,
-                  "Undefined: C%x:V%x I%x\n\r",
-                  CodeType,
-                  Value,
-                  Instance
-                  );
-
-  }
-
-  SerialPortWrite ((UINT8 *)Buffer, CharCount);
-  return EFI_SUCCESS;
-
-}
-
-
-VOID
-EFIAPI
-AddDxeCoreReportStatusCodeCallback (
-  VOID
-  )
-{
-  BuildGuidDataHob (&gEfiStatusCodeRuntimeProtocolGuid, &gStatusCode, sizeof(VOID *));
-}
-
+/** @file

+  Library that helps implement monolithic PEI

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include <PrePi.h>

+#include <Library/ReportStatusCodeLib.h>

+#include <Library/SerialPortLib.h>

+#include <Library/PrintLib.h>

+

+#include <Protocol/StatusCode.h>

+#include <Guid/StatusCodeDataTypeId.h>

+#include <Guid/StatusCodeDataTypeDebug.h>

+#include <FrameworkPei.h>

+

+#define EFI_STATUS_CODE_DATA_MAX_SIZE 200

+

+EFI_STATUS

+EFIAPI

+SerialReportStatusCode (

+  IN EFI_STATUS_CODE_TYPE             CodeType,

+  IN EFI_STATUS_CODE_VALUE            Value,

+  IN UINT32                           Instance,

+  IN CONST EFI_GUID                   *CallerId,

+  IN CONST EFI_STATUS_CODE_DATA       *Data OPTIONAL

+  );

+

+

+EFI_STATUS_CODE_PROTOCOL gStatusCode = { 

+  (EFI_REPORT_STATUS_CODE)SerialReportStatusCode 

+};

+

+/**

+  Extracts ASSERT() information from a status code structure.

+

+  Converts the status code specified by CodeType, Value, and Data to the ASSERT()

+  arguments specified by Filename, Description, and LineNumber.  If CodeType is

+  an EFI_ERROR_CODE, and CodeType has a severity of EFI_ERROR_UNRECOVERED, and

+  Value has an operation mask of EFI_SW_EC_ILLEGAL_SOFTWARE_STATE, extract

+  Filename, Description, and LineNumber from the optional data area of the

+  status code buffer specified by Data.  The optional data area of Data contains

+  a Null-terminated ASCII string for the FileName, followed by a Null-terminated

+  ASCII string for the Description, followed by a 32-bit LineNumber.  If the

+  ASSERT() information could be extracted from Data, then return TRUE.

+  Otherwise, FALSE is returned.

+

+  If Data is NULL, then ASSERT().

+  If Filename is NULL, then ASSERT().

+  If Description is NULL, then ASSERT().

+  If LineNumber is NULL, then ASSERT().

+

+  @param  CodeType     The type of status code being converted.

+  @param  Value        The status code value being converted.

+  @param  Data         Pointer to status code data buffer.

+  @param  Filename     Pointer to the source file name that generated the ASSERT().

+  @param  Description  Pointer to the description of the ASSERT().

+  @param  LineNumber   Pointer to source line number that generated the ASSERT().

+

+  @retval  TRUE   The status code specified by CodeType, Value, and Data was

+                  converted ASSERT() arguments specified by Filename, Description,

+                  and LineNumber.

+  @retval  FALSE  The status code specified by CodeType, Value, and Data could

+                  not be converted to ASSERT() arguments.

+

+**/

+BOOLEAN

+EFIAPI

+ReportStatusCodeExtractAssertInfo (

+  IN EFI_STATUS_CODE_TYPE        CodeType,

+  IN EFI_STATUS_CODE_VALUE       Value,

+  IN CONST EFI_STATUS_CODE_DATA  *Data,

+  OUT CHAR8                      **Filename,

+  OUT CHAR8                      **Description,

+  OUT UINT32                     *LineNumber

+  )

+{

+  EFI_DEBUG_ASSERT_DATA  *AssertData;

+

+  ASSERT (Data        != NULL);

+  ASSERT (Filename    != NULL);

+  ASSERT (Description != NULL);

+  ASSERT (LineNumber  != NULL);

+

+  if (((CodeType & EFI_STATUS_CODE_TYPE_MASK)      == EFI_ERROR_CODE) &&

+      ((CodeType & EFI_STATUS_CODE_SEVERITY_MASK)  == EFI_ERROR_UNRECOVERED) &&

+      ((Value    & EFI_STATUS_CODE_OPERATION_MASK) == EFI_SW_EC_ILLEGAL_SOFTWARE_STATE)) {

+    AssertData   = (EFI_DEBUG_ASSERT_DATA *)(Data + 1);

+    *Filename    = (CHAR8 *)(AssertData + 1);

+    *Description = *Filename + AsciiStrLen (*Filename) + 1;

+    *LineNumber  = AssertData->LineNumber;

+    return TRUE;

+  }

+  return FALSE;

+}

+

+

+/**

+  Extracts DEBUG() information from a status code structure.

+

+  Converts the status code specified by Data to the DEBUG() arguments specified

+  by ErrorLevel, Marker, and Format.  If type GUID in Data is

+  EFI_STATUS_CODE_DATA_TYPE_DEBUG_GUID, then extract ErrorLevel, Marker, and

+  Format from the optional data area of the status code buffer specified by Data.

+  The optional data area of Data contains a 32-bit ErrorLevel followed by Marker

+  which is 12 UINTN parameters, followed by a Null-terminated ASCII string for

+  the Format.  If the DEBUG() information could be extracted from Data, then

+  return TRUE.  Otherwise, FALSE is returned.

+

+  If Data is NULL, then ASSERT().

+  If ErrorLevel is NULL, then ASSERT().

+  If Marker is NULL, then ASSERT().

+  If Format is NULL, then ASSERT().

+

+  @param  Data        Pointer to status code data buffer.

+  @param  ErrorLevel  Pointer to error level mask for a debug message.

+  @param  Marker      Pointer to the variable argument list associated with Format.

+  @param  Format      Pointer to a Null-terminated ASCII format string of a

+                      debug message.

+

+  @retval  TRUE   The status code specified by Data was converted DEBUG() arguments

+                  specified by ErrorLevel, Marker, and Format.

+  @retval  FALSE  The status code specified by Data could not be converted to

+                  DEBUG() arguments.

+

+**/

+BOOLEAN

+EFIAPI

+ReportStatusCodeExtractDebugInfo (

+  IN CONST EFI_STATUS_CODE_DATA  *Data,

+  OUT UINT32                     *ErrorLevel,

+  OUT BASE_LIST                  *Marker,

+  OUT CHAR8                      **Format

+  )

+{

+  EFI_DEBUG_INFO  *DebugInfo;

+

+  ASSERT (Data          != NULL);

+  ASSERT (ErrorLevel    != NULL);

+  ASSERT (Marker     != NULL);

+  ASSERT (Format     != NULL);

+

+  //

+  // If the GUID type is not EFI_STATUS_CODE_DATA_TYPE_DEBUG_GUID then return FALSE

+  //

+  if (!CompareGuid (&Data->Type, &gEfiStatusCodeDataTypeDebugGuid)) {

+    return FALSE;

+  }

+

+  //

+  // Retrieve the debug information from the status code record

+  //

+  DebugInfo = (EFI_DEBUG_INFO *)(Data + 1);

+

+  *ErrorLevel = DebugInfo->ErrorLevel;

+

+  //

+  // The first 12 * UINTN bytes of the string are really an

+  // argument stack to support varargs on the Format string.

+  //

+  *Marker = (BASE_LIST) (DebugInfo + 1);

+  *Format = (CHAR8 *)(((UINT64 *)*Marker) + 12);

+

+  return TRUE;

+}

+

+

+

+

+EFI_STATUS

+EFIAPI

+SerialReportStatusCode (

+  IN EFI_STATUS_CODE_TYPE             CodeType,

+  IN EFI_STATUS_CODE_VALUE            Value,

+  IN UINT32                           Instance,

+  IN CONST EFI_GUID                   *CallerId,

+  IN CONST EFI_STATUS_CODE_DATA       *Data OPTIONAL

+  )

+{

+  CHAR8           *Filename;

+  CHAR8           *Description;

+  CHAR8           *Format;

+  CHAR8           Buffer[EFI_STATUS_CODE_DATA_MAX_SIZE];

+  UINT32          ErrorLevel;

+  UINT32          LineNumber;

+  UINTN           CharCount;

+  BASE_LIST       Marker;

+  EFI_DEBUG_INFO  *DebugInfo;

+

+  Buffer[0] = '\0';

+

+

+  if (Data != NULL &&

+    ReportStatusCodeExtractAssertInfo (CodeType, Value, Data, &Filename, &Description, &LineNumber)) {

+

+    //

+    // Print ASSERT() information into output buffer.

+    //

+    CharCount = AsciiSPrint (

+                  Buffer,

+                  EFI_STATUS_CODE_DATA_MAX_SIZE,

+                  "\n\rASSERT!: %a (%d): %a\n\r",

+                  Filename,

+                  LineNumber,

+                  Description

+                  );

+

+

+    //

+    // Callout to standard output.

+    //

+    SerialPortWrite ((UINT8 *)Buffer, CharCount);

+    return EFI_SUCCESS;

+

+  } else if (Data != NULL &&

+    ReportStatusCodeExtractDebugInfo (Data, &ErrorLevel, &Marker, &Format)) {

+    

+    //

+    // Print DEBUG() information into output buffer.

+    //

+    CharCount = AsciiBSPrint (

+                  Buffer,

+                  EFI_STATUS_CODE_DATA_MAX_SIZE,

+                  Format,

+                  Marker

+                  );

+

+  } else if (Data != NULL &&

+             CompareGuid (&Data->Type, &gEfiStatusCodeSpecificDataGuid) &&

+             (CodeType & EFI_STATUS_CODE_TYPE_MASK) == EFI_DEBUG_CODE) {

+

+    //

+    // Print specific data into output buffer.

+    //

+    DebugInfo = (EFI_DEBUG_INFO *) (Data + 1);

+    Marker    = (BASE_LIST) (DebugInfo + 1);

+    Format    = (CHAR8 *) (((UINT64 *) (DebugInfo + 1)) + 12);

+

+    CharCount = AsciiBSPrint (Buffer, EFI_STATUS_CODE_DATA_MAX_SIZE, Format, Marker);

+

+  } else if ((CodeType & EFI_STATUS_CODE_TYPE_MASK) == EFI_ERROR_CODE) {

+    //

+    // Print ERROR information into output buffer.

+    //

+

+    CharCount = AsciiSPrint (

+                  Buffer,

+                  EFI_STATUS_CODE_DATA_MAX_SIZE,

+                  "ERROR: C%x:V%x I%x",

+                  CodeType,

+                  Value,

+                  Instance

+                  );

+

+    //

+    // Make sure we don't try to print values that weren't intended to be printed, especially NULL GUID pointers.

+    //

+    if (CallerId != NULL) {

+      CharCount += AsciiSPrint (

+                     &Buffer[CharCount - 1],

+                     (EFI_STATUS_CODE_DATA_MAX_SIZE - (sizeof (Buffer[0]) * CharCount)),

+                     " %g",

+                     CallerId

+                     );

+    }

+

+    if (Data != NULL) {

+      CharCount += AsciiSPrint (

+                     &Buffer[CharCount - 1],

+                     (EFI_STATUS_CODE_DATA_MAX_SIZE - (sizeof (Buffer[0]) * CharCount)),

+                     " %x",

+                     Data

+                     );

+

+    }

+

+

+    CharCount += AsciiSPrint (

+                   &Buffer[CharCount - 1],

+                   (EFI_STATUS_CODE_DATA_MAX_SIZE - (sizeof (Buffer[0]) * CharCount)),

+                   "\n\r"

+                   );

+

+  } else if ((CodeType & EFI_STATUS_CODE_TYPE_MASK) == EFI_PROGRESS_CODE) {

+    CharCount = AsciiSPrint (

+                  Buffer,

+                  EFI_STATUS_CODE_DATA_MAX_SIZE,

+                  "PROGRESS CODE: V%x I%x\n\r",

+                  Value,

+                  Instance

+                  );

+  } else {

+    CharCount = AsciiSPrint (

+                  Buffer,

+                  EFI_STATUS_CODE_DATA_MAX_SIZE,

+                  "Undefined: C%x:V%x I%x\n\r",

+                  CodeType,

+                  Value,

+                  Instance

+                  );

+

+  }

+

+  SerialPortWrite ((UINT8 *)Buffer, CharCount);

+  return EFI_SUCCESS;

+

+}

+

+

+VOID

+EFIAPI

+AddDxeCoreReportStatusCodeCallback (

+  VOID

+  )

+{

+  BuildGuidDataHob (&gEfiStatusCodeRuntimeProtocolGuid, &gStatusCode, sizeof(VOID *));

+}

+

diff --git a/EmbeddedPkg/Library/TemplateRealTimeClockLib/TemplateRealTimeClockLib.inf b/EmbeddedPkg/Library/TemplateRealTimeClockLib/TemplateRealTimeClockLib.inf
index b88d9abf..ce0d1325 100644
--- a/EmbeddedPkg/Library/TemplateRealTimeClockLib/TemplateRealTimeClockLib.inf
+++ b/EmbeddedPkg/Library/TemplateRealTimeClockLib/TemplateRealTimeClockLib.inf
@@ -34,4 +34,4 @@
 [LibraryClasses]

   IoLib

   DebugLib

-  
\ No newline at end of file
+  
\ No newline at end of file
diff --git a/EmbeddedPkg/Library/TemplateResetSystemLib/TemplateResetSystemLib.inf b/EmbeddedPkg/Library/TemplateResetSystemLib/TemplateResetSystemLib.inf
index 446c56b3..375cb494 100644
--- a/EmbeddedPkg/Library/TemplateResetSystemLib/TemplateResetSystemLib.inf
+++ b/EmbeddedPkg/Library/TemplateResetSystemLib/TemplateResetSystemLib.inf
@@ -32,4 +32,4 @@
 

 [LibraryClasses]

   IoLib

-  DebugLib
\ No newline at end of file
+  DebugLib
\ No newline at end of file
diff --git a/EmbeddedPkg/Library/TemplateSerialPortExtLib/TemplateSerialPortExtLib.c b/EmbeddedPkg/Library/TemplateSerialPortExtLib/TemplateSerialPortExtLib.c
new file mode 100644
index 00000000..5a007c25
--- /dev/null
+++ b/EmbeddedPkg/Library/TemplateSerialPortExtLib/TemplateSerialPortExtLib.c
@@ -0,0 +1,79 @@
+/** @file

+  Extended Serial I/O Port library functions

+

+  Copyright (c) 2012, ARM Ltd. All rights reserved.

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include <Base.h>

+

+#include <Library/SerialPortLib.h>

+#include <Library/SerialPortExtLib.h>

+

+/**

+  Set the serial device control bits.

+

+  @return    Always return RETURN_UNSUPPORTED.

+

+**/

+RETURN_STATUS

+EFIAPI

+SerialPortSetControl (

+    IN UINT32                   Control

+  )

+{

+  return RETURN_UNSUPPORTED;

+}

+

+/**

+  Get the serial device control bits.

+

+  @param  Control                 Control signals read from the serial device.

+

+  @retval EFI_SUCCESS             The control bits were read from the serial device.

+  @retval EFI_DEVICE_ERROR        The serial device is not functioning correctly.

+

+**/

+RETURN_STATUS

+EFIAPI

+SerialPortGetControl (

+  OUT UINT32                  *Control

+  )

+{

+  if (SerialPortPoll ()) {

+    // If a character is pending don't set EFI_SERIAL_INPUT_BUFFER_EMPTY

+    *Control = EFI_SERIAL_OUTPUT_BUFFER_EMPTY;

+  } else {

+    *Control = EFI_SERIAL_INPUT_BUFFER_EMPTY | EFI_SERIAL_OUTPUT_BUFFER_EMPTY;

+  }

+  return EFI_SUCCESS;

+}

+

+/**

+  Set the serial device attributes.

+

+  @return    Always return RETURN_UNSUPPORTED.

+

+**/

+RETURN_STATUS

+EFIAPI

+SerialPortSetAttributes (

+  IN UINT64              BaudRate,

+  IN UINT32              ReceiveFifoDepth,

+  IN UINT32              Timeout,

+  IN EFI_PARITY_TYPE     Parity,

+  IN UINT8               DataBits,

+  IN EFI_STOP_BITS_TYPE  StopBits

+  )

+{

+  return RETURN_UNSUPPORTED;

+}

+

diff --git a/EmbeddedPkg/Library/TemplateSerialPortExtLib/TemplateSerialPortExtLib.inf b/EmbeddedPkg/Library/TemplateSerialPortExtLib/TemplateSerialPortExtLib.inf
new file mode 100644
index 00000000..2e95405a
--- /dev/null
+++ b/EmbeddedPkg/Library/TemplateSerialPortExtLib/TemplateSerialPortExtLib.inf
@@ -0,0 +1,36 @@
+#/** @file

+# Template for Extended Serial Port Library for UEFI drivers

+#

+# Copyright (c) 2006, Intel Corporation. All rights reserved.<BR>

+# Copyright (c) 2012, ARM Ltd. All rights reserved.<BR>

+#

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution. The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = TemplateSerialPortExtLib

+  FILE_GUID                      = 231fe752-40ac-40b0-8d23-4e341309b964

+  MODULE_TYPE                    = BASE

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = SerialPortExtLib

+

+

+#

+#  VALID_ARCHITECTURES           = ARM IA32 X64 IPF EBC

+#

+

+[Sources.common]

+  TemplateSerialPortExtLib.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  EmbeddedPkg/EmbeddedPkg.dec

+

diff --git a/EmbeddedPkg/Library/TemplateSerialPortLib/TemplateSerialPortLib.c b/EmbeddedPkg/Library/TemplateSerialPortLib/TemplateSerialPortLib.c
index 0110189a..5d9bb073 100644
--- a/EmbeddedPkg/Library/TemplateSerialPortLib/TemplateSerialPortLib.c
+++ b/EmbeddedPkg/Library/TemplateSerialPortLib/TemplateSerialPortLib.c
@@ -18,7 +18,6 @@
 

 

 #include <Library/SerialPortLib.h>

-#include <Library/SerialPortExtLib.h>

 

 /**

 

@@ -37,65 +36,6 @@ SerialPortInitialize (
 }

 

 /**

-  Set the serial device control bits.

-

-  @return    Always return EFI_UNSUPPORTED.

-

-**/

-RETURN_STATUS

-EFIAPI

-SerialPortSetControl (

-    IN UINT32                   Control

-  )

-{

-  return RETURN_UNSUPPORTED;

-}

-

-/**

-  Get the serial device control bits.

-

-  @param  Control                 Control signals read from the serial device.

-

-  @retval EFI_SUCCESS             The control bits were read from the serial device.

-  @retval EFI_DEVICE_ERROR        The serial device is not functioning correctly.

-

-**/

-RETURN_STATUS

-EFIAPI

-SerialPortGetControl (

-  OUT UINT32                  *Control

-  )

-{

-  if (SerialPortPoll ()) {

-    // If a character is pending don't set EFI_SERIAL_INPUT_BUFFER_EMPTY

-    *Control = EFI_SERIAL_OUTPUT_BUFFER_EMPTY;

-  } else {

-    *Control = EFI_SERIAL_INPUT_BUFFER_EMPTY | EFI_SERIAL_OUTPUT_BUFFER_EMPTY;

-  }

-  return EFI_SUCCESS;

-}

-

-/**

-  Set the serial device attributes.

-

-  @return    Always return EFI_UNSUPPORTED.

-

-**/

-RETURN_STATUS

-EFIAPI

-SerialPortSetAttributes (

-  IN OUT  UINT64              *BaudRate,

-  IN OUT  UINT32              *ReceiveFifoDepth,

-  IN OUT  UINT32              *Timeout,

-  IN OUT  EFI_PARITY_TYPE     *Parity,

-  IN OUT  UINT8               *DataBits,

-  IN OUT  EFI_STOP_BITS_TYPE  *StopBits

-  )

-{

-  return RETURN_UNSUPPORTED;

-}

-

-/**

   Write data to serial device.

 

   @param  Buffer           Point of data buffer which need to be written.

diff --git a/EmbeddedPkg/Library/TemplateSerialPortLib/TemplateSerialPortLib.inf b/EmbeddedPkg/Library/TemplateSerialPortLib/TemplateSerialPortLib.inf
index 1bc1fc0e..f1ece196 100644
--- a/EmbeddedPkg/Library/TemplateSerialPortLib/TemplateSerialPortLib.inf
+++ b/EmbeddedPkg/Library/TemplateSerialPortLib/TemplateSerialPortLib.inf
@@ -1,8 +1,8 @@
 #/** @file

-# Memory Status Code Library for UEFI drivers

+# Template for Serial Port Library for UEFI drivers

 #

-# Lib to provide memory journal status code reporting Routines

 # Copyright (c) 2006, Intel Corporation. All rights reserved.<BR>

+# Copyright (c) 2012, ARM Ltd. All rights reserved.<BR>

 #

 #  This program and the accompanying materials

 #  are licensed and made available under the terms and conditions of the BSD License

@@ -18,13 +18,13 @@
   INF_VERSION                    = 0x00010005

   BASE_NAME                      = TemplateSerialPortLib

   FILE_GUID                      = A9133571-AD4B-4457-94A8-A9CC2CE7574F

-  MODULE_TYPE                    = PEIM

+  MODULE_TYPE                    = BASE

   VERSION_STRING                 = 1.0

   LIBRARY_CLASS                  = SerialPortLib

 

 

 #

-#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC

+#  VALID_ARCHITECTURES           = ARM IA32 X64 IPF EBC

 #

 

 [Sources.common]

diff --git a/EmbeddedPkg/MetronomeDxe/Metronome.c b/EmbeddedPkg/MetronomeDxe/Metronome.c
index 8388c4d1..b43bf955 100644
--- a/EmbeddedPkg/MetronomeDxe/Metronome.c
+++ b/EmbeddedPkg/MetronomeDxe/Metronome.c
@@ -1,8 +1,8 @@
 /** @file

 

   Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

-  Copyright (c) 2012, ARM Ltd. All rights reserved.

-  

+  Copyright (c) 2013, ARM Ltd. All rights reserved.

+

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -25,66 +25,33 @@
 

 #include <Protocol/Metronome.h>

 

-

-

-/**

-  The WaitForTick() function waits for the number of ticks specified by 

-  TickNumber from a known time source in the platform.  If TickNumber of 

-  ticks are detected, then EFI_SUCCESS is returned.  The actual time passed 

-  between entry of this function and the first tick is between 0 and 

-  TickPeriod 100 nS units.  If you want to guarantee that at least TickPeriod 

-  time has elapsed, wait for two ticks.  This function waits for a hardware 

-  event to determine when a tick occurs.  It is possible for interrupt 

-  processing, or exception processing to interrupt the execution of the 

-  WaitForTick() function.  Depending on the hardware source for the ticks, it 

-  is possible for a tick to be missed.  This function cannot guarantee that 

-  ticks will not be missed.  If a timeout occurs waiting for the specified 

-  number of ticks, then EFI_TIMEOUT is returned.

-

-  @param  This             The EFI_METRONOME_ARCH_PROTOCOL instance.

-  @param  TickNumber       Number of ticks to wait.

-

-  @retval EFI_SUCCESS           The wait for the number of ticks specified by TickNumber

-                                succeeded.

-  @retval EFI_TIMEOUT           A timeout occurred waiting for the specified number of ticks.

-

-**/

 EFI_STATUS

 EFIAPI

 WaitForTick (

   IN EFI_METRONOME_ARCH_PROTOCOL  *This,

   IN UINT32                       TickNumber

-  )

-{

-  //

-  // Fill me in

-  //

-  MicroSecondDelay (10 * TickNumber);

-  return EFI_UNSUPPORTED;

-}

-

-

+  );

 

 /**

   Interface structure for the Metronome Architectural Protocol.

 

   @par Protocol Description:

   This protocol provides access to a known time source in the platform to the

-  core.  The core uses this known time source to produce core services that 

-  require calibrated delays.  

+  core.  The core uses this known time source to produce core services that

+  require calibrated delays.

 

   @param WaitForTick

-  Waits for a specified number of ticks from a known time source 

-  in the platform.  The actual time passed between entry of this 

-  function and the first tick is between 0 and TickPeriod 100 nS 

-  units.  If you want to guarantee that at least TickPeriod time 

+  Waits for a specified number of ticks from a known time source

+  in the platform.  The actual time passed between entry of this

+  function and the first tick is between 0 and TickPeriod 100 nS

+  units.  If you want to guarantee that at least TickPeriod time

   has elapsed, wait for two ticks.

 

   @param TickPeriod

-  The period of platform's known time source in 100 nS units.  

-  This value on any platform must be at least 10 uS, and must not 

-  exceed 200 uS.  The value in this field is a constant that must 

-  not be modified after the Metronome architectural protocol is 

+  The period of platform's known time source in 100 nS units.

+  This value on any platform must be at least 10 uS, and must not

+  exceed 200 uS.  The value in this field is a constant that must

+  not be modified after the Metronome architectural protocol is

   installed.  All consumers must treat this as a read-only field.

 

 **/

@@ -94,6 +61,45 @@ EFI_METRONOME_ARCH_PROTOCOL gMetronome = {
 };

 

 

+/**

+  The WaitForTick() function waits for the number of ticks specified by

+  TickNumber from a known time source in the platform.  If TickNumber of

+  ticks are detected, then EFI_SUCCESS is returned.  The actual time passed

+  between entry of this function and the first tick is between 0 and

+  TickPeriod 100 nS units.  If you want to guarantee that at least TickPeriod

+  time has elapsed, wait for two ticks.  This function waits for a hardware

+  event to determine when a tick occurs.  It is possible for interrupt

+  processing, or exception processing to interrupt the execution of the

+  WaitForTick() function.  Depending on the hardware source for the ticks, it

+  is possible for a tick to be missed.  This function cannot guarantee that

+  ticks will not be missed.  If a timeout occurs waiting for the specified

+  number of ticks, then EFI_TIMEOUT is returned.

+

+  @param  This             The EFI_METRONOME_ARCH_PROTOCOL instance.

+  @param  TickNumber       Number of ticks to wait.

+

+  @retval EFI_SUCCESS           The wait for the number of ticks specified by TickNumber

+                                succeeded.

+  @retval EFI_TIMEOUT           A timeout occurred waiting for the specified number of ticks.

+

+**/

+EFI_STATUS

+EFIAPI

+WaitForTick (

+  IN EFI_METRONOME_ARCH_PROTOCOL  *This,

+  IN UINT32                       TickNumber

+  )

+{

+  //

+  // Compute how long to stall the CPU.

+  // gMetronome.TickPeriod is in 100 ns units so it needs to be divided by 10

+  // to get it in microseconds units.

+  //

+  MicroSecondDelay (TickNumber * gMetronome.TickPeriod / 10);

+  return EFI_SUCCESS;

+}

+

+

 EFI_HANDLE  gMetronomeHandle = NULL;

 

 

@@ -116,7 +122,7 @@ MetronomeInitialize (
   )

 {

   EFI_STATUS  Status;

-  

+

   //

   // Do any hardware init required to make WaitForTick () to work here.

   //

diff --git a/EmbeddedPkg/SerialDxe/SerialDxe.inf b/EmbeddedPkg/SerialDxe/SerialDxe.inf
index 37e8e0e0..ed7f3773 100644
--- a/EmbeddedPkg/SerialDxe/SerialDxe.inf
+++ b/EmbeddedPkg/SerialDxe/SerialDxe.inf
@@ -39,6 +39,7 @@
   DebugLib

   UefiDriverEntryPoint

   SerialPortLib

+  SerialPortExtLib

 

 [Protocols]

   gEfiSerialIoProtocolGuid    

diff --git a/EmbeddedPkg/TemplateSec/TemplateSec.inf b/EmbeddedPkg/TemplateSec/TemplateSec.inf
index a7dad5e3..81f4ac76 100644
--- a/EmbeddedPkg/TemplateSec/TemplateSec.inf
+++ b/EmbeddedPkg/TemplateSec/TemplateSec.inf
@@ -1,65 +1,65 @@
-#/** @file
-#  
-#    Component description file for DxeIpl module
-#  
-#   The responsibility of this module is to load the DXE Core from a Firmware Volume. This implementation i used to load a 32-bit DXE Core.
-#  
-#  Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = TemplateSec
-  FILE_GUID                      = 1D6F730F-5A55-4078-869B-E0A18324BDC8
-  MODULE_TYPE                    = SEC
-  VERSION_STRING                 = 1.0
-
-
-#
-# The following information is for reference only and not required by the build tools.
-#
-#  VALID_ARCHITECTURES           = IA32 X64 ARM
-#
-
-[Sources.common]
-  TemplateSec.c
-
-[Sources.Ia32]
-#  Ia32/ResetVector.asm | MSFT
-#  Ia32/ResetVector.S   | GCC
-
-[Sources.X64]
-#  X64/ResetVector.asm | MSFT
-#  X64/ResetVector.S   | GCC
-
-[Sources.ARM]
-#  Arm/ResetVector.asm | RVCT
-#  Arm/ResetVector.S   | GCC
-
-[Packages]
-  MdePkg/MdePkg.dec
-  MdeModulePkg/MdeModulePkg.dec
-  EmbeddedPkg/EmbeddedPkg.dec
-  
-
-[LibraryClasses]
-  BaseLib
-  DebugLib
-  BaseMemoryLib
-  UefiDecompressLib
-  PeCoffLib
-  CacheMaintenanceLib
-  PrePiLib
-  
-[Pcd]
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedFdBaseAddress
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedFdSize
-
+#/** @file

+#  

+#    Component description file for DxeIpl module

+#  

+#   The responsibility of this module is to load the DXE Core from a Firmware Volume. This implementation i used to load a 32-bit DXE Core.

+#  

+#  Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = TemplateSec

+  FILE_GUID                      = 1D6F730F-5A55-4078-869B-E0A18324BDC8

+  MODULE_TYPE                    = SEC

+  VERSION_STRING                 = 1.0

+

+

+#

+# The following information is for reference only and not required by the build tools.

+#

+#  VALID_ARCHITECTURES           = IA32 X64 ARM

+#

+

+[Sources.common]

+  TemplateSec.c

+

+[Sources.Ia32]

+#  Ia32/ResetVector.asm | MSFT

+#  Ia32/ResetVector.S   | GCC

+

+[Sources.X64]

+#  X64/ResetVector.asm | MSFT

+#  X64/ResetVector.S   | GCC

+

+[Sources.ARM]

+#  Arm/ResetVector.asm | RVCT

+#  Arm/ResetVector.S   | GCC

+

+[Packages]

+  MdePkg/MdePkg.dec

+  MdeModulePkg/MdeModulePkg.dec

+  EmbeddedPkg/EmbeddedPkg.dec

+  

+

+[LibraryClasses]

+  BaseLib

+  DebugLib

+  BaseMemoryLib

+  UefiDecompressLib

+  PeCoffLib

+  CacheMaintenanceLib

+  PrePiLib

+  

+[Pcd]

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedFdBaseAddress

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedFdSize

+

diff --git a/EmbeddedPkg/Universal/MmcDxe/MmcBlockIo.c b/EmbeddedPkg/Universal/MmcDxe/MmcBlockIo.c
index 839f3a00..9a0320b2 100644
--- a/EmbeddedPkg/Universal/MmcDxe/MmcBlockIo.c
+++ b/EmbeddedPkg/Universal/MmcDxe/MmcBlockIo.c
@@ -1,6 +1,6 @@
 /** @file

 *

-*  Copyright (c) 2011-2012, ARM Limited. All rights reserved.

+*  Copyright (c) 2011-2013, ARM Limited. All rights reserved.

 *  

 *  This program and the accompanying materials                          

 *  are licensed and made available under the terms and conditions of the BSD License         

@@ -40,36 +40,36 @@ PrintOCR (
   IN UINT32 Ocr

   )

 {

-  UINTN minv;

-  UINTN maxv;

-  UINTN volts;

-  UINTN loop;

+  UINTN MinV;

+  UINTN MaxV;

+  UINTN Volts;

+  UINTN Loop;

 

-  minv  = 36;  // 3.6

-  maxv  = 20;  // 2.0

-  volts = 20;  // 2.0

+  MinV  = 36;  // 3.6

+  MaxV  = 20;  // 2.0

+  Volts = 20;  // 2.0

 

   // The MMC register bits [23:8] indicate the working range of the card

-  for (loop = 8; loop < 24; loop++) {

-    if (Ocr & (1 << loop)) {

-      if (minv > volts) minv = volts;

-      if (maxv < volts) maxv = volts + 1;

+  for (Loop = 8; Loop < 24; Loop++) {

+    if (Ocr & (1 << Loop)) {

+      if (MinV > Volts) MinV = Volts;

+      if (MaxV < Volts) MaxV = Volts + 1;

     }

-    volts = volts + 1;

+    Volts = Volts + 1;

   }

 

-  DEBUG((EFI_D_ERROR, "- PrintOCR Ocr (0x%X)\n",Ocr));

-  DEBUG((EFI_D_ERROR, "\t- Card operating voltage: %d.%d to %d.%d\n", minv/10, minv % 10, maxv/10, maxv % 10));

+  DEBUG ((EFI_D_ERROR, "- PrintOCR Ocr (0x%X)\n",Ocr));

+  DEBUG ((EFI_D_ERROR, "\t- Card operating voltage: %d.%d to %d.%d\n", MinV/10, MinV % 10, MaxV/10, MaxV % 10));

   if (((Ocr >> 29) & 3) == 0) {

-    DEBUG((EFI_D_ERROR, "\t- AccessMode: Byte Mode\n"));

+    DEBUG ((EFI_D_ERROR, "\t- AccessMode: Byte Mode\n"));

   } else {

-    DEBUG((EFI_D_ERROR, "\t- AccessMode: Block Mode (0x%X)\n",((Ocr >> 29) & 3)));

+    DEBUG ((EFI_D_ERROR, "\t- AccessMode: Block Mode (0x%X)\n", ((Ocr >> 29) & 3)));

   }

 

   if (Ocr & MMC_OCR_POWERUP) {

-    DEBUG((EFI_D_ERROR, "\t- PowerUp\n"));

+    DEBUG ((EFI_D_ERROR, "\t- PowerUp\n"));

   } else {

-    DEBUG((EFI_D_ERROR, "\t- Voltage Not Supported\n"));

+    DEBUG ((EFI_D_ERROR, "\t- Voltage Not Supported\n"));

   }

 }

 

@@ -77,17 +77,19 @@ VOID PrintCID (
   IN UINT32* Cid

   )

 {

-  DEBUG((EFI_D_ERROR, "- PrintCID\n"));

-  DEBUG((EFI_D_ERROR, "\t- Manufacturing date: %d/%d\n",(Cid[0] >> 8) & 0xF,(Cid[0] >> 12) & 0xFF));

-  DEBUG((EFI_D_ERROR, "\t- Product serial number: 0x%X%X\n",Cid[1] & 0xFFFFFF,(Cid[0] >> 24) & 0xFF));

-  DEBUG((EFI_D_ERROR, "\t- Product revision: %d\n",Cid[1] >> 24));

-  //DEBUG((EFI_D_ERROR, "\t- Product name: %s\n",(char*)(Cid + 2)));

-  DEBUG((EFI_D_ERROR, "\t- OEM ID: %c%c\n",(Cid[3] >> 8) & 0xFF,(Cid[3] >> 16) & 0xFF));

+  DEBUG ((EFI_D_ERROR, "- PrintCID\n"));

+  DEBUG ((EFI_D_ERROR, "\t- Manufacturing date: %d/%d\n", (Cid[0] >> 8) & 0xF, (Cid[0] >> 12) & 0xFF));

+  DEBUG ((EFI_D_ERROR, "\t- Product serial number: 0x%X%X\n", Cid[1] & 0xFFFFFF, (Cid[0] >> 24) & 0xFF));

+  DEBUG ((EFI_D_ERROR, "\t- Product revision: %d\n", Cid[1] >> 24));

+  //DEBUG ((EFI_D_ERROR, "\t- Product name: %s\n", (char*)(Cid + 2)));

+  DEBUG ((EFI_D_ERROR, "\t- OEM ID: %c%c\n", (Cid[3] >> 8) & 0xFF, (Cid[3] >> 16) & 0xFF));

 }

 

 #if !defined(MDEPKG_NDEBUG)

-CONST CHAR8* mStrUnit[] = { "100kbit/s","1Mbit/s","10Mbit/s","100MBit/s","Unkbown","Unkbown","Unkbown","Unkbown" };

-CONST CHAR8* mStrValue[] = { "1.0","1.2","1.3","1.5","2.0","2.5","3.0","3.5","4.0","4.5","5.0","Unknown","Unknown","Unknown","Unknown" };

+CONST CHAR8* mStrUnit[] = { "100kbit/s", "1Mbit/s", "10Mbit/s", "100MBit/s",

+                            "Unknown", "Unknown", "Unknown", "Unknown" };

+CONST CHAR8* mStrValue[] = { "1.0", "1.2", "1.3", "1.5", "2.0", "2.5", "3.0", "3.5", "4.0", "4.5", "5.0",

+                             "Unknown", "Unknown", "Unknown", "Unknown" };

 #endif

 

 VOID

@@ -98,26 +100,26 @@ PrintCSD (
   UINTN Value;

 

   if (((Csd[2] >> 30) & 0x3) == 0) {

-    DEBUG((EFI_D_ERROR, "- PrintCSD Version 1.01-1.10/Version 2.00/Standard Capacity\n"));

+    DEBUG ((EFI_D_ERROR, "- PrintCSD Version 1.01-1.10/Version 2.00/Standard Capacity\n"));

   } else if (((Csd[2] >> 30) & 0x3) == 1) {

-    DEBUG((EFI_D_ERROR, "- PrintCSD Version 2.00/High Capacity\n"));

+    DEBUG ((EFI_D_ERROR, "- PrintCSD Version 2.00/High Capacity\n"));

   } else {

-    DEBUG((EFI_D_ERROR, "- PrintCSD Version Higher than v3.3\n"));

+    DEBUG ((EFI_D_ERROR, "- PrintCSD Version Higher than v3.3\n"));

   }

 

-  DEBUG((EFI_D_ERROR, "\t- Supported card command class: 0x%X\n",MMC_CSD_GET_CCC(Csd)));

-  DEBUG((EFI_D_ERROR, "\t- Speed: %a %a\n",mStrValue[(MMC_CSD_GET_TRANSPEED(Csd) >> 3) & 0xF],mStrUnit[MMC_CSD_GET_TRANSPEED(Csd) & 7]));

-  DEBUG((EFI_D_ERROR, "\t- Maximum Read Data Block: %d\n",2 << (MMC_CSD_GET_READBLLEN(Csd)-1)));

-  DEBUG((EFI_D_ERROR, "\t- Maximum Write Data Block: %d\n",2 << (MMC_CSD_GET_WRITEBLLEN(Csd)-1)));

+  DEBUG ((EFI_D_ERROR, "\t- Supported card command class: 0x%X\n", MMC_CSD_GET_CCC(Csd)));

+  DEBUG ((EFI_D_ERROR, "\t- Speed: %a %a\n",mStrValue[(MMC_CSD_GET_TRANSPEED(Csd) >> 3) & 0xF],mStrUnit[MMC_CSD_GET_TRANSPEED(Csd) & 7]));

+  DEBUG ((EFI_D_ERROR, "\t- Maximum Read Data Block: %d\n",2 << (MMC_CSD_GET_READBLLEN(Csd)-1)));

+  DEBUG ((EFI_D_ERROR, "\t- Maximum Write Data Block: %d\n",2 << (MMC_CSD_GET_WRITEBLLEN(Csd)-1)));

 

   if (!MMC_CSD_GET_FILEFORMATGRP(Csd)) {

-    Value = MMC_CSD_GET_FILEFORMAT(Csd);

-    if (Value == 0)         DEBUG((EFI_D_ERROR, "\t- Format(0): Hard disk-like file system with partition table\n"));

-    else if (Value == 1)    DEBUG((EFI_D_ERROR, "\t- Format(1): DOS FAT (floppy-like) with boot sector only (no partition table)\n"));

-    else if (Value == 2)    DEBUG((EFI_D_ERROR, "\t- Format(2): Universal File Format\n"));

-    else                    DEBUG((EFI_D_ERROR, "\t- Format(3): Others/Unknown\n"));

+    Value = MMC_CSD_GET_FILEFORMAT (Csd);

+    if (Value == 0)         DEBUG ((EFI_D_ERROR, "\t- Format (0): Hard disk-like file system with partition table\n"));

+    else if (Value == 1)    DEBUG ((EFI_D_ERROR, "\t- Format (1): DOS FAT (floppy-like) with boot sector only (no partition table)\n"));

+    else if (Value == 2)    DEBUG ((EFI_D_ERROR, "\t- Format (2): Universal File Format\n"));

+    else                    DEBUG ((EFI_D_ERROR, "\t- Format (3): Others/Unknown\n"));

   } else {

-    DEBUG((EFI_D_ERROR, "\t- Format: Reserved\n"));

+    DEBUG ((EFI_D_ERROR, "\t- Format: Reserved\n"));

   }

 }

 

@@ -126,9 +128,9 @@ PrintRCA (
   IN UINT32 Rca

   )

 {

-  DEBUG((EFI_D_ERROR, "- PrintRCA: 0x%X\n",Rca));

-  DEBUG((EFI_D_ERROR, "\t- Status: 0x%X\n",Rca & 0xFFFF));

-  DEBUG((EFI_D_ERROR, "\t- RCA: 0x%X\n",(Rca >> 16) & 0xFFFF));

+  DEBUG ((EFI_D_ERROR, "- PrintRCA: 0x%X\n", Rca));

+  DEBUG ((EFI_D_ERROR, "\t- Status: 0x%X\n", Rca & 0xFFFF));

+  DEBUG ((EFI_D_ERROR, "\t- RCA: 0x%X\n", (Rca >> 16) & 0xFFFF));

 }

 

 VOID

@@ -136,19 +138,21 @@ PrintResponseR1 (
   IN  UINT32 Response

   )

 {

-  DEBUG((EFI_D_INFO, "Response: 0x%X\n",Response));

-  if (Response & MMC_R0_READY_FOR_DATA)     DEBUG((EFI_D_INFO, "\t- READY_FOR_DATA\n"));

-

-  if (((Response >> 9) & 0xF) == 0)         DEBUG((EFI_D_INFO, "\t- State: Idle\n"));

-  else if (((Response >> 9) & 0xF) == 1)    DEBUG((EFI_D_INFO, "\t- State: Ready\n"));

-  else if (((Response >> 9) & 0xF) == 2)    DEBUG((EFI_D_INFO, "\t- State: Ident\n"));

-  else if (((Response >> 9) & 0xF) == 3)    DEBUG((EFI_D_INFO, "\t- State: StandBy\n"));

-  else if (((Response >> 9) & 0xF) == 4)    DEBUG((EFI_D_INFO, "\t- State: Tran\n"));

-  else if (((Response >> 9) & 0xF) == 5)    DEBUG((EFI_D_INFO, "\t- State: Data\n"));

-  else if (((Response >> 9) & 0xF) == 6)    DEBUG((EFI_D_INFO, "\t- State: Rcv\n"));

-  else if (((Response >> 9) & 0xF) == 7)    DEBUG((EFI_D_INFO, "\t- State: Prg\n"));

-  else if (((Response >> 9) & 0xF) == 8)    DEBUG((EFI_D_INFO, "\t- State: Dis\n"));

-  else                                      DEBUG((EFI_D_INFO, "\t- State: Reserved\n"));

+  DEBUG ((EFI_D_INFO, "Response: 0x%X\n", Response));

+  if (Response & MMC_R0_READY_FOR_DATA) {

+    DEBUG ((EFI_D_INFO, "\t- READY_FOR_DATA\n"));

+  }

+

+  if (((Response >> 9) & 0xF) == 0)         DEBUG ((EFI_D_INFO, "\t- State: Idle\n"));

+  else if (((Response >> 9) & 0xF) == 1)    DEBUG ((EFI_D_INFO, "\t- State: Ready\n"));

+  else if (((Response >> 9) & 0xF) == 2)    DEBUG ((EFI_D_INFO, "\t- State: Ident\n"));

+  else if (((Response >> 9) & 0xF) == 3)    DEBUG ((EFI_D_INFO, "\t- State: StandBy\n"));

+  else if (((Response >> 9) & 0xF) == 4)    DEBUG ((EFI_D_INFO, "\t- State: Tran\n"));

+  else if (((Response >> 9) & 0xF) == 5)    DEBUG ((EFI_D_INFO, "\t- State: Data\n"));

+  else if (((Response >> 9) & 0xF) == 6)    DEBUG ((EFI_D_INFO, "\t- State: Rcv\n"));

+  else if (((Response >> 9) & 0xF) == 7)    DEBUG ((EFI_D_INFO, "\t- State: Prg\n"));

+  else if (((Response >> 9) & 0xF) == 8)    DEBUG ((EFI_D_INFO, "\t- State: Dis\n"));

+  else                                      DEBUG ((EFI_D_INFO, "\t- State: Reserved\n"));

 }

 

 EFI_STATUS

@@ -173,14 +177,14 @@ MmcGetCardStatus(
     //Get the Status of the card.

     CmdArg = MmcHostInstance->CardInfo.RCA << 16;

     Status = MmcHost->SendCommand (MmcHost, MMC_CMD13, CmdArg);

-    if (EFI_ERROR(Status)) {

-      DEBUG((EFI_D_ERROR, "MmcGetCardStatus(MMC_CMD13): Error and Status = %r\n", Status));

+    if (EFI_ERROR (Status)) {

+      DEBUG ((EFI_D_ERROR, "MmcGetCardStatus(MMC_CMD13): Error and Status = %r\n", Status));

       return Status;

     }

 

     //Read Response

-    MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1,Response);

-    PrintResponseR1(Response[0]);

+    MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1, Response);

+    PrintResponseR1 (Response[0]);

   }

 

   return Status;

@@ -211,21 +215,21 @@ MmcIdentificationMode (
   if (MmcHostInstance->State == MmcHwInitializationState) {

     // Initialize the MMC Host HW

     Status = MmcNotifyState (MmcHostInstance, MmcHwInitializationState);

-    if (EFI_ERROR(Status)) {

-      DEBUG((EFI_D_ERROR, "MmcIdentificationMode() : Error MmcHwInitializationState\n"));

+    if (EFI_ERROR (Status)) {

+      DEBUG ((EFI_D_ERROR, "MmcIdentificationMode() : Error MmcHwInitializationState\n"));

       return Status;

     }

   }

 

   Status = MmcHost->SendCommand (MmcHost, MMC_CMD0, 0);

-  if (EFI_ERROR(Status)) {

-    DEBUG((EFI_D_ERROR, "MmcIdentificationMode(MMC_CMD0): Error\n"));

+  if (EFI_ERROR (Status)) {

+    DEBUG ((EFI_D_ERROR, "MmcIdentificationMode(MMC_CMD0): Error\n"));

     return Status;

   }

 

   Status = MmcNotifyState (MmcHostInstance, MmcIdleState);

-  if (EFI_ERROR(Status)) {

-    DEBUG((EFI_D_ERROR, "MmcIdentificationMode() : Error MmcIdleState\n"));

+  if (EFI_ERROR (Status)) {

+    DEBUG ((EFI_D_ERROR, "MmcIdentificationMode() : Error MmcIdleState\n"));

     return Status;

   }

 

@@ -238,7 +242,7 @@ MmcIdentificationMode (
 #endif
   
   if (Status == EFI_SUCCESS) {

-    DEBUG((EFI_D_ERROR, "MmcIdentificationMode(MMC_CMD5): Error - SDIO not supported.\n"));

+    DEBUG ((EFI_D_ERROR, "MmcIdentificationMode(MMC_CMD5): Error - SDIO not supported.\n"));

     return EFI_UNSUPPORTED;

   }

 

@@ -248,8 +252,8 @@ MmcIdentificationMode (
   if (Status == EFI_SUCCESS) {

     DEBUG ((EFI_D_ERROR, "Card is SD2.0 => Supports high capacity\n"));

     IsHCS = TRUE;

-    MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R7,Response);

-    PrintResponseR1(Response[0]);

+    MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R7, Response);

+    PrintResponseR1 (Response[0]);

     //check if it is valid response

     if(Response[0] != CmdArg){

       DEBUG ((EFI_D_ERROR, "The Card is not usable\n"));

@@ -278,8 +282,8 @@ MmcIdentificationMode (
             CmdArg |= BIT30;

         }

         Status = MmcHost->SendCommand (MmcHost, MMC_ACMD41, CmdArg);

-        if (!EFI_ERROR(Status)) {

-          MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_OCR,Response);

+        if (!EFI_ERROR (Status)) {

+          MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_OCR, Response);

           ((UINT32 *) &(MmcHostInstance->CardInfo.OCRData))[0] = Response[0];

         }

     } else {

@@ -287,15 +291,15 @@ MmcIdentificationMode (
         MmcHostInstance->CardInfo.CardType = MMC_CARD;

 

         Status = MmcHost->SendCommand (MmcHost, MMC_CMD1, 0x800000);

-        if (!EFI_ERROR(Status)) {

-          MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_OCR,Response);

+        if (!EFI_ERROR (Status)) {

+          MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_OCR, Response);

           ((UINT32 *) &(MmcHostInstance->CardInfo.OCRData))[0] = Response[0];

         }

     }

 

-    if (!EFI_ERROR(Status)) {

+    if (!EFI_ERROR (Status)) {

       if (!MmcHostInstance->CardInfo.OCRData.PowerUp) {

-          MicroSecondDelay(1);

+          MicroSecondDelay (1);

           Timeout--;

       } else {

           if ((MmcHostInstance->CardInfo.CardType == SD_CARD_2) && (MmcHostInstance->CardInfo.OCRData.AccessMode & BIT1)) {

@@ -305,35 +309,35 @@ MmcIdentificationMode (
           break;  // The MMC/SD card is ready. Continue the Identification Mode

       }

     } else {

-      MicroSecondDelay(1);

+      MicroSecondDelay (1);

       Timeout--;

     }

   }

 

   if (Timeout == 0) {

-    DEBUG((EFI_D_ERROR, "MmcIdentificationMode(): No Card\n"));

+    DEBUG ((EFI_D_ERROR, "MmcIdentificationMode(): No Card\n"));

     return EFI_NO_MEDIA;

   } else {

-    PrintOCR(Response[0]);

+    PrintOCR (Response[0]);

   }

 

   Status = MmcNotifyState (MmcHostInstance, MmcReadyState);

-  if (EFI_ERROR(Status)) {

-    DEBUG((EFI_D_ERROR, "MmcIdentificationMode() : Error MmcReadyState\n"));

+  if (EFI_ERROR (Status)) {

+    DEBUG ((EFI_D_ERROR, "MmcIdentificationMode() : Error MmcReadyState\n"));

     return Status;

   }

 

   Status = MmcHost->SendCommand (MmcHost, MMC_CMD2, 0);

-  if (EFI_ERROR(Status)) {

-    DEBUG((EFI_D_ERROR, "MmcIdentificationMode(MMC_CMD2): Error\n"));

+  if (EFI_ERROR (Status)) {

+    DEBUG ((EFI_D_ERROR, "MmcIdentificationMode(MMC_CMD2): Error\n"));

     return Status;

   }

-  MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_CID,Response);

+  MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_CID, Response);

   PrintCID(Response);

 

   Status = MmcNotifyState (MmcHostInstance, MmcIdentificationState);

-  if (EFI_ERROR(Status)) {

-    DEBUG((EFI_D_ERROR, "MmcIdentificationMode() : Error MmcIdentificationState\n"));

+  if (EFI_ERROR (Status)) {

+    DEBUG ((EFI_D_ERROR, "MmcIdentificationMode() : Error MmcIdentificationState\n"));

     return Status;

   }

 

@@ -344,13 +348,13 @@ MmcIdentificationMode (
   //

   CmdArg = 1;

   Status = MmcHost->SendCommand (MmcHost, MMC_CMD3, CmdArg);

-  if (EFI_ERROR(Status)) {

-    DEBUG((EFI_D_ERROR, "MmcIdentificationMode(MMC_CMD3): Error\n"));

+  if (EFI_ERROR (Status)) {

+    DEBUG ((EFI_D_ERROR, "MmcIdentificationMode(MMC_CMD3): Error\n"));

     return Status;

   }

 

-  MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_RCA,Response);

-  PrintRCA(Response[0]);

+  MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_RCA, Response);

+  PrintRCA (Response[0]);

 

   // For MMC card, RCA is assigned by CMD3 while CMD3 dumps the RCA for SD card

   if (MmcHostInstance->CardInfo.CardType != MMC_CARD) {

@@ -360,8 +364,8 @@ MmcIdentificationMode (
   }

 

   Status = MmcNotifyState (MmcHostInstance, MmcStandByState);

-  if (EFI_ERROR(Status)) {

-    DEBUG((EFI_D_ERROR, "MmcIdentificationMode() : Error MmcStandByState\n"));

+  if (EFI_ERROR (Status)) {

+    DEBUG ((EFI_D_ERROR, "MmcIdentificationMode() : Error MmcStandByState\n"));

     return Status;

   }

 

@@ -385,27 +389,27 @@ EFI_STATUS InitializeMmcDevice (
   //Send a command to get Card specific data

   CmdArg = MmcHostInstance->CardInfo.RCA << 16;

   Status = MmcHost->SendCommand (MmcHost, MMC_CMD9, CmdArg);

-  if (EFI_ERROR(Status)) {

-    DEBUG((EFI_D_ERROR, "MmcIdentificationMode(MMC_CMD9): Error, Status=%r\n", Status));

+  if (EFI_ERROR (Status)) {

+    DEBUG ((EFI_D_ERROR, "MmcIdentificationMode(MMC_CMD9): Error, Status=%r\n", Status));

     return Status;

   }

   //Read Response

-  MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_CSD,Response);

+  MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_CSD, Response);

   PrintCSD(Response);

 

   if (MmcHostInstance->CardInfo.CardType == SD_CARD_2_HIGH) {

-    CardSize = HC_MMC_CSD_GET_DEVICESIZE(Response);

+    CardSize = HC_MMC_CSD_GET_DEVICESIZE (Response);

     NumBlocks = ((CardSize + 1) * 1024);

     BlockSize = 1 << MMC_CSD_GET_READBLLEN(Response);

   } else {

-    CardSize = MMC_CSD_GET_DEVICESIZE(Response);

-    NumBlocks = (CardSize + 1) * (1 << (MMC_CSD_GET_DEVICESIZEMULT(Response) + 2));

+    CardSize = MMC_CSD_GET_DEVICESIZE (Response);

+    NumBlocks = (CardSize + 1) * (1 << (MMC_CSD_GET_DEVICESIZEMULT (Response) + 2));

     BlockSize = 1 << MMC_CSD_GET_READBLLEN(Response);

   }

 

   //For >=2G card, BlockSize may be 1K, but the transfer size is 512 bytes.

   if (BlockSize > 512) {

-    NumBlocks = MultU64x32(NumBlocks, BlockSize/512);

+    NumBlocks = MultU64x32 (NumBlocks, BlockSize/512);

     BlockSize = 512;

   }

 

@@ -417,21 +421,21 @@ EFI_STATUS InitializeMmcDevice (
 

   CmdArg = MmcHostInstance->CardInfo.RCA << 16;

   Status = MmcHost->SendCommand (MmcHost, MMC_CMD7, CmdArg);

-  if (EFI_ERROR(Status)) {

-    DEBUG((EFI_D_ERROR, "MmcIdentificationMode(MMC_CMD7): Error and Status = %r\n", Status));

+  if (EFI_ERROR (Status)) {

+    DEBUG ((EFI_D_ERROR, "MmcIdentificationMode(MMC_CMD7): Error and Status = %r\n", Status));

     return Status;

   }

 

   Status = MmcNotifyState (MmcHostInstance, MmcTransferState);

-  if (EFI_ERROR(Status)) {

-    DEBUG((EFI_D_ERROR, "MmcIdentificationMode() : Error MmcTransferState\n"));

+  if (EFI_ERROR (Status)) {

+    DEBUG ((EFI_D_ERROR, "MmcIdentificationMode() : Error MmcTransferState\n"));

     return Status;

   }

 

   // Set Block Length

   Status = MmcHost->SendCommand (MmcHost, MMC_CMD16, MmcHostInstance->BlockIo.Media->BlockSize);

-  if (EFI_ERROR(Status)) {

-    DEBUG((EFI_D_ERROR, "MmcIdentificationMode(MMC_CMD16): Error MmcHostInstance->BlockIo.Media->BlockSize: %d and Error = %r\n",MmcHostInstance->BlockIo.Media->BlockSize, Status));

+  if (EFI_ERROR (Status)) {

+    DEBUG ((EFI_D_ERROR, "MmcIdentificationMode(MMC_CMD16): Error MmcHostInstance->BlockIo.Media->BlockSize: %d and Error = %r\n", MmcHostInstance->BlockIo.Media->BlockSize, Status));

     return Status;

   }

 

@@ -452,7 +456,7 @@ MmcReset (
 {

   MMC_HOST_INSTANCE       *MmcHostInstance;

 

-  MmcHostInstance = MMC_HOST_INSTANCE_FROM_BLOCK_IO_THIS(This);

+  MmcHostInstance = MMC_HOST_INSTANCE_FROM_BLOCK_IO_THIS (This);

 

   if (MmcHostInstance->MmcHost == NULL) {

     // Nothing to do

@@ -512,10 +516,10 @@ MmcIoBlocks (
   UINTN                   BytesRemainingToBeTransfered;

   UINTN                   BlockCount = 1;

 

-  MmcHostInstance = MMC_HOST_INSTANCE_FROM_BLOCK_IO_THIS(This);

-  ASSERT(MmcHostInstance != 0);

+  MmcHostInstance = MMC_HOST_INSTANCE_FROM_BLOCK_IO_THIS (This);

+  ASSERT (MmcHostInstance != 0);

   MmcHost = MmcHostInstance->MmcHost;

-  ASSERT(MmcHost);

+  ASSERT (MmcHost);

 

   if ((MmcHost == 0)|| (Buffer == NULL)) {

     return EFI_INVALID_PARAMETER;

@@ -552,16 +556,16 @@ MmcIoBlocks (
     Response[0] = 0;

     Timeout = 20;

     while(   (!(Response[0] & MMC_R0_READY_FOR_DATA))

-          && (MMC_R0_CURRENTSTATE(Response) != MMC_R0_STATE_TRAN)

+          && (MMC_R0_CURRENTSTATE (Response) != MMC_R0_STATE_TRAN)

           && Timeout--) {

       Status = MmcHost->SendCommand (MmcHost, MMC_CMD13, CmdArg);

-      if (!EFI_ERROR(Status)) {

-        MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1,Response);

+      if (!EFI_ERROR (Status)) {

+        MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1, Response);

       }

     }

 

     if (0 == Timeout) {

-      DEBUG((EFI_D_ERROR, "The Card is busy\n"));

+      DEBUG ((EFI_D_ERROR, "The Card is busy\n"));

       return EFI_NOT_READY;

     }

 

@@ -588,46 +592,46 @@ MmcIoBlocks (
 #endif

     }

     Status = MmcHost->SendCommand (MmcHost, Cmd, CmdArg);

-    if (EFI_ERROR(Status)) {

-      DEBUG((EFI_D_ERROR, "MmcIoBlocks(MMC_CMD%d): Error %r\n",Cmd, Status));

+    if (EFI_ERROR (Status)) {

+      DEBUG ((EFI_D_ERROR, "MmcIoBlocks(MMC_CMD%d): Error %r\n", Cmd, Status));

       return Status;

     }

 

     if (Transfer == MMC_IOBLOCKS_READ) {

 #ifndef USE_STREAM

       // Read one block of Data

-      Status = MmcHost->ReadBlockData (MmcHost, Lba,This->Media->BlockSize,Buffer);

-      if (EFI_ERROR(Status)) {

-        DEBUG((EFI_D_BLKIO, "MmcIoBlocks(): Error Read Block Data and Status = %r\n", Status));

+      Status = MmcHost->ReadBlockData (MmcHost, Lba, This->Media->BlockSize, Buffer);

+      if (EFI_ERROR (Status)) {

+        DEBUG ((EFI_D_BLKIO, "MmcIoBlocks(): Error Read Block Data and Status = %r\n", Status));

         return Status;

       }

 #else

       //TODO: Read a stream

-      ASSERT(0);

+      ASSERT (0);

 #endif

       Status = MmcNotifyState (MmcHostInstance, MmcProgrammingState);

-      if (EFI_ERROR(Status)) {

-        DEBUG((EFI_D_ERROR, "MmcIoBlocks() : Error MmcProgrammingState\n"));

+      if (EFI_ERROR (Status)) {

+        DEBUG ((EFI_D_ERROR, "MmcIoBlocks() : Error MmcProgrammingState\n"));

         return Status;

       }

     } else {

 #ifndef USE_STREAM

       // Write one block of Data

-      Status = MmcHost->WriteBlockData (MmcHost, Lba,This->Media->BlockSize,Buffer);

-      if (EFI_ERROR(Status)) {

-        DEBUG((EFI_D_BLKIO, "MmcIoBlocks(): Error Write Block Data and Status = %r\n", Status));

+      Status = MmcHost->WriteBlockData (MmcHost, Lba, This->Media->BlockSize, Buffer);

+      if (EFI_ERROR (Status)) {

+        DEBUG ((EFI_D_BLKIO, "MmcIoBlocks(): Error Write Block Data and Status = %r\n", Status));

         return Status;

       }

 #else

       //TODO: Write a stream

-      ASSERT(0);

+      ASSERT (0);

 #endif

     }

 

     // Command 12 - Stop transmission (ends read)

     Status = MmcHost->SendCommand (MmcHost, MMC_CMD12, 0);

-    if (!EFI_ERROR(Status)) {

-      MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1b,Response);

+    if (!EFI_ERROR (Status)) {

+      MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1b, Response);

     }

 

     // Command 13 - Read status and wait for programming to complete (return to tran)

@@ -635,21 +639,21 @@ MmcIoBlocks (
     CmdArg = MmcHostInstance->CardInfo.RCA << 16;

     Response[0] = 0;

     while(   (!(Response[0] & MMC_R0_READY_FOR_DATA))

-          && (MMC_R0_CURRENTSTATE(Response) != MMC_R0_STATE_TRAN)

+          && (MMC_R0_CURRENTSTATE (Response) != MMC_R0_STATE_TRAN)

           && Timeout--) {

       Status = MmcHost->SendCommand (MmcHost, MMC_CMD13, CmdArg);

-      if (!EFI_ERROR(Status)) {

+      if (!EFI_ERROR (Status)) {

         MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1, Response);

         if ((Response[0] & MMC_R0_READY_FOR_DATA)) {

           break;  // Prevents delay once finished

         }

       }

-      NanoSecondDelay(100);

+      NanoSecondDelay (100);

     }

 

     Status = MmcNotifyState (MmcHostInstance, MmcTransferState);

-    if (EFI_ERROR(Status)) {

-      DEBUG((EFI_D_ERROR, "MmcIoBlocks() : Error MmcTransferState\n"));

+    if (EFI_ERROR (Status)) {

+      DEBUG ((EFI_D_ERROR, "MmcIoBlocks() : Error MmcTransferState\n"));

       return Status;

     }

 

@@ -695,4 +699,3 @@ MmcFlushBlocks (
 {

   return EFI_SUCCESS;

 }

-

diff --git a/EmbeddedPkg/Universal/MmcDxe/MmcDxe.inf b/EmbeddedPkg/Universal/MmcDxe/MmcDxe.inf
index 4a21fb49..9deceea9 100644
--- a/EmbeddedPkg/Universal/MmcDxe/MmcDxe.inf
+++ b/EmbeddedPkg/Universal/MmcDxe/MmcDxe.inf
@@ -47,4 +47,4 @@
   gEfiDriverDiagnostics2ProtocolGuid

   

 [Depex]

-  TRUE
\ No newline at end of file
+  TRUE
\ No newline at end of file
diff --git a/FatPkg/FatPei/FatLiteAccess.c b/FatPkg/FatPei/FatLiteAccess.c
index 20537c0f..a409eacb 100644
--- a/FatPkg/FatPei/FatLiteAccess.c
+++ b/FatPkg/FatPei/FatLiteAccess.c
@@ -1,7 +1,7 @@
 /** @file

   FAT file system access routines for FAT recovery PEIM

 

-Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the Software

@@ -471,7 +471,7 @@ FatReadNextDirectoryEntry (
     // We only search for *FILE* in root directory

     // Long file name entry is *NOT* supported

     //

-    if ((DirEntry.Attributes == FAT_ATTR_DIRECTORY) || (DirEntry.Attributes == FAT_ATTR_LFN)) {

+    if (((DirEntry.Attributes & FAT_ATTR_DIRECTORY) == FAT_ATTR_DIRECTORY) || (DirEntry.Attributes == FAT_ATTR_LFN)) {

       continue;

     }

     //

diff --git a/FatPkg/FatPei/FatLiteLib.c b/FatPkg/FatPei/FatLiteLib.c
index 9c93900f..4789e103 100644
--- a/FatPkg/FatPei/FatLiteLib.c
+++ b/FatPkg/FatPei/FatLiteLib.c
@@ -1,7 +1,7 @@
 /** @file

   General purpose supporting routines for FAT recovery PEIM

 

-Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the Software

@@ -313,15 +313,16 @@ EngFatToStr (
   // No DBCS issues, just expand and add null terminate to end of string

   //

   while (*Fat != 0 && FatSize != 0) {

+    if (*Fat == ' ') {

+      break;

+    }

     *String = *Fat;

     String += 1;

     Fat += 1;

     FatSize -= 1;

-    if (*Fat == ' ') {

-      *String = 0;

-      return ;

-    }

   }

+

+  *String = 0;

 }

 

 

diff --git a/IntelFrameworkModulePkg/Bus/Pci/IdeBusDxe/IdeBus.c b/IntelFrameworkModulePkg/Bus/Pci/IdeBusDxe/IdeBus.c
index 597ada26..ab2ec807 100644
--- a/IntelFrameworkModulePkg/Bus/Pci/IdeBusDxe/IdeBus.c
+++ b/IntelFrameworkModulePkg/Bus/Pci/IdeBusDxe/IdeBus.c
@@ -3,7 +3,7 @@
   Child device(Disk, CDROM, etc) enumeration and child handler installation, and 

   driver stop.

     

-  Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -719,6 +719,7 @@ IDEBusDriverBindingStart (
     //

     for (IdeDevice = BeginningIdeDevice; IdeDevice <= EndIdeDevice; IdeDevice++) {

 

+      ASSERT (IdeChannel * 2 + IdeDevice < MAX_IDE_DEVICE);

       if (IdeBusDriverPrivateData->DeviceProcessed[IdeChannel * 2 + IdeDevice]) {

         continue;

       }

@@ -738,6 +739,7 @@ IDEBusDriverBindingStart (
         continue;

       }

 

+      ASSERT (IdeChannel < IdeMaxChannel && IdeDevice < IdeMaxDevice);

       IdeBlkIoDevicePtr = IdeBlkIoDevice[IdeChannel][IdeDevice];

 

       //

diff --git a/IntelFrameworkModulePkg/Csm/BiosThunk/VideoDxe/BiosVideo.c b/IntelFrameworkModulePkg/Csm/BiosThunk/VideoDxe/BiosVideo.c
index 21b3e872..7c718ba4 100644
--- a/IntelFrameworkModulePkg/Csm/BiosThunk/VideoDxe/BiosVideo.c
+++ b/IntelFrameworkModulePkg/Csm/BiosThunk/VideoDxe/BiosVideo.c
@@ -1,7 +1,7 @@
 /** @file

   ConsoleOut Routines that speak VGA.

 

-Copyright (c) 2007 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>

 

 This program and the accompanying materials

 are licensed and made available under the terms and conditions

@@ -1129,49 +1129,79 @@ ParseEdidData (
                  ((EdidDataBlock->EstablishedTimings[2] & 0x80) << 9) ;

     for (Index = 0; Index < VESA_BIOS_EXTENSIONS_EDID_ESTABLISHED_TIMING_MAX_NUMBER; Index ++) {

       if ((TimingBits & 0x1) != 0) {

+        DEBUG ((EFI_D_INFO, "Established Timing: %d x %d\n",

+        mEstablishedEdidTiming[Index].HorizontalResolution, mEstablishedEdidTiming[Index].VerticalResolution));

         ValidEdidTiming->Key[ValidNumber] = CalculateEdidKey (&mEstablishedEdidTiming[Index]);

         ValidNumber ++;

       }

       TimingBits = TimingBits >> 1;

     }

-  } else {

+  }

+

+  //

+  // Parse the standard timing data

+  //

+  BufferIndex = &EdidDataBlock->StandardTimingIdentification[0];

+  for (Index = 0; Index < 8; Index ++) {

     //

-    // If no Established timing data, read the standard timing data

+    // Check if this is a valid Standard Timing entry

+    // VESA documents unused fields should be set to 01h

     //

-    BufferIndex = &EdidDataBlock->StandardTimingIdentification[0];

-    for (Index = 0; Index < 8; Index ++) {

-      if ((BufferIndex[0] != 0x1) && (BufferIndex[1] != 0x1)){

-        //

-        // A valid Standard Timing

-        //

-        HorizontalResolution = (UINT16) (BufferIndex[0] * 8 + 248);

-        AspectRatio = (UINT8) (BufferIndex[1] >> 6);

-        switch (AspectRatio) {

-          case 0:

-            VerticalResolution = (UINT16) (HorizontalResolution / 16 * 10);

-            break;

-          case 1:

-            VerticalResolution = (UINT16) (HorizontalResolution / 4 * 3);

-            break;

-          case 2:

-            VerticalResolution = (UINT16) (HorizontalResolution / 5 * 4);

-            break;

-          case 3:

-            VerticalResolution = (UINT16) (HorizontalResolution / 16 * 9);

-            break;

-          default:

-            VerticalResolution = (UINT16) (HorizontalResolution / 4 * 3);

-            break;

-        }

-        RefreshRate = (UINT8) ((BufferIndex[1] & 0x1f) + 60);

-        TempTiming.HorizontalResolution = HorizontalResolution;

-        TempTiming.VerticalResolution = VerticalResolution;

-        TempTiming.RefreshRate = RefreshRate;

-        ValidEdidTiming->Key[ValidNumber] = CalculateEdidKey (&TempTiming);

-        ValidNumber ++;

+    if ((BufferIndex[0] != 0x1) && (BufferIndex[1] != 0x1)){

+      //

+      // A valid Standard Timing

+      //

+      HorizontalResolution = (UINT16) (BufferIndex[0] * 8 + 248);

+      AspectRatio = (UINT8) (BufferIndex[1] >> 6);

+      switch (AspectRatio) {

+        case 0:

+          VerticalResolution = (UINT16) (HorizontalResolution / 16 * 10);

+          break;

+        case 1:

+          VerticalResolution = (UINT16) (HorizontalResolution / 4 * 3);

+          break;

+        case 2:

+          VerticalResolution = (UINT16) (HorizontalResolution / 5 * 4);

+          break;

+        case 3:

+          VerticalResolution = (UINT16) (HorizontalResolution / 16 * 9);

+          break;

+        default:

+          VerticalResolution = (UINT16) (HorizontalResolution / 4 * 3);

+          break;

       }

-      BufferIndex += 2;

+      RefreshRate = (UINT8) ((BufferIndex[1] & 0x1f) + 60);

+      DEBUG ((EFI_D_INFO, "Standard Timing: %d x %d\n", HorizontalResolution, VerticalResolution));

+      TempTiming.HorizontalResolution = HorizontalResolution;

+      TempTiming.VerticalResolution = VerticalResolution;

+      TempTiming.RefreshRate = RefreshRate;

+      ValidEdidTiming->Key[ValidNumber] = CalculateEdidKey (&TempTiming);

+      ValidNumber ++;

     }

+    BufferIndex += 2;

+  }

+

+  //

+  // Parse the Detailed Timing data

+  //

+  BufferIndex = &EdidDataBlock->DetailedTimingDescriptions[0];

+  for (Index = 0; Index < 4; Index ++, BufferIndex += VESA_BIOS_EXTENSIONS_DETAILED_TIMING_EACH_DESCRIPTOR_SIZE) {

+    if ((BufferIndex[0] == 0x0) && (BufferIndex[1] == 0x0)) {

+      //

+      // Check if this is a valid Detailed Timing Descriptor

+      // If first 2 bytes are zero, it is monitor descriptor other than detailed timing descriptor

+      //

+      continue;

+    }

+    //

+    // Calculate Horizontal and Vertical resolution

+    //

+    TempTiming.HorizontalResolution = ((UINT16)(BufferIndex[4] & 0xF0) << 4) | (BufferIndex[2]);

+    TempTiming.VerticalResolution = ((UINT16)(BufferIndex[7] & 0xF0) << 4) | (BufferIndex[5]);

+    DEBUG ((EFI_D_INFO, "Detailed Timing %d: %d x %d\n",

+            Index, TempTiming.HorizontalResolution, TempTiming.VerticalResolution));

+    ValidEdidTiming->Key[ValidNumber] = CalculateEdidKey (&TempTiming);

+    ValidNumber ++;

   }

 

   ValidEdidTiming->ValidNumber = ValidNumber;

@@ -1550,6 +1580,9 @@ BiosVideoCheckForVbe (
       continue;

     }

 

+    DEBUG ((EFI_D_INFO, "Video Controller Mode 0x%x: %d x %d\n",

+            VbeModeNumber, BiosVideoPrivate->VbeModeInformationBlock->XResolution, BiosVideoPrivate->VbeModeInformationBlock->YResolution));

+

     if (EdidFound && (ValidEdidTiming.ValidNumber > 0)) {

       //

       // EDID exist, check whether this mode match with any mode in EDID

@@ -1557,7 +1590,16 @@ BiosVideoCheckForVbe (
       Timing.HorizontalResolution = BiosVideoPrivate->VbeModeInformationBlock->XResolution;

       Timing.VerticalResolution = BiosVideoPrivate->VbeModeInformationBlock->YResolution;

       if (!SearchEdidTiming (&ValidEdidTiming, &Timing)) {

+        //

+        // When EDID comes from INT10 call, EDID does not include 800x600, 640x480 and 1024x768,

+        // but INT10 can support these modes, we add them into GOP mode.

+        //

+        if ((BiosVideoPrivate->EdidDiscovered.SizeOfEdid != 0) &&

+            !((Timing.HorizontalResolution) == 1024 && (Timing.VerticalResolution == 768)) &&

+            !((Timing.HorizontalResolution) == 800 && (Timing.VerticalResolution == 600)) &&

+            !((Timing.HorizontalResolution) == 640 && (Timing.VerticalResolution == 480))) {

         continue;

+        }

       }

     }

 

@@ -1593,8 +1635,9 @@ BiosVideoCheckForVbe (
     //

     // Record the highest resolution mode to set later

     //

-    if ((BiosVideoPrivate->VbeModeInformationBlock->XResolution >= HighestHorizontalResolution) &&

-        (BiosVideoPrivate->VbeModeInformationBlock->YResolution >= HighestVerticalResolution)) {

+    if ((BiosVideoPrivate->VbeModeInformationBlock->XResolution > HighestHorizontalResolution) ||

+        ((BiosVideoPrivate->VbeModeInformationBlock->XResolution == HighestHorizontalResolution) && 

+         (BiosVideoPrivate->VbeModeInformationBlock->YResolution > HighestVerticalResolution))) {

       HighestHorizontalResolution = BiosVideoPrivate->VbeModeInformationBlock->XResolution;

       HighestVerticalResolution = BiosVideoPrivate->VbeModeInformationBlock->YResolution;

       HighestResolutionMode = ModeNumber;

diff --git a/IntelFrameworkModulePkg/Csm/BiosThunk/VideoDxe/VesaBiosExtensions.h b/IntelFrameworkModulePkg/Csm/BiosThunk/VideoDxe/VesaBiosExtensions.h
index dcda3fcd..25eee692 100644
--- a/IntelFrameworkModulePkg/Csm/BiosThunk/VideoDxe/VesaBiosExtensions.h
+++ b/IntelFrameworkModulePkg/Csm/BiosThunk/VideoDxe/VesaBiosExtensions.h
@@ -1,6 +1,6 @@
 /** @file

 

-Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 

 This program and the accompanying materials

 are licensed and made available under the terms and conditions

@@ -168,6 +168,21 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 #define VESA_BIOS_EXTENSIONS_EDID_BLOCK_SIZE                    128

 #define VESA_BIOS_EXTENSIONS_EDID_ESTABLISHED_TIMING_MAX_NUMBER 17

 

+//

+// Established Timings: 24 possible resolutions

+// Standard Timings: 8 possible resolutions

+// Detailed Timings: 4 possible resolutions

+//

+#define VESA_BIOS_EXTENSIONS_EDID_TIMING_MAX_NUMBER             36

+

+//

+// Timing data size for Established Timings, Standard Timings and Detailed Timings

+//

+#define VESA_BIOS_EXTENSIONS_ESTABLISHED_TIMING_SIZE                  3

+#define VESA_BIOS_EXTENSIONS_STANDARD_TIMING_SIZE                     16

+#define VESA_BIOS_EXTENSIONS_DETAILED_TIMING_EACH_DESCRIPTOR_SIZE     18

+#define VESA_BIOS_EXTENSIONS_DETAILED_TIMING_DESCRIPTOR_MAX_SIZE      72

+

 typedef struct {

   UINT16  HorizontalResolution;

   UINT16  VerticalResolution;

@@ -176,7 +191,7 @@ typedef struct {
 

 typedef struct {

   UINT32  ValidNumber;

-  UINT32  Key[VESA_BIOS_EXTENSIONS_EDID_ESTABLISHED_TIMING_MAX_NUMBER];

+  UINT32  Key[VESA_BIOS_EXTENSIONS_EDID_TIMING_MAX_NUMBER];

 } VESA_BIOS_EXTENSIONS_VALID_EDID_TIMING;

 

 typedef struct {

@@ -203,9 +218,9 @@ typedef struct {
   UINT8   BlueY;                            //Blue-y Bits 9 - 2

   UINT8   WhiteX;                           //White-x Bits 9 - 2

   UINT8   WhiteY;                           //White-x Bits 9 - 2

-  UINT8   EstablishedTimings[3];

-  UINT8   StandardTimingIdentification[16];

-  UINT8   DetailedTimingDescriptions[72];

+  UINT8   EstablishedTimings[VESA_BIOS_EXTENSIONS_ESTABLISHED_TIMING_SIZE];

+  UINT8   StandardTimingIdentification[VESA_BIOS_EXTENSIONS_STANDARD_TIMING_SIZE];

+  UINT8   DetailedTimingDescriptions[VESA_BIOS_EXTENSIONS_DETAILED_TIMING_DESCRIPTOR_MAX_SIZE];

   UINT8   ExtensionFlag;                    //Number of (optional) 128-byte EDID extension blocks to follow

   UINT8   Checksum;

 } VESA_BIOS_EXTENSIONS_EDID_DATA_BLOCK;

diff --git a/IntelFrameworkModulePkg/Csm/LegacyBiosDxe/LegacyBiosInterface.h b/IntelFrameworkModulePkg/Csm/LegacyBiosDxe/LegacyBiosInterface.h
index a63a7257..d60851a4 100644
--- a/IntelFrameworkModulePkg/Csm/LegacyBiosDxe/LegacyBiosInterface.h
+++ b/IntelFrameworkModulePkg/Csm/LegacyBiosDxe/LegacyBiosInterface.h
@@ -1,6 +1,6 @@
 /** @file

 

-Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 

 This program and the accompanying materials

 are licensed and made available under the terms and conditions

@@ -1520,4 +1520,20 @@ InternalLegacyBiosFarCall (
   IN  UINTN                           StackSize

   );

 

+/**

+  Load a legacy PC-AT OpROM for VGA controller.

+

+  @param  Private                Driver private data.

+

+  @retval EFI_SUCCESS            Legacy ROM successfully installed for this device.

+  @retval EFI_DEVICE_ERROR       No VGA device handle found, or native EFI video

+                                 driver cannot be successfully disconnected, or VGA

+                                 thunk driver cannot be successfully connected.

+

+**/

+EFI_STATUS

+LegacyBiosInstallVgaRom (

+  IN  LEGACY_BIOS_INSTANCE            *Private

+  );

+

 #endif

diff --git a/IntelFrameworkModulePkg/Csm/LegacyBiosDxe/LegacyPci.c b/IntelFrameworkModulePkg/Csm/LegacyBiosDxe/LegacyPci.c
index 910ed41b..5b1117eb 100644
--- a/IntelFrameworkModulePkg/Csm/LegacyBiosDxe/LegacyPci.c
+++ b/IntelFrameworkModulePkg/Csm/LegacyBiosDxe/LegacyPci.c
@@ -1,6 +1,6 @@
 /** @file

 

-Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 

 This program and the accompanying materials

 are licensed and made available under the terms and conditions

@@ -1715,6 +1715,20 @@ PciShadowRoms (
     if (!EFI_ERROR (Status)) {

       continue;

     }

+    

+    //

+    // If legacy VBIOS Oprom has not been dispatched before, install legacy VBIOS here.

+    //

+    if (IS_PCI_DISPLAY (&Pci) && Index == 0) {    

+      Status = LegacyBiosInstallVgaRom (Private);

+      //

+      // A return status of EFI_NOT_FOUND is considered valid (No EFI

+      // driver is controlling video).

+      //

+      ASSERT ((Status == EFI_SUCCESS) || (Status == EFI_NOT_FOUND));

+      continue;

+    }

+

     //

     // Install legacy ROM

     //

diff --git a/IntelFrameworkModulePkg/Include/Library/GenericBdsLib.h b/IntelFrameworkModulePkg/Include/Library/GenericBdsLib.h
index b1887b60..ecd68a00 100644
--- a/IntelFrameworkModulePkg/Include/Library/GenericBdsLib.h
+++ b/IntelFrameworkModulePkg/Include/Library/GenericBdsLib.h
@@ -4,7 +4,7 @@
     2) BDS boot device connect interface.

     3) BDS Misc interfaces for mainting boot variable, ouput string.

 

-Copyright (c) 2004 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials are licensed and made available under 

 the terms and conditions of the BSD License that accompanies this distribution.  

 The full text of the license may be found at

@@ -531,30 +531,6 @@ BdsLibConnectConsoleVariable (
   IN  CHAR16                 *ConVarName

   );

 

-/**

-  Connect the console device base on the variable ConVarName, if

-  device path of the ConVarName is multi-instance device path and

-  anyone of the instances is connected success, then this function

-  will return success. 

-  Dispatch service is not called when the handle associate with one 

-  device path node can not be created successfully. Here no driver 

-  dependency is assumed exist, so need not to call this service.

-

-  @param  ConVarName               Console related variable name, ConIn, ConOut,

-                                   ErrOut.

-

-  @retval EFI_NOT_FOUND            There is not any console devices connected

-                                   success

-  @retval EFI_SUCCESS              Success connect any one instance of the console

-                                   device path base on the variable ConVarName.

-

-**/

-EFI_STATUS

-EFIAPI

-BdsLibConnectConsoleVariableWithOutDispatch (

-  IN  CHAR16                 *ConVarName

-  );

-

 //

 // Bds device path related lib functions

 //

diff --git a/IntelFrameworkModulePkg/IntelFrameworkModulePkg.dec b/IntelFrameworkModulePkg/IntelFrameworkModulePkg.dec
index 025ebfb3..9484b5d2 100644
--- a/IntelFrameworkModulePkg/IntelFrameworkModulePkg.dec
+++ b/IntelFrameworkModulePkg/IntelFrameworkModulePkg.dec
@@ -2,7 +2,7 @@
 # Intel Framework Module Package contains the definitions and module implementation

 # which follows Intel EFI Framework Specification.

 #

-# Copyright (c) 2007 - 2012, Intel Corporation. All rights reserved.<BR>

+# Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>

 #

 # This program and the accompanying materials

 # are licensed and made available under the terms and conditions of the BSD License

@@ -147,14 +147,16 @@
   ## The PCD is used to mark whether the machine is in first boot cycle.

   #  TRUE means the machine is in first boot cycle. After completing the first boot,

   #  the PCD's value will be updated to FALSE.

+  #  This PCD should be set as HII type PCD by platform integrator.

   gEfiIntelFrameworkModulePkgTokenSpaceGuid.PcdBootState|TRUE|BOOLEAN|0x0001002f

 

   ## Timeout value for displaying progressing bar in before boot OS.

   #  According to UEFI 2.0 spec, the default TimeOut should be 0xffff.

+  #  This PCD should be set as HII type PCD by platform integrator mapped to variable L"TimeOut" and gEfiGlobalVariableGuid.

   gEfiIntelFrameworkModulePkgTokenSpaceGuid.PcdPlatformBootTimeOut|0xffff|UINT16|0x40000001

 

   ## Error level for hardware recorder. If value 0, platform does not support feature of hardware error record.

-  #  This PCD should be set as HII type PCD by platform integrator mapped to variable L"HwErrRecSupport"

+  #  This PCD should be set as HII type PCD by platform integrator mapped to variable L"HwErrRecSupport" and gEfiGlobalVariableGuid.

   gEfiIntelFrameworkModulePkgTokenSpaceGuid.PcdHardwareErrorRecordLevel|0|UINT16|0x40000002

 

 [PcdsPatchableInModule, PcdsDynamic, PcdsDynamicEx]

@@ -236,4 +238,4 @@
 

   ## This PCD specifies whether to use the optimized timing for best PS2 detection performance.

   #  Note this PCD could be set to TRUE for best boot performance and set to FALSE for best device compatibility.

-  gEfiIntelFrameworkModulePkgTokenSpaceGuid.PcdFastPS2Detection|FALSE|BOOLEAN|0x3000000b
\ No newline at end of file
+  gEfiIntelFrameworkModulePkgTokenSpaceGuid.PcdFastPS2Detection|FALSE|BOOLEAN|0x3000000b

diff --git a/IntelFrameworkModulePkg/Library/GenericBdsLib/BdsConnect.c b/IntelFrameworkModulePkg/Library/GenericBdsLib/BdsConnect.c
index 0e456dd5..f487aa61 100644
--- a/IntelFrameworkModulePkg/Library/GenericBdsLib/BdsConnect.c
+++ b/IntelFrameworkModulePkg/Library/GenericBdsLib/BdsConnect.c
@@ -1,7 +1,7 @@
 /** @file

   BDS Lib functions which relate with connect the device

 

-Copyright (c) 2004 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -65,17 +65,14 @@ BdsLibGenericConnectAll (
   BdsLibConnectAllConsoles ();

 }

 

-

 /**

   This function will create all handles associate with every device

   path node. If the handle associate with one device path node can not

-  be created successfully, Dispatch service which load the missing drivers

-  is called according to input parameter, since in some cases no driver 

-  dependency is assumed exist, so may need not to call this service.

+  be created successfully, then still give chance to do the dispatch,

+  which load the missing drivers if possible.

 

   @param  DevicePathToConnect   The device path which will be connected, it can be

                                 a multi-instance device path

-  @param  NeedDispatch          Whether requires dispatch service during connection 

 

   @retval EFI_SUCCESS           All handles associate with every device path  node

                                 have been created

@@ -85,9 +82,9 @@ BdsLibGenericConnectAll (
 

 **/

 EFI_STATUS

-ConnectDevicePathInternal (

-  IN EFI_DEVICE_PATH_PROTOCOL  *DevicePathToConnect,

-  IN BOOLEAN                   NeedDispatch

+EFIAPI

+BdsLibConnectDevicePath (

+  IN EFI_DEVICE_PATH_PROTOCOL  *DevicePathToConnect

   )

 {

   EFI_STATUS                Status;

@@ -99,11 +96,14 @@ ConnectDevicePathInternal (
   EFI_HANDLE                Handle;

   EFI_HANDLE                PreviousHandle;

   UINTN                     Size;

+  EFI_TPL                   CurrentTpl;

 

   if (DevicePathToConnect == NULL) {

     return EFI_SUCCESS;

   }

 

+  CurrentTpl  = EfiGetCurrentTpl ();

+

   DevicePath        = DuplicateDevicePath (DevicePathToConnect);

   if (DevicePath == NULL) {

     return EFI_OUT_OF_RESOURCES;

@@ -152,7 +152,10 @@ ConnectDevicePathInternal (
           // Status == EFI_SUCCESS means a driver was dispatched

           // Status == EFI_NOT_FOUND means no new drivers were dispatched

           //

-          if (NeedDispatch) {

+          if (CurrentTpl == TPL_APPLICATION) {

+            //

+            // Dispatch calls LoadImage/StartImage which cannot run at TPL > TPL_APPLICATION

+            //

             Status = gDS->Dispatch ();

           } else {

             //

@@ -199,32 +202,6 @@ ConnectDevicePathInternal (
   return Status;

 }

 

-

-/**

-  This function will create all handles associate with every device

-  path node. If the handle associate with one device path node can not

-  be created successfully, then still give chance to do the dispatch,

-  which load the missing drivers if possible.

-

-  @param  DevicePathToConnect   The device path which will be connected, it can be

-                                a multi-instance device path

-

-  @retval EFI_SUCCESS           All handles associate with every device path  node

-                                have been created

-  @retval EFI_OUT_OF_RESOURCES  There is no resource to create new handles

-  @retval EFI_NOT_FOUND         Create the handle associate with one device  path

-                                node failed

-

-**/

-EFI_STATUS

-EFIAPI

-BdsLibConnectDevicePath (

-  IN EFI_DEVICE_PATH_PROTOCOL  *DevicePathToConnect

-  )

-{

-  return ConnectDevicePathInternal(DevicePathToConnect, TRUE);

-}

-

 /**

   This function will connect all current system handles recursively. 

   

diff --git a/IntelFrameworkModulePkg/Library/GenericBdsLib/BdsConsole.c b/IntelFrameworkModulePkg/Library/GenericBdsLib/BdsConsole.c
index fe6d436a..84e4a0e6 100644
--- a/IntelFrameworkModulePkg/Library/GenericBdsLib/BdsConsole.c
+++ b/IntelFrameworkModulePkg/Library/GenericBdsLib/BdsConsole.c
@@ -1,7 +1,7 @@
 /** @file

   BDS Lib functions which contain all the code to connect console device

 

-Copyright (c) 2004 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -182,114 +182,6 @@ UpdateSystemTableConsole (
 }

 

 /**

-  Connect the console device base on the variable ConVarName, if

-  device path of the ConVarName is multi-instance device path and

-  anyone of the instances is connected success, this function will

-  return success. 

-  Dispatch service is called basing on input when the handle associate

-  with one device path node can not be created successfully. Since in

-  some cases we assume driver dependency does not exist and do not 

-  need to call this service.

-

-  @param  ConVarName               Console related variable name, ConIn, ConOut,

-                                   ErrOut.

-  @param  NeedDispatch              Whether requires dispatch service during connection 

-

-  @retval EFI_NOT_FOUND            There is not any console devices connected

-                                   success

-  @retval EFI_SUCCESS              Success connect any one instance of the console

-                                   device path base on the variable ConVarName.

-

-**/

-EFI_STATUS

-ConnectConsoleVariableInternal (

-  IN  CHAR16                 *ConVarName,

-  IN  BOOLEAN                NeedDispatch

-  )

-{

-  EFI_STATUS                Status;

-  EFI_DEVICE_PATH_PROTOCOL  *StartDevicePath;

-  UINTN                     VariableSize;

-  EFI_DEVICE_PATH_PROTOCOL  *Instance;

-  EFI_DEVICE_PATH_PROTOCOL  *Next;

-  EFI_DEVICE_PATH_PROTOCOL  *CopyOfDevicePath;

-  UINTN                     Size;

-  BOOLEAN                   DeviceExist;

-

-  Status      = EFI_SUCCESS;

-  DeviceExist = FALSE;

-

-  //

-  // Check if the console variable exist

-  //

-  StartDevicePath = BdsLibGetVariableAndSize (

-                      ConVarName,

-                      &gEfiGlobalVariableGuid,

-                      &VariableSize

-                      );

-  if (StartDevicePath == NULL) {

-    return EFI_UNSUPPORTED;

-  }

-

-  CopyOfDevicePath = StartDevicePath;

-  do {

-    //

-    // Check every instance of the console variable

-    //

-    Instance  = GetNextDevicePathInstance (&CopyOfDevicePath, &Size);

-    if (Instance == NULL) {

-      FreePool (StartDevicePath);

-      return EFI_UNSUPPORTED;

-    }

-    

-    Next      = Instance;

-    while (!IsDevicePathEndType (Next)) {

-      Next = NextDevicePathNode (Next);

-    }

-

-    SetDevicePathEndNode (Next);

-    //

-    // Connect the USB console

-    // USB console device path is a short-form device path that 

-    //  starts with the first element being a USB WWID

-    //  or a USB Class device path

-    //

-    if ((DevicePathType (Instance) == MESSAGING_DEVICE_PATH) &&

-       ((DevicePathSubType (Instance) == MSG_USB_CLASS_DP)

-       || (DevicePathSubType (Instance) == MSG_USB_WWID_DP)

-       )) {

-      Status = BdsLibConnectUsbDevByShortFormDP (0xFF, Instance);

-      if (!EFI_ERROR (Status)) {

-        DeviceExist = TRUE;

-      }

-    } else {

-      //

-      // Connect the instance device path

-      //

-      Status = ConnectDevicePathInternal (Instance, NeedDispatch);

-

-      if (EFI_ERROR (Status)) {

-        //

-        // Delete the instance from the console varialbe

-        //

-        BdsLibUpdateConsoleVariable (ConVarName, NULL, Instance);

-      } else {

-        DeviceExist = TRUE;

-      }

-    }

-    FreePool(Instance);

-  } while (CopyOfDevicePath != NULL);

-

-  FreePool (StartDevicePath);

-

-  if (!DeviceExist) {

-    return EFI_NOT_FOUND;

-  }

-

-  return EFI_SUCCESS;

-}

-

-/**

   This function update console variable based on ConVarName, it can

   add or remove one specific console device path from the variable

 

@@ -447,35 +339,86 @@ BdsLibConnectConsoleVariable (
   IN  CHAR16                 *ConVarName

   )

 {

-  return ConnectConsoleVariableInternal(ConVarName, TRUE);

-}

+  EFI_STATUS                Status;

+  EFI_DEVICE_PATH_PROTOCOL  *StartDevicePath;

+  UINTN                     VariableSize;

+  EFI_DEVICE_PATH_PROTOCOL  *Instance;

+  EFI_DEVICE_PATH_PROTOCOL  *Next;

+  EFI_DEVICE_PATH_PROTOCOL  *CopyOfDevicePath;

+  UINTN                     Size;

+  BOOLEAN                   DeviceExist;

 

-/**

-  Connect the console device base on the variable ConVarName, if

-  device path of the ConVarName is multi-instance device path and

-  anyone of the instances is connected success, then this function

-  will return success.

-  Dispatch service is not called when the handle associate with one 

-  device path node can not be created successfully. Here no driver 

-  dependency is assumed exist, so need not to call this service.

+  Status      = EFI_SUCCESS;

+  DeviceExist = FALSE;

 

+  //

+  // Check if the console variable exist

+  //

+  StartDevicePath = BdsLibGetVariableAndSize (

+                      ConVarName,

+                      &gEfiGlobalVariableGuid,

+                      &VariableSize

+                      );

+  if (StartDevicePath == NULL) {

+    return EFI_UNSUPPORTED;

+  }

 

-  @param  ConVarName               Console related variable name, ConIn, ConOut,

-                                   ErrOut.

+  CopyOfDevicePath = StartDevicePath;

+  do {

+    //

+    // Check every instance of the console variable

+    //

+    Instance  = GetNextDevicePathInstance (&CopyOfDevicePath, &Size);

+    if (Instance == NULL) {

+      FreePool (StartDevicePath);

+      return EFI_UNSUPPORTED;

+    }

+    

+    Next      = Instance;

+    while (!IsDevicePathEndType (Next)) {

+      Next = NextDevicePathNode (Next);

+    }

 

-  @retval EFI_NOT_FOUND            There is not any console devices connected

-                                   success

-  @retval EFI_SUCCESS              Success connect any one instance of the console

-                                   device path base on the variable ConVarName.

+    SetDevicePathEndNode (Next);

+    //

+    // Connect the USB console

+    // USB console device path is a short-form device path that 

+    //  starts with the first element being a USB WWID

+    //  or a USB Class device path

+    //

+    if ((DevicePathType (Instance) == MESSAGING_DEVICE_PATH) &&

+       ((DevicePathSubType (Instance) == MSG_USB_CLASS_DP)

+       || (DevicePathSubType (Instance) == MSG_USB_WWID_DP)

+       )) {

+      Status = BdsLibConnectUsbDevByShortFormDP (0xFF, Instance);

+      if (!EFI_ERROR (Status)) {

+        DeviceExist = TRUE;

+      }

+    } else {

+      //

+      // Connect the instance device path

+      //

+      Status = BdsLibConnectDevicePath (Instance);

 

-**/

-EFI_STATUS

-EFIAPI

-BdsLibConnectConsoleVariableWithOutDispatch (

-  IN  CHAR16                 *ConVarName

-  )

-{

-  return ConnectConsoleVariableInternal(ConVarName, FALSE);

+      if (EFI_ERROR (Status)) {

+        //

+        // Delete the instance from the console varialbe

+        //

+        BdsLibUpdateConsoleVariable (ConVarName, NULL, Instance);

+      } else {

+        DeviceExist = TRUE;

+      }

+    }

+    FreePool(Instance);

+  } while (CopyOfDevicePath != NULL);

+

+  FreePool (StartDevicePath);

+

+  if (!DeviceExist) {

+    return EFI_NOT_FOUND;

+  }

+

+  return EFI_SUCCESS;

 }

 

 /**

@@ -808,7 +751,10 @@ ConvertBmpToGopBlt (
         ColorMapNum = 0;

         break;

       }

-    if (BmpHeader->ImageOffset - sizeof (BMP_IMAGE_HEADER) != sizeof (BMP_COLOR_MAP) * ColorMapNum) {

+    //

+    // BMP file may has padding data between the bmp header section and the bmp data section.

+    //

+    if (BmpHeader->ImageOffset - sizeof (BMP_IMAGE_HEADER) < sizeof (BMP_COLOR_MAP) * ColorMapNum) {

       return EFI_INVALID_PARAMETER;

     }

   }

diff --git a/IntelFrameworkModulePkg/Library/GenericBdsLib/InternalBdsLib.h b/IntelFrameworkModulePkg/Library/GenericBdsLib/InternalBdsLib.h
index d5b5b3bd..5d51635b 100644
--- a/IntelFrameworkModulePkg/Library/GenericBdsLib/InternalBdsLib.h
+++ b/IntelFrameworkModulePkg/Library/GenericBdsLib/InternalBdsLib.h
@@ -1,7 +1,7 @@
 /** @file

   BDS library definition, include the file and data structure

 

-Copyright (c) 2004 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -158,28 +158,4 @@ ValidateOption (
   UINTN                     VariableSize

   );

 

-/**

-  This function will create all handles associate with every device

-  path node. If the handle associate with one device path node can not

-  be created successfully, Dispatch service which load the missing drivers

-  is called basing on input parameter, since in some cases no driver 

-  dependency is assumed exist, so may need not to call this service.

-

-  @param  DevicePathToConnect   The device path which will be connected, it can be

-                                a multi-instance device path

-  @param  NeedDispatch          Whether requires dispatch service during connection 

-

-  @retval EFI_SUCCESS           All handles associate with every device path  node

-                                have been created

-  @retval EFI_OUT_OF_RESOURCES  There is no resource to create new handles

-  @retval EFI_NOT_FOUND         Create the handle associate with one device  path

-                                node failed

-

-**/

-EFI_STATUS

-ConnectDevicePathInternal (

-  IN EFI_DEVICE_PATH_PROTOCOL  *DevicePathToConnect,

-  IN BOOLEAN                   NeedDispatch

-  );

-

 #endif // _BDS_LIB_H_

diff --git a/IntelFrameworkModulePkg/Universal/Acpi/AcpiS3SaveDxe/AcpiS3Save.c b/IntelFrameworkModulePkg/Universal/Acpi/AcpiS3SaveDxe/AcpiS3Save.c
index 38226d0d..08c6cad6 100644
--- a/IntelFrameworkModulePkg/Universal/Acpi/AcpiS3SaveDxe/AcpiS3Save.c
+++ b/IntelFrameworkModulePkg/Universal/Acpi/AcpiS3SaveDxe/AcpiS3Save.c
@@ -2,7 +2,7 @@
   This is an implementation of the ACPI S3 Save protocol.  This is defined in

   S3 boot path specification 0.9.

 

-Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 

 This program and the accompanying materials

 are licensed and made available under the terms and conditions

@@ -74,8 +74,8 @@ EFI_GUID              mAcpiS3IdtrProfileGuid = {
 **/

 VOID*

 AllocateMemoryBelow4G (

-  IN UINTN      MemoryType,

-  IN UINTN      Size

+  IN EFI_MEMORY_TYPE    MemoryType,

+  IN UINTN              Size

   )

 {

   UINTN                 Pages;

diff --git a/IntelFrameworkModulePkg/Universal/Acpi/AcpiS3SaveDxe/AcpiVariableThunkPlatform.c b/IntelFrameworkModulePkg/Universal/Acpi/AcpiS3SaveDxe/AcpiVariableThunkPlatform.c
index e2cfdbcb..641a0ae0 100644
--- a/IntelFrameworkModulePkg/Universal/Acpi/AcpiS3SaveDxe/AcpiVariableThunkPlatform.c
+++ b/IntelFrameworkModulePkg/Universal/Acpi/AcpiS3SaveDxe/AcpiVariableThunkPlatform.c
@@ -1,7 +1,7 @@
 /** @file

   This is an implementation of the AcpiVariable platform field for ECP platform.

 

-Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 

 This program and the accompanying materials

 are licensed and made available under the terms and conditions

@@ -59,8 +59,8 @@ ACPI_VARIABLE_SET_COMPATIBILITY               *mAcpiVariableSetCompatibility = N
 **/

 VOID*

 AllocateMemoryBelow4G (

-  IN UINTN      MemoryType,

-  IN UINTN      Size

+  IN EFI_MEMORY_TYPE    MemoryType,

+  IN UINTN              Size

   );

 

 /**

diff --git a/IntelFrameworkModulePkg/Universal/BdsDxe/BdsEntry.c b/IntelFrameworkModulePkg/Universal/BdsDxe/BdsEntry.c
index 5486a5c5..6eaec886 100644
--- a/IntelFrameworkModulePkg/Universal/BdsDxe/BdsEntry.c
+++ b/IntelFrameworkModulePkg/Universal/BdsDxe/BdsEntry.c
@@ -5,7 +5,7 @@
   After DxeCore finish DXE phase, gEfiBdsArchProtocolGuid->BdsEntry will be invoked

   to enter BDS phase.

 

-Copyright (c) 2004 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -457,6 +457,8 @@ BdsEntry (
   LIST_ENTRY                      BootOptionList;

   UINTN                           BootNextSize;

   CHAR16                          *FirmwareVendor;

+  EFI_STATUS                      Status;

+  UINT16                          BootTimeOut;

 

   //

   // Insert the performance probe

@@ -486,6 +488,7 @@ BdsEntry (
   //

   // Fixup Tasble CRC after we updated Firmware Vendor and Revision

   //

+  gST->Hdr.CRC32 = 0;

   gBS->CalculateCrc32 ((VOID *)gST, sizeof(EFI_SYSTEM_TABLE), &gST->Hdr.CRC32);

 

   //

@@ -510,6 +513,25 @@ BdsEntry (
   InitializeHwErrRecSupport();

 

   //

+  // Initialize L"Timeout" EFI global variable.

+  //

+  BootTimeOut = PcdGet16 (PcdPlatformBootTimeOut);

+  if (BootTimeOut != 0xFFFF) {

+    //

+    // If time out value equal 0xFFFF, no need set to 0xFFFF to variable area because UEFI specification

+    // define same behavior between no value or 0xFFFF value for L"Timeout".

+    //

+    Status = gRT->SetVariable (

+                    L"Timeout",

+                    &gEfiGlobalVariableGuid,

+                    EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,

+                    sizeof (UINT16),

+                    &BootTimeOut

+                    );

+    ASSERT_EFI_ERROR(Status);

+  }

+

+  //

   // bugbug: platform specific code

   // Initialize the platform specific string and language

   //

diff --git a/IntelFrameworkModulePkg/Universal/BdsDxe/BootMaint/BootMaint.c b/IntelFrameworkModulePkg/Universal/BdsDxe/BootMaint/BootMaint.c
index d1705a0b..44d9b71c 100644
--- a/IntelFrameworkModulePkg/Universal/BdsDxe/BootMaint/BootMaint.c
+++ b/IntelFrameworkModulePkg/Universal/BdsDxe/BootMaint/BootMaint.c
@@ -1,7 +1,7 @@
 /** @file

   The functions for Boot Maintainence Main menu.

 

-Copyright (c) 2004 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -672,7 +672,14 @@ ApplyChangeHandler (
     break;

 

   case FORM_TIME_OUT_ID:

-    PcdSet16 (PcdPlatformBootTimeOut, CurrentFakeNVMap->BootTimeOut);

+    Status = gRT->SetVariable (

+                    L"Timeout",

+                    &gEfiGlobalVariableGuid,

+                    EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,

+                    sizeof (UINT16),

+                    &(CurrentFakeNVMap->BootTimeOut)

+                    );

+    ASSERT_EFI_ERROR(Status);

 

     Private->BmmOldFakeNVData.BootTimeOut = CurrentFakeNVMap->BootTimeOut;

     break;

diff --git a/IntelFrameworkModulePkg/Universal/BdsDxe/FrontPage.c b/IntelFrameworkModulePkg/Universal/BdsDxe/FrontPage.c
index 3dad6bd6..432b2246 100644
--- a/IntelFrameworkModulePkg/Universal/BdsDxe/FrontPage.c
+++ b/IntelFrameworkModulePkg/Universal/BdsDxe/FrontPage.c
@@ -1,7 +1,7 @@
 /** @file

   FrontPage routines to handle the callbacks and browser calls

 

-Copyright (c) 2004 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -21,6 +21,7 @@ BOOLEAN   mModeInitialized = FALSE;
 

 BOOLEAN   gConnectAllHappened = FALSE;

 UINTN     gCallbackKey;

+CHAR8     *mLanguageString;

 

 //

 // Boot video resolution and text mode.

@@ -178,13 +179,10 @@ FrontPageCallback (
   OUT EFI_BROWSER_ACTION_REQUEST             *ActionRequest

   )

 {

-  CHAR8                         *LanguageString;

   CHAR8                         *LangCode;

   CHAR8                         *Lang;

   UINTN                         Index;

   EFI_STATUS                    Status;

-  CHAR8                         *PlatformSupportedLanguages;

-  CHAR8                         *BestLanguage;

 

   if (Action != EFI_BROWSER_ACTION_CHANGING && Action != EFI_BROWSER_ACTION_CHANGED) {

     //

@@ -210,18 +208,13 @@ FrontPageCallback (
 

     case FRONT_PAGE_KEY_LANGUAGE:

       //

-      // Collect the languages from what our current Language support is based on our VFR

-      //

-      LanguageString = HiiGetSupportedLanguages (gFrontPagePrivate.HiiHandle);

-      ASSERT (LanguageString != NULL);

-      //

       // Allocate working buffer for RFC 4646 language in supported LanguageString.

       //

-      Lang = AllocatePool (AsciiStrSize (LanguageString));

-      ASSERT (Lang != NULL);

+      Lang = AllocatePool (AsciiStrSize (mLanguageString));

+      ASSERT (Lang != NULL);  

 

       Index = 0;

-      LangCode = LanguageString;

+      LangCode = mLanguageString;

       while (*LangCode != 0) {

         GetNextLanguage (&LangCode, Lang);

 

@@ -232,43 +225,22 @@ FrontPageCallback (
         Index++;

       }

 

-      GetEfiGlobalVariable2 (L"PlatformLangCodes", (VOID**)&PlatformSupportedLanguages, NULL);

-      if (PlatformSupportedLanguages == NULL) {

-        PlatformSupportedLanguages = AllocateCopyPool (

-                                       AsciiStrSize ((CHAR8 *) PcdGetPtr (PcdUefiVariableDefaultPlatformLangCodes)),

-                                       (CHAR8 *) PcdGetPtr (PcdUefiVariableDefaultPlatformLangCodes)

-                                       );

-        ASSERT (PlatformSupportedLanguages != NULL);

-      }

-

-      //

-      // Select the best language in platform supported Language.

-      //

-      BestLanguage = GetBestLanguage (

-                       PlatformSupportedLanguages,

-                       FALSE,

-                       Lang,

-                       NULL

-                       );

-      if (BestLanguage != NULL) {

+      if (Index == Value->u8) {

         Status = gRT->SetVariable (

                         L"PlatformLang",

                         &gEfiGlobalVariableGuid,

                         EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,

-                        AsciiStrSize (BestLanguage),

+                        AsciiStrSize (Lang),

                         Lang

                         );

         ASSERT_EFI_ERROR(Status);

-        FreePool (BestLanguage);

       } else {

         ASSERT (FALSE);

       }

 

       *ActionRequest = EFI_BROWSER_ACTION_REQUEST_EXIT;

 

-      FreePool (PlatformSupportedLanguages);

       FreePool (Lang);

-      FreePool (LanguageString);

       break;

 

     default:

@@ -328,11 +300,9 @@ InitializeFrontPage (
   )

 {

   EFI_STATUS                  Status;

-  CHAR8                       *LanguageString;

   CHAR8                       *LangCode;

   CHAR8                       *Lang;

   CHAR8                       *CurrentLang;

-  CHAR8                       *BestLanguage;

   UINTN                       OptionCount;

   CHAR16                      *StringBuffer;

   EFI_HII_HANDLE              HiiHandle;

@@ -341,7 +311,11 @@ InitializeFrontPage (
   VOID                        *EndOpCodeHandle;

   EFI_IFR_GUID_LABEL          *StartLabel;

   EFI_IFR_GUID_LABEL          *EndLabel;

-  BOOLEAN                     FirstFlag;

+  EFI_HII_STRING_PROTOCOL     *HiiString;

+  UINTN                       StringSize;

+

+  Lang         = NULL;

+  StringBuffer = NULL;

 

   if (InitializeHiiData) {

     //

@@ -422,62 +396,84 @@ InitializeFrontPage (
   // Collect the languages from what our current Language support is based on our VFR

   //

   HiiHandle = gFrontPagePrivate.HiiHandle;

-  LanguageString = HiiGetSupportedLanguages (HiiHandle);

-  ASSERT (LanguageString != NULL);

-  //

-  // Allocate working buffer for RFC 4646 language in supported LanguageString.

-  //

-  Lang = AllocatePool (AsciiStrSize (LanguageString));

-  ASSERT (Lang != NULL);

 

-  GetEfiGlobalVariable2 (L"PlatformLang", (VOID**)&CurrentLang, NULL);

-  //

-  // Select the best language in LanguageString as the default one.

-  //

-  BestLanguage = GetBestLanguage (

-                   LanguageString,

-                   FALSE,

-                   (CurrentLang != NULL) ? CurrentLang : "",

-                   (CHAR8 *) PcdGetPtr (PcdUefiVariableDefaultPlatformLang),

-                   LanguageString,

-                   NULL

-                   );

+  CurrentLang = GetEfiGlobalVariable (L"PlatformLang");

+

   //

-  // BestLanguage must be selected as it is the first language in LanguageString by default

+  // Get Support language list from variable.

   //

-  ASSERT (BestLanguage != NULL);

-

-  OptionCount = 0;

-  LangCode    = LanguageString;

-  FirstFlag   = FALSE;

+  if (mLanguageString == NULL){

+    mLanguageString = GetEfiGlobalVariable (L"PlatformLangCodes");

+    if (mLanguageString == NULL) {

+      mLanguageString = AllocateCopyPool (

+                                 AsciiStrSize ((CHAR8 *) PcdGetPtr (PcdUefiVariableDefaultPlatformLangCodes)),

+                                 (CHAR8 *) PcdGetPtr (PcdUefiVariableDefaultPlatformLangCodes)

+                                 );

+      ASSERT (mLanguageString != NULL);

+    }

+  }

 

   if (gFrontPagePrivate.LanguageToken == NULL) {

+    //

+    // Count the language list number.

+    //  

+    LangCode      = mLanguageString;

+    Lang          = AllocatePool (AsciiStrSize (mLanguageString));

+    ASSERT (Lang != NULL);

+    OptionCount = 0;

     while (*LangCode != 0) {

       GetNextLanguage (&LangCode, Lang);

       OptionCount ++;

     }

-    gFrontPagePrivate.LanguageToken = AllocatePool (OptionCount * sizeof (EFI_STRING_ID));

+

+    //

+    // Allocate extra 1 as the end tag.

+    //

+    gFrontPagePrivate.LanguageToken = AllocateZeroPool ((OptionCount + 1) * sizeof (EFI_STRING_ID));

     ASSERT (gFrontPagePrivate.LanguageToken != NULL);

-    FirstFlag = TRUE;

-  }

 

-  OptionCount = 0;

-  LangCode = LanguageString;

-  while (*LangCode != 0) {

-    GetNextLanguage (&LangCode, Lang);

+    Status = gBS->LocateProtocol (&gEfiHiiStringProtocolGuid, NULL, (VOID **) &HiiString);

+    ASSERT_EFI_ERROR (Status);

 

-    if (FirstFlag) {

-      StringBuffer = HiiGetString (HiiHandle, PRINTABLE_LANGUAGE_NAME_STRING_ID, Lang);

-      ASSERT (StringBuffer != NULL);

+    LangCode     = mLanguageString;

+    OptionCount  = 0;

+    while (*LangCode != 0) {

+      GetNextLanguage (&LangCode, Lang);

 

-      //

-      // Save the string Id for each language

-      //

+      StringSize = 0;

+      Status = HiiString->GetString (HiiString, Lang, HiiHandle, PRINTABLE_LANGUAGE_NAME_STRING_ID, StringBuffer, &StringSize, NULL);

+      if (Status == EFI_BUFFER_TOO_SMALL) {

+        StringBuffer = AllocateZeroPool (StringSize);

+        ASSERT (StringBuffer != NULL);

+        Status = HiiString->GetString (HiiString, Lang, HiiHandle, PRINTABLE_LANGUAGE_NAME_STRING_ID, StringBuffer, &StringSize, NULL);

+        ASSERT_EFI_ERROR (Status);

+      }

+

+      if (EFI_ERROR (Status)) {

+        StringBuffer = AllocatePool (AsciiStrSize (Lang) * sizeof (CHAR16));

+        ASSERT (StringBuffer != NULL);

+        AsciiStrToUnicodeStr (Lang, StringBuffer);

+      }

+

+      ASSERT (StringBuffer != NULL);

       gFrontPagePrivate.LanguageToken[OptionCount] = HiiSetString (HiiHandle, 0, StringBuffer, NULL);

       FreePool (StringBuffer);

+

+      OptionCount++;

     }

+  }

 

-    if (AsciiStrCmp (Lang, BestLanguage) == 0) {

+  ASSERT (gFrontPagePrivate.LanguageToken != NULL);

+  LangCode     = mLanguageString;

+  OptionCount  = 0;

+  if (Lang == NULL) {

+    Lang = AllocatePool (AsciiStrSize (mLanguageString));

+    ASSERT (Lang != NULL);

+  }

+  while (*LangCode != 0) {

+    GetNextLanguage (&LangCode, Lang);

+

+    if (CurrentLang != NULL && AsciiStrCmp (Lang, CurrentLang) == 0) {

       HiiCreateOneOfOptionOpCode (

         OptionsOpCodeHandle,

         gFrontPagePrivate.LanguageToken[OptionCount],

@@ -501,9 +497,7 @@ InitializeFrontPage (
   if (CurrentLang != NULL) {

     FreePool (CurrentLang);

   }

-  FreePool (BestLanguage);

   FreePool (Lang);

-  FreePool (LanguageString);

 

   HiiCreateOneOfOpCode (

     StartOpCodeHandle,

@@ -1229,6 +1223,10 @@ PlatformBdsEnterFrontPage (
 

   } while ((Status == EFI_SUCCESS) && (gCallbackKey != FRONT_PAGE_KEY_CONTINUE));

 

+  if (mLanguageString != NULL) {

+    FreePool (mLanguageString);

+    mLanguageString = NULL;

+  }

   //

   //Will leave browser, check any reset required change is applied? if yes, reset system

   //

diff --git a/IntelFrameworkModulePkg/Universal/BdsDxe/FrontPageStrings.uni b/IntelFrameworkModulePkg/Universal/BdsDxe/FrontPageStrings.uni
index 20339e43..7af87da9 100644
--- a/IntelFrameworkModulePkg/Universal/BdsDxe/FrontPageStrings.uni
+++ b/IntelFrameworkModulePkg/Universal/BdsDxe/FrontPageStrings.uni
diff --git a/IntelFrameworkModulePkg/Universal/BdsDxe/HwErrRecSupport.c b/IntelFrameworkModulePkg/Universal/BdsDxe/HwErrRecSupport.c
index ee1763b3..ddb2f939 100644
--- a/IntelFrameworkModulePkg/Universal/BdsDxe/HwErrRecSupport.c
+++ b/IntelFrameworkModulePkg/Universal/BdsDxe/HwErrRecSupport.c
@@ -2,7 +2,7 @@
   Set the level of support for Hardware Error Record Persistence that is

   implemented by the platform.

 

-Copyright (c) 2007 - 2008, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -26,17 +26,23 @@ InitializeHwErrRecSupport (
   VOID

   )

 {

-  UINT16 HardwareErrorRecordLevel;

+  EFI_STATUS    Status;

+  UINT16        HardwareErrorRecordLevel;

   

   HardwareErrorRecordLevel = PcdGet16 (PcdHardwareErrorRecordLevel);

   

   if (HardwareErrorRecordLevel != 0) {

     //

-    // Set original value again to make sure this value is stored into variable

-    // area but not PCD database.

-    // if level value equal 0, no need set to 0 to variable area because UEFI specification

-    // define same behavior between no value or 0 value for L"HwErrRecSupport"

+    // If level value equal 0, no need set to 0 to variable area because UEFI specification

+    // define same behavior between no value or 0 value for L"HwErrRecSupport".

     //

-    PcdSet16 (PcdHardwareErrorRecordLevel, HardwareErrorRecordLevel);

+    Status = gRT->SetVariable (

+                    L"HwErrRecSupport",

+                    &gEfiGlobalVariableGuid,

+                    EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,

+                    sizeof (UINT16),

+                    &HardwareErrorRecordLevel

+                    );

+    ASSERT_EFI_ERROR(Status);

   }

 }

diff --git a/MdeModulePkg/Bus/Pci/PciBusDxe/PciEnumerator.c b/MdeModulePkg/Bus/Pci/PciBusDxe/PciEnumerator.c
index c6fe51bf..bd1e6804 100644
--- a/MdeModulePkg/Bus/Pci/PciBusDxe/PciEnumerator.c
+++ b/MdeModulePkg/Bus/Pci/PciBusDxe/PciEnumerator.c
@@ -1,7 +1,7 @@
 /** @file

   PCI eunmeration implementation on entire PCI bus system for PCI Bus module.

 

-Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -794,7 +794,6 @@ RejectPciDevice (
     if (Temp == PciDevice) {

       InitializePciDevice (Temp);

       RemoveEntryList (CurrentLink);

-      FreePciDevice (Temp);

       return EFI_SUCCESS;

     }

 

@@ -1035,6 +1034,11 @@ PciHostBridgeAdjustAllocation (
     //

     Status = RejectPciDevice (PciResNode->PciDev);

     if (Status == EFI_SUCCESS) {

+      DEBUG ((

+        EFI_D_ERROR,

+        "PciBus: [%02x|%02x|%02x] was rejected due to resource confliction.\n",

+        PciResNode->PciDev->BusNumber, PciResNode->PciDev->DeviceNumber, PciResNode->PciDev->FunctionNumber

+        ));

 

       //

       // Raise the EFI_IOB_EC_RESOURCE_CONFLICT status code

@@ -1867,7 +1871,7 @@ NotifyPhase (
                             );

   }

 

-  return EFI_SUCCESS;

+  return Status;

 }

 

 /**

diff --git a/MdeModulePkg/Bus/Pci/PciBusDxe/PciLib.c b/MdeModulePkg/Bus/Pci/PciBusDxe/PciLib.c
index 4e73b8f5..9e1184e0 100644
--- a/MdeModulePkg/Bus/Pci/PciBusDxe/PciLib.c
+++ b/MdeModulePkg/Bus/Pci/PciBusDxe/PciLib.c
@@ -1,7 +1,7 @@
 /** @file

   Internal library implementation for PCI Bus module.

 

-Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -568,6 +568,12 @@ PciHostBridgeResourceAllocator (
                                 RootBridgeDev->Handle,

                                 AcpiConfig

                                 );

+        //

+        // If SubmitResources returns error, PciBus isn't able to start.

+        // It's a fatal error so assertion is added.

+        //

+        DEBUG ((EFI_D_INFO, "PciBus: HostBridge->SubmitResources() - %r\n", Status));

+        ASSERT_EFI_ERROR (Status);

       }

 

       //

@@ -598,6 +604,7 @@ PciHostBridgeResourceAllocator (
     // Notify platform to start to program the resource

     //

     Status = NotifyPhase (PciResAlloc, EfiPciHostBridgeAllocateResources);

+    DEBUG ((EFI_D_INFO, "PciBus: HostBridge->NotifyPhase(AllocateResources) - %r\n", Status));

     if (!FeaturePcdGet (PcdPciBusHotplugDeviceSupport)) {

       //

       // If Hot Plug is not supported

diff --git a/MdeModulePkg/Bus/Pci/XhciDxe/Xhci.c b/MdeModulePkg/Bus/Pci/XhciDxe/Xhci.c
index b8a1d78a..5809a0f9 100644
--- a/MdeModulePkg/Bus/Pci/XhciDxe/Xhci.c
+++ b/MdeModulePkg/Bus/Pci/XhciDxe/Xhci.c
@@ -1,7 +1,7 @@
 /** @file
   The XHCI controller driver.
 
-Copyright (c) 2011 - 2012, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 which accompanies this distribution.  The full text of the license may be found at
@@ -916,7 +916,7 @@ XhcControlTransfer (
       ((Request->RequestType == USB_REQUEST_TYPE (EfiUsbDataIn, USB_REQ_TYPE_STANDARD, USB_TARGET_DEVICE)) || 
       ((Request->RequestType == USB_REQUEST_TYPE (EfiUsbDataIn, USB_REQ_TYPE_CLASS, USB_TARGET_DEVICE))))) {
     DescriptorType = (UINT8)(Request->Value >> 8);
-    if ((DescriptorType == USB_DESC_TYPE_DEVICE) && (*DataLength == sizeof (EFI_USB_DEVICE_DESCRIPTOR))) {
+    if ((DescriptorType == USB_DESC_TYPE_DEVICE) && ((*DataLength == sizeof (EFI_USB_DEVICE_DESCRIPTOR)) || ((DeviceSpeed == EFI_USB_SPEED_FULL) && (*DataLength == 8)))) {
         ASSERT (Data != NULL);
         //
         // Store a copy of device scriptor as hub device need this info to configure endpoint.
diff --git a/MdeModulePkg/Bus/Pci/XhciDxe/XhciSched.c b/MdeModulePkg/Bus/Pci/XhciDxe/XhciSched.c
index b91bdff2..e6c0d156 100644
--- a/MdeModulePkg/Bus/Pci/XhciDxe/XhciSched.c
+++ b/MdeModulePkg/Bus/Pci/XhciDxe/XhciSched.c
@@ -1238,7 +1238,6 @@ XhcMonitorAsyncRequests (
   UINT8                   *ProcBuf;

   URB                     *Urb;

   UINT8                   SlotId;

-  //  EFI_STATUS              Status;
   EFI_TPL                 OldTpl;

 

   OldTpl = gBS->RaiseTPL (XHC_TPL);

@@ -1260,8 +1259,7 @@ XhcMonitorAsyncRequests (
     // Check the result of URB execution. If it is still

     // active, check the next one.

     //

-    XhcCheckUrbResult (Xhc, Urb);
-    //    Status = XhcCheckUrbResult (Xhc, Urb);
+    XhcCheckUrbResult (Xhc, Urb);

 

     if (!Urb->Finished) {

       continue;

@@ -1626,20 +1624,14 @@ XhcCheckNewEvent (
   OUT TRB_TEMPLATE            **NewEvtTrb

   )

 {

-  EFI_STATUS          Status;

-  //  TRB_TEMPLATE        *EvtTrb;
-

   ASSERT (EvtRing != NULL);

 

-  //  EvtTrb     = EvtRing->EventRingDequeue;
   *NewEvtTrb = EvtRing->EventRingDequeue;

 

   if (EvtRing->EventRingDequeue == EvtRing->EventRingEnqueue) {

     return EFI_NOT_READY;

   }

 

-  Status = EFI_SUCCESS;

-

   EvtRing->EventRingDequeue++;

   //

   // If the dequeue pointer is beyond the ring, then roll-back it to the begining of the ring.

@@ -1648,7 +1640,7 @@ XhcCheckNewEvent (
     EvtRing->EventRingDequeue = EvtRing->EventRingSeg0;

   }

 

-  return Status;

+  return EFI_SUCCESS;

 }

 

 /**

diff --git a/MdeModulePkg/Bus/Usb/UsbBusDxe/UsbBus.c b/MdeModulePkg/Bus/Usb/UsbBusDxe/UsbBus.c
index 873cf251..ff6b99c8 100644
--- a/MdeModulePkg/Bus/Usb/UsbBusDxe/UsbBus.c
+++ b/MdeModulePkg/Bus/Usb/UsbBusDxe/UsbBus.c
@@ -2,7 +2,7 @@
 

     Usb Bus Driver Binding and Bus IO Protocol.

 

-Copyright (c) 2004 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -813,6 +813,7 @@ UsbIoPortReset (
   USB_DEVICE              *Dev;

   EFI_TPL                 OldTpl;

   EFI_STATUS              Status;

+  UINT8                   DevAddress;

 

   OldTpl = gBS->RaiseTPL (USB_BUS_TPL);

 

@@ -834,12 +835,17 @@ UsbIoPortReset (
     goto ON_EXIT;

   }

 

+  HubIf->HubApi->ClearPortChange (HubIf, Dev->ParentPort);

+

   //

   // Reset the device to its current address. The device now has an address

   // of ZERO after port reset, so need to set Dev->Address to the device again for

   // host to communicate with it.

   //

-  Status  = UsbSetAddress (Dev, Dev->Address);

+  DevAddress   = Dev->Address;

+  Dev->Address = 0;

+  Status  = UsbSetAddress (Dev, DevAddress);

+  Dev->Address = DevAddress;

 

   gBS->Stall (USB_SET_DEVICE_ADDRESS_STALL);

   

@@ -964,6 +970,7 @@ UsbBusBuildProtocol (
     // The EFI_USB2_HC_PROTOCOL is produced for XHCI support.

     // Then its max supported devices are 256. Otherwise it's 128.

     //

+    ASSERT (UsbBus->Usb2Hc != NULL);

     if (UsbBus->Usb2Hc->MajorRevision == 0x3) {

       UsbBus->MaxDevices = 256;

     }

diff --git a/MdeModulePkg/Bus/Usb/UsbBusDxe/UsbBus.h b/MdeModulePkg/Bus/Usb/UsbBusDxe/UsbBus.h
index 094aea21..d503a278 100644
--- a/MdeModulePkg/Bus/Usb/UsbBusDxe/UsbBus.h
+++ b/MdeModulePkg/Bus/Usb/UsbBusDxe/UsbBus.h
@@ -99,10 +99,19 @@ typedef struct _USB_HUB_API    USB_HUB_API;
 // [USB20-7.1.7.5, it says 10ms for hub and 50ms for

 // root hub]

 //

-#define USB_SET_PORT_RESET_STALL       (10 * USB_BUS_1_MILLISECOND)

+// According to USB2.0, Chapter 11.5.1.5 Resetting,

+// the worst case for TDRST is 20ms

+//

+#define USB_SET_PORT_RESET_STALL       (20 * USB_BUS_1_MILLISECOND)

 #define USB_SET_ROOT_PORT_RESET_STALL  (50 * USB_BUS_1_MILLISECOND)

 

 //

+// Wait for port recovery to accept SetAddress, refers to specification

+// [USB20-7.1.7.5, it says 10 ms for TRSTRCY]

+//

+#define USB_SET_PORT_RECOVERY_STALL    (10 * USB_BUS_1_MILLISECOND)

+

+//

 // Wait for clear roothub port reset, set by experience

 //

 #define USB_CLR_ROOT_PORT_RESET_STALL  (20 * USB_BUS_1_MILLISECOND)

diff --git a/MdeModulePkg/Bus/Usb/UsbBusDxe/UsbDesc.c b/MdeModulePkg/Bus/Usb/UsbBusDxe/UsbDesc.c
index 529b1361..35cdaf55 100644
--- a/MdeModulePkg/Bus/Usb/UsbBusDxe/UsbDesc.c
+++ b/MdeModulePkg/Bus/Usb/UsbBusDxe/UsbDesc.c
@@ -2,7 +2,7 @@
 

     Manage Usb Descriptor List

 

-Copyright (c) 2007, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -360,8 +360,8 @@ UsbParseConfigDesc (
     Setting = UsbParseInterfaceDesc (DescBuf, Len, &Consumed);

 

     if (Setting == NULL) {

-      DEBUG (( EFI_D_ERROR, "UsbParseConfigDesc: failed to parse interface setting\n"));

-      goto ON_ERROR;

+      DEBUG (( EFI_D_ERROR, "UsbParseConfigDesc: warning: failed to get interface setting, stop parsing now.\n"));

+      break;

 

     } else if (Setting->Desc.InterfaceNumber >= NumIf) {

       DEBUG (( EFI_D_ERROR, "UsbParseConfigDesc: mal-formated interface descriptor\n"));

diff --git a/MdeModulePkg/Bus/Usb/UsbBusDxe/UsbEnumer.c b/MdeModulePkg/Bus/Usb/UsbBusDxe/UsbEnumer.c
index 74de7d5d..0aa89617 100644
--- a/MdeModulePkg/Bus/Usb/UsbBusDxe/UsbEnumer.c
+++ b/MdeModulePkg/Bus/Usb/UsbBusDxe/UsbEnumer.c
@@ -2,7 +2,7 @@
 

     Usb bus enumeration support.

 

-Copyright (c) 2007 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -814,14 +814,20 @@ UsbEnumerateNewDev (
   return EFI_SUCCESS;

 

 ON_ERROR:

-  if (Address != Bus->MaxDevices) {

-    Bus->Devices[Address] = NULL;

-  }

-

-  if (Child != NULL) {

-    UsbFreeDevice (Child);

-  }

-

+  //

+  // If reach here, it means the enumeration process on a given port is interrupted due to error.

+  // The s/w resources, including the assigned address(Address) and the allocated usb device data

+  // structure(Bus->Devices[Address]), will NOT be freed here. These resources will be freed when

+  // the device is unplugged from the port or DriverBindingStop() is invoked.

+  //

+  // This way is used to co-work with the lower layer EDKII UHCI/EHCI/XHCI host controller driver.

+  // It's mainly because to keep UEFI spec unchanged EDKII XHCI driver have to maintain a state machine

+  // to keep track of the mapping between actual address and request address. If the request address

+  // (Address) is freed here, the Address value will be used by next enumerated device. Then EDKII XHCI

+  // host controller driver will have wrong information, which will cause further transaction error.

+  //

+  // EDKII UHCI/EHCI doesn't get impacted as it's make sense to reserve s/w resource till it gets unplugged.

+  //

   return Status;

 }

 

diff --git a/MdeModulePkg/Bus/Usb/UsbBusDxe/UsbHub.c b/MdeModulePkg/Bus/Usb/UsbBusDxe/UsbHub.c
index 2d24bb4b..9e5299c0 100644
--- a/MdeModulePkg/Bus/Usb/UsbBusDxe/UsbHub.c
+++ b/MdeModulePkg/Bus/Usb/UsbBusDxe/UsbHub.c
@@ -975,13 +975,13 @@ UsbHubResetPort (
   }

 

   //

-  // Drive the reset signal for at least 10ms. Check USB 2.0 Spec

+  // Drive the reset signal for worst 20ms. Check USB 2.0 Spec

   // section 7.1.7.5 for timing requirements.

   //

   gBS->Stall (USB_SET_PORT_RESET_STALL);

 

   //

-  // USB hub will clear RESET bit if reset is actually finished.

+  // Check USB_PORT_STAT_C_RESET bit to see if the resetting state is done.

   //

   ZeroMem (&PortState, sizeof (EFI_USB_PORT_STATUS));

 

@@ -989,8 +989,8 @@ UsbHubResetPort (
     Status = UsbHubGetPortStatus (HubIf, Port, &PortState);

 

     if (!EFI_ERROR (Status) &&

-        !USB_BIT_IS_SET (PortState.PortStatus, USB_PORT_STAT_RESET)) {

-

+        USB_BIT_IS_SET (PortState.PortChangeStatus, USB_PORT_STAT_C_RESET)) {

+      gBS->Stall (USB_SET_PORT_RECOVERY_STALL);

       return EFI_SUCCESS;

     }

 

diff --git a/MdeModulePkg/Bus/Usb/UsbKbDxe/KeyBoard.c b/MdeModulePkg/Bus/Usb/UsbKbDxe/KeyBoard.c
index beff3431..86dd99d2 100644
--- a/MdeModulePkg/Bus/Usb/UsbKbDxe/KeyBoard.c
+++ b/MdeModulePkg/Bus/Usb/UsbKbDxe/KeyBoard.c
@@ -1,7 +1,7 @@
 /** @file

   Helper functions for USB Keyboard Driver.

 

-Copyright (c) 2004 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -79,6 +79,7 @@ USB_KEYBOARD_LAYOUT_PACK_BIN  mUsbKeyboardLayoutBin = {
     {EfiKeyD11,        '[',      '{',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},

     {EfiKeyD12,        ']',      '}',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},

     {EfiKeyD13,        '\\',     '|',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},

+    {EfiKeyC12,        '\\',     '|',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},

     {EfiKeyC10,        ';',      ':',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},

     {EfiKeyC11,        '\'',     '"',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},

     {EfiKeyE0,         '`',      '~',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},

diff --git a/MdeModulePkg/Bus/Usb/UsbKbDxe/KeyBoard.h b/MdeModulePkg/Bus/Usb/UsbKbDxe/KeyBoard.h
index c41a0727..b3eb3e46 100644
--- a/MdeModulePkg/Bus/Usb/UsbKbDxe/KeyBoard.h
+++ b/MdeModulePkg/Bus/Usb/UsbKbDxe/KeyBoard.h
@@ -1,7 +1,7 @@
 /** @file

   Function prototype for USB Keyboard Driver.

 

-Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -18,7 +18,7 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 

 #include "EfiKey.h"

 

-#define USB_KEYBOARD_KEY_COUNT            104

+#define USB_KEYBOARD_KEY_COUNT            105

 

 #define USB_KEYBOARD_LANGUAGE_STR_LEN     5         // RFC4646 Language Code: "en-US"

 #define USB_KEYBOARD_DESCRIPTION_STR_LEN  (16 + 1)  // Description: "English Keyboard"

diff --git a/MdeModulePkg/Core/Dxe/Dispatcher/Dispatcher.c b/MdeModulePkg/Core/Dxe/Dispatcher/Dispatcher.c
index 45a236a7..75d6267f 100644
--- a/MdeModulePkg/Core/Dxe/Dispatcher/Dispatcher.c
+++ b/MdeModulePkg/Core/Dxe/Dispatcher/Dispatcher.c
@@ -26,7 +26,7 @@
   Depex - Dependency Expresion.

   SOR   - Schedule On Request - Don't schedule if this bit is set.

 

-Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -984,6 +984,7 @@ CoreProcessFvImageFile (
   UINTN                               BufferSize;

   EFI_FIRMWARE_VOLUME_HEADER          *FvHeader;

   UINT32                              FvAlignment;

+  EFI_DEVICE_PATH_PROTOCOL            *FvFileDevicePath;

 

   //

   // Read the first (and only the first) firmware volume section

@@ -1004,6 +1005,32 @@ CoreProcessFvImageFile (
                  &AuthenticationStatus

                  );

   if (!EFI_ERROR (Status)) {

+     //

+    // Evaluate the authentication status of the Firmware Volume through

+    // Security Architectural Protocol

+    //

+    if (gSecurity != NULL) {

+      FvFileDevicePath = CoreFvToDevicePath (Fv, FvHandle, DriverName);

+      Status = gSecurity->FileAuthenticationState (

+                            gSecurity,

+                            AuthenticationStatus,

+                            FvFileDevicePath

+                            );

+      if (FvFileDevicePath != NULL) {

+        FreePool (FvFileDevicePath);

+      }

+

+      if (Status != EFI_SUCCESS) {

+        //

+        // Security check failed. The firmware volume should not be used for any purpose.

+        //

+        if (Buffer != NULL) {

+          FreePool (Buffer);

+        }

+        return Status;

+      }

+    }

+

     //

     // FvImage should be at its required alignment.

     //

@@ -1087,7 +1114,6 @@ CoreFwVolEventProtocolNotify (
 {

   EFI_STATUS                    Status;

   EFI_STATUS                    GetNextFileStatus;

-  EFI_STATUS                    SecurityStatus;

   EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv;

   EFI_DEVICE_PATH_PROTOCOL      *FvDevicePath;

   EFI_HANDLE                    FvHandle;

@@ -1160,24 +1186,6 @@ CoreFwVolEventProtocolNotify (
     }

 

     //

-    // Evaluate the authentication status of the Firmware Volume through

-    // Security Architectural Protocol

-    //

-    if (gSecurity != NULL) {

-      SecurityStatus = gSecurity->FileAuthenticationState (

-                                    gSecurity,

-                                    0,

-                                    FvDevicePath

-                                    );

-      if (SecurityStatus != EFI_SUCCESS) {

-        //

-        // Security check failed. The firmware volume should not be used for any purpose.

-        //

-        continue;

-      }

-    }

-

-    //

     // Discover Drivers in FV and add them to the Discovered Driver List.

     // Process EFI_FV_FILETYPE_DRIVER type and then EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER

     //  EFI_FV_FILETYPE_DXE_CORE is processed to produce a Loaded Image protocol for the core

diff --git a/MdeModulePkg/Core/Dxe/Mem/Page.c b/MdeModulePkg/Core/Dxe/Mem/Page.c
index 6d5a259e..90976a1f 100644
--- a/MdeModulePkg/Core/Dxe/Mem/Page.c
+++ b/MdeModulePkg/Core/Dxe/Mem/Page.c
@@ -1,7 +1,7 @@
 /** @file

   UEFI Memory page management functions.

 

-Copyright (c) 2007 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -177,7 +177,20 @@ CoreAddRange (
   ASSERT_LOCKED (&gMemoryLock);

 

   DEBUG ((DEBUG_PAGE, "AddRange: %lx-%lx to %d\n", Start, End, Type));

-

+  

+  //

+  // If memory of type EfiConventionalMemory is being added that includes the page 

+  // starting at address 0, then zero the page starting at address 0.  This has 

+  // two benifits.  It helps find NULL pointer bugs and it also maximizes 

+  // compatibility with operating systems that may evaluate memory in this page 

+  // for legacy data structures.  If memory of any other type is added starting 

+  // at address 0, then do not zero the page at address 0 because the page is being 

+  // used for other purposes.

+  //  

+  if (Type == EfiConventionalMemory && Start == 0 && (End >= EFI_PAGE_SIZE - 1)) {

+    SetMem ((VOID *)(UINTN)Start, EFI_PAGE_SIZE, 0);

+  }

+  

   //

   // Memory map being altered so updated key

   //

@@ -834,7 +847,18 @@ CoreConvertPages (
     //

     CoreAddRange (NewType, Start, RangeEnd, Attribute);

     if (NewType == EfiConventionalMemory) {

-      DEBUG_CLEAR_MEMORY ((VOID *)(UINTN) Start, (UINTN) (RangeEnd - Start + 1));

+      //

+      // Avoid calling DEBUG_CLEAR_MEMORY() for an address of 0 because this

+      // macro will ASSERT() if address is 0.  Instead, CoreAddRange() guarantees

+      // that the page starting at address 0 is always filled with zeros.

+      //

+      if (Start == 0) {

+        if (RangeEnd > EFI_PAGE_SIZE) {

+          DEBUG_CLEAR_MEMORY ((VOID *)(UINTN) EFI_PAGE_SIZE, (UINTN) (RangeEnd - EFI_PAGE_SIZE + 1));

+        }

+      } else {

+        DEBUG_CLEAR_MEMORY ((VOID *)(UINTN) Start, (UINTN) (RangeEnd - Start + 1));

+      }

     }

 

     //

diff --git a/MdeModulePkg/Core/Pei/Image/Image.c b/MdeModulePkg/Core/Pei/Image/Image.c
index 41069e7a..85e5e3fc 100644
--- a/MdeModulePkg/Core/Pei/Image/Image.c
+++ b/MdeModulePkg/Core/Pei/Image/Image.c
@@ -1,7 +1,7 @@
 /** @file

   Pei Core Load Image Support

 

-Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -348,6 +348,7 @@ LoadAndRelocatePeCoffImage (
   EFI_STATUS                            Status;

   PE_COFF_LOADER_IMAGE_CONTEXT          ImageContext;

   PEI_CORE_INSTANCE                     *Private;

+  UINT64                                AlignImageSize;

 

   Private = PEI_CORE_INSTANCE_FROM_PS_THIS (GetPeiServicesTablePointer ());

 

@@ -377,6 +378,19 @@ LoadAndRelocatePeCoffImage (
   // Allocate Memory for the image when memory is ready, boot mode is not S3, and image is relocatable.

   //

   if ((!ImageContext.RelocationsStripped) && (Private->PeiMemoryInstalled) && (Private->HobList.HandoffInformationTable->BootMode != BOOT_ON_S3_RESUME)) {

+    //

+    // Allocate more buffer to avoid buffer overflow.

+    //

+    if (ImageContext.IsTeImage) {

+      AlignImageSize = ImageContext.ImageSize + ((EFI_TE_IMAGE_HEADER *) Pe32Data)->StrippedSize - sizeof (EFI_TE_IMAGE_HEADER);

+    } else {

+      AlignImageSize = ImageContext.ImageSize;

+    }

+

+    if (ImageContext.SectionAlignment > EFI_PAGE_SIZE) {

+      AlignImageSize += ImageContext.SectionAlignment;

+    }

+

     if (PcdGet64(PcdLoadModuleAtFixAddressEnable) != 0) {

       Status = GetPeCoffImageFixLoadingAssignedAddress(&ImageContext, Private);

       if (EFI_ERROR (Status)){

@@ -384,10 +398,10 @@ LoadAndRelocatePeCoffImage (
         //

         // The PEIM is not assiged valid address, try to allocate page to load it.

         //

-        ImageContext.ImageAddress = (EFI_PHYSICAL_ADDRESS)(UINTN) AllocatePages (EFI_SIZE_TO_PAGES ((UINT32) ImageContext.ImageSize));

+        ImageContext.ImageAddress = (EFI_PHYSICAL_ADDRESS)(UINTN) AllocatePages (EFI_SIZE_TO_PAGES ((UINT32) AlignImageSize));

       }

     } else {

-      ImageContext.ImageAddress = (EFI_PHYSICAL_ADDRESS)(UINTN) AllocatePages (EFI_SIZE_TO_PAGES ((UINT32) ImageContext.ImageSize));

+      ImageContext.ImageAddress = (EFI_PHYSICAL_ADDRESS)(UINTN) AllocatePages (EFI_SIZE_TO_PAGES ((UINT32) AlignImageSize));

     }

     ASSERT (ImageContext.ImageAddress != 0);

     if (ImageContext.ImageAddress == 0) {

@@ -395,6 +409,15 @@ LoadAndRelocatePeCoffImage (
     }

 

     //

+    // Adjust the Image Address to make sure it is section alignment.

+    //

+    if (ImageContext.SectionAlignment > EFI_PAGE_SIZE) {

+      ImageContext.ImageAddress =

+          (ImageContext.ImageAddress + ImageContext.SectionAlignment - 1) &

+          ~((UINTN)ImageContext.SectionAlignment - 1);

+    }

+    //

+    // Fix alignment requirement when Load IPF TeImage into memory.

     // Skip the reserved space for the stripped PeHeader when load TeImage into memory.

     //

     if (ImageContext.IsTeImage) {

diff --git a/MdeModulePkg/Core/PiSmmCore/Dispatcher.c b/MdeModulePkg/Core/PiSmmCore/Dispatcher.c
index 8a9d99b1..b2e3d6a1 100644
--- a/MdeModulePkg/Core/PiSmmCore/Dispatcher.c
+++ b/MdeModulePkg/Core/PiSmmCore/Dispatcher.c
@@ -27,7 +27,7 @@
 

   Depex - Dependency Expresion.

 

-  Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials are licensed and made available 

   under the terms and conditions of the BSD License which accompanies this 

   distribution.  The full text of the license may be found at        

@@ -671,6 +671,9 @@ SmmLoadImage (
   // used the UEFI Boot Services AllocatePool() function

   //

   Status = gBS->FreePool(Buffer);

+  if (!EFI_ERROR (Status) && EFI_ERROR (SecurityStatus)) {

+    Status = SecurityStatus;

+  }

   return Status;  

 }

 

@@ -1197,7 +1200,6 @@ SmmDriverDispatchHandler (
   UINTN                         HandleCount;

   EFI_HANDLE                    *HandleBuffer;

   EFI_STATUS                    GetNextFileStatus;

-  EFI_STATUS                    SecurityStatus;

   EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv;

   EFI_DEVICE_PATH_PROTOCOL      *FvDevicePath;

   EFI_HANDLE                    FvHandle;

@@ -1259,31 +1261,6 @@ SmmDriverDispatchHandler (
     }

 

     //

-    // If the Security Architectural Protocol has not been located yet, then attempt to locate it

-    //

-    if (mSecurity == NULL) {

-      gBS->LocateProtocol (&gEfiSecurityArchProtocolGuid, NULL, (VOID**)&mSecurity);

-    }

-

-    //

-    // Evaluate the authentication status of the Firmware Volume through

-    // Security Architectural Protocol

-    //

-    if (mSecurity != NULL) {

-      SecurityStatus = mSecurity->FileAuthenticationState (

-                                    mSecurity,

-                                    0,

-                                    FvDevicePath

-                                    );

-      if (SecurityStatus != EFI_SUCCESS) {

-        //

-        // Security check failed. The firmware volume should not be used for any purpose.

-        //

-        continue;

-      }

-    }

-

-    //

     // Discover Drivers in FV and add them to the Discovered Driver List.

     // Process EFI_FV_FILETYPE_SMM type and then EFI_FV_FILETYPE_COMBINED_SMM_DXE

     //

diff --git a/MdeModulePkg/Core/PiSmmCore/PiSmmIpl.c b/MdeModulePkg/Core/PiSmmCore/PiSmmIpl.c
index 46864704..86adb134 100644
--- a/MdeModulePkg/Core/PiSmmCore/PiSmmIpl.c
+++ b/MdeModulePkg/Core/PiSmmCore/PiSmmIpl.c
@@ -1,7 +1,7 @@
 /** @file

   SMM IPL that produces SMM related runtime protocols and load the SMM Core into SMRAM

 

-  Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials are licensed and made available 

   under the terms and conditions of the BSD License which accompanies this 

   distribution.  The full text of the license may be found at        

@@ -267,7 +267,7 @@ SMM_IPL_EVENT_NOTIFICATION  mSmmIplEvents[] = {
   // the associated event is immediately signalled, so the notification function will be executed and the 

   // SMM End Of Dxe Protocol will be found if it is already in the handle database.

   //

-  { FALSE, TRUE,  &gEfiEndOfDxeEventGroupGuid,        SmmIplGuidedEventNotify,           &gEfiEndOfDxeEventGroupGuid,        TPL_CALLBACK, NULL },

+  { FALSE, FALSE,  &gEfiEndOfDxeEventGroupGuid,        SmmIplGuidedEventNotify,           &gEfiEndOfDxeEventGroupGuid,        TPL_CALLBACK, NULL },

   //

   // Declare event notification on the DXE Dispatch Event Group.  This event is signaled by the DXE Core

   // each time the DXE Core dispatcher has completed its work.  When this event is signalled, the SMM Core

diff --git a/MdeModulePkg/Core/PiSmmCore/Smi.c b/MdeModulePkg/Core/PiSmmCore/Smi.c
index 1111959c..816d0f51 100644
--- a/MdeModulePkg/Core/PiSmmCore/Smi.c
+++ b/MdeModulePkg/Core/PiSmmCore/Smi.c
@@ -1,7 +1,7 @@
 /** @file

   SMI management.

 

-  Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials are licensed and made available 

   under the terms and conditions of the BSD License which accompanies this 

   distribution.  The full text of the license may be found at        

@@ -128,11 +128,11 @@ SmiManage (
   LIST_ENTRY   *Head;

   SMI_ENTRY    *SmiEntry;

   SMI_HANDLER  *SmiHandler;

-  BOOLEAN      InterruptQuiesced;

+  BOOLEAN      SuccessReturn;

   EFI_STATUS   Status;

   

   Status = EFI_NOT_FOUND;

-  InterruptQuiesced = FALSE;

+  SuccessReturn = FALSE;

   if (HandlerType == NULL) {

     //

     // Root SMI handler

@@ -167,8 +167,8 @@ SmiManage (
     switch (Status) {

     case EFI_INTERRUPT_PENDING:

       //

-      // If a handler returns EFI_INTERRUPT_PENDING then no additional handlers 

-      // will be processed and EFI_INTERRUPT_PENDING will be returned.

+      // If a handler returns EFI_INTERRUPT_PENDING and HandlerType is not NULL then

+      // no additional handlers will be processed and EFI_INTERRUPT_PENDING will be returned.

       //

       if (HandlerType != NULL) {

         return EFI_INTERRUPT_PENDING;

@@ -177,12 +177,14 @@ SmiManage (
 

     case EFI_SUCCESS:

       //

-      // If a handler returns EFI_SUCCESS then no additional handlers will be processed.

-      // then the function will return EFI_SUCCESS.

+      // If at least one of the handlers returns EFI_SUCCESS then the function will return

+      // EFI_SUCCESS. If a handler returns EFI_SUCCESS and HandlerType is not NULL then no

+      // additional handlers will be processed.

       //

       if (HandlerType != NULL) {

         return EFI_SUCCESS;

       }

+      SuccessReturn = TRUE;

       break;

 

     case EFI_WARN_INTERRUPT_SOURCE_QUIESCED:

@@ -190,7 +192,7 @@ SmiManage (
       // If at least one of the handlers returns EFI_WARN_INTERRUPT_SOURCE_QUIESCED

       // then the function will return EFI_SUCCESS. 

       //

-      InterruptQuiesced = TRUE;

+      SuccessReturn = TRUE;

       break;

 

     case EFI_WARN_INTERRUPT_SOURCE_PENDING:

@@ -209,7 +211,7 @@ SmiManage (
     }

   }

 

-  if (InterruptQuiesced) {

+  if (SuccessReturn) {

     Status = EFI_SUCCESS;

   }

 

diff --git a/MdeModulePkg/Include/Library/HiiLib.h b/MdeModulePkg/Include/Library/HiiLib.h
index 7860ccbf..1bdcbfe5 100644
--- a/MdeModulePkg/Include/Library/HiiLib.h
+++ b/MdeModulePkg/Include/Library/HiiLib.h
@@ -1,7 +1,7 @@
 /** @file

   Public include file for the HII Library

 

-Copyright (c) 2007 - 2011, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials are licensed and made available under 

 the terms and conditions of the BSD License that accompanies this distribution.  

 The full text of the license may be found at

@@ -680,6 +680,49 @@ HiiCreateGotoOpCode (
   );

 

 /**

+  Create EFI_IFR_REF_OP, EFI_IFR_REF2_OP, EFI_IFR_REF3_OP and EFI_IFR_REF4_OP opcode.

+

+  When RefDevicePath is not zero, EFI_IFR_REF4 opcode will be created. 

+  When RefDevicePath is zero and RefFormSetId is not NULL, EFI_IFR_REF3 opcode will be created.

+  When RefDevicePath is zero, RefFormSetId is NULL and RefQuestionId is not zero, EFI_IFR_REF2 opcode will be created.

+  When RefDevicePath is zero, RefFormSetId is NULL and RefQuestionId is zero, EFI_IFR_REF opcode will be created.

+

+  If OpCodeHandle is NULL, then ASSERT().

+  If any reserved bits are set in QuestionFlags, then ASSERT().

+

+  @param[in]  OpCodeHandle   The handle to the buffer of opcodes.

+  @param[in]  RefFormId      The Destination Form ID.

+  @param[in]  Prompt         The string ID for Prompt.

+  @param[in]  Help           The string ID for Help.

+  @param[in]  QuestionFlags  The flags in Question Header

+  @param[in]  QuestionId     Question ID.

+  @param[in]  RefQuestionId  The question on the form to which this link is referring. 

+                             If its value is zero, then the link refers to the top of the form.

+  @param[in]  RefFormSetId   The form set to which this link is referring. If its value is NULL, and RefDevicePath is 

+                             zero, then the link is to the current form set.

+  @param[in]  RefDevicePath  The string identifier that specifies the string containing the text representation of 

+                             the device path to which the form set containing the form specified by FormId.

+                             If its value is zero, then the link refers to the current page.

+

+  @retval NULL   There is not enough space left in Buffer to add the opcode.

+  @retval Other  A pointer to the created opcode.

+

+**/

+UINT8 *

+EFIAPI

+HiiCreateGotoExOpCode (

+  IN VOID             *OpCodeHandle,

+  IN EFI_FORM_ID      RefFormId,

+  IN EFI_STRING_ID    Prompt,

+  IN EFI_STRING_ID    Help,

+  IN UINT8            QuestionFlags,

+  IN EFI_QUESTION_ID  QuestionId,

+  IN EFI_QUESTION_ID  RefQuestionId,

+  IN EFI_GUID         *RefFormSetId,    OPTIONAL

+  IN EFI_STRING_ID    RefDevicePath

+  );

+

+/**

   Create EFI_IFR_CHECKBOX_OP opcode.

 

   If OpCodeHandle is NULL, then ASSERT().

diff --git a/MdeModulePkg/Library/DxeSecurityManagementLib/DxeSecurityManagementLib.c b/MdeModulePkg/Library/DxeSecurityManagementLib/DxeSecurityManagementLib.c
index 9af05a44..6a50937a 100644
--- a/MdeModulePkg/Library/DxeSecurityManagementLib/DxeSecurityManagementLib.c
+++ b/MdeModulePkg/Library/DxeSecurityManagementLib/DxeSecurityManagementLib.c
@@ -1,7 +1,7 @@
 /** @file

   Provides generic security measurement functions for DXE module.

 

-Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -102,7 +102,7 @@ CheckAuthenticationOperation (
   //

   // Make sure new auth operation can be recognized.

   //

-  ASSERT ((CheckAuthOperation & ~(EFI_AUTH_IMAGE_OPERATION_MASK | EFI_AUTH_OPERATION_IMAGE_REQUIRED)) == 0);

+  ASSERT ((CheckAuthOperation & ~(EFI_AUTH_IMAGE_OPERATION_MASK | EFI_AUTH_OPERATION_AUTHENTICATION_STATE | EFI_AUTH_OPERATION_IMAGE_REQUIRED)) == 0);

   

   //

   // When current operation includes measure image operation, 

diff --git a/MdeModulePkg/Library/PiDxeS3BootScriptLib/BootScriptExecute.c b/MdeModulePkg/Library/PiDxeS3BootScriptLib/BootScriptExecute.c
index afb4c107..cba331a3 100644
--- a/MdeModulePkg/Library/PiDxeS3BootScriptLib/BootScriptExecute.c
+++ b/MdeModulePkg/Library/PiDxeS3BootScriptLib/BootScriptExecute.c
@@ -1,7 +1,7 @@
 /** @file

   Interpret and execute the S3 data in S3 boot script. 

 

-  Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 

   This program and the accompanying materials

   are licensed and made available under the terms and conditions

@@ -1176,7 +1176,7 @@ BootScriptExecuteMemPoll (
   }

 

   for (LoopTimes = 0; LoopTimes < MemPoll.LoopTimes; LoopTimes++) {

-    NanoSecondDelay ((UINTN)MemPoll.Duration);

+    MicroSecondDelay ((UINTN)MemPoll.Duration);

 

     Data = 0;

     Status = ScriptMemoryRead (

diff --git a/MdeModulePkg/Library/UefiHiiLib/HiiLib.c b/MdeModulePkg/Library/UefiHiiLib/HiiLib.c
index ba74d0f8..9590f8f1 100644
--- a/MdeModulePkg/Library/UefiHiiLib/HiiLib.c
+++ b/MdeModulePkg/Library/UefiHiiLib/HiiLib.c
@@ -946,7 +946,7 @@ InternalHiiValidateCurrentSetting (
   UINT16                       Offset;

   UINT16                       Width;

   UINT64                       VarValue;

-  UINT64                       TmpValue;

+  EFI_IFR_TYPE_VALUE           TmpValue;

   LIST_ENTRY                   *Link;

   UINT8                        *VarBuffer;

   UINTN                        MaxBufferSize;

@@ -1511,9 +1511,10 @@ InternalHiiValidateCurrentSetting (
             //

             // Check current value is the value of one of option.

             //

-            TmpValue = 0;

+            ASSERT (IfrOneOfOption->Type <= EFI_IFR_TYPE_NUM_SIZE_64);

+            ZeroMem (&TmpValue, sizeof (EFI_IFR_TYPE_VALUE));

             CopyMem (&TmpValue, &IfrOneOfOption->Value, IfrOneOfOption->Header.Length - OFFSET_OF (EFI_IFR_ONE_OF_OPTION, Value));

-            if (VarValue == TmpValue) {

+            if (VarValue == TmpValue.u64) {

               //

               // The value is one of option value.

               // Set OpCode to Zero, don't need check again.

@@ -2858,6 +2859,82 @@ HiiCreateGotoOpCode (
 }

 

 /**

+  Create EFI_IFR_REF_OP, EFI_IFR_REF2_OP, EFI_IFR_REF3_OP and EFI_IFR_REF4_OP opcode.

+

+  When RefDevicePath is not zero, EFI_IFR_REF4 opcode will be created. 

+  When RefDevicePath is zero and RefFormSetId is not NULL, EFI_IFR_REF3 opcode will be created.

+  When RefDevicePath is zero, RefFormSetId is NULL and RefQuestionId is not zero, EFI_IFR_REF2 opcode will be created.

+  When RefDevicePath is zero, RefFormSetId is NULL and RefQuestionId is zero, EFI_IFR_REF opcode will be created.

+

+  If OpCodeHandle is NULL, then ASSERT().

+  If any reserved bits are set in QuestionFlags, then ASSERT().

+

+  @param[in]  OpCodeHandle   The handle to the buffer of opcodes.

+  @param[in]  RefFormId      The Destination Form ID.

+  @param[in]  Prompt         The string ID for Prompt.

+  @param[in]  Help           The string ID for Help.

+  @param[in]  QuestionFlags  The flags in Question Header

+  @param[in]  QuestionId     Question ID.

+  @param[in]  RefQuestionId  The question on the form to which this link is referring. 

+                             If its value is zero, then the link refers to the top of the form.

+  @param[in]  RefFormSetId   The form set to which this link is referring. If its value is NULL, and RefDevicePath is 

+                             zero, then the link is to the current form set.

+  @param[in]  RefDevicePath  The string identifier that specifies the string containing the text representation of 

+                             the device path to which the form set containing the form specified by FormId.

+                             If its value is zero, then the link refers to the current page.

+

+  @retval NULL   There is not enough space left in Buffer to add the opcode.

+  @retval Other  A pointer to the created opcode.

+

+**/

+UINT8 *

+EFIAPI

+HiiCreateGotoExOpCode (

+  IN VOID             *OpCodeHandle,

+  IN EFI_FORM_ID      RefFormId,

+  IN EFI_STRING_ID    Prompt,

+  IN EFI_STRING_ID    Help,

+  IN UINT8            QuestionFlags,

+  IN EFI_QUESTION_ID  QuestionId,

+  IN EFI_QUESTION_ID  RefQuestionId,

+  IN EFI_GUID         *RefFormSetId,    OPTIONAL

+  IN EFI_STRING_ID    RefDevicePath

+  )

+{

+  EFI_IFR_REF4  OpCode;

+  UINTN         OpCodeSize;

+

+  ASSERT ((QuestionFlags & (~(EFI_IFR_FLAG_READ_ONLY | EFI_IFR_FLAG_CALLBACK | EFI_IFR_FLAG_RESET_REQUIRED))) == 0);

+

+  ZeroMem (&OpCode, sizeof (OpCode));

+  OpCode.Question.Header.Prompt = Prompt;

+  OpCode.Question.Header.Help   = Help;

+  OpCode.Question.QuestionId    = QuestionId;

+  OpCode.Question.Flags         = QuestionFlags;

+  OpCode.FormId                 = RefFormId;

+  OpCode.QuestionId             = RefQuestionId;

+  OpCode.DevicePath             = RefDevicePath;

+  if (RefFormSetId != NULL) {

+    CopyMem (&OpCode.FormSetId, RefFormSetId, sizeof (OpCode.FormSetId));

+  }

+

+  //

+  // Cacluate OpCodeSize based on the input Ref value.

+  // Try to use the small OpCode to save size.

+  //

+  OpCodeSize = sizeof (EFI_IFR_REF);

+  if (RefDevicePath != 0) {

+    OpCodeSize = sizeof (EFI_IFR_REF4);

+  } else if (RefFormSetId != NULL) {

+    OpCodeSize = sizeof (EFI_IFR_REF3);

+  } else if (RefQuestionId != 0) {

+    OpCodeSize = sizeof (EFI_IFR_REF2);

+  }

+

+  return InternalHiiCreateOpCode (OpCodeHandle, &OpCode, EFI_IFR_REF_OP, OpCodeSize);

+}

+

+/**

   Create EFI_IFR_CHECKBOX_OP opcode.

 

   If OpCodeHandle is NULL, then ASSERT().

diff --git a/MdeModulePkg/MdeModulePkg.dec b/MdeModulePkg/MdeModulePkg.dec
index 710e3e6a..ba80b809 100644
--- a/MdeModulePkg/MdeModulePkg.dec
+++ b/MdeModulePkg/MdeModulePkg.dec
@@ -4,7 +4,7 @@
 # It also provides the defintions(including PPIs/PROTOCOLs/GUIDs and library classes)

 # and libraries instances, which are used for those modules.

 #

-# Copyright (c) 2007 - 2012, Intel Corporation. All rights reserved.<BR>

+# Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>

 # This program and the accompanying materials are licensed and made available under 

 # the terms and conditions of the BSD License that accompanies this distribution.  

 # The full text of the license may be found at

@@ -453,6 +453,11 @@
   #  If FALSE, TEXT statement will be set to GrayOut only when GrayOut condition is TRUE.

   gEfiMdeModulePkgTokenSpaceGuid.PcdBrowserGrayOutTextStatement|FALSE|BOOLEAN|0x0001004f

   

+  ## This PCD specifies whether unselectable menu should be gray out in HII Form Browser.

+  # If TRUE, the unselectable menu will be set to GrayOut.

+  # If FALSE, the menu will be show as normal menu entry even if it is not selectable.

+  gEfiMdeModulePkgTokenSpaceGuid.PcdBrowerGrayOutReadOnlyMenu|FALSE|BOOLEAN|0x00010070

+

   ## If TRUE, recovery from IDE disk will be supported.

   gEfiMdeModulePkgTokenSpaceGuid.PcdRecoveryOnIdeDisk|TRUE|BOOLEAN|0x00010060

 

diff --git a/MdeModulePkg/Universal/Acpi/BootScriptExecutorDxe/X64/SetIdtEntry.c b/MdeModulePkg/Universal/Acpi/BootScriptExecutorDxe/X64/SetIdtEntry.c
index 54ea20aa..a8944e60 100644
--- a/MdeModulePkg/Universal/Acpi/BootScriptExecutorDxe/X64/SetIdtEntry.c
+++ b/MdeModulePkg/Universal/Acpi/BootScriptExecutorDxe/X64/SetIdtEntry.c
@@ -3,7 +3,7 @@
 

   Set a IDT entry for interrupt vector 3 for debug purpose for x64 platform

 

-Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

@@ -48,6 +48,7 @@ HookPageFaultHandler (
 {

   UINT32         RegEax;

   UINT32         RegEdx;

+  UINTN          PageFaultHandlerHookAddress;

 

   AsmCpuid (0x80000008, &RegEax, NULL, NULL, NULL);

   mPhyMask = LShiftU64 (1, (UINT8)RegEax) - 1;

@@ -67,13 +68,14 @@ HookPageFaultHandler (
   //

   // Set Page Fault entry to catch >4G access

   //

+  PageFaultHandlerHookAddress = (UINTN)PageFaultHandlerHook;

   mOriginalHandler = (VOID *)(UINTN)(LShiftU64 (IdtEntry->Bits.OffsetUpper, 32) + IdtEntry->Bits.OffsetLow + (IdtEntry->Bits.OffsetHigh << 16));

-  IdtEntry->Bits.OffsetLow      = (UINT16)((UINTN)PageFaultHandlerHook);

+  IdtEntry->Bits.OffsetLow      = (UINT16)PageFaultHandlerHookAddress;

   IdtEntry->Bits.Selector       = (UINT16)AsmReadCs ();

   IdtEntry->Bits.Reserved_0     = 0;

   IdtEntry->Bits.GateType       = IA32_IDT_GATE_TYPE_INTERRUPT_32;

-  IdtEntry->Bits.OffsetHigh     = (UINT16)((UINTN)PageFaultHandlerHook >> 16);

-  IdtEntry->Bits.OffsetUpper    = (UINT32)((UINTN)PageFaultHandlerHook >> 32);

+  IdtEntry->Bits.OffsetHigh     = (UINT16)(PageFaultHandlerHookAddress >> 16);

+  IdtEntry->Bits.OffsetUpper    = (UINT32)(PageFaultHandlerHookAddress >> 32);

   IdtEntry->Bits.Reserved_1     = 0;

 

   if (mPage1GSupport) {

diff --git a/MdeModulePkg/Universal/Acpi/S3SaveStateDxe/S3SaveState.c b/MdeModulePkg/Universal/Acpi/S3SaveStateDxe/S3SaveState.c
index 249fb8ca..60cd9b1b 100644
--- a/MdeModulePkg/Universal/Acpi/S3SaveStateDxe/S3SaveState.c
+++ b/MdeModulePkg/Universal/Acpi/S3SaveStateDxe/S3SaveState.c
@@ -1,7 +1,7 @@
 /** @file

   Implementation for S3 Boot Script Saver state driver.

 

-  Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 

   This program and the accompanying materials

   are licensed and made available under the terms and conditions

@@ -344,16 +344,33 @@ BootScriptWriteMemPoll (
   VOID                      *Data;                                    

   VOID                      *DataMask;                                  

   UINTN                     Delay;                                   

-                                                                         

+  UINTN                     LoopTimes;

+  UINT32                    Remainder;

+

   Width    = VA_ARG (Marker, S3_BOOT_SCRIPT_LIB_WIDTH);                  

   Address  = VA_ARG (Marker, UINT64);                                    

   Data     = VA_ARG (Marker, VOID *);                                    

   DataMask = VA_ARG (Marker, VOID *);                                    

   Delay    = (UINTN)VA_ARG (Marker, UINT64);                            

   //

-  // According to the spec, the interval between 2 pools is 100ns

-  //                                                                       

-  return S3BootScriptSaveMemPoll (Width, Address, DataMask, Data, 100, Delay); 

+  // According to the spec, the interval between 2 polls is 100ns,

+  // but the unit of Duration for S3BootScriptSaveMemPoll() is microsecond(1000ns).

+  // Duration * 1000ns * LoopTimes = Delay * 100ns

+  // Duration will be minimum 1(microsecond) to be minimum deviation,

+  // so LoopTimes = Delay / 10.

+  //

+  LoopTimes = (UINTN) DivU64x32Remainder (

+                Delay,

+                10,

+                &Remainder

+                );

+  if (Remainder != 0) {

+    //

+    // If Remainder is not zero, LoopTimes will be rounded up by 1.

+    //

+    LoopTimes +=1;

+  }

+  return S3BootScriptSaveMemPoll (Width, Address, DataMask, Data, 1, LoopTimes);

 

 }

 

diff --git a/MdeModulePkg/Universal/Acpi/SmmS3SaveState/SmmS3SaveState.c b/MdeModulePkg/Universal/Acpi/SmmS3SaveState/SmmS3SaveState.c
index d0652d3f..e4227282 100644
--- a/MdeModulePkg/Universal/Acpi/SmmS3SaveState/SmmS3SaveState.c
+++ b/MdeModulePkg/Universal/Acpi/SmmS3SaveState/SmmS3SaveState.c
@@ -1,7 +1,7 @@
 /** @file

   Implementation for S3 SMM Boot Script Saver state driver.

 

-  Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

 

   This program and the accompanying materials

   are licensed and made available under the terms and conditions

@@ -343,16 +343,33 @@ BootScriptWriteMemPoll (
   VOID                      *Data;                                       

   VOID                      *DataMask;                                   

   UINTN                      Delay;                                       

-                                                                         

+  UINTN                      LoopTimes;

+  UINT32                     Remainder;

+

   Width    = VA_ARG (Marker, S3_BOOT_SCRIPT_LIB_WIDTH);                  

   Address  = VA_ARG (Marker, UINT64);                                    

   Data     = VA_ARG (Marker, VOID *);                                    

   DataMask = VA_ARG (Marker, VOID *);                                    

   Delay    = (UINTN)VA_ARG (Marker, UINT64);                            

   //

-  // According to the spec, the interval between 2 pools is 100ns

-  //                                                                       

-  return S3BootScriptSaveMemPoll (Width, Address, DataMask, Data, 100, Delay); 

+  // According to the spec, the interval between 2 polls is 100ns,

+  // but the unit of Duration for S3BootScriptSaveMemPoll() is microsecond(1000ns).

+  // Duration * 1000ns * LoopTimes = Delay * 100ns

+  // Duration will be minimum 1(microsecond) to be minimum deviation,

+  // so LoopTimes = Delay / 10.

+  //

+  LoopTimes = (UINTN) DivU64x32Remainder (

+                Delay,

+                10,

+                &Remainder

+                );

+  if (Remainder != 0) {

+    //

+    // If Remainder is not zero, LoopTimes will be rounded up by 1.

+    //

+    LoopTimes +=1;

+  }

+  return S3BootScriptSaveMemPoll (Width, Address, DataMask, Data, 1, LoopTimes); 

 

 }

 

diff --git a/MdeModulePkg/Universal/Console/ConPlatformDxe/ConPlatform.c b/MdeModulePkg/Universal/Console/ConPlatformDxe/ConPlatform.c
index ab65e7e1..795123d1 100644
--- a/MdeModulePkg/Universal/Console/ConPlatformDxe/ConPlatform.c
+++ b/MdeModulePkg/Universal/Console/ConPlatformDxe/ConPlatform.c
@@ -2,7 +2,7 @@
   Console Platform DXE Driver, install Console Device Guids and update Console

   Environment Variables.

 

-Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -792,7 +792,9 @@ IsGopSibling (
   EFI_DEVICE_PATH_PROTOCOL  *NodeRight;

 

   for (NodeLeft = Left; !IsDevicePathEndType (NodeLeft); NodeLeft = NextDevicePathNode (NodeLeft)) {

-    if (DevicePathType (NodeLeft) == ACPI_DEVICE_PATH && DevicePathSubType (NodeLeft) == ACPI_ADR_DP) {

+    if ((DevicePathType (NodeLeft) == ACPI_DEVICE_PATH && DevicePathSubType (NodeLeft) == ACPI_ADR_DP) ||

+        (DevicePathType (NodeLeft) == HARDWARE_DEVICE_PATH && DevicePathSubType (NodeLeft) == HW_CONTROLLER_DP &&

+         DevicePathType (NextDevicePathNode (NodeLeft)) == ACPI_DEVICE_PATH && DevicePathSubType (NextDevicePathNode (NodeLeft)) == ACPI_ADR_DP)) {

       break;

     }

   }

@@ -802,7 +804,9 @@ IsGopSibling (
   }

 

   for (NodeRight = Right; !IsDevicePathEndType (NodeRight); NodeRight = NextDevicePathNode (NodeRight)) {

-    if (DevicePathType (NodeRight) == ACPI_DEVICE_PATH && DevicePathSubType (NodeRight) == ACPI_ADR_DP) {

+    if ((DevicePathType (NodeRight) == ACPI_DEVICE_PATH && DevicePathSubType (NodeRight) == ACPI_ADR_DP) ||

+        (DevicePathType (NodeRight) == HARDWARE_DEVICE_PATH && DevicePathSubType (NodeRight) == HW_CONTROLLER_DP &&

+         DevicePathType (NextDevicePathNode (NodeRight)) == ACPI_DEVICE_PATH && DevicePathSubType (NextDevicePathNode (NodeRight)) == ACPI_ADR_DP)) {

       break;

     }

   }

diff --git a/MdeModulePkg/Universal/Console/GraphicsConsoleDxe/GraphicsConsole.c b/MdeModulePkg/Universal/Console/GraphicsConsoleDxe/GraphicsConsole.c
index 212564a5..01610f7c 100644
--- a/MdeModulePkg/Universal/Console/GraphicsConsoleDxe/GraphicsConsole.c
+++ b/MdeModulePkg/Universal/Console/GraphicsConsoleDxe/GraphicsConsole.c
@@ -1,7 +1,7 @@
 /** @file

   This is the main routine for initializing the Graphics Console support routines.

 

-Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -57,7 +57,7 @@ GRAPHICS_CONSOLE_MODE_DATA mGraphicsConsoleModeData[] = {
 EFI_HII_DATABASE_PROTOCOL   *mHiiDatabase;

 EFI_HII_FONT_PROTOCOL       *mHiiFont;

 EFI_HII_HANDLE              mHiiHandle;

-EFI_EVENT                   mHiiRegistration;

+VOID                        *mHiiRegistration;

 

 EFI_GUID             mFontPackageListGuid = {0xf5f219d3, 0x7006, 0x4648, {0xac, 0x8d, 0xd6, 0x1d, 0xfb, 0x7b, 0xc6, 0xad}};

 

@@ -453,8 +453,8 @@ GraphicsConsoleControllerDriverStart (
                            &Info

                            );

         if (!EFI_ERROR (Status)) {

-          if ((Info->HorizontalResolution >= HorizontalResolution) &&

-              (Info->VerticalResolution >= VerticalResolution)) {

+          if ((Info->HorizontalResolution > HorizontalResolution) ||

+              ((Info->HorizontalResolution == HorizontalResolution) && (Info->VerticalResolution > VerticalResolution))) {

             HorizontalResolution = Info->HorizontalResolution;

             VerticalResolution   = Info->VerticalResolution;

             ModeNumber           = ModeIndex;

@@ -549,6 +549,8 @@ GraphicsConsoleControllerDriverStart (
     }

   }

 

+  DEBUG ((EFI_D_INFO, "GraphicsConsole video resolution %d x %d\n", HorizontalResolution, VerticalResolution));

+

   //

   // Initialize the mode which GraphicsConsole supports.

   //

@@ -804,42 +806,14 @@ EfiLocateHiiProtocol (
   VOID

   )

 {

-  EFI_HANDLE  Handle;

-  UINTN       Size;

   EFI_STATUS  Status;

 

-  //

-  // There should only be one - so buffer size is this

-  //

-  Size = sizeof (EFI_HANDLE);

-

-  Status = gBS->LocateHandle (

-                  ByProtocol,

-                  &gEfiHiiDatabaseProtocolGuid,

-                  NULL,

-                  &Size,

-                  (VOID **) &Handle

-                  );

-

+  Status = gBS->LocateProtocol (&gEfiHiiDatabaseProtocolGuid, NULL, (VOID **) &mHiiDatabase);

   if (EFI_ERROR (Status)) {

     return Status;

   }

 

-  Status = gBS->HandleProtocol (

-                  Handle,

-                  &gEfiHiiDatabaseProtocolGuid,

-                  (VOID **) &mHiiDatabase

-                  );

-

-  if (EFI_ERROR (Status)) {

-    return Status;

-  }

-

-  Status = gBS->HandleProtocol (

-                  Handle,

-                  &gEfiHiiFontProtocolGuid,

-                  (VOID **) &mHiiFont

-                  );

+  Status = gBS->LocateProtocol (&gEfiHiiFontProtocolGuid, NULL, (VOID **) &mHiiFont);

   return Status;

 }

 

@@ -2055,7 +2029,9 @@ RegisterFontPackage (
                   NULL,

                   (VOID **) &HiiDatabase

                   );

-  ASSERT_EFI_ERROR (Status);

+  if (EFI_ERROR (Status)) {

+    return;

+  }

 

   //

   // Add 4 bytes to the header for entire length for HiiAddPackages use only.

diff --git a/MdeModulePkg/Universal/Disk/PartitionDxe/Mbr.c b/MdeModulePkg/Universal/Disk/PartitionDxe/Mbr.c
index 4c646637..f8416d16 100644
--- a/MdeModulePkg/Universal/Disk/PartitionDxe/Mbr.c
+++ b/MdeModulePkg/Universal/Disk/PartitionDxe/Mbr.c
@@ -155,6 +155,15 @@ PartitionInstallMbrChildHandles (
                      BlockSize,

                      Mbr

                      );

+
+  // RMH - hack - Linaro's development boards use SD cards, currently we have
+  // a problem where each unique SD card has a different UUID when created
+  // with linaro-media-create / linaro-android-media create.
+  // This means that no one Boot Device configuration can boot Linaro images
+  // without some manual intervention from the user.
+  // This hack will zero the signature (UUID) read from the card.
+  ZeroMem(&(Mbr->UniqueMbrSignature[0]), sizeof (Mbr->UniqueMbrSignature));
+
   if (EFI_ERROR (Status)) {

     Found = Status;

     goto Done;

diff --git a/MdeModulePkg/Universal/DriverSampleDxe/DriverSample.c b/MdeModulePkg/Universal/DriverSampleDxe/DriverSample.c
index 854a5a72..3ae55de2 100644
--- a/MdeModulePkg/Universal/DriverSampleDxe/DriverSample.c
+++ b/MdeModulePkg/Universal/DriverSampleDxe/DriverSample.c
@@ -2,7 +2,7 @@
 This is an example of how a driver might export data to the HII protocol to be

 later utilized by the Setup Protocol

 

-Copyright (c) 2004 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -1766,44 +1766,6 @@ DriverCallback (
   return Status;

 }

 

-

-/**

-  Transfer the binary device path to string.

-

-  @param   DevicePath     The device path info.

-

-  @retval  Device path string info.

-

-**/

-CHAR16  *

-GenerateDevicePathString (

-  EFI_DEVICE_PATH_PROTOCOL *DevicePath

-  )

-{

-  CHAR16                    *String;

-  CHAR16                    *TmpBuf;

-  UINTN                     Index;

-  UINT8                     *Buffer;

-  UINTN                     DevicePathSize;

-

-  //

-  // Compute the size of the device path in bytes

-  //

-  DevicePathSize = GetDevicePathSize (DevicePath);

-  

-  String = AllocateZeroPool ((DevicePathSize * 2 + 1) * sizeof (CHAR16));

-  if (String == NULL) {

-    return NULL;

-  }

-

-  TmpBuf = String;

-  for (Index = 0, Buffer = (UINT8 *)DevicePath; Index < DevicePathSize; Index++) {

-    TmpBuf += UnicodeValueToString (TmpBuf, PREFIX_ZERO | RADIX_HEX, *(Buffer++), 2);

-  }

-

-  return String;

-}

-

 /**

   Main entry for this driver.

 

@@ -1835,12 +1797,14 @@ DriverSampleInit (
   MY_EFI_VARSTORE_DATA            *VarStoreConfig;

   EFI_INPUT_KEY                   HotKey;

   EFI_FORM_BROWSER_EXTENSION_PROTOCOL *FormBrowserEx;

+  EFI_DEVICE_PATH_TO_TEXT_PROTOCOL *PathToText;

 

   //

   // Initialize the local variables.

   //

   ConfigRequestHdr = NULL;

   NewString        = NULL;

+  PathToText       = NULL;

 

   //

   // Initialize screen dimensions for SendForm().

@@ -1957,11 +1921,18 @@ DriverSampleInit (
   }

 

   PrivateData->HiiHandle[1] = HiiHandle[1];

+ 

+  Status = gBS->LocateProtocol (

+                  &gEfiDevicePathToTextProtocolGuid,

+                  NULL,

+                  (VOID **) &PathToText

+                  );

+  ASSERT_EFI_ERROR (Status);

 

   //

   // Update the device path string.

   //

-  NewString = GenerateDevicePathString((EFI_DEVICE_PATH_PROTOCOL*)&mHiiVendorDevicePath0);

+  NewString = PathToText->ConvertDevicePathToText((EFI_DEVICE_PATH_PROTOCOL*)&mHiiVendorDevicePath0, FALSE, FALSE);

   if (HiiSetString (HiiHandle[0], STRING_TOKEN (STR_DEVICE_PATH), NewString, NULL) == 0) {

     DriverSampleUnload (ImageHandle);

     return EFI_OUT_OF_RESOURCES;

diff --git a/MdeModulePkg/Universal/DriverSampleDxe/DriverSample.h b/MdeModulePkg/Universal/DriverSampleDxe/DriverSample.h
index 07ace648..cd546bf3 100644
--- a/MdeModulePkg/Universal/DriverSampleDxe/DriverSample.h
+++ b/MdeModulePkg/Universal/DriverSampleDxe/DriverSample.h
@@ -1,6 +1,6 @@
 /** @file

 

-Copyright (c) 2007 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -32,6 +32,7 @@ Revision History
 #include <Protocol/HiiDatabase.h>

 #include <Protocol/HiiString.h>

 #include <Protocol/FormBrowserEx.h>

+#include <Protocol/DevicePathToText.h>

 

 #include <Guid/MdeModuleHii.h>

 #include <Library/DebugLib.h>

diff --git a/MdeModulePkg/Universal/DriverSampleDxe/DriverSampleDxe.inf b/MdeModulePkg/Universal/DriverSampleDxe/DriverSampleDxe.inf
index bcc15744..36511e66 100644
--- a/MdeModulePkg/Universal/DriverSampleDxe/DriverSampleDxe.inf
+++ b/MdeModulePkg/Universal/DriverSampleDxe/DriverSampleDxe.inf
@@ -2,7 +2,7 @@
 # This is a sample driver which show how HII protocol, VFR and UNI files are used to

 # create a driver which can be dipslayed and configured by a UEFI HII Form Browser.

 #

-# Copyright (c) 2007 - 2012, Intel Corporation. All rights reserved.<BR>

+# Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>

 #

 #  This program and the accompanying materials

 #  are licensed and made available under the terms and conditions of the BSD License

@@ -70,6 +70,7 @@
   gEfiHiiDatabaseProtocolGuid                   ## CONSUMES

   gEfiSimpleTextInputExProtocolGuid             ## CONSUMES

   gEfiFormBrowserExProtocolGuid                 ## CONSUMES

+  gEfiDevicePathToTextProtocolGuid              ## CONSUMES

 

 [Depex]

   gEfiSimpleTextOutProtocolGuid AND gEfiHiiDatabaseProtocolGuid AND gEfiVariableArchProtocolGuid AND gEfiVariableWriteArchProtocolGuid

diff --git a/MdeModulePkg/Universal/Network/Ip4Dxe/Ip4If.c b/MdeModulePkg/Universal/Network/Ip4Dxe/Ip4If.c
index 22424416..67116363 100644
--- a/MdeModulePkg/Universal/Network/Ip4Dxe/Ip4If.c
+++ b/MdeModulePkg/Universal/Network/Ip4Dxe/Ip4If.c
@@ -1,7 +1,7 @@
 /** @file

   Implement IP4 pesudo interface.

   

-Copyright (c) 2005 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2005 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -740,24 +740,11 @@ Ip4FreeInterface (
   //

   Ip4CancelFrames (Interface, EFI_ABORTED, Ip4CancelInstanceFrame, IpInstance);

 

-  if (--Interface->RefCnt > 0) {

-    return EFI_SUCCESS;

-  }

-

   //

-  // Destroy the interface if this is the last IP instance that

-  // has the address. Remove all the system transmitted packets

-  // from this interface, cancel the receive request if there is

-  // one, and destroy the ARP requests.

+  // Destroy the ARP instance if this is the last IP instance that

+  // has the address.

   //

-  Ip4CancelFrames (Interface, EFI_ABORTED, Ip4CancelInstanceFrame, NULL);

-  Ip4CancelReceive (Interface);

-

-  ASSERT (IsListEmpty (&Interface->IpInstances));

-  ASSERT (IsListEmpty (&Interface->ArpQues));

-  ASSERT (IsListEmpty (&Interface->SentFrames));

-

-  if (Interface->Arp != NULL) {

+  if (Interface->Arp != NULL && IsListEmpty (&Interface->IpInstances)) {

     gBS->CloseProtocol (

           Interface->ArpHandle,

           &gEfiArpProtocolGuid,

@@ -771,8 +758,25 @@ Ip4FreeInterface (
       &gEfiArpServiceBindingProtocolGuid,

       Interface->ArpHandle

       );

+    Interface->Arp = NULL;

+  }

+  

+  if (--Interface->RefCnt > 0) {

+    return EFI_SUCCESS;

   }

 

+  //

+  // Destroy the interface if it is not referenced by any IP instance (for common Interface)

+  // or the IP service (for the DefaultInterface). Remove all the system transmitted packets

+  // from this interface, cancel the receive request if there is one.

+  //

+  Ip4CancelFrames (Interface, EFI_ABORTED, Ip4CancelInstanceFrame, NULL);

+  Ip4CancelReceive (Interface);

+

+  ASSERT (IsListEmpty (&Interface->IpInstances));

+  ASSERT (IsListEmpty (&Interface->ArpQues));

+  ASSERT (IsListEmpty (&Interface->SentFrames));

+

   RemoveEntryList (&Interface->Link);

   FreePool (Interface);

 

diff --git a/MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Impl.c b/MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Impl.c
index 74bf7f76..29f07ce4 100644
--- a/MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Impl.c
+++ b/MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Impl.c
@@ -1,6 +1,6 @@
 /** @file

 

-Copyright (c) 2005 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2005 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -562,6 +562,9 @@ Ip4AutoConfigCallBackDpc (
   IP4_ADDR                  SubnetMask;

   IP4_ADDR                  SubnetAddress;

   IP4_ADDR                  GatewayAddress;

+  IP4_PROTOCOL              *Ip4Instance;

+  EFI_ARP_PROTOCOL          *Arp;

+  LIST_ENTRY                *Entry;

 

   IpSb      = (IP4_SERVICE *) Context;

   NET_CHECK_SIGNATURE (IpSb, IP4_SERVICE_SIGNATURE);

@@ -650,11 +653,33 @@ Ip4AutoConfigCallBackDpc (
   StationAddress = EFI_NTOHL (Data->StationAddress);

   SubnetMask = EFI_NTOHL (Data->SubnetMask);

   Status = Ip4SetAddress (IpIf, StationAddress, SubnetMask);

-

   if (EFI_ERROR (Status)) {

     goto ON_EXIT;

   }

 

+  if (IpIf->Arp != NULL) {

+    //   

+    // A non-NULL IpIf->Arp here means a new ARP child is created when setting default address, 

+    // but some IP children may have referenced the default interface before it is configured,

+    // these IP instances also consume this ARP protocol so they need to open it BY_CHILD_CONTROLLER.

+    //

+    Arp = NULL;

+    NET_LIST_FOR_EACH (Entry, &IpIf->IpInstances) {

+      Ip4Instance = NET_LIST_USER_STRUCT_S (Entry, IP4_PROTOCOL, AddrLink, IP4_PROTOCOL_SIGNATURE);

+      Status = gBS->OpenProtocol (

+                      IpIf->ArpHandle,

+                      &gEfiArpProtocolGuid,

+                      (VOID **) &Arp,

+                      gIp4DriverBinding.DriverBindingHandle,

+                      Ip4Instance->Handle,

+                      EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER

+                      );

+      if (EFI_ERROR (Status)) {

+        goto ON_EXIT;

+      }

+    }

+  }

+

   Ip4AddRoute (

     IpSb->DefaultRouteTable,

     StationAddress,

diff --git a/MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Output.c b/MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Output.c
index 7ff17b66..370eaa6a 100644
--- a/MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Output.c
+++ b/MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Output.c
@@ -1,7 +1,7 @@
 /** @file

   Transmit the IP4 packet.

   

-Copyright (c) 2005 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2005 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -286,46 +286,40 @@ Ip4Output (
   if (EFI_ERROR(Status)) {

     return Status;

   }

+  

+  Dest = Head->Dst;

+  if (IP4_IS_BROADCAST (Ip4GetNetCast (Dest, IpIf)) || (Dest == IP4_ALLONE_ADDRESS)) {

+    //

+    // Set the gateway to local broadcast if the Dest is

+    // the broadcast address for the connected network or

+    // it is local broadcast.

+    //

+    GateWay = IP4_ALLONE_ADDRESS;

 

-  //

-  // Route the packet unless overrided, that is, GateWay isn't zero.

-  //

-  if (GateWay == IP4_ALLZERO_ADDRESS) {

-    Dest = Head->Dst;

-

-    if (IP4_IS_BROADCAST (Ip4GetNetCast (Dest, IpIf)) || (Dest == IP4_ALLONE_ADDRESS)) {

-      //

-      // Set the gateway to local broadcast if the Dest is

-      // the broadcast address for the connected network or

-      // it is local broadcast.

-      //

-      GateWay = IP4_ALLONE_ADDRESS;

-

-    } else if (IP4_IS_MULTICAST (Dest)) {

-      //

-      // Set the gateway to the destination if it is an multicast

-      // address. The IP4_INTERFACE won't consult ARP to send local

-      // broadcast and multicast.

-      //

-      GateWay = Head->Dst;

+  } else if (IP4_IS_MULTICAST (Dest)) {

+    //

+    // Set the gateway to the destination if it is an multicast

+    // address. The IP4_INTERFACE won't consult ARP to send local

+    // broadcast and multicast.

+    //

+    GateWay = Head->Dst;

 

+  } else if (GateWay == IP4_ALLZERO_ADDRESS) {

+    //

+    // Route the packet unless overrided, that is, GateWay isn't zero.

+    //

+    if (IpInstance == NULL) {

+      CacheEntry = Ip4Route (IpSb->DefaultRouteTable, Head->Dst, Head->Src);

     } else {

-      //

-      // Consult the route table to route the packet

-      //

-      if (IpInstance == NULL) {

-        CacheEntry = Ip4Route (IpSb->DefaultRouteTable, Head->Dst, Head->Src);

-      } else {

-        CacheEntry = Ip4Route (IpInstance->RouteTable, Head->Dst, Head->Src);

-      }

-

-      if (CacheEntry == NULL) {

-        return EFI_NOT_FOUND;

-      }

+      CacheEntry = Ip4Route (IpInstance->RouteTable, Head->Dst, Head->Src);

+    }

 

-      GateWay = CacheEntry->NextHop;

-      Ip4FreeRouteCacheEntry (CacheEntry);

+    if (CacheEntry == NULL) {

+      return EFI_NOT_FOUND;

     }

+

+    GateWay = CacheEntry->NextHop;

+    Ip4FreeRouteCacheEntry (CacheEntry);

   }

 

   //

diff --git a/MdeModulePkg/Universal/Network/SnpDxe/Snp.c b/MdeModulePkg/Universal/Network/SnpDxe/Snp.c
index f1fea0cf..177d0a91 100644
--- a/MdeModulePkg/Universal/Network/SnpDxe/Snp.c
+++ b/MdeModulePkg/Universal/Network/SnpDxe/Snp.c
@@ -1,7 +1,7 @@
 /** @file

   Implementation of driver entry point and driver binding protocol.

 

-Copyright (c) 2004 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials are licensed

 and made available under the terms and conditions of the BSD License which

 accompanies this distribution. The full text of the license may be found at

@@ -258,7 +258,7 @@ Done:
                                device to start.

 

   @retval EFI_SUCCESS          This driver is added to ControllerHandle

-  @retval EFI_ALREADY_STARTED  This driver is already running on ControllerHandle

+  @retval EFI_DEVICE_ERROR     This driver could not be started due to a device error

   @retval other                This driver does not support this device

 

 **/

@@ -698,11 +698,11 @@ SimpleNetworkDriverStart (
     return Status;

   }

 

-  Status = mPciIo->FreeBuffer (

-                        mPciIo,

-                        SNP_MEM_PAGES (4096),

-                        Snp->Cpb

-                        );

+  mPciIo->FreeBuffer (

+            mPciIo,

+            SNP_MEM_PAGES (4096),

+            Snp->Cpb

+            );

 

 Error_DeleteSNP:

 

@@ -726,6 +726,13 @@ NiiError:
         Controller

         );

 

+  //

+  // If we got here that means we are in error state.

+  //

+  if (!EFI_ERROR (Status)) {

+    Status = EFI_DEVICE_ERROR;

+  }

+

   return Status;

 }

 

diff --git a/MdeModulePkg/Universal/Network/UefiPxeBcDxe/PxeBcImpl.c b/MdeModulePkg/Universal/Network/UefiPxeBcDxe/PxeBcImpl.c
index 511e0648..7bdffc55 100644
--- a/MdeModulePkg/Universal/Network/UefiPxeBcDxe/PxeBcImpl.c
+++ b/MdeModulePkg/Universal/Network/UefiPxeBcDxe/PxeBcImpl.c
@@ -1,7 +1,7 @@
 /** @file

   Interface routines for PxeBc.

 

-Copyright (c) 2007 - 2011, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -652,9 +652,6 @@ EfiPxeBcDhcp (
   // finished, set the various Mode members.

   //

   Status = PxeBcCheckSelectedOffer (Private);

-  if (!EFI_ERROR (Status)) {

-    goto ON_EXIT;

-  }

 

 ON_EXIT:

   if (EFI_ERROR (Status)) {

@@ -840,6 +837,7 @@ EfiPxeBcDiscover (
   // If info isn't offered,

   //   use the cached DhcpAck and ProxyOffer packets.

   //

+  ZeroMem (&DefaultInfo, sizeof (EFI_PXE_BASE_CODE_DISCOVER_INFO));

   if (*Layer != EFI_PXE_BASE_CODE_BOOT_LAYER_INITIAL) {

 

     if (!Mode->PxeDiscoverValid || !Mode->PxeReplyReceived || (!Mode->PxeBisReplyReceived && UseBis)) {

diff --git a/MdeModulePkg/Universal/PCD/Dxe/Service.c b/MdeModulePkg/Universal/PCD/Dxe/Service.c
index 53780dca..6eaadd6c 100644
--- a/MdeModulePkg/Universal/PCD/Dxe/Service.c
+++ b/MdeModulePkg/Universal/PCD/Dxe/Service.c
@@ -1,7 +1,7 @@
 /** @file

     Help functions used by PCD DXE driver.

 

-Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -150,6 +150,11 @@ GetWorker (
             //

             GetPtrTypeSize (TmpTokenNumber, &GetSize);

           }

+          //

+          // If the operation is successful, we copy the data

+          // to the default value buffer in the PCD Database.

+          // So that we can free the Data allocated in GetHiiVariable.

+          //

           CopyMem (VaraiableDefaultBuffer, Data + VariableHead->Offset, GetSize);

           FreePool (Data);

         }

@@ -166,19 +171,14 @@ GetWorker (
             //

             GetPtrTypeSize (TmpTokenNumber, &GetSize);

           }

+          //

+          // If the operation is successful, we copy the data

+          // to the default value buffer in the PCD Database.

+          // So that we can free the Data allocated in GetHiiVariable.

+          //

           CopyMem (VaraiableDefaultBuffer, Data + VariableHead->Offset, GetSize);

           FreePool (Data);

         }

-        //

-        // If the operation is successful, we copy the data

-        // to the default value buffer in the PCD Database.

-        // So that we can free the Data allocated in GetHiiVariable.

-        //

-        //

-        // If the operation is not successful, 

-        // Return 1) either the default value specified by Platform Integrator 

-        //        2) Or the value Set by a PCD set operation.

-        //

         RetPtr = (VOID *) VaraiableDefaultBuffer;

       }

       break;

@@ -535,6 +535,12 @@ GetHiiVariable (
     ASSERT (Status == EFI_SUCCESS);

     *VariableData = Buffer;

     *VariableSize = Size;

+  } else {

+    //

+    // Use Default Data only when variable is not found. 

+    // For other error status, correct data can't be got, and trig ASSERT().

+    //

+    ASSERT (Status == EFI_NOT_FOUND);

   }

 

   return Status;

diff --git a/MdeModulePkg/Universal/SecurityStubDxe/SecurityStub.c b/MdeModulePkg/Universal/SecurityStubDxe/SecurityStub.c
index f2ed384c..22e6c7f4 100644
--- a/MdeModulePkg/Universal/SecurityStubDxe/SecurityStub.c
+++ b/MdeModulePkg/Universal/SecurityStubDxe/SecurityStub.c
@@ -1,7 +1,7 @@
 /** @file

   This driver produces Security2 and Security architectural protocol based on SecurityManagementLib.

  

-  Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials                          

   are licensed and made available under the terms and conditions of the BSD License         

   which accompanies this distribution.  The full text of the license may be found at        

@@ -69,13 +69,20 @@ SecurityStubAuthenticateState (
   IN CONST EFI_DEVICE_PATH_PROTOCOL    *File

   )

 {

-  return ExecuteSecurity2Handlers (EFI_AUTH_OPERATION_AUTHENTICATION_STATE, 

+  EFI_STATUS Status;

+  

+  Status = ExecuteSecurity2Handlers (EFI_AUTH_OPERATION_AUTHENTICATION_STATE, 

                                    AuthenticationStatus, 

                                    File,

                                    NULL, 

                                    0, 

                                    FALSE

                                    );

+  if (Status == EFI_SUCCESS) {

+    Status = ExecuteSecurityHandlers (AuthenticationStatus, File);

+  }

+  

+  return Status;

 }

 

 /**

diff --git a/MdeModulePkg/Universal/SetupBrowserDxe/Expression.c b/MdeModulePkg/Universal/SetupBrowserDxe/Expression.c
index 3766ca12..29de5034 100644
--- a/MdeModulePkg/Universal/SetupBrowserDxe/Expression.c
+++ b/MdeModulePkg/Universal/SetupBrowserDxe/Expression.c
@@ -1,7 +1,7 @@
 /** @file

 Utility functions for expression evaluation.

 

-Copyright (c) 2007 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -1446,7 +1446,6 @@ IfrMid (
   UINTN          Base;

   UINTN          Length;

   CHAR16         *SubString;

-  UINT8          *Buffer;

   UINT16         BufferLen;

 

   ZeroMem (Value, sizeof (Value));

@@ -1502,7 +1501,6 @@ IfrMid (
 

     FreePool (String);

   } else {

-    Buffer    = Value[2].Buffer;

     BufferLen = Value[2].BufferLen;

     

     Result->Type = EFI_IFR_TYPE_BUFFER;

@@ -1513,7 +1511,7 @@ IfrMid (
       Result->BufferLen = (UINT16)((BufferLen - Base) < Length ? (BufferLen - Base) : Length);    

       Result->Buffer = AllocateZeroPool (Result->BufferLen);

       ASSERT (Result->Buffer != NULL);

-      CopyMem (Result->Buffer, &Buffer[Base], Result->BufferLen);
+      CopyMem (Result->Buffer, &Buffer[Base], Result->BufferLen);

     }

 

     FreePool (Value[2].Buffer);

@@ -2470,22 +2468,21 @@ EvaluateExpression (
       }

 

       if (OpCode->DevicePath != 0) {

-        StrPtr = GetToken (OpCode->DevicePath, FormSet->HiiHandle);

-        if (StrPtr == NULL) {

-          Value->Type = EFI_IFR_TYPE_UNDEFINED;

-          break;

-        }

-

-        DevicePath = ConvertDevicePathFromText(StrPtr);

+        Value->Type = EFI_IFR_TYPE_UNDEFINED;

 

-        if (!GetQuestionValueFromForm(DevicePath, NULL, &OpCode->Guid, Value->Value.u16, &QuestionVal)){

-          Value->Type = EFI_IFR_TYPE_UNDEFINED;

-        } else {

-          Value = &QuestionVal;

+        StrPtr = GetToken (OpCode->DevicePath, FormSet->HiiHandle);

+        if (StrPtr != NULL && mPathFromText != NULL) {

+          DevicePath = mPathFromText->ConvertTextToDevicePath(StrPtr);

+          if (DevicePath != NULL && GetQuestionValueFromForm(DevicePath, NULL, &OpCode->Guid, Value->Value.u16, &QuestionVal)) {

+            Value = &QuestionVal;

+          }

+          if (DevicePath != NULL) {

+            FreePool (DevicePath);

+          }

         }

 

-        if (DevicePath != NULL) {

-          FreePool (DevicePath);

+        if (StrPtr != NULL) {

+          FreePool (StrPtr);

         }

       } else if (CompareGuid (&OpCode->Guid, &gZeroGuid) != 0) {

         if (!GetQuestionValueFromForm(NULL, FormSet->HiiHandle, &OpCode->Guid, Value->Value.u16, &QuestionVal)){

diff --git a/MdeModulePkg/Universal/SetupBrowserDxe/Presentation.c b/MdeModulePkg/Universal/SetupBrowserDxe/Presentation.c
index 62811c75..c3854aac 100644
--- a/MdeModulePkg/Universal/SetupBrowserDxe/Presentation.c
+++ b/MdeModulePkg/Universal/SetupBrowserDxe/Presentation.c
@@ -1,7 +1,7 @@
 /** @file

 Utility functions for UI presentation.

 

-Copyright (c) 2004 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -602,6 +602,7 @@ InitializeBrowserStrings (
   gSaveChanges          = GetToken (STRING_TOKEN (SAVE_CHANGES), gHiiHandle);

   gOptionMismatch       = GetToken (STRING_TOKEN (OPTION_MISMATCH), gHiiHandle);

   gFormSuppress         = GetToken (STRING_TOKEN (FORM_SUPPRESSED), gHiiHandle);

+  gProtocolNotFound     = GetToken (STRING_TOKEN (PROTOCOL_NOT_FOUND), gHiiHandle);

   return ;

 }

 

@@ -642,6 +643,7 @@ FreeBrowserStrings (
   FreePool (gSaveChanges);

   FreePool (gOptionMismatch);

   FreePool (gFormSuppress);

+  FreePool (gProtocolNotFound);

   return ;

 }

 

@@ -1252,6 +1254,7 @@ ProcessCallBackFunction (
           break;

 

         case EFI_BROWSER_ACTION_REQUEST_EXIT:

+          DiscardFormIsRequired = TRUE;

           Selection->Action = UI_ACTION_EXIT;

           break;

 

diff --git a/MdeModulePkg/Universal/SetupBrowserDxe/Setup.c b/MdeModulePkg/Universal/SetupBrowserDxe/Setup.c
index bcc8e020..6c019f04 100644
--- a/MdeModulePkg/Universal/SetupBrowserDxe/Setup.c
+++ b/MdeModulePkg/Universal/SetupBrowserDxe/Setup.c
@@ -1,7 +1,7 @@
 /** @file

 Entry and initialization module for the browser.

 

-Copyright (c) 2007 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -32,6 +32,7 @@ SETUP_DRIVER_PRIVATE_DATA  mPrivateData = {
 EFI_HII_DATABASE_PROTOCOL         *mHiiDatabase;

 EFI_HII_STRING_PROTOCOL           *mHiiString;

 EFI_HII_CONFIG_ROUTING_PROTOCOL   *mHiiConfigRouting;

+EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL *mPathFromText;

 

 UINTN           gBrowserContextCount = 0;

 LIST_ENTRY      gBrowserContextList = INITIALIZE_LIST_HEAD_VARIABLE (gBrowserContextList);

@@ -84,6 +85,7 @@ CHAR16            *gAdjustNumber;
 CHAR16            *gSaveChanges;

 CHAR16            *gOptionMismatch;

 CHAR16            *gFormSuppress;

+CHAR16            *gProtocolNotFound;

 

 CHAR16            *mUnknownString = L"!";

 

@@ -243,6 +245,11 @@ SendForm (
   gFooterHeight = FOOTER_HEIGHT + (Index / 3);

 

   //

+  // Clean the history menu list.

+  //

+  InitializeListHead (&gMenuList);

+

+  //

   // Save globals used by SendForm()

   //

   SaveBrowserContext ();

@@ -303,8 +310,6 @@ SendForm (
   //

   InitializeBrowserStrings ();

 

-  gFunctionKeySetting = ENABLE_FUNCTION_KEY_SETTING;

-

   //

   // Ensure we are in Text mode

   //

@@ -378,6 +383,7 @@ SendForm (
   }

 

   FreeBrowserStrings ();

+  UiFreeMenuList(&gMenuList);

 

   gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK));

   gST->ConOut->ClearScreen (gST->ConOut);

@@ -557,66 +563,6 @@ BrowserCallback (
 }

 

 /**

-  Notify function will remove the formset in the maintain list 

-  once this formset is removed.

-  

-  Functions which are registered to receive notification of

-  database events have this prototype. The actual event is encoded

-  in NotifyType. The following table describes how PackageType,

-  PackageGuid, Handle, and Package are used for each of the

-  notification types.

-

-  @param PackageType  Package type of the notification.

-

-  @param PackageGuid  If PackageType is

-                      EFI_HII_PACKAGE_TYPE_GUID, then this is

-                      the pointer to the GUID from the Guid

-                      field of EFI_HII_PACKAGE_GUID_HEADER.

-                      Otherwise, it must be NULL.

-

-  @param Package  Points to the package referred to by the

-                  notification Handle The handle of the package

-                  list which contains the specified package.

-

-  @param Handle       The HII handle.

-

-  @param NotifyType   The type of change concerning the

-                      database. See

-                      EFI_HII_DATABASE_NOTIFY_TYPE.

-

-**/

-EFI_STATUS

-EFIAPI

-FormsetRemoveNotify (

-  IN UINT8                              PackageType,

-  IN CONST EFI_GUID                     *PackageGuid,

-  IN CONST EFI_HII_PACKAGE_HEADER       *Package,

-  IN EFI_HII_HANDLE                     Handle,

-  IN EFI_HII_DATABASE_NOTIFY_TYPE       NotifyType

-  )

-{

-  FORM_BROWSER_FORMSET *FormSet;

-

-  //

-  // Ignore the update for current using formset, which is handled by another notify function.

-  //

-  if (IsHiiHandleInBrowserContext (Handle)) {

-    return EFI_SUCCESS;

-  }

-  

-  //

-  // Remove the backup FormSet data when the Form Package is removed.

-  //

-  FormSet = GetFormSetFromHiiHandle (Handle);

-  if (FormSet != NULL) {

-    RemoveEntryList (&FormSet->Link);

-    DestroyFormSet (FormSet);

-  }

-  

-  return EFI_SUCCESS;

-}

-

-/**

   Initialize Setup Browser driver.

 

   @param ImageHandle     The image handle.

@@ -634,7 +580,6 @@ InitializeSetup (
   )

 {

   EFI_STATUS                  Status;

-  EFI_HANDLE                  NotifyHandle;

   EFI_INPUT_KEY               DefaultHotKey;

   EFI_STRING                  HelpString;

 

@@ -662,6 +607,12 @@ InitializeSetup (
                   );

   ASSERT_EFI_ERROR (Status);

 

+  Status = gBS->LocateProtocol (

+                  &gEfiDevicePathFromTextProtocolGuid,

+                  NULL,

+                  (VOID **) &mPathFromText

+                  );

+

   //

   // Publish our HII data

   //

@@ -726,19 +677,6 @@ InitializeSetup (
                   );

   ASSERT_EFI_ERROR (Status);

 

-  //

-  // Register notify for Form package remove

-  //

-  Status = mHiiDatabase->RegisterPackageNotify (

-                           mHiiDatabase,

-                           EFI_HII_PACKAGE_FORMS,

-                           NULL,

-                           FormsetRemoveNotify,

-                           EFI_HII_DATABASE_NOTIFY_REMOVE_PACK,

-                           &NotifyHandle

-                           );

-  ASSERT_EFI_ERROR (Status);

-

   return Status;

 }

 

@@ -2251,6 +2189,52 @@ SendDiscardInfoToDriver (
 }

 

 /**

+  Validate the FormSet. If the formset is not validate, remove it from the list.

+

+  @param  FormSet                The input FormSet which need to validate.

+

+  @retval TRUE                   The handle is validate.

+  @retval FALSE                  The handle is invalidate.

+

+**/

+BOOLEAN

+ValidateFormSet (

+  FORM_BROWSER_FORMSET    *FormSet

+  )

+{

+  EFI_HII_HANDLE          *HiiHandles;

+  UINTN                   Index;

+  BOOLEAN                 Find;

+

+  ASSERT (FormSet != NULL);

+  Find = FALSE;

+  //

+  // Get all the Hii handles

+  //

+  HiiHandles = HiiGetHiiHandles (NULL);

+  ASSERT (HiiHandles != NULL);

+

+  //

+  // Search for formset of each class type

+  //

+  for (Index = 0; HiiHandles[Index] != NULL; Index++) {

+    if (HiiHandles[Index] == FormSet->HiiHandle) {

+      Find = TRUE;

+      break;

+    }

+  }

+

+  if (!Find) {

+    RemoveEntryList (&FormSet->Link);

+    DestroyFormSet (FormSet);

+  }

+

+  FreePool (HiiHandles);

+

+  return Find;

+}

+

+/**

   Discard data based on the input setting scope (Form, FormSet or System).

 

   @param  FormSet                FormSet data structure.

@@ -2357,8 +2341,11 @@ DiscardForm (
     Link = GetFirstNode (&gBrowserFormSetList);

     while (!IsNull (&gBrowserFormSetList, Link)) {

       LocalFormSet = FORM_BROWSER_FORMSET_FROM_LINK (Link);

-      DiscardForm (LocalFormSet, NULL, FormSetLevel);

       Link = GetNextNode (&gBrowserFormSetList, Link);

+      if (!ValidateFormSet(LocalFormSet)) {

+        continue;

+      }

+      DiscardForm (LocalFormSet, NULL, FormSetLevel);

       if (!IsHiiHandleInBrowserContext (LocalFormSet->HiiHandle)) {

         //

         // Remove maintain backup list after discard except for the current using FormSet.

@@ -2638,8 +2625,11 @@ SubmitForm (
     Link = GetFirstNode (&gBrowserFormSetList);

     while (!IsNull (&gBrowserFormSetList, Link)) {

       LocalFormSet = FORM_BROWSER_FORMSET_FROM_LINK (Link);

-      SubmitForm (LocalFormSet, NULL, FormSetLevel);

       Link = GetNextNode (&gBrowserFormSetList, Link);

+      if (!ValidateFormSet(LocalFormSet)) {

+        continue;

+      }

+      SubmitForm (LocalFormSet, NULL, FormSetLevel);

       if (!IsHiiHandleInBrowserContext (LocalFormSet->HiiHandle)) {

         //

         // Remove maintain backup list after save except for the current using FormSet.

@@ -3324,8 +3314,11 @@ ExtractDefault (
     Link = GetFirstNode (&gBrowserFormSetList);

     while (!IsNull (&gBrowserFormSetList, Link)) {

       LocalFormSet = FORM_BROWSER_FORMSET_FROM_LINK (Link);

-      ExtractDefault (LocalFormSet, NULL, DefaultId, FormSetLevel, GetDefaultValueScope, Storage, RetrieveValueFirst);

       Link = GetNextNode (&gBrowserFormSetList, Link);

+      if (!ValidateFormSet(LocalFormSet)) {

+        continue;

+      }

+      ExtractDefault (LocalFormSet, NULL, DefaultId, FormSetLevel, GetDefaultValueScope, Storage, RetrieveValueFirst);

     }

   }

 

@@ -4020,6 +4013,8 @@ InitializeFormSet (
     }

   }

 

+  gFunctionKeySetting = ENABLE_FUNCTION_KEY_SETTING;

+

   if ((gClassOfVfr & FORMSET_CLASS_FRONT_PAGE) == FORMSET_CLASS_FRONT_PAGE) {

     gFrontPageHandle = FormSet->HiiHandle;

     gFunctionKeySetting = NONE_FUNCTION_KEY_SETTING;

@@ -4107,6 +4102,7 @@ SaveBrowserContext (
   Context->HelpBlockWidth       = gHelpBlockWidth;

   Context->OldFormSet           = gOldFormSet;

   Context->MenuRefreshHead      = gMenuRefreshHead;

+  Context->ProtocolNotFound     = gProtocolNotFound;

 

   CopyMem (&Context->ScreenDimensions, &gScreenDimensions, sizeof (gScreenDimensions));

   CopyMem (&Context->MenuOption, &gMenuOption, sizeof (gMenuOption));

@@ -4184,6 +4180,7 @@ RestoreBrowserContext (
   gHelpBlockWidth       = Context->HelpBlockWidth;

   gOldFormSet           = Context->OldFormSet;

   gMenuRefreshHead      = Context->MenuRefreshHead;

+  gProtocolNotFound     = Context->ProtocolNotFound;

 

   CopyMem (&gScreenDimensions, &Context->ScreenDimensions, sizeof (gScreenDimensions));

   CopyMem (&gMenuOption, &Context->MenuOption, sizeof (gMenuOption));

@@ -4214,10 +4211,13 @@ GetFormSetFromHiiHandle (
   Link = GetFirstNode (&gBrowserFormSetList);

   while (!IsNull (&gBrowserFormSetList, Link)) {

     FormSet = FORM_BROWSER_FORMSET_FROM_LINK (Link);

+    Link = GetNextNode (&gBrowserFormSetList, Link);

+    if (!ValidateFormSet(FormSet)) {

+      continue;

+    }

     if (FormSet->HiiHandle == Handle) {

       return FormSet;

     }

-    Link = GetNextNode (&gBrowserFormSetList, Link);

   }

   

   return NULL;

@@ -4470,11 +4470,14 @@ SaveReminder (
   Link = GetFirstNode (&gBrowserFormSetList);

   while (!IsNull (&gBrowserFormSetList, Link)) {

     FormSet = FORM_BROWSER_FORMSET_FROM_LINK (Link);

+    Link = GetNextNode (&gBrowserFormSetList, Link);

+    if (!ValidateFormSet(FormSet)) {

+      continue;

+    }

     if (IsNvUpdateRequired (FormSet)) {

       IsDataChanged = TRUE;

       break;

     }

-    Link = GetNextNode (&gBrowserFormSetList, Link);

   }

   

   //

diff --git a/MdeModulePkg/Universal/SetupBrowserDxe/Setup.h b/MdeModulePkg/Universal/SetupBrowserDxe/Setup.h
index e11cdc16..8e32cb4e 100644
--- a/MdeModulePkg/Universal/SetupBrowserDxe/Setup.h
+++ b/MdeModulePkg/Universal/SetupBrowserDxe/Setup.h
@@ -1,7 +1,7 @@
 /** @file

 Private MACRO, structure and function definitions for Setup Browser module.

 

-Copyright (c) 2007 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -30,6 +30,7 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 #include <Protocol/HiiDatabase.h>

 #include <Protocol/HiiString.h>

 #include <Protocol/UserManager.h>

+#include <Protocol/DevicePathFromText.h>

 

 #include <Guid/MdeModuleHii.h>

 #include <Guid/HiiPlatformSetupFormset.h>

@@ -546,6 +547,7 @@ typedef struct {
   CHAR16                *SaveChanges;

   CHAR16                *OptionMismatch;

   CHAR16                *FormSuppress;

+  CHAR16                *ProtocolNotFound;

   CHAR16                PromptBlockWidth;

   CHAR16                OptionBlockWidth;

   CHAR16                HelpBlockWidth;

@@ -597,6 +599,7 @@ typedef enum {
 extern EFI_HII_DATABASE_PROTOCOL         *mHiiDatabase;

 extern EFI_HII_STRING_PROTOCOL           *mHiiString;

 extern EFI_HII_CONFIG_ROUTING_PROTOCOL   *mHiiConfigRouting;

+extern EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL *mPathFromText;

 

 extern BANNER_DATA           *gBannerData;

 extern EFI_HII_HANDLE        gFrontPageHandle;

@@ -647,6 +650,7 @@ extern CHAR16            *gAdjustNumber;
 extern CHAR16            *gSaveChanges;

 extern CHAR16            *gOptionMismatch;

 extern CHAR16            *gFormSuppress;

+extern CHAR16            *gProtocolNotFound;

 

 extern CHAR16            gPromptBlockWidth;

 extern CHAR16            gOptionBlockWidth;

diff --git a/MdeModulePkg/Universal/SetupBrowserDxe/SetupBrowserDxe.inf b/MdeModulePkg/Universal/SetupBrowserDxe/SetupBrowserDxe.inf
index 2edbd3ad..7e740bc0 100644
--- a/MdeModulePkg/Universal/SetupBrowserDxe/SetupBrowserDxe.inf
+++ b/MdeModulePkg/Universal/SetupBrowserDxe/SetupBrowserDxe.inf
@@ -1,7 +1,7 @@
 ## @file

 # The DXE driver produces FORM BROWSER protocols defined in UEFI HII 2.1 specificatin.

 #

-# Copyright (c) 2007 - 2012, Intel Corporation. All rights reserved.<BR>

+# Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>

 #

 #  This program and the accompanying materials

 #  are licensed and made available under the terms and conditions of the BSD License

@@ -75,10 +75,12 @@
   gEfiHiiDatabaseProtocolGuid                   ## CONSUMES

   gEfiUnicodeCollation2ProtocolGuid             ## CONSUMES

   gEfiUserManagerProtocolGuid                   ## SOMETIMES_CONSUMES

+  gEfiDevicePathFromTextProtocolGuid            ## SOMETIMES_CONSUMES

 

 [FeaturePcd]

   gEfiMdeModulePkgTokenSpaceGuid.PcdFrameworkCompatibilitySupport          ## CONSUMES

   gEfiMdeModulePkgTokenSpaceGuid.PcdBrowserGrayOutTextStatement            ## CONSUMES

+  gEfiMdeModulePkgTokenSpaceGuid.PcdBrowerGrayOutReadOnlyMenu              ## CONSUMES

 

 [Pcd]

   gEfiMdeModulePkgTokenSpaceGuid.PcdBrowserSubtitleTextColor               ## CONSUMES

diff --git a/MdeModulePkg/Universal/SetupBrowserDxe/SetupBrowserStr.uni b/MdeModulePkg/Universal/SetupBrowserDxe/SetupBrowserStr.uni
index b155a557..bb6414d2 100644
--- a/MdeModulePkg/Universal/SetupBrowserDxe/SetupBrowserStr.uni
+++ b/MdeModulePkg/Universal/SetupBrowserDxe/SetupBrowserStr.uni
diff --git a/MdeModulePkg/Universal/SetupBrowserDxe/Ui.c b/MdeModulePkg/Universal/SetupBrowserDxe/Ui.c
index b011ad39..7c246b60 100644
--- a/MdeModulePkg/Universal/SetupBrowserDxe/Ui.c
+++ b/MdeModulePkg/Universal/SetupBrowserDxe/Ui.c
@@ -1,7 +1,7 @@
 /** @file

 Utility functions for User Interface functions.

 

-Copyright (c) 2004 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -15,7 +15,7 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 #include "Setup.h"

 

 LIST_ENTRY          gMenuOption;

-LIST_ENTRY          gMenuList = INITIALIZE_LIST_HEAD_VARIABLE (gMenuList);

+LIST_ENTRY          gMenuList;

 MENU_REFRESH_ENTRY  *gMenuRefreshHead;                // Menu list used for refresh timer opcode.

 MENU_REFRESH_ENTRY  *gMenuEventGuidRefreshHead;       // Menu list used for refresh event guid opcode.

 

@@ -219,9 +219,10 @@ UiAddMenuList (
 

 

 /**

-  Search Menu with given FormId and FormSetGuid in all cached menu list.

+  Search Menu with given FormId, FormSetGuid and Handle in all cached menu list.

 

   @param  Parent                 The parent of menu to search.

+  @param  Handle                 Hii handle related to this formset.

   @param  FormSetGuid            The Formset GUID of the menu to search.  

   @param  FormId                 The Form ID of menu to search.

 

@@ -231,6 +232,7 @@ UiAddMenuList (
 UI_MENU_LIST *

 UiFindChildMenuList (

   IN UI_MENU_LIST         *Parent,

+  IN EFI_HII_HANDLE       Handle,

   IN EFI_GUID             *FormSetGuid, 

   IN UINT16               FormId

   )

@@ -241,7 +243,7 @@ UiFindChildMenuList (
 

   ASSERT (Parent != NULL);

 

-  if (Parent->FormId == FormId && CompareGuid (FormSetGuid, &Parent->FormSetGuid)) {

+  if (Parent->FormId == FormId && CompareGuid (FormSetGuid, &Parent->FormSetGuid) && Parent->HiiHandle == Handle) {

     return Parent;

   }

 

@@ -249,7 +251,7 @@ UiFindChildMenuList (
   while (!IsNull (&Parent->ChildListHead, Link)) {

     Child = UI_MENU_LIST_FROM_LINK (Link);

 

-    MenuList = UiFindChildMenuList (Child, FormSetGuid, FormId);

+    MenuList = UiFindChildMenuList (Child, Handle, FormSetGuid, FormId);

     if (MenuList != NULL) {

       return MenuList;

     }

@@ -262,8 +264,9 @@ UiFindChildMenuList (
 

 

 /**

-  Search Menu with given FormSetGuid and FormId in all cached menu list.

+  Search Menu with given Handle, FormSetGuid and FormId in all cached menu list.

 

+  @param  Handle                 Hii handle related to this formset.

   @param  FormSetGuid            The Formset GUID of the menu to search.

   @param  FormId                 The Form ID of menu to search.

 

@@ -272,6 +275,7 @@ UiFindChildMenuList (
 **/

 UI_MENU_LIST *

 UiFindMenuList (

+  IN EFI_HII_HANDLE       Handle,

   IN EFI_GUID             *FormSetGuid,

   IN UINT16               FormId

   )

@@ -284,8 +288,14 @@ UiFindMenuList (
   while (!IsNull (&gMenuList, Link)) {

     MenuList = UI_MENU_LIST_FROM_LINK (Link);

 

-    Child = UiFindChildMenuList(MenuList, FormSetGuid, FormId);

+    Child = UiFindChildMenuList(MenuList, Handle, FormSetGuid, FormId);

     if (Child != NULL) {

+

+      //

+      // If this form already in the menu history list,

+      // just free the list between old this form.

+      //

+      UiFreeMenuList(&Child->ChildListHead);

       return Child;

     }

 

@@ -295,6 +305,28 @@ UiFindMenuList (
   return NULL;

 }

 

+/**

+  Free Menu list linked list.

+

+  @param  MenuListHead    One Menu list point in the menu list.

+

+**/

+VOID

+UiFreeMenuList (

+  LIST_ENTRY   *MenuListHead

+  )

+{

+  UI_MENU_LIST    *MenuList;

+

+  while (!IsListEmpty (MenuListHead)) {

+    MenuList = UI_MENU_LIST_FROM_LINK (MenuListHead->ForwardLink);

+    RemoveEntryList (&MenuList->Link);

+    

+    UiFreeMenuList(&MenuList->ChildListHead);

+    FreePool (MenuList);

+  }

+

+}

 

 /**

   Free Menu option linked list.

@@ -778,6 +810,9 @@ UiAddMenuOption (
     if ((Statement->ValueExpression != NULL) ||

         ((Statement->QuestionFlags & EFI_IFR_FLAG_READ_ONLY) != 0)) {

       MenuOption->ReadOnly = TRUE;

+      if (FeaturePcdGet (PcdBrowerGrayOutReadOnlyMenu)) {

+        MenuOption->GrayOut = TRUE;

+      }

     }

 

     InsertTailList (&gMenuOption, &MenuOption->Link);

@@ -1507,36 +1542,34 @@ UpdateOptionSkipLines (
 

   Row           = 0;

   OptionString  = NULL;

+  Width         = (UINT16) gOptionBlockWidth;

+  OriginalRow   = 0;

+  GlyphWidth    = 1;

+  

   ProcessOptions (Selection, MenuOption, FALSE, &OptionString);

+  if (OptionString == NULL) {

+    return;

+  }

 

-  if (OptionString != NULL) {

-    Width               = (UINT16) gOptionBlockWidth;

-

-    OriginalRow         = Row;

-    GlyphWidth          = 1;

-

-    for (Index = 0; GetLineByWidth (OptionString, Width, &GlyphWidth, &Index, &OutputString) != 0x0000;) {

+  for (Index = 0; GetLineByWidth (OptionString, Width, &GlyphWidth, &Index, &OutputString) != 0x0000;) {

+    //

+    // If there is more string to process print on the next row and increment the Skip value

+    //

+    if (StrLen (&OptionString[Index]) != 0) {

+      Row++;

       //

-      // If there is more string to process print on the next row and increment the Skip value

+      // Since the Number of lines for this menu entry may or may not be reflected accurately

+      // since the prompt might be 1 lines and option might be many, and vice versa, we need to do

+      // some testing to ensure we are keeping this in-sync.

       //

-      if (StrLen (&OptionString[Index]) != 0) {

-        Row++;

-        //

-        // Since the Number of lines for this menu entry may or may not be reflected accurately

-        // since the prompt might be 1 lines and option might be many, and vice versa, we need to do

-        // some testing to ensure we are keeping this in-sync.

-        //

-        // If the difference in rows is greater than or equal to the skip value, increase the skip value

-        //

-        if ((Row - OriginalRow) >= MenuOption->Skip) {

-          MenuOption->Skip++;

-        }

+      // If the difference in rows is greater than or equal to the skip value, increase the skip value

+      //

+      if ((Row - OriginalRow) >= MenuOption->Skip) {

+        MenuOption->Skip++;

       }

-

-      FreePool (OutputString);

     }

 

-    Row = OriginalRow;

+    FreePool (OutputString);

   }

 

   if (OptionString != NULL) {

@@ -1612,6 +1645,10 @@ ValueIsScroll (
 

   @return The row distance from current MenuOption to next selectable MenuOption.

 

+  @retval -1       Reach the begin of the menu, still can't find the selectable menu.

+  @retval Value    Find the selectable menu, maybe the truly selectable, maybe the l

+                   last menu showing at current form.

+

 **/

 INTN

 MoveToNextStatement (

@@ -1632,41 +1669,56 @@ MoveToNextStatement (
 

   while (TRUE) {

     NextMenuOption = MENU_OPTION_FROM_LINK (Pos);

+    //

+    // NextMenuOption->Row == 0 means this menu has not calculate

+    // the NextMenuOption->Skip value yet, just calculate here.

+    //

     if (NextMenuOption->Row == 0) {

       UpdateOptionSkipLines (Selection, NextMenuOption);

     }

     

     if (GoUp && (PreMenuOption != NextMenuOption)) {

       //

-      // Current Position doesn't need to be caculated when go up.

-      // Caculate distanct at first when go up

+      // In this case, still can't find the selectable menu,

+      // return the last one in the showing form.

       //

       if ((UINTN) Distance + NextMenuOption->Skip > GapToTop) {

         NextMenuOption = PreMenuOption;

         break;

       }

+

+      //

+      // Current Position doesn't need to be caculated when go up.

+      // Caculate distanct at first when go up

+      //      

       Distance += NextMenuOption->Skip;

     }

+

     if (IsSelectable (NextMenuOption)) {

       break;

     }

+

+    //

+    // Arrive at begin of the menu list.

+    //

     if ((GoUp ? Pos->BackLink : Pos->ForwardLink) == &gMenuOption) {

-      //

-      // Arrive at top.

-      //

       Distance = -1;

       break;

     }

+

     if (!GoUp) {

       //

-      // Caculate distanct at later when go down

+      // In this case, still can't find the selectable menu,

+      // return the last one in the showing form.

       //

       if ((UINTN) Distance + NextMenuOption->Skip > GapToTop) {

         NextMenuOption = PreMenuOption;

         break;

       }

+

       Distance += NextMenuOption->Skip;

     }

+

     PreMenuOption = NextMenuOption;

     Pos = (GoUp ? Pos->BackLink : Pos->ForwardLink);

   }

@@ -1954,55 +2006,6 @@ FormSetGuidToHiiHandle (
 }

 

 /**

-  Transfer the device path string to binary format.

-

-  @param   StringPtr     The device path string info.

-

-  @retval  Device path binary info.

-

-**/

-EFI_DEVICE_PATH_PROTOCOL *

-ConvertDevicePathFromText (

-  IN CHAR16  *StringPtr

-  )

-{

-  UINTN                           BufferSize;

-  EFI_DEVICE_PATH_PROTOCOL        *DevicePath;

-  CHAR16                          TemStr[2];

-  UINT8                           *DevicePathBuffer;

-  UINTN                           Index;

-  UINT8                           DigitUint8;

-

-  ASSERT (StringPtr != NULL);

-

-  BufferSize = StrLen (StringPtr) / 2;

-  DevicePath = AllocatePool (BufferSize);

-  ASSERT (DevicePath != NULL);

-  

-  //

-  // Convert from Device Path String to DevicePath Buffer in the reverse order.

-  //

-  DevicePathBuffer = (UINT8 *) DevicePath;

-  for (Index = 0; StringPtr[Index] != L'\0'; Index ++) {

-    TemStr[0] = StringPtr[Index];

-    DigitUint8 = (UINT8) StrHexToUint64 (TemStr);

-    if (DigitUint8 == 0 && TemStr[0] != L'0') {

-      //

-      // Invalid Hex Char as the tail.

-      //

-      break;

-    }

-    if ((Index & 1) == 0) {

-      DevicePathBuffer [Index/2] = DigitUint8;

-    } else {

-      DevicePathBuffer [Index/2] = (UINT8) ((DevicePathBuffer [Index/2] << 4) + DigitUint8);

-    }

-  }

-

-  return DevicePath;

-}

-

-/**

   Process the goto op code, update the info in the selection structure.

 

   @param Statement    The statement belong to goto op code.

@@ -2026,11 +2029,8 @@ ProcessGotoOpCode (
   FORM_BROWSER_FORM               *RefForm;

   EFI_INPUT_KEY                   Key;

   EFI_STATUS                      Status;

-  UI_MENU_LIST                    *MenuList;

-  BOOLEAN                         UpdateFormInfo;

-  

-  Status = EFI_SUCCESS;

-  UpdateFormInfo = TRUE;

+

+  Status    = EFI_SUCCESS;

   StringPtr = NULL;

 

   //

@@ -2047,16 +2047,32 @@ ProcessGotoOpCode (
     if (Selection->Form->ModalForm) {

       return Status;

     }

+

     //

     // Goto another Hii Package list

     //

-    Selection->Action = UI_ACTION_REFRESH_FORMSET;

-    DevicePath = ConvertDevicePathFromText (StringPtr);

-

-    Selection->Handle = DevicePathToHiiHandle (DevicePath);

-    FreePool (DevicePath);

-    FreePool (StringPtr);

+    if (mPathFromText != NULL) {

+      DevicePath = mPathFromText->ConvertTextToDevicePath(StringPtr);

+      if (DevicePath != NULL) {

+        Selection->Handle = DevicePathToHiiHandle (DevicePath);

+        FreePool (DevicePath);

+      }

+      FreePool (StringPtr);

+    } else {

+      //

+      // Not found the EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL protocol.

+      //

+      do {

+        CreateDialog (4, TRUE, 0, NULL, &Key, gEmptyString, gProtocolNotFound, gPressEnter, gEmptyString);

+      } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);

+      if (Repaint != NULL) {

+        *Repaint = TRUE;

+      }

+      FreePool (StringPtr);

+      return Status;

+    }

 

+    Selection->Action = UI_ACTION_REFRESH_FORMSET;

     if (Selection->Handle == NULL) {

       //

       // If target Hii Handle not found, exit

@@ -2135,22 +2151,10 @@ ProcessGotoOpCode (
         *NewLine = TRUE;

       }

     }

-    UpdateFormInfo = FALSE;

   } else {

     if ((Statement->QuestionFlags & EFI_IFR_FLAG_CALLBACK) != 0) {

       Selection->Action = UI_ACTION_REFRESH_FORM;

     }

-    UpdateFormInfo = FALSE;

-  }

-

-  if (UpdateFormInfo) {

-    //

-    // Link current form so that we can always go back when someone hits the ESC

-    //

-    MenuList = UiFindMenuList (&Selection->FormSetGuid, Selection->FormId);

-    if (MenuList == NULL && Selection->CurrentMenu != NULL) {

-      MenuList = UiAddMenuList (Selection->CurrentMenu, Selection->Handle, &Selection->FormSetGuid, Selection->FormId);

-    }

   }

 

   return Status;

@@ -2173,7 +2177,6 @@ UiDisplayMenu (
 {

   INTN                            SkipValue;

   INTN                            Difference;

-  INTN                            OldSkipValue;

   UINTN                           DistanceValue;

   UINTN                           Row;

   UINTN                           Col;

@@ -2254,7 +2257,6 @@ UiDisplayMenu (
   UpArrow             = FALSE;

   DownArrow           = FALSE;

   SkipValue           = 0;

-  OldSkipValue        = 0;

   MenuRefreshEntry    = gMenuRefreshHead;

 

   NextMenuOption      = NULL;

@@ -2294,12 +2296,12 @@ UiDisplayMenu (
   //

   // Find current Menu

   //

-  CurrentMenu = UiFindMenuList (&Selection->FormSetGuid, Selection->FormId);

+  CurrentMenu = UiFindMenuList (Selection->Handle, &Selection->FormSetGuid, Selection->FormId);

   if (CurrentMenu == NULL) {

     //

     // Current menu not found, add it to the menu tree

     //

-    CurrentMenu = UiAddMenuList (NULL, Selection->Handle, &Selection->FormSetGuid, Selection->FormId);

+    CurrentMenu = UiAddMenuList (Selection->CurrentMenu, Selection->Handle, &Selection->FormSetGuid, Selection->FormId);

   }

   ASSERT (CurrentMenu != NULL);

   Selection->CurrentMenu = CurrentMenu;

@@ -2355,6 +2357,9 @@ UiDisplayMenu (
         Temp            = (UINTN) SkipValue;

         Temp2           = (UINTN) SkipValue;

 

+        //

+        // 1. Clear the screen.

+        //

         if (Selection->Form->ModalForm) {

           ClearLines (

             LocalScreen.LeftColumn + ModalSkipColumn,

@@ -2375,6 +2380,9 @@ UiDisplayMenu (
         UiFreeRefreshList ();

         MinRefreshInterval = 0;

 

+        //

+        // 2.Paint the menu.

+        //

         for (Link = TopOfScreen; Link != &gMenuOption; Link = Link->ForwardLink) {

           MenuOption          = MENU_OPTION_FROM_LINK (Link);

           MenuOption->Row     = Row;

@@ -2414,7 +2422,13 @@ UiDisplayMenu (
               );

           }

 

+          //

+          // 2.1. Paint the description.

+          //

           for (Index = 0; GetLineByWidth (MenuOption->Description, Width, &GlyphWidth, &Index, &OutputString) != 0x0000;) {

+            //

+            // Temp means need to skip how many lines from the start.

+            //

             if ((Temp == 0) && (Row <= BottomRow)) {

               PrintStringAt (MenuOption->Col, Row, OutputString);

             }

@@ -2436,6 +2450,9 @@ UiDisplayMenu (
           Temp  = 0;

           Row   = OriginalRow;

 

+          //

+          // 2.2. Paint the option string.

+          //

           Status = ProcessOptions (Selection, MenuOption, FALSE, &OptionString);

           if (EFI_ERROR (Status)) {

             //

@@ -2492,7 +2509,7 @@ UiDisplayMenu (
           }

 

           //

-          // If Question has refresh guid, register the op-code.

+          // 2.4 Special process for Test opcode with test two.

           //

           if (!CompareGuid (&Statement->RefreshGuid, &gZeroGuid)) {

             if (gMenuEventGuidRefreshHead == NULL) {

@@ -2600,11 +2617,10 @@ UiDisplayMenu (
           gST->ConOut->SetAttribute (gST->ConOut, PcdGet8 (PcdBrowserFieldTextColor) | FIELD_BACKGROUND);

 

           //

-          // Need to handle the bottom of the display

+          // 3. Update the row info which will be used by next menu.

           //

-          if (MenuOption->Skip > 1) {

+          if (Link == TopOfScreen) {

             Row += MenuOption->Skip - SkipValue;

-            SkipValue = 0;

           } else {

             Row += MenuOption->Skip;

           }

@@ -2656,6 +2672,16 @@ UiDisplayMenu (
       // NewPos:     Current menu option that need to hilight

       //

       ControlFlag = CfUpdateHelpString;

+      if (TopOfScreen == &MenuOption->Link) {

+        Temp = SkipValue;

+      } else {

+        Temp = 0;

+      }

+      if (NewPos == TopOfScreen) {

+        Temp2 = SkipValue;

+      } else {

+        Temp2 = 0;

+      }

       if (InitializedFlag) {

         InitializedFlag = FALSE;

         MoveToNextStatement (Selection, FALSE, &NewPos, BottomRow - TopRow);

@@ -2688,7 +2714,7 @@ UiDisplayMenu (
             SavedMenuOption = MENU_OPTION_FROM_LINK (Link);

             Index += SavedMenuOption->Skip;

             if (Link == TopOfScreen) {

-              Index -= OldSkipValue;

+              Index -= SkipValue;

             }

             Link = Link->ForwardLink;

           }

@@ -2746,7 +2772,6 @@ UiDisplayMenu (
               //

               SkipValue    = 0;

               TopOfScreen  = Link;

-              OldSkipValue = SkipValue;

             } else {

               //

               // Check whether need to skip some line for menu shows at the top of the page.

@@ -2754,7 +2779,6 @@ UiDisplayMenu (
               SkipValue = Index - BottomRow - 1;

               if (SkipValue > 0 && SkipValue < (INTN) SavedMenuOption->Skip) {

                 TopOfScreen     = Link;

-                OldSkipValue    = SkipValue;

               } else {

                 SkipValue       = 0;

                 TopOfScreen     = Link->ForwardLink;

@@ -2796,17 +2820,22 @@ UiDisplayMenu (
             GlyphWidth          = 1;

 

             for (Index = 0; GetLineByWidth (OptionString, Width, &GlyphWidth, &Index, &OutputString) != 0x0000;) {

-              if (MenuOption->Row >= TopRow && MenuOption->Row <= BottomRow) {

+              if ((Temp == 0) && (MenuOption->Row >= TopRow) && (MenuOption->Row <= BottomRow)) {

                 PrintStringAt (MenuOption->OptCol, MenuOption->Row, OutputString);

               }

               //

               // If there is more string to process print on the next row and increment the Skip value

               //

               if (StrLen (&OptionString[Index]) != 0) {

-                MenuOption->Row++;

+                if (Temp == 0) {

+                  MenuOption->Row++;

+                }

               }

 

               FreePool (OutputString);

+              if (Temp != 0) {

+                Temp--;

+              }

             }

 

             MenuOption->Row = OriginalRow;

@@ -2825,17 +2854,22 @@ UiDisplayMenu (
               GlyphWidth  = 1;

 

               for (Index = 0; GetLineByWidth (MenuOption->Description, Width, &GlyphWidth, &Index, &OutputString) != 0x0000;) {

-                if (MenuOption->Row >= TopRow && MenuOption->Row <= BottomRow) {

+                if ((Temp == 0) && (MenuOption->Row >= TopRow) && (MenuOption->Row <= BottomRow)) {

                   PrintStringAt (MenuOption->Col, MenuOption->Row, OutputString);

                 }

                 //

                 // If there is more string to process print on the next row and increment the Skip value

                 //

                 if (StrLen (&MenuOption->Description[Index]) != 0) {

-                  MenuOption->Row++;

+                  if (Temp == 0) {

+                    MenuOption->Row++;

+                  }

                 }

 

                 FreePool (OutputString);

+                if (Temp != 0) {

+                  Temp--;

+                }

               }

 

               MenuOption->Row = OriginalRow;

@@ -2897,17 +2931,22 @@ UiDisplayMenu (
           GlyphWidth          = 1;

 

           for (Index = 0; GetLineByWidth (OptionString, Width, &GlyphWidth, &Index, &OutputString) != 0x0000;) {

-            if (MenuOption->Row >= TopRow && MenuOption->Row <= BottomRow) {

+            if ((Temp2 == 0) && (MenuOption->Row >= TopRow) && (MenuOption->Row <= BottomRow) ) {

               PrintStringAt (MenuOption->OptCol, MenuOption->Row, OutputString);

             }

             //

             // If there is more string to process print on the next row and increment the Skip value

             //

             if (StrLen (&OptionString[Index]) != 0) {

+              if (Temp2 == 0) {

               MenuOption->Row++;

+              }

             }

 

             FreePool (OutputString);

+            if (Temp2 != 0) {

+              Temp2--;

+            }

           }

 

           MenuOption->Row = OriginalRow;

@@ -2921,17 +2960,22 @@ UiDisplayMenu (
             GlyphWidth          = 1;

 

             for (Index = 0; GetLineByWidth (MenuOption->Description, Width, &GlyphWidth, &Index, &OutputString) != 0x0000;) {

-              if (MenuOption->Row >= TopRow && MenuOption->Row <= BottomRow) {

+              if ((Temp2 == 0) && (MenuOption->Row >= TopRow) && (MenuOption->Row <= BottomRow) ) {

                 PrintStringAt (MenuOption->Col, MenuOption->Row, OutputString);

               }

               //

               // If there is more string to process print on the next row and increment the Skip value

               //

               if (StrLen (&MenuOption->Description[Index]) != 0) {

-                MenuOption->Row++;

+                if (Temp2 == 0) {

+                  MenuOption->Row++;

+                }

               }

 

               FreePool (OutputString);

+              if (Temp2 != 0) {

+                Temp2--;

+              }

             }

 

             MenuOption->Row = OriginalRow;

@@ -3258,7 +3302,8 @@ UiDisplayMenu (
           // Check whether Key matches the registered hot key.

           //

           HotKey = NULL;

-          if ((gBrowserSettingScope == SystemLevel) || (gFunctionKeySetting != NONE_FUNCTION_KEY_SETTING)) {

+          if ((gBrowserSettingScope == SystemLevel) || 

+              (Selection->FormEditable && gFunctionKeySetting != NONE_FUNCTION_KEY_SETTING)) {

             HotKey = GetHotKeyFromRegisterList (&Key);

           }

           if (HotKey != NULL) {

@@ -3446,7 +3491,6 @@ UiDisplayMenu (
           TopOfScreen = NewPos;

           Repaint     = TRUE;

           SkipValue = 0;

-          OldSkipValue = 0;

         } else if (!IsSelectable (NextMenuOption)) {

           //

           // Continue to go up until scroll to next page or the selectable option is found.

@@ -3475,9 +3519,15 @@ UiDisplayMenu (
       break;

 

     case CfUiPageUp:

+      //

+      // SkipValue means lines is skipped when show the top menu option.

+      //

       ControlFlag     = CfCheckSelection;

 

       ASSERT(NewPos != NULL);

+      //

+      // Already at the first menu option, so do nothing.

+      //

       if (NewPos->BackLink == &gMenuOption) {

         NewLine = FALSE;

         Repaint = FALSE;

@@ -3486,8 +3536,22 @@ UiDisplayMenu (
 

       NewLine   = TRUE;

       Repaint   = TRUE;

+

+      //

+      // SkipValue > (BottomRow - TopRow + 1) means current menu has more than one

+      // form of options to be show, so just update the SkipValue to show the next

+      // parts of options.

+      //

+      if (SkipValue > (INTN) (BottomRow - TopRow + 1)) {

+        SkipValue -= BottomRow - TopRow + 1;

+        break;

+      }

+

       Link      = TopOfScreen;

-      Index     = BottomRow;

+      //

+      // First minus the menu of the top screen, it's value is SkipValue.

+      //

+      Index     = (BottomRow + 1) - SkipValue;

       while ((Index >= TopRow) && (Link->BackLink != &gMenuOption)) {

         Link = Link->BackLink;

         PreviousMenuOption = MENU_OPTION_FROM_LINK (Link);

@@ -3495,13 +3559,13 @@ UiDisplayMenu (
           UpdateOptionSkipLines (Selection, PreviousMenuOption);

         }        

         if (Index < PreviousMenuOption->Skip) {

-          Index = 0;

           break;

         }

         Index = Index - PreviousMenuOption->Skip;

       }

       

       if ((Link->BackLink == &gMenuOption) && (Index >= TopRow)) {

+        SkipValue = 0;

         if (TopOfScreen == &gMenuOption) {

           TopOfScreen = gMenuOption.ForwardLink;

           NewPos      = gMenuOption.BackLink;

@@ -3520,10 +3584,13 @@ UiDisplayMenu (
           MoveToNextStatement (Selection, FALSE, &NewPos, BottomRow - TopRow);

         }

       } else {

-        if (Index + 1 < TopRow) {

+        if (Index >= TopRow) {

           //

-          // Back up the previous option.

+          // At here, only case "Index < PreviousMenuOption->Skip" can reach here.

           //

+          SkipValue = PreviousMenuOption->Skip - (Index - TopRow);

+        } else {

+          SkipValue = PreviousMenuOption->Skip - (TopRow - Index);

           Link = Link->ForwardLink;

         }

 

@@ -3554,6 +3621,9 @@ UiDisplayMenu (
       break;

 

     case CfUiPageDown:

+      //

+      // SkipValue means lines is skipped when show the top menu option.

+      //

       ControlFlag     = CfCheckSelection;

 

       ASSERT (NewPos != NULL);

@@ -3567,47 +3637,62 @@ UiDisplayMenu (
       Repaint = TRUE;

       Link    = TopOfScreen;

       NextMenuOption = MENU_OPTION_FROM_LINK (Link);

-      Index = TopRow;

-      while ((Index <= BottomRow) && (Link->ForwardLink != &gMenuOption)) {

-        Index = Index + NextMenuOption->Skip;

+      Index = TopRow + NextMenuOption->Skip - SkipValue;

+      //

+      // Count to the menu option which will show at the top of the next form.

+      //

+      while ((Index <= BottomRow + 1) && (Link->ForwardLink != &gMenuOption)) {

         Link           = Link->ForwardLink;

         NextMenuOption = MENU_OPTION_FROM_LINK (Link);

+        Index = Index + NextMenuOption->Skip;

       }

 

-      if ((Link->ForwardLink == &gMenuOption) && (Index <= BottomRow)) {

+      if ((Link->ForwardLink == &gMenuOption) && (Index <= BottomRow + 1)) {

         //

         // Finally we know that NewPos is the last MenuOption can be focused.

         //

         Repaint = FALSE;

         MoveToNextStatement (Selection, TRUE, &Link, Index - TopRow);

+        SkipValue = 0;

       } else {

-        if (Index - 1 > BottomRow) {

+        //

+        // Calculate the skip line for top of screen menu.

+        //

+        if (Link == TopOfScreen) {

           //

-          // Back up the previous option.

+          // The top of screen menu option occupies the entire form.

           //

-          Link = Link->BackLink;

+          SkipValue += BottomRow - TopRow + 1;

+        } else {

+          SkipValue = NextMenuOption->Skip - (Index - (BottomRow + 1));

         }

-        //

-        // There are more MenuOption needing scrolling down.

-        //

+

         TopOfScreen = Link;

         MenuOption = NULL;

         //

-        // Move to the option in Next page.

+        // Move to the Next selectable menu.

         //

         MoveToNextStatement (Selection, FALSE, &Link, BottomRow - TopRow);

       }

 

       //

+      // Save the menu as the next highlight menu.

+      //

+      NewPos  = Link;

+

+      //

       // If we encounter a Date/Time op-code set, rewind to the first op-code of the set.

       // Don't do this when we are already in the last page.

       //

-      NewPos  = Link;

       AdjustDateAndTimePosition (TRUE, &TopOfScreen);

       AdjustDateAndTimePosition (TRUE, &NewPos);

       break;

 

     case CfUiDown:

+      //

+      // SkipValue means lines is skipped when show the top menu option.

+      // NewPos  points to the menu which is highlighted now.

+      //

       ControlFlag = CfCheckSelection;

       //

       // Since the behavior of hitting the down arrow on a Date/Time op-code is intended

@@ -3626,8 +3711,14 @@ UiDisplayMenu (
         NewPos          = NewPos->ForwardLink;

 

         Difference      = 0;

+        //

+        // Current menu not at the bottom of the form.

+        //

         if (BottomRow >= MenuOption->Row + MenuOption->Skip) {

-          Difference    = MoveToNextStatement (Selection, FALSE, &NewPos, BottomRow - MenuOption->Row - MenuOption->Skip);

+          //

+          // Find the next selectable menu.

+          //

+          Difference = MoveToNextStatement (Selection, FALSE, &NewPos, BottomRow - MenuOption->Row - MenuOption->Skip);

           //

           // We hit the end of MenuOption that can be focused

           // so we simply scroll to the first page.

@@ -3645,7 +3736,8 @@ UiDisplayMenu (
             }

             NewPos        = gMenuOption.ForwardLink;

             MoveToNextStatement (Selection, FALSE, &NewPos, BottomRow - TopRow);

-    

+

+            SkipValue = 0;

             //

             // If we are at the end of the list and sitting on a Date/Time op, rewind to the head.

             //

@@ -3655,11 +3747,9 @@ UiDisplayMenu (
           }

         }

         NextMenuOption  = MENU_OPTION_FROM_LINK (NewPos);

-

-        //

-        // An option might be multi-line, so we need to reflect that data in the overall skip value

-        //

-        UpdateOptionSkipLines (Selection, NextMenuOption);

+        if (NextMenuOption->Row == 0) {

+          UpdateOptionSkipLines (Selection, NextMenuOption);

+        }

         DistanceValue  = Difference + NextMenuOption->Skip;

 

         Temp = MenuOption->Row + MenuOption->Skip + DistanceValue - 1;

@@ -3684,18 +3774,16 @@ UiDisplayMenu (
             //

             // If bottom op-code is more than one line or top op-code is more than one line

             //

-            if ((DistanceValue > 1) || (MenuOption->Skip > 1)) {

+            if ((DistanceValue > 1) || (SavedMenuOption->Skip > 1)) {

               //

               // Is the bottom op-code greater than or equal in size to the top op-code?

               //

-              if ((Temp - BottomRow) >= (SavedMenuOption->Skip - OldSkipValue)) {

+              if ((Temp - BottomRow) >= (SavedMenuOption->Skip - SkipValue)) {

                 //

                 // Skip the top op-code

                 //

                 TopOfScreen     = TopOfScreen->ForwardLink;

-                Difference      = (Temp - BottomRow) - (SavedMenuOption->Skip - OldSkipValue);

-

-                OldSkipValue    = Difference;

+                Difference      = (Temp - BottomRow) - (SavedMenuOption->Skip - SkipValue);

 

                 SavedMenuOption = MENU_OPTION_FROM_LINK (TopOfScreen);

 

@@ -3715,20 +3803,17 @@ UiDisplayMenu (
                 // SkipValue, set the skips to one less than what is required.

                 //

                 SkipValue = Difference - 1;

-

               } else {

                 //

                 // Since we will act on this op-code in the next routine, and increment the

                 // SkipValue, set the skips to one less than what is required.

                 //

-                SkipValue = OldSkipValue + (Temp - BottomRow) - 1;

+                SkipValue += (Temp - BottomRow) - 1;

               }

             } else {

-              if ((OldSkipValue + 1) == (INTN) SavedMenuOption->Skip) {

+              if ((SkipValue + 1) == (INTN) SavedMenuOption->Skip) {

                 TopOfScreen = TopOfScreen->ForwardLink;

                 break;

-              } else {

-                SkipValue = OldSkipValue;

               }

             }

             //

@@ -3750,7 +3835,6 @@ UiDisplayMenu (
           } while (SavedMenuOption->Skip == 0);

 

           Repaint       = TRUE;

-          OldSkipValue  = SkipValue;

         } else if (!IsSelectable (NextMenuOption)) {

           //

           // Continue to go down until scroll to next page or the selectable option is found.

@@ -3772,9 +3856,18 @@ UiDisplayMenu (
           Repaint     = TRUE;

           MenuOption  = NULL;

         } else {

+          //

+          // Need to remove the current highlight menu.

+          // MenuOption saved the last highlight menu info.

+          //

           MenuOption = MENU_OPTION_FROM_LINK (SavedListEntry);

         }

+

+        SkipValue     = 0;

         NewLine       = TRUE;

+        //

+        // Get the next highlight menu.

+        //

         NewPos        = gMenuOption.ForwardLink;

         MoveToNextStatement (Selection, FALSE, &NewPos, BottomRow - TopRow);

       }

diff --git a/MdeModulePkg/Universal/SetupBrowserDxe/Ui.h b/MdeModulePkg/Universal/SetupBrowserDxe/Ui.h
index ac016bbe..03cb0cd7 100644
--- a/MdeModulePkg/Universal/SetupBrowserDxe/Ui.h
+++ b/MdeModulePkg/Universal/SetupBrowserDxe/Ui.h
@@ -1,7 +1,7 @@
 /** @file

 Private structure, MACRO and function definitions for User Interface related functionalities.

 

-Copyright (c) 2004 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -195,6 +195,7 @@ typedef struct {
 

 

 extern LIST_ENTRY          gMenuOption;

+extern LIST_ENTRY          gMenuList;

 extern MENU_REFRESH_ENTRY  *gMenuRefreshHead;

 extern UI_MENU_SELECTION   *gCurrentSelection;

 extern BOOLEAN             mHiiPackageListUpdated;

@@ -250,9 +251,10 @@ UiAddMenuList (
   );

 

 /**

-  Search Menu with given FormId in the parent menu and all its child menus.

+  Search Menu with given FormId, FormSetGuid and Handle in all cached menu list.

 

   @param  Parent                 The parent of menu to search.

+  @param  Handle                 Hii handle related to this formset.

   @param  FormSetGuid            The Formset GUID of the menu to search.  

   @param  FormId                 The Form ID of menu to search.

 

@@ -262,13 +264,15 @@ UiAddMenuList (
 UI_MENU_LIST *

 UiFindChildMenuList (

   IN UI_MENU_LIST         *Parent,

+  IN EFI_HII_HANDLE       Handle,

   IN EFI_GUID             *FormSetGuid, 

   IN UINT16               FormId

   );

 

 /**

-  Search Menu with given FormSetGuid and FormId in all cached menu list.

+  Search Menu with given Handle, FormSetGuid and FormId in all cached menu list.

 

+  @param  Handle                 Hii handle related to this formset.

   @param  FormSetGuid            The Formset GUID of the menu to search.

   @param  FormId                 The Form ID of menu to search.

 

@@ -277,11 +281,23 @@ UiFindChildMenuList (
 **/

 UI_MENU_LIST *

 UiFindMenuList (

+  IN EFI_HII_HANDLE       Handle,

   IN EFI_GUID             *FormSetGuid,

   IN UINT16               FormId

   );

 

 /**

+  Free Menu list linked list.

+

+  @param  MenuListHead    One Menu list point in the menu list.

+

+**/

+VOID

+UiFreeMenuList (

+  LIST_ENTRY   *MenuListHead

+  );

+

+/**

   Free Menu option linked list.

 

 **/

@@ -1048,17 +1064,4 @@ EvaluateExpressionList (
   IN FORM_BROWSER_FORM    *Form OPTIONAL

   );

 

-/**

-  Transfer the device path string to binary format.

-

-  @param   StringPtr     The device path string info.

-

-  @retval  Device path binary info.

-

-**/

-EFI_DEVICE_PATH_PROTOCOL *

-ConvertDevicePathFromText (

-  IN CHAR16  *StringPtr

-  );

-

 #endif // _UI_H

diff --git a/MdeModulePkg/Universal/SmbiosDxe/SmbiosDxe.c b/MdeModulePkg/Universal/SmbiosDxe/SmbiosDxe.c
index 861e35eb..8bf5d443 100644
--- a/MdeModulePkg/Universal/SmbiosDxe/SmbiosDxe.c
+++ b/MdeModulePkg/Universal/SmbiosDxe/SmbiosDxe.c
@@ -2,7 +2,7 @@
   This code produces the Smbios protocol. It also responsible for constructing 

   SMBIOS table into system table.

   

-Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials                          

 are licensed and made available under the terms and conditions of the BSD License         

 which accompanies this distribution.  The full text of the license may be found at        

@@ -87,11 +87,11 @@ SMBIOS_TABLE_ENTRY_POINT EntryPointStructureData = {
   //

   0,

   //

-  // StructureTableLength, TO BE FILLED

+  // TableLength, TO BE FILLED

   //

   0,

   //

-  // StructureTableAddress, TO BE FILLED

+  // TableAddress, TO BE FILLED

   //

   0,

   //

@@ -101,7 +101,8 @@ SMBIOS_TABLE_ENTRY_POINT EntryPointStructureData = {
   //

   // SmbiosBcdRevision

   //

-  0  

+  (UINT8) ((FixedPcdGet16 (PcdSmbiosVersion) >> 4) & 0xf0)

+  | (UINT8) (FixedPcdGet16 (PcdSmbiosVersion) & 0x0f)

 };

 

 

diff --git a/MdeModulePkg/Universal/Variable/Pei/Variable.c b/MdeModulePkg/Universal/Variable/Pei/Variable.c
index 5040f820..10ad3f51 100644
--- a/MdeModulePkg/Universal/Variable/Pei/Variable.c
+++ b/MdeModulePkg/Universal/Variable/Pei/Variable.c
@@ -3,7 +3,7 @@
   Implement ReadOnly Variable Services required by PEIM and install

   PEI ReadOnly Varaiable2 PPI. These services operates the non volatile storage space.

 

-Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -430,6 +430,7 @@ FindVariableEx (
   UINTN                   Index;

   UINTN                   Offset;

   BOOLEAN                 StopRecord;

+  VARIABLE_HEADER         *InDeletedVariable;

 

   if (VariableStoreHeader == NULL) {

     return EFI_INVALID_PARAMETER;

@@ -446,6 +447,8 @@ FindVariableEx (
   PtrTrack->StartPtr = GetStartPointer (VariableStoreHeader);

   PtrTrack->EndPtr   = GetEndPointer   (VariableStoreHeader);

 

+  InDeletedVariable = NULL;

+

   //

   // No Variable Address equals zero, so 0 as initial value is safe.

   //

@@ -461,15 +464,20 @@ FindVariableEx (
       Offset   += IndexTable->Index[Index];

       MaxIndex  = (VARIABLE_HEADER *) ((UINT8 *) IndexTable->StartPtr + Offset);

       if (CompareWithValidVariable (MaxIndex, VariableName, VendorGuid, PtrTrack) == EFI_SUCCESS) {

-        return EFI_SUCCESS;

+        if (PtrTrack->CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

+          InDeletedVariable = PtrTrack->CurrPtr;

+        } else {

+          return EFI_SUCCESS;

+        }

       }

     }

 

     if (IndexTable->GoneThrough != 0) {

       //

-      // If the table has all the existing variables indexed and we still cannot find it.

+      // If the table has all the existing variables indexed, return.

       //

-      return EFI_NOT_FOUND;

+      PtrTrack->CurrPtr = InDeletedVariable;

+      return (PtrTrack->CurrPtr == NULL) ? EFI_NOT_FOUND : EFI_SUCCESS;

     }

   }

 

@@ -490,11 +498,11 @@ FindVariableEx (
   }

 

   //

-  // Find the variable by walk through non-volatile variable store

+  // Find the variable by walk through variable store

   //

   StopRecord = FALSE;

   while ((Variable < PtrTrack->EndPtr) && IsValidVariableHeader (Variable)) {

-    if (Variable->State == VAR_ADDED) {

+    if (Variable->State == VAR_ADDED || Variable->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

       //

       // Record Variable in VariableIndex HOB

       //

@@ -513,7 +521,11 @@ FindVariableEx (
       }

 

       if (CompareWithValidVariable (Variable, VariableName, VendorGuid, PtrTrack) == EFI_SUCCESS) {

-        return EFI_SUCCESS;

+        if (PtrTrack->CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

+          InDeletedVariable = PtrTrack->CurrPtr;

+        } else {

+          return EFI_SUCCESS;

+        }

       }

     }

 

@@ -526,9 +538,9 @@ FindVariableEx (
     IndexTable->GoneThrough = 1;

   }

 

-  PtrTrack->CurrPtr = NULL;

+  PtrTrack->CurrPtr = InDeletedVariable;

 

-  return EFI_NOT_FOUND;

+  return (PtrTrack->CurrPtr == NULL) ? EFI_NOT_FOUND : EFI_SUCCESS;

 }

 

 /**

@@ -691,6 +703,8 @@ PeiGetNextVariableName (
   VARIABLE_STORE_TYPE     Type;

   VARIABLE_POINTER_TRACK  Variable;

   VARIABLE_POINTER_TRACK  VariableInHob;

+  VARIABLE_POINTER_TRACK  VariablePtrTrack;

+  VARIABLE_INDEX_TABLE    *IndexTable;

   UINTN                   VarNameSize;

   EFI_STATUS              Status;

   VARIABLE_STORE_HEADER   *VariableStoreHeader[VariableStoreTypeMax];

@@ -752,7 +766,32 @@ PeiGetNextVariableName (
       Variable.CurrPtr  = Variable.StartPtr;

     }

 

-    if (Variable.CurrPtr->State == VAR_ADDED) {

+    if (Variable.CurrPtr->State == VAR_ADDED || Variable.CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

+      if (Variable.CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

+        //

+        // If it is a IN_DELETED_TRANSITION variable,

+        // and there is also a same ADDED one at the same time,

+        // don't return it.

+        //

+        for (Type = (VARIABLE_STORE_TYPE) 0; Type < VariableStoreTypeMax; Type++) {

+          if ((VariableStoreHeader[Type] != NULL) && (Variable.StartPtr == GetStartPointer (VariableStoreHeader[Type]))) {

+            break;

+          }

+        }

+        ASSERT (Type < VariableStoreTypeMax);

+        GetVariableStore (Type, &IndexTable);

+        Status = FindVariableEx (

+                   VariableStoreHeader[Type],

+                   IndexTable,

+                   GetVariableNamePtr (Variable.CurrPtr),

+                   &Variable.CurrPtr->VendorGuid,

+                   &VariablePtrTrack

+                   );

+        if (!EFI_ERROR (Status) && VariablePtrTrack.CurrPtr->State == VAR_ADDED) {

+          Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);

+          continue;

+        }

+      }

 

       //

       // Don't return NV variable when HOB overrides it

diff --git a/MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.c b/MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.c
index fad1cb32..956c1f2a 100644
--- a/MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.c
+++ b/MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.c
@@ -3,7 +3,7 @@
   The common variable operation routines shared by DXE_RUNTIME variable 

   module and DXE_SMM variable module.

   

-Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials                          

 are licensed and made available under the terms and conditions of the BSD License         

 which accompanies this distribution.  The full text of the license may be found at        

@@ -504,7 +504,7 @@ GetEndPointer (
   @param LastVariableOffset      Offset of last variable.

   @param IsVolatile              The variable store is volatile or not;

                                  if it is non-volatile, need FTW.

-  @param UpdatingVariable        Pointer to updating variable.

+  @param UpdatingPtrTrack        Pointer to updating variable pointer track structure.

   @param ReclaimAnyway           If TRUE, do reclaim anyway.

 

   @return EFI_OUT_OF_RESOURCES

@@ -517,7 +517,7 @@ Reclaim (
   IN  EFI_PHYSICAL_ADDRESS  VariableBase,

   OUT UINTN                 *LastVariableOffset,

   IN  BOOLEAN               IsVolatile,

-  IN  VARIABLE_HEADER       *UpdatingVariable,

+  IN OUT VARIABLE_POINTER_TRACK *UpdatingPtrTrack,

   IN  BOOLEAN               ReclaimAnyway

   )

 {

@@ -542,6 +542,12 @@ Reclaim (
   UINTN                 CommonVariableTotalSize;

   UINTN                 HwErrVariableTotalSize;

   BOOLEAN               NeedDoReclaim;

+  VARIABLE_HEADER       *UpdatingVariable;

+

+  UpdatingVariable = NULL;

+  if (UpdatingPtrTrack != NULL) {

+    UpdatingVariable = UpdatingPtrTrack->CurrPtr;

+  }

 

   NeedDoReclaim = FALSE;

   VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) VariableBase);

@@ -635,6 +641,8 @@ Reclaim (
   if (UpdatingVariable != NULL) {

     VariableSize = (UINTN)(GetNextVariablePtr (UpdatingVariable)) - (UINTN)UpdatingVariable;

     CopyMem (CurrPtr, (UINT8 *) UpdatingVariable, VariableSize);

+    UpdatingPtrTrack->CurrPtr = (VARIABLE_HEADER *)((UINTN)UpdatingPtrTrack->StartPtr + ((UINTN)CurrPtr - (UINTN)GetStartPointer ((VARIABLE_STORE_HEADER *) ValidBuffer)));

+    UpdatingPtrTrack->InDeletedTransitionPtr = NULL;

     CurrPtr += VariableSize;

     if ((!IsVolatile) && ((UpdatingVariable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {

         HwErrVariableTotalSize += VariableSize;

@@ -667,7 +675,7 @@ Reclaim (
            ) {

           Point0 = (VOID *) GetVariableNamePtr (AddedVariable);

           Point1 = (VOID *) GetVariableNamePtr (Variable);

-          if (CompareMem (Point0, Point1, NameSizeOfVariable (AddedVariable)) == 0) {

+          if (CompareMem (Point0, Point1, NameSize) == 0) {

             FoundAdded = TRUE;

             break;

           }

@@ -760,6 +768,8 @@ FindVariableEx (
   VARIABLE_HEADER                *InDeletedVariable;

   VOID                           *Point;

 

+  PtrTrack->InDeletedTransitionPtr = NULL;

+

   //

   // Find the variable by walk through HOB, volatile and non-volatile variable store.

   //

@@ -777,6 +787,7 @@ FindVariableEx (
           if (PtrTrack->CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

             InDeletedVariable   = PtrTrack->CurrPtr;

           } else {

+            PtrTrack->InDeletedTransitionPtr = InDeletedVariable;

             return EFI_SUCCESS;

           }

         } else {

@@ -788,6 +799,7 @@ FindVariableEx (
               if (PtrTrack->CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

                 InDeletedVariable     = PtrTrack->CurrPtr;

               } else {

+                PtrTrack->InDeletedTransitionPtr = InDeletedVariable;

                 return EFI_SUCCESS;

               }

             }

@@ -1320,7 +1332,7 @@ AutoUpdateLangVariable (
         //

         // Successfully convert PlatformLang to Lang, and set the BestLang value into Lang variable simultaneously.

         //

-        FindVariable (L"Lang", &gEfiGlobalVariableGuid, &Variable, (VARIABLE_GLOBAL *)mVariableModuleGlobal, FALSE);

+        FindVariable (L"Lang", &gEfiGlobalVariableGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);

 

         Status = UpdateVariable (L"Lang", &gEfiGlobalVariableGuid, BestLang,

                                  ISO_639_2_ENTRY_SIZE + 1, Attributes, &Variable);

@@ -1375,7 +1387,7 @@ AutoUpdateLangVariable (
   @param[in] Data               Variable data.

   @param[in] DataSize           Size of data. 0 means delete.

   @param[in] Attributes         Attribues of the variable.

-  @param[in] CacheVariable      The variable information which is used to keep track of variable usage.

+  @param[in, out] CacheVariable The variable information which is used to keep track of variable usage.

   

   @retval EFI_SUCCESS           The update operation is success.

   @retval EFI_OUT_OF_RESOURCES  Variable region is full, can not write other data into this region.

@@ -1388,7 +1400,7 @@ UpdateVariable (
   IN      VOID                        *Data,

   IN      UINTN                       DataSize,

   IN      UINT32                      Attributes      OPTIONAL,

-  IN      VARIABLE_POINTER_TRACK      *CacheVariable

+  IN OUT  VARIABLE_POINTER_TRACK      *CacheVariable

   )

 {

   EFI_STATUS                          Status;

@@ -1402,7 +1414,6 @@ UpdateVariable (
   BOOLEAN                             Volatile;

   EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *Fvb;

   UINT8                               State;

-  BOOLEAN                             Reclaimed;

   VARIABLE_POINTER_TRACK              *Variable;

   VARIABLE_POINTER_TRACK              NvVariable;

   VARIABLE_STORE_HEADER               *VariableStoreHeader;

@@ -1429,11 +1440,15 @@ UpdateVariable (
     Variable->StartPtr = GetStartPointer (VariableStoreHeader);

     Variable->EndPtr   = GetEndPointer (VariableStoreHeader);

     Variable->CurrPtr  = (VARIABLE_HEADER *)((UINTN)Variable->StartPtr + ((UINTN)CacheVariable->CurrPtr - (UINTN)CacheVariable->StartPtr));

+    if (CacheVariable->InDeletedTransitionPtr != NULL) {

+      Variable->InDeletedTransitionPtr = (VARIABLE_HEADER *)((UINTN)Variable->StartPtr + ((UINTN)CacheVariable->InDeletedTransitionPtr - (UINTN)CacheVariable->StartPtr));

+    } else {

+      Variable->InDeletedTransitionPtr = NULL;

+    }

     Variable->Volatile = FALSE;

   } 

 

   Fvb       = mVariableModuleGlobal->FvbInstance;

-  Reclaimed = FALSE;

 

   if (Variable->CurrPtr != NULL) {

     //

@@ -1463,6 +1478,32 @@ UpdateVariable (
     // causes it to be deleted.

     //

     if (DataSize == 0 || (Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == 0) {    

+      if (Variable->InDeletedTransitionPtr != NULL) {

+        //

+        // Both ADDED and IN_DELETED_TRANSITION variable are present,

+        // set IN_DELETED_TRANSITION one to DELETED state first.

+        //

+        State = Variable->InDeletedTransitionPtr->State;

+        State &= VAR_DELETED;

+        Status = UpdateVariableStore (

+                   &mVariableModuleGlobal->VariableGlobal,

+                   Variable->Volatile,

+                   FALSE,

+                   Fvb,

+                   (UINTN) &Variable->InDeletedTransitionPtr->State,

+                   sizeof (UINT8),

+                   &State

+                   );

+        if (!EFI_ERROR (Status)) {

+          if (!Variable->Volatile) {

+            ASSERT (CacheVariable->InDeletedTransitionPtr != NULL);

+            CacheVariable->InDeletedTransitionPtr->State = State;

+          }

+        } else {

+          goto Done;

+        }

+      }

+

       State = Variable->CurrPtr->State;

       State &= VAR_DELETED;

 

@@ -1607,7 +1648,7 @@ UpdateVariable (
       // Perform garbage collection & reclaim operation.

       //

       Status = Reclaim (mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase, 

-                        &mVariableModuleGlobal->NonVolatileLastVariableOffset, FALSE, Variable->CurrPtr, FALSE);

+                        &mVariableModuleGlobal->NonVolatileLastVariableOffset, FALSE, Variable, FALSE);

       if (EFI_ERROR (Status)) {

         goto Done;

       }

@@ -1621,7 +1662,10 @@ UpdateVariable (
         Status = EFI_OUT_OF_RESOURCES;

         goto Done;

       }

-      Reclaimed = TRUE;

+      if (Variable->CurrPtr != NULL) {

+        CacheVariable->CurrPtr = (VARIABLE_HEADER *)((UINTN) CacheVariable->StartPtr + ((UINTN) Variable->CurrPtr - (UINTN) Variable->StartPtr));

+        CacheVariable->InDeletedTransitionPtr = NULL;

+      }

     }

     //

     // Four steps

@@ -1722,7 +1766,7 @@ UpdateVariable (
       // Perform garbage collection & reclaim operation.

       //

       Status = Reclaim (mVariableModuleGlobal->VariableGlobal.VolatileVariableBase, 

-                          &mVariableModuleGlobal->VolatileLastVariableOffset, TRUE, Variable->CurrPtr, FALSE);

+                          &mVariableModuleGlobal->VolatileLastVariableOffset, TRUE, Variable, FALSE);

       if (EFI_ERROR (Status)) {

         goto Done;

       }

@@ -1735,7 +1779,10 @@ UpdateVariable (
         Status = EFI_OUT_OF_RESOURCES;

         goto Done;

       }

-      Reclaimed = TRUE;

+      if (Variable->CurrPtr != NULL) {

+        CacheVariable->CurrPtr = (VARIABLE_HEADER *)((UINTN) CacheVariable->StartPtr + ((UINTN) Variable->CurrPtr - (UINTN) Variable->StartPtr));

+        CacheVariable->InDeletedTransitionPtr = NULL;

+      }

     }

 

     NextVariable->State = VAR_ADDED;

@@ -1759,7 +1806,33 @@ UpdateVariable (
   //

   // Mark the old variable as deleted.

   //

-  if (!Reclaimed && !EFI_ERROR (Status) && Variable->CurrPtr != NULL) {

+  if (!EFI_ERROR (Status) && Variable->CurrPtr != NULL) {

+    if (Variable->InDeletedTransitionPtr != NULL) {

+      //

+      // Both ADDED and IN_DELETED_TRANSITION old variable are present,

+      // set IN_DELETED_TRANSITION one to DELETED state first.

+      //

+      State = Variable->InDeletedTransitionPtr->State;

+      State &= VAR_DELETED;

+      Status = UpdateVariableStore (

+                 &mVariableModuleGlobal->VariableGlobal,

+                 Variable->Volatile,

+                 FALSE,

+                 Fvb,

+                 (UINTN) &Variable->InDeletedTransitionPtr->State,

+                 sizeof (UINT8),

+                 &State

+                 );

+      if (!EFI_ERROR (Status)) {

+        if (!Variable->Volatile) {

+          ASSERT (CacheVariable->InDeletedTransitionPtr != NULL);

+          CacheVariable->InDeletedTransitionPtr->State = State;

+        }

+      } else {

+        goto Done;

+      }

+    }

+

     State = Variable->CurrPtr->State;

     State &= VAR_DELETED;

 

@@ -1947,6 +2020,7 @@ VariableServiceGetNextVariableName (
   VARIABLE_STORE_TYPE     Type;

   VARIABLE_POINTER_TRACK  Variable;

   VARIABLE_POINTER_TRACK  VariableInHob;

+  VARIABLE_POINTER_TRACK  VariablePtrTrack;

   UINTN                   VarNameSize;

   EFI_STATUS              Status;

   VARIABLE_STORE_HEADER   *VariableStoreHeader[VariableStoreTypeMax];

@@ -2020,8 +2094,27 @@ VariableServiceGetNextVariableName (
     //

     // Variable is found

     //

-    if (Variable.CurrPtr->State == VAR_ADDED) {

-      if ((AtRuntime () && ((Variable.CurrPtr->Attributes & EFI_VARIABLE_RUNTIME_ACCESS) == 0)) == 0) {

+    if (Variable.CurrPtr->State == VAR_ADDED || Variable.CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

+      if (!AtRuntime () || ((Variable.CurrPtr->Attributes & EFI_VARIABLE_RUNTIME_ACCESS) != 0)) {

+        if (Variable.CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

+          //

+          // If it is a IN_DELETED_TRANSITION variable,

+          // and there is also a same ADDED one at the same time,

+          // don't return it.

+          //

+          VariablePtrTrack.StartPtr = Variable.StartPtr;

+          VariablePtrTrack.EndPtr = Variable.EndPtr;

+          Status = FindVariableEx (

+                     GetVariableNamePtr (Variable.CurrPtr),

+                     &Variable.CurrPtr->VendorGuid,

+                     FALSE,

+                     &VariablePtrTrack

+                     );

+          if (!EFI_ERROR (Status) && VariablePtrTrack.CurrPtr->State == VAR_ADDED) {

+            Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);

+            continue;

+          }

+        }

 

         //

         // Don't return NV variable when HOB overrides it

@@ -2663,6 +2756,11 @@ VariableCommonInitialize (
   ASSERT(VariableStoreHeader->Size == VariableStoreLength);

     

   //

+  // The max variable or hardware error variable size should be < variable store size.

+  //

+  ASSERT(MAX (PcdGet32 (PcdMaxVariableSize), PcdGet32 (PcdMaxHardwareErrorVariableSize)) < VariableStoreLength);

+

+  //

   // Parse non-volatile variable data and get last variable offset.

   //

   NextVariable  = GetStartPointer ((VARIABLE_STORE_HEADER *)(UINTN)VariableStoreBase);

diff --git a/MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.h b/MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.h
index cd88177d..8504ce05 100644
--- a/MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.h
+++ b/MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.h
@@ -3,7 +3,7 @@
   The internal header file includes the common header files, defines

   internal structure and functions used by Variable modules.

 

-Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -56,6 +56,13 @@ typedef enum {
 

 typedef struct {

   VARIABLE_HEADER *CurrPtr;

+  //

+  // If both ADDED and IN_DELETED_TRANSITION variable are present,

+  // InDeletedTransitionPtr will point to the IN_DELETED_TRANSITION one.

+  // Otherwise, CurrPtr will point to the ADDED or IN_DELETED_TRANSITION one,

+  // and InDeletedTransitionPtr will be NULL at the same time.

+  //

+  VARIABLE_HEADER *InDeletedTransitionPtr;

   VARIABLE_HEADER *EndPtr;

   VARIABLE_HEADER *StartPtr;

   BOOLEAN         Volatile;

@@ -141,7 +148,7 @@ FtwVariableSpace (
 

   @param[in] Attributes         Attribues of the variable.

 

-  @param[in] Variable           The variable information that is used to keep track of variable usage.

+  @param[in, out] Variable      The variable information that is used to keep track of variable usage.

 

   @retval EFI_SUCCESS           The update operation is success.

 

@@ -155,7 +162,7 @@ UpdateVariable (
   IN      VOID            *Data,

   IN      UINTN           DataSize,

   IN      UINT32          Attributes OPTIONAL,

-  IN      VARIABLE_POINTER_TRACK *Variable

+  IN OUT  VARIABLE_POINTER_TRACK *Variable

   );

 

 

diff --git a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmmRuntimeDxe.c b/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmmRuntimeDxe.c
index 442fe1da..2fca2598 100644
--- a/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmmRuntimeDxe.c
+++ b/MdeModulePkg/Universal/Variable/RuntimeDxe/VariableSmmRuntimeDxe.c
@@ -4,7 +4,7 @@
   and volatile storage space and install variable architecture protocol

   based on SMM variable module.

 

-Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials                          

 are licensed and made available under the terms and conditions of the BSD License         

 which accompanies this distribution.  The full text of the license may be found at        

@@ -42,7 +42,51 @@ EFI_SMM_COMMUNICATION_PROTOCOL  *mSmmCommunication          = NULL;
 UINT8                           *mVariableBuffer            = NULL;

 UINT8                           *mVariableBufferPhysical    = NULL;

 UINTN                            mVariableBufferSize;

+EFI_LOCK                         mVariableServicesLock;

 

+/**

+  Acquires lock only at boot time. Simply returns at runtime.

+

+  This is a temperary function that will be removed when

+  EfiAcquireLock() in UefiLib can handle the call in UEFI

+  Runtimer driver in RT phase.

+  It calls EfiAcquireLock() at boot time, and simply returns

+  at runtime.

+

+  @param  Lock         A pointer to the lock to acquire.

+

+**/

+VOID

+AcquireLockOnlyAtBootTime (

+  IN EFI_LOCK                             *Lock

+  )

+{

+  if (!EfiAtRuntime ()) {

+    EfiAcquireLock (Lock);

+  }

+}

+

+/**

+  Releases lock only at boot time. Simply returns at runtime.

+

+  This is a temperary function which will be removed when

+  EfiReleaseLock() in UefiLib can handle the call in UEFI

+  Runtimer driver in RT phase.

+  It calls EfiReleaseLock() at boot time and simply returns

+  at runtime.

+

+  @param  Lock         A pointer to the lock to release.

+

+**/

+VOID

+ReleaseLockOnlyAtBootTime (

+  IN EFI_LOCK                             *Lock

+  )

+{

+  if (!EfiAtRuntime ()) {

+    EfiReleaseLock (Lock);

+  }

+}

 

 /**

   Initialize the communicate buffer using DataSize and Function.

@@ -153,15 +197,27 @@ RuntimeServiceGetVariable (
   if ((*DataSize != 0) && (Data == NULL)) {

     return EFI_INVALID_PARAMETER;

   }

-  

+

+  if (*DataSize >= mVariableBufferSize) {

+    //

+    // DataSize may be near MAX_ADDRESS incorrectly, this can cause the computed PayLoadSize to

+    // overflow to a small value and pass the check in InitCommunicateBuffer().

+    // To protect against this vulnerability, return EFI_INVALID_PARAMETER if DataSize is >= mVariableBufferSize.

+    // And there will be further check to ensure the total size is also not > mVariableBufferSize.

+    //

+    return EFI_INVALID_PARAMETER;

+  }

+

+  AcquireLockOnlyAtBootTime(&mVariableServicesLock);

+

   //

   // Init the communicate buffer. The buffer data size is:

-  // SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + PayloadSize + DataSize.

+  // SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + PayloadSize.

   //

   PayloadSize = OFFSET_OF (SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE, Name) + StrSize (VariableName) + *DataSize;

   Status = InitCommunicateBuffer ((VOID **)&SmmVariableHeader, PayloadSize, SMM_VARIABLE_FUNCTION_GET_VARIABLE);

   if (EFI_ERROR (Status)) {

-    return Status;

+    goto Done;

   }

   ASSERT (SmmVariableHeader != NULL);

 

@@ -189,11 +245,13 @@ RuntimeServiceGetVariable (
   }

 

   if (EFI_ERROR (Status)) {

-    return Status;

+    goto Done;

   }

 

   CopyMem (Data, (UINT8 *)SmmVariableHeader->Name + SmmVariableHeader->NameSize, SmmVariableHeader->DataSize);

 

+Done:

+  ReleaseLockOnlyAtBootTime (&mVariableServicesLock);

   return Status;

 }

 

@@ -226,7 +284,19 @@ RuntimeServiceGetNextVariableName (
   if (VariableNameSize == NULL || VariableName == NULL || VendorGuid == NULL) {

     return EFI_INVALID_PARAMETER;

   }

-  

+

+  if (*VariableNameSize >= mVariableBufferSize) {

+    //

+    // VariableNameSize may be near MAX_ADDRESS incorrectly, this can cause the computed PayLoadSize to

+    // overflow to a small value and pass the check in InitCommunicateBuffer().

+    // To protect against this vulnerability, return EFI_INVALID_PARAMETER if VariableNameSize is >= mVariableBufferSize.

+    // And there will be further check to ensure the total size is also not > mVariableBufferSize.

+    //

+    return EFI_INVALID_PARAMETER;

+  }

+

+  AcquireLockOnlyAtBootTime(&mVariableServicesLock);

+

   //

   // Init the communicate buffer. The buffer data size is:

   // SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + PayloadSize.

@@ -234,7 +304,7 @@ RuntimeServiceGetNextVariableName (
   PayloadSize = OFFSET_OF (SMM_VARIABLE_COMMUNICATE_GET_NEXT_VARIABLE_NAME, Name) + *VariableNameSize; 

   Status = InitCommunicateBuffer ((VOID **)&SmmGetNextVariableName, PayloadSize, SMM_VARIABLE_FUNCTION_GET_NEXT_VARIABLE_NAME);

   if (EFI_ERROR (Status)) {

-    return Status;

+    goto Done;

   }

   ASSERT (SmmGetNextVariableName != NULL);

 

@@ -252,12 +322,14 @@ RuntimeServiceGetNextVariableName (
   //

   *VariableNameSize = SmmGetNextVariableName->NameSize;    

   if (EFI_ERROR (Status)) {

-    return Status;

+    goto Done;

   }

   

   CopyGuid (VendorGuid, &SmmGetNextVariableName->Guid);

   CopyMem (VariableName, SmmGetNextVariableName->Name, SmmGetNextVariableName->NameSize);  

 

+Done:

+  ReleaseLockOnlyAtBootTime (&mVariableServicesLock);

   return Status;

 }

 

@@ -302,7 +374,19 @@ RuntimeServiceSetVariable (
   if (DataSize != 0 && Data == NULL) {

     return EFI_INVALID_PARAMETER;

   }

-  

+

+  if (DataSize >= mVariableBufferSize) {

+    //

+    // DataSize may be near MAX_ADDRESS incorrectly, this can cause the computed PayLoadSize to

+    // overflow to a small value and pass the check in InitCommunicateBuffer().

+    // To protect against this vulnerability, return EFI_INVALID_PARAMETER if DataSize is >= mVariableBufferSize.

+    // And there will be further check to ensure the total size is also not > mVariableBufferSize.

+    //

+    return EFI_INVALID_PARAMETER;

+  }

+

+  AcquireLockOnlyAtBootTime(&mVariableServicesLock);

+ 

   //

   // Init the communicate buffer. The buffer data size is:

   // SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + PayloadSize.

@@ -310,7 +394,7 @@ RuntimeServiceSetVariable (
   PayloadSize = OFFSET_OF (SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE, Name) + StrSize (VariableName) + DataSize;

   Status = InitCommunicateBuffer ((VOID **)&SmmVariableHeader, PayloadSize, SMM_VARIABLE_FUNCTION_SET_VARIABLE);

   if (EFI_ERROR (Status)) {

-    return Status;

+    goto Done;

   }

   ASSERT (SmmVariableHeader != NULL);

 

@@ -325,7 +409,9 @@ RuntimeServiceSetVariable (
   // Send data to SMM.

   //

   Status = SendCommunicateBuffer (PayloadSize);

- 

+

+Done:

+  ReleaseLockOnlyAtBootTime (&mVariableServicesLock);

   return Status;

 }

 

@@ -363,7 +449,9 @@ RuntimeServiceQueryVariableInfo (
   if(MaximumVariableStorageSize == NULL || RemainingVariableStorageSize == NULL || MaximumVariableSize == NULL || Attributes == 0) {

     return EFI_INVALID_PARAMETER;

   }

-  

+

+  AcquireLockOnlyAtBootTime(&mVariableServicesLock);

+

   //

   // Init the communicate buffer. The buffer data size is:

   // SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + PayloadSize;

@@ -371,7 +459,7 @@ RuntimeServiceQueryVariableInfo (
   PayloadSize = sizeof (SMM_VARIABLE_COMMUNICATE_QUERY_VARIABLE_INFO);

   Status = InitCommunicateBuffer ((VOID **)&SmmQueryVariableInfo, PayloadSize, SMM_VARIABLE_FUNCTION_QUERY_VARIABLE_INFO);

   if (EFI_ERROR (Status)) {

-    return Status;

+    goto Done;

   }

   ASSERT (SmmQueryVariableInfo != NULL);

 

@@ -382,7 +470,7 @@ RuntimeServiceQueryVariableInfo (
   //

   Status = SendCommunicateBuffer (PayloadSize);

   if (EFI_ERROR (Status)) {

-    return Status;

+    goto Done;

   }

 

   //

@@ -391,8 +479,10 @@ RuntimeServiceQueryVariableInfo (
   *MaximumVariableSize          = SmmQueryVariableInfo->MaximumVariableSize;

   *MaximumVariableStorageSize   = SmmQueryVariableInfo->MaximumVariableStorageSize;

   *RemainingVariableStorageSize = SmmQueryVariableInfo->RemainingVariableStorageSize; 

- 

-  return EFI_SUCCESS;

+

+Done:

+  ReleaseLockOnlyAtBootTime (&mVariableServicesLock);

+  return Status;

 }

 

 

@@ -589,7 +679,9 @@ VariableSmmRuntimeInitialize (
   VOID                                      *SmmVariableWriteRegistration;

   EFI_EVENT                                 OnReadyToBootEvent;

   EFI_EVENT                                 ExitBootServiceEvent;

-  

+

+  EfiInitializeLock (&mVariableServicesLock, TPL_NOTIFY);

+

   //

   // Smm variable service is ready

   //

diff --git a/MdePkg/Include/Guid/Cper.h b/MdePkg/Include/Guid/Cper.h
index ca9a9284..a5d91ff0 100644
--- a/MdePkg/Include/Guid/Cper.h
+++ b/MdePkg/Include/Guid/Cper.h
@@ -11,7 +11,7 @@
   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

 

   @par Revision Reference:

-  GUIDs introduced from UEFI 2.1 Specification.

+  GUIDs introduced from UEFI 2.3.1 Specification.

 

 **/

 

@@ -209,7 +209,6 @@ typedef struct {
   UINT8                  SecValidMask;

   UINT8                  Resv1;

   UINT32                 SectionFlags;

-  UINT8                  Resv2[3];

   EFI_GUID               SectionType;

   EFI_GUID               FruId;

   UINT32                 Severity;

diff --git a/MdePkg/Include/Library/BaseLib.h b/MdePkg/Include/Library/BaseLib.h
index 992c5387..db075963 100644
--- a/MdePkg/Include/Library/BaseLib.h
+++ b/MdePkg/Include/Library/BaseLib.h
@@ -1291,7 +1291,7 @@ InitializeListHead (
   If Entry is NULL, then ASSERT().

   If ListHead was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or

   InitializeListHead(), then ASSERT().

-  If PcdMaximumLinkedListLenth is not zero, and prior to insertion the number

+  If PcdMaximumLinkedListLength is not zero, and prior to insertion the number

   of nodes in ListHead, including the ListHead node, is greater than or

   equal to PcdMaximumLinkedListLength, then ASSERT().

 

@@ -1321,7 +1321,7 @@ InsertHeadList (
   If Entry is NULL, then ASSERT().

   If ListHead was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or 

   InitializeListHead(), then ASSERT().

-  If PcdMaximumLinkedListLenth is not zero, and prior to insertion the number

+  If PcdMaximumLinkedListLength is not zero, and prior to insertion the number

   of nodes in ListHead, including the ListHead node, is greater than or

   equal to PcdMaximumLinkedListLength, then ASSERT().

 

@@ -1350,7 +1350,7 @@ InsertTailList (
   If List is NULL, then ASSERT().

   If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or 

   InitializeListHead(), then ASSERT().

-  If PcdMaximumLinkedListLenth is not zero, and the number of nodes

+  If PcdMaximumLinkedListLength is not zero, and the number of nodes

   in List, including the List node, is greater than or equal to

   PcdMaximumLinkedListLength, then ASSERT().

 

@@ -1378,8 +1378,8 @@ GetFirstNode (
   If Node is NULL, then ASSERT().

   If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or 

   InitializeListHead(), then ASSERT().

-  If PcdMaximumLinkedListLenth is not zero, and List contains more than

-  PcdMaximumLinkedListLenth nodes, then ASSERT().

+  If PcdMaximumLinkedListLength is not zero, and List contains more than

+  PcdMaximumLinkedListLength nodes, then ASSERT().

   If PcdVerifyNodeInList is TRUE and Node is not a node in List, then ASSERT().

 

   @param  List  A pointer to the head node of a doubly linked list.

@@ -1407,8 +1407,8 @@ GetNextNode (
   If Node is NULL, then ASSERT().

   If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or 

   InitializeListHead(), then ASSERT().

-  If PcdMaximumLinkedListLenth is not zero, and List contains more than

-  PcdMaximumLinkedListLenth nodes, then ASSERT().

+  If PcdMaximumLinkedListLength is not zero, and List contains more than

+  PcdMaximumLinkedListLength nodes, then ASSERT().

   If PcdVerifyNodeInList is TRUE and Node is not a node in List, then ASSERT().

  

   @param  List  A pointer to the head node of a doubly linked list.

@@ -1434,7 +1434,7 @@ GetPreviousNode (
   If ListHead is NULL, then ASSERT().

   If ListHead was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or 

   InitializeListHead(), then ASSERT().

-  If PcdMaximumLinkedListLenth is not zero, and the number of nodes

+  If PcdMaximumLinkedListLength is not zero, and the number of nodes

   in List, including the List node, is greater than or equal to

   PcdMaximumLinkedListLength, then ASSERT().

 

@@ -1464,7 +1464,7 @@ IsListEmpty (
   If Node is NULL, then ASSERT().

   If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or InitializeListHead(), 

   then ASSERT().

-  If PcdMaximumLinkedListLenth is not zero, and the number of nodes

+  If PcdMaximumLinkedListLength is not zero, and the number of nodes

   in List, including the List node, is greater than or equal to

   PcdMaximumLinkedListLength, then ASSERT().

   If PcdVerifyNodeInList is TRUE and Node is not a node in List the and Node is not equal 

@@ -1496,7 +1496,7 @@ IsNull (
   If Node is NULL, then ASSERT().

   If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or

   InitializeListHead(), then ASSERT().

-  If PcdMaximumLinkedListLenth is not zero, and the number of nodes

+  If PcdMaximumLinkedListLength is not zero, and the number of nodes

   in List, including the List node, is greater than or equal to

   PcdMaximumLinkedListLength, then ASSERT().

   If PcdVerifyNodeInList is TRUE and Node is not a node in List, then ASSERT().

diff --git a/MdePkg/Library/BaseLib/BaseLibInternals.h b/MdePkg/Library/BaseLib/BaseLibInternals.h
index a60310ab..fe416a0c 100644
--- a/MdePkg/Library/BaseLib/BaseLibInternals.h
+++ b/MdePkg/Library/BaseLib/BaseLibInternals.h
@@ -349,7 +349,7 @@ InternalSwitchStack (
   If List->ForwardLink is NULL, then ASSERT().

   If List->backLink is NULL, then ASSERT().

   If Node is NULL, then ASSERT();

-  If PcdMaximumLinkedListLenth is not zero, and prior to insertion the number

+  If PcdMaximumLinkedListLength is not zero, and prior to insertion the number

   of nodes in ListHead, including the ListHead node, is greater than or

   equal to PcdMaximumLinkedListLength, then ASSERT().

 

diff --git a/MdePkg/Library/BaseLib/Ia32/CpuIdEx.asm b/MdePkg/Library/BaseLib/Ia32/CpuIdEx.asm
index 4e54d0c3..504b397f 100644
--- a/MdePkg/Library/BaseLib/Ia32/CpuIdEx.asm
+++ b/MdePkg/Library/BaseLib/Ia32/CpuIdEx.asm
@@ -1,6 +1,6 @@
 ;------------------------------------------------------------------------------

 ;

-; Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+; Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 ; This program and the accompanying materials

 ; are licensed and made available under the terms and conditions of the BSD License

 ; which accompanies this distribution.  The full text of the license may be found at

@@ -56,7 +56,7 @@ AsmCpuidEx  PROC    USES    ebx
     jecxz   @F

     mov     [ecx], edx

 @@:

-    mov     edx, [ebp + 28]

+    mov     ecx, [ebp + 28]

     jecxz   @F

     pop     [ecx]

 @@:

diff --git a/MdePkg/Library/BaseLib/Ia32/Thunk16.S b/MdePkg/Library/BaseLib/Ia32/Thunk16.S
index 0555cf1b..8356c5a1 100644
--- a/MdePkg/Library/BaseLib/Ia32/Thunk16.S
+++ b/MdePkg/Library/BaseLib/Ia32/Thunk16.S
@@ -1,6 +1,6 @@
 #------------------------------------------------------------------------------

 #

-# Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>

+# Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 # This program and the accompanying materials

 # are licensed and made available under the terms and conditions of the BSD License

 # which accompanies this distribution.  The full text of the license may be found at

@@ -175,7 +175,7 @@ ASM_PFX(InternalAsmThunk16):
     andl    $0x7ffffffe, %eax           # clear PE, PG bits

     movl    %cr4, %ebp

     mov     %ebp, 0xfffffff1(%edx)

-    andl    $0x300, %ebp                # clear all but PCE and OSFXSR bits

+    andl    $0xffffffcf, %ebp           # clear PAE, PSE bits

     pushl   $0x10

     pop     %ecx                        # ecx <- selector for data segments

     lgdtl   0x20(%edx)

diff --git a/MdePkg/Library/BaseLib/Ia32/Thunk16.asm b/MdePkg/Library/BaseLib/Ia32/Thunk16.asm
index 6df0a4a4..3e84aedf 100644
--- a/MdePkg/Library/BaseLib/Ia32/Thunk16.asm
+++ b/MdePkg/Library/BaseLib/Ia32/Thunk16.asm
@@ -3,7 +3,7 @@
 

 ;------------------------------------------------------------------------------

 ;

-; Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>

+; Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 ; This program and the accompanying materials

 ; are licensed and made available under the terms and conditions of the BSD License

 ; which accompanies this distribution.  The full text of the license may be found at

@@ -237,7 +237,7 @@ InternalAsmThunk16  PROC    USES    ebp ebx esi edi ds  es  fs  gs
     and     eax, 7ffffffeh              ; clear PE, PG bits

     mov     ebp, cr4

     mov     [edx + (SavedCr4 - SavedCr0)], ebp

-    and     ebp, 300h                   ; clear all but PCE and OSFXSR bits

+    and     ebp, NOT 30h                ; clear PAE, PSE bits

     push    10h

     pop     ecx                         ; ecx <- selector for data segments

     lgdt    fword ptr [edx + (_16Gdtr - SavedCr0)]

diff --git a/MdePkg/Library/BaseLib/LinkedList.c b/MdePkg/Library/BaseLib/LinkedList.c
index 03e8477c..f26ef49b 100644
--- a/MdePkg/Library/BaseLib/LinkedList.c
+++ b/MdePkg/Library/BaseLib/LinkedList.c
@@ -26,8 +26,8 @@
   If Node is NULL, then ASSERT().

   If PcdVerifyNodeInList is TRUE and DoMembershipCheck is TRUE and Node 

   is in not a member of List, then return FALSE

-  If PcdMaximumLinkedListLenth is not zero, and List contains more than

-  PcdMaximumLinkedListLenth nodes, then ASSERT().

+  If PcdMaximumLinkedListLength is not zero, and List contains more than

+  PcdMaximumLinkedListLength nodes, then ASSERT().

 

   @param  List              A pointer to a node in a linked list.

   @param  Node              A pointer to a node in a linked list.

@@ -153,7 +153,7 @@ InitializeListHead (
   If Entry is NULL, then ASSERT().

   If ListHead was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or

   InitializeListHead(), then ASSERT().

-  If PcdMaximumLinkedListLenth is not zero, and prior to insertion the number

+  If PcdMaximumLinkedListLength is not zero, and prior to insertion the number

   of nodes in ListHead, including the ListHead node, is greater than or

   equal to PcdMaximumLinkedListLength, then ASSERT().

 

@@ -194,7 +194,7 @@ InsertHeadList (
   If Entry is NULL, then ASSERT().

   If ListHead was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or 

   InitializeListHead(), then ASSERT().

-  If PcdMaximumLinkedListLenth is not zero, and prior to insertion the number

+  If PcdMaximumLinkedListLength is not zero, and prior to insertion the number

   of nodes in ListHead, including the ListHead node, is greater than or

   equal to PcdMaximumLinkedListLength, then ASSERT().

 

@@ -234,7 +234,7 @@ InsertTailList (
   If List is NULL, then ASSERT().

   If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or 

   InitializeListHead(), then ASSERT().

-  If PcdMaximumLinkedListLenth is not zero, and the number of nodes

+  If PcdMaximumLinkedListLength is not zero, and the number of nodes

   in List, including the List node, is greater than or equal to

   PcdMaximumLinkedListLength, then ASSERT().

 

@@ -269,8 +269,8 @@ GetFirstNode (
   If Node is NULL, then ASSERT().

   If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or 

   InitializeListHead(), then ASSERT().

-  If PcdMaximumLinkedListLenth is not zero, and List contains more than

-  PcdMaximumLinkedListLenth nodes, then ASSERT().

+  If PcdMaximumLinkedListLength is not zero, and List contains more than

+  PcdMaximumLinkedListLength nodes, then ASSERT().

   If PcdVerifyNodeInList is TRUE and Node is not a node in List, then ASSERT().

 

   @param  List  A pointer to the head node of a doubly-linked list.

@@ -305,8 +305,8 @@ GetNextNode (
   If Node is NULL, then ASSERT().

   If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or 

   InitializeListHead(), then ASSERT().

-  If PcdMaximumLinkedListLenth is not zero, and List contains more than

-  PcdMaximumLinkedListLenth nodes, then ASSERT().

+  If PcdMaximumLinkedListLength is not zero, and List contains more than

+  PcdMaximumLinkedListLength nodes, then ASSERT().

   If PcdVerifyNodeInList is TRUE and Node is not a node in List, then ASSERT().

  

   @param  List  A pointer to the head node of a doubly-linked list.

@@ -339,7 +339,7 @@ GetPreviousNode (
   If ListHead is NULL, then ASSERT().

   If ListHead was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or 

   InitializeListHead(), then ASSERT().

-  If PcdMaximumLinkedListLenth is not zero, and the number of nodes

+  If PcdMaximumLinkedListLength is not zero, and the number of nodes

   in List, including the List node, is greater than or equal to

   PcdMaximumLinkedListLength, then ASSERT().

 

@@ -376,7 +376,7 @@ IsListEmpty (
   If Node is NULL, then ASSERT().

   If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or InitializeListHead(), 

   then ASSERT().

-  If PcdMaximumLinkedListLenth is not zero, and the number of nodes

+  If PcdMaximumLinkedListLength is not zero, and the number of nodes

   in List, including the List node, is greater than or equal to

   PcdMaximumLinkedListLength, then ASSERT().

   If PcdVerifyNodeInList is TRUE and Node is not a node in List and Node is not 

@@ -415,7 +415,7 @@ IsNull (
   If Node is NULL, then ASSERT().

   If List was not initialized with INTIALIZE_LIST_HEAD_VARIABLE() or

   InitializeListHead(), then ASSERT().

-  If PcdMaximumLinkedListLenth is not zero, and the number of nodes

+  If PcdMaximumLinkedListLength is not zero, and the number of nodes

   in List, including the List node, is greater than or equal to

   PcdMaximumLinkedListLength, then ASSERT().

   If PcdVerifyNodeInList is TRUE and Node is not a node in List, then ASSERT().

diff --git a/MdePkg/Library/BaseLib/X64/Thunk16.S b/MdePkg/Library/BaseLib/X64/Thunk16.S
index d037a710..a521aff3 100644
--- a/MdePkg/Library/BaseLib/X64/Thunk16.S
+++ b/MdePkg/Library/BaseLib/X64/Thunk16.S
@@ -1,6 +1,6 @@
 #------------------------------------------------------------------------------

 #

-# Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>

+# Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 # This program and the accompanying materials

 # are licensed and made available under the terms and conditions of the BSD License

 # which accompanies this distribution.  The full text of the license may be found at

@@ -295,7 +295,7 @@ ASM_PFX(InternalAsmThunk16):
     andl    $0x7ffffffe,%eax            # clear PE, PG bits

     movq    %cr4, %rbp

     movl    %ebp, (%rcx)                # save CR4 in SavedCr4

-    andl    $0x300,%ebp                 # clear all but PCE and OSFXSR bits

+    andl    $0xffffffcf,%ebp            # clear PAE, PSE bits

     movl    %r8d, %esi                  # esi <- 16-bit stack segment

     .byte      0x6a, DATA32

     popq    %rdx

diff --git a/MdePkg/Library/BaseLib/X64/Thunk16.asm b/MdePkg/Library/BaseLib/X64/Thunk16.asm
index 8b208fdb..01051341 100644
--- a/MdePkg/Library/BaseLib/X64/Thunk16.asm
+++ b/MdePkg/Library/BaseLib/X64/Thunk16.asm
@@ -3,7 +3,7 @@
 

 ;------------------------------------------------------------------------------

 ;

-; Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>

+; Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 ; This program and the accompanying materials

 ; are licensed and made available under the terms and conditions of the BSD License

 ; which accompanies this distribution.  The full text of the license may be found at

@@ -282,7 +282,7 @@ InternalAsmThunk16  PROC    USES    rbp rbx rsi rdi
     and     eax, 7ffffffeh              ; clear PE, PG bits

     mov     rbp, cr4

     mov     [rcx], ebp                  ; save CR4 in SavedCr4

-    and     ebp, 300h                   ; clear all but PCE and OSFXSR bits

+    and     ebp, NOT 30h                ; clear PAE, PSE bits

     mov     esi, r8d                    ; esi <- 16-bit stack segment

     DB      6ah, DATA32                 ; push DATA32

     pop     rdx                         ; rdx <- 32-bit data segment selector

diff --git a/MdePkg/Library/UefiLib/Console.c b/MdePkg/Library/UefiLib/Console.c
index dd4d5c54..73f99153 100644
--- a/MdePkg/Library/UefiLib/Console.c
+++ b/MdePkg/Library/UefiLib/Console.c
@@ -1,7 +1,7 @@
 /** @file

   This module provide help function for displaying unicode string.

 

-  Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials                          

   are licensed and made available under the terms and conditions of the BSD License         

   which accompanies this distribution.  The full text of the license may be found at        

@@ -332,8 +332,9 @@ UefiLibGetStringWidth (
     //

     // Advance to the null-terminator or to the first width directive

     //

-    for (;(String[Index] != NARROW_CHAR) && (String[Index] != WIDE_CHAR) && (String[Index] != 0);

-         Index++, Count = Count + IncrementValue) {

+    for (;(String[Index] != NARROW_CHAR) && (String[Index] != WIDE_CHAR) && (String[Index] != 0); Index++) {

+      Count = Count + IncrementValue;

+

       if (LimitLen && Count > MaxWidth) {

         break;

       }

@@ -347,7 +348,7 @@ UefiLibGetStringWidth (
     }

 

     if (LimitLen && Count > MaxWidth) {

-      *Offset = Index - 1;

+      *Offset = Index;

       break;

     }

 

@@ -370,13 +371,6 @@ UefiLibGetStringWidth (
     }

   } while (String[Index] != 0);

 

-  //

-  // Increment by one to include the null-terminator in the size

-  //

-  if (!LimitLen) {

-    Count++;

-  }

-

   return Count * sizeof (CHAR16);

 }

 

@@ -420,6 +414,7 @@ CreatePopUp (
   UINTN                            Length;

   CHAR16                           *Line;

   UINTN                            EventIndex;

+  CHAR16                           *TmpString;

 

   //

   // Determine the length of the longest line in the popup and the the total 

@@ -520,10 +515,14 @@ CreatePopUp (
       // Length > MaxLength

       //

       UefiLibGetStringWidth (String, TRUE, MaxLength, &Length);

-      String[Length] = L'\0';

+      TmpString = AllocateZeroPool ((Length + 1) * sizeof (CHAR16));

+      ASSERT (TmpString != NULL);

+      StrnCpy(TmpString, String, Length - 3);

+      StrCat (TmpString, L"...");

 

       ConOut->SetCursorPosition (ConOut, Column + 1, Row++);

-      ConOut->OutputString (ConOut, String);

+      ConOut->OutputString (ConOut, TmpString);

+      FreePool (TmpString);

     }

     NumberOfLines--;

   }

diff --git a/NetworkPkg/Dhcp6Dxe/Dhcp6Impl.c b/NetworkPkg/Dhcp6Dxe/Dhcp6Impl.c
index 934c03ed..d8c0ad0d 100644
--- a/NetworkPkg/Dhcp6Dxe/Dhcp6Impl.c
+++ b/NetworkPkg/Dhcp6Dxe/Dhcp6Impl.c
@@ -104,12 +104,6 @@ EfiDhcp6Start (
   Instance->UdpSts = EFI_ALREADY_STARTED;

 

   //

-  // Need to clear initial time to make sure that elapsed-time

-  // is set to 0 for first Solicit.

-  //

-  Instance->StartTime = 0;

-

-  //

   // Send the solicit message to start S.A.R.R process.

   //

   Status = Dhcp6SendSolicitMsg (Instance);

diff --git a/NetworkPkg/Dhcp6Dxe/Dhcp6Impl.h b/NetworkPkg/Dhcp6Dxe/Dhcp6Impl.h
index 71b16b19..e3e75531 100644
--- a/NetworkPkg/Dhcp6Dxe/Dhcp6Impl.h
+++ b/NetworkPkg/Dhcp6Dxe/Dhcp6Impl.h
@@ -249,6 +249,10 @@ struct _DHCP6_INSTANCE {
   volatile EFI_STATUS           UdpSts;

   BOOLEAN                       InDestroy;

   BOOLEAN                       MediaPresent;

+  //

+  // StartTime is used to calculate the 'elapsed-time' option. Refer to RFC3315,

+  // the elapsed-time is amount of time since the client began its current DHCP transaction. 

+  //

   UINT64                        StartTime;

 };

 

diff --git a/NetworkPkg/Dhcp6Dxe/Dhcp6Io.c b/NetworkPkg/Dhcp6Dxe/Dhcp6Io.c
index 0e83d078..1da31dcc 100644
--- a/NetworkPkg/Dhcp6Dxe/Dhcp6Io.c
+++ b/NetworkPkg/Dhcp6Dxe/Dhcp6Io.c
@@ -1,7 +1,7 @@
 /** @file

   Dhcp6 internal functions implementation.

 

-  Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>

 

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

@@ -593,6 +593,14 @@ Dhcp6UpdateIaInfo (
   if (Instance->Config->IaDescriptor.Type == Dhcp6OptIana) {

     T1 = NTOHL (ReadUnaligned32 ((UINT32 *) (Option + 8)));

     T2 = NTOHL (ReadUnaligned32 ((UINT32 *) (Option + 12)));

+    //

+    // Refer to RFC3155 Chapter 22.4. If a client receives an IA_NA with T1 greater than T2,

+    // and both T1 and T2 are greater than 0, the client discards the IA_NA option and processes

+    // the remainder of the message as though the server had not  included the invalid IA_NA option.

+    //

+    if (T1 > T2 && T2 > 0) {

+      return EFI_DEVICE_ERROR;

+    }

     IaInnerOpt = Option + 16;

     IaInnerLen = (UINT16) (NTOHS (ReadUnaligned16 ((UINT16 *) (Option + 2))) - 12);

   } else {

@@ -697,7 +705,7 @@ Dhcp6SeekStsOption (
               &Instance->Config->IaDescriptor

               );

   if (*Option == NULL) {

-    return EFI_DEVICE_ERROR;

+    return EFI_SUCCESS;

   }

 

   //

@@ -949,7 +957,8 @@ Dhcp6SendSolicitMsg   (
              Cursor,

              Instance->IaCb.Ia,

              Instance->IaCb.T1,

-             Instance->IaCb.T2

+             Instance->IaCb.T2,

+             Packet->Dhcp6.Header.MessageType

              );

 

   //

@@ -987,6 +996,10 @@ Dhcp6SendSolicitMsg   (
   // Dhcp6selecting.

   //

   Instance->IaCb.Ia->State = Dhcp6Selecting;

+  //

+  // Clear initial time for current transaction.

+  //

+  Instance->StartTime = 0;

 

   Status = Dhcp6TransmitPacket (Instance, Packet, Elapsed);

 

@@ -1133,7 +1146,8 @@ Dhcp6SendRequestMsg (
              Cursor,

              Instance->IaCb.Ia,

              Instance->IaCb.T1,

-             Instance->IaCb.T2

+             Instance->IaCb.T2,

+             Packet->Dhcp6.Header.MessageType

              );

 

   //

@@ -1171,6 +1185,10 @@ Dhcp6SendRequestMsg (
   // Dhcp6requesting.

   //

   Instance->IaCb.Ia->State = Dhcp6Requesting;

+  //

+  // Clear initial time for current transaction.

+  //

+  Instance->StartTime = 0;

 

   Status = Dhcp6TransmitPacket (Instance, Packet, Elapsed);

 

@@ -1282,7 +1300,7 @@ Dhcp6SendDeclineMsg (
              ServerId->Duid

              );

 

-  Cursor = Dhcp6AppendIaOption (Cursor, DecIa, 0, 0);

+  Cursor = Dhcp6AppendIaOption (Cursor, DecIa, 0, 0, Packet->Dhcp6.Header.MessageType);

 

   //

   // Determine the size/length of packet.

@@ -1305,6 +1323,10 @@ Dhcp6SendDeclineMsg (
   // Dhcp6declining.

   //

   Instance->IaCb.Ia->State = Dhcp6Declining;

+  //

+  // Clear initial time for current transaction.

+  //

+  Instance->StartTime = 0;

 

   Status = Dhcp6TransmitPacket (Instance, Packet, Elapsed);

 

@@ -1415,7 +1437,7 @@ Dhcp6SendReleaseMsg (
              &Elapsed

              );

 

-  Cursor = Dhcp6AppendIaOption (Cursor, RelIa, 0, 0);

+  Cursor = Dhcp6AppendIaOption (Cursor, RelIa, 0, 0, Packet->Dhcp6.Header.MessageType);

 

   //

   // Determine the size/length of packet

@@ -1540,7 +1562,8 @@ Dhcp6SendRenewRebindMsg (
              Cursor,

              Instance->IaCb.Ia,

              Instance->IaCb.T1,

-             Instance->IaCb.T2

+             Instance->IaCb.T2,

+             Packet->Dhcp6.Header.MessageType

              );

 

   if (!RebindRequest) {

@@ -1612,6 +1635,10 @@ Dhcp6SendRenewRebindMsg (
   //

   Instance->IaCb.Ia->State = State;

   Instance->IaCb.LeaseTime = (RebindRequest) ? Instance->IaCb.T2 : Instance->IaCb.T1;

+  //

+  // Clear initial time for current transaction.

+  //

+  Instance->StartTime = 0;

 

   Status = Dhcp6TransmitPacket (Instance, Packet, Elapsed);

 

@@ -1844,6 +1871,11 @@ Dhcp6SendInfoRequestMsg (
   //

   Packet->Length += (UINT32) (Cursor - Packet->Dhcp6.Option);

   ASSERT (Packet->Size > Packet->Length + 8);

+  

+  //

+  // Clear initial time for current transaction.

+  //

+  Instance->StartTime = 0;

 

   //

   // Send info-request packet with no state.

@@ -1941,7 +1973,8 @@ Dhcp6SendConfirmMsg (
              Cursor,

              Instance->IaCb.Ia,

              Instance->IaCb.T1,

-             Instance->IaCb.T2

+             Instance->IaCb.T2,

+             Packet->Dhcp6.Header.MessageType

              );

 

   //

@@ -1978,6 +2011,10 @@ Dhcp6SendConfirmMsg (
   // Dhcp6Confirming.

   //

   Instance->IaCb.Ia->State = Dhcp6Confirming;

+  //

+  // Clear initial time for current transaction.

+  //

+  Instance->StartTime = 0;

 

   Status = Dhcp6TransmitPacket (Instance, Packet, Elapsed);

 

@@ -2020,6 +2057,8 @@ Dhcp6HandleReplyMsg (
   ASSERT (Instance->IaCb.Ia != NULL);

   ASSERT (Packet != NULL);

 

+  Status = EFI_SUCCESS;

+

   if (Packet->Dhcp6.Header.MessageType != Dhcp6MsgReply) {

     return EFI_DEVICE_ERROR;

   }

@@ -2056,7 +2095,7 @@ Dhcp6HandleReplyMsg (
                &Instance->Config->IaDescriptor

                );

     if (Option == NULL) {

-      return EFI_DEVICE_ERROR;

+      return EFI_SUCCESS;

     }

   }

 

@@ -2070,19 +2109,6 @@ Dhcp6HandleReplyMsg (
   }

 

   //

-  // Dequeue the sent packet from retransmit list since reply received.

-  //

-  Status = Dhcp6DequeueRetry (

-             Instance,

-             Packet->Dhcp6.Header.TransactionId,

-             FALSE

-             );

-

-  if (EFI_ERROR (Status)) {

-    return Status;

-  }

-

-  //

   // When receive a valid reply packet in response to a decline/release packet,

   // the client considers the decline/release event completed regardless of the

   // status code.

@@ -2115,7 +2141,8 @@ Dhcp6HandleReplyMsg (
     //

     Instance->StartTime       = 0;

 

-    return EFI_SUCCESS;

+    Status = EFI_SUCCESS;

+    goto ON_EXIT;

   }

 

   //

@@ -2132,55 +2159,63 @@ Dhcp6HandleReplyMsg (
 

   if (!EFI_ERROR (Status)) {

     //

-    // Reset start time for next exchange.

-    //

-    Instance->StartTime       = 0;

-

-    //

     // No status code or no error status code means succeed to reply.

     //

     Status = Dhcp6UpdateIaInfo (Instance, Packet);

+    if (!EFI_ERROR (Status)) {

+      //

+      // Reset start time for next exchange.

+      //

+      Instance->StartTime       = 0;

 

-    if (EFI_ERROR (Status)) {

-      return Status;

-    }

-

-    //

-    // Set bound state and store the reply packet.

-    //

-    if (Instance->IaCb.Ia->ReplyPacket != NULL) {

-      FreePool (Instance->IaCb.Ia->ReplyPacket);

-    }

+      //

+      // Set bound state and store the reply packet.

+      //

+      if (Instance->IaCb.Ia->ReplyPacket != NULL) {

+        FreePool (Instance->IaCb.Ia->ReplyPacket);

+      }

 

-    Instance->IaCb.Ia->ReplyPacket = AllocateZeroPool (Packet->Size);

+      Instance->IaCb.Ia->ReplyPacket = AllocateZeroPool (Packet->Size);

 

-    if (Instance->IaCb.Ia->ReplyPacket == NULL) {

-      return EFI_OUT_OF_RESOURCES;

-    }

+      if (Instance->IaCb.Ia->ReplyPacket == NULL) {

+        Status = EFI_OUT_OF_RESOURCES;

+        goto ON_EXIT;

+      }

 

-    CopyMem (Instance->IaCb.Ia->ReplyPacket, Packet, Packet->Size);

+      CopyMem (Instance->IaCb.Ia->ReplyPacket, Packet, Packet->Size);

 

-    Instance->IaCb.Ia->State = Dhcp6Bound;

+      Instance->IaCb.Ia->State = Dhcp6Bound;

 

-    //

-    // For sync, set the success flag out of polling in start/renewrebind.

-    //

-    Instance->UdpSts         = EFI_SUCCESS;

+      //

+      // For sync, set the success flag out of polling in start/renewrebind.

+      //

+      Instance->UdpSts         = EFI_SUCCESS;

 

-    //

-    // Maybe this is a new round DHCP process due to some reason, such as NotOnLink

-    // ReplyMsg for ConfirmMsg should triger new round to acquire new address. In that

-    // case, clear old address.ValidLifetime and append to new address. Therefore, DHCP

-    // consumers can be notified to flush old address.

-    //

-    Dhcp6AppendCacheIa (Instance);

+      //

+      // Maybe this is a new round DHCP process due to some reason, such as NotOnLink

+      // ReplyMsg for ConfirmMsg should triger new round to acquire new address. In that

+      // case, clear old address.ValidLifetime and append to new address. Therefore, DHCP

+      // consumers can be notified to flush old address.

+      //

+      Dhcp6AppendCacheIa (Instance);

 

-    //

-    // For async, signal the Ia event to inform Ia infomation update.

-    //

-    if (Instance->Config->IaInfoEvent != NULL) {

-      gBS->SignalEvent (Instance->Config->IaInfoEvent);

+      //

+      // For async, signal the Ia event to inform Ia infomation update.

+      //

+      if (Instance->Config->IaInfoEvent != NULL) {

+        gBS->SignalEvent (Instance->Config->IaInfoEvent);

+      }

+    } else if (Status == EFI_NOT_FOUND) {

+      //

+      // Refer to RFC3315 Chapter 18.1.8, for each IA in the original Renew or Rebind message, 

+      // the client sends a Renew or Rebind if the IA is not in the Reply message.

+      // Return EFI_SUCCESS so we can continue to restart the Renew/Rebind process.

+      //

+      return EFI_SUCCESS;

     }

+    

+    goto ON_EXIT;

+    

   } else if (Option != NULL) {

     //

     // Any error status code option is found.

@@ -2226,6 +2261,19 @@ Dhcp6HandleReplyMsg (
       }

       break;

 

+    case Dhcp6StsNoBinding:

+      if (Instance->IaCb.Ia->State == Dhcp6Renewing || Instance->IaCb.Ia->State == Dhcp6Rebinding) {

+        //

+        // Refer to RFC3315 Chapter 18.1.8, for each IA in the original Renew or Rebind message, the client 

+        // sends a Request message if the IA contained a Status Code option with the NoBinding status.

+        //

+        Status = Dhcp6SendRequestMsg(Instance);

+        if (EFI_ERROR (Status)) {

+          return Status;

+        }

+      }

+      break;

+

     default:

       //

       // The other status code, just restart solicitation.

@@ -2235,6 +2283,18 @@ Dhcp6HandleReplyMsg (
   }

 

   return EFI_SUCCESS;

+  

+ON_EXIT:

+

+  if (!EFI_ERROR(Status)) {

+    Status = Dhcp6DequeueRetry (

+               Instance,

+               Packet->Dhcp6.Header.TransactionId,

+               FALSE

+               );

+  }

+  

+  return Status;

 }

 

 

@@ -2378,17 +2438,13 @@ Dhcp6HandleAdvertiseMsg (
   // display the associated status message to the user.

   // See the details in the section-17.1.3 of rfc-3315.

   //

-  Option = Dhcp6SeekOption(

-             Packet->Dhcp6.Option,

-             Packet->Length - 4,

-             Dhcp6OptStatusCode

+  Status = Dhcp6SeekStsOption (

+             Instance,

+             Packet,

+             &Option

              );

-

-  if (Option != NULL) {

-    StsCode = NTOHS (ReadUnaligned16 ((UINT16 *) (Option + 4)));

-    if (StsCode != Dhcp6StsSuccess) {

-      return EFI_DEVICE_ERROR;

-    }

+  if (EFI_ERROR (Status)) {

+    return EFI_DEVICE_ERROR;

   }

 

   //

@@ -2925,7 +2981,9 @@ Dhcp6OnTimerTick (
           // Select the advertisement received before.

           //

           Status = Dhcp6SelectAdvertiseMsg (Instance, Instance->AdSelect);

-          if (EFI_ERROR (Status)) {

+          if (Status == EFI_ABORTED) {

+            goto ON_CLOSE;

+          } else if (EFI_ERROR (Status)) {

             TxCb->RetryCnt++;

           }

           return;

@@ -2941,6 +2999,7 @@ Dhcp6OnTimerTick (
       // Check whether overflow the max retry count limit for this packet

       //

       if (TxCb->RetryCtl.Mrc != 0 && TxCb->RetryCtl.Mrc < TxCb->RetryCnt) {

+        Status = EFI_NO_RESPONSE;

         goto ON_CLOSE;

       }

 

@@ -2948,6 +3007,7 @@ Dhcp6OnTimerTick (
       // Check whether overflow the max retry duration for this packet

       //

       if (TxCb->RetryCtl.Mrd != 0 && TxCb->RetryCtl.Mrd <= TxCb->RetryLos) {

+        Status = EFI_NO_RESPONSE;

         goto ON_CLOSE;

       }

 

@@ -3037,9 +3097,10 @@ Dhcp6OnTimerTick (
 

  ON_CLOSE:

 

-  if (TxCb->TxPacket->Dhcp6.Header.MessageType == Dhcp6MsgInfoRequest ||

+  if (TxCb->TxPacket != NULL &&

+      (TxCb->TxPacket->Dhcp6.Header.MessageType == Dhcp6MsgInfoRequest ||

       TxCb->TxPacket->Dhcp6.Header.MessageType == Dhcp6MsgRenew       ||

-      TxCb->TxPacket->Dhcp6.Header.MessageType == Dhcp6MsgConfirm

+      TxCb->TxPacket->Dhcp6.Header.MessageType == Dhcp6MsgConfirm)

       ) {

     //

     // The failure of renew/Confirm will still switch to the bound state.

@@ -3064,6 +3125,6 @@ Dhcp6OnTimerTick (
     //

     // The failure of the others will terminate current state machine if timeout.

     //

-    Dhcp6CleanupSession (Instance, EFI_NO_RESPONSE);

+    Dhcp6CleanupSession (Instance, Status);

   }

 }

diff --git a/NetworkPkg/Dhcp6Dxe/Dhcp6Utility.c b/NetworkPkg/Dhcp6Dxe/Dhcp6Utility.c
index 4c320286..32247c92 100644
--- a/NetworkPkg/Dhcp6Dxe/Dhcp6Utility.c
+++ b/NetworkPkg/Dhcp6Dxe/Dhcp6Utility.c
@@ -647,6 +647,75 @@ Dhcp6AppendOption (
   return Buf;

 }

 

+/**

+  Append the appointed IA Address option to Buf, and move Buf to the end.

+

+  @param[in, out] Buf           The pointer to the position to append.

+  @param[in]      IaAddr        The pointer to the IA Address.

+  @param[in]      MessageType   Message type of DHCP6 package.

+

+  @return         Buf           The position to append the next option.

+

+**/

+UINT8 *

+Dhcp6AppendIaAddrOption (

+  IN OUT UINT8                  *Buf,

+  IN     EFI_DHCP6_IA_ADDRESS   *IaAddr,

+  IN     UINT32                 MessageType

+)

+{

+

+  //  The format of the IA Address option is:

+  //

+  //       0                   1                   2                   3

+  //       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1

+  //      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

+  //      |          OPTION_IAADDR        |          option-len           |

+  //      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

+  //      |                                                               |

+  //      |                         IPv6 address                          |

+  //      |                                                               |

+  //      |                                                               |

+  //      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

+  //      |                      preferred-lifetime                       |

+  //      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

+  //      |                        valid-lifetime                         |

+  //      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

+  //      .                                                               .

+  //      .                        IAaddr-options                         .

+  //      .                                                               .

+  //      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

+  

+  //

+  // Fill the value of Ia Address option type

+  //

+  WriteUnaligned16 ((UINT16 *) Buf, HTONS (Dhcp6OptIaAddr));

+  Buf                     += 2;

+

+  WriteUnaligned16 ((UINT16 *) Buf, HTONS (sizeof (EFI_DHCP6_IA_ADDRESS)));

+  Buf                     += 2;

+

+  CopyMem (Buf, &IaAddr->IpAddress, sizeof(EFI_IPv6_ADDRESS));

+  Buf                     += sizeof(EFI_IPv6_ADDRESS);

+

+  //

+  // Fill the value of preferred-lifetime and valid-lifetime.

+  // According to RFC3315 Chapter 18.1.2, the preferred-lifetime and valid-lifetime fields

+  // should set to 0 when initiate a Confirm message.

+  //

+  if (MessageType != Dhcp6MsgConfirm) {

+    WriteUnaligned32 ((UINT32 *) Buf, HTONL (IaAddr->PreferredLifetime));

+  }

+  Buf                     += 4;

+

+  if (MessageType != Dhcp6MsgConfirm) {

+    WriteUnaligned32 ((UINT32 *) Buf, HTONL (IaAddr->ValidLifetime));

+  }

+  Buf                     += 4;

+

+  return Buf;

+}

+

 

 /**

   Append the appointed Ia option to Buf, and move Buf to the end.

@@ -655,6 +724,7 @@ Dhcp6AppendOption (
   @param[in]      Ia            The pointer to the Ia.

   @param[in]      T1            The time of T1.

   @param[in]      T2            The time of T2.

+  @param[in]      MessageType   Message type of DHCP6 package.

 

   @return         Buf           The position to append the next Ia option.

 

@@ -664,13 +734,13 @@ Dhcp6AppendIaOption (
   IN OUT UINT8                  *Buf,

   IN     EFI_DHCP6_IA           *Ia,

   IN     UINT32                 T1,

-  IN     UINT32                 T2

+  IN     UINT32                 T2,

+  IN     UINT32                 MessageType

   )

 {

   UINT8                     *AddrOpt;

   UINT16                    *Len;

   UINTN                     Index;

-  UINT16                    Length;

 

   //

   //  The format of IA_NA and IA_TA option:

@@ -713,9 +783,9 @@ Dhcp6AppendIaOption (
   // Fill the value of t1 and t2 if iana, keep it 0xffffffff if no specified.

   //

   if (Ia->Descriptor.Type == Dhcp6OptIana) {

-    WriteUnaligned32 ((UINT32 *) Buf, ((T1 != 0) ? T1 : 0xffffffff));

+    WriteUnaligned32 ((UINT32 *) Buf, HTONL ((T1 != 0) ? T1 : 0xffffffff));

     Buf                   += 4;

-    WriteUnaligned32 ((UINT32 *) Buf, ((T2 != 0) ? T2 : 0xffffffff));

+    WriteUnaligned32 ((UINT32 *) Buf, HTONL ((T2 != 0) ? T2 : 0xffffffff));

     Buf                   += 4;

   }

 

@@ -723,15 +793,8 @@ Dhcp6AppendIaOption (
   // Fill all the addresses belong to the Ia

   //

   for (Index = 0; Index < Ia->IaAddressCount; Index++) {

-

-     AddrOpt = (UINT8 *) Ia->IaAddress + Index * sizeof (EFI_DHCP6_IA_ADDRESS);

-     Length  = HTONS ((UINT16) sizeof (EFI_DHCP6_IA_ADDRESS));

-     Buf     = Dhcp6AppendOption (

-                 Buf,

-                 HTONS (Dhcp6OptIaAddr),

-                 Length,

-                 AddrOpt

-                 );

+    AddrOpt = (UINT8 *) Ia->IaAddress + Index * sizeof (EFI_DHCP6_IA_ADDRESS);

+    Buf = Dhcp6AppendIaAddrOption (Buf, (EFI_DHCP6_IA_ADDRESS *) AddrOpt, MessageType);

   }

 

   //

@@ -827,7 +890,7 @@ SetElapsedTime (
 

   //

   // Sentinel value of 0 means that this is the first DHCP packet that we are

-  // sending and that we need to initialize the value.  First DHCP Solicit

+  // sending and that we need to initialize the value.  First DHCP message

   // gets 0 elapsed-time.  Otherwise, calculate based on StartTime.

   //

   if (Instance->StartTime == 0) {

@@ -934,10 +997,39 @@ Dhcp6SeekIaOption (
   return Option;

 }

 

+/**

+  Check whether the incoming IPv6 address in IaAddr is one of the maintained 

+  addresses in the IA control blcok.

+

+  @param[in]  IaAddr            The pointer to the IA Address to be checked.

+  @param[in]  CurrentIa         The pointer to the IA in IA control block.

+

+  @retval     TRUE              Yes, this Address is already in IA control block.

+  @retval     FALSE             No, this Address is NOT in IA control block.

+

+**/

+BOOLEAN

+Dhcp6AddrIsInCurrentIa (

+  IN    EFI_DHCP6_IA_ADDRESS      *IaAddr,

+  IN    EFI_DHCP6_IA              *CurrentIa

+  )

+{

+  UINT32    Index;

+

+  ASSERT (IaAddr != NULL && CurrentIa != NULL);

+  

+  for (Index = 0; Index < CurrentIa->IaAddressCount; Index++) {

+    if (EFI_IP6_EQUAL(&IaAddr->IpAddress, &CurrentIa->IaAddress[Index].IpAddress)) {

+      return TRUE;

+    }

+  }

+  return FALSE;

+}

 

 /**

   Parse the address option and update the address infomation.

 

+  @param[in]      CurrentIa     The pointer to the Ia Address in control blcok.

   @param[in]      IaInnerOpt    The pointer to the buffer.

   @param[in]      IaInnerLen    The length to parse.

   @param[out]     AddrNum       The number of addresses.

@@ -946,6 +1038,7 @@ Dhcp6SeekIaOption (
 **/

 VOID

 Dhcp6ParseAddrOption (

+  IN     EFI_DHCP6_IA            *CurrentIa,

   IN     UINT8                   *IaInnerOpt,

   IN     UINT16                  IaInnerLen,

      OUT UINT32                  *AddrNum,

@@ -956,6 +1049,8 @@ Dhcp6ParseAddrOption (
   UINT16                      DataLen;

   UINT16                      OpCode;

   UINT32                      ValidLt;

+  UINT32                      PreferredLt;

+  EFI_DHCP6_IA_ADDRESS        *IaAddr;

 

   //

   //  The format of the IA Address option:

@@ -992,19 +1087,21 @@ Dhcp6ParseAddrOption (
 

   while (Cursor < IaInnerOpt + IaInnerLen) {

     //

-    // Count the Ia address option with non-0 valid time.

+    // Refer to RFC3315 Chapter 18.1.8, we need to update lifetimes for any addresses in the IA option

+    // that the client already has recorded in the IA, and discard the Ia address option with 0 valid time.

     //

     OpCode  = ReadUnaligned16 ((UINT16 *) Cursor);

-    ValidLt = ReadUnaligned32 ((UINT32 *) (Cursor + 24));

-    if (OpCode == HTONS (Dhcp6OptIaAddr) && ValidLt != 0) {

-

+    PreferredLt = NTOHL (ReadUnaligned32 ((UINT32 *) (Cursor + 20)));

+    ValidLt = NTOHL (ReadUnaligned32 ((UINT32 *) (Cursor + 24)));

+    IaAddr = (EFI_DHCP6_IA_ADDRESS *) (Cursor + 4);

+    if (OpCode == HTONS (Dhcp6OptIaAddr) && ValidLt >= PreferredLt &&

+        (Dhcp6AddrIsInCurrentIa(IaAddr, CurrentIa) || ValidLt !=0)) {

       if (AddrBuf != NULL) {

-        CopyMem (AddrBuf, Cursor + 4, sizeof (EFI_DHCP6_IA_ADDRESS));

-        AddrBuf->PreferredLifetime = NTOHL (AddrBuf->PreferredLifetime);

-        AddrBuf->ValidLifetime     = NTOHL (AddrBuf->ValidLifetime);

+        CopyMem (AddrBuf, IaAddr, sizeof (EFI_DHCP6_IA_ADDRESS));

+        AddrBuf->PreferredLifetime = PreferredLt;

+        AddrBuf->ValidLifetime     = ValidLt;

         AddrBuf = (EFI_DHCP6_IA_ADDRESS *) ((UINT8 *) AddrBuf + sizeof (EFI_DHCP6_IA_ADDRESS));

       }

-

       (*AddrNum)++;

     }

     DataLen = NTOHS (ReadUnaligned16 ((UINT16 *) (Cursor + 2)));

@@ -1025,6 +1122,7 @@ Dhcp6ParseAddrOption (
   @retval     EFI_NOT_FOUND         No valid IA option is found.

   @retval     EFI_SUCCESS           Create an IA control block successfully.

   @retval     EFI_OUT_OF_RESOURCES  Required system resources could not be allocated.

+  @retval     EFI_DEVICE_ERROR      An unexpected error.

 

 **/

 EFI_STATUS

@@ -1041,14 +1139,14 @@ Dhcp6GenerateIaCb (
   EFI_DHCP6_IA                 *Ia;

 

   if (Instance->IaCb.Ia == NULL) {

-    return EFI_NOT_FOUND;

+    return EFI_DEVICE_ERROR;

   }

 

   //

   // Calculate the number of addresses for this Ia, excluding the addresses with

   // the value 0 of valid lifetime.

   //

-  Dhcp6ParseAddrOption (IaInnerOpt, IaInnerLen, &AddrNum, NULL);

+  Dhcp6ParseAddrOption (Instance->IaCb.Ia, IaInnerOpt, IaInnerLen, &AddrNum, NULL);

 

   if (AddrNum == 0) {

     return EFI_NOT_FOUND;

@@ -1070,7 +1168,7 @@ Dhcp6GenerateIaCb (
   Ia->State          = Instance->IaCb.Ia->State;

   Ia->IaAddressCount = AddrNum;

   CopyMem (&Ia->Descriptor, &Instance->Config->IaDescriptor, sizeof (EFI_DHCP6_IA_DESCRIPTOR));

-  Dhcp6ParseAddrOption (IaInnerOpt, IaInnerLen, &AddrNum, Ia->IaAddress);

+  Dhcp6ParseAddrOption (Instance->IaCb.Ia, IaInnerOpt, IaInnerLen, &AddrNum, Ia->IaAddress);

 

   //

   // Free original IA resource.

diff --git a/NetworkPkg/Dhcp6Dxe/Dhcp6Utility.h b/NetworkPkg/Dhcp6Dxe/Dhcp6Utility.h
index 2a44d006..8c3151e3 100644
--- a/NetworkPkg/Dhcp6Dxe/Dhcp6Utility.h
+++ b/NetworkPkg/Dhcp6Dxe/Dhcp6Utility.h
@@ -192,6 +192,7 @@ Dhcp6AppendOption (
   @param[in]      Ia            The pointer to the Ia.

   @param[in]      T1            The time of T1.

   @param[in]      T2            The time of T2.

+  @param[in]      MessageType   Message type of DHCP6 package.

 

   @return         Buf           The position to append the next Ia option.

 

@@ -201,7 +202,8 @@ Dhcp6AppendIaOption (
   IN OUT UINT8                  *Buf,

   IN     EFI_DHCP6_IA           *Ia,

   IN     UINT32                 T1,

-  IN     UINT32                 T2

+  IN     UINT32                 T2,

+  IN     UINT32                 MessageType

   );

 

 /**

@@ -274,6 +276,7 @@ Dhcp6SeekIaOption (
 /**

   Parse the address option and update the address info.

 

+  @param[in]      CurrentIa     The pointer to the Ia Address in control blcok.

   @param[in]      IaInnerOpt    The pointer to the buffer.

   @param[in]      IaInnerLen    The length to parse.

   @param[out]     AddrNum       The number of addresses.

@@ -282,6 +285,7 @@ Dhcp6SeekIaOption (
 **/

 VOID

 Dhcp6ParseAddrOption (

+  IN     EFI_DHCP6_IA            *CurrentIa,

   IN     UINT8                   *IaInnerOpt,

   IN     UINT16                  IaInnerLen,

      OUT UINT32                  *AddrNum,

@@ -300,6 +304,7 @@ Dhcp6ParseAddrOption (
   @retval     EFI_NOT_FOUND         No valid IA option is found.

   @retval     EFI_SUCCESS           Create an IA control block successfully.

   @retval     EFI_OUT_OF_RESOURCES  Required system resources could not be allocated.

+  @retval     EFI_DEVICE_ERROR      An unexpected error.

 

 **/

 EFI_STATUS

diff --git a/NetworkPkg/Ip6Dxe/Ip6ConfigImpl.c b/NetworkPkg/Ip6Dxe/Ip6ConfigImpl.c
index b9840444..ddb8dcd3 100644
--- a/NetworkPkg/Ip6Dxe/Ip6ConfigImpl.c
+++ b/NetworkPkg/Ip6Dxe/Ip6ConfigImpl.c
@@ -1,7 +1,7 @@
 /** @file

   The implementation of EFI IPv6 Configuration Protocol.

 

-  Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>

 

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

@@ -473,7 +473,7 @@ Ip6ConfigWriteConfigData (
 

       DataRecord           = &Variable->DataRecord[Variable->DataRecordCount];

       DataRecord->DataType = (EFI_IP6_CONFIG_DATA_TYPE) Index;

-      DataRecord->DataSize = DataItem->DataSize;

+      DataRecord->DataSize = (UINT32) DataItem->DataSize;

       DataRecord->Offset   = (UINT16) (Heap - (CHAR8 *) Variable);

 

       Variable->DataRecordCount++;

diff --git a/NetworkPkg/Ip6Dxe/Ip6ConfigImpl.h b/NetworkPkg/Ip6Dxe/Ip6ConfigImpl.h
index ccb09ccc..581978bd 100644
--- a/NetworkPkg/Ip6Dxe/Ip6ConfigImpl.h
+++ b/NetworkPkg/Ip6Dxe/Ip6ConfigImpl.h
@@ -1,7 +1,7 @@
 /** @file

   Definitions for EFI IPv6 Configuartion Protocol implementation.

 

-  Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>

 

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

@@ -129,7 +129,7 @@ typedef struct {
 

 typedef struct {

   UINT16                    Offset;

-  UINTN                     DataSize;

+  UINT32                    DataSize;

   EFI_IP6_CONFIG_DATA_TYPE  DataType;

 } IP6_CONFIG_DATA_RECORD;

 

diff --git a/NetworkPkg/Ip6Dxe/Ip6ConfigNv.c b/NetworkPkg/Ip6Dxe/Ip6ConfigNv.c
index d4f25d03..eaeb44b2 100644
--- a/NetworkPkg/Ip6Dxe/Ip6ConfigNv.c
+++ b/NetworkPkg/Ip6Dxe/Ip6ConfigNv.c
@@ -1,7 +1,7 @@
 /** @file

   Helper functions for configuring or obtaining the parameters relating to IP6.

 

-  Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

 

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

@@ -669,9 +669,8 @@ Error:
 

 /**

   This function converts the interface info to string and draws it to the IP6 UI.

-  The interface information includes interface name, interface type, hardware address,

-  address info, and route table information. The address information is also used as the

-  content of manual addresses in IP6 UI.

+  The interface information includes interface name, interface type, hardware

+  address and route table information.

 

   @param[in]       IfInfo          The pointer of EFI_IP6_CONFIG_INTERFACE_INFO.

   @param[in]       HiiHandle       The handle that was previously registered in the

@@ -693,11 +692,9 @@ Ip6ConvertInterfaceInfoToString (
   UINT32                         Index;

   UINTN                          Number;

   CHAR16                         *String;

-  CHAR16                         *LinkLocalStr;

   CHAR16                         PortString[ADDRESS_STR_MAX_SIZE];

   CHAR16                         FormatString[8];

   EFI_STRING_ID                  StringId;

-  EFI_STATUS                     Status;

 

   if ((IfInfo == NULL) || (HiiHandle == NULL) || (IfrNvData == NULL)) {

     return EFI_INVALID_PARAMETER;

@@ -782,54 +779,7 @@ Ip6ConvertInterfaceInfoToString (
     return EFI_OUT_OF_RESOURCES;

   }

 

-  //

-  // Print the host address Information.

-  //

-  Status = Ip6ConvertAddressListToString (

-             PortString,

-             HiiHandle,

-             Ip6ConfigNvHostAddress,

-             IfInfo->AddressInfo,

-             IfInfo->AddressInfoCount

-             );

-  if (EFI_ERROR (Status)) {

-    return Status;

-  }

-

-  //

-  // Copy the Host Address Info to manual address field.

-  // Do not copy the link local address.

-  //

-  LinkLocalStr = StrStr (PortString, IP6_LINK_LOCAL_PREFIX);

-  if (LinkLocalStr != NULL) {

-    Number = LinkLocalStr - PortString;

-    if (Number > 0) {

-      CopyMem (IfrNvData->ManualAddress, PortString, Number * sizeof (CHAR16));

-    }

-

-    while ((*LinkLocalStr != L' ') && (*LinkLocalStr != L'\0')) {

-      LinkLocalStr++;

-    }

-

-    if (*LinkLocalStr != L'\0') {

-      LinkLocalStr++;

-      StrCat (IfrNvData->ManualAddress, LinkLocalStr);

-    }

-  } else {

-    StrCpy (IfrNvData->ManualAddress, PortString);

-  }

-

-  //

-  // Print the route table information.

-  //

-  Status = Ip6ConvertAddressListToString (

-             PortString,

-             HiiHandle,

-             Ip6ConfigNvRouteTable,

-             IfInfo->RouteTable,

-             IfInfo->RouteCount

-             );

-  return Status;

+  return EFI_SUCCESS;

 }

 

 /**

@@ -1033,75 +983,6 @@ Ip6ConvertConfigNvDataToIfrNvData (
 

   IfrNvData->DadTransmitCount = DadXmits.DupAddrDetectTransmits;

 

-  //

-  // Get DNS server list.

-  //

-  FreePool (Data);

-  Data     = NULL;

-  DataSize = 0;

-  Status   = Ip6ConfigNvGetData (

-               Ip6Config,

-               Ip6ConfigDataTypeDnsServer,

-               &DataSize,

-               (VOID **) &Data

-               );

-

-  if (EFI_ERROR (Status) && (Status != EFI_NOT_FOUND)) {

-    goto Exit;

-  }

-

-  if (DataSize > 0) {

-    //

-    // Convert the DNS server address to string and draw it to UI.

-    //

-    Status = Ip6ConvertAddressListToString (

-               IfrNvData->DnsAddress,

-               HiiHandle,

-               Ip6ConfigNvDnsAddress,

-               Data,

-               DataSize / sizeof (EFI_IPv6_ADDRESS)

-               );

-    if (EFI_ERROR (Status)) {

-      goto Exit;

-    }

-

-    FreePool (Data);

-    Data = NULL;

-  }

-

-  //

-  // Get gateway adderss list.

-  //

-  DataSize = 0;

-  Status   = Ip6ConfigNvGetData (

-               Ip6Config,

-               Ip6ConfigDataTypeGateway,

-               &DataSize,

-               (VOID **) &Data

-               );

-

-  if (EFI_ERROR (Status) && (Status != EFI_NOT_FOUND)) {

-    goto Exit;

-  }

-

-  if (DataSize > 0) {

-    //

-    // Convert the gateway address to string and draw it to UI.

-    //

-    Status = Ip6ConvertAddressListToString (

-               IfrNvData->GatewayAddress,

-               HiiHandle,

-               Ip6ConfigNvGatewayAddress,

-               Data,

-               DataSize / sizeof (EFI_IPv6_ADDRESS)

-               );

-    if (EFI_ERROR (Status)) {

-      goto Exit;

-    }

-  }

-

-  Status = EFI_SUCCESS;

-

 Exit:

   if (Data != NULL) {

      FreePool (Data);

@@ -1112,8 +993,7 @@ Exit:
 

 /**

   Convert IFR data into IP6 configuration data. The policy, alternative interface

-  ID, and DAD transmit counts, and will be saved. If under manual policy, the configured

-  manual address, gateway address, and DNS server address will be saved.

+  ID, and DAD transmit counts, and will be saved. 

 

   @param[in]       IfrNvData       The IFR NV data.

   @param[in, out]  Instance        The IP6 config instance data.

@@ -1124,7 +1004,7 @@ Exit:
 

 **/

 EFI_STATUS

-Ip6ConvertIfrNvDataToConfigNvData (

+Ip6ConvertIfrNvDataToConfigNvDataGeneral (

   IN     IP6_CONFIG_IFR_NVDATA       *IfrNvData,

   IN OUT IP6_CONFIG_INSTANCE         *Instance

   )

@@ -1132,12 +1012,6 @@ Ip6ConvertIfrNvDataToConfigNvData (
   IP6_CONFIG_NVDATA                  *Ip6NvData;

   EFI_IP6_CONFIG_PROTOCOL            *Ip6Config;

   EFI_STATUS                         Status;

-  EFI_IP6_CONFIG_MANUAL_ADDRESS      *ManualAddress;

-  EFI_IPv6_ADDRESS                   *Address;

-  BOOLEAN                            IsAddressOk;

-  EFI_EVENT                          SetAddressEvent;

-  EFI_EVENT                          TimeoutEvent;

-  UINTN                              DataSize;

 

   if ((IfrNvData == NULL) || (Instance == NULL)) {

     return EFI_INVALID_PARAMETER;

@@ -1197,11 +1071,67 @@ Ip6ConvertIfrNvDataToConfigNvData (
     return Status;

   }

 

+  return EFI_SUCCESS;

+}

+

+/**

+  Convert IFR data into IP6 configuration data. The policy, configured

+  manual address, gateway address, and DNS server address will be saved.

+

+  @param[in]       IfrNvData       The IFR NV data.

+  @param[in, out]  Instance        The IP6 config instance data.

 

-  if (Ip6NvData->Policy == Ip6ConfigPolicyAutomatic) {

+  @retval EFI_SUCCESS              The operation finished successfully.

+  @retval EFI_INVALID_PARAMETER    Any input parameter is invalid.

+  @retval Others                   Other errors as indicated.

+

+**/

+EFI_STATUS

+Ip6ConvertIfrNvDataToConfigNvDataAdvanced (

+  IN     IP6_CONFIG_IFR_NVDATA       *IfrNvData,

+  IN OUT IP6_CONFIG_INSTANCE         *Instance

+  )

+{

+  IP6_CONFIG_NVDATA                  *Ip6NvData;

+  EFI_IP6_CONFIG_PROTOCOL            *Ip6Config;

+  EFI_STATUS                         Status;

+  EFI_IP6_CONFIG_MANUAL_ADDRESS      *ManualAddress;

+  EFI_IPv6_ADDRESS                   *Address;

+  BOOLEAN                            IsAddressOk;

+  EFI_EVENT                          SetAddressEvent;

+  EFI_EVENT                          TimeoutEvent;

+  UINTN                              DataSize;

+

+  if ((IfrNvData == NULL) || (Instance == NULL)) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  if (IfrNvData->Policy == IP6_POLICY_AUTO) {

     return EFI_SUCCESS;

   }

 

+  NET_CHECK_SIGNATURE (Instance, IP6_CONFIG_INSTANCE_SIGNATURE);

+  Ip6NvData = &Instance->Ip6NvData;

+  Ip6Config = &Instance->Ip6Config;

+

+  //

+  // Update those fields which don't have INTERACTIVE attribute.

+  //

+  Ip6NvData->Policy = Ip6ConfigPolicyManual;

+

+  //

+  // Set the configured policy.

+  //

+  Status = Ip6Config->SetData (

+                        Ip6Config,

+                        Ip6ConfigDataTypePolicy,

+                        sizeof (EFI_IP6_CONFIG_POLICY),

+                        &Ip6NvData->Policy

+                        );

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+

   //

   // Create events & timers for asynchronous settings.

   //

@@ -1358,6 +1288,7 @@ Exit:
   return Status;

 }

 

+

 /**

   This function allows the caller to request the current

   configuration for one or more named elements. The resulting

@@ -1588,6 +1519,160 @@ Ip6FormRouteConfig (
 }

 

 /**

+  Display host addresses, route table, DNS addresses and gateway addresses in

+  "IPv6 Current Setting" page.

+

+  @param[in]       Instance        The IP6 config instance data.

+

+  @retval EFI_SUCCESS              The operation finished successfully.

+  @retval Others                   Other errors as indicated.

+

+**/

+EFI_STATUS

+Ip6GetCurrentSetting (

+  IN IP6_CONFIG_INSTANCE        *Instance

+  )

+{

+  EFI_IP6_CONFIG_PROTOCOL       *Ip6Config;

+  EFI_HII_HANDLE                HiiHandle;

+  EFI_IP6_CONFIG_INTERFACE_INFO *Data;

+  UINTN                         DataSize;

+  EFI_STATUS                    Status;

+  CHAR16                        PortString[ADDRESS_STR_MAX_SIZE];

+  EFI_IP6_CONFIG_INTERFACE_INFO *IfInfo;

+  

+

+  Ip6Config = &Instance->Ip6Config;

+  HiiHandle = Instance->CallbackInfo.RegisteredHandle;

+  Data      = NULL;

+

+  //

+  // Get current interface info.

+  //

+  Status = Ip6ConfigNvGetData (

+             Ip6Config,

+             Ip6ConfigDataTypeInterfaceInfo,

+             &DataSize,

+             (VOID **) &Data

+             );

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+

+  //

+  // Generate dynamic text opcode for host address and draw it.

+  //

+  IfInfo = (EFI_IP6_CONFIG_INTERFACE_INFO *) Data;

+  Status = Ip6ConvertAddressListToString (

+             PortString,

+             HiiHandle,

+             Ip6ConfigNvHostAddress,

+             IfInfo->AddressInfo,

+             IfInfo->AddressInfoCount

+             );

+  if (EFI_ERROR (Status)) {

+    FreePool (Data);

+    return Status;

+  }

+

+  //

+  // Generate the dynamic text opcode for route table and draw it.

+  //

+  Status = Ip6ConvertAddressListToString (

+             PortString,

+             HiiHandle,

+             Ip6ConfigNvRouteTable,

+             IfInfo->RouteTable,

+             IfInfo->RouteCount

+             );

+  if (EFI_ERROR (Status)) {

+    FreePool (Data);

+    return Status;

+  }

+

+  //

+  // Get DNS server list.

+  //

+  FreePool (Data);

+  DataSize = 0;

+  Data = NULL;

+  Status = Ip6ConfigNvGetData (

+             Ip6Config,

+             Ip6ConfigDataTypeDnsServer,

+             &DataSize,

+             (VOID **) &Data

+             );

+  if (EFI_ERROR (Status) && (Status != EFI_NOT_FOUND)) {

+    if (Data != NULL) {

+      FreePool (Data);

+    }

+    return Status;

+  }

+

+  if (DataSize > 0) {

+    //

+    // Generate the dynamic text opcode for DNS server and draw it.

+    //

+    Status = Ip6ConvertAddressListToString (

+               PortString,

+               HiiHandle,

+               Ip6ConfigNvDnsAddress,

+               Data,

+               DataSize / sizeof (EFI_IPv6_ADDRESS)

+               );

+    if (EFI_ERROR (Status)) {

+      FreePool (Data);

+      return Status;

+    }

+  }

+

+  //

+  // Get gateway adderss list.

+  //

+  if (Data != NULL) {

+    FreePool (Data);

+  }

+

+  DataSize = 0;

+  Data = NULL;

+  Status = Ip6ConfigNvGetData (

+             Ip6Config,

+             Ip6ConfigDataTypeGateway,

+             &DataSize,

+             (VOID **) &Data

+             );

+  if (EFI_ERROR (Status) && (Status != EFI_NOT_FOUND)) {

+    if (Data != NULL) {

+      FreePool (Data);

+    }

+    return Status;

+  }

+

+  if (DataSize > 0) {

+    //

+    // Generate the dynamic text opcode for gateway and draw it.

+    //

+    Status = Ip6ConvertAddressListToString (

+               PortString,

+               HiiHandle,

+               Ip6ConfigNvGatewayAddress,

+               Data,

+               DataSize / sizeof (EFI_IPv6_ADDRESS)

+               );

+    if (EFI_ERROR (Status)) {

+      FreePool (Data);

+      return Status;

+    }

+  }

+

+  if (Data != NULL) {

+    FreePool (Data);

+  }

+

+  return EFI_SUCCESS;

+}

+

+/**

   This function is called to provide results data to the driver.

   This data consists of a unique key that is used to identify

   which data is either being passed back or being asked for.

@@ -1632,12 +1717,6 @@ Ip6FormCallback (
   EFI_INPUT_KEY                 Key;

   IP6_CONFIG_INSTANCE           *Instance;

   IP6_CONFIG_NVDATA             *Ip6NvData;

-  EFI_IP6_CONFIG_PROTOCOL       *Ip6Config;

-  EFI_IP6_CONFIG_INTERFACE_INFO *Data;

-  UINTN                         DataSize;

-  CHAR16                        PortString[ADDRESS_STR_MAX_SIZE];

-  EFI_HII_HANDLE                HiiHandle;

-  EFI_IP6_CONFIG_INTERFACE_INFO *IfInfo;

 

   if (This == NULL) {

     return EFI_INVALID_PARAMETER;

@@ -1676,135 +1755,7 @@ Ip6FormCallback (
   if (Action == EFI_BROWSER_ACTION_CHANGING) {

     switch (QuestionId) {

     case KEY_GET_CURRENT_SETTING:

-      Ip6Config = &Instance->Ip6Config;

-      HiiHandle = Instance->CallbackInfo.RegisteredHandle;

-      Data      = NULL;

-

-      //

-      // Get current interface info.

-      //

-      Status = Ip6ConfigNvGetData (

-                 Ip6Config,

-                 Ip6ConfigDataTypeInterfaceInfo,

-                 &DataSize,

-                 (VOID **) &Data

-                 );

-      if (EFI_ERROR (Status)) {

-        return Status;

-      }

-

-      //

-      // Generate dynamic text opcode for host address and draw it.

-      //

-      IfInfo = (EFI_IP6_CONFIG_INTERFACE_INFO *) Data;

-      Status = Ip6ConvertAddressListToString (

-                 PortString,

-                 HiiHandle,

-                 Ip6ConfigNvHostAddress,

-                 IfInfo->AddressInfo,

-                 IfInfo->AddressInfoCount

-                 );

-      if (EFI_ERROR (Status)) {

-        FreePool (Data);

-        return Status;

-      }

-

-      //

-      // Generate the dynamic text opcode for route table and draw it.

-      //

-      Status = Ip6ConvertAddressListToString (

-                 PortString,

-                 HiiHandle,

-                 Ip6ConfigNvRouteTable,

-                 IfInfo->RouteTable,

-                 IfInfo->RouteCount

-                 );

-      if (EFI_ERROR (Status)) {

-        FreePool (Data);

-        return Status;

-      }

-

-      //

-      // Get DNS server list.

-      //

-      FreePool (Data);

-      DataSize = 0;

-      Data = NULL;

-      Status = Ip6ConfigNvGetData (

-                 Ip6Config,

-                 Ip6ConfigDataTypeDnsServer,

-                 &DataSize,

-                 (VOID **) &Data

-                 );

-      if (EFI_ERROR (Status) && (Status != EFI_NOT_FOUND)) {

-        if (Data != NULL) {

-          FreePool (Data);

-        }

-        return Status;

-      }

-

-      if (DataSize > 0) {

-        //

-        // Generate the dynamic text opcode for DNS server and draw it.

-        //

-        Status = Ip6ConvertAddressListToString (

-                   PortString,

-                   HiiHandle,

-                   Ip6ConfigNvDnsAddress,

-                   Data,

-                   DataSize / sizeof (EFI_IPv6_ADDRESS)

-                   );

-        if (EFI_ERROR (Status)) {

-          FreePool (Data);

-          return Status;

-        }

-      }

-

-      //

-      // Get gateway adderss list.

-      //

-      if (Data != NULL) {

-        FreePool (Data);

-      }

-

-      DataSize = 0;

-      Data = NULL;

-      Status = Ip6ConfigNvGetData (

-                 Ip6Config,

-                 Ip6ConfigDataTypeGateway,

-                 &DataSize,

-                 (VOID **) &Data

-                 );

-      if (EFI_ERROR (Status) && (Status != EFI_NOT_FOUND)) {

-        if (Data != NULL) {

-          FreePool (Data);

-        }

-        return Status;

-      }

-

-      if (DataSize > 0) {

-        //

-        // Generate the dynamic text opcode for gateway and draw it.

-        //

-        Status = Ip6ConvertAddressListToString (

-                   PortString,

-                   HiiHandle,

-                   Ip6ConfigNvGatewayAddress,

-                   Data,

-                   DataSize / sizeof (EFI_IPv6_ADDRESS)

-                   );

-        if (EFI_ERROR (Status)) {

-          FreePool (Data);

-          return Status;

-        }

-      }

-

-      if (Data != NULL) {

-        FreePool (Data);

-      }

-

-      Status = EFI_SUCCESS;

-

+      Status = Ip6GetCurrentSetting (Instance);

       break;

 

     default:

@@ -1813,6 +1764,13 @@ Ip6FormCallback (
   } else if (Action == EFI_BROWSER_ACTION_CHANGED) {

     switch (QuestionId) {

     case KEY_SAVE_CONFIG_CHANGES:

+      Status = Ip6ConvertIfrNvDataToConfigNvDataAdvanced (IfrNvData, Instance);

+      if (EFI_ERROR (Status)) {

+        break;

+      }

+

+      Status = Ip6GetCurrentSetting (Instance);

+

       *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_SUBMIT_EXIT;

       break;

 

@@ -1829,7 +1787,7 @@ Ip6FormCallback (
       break;

 

     case KEY_SAVE_CHANGES:

-      Status = Ip6ConvertIfrNvDataToConfigNvData (IfrNvData, Instance);

+      Status = Ip6ConvertIfrNvDataToConfigNvDataGeneral (IfrNvData, Instance);

       if (EFI_ERROR (Status)) {

         break;

       }

diff --git a/NetworkPkg/Ip6Dxe/Ip6NvData.h b/NetworkPkg/Ip6Dxe/Ip6NvData.h
index b67e6249..09177613 100644
--- a/NetworkPkg/Ip6Dxe/Ip6NvData.h
+++ b/NetworkPkg/Ip6Dxe/Ip6NvData.h
@@ -1,7 +1,7 @@
 /** @file

   NVData structure used by the IP6 configuration component.

 

-  Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

 

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

@@ -43,7 +43,7 @@
 

 #define INTERFACE_ID_STR_MIN_SIZE 1

 #define INTERFACE_ID_STR_MAX_SIZE 23

-#define INTERFACE_ID_STR_STORAGE  24

+#define INTERFACE_ID_STR_STORAGE  25

 #define IP6_STR_MAX_SIZE          40

 #define ADDRESS_STR_MIN_SIZE      2

 #define ADDRESS_STR_MAX_SIZE      255

diff --git a/NetworkPkg/UefiPxeBcDxe/PxeBcBoot.c b/NetworkPkg/UefiPxeBcDxe/PxeBcBoot.c
index e814d5a8..540adee3 100644
--- a/NetworkPkg/UefiPxeBcDxe/PxeBcBoot.c
+++ b/NetworkPkg/UefiPxeBcDxe/PxeBcBoot.c
@@ -1,7 +1,7 @@
 /** @file

   Boot functions implementation for UefiPxeBc Driver.

 

-  Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>

 

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

@@ -278,7 +278,7 @@ PxeBcSelectBootMenu (
   PXEBC_BOOT_MENU_ENTRY      *MenuArray[PXEBC_MENU_MAX_NUM];

 

   Finish    = FALSE;

-  Select    = 1;

+  Select    = 0;

   Index     = 0;

   *Type     = 0;

   Mode      = Private->PxeBc.Mode;

diff --git a/NetworkPkg/UefiPxeBcDxe/PxeBcImpl.c b/NetworkPkg/UefiPxeBcDxe/PxeBcImpl.c
index 183dc0ce..07f2b6cf 100644
--- a/NetworkPkg/UefiPxeBcDxe/PxeBcImpl.c
+++ b/NetworkPkg/UefiPxeBcDxe/PxeBcImpl.c
@@ -1,7 +1,7 @@
 /** @file

   This implementation of EFI_PXE_BASE_CODE_PROTOCOL and EFI_LOAD_FILE_PROTOCOL.

 

-  Copyright (c) 2007 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>

 

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

@@ -428,10 +428,6 @@ EfiPxeBcDhcp (
     // Start S.A.R.R. process to get a IPv6 address and other boot information.

     //

     Status = PxeBcDhcp6Sarr (Private, Private->Dhcp6);

-

-    if (EFI_ERROR (Status)) {

-      goto ON_EXIT;

-    }

   } else {

 

     //

@@ -443,13 +439,11 @@ EfiPxeBcDhcp (
     // Start D.O.R.A. process to get a IPv4 address and other boot information.

     //

     Status = PxeBcDhcp4Dora (Private, Private->Dhcp4);

-

-    if (EFI_ERROR (Status)) {

-      goto ON_EXIT;

-    }

   }

-  

-ON_EXIT:

+

+  //

+  // Reconfigure the UDP instance with the default configuration.

+  //

   if (Mode->UsingIpv6) {

     Private->Udp6Read->Configure (Private->Udp6Read, &Private->Udp6CfgData);

   } else {

@@ -572,6 +566,7 @@ EfiPxeBcDiscover (
   //

   // There are 3 methods to get the information for discover.

   //

+  ZeroMem (&DefaultInfo, sizeof (EFI_PXE_BASE_CODE_DISCOVER_INFO));

   if (*Layer != EFI_PXE_BASE_CODE_BOOT_LAYER_INITIAL) {

     //

     // 1. Take the previous setting as the discover info.

@@ -690,9 +685,7 @@ EfiPxeBcDiscover (
       }

   }

 

-  if (EFI_ERROR (Status)) {

-    goto ON_EXIT;

-  } else {

+  if (!EFI_ERROR (Status)) {

     //

     // Parse the cached PXE reply packet, and store it into mode data if valid.

     //

@@ -964,11 +957,9 @@ EfiPxeBcMtftp (
     Mode->IcmpErrorReceived = TRUE;

   }

 

-  if (EFI_ERROR (Status)) {

-    goto ON_EXIT;

-  }

-  

-ON_EXIT:

+  //

+  // Reconfigure the UDP instance with the default configuration.

+  //

   if (Mode->UsingIpv6) {

     Private->Udp6Read->Configure (Private->Udp6Read, &Private->Udp6CfgData);

   } else {

diff --git a/NetworkPkg/UefiPxeBcDxe/PxeBcSupport.c b/NetworkPkg/UefiPxeBcDxe/PxeBcSupport.c
index f918d6a2..e6fb01ca 100644
--- a/NetworkPkg/UefiPxeBcDxe/PxeBcSupport.c
+++ b/NetworkPkg/UefiPxeBcDxe/PxeBcSupport.c
@@ -1,7 +1,7 @@
 /** @file

   Support functions implementation for UefiPxeBc Driver.

 

-  Copyright (c) 2007 - 2011, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>

 

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

@@ -59,10 +59,6 @@ PxeBcFlushStaionIp (
     }

 

     Status = Private->Ip6->Receive (Private->Ip6, &Private->Icmp6Token);

-    if (EFI_ERROR (Status)) {

-      goto ON_EXIT;

-    }

-

   } else {

     ASSERT (SubnetMask != NULL);

     CopyMem (&Private->Udp4CfgData.StationAddress, StationIp, sizeof (EFI_IPv4_ADDRESS));

@@ -82,10 +78,6 @@ PxeBcFlushStaionIp (
     }

 

     Status = Private->Ip4->Receive (Private->Ip4, &Private->IcmpToken);

-    if (EFI_ERROR (Status)) {

-      goto ON_EXIT;

-    }

-

   }

 

 ON_EXIT:

diff --git a/Omap35xxPkg/Flash/Flash.c b/Omap35xxPkg/Flash/Flash.c
index 0056acd6..c63e0a33 100644
--- a/Omap35xxPkg/Flash/Flash.c
+++ b/Omap35xxPkg/Flash/Flash.c
@@ -1,780 +1,780 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include "Flash.h"
-
-NAND_PART_INFO_TABLE gNandPartInfoTable[1] = {
-  { 0x2C, 0xBA, 17, 11 }
-};
-
-NAND_FLASH_INFO *gNandFlashInfo = NULL;
-UINT8           *gEccCode;
-UINTN           gNum512BytesChunks = 0;
-
-//
-
-// Device path for SemiHosting. It contains our autogened Caller ID GUID.
-
-//
-
-typedef struct {
-
-  VENDOR_DEVICE_PATH        Guid;
-
-  EFI_DEVICE_PATH_PROTOCOL  End;
-
-} FLASH_DEVICE_PATH;
-
-
-
-FLASH_DEVICE_PATH gDevicePath = {
-
-  {
-
-    { HARDWARE_DEVICE_PATH, HW_VENDOR_DP, sizeof (VENDOR_DEVICE_PATH), 0 },
-
-    EFI_CALLER_ID_GUID
-
-  },
-
-  { END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE, sizeof (EFI_DEVICE_PATH_PROTOCOL), 0}
-
-};
-
-
-
-//Actual page address = Column address + Page address + Block address.
-UINTN
-GetActualPageAddressInBytes (
-  UINTN BlockIndex,
-  UINTN PageIndex
-)
-{
-  //BlockAddressStart = Start of the Block address in actual NAND
-  //PageAddressStart = Start of the Page address in actual NAND
-  return ((BlockIndex << gNandFlashInfo->BlockAddressStart) + (PageIndex << gNandFlashInfo->PageAddressStart));
-}
-
-VOID
-NandSendCommand (
-  UINT8 Command
-)
-{
-  MmioWrite16(GPMC_NAND_COMMAND_0, Command);
-}
-
-VOID
-NandSendAddress (
-  UINT8 Address
-)
-{
-  MmioWrite16(GPMC_NAND_ADDRESS_0, Address);
-}
-
-UINT16
-NandReadStatus (
-  VOID
-  )
-{
-  //Send READ STATUS command
-  NandSendCommand(READ_STATUS_CMD);
-
-  //Read status.
-  return MmioRead16(GPMC_NAND_DATA_0);
-}
-
-VOID
-NandSendAddressCycles (
-  UINTN Address
-)
-{
-  //Column address
-  NandSendAddress(Address & 0xff);
-  Address >>= 8;
-
-  //Column address
-  NandSendAddress(Address & 0x07);
-  Address >>= 3;
-
-  //Page and Block address
-  NandSendAddress(Address & 0xff);
-  Address >>= 8;
-
-  //Block address
-  NandSendAddress(Address & 0xff);
-  Address >>= 8;
-
-  //Block address
-  NandSendAddress(Address & 0x01);
-}
-
-VOID
-GpmcInit (
-  VOID
-  )
-{
-  //Enable Smart-idle mode.
-  MmioWrite32 (GPMC_SYSCONFIG, SMARTIDLEMODE);
-
-  //Set IRQSTATUS and IRQENABLE to the reset value
-  MmioWrite32 (GPMC_IRQSTATUS, 0x0);
-  MmioWrite32 (GPMC_IRQENABLE, 0x0);
-
-  //Disable GPMC timeout control.
-  MmioWrite32 (GPMC_TIMEOUT_CONTROL, TIMEOUTDISABLE);
-
-  //Set WRITEPROTECT bit to enable write access.
-  MmioWrite32 (GPMC_CONFIG, WRITEPROTECT_HIGH);
-
-  //NOTE: Following GPMC_CONFIGi_0 register settings are taken from u-boot memory dump.
-  MmioWrite32 (GPMC_CONFIG1_0, DEVICETYPE_NAND | DEVICESIZE_X16);
-  MmioWrite32 (GPMC_CONFIG2_0, CSRDOFFTIME | CSWROFFTIME);
-  MmioWrite32 (GPMC_CONFIG3_0, ADVRDOFFTIME | ADVWROFFTIME);
-  MmioWrite32 (GPMC_CONFIG4_0, OEONTIME | OEOFFTIME | WEONTIME | WEOFFTIME);
-  MmioWrite32 (GPMC_CONFIG5_0, RDCYCLETIME | WRCYCLETIME | RDACCESSTIME | PAGEBURSTACCESSTIME);
-  MmioWrite32 (GPMC_CONFIG6_0, WRACCESSTIME | WRDATAONADMUXBUS | CYCLE2CYCLEDELAY | CYCLE2CYCLESAMECSEN);
-  MmioWrite32 (GPMC_CONFIG7_0, MASKADDRESS_128MB | CSVALID | BASEADDRESS);
-}
-
-EFI_STATUS
-NandDetectPart (
-  VOID
-)
-{
-  UINT8      NandInfo = 0;
-  UINT8      PartInfo[5];
-  UINTN      Index;
-  BOOLEAN    Found = FALSE;
-
-  //Send READ ID command
-  NandSendCommand(READ_ID_CMD);
-
-  //Send one address cycle.
-  NandSendAddress(0);
-
-  //Read 5-bytes to idenfity code programmed into the NAND flash devices.
-  //BYTE 0 = Manufacture ID
-  //Byte 1 = Device ID
-  //Byte 2, 3, 4 = Nand part specific information (Page size, Block size etc)
-  for (Index = 0; Index < sizeof(PartInfo); Index++) {
-    PartInfo[Index] = MmioRead16(GPMC_NAND_DATA_0);
-  }
-
-  //Check if the ManufactureId and DeviceId are part of the currently supported nand parts.
-  for (Index = 0; Index < sizeof(gNandPartInfoTable)/sizeof(NAND_PART_INFO_TABLE); Index++) {
-    if (gNandPartInfoTable[Index].ManufactureId == PartInfo[0] && gNandPartInfoTable[Index].DeviceId == PartInfo[1]) {
-      gNandFlashInfo->BlockAddressStart = gNandPartInfoTable[Index].BlockAddressStart;
-      gNandFlashInfo->PageAddressStart = gNandPartInfoTable[Index].PageAddressStart;
-      Found = TRUE;
-      break;
-    }
-  }
-
-  if (Found == FALSE) {
-    DEBUG ((EFI_D_ERROR, "Nand part is not currently supported. Manufacture id: %x, Device id: %x\n", PartInfo[0], PartInfo[1]));
-    return EFI_NOT_FOUND;
-  }
-
-  //Populate NAND_FLASH_INFO based on the result of READ ID command.
-  gNandFlashInfo->ManufactureId = PartInfo[0];
-  gNandFlashInfo->DeviceId = PartInfo[1];
-  NandInfo = PartInfo[3];
-
-  if (PAGE_SIZE(NandInfo) == PAGE_SIZE_2K_VAL) {
-    gNandFlashInfo->PageSize = PAGE_SIZE_2K;
-  } else {
-    DEBUG ((EFI_D_ERROR, "Unknown Page size.\n"));
-    return EFI_DEVICE_ERROR;
-  }
-
-  if (SPARE_AREA_SIZE(NandInfo) == SPARE_AREA_SIZE_64B_VAL) {
-    gNandFlashInfo->SparePageSize = SPARE_AREA_SIZE_64B;
-  } else {
-    DEBUG ((EFI_D_ERROR, "Unknown Spare area size.\n"));
-    return EFI_DEVICE_ERROR;
-  }
-
-  if (BLOCK_SIZE(NandInfo) == BLOCK_SIZE_128K_VAL) {
-    gNandFlashInfo->BlockSize = BLOCK_SIZE_128K;
-  } else {
-    DEBUG ((EFI_D_ERROR, "Unknown Block size.\n"));
-    return EFI_DEVICE_ERROR;
-  }
-
-  if (ORGANIZATION(NandInfo) == ORGANIZATION_X8) {
-    gNandFlashInfo->Organization = 0;
-  } else if (ORGANIZATION(NandInfo) == ORGANIZATION_X16) {
-    gNandFlashInfo->Organization = 1;
-  }
-
-  //Calculate total number of blocks.
-  gNandFlashInfo->NumPagesPerBlock = DivU64x32(gNandFlashInfo->BlockSize, gNandFlashInfo->PageSize);
-
-  return EFI_SUCCESS;
-}
-
-VOID
-NandConfigureEcc (
-  VOID
-  )
-{
-  //Define ECC size 0 and size 1 to 512 bytes
-  MmioWrite32 (GPMC_ECC_SIZE_CONFIG, (ECCSIZE0_512BYTES | ECCSIZE1_512BYTES));
-}
-
-VOID 
-NandEnableEcc (
-  VOID
-  )
-{
-  //Clear all the ECC result registers and select ECC result register 1
-  MmioWrite32 (GPMC_ECC_CONTROL, (ECCCLEAR | ECCPOINTER_REG1));
-
-  //Enable ECC engine on CS0
-  MmioWrite32 (GPMC_ECC_CONFIG, (ECCENABLE | ECCCS_0 | ECC16B));
-}
-
-VOID
-NandDisableEcc (
-  VOID
-  )
-{
-  //Turn off ECC engine.
-  MmioWrite32 (GPMC_ECC_CONFIG, ECCDISABLE);
-}
-
-VOID
-NandCalculateEcc (
-  VOID
-  )
-{
-  UINTN Index;
-  UINTN EccResultRegister;
-  UINTN EccResult;
-
-  //Capture 32-bit ECC result for each 512-bytes chunk.
-  //In our case PageSize is 2K so read ECC1-ECC4 result registers and
-  //generate total of 12-bytes of ECC code for the particular page.
-
-  EccResultRegister = GPMC_ECC1_RESULT;
-
-  for (Index = 0; Index < gNum512BytesChunks; Index++) {
-
-    EccResult = MmioRead32 (EccResultRegister);
-
-    //Calculate ECC code from 32-bit ECC result value.
-    //NOTE: Following calculation is not part of TRM. We got this information 
-    //from Beagleboard mailing list.
-    gEccCode[Index * 3] = EccResult & 0xFF;
-    gEccCode[(Index * 3) + 1] = (EccResult >> 16) & 0xFF;
-    gEccCode[(Index * 3) + 2] = (((EccResult >> 20) & 0xF0) | ((EccResult >> 8) & 0x0F));
-
-    //Point to next ECC result register.
-    EccResultRegister += 4;
-  }
-}
-
-EFI_STATUS
-NandReadPage (
-  IN  UINTN                         BlockIndex,
-  IN  UINTN                         PageIndex,
-  OUT VOID                          *Buffer,
-  OUT UINT8                         *SpareBuffer
-)
-{
-  UINTN      Address;
-  UINTN      Index;
-  UINTN      NumMainAreaWords = (gNandFlashInfo->PageSize/2);
-  UINTN      NumSpareAreaWords = (gNandFlashInfo->SparePageSize/2);
-  UINT16     *MainAreaWordBuffer = Buffer;
-  UINT16     *SpareAreaWordBuffer = (UINT16 *)SpareBuffer;
-  UINTN      Timeout = MAX_RETRY_COUNT;
-
-  //Generate device address in bytes to access specific block and page index
-  Address = GetActualPageAddressInBytes(BlockIndex, PageIndex);
-
-  //Send READ command
-  NandSendCommand(PAGE_READ_CMD);
-
-  //Send 5 Address cycles to access specific device address
-  NandSendAddressCycles(Address);
-
-  //Send READ CONFIRM command
-  NandSendCommand(PAGE_READ_CONFIRM_CMD);
-
-  //Poll till device is busy.
-  while (Timeout) {
-    if ((NandReadStatus() & NAND_READY) == NAND_READY) {
-      break;
-    }
-    Timeout--;
-  }
-
-  if (Timeout == 0) {
-    DEBUG ((EFI_D_ERROR, "Read page timed out.\n"));
-    return EFI_TIMEOUT;
-  }
-
-  //Reissue READ command
-  NandSendCommand(PAGE_READ_CMD);
-
-  //Enable ECC engine.
-  NandEnableEcc();
-
-  //Read data into the buffer.
-  for (Index = 0; Index < NumMainAreaWords; Index++) {
-    *MainAreaWordBuffer++ = MmioRead16(GPMC_NAND_DATA_0);
-  }
-
-  //Read spare area into the buffer.
-  for (Index = 0; Index < NumSpareAreaWords; Index++) {
-    *SpareAreaWordBuffer++ = MmioRead16(GPMC_NAND_DATA_0);
-  }
-
-  //Calculate ECC.
-  NandCalculateEcc();
-
-  //Turn off ECC engine.
-  NandDisableEcc();
-
-  //Perform ECC correction.
-  //Need to implement..
-
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-NandWritePage (
-  IN  UINTN                         BlockIndex,
-  IN  UINTN                         PageIndex,
-  OUT VOID                          *Buffer,
-  IN  UINT8                         *SpareBuffer
-)
-{
-  UINTN      Address;
-  UINT16     *MainAreaWordBuffer = Buffer;
-  UINT16     *SpareAreaWordBuffer = (UINT16 *)SpareBuffer;
-  UINTN      Index;
-  UINTN      NandStatus;
-  UINTN      Timeout = MAX_RETRY_COUNT;
-
-  //Generate device address in bytes to access specific block and page index
-  Address = GetActualPageAddressInBytes(BlockIndex, PageIndex);
-
-  //Send SERIAL DATA INPUT command
-  NandSendCommand(PROGRAM_PAGE_CMD);
-
-  //Send 5 Address cycles to access specific device address
-  NandSendAddressCycles(Address);
-
-  //Enable ECC engine.
-  NandEnableEcc();
-
-  //Data input from Buffer
-  for (Index = 0; Index < (gNandFlashInfo->PageSize/2); Index++) {
-    MmioWrite16(GPMC_NAND_DATA_0, *MainAreaWordBuffer++);
-
-    //After each write access, device has to wait to accept data.
-    //Currently we may not be programming proper timing parameters to 
-    //the GPMC_CONFIGi_0 registers and we would need to figure that out.
-    //Without following delay, page programming fails.
-    gBS->Stall(1);
-  }
-
-  //Calculate ECC.
-  NandCalculateEcc();
-
-  //Turn off ECC engine.
-  NandDisableEcc();
-
-  //Prepare Spare area buffer with ECC codes.
-  SetMem(SpareBuffer, gNandFlashInfo->SparePageSize, 0xFF);
-  CopyMem(&SpareBuffer[ECC_POSITION], gEccCode, gNum512BytesChunks * 3);
-
-  //Program spare area with calculated ECC.
-  for (Index = 0; Index < (gNandFlashInfo->SparePageSize/2); Index++) {
-    MmioWrite16(GPMC_NAND_DATA_0, *SpareAreaWordBuffer++);
-  }
-
-  //Send PROGRAM command
-  NandSendCommand(PROGRAM_PAGE_CONFIRM_CMD);
-
-  //Poll till device is busy.
-  NandStatus = 0;
-  while (Timeout) {
-    NandStatus = NandReadStatus();
-    if ((NandStatus & NAND_READY) == NAND_READY) {
-      break;
-    }
-    Timeout--;
-  }
-
-  if (Timeout == 0) {
-    DEBUG ((EFI_D_ERROR, "Program page timed out.\n"));
-    return EFI_TIMEOUT;
-  }
-
-  //Bit0 indicates Pass/Fail status
-  if (NandStatus & NAND_FAILURE) {
-    return EFI_DEVICE_ERROR;
-  }
-
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-NandEraseBlock (
-  IN UINTN BlockIndex
-)
-{
-  UINTN      Address;
-  UINTN      NandStatus;
-  UINTN      Timeout = MAX_RETRY_COUNT;
-
-  //Generate device address in bytes to access specific block and page index
-  Address = GetActualPageAddressInBytes(BlockIndex, 0);
-
-  //Send ERASE SETUP command
-  NandSendCommand(BLOCK_ERASE_CMD);
-
-  //Send 3 address cycles to device to access Page address and Block address
-  Address >>= 11; //Ignore column addresses
-
-  NandSendAddress(Address & 0xff);
-  Address >>= 8;
-
-  NandSendAddress(Address & 0xff);
-  Address >>= 8;
-
-  NandSendAddress(Address & 0xff);
-
-  //Send ERASE CONFIRM command
-  NandSendCommand(BLOCK_ERASE_CONFIRM_CMD);
-
-  //Poll till device is busy.
-  NandStatus = 0;
-  while (Timeout) {
-    NandStatus = NandReadStatus();
-    if ((NandStatus & NAND_READY) == NAND_READY) {
-      break;
-    }
-    Timeout--;
-    gBS->Stall(1);
-  }
-
-  if (Timeout == 0) {
-    DEBUG ((EFI_D_ERROR, "Erase block timed out for Block: %d.\n", BlockIndex));
-    return EFI_TIMEOUT;
-  }
-
-  //Bit0 indicates Pass/Fail status
-  if (NandStatus & NAND_FAILURE) {
-    return EFI_DEVICE_ERROR;
-  }
-
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-NandReadBlock (
-  IN UINTN                          StartBlockIndex,
-  IN UINTN                          EndBlockIndex,
-  OUT VOID                          *Buffer,
-  OUT VOID                          *SpareBuffer
-)
-{
-  UINTN      BlockIndex;
-  UINTN      PageIndex;
-  EFI_STATUS Status = EFI_SUCCESS;
-
-  for (BlockIndex = StartBlockIndex; BlockIndex <= EndBlockIndex; BlockIndex++) {
-    //For each block read number of pages
-    for (PageIndex = 0; PageIndex < gNandFlashInfo->NumPagesPerBlock; PageIndex++) {
-      Status = NandReadPage(BlockIndex, PageIndex, Buffer, SpareBuffer);
-      if (EFI_ERROR(Status)) {
-        return Status;
-      }
-      Buffer = ((UINT8 *)Buffer + gNandFlashInfo->PageSize);
-    }
-  }
-
-  return Status;
-}
-
-EFI_STATUS
-NandWriteBlock (
-  IN UINTN                          StartBlockIndex,
-  IN UINTN                          EndBlockIndex,
-  OUT VOID                          *Buffer,
-  OUT VOID                          *SpareBuffer
-  )
-{
-  UINTN      BlockIndex;
-  UINTN      PageIndex;
-  EFI_STATUS Status = EFI_SUCCESS;
-
-  for (BlockIndex = StartBlockIndex; BlockIndex <= EndBlockIndex; BlockIndex++) {
-    //Page programming.
-    for (PageIndex = 0; PageIndex < gNandFlashInfo->NumPagesPerBlock; PageIndex++) {
-      Status = NandWritePage(BlockIndex, PageIndex, Buffer, SpareBuffer);
-      if (EFI_ERROR(Status)) {
-        return Status;
-      }
-      Buffer = ((UINT8 *)Buffer + gNandFlashInfo->PageSize);
-    }
-  }
-
-  return Status;
-}
-
-EFI_STATUS
-EFIAPI
-NandFlashReset (
-  IN EFI_BLOCK_IO_PROTOCOL          *This,
-  IN BOOLEAN                        ExtendedVerification
-  )
-{
-  UINTN BusyStall = 50;                            // microSeconds
-  UINTN ResetBusyTimeout = (1000000 / BusyStall);  // 1 Second
-
-  //Send RESET command to device.
-  NandSendCommand(RESET_CMD);
-  
-  //Wait for 1ms before we check status register.
-  gBS->Stall(1000);
-
-  //Check BIT#5 & BIT#6 in Status register to make sure RESET is done.
-  while ((NandReadStatus() & NAND_RESET_STATUS) != NAND_RESET_STATUS) {
-
-    //In case of extended verification, wait for extended amount of time
-    //to make sure device is reset.
-    if (ExtendedVerification) {
-      if (ResetBusyTimeout == 0) {
-        return EFI_DEVICE_ERROR;
-      }
-
-      gBS->Stall(BusyStall);
-      ResetBusyTimeout--;
-    }
-  }
-  
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-EFIAPI
-NandFlashReadBlocks (
-  IN EFI_BLOCK_IO_PROTOCOL          *This,
-  IN UINT32                         MediaId,
-  IN EFI_LBA                        Lba,
-  IN UINTN                          BufferSize,
-  OUT VOID                          *Buffer
-  )
-{
-  UINTN      NumBlocks;
-  UINTN      EndBlockIndex;
-  EFI_STATUS Status;
-  UINT8      *SpareBuffer = NULL;
-
-  if (Buffer == NULL) {
-    Status = EFI_INVALID_PARAMETER;
-    goto exit;
-  }
-  
-  if (Lba > LAST_BLOCK) {
-    Status = EFI_INVALID_PARAMETER;
-    goto exit;
-  }
-  
-  if ((BufferSize % gNandFlashInfo->BlockSize) != 0) {
-    Status = EFI_BAD_BUFFER_SIZE;
-    goto exit;
-  }
-
-  NumBlocks = DivU64x32(BufferSize, gNandFlashInfo->BlockSize);
-  EndBlockIndex = ((UINTN)Lba + NumBlocks) - 1;
-
-  SpareBuffer = (UINT8 *)AllocatePool(gNandFlashInfo->SparePageSize);
-  if (SpareBuffer == NULL) {
-    Status = EFI_OUT_OF_RESOURCES;
-    goto exit;
-  }
-
-  //Read block
-  Status = NandReadBlock((UINTN)Lba, EndBlockIndex, Buffer, SpareBuffer);
-  if (EFI_ERROR(Status)) {
-    DEBUG((EFI_D_ERROR, "Read block fails: %x\n", Status));
-    goto exit;
-  }
-
-exit:
-  if (SpareBuffer != NULL) {
-    FreePool (SpareBuffer);
-  }
-
-  return Status;
-}
-
-EFI_STATUS
-EFIAPI
-NandFlashWriteBlocks (
-  IN EFI_BLOCK_IO_PROTOCOL          *This,
-  IN UINT32                         MediaId,
-  IN EFI_LBA                        Lba,
-  IN UINTN                          BufferSize,
-  IN VOID                           *Buffer
-  )
-{
-  UINTN      BlockIndex;
-  UINTN      NumBlocks;
-  UINTN      EndBlockIndex;
-  EFI_STATUS Status;
-  UINT8      *SpareBuffer = NULL;
-
-  if (Buffer == NULL) {
-    Status = EFI_INVALID_PARAMETER;
-    goto exit;
-  }
-  
-  if (Lba > LAST_BLOCK) {
-    Status = EFI_INVALID_PARAMETER;
-    goto exit;
-  }
-  
-  if ((BufferSize % gNandFlashInfo->BlockSize) != 0) {
-    Status = EFI_BAD_BUFFER_SIZE;
-    goto exit;
-  }
-
-  NumBlocks = DivU64x32(BufferSize, gNandFlashInfo->BlockSize);
-  EndBlockIndex = ((UINTN)Lba + NumBlocks) - 1;
-
-  SpareBuffer = (UINT8 *)AllocatePool(gNandFlashInfo->SparePageSize);
-  if (SpareBuffer == NULL) {
-    Status = EFI_OUT_OF_RESOURCES;
-    goto exit;
-  }
-
-  // Erase block
-  for (BlockIndex = (UINTN)Lba; BlockIndex <= EndBlockIndex; BlockIndex++) {
-    Status = NandEraseBlock(BlockIndex);
-    if (EFI_ERROR(Status)) {
-      DEBUG((EFI_D_ERROR, "Erase block failed. Status: %x\n", Status));
-      goto exit;
-    }
-  }
-  
-  // Program data
-  Status = NandWriteBlock((UINTN)Lba, EndBlockIndex, Buffer, SpareBuffer);
-  if (EFI_ERROR(Status)) {
-    DEBUG((EFI_D_ERROR, "Block write fails: %x\n", Status));
-    goto exit;
-  }
-
-exit:
-  if (SpareBuffer != NULL) {
-    FreePool (SpareBuffer);
-  }
-
-  return Status;
-}
-
-EFI_STATUS
-EFIAPI
-NandFlashFlushBlocks (
-  IN EFI_BLOCK_IO_PROTOCOL  *This
-  )
-{
-  return EFI_SUCCESS;
-}
-
-
-
-EFI_BLOCK_IO_MEDIA gNandFlashMedia = {
-  SIGNATURE_32('n','a','n','d'),            // MediaId
-  FALSE,                                    // RemovableMedia
-  TRUE,                                     // MediaPresent
-  FALSE,                                    // LogicalPartition
-  FALSE,                                    // ReadOnly
-  FALSE,                                    // WriteCaching
-  0,                                        // BlockSize
-  2,                                        // IoAlign
-  0,                                        // Pad
-  0                                         // LastBlock
-};
-
-EFI_BLOCK_IO_PROTOCOL BlockIo = 
-{
-  EFI_BLOCK_IO_INTERFACE_REVISION,  // Revision
-  &gNandFlashMedia,                  // *Media
-  NandFlashReset,                   // Reset
-  NandFlashReadBlocks,              // ReadBlocks
-  NandFlashWriteBlocks,             // WriteBlocks
-  NandFlashFlushBlocks              // FlushBlocks
-};
-
-EFI_STATUS
-NandFlashInitialize (
-  IN EFI_HANDLE         ImageHandle,
-  IN EFI_SYSTEM_TABLE   *SystemTable
-  )
-{
-  EFI_STATUS  Status;
-  
-  gNandFlashInfo = (NAND_FLASH_INFO *)AllocateZeroPool (sizeof(NAND_FLASH_INFO));
-
-  //Initialize GPMC module.
-  GpmcInit();
-
-  //Reset NAND part
-  NandFlashReset(&BlockIo, FALSE);
-
-  //Detect NAND part and populate gNandFlashInfo structure
-  Status = NandDetectPart ();
-  if (EFI_ERROR(Status)) {
-    DEBUG((EFI_D_ERROR, "Nand part id detection failure: Status: %x\n", Status));
-    return Status;
-  }
-
-  //Count total number of 512Bytes chunk based on the page size.
-  if (gNandFlashInfo->PageSize == PAGE_SIZE_512B) {
-    gNum512BytesChunks = 1;
-  } else if (gNandFlashInfo->PageSize == PAGE_SIZE_2K) {
-    gNum512BytesChunks = 4;
-  } else if (gNandFlashInfo->PageSize == PAGE_SIZE_4K) {
-    gNum512BytesChunks = 8;
-  }
-
-  gEccCode = (UINT8 *)AllocatePool(gNum512BytesChunks * 3);
-  if (gEccCode == NULL) {
-    return EFI_OUT_OF_RESOURCES;
-  }
-
-  //Configure ECC
-  NandConfigureEcc ();
-
-  //Patch EFI_BLOCK_IO_MEDIA structure.
-  gNandFlashMedia.BlockSize = gNandFlashInfo->BlockSize;
-  gNandFlashMedia.LastBlock = LAST_BLOCK;
-
-  //Publish BlockIO.
-  Status = gBS->InstallMultipleProtocolInterfaces (
-                  &ImageHandle, 
-                  &gEfiBlockIoProtocolGuid, &BlockIo,
-                  &gEfiDevicePathProtocolGuid, &gDevicePath, 
-                  NULL
-                  );
-  return Status;
-}
-
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include "Flash.h"

+

+NAND_PART_INFO_TABLE gNandPartInfoTable[1] = {

+  { 0x2C, 0xBA, 17, 11 }

+};

+

+NAND_FLASH_INFO *gNandFlashInfo = NULL;

+UINT8           *gEccCode;

+UINTN           gNum512BytesChunks = 0;

+

+//

+

+// Device path for SemiHosting. It contains our autogened Caller ID GUID.

+

+//

+

+typedef struct {

+

+  VENDOR_DEVICE_PATH        Guid;

+

+  EFI_DEVICE_PATH_PROTOCOL  End;

+

+} FLASH_DEVICE_PATH;

+

+

+

+FLASH_DEVICE_PATH gDevicePath = {

+

+  {

+

+    { HARDWARE_DEVICE_PATH, HW_VENDOR_DP, sizeof (VENDOR_DEVICE_PATH), 0 },

+

+    EFI_CALLER_ID_GUID

+

+  },

+

+  { END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE, sizeof (EFI_DEVICE_PATH_PROTOCOL), 0}

+

+};

+

+

+

+//Actual page address = Column address + Page address + Block address.

+UINTN

+GetActualPageAddressInBytes (

+  UINTN BlockIndex,

+  UINTN PageIndex

+)

+{

+  //BlockAddressStart = Start of the Block address in actual NAND

+  //PageAddressStart = Start of the Page address in actual NAND

+  return ((BlockIndex << gNandFlashInfo->BlockAddressStart) + (PageIndex << gNandFlashInfo->PageAddressStart));

+}

+

+VOID

+NandSendCommand (

+  UINT8 Command

+)

+{

+  MmioWrite16(GPMC_NAND_COMMAND_0, Command);

+}

+

+VOID

+NandSendAddress (

+  UINT8 Address

+)

+{

+  MmioWrite16(GPMC_NAND_ADDRESS_0, Address);

+}

+

+UINT16

+NandReadStatus (

+  VOID

+  )

+{

+  //Send READ STATUS command

+  NandSendCommand(READ_STATUS_CMD);

+

+  //Read status.

+  return MmioRead16(GPMC_NAND_DATA_0);

+}

+

+VOID

+NandSendAddressCycles (

+  UINTN Address

+)

+{

+  //Column address

+  NandSendAddress(Address & 0xff);

+  Address >>= 8;

+

+  //Column address

+  NandSendAddress(Address & 0x07);

+  Address >>= 3;

+

+  //Page and Block address

+  NandSendAddress(Address & 0xff);

+  Address >>= 8;

+

+  //Block address

+  NandSendAddress(Address & 0xff);

+  Address >>= 8;

+

+  //Block address

+  NandSendAddress(Address & 0x01);

+}

+

+VOID

+GpmcInit (

+  VOID

+  )

+{

+  //Enable Smart-idle mode.

+  MmioWrite32 (GPMC_SYSCONFIG, SMARTIDLEMODE);

+

+  //Set IRQSTATUS and IRQENABLE to the reset value

+  MmioWrite32 (GPMC_IRQSTATUS, 0x0);

+  MmioWrite32 (GPMC_IRQENABLE, 0x0);

+

+  //Disable GPMC timeout control.

+  MmioWrite32 (GPMC_TIMEOUT_CONTROL, TIMEOUTDISABLE);

+

+  //Set WRITEPROTECT bit to enable write access.

+  MmioWrite32 (GPMC_CONFIG, WRITEPROTECT_HIGH);

+

+  //NOTE: Following GPMC_CONFIGi_0 register settings are taken from u-boot memory dump.

+  MmioWrite32 (GPMC_CONFIG1_0, DEVICETYPE_NAND | DEVICESIZE_X16);

+  MmioWrite32 (GPMC_CONFIG2_0, CSRDOFFTIME | CSWROFFTIME);

+  MmioWrite32 (GPMC_CONFIG3_0, ADVRDOFFTIME | ADVWROFFTIME);

+  MmioWrite32 (GPMC_CONFIG4_0, OEONTIME | OEOFFTIME | WEONTIME | WEOFFTIME);

+  MmioWrite32 (GPMC_CONFIG5_0, RDCYCLETIME | WRCYCLETIME | RDACCESSTIME | PAGEBURSTACCESSTIME);

+  MmioWrite32 (GPMC_CONFIG6_0, WRACCESSTIME | WRDATAONADMUXBUS | CYCLE2CYCLEDELAY | CYCLE2CYCLESAMECSEN);

+  MmioWrite32 (GPMC_CONFIG7_0, MASKADDRESS_128MB | CSVALID | BASEADDRESS);

+}

+

+EFI_STATUS

+NandDetectPart (

+  VOID

+)

+{

+  UINT8      NandInfo = 0;

+  UINT8      PartInfo[5];

+  UINTN      Index;

+  BOOLEAN    Found = FALSE;

+

+  //Send READ ID command

+  NandSendCommand(READ_ID_CMD);

+

+  //Send one address cycle.

+  NandSendAddress(0);

+

+  //Read 5-bytes to idenfity code programmed into the NAND flash devices.

+  //BYTE 0 = Manufacture ID

+  //Byte 1 = Device ID

+  //Byte 2, 3, 4 = Nand part specific information (Page size, Block size etc)

+  for (Index = 0; Index < sizeof(PartInfo); Index++) {

+    PartInfo[Index] = MmioRead16(GPMC_NAND_DATA_0);

+  }

+

+  //Check if the ManufactureId and DeviceId are part of the currently supported nand parts.

+  for (Index = 0; Index < sizeof(gNandPartInfoTable)/sizeof(NAND_PART_INFO_TABLE); Index++) {

+    if (gNandPartInfoTable[Index].ManufactureId == PartInfo[0] && gNandPartInfoTable[Index].DeviceId == PartInfo[1]) {

+      gNandFlashInfo->BlockAddressStart = gNandPartInfoTable[Index].BlockAddressStart;

+      gNandFlashInfo->PageAddressStart = gNandPartInfoTable[Index].PageAddressStart;

+      Found = TRUE;

+      break;

+    }

+  }

+

+  if (Found == FALSE) {

+    DEBUG ((EFI_D_ERROR, "Nand part is not currently supported. Manufacture id: %x, Device id: %x\n", PartInfo[0], PartInfo[1]));

+    return EFI_NOT_FOUND;

+  }

+

+  //Populate NAND_FLASH_INFO based on the result of READ ID command.

+  gNandFlashInfo->ManufactureId = PartInfo[0];

+  gNandFlashInfo->DeviceId = PartInfo[1];

+  NandInfo = PartInfo[3];

+

+  if (PAGE_SIZE(NandInfo) == PAGE_SIZE_2K_VAL) {

+    gNandFlashInfo->PageSize = PAGE_SIZE_2K;

+  } else {

+    DEBUG ((EFI_D_ERROR, "Unknown Page size.\n"));

+    return EFI_DEVICE_ERROR;

+  }

+

+  if (SPARE_AREA_SIZE(NandInfo) == SPARE_AREA_SIZE_64B_VAL) {

+    gNandFlashInfo->SparePageSize = SPARE_AREA_SIZE_64B;

+  } else {

+    DEBUG ((EFI_D_ERROR, "Unknown Spare area size.\n"));

+    return EFI_DEVICE_ERROR;

+  }

+

+  if (BLOCK_SIZE(NandInfo) == BLOCK_SIZE_128K_VAL) {

+    gNandFlashInfo->BlockSize = BLOCK_SIZE_128K;

+  } else {

+    DEBUG ((EFI_D_ERROR, "Unknown Block size.\n"));

+    return EFI_DEVICE_ERROR;

+  }

+

+  if (ORGANIZATION(NandInfo) == ORGANIZATION_X8) {

+    gNandFlashInfo->Organization = 0;

+  } else if (ORGANIZATION(NandInfo) == ORGANIZATION_X16) {

+    gNandFlashInfo->Organization = 1;

+  }

+

+  //Calculate total number of blocks.

+  gNandFlashInfo->NumPagesPerBlock = DivU64x32(gNandFlashInfo->BlockSize, gNandFlashInfo->PageSize);

+

+  return EFI_SUCCESS;

+}

+

+VOID

+NandConfigureEcc (

+  VOID

+  )

+{

+  //Define ECC size 0 and size 1 to 512 bytes

+  MmioWrite32 (GPMC_ECC_SIZE_CONFIG, (ECCSIZE0_512BYTES | ECCSIZE1_512BYTES));

+}

+

+VOID 

+NandEnableEcc (

+  VOID

+  )

+{

+  //Clear all the ECC result registers and select ECC result register 1

+  MmioWrite32 (GPMC_ECC_CONTROL, (ECCCLEAR | ECCPOINTER_REG1));

+

+  //Enable ECC engine on CS0

+  MmioWrite32 (GPMC_ECC_CONFIG, (ECCENABLE | ECCCS_0 | ECC16B));

+}

+

+VOID

+NandDisableEcc (

+  VOID

+  )

+{

+  //Turn off ECC engine.

+  MmioWrite32 (GPMC_ECC_CONFIG, ECCDISABLE);

+}

+

+VOID

+NandCalculateEcc (

+  VOID

+  )

+{

+  UINTN Index;

+  UINTN EccResultRegister;

+  UINTN EccResult;

+

+  //Capture 32-bit ECC result for each 512-bytes chunk.

+  //In our case PageSize is 2K so read ECC1-ECC4 result registers and

+  //generate total of 12-bytes of ECC code for the particular page.

+

+  EccResultRegister = GPMC_ECC1_RESULT;

+

+  for (Index = 0; Index < gNum512BytesChunks; Index++) {

+

+    EccResult = MmioRead32 (EccResultRegister);

+

+    //Calculate ECC code from 32-bit ECC result value.

+    //NOTE: Following calculation is not part of TRM. We got this information 

+    //from Beagleboard mailing list.

+    gEccCode[Index * 3] = EccResult & 0xFF;

+    gEccCode[(Index * 3) + 1] = (EccResult >> 16) & 0xFF;

+    gEccCode[(Index * 3) + 2] = (((EccResult >> 20) & 0xF0) | ((EccResult >> 8) & 0x0F));

+

+    //Point to next ECC result register.

+    EccResultRegister += 4;

+  }

+}

+

+EFI_STATUS

+NandReadPage (

+  IN  UINTN                         BlockIndex,

+  IN  UINTN                         PageIndex,

+  OUT VOID                          *Buffer,

+  OUT UINT8                         *SpareBuffer

+)

+{

+  UINTN      Address;

+  UINTN      Index;

+  UINTN      NumMainAreaWords = (gNandFlashInfo->PageSize/2);

+  UINTN      NumSpareAreaWords = (gNandFlashInfo->SparePageSize/2);

+  UINT16     *MainAreaWordBuffer = Buffer;

+  UINT16     *SpareAreaWordBuffer = (UINT16 *)SpareBuffer;

+  UINTN      Timeout = MAX_RETRY_COUNT;

+

+  //Generate device address in bytes to access specific block and page index

+  Address = GetActualPageAddressInBytes(BlockIndex, PageIndex);

+

+  //Send READ command

+  NandSendCommand(PAGE_READ_CMD);

+

+  //Send 5 Address cycles to access specific device address

+  NandSendAddressCycles(Address);

+

+  //Send READ CONFIRM command

+  NandSendCommand(PAGE_READ_CONFIRM_CMD);

+

+  //Poll till device is busy.

+  while (Timeout) {

+    if ((NandReadStatus() & NAND_READY) == NAND_READY) {

+      break;

+    }

+    Timeout--;

+  }

+

+  if (Timeout == 0) {

+    DEBUG ((EFI_D_ERROR, "Read page timed out.\n"));

+    return EFI_TIMEOUT;

+  }

+

+  //Reissue READ command

+  NandSendCommand(PAGE_READ_CMD);

+

+  //Enable ECC engine.

+  NandEnableEcc();

+

+  //Read data into the buffer.

+  for (Index = 0; Index < NumMainAreaWords; Index++) {

+    *MainAreaWordBuffer++ = MmioRead16(GPMC_NAND_DATA_0);

+  }

+

+  //Read spare area into the buffer.

+  for (Index = 0; Index < NumSpareAreaWords; Index++) {

+    *SpareAreaWordBuffer++ = MmioRead16(GPMC_NAND_DATA_0);

+  }

+

+  //Calculate ECC.

+  NandCalculateEcc();

+

+  //Turn off ECC engine.

+  NandDisableEcc();

+

+  //Perform ECC correction.

+  //Need to implement..

+

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+NandWritePage (

+  IN  UINTN                         BlockIndex,

+  IN  UINTN                         PageIndex,

+  OUT VOID                          *Buffer,

+  IN  UINT8                         *SpareBuffer

+)

+{

+  UINTN      Address;

+  UINT16     *MainAreaWordBuffer = Buffer;

+  UINT16     *SpareAreaWordBuffer = (UINT16 *)SpareBuffer;

+  UINTN      Index;

+  UINTN      NandStatus;

+  UINTN      Timeout = MAX_RETRY_COUNT;

+

+  //Generate device address in bytes to access specific block and page index

+  Address = GetActualPageAddressInBytes(BlockIndex, PageIndex);

+

+  //Send SERIAL DATA INPUT command

+  NandSendCommand(PROGRAM_PAGE_CMD);

+

+  //Send 5 Address cycles to access specific device address

+  NandSendAddressCycles(Address);

+

+  //Enable ECC engine.

+  NandEnableEcc();

+

+  //Data input from Buffer

+  for (Index = 0; Index < (gNandFlashInfo->PageSize/2); Index++) {

+    MmioWrite16(GPMC_NAND_DATA_0, *MainAreaWordBuffer++);

+

+    //After each write access, device has to wait to accept data.

+    //Currently we may not be programming proper timing parameters to 

+    //the GPMC_CONFIGi_0 registers and we would need to figure that out.

+    //Without following delay, page programming fails.

+    gBS->Stall(1);

+  }

+

+  //Calculate ECC.

+  NandCalculateEcc();

+

+  //Turn off ECC engine.

+  NandDisableEcc();

+

+  //Prepare Spare area buffer with ECC codes.

+  SetMem(SpareBuffer, gNandFlashInfo->SparePageSize, 0xFF);

+  CopyMem(&SpareBuffer[ECC_POSITION], gEccCode, gNum512BytesChunks * 3);

+

+  //Program spare area with calculated ECC.

+  for (Index = 0; Index < (gNandFlashInfo->SparePageSize/2); Index++) {

+    MmioWrite16(GPMC_NAND_DATA_0, *SpareAreaWordBuffer++);

+  }

+

+  //Send PROGRAM command

+  NandSendCommand(PROGRAM_PAGE_CONFIRM_CMD);

+

+  //Poll till device is busy.

+  NandStatus = 0;

+  while (Timeout) {

+    NandStatus = NandReadStatus();

+    if ((NandStatus & NAND_READY) == NAND_READY) {

+      break;

+    }

+    Timeout--;

+  }

+

+  if (Timeout == 0) {

+    DEBUG ((EFI_D_ERROR, "Program page timed out.\n"));

+    return EFI_TIMEOUT;

+  }

+

+  //Bit0 indicates Pass/Fail status

+  if (NandStatus & NAND_FAILURE) {

+    return EFI_DEVICE_ERROR;

+  }

+

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+NandEraseBlock (

+  IN UINTN BlockIndex

+)

+{

+  UINTN      Address;

+  UINTN      NandStatus;

+  UINTN      Timeout = MAX_RETRY_COUNT;

+

+  //Generate device address in bytes to access specific block and page index

+  Address = GetActualPageAddressInBytes(BlockIndex, 0);

+

+  //Send ERASE SETUP command

+  NandSendCommand(BLOCK_ERASE_CMD);

+

+  //Send 3 address cycles to device to access Page address and Block address

+  Address >>= 11; //Ignore column addresses

+

+  NandSendAddress(Address & 0xff);

+  Address >>= 8;

+

+  NandSendAddress(Address & 0xff);

+  Address >>= 8;

+

+  NandSendAddress(Address & 0xff);

+

+  //Send ERASE CONFIRM command

+  NandSendCommand(BLOCK_ERASE_CONFIRM_CMD);

+

+  //Poll till device is busy.

+  NandStatus = 0;

+  while (Timeout) {

+    NandStatus = NandReadStatus();

+    if ((NandStatus & NAND_READY) == NAND_READY) {

+      break;

+    }

+    Timeout--;

+    gBS->Stall(1);

+  }

+

+  if (Timeout == 0) {

+    DEBUG ((EFI_D_ERROR, "Erase block timed out for Block: %d.\n", BlockIndex));

+    return EFI_TIMEOUT;

+  }

+

+  //Bit0 indicates Pass/Fail status

+  if (NandStatus & NAND_FAILURE) {

+    return EFI_DEVICE_ERROR;

+  }

+

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+NandReadBlock (

+  IN UINTN                          StartBlockIndex,

+  IN UINTN                          EndBlockIndex,

+  OUT VOID                          *Buffer,

+  OUT VOID                          *SpareBuffer

+)

+{

+  UINTN      BlockIndex;

+  UINTN      PageIndex;

+  EFI_STATUS Status = EFI_SUCCESS;

+

+  for (BlockIndex = StartBlockIndex; BlockIndex <= EndBlockIndex; BlockIndex++) {

+    //For each block read number of pages

+    for (PageIndex = 0; PageIndex < gNandFlashInfo->NumPagesPerBlock; PageIndex++) {

+      Status = NandReadPage(BlockIndex, PageIndex, Buffer, SpareBuffer);

+      if (EFI_ERROR(Status)) {

+        return Status;

+      }

+      Buffer = ((UINT8 *)Buffer + gNandFlashInfo->PageSize);

+    }

+  }

+

+  return Status;

+}

+

+EFI_STATUS

+NandWriteBlock (

+  IN UINTN                          StartBlockIndex,

+  IN UINTN                          EndBlockIndex,

+  OUT VOID                          *Buffer,

+  OUT VOID                          *SpareBuffer

+  )

+{

+  UINTN      BlockIndex;

+  UINTN      PageIndex;

+  EFI_STATUS Status = EFI_SUCCESS;

+

+  for (BlockIndex = StartBlockIndex; BlockIndex <= EndBlockIndex; BlockIndex++) {

+    //Page programming.

+    for (PageIndex = 0; PageIndex < gNandFlashInfo->NumPagesPerBlock; PageIndex++) {

+      Status = NandWritePage(BlockIndex, PageIndex, Buffer, SpareBuffer);

+      if (EFI_ERROR(Status)) {

+        return Status;

+      }

+      Buffer = ((UINT8 *)Buffer + gNandFlashInfo->PageSize);

+    }

+  }

+

+  return Status;

+}

+

+EFI_STATUS

+EFIAPI

+NandFlashReset (

+  IN EFI_BLOCK_IO_PROTOCOL          *This,

+  IN BOOLEAN                        ExtendedVerification

+  )

+{

+  UINTN BusyStall = 50;                            // microSeconds

+  UINTN ResetBusyTimeout = (1000000 / BusyStall);  // 1 Second

+

+  //Send RESET command to device.

+  NandSendCommand(RESET_CMD);

+  

+  //Wait for 1ms before we check status register.

+  gBS->Stall(1000);

+

+  //Check BIT#5 & BIT#6 in Status register to make sure RESET is done.

+  while ((NandReadStatus() & NAND_RESET_STATUS) != NAND_RESET_STATUS) {

+

+    //In case of extended verification, wait for extended amount of time

+    //to make sure device is reset.

+    if (ExtendedVerification) {

+      if (ResetBusyTimeout == 0) {

+        return EFI_DEVICE_ERROR;

+      }

+

+      gBS->Stall(BusyStall);

+      ResetBusyTimeout--;

+    }

+  }

+  

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+EFIAPI

+NandFlashReadBlocks (

+  IN EFI_BLOCK_IO_PROTOCOL          *This,

+  IN UINT32                         MediaId,

+  IN EFI_LBA                        Lba,

+  IN UINTN                          BufferSize,

+  OUT VOID                          *Buffer

+  )

+{

+  UINTN      NumBlocks;

+  UINTN      EndBlockIndex;

+  EFI_STATUS Status;

+  UINT8      *SpareBuffer = NULL;

+

+  if (Buffer == NULL) {

+    Status = EFI_INVALID_PARAMETER;

+    goto exit;

+  }

+  

+  if (Lba > LAST_BLOCK) {

+    Status = EFI_INVALID_PARAMETER;

+    goto exit;

+  }

+  

+  if ((BufferSize % gNandFlashInfo->BlockSize) != 0) {

+    Status = EFI_BAD_BUFFER_SIZE;

+    goto exit;

+  }

+

+  NumBlocks = DivU64x32(BufferSize, gNandFlashInfo->BlockSize);

+  EndBlockIndex = ((UINTN)Lba + NumBlocks) - 1;

+

+  SpareBuffer = (UINT8 *)AllocatePool(gNandFlashInfo->SparePageSize);

+  if (SpareBuffer == NULL) {

+    Status = EFI_OUT_OF_RESOURCES;

+    goto exit;

+  }

+

+  //Read block

+  Status = NandReadBlock((UINTN)Lba, EndBlockIndex, Buffer, SpareBuffer);

+  if (EFI_ERROR(Status)) {

+    DEBUG((EFI_D_ERROR, "Read block fails: %x\n", Status));

+    goto exit;

+  }

+

+exit:

+  if (SpareBuffer != NULL) {

+    FreePool (SpareBuffer);

+  }

+

+  return Status;

+}

+

+EFI_STATUS

+EFIAPI

+NandFlashWriteBlocks (

+  IN EFI_BLOCK_IO_PROTOCOL          *This,

+  IN UINT32                         MediaId,

+  IN EFI_LBA                        Lba,

+  IN UINTN                          BufferSize,

+  IN VOID                           *Buffer

+  )

+{

+  UINTN      BlockIndex;

+  UINTN      NumBlocks;

+  UINTN      EndBlockIndex;

+  EFI_STATUS Status;

+  UINT8      *SpareBuffer = NULL;

+

+  if (Buffer == NULL) {

+    Status = EFI_INVALID_PARAMETER;

+    goto exit;

+  }

+  

+  if (Lba > LAST_BLOCK) {

+    Status = EFI_INVALID_PARAMETER;

+    goto exit;

+  }

+  

+  if ((BufferSize % gNandFlashInfo->BlockSize) != 0) {

+    Status = EFI_BAD_BUFFER_SIZE;

+    goto exit;

+  }

+

+  NumBlocks = DivU64x32(BufferSize, gNandFlashInfo->BlockSize);

+  EndBlockIndex = ((UINTN)Lba + NumBlocks) - 1;

+

+  SpareBuffer = (UINT8 *)AllocatePool(gNandFlashInfo->SparePageSize);

+  if (SpareBuffer == NULL) {

+    Status = EFI_OUT_OF_RESOURCES;

+    goto exit;

+  }

+

+  // Erase block

+  for (BlockIndex = (UINTN)Lba; BlockIndex <= EndBlockIndex; BlockIndex++) {

+    Status = NandEraseBlock(BlockIndex);

+    if (EFI_ERROR(Status)) {

+      DEBUG((EFI_D_ERROR, "Erase block failed. Status: %x\n", Status));

+      goto exit;

+    }

+  }

+  

+  // Program data

+  Status = NandWriteBlock((UINTN)Lba, EndBlockIndex, Buffer, SpareBuffer);

+  if (EFI_ERROR(Status)) {

+    DEBUG((EFI_D_ERROR, "Block write fails: %x\n", Status));

+    goto exit;

+  }

+

+exit:

+  if (SpareBuffer != NULL) {

+    FreePool (SpareBuffer);

+  }

+

+  return Status;

+}

+

+EFI_STATUS

+EFIAPI

+NandFlashFlushBlocks (

+  IN EFI_BLOCK_IO_PROTOCOL  *This

+  )

+{

+  return EFI_SUCCESS;

+}

+

+

+

+EFI_BLOCK_IO_MEDIA gNandFlashMedia = {

+  SIGNATURE_32('n','a','n','d'),            // MediaId

+  FALSE,                                    // RemovableMedia

+  TRUE,                                     // MediaPresent

+  FALSE,                                    // LogicalPartition

+  FALSE,                                    // ReadOnly

+  FALSE,                                    // WriteCaching

+  0,                                        // BlockSize

+  2,                                        // IoAlign

+  0,                                        // Pad

+  0                                         // LastBlock

+};

+

+EFI_BLOCK_IO_PROTOCOL BlockIo = 

+{

+  EFI_BLOCK_IO_INTERFACE_REVISION,  // Revision

+  &gNandFlashMedia,                  // *Media

+  NandFlashReset,                   // Reset

+  NandFlashReadBlocks,              // ReadBlocks

+  NandFlashWriteBlocks,             // WriteBlocks

+  NandFlashFlushBlocks              // FlushBlocks

+};

+

+EFI_STATUS

+NandFlashInitialize (

+  IN EFI_HANDLE         ImageHandle,

+  IN EFI_SYSTEM_TABLE   *SystemTable

+  )

+{

+  EFI_STATUS  Status;

+  

+  gNandFlashInfo = (NAND_FLASH_INFO *)AllocateZeroPool (sizeof(NAND_FLASH_INFO));

+

+  //Initialize GPMC module.

+  GpmcInit();

+

+  //Reset NAND part

+  NandFlashReset(&BlockIo, FALSE);

+

+  //Detect NAND part and populate gNandFlashInfo structure

+  Status = NandDetectPart ();

+  if (EFI_ERROR(Status)) {

+    DEBUG((EFI_D_ERROR, "Nand part id detection failure: Status: %x\n", Status));

+    return Status;

+  }

+

+  //Count total number of 512Bytes chunk based on the page size.

+  if (gNandFlashInfo->PageSize == PAGE_SIZE_512B) {

+    gNum512BytesChunks = 1;

+  } else if (gNandFlashInfo->PageSize == PAGE_SIZE_2K) {

+    gNum512BytesChunks = 4;

+  } else if (gNandFlashInfo->PageSize == PAGE_SIZE_4K) {

+    gNum512BytesChunks = 8;

+  }

+

+  gEccCode = (UINT8 *)AllocatePool(gNum512BytesChunks * 3);

+  if (gEccCode == NULL) {

+    return EFI_OUT_OF_RESOURCES;

+  }

+

+  //Configure ECC

+  NandConfigureEcc ();

+

+  //Patch EFI_BLOCK_IO_MEDIA structure.

+  gNandFlashMedia.BlockSize = gNandFlashInfo->BlockSize;

+  gNandFlashMedia.LastBlock = LAST_BLOCK;

+

+  //Publish BlockIO.

+  Status = gBS->InstallMultipleProtocolInterfaces (

+                  &ImageHandle, 

+                  &gEfiBlockIoProtocolGuid, &BlockIo,

+                  &gEfiDevicePathProtocolGuid, &gDevicePath, 

+                  NULL

+                  );

+  return Status;

+}

+

diff --git a/Omap35xxPkg/Flash/Flash.h b/Omap35xxPkg/Flash/Flash.h
index 9bfdba5d..46ec4db9 100644
--- a/Omap35xxPkg/Flash/Flash.h
+++ b/Omap35xxPkg/Flash/Flash.h
@@ -1,106 +1,106 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef FLASH_H
-#define FLASH_H
-
-#include <Uefi.h>
-
-#include <Library/BaseLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/MemoryAllocationLib.h>
-#include <Library/DebugLib.h>
-#include <Library/IoLib.h>
-#include <Library/PcdLib.h>
-#include <Library/UefiBootServicesTableLib.h>
-#include <Library/IoLib.h>
-
-#include <Protocol/BlockIo.h>
-#include <Protocol/Cpu.h>
-#include <Omap3530/Omap3530.h>
-
-#define PAGE_SIZE(x)             ((x) & 0x01)
-#define PAGE_SIZE_2K_VAL         (0x01UL)
-
-#define SPARE_AREA_SIZE(x)       (((x) >> 2) & 0x01)
-#define SPARE_AREA_SIZE_64B_VAL  (0x1UL)
-
-#define BLOCK_SIZE(x)            (((x) >> 4) & 0x01)
-#define BLOCK_SIZE_128K_VAL      (0x01UL)
-
-#define ORGANIZATION(x)          (((x) >> 6) & 0x01)
-#define ORGANIZATION_X8          (0x0UL)
-#define ORGANIZATION_X16         (0x1UL)
-
-#define PAGE_SIZE_512B           (512)
-#define PAGE_SIZE_2K             (2048)
-#define PAGE_SIZE_4K             (4096)
-#define SPARE_AREA_SIZE_16B      (16)
-#define SPARE_AREA_SIZE_64B      (64)
-
-#define BLOCK_SIZE_16K           (16*1024)
-#define BLOCK_SIZE_128K          (128*1024)
-
-#define BLOCK_COUNT              (2048)
-#define LAST_BLOCK               (BLOCK_COUNT - 1)
-
-#define ECC_POSITION             2
-
-//List of commands.
-#define RESET_CMD                0xFF
-#define READ_ID_CMD              0x90
-
-#define READ_STATUS_CMD          0x70
-
-#define PAGE_READ_CMD            0x00
-#define PAGE_READ_CONFIRM_CMD    0x30
-
-#define BLOCK_ERASE_CMD          0x60
-#define BLOCK_ERASE_CONFIRM_CMD  0xD0
-
-#define PROGRAM_PAGE_CMD         0x80
-#define PROGRAM_PAGE_CONFIRM_CMD 0x10
-
-//Nand status register bit definition
-#define NAND_SUCCESS             (0x0UL << 0)
-#define NAND_FAILURE             BIT0
-
-#define NAND_BUSY                (0x0UL << 6)
-#define NAND_READY               BIT6
-
-#define NAND_RESET_STATUS        (0x60UL << 0)
-
-#define MAX_RETRY_COUNT          1500
-
-
-typedef struct {
-  UINT8 ManufactureId;
-  UINT8 DeviceId;
-  UINT8 BlockAddressStart; //Start of the Block address in actual NAND
-  UINT8 PageAddressStart;  //Start of the Page address in actual NAND
-} NAND_PART_INFO_TABLE;
-
-typedef struct {
-  UINT8     ManufactureId;
-  UINT8     DeviceId;
-  UINT8     Organization;      //x8 or x16
-  UINT32    PageSize;
-  UINT32    SparePageSize;
-  UINT32    BlockSize;
-  UINT32    NumPagesPerBlock;
-  UINT8     BlockAddressStart; //Start of the Block address in actual NAND
-  UINT8     PageAddressStart;  //Start of the Page address in actual NAND
-} NAND_FLASH_INFO;
-
-#endif //FLASH_H
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef FLASH_H

+#define FLASH_H

+

+#include <Uefi.h>

+

+#include <Library/BaseLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/MemoryAllocationLib.h>

+#include <Library/DebugLib.h>

+#include <Library/IoLib.h>

+#include <Library/PcdLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/IoLib.h>

+

+#include <Protocol/BlockIo.h>

+#include <Protocol/Cpu.h>

+#include <Omap3530/Omap3530.h>

+

+#define PAGE_SIZE(x)             ((x) & 0x01)

+#define PAGE_SIZE_2K_VAL         (0x01UL)

+

+#define SPARE_AREA_SIZE(x)       (((x) >> 2) & 0x01)

+#define SPARE_AREA_SIZE_64B_VAL  (0x1UL)

+

+#define BLOCK_SIZE(x)            (((x) >> 4) & 0x01)

+#define BLOCK_SIZE_128K_VAL      (0x01UL)

+

+#define ORGANIZATION(x)          (((x) >> 6) & 0x01)

+#define ORGANIZATION_X8          (0x0UL)

+#define ORGANIZATION_X16         (0x1UL)

+

+#define PAGE_SIZE_512B           (512)

+#define PAGE_SIZE_2K             (2048)

+#define PAGE_SIZE_4K             (4096)

+#define SPARE_AREA_SIZE_16B      (16)

+#define SPARE_AREA_SIZE_64B      (64)

+

+#define BLOCK_SIZE_16K           (16*1024)

+#define BLOCK_SIZE_128K          (128*1024)

+

+#define BLOCK_COUNT              (2048)

+#define LAST_BLOCK               (BLOCK_COUNT - 1)

+

+#define ECC_POSITION             2

+

+//List of commands.

+#define RESET_CMD                0xFF

+#define READ_ID_CMD              0x90

+

+#define READ_STATUS_CMD          0x70

+

+#define PAGE_READ_CMD            0x00

+#define PAGE_READ_CONFIRM_CMD    0x30

+

+#define BLOCK_ERASE_CMD          0x60

+#define BLOCK_ERASE_CONFIRM_CMD  0xD0

+

+#define PROGRAM_PAGE_CMD         0x80

+#define PROGRAM_PAGE_CONFIRM_CMD 0x10

+

+//Nand status register bit definition

+#define NAND_SUCCESS             (0x0UL << 0)

+#define NAND_FAILURE             BIT0

+

+#define NAND_BUSY                (0x0UL << 6)

+#define NAND_READY               BIT6

+

+#define NAND_RESET_STATUS        (0x60UL << 0)

+

+#define MAX_RETRY_COUNT          1500

+

+

+typedef struct {

+  UINT8 ManufactureId;

+  UINT8 DeviceId;

+  UINT8 BlockAddressStart; //Start of the Block address in actual NAND

+  UINT8 PageAddressStart;  //Start of the Page address in actual NAND

+} NAND_PART_INFO_TABLE;

+

+typedef struct {

+  UINT8     ManufactureId;

+  UINT8     DeviceId;

+  UINT8     Organization;      //x8 or x16

+  UINT32    PageSize;

+  UINT32    SparePageSize;

+  UINT32    BlockSize;

+  UINT32    NumPagesPerBlock;

+  UINT8     BlockAddressStart; //Start of the Block address in actual NAND

+  UINT8     PageAddressStart;  //Start of the Page address in actual NAND

+} NAND_FLASH_INFO;

+

+#endif //FLASH_H

diff --git a/Omap35xxPkg/Flash/Flash.inf b/Omap35xxPkg/Flash/Flash.inf
index 1dfd5bcf..4f12a274 100644
--- a/Omap35xxPkg/Flash/Flash.inf
+++ b/Omap35xxPkg/Flash/Flash.inf
@@ -1,48 +1,48 @@
-#/** @file
-#  
-#  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = NandFlash
-  FILE_GUID                      = 4d00ef14-c4e0-426b-81b7-30a00a14aad6
-  MODULE_TYPE                    = DXE_DRIVER
-  VERSION_STRING                 = 1.0
-
-  ENTRY_POINT                    = NandFlashInitialize
-
-
-[Sources.common]
-  Flash.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  Omap35xxPkg/Omap35xxPkg.dec
-
-[LibraryClasses]
-  PcdLib
-  UefiLib
-  UefiDriverEntryPoint
-  MemoryAllocationLib
-  IoLib
-
-[Guids]
-  
-[Protocols]
-  gEfiBlockIoProtocolGuid
-  gEfiCpuArchProtocolGuid
-
-[Pcd]
-  gOmap35xxTokenSpaceGuid.PcdOmap35xxGpmcOffset
-
-[depex]
-  TRUE
\ No newline at end of file
+#/** @file

+#  

+#  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = NandFlash

+  FILE_GUID                      = 4d00ef14-c4e0-426b-81b7-30a00a14aad6

+  MODULE_TYPE                    = DXE_DRIVER

+  VERSION_STRING                 = 1.0

+

+  ENTRY_POINT                    = NandFlashInitialize

+

+

+[Sources.common]

+  Flash.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  Omap35xxPkg/Omap35xxPkg.dec

+

+[LibraryClasses]

+  PcdLib

+  UefiLib

+  UefiDriverEntryPoint

+  MemoryAllocationLib

+  IoLib

+

+[Guids]

+  

+[Protocols]

+  gEfiBlockIoProtocolGuid

+  gEfiCpuArchProtocolGuid

+

+[Pcd]

+  gOmap35xxTokenSpaceGuid.PcdOmap35xxGpmcOffset

+

+[depex]

+  TRUE
\ No newline at end of file
diff --git a/Omap35xxPkg/Gpio/Gpio.c b/Omap35xxPkg/Gpio/Gpio.c
index 33786aee..c64e6be7 100644
--- a/Omap35xxPkg/Gpio/Gpio.c
+++ b/Omap35xxPkg/Gpio/Gpio.c
@@ -1,135 +1,135 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include <Uefi.h>
-
-#include <Library/IoLib.h>
-#include <Library/OmapLib.h>
-#include <Library/UefiBootServicesTableLib.h>
-
-#include <Protocol/EmbeddedGpio.h>
-
-#include <Omap3530/Omap3530.h>
-
-EFI_STATUS
-Get (
-  IN  EMBEDDED_GPIO     *This,
-  IN  EMBEDDED_GPIO_PIN Gpio,
-  OUT UINTN               *Value
-  )
-{
-  UINTN  Port;
-  UINTN  Pin;
-  UINT32 DataInRegister;
-
-  if (Value == NULL)
-  {
-    return EFI_UNSUPPORTED;
-  }
-
-  Port    = GPIO_PORT(Gpio);
-  Pin     = GPIO_PIN(Gpio);
-
-  DataInRegister = GpioBase(Port) + GPIO_DATAIN;
-
-  if (MmioRead32 (DataInRegister) & GPIO_DATAIN_MASK(Pin)) {
-    *Value = 1;
-  } else {
-    *Value = 0;
-  }
-
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-Set (
-  IN  EMBEDDED_GPIO       *This,
-  IN  EMBEDDED_GPIO_PIN   Gpio,
-  IN  EMBEDDED_GPIO_MODE  Mode
-  )
-{
-  UINTN  Port;
-  UINTN  Pin;
-  UINT32 OutputEnableRegister;
-  UINT32 SetDataOutRegister;
-  UINT32 ClearDataOutRegister;
-
-  Port    = GPIO_PORT(Gpio);
-  Pin     = GPIO_PIN(Gpio);
-
-  OutputEnableRegister = GpioBase(Port) + GPIO_OE;
-  SetDataOutRegister   = GpioBase(Port) + GPIO_SETDATAOUT;
-  ClearDataOutRegister = GpioBase(Port) + GPIO_CLEARDATAOUT;
-
-  switch (Mode)
-  {
-    case GPIO_MODE_INPUT:
-      MmioAndThenOr32(OutputEnableRegister, ~GPIO_OE_MASK(Pin), GPIO_OE_INPUT(Pin));
-      break;
-
-    case GPIO_MODE_OUTPUT_0:
-      MmioWrite32 (ClearDataOutRegister, GPIO_CLEARDATAOUT_BIT(Pin));
-      MmioAndThenOr32(OutputEnableRegister, ~GPIO_OE_MASK(Pin), GPIO_OE_OUTPUT(Pin));
-      break;
-
-    case GPIO_MODE_OUTPUT_1:
-      MmioWrite32 (SetDataOutRegister, GPIO_SETDATAOUT_BIT(Pin));
-      MmioAndThenOr32(OutputEnableRegister, ~GPIO_OE_MASK(Pin), GPIO_OE_OUTPUT(Pin));
-      break;
-
-    default:
-      return EFI_UNSUPPORTED;
-  }
-
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-GetMode (
-  IN  EMBEDDED_GPIO       *This,
-  IN  EMBEDDED_GPIO_PIN   Gpio,
-  OUT EMBEDDED_GPIO_MODE  *Mode
-  )
-{
-  return EFI_UNSUPPORTED;
-}
-
-EFI_STATUS
-SetPull (
-  IN  EMBEDDED_GPIO       *This,
-  IN  EMBEDDED_GPIO_PIN   Gpio,
-  IN  EMBEDDED_GPIO_PULL  Direction
-  )
-{
-  return EFI_UNSUPPORTED;
-}
-
-EMBEDDED_GPIO Gpio = {
-  Get,
-  Set,
-  GetMode,
-  SetPull
-};
-
-EFI_STATUS
-GpioInitialize (
-  IN EFI_HANDLE         ImageHandle,
-  IN EFI_SYSTEM_TABLE   *SystemTable
-  )
-{
-  EFI_STATUS  Status;
-  
-  Status = gBS->InstallMultipleProtocolInterfaces(&ImageHandle, &gEmbeddedGpioProtocolGuid, &Gpio, NULL);
-  return Status;
-}
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include <Uefi.h>

+

+#include <Library/IoLib.h>

+#include <Library/OmapLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+

+#include <Protocol/EmbeddedGpio.h>

+

+#include <Omap3530/Omap3530.h>

+

+EFI_STATUS

+Get (

+  IN  EMBEDDED_GPIO     *This,

+  IN  EMBEDDED_GPIO_PIN Gpio,

+  OUT UINTN               *Value

+  )

+{

+  UINTN  Port;

+  UINTN  Pin;

+  UINT32 DataInRegister;

+

+  if (Value == NULL)

+  {

+    return EFI_UNSUPPORTED;

+  }

+

+  Port    = GPIO_PORT(Gpio);

+  Pin     = GPIO_PIN(Gpio);

+

+  DataInRegister = GpioBase(Port) + GPIO_DATAIN;

+

+  if (MmioRead32 (DataInRegister) & GPIO_DATAIN_MASK(Pin)) {

+    *Value = 1;

+  } else {

+    *Value = 0;

+  }

+

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+Set (

+  IN  EMBEDDED_GPIO       *This,

+  IN  EMBEDDED_GPIO_PIN   Gpio,

+  IN  EMBEDDED_GPIO_MODE  Mode

+  )

+{

+  UINTN  Port;

+  UINTN  Pin;

+  UINT32 OutputEnableRegister;

+  UINT32 SetDataOutRegister;

+  UINT32 ClearDataOutRegister;

+

+  Port    = GPIO_PORT(Gpio);

+  Pin     = GPIO_PIN(Gpio);

+

+  OutputEnableRegister = GpioBase(Port) + GPIO_OE;

+  SetDataOutRegister   = GpioBase(Port) + GPIO_SETDATAOUT;

+  ClearDataOutRegister = GpioBase(Port) + GPIO_CLEARDATAOUT;

+

+  switch (Mode)

+  {

+    case GPIO_MODE_INPUT:

+      MmioAndThenOr32(OutputEnableRegister, ~GPIO_OE_MASK(Pin), GPIO_OE_INPUT(Pin));

+      break;

+

+    case GPIO_MODE_OUTPUT_0:

+      MmioWrite32 (ClearDataOutRegister, GPIO_CLEARDATAOUT_BIT(Pin));

+      MmioAndThenOr32(OutputEnableRegister, ~GPIO_OE_MASK(Pin), GPIO_OE_OUTPUT(Pin));

+      break;

+

+    case GPIO_MODE_OUTPUT_1:

+      MmioWrite32 (SetDataOutRegister, GPIO_SETDATAOUT_BIT(Pin));

+      MmioAndThenOr32(OutputEnableRegister, ~GPIO_OE_MASK(Pin), GPIO_OE_OUTPUT(Pin));

+      break;

+

+    default:

+      return EFI_UNSUPPORTED;

+  }

+

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+GetMode (

+  IN  EMBEDDED_GPIO       *This,

+  IN  EMBEDDED_GPIO_PIN   Gpio,

+  OUT EMBEDDED_GPIO_MODE  *Mode

+  )

+{

+  return EFI_UNSUPPORTED;

+}

+

+EFI_STATUS

+SetPull (

+  IN  EMBEDDED_GPIO       *This,

+  IN  EMBEDDED_GPIO_PIN   Gpio,

+  IN  EMBEDDED_GPIO_PULL  Direction

+  )

+{

+  return EFI_UNSUPPORTED;

+}

+

+EMBEDDED_GPIO Gpio = {

+  Get,

+  Set,

+  GetMode,

+  SetPull

+};

+

+EFI_STATUS

+GpioInitialize (

+  IN EFI_HANDLE         ImageHandle,

+  IN EFI_SYSTEM_TABLE   *SystemTable

+  )

+{

+  EFI_STATUS  Status;

+  

+  Status = gBS->InstallMultipleProtocolInterfaces(&ImageHandle, &gEmbeddedGpioProtocolGuid, &Gpio, NULL);

+  return Status;

+}

diff --git a/Omap35xxPkg/Gpio/Gpio.inf b/Omap35xxPkg/Gpio/Gpio.inf
index c20346a4..2069d2d7 100644
--- a/Omap35xxPkg/Gpio/Gpio.inf
+++ b/Omap35xxPkg/Gpio/Gpio.inf
@@ -1,45 +1,45 @@
-#/** @file
-#  
-#  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = Gpio
-  FILE_GUID                      = E7D9CAE1-6930-46E3-BDF9-0027446E7DF2
-  MODULE_TYPE                    = DXE_DRIVER
-  VERSION_STRING                 = 1.0
-
-  ENTRY_POINT                    = GpioInitialize
-
-
-[Sources.common]
-  Gpio.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  EmbeddedPkg/EmbeddedPkg.dec
-  Omap35xxPkg/Omap35xxPkg.dec
-
-[LibraryClasses]
-  IoLib
-  UefiDriverEntryPoint
-  OmapLib
-
-[Guids]
-  
-[Protocols]
-  gEmbeddedGpioProtocolGuid
-
-[Pcd]
-
-[depex]
-  TRUE
\ No newline at end of file
+#/** @file

+#  

+#  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = Gpio

+  FILE_GUID                      = E7D9CAE1-6930-46E3-BDF9-0027446E7DF2

+  MODULE_TYPE                    = DXE_DRIVER

+  VERSION_STRING                 = 1.0

+

+  ENTRY_POINT                    = GpioInitialize

+

+

+[Sources.common]

+  Gpio.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  EmbeddedPkg/EmbeddedPkg.dec

+  Omap35xxPkg/Omap35xxPkg.dec

+

+[LibraryClasses]

+  IoLib

+  UefiDriverEntryPoint

+  OmapLib

+

+[Guids]

+  

+[Protocols]

+  gEmbeddedGpioProtocolGuid

+

+[Pcd]

+

+[depex]

+  TRUE
\ No newline at end of file
diff --git a/Omap35xxPkg/Include/Library/OmapDmaLib.h b/Omap35xxPkg/Include/Library/OmapDmaLib.h
index 0dc4468c..f13b7337 100755
--- a/Omap35xxPkg/Include/Library/OmapDmaLib.h
+++ b/Omap35xxPkg/Include/Library/OmapDmaLib.h
@@ -1,25 +1,25 @@
-/** @file
-
-  Abstractions for simple OMAP DMA. 
-  OMAP_DMA4 structure elements are described in the OMAP35xx TRM. 
-
-  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __OMAP_DMA_LIB_H__
-#define __OMAP_DMA_LIB_H__
-
-
-// Example from DMA chapter of the OMAP35xx spec
+/** @file

+

+  Abstractions for simple OMAP DMA. 

+  OMAP_DMA4 structure elements are described in the OMAP35xx TRM. 

+

+  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __OMAP_DMA_LIB_H__

+#define __OMAP_DMA_LIB_H__

+

+

+// Example from DMA chapter of the OMAP35xx spec

 typedef struct {

   UINT8     DataType;                      // DMA4_CSDPi[1:0]

   UINT8     ReadPortAccessType;            // DMA4_CSDPi[8:7]

@@ -42,10 +42,10 @@ typedef struct {
   UINT8     ReadPriority;                  // DMA4_CCRi[6]

   UINT8     WritePriority;                 // DMA4_CCRi[23]

   UINT8     ReadRequestNumber;             // DMA4_CCRi[4:0]

-  UINT8     WriteRequestNumber;            // DMA4_CCRi[20:19]
-} OMAP_DMA4;
-
-
+  UINT8     WriteRequestNumber;            // DMA4_CCRi[20:19]

+} OMAP_DMA4;

+

+

 /**                                                                 

   Configure OMAP DMA Channel

             

@@ -56,14 +56,14 @@ typedef struct {
   @retval EFI_INVALID_PARAMETER Channel is not valid

   @retval EFI_DEVICE_ERROR      The system hardware could not map the requested information.

                                    

-**/
-EFI_STATUS
-EFIAPI
-EnableDmaChannel (
-  IN  UINTN       Channel,
-  IN  OMAP_DMA4   *Dma4
-  );
-
+**/

+EFI_STATUS

+EFIAPI

+EnableDmaChannel (

+  IN  UINTN       Channel,

+  IN  OMAP_DMA4   *Dma4

+  );

+

 /**                                                                 

   Turn of DMA channel configured by EnableDma().

             

@@ -75,16 +75,16 @@ EnableDmaChannel (
   @retval EFI_INVALID_PARAMETER Channel is not valid

   @retval EFI_DEVICE_ERROR      The system hardware could not map the requested information.

                                    

-**/
-EFI_STATUS
-EFIAPI
-DisableDmaChannel (
-  IN  UINTN       Channel,
-  IN  UINT32      SuccessMask,
-  IN  UINT32      ErrorMask
-  );
-
-
-
-#endif 
-
+**/

+EFI_STATUS

+EFIAPI

+DisableDmaChannel (

+  IN  UINTN       Channel,

+  IN  UINT32      SuccessMask,

+  IN  UINT32      ErrorMask

+  );

+

+

+

+#endif 

+

diff --git a/Omap35xxPkg/Include/Library/OmapLib.h b/Omap35xxPkg/Include/Library/OmapLib.h
index 41922751..80e5e0d2 100644
--- a/Omap35xxPkg/Include/Library/OmapLib.h
+++ b/Omap35xxPkg/Include/Library/OmapLib.h
@@ -1,44 +1,44 @@
-/** @file
-
-  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __OMAPLIB_H__
-#define __OMAPLIB_H__
-
-UINT32 
-EFIAPI
-GpioBase (
-  IN  UINTN Port
-  );
-
-UINT32 
-EFIAPI
-TimerBase (
-  IN  UINTN Timer
-  );
-
-UINTN
-EFIAPI
-InterruptVectorForTimer (
-  IN  UINTN TImer
-  );
-
-UINT32
-EFIAPI
-UartBase (
-  IN  UINTN Uart
-  );
-
-
-#endif // __OMAPLIB_H__
-
+/** @file

+

+  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __OMAPLIB_H__

+#define __OMAPLIB_H__

+

+UINT32 

+EFIAPI

+GpioBase (

+  IN  UINTN Port

+  );

+

+UINT32 

+EFIAPI

+TimerBase (

+  IN  UINTN Timer

+  );

+

+UINTN

+EFIAPI

+InterruptVectorForTimer (

+  IN  UINTN TImer

+  );

+

+UINT32

+EFIAPI

+UartBase (

+  IN  UINTN Uart

+  );

+

+

+#endif // __OMAPLIB_H__

+

diff --git a/Omap35xxPkg/Include/Omap3530/Omap3530.h b/Omap35xxPkg/Include/Omap3530/Omap3530.h
index 1cf99eb0..4d378157 100644
--- a/Omap35xxPkg/Include/Omap3530/Omap3530.h
+++ b/Omap35xxPkg/Include/Omap3530/Omap3530.h
@@ -1,40 +1,40 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __OMAP3530_H__
-#define __OMAP3530_H__
-
-#include "Omap3530Gpio.h"
-#include "Omap3530Interrupt.h"
-#include "Omap3530Prcm.h"
-#include "Omap3530Timer.h"
-#include "Omap3530Uart.h"
-#include "Omap3530Usb.h"
-#include "Omap3530MMCHS.h"
-#include "Omap3530I2c.h"
-#include "Omap3530PadConfiguration.h"
-#include "Omap3530Gpmc.h"
-#include "Omap3530Dma.h"
-
-
-//CONTROL_PBIAS_LITE
-#define CONTROL_PBIAS_LITE    0x48002520
-#define PBIASLITEVMODE0       BIT0
-#define PBIASLITEPWRDNZ0      BIT1
-#define PBIASSPEEDCTRL0       BIT2
-#define PBIASLITEVMODE1       BIT8
-#define PBIASLITEWRDNZ1       BIT9
-
-#endif // __OMAP3530_H__
-
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __OMAP3530_H__

+#define __OMAP3530_H__

+

+#include "Omap3530Gpio.h"

+#include "Omap3530Interrupt.h"

+#include "Omap3530Prcm.h"

+#include "Omap3530Timer.h"

+#include "Omap3530Uart.h"

+#include "Omap3530Usb.h"

+#include "Omap3530MMCHS.h"

+#include "Omap3530I2c.h"

+#include "Omap3530PadConfiguration.h"

+#include "Omap3530Gpmc.h"

+#include "Omap3530Dma.h"

+

+

+//CONTROL_PBIAS_LITE

+#define CONTROL_PBIAS_LITE    0x48002520

+#define PBIASLITEVMODE0       BIT0

+#define PBIASLITEPWRDNZ0      BIT1

+#define PBIASSPEEDCTRL0       BIT2

+#define PBIASLITEVMODE1       BIT8

+#define PBIASLITEWRDNZ1       BIT9

+

+#endif // __OMAP3530_H__

+

diff --git a/Omap35xxPkg/Include/Omap3530/Omap3530Dma.h b/Omap35xxPkg/Include/Omap3530/Omap3530Dma.h
index 242c3253..5db9a079 100755
--- a/Omap35xxPkg/Include/Omap3530/Omap3530Dma.h
+++ b/Omap35xxPkg/Include/Omap3530/Omap3530Dma.h
@@ -1,130 +1,130 @@
-/** @file
-
-  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __OMAP3530DMA_H__
-#define __OMAP3530DMA_H__
-
-
-#define DMA4_MAX_CHANNEL 31
-
-#define DMA4_IRQENABLE_L(_i)  (0x48056018 + (0x4*(_i)))
-
-#define DMA4_CCR(_i)  (0x48056080 + (0x60*(_i)))
-#define DMA4_CICR(_i) (0x48056088 + (0x60*(_i)))
-#define DMA4_CSR(_i)  (0x4805608c + (0x60*(_i)))
-#define DMA4_CSDP(_i) (0x48056090 + (0x60*(_i)))
-#define DMA4_CEN(_i)  (0x48056094 + (0x60*(_i)))
-#define DMA4_CFN(_i)  (0x48056098 + (0x60*(_i)))
-#define DMA4_CSSA(_i) (0x4805609c + (0x60*(_i)))
-#define DMA4_CDSA(_i) (0x480560a0 + (0x60*(_i)))
-#define DMA4_CSEI(_i) (0x480560a4 + (0x60*(_i)))
-#define DMA4_CSFI(_i) (0x480560a8 + (0x60*(_i)))
-#define DMA4_CDEI(_i) (0x480560ac + (0x60*(_i)))
-#define DMA4_CDFI(_i) (0x480560b0 + (0x60*(_i)))
-
-#define DMA4_GCR      (0x48056078)
-
-// Channel Source Destination parameters
-#define DMA4_CSDP_DATA_TYPE8    0
-#define DMA4_CSDP_DATA_TYPE16   1
-#define DMA4_CSDP_DATA_TYPE32   2
-
-#define DMA4_CSDP_SRC_PACKED      BIT6
-#define DMA4_CSDP_SRC_NONPACKED   0
-
-#define DMA4_CSDP_SRC_BURST_EN    (0x0 << 7)
-#define DMA4_CSDP_SRC_BURST_EN16  (0x1 << 7)
-#define DMA4_CSDP_SRC_BURST_EN32  (0x2 << 7)
-#define DMA4_CSDP_SRC_BURST_EN64  (0x3 << 7)
-
-#define DMA4_CSDP_DST_PACKED      BIT13
-#define DMA4_CSDP_DST_NONPACKED   0
-
-#define DMA4_CSDP_BURST_EN        (0x0 << 14)
-#define DMA4_CSDP_BURST_EN16      (0x1 << 14)
-#define DMA4_CSDP_BURST_EN32      (0x2 << 14)
-#define DMA4_CSDP_BURST_EN64      (0x3 << 14)
-
-#define DMA4_CSDP_WRITE_MODE_NONE_POSTED      (0x0 << 16)  
-#define DMA4_CSDP_WRITE_MODE_POSTED           (0x1 << 16)
-#define DMA4_CSDP_WRITE_MODE_LAST_NON_POSTED  (0x2 << 16)  
-
-#define DMA4_CSDP_DST_ENDIAN_LOCK_LOCK    BIT18
-#define DMA4_CSDP_DST_ENDIAN_LOCK_ADAPT   0
-
-#define DMA4_CSDP_DST_ENDIAN_BIG          BIT19
-#define DMA4_CSDP_DST_ENDIAN_LITTLE       0
-
-#define DMA4_CSDP_SRC_ENDIAN_LOCK_LOCK    BIT20
-#define DMA4_CSDP_SRC_ENDIAN_LOCK_ADAPT   0
-
-#define DMA4_CSDP_SRC_ENDIAN_BIG          BIT21
-#define DMA4_CSDP_SRC_ENDIAN_LITTLE       0
-
-// Channel Control 
-#define DMA4_CCR_SYNCHRO_CONTROL_MASK     0x1f
-
-#define DMA4_CCR_FS_ELEMENT     (0    | 0)
-#define DMA4_CCR_FS_BLOCK       (0    | BIT18)
-#define DMA4_CCR_FS_FRAME       (BIT5 | 0)
-#define DMA4_CCR_FS_PACKET      (BIT5 | BIT18)
-
-#define DMA4_CCR_READ_PRIORITY_HIGH   BIT6
-#define DMA4_CCR_READ_PRIORITY_LOW    0
-
-#define DMA4_CCR_ENABLE               BIT7
-#define DMA4_CCR_DISABLE              0
-
-#define DMA4_CCR_SUSPEND_SENSITIVE_IGNORE BIT8
-#define DMA4_CCR_SUSPEND_SENSITIVE        0
-
-#define DMA4_CCR_RD_ACTIVE                BIT9
-#define DMA4_CCR_WR_ACTIVE                BIT10
-
-#define DMA4_CCR_SRC_AMODE                (0     | 0)
-#define DMA4_CCR_SRC_AMODE_POST_INC       (0     | BIT12)
-#define DMA4_CCR_SRC_AMODE_SINGLE_INDEX   (BIT13 | 0)
-#define DMA4_CCR_SRC_AMODE_DOUBLE_INDEX   (BIT13 | BIT12)
-
-#define DMA4_CCR_DST_AMODE                (0     | 0)
-#define DMA4_CCR_DST_AMODE_POST_INC       (0     | BIT14)
-#define DMA4_CCR_DST_AMODE_SINGLE_INDEX   (BIT15 | 0)
-#define DMA4_CCR_DST_AMODE_DOUBLE_INDEX   (BIT15 | BIT14)
-
-#define DMA4_CCR_CONST_FILL_ENABLE        BIT16
-#define DMA4_CCR_TRANSPARENT_COPY_ENABLE  BIT17
-  
-#define DMA4_CCR_SEL_SRC_DEST_SYNC_SOURCE BIT24
-
-#define DMA4_CSR_DROP                     BIT1
-#define DMA4_CSR_HALF                     BIT2
-#define DMA4_CSR_FRAME                    BIT3
-#define DMA4_CSR_LAST                     BIT4
-#define DMA4_CSR_BLOCK                    BIT5
-#define DMA4_CSR_SYNC                     BIT6
-#define DMA4_CSR_PKT                      BIT7
-#define DMA4_CSR_TRANS_ERR                BIT8
-#define DMA4_CSR_SECURE_ERR               BIT9
-#define DMA4_CSR_SUPERVISOR_ERR           BIT10
-#define DMA4_CSR_MISALIGNED_ADRS_ERR      BIT11
-#define DMA4_CSR_DRAIN_END                BIT12
-#define DMA4_CSR_RESET                    0x1FE
-#define DMA4_CSR_ERR                      (DMA4_CSR_TRANS_ERR | DMA4_CSR_SECURE_ERR | DMA4_CSR_SUPERVISOR_ERR | DMA4_CSR_MISALIGNED_ADRS_ERR)
-
-// same mapping as CSR except for SYNC. Enable all since we are polling
-#define DMA4_CICR_ENABLE_ALL              0x1FBE
-
-
-#endif 
-
+/** @file

+

+  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __OMAP3530DMA_H__

+#define __OMAP3530DMA_H__

+

+

+#define DMA4_MAX_CHANNEL 31

+

+#define DMA4_IRQENABLE_L(_i)  (0x48056018 + (0x4*(_i)))

+

+#define DMA4_CCR(_i)  (0x48056080 + (0x60*(_i)))

+#define DMA4_CICR(_i) (0x48056088 + (0x60*(_i)))

+#define DMA4_CSR(_i)  (0x4805608c + (0x60*(_i)))

+#define DMA4_CSDP(_i) (0x48056090 + (0x60*(_i)))

+#define DMA4_CEN(_i)  (0x48056094 + (0x60*(_i)))

+#define DMA4_CFN(_i)  (0x48056098 + (0x60*(_i)))

+#define DMA4_CSSA(_i) (0x4805609c + (0x60*(_i)))

+#define DMA4_CDSA(_i) (0x480560a0 + (0x60*(_i)))

+#define DMA4_CSEI(_i) (0x480560a4 + (0x60*(_i)))

+#define DMA4_CSFI(_i) (0x480560a8 + (0x60*(_i)))

+#define DMA4_CDEI(_i) (0x480560ac + (0x60*(_i)))

+#define DMA4_CDFI(_i) (0x480560b0 + (0x60*(_i)))

+

+#define DMA4_GCR      (0x48056078)

+

+// Channel Source Destination parameters

+#define DMA4_CSDP_DATA_TYPE8    0

+#define DMA4_CSDP_DATA_TYPE16   1

+#define DMA4_CSDP_DATA_TYPE32   2

+

+#define DMA4_CSDP_SRC_PACKED      BIT6

+#define DMA4_CSDP_SRC_NONPACKED   0

+

+#define DMA4_CSDP_SRC_BURST_EN    (0x0 << 7)

+#define DMA4_CSDP_SRC_BURST_EN16  (0x1 << 7)

+#define DMA4_CSDP_SRC_BURST_EN32  (0x2 << 7)

+#define DMA4_CSDP_SRC_BURST_EN64  (0x3 << 7)

+

+#define DMA4_CSDP_DST_PACKED      BIT13

+#define DMA4_CSDP_DST_NONPACKED   0

+

+#define DMA4_CSDP_BURST_EN        (0x0 << 14)

+#define DMA4_CSDP_BURST_EN16      (0x1 << 14)

+#define DMA4_CSDP_BURST_EN32      (0x2 << 14)

+#define DMA4_CSDP_BURST_EN64      (0x3 << 14)

+

+#define DMA4_CSDP_WRITE_MODE_NONE_POSTED      (0x0 << 16)  

+#define DMA4_CSDP_WRITE_MODE_POSTED           (0x1 << 16)

+#define DMA4_CSDP_WRITE_MODE_LAST_NON_POSTED  (0x2 << 16)  

+

+#define DMA4_CSDP_DST_ENDIAN_LOCK_LOCK    BIT18

+#define DMA4_CSDP_DST_ENDIAN_LOCK_ADAPT   0

+

+#define DMA4_CSDP_DST_ENDIAN_BIG          BIT19

+#define DMA4_CSDP_DST_ENDIAN_LITTLE       0

+

+#define DMA4_CSDP_SRC_ENDIAN_LOCK_LOCK    BIT20

+#define DMA4_CSDP_SRC_ENDIAN_LOCK_ADAPT   0

+

+#define DMA4_CSDP_SRC_ENDIAN_BIG          BIT21

+#define DMA4_CSDP_SRC_ENDIAN_LITTLE       0

+

+// Channel Control 

+#define DMA4_CCR_SYNCHRO_CONTROL_MASK     0x1f

+

+#define DMA4_CCR_FS_ELEMENT     (0    | 0)

+#define DMA4_CCR_FS_BLOCK       (0    | BIT18)

+#define DMA4_CCR_FS_FRAME       (BIT5 | 0)

+#define DMA4_CCR_FS_PACKET      (BIT5 | BIT18)

+

+#define DMA4_CCR_READ_PRIORITY_HIGH   BIT6

+#define DMA4_CCR_READ_PRIORITY_LOW    0

+

+#define DMA4_CCR_ENABLE               BIT7

+#define DMA4_CCR_DISABLE              0

+

+#define DMA4_CCR_SUSPEND_SENSITIVE_IGNORE BIT8

+#define DMA4_CCR_SUSPEND_SENSITIVE        0

+

+#define DMA4_CCR_RD_ACTIVE                BIT9

+#define DMA4_CCR_WR_ACTIVE                BIT10

+

+#define DMA4_CCR_SRC_AMODE                (0     | 0)

+#define DMA4_CCR_SRC_AMODE_POST_INC       (0     | BIT12)

+#define DMA4_CCR_SRC_AMODE_SINGLE_INDEX   (BIT13 | 0)

+#define DMA4_CCR_SRC_AMODE_DOUBLE_INDEX   (BIT13 | BIT12)

+

+#define DMA4_CCR_DST_AMODE                (0     | 0)

+#define DMA4_CCR_DST_AMODE_POST_INC       (0     | BIT14)

+#define DMA4_CCR_DST_AMODE_SINGLE_INDEX   (BIT15 | 0)

+#define DMA4_CCR_DST_AMODE_DOUBLE_INDEX   (BIT15 | BIT14)

+

+#define DMA4_CCR_CONST_FILL_ENABLE        BIT16

+#define DMA4_CCR_TRANSPARENT_COPY_ENABLE  BIT17

+  

+#define DMA4_CCR_SEL_SRC_DEST_SYNC_SOURCE BIT24

+

+#define DMA4_CSR_DROP                     BIT1

+#define DMA4_CSR_HALF                     BIT2

+#define DMA4_CSR_FRAME                    BIT3

+#define DMA4_CSR_LAST                     BIT4

+#define DMA4_CSR_BLOCK                    BIT5

+#define DMA4_CSR_SYNC                     BIT6

+#define DMA4_CSR_PKT                      BIT7

+#define DMA4_CSR_TRANS_ERR                BIT8

+#define DMA4_CSR_SECURE_ERR               BIT9

+#define DMA4_CSR_SUPERVISOR_ERR           BIT10

+#define DMA4_CSR_MISALIGNED_ADRS_ERR      BIT11

+#define DMA4_CSR_DRAIN_END                BIT12

+#define DMA4_CSR_RESET                    0x1FE

+#define DMA4_CSR_ERR                      (DMA4_CSR_TRANS_ERR | DMA4_CSR_SECURE_ERR | DMA4_CSR_SUPERVISOR_ERR | DMA4_CSR_MISALIGNED_ADRS_ERR)

+

+// same mapping as CSR except for SYNC. Enable all since we are polling

+#define DMA4_CICR_ENABLE_ALL              0x1FBE

+

+

+#endif 

+

diff --git a/Omap35xxPkg/Include/Omap3530/Omap3530Gpio.h b/Omap35xxPkg/Include/Omap3530/Omap3530Gpio.h
index 94822d45..e45a0f23 100644
--- a/Omap35xxPkg/Include/Omap3530/Omap3530Gpio.h
+++ b/Omap35xxPkg/Include/Omap3530/Omap3530Gpio.h
@@ -1,131 +1,131 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __OMAP3530GPIO_H__
-#define __OMAP3530GPIO_H__
-
-#define GPIO1_BASE (0x48310000)
-#define GPIO2_BASE (0x49050000)
-#define GPIO3_BASE (0x49052000)
-#define GPIO4_BASE (0x49054000)
-#define GPIO5_BASE (0x49056000)
-#define GPIO6_BASE (0x49058000)
-
-#define GPIO_SYSCONFIG        (0x0010)
-#define GPIO_SYSSTATUS        (0x0014)
-#define GPIO_IRQSTATUS1       (0x0018)
-#define GPIO_IRQENABLE1       (0x001C)
-#define GPIO_WAKEUPENABLE     (0x0020)
-#define GPIO_IRQSTATUS2       (0x0028)
-#define GPIO_IRQENABLE2       (0x002C)
-#define GPIO_CTRL             (0x0030)
-#define GPIO_OE               (0x0034)
-#define GPIO_DATAIN           (0x0038)
-#define GPIO_DATAOUT          (0x003C)
-#define GPIO_LEVELDETECT0     (0x0040)
-#define GPIO_LEVELDETECT1     (0x0044)
-#define GPIO_RISINGDETECT     (0x0048)
-#define GPIO_FALLINGDETECT    (0x004C)
-#define GPIO_DEBOUNCENABLE    (0x0050)
-#define GPIO_DEBOUNCINGTIME   (0x0054)
-#define GPIO_CLEARIRQENABLE1  (0x0060)
-#define GPIO_SETIRQENABLE1    (0x0064)
-#define GPIO_CLEARIRQENABLE2  (0x0070)
-#define GPIO_SETIRQENABLE2    (0x0074)
-#define GPIO_CLEARWKUENA      (0x0080)
-#define GPIO_SETWKUENA        (0x0084)
-#define GPIO_CLEARDATAOUT     (0x0090)
-#define GPIO_SETDATAOUT       (0x0094)
-
-#define GPIO_SYSCONFIG_IDLEMODE_MASK      (3UL << 3)
-#define GPIO_SYSCONFIG_IDLEMODE_FORCE     (0UL << 3)
-#define GPIO_SYSCONFIG_IDLEMODE_NONE      BIT3
-#define GPIO_SYSCONFIG_IDLEMODE_SMART     (2UL << 3)
-#define GPIO_SYSCONFIG_ENAWAKEUP_MASK     BIT2
-#define GPIO_SYSCONFIG_ENAWAKEUP_DISABLE  (0UL << 2)
-#define GPIO_SYSCONFIG_ENAWAKEUP_ENABLE   BIT2
-#define GPIO_SYSCONFIG_SOFTRESET_MASK     BIT1
-#define GPIO_SYSCONFIG_SOFTRESET_NORMAL   (0UL << 1)
-#define GPIO_SYSCONFIG_SOFTRESET_RESET    BIT1
-#define GPIO_SYSCONFIG_AUTOIDLE_MASK      BIT0
-#define GPIO_SYSCONFIG_AUTOIDLE_FREE_RUN  (0UL << 0)
-#define GPIO_SYSCONFIG_AUTOIDLE_ON        BIT0
-
-#define GPIO_SYSSTATUS_RESETDONE_MASK     BIT0
-#define GPIO_SYSSTATUS_RESETDONE_ONGOING  (0UL << 0)
-#define GPIO_SYSSTATUS_RESETDONE_COMPLETE BIT0
-
-#define GPIO_IRQSTATUS_MASK(x)            (1UL << (x))
-#define GPIO_IRQSTATUS_NOT_TRIGGERED(x)   (0UL << (x))
-#define GPIO_IRQSTATUS_TRIGGERED(x)       (1UL << (x))
-#define GPIO_IRQSTATUS_CLEAR(x)           (1UL << (x))
-
-#define GPIO_IRQENABLE_MASK(x)            (1UL << (x))
-#define GPIO_IRQENABLE_DISABLE(x)         (0UL << (x))
-#define GPIO_IRQENABLE_ENABLE(x)          (1UL << (x))
-
-#define GPIO_WAKEUPENABLE_MASK(x)         (1UL << (x))
-#define GPIO_WAKEUPENABLE_DISABLE(x)      (0UL << (x))
-#define GPIO_WAKEUPENABLE_ENABLE(x)       (1UL << (x))
-
-#define GPIO_CTRL_GATINGRATIO_MASK        (3UL << 1)
-#define GPIO_CTRL_GATINGRATIO_DIV_1       (0UL << 1)
-#define GPIO_CTRL_GATINGRATIO_DIV_2       BIT1
-#define GPIO_CTRL_GATINGRATIO_DIV_4       (2UL << 1)
-#define GPIO_CTRL_GATINGRATIO_DIV_8       (3UL << 1)
-#define GPIO_CTRL_DISABLEMODULE_MASK      BIT0
-#define GPIO_CTRL_DISABLEMODULE_ENABLE    (0UL << 0)
-#define GPIO_CTRL_DISABLEMODULE_DISABLE   BIT0
-
-#define GPIO_OE_MASK(x)                   (1UL << (x))
-#define GPIO_OE_OUTPUT(x)                 (0UL << (x))
-#define GPIO_OE_INPUT(x)                  (1UL << (x))
-
-#define GPIO_DATAIN_MASK(x)               (1UL << (x))
-
-#define GPIO_DATAOUT_MASK(x)              (1UL << (x))
-
-#define GPIO_LEVELDETECT_MASK(x)          (1UL << (x))
-#define GPIO_LEVELDETECT_DISABLE(x)       (0UL << (x))
-#define GPIO_LEVELDETECT_ENABLE(x)        (1UL << (x))
-
-#define GPIO_RISINGDETECT_MASK(x)         (1UL << (x))
-#define GPIO_RISINGDETECT_DISABLE(x)      (0UL << (x))
-#define GPIO_RISINGDETECT_ENABLE(x)       (1UL << (x))
-
-#define GPIO_FALLINGDETECT_MASK(x)        (1UL << (x))
-#define GPIO_FALLINGDETECT_DISABLE(x)     (0UL << (x))
-#define GPIO_FALLINGDETECT_ENABLE(x)      (1UL << (x))
-
-#define GPIO_DEBOUNCENABLE_MASK(x)        (1UL << (x))
-#define GPIO_DEBOUNCENABLE_DISABLE(x)     (0UL << (x))
-#define GPIO_DEBOUNCENABLE_ENABLE(x)      (1UL << (x))
-
-#define GPIO_DEBOUNCINGTIME_MASK          (0xFF)
-#define GPIO_DEBOUNCINGTIME_US(x)         ((((x) / 31) - 1) & GPIO_DEBOUNCINGTIME_MASK)
-
-#define GPIO_CLEARIRQENABLE_BIT(x)        (1UL << (x))
-
-#define GPIO_SETIRQENABLE_BIT(x)          (1UL << (x))
-
-#define GPIO_CLEARWKUENA_BIT(x)           (1UL << (x))
-
-#define GPIO_SETWKUENA_BIT(x)             (1UL << (x))
-
-#define GPIO_CLEARDATAOUT_BIT(x)          (1UL << (x))
-
-#define GPIO_SETDATAOUT_BIT(x)            (1UL << (x))
-
-#endif // __OMAP3530GPIO_H__
-
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __OMAP3530GPIO_H__

+#define __OMAP3530GPIO_H__

+

+#define GPIO1_BASE (0x48310000)

+#define GPIO2_BASE (0x49050000)

+#define GPIO3_BASE (0x49052000)

+#define GPIO4_BASE (0x49054000)

+#define GPIO5_BASE (0x49056000)

+#define GPIO6_BASE (0x49058000)

+

+#define GPIO_SYSCONFIG        (0x0010)

+#define GPIO_SYSSTATUS        (0x0014)

+#define GPIO_IRQSTATUS1       (0x0018)

+#define GPIO_IRQENABLE1       (0x001C)

+#define GPIO_WAKEUPENABLE     (0x0020)

+#define GPIO_IRQSTATUS2       (0x0028)

+#define GPIO_IRQENABLE2       (0x002C)

+#define GPIO_CTRL             (0x0030)

+#define GPIO_OE               (0x0034)

+#define GPIO_DATAIN           (0x0038)

+#define GPIO_DATAOUT          (0x003C)

+#define GPIO_LEVELDETECT0     (0x0040)

+#define GPIO_LEVELDETECT1     (0x0044)

+#define GPIO_RISINGDETECT     (0x0048)

+#define GPIO_FALLINGDETECT    (0x004C)

+#define GPIO_DEBOUNCENABLE    (0x0050)

+#define GPIO_DEBOUNCINGTIME   (0x0054)

+#define GPIO_CLEARIRQENABLE1  (0x0060)

+#define GPIO_SETIRQENABLE1    (0x0064)

+#define GPIO_CLEARIRQENABLE2  (0x0070)

+#define GPIO_SETIRQENABLE2    (0x0074)

+#define GPIO_CLEARWKUENA      (0x0080)

+#define GPIO_SETWKUENA        (0x0084)

+#define GPIO_CLEARDATAOUT     (0x0090)

+#define GPIO_SETDATAOUT       (0x0094)

+

+#define GPIO_SYSCONFIG_IDLEMODE_MASK      (3UL << 3)

+#define GPIO_SYSCONFIG_IDLEMODE_FORCE     (0UL << 3)

+#define GPIO_SYSCONFIG_IDLEMODE_NONE      BIT3

+#define GPIO_SYSCONFIG_IDLEMODE_SMART     (2UL << 3)

+#define GPIO_SYSCONFIG_ENAWAKEUP_MASK     BIT2

+#define GPIO_SYSCONFIG_ENAWAKEUP_DISABLE  (0UL << 2)

+#define GPIO_SYSCONFIG_ENAWAKEUP_ENABLE   BIT2

+#define GPIO_SYSCONFIG_SOFTRESET_MASK     BIT1

+#define GPIO_SYSCONFIG_SOFTRESET_NORMAL   (0UL << 1)

+#define GPIO_SYSCONFIG_SOFTRESET_RESET    BIT1

+#define GPIO_SYSCONFIG_AUTOIDLE_MASK      BIT0

+#define GPIO_SYSCONFIG_AUTOIDLE_FREE_RUN  (0UL << 0)

+#define GPIO_SYSCONFIG_AUTOIDLE_ON        BIT0

+

+#define GPIO_SYSSTATUS_RESETDONE_MASK     BIT0

+#define GPIO_SYSSTATUS_RESETDONE_ONGOING  (0UL << 0)

+#define GPIO_SYSSTATUS_RESETDONE_COMPLETE BIT0

+

+#define GPIO_IRQSTATUS_MASK(x)            (1UL << (x))

+#define GPIO_IRQSTATUS_NOT_TRIGGERED(x)   (0UL << (x))

+#define GPIO_IRQSTATUS_TRIGGERED(x)       (1UL << (x))

+#define GPIO_IRQSTATUS_CLEAR(x)           (1UL << (x))

+

+#define GPIO_IRQENABLE_MASK(x)            (1UL << (x))

+#define GPIO_IRQENABLE_DISABLE(x)         (0UL << (x))

+#define GPIO_IRQENABLE_ENABLE(x)          (1UL << (x))

+

+#define GPIO_WAKEUPENABLE_MASK(x)         (1UL << (x))

+#define GPIO_WAKEUPENABLE_DISABLE(x)      (0UL << (x))

+#define GPIO_WAKEUPENABLE_ENABLE(x)       (1UL << (x))

+

+#define GPIO_CTRL_GATINGRATIO_MASK        (3UL << 1)

+#define GPIO_CTRL_GATINGRATIO_DIV_1       (0UL << 1)

+#define GPIO_CTRL_GATINGRATIO_DIV_2       BIT1

+#define GPIO_CTRL_GATINGRATIO_DIV_4       (2UL << 1)

+#define GPIO_CTRL_GATINGRATIO_DIV_8       (3UL << 1)

+#define GPIO_CTRL_DISABLEMODULE_MASK      BIT0

+#define GPIO_CTRL_DISABLEMODULE_ENABLE    (0UL << 0)

+#define GPIO_CTRL_DISABLEMODULE_DISABLE   BIT0

+

+#define GPIO_OE_MASK(x)                   (1UL << (x))

+#define GPIO_OE_OUTPUT(x)                 (0UL << (x))

+#define GPIO_OE_INPUT(x)                  (1UL << (x))

+

+#define GPIO_DATAIN_MASK(x)               (1UL << (x))

+

+#define GPIO_DATAOUT_MASK(x)              (1UL << (x))

+

+#define GPIO_LEVELDETECT_MASK(x)          (1UL << (x))

+#define GPIO_LEVELDETECT_DISABLE(x)       (0UL << (x))

+#define GPIO_LEVELDETECT_ENABLE(x)        (1UL << (x))

+

+#define GPIO_RISINGDETECT_MASK(x)         (1UL << (x))

+#define GPIO_RISINGDETECT_DISABLE(x)      (0UL << (x))

+#define GPIO_RISINGDETECT_ENABLE(x)       (1UL << (x))

+

+#define GPIO_FALLINGDETECT_MASK(x)        (1UL << (x))

+#define GPIO_FALLINGDETECT_DISABLE(x)     (0UL << (x))

+#define GPIO_FALLINGDETECT_ENABLE(x)      (1UL << (x))

+

+#define GPIO_DEBOUNCENABLE_MASK(x)        (1UL << (x))

+#define GPIO_DEBOUNCENABLE_DISABLE(x)     (0UL << (x))

+#define GPIO_DEBOUNCENABLE_ENABLE(x)      (1UL << (x))

+

+#define GPIO_DEBOUNCINGTIME_MASK          (0xFF)

+#define GPIO_DEBOUNCINGTIME_US(x)         ((((x) / 31) - 1) & GPIO_DEBOUNCINGTIME_MASK)

+

+#define GPIO_CLEARIRQENABLE_BIT(x)        (1UL << (x))

+

+#define GPIO_SETIRQENABLE_BIT(x)          (1UL << (x))

+

+#define GPIO_CLEARWKUENA_BIT(x)           (1UL << (x))

+

+#define GPIO_SETWKUENA_BIT(x)             (1UL << (x))

+

+#define GPIO_CLEARDATAOUT_BIT(x)          (1UL << (x))

+

+#define GPIO_SETDATAOUT_BIT(x)            (1UL << (x))

+

+#endif // __OMAP3530GPIO_H__

+

diff --git a/Omap35xxPkg/Include/Omap3530/Omap3530Gpmc.h b/Omap35xxPkg/Include/Omap3530/Omap3530Gpmc.h
index 6cdd5f51..6943d303 100644
--- a/Omap35xxPkg/Include/Omap3530/Omap3530Gpmc.h
+++ b/Omap35xxPkg/Include/Omap3530/Omap3530Gpmc.h
@@ -1,107 +1,107 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __OMAP3530GPMC_H__
-#define __OMAP3530GPMC_H__
-
-#define GPMC_BASE             (0x6E000000)
-
-//GPMC NAND definitions.
-#define GPMC_SYSCONFIG        (GPMC_BASE + 0x10)
-#define SMARTIDLEMODE         (0x2UL << 3)
-
-#define GPMC_SYSSTATUS        (GPMC_BASE + 0x14)
-#define GPMC_IRQSTATUS        (GPMC_BASE + 0x18)
-#define GPMC_IRQENABLE        (GPMC_BASE + 0x1C)
-
-#define GPMC_TIMEOUT_CONTROL  (GPMC_BASE + 0x40)
-#define TIMEOUTENABLE         BIT0
-#define TIMEOUTDISABLE        (0x0UL << 0)
-
-#define GPMC_ERR_ADDRESS      (GPMC_BASE + 0x44)
-#define GPMC_ERR_TYPE         (GPMC_BASE + 0x48)
-
-#define GPMC_CONFIG           (GPMC_BASE + 0x50)
-#define WRITEPROTECT_HIGH     BIT4
-#define WRITEPROTECT_LOW      (0x0UL << 4)
-
-#define GPMC_STATUS           (GPMC_BASE + 0x54)
-
-#define GPMC_CONFIG1_0        (GPMC_BASE + 0x60)
-#define DEVICETYPE_NOR        (0x0UL << 10)
-#define DEVICETYPE_NAND       (0x2UL << 10)
-#define DEVICESIZE_X8         (0x0UL << 12)
-#define DEVICESIZE_X16        BIT12
-
-#define GPMC_CONFIG2_0        (GPMC_BASE + 0x64)
-#define CSONTIME              (0x0UL << 0)
-#define CSRDOFFTIME           (0x14UL << 8)
-#define CSWROFFTIME           (0x14UL << 16)
-
-#define GPMC_CONFIG3_0        (GPMC_BASE + 0x68)
-#define ADVRDOFFTIME          (0x14UL << 8)
-#define ADVWROFFTIME          (0x14UL << 16)
-
-#define GPMC_CONFIG4_0        (GPMC_BASE + 0x6C)
-#define OEONTIME              BIT0
-#define OEOFFTIME             (0xFUL << 8)
-#define WEONTIME              BIT16
-#define WEOFFTIME             (0xFUL << 24)
-
-#define GPMC_CONFIG5_0        (GPMC_BASE + 0x70)
-#define RDCYCLETIME           (0x14UL << 0)
-#define WRCYCLETIME           (0x14UL << 8)
-#define RDACCESSTIME          (0xCUL << 16)
-#define PAGEBURSTACCESSTIME   BIT24
-
-#define GPMC_CONFIG6_0        (GPMC_BASE + 0x74)
-#define CYCLE2CYCLESAMECSEN   BIT7
-#define CYCLE2CYCLEDELAY      (0xAUL << 8)
-#define WRDATAONADMUXBUS      (0xFUL << 16)
-#define WRACCESSTIME          BIT24
-
-#define GPMC_CONFIG7_0        (GPMC_BASE + 0x78)
-#define BASEADDRESS           (0x30UL << 0)
-#define CSVALID               BIT6
-#define MASKADDRESS_128MB     (0x8UL << 8)
-
-#define GPMC_NAND_COMMAND_0   (GPMC_BASE + 0x7C)
-#define GPMC_NAND_ADDRESS_0   (GPMC_BASE + 0x80)
-#define GPMC_NAND_DATA_0      (GPMC_BASE + 0x84)
-
-#define GPMC_ECC_CONFIG       (GPMC_BASE + 0x1F4)
-#define ECCENABLE             BIT0
-#define ECCDISABLE            (0x0UL << 0)
-#define ECCCS_0               (0x0UL << 1)
-#define ECC16B                BIT7
-
-#define GPMC_ECC_CONTROL      (GPMC_BASE + 0x1F8)
-#define ECCPOINTER_REG1       BIT0
-#define ECCCLEAR              BIT8
-
-#define GPMC_ECC_SIZE_CONFIG  (GPMC_BASE + 0x1FC)
-#define ECCSIZE0_512BYTES     (0xFFUL << 12)
-#define ECCSIZE1_512BYTES     (0xFFUL << 22)
-
-#define GPMC_ECC1_RESULT      (GPMC_BASE + 0x200)
-#define GPMC_ECC2_RESULT      (GPMC_BASE + 0x204)
-#define GPMC_ECC3_RESULT      (GPMC_BASE + 0x208)
-#define GPMC_ECC4_RESULT      (GPMC_BASE + 0x20C)
-#define GPMC_ECC5_RESULT      (GPMC_BASE + 0x210)
-#define GPMC_ECC6_RESULT      (GPMC_BASE + 0x214)
-#define GPMC_ECC7_RESULT      (GPMC_BASE + 0x218)
-#define GPMC_ECC8_RESULT      (GPMC_BASE + 0x21C)
-#define GPMC_ECC9_RESULT      (GPMC_BASE + 0x220)
-
-#endif //__OMAP3530GPMC_H__
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __OMAP3530GPMC_H__

+#define __OMAP3530GPMC_H__

+

+#define GPMC_BASE             (0x6E000000)

+

+//GPMC NAND definitions.

+#define GPMC_SYSCONFIG        (GPMC_BASE + 0x10)

+#define SMARTIDLEMODE         (0x2UL << 3)

+

+#define GPMC_SYSSTATUS        (GPMC_BASE + 0x14)

+#define GPMC_IRQSTATUS        (GPMC_BASE + 0x18)

+#define GPMC_IRQENABLE        (GPMC_BASE + 0x1C)

+

+#define GPMC_TIMEOUT_CONTROL  (GPMC_BASE + 0x40)

+#define TIMEOUTENABLE         BIT0

+#define TIMEOUTDISABLE        (0x0UL << 0)

+

+#define GPMC_ERR_ADDRESS      (GPMC_BASE + 0x44)

+#define GPMC_ERR_TYPE         (GPMC_BASE + 0x48)

+

+#define GPMC_CONFIG           (GPMC_BASE + 0x50)

+#define WRITEPROTECT_HIGH     BIT4

+#define WRITEPROTECT_LOW      (0x0UL << 4)

+

+#define GPMC_STATUS           (GPMC_BASE + 0x54)

+

+#define GPMC_CONFIG1_0        (GPMC_BASE + 0x60)

+#define DEVICETYPE_NOR        (0x0UL << 10)

+#define DEVICETYPE_NAND       (0x2UL << 10)

+#define DEVICESIZE_X8         (0x0UL << 12)

+#define DEVICESIZE_X16        BIT12

+

+#define GPMC_CONFIG2_0        (GPMC_BASE + 0x64)

+#define CSONTIME              (0x0UL << 0)

+#define CSRDOFFTIME           (0x14UL << 8)

+#define CSWROFFTIME           (0x14UL << 16)

+

+#define GPMC_CONFIG3_0        (GPMC_BASE + 0x68)

+#define ADVRDOFFTIME          (0x14UL << 8)

+#define ADVWROFFTIME          (0x14UL << 16)

+

+#define GPMC_CONFIG4_0        (GPMC_BASE + 0x6C)

+#define OEONTIME              BIT0

+#define OEOFFTIME             (0xFUL << 8)

+#define WEONTIME              BIT16

+#define WEOFFTIME             (0xFUL << 24)

+

+#define GPMC_CONFIG5_0        (GPMC_BASE + 0x70)

+#define RDCYCLETIME           (0x14UL << 0)

+#define WRCYCLETIME           (0x14UL << 8)

+#define RDACCESSTIME          (0xCUL << 16)

+#define PAGEBURSTACCESSTIME   BIT24

+

+#define GPMC_CONFIG6_0        (GPMC_BASE + 0x74)

+#define CYCLE2CYCLESAMECSEN   BIT7

+#define CYCLE2CYCLEDELAY      (0xAUL << 8)

+#define WRDATAONADMUXBUS      (0xFUL << 16)

+#define WRACCESSTIME          BIT24

+

+#define GPMC_CONFIG7_0        (GPMC_BASE + 0x78)

+#define BASEADDRESS           (0x30UL << 0)

+#define CSVALID               BIT6

+#define MASKADDRESS_128MB     (0x8UL << 8)

+

+#define GPMC_NAND_COMMAND_0   (GPMC_BASE + 0x7C)

+#define GPMC_NAND_ADDRESS_0   (GPMC_BASE + 0x80)

+#define GPMC_NAND_DATA_0      (GPMC_BASE + 0x84)

+

+#define GPMC_ECC_CONFIG       (GPMC_BASE + 0x1F4)

+#define ECCENABLE             BIT0

+#define ECCDISABLE            (0x0UL << 0)

+#define ECCCS_0               (0x0UL << 1)

+#define ECC16B                BIT7

+

+#define GPMC_ECC_CONTROL      (GPMC_BASE + 0x1F8)

+#define ECCPOINTER_REG1       BIT0

+#define ECCCLEAR              BIT8

+

+#define GPMC_ECC_SIZE_CONFIG  (GPMC_BASE + 0x1FC)

+#define ECCSIZE0_512BYTES     (0xFFUL << 12)

+#define ECCSIZE1_512BYTES     (0xFFUL << 22)

+

+#define GPMC_ECC1_RESULT      (GPMC_BASE + 0x200)

+#define GPMC_ECC2_RESULT      (GPMC_BASE + 0x204)

+#define GPMC_ECC3_RESULT      (GPMC_BASE + 0x208)

+#define GPMC_ECC4_RESULT      (GPMC_BASE + 0x20C)

+#define GPMC_ECC5_RESULT      (GPMC_BASE + 0x210)

+#define GPMC_ECC6_RESULT      (GPMC_BASE + 0x214)

+#define GPMC_ECC7_RESULT      (GPMC_BASE + 0x218)

+#define GPMC_ECC8_RESULT      (GPMC_BASE + 0x21C)

+#define GPMC_ECC9_RESULT      (GPMC_BASE + 0x220)

+

+#endif //__OMAP3530GPMC_H__

diff --git a/Omap35xxPkg/Include/Omap3530/Omap3530I2c.h b/Omap35xxPkg/Include/Omap3530/Omap3530I2c.h
index 61e1bf5c..31d4d5ea 100644
--- a/Omap35xxPkg/Include/Omap3530/Omap3530I2c.h
+++ b/Omap35xxPkg/Include/Omap3530/Omap3530I2c.h
@@ -1,62 +1,62 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __OMAP3530I2C_H__
-#define __OMAP3530I2C_H__
-
-//I2C register definitions.
-#define I2C1BASE        0x48070000
-
-#define I2C_IE          (I2C1BASE + 0x4)
-#define XRDY_IE         BIT4
-#define RRDY_IE         BIT3
-#define ARDY_IE         BIT2
-#define NACK_IE         BIT1
-
-#define I2C_STAT        (I2C1BASE + 0x8)
-#define BB              BIT12
-#define XRDY            BIT4
-#define RRDY            BIT3
-#define ARDY            BIT2
-#define NACK            BIT1
-
-#define I2C_WE          (I2C1BASE + 0xC)
-#define I2C_SYSS        (I2C1BASE + 0x10)
-#define I2C_BUF         (I2C1BASE + 0x14)
-#define I2C_CNT         (I2C1BASE + 0x18)
-#define I2C_DATA        (I2C1BASE + 0x1C)
-#define I2C_SYSC        (I2C1BASE + 0x20)
-
-#define I2C_CON         (I2C1BASE + 0x24)
-#define STT             BIT0
-#define STP             BIT1
-#define XSA             BIT8
-#define TRX             BIT9
-#define MST             BIT10
-#define I2C_EN          BIT15
-
-#define I2C_OA0         (I2C1BASE + 0x28)
-#define I2C_SA          (I2C1BASE + 0x2C)
-#define I2C_PSC         (I2C1BASE + 0x30)
-#define I2C_SCLL        (I2C1BASE + 0x34)
-#define I2C_SCLH        (I2C1BASE + 0x38)
-#define I2C_SYSTEST     (I2C1BASE + 0x3C)
-#define I2C_BUFSTAT     (I2C1BASE + 0x40)
-#define I2C_OA1         (I2C1BASE + 0x44)
-#define I2C_OA2         (I2C1BASE + 0x48)
-#define I2C_OA3         (I2C1BASE + 0x4C)
-#define I2C_ACTOA       (I2C1BASE + 0x50)
-#define I2C_SBLOCK      (I2C1BASE + 0x54)
-
-#endif //__OMAP3530I2C_H__
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __OMAP3530I2C_H__

+#define __OMAP3530I2C_H__

+

+//I2C register definitions.

+#define I2C1BASE        0x48070000

+

+#define I2C_IE          (I2C1BASE + 0x4)

+#define XRDY_IE         BIT4

+#define RRDY_IE         BIT3

+#define ARDY_IE         BIT2

+#define NACK_IE         BIT1

+

+#define I2C_STAT        (I2C1BASE + 0x8)

+#define BB              BIT12

+#define XRDY            BIT4

+#define RRDY            BIT3

+#define ARDY            BIT2

+#define NACK            BIT1

+

+#define I2C_WE          (I2C1BASE + 0xC)

+#define I2C_SYSS        (I2C1BASE + 0x10)

+#define I2C_BUF         (I2C1BASE + 0x14)

+#define I2C_CNT         (I2C1BASE + 0x18)

+#define I2C_DATA        (I2C1BASE + 0x1C)

+#define I2C_SYSC        (I2C1BASE + 0x20)

+

+#define I2C_CON         (I2C1BASE + 0x24)

+#define STT             BIT0

+#define STP             BIT1

+#define XSA             BIT8

+#define TRX             BIT9

+#define MST             BIT10

+#define I2C_EN          BIT15

+

+#define I2C_OA0         (I2C1BASE + 0x28)

+#define I2C_SA          (I2C1BASE + 0x2C)

+#define I2C_PSC         (I2C1BASE + 0x30)

+#define I2C_SCLL        (I2C1BASE + 0x34)

+#define I2C_SCLH        (I2C1BASE + 0x38)

+#define I2C_SYSTEST     (I2C1BASE + 0x3C)

+#define I2C_BUFSTAT     (I2C1BASE + 0x40)

+#define I2C_OA1         (I2C1BASE + 0x44)

+#define I2C_OA2         (I2C1BASE + 0x48)

+#define I2C_OA3         (I2C1BASE + 0x4C)

+#define I2C_ACTOA       (I2C1BASE + 0x50)

+#define I2C_SBLOCK      (I2C1BASE + 0x54)

+

+#endif //__OMAP3530I2C_H__

diff --git a/Omap35xxPkg/Include/Omap3530/Omap3530Interrupt.h b/Omap35xxPkg/Include/Omap3530/Omap3530Interrupt.h
index 9d1036d0..774d8730 100644
--- a/Omap35xxPkg/Include/Omap3530/Omap3530Interrupt.h
+++ b/Omap35xxPkg/Include/Omap3530/Omap3530Interrupt.h
@@ -1,48 +1,48 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __OMAP3530INTERRUPT_H__
-#define __OMAP3530INTERRUPT_H__
-
-#define INTERRUPT_BASE (0x48200000)
-
-#define INT_NROF_VECTORS      (96)
-#define MAX_VECTOR            (INT_NROF_VECTORS - 1)
-#define INTCPS_SYSCONFIG      (INTERRUPT_BASE + 0x0010)
-#define INTCPS_SYSSTATUS      (INTERRUPT_BASE + 0x0014)
-#define INTCPS_SIR_IRQ        (INTERRUPT_BASE + 0x0040)
-#define INTCPS_SIR_IFQ        (INTERRUPT_BASE + 0x0044)
-#define INTCPS_CONTROL        (INTERRUPT_BASE + 0x0048)
-#define INTCPS_PROTECTION     (INTERRUPT_BASE + 0x004C)
-#define INTCPS_IDLE           (INTERRUPT_BASE + 0x0050)
-#define INTCPS_IRQ_PRIORITY   (INTERRUPT_BASE + 0x0060)
-#define INTCPS_FIQ_PRIORITY   (INTERRUPT_BASE + 0x0064)
-#define INTCPS_THRESHOLD      (INTERRUPT_BASE + 0x0068)
-#define INTCPS_ITR(n)         (INTERRUPT_BASE + 0x0080 + (0x20 * (n)))
-#define INTCPS_MIR(n)         (INTERRUPT_BASE + 0x0084 + (0x20 * (n)))
-#define INTCPS_MIR_CLEAR(n)   (INTERRUPT_BASE + 0x0088 + (0x20 * (n)))
-#define INTCPS_MIR_SET(n)     (INTERRUPT_BASE + 0x008C + (0x20 * (n)))
-#define INTCPS_ISR_SET(n)     (INTERRUPT_BASE + 0x0090 + (0x20 * (n)))
-#define INTCPS_ISR_CLEAR(n)   (INTERRUPT_BASE + 0x0094 + (0x20 * (n)))
-#define INTCPS_PENDING_IRQ(n) (INTERRUPT_BASE + 0x0098 + (0x20 * (n)))
-#define INTCPS_PENDING_FIQ(n) (INTERRUPT_BASE + 0x009C + (0x20 * (n)))
-#define INTCPS_ILR(m)         (INTERRUPT_BASE + 0x0100 + (0x04 * (m)))
-
-#define INTCPS_ILR_FIQ            BIT0
-#define INTCPS_SIR_IRQ_MASK       (0x7F)
-#define INTCPS_CONTROL_NEWIRQAGR  BIT0
-#define INTCPS_CONTROL_NEWFIQAGR  BIT1
-
-#endif // __OMAP3530INTERRUPT_H__
-
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __OMAP3530INTERRUPT_H__

+#define __OMAP3530INTERRUPT_H__

+

+#define INTERRUPT_BASE (0x48200000)

+

+#define INT_NROF_VECTORS      (96)

+#define MAX_VECTOR            (INT_NROF_VECTORS - 1)

+#define INTCPS_SYSCONFIG      (INTERRUPT_BASE + 0x0010)

+#define INTCPS_SYSSTATUS      (INTERRUPT_BASE + 0x0014)

+#define INTCPS_SIR_IRQ        (INTERRUPT_BASE + 0x0040)

+#define INTCPS_SIR_IFQ        (INTERRUPT_BASE + 0x0044)

+#define INTCPS_CONTROL        (INTERRUPT_BASE + 0x0048)

+#define INTCPS_PROTECTION     (INTERRUPT_BASE + 0x004C)

+#define INTCPS_IDLE           (INTERRUPT_BASE + 0x0050)

+#define INTCPS_IRQ_PRIORITY   (INTERRUPT_BASE + 0x0060)

+#define INTCPS_FIQ_PRIORITY   (INTERRUPT_BASE + 0x0064)

+#define INTCPS_THRESHOLD      (INTERRUPT_BASE + 0x0068)

+#define INTCPS_ITR(n)         (INTERRUPT_BASE + 0x0080 + (0x20 * (n)))

+#define INTCPS_MIR(n)         (INTERRUPT_BASE + 0x0084 + (0x20 * (n)))

+#define INTCPS_MIR_CLEAR(n)   (INTERRUPT_BASE + 0x0088 + (0x20 * (n)))

+#define INTCPS_MIR_SET(n)     (INTERRUPT_BASE + 0x008C + (0x20 * (n)))

+#define INTCPS_ISR_SET(n)     (INTERRUPT_BASE + 0x0090 + (0x20 * (n)))

+#define INTCPS_ISR_CLEAR(n)   (INTERRUPT_BASE + 0x0094 + (0x20 * (n)))

+#define INTCPS_PENDING_IRQ(n) (INTERRUPT_BASE + 0x0098 + (0x20 * (n)))

+#define INTCPS_PENDING_FIQ(n) (INTERRUPT_BASE + 0x009C + (0x20 * (n)))

+#define INTCPS_ILR(m)         (INTERRUPT_BASE + 0x0100 + (0x04 * (m)))

+

+#define INTCPS_ILR_FIQ            BIT0

+#define INTCPS_SIR_IRQ_MASK       (0x7F)

+#define INTCPS_CONTROL_NEWIRQAGR  BIT0

+#define INTCPS_CONTROL_NEWFIQAGR  BIT1

+

+#endif // __OMAP3530INTERRUPT_H__

+

diff --git a/Omap35xxPkg/Include/Omap3530/Omap3530MMCHS.h b/Omap35xxPkg/Include/Omap3530/Omap3530MMCHS.h
index 1b3e734d..5bebe6c5 100644
--- a/Omap35xxPkg/Include/Omap3530/Omap3530MMCHS.h
+++ b/Omap35xxPkg/Include/Omap3530/Omap3530MMCHS.h
@@ -1,214 +1,214 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __OMAP3530SDIO_H__
-#define __OMAP3530SDIO_H__
-
-//MMC/SD/SDIO1 register definitions.
-#define MMCHS1BASE        0x4809C000
-#define MMC_REFERENCE_CLK (96000000)
-
-#define MMCHS_SYSCONFIG   (MMCHS1BASE + 0x10)
-#define SOFTRESET         BIT1
-#define ENAWAKEUP         BIT2
-
-#define MMCHS_SYSSTATUS   (MMCHS1BASE + 0x14)
-#define RESETDONE_MASK    BIT0
-#define RESETDONE         BIT0
-
-#define MMCHS_CSRE        (MMCHS1BASE + 0x24)
-#define MMCHS_SYSTEST     (MMCHS1BASE + 0x28)
-
-#define MMCHS_CON         (MMCHS1BASE + 0x2C)
-#define OD                BIT0
-#define NOINIT            (0x0UL << 1)
-#define INIT              BIT1
-#define HR                BIT2
-#define STR               BIT3
-#define MODE              BIT4
-#define DW8_1_4_BIT       (0x0UL << 5)
-#define DW8_8_BIT         BIT5
-#define MIT               BIT6
-#define CDP               BIT7
-#define WPP               BIT8
-#define CTPL              BIT11
-#define CEATA_OFF         (0x0UL << 12)
-#define CEATA_ON          BIT12
-
-#define MMCHS_PWCNT       (MMCHS1BASE + 0x30)
-
-#define MMCHS_BLK         (MMCHS1BASE + 0x104)
-#define BLEN_512BYTES     (0x200UL << 0)
-
-#define MMCHS_ARG         (MMCHS1BASE + 0x108)
-
-#define MMCHS_CMD         (MMCHS1BASE + 0x10C)
-#define DE_ENABLE         BIT0
-#define BCE_ENABLE        BIT1
-#define ACEN_ENABLE       BIT2
-#define DDIR_READ         BIT4
-#define DDIR_WRITE        (0x0UL << 4)
-#define MSBS_SGLEBLK      (0x0UL << 5)
-#define MSBS_MULTBLK      BIT5
-#define RSP_TYPE_MASK     (0x3UL << 16)
-#define RSP_TYPE_136BITS  BIT16
-#define RSP_TYPE_48BITS   (0x2UL << 16)
-#define CCCE_ENABLE       BIT19
-#define CICE_ENABLE       BIT20
-#define DP_ENABLE         BIT21 
-#define INDX(CMD_INDX)    ((CMD_INDX & 0x3F) << 24)
-
-#define MMCHS_RSP10       (MMCHS1BASE + 0x110)
-#define MMCHS_RSP32       (MMCHS1BASE + 0x114)
-#define MMCHS_RSP54       (MMCHS1BASE + 0x118)
-#define MMCHS_RSP76       (MMCHS1BASE + 0x11C)
-#define MMCHS_DATA        (MMCHS1BASE + 0x120)
-
-#define MMCHS_PSTATE      (MMCHS1BASE + 0x124)
-#define CMDI_MASK         BIT0
-#define CMDI_ALLOWED      (0x0UL << 0)
-#define CMDI_NOT_ALLOWED  BIT0
-#define DATI_MASK         BIT1
-#define DATI_ALLOWED      (0x0UL << 1)
-#define DATI_NOT_ALLOWED  BIT1
-
-#define MMCHS_HCTL        (MMCHS1BASE + 0x128)
-#define DTW_1_BIT         (0x0UL << 1)
-#define DTW_4_BIT         BIT1
-#define SDBP_MASK         BIT8
-#define SDBP_OFF          (0x0UL << 8)
-#define SDBP_ON           BIT8
-#define SDVS_1_8_V        (0x5UL << 9)
-#define SDVS_3_0_V        (0x6UL << 9)
-#define IWE               BIT24
-
-#define MMCHS_SYSCTL      (MMCHS1BASE + 0x12C)
-#define ICE               BIT0
-#define ICS_MASK          BIT1
-#define ICS               BIT1
-#define CEN               BIT2
-#define CLKD_MASK         (0x3FFUL << 6)
-#define CLKD_80KHZ        (0x258UL) //(96*1000/80)/2
-#define CLKD_400KHZ       (0xF0UL)
-#define DTO_MASK          (0xFUL << 16)
-#define DTO_VAL           (0xEUL << 16)
-#define SRA               BIT24
-#define SRC_MASK          BIT25
-#define SRC               BIT25
-#define SRD               BIT26
-
-#define MMCHS_STAT        (MMCHS1BASE + 0x130)
-#define CC                BIT0
-#define TC                BIT1
-#define BWR               BIT4
-#define BRR               BIT5
-#define ERRI              BIT15
-#define CTO               BIT16
-#define DTO               BIT20
-#define DCRC              BIT21
-#define DEB               BIT22
-
-#define MMCHS_IE          (MMCHS1BASE + 0x134)
-#define CC_EN             BIT0
-#define TC_EN             BIT1
-#define BWR_EN            BIT4
-#define BRR_EN            BIT5
-#define CTO_EN            BIT16
-#define CCRC_EN           BIT17
-#define CEB_EN            BIT18
-#define CIE_EN            BIT19
-#define DTO_EN            BIT20
-#define DCRC_EN           BIT21
-#define DEB_EN            BIT22
-#define CERR_EN           BIT28
-#define BADA_EN           BIT29
-
-#define MMCHS_ISE         (MMCHS1BASE + 0x138)
-#define CC_SIGEN          BIT0
-#define TC_SIGEN          BIT1
-#define BWR_SIGEN         BIT4
-#define BRR_SIGEN         BIT5
-#define CTO_SIGEN         BIT16
-#define CCRC_SIGEN        BIT17
-#define CEB_SIGEN         BIT18
-#define CIE_SIGEN         BIT19
-#define DTO_SIGEN         BIT20
-#define DCRC_SIGEN        BIT21
-#define DEB_SIGEN         BIT22
-#define CERR_SIGEN        BIT28
-#define BADA_SIGEN        BIT29
-
-#define MMCHS_AC12        (MMCHS1BASE + 0x13C)
-
-#define MMCHS_CAPA        (MMCHS1BASE + 0x140)
-#define VS30              BIT25
-#define VS18              BIT26
-
-#define MMCHS_CUR_CAPA    (MMCHS1BASE + 0x148)
-#define MMCHS_REV         (MMCHS1BASE + 0x1FC)
-
-#define CMD0              INDX(0)
-#define CMD0_INT_EN       (CC_EN | CEB_EN)
-
-#define CMD1              (INDX(1) | RSP_TYPE_48BITS)
-#define CMD1_INT_EN       (CC_EN | CEB_EN | CTO_EN)
-
-#define CMD2              (INDX(2) | CCCE_ENABLE | RSP_TYPE_136BITS)
-#define CMD2_INT_EN       (CERR_EN | CIE_EN | CCRC_EN | CC_EN | CEB_EN | CTO_EN)
-
-#define CMD3              (INDX(3) | CICE_ENABLE | CCCE_ENABLE | RSP_TYPE_48BITS)
-#define CMD3_INT_EN       (CERR_EN | CIE_EN | CCRC_EN | CC_EN | CEB_EN | CTO_EN)
-
-#define CMD5              (INDX(5) | RSP_TYPE_48BITS)
-#define CMD5_INT_EN       (CC_EN | CEB_EN | CTO_EN)
-
-#define CMD7              (INDX(7) | CICE_ENABLE | CCCE_ENABLE | RSP_TYPE_48BITS)
-#define CMD7_INT_EN       (CERR_EN | CIE_EN | CCRC_EN | CC_EN | CEB_EN | CTO_EN)
-
-#define CMD8              (INDX(8) | CICE_ENABLE | CCCE_ENABLE | RSP_TYPE_48BITS)
-#define CMD8_INT_EN       (CERR_EN | CIE_EN | CCRC_EN | CC_EN | CEB_EN | CTO_EN)
-//Reserved(0)[12:31], Supply voltage(1)[11:8], check pattern(0xCE)[7:0] = 0x1CE
-#define CMD8_ARG          (0x0UL << 12 | BIT8 | 0xCEUL << 0)
-
-#define CMD9              (INDX(9) | CCCE_ENABLE | RSP_TYPE_136BITS)
-#define CMD9_INT_EN       (CCRC_EN | CC_EN | CEB_EN | CTO_EN)
-
-#define CMD16             (INDX(16) | CICE_ENABLE | CCCE_ENABLE | RSP_TYPE_48BITS)
-#define CMD16_INT_EN      (CERR_EN | CIE_EN | CCRC_EN | CC_EN | CEB_EN | CTO_EN)
-
-#define CMD17             (INDX(17) | DP_ENABLE | CICE_ENABLE | CCCE_ENABLE | RSP_TYPE_48BITS | DDIR_READ)
-#define CMD17_INT_EN      (CERR_EN | CIE_EN | CCRC_EN | CC_EN | TC_EN | BRR_EN | CTO_EN | DTO_EN | DCRC_EN | DEB_EN | CEB_EN)
-
-#define CMD18             (INDX(18) | DP_ENABLE | CICE_ENABLE | CCCE_ENABLE | RSP_TYPE_48BITS | MSBS_MULTBLK | DDIR_READ | BCE_ENABLE | DE_ENABLE)
-#define CMD18_INT_EN      (CERR_EN | CIE_EN | CCRC_EN | CC_EN | TC_EN | BRR_EN | CTO_EN | DTO_EN | DCRC_EN | DEB_EN | CEB_EN)
-
-#define CMD23             (INDX(23) | CICE_ENABLE | CCCE_ENABLE | RSP_TYPE_48BITS)
-#define CMD23_INT_EN      (CERR_EN | CIE_EN | CCRC_EN | CC_EN | CEB_EN | CTO_EN)
-
-#define CMD24             (INDX(24) | DP_ENABLE | CICE_ENABLE | CCCE_ENABLE | RSP_TYPE_48BITS | DDIR_WRITE)
-#define CMD24_INT_EN      (CERR_EN | CIE_EN | CCRC_EN | CC_EN | TC_EN | BWR_EN | CTO_EN | DTO_EN | DCRC_EN | DEB_EN | CEB_EN)
-
-#define CMD25             (INDX(25) | DP_ENABLE | CICE_ENABLE | CCCE_ENABLE | RSP_TYPE_48BITS | MSBS_MULTBLK | DDIR_READ | BCE_ENABLE | DE_ENABLE)
-#define CMD25_INT_EN      (CERR_EN | CIE_EN | CCRC_EN | CC_EN | TC_EN | BRR_EN | CTO_EN | DTO_EN | DCRC_EN | DEB_EN | CEB_EN)
-
-#define CMD55             (INDX(55) | CICE_ENABLE | CCCE_ENABLE | RSP_TYPE_48BITS)
-#define CMD55_INT_EN      (CERR_EN | CIE_EN | CCRC_EN | CC_EN | CEB_EN | CTO_EN)
-
-#define ACMD41            (INDX(41) | RSP_TYPE_48BITS)
-#define ACMD41_INT_EN     (CERR_EN | CIE_EN | CCRC_EN | CC_EN | CEB_EN | CTO_EN)
-
-#define ACMD6             (INDX(6) | RSP_TYPE_48BITS)
-#define ACMD6_INT_EN      (CERR_EN | CIE_EN | CCRC_EN | CC_EN | CEB_EN | CTO_EN)
-
-#endif //__OMAP3530SDIO_H__
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __OMAP3530SDIO_H__

+#define __OMAP3530SDIO_H__

+

+//MMC/SD/SDIO1 register definitions.

+#define MMCHS1BASE        0x4809C000

+#define MMC_REFERENCE_CLK (96000000)

+

+#define MMCHS_SYSCONFIG   (MMCHS1BASE + 0x10)

+#define SOFTRESET         BIT1

+#define ENAWAKEUP         BIT2

+

+#define MMCHS_SYSSTATUS   (MMCHS1BASE + 0x14)

+#define RESETDONE_MASK    BIT0

+#define RESETDONE         BIT0

+

+#define MMCHS_CSRE        (MMCHS1BASE + 0x24)

+#define MMCHS_SYSTEST     (MMCHS1BASE + 0x28)

+

+#define MMCHS_CON         (MMCHS1BASE + 0x2C)

+#define OD                BIT0

+#define NOINIT            (0x0UL << 1)

+#define INIT              BIT1

+#define HR                BIT2

+#define STR               BIT3

+#define MODE              BIT4

+#define DW8_1_4_BIT       (0x0UL << 5)

+#define DW8_8_BIT         BIT5

+#define MIT               BIT6

+#define CDP               BIT7

+#define WPP               BIT8

+#define CTPL              BIT11

+#define CEATA_OFF         (0x0UL << 12)

+#define CEATA_ON          BIT12

+

+#define MMCHS_PWCNT       (MMCHS1BASE + 0x30)

+

+#define MMCHS_BLK         (MMCHS1BASE + 0x104)

+#define BLEN_512BYTES     (0x200UL << 0)

+

+#define MMCHS_ARG         (MMCHS1BASE + 0x108)

+

+#define MMCHS_CMD         (MMCHS1BASE + 0x10C)

+#define DE_ENABLE         BIT0

+#define BCE_ENABLE        BIT1

+#define ACEN_ENABLE       BIT2

+#define DDIR_READ         BIT4

+#define DDIR_WRITE        (0x0UL << 4)

+#define MSBS_SGLEBLK      (0x0UL << 5)

+#define MSBS_MULTBLK      BIT5

+#define RSP_TYPE_MASK     (0x3UL << 16)

+#define RSP_TYPE_136BITS  BIT16

+#define RSP_TYPE_48BITS   (0x2UL << 16)

+#define CCCE_ENABLE       BIT19

+#define CICE_ENABLE       BIT20

+#define DP_ENABLE         BIT21 

+#define INDX(CMD_INDX)    ((CMD_INDX & 0x3F) << 24)

+

+#define MMCHS_RSP10       (MMCHS1BASE + 0x110)

+#define MMCHS_RSP32       (MMCHS1BASE + 0x114)

+#define MMCHS_RSP54       (MMCHS1BASE + 0x118)

+#define MMCHS_RSP76       (MMCHS1BASE + 0x11C)

+#define MMCHS_DATA        (MMCHS1BASE + 0x120)

+

+#define MMCHS_PSTATE      (MMCHS1BASE + 0x124)

+#define CMDI_MASK         BIT0

+#define CMDI_ALLOWED      (0x0UL << 0)

+#define CMDI_NOT_ALLOWED  BIT0

+#define DATI_MASK         BIT1

+#define DATI_ALLOWED      (0x0UL << 1)

+#define DATI_NOT_ALLOWED  BIT1

+

+#define MMCHS_HCTL        (MMCHS1BASE + 0x128)

+#define DTW_1_BIT         (0x0UL << 1)

+#define DTW_4_BIT         BIT1

+#define SDBP_MASK         BIT8

+#define SDBP_OFF          (0x0UL << 8)

+#define SDBP_ON           BIT8

+#define SDVS_1_8_V        (0x5UL << 9)

+#define SDVS_3_0_V        (0x6UL << 9)

+#define IWE               BIT24

+

+#define MMCHS_SYSCTL      (MMCHS1BASE + 0x12C)

+#define ICE               BIT0

+#define ICS_MASK          BIT1

+#define ICS               BIT1

+#define CEN               BIT2

+#define CLKD_MASK         (0x3FFUL << 6)

+#define CLKD_80KHZ        (0x258UL) //(96*1000/80)/2

+#define CLKD_400KHZ       (0xF0UL)

+#define DTO_MASK          (0xFUL << 16)

+#define DTO_VAL           (0xEUL << 16)

+#define SRA               BIT24

+#define SRC_MASK          BIT25

+#define SRC               BIT25

+#define SRD               BIT26

+

+#define MMCHS_STAT        (MMCHS1BASE + 0x130)

+#define CC                BIT0

+#define TC                BIT1

+#define BWR               BIT4

+#define BRR               BIT5

+#define ERRI              BIT15

+#define CTO               BIT16

+#define DTO               BIT20

+#define DCRC              BIT21

+#define DEB               BIT22

+

+#define MMCHS_IE          (MMCHS1BASE + 0x134)

+#define CC_EN             BIT0

+#define TC_EN             BIT1

+#define BWR_EN            BIT4

+#define BRR_EN            BIT5

+#define CTO_EN            BIT16

+#define CCRC_EN           BIT17

+#define CEB_EN            BIT18

+#define CIE_EN            BIT19

+#define DTO_EN            BIT20

+#define DCRC_EN           BIT21

+#define DEB_EN            BIT22

+#define CERR_EN           BIT28

+#define BADA_EN           BIT29

+

+#define MMCHS_ISE         (MMCHS1BASE + 0x138)

+#define CC_SIGEN          BIT0

+#define TC_SIGEN          BIT1

+#define BWR_SIGEN         BIT4

+#define BRR_SIGEN         BIT5

+#define CTO_SIGEN         BIT16

+#define CCRC_SIGEN        BIT17

+#define CEB_SIGEN         BIT18

+#define CIE_SIGEN         BIT19

+#define DTO_SIGEN         BIT20

+#define DCRC_SIGEN        BIT21

+#define DEB_SIGEN         BIT22

+#define CERR_SIGEN        BIT28

+#define BADA_SIGEN        BIT29

+

+#define MMCHS_AC12        (MMCHS1BASE + 0x13C)

+

+#define MMCHS_CAPA        (MMCHS1BASE + 0x140)

+#define VS30              BIT25

+#define VS18              BIT26

+

+#define MMCHS_CUR_CAPA    (MMCHS1BASE + 0x148)

+#define MMCHS_REV         (MMCHS1BASE + 0x1FC)

+

+#define CMD0              INDX(0)

+#define CMD0_INT_EN       (CC_EN | CEB_EN)

+

+#define CMD1              (INDX(1) | RSP_TYPE_48BITS)

+#define CMD1_INT_EN       (CC_EN | CEB_EN | CTO_EN)

+

+#define CMD2              (INDX(2) | CCCE_ENABLE | RSP_TYPE_136BITS)

+#define CMD2_INT_EN       (CERR_EN | CIE_EN | CCRC_EN | CC_EN | CEB_EN | CTO_EN)

+

+#define CMD3              (INDX(3) | CICE_ENABLE | CCCE_ENABLE | RSP_TYPE_48BITS)

+#define CMD3_INT_EN       (CERR_EN | CIE_EN | CCRC_EN | CC_EN | CEB_EN | CTO_EN)

+

+#define CMD5              (INDX(5) | RSP_TYPE_48BITS)

+#define CMD5_INT_EN       (CC_EN | CEB_EN | CTO_EN)

+

+#define CMD7              (INDX(7) | CICE_ENABLE | CCCE_ENABLE | RSP_TYPE_48BITS)

+#define CMD7_INT_EN       (CERR_EN | CIE_EN | CCRC_EN | CC_EN | CEB_EN | CTO_EN)

+

+#define CMD8              (INDX(8) | CICE_ENABLE | CCCE_ENABLE | RSP_TYPE_48BITS)

+#define CMD8_INT_EN       (CERR_EN | CIE_EN | CCRC_EN | CC_EN | CEB_EN | CTO_EN)

+//Reserved(0)[12:31], Supply voltage(1)[11:8], check pattern(0xCE)[7:0] = 0x1CE

+#define CMD8_ARG          (0x0UL << 12 | BIT8 | 0xCEUL << 0)

+

+#define CMD9              (INDX(9) | CCCE_ENABLE | RSP_TYPE_136BITS)

+#define CMD9_INT_EN       (CCRC_EN | CC_EN | CEB_EN | CTO_EN)

+

+#define CMD16             (INDX(16) | CICE_ENABLE | CCCE_ENABLE | RSP_TYPE_48BITS)

+#define CMD16_INT_EN      (CERR_EN | CIE_EN | CCRC_EN | CC_EN | CEB_EN | CTO_EN)

+

+#define CMD17             (INDX(17) | DP_ENABLE | CICE_ENABLE | CCCE_ENABLE | RSP_TYPE_48BITS | DDIR_READ)

+#define CMD17_INT_EN      (CERR_EN | CIE_EN | CCRC_EN | CC_EN | TC_EN | BRR_EN | CTO_EN | DTO_EN | DCRC_EN | DEB_EN | CEB_EN)

+

+#define CMD18             (INDX(18) | DP_ENABLE | CICE_ENABLE | CCCE_ENABLE | RSP_TYPE_48BITS | MSBS_MULTBLK | DDIR_READ | BCE_ENABLE | DE_ENABLE)

+#define CMD18_INT_EN      (CERR_EN | CIE_EN | CCRC_EN | CC_EN | TC_EN | BRR_EN | CTO_EN | DTO_EN | DCRC_EN | DEB_EN | CEB_EN)

+

+#define CMD23             (INDX(23) | CICE_ENABLE | CCCE_ENABLE | RSP_TYPE_48BITS)

+#define CMD23_INT_EN      (CERR_EN | CIE_EN | CCRC_EN | CC_EN | CEB_EN | CTO_EN)

+

+#define CMD24             (INDX(24) | DP_ENABLE | CICE_ENABLE | CCCE_ENABLE | RSP_TYPE_48BITS | DDIR_WRITE)

+#define CMD24_INT_EN      (CERR_EN | CIE_EN | CCRC_EN | CC_EN | TC_EN | BWR_EN | CTO_EN | DTO_EN | DCRC_EN | DEB_EN | CEB_EN)

+

+#define CMD25             (INDX(25) | DP_ENABLE | CICE_ENABLE | CCCE_ENABLE | RSP_TYPE_48BITS | MSBS_MULTBLK | DDIR_READ | BCE_ENABLE | DE_ENABLE)

+#define CMD25_INT_EN      (CERR_EN | CIE_EN | CCRC_EN | CC_EN | TC_EN | BRR_EN | CTO_EN | DTO_EN | DCRC_EN | DEB_EN | CEB_EN)

+

+#define CMD55             (INDX(55) | CICE_ENABLE | CCCE_ENABLE | RSP_TYPE_48BITS)

+#define CMD55_INT_EN      (CERR_EN | CIE_EN | CCRC_EN | CC_EN | CEB_EN | CTO_EN)

+

+#define ACMD41            (INDX(41) | RSP_TYPE_48BITS)

+#define ACMD41_INT_EN     (CERR_EN | CIE_EN | CCRC_EN | CC_EN | CEB_EN | CTO_EN)

+

+#define ACMD6             (INDX(6) | RSP_TYPE_48BITS)

+#define ACMD6_INT_EN      (CERR_EN | CIE_EN | CCRC_EN | CC_EN | CEB_EN | CTO_EN)

+

+#endif //__OMAP3530SDIO_H__

diff --git a/Omap35xxPkg/Include/Omap3530/Omap3530PadConfiguration.h b/Omap35xxPkg/Include/Omap3530/Omap3530PadConfiguration.h
index d23156cf..1588e1d4 100644
--- a/Omap35xxPkg/Include/Omap3530/Omap3530PadConfiguration.h
+++ b/Omap35xxPkg/Include/Omap3530/Omap3530PadConfiguration.h
@@ -1,303 +1,303 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __OMAP3530_PAD_CONFIGURATION_H__
-#define __OMAP3530_PAD_CONFIGURATION_H__
-
-#define SYSTEM_CONTROL_MODULE_BASE  0x48002000
-
-//Pin definition
-#define SDRC_D0             (SYSTEM_CONTROL_MODULE_BASE + 0x030)
-#define SDRC_D1             (SYSTEM_CONTROL_MODULE_BASE + 0x032)
-#define SDRC_D2             (SYSTEM_CONTROL_MODULE_BASE + 0x034)
-#define SDRC_D3             (SYSTEM_CONTROL_MODULE_BASE + 0x036)
-#define SDRC_D4             (SYSTEM_CONTROL_MODULE_BASE + 0x038)
-#define SDRC_D5             (SYSTEM_CONTROL_MODULE_BASE + 0x03A)
-#define SDRC_D6             (SYSTEM_CONTROL_MODULE_BASE + 0x03C)
-#define SDRC_D7             (SYSTEM_CONTROL_MODULE_BASE + 0x03E)
-#define SDRC_D8             (SYSTEM_CONTROL_MODULE_BASE + 0x040)
-#define SDRC_D9             (SYSTEM_CONTROL_MODULE_BASE + 0x042)
-#define SDRC_D10            (SYSTEM_CONTROL_MODULE_BASE + 0x044)
-#define SDRC_D11            (SYSTEM_CONTROL_MODULE_BASE + 0x046)
-#define SDRC_D12            (SYSTEM_CONTROL_MODULE_BASE + 0x048)
-#define SDRC_D13            (SYSTEM_CONTROL_MODULE_BASE + 0x04A)
-#define SDRC_D14            (SYSTEM_CONTROL_MODULE_BASE + 0x04C)
-#define SDRC_D15            (SYSTEM_CONTROL_MODULE_BASE + 0x04E)
-#define SDRC_D16            (SYSTEM_CONTROL_MODULE_BASE + 0x050)
-#define SDRC_D17            (SYSTEM_CONTROL_MODULE_BASE + 0x052)
-#define SDRC_D18            (SYSTEM_CONTROL_MODULE_BASE + 0x054)
-#define SDRC_D19            (SYSTEM_CONTROL_MODULE_BASE + 0x056)
-#define SDRC_D20            (SYSTEM_CONTROL_MODULE_BASE + 0x058)
-#define SDRC_D21            (SYSTEM_CONTROL_MODULE_BASE + 0x05A)
-#define SDRC_D22            (SYSTEM_CONTROL_MODULE_BASE + 0x05C)
-#define SDRC_D23            (SYSTEM_CONTROL_MODULE_BASE + 0x05E)
-#define SDRC_D24            (SYSTEM_CONTROL_MODULE_BASE + 0x060)
-#define SDRC_D25            (SYSTEM_CONTROL_MODULE_BASE + 0x062)
-#define SDRC_D26            (SYSTEM_CONTROL_MODULE_BASE + 0x064)
-#define SDRC_D27            (SYSTEM_CONTROL_MODULE_BASE + 0x066)
-#define SDRC_D28            (SYSTEM_CONTROL_MODULE_BASE + 0x068)
-#define SDRC_D29            (SYSTEM_CONTROL_MODULE_BASE + 0x06A)
-#define SDRC_D30            (SYSTEM_CONTROL_MODULE_BASE + 0x06C)
-#define SDRC_D31            (SYSTEM_CONTROL_MODULE_BASE + 0x06E)
-#define SDRC_CLK            (SYSTEM_CONTROL_MODULE_BASE + 0x070)
-#define SDRC_DQS0           (SYSTEM_CONTROL_MODULE_BASE + 0x072)
-#define SDRC_CKE0           (SYSTEM_CONTROL_MODULE_BASE + 0x262)
-#define SDRC_CKE1           (SYSTEM_CONTROL_MODULE_BASE + 0x264)
-#define SDRC_DQS1           (SYSTEM_CONTROL_MODULE_BASE + 0x074)
-#define SDRC_DQS2           (SYSTEM_CONTROL_MODULE_BASE + 0x076)
-#define SDRC_DQS3           (SYSTEM_CONTROL_MODULE_BASE + 0x078)
-#define GPMC_A1             (SYSTEM_CONTROL_MODULE_BASE + 0x07A)
-#define GPMC_A2             (SYSTEM_CONTROL_MODULE_BASE + 0x07C)
-#define GPMC_A3             (SYSTEM_CONTROL_MODULE_BASE + 0x07E)
-#define GPMC_A4             (SYSTEM_CONTROL_MODULE_BASE + 0x080)
-#define GPMC_A5             (SYSTEM_CONTROL_MODULE_BASE + 0x082)
-#define GPMC_A6             (SYSTEM_CONTROL_MODULE_BASE + 0x084)
-#define GPMC_A7             (SYSTEM_CONTROL_MODULE_BASE + 0x086)
-#define GPMC_A8             (SYSTEM_CONTROL_MODULE_BASE + 0x088)
-#define GPMC_A9             (SYSTEM_CONTROL_MODULE_BASE + 0x08A)
-#define GPMC_A10            (SYSTEM_CONTROL_MODULE_BASE + 0x08C)
-#define GPMC_D0             (SYSTEM_CONTROL_MODULE_BASE + 0x08E)
-#define GPMC_D1             (SYSTEM_CONTROL_MODULE_BASE + 0x090)
-#define GPMC_D2             (SYSTEM_CONTROL_MODULE_BASE + 0x092)
-#define GPMC_D3             (SYSTEM_CONTROL_MODULE_BASE + 0x094)
-#define GPMC_D4             (SYSTEM_CONTROL_MODULE_BASE + 0x096)
-#define GPMC_D5             (SYSTEM_CONTROL_MODULE_BASE + 0x098)
-#define GPMC_D6             (SYSTEM_CONTROL_MODULE_BASE + 0x09A)
-#define GPMC_D7             (SYSTEM_CONTROL_MODULE_BASE + 0x09C)
-#define GPMC_D8             (SYSTEM_CONTROL_MODULE_BASE + 0x09E)
-#define GPMC_D9             (SYSTEM_CONTROL_MODULE_BASE + 0x0A0)
-#define GPMC_D10            (SYSTEM_CONTROL_MODULE_BASE + 0x0A2)
-#define GPMC_D11            (SYSTEM_CONTROL_MODULE_BASE + 0x0A4)
-#define GPMC_D12            (SYSTEM_CONTROL_MODULE_BASE + 0x0A6)
-#define GPMC_D13            (SYSTEM_CONTROL_MODULE_BASE + 0x0A8)
-#define GPMC_D14            (SYSTEM_CONTROL_MODULE_BASE + 0x0AA)
-#define GPMC_D15            (SYSTEM_CONTROL_MODULE_BASE + 0x0AC)
-#define GPMC_NCS0           (SYSTEM_CONTROL_MODULE_BASE + 0x0AE)
-#define GPMC_NCS1           (SYSTEM_CONTROL_MODULE_BASE + 0x0B0)
-#define GPMC_NCS2           (SYSTEM_CONTROL_MODULE_BASE + 0x0B2)
-#define GPMC_NCS3           (SYSTEM_CONTROL_MODULE_BASE + 0x0B4)
-#define GPMC_NCS4           (SYSTEM_CONTROL_MODULE_BASE + 0x0B6)
-#define GPMC_NCS5           (SYSTEM_CONTROL_MODULE_BASE + 0x0B8)
-#define GPMC_NCS6           (SYSTEM_CONTROL_MODULE_BASE + 0x0BA)
-#define GPMC_NCS7           (SYSTEM_CONTROL_MODULE_BASE + 0x0BC)
-#define GPMC_CLK            (SYSTEM_CONTROL_MODULE_BASE + 0x0BE)
-#define GPMC_NADV_ALE       (SYSTEM_CONTROL_MODULE_BASE + 0x0C0)
-#define GPMC_NOE            (SYSTEM_CONTROL_MODULE_BASE + 0x0C2)
-#define GPMC_NWE            (SYSTEM_CONTROL_MODULE_BASE + 0x0C4)
-#define GPMC_NBE0_CLE       (SYSTEM_CONTROL_MODULE_BASE + 0x0C6)
-#define GPMC_NBE1           (SYSTEM_CONTROL_MODULE_BASE + 0x0C8)
-#define GPMC_NWP            (SYSTEM_CONTROL_MODULE_BASE + 0x0CA)
-#define GPMC_WAIT0          (SYSTEM_CONTROL_MODULE_BASE + 0x0CC)
-#define GPMC_WAIT1          (SYSTEM_CONTROL_MODULE_BASE + 0x0CE)
-#define GPMC_WAIT2          (SYSTEM_CONTROL_MODULE_BASE + 0x0D0)
-#define GPMC_WAIT3          (SYSTEM_CONTROL_MODULE_BASE + 0x0D2)
-#define DSS_PCLK            (SYSTEM_CONTROL_MODULE_BASE + 0x0D4)
-#define DSS_HSYNC           (SYSTEM_CONTROL_MODULE_BASE + 0x0D6)
-#define DSS_PSYNC           (SYSTEM_CONTROL_MODULE_BASE + 0x0D8)
-#define DSS_ACBIAS          (SYSTEM_CONTROL_MODULE_BASE + 0x0DA)
-#define DSS_DATA0           (SYSTEM_CONTROL_MODULE_BASE + 0x0DC)
-#define DSS_DATA1           (SYSTEM_CONTROL_MODULE_BASE + 0x0DE)
-#define DSS_DATA2           (SYSTEM_CONTROL_MODULE_BASE + 0x0E0)
-#define DSS_DATA3           (SYSTEM_CONTROL_MODULE_BASE + 0x0E2)
-#define DSS_DATA4           (SYSTEM_CONTROL_MODULE_BASE + 0x0E4)
-#define DSS_DATA5           (SYSTEM_CONTROL_MODULE_BASE + 0x0E6)
-#define DSS_DATA6           (SYSTEM_CONTROL_MODULE_BASE + 0x0E8)
-#define DSS_DATA7           (SYSTEM_CONTROL_MODULE_BASE + 0x0EA)
-#define DSS_DATA8           (SYSTEM_CONTROL_MODULE_BASE + 0x0EC)
-#define DSS_DATA9           (SYSTEM_CONTROL_MODULE_BASE + 0x0EE)
-#define DSS_DATA10          (SYSTEM_CONTROL_MODULE_BASE + 0x0F0)
-#define DSS_DATA11          (SYSTEM_CONTROL_MODULE_BASE + 0x0F2)
-#define DSS_DATA12          (SYSTEM_CONTROL_MODULE_BASE + 0x0F4)
-#define DSS_DATA13          (SYSTEM_CONTROL_MODULE_BASE + 0x0F6)
-#define DSS_DATA14          (SYSTEM_CONTROL_MODULE_BASE + 0x0F8)
-#define DSS_DATA15          (SYSTEM_CONTROL_MODULE_BASE + 0x0FA)
-#define DSS_DATA16          (SYSTEM_CONTROL_MODULE_BASE + 0x0FC)
-#define DSS_DATA17          (SYSTEM_CONTROL_MODULE_BASE + 0x0FE)
-#define DSS_DATA18          (SYSTEM_CONTROL_MODULE_BASE + 0x100)
-#define DSS_DATA19          (SYSTEM_CONTROL_MODULE_BASE + 0x102)
-#define DSS_DATA20          (SYSTEM_CONTROL_MODULE_BASE + 0x104)
-#define DSS_DATA21          (SYSTEM_CONTROL_MODULE_BASE + 0x106)
-#define DSS_DATA22          (SYSTEM_CONTROL_MODULE_BASE + 0x108)
-#define DSS_DATA23          (SYSTEM_CONTROL_MODULE_BASE + 0x10A)
-#define CAM_HS              (SYSTEM_CONTROL_MODULE_BASE + 0x10C)
-#define CAM_VS              (SYSTEM_CONTROL_MODULE_BASE + 0x10E)
-#define CAM_XCLKA           (SYSTEM_CONTROL_MODULE_BASE + 0x110)
-#define CAM_PCLK            (SYSTEM_CONTROL_MODULE_BASE + 0x112)
-#define CAM_FLD             (SYSTEM_CONTROL_MODULE_BASE + 0x114)
-#define CAM_D0              (SYSTEM_CONTROL_MODULE_BASE + 0x116)
-#define CAM_D1              (SYSTEM_CONTROL_MODULE_BASE + 0x118)
-#define CAM_D2              (SYSTEM_CONTROL_MODULE_BASE + 0x11A)
-#define CAM_D3              (SYSTEM_CONTROL_MODULE_BASE + 0x11C)
-#define CAM_D4              (SYSTEM_CONTROL_MODULE_BASE + 0x11E)
-#define CAM_D5              (SYSTEM_CONTROL_MODULE_BASE + 0x120)
-#define CAM_D6              (SYSTEM_CONTROL_MODULE_BASE + 0x122)
-#define CAM_D7              (SYSTEM_CONTROL_MODULE_BASE + 0x124)
-#define CAM_D8              (SYSTEM_CONTROL_MODULE_BASE + 0x126)
-#define CAM_D9              (SYSTEM_CONTROL_MODULE_BASE + 0x128)
-#define CAM_D10             (SYSTEM_CONTROL_MODULE_BASE + 0x12A)
-#define CAM_D11             (SYSTEM_CONTROL_MODULE_BASE + 0x12C)
-#define CAM_XCLKB           (SYSTEM_CONTROL_MODULE_BASE + 0x12E)
-#define CAM_WEN             (SYSTEM_CONTROL_MODULE_BASE + 0x130)
-#define CAM_STROBE          (SYSTEM_CONTROL_MODULE_BASE + 0x132)
-#define CSI2_DX0            (SYSTEM_CONTROL_MODULE_BASE + 0x134)
-#define CSI2_DY0            (SYSTEM_CONTROL_MODULE_BASE + 0x136)
-#define CSI2_DX1            (SYSTEM_CONTROL_MODULE_BASE + 0x138)
-#define CSI2_DY1            (SYSTEM_CONTROL_MODULE_BASE + 0x13A)
-#define MCBSP2_FSX          (SYSTEM_CONTROL_MODULE_BASE + 0x13C)
-#define MCBSP2_CLKX         (SYSTEM_CONTROL_MODULE_BASE + 0x13E)
-#define MCBSP2_DR           (SYSTEM_CONTROL_MODULE_BASE + 0x140)
-#define MCBSP2_DX           (SYSTEM_CONTROL_MODULE_BASE + 0x142)
-#define MMC1_CLK            (SYSTEM_CONTROL_MODULE_BASE + 0x144)
-#define MMC1_CMD            (SYSTEM_CONTROL_MODULE_BASE + 0x146)
-#define MMC1_DAT0           (SYSTEM_CONTROL_MODULE_BASE + 0x148)
-#define MMC1_DAT1           (SYSTEM_CONTROL_MODULE_BASE + 0x14A)
-#define MMC1_DAT2           (SYSTEM_CONTROL_MODULE_BASE + 0x14C)
-#define MMC1_DAT3           (SYSTEM_CONTROL_MODULE_BASE + 0x14E)
-#define MMC1_DAT4           (SYSTEM_CONTROL_MODULE_BASE + 0x150)
-#define MMC1_DAT5           (SYSTEM_CONTROL_MODULE_BASE + 0x152)
-#define MMC1_DAT6           (SYSTEM_CONTROL_MODULE_BASE + 0x154)
-#define MMC1_DAT7           (SYSTEM_CONTROL_MODULE_BASE + 0x156)
-#define MMC2_CLK            (SYSTEM_CONTROL_MODULE_BASE + 0x158)
-#define MMC2_CMD            (SYSTEM_CONTROL_MODULE_BASE + 0x15A)
-#define MMC2_DAT0           (SYSTEM_CONTROL_MODULE_BASE + 0x15C)
-#define MMC2_DAT1           (SYSTEM_CONTROL_MODULE_BASE + 0x15E)
-#define MMC2_DAT2           (SYSTEM_CONTROL_MODULE_BASE + 0x160)
-#define MMC2_DAT3           (SYSTEM_CONTROL_MODULE_BASE + 0x162)
-#define MMC2_DAT4           (SYSTEM_CONTROL_MODULE_BASE + 0x164)
-#define MMC2_DAT5           (SYSTEM_CONTROL_MODULE_BASE + 0x166)
-#define MMC2_DAT6           (SYSTEM_CONTROL_MODULE_BASE + 0x168)
-#define MMC2_DAT7           (SYSTEM_CONTROL_MODULE_BASE + 0x16A)
-#define MCBSP3_DX           (SYSTEM_CONTROL_MODULE_BASE + 0x16C)
-#define MCBSP3_DR           (SYSTEM_CONTROL_MODULE_BASE + 0x16E)
-#define MCBSP3_CLKX         (SYSTEM_CONTROL_MODULE_BASE + 0x170)
-#define MCBSP3_FSX          (SYSTEM_CONTROL_MODULE_BASE + 0x172)
-#define UART2_CTS           (SYSTEM_CONTROL_MODULE_BASE + 0x174)
-#define UART2_RTS           (SYSTEM_CONTROL_MODULE_BASE + 0x176)
-#define UART2_TX            (SYSTEM_CONTROL_MODULE_BASE + 0x178)
-#define UART2_RX            (SYSTEM_CONTROL_MODULE_BASE + 0x17A)
-#define UART1_TX            (SYSTEM_CONTROL_MODULE_BASE + 0x17C)
-#define UART1_RTS           (SYSTEM_CONTROL_MODULE_BASE + 0x17E)
-#define UART1_CTS           (SYSTEM_CONTROL_MODULE_BASE + 0x180)
-#define UART1_RX            (SYSTEM_CONTROL_MODULE_BASE + 0x182)
-#define MCBSP4_CLKX         (SYSTEM_CONTROL_MODULE_BASE + 0x184)
-#define MCBSP4_DR           (SYSTEM_CONTROL_MODULE_BASE + 0x186)
-#define MCBSP4_DX           (SYSTEM_CONTROL_MODULE_BASE + 0x188)
-#define MCBSP4_FSX          (SYSTEM_CONTROL_MODULE_BASE + 0x18A)
-#define MCBSP1_CLKR         (SYSTEM_CONTROL_MODULE_BASE + 0x18C)
-#define MCBSP1_FSR          (SYSTEM_CONTROL_MODULE_BASE + 0x18E)
-#define MCBSP1_DX           (SYSTEM_CONTROL_MODULE_BASE + 0x190)
-#define MCBSP1_DR           (SYSTEM_CONTROL_MODULE_BASE + 0x192)
-#define MCBSP1_CLKS         (SYSTEM_CONTROL_MODULE_BASE + 0x194)
-#define MCBSP1_FSX          (SYSTEM_CONTROL_MODULE_BASE + 0x196)
-#define MCBSP1_CLKX         (SYSTEM_CONTROL_MODULE_BASE + 0x198)
-#define UART3_CTS_RCTX      (SYSTEM_CONTROL_MODULE_BASE + 0x19A)
-#define UART3_RTS_SD        (SYSTEM_CONTROL_MODULE_BASE + 0x19C)
-#define UART3_RX_IRRX       (SYSTEM_CONTROL_MODULE_BASE + 0x19E)
-#define UART3_TX_IRTX       (SYSTEM_CONTROL_MODULE_BASE + 0x1A0)
-#define HSUSB0_CLK          (SYSTEM_CONTROL_MODULE_BASE + 0x1A2)
-#define HSUSB0_STP          (SYSTEM_CONTROL_MODULE_BASE + 0x1A4)
-#define HSUSB0_DIR          (SYSTEM_CONTROL_MODULE_BASE + 0x1A6)
-#define HSUSB0_NXT          (SYSTEM_CONTROL_MODULE_BASE + 0x1A8)
-#define HSUSB0_DATA0        (SYSTEM_CONTROL_MODULE_BASE + 0x1AA)
-#define HSUSB0_DATA1        (SYSTEM_CONTROL_MODULE_BASE + 0x1AC)
-#define HSUSB0_DATA2        (SYSTEM_CONTROL_MODULE_BASE + 0x1AE)
-#define HSUSB0_DATA3        (SYSTEM_CONTROL_MODULE_BASE + 0x1B0)
-#define HSUSB0_DATA4        (SYSTEM_CONTROL_MODULE_BASE + 0x1B2)
-#define HSUSB0_DATA5        (SYSTEM_CONTROL_MODULE_BASE + 0x1B4)
-#define HSUSB0_DATA6        (SYSTEM_CONTROL_MODULE_BASE + 0x1B6)
-#define HSUSB0_DATA7        (SYSTEM_CONTROL_MODULE_BASE + 0x1B8)
-#define I2C1_SCL            (SYSTEM_CONTROL_MODULE_BASE + 0x1BA)
-#define I2C1_SDA            (SYSTEM_CONTROL_MODULE_BASE + 0x1BC)
-#define I2C2_SCL            (SYSTEM_CONTROL_MODULE_BASE + 0x1BE)
-#define I2C2_SDA            (SYSTEM_CONTROL_MODULE_BASE + 0x1C0)
-#define I2C3_SCL            (SYSTEM_CONTROL_MODULE_BASE + 0x1C2)
-#define I2C3_SDA            (SYSTEM_CONTROL_MODULE_BASE + 0x1C4)
-#define HDQ_SIO             (SYSTEM_CONTROL_MODULE_BASE + 0x1C6)
-#define MCSPI1_CLK          (SYSTEM_CONTROL_MODULE_BASE + 0x1C8)
-#define MCSPI1_SIMO         (SYSTEM_CONTROL_MODULE_BASE + 0x1CA)
-#define MCSPI1_SOMI         (SYSTEM_CONTROL_MODULE_BASE + 0x1CC)
-#define MCSPI1_CS0          (SYSTEM_CONTROL_MODULE_BASE + 0x1CE)
-#define MCSPI1_CS1          (SYSTEM_CONTROL_MODULE_BASE + 0x1D0)
-#define MCSPI1_CS2          (SYSTEM_CONTROL_MODULE_BASE + 0x1D2)
-#define MCSPI1_CS3          (SYSTEM_CONTROL_MODULE_BASE + 0x1D4)
-#define MCSPI2_CLK          (SYSTEM_CONTROL_MODULE_BASE + 0x1D6)
-#define MCSPI2_SIMO         (SYSTEM_CONTROL_MODULE_BASE + 0x1D8)
-#define MCSPI2_SOMI         (SYSTEM_CONTROL_MODULE_BASE + 0x1DA)
-#define MCSPI2_CS0          (SYSTEM_CONTROL_MODULE_BASE + 0x1DC)
-#define MCSPI2_CS1          (SYSTEM_CONTROL_MODULE_BASE + 0x1DE)
-#define SYS_NIRQ            (SYSTEM_CONTROL_MODULE_BASE + 0x1E0)
-#define SYS_CLKOUT2         (SYSTEM_CONTROL_MODULE_BASE + 0x1E2)
-#define ETK_CLK             (SYSTEM_CONTROL_MODULE_BASE + 0x5D8)
-#define ETK_CTL             (SYSTEM_CONTROL_MODULE_BASE + 0x5DA)
-#define ETK_D0              (SYSTEM_CONTROL_MODULE_BASE + 0x5DC)
-#define ETK_D1              (SYSTEM_CONTROL_MODULE_BASE + 0x5DE)
-#define ETK_D2              (SYSTEM_CONTROL_MODULE_BASE + 0x5E0)
-#define ETK_D3              (SYSTEM_CONTROL_MODULE_BASE + 0x5E2)
-#define ETK_D4              (SYSTEM_CONTROL_MODULE_BASE + 0x5E4)
-#define ETK_D5              (SYSTEM_CONTROL_MODULE_BASE + 0x5E6)
-#define ETK_D6              (SYSTEM_CONTROL_MODULE_BASE + 0x5E8)
-#define ETK_D7              (SYSTEM_CONTROL_MODULE_BASE + 0x5EA)
-#define ETK_D8              (SYSTEM_CONTROL_MODULE_BASE + 0x5EC)
-#define ETK_D9              (SYSTEM_CONTROL_MODULE_BASE + 0x5EE)
-#define ETK_D10             (SYSTEM_CONTROL_MODULE_BASE + 0x5F0)
-#define ETK_D11             (SYSTEM_CONTROL_MODULE_BASE + 0x5F2)
-#define ETK_D12             (SYSTEM_CONTROL_MODULE_BASE + 0x5F4)
-#define ETK_D13             (SYSTEM_CONTROL_MODULE_BASE + 0x5F6)
-#define ETK_D14             (SYSTEM_CONTROL_MODULE_BASE + 0x5F8)
-#define ETK_D15             (SYSTEM_CONTROL_MODULE_BASE + 0x5FA)
-#define SYS_BOOT0           (SYSTEM_CONTROL_MODULE_BASE + 0xA0A)
-#define SYS_BOOT1           (SYSTEM_CONTROL_MODULE_BASE + 0xA0C)
-#define SYS_BOOT3           (SYSTEM_CONTROL_MODULE_BASE + 0xA10)
-#define SYS_BOOT4           (SYSTEM_CONTROL_MODULE_BASE + 0xA12)
-#define SYS_BOOT5           (SYSTEM_CONTROL_MODULE_BASE + 0xA14)
-#define SYS_BOOT6           (SYSTEM_CONTROL_MODULE_BASE + 0xA16)
-
-//Mux modes
-#define MUXMODE0            (0x0UL)
-#define MUXMODE1            (0x1UL)
-#define MUXMODE2            (0x2UL)
-#define MUXMODE3            (0x3UL)
-#define MUXMODE4            (0x4UL)
-#define MUXMODE5            (0x5UL)
-#define MUXMODE6            (0x6UL)
-#define MUXMODE7            (0x7UL)
-
-//Pad configuration register.
-#define PAD_CONFIG_MASK      (0xFFFFUL)
-#define MUXMODE_OFFSET       0
-#define MUXMODE_MASK         (0x7UL << MUXMODE_OFFSET)
-#define PULL_CONFIG_OFFSET   3
-#define PULL_CONFIG_MASK     (0x3UL << PULL_CONFIG_OFFSET)
-#define INPUTENABLE_OFFSET   8
-#define INPUTENABLE_MASK     (0x1UL << INPUTENABLE_OFFSET)
-#define OFFMODE_VALUE_OFFSET 9
-#define OFFMODE_VALUE_MASK   (0x1FUL << OFFMODE_VALUE_OFFSET)
-#define WAKEUP_OFFSET        14
-#define WAKEUP_MASK          (0x2UL << WAKEUP_OFFSET)
-
-#define PULL_DOWN_SELECTED   ((0x0UL << 1) | BIT0)
-#define PULL_UP_SELECTED     (BIT1 | BIT0)
-#define PULL_DISABLED        (0x0UL << 0)
-
-#define OUTPUT               (0x0UL) //Pin is configured in output only mode.
-#define INPUT                (0x1UL) //Pin is configured in bi-directional mode.
-
-typedef struct {
-  UINTN   Pin;
-  UINTN   MuxMode;
-  UINTN   PullConfig;
-  UINTN   InputEnable;
-} PAD_CONFIGURATION;
-
-#endif //__OMAP3530_PAD_CONFIGURATION_H__
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __OMAP3530_PAD_CONFIGURATION_H__

+#define __OMAP3530_PAD_CONFIGURATION_H__

+

+#define SYSTEM_CONTROL_MODULE_BASE  0x48002000

+

+//Pin definition

+#define SDRC_D0             (SYSTEM_CONTROL_MODULE_BASE + 0x030)

+#define SDRC_D1             (SYSTEM_CONTROL_MODULE_BASE + 0x032)

+#define SDRC_D2             (SYSTEM_CONTROL_MODULE_BASE + 0x034)

+#define SDRC_D3             (SYSTEM_CONTROL_MODULE_BASE + 0x036)

+#define SDRC_D4             (SYSTEM_CONTROL_MODULE_BASE + 0x038)

+#define SDRC_D5             (SYSTEM_CONTROL_MODULE_BASE + 0x03A)

+#define SDRC_D6             (SYSTEM_CONTROL_MODULE_BASE + 0x03C)

+#define SDRC_D7             (SYSTEM_CONTROL_MODULE_BASE + 0x03E)

+#define SDRC_D8             (SYSTEM_CONTROL_MODULE_BASE + 0x040)

+#define SDRC_D9             (SYSTEM_CONTROL_MODULE_BASE + 0x042)

+#define SDRC_D10            (SYSTEM_CONTROL_MODULE_BASE + 0x044)

+#define SDRC_D11            (SYSTEM_CONTROL_MODULE_BASE + 0x046)

+#define SDRC_D12            (SYSTEM_CONTROL_MODULE_BASE + 0x048)

+#define SDRC_D13            (SYSTEM_CONTROL_MODULE_BASE + 0x04A)

+#define SDRC_D14            (SYSTEM_CONTROL_MODULE_BASE + 0x04C)

+#define SDRC_D15            (SYSTEM_CONTROL_MODULE_BASE + 0x04E)

+#define SDRC_D16            (SYSTEM_CONTROL_MODULE_BASE + 0x050)

+#define SDRC_D17            (SYSTEM_CONTROL_MODULE_BASE + 0x052)

+#define SDRC_D18            (SYSTEM_CONTROL_MODULE_BASE + 0x054)

+#define SDRC_D19            (SYSTEM_CONTROL_MODULE_BASE + 0x056)

+#define SDRC_D20            (SYSTEM_CONTROL_MODULE_BASE + 0x058)

+#define SDRC_D21            (SYSTEM_CONTROL_MODULE_BASE + 0x05A)

+#define SDRC_D22            (SYSTEM_CONTROL_MODULE_BASE + 0x05C)

+#define SDRC_D23            (SYSTEM_CONTROL_MODULE_BASE + 0x05E)

+#define SDRC_D24            (SYSTEM_CONTROL_MODULE_BASE + 0x060)

+#define SDRC_D25            (SYSTEM_CONTROL_MODULE_BASE + 0x062)

+#define SDRC_D26            (SYSTEM_CONTROL_MODULE_BASE + 0x064)

+#define SDRC_D27            (SYSTEM_CONTROL_MODULE_BASE + 0x066)

+#define SDRC_D28            (SYSTEM_CONTROL_MODULE_BASE + 0x068)

+#define SDRC_D29            (SYSTEM_CONTROL_MODULE_BASE + 0x06A)

+#define SDRC_D30            (SYSTEM_CONTROL_MODULE_BASE + 0x06C)

+#define SDRC_D31            (SYSTEM_CONTROL_MODULE_BASE + 0x06E)

+#define SDRC_CLK            (SYSTEM_CONTROL_MODULE_BASE + 0x070)

+#define SDRC_DQS0           (SYSTEM_CONTROL_MODULE_BASE + 0x072)

+#define SDRC_CKE0           (SYSTEM_CONTROL_MODULE_BASE + 0x262)

+#define SDRC_CKE1           (SYSTEM_CONTROL_MODULE_BASE + 0x264)

+#define SDRC_DQS1           (SYSTEM_CONTROL_MODULE_BASE + 0x074)

+#define SDRC_DQS2           (SYSTEM_CONTROL_MODULE_BASE + 0x076)

+#define SDRC_DQS3           (SYSTEM_CONTROL_MODULE_BASE + 0x078)

+#define GPMC_A1             (SYSTEM_CONTROL_MODULE_BASE + 0x07A)

+#define GPMC_A2             (SYSTEM_CONTROL_MODULE_BASE + 0x07C)

+#define GPMC_A3             (SYSTEM_CONTROL_MODULE_BASE + 0x07E)

+#define GPMC_A4             (SYSTEM_CONTROL_MODULE_BASE + 0x080)

+#define GPMC_A5             (SYSTEM_CONTROL_MODULE_BASE + 0x082)

+#define GPMC_A6             (SYSTEM_CONTROL_MODULE_BASE + 0x084)

+#define GPMC_A7             (SYSTEM_CONTROL_MODULE_BASE + 0x086)

+#define GPMC_A8             (SYSTEM_CONTROL_MODULE_BASE + 0x088)

+#define GPMC_A9             (SYSTEM_CONTROL_MODULE_BASE + 0x08A)

+#define GPMC_A10            (SYSTEM_CONTROL_MODULE_BASE + 0x08C)

+#define GPMC_D0             (SYSTEM_CONTROL_MODULE_BASE + 0x08E)

+#define GPMC_D1             (SYSTEM_CONTROL_MODULE_BASE + 0x090)

+#define GPMC_D2             (SYSTEM_CONTROL_MODULE_BASE + 0x092)

+#define GPMC_D3             (SYSTEM_CONTROL_MODULE_BASE + 0x094)

+#define GPMC_D4             (SYSTEM_CONTROL_MODULE_BASE + 0x096)

+#define GPMC_D5             (SYSTEM_CONTROL_MODULE_BASE + 0x098)

+#define GPMC_D6             (SYSTEM_CONTROL_MODULE_BASE + 0x09A)

+#define GPMC_D7             (SYSTEM_CONTROL_MODULE_BASE + 0x09C)

+#define GPMC_D8             (SYSTEM_CONTROL_MODULE_BASE + 0x09E)

+#define GPMC_D9             (SYSTEM_CONTROL_MODULE_BASE + 0x0A0)

+#define GPMC_D10            (SYSTEM_CONTROL_MODULE_BASE + 0x0A2)

+#define GPMC_D11            (SYSTEM_CONTROL_MODULE_BASE + 0x0A4)

+#define GPMC_D12            (SYSTEM_CONTROL_MODULE_BASE + 0x0A6)

+#define GPMC_D13            (SYSTEM_CONTROL_MODULE_BASE + 0x0A8)

+#define GPMC_D14            (SYSTEM_CONTROL_MODULE_BASE + 0x0AA)

+#define GPMC_D15            (SYSTEM_CONTROL_MODULE_BASE + 0x0AC)

+#define GPMC_NCS0           (SYSTEM_CONTROL_MODULE_BASE + 0x0AE)

+#define GPMC_NCS1           (SYSTEM_CONTROL_MODULE_BASE + 0x0B0)

+#define GPMC_NCS2           (SYSTEM_CONTROL_MODULE_BASE + 0x0B2)

+#define GPMC_NCS3           (SYSTEM_CONTROL_MODULE_BASE + 0x0B4)

+#define GPMC_NCS4           (SYSTEM_CONTROL_MODULE_BASE + 0x0B6)

+#define GPMC_NCS5           (SYSTEM_CONTROL_MODULE_BASE + 0x0B8)

+#define GPMC_NCS6           (SYSTEM_CONTROL_MODULE_BASE + 0x0BA)

+#define GPMC_NCS7           (SYSTEM_CONTROL_MODULE_BASE + 0x0BC)

+#define GPMC_CLK            (SYSTEM_CONTROL_MODULE_BASE + 0x0BE)

+#define GPMC_NADV_ALE       (SYSTEM_CONTROL_MODULE_BASE + 0x0C0)

+#define GPMC_NOE            (SYSTEM_CONTROL_MODULE_BASE + 0x0C2)

+#define GPMC_NWE            (SYSTEM_CONTROL_MODULE_BASE + 0x0C4)

+#define GPMC_NBE0_CLE       (SYSTEM_CONTROL_MODULE_BASE + 0x0C6)

+#define GPMC_NBE1           (SYSTEM_CONTROL_MODULE_BASE + 0x0C8)

+#define GPMC_NWP            (SYSTEM_CONTROL_MODULE_BASE + 0x0CA)

+#define GPMC_WAIT0          (SYSTEM_CONTROL_MODULE_BASE + 0x0CC)

+#define GPMC_WAIT1          (SYSTEM_CONTROL_MODULE_BASE + 0x0CE)

+#define GPMC_WAIT2          (SYSTEM_CONTROL_MODULE_BASE + 0x0D0)

+#define GPMC_WAIT3          (SYSTEM_CONTROL_MODULE_BASE + 0x0D2)

+#define DSS_PCLK            (SYSTEM_CONTROL_MODULE_BASE + 0x0D4)

+#define DSS_HSYNC           (SYSTEM_CONTROL_MODULE_BASE + 0x0D6)

+#define DSS_PSYNC           (SYSTEM_CONTROL_MODULE_BASE + 0x0D8)

+#define DSS_ACBIAS          (SYSTEM_CONTROL_MODULE_BASE + 0x0DA)

+#define DSS_DATA0           (SYSTEM_CONTROL_MODULE_BASE + 0x0DC)

+#define DSS_DATA1           (SYSTEM_CONTROL_MODULE_BASE + 0x0DE)

+#define DSS_DATA2           (SYSTEM_CONTROL_MODULE_BASE + 0x0E0)

+#define DSS_DATA3           (SYSTEM_CONTROL_MODULE_BASE + 0x0E2)

+#define DSS_DATA4           (SYSTEM_CONTROL_MODULE_BASE + 0x0E4)

+#define DSS_DATA5           (SYSTEM_CONTROL_MODULE_BASE + 0x0E6)

+#define DSS_DATA6           (SYSTEM_CONTROL_MODULE_BASE + 0x0E8)

+#define DSS_DATA7           (SYSTEM_CONTROL_MODULE_BASE + 0x0EA)

+#define DSS_DATA8           (SYSTEM_CONTROL_MODULE_BASE + 0x0EC)

+#define DSS_DATA9           (SYSTEM_CONTROL_MODULE_BASE + 0x0EE)

+#define DSS_DATA10          (SYSTEM_CONTROL_MODULE_BASE + 0x0F0)

+#define DSS_DATA11          (SYSTEM_CONTROL_MODULE_BASE + 0x0F2)

+#define DSS_DATA12          (SYSTEM_CONTROL_MODULE_BASE + 0x0F4)

+#define DSS_DATA13          (SYSTEM_CONTROL_MODULE_BASE + 0x0F6)

+#define DSS_DATA14          (SYSTEM_CONTROL_MODULE_BASE + 0x0F8)

+#define DSS_DATA15          (SYSTEM_CONTROL_MODULE_BASE + 0x0FA)

+#define DSS_DATA16          (SYSTEM_CONTROL_MODULE_BASE + 0x0FC)

+#define DSS_DATA17          (SYSTEM_CONTROL_MODULE_BASE + 0x0FE)

+#define DSS_DATA18          (SYSTEM_CONTROL_MODULE_BASE + 0x100)

+#define DSS_DATA19          (SYSTEM_CONTROL_MODULE_BASE + 0x102)

+#define DSS_DATA20          (SYSTEM_CONTROL_MODULE_BASE + 0x104)

+#define DSS_DATA21          (SYSTEM_CONTROL_MODULE_BASE + 0x106)

+#define DSS_DATA22          (SYSTEM_CONTROL_MODULE_BASE + 0x108)

+#define DSS_DATA23          (SYSTEM_CONTROL_MODULE_BASE + 0x10A)

+#define CAM_HS              (SYSTEM_CONTROL_MODULE_BASE + 0x10C)

+#define CAM_VS              (SYSTEM_CONTROL_MODULE_BASE + 0x10E)

+#define CAM_XCLKA           (SYSTEM_CONTROL_MODULE_BASE + 0x110)

+#define CAM_PCLK            (SYSTEM_CONTROL_MODULE_BASE + 0x112)

+#define CAM_FLD             (SYSTEM_CONTROL_MODULE_BASE + 0x114)

+#define CAM_D0              (SYSTEM_CONTROL_MODULE_BASE + 0x116)

+#define CAM_D1              (SYSTEM_CONTROL_MODULE_BASE + 0x118)

+#define CAM_D2              (SYSTEM_CONTROL_MODULE_BASE + 0x11A)

+#define CAM_D3              (SYSTEM_CONTROL_MODULE_BASE + 0x11C)

+#define CAM_D4              (SYSTEM_CONTROL_MODULE_BASE + 0x11E)

+#define CAM_D5              (SYSTEM_CONTROL_MODULE_BASE + 0x120)

+#define CAM_D6              (SYSTEM_CONTROL_MODULE_BASE + 0x122)

+#define CAM_D7              (SYSTEM_CONTROL_MODULE_BASE + 0x124)

+#define CAM_D8              (SYSTEM_CONTROL_MODULE_BASE + 0x126)

+#define CAM_D9              (SYSTEM_CONTROL_MODULE_BASE + 0x128)

+#define CAM_D10             (SYSTEM_CONTROL_MODULE_BASE + 0x12A)

+#define CAM_D11             (SYSTEM_CONTROL_MODULE_BASE + 0x12C)

+#define CAM_XCLKB           (SYSTEM_CONTROL_MODULE_BASE + 0x12E)

+#define CAM_WEN             (SYSTEM_CONTROL_MODULE_BASE + 0x130)

+#define CAM_STROBE          (SYSTEM_CONTROL_MODULE_BASE + 0x132)

+#define CSI2_DX0            (SYSTEM_CONTROL_MODULE_BASE + 0x134)

+#define CSI2_DY0            (SYSTEM_CONTROL_MODULE_BASE + 0x136)

+#define CSI2_DX1            (SYSTEM_CONTROL_MODULE_BASE + 0x138)

+#define CSI2_DY1            (SYSTEM_CONTROL_MODULE_BASE + 0x13A)

+#define MCBSP2_FSX          (SYSTEM_CONTROL_MODULE_BASE + 0x13C)

+#define MCBSP2_CLKX         (SYSTEM_CONTROL_MODULE_BASE + 0x13E)

+#define MCBSP2_DR           (SYSTEM_CONTROL_MODULE_BASE + 0x140)

+#define MCBSP2_DX           (SYSTEM_CONTROL_MODULE_BASE + 0x142)

+#define MMC1_CLK            (SYSTEM_CONTROL_MODULE_BASE + 0x144)

+#define MMC1_CMD            (SYSTEM_CONTROL_MODULE_BASE + 0x146)

+#define MMC1_DAT0           (SYSTEM_CONTROL_MODULE_BASE + 0x148)

+#define MMC1_DAT1           (SYSTEM_CONTROL_MODULE_BASE + 0x14A)

+#define MMC1_DAT2           (SYSTEM_CONTROL_MODULE_BASE + 0x14C)

+#define MMC1_DAT3           (SYSTEM_CONTROL_MODULE_BASE + 0x14E)

+#define MMC1_DAT4           (SYSTEM_CONTROL_MODULE_BASE + 0x150)

+#define MMC1_DAT5           (SYSTEM_CONTROL_MODULE_BASE + 0x152)

+#define MMC1_DAT6           (SYSTEM_CONTROL_MODULE_BASE + 0x154)

+#define MMC1_DAT7           (SYSTEM_CONTROL_MODULE_BASE + 0x156)

+#define MMC2_CLK            (SYSTEM_CONTROL_MODULE_BASE + 0x158)

+#define MMC2_CMD            (SYSTEM_CONTROL_MODULE_BASE + 0x15A)

+#define MMC2_DAT0           (SYSTEM_CONTROL_MODULE_BASE + 0x15C)

+#define MMC2_DAT1           (SYSTEM_CONTROL_MODULE_BASE + 0x15E)

+#define MMC2_DAT2           (SYSTEM_CONTROL_MODULE_BASE + 0x160)

+#define MMC2_DAT3           (SYSTEM_CONTROL_MODULE_BASE + 0x162)

+#define MMC2_DAT4           (SYSTEM_CONTROL_MODULE_BASE + 0x164)

+#define MMC2_DAT5           (SYSTEM_CONTROL_MODULE_BASE + 0x166)

+#define MMC2_DAT6           (SYSTEM_CONTROL_MODULE_BASE + 0x168)

+#define MMC2_DAT7           (SYSTEM_CONTROL_MODULE_BASE + 0x16A)

+#define MCBSP3_DX           (SYSTEM_CONTROL_MODULE_BASE + 0x16C)

+#define MCBSP3_DR           (SYSTEM_CONTROL_MODULE_BASE + 0x16E)

+#define MCBSP3_CLKX         (SYSTEM_CONTROL_MODULE_BASE + 0x170)

+#define MCBSP3_FSX          (SYSTEM_CONTROL_MODULE_BASE + 0x172)

+#define UART2_CTS           (SYSTEM_CONTROL_MODULE_BASE + 0x174)

+#define UART2_RTS           (SYSTEM_CONTROL_MODULE_BASE + 0x176)

+#define UART2_TX            (SYSTEM_CONTROL_MODULE_BASE + 0x178)

+#define UART2_RX            (SYSTEM_CONTROL_MODULE_BASE + 0x17A)

+#define UART1_TX            (SYSTEM_CONTROL_MODULE_BASE + 0x17C)

+#define UART1_RTS           (SYSTEM_CONTROL_MODULE_BASE + 0x17E)

+#define UART1_CTS           (SYSTEM_CONTROL_MODULE_BASE + 0x180)

+#define UART1_RX            (SYSTEM_CONTROL_MODULE_BASE + 0x182)

+#define MCBSP4_CLKX         (SYSTEM_CONTROL_MODULE_BASE + 0x184)

+#define MCBSP4_DR           (SYSTEM_CONTROL_MODULE_BASE + 0x186)

+#define MCBSP4_DX           (SYSTEM_CONTROL_MODULE_BASE + 0x188)

+#define MCBSP4_FSX          (SYSTEM_CONTROL_MODULE_BASE + 0x18A)

+#define MCBSP1_CLKR         (SYSTEM_CONTROL_MODULE_BASE + 0x18C)

+#define MCBSP1_FSR          (SYSTEM_CONTROL_MODULE_BASE + 0x18E)

+#define MCBSP1_DX           (SYSTEM_CONTROL_MODULE_BASE + 0x190)

+#define MCBSP1_DR           (SYSTEM_CONTROL_MODULE_BASE + 0x192)

+#define MCBSP1_CLKS         (SYSTEM_CONTROL_MODULE_BASE + 0x194)

+#define MCBSP1_FSX          (SYSTEM_CONTROL_MODULE_BASE + 0x196)

+#define MCBSP1_CLKX         (SYSTEM_CONTROL_MODULE_BASE + 0x198)

+#define UART3_CTS_RCTX      (SYSTEM_CONTROL_MODULE_BASE + 0x19A)

+#define UART3_RTS_SD        (SYSTEM_CONTROL_MODULE_BASE + 0x19C)

+#define UART3_RX_IRRX       (SYSTEM_CONTROL_MODULE_BASE + 0x19E)

+#define UART3_TX_IRTX       (SYSTEM_CONTROL_MODULE_BASE + 0x1A0)

+#define HSUSB0_CLK          (SYSTEM_CONTROL_MODULE_BASE + 0x1A2)

+#define HSUSB0_STP          (SYSTEM_CONTROL_MODULE_BASE + 0x1A4)

+#define HSUSB0_DIR          (SYSTEM_CONTROL_MODULE_BASE + 0x1A6)

+#define HSUSB0_NXT          (SYSTEM_CONTROL_MODULE_BASE + 0x1A8)

+#define HSUSB0_DATA0        (SYSTEM_CONTROL_MODULE_BASE + 0x1AA)

+#define HSUSB0_DATA1        (SYSTEM_CONTROL_MODULE_BASE + 0x1AC)

+#define HSUSB0_DATA2        (SYSTEM_CONTROL_MODULE_BASE + 0x1AE)

+#define HSUSB0_DATA3        (SYSTEM_CONTROL_MODULE_BASE + 0x1B0)

+#define HSUSB0_DATA4        (SYSTEM_CONTROL_MODULE_BASE + 0x1B2)

+#define HSUSB0_DATA5        (SYSTEM_CONTROL_MODULE_BASE + 0x1B4)

+#define HSUSB0_DATA6        (SYSTEM_CONTROL_MODULE_BASE + 0x1B6)

+#define HSUSB0_DATA7        (SYSTEM_CONTROL_MODULE_BASE + 0x1B8)

+#define I2C1_SCL            (SYSTEM_CONTROL_MODULE_BASE + 0x1BA)

+#define I2C1_SDA            (SYSTEM_CONTROL_MODULE_BASE + 0x1BC)

+#define I2C2_SCL            (SYSTEM_CONTROL_MODULE_BASE + 0x1BE)

+#define I2C2_SDA            (SYSTEM_CONTROL_MODULE_BASE + 0x1C0)

+#define I2C3_SCL            (SYSTEM_CONTROL_MODULE_BASE + 0x1C2)

+#define I2C3_SDA            (SYSTEM_CONTROL_MODULE_BASE + 0x1C4)

+#define HDQ_SIO             (SYSTEM_CONTROL_MODULE_BASE + 0x1C6)

+#define MCSPI1_CLK          (SYSTEM_CONTROL_MODULE_BASE + 0x1C8)

+#define MCSPI1_SIMO         (SYSTEM_CONTROL_MODULE_BASE + 0x1CA)

+#define MCSPI1_SOMI         (SYSTEM_CONTROL_MODULE_BASE + 0x1CC)

+#define MCSPI1_CS0          (SYSTEM_CONTROL_MODULE_BASE + 0x1CE)

+#define MCSPI1_CS1          (SYSTEM_CONTROL_MODULE_BASE + 0x1D0)

+#define MCSPI1_CS2          (SYSTEM_CONTROL_MODULE_BASE + 0x1D2)

+#define MCSPI1_CS3          (SYSTEM_CONTROL_MODULE_BASE + 0x1D4)

+#define MCSPI2_CLK          (SYSTEM_CONTROL_MODULE_BASE + 0x1D6)

+#define MCSPI2_SIMO         (SYSTEM_CONTROL_MODULE_BASE + 0x1D8)

+#define MCSPI2_SOMI         (SYSTEM_CONTROL_MODULE_BASE + 0x1DA)

+#define MCSPI2_CS0          (SYSTEM_CONTROL_MODULE_BASE + 0x1DC)

+#define MCSPI2_CS1          (SYSTEM_CONTROL_MODULE_BASE + 0x1DE)

+#define SYS_NIRQ            (SYSTEM_CONTROL_MODULE_BASE + 0x1E0)

+#define SYS_CLKOUT2         (SYSTEM_CONTROL_MODULE_BASE + 0x1E2)

+#define ETK_CLK             (SYSTEM_CONTROL_MODULE_BASE + 0x5D8)

+#define ETK_CTL             (SYSTEM_CONTROL_MODULE_BASE + 0x5DA)

+#define ETK_D0              (SYSTEM_CONTROL_MODULE_BASE + 0x5DC)

+#define ETK_D1              (SYSTEM_CONTROL_MODULE_BASE + 0x5DE)

+#define ETK_D2              (SYSTEM_CONTROL_MODULE_BASE + 0x5E0)

+#define ETK_D3              (SYSTEM_CONTROL_MODULE_BASE + 0x5E2)

+#define ETK_D4              (SYSTEM_CONTROL_MODULE_BASE + 0x5E4)

+#define ETK_D5              (SYSTEM_CONTROL_MODULE_BASE + 0x5E6)

+#define ETK_D6              (SYSTEM_CONTROL_MODULE_BASE + 0x5E8)

+#define ETK_D7              (SYSTEM_CONTROL_MODULE_BASE + 0x5EA)

+#define ETK_D8              (SYSTEM_CONTROL_MODULE_BASE + 0x5EC)

+#define ETK_D9              (SYSTEM_CONTROL_MODULE_BASE + 0x5EE)

+#define ETK_D10             (SYSTEM_CONTROL_MODULE_BASE + 0x5F0)

+#define ETK_D11             (SYSTEM_CONTROL_MODULE_BASE + 0x5F2)

+#define ETK_D12             (SYSTEM_CONTROL_MODULE_BASE + 0x5F4)

+#define ETK_D13             (SYSTEM_CONTROL_MODULE_BASE + 0x5F6)

+#define ETK_D14             (SYSTEM_CONTROL_MODULE_BASE + 0x5F8)

+#define ETK_D15             (SYSTEM_CONTROL_MODULE_BASE + 0x5FA)

+#define SYS_BOOT0           (SYSTEM_CONTROL_MODULE_BASE + 0xA0A)

+#define SYS_BOOT1           (SYSTEM_CONTROL_MODULE_BASE + 0xA0C)

+#define SYS_BOOT3           (SYSTEM_CONTROL_MODULE_BASE + 0xA10)

+#define SYS_BOOT4           (SYSTEM_CONTROL_MODULE_BASE + 0xA12)

+#define SYS_BOOT5           (SYSTEM_CONTROL_MODULE_BASE + 0xA14)

+#define SYS_BOOT6           (SYSTEM_CONTROL_MODULE_BASE + 0xA16)

+

+//Mux modes

+#define MUXMODE0            (0x0UL)

+#define MUXMODE1            (0x1UL)

+#define MUXMODE2            (0x2UL)

+#define MUXMODE3            (0x3UL)

+#define MUXMODE4            (0x4UL)

+#define MUXMODE5            (0x5UL)

+#define MUXMODE6            (0x6UL)

+#define MUXMODE7            (0x7UL)

+

+//Pad configuration register.

+#define PAD_CONFIG_MASK      (0xFFFFUL)

+#define MUXMODE_OFFSET       0

+#define MUXMODE_MASK         (0x7UL << MUXMODE_OFFSET)

+#define PULL_CONFIG_OFFSET   3

+#define PULL_CONFIG_MASK     (0x3UL << PULL_CONFIG_OFFSET)

+#define INPUTENABLE_OFFSET   8

+#define INPUTENABLE_MASK     (0x1UL << INPUTENABLE_OFFSET)

+#define OFFMODE_VALUE_OFFSET 9

+#define OFFMODE_VALUE_MASK   (0x1FUL << OFFMODE_VALUE_OFFSET)

+#define WAKEUP_OFFSET        14

+#define WAKEUP_MASK          (0x2UL << WAKEUP_OFFSET)

+

+#define PULL_DOWN_SELECTED   ((0x0UL << 1) | BIT0)

+#define PULL_UP_SELECTED     (BIT1 | BIT0)

+#define PULL_DISABLED        (0x0UL << 0)

+

+#define OUTPUT               (0x0UL) //Pin is configured in output only mode.

+#define INPUT                (0x1UL) //Pin is configured in bi-directional mode.

+

+typedef struct {

+  UINTN   Pin;

+  UINTN   MuxMode;

+  UINTN   PullConfig;

+  UINTN   InputEnable;

+} PAD_CONFIGURATION;

+

+#endif //__OMAP3530_PAD_CONFIGURATION_H__

diff --git a/Omap35xxPkg/Include/Omap3530/Omap3530Prcm.h b/Omap35xxPkg/Include/Omap3530/Omap3530Prcm.h
index cd639e30..3a297d0a 100644
--- a/Omap35xxPkg/Include/Omap3530/Omap3530Prcm.h
+++ b/Omap35xxPkg/Include/Omap3530/Omap3530Prcm.h
@@ -1,165 +1,165 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __OMAP3530PRCM_H__
-#define __OMAP3530PRCM_H__
-
-#define CM_FCLKEN1_CORE   (0x48004A00)
-#define CM_FCLKEN3_CORE   (0x48004A08)
-#define CM_ICLKEN1_CORE   (0x48004A10)
-#define CM_ICLKEN3_CORE   (0x48004A18)
-#define CM_CLKEN2_PLL     (0x48004D04)
-#define CM_CLKSEL4_PLL    (0x48004D4C)
-#define CM_CLKSEL5_PLL    (0x48004D50)
-#define CM_FCLKEN_USBHOST  (0x48005400)
-#define CM_ICLKEN_USBHOST  (0x48005410)
-#define CM_CLKSTST_USBHOST (0x4800544c)
-
-//Wakeup clock defintion
-#define CM_FCLKEN_WKUP    (0x48004C00)
-#define CM_ICLKEN_WKUP    (0x48004C10)
-
-//Peripheral clock definition
-#define CM_FCLKEN_PER     (0x48005000)
-#define CM_ICLKEN_PER     (0x48005010)
-#define CM_CLKSEL_PER     (0x48005040)
-
-//Reset management definition
-#define PRM_RSTCTRL       (0x48307250)
-#define PRM_RSTST         (0x48307258)
-
-//CORE clock
-#define CM_FCLKEN1_CORE_EN_I2C1_MASK    BIT15
-#define CM_FCLKEN1_CORE_EN_I2C1_DISABLE (0UL << 15)
-#define CM_FCLKEN1_CORE_EN_I2C1_ENABLE  BIT15
-
-#define CM_ICLKEN1_CORE_EN_I2C1_MASK    BIT15
-#define CM_ICLKEN1_CORE_EN_I2C1_DISABLE (0UL << 15)
-#define CM_ICLKEN1_CORE_EN_I2C1_ENABLE  BIT15
-
-#define CM_FCLKEN1_CORE_EN_MMC1_MASK    BIT24
-#define CM_FCLKEN1_CORE_EN_MMC1_DISABLE (0UL << 24)
-#define CM_FCLKEN1_CORE_EN_MMC1_ENABLE  BIT24
-
-#define CM_FCLKEN3_CORE_EN_USBTLL_MASK    BIT2
-#define CM_FCLKEN3_CORE_EN_USBTLL_DISABLE (0UL << 2)
-#define CM_FCLKEN3_CORE_EN_USBTLL_ENABLE  BIT2
-
-#define CM_ICLKEN1_CORE_EN_MMC1_MASK    BIT24
-#define CM_ICLKEN1_CORE_EN_MMC1_DISABLE (0UL << 24)
-#define CM_ICLKEN1_CORE_EN_MMC1_ENABLE  BIT24
-
-#define CM_ICLKEN3_CORE_EN_USBTLL_MASK    BIT2
-#define CM_ICLKEN3_CORE_EN_USBTLL_DISABLE (0UL << 2)
-#define CM_ICLKEN3_CORE_EN_USBTLL_ENABLE  BIT2
-
-#define CM_CLKEN_FREQSEL_075_100        (0x03UL << 4)
-#define CM_CLKEN_ENABLE                 (7UL << 0)
-
-#define CM_CLKSEL_PLL_MULT(x)           (((x) & 0x07FF) << 8)
-#define CM_CLKSEL_PLL_DIV(x)            ((((x) - 1) & 0x7F) << 0)
-  
-#define CM_CLKSEL_DIV_120M(x)           (((x) & 0x1F) << 0)
-
-#define CM_FCLKEN_USBHOST_EN_USBHOST2_MASK    BIT1
-#define CM_FCLKEN_USBHOST_EN_USBHOST2_DISABLE (0UL << 1)
-#define CM_FCLKEN_USBHOST_EN_USBHOST2_ENABLE  BIT1
-
-#define CM_FCLKEN_USBHOST_EN_USBHOST1_MASK    BIT0
-#define CM_FCLKEN_USBHOST_EN_USBHOST1_DISABLE (0UL << 0)
-#define CM_FCLKEN_USBHOST_EN_USBHOST1_ENABLE  BIT0
-
-#define CM_ICLKEN_USBHOST_EN_USBHOST_MASK     BIT0
-#define CM_ICLKEN_USBHOST_EN_USBHOST_DISABLE  (0UL << 0)
-#define CM_ICLKEN_USBHOST_EN_USBHOST_ENABLE   BIT0
-
-//Wakeup functional clock
-#define CM_FCLKEN_WKUP_EN_GPIO1_DISABLE       (0UL << 3)
-#define CM_FCLKEN_WKUP_EN_GPIO1_ENABLE        BIT3
-
-#define CM_FCLKEN_WKUP_EN_WDT2_DISABLE        (0UL << 5)
-#define CM_FCLKEN_WKUP_EN_WDT2_ENABLE         BIT5
-
-//Wakeup interface clock
-#define CM_ICLKEN_WKUP_EN_GPIO1_DISABLE       (0UL << 3)
-#define CM_ICLKEN_WKUP_EN_GPIO1_ENABLE        BIT3
-
-#define CM_ICLKEN_WKUP_EN_WDT2_DISABLE        (0UL << 5)
-#define CM_ICLKEN_WKUP_EN_WDT2_ENABLE         BIT5
-
-//Peripheral functional clock
-#define CM_FCLKEN_PER_EN_GPT3_DISABLE         (0UL << 4)
-#define CM_FCLKEN_PER_EN_GPT3_ENABLE          BIT4
-
-#define CM_FCLKEN_PER_EN_GPT4_DISABLE         (0UL << 5)
-#define CM_FCLKEN_PER_EN_GPT4_ENABLE          BIT5
-
-#define CM_FCLKEN_PER_EN_UART3_DISABLE        (0UL << 11)
-#define CM_FCLKEN_PER_EN_UART3_ENABLE         BIT11
-
-#define CM_FCLKEN_PER_EN_GPIO2_DISABLE        (0UL << 13)
-#define CM_FCLKEN_PER_EN_GPIO2_ENABLE         BIT13
-
-#define CM_FCLKEN_PER_EN_GPIO3_DISABLE        (0UL << 14)
-#define CM_FCLKEN_PER_EN_GPIO3_ENABLE         BIT14
-
-#define CM_FCLKEN_PER_EN_GPIO4_DISABLE        (0UL << 15)
-#define CM_FCLKEN_PER_EN_GPIO4_ENABLE         BIT15
-
-#define CM_FCLKEN_PER_EN_GPIO5_DISABLE        (0UL << 16)
-#define CM_FCLKEN_PER_EN_GPIO5_ENABLE         BIT16
-
-#define CM_FCLKEN_PER_EN_GPIO6_DISABLE        (0UL << 17)
-#define CM_FCLKEN_PER_EN_GPIO6_ENABLE         BIT17
-
-//Peripheral interface clock
-#define CM_ICLKEN_PER_EN_GPT3_DISABLE         (0UL << 4)
-#define CM_ICLKEN_PER_EN_GPT3_ENABLE          BIT4
-
-#define CM_ICLKEN_PER_EN_GPT4_DISABLE         (0UL << 5)
-#define CM_ICLKEN_PER_EN_GPT4_ENABLE          BIT5
-
-#define CM_ICLKEN_PER_EN_UART3_DISABLE        (0UL << 11)
-#define CM_ICLKEN_PER_EN_UART3_ENABLE         BIT11
-
-#define CM_ICLKEN_PER_EN_GPIO2_DISABLE        (0UL << 13)
-#define CM_ICLKEN_PER_EN_GPIO2_ENABLE         BIT13
-
-#define CM_ICLKEN_PER_EN_GPIO3_DISABLE        (0UL << 14)
-#define CM_ICLKEN_PER_EN_GPIO3_ENABLE         BIT14
-
-#define CM_ICLKEN_PER_EN_GPIO4_DISABLE        (0UL << 15)
-#define CM_ICLKEN_PER_EN_GPIO4_ENABLE         BIT15
-
-#define CM_ICLKEN_PER_EN_GPIO5_DISABLE        (0UL << 16)
-#define CM_ICLKEN_PER_EN_GPIO5_ENABLE         BIT16
-
-#define CM_ICLKEN_PER_EN_GPIO6_DISABLE        (0UL << 17)
-#define CM_ICLKEN_PER_EN_GPIO6_ENABLE         BIT17
-
-//Timer source clock selection
-#define CM_CLKSEL_PER_CLKSEL_GPT3_32K         (0UL << 1)
-#define CM_CLKSEL_PER_CLKSEL_GPT3_SYS         BIT1
-
-#define CM_CLKSEL_PER_CLKSEL_GPT4_32K         (0UL << 2)
-#define CM_CLKSEL_PER_CLKSEL_GPT4_SYS         BIT2
-
-//Reset management (Global and Cold reset)
-#define RST_GS            BIT1
-#define RST_DPLL3         BIT2
-#define GLOBAL_SW_RST     BIT1
-#define GLOBAL_COLD_RST   (0x0UL << 0)
-
-#endif // __OMAP3530PRCM_H__
-
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __OMAP3530PRCM_H__

+#define __OMAP3530PRCM_H__

+

+#define CM_FCLKEN1_CORE   (0x48004A00)

+#define CM_FCLKEN3_CORE   (0x48004A08)

+#define CM_ICLKEN1_CORE   (0x48004A10)

+#define CM_ICLKEN3_CORE   (0x48004A18)

+#define CM_CLKEN2_PLL     (0x48004D04)

+#define CM_CLKSEL4_PLL    (0x48004D4C)

+#define CM_CLKSEL5_PLL    (0x48004D50)

+#define CM_FCLKEN_USBHOST  (0x48005400)

+#define CM_ICLKEN_USBHOST  (0x48005410)

+#define CM_CLKSTST_USBHOST (0x4800544c)

+

+//Wakeup clock defintion

+#define CM_FCLKEN_WKUP    (0x48004C00)

+#define CM_ICLKEN_WKUP    (0x48004C10)

+

+//Peripheral clock definition

+#define CM_FCLKEN_PER     (0x48005000)

+#define CM_ICLKEN_PER     (0x48005010)

+#define CM_CLKSEL_PER     (0x48005040)

+

+//Reset management definition

+#define PRM_RSTCTRL       (0x48307250)

+#define PRM_RSTST         (0x48307258)

+

+//CORE clock

+#define CM_FCLKEN1_CORE_EN_I2C1_MASK    BIT15

+#define CM_FCLKEN1_CORE_EN_I2C1_DISABLE (0UL << 15)

+#define CM_FCLKEN1_CORE_EN_I2C1_ENABLE  BIT15

+

+#define CM_ICLKEN1_CORE_EN_I2C1_MASK    BIT15

+#define CM_ICLKEN1_CORE_EN_I2C1_DISABLE (0UL << 15)

+#define CM_ICLKEN1_CORE_EN_I2C1_ENABLE  BIT15

+

+#define CM_FCLKEN1_CORE_EN_MMC1_MASK    BIT24

+#define CM_FCLKEN1_CORE_EN_MMC1_DISABLE (0UL << 24)

+#define CM_FCLKEN1_CORE_EN_MMC1_ENABLE  BIT24

+

+#define CM_FCLKEN3_CORE_EN_USBTLL_MASK    BIT2

+#define CM_FCLKEN3_CORE_EN_USBTLL_DISABLE (0UL << 2)

+#define CM_FCLKEN3_CORE_EN_USBTLL_ENABLE  BIT2

+

+#define CM_ICLKEN1_CORE_EN_MMC1_MASK    BIT24

+#define CM_ICLKEN1_CORE_EN_MMC1_DISABLE (0UL << 24)

+#define CM_ICLKEN1_CORE_EN_MMC1_ENABLE  BIT24

+

+#define CM_ICLKEN3_CORE_EN_USBTLL_MASK    BIT2

+#define CM_ICLKEN3_CORE_EN_USBTLL_DISABLE (0UL << 2)

+#define CM_ICLKEN3_CORE_EN_USBTLL_ENABLE  BIT2

+

+#define CM_CLKEN_FREQSEL_075_100        (0x03UL << 4)

+#define CM_CLKEN_ENABLE                 (7UL << 0)

+

+#define CM_CLKSEL_PLL_MULT(x)           (((x) & 0x07FF) << 8)

+#define CM_CLKSEL_PLL_DIV(x)            ((((x) - 1) & 0x7F) << 0)

+  

+#define CM_CLKSEL_DIV_120M(x)           (((x) & 0x1F) << 0)

+

+#define CM_FCLKEN_USBHOST_EN_USBHOST2_MASK    BIT1

+#define CM_FCLKEN_USBHOST_EN_USBHOST2_DISABLE (0UL << 1)

+#define CM_FCLKEN_USBHOST_EN_USBHOST2_ENABLE  BIT1

+

+#define CM_FCLKEN_USBHOST_EN_USBHOST1_MASK    BIT0

+#define CM_FCLKEN_USBHOST_EN_USBHOST1_DISABLE (0UL << 0)

+#define CM_FCLKEN_USBHOST_EN_USBHOST1_ENABLE  BIT0

+

+#define CM_ICLKEN_USBHOST_EN_USBHOST_MASK     BIT0

+#define CM_ICLKEN_USBHOST_EN_USBHOST_DISABLE  (0UL << 0)

+#define CM_ICLKEN_USBHOST_EN_USBHOST_ENABLE   BIT0

+

+//Wakeup functional clock

+#define CM_FCLKEN_WKUP_EN_GPIO1_DISABLE       (0UL << 3)

+#define CM_FCLKEN_WKUP_EN_GPIO1_ENABLE        BIT3

+

+#define CM_FCLKEN_WKUP_EN_WDT2_DISABLE        (0UL << 5)

+#define CM_FCLKEN_WKUP_EN_WDT2_ENABLE         BIT5

+

+//Wakeup interface clock

+#define CM_ICLKEN_WKUP_EN_GPIO1_DISABLE       (0UL << 3)

+#define CM_ICLKEN_WKUP_EN_GPIO1_ENABLE        BIT3

+

+#define CM_ICLKEN_WKUP_EN_WDT2_DISABLE        (0UL << 5)

+#define CM_ICLKEN_WKUP_EN_WDT2_ENABLE         BIT5

+

+//Peripheral functional clock

+#define CM_FCLKEN_PER_EN_GPT3_DISABLE         (0UL << 4)

+#define CM_FCLKEN_PER_EN_GPT3_ENABLE          BIT4

+

+#define CM_FCLKEN_PER_EN_GPT4_DISABLE         (0UL << 5)

+#define CM_FCLKEN_PER_EN_GPT4_ENABLE          BIT5

+

+#define CM_FCLKEN_PER_EN_UART3_DISABLE        (0UL << 11)

+#define CM_FCLKEN_PER_EN_UART3_ENABLE         BIT11

+

+#define CM_FCLKEN_PER_EN_GPIO2_DISABLE        (0UL << 13)

+#define CM_FCLKEN_PER_EN_GPIO2_ENABLE         BIT13

+

+#define CM_FCLKEN_PER_EN_GPIO3_DISABLE        (0UL << 14)

+#define CM_FCLKEN_PER_EN_GPIO3_ENABLE         BIT14

+

+#define CM_FCLKEN_PER_EN_GPIO4_DISABLE        (0UL << 15)

+#define CM_FCLKEN_PER_EN_GPIO4_ENABLE         BIT15

+

+#define CM_FCLKEN_PER_EN_GPIO5_DISABLE        (0UL << 16)

+#define CM_FCLKEN_PER_EN_GPIO5_ENABLE         BIT16

+

+#define CM_FCLKEN_PER_EN_GPIO6_DISABLE        (0UL << 17)

+#define CM_FCLKEN_PER_EN_GPIO6_ENABLE         BIT17

+

+//Peripheral interface clock

+#define CM_ICLKEN_PER_EN_GPT3_DISABLE         (0UL << 4)

+#define CM_ICLKEN_PER_EN_GPT3_ENABLE          BIT4

+

+#define CM_ICLKEN_PER_EN_GPT4_DISABLE         (0UL << 5)

+#define CM_ICLKEN_PER_EN_GPT4_ENABLE          BIT5

+

+#define CM_ICLKEN_PER_EN_UART3_DISABLE        (0UL << 11)

+#define CM_ICLKEN_PER_EN_UART3_ENABLE         BIT11

+

+#define CM_ICLKEN_PER_EN_GPIO2_DISABLE        (0UL << 13)

+#define CM_ICLKEN_PER_EN_GPIO2_ENABLE         BIT13

+

+#define CM_ICLKEN_PER_EN_GPIO3_DISABLE        (0UL << 14)

+#define CM_ICLKEN_PER_EN_GPIO3_ENABLE         BIT14

+

+#define CM_ICLKEN_PER_EN_GPIO4_DISABLE        (0UL << 15)

+#define CM_ICLKEN_PER_EN_GPIO4_ENABLE         BIT15

+

+#define CM_ICLKEN_PER_EN_GPIO5_DISABLE        (0UL << 16)

+#define CM_ICLKEN_PER_EN_GPIO5_ENABLE         BIT16

+

+#define CM_ICLKEN_PER_EN_GPIO6_DISABLE        (0UL << 17)

+#define CM_ICLKEN_PER_EN_GPIO6_ENABLE         BIT17

+

+//Timer source clock selection

+#define CM_CLKSEL_PER_CLKSEL_GPT3_32K         (0UL << 1)

+#define CM_CLKSEL_PER_CLKSEL_GPT3_SYS         BIT1

+

+#define CM_CLKSEL_PER_CLKSEL_GPT4_32K         (0UL << 2)

+#define CM_CLKSEL_PER_CLKSEL_GPT4_SYS         BIT2

+

+//Reset management (Global and Cold reset)

+#define RST_GS            BIT1

+#define RST_DPLL3         BIT2

+#define GLOBAL_SW_RST     BIT1

+#define GLOBAL_COLD_RST   (0x0UL << 0)

+

+#endif // __OMAP3530PRCM_H__

+

diff --git a/Omap35xxPkg/Include/Omap3530/Omap3530Timer.h b/Omap35xxPkg/Include/Omap3530/Omap3530Timer.h
index 5067aaaf..d66da8dc 100644
--- a/Omap35xxPkg/Include/Omap3530/Omap3530Timer.h
+++ b/Omap35xxPkg/Include/Omap3530/Omap3530Timer.h
@@ -1,82 +1,82 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __OMAP3530TIMER_H__
-#define __OMAP3530TIMER_H__
-
-#define GPTIMER1_BASE   (0x48313000)
-#define GPTIMER2_BASE   (0x49032000)
-#define GPTIMER3_BASE   (0x49034000)
-#define GPTIMER4_BASE   (0x49036000)
-#define GPTIMER5_BASE   (0x49038000)
-#define GPTIMER6_BASE   (0x4903A000)
-#define GPTIMER7_BASE   (0x4903C000)
-#define GPTIMER8_BASE   (0x4903E000)
-#define GPTIMER9_BASE   (0x49040000)
-#define GPTIMER10_BASE  (0x48086000)
-#define GPTIMER11_BASE  (0x48088000)
-#define GPTIMER12_BASE  (0x48304000)
-#define WDTIMER2_BASE   (0x48314000)
-
-#define GPTIMER_TIOCP_CFG (0x0010)
-#define GPTIMER_TISTAT    (0x0014)
-#define GPTIMER_TISR      (0x0018)
-#define GPTIMER_TIER      (0x001C)
-#define GPTIMER_TWER      (0x0020)
-#define GPTIMER_TCLR      (0x0024)
-#define GPTIMER_TCRR      (0x0028)
-#define GPTIMER_TLDR      (0x002C)
-#define GPTIMER_TTGR      (0x0030)
-#define GPTIMER_TWPS      (0x0034)
-#define GPTIMER_TMAR      (0x0038)
-#define GPTIMER_TCAR1     (0x003C)
-#define GPTIMER_TSICR     (0x0040)
-#define GPTIMER_TCAR2     (0x0044)
-#define GPTIMER_TPIR      (0x0048)
-#define GPTIMER_TNIR      (0x004C)
-#define GPTIMER_TCVR      (0x0050)
-#define GPTIMER_TOCR      (0x0054)
-#define GPTIMER_TOWR      (0x0058)
-
-#define WSPR              (0x048)
-
-#define TISR_TCAR_IT_FLAG_MASK  BIT2
-#define TISR_OVF_IT_FLAG_MASK   BIT1
-#define TISR_MAT_IT_FLAG_MASK   BIT0
-#define TISR_ALL_INTERRUPT_MASK (TISR_TCAR_IT_FLAG_MASK | TISR_OVF_IT_FLAG_MASK | TISR_MAT_IT_FLAG_MASK)
-
-#define TISR_TCAR_IT_FLAG_NOT_PENDING   (0UL << 2)
-#define TISR_OVF_IT_FLAG_NOT_PENDING    (0UL << 1)
-#define TISR_MAT_IT_FLAG_NOT_PENDING    (0UL << 0)
-#define TISR_NO_INTERRUPTS_PENDING      (TISR_TCAR_IT_FLAG_NOT_PENDING | TISR_OVF_IT_FLAG_NOT_PENDING | TISR_MAT_IT_FLAG_NOT_PENDING)
-
-#define TISR_TCAR_IT_FLAG_CLEAR BIT2
-#define TISR_OVF_IT_FLAG_CLEAR  BIT1
-#define TISR_MAT_IT_FLAG_CLEAR  BIT0
-#define TISR_CLEAR_ALL          (TISR_TCAR_IT_FLAG_CLEAR | TISR_OVF_IT_FLAG_CLEAR | TISR_MAT_IT_FLAG_CLEAR)
-
-#define TCLR_AR_AUTORELOAD      BIT1
-#define TCLR_AR_ONESHOT         (0UL << 1)
-#define TCLR_ST_ON              BIT0
-#define TCLR_ST_OFF             (0UL << 0)
-
-#define TIER_TCAR_IT_ENABLE     (BIT2
-#define TIER_TCAR_IT_DISABLE    (0UL << 2)
-#define TIER_OVF_IT_ENABLE      BIT1
-#define TIER_OVF_IT_DISABLE     (0UL << 1)
-#define TIER_MAT_IT_ENABLE      BIT0
-#define TIER_MAT_IT_DISABLE     (0UL << 0)
-
-#endif // __OMAP3530TIMER_H__
-
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __OMAP3530TIMER_H__

+#define __OMAP3530TIMER_H__

+

+#define GPTIMER1_BASE   (0x48313000)

+#define GPTIMER2_BASE   (0x49032000)

+#define GPTIMER3_BASE   (0x49034000)

+#define GPTIMER4_BASE   (0x49036000)

+#define GPTIMER5_BASE   (0x49038000)

+#define GPTIMER6_BASE   (0x4903A000)

+#define GPTIMER7_BASE   (0x4903C000)

+#define GPTIMER8_BASE   (0x4903E000)

+#define GPTIMER9_BASE   (0x49040000)

+#define GPTIMER10_BASE  (0x48086000)

+#define GPTIMER11_BASE  (0x48088000)

+#define GPTIMER12_BASE  (0x48304000)

+#define WDTIMER2_BASE   (0x48314000)

+

+#define GPTIMER_TIOCP_CFG (0x0010)

+#define GPTIMER_TISTAT    (0x0014)

+#define GPTIMER_TISR      (0x0018)

+#define GPTIMER_TIER      (0x001C)

+#define GPTIMER_TWER      (0x0020)

+#define GPTIMER_TCLR      (0x0024)

+#define GPTIMER_TCRR      (0x0028)

+#define GPTIMER_TLDR      (0x002C)

+#define GPTIMER_TTGR      (0x0030)

+#define GPTIMER_TWPS      (0x0034)

+#define GPTIMER_TMAR      (0x0038)

+#define GPTIMER_TCAR1     (0x003C)

+#define GPTIMER_TSICR     (0x0040)

+#define GPTIMER_TCAR2     (0x0044)

+#define GPTIMER_TPIR      (0x0048)

+#define GPTIMER_TNIR      (0x004C)

+#define GPTIMER_TCVR      (0x0050)

+#define GPTIMER_TOCR      (0x0054)

+#define GPTIMER_TOWR      (0x0058)

+

+#define WSPR              (0x048)

+

+#define TISR_TCAR_IT_FLAG_MASK  BIT2

+#define TISR_OVF_IT_FLAG_MASK   BIT1

+#define TISR_MAT_IT_FLAG_MASK   BIT0

+#define TISR_ALL_INTERRUPT_MASK (TISR_TCAR_IT_FLAG_MASK | TISR_OVF_IT_FLAG_MASK | TISR_MAT_IT_FLAG_MASK)

+

+#define TISR_TCAR_IT_FLAG_NOT_PENDING   (0UL << 2)

+#define TISR_OVF_IT_FLAG_NOT_PENDING    (0UL << 1)

+#define TISR_MAT_IT_FLAG_NOT_PENDING    (0UL << 0)

+#define TISR_NO_INTERRUPTS_PENDING      (TISR_TCAR_IT_FLAG_NOT_PENDING | TISR_OVF_IT_FLAG_NOT_PENDING | TISR_MAT_IT_FLAG_NOT_PENDING)

+

+#define TISR_TCAR_IT_FLAG_CLEAR BIT2

+#define TISR_OVF_IT_FLAG_CLEAR  BIT1

+#define TISR_MAT_IT_FLAG_CLEAR  BIT0

+#define TISR_CLEAR_ALL          (TISR_TCAR_IT_FLAG_CLEAR | TISR_OVF_IT_FLAG_CLEAR | TISR_MAT_IT_FLAG_CLEAR)

+

+#define TCLR_AR_AUTORELOAD      BIT1

+#define TCLR_AR_ONESHOT         (0UL << 1)

+#define TCLR_ST_ON              BIT0

+#define TCLR_ST_OFF             (0UL << 0)

+

+#define TIER_TCAR_IT_ENABLE     (BIT2

+#define TIER_TCAR_IT_DISABLE    (0UL << 2)

+#define TIER_OVF_IT_ENABLE      BIT1

+#define TIER_OVF_IT_DISABLE     (0UL << 1)

+#define TIER_MAT_IT_ENABLE      BIT0

+#define TIER_MAT_IT_DISABLE     (0UL << 0)

+

+#endif // __OMAP3530TIMER_H__

+

diff --git a/Omap35xxPkg/Include/Omap3530/Omap3530Usb.h b/Omap35xxPkg/Include/Omap3530/Omap3530Usb.h
index 9cc17ebf..5d64cafc 100644
--- a/Omap35xxPkg/Include/Omap3530/Omap3530Usb.h
+++ b/Omap35xxPkg/Include/Omap3530/Omap3530Usb.h
@@ -1,48 +1,48 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __OMAP3530USB_H__
-#define __OMAP3530USB_H__
-
-#define USB_BASE            (0x48060000)
-
-#define UHH_SYSCONFIG       (USB_BASE + 0x4010)
-#define UHH_HOSTCONFIG      (USB_BASE + 0x4040)
-#define UHH_SYSSTATUS       (USB_BASE + 0x4014)
-
-#define USB_EHCI_HCCAPBASE  (USB_BASE + 0x4800)
-
-#define UHH_SYSCONFIG_MIDLEMODE_NO_STANDBY  BIT12
-#define UHH_SYSCONFIG_CLOCKACTIVITY_ON      BIT8
-#define UHH_SYSCONFIG_SIDLEMODE_NO_STANDBY  BIT3
-#define UHH_SYSCONFIG_ENAWAKEUP_ENABLE      BIT2
-#define UHH_SYSCONFIG_SOFTRESET             BIT1
-#define UHH_SYSCONFIG_AUTOIDLE_ALWAYS_RUN   (0UL <<  0)
-
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __OMAP3530USB_H__

+#define __OMAP3530USB_H__

+

+#define USB_BASE            (0x48060000)

+

+#define UHH_SYSCONFIG       (USB_BASE + 0x4010)

+#define UHH_HOSTCONFIG      (USB_BASE + 0x4040)

+#define UHH_SYSSTATUS       (USB_BASE + 0x4014)

+

+#define USB_EHCI_HCCAPBASE  (USB_BASE + 0x4800)

+

+#define UHH_SYSCONFIG_MIDLEMODE_NO_STANDBY  BIT12

+#define UHH_SYSCONFIG_CLOCKACTIVITY_ON      BIT8

+#define UHH_SYSCONFIG_SIDLEMODE_NO_STANDBY  BIT3

+#define UHH_SYSCONFIG_ENAWAKEUP_ENABLE      BIT2

+#define UHH_SYSCONFIG_SOFTRESET             BIT1

+#define UHH_SYSCONFIG_AUTOIDLE_ALWAYS_RUN   (0UL <<  0)

+

 #define UHH_HOSTCONFIG_P3_CONNECT_STATUS_DISCONNECT (0UL << 10)

 #define UHH_HOSTCONFIG_P2_CONNECT_STATUS_DISCONNECT (0UL <<  9)

 #define UHH_HOSTCONFIG_P1_CONNECT_STATUS_DISCONNECT (0UL <<  8)

 #define UHH_HOSTCONFIG_ENA_INCR_ALIGN_DISABLE       (0UL <<  5)

-#define UHH_HOSTCONFIG_ENA_INCR16_ENABLE            BIT4
-#define UHH_HOSTCONFIG_ENA_INCR8_ENABLE             BIT3
-#define UHH_HOSTCONFIG_ENA_INCR4_ENABLE             BIT2
+#define UHH_HOSTCONFIG_ENA_INCR16_ENABLE            BIT4

+#define UHH_HOSTCONFIG_ENA_INCR8_ENABLE             BIT3

+#define UHH_HOSTCONFIG_ENA_INCR4_ENABLE             BIT2

 #define UHH_HOSTCONFIG_AUTOPPD_ON_OVERCUR_EN_ON     (0UL <<  1)

-#define UHH_HOSTCONFIG_P1_ULPI_BYPASS_ULPI_MODE     (0UL <<  0)
-
-#define UHH_SYSSTATUS_RESETDONE                (BIT0 | BIT1 | BIT2)
-
-#endif // __OMAP3530USB_H__
-
-
-
+#define UHH_HOSTCONFIG_P1_ULPI_BYPASS_ULPI_MODE     (0UL <<  0)

+

+#define UHH_SYSSTATUS_RESETDONE                (BIT0 | BIT1 | BIT2)

+

+#endif // __OMAP3530USB_H__

+

+

+

diff --git a/Omap35xxPkg/Include/TPS65950.h b/Omap35xxPkg/Include/TPS65950.h
index cd708d97..20df2319 100644
--- a/Omap35xxPkg/Include/TPS65950.h
+++ b/Omap35xxPkg/Include/TPS65950.h
@@ -1,80 +1,80 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __TPS65950_H__
-#define __TPS65950_H__
-
-#define EXTERNAL_DEVICE_REGISTER_TO_SLAVE_ADDRESS(x)     (((x) >> 8) & 0xFF)
-#define EXTERNAL_DEVICE_REGISTER_TO_REGISTER(x)          ((x) & 0xFF)
-#define EXTERNAL_DEVICE_REGISTER(SlaveAddress, Register) (((SlaveAddress) & 0xFF) << 8 | ((Register) & 0xFF))
-
-// I2C Address group
-#define I2C_ADDR_GRP_ID1      0x48
-#define I2C_ADDR_GRP_ID2      0x49
-#define I2C_ADDR_GRP_ID3      0x4A
-#define I2C_ADDR_GRP_ID4      0x4B
-#define I2C_ADDR_GRP_ID5      0x12
-
-// MMC definitions.
-#define VMMC1_DEV_GRP         0x82
-#define DEV_GRP_P1            BIT5
-
-#define VMMC1_DEDICATED_REG   0x85 
-#define VSEL_1_85V            0x0
-#define VSEL_2_85V            0x1
-#define VSEL_3_00V            0x2
-#define VSEL_3_15V            0x3
-
-#define TPS65950_GPIO_CTRL    0xaa  //I2C_ADDR_GRP_ID2
-#define CARD_DETECT_ENABLE    (BIT2 | BIT0) // GPIO ON + GPIO CD1 enabled
-
-
-#define GPIODATAIN1           0x98  //I2C_ADDR_GRP_ID2
-#define CARD_DETECT_BIT       BIT0
-
-// LEDEN register
-#define LEDEN                 0xEE
-#define LEDAON                BIT0
-#define LEDBON                BIT1
-#define LEDAPWM               BIT4
-#define LEDBPWM               BIT5
-
-// RTC registers
-#define SECONDS_REG           0x1C
-#define MINUTES_REG           0x1D
-#define HOURS_REG             0x1E
-#define DAYS_REG              0x1F
-#define MONTHS_REG            0x20
-#define YEARS_REG             0x21
-#define WEEKS_REG             0x22
-#define RTC_CTRL_REG          0x29
-
-// USB PHY power
-#define VAUX2_DEDICATED       0x79
-#define VAUX2_DEV_GRP         0x76
-
-#define VAUX_DEV_GRP_NONE     0x00
-#define VAUX_DEV_GRP_P1       0x20
-#define VAUX_DEV_GRP_P2       0x40
-#define VAUX_DEV_GRP_P3       0x80
-#define VAUX_DEDICATED_18V    0x05
-
-// Display subsystem
-#define VPLL2_DEDICATED       0x91
-#define VPLL2_DEV_GRP         0x8E
-
-#define GPIODATADIR1          0x9B
-#define SETGPIODATAOUT1       0xA4
-
-#endif //__TPS65950_H__
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __TPS65950_H__

+#define __TPS65950_H__

+

+#define EXTERNAL_DEVICE_REGISTER_TO_SLAVE_ADDRESS(x)     (((x) >> 8) & 0xFF)

+#define EXTERNAL_DEVICE_REGISTER_TO_REGISTER(x)          ((x) & 0xFF)

+#define EXTERNAL_DEVICE_REGISTER(SlaveAddress, Register) (((SlaveAddress) & 0xFF) << 8 | ((Register) & 0xFF))

+

+// I2C Address group

+#define I2C_ADDR_GRP_ID1      0x48

+#define I2C_ADDR_GRP_ID2      0x49

+#define I2C_ADDR_GRP_ID3      0x4A

+#define I2C_ADDR_GRP_ID4      0x4B

+#define I2C_ADDR_GRP_ID5      0x12

+

+// MMC definitions.

+#define VMMC1_DEV_GRP         0x82

+#define DEV_GRP_P1            BIT5

+

+#define VMMC1_DEDICATED_REG   0x85 

+#define VSEL_1_85V            0x0

+#define VSEL_2_85V            0x1

+#define VSEL_3_00V            0x2

+#define VSEL_3_15V            0x3

+

+#define TPS65950_GPIO_CTRL    0xaa  //I2C_ADDR_GRP_ID2

+#define CARD_DETECT_ENABLE    (BIT2 | BIT0) // GPIO ON + GPIO CD1 enabled

+

+

+#define GPIODATAIN1           0x98  //I2C_ADDR_GRP_ID2

+#define CARD_DETECT_BIT       BIT0

+

+// LEDEN register

+#define LEDEN                 0xEE

+#define LEDAON                BIT0

+#define LEDBON                BIT1

+#define LEDAPWM               BIT4

+#define LEDBPWM               BIT5

+

+// RTC registers

+#define SECONDS_REG           0x1C

+#define MINUTES_REG           0x1D

+#define HOURS_REG             0x1E

+#define DAYS_REG              0x1F

+#define MONTHS_REG            0x20

+#define YEARS_REG             0x21

+#define WEEKS_REG             0x22

+#define RTC_CTRL_REG          0x29

+

+// USB PHY power

+#define VAUX2_DEDICATED       0x79

+#define VAUX2_DEV_GRP         0x76

+

+#define VAUX_DEV_GRP_NONE     0x00

+#define VAUX_DEV_GRP_P1       0x20

+#define VAUX_DEV_GRP_P2       0x40

+#define VAUX_DEV_GRP_P3       0x80

+#define VAUX_DEDICATED_18V    0x05

+

+// Display subsystem

+#define VPLL2_DEDICATED       0x91

+#define VPLL2_DEV_GRP         0x8E

+

+#define GPIODATADIR1          0x9B

+#define SETGPIODATAOUT1       0xA4

+

+#endif //__TPS65950_H__

diff --git a/Omap35xxPkg/LcdGraphicsOutputDxe/LcdGraphicsOutputBlt.c b/Omap35xxPkg/LcdGraphicsOutputDxe/LcdGraphicsOutputBlt.c
index 38c84dd8..9541e7e9 100644
--- a/Omap35xxPkg/LcdGraphicsOutputDxe/LcdGraphicsOutputBlt.c
+++ b/Omap35xxPkg/LcdGraphicsOutputDxe/LcdGraphicsOutputBlt.c
@@ -1,445 +1,445 @@
-/** @file
-
- Copyright (c) 2011, ARM Ltd. All rights reserved.<BR>
- This program and the accompanying materials
- are licensed and made available under the terms and conditions of the BSD License
- which accompanies this distribution.  The full text of the license may be found at
- http://opensource.org/licenses/bsd-license.php
-
- THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
- WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
- **/
-
-#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 = EFI_SUCCESS;
-  UINTN         SourceLine;
-  UINTN         DestinationLine;
-  UINTN         WidthInBytes;
-  UINTN         LineCount;
-  INTN          Step;
-  VOID          *SourceAddr;
-  VOID          *DestinationAddr;
-
-  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;
-  }
-
-  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;
-  }
-
-  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 = EFI_SUCCESS;
-
-  UINT16 *PixelBuffer16bit;
-  UINT16 *SourcePixel16bit;
-  UINT16 *DestinationPixel16bit;
-
-  UINT32          SourcePixelY;
-  UINT32          DestinationPixelY;
-  UINTN           SizeIn16Bits;
-
-  // 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);
-
-
-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;
-  VOID                *FrameBufferBase;
-  UINT16              *DestinationPixel16bit;
-  UINT16              Pixel16bit;
-  UINT32              DestinationPixelX;
-  UINT32              DestinationLine;
-
-  Status           = EFI_SUCCESS;
-  PixelInformation = &This->Mode->Info->PixelInformation;
-  FrameBufferBase = (UINTN *)((UINTN)(This->Mode->FrameBufferBase));
-  HorizontalResolution = This->Mode->Info->HorizontalResolution;
-
-  // 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;
-    }
-  }
-
-
-  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;
-  EFI_PIXEL_BITMASK  *PixelInformation;
-  EFI_GRAPHICS_OUTPUT_BLT_PIXEL *EfiDestinationPixel;
-  VOID               *FrameBufferBase;
-  UINT16             *SourcePixel16bit;
-  UINT16             Pixel16bit;
-  UINT32             SourcePixelX;
-  UINT32             SourceLine;
-  UINT32             DestinationPixelX;
-  UINT32             DestinationLine;
-  UINT32             BltBufferHorizontalResolution;
-
-  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;
-  }
-
-  // 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     ) >>  8 );
-      EfiDestinationPixel->Green    = (UINT8) ( (Pixel16bit & PixelInformation->GreenMask   ) >>  3 );
-      EfiDestinationPixel->Blue     = (UINT8) ( (Pixel16bit & PixelInformation->BlueMask    ) <<  3 );
-    }
-  }
-
-  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;
-  EFI_PIXEL_BITMASK  *PixelInformation;
-  EFI_GRAPHICS_OUTPUT_BLT_PIXEL *EfiSourcePixel;
-  VOID               *FrameBufferBase;
-  UINT16             *DestinationPixel16bit;
-  UINT32             SourcePixelX;
-  UINT32             SourceLine;
-  UINT32             DestinationPixelX;
-  UINT32             DestinationLine;
-  UINT32             BltBufferHorizontalResolution;
-
-  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;
-  }
-
-  // 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      <<  8) & PixelInformation->RedMask      )
-            | ( (EfiSourcePixel->Green    <<  3) & PixelInformation->GreenMask    )
-            | ( (EfiSourcePixel->Blue     >>  3) & PixelInformation->BlueMask     )
-            );
-      }
-    }
-   
-  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;
-  UINTN              BitsPerPixel;
-  VOID               *FrameBufferBase;
-
-  BitsPerPixel = 16;
-
-  HorizontalResolution = This->Mode->Info->HorizontalResolution;
-  FrameBufferBase = (UINTN *)((UINTN)(This->Mode->FrameBufferBase));
-
-  //
-  // BltVideo to BltVideo:
-  //
-  //  Source is the Video Memory,
-  //  Destination is the Video Memory
-
-  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;
-}
-
-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;
-	LCD_INSTANCE  *Instance;
-
-	Instance = LCD_INSTANCE_FROM_GOP_THIS(This);
-
-  if (!mDisplayInitialized) {
-    InitializeDisplay (Instance);
-  }
-  
-  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;
-	}
-
-  return Status;
-}
+/** @file

+

+ Copyright (c) 2011, ARM Ltd. All rights reserved.<BR>

+ This program and the accompanying materials

+ are licensed and made available under the terms and conditions of the BSD License

+ which accompanies this distribution.  The full text of the license may be found at

+ http://opensource.org/licenses/bsd-license.php

+

+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+ **/

+

+#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 = EFI_SUCCESS;

+  UINTN         SourceLine;

+  UINTN         DestinationLine;

+  UINTN         WidthInBytes;

+  UINTN         LineCount;

+  INTN          Step;

+  VOID          *SourceAddr;

+  VOID          *DestinationAddr;

+

+  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;

+  }

+

+  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;

+  }

+

+  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 = EFI_SUCCESS;

+

+  UINT16 *PixelBuffer16bit;

+  UINT16 *SourcePixel16bit;

+  UINT16 *DestinationPixel16bit;

+

+  UINT32          SourcePixelY;

+  UINT32          DestinationPixelY;

+  UINTN           SizeIn16Bits;

+

+  // 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);

+

+

+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;

+  VOID                *FrameBufferBase;

+  UINT16              *DestinationPixel16bit;

+  UINT16              Pixel16bit;

+  UINT32              DestinationPixelX;

+  UINT32              DestinationLine;

+

+  Status           = EFI_SUCCESS;

+  PixelInformation = &This->Mode->Info->PixelInformation;

+  FrameBufferBase = (UINTN *)((UINTN)(This->Mode->FrameBufferBase));

+  HorizontalResolution = This->Mode->Info->HorizontalResolution;

+

+  // 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;

+    }

+  }

+

+

+  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;

+  EFI_PIXEL_BITMASK  *PixelInformation;

+  EFI_GRAPHICS_OUTPUT_BLT_PIXEL *EfiDestinationPixel;

+  VOID               *FrameBufferBase;

+  UINT16             *SourcePixel16bit;

+  UINT16             Pixel16bit;

+  UINT32             SourcePixelX;

+  UINT32             SourceLine;

+  UINT32             DestinationPixelX;

+  UINT32             DestinationLine;

+  UINT32             BltBufferHorizontalResolution;

+

+  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;

+  }

+

+  // 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     ) >>  8 );

+      EfiDestinationPixel->Green    = (UINT8) ( (Pixel16bit & PixelInformation->GreenMask   ) >>  3 );

+      EfiDestinationPixel->Blue     = (UINT8) ( (Pixel16bit & PixelInformation->BlueMask    ) <<  3 );

+    }

+  }

+

+  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;

+  EFI_PIXEL_BITMASK  *PixelInformation;

+  EFI_GRAPHICS_OUTPUT_BLT_PIXEL *EfiSourcePixel;

+  VOID               *FrameBufferBase;

+  UINT16             *DestinationPixel16bit;

+  UINT32             SourcePixelX;

+  UINT32             SourceLine;

+  UINT32             DestinationPixelX;

+  UINT32             DestinationLine;

+  UINT32             BltBufferHorizontalResolution;

+

+  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;

+  }

+

+  // 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      <<  8) & PixelInformation->RedMask      )

+            | ( (EfiSourcePixel->Green    <<  3) & PixelInformation->GreenMask    )

+            | ( (EfiSourcePixel->Blue     >>  3) & PixelInformation->BlueMask     )

+            );

+      }

+    }

+   

+  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;

+  UINTN              BitsPerPixel;

+  VOID               *FrameBufferBase;

+

+  BitsPerPixel = 16;

+

+  HorizontalResolution = This->Mode->Info->HorizontalResolution;

+  FrameBufferBase = (UINTN *)((UINTN)(This->Mode->FrameBufferBase));

+

+  //

+  // BltVideo to BltVideo:

+  //

+  //  Source is the Video Memory,

+  //  Destination is the Video Memory

+

+  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;

+}

+

+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;

+	LCD_INSTANCE  *Instance;

+

+	Instance = LCD_INSTANCE_FROM_GOP_THIS(This);

+

+  if (!mDisplayInitialized) {

+    InitializeDisplay (Instance);

+  }

+  

+  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;

+	}

+

+  return Status;

+}

diff --git a/Omap35xxPkg/LcdGraphicsOutputDxe/LcdGraphicsOutputDxe.c b/Omap35xxPkg/LcdGraphicsOutputDxe/LcdGraphicsOutputDxe.c
index 6c20575c..e30a679d 100644
--- a/Omap35xxPkg/LcdGraphicsOutputDxe/LcdGraphicsOutputDxe.c
+++ b/Omap35xxPkg/LcdGraphicsOutputDxe/LcdGraphicsOutputDxe.c
@@ -1,403 +1,403 @@
-/** @file
-
- Copyright (c) 2011, ARM Ltd. All rights reserved.<BR>
- This program and the accompanying materials
- are licensed and made available under the terms and conditions of the BSD License
- which accompanies this distribution.  The full text of the license may be found at
- http://opensource.org/licenses/bsd-license.php
-
- THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
- WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include "LcdGraphicsOutputDxe.h"
-
-BOOLEAN mDisplayInitialized = FALSE;
-
-LCD_MODE LcdModes[] = {
-  {
-    0, 640, 480,
-    9, 4,
-    96, 16, 48,
-    2, 10, 33
-  },
-  {
-    1, 800, 600,
-    11, 2,
-    120, 56, 64,
-    5, 37, 22
-  },
-  {
-    2, 1024, 768,
-    6, 2,
-    96, 16, 48,
-    2, 10, 33
-  },
-};
-
-LCD_INSTANCE mLcdTemplate = {
-  LCD_INSTANCE_SIGNATURE,
-  NULL, // Handle
-  { // ModeInfo
-    0, // Version
-    0, // HorizontalResolution
-    0, // VerticalResolution
-    PixelBltOnly, // PixelFormat
-    {
-      0xF800, //RedMask;
-      0x7E0, //GreenMask;
-      0x1F, //BlueMask;
-      0x0//ReservedMask
-    }, // PixelInformation
-    0, // PixelsPerScanLine
-  },
-  { // Mode
-    3, // MaxMode;
-    0, // Mode;
-    NULL, // Info;
-    0, // SizeOfInfo;
-    0, // FrameBufferBase;
-    0 // FrameBufferSize;
-  },
-  { // Gop
-    LcdGraphicsQueryMode,  // QueryMode
-    LcdGraphicsSetMode,    // SetMode
-    LcdGraphicsBlt,        // Blt
-    NULL                     // *Mode
-  },
-  { // DevicePath
-    {
-      {
-        HARDWARE_DEVICE_PATH, HW_VENDOR_DP,
-        (UINT8) (sizeof(VENDOR_DEVICE_PATH)),
-        (UINT8) ((sizeof(VENDOR_DEVICE_PATH)) >> 8),
-      },
-      // Hardware Device Path for Lcd
-      EFI_CALLER_ID_GUID // Use the driver's GUID
-    },
-
-    {
-      END_DEVICE_PATH_TYPE,
-      END_ENTIRE_DEVICE_PATH_SUBTYPE,
-      sizeof(EFI_DEVICE_PATH_PROTOCOL),
-      0
-    }
-  }
-};
-
-EFI_STATUS
-LcdInstanceContructor (
-  OUT LCD_INSTANCE** NewInstance
-  )
-{
-  LCD_INSTANCE* Instance;
-
-  Instance = AllocateCopyPool (sizeof(LCD_INSTANCE), &mLcdTemplate);
-  if (Instance == NULL) {
-    return EFI_OUT_OF_RESOURCES;
-  }
-
-  Instance->Gop.Mode          = &Instance->Mode;
-  Instance->Mode.Info         = &Instance->ModeInfo;
-
-  *NewInstance = Instance;
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-LcdPlatformGetVram (
-  OUT EFI_PHYSICAL_ADDRESS*  VramBaseAddress,
-  OUT UINTN*                 VramSize
-  )
-{
-  EFI_STATUS             Status;
-  EFI_CPU_ARCH_PROTOCOL  *Cpu;
-  UINTN                  MaxSize;
-
-  MaxSize = 0x500000;
-  *VramSize = MaxSize;
-
-  // Allocate VRAM from DRAM
-  Status = gBS->AllocatePages (AllocateAnyPages, EfiBootServicesData, EFI_SIZE_TO_PAGES((MaxSize)), VramBaseAddress);
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  // Ensure the Cpu architectural protocol is already installed
-  Status = gBS->LocateProtocol (&gEfiCpuArchProtocolGuid, NULL, (VOID **)&Cpu);
-  ASSERT_EFI_ERROR(Status);
-
-  // Mark the VRAM as un-cacheable. The VRAM is inside the DRAM, which is cacheable.
-  Status = Cpu->SetMemoryAttributes (Cpu, *VramBaseAddress, *VramSize, EFI_MEMORY_UC);
-  if (EFI_ERROR(Status)) {
-    gBS->FreePool (VramBaseAddress);
-    return Status;
-  }
-
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-DssSetMode (
-  UINT32 VramBaseAddress,
-  UINTN  ModeNumber
-  )
-{
-  // Make sure the interface clock is running
-  MmioWrite32 (CM_ICLKEN_DSS, EN_DSS);  
-
-  // Stop the functional clocks
-  MmioAnd32 (CM_FCLKEN_DSS, ~(EN_DSS1 | EN_DSS2 | EN_TV));
-
-  // Program the DSS clock divisor
-  MmioWrite32 (CM_CLKSEL_DSS, 0x1000 | (LcdModes[ModeNumber].DssDivisor));
-  
-  // Start the functional clocks
-  MmioOr32 (CM_FCLKEN_DSS, (EN_DSS1 | EN_DSS2 | EN_TV));
-
-  // Wait for DSS to stabilize
-  gBS->Stall(1);
-
-  // Reset the subsystem
-  MmioWrite32(DSS_SYSCONFIG, DSS_SOFTRESET);
-  while (!(MmioRead32 (DSS_SYSSTATUS) & DSS_RESETDONE));
-  
-  // Configure LCD parameters
-  MmioWrite32 (DISPC_SIZE_LCD,
-               ((LcdModes[ModeNumber].HorizontalResolution - 1) 
-               | ((LcdModes[ModeNumber].VerticalResolution - 1) << 16))
-              );
-  MmioWrite32 (DISPC_TIMING_H,
-               ( (LcdModes[ModeNumber].HSync - 1)
-               | ((LcdModes[ModeNumber].HFrontPorch - 1) << 8)
-               | ((LcdModes[ModeNumber].HBackPorch - 1) << 20))
-              );
-  MmioWrite32 (DISPC_TIMING_V,
-               ( (LcdModes[ModeNumber].VSync - 1)
-               | ((LcdModes[ModeNumber].VFrontPorch - 1) << 8)
-               | ((LcdModes[ModeNumber].VBackPorch - 1) << 20))
-              );
-
-  // Set the framebuffer to only load frames (no gamma tables)
-  MmioAnd32 (DISPC_CONFIG, CLEARLOADMODE);
-  MmioOr32  (DISPC_CONFIG, LOAD_FRAME_ONLY);
-
-  // Divisor for the pixel clock
-  MmioWrite32(DISPC_DIVISOR, ((1 << 16) | LcdModes[ModeNumber].DispcDivisor) );
-
-  // Set up the graphics layer
-  MmioWrite32 (DISPC_GFX_PRELD, 0x2D8);
-  MmioWrite32 (DISPC_GFX_BA0, VramBaseAddress);
-  MmioWrite32 (DISPC_GFX_SIZE,
-               ((LcdModes[ModeNumber].HorizontalResolution - 1) 
-               | ((LcdModes[ModeNumber].VerticalResolution - 1) << 16))
-              );
-
-  MmioWrite32(DISPC_GFX_ATTR, (GFXENABLE | RGB16 | BURSTSIZE16));
-
-  // Start it all
-  MmioOr32 (DISPC_CONTROL, (LCDENABLE | ACTIVEMATRIX | DATALINES24 | BYPASS_MODE | LCDENABLESIGNAL));
-  MmioOr32 (DISPC_CONTROL, GOLCD);
-
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-HwInitializeDisplay (
-  UINTN VramBaseAddress,
-  UINTN VramSize
-  )
-{
-  EFI_STATUS    Status;
-  UINT8         Data;
-  EFI_TPL       OldTpl;
-  EMBEDDED_EXTERNAL_DEVICE   *gTPS65950;
-
-  // Enable power lines used by TFP410
-  Status = gBS->LocateProtocol (&gEmbeddedExternalDeviceProtocolGuid, NULL, (VOID **)&gTPS65950);
-  ASSERT_EFI_ERROR (Status);  
-
-  OldTpl = gBS->RaiseTPL(TPL_NOTIFY);
-  Data = VAUX_DEV_GRP_P1;
-  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VPLL2_DEV_GRP), 1, &Data);
-  ASSERT_EFI_ERROR(Status);
-
-  Data = VAUX_DEDICATED_18V;
-  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VPLL2_DEDICATED), 1, &Data);
-  ASSERT_EFI_ERROR (Status);  
-
-  // Power up TFP410 (set GPIO2 on TPS - for BeagleBoard-xM)
-  Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, GPIODATADIR1), 1, &Data);
-  ASSERT_EFI_ERROR (Status);
-  Data |= BIT2;
-  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, GPIODATADIR1), 1, &Data);
-  ASSERT_EFI_ERROR (Status);
-
-  Data = BIT2;
-  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, SETGPIODATAOUT1), 1, &Data);
-  ASSERT_EFI_ERROR (Status);
-
-  gBS->RestoreTPL(OldTpl);
-
-  // Power up TFP410 (set GPIO 170 - for older BeagleBoards)
-  MmioAnd32 (GPIO6_BASE + GPIO_OE, ~BIT10);
-  MmioOr32  (GPIO6_BASE + GPIO_SETDATAOUT, BIT10);  
-
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-InitializeDisplay (
-  IN LCD_INSTANCE* Instance
-  )
-{
-  EFI_STATUS           Status; 
-  UINTN                VramSize;
-  EFI_PHYSICAL_ADDRESS VramBaseAddress;
-
-  Status = LcdPlatformGetVram (&VramBaseAddress, &VramSize);
-  if (EFI_ERROR (Status)) {
-    return Status;
-  }
-
-  Instance->Mode.FrameBufferBase = VramBaseAddress;
-  Instance->Mode.FrameBufferSize = VramSize;
-
-  Status = HwInitializeDisplay((UINTN)VramBaseAddress, VramSize);
-  if (!EFI_ERROR (Status)) {
-    mDisplayInitialized = TRUE;
-  }
-
-  return Status;
-}
-
-EFI_STATUS
-EFIAPI
-LcdGraphicsQueryMode (
-  IN EFI_GRAPHICS_OUTPUT_PROTOCOL            *This,
-	IN UINT32                                  ModeNumber,
-	OUT UINTN                                  *SizeOfInfo,
-	OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION   **Info
-	)
-{
-	LCD_INSTANCE  *Instance;
-
-	Instance = LCD_INSTANCE_FROM_GOP_THIS(This);
-
-  if (!mDisplayInitialized) {
-    InitializeDisplay (Instance);
-  }
-
-  // Error checking
-	if ( (This == NULL) || (Info == NULL) || (SizeOfInfo == NULL) || (ModeNumber >= This->Mode->MaxMode) ) {
-	  DEBUG((DEBUG_ERROR, "LcdGraphicsQueryMode: ERROR - For mode number %d : Invalid Parameter.\n", ModeNumber ));
-		return EFI_INVALID_PARAMETER;
-	}
-
-  *Info = AllocateCopyPool(sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION), &Instance->ModeInfo);
-  if (*Info == NULL) {
-    return EFI_OUT_OF_RESOURCES;
-  }
-
-  *SizeOfInfo = sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);
-
-  (*Info)->Version = 0;
-  (*Info)->HorizontalResolution = LcdModes[ModeNumber].HorizontalResolution;
-  (*Info)->VerticalResolution = LcdModes[ModeNumber].VerticalResolution;
-  (*Info)->PixelFormat = PixelBltOnly;
-
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-EFIAPI
-LcdGraphicsSetMode (
-  IN EFI_GRAPHICS_OUTPUT_PROTOCOL   *This,
-	IN UINT32                         ModeNumber
-	)
-{
-	LCD_INSTANCE  *Instance;
-
-	Instance = LCD_INSTANCE_FROM_GOP_THIS(This);
-
-  if (ModeNumber >= Instance->Mode.MaxMode) {
-    return EFI_UNSUPPORTED;
-  }
-
-  if (!mDisplayInitialized) {
-    InitializeDisplay (Instance);
-  }
-
-  DssSetMode((UINT32)Instance->Mode.FrameBufferBase, ModeNumber);
-
-  Instance->Mode.Mode = ModeNumber;
-  Instance->ModeInfo.HorizontalResolution = LcdModes[ModeNumber].HorizontalResolution;
-  Instance->ModeInfo.VerticalResolution = LcdModes[ModeNumber].VerticalResolution;
-
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-EFIAPI
-LcdGraphicsOutputDxeInitialize (
-  IN EFI_HANDLE         ImageHandle,
-  IN EFI_SYSTEM_TABLE   *SystemTable
-  )
-{
-  EFI_STATUS Status = EFI_SUCCESS;
-  LCD_INSTANCE* Instance;
-
-  Status = LcdInstanceContructor (&Instance);
-  if (EFI_ERROR(Status)) {
-    goto EXIT;
-  }
-
-	// Install the Graphics Output Protocol and the Device Path
-	Status = gBS->InstallMultipleProtocolInterfaces(
-			&Instance->Handle,
-			&gEfiGraphicsOutputProtocolGuid, &Instance->Gop,
-			&gEfiDevicePathProtocolGuid,     &Instance->DevicePath,
-			NULL
-	   );
-
-	if (EFI_ERROR(Status)) {
-	  DEBUG((DEBUG_ERROR, "GraphicsOutputDxeInitialize: Can not install the protocol. Exit Status=%r\n", Status));
-		goto EXIT;
-	}
-
-  // Register for an ExitBootServicesEvent
-	// When ExitBootServices starts, this function here will make sure that the graphics driver will shut down properly,
-	// i.e. it will free up all allocated memory and perform any necessary hardware re-configuration.
-	/*Status = gBS->CreateEvent (
-	    EVT_SIGNAL_EXIT_BOOT_SERVICES,
-	    TPL_NOTIFY,
-	    LcdGraphicsExitBootServicesEvent, NULL,
-			&Instance->ExitBootServicesEvent
-			);
-
-	if (EFI_ERROR(Status)) {
-	  DEBUG((DEBUG_ERROR, "GraphicsOutputDxeInitialize: Can not install the ExitBootServicesEvent handler. Exit Status=%r\n", Status));
-		goto EXIT_ERROR_UNINSTALL_PROTOCOL;
-	}*/
-
-	// To get here, everything must be fine, so just exit
-	goto EXIT;
-
-//EXIT_ERROR_UNINSTALL_PROTOCOL:
-	/* The following function could return an error message,
-	 * however, to get here something must have gone wrong already,
-	 * so preserve the original error, i.e. don't change
-	 * the Status variable, even it fails to uninstall the protocol.
-	 */
-/*	gBS->UninstallMultipleProtocolInterfaces (
-	    Instance->Handle,
-	    &gEfiGraphicsOutputProtocolGuid, &Instance->Gop, // Uninstall Graphics Output protocol
-	    &gEfiDevicePathProtocolGuid,     &Instance->DevicePath,     // Uninstall device path
-	    NULL
-	    );*/
-
-EXIT:
-	return Status;
-
-}
+/** @file

+

+ Copyright (c) 2011, ARM Ltd. All rights reserved.<BR>

+ This program and the accompanying materials

+ are licensed and made available under the terms and conditions of the BSD License

+ which accompanies this distribution.  The full text of the license may be found at

+ http://opensource.org/licenses/bsd-license.php

+

+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include "LcdGraphicsOutputDxe.h"

+

+BOOLEAN mDisplayInitialized = FALSE;

+

+LCD_MODE LcdModes[] = {

+  {

+    0, 640, 480,

+    9, 4,

+    96, 16, 48,

+    2, 10, 33

+  },

+  {

+    1, 800, 600,

+    11, 2,

+    120, 56, 64,

+    5, 37, 22

+  },

+  {

+    2, 1024, 768,

+    6, 2,

+    96, 16, 48,

+    2, 10, 33

+  },

+};

+

+LCD_INSTANCE mLcdTemplate = {

+  LCD_INSTANCE_SIGNATURE,

+  NULL, // Handle

+  { // ModeInfo

+    0, // Version

+    0, // HorizontalResolution

+    0, // VerticalResolution

+    PixelBltOnly, // PixelFormat

+    {

+      0xF800, //RedMask;

+      0x7E0, //GreenMask;

+      0x1F, //BlueMask;

+      0x0//ReservedMask

+    }, // PixelInformation

+    0, // PixelsPerScanLine

+  },

+  { // Mode

+    3, // MaxMode;

+    0, // Mode;

+    NULL, // Info;

+    0, // SizeOfInfo;

+    0, // FrameBufferBase;

+    0 // FrameBufferSize;

+  },

+  { // Gop

+    LcdGraphicsQueryMode,  // QueryMode

+    LcdGraphicsSetMode,    // SetMode

+    LcdGraphicsBlt,        // Blt

+    NULL                     // *Mode

+  },

+  { // DevicePath

+    {

+      {

+        HARDWARE_DEVICE_PATH, HW_VENDOR_DP,

+        (UINT8) (sizeof(VENDOR_DEVICE_PATH)),

+        (UINT8) ((sizeof(VENDOR_DEVICE_PATH)) >> 8),

+      },

+      // Hardware Device Path for Lcd

+      EFI_CALLER_ID_GUID // Use the driver's GUID

+    },

+

+    {

+      END_DEVICE_PATH_TYPE,

+      END_ENTIRE_DEVICE_PATH_SUBTYPE,

+      sizeof(EFI_DEVICE_PATH_PROTOCOL),

+      0

+    }

+  }

+};

+

+EFI_STATUS

+LcdInstanceContructor (

+  OUT LCD_INSTANCE** NewInstance

+  )

+{

+  LCD_INSTANCE* Instance;

+

+  Instance = AllocateCopyPool (sizeof(LCD_INSTANCE), &mLcdTemplate);

+  if (Instance == NULL) {

+    return EFI_OUT_OF_RESOURCES;

+  }

+

+  Instance->Gop.Mode          = &Instance->Mode;

+  Instance->Mode.Info         = &Instance->ModeInfo;

+

+  *NewInstance = Instance;

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+LcdPlatformGetVram (

+  OUT EFI_PHYSICAL_ADDRESS*  VramBaseAddress,

+  OUT UINTN*                 VramSize

+  )

+{

+  EFI_STATUS             Status;

+  EFI_CPU_ARCH_PROTOCOL  *Cpu;

+  UINTN                  MaxSize;

+

+  MaxSize = 0x500000;

+  *VramSize = MaxSize;

+

+  // Allocate VRAM from DRAM

+  Status = gBS->AllocatePages (AllocateAnyPages, EfiBootServicesData, EFI_SIZE_TO_PAGES((MaxSize)), VramBaseAddress);

+  if (EFI_ERROR(Status)) {

+    return Status;

+  }

+

+  // Ensure the Cpu architectural protocol is already installed

+  Status = gBS->LocateProtocol (&gEfiCpuArchProtocolGuid, NULL, (VOID **)&Cpu);

+  ASSERT_EFI_ERROR(Status);

+

+  // Mark the VRAM as un-cacheable. The VRAM is inside the DRAM, which is cacheable.

+  Status = Cpu->SetMemoryAttributes (Cpu, *VramBaseAddress, *VramSize, EFI_MEMORY_UC);

+  if (EFI_ERROR(Status)) {

+    gBS->FreePool (VramBaseAddress);

+    return Status;

+  }

+

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+DssSetMode (

+  UINT32 VramBaseAddress,

+  UINTN  ModeNumber

+  )

+{

+  // Make sure the interface clock is running

+  MmioWrite32 (CM_ICLKEN_DSS, EN_DSS);  

+

+  // Stop the functional clocks

+  MmioAnd32 (CM_FCLKEN_DSS, ~(EN_DSS1 | EN_DSS2 | EN_TV));

+

+  // Program the DSS clock divisor

+  MmioWrite32 (CM_CLKSEL_DSS, 0x1000 | (LcdModes[ModeNumber].DssDivisor));

+  

+  // Start the functional clocks

+  MmioOr32 (CM_FCLKEN_DSS, (EN_DSS1 | EN_DSS2 | EN_TV));

+

+  // Wait for DSS to stabilize

+  gBS->Stall(1);

+

+  // Reset the subsystem

+  MmioWrite32(DSS_SYSCONFIG, DSS_SOFTRESET);

+  while (!(MmioRead32 (DSS_SYSSTATUS) & DSS_RESETDONE));

+  

+  // Configure LCD parameters

+  MmioWrite32 (DISPC_SIZE_LCD,

+               ((LcdModes[ModeNumber].HorizontalResolution - 1) 

+               | ((LcdModes[ModeNumber].VerticalResolution - 1) << 16))

+              );

+  MmioWrite32 (DISPC_TIMING_H,

+               ( (LcdModes[ModeNumber].HSync - 1)

+               | ((LcdModes[ModeNumber].HFrontPorch - 1) << 8)

+               | ((LcdModes[ModeNumber].HBackPorch - 1) << 20))

+              );

+  MmioWrite32 (DISPC_TIMING_V,

+               ( (LcdModes[ModeNumber].VSync - 1)

+               | ((LcdModes[ModeNumber].VFrontPorch - 1) << 8)

+               | ((LcdModes[ModeNumber].VBackPorch - 1) << 20))

+              );

+

+  // Set the framebuffer to only load frames (no gamma tables)

+  MmioAnd32 (DISPC_CONFIG, CLEARLOADMODE);

+  MmioOr32  (DISPC_CONFIG, LOAD_FRAME_ONLY);

+

+  // Divisor for the pixel clock

+  MmioWrite32(DISPC_DIVISOR, ((1 << 16) | LcdModes[ModeNumber].DispcDivisor) );

+

+  // Set up the graphics layer

+  MmioWrite32 (DISPC_GFX_PRELD, 0x2D8);

+  MmioWrite32 (DISPC_GFX_BA0, VramBaseAddress);

+  MmioWrite32 (DISPC_GFX_SIZE,

+               ((LcdModes[ModeNumber].HorizontalResolution - 1) 

+               | ((LcdModes[ModeNumber].VerticalResolution - 1) << 16))

+              );

+

+  MmioWrite32(DISPC_GFX_ATTR, (GFXENABLE | RGB16 | BURSTSIZE16));

+

+  // Start it all

+  MmioOr32 (DISPC_CONTROL, (LCDENABLE | ACTIVEMATRIX | DATALINES24 | BYPASS_MODE | LCDENABLESIGNAL));

+  MmioOr32 (DISPC_CONTROL, GOLCD);

+

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+HwInitializeDisplay (

+  UINTN VramBaseAddress,

+  UINTN VramSize

+  )

+{

+  EFI_STATUS    Status;

+  UINT8         Data;

+  EFI_TPL       OldTpl;

+  EMBEDDED_EXTERNAL_DEVICE   *gTPS65950;

+

+  // Enable power lines used by TFP410

+  Status = gBS->LocateProtocol (&gEmbeddedExternalDeviceProtocolGuid, NULL, (VOID **)&gTPS65950);

+  ASSERT_EFI_ERROR (Status);  

+

+  OldTpl = gBS->RaiseTPL(TPL_NOTIFY);

+  Data = VAUX_DEV_GRP_P1;

+  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VPLL2_DEV_GRP), 1, &Data);

+  ASSERT_EFI_ERROR(Status);

+

+  Data = VAUX_DEDICATED_18V;

+  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VPLL2_DEDICATED), 1, &Data);

+  ASSERT_EFI_ERROR (Status);  

+

+  // Power up TFP410 (set GPIO2 on TPS - for BeagleBoard-xM)

+  Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, GPIODATADIR1), 1, &Data);

+  ASSERT_EFI_ERROR (Status);

+  Data |= BIT2;

+  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, GPIODATADIR1), 1, &Data);

+  ASSERT_EFI_ERROR (Status);

+

+  Data = BIT2;

+  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, SETGPIODATAOUT1), 1, &Data);

+  ASSERT_EFI_ERROR (Status);

+

+  gBS->RestoreTPL(OldTpl);

+

+  // Power up TFP410 (set GPIO 170 - for older BeagleBoards)

+  MmioAnd32 (GPIO6_BASE + GPIO_OE, ~BIT10);

+  MmioOr32  (GPIO6_BASE + GPIO_SETDATAOUT, BIT10);  

+

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+InitializeDisplay (

+  IN LCD_INSTANCE* Instance

+  )

+{

+  EFI_STATUS           Status; 

+  UINTN                VramSize;

+  EFI_PHYSICAL_ADDRESS VramBaseAddress;

+

+  Status = LcdPlatformGetVram (&VramBaseAddress, &VramSize);

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+

+  Instance->Mode.FrameBufferBase = VramBaseAddress;

+  Instance->Mode.FrameBufferSize = VramSize;

+

+  Status = HwInitializeDisplay((UINTN)VramBaseAddress, VramSize);

+  if (!EFI_ERROR (Status)) {

+    mDisplayInitialized = TRUE;

+  }

+

+  return Status;

+}

+

+EFI_STATUS

+EFIAPI

+LcdGraphicsQueryMode (

+  IN EFI_GRAPHICS_OUTPUT_PROTOCOL            *This,

+	IN UINT32                                  ModeNumber,

+	OUT UINTN                                  *SizeOfInfo,

+	OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION   **Info

+	)

+{

+	LCD_INSTANCE  *Instance;

+

+	Instance = LCD_INSTANCE_FROM_GOP_THIS(This);

+

+  if (!mDisplayInitialized) {

+    InitializeDisplay (Instance);

+  }

+

+  // Error checking

+	if ( (This == NULL) || (Info == NULL) || (SizeOfInfo == NULL) || (ModeNumber >= This->Mode->MaxMode) ) {

+	  DEBUG((DEBUG_ERROR, "LcdGraphicsQueryMode: ERROR - For mode number %d : Invalid Parameter.\n", ModeNumber ));

+		return EFI_INVALID_PARAMETER;

+	}

+

+  *Info = AllocateCopyPool(sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION), &Instance->ModeInfo);

+  if (*Info == NULL) {

+    return EFI_OUT_OF_RESOURCES;

+  }

+

+  *SizeOfInfo = sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);

+

+  (*Info)->Version = 0;

+  (*Info)->HorizontalResolution = LcdModes[ModeNumber].HorizontalResolution;

+  (*Info)->VerticalResolution = LcdModes[ModeNumber].VerticalResolution;

+  (*Info)->PixelFormat = PixelBltOnly;

+

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+EFIAPI

+LcdGraphicsSetMode (

+  IN EFI_GRAPHICS_OUTPUT_PROTOCOL   *This,

+	IN UINT32                         ModeNumber

+	)

+{

+	LCD_INSTANCE  *Instance;

+

+	Instance = LCD_INSTANCE_FROM_GOP_THIS(This);

+

+  if (ModeNumber >= Instance->Mode.MaxMode) {

+    return EFI_UNSUPPORTED;

+  }

+

+  if (!mDisplayInitialized) {

+    InitializeDisplay (Instance);

+  }

+

+  DssSetMode((UINT32)Instance->Mode.FrameBufferBase, ModeNumber);

+

+  Instance->Mode.Mode = ModeNumber;

+  Instance->ModeInfo.HorizontalResolution = LcdModes[ModeNumber].HorizontalResolution;

+  Instance->ModeInfo.VerticalResolution = LcdModes[ModeNumber].VerticalResolution;

+

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+EFIAPI

+LcdGraphicsOutputDxeInitialize (

+  IN EFI_HANDLE         ImageHandle,

+  IN EFI_SYSTEM_TABLE   *SystemTable

+  )

+{

+  EFI_STATUS Status = EFI_SUCCESS;

+  LCD_INSTANCE* Instance;

+

+  Status = LcdInstanceContructor (&Instance);

+  if (EFI_ERROR(Status)) {

+    goto EXIT;

+  }

+

+	// Install the Graphics Output Protocol and the Device Path

+	Status = gBS->InstallMultipleProtocolInterfaces(

+			&Instance->Handle,

+			&gEfiGraphicsOutputProtocolGuid, &Instance->Gop,

+			&gEfiDevicePathProtocolGuid,     &Instance->DevicePath,

+			NULL

+	   );

+

+	if (EFI_ERROR(Status)) {

+	  DEBUG((DEBUG_ERROR, "GraphicsOutputDxeInitialize: Can not install the protocol. Exit Status=%r\n", Status));

+		goto EXIT;

+	}

+

+  // Register for an ExitBootServicesEvent

+	// When ExitBootServices starts, this function here will make sure that the graphics driver will shut down properly,

+	// i.e. it will free up all allocated memory and perform any necessary hardware re-configuration.

+	/*Status = gBS->CreateEvent (

+	    EVT_SIGNAL_EXIT_BOOT_SERVICES,

+	    TPL_NOTIFY,

+	    LcdGraphicsExitBootServicesEvent, NULL,

+			&Instance->ExitBootServicesEvent

+			);

+

+	if (EFI_ERROR(Status)) {

+	  DEBUG((DEBUG_ERROR, "GraphicsOutputDxeInitialize: Can not install the ExitBootServicesEvent handler. Exit Status=%r\n", Status));

+		goto EXIT_ERROR_UNINSTALL_PROTOCOL;

+	}*/

+

+	// To get here, everything must be fine, so just exit

+	goto EXIT;

+

+//EXIT_ERROR_UNINSTALL_PROTOCOL:

+	/* The following function could return an error message,

+	 * however, to get here something must have gone wrong already,

+	 * so preserve the original error, i.e. don't change

+	 * the Status variable, even it fails to uninstall the protocol.

+	 */

+/*	gBS->UninstallMultipleProtocolInterfaces (

+	    Instance->Handle,

+	    &gEfiGraphicsOutputProtocolGuid, &Instance->Gop, // Uninstall Graphics Output protocol

+	    &gEfiDevicePathProtocolGuid,     &Instance->DevicePath,     // Uninstall device path

+	    NULL

+	    );*/

+

+EXIT:

+	return Status;

+

+}

diff --git a/Omap35xxPkg/LcdGraphicsOutputDxe/LcdGraphicsOutputDxe.h b/Omap35xxPkg/LcdGraphicsOutputDxe/LcdGraphicsOutputDxe.h
index 39e69478..520e28e6 100644
--- a/Omap35xxPkg/LcdGraphicsOutputDxe/LcdGraphicsOutputDxe.h
+++ b/Omap35xxPkg/LcdGraphicsOutputDxe/LcdGraphicsOutputDxe.h
@@ -1,157 +1,157 @@
-/** @file
-
- Copyright (c) 2011, ARM Ltd. All rights reserved.<BR>
- This program and the accompanying materials
- are licensed and made available under the terms and conditions of the BSD License
- which accompanies this distribution.  The full text of the license may be found at
- http://opensource.org/licenses/bsd-license.php
-
- THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
- WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#ifndef __OMAP3_DSS_GRAPHICS__
-#define __OMAP3_DSS_GRAPHICS__
-
-#include <Library/UefiBootServicesTableLib.h>
-#include <Library/UefiLib.h>
-#include <Library/DebugLib.h>
-#include <Library/MemoryAllocationLib.h>
-#include <Library/IoLib.h>
-
-#include <Protocol/DevicePathToText.h>
-#include <Protocol/EmbeddedExternalDevice.h>
-#include <Protocol/Cpu.h>
-
-#include <Guid/GlobalVariable.h>
-
-#include <Omap3530/Omap3530.h>
-#include <TPS65950.h>
-
-typedef struct {
-  VENDOR_DEVICE_PATH            Guid;
-  EFI_DEVICE_PATH_PROTOCOL      End;
-} LCD_GRAPHICS_DEVICE_PATH;
-
-typedef struct {
-  UINTN                                 Signature;
-  EFI_HANDLE                            Handle;
-  EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  ModeInfo;
-  EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE     Mode;
-  EFI_GRAPHICS_OUTPUT_PROTOCOL          Gop;
-  LCD_GRAPHICS_DEVICE_PATH              DevicePath;
-//  EFI_EVENT                             ExitBootServicesEvent;
-} LCD_INSTANCE;
-
-#define LCD_INSTANCE_SIGNATURE  SIGNATURE_32('l', 'c', 'd', '0')
-#define LCD_INSTANCE_FROM_GOP_THIS(a)     CR (a, LCD_INSTANCE, Gop, LCD_INSTANCE_SIGNATURE)
-
-typedef struct {
-  UINTN             Mode;
-  UINTN             HorizontalResolution;
-  UINTN             VerticalResolution;
-
-  UINT32            DssDivisor;
-  UINT32            DispcDivisor;
-
-  UINT32            HSync;
-  UINT32            HFrontPorch;
-  UINT32            HBackPorch;
-
-  UINT32            VSync;
-  UINT32            VFrontPorch;
-  UINT32            VBackPorch;
-} LCD_MODE;
-
-EFI_STATUS
-InitializeDisplay (
-  IN LCD_INSTANCE* Instance
-);
-
-EFI_STATUS
-EFIAPI
-LcdGraphicsQueryMode (
-  IN  EFI_GRAPHICS_OUTPUT_PROTOCOL          *This,
-  IN  UINT32                                ModeNumber,
-  OUT UINTN                                 *SizeOfInfo,
-  OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  **Info
-);
-
-EFI_STATUS
-EFIAPI
-LcdGraphicsSetMode (
-  IN EFI_GRAPHICS_OUTPUT_PROTOCOL  *This,
-  IN UINT32                        ModeNumber
-);
-
-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
-);
-
-// HW registers
-#define CM_FCLKEN_DSS   0x48004E00
-#define CM_ICLKEN_DSS   0x48004E10
-
-#define DSS_CONTROL     0x48050040
-#define DSS_SYSCONFIG   0x48050010
-#define DSS_SYSSTATUS   0x48050014
-
-#define DISPC_CONTROL   0x48050440
-#define DISPC_CONFIG    0x48050444
-#define DISPC_SIZE_LCD  0x4805047C
-#define DISPC_TIMING_H  0x48050464
-#define DISPC_TIMING_V  0x48050468
-
-#define CM_CLKSEL_DSS   0x48004E40
-#define DISPC_DIVISOR   0x48050470
-#define DISPC_POL_FREQ  0x4805046C
-
-#define DISPC_GFX_TABLE_BA 0x480504B8
-#define DISPC_GFX_BA0   0x48050480
-#define DISPC_GFX_BA1   0x48050484
-#define DISPC_GFX_POS   0x48050488
-#define DISPC_GFX_SIZE  0x4805048C
-#define DISPC_GFX_ATTR  0x480504A0
-#define DISPC_GFX_PRELD 0x4805062C
-
-#define DISPC_DEFAULT_COLOR_0 0x4805044C
-
-//#define DISPC_IRQSTATUS
-
-// Bits
-#define EN_TV           0x4
-#define EN_DSS2         0x2
-#define EN_DSS1         0x1
-#define EN_DSS          0x1
-
-#define DSS_SOFTRESET   0x2
-#define DSS_RESETDONE   0x1
-
-#define BYPASS_MODE     (BIT15 | BIT16)
-
-#define LCDENABLE       BIT0
-#define ACTIVEMATRIX    BIT3
-#define GOLCD           BIT5
-#define DATALINES24     (BIT8 | BIT9)   
-#define LCDENABLESIGNAL BIT28
-
-#define GFXENABLE       BIT0
-#define RGB16           (0x6 << 1)
-#define BURSTSIZE16     (0x2 << 6)
-
-#define CLEARLOADMODE   ~(BIT2 | BIT1)
-#define LOAD_FRAME_ONLY BIT2
-
-#endif
+/** @file

+

+ Copyright (c) 2011, ARM Ltd. All rights reserved.<BR>

+ This program and the accompanying materials

+ are licensed and made available under the terms and conditions of the BSD License

+ which accompanies this distribution.  The full text of the license may be found at

+ http://opensource.org/licenses/bsd-license.php

+

+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __OMAP3_DSS_GRAPHICS__

+#define __OMAP3_DSS_GRAPHICS__

+

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/UefiLib.h>

+#include <Library/DebugLib.h>

+#include <Library/MemoryAllocationLib.h>

+#include <Library/IoLib.h>

+

+#include <Protocol/DevicePathToText.h>

+#include <Protocol/EmbeddedExternalDevice.h>

+#include <Protocol/Cpu.h>

+

+#include <Guid/GlobalVariable.h>

+

+#include <Omap3530/Omap3530.h>

+#include <TPS65950.h>

+

+typedef struct {

+  VENDOR_DEVICE_PATH            Guid;

+  EFI_DEVICE_PATH_PROTOCOL      End;

+} LCD_GRAPHICS_DEVICE_PATH;

+

+typedef struct {

+  UINTN                                 Signature;

+  EFI_HANDLE                            Handle;

+  EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  ModeInfo;

+  EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE     Mode;

+  EFI_GRAPHICS_OUTPUT_PROTOCOL          Gop;

+  LCD_GRAPHICS_DEVICE_PATH              DevicePath;

+//  EFI_EVENT                             ExitBootServicesEvent;

+} LCD_INSTANCE;

+

+#define LCD_INSTANCE_SIGNATURE  SIGNATURE_32('l', 'c', 'd', '0')

+#define LCD_INSTANCE_FROM_GOP_THIS(a)     CR (a, LCD_INSTANCE, Gop, LCD_INSTANCE_SIGNATURE)

+

+typedef struct {

+  UINTN             Mode;

+  UINTN             HorizontalResolution;

+  UINTN             VerticalResolution;

+

+  UINT32            DssDivisor;

+  UINT32            DispcDivisor;

+

+  UINT32            HSync;

+  UINT32            HFrontPorch;

+  UINT32            HBackPorch;

+

+  UINT32            VSync;

+  UINT32            VFrontPorch;

+  UINT32            VBackPorch;

+} LCD_MODE;

+

+EFI_STATUS

+InitializeDisplay (

+  IN LCD_INSTANCE* Instance

+);

+

+EFI_STATUS

+EFIAPI

+LcdGraphicsQueryMode (

+  IN  EFI_GRAPHICS_OUTPUT_PROTOCOL          *This,

+  IN  UINT32                                ModeNumber,

+  OUT UINTN                                 *SizeOfInfo,

+  OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  **Info

+);

+

+EFI_STATUS

+EFIAPI

+LcdGraphicsSetMode (

+  IN EFI_GRAPHICS_OUTPUT_PROTOCOL  *This,

+  IN UINT32                        ModeNumber

+);

+

+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

+);

+

+// HW registers

+#define CM_FCLKEN_DSS   0x48004E00

+#define CM_ICLKEN_DSS   0x48004E10

+

+#define DSS_CONTROL     0x48050040

+#define DSS_SYSCONFIG   0x48050010

+#define DSS_SYSSTATUS   0x48050014

+

+#define DISPC_CONTROL   0x48050440

+#define DISPC_CONFIG    0x48050444

+#define DISPC_SIZE_LCD  0x4805047C

+#define DISPC_TIMING_H  0x48050464

+#define DISPC_TIMING_V  0x48050468

+

+#define CM_CLKSEL_DSS   0x48004E40

+#define DISPC_DIVISOR   0x48050470

+#define DISPC_POL_FREQ  0x4805046C

+

+#define DISPC_GFX_TABLE_BA 0x480504B8

+#define DISPC_GFX_BA0   0x48050480

+#define DISPC_GFX_BA1   0x48050484

+#define DISPC_GFX_POS   0x48050488

+#define DISPC_GFX_SIZE  0x4805048C

+#define DISPC_GFX_ATTR  0x480504A0

+#define DISPC_GFX_PRELD 0x4805062C

+

+#define DISPC_DEFAULT_COLOR_0 0x4805044C

+

+//#define DISPC_IRQSTATUS

+

+// Bits

+#define EN_TV           0x4

+#define EN_DSS2         0x2

+#define EN_DSS1         0x1

+#define EN_DSS          0x1

+

+#define DSS_SOFTRESET   0x2

+#define DSS_RESETDONE   0x1

+

+#define BYPASS_MODE     (BIT15 | BIT16)

+

+#define LCDENABLE       BIT0

+#define ACTIVEMATRIX    BIT3

+#define GOLCD           BIT5

+#define DATALINES24     (BIT8 | BIT9)   

+#define LCDENABLESIGNAL BIT28

+

+#define GFXENABLE       BIT0

+#define RGB16           (0x6 << 1)

+#define BURSTSIZE16     (0x2 << 6)

+

+#define CLEARLOADMODE   ~(BIT2 | BIT1)

+#define LOAD_FRAME_ONLY BIT2

+

+#endif

diff --git a/Omap35xxPkg/LcdGraphicsOutputDxe/LcdGraphicsOutputDxe.inf b/Omap35xxPkg/LcdGraphicsOutputDxe/LcdGraphicsOutputDxe.inf
index f595bb39..ac026f43 100644
--- a/Omap35xxPkg/LcdGraphicsOutputDxe/LcdGraphicsOutputDxe.inf
+++ b/Omap35xxPkg/LcdGraphicsOutputDxe/LcdGraphicsOutputDxe.inf
@@ -1,52 +1,52 @@
-#/** @file
-#  
-#  Copyright (c) 2011, ARM Ltd. All rights reserved.<BR>
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = LcdGraphicsDxe
-  FILE_GUID                      = E68088EF-D1A4-4336-C1DB-4D3A204730A6
-  MODULE_TYPE                    = DXE_DRIVER
-  VERSION_STRING                 = 1.0
-  ENTRY_POINT                    = LcdGraphicsOutputDxeInitialize
-
-[Sources.common]
-  LcdGraphicsOutputDxe.c
-  LcdGraphicsOutputBlt.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  MdeModulePkg/MdeModulePkg.dec
-  ArmPkg/ArmPkg.dec
-  ArmPlatformPkg/ArmPlatformPkg.dec
-  Omap35xxPkg/Omap35xxPkg.dec
-  EmbeddedPkg/EmbeddedPkg.dec
-
-[LibraryClasses]
-  ArmLib
-  UefiLib
-  BaseLib
-  DebugLib
-  TimerLib
-  UefiDriverEntryPoint
-  UefiBootServicesTableLib
-  IoLib
-  BaseMemoryLib
-
-[Protocols]
-  gEfiDevicePathProtocolGuid
-  gEfiGraphicsOutputProtocolGuid
-  gEfiDevicePathToTextProtocolGuid
-  gEmbeddedExternalDeviceProtocolGuid
-
-[Depex]
-  gEfiCpuArchProtocolGuid AND gEfiTimerArchProtocolGuid
+#/** @file

+#  

+#  Copyright (c) 2011, ARM Ltd. All rights reserved.<BR>

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = LcdGraphicsDxe

+  FILE_GUID                      = E68088EF-D1A4-4336-C1DB-4D3A204730A6

+  MODULE_TYPE                    = DXE_DRIVER

+  VERSION_STRING                 = 1.0

+  ENTRY_POINT                    = LcdGraphicsOutputDxeInitialize

+

+[Sources.common]

+  LcdGraphicsOutputDxe.c

+  LcdGraphicsOutputBlt.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  MdeModulePkg/MdeModulePkg.dec

+  ArmPkg/ArmPkg.dec

+  ArmPlatformPkg/ArmPlatformPkg.dec

+  Omap35xxPkg/Omap35xxPkg.dec

+  EmbeddedPkg/EmbeddedPkg.dec

+

+[LibraryClasses]

+  ArmLib

+  UefiLib

+  BaseLib

+  DebugLib

+  TimerLib

+  UefiDriverEntryPoint

+  UefiBootServicesTableLib

+  IoLib

+  BaseMemoryLib

+

+[Protocols]

+  gEfiDevicePathProtocolGuid

+  gEfiGraphicsOutputProtocolGuid

+  gEfiDevicePathToTextProtocolGuid

+  gEmbeddedExternalDeviceProtocolGuid

+

+[Depex]

+  gEfiCpuArchProtocolGuid AND gEfiTimerArchProtocolGuid

diff --git a/Omap35xxPkg/Library/DebugAgentTimerLib/DebugAgentTimerLib.c b/Omap35xxPkg/Library/DebugAgentTimerLib/DebugAgentTimerLib.c
index 76c13d55..b3da7366 100755
--- a/Omap35xxPkg/Library/DebugAgentTimerLib/DebugAgentTimerLib.c
+++ b/Omap35xxPkg/Library/DebugAgentTimerLib/DebugAgentTimerLib.c
@@ -13,23 +13,23 @@
 

 **/

 #include <Base.h>

-#include <Library/BaseLib.h>
-#include <Library/IoLib.h>
-#include <Library/OmapLib.h>
+#include <Library/BaseLib.h>

+#include <Library/IoLib.h>

+#include <Library/OmapLib.h>

 #include <Library/ArmLib.h>

-#include <Library/PcdLib.h>
+#include <Library/PcdLib.h>

 

-#include <Omap3530/Omap3530.h>
+#include <Omap3530/Omap3530.h>

 

 

 volatile UINT32 gVector;

-
-// Cached registers
-volatile UINT32 gTISR;
-volatile UINT32 gTCLR;
-volatile UINT32 gTLDR;
-volatile UINT32 gTCRR;
-volatile UINT32 gTIER;
+

+// Cached registers

+volatile UINT32 gTISR;

+volatile UINT32 gTCLR;

+volatile UINT32 gTLDR;

+volatile UINT32 gTCRR;

+volatile UINT32 gTIER;

 

 VOID

 EnableInterruptSource (

@@ -80,15 +80,15 @@ DebugAgentTimerIntialize (
   UINT32      TimerNumber;

 

   TimerNumber = PcdGet32(PcdOmap35xxDebugAgentTimer);

-  gVector = InterruptVectorForTimer (TimerNumber);
+  gVector = InterruptVectorForTimer (TimerNumber);

 

-  // Set up the timer registers
-  TimerBaseAddress = TimerBase (TimerNumber);
-  gTISR = TimerBaseAddress + GPTIMER_TISR;
-  gTCLR = TimerBaseAddress + GPTIMER_TCLR;
-  gTLDR = TimerBaseAddress + GPTIMER_TLDR;
-  gTCRR = TimerBaseAddress + GPTIMER_TCRR;
-  gTIER = TimerBaseAddress + GPTIMER_TIER;
+  // Set up the timer registers

+  TimerBaseAddress = TimerBase (TimerNumber);

+  gTISR = TimerBaseAddress + GPTIMER_TISR;

+  gTCLR = TimerBaseAddress + GPTIMER_TCLR;

+  gTLDR = TimerBaseAddress + GPTIMER_TLDR;

+  gTCRR = TimerBaseAddress + GPTIMER_TCRR;

+  gTIER = TimerBaseAddress + GPTIMER_TIER;

 

   if ((TimerNumber < 2) || (TimerNumber > 9)) {

     // This code assumes one the General Purpose timers is used

@@ -113,31 +113,31 @@ DebugAgentTimerSetPeriod (
   IN  UINT32  TimerPeriodMilliseconds

   )

 {

-  UINT64      TimerCount;
-  INT32       LoadValue;
-  
-  if (TimerPeriodMilliseconds == 0) {
-    // Turn off GPTIMER3
-    MmioWrite32 (gTCLR, TCLR_ST_OFF);
-    
-    DisableInterruptSource ();
-  } else {  
-    // Calculate required timer count
-    TimerCount = DivU64x32(TimerPeriodMilliseconds * 1000000, PcdGet32(PcdDebugAgentTimerFreqNanoSeconds));
-
-    // Set GPTIMER5 Load register
-    LoadValue = (INT32) -TimerCount;
-    MmioWrite32 (gTLDR, LoadValue);
-    MmioWrite32 (gTCRR, LoadValue);
-
-    // Enable Overflow interrupt
-    MmioWrite32 (gTIER, TIER_TCAR_IT_DISABLE | TIER_OVF_IT_ENABLE | TIER_MAT_IT_DISABLE);
-
-    // Turn on GPTIMER3, it will reload at overflow
-    MmioWrite32 (gTCLR, TCLR_AR_AUTORELOAD | TCLR_ST_ON);
-
-    EnableInterruptSource ();
-  }
+  UINT64      TimerCount;

+  INT32       LoadValue;

+  

+  if (TimerPeriodMilliseconds == 0) {

+    // Turn off GPTIMER3

+    MmioWrite32 (gTCLR, TCLR_ST_OFF);

+    

+    DisableInterruptSource ();

+  } else {  

+    // Calculate required timer count

+    TimerCount = DivU64x32(TimerPeriodMilliseconds * 1000000, PcdGet32(PcdDebugAgentTimerFreqNanoSeconds));

+

+    // Set GPTIMER5 Load register

+    LoadValue = (INT32) -TimerCount;

+    MmioWrite32 (gTLDR, LoadValue);

+    MmioWrite32 (gTCRR, LoadValue);

+

+    // Enable Overflow interrupt

+    MmioWrite32 (gTIER, TIER_TCAR_IT_DISABLE | TIER_OVF_IT_ENABLE | TIER_MAT_IT_DISABLE);

+

+    // Turn on GPTIMER3, it will reload at overflow

+    MmioWrite32 (gTCLR, TCLR_AR_AUTORELOAD | TCLR_ST_ON);

+

+    EnableInterruptSource ();

+  }

 }

   

 

@@ -152,10 +152,10 @@ DebugAgentTimerEndOfInterrupt (
   VOID

   )

 {

-   // Clear all timer interrupts
-  MmioWrite32 (gTISR, TISR_CLEAR_ALL);  
-
-  // Poll interrupt status bits to ensure clearing
+   // Clear all timer interrupts

+  MmioWrite32 (gTISR, TISR_CLEAR_ALL);  

+

+  // Poll interrupt status bits to ensure clearing

   while ((MmioRead32 (gTISR) & TISR_ALL_INTERRUPT_MASK) != TISR_NO_INTERRUPTS_PENDING);

 

   MmioWrite32 (INTCPS_CONTROL, INTCPS_CONTROL_NEWFIQAGR);

@@ -163,4 +163,4 @@ DebugAgentTimerEndOfInterrupt (
 

 }

 

-  
\ No newline at end of file
+  
\ No newline at end of file
diff --git a/Omap35xxPkg/Library/DebugAgentTimerLib/DebugAgentTimerLib.inf b/Omap35xxPkg/Library/DebugAgentTimerLib/DebugAgentTimerLib.inf
index e1685b58..551aee53 100755
--- a/Omap35xxPkg/Library/DebugAgentTimerLib/DebugAgentTimerLib.inf
+++ b/Omap35xxPkg/Library/DebugAgentTimerLib/DebugAgentTimerLib.inf
@@ -31,9 +31,9 @@
 [Packages]

   MdePkg/MdePkg.dec

   EmbeddedPkg/EmbeddedPkg.dec

-  Omap35xxPkg/Omap35xxPkg.dec
-  ArmPkg/ArmPkg.dec
-  
+  Omap35xxPkg/Omap35xxPkg.dec

+  ArmPkg/ArmPkg.dec

+  

 

 [LibraryClasses]

   BaseLib

@@ -44,4 +44,4 @@
 [Pcd]

   gOmap35xxTokenSpaceGuid.PcdOmap35xxDebugAgentTimer

   gOmap35xxTokenSpaceGuid.PcdDebugAgentTimerFreqNanoSeconds

-  
\ No newline at end of file
+  
\ No newline at end of file
diff --git a/Omap35xxPkg/Library/GdbSerialLib/GdbSerialLib.c b/Omap35xxPkg/Library/GdbSerialLib/GdbSerialLib.c
index b306355d..54247e42 100644
--- a/Omap35xxPkg/Library/GdbSerialLib/GdbSerialLib.c
+++ b/Omap35xxPkg/Library/GdbSerialLib/GdbSerialLib.c
@@ -1,102 +1,102 @@
-/** @file
-  Basic serial IO abstaction for GDB
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include <Uefi.h>
-#include <Library/GdbSerialLib.h>
-#include <Library/PcdLib.h>
-#include <Library/IoLib.h>
-#include <Library/DebugLib.h>
-#include <Library/OmapLib.h>
-#include <Omap3530/Omap3530.h>
-
-RETURN_STATUS
-EFIAPI
-GdbSerialLibConstructor (
-  VOID
-  )
-{
-  return RETURN_SUCCESS;
-}
-
-RETURN_STATUS
-EFIAPI
-GdbSerialInit (
-  IN UINT64     BaudRate, 
-  IN UINT8      Parity, 
-  IN UINT8      DataBits, 
-  IN UINT8      StopBits 
-  )
-{
-  return RETURN_SUCCESS;
-}
-
-BOOLEAN
-EFIAPI
-GdbIsCharAvailable (
-  VOID
-  )  
-{
-  UINT32 LSR = UartBase(PcdGet32(PcdOmap35xxConsoleUart)) + UART_LSR_REG;
-
-  if ((MmioRead8(LSR) & UART_LSR_RX_FIFO_E_MASK) == UART_LSR_RX_FIFO_E_NOT_EMPTY) {
-    return TRUE;
-  } else {
-    return FALSE;
-  }
-}
-
-CHAR8
-EFIAPI
-GdbGetChar (
-  VOID
-  )
-{
-  UINT32  LSR = UartBase(PcdGet32(PcdOmap35xxConsoleUart)) + UART_LSR_REG;
-  UINT32  RBR = UartBase(PcdGet32(PcdOmap35xxConsoleUart)) + UART_RBR_REG;
-  CHAR8   Char;
-    
-  while ((MmioRead8(LSR) & UART_LSR_RX_FIFO_E_MASK) == UART_LSR_RX_FIFO_E_EMPTY);
-  Char = MmioRead8(RBR);
-
-  return Char;
-}
-
-VOID
-EFIAPI
-GdbPutChar (
-  IN  CHAR8   Char
-  )
-{
-  UINT32  LSR = UartBase(PcdGet32(PcdOmap35xxConsoleUart)) + UART_LSR_REG;
-  UINT32  THR = UartBase(PcdGet32(PcdOmap35xxConsoleUart)) + UART_THR_REG;
-    
-  while ((MmioRead8(LSR) & UART_LSR_TX_FIFO_E_MASK) == UART_LSR_TX_FIFO_E_NOT_EMPTY);
-  MmioWrite8(THR, Char);
-}
-
-VOID
-GdbPutString (
-  IN CHAR8  *String
-  )
-{
-  while (*String != '\0') {
-    GdbPutChar (*String);
-    String++;
-  }
-}
-
-
-
-
+/** @file

+  Basic serial IO abstaction for GDB

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include <Uefi.h>

+#include <Library/GdbSerialLib.h>

+#include <Library/PcdLib.h>

+#include <Library/IoLib.h>

+#include <Library/DebugLib.h>

+#include <Library/OmapLib.h>

+#include <Omap3530/Omap3530.h>

+

+RETURN_STATUS

+EFIAPI

+GdbSerialLibConstructor (

+  VOID

+  )

+{

+  return RETURN_SUCCESS;

+}

+

+RETURN_STATUS

+EFIAPI

+GdbSerialInit (

+  IN UINT64     BaudRate, 

+  IN UINT8      Parity, 

+  IN UINT8      DataBits, 

+  IN UINT8      StopBits 

+  )

+{

+  return RETURN_SUCCESS;

+}

+

+BOOLEAN

+EFIAPI

+GdbIsCharAvailable (

+  VOID

+  )  

+{

+  UINT32 LSR = UartBase(PcdGet32(PcdOmap35xxConsoleUart)) + UART_LSR_REG;

+

+  if ((MmioRead8(LSR) & UART_LSR_RX_FIFO_E_MASK) == UART_LSR_RX_FIFO_E_NOT_EMPTY) {

+    return TRUE;

+  } else {

+    return FALSE;

+  }

+}

+

+CHAR8

+EFIAPI

+GdbGetChar (

+  VOID

+  )

+{

+  UINT32  LSR = UartBase(PcdGet32(PcdOmap35xxConsoleUart)) + UART_LSR_REG;

+  UINT32  RBR = UartBase(PcdGet32(PcdOmap35xxConsoleUart)) + UART_RBR_REG;

+  CHAR8   Char;

+    

+  while ((MmioRead8(LSR) & UART_LSR_RX_FIFO_E_MASK) == UART_LSR_RX_FIFO_E_EMPTY);

+  Char = MmioRead8(RBR);

+

+  return Char;

+}

+

+VOID

+EFIAPI

+GdbPutChar (

+  IN  CHAR8   Char

+  )

+{

+  UINT32  LSR = UartBase(PcdGet32(PcdOmap35xxConsoleUart)) + UART_LSR_REG;

+  UINT32  THR = UartBase(PcdGet32(PcdOmap35xxConsoleUart)) + UART_THR_REG;

+    

+  while ((MmioRead8(LSR) & UART_LSR_TX_FIFO_E_MASK) == UART_LSR_TX_FIFO_E_NOT_EMPTY);

+  MmioWrite8(THR, Char);

+}

+

+VOID

+GdbPutString (

+  IN CHAR8  *String

+  )

+{

+  while (*String != '\0') {

+    GdbPutChar (*String);

+    String++;

+  }

+}

+

+

+

+

diff --git a/Omap35xxPkg/Library/GdbSerialLib/GdbSerialLib.inf b/Omap35xxPkg/Library/GdbSerialLib/GdbSerialLib.inf
index 7e949c2f..3ab26bb9 100644
--- a/Omap35xxPkg/Library/GdbSerialLib/GdbSerialLib.inf
+++ b/Omap35xxPkg/Library/GdbSerialLib/GdbSerialLib.inf
@@ -1,41 +1,41 @@
-#/** @file
-#  
-#  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = GdbSerialLib
-  FILE_GUID                      = E2423349-EF5D-439B-95F5-8B8D8E3B443F
-  MODULE_TYPE                    = BASE
-  VERSION_STRING                 = 1.0
-  LIBRARY_CLASS                  = GdbSerialLib
-
-  CONSTRUCTOR                    = GdbSerialLibConstructor
-
-
-[Sources.common]
-  GdbSerialLib.c
-
-
-[Packages]
-  MdePkg/MdePkg.dec
-  EmbeddedPkg/EmbeddedPkg.dec
-  Omap35xxPkg/Omap35xxPkg.dec
-
-[LibraryClasses]
-  DebugLib
-  IoLib
-  OmapLib    
-
-[FixedPcd]
-  gOmap35xxTokenSpaceGuid.PcdOmap35xxConsoleUart
-
+#/** @file

+#  

+#  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = GdbSerialLib

+  FILE_GUID                      = E2423349-EF5D-439B-95F5-8B8D8E3B443F

+  MODULE_TYPE                    = BASE

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = GdbSerialLib

+

+  CONSTRUCTOR                    = GdbSerialLibConstructor

+

+

+[Sources.common]

+  GdbSerialLib.c

+

+

+[Packages]

+  MdePkg/MdePkg.dec

+  EmbeddedPkg/EmbeddedPkg.dec

+  Omap35xxPkg/Omap35xxPkg.dec

+

+[LibraryClasses]

+  DebugLib

+  IoLib

+  OmapLib    

+

+[FixedPcd]

+  gOmap35xxTokenSpaceGuid.PcdOmap35xxConsoleUart

+

diff --git a/Omap35xxPkg/Library/OmapDmaLib/OmapDmaLib.inf b/Omap35xxPkg/Library/OmapDmaLib/OmapDmaLib.inf
index 4356853b..d94ddf98 100755
--- a/Omap35xxPkg/Library/OmapDmaLib/OmapDmaLib.inf
+++ b/Omap35xxPkg/Library/OmapDmaLib/OmapDmaLib.inf
@@ -47,4 +47,4 @@
 [Pcd]

 

 [Depex]

-  gEfiCpuArchProtocolGuid
\ No newline at end of file
+  gEfiCpuArchProtocolGuid
\ No newline at end of file
diff --git a/Omap35xxPkg/Library/RealTimeClockLib/RealTimeClockLib.c b/Omap35xxPkg/Library/RealTimeClockLib/RealTimeClockLib.c
index e1d5c9ca..0b9c70bc 100755
--- a/Omap35xxPkg/Library/RealTimeClockLib/RealTimeClockLib.c
+++ b/Omap35xxPkg/Library/RealTimeClockLib/RealTimeClockLib.c
@@ -1,297 +1,297 @@
-/** @file
-*
-*  Copyright (c) 2011, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-#include <Uefi.h>
-
-#include <Library/BaseMemoryLib.h>
-#include <Library/UefiBootServicesTableLib.h>
-#include <Library/UefiRuntimeServicesTableLib.h>
-#include <Library/DebugLib.h>
-#include <Library/IoLib.h>
-
-#include <Protocol/RealTimeClock.h>
-#include <Protocol/EmbeddedExternalDevice.h>
-
-#include <Omap3530/Omap3530.h>
-#include <TPS65950.h>
-
-
-EMBEDDED_EXTERNAL_DEVICE   *gTPS65950;
-INT16                      TimeZone = EFI_UNSPECIFIED_TIMEZONE;
-
-/**
-  Returns the current time and date information, and the time-keeping capabilities
-  of the hardware platform.
-
-  @param  Time                  A pointer to storage to receive a snapshot of the current time.
-  @param  Capabilities          An optional pointer to a buffer to receive the real time clock
-                                device's capabilities.
-
-  @retval EFI_SUCCESS           The operation completed successfully.
-  @retval EFI_INVALID_PARAMETER Time is NULL.
-  @retval EFI_DEVICE_ERROR      The time could not be retrieved due to hardware error.
-
-**/
-EFI_STATUS
-EFIAPI
-LibGetTime (
-  OUT EFI_TIME                *Time,
-  OUT EFI_TIME_CAPABILITIES   *Capabilities
-  )
-{
-  EFI_STATUS            Status;
-  UINT8                 Data;
-  EFI_TPL               OldTpl;
-
-  if (Time == NULL) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  OldTpl = gBS->RaiseTPL(TPL_NOTIFY);
-
-  /* Get time and date */
-  ZeroMem(Time, sizeof(EFI_TIME));
-
-  // Latch values
-  Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, RTC_CTRL_REG), 1, &Data);
-  if (Status != EFI_SUCCESS) goto EXIT;
-  Data |= BIT6;
-  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, RTC_CTRL_REG), 1, &Data);
-  if (Status != EFI_SUCCESS) goto EXIT;
-
-  // Read registers
-  Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, YEARS_REG), 1, &Data);
-  if (Status != EFI_SUCCESS) goto EXIT;
-  Time->Year = 2000 + ((Data >> 4) & 0xF) * 10 + (Data & 0xF);
-
-  Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, MONTHS_REG), 1, &Data);
-  if (Status != EFI_SUCCESS) goto EXIT;
-  Time->Month = ((Data >> 4) & 0x1) * 10 + (Data & 0xF);
-
-  Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, DAYS_REG), 1, &Data);
-  if (Status != EFI_SUCCESS) goto EXIT;
-  Time->Day = ((Data >> 4) & 0x3) * 10 + (Data & 0xF);
-
-  Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, HOURS_REG), 1, &Data);
-  if (Status != EFI_SUCCESS) goto EXIT;
-  Time->Hour = ((Data >> 4) & 0x3) * 10 + (Data & 0xF);
-
-  Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, MINUTES_REG), 1, &Data);
-  if (Status != EFI_SUCCESS) goto EXIT;
-  Time->Minute = ((Data >> 4) & 0x7) * 10 + (Data & 0xF);
-
-  Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, SECONDS_REG), 1, &Data);
-  if (Status != EFI_SUCCESS) goto EXIT;
-  Time->Second = ((Data >> 4) & 0x7) * 10 + (Data & 0xF);
-
-  Time->TimeZone = TimeZone;
-  // TODO: check what to use here
-  Time->Daylight = EFI_TIME_ADJUST_DAYLIGHT;
-
-  // Set capabilities
-
-  // TODO: Set real capabilities
-  if (Capabilities != NULL) {
-    Capabilities->Resolution = 1;
-    Capabilities->Accuracy = 50000000;
-    Capabilities->SetsToZero = FALSE;
-  }
-
-EXIT:
-  gBS->RestoreTPL(OldTpl);
-
-  return (Status == EFI_SUCCESS) ? Status : EFI_DEVICE_ERROR;
-}
-
-/**
-  Sets the current local time and date information.
-
-  @param  Time                  A pointer to the current time.
-
-  @retval EFI_SUCCESS           The operation completed successfully.
-  @retval EFI_INVALID_PARAMETER A time field is out of range.
-  @retval EFI_DEVICE_ERROR      The time could not be set due due to hardware error.
-
-**/
-EFI_STATUS
-EFIAPI
-LibSetTime (
-  IN EFI_TIME                *Time
-  )
-{
-  EFI_STATUS Status;
-  UINT8      Data;
-  UINT8      MonthDayCount[12] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
-  EFI_TPL    OldTpl;
-
-  // Input validation according both to UEFI spec and hardware constraints
-  // UEFI spec says valid year range is 1900-9999 but TPS only supports 2000-2099
-  if ( (Time == NULL)
-    || (Time->Year < 2000 || Time->Year > 2099)
-    || (Time->Month < 1 || Time->Month > 12)
-    || (Time->Day < 1 || Time->Day > MonthDayCount[Time->Month])
-    || (Time->Hour > 23)
-    || (Time->Minute > 59)
-    || (Time->Second > 59)
-    || (Time->Nanosecond > 999999999)
-    || ((Time->TimeZone < -1440 || Time->TimeZone > 1440) && Time->TimeZone != 2047)
-  ) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  OldTpl = gBS->RaiseTPL(TPL_NOTIFY);
-
-  Data = Time->Year - 2000;
-  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, YEARS_REG), 1, &Data);
-  if (Status != EFI_SUCCESS) goto EXIT;
-
-  Data = ((Time->Month / 10) << 4) | (Time->Month % 10);
-  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, MONTHS_REG), 1, &Data);
-  if (Status != EFI_SUCCESS) goto EXIT;
-
-  Data = ((Time->Day / 10) << 4) | (Time->Day % 10);
-  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, DAYS_REG), 1, &Data);
-  if (Status != EFI_SUCCESS) goto EXIT;
-
-  Data = ((Time->Hour / 10) << 4) | (Time->Hour % 10);
-  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, HOURS_REG), 1, &Data);
-  if (Status != EFI_SUCCESS) goto EXIT;
-
-  Data = ((Time->Minute / 10) << 4) | (Time->Minute % 10);
-  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, MINUTES_REG), 1, &Data);
-  if (Status != EFI_SUCCESS) goto EXIT;
-
-  Data = ((Time->Second / 10) << 4) | (Time->Second % 10);
-  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, SECONDS_REG), 1, &Data);
-  if (Status != EFI_SUCCESS) goto EXIT;
-
-  TimeZone = Time->TimeZone;
-
-EXIT:
-  gBS->RestoreTPL(OldTpl);
-
-  return (Status == EFI_SUCCESS) ? Status : EFI_DEVICE_ERROR;
-}
-
-/**
-  Returns the current wakeup alarm clock setting.
-
-  @param  Enabled               Indicates if the alarm is currently enabled or disabled.
-  @param  Pending               Indicates if the alarm signal is pending and requires acknowledgement.
-  @param  Time                  The current alarm setting.
-
-  @retval EFI_SUCCESS           The alarm settings were returned.
-  @retval EFI_INVALID_PARAMETER Any parameter is NULL.
-  @retval EFI_DEVICE_ERROR      The wakeup time could not be retrieved due to a hardware error.
-
-**/
-EFI_STATUS
-EFIAPI
-LibGetWakeupTime (
-  OUT BOOLEAN     *Enabled,
-  OUT BOOLEAN     *Pending,
-  OUT EFI_TIME    *Time
-  )
-{
-  return EFI_UNSUPPORTED;
-}
-
-/**
-  Sets the system wakeup alarm clock time.
-
-  @param  Enabled               Enable or disable the wakeup alarm.
-  @param  Time                  If Enable is TRUE, the time to set the wakeup alarm for.
-
-  @retval EFI_SUCCESS           If Enable is TRUE, then the wakeup alarm was enabled. If
-                                Enable is FALSE, then the wakeup alarm was disabled.
-  @retval EFI_INVALID_PARAMETER A time field is out of range.
-  @retval EFI_DEVICE_ERROR      The wakeup time could not be set due to a hardware error.
-  @retval EFI_UNSUPPORTED       A wakeup timer is not supported on this platform.
-
-**/
-EFI_STATUS
-EFIAPI
-LibSetWakeupTime (
-  IN BOOLEAN      Enabled,
-  OUT EFI_TIME    *Time
-  )
-{
-  return EFI_UNSUPPORTED;
-}
-
-/**
-  This is the declaration of an EFI image entry point. This can be the entry point to an application
-  written to this specification, an EFI boot service driver, or an EFI runtime driver.
-
-  @param  ImageHandle           Handle that identifies the loaded image.
-  @param  SystemTable           System Table for this image.
-
-  @retval EFI_SUCCESS           The operation completed successfully.
-
-**/
-EFI_STATUS
-EFIAPI
-LibRtcInitialize (
-  IN EFI_HANDLE                            ImageHandle,
-  IN EFI_SYSTEM_TABLE                      *SystemTable
-  )
-{
-  EFI_STATUS    Status;
-  EFI_HANDLE    Handle;
-  UINT8         Data;
-  EFI_TPL       OldTpl;
-
-  Status = gBS->LocateProtocol (&gEmbeddedExternalDeviceProtocolGuid, NULL, (VOID **)&gTPS65950);
-  ASSERT_EFI_ERROR(Status);
-
-  OldTpl = gBS->RaiseTPL(TPL_NOTIFY);
-  Data = 1;
-  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, RTC_CTRL_REG), 1, &Data);
-  ASSERT_EFI_ERROR(Status);
-  gBS->RestoreTPL(OldTpl);
-
-  // Setup the setters and getters
-  gRT->GetTime       = LibGetTime;
-  gRT->SetTime       = LibSetTime;
-  gRT->GetWakeupTime = LibGetWakeupTime;
-  gRT->SetWakeupTime = LibSetWakeupTime;
-
-  // Install the protocol
-  Handle = NULL;
-  Status = gBS->InstallMultipleProtocolInterfaces (
-                  &Handle,
-                  &gEfiRealTimeClockArchProtocolGuid,  NULL,
-                  NULL
-                 );
-
-  return Status;
-}
-
-/**
-  Fixup internal data so that EFI can be call in virtual mode.
-  Call the passed in Child Notify event and convert any pointers in
-  lib to virtual mode.
-
-  @param[in]    Event   The Event that is being processed
-  @param[in]    Context Event Context
-**/
-VOID
-EFIAPI
-LibRtcVirtualNotifyEvent (
-  IN EFI_EVENT        Event,
-  IN VOID             *Context
-  )
-{
-  return;
-}
+/** @file

+*

+*  Copyright (c) 2011, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+#include <Uefi.h>

+

+#include <Library/BaseMemoryLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/UefiRuntimeServicesTableLib.h>

+#include <Library/DebugLib.h>

+#include <Library/IoLib.h>

+

+#include <Protocol/RealTimeClock.h>

+#include <Protocol/EmbeddedExternalDevice.h>

+

+#include <Omap3530/Omap3530.h>

+#include <TPS65950.h>

+

+

+EMBEDDED_EXTERNAL_DEVICE   *gTPS65950;

+INT16                      TimeZone = EFI_UNSPECIFIED_TIMEZONE;

+

+/**

+  Returns the current time and date information, and the time-keeping capabilities

+  of the hardware platform.

+

+  @param  Time                  A pointer to storage to receive a snapshot of the current time.

+  @param  Capabilities          An optional pointer to a buffer to receive the real time clock

+                                device's capabilities.

+

+  @retval EFI_SUCCESS           The operation completed successfully.

+  @retval EFI_INVALID_PARAMETER Time is NULL.

+  @retval EFI_DEVICE_ERROR      The time could not be retrieved due to hardware error.

+

+**/

+EFI_STATUS

+EFIAPI

+LibGetTime (

+  OUT EFI_TIME                *Time,

+  OUT EFI_TIME_CAPABILITIES   *Capabilities

+  )

+{

+  EFI_STATUS            Status;

+  UINT8                 Data;

+  EFI_TPL               OldTpl;

+

+  if (Time == NULL) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  OldTpl = gBS->RaiseTPL(TPL_NOTIFY);

+

+  /* Get time and date */

+  ZeroMem(Time, sizeof(EFI_TIME));

+

+  // Latch values

+  Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, RTC_CTRL_REG), 1, &Data);

+  if (Status != EFI_SUCCESS) goto EXIT;

+  Data |= BIT6;

+  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, RTC_CTRL_REG), 1, &Data);

+  if (Status != EFI_SUCCESS) goto EXIT;

+

+  // Read registers

+  Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, YEARS_REG), 1, &Data);

+  if (Status != EFI_SUCCESS) goto EXIT;

+  Time->Year = 2000 + ((Data >> 4) & 0xF) * 10 + (Data & 0xF);

+

+  Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, MONTHS_REG), 1, &Data);

+  if (Status != EFI_SUCCESS) goto EXIT;

+  Time->Month = ((Data >> 4) & 0x1) * 10 + (Data & 0xF);

+

+  Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, DAYS_REG), 1, &Data);

+  if (Status != EFI_SUCCESS) goto EXIT;

+  Time->Day = ((Data >> 4) & 0x3) * 10 + (Data & 0xF);

+

+  Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, HOURS_REG), 1, &Data);

+  if (Status != EFI_SUCCESS) goto EXIT;

+  Time->Hour = ((Data >> 4) & 0x3) * 10 + (Data & 0xF);

+

+  Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, MINUTES_REG), 1, &Data);

+  if (Status != EFI_SUCCESS) goto EXIT;

+  Time->Minute = ((Data >> 4) & 0x7) * 10 + (Data & 0xF);

+

+  Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, SECONDS_REG), 1, &Data);

+  if (Status != EFI_SUCCESS) goto EXIT;

+  Time->Second = ((Data >> 4) & 0x7) * 10 + (Data & 0xF);

+

+  Time->TimeZone = TimeZone;

+  // TODO: check what to use here

+  Time->Daylight = EFI_TIME_ADJUST_DAYLIGHT;

+

+  // Set capabilities

+

+  // TODO: Set real capabilities

+  if (Capabilities != NULL) {

+    Capabilities->Resolution = 1;

+    Capabilities->Accuracy = 50000000;

+    Capabilities->SetsToZero = FALSE;

+  }

+

+EXIT:

+  gBS->RestoreTPL(OldTpl);

+

+  return (Status == EFI_SUCCESS) ? Status : EFI_DEVICE_ERROR;

+}

+

+/**

+  Sets the current local time and date information.

+

+  @param  Time                  A pointer to the current time.

+

+  @retval EFI_SUCCESS           The operation completed successfully.

+  @retval EFI_INVALID_PARAMETER A time field is out of range.

+  @retval EFI_DEVICE_ERROR      The time could not be set due due to hardware error.

+

+**/

+EFI_STATUS

+EFIAPI

+LibSetTime (

+  IN EFI_TIME                *Time

+  )

+{

+  EFI_STATUS Status;

+  UINT8      Data;

+  UINT8      MonthDayCount[12] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

+  EFI_TPL    OldTpl;

+

+  // Input validation according both to UEFI spec and hardware constraints

+  // UEFI spec says valid year range is 1900-9999 but TPS only supports 2000-2099

+  if ( (Time == NULL)

+    || (Time->Year < 2000 || Time->Year > 2099)

+    || (Time->Month < 1 || Time->Month > 12)

+    || (Time->Day < 1 || Time->Day > MonthDayCount[Time->Month])

+    || (Time->Hour > 23)

+    || (Time->Minute > 59)

+    || (Time->Second > 59)

+    || (Time->Nanosecond > 999999999)

+    || ((Time->TimeZone < -1440 || Time->TimeZone > 1440) && Time->TimeZone != 2047)

+  ) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  OldTpl = gBS->RaiseTPL(TPL_NOTIFY);

+

+  Data = Time->Year - 2000;

+  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, YEARS_REG), 1, &Data);

+  if (Status != EFI_SUCCESS) goto EXIT;

+

+  Data = ((Time->Month / 10) << 4) | (Time->Month % 10);

+  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, MONTHS_REG), 1, &Data);

+  if (Status != EFI_SUCCESS) goto EXIT;

+

+  Data = ((Time->Day / 10) << 4) | (Time->Day % 10);

+  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, DAYS_REG), 1, &Data);

+  if (Status != EFI_SUCCESS) goto EXIT;

+

+  Data = ((Time->Hour / 10) << 4) | (Time->Hour % 10);

+  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, HOURS_REG), 1, &Data);

+  if (Status != EFI_SUCCESS) goto EXIT;

+

+  Data = ((Time->Minute / 10) << 4) | (Time->Minute % 10);

+  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, MINUTES_REG), 1, &Data);

+  if (Status != EFI_SUCCESS) goto EXIT;

+

+  Data = ((Time->Second / 10) << 4) | (Time->Second % 10);

+  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, SECONDS_REG), 1, &Data);

+  if (Status != EFI_SUCCESS) goto EXIT;

+

+  TimeZone = Time->TimeZone;

+

+EXIT:

+  gBS->RestoreTPL(OldTpl);

+

+  return (Status == EFI_SUCCESS) ? Status : EFI_DEVICE_ERROR;

+}

+

+/**

+  Returns the current wakeup alarm clock setting.

+

+  @param  Enabled               Indicates if the alarm is currently enabled or disabled.

+  @param  Pending               Indicates if the alarm signal is pending and requires acknowledgement.

+  @param  Time                  The current alarm setting.

+

+  @retval EFI_SUCCESS           The alarm settings were returned.

+  @retval EFI_INVALID_PARAMETER Any parameter is NULL.

+  @retval EFI_DEVICE_ERROR      The wakeup time could not be retrieved due to a hardware error.

+

+**/

+EFI_STATUS

+EFIAPI

+LibGetWakeupTime (

+  OUT BOOLEAN     *Enabled,

+  OUT BOOLEAN     *Pending,

+  OUT EFI_TIME    *Time

+  )

+{

+  return EFI_UNSUPPORTED;

+}

+

+/**

+  Sets the system wakeup alarm clock time.

+

+  @param  Enabled               Enable or disable the wakeup alarm.

+  @param  Time                  If Enable is TRUE, the time to set the wakeup alarm for.

+

+  @retval EFI_SUCCESS           If Enable is TRUE, then the wakeup alarm was enabled. If

+                                Enable is FALSE, then the wakeup alarm was disabled.

+  @retval EFI_INVALID_PARAMETER A time field is out of range.

+  @retval EFI_DEVICE_ERROR      The wakeup time could not be set due to a hardware error.

+  @retval EFI_UNSUPPORTED       A wakeup timer is not supported on this platform.

+

+**/

+EFI_STATUS

+EFIAPI

+LibSetWakeupTime (

+  IN BOOLEAN      Enabled,

+  OUT EFI_TIME    *Time

+  )

+{

+  return EFI_UNSUPPORTED;

+}

+

+/**

+  This is the declaration of an EFI image entry point. This can be the entry point to an application

+  written to this specification, an EFI boot service driver, or an EFI runtime driver.

+

+  @param  ImageHandle           Handle that identifies the loaded image.

+  @param  SystemTable           System Table for this image.

+

+  @retval EFI_SUCCESS           The operation completed successfully.

+

+**/

+EFI_STATUS

+EFIAPI

+LibRtcInitialize (

+  IN EFI_HANDLE                            ImageHandle,

+  IN EFI_SYSTEM_TABLE                      *SystemTable

+  )

+{

+  EFI_STATUS    Status;

+  EFI_HANDLE    Handle;

+  UINT8         Data;

+  EFI_TPL       OldTpl;

+

+  Status = gBS->LocateProtocol (&gEmbeddedExternalDeviceProtocolGuid, NULL, (VOID **)&gTPS65950);

+  ASSERT_EFI_ERROR(Status);

+

+  OldTpl = gBS->RaiseTPL(TPL_NOTIFY);

+  Data = 1;

+  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, RTC_CTRL_REG), 1, &Data);

+  ASSERT_EFI_ERROR(Status);

+  gBS->RestoreTPL(OldTpl);

+

+  // Setup the setters and getters

+  gRT->GetTime       = LibGetTime;

+  gRT->SetTime       = LibSetTime;

+  gRT->GetWakeupTime = LibGetWakeupTime;

+  gRT->SetWakeupTime = LibSetWakeupTime;

+

+  // Install the protocol

+  Handle = NULL;

+  Status = gBS->InstallMultipleProtocolInterfaces (

+                  &Handle,

+                  &gEfiRealTimeClockArchProtocolGuid,  NULL,

+                  NULL

+                 );

+

+  return Status;

+}

+

+/**

+  Fixup internal data so that EFI can be call in virtual mode.

+  Call the passed in Child Notify event and convert any pointers in

+  lib to virtual mode.

+

+  @param[in]    Event   The Event that is being processed

+  @param[in]    Context Event Context

+**/

+VOID

+EFIAPI

+LibRtcVirtualNotifyEvent (

+  IN EFI_EVENT        Event,

+  IN VOID             *Context

+  )

+{

+  return;

+}

diff --git a/Omap35xxPkg/Library/RealTimeClockLib/RealTimeClockLib.inf b/Omap35xxPkg/Library/RealTimeClockLib/RealTimeClockLib.inf
index c62257df..7c4911c3 100755
--- a/Omap35xxPkg/Library/RealTimeClockLib/RealTimeClockLib.inf
+++ b/Omap35xxPkg/Library/RealTimeClockLib/RealTimeClockLib.inf
@@ -1,38 +1,38 @@
-#  Copyright (c) 2011, ARM Limited. All rights reserved.
-#  
-#  This program and the accompanying materials                          
-#  are licensed and made available under the terms and conditions of the BSD License         
-#  which accompanies this distribution.  The full text of the license may be found at        
-#  http://opensource.org/licenses/bsd-license.php                                            
-#
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-#
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = RealTimeClockLib 
-  FILE_GUID                      = EC1713DB-7DB5-4c99-8FE2-6F52F95A1132
-  MODULE_TYPE                    = BASE
-  VERSION_STRING                 = 1.0
-  LIBRARY_CLASS                  = RealTimeClockLib
-
-[Sources.common]
-  RealTimeClockLib.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  EmbeddedPkg/EmbeddedPkg.dec
-  Omap35xxPkg/Omap35xxPkg.dec
-  
-[LibraryClasses]
-  IoLib
-  UefiLib
-  DebugLib
-  PcdLib
-
-[Protocols]
-  gEmbeddedExternalDeviceProtocolGuid
-
-[depex]
-  gEmbeddedExternalDeviceProtocolGuid
+#  Copyright (c) 2011, ARM Limited. All rights reserved.

+#  

+#  This program and the accompanying materials                          

+#  are licensed and made available under the terms and conditions of the BSD License         

+#  which accompanies this distribution.  The full text of the license may be found at        

+#  http://opensource.org/licenses/bsd-license.php                                            

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+#

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = RealTimeClockLib 

+  FILE_GUID                      = EC1713DB-7DB5-4c99-8FE2-6F52F95A1132

+  MODULE_TYPE                    = BASE

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = RealTimeClockLib

+

+[Sources.common]

+  RealTimeClockLib.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  EmbeddedPkg/EmbeddedPkg.dec

+  Omap35xxPkg/Omap35xxPkg.dec

+  

+[LibraryClasses]

+  IoLib

+  UefiLib

+  DebugLib

+  PcdLib

+

+[Protocols]

+  gEmbeddedExternalDeviceProtocolGuid

+

+[depex]

+  gEmbeddedExternalDeviceProtocolGuid

diff --git a/Omap35xxPkg/Library/SerialPortLib/SerialPortLib.c b/Omap35xxPkg/Library/SerialPortLib/SerialPortLib.c
index 9a70593d..2f93140e 100644
--- a/Omap35xxPkg/Library/SerialPortLib/SerialPortLib.c
+++ b/Omap35xxPkg/Library/SerialPortLib/SerialPortLib.c
@@ -17,7 +17,6 @@
 #include <Base.h>

 #include <Library/DebugLib.h>

 #include <Library/SerialPortLib.h>

-#include <Library/SerialPortExtLib.h>

 #include <Library/PcdLib.h>

 #include <Library/IoLib.h>

 #include <Library/OmapLib.h>

@@ -123,57 +122,3 @@ SerialPortPoll (
   }

 }

 

-/**

-  Set the serial device control bits.

-

-  @return    Always return EFI_UNSUPPORTED.

-

-**/

-RETURN_STATUS

-EFIAPI

-SerialPortSetControl (

-  IN UINT32                   Control

-  )

-{

-  return RETURN_SUCCESS;

-}

-

-/**

-  Get the serial device control bits.

-

-  @param  Control                 Control signals read from the serial device.

-

-  @retval EFI_SUCCESS             The control bits were read from the serial device.

-  @retval EFI_DEVICE_ERROR        The serial device is not functioning correctly.

-

-**/

-RETURN_STATUS

-EFIAPI

-SerialPortGetControl (

-  OUT UINT32                  *Control

-  )

-{

-  return RETURN_SUCCESS;

-}

-

-

-/**

-  Set the serial device attributes.

-

-  @return    Always return EFI_UNSUPPORTED.

-

-**/

-RETURN_STATUS

-EFIAPI

-SerialPortSetAttributes (

-  IN UINT64              BaudRate,

-  IN UINT32              ReceiveFifoDepth,

-  IN UINT32              Timeout,

-  IN EFI_PARITY_TYPE     Parity,

-  IN UINT8               DataBits,

-  IN EFI_STOP_BITS_TYPE  StopBits

-  )

-{

-  return RETURN_SUCCESS;

-}

-

diff --git a/Omap35xxPkg/Library/SerialPortLib/SerialPortLib.inf b/Omap35xxPkg/Library/SerialPortLib/SerialPortLib.inf
index a7d4fadc..340f4a6a 100644
--- a/Omap35xxPkg/Library/SerialPortLib/SerialPortLib.inf
+++ b/Omap35xxPkg/Library/SerialPortLib/SerialPortLib.inf
@@ -17,13 +17,13 @@
   INF_VERSION                    = 0x00010005

   BASE_NAME                      = BeagleBoardSerialPortLib

   FILE_GUID                      = 97546cbd-c0ff-4c48-ab0b-e4f58862acd3

-  MODULE_TYPE                    = PEIM

+  MODULE_TYPE                    = BASE

   VERSION_STRING                 = 1.0

   LIBRARY_CLASS                  = SerialPortLib

 

 

 #

-#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC

+#  VALID_ARCHITECTURES           = ARM IA32 X64 IPF EBC

 #

 

 [Sources.common]

diff --git a/Omap35xxPkg/MMCHSDxe/MMCHS.c b/Omap35xxPkg/MMCHSDxe/MMCHS.c
index 786bc882..7d4e22f5 100644
--- a/Omap35xxPkg/MMCHSDxe/MMCHS.c
+++ b/Omap35xxPkg/MMCHSDxe/MMCHS.c
@@ -1,1495 +1,1495 @@
-/** @file
-  MMC/SD Card driver for OMAP 35xx (SDIO not supported)
-
-  This driver always produces a BlockIo protocol but it starts off with no Media
-  present. A TimerCallBack detects when media is inserted or removed and after 
-  a media change event a call to BlockIo ReadBlocks/WriteBlocks will cause the 
-  media to be detected (or removed) and the BlockIo Media structure will get
-  updated. No MMC/SD Card harward registers are updated until the first BlockIo
-  ReadBlocks/WriteBlocks after media has been insterted (booting with a card 
-  plugged in counts as an insertion event). 
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include "MMCHS.h"
-
-EFI_BLOCK_IO_MEDIA gMMCHSMedia = {
-  SIGNATURE_32('s','d','i','o'),            // MediaId
-  TRUE,                                     // RemovableMedia
-  FALSE,                                    // MediaPresent
-  FALSE,                                    // LogicalPartition
-  FALSE,                                    // ReadOnly
-  FALSE,                                    // WriteCaching
-  512,                                      // BlockSize
-  4,                                        // IoAlign
-  0,                                        // Pad
-  0                                         // LastBlock
-};
-
-typedef struct {
-  VENDOR_DEVICE_PATH  Mmc;
-  EFI_DEVICE_PATH     End;
-} MMCHS_DEVICE_PATH;
-
-MMCHS_DEVICE_PATH gMmcHsDevicePath = {
-  {
-    HARDWARE_DEVICE_PATH,
-    HW_VENDOR_DP,
-    (UINT8)(sizeof(VENDOR_DEVICE_PATH)),
-    (UINT8)((sizeof(VENDOR_DEVICE_PATH)) >> 8),
-    0xb615f1f5, 0x5088, 0x43cd, 0x80, 0x9c, 0xa1, 0x6e, 0x52, 0x48, 0x7d, 0x00 
-  },
-  {
-    END_DEVICE_PATH_TYPE,
-    END_ENTIRE_DEVICE_PATH_SUBTYPE,
-    sizeof (EFI_DEVICE_PATH_PROTOCOL),
-    0
-  }
-};
-
-CARD_INFO                  gCardInfo;
-EMBEDDED_EXTERNAL_DEVICE   *gTPS65950;
-EFI_EVENT                  gTimerEvent;
-BOOLEAN                    gMediaChange = FALSE;
-
-//
-// Internal Functions
-//
-
-
-VOID
-ParseCardCIDData (
-  UINT32 Response0, 
-  UINT32 Response1, 
-  UINT32 Response2,
-  UINT32 Response3
-  )
-{
-  gCardInfo.CIDData.MDT = ((Response0 >> 8) & 0xFFF);
-  gCardInfo.CIDData.PSN = (((Response0 >> 24) & 0xFF) | ((Response1 & 0xFFFFFF) << 8));
-  gCardInfo.CIDData.PRV = ((Response1 >> 24) & 0xFF);
-  gCardInfo.CIDData.PNM[4] = ((Response2) & 0xFF);
-  gCardInfo.CIDData.PNM[3] = ((Response2 >> 8) & 0xFF);
-  gCardInfo.CIDData.PNM[2] = ((Response2 >> 16) & 0xFF);
-  gCardInfo.CIDData.PNM[1] = ((Response2 >> 24) & 0xFF);
-  gCardInfo.CIDData.PNM[0] = ((Response3) & 0xFF);
-  gCardInfo.CIDData.OID = ((Response3 >> 8) & 0xFFFF);
-  gCardInfo.CIDData.MID = ((Response3 >> 24) & 0xFF);
-}
-
-
-VOID
-UpdateMMCHSClkFrequency (
-  UINTN NewCLKD
-  )
-{
-  //Set Clock enable to 0x0 to not provide the clock to the card
-  MmioAnd32 (MMCHS_SYSCTL, ~CEN);
-
-  //Set new clock frequency.
-  MmioAndThenOr32 (MMCHS_SYSCTL, ~CLKD_MASK, NewCLKD << 6); 
-
-  //Poll till Internal Clock Stable
-  while ((MmioRead32 (MMCHS_SYSCTL) & ICS_MASK) != ICS);
-
-  //Set Clock enable to 0x1 to provide the clock to the card
-  MmioOr32 (MMCHS_SYSCTL, CEN);
-}
-
-
-EFI_STATUS
-SendCmd (
-  UINTN Cmd,
-  UINTN CmdInterruptEnableVal,
-  UINTN CmdArgument
-  )
-{
-  UINTN MmcStatus;
-  UINTN RetryCount = 0;
-
-  //Check if command line is in use or not. Poll till command line is available.
-  while ((MmioRead32 (MMCHS_PSTATE) & DATI_MASK) == DATI_NOT_ALLOWED);
-
-  //Provide the block size.
-  MmioWrite32 (MMCHS_BLK, BLEN_512BYTES);
-
-  //Setting Data timeout counter value to max value.
-  MmioAndThenOr32 (MMCHS_SYSCTL, ~DTO_MASK, DTO_VAL);
-
-  //Clear Status register.
-  MmioWrite32 (MMCHS_STAT, 0xFFFFFFFF);
-
-  //Set command argument register
-  MmioWrite32 (MMCHS_ARG, CmdArgument);
-
-  //Enable interrupt enable events to occur
-  MmioWrite32 (MMCHS_IE, CmdInterruptEnableVal);
-
-  //Send a command
-  MmioWrite32 (MMCHS_CMD, Cmd);
-
-  //Check for the command status.
-  while (RetryCount < MAX_RETRY_COUNT) {
-    do {
-      MmcStatus = MmioRead32 (MMCHS_STAT);
-    } while (MmcStatus == 0);
-
-    //Read status of command response
-    if ((MmcStatus & ERRI) != 0) {
-
-      //Perform soft-reset for mmci_cmd line.
-      MmioOr32 (MMCHS_SYSCTL, SRC);
-      while ((MmioRead32 (MMCHS_SYSCTL) & SRC));
-
-      DEBUG ((EFI_D_INFO, "MmcStatus: %x\n", MmcStatus));
-      return EFI_DEVICE_ERROR;
-    }
-
-    //Check if command is completed.
-    if ((MmcStatus & CC) == CC) {
-      MmioWrite32 (MMCHS_STAT, CC);
-      break;
-    }
-
-    RetryCount++;
-  }
-
-  if (RetryCount == MAX_RETRY_COUNT) {
-    return EFI_TIMEOUT;
-  }
-
-  return EFI_SUCCESS;
-}
-
-
-VOID
-GetBlockInformation (
-  UINTN *BlockSize,
-  UINTN *NumBlocks
-  )
-{
-  CSD_SDV2 *CsdSDV2Data;
-  UINTN    CardSize;
-
-  if (gCardInfo.CardType == SD_CARD_2_HIGH) {
-    CsdSDV2Data = (CSD_SDV2 *)&gCardInfo.CSDData;
-
-    //Populate BlockSize.
-    *BlockSize = (0x1UL << CsdSDV2Data->READ_BL_LEN);
-
-    //Calculate Total number of blocks.
-    CardSize = CsdSDV2Data->C_SIZELow16 | (CsdSDV2Data->C_SIZEHigh6 << 2);
-    *NumBlocks = ((CardSize + 1) * 1024);
-  } else {
-    //Populate BlockSize.
-    *BlockSize = (0x1UL << gCardInfo.CSDData.READ_BL_LEN);
-
-    //Calculate Total number of blocks.
-    CardSize = gCardInfo.CSDData.C_SIZELow2 | (gCardInfo.CSDData.C_SIZEHigh10 << 2);
-    *NumBlocks = (CardSize + 1) * (1 << (gCardInfo.CSDData.C_SIZE_MULT + 2));
-  }
-
-  //For >=2G card, BlockSize may be 1K, but the transfer size is 512 bytes.
-  if (*BlockSize > 512) {
-    *NumBlocks = MultU64x32(*NumBlocks, *BlockSize/2);
-    *BlockSize = 512;
-  }
-
-  DEBUG ((EFI_D_INFO, "Card type: %x, BlockSize: %x, NumBlocks: %x\n", gCardInfo.CardType, *BlockSize, *NumBlocks));
-}
-
-
-VOID
-CalculateCardCLKD (
-  UINTN *ClockFrequencySelect
-  )
-{
-  UINT8    MaxDataTransferRate;
-  UINTN    TransferRateValue = 0;
-  UINTN    TimeValue = 0 ;
-  UINTN    Frequency = 0;
-
-  MaxDataTransferRate = gCardInfo.CSDData.TRAN_SPEED;
-
-  // For SD Cards  we would need to send CMD6 to set
-  // speeds abouve 25MHz. High Speed mode 50 MHz and up
-
-  //Calculate Transfer rate unit (Bits 2:0 of TRAN_SPEED)
-  switch (MaxDataTransferRate & 0x7) {
-    case 0:
-      TransferRateValue = 100 * 1000;
-      break;
-
-    case 1:
-      TransferRateValue = 1 * 1000 * 1000;
-      break;
-
-    case 2:
-      TransferRateValue = 10 * 1000 * 1000;
-      break;
-
-    case 3:
-      TransferRateValue = 100 * 1000 * 1000;
-      break;
-
-    default:
-      DEBUG((EFI_D_ERROR, "Invalid parameter.\n"));
-      ASSERT(FALSE);
-  }
-
-  //Calculate Time value (Bits 6:3 of TRAN_SPEED)
-  switch ((MaxDataTransferRate >> 3) & 0xF) {
-    case 1:
-      TimeValue = 10;
-      break;
-
-    case 2:
-      TimeValue = 12;
-      break;
-
-    case 3:
-      TimeValue = 13;
-      break;
-
-    case 4:
-      TimeValue = 15;
-      break;
-
-    case 5:
-      TimeValue = 20;
-      break;
-
-    case 6:
-      TimeValue = 25;
-      break;
-
-    case 7:
-      TimeValue = 30;
-      break;
-
-    case 8:
-      TimeValue = 35;
-      break;
-
-    case 9:
-      TimeValue = 40;
-      break;
-
-    case 10:
-      TimeValue = 45;
-      break;
-
-    case 11:
-      TimeValue = 50;
-      break;
-
-    case 12:
-      TimeValue = 55;
-      break;
-
-    case 13:
-      TimeValue = 60;
-      break;
-
-    case 14:
-      TimeValue = 70;
-      break;
-
-    case 15:
-      TimeValue = 80;
-      break;
-
-    default:
-      DEBUG((EFI_D_ERROR, "Invalid parameter.\n"));
-      ASSERT(FALSE);
-  }
-
-  Frequency = TransferRateValue * TimeValue/10;
-
-  //Calculate Clock divider value to program in MMCHS_SYSCTL[CLKD] field.
-  *ClockFrequencySelect = ((MMC_REFERENCE_CLK/Frequency) + 1);
-
-  DEBUG ((EFI_D_INFO, "MaxDataTransferRate: 0x%x, Frequency: %d KHz, ClockFrequencySelect: %x\n", MaxDataTransferRate, Frequency/1000, *ClockFrequencySelect));
-}
-
-
-VOID
-GetCardConfigurationData (
-  VOID
-  )
-{
-  UINTN  BlockSize;
-  UINTN  NumBlocks;
-  UINTN  ClockFrequencySelect;
-
-  //Calculate BlockSize and Total number of blocks in the detected card.
-  GetBlockInformation(&BlockSize, &NumBlocks);
-  gCardInfo.BlockSize = BlockSize;
-  gCardInfo.NumBlocks = NumBlocks;
-
-  //Calculate Card clock divider value.
-  CalculateCardCLKD(&ClockFrequencySelect);
-  gCardInfo.ClockFrequencySelect = ClockFrequencySelect;
-}
-
-
-EFI_STATUS
-InitializeMMCHS (
-  VOID
-  )
-{
-  UINT8      Data = 0;
-  EFI_STATUS Status;
-
-  //Select Device group to belong to P1 device group in Power IC.
-  Data = DEV_GRP_P1;
-  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VMMC1_DEV_GRP), 1, &Data);
-  ASSERT_EFI_ERROR(Status);
-
-  //Configure voltage regulator for MMC1 in Power IC to output 3.0 voltage.
-  Data = VSEL_3_00V;
-  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VMMC1_DEDICATED_REG), 1, &Data);
-  ASSERT_EFI_ERROR(Status);
-  
-  //After ramping up voltage, set VDDS stable bit to indicate that voltage level is stable.
-  MmioOr32 (CONTROL_PBIAS_LITE, (PBIASLITEVMODE0 | PBIASLITEPWRDNZ0 | PBIASSPEEDCTRL0 | PBIASLITEVMODE1 | PBIASLITEWRDNZ1));
-
-  // Enable WP GPIO
-  MmioAndThenOr32 (GPIO1_BASE + GPIO_OE, ~BIT23, BIT23);
-
-  // Enable Card Detect
-  Data = CARD_DETECT_ENABLE;
-  gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, TPS65950_GPIO_CTRL), 1, &Data);
-
-
-  return Status;
-}
-
-
-EFI_STATUS
-PerformCardIdenfication (
-  VOID
-  )
-{
-  EFI_STATUS Status;
-  UINTN      CmdArgument = 0;
-  UINTN      Response = 0;
-  UINTN      RetryCount = 0;
-  BOOLEAN    SDCmd8Supported = FALSE;
-
-  //Enable interrupts.
-  MmioWrite32 (MMCHS_IE, (BADA_EN | CERR_EN | DEB_EN | DCRC_EN | DTO_EN | CIE_EN |
-    CEB_EN | CCRC_EN | CTO_EN | BRR_EN | BWR_EN | TC_EN | CC_EN));
-
-  //Controller INIT procedure start.
-  MmioOr32 (MMCHS_CON, INIT);
-  MmioWrite32 (MMCHS_CMD, 0x00000000);
-  while (!(MmioRead32 (MMCHS_STAT) & CC));
-
-  //Wait for 1 ms
-  gBS->Stall(1000);
-
-  //Set CC bit to 0x1 to clear the flag
-  MmioOr32 (MMCHS_STAT, CC);
-
-  //Retry INIT procedure.
-  MmioWrite32 (MMCHS_CMD, 0x00000000);
-  while (!(MmioRead32 (MMCHS_STAT) & CC));
-
-  //End initialization sequence
-  MmioAnd32 (MMCHS_CON, ~INIT);
-
-  MmioOr32 (MMCHS_HCTL, (SDVS_3_0_V | DTW_1_BIT | SDBP_ON));
-
-  //Change clock frequency to 400KHz to fit protocol
-  UpdateMMCHSClkFrequency(CLKD_400KHZ);
-
-  MmioOr32 (MMCHS_CON, OD);
-
-  //Send CMD0 command.
-  Status = SendCmd (CMD0, CMD0_INT_EN, CmdArgument);
-  if (EFI_ERROR(Status)) {
-    DEBUG ((EFI_D_ERROR, "Cmd0 fails.\n"));
-    return Status;
-  }
-
-  DEBUG ((EFI_D_INFO, "CMD0 response: %x\n", MmioRead32 (MMCHS_RSP10)));
-
-  //Send CMD5 command. 
-  Status = SendCmd (CMD5, CMD5_INT_EN, CmdArgument);
-  if (Status == EFI_SUCCESS) {
-    DEBUG ((EFI_D_ERROR, "CMD5 Success. SDIO card. Follow SDIO card specification.\n"));
-    DEBUG ((EFI_D_INFO, "CMD5 response: %x\n", MmioRead32 (MMCHS_RSP10)));
-    //NOTE: Returning unsupported error for now. Need to implement SDIO specification.
-    return EFI_UNSUPPORTED; 
-  } else {
-    DEBUG ((EFI_D_INFO, "CMD5 fails. Not an SDIO card.\n"));
-  }
-
-  MmioOr32 (MMCHS_SYSCTL, SRC);
-  gBS->Stall(1000);
-  while ((MmioRead32 (MMCHS_SYSCTL) & SRC));
-
-  //Send CMD8 command. (New v2.00 command for Voltage check)
-  //Only 2.7V - 3.6V is supported for SD2.0, only SD 2.0 card can pass.
-  //MMC & SD1.1 card will fail this command.
-  CmdArgument = CMD8_ARG;
-  Status = SendCmd (CMD8, CMD8_INT_EN, CmdArgument);
-  if (Status == EFI_SUCCESS) {
-    Response = MmioRead32 (MMCHS_RSP10);
-    DEBUG ((EFI_D_INFO, "CMD8 success. CMD8 response: %x\n", Response));
-    if (Response != CmdArgument) {
-      return EFI_DEVICE_ERROR;
-    }
-    DEBUG ((EFI_D_INFO, "Card is SD2.0\n"));
-    SDCmd8Supported = TRUE; //Supports high capacity.
-  } else {
-    DEBUG ((EFI_D_INFO, "CMD8 fails. Not an SD2.0 card.\n"));
-  }
-
-  MmioOr32 (MMCHS_SYSCTL, SRC);
-  gBS->Stall(1000);
-  while ((MmioRead32 (MMCHS_SYSCTL) & SRC));
-
-  //Poll till card is busy
-  while (RetryCount < MAX_RETRY_COUNT) {
-    //Send CMD55 command. 
-    CmdArgument = 0;
-    Status = SendCmd (CMD55, CMD55_INT_EN, CmdArgument);
-    if (Status == EFI_SUCCESS) {
-      DEBUG ((EFI_D_INFO, "CMD55 success. CMD55 response: %x\n", MmioRead32 (MMCHS_RSP10)));
-      gCardInfo.CardType = SD_CARD;
-    } else {
-      DEBUG ((EFI_D_INFO, "CMD55 fails.\n"));
-      gCardInfo.CardType = MMC_CARD;
-    }
-
-    //Send appropriate command for the card type which got detected.
-    if (gCardInfo.CardType == SD_CARD) {
-      CmdArgument = ((UINTN *) &(gCardInfo.OCRData))[0];
-
-      //Set HCS bit.
-      if (SDCmd8Supported) {
-        CmdArgument |= HCS;
-      }
-
-      Status = SendCmd (ACMD41, ACMD41_INT_EN, CmdArgument);
-      if (EFI_ERROR(Status)) {
-        DEBUG ((EFI_D_INFO, "ACMD41 fails.\n"));
-        return Status;
-      }
-      ((UINT32 *) &(gCardInfo.OCRData))[0] = MmioRead32 (MMCHS_RSP10);
-      DEBUG ((EFI_D_INFO, "SD card detected. ACMD41 OCR: %x\n", ((UINT32 *) &(gCardInfo.OCRData))[0]));
-    } else if (gCardInfo.CardType == MMC_CARD) {
-      CmdArgument = 0;
-      Status = SendCmd (CMD1, CMD1_INT_EN, CmdArgument);
-      if (EFI_ERROR(Status)) {
-        DEBUG ((EFI_D_INFO, "CMD1 fails.\n"));
-        return Status;
-      }
-      Response = MmioRead32 (MMCHS_RSP10);
-      DEBUG ((EFI_D_INFO, "MMC card detected.. CMD1 response: %x\n", Response));
-
-      //NOTE: For now, I am skipping this since I only have an SD card.
-      //Compare card OCR and host OCR (Section 22.6.1.3.2.4)
-      return EFI_UNSUPPORTED; //For now, MMC is not supported.
-    }
-
-    //Poll the card until it is out of its power-up sequence.
-    if (gCardInfo.OCRData.Busy == 1) {
-
-      if (SDCmd8Supported) {
-        gCardInfo.CardType = SD_CARD_2;
-      }
-
-      //Card is ready. Check CCS (Card capacity status) bit (bit#30).
-      //SD 2.0 standard card will response with CCS 0, SD high capacity card will respond with CCS 1.
-      if (gCardInfo.OCRData.AccessMode & BIT1) {
-        gCardInfo.CardType = SD_CARD_2_HIGH;
-        DEBUG ((EFI_D_INFO, "High capacity card.\n"));
-      } else {
-        DEBUG ((EFI_D_INFO, "Standard capacity card.\n"));
-      }
-
-      break;
-    }
-
-    gBS->Stall(1000);
-    RetryCount++;
-  }
-
-  if (RetryCount == MAX_RETRY_COUNT) {
-    DEBUG ((EFI_D_ERROR, "Timeout error. RetryCount: %d\n", RetryCount));
-    return EFI_TIMEOUT;
-  }
-
-  //Read CID data.
-  CmdArgument = 0;
-  Status = SendCmd (CMD2, CMD2_INT_EN, CmdArgument);
-  if (EFI_ERROR(Status)) {
-    DEBUG ((EFI_D_ERROR, "CMD2 fails. Status: %x\n", Status));
-    return Status;
-  }
-
-  DEBUG ((EFI_D_INFO, "CMD2 response: %x %x %x %x\n", MmioRead32 (MMCHS_RSP10), MmioRead32 (MMCHS_RSP32), MmioRead32 (MMCHS_RSP54), MmioRead32 (MMCHS_RSP76)));
-
-  //Parse CID register data.
-  ParseCardCIDData(MmioRead32 (MMCHS_RSP10), MmioRead32 (MMCHS_RSP32), MmioRead32 (MMCHS_RSP54), MmioRead32 (MMCHS_RSP76));
-
-  //Read RCA
-  CmdArgument = 0;
-  Status = SendCmd (CMD3, CMD3_INT_EN, CmdArgument);
-  if (EFI_ERROR(Status)) {
-    DEBUG ((EFI_D_ERROR, "CMD3 fails. Status: %x\n", Status));
-    return Status;
-  }
-
-  //Set RCA for the detected card. RCA is CMD3 response.
-  gCardInfo.RCA = (MmioRead32 (MMCHS_RSP10) >> 16);
-  DEBUG ((EFI_D_INFO, "CMD3 response: RCA %x\n", gCardInfo.RCA));
-
-  //MMC Bus setting change after card identification.
-  MmioAnd32 (MMCHS_CON, ~OD);
-  MmioOr32 (MMCHS_HCTL, SDVS_3_0_V);
-  UpdateMMCHSClkFrequency(CLKD_400KHZ); //Set the clock frequency to 400KHz.
-
-  return EFI_SUCCESS;
-}
-
-
-EFI_STATUS
-GetCardSpecificData (
-  VOID
-  )
-{
-  EFI_STATUS Status;
-  UINTN      CmdArgument;
-
-  //Send CMD9 to retrieve CSD.
-  CmdArgument = gCardInfo.RCA << 16;
-  Status = SendCmd (CMD9, CMD9_INT_EN, CmdArgument);
-  if (EFI_ERROR(Status)) {
-    DEBUG ((EFI_D_ERROR, "CMD9 fails. Status: %x\n", Status));
-    return Status;
-  }
-
-  //Populate 128-bit CSD register data.
-  ((UINT32 *)&(gCardInfo.CSDData))[0] = MmioRead32 (MMCHS_RSP10);
-  ((UINT32 *)&(gCardInfo.CSDData))[1] = MmioRead32 (MMCHS_RSP32);
-  ((UINT32 *)&(gCardInfo.CSDData))[2] = MmioRead32 (MMCHS_RSP54);
-  ((UINT32 *)&(gCardInfo.CSDData))[3] = MmioRead32 (MMCHS_RSP76);
-
-  DEBUG ((EFI_D_INFO, "CMD9 response: %x %x %x %x\n", MmioRead32 (MMCHS_RSP10), MmioRead32 (MMCHS_RSP32), MmioRead32 (MMCHS_RSP54), MmioRead32 (MMCHS_RSP76)));
-
-  //Calculate total number of blocks and max. data transfer rate supported by the detected card.
-  GetCardConfigurationData();
-
-  return Status;
-}
-
-
-EFI_STATUS
-PerformCardConfiguration (
-  VOID
-  )
-{
-  UINTN      CmdArgument = 0;
-  EFI_STATUS Status;
-
-  //Send CMD7
-  CmdArgument = gCardInfo.RCA << 16;
-  Status = SendCmd (CMD7, CMD7_INT_EN, CmdArgument);
-  if (EFI_ERROR(Status)) {
-    DEBUG ((EFI_D_ERROR, "CMD7 fails. Status: %x\n", Status));
-    return Status;
-  }
-
-  if ((gCardInfo.CardType != UNKNOWN_CARD) && (gCardInfo.CardType != MMC_CARD)) {
-    // We could read SCR register, but SD Card Phys spec stats any SD Card shall
-    // set SCR.SD_BUS_WIDTHS to support 4-bit mode, so why bother?
- 
-    // Send ACMD6 (application specific commands must be prefixed with CMD55)
-    Status = SendCmd (CMD55, CMD55_INT_EN, CmdArgument);
-    if (!EFI_ERROR (Status)) {
-      // set device into 4-bit data bus mode
-      Status = SendCmd (ACMD6, ACMD6_INT_EN, 0x2);
-      if (!EFI_ERROR (Status)) {
-        // Set host controler into 4-bit mode
-        MmioOr32 (MMCHS_HCTL, DTW_4_BIT);
-        DEBUG ((EFI_D_INFO, "SD Memory Card set to 4-bit mode\n"));
-      }
-    }
-  }
-
-  //Send CMD16 to set the block length
-  CmdArgument = gCardInfo.BlockSize;
-  Status = SendCmd (CMD16, CMD16_INT_EN, CmdArgument);
-  if (EFI_ERROR(Status)) {
-    DEBUG ((EFI_D_ERROR, "CMD16 fails. Status: %x\n", Status));
-    return Status;
-  }
-
-  //Change MMCHS clock frequency to what detected card can support.
-  UpdateMMCHSClkFrequency(gCardInfo.ClockFrequencySelect);
-
-  return EFI_SUCCESS;
-}
-
-
-EFI_STATUS
-ReadBlockData (
-  IN  EFI_BLOCK_IO_PROTOCOL       *This,
-  OUT VOID                        *Buffer
-  )
-{
-  UINTN MmcStatus;
-  UINTN *DataBuffer = Buffer;
-  UINTN DataSize = This->Media->BlockSize/4;
-  UINTN Count;
-  UINTN RetryCount = 0;
-
-  //Check controller status to make sure there is no error.
-  while (RetryCount < MAX_RETRY_COUNT) {
-    do {
-      //Read Status.
-      MmcStatus = MmioRead32 (MMCHS_STAT);
-    } while(MmcStatus == 0);
-
-    //Check if Buffer read ready (BRR) bit is set?
-    if (MmcStatus & BRR) {
-
-      //Clear BRR bit
-      MmioOr32 (MMCHS_STAT, BRR);
-
-      //Read block worth of data.
-      for (Count = 0; Count < DataSize; Count++) {
-        *DataBuffer++ = MmioRead32 (MMCHS_DATA);
-      }
-      break;
-    }
-    RetryCount++;
-  }
-
-  if (RetryCount == MAX_RETRY_COUNT) {
-    return EFI_TIMEOUT;
-  }
-
-  return EFI_SUCCESS;
-}
-
-
-EFI_STATUS
-WriteBlockData (
-  IN  EFI_BLOCK_IO_PROTOCOL       *This,
-  OUT VOID                        *Buffer
-  )
-{
-  UINTN MmcStatus;
-  UINTN *DataBuffer = Buffer;
-  UINTN DataSize = This->Media->BlockSize/4;
-  UINTN Count;
-  UINTN RetryCount = 0;
-
-  //Check controller status to make sure there is no error.
-  while (RetryCount < MAX_RETRY_COUNT) {
-    do {
-      //Read Status.
-      MmcStatus = MmioRead32 (MMCHS_STAT);
-    } while(MmcStatus == 0);
-
-    //Check if Buffer write ready (BWR) bit is set?
-    if (MmcStatus & BWR) {
-
-      //Clear BWR bit
-      MmioOr32 (MMCHS_STAT, BWR);
-
-      //Write block worth of data.
-      for (Count = 0; Count < DataSize; Count++) {
-        MmioWrite32 (MMCHS_DATA, *DataBuffer++);
-      }
-
-      break;
-    }
-    RetryCount++;
-  }
-
-  if (RetryCount == MAX_RETRY_COUNT) {
-    return EFI_TIMEOUT;
-  }
-
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-DmaBlocks (
-  IN EFI_BLOCK_IO_PROTOCOL        *This,
-  IN  UINTN                       Lba,
-  IN OUT VOID                     *Buffer,
-  IN  UINTN                       BlockCount,
-  IN  OPERATION_TYPE              OperationType
-  )
-{
-  EFI_STATUS            Status;
-  UINTN                 DmaSize = 0;
-  UINTN                 Cmd = 0;
-  UINTN                 CmdInterruptEnable;
-  UINTN                 CmdArgument;
-  VOID                  *BufferMap;
-  EFI_PHYSICAL_ADDRESS  BufferAddress;
-  OMAP_DMA4             Dma4;
-  DMA_MAP_OPERATION     DmaOperation;
-  EFI_STATUS            MmcStatus;
-  UINTN                 RetryCount = 0;
-
-CpuDeadLoop ();
-  // Map passed in buffer for DMA xfer
-  DmaSize = BlockCount * This->Media->BlockSize;
-  Status = DmaMap (DmaOperation, Buffer, &DmaSize, &BufferAddress, &BufferMap);
-  if (EFI_ERROR (Status)) {
-    return Status;
-  }
-
-  ZeroMem (&DmaOperation, sizeof (DMA_MAP_OPERATION));
-  
-
-  Dma4.DataType = 2;                      // DMA4_CSDPi[1:0]   32-bit elements from MMCHS_DATA
-
-  Dma4.SourceEndiansim = 0;               // DMA4_CSDPi[21]    
-
-  Dma4.DestinationEndianism = 0;          // DMA4_CSDPi[19]
-
-  Dma4.SourcePacked = 0;                  // DMA4_CSDPi[6]
-
-  Dma4.DestinationPacked = 0;             // DMA4_CSDPi[13]
-
-  Dma4.NumberOfElementPerFrame = This->Media->BlockSize/4; // DMA4_CENi  (TRM 4K is optimum value)  
-
-  Dma4.NumberOfFramePerTransferBlock = BlockCount;         // DMA4_CFNi    
-
-  Dma4.ReadPriority = 0;                  // DMA4_CCRi[6]      Low priority read  
-
-  Dma4.WritePriority = 0;                 // DMA4_CCRi[23]     Prefetech disabled
-
-
-  //Populate the command information based on the operation type.
-  if (OperationType == READ) {
-    Cmd = CMD18; //Multiple block read
-    CmdInterruptEnable = CMD18_INT_EN;
-    DmaOperation = MapOperationBusMasterCommonBuffer;
-
-    Dma4.ReadPortAccessType =0 ;            // DMA4_CSDPi[8:7]   Can not burst MMCHS_DATA reg
-
-    Dma4.WritePortAccessType = 3;           // DMA4_CSDPi[15:14] Memory burst 16x32
-
-    Dma4.WriteMode = 1;                     // DMA4_CSDPi[17:16] Write posted
-
-    
-
-    Dma4.SourceStartAddress = MMCHS_DATA;                   // DMA4_CSSAi
-
-    Dma4.DestinationStartAddress = (UINT32)BufferAddress;   // DMA4_CDSAi
-
-    Dma4.SourceElementIndex = 1;                            // DMA4_CSEi
-
-    Dma4.SourceFrameIndex = 0x200;                          // DMA4_CSFi
-
-    Dma4.DestinationElementIndex = 1;                       // DMA4_CDEi
-
-    Dma4.DestinationFrameIndex = 0;                         // DMA4_CDFi
-
-
-
-    Dma4.ReadPortAccessMode = 0;            // DMA4_CCRi[13:12]  Always read MMCHS_DATA
-
-    Dma4.WritePortAccessMode = 1;           // DMA4_CCRi[15:14]  Post increment memory address
-
-    Dma4.ReadRequestNumber = 0x1e;          // DMA4_CCRi[4:0]    Syncro with MMCA_DMA_RX (61)  
-
-    Dma4.WriteRequestNumber = 1;            // DMA4_CCRi[20:19]  Syncro upper 0x3e == 62 (one based)
-
-  } else if (OperationType == WRITE) { 
-    Cmd = CMD25; //Multiple block write
-    CmdInterruptEnable = CMD25_INT_EN;
-    DmaOperation = MapOperationBusMasterRead;
-
-    Dma4.ReadPortAccessType = 3;            // DMA4_CSDPi[8:7]   Memory burst 16x32
-
-    Dma4.WritePortAccessType = 0;           // DMA4_CSDPi[15:14] Can not burst MMCHS_DATA reg
-
-    Dma4.WriteMode = 1;                     // DMA4_CSDPi[17:16] Write posted ???
-
-    
-
-    Dma4.SourceStartAddress = (UINT32)BufferAddress;        // DMA4_CSSAi
-
-    Dma4.DestinationStartAddress = MMCHS_DATA;              // DMA4_CDSAi
-
-    Dma4.SourceElementIndex = 1;                            // DMA4_CSEi
-
-    Dma4.SourceFrameIndex = 0x200;                          // DMA4_CSFi
-
-    Dma4.DestinationElementIndex = 1;                       // DMA4_CDEi
-
-    Dma4.DestinationFrameIndex = 0;                         // DMA4_CDFi
-
-
-
-    Dma4.ReadPortAccessMode = 1;            // DMA4_CCRi[13:12]  Post increment memory address
-
-    Dma4.WritePortAccessMode = 0;           // DMA4_CCRi[15:14]  Always write MMCHS_DATA
-
-    Dma4.ReadRequestNumber = 0x1d;          // DMA4_CCRi[4:0]    Syncro with MMCA_DMA_TX (60)  
-
-    Dma4.WriteRequestNumber = 1;            // DMA4_CCRi[20:19]  Syncro upper 0x3d == 61 (one based)
-
-  } else {
-    return EFI_INVALID_PARAMETER;
-  }
-
-
-  EnableDmaChannel (2, &Dma4);
-  
-
-  //Set command argument based on the card access mode (Byte mode or Block mode)
-  if (gCardInfo.OCRData.AccessMode & BIT1) {
-    CmdArgument = Lba;
-  } else {
-    CmdArgument = Lba * This->Media->BlockSize;
-  }
-
-  //Send Command.
-  Status = SendCmd (Cmd, CmdInterruptEnable, CmdArgument);
-  if (EFI_ERROR (Status)) {
-    DEBUG ((EFI_D_ERROR, "CMD fails. Status: %x\n", Status));
-    return Status;
-  }
-
-    //Check for the Transfer completion.
-  while (RetryCount < MAX_RETRY_COUNT) {
-    //Read Status
-    do {
-      MmcStatus = MmioRead32 (MMCHS_STAT);
-    } while (MmcStatus == 0);
-
-    //Check if Transfer complete (TC) bit is set?
-    if (MmcStatus & TC) {
-      break;
-    } else {
-      DEBUG ((EFI_D_ERROR, "MmcStatus for TC: %x\n", MmcStatus));
-      //Check if DEB, DCRC or DTO interrupt occured.
-      if ((MmcStatus & DEB) | (MmcStatus & DCRC) | (MmcStatus & DTO)) {
-        //There was an error during the data transfer.
-
-        //Set SRD bit to 1 and wait until it return to 0x0.
-        MmioOr32 (MMCHS_SYSCTL, SRD);
-        while((MmioRead32 (MMCHS_SYSCTL) & SRD) != 0x0);
-
-        DisableDmaChannel (2, DMA4_CSR_BLOCK, DMA4_CSR_ERR);
-        DmaUnmap (BufferMap);
-        return EFI_DEVICE_ERROR;
-      }
-    }
-    RetryCount++;
-  } 
-
-  DisableDmaChannel (2, DMA4_CSR_BLOCK, DMA4_CSR_ERR);
-  Status = DmaUnmap (BufferMap);
-
-  if (RetryCount == MAX_RETRY_COUNT) {
-    DEBUG ((EFI_D_ERROR, "TransferBlockData timed out.\n"));
-    return EFI_TIMEOUT;
-  }
-
-  return Status;
-}
-
-
-EFI_STATUS
-TransferBlock (
-  IN EFI_BLOCK_IO_PROTOCOL        *This,
-  IN  UINTN                       Lba,
-  IN OUT VOID                     *Buffer,
-  IN  OPERATION_TYPE              OperationType
-  )
-{
-  EFI_STATUS Status;
-  UINTN      MmcStatus;
-  UINTN      RetryCount = 0;
-  UINTN      Cmd = 0;
-  UINTN      CmdInterruptEnable = 0;
-  UINTN      CmdArgument = 0;
-
-
-  //Populate the command information based on the operation type.
-  if (OperationType == READ) {
-    Cmd = CMD17; //Single block read
-    CmdInterruptEnable = CMD18_INT_EN;
-  } else if (OperationType == WRITE) { 
-    Cmd = CMD24; //Single block write
-    CmdInterruptEnable = CMD24_INT_EN;
-  }
-
-  //Set command argument based on the card access mode (Byte mode or Block mode)
-  if (gCardInfo.OCRData.AccessMode & BIT1) {
-    CmdArgument = Lba;
-  } else {
-    CmdArgument = Lba * This->Media->BlockSize;
-  }
-
-  //Send Command.
-  Status = SendCmd (Cmd, CmdInterruptEnable, CmdArgument);
-  if (EFI_ERROR(Status)) {
-    DEBUG ((EFI_D_ERROR, "CMD fails. Status: %x\n", Status));
-    return Status;
-  }
-
-  //Read or Write data.
-  if (OperationType == READ) {
-    Status = ReadBlockData (This, Buffer);
-    if (EFI_ERROR(Status)) {
-      DEBUG((EFI_D_ERROR, "ReadBlockData fails.\n"));
-      return Status;
-    }
-  } else if (OperationType == WRITE) {
-    Status = WriteBlockData (This, Buffer);
-    if (EFI_ERROR(Status)) {
-      DEBUG((EFI_D_ERROR, "WriteBlockData fails.\n"));
-      return Status;
-    }
-  }
-
-  //Check for the Transfer completion.
-  while (RetryCount < MAX_RETRY_COUNT) {
-    //Read Status
-    do {
-      MmcStatus = MmioRead32 (MMCHS_STAT);
-    } while (MmcStatus == 0);
-
-    //Check if Transfer complete (TC) bit is set?
-    if (MmcStatus & TC) {
-      break;
-    } else {
-      DEBUG ((EFI_D_ERROR, "MmcStatus for TC: %x\n", MmcStatus));
-      //Check if DEB, DCRC or DTO interrupt occured.
-      if ((MmcStatus & DEB) | (MmcStatus & DCRC) | (MmcStatus & DTO)) {
-        //There was an error during the data transfer.
-
-        //Set SRD bit to 1 and wait until it return to 0x0.
-        MmioOr32 (MMCHS_SYSCTL, SRD);
-        while((MmioRead32 (MMCHS_SYSCTL) & SRD) != 0x0);
-
-        return EFI_DEVICE_ERROR;
-      }
-    }
-    RetryCount++;
-  } 
-
-  if (RetryCount == MAX_RETRY_COUNT) {
-    DEBUG ((EFI_D_ERROR, "TransferBlockData timed out.\n"));
-    return EFI_TIMEOUT;
-  }
-
-  return EFI_SUCCESS;
-}
-
-BOOLEAN
-CardPresent (
-  VOID
-  )
-{
-  EFI_STATUS  Status;
-  UINT8       Data;
-
-  //
-  // Card detect is a GPIO0 on the TPS65950
-  //
-  Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, GPIODATAIN1), 1, &Data);
-  if (EFI_ERROR (Status)) {
-    return FALSE;
-  }
-
-  if ((Data & CARD_DETECT_BIT) == CARD_DETECT_BIT) {
-    // No Card present
-    return FALSE;
-  } else {
-    return TRUE;
-  }
-}
-
-EFI_STATUS
-DetectCard (
-  VOID
-  )
-{
-  EFI_STATUS    Status;
-
-  if (!CardPresent ()) {
-    return EFI_NO_MEDIA;
-  }
-
-  //Initialize MMC host controller clocks.
-  Status = InitializeMMCHS ();
-  if (EFI_ERROR(Status)) {
-    DEBUG ((EFI_D_ERROR, "Initialize MMC host controller fails. Status: %x\n", Status));
-    return Status;
-  }
-
-  //Software reset of the MMCHS host controller.
-  MmioWrite32 (MMCHS_SYSCONFIG, SOFTRESET);
-  gBS->Stall(1000);
-  while ((MmioRead32 (MMCHS_SYSSTATUS) & RESETDONE_MASK) != RESETDONE);
-
-  //Soft reset for all.
-  MmioWrite32 (MMCHS_SYSCTL, SRA);
-  gBS->Stall(1000);
-  while ((MmioRead32 (MMCHS_SYSCTL) & SRA) != 0x0);
-
-  //Voltage capabilities initialization. Activate VS18 and VS30.
-  MmioOr32 (MMCHS_CAPA, (VS30 | VS18));
-
-  //Wakeup configuration
-  MmioOr32 (MMCHS_SYSCONFIG, ENAWAKEUP);
-  MmioOr32 (MMCHS_HCTL, IWE);
-
-  //MMCHS Controller default initialization
-  MmioOr32 (MMCHS_CON, (OD | DW8_1_4_BIT | CEATA_OFF));
-
-  MmioWrite32 (MMCHS_HCTL, (SDVS_3_0_V | DTW_1_BIT | SDBP_OFF));
-
-  //Enable internal clock
-  MmioOr32 (MMCHS_SYSCTL, ICE);
-
-  //Set the clock frequency to 80KHz.
-  UpdateMMCHSClkFrequency (CLKD_80KHZ);
-
-  //Enable SD bus power.
-  MmioOr32 (MMCHS_HCTL, (SDBP_ON));
-
-  //Poll till SD bus power bit is set.
-  while ((MmioRead32 (MMCHS_HCTL) & SDBP_MASK) != SDBP_ON);
-
-  //Card idenfication
-  Status = PerformCardIdenfication ();
-  if (EFI_ERROR(Status)) {
-    DEBUG ((EFI_D_ERROR, "No MMC/SD card detected.\n"));
-    return Status;
-  }
-  
-  //Get CSD (Card specific data) for the detected card.
-  Status = GetCardSpecificData();
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-  
-  //Configure the card in data transfer mode.
-  Status = PerformCardConfiguration();
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  //Patch the Media structure.
-  gMMCHSMedia.LastBlock    = (gCardInfo.NumBlocks - 1);
-  gMMCHSMedia.BlockSize    = gCardInfo.BlockSize;
-  gMMCHSMedia.ReadOnly     = (MmioRead32 (GPIO1_BASE + GPIO_DATAIN) & BIT23) == BIT23;
-  gMMCHSMedia.MediaPresent = TRUE; 
-  gMMCHSMedia.MediaId++; 
-
-  DEBUG ((EFI_D_INFO, "SD Card Media Change on Handle 0x%08x\n", gImageHandle));
-
-  return Status;
-}
-
-#define MAX_MMCHS_TRANSFER_SIZE  0x4000
-
-EFI_STATUS
-SdReadWrite (
-  IN EFI_BLOCK_IO_PROTOCOL    *This,
-  IN  UINTN                   Lba, 
-  OUT VOID                    *Buffer, 
-  IN  UINTN                   BufferSize,
-  IN  OPERATION_TYPE          OperationType
-  )
-{
-  EFI_STATUS Status = EFI_SUCCESS;
-  UINTN      RetryCount = 0;
-  UINTN      BlockCount;
-  UINTN      BytesToBeTranferedThisPass = 0;
-  UINTN      BytesRemainingToBeTransfered;
-  EFI_TPL    OldTpl;
-
-  BOOLEAN    Update;
-
-
-  
-  Update               = FALSE;
-
-  if (gMediaChange) {
-    Update = TRUE;
-    Status = DetectCard  ();
-    if (EFI_ERROR (Status)) {
-      // We detected a removal
-      gMMCHSMedia.MediaPresent = FALSE;
-      gMMCHSMedia.LastBlock    = 0;
-      gMMCHSMedia.BlockSize    = 512;  // Should be zero but there is a bug in DiskIo
-      gMMCHSMedia.ReadOnly     = FALSE; 
-    }
-    gMediaChange             = FALSE;
-  } else if (!gMMCHSMedia.MediaPresent) {
-    Status = EFI_NO_MEDIA;
-    goto Done;
-  }
-
-  if (Update) {
-    DEBUG ((EFI_D_INFO, "SD Card ReinstallProtocolInterface ()\n"));
-    gBS->ReinstallProtocolInterface (
-          gImageHandle,
-          &gEfiBlockIoProtocolGuid,
-          &gBlockIo,
-          &gBlockIo
-          );
-    return EFI_MEDIA_CHANGED;
-  }
-
-  if (EFI_ERROR (Status)) {
-    goto Done;
-  }
-
-  if (Buffer == NULL) {
-    Status = EFI_INVALID_PARAMETER;
-    goto Done;
-  }
-
-  if (Lba > This->Media->LastBlock) {
-    Status = EFI_INVALID_PARAMETER;
-    goto Done;
-  }
-  
-  if ((BufferSize % This->Media->BlockSize) != 0) {
-    Status = EFI_BAD_BUFFER_SIZE;
-    goto Done;
-  }
-
-  //Check if the data lines are not in use.
-  while ((RetryCount++ < MAX_RETRY_COUNT) && ((MmioRead32 (MMCHS_PSTATE) & DATI_MASK) != DATI_ALLOWED));
-  if (RetryCount == MAX_RETRY_COUNT) {
-    Status = EFI_TIMEOUT;
-    goto Done;
-  }
-
-  OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
-
-  BytesRemainingToBeTransfered = BufferSize;
-  while (BytesRemainingToBeTransfered > 0) {
-
-    if (gMediaChange) {
-      Status = EFI_NO_MEDIA;
-      DEBUG ((EFI_D_INFO, "SdReadWrite() EFI_NO_MEDIA due to gMediaChange\n"));
-      goto DoneRestoreTPL;
-    }
-
-    // Turn OFF DMA path until it is debugged
-    // BytesToBeTranferedThisPass = (BytesToBeTranferedThisPass >= MAX_MMCHS_TRANSFER_SIZE) ? MAX_MMCHS_TRANSFER_SIZE : BytesRemainingToBeTransfered;
-    BytesToBeTranferedThisPass   = This->Media->BlockSize;
-
-    BlockCount = BytesToBeTranferedThisPass/This->Media->BlockSize;
-
-    if (BlockCount > 1) {
-      Status = DmaBlocks (This, Lba, Buffer, BlockCount, OperationType);
-    } else {
-      //Transfer a block worth of data.
-      Status = TransferBlock (This, Lba, Buffer, OperationType);
-    }
-
-    if (EFI_ERROR(Status)) {
-      DEBUG ((EFI_D_ERROR, "TransferBlockData fails. %x\n", Status));
-      goto DoneRestoreTPL;
-    }
-
-    BytesRemainingToBeTransfered -= BytesToBeTranferedThisPass;
-    Lba    += BlockCount;
-    Buffer = (UINT8 *)Buffer + This->Media->BlockSize;
-  }
-
-DoneRestoreTPL:
-
-  gBS->RestoreTPL (OldTpl);
-
-Done:
-
-  return Status;
-
-}
-
-
-/**
-
-  Reset the Block Device.
-
-
-
-  @param  This                 Indicates a pointer to the calling context.
-
-  @param  ExtendedVerification Driver may perform diagnostics on reset.
-
-
-
-  @retval EFI_SUCCESS          The device was reset.
-
-  @retval EFI_DEVICE_ERROR     The device is not functioning properly and could
-
-                               not be reset.
-
-
-
-**/
-EFI_STATUS
-EFIAPI
-MMCHSReset (
-  IN EFI_BLOCK_IO_PROTOCOL          *This,
-  IN BOOLEAN                        ExtendedVerification
-  )
-{
-  return EFI_SUCCESS; 
-}
-
-
-/**
-
-  Read BufferSize bytes from Lba into Buffer.
-
-
-
-  @param  This       Indicates a pointer to the calling context.
-
-  @param  MediaId    Id of the media, changes every time the media is replaced.
-
-  @param  Lba        The starting Logical Block Address to read from
-
-  @param  BufferSize Size of Buffer, must be a multiple of device block size.
-
-  @param  Buffer     A pointer to the destination buffer for the data. The caller is
-
-                     responsible for either having implicit or explicit ownership of the buffer.
-
-
-
-  @retval EFI_SUCCESS           The data was read correctly from the device.
-
-  @retval EFI_DEVICE_ERROR      The device reported an error while performing the read.
-
-  @retval EFI_NO_MEDIA          There is no media in the device.
-
-  @retval EFI_MEDIA_CHANGED     The MediaId does not matched the current device.
-
-  @retval EFI_BAD_BUFFER_SIZE   The Buffer was not a multiple of the block size of the device.
-
-  @retval EFI_INVALID_PARAMETER The read request contains LBAs that are not valid, 
-
-                                or the buffer is not on proper alignment.
-
-EFI_STATUS
-
-**/
-EFI_STATUS
-EFIAPI
-MMCHSReadBlocks (
-  IN EFI_BLOCK_IO_PROTOCOL          *This,
-  IN UINT32                         MediaId,
-  IN EFI_LBA                        Lba,
-  IN UINTN                          BufferSize,
-  OUT VOID                          *Buffer
-  )
-{
-  EFI_STATUS Status;
-
-  //Perform Read operation.
-  Status = SdReadWrite (This, (UINTN)Lba, Buffer, BufferSize, READ);
-
-  return Status;
-
-}
-
-
-/**
-
-  Write BufferSize bytes from Lba into Buffer.
-
-
-
-  @param  This       Indicates a pointer to the calling context.
-
-  @param  MediaId    The media ID that the write request is for.
-
-  @param  Lba        The starting logical block address to be written. The caller is
-
-                     responsible for writing to only legitimate locations.
-
-  @param  BufferSize Size of Buffer, must be a multiple of device block size.
-
-  @param  Buffer     A pointer to the source buffer for the data.
-
-
-
-  @retval EFI_SUCCESS           The data was written correctly to the device.
-
-  @retval EFI_WRITE_PROTECTED   The device can not be written to.
-
-  @retval EFI_DEVICE_ERROR      The device reported an error while performing the write.
-
-  @retval EFI_NO_MEDIA          There is no media in the device.
-
-  @retval EFI_MEDIA_CHNAGED     The MediaId does not matched the current device.
-
-  @retval EFI_BAD_BUFFER_SIZE   The Buffer was not a multiple of the block size of the device.
-
-  @retval EFI_INVALID_PARAMETER The write request contains LBAs that are not valid, 
-
-                                or the buffer is not on proper alignment.
-
-
-
-**/
-EFI_STATUS
-EFIAPI
-MMCHSWriteBlocks (
-  IN EFI_BLOCK_IO_PROTOCOL          *This,
-  IN UINT32                         MediaId,
-  IN EFI_LBA                        Lba,
-  IN UINTN                          BufferSize,
-  IN VOID                           *Buffer
-  )
-{
-  EFI_STATUS  Status;
-
-  //Perform write operation.
-  Status = SdReadWrite (This, (UINTN)Lba, Buffer, BufferSize, WRITE);
-
-
-  return Status;
-
-}
-
-
-/**
-
-  Flush the Block Device.
-
-
-
-  @param  This              Indicates a pointer to the calling context.
-
-
-
-  @retval EFI_SUCCESS       All outstanding data was written to the device
-
-  @retval EFI_DEVICE_ERROR  The device reported an error while writting back the data
-
-  @retval EFI_NO_MEDIA      There is no media in the device.
-
-
-
-**/
-EFI_STATUS
-EFIAPI
-MMCHSFlushBlocks (
-  IN EFI_BLOCK_IO_PROTOCOL  *This
-  )
-{
-  return EFI_SUCCESS;
-}
-
-
-EFI_BLOCK_IO_PROTOCOL gBlockIo = {
-  EFI_BLOCK_IO_INTERFACE_REVISION,   // Revision
-  &gMMCHSMedia,                      // *Media
-  MMCHSReset,                        // Reset
-  MMCHSReadBlocks,                   // ReadBlocks
-  MMCHSWriteBlocks,                  // WriteBlocks
-  MMCHSFlushBlocks                   // FlushBlocks
-};
-
-
-/**
-
-  Timer callback to convert card present hardware into a boolean that indicates
-
-  a media change event has happened. If you just check the GPIO you could see 
-
-  card 1 and then check again after card 1 was removed and card 2 was inserted
-
-  and you would still see media present. Thus you need the timer tick to catch
-
-  the toggle event.
-
-
-
-  @param  Event                 Event whose notification function is being invoked.
-
-  @param  Context               The pointer to the notification function's context,
-
-                                which is implementation-dependent. Not used.
-
-
-
-**/
-VOID
-EFIAPI
-TimerCallback (
-  IN  EFI_EVENT   Event,
-  IN  VOID        *Context
-  )
-{
-  BOOLEAN Present;
-
-  Present = CardPresent ();
-  if (gMMCHSMedia.MediaPresent) {
-    if (!Present && !gMediaChange) {
-      gMediaChange = TRUE;
-    }
-  } else {
-    if (Present && !gMediaChange) {
-      gMediaChange = TRUE;    
-    }
-  }
-}
-
-
-EFI_STATUS
-EFIAPI
-MMCHSInitialize (
-  IN EFI_HANDLE         ImageHandle,
-  IN EFI_SYSTEM_TABLE   *SystemTable
-  )
-{
-  EFI_STATUS  Status;
-
-  Status = gBS->LocateProtocol (&gEmbeddedExternalDeviceProtocolGuid, NULL, (VOID **)&gTPS65950);
-  ASSERT_EFI_ERROR(Status);
-
-  ZeroMem (&gCardInfo, sizeof (CARD_INFO));
-
-  Status = gBS->CreateEvent (EVT_TIMER | EVT_NOTIFY_SIGNAL, TPL_CALLBACK, TimerCallback, NULL, &gTimerEvent);
-  ASSERT_EFI_ERROR (Status);
- 
-  Status = gBS->SetTimer (gTimerEvent, TimerPeriodic, FixedPcdGet32 (PcdMmchsTimerFreq100NanoSeconds)); 
-  ASSERT_EFI_ERROR (Status);
-
-  //Publish BlockIO.
-  Status = gBS->InstallMultipleProtocolInterfaces (
-                  &ImageHandle, 
-                  &gEfiBlockIoProtocolGuid,    &gBlockIo, 
-                  &gEfiDevicePathProtocolGuid, &gMmcHsDevicePath,
-                  NULL
-                  );
-  return Status;
-}
+/** @file

+  MMC/SD Card driver for OMAP 35xx (SDIO not supported)

+

+  This driver always produces a BlockIo protocol but it starts off with no Media

+  present. A TimerCallBack detects when media is inserted or removed and after 

+  a media change event a call to BlockIo ReadBlocks/WriteBlocks will cause the 

+  media to be detected (or removed) and the BlockIo Media structure will get

+  updated. No MMC/SD Card harward registers are updated until the first BlockIo

+  ReadBlocks/WriteBlocks after media has been insterted (booting with a card 

+  plugged in counts as an insertion event). 

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include "MMCHS.h"

+

+EFI_BLOCK_IO_MEDIA gMMCHSMedia = {

+  SIGNATURE_32('s','d','i','o'),            // MediaId

+  TRUE,                                     // RemovableMedia

+  FALSE,                                    // MediaPresent

+  FALSE,                                    // LogicalPartition

+  FALSE,                                    // ReadOnly

+  FALSE,                                    // WriteCaching

+  512,                                      // BlockSize

+  4,                                        // IoAlign

+  0,                                        // Pad

+  0                                         // LastBlock

+};

+

+typedef struct {

+  VENDOR_DEVICE_PATH  Mmc;

+  EFI_DEVICE_PATH     End;

+} MMCHS_DEVICE_PATH;

+

+MMCHS_DEVICE_PATH gMmcHsDevicePath = {

+  {

+    HARDWARE_DEVICE_PATH,

+    HW_VENDOR_DP,

+    (UINT8)(sizeof(VENDOR_DEVICE_PATH)),

+    (UINT8)((sizeof(VENDOR_DEVICE_PATH)) >> 8),

+    0xb615f1f5, 0x5088, 0x43cd, 0x80, 0x9c, 0xa1, 0x6e, 0x52, 0x48, 0x7d, 0x00 

+  },

+  {

+    END_DEVICE_PATH_TYPE,

+    END_ENTIRE_DEVICE_PATH_SUBTYPE,

+    sizeof (EFI_DEVICE_PATH_PROTOCOL),

+    0

+  }

+};

+

+CARD_INFO                  gCardInfo;

+EMBEDDED_EXTERNAL_DEVICE   *gTPS65950;

+EFI_EVENT                  gTimerEvent;

+BOOLEAN                    gMediaChange = FALSE;

+

+//

+// Internal Functions

+//

+

+

+VOID

+ParseCardCIDData (

+  UINT32 Response0, 

+  UINT32 Response1, 

+  UINT32 Response2,

+  UINT32 Response3

+  )

+{

+  gCardInfo.CIDData.MDT = ((Response0 >> 8) & 0xFFF);

+  gCardInfo.CIDData.PSN = (((Response0 >> 24) & 0xFF) | ((Response1 & 0xFFFFFF) << 8));

+  gCardInfo.CIDData.PRV = ((Response1 >> 24) & 0xFF);

+  gCardInfo.CIDData.PNM[4] = ((Response2) & 0xFF);

+  gCardInfo.CIDData.PNM[3] = ((Response2 >> 8) & 0xFF);

+  gCardInfo.CIDData.PNM[2] = ((Response2 >> 16) & 0xFF);

+  gCardInfo.CIDData.PNM[1] = ((Response2 >> 24) & 0xFF);

+  gCardInfo.CIDData.PNM[0] = ((Response3) & 0xFF);

+  gCardInfo.CIDData.OID = ((Response3 >> 8) & 0xFFFF);

+  gCardInfo.CIDData.MID = ((Response3 >> 24) & 0xFF);

+}

+

+

+VOID

+UpdateMMCHSClkFrequency (

+  UINTN NewCLKD

+  )

+{

+  //Set Clock enable to 0x0 to not provide the clock to the card

+  MmioAnd32 (MMCHS_SYSCTL, ~CEN);

+

+  //Set new clock frequency.

+  MmioAndThenOr32 (MMCHS_SYSCTL, ~CLKD_MASK, NewCLKD << 6); 

+

+  //Poll till Internal Clock Stable

+  while ((MmioRead32 (MMCHS_SYSCTL) & ICS_MASK) != ICS);

+

+  //Set Clock enable to 0x1 to provide the clock to the card

+  MmioOr32 (MMCHS_SYSCTL, CEN);

+}

+

+

+EFI_STATUS

+SendCmd (

+  UINTN Cmd,

+  UINTN CmdInterruptEnableVal,

+  UINTN CmdArgument

+  )

+{

+  UINTN MmcStatus;

+  UINTN RetryCount = 0;

+

+  //Check if command line is in use or not. Poll till command line is available.

+  while ((MmioRead32 (MMCHS_PSTATE) & DATI_MASK) == DATI_NOT_ALLOWED);

+

+  //Provide the block size.

+  MmioWrite32 (MMCHS_BLK, BLEN_512BYTES);

+

+  //Setting Data timeout counter value to max value.

+  MmioAndThenOr32 (MMCHS_SYSCTL, ~DTO_MASK, DTO_VAL);

+

+  //Clear Status register.

+  MmioWrite32 (MMCHS_STAT, 0xFFFFFFFF);

+

+  //Set command argument register

+  MmioWrite32 (MMCHS_ARG, CmdArgument);

+

+  //Enable interrupt enable events to occur

+  MmioWrite32 (MMCHS_IE, CmdInterruptEnableVal);

+

+  //Send a command

+  MmioWrite32 (MMCHS_CMD, Cmd);

+

+  //Check for the command status.

+  while (RetryCount < MAX_RETRY_COUNT) {

+    do {

+      MmcStatus = MmioRead32 (MMCHS_STAT);

+    } while (MmcStatus == 0);

+

+    //Read status of command response

+    if ((MmcStatus & ERRI) != 0) {

+

+      //Perform soft-reset for mmci_cmd line.

+      MmioOr32 (MMCHS_SYSCTL, SRC);

+      while ((MmioRead32 (MMCHS_SYSCTL) & SRC));

+

+      DEBUG ((EFI_D_INFO, "MmcStatus: %x\n", MmcStatus));

+      return EFI_DEVICE_ERROR;

+    }

+

+    //Check if command is completed.

+    if ((MmcStatus & CC) == CC) {

+      MmioWrite32 (MMCHS_STAT, CC);

+      break;

+    }

+

+    RetryCount++;

+  }

+

+  if (RetryCount == MAX_RETRY_COUNT) {

+    return EFI_TIMEOUT;

+  }

+

+  return EFI_SUCCESS;

+}

+

+

+VOID

+GetBlockInformation (

+  UINTN *BlockSize,

+  UINTN *NumBlocks

+  )

+{

+  CSD_SDV2 *CsdSDV2Data;

+  UINTN    CardSize;

+

+  if (gCardInfo.CardType == SD_CARD_2_HIGH) {

+    CsdSDV2Data = (CSD_SDV2 *)&gCardInfo.CSDData;

+

+    //Populate BlockSize.

+    *BlockSize = (0x1UL << CsdSDV2Data->READ_BL_LEN);

+

+    //Calculate Total number of blocks.

+    CardSize = CsdSDV2Data->C_SIZELow16 | (CsdSDV2Data->C_SIZEHigh6 << 2);

+    *NumBlocks = ((CardSize + 1) * 1024);

+  } else {

+    //Populate BlockSize.

+    *BlockSize = (0x1UL << gCardInfo.CSDData.READ_BL_LEN);

+

+    //Calculate Total number of blocks.

+    CardSize = gCardInfo.CSDData.C_SIZELow2 | (gCardInfo.CSDData.C_SIZEHigh10 << 2);

+    *NumBlocks = (CardSize + 1) * (1 << (gCardInfo.CSDData.C_SIZE_MULT + 2));

+  }

+

+  //For >=2G card, BlockSize may be 1K, but the transfer size is 512 bytes.

+  if (*BlockSize > 512) {

+    *NumBlocks = MultU64x32(*NumBlocks, *BlockSize/2);

+    *BlockSize = 512;

+  }

+

+  DEBUG ((EFI_D_INFO, "Card type: %x, BlockSize: %x, NumBlocks: %x\n", gCardInfo.CardType, *BlockSize, *NumBlocks));

+}

+

+

+VOID

+CalculateCardCLKD (

+  UINTN *ClockFrequencySelect

+  )

+{

+  UINT8    MaxDataTransferRate;

+  UINTN    TransferRateValue = 0;

+  UINTN    TimeValue = 0 ;

+  UINTN    Frequency = 0;

+

+  MaxDataTransferRate = gCardInfo.CSDData.TRAN_SPEED;

+

+  // For SD Cards  we would need to send CMD6 to set

+  // speeds abouve 25MHz. High Speed mode 50 MHz and up

+

+  //Calculate Transfer rate unit (Bits 2:0 of TRAN_SPEED)

+  switch (MaxDataTransferRate & 0x7) {

+    case 0:

+      TransferRateValue = 100 * 1000;

+      break;

+

+    case 1:

+      TransferRateValue = 1 * 1000 * 1000;

+      break;

+

+    case 2:

+      TransferRateValue = 10 * 1000 * 1000;

+      break;

+

+    case 3:

+      TransferRateValue = 100 * 1000 * 1000;

+      break;

+

+    default:

+      DEBUG((EFI_D_ERROR, "Invalid parameter.\n"));

+      ASSERT(FALSE);

+  }

+

+  //Calculate Time value (Bits 6:3 of TRAN_SPEED)

+  switch ((MaxDataTransferRate >> 3) & 0xF) {

+    case 1:

+      TimeValue = 10;

+      break;

+

+    case 2:

+      TimeValue = 12;

+      break;

+

+    case 3:

+      TimeValue = 13;

+      break;

+

+    case 4:

+      TimeValue = 15;

+      break;

+

+    case 5:

+      TimeValue = 20;

+      break;

+

+    case 6:

+      TimeValue = 25;

+      break;

+

+    case 7:

+      TimeValue = 30;

+      break;

+

+    case 8:

+      TimeValue = 35;

+      break;

+

+    case 9:

+      TimeValue = 40;

+      break;

+

+    case 10:

+      TimeValue = 45;

+      break;

+

+    case 11:

+      TimeValue = 50;

+      break;

+

+    case 12:

+      TimeValue = 55;

+      break;

+

+    case 13:

+      TimeValue = 60;

+      break;

+

+    case 14:

+      TimeValue = 70;

+      break;

+

+    case 15:

+      TimeValue = 80;

+      break;

+

+    default:

+      DEBUG((EFI_D_ERROR, "Invalid parameter.\n"));

+      ASSERT(FALSE);

+  }

+

+  Frequency = TransferRateValue * TimeValue/10;

+

+  //Calculate Clock divider value to program in MMCHS_SYSCTL[CLKD] field.

+  *ClockFrequencySelect = ((MMC_REFERENCE_CLK/Frequency) + 1);

+

+  DEBUG ((EFI_D_INFO, "MaxDataTransferRate: 0x%x, Frequency: %d KHz, ClockFrequencySelect: %x\n", MaxDataTransferRate, Frequency/1000, *ClockFrequencySelect));

+}

+

+

+VOID

+GetCardConfigurationData (

+  VOID

+  )

+{

+  UINTN  BlockSize;

+  UINTN  NumBlocks;

+  UINTN  ClockFrequencySelect;

+

+  //Calculate BlockSize and Total number of blocks in the detected card.

+  GetBlockInformation(&BlockSize, &NumBlocks);

+  gCardInfo.BlockSize = BlockSize;

+  gCardInfo.NumBlocks = NumBlocks;

+

+  //Calculate Card clock divider value.

+  CalculateCardCLKD(&ClockFrequencySelect);

+  gCardInfo.ClockFrequencySelect = ClockFrequencySelect;

+}

+

+

+EFI_STATUS

+InitializeMMCHS (

+  VOID

+  )

+{

+  UINT8      Data = 0;

+  EFI_STATUS Status;

+

+  //Select Device group to belong to P1 device group in Power IC.

+  Data = DEV_GRP_P1;

+  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VMMC1_DEV_GRP), 1, &Data);

+  ASSERT_EFI_ERROR(Status);

+

+  //Configure voltage regulator for MMC1 in Power IC to output 3.0 voltage.

+  Data = VSEL_3_00V;

+  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VMMC1_DEDICATED_REG), 1, &Data);

+  ASSERT_EFI_ERROR(Status);

+  

+  //After ramping up voltage, set VDDS stable bit to indicate that voltage level is stable.

+  MmioOr32 (CONTROL_PBIAS_LITE, (PBIASLITEVMODE0 | PBIASLITEPWRDNZ0 | PBIASSPEEDCTRL0 | PBIASLITEVMODE1 | PBIASLITEWRDNZ1));

+

+  // Enable WP GPIO

+  MmioAndThenOr32 (GPIO1_BASE + GPIO_OE, ~BIT23, BIT23);

+

+  // Enable Card Detect

+  Data = CARD_DETECT_ENABLE;

+  gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, TPS65950_GPIO_CTRL), 1, &Data);

+

+

+  return Status;

+}

+

+

+EFI_STATUS

+PerformCardIdenfication (

+  VOID

+  )

+{

+  EFI_STATUS Status;

+  UINTN      CmdArgument = 0;

+  UINTN      Response = 0;

+  UINTN      RetryCount = 0;

+  BOOLEAN    SDCmd8Supported = FALSE;

+

+  //Enable interrupts.

+  MmioWrite32 (MMCHS_IE, (BADA_EN | CERR_EN | DEB_EN | DCRC_EN | DTO_EN | CIE_EN |

+    CEB_EN | CCRC_EN | CTO_EN | BRR_EN | BWR_EN | TC_EN | CC_EN));

+

+  //Controller INIT procedure start.

+  MmioOr32 (MMCHS_CON, INIT);

+  MmioWrite32 (MMCHS_CMD, 0x00000000);

+  while (!(MmioRead32 (MMCHS_STAT) & CC));

+

+  //Wait for 1 ms

+  gBS->Stall(1000);

+

+  //Set CC bit to 0x1 to clear the flag

+  MmioOr32 (MMCHS_STAT, CC);

+

+  //Retry INIT procedure.

+  MmioWrite32 (MMCHS_CMD, 0x00000000);

+  while (!(MmioRead32 (MMCHS_STAT) & CC));

+

+  //End initialization sequence

+  MmioAnd32 (MMCHS_CON, ~INIT);

+

+  MmioOr32 (MMCHS_HCTL, (SDVS_3_0_V | DTW_1_BIT | SDBP_ON));

+

+  //Change clock frequency to 400KHz to fit protocol

+  UpdateMMCHSClkFrequency(CLKD_400KHZ);

+

+  MmioOr32 (MMCHS_CON, OD);

+

+  //Send CMD0 command.

+  Status = SendCmd (CMD0, CMD0_INT_EN, CmdArgument);

+  if (EFI_ERROR(Status)) {

+    DEBUG ((EFI_D_ERROR, "Cmd0 fails.\n"));

+    return Status;

+  }

+

+  DEBUG ((EFI_D_INFO, "CMD0 response: %x\n", MmioRead32 (MMCHS_RSP10)));

+

+  //Send CMD5 command. 

+  Status = SendCmd (CMD5, CMD5_INT_EN, CmdArgument);

+  if (Status == EFI_SUCCESS) {

+    DEBUG ((EFI_D_ERROR, "CMD5 Success. SDIO card. Follow SDIO card specification.\n"));

+    DEBUG ((EFI_D_INFO, "CMD5 response: %x\n", MmioRead32 (MMCHS_RSP10)));

+    //NOTE: Returning unsupported error for now. Need to implement SDIO specification.

+    return EFI_UNSUPPORTED; 

+  } else {

+    DEBUG ((EFI_D_INFO, "CMD5 fails. Not an SDIO card.\n"));

+  }

+

+  MmioOr32 (MMCHS_SYSCTL, SRC);

+  gBS->Stall(1000);

+  while ((MmioRead32 (MMCHS_SYSCTL) & SRC));

+

+  //Send CMD8 command. (New v2.00 command for Voltage check)

+  //Only 2.7V - 3.6V is supported for SD2.0, only SD 2.0 card can pass.

+  //MMC & SD1.1 card will fail this command.

+  CmdArgument = CMD8_ARG;

+  Status = SendCmd (CMD8, CMD8_INT_EN, CmdArgument);

+  if (Status == EFI_SUCCESS) {

+    Response = MmioRead32 (MMCHS_RSP10);

+    DEBUG ((EFI_D_INFO, "CMD8 success. CMD8 response: %x\n", Response));

+    if (Response != CmdArgument) {

+      return EFI_DEVICE_ERROR;

+    }

+    DEBUG ((EFI_D_INFO, "Card is SD2.0\n"));

+    SDCmd8Supported = TRUE; //Supports high capacity.

+  } else {

+    DEBUG ((EFI_D_INFO, "CMD8 fails. Not an SD2.0 card.\n"));

+  }

+

+  MmioOr32 (MMCHS_SYSCTL, SRC);

+  gBS->Stall(1000);

+  while ((MmioRead32 (MMCHS_SYSCTL) & SRC));

+

+  //Poll till card is busy

+  while (RetryCount < MAX_RETRY_COUNT) {

+    //Send CMD55 command. 

+    CmdArgument = 0;

+    Status = SendCmd (CMD55, CMD55_INT_EN, CmdArgument);

+    if (Status == EFI_SUCCESS) {

+      DEBUG ((EFI_D_INFO, "CMD55 success. CMD55 response: %x\n", MmioRead32 (MMCHS_RSP10)));

+      gCardInfo.CardType = SD_CARD;

+    } else {

+      DEBUG ((EFI_D_INFO, "CMD55 fails.\n"));

+      gCardInfo.CardType = MMC_CARD;

+    }

+

+    //Send appropriate command for the card type which got detected.

+    if (gCardInfo.CardType == SD_CARD) {

+      CmdArgument = ((UINTN *) &(gCardInfo.OCRData))[0];

+

+      //Set HCS bit.

+      if (SDCmd8Supported) {

+        CmdArgument |= HCS;

+      }

+

+      Status = SendCmd (ACMD41, ACMD41_INT_EN, CmdArgument);

+      if (EFI_ERROR(Status)) {

+        DEBUG ((EFI_D_INFO, "ACMD41 fails.\n"));

+        return Status;

+      }

+      ((UINT32 *) &(gCardInfo.OCRData))[0] = MmioRead32 (MMCHS_RSP10);

+      DEBUG ((EFI_D_INFO, "SD card detected. ACMD41 OCR: %x\n", ((UINT32 *) &(gCardInfo.OCRData))[0]));

+    } else if (gCardInfo.CardType == MMC_CARD) {

+      CmdArgument = 0;

+      Status = SendCmd (CMD1, CMD1_INT_EN, CmdArgument);

+      if (EFI_ERROR(Status)) {

+        DEBUG ((EFI_D_INFO, "CMD1 fails.\n"));

+        return Status;

+      }

+      Response = MmioRead32 (MMCHS_RSP10);

+      DEBUG ((EFI_D_INFO, "MMC card detected.. CMD1 response: %x\n", Response));

+

+      //NOTE: For now, I am skipping this since I only have an SD card.

+      //Compare card OCR and host OCR (Section 22.6.1.3.2.4)

+      return EFI_UNSUPPORTED; //For now, MMC is not supported.

+    }

+

+    //Poll the card until it is out of its power-up sequence.

+    if (gCardInfo.OCRData.Busy == 1) {

+

+      if (SDCmd8Supported) {

+        gCardInfo.CardType = SD_CARD_2;

+      }

+

+      //Card is ready. Check CCS (Card capacity status) bit (bit#30).

+      //SD 2.0 standard card will response with CCS 0, SD high capacity card will respond with CCS 1.

+      if (gCardInfo.OCRData.AccessMode & BIT1) {

+        gCardInfo.CardType = SD_CARD_2_HIGH;

+        DEBUG ((EFI_D_INFO, "High capacity card.\n"));

+      } else {

+        DEBUG ((EFI_D_INFO, "Standard capacity card.\n"));

+      }

+

+      break;

+    }

+

+    gBS->Stall(1000);

+    RetryCount++;

+  }

+

+  if (RetryCount == MAX_RETRY_COUNT) {

+    DEBUG ((EFI_D_ERROR, "Timeout error. RetryCount: %d\n", RetryCount));

+    return EFI_TIMEOUT;

+  }

+

+  //Read CID data.

+  CmdArgument = 0;

+  Status = SendCmd (CMD2, CMD2_INT_EN, CmdArgument);

+  if (EFI_ERROR(Status)) {

+    DEBUG ((EFI_D_ERROR, "CMD2 fails. Status: %x\n", Status));

+    return Status;

+  }

+

+  DEBUG ((EFI_D_INFO, "CMD2 response: %x %x %x %x\n", MmioRead32 (MMCHS_RSP10), MmioRead32 (MMCHS_RSP32), MmioRead32 (MMCHS_RSP54), MmioRead32 (MMCHS_RSP76)));

+

+  //Parse CID register data.

+  ParseCardCIDData(MmioRead32 (MMCHS_RSP10), MmioRead32 (MMCHS_RSP32), MmioRead32 (MMCHS_RSP54), MmioRead32 (MMCHS_RSP76));

+

+  //Read RCA

+  CmdArgument = 0;

+  Status = SendCmd (CMD3, CMD3_INT_EN, CmdArgument);

+  if (EFI_ERROR(Status)) {

+    DEBUG ((EFI_D_ERROR, "CMD3 fails. Status: %x\n", Status));

+    return Status;

+  }

+

+  //Set RCA for the detected card. RCA is CMD3 response.

+  gCardInfo.RCA = (MmioRead32 (MMCHS_RSP10) >> 16);

+  DEBUG ((EFI_D_INFO, "CMD3 response: RCA %x\n", gCardInfo.RCA));

+

+  //MMC Bus setting change after card identification.

+  MmioAnd32 (MMCHS_CON, ~OD);

+  MmioOr32 (MMCHS_HCTL, SDVS_3_0_V);

+  UpdateMMCHSClkFrequency(CLKD_400KHZ); //Set the clock frequency to 400KHz.

+

+  return EFI_SUCCESS;

+}

+

+

+EFI_STATUS

+GetCardSpecificData (

+  VOID

+  )

+{

+  EFI_STATUS Status;

+  UINTN      CmdArgument;

+

+  //Send CMD9 to retrieve CSD.

+  CmdArgument = gCardInfo.RCA << 16;

+  Status = SendCmd (CMD9, CMD9_INT_EN, CmdArgument);

+  if (EFI_ERROR(Status)) {

+    DEBUG ((EFI_D_ERROR, "CMD9 fails. Status: %x\n", Status));

+    return Status;

+  }

+

+  //Populate 128-bit CSD register data.

+  ((UINT32 *)&(gCardInfo.CSDData))[0] = MmioRead32 (MMCHS_RSP10);

+  ((UINT32 *)&(gCardInfo.CSDData))[1] = MmioRead32 (MMCHS_RSP32);

+  ((UINT32 *)&(gCardInfo.CSDData))[2] = MmioRead32 (MMCHS_RSP54);

+  ((UINT32 *)&(gCardInfo.CSDData))[3] = MmioRead32 (MMCHS_RSP76);

+

+  DEBUG ((EFI_D_INFO, "CMD9 response: %x %x %x %x\n", MmioRead32 (MMCHS_RSP10), MmioRead32 (MMCHS_RSP32), MmioRead32 (MMCHS_RSP54), MmioRead32 (MMCHS_RSP76)));

+

+  //Calculate total number of blocks and max. data transfer rate supported by the detected card.

+  GetCardConfigurationData();

+

+  return Status;

+}

+

+

+EFI_STATUS

+PerformCardConfiguration (

+  VOID

+  )

+{

+  UINTN      CmdArgument = 0;

+  EFI_STATUS Status;

+

+  //Send CMD7

+  CmdArgument = gCardInfo.RCA << 16;

+  Status = SendCmd (CMD7, CMD7_INT_EN, CmdArgument);

+  if (EFI_ERROR(Status)) {

+    DEBUG ((EFI_D_ERROR, "CMD7 fails. Status: %x\n", Status));

+    return Status;

+  }

+

+  if ((gCardInfo.CardType != UNKNOWN_CARD) && (gCardInfo.CardType != MMC_CARD)) {

+    // We could read SCR register, but SD Card Phys spec stats any SD Card shall

+    // set SCR.SD_BUS_WIDTHS to support 4-bit mode, so why bother?

+ 

+    // Send ACMD6 (application specific commands must be prefixed with CMD55)

+    Status = SendCmd (CMD55, CMD55_INT_EN, CmdArgument);

+    if (!EFI_ERROR (Status)) {

+      // set device into 4-bit data bus mode

+      Status = SendCmd (ACMD6, ACMD6_INT_EN, 0x2);

+      if (!EFI_ERROR (Status)) {

+        // Set host controler into 4-bit mode

+        MmioOr32 (MMCHS_HCTL, DTW_4_BIT);

+        DEBUG ((EFI_D_INFO, "SD Memory Card set to 4-bit mode\n"));

+      }

+    }

+  }

+

+  //Send CMD16 to set the block length

+  CmdArgument = gCardInfo.BlockSize;

+  Status = SendCmd (CMD16, CMD16_INT_EN, CmdArgument);

+  if (EFI_ERROR(Status)) {

+    DEBUG ((EFI_D_ERROR, "CMD16 fails. Status: %x\n", Status));

+    return Status;

+  }

+

+  //Change MMCHS clock frequency to what detected card can support.

+  UpdateMMCHSClkFrequency(gCardInfo.ClockFrequencySelect);

+

+  return EFI_SUCCESS;

+}

+

+

+EFI_STATUS

+ReadBlockData (

+  IN  EFI_BLOCK_IO_PROTOCOL       *This,

+  OUT VOID                        *Buffer

+  )

+{

+  UINTN MmcStatus;

+  UINTN *DataBuffer = Buffer;

+  UINTN DataSize = This->Media->BlockSize/4;

+  UINTN Count;

+  UINTN RetryCount = 0;

+

+  //Check controller status to make sure there is no error.

+  while (RetryCount < MAX_RETRY_COUNT) {

+    do {

+      //Read Status.

+      MmcStatus = MmioRead32 (MMCHS_STAT);

+    } while(MmcStatus == 0);

+

+    //Check if Buffer read ready (BRR) bit is set?

+    if (MmcStatus & BRR) {

+

+      //Clear BRR bit

+      MmioOr32 (MMCHS_STAT, BRR);

+

+      //Read block worth of data.

+      for (Count = 0; Count < DataSize; Count++) {

+        *DataBuffer++ = MmioRead32 (MMCHS_DATA);

+      }

+      break;

+    }

+    RetryCount++;

+  }

+

+  if (RetryCount == MAX_RETRY_COUNT) {

+    return EFI_TIMEOUT;

+  }

+

+  return EFI_SUCCESS;

+}

+

+

+EFI_STATUS

+WriteBlockData (

+  IN  EFI_BLOCK_IO_PROTOCOL       *This,

+  OUT VOID                        *Buffer

+  )

+{

+  UINTN MmcStatus;

+  UINTN *DataBuffer = Buffer;

+  UINTN DataSize = This->Media->BlockSize/4;

+  UINTN Count;

+  UINTN RetryCount = 0;

+

+  //Check controller status to make sure there is no error.

+  while (RetryCount < MAX_RETRY_COUNT) {

+    do {

+      //Read Status.

+      MmcStatus = MmioRead32 (MMCHS_STAT);

+    } while(MmcStatus == 0);

+

+    //Check if Buffer write ready (BWR) bit is set?

+    if (MmcStatus & BWR) {

+

+      //Clear BWR bit

+      MmioOr32 (MMCHS_STAT, BWR);

+

+      //Write block worth of data.

+      for (Count = 0; Count < DataSize; Count++) {

+        MmioWrite32 (MMCHS_DATA, *DataBuffer++);

+      }

+

+      break;

+    }

+    RetryCount++;

+  }

+

+  if (RetryCount == MAX_RETRY_COUNT) {

+    return EFI_TIMEOUT;

+  }

+

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+DmaBlocks (

+  IN EFI_BLOCK_IO_PROTOCOL        *This,

+  IN  UINTN                       Lba,

+  IN OUT VOID                     *Buffer,

+  IN  UINTN                       BlockCount,

+  IN  OPERATION_TYPE              OperationType

+  )

+{

+  EFI_STATUS            Status;

+  UINTN                 DmaSize = 0;

+  UINTN                 Cmd = 0;

+  UINTN                 CmdInterruptEnable;

+  UINTN                 CmdArgument;

+  VOID                  *BufferMap;

+  EFI_PHYSICAL_ADDRESS  BufferAddress;

+  OMAP_DMA4             Dma4;

+  DMA_MAP_OPERATION     DmaOperation;

+  EFI_STATUS            MmcStatus;

+  UINTN                 RetryCount = 0;

+

+CpuDeadLoop ();

+  // Map passed in buffer for DMA xfer

+  DmaSize = BlockCount * This->Media->BlockSize;

+  Status = DmaMap (DmaOperation, Buffer, &DmaSize, &BufferAddress, &BufferMap);

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+

+  ZeroMem (&DmaOperation, sizeof (DMA_MAP_OPERATION));

+  

+

+  Dma4.DataType = 2;                      // DMA4_CSDPi[1:0]   32-bit elements from MMCHS_DATA

+

+  Dma4.SourceEndiansim = 0;               // DMA4_CSDPi[21]    

+

+  Dma4.DestinationEndianism = 0;          // DMA4_CSDPi[19]

+

+  Dma4.SourcePacked = 0;                  // DMA4_CSDPi[6]

+

+  Dma4.DestinationPacked = 0;             // DMA4_CSDPi[13]

+

+  Dma4.NumberOfElementPerFrame = This->Media->BlockSize/4; // DMA4_CENi  (TRM 4K is optimum value)  

+

+  Dma4.NumberOfFramePerTransferBlock = BlockCount;         // DMA4_CFNi    

+

+  Dma4.ReadPriority = 0;                  // DMA4_CCRi[6]      Low priority read  

+

+  Dma4.WritePriority = 0;                 // DMA4_CCRi[23]     Prefetech disabled

+

+

+  //Populate the command information based on the operation type.

+  if (OperationType == READ) {

+    Cmd = CMD18; //Multiple block read

+    CmdInterruptEnable = CMD18_INT_EN;

+    DmaOperation = MapOperationBusMasterCommonBuffer;

+

+    Dma4.ReadPortAccessType =0 ;            // DMA4_CSDPi[8:7]   Can not burst MMCHS_DATA reg

+

+    Dma4.WritePortAccessType = 3;           // DMA4_CSDPi[15:14] Memory burst 16x32

+

+    Dma4.WriteMode = 1;                     // DMA4_CSDPi[17:16] Write posted

+

+    

+

+    Dma4.SourceStartAddress = MMCHS_DATA;                   // DMA4_CSSAi

+

+    Dma4.DestinationStartAddress = (UINT32)BufferAddress;   // DMA4_CDSAi

+

+    Dma4.SourceElementIndex = 1;                            // DMA4_CSEi

+

+    Dma4.SourceFrameIndex = 0x200;                          // DMA4_CSFi

+

+    Dma4.DestinationElementIndex = 1;                       // DMA4_CDEi

+

+    Dma4.DestinationFrameIndex = 0;                         // DMA4_CDFi

+

+

+

+    Dma4.ReadPortAccessMode = 0;            // DMA4_CCRi[13:12]  Always read MMCHS_DATA

+

+    Dma4.WritePortAccessMode = 1;           // DMA4_CCRi[15:14]  Post increment memory address

+

+    Dma4.ReadRequestNumber = 0x1e;          // DMA4_CCRi[4:0]    Syncro with MMCA_DMA_RX (61)  

+

+    Dma4.WriteRequestNumber = 1;            // DMA4_CCRi[20:19]  Syncro upper 0x3e == 62 (one based)

+

+  } else if (OperationType == WRITE) { 

+    Cmd = CMD25; //Multiple block write

+    CmdInterruptEnable = CMD25_INT_EN;

+    DmaOperation = MapOperationBusMasterRead;

+

+    Dma4.ReadPortAccessType = 3;            // DMA4_CSDPi[8:7]   Memory burst 16x32

+

+    Dma4.WritePortAccessType = 0;           // DMA4_CSDPi[15:14] Can not burst MMCHS_DATA reg

+

+    Dma4.WriteMode = 1;                     // DMA4_CSDPi[17:16] Write posted ???

+

+    

+

+    Dma4.SourceStartAddress = (UINT32)BufferAddress;        // DMA4_CSSAi

+

+    Dma4.DestinationStartAddress = MMCHS_DATA;              // DMA4_CDSAi

+

+    Dma4.SourceElementIndex = 1;                            // DMA4_CSEi

+

+    Dma4.SourceFrameIndex = 0x200;                          // DMA4_CSFi

+

+    Dma4.DestinationElementIndex = 1;                       // DMA4_CDEi

+

+    Dma4.DestinationFrameIndex = 0;                         // DMA4_CDFi

+

+

+

+    Dma4.ReadPortAccessMode = 1;            // DMA4_CCRi[13:12]  Post increment memory address

+

+    Dma4.WritePortAccessMode = 0;           // DMA4_CCRi[15:14]  Always write MMCHS_DATA

+

+    Dma4.ReadRequestNumber = 0x1d;          // DMA4_CCRi[4:0]    Syncro with MMCA_DMA_TX (60)  

+

+    Dma4.WriteRequestNumber = 1;            // DMA4_CCRi[20:19]  Syncro upper 0x3d == 61 (one based)

+

+  } else {

+    return EFI_INVALID_PARAMETER;

+  }

+

+

+  EnableDmaChannel (2, &Dma4);

+  

+

+  //Set command argument based on the card access mode (Byte mode or Block mode)

+  if (gCardInfo.OCRData.AccessMode & BIT1) {

+    CmdArgument = Lba;

+  } else {

+    CmdArgument = Lba * This->Media->BlockSize;

+  }

+

+  //Send Command.

+  Status = SendCmd (Cmd, CmdInterruptEnable, CmdArgument);

+  if (EFI_ERROR (Status)) {

+    DEBUG ((EFI_D_ERROR, "CMD fails. Status: %x\n", Status));

+    return Status;

+  }

+

+    //Check for the Transfer completion.

+  while (RetryCount < MAX_RETRY_COUNT) {

+    //Read Status

+    do {

+      MmcStatus = MmioRead32 (MMCHS_STAT);

+    } while (MmcStatus == 0);

+

+    //Check if Transfer complete (TC) bit is set?

+    if (MmcStatus & TC) {

+      break;

+    } else {

+      DEBUG ((EFI_D_ERROR, "MmcStatus for TC: %x\n", MmcStatus));

+      //Check if DEB, DCRC or DTO interrupt occured.

+      if ((MmcStatus & DEB) | (MmcStatus & DCRC) | (MmcStatus & DTO)) {

+        //There was an error during the data transfer.

+

+        //Set SRD bit to 1 and wait until it return to 0x0.

+        MmioOr32 (MMCHS_SYSCTL, SRD);

+        while((MmioRead32 (MMCHS_SYSCTL) & SRD) != 0x0);

+

+        DisableDmaChannel (2, DMA4_CSR_BLOCK, DMA4_CSR_ERR);

+        DmaUnmap (BufferMap);

+        return EFI_DEVICE_ERROR;

+      }

+    }

+    RetryCount++;

+  } 

+

+  DisableDmaChannel (2, DMA4_CSR_BLOCK, DMA4_CSR_ERR);

+  Status = DmaUnmap (BufferMap);

+

+  if (RetryCount == MAX_RETRY_COUNT) {

+    DEBUG ((EFI_D_ERROR, "TransferBlockData timed out.\n"));

+    return EFI_TIMEOUT;

+  }

+

+  return Status;

+}

+

+

+EFI_STATUS

+TransferBlock (

+  IN EFI_BLOCK_IO_PROTOCOL        *This,

+  IN  UINTN                       Lba,

+  IN OUT VOID                     *Buffer,

+  IN  OPERATION_TYPE              OperationType

+  )

+{

+  EFI_STATUS Status;

+  UINTN      MmcStatus;

+  UINTN      RetryCount = 0;

+  UINTN      Cmd = 0;

+  UINTN      CmdInterruptEnable = 0;

+  UINTN      CmdArgument = 0;

+

+

+  //Populate the command information based on the operation type.

+  if (OperationType == READ) {

+    Cmd = CMD17; //Single block read

+    CmdInterruptEnable = CMD18_INT_EN;

+  } else if (OperationType == WRITE) { 

+    Cmd = CMD24; //Single block write

+    CmdInterruptEnable = CMD24_INT_EN;

+  }

+

+  //Set command argument based on the card access mode (Byte mode or Block mode)

+  if (gCardInfo.OCRData.AccessMode & BIT1) {

+    CmdArgument = Lba;

+  } else {

+    CmdArgument = Lba * This->Media->BlockSize;

+  }

+

+  //Send Command.

+  Status = SendCmd (Cmd, CmdInterruptEnable, CmdArgument);

+  if (EFI_ERROR(Status)) {

+    DEBUG ((EFI_D_ERROR, "CMD fails. Status: %x\n", Status));

+    return Status;

+  }

+

+  //Read or Write data.

+  if (OperationType == READ) {

+    Status = ReadBlockData (This, Buffer);

+    if (EFI_ERROR(Status)) {

+      DEBUG((EFI_D_ERROR, "ReadBlockData fails.\n"));

+      return Status;

+    }

+  } else if (OperationType == WRITE) {

+    Status = WriteBlockData (This, Buffer);

+    if (EFI_ERROR(Status)) {

+      DEBUG((EFI_D_ERROR, "WriteBlockData fails.\n"));

+      return Status;

+    }

+  }

+

+  //Check for the Transfer completion.

+  while (RetryCount < MAX_RETRY_COUNT) {

+    //Read Status

+    do {

+      MmcStatus = MmioRead32 (MMCHS_STAT);

+    } while (MmcStatus == 0);

+

+    //Check if Transfer complete (TC) bit is set?

+    if (MmcStatus & TC) {

+      break;

+    } else {

+      DEBUG ((EFI_D_ERROR, "MmcStatus for TC: %x\n", MmcStatus));

+      //Check if DEB, DCRC or DTO interrupt occured.

+      if ((MmcStatus & DEB) | (MmcStatus & DCRC) | (MmcStatus & DTO)) {

+        //There was an error during the data transfer.

+

+        //Set SRD bit to 1 and wait until it return to 0x0.

+        MmioOr32 (MMCHS_SYSCTL, SRD);

+        while((MmioRead32 (MMCHS_SYSCTL) & SRD) != 0x0);

+

+        return EFI_DEVICE_ERROR;

+      }

+    }

+    RetryCount++;

+  } 

+

+  if (RetryCount == MAX_RETRY_COUNT) {

+    DEBUG ((EFI_D_ERROR, "TransferBlockData timed out.\n"));

+    return EFI_TIMEOUT;

+  }

+

+  return EFI_SUCCESS;

+}

+

+BOOLEAN

+CardPresent (

+  VOID

+  )

+{

+  EFI_STATUS  Status;

+  UINT8       Data;

+

+  //

+  // Card detect is a GPIO0 on the TPS65950

+  //

+  Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, GPIODATAIN1), 1, &Data);

+  if (EFI_ERROR (Status)) {

+    return FALSE;

+  }

+

+  if ((Data & CARD_DETECT_BIT) == CARD_DETECT_BIT) {

+    // No Card present

+    return FALSE;

+  } else {

+    return TRUE;

+  }

+}

+

+EFI_STATUS

+DetectCard (

+  VOID

+  )

+{

+  EFI_STATUS    Status;

+

+  if (!CardPresent ()) {

+    return EFI_NO_MEDIA;

+  }

+

+  //Initialize MMC host controller clocks.

+  Status = InitializeMMCHS ();

+  if (EFI_ERROR(Status)) {

+    DEBUG ((EFI_D_ERROR, "Initialize MMC host controller fails. Status: %x\n", Status));

+    return Status;

+  }

+

+  //Software reset of the MMCHS host controller.

+  MmioWrite32 (MMCHS_SYSCONFIG, SOFTRESET);

+  gBS->Stall(1000);

+  while ((MmioRead32 (MMCHS_SYSSTATUS) & RESETDONE_MASK) != RESETDONE);

+

+  //Soft reset for all.

+  MmioWrite32 (MMCHS_SYSCTL, SRA);

+  gBS->Stall(1000);

+  while ((MmioRead32 (MMCHS_SYSCTL) & SRA) != 0x0);

+

+  //Voltage capabilities initialization. Activate VS18 and VS30.

+  MmioOr32 (MMCHS_CAPA, (VS30 | VS18));

+

+  //Wakeup configuration

+  MmioOr32 (MMCHS_SYSCONFIG, ENAWAKEUP);

+  MmioOr32 (MMCHS_HCTL, IWE);

+

+  //MMCHS Controller default initialization

+  MmioOr32 (MMCHS_CON, (OD | DW8_1_4_BIT | CEATA_OFF));

+

+  MmioWrite32 (MMCHS_HCTL, (SDVS_3_0_V | DTW_1_BIT | SDBP_OFF));

+

+  //Enable internal clock

+  MmioOr32 (MMCHS_SYSCTL, ICE);

+

+  //Set the clock frequency to 80KHz.

+  UpdateMMCHSClkFrequency (CLKD_80KHZ);

+

+  //Enable SD bus power.

+  MmioOr32 (MMCHS_HCTL, (SDBP_ON));

+

+  //Poll till SD bus power bit is set.

+  while ((MmioRead32 (MMCHS_HCTL) & SDBP_MASK) != SDBP_ON);

+

+  //Card idenfication

+  Status = PerformCardIdenfication ();

+  if (EFI_ERROR(Status)) {

+    DEBUG ((EFI_D_ERROR, "No MMC/SD card detected.\n"));

+    return Status;

+  }

+  

+  //Get CSD (Card specific data) for the detected card.

+  Status = GetCardSpecificData();

+  if (EFI_ERROR(Status)) {

+    return Status;

+  }

+  

+  //Configure the card in data transfer mode.

+  Status = PerformCardConfiguration();

+  if (EFI_ERROR(Status)) {

+    return Status;

+  }

+

+  //Patch the Media structure.

+  gMMCHSMedia.LastBlock    = (gCardInfo.NumBlocks - 1);

+  gMMCHSMedia.BlockSize    = gCardInfo.BlockSize;

+  gMMCHSMedia.ReadOnly     = (MmioRead32 (GPIO1_BASE + GPIO_DATAIN) & BIT23) == BIT23;

+  gMMCHSMedia.MediaPresent = TRUE; 

+  gMMCHSMedia.MediaId++; 

+

+  DEBUG ((EFI_D_INFO, "SD Card Media Change on Handle 0x%08x\n", gImageHandle));

+

+  return Status;

+}

+

+#define MAX_MMCHS_TRANSFER_SIZE  0x4000

+

+EFI_STATUS

+SdReadWrite (

+  IN EFI_BLOCK_IO_PROTOCOL    *This,

+  IN  UINTN                   Lba, 

+  OUT VOID                    *Buffer, 

+  IN  UINTN                   BufferSize,

+  IN  OPERATION_TYPE          OperationType

+  )

+{

+  EFI_STATUS Status = EFI_SUCCESS;

+  UINTN      RetryCount = 0;

+  UINTN      BlockCount;

+  UINTN      BytesToBeTranferedThisPass = 0;

+  UINTN      BytesRemainingToBeTransfered;

+  EFI_TPL    OldTpl;

+

+  BOOLEAN    Update;

+

+

+  

+  Update               = FALSE;

+

+  if (gMediaChange) {

+    Update = TRUE;

+    Status = DetectCard  ();

+    if (EFI_ERROR (Status)) {

+      // We detected a removal

+      gMMCHSMedia.MediaPresent = FALSE;

+      gMMCHSMedia.LastBlock    = 0;

+      gMMCHSMedia.BlockSize    = 512;  // Should be zero but there is a bug in DiskIo

+      gMMCHSMedia.ReadOnly     = FALSE; 

+    }

+    gMediaChange             = FALSE;

+  } else if (!gMMCHSMedia.MediaPresent) {

+    Status = EFI_NO_MEDIA;

+    goto Done;

+  }

+

+  if (Update) {

+    DEBUG ((EFI_D_INFO, "SD Card ReinstallProtocolInterface ()\n"));

+    gBS->ReinstallProtocolInterface (

+          gImageHandle,

+          &gEfiBlockIoProtocolGuid,

+          &gBlockIo,

+          &gBlockIo

+          );

+    return EFI_MEDIA_CHANGED;

+  }

+

+  if (EFI_ERROR (Status)) {

+    goto Done;

+  }

+

+  if (Buffer == NULL) {

+    Status = EFI_INVALID_PARAMETER;

+    goto Done;

+  }

+

+  if (Lba > This->Media->LastBlock) {

+    Status = EFI_INVALID_PARAMETER;

+    goto Done;

+  }

+  

+  if ((BufferSize % This->Media->BlockSize) != 0) {

+    Status = EFI_BAD_BUFFER_SIZE;

+    goto Done;

+  }

+

+  //Check if the data lines are not in use.

+  while ((RetryCount++ < MAX_RETRY_COUNT) && ((MmioRead32 (MMCHS_PSTATE) & DATI_MASK) != DATI_ALLOWED));

+  if (RetryCount == MAX_RETRY_COUNT) {

+    Status = EFI_TIMEOUT;

+    goto Done;

+  }

+

+  OldTpl = gBS->RaiseTPL (TPL_NOTIFY);

+

+  BytesRemainingToBeTransfered = BufferSize;

+  while (BytesRemainingToBeTransfered > 0) {

+

+    if (gMediaChange) {

+      Status = EFI_NO_MEDIA;

+      DEBUG ((EFI_D_INFO, "SdReadWrite() EFI_NO_MEDIA due to gMediaChange\n"));

+      goto DoneRestoreTPL;

+    }

+

+    // Turn OFF DMA path until it is debugged

+    // BytesToBeTranferedThisPass = (BytesToBeTranferedThisPass >= MAX_MMCHS_TRANSFER_SIZE) ? MAX_MMCHS_TRANSFER_SIZE : BytesRemainingToBeTransfered;

+    BytesToBeTranferedThisPass   = This->Media->BlockSize;

+

+    BlockCount = BytesToBeTranferedThisPass/This->Media->BlockSize;

+

+    if (BlockCount > 1) {

+      Status = DmaBlocks (This, Lba, Buffer, BlockCount, OperationType);

+    } else {

+      //Transfer a block worth of data.

+      Status = TransferBlock (This, Lba, Buffer, OperationType);

+    }

+

+    if (EFI_ERROR(Status)) {

+      DEBUG ((EFI_D_ERROR, "TransferBlockData fails. %x\n", Status));

+      goto DoneRestoreTPL;

+    }

+

+    BytesRemainingToBeTransfered -= BytesToBeTranferedThisPass;

+    Lba    += BlockCount;

+    Buffer = (UINT8 *)Buffer + This->Media->BlockSize;

+  }

+

+DoneRestoreTPL:

+

+  gBS->RestoreTPL (OldTpl);

+

+Done:

+

+  return Status;

+

+}

+

+

+/**

+

+  Reset the Block Device.

+

+

+

+  @param  This                 Indicates a pointer to the calling context.

+

+  @param  ExtendedVerification Driver may perform diagnostics on reset.

+

+

+

+  @retval EFI_SUCCESS          The device was reset.

+

+  @retval EFI_DEVICE_ERROR     The device is not functioning properly and could

+

+                               not be reset.

+

+

+

+**/

+EFI_STATUS

+EFIAPI

+MMCHSReset (

+  IN EFI_BLOCK_IO_PROTOCOL          *This,

+  IN BOOLEAN                        ExtendedVerification

+  )

+{

+  return EFI_SUCCESS; 

+}

+

+

+/**

+

+  Read BufferSize bytes from Lba into Buffer.

+

+

+

+  @param  This       Indicates a pointer to the calling context.

+

+  @param  MediaId    Id of the media, changes every time the media is replaced.

+

+  @param  Lba        The starting Logical Block Address to read from

+

+  @param  BufferSize Size of Buffer, must be a multiple of device block size.

+

+  @param  Buffer     A pointer to the destination buffer for the data. The caller is

+

+                     responsible for either having implicit or explicit ownership of the buffer.

+

+

+

+  @retval EFI_SUCCESS           The data was read correctly from the device.

+

+  @retval EFI_DEVICE_ERROR      The device reported an error while performing the read.

+

+  @retval EFI_NO_MEDIA          There is no media in the device.

+

+  @retval EFI_MEDIA_CHANGED     The MediaId does not matched the current device.

+

+  @retval EFI_BAD_BUFFER_SIZE   The Buffer was not a multiple of the block size of the device.

+

+  @retval EFI_INVALID_PARAMETER The read request contains LBAs that are not valid, 

+

+                                or the buffer is not on proper alignment.

+

+EFI_STATUS

+

+**/

+EFI_STATUS

+EFIAPI

+MMCHSReadBlocks (

+  IN EFI_BLOCK_IO_PROTOCOL          *This,

+  IN UINT32                         MediaId,

+  IN EFI_LBA                        Lba,

+  IN UINTN                          BufferSize,

+  OUT VOID                          *Buffer

+  )

+{

+  EFI_STATUS Status;

+

+  //Perform Read operation.

+  Status = SdReadWrite (This, (UINTN)Lba, Buffer, BufferSize, READ);

+

+  return Status;

+

+}

+

+

+/**

+

+  Write BufferSize bytes from Lba into Buffer.

+

+

+

+  @param  This       Indicates a pointer to the calling context.

+

+  @param  MediaId    The media ID that the write request is for.

+

+  @param  Lba        The starting logical block address to be written. The caller is

+

+                     responsible for writing to only legitimate locations.

+

+  @param  BufferSize Size of Buffer, must be a multiple of device block size.

+

+  @param  Buffer     A pointer to the source buffer for the data.

+

+

+

+  @retval EFI_SUCCESS           The data was written correctly to the device.

+

+  @retval EFI_WRITE_PROTECTED   The device can not be written to.

+

+  @retval EFI_DEVICE_ERROR      The device reported an error while performing the write.

+

+  @retval EFI_NO_MEDIA          There is no media in the device.

+

+  @retval EFI_MEDIA_CHNAGED     The MediaId does not matched the current device.

+

+  @retval EFI_BAD_BUFFER_SIZE   The Buffer was not a multiple of the block size of the device.

+

+  @retval EFI_INVALID_PARAMETER The write request contains LBAs that are not valid, 

+

+                                or the buffer is not on proper alignment.

+

+

+

+**/

+EFI_STATUS

+EFIAPI

+MMCHSWriteBlocks (

+  IN EFI_BLOCK_IO_PROTOCOL          *This,

+  IN UINT32                         MediaId,

+  IN EFI_LBA                        Lba,

+  IN UINTN                          BufferSize,

+  IN VOID                           *Buffer

+  )

+{

+  EFI_STATUS  Status;

+

+  //Perform write operation.

+  Status = SdReadWrite (This, (UINTN)Lba, Buffer, BufferSize, WRITE);

+

+

+  return Status;

+

+}

+

+

+/**

+

+  Flush the Block Device.

+

+

+

+  @param  This              Indicates a pointer to the calling context.

+

+

+

+  @retval EFI_SUCCESS       All outstanding data was written to the device

+

+  @retval EFI_DEVICE_ERROR  The device reported an error while writting back the data

+

+  @retval EFI_NO_MEDIA      There is no media in the device.

+

+

+

+**/

+EFI_STATUS

+EFIAPI

+MMCHSFlushBlocks (

+  IN EFI_BLOCK_IO_PROTOCOL  *This

+  )

+{

+  return EFI_SUCCESS;

+}

+

+

+EFI_BLOCK_IO_PROTOCOL gBlockIo = {

+  EFI_BLOCK_IO_INTERFACE_REVISION,   // Revision

+  &gMMCHSMedia,                      // *Media

+  MMCHSReset,                        // Reset

+  MMCHSReadBlocks,                   // ReadBlocks

+  MMCHSWriteBlocks,                  // WriteBlocks

+  MMCHSFlushBlocks                   // FlushBlocks

+};

+

+

+/**

+

+  Timer callback to convert card present hardware into a boolean that indicates

+

+  a media change event has happened. If you just check the GPIO you could see 

+

+  card 1 and then check again after card 1 was removed and card 2 was inserted

+

+  and you would still see media present. Thus you need the timer tick to catch

+

+  the toggle event.

+

+

+

+  @param  Event                 Event whose notification function is being invoked.

+

+  @param  Context               The pointer to the notification function's context,

+

+                                which is implementation-dependent. Not used.

+

+

+

+**/

+VOID

+EFIAPI

+TimerCallback (

+  IN  EFI_EVENT   Event,

+  IN  VOID        *Context

+  )

+{

+  BOOLEAN Present;

+

+  Present = CardPresent ();

+  if (gMMCHSMedia.MediaPresent) {

+    if (!Present && !gMediaChange) {

+      gMediaChange = TRUE;

+    }

+  } else {

+    if (Present && !gMediaChange) {

+      gMediaChange = TRUE;    

+    }

+  }

+}

+

+

+EFI_STATUS

+EFIAPI

+MMCHSInitialize (

+  IN EFI_HANDLE         ImageHandle,

+  IN EFI_SYSTEM_TABLE   *SystemTable

+  )

+{

+  EFI_STATUS  Status;

+

+  Status = gBS->LocateProtocol (&gEmbeddedExternalDeviceProtocolGuid, NULL, (VOID **)&gTPS65950);

+  ASSERT_EFI_ERROR(Status);

+

+  ZeroMem (&gCardInfo, sizeof (CARD_INFO));

+

+  Status = gBS->CreateEvent (EVT_TIMER | EVT_NOTIFY_SIGNAL, TPL_CALLBACK, TimerCallback, NULL, &gTimerEvent);

+  ASSERT_EFI_ERROR (Status);

+ 

+  Status = gBS->SetTimer (gTimerEvent, TimerPeriodic, FixedPcdGet32 (PcdMmchsTimerFreq100NanoSeconds)); 

+  ASSERT_EFI_ERROR (Status);

+

+  //Publish BlockIO.

+  Status = gBS->InstallMultipleProtocolInterfaces (

+                  &ImageHandle, 

+                  &gEfiBlockIoProtocolGuid,    &gBlockIo, 

+                  &gEfiDevicePathProtocolGuid, &gMmcHsDevicePath,

+                  NULL

+                  );

+  return Status;

+}

diff --git a/Omap35xxPkg/MMCHSDxe/MMCHS.h b/Omap35xxPkg/MMCHSDxe/MMCHS.h
index 2cda5679..e19607ba 100644
--- a/Omap35xxPkg/MMCHSDxe/MMCHS.h
+++ b/Omap35xxPkg/MMCHSDxe/MMCHS.h
@@ -15,28 +15,28 @@
 #ifndef _MMCHS_H_

 #define _MMCHS_H_

 

-#include <Uefi.h>
-

-#include <Library/BaseLib.h>
-#include <Library/MemoryAllocationLib.h>
-#include <Library/DebugLib.h>
-#include <Library/IoLib.h>
-#include <Library/PcdLib.h>
-#include <Library/UefiBootServicesTableLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/OmapLib.h>
-#include <Library/OmapDmaLib.h>
-#include <Library/DmaLib.h>
-
+#include <Uefi.h>

+

+#include <Library/BaseLib.h>

+#include <Library/MemoryAllocationLib.h>

+#include <Library/DebugLib.h>

+#include <Library/IoLib.h>

+#include <Library/PcdLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/OmapLib.h>

+#include <Library/OmapDmaLib.h>

+#include <Library/DmaLib.h>

+

 #include <Protocol/EmbeddedExternalDevice.h>

-#include <Protocol/BlockIo.h>
-#include <Protocol/DevicePath.h>
-
+#include <Protocol/BlockIo.h>

+#include <Protocol/DevicePath.h>

+

 #include <Omap3530/Omap3530.h>

 #include <TPS65950.h>

 

-#define MAX_RETRY_COUNT  (100*5)
-
+#define MAX_RETRY_COUNT  (100*5)

+

 #define HCS               BIT30 //Host capacity support/1 = Supporting high capacity

 #define CCS               BIT30 //Card capacity status/1 = High capacity card

 typedef struct {

@@ -141,12 +141,12 @@ typedef struct {
   UINT8   CSD_STRUCTURE:      2; // CSD structure [127:126]

 }CSD_SDV2;

 

-typedef enum {
-  UNKNOWN_CARD,
-  MMC_CARD,              //MMC card
-  SD_CARD,               //SD 1.1 card
-  SD_CARD_2,             //SD 2.0 or above standard card
-  SD_CARD_2_HIGH         //SD 2.0 or above high capacity card
+typedef enum {

+  UNKNOWN_CARD,

+  MMC_CARD,              //MMC card

+  SD_CARD,               //SD 1.1 card

+  SD_CARD_2,             //SD 2.0 or above standard card

+  SD_CARD_2_HIGH         //SD 2.0 or above high capacity card

 } CARD_TYPE;

 

 typedef enum {

@@ -165,9 +165,9 @@ typedef struct  {
   CSD       CSDData;

 } CARD_INFO;

 

-EFI_STATUS
-DetectCard (
-  VOID
+EFI_STATUS

+DetectCard (

+  VOID

   );

 

 extern EFI_BLOCK_IO_PROTOCOL gBlockIo;

diff --git a/Omap35xxPkg/MMCHSDxe/MMCHS.inf b/Omap35xxPkg/MMCHSDxe/MMCHS.inf
index 0931112e..cc753c2a 100644
--- a/Omap35xxPkg/MMCHSDxe/MMCHS.inf
+++ b/Omap35xxPkg/MMCHSDxe/MMCHS.inf
@@ -1,54 +1,54 @@
-#/** @file
-#  
-#  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = MMCHS
-  FILE_GUID                      = 100c2cfa-b586-4198-9b4c-1683d195b1da
-  MODULE_TYPE                    = DXE_DRIVER
-  VERSION_STRING                 = 1.0
-
-  ENTRY_POINT                    = MMCHSInitialize
-
-
-[Sources.common]
-  MMCHS.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  EmbeddedPkg/EmbeddedPkg.dec
-  Omap35xxPkg/Omap35xxPkg.dec
-
-[LibraryClasses]
-  PcdLib
-  UefiLib
-  UefiDriverEntryPoint
-  MemoryAllocationLib
-  IoLib
-  OmapDmaLib
-  DmaLib
-
-[Guids]
-  
-[Protocols]
-  gEfiBlockIoProtocolGuid
-  gEfiCpuArchProtocolGuid
-  gEfiDevicePathProtocolGuid
-  gEmbeddedExternalDeviceProtocolGuid
-
-[Pcd]
-  gOmap35xxTokenSpaceGuid.PcdOmap35xxMMCHS1Base
-  gOmap35xxTokenSpaceGuid.PcdMmchsTimerFreq100NanoSeconds
-
-[depex]
-  gEmbeddedExternalDeviceProtocolGuid
+#/** @file

+#  

+#  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = MMCHS

+  FILE_GUID                      = 100c2cfa-b586-4198-9b4c-1683d195b1da

+  MODULE_TYPE                    = DXE_DRIVER

+  VERSION_STRING                 = 1.0

+

+  ENTRY_POINT                    = MMCHSInitialize

+

+

+[Sources.common]

+  MMCHS.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  EmbeddedPkg/EmbeddedPkg.dec

+  Omap35xxPkg/Omap35xxPkg.dec

+

+[LibraryClasses]

+  PcdLib

+  UefiLib

+  UefiDriverEntryPoint

+  MemoryAllocationLib

+  IoLib

+  OmapDmaLib

+  DmaLib

+

+[Guids]

+  

+[Protocols]

+  gEfiBlockIoProtocolGuid

+  gEfiCpuArchProtocolGuid

+  gEfiDevicePathProtocolGuid

+  gEmbeddedExternalDeviceProtocolGuid

+

+[Pcd]

+  gOmap35xxTokenSpaceGuid.PcdOmap35xxMMCHS1Base

+  gOmap35xxTokenSpaceGuid.PcdMmchsTimerFreq100NanoSeconds

+

+[depex]

+  gEmbeddedExternalDeviceProtocolGuid

diff --git a/Omap35xxPkg/MmcHostDxe/MmcHostDxe.c b/Omap35xxPkg/MmcHostDxe/MmcHostDxe.c
index 17ebf8d7..0cbd82bd 100755
--- a/Omap35xxPkg/MmcHostDxe/MmcHostDxe.c
+++ b/Omap35xxPkg/MmcHostDxe/MmcHostDxe.c
@@ -1,677 +1,677 @@
-/** @file
-*
-*  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.
-*  Copyright (c) 2011, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-#include "MmcHostDxe.h"
-
-EMBEDDED_EXTERNAL_DEVICE   *gTPS65950;
-UINT8                      mMaxDataTransferRate = 0;
-UINT32                     mRca = 0;
-BOOLEAN                    mBitModeSet = FALSE;
-
-
-typedef struct {
-  VENDOR_DEVICE_PATH  Mmc;
-  EFI_DEVICE_PATH     End;
-} MMCHS_DEVICE_PATH;
-
-MMCHS_DEVICE_PATH gMMCDevicePath = {
-  {
-    HARDWARE_DEVICE_PATH,
-    HW_VENDOR_DP,
-    (UINT8)(sizeof(VENDOR_DEVICE_PATH)),
-    (UINT8)((sizeof(VENDOR_DEVICE_PATH)) >> 8),
-    0xb615f1f5, 0x5088, 0x43cd, 0x80, 0x9c, 0xa1, 0x6e, 0x52, 0x48, 0x7d, 0x00 
-  },
-  {
-    END_DEVICE_PATH_TYPE,
-    END_ENTIRE_DEVICE_PATH_SUBTYPE,
-    sizeof (EFI_DEVICE_PATH_PROTOCOL),
-    0
-  }
-};
-
-BOOLEAN
-IgnoreCommand (
-  UINT32 Command
-  )
-{
-  switch(Command) {
-    case MMC_CMD12:
-      return TRUE;
-    case MMC_CMD13:
-      return TRUE;
-    default:
-      return FALSE;
-  }
-}
-
-UINT32
-TranslateCommand (
-  UINT32 Command
-  )
-{
-  UINT32 Translation;
-
-  switch(Command) {
-    case MMC_CMD2:
-      Translation = CMD2;
-      break;
-    case MMC_CMD3:
-      Translation = CMD3;
-      break;
-    /*case MMC_CMD6:
-      Translation = CMD6;
-      break;*/
-    case MMC_CMD7:
-      Translation = CMD7;
-      break;
-    case MMC_CMD8:
-      Translation = CMD8;
-      break;
-    case MMC_CMD9:
-      Translation = CMD9;
-      break;
-    /*case MMC_CMD12:
-      Translation = CMD12;
-      break;
-    case MMC_CMD13:
-      Translation = CMD13;
-      break;*/
-    case MMC_CMD16:
-      Translation = CMD16;
-      break;
-    case MMC_CMD17:
-      Translation = 0x113A0014;//CMD17;
-      break;
-    case MMC_CMD24:
-      Translation = CMD24 | 4;
-      break;
-    case MMC_CMD55:
-      Translation = CMD55;
-      break;
-    case MMC_ACMD41:
-      Translation = ACMD41;
-      break;
-    default:
-      Translation = Command;
-  }
-
-  return Translation;
-}
-
-VOID
-CalculateCardCLKD (
-  UINTN *ClockFrequencySelect
-  )
-{
-  UINTN    TransferRateValue = 0;
-  UINTN    TimeValue = 0 ;
-  UINTN    Frequency = 0;
-
-  DEBUG ((DEBUG_BLKIO, "CalculateCardCLKD()\n"));
-
-  // For SD Cards  we would need to send CMD6 to set
-  // speeds abouve 25MHz. High Speed mode 50 MHz and up
-
-  // Calculate Transfer rate unit (Bits 2:0 of TRAN_SPEED)
-  switch (mMaxDataTransferRate & 0x7) { // 2
-    case 0:
-      TransferRateValue = 100 * 1000;
-      break;
-
-    case 1:
-      TransferRateValue = 1 * 1000 * 1000;
-      break;
-
-    case 2:
-      TransferRateValue = 10 * 1000 * 1000;
-      break;
-
-    case 3:
-      TransferRateValue = 100 * 1000 * 1000;
-      break;
-
-    default:
-      DEBUG ((DEBUG_BLKIO, "Invalid parameter.\n"));
-      ASSERT(FALSE);
-      return;
-  }
-
-  //Calculate Time value (Bits 6:3 of TRAN_SPEED)
-  switch ((mMaxDataTransferRate >> 3) & 0xF) { // 6
-    case 1:
-      TimeValue = 10;
-      break;
-
-    case 2:
-      TimeValue = 12;
-      break;
-
-    case 3:
-      TimeValue = 13;
-      break;
-
-    case 4:
-      TimeValue = 15;
-      break;
-
-    case 5:
-      TimeValue = 20;
-      break;
-
-    case 6:
-      TimeValue = 25;
-      break;
-
-    case 7:
-      TimeValue = 30;
-      break;
-
-    case 8:
-      TimeValue = 35;
-      break;
-
-    case 9:
-      TimeValue = 40;
-      break;
-
-    case 10:
-      TimeValue = 45;
-      break;
-
-    case 11:
-      TimeValue = 50;
-      break;
-
-    case 12:
-      TimeValue = 55;
-      break;
-
-    case 13:
-      TimeValue = 60;
-      break;
-
-    case 14:
-      TimeValue = 70;
-      break;
-
-    case 15:
-      TimeValue = 80;
-      break;
-
-    default:
-      DEBUG ((DEBUG_BLKIO, "Invalid parameter.\n"));
-      ASSERT(FALSE);
-      return;
-  }
-
-  Frequency = TransferRateValue * TimeValue/10;
-
-  // Calculate Clock divider value to program in MMCHS_SYSCTL[CLKD] field.
-  *ClockFrequencySelect = ((MMC_REFERENCE_CLK/Frequency) + 1);
-
-  DEBUG ((DEBUG_BLKIO, "mMaxDataTransferRate: 0x%x, Frequency: %d KHz, ClockFrequencySelect: %x\n", mMaxDataTransferRate, Frequency/1000, *ClockFrequencySelect));
-}
-
-VOID
-UpdateMMCHSClkFrequency (
-  UINTN NewCLKD
-  )
-{
-  DEBUG ((DEBUG_BLKIO, "UpdateMMCHSClkFrequency()\n"));
-
-  // Set Clock enable to 0x0 to not provide the clock to the card
-  MmioAnd32 (MMCHS_SYSCTL, ~CEN);
-
-  // Set new clock frequency.
-  MmioAndThenOr32 (MMCHS_SYSCTL, ~CLKD_MASK, NewCLKD << 6); 
-
-  // Poll till Internal Clock Stable
-  while ((MmioRead32 (MMCHS_SYSCTL) & ICS_MASK) != ICS);
-
-  // Set Clock enable to 0x1 to provide the clock to the card
-  MmioOr32 (MMCHS_SYSCTL, CEN);
-}
-
-EFI_STATUS
-InitializeMMCHS (
-  VOID
-  )
-{
-  UINT8      Data;
-  EFI_STATUS Status;
-
-  DEBUG ((DEBUG_BLKIO, "InitializeMMCHS()\n"));
-
-  // Select Device group to belong to P1 device group in Power IC.
-  Data = DEV_GRP_P1;
-  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VMMC1_DEV_GRP), 1, &Data);
-  ASSERT_EFI_ERROR(Status);
-
-  // Configure voltage regulator for MMC1 in Power IC to output 3.0 voltage.
-  Data = VSEL_3_00V;
-  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VMMC1_DEDICATED_REG), 1, &Data);
-  ASSERT_EFI_ERROR(Status);
-  
-  // After ramping up voltage, set VDDS stable bit to indicate that voltage level is stable.
-  MmioOr32 (CONTROL_PBIAS_LITE, (PBIASLITEVMODE0 | PBIASLITEPWRDNZ0 | PBIASSPEEDCTRL0 | PBIASLITEVMODE1 | PBIASLITEWRDNZ1));
-
-  // Enable WP GPIO
-  MmioAndThenOr32 (GPIO1_BASE + GPIO_OE, ~BIT23, BIT23);
-
-  // Enable Card Detect
-  Data = CARD_DETECT_ENABLE;
-  gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, TPS65950_GPIO_CTRL), 1, &Data);
-
-  return Status;
-}
-
-BOOLEAN
-MMCIsCardPresent (
-  IN EFI_MMC_HOST_PROTOCOL     *This
-  )
-{
-  EFI_STATUS  Status;
-  UINT8       Data;
-
-  //
-  // Card detect is a GPIO0 on the TPS65950
-  //
-  Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, GPIODATAIN1), 1, &Data);
-  if (EFI_ERROR (Status)) {
-    return FALSE;
-  }
-
-  return !(Data & CARD_DETECT_BIT);
-}
-
-BOOLEAN
-MMCIsReadOnly (
-  IN EFI_MMC_HOST_PROTOCOL     *This
-  )
-{
-  /* Note:
-   * On our BeagleBoard the SD card WP pin is always read as TRUE. 
-   * Probably something wrong with GPIO configuration.
-   * BeagleBoard-xM uses microSD cards so there is no write protect at all.
-   * Hence commenting out SD card WP pin read status.  
-   */
-  //return (MmioRead32 (GPIO1_BASE + GPIO_DATAIN) & BIT23) == BIT23;
-  return 0;
-
-}
-
-// TODO
-EFI_GUID mPL180MciDevicePathGuid = EFI_CALLER_ID_GUID;
-
-EFI_STATUS
-MMCBuildDevicePath (
-  IN EFI_MMC_HOST_PROTOCOL     *This,
-  IN EFI_DEVICE_PATH_PROTOCOL  **DevicePath
-  )
-{
-  EFI_DEVICE_PATH_PROTOCOL    *NewDevicePathNode;
-
-  NewDevicePathNode = CreateDeviceNode(HARDWARE_DEVICE_PATH,HW_VENDOR_DP,sizeof(VENDOR_DEVICE_PATH));
-  CopyGuid(&((VENDOR_DEVICE_PATH*)NewDevicePathNode)->Guid,&mPL180MciDevicePathGuid);
-  *DevicePath = NewDevicePathNode;
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-MMCSendCommand (
-  IN EFI_MMC_HOST_PROTOCOL     *This,
-  IN MMC_CMD                   MmcCmd,
-  IN UINT32                    Argument
-  )
-{
-  UINTN MmcStatus;
-  UINTN RetryCount = 0;
-
-  if (IgnoreCommand(MmcCmd))
-    return EFI_SUCCESS;
-
-  MmcCmd = TranslateCommand(MmcCmd);
-
-  //DEBUG ((EFI_D_ERROR, "MMCSendCommand(%d)\n", MmcCmd));
-
-  // Check if command line is in use or not. Poll till command line is available.
-  while ((MmioRead32 (MMCHS_PSTATE) & DATI_MASK) == DATI_NOT_ALLOWED);
-
-  // Provide the block size.
-  MmioWrite32 (MMCHS_BLK, BLEN_512BYTES);
-
-  // Setting Data timeout counter value to max value.
-  MmioAndThenOr32 (MMCHS_SYSCTL, ~DTO_MASK, DTO_VAL);
-
-  // Clear Status register.
-  MmioWrite32 (MMCHS_STAT, 0xFFFFFFFF);
-
-  // Set command argument register
-  MmioWrite32 (MMCHS_ARG, Argument);
-
-  //TODO: fix this
-  //Enable interrupt enable events to occur
-  //MmioWrite32 (MMCHS_IE, CmdInterruptEnableVal);
-
-  // Send a command
-  MmioWrite32 (MMCHS_CMD, MmcCmd);
-
-  // Check for the command status.
-  while (RetryCount < MAX_RETRY_COUNT) {
-    do {
-      MmcStatus = MmioRead32 (MMCHS_STAT);
-    } while (MmcStatus == 0);
-
-    // Read status of command response
-    if ((MmcStatus & ERRI) != 0) {
-
-      // Perform soft-reset for mmci_cmd line.
-      MmioOr32 (MMCHS_SYSCTL, SRC);
-      while ((MmioRead32 (MMCHS_SYSCTL) & SRC));
-
-      //DEBUG ((EFI_D_INFO, "MmcStatus: 0x%x\n", MmcStatus));
-      return EFI_DEVICE_ERROR;
-    }
-
-    // Check if command is completed.
-    if ((MmcStatus & CC) == CC) {
-      MmioWrite32 (MMCHS_STAT, CC);
-      break;
-    }
-
-    RetryCount++;
-  }
-
-  if (RetryCount == MAX_RETRY_COUNT) {
-    DEBUG ((DEBUG_BLKIO, "MMCSendCommand: Timeout\n"));
-    return EFI_TIMEOUT;
-  }
-
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-MMCNotifyState (
-  IN EFI_MMC_HOST_PROTOCOL    *This,
-  IN MMC_STATE                State
-  )
-{
-  EFI_STATUS              Status;
-  UINTN                   FreqSel;
-
-  switch(State) {
-    case MmcInvalidState:
-      ASSERT(0);
-      break;
-    case MmcHwInitializationState:
-      mBitModeSet = FALSE;
-
-      DEBUG ((DEBUG_BLKIO, "MMCHwInitializationState()\n"));
-      Status = InitializeMMCHS ();
-      if (EFI_ERROR(Status)) {
-        DEBUG ((DEBUG_BLKIO, "Initialize MMC host controller fails. Status: %x\n", Status));
-        return Status;
-      }
-
-      // Software reset of the MMCHS host controller.
-      MmioWrite32 (MMCHS_SYSCONFIG, SOFTRESET);
-      gBS->Stall(1000);
-      while ((MmioRead32 (MMCHS_SYSSTATUS) & RESETDONE_MASK) != RESETDONE);
-
-      // Soft reset for all.
-      MmioWrite32 (MMCHS_SYSCTL, SRA);
-      gBS->Stall(1000);
-      while ((MmioRead32 (MMCHS_SYSCTL) & SRA) != 0x0);
-
-      //Voltage capabilities initialization. Activate VS18 and VS30.
-      MmioOr32 (MMCHS_CAPA, (VS30 | VS18));
-
-      // Wakeup configuration
-      MmioOr32 (MMCHS_SYSCONFIG, ENAWAKEUP);
-      MmioOr32 (MMCHS_HCTL, IWE);
-
-      // MMCHS Controller default initialization
-      MmioOr32 (MMCHS_CON, (OD | DW8_1_4_BIT | CEATA_OFF));
-
-      MmioWrite32 (MMCHS_HCTL, (SDVS_3_0_V | DTW_1_BIT | SDBP_OFF));
-
-      // Enable internal clock
-      MmioOr32 (MMCHS_SYSCTL, ICE);
-
-      // Set the clock frequency to 80KHz.
-      UpdateMMCHSClkFrequency (CLKD_80KHZ);
-
-      // Enable SD bus power.
-      MmioOr32 (MMCHS_HCTL, (SDBP_ON));
-
-      // Poll till SD bus power bit is set.
-      while ((MmioRead32 (MMCHS_HCTL) & SDBP_MASK) != SDBP_ON);
-
-      // Enable interrupts.
-      MmioWrite32 (MMCHS_IE, (BADA_EN | CERR_EN | DEB_EN | DCRC_EN | DTO_EN | CIE_EN |
-        CEB_EN | CCRC_EN | CTO_EN | BRR_EN | BWR_EN | TC_EN | CC_EN));
-
-      // Controller INIT procedure start.
-      MmioOr32 (MMCHS_CON, INIT);
-      MmioWrite32 (MMCHS_CMD, 0x00000000);
-      while (!(MmioRead32 (MMCHS_STAT) & CC));
-
-      // Wait for 1 ms
-      gBS->Stall (1000);
-
-      // Set CC bit to 0x1 to clear the flag
-      MmioOr32 (MMCHS_STAT, CC);
-
-      // Retry INIT procedure.
-      MmioWrite32 (MMCHS_CMD, 0x00000000);
-      while (!(MmioRead32 (MMCHS_STAT) & CC));
-
-      // End initialization sequence
-      MmioAnd32 (MMCHS_CON, ~INIT);
-
-      MmioOr32 (MMCHS_HCTL, (SDVS_3_0_V | DTW_1_BIT | SDBP_ON));
-
-      // Change clock frequency to 400KHz to fit protocol
-      UpdateMMCHSClkFrequency(CLKD_400KHZ);
-
-      MmioOr32 (MMCHS_CON, OD);
-      break;
-    case MmcIdleState:
-      break;
-    case MmcReadyState:
-      break;
-    case MmcIdentificationState:
-      break;
-    case MmcStandByState:
-      CalculateCardCLKD (&FreqSel);
-      UpdateMMCHSClkFrequency (FreqSel);
-      break;
-    case MmcTransferState:
-      if (!mBitModeSet) {
-        Status = MMCSendCommand (This, CMD55, mRca << 16);
-        if (!EFI_ERROR (Status)) {
-          // Set device into 4-bit data bus mode
-          Status = MMCSendCommand (This, ACMD6, 0x2);
-          if (!EFI_ERROR (Status)) {
-            // Set host controler into 4-bit mode
-            MmioOr32 (MMCHS_HCTL, DTW_4_BIT);
-            DEBUG ((DEBUG_BLKIO, "SD Memory Card set to 4-bit mode\n"));
-            mBitModeSet = TRUE;
-          }
-        }
-      }
-      break;
-    case MmcSendingDataState:
-      break;
-    case MmcReceiveDataState:
-      break;
-    case MmcProgrammingState:
-      break;
-    case MmcDisconnectState:
-    default:
-      ASSERT(0);
-  }
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-MMCReceiveResponse (
-  IN EFI_MMC_HOST_PROTOCOL     *This,
-  IN MMC_RESPONSE_TYPE         Type,
-  IN UINT32*                   Buffer
-  )
-{
-  if (Buffer == NULL) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  if (Type == MMC_RESPONSE_TYPE_R2) {
-    Buffer[0] = MmioRead32 (MMCHS_RSP10);
-    Buffer[1] = MmioRead32 (MMCHS_RSP32);
-    Buffer[2] = MmioRead32 (MMCHS_RSP54);
-    Buffer[3] = MmioRead32 (MMCHS_RSP76);
-  } else {
-    Buffer[0] = MmioRead32 (MMCHS_RSP10);
-  }
-
-  if (Type == MMC_RESPONSE_TYPE_CSD) {
-    mMaxDataTransferRate = Buffer[3] & 0xFF;
-  } else if (Type == MMC_RESPONSE_TYPE_RCA) {
-    mRca = Buffer[0] >> 16;
-  }
-
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-MMCReadBlockData (
-  IN EFI_MMC_HOST_PROTOCOL      *This,
-  IN EFI_LBA                    Lba,
-  IN UINTN                      Length,
-  IN UINT32*                    Buffer
-  )
-{
-  UINTN MmcStatus;
-  UINTN Count;
-  UINTN RetryCount = 0;
-
-  DEBUG ((DEBUG_BLKIO, "MMCReadBlockData(LBA: 0x%x, Length: 0x%x, Buffer: 0x%x)\n", Lba, Length, Buffer));
-
-  // Check controller status to make sure there is no error.
-  while (RetryCount < MAX_RETRY_COUNT) {
-    do {
-      // Read Status.
-      MmcStatus = MmioRead32 (MMCHS_STAT);
-    } while(MmcStatus == 0);
-
-    // Check if Buffer read ready (BRR) bit is set?
-    if (MmcStatus & BRR) {
-
-      // Clear BRR bit
-      MmioOr32 (MMCHS_STAT, BRR);
-
-      for (Count = 0; Count < Length / 4; Count++) {
-        *Buffer++ = MmioRead32(MMCHS_DATA);
-      }
-      break;
-    }
-    RetryCount++;
-  }
-
-  if (RetryCount == MAX_RETRY_COUNT) {
-    return EFI_TIMEOUT;
-  }
-
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-MMCWriteBlockData (
-  IN EFI_MMC_HOST_PROTOCOL    *This,
-  IN EFI_LBA                  Lba,
-  IN UINTN                    Length,
-  IN UINT32*                  Buffer
-  )
-{
-  UINTN MmcStatus;
-  UINTN Count;
-  UINTN RetryCount = 0;
-
-  // Check controller status to make sure there is no error.
-  while (RetryCount < MAX_RETRY_COUNT) {
-    do {
-      // Read Status.
-      MmcStatus = MmioRead32 (MMCHS_STAT);
-    } while(MmcStatus == 0);
-
-    // Check if Buffer write ready (BWR) bit is set?
-    if (MmcStatus & BWR) {
-
-      // Clear BWR bit
-      MmioOr32 (MMCHS_STAT, BWR);
-
-      // Write block worth of data.
-      for (Count = 0; Count < Length / 4; Count++) {
-        MmioWrite32 (MMCHS_DATA, *Buffer++);
-      }
-
-      break;
-    }
-    RetryCount++;
-  }
-
-  if (RetryCount == MAX_RETRY_COUNT) {
-    return EFI_TIMEOUT;
-  }
-
-  return EFI_SUCCESS;
-}
-
-EFI_MMC_HOST_PROTOCOL gMMCHost = {
-  MMC_HOST_PROTOCOL_REVISION,
-  MMCIsCardPresent,
-  MMCIsReadOnly,
-  MMCBuildDevicePath,
-  MMCNotifyState,
-  MMCSendCommand,
-  MMCReceiveResponse,
-  MMCReadBlockData,
-  MMCWriteBlockData
-};
-
-EFI_STATUS
-MMCInitialize (
-  IN EFI_HANDLE         ImageHandle,
-  IN EFI_SYSTEM_TABLE   *SystemTable
-  )
-{
-  EFI_STATUS    Status;
-  EFI_HANDLE    Handle = NULL;
-
-  DEBUG ((DEBUG_BLKIO, "MMCInitialize()\n"));
-
-  Status = gBS->LocateProtocol (&gEmbeddedExternalDeviceProtocolGuid, NULL, (VOID **)&gTPS65950);
-  ASSERT_EFI_ERROR(Status);
-
-  Status = gBS->InstallMultipleProtocolInterfaces (
-                  &Handle, 
-                  &gEfiMmcHostProtocolGuid,         &gMMCHost,
-                  NULL
-                  );
-  ASSERT_EFI_ERROR (Status);
-
-  return Status;
-}
+/** @file

+*

+*  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.

+*  Copyright (c) 2011, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+#include "MmcHostDxe.h"

+

+EMBEDDED_EXTERNAL_DEVICE   *gTPS65950;

+UINT8                      mMaxDataTransferRate = 0;

+UINT32                     mRca = 0;

+BOOLEAN                    mBitModeSet = FALSE;

+

+

+typedef struct {

+  VENDOR_DEVICE_PATH  Mmc;

+  EFI_DEVICE_PATH     End;

+} MMCHS_DEVICE_PATH;

+

+MMCHS_DEVICE_PATH gMMCDevicePath = {

+  {

+    HARDWARE_DEVICE_PATH,

+    HW_VENDOR_DP,

+    (UINT8)(sizeof(VENDOR_DEVICE_PATH)),

+    (UINT8)((sizeof(VENDOR_DEVICE_PATH)) >> 8),

+    0xb615f1f5, 0x5088, 0x43cd, 0x80, 0x9c, 0xa1, 0x6e, 0x52, 0x48, 0x7d, 0x00 

+  },

+  {

+    END_DEVICE_PATH_TYPE,

+    END_ENTIRE_DEVICE_PATH_SUBTYPE,

+    sizeof (EFI_DEVICE_PATH_PROTOCOL),

+    0

+  }

+};

+

+BOOLEAN

+IgnoreCommand (

+  UINT32 Command

+  )

+{

+  switch(Command) {

+    case MMC_CMD12:

+      return TRUE;

+    case MMC_CMD13:

+      return TRUE;

+    default:

+      return FALSE;

+  }

+}

+

+UINT32

+TranslateCommand (

+  UINT32 Command

+  )

+{

+  UINT32 Translation;

+

+  switch(Command) {

+    case MMC_CMD2:

+      Translation = CMD2;

+      break;

+    case MMC_CMD3:

+      Translation = CMD3;

+      break;

+    /*case MMC_CMD6:

+      Translation = CMD6;

+      break;*/

+    case MMC_CMD7:

+      Translation = CMD7;

+      break;

+    case MMC_CMD8:

+      Translation = CMD8;

+      break;

+    case MMC_CMD9:

+      Translation = CMD9;

+      break;

+    /*case MMC_CMD12:

+      Translation = CMD12;

+      break;

+    case MMC_CMD13:

+      Translation = CMD13;

+      break;*/

+    case MMC_CMD16:

+      Translation = CMD16;

+      break;

+    case MMC_CMD17:

+      Translation = 0x113A0014;//CMD17;

+      break;

+    case MMC_CMD24:

+      Translation = CMD24 | 4;

+      break;

+    case MMC_CMD55:

+      Translation = CMD55;

+      break;

+    case MMC_ACMD41:

+      Translation = ACMD41;

+      break;

+    default:

+      Translation = Command;

+  }

+

+  return Translation;

+}

+

+VOID

+CalculateCardCLKD (

+  UINTN *ClockFrequencySelect

+  )

+{

+  UINTN    TransferRateValue = 0;

+  UINTN    TimeValue = 0 ;

+  UINTN    Frequency = 0;

+

+  DEBUG ((DEBUG_BLKIO, "CalculateCardCLKD()\n"));

+

+  // For SD Cards  we would need to send CMD6 to set

+  // speeds abouve 25MHz. High Speed mode 50 MHz and up

+

+  // Calculate Transfer rate unit (Bits 2:0 of TRAN_SPEED)

+  switch (mMaxDataTransferRate & 0x7) { // 2

+    case 0:

+      TransferRateValue = 100 * 1000;

+      break;

+

+    case 1:

+      TransferRateValue = 1 * 1000 * 1000;

+      break;

+

+    case 2:

+      TransferRateValue = 10 * 1000 * 1000;

+      break;

+

+    case 3:

+      TransferRateValue = 100 * 1000 * 1000;

+      break;

+

+    default:

+      DEBUG ((DEBUG_BLKIO, "Invalid parameter.\n"));

+      ASSERT(FALSE);

+      return;

+  }

+

+  //Calculate Time value (Bits 6:3 of TRAN_SPEED)

+  switch ((mMaxDataTransferRate >> 3) & 0xF) { // 6

+    case 1:

+      TimeValue = 10;

+      break;

+

+    case 2:

+      TimeValue = 12;

+      break;

+

+    case 3:

+      TimeValue = 13;

+      break;

+

+    case 4:

+      TimeValue = 15;

+      break;

+

+    case 5:

+      TimeValue = 20;

+      break;

+

+    case 6:

+      TimeValue = 25;

+      break;

+

+    case 7:

+      TimeValue = 30;

+      break;

+

+    case 8:

+      TimeValue = 35;

+      break;

+

+    case 9:

+      TimeValue = 40;

+      break;

+

+    case 10:

+      TimeValue = 45;

+      break;

+

+    case 11:

+      TimeValue = 50;

+      break;

+

+    case 12:

+      TimeValue = 55;

+      break;

+

+    case 13:

+      TimeValue = 60;

+      break;

+

+    case 14:

+      TimeValue = 70;

+      break;

+

+    case 15:

+      TimeValue = 80;

+      break;

+

+    default:

+      DEBUG ((DEBUG_BLKIO, "Invalid parameter.\n"));

+      ASSERT(FALSE);

+      return;

+  }

+

+  Frequency = TransferRateValue * TimeValue/10;

+

+  // Calculate Clock divider value to program in MMCHS_SYSCTL[CLKD] field.

+  *ClockFrequencySelect = ((MMC_REFERENCE_CLK/Frequency) + 1);

+

+  DEBUG ((DEBUG_BLKIO, "mMaxDataTransferRate: 0x%x, Frequency: %d KHz, ClockFrequencySelect: %x\n", mMaxDataTransferRate, Frequency/1000, *ClockFrequencySelect));

+}

+

+VOID

+UpdateMMCHSClkFrequency (

+  UINTN NewCLKD

+  )

+{

+  DEBUG ((DEBUG_BLKIO, "UpdateMMCHSClkFrequency()\n"));

+

+  // Set Clock enable to 0x0 to not provide the clock to the card

+  MmioAnd32 (MMCHS_SYSCTL, ~CEN);

+

+  // Set new clock frequency.

+  MmioAndThenOr32 (MMCHS_SYSCTL, ~CLKD_MASK, NewCLKD << 6); 

+

+  // Poll till Internal Clock Stable

+  while ((MmioRead32 (MMCHS_SYSCTL) & ICS_MASK) != ICS);

+

+  // Set Clock enable to 0x1 to provide the clock to the card

+  MmioOr32 (MMCHS_SYSCTL, CEN);

+}

+

+EFI_STATUS

+InitializeMMCHS (

+  VOID

+  )

+{

+  UINT8      Data;

+  EFI_STATUS Status;

+

+  DEBUG ((DEBUG_BLKIO, "InitializeMMCHS()\n"));

+

+  // Select Device group to belong to P1 device group in Power IC.

+  Data = DEV_GRP_P1;

+  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VMMC1_DEV_GRP), 1, &Data);

+  ASSERT_EFI_ERROR(Status);

+

+  // Configure voltage regulator for MMC1 in Power IC to output 3.0 voltage.

+  Data = VSEL_3_00V;

+  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VMMC1_DEDICATED_REG), 1, &Data);

+  ASSERT_EFI_ERROR(Status);

+  

+  // After ramping up voltage, set VDDS stable bit to indicate that voltage level is stable.

+  MmioOr32 (CONTROL_PBIAS_LITE, (PBIASLITEVMODE0 | PBIASLITEPWRDNZ0 | PBIASSPEEDCTRL0 | PBIASLITEVMODE1 | PBIASLITEWRDNZ1));

+

+  // Enable WP GPIO

+  MmioAndThenOr32 (GPIO1_BASE + GPIO_OE, ~BIT23, BIT23);

+

+  // Enable Card Detect

+  Data = CARD_DETECT_ENABLE;

+  gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, TPS65950_GPIO_CTRL), 1, &Data);

+

+  return Status;

+}

+

+BOOLEAN

+MMCIsCardPresent (

+  IN EFI_MMC_HOST_PROTOCOL     *This

+  )

+{

+  EFI_STATUS  Status;

+  UINT8       Data;

+

+  //

+  // Card detect is a GPIO0 on the TPS65950

+  //

+  Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, GPIODATAIN1), 1, &Data);

+  if (EFI_ERROR (Status)) {

+    return FALSE;

+  }

+

+  return !(Data & CARD_DETECT_BIT);

+}

+

+BOOLEAN

+MMCIsReadOnly (

+  IN EFI_MMC_HOST_PROTOCOL     *This

+  )

+{

+  /* Note:

+   * On our BeagleBoard the SD card WP pin is always read as TRUE. 

+   * Probably something wrong with GPIO configuration.

+   * BeagleBoard-xM uses microSD cards so there is no write protect at all.

+   * Hence commenting out SD card WP pin read status.  

+   */

+  //return (MmioRead32 (GPIO1_BASE + GPIO_DATAIN) & BIT23) == BIT23;

+  return 0;

+

+}

+

+// TODO

+EFI_GUID mPL180MciDevicePathGuid = EFI_CALLER_ID_GUID;

+

+EFI_STATUS

+MMCBuildDevicePath (

+  IN EFI_MMC_HOST_PROTOCOL     *This,

+  IN EFI_DEVICE_PATH_PROTOCOL  **DevicePath

+  )

+{

+  EFI_DEVICE_PATH_PROTOCOL    *NewDevicePathNode;

+

+  NewDevicePathNode = CreateDeviceNode(HARDWARE_DEVICE_PATH,HW_VENDOR_DP,sizeof(VENDOR_DEVICE_PATH));

+  CopyGuid(&((VENDOR_DEVICE_PATH*)NewDevicePathNode)->Guid,&mPL180MciDevicePathGuid);

+  *DevicePath = NewDevicePathNode;

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+MMCSendCommand (

+  IN EFI_MMC_HOST_PROTOCOL     *This,

+  IN MMC_CMD                   MmcCmd,

+  IN UINT32                    Argument

+  )

+{

+  UINTN MmcStatus;

+  UINTN RetryCount = 0;

+

+  if (IgnoreCommand(MmcCmd))

+    return EFI_SUCCESS;

+

+  MmcCmd = TranslateCommand(MmcCmd);

+

+  //DEBUG ((EFI_D_ERROR, "MMCSendCommand(%d)\n", MmcCmd));

+

+  // Check if command line is in use or not. Poll till command line is available.

+  while ((MmioRead32 (MMCHS_PSTATE) & DATI_MASK) == DATI_NOT_ALLOWED);

+

+  // Provide the block size.

+  MmioWrite32 (MMCHS_BLK, BLEN_512BYTES);

+

+  // Setting Data timeout counter value to max value.

+  MmioAndThenOr32 (MMCHS_SYSCTL, ~DTO_MASK, DTO_VAL);

+

+  // Clear Status register.

+  MmioWrite32 (MMCHS_STAT, 0xFFFFFFFF);

+

+  // Set command argument register

+  MmioWrite32 (MMCHS_ARG, Argument);

+

+  //TODO: fix this

+  //Enable interrupt enable events to occur

+  //MmioWrite32 (MMCHS_IE, CmdInterruptEnableVal);

+

+  // Send a command

+  MmioWrite32 (MMCHS_CMD, MmcCmd);

+

+  // Check for the command status.

+  while (RetryCount < MAX_RETRY_COUNT) {

+    do {

+      MmcStatus = MmioRead32 (MMCHS_STAT);

+    } while (MmcStatus == 0);

+

+    // Read status of command response

+    if ((MmcStatus & ERRI) != 0) {

+

+      // Perform soft-reset for mmci_cmd line.

+      MmioOr32 (MMCHS_SYSCTL, SRC);

+      while ((MmioRead32 (MMCHS_SYSCTL) & SRC));

+

+      //DEBUG ((EFI_D_INFO, "MmcStatus: 0x%x\n", MmcStatus));

+      return EFI_DEVICE_ERROR;

+    }

+

+    // Check if command is completed.

+    if ((MmcStatus & CC) == CC) {

+      MmioWrite32 (MMCHS_STAT, CC);

+      break;

+    }

+

+    RetryCount++;

+  }

+

+  if (RetryCount == MAX_RETRY_COUNT) {

+    DEBUG ((DEBUG_BLKIO, "MMCSendCommand: Timeout\n"));

+    return EFI_TIMEOUT;

+  }

+

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+MMCNotifyState (

+  IN EFI_MMC_HOST_PROTOCOL    *This,

+  IN MMC_STATE                State

+  )

+{

+  EFI_STATUS              Status;

+  UINTN                   FreqSel;

+

+  switch(State) {

+    case MmcInvalidState:

+      ASSERT(0);

+      break;

+    case MmcHwInitializationState:

+      mBitModeSet = FALSE;

+

+      DEBUG ((DEBUG_BLKIO, "MMCHwInitializationState()\n"));

+      Status = InitializeMMCHS ();

+      if (EFI_ERROR(Status)) {

+        DEBUG ((DEBUG_BLKIO, "Initialize MMC host controller fails. Status: %x\n", Status));

+        return Status;

+      }

+

+      // Software reset of the MMCHS host controller.

+      MmioWrite32 (MMCHS_SYSCONFIG, SOFTRESET);

+      gBS->Stall(1000);

+      while ((MmioRead32 (MMCHS_SYSSTATUS) & RESETDONE_MASK) != RESETDONE);

+

+      // Soft reset for all.

+      MmioWrite32 (MMCHS_SYSCTL, SRA);

+      gBS->Stall(1000);

+      while ((MmioRead32 (MMCHS_SYSCTL) & SRA) != 0x0);

+

+      //Voltage capabilities initialization. Activate VS18 and VS30.

+      MmioOr32 (MMCHS_CAPA, (VS30 | VS18));

+

+      // Wakeup configuration

+      MmioOr32 (MMCHS_SYSCONFIG, ENAWAKEUP);

+      MmioOr32 (MMCHS_HCTL, IWE);

+

+      // MMCHS Controller default initialization

+      MmioOr32 (MMCHS_CON, (OD | DW8_1_4_BIT | CEATA_OFF));

+

+      MmioWrite32 (MMCHS_HCTL, (SDVS_3_0_V | DTW_1_BIT | SDBP_OFF));

+

+      // Enable internal clock

+      MmioOr32 (MMCHS_SYSCTL, ICE);

+

+      // Set the clock frequency to 80KHz.

+      UpdateMMCHSClkFrequency (CLKD_80KHZ);

+

+      // Enable SD bus power.

+      MmioOr32 (MMCHS_HCTL, (SDBP_ON));

+

+      // Poll till SD bus power bit is set.

+      while ((MmioRead32 (MMCHS_HCTL) & SDBP_MASK) != SDBP_ON);

+

+      // Enable interrupts.

+      MmioWrite32 (MMCHS_IE, (BADA_EN | CERR_EN | DEB_EN | DCRC_EN | DTO_EN | CIE_EN |

+        CEB_EN | CCRC_EN | CTO_EN | BRR_EN | BWR_EN | TC_EN | CC_EN));

+

+      // Controller INIT procedure start.

+      MmioOr32 (MMCHS_CON, INIT);

+      MmioWrite32 (MMCHS_CMD, 0x00000000);

+      while (!(MmioRead32 (MMCHS_STAT) & CC));

+

+      // Wait for 1 ms

+      gBS->Stall (1000);

+

+      // Set CC bit to 0x1 to clear the flag

+      MmioOr32 (MMCHS_STAT, CC);

+

+      // Retry INIT procedure.

+      MmioWrite32 (MMCHS_CMD, 0x00000000);

+      while (!(MmioRead32 (MMCHS_STAT) & CC));

+

+      // End initialization sequence

+      MmioAnd32 (MMCHS_CON, ~INIT);

+

+      MmioOr32 (MMCHS_HCTL, (SDVS_3_0_V | DTW_1_BIT | SDBP_ON));

+

+      // Change clock frequency to 400KHz to fit protocol

+      UpdateMMCHSClkFrequency(CLKD_400KHZ);

+

+      MmioOr32 (MMCHS_CON, OD);

+      break;

+    case MmcIdleState:

+      break;

+    case MmcReadyState:

+      break;

+    case MmcIdentificationState:

+      break;

+    case MmcStandByState:

+      CalculateCardCLKD (&FreqSel);

+      UpdateMMCHSClkFrequency (FreqSel);

+      break;

+    case MmcTransferState:

+      if (!mBitModeSet) {

+        Status = MMCSendCommand (This, CMD55, mRca << 16);

+        if (!EFI_ERROR (Status)) {

+          // Set device into 4-bit data bus mode

+          Status = MMCSendCommand (This, ACMD6, 0x2);

+          if (!EFI_ERROR (Status)) {

+            // Set host controler into 4-bit mode

+            MmioOr32 (MMCHS_HCTL, DTW_4_BIT);

+            DEBUG ((DEBUG_BLKIO, "SD Memory Card set to 4-bit mode\n"));

+            mBitModeSet = TRUE;

+          }

+        }

+      }

+      break;

+    case MmcSendingDataState:

+      break;

+    case MmcReceiveDataState:

+      break;

+    case MmcProgrammingState:

+      break;

+    case MmcDisconnectState:

+    default:

+      ASSERT(0);

+  }

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+MMCReceiveResponse (

+  IN EFI_MMC_HOST_PROTOCOL     *This,

+  IN MMC_RESPONSE_TYPE         Type,

+  IN UINT32*                   Buffer

+  )

+{

+  if (Buffer == NULL) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  if (Type == MMC_RESPONSE_TYPE_R2) {

+    Buffer[0] = MmioRead32 (MMCHS_RSP10);

+    Buffer[1] = MmioRead32 (MMCHS_RSP32);

+    Buffer[2] = MmioRead32 (MMCHS_RSP54);

+    Buffer[3] = MmioRead32 (MMCHS_RSP76);

+  } else {

+    Buffer[0] = MmioRead32 (MMCHS_RSP10);

+  }

+

+  if (Type == MMC_RESPONSE_TYPE_CSD) {

+    mMaxDataTransferRate = Buffer[3] & 0xFF;

+  } else if (Type == MMC_RESPONSE_TYPE_RCA) {

+    mRca = Buffer[0] >> 16;

+  }

+

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+MMCReadBlockData (

+  IN EFI_MMC_HOST_PROTOCOL      *This,

+  IN EFI_LBA                    Lba,

+  IN UINTN                      Length,

+  IN UINT32*                    Buffer

+  )

+{

+  UINTN MmcStatus;

+  UINTN Count;

+  UINTN RetryCount = 0;

+

+  DEBUG ((DEBUG_BLKIO, "MMCReadBlockData(LBA: 0x%x, Length: 0x%x, Buffer: 0x%x)\n", Lba, Length, Buffer));

+

+  // Check controller status to make sure there is no error.

+  while (RetryCount < MAX_RETRY_COUNT) {

+    do {

+      // Read Status.

+      MmcStatus = MmioRead32 (MMCHS_STAT);

+    } while(MmcStatus == 0);

+

+    // Check if Buffer read ready (BRR) bit is set?

+    if (MmcStatus & BRR) {

+

+      // Clear BRR bit

+      MmioOr32 (MMCHS_STAT, BRR);

+

+      for (Count = 0; Count < Length / 4; Count++) {

+        *Buffer++ = MmioRead32(MMCHS_DATA);

+      }

+      break;

+    }

+    RetryCount++;

+  }

+

+  if (RetryCount == MAX_RETRY_COUNT) {

+    return EFI_TIMEOUT;

+  }

+

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+MMCWriteBlockData (

+  IN EFI_MMC_HOST_PROTOCOL    *This,

+  IN EFI_LBA                  Lba,

+  IN UINTN                    Length,

+  IN UINT32*                  Buffer

+  )

+{

+  UINTN MmcStatus;

+  UINTN Count;

+  UINTN RetryCount = 0;

+

+  // Check controller status to make sure there is no error.

+  while (RetryCount < MAX_RETRY_COUNT) {

+    do {

+      // Read Status.

+      MmcStatus = MmioRead32 (MMCHS_STAT);

+    } while(MmcStatus == 0);

+

+    // Check if Buffer write ready (BWR) bit is set?

+    if (MmcStatus & BWR) {

+

+      // Clear BWR bit

+      MmioOr32 (MMCHS_STAT, BWR);

+

+      // Write block worth of data.

+      for (Count = 0; Count < Length / 4; Count++) {

+        MmioWrite32 (MMCHS_DATA, *Buffer++);

+      }

+

+      break;

+    }

+    RetryCount++;

+  }

+

+  if (RetryCount == MAX_RETRY_COUNT) {

+    return EFI_TIMEOUT;

+  }

+

+  return EFI_SUCCESS;

+}

+

+EFI_MMC_HOST_PROTOCOL gMMCHost = {

+  MMC_HOST_PROTOCOL_REVISION,

+  MMCIsCardPresent,

+  MMCIsReadOnly,

+  MMCBuildDevicePath,

+  MMCNotifyState,

+  MMCSendCommand,

+  MMCReceiveResponse,

+  MMCReadBlockData,

+  MMCWriteBlockData

+};

+

+EFI_STATUS

+MMCInitialize (

+  IN EFI_HANDLE         ImageHandle,

+  IN EFI_SYSTEM_TABLE   *SystemTable

+  )

+{

+  EFI_STATUS    Status;

+  EFI_HANDLE    Handle = NULL;

+

+  DEBUG ((DEBUG_BLKIO, "MMCInitialize()\n"));

+

+  Status = gBS->LocateProtocol (&gEmbeddedExternalDeviceProtocolGuid, NULL, (VOID **)&gTPS65950);

+  ASSERT_EFI_ERROR(Status);

+

+  Status = gBS->InstallMultipleProtocolInterfaces (

+                  &Handle, 

+                  &gEfiMmcHostProtocolGuid,         &gMMCHost,

+                  NULL

+                  );

+  ASSERT_EFI_ERROR (Status);

+

+  return Status;

+}

diff --git a/Omap35xxPkg/MmcHostDxe/MmcHostDxe.h b/Omap35xxPkg/MmcHostDxe/MmcHostDxe.h
index 940087f2..ec55234d 100755
--- a/Omap35xxPkg/MmcHostDxe/MmcHostDxe.h
+++ b/Omap35xxPkg/MmcHostDxe/MmcHostDxe.h
@@ -1,44 +1,44 @@
-/** @file
-*
-*  Copyright (c) 2011, ARM Limited. All rights reserved.
-*  
-*  This program and the accompanying materials                          
-*  are licensed and made available under the terms and conditions of the BSD License         
-*  which accompanies this distribution.  The full text of the license may be found at        
-*  http://opensource.org/licenses/bsd-license.php                                            
-*
-*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-*
-**/
-
-#ifndef _MMC_HOST_DXE_H_
-#define _MMC_HOST_DXE_H_
-
-#include <Uefi.h>
-
-#include <Library/BaseLib.h>
-#include <Library/MemoryAllocationLib.h>
-#include <Library/DebugLib.h>
-#include <Library/DevicePathLib.h>
-#include <Library/IoLib.h>
-#include <Library/PcdLib.h>
-#include <Library/UefiBootServicesTableLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/OmapLib.h>
-#include <Library/OmapDmaLib.h>
-#include <Library/DmaLib.h>
-
-#include <Protocol/EmbeddedExternalDevice.h>
-#include <Protocol/BlockIo.h>
-#include <Protocol/DevicePath.h>
-#include <Protocol/MmcHost.h>
-
-#include <Omap3530/Omap3530.h>
-#include <TPS65950.h>
-
-#define MAX_RETRY_COUNT  (100*5)
-
-extern EFI_BLOCK_IO_PROTOCOL gBlockIo;
-
-#endif
+/** @file

+*

+*  Copyright (c) 2011, ARM Limited. All rights reserved.

+*  

+*  This program and the accompanying materials                          

+*  are licensed and made available under the terms and conditions of the BSD License         

+*  which accompanies this distribution.  The full text of the license may be found at        

+*  http://opensource.org/licenses/bsd-license.php                                            

+*

+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+*

+**/

+

+#ifndef _MMC_HOST_DXE_H_

+#define _MMC_HOST_DXE_H_

+

+#include <Uefi.h>

+

+#include <Library/BaseLib.h>

+#include <Library/MemoryAllocationLib.h>

+#include <Library/DebugLib.h>

+#include <Library/DevicePathLib.h>

+#include <Library/IoLib.h>

+#include <Library/PcdLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/OmapLib.h>

+#include <Library/OmapDmaLib.h>

+#include <Library/DmaLib.h>

+

+#include <Protocol/EmbeddedExternalDevice.h>

+#include <Protocol/BlockIo.h>

+#include <Protocol/DevicePath.h>

+#include <Protocol/MmcHost.h>

+

+#include <Omap3530/Omap3530.h>

+#include <TPS65950.h>

+

+#define MAX_RETRY_COUNT  (100*5)

+

+extern EFI_BLOCK_IO_PROTOCOL gBlockIo;

+

+#endif

diff --git a/Omap35xxPkg/MmcHostDxe/MmcHostDxe.inf b/Omap35xxPkg/MmcHostDxe/MmcHostDxe.inf
index a15b6f70..8c95c0f2 100755
--- a/Omap35xxPkg/MmcHostDxe/MmcHostDxe.inf
+++ b/Omap35xxPkg/MmcHostDxe/MmcHostDxe.inf
@@ -1,53 +1,53 @@
-#  Copyright (c) 2011, ARM Limited. All rights reserved.
-#  
-#  This program and the accompanying materials                          
-#  are licensed and made available under the terms and conditions of the BSD License         
-#  which accompanies this distribution.  The full text of the license may be found at        
-#  http://opensource.org/licenses/bsd-license.php                                            
-#
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-#
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = MMC
-  FILE_GUID                      = 100c2cfa-b586-4198-9b4c-1683d195b1da
-  MODULE_TYPE                    = DXE_DRIVER
-  VERSION_STRING                 = 1.0
-
-  ENTRY_POINT                    = MMCInitialize
-
-
-[Sources.common]
-  MmcHostDxe.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  EmbeddedPkg/EmbeddedPkg.dec
-  Omap35xxPkg/Omap35xxPkg.dec
-
-[LibraryClasses]
-  PcdLib
-  UefiLib
-  UefiDriverEntryPoint
-  MemoryAllocationLib
-  IoLib
-  OmapDmaLib
-  DmaLib
-
-[Guids]
-  
-[Protocols]
-  gEfiBlockIoProtocolGuid
-  gEfiCpuArchProtocolGuid
-  gEfiDevicePathProtocolGuid
-  gEmbeddedExternalDeviceProtocolGuid
-  gEfiMmcHostProtocolGuid
-
-[Pcd]
-  gOmap35xxTokenSpaceGuid.PcdOmap35xxMMCHS1Base
-  gOmap35xxTokenSpaceGuid.PcdMmchsTimerFreq100NanoSeconds
-
-[depex]
-  gEmbeddedExternalDeviceProtocolGuid
+#  Copyright (c) 2011, ARM Limited. All rights reserved.

+#  

+#  This program and the accompanying materials                          

+#  are licensed and made available under the terms and conditions of the BSD License         

+#  which accompanies this distribution.  The full text of the license may be found at        

+#  http://opensource.org/licenses/bsd-license.php                                            

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+#

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = MMC

+  FILE_GUID                      = 100c2cfa-b586-4198-9b4c-1683d195b1da

+  MODULE_TYPE                    = DXE_DRIVER

+  VERSION_STRING                 = 1.0

+

+  ENTRY_POINT                    = MMCInitialize

+

+

+[Sources.common]

+  MmcHostDxe.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  EmbeddedPkg/EmbeddedPkg.dec

+  Omap35xxPkg/Omap35xxPkg.dec

+

+[LibraryClasses]

+  PcdLib

+  UefiLib

+  UefiDriverEntryPoint

+  MemoryAllocationLib

+  IoLib

+  OmapDmaLib

+  DmaLib

+

+[Guids]

+  

+[Protocols]

+  gEfiBlockIoProtocolGuid

+  gEfiCpuArchProtocolGuid

+  gEfiDevicePathProtocolGuid

+  gEmbeddedExternalDeviceProtocolGuid

+  gEfiMmcHostProtocolGuid

+

+[Pcd]

+  gOmap35xxTokenSpaceGuid.PcdOmap35xxMMCHS1Base

+  gOmap35xxTokenSpaceGuid.PcdMmchsTimerFreq100NanoSeconds

+

+[depex]

+  gEmbeddedExternalDeviceProtocolGuid

diff --git a/Omap35xxPkg/Omap35xxPkg.dsc b/Omap35xxPkg/Omap35xxPkg.dsc
index 1666a683..075dd6ae 100644
--- a/Omap35xxPkg/Omap35xxPkg.dsc
+++ b/Omap35xxPkg/Omap35xxPkg.dsc
@@ -1,188 +1,188 @@
-#/** @file
-# Omap35xx SoC package.
-#
-# Copyright (c) 2009 - 2010, Apple Inc. All rights reserved.<BR>
-#
-#    This program and the accompanying materials
-#    are licensed and made available under the terms and conditions of the BSD License
-#    which accompanies this distribution. The full text of the license may be found at
-#    http://opensource.org/licenses/bsd-license.php
-#
-#    THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-#**/
-
-################################################################################
-#
-# Defines Section - statements that will be processed to create a Makefile.
-#
-################################################################################
-[Defines]
-  PLATFORM_NAME                  = Omap35xxPkg
-  PLATFORM_GUID                  = D196A631-B7B7-4953-A3EE-0F773CBABF20
-  PLATFORM_VERSION               = 0.1
-  DSC_SPECIFICATION              = 0x00010005
-  OUTPUT_DIRECTORY               = Build/Omap35xxPkg
-  SUPPORTED_ARCHITECTURES        = ARM
-  BUILD_TARGETS                  = DEBUG|RELEASE
-  SKUID_IDENTIFIER               = DEFAULT
-  DEFINE TARGET_HACK             = DEBUG
-
-
-[LibraryClasses.common]
-  DebugLib|MdePkg/Library/BaseDebugLibNull/BaseDebugLibNull.inf
-
-  ArmLib|ArmPkg/Library/ArmLib/ArmV7/ArmV7Lib.inf
-  MemoryAllocationLib|MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf
-  
-  BaseLib|MdePkg/Library/BaseLib/BaseLib.inf
-  BaseMemoryLib|MdePkg/Library/BaseMemoryLib/BaseMemoryLib.inf
-
-  PrintLib|MdePkg/Library/BasePrintLib/BasePrintLib.inf
-  
-  CacheMaintenanceLib|ArmPkg/Library/ArmCacheMaintenanceLib/ArmCacheMaintenanceLib.inf
-  DefaultExceptioHandlerLib|ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandlerLib.inf
-  CpuExceptionHandlerLib|MdeModulePkg/Library/CpuExceptionHandlerLibNull/CpuExceptionHandlerLibNull.inf
-  PrePiLib|EmbeddedPkg/Library/PrePiLib/PrePiLib.inf
-  
-  RealTimeClockLib|EmbeddedPkg/Library/TemplateRealTimeClockLib/TemplateRealTimeClockLib.inf
-
-  IoLib|MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.inf
-  OmapLib|Omap35xxPkg/Library/OmapLib/OmapLib.inf
-  OmapDmaLib|Omap35xxPkg/Library/OmapDmaLib/OmapDmaLib.inf
-  
-  MemoryAllocationLib|MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf
-  UefiLib|MdePkg/Library/UefiLib/UefiLib.inf
-  UefiRuntimeServicesTableLib|MdePkg/Library/UefiRuntimeServicesTableLib/UefiRuntimeServicesTableLib.inf
-  DevicePathLib|MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.inf
-  UefiBootServicesTableLib|MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.inf
-
-  DxeServicesTableLib|MdePkg/Library/DxeServicesTableLib/DxeServicesTableLib.inf
-  UefiDriverEntryPoint|MdePkg/Library/UefiDriverEntryPoint/UefiDriverEntryPoint.inf
-  UefiApplicationEntryPoint|MdePkg/Library/UefiApplicationEntryPoint/UefiApplicationEntryPoint.inf
-  DmaLib|ArmPkg/Library/ArmDmaLib/ArmDmaLib.inf
-
-#
-# Assume everything is fixed at build
-#
-  PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf
-
-  UefiRuntimeLib|MdePkg/Library/UefiRuntimeLib/UefiRuntimeLib.inf
-    
- # UncachedMemoryAllocationLib|ArmPkg/Library/UncachedMemoryAllocationLib/UncachedMemoryAllocationLib.inf
-  UncachedMemoryAllocationLib|ArmPkg/Library/DebugUncachedMemoryAllocationLib/DebugUncachedMemoryAllocationLib.inf
-
-  CpuLib|MdePkg/Library/BaseCpuLib/BaseCpuLib.inf
-
-
-[LibraryClasses.common.DXE_DRIVER]
-  DxeServicesLib|MdePkg/Library/DxeServicesLib/DxeServicesLib.inf
-
-
-[LibraryClasses.ARM]
-  #
-  # Note: This NULL library feature is not yet in the edk2/BaseTools, but it is checked in to 
-  # the BaseTools project. So you need to build with the BaseTools project util this feature gets synced.
-  #
-  NULL|ArmPkg/Library/CompilerIntrinsicsLib/CompilerIntrinsicsLib.inf
-
-
-[BuildOptions]
-  XCODE:*_*_ARM_ARCHCC_FLAGS     == -arch armv7 -march=armv7
-  XCODE:*_*_ARM_ARCHASM_FLAGS    == -arch armv7
-  XCODE:*_*_ARM_ARCHDLINK_FLAGS  == -arch armv7
-
-  GCC:*_*_ARM_ARCHCC_FLAGS     == -march=armv7-a -mthumb
-  GCC:*_*_ARM_ARCHASM_FLAGS    == -march=armv7-a
-
-  RVCT:*_*_ARM_ARCHCC_FLAGS     == --cpu 7-A
-  RVCT:*_*_ARM_ARCHASM_FLAGS    == --cpu 7-A
- 
-
-################################################################################
-#
-# Pcd Section - list of all EDK II PCD Entries defined by this Platform
-#
-################################################################################
-
-  
-[PcdsFixedAtBuild.common]
-
-# DEBUG_ASSERT_ENABLED       0x01
-# DEBUG_PRINT_ENABLED        0x02
-# DEBUG_CODE_ENABLED         0x04
-# CLEAR_MEMORY_ENABLED       0x08
-# ASSERT_BREAKPOINT_ENABLED  0x10
-# ASSERT_DEADLOOP_ENABLED    0x20
-  gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask|0x2f
-
-#  DEBUG_INIT      0x00000001  // Initialization
-#  DEBUG_WARN      0x00000002  // Warnings
-#  DEBUG_LOAD      0x00000004  // Load events
-#  DEBUG_FS        0x00000008  // EFI File system
-#  DEBUG_POOL      0x00000010  // Alloc & Free's
-#  DEBUG_PAGE      0x00000020  // Alloc & Free's
-#  DEBUG_INFO      0x00000040  // Verbose
-#  DEBUG_DISPATCH  0x00000080  // PEI/DXE Dispatchers
-#  DEBUG_VARIABLE  0x00000100  // Variable
-#  DEBUG_BM        0x00000400  // Boot Manager
-#  DEBUG_BLKIO     0x00001000  // BlkIo Driver
-#  DEBUG_NET       0x00004000  // SNI Driver
-#  DEBUG_UNDI      0x00010000  // UNDI Driver
-#  DEBUG_LOADFILE  0x00020000  // UNDI Driver
-#  DEBUG_EVENT     0x00080000  // Event messages
-#  DEBUG_ERROR     0x80000000  // Error
-  gEfiMdePkgTokenSpaceGuid.PcdDebugPrintErrorLevel|0x80000004
-
-  gEfiMdePkgTokenSpaceGuid.PcdReportStatusCodePropertyMask|0x07
-  
-  gEmbeddedTokenSpaceGuid.PcdPrePiTempMemorySize|0
-  gEmbeddedTokenSpaceGuid.PcdPrePiBfvBaseAddress|0
-  gEmbeddedTokenSpaceGuid.PcdPrePiBfvSize|0
-  gEmbeddedTokenSpaceGuid.PcdFlashFvMainBase|0
-  gEmbeddedTokenSpaceGuid.PcdFlashFvMainSize|0
-  gEmbeddedTokenSpaceGuid.PcdPrePiHobBase|0x80001000
-  gEmbeddedTokenSpaceGuid.PcdPrePiStackBase|0x87FE0000 # stack at top of memory
-  gEmbeddedTokenSpaceGuid.PcdPrePiStackSize|0x20000  # 128K stack
-  gArmTokenSpaceGuid.PcdCpuVectorBaseAddress|0x80000000
-  gArmTokenSpaceGuid.PcdCpuResetAddress|0x80008000
-  
-  gOmap35xxTokenSpaceGuid.PcdOmap35xxGpmcOffset|0x6E000000
-  gOmap35xxTokenSpaceGuid.PcdOmap35xxMMCHS1Base|0x4809C000
-
-  # Console  
-  gOmap35xxTokenSpaceGuid.PcdOmap35xxConsoleUart|3
-  
-  # Timers
-  gOmap35xxTokenSpaceGuid.PcdOmap35xxArchTimer|3
-  gOmap35xxTokenSpaceGuid.PcdOmap35xxFreeTimer|4
-  gEmbeddedTokenSpaceGuid.PcdTimerPeriod|100000
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedPerformanceCounterPeriodInNanoseconds|77
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedPerformanceCounterFrequencyInHz|13000000
-  
-  #
-  # ARM Pcds
-  #
-  gArmTokenSpaceGuid.PcdArmUncachedMemoryMask|0x0000000040000000
-
-################################################################################
-#
-# Components Section - list of all EDK II Modules needed by this Platform
-#
-################################################################################
-[Components.common]
-  Omap35xxPkg/Library/Omap35xxTimerLib/Omap35xxTimerLib.inf  
-  Omap35xxPkg/Library/OmapLib/OmapLib.inf
-  Omap35xxPkg/Library/OmapDmaLib/OmapDmaLib.inf
-  
-  Omap35xxPkg/Flash/Flash.inf
-  Omap35xxPkg/MMCHSDxe/MMCHS.inf
-  Omap35xxPkg/SmbusDxe/Smbus.inf
-  Omap35xxPkg/Gpio/Gpio.inf
-  Omap35xxPkg/InterruptDxe/InterruptDxe.inf
-  Omap35xxPkg/TimerDxe/TimerDxe.inf 
-  Omap35xxPkg/TPS65950Dxe/TPS65950.inf
-  
-  
-
+#/** @file

+# Omap35xx SoC package.

+#

+# Copyright (c) 2009 - 2010, Apple Inc. All rights reserved.<BR>

+#

+#    This program and the accompanying materials

+#    are licensed and made available under the terms and conditions of the BSD License

+#    which accompanies this distribution. The full text of the license may be found at

+#    http://opensource.org/licenses/bsd-license.php

+#

+#    THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#    WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#**/

+

+################################################################################

+#

+# Defines Section - statements that will be processed to create a Makefile.

+#

+################################################################################

+[Defines]

+  PLATFORM_NAME                  = Omap35xxPkg

+  PLATFORM_GUID                  = D196A631-B7B7-4953-A3EE-0F773CBABF20

+  PLATFORM_VERSION               = 0.1

+  DSC_SPECIFICATION              = 0x00010005

+  OUTPUT_DIRECTORY               = Build/Omap35xxPkg

+  SUPPORTED_ARCHITECTURES        = ARM

+  BUILD_TARGETS                  = DEBUG|RELEASE

+  SKUID_IDENTIFIER               = DEFAULT

+  DEFINE TARGET_HACK             = DEBUG

+

+

+[LibraryClasses.common]

+  DebugLib|MdePkg/Library/BaseDebugLibNull/BaseDebugLibNull.inf

+

+  ArmLib|ArmPkg/Library/ArmLib/ArmV7/ArmV7Lib.inf

+  MemoryAllocationLib|MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf

+  

+  BaseLib|MdePkg/Library/BaseLib/BaseLib.inf

+  BaseMemoryLib|MdePkg/Library/BaseMemoryLib/BaseMemoryLib.inf

+

+  PrintLib|MdePkg/Library/BasePrintLib/BasePrintLib.inf

+  

+  CacheMaintenanceLib|ArmPkg/Library/ArmCacheMaintenanceLib/ArmCacheMaintenanceLib.inf

+  DefaultExceptioHandlerLib|ArmPkg/Library/DefaultExceptionHandlerLib/DefaultExceptionHandlerLib.inf

+  CpuExceptionHandlerLib|MdeModulePkg/Library/CpuExceptionHandlerLibNull/CpuExceptionHandlerLibNull.inf

+  PrePiLib|EmbeddedPkg/Library/PrePiLib/PrePiLib.inf

+  

+  RealTimeClockLib|EmbeddedPkg/Library/TemplateRealTimeClockLib/TemplateRealTimeClockLib.inf

+

+  IoLib|MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.inf

+  OmapLib|Omap35xxPkg/Library/OmapLib/OmapLib.inf

+  OmapDmaLib|Omap35xxPkg/Library/OmapDmaLib/OmapDmaLib.inf

+  

+  MemoryAllocationLib|MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf

+  UefiLib|MdePkg/Library/UefiLib/UefiLib.inf

+  UefiRuntimeServicesTableLib|MdePkg/Library/UefiRuntimeServicesTableLib/UefiRuntimeServicesTableLib.inf

+  DevicePathLib|MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.inf

+  UefiBootServicesTableLib|MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.inf

+

+  DxeServicesTableLib|MdePkg/Library/DxeServicesTableLib/DxeServicesTableLib.inf

+  UefiDriverEntryPoint|MdePkg/Library/UefiDriverEntryPoint/UefiDriverEntryPoint.inf

+  UefiApplicationEntryPoint|MdePkg/Library/UefiApplicationEntryPoint/UefiApplicationEntryPoint.inf

+  DmaLib|ArmPkg/Library/ArmDmaLib/ArmDmaLib.inf

+

+#

+# Assume everything is fixed at build

+#

+  PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf

+

+  UefiRuntimeLib|MdePkg/Library/UefiRuntimeLib/UefiRuntimeLib.inf

+    

+ # UncachedMemoryAllocationLib|ArmPkg/Library/UncachedMemoryAllocationLib/UncachedMemoryAllocationLib.inf

+  UncachedMemoryAllocationLib|ArmPkg/Library/DebugUncachedMemoryAllocationLib/DebugUncachedMemoryAllocationLib.inf

+

+  CpuLib|MdePkg/Library/BaseCpuLib/BaseCpuLib.inf

+

+

+[LibraryClasses.common.DXE_DRIVER]

+  DxeServicesLib|MdePkg/Library/DxeServicesLib/DxeServicesLib.inf

+

+

+[LibraryClasses.ARM]

+  #

+  # Note: This NULL library feature is not yet in the edk2/BaseTools, but it is checked in to 

+  # the BaseTools project. So you need to build with the BaseTools project util this feature gets synced.

+  #

+  NULL|ArmPkg/Library/CompilerIntrinsicsLib/CompilerIntrinsicsLib.inf

+

+

+[BuildOptions]

+  XCODE:*_*_ARM_ARCHCC_FLAGS     == -arch armv7 -march=armv7

+  XCODE:*_*_ARM_ARCHASM_FLAGS    == -arch armv7

+  XCODE:*_*_ARM_ARCHDLINK_FLAGS  == -arch armv7

+

+  GCC:*_*_ARM_ARCHCC_FLAGS     == -march=armv7-a -mthumb

+  GCC:*_*_ARM_ARCHASM_FLAGS    == -march=armv7-a

+

+  RVCT:*_*_ARM_ARCHCC_FLAGS     == --cpu 7-A

+  RVCT:*_*_ARM_ARCHASM_FLAGS    == --cpu 7-A

+ 

+

+################################################################################

+#

+# Pcd Section - list of all EDK II PCD Entries defined by this Platform

+#

+################################################################################

+

+  

+[PcdsFixedAtBuild.common]

+

+# DEBUG_ASSERT_ENABLED       0x01

+# DEBUG_PRINT_ENABLED        0x02

+# DEBUG_CODE_ENABLED         0x04

+# CLEAR_MEMORY_ENABLED       0x08

+# ASSERT_BREAKPOINT_ENABLED  0x10

+# ASSERT_DEADLOOP_ENABLED    0x20

+  gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask|0x2f

+

+#  DEBUG_INIT      0x00000001  // Initialization

+#  DEBUG_WARN      0x00000002  // Warnings

+#  DEBUG_LOAD      0x00000004  // Load events

+#  DEBUG_FS        0x00000008  // EFI File system

+#  DEBUG_POOL      0x00000010  // Alloc & Free's

+#  DEBUG_PAGE      0x00000020  // Alloc & Free's

+#  DEBUG_INFO      0x00000040  // Verbose

+#  DEBUG_DISPATCH  0x00000080  // PEI/DXE Dispatchers

+#  DEBUG_VARIABLE  0x00000100  // Variable

+#  DEBUG_BM        0x00000400  // Boot Manager

+#  DEBUG_BLKIO     0x00001000  // BlkIo Driver

+#  DEBUG_NET       0x00004000  // SNI Driver

+#  DEBUG_UNDI      0x00010000  // UNDI Driver

+#  DEBUG_LOADFILE  0x00020000  // UNDI Driver

+#  DEBUG_EVENT     0x00080000  // Event messages

+#  DEBUG_ERROR     0x80000000  // Error

+  gEfiMdePkgTokenSpaceGuid.PcdDebugPrintErrorLevel|0x80000004

+

+  gEfiMdePkgTokenSpaceGuid.PcdReportStatusCodePropertyMask|0x07

+  

+  gEmbeddedTokenSpaceGuid.PcdPrePiTempMemorySize|0

+  gEmbeddedTokenSpaceGuid.PcdPrePiBfvBaseAddress|0

+  gEmbeddedTokenSpaceGuid.PcdPrePiBfvSize|0

+  gEmbeddedTokenSpaceGuid.PcdFlashFvMainBase|0

+  gEmbeddedTokenSpaceGuid.PcdFlashFvMainSize|0

+  gEmbeddedTokenSpaceGuid.PcdPrePiHobBase|0x80001000

+  gEmbeddedTokenSpaceGuid.PcdPrePiStackBase|0x87FE0000 # stack at top of memory

+  gEmbeddedTokenSpaceGuid.PcdPrePiStackSize|0x20000  # 128K stack

+  gArmTokenSpaceGuid.PcdCpuVectorBaseAddress|0x80000000

+  gArmTokenSpaceGuid.PcdCpuResetAddress|0x80008000

+  

+  gOmap35xxTokenSpaceGuid.PcdOmap35xxGpmcOffset|0x6E000000

+  gOmap35xxTokenSpaceGuid.PcdOmap35xxMMCHS1Base|0x4809C000

+

+  # Console  

+  gOmap35xxTokenSpaceGuid.PcdOmap35xxConsoleUart|3

+  

+  # Timers

+  gOmap35xxTokenSpaceGuid.PcdOmap35xxArchTimer|3

+  gOmap35xxTokenSpaceGuid.PcdOmap35xxFreeTimer|4

+  gEmbeddedTokenSpaceGuid.PcdTimerPeriod|100000

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedPerformanceCounterPeriodInNanoseconds|77

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedPerformanceCounterFrequencyInHz|13000000

+  

+  #

+  # ARM Pcds

+  #

+  gArmTokenSpaceGuid.PcdArmUncachedMemoryMask|0x0000000040000000

+

+################################################################################

+#

+# Components Section - list of all EDK II Modules needed by this Platform

+#

+################################################################################

+[Components.common]

+  Omap35xxPkg/Library/Omap35xxTimerLib/Omap35xxTimerLib.inf  

+  Omap35xxPkg/Library/OmapLib/OmapLib.inf

+  Omap35xxPkg/Library/OmapDmaLib/OmapDmaLib.inf

+  

+  Omap35xxPkg/Flash/Flash.inf

+  Omap35xxPkg/MMCHSDxe/MMCHS.inf

+  Omap35xxPkg/SmbusDxe/Smbus.inf

+  Omap35xxPkg/Gpio/Gpio.inf

+  Omap35xxPkg/InterruptDxe/InterruptDxe.inf

+  Omap35xxPkg/TimerDxe/TimerDxe.inf 

+  Omap35xxPkg/TPS65950Dxe/TPS65950.inf

+  

+  

+

diff --git a/Omap35xxPkg/PciEmulation/PciEmulation.c b/Omap35xxPkg/PciEmulation/PciEmulation.c
index 6b5528ce..0cc0faa4 100644
--- a/Omap35xxPkg/PciEmulation/PciEmulation.c
+++ b/Omap35xxPkg/PciEmulation/PciEmulation.c
@@ -1,524 +1,524 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include "PciEmulation.h"
-
-EMBEDDED_EXTERNAL_DEVICE   *gTPS65950;
-
-#define HOST_CONTROLLER_OPERATION_REG_SIZE  0x44
-
-typedef struct {
-  ACPI_HID_DEVICE_PATH      AcpiDevicePath;
-  PCI_DEVICE_PATH           PciDevicePath;
-  EFI_DEVICE_PATH_PROTOCOL  EndDevicePath;
-} EFI_PCI_IO_DEVICE_PATH;
-
-typedef struct {
-  UINT32                  Signature;
-  EFI_PCI_IO_DEVICE_PATH  DevicePath;
-  EFI_PCI_IO_PROTOCOL     PciIoProtocol;
-  PCI_TYPE00              *ConfigSpace;
-  PCI_ROOT_BRIDGE         RootBridge;
-  UINTN                   Segment;
-} EFI_PCI_IO_PRIVATE_DATA;
-
-#define EFI_PCI_IO_PRIVATE_DATA_SIGNATURE     SIGNATURE_32('p', 'c', 'i', 'o')
-#define EFI_PCI_IO_PRIVATE_DATA_FROM_THIS(a)  CR(a, EFI_PCI_IO_PRIVATE_DATA, PciIoProtocol, EFI_PCI_IO_PRIVATE_DATA_SIGNATURE)
-
-EFI_PCI_IO_DEVICE_PATH PciIoDevicePathTemplate = 
-{
-  {
-    { ACPI_DEVICE_PATH, ACPI_DP, sizeof (ACPI_HID_DEVICE_PATH), 0},
-    EISA_PNP_ID(0x0A03),  // HID
-    0                     // UID
-  },
-  {
-    { HARDWARE_DEVICE_PATH, HW_PCI_DP, sizeof (PCI_DEVICE_PATH), 0},
-    0,
-    0
-  },
-  { END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE, sizeof (EFI_DEVICE_PATH_PROTOCOL), 0}
-};
-
-STATIC
-VOID
-ConfigureUSBHost (
-  VOID
-  )
-{
-  EFI_STATUS Status;
-  UINT8      Data = 0;
-
-  // Take USB host out of force-standby mode
-  MmioWrite32 (UHH_SYSCONFIG, UHH_SYSCONFIG_MIDLEMODE_NO_STANDBY
-                            | UHH_SYSCONFIG_CLOCKACTIVITY_ON
-                            | UHH_SYSCONFIG_SIDLEMODE_NO_STANDBY
-                            | UHH_SYSCONFIG_ENAWAKEUP_ENABLE
-                            | UHH_SYSCONFIG_AUTOIDLE_ALWAYS_RUN);
-  MmioWrite32 (UHH_HOSTCONFIG, UHH_HOSTCONFIG_P3_CONNECT_STATUS_DISCONNECT
-                             | UHH_HOSTCONFIG_P2_CONNECT_STATUS_DISCONNECT
-                             | UHH_HOSTCONFIG_P1_CONNECT_STATUS_DISCONNECT
-                             | UHH_HOSTCONFIG_ENA_INCR_ALIGN_DISABLE
-                             | UHH_HOSTCONFIG_ENA_INCR16_ENABLE
-                             | UHH_HOSTCONFIG_ENA_INCR8_ENABLE
-                             | UHH_HOSTCONFIG_ENA_INCR4_ENABLE
-                             | UHH_HOSTCONFIG_AUTOPPD_ON_OVERCUR_EN_ON
-                             | UHH_HOSTCONFIG_P1_ULPI_BYPASS_ULPI_MODE);
-
-  // USB reset (GPIO 147 - Port 5 pin 19) output high
-  MmioAnd32 (GPIO5_BASE + GPIO_OE, ~BIT19);
-  MmioWrite32 (GPIO5_BASE + GPIO_SETDATAOUT, BIT19);
-
-  // Get the Power IC protocol
-  Status = gBS->LocateProtocol (&gEmbeddedExternalDeviceProtocolGuid, NULL, (VOID **)&gTPS65950);
-  ASSERT_EFI_ERROR (Status);  
-
-  // Power the USB PHY
-  Data = VAUX_DEV_GRP_P1;
-  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VAUX2_DEV_GRP), 1, &Data);
-  ASSERT_EFI_ERROR(Status);
-
-  Data = VAUX_DEDICATED_18V;
-  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VAUX2_DEDICATED), 1, &Data);
-  ASSERT_EFI_ERROR (Status);  
-
-  // Enable power to the USB hub
-  Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID3, LEDEN), 1, &Data);
-  ASSERT_EFI_ERROR (Status);
-
-  // LEDAON controls the power to the USB host, PWM is disabled
-  Data &= ~LEDAPWM;
-  Data |= LEDAON;
-
-  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID3, LEDEN), 1, &Data);
-  ASSERT_EFI_ERROR (Status);
-}
-
-
-EFI_STATUS
-PciIoPollMem (
-  IN EFI_PCI_IO_PROTOCOL           *This,
-  IN  EFI_PCI_IO_PROTOCOL_WIDTH    Width,
-  IN  UINT8                        BarIndex,
-  IN  UINT64                       Offset,
-  IN  UINT64                       Mask,
-  IN  UINT64                       Value,
-  IN  UINT64                       Delay,
-  OUT UINT64                       *Result
-  )
-{
-  ASSERT (FALSE);
-  return EFI_UNSUPPORTED;
-}
-
-EFI_STATUS
-PciIoPollIo (
-  IN EFI_PCI_IO_PROTOCOL           *This,
-  IN  EFI_PCI_IO_PROTOCOL_WIDTH    Width,
-  IN  UINT8                        BarIndex,
-  IN  UINT64                       Offset,
-  IN  UINT64                       Mask,
-  IN  UINT64                       Value,
-  IN  UINT64                       Delay,
-  OUT UINT64                       *Result
-  )
-{
-  ASSERT (FALSE);
-  return EFI_UNSUPPORTED;
-}
-
-EFI_STATUS
-PciIoMemRead (
-  IN EFI_PCI_IO_PROTOCOL              *This,
-  IN     EFI_PCI_IO_PROTOCOL_WIDTH    Width,
-  IN     UINT8                        BarIndex,
-  IN     UINT64                       Offset,
-  IN     UINTN                        Count,
-  IN OUT VOID                         *Buffer
-  )
-{
-  EFI_PCI_IO_PRIVATE_DATA *Private = EFI_PCI_IO_PRIVATE_DATA_FROM_THIS(This);
-
-  return PciRootBridgeIoMemRead (&Private->RootBridge.Io, 
-                                (EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH) Width,
-                                Private->ConfigSpace->Device.Bar[BarIndex] + Offset,
-                                Count,
-                                Buffer
-                                );
-}
-
-EFI_STATUS
-PciIoMemWrite (
-  IN EFI_PCI_IO_PROTOCOL              *This,
-  IN     EFI_PCI_IO_PROTOCOL_WIDTH    Width,
-  IN     UINT8                        BarIndex,
-  IN     UINT64                       Offset,
-  IN     UINTN                        Count,
-  IN OUT VOID                         *Buffer
-  )
-{
-  EFI_PCI_IO_PRIVATE_DATA *Private = EFI_PCI_IO_PRIVATE_DATA_FROM_THIS(This);
-
-  return PciRootBridgeIoMemWrite (&Private->RootBridge.Io, 
-                                 (EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH) Width,
-                                 Private->ConfigSpace->Device.Bar[BarIndex] + Offset,
-                                 Count,
-                                 Buffer
-                                 );
-}
-
-EFI_STATUS
-PciIoIoRead (
-  IN EFI_PCI_IO_PROTOCOL              *This,
-  IN     EFI_PCI_IO_PROTOCOL_WIDTH    Width,
-  IN     UINT8                        BarIndex,
-  IN     UINT64                       Offset,
-  IN     UINTN                        Count,
-  IN OUT VOID                         *Buffer
-  )
-{
-  ASSERT (FALSE);
-  return EFI_UNSUPPORTED;
-}
-
-EFI_STATUS
-PciIoIoWrite (
-  IN EFI_PCI_IO_PROTOCOL              *This,
-  IN     EFI_PCI_IO_PROTOCOL_WIDTH    Width,
-  IN     UINT8                        BarIndex,
-  IN     UINT64                       Offset,
-  IN     UINTN                        Count,
-  IN OUT VOID                         *Buffer
-  )
-{
-  ASSERT (FALSE);
-  return EFI_UNSUPPORTED;
-}
-
-EFI_STATUS
-PciIoPciRead (
-  IN EFI_PCI_IO_PROTOCOL              *This,
-  IN     EFI_PCI_IO_PROTOCOL_WIDTH    Width,
-  IN     UINT32                       Offset,
-  IN     UINTN                        Count,
-  IN OUT VOID                         *Buffer
-  )
-{
-  EFI_PCI_IO_PRIVATE_DATA *Private = EFI_PCI_IO_PRIVATE_DATA_FROM_THIS(This);
-
-  return PciRootBridgeIoMemRW ((EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH)Width, 
-                               Count, 
-                               TRUE, 
-                               (PTR)(UINTN)Buffer, 
-                               TRUE, 
-                               (PTR)(UINTN)(((UINT8 *)Private->ConfigSpace) + Offset)
-                              );
-}
-
-EFI_STATUS
-PciIoPciWrite (
-  IN EFI_PCI_IO_PROTOCOL              *This,
-  IN     EFI_PCI_IO_PROTOCOL_WIDTH    Width,
-  IN     UINT32                       Offset,
-  IN     UINTN                        Count,
-  IN OUT VOID                         *Buffer
-  )
-{
-  EFI_PCI_IO_PRIVATE_DATA *Private = EFI_PCI_IO_PRIVATE_DATA_FROM_THIS(This);
-
-  return PciRootBridgeIoMemRW ((EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH) Width, 
-                               Count, 
-                               TRUE, 
-                               (PTR)(UINTN)(((UINT8 *)Private->ConfigSpace) + Offset), 
-                               TRUE, 
-                               (PTR)(UINTN)Buffer
-                               );
-}
-
-EFI_STATUS
-PciIoCopyMem (
-  IN EFI_PCI_IO_PROTOCOL              *This,
-  IN     EFI_PCI_IO_PROTOCOL_WIDTH    Width,
-  IN     UINT8                        DestBarIndex,
-  IN     UINT64                       DestOffset,
-  IN     UINT8                        SrcBarIndex,
-  IN     UINT64                       SrcOffset,
-  IN     UINTN                        Count
-  )
-{
-  ASSERT (FALSE);
-  return EFI_UNSUPPORTED;
-}
-
-EFI_STATUS
-PciIoMap (
-  IN EFI_PCI_IO_PROTOCOL                *This,
-  IN     EFI_PCI_IO_PROTOCOL_OPERATION  Operation,
-  IN     VOID                           *HostAddress,
-  IN OUT UINTN                          *NumberOfBytes,
-  OUT    EFI_PHYSICAL_ADDRESS           *DeviceAddress,
-  OUT    VOID                           **Mapping
-  )
-{
-  DMA_MAP_OPERATION   DmaOperation;
-
-  if (Operation == EfiPciIoOperationBusMasterRead) {
-    DmaOperation = MapOperationBusMasterRead;
-  } else if (Operation == EfiPciIoOperationBusMasterWrite) {
-    DmaOperation = MapOperationBusMasterWrite;
-  } else if (Operation == EfiPciIoOperationBusMasterCommonBuffer) {
-    DmaOperation = MapOperationBusMasterCommonBuffer;
-  } else {
-    return EFI_INVALID_PARAMETER;
-  }
-  return DmaMap (DmaOperation, HostAddress, NumberOfBytes, DeviceAddress, Mapping);
-}
-
-EFI_STATUS
-PciIoUnmap (
-  IN EFI_PCI_IO_PROTOCOL           *This,
-  IN  VOID                         *Mapping
-  )
-{
-  return DmaUnmap (Mapping);
-}
-
-EFI_STATUS
-PciIoAllocateBuffer (
-  IN EFI_PCI_IO_PROTOCOL           *This,
-  IN  EFI_ALLOCATE_TYPE            Type,
-  IN  EFI_MEMORY_TYPE              MemoryType,
-  IN  UINTN                        Pages,
-  OUT VOID                         **HostAddress,
-  IN  UINT64                       Attributes
-  )
-{
-  if (Attributes & EFI_PCI_ATTRIBUTE_INVALID_FOR_ALLOCATE_BUFFER) {
-    // Check this
-    return EFI_UNSUPPORTED;
-  }
-
-  return DmaAllocateBuffer (MemoryType, Pages, HostAddress);
-}
-
-
-EFI_STATUS
-PciIoFreeBuffer (
-  IN EFI_PCI_IO_PROTOCOL           *This,
-  IN  UINTN                        Pages,
-  IN  VOID                         *HostAddress
-  )
-{
-  return DmaFreeBuffer (Pages, HostAddress);
-}
-
-
-EFI_STATUS
-PciIoFlush (
-  IN EFI_PCI_IO_PROTOCOL  *This
-  )
-{
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-PciIoGetLocation (
-  IN EFI_PCI_IO_PROTOCOL          *This,
-  OUT UINTN                       *SegmentNumber,
-  OUT UINTN                       *BusNumber,
-  OUT UINTN                       *DeviceNumber,
-  OUT UINTN                       *FunctionNumber
-  )
-{
-  EFI_PCI_IO_PRIVATE_DATA *Private = EFI_PCI_IO_PRIVATE_DATA_FROM_THIS(This);
-
-  if (SegmentNumber != NULL) {
-    *SegmentNumber = Private->Segment;
-  }
-
-  if (BusNumber != NULL) {
-    *BusNumber = 0xff;
-  }
-
-  if (DeviceNumber != NULL) {
-    *DeviceNumber = 0;
-  }
-
-  if (FunctionNumber != NULL) {
-    *FunctionNumber = 0;
-  }
-
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-PciIoAttributes (
-  IN EFI_PCI_IO_PROTOCOL                       *This,
-  IN  EFI_PCI_IO_PROTOCOL_ATTRIBUTE_OPERATION  Operation,
-  IN  UINT64                                   Attributes,
-  OUT UINT64                                   *Result OPTIONAL
-  )
-{
-  switch (Operation) {
-  case EfiPciIoAttributeOperationGet:
-  case EfiPciIoAttributeOperationSupported:
-    if (Result == NULL) {
-      return EFI_INVALID_PARAMETER;
-    }
-    // We are not a real PCI device so just say things we kind of do
-    *Result = EFI_PCI_IO_ATTRIBUTE_MEMORY | EFI_PCI_IO_ATTRIBUTE_BUS_MASTER | EFI_PCI_DEVICE_ENABLE;
-    break;
-
-  case EfiPciIoAttributeOperationSet:
-  case EfiPciIoAttributeOperationEnable:
-  case EfiPciIoAttributeOperationDisable:
-    // Since we are not a real PCI device no enable/set or disable operations exist.
-    return EFI_SUCCESS;
-    
-  default:
-  ASSERT (FALSE);
-    return EFI_INVALID_PARAMETER;
-  };
-  return EFI_SUCCESS;
-}
-
-EFI_STATUS
-PciIoGetBarAttributes (
-  IN EFI_PCI_IO_PROTOCOL             *This,
-  IN  UINT8                          BarIndex,
-  OUT UINT64                         *Supports, OPTIONAL
-  OUT VOID                           **Resources OPTIONAL
-  )
-{
-  ASSERT (FALSE);
-  return EFI_UNSUPPORTED;
-}
-
-EFI_STATUS
-PciIoSetBarAttributes (
-  IN EFI_PCI_IO_PROTOCOL              *This,
-  IN     UINT64                       Attributes,
-  IN     UINT8                        BarIndex,
-  IN OUT UINT64                       *Offset,
-  IN OUT UINT64                       *Length
-  )
-{
-  ASSERT (FALSE);
-  return EFI_UNSUPPORTED;
-}
-
-EFI_PCI_IO_PROTOCOL PciIoTemplate = 
-{
-  PciIoPollMem,
-  PciIoPollIo,
-  PciIoMemRead,
-  PciIoMemWrite,
-  PciIoIoRead,
-  PciIoIoWrite,
-  PciIoPciRead,
-  PciIoPciWrite,
-  PciIoCopyMem,
-  PciIoMap,
-  PciIoUnmap,
-  PciIoAllocateBuffer,
-  PciIoFreeBuffer,
-  PciIoFlush,
-  PciIoGetLocation,
-  PciIoAttributes,
-  PciIoGetBarAttributes,
-  PciIoSetBarAttributes,
-  0,
-  0
-};
-
-EFI_STATUS
-EFIAPI
-PciEmulationEntryPoint (
-  IN EFI_HANDLE       ImageHandle,
-  IN EFI_SYSTEM_TABLE *SystemTable
-  )
-{
-  EFI_STATUS              Status;
-  EFI_HANDLE              Handle;
-  EFI_PCI_IO_PRIVATE_DATA *Private;
-  UINT8                   CapabilityLength;
-  UINT8                   PhysicalPorts;
-  UINTN                   Count;
-
-
-  //Configure USB host for OMAP3530.
-  ConfigureUSBHost();
-
-  // Create a private structure
-  Private = AllocatePool(sizeof(EFI_PCI_IO_PRIVATE_DATA));
-  if (Private == NULL) {
-    Status = EFI_OUT_OF_RESOURCES;
-    return Status;
-  }
-  
-  Private->Signature              = EFI_PCI_IO_PRIVATE_DATA_SIGNATURE;  // Fill in signature
-  Private->RootBridge.Signature   = PCI_ROOT_BRIDGE_SIGNATURE;          // Fake Root Bridge structure needs a signature too
-  Private->RootBridge.MemoryStart = USB_EHCI_HCCAPBASE;                 // Get the USB capability register base
-  Private->Segment                = 0;                                  // Default to segment zero
-
-  // Find out the capability register length and number of physical ports.
-  CapabilityLength = MmioRead8(Private->RootBridge.MemoryStart);
-  PhysicalPorts    = (MmioRead32 (Private->RootBridge.MemoryStart + 0x4)) & 0x0000000F;
-
-  // Calculate the total size of the USB registers.
-  Private->RootBridge.MemorySize = CapabilityLength + (HOST_CONTROLLER_OPERATION_REG_SIZE + ((4 * PhysicalPorts) - 1));
-
-  // Enable Port Power bit in Port status and control registers in EHCI register space.
-  // Port Power Control (PPC) bit in the HCSPARAMS register is already set which indicates
-  // host controller implementation includes port power control.
-  for (Count = 0; Count < PhysicalPorts; Count++) {
-    MmioOr32 ((Private->RootBridge.MemoryStart + CapabilityLength + HOST_CONTROLLER_OPERATION_REG_SIZE + 4*Count), 0x00001000);
-  }
-
-  // Create fake PCI config space.
-  Private->ConfigSpace = AllocateZeroPool(sizeof(PCI_TYPE00));
-  if (Private->ConfigSpace == NULL) {
-    Status = EFI_OUT_OF_RESOURCES;
-    FreePool(Private);
-    return Status;
-  }
-
-  // Configure PCI config space
-  Private->ConfigSpace->Hdr.VendorId = 0x3530;
-  Private->ConfigSpace->Hdr.DeviceId = 0x3530;
-  Private->ConfigSpace->Hdr.ClassCode[0] = 0x20;
-  Private->ConfigSpace->Hdr.ClassCode[1] = 0x03;
-  Private->ConfigSpace->Hdr.ClassCode[2] = 0x0C;
-  Private->ConfigSpace->Device.Bar[0] = Private->RootBridge.MemoryStart;
-
-  Handle = NULL;
-
-  // Unique device path.
-  CopyMem(&Private->DevicePath, &PciIoDevicePathTemplate, sizeof(PciIoDevicePathTemplate));
-  Private->DevicePath.AcpiDevicePath.UID = 0;
-  
-  // Copy protocol structure
-  CopyMem(&Private->PciIoProtocol, &PciIoTemplate, sizeof(PciIoTemplate));
-
-  Status = gBS->InstallMultipleProtocolInterfaces(&Handle,
-                                                  &gEfiPciIoProtocolGuid,       &Private->PciIoProtocol,
-                                                  &gEfiDevicePathProtocolGuid,  &Private->DevicePath,
-                                                  NULL);
-  if (EFI_ERROR(Status)) {
-    DEBUG((EFI_D_ERROR, "PciEmulationEntryPoint InstallMultipleProtocolInterfaces() failed.\n"));
-  }
-
-  return Status;
-}
-
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include "PciEmulation.h"

+

+EMBEDDED_EXTERNAL_DEVICE   *gTPS65950;

+

+#define HOST_CONTROLLER_OPERATION_REG_SIZE  0x44

+

+typedef struct {

+  ACPI_HID_DEVICE_PATH      AcpiDevicePath;

+  PCI_DEVICE_PATH           PciDevicePath;

+  EFI_DEVICE_PATH_PROTOCOL  EndDevicePath;

+} EFI_PCI_IO_DEVICE_PATH;

+

+typedef struct {

+  UINT32                  Signature;

+  EFI_PCI_IO_DEVICE_PATH  DevicePath;

+  EFI_PCI_IO_PROTOCOL     PciIoProtocol;

+  PCI_TYPE00              *ConfigSpace;

+  PCI_ROOT_BRIDGE         RootBridge;

+  UINTN                   Segment;

+} EFI_PCI_IO_PRIVATE_DATA;

+

+#define EFI_PCI_IO_PRIVATE_DATA_SIGNATURE     SIGNATURE_32('p', 'c', 'i', 'o')

+#define EFI_PCI_IO_PRIVATE_DATA_FROM_THIS(a)  CR(a, EFI_PCI_IO_PRIVATE_DATA, PciIoProtocol, EFI_PCI_IO_PRIVATE_DATA_SIGNATURE)

+

+EFI_PCI_IO_DEVICE_PATH PciIoDevicePathTemplate = 

+{

+  {

+    { ACPI_DEVICE_PATH, ACPI_DP, sizeof (ACPI_HID_DEVICE_PATH), 0},

+    EISA_PNP_ID(0x0A03),  // HID

+    0                     // UID

+  },

+  {

+    { HARDWARE_DEVICE_PATH, HW_PCI_DP, sizeof (PCI_DEVICE_PATH), 0},

+    0,

+    0

+  },

+  { END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE, sizeof (EFI_DEVICE_PATH_PROTOCOL), 0}

+};

+

+STATIC

+VOID

+ConfigureUSBHost (

+  VOID

+  )

+{

+  EFI_STATUS Status;

+  UINT8      Data = 0;

+

+  // Take USB host out of force-standby mode

+  MmioWrite32 (UHH_SYSCONFIG, UHH_SYSCONFIG_MIDLEMODE_NO_STANDBY

+                            | UHH_SYSCONFIG_CLOCKACTIVITY_ON

+                            | UHH_SYSCONFIG_SIDLEMODE_NO_STANDBY

+                            | UHH_SYSCONFIG_ENAWAKEUP_ENABLE

+                            | UHH_SYSCONFIG_AUTOIDLE_ALWAYS_RUN);

+  MmioWrite32 (UHH_HOSTCONFIG, UHH_HOSTCONFIG_P3_CONNECT_STATUS_DISCONNECT

+                             | UHH_HOSTCONFIG_P2_CONNECT_STATUS_DISCONNECT

+                             | UHH_HOSTCONFIG_P1_CONNECT_STATUS_DISCONNECT

+                             | UHH_HOSTCONFIG_ENA_INCR_ALIGN_DISABLE

+                             | UHH_HOSTCONFIG_ENA_INCR16_ENABLE

+                             | UHH_HOSTCONFIG_ENA_INCR8_ENABLE

+                             | UHH_HOSTCONFIG_ENA_INCR4_ENABLE

+                             | UHH_HOSTCONFIG_AUTOPPD_ON_OVERCUR_EN_ON

+                             | UHH_HOSTCONFIG_P1_ULPI_BYPASS_ULPI_MODE);

+

+  // USB reset (GPIO 147 - Port 5 pin 19) output high

+  MmioAnd32 (GPIO5_BASE + GPIO_OE, ~BIT19);

+  MmioWrite32 (GPIO5_BASE + GPIO_SETDATAOUT, BIT19);

+

+  // Get the Power IC protocol

+  Status = gBS->LocateProtocol (&gEmbeddedExternalDeviceProtocolGuid, NULL, (VOID **)&gTPS65950);

+  ASSERT_EFI_ERROR (Status);  

+

+  // Power the USB PHY

+  Data = VAUX_DEV_GRP_P1;

+  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VAUX2_DEV_GRP), 1, &Data);

+  ASSERT_EFI_ERROR(Status);

+

+  Data = VAUX_DEDICATED_18V;

+  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VAUX2_DEDICATED), 1, &Data);

+  ASSERT_EFI_ERROR (Status);  

+

+  // Enable power to the USB hub

+  Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID3, LEDEN), 1, &Data);

+  ASSERT_EFI_ERROR (Status);

+

+  // LEDAON controls the power to the USB host, PWM is disabled

+  Data &= ~LEDAPWM;

+  Data |= LEDAON;

+

+  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID3, LEDEN), 1, &Data);

+  ASSERT_EFI_ERROR (Status);

+}

+

+

+EFI_STATUS

+PciIoPollMem (

+  IN EFI_PCI_IO_PROTOCOL           *This,

+  IN  EFI_PCI_IO_PROTOCOL_WIDTH    Width,

+  IN  UINT8                        BarIndex,

+  IN  UINT64                       Offset,

+  IN  UINT64                       Mask,

+  IN  UINT64                       Value,

+  IN  UINT64                       Delay,

+  OUT UINT64                       *Result

+  )

+{

+  ASSERT (FALSE);

+  return EFI_UNSUPPORTED;

+}

+

+EFI_STATUS

+PciIoPollIo (

+  IN EFI_PCI_IO_PROTOCOL           *This,

+  IN  EFI_PCI_IO_PROTOCOL_WIDTH    Width,

+  IN  UINT8                        BarIndex,

+  IN  UINT64                       Offset,

+  IN  UINT64                       Mask,

+  IN  UINT64                       Value,

+  IN  UINT64                       Delay,

+  OUT UINT64                       *Result

+  )

+{

+  ASSERT (FALSE);

+  return EFI_UNSUPPORTED;

+}

+

+EFI_STATUS

+PciIoMemRead (

+  IN EFI_PCI_IO_PROTOCOL              *This,

+  IN     EFI_PCI_IO_PROTOCOL_WIDTH    Width,

+  IN     UINT8                        BarIndex,

+  IN     UINT64                       Offset,

+  IN     UINTN                        Count,

+  IN OUT VOID                         *Buffer

+  )

+{

+  EFI_PCI_IO_PRIVATE_DATA *Private = EFI_PCI_IO_PRIVATE_DATA_FROM_THIS(This);

+

+  return PciRootBridgeIoMemRead (&Private->RootBridge.Io, 

+                                (EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH) Width,

+                                Private->ConfigSpace->Device.Bar[BarIndex] + Offset,

+                                Count,

+                                Buffer

+                                );

+}

+

+EFI_STATUS

+PciIoMemWrite (

+  IN EFI_PCI_IO_PROTOCOL              *This,

+  IN     EFI_PCI_IO_PROTOCOL_WIDTH    Width,

+  IN     UINT8                        BarIndex,

+  IN     UINT64                       Offset,

+  IN     UINTN                        Count,

+  IN OUT VOID                         *Buffer

+  )

+{

+  EFI_PCI_IO_PRIVATE_DATA *Private = EFI_PCI_IO_PRIVATE_DATA_FROM_THIS(This);

+

+  return PciRootBridgeIoMemWrite (&Private->RootBridge.Io, 

+                                 (EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH) Width,

+                                 Private->ConfigSpace->Device.Bar[BarIndex] + Offset,

+                                 Count,

+                                 Buffer

+                                 );

+}

+

+EFI_STATUS

+PciIoIoRead (

+  IN EFI_PCI_IO_PROTOCOL              *This,

+  IN     EFI_PCI_IO_PROTOCOL_WIDTH    Width,

+  IN     UINT8                        BarIndex,

+  IN     UINT64                       Offset,

+  IN     UINTN                        Count,

+  IN OUT VOID                         *Buffer

+  )

+{

+  ASSERT (FALSE);

+  return EFI_UNSUPPORTED;

+}

+

+EFI_STATUS

+PciIoIoWrite (

+  IN EFI_PCI_IO_PROTOCOL              *This,

+  IN     EFI_PCI_IO_PROTOCOL_WIDTH    Width,

+  IN     UINT8                        BarIndex,

+  IN     UINT64                       Offset,

+  IN     UINTN                        Count,

+  IN OUT VOID                         *Buffer

+  )

+{

+  ASSERT (FALSE);

+  return EFI_UNSUPPORTED;

+}

+

+EFI_STATUS

+PciIoPciRead (

+  IN EFI_PCI_IO_PROTOCOL              *This,

+  IN     EFI_PCI_IO_PROTOCOL_WIDTH    Width,

+  IN     UINT32                       Offset,

+  IN     UINTN                        Count,

+  IN OUT VOID                         *Buffer

+  )

+{

+  EFI_PCI_IO_PRIVATE_DATA *Private = EFI_PCI_IO_PRIVATE_DATA_FROM_THIS(This);

+

+  return PciRootBridgeIoMemRW ((EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH)Width, 

+                               Count, 

+                               TRUE, 

+                               (PTR)(UINTN)Buffer, 

+                               TRUE, 

+                               (PTR)(UINTN)(((UINT8 *)Private->ConfigSpace) + Offset)

+                              );

+}

+

+EFI_STATUS

+PciIoPciWrite (

+  IN EFI_PCI_IO_PROTOCOL              *This,

+  IN     EFI_PCI_IO_PROTOCOL_WIDTH    Width,

+  IN     UINT32                       Offset,

+  IN     UINTN                        Count,

+  IN OUT VOID                         *Buffer

+  )

+{

+  EFI_PCI_IO_PRIVATE_DATA *Private = EFI_PCI_IO_PRIVATE_DATA_FROM_THIS(This);

+

+  return PciRootBridgeIoMemRW ((EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH) Width, 

+                               Count, 

+                               TRUE, 

+                               (PTR)(UINTN)(((UINT8 *)Private->ConfigSpace) + Offset), 

+                               TRUE, 

+                               (PTR)(UINTN)Buffer

+                               );

+}

+

+EFI_STATUS

+PciIoCopyMem (

+  IN EFI_PCI_IO_PROTOCOL              *This,

+  IN     EFI_PCI_IO_PROTOCOL_WIDTH    Width,

+  IN     UINT8                        DestBarIndex,

+  IN     UINT64                       DestOffset,

+  IN     UINT8                        SrcBarIndex,

+  IN     UINT64                       SrcOffset,

+  IN     UINTN                        Count

+  )

+{

+  ASSERT (FALSE);

+  return EFI_UNSUPPORTED;

+}

+

+EFI_STATUS

+PciIoMap (

+  IN EFI_PCI_IO_PROTOCOL                *This,

+  IN     EFI_PCI_IO_PROTOCOL_OPERATION  Operation,

+  IN     VOID                           *HostAddress,

+  IN OUT UINTN                          *NumberOfBytes,

+  OUT    EFI_PHYSICAL_ADDRESS           *DeviceAddress,

+  OUT    VOID                           **Mapping

+  )

+{

+  DMA_MAP_OPERATION   DmaOperation;

+

+  if (Operation == EfiPciIoOperationBusMasterRead) {

+    DmaOperation = MapOperationBusMasterRead;

+  } else if (Operation == EfiPciIoOperationBusMasterWrite) {

+    DmaOperation = MapOperationBusMasterWrite;

+  } else if (Operation == EfiPciIoOperationBusMasterCommonBuffer) {

+    DmaOperation = MapOperationBusMasterCommonBuffer;

+  } else {

+    return EFI_INVALID_PARAMETER;

+  }

+  return DmaMap (DmaOperation, HostAddress, NumberOfBytes, DeviceAddress, Mapping);

+}

+

+EFI_STATUS

+PciIoUnmap (

+  IN EFI_PCI_IO_PROTOCOL           *This,

+  IN  VOID                         *Mapping

+  )

+{

+  return DmaUnmap (Mapping);

+}

+

+EFI_STATUS

+PciIoAllocateBuffer (

+  IN EFI_PCI_IO_PROTOCOL           *This,

+  IN  EFI_ALLOCATE_TYPE            Type,

+  IN  EFI_MEMORY_TYPE              MemoryType,

+  IN  UINTN                        Pages,

+  OUT VOID                         **HostAddress,

+  IN  UINT64                       Attributes

+  )

+{

+  if (Attributes & EFI_PCI_ATTRIBUTE_INVALID_FOR_ALLOCATE_BUFFER) {

+    // Check this

+    return EFI_UNSUPPORTED;

+  }

+

+  return DmaAllocateBuffer (MemoryType, Pages, HostAddress);

+}

+

+

+EFI_STATUS

+PciIoFreeBuffer (

+  IN EFI_PCI_IO_PROTOCOL           *This,

+  IN  UINTN                        Pages,

+  IN  VOID                         *HostAddress

+  )

+{

+  return DmaFreeBuffer (Pages, HostAddress);

+}

+

+

+EFI_STATUS

+PciIoFlush (

+  IN EFI_PCI_IO_PROTOCOL  *This

+  )

+{

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+PciIoGetLocation (

+  IN EFI_PCI_IO_PROTOCOL          *This,

+  OUT UINTN                       *SegmentNumber,

+  OUT UINTN                       *BusNumber,

+  OUT UINTN                       *DeviceNumber,

+  OUT UINTN                       *FunctionNumber

+  )

+{

+  EFI_PCI_IO_PRIVATE_DATA *Private = EFI_PCI_IO_PRIVATE_DATA_FROM_THIS(This);

+

+  if (SegmentNumber != NULL) {

+    *SegmentNumber = Private->Segment;

+  }

+

+  if (BusNumber != NULL) {

+    *BusNumber = 0xff;

+  }

+

+  if (DeviceNumber != NULL) {

+    *DeviceNumber = 0;

+  }

+

+  if (FunctionNumber != NULL) {

+    *FunctionNumber = 0;

+  }

+

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+PciIoAttributes (

+  IN EFI_PCI_IO_PROTOCOL                       *This,

+  IN  EFI_PCI_IO_PROTOCOL_ATTRIBUTE_OPERATION  Operation,

+  IN  UINT64                                   Attributes,

+  OUT UINT64                                   *Result OPTIONAL

+  )

+{

+  switch (Operation) {

+  case EfiPciIoAttributeOperationGet:

+  case EfiPciIoAttributeOperationSupported:

+    if (Result == NULL) {

+      return EFI_INVALID_PARAMETER;

+    }

+    // We are not a real PCI device so just say things we kind of do

+    *Result = EFI_PCI_IO_ATTRIBUTE_MEMORY | EFI_PCI_IO_ATTRIBUTE_BUS_MASTER | EFI_PCI_DEVICE_ENABLE;

+    break;

+

+  case EfiPciIoAttributeOperationSet:

+  case EfiPciIoAttributeOperationEnable:

+  case EfiPciIoAttributeOperationDisable:

+    // Since we are not a real PCI device no enable/set or disable operations exist.

+    return EFI_SUCCESS;

+    

+  default:

+  ASSERT (FALSE);

+    return EFI_INVALID_PARAMETER;

+  };

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+PciIoGetBarAttributes (

+  IN EFI_PCI_IO_PROTOCOL             *This,

+  IN  UINT8                          BarIndex,

+  OUT UINT64                         *Supports, OPTIONAL

+  OUT VOID                           **Resources OPTIONAL

+  )

+{

+  ASSERT (FALSE);

+  return EFI_UNSUPPORTED;

+}

+

+EFI_STATUS

+PciIoSetBarAttributes (

+  IN EFI_PCI_IO_PROTOCOL              *This,

+  IN     UINT64                       Attributes,

+  IN     UINT8                        BarIndex,

+  IN OUT UINT64                       *Offset,

+  IN OUT UINT64                       *Length

+  )

+{

+  ASSERT (FALSE);

+  return EFI_UNSUPPORTED;

+}

+

+EFI_PCI_IO_PROTOCOL PciIoTemplate = 

+{

+  PciIoPollMem,

+  PciIoPollIo,

+  PciIoMemRead,

+  PciIoMemWrite,

+  PciIoIoRead,

+  PciIoIoWrite,

+  PciIoPciRead,

+  PciIoPciWrite,

+  PciIoCopyMem,

+  PciIoMap,

+  PciIoUnmap,

+  PciIoAllocateBuffer,

+  PciIoFreeBuffer,

+  PciIoFlush,

+  PciIoGetLocation,

+  PciIoAttributes,

+  PciIoGetBarAttributes,

+  PciIoSetBarAttributes,

+  0,

+  0

+};

+

+EFI_STATUS

+EFIAPI

+PciEmulationEntryPoint (

+  IN EFI_HANDLE       ImageHandle,

+  IN EFI_SYSTEM_TABLE *SystemTable

+  )

+{

+  EFI_STATUS              Status;

+  EFI_HANDLE              Handle;

+  EFI_PCI_IO_PRIVATE_DATA *Private;

+  UINT8                   CapabilityLength;

+  UINT8                   PhysicalPorts;

+  UINTN                   Count;

+

+

+  //Configure USB host for OMAP3530.

+  ConfigureUSBHost();

+

+  // Create a private structure

+  Private = AllocatePool(sizeof(EFI_PCI_IO_PRIVATE_DATA));

+  if (Private == NULL) {

+    Status = EFI_OUT_OF_RESOURCES;

+    return Status;

+  }

+  

+  Private->Signature              = EFI_PCI_IO_PRIVATE_DATA_SIGNATURE;  // Fill in signature

+  Private->RootBridge.Signature   = PCI_ROOT_BRIDGE_SIGNATURE;          // Fake Root Bridge structure needs a signature too

+  Private->RootBridge.MemoryStart = USB_EHCI_HCCAPBASE;                 // Get the USB capability register base

+  Private->Segment                = 0;                                  // Default to segment zero

+

+  // Find out the capability register length and number of physical ports.

+  CapabilityLength = MmioRead8(Private->RootBridge.MemoryStart);

+  PhysicalPorts    = (MmioRead32 (Private->RootBridge.MemoryStart + 0x4)) & 0x0000000F;

+

+  // Calculate the total size of the USB registers.

+  Private->RootBridge.MemorySize = CapabilityLength + (HOST_CONTROLLER_OPERATION_REG_SIZE + ((4 * PhysicalPorts) - 1));

+

+  // Enable Port Power bit in Port status and control registers in EHCI register space.

+  // Port Power Control (PPC) bit in the HCSPARAMS register is already set which indicates

+  // host controller implementation includes port power control.

+  for (Count = 0; Count < PhysicalPorts; Count++) {

+    MmioOr32 ((Private->RootBridge.MemoryStart + CapabilityLength + HOST_CONTROLLER_OPERATION_REG_SIZE + 4*Count), 0x00001000);

+  }

+

+  // Create fake PCI config space.

+  Private->ConfigSpace = AllocateZeroPool(sizeof(PCI_TYPE00));

+  if (Private->ConfigSpace == NULL) {

+    Status = EFI_OUT_OF_RESOURCES;

+    FreePool(Private);

+    return Status;

+  }

+

+  // Configure PCI config space

+  Private->ConfigSpace->Hdr.VendorId = 0x3530;

+  Private->ConfigSpace->Hdr.DeviceId = 0x3530;

+  Private->ConfigSpace->Hdr.ClassCode[0] = 0x20;

+  Private->ConfigSpace->Hdr.ClassCode[1] = 0x03;

+  Private->ConfigSpace->Hdr.ClassCode[2] = 0x0C;

+  Private->ConfigSpace->Device.Bar[0] = Private->RootBridge.MemoryStart;

+

+  Handle = NULL;

+

+  // Unique device path.

+  CopyMem(&Private->DevicePath, &PciIoDevicePathTemplate, sizeof(PciIoDevicePathTemplate));

+  Private->DevicePath.AcpiDevicePath.UID = 0;

+  

+  // Copy protocol structure

+  CopyMem(&Private->PciIoProtocol, &PciIoTemplate, sizeof(PciIoTemplate));

+

+  Status = gBS->InstallMultipleProtocolInterfaces(&Handle,

+                                                  &gEfiPciIoProtocolGuid,       &Private->PciIoProtocol,

+                                                  &gEfiDevicePathProtocolGuid,  &Private->DevicePath,

+                                                  NULL);

+  if (EFI_ERROR(Status)) {

+    DEBUG((EFI_D_ERROR, "PciEmulationEntryPoint InstallMultipleProtocolInterfaces() failed.\n"));

+  }

+

+  return Status;

+}

+

diff --git a/Omap35xxPkg/PciEmulation/PciEmulation.h b/Omap35xxPkg/PciEmulation/PciEmulation.h
index 7db4f330..2a381f2f 100644
--- a/Omap35xxPkg/PciEmulation/PciEmulation.h
+++ b/Omap35xxPkg/PciEmulation/PciEmulation.h
@@ -40,7 +40,7 @@
 #include <IndustryStandard/Pci22.h>

 #include <IndustryStandard/Acpi.h>

 

-#include <Omap3530/Omap3530.h>
+#include <Omap3530/Omap3530.h>

 

 

 

diff --git a/Omap35xxPkg/PciEmulation/PciEmulation.inf b/Omap35xxPkg/PciEmulation/PciEmulation.inf
index 8567b693..ab375417 100644
--- a/Omap35xxPkg/PciEmulation/PciEmulation.inf
+++ b/Omap35xxPkg/PciEmulation/PciEmulation.inf
@@ -54,4 +54,4 @@
 [Depex]

   gEfiMetronomeArchProtocolGuid AND 

   gEmbeddedExternalDeviceProtocolGuid

-  
\ No newline at end of file
+  
\ No newline at end of file
diff --git a/Omap35xxPkg/SmbusDxe/Smbus.c b/Omap35xxPkg/SmbusDxe/Smbus.c
index 86dc65c8..3b88974a 100644
--- a/Omap35xxPkg/SmbusDxe/Smbus.c
+++ b/Omap35xxPkg/SmbusDxe/Smbus.c
@@ -1,325 +1,325 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include <Uefi.h>
-#include <Omap3530/Omap3530.h>
-
-#include <Library/DebugLib.h>
-#include <Library/IoLib.h>
-#include <Library/UefiBootServicesTableLib.h>
-
-#include <Protocol/SmbusHc.h>
-
-#define MAX_RETRY  1000
-
-//
-// Internal Functions
-//
-STATIC
-EFI_STATUS
-WaitForBusBusy (
-  VOID
-  )
-{
-  UINTN Retry = 0;
-
-  while (++Retry < MAX_RETRY && (MmioRead16(I2C_STAT) & BB) == 0x1);
-
-  if (Retry == MAX_RETRY) {
-    return EFI_TIMEOUT;
-  }
-
-  return EFI_SUCCESS;
-}
-
-STATIC
-EFI_STATUS
-PollForStatus(
-  UINT16 StatusBit
-  )
-{
-  UINTN Retry = 0;
-
-  while(Retry < MAX_RETRY) {
-    if (MmioRead16(I2C_STAT) & StatusBit) {
-      //Clear particular status bit from Status register.
-      MmioOr16(I2C_STAT, StatusBit);
-      break;
-    }
-    Retry++;
-  }
-
-  if (Retry == MAX_RETRY) {
-    return EFI_TIMEOUT;
-  }
-
-  return EFI_SUCCESS;
-}
-
-STATIC
-EFI_STATUS
-ConfigureI2c (
-  VOID
-  )
-{
-  //Program prescaler to obtain 12-MHz clock
-  MmioWrite16(I2C_PSC, 0x0000);
-
-  //Program SCLL and SCLH 
-  //NOTE: Following values are the register dump after U-Boot code executed. 
-  //We need to figure out how its calculated based on the I2C functional clock and I2C_PSC.
-  MmioWrite16(I2C_SCLL, 0x0035);
-  MmioWrite16(I2C_SCLH, 0x0035);
-
-  //Take the I2C controller out of reset.
-  MmioOr16(I2C_CON, I2C_EN);
-
-  //Initialize the I2C controller.
-
-  //Set I2C controller in Master mode.
-  MmioOr16(I2C_CON, MST);
-
-  //Enable interrupts for receive/transmit mode.
-  MmioOr16(I2C_IE, (XRDY_IE | RRDY_IE | ARDY_IE | NACK_IE));
-
-  return EFI_SUCCESS;
-}
-
-STATIC
-EFI_STATUS
-I2CReadOneByte (
-  UINT8 *Data
-  )
-{
-  EFI_STATUS Status;
-
-  //I2C bus status checking
-  Status = WaitForBusBusy();
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  //Poll till Receive ready bit is set.
-  Status = PollForStatus(RRDY);
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  *Data = MmioRead8(I2C_DATA);
-
-  return EFI_SUCCESS;
-}
-
-STATIC
-EFI_STATUS
-I2CWriteOneByte (
-  UINT8 Data    
-  )
-{
-  EFI_STATUS Status;
-
-  //I2C bus status checking
-  Status = WaitForBusBusy();
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  //Data transfer
-  //Poll till Transmit ready bit is set
-  Status = PollForStatus(XRDY);
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  MmioWrite8(I2C_DATA, Data);
-
-  //Wait and check if the NACK is not set.
-  gBS->Stall(1000);
-  if (MmioRead16(I2C_STAT) & NACK) {
-    return EFI_DEVICE_ERROR;
-  }
-
-  return EFI_SUCCESS;
-}
-
-STATIC
-EFI_STATUS
-SmbusBlockRead (
-  OUT UINT8       *Buffer,
-  IN  UINTN       Length
-  )
-{
-  UINTN      Index = 0;
-  EFI_STATUS Status = EFI_SUCCESS;
-
-  //Transfer configuration for receiving data.
-  MmioWrite16(I2C_CNT, Length);
-  //Need stop bit before sending data.
-  MmioWrite16(I2C_CON, (I2C_EN | MST | STP | STT));
-
-  while (Index < Length) {
-    //Read a byte
-    Status = I2CReadOneByte(&Buffer[Index++]);
-    if (EFI_ERROR(Status)) {
-      return Status;
-    }
-  }
-
-  //Transfer completion
-  Status = PollForStatus(ARDY);
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  return Status;
-}
-
-STATIC
-EFI_STATUS
-SmbusBlockWrite (
-  IN UINT8       *Buffer,
-  IN UINTN       Length
-  )
-{
-  UINTN      Index = 0;
-  EFI_STATUS Status = EFI_SUCCESS;
-
-  //Transfer configuration for transmitting data
-  MmioWrite16(I2C_CNT, Length);
-  MmioWrite16(I2C_CON, (I2C_EN | TRX | MST | STT | STP));
-
-  while (Index < Length) {
-    //Send a byte
-    Status = I2CWriteOneByte(Buffer[Index++]);
-    if (EFI_ERROR(Status)) {
-      return Status;
-    }
-  }
-
-  //Transfer completion
-  Status = PollForStatus(ARDY);
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  return Status;
-}
-
-//
-// Public Functions.
-//
-EFI_STATUS
-EFIAPI
-SmbusExecute (
-  IN CONST EFI_SMBUS_HC_PROTOCOL    *This,
-  IN CONST EFI_SMBUS_DEVICE_ADDRESS SlaveAddress,
-  IN CONST EFI_SMBUS_DEVICE_COMMAND Command,
-  IN CONST EFI_SMBUS_OPERATION      Operation,
-  IN CONST BOOLEAN                  PecCheck,
-  IN OUT   UINTN                    *Length,
-  IN OUT   VOID                     *Buffer
-  )
-{
-  UINT8      *ByteBuffer  = Buffer;
-  EFI_STATUS Status       = EFI_SUCCESS;
-  UINT8      SlaveAddr    = (UINT8)(SlaveAddress.SmbusDeviceAddress);
-
-  if (PecCheck) {
-    return EFI_UNSUPPORTED;
-  }
-
-  if ((Operation != EfiSmbusWriteBlock) && (Operation != EfiSmbusReadBlock)) {
-    return EFI_UNSUPPORTED;
-  }
-
-  //Set the Slave address.
-  MmioWrite16(I2C_SA, SlaveAddr);
-
-  if (Operation == EfiSmbusReadBlock) {
-    Status = SmbusBlockRead(ByteBuffer, *Length);
-  } else if (Operation == EfiSmbusWriteBlock) {
-    Status = SmbusBlockWrite(ByteBuffer, *Length);
-  }
-
-  return Status;
-}
-
-EFI_STATUS
-EFIAPI
-SmbusArpDevice (
-  IN CONST EFI_SMBUS_HC_PROTOCOL    *This,
-  IN       BOOLEAN                  ArpAll,
-  IN       EFI_SMBUS_UDID           *SmbusUdid OPTIONAL,
-  IN OUT   EFI_SMBUS_DEVICE_ADDRESS *SlaveAddress OPTIONAL
-  )
-{
-  return EFI_UNSUPPORTED;
-}
-
-
-EFI_STATUS
-EFIAPI
-SmbusGetArpMap (
-  IN CONST EFI_SMBUS_HC_PROTOCOL    *This,
-  IN OUT   UINTN                    *Length,
-  IN OUT   EFI_SMBUS_DEVICE_MAP     **SmbusDeviceMap
-  )
-{
-  return EFI_UNSUPPORTED;
-}
-
-
-EFI_STATUS
-EFIAPI
-SmbusNotify (
-  IN CONST  EFI_SMBUS_HC_PROTOCOL     *This,
-  IN CONST  EFI_SMBUS_DEVICE_ADDRESS  SlaveAddress,
-  IN CONST  UINTN                     Data,
-  IN CONST  EFI_SMBUS_NOTIFY_FUNCTION NotifyFunction
-  )
-{
-  return EFI_UNSUPPORTED;
-}
-
-EFI_SMBUS_HC_PROTOCOL SmbusProtocol =
-{
-  SmbusExecute,
-  SmbusArpDevice,
-  SmbusGetArpMap,
-  SmbusNotify
-};
-
-EFI_STATUS
-InitializeSmbus (
-    IN EFI_HANDLE       ImageHandle,
-    IN EFI_SYSTEM_TABLE *SystemTable
-    )
-{
-  EFI_HANDLE      Handle = NULL;
-  EFI_STATUS      Status;
-
-  //Configure I2C controller.
-  Status = ConfigureI2c();
-  if (EFI_ERROR(Status)) {
-    DEBUG ((EFI_D_ERROR, "InitializeI2c fails.\n"));
-    return Status;
-  }
-
-  // Install the SMBUS interface
-  Status = gBS->InstallMultipleProtocolInterfaces(&Handle, &gEfiSmbusHcProtocolGuid, &SmbusProtocol, NULL);
-  ASSERT_EFI_ERROR(Status);
-  
-  return Status;
-}
-
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include <Uefi.h>

+#include <Omap3530/Omap3530.h>

+

+#include <Library/DebugLib.h>

+#include <Library/IoLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+

+#include <Protocol/SmbusHc.h>

+

+#define MAX_RETRY  1000

+

+//

+// Internal Functions

+//

+STATIC

+EFI_STATUS

+WaitForBusBusy (

+  VOID

+  )

+{

+  UINTN Retry = 0;

+

+  while (++Retry < MAX_RETRY && (MmioRead16(I2C_STAT) & BB) == 0x1);

+

+  if (Retry == MAX_RETRY) {

+    return EFI_TIMEOUT;

+  }

+

+  return EFI_SUCCESS;

+}

+

+STATIC

+EFI_STATUS

+PollForStatus(

+  UINT16 StatusBit

+  )

+{

+  UINTN Retry = 0;

+

+  while(Retry < MAX_RETRY) {

+    if (MmioRead16(I2C_STAT) & StatusBit) {

+      //Clear particular status bit from Status register.

+      MmioOr16(I2C_STAT, StatusBit);

+      break;

+    }

+    Retry++;

+  }

+

+  if (Retry == MAX_RETRY) {

+    return EFI_TIMEOUT;

+  }

+

+  return EFI_SUCCESS;

+}

+

+STATIC

+EFI_STATUS

+ConfigureI2c (

+  VOID

+  )

+{

+  //Program prescaler to obtain 12-MHz clock

+  MmioWrite16(I2C_PSC, 0x0000);

+

+  //Program SCLL and SCLH 

+  //NOTE: Following values are the register dump after U-Boot code executed. 

+  //We need to figure out how its calculated based on the I2C functional clock and I2C_PSC.

+  MmioWrite16(I2C_SCLL, 0x0035);

+  MmioWrite16(I2C_SCLH, 0x0035);

+

+  //Take the I2C controller out of reset.

+  MmioOr16(I2C_CON, I2C_EN);

+

+  //Initialize the I2C controller.

+

+  //Set I2C controller in Master mode.

+  MmioOr16(I2C_CON, MST);

+

+  //Enable interrupts for receive/transmit mode.

+  MmioOr16(I2C_IE, (XRDY_IE | RRDY_IE | ARDY_IE | NACK_IE));

+

+  return EFI_SUCCESS;

+}

+

+STATIC

+EFI_STATUS

+I2CReadOneByte (

+  UINT8 *Data

+  )

+{

+  EFI_STATUS Status;

+

+  //I2C bus status checking

+  Status = WaitForBusBusy();

+  if (EFI_ERROR(Status)) {

+    return Status;

+  }

+

+  //Poll till Receive ready bit is set.

+  Status = PollForStatus(RRDY);

+  if (EFI_ERROR(Status)) {

+    return Status;

+  }

+

+  *Data = MmioRead8(I2C_DATA);

+

+  return EFI_SUCCESS;

+}

+

+STATIC

+EFI_STATUS

+I2CWriteOneByte (

+  UINT8 Data    

+  )

+{

+  EFI_STATUS Status;

+

+  //I2C bus status checking

+  Status = WaitForBusBusy();

+  if (EFI_ERROR(Status)) {

+    return Status;

+  }

+

+  //Data transfer

+  //Poll till Transmit ready bit is set

+  Status = PollForStatus(XRDY);

+  if (EFI_ERROR(Status)) {

+    return Status;

+  }

+

+  MmioWrite8(I2C_DATA, Data);

+

+  //Wait and check if the NACK is not set.

+  gBS->Stall(1000);

+  if (MmioRead16(I2C_STAT) & NACK) {

+    return EFI_DEVICE_ERROR;

+  }

+

+  return EFI_SUCCESS;

+}

+

+STATIC

+EFI_STATUS

+SmbusBlockRead (

+  OUT UINT8       *Buffer,

+  IN  UINTN       Length

+  )

+{

+  UINTN      Index = 0;

+  EFI_STATUS Status = EFI_SUCCESS;

+

+  //Transfer configuration for receiving data.

+  MmioWrite16(I2C_CNT, Length);

+  //Need stop bit before sending data.

+  MmioWrite16(I2C_CON, (I2C_EN | MST | STP | STT));

+

+  while (Index < Length) {

+    //Read a byte

+    Status = I2CReadOneByte(&Buffer[Index++]);

+    if (EFI_ERROR(Status)) {

+      return Status;

+    }

+  }

+

+  //Transfer completion

+  Status = PollForStatus(ARDY);

+  if (EFI_ERROR(Status)) {

+    return Status;

+  }

+

+  return Status;

+}

+

+STATIC

+EFI_STATUS

+SmbusBlockWrite (

+  IN UINT8       *Buffer,

+  IN UINTN       Length

+  )

+{

+  UINTN      Index = 0;

+  EFI_STATUS Status = EFI_SUCCESS;

+

+  //Transfer configuration for transmitting data

+  MmioWrite16(I2C_CNT, Length);

+  MmioWrite16(I2C_CON, (I2C_EN | TRX | MST | STT | STP));

+

+  while (Index < Length) {

+    //Send a byte

+    Status = I2CWriteOneByte(Buffer[Index++]);

+    if (EFI_ERROR(Status)) {

+      return Status;

+    }

+  }

+

+  //Transfer completion

+  Status = PollForStatus(ARDY);

+  if (EFI_ERROR(Status)) {

+    return Status;

+  }

+

+  return Status;

+}

+

+//

+// Public Functions.

+//

+EFI_STATUS

+EFIAPI

+SmbusExecute (

+  IN CONST EFI_SMBUS_HC_PROTOCOL    *This,

+  IN CONST EFI_SMBUS_DEVICE_ADDRESS SlaveAddress,

+  IN CONST EFI_SMBUS_DEVICE_COMMAND Command,

+  IN CONST EFI_SMBUS_OPERATION      Operation,

+  IN CONST BOOLEAN                  PecCheck,

+  IN OUT   UINTN                    *Length,

+  IN OUT   VOID                     *Buffer

+  )

+{

+  UINT8      *ByteBuffer  = Buffer;

+  EFI_STATUS Status       = EFI_SUCCESS;

+  UINT8      SlaveAddr    = (UINT8)(SlaveAddress.SmbusDeviceAddress);

+

+  if (PecCheck) {

+    return EFI_UNSUPPORTED;

+  }

+

+  if ((Operation != EfiSmbusWriteBlock) && (Operation != EfiSmbusReadBlock)) {

+    return EFI_UNSUPPORTED;

+  }

+

+  //Set the Slave address.

+  MmioWrite16(I2C_SA, SlaveAddr);

+

+  if (Operation == EfiSmbusReadBlock) {

+    Status = SmbusBlockRead(ByteBuffer, *Length);

+  } else if (Operation == EfiSmbusWriteBlock) {

+    Status = SmbusBlockWrite(ByteBuffer, *Length);

+  }

+

+  return Status;

+}

+

+EFI_STATUS

+EFIAPI

+SmbusArpDevice (

+  IN CONST EFI_SMBUS_HC_PROTOCOL    *This,

+  IN       BOOLEAN                  ArpAll,

+  IN       EFI_SMBUS_UDID           *SmbusUdid OPTIONAL,

+  IN OUT   EFI_SMBUS_DEVICE_ADDRESS *SlaveAddress OPTIONAL

+  )

+{

+  return EFI_UNSUPPORTED;

+}

+

+

+EFI_STATUS

+EFIAPI

+SmbusGetArpMap (

+  IN CONST EFI_SMBUS_HC_PROTOCOL    *This,

+  IN OUT   UINTN                    *Length,

+  IN OUT   EFI_SMBUS_DEVICE_MAP     **SmbusDeviceMap

+  )

+{

+  return EFI_UNSUPPORTED;

+}

+

+

+EFI_STATUS

+EFIAPI

+SmbusNotify (

+  IN CONST  EFI_SMBUS_HC_PROTOCOL     *This,

+  IN CONST  EFI_SMBUS_DEVICE_ADDRESS  SlaveAddress,

+  IN CONST  UINTN                     Data,

+  IN CONST  EFI_SMBUS_NOTIFY_FUNCTION NotifyFunction

+  )

+{

+  return EFI_UNSUPPORTED;

+}

+

+EFI_SMBUS_HC_PROTOCOL SmbusProtocol =

+{

+  SmbusExecute,

+  SmbusArpDevice,

+  SmbusGetArpMap,

+  SmbusNotify

+};

+

+EFI_STATUS

+InitializeSmbus (

+    IN EFI_HANDLE       ImageHandle,

+    IN EFI_SYSTEM_TABLE *SystemTable

+    )

+{

+  EFI_HANDLE      Handle = NULL;

+  EFI_STATUS      Status;

+

+  //Configure I2C controller.

+  Status = ConfigureI2c();

+  if (EFI_ERROR(Status)) {

+    DEBUG ((EFI_D_ERROR, "InitializeI2c fails.\n"));

+    return Status;

+  }

+

+  // Install the SMBUS interface

+  Status = gBS->InstallMultipleProtocolInterfaces(&Handle, &gEfiSmbusHcProtocolGuid, &SmbusProtocol, NULL);

+  ASSERT_EFI_ERROR(Status);

+  

+  return Status;

+}

+

diff --git a/Omap35xxPkg/SmbusDxe/Smbus.inf b/Omap35xxPkg/SmbusDxe/Smbus.inf
index 6a8a4e91..5a4e43ea 100644
--- a/Omap35xxPkg/SmbusDxe/Smbus.inf
+++ b/Omap35xxPkg/SmbusDxe/Smbus.inf
@@ -1,45 +1,45 @@
-#/** @file
-#  
-#  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = Smbus
-  FILE_GUID                      = d5125e0f-1226-444f-a218-0085996ed5da
-  MODULE_TYPE                    = DXE_DRIVER
-  VERSION_STRING                 = 1.0
-
-  ENTRY_POINT                    = InitializeSmbus
-
-[Sources.common]
-  Smbus.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  Omap35xxPkg/Omap35xxPkg.dec
-
-[LibraryClasses]
-  PcdLib
-  UefiLib
-  UefiDriverEntryPoint
-  MemoryAllocationLib
-  IoLib
-
-[Guids]
-  
-[Protocols]
-  gEfiSmbusHcProtocolGuid
-
-[Pcd]
-
-[depex]
-  TRUE
\ No newline at end of file
+#/** @file

+#  

+#  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = Smbus

+  FILE_GUID                      = d5125e0f-1226-444f-a218-0085996ed5da

+  MODULE_TYPE                    = DXE_DRIVER

+  VERSION_STRING                 = 1.0

+

+  ENTRY_POINT                    = InitializeSmbus

+

+[Sources.common]

+  Smbus.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  Omap35xxPkg/Omap35xxPkg.dec

+

+[LibraryClasses]

+  PcdLib

+  UefiLib

+  UefiDriverEntryPoint

+  MemoryAllocationLib

+  IoLib

+

+[Guids]

+  

+[Protocols]

+  gEfiSmbusHcProtocolGuid

+

+[Pcd]

+

+[depex]

+  TRUE
\ No newline at end of file
diff --git a/Omap35xxPkg/TPS65950Dxe/TPS65950.c b/Omap35xxPkg/TPS65950Dxe/TPS65950.c
index 6b76da50..ed19389d 100644
--- a/Omap35xxPkg/TPS65950Dxe/TPS65950.c
+++ b/Omap35xxPkg/TPS65950Dxe/TPS65950.c
@@ -1,116 +1,116 @@
-/** @file
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials
-  are licensed and made available under the terms and conditions of the BSD License
-  which accompanies this distribution.  The full text of the license may be found at
-  http://opensource.org/licenses/bsd-license.php
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-
-**/
-
-#include <Uefi.h>
-
-#include <TPS65950.h>
-
-#include <Library/BaseMemoryLib.h>
-#include <Library/DebugLib.h>
-#include <Library/MemoryAllocationLib.h>
-#include <Library/UefiBootServicesTableLib.h>
-
-#include <Protocol/EmbeddedExternalDevice.h>
-#include <Protocol/SmbusHc.h>
-
-EFI_SMBUS_HC_PROTOCOL *Smbus;
-
-EFI_STATUS
-Read (
-  IN  EMBEDDED_EXTERNAL_DEVICE    *This,
-  IN  UINTN                       Register,
-  IN  UINTN                       Length,
-  OUT VOID                        *Buffer
-  )
-{
-  EFI_STATUS               Status;
-  EFI_SMBUS_DEVICE_ADDRESS SlaveAddress; 
-  UINT8                    DeviceRegister;
-  UINTN                    DeviceRegisterLength = 1;
-
-  SlaveAddress.SmbusDeviceAddress = EXTERNAL_DEVICE_REGISTER_TO_SLAVE_ADDRESS(Register);
-  DeviceRegister = (UINT8)EXTERNAL_DEVICE_REGISTER_TO_REGISTER(Register);
-
-  //Write DeviceRegister.
-  Status = Smbus->Execute(Smbus, SlaveAddress, 0, EfiSmbusWriteBlock, FALSE, &DeviceRegisterLength, &DeviceRegister);
-  if (EFI_ERROR(Status)) {
-    return Status;
-  }
-
-  //Read Data
-  Status = Smbus->Execute(Smbus, SlaveAddress, 0, EfiSmbusReadBlock, FALSE, &Length, Buffer);
-  return Status;
-}
-
-EFI_STATUS
-Write (
-  IN EMBEDDED_EXTERNAL_DEVICE   *This,
-  IN UINTN                      Register,
-  IN UINTN                      Length,
-  IN VOID                       *Buffer
-  )
-{
-  EFI_STATUS               Status;
-  EFI_SMBUS_DEVICE_ADDRESS SlaveAddress; 
-  UINT8                    DeviceRegister;
-  UINTN                    DeviceBufferLength = Length + 1;
-  UINT8                    *DeviceBuffer;
-
-  SlaveAddress.SmbusDeviceAddress = EXTERNAL_DEVICE_REGISTER_TO_SLAVE_ADDRESS(Register);
-  DeviceRegister = (UINT8)EXTERNAL_DEVICE_REGISTER_TO_REGISTER(Register);
-
-  //Prepare buffer for writing
-  DeviceBuffer = (UINT8 *)AllocatePool(DeviceBufferLength);
-  if (DeviceBuffer == NULL) {
-    Status = EFI_OUT_OF_RESOURCES;
-    goto exit;
-  }
-
-  //Set Device register followed by data to write.
-  DeviceBuffer[0] = DeviceRegister;
-  CopyMem(&DeviceBuffer[1], Buffer, Length);
-
-  //Write Data
-  Status = Smbus->Execute(Smbus, SlaveAddress, 0, EfiSmbusWriteBlock, FALSE, &DeviceBufferLength, DeviceBuffer);
-  if (EFI_ERROR(Status)) {
-    goto exit;
-  }
-
-exit:
-  if (DeviceBuffer) {
-    FreePool(DeviceBuffer);
-  }
-
-  return Status;
-}
-
-EMBEDDED_EXTERNAL_DEVICE ExternalDevice = {
-  Read,
-  Write
-};
-
-EFI_STATUS
-TPS65950Initialize (
-  IN EFI_HANDLE         ImageHandle,
-  IN EFI_SYSTEM_TABLE   *SystemTable
-  )
-{
-  EFI_STATUS  Status;
-  
-  Status = gBS->LocateProtocol(&gEfiSmbusHcProtocolGuid, NULL, (VOID **)&Smbus);
-  ASSERT_EFI_ERROR(Status);
-  
-  Status = gBS->InstallMultipleProtocolInterfaces(&ImageHandle, &gEmbeddedExternalDeviceProtocolGuid, &ExternalDevice, NULL);
-  return Status;
-}
+/** @file

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include <Uefi.h>

+

+#include <TPS65950.h>

+

+#include <Library/BaseMemoryLib.h>

+#include <Library/DebugLib.h>

+#include <Library/MemoryAllocationLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+

+#include <Protocol/EmbeddedExternalDevice.h>

+#include <Protocol/SmbusHc.h>

+

+EFI_SMBUS_HC_PROTOCOL *Smbus;

+

+EFI_STATUS

+Read (

+  IN  EMBEDDED_EXTERNAL_DEVICE    *This,

+  IN  UINTN                       Register,

+  IN  UINTN                       Length,

+  OUT VOID                        *Buffer

+  )

+{

+  EFI_STATUS               Status;

+  EFI_SMBUS_DEVICE_ADDRESS SlaveAddress; 

+  UINT8                    DeviceRegister;

+  UINTN                    DeviceRegisterLength = 1;

+

+  SlaveAddress.SmbusDeviceAddress = EXTERNAL_DEVICE_REGISTER_TO_SLAVE_ADDRESS(Register);

+  DeviceRegister = (UINT8)EXTERNAL_DEVICE_REGISTER_TO_REGISTER(Register);

+

+  //Write DeviceRegister.

+  Status = Smbus->Execute(Smbus, SlaveAddress, 0, EfiSmbusWriteBlock, FALSE, &DeviceRegisterLength, &DeviceRegister);

+  if (EFI_ERROR(Status)) {

+    return Status;

+  }

+

+  //Read Data

+  Status = Smbus->Execute(Smbus, SlaveAddress, 0, EfiSmbusReadBlock, FALSE, &Length, Buffer);

+  return Status;

+}

+

+EFI_STATUS

+Write (

+  IN EMBEDDED_EXTERNAL_DEVICE   *This,

+  IN UINTN                      Register,

+  IN UINTN                      Length,

+  IN VOID                       *Buffer

+  )

+{

+  EFI_STATUS               Status;

+  EFI_SMBUS_DEVICE_ADDRESS SlaveAddress; 

+  UINT8                    DeviceRegister;

+  UINTN                    DeviceBufferLength = Length + 1;

+  UINT8                    *DeviceBuffer;

+

+  SlaveAddress.SmbusDeviceAddress = EXTERNAL_DEVICE_REGISTER_TO_SLAVE_ADDRESS(Register);

+  DeviceRegister = (UINT8)EXTERNAL_DEVICE_REGISTER_TO_REGISTER(Register);

+

+  //Prepare buffer for writing

+  DeviceBuffer = (UINT8 *)AllocatePool(DeviceBufferLength);

+  if (DeviceBuffer == NULL) {

+    Status = EFI_OUT_OF_RESOURCES;

+    goto exit;

+  }

+

+  //Set Device register followed by data to write.

+  DeviceBuffer[0] = DeviceRegister;

+  CopyMem(&DeviceBuffer[1], Buffer, Length);

+

+  //Write Data

+  Status = Smbus->Execute(Smbus, SlaveAddress, 0, EfiSmbusWriteBlock, FALSE, &DeviceBufferLength, DeviceBuffer);

+  if (EFI_ERROR(Status)) {

+    goto exit;

+  }

+

+exit:

+  if (DeviceBuffer) {

+    FreePool(DeviceBuffer);

+  }

+

+  return Status;

+}

+

+EMBEDDED_EXTERNAL_DEVICE ExternalDevice = {

+  Read,

+  Write

+};

+

+EFI_STATUS

+TPS65950Initialize (

+  IN EFI_HANDLE         ImageHandle,

+  IN EFI_SYSTEM_TABLE   *SystemTable

+  )

+{

+  EFI_STATUS  Status;

+  

+  Status = gBS->LocateProtocol(&gEfiSmbusHcProtocolGuid, NULL, (VOID **)&Smbus);

+  ASSERT_EFI_ERROR(Status);

+  

+  Status = gBS->InstallMultipleProtocolInterfaces(&ImageHandle, &gEmbeddedExternalDeviceProtocolGuid, &ExternalDevice, NULL);

+  return Status;

+}

diff --git a/Omap35xxPkg/TPS65950Dxe/TPS65950.inf b/Omap35xxPkg/TPS65950Dxe/TPS65950.inf
index d03326bd..5fca7a35 100644
--- a/Omap35xxPkg/TPS65950Dxe/TPS65950.inf
+++ b/Omap35xxPkg/TPS65950Dxe/TPS65950.inf
@@ -1,48 +1,48 @@
-#/** @file
-#  
-#  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = TPS65950
-  FILE_GUID                      = 71fe861a-5450-48b6-bfb0-b93522616f99
-  MODULE_TYPE                    = DXE_DRIVER
-  VERSION_STRING                 = 1.0
-
-  ENTRY_POINT                    = TPS65950Initialize
-
-
-[Sources.common]
-  TPS65950.c
-
-[Packages]
-  MdePkg/MdePkg.dec
-  EmbeddedPkg/EmbeddedPkg.dec
-  Omap35xxPkg/Omap35xxPkg.dec
-
-[LibraryClasses]
-  BaseMemoryLib
-  PcdLib
-  UefiLib
-  UefiDriverEntryPoint
-  MemoryAllocationLib
-
-[Guids]
-  
-[Protocols]
-  gEfiSmbusHcProtocolGuid
-  gEmbeddedExternalDeviceProtocolGuid
-
-[Pcd]
-
-[depex]
-  gEfiSmbusHcProtocolGuid
+#/** @file

+#  

+#  Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR>

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = TPS65950

+  FILE_GUID                      = 71fe861a-5450-48b6-bfb0-b93522616f99

+  MODULE_TYPE                    = DXE_DRIVER

+  VERSION_STRING                 = 1.0

+

+  ENTRY_POINT                    = TPS65950Initialize

+

+

+[Sources.common]

+  TPS65950.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  EmbeddedPkg/EmbeddedPkg.dec

+  Omap35xxPkg/Omap35xxPkg.dec

+

+[LibraryClasses]

+  BaseMemoryLib

+  PcdLib

+  UefiLib

+  UefiDriverEntryPoint

+  MemoryAllocationLib

+

+[Guids]

+  

+[Protocols]

+  gEfiSmbusHcProtocolGuid

+  gEmbeddedExternalDeviceProtocolGuid

+

+[Pcd]

+

+[depex]

+  gEfiSmbusHcProtocolGuid

diff --git a/Omap35xxPkg/TimerDxe/Timer.c b/Omap35xxPkg/TimerDxe/Timer.c
index d0ea9735..bc3d9b0a 100644
--- a/Omap35xxPkg/TimerDxe/Timer.c
+++ b/Omap35xxPkg/TimerDxe/Timer.c
@@ -1,376 +1,376 @@
-/** @file
-  Template for Timer Architecture Protocol driver of the ARM flavor
-
-  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  
-  This program and the accompanying materials                          
-  are licensed and made available under the terms and conditions of the BSD License         
-  which accompanies this distribution.  The full text of the license may be found at        
-  http://opensource.org/licenses/bsd-license.php                                            
-
-  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
-  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
-
-**/
-
-
-#include <PiDxe.h>
-
-#include <Library/BaseLib.h>
-#include <Library/DebugLib.h>
-#include <Library/BaseMemoryLib.h>
-#include <Library/UefiBootServicesTableLib.h>
-#include <Library/UefiLib.h>
-#include <Library/PcdLib.h>
-#include <Library/IoLib.h>
-#include <Library/OmapLib.h>
-
-#include <Protocol/Timer.h>
-#include <Protocol/HardwareInterrupt.h>
-
-#include <Omap3530/Omap3530.h>
-
-
-// The notification function to call on every timer interrupt.
-volatile EFI_TIMER_NOTIFY      mTimerNotifyFunction   = (EFI_TIMER_NOTIFY)NULL;
-
-
-// The current period of the timer interrupt
-volatile UINT64 mTimerPeriod = 0;
-
-// Cached copy of the Hardware Interrupt protocol instance
-EFI_HARDWARE_INTERRUPT_PROTOCOL *gInterrupt = NULL;
-
-// Cached registers
-volatile UINT32 TISR;
-volatile UINT32 TCLR;
-volatile UINT32 TLDR;
-volatile UINT32 TCRR;
-volatile UINT32 TIER;
-
-// Cached interrupt vector
-volatile UINTN  gVector;
-
-
-/**
-
-  C Interrupt Handler calledin the interrupt context when Source interrupt is active.
-
-
-  @param Source         Source of the interrupt. Hardware routing off a specific platform defines
-                        what source means.
-
-  @param SystemContext  Pointer to system register context. Mostly used by debuggers and will
-                        update the system context after the return from the interrupt if 
-                        modified. Don't change these values unless you know what you are doing
-
-**/
-VOID
-EFIAPI
-TimerInterruptHandler (
-  IN  HARDWARE_INTERRUPT_SOURCE   Source,
-  IN  EFI_SYSTEM_CONTEXT          SystemContext       
-  )
-{
-  EFI_TPL OriginalTPL;
-
-
-
-  //
-  // DXE core uses this callback for the EFI timer tick. The DXE core uses locks 
-  // that raise to TPL_HIGH and then restore back to current level. Thus we need
-  // to make sure TPL level is set to TPL_HIGH while we are handling the timer tick. 
-  //
-  OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);
-
-  if (mTimerNotifyFunction) {
-    mTimerNotifyFunction(mTimerPeriod);
-  }
-
-  // Clear all timer interrupts
-  MmioWrite32 (TISR, TISR_CLEAR_ALL);  
-
-  // Poll interrupt status bits to ensure clearing
-  while ((MmioRead32 (TISR) & TISR_ALL_INTERRUPT_MASK) != TISR_NO_INTERRUPTS_PENDING);
-
-  gBS->RestoreTPL (OriginalTPL);
-}
-
-/**
-  This function registers the handler NotifyFunction so it is called every time 
-  the timer interrupt fires.  It also passes the amount of time since the last 
-  handler call to the NotifyFunction.  If NotifyFunction is NULL, then the 
-  handler is unregistered.  If the handler is registered, then EFI_SUCCESS is 
-  returned.  If the CPU does not support registering a timer interrupt handler, 
-  then EFI_UNSUPPORTED is returned.  If an attempt is made to register a handler 
-  when a handler is already registered, then EFI_ALREADY_STARTED is returned.  
-  If an attempt is made to unregister a handler when a handler is not registered, 
-  then EFI_INVALID_PARAMETER is returned.  If an error occurs attempting to 
-  register the NotifyFunction with the timer interrupt, then EFI_DEVICE_ERROR 
-  is returned.
-
-  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
-  @param  NotifyFunction   The function to call when a timer interrupt fires. This
-                           function executes at TPL_HIGH_LEVEL. The DXE Core will
-                           register a handler for the timer interrupt, so it can know
-                           how much time has passed. This information is used to
-                           signal timer based events. NULL will unregister the handler.
-  @retval EFI_SUCCESS           The timer handler was registered.
-  @retval EFI_UNSUPPORTED       The platform does not support timer interrupts.
-  @retval EFI_ALREADY_STARTED   NotifyFunction is not NULL, and a handler is already
-                                registered.
-  @retval EFI_INVALID_PARAMETER NotifyFunction is NULL, and a handler was not
-                                previously registered.
-  @retval EFI_DEVICE_ERROR      The timer handler could not be registered.
-
-**/
-EFI_STATUS
-EFIAPI
-TimerDriverRegisterHandler (
-  IN EFI_TIMER_ARCH_PROTOCOL  *This,
-  IN EFI_TIMER_NOTIFY         NotifyFunction
-  )
-{
-  if ((NotifyFunction == NULL) && (mTimerNotifyFunction == NULL)) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  if ((NotifyFunction != NULL) && (mTimerNotifyFunction != NULL)) {
-    return EFI_ALREADY_STARTED;
-  }
-
-  mTimerNotifyFunction = NotifyFunction;
-
-  return EFI_SUCCESS;
-}
-
-/**
-
-  This function adjusts the period of timer interrupts to the value specified 
-  by TimerPeriod.  If the timer period is updated, then the selected timer 
-  period is stored in EFI_TIMER.TimerPeriod, and EFI_SUCCESS is returned.  If 
-  the timer hardware is not programmable, then EFI_UNSUPPORTED is returned.  
-  If an error occurs while attempting to update the timer period, then the 
-  timer hardware will be put back in its state prior to this call, and 
-  EFI_DEVICE_ERROR is returned.  If TimerPeriod is 0, then the timer interrupt 
-  is disabled.  This is not the same as disabling the CPU's interrupts.  
-  Instead, it must either turn off the timer hardware, or it must adjust the 
-  interrupt controller so that a CPU interrupt is not generated when the timer 
-  interrupt fires. 
-
-  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
-  @param  TimerPeriod      The rate to program the timer interrupt in 100 nS units. If
-                           the timer hardware is not programmable, then EFI_UNSUPPORTED is
-                           returned. If the timer is programmable, then the timer period
-                           will be rounded up to the nearest timer period that is supported
-                           by the timer hardware. If TimerPeriod is set to 0, then the
-                           timer interrupts will be disabled.
-
-
-  @retval EFI_SUCCESS           The timer period was changed.
-  @retval EFI_UNSUPPORTED       The platform cannot change the period of the timer interrupt.
-  @retval EFI_DEVICE_ERROR      The timer period could not be changed due to a device error.
-
-**/
-EFI_STATUS
-EFIAPI
-TimerDriverSetTimerPeriod (
-  IN EFI_TIMER_ARCH_PROTOCOL  *This,
-  IN UINT64                   TimerPeriod
-  )
-{
-  EFI_STATUS  Status;
-  UINT64      TimerCount;
-  INT32       LoadValue;
-  
-  if (TimerPeriod == 0) {
-    // Turn off GPTIMER3
-    MmioWrite32 (TCLR, TCLR_ST_OFF);
-    
-    Status = gInterrupt->DisableInterruptSource(gInterrupt, gVector);    
-  } else {  
-    // Calculate required timer count
-    TimerCount = DivU64x32(TimerPeriod * 100, PcdGet32(PcdEmbeddedPerformanceCounterPeriodInNanoseconds));
-
-    // Set GPTIMER3 Load register
-    LoadValue = (INT32) -TimerCount;
-    MmioWrite32 (TLDR, LoadValue);
-    MmioWrite32 (TCRR, LoadValue);
-
-    // Enable Overflow interrupt
-    MmioWrite32 (TIER, TIER_TCAR_IT_DISABLE | TIER_OVF_IT_ENABLE | TIER_MAT_IT_DISABLE);
-
-    // Turn on GPTIMER3, it will reload at overflow
-    MmioWrite32 (TCLR, TCLR_AR_AUTORELOAD | TCLR_ST_ON);
-
-    Status = gInterrupt->EnableInterruptSource(gInterrupt, gVector);    
-  }
-
-  //
-  // Save the new timer period
-  //
-  mTimerPeriod = TimerPeriod;
-  return Status;
-}
-
-
-/**
-  This function retrieves the period of timer interrupts in 100 ns units, 
-  returns that value in TimerPeriod, and returns EFI_SUCCESS.  If TimerPeriod 
-  is NULL, then EFI_INVALID_PARAMETER is returned.  If a TimerPeriod of 0 is 
-  returned, then the timer is currently disabled.
-
-  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
-  @param  TimerPeriod      A pointer to the timer period to retrieve in 100 ns units. If
-                           0 is returned, then the timer is currently disabled.
-
-
-  @retval EFI_SUCCESS           The timer period was returned in TimerPeriod.
-  @retval EFI_INVALID_PARAMETER TimerPeriod is NULL.
-
-**/
-EFI_STATUS
-EFIAPI
-TimerDriverGetTimerPeriod (
-  IN EFI_TIMER_ARCH_PROTOCOL   *This,
-  OUT UINT64                   *TimerPeriod
-  )
-{
-  if (TimerPeriod == NULL) {
-    return EFI_INVALID_PARAMETER;
-  }
-
-  *TimerPeriod = mTimerPeriod;
-  return EFI_SUCCESS;
-}
-
-/**
-  This function generates a soft timer interrupt. If the platform does not support soft 
-  timer interrupts, then EFI_UNSUPPORTED is returned. Otherwise, EFI_SUCCESS is returned. 
-  If a handler has been registered through the EFI_TIMER_ARCH_PROTOCOL.RegisterHandler() 
-  service, then a soft timer interrupt will be generated. If the timer interrupt is 
-  enabled when this service is called, then the registered handler will be invoked. The 
-  registered handler should not be able to distinguish a hardware-generated timer 
-  interrupt from a software-generated timer interrupt.
-
-  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
-
-  @retval EFI_SUCCESS           The soft timer interrupt was generated.
-  @retval EFI_UNSUPPORTED       The platform does not support the generation of soft timer interrupts.
-
-**/
-EFI_STATUS
-EFIAPI
-TimerDriverGenerateSoftInterrupt (
-  IN EFI_TIMER_ARCH_PROTOCOL  *This
-  )
-{
-  return EFI_UNSUPPORTED;
-}
-
-
-/**
-  Interface stucture for the Timer Architectural Protocol.
-
-  @par Protocol Description:
-  This protocol provides the services to initialize a periodic timer 
-  interrupt, and to register a handler that is called each time the timer
-  interrupt fires.  It may also provide a service to adjust the rate of the
-  periodic timer interrupt.  When a timer interrupt occurs, the handler is 
-  passed the amount of time that has passed since the previous timer 
-  interrupt.
-
-  @param RegisterHandler
-  Registers a handler that will be called each time the 
-  timer interrupt fires.  TimerPeriod defines the minimum 
-  time between timer interrupts, so TimerPeriod will also 
-  be the minimum time between calls to the registered 
-  handler.
-
-  @param SetTimerPeriod
-  Sets the period of the timer interrupt in 100 nS units.  
-  This function is optional, and may return EFI_UNSUPPORTED.  
-  If this function is supported, then the timer period will 
-  be rounded up to the nearest supported timer period.
-
-
-  @param GetTimerPeriod
-  Retrieves the period of the timer interrupt in 100 nS units.
-
-  @param GenerateSoftInterrupt
-  Generates a soft timer interrupt that simulates the firing of 
-  the timer interrupt. This service can be used to invoke the   registered handler if the timer interrupt has been masked for 
-  a period of time.
-
-**/
-EFI_TIMER_ARCH_PROTOCOL   gTimer = {
-  TimerDriverRegisterHandler,
-  TimerDriverSetTimerPeriod,
-  TimerDriverGetTimerPeriod,
-  TimerDriverGenerateSoftInterrupt
-};
-
-
-/**
-  Initialize the state information for the Timer Architectural Protocol and
-  the Timer Debug support protocol that allows the debugger to break into a
-  running program.
-
-  @param  ImageHandle   of the loaded driver
-  @param  SystemTable   Pointer to the System Table
-
-  @retval EFI_SUCCESS           Protocol registered
-  @retval EFI_OUT_OF_RESOURCES  Cannot allocate protocol data structure
-  @retval EFI_DEVICE_ERROR      Hardware problems
-
-**/
-EFI_STATUS
-EFIAPI
-TimerInitialize (
-  IN EFI_HANDLE         ImageHandle,
-  IN EFI_SYSTEM_TABLE   *SystemTable
-  )
-{
-  EFI_HANDLE  Handle = NULL;
-  EFI_STATUS  Status;
-  UINT32      TimerBaseAddress;
-
-  // Find the interrupt controller protocol.  ASSERT if not found.
-  Status = gBS->LocateProtocol (&gHardwareInterruptProtocolGuid, NULL, (VOID **)&gInterrupt);
-  ASSERT_EFI_ERROR (Status);
-
-  // Set up the timer registers
-  TimerBaseAddress = TimerBase (FixedPcdGet32(PcdOmap35xxArchTimer));
-  TISR = TimerBaseAddress + GPTIMER_TISR;
-  TCLR = TimerBaseAddress + GPTIMER_TCLR;
-  TLDR = TimerBaseAddress + GPTIMER_TLDR;
-  TCRR = TimerBaseAddress + GPTIMER_TCRR;
-  TIER = TimerBaseAddress + GPTIMER_TIER;
-
-  // Disable the timer
-  Status = TimerDriverSetTimerPeriod (&gTimer, 0);
-  ASSERT_EFI_ERROR (Status);
-
-  // Install interrupt handler
-  gVector = InterruptVectorForTimer (FixedPcdGet32(PcdOmap35xxArchTimer));
-  Status = gInterrupt->RegisterInterruptSource (gInterrupt, gVector, TimerInterruptHandler);
-  ASSERT_EFI_ERROR (Status);
-
-  // Turn on the functional clock for Timer
-  MmioOr32 (CM_FCLKEN_PER, CM_FCLKEN_PER_EN_GPT3_ENABLE);
-
-  // Set up default timer
-  Status = TimerDriverSetTimerPeriod (&gTimer, FixedPcdGet32(PcdTimerPeriod));
-  ASSERT_EFI_ERROR (Status);
-
-  // Install the Timer Architectural Protocol onto a new handle
-  Status = gBS->InstallMultipleProtocolInterfaces (
-                  &Handle,
-                  &gEfiTimerArchProtocolGuid,      &gTimer,
-                  NULL
-                  );
-  ASSERT_EFI_ERROR(Status);
-
-  return Status;
-}
-
+/** @file

+  Template for Timer Architecture Protocol driver of the ARM flavor

+

+  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>

+  

+  This program and the accompanying materials                          

+  are licensed and made available under the terms and conditions of the BSD License         

+  which accompanies this distribution.  The full text of the license may be found at        

+  http://opensource.org/licenses/bsd-license.php                                            

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+

+**/

+

+

+#include <PiDxe.h>

+

+#include <Library/BaseLib.h>

+#include <Library/DebugLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/UefiLib.h>

+#include <Library/PcdLib.h>

+#include <Library/IoLib.h>

+#include <Library/OmapLib.h>

+

+#include <Protocol/Timer.h>

+#include <Protocol/HardwareInterrupt.h>

+

+#include <Omap3530/Omap3530.h>

+

+

+// The notification function to call on every timer interrupt.

+volatile EFI_TIMER_NOTIFY      mTimerNotifyFunction   = (EFI_TIMER_NOTIFY)NULL;

+

+

+// The current period of the timer interrupt

+volatile UINT64 mTimerPeriod = 0;

+

+// Cached copy of the Hardware Interrupt protocol instance

+EFI_HARDWARE_INTERRUPT_PROTOCOL *gInterrupt = NULL;

+

+// Cached registers

+volatile UINT32 TISR;

+volatile UINT32 TCLR;

+volatile UINT32 TLDR;

+volatile UINT32 TCRR;

+volatile UINT32 TIER;

+

+// Cached interrupt vector

+volatile UINTN  gVector;

+

+

+/**

+

+  C Interrupt Handler calledin the interrupt context when Source interrupt is active.

+

+

+  @param Source         Source of the interrupt. Hardware routing off a specific platform defines

+                        what source means.

+

+  @param SystemContext  Pointer to system register context. Mostly used by debuggers and will

+                        update the system context after the return from the interrupt if 

+                        modified. Don't change these values unless you know what you are doing

+

+**/

+VOID

+EFIAPI

+TimerInterruptHandler (

+  IN  HARDWARE_INTERRUPT_SOURCE   Source,

+  IN  EFI_SYSTEM_CONTEXT          SystemContext       

+  )

+{

+  EFI_TPL OriginalTPL;

+

+

+

+  //

+  // DXE core uses this callback for the EFI timer tick. The DXE core uses locks 

+  // that raise to TPL_HIGH and then restore back to current level. Thus we need

+  // to make sure TPL level is set to TPL_HIGH while we are handling the timer tick. 

+  //

+  OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);

+

+  if (mTimerNotifyFunction) {

+    mTimerNotifyFunction(mTimerPeriod);

+  }

+

+  // Clear all timer interrupts

+  MmioWrite32 (TISR, TISR_CLEAR_ALL);  

+

+  // Poll interrupt status bits to ensure clearing

+  while ((MmioRead32 (TISR) & TISR_ALL_INTERRUPT_MASK) != TISR_NO_INTERRUPTS_PENDING);

+

+  gBS->RestoreTPL (OriginalTPL);

+}

+

+/**

+  This function registers the handler NotifyFunction so it is called every time 

+  the timer interrupt fires.  It also passes the amount of time since the last 

+  handler call to the NotifyFunction.  If NotifyFunction is NULL, then the 

+  handler is unregistered.  If the handler is registered, then EFI_SUCCESS is 

+  returned.  If the CPU does not support registering a timer interrupt handler, 

+  then EFI_UNSUPPORTED is returned.  If an attempt is made to register a handler 

+  when a handler is already registered, then EFI_ALREADY_STARTED is returned.  

+  If an attempt is made to unregister a handler when a handler is not registered, 

+  then EFI_INVALID_PARAMETER is returned.  If an error occurs attempting to 

+  register the NotifyFunction with the timer interrupt, then EFI_DEVICE_ERROR 

+  is returned.

+

+  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.

+  @param  NotifyFunction   The function to call when a timer interrupt fires. This

+                           function executes at TPL_HIGH_LEVEL. The DXE Core will

+                           register a handler for the timer interrupt, so it can know

+                           how much time has passed. This information is used to

+                           signal timer based events. NULL will unregister the handler.

+  @retval EFI_SUCCESS           The timer handler was registered.

+  @retval EFI_UNSUPPORTED       The platform does not support timer interrupts.

+  @retval EFI_ALREADY_STARTED   NotifyFunction is not NULL, and a handler is already

+                                registered.

+  @retval EFI_INVALID_PARAMETER NotifyFunction is NULL, and a handler was not

+                                previously registered.

+  @retval EFI_DEVICE_ERROR      The timer handler could not be registered.

+

+**/

+EFI_STATUS

+EFIAPI

+TimerDriverRegisterHandler (

+  IN EFI_TIMER_ARCH_PROTOCOL  *This,

+  IN EFI_TIMER_NOTIFY         NotifyFunction

+  )

+{

+  if ((NotifyFunction == NULL) && (mTimerNotifyFunction == NULL)) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  if ((NotifyFunction != NULL) && (mTimerNotifyFunction != NULL)) {

+    return EFI_ALREADY_STARTED;

+  }

+

+  mTimerNotifyFunction = NotifyFunction;

+

+  return EFI_SUCCESS;

+}

+

+/**

+

+  This function adjusts the period of timer interrupts to the value specified 

+  by TimerPeriod.  If the timer period is updated, then the selected timer 

+  period is stored in EFI_TIMER.TimerPeriod, and EFI_SUCCESS is returned.  If 

+  the timer hardware is not programmable, then EFI_UNSUPPORTED is returned.  

+  If an error occurs while attempting to update the timer period, then the 

+  timer hardware will be put back in its state prior to this call, and 

+  EFI_DEVICE_ERROR is returned.  If TimerPeriod is 0, then the timer interrupt 

+  is disabled.  This is not the same as disabling the CPU's interrupts.  

+  Instead, it must either turn off the timer hardware, or it must adjust the 

+  interrupt controller so that a CPU interrupt is not generated when the timer 

+  interrupt fires. 

+

+  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.

+  @param  TimerPeriod      The rate to program the timer interrupt in 100 nS units. If

+                           the timer hardware is not programmable, then EFI_UNSUPPORTED is

+                           returned. If the timer is programmable, then the timer period

+                           will be rounded up to the nearest timer period that is supported

+                           by the timer hardware. If TimerPeriod is set to 0, then the

+                           timer interrupts will be disabled.

+

+

+  @retval EFI_SUCCESS           The timer period was changed.

+  @retval EFI_UNSUPPORTED       The platform cannot change the period of the timer interrupt.

+  @retval EFI_DEVICE_ERROR      The timer period could not be changed due to a device error.

+

+**/

+EFI_STATUS

+EFIAPI

+TimerDriverSetTimerPeriod (

+  IN EFI_TIMER_ARCH_PROTOCOL  *This,

+  IN UINT64                   TimerPeriod

+  )

+{

+  EFI_STATUS  Status;

+  UINT64      TimerCount;

+  INT32       LoadValue;

+  

+  if (TimerPeriod == 0) {

+    // Turn off GPTIMER3

+    MmioWrite32 (TCLR, TCLR_ST_OFF);

+    

+    Status = gInterrupt->DisableInterruptSource(gInterrupt, gVector);    

+  } else {  

+    // Calculate required timer count

+    TimerCount = DivU64x32(TimerPeriod * 100, PcdGet32(PcdEmbeddedPerformanceCounterPeriodInNanoseconds));

+

+    // Set GPTIMER3 Load register

+    LoadValue = (INT32) -TimerCount;

+    MmioWrite32 (TLDR, LoadValue);

+    MmioWrite32 (TCRR, LoadValue);

+

+    // Enable Overflow interrupt

+    MmioWrite32 (TIER, TIER_TCAR_IT_DISABLE | TIER_OVF_IT_ENABLE | TIER_MAT_IT_DISABLE);

+

+    // Turn on GPTIMER3, it will reload at overflow

+    MmioWrite32 (TCLR, TCLR_AR_AUTORELOAD | TCLR_ST_ON);

+

+    Status = gInterrupt->EnableInterruptSource(gInterrupt, gVector);    

+  }

+

+  //

+  // Save the new timer period

+  //

+  mTimerPeriod = TimerPeriod;

+  return Status;

+}

+

+

+/**

+  This function retrieves the period of timer interrupts in 100 ns units, 

+  returns that value in TimerPeriod, and returns EFI_SUCCESS.  If TimerPeriod 

+  is NULL, then EFI_INVALID_PARAMETER is returned.  If a TimerPeriod of 0 is 

+  returned, then the timer is currently disabled.

+

+  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.

+  @param  TimerPeriod      A pointer to the timer period to retrieve in 100 ns units. If

+                           0 is returned, then the timer is currently disabled.

+

+

+  @retval EFI_SUCCESS           The timer period was returned in TimerPeriod.

+  @retval EFI_INVALID_PARAMETER TimerPeriod is NULL.

+

+**/

+EFI_STATUS

+EFIAPI

+TimerDriverGetTimerPeriod (

+  IN EFI_TIMER_ARCH_PROTOCOL   *This,

+  OUT UINT64                   *TimerPeriod

+  )

+{

+  if (TimerPeriod == NULL) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  *TimerPeriod = mTimerPeriod;

+  return EFI_SUCCESS;

+}

+

+/**

+  This function generates a soft timer interrupt. If the platform does not support soft 

+  timer interrupts, then EFI_UNSUPPORTED is returned. Otherwise, EFI_SUCCESS is returned. 

+  If a handler has been registered through the EFI_TIMER_ARCH_PROTOCOL.RegisterHandler() 

+  service, then a soft timer interrupt will be generated. If the timer interrupt is 

+  enabled when this service is called, then the registered handler will be invoked. The 

+  registered handler should not be able to distinguish a hardware-generated timer 

+  interrupt from a software-generated timer interrupt.

+

+  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.

+

+  @retval EFI_SUCCESS           The soft timer interrupt was generated.

+  @retval EFI_UNSUPPORTED       The platform does not support the generation of soft timer interrupts.

+

+**/

+EFI_STATUS

+EFIAPI

+TimerDriverGenerateSoftInterrupt (

+  IN EFI_TIMER_ARCH_PROTOCOL  *This

+  )

+{

+  return EFI_UNSUPPORTED;

+}

+

+

+/**

+  Interface stucture for the Timer Architectural Protocol.

+

+  @par Protocol Description:

+  This protocol provides the services to initialize a periodic timer 

+  interrupt, and to register a handler that is called each time the timer

+  interrupt fires.  It may also provide a service to adjust the rate of the

+  periodic timer interrupt.  When a timer interrupt occurs, the handler is 

+  passed the amount of time that has passed since the previous timer 

+  interrupt.

+

+  @param RegisterHandler

+  Registers a handler that will be called each time the 

+  timer interrupt fires.  TimerPeriod defines the minimum 

+  time between timer interrupts, so TimerPeriod will also 

+  be the minimum time between calls to the registered 

+  handler.

+

+  @param SetTimerPeriod

+  Sets the period of the timer interrupt in 100 nS units.  

+  This function is optional, and may return EFI_UNSUPPORTED.  

+  If this function is supported, then the timer period will 

+  be rounded up to the nearest supported timer period.

+

+

+  @param GetTimerPeriod

+  Retrieves the period of the timer interrupt in 100 nS units.

+

+  @param GenerateSoftInterrupt

+  Generates a soft timer interrupt that simulates the firing of 

+  the timer interrupt. This service can be used to invoke the   registered handler if the timer interrupt has been masked for 

+  a period of time.

+

+**/

+EFI_TIMER_ARCH_PROTOCOL   gTimer = {

+  TimerDriverRegisterHandler,

+  TimerDriverSetTimerPeriod,

+  TimerDriverGetTimerPeriod,

+  TimerDriverGenerateSoftInterrupt

+};

+

+

+/**

+  Initialize the state information for the Timer Architectural Protocol and

+  the Timer Debug support protocol that allows the debugger to break into a

+  running program.

+

+  @param  ImageHandle   of the loaded driver

+  @param  SystemTable   Pointer to the System Table

+

+  @retval EFI_SUCCESS           Protocol registered

+  @retval EFI_OUT_OF_RESOURCES  Cannot allocate protocol data structure

+  @retval EFI_DEVICE_ERROR      Hardware problems

+

+**/

+EFI_STATUS

+EFIAPI

+TimerInitialize (

+  IN EFI_HANDLE         ImageHandle,

+  IN EFI_SYSTEM_TABLE   *SystemTable

+  )

+{

+  EFI_HANDLE  Handle = NULL;

+  EFI_STATUS  Status;

+  UINT32      TimerBaseAddress;

+

+  // Find the interrupt controller protocol.  ASSERT if not found.

+  Status = gBS->LocateProtocol (&gHardwareInterruptProtocolGuid, NULL, (VOID **)&gInterrupt);

+  ASSERT_EFI_ERROR (Status);

+

+  // Set up the timer registers

+  TimerBaseAddress = TimerBase (FixedPcdGet32(PcdOmap35xxArchTimer));

+  TISR = TimerBaseAddress + GPTIMER_TISR;

+  TCLR = TimerBaseAddress + GPTIMER_TCLR;

+  TLDR = TimerBaseAddress + GPTIMER_TLDR;

+  TCRR = TimerBaseAddress + GPTIMER_TCRR;

+  TIER = TimerBaseAddress + GPTIMER_TIER;

+

+  // Disable the timer

+  Status = TimerDriverSetTimerPeriod (&gTimer, 0);

+  ASSERT_EFI_ERROR (Status);

+

+  // Install interrupt handler

+  gVector = InterruptVectorForTimer (FixedPcdGet32(PcdOmap35xxArchTimer));

+  Status = gInterrupt->RegisterInterruptSource (gInterrupt, gVector, TimerInterruptHandler);

+  ASSERT_EFI_ERROR (Status);

+

+  // Turn on the functional clock for Timer

+  MmioOr32 (CM_FCLKEN_PER, CM_FCLKEN_PER_EN_GPT3_ENABLE);

+

+  // Set up default timer

+  Status = TimerDriverSetTimerPeriod (&gTimer, FixedPcdGet32(PcdTimerPeriod));

+  ASSERT_EFI_ERROR (Status);

+

+  // Install the Timer Architectural Protocol onto a new handle

+  Status = gBS->InstallMultipleProtocolInterfaces (

+                  &Handle,

+                  &gEfiTimerArchProtocolGuid,      &gTimer,

+                  NULL

+                  );

+  ASSERT_EFI_ERROR(Status);

+

+  return Status;

+}

+

diff --git a/Omap35xxPkg/TimerDxe/TimerDxe.inf b/Omap35xxPkg/TimerDxe/TimerDxe.inf
index 6cfab775..2c5a2f7a 100644
--- a/Omap35xxPkg/TimerDxe/TimerDxe.inf
+++ b/Omap35xxPkg/TimerDxe/TimerDxe.inf
@@ -1,57 +1,57 @@
-#/** @file
-#  
-#    Component description file for Timer module
-#  
-#  Copyright (c) 2009, Apple Inc. All rights reserved.<BR>
-#  This program and the accompanying materials
-#  are licensed and made available under the terms and conditions of the BSD License
-#  which accompanies this distribution.  The full text of the license may be found at
-#  http://opensource.org/licenses/bsd-license.php
-#  
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#  
-#**/
-
-[Defines]
-  INF_VERSION                    = 0x00010005
-  BASE_NAME                      = BeagleBoardTimerDxe
-  FILE_GUID                      = 6ddbf08b-cfc9-43cc-9e81-0784ba312ca0
-  MODULE_TYPE                    = DXE_DRIVER
-  VERSION_STRING                 = 1.0
-
-  ENTRY_POINT                    = TimerInitialize
-
-[Sources.common]
-  Timer.c
-
-[Packages]
-  Omap35xxPkg/Omap35xxPkg.dec
-  MdePkg/MdePkg.dec
-  EmbeddedPkg/EmbeddedPkg.dec
-  ArmPkg/ArmPkg.dec
-
-[LibraryClasses]
-  BaseLib
-  UefiRuntimeServicesTableLib
-  UefiLib
-  UefiBootServicesTableLib
-  BaseMemoryLib
-  DebugLib
-  UefiDriverEntryPoint
-  IoLib
-  OmapLib
-
-[Guids]
-
-[Protocols]
-  gEfiTimerArchProtocolGuid  
-  gHardwareInterruptProtocolGuid
-
-[Pcd.common]
-  gEmbeddedTokenSpaceGuid.PcdTimerPeriod
-  gEmbeddedTokenSpaceGuid.PcdEmbeddedPerformanceCounterPeriodInNanoseconds
-  gOmap35xxTokenSpaceGuid.PcdOmap35xxArchTimer
-
-[Depex]
-  gHardwareInterruptProtocolGuid
\ No newline at end of file
+#/** @file

+#  

+#    Component description file for Timer module

+#  

+#  Copyright (c) 2009, Apple Inc. All rights reserved.<BR>

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution.  The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#  

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = BeagleBoardTimerDxe

+  FILE_GUID                      = 6ddbf08b-cfc9-43cc-9e81-0784ba312ca0

+  MODULE_TYPE                    = DXE_DRIVER

+  VERSION_STRING                 = 1.0

+

+  ENTRY_POINT                    = TimerInitialize

+

+[Sources.common]

+  Timer.c

+

+[Packages]

+  Omap35xxPkg/Omap35xxPkg.dec

+  MdePkg/MdePkg.dec

+  EmbeddedPkg/EmbeddedPkg.dec

+  ArmPkg/ArmPkg.dec

+

+[LibraryClasses]

+  BaseLib

+  UefiRuntimeServicesTableLib

+  UefiLib

+  UefiBootServicesTableLib

+  BaseMemoryLib

+  DebugLib

+  UefiDriverEntryPoint

+  IoLib

+  OmapLib

+

+[Guids]

+

+[Protocols]

+  gEfiTimerArchProtocolGuid  

+  gHardwareInterruptProtocolGuid

+

+[Pcd.common]

+  gEmbeddedTokenSpaceGuid.PcdTimerPeriod

+  gEmbeddedTokenSpaceGuid.PcdEmbeddedPerformanceCounterPeriodInNanoseconds

+  gOmap35xxTokenSpaceGuid.PcdOmap35xxArchTimer

+

+[Depex]

+  gHardwareInterruptProtocolGuid
\ No newline at end of file
diff --git a/Omap44xxPkg/Include/Omap4430/Omap4430.h b/Omap44xxPkg/Include/Omap4430/Omap4430.h
index c127398c..f59eec4d 100644
--- a/Omap44xxPkg/Include/Omap4430/Omap4430.h
+++ b/Omap44xxPkg/Include/Omap4430/Omap4430.h
@@ -27,14 +27,5 @@
 #include "Omap4430Gpmc.h"
 #include "Omap4430Dma.h"
 
-
-//CONTROL_PBIAS_LITE
-#define CONTROL_PBIAS_LITE    0x4a100600
-#define PBIASVMODE3V          BIT21
-#define PBIASLITEPWRDNZ       BIT22
-#define PBIASVMODEERR         BIT23
-#define PBIASHIZ              BIT25
-#define PBIASPWRDNZ           BIT26
-
 #endif // __OMAP4430_H__
 
diff --git a/Omap44xxPkg/Include/Omap4430/Omap4430Gpio.h b/Omap44xxPkg/Include/Omap4430/Omap4430Gpio.h
index 035ea225..dcaa74cc 100644
--- a/Omap44xxPkg/Include/Omap4430/Omap4430Gpio.h
+++ b/Omap44xxPkg/Include/Omap4430/Omap4430Gpio.h
@@ -15,13 +15,14 @@
 #ifndef __OMAP4430GPIO_H__
 #define __OMAP4430GPIO_H__
 
-#define GPIO1_BASE (0x48310000)
-#define GPIO2_BASE (0x49050000)
-#define GPIO3_BASE (0x49052000)
-#define GPIO4_BASE (0x49054000)
-#define GPIO5_BASE (0x49056000)
-#define GPIO6_BASE (0x49058000)
-
+#define GPIO1_BASE (0x4A310000)
+#define GPIO2_BASE (0x48055000)
+#define GPIO3_BASE (0x48057000)
+#define GPIO4_BASE (0x48059000)
+#define GPIO5_BASE (0x4805B000)
+#define GPIO6_BASE (0x4805D000)
+
+// TODO: review below defines, offsets changed from omap3 to omap4
 #define GPIO_SYSCONFIG        (0x0010)
 #define GPIO_SYSSTATUS        (0x0014)
 #define GPIO_IRQSTATUS1       (0x0018)
@@ -30,8 +31,8 @@
 #define GPIO_IRQSTATUS2       (0x0028)
 #define GPIO_IRQENABLE2       (0x002C)
 #define GPIO_CTRL             (0x0030)
-#define GPIO_OE               (0x0034)
-#define GPIO_DATAIN           (0x0038)
+#define GPIO_OE               (0x0134)
+#define GPIO_DATAIN           (0x0138)
 #define GPIO_DATAOUT          (0x003C)
 #define GPIO_LEVELDETECT0     (0x0040)
 #define GPIO_LEVELDETECT1     (0x0044)
@@ -45,8 +46,8 @@
 #define GPIO_SETIRQENABLE2    (0x0074)
 #define GPIO_CLEARWKUENA      (0x0080)
 #define GPIO_SETWKUENA        (0x0084)
-#define GPIO_CLEARDATAOUT     (0x0090)
-#define GPIO_SETDATAOUT       (0x0094)
+#define GPIO_CLEARDATAOUT     (0x0190)
+#define GPIO_SETDATAOUT       (0x0194)
 
 #define GPIO_SYSCONFIG_IDLEMODE_MASK      (3UL << 3)
 #define GPIO_SYSCONFIG_IDLEMODE_FORCE     (0UL << 3)
diff --git a/Omap44xxPkg/Include/Omap4430/Omap4430PadConfiguration.h b/Omap44xxPkg/Include/Omap4430/Omap4430PadConfiguration.h
index 8e6473cf..449e9966 100644
--- a/Omap44xxPkg/Include/Omap4430/Omap4430PadConfiguration.h
+++ b/Omap44xxPkg/Include/Omap4430/Omap4430PadConfiguration.h
@@ -15,289 +15,320 @@
 #ifndef __OMAP4430_PAD_CONFIGURATION_H__
 #define __OMAP4430_PAD_CONFIGURATION_H__
 
-#define SYSTEM_CONTROL_MODULE_BASE  0x48002000
+#define OMAP4430_CONTROL_MODULE_CORE_BASE 0x4A100000
+#define OMAP4430_CONTROL_MODULE_WKUP_BASE 0x4A31E000
 
-//Pin definition
-#define SDRC_D0             (SYSTEM_CONTROL_MODULE_BASE + 0x030)
-#define SDRC_D1             (SYSTEM_CONTROL_MODULE_BASE + 0x032)
-#define SDRC_D2             (SYSTEM_CONTROL_MODULE_BASE + 0x034)
-#define SDRC_D3             (SYSTEM_CONTROL_MODULE_BASE + 0x036)
-#define SDRC_D4             (SYSTEM_CONTROL_MODULE_BASE + 0x038)
-#define SDRC_D5             (SYSTEM_CONTROL_MODULE_BASE + 0x03A)
-#define SDRC_D6             (SYSTEM_CONTROL_MODULE_BASE + 0x03C)
-#define SDRC_D7             (SYSTEM_CONTROL_MODULE_BASE + 0x03E)
-#define SDRC_D8             (SYSTEM_CONTROL_MODULE_BASE + 0x040)
-#define SDRC_D9             (SYSTEM_CONTROL_MODULE_BASE + 0x042)
-#define SDRC_D10            (SYSTEM_CONTROL_MODULE_BASE + 0x044)
-#define SDRC_D11            (SYSTEM_CONTROL_MODULE_BASE + 0x046)
-#define SDRC_D12            (SYSTEM_CONTROL_MODULE_BASE + 0x048)
-#define SDRC_D13            (SYSTEM_CONTROL_MODULE_BASE + 0x04A)
-#define SDRC_D14            (SYSTEM_CONTROL_MODULE_BASE + 0x04C)
-#define SDRC_D15            (SYSTEM_CONTROL_MODULE_BASE + 0x04E)
-#define SDRC_D16            (SYSTEM_CONTROL_MODULE_BASE + 0x050)
-#define SDRC_D17            (SYSTEM_CONTROL_MODULE_BASE + 0x052)
-#define SDRC_D18            (SYSTEM_CONTROL_MODULE_BASE + 0x054)
-#define SDRC_D19            (SYSTEM_CONTROL_MODULE_BASE + 0x056)
-#define SDRC_D20            (SYSTEM_CONTROL_MODULE_BASE + 0x058)
-#define SDRC_D21            (SYSTEM_CONTROL_MODULE_BASE + 0x05A)
-#define SDRC_D22            (SYSTEM_CONTROL_MODULE_BASE + 0x05C)
-#define SDRC_D23            (SYSTEM_CONTROL_MODULE_BASE + 0x05E)
-#define SDRC_D24            (SYSTEM_CONTROL_MODULE_BASE + 0x060)
-#define SDRC_D25            (SYSTEM_CONTROL_MODULE_BASE + 0x062)
-#define SDRC_D26            (SYSTEM_CONTROL_MODULE_BASE + 0x064)
-#define SDRC_D27            (SYSTEM_CONTROL_MODULE_BASE + 0x066)
-#define SDRC_D28            (SYSTEM_CONTROL_MODULE_BASE + 0x068)
-#define SDRC_D29            (SYSTEM_CONTROL_MODULE_BASE + 0x06A)
-#define SDRC_D30            (SYSTEM_CONTROL_MODULE_BASE + 0x06C)
-#define SDRC_D31            (SYSTEM_CONTROL_MODULE_BASE + 0x06E)
-#define SDRC_CLK            (SYSTEM_CONTROL_MODULE_BASE + 0x070)
-#define SDRC_DQS0           (SYSTEM_CONTROL_MODULE_BASE + 0x072)
-#define SDRC_CKE0           (SYSTEM_CONTROL_MODULE_BASE + 0x262)
-#define SDRC_CKE1           (SYSTEM_CONTROL_MODULE_BASE + 0x264)
-#define SDRC_DQS1           (SYSTEM_CONTROL_MODULE_BASE + 0x074)
-#define SDRC_DQS2           (SYSTEM_CONTROL_MODULE_BASE + 0x076)
-#define SDRC_DQS3           (SYSTEM_CONTROL_MODULE_BASE + 0x078)
-#define GPMC_A1             (SYSTEM_CONTROL_MODULE_BASE + 0x07A)
-#define GPMC_A2             (SYSTEM_CONTROL_MODULE_BASE + 0x07C)
-#define GPMC_A3             (SYSTEM_CONTROL_MODULE_BASE + 0x07E)
-#define GPMC_A4             (SYSTEM_CONTROL_MODULE_BASE + 0x080)
-#define GPMC_A5             (SYSTEM_CONTROL_MODULE_BASE + 0x082)
-#define GPMC_A6             (SYSTEM_CONTROL_MODULE_BASE + 0x084)
-#define GPMC_A7             (SYSTEM_CONTROL_MODULE_BASE + 0x086)
-#define GPMC_A8             (SYSTEM_CONTROL_MODULE_BASE + 0x088)
-#define GPMC_A9             (SYSTEM_CONTROL_MODULE_BASE + 0x08A)
-#define GPMC_A10            (SYSTEM_CONTROL_MODULE_BASE + 0x08C)
-#define GPMC_D0             (SYSTEM_CONTROL_MODULE_BASE + 0x08E)
-#define GPMC_D1             (SYSTEM_CONTROL_MODULE_BASE + 0x090)
-#define GPMC_D2             (SYSTEM_CONTROL_MODULE_BASE + 0x092)
-#define GPMC_D3             (SYSTEM_CONTROL_MODULE_BASE + 0x094)
-#define GPMC_D4             (SYSTEM_CONTROL_MODULE_BASE + 0x096)
-#define GPMC_D5             (SYSTEM_CONTROL_MODULE_BASE + 0x098)
-#define GPMC_D6             (SYSTEM_CONTROL_MODULE_BASE + 0x09A)
-#define GPMC_D7             (SYSTEM_CONTROL_MODULE_BASE + 0x09C)
-#define GPMC_D8             (SYSTEM_CONTROL_MODULE_BASE + 0x09E)
-#define GPMC_D9             (SYSTEM_CONTROL_MODULE_BASE + 0x0A0)
-#define GPMC_D10            (SYSTEM_CONTROL_MODULE_BASE + 0x0A2)
-#define GPMC_D11            (SYSTEM_CONTROL_MODULE_BASE + 0x0A4)
-#define GPMC_D12            (SYSTEM_CONTROL_MODULE_BASE + 0x0A6)
-#define GPMC_D13            (SYSTEM_CONTROL_MODULE_BASE + 0x0A8)
-#define GPMC_D14            (SYSTEM_CONTROL_MODULE_BASE + 0x0AA)
-#define GPMC_D15            (SYSTEM_CONTROL_MODULE_BASE + 0x0AC)
-#define GPMC_NCS0           (SYSTEM_CONTROL_MODULE_BASE + 0x0AE)
-#define GPMC_NCS1           (SYSTEM_CONTROL_MODULE_BASE + 0x0B0)
-#define GPMC_NCS2           (SYSTEM_CONTROL_MODULE_BASE + 0x0B2)
-#define GPMC_NCS3           (SYSTEM_CONTROL_MODULE_BASE + 0x0B4)
-#define GPMC_NCS4           (SYSTEM_CONTROL_MODULE_BASE + 0x0B6)
-#define GPMC_NCS5           (SYSTEM_CONTROL_MODULE_BASE + 0x0B8)
-#define GPMC_NCS6           (SYSTEM_CONTROL_MODULE_BASE + 0x0BA)
-#define GPMC_NCS7           (SYSTEM_CONTROL_MODULE_BASE + 0x0BC)
-#define GPMC_CLK            (SYSTEM_CONTROL_MODULE_BASE + 0x0BE)
-#define GPMC_NADV_ALE       (SYSTEM_CONTROL_MODULE_BASE + 0x0C0)
-#define GPMC_NOE            (SYSTEM_CONTROL_MODULE_BASE + 0x0C2)
-#define GPMC_NWE            (SYSTEM_CONTROL_MODULE_BASE + 0x0C4)
-#define GPMC_NBE0_CLE       (SYSTEM_CONTROL_MODULE_BASE + 0x0C6)
-#define GPMC_NBE1           (SYSTEM_CONTROL_MODULE_BASE + 0x0C8)
-#define GPMC_NWP            (SYSTEM_CONTROL_MODULE_BASE + 0x0CA)
-#define GPMC_WAIT0          (SYSTEM_CONTROL_MODULE_BASE + 0x0CC)
-#define GPMC_WAIT1          (SYSTEM_CONTROL_MODULE_BASE + 0x0CE)
-#define GPMC_WAIT2          (SYSTEM_CONTROL_MODULE_BASE + 0x0D0)
-#define GPMC_WAIT3          (SYSTEM_CONTROL_MODULE_BASE + 0x0D2)
-#define DSS_PCLK            (SYSTEM_CONTROL_MODULE_BASE + 0x0D4)
-#define DSS_HSYNC           (SYSTEM_CONTROL_MODULE_BASE + 0x0D6)
-#define DSS_PSYNC           (SYSTEM_CONTROL_MODULE_BASE + 0x0D8)
-#define DSS_ACBIAS          (SYSTEM_CONTROL_MODULE_BASE + 0x0DA)
-#define DSS_DATA0           (SYSTEM_CONTROL_MODULE_BASE + 0x0DC)
-#define DSS_DATA1           (SYSTEM_CONTROL_MODULE_BASE + 0x0DE)
-#define DSS_DATA2           (SYSTEM_CONTROL_MODULE_BASE + 0x0E0)
-#define DSS_DATA3           (SYSTEM_CONTROL_MODULE_BASE + 0x0E2)
-#define DSS_DATA4           (SYSTEM_CONTROL_MODULE_BASE + 0x0E4)
-#define DSS_DATA5           (SYSTEM_CONTROL_MODULE_BASE + 0x0E6)
-#define DSS_DATA6           (SYSTEM_CONTROL_MODULE_BASE + 0x0E8)
-#define DSS_DATA7           (SYSTEM_CONTROL_MODULE_BASE + 0x0EA)
-#define DSS_DATA8           (SYSTEM_CONTROL_MODULE_BASE + 0x0EC)
-#define DSS_DATA9           (SYSTEM_CONTROL_MODULE_BASE + 0x0EE)
-#define DSS_DATA10          (SYSTEM_CONTROL_MODULE_BASE + 0x0F0)
-#define DSS_DATA11          (SYSTEM_CONTROL_MODULE_BASE + 0x0F2)
-#define DSS_DATA12          (SYSTEM_CONTROL_MODULE_BASE + 0x0F4)
-#define DSS_DATA13          (SYSTEM_CONTROL_MODULE_BASE + 0x0F6)
-#define DSS_DATA14          (SYSTEM_CONTROL_MODULE_BASE + 0x0F8)
-#define DSS_DATA15          (SYSTEM_CONTROL_MODULE_BASE + 0x0FA)
-#define DSS_DATA16          (SYSTEM_CONTROL_MODULE_BASE + 0x0FC)
-#define DSS_DATA17          (SYSTEM_CONTROL_MODULE_BASE + 0x0FE)
-#define DSS_DATA18          (SYSTEM_CONTROL_MODULE_BASE + 0x100)
-#define DSS_DATA19          (SYSTEM_CONTROL_MODULE_BASE + 0x102)
-#define DSS_DATA20          (SYSTEM_CONTROL_MODULE_BASE + 0x104)
-#define DSS_DATA21          (SYSTEM_CONTROL_MODULE_BASE + 0x106)
-#define DSS_DATA22          (SYSTEM_CONTROL_MODULE_BASE + 0x108)
-#define DSS_DATA23          (SYSTEM_CONTROL_MODULE_BASE + 0x10A)
-#define CAM_HS              (SYSTEM_CONTROL_MODULE_BASE + 0x10C)
-#define CAM_VS              (SYSTEM_CONTROL_MODULE_BASE + 0x10E)
-#define CAM_XCLKA           (SYSTEM_CONTROL_MODULE_BASE + 0x110)
-#define CAM_PCLK            (SYSTEM_CONTROL_MODULE_BASE + 0x112)
-#define CAM_FLD             (SYSTEM_CONTROL_MODULE_BASE + 0x114)
-#define CAM_D0              (SYSTEM_CONTROL_MODULE_BASE + 0x116)
-#define CAM_D1              (SYSTEM_CONTROL_MODULE_BASE + 0x118)
-#define CAM_D2              (SYSTEM_CONTROL_MODULE_BASE + 0x11A)
-#define CAM_D3              (SYSTEM_CONTROL_MODULE_BASE + 0x11C)
-#define CAM_D4              (SYSTEM_CONTROL_MODULE_BASE + 0x11E)
-#define CAM_D5              (SYSTEM_CONTROL_MODULE_BASE + 0x120)
-#define CAM_D6              (SYSTEM_CONTROL_MODULE_BASE + 0x122)
-#define CAM_D7              (SYSTEM_CONTROL_MODULE_BASE + 0x124)
-#define CAM_D8              (SYSTEM_CONTROL_MODULE_BASE + 0x126)
-#define CAM_D9              (SYSTEM_CONTROL_MODULE_BASE + 0x128)
-#define CAM_D10             (SYSTEM_CONTROL_MODULE_BASE + 0x12A)
-#define CAM_D11             (SYSTEM_CONTROL_MODULE_BASE + 0x12C)
-#define CAM_XCLKB           (SYSTEM_CONTROL_MODULE_BASE + 0x12E)
-#define CAM_WEN             (SYSTEM_CONTROL_MODULE_BASE + 0x130)
-#define CAM_STROBE          (SYSTEM_CONTROL_MODULE_BASE + 0x132)
-#define CSI2_DX0            (SYSTEM_CONTROL_MODULE_BASE + 0x134)
-#define CSI2_DY0            (SYSTEM_CONTROL_MODULE_BASE + 0x136)
-#define CSI2_DX1            (SYSTEM_CONTROL_MODULE_BASE + 0x138)
-#define CSI2_DY1            (SYSTEM_CONTROL_MODULE_BASE + 0x13A)
-#define MCBSP2_FSX          (SYSTEM_CONTROL_MODULE_BASE + 0x13C)
-#define MCBSP2_CLKX         (SYSTEM_CONTROL_MODULE_BASE + 0x13E)
-#define MCBSP2_DR           (SYSTEM_CONTROL_MODULE_BASE + 0x140)
-#define MCBSP2_DX           (SYSTEM_CONTROL_MODULE_BASE + 0x142)
-#define MMC1_CLK            (SYSTEM_CONTROL_MODULE_BASE + 0x144)
-#define MMC1_CMD            (SYSTEM_CONTROL_MODULE_BASE + 0x146)
-#define MMC1_DAT0           (SYSTEM_CONTROL_MODULE_BASE + 0x148)
-#define MMC1_DAT1           (SYSTEM_CONTROL_MODULE_BASE + 0x14A)
-#define MMC1_DAT2           (SYSTEM_CONTROL_MODULE_BASE + 0x14C)
-#define MMC1_DAT3           (SYSTEM_CONTROL_MODULE_BASE + 0x14E)
-#define MMC1_DAT4           (SYSTEM_CONTROL_MODULE_BASE + 0x150)
-#define MMC1_DAT5           (SYSTEM_CONTROL_MODULE_BASE + 0x152)
-#define MMC1_DAT6           (SYSTEM_CONTROL_MODULE_BASE + 0x154)
-#define MMC1_DAT7           (SYSTEM_CONTROL_MODULE_BASE + 0x156)
-#define MMC2_CLK            (SYSTEM_CONTROL_MODULE_BASE + 0x158)
-#define MMC2_CMD            (SYSTEM_CONTROL_MODULE_BASE + 0x15A)
-#define MMC2_DAT0           (SYSTEM_CONTROL_MODULE_BASE + 0x15C)
-#define MMC2_DAT1           (SYSTEM_CONTROL_MODULE_BASE + 0x15E)
-#define MMC2_DAT2           (SYSTEM_CONTROL_MODULE_BASE + 0x160)
-#define MMC2_DAT3           (SYSTEM_CONTROL_MODULE_BASE + 0x162)
-#define MMC2_DAT4           (SYSTEM_CONTROL_MODULE_BASE + 0x164)
-#define MMC2_DAT5           (SYSTEM_CONTROL_MODULE_BASE + 0x166)
-#define MMC2_DAT6           (SYSTEM_CONTROL_MODULE_BASE + 0x168)
-#define MMC2_DAT7           (SYSTEM_CONTROL_MODULE_BASE + 0x16A)
-#define MCBSP3_DX           (SYSTEM_CONTROL_MODULE_BASE + 0x16C)
-#define MCBSP3_DR           (SYSTEM_CONTROL_MODULE_BASE + 0x16E)
-#define MCBSP3_CLKX         (SYSTEM_CONTROL_MODULE_BASE + 0x170)
-#define MCBSP3_FSX          (SYSTEM_CONTROL_MODULE_BASE + 0x172)
-#define UART2_CTS           (SYSTEM_CONTROL_MODULE_BASE + 0x174)
-#define UART2_RTS           (SYSTEM_CONTROL_MODULE_BASE + 0x176)
-#define UART2_TX            (SYSTEM_CONTROL_MODULE_BASE + 0x178)
-#define UART2_RX            (SYSTEM_CONTROL_MODULE_BASE + 0x17A)
-#define UART1_TX            (SYSTEM_CONTROL_MODULE_BASE + 0x17C)
-#define UART1_RTS           (SYSTEM_CONTROL_MODULE_BASE + 0x17E)
-#define UART1_CTS           (SYSTEM_CONTROL_MODULE_BASE + 0x180)
-#define UART1_RX            (SYSTEM_CONTROL_MODULE_BASE + 0x182)
-#define MCBSP4_CLKX         (SYSTEM_CONTROL_MODULE_BASE + 0x184)
-#define MCBSP4_DR           (SYSTEM_CONTROL_MODULE_BASE + 0x186)
-#define MCBSP4_DX           (SYSTEM_CONTROL_MODULE_BASE + 0x188)
-#define MCBSP4_FSX          (SYSTEM_CONTROL_MODULE_BASE + 0x18A)
-#define MCBSP1_CLKR         (SYSTEM_CONTROL_MODULE_BASE + 0x18C)
-#define MCBSP1_FSR          (SYSTEM_CONTROL_MODULE_BASE + 0x18E)
-#define MCBSP1_DX           (SYSTEM_CONTROL_MODULE_BASE + 0x190)
-#define MCBSP1_DR           (SYSTEM_CONTROL_MODULE_BASE + 0x192)
-#define MCBSP1_CLKS         (SYSTEM_CONTROL_MODULE_BASE + 0x194)
-#define MCBSP1_FSX          (SYSTEM_CONTROL_MODULE_BASE + 0x196)
-#define MCBSP1_CLKX         (SYSTEM_CONTROL_MODULE_BASE + 0x198)
-#define UART3_CTS_RCTX      (SYSTEM_CONTROL_MODULE_BASE + 0x19A)
-#define UART3_RTS_SD        (SYSTEM_CONTROL_MODULE_BASE + 0x19C)
-#define UART3_RX_IRRX       (SYSTEM_CONTROL_MODULE_BASE + 0x19E)
-#define UART3_TX_IRTX       (SYSTEM_CONTROL_MODULE_BASE + 0x1A0)
-#define HSUSB0_CLK          (SYSTEM_CONTROL_MODULE_BASE + 0x1A2)
-#define HSUSB0_STP          (SYSTEM_CONTROL_MODULE_BASE + 0x1A4)
-#define HSUSB0_DIR          (SYSTEM_CONTROL_MODULE_BASE + 0x1A6)
-#define HSUSB0_NXT          (SYSTEM_CONTROL_MODULE_BASE + 0x1A8)
-#define HSUSB0_DATA0        (SYSTEM_CONTROL_MODULE_BASE + 0x1AA)
-#define HSUSB0_DATA1        (SYSTEM_CONTROL_MODULE_BASE + 0x1AC)
-#define HSUSB0_DATA2        (SYSTEM_CONTROL_MODULE_BASE + 0x1AE)
-#define HSUSB0_DATA3        (SYSTEM_CONTROL_MODULE_BASE + 0x1B0)
-#define HSUSB0_DATA4        (SYSTEM_CONTROL_MODULE_BASE + 0x1B2)
-#define HSUSB0_DATA5        (SYSTEM_CONTROL_MODULE_BASE + 0x1B4)
-#define HSUSB0_DATA6        (SYSTEM_CONTROL_MODULE_BASE + 0x1B6)
-#define HSUSB0_DATA7        (SYSTEM_CONTROL_MODULE_BASE + 0x1B8)
-#define I2C1_SCL            (SYSTEM_CONTROL_MODULE_BASE + 0x1BA)
-#define I2C1_SDA            (SYSTEM_CONTROL_MODULE_BASE + 0x1BC)
-#define I2C2_SCL            (SYSTEM_CONTROL_MODULE_BASE + 0x1BE)
-#define I2C2_SDA            (SYSTEM_CONTROL_MODULE_BASE + 0x1C0)
-#define I2C3_SCL            (SYSTEM_CONTROL_MODULE_BASE + 0x1C2)
-#define I2C3_SDA            (SYSTEM_CONTROL_MODULE_BASE + 0x1C4)
-#define HDQ_SIO             (SYSTEM_CONTROL_MODULE_BASE + 0x1C6)
-#define MCSPI1_CLK          (SYSTEM_CONTROL_MODULE_BASE + 0x1C8)
-#define MCSPI1_SIMO         (SYSTEM_CONTROL_MODULE_BASE + 0x1CA)
-#define MCSPI1_SOMI         (SYSTEM_CONTROL_MODULE_BASE + 0x1CC)
-#define MCSPI1_CS0          (SYSTEM_CONTROL_MODULE_BASE + 0x1CE)
-#define MCSPI1_CS1          (SYSTEM_CONTROL_MODULE_BASE + 0x1D0)
-#define MCSPI1_CS2          (SYSTEM_CONTROL_MODULE_BASE + 0x1D2)
-#define MCSPI1_CS3          (SYSTEM_CONTROL_MODULE_BASE + 0x1D4)
-#define MCSPI2_CLK          (SYSTEM_CONTROL_MODULE_BASE + 0x1D6)
-#define MCSPI2_SIMO         (SYSTEM_CONTROL_MODULE_BASE + 0x1D8)
-#define MCSPI2_SOMI         (SYSTEM_CONTROL_MODULE_BASE + 0x1DA)
-#define MCSPI2_CS0          (SYSTEM_CONTROL_MODULE_BASE + 0x1DC)
-#define MCSPI2_CS1          (SYSTEM_CONTROL_MODULE_BASE + 0x1DE)
-#define SYS_NIRQ            (SYSTEM_CONTROL_MODULE_BASE + 0x1E0)
-#define SYS_CLKOUT2         (SYSTEM_CONTROL_MODULE_BASE + 0x1E2)
-#define ETK_CLK             (SYSTEM_CONTROL_MODULE_BASE + 0x5D8)
-#define ETK_CTL             (SYSTEM_CONTROL_MODULE_BASE + 0x5DA)
-#define ETK_D0              (SYSTEM_CONTROL_MODULE_BASE + 0x5DC)
-#define ETK_D1              (SYSTEM_CONTROL_MODULE_BASE + 0x5DE)
-#define ETK_D2              (SYSTEM_CONTROL_MODULE_BASE + 0x5E0)
-#define ETK_D3              (SYSTEM_CONTROL_MODULE_BASE + 0x5E2)
-#define ETK_D4              (SYSTEM_CONTROL_MODULE_BASE + 0x5E4)
-#define ETK_D5              (SYSTEM_CONTROL_MODULE_BASE + 0x5E6)
-#define ETK_D6              (SYSTEM_CONTROL_MODULE_BASE + 0x5E8)
-#define ETK_D7              (SYSTEM_CONTROL_MODULE_BASE + 0x5EA)
-#define ETK_D8              (SYSTEM_CONTROL_MODULE_BASE + 0x5EC)
-#define ETK_D9              (SYSTEM_CONTROL_MODULE_BASE + 0x5EE)
-#define ETK_D10             (SYSTEM_CONTROL_MODULE_BASE + 0x5F0)
-#define ETK_D11             (SYSTEM_CONTROL_MODULE_BASE + 0x5F2)
-#define ETK_D12             (SYSTEM_CONTROL_MODULE_BASE + 0x5F4)
-#define ETK_D13             (SYSTEM_CONTROL_MODULE_BASE + 0x5F6)
-#define ETK_D14             (SYSTEM_CONTROL_MODULE_BASE + 0x5F8)
-#define ETK_D15             (SYSTEM_CONTROL_MODULE_BASE + 0x5FA)
-#define SYS_BOOT0           (SYSTEM_CONTROL_MODULE_BASE + 0xA0A)
-#define SYS_BOOT1           (SYSTEM_CONTROL_MODULE_BASE + 0xA0C)
-#define SYS_BOOT3           (SYSTEM_CONTROL_MODULE_BASE + 0xA10)
-#define SYS_BOOT4           (SYSTEM_CONTROL_MODULE_BASE + 0xA12)
-#define SYS_BOOT5           (SYSTEM_CONTROL_MODULE_BASE + 0xA14)
-#define SYS_BOOT6           (SYSTEM_CONTROL_MODULE_BASE + 0xA16)
+#define CONTROL_WKUP_PAD1_FREF_CLK4_REQ	0x4A31E05A
 
-//Mux modes
-#define MUXMODE0            (0x0UL)
-#define MUXMODE1            (0x1UL)
-#define MUXMODE2            (0x2UL)
-#define MUXMODE3            (0x3UL)
-#define MUXMODE4            (0x4UL)
-#define MUXMODE5            (0x5UL)
-#define MUXMODE6            (0x6UL)
-#define MUXMODE7            (0x7UL)
+#ifdef CONFIG_OFF_PADCONF
+#define OFF_PD          (1 << 12)
+#define OFF_PU          (3 << 12)
+#define OFF_OUT_PTD     (0 << 10)
+#define OFF_OUT_PTU     (2 << 10)
+#define OFF_IN          (1 << 10)
+#define OFF_OUT         (0 << 10)
+#define OFF_EN          (1 << 9)
+#else
+#define OFF_PD          (0 << 12)
+#define OFF_PU          (0 << 12)
+#define OFF_OUT_PTD     (0 << 10)
+#define OFF_OUT_PTU     (0 << 10)
+#define OFF_IN          (0 << 10)
+#define OFF_OUT         (0 << 10)
+#define OFF_EN          (0 << 9)
+#endif
 
-//Pad configuration register.
-#define PAD_CONFIG_MASK      (0xFFFFUL)
-#define MUXMODE_OFFSET       0
-#define MUXMODE_MASK         (0x7UL << MUXMODE_OFFSET)
-#define PULL_CONFIG_OFFSET   3
-#define PULL_CONFIG_MASK     (0x3UL << PULL_CONFIG_OFFSET)
-#define INPUTENABLE_OFFSET   8
-#define INPUTENABLE_MASK     (0x1UL << INPUTENABLE_OFFSET)
-#define OFFMODE_VALUE_OFFSET 9
-#define OFFMODE_VALUE_MASK   (0x1FUL << OFFMODE_VALUE_OFFSET)
-#define WAKEUP_OFFSET        14
-#define WAKEUP_MASK          (0x2UL << WAKEUP_OFFSET)
+#define IEN             (1 << 8)
+#define IDIS            (0 << 8)
+#define PTU             (3 << 3)
+#define PTD             (1 << 3)
+#define EN              (1 << 3)
+#define DIS             (0 << 3)
 
-#define PULL_DOWN_SELECTED   ((0x0UL << 1) | BIT0)
-#define PULL_UP_SELECTED     (BIT1 | BIT0)
-#define PULL_DISABLED        (0x0UL << 0)
+#define M0              0
+#define M1              1
+#define M2              2
+#define M3              3
+#define M4              4
+#define M5              5
+#define M6              6
+#define M7              7
 
-#define OUTPUT               (0x0UL) //Pin is configured in output only mode.
-#define INPUT                (0x1UL) //Pin is configured in bi-directional mode.
+#define SAFE_MODE	M7
+
+#ifdef CONFIG_OFF_PADCONF
+#define OFF_IN_PD       (OFF_PD | OFF_IN | OFF_EN)
+#define OFF_IN_PU       (OFF_PU | OFF_IN | OFF_EN)
+#define OFF_OUT_PD      (OFF_OUT_PTD | OFF_OUT | OFF_EN)
+#define OFF_OUT_PU      (OFF_OUT_PTU | OFF_OUT | OFF_EN)
+#else
+#define OFF_IN_PD       0
+#define OFF_IN_PU       0
+#define OFF_OUT_PD      0
+#define OFF_OUT_PU      0
+#endif
+
+#define CORE_REVISION		0x0000
+#define CORE_HWINFO		0x0004
+#define CORE_SYSCONFIG		0x0010
+#define GPMC_AD0		0x0040
+#define GPMC_AD1		0x0042
+#define GPMC_AD2		0x0044
+#define GPMC_AD3		0x0046
+#define GPMC_AD4		0x0048
+#define GPMC_AD5		0x004A
+#define GPMC_AD6		0x004C
+#define GPMC_AD7		0x004E
+#define GPMC_AD8		0x0050
+#define GPMC_AD9		0x0052
+#define GPMC_AD10		0x0054
+#define GPMC_AD11		0x0056
+#define GPMC_AD12		0x0058
+#define GPMC_AD13		0x005A
+#define GPMC_AD14		0x005C
+#define GPMC_AD15		0x005E
+#define GPMC_A16		0x0060
+#define GPMC_A17		0x0062
+#define GPMC_A18		0x0064
+#define GPMC_A19		0x0066
+#define GPMC_A20		0x0068
+#define GPMC_A21		0x006A
+#define GPMC_A22		0x006C
+#define GPMC_A23		0x006E
+#define GPMC_A24		0x0070
+#define GPMC_A25		0x0072
+#define GPMC_NCS0		0x0074
+#define GPMC_NCS1		0x0076
+#define GPMC_NCS2		0x0078
+#define GPMC_NCS3		0x007A
+#define GPMC_NWP		0x007C
+#define GPMC_CLK		0x007E
+#define GPMC_NADV_ALE		0x0080
+#define GPMC_NOE		0x0082
+#define GPMC_NWE		0x0084
+#define GPMC_NBE0_CLE		0x0086
+#define GPMC_NBE1		0x0088
+#define GPMC_WAIT0		0x008A
+#define GPMC_WAIT1		0x008C
+#define C2C_DATA11		0x008E
+#define C2C_DATA12		0x0090
+#define C2C_DATA13		0x0092
+#define C2C_DATA14		0x0094
+#define C2C_DATA15		0x0096
+#define HDMI_HPD		0x0098
+#define HDMI_CEC		0x009A
+#define HDMI_DDC_SCL		0x009C
+#define HDMI_DDC_SDA		0x009E
+#define CSI21_DX0		0x00A0
+#define CSI21_DY0		0x00A2
+#define CSI21_DX1		0x00A4
+#define CSI21_DY1		0x00A6
+#define CSI21_DX2		0x00A8
+#define CSI21_DY2		0x00AA
+#define CSI21_DX3		0x00AC
+#define CSI21_DY3		0x00AE
+#define CSI21_DX4		0x00B0
+#define CSI21_DY4		0x00B2
+#define CSI22_DX0		0x00B4
+#define CSI22_DY0		0x00B6
+#define CSI22_DX1		0x00B8
+#define CSI22_DY1		0x00BA
+#define CAM_SHUTTER		0x00BC
+#define CAM_STROBE		0x00BE
+#define CAM_GLOBALRESET		0x00C0
+#define USBB1_ULPITLL_CLK	0x00C2
+#define USBB1_ULPITLL_STP	0x00C4
+#define USBB1_ULPITLL_DIR	0x00C6
+#define USBB1_ULPITLL_NXT	0x00C8
+#define USBB1_ULPITLL_DAT0	0x00CA
+#define USBB1_ULPITLL_DAT1	0x00CC
+#define USBB1_ULPITLL_DAT2	0x00CE
+#define USBB1_ULPITLL_DAT3	0x00D0
+#define USBB1_ULPITLL_DAT4	0x00D2
+#define USBB1_ULPITLL_DAT5	0x00D4
+#define USBB1_ULPITLL_DAT6	0x00D6
+#define USBB1_ULPITLL_DAT7	0x00D8
+#define USBB1_HSIC_DATA		0x00DA
+#define USBB1_HSIC_STROBE	0x00DC
+#define USBC1_ICUSB_DP		0x00DE
+#define USBC1_ICUSB_DM		0x00E0
+#define SDMMC1_CLK		0x00E2
+#define SDMMC1_CMD		0x00E4
+#define SDMMC1_DAT0		0x00E6
+#define SDMMC1_DAT1		0x00E8
+#define SDMMC1_DAT2		0x00EA
+#define SDMMC1_DAT3		0x00EC
+#define SDMMC1_DAT4		0x00EE
+#define SDMMC1_DAT5		0x00F0
+#define SDMMC1_DAT6		0x00F2
+#define SDMMC1_DAT7		0x00F4
+#define ABE_MCBSP2_CLKX		0x00F6
+#define ABE_MCBSP2_DR		0x00F8
+#define ABE_MCBSP2_DX		0x00FA
+#define ABE_MCBSP2_FSX		0x00FC
+#define ABE_MCBSP1_CLKX		0x00FE
+#define ABE_MCBSP1_DR		0x0100
+#define ABE_MCBSP1_DX		0x0102
+#define ABE_MCBSP1_FSX		0x0104
+#define ABE_PDM_UL_DATA		0x0106
+#define ABE_PDM_DL_DATA		0x0108
+#define ABE_PDM_FRAME		0x010A
+#define ABE_PDM_LB_CLK		0x010C
+#define ABE_CLKS		0x010E
+#define ABE_DMIC_CLK1		0x0110
+#define ABE_DMIC_DIN1		0x0112
+#define ABE_DMIC_DIN2		0x0114
+#define ABE_DMIC_DIN3		0x0116
+#define UART2_CTS		0x0118
+#define UART2_RTS		0x011A
+#define UART2_RX		0x011C
+#define UART2_TX		0x011E
+#define HDQ_SIO			0x0120
+#define I2C1_SCL		0x0122
+#define I2C1_SDA		0x0124
+#define I2C2_SCL		0x0126
+#define I2C2_SDA		0x0128
+#define I2C3_SCL		0x012A
+#define I2C3_SDA		0x012C
+#define I2C4_SCL		0x012E
+#define I2C4_SDA		0x0130
+#define MCSPI1_CLK		0x0132
+#define MCSPI1_SOMI		0x0134
+#define MCSPI1_SIMO		0x0136
+#define MCSPI1_CS0		0x0138
+#define MCSPI1_CS1		0x013A
+#define MCSPI1_CS2		0x013C
+#define MCSPI1_CS3		0x013E
+#define UART3_CTS_RCTX		0x0140
+#define UART3_RTS_SD		0x0142
+#define UART3_RX_IRRX		0x0144
+#define UART3_TX_IRTX		0x0146
+#define SDMMC5_CLK		0x0148
+#define SDMMC5_CMD		0x014A
+#define SDMMC5_DAT0		0x014C
+#define SDMMC5_DAT1		0x014E
+#define SDMMC5_DAT2		0x0150
+#define SDMMC5_DAT3		0x0152
+#define MCSPI4_CLK		0x0154
+#define MCSPI4_SIMO		0x0156
+#define MCSPI4_SOMI		0x0158
+#define MCSPI4_CS0		0x015A
+#define UART4_RX		0x015C
+#define UART4_TX		0x015E
+#define USBB2_ULPITLL_CLK	0x0160
+#define USBB2_ULPITLL_STP	0x0162
+#define USBB2_ULPITLL_DIR	0x0164
+#define USBB2_ULPITLL_NXT	0x0166
+#define USBB2_ULPITLL_DAT0	0x0168
+#define USBB2_ULPITLL_DAT1	0x016A
+#define USBB2_ULPITLL_DAT2	0x016C
+#define USBB2_ULPITLL_DAT3	0x016E
+#define USBB2_ULPITLL_DAT4	0x0170
+#define USBB2_ULPITLL_DAT5	0x0172
+#define USBB2_ULPITLL_DAT6	0x0174
+#define USBB2_ULPITLL_DAT7	0x0176
+#define USBB2_HSIC_DATA		0x0178
+#define USBB2_HSIC_STROBE	0x017A
+#define UNIPRO_TX0		0x017C
+#define UNIPRO_TY0		0x017E
+#define UNIPRO_TX1		0x0180
+#define UNIPRO_TY1		0x0182
+#define UNIPRO_TX2		0x0184
+#define UNIPRO_TY2		0x0186
+#define UNIPRO_RX0		0x0188
+#define UNIPRO_RY0		0x018A
+#define UNIPRO_RX1		0x018C
+#define UNIPRO_RY1		0x018E
+#define UNIPRO_RX2		0x0190
+#define UNIPRO_RY2		0x0192
+#define USBA0_OTG_CE		0x0194
+#define USBA0_OTG_DP		0x0196
+#define USBA0_OTG_DM		0x0198
+#define FREF_CLK1_OUT		0x019A
+#define FREF_CLK2_OUT		0x019C
+#define SYS_NIRQ1		0x019E
+#define SYS_NIRQ2		0x01A0
+#define SYS_BOOT0		0x01A2
+#define SYS_BOOT1		0x01A4
+#define SYS_BOOT2		0x01A6
+#define SYS_BOOT3		0x01A8
+#define SYS_BOOT4		0x01AA
+#define SYS_BOOT5		0x01AC
+#define DPM_EMU0		0x01AE
+#define DPM_EMU1		0x01B0
+#define DPM_EMU2		0x01B2
+#define DPM_EMU3		0x01B4
+#define DPM_EMU4		0x01B6
+#define DPM_EMU5		0x01B8
+#define DPM_EMU6		0x01BA
+#define DPM_EMU7		0x01BC
+#define DPM_EMU8		0x01BE
+#define DPM_EMU9		0x01C0
+#define DPM_EMU10		0x01C2
+#define DPM_EMU11		0x01C4
+#define DPM_EMU12		0x01C6
+#define DPM_EMU13		0x01C8
+#define DPM_EMU14		0x01CA
+#define DPM_EMU15		0x01CC
+#define DPM_EMU16		0x01CE
+#define DPM_EMU17		0x01D0
+#define DPM_EMU18		0x01D2
+#define DPM_EMU19		0x01D4
+#define WAKEUPEVENT_0		0x01D8
+#define WAKEUPEVENT_1		0x01DC
+#define WAKEUPEVENT_2		0x01E0
+#define WAKEUPEVENT_3		0x01E4
+#define WAKEUPEVENT_4		0x01E8
+#define WAKEUPEVENT_5		0x01EC
+#define WAKEUPEVENT_6		0x01F0
+
+#define WKUP_REVISION		0x0000
+#define WKUP_HWINFO		0x0004
+#define WKUP_SYSCONFIG		0x0010
+#define PAD0_SIM_IO		0x0040
+#define PAD1_SIM_CLK		0x0042
+#define PAD0_SIM_RESET		0x0044
+#define PAD1_SIM_CD		0x0046
+#define PAD0_SIM_PWRCTRL		0x0048
+#define PAD1_SR_SCL		0x004A
+#define PAD0_SR_SDA		0x004C
+#define PAD1_FREF_XTAL_IN		0x004E
+#define PAD0_FREF_SLICER_IN	0x0050
+#define PAD1_FREF_CLK_IOREQ	0x0052
+#define PAD0_FREF_CLK0_OUT		0x0054
+#define PAD1_FREF_CLK3_REQ		0x0056
+#define PAD0_FREF_CLK3_OUT		0x0058
+#define PAD1_FREF_CLK4_REQ		0x005A
+#define PAD0_FREF_CLK4_OUT		0x005C
+#define PAD1_SYS_32K		0x005E
+#define PAD0_SYS_NRESPWRON		0x0060
+#define PAD1_SYS_NRESWARM		0x0062
+#define PAD0_SYS_PWR_REQ		0x0064
+#define PAD1_SYS_PWRON_RESET	0x0066
+#define PAD0_SYS_BOOT6		0x0068
+#define PAD1_SYS_BOOT7		0x006A
+#define PAD0_JTAG_NTRST		0x006C
+#define PAD1_JTAG_TCK		0x006D
+#define PAD0_JTAG_RTCK		0x0070
+#define PAD1_JTAG_TMS_TMSC		0x0072
+#define PAD0_JTAG_TDI		0x0074
+#define PAD1_JTAG_TDO		0x0076
+#define PADCONF_WAKEUPEVENT_0	0x007C
+#define CONTROL_SMART1NOPMIO_PADCONF_0		0x05A0
+#define CONTROL_SMART1NOPMIO_PADCONF_1		0x05A4
+#define PADCONF_MODE		0x05A8
+#define CONTROL_XTAL_OSCILLATOR			0x05AC
+#define CONTROL_CONTROL_I2C_2			0x0604
+#define CONTROL_CONTROL_JTAG			0x0608
+#define CONTROL_CONTROL_SYS			0x060C
+#define CONTROL_SPARE_RW		0x0614
+#define CONTROL_SPARE_R		0x0618
+#define CONTROL_SPARE_R_C0		0x061C
 
 typedef struct {
-  UINTN   Pin;
-  UINTN   MuxMode;
-  UINTN   PullConfig;
-  UINTN   InputEnable;
+  UINT16   Off;
+  UINT16   Val;
+
 } PAD_CONFIGURATION;
 
 #endif //__OMAP4430_PAD_CONFIGURATION_H__
diff --git a/Omap44xxPkg/Include/Omap4430/Omap4430Prcm.h b/Omap44xxPkg/Include/Omap4430/Omap4430Prcm.h
index 1f476058..40b6e1f3 100644
--- a/Omap44xxPkg/Include/Omap4430/Omap4430Prcm.h
+++ b/Omap44xxPkg/Include/Omap4430/Omap4430Prcm.h
@@ -15,151 +15,134 @@
 #ifndef __OMAP4430PRCM_H__
 #define __OMAP4430PRCM_H__
 
-#define CM_FCLKEN1_CORE   (0x48004A00)
-#define CM_FCLKEN3_CORE   (0x48004A08)
-#define CM_ICLKEN1_CORE   (0x48004A10)
-#define CM_ICLKEN3_CORE   (0x48004A18)
-#define CM_CLKEN2_PLL     (0x48004D04)
-#define CM_CLKSEL4_PLL    (0x48004D4C)
-#define CM_CLKSEL5_PLL    (0x48004D50)
-#define CM_FCLKEN_USBHOST  (0x48005400)
-#define CM_ICLKEN_USBHOST  (0x48005410)
-#define CM_CLKSTST_USBHOST (0x4800544c)
+// CONTROL_CORE
 
-//Wakeup clock defintion
-#define CM_FCLKEN_WKUP    (0x48004C00)
-#define CM_ICLKEN_WKUP    (0x48004C10)
+#define CONTROL_CORE_U_BASE                          (0x4A002000)
+#define CONTROL_CORE_ID_CODE                         (CONTROL_CORE_U_BASE+0x204)
+#define CONTROL_CORE_LDOSRAM_IVA_VOLTAGE_CTRL        (CONTROL_CORE_U_BASE+0x320)
+#define CONTROL_CORE_LDOSRAM_MPU_VOLTAGE_CTRL        (CONTROL_CORE_U_BASE+0x324)
+#define CONTROL_CORE_LDOSRAM_CORE_VOLTAGE_CTRL       (CONTROL_CORE_U_BASE+0x328)
 
-//Peripheral clock definition
-#define CM_FCLKEN_PER     (0x48005000)
-#define CM_ICLKEN_PER     (0x48005010)
-#define CM_CLKSEL_PER     (0x48005040)
+#define CONTROL_CORE_LDOSRAM_VOLTAGE_CTRL_VAL               (0x0401040F)
 
-//Reset management definition
-#define PRM_RSTCTRL       (0x48307250)
-#define PRM_RSTST         (0x48307258)
+#define CONTROL_PBIAS_LITE                                  (0x4a100600)
+#define PBIASVMODE3V                                        (BIT21)
+#define PBIASLITEPWRDNZ                                     (BIT22)
+#define PBIASVMODEERR                                       (BIT23)
+#define PBIASHIZ                                            (BIT25)
+#define PBIASPWRDNZ                                         (BIT26)
 
-//CORE clock
-#define CM_FCLKEN1_CORE_EN_I2C1_MASK    BIT15
-#define CM_FCLKEN1_CORE_EN_I2C1_DISABLE (0UL << 15)
-#define CM_FCLKEN1_CORE_EN_I2C1_ENABLE  BIT15
+// PRM
 
-#define CM_ICLKEN1_CORE_EN_I2C1_MASK    BIT15
-#define CM_ICLKEN1_CORE_EN_I2C1_DISABLE (0UL << 15)
-#define CM_ICLKEN1_CORE_EN_I2C1_ENABLE  BIT15
+#define PRM_U_BASE                                          (0x4A307B00)
 
-#define CM_FCLKEN1_CORE_EN_MMC1_MASK    BIT24
-#define CM_FCLKEN1_CORE_EN_MMC1_DISABLE (0UL << 24)
-#define CM_FCLKEN1_CORE_EN_MMC1_ENABLE  BIT24
+#define PRM_RSTCTRL                                         (PRM_U_BASE+0x0)
+#define PRM_RSTST                                           (PRM_U_BASE+0x4)
 
-#define CM_FCLKEN3_CORE_EN_USBTLL_MASK    BIT2
-#define CM_FCLKEN3_CORE_EN_USBTLL_DISABLE (0UL << 2)
-#define CM_FCLKEN3_CORE_EN_USBTLL_ENABLE  BIT2
+#define PRM_RSTST_GLOBAL_COLD_RST_MASK                      (0x1)
 
-#define CM_ICLKEN1_CORE_EN_MMC1_MASK    BIT24
-#define CM_ICLKEN1_CORE_EN_MMC1_DISABLE (0UL << 24)
-#define CM_ICLKEN1_CORE_EN_MMC1_ENABLE  BIT24
+#define PRM_RSTCTRL_RST_GLOBAL_COLD_SW_VAL                  (0x2)
 
-#define CM_ICLKEN3_CORE_EN_USBTLL_MASK    BIT2
-#define CM_ICLKEN3_CORE_EN_USBTLL_DISABLE (0UL << 2)
-#define CM_ICLKEN3_CORE_EN_USBTLL_ENABLE  BIT2
+#define PRM_VC_VAL_BYPASS                                   (PRM_U_BASE+0xA0)
+#define PRM_VC_VAL_BYPASS_REGADDR_POS                       (8)
+#define PRM_VC_VAL_BYPASS_DATA_POS                          (16)
 
-#define CM_CLKEN_FREQSEL_075_100        (0x03UL << 4)
-#define CM_CLKEN_ENABLE                 (7UL << 0)
+#define PRM_VC_CFG_I2C_MODE                                 (PRM_U_BASE+0xA8)
+#define PRM_VC_CFG_I2C_CLK                                  (PRM_U_BASE+0xAC)
 
-#define CM_CLKSEL_PLL_MULT(x)           (((x) & 0x07FF) << 8)
-#define CM_CLKSEL_PLL_DIV(x)            ((((x) - 1) & 0x7F) << 0)
-  
-#define CM_CLKSEL_DIV_120M(x)           (((x) & 0x1F) << 0)
+#define VC_CFG_I2C_MODE_VAL                                 (0x0)
+#define VC_CFG_I2C_CLK_VAL                                  (0x167FFB)
 
-#define CM_FCLKEN_USBHOST_EN_USBHOST2_MASK    BIT1
-#define CM_FCLKEN_USBHOST_EN_USBHOST2_DISABLE (0UL << 1)
-#define CM_FCLKEN_USBHOST_EN_USBHOST2_ENABLE  BIT1
+#define PMIC_SMPS_ID0_SLAVE_ADDR                            (0x12)
+#define PMIC_VCORE3_CFG_FORCE_REGADDR                       (0x61)
+#define PMIC_VCORE1_CFG_FORCE_REGADDR                       (0x55)
+#define PMIC_VCORE2_CFG_FORCE_REGADDR                       (0x5B)
+#define PMIC_VCORE3_CFG_FORCE_VSEL                          (0x28)
+#define PMIC_VCORE1_CFG_FORCE_VSEL_VDD_MPU_4430             (0x32)
+#define PMIC_VCORE1_CFG_FORCE_VSEL_VDD_CORE_4460            (0x28)
+#define PMIC_VCORE2_CFG_FORCE_VSEL                          (0x28)
 
-#define CM_FCLKEN_USBHOST_EN_USBHOST1_MASK    BIT0
-#define CM_FCLKEN_USBHOST_EN_USBHOST1_DISABLE (0UL << 0)
-#define CM_FCLKEN_USBHOST_EN_USBHOST1_ENABLE  BIT0
+#define TPS62361_SLAVE_ADDR                                 (0x60)
+#define TPS62361_SET1_REG_ADDR                              (0x01)
+#define TPS62361_SET1_REG_VAL                               (0x46)
 
-#define CM_ICLKEN_USBHOST_EN_USBHOST_MASK     BIT0
-#define CM_ICLKEN_USBHOST_EN_USBHOST_DISABLE  (0UL << 0)
-#define CM_ICLKEN_USBHOST_EN_USBHOST_ENABLE   BIT0
+// CKGEN_CM1
 
-//Wakeup functional clock
-#define CM_FCLKEN_WKUP_EN_GPIO1_DISABLE       (0UL << 3)
-#define CM_FCLKEN_WKUP_EN_GPIO1_ENABLE        BIT3
+#define CKGEN_CM1_U_BASE                                    (0x4A004100)
 
-#define CM_FCLKEN_WKUP_EN_WDT2_DISABLE        (0UL << 5)
-#define CM_FCLKEN_WKUP_EN_WDT2_ENABLE         BIT5
+#define CKGEN_CM1_CM_DIV_M3_DPLL_CORE                       (CKGEN_CM1_U_BASE+0x34)
+#define CKGEN_CM1_CM_DIV_M4_DPLL_CORE                       (CKGEN_CM1_U_BASE+0x38)
+#define CKGEN_CM1_CM_DIV_M5_DPLL_CORE                       (CKGEN_CM1_U_BASE+0x3C)
+#define CKGEN_CM1_CM_DIV_M6_DPLL_CORE                       (CKGEN_CM1_U_BASE+0x40)
+#define CKGEN_CM1_CM_DIV_M7_DPLL_CORE                       (CKGEN_CM1_U_BASE+0x44)
 
-//Wakeup interface clock
-#define CM_ICLKEN_WKUP_EN_GPIO1_DISABLE       (0UL << 3)
-#define CM_ICLKEN_WKUP_EN_GPIO1_ENABLE        BIT3
+#define CKGEN_CM1_CM_DIV_M2_DPLL_MPU                        (CKGEN_CM1_U_BASE+0x70)
 
-#define CM_ICLKEN_WKUP_EN_WDT2_DISABLE        (0UL << 5)
-#define CM_ICLKEN_WKUP_EN_WDT2_ENABLE         BIT5
+#define CKGEN_CM1_CM_CLKMODE_DPLL_IVA                       (CKGEN_CM1_U_BASE+0xA0)
+#define CKGEN_CM1_CM_CLKSEL_DPLL_IVA                        (CKGEN_CM1_U_BASE+0xAC)
+#define CKGEN_CM1_CM_DIV_M4_DPLL_IVA                        (CKGEN_CM1_U_BASE+0xB8)
+#define CKGEN_CM1_CM_DIV_M5_DPLL_IVA                        (CKGEN_CM1_U_BASE+0xBC)
+#define CKGEN_CM1_CM_BYPCLK_DPLL_IVA                        (CKGEN_CM1_U_BASE+0xDC)
 
-//Peripheral functional clock
-#define CM_FCLKEN_PER_EN_GPT3_DISABLE         (0UL << 4)
-#define CM_FCLKEN_PER_EN_GPT3_ENABLE          BIT4
+#define CKGEN_CM1_CM_CLKSEL_DPLL_IVA_CLKSEL_VAL             (0x19c10)
+#define CKGEN_CM1_CM_CLKSEL_DPLL_IVA_M4_VAL                 (4)
+#define CKGEN_CM1_CM_CLKSEL_DPLL_IVA_M5_VAL                 (7)
+#define CKGEN_CM1_CM_CLKSEL_DPLL_IVA_BYCLK_VAL              (1)
+#define CKGEN_CM1_CM_CLKSEL_DPLL_IVA_CLKMODE_VAL            (7)
 
-#define CM_FCLKEN_PER_EN_GPT4_DISABLE         (0UL << 5)
-#define CM_FCLKEN_PER_EN_GPT4_ENABLE          BIT5
+#define CKGEN_CM1_CM_CLKMODE_DPLL_ABE                       (CKGEN_CM1_U_BASE+0xE0)
+#define CKGEN_CM1_CM_CLKSEL_DPLL_ABE                        (CKGEN_CM1_U_BASE+0xEC)
+#define CKGEN_CM1_CM_DIV_M2_DPLL_ABE                        (CKGEN_CM1_U_BASE+0xF0)
+#define CKGEN_CM1_CM_DIV_M3_DPLL_ABE                        (CKGEN_CM1_U_BASE+0xF4)
 
-#define CM_FCLKEN_PER_EN_UART3_DISABLE        (0UL << 11)
-#define CM_FCLKEN_PER_EN_UART3_ENABLE         BIT11
+#define CKGEN_CM1_CM_CLKSEL_DPLL_ABE_VAL                    (0x82ee00)
+#define CKGEN_CM1_CM_DIV_M2_DPLL_ABE_VAL                    (1)
+#define CKGEN_CM1_CM_DIV_M3_DPLL_ABE_VAL                    (1)
+#define CKGEN_CM1_CM_CLKMODE_DPLL_ABE_VAL                   (0xf27)
 
-#define CM_FCLKEN_PER_EN_GPIO2_DISABLE        (0UL << 13)
-#define CM_FCLKEN_PER_EN_GPIO2_ENABLE         BIT13
+#define CKGEN_CM1_CM_SHADOW_FREQ_CONFIG1                    (CKGEN_CM1_U_BASE+0x160)
+#define CM_SHADOW_FREQ_CONFIG1_DPLL_CORE_M2_DIV_OPP100      (1<<11)
+#define CM_SHADOW_FREQ_CONFIG1_DPLL_CORE_DPLL_EN_LOCK       (7<<8)
+#define CM_SHADOW_FREQ_CONFIG1_DLL_RESET_RST                (1<<3)
+#define CM_SHADOW_FREQ_CONFIG1_FREQ_UPDATE_START            (1<<0)
 
-#define CM_FCLKEN_PER_EN_GPIO3_DISABLE        (0UL << 14)
-#define CM_FCLKEN_PER_EN_GPIO3_ENABLE         BIT14
+#define CM_DIV_M2_DPLL_MPU_OPP100_VAL                       (1)
+#define CM_DIV_M3_DPLL_CORE_OPP100_VAL                      (5)
+#define CM_DIV_M4_DPLL_CORE_OPP100_VAL                      (8)
+#define CM_DIV_M5_DPLL_CORE_OPP100_VAL                      (4)
+#define CM_DIV_M6_DPLL_CORE_OPP100_VAL                      (6)
+#define CM_DIV_M7_DPLL_CORE_OPP100_VAL                      (5)
 
-#define CM_FCLKEN_PER_EN_GPIO4_DISABLE        (0UL << 15)
-#define CM_FCLKEN_PER_EN_GPIO4_ENABLE         BIT15
+// CKGEN_CM2
 
-#define CM_FCLKEN_PER_EN_GPIO5_DISABLE        (0UL << 16)
-#define CM_FCLKEN_PER_EN_GPIO5_ENABLE         BIT16
+#define CKGEN_CM2_U_BASE                                    (0x4A008100)
 
-#define CM_FCLKEN_PER_EN_GPIO6_DISABLE        (0UL << 17)
-#define CM_FCLKEN_PER_EN_GPIO6_ENABLE         BIT17
+#define CKGEN_CM2_CM_CLKMODE_DPLL_USB                       (CKGEN_CM2_U_BASE+0x80)
+#define CKGEN_CM2_CM_CLKSEL_DPLL_USB                        (CKGEN_CM2_U_BASE+0x8C)
+#define CKGEN_CM2_CM_DIV_M2_DPLL_USB                        (CKGEN_CM2_U_BASE+0x90)
 
-//Peripheral interface clock
-#define CM_ICLKEN_PER_EN_GPT3_DISABLE         (0UL << 4)
-#define CM_ICLKEN_PER_EN_GPT3_ENABLE          BIT4
+#define CKGEN_CM2_CM_CLKSEL_DPLL_USB_VAL                    (0x25817)
+#define CKGEN_CM2_CM_DIV_M2_DPLL_USB_VAL                    (0x282)
+#define CKGEN_CM2_CM_CLKMODE_DPLL_USB_VAL                   (0x7)
 
-#define CM_ICLKEN_PER_EN_GPT4_DISABLE         (0UL << 5)
-#define CM_ICLKEN_PER_EN_GPT4_ENABLE          BIT5
+// RESTORE_CM1
 
-#define CM_ICLKEN_PER_EN_UART3_DISABLE        (0UL << 11)
-#define CM_ICLKEN_PER_EN_UART3_ENABLE         BIT11
+#define RESTORE_CM1_U_BASE                                  (0x4A004E00)
 
-#define CM_ICLKEN_PER_EN_GPIO2_DISABLE        (0UL << 13)
-#define CM_ICLKEN_PER_EN_GPIO2_ENABLE         BIT13
+#define RESTORE_CM1_CM_DIV_M2_DPLL_CORE_RESTORE             (RESTORE_CM1_U_BASE+0x4)
+#define RESTORE_CM1_CM_DIV_M3_DPLL_CORE_RESTORE             (RESTORE_CM1_U_BASE+0x8)
+#define RESTORE_CM1_CM_DIV_M5_DPLL_CORE_RESTORE             (RESTORE_CM1_U_BASE+0x10)
+#define RESTORE_CM1_CM_DIV_M6_DPLL_CORE_RESTORE             (RESTORE_CM1_U_BASE+0x14)
+#define RESTORE_CM1_CM_DIV_M7_DPLL_CORE_RESTORE             (RESTORE_CM1_U_BASE+0x18)
+#define RESTORE_CM1_CM_CLKSEL_DPLL_CORE_RESTORE             (RESTORE_CM1_U_BASE+0x1C)
+#define RESTORE_CM1_CM_SHADOW_FREQ_CONFIG1_RESTORE          (RESTORE_CM1_U_BASE+0x30)
 
-#define CM_ICLKEN_PER_EN_GPIO3_DISABLE        (0UL << 14)
-#define CM_ICLKEN_PER_EN_GPIO3_ENABLE         BIT14
+// SCRM
 
-#define CM_ICLKEN_PER_EN_GPIO4_DISABLE        (0UL << 15)
-#define CM_ICLKEN_PER_EN_GPIO4_ENABLE         BIT15
+#define SCRM_U_BASE                                         (0x4A30A000)
 
-#define CM_ICLKEN_PER_EN_GPIO5_DISABLE        (0UL << 16)
-#define CM_ICLKEN_PER_EN_GPIO5_ENABLE         BIT16
-
-#define CM_ICLKEN_PER_EN_GPIO6_DISABLE        (0UL << 17)
-#define CM_ICLKEN_PER_EN_GPIO6_ENABLE         BIT17
-
-//Timer source clock selection
-#define CM_CLKSEL_PER_CLKSEL_GPT3_32K         (0UL << 1)
-#define CM_CLKSEL_PER_CLKSEL_GPT3_SYS         BIT1
-
-#define CM_CLKSEL_PER_CLKSEL_GPT4_32K         (0UL << 2)
-#define CM_CLKSEL_PER_CLKSEL_GPT4_SYS         BIT2
-
-//Reset management (Global and Cold reset)
-#define RST_GS            BIT1
-#define RST_DPLL3         BIT2
-#define GLOBAL_SW_RST     BIT1
-#define GLOBAL_COLD_RST   (0x0UL << 0)
+#define SCRM_AUXCLK3                                        (SCRM_U_BASE+0x31C)
+#define SCRM_AUXCLK3_VAL                                    (0x00010100)
 
 #endif // __OMAP4430PRCM_H__
 
diff --git a/Omap44xxPkg/Include/Omap4430/Omap4430Usb.h b/Omap44xxPkg/Include/Omap4430/Omap4430Usb.h
index c70f63f3..22fe47c8 100644
--- a/Omap44xxPkg/Include/Omap4430/Omap4430Usb.h
+++ b/Omap44xxPkg/Include/Omap4430/Omap4430Usb.h
@@ -15,22 +15,18 @@
 #ifndef __OMAP4430USB_H__
 #define __OMAP4430USB_H__
 
-#define USB_BASE            (0x48060000)
+#define USB_BASE            (0x4A060000)
 
 #define UHH_SYSCONFIG       (USB_BASE + 0x4010)
 #define UHH_HOSTCONFIG      (USB_BASE + 0x4040)
 #define UHH_SYSSTATUS       (USB_BASE + 0x4014)
 
-#define USB_EHCI_HCCAPBASE  (USB_BASE + 0x4800)
+#define USB_EHCI_HCCAPBASE  (USB_BASE + 0x4C00)
 
-#define UHH_SYSCONFIG_MIDLEMODE_NO_STANDBY  BIT12
-#define UHH_SYSCONFIG_CLOCKACTIVITY_ON      BIT8
-#define UHH_SYSCONFIG_SIDLEMODE_NO_STANDBY  BIT3
-#define UHH_SYSCONFIG_ENAWAKEUP_ENABLE      BIT2
-#define UHH_SYSCONFIG_SOFTRESET             BIT1
-#define UHH_SYSCONFIG_AUTOIDLE_ALWAYS_RUN   (0UL <<  0)
+#define UHH_SYSCONFIG_STANDBYMODE_NO_STANDBY  BIT4
+#define UHH_SYSCONFIG_IDLEMODE_NO_IDLE        BIT2
+#define UHH_SYSCONFIG_SOFTRESET               BIT0
 
-#define UHH_HOSTCONFIG_P3_CONNECT_STATUS_DISCONNECT (0UL << 10)
 #define UHH_HOSTCONFIG_P2_CONNECT_STATUS_DISCONNECT (0UL <<  9)
 #define UHH_HOSTCONFIG_P1_CONNECT_STATUS_DISCONNECT (0UL <<  8)
 #define UHH_HOSTCONFIG_ENA_INCR_ALIGN_DISABLE       (0UL <<  5)
@@ -38,11 +34,8 @@
 #define UHH_HOSTCONFIG_ENA_INCR8_ENABLE             BIT3
 #define UHH_HOSTCONFIG_ENA_INCR4_ENABLE             BIT2
 #define UHH_HOSTCONFIG_AUTOPPD_ON_OVERCUR_EN_ON     (0UL <<  1)
-#define UHH_HOSTCONFIG_P1_ULPI_BYPASS_ULPI_MODE     (0UL <<  0)
+#define UHH_HOSTCONFIG_P1_ULPI_BYPASS_ULPI_MODE     (0UL <<  16)
 
-#define UHH_SYSSTATUS_RESETDONE                (BIT0 | BIT1 | BIT2)
+#define UHH_SYSSTATUS_RESETDONE                (BIT1 | BIT2)
 
 #endif // __OMAP4430USB_H__
-
-
-
diff --git a/Omap44xxPkg/Library/SerialPortLib/SerialPortLib.c b/Omap44xxPkg/Library/SerialPortLib/SerialPortLib.c
index 1a37e0f1..9162c6c8 100644
--- a/Omap44xxPkg/Library/SerialPortLib/SerialPortLib.c
+++ b/Omap44xxPkg/Library/SerialPortLib/SerialPortLib.c
@@ -153,64 +153,3 @@ SerialPortPoll (
   }
 }
 
-/**
-  Set the serial device control bits.
-
-  @return    Always return EFI_UNSUPPORTED.
-
-**/
-RETURN_STATUS
-EFIAPI
-SerialPortSetControl (
-  IN UINT32                   Control
-  )
-{
-  return RETURN_SUCCESS;
-}
-
-/**
-  Get the serial device control bits.
-
-  @param  Control                 Control signals read from the serial device.
-
-  @retval EFI_SUCCESS             The control bits were read from the serial device.
-  @retval EFI_DEVICE_ERROR        The serial device is not functioning correctly.
-
-**/
-RETURN_STATUS
-EFIAPI
-SerialPortGetControl (
-  OUT UINT32                  *Control
-  )
-{
-  if (SerialPortPoll ()) {
-    // If a character is pending don't set EFI_SERIAL_INPUT_BUFFER_EMPTY
-    *Control = EFI_SERIAL_OUTPUT_BUFFER_EMPTY;
-  } else {
-    *Control = EFI_SERIAL_INPUT_BUFFER_EMPTY | EFI_SERIAL_OUTPUT_BUFFER_EMPTY;
-  }
-
-  return RETURN_SUCCESS;
-}
-
-
-/**
-  Set the serial device attributes.
-
-  @return    Always return EFI_UNSUPPORTED.
-
-**/
-RETURN_STATUS
-EFIAPI
-SerialPortSetAttributes (
-  IN UINT64              BaudRate,
-  IN UINT32              ReceiveFifoDepth,
-  IN UINT32              Timeout,
-  IN EFI_PARITY_TYPE     Parity,
-  IN UINT8               DataBits,
-  IN EFI_STOP_BITS_TYPE  StopBits
-  )
-{
-  return RETURN_SUCCESS;
-}
-
diff --git a/Omap44xxPkg/Library/SerialPortLib/SerialPortLib.inf b/Omap44xxPkg/Library/SerialPortLib/SerialPortLib.inf
index 676eb116..07db0f83 100644
--- a/Omap44xxPkg/Library/SerialPortLib/SerialPortLib.inf
+++ b/Omap44xxPkg/Library/SerialPortLib/SerialPortLib.inf
@@ -17,7 +17,7 @@
   INF_VERSION                    = 0x00010005
   BASE_NAME                      = PandaBoardSerialPortLib
   FILE_GUID                      = 97546cbd-c0ff-4c48-ab0b-e4f58862acd3
-  MODULE_TYPE                    = PEIM
+  MODULE_TYPE                    = BASE
   VERSION_STRING                 = 1.0
   LIBRARY_CLASS                  = SerialPortLib
 
diff --git a/Omap44xxPkg/PciEmulation/PciEmulation.c b/Omap44xxPkg/PciEmulation/PciEmulation.c
index dc9109f9..2a2fcd58 100644
--- a/Omap44xxPkg/PciEmulation/PciEmulation.c
+++ b/Omap44xxPkg/PciEmulation/PciEmulation.c
@@ -57,17 +57,10 @@ ConfigureUSBHost (
   VOID
   )
 {
-  EFI_STATUS Status;
-  UINT8      Data = 0;
-
   // Take USB host out of force-standby mode
-  MmioWrite32 (UHH_SYSCONFIG, UHH_SYSCONFIG_MIDLEMODE_NO_STANDBY
-                            | UHH_SYSCONFIG_CLOCKACTIVITY_ON
-                            | UHH_SYSCONFIG_SIDLEMODE_NO_STANDBY
-                            | UHH_SYSCONFIG_ENAWAKEUP_ENABLE
-                            | UHH_SYSCONFIG_AUTOIDLE_ALWAYS_RUN);
-  MmioWrite32 (UHH_HOSTCONFIG, UHH_HOSTCONFIG_P3_CONNECT_STATUS_DISCONNECT
-                             | UHH_HOSTCONFIG_P2_CONNECT_STATUS_DISCONNECT
+  MmioWrite32 (UHH_SYSCONFIG, UHH_SYSCONFIG_STANDBYMODE_NO_STANDBY
+                            | UHH_SYSCONFIG_IDLEMODE_NO_IDLE);
+  MmioWrite32 (UHH_HOSTCONFIG, UHH_HOSTCONFIG_P2_CONNECT_STATUS_DISCONNECT
                              | UHH_HOSTCONFIG_P1_CONNECT_STATUS_DISCONNECT
                              | UHH_HOSTCONFIG_ENA_INCR_ALIGN_DISABLE
                              | UHH_HOSTCONFIG_ENA_INCR16_ENABLE
@@ -76,36 +69,18 @@ ConfigureUSBHost (
                              | UHH_HOSTCONFIG_AUTOPPD_ON_OVERCUR_EN_ON
                              | UHH_HOSTCONFIG_P1_ULPI_BYPASS_ULPI_MODE);
 
-  // USB reset (GPIO 147 - Port 5 pin 19) output high
-  MmioAnd32 (GPIO5_BASE + GPIO_OE, ~BIT19);
-  MmioWrite32 (GPIO5_BASE + GPIO_SETDATAOUT, BIT19);
-
-  // Get the Power IC protocol
-  Status = gBS->LocateProtocol (&gEmbeddedExternalDeviceProtocolGuid, NULL, (VOID **)&gTWL6030);
-  ASSERT_EFI_ERROR (Status);  
-
-  // Power the USB PHY
-  Data = VAUX_DEV_GRP_P1;
-  Status = gTWL6030->Write (gTWL6030, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VAUX2_DEV_GRP), 1, &Data);
-  ASSERT_EFI_ERROR(Status);
-
-  Data = VAUX_DEDICATED_18V;
-  Status = gTWL6030->Write (gTWL6030, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VAUX2_DEDICATED), 1, &Data);
-  ASSERT_EFI_ERROR (Status);  
+  // fref auxclk3 feeds USB3320 ULPI/DPDM converter with 19.2 MHz square clock
+  MmioWrite32 (SCRM_AUXCLK3, SCRM_AUXCLK3_VAL);
 
-  // Enable power to the USB hub
-  Status = gTWL6030->Read (gTWL6030, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID3, LEDEN), 1, &Data);
-  ASSERT_EFI_ERROR (Status);
+  // USB3320 and LAN9514 reset (HUB_NRESET: GPIO 62 - Port 2 pin 30 output high)
+  MmioAnd32 (GPIO2_BASE + GPIO_OE, ~BIT30);
+  MmioOr32 (GPIO2_BASE + GPIO_SETDATAOUT, BIT30);
 
-  // LEDAON controls the power to the USB host, PWM is disabled
-  Data &= ~LEDAPWM;
-  Data |= LEDAON;
-
-  Status = gTWL6030->Write (gTWL6030, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID3, LEDEN), 1, &Data);
-  ASSERT_EFI_ERROR (Status);
+  // Enable power to USB hub (HUB_NPD: GPIO1 - Port 1 pin 1 output high)
+  MmioAnd32 (GPIO1_BASE + GPIO_OE, ~BIT1);
+  MmioOr32 (GPIO1_BASE + GPIO_SETDATAOUT, BIT1);
 }
 
-
 EFI_STATUS
 PciIoPollMem (
   IN EFI_PCI_IO_PROTOCOL           *This,
@@ -456,10 +431,6 @@ PciEmulationEntryPoint (
   UINT8                   PhysicalPorts;
   UINTN                   Count;
 
-  // TODO
-  // Currently this driver makes boot up crashing on Panda
-  return EFI_SUCCESS;
-
   //Configure USB host for OMAP4430.
   ConfigureUSBHost();
 
diff --git a/OptionRomPkg/Bus/Usb/UsbNetworking/Ax88772b/Ax88772.c b/OptionRomPkg/Bus/Usb/UsbNetworking/Ax88772b/Ax88772.c
new file mode 100644
index 00000000..45ba3e52
--- /dev/null
+++ b/OptionRomPkg/Bus/Usb/UsbNetworking/Ax88772b/Ax88772.c
@@ -0,0 +1,878 @@
+/** @file

+  Implement the interface to the AX88772 Ethernet controller.

+

+  This module implements the interface to the ASIX AX88772

+  USB to Ethernet MAC with integrated 10/100 PHY.  Note that this implementation

+  only supports the integrated PHY since no other test cases were available.

+

+  Copyright (c) 2011, Intel Corporation

+  All rights reserved. This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include "Ax88772.h"

+

+

+/**

+  Compute the CRC 

+

+  @param [in] pMacAddress      Address of a six byte buffer to containing the MAC address.

+

+  @returns The CRC-32 value associated with this MAC address

+

+**/

+UINT32

+Ax88772Crc (

+  IN UINT8 * pMacAddress

+  )

+{

+  UINT32 BitNumber;

+  INT32 Carry;

+  INT32 Crc;

+  UINT32 Data;

+  UINT8 * pEnd;

+

+  //

+  //  Walk the MAC address

+  //

+  Crc = -1;

+  pEnd = &pMacAddress[ PXE_HWADDR_LEN_ETHER ];

+  while ( pEnd > pMacAddress ) {

+    Data = *pMacAddress++;

+    //

+    //  CRC32: x32 + x26 + x23 + x22 + x16 + x12 + x11 + x10 + x8 + x7 + x5 + x4 + x2 + x + 1

+    //

+    //          1 0000 0100 1100 0001 0001 1101 1011 0111

+    //

+    for ( BitNumber = 0; 8 > BitNumber; BitNumber++ ) {

+      Carry = (( Crc >> 31 ) & 1 ) ^ ( Data & 1 );

+      Crc <<= 1;

+      if ( 0 != Carry ) {

+        Crc ^= 0x04c11db7;

+      }

+      Data >>= 1;

+    }

+  }

+  //

+  //  Return the CRC value

+  //

+  return (UINT32) Crc;

+}

+

+

+/**

+  Get the MAC address

+

+  This routine calls ::Ax88772UsbCommand to request the MAC

+  address from the network adapter.

+

+  @param [in] pNicDevice       Pointer to the NIC_DEVICE structure

+  @param [out] pMacAddress      Address of a six byte buffer to receive the MAC address.

+

+  @retval EFI_SUCCESS          The MAC address is available.

+  @retval other                The MAC address is not valid.

+

+**/

+EFI_STATUS

+Ax88772MacAddressGet (

+  IN NIC_DEVICE * pNicDevice,

+  OUT UINT8 * pMacAddress

+  )

+{

+  USB_DEVICE_REQUEST SetupMsg;

+  EFI_STATUS Status;

+

+  //

+  //  Set the register address.

+  //

+  SetupMsg.RequestType = USB_ENDPOINT_DIR_IN

+                       | USB_REQ_TYPE_VENDOR

+                       | USB_TARGET_DEVICE;

+  SetupMsg.Request = CMD_MAC_ADDRESS_READ;

+  SetupMsg.Value = 0;

+  SetupMsg.Index = 0;

+  SetupMsg.Length = PXE_HWADDR_LEN_ETHER;

+

+  //

+  //  Read the PHY register

+  //

+  Status = Ax88772UsbCommand ( pNicDevice,

+                               &SetupMsg,

+                               pMacAddress );

+  return Status;

+}

+

+

+/**

+  Set the MAC address

+

+  This routine calls ::Ax88772UsbCommand to set the MAC address

+  in the network adapter.

+

+  @param [in] pNicDevice       Pointer to the NIC_DEVICE structure

+  @param [in] pMacAddress      Address of a six byte buffer to containing the new MAC address.

+

+  @retval EFI_SUCCESS          The MAC address was set.

+  @retval other                The MAC address was not set.

+

+**/

+EFI_STATUS

+Ax88772MacAddressSet (

+  IN NIC_DEVICE * pNicDevice,

+  IN UINT8 * pMacAddress

+  )

+{

+  USB_DEVICE_REQUEST SetupMsg;

+  EFI_STATUS Status;

+

+  //

+  //  Set the register address.

+  //

+  SetupMsg.RequestType = USB_REQ_TYPE_VENDOR

+                       | USB_TARGET_DEVICE;

+  SetupMsg.Request = CMD_MAC_ADDRESS_WRITE;

+  SetupMsg.Value = 0;

+  SetupMsg.Index = 0;

+  SetupMsg.Length = PXE_HWADDR_LEN_ETHER;

+  

+  //

+  //  Read the PHY register

+  //

+  Status = Ax88772UsbCommand ( pNicDevice,

+                               &SetupMsg,

+                               pMacAddress );

+  return Status;

+}

+

+/**

+  Clear the multicast hash table

+

+  @param [in] pNicDevice       Pointer to the NIC_DEVICE structure

+

+**/

+VOID

+Ax88772MulticastClear (

+  IN NIC_DEVICE * pNicDevice

+  )

+{

+  int i = 0;

+  //

+  // Clear the multicast hash table

+  //

+  for ( i = 0 ; i < 8 ; i ++ )

+     pNicDevice->MulticastHash[0] = 0;

+}

+

+/**

+  Enable a multicast address in the multicast hash table

+

+  This routine calls ::Ax88772Crc to compute the hash bit for

+  this MAC address.

+

+  @param [in] pNicDevice       Pointer to the NIC_DEVICE structure

+  @param [in] pMacAddress      Address of a six byte buffer to containing the MAC address.

+

+**/

+VOID

+Ax88772MulticastSet (

+  IN NIC_DEVICE * pNicDevice,

+  IN UINT8 * pMacAddress

+  )

+{

+  UINT32 Crc;

+

+  //

+  //  Compute the CRC on the destination address

+  //

+  Crc = Ax88772Crc ( pMacAddress ) >> 26;

+

+  //

+  //  Set the bit corresponding to the destination address

+  //

+   pNicDevice->MulticastHash [ Crc >> 3 ] |= ( 1<< (Crc& 7));

+}

+

+/**

+  Start the link negotiation

+

+  This routine calls ::Ax88772PhyWrite to start the PHY's link

+  negotiation.

+

+  @param [in] pNicDevice       Pointer to the NIC_DEVICE structure

+

+  @retval EFI_SUCCESS          The link negotiation was started.

+  @retval other                Failed to start the link negotiation.

+

+**/

+EFI_STATUS

+Ax88772NegotiateLinkStart (

+  IN NIC_DEVICE * pNicDevice

+  )

+{

+  UINT16 Control;

+  EFI_STATUS Status;

+  int i; 

+  //

+  // Set the supported capabilities.

+  //

+  Status = Ax88772PhyWrite ( pNicDevice,

+                             PHY_ANAR,

+                             AN_CSMA_CD

+                             | AN_TX_FDX | AN_TX_HDX

+                             | AN_10_FDX | AN_10_HDX );

+  if ( !EFI_ERROR ( Status )) {

+    //

+    // Set the link speed and duplex

+    //

+    Control = BMCR_AUTONEGOTIATION_ENABLE

+            | BMCR_RESTART_AUTONEGOTIATION;

+    if ( pNicDevice->b100Mbps ) {

+      Control |= BMCR_100MBPS;

+    }

+    if ( pNicDevice->bFullDuplex ) {

+      Control |= BMCR_FULL_DUPLEX;

+    }

+    Status = Ax88772PhyWrite ( pNicDevice, PHY_BMCR, Control );

+  }

+  

+  if (!EFI_ERROR(Status)) {

+    i = 0;

+    do {

+      

+        if (pNicDevice->bComplete && pNicDevice->bLinkUp) {

+            pNicDevice->SimpleNetwork.Mode->MediaPresent 

+               = pNicDevice->bLinkUp & pNicDevice->bComplete;

+           break;

+       }

+       else {

+            gBS->Stall(AUTONEG_DELAY);

+            Status = Ax88772NegotiateLinkComplete ( pNicDevice,

+                                            &pNicDevice->PollCount,

+                                            &pNicDevice->bComplete,

+                                            &pNicDevice->bLinkUp,

+                                            &pNicDevice->b100Mbps,

+                                            &pNicDevice->bFullDuplex );

+            i++;

+        }

+    }while(!pNicDevice->bLinkUp && i < AUTONEG_POLLCNT);

+  }

+  return Status;

+}

+

+

+/**

+  Complete the negotiation of the PHY link

+

+  This routine calls ::Ax88772PhyRead to determine if the

+  link negotiation is complete.

+

+  @param [in] pNicDevice       Pointer to the NIC_DEVICE structure

+  @param [in, out] pPollCount  Address of number of times this routine was polled

+  @param [out] pbComplete      Address of boolean to receive complate status.

+  @param [out] pbLinkUp        Address of boolean to receive link status, TRUE=up.

+  @param [out] pbHiSpeed       Address of boolean to receive link speed, TRUE=100Mbps.

+  @param [out] pbFullDuplex    Address of boolean to receive link duplex, TRUE=full.

+

+  @retval EFI_SUCCESS          The MAC address is available.

+  @retval other                The MAC address is not valid.

+

+**/

+EFI_STATUS

+Ax88772NegotiateLinkComplete (

+  IN NIC_DEVICE * pNicDevice,

+  IN OUT UINTN * pPollCount,

+  OUT BOOLEAN * pbComplete,

+  OUT BOOLEAN * pbLinkUp,

+  OUT BOOLEAN * pbHiSpeed,

+  OUT BOOLEAN * pbFullDuplex

+  )

+{

+  UINT16 Mask;

+  UINT16 PhyData;

+  EFI_STATUS  Status;

+ 

+  //

+  //  Determine if the link is up.

+  //

+  *pbComplete = FALSE;  

+

+  //

+  //  Get the link status

+  //

+  Status = Ax88772PhyRead ( pNicDevice,

+                            PHY_BMSR,

+                            &PhyData );

+

+  if ( !EFI_ERROR ( Status )) {

+      *pbLinkUp = (BOOLEAN)( 0 != ( PhyData & BMSR_LINKST ));

+      if ( 0 == *pbLinkUp ) {

+        DEBUG (( EFI_D_INFO, "Link Down\n" ));

+      }      

+      else {

+         *pbComplete = (BOOLEAN)( 0 != ( PhyData & 0x20 ));

+         if ( 0 == *pbComplete ) {

+              DEBUG (( EFI_D_INFO, "Autoneg is not yet Complete\n" ));

+        }

+        else {

+          Status = Ax88772PhyRead ( pNicDevice,

+                                PHY_ANLPAR,

+                                &PhyData );

+          if ( !EFI_ERROR ( Status )) {

+            //

+            //  Autonegotiation is complete

+            //  Determine the link speed.

+            //

+            *pbHiSpeed = (BOOLEAN)( 0 != ( PhyData & ( AN_TX_FDX | AN_TX_HDX )));

+

+            //

+            //  Determine the link duplex.

+            //

+            Mask = ( *pbHiSpeed ) ? AN_TX_FDX : AN_10_FDX;

+            *pbFullDuplex = (BOOLEAN)( 0 != ( PhyData & Mask ));

+          }

+        } 

+      }

+  } 

+  else {

+      DEBUG (( EFI_D_ERROR, "Failed to read BMCR\n" ));

+  }

+  return Status;

+}

+

+

+/**

+  Read a register from the PHY

+

+  This routine calls ::Ax88772UsbCommand to read a PHY register.

+

+  @param [in] pNicDevice       Pointer to the NIC_DEVICE structure

+  @param [in] RegisterAddress  Number of the register to read.

+  @param [in, out] pPhyData    Address of a buffer to receive the PHY register value

+

+  @retval EFI_SUCCESS          The PHY data is available.

+  @retval other                The PHY data is not valid.

+

+**/

+EFI_STATUS

+Ax88772PhyRead (

+  IN NIC_DEVICE * pNicDevice,

+  IN UINT8 RegisterAddress,

+  IN OUT UINT16 * pPhyData

+  )

+{

+  USB_DEVICE_REQUEST SetupMsg;

+  EFI_STATUS Status;

+

+  //

+  //  Request access to the PHY

+  //

+  SetupMsg.RequestType = USB_REQ_TYPE_VENDOR

+                       | USB_TARGET_DEVICE;

+  SetupMsg.Request = CMD_PHY_ACCESS_SOFTWARE;   

+  SetupMsg.Value = 0;

+  SetupMsg.Index = 0;

+  SetupMsg.Length = 0;

+  Status = Ax88772UsbCommand ( pNicDevice,

+                               &SetupMsg,

+                               NULL );

+  if ( !EFI_ERROR ( Status )) {

+    //

+    //  Read the PHY register address.

+    //

+    SetupMsg.RequestType = USB_ENDPOINT_DIR_IN

+                         | USB_REQ_TYPE_VENDOR

+                         | USB_TARGET_DEVICE;

+    SetupMsg.Request = CMD_PHY_REG_READ;

+    SetupMsg.Value = pNicDevice->PhyId;

+    SetupMsg.Index = RegisterAddress;

+    SetupMsg.Length = sizeof ( *pPhyData );

+    Status = Ax88772UsbCommand ( pNicDevice,

+                                 &SetupMsg,

+                                 pPhyData );

+    if ( !EFI_ERROR ( Status )) {

+

+      //

+      //  Release the PHY to the hardware

+      //

+      SetupMsg.RequestType = USB_REQ_TYPE_VENDOR

+                           | USB_TARGET_DEVICE;

+      SetupMsg.Request = CMD_PHY_ACCESS_HARDWARE;

+      SetupMsg.Value = 0;

+      SetupMsg.Index = 0;

+      SetupMsg.Length = 0;

+      Status = Ax88772UsbCommand ( pNicDevice,

+                                   &SetupMsg,

+                                   NULL );

+    }

+  }

+  return Status;

+}

+

+

+/**

+  Write to a PHY register

+

+  This routine calls ::Ax88772UsbCommand to write a PHY register.

+

+  @param [in] pNicDevice       Pointer to the NIC_DEVICE structure

+  @param [in] RegisterAddress  Number of the register to read.

+  @param [in] PhyData          Address of a buffer to receive the PHY register value

+

+  @retval EFI_SUCCESS          The PHY data was written.

+  @retval other                Failed to wwrite the PHY register.

+

+**/

+EFI_STATUS

+Ax88772PhyWrite (

+  IN NIC_DEVICE * pNicDevice,

+  IN UINT8 RegisterAddress,

+  IN UINT16 PhyData

+  )

+{

+  USB_DEVICE_REQUEST SetupMsg;

+  EFI_STATUS Status;

+

+  //

+  //  Request access to the PHY

+  //

+  SetupMsg.RequestType = USB_REQ_TYPE_VENDOR

+                       | USB_TARGET_DEVICE;

+  SetupMsg.Request = CMD_PHY_ACCESS_SOFTWARE;

+  SetupMsg.Value = 0;

+  SetupMsg.Index = 0;

+  SetupMsg.Length = 0;

+  Status = Ax88772UsbCommand ( pNicDevice,

+                               &SetupMsg,

+                               NULL );

+  if ( !EFI_ERROR ( Status )) {

+    //

+    //  Write the PHY register

+    //

+    SetupMsg.RequestType = USB_REQ_TYPE_VENDOR

+                         | USB_TARGET_DEVICE;

+    SetupMsg.Request = CMD_PHY_REG_WRITE;

+    SetupMsg.Value = pNicDevice->PhyId;

+    SetupMsg.Index = RegisterAddress;

+    SetupMsg.Length = sizeof ( PhyData );

+    Status = Ax88772UsbCommand ( pNicDevice,

+                                 &SetupMsg,

+                                 &PhyData );

+    if ( !EFI_ERROR ( Status )) {

+

+      //

+      //  Release the PHY to the hardware

+      //

+      SetupMsg.RequestType = USB_REQ_TYPE_VENDOR

+                           | USB_TARGET_DEVICE;

+      SetupMsg.Request = CMD_PHY_ACCESS_HARDWARE;

+      SetupMsg.Value = 0;

+      SetupMsg.Index = 0;

+      SetupMsg.Length = 0;

+      Status = Ax88772UsbCommand ( pNicDevice,

+                                   &SetupMsg,

+                                   NULL );

+    }

+  }

+

+  return Status;

+}

+

+

+/**

+  Reset the AX88772

+

+  This routine uses ::Ax88772UsbCommand to reset the network

+  adapter.  This routine also uses ::Ax88772PhyWrite to reset

+  the PHY.

+

+  @param [in] pNicDevice       Pointer to the NIC_DEVICE structure

+

+  @retval EFI_SUCCESS          The MAC address is available.

+  @retval other                The MAC address is not valid.

+

+**/

+EFI_STATUS

+Ax88772Reset (

+  IN NIC_DEVICE * pNicDevice

+  )

+{

+  USB_DEVICE_REQUEST SetupMsg;

+  EFI_STATUS Status;

+  

+  EFI_USB_IO_PROTOCOL *pUsbIo;

+  EFI_USB_DEVICE_DESCRIPTOR Device;

+  

+  pUsbIo = pNicDevice->pUsbIo;

+  Status = pUsbIo->UsbGetDeviceDescriptor ( pUsbIo, &Device );

+

+	if (EFI_ERROR(Status)) goto err; 

+

+  SetupMsg.RequestType = USB_REQ_TYPE_VENDOR

+                           | USB_TARGET_DEVICE;

+  SetupMsg.Request = CMD_PHY_ACCESS_HARDWARE;

+  SetupMsg.Value = 0;

+  SetupMsg.Index = 0;

+  SetupMsg.Length = 0;

+  Status = Ax88772UsbCommand ( pNicDevice,

+                                &SetupMsg,

+                                NULL );

+                                   

+  if (EFI_ERROR(Status)) goto err;                                 

+                                   

+  SetupMsg.RequestType = USB_REQ_TYPE_VENDOR

+                          | USB_TARGET_DEVICE;

+      SetupMsg.Request = CMD_PHY_SELECT;

+      SetupMsg.Value = SPHY_PSEL;

+      SetupMsg.Index = 0;

+      SetupMsg.Length = 0;

+      Status = Ax88772UsbCommand ( pNicDevice,

+                                    &SetupMsg,

+                                    NULL );

+                                    

+  if (EFI_ERROR(Status)) goto err;  

+                                     

+  SetupMsg.RequestType = USB_REQ_TYPE_VENDOR

+                          | USB_TARGET_DEVICE;                                

+  SetupMsg.Request = CMD_RESET;

+      SetupMsg.Value = SRR_IPRL ;

+      SetupMsg.Index = 0;

+      SetupMsg.Length = 0;

+      Status = Ax88772UsbCommand ( pNicDevice,

+                                   &SetupMsg,

+                                   NULL );  

+                                   

+  if (EFI_ERROR(Status)) goto err;  

+                                   

+  SetupMsg.RequestType = USB_REQ_TYPE_VENDOR

+                          | USB_TARGET_DEVICE;                                

+  SetupMsg.Request = CMD_RESET;

+        SetupMsg.Value = SRR_IPPD | SRR_IPRL ;

+        SetupMsg.Index = 0;

+        SetupMsg.Length = 0;

+        Status = Ax88772UsbCommand ( pNicDevice,

+                                    &SetupMsg,

+                                    NULL );

+                                   

+  gBS->Stall ( 200000 );

+    

+  if (EFI_ERROR(Status)) goto err;  

+    

+  SetupMsg.RequestType = USB_REQ_TYPE_VENDOR

+                          | USB_TARGET_DEVICE;

+  SetupMsg.Request = CMD_RESET;

+  SetupMsg.Value =  SRR_IPRL  ;

+  SetupMsg.Index = 0;

+  SetupMsg.Length = 0;

+  Status = Ax88772UsbCommand ( pNicDevice,

+                                &SetupMsg,

+                                NULL );   

+                                    

+  gBS->Stall ( 200000 ); 

+     

+  if (EFI_ERROR(Status)) goto err;  

+     

+  SetupMsg.RequestType = USB_REQ_TYPE_VENDOR

+                          | USB_TARGET_DEVICE;

+  SetupMsg.Request = CMD_RESET;

+  SetupMsg.Value = 0;

+  SetupMsg.Index = 0;

+  SetupMsg.Length = 0;

+  Status = Ax88772UsbCommand ( pNicDevice,

+                                    &SetupMsg,

+                                    NULL );

+                                    

+  if (EFI_ERROR(Status)) goto err;                                

+                                    

+  SetupMsg.RequestType = USB_REQ_TYPE_VENDOR

+                          | USB_TARGET_DEVICE;

+  SetupMsg.Request = CMD_PHY_SELECT;

+  SetupMsg.Value = SPHY_PSEL;

+  SetupMsg.Index = 0;

+  SetupMsg.Length = 0;

+  Status = Ax88772UsbCommand ( pNicDevice,

+                                    &SetupMsg,

+                                    NULL ); 

+                                    

+  if (EFI_ERROR(Status)) goto err;                                

+                                    

+  SetupMsg.RequestType = USB_REQ_TYPE_VENDOR

+                          | USB_TARGET_DEVICE;

+  SetupMsg.Request = CMD_RESET;

+  SetupMsg.Value =  SRR_IPRL | SRR_BZ | SRR_BZTYPE;

+  SetupMsg.Index = 0;

+  SetupMsg.Length = 0;

+  Status = Ax88772UsbCommand ( pNicDevice,

+                                    &SetupMsg,

+                                    NULL );

+                                    

+  if (EFI_ERROR(Status)) goto err;                                

+                                    

+  SetupMsg.RequestType = USB_REQ_TYPE_VENDOR

+                        | USB_TARGET_DEVICE;

+  SetupMsg.Request = CMD_RX_CONTROL_WRITE;

+  SetupMsg.Value = 0;

+  SetupMsg.Index = 0;

+  SetupMsg.Length = 0;

+  Status = Ax88772UsbCommand ( pNicDevice,

+                                  &SetupMsg,

+                                  NULL );

+                                  

+  if (EFI_ERROR(Status)) goto err;  

+

+  SetupMsg.RequestType = USB_REQ_TYPE_VENDOR

+                        | USB_TARGET_DEVICE; 

+  SetupMsg.Request = CMD_RXQTC;

+  SetupMsg.Value = 0x8000;

+  SetupMsg.Index = 0x8001;

+  SetupMsg.Length = 0;

+  Status = Ax88772UsbCommand ( pNicDevice,

+                                  &SetupMsg,

+                                  NULL ); 

+err:

+  return Status;

+}

+

+/**

+  Enable or disable the receiver

+

+  This routine calls ::Ax88772UsbCommand to update the

+  receiver state.  This routine also calls ::Ax88772MacAddressSet

+  to establish the MAC address for the network adapter.

+

+  @param [in] pNicDevice       Pointer to the NIC_DEVICE structure

+  @param [in] RxFilter         Simple network RX filter mask value

+

+  @retval EFI_SUCCESS          The MAC address was set.

+  @retval other                The MAC address was not set.

+

+**/

+EFI_STATUS

+Ax88772RxControl (

+  IN NIC_DEVICE * pNicDevice,

+  IN UINT32 RxFilter

+  )

+{

+  UINT16 MediumStatus;

+  UINT16 RxControl;

+  USB_DEVICE_REQUEST SetupMsg;

+  EFI_STATUS Status;

+  EFI_USB_IO_PROTOCOL *pUsbIo;

+  EFI_USB_DEVICE_DESCRIPTOR Device;

+  

+  pUsbIo = pNicDevice->pUsbIo;

+  Status = pUsbIo->UsbGetDeviceDescriptor ( pUsbIo, &Device );

+  

+  if (EFI_ERROR(Status)) {

+    DEBUG (( EFI_D_ERROR, "Failed to get device descriptor\n" ));

+    return Status;

+  }

+

+  //

+  // Enable the receiver if something is to be received

+  //

+  

+  if ( 0 != RxFilter ) {

+    //

+    //  Enable the receiver

+    //

+    SetupMsg.RequestType = USB_ENDPOINT_DIR_IN

+                         | USB_REQ_TYPE_VENDOR

+                         | USB_TARGET_DEVICE;

+    SetupMsg.Request = CMD_MEDIUM_STATUS_READ;    

+    SetupMsg.Value = 0;

+    SetupMsg.Index = 0;

+    SetupMsg.Length = sizeof ( MediumStatus );

+    Status = Ax88772UsbCommand ( pNicDevice,

+                                 &SetupMsg,

+                                 &MediumStatus );

+    if ( !EFI_ERROR ( Status )) {

+      if ( 0 == ( MediumStatus & MS_RE )) {

+        MediumStatus |= MS_RE | MS_ONE;

+        

+        if ( pNicDevice->bFullDuplex )

+          MediumStatus |= MS_TFC | MS_RFC | MS_FD;

+        else

+          MediumStatus &= ~(MS_TFC | MS_RFC | MS_FD);

+        

+        if ( pNicDevice->b100Mbps )

+          MediumStatus |= MS_PS;

+        else

+          MediumStatus &= ~MS_PS;

+        

+        SetupMsg.RequestType = USB_REQ_TYPE_VENDOR

+                             | USB_TARGET_DEVICE;

+        SetupMsg.Request = CMD_MEDIUM_STATUS_WRITE;

+        SetupMsg.Value = MediumStatus;

+        SetupMsg.Index = 0;

+        SetupMsg.Length = 0;

+        Status = Ax88772UsbCommand ( pNicDevice,

+                                     &SetupMsg,

+                                     NULL );

+        if ( EFI_ERROR ( Status )) {

+            DEBUG (( EFI_D_ERROR, "Failed to enable receiver, Status: %r\r\n",

+              Status ));

+        }

+      }

+    }

+    else {

+        DEBUG (( EFI_D_ERROR, "Failed to read receiver status, Status: %r\r\n",

+              Status ));

+    }

+  }

+  

+  RxControl = RXC_SO | RXC_RH1M;  

+  //

+  //  Enable multicast if requested

+  //

+  if ( 0 != ( RxFilter & EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST )) {

+      RxControl |= RXC_AM;

+      //

+      //  Update the multicast hash table

+      //

+      SetupMsg.RequestType = USB_REQ_TYPE_VENDOR

+                           | USB_TARGET_DEVICE;

+      SetupMsg.Request = CMD_MULTICAST_HASH_WRITE;

+      SetupMsg.Value = 0;

+      SetupMsg.Index = 0;

+      SetupMsg.Length = sizeof ( pNicDevice ->MulticastHash );

+      Status = Ax88772UsbCommand ( pNicDevice,

+                                   &SetupMsg,

+                                   &pNicDevice->MulticastHash );

+  }

+  //

+  //  Enable all multicast if requested

+  //

+  if ( 0 != ( RxFilter & EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST )) {

+      RxControl |= RXC_AMALL;

+  }

+

+  //

+  //  Enable broadcast if requested

+  //

+  if ( 0 != ( RxFilter & EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST )) {

+      RxControl |= RXC_AB;

+  }

+

+  //

+  //  Enable promiscuous mode if requested

+  //

+  if ( 0 != ( RxFilter & EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS )) {

+      RxControl |= RXC_PRO;

+  }

+    

+  //

+  //  Update the receiver control

+  //

+  if (pNicDevice->CurRxControl != RxControl) {

+    SetupMsg.RequestType = USB_REQ_TYPE_VENDOR

+                         | USB_TARGET_DEVICE;

+    SetupMsg.Request = CMD_RX_CONTROL_WRITE;

+    SetupMsg.Value = RxControl;

+    SetupMsg.Index = 0;

+    SetupMsg.Length = 0;

+    Status = Ax88772UsbCommand ( pNicDevice,

+                                 &SetupMsg,

+                                 NULL );

+    if ( !EFI_ERROR ( Status )) {

+      pNicDevice->CurRxControl = RxControl;

+      

+    }

+    else {

+        DEBUG (( EFI_D_ERROR, "ERROR - Failed to set receiver control, Status: %r\r\n",

+            Status ));

+    }

+  }

+  return Status;

+}

+

+

+/**

+  Read an SROM location

+

+  This routine calls ::Ax88772UsbCommand to read data from the

+  SROM.

+

+  @param [in] pNicDevice       Pointer to the NIC_DEVICE structure

+  @param [in] Address          SROM address

+  @param [out] pData           Buffer to receive the data

+

+  @retval EFI_SUCCESS          The read was successful

+  @retval other                The read failed

+

+**/

+EFI_STATUS

+Ax88772SromRead (

+  IN NIC_DEVICE * pNicDevice,

+  IN UINT32 Address,

+  OUT UINT16 * pData

+  )

+{ 

+  return EFI_UNSUPPORTED;

+}

+

+/**

+  Send a command to the USB device.

+

+  @param [in] pNicDevice       Pointer to the NIC_DEVICE structure

+  @param [in] pRequest         Pointer to the request structure

+  @param [in, out] pBuffer     Data buffer address

+

+  @retval EFI_SUCCESS          The USB transfer was successful

+  @retval other                The USB transfer failed

+

+**/

+EFI_STATUS

+Ax88772UsbCommand (

+  IN NIC_DEVICE * pNicDevice,

+  IN USB_DEVICE_REQUEST * pRequest,

+  IN OUT VOID * pBuffer

+  )

+{

+  UINT32 CmdStatus;

+  EFI_USB_DATA_DIRECTION Direction;

+  EFI_USB_IO_PROTOCOL * pUsbIo;

+  EFI_STATUS Status;

+

+  //

+  // Determine the transfer direction

+  //

+  Direction = EfiUsbNoData;

+  if ( 0 != pRequest->Length ) {

+    Direction = ( 0 != ( pRequest->RequestType & USB_ENDPOINT_DIR_IN ))

+              ? EfiUsbDataIn : EfiUsbDataOut;

+  }

+

+  //

+  // Issue the command

+  //

+  pUsbIo = pNicDevice->pUsbIo;

+  Status = pUsbIo->UsbControlTransfer ( pUsbIo,

+                                        pRequest,

+                                        Direction,

+                                        USB_BUS_TIMEOUT,

+                                        pBuffer,

+                                        pRequest->Length,

+                                        &CmdStatus );

+  //

+  // Determine the operation status

+  //

+  if ( !EFI_ERROR ( Status )) {

+    Status = CmdStatus;

+  }

+  else {

+    //

+    // Only use status values associated with the Simple Network protocol

+    //

+    if ( EFI_TIMEOUT == Status ) {

+      Status = EFI_DEVICE_ERROR;

+    }

+  }

+  return Status;

+}

+

diff --git a/OptionRomPkg/Bus/Usb/UsbNetworking/Ax88772b/Ax88772.h b/OptionRomPkg/Bus/Usb/UsbNetworking/Ax88772b/Ax88772.h
new file mode 100644
index 00000000..5382e44c
--- /dev/null
+++ b/OptionRomPkg/Bus/Usb/UsbNetworking/Ax88772b/Ax88772.h
@@ -0,0 +1,1023 @@
+/** @file

+  Definitions for ASIX AX88772 Ethernet adapter.

+

+  Copyright (c) 2011, Intel Corporation

+  All rights reserved. This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef _AX88772_H_

+#define _AX88772_H_

+

+#include <Uefi.h>

+

+#include <Guid/EventGroup.h>

+#include <Guid/NicIp4ConfigNvData.h>

+

+#include <IndustryStandard/Pci.h>

+

+#include <Library/BaseMemoryLib.h>

+#include <Library/DebugLib.h>

+#include <Library/DevicePathLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/UefiDriverEntryPoint.h>

+#include <Library/UefiLib.h>

+#include <Library/UefiRuntimeLib.h>

+

+#include <Protocol/DevicePath.h>

+#include <Protocol/LoadedImage.h>

+#include <Protocol/NetworkInterfaceIdentifier.h>

+#include <Protocol/SimpleNetwork.h>

+#include <Protocol/UsbIo.h>

+

+#define MAX_QUEUE_SIZE 50

+#define MAX_BULKIN_SIZE 16384

+#define HW_HDR_LENGTH 8

+

+

+#define MAX_LINKIDLE_THRESHOLD  20000

+

+

+

+//------------------------------------------------------------------------------

+//  Macros

+//------------------------------------------------------------------------------

+

+#if defined(_MSC_VER)           /* Handle Microsoft VC++ compiler specifics. */

+#define DBG_ENTER()             DEBUG (( 0xffffffff, "Entering " __FUNCTION__ "\n" )) ///<  Display routine entry

+#define DBG_EXIT()              DEBUG (( 0xffffffff, "Exiting " __FUNCTION__ "\n" ))  ///<  Display routine exit

+#define DBG_EXIT_DEC(Status)    DEBUG (( 0xffffffff, "Exiting " __FUNCTION__ ", Status: %d\n", Status ))      ///<  Display routine exit with decimal value

+#define DBG_EXIT_HEX(Status)    DEBUG (( 0xffffffff, "Exiting " __FUNCTION__ ", Status: 0x%08x\n", Status ))  ///<  Display routine exit with hex value

+#define DBG_EXIT_STATUS(Status) DEBUG (( 0xffffffff, "Exiting " __FUNCTION__ ", Status: %r\n", Status ))      ///<  Display routine exit with status value

+#define DBG_EXIT_TF(Status)     DEBUG (( 0xffffffff, "Exiting " __FUNCTION__ ", returning %s\n", (FALSE == Status) ? L"FALSE" : L"TRUE" ))  ///<  Display routine with TRUE/FALSE value

+#else   //  _MSC_VER

+#define DBG_ENTER()               ///<  Display routine entry

+#define DBG_EXIT()                ///<  Display routine exit

+#define DBG_EXIT_DEC(Status)      ///<  Display routine exit with decimal value

+#define DBG_EXIT_HEX(Status)      ///<  Display routine exit with hex value

+#define DBG_EXIT_STATUS(Status)   ///<  Display routine exit with status value

+#define DBG_EXIT_TF(Status)       ///<  Display routine with TRUE/FALSE value

+#endif  //  _MSC_VER

+

+#define USB_IS_IN_ENDPOINT(EndPointAddr)      (((EndPointAddr) & BIT7) != 0)  ///<  Return TRUE/FALSE for IN direction

+#define USB_IS_OUT_ENDPOINT(EndPointAddr)     (((EndPointAddr) & BIT7) == 0)  ///<  Return TRUE/FALSE for OUT direction

+#define USB_IS_BULK_ENDPOINT(Attribute)       (((Attribute) & (BIT0 | BIT1)) == USB_ENDPOINT_BULK)      ///<  Return TRUE/FALSE for BULK type

+#define USB_IS_INTERRUPT_ENDPOINT(Attribute)  (((Attribute) & (BIT0 | BIT1)) == USB_ENDPOINT_INTERRUPT) ///<  Return TRUE/FALSE for INTERRUPT type

+

+

+#define PRINT(_L_STR) (gST->ConOut->OutputString(gST->ConOut,(_L_STR)))

+//------------------------------------------------------------------------------

+//  Constants

+//------------------------------------------------------------------------------

+

+#define DEBUG_RX_BROADCAST  0x40000000  ///<  Display RX broadcast messages

+#define DEBUG_RX_MULTICAST  0x20000000  ///<  Display RX multicast messages

+#define DEBUG_RX_UNICAST    0x10000000  ///<  Display RX unicast messages

+#define DEBUG_MAC_ADDRESS   0x08000000  ///<  Display the MAC address

+#define DEBUG_LINK          0x04000000  ///<  Display the link status

+#define DEBUG_TX            0x02000000  ///<  Display the TX messages

+#define DEBUG_PHY           0x01000000  ///<  Display the PHY register values

+#define DEBUG_SROM          0x00800000  ///<  Display the SROM contents

+#define DEBUG_TIMER         0x00400000  ///<  Display the timer routine entry/exit

+#define DEBUG_TPL           0x00200000  ///<  Display the timer routine entry/exit

+

+#define AX88772_MAX_PKT_SIZE  2048  ///< Maximum packet size

+

+#define ETHERNET_HEADER_SIZE  sizeof ( ETHERNET_HEADER )  ///<  Size in bytes of the Ethernet header

+#define MIN_ETHERNET_PKT_SIZE 60    ///<  Minimum packet size including Ethernet header

+#define MAX_ETHERNET_PKT_SIZE 1500  ///<  Ethernet spec 3.1.1: Minimum packet size

+

+#define USB_NETWORK_CLASS   0x09    ///<  USB Network class code

+#define USB_BUS_TIMEOUT     1000    ///<  USB timeout in milliseconds

+

+#define TIMER_MSEC          20              ///<  Polling interval for the NIC

+//#define TPL_AX88772         TPL_CALLBACK    ///<  TPL for routine synchronization

+

+#define HC_DEBUG  0

+#define BULKIN_TIMEOUT  20

+#define AUTONEG_DELAY   500000

+#define AUTONEG_POLLCNT 20

+

+/**

+  Verify new TPL value

+

+  This macro which is enabled when debug is enabled verifies that

+  the new TPL value is >= the current TPL value.

+**/

+#ifdef VERIFY_TPL

+#undef VERIFY_TPL

+#endif  //  VERIFY_TPL

+

+#if !defined(MDEPKG_NDEBUG)

+

+#define VERIFY_TPL(tpl)                           \

+{                                                 \

+  EFI_TPL PreviousTpl;                            \

+                                                  \

+  PreviousTpl = gBS->RaiseTPL ( TPL_HIGH_LEVEL ); \

+  gBS->RestoreTPL ( PreviousTpl );                \

+  if ( PreviousTpl > tpl ) {                      \

+    DEBUG (( DEBUG_ERROR, "Current TPL: %d, New TPL: %d\r\n", PreviousTpl, tpl ));  \

+    ASSERT ( PreviousTpl <= tpl );                \

+  }                                               \

+}

+

+#else   //  MDEPKG_NDEBUG

+

+#define VERIFY_TPL(tpl)

+

+#endif  //  MDEPKG_NDEBUG

+

+//------------------------------------------------------------------------------

+//  Hardware Definition

+//------------------------------------------------------------------------------

+

+#define FreeQueueSize     10

+

+#define DEV_SIGNATURE     SIGNATURE_32 ('A','X','8','8')  ///<  Signature of data structures in memory

+

+#define VENDOR_ID         0x0B95  ///<  Vendor ID for Asix

+#define PRODUCT_ID        0x772B  ///<  Product ID for the AX88772 USB 10/100 Ethernet controller

+

+#define RESET_MSEC        1000    ///<  Reset duration

+#define PHY_RESET_MSEC     500    ///<  PHY reset duration

+

+//

+//  RX Control register

+//

+

+#define RXC_PRO           0x0001  ///<  Receive all packets

+#define RXC_AMALL         0x0002  ///<  Receive all multicast packets

+#define RXC_SEP           0x0004  ///<  Save error packets

+#define RXC_AB            0x0008  ///<  Receive broadcast packets

+#define RXC_AM            0x0010  ///<  Use multicast destination address hash table

+#define RXC_AP            0x0020  ///<  Accept physical address from Multicast Filter

+#define RXC_SO            0x0080  ///<  Start operation

+#define RXC_MFB           0x0300  ///<  Maximum frame burst

+#define RXC_MFB_2048      0       ///<  Maximum frame size:  2048 bytes

+#define RXC_MFB_4096      0x0100  ///<  Maximum frame size:  4096 bytes

+#define RXC_MFB_8192      0x0200  ///<  Maximum frame size:  8192 bytes

+#define RXC_MFB_16384     0x0300  ///<  Maximum frame size: 16384 bytes

+

+/*Freddy*/

+#define RXC_RH1M          0x0100  ///<  Rx header 1

+#define RXC_RH2M          0x0200  ///<  Rx header 2

+#define RXC_RH3M          0x0400  ///<  Rx header 3

+/*Freddy*/

+

+//

+//  Medium Status register

+//

+

+#define MS_FD             0x0002  ///<  Full duplex

+#define MS_ONE            0x0004  ///<  Must be one

+#define MS_RFC            0x0010  ///<  RX flow control enable

+#define MS_TFC            0x0020  ///<  TX flow control enable

+#define MS_PF             0x0080  ///<  Pause frame enable

+#define MS_RE             0x0100  ///<  Receive enable

+#define MS_PS             0x0200  ///<  Port speed 1=100, 0=10 Mbps

+#define MS_SBP            0x0800  ///<  Stop back pressure

+#define MS_SM             0x1000  ///<  Super MAC support

+

+//

+//  Software PHY Select register

+//

+

+#define SPHY_PSEL         (1 << 0)    ///<  Select internal PHY

+#define SPHY_SSMII        (1 << 2)

+#define SPHY_SSEN         (1 << 4)

+#define SPHY_ASEL         0x02    ///<  1=Auto select, 0=Manual select

+

+//

+//  Software Reset register

+//

+

+#define SRR_RR            0x01    ///<  Clear receive frame length error

+#define SRR_RT            0x02    ///<  Clear transmit frame length error

+#define SRR_BZTYPE        0x04    ///<  External PHY reset pin tri-state enable

+#define SRR_PRL           0x08    ///<  External PHY reset pin level

+#define SRR_BZ            0x10    ///<  Force Bulk to return zero length packet

+#define SRR_IPRL          0x20    ///<  Internal PHY reset control

+#define SRR_IPPD          0x40    ///<  Internal PHY power down

+

+//

+//  PHY ID values

+//

+

+#define PHY_ID_INTERNAL   0x0010  ///<  Internal PHY

+

+//

+//  USB Commands

+//

+

+#define CMD_PHY_ACCESS_SOFTWARE   0x06  ///<  Software in control of PHY

+#define CMD_PHY_REG_READ          0x07  ///<  Read PHY register, Value: PHY, Index: Register, Data: Register value

+#define CMD_PHY_REG_WRITE         0x08  ///<  Write PHY register, Value: PHY, Index: Register, Data: New 16-bit value

+#define CMD_PHY_ACCESS_HARDWARE   0x0a  ///<  Hardware in control of PHY

+#define CMD_SROM_READ             0x0b  ///<  Read SROM register: Value: Address, Data: Value

+#define CMD_RX_CONTROL_WRITE      0x10  ///<  Set the RX control register, Value: New value

+#define CMD_GAPS_WRITE            0x12  ///<  Write the gaps register, Value: New value

+#define CMD_MAC_ADDRESS_READ      0x13  ///<  Read the MAC address, Data: 6 byte MAC address

+#define CMD_MAC_ADDRESS_WRITE     0x14  ///<  Set the MAC address, Data: New 6 byte MAC address

+#define CMD_MULTICAST_HASH_WRITE  0x16  ///<  Write the multicast hash table, Data: New 8 byte value

+#define CMD_MULTICAST_HASH_READ  0x16  ///<  Read the multicast hash table

+#define CMD_MEDIUM_STATUS_READ    0x1a  ///<  Read medium status register, Data: Register value

+#define CMD_MEDIUM_STATUS_WRITE   0x1b  ///<  Write medium status register, Value: New value

+#define CMD_WRITE_GPIOS           0x1f

+#define CMD_RESET                 0x20  ///<  Reset register, Value: New value

+#define CMD_PHY_SELECT            0x22  ///<  PHY select register, Value: New value

+

+/*Freddy*/

+#define CMD_RXQTC                 0x2a  ///<  RX Queue Cascade Threshold Control Register

+/*Freddy*/

+

+//------------------------------

+//  USB Endpoints

+//------------------------------

+

+#define CONTROL_ENDPOINT                0       ///<  Control endpoint

+#define INTERRUPT_ENDPOINT              1       ///<  Interrupt endpoint

+#define BULK_IN_ENDPOINT                2       ///<  Receive endpoint

+#define BULK_OUT_ENDPOINT               3       ///<  Transmit endpoint

+

+//------------------------------

+//  PHY Registers

+//------------------------------

+

+#define PHY_BMCR                        0       ///<  Control register

+#define PHY_BMSR                        1       ///<  Status register

+#define PHY_ANAR                        4       ///<  Autonegotiation advertisement register

+#define PHY_ANLPAR                      5       ///<  Autonegotiation link parter ability register

+#define PHY_ANER                        6       ///<  Autonegotiation expansion register

+

+//  BMCR - Register 0

+

+#define BMCR_RESET                      0x8000  ///<  1 = Reset the PHY, bit clears after reset

+#define BMCR_LOOPBACK                   0x4000  ///<  1 = Loopback enabled

+#define BMCR_100MBPS                    0x2000  ///<  100 Mbits/Sec

+#define BMCR_10MBPS                     0       ///<  10 Mbits/Sec

+#define BMCR_AUTONEGOTIATION_ENABLE     0x1000  ///<  1 = Enable autonegotiation

+#define BMCR_POWER_DOWN                 0x0800  ///<  1 = Power down

+#define BMCR_ISOLATE                    0x0400  ///<  0 = Isolate PHY

+#define BMCR_RESTART_AUTONEGOTIATION    0x0200  ///<  1 = Restart autonegotiation

+#define BMCR_FULL_DUPLEX                0x0100  ///<  Full duplex operation

+#define BMCR_HALF_DUPLEX                0       ///<  Half duplex operation

+#define BMCR_COLLISION_TEST             0x0080  ///<  1 = Collision test enabled

+

+//  BSMR - Register 1

+

+#define BMSR_100BASET4                  0x8000  ///<  1 = 100BASE-T4 mode

+#define BMSR_100BASETX_FDX              0x4000  ///<  1 = 100BASE-TX full duplex

+#define BMSR_100BASETX_HDX              0x2000  ///<  1 = 100BASE-TX half duplex

+#define BMSR_10BASET_FDX                0x1000  ///<  1 = 10BASE-T full duplex

+#define BMSR_10BASET_HDX                0x0800  ///<  1 = 10BASE-T half duplex

+#define BMSR_MF                         0x0040  ///<  1 = PHY accepts frames with preamble suppressed

+#define BMSR_AUTONEG_CMPLT              0x0020  ///<  1 = Autonegotiation complete

+#define BMSR_RF                         0x0010  ///<  1 = Remote fault

+#define BMSR_AUTONEG                    0x0008  ///<  1 = Able to perform autonegotiation

+#define BMSR_LINKST                     0x0004  ///<  1 = Link up

+#define BMSR_JABBER_DETECT              0x0002  ///<  1 = jabber condition detected

+#define BMSR_EXTENDED_CAPABILITY        0x0001  ///<  1 = Extended register capable

+

+//  ANAR and ANLPAR Registers 4, 5

+

+#define AN_NP                           0x8000  ///<  1 = Next page available

+#define AN_ACK                          0x4000  ///<  1 = Link partner acknowledged

+#define AN_RF                           0x2000  ///<  1 = Remote fault indicated by link partner

+#define AN_FCS                          0x0400  ///<  1 = Flow control ability

+#define AN_T4                           0x0200  ///<  1 = 100BASE-T4 support

+#define AN_TX_FDX                       0x0100  ///<  1 = 100BASE-TX Full duplex

+#define AN_TX_HDX                       0x0080  ///<  1 = 100BASE-TX support

+#define AN_10_FDX                       0x0040  ///<  1 = 10BASE-T Full duplex

+#define AN_10_HDX                       0x0020  ///<  1 = 10BASE-T support

+#define AN_CSMA_CD                      0x0001  ///<  1 = IEEE 802.3 CSMA/CD support

+

+

+

+//------------------------------------------------------------------------------

+//  Data Types

+//------------------------------------------------------------------------------

+

+/**

+  Ethernet header layout

+

+  IEEE 802.3-2002 Part 3 specification, section 3.1.1.

+**/

+#pragma pack(1)

+typedef struct {

+  UINT8 dest_addr[PXE_HWADDR_LEN_ETHER];  ///<  Destination LAN address

+  UINT8 src_addr[PXE_HWADDR_LEN_ETHER];   ///<  Source LAN address

+  UINT16 type;                            ///<  Protocol or length

+} ETHERNET_HEADER;

+#pragma pack()

+

+/**

+  Receive and Transmit packet structure

+**/

+#pragma pack(1)

+typedef struct _RX_TX_PACKET {

+  struct _RX_TX_PACKET * pNext;       ///<  Next receive packet

+  UINT16 Length;                      ///<  Packet length

+  UINT16 LengthBar;                   ///<  Complement of the length

+  UINT8 Data[ AX88772_MAX_PKT_SIZE ]; ///<  Received packet data

+} RX_TX_PACKET;

+#pragma pack()

+

+

+#pragma pack(1)

+typedef struct _RX_PKT {

+  struct _RX_PKT *pNext;

+  BOOLEAN f_Used;

+  UINT16 Length;

+  UINT8 Data [AX88772_MAX_PKT_SIZE] ;

+} RX_PKT;

+#pragma pack()

+

+/**

+  AX88772 control structure

+

+  The driver uses this structure to manage the Asix AX88772 10/100

+  Ethernet controller.

+**/

+typedef struct {

+  UINTN Signature;          ///<  Structure identification

+

+  //

+  //  USB data

+  //

+  EFI_HANDLE Controller;        ///<  Controller handle

+  EFI_USB_IO_PROTOCOL * pUsbIo;  ///<  USB driver interface

+

+  //

+  //  Simple network protocol data

+  //

+  EFI_SIMPLE_NETWORK_PROTOCOL SimpleNetwork;  ///<  Driver's network stack interface

+  EFI_SIMPLE_NETWORK_PROTOCOL SimpleNetwork_Backup;

+  EFI_SIMPLE_NETWORK_MODE SimpleNetworkData;  ///<  Data for simple network

+

+  //

+  // Ethernet controller data

+  //

+  BOOLEAN bInitialized;     ///<  Controller initialized

+  VOID * pTxBuffer;         ///<  Last transmit buffer

+  UINT16 PhyId;             ///<  PHY ID

+

+  //

+  //  Link state

+  //

+  BOOLEAN b100Mbps;         ///<  Current link speed, FALSE = 10 Mbps

+  BOOLEAN bComplete;        ///<  Current state of auto-negotiation

+  BOOLEAN bFullDuplex;      ///<  Current duplex

+  BOOLEAN bLinkUp;          ///<  Current link state

+  UINTN  LinkIdleCnt;

+  UINTN PollCount;          ///<  Number of times the autonegotiation status was polled

+  UINT16 CurRxControl;

+  //

+  //  Receive buffer list

+  //

+  RX_TX_PACKET * pRxTest;

+  RX_TX_PACKET * pTxTest;

+

+  INT8 MulticastHash[8];

+  EFI_MAC_ADDRESS MAC;

+  BOOLEAN bHavePkt;

+ 

+  EFI_DEVICE_PATH_PROTOCOL                  *MyDevPath;

+  

+  EFI_DRIVER_BINDING_PROTOCOL * DrvBind;

+  

+  RX_PKT * QueueHead;

+  RX_PKT * pNextFill;

+  RX_PKT * pFirstFill;

+  UINTN   PktCntInQueue;

+  UINT8 * pBulkInBuff;

+ 

+} NIC_DEVICE;

+

+#define DEV_FROM_SIMPLE_NETWORK(a)  CR (a, NIC_DEVICE, SimpleNetwork, DEV_SIGNATURE)  ///< Locate NIC_DEVICE from Simple Network Protocol

+

+//------------------------------------------------------------------------------

+// Simple Network Protocol

+//------------------------------------------------------------------------------

+

+/**

+  Reset the network adapter.

+

+  Resets a network adapter and reinitializes it with the parameters that

+  were provided in the previous call to Initialize ().  The transmit and

+  receive queues are cleared.  Receive filters, the station address, the

+  statistics, and the multicast-IP-to-HW MAC addresses are not reset by

+  this call.

+

+  This routine calls ::Ax88772Reset to perform the adapter specific

+  reset operation.  This routine also starts the link negotiation

+  by calling ::Ax88772NegotiateLinkStart.

+

+  @param [in] pSimpleNetwork    Protocol instance pointer

+  @param [in] bExtendedVerification  Indicates that the driver may perform a more

+                                exhaustive verification operation of the device

+                                during reset.

+

+  @retval EFI_SUCCESS           This operation was successful.

+  @retval EFI_NOT_STARTED       The network interface was not started.

+  @retval EFI_INVALID_PARAMETER pSimpleNetwork parameter was NULL or did not point to a valid

+                                EFI_SIMPLE_NETWORK_PROTOCOL structure.

+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.

+  @retval EFI_UNSUPPORTED       The increased buffer size feature is not supported.

+

+**/

+EFI_STATUS

+EFIAPI

+SN_Reset (

+  IN EFI_SIMPLE_NETWORK_PROTOCOL * pSimpleNetwork,

+  IN BOOLEAN bExtendedVerification

+  );

+

+/**

+  Initialize the simple network protocol.

+

+  This routine calls ::Ax88772MacAddressGet to obtain the

+  MAC address.

+

+  @param [in] pNicDevice       NIC_DEVICE_INSTANCE pointer

+

+  @retval EFI_SUCCESS     Setup was successful

+

+**/

+EFI_STATUS

+SN_Setup (

+  IN NIC_DEVICE * pNicDevice

+  );

+

+/**

+  This routine starts the network interface.

+

+  @param [in] pSimpleNetwork    Protocol instance pointer

+

+  @retval EFI_SUCCESS           This operation was successful.

+  @retval EFI_ALREADY_STARTED   The network interface was already started.

+  @retval EFI_INVALID_PARAMETER pSimpleNetwork parameter was NULL or did not point to a valid

+                                EFI_SIMPLE_NETWORK_PROTOCOL structure.

+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.

+  @retval EFI_UNSUPPORTED       The increased buffer size feature is not supported.

+

+**/

+EFI_STATUS

+EFIAPI

+SN_Start (

+  IN EFI_SIMPLE_NETWORK_PROTOCOL * pSimpleNetwork

+  );

+

+/**

+  Set the MAC address.

+  

+  This function modifies or resets the current station address of a

+  network interface.  If Reset is TRUE, then the current station address

+  is set ot the network interface's permanent address.  If Reset if FALSE

+  then the current station address is changed to the address specified by

+  pNew.

+

+  This routine calls ::Ax88772MacAddressSet to update the MAC address

+  in the network adapter.

+

+  @param [in] pSimpleNetwork    Protocol instance pointer

+  @param [in] bReset            Flag used to reset the station address to the

+                                network interface's permanent address.

+  @param [in] pNew              New station address to be used for the network

+                                interface.

+

+  @retval EFI_SUCCESS           This operation was successful.

+  @retval EFI_NOT_STARTED       The network interface was not started.

+  @retval EFI_INVALID_PARAMETER pSimpleNetwork parameter was NULL or did not point to a valid

+                                EFI_SIMPLE_NETWORK_PROTOCOL structure.

+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.

+  @retval EFI_UNSUPPORTED       The increased buffer size feature is not supported.

+

+**/

+EFI_STATUS

+EFIAPI

+SN_StationAddress (

+  IN EFI_SIMPLE_NETWORK_PROTOCOL * pSimpleNetwork,

+  IN BOOLEAN bReset,

+  IN EFI_MAC_ADDRESS * pNew

+  );

+

+/**

+  This function resets or collects the statistics on a network interface.

+  If the size of the statistics table specified by StatisticsSize is not

+  big enough for all of the statistics that are collected by the network

+  interface, then a partial buffer of statistics is returned in

+  StatisticsTable.

+

+  @param [in] pSimpleNetwork    Protocol instance pointer

+  @param [in] bReset            Set to TRUE to reset the statistics for the network interface.

+  @param [in, out] pStatisticsSize  On input the size, in bytes, of StatisticsTable.  On output

+                                the size, in bytes, of the resulting table of statistics.

+  @param [out] pStatisticsTable A pointer to the EFI_NETWORK_STATISTICS structure that

+                                conains the statistics.

+

+  @retval EFI_SUCCESS           This operation was successful.

+  @retval EFI_NOT_STARTED       The network interface was not started.

+  @retval EFI_BUFFER_TOO_SMALL  The pStatisticsTable is NULL or the buffer is too small.

+  @retval EFI_INVALID_PARAMETER pSimpleNetwork parameter was NULL or did not point to a valid

+                                EFI_SIMPLE_NETWORK_PROTOCOL structure.

+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.

+  @retval EFI_UNSUPPORTED       The increased buffer size feature is not supported.

+

+**/

+EFI_STATUS

+EFIAPI

+SN_Statistics (

+  IN EFI_SIMPLE_NETWORK_PROTOCOL * pSimpleNetwork,

+  IN BOOLEAN bReset,

+  IN OUT UINTN * pStatisticsSize,

+  OUT EFI_NETWORK_STATISTICS * pStatisticsTable

+  );

+

+/**

+  This function stops a network interface.  This call is only valid

+  if the network interface is in the started state.

+

+  @param [in] pSimpleNetwork    Protocol instance pointer

+

+  @retval EFI_SUCCESS           This operation was successful.

+  @retval EFI_NOT_STARTED       The network interface was not started.

+  @retval EFI_INVALID_PARAMETER pSimpleNetwork parameter was NULL or did not point to a valid

+                                EFI_SIMPLE_NETWORK_PROTOCOL structure.

+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.

+  @retval EFI_UNSUPPORTED       The increased buffer size feature is not supported.

+

+**/

+EFI_STATUS

+EFIAPI

+SN_Stop (

+  IN EFI_SIMPLE_NETWORK_PROTOCOL * pSimpleNetwork

+  );

+

+/**

+  This function releases the memory buffers assigned in the Initialize() call.

+  Pending transmits and receives are lost, and interrupts are cleared and disabled.

+  After this call, only Initialize() and Stop() calls may be used.

+

+  @param [in] pSimpleNetwork    Protocol instance pointer

+

+  @retval EFI_SUCCESS           This operation was successful.

+  @retval EFI_NOT_STARTED       The network interface was not started.

+  @retval EFI_INVALID_PARAMETER pSimpleNetwork parameter was NULL or did not point to a valid

+                                EFI_SIMPLE_NETWORK_PROTOCOL structure.

+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.

+  @retval EFI_UNSUPPORTED       The increased buffer size feature is not supported.

+

+**/

+EFI_STATUS

+EFIAPI

+SN_Shutdown (

+  IN EFI_SIMPLE_NETWORK_PROTOCOL * pSimpleNetwork

+  );

+

+/**

+  Send a packet over the network.

+

+  This function places the packet specified by Header and Buffer on

+  the transmit queue.  This function performs a non-blocking transmit

+  operation.  When the transmit is complete, the buffer is returned

+  via the GetStatus() call.

+

+  This routine calls ::Ax88772Rx to empty the network adapter of

+  receive packets.  The routine then passes the transmit packet

+  to the network adapter.

+

+  @param [in] pSimpleNetwork    Protocol instance pointer

+  @param [in] HeaderSize        The size, in bytes, of the media header to be filled in by

+                                the Transmit() function.  If HeaderSize is non-zero, then

+                                it must be equal to SimpleNetwork->Mode->MediaHeaderSize

+                                and DestAddr and Protocol parameters must not be NULL.

+  @param [in] BufferSize        The size, in bytes, of the entire packet (media header and

+                                data) to be transmitted through the network interface.

+  @param [in] pBuffer           A pointer to the packet (media header followed by data) to

+                                to be transmitted.  This parameter can not be NULL.  If

+                                HeaderSize is zero, then the media header is Buffer must

+                                already be filled in by the caller.  If HeaderSize is nonzero,

+                                then the media header will be filled in by the Transmit()

+                                function.

+  @param [in] pSrcAddr          The source HW MAC address.  If HeaderSize is zero, then

+                                this parameter is ignored.  If HeaderSize is nonzero and

+                                SrcAddr is NULL, then SimpleNetwork->Mode->CurrentAddress

+                                is used for the source HW MAC address.

+  @param [in] pDestAddr         The destination HW MAC address.  If HeaderSize is zero, then

+                                this parameter is ignored.

+  @param [in] pProtocol         The type of header to build.  If HeaderSize is zero, then

+                                this parameter is ignored.

+

+  @retval EFI_SUCCESS           This operation was successful.

+  @retval EFI_NOT_STARTED       The network interface was not started.

+  @retval EFI_NOT_READY         The network interface is too busy to accept this transmit request.

+  @retval EFI_BUFFER_TOO_SMALL  The BufferSize parameter is too small.

+  @retval EFI_INVALID_PARAMETER pSimpleNetwork parameter was NULL or did not point to a valid

+                                EFI_SIMPLE_NETWORK_PROTOCOL structure.

+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.

+

+**/

+EFI_STATUS

+EFIAPI

+SN_Transmit (

+  IN EFI_SIMPLE_NETWORK_PROTOCOL * pSimpleNetwork,

+  IN UINTN HeaderSize,

+  IN UINTN BufferSize,

+  IN VOID * pBuffer,

+  IN EFI_MAC_ADDRESS * pSrcAddr,

+  IN EFI_MAC_ADDRESS * pDestAddr,

+  IN UINT16 * pProtocol

+  );

+

+//------------------------------------------------------------------------------

+// Support Routines

+//------------------------------------------------------------------------------

+

+/**

+  Get the MAC address

+

+  This routine calls ::Ax88772UsbCommand to request the MAC

+  address from the network adapter.

+

+  @param [in] pNicDevice       Pointer to the NIC_DEVICE structure

+  @param [out] pMacAddress      Address of a six byte buffer to receive the MAC address.

+

+  @retval EFI_SUCCESS          The MAC address is available.

+  @retval other                The MAC address is not valid.

+

+**/

+EFI_STATUS

+Ax88772MacAddressGet (

+  IN NIC_DEVICE * pNicDevice,

+  OUT UINT8 * pMacAddress

+  );

+

+/**

+  Set the MAC address

+

+  This routine calls ::Ax88772UsbCommand to set the MAC address

+  in the network adapter.

+

+  @param [in] pNicDevice       Pointer to the NIC_DEVICE structure

+  @param [in] pMacAddress      Address of a six byte buffer to containing the new MAC address.

+

+  @retval EFI_SUCCESS          The MAC address was set.

+  @retval other                The MAC address was not set.

+

+**/

+EFI_STATUS

+Ax88772MacAddressSet (

+  IN NIC_DEVICE * pNicDevice,

+  IN UINT8 * pMacAddress

+  );

+

+/**

+  Clear the multicast hash table

+

+  @param [in] pNicDevice       Pointer to the NIC_DEVICE structure

+

+**/

+VOID

+Ax88772MulticastClear (

+  IN NIC_DEVICE * pNicDevice

+  );

+

+/**

+  Enable a multicast address in the multicast hash table

+

+  This routine calls ::Ax88772Crc to compute the hash bit for

+  this MAC address.

+

+  @param [in] pNicDevice       Pointer to the NIC_DEVICE structure

+  @param [in] pMacAddress      Address of a six byte buffer to containing the MAC address.

+

+**/

+VOID

+Ax88772MulticastSet (

+  IN NIC_DEVICE * pNicDevice,

+  IN UINT8 * pMacAddress

+  );

+

+/**

+  Start the link negotiation

+

+  This routine calls ::Ax88772PhyWrite to start the PHY's link

+  negotiation.

+

+  @param [in] pNicDevice       Pointer to the NIC_DEVICE structure

+

+  @retval EFI_SUCCESS          The link negotiation was started.

+  @retval other                Failed to start the link negotiation.

+

+**/

+EFI_STATUS

+Ax88772NegotiateLinkStart (

+  IN NIC_DEVICE * pNicDevice

+  );

+

+/**

+  Complete the negotiation of the PHY link

+

+  This routine calls ::Ax88772PhyRead to determine if the

+  link negotiation is complete.

+

+  @param [in] pNicDevice       Pointer to the NIC_DEVICE structure

+  @param [in, out] pPollCount  Address of number of times this routine was polled

+  @param [out] pbComplete      Address of boolean to receive complate status.

+  @param [out] pbLinkUp        Address of boolean to receive link status, TRUE=up.

+  @param [out] pbHiSpeed       Address of boolean to receive link speed, TRUE=100Mbps.

+  @param [out] pbFullDuplex    Address of boolean to receive link duplex, TRUE=full.

+

+  @retval EFI_SUCCESS          The MAC address is available.

+  @retval other                The MAC address is not valid.

+

+**/

+EFI_STATUS

+Ax88772NegotiateLinkComplete (

+  IN NIC_DEVICE * pNicDevice,

+  IN OUT UINTN * pPollCount,

+  OUT BOOLEAN * pbComplete,

+  OUT BOOLEAN * pbLinkUp,

+  OUT BOOLEAN * pbHiSpeed,

+  OUT BOOLEAN * pbFullDuplex

+  );

+

+/**

+  Read a register from the PHY

+

+  This routine calls ::Ax88772UsbCommand to read a PHY register.

+

+  @param [in] pNicDevice       Pointer to the NIC_DEVICE structure

+  @param [in] RegisterAddress  Number of the register to read.

+  @param [in, out] pPhyData    Address of a buffer to receive the PHY register value

+

+  @retval EFI_SUCCESS          The PHY data is available.

+  @retval other                The PHY data is not valid.

+

+**/

+EFI_STATUS

+Ax88772PhyRead (

+  IN NIC_DEVICE * pNicDevice,

+  IN UINT8 RegisterAddress,

+  IN OUT UINT16 * pPhyData

+  );

+

+/**

+  Write to a PHY register

+

+  This routine calls ::Ax88772UsbCommand to write a PHY register.

+

+  @param [in] pNicDevice       Pointer to the NIC_DEVICE structure

+  @param [in] RegisterAddress  Number of the register to read.

+  @param [in] PhyData          Address of a buffer to receive the PHY register value

+

+  @retval EFI_SUCCESS          The PHY data was written.

+  @retval other                Failed to wwrite the PHY register.

+

+**/

+EFI_STATUS

+Ax88772PhyWrite (

+  IN NIC_DEVICE * pNicDevice,

+  IN UINT8 RegisterAddress,

+  IN UINT16 PhyData

+  );

+

+/**

+  Reset the AX88772

+

+  This routine uses ::Ax88772UsbCommand to reset the network

+  adapter.  This routine also uses ::Ax88772PhyWrite to reset

+  the PHY.

+

+  @param [in] pNicDevice       Pointer to the NIC_DEVICE structure

+

+  @retval EFI_SUCCESS          The MAC address is available.

+  @retval other                The MAC address is not valid.

+

+**/

+EFI_STATUS

+Ax88772Reset (

+  IN NIC_DEVICE * pNicDevice

+  );

+

+VOID

+Ax88772ChkLink (

+  IN NIC_DEVICE * pNicDevice,

+  IN BOOLEAN bUpdateLink

+  );

+

+/**

+  Receive a frame from the network.

+

+  This routine polls the USB receive interface for a packet.  If a packet

+  is available, this routine adds the receive packet to the list of

+  pending receive packets.

+

+  This routine calls ::Ax88772NegotiateLinkComplete to verify

+  that the link is up.  This routine also calls ::SN_Reset to

+  reset the network adapter when necessary.  Finally this

+  routine attempts to receive one or more packets from the

+  network adapter.

+

+  @param [in] pNicDevice  Pointer to the NIC_DEVICE structure

+  @param [in] bUpdateLink TRUE = Update link status

+

+**/

+VOID

+Ax88772Rx (

+  IN NIC_DEVICE * pNicDevice,

+  IN BOOLEAN bUpdateLink

+  );

+

+/**

+  Enable or disable the receiver

+

+  This routine calls ::Ax88772UsbCommand to update the

+  receiver state.  This routine also calls ::Ax88772MacAddressSet

+  to establish the MAC address for the network adapter.

+

+  @param [in] pNicDevice       Pointer to the NIC_DEVICE structure

+  @param [in] RxFilter         Simple network RX filter mask value

+

+  @retval EFI_SUCCESS          The MAC address was set.

+  @retval other                The MAC address was not set.

+

+**/

+EFI_STATUS

+Ax88772RxControl (

+  IN NIC_DEVICE * pNicDevice,

+  IN UINT32 RxFilter

+  );

+

+/**

+  Read an SROM location

+

+  This routine calls ::Ax88772UsbCommand to read data from the

+  SROM.

+

+  @param [in] pNicDevice       Pointer to the NIC_DEVICE structure

+  @param [in] Address          SROM address

+  @param [out] pData           Buffer to receive the data

+

+  @retval EFI_SUCCESS          The read was successful

+  @retval other                The read failed

+

+**/

+EFI_STATUS

+Ax88772SromRead (

+  IN NIC_DEVICE * pNicDevice,

+  IN UINT32 Address,

+  OUT UINT16 * pData

+  );

+

+/**

+  Send a command to the USB device.

+

+  @param [in] pNicDevice       Pointer to the NIC_DEVICE structure

+  @param [in] pRequest         Pointer to the request structure

+  @param [in, out] pBuffer     Data buffer address

+

+  @retval EFI_SUCCESS          The USB transfer was successful

+  @retval other                The USB transfer failed

+

+**/

+EFI_STATUS

+Ax88772UsbCommand (

+  IN NIC_DEVICE * pNicDevice,

+  IN USB_DEVICE_REQUEST * pRequest,

+  IN OUT VOID * pBuffer

+  );

+

+//------------------------------------------------------------------------------

+// EFI Component Name Protocol Support

+//------------------------------------------------------------------------------

+

+extern EFI_COMPONENT_NAME_PROTOCOL   gComponentName;  ///<  Component name protocol declaration

+extern EFI_COMPONENT_NAME2_PROTOCOL  gComponentName2; ///<  Component name 2 protocol declaration

+

+/**

+  Retrieves a Unicode string that is the user readable name of the driver.

+

+  This function retrieves the user readable name of a driver in the form of a

+  Unicode string. If the driver specified by This has a user readable name in

+  the language specified by Language, then a pointer to the driver name is

+  returned in DriverName, and EFI_SUCCESS is returned. If the driver specified

+  by This does not support the language specified by Language,

+  then EFI_UNSUPPORTED is returned.

+

+  @param [in] pThis             A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or

+                                EFI_COMPONENT_NAME_PROTOCOL instance.

+  @param [in] pLanguage         A pointer to a Null-terminated ASCII string

+                                array indicating the language. This is the

+                                language of the driver name that the caller is

+                                requesting, and it must match one of the

+                                languages specified in SupportedLanguages. The

+                                number of languages supported by a driver is up

+                                to the driver writer. Language is specified

+                                in RFC 3066 or ISO 639-2 language code format.

+  @param [out] ppDriverName     A pointer to the Unicode string to return.

+                                This Unicode string is the name of the

+                                driver specified by This in the language

+                                specified by Language.

+

+  @retval EFI_SUCCESS           The Unicode string for the Driver specified by

+                                This and the language specified by Language was

+                                returned in DriverName.

+  @retval EFI_INVALID_PARAMETER Language is NULL.

+  @retval EFI_INVALID_PARAMETER DriverName is NULL.

+  @retval EFI_UNSUPPORTED       The driver specified by This does not support

+                                the language specified by Language.

+

+**/

+EFI_STATUS

+EFIAPI

+GetDriverName (

+  IN  EFI_COMPONENT_NAME_PROTOCOL * pThis,

+  IN  CHAR8 * pLanguage,

+  OUT CHAR16 ** ppDriverName

+  );

+

+

+/**

+  Retrieves a Unicode string that is the user readable name of the controller

+  that is being managed by a driver.

+

+  This function retrieves the user readable name of the controller specified by

+  ControllerHandle and ChildHandle in the form of a Unicode string. If the

+  driver specified by This has a user readable name in the language specified by

+  Language, then a pointer to the controller name is returned in ControllerName,

+  and EFI_SUCCESS is returned.  If the driver specified by This is not currently

+  managing the controller specified by ControllerHandle and ChildHandle,

+  then EFI_UNSUPPORTED is returned.  If the driver specified by This does not

+  support the language specified by Language, then EFI_UNSUPPORTED is returned.

+

+  @param [in] pThis             A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or

+                                EFI_COMPONENT_NAME_PROTOCOL instance.

+  @param [in] ControllerHandle  The handle of a controller that the driver

+                                specified by This is managing.  This handle

+                                specifies the controller whose name is to be

+                                returned.

+  @param [in] ChildHandle       The handle of the child controller to retrieve

+                                the name of.  This is an optional parameter that

+                                may be NULL.  It will be NULL for device

+                                drivers.  It will also be NULL for a bus drivers

+                                that wish to retrieve the name of the bus

+                                controller.  It will not be NULL for a bus

+                                driver that wishes to retrieve the name of a

+                                child controller.

+  @param [in] pLanguage         A pointer to a Null-terminated ASCII string

+                                array indicating the language.  This is the

+                                language of the driver name that the caller is

+                                requesting, and it must match one of the

+                                languages specified in SupportedLanguages. The

+                                number of languages supported by a driver is up

+                                to the driver writer. Language is specified in

+                                RFC 3066 or ISO 639-2 language code format.

+  @param [out] ppControllerName A pointer to the Unicode string to return.

+                                This Unicode string is the name of the

+                                controller specified by ControllerHandle and

+                                ChildHandle in the language specified by

+                                Language from the point of view of the driver

+                                specified by This.

+

+  @retval EFI_SUCCESS           The Unicode string for the user readable name in

+                                the language specified by Language for the

+                                driver specified by This was returned in

+                                DriverName.

+  @retval EFI_INVALID_PARAMETER ControllerHandle is not a valid EFI_HANDLE.

+  @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid

+                                EFI_HANDLE.

+  @retval EFI_INVALID_PARAMETER Language is NULL.

+  @retval EFI_INVALID_PARAMETER ControllerName is NULL.

+  @retval EFI_UNSUPPORTED       The driver specified by This is not currently

+                                managing the controller specified by

+                                ControllerHandle and ChildHandle.

+  @retval EFI_UNSUPPORTED       The driver specified by This does not support

+                                the language specified by Language.

+

+**/

+EFI_STATUS

+EFIAPI

+GetControllerName (

+  IN  EFI_COMPONENT_NAME_PROTOCOL * pThis,

+  IN  EFI_HANDLE ControllerHandle,

+  IN OPTIONAL EFI_HANDLE ChildHandle,

+  IN  CHAR8 * pLanguage,

+  OUT CHAR16 ** ppControllerName

+  );

+  

+VOID 

+FillPkt2Queue (

+  IN EFI_SIMPLE_NETWORK_PROTOCOL * pSimpleNetwork,

+  IN UINTN BufLength);

+

+//------------------------------------------------------------------------------

+

+#endif  //  _AX88772_H_

diff --git a/OptionRomPkg/Bus/Usb/UsbNetworking/Ax88772b/Ax88772b.inf b/OptionRomPkg/Bus/Usb/UsbNetworking/Ax88772b/Ax88772b.inf
new file mode 100644
index 00000000..b1cf5621
--- /dev/null
+++ b/OptionRomPkg/Bus/Usb/UsbNetworking/Ax88772b/Ax88772b.inf
@@ -0,0 +1,72 @@
+#/** @file

+# Component description file for ASIX AX88772 USB/Ethernet driver.

+#

+# This module provides support for the ASIX AX88772 USB/Ethernet adapter.

+# Copyright (c) 2011, Intel Corporation

+#

+#  All rights reserved. This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution. The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = Ax88772b

+  FILE_GUID                      = 95C8D770-E1A4-4422-B263-E32F14FD8186

+  MODULE_TYPE                    = DXE_RUNTIME_DRIVER

+  VERSION_STRING                 = 1.0

+

+  ENTRY_POINT                    = EntryPoint

+

+#

+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC

+#

+

+[Sources.common]

+  Ax88772.h

+  Ax88772.c

+  ComponentName.c

+  DriverBinding.c

+  SimpleNetwork.c

+

+

+[Packages]

+  MdePkg/MdePkg.dec

+  MdeModulePkg/MdeModulePkg.dec

+

+[LibraryClasses]

+  UefiLib

+  UefiBootServicesTableLib

+  BaseMemoryLib

+  DebugLib

+  UefiRuntimeLib

+  UefiDriverEntryPoint

+

+[Protocols]

+  gEfiDevicePathProtocolGuid

+  gEfiSimpleNetworkProtocolGuid

+  gEfiUsbIoProtocolGuid                ## TO_START

+

+[Guids]

+  gEfiEventExitBootServicesGuid        ## PRODUCES ## Event

+  gEfiEventVirtualAddressChangeGuid    ## PRODUCES ## Event

+  gEfiNicIp4ConfigVariableGuid

+

+[Depex]

+  gEfiBdsArchProtocolGuid AND

+  gEfiCpuArchProtocolGuid AND

+  gEfiMetronomeArchProtocolGuid AND

+  gEfiMonotonicCounterArchProtocolGuid AND

+  gEfiRealTimeClockArchProtocolGuid AND

+  gEfiResetArchProtocolGuid AND

+  gEfiRuntimeArchProtocolGuid AND

+  gEfiSecurityArchProtocolGuid AND

+  gEfiTimerArchProtocolGuid AND

+  gEfiVariableWriteArchProtocolGuid AND

+  gEfiVariableArchProtocolGuid AND

+  gEfiWatchdogTimerArchProtocolGuid

diff --git a/OptionRomPkg/Bus/Usb/UsbNetworking/Ax88772b/ComponentName.c b/OptionRomPkg/Bus/Usb/UsbNetworking/Ax88772b/ComponentName.c
new file mode 100644
index 00000000..e78d76bc
--- /dev/null
+++ b/OptionRomPkg/Bus/Usb/UsbNetworking/Ax88772b/ComponentName.c
@@ -0,0 +1,181 @@
+/** @file

+  UEFI Component Name(2) protocol implementation.

+

+  Copyright (c) 2011, Intel Corporation

+  All rights reserved. This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include "Ax88772.h"

+

+/**

+  EFI Component Name Protocol declaration

+**/

+GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME_PROTOCOL  gComponentName = {

+  GetDriverName,

+  GetControllerName,

+  "eng"

+};

+

+/**

+  EFI Component Name 2 Protocol declaration

+**/

+GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME2_PROTOCOL gComponentName2 = {

+  (EFI_COMPONENT_NAME2_GET_DRIVER_NAME) GetDriverName,

+  (EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME) GetControllerName,

+  "en"

+};

+

+

+/**

+  Driver name table declaration

+**/

+GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE

+mDriverNameTable[] = {

+  {"eng;en", L"ASIX AX88772B Ethernet Driver 1.0"},

+  {NULL,  NULL}

+};

+

+/**

+  Retrieves a Unicode string that is the user readable name of the driver.

+

+  This function retrieves the user readable name of a driver in the form of a

+  Unicode string. If the driver specified by This has a user readable name in

+  the language specified by Language, then a pointer to the driver name is

+  returned in DriverName, and EFI_SUCCESS is returned. If the driver specified

+  by This does not support the language specified by Language,

+  then EFI_UNSUPPORTED is returned.

+

+  @param [in] pThis             A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or

+                                EFI_COMPONENT_NAME_PROTOCOL instance.

+  @param [in] pLanguage         A pointer to a Null-terminated ASCII string

+                                array indicating the language. This is the

+                                language of the driver name that the caller is

+                                requesting, and it must match one of the

+                                languages specified in SupportedLanguages. The

+                                number of languages supported by a driver is up

+                                to the driver writer. Language is specified

+                                in RFC 3066 or ISO 639-2 language code format.

+  @param [out] ppDriverName     A pointer to the Unicode string to return.

+                                This Unicode string is the name of the

+                                driver specified by This in the language

+                                specified by Language.

+

+  @retval EFI_SUCCESS           The Unicode string for the Driver specified by

+                                This and the language specified by Language was

+                                returned in DriverName.

+  @retval EFI_INVALID_PARAMETER Language is NULL.

+  @retval EFI_INVALID_PARAMETER DriverName is NULL.

+  @retval EFI_UNSUPPORTED       The driver specified by This does not support

+                                the language specified by Language.

+

+**/

+EFI_STATUS

+EFIAPI

+GetDriverName (

+  IN  EFI_COMPONENT_NAME_PROTOCOL * pThis,

+  IN  CHAR8 * pLanguage,

+  OUT CHAR16 ** ppDriverName

+  )

+{

+  EFI_STATUS Status;

+

+  Status = LookupUnicodeString2 (

+             pLanguage,

+             pThis->SupportedLanguages,

+             mDriverNameTable,

+             ppDriverName,

+             (BOOLEAN)(pThis == &gComponentName)

+             );

+

+  return Status;

+}

+

+/**

+  Retrieves a Unicode string that is the user readable name of the controller

+  that is being managed by a driver.

+

+  This function retrieves the user readable name of the controller specified by

+  ControllerHandle and ChildHandle in the form of a Unicode string. If the

+  driver specified by This has a user readable name in the language specified by

+  Language, then a pointer to the controller name is returned in ControllerName,

+  and EFI_SUCCESS is returned.  If the driver specified by This is not currently

+  managing the controller specified by ControllerHandle and ChildHandle,

+  then EFI_UNSUPPORTED is returned.  If the driver specified by This does not

+  support the language specified by Language, then EFI_UNSUPPORTED is returned.

+

+  @param [in] pThis             A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or

+                                EFI_COMPONENT_NAME_PROTOCOL instance.

+  @param [in] ControllerHandle  The handle of a controller that the driver

+                                specified by This is managing.  This handle

+                                specifies the controller whose name is to be

+                                returned.

+  @param [in] ChildHandle       The handle of the child controller to retrieve

+                                the name of.  This is an optional parameter that

+                                may be NULL.  It will be NULL for device

+                                drivers.  It will also be NULL for a bus drivers

+                                that wish to retrieve the name of the bus

+                                controller.  It will not be NULL for a bus

+                                driver that wishes to retrieve the name of a

+                                child controller.

+  @param [in] pLanguage         A pointer to a Null-terminated ASCII string

+                                array indicating the language.  This is the

+                                language of the driver name that the caller is

+                                requesting, and it must match one of the

+                                languages specified in SupportedLanguages. The

+                                number of languages supported by a driver is up

+                                to the driver writer. Language is specified in

+                                RFC 3066 or ISO 639-2 language code format.

+  @param [out] ppControllerName A pointer to the Unicode string to return.

+                                This Unicode string is the name of the

+                                controller specified by ControllerHandle and

+                                ChildHandle in the language specified by

+                                Language from the point of view of the driver

+                                specified by This.

+

+  @retval EFI_SUCCESS           The Unicode string for the user readable name in

+                                the language specified by Language for the

+                                driver specified by This was returned in

+                                DriverName.

+  @retval EFI_INVALID_PARAMETER ControllerHandle is not a valid EFI_HANDLE.

+  @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid

+                                EFI_HANDLE.

+  @retval EFI_INVALID_PARAMETER Language is NULL.

+  @retval EFI_INVALID_PARAMETER ControllerName is NULL.

+  @retval EFI_UNSUPPORTED       The driver specified by This is not currently

+                                managing the controller specified by

+                                ControllerHandle and ChildHandle.

+  @retval EFI_UNSUPPORTED       The driver specified by This does not support

+                                the language specified by Language.

+

+**/

+EFI_STATUS

+EFIAPI

+GetControllerName (

+  IN  EFI_COMPONENT_NAME_PROTOCOL * pThis,

+  IN  EFI_HANDLE ControllerHandle,

+  IN OPTIONAL EFI_HANDLE ChildHandle,

+  IN  CHAR8 * pLanguage,

+  OUT CHAR16 ** ppControllerName

+  )

+{

+  EFI_STATUS Status;

+

+  //

+  // Set the controller name

+  //

+  *ppControllerName = L"ASIX AX88772B USB Fast Ethernet Controller";

+  Status = EFI_SUCCESS;

+

+  //

+  // Return the operation status

+  //

+

+  return Status;

+}

diff --git a/OptionRomPkg/Bus/Usb/UsbNetworking/Ax88772b/DriverBinding.c b/OptionRomPkg/Bus/Usb/UsbNetworking/Ax88772b/DriverBinding.c
new file mode 100644
index 00000000..076b6396
--- /dev/null
+++ b/OptionRomPkg/Bus/Usb/UsbNetworking/Ax88772b/DriverBinding.c
@@ -0,0 +1,672 @@
+/** @file

+  Implement the driver binding protocol for Asix AX88772 Ethernet driver.

+                     

+  Copyright (c) 2011, Intel Corporation

+  All rights reserved. This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include "Ax88772.h"

+

+/**

+  Verify the controller type

+

+  @param [in] pThis                Protocol instance pointer.

+  @param [in] Controller           Handle of device to test.

+  @param [in] pRemainingDevicePath Not used.

+

+  @retval EFI_SUCCESS          This driver supports this device.

+  @retval other                This driver does not support this device.

+

+**/

+EFI_STATUS

+EFIAPI

+DriverSupported (

+  IN EFI_DRIVER_BINDING_PROTOCOL * pThis,

+  IN EFI_HANDLE Controller,

+  IN EFI_DEVICE_PATH_PROTOCOL * pRemainingDevicePath

+  )

+{

+  EFI_USB_DEVICE_DESCRIPTOR Device;

+  EFI_USB_IO_PROTOCOL * pUsbIo;

+  EFI_STATUS Status;

+  //

+  //  Connect to the USB stack

+  //

+  Status = gBS->OpenProtocol (

+                  Controller,

+                  &gEfiUsbIoProtocolGuid,

+                  (VOID **) &pUsbIo,

+                  pThis->DriverBindingHandle,         

+                  Controller,

+                  EFI_OPEN_PROTOCOL_BY_DRIVER

+                  );

+  if (!EFI_ERROR ( Status )) {

+

+    //

+    //  Get the interface descriptor to check the USB class and find a transport

+    //  protocol handler.

+    //

+    Status = pUsbIo->UsbGetDeviceDescriptor ( pUsbIo, &Device );

+    if (EFI_ERROR ( Status )) {

+    	Status = EFI_UNSUPPORTED;

+    }

+    else {

+      //

+      //  Validate the adapter

+      //   

+      if ( VENDOR_ID == Device.IdVendor ) {

+

+        if (PRODUCT_ID == Device.IdProduct) {

+            DEBUG ((EFI_D_INFO, "Found the AX88772B\r\n"));

+        }

+		    else  {

+			     Status = EFI_UNSUPPORTED;

+		    }

+      }

+	    else {

+		      Status = EFI_UNSUPPORTED;

+       }   

+    }

+   

+    //

+    //  Done with the USB stack

+    //

+    gBS->CloseProtocol (

+           Controller,

+           &gEfiUsbIoProtocolGuid,

+           pThis->DriverBindingHandle,

+           Controller

+           );

+  }

+  return Status;

+}

+

+

+/**

+  Start this driver on Controller by opening UsbIo and DevicePath protocols.

+  Initialize PXE structures, create a copy of the Controller Device Path with the

+  NIC's MAC address appended to it, install the NetworkInterfaceIdentifier protocol

+  on the newly created Device Path.

+

+  @param [in] pThis                Protocol instance pointer.

+  @param [in] Controller           Handle of device to work with.

+  @param [in] pRemainingDevicePath Not used, always produce all possible children.

+

+  @retval EFI_SUCCESS          This driver is added to Controller.

+  @retval other                This driver does not support this device.

+

+**/

+EFI_STATUS

+EFIAPI

+DriverStart (

+  IN EFI_DRIVER_BINDING_PROTOCOL * pThis,

+  IN EFI_HANDLE Controller,

+  IN EFI_DEVICE_PATH_PROTOCOL * pRemainingDevicePath

+  )

+{

+

+	EFI_STATUS						Status;

+	NIC_DEVICE						*pNicDevice;

+	UINTN							LengthInBytes;

+	EFI_DEVICE_PATH_PROTOCOL        *ParentDevicePath = NULL;

+	MAC_ADDR_DEVICE_PATH            MacDeviceNode;

+

+  //

+	//  Allocate the device structure

+	//

+	LengthInBytes = sizeof ( *pNicDevice );

+	Status = gBS->AllocatePool (

+                  EfiRuntimeServicesData,

+                  LengthInBytes,

+                  (VOID **) &pNicDevice

+                  );

+

+	if (EFI_ERROR (Status)) {

+		DEBUG ((EFI_D_ERROR, "gBS->AllocatePool:pNicDevice ERROR Status = %r\n", Status));

+		goto EXIT;

+	}

+	

+	//

+  //  Set the structure signature

+  //

+  ZeroMem ( pNicDevice, LengthInBytes );

+  pNicDevice->Signature = DEV_SIGNATURE;

+

+	Status = gBS->OpenProtocol (

+                    Controller,

+                    &gEfiUsbIoProtocolGuid,

+                    (VOID **) &pNicDevice->pUsbIo,

+                    pThis->DriverBindingHandle,

+                    Controller,

+                    EFI_OPEN_PROTOCOL_BY_DRIVER

+                    );

+

+	if (EFI_ERROR (Status)) {

+		DEBUG ((EFI_D_ERROR, "gBS->OpenProtocol:EFI_USB_IO_PROTOCOL ERROR Status = %r\n", Status));

+		gBS->FreePool ( pNicDevice );

+		goto EXIT;

+	}

+

+	//

+  //  Initialize the simple network protocol

+  //

+	Status = SN_Setup ( pNicDevice );

+

+	if (EFI_ERROR(Status)){

+	   DEBUG ((EFI_D_ERROR, "SN_Setup ERROR Status = %r\n", Status));

+	   gBS->CloseProtocol (

+					Controller,

+					&gEfiUsbIoProtocolGuid,

+					pThis->DriverBindingHandle,

+					Controller

+					);

+		  gBS->FreePool ( pNicDevice );

+		  goto EXIT;

+  }

+

+	//

+  // Set Device Path

+  //  			

+  Status = gBS->OpenProtocol (

+                  Controller,

+                  &gEfiDevicePathProtocolGuid,

+                  (VOID **) &ParentDevicePath,

+				          pThis->DriverBindingHandle,

+                  Controller,

+                  EFI_OPEN_PROTOCOL_BY_DRIVER

+                  );

+	if (EFI_ERROR(Status)) {

+        DEBUG ((EFI_D_ERROR, "gBS->OpenProtocol:EFI_DEVICE_PATH_PROTOCOL error. Status = %r\n",

+            Status));        

+		    gBS->CloseProtocol (

+					Controller,

+					&gEfiUsbIoProtocolGuid,

+					pThis->DriverBindingHandle,

+					Controller

+					);

+		  gBS->FreePool ( pNicDevice );

+		  goto EXIT;

+	}

+

+  ZeroMem (&MacDeviceNode, sizeof (MAC_ADDR_DEVICE_PATH));

+  MacDeviceNode.Header.Type = MESSAGING_DEVICE_PATH;

+  MacDeviceNode.Header.SubType = MSG_MAC_ADDR_DP;

+

+  SetDevicePathNodeLength (&MacDeviceNode.Header, sizeof (MAC_ADDR_DEVICE_PATH));

+      			

+  CopyMem (&MacDeviceNode.MacAddress,

+      								&pNicDevice->SimpleNetworkData.CurrentAddress,

+      								PXE_HWADDR_LEN_ETHER);

+      								

+  MacDeviceNode.IfType = pNicDevice->SimpleNetworkData.IfType;

+

+  pNicDevice->MyDevPath = AppendDevicePathNode (

+                                          ParentDevicePath,

+                                          (EFI_DEVICE_PATH_PROTOCOL *) &MacDeviceNode

+                                          );

+

+	pNicDevice->Controller = NULL;

+

+	//

+  //  Install both the simple network and device path protocols.

+  //

+  Status = gBS->InstallMultipleProtocolInterfaces (

+                          &pNicDevice->Controller,

+                          &gEfiCallerIdGuid,

+                          pNicDevice,

+                          &gEfiSimpleNetworkProtocolGuid,            

+                          &pNicDevice->SimpleNetwork,

+						              &gEfiDevicePathProtocolGuid,

+						              pNicDevice->MyDevPath,

+                          NULL

+                          );

+

+	if (EFI_ERROR(Status)){

+		DEBUG ((EFI_D_ERROR, "gBS->InstallMultipleProtocolInterfaces error. Status = %r\n",

+            Status)); 

+		gBS->CloseProtocol (

+					               Controller,

+					               &gEfiDevicePathProtocolGuid,

+					               pThis->DriverBindingHandle,

+					               Controller);

+	   gBS->CloseProtocol (

+					Controller,

+					&gEfiUsbIoProtocolGuid,

+					pThis->DriverBindingHandle,

+					Controller

+					);

+		  gBS->FreePool ( pNicDevice );

+		  goto EXIT;

+	}

+

+	//

+	// Open For Child Device

+	//

+	Status = gBS->OpenProtocol (                                                                         

+                  Controller,

+                  &gEfiUsbIoProtocolGuid,

+                  (VOID **) &pNicDevice->pUsbIo,

+                  pThis->DriverBindingHandle,

+                  pNicDevice->Controller,

+                  EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER

+                  );

+

+	if (EFI_ERROR(Status)){

+	   gBS->UninstallMultipleProtocolInterfaces (

+              &pNicDevice->Controller,

+                          &gEfiCallerIdGuid,

+                          pNicDevice,

+                          &gEfiSimpleNetworkProtocolGuid,            

+                          &pNicDevice->SimpleNetwork,

+						              &gEfiDevicePathProtocolGuid,

+						              pNicDevice->MyDevPath,

+                          NULL

+                          );

+		gBS->CloseProtocol (

+					               Controller,

+					               &gEfiDevicePathProtocolGuid,

+					               pThis->DriverBindingHandle,

+					               Controller);

+	   gBS->CloseProtocol (

+					Controller,

+					&gEfiUsbIoProtocolGuid,

+					pThis->DriverBindingHandle,

+					Controller

+					);

+		  gBS->FreePool ( pNicDevice );

+	}

+

+EXIT:

+	return Status;

+

+}

+

+/**

+  Stop this driver on Controller by removing NetworkInterfaceIdentifier protocol and

+  closing the DevicePath and PciIo protocols on Controller.

+

+  @param [in] pThis                Protocol instance pointer.

+  @param [in] Controller           Handle of device to stop driver on.

+  @param [in] NumberOfChildren     How many children need to be stopped.

+  @param [in] pChildHandleBuffer   Not used.

+

+  @retval EFI_SUCCESS          This driver is removed Controller.

+  @retval EFI_DEVICE_ERROR     The device could not be stopped due to a device error.

+  @retval other                This driver was not removed from this device.

+

+**/

+EFI_STATUS

+EFIAPI

+DriverStop (

+  IN  EFI_DRIVER_BINDING_PROTOCOL * pThis,

+  IN  EFI_HANDLE Controller,

+  IN  UINTN NumberOfChildren,

+  IN  EFI_HANDLE * ChildHandleBuffer

+  )

+{

+		BOOLEAN                                   AllChildrenStopped;

+		UINTN                                     Index;

+		EFI_SIMPLE_NETWORK_PROTOCOL				  *SimpleNetwork;

+		EFI_STATUS                                Status = EFI_SUCCESS;

+		NIC_DEVICE								  *pNicDevice;

+		

+		//

+		// Complete all outstanding transactions to Controller.

+		// Don't allow any new transaction to Controller to be started.

+		//

+		if (NumberOfChildren == 0) {

+		

+		  Status = gBS->OpenProtocol (

+				                Controller,

+				                &gEfiSimpleNetworkProtocolGuid,

+				                (VOID **) &SimpleNetwork,

+				                pThis->DriverBindingHandle,

+				                Controller,

+				                EFI_OPEN_PROTOCOL_GET_PROTOCOL

+				                );

+				                

+			if (EFI_ERROR(Status)) {

+        //

+        // This is a 2nd type handle(multi-lun root), it needs to close devicepath

+        // and usbio protocol.

+        //

+        gBS->CloseProtocol (

+            Controller,

+            &gEfiDevicePathProtocolGuid,

+            pThis->DriverBindingHandle,

+            Controller

+            );

+        gBS->CloseProtocol (

+            Controller,

+            &gEfiUsbIoProtocolGuid,

+            pThis->DriverBindingHandle,

+            Controller

+            );

+        return EFI_SUCCESS;

+      }

+      

+      pNicDevice = DEV_FROM_SIMPLE_NETWORK ( SimpleNetwork );

+      

+      Status = gBS->UninstallMultipleProtocolInterfaces (

+				                  Controller,				                  

+				                  &gEfiCallerIdGuid,

+                          pNicDevice,

+                          &gEfiSimpleNetworkProtocolGuid,            

+                          &pNicDevice->SimpleNetwork,

+						              &gEfiDevicePathProtocolGuid,

+						              pNicDevice->MyDevPath,

+                          NULL

+                          );

+                          

+      if (EFI_ERROR (Status)) {

+        return Status;

+      }

+		  //

+		  // Close the bus driver

+		  //

+		  Status = gBS->CloseProtocol (

+		                  Controller,

+		                  &gEfiDevicePathProtocolGuid,

+		                  pThis->DriverBindingHandle,

+		                  Controller

+		                  );

+

+		  if (EFI_ERROR(Status)){

+          DEBUG ((EFI_D_ERROR, "driver stop: gBS->CloseProtocol:EfiDevicePathProtocol error. Status %r\n", Status));

+		  }

+

+		  Status = gBS->CloseProtocol (

+		                  Controller,

+		                  &gEfiUsbIoProtocolGuid,

+		                  pThis->DriverBindingHandle,

+		                  Controller

+		                  );

+

+		  if (EFI_ERROR(Status)){

+          DEBUG ((EFI_D_ERROR, "driver stop: gBS->CloseProtocol:EfiUsbIoProtocol error. Status %r\n", Status));

+		  }

+      return EFI_SUCCESS;

+		} 

+		AllChildrenStopped = TRUE;

+

+		for (Index = 0; Index < NumberOfChildren; Index++) {

+

+				Status = gBS->OpenProtocol (

+				                ChildHandleBuffer[Index],

+				                &gEfiSimpleNetworkProtocolGuid,

+				                (VOID **) &SimpleNetwork,

+				                pThis->DriverBindingHandle,

+				                Controller,

+				                EFI_OPEN_PROTOCOL_GET_PROTOCOL

+				                );

+				                

+				if (EFI_ERROR (Status)) {

+          AllChildrenStopped = FALSE;

+          DEBUG ((EFI_D_ERROR, "Fail to stop No.%d multi-lun child handle when opening SimpleNetwork\n", (UINT32)Index));

+          continue;

+        } 

+        

+        pNicDevice = DEV_FROM_SIMPLE_NETWORK ( SimpleNetwork );

+        

+        gBS->CloseProtocol (

+				                    Controller,

+				                    &gEfiUsbIoProtocolGuid,

+				                    pThis->DriverBindingHandle,

+				                    ChildHandleBuffer[Index]

+				                    ); 

+				                    

+				Status = gBS->UninstallMultipleProtocolInterfaces (

+				                  ChildHandleBuffer[Index],				                  

+				                  &gEfiCallerIdGuid,

+                          pNicDevice,

+                          &gEfiSimpleNetworkProtocolGuid,            

+                          &pNicDevice->SimpleNetwork,

+						              &gEfiDevicePathProtocolGuid,

+						              pNicDevice->MyDevPath,

+                          NULL

+                          );

+                          

+        if (EFI_ERROR (Status)) {

+            Status = gBS->OpenProtocol (                                                                         

+                  Controller,

+                  &gEfiUsbIoProtocolGuid,

+                  (VOID **) &pNicDevice->pUsbIo,

+                  pThis->DriverBindingHandle,

+                  ChildHandleBuffer[Index],

+                  EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER

+                  );

+        }

+        else {

+            int i;

+            RX_PKT * pCurr = pNicDevice->QueueHead;

+            RX_PKT * pFree;

+            

+            for ( i = 0 ; i < MAX_QUEUE_SIZE ; i++) {

+                 if ( NULL != pCurr ) {

+                    pFree = pCurr;

+                    pCurr = pCurr->pNext;

+                    gBS->FreePool (pFree);

+                 }

+            }

+            

+            if ( NULL != pNicDevice->pRxTest)

+						    gBS->FreePool (pNicDevice->pRxTest);

+

+					 if ( NULL != pNicDevice->pTxTest)

+						    gBS->FreePool (pNicDevice->pTxTest);

+

+           if ( NULL != pNicDevice->MyDevPath)

+					       gBS->FreePool (pNicDevice->MyDevPath);

+		  

+				    if ( NULL != pNicDevice)

+                  gBS->FreePool (pNicDevice);

+        }

+    }

+        

+        if (!AllChildrenStopped) {

+                return EFI_DEVICE_ERROR;

+        }

+        return EFI_SUCCESS;

+}

+

+

+/**

+  Driver binding protocol declaration

+**/

+EFI_DRIVER_BINDING_PROTOCOL  gDriverBinding = {

+  DriverSupported,

+  DriverStart,

+  DriverStop,

+  0xa,

+  NULL,

+  NULL

+};

+

+

+/**

+  Ax88772 driver unload routine.

+

+  @param [in] ImageHandle       Handle for the image.

+

+  @retval EFI_SUCCESS           Image may be unloaded

+

+**/

+EFI_STATUS

+EFIAPI

+DriverUnload (

+  IN EFI_HANDLE ImageHandle

+  )

+{

+  UINTN BufferSize;

+  UINTN Index;

+  UINTN Max;

+  EFI_HANDLE * pHandle;

+  EFI_STATUS Status;

+

+  //

+  //  Determine which devices are using this driver

+  //

+  BufferSize = 0;

+  pHandle = NULL;

+  Status = gBS->LocateHandle (

+                  ByProtocol,

+                  &gEfiCallerIdGuid,

+                  NULL,

+                  &BufferSize,

+                  NULL );

+  if ( EFI_BUFFER_TOO_SMALL == Status ) {

+    for ( ; ; ) {

+      //

+      //  One or more block IO devices are present

+      //

+      Status = gBS->AllocatePool (

+                      EfiRuntimeServicesData,

+                      BufferSize,

+                      (VOID **) &pHandle

+                      );

+      if ( EFI_ERROR ( Status )) {

+        DEBUG ((EFI_D_ERROR, "Insufficient memory, failed handle buffer allocation\r\n"));

+        break;

+      }

+

+      //

+      //  Locate the block IO devices

+      //

+      Status = gBS->LocateHandle (

+                      ByProtocol,

+                      &gEfiCallerIdGuid,

+                      NULL,

+                      &BufferSize,

+                      pHandle );

+      if ( EFI_ERROR ( Status )) {

+        //

+        //  Error getting handles

+        //

+        break;

+      }

+      

+      //

+      //  Remove any use of the driver

+      //

+      Max = BufferSize / sizeof ( pHandle[ 0 ]);

+      for ( Index = 0; Max > Index; Index++ ) {

+        Status = DriverStop ( &gDriverBinding,

+                              pHandle[ Index ],

+                              0,

+                              NULL );

+        if ( EFI_ERROR ( Status )) {

+          DEBUG ((EFI_D_ERROR, "WARNING - Failed to shutdown the driver on handle %08x\r\n", pHandle[ Index ]));

+          break;

+        }

+      }

+      break;

+    }

+  }

+  else {

+    if ( EFI_NOT_FOUND == Status ) {

+      //

+      //  No devices were found

+      //

+      Status = EFI_SUCCESS;

+    }

+  }

+

+  //

+  //  Free the handle array          

+  //

+  if ( NULL != pHandle ) {

+    gBS->FreePool ( pHandle );

+  }

+

+  //

+  //  Remove the protocols installed by the EntryPoint routine.

+  //

+  if ( !EFI_ERROR ( Status )) {

+    gBS->UninstallMultipleProtocolInterfaces (

+            ImageHandle,

+            &gEfiDriverBindingProtocolGuid,

+            &gDriverBinding,                              

+            &gEfiComponentNameProtocolGuid,

+            &gComponentName,

+            &gEfiComponentName2ProtocolGuid,

+            &gComponentName2,

+            NULL

+            );

+

+    DEBUG (( DEBUG_POOL | DEBUG_INIT | DEBUG_INFO,

+            "Removed:   gEfiComponentName2ProtocolGuid from 0x%08x\r\n",

+            ImageHandle ));

+    DEBUG (( DEBUG_POOL | DEBUG_INIT | DEBUG_INFO,

+              "Removed:   gEfiComponentNameProtocolGuid from 0x%08x\r\n",

+              ImageHandle ));

+    DEBUG (( DEBUG_POOL | DEBUG_INIT | DEBUG_INFO,

+              "Removed:   gEfiDriverBindingProtocolGuid from 0x%08x\r\n",

+              ImageHandle ));

+

+  }

+

+  return Status;

+}

+

+

+/**

+Ax88772 driver entry point.

+

+@param [in] ImageHandle       Handle for the image.

+@param [in] pSystemTable      Address of the system table.

+

+@retval EFI_SUCCESS           Image successfully loaded.

+

+**/

+EFI_STATUS

+EFIAPI

+EntryPoint (

+  IN EFI_HANDLE ImageHandle,

+  IN EFI_SYSTEM_TABLE * pSystemTable

+  )

+{

+  EFI_LOADED_IMAGE_PROTOCOL * pLoadedImage;

+  EFI_STATUS    Status;

+

+  //

+  //  Enable unload support

+  //

+  Status = gBS->HandleProtocol (

+                  gImageHandle,

+                  &gEfiLoadedImageProtocolGuid,

+                  (VOID **)&pLoadedImage

+                  );

+  if (!EFI_ERROR (Status)) {

+    pLoadedImage->Unload = DriverUnload;

+  }

+

+  //

+  //  Add the driver to the list of drivers

+  //

+  Status = EfiLibInstallDriverBindingComponentName2 (

+             ImageHandle,

+             pSystemTable,

+             &gDriverBinding,

+             ImageHandle,

+             &gComponentName,

+             &gComponentName2

+             );

+  if ( !EFI_ERROR ( Status )) {

+

+    AsciiPrint ("Installed: gEfiDriverBindingProtocolGuid on   0x%08x\r\n",

+              ImageHandle );

+    AsciiPrint("Installed: gEfiComponentNameProtocolGuid on   0x%08x\r\n",

+              ImageHandle );

+    AsciiPrint("Installed: gEfiComponentName2ProtocolGuid on   0x%08x\r\n",

+              ImageHandle );

+

+  }

+  return Status;

+}

diff --git a/OptionRomPkg/Bus/Usb/UsbNetworking/Ax88772b/SimpleNetwork.c b/OptionRomPkg/Bus/Usb/UsbNetworking/Ax88772b/SimpleNetwork.c
new file mode 100644
index 00000000..be751618
--- /dev/null
+++ b/OptionRomPkg/Bus/Usb/UsbNetworking/Ax88772b/SimpleNetwork.c
@@ -0,0 +1,1574 @@
+/** @file

+  Provides the Simple Network functions.

+

+  Copyright (c) 2011, Intel Corporation

+  All rights reserved. This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include "Ax88772.h"

+

+/**

+  This function updates the filtering on the receiver.

+

+  This support routine calls ::Ax88772MacAddressSet to update

+  the MAC address.  This routine then rebuilds the multicast

+  hash by calling ::Ax88772MulticastClear and ::Ax88772MulticastSet.

+  Finally this routine enables the receiver by calling

+  ::Ax88772RxControl.

+                                                                                  

+  @param [in] pSimpleNetwork    Simple network mode pointer  

+

+  @retval EFI_SUCCESS           This operation was successful.

+  @retval EFI_NOT_STARTED       The network interface was not started.

+  @retval EFI_INVALID_PARAMETER pSimpleNetwork parameter was NULL or did not point to a valid

+                                EFI_SIMPLE_NETWORK_PROTOCOL structure.

+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.

+  @retval EFI_UNSUPPORTED       The increased buffer size feature is not supported.

+

+**/

+EFI_STATUS

+ReceiveFilterUpdate (

+  IN EFI_SIMPLE_NETWORK_PROTOCOL * pSimpleNetwork

+  )

+{

+  EFI_SIMPLE_NETWORK_MODE * pMode;

+  NIC_DEVICE * pNicDevice;

+  EFI_STATUS Status;

+  UINT32 Index;

+

+  //

+  // Set the MAC address

+  //

+  pNicDevice = DEV_FROM_SIMPLE_NETWORK ( pSimpleNetwork );

+  pMode = pSimpleNetwork->Mode;

+

+  //

+  // Clear the multicast hash table

+  //

+  Ax88772MulticastClear ( pNicDevice );

+

+  //

+  // Load the multicast hash table

+  //

+  if ( 0 != ( pMode->ReceiveFilterSetting & EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST )) {

+      for ( Index = 0; Index < pMode->MCastFilterCount; Index++ ) {

+        //

+        // Enable the next multicast address

+        //

+        Ax88772MulticastSet ( pNicDevice,

+                              &pMode->MCastFilter[ Index ].Addr[0]);

+      }

+  }

+

+  Status = Ax88772RxControl ( pNicDevice, pMode->ReceiveFilterSetting );

+

+  return Status;

+}

+

+

+/**

+  This function updates the SNP driver status.

+  

+  This function gets the current interrupt and recycled transmit

+  buffer status from the network interface.  The interrupt status

+  and the media status are returned as a bit mask in InterruptStatus.

+  If InterruptStatus is NULL, the interrupt status will not be read.

+  Upon successful return of the media status, the MediaPresent field

+  of EFI_SIMPLE_NETWORK_MODE will be updated to reflect any change

+  of media status.  If TxBuf is not NULL, a recycled transmit buffer

+  address will be retrived.  If a recycled transmit buffer address

+  is returned in TxBuf, then the buffer has been successfully

+  transmitted, and the status for that buffer is cleared.

+

+  This function calls ::Ax88772Rx to update the media status and

+  queue any receive packets.

+

+  @param [in] pSimpleNetwork    Protocol instance pointer

+  @param [in] pInterruptStatus  A pointer to the bit mask of the current active interrupts.

+                                If this is NULL, the interrupt status will not be read from

+                                the device.  If this is not NULL, the interrupt status will

+                                be read from teh device.  When the interrupt status is read,

+                                it will also be cleared.  Clearing the transmit interrupt

+                                does not empty the recycled transmit buffer array.

+  @param [out] ppTxBuf          Recycled transmit buffer address.  The network interface will

+                                not transmit if its internal recycled transmit buffer array is

+                                full.  Reading the transmit buffer does not clear the transmit

+                                interrupt.  If this is NULL, then the transmit buffer status

+                                will not be read.  If there are not transmit buffers to recycle

+                                and TxBuf is not NULL, *TxBuf will be set to NULL.

+

+  @retval EFI_SUCCESS           This operation was successful.

+  @retval EFI_NOT_STARTED       The network interface was not started.

+  @retval EFI_INVALID_PARAMETER pSimpleNetwork parameter was NULL or did not point to a valid

+                                EFI_SIMPLE_NETWORK_PROTOCOL structure.

+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.

+

+**/

+EFI_STATUS

+EFIAPI

+SN_GetStatus (

+  IN EFI_SIMPLE_NETWORK_PROTOCOL * pSimpleNetwork,

+  OUT UINT32 * pInterruptStatus,

+  OUT VOID ** ppTxBuf

+  )

+{

+  EFI_SIMPLE_NETWORK_MODE * pMode;

+  NIC_DEVICE * pNicDevice;

+  EFI_STATUS Status;

+  BOOLEAN bFullDuplex;

+  BOOLEAN bLinkUp;

+  BOOLEAN bSpeed100;

+  EFI_TPL TplPrevious;

+ 

+  TplPrevious = gBS->RaiseTPL(TPL_CALLBACK);

+  //

+  // Verify the parameters

+  //

+  if (( NULL != pSimpleNetwork ) && ( NULL != pSimpleNetwork->Mode )) {

+    //

+    // Return the transmit buffer

+    //

+    

+    pNicDevice = DEV_FROM_SIMPLE_NETWORK ( pSimpleNetwork );

+    if (( NULL != ppTxBuf ) && ( NULL != pNicDevice->pTxBuffer )) {

+     		 *ppTxBuf = pNicDevice->pTxBuffer;

+     		 pNicDevice->pTxBuffer = NULL;

+   	}

+    

+    //

+    // Determine if interface is running

+    //

+    pMode = pSimpleNetwork->Mode;

+    if ( EfiSimpleNetworkInitialized == pMode->State ) {

+

+      if ( pNicDevice->LinkIdleCnt > MAX_LINKIDLE_THRESHOLD) {

+

+          bLinkUp = pNicDevice->bLinkUp;

+          bSpeed100 = pNicDevice->b100Mbps;

+          bFullDuplex = pNicDevice->bFullDuplex;

+          Status = Ax88772NegotiateLinkComplete ( pNicDevice,

+                                            &pNicDevice->PollCount,

+                                            &pNicDevice->bComplete,

+                                            &pNicDevice->bLinkUp,

+                                            &pNicDevice->b100Mbps,

+                                            &pNicDevice->bFullDuplex );

+

+          //

+          // Determine if the autonegotiation is complete

+          //

+          if ( pNicDevice->bComplete ) {

+              if ( pNicDevice->bLinkUp ) {

+                  if (( bSpeed100 && ( !pNicDevice->b100Mbps ))

+                      || (( !bSpeed100 ) && pNicDevice->b100Mbps )

+                      || ( bFullDuplex && ( !pNicDevice->bFullDuplex ))

+                      || (( !bFullDuplex ) && pNicDevice->bFullDuplex )) {

+                          pNicDevice->PollCount = 0;

+                          DEBUG (( EFI_D_INFO , "Reset to establish proper link setup: %d Mbps, %a duplex\r\n",

+                                    pNicDevice->b100Mbps ? 100 : 10, pNicDevice->bFullDuplex ? "Full" : "Half"));

+                          Status = SN_Reset ( &pNicDevice->SimpleNetwork, FALSE );

+                  }

+                  if (( !bLinkUp ) && pNicDevice->bLinkUp ) {

+                      //

+                      // Display the autonegotiation status

+                      //

+                      DEBUG (( EFI_D_INFO , "Link: Up, %d Mbps, %a duplex\r\n",

+                                pNicDevice->b100Mbps ? 100 : 10, pNicDevice->bFullDuplex ? "Full" : "Half"));

+

+                  }

+                  pNicDevice->LinkIdleCnt = 0;

+            }

+        }

+        //

+        //  Update the link status

+        //

+        if ( bLinkUp && ( !pNicDevice->bLinkUp )) {

+            DEBUG (( EFI_D_INFO , "Link: Down\r\n"));

+        }

+      }

+

+      pMode->MediaPresent = pNicDevice->bLinkUp;

+      //

+      // Return the interrupt status

+      //

+      if ( NULL != pInterruptStatus ) {

+        *pInterruptStatus = 0;

+      }   

+      Status = EFI_SUCCESS;

+    }

+    else {

+      Status = EFI_NOT_STARTED;

+    }

+      

+  }

+  else {

+    Status = EFI_INVALID_PARAMETER;

+  }

+  gBS->RestoreTPL(TplPrevious) ;

+

+  return Status;

+}

+

+

+/**

+  Resets the network adapter and allocates the transmit and receive buffers

+  required by the network interface; optionally, also requests allocation of

+  additional transmit and receive buffers.  This routine must be called before

+  any other routine in the Simple Network protocol is called.

+

+  @param [in] pSimpleNetwork    Protocol instance pointer

+  @param [in] ExtraRxBufferSize Size in bytes to add to the receive buffer allocation

+  @param [in] ExtraTxBufferSize Size in bytes to add to the transmit buffer allocation

+

+  @retval EFI_SUCCESS           This operation was successful.

+  @retval EFI_NOT_STARTED       The network interface was not started.

+  @retval EFI_OUT_OF_RESORUCES  There was not enough memory for the transmit and receive buffers

+  @retval EFI_INVALID_PARAMETER pSimpleNetwork parameter was NULL or did not point to a valid

+                                EFI_SIMPLE_NETWORK_PROTOCOL structure.

+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.

+  @retval EFI_UNSUPPORTED       The increased buffer size feature is not supported.

+

+**/

+EFI_STATUS

+EFIAPI

+SN_Initialize (                                              

+  IN EFI_SIMPLE_NETWORK_PROTOCOL * pSimpleNetwork,

+  IN UINTN ExtraRxBufferSize,

+  IN UINTN ExtraTxBufferSize

+  )

+{

+  EFI_SIMPLE_NETWORK_MODE * pMode;

+  EFI_STATUS Status;

+  UINT32  TmpState;

+   EFI_TPL TplPrevious;

+   

+   TplPrevious = gBS->RaiseTPL (TPL_CALLBACK);

+  //

+  // Verify the parameters

+  //

+  if (( NULL != pSimpleNetwork ) && ( NULL != pSimpleNetwork->Mode )) {

+    //

+    // Determine if the interface is already started

+    //

+    pMode = pSimpleNetwork->Mode;

+    if ( EfiSimpleNetworkStarted == pMode->State ) {

+      if (( 0 == ExtraRxBufferSize ) && ( 0 == ExtraTxBufferSize )) {

+        //

+        // Start the adapter

+        //

+        TmpState = pMode->State;

+        pMode->State = EfiSimpleNetworkInitialized;

+        Status = SN_Reset ( pSimpleNetwork, FALSE );

+        if ( EFI_ERROR ( Status )) {

+          //

+          // Update the network state

+          //

+          pMode->State = TmpState;

+          DEBUG (( EFI_D_ERROR , "SN_reset failed\n"));

+        }

+      }

+      else {

+        DEBUG (( EFI_D_ERROR , "Increase ExtraRxBufferSize = %d ExtraTxBufferSize=%d\n", 

+              ExtraRxBufferSize, ExtraTxBufferSize));

+        Status = EFI_UNSUPPORTED;

+      }

+    }

+    else {

+      Status = EFI_NOT_STARTED;

+    }

+  }

+  else {

+    Status = EFI_INVALID_PARAMETER;

+  }

+  gBS->RestoreTPL (TplPrevious);

+

+  return Status;

+}

+

+

+/**

+  This function converts a multicast IP address to a multicast HW MAC address

+  for all packet transactions.

+

+  @param [in] pSimpleNetwork    Protocol instance pointer

+  @param [in] bIPv6             Set to TRUE if the multicast IP address is IPv6 [RFC2460].

+                                Set to FALSE if the multicast IP address is IPv4 [RFC 791].

+  @param [in] pIP               The multicast IP address that is to be converted to a

+                                multicast HW MAC address.

+  @param [in] pMAC              The multicast HW MAC address that is to be generated from IP.

+

+  @retval EFI_SUCCESS           This operation was successful.

+  @retval EFI_NOT_STARTED       The network interface was not started.

+  @retval EFI_INVALID_PARAMETER pSimpleNetwork parameter was NULL or did not point to a valid

+                                EFI_SIMPLE_NETWORK_PROTOCOL structure.

+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.

+  @retval EFI_UNSUPPORTED       The increased buffer size feature is not supported.

+

+**/

+EFI_STATUS

+EFIAPI

+SN_MCastIPtoMAC (

+  IN EFI_SIMPLE_NETWORK_PROTOCOL * pSimpleNetwork,

+  IN BOOLEAN bIPv6,

+  IN EFI_IP_ADDRESS * pIP,

+  IN EFI_MAC_ADDRESS * pMAC

+  )

+{

+  EFI_STATUS Status;

+  EFI_TPL TplPrevious;

+

+  TplPrevious = gBS->RaiseTPL(TPL_CALLBACK);

+  //

+  // Get pointer to SNP driver instance for *this.

+  //

+  if (pSimpleNetwork == NULL) {

+    gBS->RestoreTPL(TplPrevious);

+    return EFI_INVALID_PARAMETER;

+  }

+

+  if (pIP == NULL || pMAC == NULL) {

+    gBS->RestoreTPL(TplPrevious);

+    return EFI_INVALID_PARAMETER;

+  }

+

+  if (bIPv6){

+    Status = EFI_UNSUPPORTED;

+  }  

+  else {

+      //

+      // check if the ip given is a mcast IP

+      //

+      if ((pIP->v4.Addr[0] & 0xF0) != 0xE0) {

+        gBS->RestoreTPL(TplPrevious);

+        return EFI_INVALID_PARAMETER;

+      }

+      else {

+        pMAC->Addr[0] = 0x01;

+        pMAC->Addr[1] = 0x00;

+        pMAC->Addr[2] = 0x5e;

+        pMAC->Addr[3] = (UINT8) (pIP->v4.Addr[1] & 0x7f);

+        pMAC->Addr[4] = (UINT8) pIP->v4.Addr[2];

+        pMAC->Addr[5] = (UINT8) pIP->v4.Addr[3];

+        Status = EFI_SUCCESS;

+        gBS->RestoreTPL(TplPrevious);

+      }

+  }

+  return Status;

+}

+

+

+/**

+  This function performs read and write operations on the NVRAM device

+  attached to a network interface.

+

+  @param [in] pSimpleNetwork    Protocol instance pointer

+  @param [in] ReadWrite         TRUE for read operations, FALSE for write operations.

+  @param [in] Offset            Byte offset in the NVRAM device at which to start the

+                                read or write operation.  This must be a multiple of

+                                NvRamAccessSize and less than NvRamSize.

+  @param [in] BufferSize        The number of bytes to read or write from the NVRAM device.

+                                This must also be a multiple of NvramAccessSize.

+  @param [in, out] pBuffer      A pointer to the data buffer.

+

+  @retval EFI_SUCCESS           This operation was successful.

+  @retval EFI_NOT_STARTED       The network interface was not started.

+  @retval EFI_INVALID_PARAMETER pSimpleNetwork parameter was NULL or did not point to a valid

+                                EFI_SIMPLE_NETWORK_PROTOCOL structure.

+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.

+  @retval EFI_UNSUPPORTED       The increased buffer size feature is not supported.

+

+**/

+EFI_STATUS

+EFIAPI

+SN_NvData (

+  IN EFI_SIMPLE_NETWORK_PROTOCOL * pSimpleNetwork,

+  IN BOOLEAN ReadWrite,

+  IN UINTN Offset,

+  IN UINTN BufferSize,

+  IN OUT VOID * pBuffer

+  )

+{

+  EFI_STATUS Status;

+  //

+  // This is not currently supported

+  //

+  Status = EFI_UNSUPPORTED;

+  return Status;

+}

+

+VOID 

+FillPkt2Queue (

+  IN EFI_SIMPLE_NETWORK_PROTOCOL * pSimpleNetwork,

+  IN UINTN BufLength)

+{

+

+  UINT16 * pLength;

+  UINT16 * pLengthBar;

+  UINT8* pData;

+  UINT32 offset;

+  NIC_DEVICE * pNicDevice;

+  

+  pNicDevice = DEV_FROM_SIMPLE_NETWORK ( pSimpleNetwork);

+  for ( offset = 0; offset < BufLength; ){

+      pLength = (UINT16*) (pNicDevice->pBulkInBuff + offset);

+      pLengthBar = (UINT16*) (pNicDevice->pBulkInBuff + offset +2);

+      

+      *pLength &= 0x7ff;

+      *pLengthBar &= 0x7ff;

+      *pLengthBar |= 0xf800;

+      

+      if ((*pLength ^ *pLengthBar ) != 0xFFFF) {

+          DEBUG (( EFI_D_ERROR , "Pkt length error. BufLength = %d\n", BufLength));

+          return;

+      }          

+      

+      if (TRUE == pNicDevice->pNextFill->f_Used) {

+        return;

+      }

+      else {

+          pData = pNicDevice->pBulkInBuff + offset + 4;

+          pNicDevice->pNextFill->f_Used = TRUE;

+          pNicDevice->pNextFill->Length = *pLength;

+          CopyMem (&pNicDevice->pNextFill->Data[0], pData, *pLength);

+          

+          pNicDevice->pNextFill = pNicDevice->pNextFill->pNext;

+          offset += ((*pLength + HW_HDR_LENGTH - 1) &~3) + 1;

+          pNicDevice->PktCntInQueue++;

+      }

+              

+  }

+}

+

+EFI_STATUS

+EFIAPI

+SN_Receive (

+  IN EFI_SIMPLE_NETWORK_PROTOCOL * pSimpleNetwork,

+  OUT UINTN                      * pHeaderSize,

+  OUT UINTN                      * pBufferSize,

+  OUT VOID                       * pBuffer,

+  OUT EFI_MAC_ADDRESS            * pSrcAddr,

+  OUT EFI_MAC_ADDRESS            * pDestAddr,

+  OUT UINT16                     * pProtocol

+  )

+{

+  EFI_SIMPLE_NETWORK_MODE * pMode;

+  NIC_DEVICE * pNicDevice;

+  EFI_STATUS Status;

+  EFI_TPL TplPrevious;

+  UINT16 Type;

+  EFI_USB_IO_PROTOCOL *pUsbIo;

+  UINTN LengthInBytes;

+  UINT32 TransferStatus;

+  RX_PKT * pFirstFill;

+  TplPrevious = gBS->RaiseTPL (TPL_CALLBACK);

+  

+  //

+  // Verify the parameters

+  //

+  if (( NULL != pSimpleNetwork ) && ( NULL != pSimpleNetwork->Mode )) {

+    //

+    // The interface must be running

+    //

+    pMode = pSimpleNetwork->Mode;

+    if ( EfiSimpleNetworkInitialized == pMode->State ) {

+      //

+      // Update the link status

+      //

+      pNicDevice = DEV_FROM_SIMPLE_NETWORK ( pSimpleNetwork );

+      pNicDevice->LinkIdleCnt++;

+      pMode->MediaPresent = pNicDevice->bLinkUp;

+      

+      if ( pMode->MediaPresent && pNicDevice->bComplete) {

+      

+      

+        if (pNicDevice->PktCntInQueue != 0 ) {

+            DEBUG (( EFI_D_INFO, "pNicDevice->PktCntInQueue = %d\n",

+                pNicDevice->PktCntInQueue));

+        }

+        

+        LengthInBytes = MAX_BULKIN_SIZE;

+        if (pNicDevice->PktCntInQueue == 0 ){

+            //

+            // Attempt to do bulk in

+            //

+            SetMem (&pNicDevice->pBulkInBuff[0], 4, 0);

+            pUsbIo = pNicDevice->pUsbIo;

+            Status = pUsbIo->UsbBulkTransfer ( pUsbIo,

+                                       USB_ENDPOINT_DIR_IN | BULK_IN_ENDPOINT,

+                                       &pNicDevice->pBulkInBuff[0],

+                                       &LengthInBytes,

+                                       BULKIN_TIMEOUT,

+                                       &TransferStatus );

+                                       

+            if (LengthInBytes != 0 && !EFI_ERROR(Status) && !EFI_ERROR(TransferStatus) ){

+                FillPkt2Queue(pSimpleNetwork, LengthInBytes);

+            }

+        }

+        

+        pFirstFill = pNicDevice->pFirstFill;

+         

+        if (TRUE == pFirstFill->f_Used) {

+            ETHERNET_HEADER * pHeader;

+            pNicDevice->LinkIdleCnt = 0;

+            CopyMem (pBuffer,  &pFirstFill->Data[0], pFirstFill->Length);

+            pHeader = (ETHERNET_HEADER *) &pFirstFill->Data[0];

+                     

+            DEBUG (( EFI_D_INFO, "RX: %02x-%02x-%02x-%02x-%02x-%02x " 

+                      "%02x-%02x-%02x-%02x-%02x-%02x  %02x-%02x  %d bytes\r\n",

+                      pFirstFill->Data[0],

+                      pFirstFill->Data[1],

+                      pFirstFill->Data[2],

+                      pFirstFill->Data[3],

+                      pFirstFill->Data[4],

+                      pFirstFill->Data[5],

+                      pFirstFill->Data[6],

+                      pFirstFill->Data[7],

+                      pFirstFill->Data[8],

+                      pFirstFill->Data[9],

+                      pFirstFill->Data[10],

+                      pFirstFill->Data[11],

+                      pFirstFill->Data[12],

+                      pFirstFill->Data[13],

+                      pFirstFill->Length));   

+            

+            if ( NULL != pHeaderSize ) {

+              *pHeaderSize = sizeof ( *pHeader );

+            }

+            if ( NULL != pDestAddr ) {

+               CopyMem ( pDestAddr, &pHeader->dest_addr, PXE_HWADDR_LEN_ETHER );

+            }

+            if ( NULL != pSrcAddr ) {

+             CopyMem ( pSrcAddr, &pHeader->src_addr, PXE_HWADDR_LEN_ETHER );

+            }

+            if ( NULL != pProtocol ) {

+              Type = pHeader->type;

+              Type = (UINT16)(( Type >> 8 ) | ( Type << 8 ));

+              *pProtocol = Type;

+            }

+            Status = EFI_SUCCESS;

+            if (*pBufferSize < pFirstFill->Length) {

+                  DEBUG (( EFI_D_ERROR, "RX: Buffer was too small"));

+                  Status = EFI_BUFFER_TOO_SMALL;

+            }

+            *pBufferSize =  pFirstFill->Length;

+            pFirstFill->f_Used = FALSE;

+            pNicDevice->pFirstFill = pFirstFill->pNext;

+            pNicDevice->PktCntInQueue--;

+        }

+        else {

+            pNicDevice->LinkIdleCnt++;

+            Status = EFI_NOT_READY;

+        }

+      }

+      else {

+        //

+        //  Link no up

+        //

+        pNicDevice->LinkIdleCnt++;

+        Status = EFI_NOT_READY; 

+      }

+      

+    }

+    else {

+      Status = EFI_NOT_STARTED;

+    }

+  }

+  else {

+    Status = EFI_INVALID_PARAMETER;

+  }                              

+  gBS->RestoreTPL (TplPrevious);

+  return Status;

+}

+

+/**

+  This function is used to enable and disable the hardware and software receive

+  filters for the underlying network device.

+

+  The receive filter change is broken down into three steps:

+

+    1.  The filter mask bits that are set (ON) in the Enable parameter

+        are added to the current receive filter settings.

+

+    2.  The filter mask bits that are set (ON) in the Disable parameter

+        are subtracted from the updated receive filter settins.

+

+    3.  If the resulting filter settigns is not supported by the hardware

+        a more liberal setting is selected.

+

+  If the same bits are set in the Enable and Disable parameters, then the bits

+  in the Disable parameter takes precedence.

+

+  If the ResetMCastFilter parameter is TRUE, then the multicast address list

+  filter is disabled (irregardless of what other multicast bits are set in

+  the enable and Disable parameters).  The SNP->Mode->MCastFilterCount field

+  is set to zero.  The SNP->Mode->MCastFilter contents are undefined.

+

+  After enableing or disabling receive filter settings, software should

+  verify the new settings by checking the SNP->Mode->ReceeiveFilterSettings,

+  SNP->Mode->MCastFilterCount and SNP->Mode->MCastFilter fields.

+

+  Note: Some network drivers and/or devices will automatically promote

+  receive filter settings if the requested setting can not be honored.

+  For example, if a request for four multicast addresses is made and

+  the underlying hardware only supports two multicast addresses the

+  driver might set the promiscuous or promiscuous multicast receive filters

+  instead.  The receiving software is responsible for discarding any extra

+  packets that get through the hardware receive filters.

+

+  If ResetMCastFilter is TRUE, then the multicast receive filter list

+  on the network interface will be reset to the default multicast receive

+  filter list.  If ResetMCastFilter is FALSE, and this network interface

+  allows the multicast receive filter list to be modified, then the

+  MCastFilterCnt and MCastFilter are used to update the current multicast

+  receive filter list.  The modified receive filter list settings can be

+  found in the MCastFilter field of EFI_SIMPLE_NETWORK_MODE.

+

+  This routine calls ::ReceiveFilterUpdate to update the receive

+  state in the network adapter.

+

+  @param [in] pSimpleNetwork    Protocol instance pointer

+  @param [in] Enable            A bit mask of receive filters to enable on the network interface.

+  @param [in] Disable           A bit mask of receive filters to disable on the network interface.

+                                For backward compatibility with EFI 1.1 platforms, the

+                                EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST bit must be set

+                                when the ResetMCastFilter parameter is TRUE.

+  @param [in] bResetMCastFilter Set to TRUE to reset the contents of the multicast receive

+                                filters on the network interface to their default values.

+  @param [in] MCastFilterCnt    Number of multicast HW MAC address in the new MCastFilter list.

+                                This value must be less than or equal to the MaxMCastFilterCnt

+                                field of EFI_SIMPLE_NETWORK_MODE.  This field is optional if

+                                ResetMCastFilter is TRUE.

+  @param [in] pMCastFilter      A pointer to a list of new multicast receive filter HW MAC

+                                addresses.  This list will replace any existing multicast

+                                HW MAC address list.  This field is optional if ResetMCastFilter

+                                is TRUE.

+

+  @retval EFI_SUCCESS           This operation was successful.

+  @retval EFI_NOT_STARTED       The network interface was not started.

+  @retval EFI_INVALID_PARAMETER pSimpleNetwork parameter was NULL or did not point to a valid

+                                EFI_SIMPLE_NETWORK_PROTOCOL structure.

+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.

+  @retval EFI_UNSUPPORTED       The increased buffer size feature is not supported.

+

+**/

+EFI_STATUS

+EFIAPI

+SN_ReceiveFilters (

+  IN EFI_SIMPLE_NETWORK_PROTOCOL * pSimpleNetwork,

+  IN UINT32 Enable,

+  IN UINT32 Disable,

+/*

+#define EFI_SIMPLE_NETWORK_RECEIVE_UNICAST               0x01

+#define EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST             0x02

+#define EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST             0x04

+#define EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS           0x08

+#define EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST 0x10

+*/

+  IN BOOLEAN bResetMCastFilter,

+  IN UINTN MCastFilterCnt,

+  IN EFI_MAC_ADDRESS * pMCastFilter

+  )

+{

+  EFI_SIMPLE_NETWORK_MODE * pMode;

+  EFI_STATUS Status = EFI_SUCCESS;   

+  EFI_TPL TplPrevious; 

+  NIC_DEVICE * pNicDevice;

+

+  TplPrevious = gBS->RaiseTPL(TPL_CALLBACK);

+  pNicDevice = DEV_FROM_SIMPLE_NETWORK ( pSimpleNetwork );

+  pMode = pSimpleNetwork->Mode;

+

+  if (pSimpleNetwork == NULL) {

+    gBS->RestoreTPL(TplPrevious);

+    return EFI_INVALID_PARAMETER;

+  }

+

+  switch (pMode->State) {

+    case EfiSimpleNetworkInitialized:

+      break;

+    case EfiSimpleNetworkStopped:

+      Status = EFI_NOT_STARTED;

+      gBS->RestoreTPL(TplPrevious);

+      return Status;

+    default:

+      Status = EFI_DEVICE_ERROR;

+      gBS->RestoreTPL(TplPrevious);

+      return Status;

+  }

+

+  //

+  // check if we are asked to enable or disable something that the UNDI

+  // does not even support!

+  //

+  if (((Enable &~pMode->ReceiveFilterMask) != 0) ||

+    ((Disable &~pMode->ReceiveFilterMask) != 0)) {

+    Status = EFI_INVALID_PARAMETER;

+    gBS->RestoreTPL(TplPrevious);

+    return Status;

+  }

+  

+  if (bResetMCastFilter) {

+    Disable |= (EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST & pMode->ReceiveFilterMask);

+      pMode->MCastFilterCount = 0;

+      if ( (0 == (pMode->ReceiveFilterSetting & EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST)) 

+            && Enable == 0 && Disable == 2) {

+            gBS->RestoreTPL(TplPrevious);

+            return EFI_SUCCESS;

+      }

+  } 

+  else {

+    if (MCastFilterCnt != 0) {

+      UINTN i; 

+      EFI_MAC_ADDRESS * pMulticastAddress;

+      pMulticastAddress =  pMCastFilter;

+      

+      if ((MCastFilterCnt > pMode->MaxMCastFilterCount) ||

+          (pMCastFilter == NULL)) {

+        Status = EFI_INVALID_PARAMETER;

+        gBS->RestoreTPL(TplPrevious);

+        return Status;

+      }

+      

+      for ( i = 0 ; i < MCastFilterCnt ; i++ ) {

+          UINT8  tmp;

+          tmp = pMulticastAddress->Addr[0];

+          if ( (tmp & 0x01) != 0x01 ) {

+            gBS->RestoreTPL(TplPrevious);

+            return EFI_INVALID_PARAMETER;

+          }

+          pMulticastAddress++;

+      }

+      

+      pMode->MCastFilterCount = (UINT32)MCastFilterCnt;

+      CopyMem (&pMode->MCastFilter[0],

+                     pMCastFilter,

+                     MCastFilterCnt * sizeof ( EFI_MAC_ADDRESS));

+    }

+  }

+  

+  if (Enable == 0 && Disable == 0 && !bResetMCastFilter && MCastFilterCnt == 0) {

+    Status = EFI_SUCCESS;

+    gBS->RestoreTPL(TplPrevious);

+    return Status;

+  }

+

+  if ((Enable & EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST) != 0 && MCastFilterCnt == 0) {

+    Status = EFI_INVALID_PARAMETER;

+    gBS->RestoreTPL(TplPrevious);

+    return Status;

+  }

+  

+  pMode->ReceiveFilterSetting |= Enable;

+  pMode->ReceiveFilterSetting &= ~Disable;

+  Status = ReceiveFilterUpdate (pSimpleNetwork);

+  

+  if (EFI_DEVICE_ERROR == Status || EFI_INVALID_PARAMETER == Status)

+      Status = EFI_SUCCESS;

+

+  gBS->RestoreTPL(TplPrevious);

+  return Status;

+}

+

+/**

+  Reset the network adapter.

+

+  Resets a network adapter and reinitializes it with the parameters that

+  were provided in the previous call to Initialize ().  The transmit and

+  receive queues are cleared.  Receive filters, the station address, the

+  statistics, and the multicast-IP-to-HW MAC addresses are not reset by

+  this call.

+

+  This routine calls ::Ax88772Reset to perform the adapter specific

+  reset operation.  This routine also starts the link negotiation

+  by calling ::Ax88772NegotiateLinkStart.

+

+  @param [in] pSimpleNetwork    Protocol instance pointer

+  @param [in] bExtendedVerification  Indicates that the driver may perform a more

+                                exhaustive verification operation of the device

+                                during reset.

+

+  @retval EFI_SUCCESS           This operation was successful.

+  @retval EFI_NOT_STARTED       The network interface was not started.

+  @retval EFI_INVALID_PARAMETER pSimpleNetwork parameter was NULL or did not point to a valid

+                                EFI_SIMPLE_NETWORK_PROTOCOL structure.

+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.

+  @retval EFI_UNSUPPORTED       The increased buffer size feature is not supported.

+

+**/

+EFI_STATUS

+EFIAPI

+SN_Reset (

+  IN EFI_SIMPLE_NETWORK_PROTOCOL * pSimpleNetwork,

+  IN BOOLEAN bExtendedVerification

+  )

+{

+  EFI_SIMPLE_NETWORK_MODE * pMode;

+  NIC_DEVICE * pNicDevice;

+  EFI_STATUS Status;

+  EFI_TPL TplPrevious;

+

+  TplPrevious = gBS->RaiseTPL(TPL_CALLBACK);

+  //

+  //  Verify the parameters

+  //

+  if (( NULL != pSimpleNetwork ) && ( NULL != pSimpleNetwork->Mode )) {

+		pMode = pSimpleNetwork->Mode;

+		if ( EfiSimpleNetworkInitialized == pMode->State ) {

+    	//

+    	//  Update the device state

+    	//

+    	pNicDevice = DEV_FROM_SIMPLE_NETWORK ( pSimpleNetwork );

+    	pNicDevice->bComplete = FALSE;

+    	pNicDevice->bLinkUp = FALSE; 

+    	pNicDevice->bHavePkt = FALSE;

+    	pMode = pSimpleNetwork->Mode;

+    	pMode->MediaPresent = FALSE;

+

+    	//

+   		//  Reset the device

+    	//

+    	Status = Ax88772Reset ( pNicDevice );

+    	if ( !EFI_ERROR ( Status )) {

+     	 	//

+     	 	//  Update the receive filters in the adapter

+     	 	//

+     	 	Status = ReceiveFilterUpdate ( pSimpleNetwork );

+

+     	 	//

+     		 //  Try to get a connection to the network

+     	 	//

+     	 	if ( !EFI_ERROR ( Status )) {

+        	//

+        	//  Start the autonegotiation

+       		//

+        	Status = Ax88772NegotiateLinkStart ( pNicDevice );

+     		}

+   	 	}

+   	}

+   	else {

+   		Status = EFI_NOT_STARTED;

+   	}  

+  }

+  else {

+    Status = EFI_INVALID_PARAMETER;

+  }

+  gBS->RestoreTPL ( TplPrevious );

+  return Status;

+}

+

+/**

+  Initialize the simple network protocol.

+

+  This routine calls ::Ax88772MacAddressGet to obtain the

+  MAC address.

+

+  @param [in] pNicDevice       NIC_DEVICE_INSTANCE pointer

+

+  @retval EFI_SUCCESS     Setup was successful

+

+**/

+EFI_STATUS

+SN_Setup (

+  IN NIC_DEVICE * pNicDevice

+  )

+{

+  

+

+  EFI_SIMPLE_NETWORK_MODE * pMode;

+  EFI_SIMPLE_NETWORK_PROTOCOL * pSimpleNetwork;

+  EFI_STATUS Status;

+  RX_PKT * pCurr = NULL;

+  RX_PKT * pPrev = NULL;

+

+	pSimpleNetwork = &pNicDevice->SimpleNetwork;  

+  pSimpleNetwork->Revision = EFI_SIMPLE_NETWORK_PROTOCOL_REVISION;

+  pSimpleNetwork->Start = (EFI_SIMPLE_NETWORK_START)SN_Start;

+  pSimpleNetwork->Stop = (EFI_SIMPLE_NETWORK_STOP)SN_Stop;

+  pSimpleNetwork->Initialize = (EFI_SIMPLE_NETWORK_INITIALIZE)SN_Initialize;

+  pSimpleNetwork->Reset = (EFI_SIMPLE_NETWORK_RESET)SN_Reset;

+  pSimpleNetwork->Shutdown = (EFI_SIMPLE_NETWORK_SHUTDOWN)SN_Shutdown;

+  pSimpleNetwork->ReceiveFilters = (EFI_SIMPLE_NETWORK_RECEIVE_FILTERS)SN_ReceiveFilters;

+  pSimpleNetwork->StationAddress = (EFI_SIMPLE_NETWORK_STATION_ADDRESS)SN_StationAddress;

+  pSimpleNetwork->Statistics = (EFI_SIMPLE_NETWORK_STATISTICS)SN_Statistics;

+  pSimpleNetwork->MCastIpToMac = (EFI_SIMPLE_NETWORK_MCAST_IP_TO_MAC)SN_MCastIPtoMAC;

+  pSimpleNetwork->NvData = (EFI_SIMPLE_NETWORK_NVDATA)SN_NvData;

+  pSimpleNetwork->GetStatus = (EFI_SIMPLE_NETWORK_GET_STATUS)SN_GetStatus;

+  pSimpleNetwork->Transmit = (EFI_SIMPLE_NETWORK_TRANSMIT)SN_Transmit;

+  pSimpleNetwork->Receive = (EFI_SIMPLE_NETWORK_RECEIVE)SN_Receive;

+  pSimpleNetwork->WaitForPacket = NULL;

+  pMode = &pNicDevice->SimpleNetworkData;

+  pSimpleNetwork->Mode = pMode;

+  pMode->State = EfiSimpleNetworkStopped;

+  pMode->HwAddressSize = PXE_HWADDR_LEN_ETHER;

+  pMode->MediaHeaderSize = sizeof ( ETHERNET_HEADER );

+  pMode->MaxPacketSize = MAX_ETHERNET_PKT_SIZE;

+  pMode->NvRamSize = 0;

+  pMode->NvRamAccessSize = 0;

+  pMode->ReceiveFilterMask = EFI_SIMPLE_NETWORK_RECEIVE_UNICAST

+                           | EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST

+                           | EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST

+                           | EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS

+                           | EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST;

+  pMode->ReceiveFilterSetting = EFI_SIMPLE_NETWORK_RECEIVE_UNICAST

+                              | EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST;

+  pMode->MaxMCastFilterCount = MAX_MCAST_FILTER_CNT;

+  pMode->MCastFilterCount = 0;

+  SetMem ( &pMode->BroadcastAddress,

+           PXE_HWADDR_LEN_ETHER,

+           0xff );

+  pMode->IfType = EfiNetworkInterfaceUndi;

+  pMode->MacAddressChangeable = TRUE;

+  pMode->MultipleTxSupported = FALSE;

+  pMode->MediaPresentSupported = TRUE;

+  pMode->MediaPresent = FALSE;

+  pNicDevice->LinkIdleCnt = 0;

+  //

+  //  Read the MAC address

+  //

+  pNicDevice->PhyId = PHY_ID_INTERNAL;

+  pNicDevice->b100Mbps = TRUE;

+  pNicDevice->bFullDuplex = TRUE;

+  

+  Status = Ax88772MacAddressGet (

+                pNicDevice,

+                &pMode->PermanentAddress.Addr[0]);

+

+  if ( !EFI_ERROR ( Status )) {

+    int i; 

+    //

+    //  Use the hardware address as the current address

+    //

+

+    CopyMem ( &pMode->CurrentAddress,

+              &pMode->PermanentAddress,

+              PXE_HWADDR_LEN_ETHER );

+              

+    CopyMem ( &pNicDevice->MAC,

+              &pMode->PermanentAddress,

+              PXE_HWADDR_LEN_ETHER );

+              

+    pNicDevice->PktCntInQueue = 0;

+    

+    for ( i = 0 ; i < MAX_QUEUE_SIZE ; i++) {

+        Status = gBS->AllocatePool ( EfiRuntimeServicesData, 

+                                      sizeof (RX_PKT),

+                                      (VOID **) &pCurr);

+        if ( EFI_ERROR(Status)) {

+            DEBUG (( EFI_D_ERROR, "Memory are not enough\n"));

+            return Status;

+        }                              

+        pCurr->f_Used = FALSE;

+        

+        if ( i ) {

+            pPrev->pNext = pCurr;

+        }

+        else {

+            pNicDevice->QueueHead = pCurr;

+        }

+        

+        if (MAX_QUEUE_SIZE - 1 == i) {

+            pCurr->pNext = pNicDevice->QueueHead;

+        }

+        

+        pPrev = pCurr;

+    }

+    

+    pNicDevice->pNextFill = pNicDevice->QueueHead;

+    pNicDevice->pFirstFill = pNicDevice->QueueHead;

+    

+    Status = gBS->AllocatePool (EfiRuntimeServicesData,

+                                MAX_BULKIN_SIZE,

+                                (VOID **) &pNicDevice->pBulkInBuff);

+                                

+    if (EFI_ERROR(Status)) {

+        DEBUG (( EFI_D_ERROR, "gBS->AllocatePool for pBulkInBuff error. Status = %r\n",

+              Status));

+        return Status;

+    }

+  }

+  else {

+    DEBUG (( EFI_D_ERROR, "Ax88772MacAddressGet error. Status = %r\n", Status));

+		return Status;

+  }

+  

+  Status = gBS->AllocatePool ( EfiRuntimeServicesData,

+                                   sizeof ( RX_TX_PACKET ),

+                                   (VOID **) &pNicDevice->pRxTest );

+

+  if (EFI_ERROR (Status)) {

+    DEBUG (( EFI_D_ERROR, "gBS->AllocatePool:pNicDevice->pRxTest error. Status = %r\n",

+              Status));

+	  return Status;

+  }

+                                   

+  Status = gBS->AllocatePool ( EfiRuntimeServicesData,

+                                   sizeof ( RX_TX_PACKET ),

+                                   (VOID **) &pNicDevice->pTxTest );

+

+  if (EFI_ERROR (Status)) {

+    DEBUG (( EFI_D_ERROR, "gBS->AllocatePool:pNicDevice->pTxTest error. Status = %r\n",

+              Status));

+	  gBS->FreePool (pNicDevice->pRxTest);

+  }

+

+  return Status;

+}

+

+

+/**

+  This routine starts the network interface.

+

+  @param [in] pSimpleNetwork    Protocol instance pointer

+

+  @retval EFI_SUCCESS           This operation was successful.

+  @retval EFI_ALREADY_STARTED   The network interface was already started.

+  @retval EFI_INVALID_PARAMETER pSimpleNetwork parameter was NULL or did not point to a valid

+                                EFI_SIMPLE_NETWORK_PROTOCOL structure.

+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.

+  @retval EFI_UNSUPPORTED       The increased buffer size feature is not supported.

+

+**/

+EFI_STATUS

+EFIAPI

+SN_Start (

+  IN EFI_SIMPLE_NETWORK_PROTOCOL * pSimpleNetwork

+  )

+{

+  NIC_DEVICE * pNicDevice;

+  EFI_SIMPLE_NETWORK_MODE * pMode;

+  EFI_STATUS Status;

+  EFI_TPL TplPrevious;

+  int i = 0;

+  RX_PKT * pCurr = NULL;

+

+  TplPrevious = gBS->RaiseTPL(TPL_CALLBACK);

+  //

+  // Verify the parameters

+  //

+  Status = EFI_INVALID_PARAMETER;

+  if (( NULL != pSimpleNetwork ) && ( NULL != pSimpleNetwork->Mode )) {

+    pMode = pSimpleNetwork->Mode;

+    if ( EfiSimpleNetworkStopped == pMode->State ) {

+      //

+      // Initialize the mode structuref

+      // NVRAM access is not supported

+      //

+      ZeroMem ( pMode, sizeof ( *pMode ));

+  

+      pMode->State = EfiSimpleNetworkStarted;

+      pMode->HwAddressSize = PXE_HWADDR_LEN_ETHER;

+      pMode->MediaHeaderSize = sizeof ( ETHERNET_HEADER );

+      pMode->MaxPacketSize = MAX_ETHERNET_PKT_SIZE;

+      pMode->ReceiveFilterMask = EFI_SIMPLE_NETWORK_RECEIVE_UNICAST

+                               | EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST

+                               | EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST

+                               | EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS

+                               | EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST;

+      pMode->ReceiveFilterSetting = EFI_SIMPLE_NETWORK_RECEIVE_UNICAST;

+      pMode->MaxMCastFilterCount = MAX_MCAST_FILTER_CNT;

+      pNicDevice = DEV_FROM_SIMPLE_NETWORK ( pSimpleNetwork );

+      Status = Ax88772MacAddressGet ( pNicDevice, &pMode->PermanentAddress.Addr[0]);

+      CopyMem ( &pMode->CurrentAddress,

+                &pMode->PermanentAddress,

+                sizeof ( pMode->CurrentAddress ));

+      SetMem(&pMode->BroadcastAddress, PXE_HWADDR_LEN_ETHER, 0xff);

+      pMode->IfType = EfiNetworkInterfaceUndi;

+      pMode->MacAddressChangeable = TRUE;

+      pMode->MultipleTxSupported = FALSE;

+      pMode->MediaPresentSupported = TRUE;

+      pMode->MediaPresent = FALSE; 

+      pNicDevice->PktCntInQueue = 0;

+      pNicDevice->pNextFill = pNicDevice->QueueHead;

+      pNicDevice->pFirstFill = pNicDevice->QueueHead;

+      pCurr = pNicDevice->QueueHead;

+      

+      for ( i = 0 ; i < MAX_QUEUE_SIZE ; i++) { 

+        pCurr->f_Used = FALSE;

+        pCurr = pCurr->pNext;

+      }

+      

+    }

+    else {

+      Status = EFI_ALREADY_STARTED;

+    }

+  }

+  gBS->RestoreTPL ( TplPrevious );

+  return Status;

+}

+

+

+/**

+  Set the MAC address.

+  

+  This function modifies or resets the current station address of a

+  network interface.  If Reset is TRUE, then the current station address

+  is set ot the network interface's permanent address.  If Reset if FALSE

+  then the current station address is changed to the address specified by

+  pNew.

+

+  This routine calls ::Ax88772MacAddressSet to update the MAC address

+  in the network adapter.

+

+  @param [in] pSimpleNetwork    Protocol instance pointer

+  @param [in] bReset            Flag used to reset the station address to the

+                                network interface's permanent address.

+  @param [in] pNew              New station address to be used for the network

+                                interface.

+

+  @retval EFI_SUCCESS           This operation was successful.

+  @retval EFI_NOT_STARTED       The network interface was not started.

+  @retval EFI_INVALID_PARAMETER pSimpleNetwork parameter was NULL or did not point to a valid

+                                EFI_SIMPLE_NETWORK_PROTOCOL structure.

+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.

+  @retval EFI_UNSUPPORTED       The increased buffer size feature is not supported.

+

+**/

+EFI_STATUS

+EFIAPI

+SN_StationAddress (

+  IN EFI_SIMPLE_NETWORK_PROTOCOL * pSimpleNetwork,

+  IN BOOLEAN bReset,

+  IN EFI_MAC_ADDRESS * pNew

+  )

+{

+  NIC_DEVICE * pNicDevice;

+  EFI_SIMPLE_NETWORK_MODE * pMode;

+  EFI_STATUS Status;

+  EFI_TPL TplPrevious;

+  

+  TplPrevious = gBS->RaiseTPL(TPL_CALLBACK);

+  //

+  // Verify the parameters

+  //

+  if (( NULL != pSimpleNetwork )

+    && ( NULL != pSimpleNetwork->Mode )

+    && (( !bReset ) || ( bReset && ( NULL != pNew )))) {

+    //

+    // Verify that the adapter is already started

+    //

+    pNicDevice = DEV_FROM_SIMPLE_NETWORK ( pSimpleNetwork );

+    pMode = pSimpleNetwork->Mode;

+    if ( EfiSimpleNetworkStarted == pMode->State ) {

+      //

+      // Determine the adapter MAC address

+      //

+      if ( bReset ) {

+        //

+        // Use the permanent address

+        //

+        CopyMem ( &pMode->CurrentAddress,

+                  &pMode->PermanentAddress,

+                  sizeof ( pMode->CurrentAddress ));

+      }

+      else {

+        //

+        // Use the specified address

+        //

+        CopyMem ( &pMode->CurrentAddress,

+                  pNew,

+                  sizeof ( pMode->CurrentAddress ));

+      }

+

+      //

+      // Update the address on the adapter

+      //

+      Status = Ax88772MacAddressSet ( pNicDevice, &pMode->CurrentAddress.Addr[0]);

+    }

+    else {

+      Status = EFI_NOT_STARTED;

+    }

+  }

+  else {

+    Status = EFI_INVALID_PARAMETER;

+  }

+  gBS->RestoreTPL ( TplPrevious );

+  return Status;

+}

+

+

+/**

+  This function resets or collects the statistics on a network interface.

+  If the size of the statistics table specified by StatisticsSize is not

+  big enough for all of the statistics that are collected by the network

+  interface, then a partial buffer of statistics is returned in

+  StatisticsTable.

+

+  @param [in] pSimpleNetwork    Protocol instance pointer

+  @param [in] bReset            Set to TRUE to reset the statistics for the network interface.

+  @param [in, out] pStatisticsSize  On input the size, in bytes, of StatisticsTable.  On output

+                                the size, in bytes, of the resulting table of statistics.

+  @param [out] pStatisticsTable A pointer to the EFI_NETWORK_STATISTICS structure that

+                                conains the statistics.

+

+  @retval EFI_SUCCESS           This operation was successful.

+  @retval EFI_NOT_STARTED       The network interface was not started.

+  @retval EFI_BUFFER_TOO_SMALL  The pStatisticsTable is NULL or the buffer is too small.

+  @retval EFI_INVALID_PARAMETER pSimpleNetwork parameter was NULL or did not point to a valid

+                                EFI_SIMPLE_NETWORK_PROTOCOL structure.

+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.

+  @retval EFI_UNSUPPORTED       The increased buffer size feature is not supported.

+

+  typedef struct {

+  UINT64 RxTotalFrames;

+  UINT64 RxGoodFrames;

+  UINT64 RxUndersizeFrames;

+  UINT64 RxOversizeFrames;

+  UINT64 RxDroppedFrames;

+  UINT64 RxUnicastFrames;

+  UINT64 RxBroadcastFrames;

+  UINT64 RxMulticastFrames;

+  UINT64 RxCrcErrorFrames;

+  UINT64 RxTotalBytes;

+  UINT64 TxTotalFrames;

+  UINT64 TxGoodFrames;

+  UINT64 TxUndersizeFrames;

+  UINT64 TxOversizeFrames;

+  UINT64 TxDroppedFrames;

+  UINT64 TxUnicastFrames;

+  UINT64 TxBroadcastFrames;

+  UINT64 TxMulticastFrames;

+  UINT64 TxCrcErrorFrames;

+  UINT64 TxTotalBytes;

+  UINT64 Collisions;

+  UINT64 UnsupportedProtocol;

+  } EFI_NETWORK_STATISTICS;

+**/

+EFI_STATUS

+EFIAPI

+SN_Statistics (

+  IN EFI_SIMPLE_NETWORK_PROTOCOL * pSimpleNetwork,

+  IN BOOLEAN bReset,

+  IN OUT UINTN * pStatisticsSize,

+  OUT EFI_NETWORK_STATISTICS * pStatisticsTable

+  )

+{

+  EFI_STATUS Status;

+

+  Status = EFI_UNSUPPORTED;

+

+  return Status;

+}

+

+

+/**

+  This function stops a network interface.  This call is only valid

+  if the network interface is in the started state.

+

+  @param [in] pSimpleNetwork    Protocol instance pointer

+

+  @retval EFI_SUCCESS           This operation was successful.

+  @retval EFI_NOT_STARTED       The network interface was not started.

+  @retval EFI_INVALID_PARAMETER pSimpleNetwork parameter was NULL or did not point to a valid

+                                EFI_SIMPLE_NETWORK_PROTOCOL structure.

+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.

+  @retval EFI_UNSUPPORTED       The increased buffer size feature is not supported.

+

+**/

+EFI_STATUS

+EFIAPI

+SN_Stop (

+  IN EFI_SIMPLE_NETWORK_PROTOCOL * pSimpleNetwork

+  )

+{

+  EFI_SIMPLE_NETWORK_MODE * pMode;

+  EFI_STATUS Status;

+  EFI_TPL TplPrevious;

+  

+  TplPrevious = gBS->RaiseTPL(TPL_CALLBACK);

+  //

+  // Verify the parameters

+  //

+  if (( NULL != pSimpleNetwork ) && ( NULL != pSimpleNetwork->Mode )) {

+    //

+    // Determine if the interface is started

+    //

+    pMode = pSimpleNetwork->Mode;   

+    if ( EfiSimpleNetworkStarted == pMode->State ) {

+        pMode->State = EfiSimpleNetworkStopped;

+        Status = EFI_SUCCESS; 

+    }

+    else {

+        Status = EFI_NOT_STARTED;

+    }

+  } 

+  else {

+    Status = EFI_INVALID_PARAMETER;

+  }

+  

+  gBS->RestoreTPL ( TplPrevious );

+  return Status;

+}

+

+

+/**

+  This function releases the memory buffers assigned in the Initialize() call.

+  Pending transmits and receives are lost, and interrupts are cleared and disabled.

+  After this call, only Initialize() and Stop() calls may be used.

+

+  @param [in] pSimpleNetwork    Protocol instance pointer

+

+  @retval EFI_SUCCESS           This operation was successful.

+  @retval EFI_NOT_STARTED       The network interface was not started.

+  @retval EFI_INVALID_PARAMETER pSimpleNetwork parameter was NULL or did not point to a valid

+                                EFI_SIMPLE_NETWORK_PROTOCOL structure.

+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.

+  @retval EFI_UNSUPPORTED       The increased buffer size feature is not supported.

+

+**/

+EFI_STATUS

+EFIAPI

+SN_Shutdown (

+  IN EFI_SIMPLE_NETWORK_PROTOCOL * pSimpleNetwork

+  )

+{

+  EFI_SIMPLE_NETWORK_MODE * pMode;

+  UINT32 RxFilter;

+  EFI_STATUS Status;

+  EFI_TPL TplPrevious;

+  

+  TplPrevious = gBS->RaiseTPL(TPL_CALLBACK);

+  //

+  // Verify the parameters

+  //

+  if (( NULL != pSimpleNetwork ) && ( NULL != pSimpleNetwork->Mode )) {

+    //

+    // Determine if the interface is already started

+    //

+    pMode = pSimpleNetwork->Mode;

+    if ( EfiSimpleNetworkInitialized == pMode->State ) {

+      //

+      // Stop the adapter

+      //

+      RxFilter = pMode->ReceiveFilterSetting;

+      pMode->ReceiveFilterSetting = 0;

+      Status = SN_Reset ( pSimpleNetwork, FALSE );

+      pMode->ReceiveFilterSetting = RxFilter;

+      if ( !EFI_ERROR ( Status )) {

+

+        //

+        // Update the network state

+        //

+        pMode->State = EfiSimpleNetworkStarted;

+      }

+      else if ( EFI_DEVICE_ERROR == Status ) {

+      	pMode->State = EfiSimpleNetworkStopped;

+      }

+    }

+    else {

+      Status = EFI_NOT_STARTED;

+    }

+  }

+  else {

+    Status = EFI_INVALID_PARAMETER;

+  }

+  gBS->RestoreTPL ( TplPrevious );

+  return Status;

+}

+

+

+/**

+  Send a packet over the network.

+

+  This function places the packet specified by Header and Buffer on

+  the transmit queue.  This function performs a non-blocking transmit

+  operation.  When the transmit is complete, the buffer is returned

+  via the GetStatus() call.

+

+  This routine calls ::Ax88772Rx to empty the network adapter of

+  receive packets.  The routine then passes the transmit packet

+  to the network adapter.

+

+  @param [in] pSimpleNetwork    Protocol instance pointer

+  @param [in] HeaderSize        The size, in bytes, of the media header to be filled in by

+                                the Transmit() function.  If HeaderSize is non-zero, then

+                                it must be equal to SimpleNetwork->Mode->MediaHeaderSize

+                                and DestAddr and Protocol parameters must not be NULL.

+  @param [in] BufferSize        The size, in bytes, of the entire packet (media header and

+                                data) to be transmitted through the network interface.

+  @param [in] pBuffer           A pointer to the packet (media header followed by data) to

+                                to be transmitted.  This parameter can not be NULL.  If

+                                HeaderSize is zero, then the media header is Buffer must

+                                already be filled in by the caller.  If HeaderSize is nonzero,

+                                then the media header will be filled in by the Transmit()

+                                function.

+  @param [in] pSrcAddr          The source HW MAC address.  If HeaderSize is zero, then

+                                this parameter is ignored.  If HeaderSize is nonzero and

+                                SrcAddr is NULL, then SimpleNetwork->Mode->CurrentAddress

+                                is used for the source HW MAC address.

+  @param [in] pDestAddr         The destination HW MAC address.  If HeaderSize is zero, then

+                                this parameter is ignored.

+  @param [in] pProtocol         The type of header to build.  If HeaderSize is zero, then

+                                this parameter is ignored.

+

+  @retval EFI_SUCCESS           This operation was successful.

+  @retval EFI_NOT_STARTED       The network interface was not started.

+  @retval EFI_NOT_READY         The network interface is too busy to accept this transmit request.

+  @retval EFI_BUFFER_TOO_SMALL  The BufferSize parameter is too small.

+  @retval EFI_INVALID_PARAMETER pSimpleNetwork parameter was NULL or did not point to a valid

+                                EFI_SIMPLE_NETWORK_PROTOCOL structure.

+  @retval EFI_DEVICE_ERROR      The command could not be sent to the network interface.

+

+**/

+EFI_STATUS

+EFIAPI

+SN_Transmit (

+  IN EFI_SIMPLE_NETWORK_PROTOCOL * pSimpleNetwork,

+  IN UINTN HeaderSize,

+  IN UINTN BufferSize,

+  IN VOID * pBuffer,

+  IN EFI_MAC_ADDRESS * pSrcAddr,

+  IN EFI_MAC_ADDRESS * pDestAddr,

+  IN UINT16 * pProtocol

+  )

+{

+  ETHERNET_HEADER * pHeader;

+  EFI_SIMPLE_NETWORK_MODE * pMode;

+  NIC_DEVICE * pNicDevice;

+  EFI_USB_IO_PROTOCOL * pUsbIo;

+  EFI_STATUS Status;

+  UINTN TransferLength;

+  UINT32 TransferStatus;

+  UINT16 Type;

+  EFI_TPL TplPrevious;

+

+  TplPrevious = gBS->RaiseTPL(TPL_CALLBACK);

+

+  // Verify the parameters

+  //

+  if (( NULL != pSimpleNetwork ) && ( NULL != pSimpleNetwork->Mode )) {

+    //

+    // The interface must be running

+    //

+    pMode = pSimpleNetwork->Mode;

+    if ( EfiSimpleNetworkInitialized == pMode->State ) {

+      //

+      // Update the link status

+      //

+      pNicDevice = DEV_FROM_SIMPLE_NETWORK ( pSimpleNetwork );

+      pMode->MediaPresent = pNicDevice->bLinkUp;

+

+      //

+      //  Release the synchronization with Ax88772Timer

+      //      

+      if ( pMode->MediaPresent && pNicDevice->bComplete) {

+        //

+        //  Copy the packet into the USB buffer

+        //

+

+        CopyMem ( &pNicDevice->pTxTest->Data[0], pBuffer, BufferSize ); 

+        pNicDevice->pTxTest->Length = (UINT16) BufferSize;

+

+        //

+        //  Transmit the packet

+        //

+        pHeader = (ETHERNET_HEADER *) &pNicDevice->pTxTest->Data[0];

+        if ( 0 != HeaderSize ) {

+          if ( NULL != pDestAddr ) {

+            CopyMem ( &pHeader->dest_addr, pDestAddr, PXE_HWADDR_LEN_ETHER );

+          }

+          if ( NULL != pSrcAddr ) {

+            CopyMem ( &pHeader->src_addr, pSrcAddr, PXE_HWADDR_LEN_ETHER );

+          }

+          else {

+            CopyMem ( &pHeader->src_addr, &pMode->CurrentAddress.Addr[0], PXE_HWADDR_LEN_ETHER );

+          }

+          if ( NULL != pProtocol ) {

+            Type = *pProtocol;

+          }

+          else {

+            Type = pNicDevice->pTxTest->Length;

+          }

+          Type = (UINT16)(( Type >> 8 ) | ( Type << 8 ));

+          pHeader->type = Type;

+        }

+        if ( pNicDevice->pTxTest->Length < MIN_ETHERNET_PKT_SIZE ) {

+          pNicDevice->pTxTest->Length = MIN_ETHERNET_PKT_SIZE;

+          ZeroMem ( &pNicDevice->pTxTest->Data[ BufferSize ],

+                    pNicDevice->pTxTest->Length - BufferSize );

+        }

+    

+        DEBUG ((EFI_D_INFO, "TX: %02x-%02x-%02x-%02x-%02x-%02x  %02x-%02x-%02x-%02x-%02x-%02x"

+                  "  %02x-%02x  %d bytes\r\n",

+                  pNicDevice->pTxTest->Data[0],

+                  pNicDevice->pTxTest->Data[1],

+                  pNicDevice->pTxTest->Data[2],

+                  pNicDevice->pTxTest->Data[3],

+                  pNicDevice->pTxTest->Data[4],

+                  pNicDevice->pTxTest->Data[5],

+                  pNicDevice->pTxTest->Data[6],

+                  pNicDevice->pTxTest->Data[7],

+                  pNicDevice->pTxTest->Data[8],

+                  pNicDevice->pTxTest->Data[9],

+                  pNicDevice->pTxTest->Data[10],

+                  pNicDevice->pTxTest->Data[11],

+                  pNicDevice->pTxTest->Data[12],

+                  pNicDevice->pTxTest->Data[13],

+                  pNicDevice->pTxTest->Length ));

+

+        pNicDevice->pTxTest->LengthBar = ~(pNicDevice->pTxTest->Length);

+        TransferLength = sizeof ( pNicDevice->pTxTest->Length )

+                       + sizeof ( pNicDevice->pTxTest->LengthBar )

+                       + pNicDevice->pTxTest->Length;

+                       

+        if (TransferLength % 512 == 0 || TransferLength % 1024 == 0)

+            TransferLength +=4;

+

+        //

+        //  Work around USB bus driver bug where a timeout set by receive

+        //  succeeds but the timeout expires immediately after, causing the

+        //  transmit operation to timeout.

+        //

+        pUsbIo = pNicDevice->pUsbIo;

+        Status = pUsbIo->UsbBulkTransfer ( pUsbIo,

+                                           BULK_OUT_ENDPOINT,

+                                           &pNicDevice->pTxTest->Length,

+                                           &TransferLength,

+                                           0xfffffffe, 

+                                           &TransferStatus );

+        if ( !EFI_ERROR ( Status )) {

+          Status = TransferStatus;

+        }

+

+        if ( !EFI_ERROR ( Status )) {

+          pNicDevice->pTxBuffer = pBuffer;

+        }

+        else {

+          if ((TransferLength != (UINTN)( pNicDevice->pTxTest->Length + 4 )) &&

+               (TransferLength != (UINTN)(( pNicDevice->pTxTest->Length + 4 ) + 4))) {

+            DEBUG ((EFI_D_INFO, "TransferLength didn't match Packet Length\n"));

+          }

+          //

+          //  Reset the controller to fix the error

+          //

+          if ( EFI_DEVICE_ERROR == Status ) {

+                SN_Reset ( pSimpleNetwork, FALSE );

+          }

+          Status = EFI_NOT_READY;

+        }

+      }

+      else {

+        //

+        // No packets available.

+        //

+        Status = EFI_NOT_READY;

+      }

+      

+    }

+    else {

+      Status = EFI_NOT_STARTED ;

+    }

+  }

+  else {

+    Status = EFI_INVALID_PARAMETER;

+  }

+  

+  gBS->RestoreTPL (TplPrevious);

+

+  return Status;

+}

diff --git a/OvmfPkg/AcpiPlatformDxe/Qemu.c b/OvmfPkg/AcpiPlatformDxe/Qemu.c
index 35d667fe..8a6ecf75 100644
--- a/OvmfPkg/AcpiPlatformDxe/Qemu.c
+++ b/OvmfPkg/AcpiPlatformDxe/Qemu.c
@@ -200,16 +200,20 @@ typedef struct {
 } FIRMWARE_DATA;

 

 typedef struct {

-  UINT8 NameOp;

-  UINT8 RootChar;

-  UINT8 NameChar[4];

-  UINT8 PackageOp;

-  UINT8 PkgLength;

-  UINT8 NumElements;

-  UINT8 DWordPrefix;

-  UINT8 Pm1aCntSlpTyp;

-  UINT8 Pm1bCntSlpTyp;

-  UINT8 Reserved[2];

+  UINT8 BytePrefix;

+  UINT8 ByteValue;

+} AML_BYTE;

+

+typedef struct {

+  UINT8    NameOp;

+  UINT8    RootChar;

+  UINT8    NameChar[4];

+  UINT8    PackageOp;

+  UINT8    PkgLength;

+  UINT8    NumElements;

+  AML_BYTE Pm1aCntSlpTyp;

+  AML_BYTE Pm1bCntSlpTyp;

+  AML_BYTE Reserved[2];

 } SYSTEM_STATE_PACKAGE;

 

 #pragma pack()

@@ -326,12 +330,14 @@ GetSuspendStates (
     '\\',                   // RootChar

     { '_', 'S', 'x', '_' }, // NameChar[4]

     0x12,                   // PackageOp

-    0x07,                   // PkgLength

-    0x01,                   // NumElements

-    0x0c,                   // DWordPrefix

-    0x00,                   // Pm1aCntSlpTyp

-    0x00,                   // Pm1bCntSlpTyp -- we don't support it

-    { 0x00, 0x00 }          // Reserved

+    0x0A,                   // PkgLength

+    0x04,                   // NumElements

+    { 0x0A, 0x00 },         // Pm1aCntSlpTyp

+    { 0x0A, 0x00 },         // Pm1bCntSlpTyp -- we don't support it

+    {                       // Reserved[2]

+      { 0x0A, 0x00 },

+      { 0x0A, 0x00 }

+    }

   };

   RETURN_STATUS                     Status;

   FIRMWARE_CONFIG_ITEM              FwCfgItem;

@@ -343,13 +349,13 @@ GetSuspendStates (
   //

   *SuspendToRamSize = sizeof Template;

   CopyMem (SuspendToRam, &Template, sizeof Template);

-  SuspendToRam->NameChar[2]   = '3'; // S3

-  SuspendToRam->Pm1aCntSlpTyp = 1;   // PIIX4: STR

+  SuspendToRam->NameChar[2]             = '3'; // S3

+  SuspendToRam->Pm1aCntSlpTyp.ByteValue = 1;   // PIIX4: STR

 

   *SuspendToDiskSize = sizeof Template;

   CopyMem (SuspendToDisk, &Template, sizeof Template);

-  SuspendToDisk->NameChar[2]   = '4'; // S4

-  SuspendToDisk->Pm1aCntSlpTyp = 2;   // PIIX4: POSCL

+  SuspendToDisk->NameChar[2]             = '4'; // S4

+  SuspendToDisk->Pm1aCntSlpTyp.ByteValue = 2;   // PIIX4: POSCL

 

   //

   // check for overrides

@@ -368,16 +374,20 @@ GetSuspendStates (
   // value to be written to the PM control register's SUS_TYP bits.

   //

   if (SystemStates[3] & BIT7) {

-    SuspendToRam->Pm1aCntSlpTyp = SystemStates[3] & (BIT2 | BIT1 | BIT0);

-    DEBUG ((DEBUG_INFO, "ACPI S3 value: %d\n", SuspendToRam->Pm1aCntSlpTyp));

+    SuspendToRam->Pm1aCntSlpTyp.ByteValue =

+        SystemStates[3] & (BIT2 | BIT1 | BIT0);

+    DEBUG ((DEBUG_INFO, "ACPI S3 value: %d\n",

+            SuspendToRam->Pm1aCntSlpTyp.ByteValue));

   } else {

     *SuspendToRamSize = 0;

     DEBUG ((DEBUG_INFO, "ACPI S3 disabled\n"));

   }

 

   if (SystemStates[4] & BIT7) {

-    SuspendToDisk->Pm1aCntSlpTyp = SystemStates[4] & (BIT2 | BIT1 | BIT0);

-    DEBUG ((DEBUG_INFO, "ACPI S4 value: %d\n", SuspendToDisk->Pm1aCntSlpTyp));

+    SuspendToDisk->Pm1aCntSlpTyp.ByteValue =

+        SystemStates[4] & (BIT2 | BIT1 | BIT0);

+    DEBUG ((DEBUG_INFO, "ACPI S4 value: %d\n",

+            SuspendToDisk->Pm1aCntSlpTyp.ByteValue));

   } else {

     *SuspendToDiskSize = 0;

     DEBUG ((DEBUG_INFO, "ACPI S4 disabled\n"));

diff --git a/OvmfPkg/AcpiTables/Dsdt.asl b/OvmfPkg/AcpiTables/Dsdt.asl
index 12a4f142..519a3125 100644
--- a/OvmfPkg/AcpiTables/Dsdt.asl
+++ b/OvmfPkg/AcpiTables/Dsdt.asl
@@ -203,10 +203,28 @@ DefinitionBlock ("Dsdt.aml", "DSDT", 1, "INTEL ", "OVMF    ", 4) {
             Package () {0x0000FFFF, 0x02, \_SB.PCI0.LPC.LNKB, 0x00},

             Package () {0x0000FFFF, 0x03, \_SB.PCI0.LPC.LNKC, 0x00},

 

-            Package () {0x0001FFFF, 0x00, 0x00, 0x09},

             //

-            // list of IRQs occupied thus far: 9

+            // Bus 0, Device 1, Pin 0 (INTA) is special; it corresponds to the

+            // internally generated SCI (System Control Interrupt), which is

+            // always routed to GSI 9. By setting the third (= Source) field to

+            // zero, we could use the fourth (= Source Index) field to hardwire

+            // the pin to GSI 9 directly.

+            //

+            // That way however, in accordance with the ACPI spec's description

+            // of SCI, the interrupt would be treated as "active low,

+            // shareable, level", and that doesn't match qemu.

             //

+            // In QemuInstallAcpiMadtTable() [OvmfPkg/AcpiPlatformDxe/Qemu.c]

+            // we install an Interrupt Override Structure for the identity

+            // mapped IRQ#9 / GSI 9 (the corresponding bit being set in

+            // Pcd8259LegacyModeEdgeLevel), which describes the correct

+            // polarity (active high). As a consequence, some OS'en (eg. Linux)

+            // override the default (active low) polarity originating from the

+            // _PRT; others (eg. FreeBSD) don't. Therefore we need a separate

+            // link device just to specify a polarity that matches the MADT.

+            //

+            Package () {0x0001FFFF, 0x00, \_SB.PCI0.LPC.LNKS, 0x00},

+

             Package () {0x0001FFFF, 0x01, \_SB.PCI0.LPC.LNKB, 0x00},

             Package () {0x0001FFFF, 0x02, \_SB.PCI0.LPC.LNKC, 0x00},

             Package () {0x0001FFFF, 0x03, \_SB.PCI0.LPC.LNKD, 0x00},

@@ -292,6 +310,30 @@ DefinitionBlock ("Dsdt.aml", "DSDT", 1, "INTEL ", "OVMF    ", 4) {
         Name (_ADR, 0x00010000)

 

         //

+        // The SCI cannot be rerouted or disabled with PIRQRC[A:D]; we only

+        // need this link device in order to specify the polarity.

+        //

+        Device (LNKS) {

+          Name (_HID, EISAID("PNP0C0F"))

+          Name (_UID, 0)

+

+          Name (_STA, 0xB) // 0x1: device present

+                           // 0x2: enabled and decoding resources

+                           // 0x8: functioning properly

+

+          Method (_SRS, 1, NotSerialized) { /* no-op */ }

+          Method (_DIS, 0, NotSerialized) { /* no-op */ }

+

+          Name (_PRS, ResourceTemplate () {

+            Interrupt (ResourceConsumer, Level, ActiveHigh, Shared) { 9 }

+            //

+            // list of IRQs occupied thus far: 9

+            //

+          })

+          Method (_CRS, 0, NotSerialized) { Return (_PRS) }

+        }

+

+        //

         // PCI Interrupt Routing Configuration Registers, PIRQRC[A:D]

         //

         OperationRegion (PRR0, PCI_Config, 0x60, 0x04)

diff --git a/OvmfPkg/AcpiTables/Facp.aslc b/OvmfPkg/AcpiTables/Facp.aslc
index b48af760..df35285c 100644
--- a/OvmfPkg/AcpiTables/Facp.aslc
+++ b/OvmfPkg/AcpiTables/Facp.aslc
@@ -1,6 +1,7 @@
 /** @file

   FACP Table

 

+  Copyright (c) 2013, Red Hat, Inc.

   Copyright (c) 2008 - 2012, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials are

   licensed and made available under the terms and conditions of the BSD License

@@ -14,11 +15,11 @@
 

 #include "Platform.h"

 

-EFI_ACPI_1_0_FIXED_ACPI_DESCRIPTION_TABLE FACP = {

+EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE FACP = {

   {

-    EFI_ACPI_1_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE,

-    sizeof (EFI_ACPI_1_0_FIXED_ACPI_DESCRIPTION_TABLE),

-    EFI_ACPI_1_0_FIXED_ACPI_DESCRIPTION_TABLE_REVISION,

+    EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE,

+    sizeof (EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE),

+    EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE_REVISION,

     0,                          // to make sum of entire table == 0

     {EFI_ACPI_OEM_ID},          // OEMID is a 6 bytes long field

     EFI_ACPI_OEM_TABLE_ID,      // OEM table identification(8 bytes long)

@@ -28,8 +29,8 @@ EFI_ACPI_1_0_FIXED_ACPI_DESCRIPTION_TABLE FACP = {
   },

   0,                // Physical addesss of FACS

   0,                // Physical address of DSDT

-  INT_MODEL,        // System Interrupt Model

-  RESERVED,         // reserved

+  RESERVED,         // System Interrupt Model in ACPI 1.0, eliminated in 2.0

+  EFI_ACPI_2_0_PM_PROFILE_UNSPECIFIED, // Preferred PM profile

   SCI_INT_VECTOR,   // System vector of SCI interrupt

   SMI_CMD_IO_PORT,  // Port address of SMI command port

   ACPI_ENABLE,      // value to write to port smi_cmd to enable ACPI

@@ -37,20 +38,20 @@ EFI_ACPI_1_0_FIXED_ACPI_DESCRIPTION_TABLE FACP = {
   S4BIOS_REQ,       // Value to write to SMI CMD port to enter the S4BIOS state

   0,                // PState control

   PM1a_EVT_BLK,     // Port address of Power Mgt 1a Event Reg Blk

-  PM1b_EVT_BLK,     // Port address of Power Mgt 1b Event Reg Blk

+  0,                // Power Mgt 1b Event Reg Blk unsupported

   PM1a_CNT_BLK,     // Port address of Power Mgt 1a Ctrl Reg Blk

-  PM1b_CNT_BLK,     // Port address of Power Mgt 1b Ctrl Reg Blk

-  PM2_CNT_BLK,      // Port address of Power Mgt 2  Ctrl Reg Blk

+  0,                // Power Mgt 1b Ctrl Reg Blk unsupported

+  0,                // Power Mgt 2  Ctrl Reg Blk unsupported

   PM_TMR_BLK,       // Port address of Power Mgt Timer Ctrl Reg Blk

   GPE0_BLK,         // Port addr of General Purpose Event 0 Reg Blk

-  GPE1_BLK,         // Port addr of General Purpose Event 1 Reg Blk

+  0,                // General Purpose Event 1 Reg Blk unsupported

   PM1_EVT_LEN,      // Byte Length of ports at pm1X_evt_blk

   PM1_CNT_LEN,      // Byte Length of ports at pm1X_cnt_blk

-  PM2_CNT_LEN,      // Byte Length of ports at pm2_cnt_blk

+  0,                // Power Mgt 2 Ctrl Reg Blk unsupported

   PM_TM_LEN,        // Byte Length of ports at pm_tm_blk

   GPE0_BLK_LEN,     // Byte Length of ports at gpe0_blk

-  GPE1_BLK_LEN,     // Byte Length of ports at gpe1_blk

-  GPE1_BASE,        // offset in gpe model where gpe1 events start

+  0,                // General Purpose Event 1 Reg Blk unsupported

+  0,                // General Purpose Event 1 Reg Blk unsupported

   0,                // _CST support

   P_LVL2_LAT,       // worst case HW latency to enter/exit C2 state

   P_LVL3_LAT,       // worst case HW latency to enter/exit C3 state

@@ -61,10 +62,23 @@ EFI_ACPI_1_0_FIXED_ACPI_DESCRIPTION_TABLE FACP = {
   DAY_ALRM,         // index to day-of-month alarm in RTC CMOS RAM

   MON_ALRM,         // index to month-of-year alarm in RTC CMOS RAM

   CENTURY,          // index to century in RTC CMOS RAM

-  0x00,             // Boot architecture flag

-  0x00,             // Boot architecture flag

+  0x0000,           // Boot architecture flag (16-bit)

   RESERVED,         // reserved

-  FLAG

+  FLAG,             // Fixed feature flags

+  GAS2_IO(RESET_REG, 1), // Extended address of the Reset Register

+  RESET_VALUE,           // Value for the Reset Register to reset the system

+  { RESERVED },     // reserved[3]

+  0,                // 64-bit physical addesss of FACS, set at installation

+  0,                // 64-bit physical addesss of DSDT, set at installation

+

+  GAS2_IO(PM1a_EVT_BLK, PM1_EVT_LEN), // Ext. addr. of PM 1a Event Reg Blk

+  { 0 },                              // PM 1b Event Reg Blk unsupported

+  GAS2_IO(PM1a_CNT_BLK, PM1_CNT_LEN), // Ext. addr. of PM 1a Ctrl Reg Blk

+  { 0 },                              // PM 1b Ctrl Reg Blk unsupported

+  { 0 },                              // PM 2  Ctrl Reg Blk unsupported

+  GAS2_IO(PM_TMR_BLK, PM_TM_LEN),     // Ext. addr. of PM Timer Ctrl Reg Blk

+  GAS2_IO(GPE0_BLK, GPE0_BLK_LEN),    // Ext. addr. of GPE 0 Reg Blk

+  { 0 }                               // GPE 1 Reg Blk unsupported

 };

 

 

diff --git a/OvmfPkg/AcpiTables/Platform.h b/OvmfPkg/AcpiTables/Platform.h
index e8fae3c8..d96b8472 100644
--- a/OvmfPkg/AcpiTables/Platform.h
+++ b/OvmfPkg/AcpiTables/Platform.h
@@ -1,6 +1,7 @@
 /** @file

   Platform specific defines for constructing ACPI tables

 

+  Copyright (c) 2012, 2013, Red Hat, Inc.

   Copyright (c) 2008, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials are

   licensed and made available under the terms and conditions of the BSD License

@@ -23,31 +24,23 @@
 //

 #define EFI_ACPI_OEM_ID           'O','V','M','F',' ',' '   // OEMID 6 bytes long

 #define EFI_ACPI_OEM_TABLE_ID     SIGNATURE_64('O','V','M','F','E','D','K','2') // OEM table id 8 bytes long

-#define EFI_ACPI_OEM_REVISION     0x20120804

+#define EFI_ACPI_OEM_REVISION     0x20130221

 #define EFI_ACPI_CREATOR_ID       SIGNATURE_32('O','V','M','F')

-#define EFI_ACPI_CREATOR_REVISION 0x00000098

+#define EFI_ACPI_CREATOR_REVISION 0x00000099

 

-#define INT_MODEL       0x01

 #define SCI_INT_VECTOR  0x0009

 #define SMI_CMD_IO_PORT 0xB2

 #define ACPI_ENABLE     0xF1

 #define ACPI_DISABLE    0xF0

 #define S4BIOS_REQ      0x00

 #define PM1a_EVT_BLK    0x0000b000

-#define PM1b_EVT_BLK    0x00000000

 #define PM1a_CNT_BLK    0x0000b004

-#define PM1b_CNT_BLK    0x00000000

-#define PM2_CNT_BLK     0x00000000

 #define PM_TMR_BLK      0x0000b008

 #define GPE0_BLK        0x0000afe0

-#define GPE1_BLK        0x00000000

 #define PM1_EVT_LEN     0x04

 #define PM1_CNT_LEN     0x02

-#define PM2_CNT_LEN     0x00

 #define PM_TM_LEN       0x04

 #define GPE0_BLK_LEN    0x04

-#define GPE1_BLK_LEN    0x00

-#define GPE1_BASE       0x00

 #define RESERVED        0x00

 #define P_LVL2_LAT      0x0065

 #define P_LVL3_LAT      0x03E9

@@ -58,7 +51,24 @@
 #define DAY_ALRM        0x00

 #define MON_ALRM        0x00

 #define CENTURY         0x00

-#define FLAG            EFI_ACPI_1_0_WBINVD | EFI_ACPI_1_0_PROC_C1 | EFI_ACPI_1_0_SLP_BUTTON | EFI_ACPI_1_0_RTC_S4

+#define FLAG            (EFI_ACPI_2_0_WBINVD | \

+                         EFI_ACPI_2_0_PROC_C1 | \

+                         EFI_ACPI_2_0_SLP_BUTTON | \

+                         EFI_ACPI_2_0_RTC_S4 | \

+                         EFI_ACPI_2_0_RESET_REG_SUP)

+#define RESET_REG       0xCF9

+#define RESET_VALUE     (BIT2 | BIT1) // PIIX3 Reset CPU + System Reset

 

-#endif

+//

+// Byte-aligned IO port register block initializer for

+// EFI_ACPI_2_0_GENERIC_ADDRESS_STRUCTURE

+//

+#define GAS2_IO(Base, Size) {                             \

+          EFI_ACPI_2_0_SYSTEM_IO, /* AddressSpaceId    */ \

+          (Size) * 8,             /* RegisterBitWidth  */ \

+          0,                      /* RegisterBitOffset */ \

+          0,                      /* Reserved          */ \

+          (Base)                  /* Address           */ \

+          }

 

+#endif

diff --git a/OvmfPkg/Include/IndustryStandard/LinuxBzimage.h b/OvmfPkg/Include/IndustryStandard/LinuxBzimage.h
index d16b112f..b83b7916 100644
--- a/OvmfPkg/Include/IndustryStandard/LinuxBzimage.h
+++ b/OvmfPkg/Include/IndustryStandard/LinuxBzimage.h
@@ -1,6 +1,6 @@
 /** @file

 

-  Copyright (c) 2011 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -15,7 +15,6 @@
 #define __LINUX_BZIMAGE_H__

 

 #define BOOTSIG			0x1FE

-#define SETUP_VERSION		0x206

 #define SETUP_HDR		0x53726448	/* 0x53726448 == "HdrS" */

 

 #define E820_RAM		1

@@ -55,7 +54,8 @@ struct setup_header {
 	UINT32 ramdisk_max;    /* Highest legal initrd address */

 	UINT32 kernel_alignment; /* Physical addr alignment required for kernel */

 	UINT8 relocatable_kernel; /* Whether kernel is relocatable or not */

-	UINT8 _pad2[3];

+	UINT8 min_alignment;

+	UINT16 xloadflags;

 	UINT32 cmdline_size;

 	UINT32 hardware_subarch;

 	UINT64 hardware_subarch_data;

diff --git a/OvmfPkg/Include/Library/LoadLinuxLib.h b/OvmfPkg/Include/Library/LoadLinuxLib.h
index d1064d23..36ee352e 100644
--- a/OvmfPkg/Include/Library/LoadLinuxLib.h
+++ b/OvmfPkg/Include/Library/LoadLinuxLib.h
@@ -1,7 +1,7 @@
 /** @file

   Load/boot UEFI Linux.

 

-  Copyright (c) 2011 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -95,6 +95,26 @@ LoadLinuxAllocateKernelSetupPages (
 

 

 /**

+  Clears the uninitialised space before and after the struct setup_header

+  in the kernel setup image. The kernel requires that these be zeroed

+  unless explicitly initialised, so this function should be called after

+  the setup_header has been copied in from a bzImage, before setting up

+  anything else.

+

+  @param[in]     KernelSetup - The kernel setup image

+

+  @retval    EFI_SUCCESS - The Linux kernel setup was successfully initialized

+  @retval    EFI_INVALID_PARAMETER - KernelSetup was NULL

+  @retval    EFI_UNSUPPORTED - The Linux kernel is not supported

+

+**/

+EFI_STATUS

+EFIAPI

+LoadLinuxInitializeKernelSetup (

+  IN VOID        *KernelSetup

+  );

+

+/**

   Allocates pages for the kernel.

 

   @param[in]     KernelSetup - The kernel setup image

diff --git a/OvmfPkg/Include/Library/QemuFwCfgLib.h b/OvmfPkg/Include/Library/QemuFwCfgLib.h
index 3776d79e..9d023777 100644
--- a/OvmfPkg/Include/Library/QemuFwCfgLib.h
+++ b/OvmfPkg/Include/Library/QemuFwCfgLib.h
@@ -1,7 +1,7 @@
 /** @file

   QEMU/KVM Firmware Configuration access

 

-  Copyright (c) 2011 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -103,6 +103,25 @@ QemuFwCfgReadBytes (
 

 

 /**

+  Writes firmware configuration bytes from a buffer

+

+  If called multiple times, then the data written will

+  continue at the offset of the firmware configuration

+  item where the previous write ended.

+

+  @param[in] Size - Size in bytes to write

+  @param[in] Buffer - Buffer to read data from

+

+**/

+VOID

+EFIAPI

+QemuFwCfgWriteBytes (

+  IN UINTN                  Size,

+  IN VOID                   *Buffer

+  );

+

+

+/**

   Reads a UINT8 firmware configuration value

 

   @return    Value of Firmware Configuration item read

diff --git a/OvmfPkg/Library/LoadLinuxLib/Ia32/JumpToKernel.S b/OvmfPkg/Library/LoadLinuxLib/Ia32/JumpToKernel.S
index b8cd4ca5..f7440f74 100644
--- a/OvmfPkg/Library/LoadLinuxLib/Ia32/JumpToKernel.S
+++ b/OvmfPkg/Library/LoadLinuxLib/Ia32/JumpToKernel.S
@@ -1,6 +1,6 @@
 #------------------------------------------------------------------------------

 #

-# Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>

+# Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 #

 # This program and the accompanying materials

 # are licensed and made available under the terms and conditions of the BSD License

@@ -13,6 +13,7 @@
 #------------------------------------------------------------------------------

 

 ASM_GLOBAL ASM_PFX(JumpToKernel)

+ASM_GLOBAL ASM_PFX(JumpToUefiKernel)

 

 #------------------------------------------------------------------------------

 # VOID

@@ -27,3 +28,19 @@ ASM_PFX(JumpToKernel):
     calll   0x4(%esp)

     ret

 

+#------------------------------------------------------------------------------

+# VOID

+# EFIAPI

+# JumpToUefiKernel (

+#   EFI_HANDLE ImageHandle,

+#   EFI_SYSTEM_TABLE *SystemTable,

+#   VOID *KernelBootParams,

+#   VOID *KernelStart

+#   );

+#------------------------------------------------------------------------------

+ASM_PFX(JumpToUefiKernel):

+    movl    0xc(%esp), %eax

+    movl    0x264(%eax), %eax

+    addl    0x10(%esp), %eax

+    jmp     %eax

+

diff --git a/OvmfPkg/Library/LoadLinuxLib/Ia32/JumpToKernel.asm b/OvmfPkg/Library/LoadLinuxLib/Ia32/JumpToKernel.asm
index a8f3965f..21d0c4e7 100644
--- a/OvmfPkg/Library/LoadLinuxLib/Ia32/JumpToKernel.asm
+++ b/OvmfPkg/Library/LoadLinuxLib/Ia32/JumpToKernel.asm
@@ -1,6 +1,6 @@
 ;------------------------------------------------------------------------------

 ;

-; Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+; Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 ;

 ; This program and the accompanying materials

 ; are licensed and made available under the terms and conditions of the BSD License

@@ -32,4 +32,23 @@ JumpToKernel PROC
 

 JumpToKernel ENDP

 

+;------------------------------------------------------------------------------

+; VOID

+; EFIAPI

+; JumpToUefiKernel (

+;   EFI_HANDLE ImageHandle,

+;   EFI_SYSTEM_TABLE *SystemTable,

+;   VOID *KernelBootParams,

+;   VOID *KernelStart

+;   );

+;------------------------------------------------------------------------------

+JumpToUefiKernel PROC

+

+    mov     eax, [esp + 12]

+    mov     eax, [eax + 264h]

+    add     eax, [esp + 16]

+    jmp     eax

+

+JumpToUefiKernel ENDP

+

 END

diff --git a/OvmfPkg/Library/LoadLinuxLib/Linux.c b/OvmfPkg/Library/LoadLinuxLib/Linux.c
index 96c985bc..c714225e 100644
--- a/OvmfPkg/Library/LoadLinuxLib/Linux.c
+++ b/OvmfPkg/Library/LoadLinuxLib/Linux.c
@@ -1,6 +1,6 @@
 /** @file

 

-  Copyright (c) 2011 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>

 

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

@@ -60,7 +60,8 @@ LoadLinuxCheckKernelSetup (
 

   if ((Bp->hdr.signature != 0xAA55) || // Check boot sector signature

       (Bp->hdr.header != SETUP_HDR) ||

-      (Bp->hdr.version < 0x205)        // We only support relocatable kernels

+      (Bp->hdr.version < 0x205) || // We only support relocatable kernels

+      (!Bp->hdr.relocatable_kernel)

      ) {

     return EFI_UNSUPPORTED;

   } else {

@@ -118,6 +119,34 @@ LoadLinuxAllocateKernelSetupPages (
   }

 }

 

+EFI_STATUS

+EFIAPI

+LoadLinuxInitializeKernelSetup (

+  IN VOID        *KernelSetup

+  )

+{

+  EFI_STATUS                Status;

+  UINTN                     SetupEnd;

+  struct boot_params        *Bp;

+

+  Status = BasicKernelSetupCheck (KernelSetup);

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+

+  Bp = (struct boot_params*) KernelSetup;

+

+  SetupEnd = 0x202 + (Bp->hdr.jump & 0xff);

+

+  //

+  // Clear all but the setup_header

+  //

+  ZeroMem (KernelSetup, 0x1f1);

+  ZeroMem (((UINT8 *)KernelSetup) + SetupEnd, 4096 - SetupEnd);

+  DEBUG ((EFI_D_INFO, "Cleared kernel setup 0-0x1f1, 0x%x-0x1000\n", SetupEnd));

+

+  return EFI_SUCCESS;

+}

 

 VOID*

 EFIAPI

@@ -575,14 +604,11 @@ SetupGraphics (
 STATIC

 EFI_STATUS

 SetupLinuxBootParams (

-  IN VOID                   *Kernel,

   IN OUT struct boot_params *Bp

   )

 {

   SetupGraphics (Bp);

 

-  Bp->hdr.code32_start = (UINT32)(UINTN) Kernel;

-

   SetupLinuxMemmap (Bp);

 

   return EFI_SUCCESS;

@@ -606,7 +632,7 @@ LoadLinux (
 

   Bp = (struct boot_params *) KernelSetup;

 

-  if (Bp->hdr.version < 0x205) {

+  if (Bp->hdr.version < 0x205 || !Bp->hdr.relocatable_kernel) {

     //

     // We only support relocatable kernels

     //

@@ -615,7 +641,19 @@ LoadLinux (
 

   InitLinuxDescriptorTables ();

 

-  SetupLinuxBootParams (Kernel, (struct boot_params*) KernelSetup);

+  Bp->hdr.code32_start = (UINT32)(UINTN) Kernel;

+  if (Bp->hdr.version >= 0x20c && Bp->hdr.handover_offset &&

+      (Bp->hdr.load_flags & (sizeof (UINTN) == 4 ? BIT2 : BIT3))) {

+    DEBUG ((EFI_D_INFO, "Jumping to kernel EFI handover point at ofs %x\n", Bp->hdr.handover_offset));

+

+    DisableInterrupts ();

+    JumpToUefiKernel ((VOID*) gImageHandle, (VOID*) gST, KernelSetup, Kernel);

+  }

+

+  //

+  // Old kernels without EFI handover protocol

+  //

+  SetupLinuxBootParams (KernelSetup);

 

   DEBUG ((EFI_D_INFO, "Jumping to kernel\n"));

   DisableInterrupts ();

diff --git a/OvmfPkg/Library/LoadLinuxLib/LoadLinuxLib.h b/OvmfPkg/Library/LoadLinuxLib/LoadLinuxLib.h
index f8697972..045cbf9b 100644
--- a/OvmfPkg/Library/LoadLinuxLib/LoadLinuxLib.h
+++ b/OvmfPkg/Library/LoadLinuxLib/LoadLinuxLib.h
@@ -1,7 +1,7 @@
 /** @file

   Boot UEFI Linux.

 

-  Copyright (c) 2008 - 2011, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2008 - 2013, Intel Corporation. All rights reserved.<BR>

 

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

@@ -37,6 +37,15 @@ JumpToKernel (
   );

 

 VOID

+EFIAPI

+JumpToUefiKernel (

+  EFI_HANDLE ImageHandle,

+  EFI_SYSTEM_TABLE *SystemTable,

+  VOID *KernelBootParams,

+  VOID *KernelStart

+  );

+

+VOID

 InitLinuxDescriptorTables (

   VOID

   );

diff --git a/OvmfPkg/Library/LoadLinuxLib/X64/JumpToKernel.S b/OvmfPkg/Library/LoadLinuxLib/X64/JumpToKernel.S
index 9ae755b0..056e3c01 100644
--- a/OvmfPkg/Library/LoadLinuxLib/X64/JumpToKernel.S
+++ b/OvmfPkg/Library/LoadLinuxLib/X64/JumpToKernel.S
@@ -1,6 +1,6 @@
 #------------------------------------------------------------------------------

 #

-# Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>

+# Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 #

 # This program and the accompanying materials

 # are licensed and made available under the terms and conditions of the BSD License

@@ -13,6 +13,7 @@
 #------------------------------------------------------------------------------

 

 ASM_GLOBAL ASM_PFX(JumpToKernel)

+ASM_GLOBAL ASM_PFX(JumpToUefiKernel)

 

 #------------------------------------------------------------------------------

 # VOID

@@ -23,8 +24,68 @@ ASM_GLOBAL ASM_PFX(JumpToKernel)
 #   );

 #------------------------------------------------------------------------------

 ASM_PFX(JumpToKernel):

+

+    // Set up for executing kernel. BP in %esi, entry point on the stack

+    // (64-bit when the 'ret' will use it as 32-bit, but we're little-endian)

+    movq    %rdx, %rsi

+    pushq   %rcx

+

+    // Jump into the compatibility mode CS

+    pushq   $0x10

+    leaq    1f(%rip), %rax

+    pushq   %rax

+    .byte   0x48, 0xcb                      // retfq

+

+1:  // Now in compatibility mode

+.code32

+    movl    $0x18, %eax

+    movl    %eax, %ds

+    movl    %eax, %es

+    movl    %eax, %fs

+    movl    %eax, %gs

+    movl    %eax, %ss

+

+    // Disable paging

+    movl    %cr0, %eax

+    btcl    $31, %eax

+    movl    %eax, %cr0

+

+    // Disable long mode in EFER

+    movl    $0x0c0000080, %ecx

+    rdmsr

+    btcl    $8, %eax

+    wrmsr

+

+    // Disable PAE

+    movl    %cr4, %eax

+    btcl    $5, %eax

+    movl    %eax, %cr4

+

+    // Zero registers and 'return' to kernel

+    xorl    %ebp, %ebp

+    xorl    %edi, %edi

+    xorl    %ebx, %ebx

+    ret

+.code64

+

+#------------------------------------------------------------------------------

+# VOID

+# EFIAPI

+# JumpToUefiKernel (

+#   EFI_HANDLE ImageHandle,        // rcx

+#   EFI_SYSTEM_TABLE *SystemTable, // rdx

+#   VOID *KernelBootParams,        // r8

+#   VOID *KernelStart              // r9

+#   );

+#------------------------------------------------------------------------------

+ASM_PFX(JumpToUefiKernel):

+    movq    %rcx, %rdi

     movq    %rdx, %rsi

-    addq    $0x200, %rcx

-    callq   %rcx

+    movq    %r8, %rdx

+    xor     %rax, %rax

+    movl    0x264(%r8), %eax

+    addq    %rax, %r9

+    addq    $0x200, %r9

+    callq   %r9

     ret

 

diff --git a/OvmfPkg/Library/LoadLinuxLib/X64/JumpToKernel.asm b/OvmfPkg/Library/LoadLinuxLib/X64/JumpToKernel.asm
index ed53321c..fc07eab6 100644
--- a/OvmfPkg/Library/LoadLinuxLib/X64/JumpToKernel.asm
+++ b/OvmfPkg/Library/LoadLinuxLib/X64/JumpToKernel.asm
@@ -1,6 +1,6 @@
 ;------------------------------------------------------------------------------

 ;

-; Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+; Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 ;

 ; This program and the accompanying materials

 ; are licensed and made available under the terms and conditions of the BSD License

@@ -24,11 +24,72 @@
 ;------------------------------------------------------------------------------

 JumpToKernel PROC

 

+    ; Set up for executing kernel. BP in %esi, entry point on the stack

+    ; (64-bit when the 'ret' will use it as 32-bit, but we're little-endian)

+    mov    rsi, rdx

+    push   rcx

+

+    ; Jump into the compatibility mode CS

+    push    10h

+    lea     rax, @F

+    push    rax

+    DB 048h, 0cbh                      ; retfq

+

+@@:

+    ; Now in compatibility mode.

+

+    DB 0b8h, 018h, 000h, 000h, 000h    ; movl    $0x18, %eax

+    DB 08eh, 0d8h                      ; movl    %eax, %ds

+    DB 08eh, 0c0h                      ; movl    %eax, %es

+    DB 08eh, 0e0h                      ; movl    %eax, %fs

+    DB 08eh, 0e8h                      ; movl    %eax, %gs

+    DB 08eh, 0d0h                      ; movl    %eax, %ss

+

+    ; Disable paging

+    DB 00fh, 020h, 0c0h                ; movl    %cr0, %eax

+    DB 00fh, 0bah, 0f8h, 01fh          ; btcl    $31, %eax

+    DB 00fh, 022h, 0c0h                ; movl    %eax, %cr0

+

+    ; Disable long mode in EFER

+    DB 0b9h, 080h, 000h, 000h, 0c0h    ; movl    $0x0c0000080, %ecx

+    DB 00fh, 032h                      ; rdmsr

+    DB 00fh, 0bah, 0f8h, 008h          ; btcl    $8, %eax

+    DB 00fh, 030h                      ; wrmsr

+

+    ; Disable PAE

+    DB 00fh, 020h, 0e0h                ; movl    %cr4, %eax

+    DB 00fh, 0bah, 0f8h, 005h          ; btcl    $5, %eax

+    DB 00fh, 022h, 0e0h                ; movl    %eax, %cr4

+

+    DB 031h, 0edh                      ; xor     %ebp, %ebp

+    DB 031h, 0ffh                      ; xor     %edi, %edi

+    DB 031h, 0dbh                      ; xor     %ebx, %ebx

+    DB 0c3h                            ; ret

+

+JumpToKernel ENDP

+

+;------------------------------------------------------------------------------

+; VOID

+; EFIAPI

+; JumpToUefiKernel (

+;   EFI_HANDLE ImageHandle,        // rcx

+;   EFI_SYSTEM_TABLE *SystemTable, // rdx

+;   VOID *KernelBootParams         // r8

+;   VOID *KernelStart,             // r9

+;   );

+;------------------------------------------------------------------------------

+JumpToUefiKernel PROC

+

+    mov     rdi, rcx

     mov     rsi, rdx

-    add     rcx, 200h

-    call    rcx

+    mov     rdx, r8

+    xor     rax, rax

+    mov     eax, [r8 + 264h]

+    add     r9, rax

+    add     r9, 200h

+    call    r9

     ret

 

-JumpToKernel ENDP

+JumpToUefiKernel ENDP

 

 END

diff --git a/OvmfPkg/Library/PlatformBdsLib/QemuKernel.c b/OvmfPkg/Library/PlatformBdsLib/QemuKernel.c
index fa8bcbc9..47ebed9f 100644
--- a/OvmfPkg/Library/PlatformBdsLib/QemuKernel.c
+++ b/OvmfPkg/Library/PlatformBdsLib/QemuKernel.c
@@ -1,6 +1,6 @@
 /** @file

 

-  Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -78,6 +78,11 @@ TryRunningQemuKernel (
     goto FreeAndReturn;

   }

 

+  Status = LoadLinuxInitializeKernelSetup (SetupBuf);

+  if (EFI_ERROR (Status)) {

+    goto FreeAndReturn;

+  }

+

   KernelInitialSize = LoadLinuxGetKernelSize (SetupBuf, KernelSize);

   if (KernelInitialSize == 0) {

     Status = EFI_UNSUPPORTED;

diff --git a/OvmfPkg/Library/QemuFwCfgLib/Ia32/IoLibExAsm.S b/OvmfPkg/Library/QemuFwCfgLib/Ia32/IoLibExAsm.S
index a32b2c60..c2735d2c 100644
--- a/OvmfPkg/Library/QemuFwCfgLib/Ia32/IoLibExAsm.S
+++ b/OvmfPkg/Library/QemuFwCfgLib/Ia32/IoLibExAsm.S
@@ -1,6 +1,6 @@
 #------------------------------------------------------------------------------

 #

-# Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+# Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 # This program and the accompanying materials

 # are licensed and made available under the terms and conditions of the BSD License

 # which accompanies this distribution.  The full text of the license may be found at

@@ -30,3 +30,23 @@ rep insb
     popl    %edi

     ret

 

+

+#------------------------------------------------------------------------------

+#  VOID

+#  EFIAPI

+#  IoWriteFifo8 (

+#    IN UINTN                  Port,

+#    IN UINTN                  Size,

+#    IN VOID                   *Buffer

+#    );

+#------------------------------------------------------------------------------

+ASM_GLOBAL ASM_PFX(IoWriteFifo8)

+ASM_PFX(IoWriteFifo8):

+    movw    4(%esp), %dx

+    movl    8(%esp), %ecx

+    pushl   %esi

+    movl    16(%esp), %esi

+rep outsb

+    popl    %esi

+    ret

+

diff --git a/OvmfPkg/Library/QemuFwCfgLib/Ia32/IoLibExAsm.asm b/OvmfPkg/Library/QemuFwCfgLib/Ia32/IoLibExAsm.asm
index e46af81e..f7d65c49 100644
--- a/OvmfPkg/Library/QemuFwCfgLib/Ia32/IoLibExAsm.asm
+++ b/OvmfPkg/Library/QemuFwCfgLib/Ia32/IoLibExAsm.asm
@@ -1,6 +1,6 @@
 ;------------------------------------------------------------------------------

 ;

-; Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+; Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 ; This program and the accompanying materials

 ; are licensed and made available under the terms and conditions of the BSD License

 ; which accompanies this distribution.  The full text of the license may be found at

@@ -29,12 +29,34 @@ IoReadFifo8 PROC
     mov     dx, [esp + 4]

     mov     ecx, [esp + 8]

     push    edi

-    mov     edx, [esp + 16]

+    mov     edi, [esp + 16]

 rep insb

     pop     edi

     ret

 

 IoReadFifo8 ENDP

 

+

+;------------------------------------------------------------------------------

+;  VOID

+;  EFIAPI

+;  IoWriteFifo8 (

+;    IN UINTN                  Port,

+;    IN UINTN                  Size,

+;    IN VOID                   *Buffer

+;    );

+;------------------------------------------------------------------------------

+IoWriteFifo8 PROC

+

+    mov     dx, [esp + 4]

+    mov     ecx, [esp + 8]

+    push    esi

+    mov     esi, [esp + 16]

+rep outsb

+    pop     esi

+    ret

+

+IoWriteFifo8 ENDP

+

     END

 

diff --git a/OvmfPkg/Library/QemuFwCfgLib/QemuFwCfgLib.c b/OvmfPkg/Library/QemuFwCfgLib/QemuFwCfgLib.c
index 8caab42e..7e5ea00b 100644
--- a/OvmfPkg/Library/QemuFwCfgLib/QemuFwCfgLib.c
+++ b/OvmfPkg/Library/QemuFwCfgLib/QemuFwCfgLib.c
@@ -1,6 +1,6 @@
 /** @file

 

-  Copyright (c) 2011 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>

 

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

@@ -50,6 +50,32 @@ IoReadFifo8 (
   OUT     VOID                      *Buffer

   );

 

+/**

+  Writes an 8-bit I/O port fifo from a block of memory.

+

+  Writes the 8-bit I/O fifo port specified by Port.

+

+  The port is written Count times, and the data are obtained

+  from the provided Buffer.

+

+  This function must guarantee that all I/O read and write operations are

+  serialized.

+

+  If 8-bit I/O port operations are not supported, then ASSERT().

+

+  @param  Port    The I/O port to read.

+  @param  Count   The number of times to read I/O port.

+  @param  Buffer  The buffer to store the read data into.

+

+**/

+VOID

+EFIAPI

+IoWriteFifo8 (

+  IN      UINTN                     Port,

+  IN      UINTN                     Count,

+  OUT     VOID                      *Buffer

+  );

+

 

 /**

   Returns a boolean indicating if the firmware configuration interface

@@ -132,6 +158,29 @@ QemuFwCfgReadBytes (
   }

 }

 

+/**

+  Write firmware configuration bytes from a buffer

+

+  If called multiple times, then the data written will

+  continue at the offset of the firmware configuration

+  item where the previous write ended.

+

+  @param[in] Size - Size in bytes to write

+  @param[in] Buffer - Buffer to read data from

+

+**/

+VOID

+EFIAPI

+QemuFwCfgWriteBytes (

+  IN UINTN                  Size,

+  IN VOID                   *Buffer

+  )

+{

+  if (mQemuFwCfgSupported) {

+    IoWriteFifo8 (0x511, Size, Buffer);

+  }

+}

+

 

 /**

   Reads a UINT8 firmware configuration value

diff --git a/OvmfPkg/Library/QemuFwCfgLib/X64/IoLibExAsm.S b/OvmfPkg/Library/QemuFwCfgLib/X64/IoLibExAsm.S
index b1125ed7..69167b70 100644
--- a/OvmfPkg/Library/QemuFwCfgLib/X64/IoLibExAsm.S
+++ b/OvmfPkg/Library/QemuFwCfgLib/X64/IoLibExAsm.S
@@ -1,6 +1,6 @@
 #------------------------------------------------------------------------------

 #

-# Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+# Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 # This program and the accompanying materials

 # are licensed and made available under the terms and conditions of the BSD License

 # which accompanies this distribution.  The full text of the license may be found at

@@ -28,3 +28,20 @@ rep insb
     mov     %r8, %rdi           # restore rdi

     ret

 

+#------------------------------------------------------------------------------

+#  VOID

+#  EFIAPI

+#  IoWriteFifo8 (

+#    IN UINTN                  Port,              // rcx

+#    IN UINTN                  Size,              // rdx

+#    IN VOID                   *Buffer            // r8

+#    );

+#------------------------------------------------------------------------------

+ASM_GLOBAL ASM_PFX(IoWriteFifo8)

+ASM_PFX(IoWriteFifo8):

+    xchg    %rcx, %rdx

+    xchg    %r8, %rsi           # rdi: buffer address; r8: save rsi

+rep outsb

+    mov     %r8, %rsi           # restore rsi

+    ret

+

diff --git a/OvmfPkg/Library/QemuFwCfgLib/X64/IoLibExAsm.asm b/OvmfPkg/Library/QemuFwCfgLib/X64/IoLibExAsm.asm
index c60ad2c5..47ac158f 100644
--- a/OvmfPkg/Library/QemuFwCfgLib/X64/IoLibExAsm.asm
+++ b/OvmfPkg/Library/QemuFwCfgLib/X64/IoLibExAsm.asm
@@ -1,6 +1,6 @@
 ;------------------------------------------------------------------------------

 ;

-; Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+; Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 ; This program and the accompanying materials

 ; are licensed and made available under the terms and conditions of the BSD License

 ; which accompanies this distribution.  The full text of the license may be found at

@@ -32,5 +32,25 @@ rep insb
 

 IoReadFifo8 ENDP

 

+

+;------------------------------------------------------------------------------

+;  VOID

+;  EFIAPI

+;  IoWriteFifo8 (

+;    IN UINTN                  Port,              // rcx

+;    IN UINTN                  Size,              // rdx

+;    IN VOID                   *Buffer            // r8

+;    );

+;------------------------------------------------------------------------------

+IoWriteFifo8 PROC

+

+    xchg    rcx, rdx

+    xchg    rsi, r8             ; rdi: buffer address; r8: save rdi

+rep outsb

+    mov     rsi, r8             ; restore rdi

+    ret

+

+IoWriteFifo8 ENDP

+

     END

 

diff --git a/OvmfPkg/Library/ResetSystemLib/ResetSystemLib.c b/OvmfPkg/Library/ResetSystemLib/ResetSystemLib.c
index 52406add..d075fbef 100644
--- a/OvmfPkg/Library/ResetSystemLib/ResetSystemLib.c
+++ b/OvmfPkg/Library/ResetSystemLib/ResetSystemLib.c
@@ -17,6 +17,7 @@
 #include <Library/BaseLib.h>

 #include <Library/DebugLib.h>

 #include <Library/IoLib.h>

+#include <Library/TimerLib.h>

 

 VOID

 AcpiPmControl (

@@ -45,7 +46,11 @@ ResetCold (
   VOID

   )

 {

-  IoWrite8 (0x64, 0xfe);

+  IoWrite8 (0xCF9, BIT2 | BIT1); // 1st choice: PIIX3 RCR, RCPU|SRST

+  MicroSecondDelay (50);

+

+  IoWrite8 (0x64, 0xfe);         // 2nd choice: keyboard controller

+  CpuDeadLoop ();

 }

 

 /**

@@ -62,6 +67,7 @@ ResetWarm (
   )

 {

   IoWrite8 (0x64, 0xfe);

+  CpuDeadLoop ();

 }

 

 /**

diff --git a/OvmfPkg/Library/ResetSystemLib/ResetSystemLib.inf b/OvmfPkg/Library/ResetSystemLib/ResetSystemLib.inf
index 0694b4dd..c4d8ce54 100644
--- a/OvmfPkg/Library/ResetSystemLib/ResetSystemLib.inf
+++ b/OvmfPkg/Library/ResetSystemLib/ResetSystemLib.inf
@@ -35,4 +35,4 @@
 [LibraryClasses]

   DebugLib

   IoLib

-

+  TimerLib

diff --git a/OvmfPkg/OvmfPkgIa32.fdf b/OvmfPkg/OvmfPkgIa32.fdf
index 36c97566..8861980b 100644
--- a/OvmfPkg/OvmfPkgIa32.fdf
+++ b/OvmfPkg/OvmfPkgIa32.fdf
@@ -46,12 +46,12 @@ FV = SECFV
 

 [FD.MEMFD]

 BaseAddress   = 0x800000|gUefiOvmfPkgTokenSpaceGuid.PcdOvmfMemFvBase

-Size          = 0x600000|gUefiOvmfPkgTokenSpaceGuid.PcdOvmfMemFvSize

+Size          = 0x800000|gUefiOvmfPkgTokenSpaceGuid.PcdOvmfMemFvSize

 ErasePolarity = 1

 BlockSize     = 0x10000

-NumBlocks     = 0x60

+NumBlocks     = 0x80

 

-0x0|0x600000

+0x0|0x800000

 FV = MAINFV

 

 ################################################################################

diff --git a/OvmfPkg/OvmfPkgIa32X64.fdf b/OvmfPkg/OvmfPkgIa32X64.fdf
index a762dc9f..93a36b7c 100644
--- a/OvmfPkg/OvmfPkgIa32X64.fdf
+++ b/OvmfPkg/OvmfPkgIa32X64.fdf
@@ -46,12 +46,12 @@ FV = SECFV
 

 [FD.MEMFD]

 BaseAddress   = 0x800000|gUefiOvmfPkgTokenSpaceGuid.PcdOvmfMemFvBase

-Size          = 0x600000|gUefiOvmfPkgTokenSpaceGuid.PcdOvmfMemFvSize

+Size          = 0x800000|gUefiOvmfPkgTokenSpaceGuid.PcdOvmfMemFvSize

 ErasePolarity = 1

 BlockSize     = 0x10000

-NumBlocks     = 0x60

+NumBlocks     = 0x80

 

-0x0|0x600000

+0x0|0x800000

 FV = MAINFV

 

 ################################################################################

diff --git a/OvmfPkg/OvmfPkgX64.fdf b/OvmfPkg/OvmfPkgX64.fdf
index fcdac031..d023cb19 100644
--- a/OvmfPkg/OvmfPkgX64.fdf
+++ b/OvmfPkg/OvmfPkgX64.fdf
@@ -46,12 +46,12 @@ FV = SECFV
 

 [FD.MEMFD]

 BaseAddress   = 0x800000|gUefiOvmfPkgTokenSpaceGuid.PcdOvmfMemFvBase

-Size          = 0x600000|gUefiOvmfPkgTokenSpaceGuid.PcdOvmfMemFvSize

+Size          = 0x800000|gUefiOvmfPkgTokenSpaceGuid.PcdOvmfMemFvSize

 ErasePolarity = 1

 BlockSize     = 0x10000

-NumBlocks     = 0x60

+NumBlocks     = 0x80

 

-0x0|0x600000

+0x0|0x800000

 FV = MAINFV

 

 ################################################################################

diff --git a/OvmfPkg/README b/OvmfPkg/README
index 8db4cac0..0c0a81a6 100644
--- a/OvmfPkg/README
+++ b/OvmfPkg/README
@@ -52,6 +52,7 @@ these binary outputs:
 * OVMF.FD

   - Please note!  This filename has changed.  Older releases used OVMF.Fv.

 * OvmfVideo.rom

+  - This file is not built separately any longer, starting with svn r13520.

 

 More information on building OVMF can be found at:

 

diff --git a/OvmfPkg/build.sh b/OvmfPkg/build.sh
index 61b3ff85..f64ea915 100755
--- a/OvmfPkg/build.sh
+++ b/OvmfPkg/build.sh
@@ -1,7 +1,7 @@
 #!/bin/bash
 #
 # Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-# Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>
+# Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>
 #
 # This program and the accompanying materials
 # are licensed and made available under the terms and conditions of the BSD License
@@ -58,15 +58,20 @@ case `uname` in
     echo Cygwin not fully supported yet.
     ;;
   Darwin*)
-      Major=$(uname -r | cut -f 1 -d '.')
-      if [[ $Major == 9 ]]
-      then
+    Major=$(uname -r | cut -f 1 -d '.')
+    case $Major in
+      10)
+        TARGET_TOOLS=XCODE32
+        ;;
+      1[12])
+        TARGET_TOOLS=XCLANG
+        ;;
+       *)
         echo OvmfPkg requires Snow Leopard or later OS
         exit 1
-      else
-        TARGET_TOOLS=XCODE32
-      fi
-      ;;
+        ;;
+    esac
+    ;;
   Linux*)
     gcc_version=$(gcc -v 2>&1 | tail -1 | awk '{print $3}')
     case $gcc_version in
@@ -134,7 +139,16 @@ done
 case $PROCESSOR in
   IA32)
     Processor=Ia32
-    QEMU_COMMAND=qemu
+    if  [ -x `which qemu-system-i386` ]; then
+      QEMU_COMMAND=qemu-system-i386
+    elif  [ -x `which qemu-system-x86_64` ]; then
+      QEMU_COMMAND=qemu-system-x86_64
+    elif  [ -x `which qemu` ]; then
+      QEMU_COMMAND=qemu
+    else
+      echo Unable to find QEMU for IA32 architecture!
+      exit 1
+    fi
     ;;
   X64)
     Processor=X64
diff --git a/OvmfPkg/create-release.py b/OvmfPkg/create-release.py
index 508c0919..6a6017a9 100755
--- a/OvmfPkg/create-release.py
+++ b/OvmfPkg/create-release.py
@@ -227,7 +227,6 @@ def create_zip(arch):
         'FV'

         )

     zipf.write(os.path.join(FV_DIR, 'OVMF.fd'), 'OVMF.fd')

-    zipf.write(os.path.join(FV_DIR, 'OvmfVideo.rom'), 'OvmfVideo.rom')

     zipf.close()

     print '[done]'

 

diff --git a/PandaBoardPkg/ConfigurationHeader.dat b/PandaBoardPkg/ConfigurationHeader.dat
index 4cb88825..ec7dbcd3 100644
--- a/PandaBoardPkg/ConfigurationHeader.dat
+++ b/PandaBoardPkg/ConfigurationHeader.dat
@@ -9,10 +9,10 @@ Flags=0x00000BBD
 CM_CLKSEL_CORE=0x00000110
 CM_DLL_CTRL=0x00000000
 CM_AUTOIDLE_DPLL_MPU=0x00000000
-CM_CLKSEL_DPLL_MPU=0x0002EE2F
+CM_CLKSEL_DPLL_MPU=0x00007D05
 CM_DIV_M2_DPLL_MPU=0x00000002
 CM_AUTOIDLE_DPLL_CORE=0x00000000
-CM_CLKSEL_DPLL_CORE=0x0003E82F
+CM_CLKSEL_DPLL_CORE=0x00007D05
 CM_DIV_M2_DPLL_CORE=0x00000002
 CM_DIV_M3_DPLL_CORE=0x00000008
 CM_DIV_M4_DPLL_CORE=0x00000008
@@ -20,7 +20,7 @@ CM_DIV_M5_DPLL_CORE=0x00000008
 CM_DIV_M6_DPLL_CORE=0x00000008
 CM_DIV_M7_DPLL_CORE=0x00000010
 CM_AUTOIDLE_DPLL_PER=0x00000000
-CM_CLKSEL_DPLL_PER=0x0002581D
+CM_CLKSEL_DPLL_PER=0x00001400
 CM_DIV_M2_DPLL_PER=0x00000008
 CM_DIV_M3_DPLL_PER=0x00000008
 CM_DIV_M4_DPLL_PER=0x0000000C
@@ -29,36 +29,36 @@ CM_DIV_M6_DPLL_PER=0x00000008
 CM_DIV_M7_DPLL_PER=0x0000000A
 CM_AUTOIDLE_DPLL_USB=0x00000000
 CM_CLKSEL_DPLL_USB=0x00000000
-CM_DIV_M2_DPLL_USB=0x00000002
+CM_DIV_M2_DPLL_USB=0x00000000
 
 CHRAM
 SectionKey=0xC0C0C0C2
 Valid=0x00000001
 Version=0x00000000
 Reserved=0x00000000
-SdramConfigEMIF1=0x98810EB1
-SdramRefreshEMIF1=0x0000030C
-SdramTim1EMIF1=0x12CD1624
-SdramTim2EMIF1=0x3058161B
-SdramTim3EMIF1=0x00D20540
-PwrMgtCtrlEMIF1=0x00000000
-DdrPhyCtrl1EMIF1=0x901FF417
-DdrPhyCtrl2EMIF1=0x00000000
-ModeReg1EMIF1=0x00000023
-ModeReg2EMIF1=0x00000001
-ModeReg3EMIF1=0x00000002
+SdramConfigEMIF1=0x80001ab9
+SdramRefreshEMIF1=0x00000618
+SdramTim1EMIF1=0x10eb0662
+SdramTim2EMIF1=0x20370dd2
+SdramTim3EMIF1=0x00b1c33f
+PwrMgtCtrlEMIF1=0x000000ff
+DdrPhyCtrl1EMIF1=0x049ff418
+DdrPhyCtrl2EMIF1=0x00000004
+ModeReg1EMIF1=0x000000c3
+ModeReg2EMIF1=0x00000004
+ModeReg3EMIF1=0x00000001
 Reserved=0x00000000
-SdramConfigEMIF2=0x98810EB1
-SdramRefreshEMIF2=0x0000030C
-SdramTim1EMIF2=0x12CD1624
-SdramTim2EMIF2=0x3058161B
-SdramTim3EMIF2=0x00D20540
-PwrMgtCtrlEMIF2=0x00000000
-DdrPhyCtrl1EMIF2=0x901FF417
-DdrPhyCtrl2EMIF2=0x00000000
-ModeReg1EMIF2=0x00000023
-ModeReg2EMIF2=0x00000001
-ModeReg3EMIF2=0x00000002
+SdramConfigEMIF2=0x80001ab9
+SdramRefreshEMIF2=0x00000618
+SdramTim1EMIF2=0x10eb0662
+SdramTim2EMIF2=0x20370dd2
+SdramTim3EMIF2=0x00b1c33f
+PwrMgtCtrlEMIF2=0x000000ff
+DdrPhyCtrl1EMIF2=0x049ff418
+DdrPhyCtrl2EMIF2=0x00000004
+ModeReg1EMIF2=0x000000c3
+ModeReg2EMIF2=0x00000004
+ModeReg3EMIF2=0x00000001
 Reserved=0x00000000
-DMMLisaMap0=0x80500300
-Flags=0x00000105
+DMMLisaMap0=0x80640300
+Flags=0x0000010f
diff --git a/PandaBoardPkg/Include/PandaBoard.h b/PandaBoardPkg/Include/PandaBoard.h
index 75e420f4..3f806e8e 100755
--- a/PandaBoardPkg/Include/PandaBoard.h
+++ b/PandaBoardPkg/Include/PandaBoard.h
@@ -172,16 +172,11 @@
 #define ARM_EB_EFI_MEMORY_REGION_SZ             0x1000000
 #endif
 
-// TODO: review Panda board revisions
+#endif 
+
 typedef enum {
-  REVISION_XM,
-  REVISION_UNKNOWN0,
-  REVISION_UNKNOWN1,
-  REVISION_UNKNOWN2,
-  REVISION_UNKNOWN3,
-  REVISION_C4,
-  REVISION_C123,
-  REVISION_AB,
-} PANDABOARD_REVISION;
+  PANDABOARD_REVISION_UNKNOWN=0,
+  PANDABOARD_REVISION_PANDA,
+  PANDABOARD_REVISION_PANDAES
 
-#endif 
+} PANDABOARD_REVISION;
diff --git a/PandaBoardPkg/Library/PandaBoardLib/Clock.c b/PandaBoardPkg/Library/PandaBoardLib/Clock.c
index cf73d79b..6e3ffbf4 100755
--- a/PandaBoardPkg/Library/PandaBoardLib/Clock.c
+++ b/PandaBoardPkg/Library/PandaBoardLib/Clock.c
@@ -15,55 +15,243 @@
 #include <Library/IoLib.h>
 #include <Library/DebugLib.h>
 
+#include <PandaBoard.h>
 #include <Omap4430/Omap4430.h>
 
 VOID
-ClockInit (
+VolConSetup (
+  IN  UINTN                     PmcSlaveAddr,
+  IN  UINTN                     SmpsAddr,
+  IN  UINTN                     Data
+  )
+{
+  // Setup VolCon command
+  MmioWrite32 (PRM_VC_VAL_BYPASS,
+               ((Data<<PRM_VC_VAL_BYPASS_DATA_POS)|
+               (SmpsAddr<<PRM_VC_VAL_BYPASS_REGADDR_POS)|
+               (PmcSlaveAddr)) );
+
+  // Validate command
+  MmioOr32 (PRM_VC_VAL_BYPASS, BIT24);
+  
+  // Wait for command completion
+  while( MmioRead32(PRM_VC_VAL_BYPASS) & BIT24 );
+}
+
+VOID
+VolConInit (
   VOID
   )
 {
-  //DPLL1 - DPLL4 are configured part of Configuration header which OMAP4 ROM parses.
-
-  // Enable PLL5 and set to 120 MHz as a reference clock.
-  MmioWrite32 (CM_CLKSEL4_PLL, CM_CLKSEL_PLL_MULT(120) | CM_CLKSEL_PLL_DIV(13));
-  MmioWrite32 (CM_CLKSEL5_PLL, CM_CLKSEL_DIV_120M(1));
-  MmioWrite32 (CM_CLKEN2_PLL, CM_CLKEN_FREQSEL_075_100 | CM_CLKEN_ENABLE);
-
-  // Turn on functional & interface clocks to the USBHOST power domain
-  MmioOr32(CM_FCLKEN_USBHOST, CM_FCLKEN_USBHOST_EN_USBHOST2_ENABLE
-                              | CM_FCLKEN_USBHOST_EN_USBHOST1_ENABLE);
-  MmioOr32(CM_ICLKEN_USBHOST, CM_ICLKEN_USBHOST_EN_USBHOST_ENABLE);
-
-  // Turn on functional & interface clocks to the USBTLL block.
-  MmioOr32(CM_FCLKEN3_CORE, CM_FCLKEN3_CORE_EN_USBTLL_ENABLE);
-  MmioOr32(CM_ICLKEN3_CORE, CM_ICLKEN3_CORE_EN_USBTLL_ENABLE);
-
-  // Turn on functional & interface clocks to MMC1 and I2C1 modules.
-  MmioOr32(CM_FCLKEN1_CORE, CM_FCLKEN1_CORE_EN_MMC1_ENABLE
-                            | CM_FCLKEN1_CORE_EN_I2C1_ENABLE);
-  MmioOr32(CM_ICLKEN1_CORE, CM_ICLKEN1_CORE_EN_MMC1_ENABLE
-                            | CM_ICLKEN1_CORE_EN_I2C1_ENABLE);
-
-  // Turn on functional & interface clocks to various Peripherals.
-  MmioOr32(CM_FCLKEN_PER, CM_FCLKEN_PER_EN_UART3_ENABLE
-                          | CM_FCLKEN_PER_EN_GPT4_ENABLE
-                          | CM_FCLKEN_PER_EN_GPIO2_ENABLE
-                          | CM_FCLKEN_PER_EN_GPIO3_ENABLE
-                          | CM_FCLKEN_PER_EN_GPIO4_ENABLE
-                          | CM_FCLKEN_PER_EN_GPIO5_ENABLE
-                          | CM_FCLKEN_PER_EN_GPIO6_ENABLE);
-  MmioOr32(CM_ICLKEN_PER, CM_ICLKEN_PER_EN_UART3_ENABLE
-                          | CM_ICLKEN_PER_EN_GPT3_ENABLE
-                          | CM_ICLKEN_PER_EN_GPT4_ENABLE
-                          | CM_ICLKEN_PER_EN_GPIO2_ENABLE
-                          | CM_ICLKEN_PER_EN_GPIO3_ENABLE
-                          | CM_ICLKEN_PER_EN_GPIO4_ENABLE
-                          | CM_ICLKEN_PER_EN_GPIO5_ENABLE
-                          | CM_ICLKEN_PER_EN_GPIO6_ENABLE);
-
-  // Turn on functional & inteface clocks to various wakeup modules.
-  MmioOr32(CM_FCLKEN_WKUP, CM_FCLKEN_WKUP_EN_GPIO1_ENABLE
-                           | CM_FCLKEN_WKUP_EN_WDT2_ENABLE);
-  MmioOr32(CM_ICLKEN_WKUP, CM_ICLKEN_WKUP_EN_GPIO1_ENABLE
-                           | CM_ICLKEN_WKUP_EN_WDT2_ENABLE);
+  // Sram Ldo Voltage Control Override (MPU, CORE, IVA)
+  MmioWrite32 (CONTROL_CORE_LDOSRAM_IVA_VOLTAGE_CTRL,
+               CONTROL_CORE_LDOSRAM_VOLTAGE_CTRL_VAL);
+  MmioWrite32 (CONTROL_CORE_LDOSRAM_MPU_VOLTAGE_CTRL,
+               CONTROL_CORE_LDOSRAM_VOLTAGE_CTRL_VAL);
+  MmioWrite32 (CONTROL_CORE_LDOSRAM_CORE_VOLTAGE_CTRL,
+               CONTROL_CORE_LDOSRAM_VOLTAGE_CTRL_VAL);
+
+  // Voltage controller setup
+  MmioWrite32 (PRM_VC_CFG_I2C_MODE, VC_CFG_I2C_MODE_VAL);
+  MmioWrite32 (PRM_VC_CFG_I2C_CLK, VC_CFG_I2C_CLK_VAL);
+}
+
+VOID
+ClockModuleEnable (
+  IN  UINTN                     Addr,
+  IN  UINTN                     Mode
+  )
+{
+  MmioOr32 (Addr, Mode);
+  while( (MmioRead32(Addr) & (BIT16|BIT17)) != 0 );
+}
+
+VOID
+ClockInit (
+  PANDABOARD_REVISION BoardRevision
+  )
+{
+  // Init Voltage Controller
+  VolConInit ();
+
+  // Setup CORE, MPU, IVA voltages for OPP100 operation
+
+  ClockModuleEnable (0x4A307838, 0x1); //cm_wkup_gpio1_clkctrl: AUTO
+
+  if( BoardRevision == PANDABOARD_REVISION_PANDAES ) {
+    //   TPS62361       => VDD_MPU
+    //   TWL6030 VCORE2 => VDD_IVA
+    //   TWL6030 VCORE1 => VDD_CORE
+
+	// Setup CORE voltage
+    VolConSetup(PMIC_SMPS_ID0_SLAVE_ADDR,
+	            PMIC_VCORE1_CFG_FORCE_REGADDR,
+                PMIC_VCORE1_CFG_FORCE_VSEL_VDD_CORE_4460);
+
+    // Clear TPS VSEL0
+    MmioAnd32 (GPIO1_BASE + GPIO_OE, ~BIT7);
+    MmioOr32 (GPIO1_BASE + GPIO_CLEARDATAOUT, BIT7);
+
+	// Setup MPU voltage
+    VolConSetup(TPS62361_SLAVE_ADDR,
+	            TPS62361_SET1_REG_ADDR,
+                TPS62361_SET1_REG_VAL);
+
+    // Set TPS VSEL0
+    MmioOr32 (GPIO1_BASE + GPIO_SETDATAOUT, BIT7);
+  }
+  else {
+    //   TWL6030 VCORE1 => VDD_MPU
+    //   TWL6030 VCORE2 => VDD_IVA
+    //   TWL6030 VCORE3 => VDD_CORE
+
+	// Setup CORE voltage
+    VolConSetup(PMIC_SMPS_ID0_SLAVE_ADDR,
+	            PMIC_VCORE3_CFG_FORCE_REGADDR,
+                PMIC_VCORE3_CFG_FORCE_VSEL);
+
+	// Setup MPU voltage
+    VolConSetup(PMIC_SMPS_ID0_SLAVE_ADDR,
+	            PMIC_VCORE1_CFG_FORCE_REGADDR,
+                PMIC_VCORE1_CFG_FORCE_VSEL_VDD_MPU_4430);
+  }
+
+  // Setup IVA voltage
+  VolConSetup(PMIC_SMPS_ID0_SLAVE_ADDR,
+              PMIC_VCORE2_CFG_FORCE_REGADDR,
+              PMIC_VCORE2_CFG_FORCE_VSEL);
+  
+  // Accelerate MPU frequency
+  MmioWrite32 (CKGEN_CM1_CM_DIV_M2_DPLL_MPU, CM_DIV_M2_DPLL_MPU_OPP100_VAL);
+
+  // Accelerate CORE clocks
+  MmioWrite32 (CKGEN_CM1_CM_DIV_M3_DPLL_CORE, CM_DIV_M3_DPLL_CORE_OPP100_VAL);
+  MmioWrite32 (CKGEN_CM1_CM_DIV_M4_DPLL_CORE, CM_DIV_M4_DPLL_CORE_OPP100_VAL);
+  MmioWrite32 (CKGEN_CM1_CM_DIV_M5_DPLL_CORE, CM_DIV_M5_DPLL_CORE_OPP100_VAL);
+  MmioWrite32 (CKGEN_CM1_CM_DIV_M6_DPLL_CORE, CM_DIV_M6_DPLL_CORE_OPP100_VAL);
+  MmioWrite32 (CKGEN_CM1_CM_DIV_M7_DPLL_CORE, CM_DIV_M7_DPLL_CORE_OPP100_VAL);
+
+  // Start core frequency update
+  MmioWrite32 ( CKGEN_CM1_CM_SHADOW_FREQ_CONFIG1,
+               (CM_SHADOW_FREQ_CONFIG1_DPLL_CORE_M2_DIV_OPP100|
+                CM_SHADOW_FREQ_CONFIG1_DPLL_CORE_DPLL_EN_LOCK|
+                CM_SHADOW_FREQ_CONFIG1_DLL_RESET_RST|
+                CM_SHADOW_FREQ_CONFIG1_FREQ_UPDATE_START));
+
+  // Wait for core frequency update completion
+  while( (MmioRead32(CKGEN_CM1_CM_SHADOW_FREQ_CONFIG1) & (BIT0)) != 0 );
+
+  // Setup and lock IVA DPLL
+  MmioWrite32 (CKGEN_CM1_CM_CLKSEL_DPLL_IVA,
+               CKGEN_CM1_CM_CLKSEL_DPLL_IVA_CLKSEL_VAL);
+  MmioWrite32 (CKGEN_CM1_CM_DIV_M4_DPLL_IVA,
+               CKGEN_CM1_CM_CLKSEL_DPLL_IVA_M4_VAL);
+  MmioWrite32 (CKGEN_CM1_CM_DIV_M5_DPLL_IVA,
+               CKGEN_CM1_CM_CLKSEL_DPLL_IVA_M5_VAL);
+  MmioWrite32 (CKGEN_CM1_CM_BYPCLK_DPLL_IVA,
+               CKGEN_CM1_CM_CLKSEL_DPLL_IVA_BYCLK_VAL);
+  MmioWrite32 (CKGEN_CM1_CM_CLKMODE_DPLL_IVA,
+               CKGEN_CM1_CM_CLKSEL_DPLL_IVA_CLKMODE_VAL);
+
+  // Setup and lock ABE DPLL
+  MmioWrite32 (CKGEN_CM1_CM_CLKSEL_DPLL_ABE,
+               CKGEN_CM1_CM_CLKSEL_DPLL_ABE_VAL);
+  MmioWrite32 (CKGEN_CM1_CM_DIV_M2_DPLL_ABE,
+               CKGEN_CM1_CM_DIV_M2_DPLL_ABE_VAL);
+  MmioWrite32 (CKGEN_CM1_CM_DIV_M3_DPLL_ABE,
+               CKGEN_CM1_CM_DIV_M3_DPLL_ABE_VAL);
+  MmioWrite32 (CKGEN_CM1_CM_CLKMODE_DPLL_ABE,
+               CKGEN_CM1_CM_CLKMODE_DPLL_ABE_VAL);
+
+  // Setup and lock USB DPLL
+  MmioWrite32 (CKGEN_CM2_CM_CLKSEL_DPLL_USB,
+               CKGEN_CM2_CM_CLKSEL_DPLL_USB_VAL);
+  MmioWrite32 (CKGEN_CM2_CM_DIV_M2_DPLL_USB,
+               CKGEN_CM2_CM_DIV_M2_DPLL_USB_VAL);
+  MmioWrite32 (CKGEN_CM2_CM_CLKMODE_DPLL_USB,
+               CKGEN_CM2_CM_CLKMODE_DPLL_USB_VAL);
+
+  MmioOr32 (0x4A009020, 0x100); //ISS_CLKCTRL_OPTFCLKEN
+  MmioOr32 (0x4A009120, 0xF00); //DSS_CLKCTRL_OPTFCLKEN
+
+  MmioWrite32 (0x4A008900, 0x2); //cm_mpu_m3_clkstctrl: SW_WKUP
+  MmioWrite32 (0x4A008F00, 0x2); //cm_ivahd_clkstctrl: SW_WKUP
+  MmioWrite32 (0x4A004400, 0x2); //cm_dsp_clkstctrl: SW_WKUP
+  MmioWrite32 (0x4A009100, 0x2); //cm_dss_clkstctrl: SW_WKUP
+  MmioWrite32 (0x4A009200, 0x2); //cm_sgx_clkstctrl: SW_WKUP
+  MmioWrite32 (0x4A004500, 0x2); //cm1_abe_clkstctrl: SW_WKUP
+  MmioWrite32 (0x4A008C00, 0x2); //cm_c2c_clkstctrl: SW_WKUP
+  MmioWrite32 (0x4A009000, 0x2); //cm_cam_clkstctrl: SW_WKUP
+  MmioWrite32 (0x4A008A00, 0x2); //cm_sdma_clkstctrl: SW_WKUP
+
+  MmioWrite32 (0x4A008E20, 0x1); //cm_l3instr_l3_3_clkctrl: AUTO
+  MmioWrite32 (0x4A008E28, 0x1); //cm_l3instr_l3_instr_clkctrl: AUTO
+  MmioWrite32 (0x4A008E40, 0x1); //cm_l3instr_intrconn_wp1_clkctrl: AUTO
+  MmioWrite32 (0x4A009338, 0x1); //cm_l3init_hsi_clkctrl: AUTO
+  
+  ClockModuleEnable (0x4A004528, 0x2); //cm1_abe_aess_clkctrl: ENABLE
+  
+  // TODO: pdm needs clock enabled externally to make it functional
+  MmioWrite32 (0x4A004530, 0x2); //cm1_abe_pdm_clkctrl: ENABLE
+
+  ClockModuleEnable (0x4A004538, 0x2); //cm1_abe_dmic_clkctrl: ENABLE
+  ClockModuleEnable (0x4A004540, 0x2); //cm1_abe_mcasp_clkctrl: ENABLE
+  ClockModuleEnable (0x4A004548, 0x2); //cm1_abe_mcbsp1_clkctrl: ENABLE
+  ClockModuleEnable (0x4A004550, 0x2); //cm1_abe_mcbsp2_clkctrl: ENABLE
+  ClockModuleEnable (0x4A004558, 0x2); //cm1_abe_mcbsp3_clkctrl: ENABLE
+  ClockModuleEnable (0x4A004560, 0x2); //cm1_abe_slimbus_clkctrl: ENABLE
+  ClockModuleEnable (0x4A004568, 0x2); //cm1_abe_timer5_clkctrl: ENABLE
+  ClockModuleEnable (0x4A004570, 0x2); //cm1_abe_timer6_clkctrl: ENABLE
+  ClockModuleEnable (0x4A004578, 0x2); //cm1_abe_timer7_clkctrl: ENABLE
+  ClockModuleEnable (0x4A004580, 0x2); //cm1_abe_timer8_clkctrl: ENABLE
+  ClockModuleEnable (0x4A004588, 0x2); //cm1_abe_wdt3_clkctrl: ENABLE
+  ClockModuleEnable (0x4A009450, 0x2); //cm_l4per_gptimer9_clkctrl: ENABLE
+  ClockModuleEnable (0x4A009428, 0x2); //cm_l4per_gptimer10_clkctrl: ENABLE
+  ClockModuleEnable (0x4A009430, 0x2); //cm_l4per_gptimer11_clkctrl: ENABLE
+  ClockModuleEnable (0x4A009440, 0x2); //cm_l4per_gptimer3_clkctrl: ENABLE
+  ClockModuleEnable (0x4A009448, 0x2); //cm_l4per_gptimer4_clkctrl: ENABLE
+  ClockModuleEnable (0x4A009488, 0x2); //cm_l4per_hdq1w_clkctrl: ENABLE
+  ClockModuleEnable (0x4A0094E0, 0x2); //cm_l4per_mcbsp4_clkctrl: ENABLE
+  ClockModuleEnable (0x4A0094F8, 0x2); //cm_l4per_mcspi2_clkctrl: ENABLE
+  ClockModuleEnable (0x4A009500, 0x2); //cm_l4per_mcspi3_clkctrl: ENABLE
+  ClockModuleEnable (0x4A009508, 0x2); //cm_l4per_mcspi4_clkctrl: ENABLE
+  ClockModuleEnable (0x4A009520, 0x2); //cm_l4per_mmcsd3_clkctrl: ENABLE
+  ClockModuleEnable (0x4A009528, 0x2); //cm_l4per_mmcsd4_clkctrl: ENABLE
+  ClockModuleEnable (0x4A009560, 0x2); //cm_l4per_mmcsd5_clkctrl: ENABLE
+  ClockModuleEnable (0x4A009540, 0x2); //cm_l4per_uart1_clkctrl: ENABLE
+  ClockModuleEnable (0x4A009548, 0x2); //cm_l4per_uart2_clkctrl: ENABLE
+  ClockModuleEnable (0x4A009558, 0x2); //cm_l4per_uart4_clkctrl: ENABLE
+  ClockModuleEnable (0x4A009438, 0x2); //gptimer2: ENABLE
+  ClockModuleEnable (0x4A009460, 0x1); //gpio2: AUTO
+  ClockModuleEnable (0x4A009468, 0x1); //gpio3: AUTO
+  ClockModuleEnable (0x4A009470, 0x101); //gpio4: AUTO+FCLK
+  ClockModuleEnable (0x4A009478, 0x1); //gpio5: AUTO
+  ClockModuleEnable (0x4A009480, 0x1); //gpio6: AUTO
+  ClockModuleEnable (0x4A0094A8, 0x2); //i2c2: ENABLE
+  ClockModuleEnable (0x4A0094B0, 0x2); //i2c3: ENABLE
+  ClockModuleEnable (0x4A0094B8, 0x2); //i2c4: ENABLE
+  ClockModuleEnable (0x4A0094F0, 0x2); //mcspi1: ENABLE
+  ClockModuleEnable (0x4A307878, 0x2); //cm_wkup_keyboard_clkctrl: ENABLE
+  ClockModuleEnable (0x4A009020, 0x2); //cm_cam_iss_clkctrl: ENABLE
+  ClockModuleEnable (0x4A009028, 0x2); //cm_cam_fdif_clkctrl: ENABLE
+  ClockModuleEnable (0x4A009120, 0x2); //cm_dss_dss_clkctrl: ENABLE
+  ClockModuleEnable (0x4A009220, 0x2); //cm_sgx_sgx_clkctrl: ENABLE
+  ClockModuleEnable (0x4A009328, 0x1040002); //mmchs1: ENABLE
+  ClockModuleEnable (0x4A009330, 0x1040002); //mmchs2: ENABLE
+  ClockModuleEnable (0x4A009358, 0xFF02); //cm_l3init_hsusbhost_clkctrl: ENABLE
+  ClockModuleEnable (0x4A009368, 0x1); //usbtll: AUTO
+
+  MmioWrite32 (0x4A008900, 0x3); //cm_mpu_m3_clkstctrl: HW_AUTO
+  MmioWrite32 (0x4A008F00, 0x3); //cm_ivahd_clkstctrl: HW_AUTO
+  MmioWrite32 (0x4A004400, 0x3); //cm_dsp_clkstctrl: HW_AUTO
+  MmioWrite32 (0x4A009100, 0x3); //cm_dss_clkstctrl: HW_AUTO
+  MmioWrite32 (0x4A009200, 0x3); //cm_sgx_clkstctrl: HW_AUTO
+  MmioWrite32 (0x4A004500, 0x3); //cm1_abe_clkstctrl: HW_AUTO
+  MmioWrite32 (0x4A008C00, 0x3); //cm_c2c_clkstctrl: HW_AUTO
+  MmioWrite32 (0x4A008A00, 0x3); //cm_sdma_clkstctrl: HW_AUTO
+  MmioWrite32 (0x4A009400, 0x3); //l4per: HW_AUTO
+  MmioWrite32 (0x4A009300, 0x3); //l3init: HW_AUTO
+  MmioWrite32 (0x4A008B00, 0x3); //memif: HW_AUTO
+  MmioWrite32 (0x4A008D00, 0x3); //l4cfg: HW_AUTO
+  MmioWrite32 (0x4A009000, 0x0); //cm_cam_clkstctrl: NO_SLEEP
 }
diff --git a/PandaBoardPkg/Library/PandaBoardLib/PadConfiguration.c b/PandaBoardPkg/Library/PandaBoardLib/PadConfiguration.c
index c22b8065..41dae5b4 100755
--- a/PandaBoardPkg/Library/PandaBoardLib/PadConfiguration.c
+++ b/PandaBoardPkg/Library/PandaBoardLib/PadConfiguration.c
@@ -18,305 +18,326 @@
 #include <Omap4430/Omap4430.h>
 #include <PandaBoard.h>
 
-#define NUM_PINS_SHARED 232
-#define NUM_PINS_ABC 6
-#define NUM_PINS_XM 12
+PAD_CONFIGURATION PadConfigurationTableSharedCore[] = {
+    {GPMC_AD0, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M1)}, /* sdmmc2_dat0 */
+    {GPMC_AD1, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M1)}, /* sdmmc2_dat1 */
+    {GPMC_AD2, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M1)}, /* sdmmc2_dat2 */
+    {GPMC_AD3, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M1)}, /* sdmmc2_dat3 */
+    {GPMC_AD4, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M1)}, /* sdmmc2_dat4 */
+    {GPMC_AD5, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M1)}, /* sdmmc2_dat5 */
+    {GPMC_AD6, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M1)}, /* sdmmc2_dat6 */
+    {GPMC_AD7, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M1)}, /* sdmmc2_dat7 */
+    {GPMC_NOE, (PTU | IEN | OFF_EN | OFF_OUT_PTD | M1)},	 /* sdmmc2_clk */
+    {GPMC_NWE, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M1)}, /* sdmmc2_cmd */
+    {SDMMC1_CLK, (PTU | OFF_EN | OFF_OUT_PTD | M0)},	 /* sdmmc1_clk */
+    {SDMMC1_CMD, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M0)}, /* sdmmc1_cmd */
+    {SDMMC1_DAT0, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M0)}, /* sdmmc1_dat0 */
+    {SDMMC1_DAT1, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M0)}, /* sdmmc1_dat1 */
+    {SDMMC1_DAT2, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M0)}, /* sdmmc1_dat2 */
+    {SDMMC1_DAT3, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M0)}, /* sdmmc1_dat3 */
+    {SDMMC1_DAT4, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M0)}, /* sdmmc1_dat4 */
+    {SDMMC1_DAT5, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M0)}, /* sdmmc1_dat5 */
+    {SDMMC1_DAT6, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M0)}, /* sdmmc1_dat6 */
+    {SDMMC1_DAT7, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M0)}, /* sdmmc1_dat7 */
+    {I2C1_SCL, (PTU | IEN | M0)},				/* i2c1_scl */
+    {I2C1_SDA, (PTU | IEN | M0)},				/* i2c1_sda */
+    {I2C2_SCL, (PTU | IEN | M0)},				/* i2c2_scl */
+    {I2C2_SDA, (PTU | IEN | M0)},				/* i2c2_sda */
+    {I2C3_SCL, (PTU | IEN | M0)},				/* i2c3_scl */
+    {I2C3_SDA, (PTU | IEN | M0)},				/* i2c3_sda */
+    {I2C4_SCL, (PTU | IEN | M0)},				/* i2c4_scl */
+    {I2C4_SDA, (PTU | IEN | M0)},				/* i2c4_sda */
+    {UART3_CTS_RCTX, (PTU | IEN | M0)},			/* uart3_tx */
+    {UART3_RTS_SD, (M0)},					/* uart3_rts_sd */
+    {UART3_RX_IRRX, (IEN | M0)},				/* uart3_rx */
+    {UART3_TX_IRTX, (M0)},					/* uart3_tx */
+    {USBB1_ULPITLL_CLK, (PTD | IEN | OFF_EN | OFF_PD | OFF_IN | M4)},/* usbb1_ulpiphy_clk */
+    {USBB1_ULPITLL_STP, (OFF_EN | OFF_OUT_PTD | M4)},		/* usbb1_ulpiphy_stp */
+    {USBB1_ULPITLL_DIR, (IEN | OFF_EN | OFF_PD | OFF_IN | M4)},	/* usbb1_ulpiphy_dir */
+    {USBB1_ULPITLL_NXT, (IEN | OFF_EN | OFF_PD | OFF_IN | M4)},	/* usbb1_ulpiphy_nxt */
+    {USBB1_ULPITLL_DAT0, (IEN | OFF_EN | OFF_PD | OFF_IN | M4)},	/* usbb1_ulpiphy_dat0 */
+    {USBB1_ULPITLL_DAT1, (IEN | OFF_EN | OFF_PD | OFF_IN | M4)},	/* usbb1_ulpiphy_dat1 */
+    {USBB1_ULPITLL_DAT2, (IEN | OFF_EN | OFF_PD | OFF_IN | M4)},	/* usbb1_ulpiphy_dat2 */
+    {USBB1_ULPITLL_DAT3, (IEN | OFF_EN | OFF_PD | OFF_IN | M4)},	/* usbb1_ulpiphy_dat3 */
+    {USBB1_ULPITLL_DAT4, (IEN | OFF_EN | OFF_PD | OFF_IN | M4)},	/* usbb1_ulpiphy_dat4 */
+    {USBB1_ULPITLL_DAT5, (IEN | OFF_EN | OFF_PD | OFF_IN | M4)},	/* usbb1_ulpiphy_dat5 */
+    {USBB1_ULPITLL_DAT6, (IEN | OFF_EN | OFF_PD | OFF_IN | M4)},	/* usbb1_ulpiphy_dat6 */
+    {USBB1_ULPITLL_DAT7, (IEN | OFF_EN | OFF_PD | OFF_IN | M4)},	/* usbb1_ulpiphy_dat7 */
+    {USBB1_HSIC_DATA, (IEN | OFF_EN | OFF_PD | OFF_IN | M0)},	/* usbb1_hsic_data */
+    {USBB1_HSIC_STROBE, (IEN | OFF_EN | OFF_PD | OFF_IN | M0)},	/* usbb1_hsic_strobe */
+    {USBC1_ICUSB_DP, (IEN | M0)},					/* usbc1_icusb_dp */
+    {USBC1_ICUSB_DM, (IEN | M0)},					/* usbc1_icusb_dm */
+    {UNIPRO_TY2, (PTU | IEN | M3)},					/* gpio_1 */
+    {GPMC_WAIT1,  (PTD | OFF_EN | OFF_PD | OFF_OUT_PTD | M3)},	/* gpio_62 */
+    {FREF_CLK2_OUT, (PTU | IEN | M3)},				/* gpio_182: BOARD_ID0 */
+	{GPMC_AD8, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M3)},	/* gpio_32 */
+	{GPMC_AD9, (PTU | IEN | M3)},					/* gpio_33 */
+	{GPMC_AD10, (PTU | IEN | M3)},					/* gpio_34 */
+	{GPMC_AD11, (PTU | IEN | M3)},					/* gpio_35 */
+	{GPMC_AD12, (PTU | IEN | M3)},					/* gpio_36 */
+	{GPMC_AD13, (PTD | OFF_EN | OFF_PD | OFF_OUT_PTD | M3)},	/* gpio_37 */
+	{GPMC_AD14, (PTD | OFF_EN | OFF_PD | OFF_OUT_PTD | M3)},	/* gpio_38 */
+	{GPMC_AD15, (PTD | OFF_EN | OFF_PD | OFF_OUT_PTD | M3)},	/* gpio_39 */
+	{GPMC_A16, (M3)},						/* gpio_40 */
+	{GPMC_A17, (PTD | M3)},						/* gpio_41 */
+	{GPMC_A18, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M1)},	/* kpd_row6 */
+	{GPMC_A19, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M1)},	/* kpd_row7 */
+	{GPMC_A20, (IEN | M3)},						/* gpio_44 */
+	{GPMC_A21, (M3)},						/* gpio_45 */
+	{GPMC_A22, (M3)},						/* gpio_46 */
+	{GPMC_A23, (OFF_EN | OFF_PD | OFF_IN | M1)},			/* kpd_col7 */
+	{GPMC_A24, (PTD | M3)},						/* gpio_48: BOARD_ID1 (Panda ES only) */
+	{GPMC_A25, (PTD | M3)},						/* gpio_49 */
+	{GPMC_NCS0, (M3)},						/* gpio_50 */
+	{GPMC_NCS1, (IEN | M3)},					/* gpio_51 */
+	{GPMC_NCS2, (IEN | M3)},					/* gpio_52 */
+	{GPMC_NCS3, (IEN | M3)},					/* gpio_53 */
+	{GPMC_NWP, (M3)},						/* gpio_54 */
+	{GPMC_CLK, (PTD | M3)},						/* gpio_55 */
+	{GPMC_NADV_ALE, (M3)},						/* gpio_56 */
+	{GPMC_NBE0_CLE, (M3)},						/* gpio_59 */
+	{GPMC_NBE1, (PTD | M3)},					/* gpio_60 */
+	{GPMC_WAIT0, (PTU | IEN | M3)},					/* gpio_61 */
+	{C2C_DATA11, (PTD | M3)},					/* gpio_100 */
+	{C2C_DATA12, (PTU | IEN | M3)},					/* gpio_101: BOARD_ID1 (Panda only) */
+	{C2C_DATA13, (PTD | M3)},					/* gpio_102 */
+	{C2C_DATA14, (M1)},						/* dsi2_te0 */
+	{C2C_DATA15, (PTD | M3)},					/* gpio_104 */
+	{HDMI_HPD, (M0)},						/* hdmi_hpd */
+	{HDMI_CEC, (M0)},						/* hdmi_cec */
+	{HDMI_DDC_SCL, (PTU | M0)},					/* hdmi_ddc_scl */
+	{HDMI_DDC_SDA, (PTU | IEN | M0)},				/* hdmi_ddc_sda */
+	{CSI21_DX0, (IEN | M0)},					/* csi21_dx0 */
+	{CSI21_DY0, (IEN | M0)},					/* csi21_dy0 */
+	{CSI21_DX1, (IEN | M0)},					/* csi21_dx1 */
+	{CSI21_DY1, (IEN | M0)},					/* csi21_dy1 */
+	{CSI21_DX2, (IEN | M0)},					/* csi21_dx2 */
+	{CSI21_DY2, (IEN | M0)},					/* csi21_dy2 */
+	{CSI21_DX3, (PTD | M7)},					/* csi21_dx3 */
+	{CSI21_DY3, (PTD | M7)},					/* csi21_dy3 */
+	{CSI21_DX4, (PTD | OFF_EN | OFF_PD | OFF_IN | M7)},		/* csi21_dx4 */
+	{CSI21_DY4, (PTD | OFF_EN | OFF_PD | OFF_IN | M7)},		/* csi21_dy4 */
+	{CSI22_DX0, (IEN | M0)},					/* csi22_dx0 */
+	{CSI22_DY0, (IEN | M0)},					/* csi22_dy0 */
+	{CSI22_DX1, (IEN | M0)},					/* csi22_dx1 */
+	{CSI22_DY1, (IEN | M0)},					/* csi22_dy1 */
+	{CAM_SHUTTER, (OFF_EN | OFF_PD | OFF_OUT_PTD | M0)},		/* cam_shutter */
+	{CAM_STROBE, (OFF_EN | OFF_PD | OFF_OUT_PTD | M0)},		/* cam_strobe */
+	{CAM_GLOBALRESET, (PTD | OFF_EN | OFF_PD | OFF_OUT_PTD | M3)},	/* gpio_83 */
+	{ABE_MCBSP2_DR, (IEN | OFF_EN | OFF_OUT_PTD | M0)},		/* abe_mcbsp2_dr */
+	{ABE_MCBSP2_DX, (OFF_EN | OFF_OUT_PTD | M0)},			/* abe_mcbsp2_dx */
+	{ABE_MCBSP2_FSX, (IEN | OFF_EN | OFF_PD | OFF_IN | M0)},	/* abe_mcbsp2_fsx */
+	{ABE_MCBSP1_CLKX, (IEN | M0)},					/* abe_mcbsp1_clkx */
+	{ABE_MCBSP1_DR, (IEN | M0)},					/* abe_mcbsp1_dr */
+	{ABE_MCBSP1_DX, (OFF_EN | OFF_OUT_PTD | M0)},			/* abe_mcbsp1_dx */
+	{ABE_MCBSP1_FSX, (IEN | OFF_EN | OFF_PD | OFF_IN | M0)},	/* abe_mcbsp1_fsx */
+	{ABE_PDM_UL_DATA, (PTD | IEN | OFF_EN | OFF_PD | OFF_IN | M0)},	/* abe_pdm_ul_data */
+	{ABE_PDM_DL_DATA, (PTD | IEN | OFF_EN | OFF_PD | OFF_IN | M0)},	/* abe_pdm_dl_data */
+	{ABE_PDM_FRAME, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M0)},	/* abe_pdm_frame */
+	{ABE_PDM_LB_CLK, (PTD | IEN | OFF_EN | OFF_PD | OFF_IN | M0)},	/* abe_pdm_lb_clk */
+	{ABE_CLKS, (PTD | IEN | OFF_EN | OFF_PD | OFF_IN | M0)},	/* abe_clks */
+	{ABE_DMIC_CLK1, (M0)},						/* abe_dmic_clk1 */
+	{ABE_DMIC_DIN1, (IEN | M0)},					/* abe_dmic_din1 */
+	{ABE_DMIC_DIN2, (PTU | IEN | M3)},				/* gpio_121 */
+	{ABE_DMIC_DIN3, (IEN | M0)},					/* abe_dmic_din3 */
+	{UART2_CTS, (PTU | IEN | M7)},					/* uart2_cts */
+	{UART2_RTS, (M7)},						/* uart2_rts */
+	{UART2_RX, (PTU | IEN | M7)},					/* uart2_rx */
+	{UART2_TX, (M7)},						/* uart2_tx */
+	{HDQ_SIO, (M3)},						/* gpio_127 */
+	{MCSPI1_CLK, (IEN | OFF_EN | OFF_PD | OFF_IN | M0)},		/* mcspi1_clk */
+	{MCSPI1_SOMI, (IEN | OFF_EN | OFF_PD | OFF_IN | M0)},		/* mcspi1_somi */
+	{MCSPI1_SIMO, (IEN | OFF_EN | OFF_PD | OFF_IN | M0)},		/* mcspi1_simo */
+	{MCSPI1_CS0, (PTD | IEN | OFF_EN | OFF_PD | OFF_IN | M0)},	/* mcspi1_cs0 */
+	{MCSPI1_CS1, (PTD | IEN | OFF_EN | OFF_PD | OFF_IN | M3)},	/* mcspi1_cs1 */
+	{MCSPI1_CS2, (PTU | OFF_EN | OFF_OUT_PTU | M3)},		/* gpio_139 */
+	{MCSPI1_CS3, (PTU | IEN | M3)},					/* gpio_140 */
+	{SDMMC5_CLK, (PTU | IEN | OFF_EN | OFF_OUT_PTD | M0)},		/* sdmmc5_clk */
+	{SDMMC5_CMD, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M0)},	/* sdmmc5_cmd */
+	{SDMMC5_DAT0, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M0)},	/* sdmmc5_dat0 */
+	{SDMMC5_DAT1, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M0)},	/* sdmmc5_dat1 */
+	{SDMMC5_DAT2, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M0)},	/* sdmmc5_dat2 */
+	{SDMMC5_DAT3, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M0)},	/* sdmmc5_dat3 */
+	{MCSPI4_CLK, (IEN | OFF_EN | OFF_PD | OFF_IN | M0)},		/* mcspi4_clk */
+	{MCSPI4_SIMO, (IEN | OFF_EN | OFF_PD | OFF_IN | M0)},		/* mcspi4_simo */
+	{MCSPI4_SOMI, (IEN | OFF_EN | OFF_PD | OFF_IN | M0)},		/* mcspi4_somi */
+	{MCSPI4_CS0, (PTD | IEN | OFF_EN | OFF_PD | OFF_IN | M0)},	/* mcspi4_cs0 */
+	{UART4_RX, (IEN | M0)},						/* uart4_rx */
+	{UART4_TX, (M0)},						/* uart4_tx */
+	{USBB2_ULPITLL_CLK, (IEN | M3)},				/* gpio_157 */
+	{USBB2_ULPITLL_STP, (IEN | M5)},				/* dispc2_data23 */
+	{USBB2_ULPITLL_DIR, (IEN | M5)},				/* dispc2_data22 */
+	{USBB2_ULPITLL_NXT, (IEN | M5)},				/* dispc2_data21 */
+	{USBB2_ULPITLL_DAT0, (IEN | M5)},				/* dispc2_data20 */
+	{USBB2_ULPITLL_DAT1, (IEN | M5)},				/* dispc2_data19 */
+	{USBB2_ULPITLL_DAT2, (IEN | M5)},				/* dispc2_data18 */
+	{USBB2_ULPITLL_DAT3, (IEN | M5)},				/* dispc2_data15 */
+	{USBB2_ULPITLL_DAT4, (IEN | M5)},				/* dispc2_data14 */
+	{USBB2_ULPITLL_DAT5, (IEN | M5)},				/* dispc2_data13 */
+	{USBB2_ULPITLL_DAT6, (IEN | M5)},				/* dispc2_data12 */
+	{USBB2_ULPITLL_DAT7, (IEN | M5)},				/* dispc2_data11 */
+	{USBB2_HSIC_DATA, (PTD | OFF_EN | OFF_OUT_PTU | M3)},		/* gpio_169 */
+	{USBB2_HSIC_STROBE, (PTD | OFF_EN | OFF_OUT_PTU | M3)},		/* gpio_170 */
+	{UNIPRO_TX0, (PTD | IEN | M3)},					/* gpio_171 */
+	{UNIPRO_TY0, (OFF_EN | OFF_PD | OFF_IN | M1)},			/* kpd_col1 */
+	{UNIPRO_TX1, (OFF_EN | OFF_PD | OFF_IN | M1)},			/* kpd_col2 */
+	{UNIPRO_TY1, (OFF_EN | OFF_PD | OFF_IN | M1)},			/* kpd_col3: BOARD_ID2 (gpio_171) */
+	{UNIPRO_TX2, (PTU | IEN | M3)},					/* gpio_0 */
+	{UNIPRO_RX0, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M1)},	/* kpd_row0 */
+	{UNIPRO_RY0, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M3 | DIS)}, /* kpd_row1: BOARD_ID4 (gpio_2) */
+	{UNIPRO_RX1, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M3 | DIS)}, /* kpd_row2: BOARD_ID3 (gpio_3) */
+	{UNIPRO_RY1, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M1)},	/* kpd_row3 */
+	{UNIPRO_RX2, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M1)},	/* kpd_row4 */
+	{UNIPRO_RY2, (PTU | IEN | OFF_EN | OFF_PD | OFF_IN | M1)},	/* kpd_row5 */
+	{USBA0_OTG_CE, (PTD | OFF_EN | OFF_PD | OFF_OUT_PTD | M0)},	/* usba0_otg_ce */
+	{USBA0_OTG_DP, (IEN | OFF_EN | OFF_PD | OFF_IN | M0)},		/* usba0_otg_dp */
+	{USBA0_OTG_DM, (IEN | OFF_EN | OFF_PD | OFF_IN | M0)},		/* usba0_otg_dm */
+	{FREF_CLK1_OUT, (M0)},						/* fref_clk1_out */
+	{SYS_NIRQ1, (PTU | IEN | M0)},					/* sys_nirq1 */
+	{SYS_NIRQ2, (PTU | IEN | M0)},					/* sys_nirq2 */
+	{SYS_BOOT0, (PTU | IEN | M3)},					/* gpio_184 */
+	{SYS_BOOT1, (M3)},						/* gpio_185 */
+	{SYS_BOOT2, (PTD | IEN | M3)},					/* gpio_186 */
+	{SYS_BOOT3, (M3)},						/* gpio_187 */
+	{SYS_BOOT4, (M3)},						/* gpio_188 */
+	{SYS_BOOT5, (PTD | IEN | M3)},					/* gpio_189 */
+	{DPM_EMU0, (IEN | M0)},						/* dpm_emu0 */
+	{DPM_EMU1, (IEN | M0)},						/* dpm_emu1 */
+	{DPM_EMU2, (IEN | M0)},						/* dpm_emu2 */
+	{DPM_EMU3, (IEN | M5)},						/* dispc2_data10 */
+	{DPM_EMU4, (IEN | M5)},						/* dispc2_data9 */
+	{DPM_EMU5, (IEN | M5)},						/* dispc2_data16 */
+	{DPM_EMU6, (IEN | M5)},						/* dispc2_data17 */
+	{DPM_EMU7, (IEN | M5)},						/* dispc2_hsync */
+	{DPM_EMU8, (IEN | M5)},						/* dispc2_pclk */
+	{DPM_EMU9, (IEN | M5)},						/* dispc2_vsync */
+	{DPM_EMU10, (IEN | M5)},					/* dispc2_de */
+	{DPM_EMU11, (IEN | M5)},					/* dispc2_data8 */
+	{DPM_EMU12, (IEN | M5)},					/* dispc2_data7 */
+	{DPM_EMU13, (IEN | M5)},					/* dispc2_data6 */
+	{DPM_EMU14, (IEN | M5)},					/* dispc2_data5 */
+	{DPM_EMU15, (IEN | M5)},					/* dispc2_data4 */
+	{DPM_EMU16, (M3)},						/* gpio_27 */
+	{DPM_EMU17, (IEN | M5)},					/* dispc2_data2 */
+	{DPM_EMU18, (IEN | M5)},					/* dispc2_data1 */
+	{DPM_EMU19, (IEN | M5)},					/* dispc2_data0 */
+};
+
+PAD_CONFIGURATION PadConfigurationTableSharedWkup[] = {
+    {PAD1_SR_SCL, (PTU | IEN | M0)}, /* sr_scl */
+    {PAD0_SR_SDA, (PTU | IEN | M0)}, /* sr_sda */
+    {PAD1_SYS_32K, (IEN | M0)},	 /* sys_32k */
+    {PAD0_FREF_CLK3_OUT, (M0)}, /* fref_clk3_out */
+	{PAD0_SIM_IO, (IEN | M0)},		/* sim_io */
+	{PAD1_SIM_CLK, (M0)},			/* sim_clk */
+	{PAD0_SIM_RESET, (M0)},			/* sim_reset */
+	{PAD1_SIM_CD, (PTU | IEN | M0)},	/* sim_cd */
+	{PAD0_SIM_PWRCTRL, (M0)},		/* sim_pwrctrl */
+	{PAD1_FREF_XTAL_IN, (M0)},		/* # */
+	{PAD0_FREF_SLICER_IN, (M0)},		/* fref_slicer_in */
+	{PAD1_FREF_CLK_IOREQ, (M0)},		/* fref_clk_ioreq */
+	{PAD0_FREF_CLK0_OUT, (M2)},		/* sys_drm_msecure */
+	{PAD1_FREF_CLK3_REQ, M7},		/* safe mode */
+	{PAD0_FREF_CLK4_OUT, (PTU | M3)},	/* led status_2 */
+	{PAD0_SYS_NRESPWRON, (M0)},		/* sys_nrespwron */
+	{PAD1_SYS_NRESWARM, (M0)},		/* sys_nreswarm */
+	{PAD0_SYS_PWR_REQ, (PTU | M0)},		/* sys_pwr_req */
+	{PAD1_SYS_PWRON_RESET, (M3)},		/* gpio_wk29 */
+	{PAD0_SYS_BOOT6, (IEN | M3)},		/* gpio_wk9 */
+	{PAD1_SYS_BOOT7, (IEN | M3)},		/* gpio_wk10 */
+};
 
-PAD_CONFIGURATION PadConfigurationTableShared[] = {
-  //Pin,           MuxMode,    PullConfig,                      InputEnable
-  { SDRC_D0,       MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D1,       MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D2,       MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D3,       MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D4,       MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D5,       MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D6,       MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D7,       MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D8,       MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D9,       MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D10,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D11,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D12,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D13,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D14,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D15,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D16,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D17,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D18,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D19,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D20,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D21,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D22,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D23,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D24,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D25,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D26,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D27,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D28,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D29,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D30,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_D31,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_CLK,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_DQS0,     MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_CKE0,     MUXMODE0,   PULL_UP_SELECTED,             INPUT  },
-  { SDRC_CKE1,     MUXMODE7,   PULL_DISABLED,                INPUT  },
-  { SDRC_DQS1,     MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_DQS2,     MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { SDRC_DQS3,     MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { GPMC_A1,       MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { GPMC_A2,       MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { GPMC_A3,       MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { GPMC_A4,       MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { GPMC_A5,       MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { GPMC_A6,       MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { GPMC_A7,       MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { GPMC_A8,       MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { GPMC_A9,       MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { GPMC_A10,      MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { GPMC_D0,       MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { GPMC_D1,       MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { GPMC_D2,       MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { GPMC_D3,       MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { GPMC_D4,       MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { GPMC_D5,       MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { GPMC_D6,       MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { GPMC_D7,       MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { GPMC_D8,       MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { GPMC_D9,       MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { GPMC_D10,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { GPMC_D11,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { GPMC_D12,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { GPMC_D13,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { GPMC_D14,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { GPMC_D15,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { GPMC_NCS0,     MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { GPMC_NCS1,     MUXMODE0,   PULL_UP_SELECTED,             OUTPUT },
-  { GPMC_NCS2,     MUXMODE0,   PULL_UP_SELECTED,             OUTPUT },
-  { GPMC_NCS3,     MUXMODE0,   PULL_UP_SELECTED,             OUTPUT },
-  { GPMC_NCS4,     MUXMODE0,   PULL_UP_SELECTED,             OUTPUT },
-  { GPMC_NCS5,     MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { GPMC_NCS6,     MUXMODE1,   PULL_DISABLED,                INPUT  },
-  { GPMC_NCS7,     MUXMODE1,   PULL_UP_SELECTED,             INPUT  },
-  { GPMC_CLK,      MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { GPMC_NADV_ALE, MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { GPMC_NOE,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { GPMC_NWE,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { GPMC_NBE0_CLE, MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { GPMC_NBE1,     MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { GPMC_NWP,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { GPMC_WAIT0,    MUXMODE0,   PULL_UP_SELECTED,             INPUT  },
-  { GPMC_WAIT1,    MUXMODE0,   PULL_UP_SELECTED,             INPUT  },
-  { GPMC_WAIT2,    MUXMODE0,   PULL_UP_SELECTED,             INPUT  },
-  { GPMC_WAIT3,    MUXMODE0,   PULL_UP_SELECTED,             INPUT  },
-  { DSS_PCLK,      MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { DSS_HSYNC,     MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { DSS_PSYNC,     MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { DSS_ACBIAS,    MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA0,     MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA1,     MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA2,     MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA3,     MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA4,     MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA5,     MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA6,     MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA7,     MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA8,     MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA9,     MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA10,    MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA11,    MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA12,    MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA13,    MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA14,    MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA15,    MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA16,    MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA17,    MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { CAM_HS,        MUXMODE0,   PULL_UP_SELECTED,             INPUT },
-  { CAM_VS,        MUXMODE0,   PULL_UP_SELECTED,             INPUT },
-  { CAM_XCLKA,     MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { CAM_PCLK,      MUXMODE0,   PULL_UP_SELECTED,             INPUT },
-  { CAM_FLD,       MUXMODE4,   PULL_DISABLED,                OUTPUT },
-  { CAM_D0,        MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { CAM_D1,        MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { CAM_D2,        MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { CAM_D3,        MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { CAM_D4,        MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { CAM_D5,        MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { CAM_D6,        MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { CAM_D7,        MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { CAM_D8,        MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { CAM_D9,        MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { CAM_D10,       MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { CAM_D11,       MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { CAM_XCLKB,     MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { CAM_WEN,       MUXMODE4,   PULL_DISABLED,                INPUT  },
-  { CAM_STROBE,    MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { CSI2_DX0,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { CSI2_DY0,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { CSI2_DX1,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { CSI2_DY1,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { MCBSP2_FSX,    MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { MCBSP2_CLKX,   MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { MCBSP2_DR,     MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { MCBSP2_DX,     MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { MMC1_CLK,      MUXMODE0,   PULL_UP_SELECTED,             OUTPUT },
-  { MMC1_CMD,      MUXMODE0,   PULL_UP_SELECTED,             INPUT  },
-  { MMC1_DAT0,     MUXMODE0,   PULL_UP_SELECTED,             INPUT  },
-  { MMC1_DAT1,     MUXMODE0,   PULL_UP_SELECTED,             INPUT  },
-  { MMC1_DAT2,     MUXMODE0,   PULL_UP_SELECTED,             INPUT  },
-  { MMC1_DAT3,     MUXMODE0,   PULL_UP_SELECTED,             INPUT  },
-  { MMC1_DAT4,     MUXMODE0,   PULL_UP_SELECTED,             INPUT  },
-  { MMC1_DAT5,     MUXMODE0,   PULL_UP_SELECTED,             INPUT  },
-  { MMC1_DAT6,     MUXMODE0,   PULL_UP_SELECTED,             INPUT  },
-  { MMC1_DAT7,     MUXMODE0,   PULL_UP_SELECTED,             INPUT  },
-  { MMC2_CLK,      MUXMODE4,   PULL_UP_SELECTED,             INPUT  },
-  { MMC2_CMD,      MUXMODE4,   PULL_UP_SELECTED,             INPUT  },
-  { MMC2_DAT0,     MUXMODE4,   PULL_UP_SELECTED,             INPUT  },
-  { MMC2_DAT1,     MUXMODE4,   PULL_UP_SELECTED,             INPUT  },
-  { MMC2_DAT2,     MUXMODE4,   PULL_UP_SELECTED,             INPUT  },
-  { MMC2_DAT3,     MUXMODE4,   PULL_UP_SELECTED,             INPUT  },
-  { MMC2_DAT4,     MUXMODE4,   PULL_UP_SELECTED,             INPUT  },
-  { MMC2_DAT5,     MUXMODE4,   PULL_UP_SELECTED,             INPUT  },
-  { MMC2_DAT6,     MUXMODE4,   PULL_UP_SELECTED,             INPUT  },
-  { MMC2_DAT7,     MUXMODE4,   PULL_UP_SELECTED,             INPUT  },
-  { MCBSP3_DX,     MUXMODE4,   PULL_DISABLED,                OUTPUT },
-  { MCBSP3_DR,     MUXMODE4,   PULL_DISABLED,                OUTPUT },
-  { MCBSP3_CLKX,   MUXMODE4,   PULL_DISABLED,                OUTPUT },
-  { MCBSP3_FSX,    MUXMODE4,   PULL_DISABLED,                OUTPUT },
-  { UART2_CTS,     MUXMODE0,   PULL_UP_SELECTED,             INPUT  },
-  { UART2_RTS,     MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { UART2_TX,      MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { UART2_RX,      MUXMODE4,   PULL_DISABLED,                OUTPUT },
-  { UART1_TX,      MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { UART1_RTS,     MUXMODE4,   PULL_DISABLED,                OUTPUT },
-  { UART1_CTS,     MUXMODE4,   PULL_DISABLED,                OUTPUT },
-  { UART1_RX,      MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { MCBSP4_CLKX,   MUXMODE1,   PULL_DISABLED,                INPUT  },
-  { MCBSP4_DR,     MUXMODE1,   PULL_DISABLED,                INPUT  },
-  { MCBSP4_DX,     MUXMODE1,   PULL_DISABLED,                INPUT  },
-  { MCBSP4_FSX,    MUXMODE1,   PULL_DISABLED,                INPUT  },
-  { MCBSP1_CLKR,   MUXMODE4,   PULL_DISABLED,                OUTPUT },
-  { MCBSP1_FSR,    MUXMODE4,   PULL_UP_SELECTED,             OUTPUT },
-  { MCBSP1_DX,     MUXMODE4,   PULL_DISABLED,                OUTPUT },
-  { MCBSP1_DR,     MUXMODE4,   PULL_DISABLED,                OUTPUT },
-  { MCBSP1_CLKS,   MUXMODE0,   PULL_UP_SELECTED,             INPUT  },
-  { MCBSP1_FSX,    MUXMODE4,   PULL_DISABLED,                OUTPUT },
-  { MCBSP1_CLKX,   MUXMODE4,   PULL_DISABLED,                OUTPUT },
-  { UART3_CTS_RCTX,MUXMODE0,   PULL_UP_SELECTED,                 INPUT  },
-  { UART3_RTS_SD,  MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { UART3_RX_IRRX, MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { UART3_TX_IRTX, MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { HSUSB0_CLK,    MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { HSUSB0_STP,    MUXMODE0,   PULL_UP_SELECTED,             OUTPUT },
-  { HSUSB0_DIR,    MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { HSUSB0_NXT,    MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { HSUSB0_DATA0,  MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { HSUSB0_DATA1,  MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { HSUSB0_DATA2,  MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { HSUSB0_DATA3,  MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { HSUSB0_DATA4,  MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { HSUSB0_DATA5,  MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { HSUSB0_DATA6,  MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { HSUSB0_DATA7,  MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { I2C1_SCL,      MUXMODE0,   PULL_UP_SELECTED,             INPUT  },
-  { I2C1_SDA,      MUXMODE0,   PULL_UP_SELECTED,             INPUT  },
-  { I2C2_SCL,      MUXMODE4,   PULL_UP_SELECTED,             INPUT  },
-  { I2C2_SDA,      MUXMODE4,   PULL_UP_SELECTED,             INPUT  },
-  { I2C3_SCL,      MUXMODE0,   PULL_UP_SELECTED,             INPUT  },
-  { I2C3_SDA,      MUXMODE0,   PULL_UP_SELECTED,             INPUT  },
-  { HDQ_SIO,       MUXMODE4,   PULL_DISABLED,                OUTPUT },
-  { MCSPI1_CLK,    MUXMODE4,   PULL_UP_SELECTED,             INPUT  },
-  { MCSPI1_SIMO,   MUXMODE4,   PULL_UP_SELECTED,             INPUT  },
-  { MCSPI1_SOMI,   MUXMODE0,   PULL_DISABLED,                INPUT  },
-  { MCSPI1_CS0,    MUXMODE0,   PULL_UP_SELECTED,                 INPUT  },
-  { MCSPI1_CS1,    MUXMODE0,   PULL_UP_SELECTED,                 OUTPUT },
-  { MCSPI1_CS2,    MUXMODE4,   PULL_DISABLED,                OUTPUT },
-  { MCSPI1_CS3,    MUXMODE3,   PULL_UP_SELECTED,             INPUT  },
-  { MCSPI2_CLK,    MUXMODE3,   PULL_UP_SELECTED,             INPUT  },
-  { MCSPI2_SIMO,   MUXMODE3,   PULL_UP_SELECTED,             INPUT  },
-  { MCSPI2_SOMI,   MUXMODE3,   PULL_UP_SELECTED,             INPUT  },
-  { MCSPI2_CS0,    MUXMODE3,   PULL_UP_SELECTED,             INPUT  },
-  { MCSPI2_CS1,    MUXMODE3,   PULL_UP_SELECTED,             INPUT  },
-  { SYS_NIRQ,      MUXMODE0,   PULL_UP_SELECTED,             INPUT  },
-  { SYS_CLKOUT2,   MUXMODE4,   PULL_UP_SELECTED,             INPUT  },
-  { ETK_CLK,       MUXMODE3,   PULL_UP_SELECTED,             OUTPUT },
-  { ETK_CTL,       MUXMODE3,   PULL_UP_SELECTED,             OUTPUT },
-  { ETK_D0,        MUXMODE3,   PULL_UP_SELECTED,             INPUT  },
-  { ETK_D1,        MUXMODE3,   PULL_UP_SELECTED,             INPUT  },
-  { ETK_D2,        MUXMODE3,   PULL_UP_SELECTED,             INPUT  },
-  { ETK_D3,        MUXMODE3,   PULL_UP_SELECTED,             INPUT  },
-  { ETK_D4,        MUXMODE3,   PULL_UP_SELECTED,             INPUT  },
-  { ETK_D5,        MUXMODE3,   PULL_UP_SELECTED,             INPUT  },
-  { ETK_D6,        MUXMODE3,   PULL_UP_SELECTED,             INPUT  },
-  { ETK_D7,        MUXMODE3,   PULL_UP_SELECTED,             INPUT  },
-  { ETK_D8,        MUXMODE3,   PULL_UP_SELECTED,             INPUT  },
-  { ETK_D9,        MUXMODE4,   PULL_UP_SELECTED,             INPUT  },
-  { ETK_D10,       MUXMODE3,   PULL_UP_SELECTED,             OUTPUT },
-  { ETK_D11,       MUXMODE3,   PULL_UP_SELECTED,             OUTPUT },
-  { ETK_D12,       MUXMODE3,   PULL_UP_SELECTED,             INPUT  },
-  { ETK_D13,       MUXMODE3,   PULL_UP_SELECTED,             INPUT  },
-  { ETK_D14,       MUXMODE3,   PULL_UP_SELECTED,             INPUT  },
-  { ETK_D15,       MUXMODE3,   PULL_UP_SELECTED,             INPUT  }
+PAD_CONFIGURATION PadConfigurationTable4430Core[] = {
+	{ABE_MCBSP2_CLKX, (IEN | OFF_EN | OFF_PD | OFF_IN | M0)},	/* abe_mcbsp2_clkx */
 };
 
-PAD_CONFIGURATION PadConfigurationTableAbc[] = {
-  { DSS_DATA18,    MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA19,    MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA20,    MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA21,    MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA22,    MUXMODE0,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA23,    MUXMODE0,   PULL_DISABLED,                OUTPUT }
+PAD_CONFIGURATION PadConfigurationTable4430Wkup[] = {
+	{PAD1_FREF_CLK4_REQ, (PTU | M3)},	/* led status_1 */
 };
 
-PAD_CONFIGURATION PadConfigurationTableXm[] = {
-  { DSS_DATA18,    MUXMODE3,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA19,    MUXMODE3,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA20,    MUXMODE3,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA21,    MUXMODE3,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA22,    MUXMODE3,   PULL_DISABLED,                OUTPUT },
-  { DSS_DATA23,    MUXMODE3,   PULL_DISABLED,                OUTPUT },
-  { SYS_BOOT0,     MUXMODE3,   PULL_DISABLED,                OUTPUT },
-  { SYS_BOOT1,     MUXMODE3,   PULL_DISABLED,                OUTPUT },
-  { SYS_BOOT3,     MUXMODE3,   PULL_DISABLED,                OUTPUT },
-  { SYS_BOOT4,     MUXMODE3,   PULL_DISABLED,                OUTPUT },
-  { SYS_BOOT5,     MUXMODE3,   PULL_DISABLED,                OUTPUT },
-  { SYS_BOOT6,     MUXMODE3,   PULL_DISABLED,                OUTPUT }
+PAD_CONFIGURATION PadConfigurationTable4460Core[] = {
+	{ABE_MCBSP2_CLKX, (PTU | OFF_EN | OFF_OUT_PTU | M3)},		/* led status_1 */
+};
+
+PAD_CONFIGURATION PadConfigurationTable4460Wkup[] = {
+    {PAD1_FREF_CLK4_REQ, (M3)}, /* gpio_wk7 for TPS: Mode 3 */
 };
 
 VOID
 PadConfiguration (
-  PANDABOARD_REVISION Revision
+  PANDABOARD_REVISION BoardRevision
   )
 {
   UINTN             Index;
-  UINT16            PadConfiguration;
-  PAD_CONFIGURATION *BoardConfiguration;
   UINTN             NumPinsToConfigure;
 
-  for (Index = 0; Index < NUM_PINS_SHARED; Index++) {
-    // Set up Pad configuration for particular pin.
-    PadConfiguration =  (PadConfigurationTableShared[Index].MuxMode << MUXMODE_OFFSET);
-    PadConfiguration |= (PadConfigurationTableShared[Index].PullConfig << PULL_CONFIG_OFFSET);
-    PadConfiguration |= (PadConfigurationTableShared[Index].InputEnable << INPUTENABLE_OFFSET);
-
+  // Calculate number of pins for core domain
+  NumPinsToConfigure = sizeof(PadConfigurationTableSharedCore) / sizeof(PAD_CONFIGURATION);
+  
+  for (Index = 0; Index < NumPinsToConfigure; Index++) {
     // Configure the pin with specific Pad configuration.
-    MmioWrite16(PadConfigurationTableShared[Index].Pin, PadConfiguration);
+    MmioWrite16((OMAP4430_CONTROL_MODULE_CORE_BASE+PadConfigurationTableSharedCore[Index].Off),
+	            PadConfigurationTableSharedCore[Index].Val);
   }
 
-  if (Revision == REVISION_XM) {
-    BoardConfiguration = PadConfigurationTableXm;
-    NumPinsToConfigure = NUM_PINS_XM;
-  } else {
-    BoardConfiguration = PadConfigurationTableAbc;
-    NumPinsToConfigure = NUM_PINS_ABC;
+  // Calculate number of pins for wkup domain
+  NumPinsToConfigure = sizeof(PadConfigurationTableSharedWkup) / sizeof(PAD_CONFIGURATION);
+  
+  for (Index = 0; Index < NumPinsToConfigure; Index++) {
+    // Configure the pin with specific Pad configuration.
+    MmioWrite16((OMAP4430_CONTROL_MODULE_WKUP_BASE+PadConfigurationTableSharedWkup[Index].Off),
+	            PadConfigurationTableSharedWkup[Index].Val);
+  }
+  
+  // If PandaBoard-ES
+  if( BoardRevision == PANDABOARD_REVISION_PANDAES ) {
+      // Calculate number of pins for core domain
+      NumPinsToConfigure = sizeof(PadConfigurationTable4460Core) / sizeof(PAD_CONFIGURATION);
+  
+      for (Index = 0; Index < NumPinsToConfigure; Index++) {
+        // Configure the pin with specific Pad configuration.
+        MmioWrite16((OMAP4430_CONTROL_MODULE_CORE_BASE+PadConfigurationTable4460Core[Index].Off),
+	              PadConfigurationTable4460Core[Index].Val);
+      }
+	  
+      // Calculate number of pins for wkup domain
+      NumPinsToConfigure = sizeof(PadConfigurationTable4460Wkup) / sizeof(PAD_CONFIGURATION);
+  
+      for (Index = 0; Index < NumPinsToConfigure; Index++) {
+        // Configure the pin with specific Pad configuration.
+        MmioWrite16((OMAP4430_CONTROL_MODULE_WKUP_BASE+PadConfigurationTable4460Wkup[Index].Off),
+	              PadConfigurationTable4460Wkup[Index].Val);
+      }
+  }
+  else {
+      // Calculate number of pins for core domain
+      NumPinsToConfigure = sizeof(PadConfigurationTable4430Core) / sizeof(PAD_CONFIGURATION);
+  
+      for (Index = 0; Index < NumPinsToConfigure; Index++) {
+        // Configure the pin with specific Pad configuration.
+        MmioWrite16((OMAP4430_CONTROL_MODULE_CORE_BASE+PadConfigurationTable4430Core[Index].Off),
+	              PadConfigurationTable4430Core[Index].Val);
+      }
+	  
+      // Calculate number of pins for wkup domain
+      NumPinsToConfigure = sizeof(PadConfigurationTable4430Wkup) / sizeof(PAD_CONFIGURATION);
+  
+      for (Index = 0; Index < NumPinsToConfigure; Index++) {
+        // Configure the pin with specific Pad configuration.
+        MmioWrite16((OMAP4430_CONTROL_MODULE_WKUP_BASE+PadConfigurationTable4430Wkup[Index].Off),
+	              PadConfigurationTable4430Wkup[Index].Val);
+      }
   }
 
-  for (Index = 0; Index < NumPinsToConfigure; Index++) {
-    //Set up Pad configuration for particular pin.
-    PadConfiguration =  (BoardConfiguration[Index].MuxMode << MUXMODE_OFFSET);
-    PadConfiguration |= (BoardConfiguration[Index].PullConfig << PULL_CONFIG_OFFSET);
-    PadConfiguration |= (BoardConfiguration[Index].InputEnable << INPUTENABLE_OFFSET);
+  // EMIF pads
+  MmioWrite32 (0x4A100638, 0x7c7c7c7c);
+  MmioWrite32 (0x4A10063C, 0x7c7c7c7c);
+  MmioWrite32 (0x4A100640, 0x7C787C00);
+  MmioWrite32 (0x4A100644, 0xA0888C0F);
+
+  MmioWrite32 (0x4A100648, 0x7C7C7C7C);
+  MmioWrite32 (0x4A10064C, 0x7C7C7C7C);
+  MmioWrite32 (0x4A100650, 0x7C787C00);
+  MmioWrite32 (0x4A100654, 0xA0888C0F);
 
-    //Configure the pin with specific Pad configuration.
-    MmioWrite16(BoardConfiguration[Index].Pin, PadConfiguration);
-  }
 }
diff --git a/PandaBoardPkg/Library/PandaBoardLib/PandaBoard.c b/PandaBoardPkg/Library/PandaBoardLib/PandaBoard.c
index c04fc6af..cec10b1a 100644
--- a/PandaBoardPkg/Library/PandaBoardLib/PandaBoard.c
+++ b/PandaBoardPkg/Library/PandaBoardLib/PandaBoard.c
@@ -47,12 +47,12 @@ ARM_CORE_INFO mVersatileExpressMpCoreInfoPandaBoard[] = {
 
 VOID
 PadConfiguration (
-  PANDABOARD_REVISION Revision
+  PANDABOARD_REVISION BoardRevision
   );
 
 VOID
 ClockInit (
-  VOID
+  PANDABOARD_REVISION BoardRevision
   );
 
 /**
@@ -61,26 +61,22 @@ ClockInit (
   @return Board revision
 **/
 PANDABOARD_REVISION
-PandaBoardGetRevision (
+PandaBoardGetBoardRevision (
   VOID
   )
 {
-#if 0
-  UINT32 OldPinDir;
   UINT32 Revision;
 
-  // Read GPIO 171, 172, 173
-  OldPinDir = MmioRead32 (GPIO6_BASE + GPIO_OE);
-  MmioWrite32(GPIO6_BASE + GPIO_OE, (OldPinDir | BIT11 | BIT12 | BIT13));
-  Revision = MmioRead32 (GPIO6_BASE + GPIO_DATAIN);
-  
-  // Restore I/O settings
-  MmioWrite32 (GPIO6_BASE + GPIO_OE, OldPinDir);
-  
-  return (PANDABOARD_REVISION)((Revision >> 11) & 0x7);
-#endif
+  // If Chip Id code matches 4460 processor
+  if( ((MmioRead32(CONTROL_CORE_ID_CODE)>>16)&0xFFF) == 0xb94 ) {
+    Revision = PANDABOARD_REVISION_PANDAES;
+  }
+  else {
+    // Assume 4430
+    Revision = PANDABOARD_REVISION_PANDA;
+  }
 
-  return 0;
+  return Revision;
 }
 
 /**
@@ -113,10 +109,7 @@ ArmPlatformGetBootMode (
 }
 
 /**
-  Initialize controllers that must setup at the early stage
-
-  Some peripherals must be initialized in Secure World.
-  For example, some L2x0 requires to be initialized in Secure World
+  Early board setup
 
 **/
 RETURN_STATUS
@@ -124,30 +117,21 @@ ArmPlatformInitialize (
   IN  UINTN                     MpId
   )
 {
-#if 0
   PANDABOARD_REVISION Revision;
 
-  Revision = PandaBoardGetRevision();
+  // Get chip version
+  Revision = PandaBoardGetBoardRevision();
 
   // Set up Pin muxing.
   PadConfiguration (Revision);
 
   // Set up system clocking
-  ClockInit ();
-
-  // Turn off the functional clock for Timer 3
-  MmioAnd32 (CM_FCLKEN_PER, 0xFFFFFFFF ^ CM_ICLKEN_PER_EN_GPT3_ENABLE );
-  ArmDataSyncronizationBarrier ();
-
-  // Clear IRQs
-  MmioWrite32 (INTCPS_CONTROL, INTCPS_CONTROL_NEWIRQAGR);
-  ArmDataSyncronizationBarrier ();
-#endif
+  ClockInit (Revision);
 
   // Make sure GPMC region region 0 is disabled
   // Not doing so makes gpmc_init hang early in kernel init
   MmioAnd32 (GPMC_CONFIG7_0, ~CSVALID);
-
+  
   return RETURN_SUCCESS;
 }
 
diff --git a/PandaBoardPkg/Library/PandaBoardLib/PandaBoardHelper.S b/PandaBoardPkg/Library/PandaBoardLib/PandaBoardHelper.S
index 26624b80..6405d167 100644
--- a/PandaBoardPkg/Library/PandaBoardLib/PandaBoardHelper.S
+++ b/PandaBoardPkg/Library/PandaBoardLib/PandaBoardHelper.S
@@ -20,41 +20,77 @@
 .text
 .align 3
 
-GCC_ASM_EXPORT(ArmPlatformIsBootMemoryInitialized)
-GCC_ASM_EXPORT(ArmPlatformInitializeBootMemory)
+GCC_ASM_EXPORT(ArmPlatformPrePiBootAction)
 GCC_ASM_EXPORT(ArmPlatformGetCorePosition)
 
 /**
-  Called at the early stage of the Boot phase to know if the memory has already been initialized
-
-  Running the code from the reset vector does not mean we start from cold boot. In some case, we
-  can go through this code with the memory already initialized.
-  Because this function is called at the early stage, the implementation must not use the stack.
-  Its implementation must probably done in assembly to ensure this requirement.
-
-  @return   Return a non zero value if initialized
+  ArmPlatformPrePiBootAction
 
 **/
-ASM_PFX(ArmPlatformIsBootMemoryInitialized):
-  // The system memory is initialized by the PandaBoard firmware
-  mov   r0, #1
-  bx    lr
+ASM_PFX(ArmPlatformPrePiBootAction):
+  //relocate the relocator
+  sub r12,r12
+  orr r12,r12,#0x80000000
+  mov r3,r12                 // relocator target address (0x80000000)
+  ldr r0, =relocator_start   // relocator code start addr
+  ldr r1, =relocator_end     // relocator end addr
+  sub r1,r1,r0               // compute relocator code size
+  lsr r1,r1,#0x2             // size in words
+reloc_loop_reloc:            // copy relocator
+  ldm r0!,{r2}
+  stm r3!,{r2}
+  subs r1,r1,#0x1
+  bne reloc_loop_reloc
 
-    
-/**
-  Initialize the memory where the initial stacks will reside
+  // get chip id code
+  ldr r2,=0x4a002206         // control module id code address
+  ldrh r2,[r2]               // get higher order 16b
+  lsl r2,r2,#0x14
+  ldr r1,=0xb9400000         // compare with 4460 id
+  cmp r1,r2                  // Z bit set if 4460
 
-  This memory can contain the initial stacks (Secure and Secure Monitor stacks).
-  In some platform, this region is already initialized and the implementation of this function can
-  do nothing. This memory can also represent the Secure RAM.
-  This function is called before the satck has been set up. Its implementation must ensure the stack
-  pointer is not used (probably required to use assembly language)
+  // update dmm conf
+  mov r0,#0x4e
+  lsl r0,r0,#0x18            // load DMM LISA base address
+  ldr r2,=0x482af000         // load MA LISA base address
+  ldr r1,[r0,#0x40]          // get DMM LISA section 0
+  str r1,[r0,#0x4c]          // update DMM LISA section 3
+  streq r1,[r2,#0x4c]        // update MA LISA section 3 (when Z=1: 4460 only)
+  ldr r1,=0xff020100         // prepare LISA section 0
+  str r1,[r0,#0x40]          // update DMM LISA section 0
+  streq r1,[r2,#0x40]        // update MA LISA section 0 (when Z set: 4460 only)
+  bx r12                     // jump to relocator
 
-**/
-ASM_PFX(ArmPlatformInitializeBootMemory):
-  // We must need to go into this function
-  bx    lr
+relocator_start:
+  // update emif conf.
+  sub r2,r0,#0x1000000
+  sub r1,r2,#0x1000000
+  mov r0,#0x10
+  str r0,[r1,#0xc]
+  str r0,[r2,#0xc]
+  ldr r0,[r1,#0x8]
+  orr r0,r0,#0x8
+  str r0,[r1,#0x8]
+  str r0,[r2,#0x8]
 
+  // copy
+  add r1,r12,#0x8000
+  add r0,r1,#0x8000
+  mov r10,#0x1
+  lsl r11,r10,#0x5
+reloc_loop_1M:
+  lsl r10,r10,#0xA
+reloc_loop_4K:
+  ldm r0!,{r2-r9}
+  stm r1!,{r2-r9}
+  subs r10,r10,#1
+  bne reloc_loop_4K
+  add r0,r0,#0x8000
+  subs r11,r11,#1
+  add r10,r10,#0x1
+  bne reloc_loop_1M
+  bx lr
+relocator_end:
 
 //UINTN
 //ArmPlatformGetCorePosition (
diff --git a/PandaBoardPkg/Library/ResetSystemLib/ResetSystemLib.c b/PandaBoardPkg/Library/ResetSystemLib/ResetSystemLib.c
index 79a51e13..fa0877a5 100644
--- a/PandaBoardPkg/Library/ResetSystemLib/ResetSystemLib.c
+++ b/PandaBoardPkg/Library/ResetSystemLib/ResetSystemLib.c
@@ -132,8 +132,8 @@ LibResetSystem (
   case EfiResetShutdown:
   default:
     //Perform cold reset of the system.
-    MmioOr32 (PRM_RSTCTRL, RST_DPLL3);
-    while ((MmioRead32(PRM_RSTST) & GLOBAL_COLD_RST) != 0x1);
+    MmioOr32 (PRM_RSTCTRL, PRM_RSTCTRL_RST_GLOBAL_COLD_SW_VAL);
+    while ((MmioRead32(PRM_RSTST) & PRM_RSTST_GLOBAL_COLD_RST_MASK) != 0x1);
     break;
   }
 
diff --git a/PandaBoardPkg/PandaBoardPkg.dsc b/PandaBoardPkg/PandaBoardPkg.dsc
index c9977591..9381e0e0 100644
--- a/PandaBoardPkg/PandaBoardPkg.dsc
+++ b/PandaBoardPkg/PandaBoardPkg.dsc
@@ -35,6 +35,7 @@
   ArmPlatformLib|PandaBoardPkg/Library/PandaBoardLib/PandaBoardLib.inf
   ArmCpuLib|ArmPkg/Drivers/ArmCpuLib/ArmCortexA9Lib/ArmCortexA9Lib.inf
   ArmPlatformStackLib|ArmPlatformPkg/Library/ArmPlatformStackLib/ArmPlatformStackLib.inf
+  ArmSmcLib|ArmPkg/Library/ArmSmcLib/ArmSmcLib.inf
   
   HiiLib|MdeModulePkg/Library/UefiHiiLib/UefiHiiLib.inf
   UefiHiiServicesLib|MdeModulePkg/Library/UefiHiiServicesLib/UefiHiiServicesLib.inf
@@ -85,6 +86,7 @@
   PrePiLib|EmbeddedPkg/Library/PrePiLib/PrePiLib.inf
   
   SerialPortLib|Omap44xxPkg/Library/SerialPortLib/SerialPortLib.inf
+  SerialPortExtLib|EmbeddedPkg/Library/TemplateSerialPortExtLib/TemplateSerialPortExtLib.inf
   SemihostLib|ArmPkg/Library/SemihostLib/SemihostLib.inf
 
   RealTimeClockLib|Omap44xxPkg/Library/RealTimeClockLib/RealTimeClockLib.inf
@@ -366,10 +368,13 @@
   gArmTokenSpaceGuid.PcdArmUncachedMemoryMask|0x0000000040000000
 
   gArmPlatformTokenSpaceGuid.PcdDefaultBootDescription|L"Linux from SD"
-  gArmPlatformTokenSpaceGuid.PcdDefaultBootDevicePath|L"VenHw(100C2CFA-B586-4198-9B4C-1683D195B1DA)/HD(1,MBR,0xB663049F,0x3F,0x13986)/zImage"
+  gArmPlatformTokenSpaceGuid.PcdDefaultBootDevicePath|L"VenHw(100C2CFA-B586-4198-9B4C-1683D195B1DA)/HD(1,MBR,0x00000000,0x3F,0x19FC0)/uImage"
+  gArmPlatformTokenSpaceGuid.PcdFdtDevicePath|L"VenHw(100C2CFA-B586-4198-9B4C-1683D195B1DA)/HD(1,MBR,0x00000000,0x3F,0x19FC0)/board.dtb"
+  gArmPlatformTokenSpaceGuid.PcdDefaultBootInitrdPath|L"VenHw(100C2CFA-B586-4198-9B4C-1683D195B1DA)/HD(1,MBR,0x00000000,0x3F,0x19FC0)/uInitrd"
+  gArmPlatformTokenSpaceGuid.PcdDefaultBootArgument|"console=ttyO2,115200n8 root=/dev/mmcblk0p2 rootwait ro fixrtc nocompcache vram=48M omapfb.vram=0:24M"
+  
   gArmPlatformTokenSpaceGuid.PcdDefaultBootType|2
   gArmPlatformTokenSpaceGuid.PcdPlatformBootTimeOut|3
-  gArmPlatformTokenSpaceGuid.PcdFdtDevicePath|L"VenHw(100C2CFA-B586-4198-9B4C-1683D195B1DA)/HD(1,MBR,0xB663049F,0x3F,0x13986)/omap4-panda.dtb"
 
   gArmPlatformTokenSpaceGuid.PcdDefaultConOutPaths|L"VenHw(D3987D4B-971A-435F-8CAF-4967EB627241)/Uart(115200,8,N,1)/VenPcAnsi();VenHw(E68088EF-D1A4-4336-C1DB-4D3A204730A6)"
   gArmPlatformTokenSpaceGuid.PcdDefaultConInPaths|L"VenHw(D3987D4B-971A-435F-8CAF-4967EB627241)/Uart(115200,8,N,1)/VenPcAnsi()"
@@ -377,9 +382,9 @@
   #
   # ARM OS Loader
   #
-  # PandaBoard machine type required for ARM Linux: 
+  # PandaBoard machine type required for ARM Linux:
   gArmTokenSpaceGuid.PcdArmMachineType|2791
-
+  
 ################################################################################
 #
 # Components Section - list of all EDK II Modules needed by this Platform
@@ -442,8 +447,6 @@
   #
   Omap44xxPkg/PciEmulation/PciEmulation.inf
 
-  #NOTE: Open source EHCI stack doesn't work on Pandaboard.
-  #NOTE: UsbBus and UsbMassStorage don't work using iPhone SDK tool chain.
   MdeModulePkg/Bus/Pci/EhciDxe/EhciDxe.inf {
     <PcdsFixedAtBuild>
       gEfiMdePkgTokenSpaceGuid.PcdDebugPrintErrorLevel|0x800fffff
diff --git a/PandaBoardPkg/PandaBoardPkg.fdf b/PandaBoardPkg/PandaBoardPkg.fdf
index 04486dfd..42482592 100644
--- a/PandaBoardPkg/PandaBoardPkg.fdf
+++ b/PandaBoardPkg/PandaBoardPkg.fdf
@@ -150,10 +150,10 @@ READ_LOCK_STATUS   = TRUE
   # USB Support (not supported currently)
   #
 
-  #INF Omap44xxPkg/PciEmulation/PciEmulation.inf
-  #INF MdeModulePkg/Bus/Pci/EhciDxe/EhciDxe.inf
-  #INF MdeModulePkg/Bus/Usb/UsbBusDxe/UsbBusDxe.inf
-  #INF MdeModulePkg/Bus/Usb/UsbMassStorageDxe/UsbMassStorageDxe.inf
+  INF Omap44xxPkg/PciEmulation/PciEmulation.inf
+  INF MdeModulePkg/Bus/Pci/EhciDxe/EhciDxe.inf
+  INF MdeModulePkg/Bus/Usb/UsbBusDxe/UsbBusDxe.inf
+  INF MdeModulePkg/Bus/Usb/UsbMassStorageDxe/UsbMassStorageDxe.inf
 
   #
   # UEFI application (Shell Embedded Boot Loader) 
diff --git a/PandaBoardPkg/build.sh b/PandaBoardPkg/build.sh
index 8002eac2..dc4b9067 100755
--- a/PandaBoardPkg/build.sh
+++ b/PandaBoardPkg/build.sh
@@ -85,12 +85,23 @@ then
 fi
 
 TARGET=DEBUG
-for arg in "$@"
+BUILD_TARGET=DEBUG
+args=($@)
+
+for (( i=0; i<$#; i++ ))
 do
-  if [[ $arg == RELEASE ]]; 
-  then
-    TARGET=RELEASE
-  fi
+	if [[ "${args[$i]}" == "-b" ]]
+	then
+		TARGET=${args[$i+1]}
+		BUILD_TARGET=$TARGET
+		if [[ "$TARGET" == "RELEASE" ]]
+		then
+			BUILD_TARGET="$BUILD_TARGET -D DEBUG_TARGET=RELEASE"
+		fi
+		i=$i+1
+	else
+		other_args="$other_args ${args[$i]}"
+	fi
 done
 
 BUILD_ROOT=$WORKSPACE/Build/PandaBoard/"$TARGET"_"$TARGET_TOOLS"
@@ -109,12 +120,7 @@ fi
 #
 # Build the edk2 PandaBoard code
 #
-if [[ $TARGET == RELEASE ]]; then
-  build -p $WORKSPACE/PandaBoardPkg/PandaBoardPkg.dsc -a ARM -t $TARGET_TOOLS -b $TARGET -D DEBUG_TARGET=RELEASE ${2:-} ${3:-} ${4:-} ${5:-} ${6:-} ${7:-} ${8:-}
-else
-  build -p ${WORKSPACE:-}/PandaBoardPkg/PandaBoardPkg.dsc -a ARM -t $TARGET_TOOLS -b $TARGET ${1:-} ${2:-} ${3:-} ${4:-} ${5:-} ${6:-} ${7:-} ${8:-}
-fi
-
+build -p $WORKSPACE/PandaBoardPkg/PandaBoardPkg.dsc -a ARM -t $TARGET_TOOLS -b $BUILD_TARGET $other_args
 
 for arg in "$@"
 do
diff --git a/PandaBoardPkg/patches/0001-Add-call-to-early-prepi-init-in-ModuleEntryPoint.patch b/PandaBoardPkg/patches/0001-Add-call-to-early-prepi-init-in-ModuleEntryPoint.patch
new file mode 100644
index 00000000..15b4d7f9
--- /dev/null
+++ b/PandaBoardPkg/patches/0001-Add-call-to-early-prepi-init-in-ModuleEntryPoint.patch
@@ -0,0 +1,35 @@
+From 9a22e1fed42e2ece74ae06546bc300bd0202e1ad Mon Sep 17 00:00:00 2001
+From: Olivier Deprez <o-deprez@ti.com>
+Date: Fri, 1 Mar 2013 16:03:11 +0100
+Subject: [PATCH] Add call to early prepi init in ModuleEntryPoint
+
+omap4 requires an early call to an inner asm function to work
+around a rom mask issue tied to dram initialization.
+---
+ ArmPlatformPkg/PrePi/ModuleEntryPoint.S |    4 ++++
+ 1 file changed, 4 insertions(+)
+
+diff --git a/ArmPlatformPkg/PrePi/ModuleEntryPoint.S b/ArmPlatformPkg/PrePi/ModuleEntryPoint.S
+index c0c20a9..66f0701 100755
+--- a/ArmPlatformPkg/PrePi/ModuleEntryPoint.S
++++ b/ArmPlatformPkg/PrePi/ModuleEntryPoint.S
+@@ -24,12 +24,16 @@
+ GCC_ASM_IMPORT(CEntryPoint)
+ GCC_ASM_IMPORT(ArmReadMpidr)
+ GCC_ASM_IMPORT(ArmPlatformStackSet)
++GCC_ASM_IMPORT(ArmPlatformPrePiBootAction)
+ GCC_ASM_EXPORT(_ModuleEntryPoint)
+ 
+ StartupAddr: .word    CEntryPoint
+ 
+ 
+ ASM_PFX(_ModuleEntryPoint):
++  // Perform early PrePi init
++  bl ASM_PFX(ArmPlatformPrePiBootAction)
++
+   // Get ID of this CPU in Multicore system
+   bl    ASM_PFX(ArmReadMpidr)
+   LoadConstantToReg (FixedPcdGet32(PcdArmPrimaryCoreMask), r1)
+-- 
+1.7.9.5
+
diff --git a/PandaBoardPkg/readme.txt b/PandaBoardPkg/readme.txt
index 32b16375..fee17d8f 100644
--- a/PandaBoardPkg/readme.txt
+++ b/PandaBoardPkg/readme.txt
@@ -1,83 +1,59 @@
-
-Overview
-=========
+A. Overview
+===========
 
 The Panda packages are hosted on http://gitorious.org/omap-romcode/omap-edk2
 This repository contains the latest developments concerning UEFI on PandaBoard.
 Contact: o-deprez@ti.com
 
 Patches from omap-edk2 tree are regularly merged on need basis to
-http://git.linaro.org/gitweb?p=arm/uefi/uefi-next.git by ARM LT team.
-
-History
-========
-
-11/09/2012 PANDA_EDK2_110912
-    Rebased to uefi-next commit-id 99af201b87a6048c26f372e3f75a46d291b2f683
-    Fix build.sh removing tmp.bin temporary file
-    Fix SerialPollGetControl with returning correct Control parm
-    Comment out Semihostfs from PandaBoardPkg.fdf
-
-08/09/2012 PANDA_EDK2_080912
-	Rebased to linaro-uefi-2012.04 label
-	Boots linux "OMAP Ubuntu Core" kernel
-
-06/25/2012 PANDA_EDK2_062512
-	First drop able to boot EBL
+http://git.linaro.org/gitweb?p=arm/uefi/uefi-next.git by Linaro maintainer.
 
-Environment setup
-==================
+B. Environment setup
+====================
 
-	1. General setup
-	----------------
-
-bash
-mkdir panda_uefi; cd panda_uefi
-export PANDA_UEFI=`pwd`
-
-	2. Toolchain
+	1. Toolchain
 	------------
 
-For a list of possible toolchains visit:
-*http://sourceforge.net/apps/mediawiki/tianocore/index.php?title=ArmPkg/Toolchain
-
-PandaBoardPkg was built using gcc version 4.5.1 (Sourcery G++ Lite 2010.09-51).
-If you want to use the same compiler, use below commands (copy/paste from above webpage):
+PandaBoardPkg was built/tested using gcc version 4.6 on an Ubuntu Precise machine.
 
-wget http://www.codesourcery.com/sgpp/lite/arm/portal/package7813/public/arm-none-eabi/arm-2010.09-51-arm-none-eabi-i686-pc-linux-gnu.tar.bz2
-tar xjf arm-2010.09-51-arm-none-eabi-i686-pc-linux-gnu.tar.bz2
-rm !$
-
-$ Add arm gcc compiler to path
-export PATH=$PANDA_UEFI/arm-2010.09/bin:$PATH
+For a list of possible toolchains visit:
+http://sourceforge.net/apps/mediawiki/tianocore/index.php?title=ArmPkg/Toolchain
 
-	3. Install necessary package
+	2. Install necessary package
 	----------------------------
 
-# Install uuid-dev package if not present already
-sudo apt-get install uuid-dev
+Install uuid-dev package if not present already:
 
-Note: the build was done an Ubuntu 10.04 machine.
+sudo apt-get install uuid-dev
 
-Building
-=========
+C. Building
+===========
 
 Build information is found on uefi-next summary page:
 http://git.linaro.org/gitweb?p=arm/uefi/uefi-next.git;a=summary
 
-cd PandaBoardPkg
-./build.sh RELEASE
+After cloning the Linaro EDK2 tree and before compiling the PandaBoardPkg,
+you must apply following patch to ArmPlatformPkg:
+
+  git apply PandaBoardPkg/patches/0001-Add-call-to-early-prepi-init-in-ModuleEntryPoint.patch
+
+Compilation is done with following command:
+
+  cd PandaBoardPkg
+  ./build.sh -b RELEASE
+
+Note: the Debug version is compiled by invoking build.sh without parameters or:
 
-Note: you can build the debug version by invoking the build.sh command without parameters.
+  ./build.sh -b DEBUG
 
-Running EDK2 on Panda
-======================
+D. Running EDK2 on Panda
+========================
 
-    1. UEFI EBL shell
-    -----------------
+    1. UEFI Shell
+    -------------
 
-If you just intend to see how UEFI boots up and make a try with EBL, you
-can just do a raw copy of the firmware image to an SD card (e.g. /dev/sdc):
+If you just intend to see how UEFI boots up and make a try with the shell, you
+can do a raw copy of the firmware image to an SD card (e.g. /dev/sdc):
 
     dd if=edk2/Build/PandaBoard/RELEASE_ARMGCC/FV/MLO of=/dev/sdc
 
@@ -86,66 +62,53 @@ Open your favorite serial terminal e.g.
 
 Plug serial and power cables.
 
-After few seconds, you should see following boot menu:
+After few seconds, the following boot menu shall pop up:
 
-    The default boot selection will start in   1 seconds
-    ERROR: Did not find Linux kernel.
     [1] Linux from SD
-    [2] EBL
-    [3] Boot Manager
-Start: 
-
-[Type 2 for starting EBL.]
-
-More info on EBL:
-*http://sourceforge.net/apps/mediawiki/tianocore/index.php?title=EDK_Boot_Loader_(EBL)_WiKi
+            - VenHw(100C2CFA-B586-4198-9B4C-1683D195B1DA)/HD(1,MBR,0x00000000,0x3F,0
+    x19FC0)/uImage
+            - Initrd: VenHw(100C2CFA-B586-4198-9B4C-1683D195B1DA)/HD(1,MBR,0x0000000
+    0,0x3F,0x19FC0)/uInitrd
+            - Arguments: console=ttyO2,115200n8 root=/dev/mmcblk0p2 earlyprintk root
+    wait ro fixrtc nocompcache vram=48M omapfb.vram=0:24M
+            - LoaderType: Linux kernel with global FDT
+    -----------------------
+    Global FDT Config
+            - VenHw(100C2CFA-B586-4198-9B4C-1683D195B1DA)/HD(1,MBR,0x00000000,0x3F,0
+    x19FC0)/board.dtb
+    -----------------------
+    [a] Boot Manager
+    [b] Shell
+    Start:
+
+From there, type 'b' for starting the shell.
 
     2. Starting a Linux kernel
     --------------------------
 
-As a matter of testing linux boot, you can clone "OMAP Ubuntu Core" kernel, instructions located here:
-*http://omappedia.org/wiki/OMAP_Ubuntu_Core
-
-1. Copy/pasted the relevant commands for cloning and building omap linux kernel:
-
-	bash
-	export PATH=<path to your toolchain>:$PATH
-	export ARCH=arm
-	export CROSS_COMPILE=arm-none-linux-gnueabi-
-
-	git clone git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
-	cd linux; git checkout -b v3.3-rc1 v3.3-rc1
-	make omap2plus_defconfig
-	make zImage 
-
-2. InPandaBoardPkg.dsc, update the boot device path with the one matching your SD card:
-	gArmPlatformTokenSpaceGuid.PcdDefaultBootDevicePath|L"VenHw(100C2CFA-B586-4198-9B4C-1683D195B1DA)/HD(1,MBR,0x00000000,0x3F,0x2348A)/zImage"
-
-Note: this device path changes any time your swap/change SD card. If ever you need to boot up same build or another SD card, you need to re-build with updated device path.
+Check following page: http://releases.linaro.org/13.01/ubuntu/panda
 
-3. Re-build PandaBoardPkg
+The easiest way is to get a full boot+filesystem image:
+wget http://releases.linaro.org/13.01/ubuntu/boards/panda/panda-quantal_developer_20130128-58.img.gz
 
-4. Format the SD card with a FAT32 and an ext3 partiton
+Unzip and dd to an sd card as described on Linaro's website.
 
-More information on how to format an SD card here:
-*http://www.omappedia.com/wiki/SD_Configuration
+Note: on OMAP, usage of earlyprintk statement on kernel command line looks incompatible with device tree.
+Indeed early print routines use legacy machine type id to identify which uart module to use.
+In case of device tree based boot  the machine type passed to kernel entry by Bds is 0xFFFFFFFF,
+which is unknown to earlyprintk routines and result in a hang.
 
-5. Drop following files in FAT32 partition:
-	edk2/Build/PandaBoard/RELEASE_ARMGCC/FV/MLO
-	linux/arch/arm/boot/zImage generated at step 1
-
-6. Insert SD card and boot up Panda board.
-   You should see the boot menu and kernel starting after 3 seconds.
-
-Boards tested
-==================
+E. Boards tested
+================
 
 PandaBoard Rev EA2    - EBL and linux boot (PANDA_EDK2_080912)
-PandaBoard Rev A3     - EBL and linux boot (PANDA_EDK2_080912)
-PandaBoard ES Rev B1  - EBL (PANDA_EDK2_062512)
+PandaBoard Rev A3     - Shell and linux boot (PANDA_EDK2_030113)
+PandaBoard ES Rev B1  - Shell (PANDA_EDK2_030113)
+
+Note: Panda ES did not fully boot up linaro 13.01 image thru UEFI (stuck at L2 cache init).
 
-chtool
-=======
+F. chtool
+=========
 
 The PandaBoardPkg/Tools directory contains a tool called chtool for creating
 a Configuration Header block for use with the ROM Code boot sequence (in this port
@@ -155,8 +118,42 @@ This tool is tracked in the following tree: git://gitorious.org/omap-romcode/cht
 
 The version of chtool present in PandaBoardPkg is v0.4.
 
-Resources
-=========
+G. History
+==========
+
+03/01/2013 PANDA_EDK2_030113
+    Added patch early PrePi init patch to ArmPlatformPkg
+	Board revision
+	Cleaned up Pad conf
+	Cleaned up setup clocks acceleration
+	Enable 1GB support
+	Add usb host support
+	Use null sd card's uuid
+
+01/28/2013 PANDA_EDK2_012813
+    Created an edk2 top dir, moved packages in this dir
+
+11/21/2012 PANDA_EDK2_112112
+    Add TWL6030 PMIC support
+    Update GPMC base address
+	Remove unused drivers (Flash, MMCHSDxe, InterruptDxe, SemihostFs)
+    Change PcdCoreCount to 2
+	Change default boot type to Fdt
+	Update linux machine type to PandaBoard
+
+11/09/2012 PANDA_EDK2_110912
+    Fix build.sh removing tmp.bin temporary file
+    Fix SerialPollGetControl with returning correct Control parm
+    Comment out Semihostfs from PandaBoardPkg.fdf
+
+08/09/2012 PANDA_EDK2_080912
+	Boots linux "OMAP Ubuntu Core" kernel
+
+06/25/2012 PANDA_EDK2_062512
+	First drop able to boot EBL
+
+H. Resources
+============
 
 Panda Board - TI OMAP4
 *http://pandaboard.org
@@ -167,14 +164,16 @@ Beagle Board - TI OMAP3
 ArmPlatformPkg - Generic package for ARM platforms
 *http://sourceforge.net/apps/mediawiki/tianocore/index.php?title=ArmPlatformPkg
 
-To do/next steps
-======================
--Enable >512MiB external SDRAM
--Add PMIC management e.g. for SD card detection
+I. To do/next steps
+===================
+
+-Enable Network
 -Enable display/gui
--Clean PandaBoardLib for: detection of PandaBoard revision, pad conf, clocks speed up (if necessary)
 -Add a CHMMCSD item in ROM's Configuration Header to accelerate image copy from SD to external RAM
 
+-DONE 03/01/2013 Enable USB host capability
+-DONE 03/01/2013 Enable >512MiB external SDRAM
+-DONE 03/01/2013 Clean PandaBoardLib for: detection of PandaBoard revision, pad conf, clocks speed up (if necessary)
+-DONE 11/21/2012 Add PMIC management e.g. for SD card detection
 -DONE 08/09/2012 Boot up linux kernel
 -DONE 08/09/2012 Switch to linaro-uefi-2012.04 tag
-
diff --git a/SamsungPlatformPkg/ArndaleBoardPkg/ArndaleBoardPkg.dsc.inc b/SamsungPlatformPkg/ArndaleBoardPkg/ArndaleBoardPkg.dsc.inc
index 04a18e9e..671ef131 100644
--- a/SamsungPlatformPkg/ArndaleBoardPkg/ArndaleBoardPkg.dsc.inc
+++ b/SamsungPlatformPkg/ArndaleBoardPkg/ArndaleBoardPkg.dsc.inc
@@ -296,11 +296,13 @@ ArmPlatformSecLib|ArmPlatformPkg/Library/ArmPlatformSecLibNull/ArmPlatformLibNul
   # ARM OS Loader
   #
   gArmTokenSpaceGuid.PcdArmMachineType|2456
-  gArmPlatformTokenSpaceGuid.PcdDefaultBootDescription|L"SD-MMC Booting"
-  gArmPlatformTokenSpaceGuid.PcdDefaultBootDevicePath|L"VenHw(3A02E7FE-0649-4FB4-BE4F-A862CA1872A9)/HD(2,MBR,0x000A65DC,0x59B303,0x3B7C)/uImage"
-  gArmPlatformTokenSpaceGuid.PcdFdtDevicePath|L"VenHw(3A02E7FE-0649-4FB4-BE4F-A862CA1872A9)/HD(2,MBR,0x000A65DC,0x59B303,0x3B7C)/exynos5250-arndale.dtb"
-  gArmPlatformTokenSpaceGuid.PcdDefaultBootArgument|"root=/dev/mmcblk1p1 rw rootwait console=ttySAC2,115200n8 init --no-log"
-  gArmPlatformTokenSpaceGuid.PcdDefaultBootType|2
+  gArmPlatformTokenSpaceGuid.PcdDefaultBootDescription|L"Linaro image on SD card"
+  gArmPlatformTokenSpaceGuid.PcdDefaultBootDevicePath|L"VenHw(3A02E7FE-0649-4FB4-BE4F-A862CA1872A9)/HD(2,MBR,0x00000000,0x2000,0x1A000)/uImage"
+  gArmPlatformTokenSpaceGuid.PcdDefaultBootInitrdPath|L"VenHw(3A02E7FE-0649-4FB4-BE4F-A862CA1872A9)/HD(2,MBR,0x00000000,0x2000,0x1A000)/uInitrd"
+  gArmPlatformTokenSpaceGuid.PcdDefaultFdtLocalDevicePath|L"VenHw(3A02E7FE-0649-4FB4-BE4F-A862CA1872A9)/HD(2,MBR,0x00000000,0x2000,0x1A000)/board.dtb"
+  gArmPlatformTokenSpaceGuid.PcdDefaultBootArgument|"root=/dev/mmcblk1p3 rw rootwait console=ttySAC2,115200n8 init --no-log"
+  gArmPlatformTokenSpaceGuid.PcdDefaultBootType|3
+  gArmPlatformTokenSpaceGuid.PcdFdtDevicePath|L"VenHw(3A02E7FE-0649-4FB4-BE4F-A862CA1872A9)/HD(2,MBR,0x00000000,0x2000,0x1A000)/board.dtb"
 
   # Use the Serial console (ConIn & ConOut) and the Graphic driver (ConOut)
   gArmPlatformTokenSpaceGuid.PcdDefaultConOutPaths|L"VenHw(D3987D4B-971A-435F-8CAF-4967EB627241)/Uart(115200,8,N,1)/VenPcAnsi();VenHw(9042A9DE-23DC-4A38-96FB-7ADED080516A)"
diff --git a/SamsungPlatformPkg/ArndaleBoardPkg/arndale-Exynos5250.dsc b/SamsungPlatformPkg/ArndaleBoardPkg/arndale-Exynos5250.dsc
index 6116f4ea..941c6e55 100755
--- a/SamsungPlatformPkg/ArndaleBoardPkg/arndale-Exynos5250.dsc
+++ b/SamsungPlatformPkg/ArndaleBoardPkg/arndale-Exynos5250.dsc
@@ -46,6 +46,7 @@
   # ARM PL390 General Interrupt Driver in Secure and Non-secure
   ArmGicSecLib|SamsungPlatformPkg/ExynosPkg/Exynos5250/Drivers/Gic400Dxe/PL390GicSecLib.inf
   ArmGicLib|SamsungPlatformPkg/ExynosPkg/Exynos5250/Drivers/Gic400Dxe/PL390GicLib.inf
+  ArmSmcLib|ArmPkg/Library/ArmSmcLibNull/ArmSmcLibNull.inf
 
 [LibraryClasses.common.SEC]
   ArmLib|ArmPkg/Library/ArmLib/ArmV7/ArmV7LibSec.inf
@@ -68,6 +69,11 @@
 ################################################################################
 
 [PcdsFeatureFlag.common]
+  gEfiMdePkgTokenSpaceGuid.PcdComponentNameDisable|FALSE
+  gEfiMdePkgTokenSpaceGuid.PcdDriverDiagnosticsDisable|TRUE
+  gEfiMdePkgTokenSpaceGuid.PcdComponentName2Disable|FALSE
+  gEfiMdePkgTokenSpaceGuid.PcdDriverDiagnostics2Disable|TRUE
+
 !ifdef $(EDK2_SKIP_PEICORE)
   gArmPlatformTokenSpaceGuid.PcdSystemMemoryInitializeInSec|TRUE
   gArmPlatformTokenSpaceGuid.PcdSendSgiToBringUpSecondaryCores|TRUE
@@ -104,9 +110,12 @@
   gArmTokenSpaceGuid.PcdFdSize|0x00200000              # Must be equal to gEmbeddedTokenSpaceGuid.PcdFlashFvMainSize
 
   # System Memory (256MB)
-  gArmTokenSpaceGuid.PcdSystemMemoryBase|0x50000000 #0x40000000
+  gArmTokenSpaceGuid.PcdSystemMemoryBase|0x40000000
   gArmTokenSpaceGuid.PcdSystemMemorySize|0x50000000
 
+  #FDT offset
+  gArmTokenSpaceGuid.PcdArmLinuxFdtMaxOffset|0x9000000
+
   # Size of the region used by UEFI in permanent memory (Reserved 64MB)
   gArmPlatformTokenSpaceGuid.PcdSystemMemoryUefiRegionSize|0x04000000
 
diff --git a/SamsungPlatformPkg/ExynosPkg/Exynos5250/Drivers/DisplayDxe/DisplayDxe.c b/SamsungPlatformPkg/ExynosPkg/Exynos5250/Drivers/DisplayDxe/DisplayDxe.c
index b9029c45..d1b5a3be 100644
--- a/SamsungPlatformPkg/ExynosPkg/Exynos5250/Drivers/DisplayDxe/DisplayDxe.c
+++ b/SamsungPlatformPkg/ExynosPkg/Exynos5250/Drivers/DisplayDxe/DisplayDxe.c
@@ -529,7 +529,6 @@ DisplayBlt(
   IN  UINTN                                   Delta         OPTIONAL
   )
 {
-  EFI_STATUS Status=EFI_SUCCESS;
   UINT8 *VidBuf, *BltBuf, *VidBuf1;
   UINTN i, j;
 
@@ -604,7 +603,7 @@ DisplayBlt(
       break;
 
     default:
-      ASSERT_EFI_ERROR(Status);
+      ASSERT_EFI_ERROR(EFI_SUCCESS);
   }
 
   return EFI_SUCCESS;
diff --git a/SamsungPlatformPkg/ExynosPkg/Exynos5250/Drivers/SDHCDxe_EVT1/SDHCDxe.c b/SamsungPlatformPkg/ExynosPkg/Exynos5250/Drivers/SDHCDxe_EVT1/SDHCDxe.c
index 70dbae15..0c3a219a 100755
--- a/SamsungPlatformPkg/ExynosPkg/Exynos5250/Drivers/SDHCDxe_EVT1/SDHCDxe.c
+++ b/SamsungPlatformPkg/ExynosPkg/Exynos5250/Drivers/SDHCDxe_EVT1/SDHCDxe.c
@@ -118,7 +118,7 @@ MSHC_SendCmd (
   UINTN CmdArgument
   )
 {
-  UINTN MmcStatus;
+  UINTN MmcStatus = 0;
   volatile UINTN RetryCount = 0;
   int cmd_flags = 0;
   int timeout=0;
@@ -246,13 +246,14 @@ static const UINT8 MultiFactor[16]={0, 10, 12, 13, 15, 20, 26, 30, 35, 40, 45, 5
 
 void PrintCardInfo()
 {
+#if !defined(MDEPKG_NDEBUG)
     UINT8 TransSpeed = gCardInfo.CSDData.TRAN_SPEED;
     
     DEBUG ((EFI_D_INFO, "SDHC::READ_BL_LEN %d\n", gCardInfo.CSDData.READ_BL_LEN));     
     DEBUG ((EFI_D_INFO, "SDHC::CSize %d\n", gCardInfo.CSDData.C_SIZELow2 | (gCardInfo.CSDData.C_SIZEHigh10 << 2)));         
     DEBUG ((EFI_D_INFO, "SDHC::MULTI %d\n", gCardInfo.CSDData.C_SIZE_MULT));         
     DEBUG ((EFI_D_INFO, "SDHC::Speed %d\n", (FreqUnit[TransSpeed&0x7]*MultiFactor[TransSpeed>>3])));         
-
+#endif
 }
 
 
@@ -599,7 +600,7 @@ ReadBlockData (
   IN  UINTN                         BlockCount
   )
 {
-  EFI_STATUS Status;
+  EFI_STATUS Status = EFI_INVALID_PARAMETER;
   UINTN DataSize = This->Media->BlockSize/4;
 
   DEBUG ((EFI_D_INFO, "SDHC::ReadBlockData start \n"));
@@ -625,7 +626,7 @@ WriteBlockData (
   IN  UINTN                         BlockCount  
   )
 {
-    EFI_STATUS Status;
+    EFI_STATUS Status = EFI_INVALID_PARAMETER;
     UINTN DataSize = This->Media->BlockSize/4;
 
     if(MSHC_operation_mode == MSHC_FIFO)
diff --git a/SamsungPlatformPkg/ExynosPkg/Exynos5250/Drivers/eMMCDxe/eMMCDxe.c b/SamsungPlatformPkg/ExynosPkg/Exynos5250/Drivers/eMMCDxe/eMMCDxe.c
index c38001a5..87f93792 100755
--- a/SamsungPlatformPkg/ExynosPkg/Exynos5250/Drivers/eMMCDxe/eMMCDxe.c
+++ b/SamsungPlatformPkg/ExynosPkg/Exynos5250/Drivers/eMMCDxe/eMMCDxe.c
@@ -123,7 +123,7 @@ MSHC_SendCmd (
   UINTN CmdArgument
   )
 {
-  UINTN MmcStatus;
+  UINTN MmcStatus = 0;
   volatile UINTN RetryCount = 0;
   int cmd_flags = 0;
   int timeout=0;
@@ -580,7 +580,7 @@ ReadBlockData (
   IN  UINTN                         BlockCount
   )
 {
-  EFI_STATUS Status;
+  EFI_STATUS Status = EFI_INVALID_PARAMETER;
   UINTN DataSize = This->Media->BlockSize/4;
 
   DEBUG ((EFI_D_INFO, "MSHC::ReadBlockData start \n"));
@@ -606,7 +606,7 @@ WriteBlockData (
   IN  UINTN                         BlockCount  
   )
 {
-    EFI_STATUS Status;
+    EFI_STATUS Status = EFI_INVALID_PARAMETER;
     UINTN DataSize = This->Media->BlockSize/4;
 
     if(MSHC_operation_mode == MSHC_FIFO)
@@ -840,7 +840,6 @@ DetectCard (
   gSDMMCMedia.MediaId++;
 
   UpdateMSHCClkFrequency(MSHC_CLK_50M);
-  MSHC_EMMC_Boot_Open();    //do not close boot partition
   DEBUG ((EFI_D_INFO, "SD Card Media Change on Handle 0x%08x\n", gImageHandle));
 
   return Status;
diff --git a/SamsungPlatformPkg/ExynosPkg/Exynos5250/Drivers/eMMCDxe/eMMCDxe.h b/SamsungPlatformPkg/ExynosPkg/Exynos5250/Drivers/eMMCDxe/eMMCDxe.h
index 9bbf13a2..e410d669 100755
--- a/SamsungPlatformPkg/ExynosPkg/Exynos5250/Drivers/eMMCDxe/eMMCDxe.h
+++ b/SamsungPlatformPkg/ExynosPkg/Exynos5250/Drivers/eMMCDxe/eMMCDxe.h
@@ -65,7 +65,7 @@ NV data for general purpose : 3400
 #define BLEN_512BYTES	(0x200)
 #define BLKSIZE_1	        (0x1)
 
-#define OM_EMMC 0x28
+#define OM_EMMC 0x8
 
 #define MAX_RETRY_COUNT  (100000)
 #define MMC_REFERENCE_CLK (96000000)
diff --git a/SamsungPlatformPkg/ExynosPkg/Exynos5250/Sec/SecEntryPoint.S b/SamsungPlatformPkg/ExynosPkg/Exynos5250/Sec/SecEntryPoint.S
index a10eae12..08a893cb 100644
--- a/SamsungPlatformPkg/ExynosPkg/Exynos5250/Sec/SecEntryPoint.S
+++ b/SamsungPlatformPkg/ExynosPkg/Exynos5250/Sec/SecEntryPoint.S
@@ -198,7 +198,7 @@ _CopyFirmware:
   ldr r1, [r0,#0x0]
   bic r2, r1, #0xffffffc1
 
-  cmp r2, #0x28
+  cmp r2, #0x8
   beq _CopyFirmwareEMMC
 
   /* SD/MMC BOOT */
diff --git a/SamsungPlatformPkgOrigen/ExynosPkg/Library/SerialPortLib/SerialPortLib.c b/SamsungPlatformPkgOrigen/ExynosPkg/Library/SerialPortLib/SerialPortLib.c
index 328956fb..548330e6 100644
--- a/SamsungPlatformPkgOrigen/ExynosPkg/Library/SerialPortLib/SerialPortLib.c
+++ b/SamsungPlatformPkgOrigen/ExynosPkg/Library/SerialPortLib/SerialPortLib.c
@@ -148,57 +148,3 @@ SerialPortPoll (
 	return ((MmioRead32 (UARTConsoleBase + UTRSTAT_OFFSET) & UART_RX_EMPTY_FLAG_MASK) != 0);
 }
 
-/**
-  Set the serial device control bits.
-
-  @return    Always return EFI_UNSUPPORTED.
-
-**/
-RETURN_STATUS
-EFIAPI
-SerialPortSetControl (
-  IN UINT32                   Control
-  )
-{
-  return RETURN_SUCCESS;
-}
-
-/**
-  Get the serial device control bits.
-
-  @param  Control                 Control signals read from the serial device.
-
-  @retval EFI_SUCCESS             The control bits were read from the serial device.
-  @retval EFI_DEVICE_ERROR        The serial device is not functioning correctly.
-
-**/
-RETURN_STATUS
-EFIAPI
-SerialPortGetControl (
-  OUT UINT32                  *Control
-  )
-{
-  return RETURN_SUCCESS;
-}
-
-
-/**
-  Set the serial device attributes.
-
-  @return    Always return EFI_UNSUPPORTED.
-
-**/
-RETURN_STATUS
-EFIAPI
-SerialPortSetAttributes (
-  IN UINT64              BaudRate,
-  IN UINT32              ReceiveFifoDepth,
-  IN UINT32              Timeout,
-  IN EFI_PARITY_TYPE     Parity,
-  IN UINT8               DataBits,
-  IN EFI_STOP_BITS_TYPE  StopBits
-  )
-{
-  return RETURN_SUCCESS;
-}
-
diff --git a/SamsungPlatformPkgOrigen/ExynosPkg/Library/SerialPortLib/SerialPortLib.inf b/SamsungPlatformPkgOrigen/ExynosPkg/Library/SerialPortLib/SerialPortLib.inf
index e9a520d8..73349aa7 100644
--- a/SamsungPlatformPkgOrigen/ExynosPkg/Library/SerialPortLib/SerialPortLib.inf
+++ b/SamsungPlatformPkgOrigen/ExynosPkg/Library/SerialPortLib/SerialPortLib.inf
@@ -17,7 +17,7 @@
   INF_VERSION                    = 0x00010005
   BASE_NAME                      = SerialPortLib
   FILE_GUID                      = 8ecefc8f-a2c4-4091-b80f-20f7aeb0567f
-  MODULE_TYPE                    = PEIM
+  MODULE_TYPE                    = BASE
   VERSION_STRING                 = 1.0
   LIBRARY_CLASS                  = SerialPortLib
 
diff --git a/SamsungPlatformPkgOrigen/OrigenBoardPkg/OrigenBoardPkg-Exynos.dsc b/SamsungPlatformPkgOrigen/OrigenBoardPkg/OrigenBoardPkg-Exynos.dsc
index a6a96aa5..be958729 100644
--- a/SamsungPlatformPkgOrigen/OrigenBoardPkg/OrigenBoardPkg-Exynos.dsc
+++ b/SamsungPlatformPkgOrigen/OrigenBoardPkg/OrigenBoardPkg-Exynos.dsc
@@ -48,6 +48,7 @@
   PrintLib|MdePkg/Library/BasePrintLib/BasePrintLib.inf
   PeCoffGetEntryPointLib|MdePkg/Library/BasePeCoffGetEntryPointLib/BasePeCoffGetEntryPointLib.inf
   CpuExceptionHandlerLib|MdeModulePkg/Library/CpuExceptionHandlerLibNull/CpuExceptionHandlerLibNull.inf
+  ArmSmcLib|ArmPkg/Library/ArmSmcLibNull/ArmSmcLibNull.inf
 
   #
   # Uncomment (and comment out the next line) For RealView Debugger. The Standard IO window
@@ -84,6 +85,7 @@
   PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf
   PeCoffGetEntryPointLib|MdePkg/Library/BasePeCoffGetEntryPointLib/BasePeCoffGetEntryPointLib.inf
   SerialPortLib|SamsungPlatformPkgOrigen/ExynosPkg/Library/SerialPortLib/SerialPortLib.inf
+  SerialPortExtLib|EmbeddedPkg/Library/TemplateSerialPortExtLib/TemplateSerialPortExtLib.inf
   TimerLib|SamsungPlatformPkgOrigen/ExynosPkg/Library/TimerLib/TimerLib.inf
   UefiRuntimeLib|MdePkg/Library/UefiRuntimeLib/UefiRuntimeLib.inf
 
diff --git a/SecurityPkg/Library/DxeImageVerificationLib/DxeImageVerificationLib.c b/SecurityPkg/Library/DxeImageVerificationLib/DxeImageVerificationLib.c
index 3b4fc57c..5bc29cf1 100644
--- a/SecurityPkg/Library/DxeImageVerificationLib/DxeImageVerificationLib.c
+++ b/SecurityPkg/Library/DxeImageVerificationLib/DxeImageVerificationLib.c
@@ -12,7 +12,7 @@
   DxeImageVerificationHandler(), HashPeImageByType(), HashPeImage() function will accept

   untrusted PE/COFF image and validate its data structure within this image buffer before use.

 

-Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -837,7 +837,7 @@ IsSignatureFoundInDatabase (
   //

   CertList = (EFI_SIGNATURE_LIST *) Data;

   while ((DataSize > 0) && (DataSize >= CertList->SignatureListSize)) {

-    CertCount = (CertList->SignatureListSize - CertList->SignatureHeaderSize) / CertList->SignatureSize;

+    CertCount = (CertList->SignatureListSize - sizeof (EFI_SIGNATURE_LIST) - CertList->SignatureHeaderSize) / CertList->SignatureSize;

     Cert      = (EFI_SIGNATURE_DATA *) ((UINT8 *) CertList + sizeof (EFI_SIGNATURE_LIST) + CertList->SignatureHeaderSize);

     if ((CertList->SignatureSize == sizeof(EFI_SIGNATURE_DATA) - 1 + SignatureSize) && (CompareGuid(&CertList->SignatureType, CertType))) {

       for (Index = 0; Index < CertCount; Index++) {

@@ -967,43 +967,6 @@ Done:
 }

 

 /**

-  Verify certificate in WIN_CERT_TYPE_PKCS_SIGNED_DATA format.

-

-  @param[in]  AuthData      Pointer to the Authenticode Signature retrieved from signed image.

-  @param[in]  AuthDataSize  Size of the Authenticode Signature in bytes.

-

-  @retval EFI_SUCCESS                 Image pass verification.

-  @retval EFI_SECURITY_VIOLATION      Image fail verification.

-

-**/

-EFI_STATUS

-VerifyCertPkcsSignedData (

-  IN UINT8              *AuthData,

-  IN UINTN              AuthDataSize

-  )

-{

-  //

-  // 1: Find certificate from DBX forbidden database for revoked certificate.

-  //

-  if (IsPkcsSignedDataVerifiedBySignatureList (AuthData, AuthDataSize, EFI_IMAGE_SECURITY_DATABASE1, &gEfiImageSecurityDatabaseGuid)) {

-    //

-    // DBX is forbidden database, if Authenticode verification pass with

-    // one of the certificate in DBX, this image should be rejected.

-    //

-    return EFI_SECURITY_VIOLATION;

-  }

-

-  //

-  // 2: Find certificate from DB database and try to verify authenticode struct.

-  //

-  if (IsPkcsSignedDataVerifiedBySignatureList (AuthData, AuthDataSize, EFI_IMAGE_SECURITY_DATABASE, &gEfiImageSecurityDatabaseGuid)) {

-    return EFI_SUCCESS;

-  } else {

-    return EFI_SECURITY_VIOLATION;

-  }

-}

-

-/**

   Provide verification service for signed images, which include both signature validation

   and platform policy control. For signature types, both UEFI WIN_CERTIFICATE_UEFI_GUID and

   MSFT Authenticode type signatures are supported.

@@ -1011,25 +974,14 @@ VerifyCertPkcsSignedData (
   In this implementation, only verify external executables when in USER MODE.

   Executables from FV is bypass, so pass in AuthenticationStatus is ignored.

 

-  The image verification process is:

+  The image verification policy is:

     If the image is signed,

-      If the image's certificate verifies against a certificate (root or intermediate) in the allowed 

-      database (DB) and not in the forbidden database (DBX), the certificate verification is passed.

-        If the image's hash digest is in DBX,

-          deny execution.

-        If not,

-          run it.

-      If the Image's certificate verification failed.

-        If the Image's Hash is in DB and not in DBX,

-          run it.

-        Otherwise,

-          deny execution.

+      At least one valid signature or at least one hash value of the image must match a record

+      in the security database "db", and no valid signature nor any hash value of the image may

+      be reflected in the security database "dbx".

     Otherwise, the image is not signed,

-      Is the Image's Hash in DBX?

-        If yes, deny execution.

-        If not, is the Image's Hash in DB?

-          If yes, run it.

-          If not, deny execution.

+      The SHA256 hash value of the image must match a record in the security database "db", and

+      not be reflected in the security data base "dbx".

 

   Caution: This function may receive untrusted input.

   PE/COFF image is external input, so this function will validate its data structure

@@ -1084,12 +1036,12 @@ DxeImageVerificationHandler (
   UINT8                                *SecureBoot;

   PE_COFF_LOADER_IMAGE_CONTEXT         ImageContext;

   UINT32                               NumberOfRvaAndSizes;

-  UINT32                               CertSize;

   WIN_CERTIFICATE_EFI_PKCS             *PkcsCertData;

   WIN_CERTIFICATE_UEFI_GUID            *WinCertUefiGuid;

   UINT8                                *AuthData;

   UINTN                                AuthDataSize;

   EFI_IMAGE_DATA_DIRECTORY             *SecDataDir;

+  UINT32                               OffSet;

 

   SignatureList     = NULL;

   SignatureListSize = 0;

@@ -1098,6 +1050,8 @@ DxeImageVerificationHandler (
   PkcsCertData      = NULL;

   Action            = EFI_IMAGE_EXECUTION_AUTH_UNTESTED;

   Status            = EFI_ACCESS_DENIED;

+  VerifyStatus      = EFI_ACCESS_DENIED;

+

   //

   // Check the image type and get policy setting.

   //

@@ -1230,9 +1184,13 @@ DxeImageVerificationHandler (
     }

   }

 

-  if ((SecDataDir == NULL) || ((SecDataDir != NULL) && (SecDataDir->Size == 0))) {

+  //

+  // Start Image Validation.

+  //

+  if (SecDataDir == NULL || SecDataDir->Size == 0) {

     //

-    // This image is not signed.

+    // This image is not signed. The SHA256 hash value of the image must match a record in the security database "db", 

+    // and not be reflected in the security data base "dbx".

     //

     if (!HashPeImage (HASHALG_SHA256)) {

       goto Done;

@@ -1259,109 +1217,118 @@ DxeImageVerificationHandler (
   }

 

   //

-  // Verify signature of executables.

+  // Verify the signature of the image, multiple signatures are allowed as per PE/COFF Section 4.7 

+  // "Attribute Certificate Table".

+  // The first certificate starts at offset (SecDataDir->VirtualAddress) from the start of the file.

   //

-  WinCertificate = (WIN_CERTIFICATE *) (mImageBase + SecDataDir->VirtualAddress);

-

-  CertSize = sizeof (WIN_CERTIFICATE);

-

-  if ((SecDataDir->Size <= CertSize) || (SecDataDir->Size < WinCertificate->dwLength)) {

-    goto Done;

-  }

-

-  //

-  // Verify the image's Authenticode signature, only DER-encoded PKCS#7 signed data is supported.

-  //

-  if (WinCertificate->wCertificateType == WIN_CERT_TYPE_PKCS_SIGNED_DATA) {

+  for (OffSet = SecDataDir->VirtualAddress;

+       OffSet < (SecDataDir->VirtualAddress + SecDataDir->Size);

+       OffSet += WinCertificate->dwLength, OffSet += ALIGN_SIZE (OffSet)) {

+    WinCertificate = (WIN_CERTIFICATE *) (mImageBase + OffSet);

+    if ((SecDataDir->VirtualAddress + SecDataDir->Size - OffSet) <= sizeof (WIN_CERTIFICATE) ||

+        (SecDataDir->VirtualAddress + SecDataDir->Size - OffSet) < WinCertificate->dwLength) {

+      break;

+    }

+    

     //

-    // The certificate is formatted as WIN_CERTIFICATE_EFI_PKCS which is described in the 

-    // Authenticode specification.

+    // Verify the image's Authenticode signature, only DER-encoded PKCS#7 signed data is supported.

     //

-    PkcsCertData = (WIN_CERTIFICATE_EFI_PKCS *) WinCertificate;

-    if (PkcsCertData->Hdr.dwLength <= sizeof (PkcsCertData->Hdr)) {

-      goto Done;

+    if (WinCertificate->wCertificateType == WIN_CERT_TYPE_PKCS_SIGNED_DATA) {

+      //

+      // The certificate is formatted as WIN_CERTIFICATE_EFI_PKCS which is described in the 

+      // Authenticode specification.

+      //

+      PkcsCertData = (WIN_CERTIFICATE_EFI_PKCS *) WinCertificate;

+      if (PkcsCertData->Hdr.dwLength <= sizeof (PkcsCertData->Hdr)) {

+        break;

+      }

+      AuthData   = PkcsCertData->CertData;

+      AuthDataSize = PkcsCertData->Hdr.dwLength - sizeof(PkcsCertData->Hdr);

+    } else if (WinCertificate->wCertificateType == WIN_CERT_TYPE_EFI_GUID) {

+      //

+      // The certificate is formatted as WIN_CERTIFICATE_UEFI_GUID which is described in UEFI Spec.

+      //

+      WinCertUefiGuid = (WIN_CERTIFICATE_UEFI_GUID *) WinCertificate;

+      if (WinCertUefiGuid->Hdr.dwLength <= OFFSET_OF(WIN_CERTIFICATE_UEFI_GUID, CertData)) {

+        break;

+      }

+      if (!CompareGuid (&WinCertUefiGuid->CertType, &gEfiCertPkcs7Guid)) {

+        continue;

+      }

+      AuthData = WinCertUefiGuid->CertData;

+      AuthDataSize = WinCertUefiGuid->Hdr.dwLength - OFFSET_OF(WIN_CERTIFICATE_UEFI_GUID, CertData);

+    } else {

+      if (WinCertificate->dwLength < sizeof (WIN_CERTIFICATE)) {

+        break;

+      }

+      continue;

     }

-    AuthData   = PkcsCertData->CertData;

-    AuthDataSize = PkcsCertData->Hdr.dwLength - sizeof(PkcsCertData->Hdr);

-    

+

     Status = HashPeImageByType (AuthData, AuthDataSize);

     if (EFI_ERROR (Status)) {

-      goto Done;

+      continue;

     }

-

-    VerifyStatus = VerifyCertPkcsSignedData (AuthData, AuthDataSize);

-  } else if (WinCertificate->wCertificateType == WIN_CERT_TYPE_EFI_GUID) {

+    

     //

-    // The certificate is formatted as WIN_CERTIFICATE_UEFI_GUID which is described in UEFI Spec.

+    // Check the digital signature against the revoked certificate in forbidden database (dbx).

     //

-    WinCertUefiGuid = (WIN_CERTIFICATE_UEFI_GUID *) WinCertificate;

-    if (!CompareGuid(&WinCertUefiGuid->CertType, &gEfiCertPkcs7Guid) ||

-        (WinCertUefiGuid->Hdr.dwLength <= OFFSET_OF(WIN_CERTIFICATE_UEFI_GUID, CertData))) {

-      goto Done;

-    }

-    AuthData = WinCertUefiGuid->CertData;

-    AuthDataSize = WinCertUefiGuid->Hdr.dwLength - OFFSET_OF(WIN_CERTIFICATE_UEFI_GUID, CertData);

-    

-    Status = HashPeImageByType (AuthData, AuthDataSize);

-    if (EFI_ERROR (Status)) {

-      goto Done;

+    if (IsPkcsSignedDataVerifiedBySignatureList (AuthData, AuthDataSize, EFI_IMAGE_SECURITY_DATABASE1, &gEfiImageSecurityDatabaseGuid)) {

+      Action = EFI_IMAGE_EXECUTION_AUTH_SIG_FAILED;

+      VerifyStatus = EFI_ACCESS_DENIED;

+      break;

     }

-    VerifyStatus = VerifyCertPkcsSignedData (AuthData, AuthDataSize);

-  } else {

-    goto Done;

-  }

 

-  if (!EFI_ERROR (VerifyStatus)) {

     //

-    // Verification is passed.

-    // Continue to check the image digest in signature database.

+    // Check the digital signature against the valid certificate in allowed database (db).

     //

-    if (IsSignatureFoundInDatabase (EFI_IMAGE_SECURITY_DATABASE1, mImageDigest, &mCertType, mImageDigestSize)) {

-      //

-      // Executable signature verification passes, but is found in forbidden signature database.

-      //

-      Action = EFI_IMAGE_EXECUTION_AUTH_SIG_FOUND;

-      Status = EFI_ACCESS_DENIED;

-    } else {

-      //

-      // For image verification against enrolled X.509 certificate(root or intermediate),

-      // no need to check image's hash in the allowed database.

-      //

-      return EFI_SUCCESS;

+    if (EFI_ERROR (VerifyStatus)) {

+      if (IsPkcsSignedDataVerifiedBySignatureList (AuthData, AuthDataSize, EFI_IMAGE_SECURITY_DATABASE, &gEfiImageSecurityDatabaseGuid)) {

+        VerifyStatus = EFI_SUCCESS;

+      }

     }

-  } else {

+

     //

-    // Verification failure.

+    // Check the image's hash value.

     //

-    if (!IsSignatureFoundInDatabase (EFI_IMAGE_SECURITY_DATABASE1, mImageDigest, &mCertType, mImageDigestSize) &&

-        IsSignatureFoundInDatabase (EFI_IMAGE_SECURITY_DATABASE, mImageDigest, &mCertType, mImageDigestSize)) {

-      //

-      // Verification fail, Image Hash is not in forbidden database (DBX),

-      // and Image Hash is in allowed database (DB).

-      //

-      Status = EFI_SUCCESS;

-    } else {

-      Action = EFI_IMAGE_EXECUTION_AUTH_SIG_FAILED;

-      Status = EFI_ACCESS_DENIED;

+    if (IsSignatureFoundInDatabase (EFI_IMAGE_SECURITY_DATABASE1, mImageDigest, &mCertType, mImageDigestSize)) {

+      Action = EFI_IMAGE_EXECUTION_AUTH_SIG_FOUND;

+      VerifyStatus = EFI_ACCESS_DENIED;

+      break;

+    } else if (EFI_ERROR (VerifyStatus)) {

+      if (IsSignatureFoundInDatabase (EFI_IMAGE_SECURITY_DATABASE, mImageDigest, &mCertType, mImageDigestSize)) {

+        VerifyStatus = EFI_SUCCESS;

+      }

     }

   }

 

-  if (EFI_ERROR (Status)) {

+  if (OffSet != (SecDataDir->VirtualAddress + SecDataDir->Size)) {

     //

-    // Get image hash value as executable's signature.

+    // The Size in Certificate Table or the attribute certicate table is corrupted.

     //

-    SignatureListSize = sizeof (EFI_SIGNATURE_LIST) + sizeof (EFI_SIGNATURE_DATA) - 1 + mImageDigestSize;

-    SignatureList     = (EFI_SIGNATURE_LIST *) AllocateZeroPool (SignatureListSize);

-    if (SignatureList == NULL) {

-      Status = EFI_OUT_OF_RESOURCES;

-      goto Done;

+    VerifyStatus = EFI_ACCESS_DENIED;

+  }

+  

+  if (!EFI_ERROR (VerifyStatus)) {

+    return EFI_SUCCESS;

+  } else {

+    Status = EFI_ACCESS_DENIED;

+    if (Action == EFI_IMAGE_EXECUTION_AUTH_SIG_FAILED || Action == EFI_IMAGE_EXECUTION_AUTH_SIG_FOUND) {

+      //

+      // Get image hash value as executable's signature.

+      //

+      SignatureListSize = sizeof (EFI_SIGNATURE_LIST) + sizeof (EFI_SIGNATURE_DATA) - 1 + mImageDigestSize;

+      SignatureList     = (EFI_SIGNATURE_LIST *) AllocateZeroPool (SignatureListSize);

+      if (SignatureList == NULL) {

+        Status = EFI_OUT_OF_RESOURCES;

+        goto Done;

+      }

+      SignatureList->SignatureHeaderSize  = 0;

+      SignatureList->SignatureListSize    = (UINT32) SignatureListSize;

+      SignatureList->SignatureSize        = (UINT32) mImageDigestSize;

+      CopyMem (&SignatureList->SignatureType, &mCertType, sizeof (EFI_GUID));

+      Signature = (EFI_SIGNATURE_DATA *) ((UINT8 *) SignatureList + sizeof (EFI_SIGNATURE_LIST));

+      CopyMem (Signature->SignatureData, mImageDigest, mImageDigestSize);

     }

-    SignatureList->SignatureHeaderSize  = 0;

-    SignatureList->SignatureListSize    = (UINT32) SignatureListSize;

-    SignatureList->SignatureSize        = (UINT32) mImageDigestSize;

-    CopyMem (&SignatureList->SignatureType, &mCertType, sizeof (EFI_GUID));

-    Signature = (EFI_SIGNATURE_DATA *) ((UINT8 *) SignatureList + sizeof (EFI_SIGNATURE_LIST));

-    CopyMem (Signature->SignatureData, mImageDigest, mImageDigestSize);

   }

 

 Done:

diff --git a/SecurityPkg/Library/DxeImageVerificationLib/DxeImageVerificationLib.h b/SecurityPkg/Library/DxeImageVerificationLib/DxeImageVerificationLib.h
index 55371e90..9aef601c 100644
--- a/SecurityPkg/Library/DxeImageVerificationLib/DxeImageVerificationLib.h
+++ b/SecurityPkg/Library/DxeImageVerificationLib/DxeImageVerificationLib.h
@@ -2,7 +2,7 @@
   The internal header file includes the common header files, defines

   internal structure and functions used by ImageVerificationLib.

 

-Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials 

 are licensed and made available under the terms and conditions of the BSD License 

 which accompanies this distribution.  The full text of the license may be found at 

@@ -43,6 +43,9 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 #define MAX_NOTIFY_STRING_LEN             64

 #define TWO_BYTE_ENCODE                   0x82

 

+#define ALIGNMENT_SIZE                    8

+#define ALIGN_SIZE(a) (((a) % ALIGNMENT_SIZE) ? ALIGNMENT_SIZE - ((a) % ALIGNMENT_SIZE) : 0)

+

 //

 // Image type definitions

 //

diff --git a/SecurityPkg/Library/DxeTcgPhysicalPresenceLib/DxeTcgPhysicalPresenceLib.c b/SecurityPkg/Library/DxeTcgPhysicalPresenceLib/DxeTcgPhysicalPresenceLib.c
index 44845b0f..3414cd2e 100644
--- a/SecurityPkg/Library/DxeTcgPhysicalPresenceLib/DxeTcgPhysicalPresenceLib.c
+++ b/SecurityPkg/Library/DxeTcgPhysicalPresenceLib/DxeTcgPhysicalPresenceLib.c
@@ -8,7 +8,7 @@
 

   ExecutePendingTpmRequest() will receive untrusted input and do validation.

 

-Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials 

 are licensed and made available under the terms and conditions of the BSD License 

 which accompanies this distribution.  The full text of the license may be found at 

@@ -1010,13 +1010,6 @@ ExecutePendingTpmRequest (
   UINTN                             DataSize;

   BOOLEAN                           RequestConfirmed;

 

-  if (TcgPpData->PPRequest == PHYSICAL_PRESENCE_NO_ACTION) {

-    //

-    // No operation request

-    //

-    return;

-  }

-

   if (!HaveValidTpmRequest(TcgPpData, &RequestConfirmed)) {

     //

     // Invalid operation request.

@@ -1165,6 +1158,13 @@ TcgPhysicalPresenceLibProcessRequest (
 

   DEBUG ((EFI_D_INFO, "[TPM] Flags=%x, PPRequest=%x\n", TcgPpData.Flags, TcgPpData.PPRequest));

 

+  if (TcgPpData.PPRequest == PHYSICAL_PRESENCE_NO_ACTION) {

+    //

+    // No operation request

+    //

+    return;

+  }

+

   Status = GetTpmCapability (TcgProtocol, &LifetimeLock, &CmdEnable);

   if (EFI_ERROR (Status)) {

     return ;

diff --git a/SecurityPkg/VariableAuthenticated/Pei/Variable.c b/SecurityPkg/VariableAuthenticated/Pei/Variable.c
index d27f6790..38b9170a 100644
--- a/SecurityPkg/VariableAuthenticated/Pei/Variable.c
+++ b/SecurityPkg/VariableAuthenticated/Pei/Variable.c
@@ -3,7 +3,7 @@
   ReadOnly Varaiable2 PPI. These services operates the non-volatile 

   storage space.

 

-Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials 

 are licensed and made available under the terms and conditions of the BSD License 

 which accompanies this distribution.  The full text of the license may be found at 

@@ -428,6 +428,7 @@ FindVariableEx (
   UINTN                   Index;

   UINTN                   Offset;

   BOOLEAN                 StopRecord;

+  VARIABLE_HEADER         *InDeletedVariable;

 

   if (VariableStoreHeader == NULL) {

     return EFI_INVALID_PARAMETER;

@@ -444,6 +445,8 @@ FindVariableEx (
   PtrTrack->StartPtr = GetStartPointer (VariableStoreHeader);

   PtrTrack->EndPtr   = GetEndPointer   (VariableStoreHeader);

 

+  InDeletedVariable = NULL;

+

   //

   // No Variable Address equals zero, so 0 as initial value is safe.

   //

@@ -459,15 +462,20 @@ FindVariableEx (
       Offset   += IndexTable->Index[Index];

       MaxIndex  = (VARIABLE_HEADER *) ((UINT8 *) IndexTable->StartPtr + Offset);

       if (CompareWithValidVariable (MaxIndex, VariableName, VendorGuid, PtrTrack) == EFI_SUCCESS) {

-        return EFI_SUCCESS;

+        if (PtrTrack->CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

+          InDeletedVariable = PtrTrack->CurrPtr;

+        } else {

+          return EFI_SUCCESS;

+        }

       }

     }

 

     if (IndexTable->GoneThrough != 0) {

       //

-      // If the table has all the existing variables indexed and we still cannot find it.

+      // If the table has all the existing variables indexed, return.

       //

-      return EFI_NOT_FOUND;

+      PtrTrack->CurrPtr = InDeletedVariable;

+      return (PtrTrack->CurrPtr == NULL) ? EFI_NOT_FOUND : EFI_SUCCESS;

     }

   }

 

@@ -488,11 +496,11 @@ FindVariableEx (
   }

 

   //

-  // Find the variable by walk through non-volatile variable store

+  // Find the variable by walk through variable store

   //

   StopRecord = FALSE;

   while ((Variable < PtrTrack->EndPtr) && IsValidVariableHeader (Variable)) {

-    if (Variable->State == VAR_ADDED) {

+    if (Variable->State == VAR_ADDED || Variable->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

       //

       // Record Variable in VariableIndex HOB

       //

@@ -511,7 +519,11 @@ FindVariableEx (
       }

 

       if (CompareWithValidVariable (Variable, VariableName, VendorGuid, PtrTrack) == EFI_SUCCESS) {

-        return EFI_SUCCESS;

+        if (PtrTrack->CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

+          InDeletedVariable = PtrTrack->CurrPtr;

+        } else {

+          return EFI_SUCCESS;

+        }

       }

     }

 

@@ -524,9 +536,9 @@ FindVariableEx (
     IndexTable->GoneThrough = 1;

   }

 

-  PtrTrack->CurrPtr = NULL;

+  PtrTrack->CurrPtr = InDeletedVariable;

 

-  return EFI_NOT_FOUND;

+  return (PtrTrack->CurrPtr == NULL) ? EFI_NOT_FOUND : EFI_SUCCESS;

 }

 

 /**

@@ -689,6 +701,8 @@ PeiGetNextVariableName (
   VARIABLE_STORE_TYPE     Type;

   VARIABLE_POINTER_TRACK  Variable;

   VARIABLE_POINTER_TRACK  VariableInHob;

+  VARIABLE_POINTER_TRACK  VariablePtrTrack;

+  VARIABLE_INDEX_TABLE    *IndexTable;

   UINTN                   VarNameSize;

   EFI_STATUS              Status;

   VARIABLE_STORE_HEADER   *VariableStoreHeader[VariableStoreTypeMax];

@@ -750,7 +764,32 @@ PeiGetNextVariableName (
       Variable.CurrPtr  = Variable.StartPtr;

     }

 

-    if (Variable.CurrPtr->State == VAR_ADDED) {

+    if (Variable.CurrPtr->State == VAR_ADDED || Variable.CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

+      if (Variable.CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

+        //

+        // If it is a IN_DELETED_TRANSITION variable,

+        // and there is also a same ADDED one at the same time,

+        // don't return it.

+        //

+        for (Type = (VARIABLE_STORE_TYPE) 0; Type < VariableStoreTypeMax; Type++) {

+          if ((VariableStoreHeader[Type] != NULL) && (Variable.StartPtr == GetStartPointer (VariableStoreHeader[Type]))) {

+            break;

+          }

+        }

+        ASSERT (Type < VariableStoreTypeMax);

+        GetVariableStore (Type, &IndexTable);

+        Status = FindVariableEx (

+                   VariableStoreHeader[Type],

+                   IndexTable,

+                   GetVariableNamePtr (Variable.CurrPtr),

+                   &Variable.CurrPtr->VendorGuid,

+                   &VariablePtrTrack

+                   );

+        if (!EFI_ERROR (Status) && VariablePtrTrack.CurrPtr->State == VAR_ADDED) {

+          Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);

+          continue;

+        }

+      }

 

       //

       // Don't return NV variable when HOB overrides it

diff --git a/SecurityPkg/VariableAuthenticated/RuntimeDxe/AuthService.c b/SecurityPkg/VariableAuthenticated/RuntimeDxe/AuthService.c
index 64ce968a..6f8808a7 100644
--- a/SecurityPkg/VariableAuthenticated/RuntimeDxe/AuthService.c
+++ b/SecurityPkg/VariableAuthenticated/RuntimeDxe/AuthService.c
@@ -15,7 +15,7 @@
   They will do basic validation for authentication data structure, then call crypto library

   to verify the signature.

 

-Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -356,30 +356,23 @@ AutenticatedVariableServiceInitialize (
   DEBUG ((EFI_D_INFO, "Variable %s is %x\n", EFI_SECURE_BOOT_ENABLE_NAME, SecureBootEnable));

 

   //

-  // Check "CustomMode" variable's existence.

+  // Initialize "CustomMode" in STANDARD_SECURE_BOOT_MODE state.

   //

   FindVariable (EFI_CUSTOM_MODE_NAME, &gEfiCustomModeEnableGuid, &Variable, &mVariableModuleGlobal->VariableGlobal, FALSE);

-  if (Variable.CurrPtr != NULL) {

-    CustomMode = *(GetVariableDataPtr (Variable.CurrPtr));

-  } else {

-    //

-    // "CustomMode" not exist, initialize it in STANDARD_SECURE_BOOT_MODE.

-    //

-    CustomMode = STANDARD_SECURE_BOOT_MODE;

-    Status = UpdateVariable (

-               EFI_CUSTOM_MODE_NAME,

-               &gEfiCustomModeEnableGuid,

-               &CustomMode,

-               sizeof (UINT8),

-               EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,

-               0,

-               0,

-               &Variable,

-               NULL

-               );

-    if (EFI_ERROR (Status)) {

-      return Status;

-    }

+  CustomMode = STANDARD_SECURE_BOOT_MODE;

+  Status = UpdateVariable (

+             EFI_CUSTOM_MODE_NAME,

+             &gEfiCustomModeEnableGuid,

+             &CustomMode,

+             sizeof (UINT8),

+             EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,

+             0,

+             0,

+             &Variable,

+             NULL

+             );

+  if (EFI_ERROR (Status)) {

+    return Status;

   }

   

   DEBUG ((EFI_D_INFO, "Variable %s is %x\n", EFI_CUSTOM_MODE_NAME, CustomMode));

@@ -437,6 +430,8 @@ AddPubKeyInStore (
   UINT32                  Index;

   VARIABLE_POINTER_TRACK  Variable;

   UINT8                   *Ptr;

+  UINT8                   *Data;

+  UINTN                   DataSize;

 

   if (PubKey == NULL) {

     return 0;

@@ -450,6 +445,10 @@ AddPubKeyInStore (
              FALSE

              );

   ASSERT_EFI_ERROR (Status);

+  if (EFI_ERROR (Status)) {

+    return 0;

+  }

+

   //

   // Check whether the public key entry does exist.

   //

@@ -468,9 +467,48 @@ AddPubKeyInStore (
     //

     if (mPubKeyNumber == MAX_KEY_NUM) {

       //

-      // Notes: Database is full, need enhancement here, currently just return 0.

+      // Public key dadatase is full, try to reclaim invalid key.

       //

-      return 0;

+      if (AtRuntime ()) {

+        //

+        // NV storage can't reclaim at runtime.

+        //

+        return 0;

+      }

+      

+      Status = Reclaim (

+                 mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,

+                 &mVariableModuleGlobal->NonVolatileLastVariableOffset,

+                 FALSE,

+                 NULL,

+                 TRUE,

+                 TRUE

+                 );

+      if (EFI_ERROR (Status)) {

+        return 0;

+      }

+

+      Status = FindVariable (

+                 AUTHVAR_KEYDB_NAME,

+                 &gEfiAuthenticatedVariableGuid,

+                 &Variable,

+                 &mVariableModuleGlobal->VariableGlobal,

+                 FALSE

+                 );

+      ASSERT_EFI_ERROR (Status);

+      if (EFI_ERROR (Status)) {

+        return 0;

+      }

+

+      DataSize  = DataSizeOfVariable (Variable.CurrPtr);

+      Data      = GetVariableDataPtr (Variable.CurrPtr);

+      ASSERT ((DataSize != 0) && (Data != NULL));

+      CopyMem (mPubKeyStore, (UINT8 *) Data, DataSize);

+      mPubKeyNumber = (UINT32) (DataSize / EFI_CERT_TYPE_RSA2048_SIZE);

+

+      if (mPubKeyNumber == MAX_KEY_NUM) {

+        return 0;

+      }     

     }

 

     CopyMem (mPubKeyStore + mPubKeyNumber * EFI_CERT_TYPE_RSA2048_SIZE, PubKey, EFI_CERT_TYPE_RSA2048_SIZE);

diff --git a/SecurityPkg/VariableAuthenticated/RuntimeDxe/Variable.c b/SecurityPkg/VariableAuthenticated/RuntimeDxe/Variable.c
index 5f023dfd..1595c8c2 100644
--- a/SecurityPkg/VariableAuthenticated/RuntimeDxe/Variable.c
+++ b/SecurityPkg/VariableAuthenticated/RuntimeDxe/Variable.c
@@ -16,7 +16,7 @@
   VariableServiceSetVariable() should also check authenticate data to avoid buffer overflow,

   integer overflow. It should also check attribute to avoid authentication bypass.

 

-Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -511,30 +511,168 @@ GetEndPointer (
   return (VARIABLE_HEADER *) HEADER_ALIGN ((UINTN) VarStoreHeader + VarStoreHeader->Size);

 }

 

+/**

+

+  Check the PubKeyIndex is a valid key or not.

+

+  This function will iterate the NV storage to see if this PubKeyIndex is still referenced 

+  by any valid count-based auth variabe.

+  

+  @param[in]  PubKeyIndex     Index of the public key in public key store.

+

+  @retval     TRUE            The PubKeyIndex is still in use.

+  @retval     FALSE           The PubKeyIndex is not referenced by any count-based auth variabe.

+  

+**/

+BOOLEAN

+IsValidPubKeyIndex (

+  IN   UINT32      PubKeyIndex

+  )

+{

+  VARIABLE_HEADER          *Variable;

+

+  if (PubKeyIndex > mPubKeyNumber) {

+    return FALSE;

+  }

+  

+  Variable = GetStartPointer (mNvVariableCache);

+  

+  while (IsValidVariableHeader (Variable)) {

+    if ((Variable->State == VAR_ADDED || Variable->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) && 

+        Variable->PubKeyIndex == PubKeyIndex) {

+      return TRUE;

+    }

+    Variable = GetNextVariablePtr (Variable);

+  }

+  

+  return FALSE;

+}

 

 /**

 

-  Variable store garbage collection and reclaim operation.

+  Get the number of valid public key in PubKeyStore.

+  

+  @param[in]  PubKeyNumber     Number of the public key in public key store.

+

+  @return     Number of valid public key in PubKeyStore.

+

+**/

+UINT32

+GetValidPubKeyNumber (

+  IN   UINT32       PubKeyNumber

+  )

+{

+  UINT32       PubKeyIndex;

+  UINT32       Counter;

+

+  Counter = 0;

+  

+  for (PubKeyIndex = 1; PubKeyIndex <= PubKeyNumber; PubKeyIndex++) {

+    if (IsValidPubKeyIndex (PubKeyIndex)) {

+      Counter++;

+    }

+  }

+  

+  return Counter;

+}

+

+/**

+

+  Filter the useless key in public key store.

+

+  This function will find out all valid public keys in public key database, save them in new allocated 

+  buffer NewPubKeyStore, and give the new PubKeyIndex. The caller is responsible for freeing buffer

+  NewPubKeyIndex and NewPubKeyStore with FreePool().

+

+  @param[in]   PubKeyStore          Point to the public key database.

+  @param[in]   PubKeyNumber         Number of the public key in PubKeyStore.

+  @param[out]  NewPubKeyIndex       Point to an array of new PubKeyIndex corresponds to NewPubKeyStore.

+  @param[out]  NewPubKeyStore       Saved all valid public keys in PubKeyStore.

+  @param[out]  NewPubKeySize        Buffer size of the NewPubKeyStore.

+  

+  @retval  EFI_SUCCESS              Trim operation is complete successfully.

+  @retval  EFI_OUT_OF_RESOURCES     No enough memory resources, or no useless key in PubKeyStore.

+  

+**/

+EFI_STATUS

+PubKeyStoreFilter (

+  IN   UINT8         *PubKeyStore,

+  IN   UINT32        PubKeyNumber,

+  OUT  UINT32        **NewPubKeyIndex,

+  OUT  UINT8         **NewPubKeyStore,

+  OUT  UINT32        *NewPubKeySize

+  )

+{

+  UINT32        PubKeyIndex;

+  UINT32        CopiedKey;

+  UINT32        NewPubKeyNumber;

+  

+  NewPubKeyNumber = GetValidPubKeyNumber (PubKeyNumber);

+  if (NewPubKeyNumber == PubKeyNumber) {

+    return EFI_OUT_OF_RESOURCES;

+  }

+

+  if (NewPubKeyNumber != 0) {

+    *NewPubKeySize = NewPubKeyNumber * EFI_CERT_TYPE_RSA2048_SIZE;

+  } else {

+    *NewPubKeySize = sizeof (UINT8);

+  }

+

+  *NewPubKeyStore = AllocatePool (*NewPubKeySize);

+  if (*NewPubKeyStore == NULL) {

+    return EFI_OUT_OF_RESOURCES;

+  }

 

-  @param VariableBase            Base address of variable store.

-  @param LastVariableOffset      Offset of last variable.

-  @param IsVolatile              The variable store is volatile or not;

-                                 if it is non-volatile, need FTW.

-  @param UpdatingVariable        Pointer to updating variable.

-  @param ReclaimAnyway           If TRUE, do reclaim anyway.

+  *NewPubKeyIndex = AllocateZeroPool ((PubKeyNumber + 1) * sizeof (UINT32));

+  if (*NewPubKeyIndex == NULL) {

+    FreePool (*NewPubKeyStore);

+    return EFI_OUT_OF_RESOURCES;

+  }

+

+  CopiedKey = 0;

+  for (PubKeyIndex = 1; PubKeyIndex <= PubKeyNumber; PubKeyIndex++) {

+    if (IsValidPubKeyIndex (PubKeyIndex)) {

+      CopyMem (

+        *NewPubKeyStore + CopiedKey * EFI_CERT_TYPE_RSA2048_SIZE,

+        PubKeyStore + (PubKeyIndex - 1) * EFI_CERT_TYPE_RSA2048_SIZE,

+        EFI_CERT_TYPE_RSA2048_SIZE

+        );

+      (*NewPubKeyIndex)[PubKeyIndex] = ++CopiedKey;

+    }

+  }

+  return EFI_SUCCESS;

+}

 

-  @return EFI_OUT_OF_RESOURCES

-  @return EFI_SUCCESS

-  @return Others

+/**

+

+  Variable store garbage collection and reclaim operation.

+

+  If ReclaimPubKeyStore is FALSE, reclaim variable space by deleting the obsoleted varaibles.

+  If ReclaimPubKeyStore is TRUE, reclaim invalid key in public key database and update the PubKeyIndex

+  for all the count-based authenticate variable in NV storage.

+

+  @param[in]      VariableBase            Base address of variable store.

+  @param[out]     LastVariableOffset      Offset of last variable.

+  @param[in]      IsVolatile              The variable store is volatile or not;

+                                          if it is non-volatile, need FTW.

+  @param[in, out] UpdatingPtrTrack        Pointer to updating variable pointer track structure.

+  @param[in]      ReclaimPubKeyStore      Reclaim for public key database or not.

+  @param[in]      ReclaimAnyway           If TRUE, do reclaim anyway.

+  

+  @return EFI_SUCCESS                  Reclaim operation has finished successfully.

+  @return EFI_OUT_OF_RESOURCES         No enough memory resources.

+  @return EFI_DEVICE_ERROR             The public key database doesn't exist.

+  @return Others                       Unexpect error happened during reclaim operation.

 

 **/

 EFI_STATUS

 Reclaim (

-  IN  EFI_PHYSICAL_ADDRESS  VariableBase,

-  OUT UINTN                 *LastVariableOffset,

-  IN  BOOLEAN               IsVolatile,

-  IN  VARIABLE_HEADER       *UpdatingVariable,

-  IN  BOOLEAN               ReclaimAnyway

+  IN     EFI_PHYSICAL_ADDRESS         VariableBase,

+  OUT    UINTN                        *LastVariableOffset,

+  IN     BOOLEAN                      IsVolatile,

+  IN OUT VARIABLE_POINTER_TRACK       *UpdatingPtrTrack,

+  IN     BOOLEAN                      ReclaimPubKeyStore,

+  IN     BOOLEAN                      ReclaimAnyway

   )

 {

   VARIABLE_HEADER       *Variable;

@@ -557,14 +695,28 @@ Reclaim (
   CHAR16                *UpdatingVariableNamePtr;

   UINTN                 CommonVariableTotalSize;

   UINTN                 HwErrVariableTotalSize;

+  UINT32                *NewPubKeyIndex;

+  UINT8                 *NewPubKeyStore;

+  UINT32                NewPubKeySize;

+  VARIABLE_HEADER       *PubKeyHeader;

   BOOLEAN               NeedDoReclaim;

+  VARIABLE_HEADER       *UpdatingVariable;

+

+  UpdatingVariable = NULL;

+  if (UpdatingPtrTrack != NULL) {

+    UpdatingVariable = UpdatingPtrTrack->CurrPtr;

+  }

 

   NeedDoReclaim = FALSE;

   VariableStoreHeader = (VARIABLE_STORE_HEADER *) ((UINTN) VariableBase);

 

   CommonVariableTotalSize = 0;

   HwErrVariableTotalSize  = 0;

-

+  NewPubKeyIndex = NULL;

+  NewPubKeyStore = NULL;

+  NewPubKeySize  = 0;

+  PubKeyHeader   = NULL;

+  

   //

   // Start Pointers for the variable.

   //

@@ -608,95 +760,97 @@ Reclaim (
   CopyMem (ValidBuffer, VariableStoreHeader, sizeof (VARIABLE_STORE_HEADER));

   CurrPtr = (UINT8 *) GetStartPointer ((VARIABLE_STORE_HEADER *) ValidBuffer);

 

-  //

-  // Reinstall all ADDED variables as long as they are not identical to Updating Variable.

-  //

-  Variable = GetStartPointer (VariableStoreHeader);

-  while (IsValidVariableHeader (Variable)) {

-    NextVariable = GetNextVariablePtr (Variable);

-    if (Variable->State == VAR_ADDED) {

-      if (UpdatingVariable != NULL) {

-        if (UpdatingVariable == Variable) {

-          Variable = NextVariable;

-          continue;

-        }

-

-        VariableNameSize         = NameSizeOfVariable(Variable);

-        UpdatingVariableNameSize = NameSizeOfVariable(UpdatingVariable);

+  if (ReclaimPubKeyStore) {

+    //

+    // Trim the PubKeyStore and get new PubKeyIndex.

+    //

+    Status = PubKeyStoreFilter (

+               mPubKeyStore,

+               mPubKeyNumber,

+               &NewPubKeyIndex,

+               &NewPubKeyStore,

+               &NewPubKeySize

+               );

+    if (EFI_ERROR (Status)) {

+      FreePool (ValidBuffer);

+      return Status;

+    }

 

-        VariableNamePtr         = GetVariableNamePtr (Variable);

-        UpdatingVariableNamePtr = GetVariableNamePtr (UpdatingVariable);

-        if (CompareGuid (&Variable->VendorGuid, &UpdatingVariable->VendorGuid)    &&

-            VariableNameSize == UpdatingVariableNameSize &&

-            CompareMem (VariableNamePtr, UpdatingVariableNamePtr, VariableNameSize) == 0 ) {

+    //

+    // Refresh the PubKeyIndex for all valid variables (ADDED and IN_DELETED_TRANSITION).

+    //

+    Variable = GetStartPointer (mNvVariableCache);

+    while (IsValidVariableHeader (Variable)) {

+      NextVariable = GetNextVariablePtr (Variable);

+      if (Variable->State == VAR_ADDED || Variable->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

+        if ((StrCmp (GetVariableNamePtr (Variable), AUTHVAR_KEYDB_NAME) == 0) && 

+            (CompareGuid (&Variable->VendorGuid, &gEfiAuthenticatedVariableGuid))) {

+          //

+          // Skip the public key database, it will be reinstalled later.

+          //

+          PubKeyHeader = Variable;

           Variable = NextVariable;

           continue;

         }

+        

+        VariableSize = (UINTN) NextVariable - (UINTN) Variable;

+        CopyMem (CurrPtr, (UINT8 *) Variable, VariableSize);

+        ((VARIABLE_HEADER*) CurrPtr)->PubKeyIndex = NewPubKeyIndex[Variable->PubKeyIndex];

+        CurrPtr += VariableSize;

+        if ((!IsVolatile) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {

+          HwErrVariableTotalSize += VariableSize;

+        } else if ((!IsVolatile) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {

+          CommonVariableTotalSize += VariableSize;

+        }

       }

-      VariableSize = (UINTN) NextVariable - (UINTN) Variable;

-      CopyMem (CurrPtr, (UINT8 *) Variable, VariableSize);

-      CurrPtr += VariableSize;

-      if ((!IsVolatile) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {

-        HwErrVariableTotalSize += VariableSize;

-      } else if ((!IsVolatile) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {

-        CommonVariableTotalSize += VariableSize;

-      }

+      Variable = NextVariable;

     }

-    Variable = NextVariable;

-  }

 

-  //

-  // Reinstall the variable being updated if it is not NULL.

-  //

-  if (UpdatingVariable != NULL) {

-    VariableSize = (UINTN)(GetNextVariablePtr (UpdatingVariable)) - (UINTN)UpdatingVariable;

-    CopyMem (CurrPtr, (UINT8 *) UpdatingVariable, VariableSize);

-    CurrPtr += VariableSize;

-    if ((!IsVolatile) && ((UpdatingVariable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {

-        HwErrVariableTotalSize += VariableSize;

-    } else if ((!IsVolatile) && ((UpdatingVariable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {

-        CommonVariableTotalSize += VariableSize;

+    //

+    // Reinstall the new public key database.

+    //

+    ASSERT (PubKeyHeader != NULL);

+    if (PubKeyHeader == NULL) {

+      FreePool (ValidBuffer);

+      FreePool (NewPubKeyIndex);

+      FreePool (NewPubKeyStore);

+      return EFI_DEVICE_ERROR;

     }

-  }

-

-  //

-  // Reinstall all in delete transition variables.

-  //

-  Variable      = GetStartPointer (VariableStoreHeader);

-  while (IsValidVariableHeader (Variable)) {

-    NextVariable = GetNextVariablePtr (Variable);

-    if (Variable != UpdatingVariable && Variable->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

+    CopyMem (CurrPtr, (UINT8*) PubKeyHeader, sizeof (VARIABLE_HEADER));

+    Variable = (VARIABLE_HEADER*) CurrPtr;

+    Variable->DataSize = NewPubKeySize;

+    StrCpy (GetVariableNamePtr (Variable), GetVariableNamePtr (PubKeyHeader));

+    CopyMem (GetVariableDataPtr (Variable), NewPubKeyStore, NewPubKeySize);

+    CurrPtr = (UINT8*) GetNextVariablePtr (Variable); 

+    CommonVariableTotalSize += (UINTN) CurrPtr - (UINTN) Variable;

+  } else {

+    //

+    // Reinstall all ADDED variables as long as they are not identical to Updating Variable.

+    //

+    Variable = GetStartPointer (VariableStoreHeader);

+    while (IsValidVariableHeader (Variable)) {

+      NextVariable = GetNextVariablePtr (Variable);

+      if (Variable->State == VAR_ADDED) {

+        if (UpdatingVariable != NULL) {

+          if (UpdatingVariable == Variable) {

+            Variable = NextVariable;

+            continue;

+          }

 

-      //

-      // Buffer has cached all ADDED variable.

-      // Per IN_DELETED variable, we have to guarantee that

-      // no ADDED one in previous buffer.

-      //

+          VariableNameSize         = NameSizeOfVariable(Variable);

+          UpdatingVariableNameSize = NameSizeOfVariable(UpdatingVariable);

 

-      FoundAdded = FALSE;

-      AddedVariable = GetStartPointer ((VARIABLE_STORE_HEADER *) ValidBuffer);

-      while (IsValidVariableHeader (AddedVariable)) {

-        NextAddedVariable = GetNextVariablePtr (AddedVariable);

-        NameSize = NameSizeOfVariable (AddedVariable);

-        if (CompareGuid (&AddedVariable->VendorGuid, &Variable->VendorGuid) &&

-            NameSize == NameSizeOfVariable (Variable)

-           ) {

-          Point0 = (VOID *) GetVariableNamePtr (AddedVariable);

-          Point1 = (VOID *) GetVariableNamePtr (Variable);

-          if (CompareMem (Point0, Point1, NameSizeOfVariable (AddedVariable)) == 0) {

-            FoundAdded = TRUE;

-            break;

+          VariableNamePtr         = GetVariableNamePtr (Variable);

+          UpdatingVariableNamePtr = GetVariableNamePtr (UpdatingVariable);

+          if (CompareGuid (&Variable->VendorGuid, &UpdatingVariable->VendorGuid)    &&

+              VariableNameSize == UpdatingVariableNameSize &&

+              CompareMem (VariableNamePtr, UpdatingVariableNamePtr, VariableNameSize) == 0 ) {

+            Variable = NextVariable;

+            continue;

           }

         }

-        AddedVariable = NextAddedVariable;

-      }

-      if (!FoundAdded) {

-        //

-        // Promote VAR_IN_DELETED_TRANSITION to VAR_ADDED.

-        //

         VariableSize = (UINTN) NextVariable - (UINTN) Variable;

         CopyMem (CurrPtr, (UINT8 *) Variable, VariableSize);

-        ((VARIABLE_HEADER *) CurrPtr)->State = VAR_ADDED;

         CurrPtr += VariableSize;

         if ((!IsVolatile) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {

           HwErrVariableTotalSize += VariableSize;

@@ -704,9 +858,74 @@ Reclaim (
           CommonVariableTotalSize += VariableSize;

         }

       }

+      Variable = NextVariable;

     }

 

-    Variable = NextVariable;

+    //

+    // Reinstall the variable being updated if it is not NULL.

+    //

+    if (UpdatingVariable != NULL) {

+      VariableSize = (UINTN)(GetNextVariablePtr (UpdatingVariable)) - (UINTN)UpdatingVariable;

+      CopyMem (CurrPtr, (UINT8 *) UpdatingVariable, VariableSize);

+      UpdatingPtrTrack->CurrPtr = (VARIABLE_HEADER *)((UINTN)UpdatingPtrTrack->StartPtr + ((UINTN)CurrPtr - (UINTN)GetStartPointer ((VARIABLE_STORE_HEADER *) ValidBuffer)));

+      UpdatingPtrTrack->InDeletedTransitionPtr = NULL;

+      CurrPtr += VariableSize;

+      if ((!IsVolatile) && ((UpdatingVariable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {

+          HwErrVariableTotalSize += VariableSize;

+      } else if ((!IsVolatile) && ((UpdatingVariable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {

+          CommonVariableTotalSize += VariableSize;

+      }

+    }

+

+    //

+    // Reinstall all in delete transition variables.

+    //

+    Variable      = GetStartPointer (VariableStoreHeader);

+    while (IsValidVariableHeader (Variable)) {

+      NextVariable = GetNextVariablePtr (Variable);

+      if (Variable != UpdatingVariable && Variable->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

+

+        //

+        // Buffer has cached all ADDED variable.

+        // Per IN_DELETED variable, we have to guarantee that

+        // no ADDED one in previous buffer.

+        //

+

+        FoundAdded = FALSE;

+        AddedVariable = GetStartPointer ((VARIABLE_STORE_HEADER *) ValidBuffer);

+        while (IsValidVariableHeader (AddedVariable)) {

+          NextAddedVariable = GetNextVariablePtr (AddedVariable);

+          NameSize = NameSizeOfVariable (AddedVariable);

+          if (CompareGuid (&AddedVariable->VendorGuid, &Variable->VendorGuid) &&

+              NameSize == NameSizeOfVariable (Variable)

+             ) {

+            Point0 = (VOID *) GetVariableNamePtr (AddedVariable);

+            Point1 = (VOID *) GetVariableNamePtr (Variable);

+            if (CompareMem (Point0, Point1, NameSize) == 0) {

+              FoundAdded = TRUE;

+              break;

+            }

+          }

+          AddedVariable = NextAddedVariable;

+        }

+        if (!FoundAdded) {

+          //

+          // Promote VAR_IN_DELETED_TRANSITION to VAR_ADDED.

+          //

+          VariableSize = (UINTN) NextVariable - (UINTN) Variable;

+          CopyMem (CurrPtr, (UINT8 *) Variable, VariableSize);

+          ((VARIABLE_HEADER *) CurrPtr)->State = VAR_ADDED;

+          CurrPtr += VariableSize;

+          if ((!IsVolatile) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) == EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {

+            HwErrVariableTotalSize += VariableSize;

+          } else if ((!IsVolatile) && ((Variable->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != EFI_VARIABLE_HARDWARE_ERROR_RECORD)) {

+            CommonVariableTotalSize += VariableSize;

+          }

+        }

+      }

+

+      Variable = NextVariable;

+    }

   }

 

   if (IsVolatile) {

@@ -748,6 +967,14 @@ Reclaim (
     *LastVariableOffset = (UINTN) NextVariable - (UINTN) VariableBase;

   }

 

+  if (NewPubKeyStore != NULL) {

+    FreePool (NewPubKeyStore);

+  }

+

+  if (NewPubKeyIndex != NULL) {

+    FreePool (NewPubKeyIndex);

+  }

+  

   FreePool (ValidBuffer);

 

   return Status;

@@ -776,6 +1003,8 @@ FindVariableEx (
   VARIABLE_HEADER                *InDeletedVariable;

   VOID                           *Point;

 

+  PtrTrack->InDeletedTransitionPtr = NULL;

+

   //

   // Find the variable by walk through HOB, volatile and non-volatile variable store.

   //

@@ -793,6 +1022,7 @@ FindVariableEx (
           if (PtrTrack->CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

             InDeletedVariable   = PtrTrack->CurrPtr;

           } else {

+            PtrTrack->InDeletedTransitionPtr = InDeletedVariable;

             return EFI_SUCCESS;

           }

         } else {

@@ -804,6 +1034,7 @@ FindVariableEx (
               if (PtrTrack->CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

                 InDeletedVariable     = PtrTrack->CurrPtr;

               } else {

+                PtrTrack->InDeletedTransitionPtr = InDeletedVariable;

                 return EFI_SUCCESS;

               }

             }

@@ -1395,7 +1626,7 @@ AutoUpdateLangVariable (
   @param[in] Attributes         Attributes of the variable.

   @param[in] KeyIndex           Index of associated public key.

   @param[in] MonotonicCount     Value of associated monotonic count.

-  @param[in] CacheVariable      The variable information which is used to keep track of variable usage.

+  @param[in, out] CacheVariable The variable information which is used to keep track of variable usage.

   @param[in] TimeStamp          Value of associated TimeStamp.

 

   @retval EFI_SUCCESS           The update operation is success.

@@ -1411,7 +1642,7 @@ UpdateVariable (
   IN      UINT32                      Attributes      OPTIONAL,

   IN      UINT32                      KeyIndex        OPTIONAL,

   IN      UINT64                      MonotonicCount  OPTIONAL,

-  IN      VARIABLE_POINTER_TRACK      *CacheVariable,

+  IN OUT  VARIABLE_POINTER_TRACK      *CacheVariable,

   IN      EFI_TIME                    *TimeStamp      OPTIONAL

   )

 {

@@ -1427,7 +1658,6 @@ UpdateVariable (
   BOOLEAN                             Volatile;

   EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *Fvb;

   UINT8                               State;

-  BOOLEAN                             Reclaimed;

   VARIABLE_POINTER_TRACK              *Variable;

   VARIABLE_POINTER_TRACK              NvVariable;

   VARIABLE_STORE_HEADER               *VariableStoreHeader;

@@ -1467,11 +1697,15 @@ UpdateVariable (
     Variable->StartPtr = GetStartPointer (VariableStoreHeader);

     Variable->EndPtr   = GetEndPointer (VariableStoreHeader);

     Variable->CurrPtr  = (VARIABLE_HEADER *)((UINTN)Variable->StartPtr + ((UINTN)CacheVariable->CurrPtr - (UINTN)CacheVariable->StartPtr));

+    if (CacheVariable->InDeletedTransitionPtr != NULL) {

+      Variable->InDeletedTransitionPtr = (VARIABLE_HEADER *)((UINTN)Variable->StartPtr + ((UINTN)CacheVariable->InDeletedTransitionPtr - (UINTN)CacheVariable->StartPtr));

+    } else {

+      Variable->InDeletedTransitionPtr = NULL;

+    }

     Variable->Volatile = FALSE;

   }

 

   Fvb       = mVariableModuleGlobal->FvbInstance;

-  Reclaimed = FALSE;

 

   //

   // Tricky part: Use scratch data area at the end of volatile variable store

@@ -1519,6 +1753,32 @@ UpdateVariable (
     // not delete the variable.

     //

     if ((((Attributes & EFI_VARIABLE_APPEND_WRITE) == 0) && (DataSize == 0))|| ((Attributes & (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)) == 0)) {

+      if (Variable->InDeletedTransitionPtr != NULL) {

+        //

+        // Both ADDED and IN_DELETED_TRANSITION variable are present,

+        // set IN_DELETED_TRANSITION one to DELETED state first.

+        //

+        State = Variable->InDeletedTransitionPtr->State;

+        State &= VAR_DELETED;

+        Status = UpdateVariableStore (

+                   &mVariableModuleGlobal->VariableGlobal,

+                   Variable->Volatile,

+                   FALSE,

+                   Fvb,

+                   (UINTN) &Variable->InDeletedTransitionPtr->State,

+                   sizeof (UINT8),

+                   &State

+                   );

+        if (!EFI_ERROR (Status)) {

+          if (!Variable->Volatile) {

+            ASSERT (CacheVariable->InDeletedTransitionPtr != NULL);

+            CacheVariable->InDeletedTransitionPtr->State = State;

+          }

+        } else {

+          goto Done;

+        }

+      }

+

       State = Variable->CurrPtr->State;

       State &= VAR_DELETED;

 

@@ -1567,11 +1827,11 @@ UpdateVariable (
         DataOffset = sizeof (VARIABLE_HEADER) + Variable->CurrPtr->NameSize + GET_PAD_SIZE (Variable->CurrPtr->NameSize);

         CopyMem (mStorageArea, (UINT8*)((UINTN) Variable->CurrPtr + DataOffset), Variable->CurrPtr->DataSize);

 

-        if (CompareGuid (VendorGuid, &gEfiImageSecurityDatabaseGuid) ||

-        	(CompareGuid (VendorGuid, &gEfiGlobalVariableGuid) && (StrCmp (VariableName, EFI_KEY_EXCHANGE_KEY_NAME) == 0))) {

+        if ((CompareGuid (VendorGuid, &gEfiImageSecurityDatabaseGuid) &&

+            ((StrCmp (VariableName, EFI_IMAGE_SECURITY_DATABASE) == 0) || (StrCmp (VariableName, EFI_IMAGE_SECURITY_DATABASE1) == 0))) ||

+            (CompareGuid (VendorGuid, &gEfiGlobalVariableGuid) && (StrCmp (VariableName, EFI_KEY_EXCHANGE_KEY_NAME) == 0))) {

           //

-          // For variables with the GUID EFI_IMAGE_SECURITY_DATABASE_GUID (i.e. where the data

-          // buffer is formatted as EFI_SIGNATURE_LIST), the driver shall not perform an append of

+          // For variables with formatted as EFI_SIGNATURE_LIST, the driver shall not perform an append of

           // EFI_SIGNATURE_DATA values that are already part of the existing variable value.

           //

           BufSize = AppendSignatureList (mStorageArea, Variable->CurrPtr->DataSize, Data, DataSize);

@@ -1744,8 +2004,14 @@ UpdateVariable (
       //

       // Perform garbage collection & reclaim operation.

       //

-      Status = Reclaim (mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,

-                        &mVariableModuleGlobal->NonVolatileLastVariableOffset, FALSE, Variable->CurrPtr, FALSE);

+      Status = Reclaim (

+                 mVariableModuleGlobal->VariableGlobal.NonVolatileVariableBase,

+                 &mVariableModuleGlobal->NonVolatileLastVariableOffset,

+                 FALSE,

+                 Variable,

+                 FALSE,

+                 FALSE

+                 );

       if (EFI_ERROR (Status)) {

         goto Done;

       }

@@ -1759,7 +2025,10 @@ UpdateVariable (
         Status = EFI_OUT_OF_RESOURCES;

         goto Done;

       }

-      Reclaimed = TRUE;

+      if (Variable->CurrPtr != NULL) {

+        CacheVariable->CurrPtr = (VARIABLE_HEADER *)((UINTN) CacheVariable->StartPtr + ((UINTN) Variable->CurrPtr - (UINTN) Variable->StartPtr));

+        CacheVariable->InDeletedTransitionPtr = NULL;

+      }

     }

     //

     // Four steps

@@ -1859,8 +2128,14 @@ UpdateVariable (
       //

       // Perform garbage collection & reclaim operation.

       //

-      Status = Reclaim (mVariableModuleGlobal->VariableGlobal.VolatileVariableBase,

-                          &mVariableModuleGlobal->VolatileLastVariableOffset, TRUE, Variable->CurrPtr, FALSE);

+      Status = Reclaim (

+                 mVariableModuleGlobal->VariableGlobal.VolatileVariableBase,

+                 &mVariableModuleGlobal->VolatileLastVariableOffset,

+                 TRUE,

+                 Variable,

+                 FALSE,

+                 FALSE

+                 );

       if (EFI_ERROR (Status)) {

         goto Done;

       }

@@ -1873,7 +2148,10 @@ UpdateVariable (
         Status = EFI_OUT_OF_RESOURCES;

         goto Done;

       }

-      Reclaimed = TRUE;

+      if (Variable->CurrPtr != NULL) {

+        CacheVariable->CurrPtr = (VARIABLE_HEADER *)((UINTN) CacheVariable->StartPtr + ((UINTN) Variable->CurrPtr - (UINTN) Variable->StartPtr));

+        CacheVariable->InDeletedTransitionPtr = NULL;

+      }

     }

 

     NextVariable->State = VAR_ADDED;

@@ -1897,7 +2175,33 @@ UpdateVariable (
   //

   // Mark the old variable as deleted.

   //

-  if (!Reclaimed && !EFI_ERROR (Status) && Variable->CurrPtr != NULL) {

+  if (!EFI_ERROR (Status) && Variable->CurrPtr != NULL) {

+    if (Variable->InDeletedTransitionPtr != NULL) {

+      //

+      // Both ADDED and IN_DELETED_TRANSITION old variable are present,

+      // set IN_DELETED_TRANSITION one to DELETED state first.

+      //

+      State = Variable->InDeletedTransitionPtr->State;

+      State &= VAR_DELETED;

+      Status = UpdateVariableStore (

+                 &mVariableModuleGlobal->VariableGlobal,

+                 Variable->Volatile,

+                 FALSE,

+                 Fvb,

+                 (UINTN) &Variable->InDeletedTransitionPtr->State,

+                 sizeof (UINT8),

+                 &State

+                 );

+      if (!EFI_ERROR (Status)) {

+        if (!Variable->Volatile) {

+          ASSERT (CacheVariable->InDeletedTransitionPtr != NULL);

+          CacheVariable->InDeletedTransitionPtr->State = State;

+        }

+      } else {

+        goto Done;

+      }

+    }

+

     State = Variable->CurrPtr->State;

     State &= VAR_DELETED;

 

@@ -2119,6 +2423,7 @@ VariableServiceGetNextVariableName (
   VARIABLE_STORE_TYPE     Type;

   VARIABLE_POINTER_TRACK  Variable;

   VARIABLE_POINTER_TRACK  VariableInHob;

+  VARIABLE_POINTER_TRACK  VariablePtrTrack;

   UINTN                   VarNameSize;

   EFI_STATUS              Status;

   VARIABLE_STORE_HEADER   *VariableStoreHeader[VariableStoreTypeMax];

@@ -2192,8 +2497,27 @@ VariableServiceGetNextVariableName (
     //

     // Variable is found

     //

-    if (Variable.CurrPtr->State == VAR_ADDED) {

-      if ((AtRuntime () && ((Variable.CurrPtr->Attributes & EFI_VARIABLE_RUNTIME_ACCESS) == 0)) == 0) {

+    if (Variable.CurrPtr->State == VAR_ADDED || Variable.CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

+      if (!AtRuntime () || ((Variable.CurrPtr->Attributes & EFI_VARIABLE_RUNTIME_ACCESS) != 0)) {

+        if (Variable.CurrPtr->State == (VAR_IN_DELETED_TRANSITION & VAR_ADDED)) {

+          //

+          // If it is a IN_DELETED_TRANSITION variable,

+          // and there is also a same ADDED one at the same time,

+          // don't return it.

+          //

+          VariablePtrTrack.StartPtr = Variable.StartPtr;

+          VariablePtrTrack.EndPtr = Variable.EndPtr;

+          Status = FindVariableEx (

+                     GetVariableNamePtr (Variable.CurrPtr),

+                     &Variable.CurrPtr->VendorGuid,

+                     FALSE,

+                     &VariablePtrTrack

+                     );

+          if (!EFI_ERROR (Status) && VariablePtrTrack.CurrPtr->State == VAR_ADDED) {

+            Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);

+            continue;

+          }

+        }

 

         //

         // Don't return NV variable when HOB overrides it

@@ -2629,6 +2953,7 @@ ReclaimForOS(
             &mVariableModuleGlobal->NonVolatileLastVariableOffset,

             FALSE,

             NULL,

+            FALSE,

             FALSE

             );

     ASSERT_EFI_ERROR (Status);

@@ -2760,6 +3085,7 @@ VariableWriteServiceInitialize (
                  &mVariableModuleGlobal->NonVolatileLastVariableOffset,

                  FALSE,

                  NULL,

+                 FALSE,

                  TRUE

                  );

       if (EFI_ERROR (Status)) {

@@ -2898,6 +3224,11 @@ VariableCommonInitialize (
   ASSERT(VariableStoreHeader->Size == VariableStoreLength);

 

   //

+  // The max variable or hardware error variable size should be < variable store size.

+  //

+  ASSERT(MAX (PcdGet32 (PcdMaxVariableSize), PcdGet32 (PcdMaxHardwareErrorVariableSize)) < VariableStoreLength);

+

+  //

   // Parse non-volatile variable data and get last variable offset.

   //

   NextVariable  = GetStartPointer ((VARIABLE_STORE_HEADER *)(UINTN)VariableStoreBase);

diff --git a/SecurityPkg/VariableAuthenticated/RuntimeDxe/Variable.h b/SecurityPkg/VariableAuthenticated/RuntimeDxe/Variable.h
index 6a51bcce..45015836 100644
--- a/SecurityPkg/VariableAuthenticated/RuntimeDxe/Variable.h
+++ b/SecurityPkg/VariableAuthenticated/RuntimeDxe/Variable.h
@@ -2,7 +2,7 @@
   The internal header file includes the common header files, defines

   internal structure and functions used by Variable modules.

 

-Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials 

 are licensed and made available under the terms and conditions of the BSD License 

 which accompanies this distribution.  The full text of the license may be found at 

@@ -65,6 +65,13 @@ typedef enum {
 

 typedef struct {

   VARIABLE_HEADER *CurrPtr;

+  //

+  // If both ADDED and IN_DELETED_TRANSITION variable are present,

+  // InDeletedTransitionPtr will point to the IN_DELETED_TRANSITION one.

+  // Otherwise, CurrPtr will point to the ADDED or IN_DELETED_TRANSITION one,

+  // and InDeletedTransitionPtr will be NULL at the same time.

+  //

+  VARIABLE_HEADER *InDeletedTransitionPtr;

   VARIABLE_HEADER *EndPtr;

   VARIABLE_HEADER *StartPtr;

   BOOLEAN         Volatile;

@@ -209,7 +216,7 @@ DataSizeOfVariable (
   @param[in] Attributes         Attributes of the variable.

   @param[in] KeyIndex           Index of associated public key.

   @param[in] MonotonicCount     Value of associated monotonic count.

-  @param[in] Variable           The variable information that is used to keep track of variable usage.

+  @param[in, out] Variable      The variable information that is used to keep track of variable usage.

 

   @param[in] TimeStamp          Value of associated TimeStamp.

 

@@ -226,7 +233,7 @@ UpdateVariable (
   IN      UINT32          Attributes OPTIONAL,

   IN      UINT32          KeyIndex  OPTIONAL,

   IN      UINT64          MonotonicCount  OPTIONAL,

-  IN      VARIABLE_POINTER_TRACK *Variable,

+  IN OUT  VARIABLE_POINTER_TRACK *Variable,

   IN      EFI_TIME        *TimeStamp  OPTIONAL  

   );

 

@@ -367,6 +374,38 @@ VariableCommonInitialize (
   );

 

 /**

+

+  Variable store garbage collection and reclaim operation.

+

+  If ReclaimPubKeyStore is FALSE, reclaim variable space by deleting the obsoleted varaibles.

+  If ReclaimPubKeyStore is TRUE, reclaim invalid key in public key database and update the PubKeyIndex

+  for all the count-based authenticate variable in NV storage.

+

+  @param[in]      VariableBase            Base address of variable store.

+  @param[out]     LastVariableOffset      Offset of last variable.

+  @param[in]      IsVolatile              The variable store is volatile or not;

+                                          if it is non-volatile, need FTW.

+  @param[in, out] UpdatingPtrTrack        Pointer to updating variable pointer track structure.

+  @param[in]      ReclaimPubKeyStore      Reclaim for public key database or not.

+  @param[in]      ReclaimAnyway           If TRUE, do reclaim anyway.

+  

+  @return EFI_SUCCESS                  Reclaim operation has finished successfully.

+  @return EFI_OUT_OF_RESOURCES         No enough memory resources.

+  @return EFI_DEVICE_ERROR             The public key database doesn't exist.

+  @return Others                       Unexpect error happened during reclaim operation.

+

+**/

+EFI_STATUS

+Reclaim (

+  IN     EFI_PHYSICAL_ADDRESS         VariableBase,

+  OUT    UINTN                        *LastVariableOffset,

+  IN     BOOLEAN                      IsVolatile,

+  IN OUT VARIABLE_POINTER_TRACK       *UpdatingPtrTrack,

+  IN     BOOLEAN                      ReclaimPubKeyStore,

+  IN     BOOLEAN                      ReclaimAnyway

+  );

+

+/**

   This function reclaims variable storage if free size is below the threshold.

   

 **/

diff --git a/SecurityPkg/VariableAuthenticated/RuntimeDxe/VariableSmmRuntimeDxe.c b/SecurityPkg/VariableAuthenticated/RuntimeDxe/VariableSmmRuntimeDxe.c
index 2ef44e3a..103a1291 100644
--- a/SecurityPkg/VariableAuthenticated/RuntimeDxe/VariableSmmRuntimeDxe.c
+++ b/SecurityPkg/VariableAuthenticated/RuntimeDxe/VariableSmmRuntimeDxe.c
@@ -13,7 +13,7 @@
 

   InitCommunicateBuffer() is really function to check the variable data size.

 

-Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials 

 are licensed and made available under the terms and conditions of the BSD License 

 which accompanies this distribution.  The full text of the license may be found at 

@@ -52,7 +52,51 @@ EFI_SMM_COMMUNICATION_PROTOCOL  *mSmmCommunication          = NULL;
 UINT8                           *mVariableBuffer            = NULL;

 UINT8                           *mVariableBufferPhysical    = NULL;

 UINTN                            mVariableBufferSize;

+EFI_LOCK                         mVariableServicesLock;

 

+/**

+  Acquires lock only at boot time. Simply returns at runtime.

+

+  This is a temperary function that will be removed when

+  EfiAcquireLock() in UefiLib can handle the call in UEFI

+  Runtimer driver in RT phase.

+  It calls EfiAcquireLock() at boot time, and simply returns

+  at runtime.

+

+  @param  Lock         A pointer to the lock to acquire.

+

+**/

+VOID

+AcquireLockOnlyAtBootTime (

+  IN EFI_LOCK                             *Lock

+  )

+{

+  if (!EfiAtRuntime ()) {

+    EfiAcquireLock (Lock);

+  }

+}

+

+/**

+  Releases lock only at boot time. Simply returns at runtime.

+

+  This is a temperary function which will be removed when

+  EfiReleaseLock() in UefiLib can handle the call in UEFI

+  Runtimer driver in RT phase.

+  It calls EfiReleaseLock() at boot time and simply returns

+  at runtime.

+

+  @param  Lock         A pointer to the lock to release.

+

+**/

+VOID

+ReleaseLockOnlyAtBootTime (

+  IN EFI_LOCK                             *Lock

+  )

+{

+  if (!EfiAtRuntime ()) {

+    EfiReleaseLock (Lock);

+  }

+}

 

 /**

   Initialize the communicate buffer using DataSize and Function.

@@ -169,15 +213,27 @@ RuntimeServiceGetVariable (
   if ((*DataSize != 0) && (Data == NULL)) {

     return EFI_INVALID_PARAMETER;

   }

-  

+

+  if (*DataSize >= mVariableBufferSize) {

+    //

+    // DataSize may be near MAX_ADDRESS incorrectly, this can cause the computed PayLoadSize to

+    // overflow to a small value and pass the check in InitCommunicateBuffer().

+    // To protect against this vulnerability, return EFI_INVALID_PARAMETER if DataSize is >= mVariableBufferSize.

+    // And there will be further check to ensure the total size is also not > mVariableBufferSize.

+    //

+    return EFI_INVALID_PARAMETER;

+  }

+

+  AcquireLockOnlyAtBootTime(&mVariableServicesLock);

+

   //

   // Init the communicate buffer. The buffer data size is:

-  // SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + PayloadSize + DataSize.

+  // SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + PayloadSize.

   //

   PayloadSize = OFFSET_OF (SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE, Name) + StrSize (VariableName) + *DataSize;

   Status = InitCommunicateBuffer ((VOID **)&SmmVariableHeader, PayloadSize, SMM_VARIABLE_FUNCTION_GET_VARIABLE);

   if (EFI_ERROR (Status)) {

-    return Status;

+    goto Done;

   }

   ASSERT (SmmVariableHeader != NULL);

 

@@ -205,11 +261,13 @@ RuntimeServiceGetVariable (
   }

 

   if (EFI_ERROR (Status)) {

-    return Status;

+    goto Done;

   }

 

   CopyMem (Data, (UINT8 *)SmmVariableHeader->Name + SmmVariableHeader->NameSize, SmmVariableHeader->DataSize);

 

+Done:

+  ReleaseLockOnlyAtBootTime (&mVariableServicesLock);

   return Status;

 }

 

@@ -242,7 +300,19 @@ RuntimeServiceGetNextVariableName (
   if (VariableNameSize == NULL || VariableName == NULL || VendorGuid == NULL) {

     return EFI_INVALID_PARAMETER;

   }

-  

+

+  if (*VariableNameSize >= mVariableBufferSize) {

+    //

+    // VariableNameSize may be near MAX_ADDRESS incorrectly, this can cause the computed PayLoadSize to

+    // overflow to a small value and pass the check in InitCommunicateBuffer().

+    // To protect against this vulnerability, return EFI_INVALID_PARAMETER if VariableNameSize is >= mVariableBufferSize.

+    // And there will be further check to ensure the total size is also not > mVariableBufferSize.

+    //

+    return EFI_INVALID_PARAMETER;

+  }

+

+  AcquireLockOnlyAtBootTime(&mVariableServicesLock);

+

   //

   // Init the communicate buffer. The buffer data size is:

   // SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + PayloadSize.

@@ -250,7 +320,7 @@ RuntimeServiceGetNextVariableName (
   PayloadSize = OFFSET_OF (SMM_VARIABLE_COMMUNICATE_GET_NEXT_VARIABLE_NAME, Name) + *VariableNameSize; 

   Status = InitCommunicateBuffer ((VOID **)&SmmGetNextVariableName, PayloadSize, SMM_VARIABLE_FUNCTION_GET_NEXT_VARIABLE_NAME);

   if (EFI_ERROR (Status)) {

-    return Status;

+    goto Done;

   }

   ASSERT (SmmGetNextVariableName != NULL);

 

@@ -268,12 +338,14 @@ RuntimeServiceGetNextVariableName (
   //

   *VariableNameSize = SmmGetNextVariableName->NameSize;    

   if (EFI_ERROR (Status)) {

-    return Status;

+    goto Done;

   }

   

   CopyGuid (VendorGuid, &SmmGetNextVariableName->Guid);

   CopyMem (VariableName, SmmGetNextVariableName->Name, SmmGetNextVariableName->NameSize);  

 

+Done:

+  ReleaseLockOnlyAtBootTime (&mVariableServicesLock);

   return Status;

 }

 

@@ -321,7 +393,19 @@ RuntimeServiceSetVariable (
   if (DataSize != 0 && Data == NULL) {

     return EFI_INVALID_PARAMETER;

   }

-  

+

+  if (DataSize >= mVariableBufferSize) {

+    //

+    // DataSize may be near MAX_ADDRESS incorrectly, this can cause the computed PayLoadSize to

+    // overflow to a small value and pass the check in InitCommunicateBuffer().

+    // To protect against this vulnerability, return EFI_INVALID_PARAMETER if DataSize is >= mVariableBufferSize.

+    // And there will be further check to ensure the total size is also not > mVariableBufferSize.

+    //

+    return EFI_INVALID_PARAMETER;

+  }

+

+  AcquireLockOnlyAtBootTime(&mVariableServicesLock);

+ 

   //

   // Init the communicate buffer. The buffer data size is:

   // SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + PayloadSize.

@@ -329,7 +413,7 @@ RuntimeServiceSetVariable (
   PayloadSize = OFFSET_OF (SMM_VARIABLE_COMMUNICATE_ACCESS_VARIABLE, Name) + StrSize (VariableName) + DataSize;

   Status = InitCommunicateBuffer ((VOID **)&SmmVariableHeader, PayloadSize, SMM_VARIABLE_FUNCTION_SET_VARIABLE);

   if (EFI_ERROR (Status)) {

-    return Status;

+    goto Done;

   }

   ASSERT (SmmVariableHeader != NULL);

 

@@ -344,7 +428,9 @@ RuntimeServiceSetVariable (
   // Send data to SMM.

   //

   Status = SendCommunicateBuffer (PayloadSize);

- 

+

+Done:

+  ReleaseLockOnlyAtBootTime (&mVariableServicesLock);

   return Status;

 }

 

@@ -382,7 +468,9 @@ RuntimeServiceQueryVariableInfo (
   if(MaximumVariableStorageSize == NULL || RemainingVariableStorageSize == NULL || MaximumVariableSize == NULL || Attributes == 0) {

     return EFI_INVALID_PARAMETER;

   }

-  

+

+  AcquireLockOnlyAtBootTime(&mVariableServicesLock);

+

   //

   // Init the communicate buffer. The buffer data size is:

   // SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE + PayloadSize;

@@ -390,7 +478,7 @@ RuntimeServiceQueryVariableInfo (
   PayloadSize = sizeof (SMM_VARIABLE_COMMUNICATE_QUERY_VARIABLE_INFO);

   Status = InitCommunicateBuffer ((VOID **)&SmmQueryVariableInfo, PayloadSize, SMM_VARIABLE_FUNCTION_QUERY_VARIABLE_INFO);

   if (EFI_ERROR (Status)) {

-    return Status;

+    goto Done;

   }

   ASSERT (SmmQueryVariableInfo != NULL);

 

@@ -401,7 +489,7 @@ RuntimeServiceQueryVariableInfo (
   //

   Status = SendCommunicateBuffer (PayloadSize);

   if (EFI_ERROR (Status)) {

-    return Status;

+    goto Done;

   }

 

   //

@@ -410,8 +498,10 @@ RuntimeServiceQueryVariableInfo (
   *MaximumVariableSize          = SmmQueryVariableInfo->MaximumVariableSize;

   *MaximumVariableStorageSize   = SmmQueryVariableInfo->MaximumVariableStorageSize;

   *RemainingVariableStorageSize = SmmQueryVariableInfo->RemainingVariableStorageSize; 

- 

-  return EFI_SUCCESS;

+

+Done:

+  ReleaseLockOnlyAtBootTime (&mVariableServicesLock);

+  return Status;

 }

 

 

@@ -608,7 +698,9 @@ VariableSmmRuntimeInitialize (
   VOID                                      *SmmVariableWriteRegistration;

   EFI_EVENT                                 OnReadyToBootEvent;

   EFI_EVENT                                 ExitBootServiceEvent;

-  

+

+  EfiInitializeLock (&mVariableServicesLock, TPL_NOTIFY);

+

   //

   // Smm variable service is ready

   //

diff --git a/SecurityPkg/VariableAuthenticated/SecureBootConfigDxe/SecureBootConfig.vfr b/SecurityPkg/VariableAuthenticated/SecureBootConfigDxe/SecureBootConfig.vfr
index df7ff37a..ae4b71bf 100644
--- a/SecurityPkg/VariableAuthenticated/SecureBootConfigDxe/SecureBootConfig.vfr
+++ b/SecurityPkg/VariableAuthenticated/SecureBootConfigDxe/SecureBootConfig.vfr
@@ -1,7 +1,7 @@
 /** @file

   VFR file used by the SecureBoot configuration component.

 

-Copyright (c) 2011 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials 

 are licensed and made available under the terms and conditions of the BSD License 

 which accompanies this distribution.  The full text of the license may be found at 

@@ -32,7 +32,12 @@ formset
     title = STRING_TOKEN(STR_SECUREBOOT_TITLE);

 

     subtitle text = STRING_TOKEN(STR_NULL);

-    

+

+    text

+      help   = STRING_TOKEN(STR_SECURE_BOOT_STATE_HELP),

+      text   = STRING_TOKEN(STR_SECURE_BOOT_STATE_PROMPT),

+        text   = STRING_TOKEN(STR_SECURE_BOOT_STATE_CONTENT);

+        

     //

     // Define of Check Box: Attempt Secure Boot

     //

@@ -47,7 +52,7 @@ formset
     // Display of Check Box: Attempt Secure Boot

     //

     grayoutif ideqval SECUREBOOT_CONFIGURATION.HideSecureBoot == 1;

-    checkbox varid = SECUREBOOT_CONFIGURATION.SecureBootState,

+    checkbox varid = SECUREBOOT_CONFIGURATION.AttemptSecureBoot,

           questionid = KEY_SECURE_BOOT_ENABLE,

           prompt = STRING_TOKEN(STR_SECURE_BOOT_PROMPT),

           help   = STRING_TOKEN(STR_SECURE_BOOT_HELP),

diff --git a/SecurityPkg/VariableAuthenticated/SecureBootConfigDxe/SecureBootConfigImpl.c b/SecurityPkg/VariableAuthenticated/SecureBootConfigDxe/SecureBootConfigImpl.c
index c56a3117..51da86b6 100644
--- a/SecurityPkg/VariableAuthenticated/SecureBootConfigDxe/SecureBootConfigImpl.c
+++ b/SecurityPkg/VariableAuthenticated/SecureBootConfigDxe/SecureBootConfigImpl.c
@@ -1,7 +1,7 @@
 /** @file

   HII Config Access protocol implementation of SecureBoot configuration module.

 

-Copyright (c) 2011 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials

 are licensed and made available under the terms and conditions of the BSD License

 which accompanies this distribution.  The full text of the license may be found at

@@ -253,6 +253,7 @@ DeleteVariable (
   if (Variable == NULL) {

     return EFI_SUCCESS;

   }

+  FreePool (Variable);

 

   Data     = NULL;

   DataSize = 0;

@@ -279,6 +280,31 @@ DeleteVariable (
 }

 

 /**

+

+  Set the platform secure boot mode into "Custom" or "Standard" mode.

+

+  @param[in]   SecureBootMode        New secure boot mode: STANDARD_SECURE_BOOT_MODE or

+                                     CUSTOM_SECURE_BOOT_MODE.

+  

+  @return EFI_SUCCESS                The platform has switched to the special mode successfully.

+  @return other                      Fail to operate the secure boot mode.

+  

+**/

+EFI_STATUS

+SetSecureBootMode (

+  IN     UINT8         SecureBootMode

+  )

+{

+  return gRT->SetVariable (                          

+                EFI_CUSTOM_MODE_NAME,

+                &gEfiCustomModeEnableGuid,

+                EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,

+                sizeof (UINT8),

+                &SecureBootMode

+                );

+}

+

+/**

   Generate the PK signature list from the X509 Certificate storing file (.cer)

 

   @param[in]   X509File              FileHandle of X509 Certificate storing file.

@@ -380,6 +406,11 @@ EnrollPlatformKey (
 

   PkCert = NULL;

 

+  Status = SetSecureBootMode(CUSTOM_SECURE_BOOT_MODE);

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+

   //

   // Parse the file's postfix. Only support DER encoded X.509 certificate files.

   //

@@ -457,6 +488,11 @@ DeletePlatformKey (
 {

   EFI_STATUS Status;

 

+  Status = SetSecureBootMode(CUSTOM_SECURE_BOOT_MODE);

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+

   Status = DeleteVariable (

              EFI_PLATFORM_KEY_NAME,

              &gEfiGlobalVariableGuid

@@ -766,11 +802,17 @@ EnrollKeyExchangeKey (
   ) 

 {

   UINT16*     FilePostFix;

+  EFI_STATUS  Status;

   

   if ((Private->FileContext->FileName == NULL) || (Private->SignatureGUID == NULL)) {

     return EFI_INVALID_PARAMETER;

   }

 

+  Status = SetSecureBootMode(CUSTOM_SECURE_BOOT_MODE);

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+

   //

   // Parse the file's postfix. Supports DER-encoded X509 certificate, 

   // and .pbk as RSA public key file.

@@ -1508,11 +1550,17 @@ EnrollSignatureDatabase (
   ) 

 {

   UINT16*      FilePostFix;

+  EFI_STATUS   Status;

 

   if ((Private->FileContext->FileName == NULL) || (Private->FileContext->FHandle == NULL) || (Private->SignatureGUID == NULL)) {

     return EFI_INVALID_PARAMETER;

   }

 

+  Status = SetSecureBootMode(CUSTOM_SECURE_BOOT_MODE);

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+  

   //

   // Parse the file's postfix. 

   //

@@ -1659,6 +1707,8 @@ UpdateDeletePage (
       //

       // The signature type is not supported in current implementation.

       //

+      ItemDataSize -= CertList->SignatureListSize;

+      CertList = (EFI_SIGNATURE_LIST *) ((UINT8 *) CertList + CertList->SignatureListSize);

       continue;

     }

 

@@ -1756,6 +1806,11 @@ DeleteKeyExchangeKey (
   Cert            = NULL;

   Attr            = 0;   

   DeleteKekIndex  = QuestionId - OPTION_DEL_KEK_QUESTION_ID;

+

+  Status = SetSecureBootMode(CUSTOM_SECURE_BOOT_MODE);

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

   

   //

   // Get original KEK variable.

@@ -1944,6 +1999,11 @@ DeleteSignature (
   Cert            = NULL;

   Attr            = 0; 

 

+  Status = SetSecureBootMode(CUSTOM_SECURE_BOOT_MODE);

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+

   //

   // Get original signature list data.

   //                           

@@ -2103,23 +2163,25 @@ SecureBootExtractConfigFromVariable (
 {

   UINT8   *SecureBootEnable;

   UINT8   *SetupMode;

-  UINT8   *SecureBoot;

   UINT8   *SecureBootMode;

 

   SecureBootEnable = NULL;

   SetupMode        = NULL;

-  SecureBoot       = NULL;

   SecureBootMode   = NULL;

   

   //

   // If the SecureBootEnable Variable doesn't exist, hide the SecureBoot Enable/Disable

   // Checkbox.

   //

+  ConfigData->AttemptSecureBoot = FALSE;

   GetVariable2 (EFI_SECURE_BOOT_ENABLE_NAME, &gEfiSecureBootEnableDisableGuid, (VOID**)&SecureBootEnable, NULL);

   if (SecureBootEnable == NULL) {

     ConfigData->HideSecureBoot = TRUE;

   } else {

     ConfigData->HideSecureBoot = FALSE;

+    if ((*SecureBootEnable) == SECURE_BOOT_ENABLE) {

+      ConfigData->AttemptSecureBoot = TRUE;

+    }

   }

   

   //

@@ -2140,16 +2202,6 @@ SecureBootExtractConfigFromVariable (
   } else  {

     ConfigData->HasPk = TRUE;

   }

-  

-  //

-  // If the value of SecureBoot variable is 1, the platform is operating in secure boot mode.

-  //

-  GetVariable2 (EFI_SECURE_BOOT_MODE_NAME, &gEfiGlobalVariableGuid, (VOID**)&SecureBoot, NULL);

-  if (SecureBoot != NULL && *SecureBoot == SECURE_BOOT_MODE_ENABLE) {

-    ConfigData->SecureBootState = TRUE;

-  } else {

-    ConfigData->SecureBootState = FALSE;

-  }

 

   //

   // Get the SecureBootMode from CustomMode variable.

@@ -2160,7 +2212,16 @@ SecureBootExtractConfigFromVariable (
   } else {

     ConfigData->SecureBootMode = *(SecureBootMode);

   }

-  

+

+  if (SecureBootEnable != NULL) {

+    FreePool (SecureBootEnable);

+  }

+  if (SetupMode != NULL) {

+    FreePool (SetupMode);

+  }

+  if (SecureBootMode != NULL) {

+    FreePool (SecureBootMode);

+  }

 }

 

 /**

@@ -2206,6 +2267,7 @@ SecureBootExtractConfig (
   EFI_STRING                        ConfigRequestHdr;

   SECUREBOOT_CONFIG_PRIVATE_DATA    *PrivateData;

   BOOLEAN                           AllocatedRequest;

+  UINT8                             *SecureBoot;

 

   if (Progress == NULL || Results == NULL) {

     return EFI_INVALID_PARAMETER;

@@ -2215,6 +2277,7 @@ SecureBootExtractConfig (
   ConfigRequestHdr = NULL;

   ConfigRequest    = NULL;

   Size             = 0;

+  SecureBoot       = NULL;

   

   ZeroMem (&Configuration, sizeof (Configuration));

   PrivateData      = SECUREBOOT_CONFIG_PRIVATE_FROM_THIS (This);

@@ -2228,6 +2291,19 @@ SecureBootExtractConfig (
   // Get Configuration from Variable.

   //

   SecureBootExtractConfigFromVariable (&Configuration);

+

+  //

+  // Update current secure boot state.

+  //

+  GetVariable2 (EFI_SECURE_BOOT_MODE_NAME, &gEfiGlobalVariableGuid, (VOID**)&SecureBoot, NULL);

+  if (SecureBoot != NULL && *SecureBoot == SECURE_BOOT_MODE_ENABLE) {

+    HiiSetString (PrivateData->HiiHandle, STRING_TOKEN (STR_SECURE_BOOT_STATE_CONTENT), L"Enabled", NULL);

+  } else {

+    HiiSetString (PrivateData->HiiHandle, STRING_TOKEN (STR_SECURE_BOOT_STATE_CONTENT), L"Disabled", NULL);

+  }

+  if (SecureBoot != NULL) {

+    FreePool (SecureBoot);

+  }

   

   BufferSize = sizeof (SECUREBOOT_CONFIGURATION);

   ConfigRequest = Request;

@@ -2355,15 +2431,21 @@ SecureBootCallback (
   SECUREBOOT_CONFIGURATION        *IfrNvData;

   UINT16                          LabelId;

   UINT8                           *SecureBootEnable;

+  UINT8                           *SecureBootMode;

+  UINT8                           *SetupMode;

   CHAR16                          PromptString[100];

 

   SecureBootEnable = NULL;

+  SecureBootMode   = NULL;

+  SetupMode        = NULL;

 

   if ((This == NULL) || (Value == NULL) || (ActionRequest == NULL)) {

     return EFI_INVALID_PARAMETER;

   }

 

-  if ((Action != EFI_BROWSER_ACTION_CHANGED) && (Action != EFI_BROWSER_ACTION_CHANGING)) {

+  if ((Action != EFI_BROWSER_ACTION_CHANGED) &&

+      (Action != EFI_BROWSER_ACTION_CHANGING) &&

+      (Action != EFI_BROWSER_ACTION_FORM_CLOSE)) {

     return EFI_UNSUPPORTED;

   }

   

@@ -2388,6 +2470,7 @@ SecureBootCallback (
     case KEY_SECURE_BOOT_ENABLE:

       GetVariable2 (EFI_SECURE_BOOT_ENABLE_NAME, &gEfiSecureBootEnableDisableGuid, (VOID**)&SecureBootEnable, NULL);

       if (NULL != SecureBootEnable) {

+        FreePool (SecureBootEnable);

         if (EFI_ERROR (SaveSecureBootVariable (Value->u8))) {

           CreatePopUp (

             EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,

@@ -2400,11 +2483,10 @@ SecureBootCallback (
           CreatePopUp (

             EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,

             &Key,

-            L"Secure boot configuration is changed, please reset the platform to take effect!",

+            L"Configuration changed, please reset the platform to take effect!",

             NULL

             );

         }

-        *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_APPLY; 

       }

       break;

 

@@ -2461,10 +2543,26 @@ SecureBootCallback (
       break;

 

     case KEY_SECURE_BOOT_DELETE_PK: 

-        if (Value->u8) {

+      if (Value->u8) {

+        CreatePopUp (

+          EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,

+          &Key,

+          L"Are you sure you want to delete PK? Secure boot will be disabled!",

+          L"Press 'Y' to delete PK and exit, 'N' to discard change and return",

+          NULL

+          );

+        if (Key.UnicodeChar == 'y' || Key.UnicodeChar == 'Y') {

           Status = DeletePlatformKey ();

-          *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_APPLY;

+          if (EFI_ERROR (Status)) {

+            CreatePopUp (

+              EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE,

+              &Key,

+              L"Only Physical Presence User could delete PK in custom mode!",

+              NULL

+              );

+          }

         }

+      }

       break;

 

     case KEY_DELETE_KEK:

@@ -2547,7 +2645,7 @@ SecureBootCallback (
   } else if (Action == EFI_BROWSER_ACTION_CHANGED) {

     switch (QuestionId) {

     case KEY_SECURE_BOOT_ENABLE:

-      *ActionRequest = EFI_BROWSER_ACTION_REQUEST_SUBMIT;      

+      *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_APPLY;

       break;  

     case KEY_VALUE_SAVE_AND_EXIT_PK:

       Status = EnrollPlatformKey (Private);

@@ -2588,8 +2686,8 @@ SecureBootCallback (
       break;

       

     case KEY_SECURE_BOOT_MODE:

-      GetVariable2 (EFI_CUSTOM_MODE_NAME, &gEfiCustomModeEnableGuid, (VOID**)&SecureBootEnable, NULL);

-      if (NULL != SecureBootEnable) {

+      GetVariable2 (EFI_CUSTOM_MODE_NAME, &gEfiCustomModeEnableGuid, (VOID**)&SecureBootMode, NULL);

+      if (NULL != SecureBootMode) {

         Status = gRT->SetVariable (                          

                         EFI_CUSTOM_MODE_NAME,

                         &gEfiCustomModeEnableGuid,

@@ -2599,6 +2697,7 @@ SecureBootCallback (
                         );

         *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_APPLY;

         IfrNvData->SecureBootMode = Value->u8;

+        FreePool (SecureBootMode);

       }        

       break;

 

@@ -2619,11 +2718,33 @@ SecureBootCallback (
       break;

 

     case KEY_SECURE_BOOT_DELETE_PK:

-      if (Value->u8) {

+      GetVariable2 (EFI_SETUP_MODE_NAME, &gEfiGlobalVariableGuid, (VOID**)&SetupMode, NULL);

+      if (SetupMode == NULL || (*SetupMode) == SETUP_MODE) {

+        IfrNvData->DeletePk = TRUE;

+        IfrNvData->HasPk    = FALSE;

         *ActionRequest = EFI_BROWSER_ACTION_REQUEST_SUBMIT;

+      } else  {

+        IfrNvData->DeletePk = FALSE;

+        IfrNvData->HasPk    = TRUE;

+        *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_APPLY;

+      }

+      if (SetupMode != NULL) {

+        FreePool (SetupMode);

       }

       break;  

     }

+  } else if (Action == EFI_BROWSER_ACTION_FORM_CLOSE) {

+    //

+    // Force the platform back to Standard Mode once user leave the setup screen.

+    //

+    GetVariable2 (EFI_CUSTOM_MODE_NAME, &gEfiCustomModeEnableGuid, (VOID**)&SecureBootMode, NULL);

+    if (NULL != SecureBootMode && *SecureBootMode == CUSTOM_SECURE_BOOT_MODE) {

+      IfrNvData->SecureBootMode = STANDARD_SECURE_BOOT_MODE;

+      SetSecureBootMode(STANDARD_SECURE_BOOT_MODE);

+    }

+    if (SecureBootMode != NULL) {

+      FreePool (SecureBootMode);

+    }

   }

   

   if (!EFI_ERROR (Status)) {

diff --git a/SecurityPkg/VariableAuthenticated/SecureBootConfigDxe/SecureBootConfigNvData.h b/SecurityPkg/VariableAuthenticated/SecureBootConfigDxe/SecureBootConfigNvData.h
index 6015dd63..ea431929 100644
--- a/SecurityPkg/VariableAuthenticated/SecureBootConfigDxe/SecureBootConfigNvData.h
+++ b/SecurityPkg/VariableAuthenticated/SecureBootConfigDxe/SecureBootConfigNvData.h
@@ -1,7 +1,7 @@
 /** @file

   Header file for NV data structure definition.

 

-Copyright (c) 2011 - 2012, Intel Corporation. All rights reserved.<BR>

+Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>

 This program and the accompanying materials 

 are licensed and made available under the terms and conditions of the BSD License 

 which accompanies this distribution.  The full text of the license may be found at 

@@ -106,7 +106,7 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 // Nv Data structure referenced by IFR

 //

 typedef struct {

-  BOOLEAN SecureBootState; //Secure Boot Disable/Enable;

+  BOOLEAN AttemptSecureBoot;  //Attempt to enable/disable Secure Boot.

   BOOLEAN HideSecureBoot;  //Hiden Attempt Secure Boot

   CHAR16  SignatureGuid[SECURE_BOOT_GUID_STORAGE_SIZE];

   BOOLEAN PhysicalPresent; //If a Physical Present User;

diff --git a/SecurityPkg/VariableAuthenticated/SecureBootConfigDxe/SecureBootConfigStrings.uni b/SecurityPkg/VariableAuthenticated/SecureBootConfigDxe/SecureBootConfigStrings.uni
index ed4db131..8a4cb36f 100644
--- a/SecurityPkg/VariableAuthenticated/SecureBootConfigDxe/SecureBootConfigStrings.uni
+++ b/SecurityPkg/VariableAuthenticated/SecureBootConfigDxe/SecureBootConfigStrings.uni
diff --git a/ShellPkg/Application/Shell/ShellParametersProtocol.c b/ShellPkg/Application/Shell/ShellParametersProtocol.c
index a01a5c6a..067f6b7c 100644
--- a/ShellPkg/Application/Shell/ShellParametersProtocol.c
+++ b/ShellPkg/Application/Shell/ShellParametersProtocol.c
@@ -290,10 +290,10 @@ CreatePopulateInstallShellParametersProtocol (
   //

   // Build the full command line

   //

-  Status = SHELL_GET_ENVIRONMENT_VARIABLE(L"ShellOpt", &Size, &FullCommandLine);

+  Status = SHELL_GET_ENVIRONMENT_VARIABLE(L"ShellOpt", &Size, FullCommandLine);

   if (Status == EFI_BUFFER_TOO_SMALL) {

     FullCommandLine = AllocateZeroPool(Size + LoadedImage->LoadOptionsSize);

-    Status = SHELL_GET_ENVIRONMENT_VARIABLE(L"ShellOpt", &Size, &FullCommandLine);

+    Status = SHELL_GET_ENVIRONMENT_VARIABLE(L"ShellOpt", &Size, FullCommandLine);

   }

   if (Status == EFI_NOT_FOUND) {

     //

diff --git a/ShellPkg/Include/Library/ShellLib.h b/ShellPkg/Include/Library/ShellLib.h
index 7d2416d3..eefa030a 100644
--- a/ShellPkg/Include/Library/ShellLib.h
+++ b/ShellPkg/Include/Library/ShellLib.h
@@ -1,7 +1,7 @@
 /** @file

   Provides interface to shell functionality for shell commands and applications.

 

-  Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -1328,4 +1328,52 @@ ShellFileHandleReadLine(
   IN OUT BOOLEAN                *Ascii

   );

 

+/**

+  Function to delete a file by name

+  

+  @param[in]       FileName       Pointer to file name to delete.

+  

+  @retval EFI_SUCCESS             the file was deleted sucessfully

+  @retval EFI_WARN_DELETE_FAILURE the handle was closed, but the file was not

+                                  deleted

+  @retval EFI_INVALID_PARAMETER   One of the parameters has an invalid value.

+  @retval EFI_NOT_FOUND           The specified file could not be found on the

+                                  device or the file system could not be found

+                                  on the device.

+  @retval EFI_NO_MEDIA            The device has no medium.

+  @retval EFI_MEDIA_CHANGED       The device has a different medium in it or the

+                                  medium is no longer supported.

+  @retval EFI_DEVICE_ERROR        The device reported an error.

+  @retval EFI_VOLUME_CORRUPTED    The file system structures are corrupted.

+  @retval EFI_WRITE_PROTECTED     The file or medium is write protected.

+  @retval EFI_ACCESS_DENIED       The file was opened read only.

+  @retval EFI_OUT_OF_RESOURCES    Not enough resources were available to open the

+                                  file.

+  @retval other                   The file failed to open

+**/

+EFI_STATUS

+EFIAPI

+ShellDeleteFileByName(

+  IN CONST CHAR16               *FileName

+  );

+

+/**

+  Function to print help file / man page content in the spec from the UEFI Shell protocol GetHelpText function.

+

+  @param[in] CommandToGetHelpOn  Pointer to a string containing the command name of help file to be printed.

+  @param[in] SectionToGetHelpOn  Pointer to the section specifier(s).

+  @param[in] PrintCommandText    If TRUE, prints the command followed by the help content, otherwise prints 

+                                 the help content only.

+  @retval EFI_DEVICE_ERROR       The help data format was incorrect.

+  @retval EFI_NOT_FOUND          The help data could not be found.

+  @retval EFI_SUCCESS            The operation was successful.

+**/

+EFI_STATUS

+EFIAPI

+ShellPrintHelp (

+  IN CONST CHAR16     *CommandToGetHelpOn,

+  IN CONST CHAR16     *SectionToGetHelpOn,

+  IN BOOLEAN          PrintCommandText

+  );

+

 #endif // __SHELL_LIB__

diff --git a/ShellPkg/Library/UefiDpLib/Dp.c b/ShellPkg/Library/UefiDpLib/Dp.c
new file mode 100644
index 00000000..82701723
--- /dev/null
+++ b/ShellPkg/Library/UefiDpLib/Dp.c
@@ -0,0 +1,319 @@
+/** @file

+  Shell command for Displaying Performance Metrics.

+

+  The Dp command reads performance data and presents it in several

+  different formats depending upon the needs of the user.  Both

+  Trace and Measured Profiling information is processed and presented.

+

+  Dp uses the "PerformanceLib" to read the measurement records.

+  The "TimerLib" provides information about the timer, such as frequency,

+  beginning, and ending counter values.

+  Measurement records contain identifying information (Handle, Token, Module)

+  and start and end time values.

+  Dp uses this information to group records in different ways.  It also uses

+  timer information to calculate elapsed time for each measurement.

+ 

+  Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+ 

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+**/

+

+#include "UefiDpLib.h"

+#include <Guid/GlobalVariable.h>

+#include <Library/PrintLib.h>

+#include <Library/HandleParsingLib.h>

+#include <Library/DevicePathLib.h>

+

+#include <Library/ShellLib.h>

+#include <Library/BaseLib.h>

+#include <Library/MemoryAllocationLib.h>

+#include <Library/DebugLib.h>

+#include <Library/TimerLib.h>

+#include <Library/UefiLib.h>

+

+#include <Guid/Performance.h>

+

+#include "PerformanceTokens.h"

+#include "Dp.h"

+#include "Literals.h"

+#include "DpInternal.h"

+

+//

+/// Module-Global Variables

+///@{

+CHAR16           mGaugeString[DP_GAUGE_STRING_LENGTH + 1];

+CHAR16           mUnicodeToken[DXE_PERFORMANCE_STRING_SIZE];

+UINT64           mInterestThreshold;

+BOOLEAN          mShowId = FALSE;

+

+PERF_SUMMARY_DATA SummaryData = { 0 };    ///< Create the SummaryData structure and init. to ZERO.

+

+/// Timer Specific Information.

+TIMER_INFO TimerInfo;

+

+/// Items for which to gather cumulative statistics.

+PERF_CUM_DATA CumData[] = {

+  PERF_INIT_CUM_DATA (LOAD_IMAGE_TOK),

+  PERF_INIT_CUM_DATA (START_IMAGE_TOK),

+  PERF_INIT_CUM_DATA (DRIVERBINDING_START_TOK),

+  PERF_INIT_CUM_DATA (DRIVERBINDING_SUPPORT_TOK)

+};

+

+/// Number of items for which we are gathering cumulative statistics.

+UINT32 const      NumCum = sizeof(CumData) / sizeof(PERF_CUM_DATA);

+

+STATIC CONST SHELL_PARAM_ITEM ParamList[] = {

+  {L"-v", TypeFlag},   // -v   Verbose Mode

+  {L"-A", TypeFlag},   // -A   All, Cooked

+  {L"-R", TypeFlag},   // -R   RAW All

+  {L"-s", TypeFlag},   // -s   Summary

+#if PROFILING_IMPLEMENTED

+  {L"-P", TypeFlag},   // -P   Dump Profile Data

+  {L"-T", TypeFlag},   // -T   Dump Trace Data

+#endif // PROFILING_IMPLEMENTED

+  {L"-x", TypeFlag},   // -x   eXclude Cumulative Items

+  {L"-i", TypeFlag},   // -i   Display Identifier

+  {L"-n", TypeValue},  // -n # Number of records to display for A and R

+  {L"-t", TypeValue},  // -t # Threshold of interest

+  {NULL, TypeMax}

+  };

+

+///@}

+

+/**

+   Display the trailing Verbose information.

+**/

+VOID

+DumpStatistics( void )

+{

+  EFI_STRING                StringPtr;

+  EFI_STRING                StringPtrUnknown;

+  StringPtr        = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_DP_SECTION_STATISTICS), NULL);

+  StringPtrUnknown = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL);

+  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_SECTION_HEADER), gDpHiiHandle,

+              (StringPtr == NULL) ? StringPtrUnknown : StringPtr);

+  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_STATS_NUMTRACE), gDpHiiHandle,      SummaryData.NumTrace);

+  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_STATS_NUMINCOMPLETE), gDpHiiHandle, SummaryData.NumIncomplete);

+  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_STATS_NUMPHASES), gDpHiiHandle,     SummaryData.NumSummary);

+  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_STATS_NUMHANDLES), gDpHiiHandle,    SummaryData.NumHandles, SummaryData.NumTrace - SummaryData.NumHandles);

+  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_STATS_NUMPEIMS), gDpHiiHandle,      SummaryData.NumPEIMs);

+  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_STATS_NUMGLOBALS), gDpHiiHandle,    SummaryData.NumGlobal);

+#if PROFILING_IMPLEMENTED

+  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_STATS_NUMPROFILE), gDpHiiHandle,    SummaryData.NumProfile);

+#endif // PROFILING_IMPLEMENTED

+  SHELL_FREE_NON_NULL (StringPtr);

+  SHELL_FREE_NON_NULL (StringPtrUnknown);

+}

+

+/** 

+  Dump performance data.

+  

+  @param[in]  ImageHandle     The image handle.

+  @param[in]  SystemTable     The system table.

+  

+  @retval EFI_SUCCESS            Command completed successfully.

+  @retval EFI_INVALID_PARAMETER  Command usage error.

+  @retval value                  Unknown error.

+  

+**/

+SHELL_STATUS

+EFIAPI

+ShellCommandRunDp (

+  IN EFI_HANDLE               ImageHandle,

+  IN EFI_SYSTEM_TABLE         *SystemTable

+  )

+{

+  LIST_ENTRY                *ParamPackage;

+  CONST CHAR16              *CmdLineArg;

+  EFI_STATUS                Status;

+

+  UINT64                    Freq;

+  UINT64                    Ticker;

+  UINTN                     Number2Display;

+

+  EFI_STRING                StringPtr;

+  BOOLEAN                   SummaryMode;

+  BOOLEAN                   VerboseMode;

+  BOOLEAN                   AllMode;

+  BOOLEAN                   RawMode;

+  BOOLEAN                   TraceMode;

+  BOOLEAN                   ProfileMode;

+  BOOLEAN                   ExcludeMode;

+

+  StringPtr   = NULL;

+  SummaryMode = FALSE;

+  VerboseMode = FALSE;

+  AllMode     = FALSE;

+  RawMode     = FALSE;

+  TraceMode   = FALSE;

+  ProfileMode = FALSE;

+  ExcludeMode = FALSE;

+

+  // Get DP's entry time as soon as possible.

+  // This is used as the Shell-Phase end time.

+  //

+  Ticker  = GetPerformanceCounter ();

+

+  //

+  // initialize the shell lib (we must be in non-auto-init...)

+  //

+  Status = ShellInitialize();

+  ASSERT_EFI_ERROR(Status);

+

+  Status = CommandInit();

+  ASSERT_EFI_ERROR(Status);

+

+  //

+  // Process Command Line arguments

+  //

+  Status = ShellCommandLineParse (ParamList, &ParamPackage, NULL, TRUE);

+  if (EFI_ERROR(Status)) {

+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_INVALID_ARG), gDpHiiHandle);

+    return SHELL_INVALID_PARAMETER;

+  }

+

+  //

+  // Boolean options

+  //

+  VerboseMode = ShellCommandLineGetFlag (ParamPackage, L"-v");

+  SummaryMode = (BOOLEAN) (ShellCommandLineGetFlag (ParamPackage, L"-S") || ShellCommandLineGetFlag (ParamPackage, L"-s"));

+  AllMode     = ShellCommandLineGetFlag (ParamPackage, L"-A");

+  RawMode     = ShellCommandLineGetFlag (ParamPackage, L"-R");

+#if PROFILING_IMPLEMENTED

+  TraceMode   = ShellCommandLineGetFlag (ParamPackage, L"-T");

+  ProfileMode = ShellCommandLineGetFlag (ParamPackage, L"-P");

+#endif  // PROFILING_IMPLEMENTED

+  ExcludeMode = ShellCommandLineGetFlag (ParamPackage, L"-x");

+  mShowId     = ShellCommandLineGetFlag (ParamPackage, L"-i");

+

+  // Options with Values

+  CmdLineArg  = ShellCommandLineGetValue (ParamPackage, L"-n");

+  if (CmdLineArg == NULL) {

+    Number2Display = DEFAULT_DISPLAYCOUNT;

+  } else {

+    Number2Display = StrDecimalToUintn(CmdLineArg);

+    if (Number2Display == 0) {

+      Number2Display = MAXIMUM_DISPLAYCOUNT;

+    }

+  }

+

+  CmdLineArg  = ShellCommandLineGetValue (ParamPackage, L"-t");

+  if (CmdLineArg == NULL) {

+    mInterestThreshold = DEFAULT_THRESHOLD;  // 1ms := 1,000 us

+  } else {

+    mInterestThreshold = StrDecimalToUint64(CmdLineArg);

+  }

+

+  // Handle Flag combinations and default behaviors

+  // If both TraceMode and ProfileMode are FALSE, set them both to TRUE

+  if ((! TraceMode) && (! ProfileMode)) {

+    TraceMode   = TRUE;

+#if PROFILING_IMPLEMENTED

+    ProfileMode = TRUE;

+#endif  // PROFILING_IMPLEMENTED

+  }

+

+  //

+  // Timer specific processing

+  //

+  // Get the Performance counter characteristics:

+  //          Freq = Frequency in Hz

+  //    StartCount = Value loaded into the counter when it starts counting

+  //      EndCount = Value counter counts to before it needs to be reset

+  //

+  Freq = GetPerformanceCounterProperties (&TimerInfo.StartCount, &TimerInfo.EndCount);

+

+  // Convert the Frequency from Hz to KHz

+  TimerInfo.Frequency = (UINT32)DivU64x32 (Freq, 1000);

+

+  // Determine in which direction the performance counter counts.

+  TimerInfo.CountUp = (BOOLEAN) (TimerInfo.EndCount >= TimerInfo.StartCount);

+

+  //

+  // Print header

+  //

+  // print DP's build version

+  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_BUILD_REVISION), gDpHiiHandle, DP_MAJOR_VERSION, DP_MINOR_VERSION);

+

+  // print performance timer characteristics

+  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_KHZ), gDpHiiHandle, TimerInfo.Frequency);

+

+  if (VerboseMode && !RawMode) {

+    StringPtr = HiiGetString (gDpHiiHandle,

+                  (EFI_STRING_ID) (TimerInfo.CountUp ? STRING_TOKEN (STR_DP_UP) : STRING_TOKEN (STR_DP_DOWN)), NULL);

+    ASSERT (StringPtr != NULL);

+    // Print Timer count range and direction

+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_TIMER_PROPERTIES), gDpHiiHandle,

+                StringPtr,

+                TimerInfo.StartCount,

+                TimerInfo.EndCount

+                );

+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_VERBOSE_THRESHOLD), gDpHiiHandle, mInterestThreshold);

+  }

+

+/****************************************************************************

+****            Print Sections based on command line options

+****

+****  Option modes have the following priority:

+****    v Verbose     --  Valid in combination with any other options

+****    t Threshold   --  Modifies All, Raw, and Cooked output

+****                      Default is 0 for All and Raw mode

+****                      Default is DEFAULT_THRESHOLD for "Cooked" mode

+****    n Number2Display  Used by All and Raw mode.  Otherwise ignored.

+****    A All         --  R and S options are ignored

+****    R Raw         --  S option is ignored

+****    s Summary     --  Modifies "Cooked" output only

+****    Cooked (Default)

+****

+****  The All, Raw, and Cooked modes are modified by the Trace and Profile

+****  options.

+****    !T && !P  := (0) Default, Both are displayed

+****     T && !P  := (1) Only Trace records are displayed

+****    !T &&  P  := (2) Only Profile records are displayed

+****     T &&  P  := (3) Same as Default, both are displayed

+****************************************************************************/

+  GatherStatistics();

+  if (AllMode) {

+    if (TraceMode) {

+      DumpAllTrace( Number2Display, ExcludeMode);

+    }

+    if (ProfileMode) {

+      DumpAllProfile( Number2Display, ExcludeMode);

+    }

+  } else if (RawMode) {

+    if (TraceMode) {

+      DumpRawTrace( Number2Display, ExcludeMode);

+    }

+    if (ProfileMode) {

+      DumpRawProfile( Number2Display, ExcludeMode);

+    }

+  } else {

+    //------------- Begin Cooked Mode Processing

+    if (TraceMode) {

+      ProcessPhases ( Ticker );

+      if ( ! SummaryMode) {

+        Status = ProcessHandles ( ExcludeMode);

+        if ( ! EFI_ERROR( Status)) {

+          ProcessPeims ();

+          ProcessGlobal ();

+          ProcessCumulative ();

+        }

+      }

+    }

+    if (ProfileMode) {

+      DumpAllProfile( Number2Display, ExcludeMode);

+    }

+  } //------------- End of Cooked Mode Processing

+  if ( VerboseMode || SummaryMode) {

+    DumpStatistics();

+  }

+

+  SHELL_FREE_NON_NULL (StringPtr);

+

+  return SHELL_SUCCESS;

+}

diff --git a/ShellPkg/Library/UefiDpLib/Dp.h b/ShellPkg/Library/UefiDpLib/Dp.h
new file mode 100644
index 00000000..72e2c3ba
--- /dev/null
+++ b/ShellPkg/Library/UefiDpLib/Dp.h
@@ -0,0 +1,98 @@
+/** @file

+  Common declarations for the Dp Performance Reporting Utility.

+

+  Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+**/

+

+#ifndef _EFI_APP_DP_H_

+#define _EFI_APP_DP_H_

+

+#include <Library/ShellLib.h>

+#include <ShellBase.h>

+

+#define DP_MAJOR_VERSION        2

+#define DP_MINOR_VERSION        4

+

+/**

+  * The value assigned to DP_DEBUG controls which debug output

+  * is generated.  Set it to ZERO to disable.

+**/

+#define DP_DEBUG                0

+

+/**

+  * Set to 1 once Profiling has been implemented in order to enable

+  * profiling related options and report output.

+**/

+#define PROFILING_IMPLEMENTED   0

+

+#define DEFAULT_THRESHOLD       1000    ///< One millisecond.

+#define DEFAULT_DISPLAYCOUNT    50

+#define MAXIMUM_DISPLAYCOUNT    999999  ///< Arbitrary maximum reasonable number.

+

+#define PERF_MAXDUR             0xFFFFFFFFFFFFFFFFULL

+

+/// Determine whether  0 <= C < L.  If L == 0, return true regardless of C.

+#define WITHIN_LIMIT( C, L)   ( ((L) == 0) || ((C) < (L)) )

+

+/// Structure for storing Timer specific information.

+typedef struct {

+  UINT64    StartCount;   ///< Value timer is initialized with.

+  UINT64    EndCount;     ///< Value timer has just before it wraps.

+  UINT32    Frequency;    ///< Timer count frequency in KHz.

+  BOOLEAN   CountUp;      ///< TRUE if the counter counts up.

+} TIMER_INFO;

+

+/** Initialize one PERF_CUM_DATA structure instance for token t.

+  *

+  * This parameterized macro takes a single argument, t, which is expected

+  * to resolve to a pointer to an ASCII string literal.  This parameter may

+  * take any one of the following forms:

+  *   - PERF_INIT_CUM_DATA("Token")         A string literal

+  *   - PERF_INIT_CUM_DATA(pointer)         A pointer -- CHAR8 *pointer;

+  *   - PERF_INIT_CUM_DATA(array)           Address of an array -- CHAR8 array[N];

+**/

+#define PERF_INIT_CUM_DATA(t)   { 0ULL, PERF_MAXDUR, 0ULL, (t), 0U }

+

+typedef struct {

+  UINT64  Duration;     ///< Cumulative duration for this item.

+  UINT64  MinDur;       ///< Smallest duration encountered.

+  UINT64  MaxDur;       ///< Largest duration encountered.

+  CHAR8   *Name;        ///< ASCII name of this item.

+  UINT32  Count;        ///< Total number of measurements accumulated.

+} PERF_CUM_DATA;

+

+typedef struct {

+  UINT32                NumTrace;         ///< Number of recorded TRACE performance measurements.

+  UINT32                NumProfile;       ///< Number of recorded PROFILE performance measurements.

+  UINT32                NumIncomplete;    ///< Number of measurements with no END value.

+  UINT32                NumSummary;       ///< Number of summary section measurements.

+  UINT32                NumHandles;       ///< Number of measurements with handles.

+  UINT32                NumPEIMs;         ///< Number of measurements of PEIMs.

+  UINT32                NumGlobal;        ///< Number of measurements with END value and NULL handle.

+} PERF_SUMMARY_DATA;

+

+typedef struct {

+  CONST VOID            *Handle;

+  CONST CHAR8           *Token;           ///< Measured token string name.

+  CONST CHAR8           *Module;          ///< Module string name.

+  UINT64                StartTimeStamp;   ///< Start time point.

+  UINT64                EndTimeStamp;     ///< End time point.

+  UINT32                Identifier;       ///< Identifier.

+} MEASUREMENT_RECORD;

+

+typedef struct {

+  CHAR8                 *Name;            ///< Measured token string name.

+  UINT64                CumulativeTime;   ///< Accumulated Elapsed Time.

+  UINT64                MinTime;          ///< Minimum Elapsed Time.

+  UINT64                MaxTime;          ///< Maximum Elapsed Time.

+  UINT32                Count;            ///< Number of measurements accumulated.

+} PROFILE_RECORD;

+

+#endif  // _EFI_APP_DP_H_

diff --git a/ShellPkg/Library/UefiDpLib/DpInternal.h b/ShellPkg/Library/UefiDpLib/DpInternal.h
new file mode 100644
index 00000000..c7d9a592
--- /dev/null
+++ b/ShellPkg/Library/UefiDpLib/DpInternal.h
@@ -0,0 +1,340 @@
+/** @file

+  Declarations of objects defined internally to the Dp Application.

+

+  Declarations of data and functions which are private to the Dp application.

+  This file should never be referenced by anything other than components of the

+  Dp application.  In addition to global data, function declarations for

+  DpUtilities.c, DpTrace.c, and DpProfile.c are included here.

+

+  Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+**/

+#ifndef _DP_INTELNAL_H_

+#define _DP_INTELNAL_H_

+

+#define DP_GAUGE_STRING_LENGTH   36

+

+//

+/// Module-Global Variables

+///@{

+extern EFI_HII_HANDLE     gDpHiiHandle;

+extern CHAR16             mGaugeString[DP_GAUGE_STRING_LENGTH + 1];

+extern CHAR16             mUnicodeToken[DXE_PERFORMANCE_STRING_SIZE];

+extern UINT64             mInterestThreshold;

+extern BOOLEAN            mShowId;

+

+extern PERF_SUMMARY_DATA  SummaryData;    ///< Create the SummaryData structure and init. to ZERO.

+

+/// Timer Specific Information.

+extern TIMER_INFO         TimerInfo;

+

+/// Items for which to gather cumulative statistics.

+extern PERF_CUM_DATA      CumData[];

+

+/// Number of items for which we are gathering cumulative statistics.

+extern UINT32 const       NumCum;

+

+///@}

+

+/** 

+  Calculate an event's duration in timer ticks.

+  

+  Given the count direction and the event's start and end timer values,

+  calculate the duration of the event in timer ticks.  Information for

+  the current measurement is pointed to by the parameter.

+  

+  If the measurement's start time is 1, it indicates that the developer

+  is indicating that the measurement began at the release of reset.

+  The start time is adjusted to the timer's starting count before performing

+  the elapsed time calculation.

+  

+  The calculated duration, in ticks, is the absolute difference between

+  the measurement's ending and starting counts.

+  

+  @param Measurement   Pointer to a MEASUREMENT_RECORD structure containing

+                       data for the current measurement.

+  

+  @return              The 64-bit duration of the event.

+**/

+UINT64

+GetDuration (

+  IN OUT MEASUREMENT_RECORD *Measurement

+  );

+

+/** 

+  Determine whether the Measurement record is for an EFI Phase.

+  

+  The Token and Module members of the measurement record are checked.

+  Module must be empty and Token must be one of SEC, PEI, DXE, BDS, or SHELL.

+  

+  @param[in]  Measurement A pointer to the Measurement record to test.

+  

+  @retval     TRUE        The measurement record is for an EFI Phase.

+  @retval     FALSE       The measurement record is NOT for an EFI Phase.

+**/

+BOOLEAN

+IsPhase(

+  IN MEASUREMENT_RECORD *Measurement

+  );

+

+/** 

+  Get the file name portion of the Pdb File Name.

+  

+  The portion of the Pdb File Name between the last backslash and

+  either a following period or the end of the string is converted

+  to Unicode and copied into UnicodeBuffer.  The name is truncated,

+  if necessary, to ensure that UnicodeBuffer is not overrun.

+  

+  @param[in]  PdbFileName     Pdb file name.

+  @param[out] UnicodeBuffer   The resultant Unicode File Name.

+  

+**/

+VOID

+GetShortPdbFileName (

+  IN  CHAR8     *PdbFileName,

+  OUT CHAR16    *UnicodeBuffer

+  );

+

+/** 

+  Get a human readable name for an image handle.

+  The following methods will be tried orderly:

+    1. Image PDB

+    2. ComponentName2 protocol

+    3. FFS UI section

+    4. Image GUID

+    5. Image DevicePath

+    6. Unknown Driver Name

+  

+  @param[in]    Handle

+  

+  @post   The resulting Unicode name string is stored in the

+          mGaugeString global array.

+  

+**/

+VOID

+GetNameFromHandle (

+  IN EFI_HANDLE Handle

+  );

+

+/** 

+  Calculate the Duration in microseconds.

+  

+  Duration is multiplied by 1000, instead of Frequency being divided by 1000 or

+  multiplying the result by 1000, in order to maintain precision.  Since Duration is

+  a 64-bit value, multiplying it by 1000 is unlikely to produce an overflow.

+  

+  The time is calculated as (Duration * 1000) / Timer_Frequency.

+  

+  @param[in]  Duration   The event duration in timer ticks.

+  

+  @return     A 64-bit value which is the Elapsed time in microseconds.

+**/

+UINT64

+DurationInMicroSeconds (

+  IN UINT64 Duration

+  );

+

+/** 

+  Get index of Measurement Record's match in the CumData array.

+  

+  If the Measurement's Token value matches a Token in one of the CumData

+  records, the index of the matching record is returned.  The returned

+  index is a signed value so that negative values can indicate that

+  the Measurement didn't match any entry in the CumData array.

+  

+  @param[in]  Measurement A pointer to a Measurement Record to match against the CumData array.

+  

+  @retval     <0    Token is not in the CumData array.

+  @retval     >=0   Return value is the index into CumData where Token is found.

+**/

+INTN

+GetCumulativeItem(

+  IN MEASUREMENT_RECORD *Measurement

+  );

+

+/** 

+  Collect verbose statistics about the logged performance measurements.

+  

+  General Summary information for all Trace measurements is gathered and

+  stored within the SummaryData structure.  This information is both

+  used internally by subsequent reporting functions, and displayed

+  at the end of verbose reports.

+  

+  @pre  The SummaryData and CumData structures must be initialized

+        prior to calling this function.

+  

+  @post The SummaryData and CumData structures contain statistics for the

+        current performance logs.

+**/

+VOID

+GatherStatistics(

+  VOID

+  );

+

+/** 

+  Gather and print ALL Trace Records.

+  

+  Displays all "interesting" Trace measurements in order.<BR>

+  The number of records displayed is controlled by:

+     - records with a duration less than mInterestThreshold microseconds are not displayed.

+     - No more than Limit records are displayed.  A Limit of zero will not limit the output.

+     - If the ExcludeFlag is TRUE, records matching entries in the CumData array are not

+       displayed.

+  

+  @pre    The mInterestThreshold global variable is set to the shortest duration to be printed.

+           The mGaugeString and mUnicodeToken global arrays are used for temporary string storage.

+           They must not be in use by a calling function.

+  

+  @param[in]    Limit       The number of records to print.  Zero is ALL.

+  @param[in]    ExcludeFlag TRUE to exclude individual Cumulative items from display.

+  

+**/

+VOID

+DumpAllTrace(

+  IN UINTN             Limit,

+  IN BOOLEAN           ExcludeFlag

+  );

+

+/** 

+  Gather and print Raw Trace Records.

+  

+  All Trace measurements with a duration greater than or equal to

+  mInterestThreshold are printed without interpretation.

+  

+  The number of records displayed is controlled by:

+     - records with a duration less than mInterestThreshold microseconds are not displayed.

+     - No more than Limit records are displayed.  A Limit of zero will not limit the output.

+     - If the ExcludeFlag is TRUE, records matching entries in the CumData array are not

+       displayed.

+  

+  @pre    The mInterestThreshold global variable is set to the shortest duration to be printed.

+  

+  @param[in]    Limit       The number of records to print.  Zero is ALL.

+  @param[in]    ExcludeFlag TRUE to exclude individual Cumulative items from display.

+  

+**/

+VOID

+DumpRawTrace(

+  IN UINTN          Limit,

+  IN BOOLEAN        ExcludeFlag

+  );

+

+/** 

+  Gather and print Major Phase metrics.

+  

+  @param[in]    Ticker      The timer value for the END of Shell phase

+  

+**/

+VOID

+ProcessPhases(

+  IN UINT64 Ticker

+  );

+

+

+/** 

+  Gather and print Handle data.

+  

+  @param[in]    ExcludeFlag   TRUE to exclude individual Cumulative items from display.

+  

+  @return       Status from a call to gBS->LocateHandle().

+**/

+EFI_STATUS

+ProcessHandles(

+  IN BOOLEAN ExcludeFlag

+  );

+

+

+/** 

+  Gather and print PEIM data.

+  

+  Only prints complete PEIM records

+  

+**/

+VOID

+ProcessPeims(

+  VOID

+  );

+

+/** 

+  Gather and print global data.

+  

+  Strips out incomplete or "Execution Phase" records

+  Only prints records where Handle is NULL

+  Increment TIndex for every record, even skipped ones, so that we have an

+  indication of every measurement record taken.

+  

+**/

+VOID

+ProcessGlobal(

+  VOID

+  );

+

+/** 

+  Gather and print cumulative data.

+  

+  Traverse the measurement records and:<BR>

+  For each record with a Token listed in the CumData array:<BR>

+     - Update the instance count and the total, minimum, and maximum durations.

+  Finally, print the gathered cumulative statistics.

+  

+**/

+VOID

+ProcessCumulative(

+  VOID

+  );

+

+/** 

+  Gather and print ALL Profiling Records.

+  

+  Displays all "interesting" Profile measurements in order.

+  The number of records displayed is controlled by:

+     - records with a duration less than mInterestThreshold microseconds are not displayed.

+     - No more than Limit records are displayed.  A Limit of zero will not limit the output.

+     - If the ExcludeFlag is TRUE, records matching entries in the CumData array are not

+       displayed.

+  

+  @pre    The mInterestThreshold global variable is set to the shortest duration to be printed.

+           The mGaugeString and mUnicodeToken global arrays are used for temporary string storage.

+           They must not be in use by a calling function.

+  

+  @param[in]    Limit         The number of records to print.  Zero is ALL.

+  @param[in]    ExcludeFlag   TRUE to exclude individual Cumulative items from display.

+  

+**/

+VOID

+DumpAllProfile(

+  IN UINTN          Limit,

+  IN BOOLEAN        ExcludeFlag

+  );

+

+/** 

+  Gather and print Raw Profile Records.

+  

+  All Profile measurements with a duration greater than or equal to

+  mInterestThreshold are printed without interpretation.

+  

+  The number of records displayed is controlled by:

+     - records with a duration less than mInterestThreshold microseconds are not displayed.

+     - No more than Limit records are displayed.  A Limit of zero will not limit the output.

+     - If the ExcludeFlag is TRUE, records matching entries in the CumData array are not

+       displayed.

+  

+  @pre    The mInterestThreshold global variable is set to the shortest duration to be printed.

+  

+  @param[in]    Limit         The number of records to print.  Zero is ALL.

+  @param[in]    ExcludeFlag   TRUE to exclude individual Cumulative items from display.

+  

+**/

+VOID

+DumpRawProfile(

+  IN UINTN          Limit,

+  IN BOOLEAN        ExcludeFlag

+  );

+

+#endif

diff --git a/ShellPkg/Library/UefiDpLib/DpProfile.c b/ShellPkg/Library/UefiDpLib/DpProfile.c
new file mode 100644
index 00000000..64583988
--- /dev/null
+++ b/ShellPkg/Library/UefiDpLib/DpProfile.c
@@ -0,0 +1,101 @@
+/** @file

+  Measured Profiling reporting for the Dp utility.

+

+  Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+**/

+

+#include <Library/BaseLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/MemoryAllocationLib.h>

+#include <Library/DebugLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/TimerLib.h>

+#include <Library/PeCoffGetEntryPointLib.h>

+#include <Library/PerformanceLib.h>

+#include <Library/PrintLib.h>

+#include <Library/HiiLib.h>

+#include <Library/PcdLib.h>

+

+#include <Guid/Performance.h>

+

+#include "Dp.h"

+#include "Literals.h"

+#include "DpInternal.h"

+

+/** 

+  Gather and print ALL Profiling Records.

+  

+  Displays all "interesting" Profile measurements in order.

+  The number of records displayed is controlled by:

+     - records with a duration less than mInterestThreshold microseconds are not displayed.

+     - No more than Limit records are displayed.  A Limit of zero will not limit the output.

+     - If the ExcludeFlag is TRUE, records matching entries in the CumData array are not

+       displayed.

+  

+  @pre    The mInterestThreshold global variable is set to the shortest duration to be printed.

+           The mGaugeString and mUnicodeToken global arrays are used for temporary string storage.

+           They must not be in use by a calling function.

+  

+  @param[in]    Limit         The number of records to print.  Zero is ALL.

+  @param[in]    ExcludeFlag   TRUE to exclude individual Cumulative items from display.

+  

+**/

+VOID

+DumpAllProfile(

+  IN UINTN      Limit,

+  IN BOOLEAN    ExcludeFlag

+  )

+{

+  EFI_STRING    StringPtr;

+  EFI_STRING    StringPtrUnknown;

+

+  StringPtrUnknown = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL);   

+  StringPtr = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_DP_SECTION_PROFILE), NULL);

+

+  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_SECTION_HEADER), gDpHiiHandle, 

+              (StringPtr == NULL) ? StringPtrUnknown: StringPtr);

+  FreePool (StringPtr);

+  FreePool (StringPtrUnknown);

+}

+

+/** 

+  Gather and print Raw Profile Records.

+  

+  All Profile measurements with a duration greater than or equal to

+  mInterestThreshold are printed without interpretation.

+  

+  The number of records displayed is controlled by:

+     - records with a duration less than mInterestThreshold microseconds are not displayed.

+     - No more than Limit records are displayed.  A Limit of zero will not limit the output.

+     - If the ExcludeFlag is TRUE, records matching entries in the CumData array are not

+       displayed.

+  

+  @pre    The mInterestThreshold global variable is set to the shortest duration to be printed.

+  

+  @param[in]    Limit         The number of records to print.  Zero is ALL.

+  @param[in]    ExcludeFlag   TRUE to exclude individual Cumulative items from display.

+  

+**/

+VOID

+DumpRawProfile(

+  IN UINTN      Limit,

+  IN BOOLEAN    ExcludeFlag

+  )

+{

+  EFI_STRING    StringPtr;

+  EFI_STRING    StringPtrUnknown;

+

+  StringPtrUnknown = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL);

+  StringPtr = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_DP_SECTION_RAWPROFILE), NULL);

+  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_SECTION_HEADER), gDpHiiHandle, 

+              (StringPtr == NULL) ? StringPtrUnknown: StringPtr);

+  FreePool (StringPtr);

+  FreePool (StringPtrUnknown);

+}

diff --git a/ShellPkg/Library/UefiDpLib/DpTrace.c b/ShellPkg/Library/UefiDpLib/DpTrace.c
new file mode 100644
index 00000000..de1d45aa
--- /dev/null
+++ b/ShellPkg/Library/UefiDpLib/DpTrace.c
@@ -0,0 +1,828 @@
+/** @file

+  Trace reporting for the Dp utility.

+

+  Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+**/

+

+#include <Library/BaseLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/MemoryAllocationLib.h>

+#include <Library/DebugLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/TimerLib.h>

+#include <Library/PeCoffGetEntryPointLib.h>

+#include <Library/PerformanceLib.h>

+#include <Library/PrintLib.h>

+#include <Library/HiiLib.h>

+#include <Library/PcdLib.h>

+

+#include <Guid/Performance.h>

+

+#include "Dp.h"

+#include "Literals.h"

+#include "DpInternal.h"

+

+/** 

+  Collect verbose statistics about the logged performance measurements.

+  

+  General Summary information for all Trace measurements is gathered and

+  stored within the SummaryData structure.  This information is both

+  used internally by subsequent reporting functions, and displayed

+  at the end of verbose reports.

+  

+  @pre  The SummaryData and CumData structures must be initialized

+        prior to calling this function.

+  

+  @post The SummaryData and CumData structures contain statistics for the

+        current performance logs.

+**/

+VOID

+GatherStatistics(

+  VOID

+)

+{

+  MEASUREMENT_RECORD        Measurement;

+  UINT64                    Duration;

+  UINTN                     LogEntryKey;

+  INTN                      TIndex;

+

+  LogEntryKey = 0;

+  while ((LogEntryKey = GetPerformanceMeasurementEx (

+                        LogEntryKey,

+                        &Measurement.Handle,

+                        &Measurement.Token,

+                        &Measurement.Module,

+                        &Measurement.StartTimeStamp,

+                        &Measurement.EndTimeStamp,

+                        &Measurement.Identifier)) != 0)

+  {

+    ++SummaryData.NumTrace;           // Count the number of TRACE Measurement records

+    if (Measurement.EndTimeStamp == 0) {

+      ++SummaryData.NumIncomplete;    // Count the incomplete records

+      continue;

+    }

+

+    if (Measurement.Handle != NULL) {

+      ++SummaryData.NumHandles;       // Count the number of measurements with non-NULL handles

+    }

+

+    if (IsPhase( &Measurement)) {

+      ++SummaryData.NumSummary;       // Count the number of major phases

+    }

+    else {  // !IsPhase(...

+      if(Measurement.Handle == NULL) {

+        ++SummaryData.NumGlobal;

+      }

+    }

+

+    if (AsciiStrnCmp (Measurement.Token, ALit_PEIM, PERF_TOKEN_LENGTH) == 0) {

+      ++SummaryData.NumPEIMs;         // Count PEIM measurements

+    }

+

+    Duration = GetDuration (&Measurement);

+    TIndex = GetCumulativeItem (&Measurement);

+    if (TIndex >= 0) {

+      CumData[TIndex].Duration += Duration;

+      CumData[TIndex].Count++;

+      if ( Duration < CumData[TIndex].MinDur ) {

+        CumData[TIndex].MinDur = Duration;

+      }

+      if ( Duration > CumData[TIndex].MaxDur ) {

+        CumData[TIndex].MaxDur = Duration;

+      }

+    }

+  }

+}

+

+/** 

+  Gather and print ALL Trace Records.

+  

+  Displays all "interesting" Trace measurements in order.<BR>

+  The number of records displayed is controlled by:

+     - records with a duration less than mInterestThreshold microseconds are not displayed.

+     - No more than Limit records are displayed.  A Limit of zero will not limit the output.

+     - If the ExcludeFlag is TRUE, records matching entries in the CumData array are not

+       displayed.

+  

+  @pre    The mInterestThreshold global variable is set to the shortest duration to be printed.

+           The mGaugeString and mUnicodeToken global arrays are used for temporary string storage.

+           They must not be in use by a calling function.

+  

+  @param[in]    Limit       The number of records to print.  Zero is ALL.

+  @param[in]    ExcludeFlag TRUE to exclude individual Cumulative items from display.

+  

+**/

+VOID

+DumpAllTrace(

+  IN UINTN             Limit,

+  IN BOOLEAN           ExcludeFlag

+  )

+{

+  MEASUREMENT_RECORD        Measurement;

+  UINT64                    ElapsedTime;

+  UINT64                    Duration;

+  CHAR16                    *IncFlag;

+  UINTN                     LogEntryKey;

+  UINTN                     Count;

+  UINTN                     Index;

+  UINTN                     TIndex;

+

+  EFI_HANDLE                *HandleBuffer;

+  UINTN                     Size;

+  EFI_HANDLE                TempHandle;

+  EFI_STATUS                Status;

+  EFI_STRING                StringPtrUnknown;

+

+  StringPtrUnknown = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL);

+  IncFlag = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_DP_SECTION_ALL), NULL);

+  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_SECTION_HEADER), gDpHiiHandle,

+              (IncFlag == NULL) ? StringPtrUnknown : IncFlag);

+  FreePool (StringPtrUnknown);

+

+  // Get Handle information

+  //

+  Size = 0;

+  HandleBuffer = &TempHandle;

+  Status  = gBS->LocateHandle (AllHandles, NULL, NULL, &Size, &TempHandle);

+  if (Status == EFI_BUFFER_TOO_SMALL) {

+    HandleBuffer = AllocatePool (Size);

+    ASSERT (HandleBuffer != NULL);

+    if (HandleBuffer == NULL) {

+      return;

+    }

+    Status  = gBS->LocateHandle (AllHandles, NULL, NULL, &Size, HandleBuffer);

+  }

+  if (EFI_ERROR (Status)) {

+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_HANDLES_ERROR), gDpHiiHandle, Status);

+  }

+  else {

+    // We have successfully populated the HandleBuffer

+    // Display ALL Measurement Records

+    //    Up to Limit lines displayed

+    //    Display only records with Elapsed times >= mInterestThreshold

+    //    Display driver names in Module field for records with Handles.

+    //

+    if (mShowId) {

+      ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_ALL_HEADR2), gDpHiiHandle);

+      ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_ALL_DASHES2), gDpHiiHandle);

+    } else {

+      ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_ALL_HEADR), gDpHiiHandle);

+      ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_DASHES), gDpHiiHandle);

+    }

+

+    LogEntryKey = 0;

+    Count = 0;

+    Index = 0;

+    while ( WITHIN_LIMIT(Count, Limit) &&

+            ((LogEntryKey = GetPerformanceMeasurementEx (

+                            LogEntryKey,

+                            &Measurement.Handle,

+                            &Measurement.Token,

+                            &Measurement.Module,

+                            &Measurement.StartTimeStamp,

+                            &Measurement.EndTimeStamp,

+                            &Measurement.Identifier)) != 0)

+          )

+    {

+      ++Index;    // Count every record.  First record is 1.

+      ElapsedTime = 0;

+      SHELL_FREE_NON_NULL (IncFlag);

+      if (Measurement.EndTimeStamp != 0) {

+        Duration = GetDuration (&Measurement);

+        ElapsedTime = DurationInMicroSeconds ( Duration );

+        IncFlag = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_DP_COMPLETE), NULL);

+      }

+      else {

+        IncFlag = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_DP_INCOMPLETE), NULL);  // Mark incomplete records

+      }

+      if (((Measurement.EndTimeStamp != 0) && (ElapsedTime < mInterestThreshold)) ||

+          ((ExcludeFlag) && (GetCumulativeItem(&Measurement) >= 0))

+         ) {      // Ignore "uninteresting" or excluded records

+        continue;

+      }

+      ++Count;    // Count the number of records printed

+

+      // If Handle is non-zero, see if we can determine a name for the driver

+      AsciiStrToUnicodeStr (Measurement.Module, mGaugeString); // Use Module by default

+      AsciiStrToUnicodeStr (Measurement.Token, mUnicodeToken);

+      if (Measurement.Handle != NULL) {

+        // See if the Handle is in the HandleBuffer

+        for (TIndex = 0; TIndex < (Size / sizeof(HandleBuffer[0])); TIndex++) {

+          if (Measurement.Handle == HandleBuffer[TIndex]) {

+            GetNameFromHandle (HandleBuffer[TIndex]);

+            break;

+          }

+        }

+      }

+

+      if (AsciiStrnCmp (Measurement.Token, ALit_PEIM, PERF_TOKEN_LENGTH) == 0) {

+        UnicodeSPrint (mGaugeString, sizeof (mGaugeString), L"%g", Measurement.Handle);

+      }

+

+      // Ensure that the argument strings are not too long.

+      mGaugeString[DP_GAUGE_STRING_LENGTH] = 0;

+      mUnicodeToken[13] = 0;

+

+      if (mShowId) {

+        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_ALL_VARS2), gDpHiiHandle,

+          Index,      // 1 based, Which measurement record is being printed

+          IncFlag,

+          Measurement.Handle,

+          mGaugeString,

+          mUnicodeToken,

+          ElapsedTime,

+          Measurement.Identifier

+        );

+      } else {

+        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_ALL_VARS), gDpHiiHandle,

+          Index,      // 1 based, Which measurement record is being printed

+          IncFlag,

+          Measurement.Handle,

+          mGaugeString,

+          mUnicodeToken,

+          ElapsedTime

+        );

+      }

+    }

+  }

+  if (HandleBuffer != &TempHandle) {

+    FreePool (HandleBuffer);

+  }

+  SHELL_FREE_NON_NULL (IncFlag);

+}

+

+/** 

+  Gather and print Raw Trace Records.

+  

+  All Trace measurements with a duration greater than or equal to

+  mInterestThreshold are printed without interpretation.

+  

+  The number of records displayed is controlled by:

+     - records with a duration less than mInterestThreshold microseconds are not displayed.

+     - No more than Limit records are displayed.  A Limit of zero will not limit the output.

+     - If the ExcludeFlag is TRUE, records matching entries in the CumData array are not

+       displayed.

+  

+  @pre    The mInterestThreshold global variable is set to the shortest duration to be printed.

+  

+  @param[in]    Limit       The number of records to print.  Zero is ALL.

+  @param[in]    ExcludeFlag TRUE to exclude individual Cumulative items from display.

+  

+**/

+VOID

+DumpRawTrace(

+  IN UINTN          Limit,

+  IN BOOLEAN        ExcludeFlag

+  )

+{

+  MEASUREMENT_RECORD        Measurement;

+  UINT64                    ElapsedTime;

+  UINT64                    Duration;

+  UINTN                     LogEntryKey;

+  UINTN                     Count;

+  UINTN                     Index;

+

+  EFI_STRING    StringPtr;

+  EFI_STRING    StringPtrUnknown;

+

+  StringPtrUnknown = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL);  

+  StringPtr = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_DP_SECTION_RAWTRACE), NULL);

+  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_SECTION_HEADER), gDpHiiHandle,

+              (StringPtr == NULL) ? StringPtrUnknown : StringPtr);

+  FreePool (StringPtr);

+  FreePool (StringPtrUnknown);

+

+  if (mShowId) {

+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_RAW_HEADR2), gDpHiiHandle);

+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_RAW_DASHES2), gDpHiiHandle);

+  } else {

+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_RAW_HEADR), gDpHiiHandle);

+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_RAW_DASHES), gDpHiiHandle);

+  }

+

+  LogEntryKey = 0;

+  Count = 0;

+  Index = 0;

+  while ( WITHIN_LIMIT(Count, Limit) &&

+          ((LogEntryKey = GetPerformanceMeasurementEx (

+                          LogEntryKey,

+                          &Measurement.Handle,

+                          &Measurement.Token,

+                          &Measurement.Module,

+                          &Measurement.StartTimeStamp,

+                          &Measurement.EndTimeStamp,

+                          &Measurement.Identifier)) != 0)

+        )

+  {

+    ++Index;    // Count every record.  First record is 1.

+    ElapsedTime = 0;

+    if (Measurement.EndTimeStamp != 0) {

+      Duration = GetDuration (&Measurement);

+      ElapsedTime = DurationInMicroSeconds ( Duration );

+    }

+    if ((ElapsedTime < mInterestThreshold)                 ||

+        ((ExcludeFlag) && (GetCumulativeItem(&Measurement) >= 0))

+        ) { // Ignore "uninteresting" or Excluded records

+      continue;

+    }

+    ++Count;    // Count the number of records printed

+

+    if (mShowId) {

+      ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_RAW_VARS2), gDpHiiHandle,

+        Index,      // 1 based, Which measurement record is being printed

+        Measurement.Handle,

+        Measurement.StartTimeStamp,

+        Measurement.EndTimeStamp,

+        Measurement.Token,

+        Measurement.Module,

+        Measurement.Identifier

+      );

+    } else {

+      ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_RAW_VARS), gDpHiiHandle,

+        Index,      // 1 based, Which measurement record is being printed

+        Measurement.Handle,

+        Measurement.StartTimeStamp,

+        Measurement.EndTimeStamp,

+        Measurement.Token,

+        Measurement.Module

+      );

+    }

+  }

+}

+

+/** 

+  Gather and print Major Phase metrics.

+  

+  @param[in]    Ticker      The timer value for the END of Shell phase

+  

+**/

+VOID

+ProcessPhases(

+  IN UINT64            Ticker

+  )

+{

+  MEASUREMENT_RECORD        Measurement;

+  UINT64                    BdsTimeoutValue;

+  UINT64                    SecTime;

+  UINT64                    PeiTime;

+  UINT64                    DxeTime;

+  UINT64                    BdsTime;

+  UINT64                    ShellTime;

+  UINT64                    ElapsedTime;

+  UINT64                    Duration;

+  UINT64                    Total;

+  EFI_STRING                StringPtr;

+  UINTN                     LogEntryKey;

+  EFI_STRING                StringPtrUnknown;

+

+  BdsTimeoutValue = 0;

+  SecTime         = 0;

+  PeiTime         = 0;

+  DxeTime         = 0;

+  BdsTime         = 0;

+  ShellTime       = 0;   

+  //

+  // Get Execution Phase Statistics

+  //

+  StringPtrUnknown = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL);   

+  StringPtr = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_DP_SECTION_PHASES), NULL);

+  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_SECTION_HEADER), gDpHiiHandle,

+              (StringPtr == NULL) ? StringPtrUnknown : StringPtr);

+  FreePool (StringPtr);

+  FreePool (StringPtrUnknown);

+

+  LogEntryKey = 0;

+  while ((LogEntryKey = GetPerformanceMeasurementEx (

+                          LogEntryKey,

+                          &Measurement.Handle,

+                          &Measurement.Token,

+                          &Measurement.Module,

+                          &Measurement.StartTimeStamp,

+                          &Measurement.EndTimeStamp,

+                          &Measurement.Identifier)) != 0)

+  {

+    if (AsciiStrnCmp (Measurement.Token, ALit_SHELL, PERF_TOKEN_LENGTH) == 0) {

+      Measurement.EndTimeStamp = Ticker;

+    }

+    if (Measurement.EndTimeStamp == 0) { // Skip "incomplete" records

+      continue;

+    }

+    Duration = GetDuration (&Measurement);

+    if (   Measurement.Handle != NULL

+        && (AsciiStrnCmp (Measurement.Token, ALit_BdsTO, PERF_TOKEN_LENGTH) == 0)

+       )

+    {

+      BdsTimeoutValue = Duration;

+    } else if (AsciiStrnCmp (Measurement.Token, ALit_SEC, PERF_TOKEN_LENGTH) == 0) {

+      SecTime     = Duration;

+    } else if (AsciiStrnCmp (Measurement.Token, ALit_PEI, PERF_TOKEN_LENGTH) == 0) {

+      PeiTime     = Duration;

+    } else if (AsciiStrnCmp (Measurement.Token, ALit_DXE, PERF_TOKEN_LENGTH) == 0) {

+      DxeTime      = Duration;

+    } else if (AsciiStrnCmp (Measurement.Token, ALit_BDS, PERF_TOKEN_LENGTH) == 0) {

+      BdsTime      = Duration;

+    } else if (AsciiStrnCmp (Measurement.Token, ALit_SHELL, PERF_TOKEN_LENGTH) == 0) {

+      ShellTime    = Duration;

+    }

+  }

+

+  Total = 0;

+

+  // print SEC phase duration time

+  //

+  if (SecTime > 0) {

+    ElapsedTime = DurationInMicroSeconds ( SecTime );     // Calculate elapsed time in microseconds

+    Total += DivU64x32 (ElapsedTime, 1000);   // Accumulate time in milliseconds

+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_SEC_PHASE), gDpHiiHandle, ElapsedTime);

+  }

+

+  // print PEI phase duration time

+  //

+  if (PeiTime > 0) {

+    ElapsedTime = DivU64x32 (

+                    PeiTime,

+                    (UINT32)TimerInfo.Frequency

+                    );

+    Total += ElapsedTime;

+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_PHASE_DURATION), gDpHiiHandle, ALit_PEI, ElapsedTime);

+  }

+

+  // print DXE phase duration time

+  //

+  if (DxeTime > 0) {

+    ElapsedTime = DivU64x32 (

+                    DxeTime,

+                    (UINT32)TimerInfo.Frequency

+                    );

+    Total += ElapsedTime;

+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_PHASE_DURATION), gDpHiiHandle, ALit_DXE, ElapsedTime);

+  }

+

+  // print BDS phase duration time

+  //

+  if (BdsTime > 0) {

+    ElapsedTime = DivU64x32 (

+                    BdsTime,

+                    (UINT32)TimerInfo.Frequency

+                    );

+    Total += ElapsedTime;

+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_PHASE_DURATION), gDpHiiHandle, ALit_BDS, ElapsedTime);

+  }

+

+  if (BdsTimeoutValue > 0) {

+    ElapsedTime = DivU64x32 (

+                    BdsTimeoutValue,

+                    (UINT32)TimerInfo.Frequency

+                    );

+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_PHASE_BDSTO), gDpHiiHandle, ALit_BdsTO, ElapsedTime);

+  }

+

+  // print SHELL phase duration time

+  //

+  if (ShellTime > 0) {

+    ElapsedTime = DivU64x32 (

+                    ShellTime,

+                    (UINT32)TimerInfo.Frequency

+                    );

+    Total += ElapsedTime;

+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_PHASE_DURATION), gDpHiiHandle, ALit_SHELL, ElapsedTime);

+  }

+

+  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_TOTAL_DURATION), gDpHiiHandle, Total);

+}

+

+/** 

+  Gather and print Handle data.

+  

+  @param[in]    ExcludeFlag   TRUE to exclude individual Cumulative items from display.

+  

+  @return       Status from a call to gBS->LocateHandle().

+**/

+EFI_STATUS

+ProcessHandles(

+  IN BOOLEAN      ExcludeFlag

+  )

+{

+  MEASUREMENT_RECORD        Measurement;

+  UINT64                    ElapsedTime;

+  UINT64                    Duration;

+  EFI_HANDLE                *HandleBuffer;

+  EFI_STRING                StringPtr;

+  UINTN                     Index;

+  UINTN                     LogEntryKey;

+  UINTN                     Count;

+  UINTN                     Size;

+  EFI_HANDLE                TempHandle;

+  EFI_STATUS                Status;

+  EFI_STRING                StringPtrUnknown;

+

+  StringPtrUnknown = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL);  

+  StringPtr = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_DP_SECTION_DRIVERS), NULL);

+  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_SECTION_HEADER), gDpHiiHandle,

+              (StringPtr == NULL) ? StringPtrUnknown : StringPtr);

+  FreePool (StringPtr);

+  FreePool (StringPtrUnknown);

+

+  Size = 0;

+  HandleBuffer = &TempHandle;

+  Status  = gBS->LocateHandle (AllHandles, NULL, NULL, &Size, &TempHandle);

+  if (Status == EFI_BUFFER_TOO_SMALL) {

+    HandleBuffer = AllocatePool (Size);

+    ASSERT (HandleBuffer != NULL);

+    if (HandleBuffer == NULL) {

+      return Status;

+    }

+    Status  = gBS->LocateHandle (AllHandles, NULL, NULL, &Size, HandleBuffer);

+  }

+  if (EFI_ERROR (Status)) {

+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_HANDLES_ERROR), gDpHiiHandle, Status);

+  }

+  else {

+#if DP_DEBUG == 2

+    Print (L"There are %,d Handles defined.\n", (Size / sizeof(HandleBuffer[0])));

+#endif

+

+    if (mShowId) {

+      ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_HANDLE_SECTION2), gDpHiiHandle);

+    } else {

+      ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_HANDLE_SECTION), gDpHiiHandle);

+    }

+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_DASHES), gDpHiiHandle);

+

+    LogEntryKey = 0;

+    Count   = 0;

+    while ((LogEntryKey = GetPerformanceMeasurementEx (

+                            LogEntryKey,

+                            &Measurement.Handle,

+                            &Measurement.Token,

+                            &Measurement.Module,

+                            &Measurement.StartTimeStamp,

+                            &Measurement.EndTimeStamp,

+                            &Measurement.Identifier)) != 0)

+    {

+      Count++;

+      Duration = GetDuration (&Measurement);

+      ElapsedTime = DurationInMicroSeconds ( Duration );

+      if ((ElapsedTime < mInterestThreshold)                 ||

+          (Measurement.EndTimeStamp == 0)                    ||

+          (Measurement.Handle == NULL)                       ||

+          ((ExcludeFlag) && (GetCumulativeItem(&Measurement) >= 0))

+         ) { // Ignore "uninteresting" or excluded records

+        continue;

+      }

+      mGaugeString[0] = 0;    // Empty driver name by default

+      AsciiStrToUnicodeStr (Measurement.Token, mUnicodeToken);

+      // See if the Handle is in the HandleBuffer

+      for (Index = 0; Index < (Size / sizeof(HandleBuffer[0])); Index++) {

+        if (Measurement.Handle == HandleBuffer[Index]) {

+          GetNameFromHandle (HandleBuffer[Index]); // Name is put into mGaugeString

+          break;

+        }

+      }

+      // Ensure that the argument strings are not too long.

+      mGaugeString[DP_GAUGE_STRING_LENGTH] = 0;

+      mUnicodeToken[11] = 0;

+      if (mGaugeString[0] != 0) {

+        // Display the record if it has a valid handle.

+        if (mShowId) {

+          ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_HANDLE_VARS2), gDpHiiHandle,

+            Count,      // 1 based, Which measurement record is being printed

+            Index + 1,  // 1 based, Which handle is being printed

+            mGaugeString,

+            mUnicodeToken,

+            ElapsedTime,

+            Measurement.Identifier

+          );

+        } else {

+          ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_HANDLE_VARS), gDpHiiHandle,

+            Count,      // 1 based, Which measurement record is being printed

+            Index + 1,  // 1 based, Which handle is being printed

+            mGaugeString,

+            mUnicodeToken,

+            ElapsedTime

+          );

+        }

+      }

+    }

+  }

+  if (HandleBuffer != &TempHandle) {

+    FreePool (HandleBuffer);

+  }

+  return Status;

+}

+

+/** 

+  Gather and print PEIM data.

+  

+  Only prints complete PEIM records

+  

+**/

+VOID

+ProcessPeims(

+  VOID

+)

+{

+  MEASUREMENT_RECORD        Measurement;

+  UINT64                    Duration;

+  UINT64                    ElapsedTime;

+  EFI_STRING                StringPtr;

+  UINTN                     LogEntryKey;

+  UINTN                     TIndex;

+  EFI_STRING                StringPtrUnknown;

+

+  StringPtrUnknown = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL);  

+  StringPtr = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_DP_SECTION_PEIMS), NULL);

+  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_SECTION_HEADER), gDpHiiHandle,

+              (StringPtr == NULL) ? StringPtrUnknown : StringPtr);

+  FreePool (StringPtr);

+  FreePool (StringPtrUnknown);

+

+  if (mShowId) {

+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_PEIM_SECTION2), gDpHiiHandle);

+  } else {

+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_PEIM_SECTION), gDpHiiHandle);

+  }

+  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_DASHES), gDpHiiHandle);

+  TIndex  = 0;

+  LogEntryKey = 0;

+  while ((LogEntryKey = GetPerformanceMeasurementEx (

+                          LogEntryKey,

+                          &Measurement.Handle,

+                          &Measurement.Token,

+                          &Measurement.Module,

+                          &Measurement.StartTimeStamp,

+                          &Measurement.EndTimeStamp,

+                          &Measurement.Identifier)) != 0)

+  {

+    TIndex++;

+    if ((Measurement.EndTimeStamp == 0) ||

+        (AsciiStrnCmp (Measurement.Token, ALit_PEIM, PERF_TOKEN_LENGTH) != 0)

+       ) {

+      continue;

+    }

+

+    Duration = GetDuration (&Measurement);

+    ElapsedTime = DurationInMicroSeconds ( Duration );  // Calculate elapsed time in microseconds

+    if (ElapsedTime >= mInterestThreshold) {

+      // PEIM FILE Handle is the start address of its FFS file that contains its file guid.

+      if (mShowId) {

+        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_PEIM_VARS2), gDpHiiHandle,

+              TIndex,   // 1 based, Which measurement record is being printed

+              Measurement.Handle,  // base address

+              Measurement.Handle,  // file guid

+              ElapsedTime,

+              Measurement.Identifier

+        );

+      } else {

+        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_PEIM_VARS), gDpHiiHandle,

+              TIndex,   // 1 based, Which measurement record is being printed

+              Measurement.Handle,  // base address

+              Measurement.Handle,  // file guid

+              ElapsedTime

+        );

+      }

+    }

+  }

+}

+

+/** 

+  Gather and print global data.

+  

+  Strips out incomplete or "Execution Phase" records

+  Only prints records where Handle is NULL

+  Increment TIndex for every record, even skipped ones, so that we have an

+  indication of every measurement record taken.

+  

+**/

+VOID

+ProcessGlobal(

+  VOID

+)

+{

+  MEASUREMENT_RECORD        Measurement;

+  UINT64                    Duration;

+  UINT64                    ElapsedTime;

+  EFI_STRING                StringPtr;

+  UINTN                     LogEntryKey;

+  UINTN                     Index;        // Index, or number, of the measurement record being processed

+  EFI_STRING                StringPtrUnknown;

+

+  StringPtrUnknown = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL);  

+  StringPtr = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_DP_SECTION_GENERAL), NULL);

+  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_SECTION_HEADER), gDpHiiHandle,

+              (StringPtr == NULL) ? StringPtrUnknown: StringPtr);

+  FreePool (StringPtr);

+  FreePool (StringPtrUnknown);

+

+  if (mShowId) {

+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_GLOBAL_SECTION2), gDpHiiHandle);

+  } else {

+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_GLOBAL_SECTION), gDpHiiHandle);

+  }

+  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_DASHES), gDpHiiHandle);

+

+  Index = 1;

+  LogEntryKey = 0;

+

+  while ((LogEntryKey = GetPerformanceMeasurementEx (

+                          LogEntryKey,

+                          &Measurement.Handle,

+                          &Measurement.Token,

+                          &Measurement.Module,

+                          &Measurement.StartTimeStamp,

+                          &Measurement.EndTimeStamp,

+                          &Measurement.Identifier)) != 0)

+  {

+    AsciiStrToUnicodeStr (Measurement.Module, mGaugeString);

+    AsciiStrToUnicodeStr (Measurement.Token, mUnicodeToken);

+    mGaugeString[25] = 0;

+    mUnicodeToken[31] = 0;

+    if ( ! ( IsPhase( &Measurement)  ||

+        (Measurement.Handle != NULL)      ||

+        (Measurement.EndTimeStamp == 0)

+        ))

+    {

+      Duration = GetDuration (&Measurement);

+      ElapsedTime = DurationInMicroSeconds ( Duration );

+      if (ElapsedTime >= mInterestThreshold) {

+        if (mShowId) {

+          ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_GLOBAL_VARS2), gDpHiiHandle,

+            Index,

+            mGaugeString,

+            mUnicodeToken,

+            ElapsedTime,

+            Measurement.Identifier

+            );

+        } else {

+           ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_GLOBAL_VARS), gDpHiiHandle,

+            Index,

+            mGaugeString,

+            mUnicodeToken,

+            ElapsedTime

+            );

+        }

+      }

+    }

+    Index++;

+  }

+}

+

+/** 

+  Gather and print cumulative data.

+  

+  Traverse the measurement records and:<BR>

+  For each record with a Token listed in the CumData array:<BR>

+     - Update the instance count and the total, minimum, and maximum durations.

+  Finally, print the gathered cumulative statistics.

+  

+**/

+VOID

+ProcessCumulative(

+  VOID

+)

+{

+  UINT64                    AvgDur;         // the computed average duration

+  UINT64                    Dur;

+  UINT64                    MinDur;

+  UINT64                    MaxDur;

+  EFI_STRING                StringPtr;

+  UINTN                     TIndex;

+  EFI_STRING                StringPtrUnknown;

+

+  StringPtrUnknown = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL);  

+  StringPtr = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_DP_SECTION_CUMULATIVE), NULL);

+  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_SECTION_HEADER), gDpHiiHandle,

+              (StringPtr == NULL) ? StringPtrUnknown: StringPtr);

+  FreePool (StringPtr);

+  FreePool (StringPtrUnknown);

+

+  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_CUMULATIVE_SECT_1), gDpHiiHandle);

+  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_CUMULATIVE_SECT_2), gDpHiiHandle);

+  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_DASHES), gDpHiiHandle);

+

+  for ( TIndex = 0; TIndex < NumCum; ++TIndex) {

+    if (CumData[TIndex].Count != 0) {

+      AvgDur = DivU64x32 (CumData[TIndex].Duration, CumData[TIndex].Count);

+      AvgDur = DurationInMicroSeconds(AvgDur);

+      Dur    = DurationInMicroSeconds(CumData[TIndex].Duration);

+      MaxDur = DurationInMicroSeconds(CumData[TIndex].MaxDur);

+      MinDur = DurationInMicroSeconds(CumData[TIndex].MinDur);

+    

+      ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_CUMULATIVE_STATS), gDpHiiHandle,

+                  CumData[TIndex].Name,

+                  CumData[TIndex].Count,

+                  Dur,

+                  AvgDur,

+                  MinDur,

+                  MaxDur

+                 );

+    }

+  }

+}

diff --git a/ShellPkg/Library/UefiDpLib/DpUtilities.c b/ShellPkg/Library/UefiDpLib/DpUtilities.c
new file mode 100644
index 00000000..89c9919e
--- /dev/null
+++ b/ShellPkg/Library/UefiDpLib/DpUtilities.c
@@ -0,0 +1,400 @@
+/** @file

+  Utility functions used by the Dp application.

+

+  Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+**/

+

+#include <Library/BaseLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/MemoryAllocationLib.h>

+#include <Library/DebugLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/TimerLib.h>

+#include <Library/PeCoffGetEntryPointLib.h>

+#include <Library/PrintLib.h>

+#include <Library/HiiLib.h>

+#include <Library/PcdLib.h>

+#include <Library/UefiLib.h>

+#include <Library/DevicePathLib.h>

+

+#include <Pi/PiFirmwareFile.h>

+#include <Library/DxeServicesLib.h>

+

+#include <Protocol/LoadedImage.h>

+#include <Protocol/DriverBinding.h>

+#include <Protocol/ComponentName2.h>

+#include <Protocol/DevicePath.h>

+#include <Protocol/DevicePathToText.h>

+

+#include <Guid/Performance.h>

+

+#include "Dp.h"

+#include "Literals.h"

+#include "DpInternal.h"

+

+/** 

+  Calculate an event's duration in timer ticks.

+  

+  Given the count direction and the event's start and end timer values,

+  calculate the duration of the event in timer ticks.  Information for

+  the current measurement is pointed to by the parameter.

+  

+  If the measurement's start time is 1, it indicates that the developer

+  is indicating that the measurement began at the release of reset.

+  The start time is adjusted to the timer's starting count before performing

+  the elapsed time calculation.

+  

+  The calculated duration, in ticks, is the absolute difference between

+  the measurement's ending and starting counts.

+  

+  @param Measurement   Pointer to a MEASUREMENT_RECORD structure containing

+                       data for the current measurement.

+  

+  @return              The 64-bit duration of the event.

+**/

+UINT64

+GetDuration (

+  IN OUT MEASUREMENT_RECORD   *Measurement

+  )

+{

+  UINT64    Duration;

+  BOOLEAN   Error;

+

+  // PERF_START macros are called with a value of 1 to indicate

+  // the beginning of time.  So, adjust the start ticker value

+  // to the real beginning of time.

+  // Assumes no wraparound.  Even then, there is a very low probability

+  // of having a valid StartTicker value of 1.

+  if (Measurement->StartTimeStamp == 1) {

+    Measurement->StartTimeStamp = TimerInfo.StartCount;

+  }

+  if (TimerInfo.CountUp) {

+    Duration = Measurement->EndTimeStamp - Measurement->StartTimeStamp;

+    Error = (BOOLEAN)(Duration > Measurement->EndTimeStamp);

+  }

+  else {

+    Duration = Measurement->StartTimeStamp - Measurement->EndTimeStamp;

+    Error = (BOOLEAN)(Duration > Measurement->StartTimeStamp);

+  }

+

+  if (Error) {

+    DEBUG ((EFI_D_ERROR, ALit_TimerLibError));

+    Duration = 0;

+  }

+  return Duration;

+}

+

+/** 

+  Determine whether the Measurement record is for an EFI Phase.

+  

+  The Token and Module members of the measurement record are checked.

+  Module must be empty and Token must be one of SEC, PEI, DXE, BDS, or SHELL.

+  

+  @param[in]  Measurement A pointer to the Measurement record to test.

+  

+  @retval     TRUE        The measurement record is for an EFI Phase.

+  @retval     FALSE       The measurement record is NOT for an EFI Phase.

+**/

+BOOLEAN

+IsPhase(

+  IN MEASUREMENT_RECORD        *Measurement

+  )

+{

+  BOOLEAN   RetVal;

+

+  RetVal = (BOOLEAN)( ( *Measurement->Module == '\0')                               &&

+            ((AsciiStrnCmp (Measurement->Token, ALit_SEC, PERF_TOKEN_LENGTH) == 0)    ||

+             (AsciiStrnCmp (Measurement->Token, ALit_PEI, PERF_TOKEN_LENGTH) == 0)    ||

+             (AsciiStrnCmp (Measurement->Token, ALit_DXE, PERF_TOKEN_LENGTH) == 0)    ||

+             (AsciiStrnCmp (Measurement->Token, ALit_BDS, PERF_TOKEN_LENGTH) == 0))

+            );

+  return RetVal;

+}

+

+/** 

+  Get the file name portion of the Pdb File Name.

+  

+  The portion of the Pdb File Name between the last backslash and

+  either a following period or the end of the string is converted

+  to Unicode and copied into UnicodeBuffer.  The name is truncated,

+  if necessary, to ensure that UnicodeBuffer is not overrun.

+  

+  @param[in]  PdbFileName     Pdb file name.

+  @param[out] UnicodeBuffer   The resultant Unicode File Name.

+  

+**/

+VOID

+GetShortPdbFileName (

+  IN  CHAR8     *PdbFileName,

+  OUT CHAR16    *UnicodeBuffer

+  )

+{

+  UINTN IndexA;     // Current work location within an ASCII string.

+  UINTN IndexU;     // Current work location within a Unicode string.

+  UINTN StartIndex;

+  UINTN EndIndex;

+

+  ZeroMem (UnicodeBuffer, DXE_PERFORMANCE_STRING_LENGTH * sizeof (CHAR16));

+

+  if (PdbFileName == NULL) {

+    StrCpy (UnicodeBuffer, L" ");

+  } else {

+    StartIndex = 0;

+    for (EndIndex = 0; PdbFileName[EndIndex] != 0; EndIndex++)

+      ;

+    for (IndexA = 0; PdbFileName[IndexA] != 0; IndexA++) {

+      if (PdbFileName[IndexA] == '\\') {

+        StartIndex = IndexA + 1;

+      }

+

+      if (PdbFileName[IndexA] == '.') {

+        EndIndex = IndexA;

+      }

+    }

+

+    IndexU = 0;

+    for (IndexA = StartIndex; IndexA < EndIndex; IndexA++) {

+      UnicodeBuffer[IndexU] = (CHAR16) PdbFileName[IndexA];

+      IndexU++;

+      if (IndexU >= DXE_PERFORMANCE_STRING_LENGTH) {

+        UnicodeBuffer[DXE_PERFORMANCE_STRING_LENGTH] = 0;

+        break;

+      }

+    }

+  }

+}

+

+/** 

+  Get a human readable name for an image handle.

+  The following methods will be tried orderly:

+    1. Image PDB

+    2. ComponentName2 protocol

+    3. FFS UI section

+    4. Image GUID

+    5. Image DevicePath

+    6. Unknown Driver Name

+

+  @param[in]    Handle

+

+  @post   The resulting Unicode name string is stored in the

+          mGaugeString global array.

+

+**/

+VOID

+GetNameFromHandle (

+  IN EFI_HANDLE   Handle

+  )

+{

+  EFI_STATUS                  Status;

+  EFI_LOADED_IMAGE_PROTOCOL   *Image;

+  CHAR8                       *PdbFileName;

+  EFI_DRIVER_BINDING_PROTOCOL *DriverBinding;

+  EFI_STRING                  StringPtr;

+  EFI_DEVICE_PATH_PROTOCOL    *LoadedImageDevicePath;

+  EFI_DEVICE_PATH_PROTOCOL    *DevicePath;

+  EFI_GUID                    *NameGuid;

+  CHAR16                      *NameString;

+  UINTN                       StringSize;

+  CHAR8                       *PlatformLanguage;

+  EFI_COMPONENT_NAME2_PROTOCOL      *ComponentName2;

+  EFI_DEVICE_PATH_TO_TEXT_PROTOCOL  *DevicePathToText;

+

+  //

+  // Method 1: Get the name string from image PDB

+  //

+  Status = gBS->HandleProtocol (

+                  Handle,

+                  &gEfiLoadedImageProtocolGuid,

+                  (VOID **) &Image

+                  );

+

+  if (EFI_ERROR (Status)) {

+    Status = gBS->OpenProtocol (

+                    Handle,

+                    &gEfiDriverBindingProtocolGuid,

+                    (VOID **) &DriverBinding,

+                    NULL,

+                    NULL,

+                    EFI_OPEN_PROTOCOL_GET_PROTOCOL

+                    );

+    if (!EFI_ERROR (Status)) {

+      Status = gBS->HandleProtocol (

+                      DriverBinding->ImageHandle,

+                      &gEfiLoadedImageProtocolGuid,

+                      (VOID **) &Image

+                      );

+    }

+  }

+

+  if (!EFI_ERROR (Status)) {

+    PdbFileName = PeCoffLoaderGetPdbPointer (Image->ImageBase);

+

+    if (PdbFileName != NULL) {

+      GetShortPdbFileName (PdbFileName, mGaugeString);

+      return;

+    }

+  }

+

+  //

+  // Method 2: Get the name string from ComponentName2 protocol

+  //

+  Status = gBS->HandleProtocol (

+                  Handle,

+                  &gEfiComponentName2ProtocolGuid,

+                  (VOID **) &ComponentName2

+                  );

+  if (!EFI_ERROR (Status)) {

+    //

+    // Get the current platform language setting

+    //

+    GetEfiGlobalVariable2 (L"PlatformLang", (VOID**)&PlatformLanguage, NULL);

+    Status = ComponentName2->GetDriverName (

+                               ComponentName2,

+                               PlatformLanguage != NULL ? PlatformLanguage : "en-US",

+                               &StringPtr

+                               );

+    if (!EFI_ERROR (Status)) {

+      SHELL_FREE_NON_NULL (PlatformLanguage);

+      StrnCpy (mGaugeString, StringPtr, DP_GAUGE_STRING_LENGTH);

+      mGaugeString[DP_GAUGE_STRING_LENGTH] = 0;

+      return;

+    }

+  }

+

+  Status = gBS->HandleProtocol (

+                  Handle,

+                  &gEfiLoadedImageDevicePathProtocolGuid,

+                  (VOID **) &LoadedImageDevicePath

+                  );

+  if (!EFI_ERROR (Status) && (LoadedImageDevicePath != NULL)) {

+    DevicePath = LoadedImageDevicePath;

+

+    //

+    // Try to get image GUID from LoadedImageDevicePath protocol

+    //

+    NameGuid = NULL;

+    while (!IsDevicePathEndType (DevicePath)) {

+      NameGuid = EfiGetNameGuidFromFwVolDevicePathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) DevicePath);

+      if (NameGuid != NULL) {

+        break;

+      }

+      DevicePath = NextDevicePathNode (DevicePath);

+    }

+

+    if (NameGuid != NULL) {

+      //

+      // Try to get the image's FFS UI section by image GUID

+      //

+      NameString = NULL;

+      StringSize = 0;

+      Status = GetSectionFromAnyFv (

+                NameGuid,

+                EFI_SECTION_USER_INTERFACE,

+                0,

+                (VOID **) &NameString,

+                &StringSize

+                );

+

+      if (!EFI_ERROR (Status)) {

+        //

+        // Method 3. Get the name string from FFS UI section

+        //

+        StrnCpy (mGaugeString, NameString, DP_GAUGE_STRING_LENGTH);

+        mGaugeString[DP_GAUGE_STRING_LENGTH] = 0;

+        FreePool (NameString);

+      } else {

+        //

+        // Method 4: Get the name string from image GUID

+        //

+        UnicodeSPrint (mGaugeString, sizeof (mGaugeString), L"%g", NameGuid);

+      }

+      return;

+    } else {

+      //

+      // Method 5: Get the name string from image DevicePath

+      //

+      Status = gBS->LocateProtocol (

+                      &gEfiDevicePathToTextProtocolGuid,

+                      NULL,

+                      (VOID **) &DevicePathToText

+                      );

+      if (!EFI_ERROR (Status)) {

+        NameString = DevicePathToText->ConvertDevicePathToText (LoadedImageDevicePath, TRUE, FALSE);

+        if (NameString != NULL) {

+          StrnCpy (mGaugeString, NameString, DP_GAUGE_STRING_LENGTH);

+          mGaugeString[DP_GAUGE_STRING_LENGTH] = 0;

+          FreePool (NameString);

+          return;

+        }

+      }

+    }

+  }

+

+  //

+  // Method 6: Unknown Driver Name

+  //

+  StringPtr = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_DP_ERROR_NAME), NULL);

+  ASSERT (StringPtr != NULL);

+  StrCpy (mGaugeString, StringPtr);

+  FreePool (StringPtr);

+}

+

+/** 

+  Calculate the Duration in microseconds.

+  

+  Duration is multiplied by 1000, instead of Frequency being divided by 1000 or

+  multiplying the result by 1000, in order to maintain precision.  Since Duration is

+  a 64-bit value, multiplying it by 1000 is unlikely to produce an overflow.

+  

+  The time is calculated as (Duration * 1000) / Timer_Frequency.

+  

+  @param[in]  Duration   The event duration in timer ticks.

+  

+  @return     A 64-bit value which is the Elapsed time in microseconds.

+**/

+UINT64

+DurationInMicroSeconds (

+  IN UINT64 Duration

+  )

+{

+  UINT64 Temp;

+

+  Temp = MultU64x32 (Duration, 1000);

+  return DivU64x32 (Temp, TimerInfo.Frequency);

+}

+

+/** 

+  Get index of Measurement Record's match in the CumData array.

+  

+  If the Measurement's Token value matches a Token in one of the CumData

+  records, the index of the matching record is returned.  The returned

+  index is a signed value so that negative values can indicate that

+  the Measurement didn't match any entry in the CumData array.

+  

+  @param[in]  Measurement A pointer to a Measurement Record to match against the CumData array.

+  

+  @retval     <0    Token is not in the CumData array.

+  @retval     >=0   Return value is the index into CumData where Token is found.

+**/

+INTN

+GetCumulativeItem(

+  IN MEASUREMENT_RECORD   *Measurement

+  )

+{

+  INTN    Index;

+

+  for( Index = 0; Index < (INTN)NumCum; ++Index) {

+    if (AsciiStrnCmp (Measurement->Token, CumData[Index].Name, PERF_TOKEN_LENGTH) == 0) {

+      return Index;  // Exit, we found a match

+    }

+  }

+  // If the for loop exits, Token was not found.

+  return -1;   // Indicate failure

+}

diff --git a/ShellPkg/Library/UefiDpLib/Literals.c b/ShellPkg/Library/UefiDpLib/Literals.c
new file mode 100644
index 00000000..68de0fbc
--- /dev/null
+++ b/ShellPkg/Library/UefiDpLib/Literals.c
@@ -0,0 +1,23 @@
+/** @file

+  Definitions of ASCII string literals used by DP.

+

+  Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+**/

+#include <PerformanceTokens.h>

+

+// ASCII String literals which probably don't need translation

+CHAR8 const ALit_TimerLibError[] = "Timer library instance error!\n";

+CHAR8 const ALit_SEC[]    = SEC_TOK;

+CHAR8 const ALit_DXE[]    = DXE_TOK;

+CHAR8 const ALit_SHELL[]  = SHELL_TOK;

+CHAR8 const ALit_PEI[]    = PEI_TOK;

+CHAR8 const ALit_BDS[]    = BDS_TOK;

+CHAR8 const ALit_BdsTO[]  = "BdsTimeOut";

+CHAR8 const ALit_PEIM[]   = "PEIM";

diff --git a/ShellPkg/Library/UefiDpLib/Literals.h b/ShellPkg/Library/UefiDpLib/Literals.h
new file mode 100644
index 00000000..8aec09c0
--- /dev/null
+++ b/ShellPkg/Library/UefiDpLib/Literals.h
@@ -0,0 +1,26 @@
+/** @file

+  Declarations of ASCII string literals used by DP.

+

+  Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+**/

+#ifndef _LITERALS_H_

+#define _LITERALS_H_

+

+// ASCII String literals which probably don't need translation

+extern CHAR8 const ALit_TimerLibError[];

+extern CHAR8 const ALit_SEC[];

+extern CHAR8 const ALit_DXE[];

+extern CHAR8 const ALit_SHELL[];

+extern CHAR8 const ALit_PEI[];

+extern CHAR8 const ALit_BDS[];

+extern CHAR8 const ALit_BdsTO[];

+extern CHAR8 const ALit_PEIM[];

+

+#endif  // _LITERALS_H_

diff --git a/ShellPkg/Library/UefiDpLib/PerformanceTokens.h b/ShellPkg/Library/UefiDpLib/PerformanceTokens.h
new file mode 100644
index 00000000..bbbc48d7
--- /dev/null
+++ b/ShellPkg/Library/UefiDpLib/PerformanceTokens.h
@@ -0,0 +1,28 @@
+/** @file

+  ASCII String Literals with special meaning to Performance measurement and the Dp utility.

+

+Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>

+This program and the accompanying materials

+are licensed and made available under the terms and conditions of the BSD License

+which accompanies this distribution.  The full text of the license may be found at

+http://opensource.org/licenses/bsd-license.php

+

+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __PERFORMANCE_TOKENS_H__

+#define __PERFORMANCE_TOKENS_H__

+

+#define SEC_TOK                         "SEC"             ///< SEC Phase

+#define DXE_TOK                         "DXE"             ///< DEC Phase

+#define SHELL_TOK                       "SHELL"           ///< Shell Phase

+#define PEI_TOK                         "PEI"             ///< PEI Phase

+#define BDS_TOK                         "BDS"             ///< BDS Phase

+#define DRIVERBINDING_START_TOK         "DB:Start:"       ///< Driver Binding Start() function call

+#define DRIVERBINDING_SUPPORT_TOK       "DB:Support:"     ///< Driver Binding Support() function call

+#define LOAD_IMAGE_TOK                  "LoadImage:"      ///< Load a dispatched module

+#define START_IMAGE_TOK                 "StartImage:"     ///< Dispatched Modules Entry Point execution

+

+#endif  // __PERFORMANCE_TOKENS_H__

diff --git a/ShellPkg/Library/UefiDpLib/Readme.txt b/ShellPkg/Library/UefiDpLib/Readme.txt
new file mode 100644
index 00000000..849efa43
--- /dev/null
+++ b/ShellPkg/Library/UefiDpLib/Readme.txt
@@ -0,0 +1,2 @@
+from PerformancePkg\Dp_App

+SVN 13406

diff --git a/ShellPkg/Library/UefiDpLib/UefiDpLib.c b/ShellPkg/Library/UefiDpLib/UefiDpLib.c
new file mode 100644
index 00000000..f3ecfeac
--- /dev/null
+++ b/ShellPkg/Library/UefiDpLib/UefiDpLib.c
@@ -0,0 +1,101 @@
+/** @file

+  Main file for NULL named library for install1 shell command functions.

+

+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include "UefiDpLib.h"

+

+STATIC CONST CHAR16 mFileName[] = L"ShellCommands";

+EFI_HANDLE gDpHiiHandle = NULL;

+

+#define DP_HII_GUID \

+  { \

+  0xeb832fd9, 0x9089, 0x4898, { 0x83, 0xc9, 0x41, 0x61, 0x8f, 0x5c, 0x48, 0xb9 } \

+  }

+

+EFI_GUID gDpHiiGuid = DP_HII_GUID;

+

+/**

+  Function to get the filename with help context if HII will not be used.

+

+  @return   The filename with help text in it.

+**/

+CONST CHAR16*

+EFIAPI

+UefiDpLibGetManFileName (

+  VOID

+  )

+{

+  return (mFileName);

+}

+

+/**

+  Constructor for the Shell Level 1 Commands library.

+

+  Install the handlers for level 1 UEFI Shell 2.0 commands.

+

+  @param ImageHandle    the image handle of the process

+  @param SystemTable    the EFI System Table pointer

+

+  @retval EFI_SUCCESS        the shell command handlers were installed sucessfully

+  @retval EFI_UNSUPPORTED    the shell level required was not found.

+**/

+EFI_STATUS

+EFIAPI

+UefiDpLibConstructor (

+  IN EFI_HANDLE        ImageHandle,

+  IN EFI_SYSTEM_TABLE  *SystemTable

+  )

+{

+  //

+  // check our bit of the profiles mask

+  //

+  if ((PcdGet8(PcdShellProfileMask) & BIT2) == 0) {

+    return (EFI_SUCCESS);

+  }

+

+  //

+  // 3rd parameter 'HII strings array' must be name of .uni strings file followed by 'Strings', e.g. mycommands.uni must be

+  // specified as 'mycommandsStrings' because the build Autogen process defines this as a string array for the strings in your

+  // .uni file.  Examine your Build folder under your package's DEBUG folder and you will find it defined in a xxxStrDefs.h file.

+  //

+  gDpHiiHandle = HiiAddPackages (&gDpHiiGuid, gImageHandle, UefiDpLibStrings, NULL);

+  if (gDpHiiHandle == NULL) {

+    return (EFI_DEVICE_ERROR);

+  }

+

+  //

+  // install our shell command handlers that are always installed

+  //

+  ShellCommandRegisterCommandName(L"dp", ShellCommandRunDp , UefiDpLibGetManFileName, 0, L"", FALSE, gDpHiiHandle, STRING_TOKEN(STR_GET_HELP_DP));

+

+  return (EFI_SUCCESS);

+}

+

+/**

+  Destructor for the library.  free any resources.

+

+  @param ImageHandle            The image handle of the process.

+  @param SystemTable            The EFI System Table pointer.

+**/

+EFI_STATUS

+EFIAPI

+UefiDpLibDestructor (

+  IN EFI_HANDLE        ImageHandle,

+  IN EFI_SYSTEM_TABLE  *SystemTable

+  )

+{

+  if (gDpHiiHandle != NULL) {

+    HiiRemovePackages(gDpHiiHandle);

+  }

+  return (EFI_SUCCESS);

+}

diff --git a/ShellPkg/Library/UefiDpLib/UefiDpLib.h b/ShellPkg/Library/UefiDpLib/UefiDpLib.h
new file mode 100644
index 00000000..2cec9914
--- /dev/null
+++ b/ShellPkg/Library/UefiDpLib/UefiDpLib.h
@@ -0,0 +1,60 @@
+/** @file

+  Main file for NULL named library for dp command functions.

+

+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef _UEFI_DP_LIB_H_

+#define _UEFI_DP_LIB_H_

+

+#include <Uefi.h>

+#include <ShellBase.h>

+

+extern EFI_GUID gDpHiiGuid;

+

+#include <Protocol/EfiShell.h>

+#include <Protocol/EfiShellParameters.h>

+#include <Protocol/DevicePath.h>

+#include <Protocol/LoadedImage.h>

+#include <Protocol/UnicodeCollation.h>

+#include <Protocol/DevicePathToText.h>

+

+#include <Library/BaseLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/DebugLib.h>

+#include <Library/MemoryAllocationLib.h>

+#include <Library/PcdLib.h>

+#include <Library/ShellCommandLib.h>

+#include <Library/ShellLib.h>

+#include <Library/SortLib.h>

+#include <Library/UefiLib.h>

+#include <Library/UefiRuntimeServicesTableLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/HiiLib.h>

+#include <Library/FileHandleLib.h>

+

+extern        EFI_HANDLE                        gDpHiiHandle;

+

+/**

+  Function for 'dp' command.

+

+  @param[in] ImageHandle  Handle to the Image (NULL if Internal).

+  @param[in] SystemTable  Pointer to the System Table (NULL if Internal).

+**/

+SHELL_STATUS

+EFIAPI

+ShellCommandRunDp (

+  IN EFI_HANDLE        ImageHandle,

+  IN EFI_SYSTEM_TABLE  *SystemTable

+  );

+

+#endif

+

diff --git a/ShellPkg/Library/UefiDpLib/UefiDpLib.inf b/ShellPkg/Library/UefiDpLib/UefiDpLib.inf
new file mode 100644
index 00000000..cb53a594
--- /dev/null
+++ b/ShellPkg/Library/UefiDpLib/UefiDpLib.inf
@@ -0,0 +1,75 @@
+##  @file

+#  Display Performance Application, Module information file.

+#

+# Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+##

+

+[Defines]

+  INF_VERSION                    = 0x00010006

+  BASE_NAME                      = UefiDpLib

+  FILE_GUID                      = 9DF262F7-CF81-4294-B5A5-B2E3CAFE5618

+  MODULE_TYPE                    = UEFI_DRIVER

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = NULL|UEFI_APPLICATION UEFI_DRIVER

+  CONSTRUCTOR                    = UefiDpLibConstructor

+  DESTRUCTOR                     = UefiDpLibDestructor

+

+#

+# The following information is for reference only and not required by the build tools.

+#

+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC

+#

+

+[Sources.common]

+  PerformanceTokens.h

+  UefiDpLib.c

+  UefiDpLib.h

+  UefiDpLib.uni

+  Dp.c

+  Dp.h

+  Literals.h

+  Literals.c

+  DpInternal.h

+  DpUtilities.c

+  DpTrace.c

+  DpProfile.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  ShellPkg/ShellPkg.dec

+  MdeModulePkg/MdeModulePkg.dec

+

+[LibraryClasses]

+  TimerLib

+  PerformanceLib

+  DxeServicesLib

+  MemoryAllocationLib

+  BaseLib

+  BaseMemoryLib

+  DebugLib

+  ShellCommandLib

+  ShellLib

+  UefiLib

+  UefiRuntimeServicesTableLib

+  UefiBootServicesTableLib

+  SortLib

+  PrintLib

+

+[Protocols]

+  gEfiLoadedImageProtocolGuid                             # ALWAYS_CONSUMED

+  gEfiDriverBindingProtocolGuid                           # SOMETIMES_CONSUMED

+  gEfiComponentName2ProtocolGuid                          # SOMETIMES_CONSUMED

+  gEfiLoadedImageDevicePathProtocolGuid                   # SOMETIMES_CONSUMED

+  gEfiDevicePathToTextProtocolGuid                        # SOMETIMES_CONSUMED

+

+[Pcd]

+  gEfiMdePkgTokenSpaceGuid.PcdUefiLibMaxPrintBufferSize

+  gEfiShellPkgTokenSpaceGuid.PcdShellProfileMask # ALWAYS_CONSUMED

diff --git a/ShellPkg/Library/UefiDpLib/UefiDpLib.uni b/ShellPkg/Library/UefiDpLib/UefiDpLib.uni
new file mode 100644
index 00000000..fa29f9be
--- /dev/null
+++ b/ShellPkg/Library/UefiDpLib/UefiDpLib.uni
diff --git a/ShellPkg/Library/UefiShellDebug1CommandsLib/Edit/MainTextEditor.c b/ShellPkg/Library/UefiShellDebug1CommandsLib/Edit/MainTextEditor.c
index 3583dd3d..a1564d4f 100644
--- a/ShellPkg/Library/UefiShellDebug1CommandsLib/Edit/MainTextEditor.c
+++ b/ShellPkg/Library/UefiShellDebug1CommandsLib/Edit/MainTextEditor.c
@@ -1502,7 +1502,7 @@ MainEditorInit (
   //

   // below will call the five components' init function

   //

-  Status = MainTitleBarInit (L"UEFI EDIT 2.0");

+  Status = MainTitleBarInit (L"UEFI EDIT");

   if (EFI_ERROR (Status)) {

     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN(STR_EDIT_LIBEDITOR_TITLEBAR), gShellDebug1HiiHandle);

     return EFI_LOAD_ERROR;

diff --git a/ShellPkg/Library/UefiShellDebug1CommandsLib/HexEdit/MainHexEditor.c b/ShellPkg/Library/UefiShellDebug1CommandsLib/HexEdit/MainHexEditor.c
index 446dac7e..09213d89 100644
--- a/ShellPkg/Library/UefiShellDebug1CommandsLib/HexEdit/MainHexEditor.c
+++ b/ShellPkg/Library/UefiShellDebug1CommandsLib/HexEdit/MainHexEditor.c
@@ -1687,7 +1687,7 @@ HMainEditorInit (
   //

   // below will call the five components' init function

   //

-  Status = MainTitleBarInit (NULL);

+  Status = MainTitleBarInit (L"UEFI HEXEDIT");

   if (EFI_ERROR (Status)) {

     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HEXEDIT_LIBEDITOR_MAINEDITOR_TITLE), gShellDebug1HiiHandle);

     return EFI_LOAD_ERROR;

diff --git a/ShellPkg/Library/UefiShellDebug1CommandsLib/SmbiosView/PrintInfo.c b/ShellPkg/Library/UefiShellDebug1CommandsLib/SmbiosView/PrintInfo.c
index 3aea96b6..9ae5a0c7 100644
--- a/ShellPkg/Library/UefiShellDebug1CommandsLib/SmbiosView/PrintInfo.c
+++ b/ShellPkg/Library/UefiShellDebug1CommandsLib/SmbiosView/PrintInfo.c
@@ -249,7 +249,7 @@ SmbiosPrintStructure (
     PRINT_PENDING_STRING (Struct, Type0, BiosReleaseDate);

     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIOS_SIZE), gShellDebug1HiiHandle, 64 * (Struct->Type0->BiosSize + 1));

 

-    DisplayBiosCharacteristics (*(UINT64 *) &(Struct->Type0->BiosCharacteristics), Option);

+    DisplayBiosCharacteristics (ReadUnaligned64 ((UINT64 *) (UINTN) &(Struct->Type0->BiosCharacteristics)), Option);

 

     if (Struct->Hdr->Length > 0x12) {

       DisplayBiosCharacteristicsExt1 (Struct->Type0->BIOSCharacteristicsExtensionBytes[0], Option);

@@ -416,7 +416,7 @@ SmbiosPrintStructure (
     PRINT_STRUCT_VALUE_H (Struct, Type7, InstalledSize);

     PRINT_STRUCT_VALUE_H (Struct, Type7, SupportedSRAMType);

     PRINT_STRUCT_VALUE_H (Struct, Type7, CurrentSRAMType);

-    DisplayCacheSRAMType (*(UINT16 *) &(Struct->Type7->CurrentSRAMType), Option);

+    DisplayCacheSRAMType (ReadUnaligned16 ((UINT16 *) (UINTN) &(Struct->Type7->CurrentSRAMType)), Option);

     PRINT_STRUCT_VALUE_H (Struct, Type7, CacheSpeed);

     DisplayCacheErrCorrectingType (Struct->Type7->ErrorCorrectionType, Option);

     DisplayCacheSystemCacheType (Struct->Type7->SystemCacheType, Option);

@@ -633,7 +633,7 @@ SmbiosPrintStructure (
     PRINT_PENDING_STRING (Struct, Type17, DeviceLocator);

     PRINT_PENDING_STRING (Struct, Type17, BankLocator);

     DisplayMemoryDeviceType (Struct->Type17->MemoryType, Option);

-    DisplayMemoryDeviceTypeDetail (*(UINT16 *) &(Struct->Type17->TypeDetail), Option);

+    DisplayMemoryDeviceTypeDetail (ReadUnaligned16 ((UINT16 *) (UINTN) &(Struct->Type17->TypeDetail)), Option);

     PRINT_STRUCT_VALUE_H (Struct, Type17, Speed);

     PRINT_PENDING_STRING (Struct, Type17, Manufacturer);

     PRINT_PENDING_STRING (Struct, Type17, SerialNumber);

diff --git a/ShellPkg/Library/UefiShellLevel2CommandsLib/Cd.c b/ShellPkg/Library/UefiShellLevel2CommandsLib/Cd.c
index 74beb093..c0d3c920 100644
--- a/ShellPkg/Library/UefiShellLevel2CommandsLib/Cd.c
+++ b/ShellPkg/Library/UefiShellLevel2CommandsLib/Cd.c
@@ -1,7 +1,7 @@
 /** @file

   Main file for attrib shell level 2 function.

 

-  Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -149,6 +149,9 @@ ShellCommandRunCd (
             }

           }

         } else if (StrStr(Param1Copy, L":") == NULL) {

+          //

+          // change directory without a drive identifier

+          //

           if (ShellGetCurrentDir(NULL) == NULL) {

             ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_CWD), gShellLevel2HiiHandle);

             ShellStatus = SHELL_NOT_FOUND;

@@ -189,7 +192,7 @@ ShellCommandRunCd (
           }

         } else {

           //

-          // change directory on other drive letter

+          // change directory with a drive letter

           //

           Drive = AllocateZeroPool(StrSize(Param1Copy));

           if (Drive == NULL) {

@@ -199,7 +202,10 @@ ShellCommandRunCd (
             Drive = StrCpy(Drive, Param1Copy);

             Path = StrStr(Drive, L":");

             ASSERT(Path != NULL);

-            if (*(Path+1) == CHAR_NULL) {

+            if (EFI_ERROR(ShellIsDirectory(Param1Copy))) {

+              ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NOT_DIR), gShellLevel2HiiHandle, Param1Copy);

+              ShellStatus = SHELL_NOT_FOUND;

+            } else if (*(Path+1) == CHAR_NULL) {

               ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CD_NF), gShellLevel2HiiHandle);

               ShellStatus = SHELL_NOT_FOUND;

             } else {

diff --git a/ShellPkg/Library/UefiShellLevel2CommandsLib/Cp.c b/ShellPkg/Library/UefiShellLevel2CommandsLib/Cp.c
index 00b51b41..eb2b2cc5 100644
--- a/ShellPkg/Library/UefiShellLevel2CommandsLib/Cp.c
+++ b/ShellPkg/Library/UefiShellLevel2CommandsLib/Cp.c
@@ -1,7 +1,7 @@
 /** @file

   Main file for cp shell level 2 function.

 

-  Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -13,6 +13,8 @@
 **/

 

 #include "UefiShellLevel2CommandsLib.h"

+#include <Guid/FileSystemInfo.h>

+#include <Guid/FileSystemVolumeLabelInfo.h>

 

 /**

   Function to take a list of files to copy and a destination location and do

@@ -62,24 +64,29 @@ CopySingleFile(
   IN BOOLEAN      SilentMode

   )

 {

-  VOID                *Response;

-  UINTN               ReadSize;

-  SHELL_FILE_HANDLE   SourceHandle;

-  SHELL_FILE_HANDLE   DestHandle;

-  EFI_STATUS          Status;

-  VOID                *Buffer;

-  CHAR16              *TempName;

-  UINTN               Size;

-  EFI_SHELL_FILE_INFO *List;

-  SHELL_STATUS        ShellStatus;

-

+  VOID                  *Response;

+  UINTN                 ReadSize;

+  SHELL_FILE_HANDLE     SourceHandle;

+  SHELL_FILE_HANDLE     DestHandle;

+  EFI_STATUS            Status;

+  VOID                  *Buffer;

+  CHAR16                *TempName;

+  UINTN                 Size;

+  EFI_SHELL_FILE_INFO   *List;

+  SHELL_STATUS          ShellStatus;

+  UINT64                SourceFileSize;

+  UINT64                DestFileSize;

+  EFI_FILE_PROTOCOL     *DestVolumeFP;

+  EFI_FILE_SYSTEM_INFO  *DestVolumeInfo;

+  UINTN                 DestVolumeInfoSize;

 

   ASSERT(Resp != NULL);

 

-  SourceHandle  = NULL;

-  DestHandle    = NULL;

-  Response      = *Resp;

-  List          = NULL;

+  SourceHandle    = NULL;

+  DestHandle      = NULL;

+  Response        = *Resp;

+  List            = NULL;

+  DestVolumeInfo  = NULL;

 

   ReadSize = PcdGet16(PcdShellFileOperationSize);

   // Why bother copying a file to itself

@@ -143,43 +150,95 @@ CopySingleFile(
     // Now copy all the files under the directory...

     //

     TempName    = NULL;

-    Size          = 0;

+    Size        = 0;

     StrnCatGrow(&TempName, &Size, Source, 0);

     StrnCatGrow(&TempName, &Size, L"\\*", 0);

-    ShellOpenFileMetaArg((CHAR16*)TempName, EFI_FILE_MODE_READ, &List);

-    TempName = NULL;

-    StrnCatGrow(&TempName, &Size, Dest, 0);

-    StrnCatGrow(&TempName, &Size, L"\\", 0);

-    ShellStatus = ValidateAndCopyFiles(List, TempName, SilentMode, TRUE, Resp);

-    ShellCloseFileMetaArg(&List);

-    FreePool(TempName);

-    Size = 0;

-  } else {

-    //

-    // open file with create enabled

-    //

-    Status = ShellOpenFileByName(Dest, &DestHandle, EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE|EFI_FILE_MODE_CREATE, 0);

-    if (EFI_ERROR(Status)) {

-      return (SHELL_ACCESS_DENIED);

+    if (TempName != NULL) {

+      ShellOpenFileMetaArg((CHAR16*)TempName, EFI_FILE_MODE_READ, &List);

+      *TempName = CHAR_NULL;

+      StrnCatGrow(&TempName, &Size, Dest, 0);

+      StrnCatGrow(&TempName, &Size, L"\\", 0);

+      ShellStatus = ValidateAndCopyFiles(List, TempName, SilentMode, TRUE, Resp);

+      ShellCloseFileMetaArg(&List);

+      SHELL_FREE_NON_NULL(TempName);

+      Size = 0;

     }

+  } else {

+      //

+      // open file with create enabled

+      //

+      Status = ShellOpenFileByName(Dest, &DestHandle, EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE|EFI_FILE_MODE_CREATE, 0);

+      if (EFI_ERROR(Status)) {

+        return (SHELL_ACCESS_DENIED);

+      }

 

-    //

-    // open source file

-    //

-    Status = ShellOpenFileByName(Source, &SourceHandle, EFI_FILE_MODE_READ, 0);

-    ASSERT_EFI_ERROR(Status);

-

-    //

-    // copy data between files

-    //

-    Buffer = AllocateZeroPool(ReadSize);

-    ASSERT(Buffer != NULL);

-    while (ReadSize == PcdGet16(PcdShellFileOperationSize) && !EFI_ERROR(Status)) {

-      Status = ShellReadFile(SourceHandle, &ReadSize, Buffer);

+      //

+      // open source file

+      //

+      Status = ShellOpenFileByName(Source, &SourceHandle, EFI_FILE_MODE_READ, 0);

       ASSERT_EFI_ERROR(Status);

-      Status = ShellWriteFile(DestHandle, &ReadSize, Buffer);

+

+      //

+      //get file size of source file and freespace available on destination volume

+      //

+      ShellGetFileSize(SourceHandle, &SourceFileSize);

+      ShellGetFileSize(DestHandle, &DestFileSize);

+

+      //

+      //if the destination file already exists then it will be replaced, meaning the sourcefile effectively needs less storage space

+      //

+      if(DestFileSize < SourceFileSize){

+        SourceFileSize -= DestFileSize;

+      } else {

+        SourceFileSize = 0;

+      }

+

+      //

+      //get the system volume info to check the free space

+      //

+      DestVolumeFP = ConvertShellHandleToEfiFileProtocol(DestHandle);

+      DestVolumeInfo = NULL;

+      DestVolumeInfoSize = 0;

+      Status = DestVolumeFP->GetInfo(

+        DestVolumeFP,

+        &gEfiFileSystemInfoGuid,

+        &DestVolumeInfoSize,

+        DestVolumeInfo

+        );

+

+      if (Status == EFI_BUFFER_TOO_SMALL) {

+        DestVolumeInfo = AllocateZeroPool(DestVolumeInfoSize);

+        Status = DestVolumeFP->GetInfo(

+          DestVolumeFP,

+          &gEfiFileSystemInfoGuid,

+          &DestVolumeInfoSize,

+          DestVolumeInfo

+          );

+      }

+

+      //

+      //check if enough space available on destination drive to complete copy

+      //

+      if (DestVolumeInfo->FreeSpace < SourceFileSize) {

+        //

+        //not enough space on destination directory to copy file

+        //

+        SHELL_FREE_NON_NULL(DestVolumeInfo);

+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_CPY_FAIL), gShellLevel2HiiHandle);

+        return(SHELL_VOLUME_FULL);

+      } else {

+        //

+        // copy data between files

+        //

+        Buffer = AllocateZeroPool(ReadSize);

+        ASSERT(Buffer != NULL);

+        while (ReadSize == PcdGet16(PcdShellFileOperationSize) && !EFI_ERROR(Status)) {

+          Status = ShellReadFile(SourceHandle, &ReadSize, Buffer);

+          Status = ShellWriteFile(DestHandle, &ReadSize, Buffer);

+        }

+      }

+      SHELL_FREE_NON_NULL(DestVolumeInfo);

     }

-  }

 

   //

   // close files

@@ -272,7 +331,7 @@ ValidateAndCopyFiles(
   for (Node = (EFI_SHELL_FILE_INFO *)GetFirstNode(&FileList->Link)

     ;  !IsNull(&FileList->Link, &Node->Link)

     ;  Node = (EFI_SHELL_FILE_INFO *)GetNextNode(&FileList->Link, &Node->Link)

-   ){

+    ){

     //

     // skip the directory traversing stuff...

     //

@@ -324,7 +383,7 @@ ValidateAndCopyFiles(
   for (Node = (EFI_SHELL_FILE_INFO *)GetFirstNode(&FileList->Link)

     ;  !IsNull(&FileList->Link, &Node->Link)

     ;  Node = (EFI_SHELL_FILE_INFO *)GetNextNode(&FileList->Link, &Node->Link)

-   ){

+    ){

     if (ShellGetExecutionBreakFlag()) {

       break;

     }

@@ -340,7 +399,7 @@ ValidateAndCopyFiles(
 

     if (FileList->Link.ForwardLink == FileList->Link.BackLink // 1 item

       && EFI_ERROR(ShellIsDirectory(DestDir))                 // not an existing directory

-     ) {

+      ) {

       if (StrStr(DestDir, L":") == NULL) {

         //

         // simple copy of a single file

@@ -364,9 +423,9 @@ ValidateAndCopyFiles(
       // Check for leading slash

       //

       if (DestDir[0] == L'\\') {

-         //

-         // Copy to the root of CWD

-         //

+          //

+          // Copy to the root of CWD

+          //

         StrCpy(DestPath, Cwd);

         while (PathRemoveLastItem(DestPath));

         StrCat(DestPath, DestDir+1);

@@ -409,7 +468,7 @@ ValidateAndCopyFiles(
     if ( !EFI_ERROR(ShellIsDirectory(Node->FullName))

       && !EFI_ERROR(ShellIsDirectory(DestPath))

       && StrniCmp(Node->FullName, DestPath, StrLen(DestPath)) == NULL

-     ){

+      ){

       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_SD_PARENT), gShellLevel2HiiHandle);

       ShellStatus = SHELL_INVALID_PARAMETER;

       break;

@@ -422,7 +481,7 @@ ValidateAndCopyFiles(
 

     if ((TempLocation = StrniCmp(Node->FullName, DestPath, StrLen(Node->FullName))) == 0

       && (DestPath[StrLen(Node->FullName)] == CHAR_NULL || DestPath[StrLen(Node->FullName)] == L'\\')

-     ) {

+      ) {

       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_SD_SAME), gShellLevel2HiiHandle);

       ShellStatus = SHELL_INVALID_PARAMETER;

       break;

@@ -452,6 +511,7 @@ ValidateAndCopyFiles(
   }

 

   return (ShellStatus);

+

 }

 

 /**

diff --git a/ShellPkg/Library/UefiShellLevel2CommandsLib/UefiShellLevel2CommandsLib.uni b/ShellPkg/Library/UefiShellLevel2CommandsLib/UefiShellLevel2CommandsLib.uni
index c2020ca7..08372d5b 100644
--- a/ShellPkg/Library/UefiShellLevel2CommandsLib/UefiShellLevel2CommandsLib.uni
+++ b/ShellPkg/Library/UefiShellLevel2CommandsLib/UefiShellLevel2CommandsLib.uni
diff --git a/ShellPkg/Library/UefiShellLevel3CommandsLib/Help.c b/ShellPkg/Library/UefiShellLevel3CommandsLib/Help.c
index 7e9d039f..c4acc0b4 100644
--- a/ShellPkg/Library/UefiShellLevel3CommandsLib/Help.c
+++ b/ShellPkg/Library/UefiShellLevel3CommandsLib/Help.c
@@ -1,7 +1,7 @@
 /** @file

   Main file for Help shell level 3 function.

 

-  Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved. <BR>

+  Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved. <BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -48,9 +48,9 @@ ShellCommandRunHelp (
   CHAR16              *SectionToGetHelpOn;

   CHAR16              *HiiString;

   BOOLEAN             Found;

-  BOOLEAN             HelpPage;

+  BOOLEAN             PrintCommandText;

 

-  HelpPage            = FALSE;

+  PrintCommandText    = TRUE;

   ProblemParam        = NULL;

   ShellStatus         = SHELL_SUCCESS;

   OutText             = NULL;

@@ -111,7 +111,7 @@ ShellCommandRunHelp (
         ASSERT(SectionToGetHelpOn == NULL);

         StrnCatGrow(&SectionToGetHelpOn, NULL, L"NAME", 0);

       } else {

-        HelpPage = TRUE;

+        PrintCommandText = FALSE;

         ASSERT(SectionToGetHelpOn == NULL);

         //

         // Get the section name for the given command name

@@ -156,26 +156,13 @@ ShellCommandRunHelp (
             //

             // We have a command to look for help on.

             //

-            Status = gEfiShellProtocol->GetHelpText(Node->CommandString, SectionToGetHelpOn, &OutText);

-            if (EFI_ERROR(Status) || OutText == NULL) {

-              if (Status == EFI_DEVICE_ERROR) {

+            Status = ShellPrintHelp(Node->CommandString, SectionToGetHelpOn, PrintCommandText);

+            if (Status == EFI_DEVICE_ERROR) {

                 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HELP_INV), gShellLevel3HiiHandle, Node->CommandString);

-              } else {

+            } else if (EFI_ERROR(Status)) {

                 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HELP_NF), gShellLevel3HiiHandle, Node->CommandString);

-              }

-              ShellStatus = SHELL_NOT_FOUND;

             } else {

-              if (HelpPage) {

-                 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HELP_PAGE_COMMAND), gShellLevel3HiiHandle, OutText);

-              } else {

-                while (OutText[StrLen(OutText)-1] == L'\r' || OutText[StrLen(OutText)-1] == L'\n' || OutText[StrLen(OutText)-1] == L' ') {

-                  OutText[StrLen(OutText)-1] = CHAR_NULL;

-                }

-                ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HELP_COMMAND), gShellLevel3HiiHandle, Node->CommandString, OutText);

-              }

-              FreePool(OutText);

-              OutText = NULL;

-              Found = TRUE;

+                Found = TRUE;

             }

           }

         }

@@ -183,30 +170,18 @@ ShellCommandRunHelp (
         // Search the .man file for Shell applications (Shell external commands).

         //

         if (!Found) {

-          Status = gEfiShellProtocol->GetHelpText (CommandToGetHelpOn, SectionToGetHelpOn, &OutText);

-          if (EFI_ERROR(Status) || OutText == NULL) {

+            Status = ShellPrintHelp(CommandToGetHelpOn, SectionToGetHelpOn, FALSE);

             if (Status == EFI_DEVICE_ERROR) {

-              ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_HELP_INV), gShellLevel3HiiHandle, CommandToGetHelpOn);

+               ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HELP_INV), gShellLevel3HiiHandle, CommandToGetHelpOn);

+            } else if (EFI_ERROR(Status)) {

+               ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HELP_NF), gShellLevel3HiiHandle, CommandToGetHelpOn);

             } else {

-              ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_HELP_NF), gShellLevel3HiiHandle, CommandToGetHelpOn);

-            }

-            ShellStatus = SHELL_NOT_FOUND;

-          } else {

-            while (OutText[StrLen (OutText) - 1] == L'\r' || OutText[StrLen (OutText) - 1] == L'\n' || OutText[StrLen (OutText) - 1] == L' ') {

-              OutText[StrLen (OutText)-1] = CHAR_NULL;

-            }

-            ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_HELP_COMMAND), gShellLevel3HiiHandle, CommandToGetHelpOn, OutText);

-            if (OutText != NULL) {

-              FreePool (OutText);

-              OutText = NULL;

+              Found = TRUE;

             }

-            Found = TRUE;

-          }

         }

       }

 

-      if (!Found && ShellStatus == SHELL_SUCCESS) {

-        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HELP_NF), gShellLevel3HiiHandle, CommandToGetHelpOn);

+      if (!Found) {

         ShellStatus = SHELL_NOT_FOUND;

       }

 

@@ -216,6 +191,14 @@ ShellCommandRunHelp (
       ShellCommandLineFreeVarList (Package);

     }

   }

+

+  if (CommandToGetHelpOn != NULL && StrCmp(CommandToGetHelpOn, L"*") == 0){

+    //

+    // If '*' then the command entered was 'Help' without qualifiers, This footer

+    // provides additional info on help switches

+    //

+    ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HELP_FOOTER), gShellLevel3HiiHandle);

+  }

   if (CommandToGetHelpOn != NULL) {

     FreePool(CommandToGetHelpOn);

   }

diff --git a/ShellPkg/Library/UefiShellLevel3CommandsLib/UefiShellLevel3CommandsLib.uni b/ShellPkg/Library/UefiShellLevel3CommandsLib/UefiShellLevel3CommandsLib.uni
index bf5714c9..55b28060 100644
--- a/ShellPkg/Library/UefiShellLevel3CommandsLib/UefiShellLevel3CommandsLib.uni
+++ b/ShellPkg/Library/UefiShellLevel3CommandsLib/UefiShellLevel3CommandsLib.uni
diff --git a/ShellPkg/Library/UefiShellLib/UefiShellLib.c b/ShellPkg/Library/UefiShellLib/UefiShellLib.c
index 222bd98a..6b985ed6 100644
--- a/ShellPkg/Library/UefiShellLib/UefiShellLib.c
+++ b/ShellPkg/Library/UefiShellLib/UefiShellLib.c
@@ -1,7 +1,7 @@
 /** @file

   Provides interface to shell functionality for shell commands and applications.

 

-  Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -486,6 +486,8 @@ ShellOpenFileByDevicePath(
   EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *EfiSimpleFileSystemProtocol;

   EFI_FILE_PROTOCOL               *Handle1;

   EFI_FILE_PROTOCOL               *Handle2;

+  CHAR16                          *FnafPathName;

+  UINTN                           PathLen;

 

   if (FilePath == NULL || FileHandle == NULL || DeviceHandle == NULL) {

     return (EFI_INVALID_PARAMETER);

@@ -552,12 +554,35 @@ ShellOpenFileByDevicePath(
     Handle1 = NULL;

 

     //

+    // File Name Alignment Fix (FNAF)

+    // Handle2->Open may be incapable of handling a unaligned CHAR16 data.

+    // The structure pointed to by FilePath may be not CHAR16 aligned.

+    // This code copies the potentially unaligned PathName data from the

+    // FilePath structure to the aligned FnafPathName for use in the

+    // calls to Handl2->Open.

+    //

+

+    //

+    // Determine length of PathName, in bytes.

+    //

+    PathLen = DevicePathNodeLength (*FilePath) - SIZE_OF_FILEPATH_DEVICE_PATH;

+

+    //

+    // Allocate memory for the aligned copy of the string Extra allocation is to allow for forced alignment

+    // Copy bytes from possibly unaligned location to aligned location

+    //

+    FnafPathName = AllocateCopyPool(PathLen, (UINT8 *)((FILEPATH_DEVICE_PATH*)*FilePath)->PathName);

+    if (FnafPathName == NULL) {

+      return EFI_OUT_OF_RESOURCES;

+    }

+

+    //

     // Try to test opening an existing file

     //

     Status = Handle2->Open (

                           Handle2,

                           &Handle1,

-                          ((FILEPATH_DEVICE_PATH*)*FilePath)->PathName,

+                          FnafPathName,

                           OpenMode &~EFI_FILE_MODE_CREATE,

                           0

                          );

@@ -569,11 +594,17 @@ ShellOpenFileByDevicePath(
       Status = Handle2->Open (

                             Handle2,

                             &Handle1,

-                            ((FILEPATH_DEVICE_PATH*)*FilePath)->PathName,

+                            FnafPathName,

                             OpenMode,

                             Attributes

                            );

     }

+

+    //

+    // Free the alignment buffer

+    //

+    FreePool(FnafPathName);

+

     //

     // Close the last node

     //

@@ -4028,3 +4059,108 @@ ShellFileHandleReadLine(
 

   return (Status);

 }

+

+/**

+  Function to print help file / man page content in the spec from the UEFI Shell protocol GetHelpText function.

+

+  @param[in] CommandToGetHelpOn  Pointer to a string containing the command name of help file to be printed.

+  @param[in] SectionToGetHelpOn  Pointer to the section specifier(s).

+  @param[in] PrintCommandText    If TRUE, prints the command followed by the help content, otherwise prints 

+                                 the help content only.

+  @retval EFI_DEVICE_ERROR       The help data format was incorrect.

+  @retval EFI_NOT_FOUND          The help data could not be found.

+  @retval EFI_SUCCESS            The operation was successful.

+**/

+EFI_STATUS

+EFIAPI

+ShellPrintHelp (

+  IN CONST CHAR16     *CommandToGetHelpOn,

+  IN CONST CHAR16     *SectionToGetHelpOn,

+  IN BOOLEAN          PrintCommandText

+  )

+{

+	EFI_STATUS          Status;

+	CHAR16              *OutText;

+	  

+	OutText = NULL;

+	

+  //

+  // Get the string to print based

+  //

+	Status = gEfiShellProtocol->GetHelpText (CommandToGetHelpOn, SectionToGetHelpOn, &OutText);

+  

+  //

+  // make sure we got a valid string

+  //

+  if (EFI_ERROR(Status)){

+    return Status;

+	} 

+  if (OutText == NULL || StrLen(OutText) == 0) {

+    return EFI_NOT_FOUND;  

+	}

+  

+  //

+  // Chop off trailing stuff we dont need

+  //

+  while (OutText[StrLen(OutText)-1] == L'\r' || OutText[StrLen(OutText)-1] == L'\n' || OutText[StrLen(OutText)-1] == L' ') {

+    OutText[StrLen(OutText)-1] = CHAR_NULL;

+  }

+  

+  //

+  // Print this out to the console

+  //

+  if (PrintCommandText) {

+    ShellPrintEx(-1, -1, L"%H%-14s%N- %s\r\n", CommandToGetHelpOn, OutText);

+  } else {

+    ShellPrintEx(-1, -1, L"%N%s\r\n", OutText);

+  }

+  

+  SHELL_FREE_NON_NULL(OutText);

+

+	return EFI_SUCCESS;

+}

+

+/**

+  Function to delete a file by name

+  

+  @param[in]       FileName       Pointer to file name to delete.

+  

+  @retval EFI_SUCCESS             the file was deleted sucessfully

+  @retval EFI_WARN_DELETE_FAILURE the handle was closed, but the file was not

+                                  deleted

+  @retval EFI_INVALID_PARAMETER   One of the parameters has an invalid value.

+  @retval EFI_NOT_FOUND           The specified file could not be found on the

+                                  device or the file system could not be found

+                                  on the device.

+  @retval EFI_NO_MEDIA            The device has no medium.

+  @retval EFI_MEDIA_CHANGED       The device has a different medium in it or the

+                                  medium is no longer supported.

+  @retval EFI_DEVICE_ERROR        The device reported an error.

+  @retval EFI_VOLUME_CORRUPTED    The file system structures are corrupted.

+  @retval EFI_WRITE_PROTECTED     The file or medium is write protected.

+  @retval EFI_ACCESS_DENIED       The file was opened read only.

+  @retval EFI_OUT_OF_RESOURCES    Not enough resources were available to open the

+                                  file.

+  @retval other                   The file failed to open

+**/

+EFI_STATUS

+EFIAPI

+ShellDeleteFileByName(

+  IN CONST CHAR16               *FileName

+  )

+{

+  EFI_STATUS                Status;

+  SHELL_FILE_HANDLE         FileHandle;

+  

+  Status = ShellFileExists(FileName);

+  

+  if (Status == EFI_SUCCESS){

+    Status = ShellOpenFileByName(FileName, &FileHandle, EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE, 0x0);

+    if (Status == EFI_SUCCESS){

+      Status = ShellDeleteFile(&FileHandle);

+    }

+  } 

+

+  return(Status);

+  

+}

diff --git a/ShellPkg/ShellPkg.dsc b/ShellPkg/ShellPkg.dsc
index 6b641155..f22986bf 100644
--- a/ShellPkg/ShellPkg.dsc
+++ b/ShellPkg/ShellPkg.dsc
@@ -1,7 +1,7 @@
 ##  @file

 # Shell Package

 #

-# Copyright (c) 2007 - 2011, Intel Corporation. All rights reserved.<BR>

+# Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>

 #

 #    This program and the accompanying materials

 #    are licensed and made available under the terms and conditions of the BSD License

@@ -64,7 +64,7 @@
   gEfiMdePkgTokenSpaceGuid.PcdUefiLibMaxPrintBufferSize|16000

 !ifdef $(NO_SHELL_PROFILES)

   gEfiShellPkgTokenSpaceGuid.PcdShellProfileMask|0x00

-!endif

+!endif #$(NO_SHELL_PROFILES)

 

 [Components]

   ShellPkg/Library/UefiFileHandleLib/UefiFileHandleLib.inf

@@ -73,6 +73,13 @@
   ShellPkg/Library/UefiShellLevel2CommandsLib/UefiShellLevel2CommandsLib.inf

   ShellPkg/Library/UefiHandleParsingLib/UefiHandleParsingLib.inf

 

+  ShellPkg/Library/UefiDpLib/UefiDpLib.inf {

+    <LibraryClasses>

+      TimerLib|MdePkg/Library/BaseTimerLibNullTemplate/BaseTimerLibNullTemplate.inf

+      PerformanceLib|MdePkg/Library/BasePerformanceLibNull/BasePerformanceLibNull.inf

+      DxeServicesLib|MdePkg/Library/DxeServicesLib/DxeServicesLib.inf

+  }

+

   ShellPkg/Application/Shell/Shell.inf {

     <LibraryClasses>

       NULL|ShellPkg/Library/UefiShellLevel2CommandsLib/UefiShellLevel2CommandsLib.inf

@@ -83,6 +90,9 @@
       NULL|ShellPkg/Library/UefiShellInstall1CommandsLib/UefiShellInstall1CommandsLib.inf

       NULL|ShellPkg/Library/UefiShellDebug1CommandsLib/UefiShellDebug1CommandsLib.inf

       NULL|ShellPkg/Library/UefiShellNetwork1CommandsLib/UefiShellNetwork1CommandsLib.inf

-!endif

+!ifdef $(INCLUDE_DP)

+      NULL|ShellPkg/Library/UefiDpLib/UefiDpLib.inf

+!endif #$(INCLUDE_DP)

+!endif #$(NO_SHELL_PROFILES)

   }

 

diff --git a/SourceLevelDebugPkg/DebugAgentDxe/DebugAgentDxe.c b/SourceLevelDebugPkg/DebugAgentDxe/DebugAgentDxe.c
new file mode 100644
index 00000000..99bb2fde
--- /dev/null
+++ b/SourceLevelDebugPkg/DebugAgentDxe/DebugAgentDxe.c
@@ -0,0 +1,101 @@
+/** @file

+  Initialize Debug Agent in DXE by invoking Debug Agent Library.

+

+Copyright (c) 2013, Intel Corporation. All rights reserved.<BR>

+This program and the accompanying materials                          

+are licensed and made available under the terms and conditions of the BSD License         

+which accompanies this distribution.  The full text of the license may be found at        

+http://opensource.org/licenses/bsd-license.php                                            

+                                                                                          

+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+

+**/

+

+#include <PiDxe.h>

+#include <Guid/EventGroup.h>

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/DebugAgentLib.h>

+

+EFI_EVENT       mExitBootServiceEvent; 

+

+/**

+  One notified function to disable Debug Timer interrupt when gBS->ExitBootServices() called.

+

+  @param[in]  Event              Pointer to this event

+  @param[in]  Context            Event hanlder private data

+

+**/

+VOID

+EFIAPI

+DisableDebugTimerExitBootService (

+  EFI_EVENT                      Event,

+  VOID                           *Context

+  )

+

+{

+  SaveAndSetDebugTimerInterrupt (FALSE);

+}

+

+/**

+  The Entry Point for Debug Agent Dxe driver.

+

+  It will invoke Debug Agent Library to enable source debugging feature in DXE phase.

+

+  @param[in] ImageHandle    The firmware allocated handle for the EFI image.

+  @param[in] SystemTable    A pointer to the EFI System Table.

+

+  @retval EFI_SUCCESS       The entry point is executed successfully.

+  @retval other             Some error occurs when initialzed Debug Agent.

+

+**/

+EFI_STATUS

+EFIAPI

+DebugAgentDxeInitialize(

+  IN EFI_HANDLE           ImageHandle,

+  IN EFI_SYSTEM_TABLE     *SystemTable

+  )

+{

+  EFI_STATUS      Status;

+

+  InitializeDebugAgent (DEBUG_AGENT_INIT_DXE_LOAD, &Status, NULL);

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+  //

+  // Create event to disable Debug Timer interrupt when exit boot service.

+  //

+  Status = gBS->CreateEventEx (

+                  EVT_NOTIFY_SIGNAL,

+                  TPL_NOTIFY,

+                  DisableDebugTimerExitBootService,

+                  NULL,

+                  &gEfiEventExitBootServicesGuid,

+                  &mExitBootServiceEvent

+                  );

+  return Status;

+}

+

+/**

+  This is the unload handle for Debug Agent Dxe driver.

+

+  It will invoke Debug Agent Library to disable source debugging feature.

+

+  @param[in]  ImageHandle       The drivers' driver image.

+

+  @retval EFI_SUCCESS           The image is unloaded.

+  @retval Others                Failed to unload the image.

+

+**/

+EFI_STATUS

+EFIAPI

+DebugAgentDxeUnload (

+  IN EFI_HANDLE           ImageHandle

+  )

+{

+  EFI_STATUS          Status;

+

+  InitializeDebugAgent (DEBUG_AGENT_INIT_DXE_UNLOAD, &Status, NULL);

+

+  return Status;

+}

diff --git a/SourceLevelDebugPkg/DebugAgentDxe/DebugAgentDxe.inf b/SourceLevelDebugPkg/DebugAgentDxe/DebugAgentDxe.inf
new file mode 100644
index 00000000..114b708a
--- /dev/null
+++ b/SourceLevelDebugPkg/DebugAgentDxe/DebugAgentDxe.inf
@@ -0,0 +1,48 @@
+## @file

+#  Initialized Debug Agent in one separated DXE driver.

+#

+#  This DXE driver will invoke Debug Agent Library to initialize the debug agent.

+#

+# Copyright (c) 2013, Intel Corporation. All rights reserved.<BR>

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+##

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = DebugAgentDxe

+  FILE_GUID                      = 9727502C-034E-472b-8E1B-67BB28C6CFDB

+  MODULE_TYPE                    = DXE_DRIVER

+  VERSION_STRING                 = 1.0  

+  ENTRY_POINT                    = DebugAgentDxeInitialize

+  UNLOAD_IMAGE                   = DebugAgentDxeUnload

+

+#

+# The following information is for reference only and not required by the build tools.

+#

+#  VALID_ARCHITECTURES           = IA32 X64

+#

+

+[Sources]

+  DebugAgentDxe.c

+  

+[Packages]

+  MdePkg/MdePkg.dec

+  MdeModulePkg/MdeModulePkg.dec

+

+[LibraryClasses]

+  UefiDriverEntryPoint

+  UefiBootServicesTableLib

+  DebugAgentLib  

+

+[Guids]

+  gEfiEventExitBootServicesGuid                 ## SOMETIMES_CONSUMES ## Event

+

+[Depex]

+  TRUE

diff --git a/SourceLevelDebugPkg/DebugAgentPei/DebugAgentPei.c b/SourceLevelDebugPkg/DebugAgentPei/DebugAgentPei.c
new file mode 100644
index 00000000..df0ac87b
--- /dev/null
+++ b/SourceLevelDebugPkg/DebugAgentPei/DebugAgentPei.c
@@ -0,0 +1,45 @@
+/** @file

+  Initialize Debug Agent in PEI by invoking Debug Agent Library.

+

+Copyright (c) 2013, Intel Corporation. All rights reserved.<BR>

+This program and the accompanying materials                          

+are licensed and made available under the terms and conditions of the BSD License         

+which accompanies this distribution.  The full text of the license may be found at        

+http://opensource.org/licenses/bsd-license.php                                            

+                                                                                          

+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+

+**/

+

+#include <PiPei.h>

+

+#include <Library/DebugAgentLib.h>

+

+/**

+  The Entry Point for Debug Agent PEI driver.

+

+  It will invoke Debug Agent Library to enable source debugging feature in PEI phase.

+

+  This function is the Entry point of the CPU I/O PEIM which installs CpuIoPpi.

+

+  @param[in]  FileHandle   Pointer to image file handle.

+  @param[in]  PeiServices  Pointer to PEI Services Table   

+

+  @retval EFI_SUCCESS    Debug Agent successfully initialized.

+  @retval other          Some error occurs when initialzed Debug Agent.

+

+**/

+EFI_STATUS

+EFIAPI

+DebugAgentPeiInitialize (

+  IN EFI_PEI_FILE_HANDLE     FileHandle,

+  IN CONST EFI_PEI_SERVICES  **PeiServices

+  )

+{

+  EFI_STATUS                 Status;

+

+  InitializeDebugAgent (DEBUG_AGENT_INIT_PEI, &Status, NULL);

+

+  return Status;

+}

diff --git a/SourceLevelDebugPkg/DebugAgentPei/DebugAgentPei.inf b/SourceLevelDebugPkg/DebugAgentPei/DebugAgentPei.inf
new file mode 100644
index 00000000..d20a0120
--- /dev/null
+++ b/SourceLevelDebugPkg/DebugAgentPei/DebugAgentPei.inf
@@ -0,0 +1,44 @@
+## @file

+#  Initialized Debug Agent in PEI phase.

+#

+#  This PEIM will invoke Debug Agent Library to initialize the debug agent in 

+#  whole PEI phase.

+#

+# Copyright (c) 2013, Intel Corporation. All rights reserved.<BR>

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+##

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = DebugAgentPei

+  FILE_GUID                      = D9D114EF-F40B-4d48-AAA0-A3DC99C9F5BD

+  MODULE_TYPE                    = PEIM

+  VERSION_STRING                 = 1.0  

+  ENTRY_POINT                    = DebugAgentPeiInitialize

+

+#

+# The following information is for reference only and not required by the build tools.

+#

+#  VALID_ARCHITECTURES           = IA32 X64

+#

+

+[Sources]

+  DebugAgentPei.c

+  

+[Packages]

+  MdePkg/MdePkg.dec

+  MdeModulePkg/MdeModulePkg.dec

+

+[LibraryClasses]

+  PeimEntryPoint

+  DebugAgentLib

+

+[Depex]

+  TRUE

diff --git a/SourceLevelDebugPkg/Include/ImageDebugSupport.h b/SourceLevelDebugPkg/Include/ImageDebugSupport.h
index 68299857..511a12ce 100644
--- a/SourceLevelDebugPkg/Include/ImageDebugSupport.h
+++ b/SourceLevelDebugPkg/Include/ImageDebugSupport.h
@@ -2,7 +2,7 @@
   Public include file for Debug Agent Library instance and PE/COFF Extra

   Action Library instance.

 

-  Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -19,6 +19,7 @@
 #define IO_PORT_BREAKPOINT_ADDRESS  0x84

 #define IMAGE_LOAD_SIGNATURE        SIGNATURE_32('L','O','A','D')

 #define IMAGE_UNLOAD_SIGNATURE      SIGNATURE_32('U','N','L','O')

+#define AGENT_HANDLER_SIGNATURE     SIGNATURE_32('A','G','T','H')

 

 #define DEBUG_AGENT_IMAGE_WAIT      0x00

 #define DEBUG_AGENT_IMAGE_CONTINUE  0x01

diff --git a/SourceLevelDebugPkg/Include/TransferProtocol.h b/SourceLevelDebugPkg/Include/TransferProtocol.h
index bb7b07b4..53e9f7cf 100644
--- a/SourceLevelDebugPkg/Include/TransferProtocol.h
+++ b/SourceLevelDebugPkg/Include/TransferProtocol.h
@@ -2,7 +2,7 @@
   Transfer protocol defintions used by debug agent and host. It is only

   intended to be used by Debug related module implementation.

 

-  Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -21,25 +21,19 @@
 //

 // Current revision of transfer protocol

 //

-#define DEBUG_AGENT_REVISION            ((0 << 16) | 02)

+#define DEBUG_AGENT_REVISION            ((0 << 16) | 03)

 #define DEBUG_AGENT_CAPABILITIES        0

 

 //

-// Definitions for break command.

-//

-#define DEBUG_STARTING_SYMBOL_BREAK         (0xFC)

-

-//

 // Definitions for attach command

 //

-#define DEBUG_STARTING_SYMBOL_ATTACH        (0xFA)

+#define DEBUG_STARTING_SYMBOL_ATTACH    (0xFA)

 

 //

 // Definition for starting symbol of a normal debug packet. Choose a non-ASCII to avoid conflict with other serial output.

 //

 #define DEBUG_STARTING_SYMBOL_NORMAL    (0xFE)

 

-

 #pragma pack(1)

 

 //

@@ -49,7 +43,8 @@ typedef struct {
   UINT8                      StartSymbol;

   UINT8                      Command;

   UINT8                      Length;    // Length of Debug Packet including header and payload in byte

-  UINT8                      CheckSum;

+  UINT8                      SequenceNo;

+  UINT16                     Crc;

 } DEBUG_PACKET_HEADER;

 

 //

@@ -86,6 +81,7 @@ typedef struct {
 #define DEBUG_COMMAND_DETACH                      (DEBUG_COMMAND_REQUEST | 0x16)

 #define DEBUG_COMMAND_CPUID                       (DEBUG_COMMAND_REQUEST | 0x17)

 #define DEBUG_COMMAND_SEARCH_SIGNATURE            (DEBUG_COMMAND_REQUEST | 0x18)

+#define DEBUG_COMMAND_HALT                        (DEBUG_COMMAND_REQUEST | 0x19)

 

 //

 // TARGET initiated commands

@@ -94,6 +90,7 @@ typedef struct {
 #define DEBUG_COMMAND_BREAK_POINT                 (DEBUG_COMMAND_REQUEST | 0x3E)

 #define DEBUG_COMMAND_MEMORY_READY                (DEBUG_COMMAND_REQUEST | 0x3D)

 #define DEBUG_COMMAND_PRINT_MESSAGE               (DEBUG_COMMAND_REQUEST | 0x3C)

+#define DEBUG_COMMAND_ATTACH_BREAK                (DEBUG_COMMAND_REQUEST | 0x3B)

 

 //

 // Response commands

@@ -308,8 +305,9 @@ typedef struct {
 //

 // Supported keys

 //

-#define DEBUG_AGENT_SETTING_SMM_ENTRY_BREAK     1

-#define DEBUG_AGENT_SETTING_PRINT_ERROR_LEVEL   2

+#define DEBUG_AGENT_SETTING_SMM_ENTRY_BREAK          1

+#define DEBUG_AGENT_SETTING_PRINT_ERROR_LEVEL        2

+#define DEBUG_AGENT_SETTING_BOOT_SCRIPT_ENTRY_BREAK  3

 //

 // Bitmask of print error level for debug message

 //

diff --git a/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/DebugAgent.c b/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/DebugAgent.c
index 04dae341..f4039f49 100644
--- a/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/DebugAgent.c
+++ b/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/DebugAgent.c
@@ -4,7 +4,7 @@
   read/write debug packet to communication with HOST based on transfer

   protocol.

 

-  Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -18,12 +18,305 @@
 #include "DebugAgent.h"

 #include "Ia32/DebugException.h"

 

-#define INIT_BREAK_ACK_TIMEOUT  (200 * 1000)

+CHAR8 mErrorMsgVersionAlert[]       = "\rThe SourceLevelDebugPkg you are using requires a newer version of the Intel(R) UDK Debugger Tool.\r\n";

+CHAR8 mErrorMsgSendInitPacket[]     = "\rSend INIT break packet and try to connect the HOST (Intel(R) UDK Debugger Tool v1.3) ...\r\n";

+CHAR8 mErrorMsgConnectOK[]          = "HOST connection is successful!\r\n";

+CHAR8 mErrorMsgConnectFail[]        = "HOST connection is failed!\r\n";

+CHAR8 mWarningMsgIngoreBreakpoint[] = "Ignore break point in SMM for SMI issued during DXE debugging!\r\n";

 

-CHAR8 mErrorMsgVersionAlert[]   = "\rThe SourceLevelDebugPkg you are using requires a newer version of the Intel(R) UDK Debugger Tool.\r\n";

-CHAR8 mErrorMsgSendInitPacket[] = "\rSend INIT break packet to HOST ...\r\n";

-CHAR8 mErrorMsgConnectOK[]      = "HOST connection is successful!\r\n";

-CHAR8 mErrorMsgConnectFail[]    = "HOST connection is failed!\r\n";

+/**

+  Calculate CRC16 for target data.

+

+  @param[in]  Data              The target data.

+  @param[in]  DataSize          The target data size.

+  @param[in]  Crc               Initial CRC.

+

+  @return UINT16     The CRC16 value.

+

+**/

+UINT16

+CalculateCrc16 (

+  IN UINT8   *Data,

+  IN UINTN   DataSize,

+  IN UINT16  Crc

+  )

+{

+  UINTN  Index;

+  UINTN  BitIndex;

+

+  for (Index = 0; Index < DataSize; Index++) {

+    Crc ^= Data[Index];

+    for (BitIndex = 0; BitIndex < 8; BitIndex++) {

+      if ((Crc & 0x8000) != 0) {

+        Crc <<= 1;

+        Crc ^= 0x1021;

+      } else {

+        Crc <<= 1;

+      }

+    }

+  }

+  return Crc;

+}

+

+

+/**

+  Read IDT entry to check if IDT entries are setup by Debug Agent.

+

+  @retval  TRUE     IDT entries were setup by Debug Agent.

+  @retval  FALSE    IDT entries were not setup by Debug Agent.

+

+**/

+BOOLEAN 

+IsDebugAgentInitialzed (

+  VOID

+  )

+{

+  UINTN                      InterruptHandler;

+

+  InterruptHandler = (UINTN) GetExceptionHandlerInIdtEntry (0);

+  if (InterruptHandler >= 4 &&  *(UINT32 *)(InterruptHandler - 4) == AGENT_HANDLER_SIGNATURE) {

+    return TRUE;

+  } else {

+    return FALSE;

+  }

+}

+

+/**

+  Find and report module image info to HOST.

+  

+  @param[in] AlignSize      Image aligned size.

+  

+**/

+VOID 

+FindAndReportModuleImageInfo (

+  IN UINTN          AlignSize                   

+  )

+{

+  UINTN                                Pe32Data;

+  EFI_IMAGE_DOS_HEADER                 *DosHdr;

+  EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION  Hdr;

+  PE_COFF_LOADER_IMAGE_CONTEXT         ImageContext;

+

+  //

+  // Find Image Base

+  //

+  Pe32Data = ((UINTN)mErrorMsgVersionAlert) & ~(AlignSize - 1);

+  while (Pe32Data != 0) {

+    DosHdr = (EFI_IMAGE_DOS_HEADER *) Pe32Data;

+    if (DosHdr->e_magic == EFI_IMAGE_DOS_SIGNATURE) {

+      //

+      // DOS image header is present, so read the PE header after the DOS image header.

+      // Check if address overflow firstly.

+      //

+      if ((MAX_ADDRESS - (UINTN)DosHdr->e_lfanew) > Pe32Data) {

+        Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)(Pe32Data + (UINTN)(DosHdr->e_lfanew));

+        if (Hdr.Pe32->Signature == EFI_IMAGE_NT_SIGNATURE) {

+          //

+          // It's PE image.

+          //

+          break;

+        }

+      }

+    } else {

+      //

+      // DOS image header is not present, TE header is at the image base.

+      //

+      Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)Pe32Data;

+      if ((Hdr.Te->Signature == EFI_TE_IMAGE_HEADER_SIGNATURE) &&

+          ((Hdr.Te->Machine == IMAGE_FILE_MACHINE_I386) || Hdr.Te->Machine == IMAGE_FILE_MACHINE_X64)) {

+        //

+        // It's TE image, it TE header and Machine type match

+        //

+        break;

+      }

+    }

+

+    //

+    // Not found the image base, check the previous aligned address

+    // 

+    Pe32Data -= AlignSize;

+  }

+

+  ImageContext.ImageAddress = Pe32Data;

+  ImageContext.PdbPointer = PeCoffLoaderGetPdbPointer ((VOID*) (UINTN) ImageContext.ImageAddress);

+  PeCoffLoaderRelocateImageExtraAction (&ImageContext);

+}

+

+/**

+  Trigger one software interrupt to debug agent to handle it.

+

+  @param[in] Signature       Software interrupt signature.

+

+**/

+VOID

+TriggerSoftInterrupt (

+  IN UINT32                 Signature

+  )

+{

+  UINTN                  Dr0;

+  UINTN                  Dr1;

+

+  //

+  // Save Debug Register State

+  //

+  Dr0 = AsmReadDr0 ();

+  Dr1 = AsmReadDr1 ();

+

+  //

+  // DR0 = Signature

+  //

+  AsmWriteDr0 (SOFT_INTERRUPT_SIGNATURE);

+  AsmWriteDr1 (Signature);

+

+  //

+  // Do INT3 to communicate with HOST side

+  //

+  CpuBreakpoint ();

+

+  //

+  // Restore Debug Register State only when Host didn't change it inside exception handler.

+  //   Dr registers can only be changed by setting the HW breakpoint.

+  //

+  AsmWriteDr0 (Dr0);

+  AsmWriteDr1 (Dr1);

+

+}

+

+/**

+  Caculate Mailbox checksum and update the checksum field.

+

+  @param[in]  Mailbox  Debug Agent Mailbox pointer.

+

+**/

+VOID

+UpdateMailboxChecksum (

+  IN DEBUG_AGENT_MAILBOX    *Mailbox

+  )

+{

+  Mailbox->CheckSum = CalculateCheckSum8 ((UINT8 *)Mailbox, sizeof (DEBUG_AGENT_MAILBOX) - 2);    

+}

+

+/**

+  Verify Mailbox checksum.

+

+  If checksum error, print debug message and run init dead loop.

+

+  @param[in]  Mailbox  Debug Agent Mailbox pointer.

+

+**/

+VOID 

+VerifyMailboxChecksum (

+  IN DEBUG_AGENT_MAILBOX    *Mailbox

+  )

+{

+  UINT8                     CheckSum;

+  

+  CheckSum = CalculateCheckSum8 ((UINT8 *) Mailbox, sizeof (DEBUG_AGENT_MAILBOX) - 2);

+  //

+  // The checksum updating process may be disturbed by hardware SMI, we need to check CheckSum field 

+  // and ToBeCheckSum field to validate the mail box.

+  //

+  if (CheckSum != Mailbox->CheckSum && CheckSum != Mailbox->ToBeCheckSum) {

+    DEBUG ((EFI_D_ERROR, "DebugAgent: Mailbox checksum error, stack or heap crashed!\n"));

+    DEBUG ((EFI_D_ERROR, "DebugAgent: CheckSum = %x, Mailbox->CheckSum = %x, Mailbox->ToBeCheckSum = %x\n", CheckSum, Mailbox->CheckSum, Mailbox->ToBeCheckSum));

+    CpuDeadLoop ();

+  }

+}

+

+/**

+  Update Mailbox content by index.

+

+  @param[in]  Mailbox  Debug Agent Mailbox pointer.

+  @param[in]  Index    Mailbox content index.

+  @param[in]  Value    Value to be set into Mailbox.

+  

+**/

+VOID

+UpdateMailboxContent ( 

+  IN DEBUG_AGENT_MAILBOX    *Mailbox,

+  IN UINTN                  Index,

+  IN UINT64                 Value

+  )

+{

+  AcquireMpSpinLock (&mDebugMpContext.MailboxSpinLock);

+  switch (Index) {

+  case DEBUG_MAILBOX_DEBUG_FLAG_INDEX:

+    Mailbox->ToBeCheckSum = Mailbox->CheckSum + CalculateSum8 ((UINT8 *)&Mailbox->DebugFlag.Uint64, sizeof(UINT64)) 

+                                              - CalculateSum8 ((UINT8 *)&Value, sizeof(UINT64));

+    Mailbox->DebugFlag.Uint64 = Value;

+    break;

+  case DEBUG_MAILBOX_DEBUG_PORT_HANDLE_INDEX:

+    Mailbox->ToBeCheckSum = Mailbox->CheckSum + CalculateSum8 ((UINT8 *)&Mailbox->DebugPortHandle, sizeof(UINTN))

+                                              - CalculateSum8 ((UINT8 *)&Value, sizeof(UINTN));

+    Mailbox->DebugPortHandle = (UINTN) Value;

+    break;

+  case DEBUG_MAILBOX_EXCEPTION_BUFFER_POINTER_INDEX:

+    Mailbox->ToBeCheckSum = Mailbox->CheckSum + CalculateSum8 ((UINT8 *)&Mailbox->ExceptionBufferPointer, sizeof(UINTN))

+                                              - CalculateSum8 ((UINT8 *)&Value, sizeof(UINTN));

+    Mailbox->ExceptionBufferPointer = (UINTN) Value;

+    break;

+  case DEBUG_MAILBOX_LAST_ACK:

+    Mailbox->ToBeCheckSum = Mailbox->CheckSum + CalculateSum8 ((UINT8 *)&Mailbox->LastAck, sizeof(UINT8))

+                                              - CalculateSum8 ((UINT8 *)&Value, sizeof(UINT8));

+    Mailbox->LastAck = (UINT8) Value;

+    break;

+  case DEBUG_MAILBOX_SEQUENCE_NO_INDEX:

+    Mailbox->ToBeCheckSum = Mailbox->CheckSum + CalculateSum8 ((UINT8 *)&Mailbox->SequenceNo, sizeof(UINT8))

+                                              - CalculateSum8 ((UINT8 *)&Value, sizeof(UINT8));

+    Mailbox->SequenceNo = (UINT8) Value;

+    break;

+  case DEBUG_MAILBOX_HOST_SEQUENCE_NO_INDEX:

+    Mailbox->ToBeCheckSum = Mailbox->CheckSum + CalculateSum8 ((UINT8 *)&Mailbox->HostSequenceNo, sizeof(UINT8))

+                                              - CalculateSum8 ((UINT8 *)&Value, sizeof(UINT8));

+    Mailbox->HostSequenceNo = (UINT8) Value;

+    break;

+  }

+  UpdateMailboxChecksum (Mailbox);

+  ReleaseMpSpinLock (&mDebugMpContext.MailboxSpinLock);

+}

+/**

+  Set debug flag in mailbox.

+

+  @param[in]  FlagMask      Debug flag mask value.

+  @param[in]  FlagValue     Debug flag value.

+

+**/

+VOID 

+SetDebugFlag (

+  IN UINT64                 FlagMask,

+  IN UINT32                 FlagValue                          

+  )

+{

+  DEBUG_AGENT_MAILBOX    *Mailbox;

+  UINT64                 Data64;

+

+  Mailbox = GetMailboxPointer ();

+  Data64 = (Mailbox->DebugFlag.Uint64 & ~FlagMask) |

+           (LShiftU64 ((UINT64)FlagValue, LowBitSet64 (FlagMask)) & FlagMask);

+  UpdateMailboxContent (Mailbox, DEBUG_MAILBOX_DEBUG_FLAG_INDEX, Data64);

+}

+

+/**

+  Get debug flag in mailbox.

+

+  @param[in]  FlagMask      Debug flag mask value.

+  

+  @return Debug flag value.

+

+**/

+UINT32

+GetDebugFlag (

+  IN UINT64                 FlagMask

+  )

+{

+  DEBUG_AGENT_MAILBOX    *Mailbox;

+  UINT32                 DebugFlag;

+

+  Mailbox = GetMailboxPointer ();

+  DebugFlag = (UINT32) RShiftU64 (Mailbox->DebugFlag.Uint64 & FlagMask, LowBitSet64 (FlagMask));

+

+  return DebugFlag;

+}

 

 /**

   Send a debug message packet to the debug port.

@@ -46,8 +339,12 @@ SendDebugMsgPacket (
   DebugHeader.StartSymbol = DEBUG_STARTING_SYMBOL_NORMAL;

   DebugHeader.Command     = DEBUG_COMMAND_PRINT_MESSAGE;

   DebugHeader.Length      = sizeof (DEBUG_PACKET_HEADER) + (UINT8) Length;

-  DebugHeader.CheckSum    = 0;

-  DebugHeader.CheckSum    = CalculateCheckSum8 ((UINT8 *)&DebugHeader, sizeof (DEBUG_PACKET_HEADER));

+  DebugHeader.SequenceNo  = 0xEE;

+  DebugHeader.Crc         = 0;

+  DebugHeader.Crc         = CalculateCrc16 (

+                              (UINT8 *)Buffer, Length,

+                              CalculateCrc16 ((UINT8 *)&DebugHeader, sizeof (DEBUG_PACKET_HEADER), 0)

+                              );

 

   DebugPortWriteBuffer (Handle, (UINT8 *)&DebugHeader, sizeof (DEBUG_PACKET_HEADER));

   DebugPortWriteBuffer (Handle, (UINT8 *)Buffer, Length);

@@ -73,15 +370,13 @@ DebugAgentMsgPrint (
   ...

   )

 {

-  DEBUG_AGENT_MAILBOX  *Mailbox;

   CHAR8                Buffer[DEBUG_DATA_MAXIMUM_REAL_DATA];

   VA_LIST              Marker;

 

-  Mailbox = GetMailboxPointer ();

   //

   // Check driver debug mask value and global mask

   //

-  if ((ErrorLevel & Mailbox->DebugFlag.PrintErrorLevel) == 0) {

+  if ((ErrorLevel & GetDebugFlag (DEBUG_AGENT_FLAG_PRINT_ERROR_LEVEL)) == 0) {

     return;

   }

 

@@ -119,16 +414,14 @@ DebugAgentDataMsgPrint (
   IN UINT8             Length  

   )

 {

-  DEBUG_AGENT_MAILBOX  *Mailbox;

   CHAR8                Buffer[DEBUG_DATA_MAXIMUM_REAL_DATA];

   CHAR8                *DestBuffer;

   UINTN                Index;

 

-  Mailbox = GetMailboxPointer ();

   //

   // Check driver debug mask value and global mask

   //

-  if ((ErrorLevel & Mailbox->DebugFlag.PrintErrorLevel) == 0) {

+  if ((ErrorLevel & GetDebugFlag (DEBUG_AGENT_FLAG_PRINT_ERROR_LEVEL)) == 0) {

     return;

   }

 

@@ -152,7 +445,7 @@ DebugAgentDataMsgPrint (
     DestBuffer += AsciiSPrint (DestBuffer, DEBUG_DATA_MAXIMUM_REAL_DATA - (DestBuffer - Buffer), "%02x ", Data[Index]);

     Index ++;

     if (Index >= Length) {

-      //s

+      //

       // The last character of debug message has been foramtted in buffer

       //

       DestBuffer += AsciiSPrint(DestBuffer, DEBUG_DATA_MAXIMUM_REAL_DATA - (DestBuffer - Buffer), "]\n");

@@ -162,6 +455,46 @@ DebugAgentDataMsgPrint (
   }

 }

 

+/**

+  Read remaing debug packet except for the start symbol

+

+  @param[in]      Handle        Pointer to Debug Port handle.

+  @param[in, out] DebugHeader   Debug header buffer including start symbol.

+

+  @retval EFI_SUCCESS        Read the symbol in BreakSymbol.

+  @retval EFI_CRC_ERROR      CRC check fail.

+  @retval EFI_TIMEOUT        Timeout occurs when reading debug packet.

+

+**/

+EFI_STATUS

+ReadRemainingBreakPacket (

+  IN     DEBUG_PORT_HANDLE      Handle,

+  IN OUT DEBUG_PACKET_HEADER    *DebugHeader

+  )

+{

+  UINT16                     Crc;

+  //

+  // Has received start symbol, try to read the rest part

+  //

+  if (DebugPortReadBuffer (Handle, &DebugHeader->Command, sizeof (DEBUG_PACKET_HEADER) - 1, READ_PACKET_TIMEOUT) == 0) {

+    //

+    // Timeout occur, exit

+    //

+    DebugAgentMsgPrint (DEBUG_AGENT_WARNING, "Timeout in Debug Timer interrupt\n");

+    return EFI_TIMEOUT;

+  }

+

+  Crc = DebugHeader->Crc;

+  DebugHeader->Crc = 0;

+  if (CalculateCrc16 ((UINT8 *)DebugHeader, DebugHeader->Length, 0) != Crc) {

+    DebugAgentMsgPrint (DEBUG_AGENT_WARNING, "Debug Timer CRC (%x) against (%x)\n", Crc, CalculateCrc16 ((UINT8 *) &DebugHeader, DebugHeader->Length, 0));

+    DebugAgentDataMsgPrint (DEBUG_AGENT_VERBOSE, FALSE, (UINT8 *)DebugHeader, DebugHeader->Length);

+    return EFI_CRC_ERROR;

+  }

+

+  UpdateMailboxContent (GetMailboxPointer(), DEBUG_MAILBOX_HOST_SEQUENCE_NO_INDEX, DebugHeader->SequenceNo);

+  return EFI_SUCCESS;

+}

 

 /**

   Check if HOST is attached based on Mailbox.

@@ -175,7 +508,7 @@ IsHostAttached (
   VOID

   )

 {

-  return (BOOLEAN) (GetMailboxPointer ()->DebugFlag.HostAttached == 1);

+  return (BOOLEAN) (GetDebugFlag (DEBUG_AGENT_FLAG_HOST_ATTACHED) == 1);

 }

 

 /**

@@ -190,7 +523,7 @@ SetHostAttached (
   )

 {

   DebugAgentMsgPrint (DEBUG_AGENT_INFO, "Attach status is %d\n", Attached);

-  GetMailboxPointer ()->DebugFlag.HostAttached = Attached;

+  SetDebugFlag (DEBUG_AGENT_FLAG_HOST_ATTACHED, (UINT32)Attached);

 }

 

 /**

@@ -208,17 +541,17 @@ SetDebugSetting (
   )

 {

   RETURN_STATUS                Status;

-  DEBUG_AGENT_MAILBOX          *Mailbox;

-

-  Mailbox = GetMailboxPointer ();

 

   Status = RETURN_SUCCESS;

   switch (DebugSetting->Key) {

   case DEBUG_AGENT_SETTING_SMM_ENTRY_BREAK:

-    Mailbox->DebugFlag.BreakOnNextSmi = DebugSetting->Value;

+    SetDebugFlag (DEBUG_AGENT_FLAG_BREAK_ON_NEXT_SMI, DebugSetting->Value);

     break;

   case DEBUG_AGENT_SETTING_PRINT_ERROR_LEVEL:

-    Mailbox->DebugFlag.PrintErrorLevel = DebugSetting->Value;

+    SetDebugFlag (DEBUG_AGENT_FLAG_PRINT_ERROR_LEVEL, DebugSetting->Value);

+    break;

+  case DEBUG_AGENT_SETTING_BOOT_SCRIPT_ENTRY_BREAK:

+    SetDebugFlag (DEBUG_AGENT_FLAG_BREAK_BOOT_SCRIPT, DebugSetting->Value);

     break;

   default:

     Status = RETURN_UNSUPPORTED;

@@ -446,11 +779,13 @@ ArchReadRegisterBuffer (
   Send the packet without data to HOST.

 

   @param[in] CommandType    Type of Command.

+  @param[in] SequenceNo     Sequence number.

 

 **/

 VOID

 SendPacketWithoutData (

-  IN UINT8                  CommandType

+  IN UINT8                  CommandType,

+  IN UINT8                  SequenceNo

   )

 {

   DEBUG_PACKET_HEADER       DebugHeader;

@@ -461,8 +796,9 @@ SendPacketWithoutData (
   DebugHeader.StartSymbol = DEBUG_STARTING_SYMBOL_NORMAL;

   DebugHeader.Command     = CommandType;

   DebugHeader.Length      = sizeof (DEBUG_PACKET_HEADER);

-  DebugHeader.CheckSum    = 0;

-  DebugHeader.CheckSum    = CalculateCheckSum8 ((UINT8 *)&DebugHeader, sizeof (DEBUG_PACKET_HEADER));

+  DebugHeader.SequenceNo  = SequenceNo;

+  DebugHeader.Crc         = 0;

+  DebugHeader.Crc         = CalculateCrc16 ((UINT8 *)&DebugHeader, sizeof (DEBUG_PACKET_HEADER), 0);

 

   DebugAgentDataMsgPrint (DEBUG_AGENT_VERBOSE, TRUE, (UINT8 *) &DebugHeader, DebugHeader.Length);

   DebugPortWriteBuffer (Handle, (UINT8 *) &DebugHeader, DebugHeader.Length);

@@ -479,104 +815,142 @@ SendAckPacket (
   IN UINT8                AckCommand

   )

 {

+  UINT8                   SequenceNo;

+  DEBUG_AGENT_MAILBOX     *Mailbox;

+

   if (AckCommand != DEBUG_COMMAND_OK) {

+    //

+    // This is not ACK OK packet

+    //

     DebugAgentMsgPrint (DEBUG_AGENT_ERROR, "Send ACK(%d)\n", AckCommand);

   }

-  SendPacketWithoutData (AckCommand);

+  Mailbox = GetMailboxPointer();

+  SequenceNo = Mailbox->HostSequenceNo;

+  DebugAgentMsgPrint (DEBUG_AGENT_INFO, "SendAckPacket: SequenceNo = %x\n", SequenceNo);

+  SendPacketWithoutData (AckCommand, SequenceNo);

+  UpdateMailboxContent (Mailbox, DEBUG_MAILBOX_LAST_ACK, AckCommand);

 }

 

 /**

-  Receive acknowledge packet from HOST in specified time.

+  Receive valid packet from HOST.

 

-  @param[out] Ack            Returned acknowlege type from HOST.

-  @param[in]  Timeout        Time out value to wait for acknowlege from HOST.

-                             The unit is microsecond.

-  @param[out] BreakReceived  If BreakReceived is not NULL,

-                             TRUE is retured if break-in symbol received.

-                             FALSE is retured if break-in symbol not received.

-  @param[out] CheckSumStatus If CheckSumStatus is not NULL,

-                             RETURN_SUCCESS   CheckSum is OK.

-                             RETURN_NOT_FOUND Not find the CheckSum field.

+  @param[out] InputPacket         Buffer to receive packet.

+  @param[out] BreakReceived       TRUE means break-in symbol received.

+                                  FALSE means break-in symbol not received.

+  @param[out] IncompatibilityFlag If IncompatibilityFlag is not NULL, return

+                                  TRUE:  Compatible packet received.

+                                  FALSE: Incompatible packet received.

+  @param[in]  Timeout             Time out value to wait for acknowlege from HOST.

+                                  The unit is microsecond.

+  @param[in]  SkipStartSymbol     TRUE:  Skip time out when reading start symbol.

+                                  FALSE: Does not Skip time out when reading start symbol.

 

-  @retval  RETRUEN_SUCCESS  Succeed to receive acknowlege packet from HOST,

-                            the type of acknowlege packet saved in Ack.

-  @retval  RETURN_TIMEOUT   Specified timeout value was up.

+  @retval RETURN_SUCCESS   A valid package was reveived in InputPacket.

+  @retval RETURN_TIMEOUT   Timeout occurs.

 

 **/

 RETURN_STATUS

-ReceiveAckPacket (

-  OUT UINT8                     *Ack,

-  IN  UINTN                     Timeout,

-  OUT BOOLEAN                   *BreakReceived, OPTIONAL

-  OUT RETURN_STATUS             *CheckSumStatus OPTIONAL

+ReceivePacket (

+  OUT UINT8             *InputPacket,

+  OUT BOOLEAN           *BreakReceived,

+  OUT BOOLEAN           *IncompatibilityFlag, OPTIONAL

+  IN  UINTN             Timeout,

+  IN  BOOLEAN           SkipStartSymbol

   )

 {

-  DEBUG_PACKET_HEADER       DebugHeader;

-  DEBUG_PORT_HANDLE         Handle;

+  DEBUG_PACKET_HEADER   *DebugHeader;

+  UINTN                 Received;

+  DEBUG_PORT_HANDLE     Handle;

+  UINT16                Crc;

+  UINTN                 TimeoutForStartSymbol;

 

   Handle = GetDebugPortHandle();

-

+  if (SkipStartSymbol) {

+    TimeoutForStartSymbol = 0;

+  } else {

+    TimeoutForStartSymbol = Timeout;

+  }

+  

+  DebugHeader = (DEBUG_PACKET_HEADER *) InputPacket;

   while (TRUE) {

-    if (DebugPortReadBuffer (Handle, (UINT8 *) &DebugHeader.StartSymbol, sizeof (DebugHeader.StartSymbol), Timeout) == 0) {

+    //

+    // Find the valid start symbol

+    //

+    Received = DebugPortReadBuffer (Handle, &DebugHeader->StartSymbol, sizeof (DebugHeader->StartSymbol), TimeoutForStartSymbol);

+    if (Received < sizeof (DebugHeader->StartSymbol)) {

+      DebugAgentMsgPrint (DEBUG_AGENT_WARNING, "DebugPortReadBuffer(StartSymbol) timeout\n");

       return RETURN_TIMEOUT;

     }

-    if (DebugHeader.StartSymbol == DEBUG_STARTING_SYMBOL_BREAK) {

-      if (BreakReceived != NULL) {

-        SendAckPacket (DEBUG_COMMAND_HALT_DEFERRED);

-        *BreakReceived = TRUE;

-      }

-    }

-    if (DebugHeader.StartSymbol == DEBUG_STARTING_SYMBOL_NORMAL) {

-      break;

+

+    if (DebugHeader->StartSymbol != DEBUG_STARTING_SYMBOL_NORMAL) {

+      DebugAgentMsgPrint (DEBUG_AGENT_WARNING, "Invalid start symbol received [%02x]\n", DebugHeader->StartSymbol);

+      continue;

     }

-    DebugAgentMsgPrint (DEBUG_AGENT_ERROR, "Invalid start symbol received [%02x]\n", DebugHeader.StartSymbol);

-  }

-  //

-  // Read ACK packet header till field Length (not including StartSymbol and CheckSum)

-  //

-  DebugHeader.Length = 0;

-  if (DebugPortReadBuffer (

-        Handle,

-        (UINT8 *)&DebugHeader.Command,

-        OFFSET_OF (DEBUG_PACKET_HEADER, Length) + sizeof (DebugHeader.Length) - sizeof (DebugHeader.StartSymbol),

-        Timeout

-        ) == 0) {

-    return RETURN_TIMEOUT;

-  }

 

-  if (DebugHeader.Length == 0) {

     //

-    // The CheckSum field does not exist

+    // Read Package header till field Length

     //

-    if (CheckSumStatus != NULL) {

-      *CheckSumStatus = RETURN_NOT_FOUND;

-    }

-  } else {

-    if (CheckSumStatus != NULL) {

-      *CheckSumStatus = RETURN_SUCCESS;

-    }

-    if (DebugPortReadBuffer (Handle, &DebugHeader.CheckSum, sizeof (DebugHeader.CheckSum), Timeout) == 0) {

+    Received = DebugPortReadBuffer (

+                 Handle,

+                 &DebugHeader->Command,

+                 OFFSET_OF (DEBUG_PACKET_HEADER, Length) + sizeof (DebugHeader->Length) - sizeof (DebugHeader->StartSymbol),

+                 Timeout

+                 );

+    if (Received == 0) {

+      DebugAgentMsgPrint (DEBUG_AGENT_ERROR, "DebugPortReadBuffer(Command) timeout\n");

       return RETURN_TIMEOUT;

     }

+    if (DebugHeader->Length < sizeof (DEBUG_PACKET_HEADER)) {

+      if (IncompatibilityFlag != NULL) {

+        //

+        // This is one old version debug packet format, set Incompatibility flag

+        //

+        *IncompatibilityFlag = TRUE;

+      } else {

+        //

+        // Skip the bad small packet

+        //

+        continue;

+      }

+    } else {

+      //

+      // Read the payload data include the CRC field

+      //

+      Received = DebugPortReadBuffer (Handle, &DebugHeader->SequenceNo, (UINT8) (DebugHeader->Length - OFFSET_OF (DEBUG_PACKET_HEADER, SequenceNo)), Timeout);

+      if (Received == 0) {

+        DebugAgentMsgPrint (DEBUG_AGENT_ERROR, "DebugPortReadBuffer(SequenceNo) timeout\n");

+        return RETURN_TIMEOUT;

+      }

+      //

+      // Calculate the CRC of Debug Packet

+      //

+      Crc = DebugHeader->Crc;

+      DebugHeader->Crc = 0;

+      if (Crc == CalculateCrc16 ((UINT8 *) DebugHeader, DebugHeader->Length, 0)) {

+        break;

+      }

+      DebugAgentMsgPrint (DEBUG_AGENT_WARNING, "CRC Error (received CRC is %x)\n", Crc);

+      DebugAgentDataMsgPrint (DEBUG_AGENT_VERBOSE, FALSE, (UINT8 *) DebugHeader, DebugHeader->Length);

+    }

   }

 

-  DebugAgentDataMsgPrint (DEBUG_AGENT_VERBOSE, FALSE, (UINT8 *)&DebugHeader, DebugHeader.Length);

-  *Ack = DebugHeader.Command;

+  DebugAgentDataMsgPrint (DEBUG_AGENT_VERBOSE, FALSE, (UINT8 *) DebugHeader, DebugHeader->Length);

+

   return RETURN_SUCCESS;

 }

 

 /**

   Receive acknowledge packet OK from HOST in specified time.

 

-  @param[in]  Command        The command type issued by TARGET.

-  @param[in]  Timeout        Time out value to wait for acknowlege from HOST.

-                             The unit is microsecond.

-  @param[out] BreakReceived  If BreakReceived is not NULL,

-                             TRUE is retured if break-in symbol received.

-                             FALSE is retured if break-in symbol not received.

-  @param[out] CheckSumStatus If CheckSumStatus is not NULL,

-                             RETURN_SUCCESS   CheckSum is OK.

-                             RETURN_NOT_FOUND Not find the CheckSum field.

+  @param[in]  Command             The command type issued by TARGET.

+  @param[in]  Timeout             Time out value to wait for acknowlege from HOST.

+                                  The unit is microsecond.

+  @param[out] BreakReceived       If BreakReceived is not NULL,

+                                  TRUE is retured if break-in symbol received.

+                                  FALSE is retured if break-in symbol not received.

+  @param[out] IncompatibilityFlag If IncompatibilityFlag is not NULL, return

+                                  TRUE:  Compatible packet received.

+                                  FALSE: Incompatible packet received.

 

   @retval  RETRUEN_SUCCESS  Succeed to receive acknowlege packet from HOST,

                             the type of acknowlege packet saved in Ack.

@@ -588,109 +962,56 @@ SendCommandAndWaitForAckOK (
   IN  UINT8               Command,

   IN  UINTN               Timeout,

   OUT BOOLEAN             *BreakReceived, OPTIONAL

-  OUT RETURN_STATUS       *CheckSumStatus OPTIONAL

+  OUT BOOLEAN             *IncompatibilityFlag OPTIONAL

   )

 {

   RETURN_STATUS           Status;

-  UINT8                   Ack;

-  

-  while (TRUE) {

-    SendPacketWithoutData (Command);

-    while (TRUE) {

-      Status = ReceiveAckPacket (&Ack, Timeout, BreakReceived, CheckSumStatus);

-      if (Status == RETURN_SUCCESS && Ack == DEBUG_COMMAND_RESEND) {

-        //

-        // Resend the last command

-        //

-        break;

-      } 

-      if ((Status == RETURN_SUCCESS && Ack == DEBUG_COMMAND_OK) ||

-           Status == RETURN_TIMEOUT) {

-        //

-        // Received Ack OK or timeout

-        //

-        return Status;

-      }  

-    }

-  }

-}

-

-/**

-  Receive valid packet from HOST.

-

-  @param[out] InputPacket    Buffer to receive packet.

-  @param[out] BreakReceived  TRUE means break-in symbol received.

-                             FALSE means break-in symbol not received.

-

-  @retval RETURN_SUCCESS   A valid package was reveived in InputPacket.

-  @retval RETURN_TIMEOUT   Timeout occurs.

-

-**/

-RETURN_STATUS

-ReceivePacket (

-  OUT UINT8             *InputPacket,

-  OUT BOOLEAN           *BreakReceived

-  )

-{

-  DEBUG_PACKET_HEADER   *DebugHeader;

-  UINTN                 Received;

-  DEBUG_PORT_HANDLE     Handle;

-  UINT8                 CheckSum;

-

-  Handle = GetDebugPortHandle();

-  

-  DebugHeader = (DEBUG_PACKET_HEADER *) InputPacket;

-  while (TRUE) {

-    //

-    // Find the valid start symbol

-    //

-    DebugPortReadBuffer (Handle, &DebugHeader->StartSymbol, sizeof (DebugHeader->StartSymbol), 0);

-

-    if (DebugHeader->StartSymbol == DEBUG_STARTING_SYMBOL_BREAK) {

-      *BreakReceived = TRUE;

-      SendAckPacket (DEBUG_COMMAND_HALT_DEFERRED);

-    }

-

-    if (DebugHeader->StartSymbol != DEBUG_STARTING_SYMBOL_NORMAL) {

-      DebugAgentMsgPrint (DEBUG_AGENT_ERROR, "Invalid start symbol received [%02x]\n", DebugHeader->StartSymbol);

+  UINT8                   InputPacketBuffer[DEBUG_DATA_UPPER_LIMIT];

+  DEBUG_PACKET_HEADER     *DebugHeader;

+  UINT8                   SequenceNo;

+  UINT8                   HostSequenceNo;

+  UINT8                   RetryCount;

+

+  RetryCount  = 3;

+  DebugHeader = (DEBUG_PACKET_HEADER *) InputPacketBuffer;

+  Status      = RETURN_TIMEOUT;

+  while (RetryCount > 0) {

+    SequenceNo = GetMailboxPointer()->SequenceNo;

+    HostSequenceNo = GetMailboxPointer()->HostSequenceNo;

+    SendPacketWithoutData (Command, SequenceNo);

+    Status = ReceivePacket ((UINT8 *) DebugHeader, BreakReceived, IncompatibilityFlag, Timeout, FALSE);

+    if (Status == RETURN_TIMEOUT) {

+      if (Command == DEBUG_COMMAND_INIT_BREAK) {

+        RetryCount--;

+      } else {

+        DebugAgentMsgPrint (DEBUG_AGENT_WARNING, "TARGET: Timeout when waiting for ACK packet.\n");

+      }

       continue;

     }

-

-    //

-    // Read Package header except for checksum

-    //

-    Received = DebugPortReadBuffer (

-                 Handle,

-                 &DebugHeader->Command,

-                 OFFSET_OF (DEBUG_PACKET_HEADER, Length) + sizeof (DebugHeader->Length) - sizeof (DebugHeader->StartSymbol),

-                 0

-                 );

-    if (Received == 0) {

-      return RETURN_TIMEOUT;

-    }

-

+    ASSERT_EFI_ERROR (Status);

     //

-    // Read the payload data include the checksum

+    // Status == RETURN_SUCCESS

     //

-    Received = DebugPortReadBuffer (Handle, &DebugHeader->CheckSum, DebugHeader->Length - OFFSET_OF (DEBUG_PACKET_HEADER, CheckSum), 0);

-    if (Received == 0) {

-      return RETURN_TIMEOUT;

+    if (DebugHeader->Command == DEBUG_COMMAND_OK && DebugHeader->SequenceNo == SequenceNo) {

+      //

+      // Received Ack OK

+      //

+      UpdateMailboxContent (GetMailboxPointer(), DEBUG_MAILBOX_SEQUENCE_NO_INDEX, ++SequenceNo);

+      return Status;

     }

-    //

-    // Calculate the checksum of Debug Packet

-    //

-    CheckSum = CalculateCheckSum8 ((UINT8 *) DebugHeader, DebugHeader->Length);

-    if (CheckSum == 0) {

-      break;

+    if (DebugHeader->Command == DEBUG_COMMAND_GO && (DebugHeader->SequenceNo == HostSequenceNo || Command == DEBUG_COMMAND_INIT_BREAK)) {

+      //

+      // Received Old GO

+      //

+      if (Command == DEBUG_COMMAND_INIT_BREAK) {

+        DebugAgentMsgPrint (DEBUG_AGENT_WARNING, "TARGET: Receive GO() in last boot\n");

+      }

+      SendPacketWithoutData (DEBUG_COMMAND_OK, DebugHeader->SequenceNo);

     }

-    DebugAgentMsgPrint (DEBUG_AGENT_WARNING, "CheckSum Error (Caculated checksum is %x, received checksum is %x\n", CheckSum, DebugHeader->CheckSum);

-    DebugAgentMsgPrint (DEBUG_AGENT_WARNING, "Send DEBUG_COMMAND_RESEND command.\n");

-    SendAckPacket (DEBUG_COMMAND_RESEND);

   }

 

-  DebugAgentDataMsgPrint (DEBUG_AGENT_VERBOSE, FALSE, (UINT8 *) DebugHeader, DebugHeader->Length);

-

-  return RETURN_SUCCESS;

+  ASSERT (Command == DEBUG_COMMAND_INIT_BREAK);

+  return Status;

 }

 

 /**

@@ -773,7 +1094,7 @@ GetBreakCause (
 

   default:

     if (Vector < 20) {

-      if (GetMailboxPointer()->DebugFlag.SteppingFlag == 1) {

+      if (GetDebugFlag (DEBUG_AGENT_FLAG_STEPPING) == 1) {

         //

         // If stepping command is executing

         //

@@ -789,28 +1110,28 @@ GetBreakCause (
 }

 

 /**

-  Send command packet with data to HOST.

+  Send packet with response data to HOST.

 

-  @param[in] Command     Command type.

   @param[in] Data        Pointer to response data buffer.

   @param[in] DataSize    Size of response data in byte.

 

   @retval RETURN_SUCCESS      Response data was sent successfully.

-  @retval RETURN_DEVICE_ERROR Cannot receive DEBUG_COMMAND_OK from HOST.

 

 **/

 RETURN_STATUS

-SendCommandWithDataPacket (

-  IN UINT8                Command,

+SendDataResponsePacket (

   IN UINT8                *Data,

   IN UINT16               DataSize

   )

 {

+  RETURN_STATUS        Status;

   DEBUG_PACKET_HEADER  *DebugHeader;

   BOOLEAN              LastPacket;

-  UINT8                Ack;

+  DEBUG_PACKET_HEADER  *AckDebugHeader;

   UINT8                DebugPacket[DEBUG_DATA_UPPER_LIMIT];

+  UINT8                InputPacketBuffer[DEBUG_DATA_UPPER_LIMIT];

   DEBUG_PORT_HANDLE    Handle;

+  UINT8                SequenceNo;

 

   Handle = GetDebugPortHandle();

 

@@ -818,84 +1139,67 @@ SendCommandWithDataPacket (
   DebugHeader->StartSymbol = DEBUG_STARTING_SYMBOL_NORMAL;

 

   while (TRUE) {

+    SequenceNo = GetMailboxPointer()->HostSequenceNo;

     if (DataSize <= DEBUG_DATA_MAXIMUM_REAL_DATA) {

       LastPacket = TRUE;

-      DebugHeader->Command  = Command;

-      DebugHeader->Length   = (UINT8) (DataSize + sizeof (DEBUG_PACKET_HEADER));

-      DebugHeader->CheckSum = 0;

+      DebugHeader->Command    = DEBUG_COMMAND_OK;

+      DebugHeader->Length     = (UINT8) (DataSize + sizeof (DEBUG_PACKET_HEADER));

+      DebugHeader->SequenceNo = SequenceNo;

+      DebugHeader->Crc        = 0;

       CopyMem (DebugHeader + 1, Data, DataSize);

 

     } else {

       LastPacket = FALSE;

-      DebugHeader->Command  = DEBUG_COMMAND_IN_PROGRESS;

-      DebugHeader->Length   = DEBUG_DATA_MAXIMUM_REAL_DATA + sizeof (DEBUG_PACKET_HEADER);

-      DebugHeader->CheckSum = 0;

+      DebugHeader->Command    = DEBUG_COMMAND_IN_PROGRESS;

+      DebugHeader->Length     = DEBUG_DATA_MAXIMUM_REAL_DATA + sizeof (DEBUG_PACKET_HEADER);

+      DebugHeader->SequenceNo = SequenceNo;

+      DebugHeader->Crc        = 0;

       CopyMem (DebugHeader + 1, Data, DEBUG_DATA_MAXIMUM_REAL_DATA);

     }

 

     //

     // Calculate and fill the checksum

     //

-    DebugHeader->CheckSum = CalculateCheckSum8 ((UINT8 *) DebugHeader, DebugHeader->Length);

+    DebugHeader->Crc = CalculateCrc16 ((UINT8 *) DebugHeader, DebugHeader->Length, 0);

 

     DebugAgentDataMsgPrint (DEBUG_AGENT_VERBOSE, TRUE, (UINT8 *) DebugHeader, DebugHeader->Length);

     

     DebugPortWriteBuffer (Handle, (UINT8 *) DebugHeader, DebugHeader->Length);

 

-    ReceiveAckPacket(&Ack, 0, NULL, NULL);

-    switch (Ack) {

-    case DEBUG_COMMAND_RESEND:

-      //

-      // Send the packet again

-      //

-      DebugAgentMsgPrint (DEBUG_AGENT_WARNING, "Received DEBUG_COMMAND_RESEND.\n");

-      break;

-

-    case DEBUG_COMMAND_CONTINUE:

-      //

-      // Send the rest packet

-      //

-      Data     += DEBUG_DATA_MAXIMUM_REAL_DATA;

-      DataSize -= DEBUG_DATA_MAXIMUM_REAL_DATA;

-      break;

-

-    case DEBUG_COMMAND_OK:

-      if (LastPacket) {

+    while (TRUE) {

+      Status = ReceivePacket (InputPacketBuffer, NULL, NULL, READ_PACKET_TIMEOUT, FALSE);

+      if (Status == RETURN_TIMEOUT) {

+        DebugAgentMsgPrint (DEBUG_AGENT_WARNING, "TARGET: Timeout in SendDataResponsePacket()\n");

+        break;

+      }

+      AckDebugHeader = (DEBUG_PACKET_HEADER *) InputPacketBuffer;

+      SequenceNo = AckDebugHeader->SequenceNo;

+      if (AckDebugHeader->Command == DEBUG_COMMAND_OK &&

+          SequenceNo == DebugHeader->SequenceNo &&

+          LastPacket) {

         //

         // If this is the last packet, return RETURN_SUCCESS.

         //

         return RETURN_SUCCESS;

-      } else {

-        return RETURN_DEVICE_ERROR;

       }

-

-    default:

-      return RETURN_DEVICE_ERROR;

-

+      if ((SequenceNo == (UINT8) (DebugHeader->SequenceNo + 1)) && (AckDebugHeader->Command == DEBUG_COMMAND_CONTINUE)) {

+        //

+        // Send the rest packet

+        //

+        Data     += DEBUG_DATA_MAXIMUM_REAL_DATA;

+        DataSize -= DEBUG_DATA_MAXIMUM_REAL_DATA;

+        UpdateMailboxContent (GetMailboxPointer(), DEBUG_MAILBOX_HOST_SEQUENCE_NO_INDEX, (UINT8) SequenceNo);

+        break;

+      }

+      if (SequenceNo >= DebugHeader->SequenceNo) {

+        DebugAgentMsgPrint (DEBUG_AGENT_WARNING, "TARGET: Received one old or new command(SequenceNo is %x, last SequenceNo is %x)\n", SequenceNo, DebugHeader->SequenceNo);

+        break;

+      }

     }

   }

 }

 

 /**

-  Send packet with response data to HOST.

-

-  @param[in] Data        Pointer to response data buffer.

-  @param[in] DataSize    Size of response data in byte.

-

-  @retval RETURN_SUCCESS      Response data was sent successfully.

-  @retval RETURN_DEVICE_ERROR Cannot receive DEBUG_COMMAND_OK from HOST.

-

-**/

-RETURN_STATUS

-SendDataResponsePacket (

-  IN UINT8                *Data,

-  IN UINT16               DataSize

-  )

-{

-  return SendCommandWithDataPacket (DEBUG_COMMAND_OK, Data, DataSize);

-}

-

-/**

   Send break cause packet to HOST.

 

   @param[in] Vector      Vector value of exception or interrutp.

@@ -927,6 +1231,7 @@ SendBreakCausePacket (
   If received acknowlege, check the revision of HOST. 

   Set Attach Flag if attach successfully.  

   

+  @param[in]  BreakCause     Break cause of this break event.

   @param[in]  Timeout        Time out value to wait for acknowlege from HOST.

                              The unit is microsecond.

   @param[out] BreakReceived  If BreakReceived is not NULL,

@@ -935,42 +1240,45 @@ SendBreakCausePacket (
 **/

 RETURN_STATUS

 AttachHost (

+  IN  UINT8                BreakCause,

   IN  UINTN                Timeout,

   OUT BOOLEAN              *BreakReceived

   )

 {

   RETURN_STATUS                    Status;

   DEBUG_PORT_HANDLE                Handle;

-  RETURN_STATUS                    CheckSumStatus;

+  BOOLEAN                          IncompatibilityFlag;

 

+  IncompatibilityFlag = FALSE;

   Handle = GetDebugPortHandle();

     

   //

   // Send init break and wait ack in Timeout

   //

   DebugPortWriteBuffer (Handle, (UINT8 *) mErrorMsgSendInitPacket, AsciiStrLen (mErrorMsgSendInitPacket));

-  Status = SendCommandAndWaitForAckOK (DEBUG_COMMAND_INIT_BREAK, Timeout, BreakReceived, &CheckSumStatus);

-  if (RETURN_ERROR (Status)) {

-    DebugPortWriteBuffer (Handle, (UINT8 *) mErrorMsgConnectFail, AsciiStrLen (mErrorMsgConnectFail));

-    return Status;

+  if (BreakCause == DEBUG_DATA_BREAK_CAUSE_SYSTEM_RESET) {

+    Status = SendCommandAndWaitForAckOK (DEBUG_COMMAND_INIT_BREAK, Timeout, BreakReceived, &IncompatibilityFlag);

+  } else {

+    Status = SendCommandAndWaitForAckOK (DEBUG_COMMAND_ATTACH_BREAK, Timeout, BreakReceived, &IncompatibilityFlag);

   }

-  

-  if (CheckSumStatus == RETURN_NOT_FOUND) {

+  if (IncompatibilityFlag) {

     //

-    // If the CheckSum field does not exist in Debug Packet,

-    // the HOST should be running with 0.1 transfer protocol.

-    // It could be UDK Debugger for Windows v1.1 or for Linux v0.8.

+    // If the incompatible Debug Packet received, the HOST should be running transfer protocol before DEBUG_AGENT_REVISION.

+    // It could be UDK Debugger for Windows v1.1/v1.2 or for Linux v0.8/v1.2.

     //

     DebugPortWriteBuffer (Handle, (UINT8 *) mErrorMsgVersionAlert, AsciiStrLen (mErrorMsgVersionAlert));

     CpuDeadLoop ();

   }

-

-  DebugPortWriteBuffer (Handle, (UINT8 *) mErrorMsgConnectOK, AsciiStrLen (mErrorMsgConnectOK));

-  //

-  // Set Attach flag

-  //

-  SetHostAttached (TRUE);

-

+  

+  if (RETURN_ERROR (Status)) {

+    DebugPortWriteBuffer (Handle, (UINT8 *) mErrorMsgConnectFail, AsciiStrLen (mErrorMsgConnectFail));

+  } else {

+    DebugPortWriteBuffer (Handle, (UINT8 *) mErrorMsgConnectOK, AsciiStrLen (mErrorMsgConnectOK));

+    //

+    // Set Attach flag

+    //

+    SetHostAttached (TRUE);

+  }

   return Status;

 }

 

@@ -978,7 +1286,8 @@ AttachHost (
   Send Break point packet to HOST. 

   

   Only the first breaking processor could sent BREAK_POINT packet.

- 

+

+  @param[in]  BreakCause     Break cause of this break event.

   @param[in]  ProcessorIndex Processor index value.

   @param[out] BreakReceived  If BreakReceived is not NULL,

                              TRUE is retured if break-in symbol received.

@@ -987,6 +1296,7 @@ AttachHost (
 **/

 VOID

 SendBreakPacketToHost (

+  IN  UINT8                BreakCause,

   IN  UINT32               ProcessorIndex,

   OUT BOOLEAN              *BreakReceived

   )

@@ -998,7 +1308,7 @@ SendBreakPacketToHost (
   

   if (IsHostAttached ()) {

     DebugAgentMsgPrint (DEBUG_AGENT_INFO, "processor[%x]:Send Break Packet to HOST.\n", ProcessorIndex);

-    SendCommandAndWaitForAckOK (DEBUG_COMMAND_BREAK_POINT, 0, BreakReceived, NULL);

+    SendCommandAndWaitForAckOK (DEBUG_COMMAND_BREAK_POINT, READ_PACKET_TIMEOUT, BreakReceived, NULL);

   } else {

     DebugAgentMsgPrint (DEBUG_AGENT_INFO, "processor[%x]:Try to attach HOST.\n", ProcessorIndex);

     //

@@ -1015,7 +1325,7 @@ SendBreakPacketToHost (
     //

     // Try to attach HOST

     //

-    while (AttachHost (0, NULL) != RETURN_SUCCESS);

+    while (AttachHost (BreakCause, 0, NULL) != RETURN_SUCCESS);

    

   }

 }

@@ -1065,12 +1375,13 @@ CommandCommunication (
   DEBUG_PORT_HANDLE                 Handle;

   DEBUG_AGENT_EXCEPTION_BUFFER      AgentExceptionBuffer;

   UINT32                            IssuedViewPoint;

+  DEBUG_AGENT_MAILBOX               *Mailbox;

 

   ProcessorIndex  = 0;

   IssuedViewPoint = 0;

   HaltDeferred    = BreakReceived;

 

-  if (MultiProcessorDebugSupport) {

+  if (MultiProcessorDebugSupport()) {

     ProcessorIndex = GetProcessorIndex ();

     SetCpuStopFlagByIndex (ProcessorIndex, TRUE);

     if (mDebugMpContext.ViewPointIndex == ProcessorIndex) {

@@ -1085,14 +1396,14 @@ CommandCommunication (
     //

     // Set AgentInProgress Flag.

     //

-    GetMailboxPointer()->DebugFlag.AgentInProgress = 1;

+    SetDebugFlag (DEBUG_AGENT_FLAG_AGENT_IN_PROGRESS, 1);

   }  

 

   Handle = GetDebugPortHandle();

 

   while (TRUE) {

 

-    if (MultiProcessorDebugSupport) {

+    if (MultiProcessorDebugSupport()) {

       //

       // Check if the current processor is HOST view point

       //

@@ -1114,35 +1425,44 @@ CommandCommunication (
       }

     }

 

-    AcquireDebugPortControl ();

+    AcquireMpSpinLock (&mDebugMpContext.DebugPortSpinLock);

 

-    Status = ReceivePacket (InputPacketBuffer, &BreakReceived);

+    DebugHeader =(DEBUG_PACKET_HEADER *) InputPacketBuffer;

 

-    if (BreakReceived) {

-      HaltDeferred = TRUE;

-      BreakReceived = FALSE;

+    DebugAgentMsgPrint (DEBUG_AGENT_INFO, "TARGET: Try to get command from HOST...\n");

+    Status = ReceivePacket ((UINT8 *)DebugHeader, &BreakReceived, NULL, READ_PACKET_TIMEOUT, TRUE);

+    if (Status != RETURN_SUCCESS || (DebugHeader->Command & DEBUG_COMMAND_RESPONSE) != 0) {

+      DebugAgentMsgPrint (DEBUG_AGENT_WARNING, "TARGET: Get command[%x] sequenceno[%x] returned status is [%x] \n", DebugHeader->Command, DebugHeader->SequenceNo, Status);

+      DebugAgentMsgPrint (DEBUG_AGENT_WARNING, "TARGET: Get command failed or it's response packet not expected! \n");

+      ReleaseMpSpinLock (&mDebugMpContext.DebugPortSpinLock);

+      continue;

     }

 

-    if (Status != RETURN_SUCCESS) {

-      ReleaseDebugPortControl ();

+    Mailbox = GetMailboxPointer ();

+    if (DebugHeader->SequenceNo == Mailbox->HostSequenceNo) {

+      DebugAgentMsgPrint (DEBUG_AGENT_WARNING, "TARGET: Receive one old command[%x] agaist command[%x]\n", DebugHeader->SequenceNo, Mailbox->HostSequenceNo);

+      SendAckPacket (Mailbox->LastAck);

+      ReleaseMpSpinLock (&mDebugMpContext.DebugPortSpinLock);

+      continue;

+    } else if (DebugHeader->SequenceNo == (UINT8) (Mailbox->HostSequenceNo + 1)) {

+      UpdateMailboxContent (Mailbox, DEBUG_MAILBOX_HOST_SEQUENCE_NO_INDEX, (UINT8) DebugHeader->SequenceNo);

+    } else {

+      DebugAgentMsgPrint (DEBUG_AGENT_WARNING, "Receive one invalid comamnd[%x] agaist command[%x]\n", DebugHeader->SequenceNo, Mailbox->HostSequenceNo);

+      ReleaseMpSpinLock (&mDebugMpContext.DebugPortSpinLock);

       continue;

     }

-

-    Data8 = 1;

-

-    DebugHeader =(DEBUG_PACKET_HEADER *) InputPacketBuffer;

-

-    GetMailboxPointer()->ExceptionBufferPointer = (UINT64)(UINTN) &AgentExceptionBuffer.JumpBuffer;

+    

     //

     // Save CPU content before executing HOST commond

     //

+    UpdateMailboxContent (Mailbox, DEBUG_MAILBOX_EXCEPTION_BUFFER_POINTER_INDEX, (UINT64)(UINTN) &AgentExceptionBuffer.JumpBuffer);

     if (SetJump (&AgentExceptionBuffer.JumpBuffer) != 0) {

       //

       // If HOST command failed, continue to wait for HOST's next command

       // If needed, agent could send exception info to HOST.

       //

       SendAckPacket (DEBUG_COMMAND_ABORT);

-      ReleaseDebugPortControl ();

+      ReleaseMpSpinLock (&mDebugMpContext.DebugPortSpinLock);

       continue;

     }

 

@@ -1150,9 +1470,18 @@ CommandCommunication (
     

     switch (DebugHeader->Command) {

 

+    case DEBUG_COMMAND_HALT:

+      SendAckPacket (DEBUG_COMMAND_HALT_DEFERRED);

+      HaltDeferred = TRUE;

+      BreakReceived = FALSE;

+      Status = RETURN_SUCCESS;

+      break;

+

     case DEBUG_COMMAND_RESET:

       SendAckPacket (DEBUG_COMMAND_OK);

-      ReleaseDebugPortControl ();

+      SendAckPacket (DEBUG_COMMAND_OK);

+      SendAckPacket (DEBUG_COMMAND_OK);

+      ReleaseMpSpinLock (&mDebugMpContext.DebugPortSpinLock);

 

       ResetCold ();

       //

@@ -1160,6 +1489,9 @@ CommandCommunication (
       // PCD can be used if 2 seconds isn't long enough for some platforms.

       //

       MicroSecondDelay (2000000);

+      UpdateMailboxContent (Mailbox, DEBUG_MAILBOX_HOST_SEQUENCE_NO_INDEX, Mailbox->HostSequenceNo + 1);

+      SendAckPacket (DEBUG_COMMAND_TIMEOUT);

+      SendAckPacket (DEBUG_COMMAND_TIMEOUT);

       SendAckPacket (DEBUG_COMMAND_TIMEOUT);

       break;

 

@@ -1176,13 +1508,13 @@ CommandCommunication (
       //

       // Clear Stepping Flag

       //

-      GetMailboxPointer()->DebugFlag.SteppingFlag = 0;

+      SetDebugFlag (DEBUG_AGENT_FLAG_STEPPING, 0);

       

       if (!HaltDeferred) {

         //

         // If no HALT command received when being in-active mode

         //

-        if (MultiProcessorDebugSupport) {

+        if (MultiProcessorDebugSupport()) {

           Data32 = FindNextPendingBreakCpu ();

           if (Data32 != -1) {

             //

@@ -1200,11 +1532,11 @@ CommandCommunication (
             //

             // Send break packet to HOST to let HOST break again

             //

-            SendBreakPacketToHost (0, &BreakReceived);

+            SendBreakPacketToHost (DEBUG_DATA_BREAK_CAUSE_UNKNOWN, mDebugMpContext.BreakAtCpuIndex, &BreakReceived);

             //

             // Continue to run into loop to read command packet from HOST

             //

-            ReleaseDebugPortControl (); 

+            ReleaseMpSpinLock (&mDebugMpContext.DebugPortSpinLock);

             break;

           }

 

@@ -1240,8 +1572,12 @@ CommandCommunication (
         //

         SendAckPacket (DEBUG_COMMAND_OK);

 

-        ReleaseDebugPortControl ();

+        ReleaseMpSpinLock (&mDebugMpContext.DebugPortSpinLock);

 

+        if (!IsHostAttached()) {

+          UpdateMailboxContent (Mailbox, DEBUG_MAILBOX_SEQUENCE_NO_INDEX, 0);

+          UpdateMailboxContent (Mailbox, DEBUG_MAILBOX_HOST_SEQUENCE_NO_INDEX, 0);

+        }

         return;

 

       } else {

@@ -1257,7 +1593,7 @@ CommandCommunication (
 

     case DEBUG_COMMAND_BREAK_CAUSE:

 

-      if (MultiProcessorDebugSupport && ProcessorIndex != mDebugMpContext.BreakAtCpuIndex) {

+      if (MultiProcessorDebugSupport() && ProcessorIndex != mDebugMpContext.BreakAtCpuIndex) {

         Status = SendBreakCausePacket (DEBUG_TIMER_VECTOR, CpuContext);

 

       } else {

@@ -1291,8 +1627,8 @@ CommandCommunication (
       //

       // Set Stepping Flag

       //

-      GetMailboxPointer()->DebugFlag.SteppingFlag = 1;

-      ReleaseDebugPortControl ();

+      SetDebugFlag (DEBUG_AGENT_FLAG_STEPPING, 1);

+      ReleaseMpSpinLock (&mDebugMpContext.DebugPortSpinLock);

       //

       // Executing stepping command directly without sending ACK packet,

       // ACK packet will be sent after stepping done.

@@ -1424,7 +1760,7 @@ CommandCommunication (
 

     case DEBUG_COMMAND_SET_VIEWPOINT:

       SetViewPoint = (DEBUG_DATA_SET_VIEWPOINT *) (DebugHeader + 1);

-      if (MultiProcessorDebugSupport) {

+      if (MultiProcessorDebugSupport()) {

         if (IsCpuStopped (SetViewPoint->ViewPoint)) {

           SetDebugViewPoint (SetViewPoint->ViewPoint);

           SendAckPacket (DEBUG_COMMAND_OK);

@@ -1449,7 +1785,7 @@ CommandCommunication (
       break;

 

     case DEBUG_COMMAND_MEMORY_READY:

-      Data8 = (UINT8) GetMailboxPointer ()->DebugFlag.MemoryReady;

+      Data8 = (UINT8) GetDebugFlag (DEBUG_AGENT_FLAG_MEMORY_READY);

       SendDataResponsePacket (&Data8, (UINT16) sizeof (UINT8));

       break;

 

@@ -1517,7 +1853,7 @@ CommandCommunication (
       SendAckPacket (DEBUG_COMMAND_ABORT);

     }

 

-    ReleaseDebugPortControl ();

+    ReleaseMpSpinLock (&mDebugMpContext.DebugPortSpinLock);

     CpuPause ();

   }

 }

@@ -1552,7 +1888,17 @@ InterruptProcess (
   IssuedViewPoint = 0;

   BreakReceived   = FALSE;

 

-  if (MultiProcessorDebugSupport) {

+  if (mSkipBreakpoint) {

+    //

+    // If Skip Breakpoint flag is set, means communication is disturbed by hardware SMI, we need to ignore the break points in SMM

+    //

+    if ((Vector == DEBUG_INT1_VECTOR) || (Vector == DEBUG_INT3_VECTOR)) {

+      DebugPortWriteBuffer (GetDebugPortHandle(), (UINT8 *) mWarningMsgIngoreBreakpoint, AsciiStrLen (mWarningMsgIngoreBreakpoint));

+      return;

+    }

+  }

+

+  if (MultiProcessorDebugSupport()) {

     ProcessorIndex = GetProcessorIndex ();

     //

     // If this processor has alreay halted before, need to check it later

@@ -1562,22 +1908,22 @@ InterruptProcess (
     }

   }

 

-  if (IssuedViewPoint == ProcessorIndex) {

+  if (IssuedViewPoint == ProcessorIndex && GetDebugFlag (DEBUG_AGENT_FLAG_STEPPING) != 1) {

     //

     // Check if this exception is issued by Debug Agent itself

     // If yes, fill the debug agent exception buffer and LongJump() back to

     // the saved CPU content in CommandCommunication()

     //

-    if (GetMailboxPointer()->DebugFlag.AgentInProgress == 1) {

+    if (GetDebugFlag (DEBUG_AGENT_FLAG_AGENT_IN_PROGRESS) == 1) {

       DebugAgentMsgPrint (DEBUG_AGENT_ERROR, "Debug agent meet one Exception, ExceptionNum is %d.\n", Vector);

       ExceptionBuffer = (DEBUG_AGENT_EXCEPTION_BUFFER *) (UINTN) GetMailboxPointer()->ExceptionBufferPointer;

       ExceptionBuffer->ExceptionContent.ExceptionNum  = (UINT8) Vector;

       ExceptionBuffer->ExceptionContent.ExceptionData = (UINT32) CpuContext->ExceptionData;

-      LongJump ((BASE_LIBRARY_JUMP_BUFFER *)(UINTN)(GetMailboxPointer()->ExceptionBufferPointer), 1);

+      LongJump ((BASE_LIBRARY_JUMP_BUFFER *)(UINTN)(ExceptionBuffer), 1);

     }

   }

 

-  if (MultiProcessorDebugSupport) {

+  if (MultiProcessorDebugSupport()) {

     //

     // If RUN commmand is executing, wait for it done.  

     //

@@ -1586,16 +1932,14 @@ InterruptProcess (
     }

   }

 

-  Handle = GetDebugPortHandle();

-

+  Handle     = GetDebugPortHandle();

+  BreakCause = GetBreakCause (Vector, CpuContext);

   switch (Vector) {

   case DEBUG_INT1_VECTOR:

   case DEBUG_INT3_VECTOR:

-    BreakCause = GetBreakCause (Vector, CpuContext);

-

     switch (BreakCause) {

     case DEBUG_DATA_BREAK_CAUSE_SYSTEM_RESET:

-      if (AttachHost (INIT_BREAK_ACK_TIMEOUT, &BreakReceived) != RETURN_SUCCESS) {

+      if (AttachHost (BreakCause, READ_PACKET_TIMEOUT, &BreakReceived) != RETURN_SUCCESS) {

         //

         // Try to connect HOST, return if fails

         //

@@ -1608,7 +1952,7 @@ InterruptProcess (
       //

       // Stepping is finished, send Ack package.

       //

-      if (MultiProcessorDebugSupport) {

+      if (MultiProcessorDebugSupport()) {

         mDebugMpContext.BreakAtCpuIndex = ProcessorIndex;

       }

       SendAckPacket (DEBUG_COMMAND_OK);

@@ -1619,7 +1963,7 @@ InterruptProcess (
       //

       // Memory is ready

       //

-      SendCommandAndWaitForAckOK (DEBUG_COMMAND_MEMORY_READY, 0, &BreakReceived, NULL);

+      SendCommandAndWaitForAckOK (DEBUG_COMMAND_MEMORY_READY, READ_PACKET_TIMEOUT, &BreakReceived, NULL);

       CommandCommunication (Vector, CpuContext, BreakReceived);

       break;

 

@@ -1647,14 +1991,14 @@ InterruptProcess (
       //

       // Send Break packet to HOST

       //

-      AcquireDebugPortControl ();

+      AcquireMpSpinLock (&mDebugMpContext.DebugPortSpinLock);

       //

       // Only the first breaking processor could send BREAK_POINT to HOST

       // 

       if (IsFirstBreakProcessor (ProcessorIndex)) {

-        SendBreakPacketToHost (ProcessorIndex, &BreakReceived);

+        SendBreakPacketToHost (BreakCause, ProcessorIndex, &BreakReceived);

       }

-      ReleaseDebugPortControl ();

+      ReleaseMpSpinLock (&mDebugMpContext.DebugPortSpinLock);

       

       if (Vector == DEBUG_INT3_VECTOR) {

         //

@@ -1681,9 +2025,9 @@ InterruptProcess (
 

   case DEBUG_TIMER_VECTOR:

 

-    AcquireDebugPortControl ();

+    AcquireMpSpinLock (&mDebugMpContext.DebugPortSpinLock);

 

-    if (MultiProcessorDebugSupport) {

+    if (MultiProcessorDebugSupport()) {

       if (IsBsp (ProcessorIndex)) {

         //

         // If current processor is BSP, check Apic timer's init count if changed,

@@ -1697,7 +2041,7 @@ InterruptProcess (
       }

 

       if (!IsBsp (ProcessorIndex) || mDebugMpContext.IpiSentByAp) {

-        ReleaseDebugPortControl ();

+        ReleaseMpSpinLock (&mDebugMpContext.DebugPortSpinLock);

         //

         // If current processor is not BSP or this is one IPI sent by AP

         //

@@ -1725,8 +2069,10 @@ InterruptProcess (
       if (DebugReadBreakSymbol (Handle, &InputCharacter) == EFI_NOT_FOUND) {

         break;

       }

+

       if ((!IsHostAttached () && (InputCharacter == DEBUG_STARTING_SYMBOL_ATTACH)) ||

-          (IsHostAttached () && (InputCharacter == DEBUG_STARTING_SYMBOL_BREAK))

+          (IsHostAttached () && (InputCharacter == DEBUG_COMMAND_HALT)) ||

+          (IsHostAttached () && (InputCharacter == DEBUG_COMMAND_GO))

          ) {

         DebugAgentMsgPrint (DEBUG_AGENT_VERBOSE, "Received data [%02x]\n", InputCharacter);

         //

@@ -1734,25 +2080,32 @@ InterruptProcess (
         //

         SendAckPacket (DEBUG_COMMAND_OK);

 

+        //

+        // If receive GO command in Debug Timer, means HOST may lost ACK packet before.

+        //

+        if (InputCharacter == DEBUG_COMMAND_GO) {

+          break;

+        }

+

         if (!IsHostAttached ()) {

           //

           // Try to attach HOST, if no ack received after 200ms, return

           //

-          if (AttachHost (INIT_BREAK_ACK_TIMEOUT, &BreakReceived) != RETURN_SUCCESS) {

+          if (AttachHost (BreakCause, READ_PACKET_TIMEOUT, &BreakReceived) != RETURN_SUCCESS) {

             break;

           }

         }

 

-        if (MultiProcessorDebugSupport) {

+        if (MultiProcessorDebugSupport()) {

           if(FindNextPendingBreakCpu  () != -1) {

             SetCpuBreakFlagByIndex (ProcessorIndex, TRUE);

           } else {

             HaltOtherProcessors (ProcessorIndex);

           }

         }

-        ReleaseDebugPortControl ();

+        ReleaseMpSpinLock (&mDebugMpContext.DebugPortSpinLock);

         CommandCommunication (Vector, CpuContext, BreakReceived);

-        AcquireDebugPortControl ();

+        AcquireMpSpinLock (&mDebugMpContext.DebugPortSpinLock);

         break;

       }

     }

@@ -1762,19 +2115,17 @@ InterruptProcess (
     //

     SendApicEoi ();

 

-    ReleaseDebugPortControl ();

+    ReleaseMpSpinLock (&mDebugMpContext.DebugPortSpinLock);

 

     break;

 

   default:

-

     if (Vector <= DEBUG_EXCEPT_SIMD) {

-      BreakCause = GetBreakCause (Vector, CpuContext);

       if (BreakCause == DEBUG_DATA_BREAK_CAUSE_STEPPING) {

         //

         // Stepping is finished, send Ack package.

         //

-        if (MultiProcessorDebugSupport) {

+        if (MultiProcessorDebugSupport()) {

           mDebugMpContext.BreakAtCpuIndex = ProcessorIndex;

         }

         SendAckPacket (DEBUG_COMMAND_OK);

@@ -1782,14 +2133,14 @@ InterruptProcess (
         //

         // Exception occurs, send Break packet to HOST

         //

-        AcquireDebugPortControl ();

+        AcquireMpSpinLock (&mDebugMpContext.DebugPortSpinLock);

         //

         // Only the first breaking processor could send BREAK_POINT to HOST

         // 

         if (IsFirstBreakProcessor (ProcessorIndex)) {

-          SendBreakPacketToHost (ProcessorIndex, &BreakReceived);

+          SendBreakPacketToHost (BreakCause, ProcessorIndex, &BreakReceived);

         }

-        ReleaseDebugPortControl ();

+        ReleaseMpSpinLock (&mDebugMpContext.DebugPortSpinLock);

       }

       

       CommandCommunication (Vector, CpuContext, BreakReceived);

@@ -1797,7 +2148,7 @@ InterruptProcess (
     break;

   }

 

-  if (MultiProcessorDebugSupport) {

+  if (MultiProcessorDebugSupport()) {

     //

     // Clear flag and wait for all processors run here

     //

@@ -1814,11 +2165,11 @@ InterruptProcess (
     }

   }

 

-  if (IssuedViewPoint == ProcessorIndex) {

+  if (IssuedViewPoint == ProcessorIndex && GetDebugFlag (DEBUG_AGENT_FLAG_STEPPING) != 1) {

     //

-    // Clean up AgentInProgress flag

+    // If the command is not stepping, clean up AgentInProgress flag

     //

-    GetMailboxPointer()->DebugFlag.AgentInProgress = 0;

+    SetDebugFlag (DEBUG_AGENT_FLAG_AGENT_IN_PROGRESS, 0);

   }

 

   return;

diff --git a/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/DebugAgent.h b/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/DebugAgent.h
index 61448448..5eb50d03 100644
--- a/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/DebugAgent.h
+++ b/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/DebugAgent.h
@@ -1,7 +1,7 @@
 /** @file

   Command header of for Debug Agent library instance.

 

-  Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -32,6 +32,8 @@
 #include <Library/DebugLib.h>

 #include <Library/TimerLib.h>

 #include <Library/PrintLib.h>

+#include <Library/PeCoffGetEntryPointLib.h>

+#include <Library/PeCoffExtraActionLib.h>

 

 #include <TransferProtocol.h>

 #include <ImageDebugSupport.h>

@@ -40,11 +42,24 @@
 #include "DebugTimer.h"

 #include "ArchDebugSupport.h"

 

+//

+// These macros may be already defined in DebugAgentLib.h

+//

+#define DEBUG_AGENT_INIT_PEI                     9

+#define DEBUG_AGENT_INIT_DXE_LOAD               10

+#define DEBUG_AGENT_INIT_DXE_UNLOAD             11

+#define DEBUG_AGENT_INIT_THUNK_PEI_IA32TOX64    12

+

 #define DEBUG_INT1_VECTOR               1

 #define DEBUG_INT3_VECTOR               3

 #define DEBUG_TIMER_VECTOR              32

 #define DEBUG_MAILBOX_VECTOR            33

 

+//

+//  Timeout value for reading packet (unit is microsecond)

+//

+#define READ_PACKET_TIMEOUT     (500 * 1000)

+

 #define SOFT_INTERRUPT_SIGNATURE    SIGNATURE_32('S','O','F','T')

 #define SYSTEM_RESET_SIGNATURE      SIGNATURE_32('S','Y','S','R')

 #define MEMORY_READY_SIGNATURE      SIGNATURE_32('M','E','M','R')

@@ -53,6 +68,8 @@ extern UINTN  Exception0Handle;
 extern UINTN  TimerInterruptHandle;

 extern UINT16 ExceptionStubHeaderSize;

 

+extern BOOLEAN mSkipBreakpoint;

+

 //

 // CPU exception information issued by debug agent

 //

@@ -67,23 +84,44 @@ typedef struct {
   DEBUG_DATA_RESPONSE_GET_EXCEPTION   ExceptionContent;

 } DEBUG_AGENT_EXCEPTION_BUFFER;

 

-#pragma pack(1)

-typedef struct {

-  //

-  // Lower 32 bits to store the status of DebugAgent

-  //

-  UINT32  HostAttached    : 1;   // 1: HOST is attached

-  UINT32  AgentInProgress : 1;   // 1: Debug Agent is communicating with HOST

-  UINT32  MemoryReady     : 1;   // 1: Memory is ready

-  UINT32  SteppingFlag    : 1;   // 1: Agent is running stepping command

-  UINT32  Reserved1       : 28;

+#define DEBUG_AGENT_FLAG_HOST_ATTACHED         BIT0

+#define DEBUG_AGENT_FLAG_AGENT_IN_PROGRESS     BIT1

+#define DEBUG_AGENT_FLAG_MEMORY_READY          BIT2

+#define DEBUG_AGENT_FLAG_STEPPING              BIT3

+#define DEBUG_AGENT_FLAG_CHECK_MAILBOX_IN_HOB  BIT4

+#define DEBUG_AGENT_FLAG_BREAK_ON_NEXT_SMI     BIT32

+#define DEBUG_AGENT_FLAG_PRINT_ERROR_LEVEL     (BIT33|BIT34|BIT35|BIT36)

+#define DEBUG_AGENT_FLAG_BREAK_BOOT_SCRIPT     BIT37

+

+#define DEBUG_MAILBOX_DEBUG_FLAG_INDEX                1

+#define DEBUG_MAILBOX_DEBUG_PORT_HANDLE_INDEX         2

+#define DEBUG_MAILBOX_EXCEPTION_BUFFER_POINTER_INDEX  3

+#define DEBUG_MAILBOX_LAST_ACK                        4

+#define DEBUG_MAILBOX_SEQUENCE_NO_INDEX               5

+#define DEBUG_MAILBOX_HOST_SEQUENCE_NO_INDEX          6

 

-  //

-  // Higher 32bits to control the behavior of DebugAgent

-  //

-  UINT32  BreakOnNextSmi  : 1;   // 1: Break on next SMI

-  UINT32  PrintErrorLevel : 8;   // Bitmask of print error level for debug message

-  UINT32  Reserved2       : 23;

+#pragma pack(1)

+typedef union {

+  struct {

+    //

+    // Lower 32 bits to store the status of DebugAgent

+    //

+    UINT32  HostAttached      : 1;   // 1: HOST is attached

+    UINT32  AgentInProgress   : 1;   // 1: Debug Agent is communicating with HOST

+    UINT32  MemoryReady       : 1;   // 1: Memory is ready

+    UINT32  SteppingFlag      : 1;   // 1: Agent is running stepping command

+    UINT32  CheckMailboxInHob : 1;   // 1: Need to check mailbox saved in HOB

+    UINT32  SendingPacket     : 1;   // 1: TARGET is sending debug packet to HOST

+    UINT32  Reserved1         : 26;

+    //

+    // Higher 32bits to control the behavior of DebugAgent

+    //

+    UINT32  BreakOnNextSmi    : 1;   // 1: Break on next SMI

+    UINT32  PrintErrorLevel   : 4;   // Bitmask of print error level for debug message

+    UINT32  BreakOnBootScript : 1;   // 1: Break before executing boot script 

+    UINT32  Reserved2         : 26;

+  } Bits;

+  UINT64  Uint64;

 } DEBUG_AGENT_FLAG;

 

 typedef struct {

@@ -93,9 +131,29 @@ typedef struct {
   // Pointer to DEBUG_AGENT_EXCEPTION_BUFFER

   //

   UINT64                     ExceptionBufferPointer;

+  UINT8                      LastAck;      // The last ack packet type

+  UINT8                      SequenceNo;

+  UINT8                      HostSequenceNo;

+  UINT8                      CheckSum;     // Mailbox checksum

+  UINT8                      ToBeCheckSum; // To be Mailbox checksum at the next

 } DEBUG_AGENT_MAILBOX;

 #pragma pack()

 

+///

+/// Byte packed structure for an IA-32 Interrupt Gate Descriptor.

+///

+typedef union {

+  struct {

+    UINT32  OffsetLow:16;   ///< Offset bits 15..0.

+    UINT32  Selector:16;    ///< Selector.

+    UINT32  Reserved_0:8;   ///< Reserved.

+    UINT32  GateType:8;     ///< Gate Type.  See #defines above.

+    UINT32  OffsetHigh:16;  ///< Offset bits 31..16.

+  } Bits;

+  UINT64  Uint64;

+} IA32_IDT_ENTRY;

+

+

 typedef union {

   struct {

     UINT32  LimitLow    : 16;

@@ -116,22 +174,6 @@ typedef union {
 } IA32_GDT;

 

 /**

-  Caller provided function to be invoked at the end of DebugPortInitialize().

-

-  Refer to the descrption for DebugPortInitialize() for more details.

-

-  @param[in] Context           The first input argument of DebugPortInitialize().

-  @param[in] DebugPortHandle   Debug port handle created by Debug Communication Libary.

-

-**/

-VOID

-EFIAPI

-InitializeDebugAgentPhase2 (

-  IN VOID                  *Context,

-  IN DEBUG_PORT_HANDLE     DebugPortHandle

-  );

-

-/**

   Initialize IDT entries to support source level debug.

 

 **/

@@ -242,5 +284,184 @@ DebugAgentMsgPrint (
   IN CHAR8         *Format,

   ...

   );

+

+/**

+  Trigger one software interrupt to debug agent to handle it.

+

+  @param[in] Signature       Software interrupt signature.

+

+**/

+VOID

+TriggerSoftInterrupt (

+  IN UINT32                 Signature

+  );

+

+/**

+  Check if debug agent support multi-processor.

+

+  @retval TRUE    Multi-processor is supported.

+  @retval FALSE   Multi-processor is not supported.

+

+**/

+BOOLEAN

+MultiProcessorDebugSupport (

+  VOID

+  );

+

+/**

+  Find and report module image info to HOST.

+  

+  @param[in] AlignSize      Image aligned size.

+  

+**/

+VOID 

+FindAndReportModuleImageInfo (

+  IN UINTN          AlignSize                   

+  );

+

+/**

+  Read IDT entry to check if IDT entries are setup by Debug Agent.

+

+  @retval  TRUE     IDT entries were setup by Debug Agent.

+  @retval  FALSE    IDT entries were not setup by Debug Agent.

+

+**/

+BOOLEAN 

+IsDebugAgentInitialzed (

+  VOID

+  );

+

+/**

+  Caculate Mailbox checksum and update the checksum field.

+

+  @param[in]  Mailbox  Debug Agent Mailbox pointer.

+

+**/

+VOID

+UpdateMailboxChecksum (

+  IN DEBUG_AGENT_MAILBOX    *Mailbox

+  );

+

+/**

+  Verify Mailbox checksum.

+

+  If checksum error, print debug message and run init dead loop.

+

+  @param[in]  Mailbox  Debug Agent Mailbox pointer.

+

+**/

+VOID 

+VerifyMailboxChecksum (

+  IN DEBUG_AGENT_MAILBOX    *Mailbox

+  );

+

+/**

+  Set debug flag in mailbox.

+

+  @param[in]  FlagMask      Debug flag mask value.

+  @param[in]  FlagValue     Debug flag value.

+

+**/

+VOID 

+SetDebugFlag (

+  IN UINT64                 FlagMask,

+  IN UINT32                 FlagValue                          

+  );

+

+/**

+  Get debug flag in mailbox.

+

+  @param[in]  FlagMask      Debug flag mask value.

+  

+  @return Debug flag value.

+

+**/

+UINT32

+GetDebugFlag (

+  IN UINT64                 FlagMask

+  );

+

+/**

+  Update Mailbox content by index.

+

+  @param[in]  Mailbox  Debug Agent Mailbox pointer.

+  @param[in]  Index    Mailbox content index.

+  @param[in]  Value    Value to be set into mail box.

+  

+**/

+VOID

+UpdateMailboxContent ( 

+  IN DEBUG_AGENT_MAILBOX    *Mailbox,

+  IN UINTN                  Index,

+  IN UINT64                 Value

+  );

+

+/**

+  Retrieve exception handler from IDT table by ExceptionNum.

+

+  @param[in]  ExceptionNum    Exception number

+ 

+  @return Exception handler

+

+**/

+VOID *

+GetExceptionHandlerInIdtEntry (

+  IN UINTN             ExceptionNum

+  );

+

+/**

+  Set exception handler in IDT table by ExceptionNum.

+

+  @param[in]  ExceptionNum      Exception number

+  @param[in]  ExceptionHandler  Exception Handler to be set 

+

+**/

+VOID

+SetExceptionHandlerInIdtEntry (

+  IN UINTN             ExceptionNum,

+  IN VOID              *ExceptionHandler

+  );

+

+/**

+  Prints a debug message to the debug output device if the specified error level is enabled.

+

+  If any bit in ErrorLevel is also set in DebugPrintErrorLevelLib function 

+  GetDebugPrintErrorLevel (), then print the message specified by Format and the 

+  associated variable argument list to the debug output device.

+

+  If Format is NULL, then ASSERT().

+

+  @param[in] ErrorLevel  The error level of the debug message.

+  @param[in] IsSend      Flag of debug message to declare that the data is being sent or being received.

+  @param[in] Data        Variable argument list whose contents are accessed 

+  @param[in] Length      based on the format string specified by Format.

+

+**/

+VOID

+EFIAPI

+DebugAgentDataMsgPrint (

+  IN UINT8             ErrorLevel,

+  IN BOOLEAN           IsSend,

+  IN UINT8             *Data,

+  IN UINT8             Length  

+  );

+

+/**

+  Read remaing debug packet except for the start symbol

+

+  @param[in]      Handle        Pointer to Debug Port handle.

+  @param[in, out] DebugHeader   Debug header buffer including start symbol.

+

+  @retval EFI_SUCCESS        Read the symbol in BreakSymbol.

+  @retval EFI_CRC_ERROR      CRC check fail.

+  @retval EFI_TIMEOUT        Timeout occurs when reading debug packet.

+

+**/

+EFI_STATUS

+ReadRemainingBreakPacket (

+  IN     DEBUG_PORT_HANDLE      Handle,

+  IN OUT DEBUG_PACKET_HEADER    *DebugHeader

+  );

+

 #endif

 

diff --git a/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/DebugMp.c b/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/DebugMp.c
index d7df6ad2..6c729986 100644
--- a/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/DebugMp.c
+++ b/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/DebugMp.c
@@ -1,7 +1,7 @@
 /** @file

   Multi-Processor support functions implementation.

 

-  Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -14,27 +14,30 @@
 

 #include "DebugAgent.h"

 

-DEBUG_MP_CONTEXT volatile  mDebugMpContext = {0,0,{0},{0},0,0,0,0,FALSE,FALSE};

+DEBUG_MP_CONTEXT volatile  mDebugMpContext = {0,0,0,{0},{0},0,0,0,0,FALSE,FALSE};

 

 DEBUG_CPU_DATA volatile  mDebugCpuData = {0};

 

 /**

-  Acquire access control on debug port.

+  Acquire a spin lock when Multi-processor supported.

 

   It will block in the function if cannot get the access control.

+  If Multi-processor is not supported, return directly.

+

+  @param[in, out] MpSpinLock      A pointer to the spin lock.

 

 **/

 VOID

-AcquireDebugPortControl (

-  VOID

+AcquireMpSpinLock (

+  IN OUT SPIN_LOCK           *MpSpinLock

   )

 {

-  if (!MultiProcessorDebugSupport) {

+  if (!MultiProcessorDebugSupport()) {

     return;

   }

 

   while (TRUE) {

-    if (AcquireSpinLockOrFail (&mDebugMpContext.DebugPortSpinLock)) {

+    if (AcquireSpinLockOrFail (MpSpinLock)) {

       break;

     }

     CpuPause ();

@@ -43,51 +46,21 @@ AcquireDebugPortControl (
 }

 

 /**

-  Release access control on debug port.

-

-**/

-VOID

-ReleaseDebugPortControl (

-  VOID

-  )

-{

-  if (!MultiProcessorDebugSupport) {

-    return;

-  }

-

-  ReleaseSpinLock (&mDebugMpContext.DebugPortSpinLock);

-}

-

-/**

-  Acquire access control on MP context.

+  Release a spin lock when Multi-processor supported.

 

-  It will block in the function if cannot get the access control.

+  @param[in, out] MpSpinLock      A pointer to the spin lock.

 

 **/

 VOID

-AcquireMpContextControl (

-  VOID

+ReleaseMpSpinLock (

+  IN OUT SPIN_LOCK           *MpSpinLock

   )

 {

-  while (TRUE) {

-    if (AcquireSpinLockOrFail (&mDebugMpContext.MpContextSpinLock)) {

-      break;

-    }

-    CpuPause ();

-    continue;

+  if (!MultiProcessorDebugSupport()) {

+    return;

   }

-}

 

-/**

-  Release access control on MP context.

-

-**/

-VOID

-ReleaseMpContextControl (

-  VOID

-  )

-{

-  ReleaseSpinLock (&mDebugMpContext.MpContextSpinLock);

+  ReleaseSpinLock (MpSpinLock);

 }

 

 /**

@@ -136,7 +109,7 @@ GetProcessorIndex (
 

   LocalApicID = (UINT16) GetApicId ();

 

-  AcquireMpContextControl ();

+  AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock);

 

   for (Index = 0; Index < mDebugCpuData.CpuCount; Index ++) {

     if (mDebugCpuData.ApicID[Index] == LocalApicID) {

@@ -149,7 +122,7 @@ GetProcessorIndex (
     mDebugCpuData.CpuCount ++ ;

   }

 

-  ReleaseMpContextControl ();

+  ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock);

 

   return Index;

 }

@@ -170,9 +143,9 @@ IsBsp (
 {

   if (AsmMsrBitFieldRead64 (MSR_IA32_APIC_BASE_ADDRESS, 8, 8) == 1) {

     if (mDebugMpContext.BspIndex != ProcessorIndex) {

-      AcquireMpContextControl ();

+      AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock);

       mDebugMpContext.BspIndex = ProcessorIndex;

-      ReleaseMpContextControl ();

+      ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock);

     }

     return TRUE;

   } else {

@@ -197,7 +170,7 @@ SetCpuStopFlagByIndex (
   UINT8                 Value;

   UINTN                 Index;

 

-  AcquireMpContextControl ();

+  AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock);

 

   Value = mDebugMpContext.CpuStopStatusMask[ProcessorIndex / 8];

   Index = ProcessorIndex % 8;

@@ -208,7 +181,7 @@ SetCpuStopFlagByIndex (
   }

   mDebugMpContext.CpuStopStatusMask[ProcessorIndex / 8] = Value;

 

-  ReleaseMpContextControl ();

+  ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock);

 }

 

 /**

@@ -228,7 +201,7 @@ SetCpuBreakFlagByIndex (
   UINT8                 Value;

   UINTN                 Index;

 

-  AcquireMpContextControl ();

+  AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock);

 

   Value = mDebugMpContext.CpuBreakMask[ProcessorIndex / 8];

   Index = ProcessorIndex % 8;

@@ -239,7 +212,7 @@ SetCpuBreakFlagByIndex (
   }

   mDebugMpContext.CpuBreakMask[ProcessorIndex / 8] = Value;

 

-  ReleaseMpContextControl ();

+  ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock);

 }

 

 /**

@@ -279,11 +252,9 @@ SetCpuRunningFlag (
   IN BOOLEAN            RunningFlag

   )

 {

-  AcquireMpContextControl ();

-

+  AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock);

   mDebugMpContext.RunCommandSet = RunningFlag;

-

-  ReleaseMpContextControl ();

+  ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock);

 }

 

 /**

@@ -297,11 +268,9 @@ SetDebugViewPoint (
   IN UINT32             ProcessorIndex

   )

 {

-  AcquireMpContextControl ();

-

+  AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock);

   mDebugMpContext.ViewPointIndex = ProcessorIndex;

-

-  ReleaseMpContextControl ();

+  ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock);

 }

 

 /**

@@ -316,11 +285,9 @@ SetIpiSentByApFlag (
   IN BOOLEAN            IpiSentByApFlag

   )

 {

-  AcquireMpContextControl ();

-

+  AcquireMpSpinLock (&mDebugMpContext.MpContextSpinLock);

   mDebugMpContext.IpiSentByAp = IpiSentByApFlag;

-

-  ReleaseMpContextControl ();

+  ReleaseMpSpinLock (&mDebugMpContext.MpContextSpinLock);

 }

 

 /**

@@ -384,7 +351,7 @@ IsFirstBreakProcessor (
   IN UINT32              ProcessorIndex

   )

 {

-  if (MultiProcessorDebugSupport) {

+  if (MultiProcessorDebugSupport()) {

     if (mDebugMpContext.BreakAtCpuIndex != (UINT32) -1) {

       //

       // The current processor is not the first breaking one.

diff --git a/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/DebugMp.h b/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/DebugMp.h
index 183887cc..5bb50960 100644
--- a/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/DebugMp.h
+++ b/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/DebugMp.h
@@ -1,7 +1,7 @@
 /** @file

   Header file for Multi-Processor support.

 

-  Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -25,6 +25,7 @@ typedef struct {
 typedef struct {

   SPIN_LOCK                 MpContextSpinLock;   ///< Lock for writting MP context

   SPIN_LOCK                 DebugPortSpinLock;   ///< Lock for access debug port

+  SPIN_LOCK                 MailboxSpinLock;     ///< Lock for accessing mail box

   UINT8                     CpuBreakMask[DEBUG_CPU_MAX_COUNT/8];        ///< Bitmask of all breaking CPUs

   UINT8                     CpuStopStatusMask[DEBUG_CPU_MAX_COUNT/8];   ///< Bitmask of CPU stop status

   UINT32                    ViewPointIndex;      ///< Current view point to be debugged

@@ -35,7 +36,6 @@ typedef struct {
   BOOLEAN                   RunCommandSet;       ///< TRUE: RUN commmand is executing. FALSE : RUN command has been executed.

 } DEBUG_MP_CONTEXT;

 

-extern CONST BOOLEAN               MultiProcessorDebugSupport;

 extern DEBUG_MP_CONTEXT volatile   mDebugMpContext;

 extern DEBUG_CPU_DATA   volatile   mDebugCpuData;

 

@@ -62,43 +62,28 @@ GetProcessorIndex (
   );

 

 /**

-  Acquire access control on MP context.

+  Acquire a spin lock when Multi-processor supported.

 

   It will block in the function if cannot get the access control.

+  If Multi-processor is not supported, return directly.

 

-**/

-VOID

-AcquireMpContextControl (

-  VOID

-  );

-

-/**

-  Release access control on MP context.

+  @param[in, out] MpSpinLock      A pointer to the spin lock.

 

 **/

 VOID

-ReleaseMpContextControl (

-  VOID

+AcquireMpSpinLock (

+  IN OUT SPIN_LOCK           *MpSpinLock

   );

 

 /**

-  Acquire access control on debug port.

-

-  It will block in the function if cannot get the access control.

-

-**/

-VOID

-AcquireDebugPortControl (

-  VOID

-  );

+  Release a spin lock when Multi-processor supported.

 

-/**

-  Release access control on debug port.

+  @param[in, out] MpSpinLock      A pointer to the spin lock.

 

 **/

 VOID

-ReleaseDebugPortControl (

-  VOID

+ReleaseMpSpinLock (

+  IN OUT SPIN_LOCK           *MpSpinLock

   );

 

 /**

diff --git a/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/DebugTimer.c b/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/DebugTimer.c
index d473df86..01fc4841 100644
--- a/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/DebugTimer.c
+++ b/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/DebugTimer.c
@@ -1,7 +1,7 @@
 /** @file

   Code for debug timer to support debug agent library implementation.

 

-  Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -41,7 +41,7 @@ InitializeDebugTimer (
 

   InitializeApicTimer (ApicTimerDivisor, InitialCount, TRUE, DEBUG_TIMER_VECTOR);

 

-  if (MultiProcessorDebugSupport) {

+  if (MultiProcessorDebugSupport()) {

     mDebugMpContext.DebugTimerInitCount = InitialCount;

   }

 }

@@ -65,19 +65,26 @@ SaveAndSetDebugTimerInterrupt (
   IN BOOLEAN                EnableStatus

   )

 {

-  BOOLEAN     OldInterruptState;

   BOOLEAN     OldDebugTimerInterruptState;

 

-  OldInterruptState = SaveAndDisableInterrupts ();

   OldDebugTimerInterruptState = GetApicTimerInterruptState ();

   

-  if (EnableStatus) {

-    EnableApicTimerInterrupt ();

-  } else {

-    DisableApicTimerInterrupt ();

+  if (OldDebugTimerInterruptState != EnableStatus) {

+    if (EnableStatus) {

+      EnableApicTimerInterrupt ();

+    } else {

+      DisableApicTimerInterrupt ();

+    }

+    //

+    // Validate the Debug Timer interrupt state

+    // This will make additional delay after Local Apic Timer interrupt state is changed.

+    // Thus, CPU could handle the potential pending interrupt of Local Apic timer.

+    //

+    while (GetApicTimerInterruptState () != EnableStatus) {

+      CpuPause ();

+    }

   }

-

-  SetInterruptState (OldInterruptState);

+  

   return OldDebugTimerInterruptState;

 }

 

diff --git a/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/Ia32/ArchDebugSupport.c b/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/Ia32/ArchDebugSupport.c
index 52ed647a..9bd8fca6 100644
--- a/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/Ia32/ArchDebugSupport.c
+++ b/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/Ia32/ArchDebugSupport.c
@@ -1,7 +1,7 @@
 /** @file

   Supporting functions for IA32 architecture.

 

-  Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -39,17 +39,17 @@ InitializeDebugIdt (
   IdtEntry = (IA32_IDT_GATE_DESCRIPTOR *) IdtDescriptor.Base;

 

   for (Index = 0; Index < 20; Index ++) {

-    if ((PcdGet32 (PcdExceptionsIgnoredByDebugger) & (1 << Index)) != 0) {

+    if (((PcdGet32 (PcdExceptionsIgnoredByDebugger) & ~(BIT1 | BIT3)) & (1 << Index)) != 0) {

       //

-      // If the exception is masked to be reserved, skip it

+      // If the exception is masked to be reserved except for INT1 and INT3, skip it

       //

       continue;

     }

     InterruptHandler = (UINTN)&Exception0Handle + Index * ExceptionStubHeaderSize;

     IdtEntry[Index].Bits.OffsetLow  = (UINT16)(UINTN)InterruptHandler;

     IdtEntry[Index].Bits.OffsetHigh = (UINT16)((UINTN)InterruptHandler >> 16);

-    IdtEntry[Index].Bits.Selector        = CodeSegment;

-    IdtEntry[Index].Bits.GateType        = IA32_IDT_GATE_TYPE_INTERRUPT_32;

+    IdtEntry[Index].Bits.Selector   = CodeSegment;

+    IdtEntry[Index].Bits.GateType   = IA32_IDT_GATE_TYPE_INTERRUPT_32;

   }

 

   InterruptHandler = (UINTN) &TimerInterruptHandle;

@@ -63,3 +63,49 @@ InitializeDebugIdt (
   //

   AsmWriteCr4 (AsmReadCr4 () | BIT3);

 }

+

+/**

+  Retrieve exception handler from IDT table by ExceptionNum.

+

+  @param[in]  ExceptionNum    Exception number

+ 

+  @return Exception handler

+

+**/

+VOID *

+GetExceptionHandlerInIdtEntry (

+  IN UINTN             ExceptionNum

+  )

+{

+  IA32_IDT_GATE_DESCRIPTOR   *IdtEntry;

+  IA32_DESCRIPTOR            IdtDescriptor;

+

+  AsmReadIdtr (&IdtDescriptor);

+  IdtEntry = (IA32_IDT_GATE_DESCRIPTOR *) IdtDescriptor.Base;

+

+  return (VOID *) (((UINTN)IdtEntry[ExceptionNum].Bits.OffsetLow) |

+                  (((UINTN)IdtEntry[ExceptionNum].Bits.OffsetHigh) << 16));

+} 

+

+/**

+  Set exception handler in IDT table by ExceptionNum.

+

+  @param[in]  ExceptionNum      Exception number

+  @param[in]  ExceptionHandler  Exception Handler to be set 

+

+**/

+VOID

+SetExceptionHandlerInIdtEntry (

+  IN UINTN             ExceptionNum,

+  IN VOID              *ExceptionHandler

+  )

+{

+  IA32_IDT_GATE_DESCRIPTOR   *IdtEntry;

+  IA32_DESCRIPTOR            IdtDescriptor;

+

+  AsmReadIdtr (&IdtDescriptor);

+  IdtEntry = (IA32_IDT_GATE_DESCRIPTOR *) IdtDescriptor.Base;

+

+  IdtEntry[ExceptionNum].Bits.OffsetLow   = (UINT16)(UINTN)ExceptionHandler;

+  IdtEntry[ExceptionNum].Bits.OffsetHigh  = (UINT16)((UINTN)ExceptionHandler >> 16);

+}

diff --git a/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/Ia32/AsmFuncs.S b/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/Ia32/AsmFuncs.S
index cfeeea04..e05317aa 100644
--- a/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/Ia32/AsmFuncs.S
+++ b/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/Ia32/AsmFuncs.S
@@ -1,6 +1,6 @@
 #------------------------------------------------------------------------------

 #

-# Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>

+# Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

 # This program and the accompanying materials

 # are licensed and made available under the terms and conditions of the BSD License

 # which accompanies this distribution.  The full text of the license may be found at

@@ -33,6 +33,7 @@ ASM_PFX(ExceptionStubHeaderSize):  .word     ASM_PFX(Exception1Handle) - ASM_PFX
 

 .text

 

+.byte 0x41, 0x47, 0x54, 0x48  # AGENT_HANDLER_SIGNATURE     SIGNATURE_32('A','G','T','H')

 ASM_PFX(Exception0Handle):

    cli

    pushl %eax

@@ -259,7 +260,7 @@ NoExtrPush:
   pushl   %eax

 ## clear Dr7 while executing debugger itself

   xorl    %eax,%eax

-#  movl    %eax, %dr7

+  movl    %eax, %dr7

 

   movl    %dr6, %eax

   pushl   %eax

diff --git a/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/Ia32/AsmFuncs.asm b/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/Ia32/AsmFuncs.asm
index 6f3b3bc3..c80a33ba 100644
--- a/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/Ia32/AsmFuncs.asm
+++ b/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/Ia32/AsmFuncs.asm
@@ -1,6 +1,6 @@
 ;------------------------------------------------------------------------------

 ;

-; Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>

+; Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

 ; This program and the accompanying materials

 ; are licensed and made available under the terms and conditions of the BSD License

 ; which accompanies this distribution.  The full text of the license may be found at

@@ -39,6 +39,7 @@ CommonEntryAddr           DD    CommonEntry
 

 .code

 

+db   41h, 47h, 54h, 48h  ; AGENT_HANDLER_SIGNATURE     SIGNATURE_32('A','G','T','H')

 Exception0Handle:

     cli

     push    eax

@@ -259,7 +260,7 @@ NoExtrPush:
 

     ;; clear Dr7 while executing debugger itself

     xor     eax, eax

- ;; mov     dr7, eax

+    mov     dr7, eax

 

     ;; Dr6

     mov     eax, dr6

diff --git a/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/X64/ArchDebugSupport.c b/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/X64/ArchDebugSupport.c
index 9803f0f7..60d3eb8b 100644
--- a/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/X64/ArchDebugSupport.c
+++ b/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/X64/ArchDebugSupport.c
@@ -1,7 +1,7 @@
 /** @file

   Supporting functions for X64 architecture.

 

-  Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -39,9 +39,9 @@ InitializeDebugIdt (
   IdtEntry = (IA32_IDT_GATE_DESCRIPTOR *) IdtDescriptor.Base;

 

   for (Index = 0; Index < 20; Index ++) {

-    if ((PcdGet32 (PcdExceptionsIgnoredByDebugger) & (1 << Index)) != 0) {

+    if (((PcdGet32 (PcdExceptionsIgnoredByDebugger) & ~(BIT1 | BIT3)) & (1 << Index)) != 0) {

       //

-      // If the exception is masked to be reserved, skip it

+      // If the exception is masked to be reserved except for INT1 and INT3, skip it

       //

       continue;

     }

@@ -65,3 +65,51 @@ InitializeDebugIdt (
   //

   AsmWriteCr4 (AsmReadCr4 () | BIT3);

 }

+

+/**

+  Retrieve exception handler from IDT table by ExceptionNum.

+

+  @param[in]  ExceptionNum    Exception number

+ 

+  @return Exception handler

+

+**/

+VOID *

+GetExceptionHandlerInIdtEntry (

+  IN UINTN             ExceptionNum

+  )

+{

+  IA32_IDT_GATE_DESCRIPTOR   *IdtEntry;

+  IA32_DESCRIPTOR            IdtDescriptor;

+

+  AsmReadIdtr (&IdtDescriptor);

+  IdtEntry = (IA32_IDT_GATE_DESCRIPTOR *) IdtDescriptor.Base;

+

+  return (VOID *) (IdtEntry[ExceptionNum].Bits.OffsetLow |

+                  (((UINTN)IdtEntry[ExceptionNum].Bits.OffsetHigh) << 16) |

+                  (((UINTN)IdtEntry[ExceptionNum].Bits.OffsetUpper) << 32));

+} 

+

+/**

+  Set exception handler in IDT table by ExceptionNum.

+

+  @param[in]  ExceptionNum      Exception number

+  @param[in]  ExceptionHandler  Exception Handler to be set 

+

+**/

+VOID

+SetExceptionHandlerInIdtEntry (

+  IN UINTN             ExceptionNum,

+  IN VOID              *ExceptionHandler

+  )

+{

+  IA32_IDT_GATE_DESCRIPTOR   *IdtEntry;

+  IA32_DESCRIPTOR            IdtDescriptor;

+

+  AsmReadIdtr (&IdtDescriptor);

+  IdtEntry = (IA32_IDT_GATE_DESCRIPTOR *) IdtDescriptor.Base;

+

+  IdtEntry[ExceptionNum].Bits.OffsetLow   = (UINT16)(UINTN)ExceptionHandler;

+  IdtEntry[ExceptionNum].Bits.OffsetHigh  = (UINT16)((UINTN)ExceptionHandler >> 16);

+  IdtEntry[ExceptionNum].Bits.OffsetUpper = (UINT32)((UINTN)ExceptionHandler >> 32);

+}

diff --git a/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/X64/AsmFuncs.S b/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/X64/AsmFuncs.S
index 3de9767d..e7c3ed74 100644
--- a/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/X64/AsmFuncs.S
+++ b/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/X64/AsmFuncs.S
@@ -1,6 +1,6 @@
 #------------------------------------------------------------------------------

 #

-# Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>

+# Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

 # This program and the accompanying materials

 # are licensed and made available under the terms and conditions of the BSD License

 # which accompanies this distribution.  The full text of the license may be found at

@@ -35,6 +35,7 @@ ASM_PFX(ExceptionStubHeaderSize):  .word     ASM_PFX(Exception1Handle) - ASM_PFX
 

 .text

 

+.byte 0x41, 0x47, 0x54, 0x48  # AGENT_HANDLER_SIGNATURE     SIGNATURE_32('A','G','T','H')

 ASM_PFX(Exception0Handle):

    cli

    pushq %rcx

@@ -280,7 +281,7 @@ NoExtrPush:
   pushq   %rax

 ## clear Dr7 while executing debugger itself

    xorq    %rax, %rax

-#debug   movq    %rax, %dr7

+   movq    %rax, %dr7

 

    movq    %dr6, %rax

   pushq    %rax

diff --git a/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/X64/AsmFuncs.asm b/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/X64/AsmFuncs.asm
index 16d73a41..23abcc76 100644
--- a/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/X64/AsmFuncs.asm
+++ b/SourceLevelDebugPkg/Library/DebugAgent/DebugAgentCommon/X64/AsmFuncs.asm
@@ -1,6 +1,6 @@
 ;------------------------------------------------------------------------------

 ;

-; Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>

+; Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

 ; This program and the accompanying materials

 ; are licensed and made available under the terms and conditions of the BSD License

 ; which accompanies this distribution.  The full text of the license may be found at

@@ -33,6 +33,7 @@ CommonEntryAddr                dq      CommonEntry ;
 

 .code

 

+db   41h, 47h, 54h, 48h  ; AGENT_HANDLER_SIGNATURE     SIGNATURE_32('A','G','T','H')

 Exception0Handle:

     cli

     push    rcx

@@ -198,7 +199,7 @@ NoExtrPush:
     push    rax

     mov     rax, cr2

     push    rax

-    push    0         ; cr0 will not saved???

+    push    0

     mov     rax, cr0

     push    rax

 

diff --git a/SourceLevelDebugPkg/Library/DebugAgent/DxeDebugAgent/DxeDebugAgentLib.c b/SourceLevelDebugPkg/Library/DebugAgent/DxeDebugAgent/DxeDebugAgentLib.c
index f8e3f6c1..35c6acfd 100644
--- a/SourceLevelDebugPkg/Library/DebugAgent/DxeDebugAgent/DxeDebugAgentLib.c
+++ b/SourceLevelDebugPkg/Library/DebugAgent/DxeDebugAgent/DxeDebugAgentLib.c
@@ -1,7 +1,7 @@
 /** @file

   Debug Agent library implementition for Dxe Core and Dxr modules.

 

-  Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -15,57 +15,51 @@
 #include "DxeDebugAgentLib.h"

 

 DEBUG_AGENT_MAILBOX          mMailbox;

-DEBUG_AGENT_MAILBOX          *mMailboxPointer;

+DEBUG_AGENT_MAILBOX          *mMailboxPointer = NULL;

 IA32_IDT_GATE_DESCRIPTOR     mIdtEntryTable[33];

-BOOLEAN                      mDxeCoreFlag               = FALSE;

-CONST BOOLEAN                MultiProcessorDebugSupport = TRUE;

+BOOLEAN                      mDxeCoreFlag                = FALSE;

+BOOLEAN                      mMultiProcessorDebugSupport = FALSE;

+VOID                         *mSavedIdtTable             = NULL;

+UINTN                        mSaveIdtTableSize           = 0;

+BOOLEAN                      mDebugAgentInitialized      = FALSE;

+BOOLEAN                      mSkipBreakpoint             = FALSE;

 

 /**

-  Constructor allocates the NVS memory to store Mailbox and install configuration table

-  in system table to store its pointer.

+  Check if debug agent support multi-processor.

 

-  @param[in]  ImageHandle   The firmware allocated handle for the EFI image.

-  @param[in]  SystemTable   A pointer to the EFI System Table.

+  @retval TRUE    Multi-processor is supported.

+  @retval FALSE   Multi-processor is not supported.

+

+**/

+BOOLEAN

+MultiProcessorDebugSupport (

+  VOID

+  )

+{

+  return mMultiProcessorDebugSupport;

+}

 

-  @retval  RETURN_SUCCESS   Allocate the global memory space to store guid and function tables.

+/**

+  Internal constructor worker function.

+

+  It will register one callback function on EFI PCD Protocol.

+  It will allocate the NVS memory to store Mailbox and install configuration table

+  in system table to store its pointer.

 

 **/

-RETURN_STATUS

-EFIAPI

-DxeDebugAgentLibConstructor (

-  IN EFI_HANDLE        ImageHandle,

-  IN EFI_SYSTEM_TABLE  *SystemTable

+VOID

+InternalConstructorWorker (

+  VOID

   )

 {

   EFI_STATUS                  Status;

   EFI_PHYSICAL_ADDRESS        Address;

-  EFI_EVENT                   Event;

-  VOID                        *EventRegistration;

-

-  if (!mDxeCoreFlag) {

-    return RETURN_SUCCESS;

-  }

-

-  Status = gBS->CreateEvent (

-                  EVT_NOTIFY_SIGNAL,

-                  TPL_CALLBACK,

-                  InstallSerialIoNotification,

-                  NULL,

-                  &Event

-                  );

-  ASSERT_EFI_ERROR (Status);

+  BOOLEAN                     DebugTimerInterruptState;

 

   //

-  // Register for protocol notifications on this event

+  // Install EFI Serial IO protocol on debug port

   //

-

-  Status = gBS->RegisterProtocolNotify (

-                  &gEfiPcdProtocolGuid,

-                  Event,

-                  &EventRegistration

-                  );

-

-  ASSERT_EFI_ERROR (Status);

+  InstallSerialIo ();

 

   Address = 0;

   Status = gBS->AllocatePages (

@@ -76,18 +70,67 @@ DxeDebugAgentLibConstructor (
                   );

   ASSERT_EFI_ERROR (Status);

 

+  DebugTimerInterruptState = SaveAndSetDebugTimerInterrupt (FALSE);

   CopyMem (

     (UINT8 *) (UINTN) Address,

-    (UINT8 *) (UINTN) mMailboxPointer,

+    (UINT8 *) (UINTN) GetMailboxPointer (),

     sizeof (DEBUG_AGENT_MAILBOX)

     );

+  DebugTimerInterruptState = SaveAndSetDebugTimerInterrupt (DebugTimerInterruptState);

 

   mMailboxPointer = (DEBUG_AGENT_MAILBOX *) (UINTN) Address;

 

   Status = gBS->InstallConfigurationTable (&gEfiDebugAgentGuid, (VOID *) mMailboxPointer);

   ASSERT_EFI_ERROR (Status);

+}

+

+/**

+  Debug Agent constructor function.

+

+  @param[in]  ImageHandle   The firmware allocated handle for the EFI image.

+  @param[in]  SystemTable   A pointer to the EFI System Table.

+

+  @retval  RETURN_SUCCESS  When this function completed.

+

+**/

+RETURN_STATUS

+EFIAPI

+DxeDebugAgentLibConstructor (

+  IN EFI_HANDLE        ImageHandle,

+  IN EFI_SYSTEM_TABLE  *SystemTable

+  )

+{

+  if (mDxeCoreFlag) {

+    //

+    // Invoke internal constructor function only when DXE core links this library instance

+    //

+    InternalConstructorWorker ();

+  }

+

+  return RETURN_SUCCESS;

+}

+

+/**

+  Get the pointer to Mailbox from the configuration table.

+

+  @return Pointer to Mailbox.

+

+**/

+DEBUG_AGENT_MAILBOX *

+GetMailboxFromConfigurationTable (

+  VOID

+  )

+{

+  EFI_STATUS               Status;

+  DEBUG_AGENT_MAILBOX      *Mailbox;

   

-  return Status;

+  Status = EfiGetSystemConfigurationTable (&gEfiDebugAgentGuid, (VOID **) &Mailbox);

+  if (Status == EFI_SUCCESS && Mailbox != NULL) {

+    VerifyMailboxChecksum (Mailbox);

+    return Mailbox;

+  } else {

+    return NULL;

+  }

 }

 

 /**

@@ -104,13 +147,18 @@ GetMailboxFromHob (
   )

 {

   EFI_HOB_GUID_TYPE        *GuidHob;

+  UINT64                   *MailboxLocation;

+  DEBUG_AGENT_MAILBOX      *Mailbox;

 

   GuidHob = GetNextGuidHob (&gEfiDebugAgentGuid, HobStart);

   if (GuidHob == NULL) {

     return NULL;

   }

+  MailboxLocation = (UINT64 *) (GET_GUID_HOB_DATA(GuidHob));

+  Mailbox = (DEBUG_AGENT_MAILBOX *)(UINTN)(*MailboxLocation);

+  VerifyMailboxChecksum (Mailbox);

 

-  return (DEBUG_AGENT_MAILBOX *) (GET_GUID_HOB_DATA(GuidHob));

+  return Mailbox;

 }

 

 /**

@@ -124,6 +172,9 @@ GetMailboxPointer (
   VOID

   )

 {

+  AcquireMpSpinLock (&mDebugMpContext.MailboxSpinLock);

+  VerifyMailboxChecksum (mMailboxPointer);

+  ReleaseMpSpinLock (&mDebugMpContext.MailboxSpinLock);

   return mMailboxPointer;

 }

 

@@ -138,10 +189,86 @@ GetDebugPortHandle (
   VOID

   )

 {

-  return (DEBUG_PORT_HANDLE) (UINTN)(mMailboxPointer->DebugPortHandle);

+  return (DEBUG_PORT_HANDLE) (UINTN)(GetMailboxPointer ()->DebugPortHandle);

+}

+

+/**

+  Worker function to setup IDT table and initialize the IDT entries.

+

+  @param[in] Mailbox        Pointer to Mailbox.

+

+**/

+VOID

+SetupDebugAgentEnviroment (

+  IN DEBUG_AGENT_MAILBOX       *Mailbox

+  )

+{

+  IA32_DESCRIPTOR              Idtr;

+  UINT16                       IdtEntryCount;

+  UINT64                       DebugPortHandle;

+

+  if (mMultiProcessorDebugSupport) {

+    InitializeSpinLock (&mDebugMpContext.MpContextSpinLock);

+    InitializeSpinLock (&mDebugMpContext.DebugPortSpinLock);

+    InitializeSpinLock (&mDebugMpContext.MailboxSpinLock);

+    //

+    // Clear Break CPU index value

+    //

+    mDebugMpContext.BreakAtCpuIndex = (UINT32) -1;

+  }

+

+  //

+  // Get original IDT address and size.

+  //

+  AsmReadIdtr ((IA32_DESCRIPTOR *) &Idtr);

+  IdtEntryCount = (UINT16) ((Idtr.Limit + 1) / sizeof (IA32_IDT_GATE_DESCRIPTOR));

+  if (IdtEntryCount < 33) {

+    Idtr.Limit = (UINT16) (sizeof (IA32_IDT_GATE_DESCRIPTOR) * 33 - 1);

+    Idtr.Base  = (UINTN) &mIdtEntryTable;

+    ZeroMem (&mIdtEntryTable, Idtr.Limit + 1);

+    AsmWriteIdtr ((IA32_DESCRIPTOR *) &Idtr);

+  }

+

+  //

+  // Initialize the IDT table entries to support source level debug.

+  //

+  InitializeDebugIdt ();

+

+  if (Mailbox != NULL) {

+    //

+    // If Mailbox exists, copy it into one global variable,

+    //

+    CopyMem (&mMailbox, Mailbox, sizeof (DEBUG_AGENT_MAILBOX));

+  } else {

+    ZeroMem (&mMailbox, sizeof (DEBUG_AGENT_MAILBOX));

+  }  

+

+  mMailboxPointer = &mMailbox;

+  //

+  // Initialize debug communication port

+  //

+  DebugPortHandle = (UINT64) (UINTN)DebugPortInitialize ((VOID *)(UINTN)mMailboxPointer->DebugPortHandle, NULL);

+  UpdateMailboxContent (mMailboxPointer, DEBUG_MAILBOX_DEBUG_PORT_HANDLE_INDEX, DebugPortHandle);

+

+  if (Mailbox == NULL) {

+    //

+    // Trigger one software interrupt to inform HOST

+    //

+    TriggerSoftInterrupt (SYSTEM_RESET_SIGNATURE);

+    SetDebugFlag (DEBUG_AGENT_FLAG_MEMORY_READY, 1);

+    //

+    // Memory has been ready

+    //

+    if (IsHostAttached ()) {

+      //

+      // Trigger one software interrupt to inform HOST

+      //

+      TriggerSoftInterrupt (MEMORY_READY_SIGNATURE);

+    }

+  }

 }

 

- 

+

 /**

   Initialize debug agent.

 

@@ -167,105 +294,207 @@ InitializeDebugAgent (
   IN DEBUG_AGENT_CONTINUE  Function  OPTIONAL

   )

 {

+  UINT64                       *MailboxLocation;

   DEBUG_AGENT_MAILBOX          *Mailbox;

-  IA32_DESCRIPTOR              Idtr;

-  UINT16                       IdtEntryCount;

   BOOLEAN                      InterruptStatus;

+  VOID                         *HobList;

+  IA32_DESCRIPTOR              IdtDescriptor;

+  IA32_DESCRIPTOR              *Ia32Idtr;

+  IA32_IDT_ENTRY               *Ia32IdtEntry;

 

-  if (InitFlag != DEBUG_AGENT_INIT_DXE_CORE &&

-      InitFlag != DEBUG_AGENT_INIT_S3 &&

-      InitFlag != DEBUG_AGENT_INIT_DXE_AP) {

-    return;

+  if (InitFlag == DEBUG_AGENT_INIT_DXE_AP) {

+    //

+    // Invoked by AP, enable interrupt to let AP could receive IPI from other processors

+    //

+    EnableInterrupts ();

+    return ;

   }

 

+  // 

+  // Disable Debug Timer interrupt

+  //

+  SaveAndSetDebugTimerInterrupt (FALSE);

   //

   // Save and disable original interrupt status

   //

   InterruptStatus = SaveAndDisableInterrupts ();

 

-  if (InitFlag == DEBUG_AGENT_INIT_DXE_CORE) {

+  //

+  // Try to get mailbox firstly

+  //

+  HobList         = NULL;

+  Mailbox         = NULL;

+  MailboxLocation = NULL;

+

+  switch (InitFlag) {

+

+  case DEBUG_AGENT_INIT_DXE_LOAD:

     //

-    // Try to get Mailbox from GUIDed HOB.

+    // Check if Debug Agent has been initialized before

     //

-    mDxeCoreFlag = TRUE;

-    Mailbox = GetMailboxFromHob (Context);

-    

+    if (IsDebugAgentInitialzed ()) {

+      DEBUG ((EFI_D_INFO, "Debug Agent: The former agent will be overwritten by the new one!\n"));

+    }

+

+    mMultiProcessorDebugSupport = TRUE;

     //

-    // Clear Break CPU index value

+    // Save original IDT table

+    //

+    AsmReadIdtr (&IdtDescriptor);

+    mSaveIdtTableSize = IdtDescriptor.Limit + 1;

+    mSavedIdtTable    = AllocateCopyPool (mSaveIdtTableSize, (VOID *) IdtDescriptor.Base);

+    //

+    // Initialize Debug Timer hardware

+    //

+    InitializeDebugTimer ();

+    //

+    // Check if Debug Agent initialized in DXE phase

+    //

+    Mailbox = GetMailboxFromConfigurationTable ();

+    if (Mailbox == NULL) {

+      //

+      // Try to get mailbox from GUIDed HOB build in PEI 

+      //

+      HobList = GetHobList ();

+      Mailbox = GetMailboxFromHob (HobList);

+    }

+    //

+    // Set up IDT table and prepare for IDT entries

+    //

+    SetupDebugAgentEnviroment (Mailbox);

+    //

+    // For DEBUG_AGENT_INIT_S3, needn't to install configuration table and EFI Serial IO protocol

+    // For DEBUG_AGENT_INIT_DXE_CORE, InternalConstructorWorker() will invoked in Constructor()

+    //

+    InternalConstructorWorker ();

+    //

+    // Enable interrupt to receive Debug Timer interrupt

     //

-    mDebugMpContext.BreakAtCpuIndex = (UINT32) -1;

-

-  } else if (InitFlag == DEBUG_AGENT_INIT_DXE_AP) {

-

     EnableInterrupts ();

 

-    return;

+    mDebugAgentInitialized = TRUE;

+    FindAndReportModuleImageInfo (SIZE_4KB);

+

+    *(EFI_STATUS *)Context = EFI_SUCCESS;

+

+    if (gST->ConOut != NULL) {

+      Print (L"Debug Agent: Initialized successfully!\r\n");

+      Print (L"If the Debug Port is serial port, please make sure this serial port isn't connected by ISA Serial driver\r\n");

+      Print (L"You could do the following steps to disconnect the serial port:\r\n");

+      Print (L"1: Shell> drivers\r\n");

+      Print (L"   ...\r\n");

+      Print (L"   V  VERSION  E G G #D #C DRIVER NAME                         IMAGE NAME\r\n");

+      Print (L"   == ======== = = = == == =================================== ===================\r\n");

+      Print (L"   8F 0000000A B - -  1 14 PCI Bus Driver                      PciBusDxe\r\n");

+      Print (L"   91 00000010 ? - -  -  - ATA Bus Driver                      AtaBusDxe\r\n");

+      Print (L"   ...\r\n");

+      Print (L"   A7 0000000A B - -  1  1 ISA Serial Driver                   IsaSerialDxe\r\n");

+      Print (L"   ...\r\n");

+      Print (L"2: Shell> dh -d A7\r\n");

+      Print (L"   A7: Image(IsaSerialDxe) ImageDevPath (..9FB3-11D4-9A3A-0090273FC14D))DriverBinding ComponentName ComponentName2\r\n");

+      Print (L"        Driver Name    : ISA Serial Driver\r\n");

+      Print (L"        Image Name     : FvFile(93B80003-9FB3-11D4-9A3A-0090273FC14D)\r\n");

+      Print (L"        Driver Version : 0000000A\r\n");

+      Print (L"        Driver Type    : BUS\r\n");

+      Print (L"        Configuration  : NO\r\n");

+      Print (L"        Diagnostics    : NO\r\n");

+      Print (L"        Managing       :\r\n");

+      Print (L"          Ctrl[EA] : PciRoot(0x0)/Pci(0x1F,0x0)/Serial(0x0)\r\n");

+      Print (L"            Child[EB] : PciRoot(0x0)/Pci(0x1F,0x0)/Serial(0x0)/Uart(115200,8,N,1)\r\n");

+      Print (L"3: Shell> disconnect EA\r\n");

+      Print (L"4: Shell> load -nc DebugAgentDxe.efi\r\n\r\n");

+    }

+    break;

+

+  case DEBUG_AGENT_INIT_DXE_UNLOAD:

+    if (mDebugAgentInitialized) {

+      if (IsHostAttached ()) {

+        Print (L"Debug Agent: Host is still connected, please de-attach TARGET firstly!\r\n");

+        *(EFI_STATUS *)Context = EFI_ACCESS_DENIED;

+        // 

+        // Enable Debug Timer interrupt again

+        //

+        SaveAndSetDebugTimerInterrupt (TRUE);

+      } else {

+        //

+        // Restore original IDT table

+        //

+        AsmReadIdtr (&IdtDescriptor);

+        IdtDescriptor.Limit = (UINT16) (mSaveIdtTableSize - 1);

+        CopyMem ((VOID *) IdtDescriptor.Base, mSavedIdtTable, mSaveIdtTableSize);

+        AsmWriteIdtr (&IdtDescriptor);

+        FreePool (mSavedIdtTable);

+        mDebugAgentInitialized = FALSE;

+        *(EFI_STATUS *)Context = EFI_SUCCESS;

+      }

+    } else {

+      Print (L"Debug Agent: It hasn't been initialized, cannot unload it!\r\n");

+      *(EFI_STATUS *)Context = EFI_NOT_STARTED;

+    }

 

-  } else {

     //

-    // If it is in S3 path, needn't to install configuration table.

+    // Restore interrupt state.

     //

-    Mailbox = NULL;

-  }

+    SetInterruptState (InterruptStatus);

+    break;

 

-  if (Mailbox != NULL) {

+  case DEBUG_AGENT_INIT_DXE_CORE:

+    mDxeCoreFlag                = TRUE;

+    mMultiProcessorDebugSupport = TRUE;

     //

-    // If Mailbox exists, copy it into one global variable.

+    // Initialize Debug Timer hardware

     //

-    CopyMem (&mMailbox, Mailbox, sizeof (DEBUG_AGENT_MAILBOX));

-  } else {

+    InitializeDebugTimer ();

     //

-    // If Mailbox not exists, used the local Mailbox.

+    // Try to get mailbox from GUIDed HOB build in PEI 

     //

-    ZeroMem (&mMailbox, sizeof (DEBUG_AGENT_MAILBOX));

-  }

-

-  mMailboxPointer = &mMailbox;

-

-  //

-  // Get original IDT address and size.

-  //

-  AsmReadIdtr ((IA32_DESCRIPTOR *) &Idtr);

-  IdtEntryCount = (UINT16) ((Idtr.Limit + 1) / sizeof (IA32_IDT_GATE_DESCRIPTOR));

-  if (IdtEntryCount < 33) {

-    Idtr.Limit = (UINT16) (sizeof (IA32_IDT_GATE_DESCRIPTOR) * 33 - 1);

-    Idtr.Base  = (UINTN) &mIdtEntryTable;

-    ZeroMem (&mIdtEntryTable, Idtr.Limit + 1);

-    AsmWriteIdtr ((IA32_DESCRIPTOR *) &Idtr);

-  }

+    HobList = Context;

+    Mailbox = GetMailboxFromHob (HobList);

+    //

+    // Set up IDT table and prepare for IDT entries

+    //

+    SetupDebugAgentEnviroment (Mailbox);

+    //

+    // Enable interrupt to receive Debug Timer interrupt

+    //

+    EnableInterrupts ();

 

-  //

-  // Initialize the IDT table entries to support source level debug.

-  //

-  InitializeDebugIdt ();

+    break;

 

-  //

-  // Initialize debug communication port

-  //

-  mMailboxPointer->DebugPortHandle = (UINT64) (UINTN)DebugPortInitialize ((VOID *)(UINTN)mMailbox.DebugPortHandle, NULL);

+  case DEBUG_AGENT_INIT_S3:

 

-  InitializeSpinLock (&mDebugMpContext.MpContextSpinLock);

-  InitializeSpinLock (&mDebugMpContext.DebugPortSpinLock);

- 

-  if (InitFlag == DEBUG_AGENT_INIT_DXE_CORE) {

+    if (Context != NULL) {

+      Ia32Idtr =  (IA32_DESCRIPTOR *) Context;

+      Ia32IdtEntry = (IA32_IDT_ENTRY *)(Ia32Idtr->Base);

+      MailboxLocation = (UINT64 *) (UINTN) (Ia32IdtEntry[DEBUG_MAILBOX_VECTOR].Bits.OffsetLow + 

+                                           (Ia32IdtEntry[DEBUG_MAILBOX_VECTOR].Bits.OffsetHigh << 16));

+      Mailbox = (DEBUG_AGENT_MAILBOX *)(UINTN)(*MailboxLocation);

+      VerifyMailboxChecksum (Mailbox);

+    }

     //

-    // Initialize Debug Timer hardware and enable interrupt.

+    // Set up IDT table and prepare for IDT entries

     //

-    InitializeDebugTimer ();

-    EnableInterrupts ();

-

-    return;

-  } else {

+    SetupDebugAgentEnviroment (Mailbox);

     //

-    // Disable Debug Timer interrupt in S3 path.

+    // Disable interrupt

     //

-    SaveAndSetDebugTimerInterrupt (FALSE);

-

+    DisableInterrupts ();

+    FindAndReportModuleImageInfo (SIZE_4KB);

+    if (GetDebugFlag (DEBUG_AGENT_FLAG_BREAK_BOOT_SCRIPT) == 1) {

+      //

+      // If Boot Script entry break is set, code will be break at here.

+      //

+      CpuBreakpoint ();

+    }

+    break;

+

+  default:

     //

-    // Restore interrupt state.

+    // Only DEBUG_AGENT_INIT_PREMEM_SEC and DEBUG_AGENT_INIT_POSTMEM_SEC are allowed for this 

+    // Debug Agent library instance.

     //

-    SetInterruptState (InterruptStatus);

+    DEBUG ((EFI_D_ERROR, "Debug Agent: The InitFlag value is not allowed!\n"));

+    CpuDeadLoop ();

+    break;

   }

-

 }

-

diff --git a/SourceLevelDebugPkg/Library/DebugAgent/DxeDebugAgent/DxeDebugAgentLib.h b/SourceLevelDebugPkg/Library/DebugAgent/DxeDebugAgent/DxeDebugAgentLib.h
index ab561812..536fb71d 100644
--- a/SourceLevelDebugPkg/Library/DebugAgent/DxeDebugAgent/DxeDebugAgentLib.h
+++ b/SourceLevelDebugPkg/Library/DebugAgent/DxeDebugAgent/DxeDebugAgentLib.h
@@ -1,7 +1,7 @@
 /** @file

   Header file for Dxe Core Debug Agent Library instance.

 

-  Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -24,22 +24,17 @@
 #include <Library/UefiBootServicesTableLib.h>

 #include <Library/UefiLib.h>

 #include <Library/DevicePathLib.h>

+#include <Library/MemoryAllocationLib.h>

 

 #include "DebugAgent.h"

 

 /**

-  Notification function on EFI PCD protocol to install EFI Serial IO protocol based

-  on Debug Communication Library. 

-

-  @param[in]  Event    The event of notify protocol.

-  @param[in]  Context  Notify event context.

+  Install EFI Serial IO protocol based on Debug Communication Library. 

 

 **/

 VOID

-EFIAPI

-InstallSerialIoNotification (

-  IN EFI_EVENT     Event,

-  IN VOID          *Context

+InstallSerialIo (

+  VOID

   );

   

 #endif

diff --git a/SourceLevelDebugPkg/Library/DebugAgent/DxeDebugAgent/SerialIo.c b/SourceLevelDebugPkg/Library/DebugAgent/DxeDebugAgent/SerialIo.c
index 0cb7c525..9b181e3a 100644
--- a/SourceLevelDebugPkg/Library/DebugAgent/DxeDebugAgent/SerialIo.c
+++ b/SourceLevelDebugPkg/Library/DebugAgent/DxeDebugAgent/SerialIo.c
@@ -1,7 +1,7 @@
 /** @file

   Install Serial IO Protocol that layers on top of a Debug Communication Library instance.

 

-  Copyright (c) 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2012 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -149,11 +149,11 @@ SerialRead (
 EFI_SERIAL_IO_MODE  mSerialIoMode = {

   SERIAL_PORT_DEFAULT_CONTROL_MASK,

   SERIAL_PORT_DEFAULT_TIMEOUT,

-  0,  // BaudRate

+  0,  // default BaudRate

   SERIAL_PORT_DEFAULT_RECEIVE_FIFO_DEPTH,

-  0,  // DataBits

-  0,  // Parity

-  0   // StopBits

+  0,  // default DataBits

+  0,  // default Parity

+  0   // default StopBits

 };

 

 //

@@ -204,10 +204,10 @@ SERIAL_IO_DEVICE_PATH mSerialIoDevicePath = {
       }

     },

     0,

-    0,  // BaudRate

-    0,  // DataBits

-    0,  // Parity

-    0,  // StopBits

+    0,  // default BaudRate

+    0,  // default DataBits

+    0,  // default Parity

+    0,  // default StopBits

   },

   {

     END_DEVICE_PATH_TYPE,

@@ -357,34 +357,15 @@ DebugTerminalFifoRemove (
 }

 

 /**

-  Notification function on EFI PCD protocol to install EFI Serial IO protocol based

-  on Debug Communication Library. 

-

-  @param[in]  Event    The event of notify protocol.

-  @param[in]  Context  Notify event context.

+  Install EFI Serial IO protocol based on Debug Communication Library. 

 

 **/

 VOID

-EFIAPI

-InstallSerialIoNotification (

-  IN EFI_EVENT     Event,

-  IN VOID          *Context

+InstallSerialIo (

+  VOID

   )

 {

-  EFI_STATUS  Status;

-

-  //

-  // Get Debug Port parameters from PCDs

-  //

-  mSerialIoDevicePath.UartDevicePath.BaudRate = PcdGet64 (PcdUartDefaultBaudRate);

-  mSerialIoDevicePath.UartDevicePath.DataBits = PcdGet8 (PcdUartDefaultDataBits);

-  mSerialIoDevicePath.UartDevicePath.Parity   = PcdGet8 (PcdUartDefaultParity);

-  mSerialIoDevicePath.UartDevicePath.StopBits = PcdGet8 (PcdUartDefaultStopBits);

-

-  mSerialIoMode.BaudRate = mSerialIoDevicePath.UartDevicePath.BaudRate;

-  mSerialIoMode.DataBits = mSerialIoDevicePath.UartDevicePath.DataBits;

-  mSerialIoMode.Parity   = mSerialIoDevicePath.UartDevicePath.Parity;

-  mSerialIoMode.StopBits = mSerialIoDevicePath.UartDevicePath.StopBits;

+  EFI_STATUS       Status;

 

   Status = gBS->InstallMultipleProtocolInterfaces (

                   &mSerialIoHandle,

@@ -448,22 +429,10 @@ SerialSetAttributes (
   )

 {

   //

-  // The Debug Communication Library does not support changing communications parameters, so unless

-  // the request is to use the default value or the value the Debug Communication Library is already

-  // using, then return EFI_INVALID_PARAMETER.

+  // The Debug Communication Library CAN NOT change communications parameters (if it has)

+  // actually. Because it also has no any idea on what parameters are based on, we cannot

+  // check the input parameters (like BaudRate, Parity, DataBits and StopBits). 

   //

-  if (BaudRate != 0 && BaudRate != PcdGet64 (PcdUartDefaultBaudRate)) {

-    return EFI_INVALID_PARAMETER;

-  }

-  if (Parity != DefaultParity && Parity != PcdGet8 (PcdUartDefaultParity)) {

-    return EFI_INVALID_PARAMETER;

-  }

-  if (DataBits != 0 && DataBits != PcdGet8 (PcdUartDefaultDataBits)) {

-    return EFI_INVALID_PARAMETER;

-  }

-  if (StopBits != DefaultStopBits && StopBits != PcdGet8 (PcdUartDefaultStopBits)) {

-    return EFI_INVALID_PARAMETER;

-  }

   

   //

   // Update the Timeout value in the mode structure based on the request.

@@ -536,7 +505,18 @@ SerialGetControl (
   )

 {

   DEBUG_PORT_HANDLE                Handle;

+  BOOLEAN                          DebugTimerInterruptState;

+  EFI_TPL                          Tpl;

 

+  //

+  // Raise TPL to prevent recursion from EFI timer interrupts

+  //

+  Tpl = gBS->RaiseTPL (TPL_NOTIFY);

+  

+  //

+  // Save and disable Debug Timer interrupt to avoid it to access Debug Port

+  //

+  DebugTimerInterruptState = SaveAndSetDebugTimerInterrupt (FALSE);

   Handle = GetDebugPortHandle ();

   

   //

@@ -552,6 +532,17 @@ SerialGetControl (
   if (!IsDebugTermianlFifoEmpty (&mSerialFifoForTerminal) || DebugPortPollBuffer (Handle)) {

     *Control &= ~EFI_SERIAL_INPUT_BUFFER_EMPTY;

   }

+

+  //

+  // Restore Debug Timer interrupt

+  //  

+  SaveAndSetDebugTimerInterrupt (DebugTimerInterruptState);

+  

+  //

+  // Restore to original TPL

+  //

+  gBS->RestoreTPL (Tpl);

+  

   return EFI_SUCCESS;

 }

 

@@ -577,7 +568,18 @@ SerialWrite (
   )

 {

   DEBUG_PORT_HANDLE                Handle;

+  BOOLEAN                          DebugTimerInterruptState;

+  EFI_TPL                          Tpl;

 

+  //

+  // Raise TPL to prevent recursion from EFI timer interrupts

+  //

+  Tpl = gBS->RaiseTPL (TPL_NOTIFY);

+  

+  //

+  // Save and disable Debug Timer interrupt to avoid it to access Debug Port

+  //

+  DebugTimerInterruptState = SaveAndSetDebugTimerInterrupt (FALSE);

   Handle = GetDebugPortHandle ();

   

   if ((mSerialIoMode.ControlMask & EFI_SERIAL_SOFTWARE_LOOPBACK_ENABLE) != 0)  {

@@ -593,6 +595,17 @@ SerialWrite (
   } else {

     *BufferSize = DebugPortWriteBuffer (Handle, Buffer, *BufferSize);

   }

+

+  //

+  // Restore Debug Timer interrupt

+  //  

+  SaveAndSetDebugTimerInterrupt (DebugTimerInterruptState);

+  

+  //

+  // Restore to original TPL

+  //

+  gBS->RestoreTPL (Tpl);

+  

   return EFI_SUCCESS;

 }

 

@@ -620,17 +633,24 @@ SerialRead (
   EFI_STATUS                  Status;

   UINTN                       Index;

   UINT8                       *Uint8Buffer;

-  BOOLEAN                     OldInterruptState;

+  BOOLEAN                     DebugTimerInterruptState;

+  EFI_TPL                     Tpl;

   DEBUG_PORT_HANDLE           Handle;

-  UINT8                       Data;

-

-  Handle = GetDebugPortHandle ();

+  DEBUG_PACKET_HEADER         DebugHeader;

+  UINT8                       *Data8;

 

   //

-  // Save and disable Debug Timer interrupt to avoid it to access Debug Port

+  // Raise TPL to prevent recursion from EFI timer interrupts

   //

-  OldInterruptState = SaveAndSetDebugTimerInterrupt (FALSE);

+  Tpl = gBS->RaiseTPL (TPL_NOTIFY);

   

+  //

+  // Save and disable Debug Timer interrupt to avoid it to access Debug Port

+  //

+  DebugTimerInterruptState = SaveAndSetDebugTimerInterrupt (FALSE);

+  Handle = GetDebugPortHandle ();

+ 

+  Data8 = (UINT8 *) &DebugHeader;

   Uint8Buffer = (UINT8 *)Buffer;

   if ((mSerialIoMode.ControlMask & EFI_SERIAL_SOFTWARE_LOOPBACK_ENABLE) != 0)  {

     if ((mLoopbackBuffer & SERIAL_PORT_LOOPBACK_BUFFER_FULL) == 0) {

@@ -644,9 +664,9 @@ SerialRead (
       //

       // Read input character from terminal FIFO firstly

       //

-      Status = DebugTerminalFifoRemove (&mSerialFifoForTerminal, &Data);

+      Status = DebugTerminalFifoRemove (&mSerialFifoForTerminal, Data8);

       if (Status == EFI_SUCCESS) {

-        *Uint8Buffer = Data;

+        *Uint8Buffer = *Data8;

         Uint8Buffer ++;

         continue;

       }

@@ -656,16 +676,25 @@ SerialRead (
       if (!DebugPortPollBuffer (Handle)) {

         break;

       }

-      DebugPortReadBuffer (Handle, &Data, 1, 0);

+      DebugPortReadBuffer (Handle, Data8, 1, 0);

 

-      if (Data== DEBUG_STARTING_SYMBOL_ATTACH ||

-          Data == DEBUG_STARTING_SYMBOL_BREAK) {

+      if (*Data8 == DEBUG_STARTING_SYMBOL_ATTACH) {

         //

         // Add the debug symbol into Debug FIFO

         //

-        DebugTerminalFifoAdd (&mSerialFifoForDebug, Data);

+        DebugAgentMsgPrint (DEBUG_AGENT_INFO, "Terminal Timer attach symbol received %x", *Data8);

+        DebugTerminalFifoAdd (&mSerialFifoForDebug, *Data8);

+      } else if (*Data8 == DEBUG_STARTING_SYMBOL_NORMAL) {

+        Status = ReadRemainingBreakPacket (Handle, &DebugHeader);

+        if (Status == EFI_SUCCESS) {

+          DebugAgentMsgPrint (DEBUG_AGENT_INFO, "Terminal Timer break symbol received %x", DebugHeader.Command);

+          DebugTerminalFifoAdd (&mSerialFifoForDebug, DebugHeader.Command);

+        }

+        if (Status == EFI_TIMEOUT) {

+          continue;

+        }

       } else {

-        *Uint8Buffer = Data;

+        *Uint8Buffer = *Data8;

         Uint8Buffer ++;

       }

     }

@@ -675,7 +704,12 @@ SerialRead (
   //

   // Restore Debug Timer interrupt

   //  

-  SaveAndSetDebugTimerInterrupt (OldInterruptState);

+  SaveAndSetDebugTimerInterrupt (DebugTimerInterruptState);

+  

+  //

+  // Restore to original TPL

+  //

+  gBS->RestoreTPL (Tpl);

   

   return EFI_SUCCESS;

 }

@@ -691,36 +725,90 @@ SerialRead (
 

 **/

 EFI_STATUS

-DebugReadBreakSymbol (

+DebugReadBreakFromDebugPort (

   IN  DEBUG_PORT_HANDLE      Handle,

   OUT UINT8                  *BreakSymbol

   )

 {

-  EFI_STATUS               Status;

-  UINT8                    Data;

+  EFI_STATUS                 Status;

+  DEBUG_PACKET_HEADER        DebugHeader;

+  UINT8                      *Data8;

 

-  Status = DebugTerminalFifoRemove (&mSerialFifoForDebug, &Data);

-  if (Status != EFI_SUCCESS) {

+  *BreakSymbol = 0;

+  //

+  // If Debug Port buffer has data, read it till it was break symbol or Debug Port buffer empty.

+  //

+  Data8 = (UINT8 *) &DebugHeader;

+  while (TRUE) {

+    //

+    // If start symbol is not received

+    //

     if (!DebugPortPollBuffer (Handle)) {

       //

-      // No data in Debug Port buffer.

+      // If no data in Debug Port, exit

       //

-      return EFI_NOT_FOUND;

+      break;

+    }

+    //

+    // Try to read the start symbol

+    //

+    DebugPortReadBuffer (Handle, Data8, 1, 0);

+    if (*Data8 == DEBUG_STARTING_SYMBOL_ATTACH) {

+      DebugAgentMsgPrint (DEBUG_AGENT_INFO, "Debug Timer attach symbol received %x", *Data8);

+      *BreakSymbol = *Data8;

+      return EFI_SUCCESS;

+    } 

+    if (*Data8 == DEBUG_STARTING_SYMBOL_NORMAL) {

+      Status = ReadRemainingBreakPacket (Handle, &DebugHeader);

+      if (Status == EFI_SUCCESS) {

+        DebugAgentMsgPrint (DEBUG_AGENT_INFO, "Debug Timer break symbol received %x", DebugHeader.Command);

+        *BreakSymbol = DebugHeader.Command;

+        return EFI_SUCCESS;

+      }

+      if (Status == EFI_TIMEOUT) {

+        break;

+      }

     } else {

       //

-      // Read one character from Debug Port.

+      // Add to Terminal FIFO

       //

-      DebugPortReadBuffer (Handle, &Data, 1, 0);

-      if ((Data != DEBUG_STARTING_SYMBOL_ATTACH) && (Data != DEBUG_STARTING_SYMBOL_BREAK)) {

-        //

-        // If the data is not Break symbol, add it into Terminal FIFO

-        //

-        DebugTerminalFifoAdd (&mSerialFifoForTerminal, Data);

-        return EFI_NOT_FOUND;

-      }

+      DebugTerminalFifoAdd (&mSerialFifoForTerminal, *Data8);

     }

   }

   

-  *BreakSymbol = Data;

-  return EFI_SUCCESS;

+  return EFI_NOT_FOUND;

+}

+

+/**

+  Read the Attach/Break-in symbols.

+

+  @param[in]  Handle         Pointer to Debug Port handle.

+  @param[out] BreakSymbol    Returned break symbol.

+

+  @retval EFI_SUCCESS        Read the symbol in BreakSymbol.

+  @retval EFI_NOT_FOUND      No read the break symbol.

+

+**/

+EFI_STATUS

+DebugReadBreakSymbol (

+  IN  DEBUG_PORT_HANDLE      Handle,

+  OUT UINT8                  *BreakSymbol

+  )

+{

+  EFI_STATUS               Status;

+  UINT8                    Data8;

+

+  //

+  // Read break symbol from debug FIFO firstly

+  //

+  Status = DebugTerminalFifoRemove (&mSerialFifoForDebug, &Data8);

+  if (Status == EFI_SUCCESS) {

+    *BreakSymbol = Data8;

+    return EFI_SUCCESS;

+  } else {

+    //

+    // Read Break symbol from debug port

+    //

+    return DebugReadBreakFromDebugPort (Handle, BreakSymbol);

+  }

 }

diff --git a/SourceLevelDebugPkg/Library/DebugAgent/DxeDebugAgentLib.inf b/SourceLevelDebugPkg/Library/DebugAgent/DxeDebugAgentLib.inf
index 434d21a9..f73385ce 100644
--- a/SourceLevelDebugPkg/Library/DebugAgent/DxeDebugAgentLib.inf
+++ b/SourceLevelDebugPkg/Library/DebugAgent/DxeDebugAgentLib.inf
@@ -1,7 +1,7 @@
 ## @file

 #  Debug Agent library instance for Dxe Core and Dxe modules.

 #

-#  Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>

+#  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

 #

 #  This program and the accompanying materials

 #  are licensed and made available under the terms and conditions of the BSD License

@@ -75,6 +75,9 @@
   LocalApicLib

   TimerLib

   PrintLib

+  PeCoffGetEntryPointLib

+  PeCoffExtraActionLib

+  MemoryAllocationLib

 

 [Guids]

   gEfiDebugAgentGuid                            ## PRODUCES ## Configuration Table

@@ -83,13 +86,8 @@
 [Protocols]

   gEfiSerialIoProtocolGuid                      ## PRODUCES

   gEfiDevicePathProtocolGuid                    ## PRODUCES 

-  gEfiPcdProtocolGuid                           ## NOTIFY

 

 [Pcd]

   gEfiMdePkgTokenSpaceGuid.PcdFSBClock                                  ## CONSUMES

-  gEfiMdePkgTokenSpaceGuid.PcdUartDefaultBaudRate                       ## CONSUMES

-  gEfiMdePkgTokenSpaceGuid.PcdUartDefaultDataBits                       ## CONSUMES

-  gEfiMdePkgTokenSpaceGuid.PcdUartDefaultParity                         ## CONSUMES

-  gEfiMdePkgTokenSpaceGuid.PcdUartDefaultStopBits                       ## CONSUMES

   gEfiSourceLevelDebugPkgTokenSpaceGuid.PcdExceptionsIgnoredByDebugger  ## CONSUMES

 

diff --git a/SourceLevelDebugPkg/Library/DebugAgent/SecPeiDebugAgent/SecPeiDebugAgentLib.c b/SourceLevelDebugPkg/Library/DebugAgent/SecPeiDebugAgent/SecPeiDebugAgentLib.c
index ea702e65..49c8268e 100644
--- a/SourceLevelDebugPkg/Library/DebugAgent/SecPeiDebugAgent/SecPeiDebugAgentLib.c
+++ b/SourceLevelDebugPkg/Library/DebugAgent/SecPeiDebugAgent/SecPeiDebugAgentLib.c
@@ -1,7 +1,7 @@
 /** @file

   SEC Core Debug Agent Library instance implementition.

 

-  Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -14,7 +14,30 @@
 

 #include "SecPeiDebugAgentLib.h"

 

-CONST BOOLEAN                MultiProcessorDebugSupport = FALSE;

+BOOLEAN  mSkipBreakpoint = FALSE;

+

+EFI_PEI_NOTIFY_DESCRIPTOR mMemoryDiscoveredNotifyList[1] = {

+  {

+    (EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),

+    &gEfiPeiMemoryDiscoveredPpiGuid,

+    DebugAgentCallbackMemoryDiscoveredPpi

+  }

+};

+

+/**

+  Check if debug agent support multi-processor.

+

+  @retval TRUE    Multi-processor is supported.

+  @retval FALSE   Multi-processor is not supported.

+

+**/

+BOOLEAN

+MultiProcessorDebugSupport (

+  VOID

+  )

+{

+  return FALSE;

+}

 

 /**

   Read the Attach/Break-in symbols from the debug port.

@@ -32,14 +55,44 @@ DebugReadBreakSymbol (
   OUT UINT8                  *BreakSymbol

   )

 {

+  EFI_STATUS                 Status;

+  DEBUG_PACKET_HEADER        DebugHeader;

+  UINT8                      *Data8;

+

   *BreakSymbol = 0;

   //

-  // If Debug Port buffer has data, read it till it was break symbol or Debug Port buffer emty.

+  // If Debug Port buffer has data, read it till it was break symbol or Debug Port buffer empty.

   //

-  while (DebugPortPollBuffer (Handle)) {

-    DebugPortReadBuffer (Handle, BreakSymbol, 1, 0);

-    if (*BreakSymbol == DEBUG_STARTING_SYMBOL_ATTACH || *BreakSymbol == DEBUG_STARTING_SYMBOL_BREAK) {

+  Data8 = (UINT8 *) &DebugHeader;

+  while (TRUE) {

+    //

+    // If start symbol is not received

+    //

+    if (!DebugPortPollBuffer (Handle)) {

+      //

+      // If no data in Debug Port, exit

+      //

+      break;

+    }

+    //

+    // Try to read the start symbol

+    //

+    DebugPortReadBuffer (Handle, Data8, 1, 0);

+    if (*Data8 == DEBUG_STARTING_SYMBOL_ATTACH) {

+      *BreakSymbol = *Data8;

+      DebugAgentMsgPrint (DEBUG_AGENT_INFO, "Debug Timer attach symbol received %x", *BreakSymbol);

       return EFI_SUCCESS;

+    } 

+    if (*Data8 == DEBUG_STARTING_SYMBOL_NORMAL) {

+      Status = ReadRemainingBreakPacket (Handle, &DebugHeader);

+      if (Status == EFI_SUCCESS) {

+        *BreakSymbol = DebugHeader.Command;

+        DebugAgentMsgPrint (DEBUG_AGENT_INFO, "Debug Timer break symbol received %x", *BreakSymbol);

+        return EFI_SUCCESS;

+      }

+      if (Status == EFI_TIMEOUT) {

+        break;

+      }

     }

   }

   

@@ -47,67 +100,56 @@ DebugReadBreakSymbol (
 }

 

 /**

-  Get pointer to Mailbox from IDT entry before memory is ready.

+  Get the pointer to location saved Mailbox pointer from IDT entry.

 

 **/

 VOID *

-GetMailboxPointerInIdtEntry (

+GetLocationSavedMailboxPointerInIdtEntry (

   VOID

   )

 {

-  IA32_IDT_GATE_DESCRIPTOR   *IdtEntry;

-  IA32_DESCRIPTOR            IdtDescriptor;

-  UINTN                      Mailbox;

-

-  AsmReadIdtr (&IdtDescriptor);

-  IdtEntry = (IA32_IDT_GATE_DESCRIPTOR *) IdtDescriptor.Base;

+  UINTN                     *MailboxLocation;

 

-  Mailbox = IdtEntry[DEBUG_MAILBOX_VECTOR].Bits.OffsetLow + (IdtEntry[DEBUG_MAILBOX_VECTOR].Bits.OffsetHigh << 16);

-  return (VOID *) Mailbox;

+  MailboxLocation = (UINTN *) GetExceptionHandlerInIdtEntry (DEBUG_MAILBOX_VECTOR);

+  //

+  // *MailboxLocation is the pointer to Mailbox

+  //

+  VerifyMailboxChecksum ((DEBUG_AGENT_MAILBOX *) (*MailboxLocation));

+  return MailboxLocation;

 }

 

 /**

   Set the pointer of Mailbox into IDT entry before memory is ready.

 

-  @param[in]  Mailbox       The pointer of Mailbox.

+  @param[in]  MailboxLocation    Pointer to location saved Mailbox pointer.

 

 **/

 VOID

-SetMailboxPointerInIdtEntry (

-  IN VOID                    *Mailbox

+SetLocationSavedMailboxPointerInIdtEntry (

+  IN VOID                  *MailboxLocation

   )

 {

-  IA32_IDT_GATE_DESCRIPTOR   *IdtEntry;

-  IA32_DESCRIPTOR            IdtDescriptor;

-

-  AsmReadIdtr (&IdtDescriptor);

-  IdtEntry = (IA32_IDT_GATE_DESCRIPTOR *) IdtDescriptor.Base;

-

-  IdtEntry[DEBUG_MAILBOX_VECTOR].Bits.OffsetLow  = (UINT16)(UINTN)Mailbox;

-  IdtEntry[DEBUG_MAILBOX_VECTOR].Bits.OffsetHigh = (UINT16)((UINTN)Mailbox >> 16);

+  SetExceptionHandlerInIdtEntry (DEBUG_MAILBOX_VECTOR, MailboxLocation);

 }

 

 /**

-  Get the pointer to Mailbox from IDT entry and build the Mailbox into GUIDed Hob

-  after memory is ready.

+  Get the location of Mailbox pointer from the GUIDed HOB.

 

-  @return Pointer to Mailbox.

+  @return Pointer to the location saved Mailbox pointer.

 

 **/

-DEBUG_AGENT_MAILBOX *

-BuildMailboxHob (

+UINT64 *

+GetMailboxLocationFromHob (

   VOID

   )

 {

-  DEBUG_AGENT_MAILBOX       *Mailbox;

-

-  Mailbox = (DEBUG_AGENT_MAILBOX *) GetMailboxPointerInIdtEntry ();

+  EFI_HOB_GUID_TYPE        *GuidHob;

 

-  return BuildGuidDataHob (

-           &gEfiDebugAgentGuid,

-           Mailbox,

-           sizeof (DEBUG_AGENT_MAILBOX)

-           );

+  GuidHob = GetFirstGuidHob (&gEfiDebugAgentGuid);

+  if (GuidHob == NULL) {

+    return NULL;

+  }

+  return (UINT64 *) (GET_GUID_HOB_DATA(GuidHob));

 }

 

 /**

@@ -121,7 +163,49 @@ GetMailboxPointer (
   VOID

   )

 {

-  return (DEBUG_AGENT_MAILBOX *) GetMailboxPointerInIdtEntry ();

+  UINT64               DebugPortHandle;

+  UINT64               *MailboxLocationInIdt;

+  UINT64               *MailboxLocationInHob;

+  DEBUG_AGENT_MAILBOX  *Mailbox;

+  

+  //

+  // Get mailbox from IDT entry firstly

+  //

+  MailboxLocationInIdt = GetLocationSavedMailboxPointerInIdtEntry ();

+  Mailbox = (DEBUG_AGENT_MAILBOX *)(UINTN)(*MailboxLocationInIdt);

+  //

+  // Check if mailbox was setup in PEI firstly, cannot used GetDebugFlag() to 

+  // get CheckMailboxInHob flag to avoid GetMailboxPointer() nesting.

+  //

+  if (Mailbox->DebugFlag.Bits.CheckMailboxInHob != 1) {

+    //

+    // If mailbox in IDT entry has already been the final one

+    //

+    return Mailbox;

+  }

+

+  MailboxLocationInHob = GetMailboxLocationFromHob ();

+  //

+  // Compare mailbox in IDT enry with mailbox in HOB

+  //

+  if (MailboxLocationInHob != MailboxLocationInIdt && MailboxLocationInHob != NULL) {

+    Mailbox = (DEBUG_AGENT_MAILBOX *)(UINTN)(*MailboxLocationInHob);

+    //

+    // Fix up Debug Port handler and save new mailbox in IDT entry

+    //

+    Mailbox = (DEBUG_AGENT_MAILBOX *)((UINTN)Mailbox + ((UINTN)(MailboxLocationInHob) - (UINTN)MailboxLocationInIdt));

+    DebugPortHandle = (UINT64)((UINTN)Mailbox->DebugPortHandle + ((UINTN)(MailboxLocationInHob) - (UINTN)MailboxLocationInIdt));

+    UpdateMailboxContent (Mailbox, DEBUG_MAILBOX_DEBUG_PORT_HANDLE_INDEX, DebugPortHandle);

+    *MailboxLocationInHob = (UINT64)(UINTN)Mailbox;

+    SetLocationSavedMailboxPointerInIdtEntry (MailboxLocationInHob);

+    //

+    // Clean CheckMailboxInHob flag

+    //

+    Mailbox->DebugFlag.Bits.CheckMailboxInHob = 0;

+    UpdateMailboxChecksum (Mailbox);

+  }

+

+  return Mailbox;

 }

 

 /**

@@ -137,49 +221,59 @@ GetDebugPortHandle (
 {

   DEBUG_AGENT_MAILBOX    *DebugAgentMailbox;

   

-  DebugAgentMailbox = (DEBUG_AGENT_MAILBOX *)GetMailboxPointerInIdtEntry ();

+  DebugAgentMailbox = GetMailboxPointer ();

 

   return (DEBUG_PORT_HANDLE) (UINTN)(DebugAgentMailbox->DebugPortHandle);

 }

 

 /**

-  Trigger one software interrupt to debug agent to handle it.

+  Debug Agent provided notify callback function on Memory Discovered PPI.

+

+  @param[in] PeiServices      Indirect reference to the PEI Services Table.

+  @param[in] NotifyDescriptor Address of the notification descriptor data structure.

+  @param[in] Ppi              Address of the PPI that was installed.

 

-  @param Signature       Software interrupt signature.

+  @retval EFI_SUCCESS If the function completed successfully.

 

 **/

-VOID

-TriggerSoftInterrupt (

-  UINT32                 Signature

+EFI_STATUS

+EFIAPI

+DebugAgentCallbackMemoryDiscoveredPpi (

+  IN EFI_PEI_SERVICES                     **PeiServices,

+  IN EFI_PEI_NOTIFY_DESCRIPTOR            *NotifyDescriptor,

+  IN VOID                                 *Ppi

   )

 {

-  UINTN                  Dr0;

-  UINTN                  Dr1;

-

+  DEBUG_AGENT_MAILBOX            *Mailbox;

+  BOOLEAN                        InterruptStatus;

+  

   //

-  // Save Debug Register State

+  // Save and disable original interrupt status

   //

-  Dr0 = AsmReadDr0 ();

-  Dr1 = AsmReadDr1 ();

-

+  InterruptStatus = SaveAndDisableInterrupts ();

+  

   //

-  // DR0 = Signature

+  // Set physical memory ready flag

   //

-  AsmWriteDr0 (SOFT_INTERRUPT_SIGNATURE);

-  AsmWriteDr1 (Signature);

+  Mailbox = GetMailboxPointer ();

+  SetDebugFlag (DEBUG_AGENT_FLAG_MEMORY_READY, 1);

 

   //

-  // Do INT3 to communicate with HOST side

+  // Memory has been ready

   //

-  CpuBreakpoint ();

+  if (IsHostAttached ()) {

+    //

+    // Trigger one software interrupt to inform HOST

+    //

+    TriggerSoftInterrupt (MEMORY_READY_SIGNATURE);

+  }

 

   //

-  // Restore Debug Register State only when Host didn't change it inside exception handler.

-  //   Dr registers can only be changed by setting the HW breakpoint.

+  // Restore interrupt state.

   //

-  AsmWriteDr0 (Dr0);

-  AsmWriteDr1 (Dr1);

-

+  SetInterruptState (InterruptStatus);

+  

+  return EFI_SUCCESS;

 }

 

 /**

@@ -225,7 +319,13 @@ InitializeDebugAgent (
   DEBUG_AGENT_MAILBOX              MailboxInStack;

   DEBUG_AGENT_PHASE2_CONTEXT       Phase2Context;

   DEBUG_AGENT_CONTEXT_POSTMEM_SEC  *DebugAgentContext;

-

+  EFI_STATUS                       Status;

+  IA32_DESCRIPTOR                  *Ia32Idtr;

+  IA32_IDT_ENTRY                   *Ia32IdtEntry;

+  UINT64                           DebugPortHandle;

+  UINT64                           MailboxLocation;

+  UINT64                           *MailboxLocationPointer;

+  

   DisableInterrupts ();

 

   switch (InitFlag) {

@@ -234,20 +334,20 @@ InitializeDebugAgent (
 

     InitializeDebugIdt ();

 

+    MailboxLocation = (UINT64)(UINTN)&MailboxInStack;

     Mailbox = &MailboxInStack;

     ZeroMem ((VOID *) Mailbox, sizeof (DEBUG_AGENT_MAILBOX));

-

     //

     // Get and save debug port handle and set the length of memory block.

     //

-    SetMailboxPointerInIdtEntry ((VOID *) Mailbox);

+    SetLocationSavedMailboxPointerInIdtEntry (&MailboxLocation);

+    SetDebugFlag (DEBUG_AGENT_FLAG_PRINT_ERROR_LEVEL, DEBUG_AGENT_ERROR);

 

     InitializeDebugTimer ();

 

     Phase2Context.Context  = Context;

     Phase2Context.Function = Function;

     DebugPortInitialize ((VOID *) &Phase2Context, InitializeDebugAgentPhase2);

-

     //

     // If reaches here, it means Debug Port initialization failed.

     //

@@ -256,34 +356,123 @@ InitializeDebugAgent (
     break;

 

   case DEBUG_AGENT_INIT_POSTMEM_SEC:

-

+    Mailbox = GetMailboxPointer ();

     //

     // Memory has been ready

     //

-    if (IsHostAttached()) {

+    SetDebugFlag (DEBUG_AGENT_FLAG_MEMORY_READY, 1);

+    if (IsHostAttached ()) {

       //

       // Trigger one software interrupt to inform HOST

       //

       TriggerSoftInterrupt (MEMORY_READY_SIGNATURE);

     }

 

+    //

+    // Fix up Debug Port handle address and mailbox address

+    //

     DebugAgentContext = (DEBUG_AGENT_CONTEXT_POSTMEM_SEC *) Context;

+    DebugPortHandle = (UINT64)(UINT32)(Mailbox->DebugPortHandle + DebugAgentContext->StackMigrateOffset);

+    UpdateMailboxContent (Mailbox, DEBUG_MAILBOX_DEBUG_PORT_HANDLE_INDEX, DebugPortHandle);

+    Mailbox = (DEBUG_AGENT_MAILBOX *) ((UINTN) Mailbox + DebugAgentContext->StackMigrateOffset);

+    MailboxLocation = (UINT64)(UINTN)Mailbox;

+    //

+    // Build mailbox location in HOB and fix-up its address

+    //

+    MailboxLocationPointer = BuildGuidDataHob (

+                               &gEfiDebugAgentGuid,

+                               &MailboxLocation,

+                               sizeof (UINT64)

+                               );

+    MailboxLocationPointer = (UINT64 *) ((UINTN) MailboxLocationPointer + DebugAgentContext->HeapMigrateOffset);

+    //

+    // Update IDT entry to save the location saved mailbox pointer

+    //

+    SetLocationSavedMailboxPointerInIdtEntry (MailboxLocationPointer);

+    //

+    // Enable CPU interrupts so debug timer interrupts can be delivered

+    //

+    EnableInterrupts ();

+

+    break;

+

+  case DEBUG_AGENT_INIT_PEI:

+    //

+    // Check if Debug Agent has initialized before

+    //

+    if (IsDebugAgentInitialzed()) {

+      DEBUG ((EFI_D_WARN, "Debug Agent: It has already initialized in SEC Core!\n"));

+      break;

+    }

+    //

+    // Set up IDT entries

+    //

+    InitializeDebugIdt ();

+    //

+    // Build mailbox in HOB and setup Mailbox Set In Pei flag

+    //

+    Mailbox = AllocateZeroPool (sizeof (DEBUG_AGENT_MAILBOX));

+    MailboxLocation = (UINT64)(UINTN)Mailbox;

+    MailboxLocationPointer = BuildGuidDataHob (

+                               &gEfiDebugAgentGuid,

+                               &MailboxLocation,

+                               sizeof (UINT64)

+                               );

 

-    Mailbox = (DEBUG_AGENT_MAILBOX *) GetMailboxPointerInIdtEntry ();

-    Mailbox->DebugPortHandle = (UINT64)(UINT32)(Mailbox->DebugPortHandle + DebugAgentContext->StackMigrateOffset);

-    Mailbox->DebugFlag.MemoryReady = 1;

+    InitializeDebugTimer ();

+    //

+    // Update IDT entry to save the location pointer saved mailbox pointer

+    //

+    SetLocationSavedMailboxPointerInIdtEntry (MailboxLocationPointer);

+    //

+    // Register for a callback once memory has been initialized.

+    // If memery has been ready, the callback funtion will be invoked immediately

+    //

+    Status = PeiServicesNotifyPpi (&mMemoryDiscoveredNotifyList[0]);

+    ASSERT_EFI_ERROR (Status);

+    //

+    // Set HOB check flag if memory has not been ready yet

+    //

+    if (GetDebugFlag (DEBUG_AGENT_FLAG_MEMORY_READY) == 0) {

+      SetDebugFlag (DEBUG_AGENT_FLAG_CHECK_MAILBOX_IN_HOB, 1);

+    }

 

-    Mailbox = BuildMailboxHob ();

-    Mailbox = (DEBUG_AGENT_MAILBOX *) ((UINTN) Mailbox + DebugAgentContext->HeapMigrateOffset);

+    Phase2Context.Context  = Context;

+    Phase2Context.Function = Function;

+    DebugPortInitialize ((VOID *) &Phase2Context, InitializeDebugAgentPhase2);

 

-    SetMailboxPointerInIdtEntry ((VOID *) Mailbox);

+    FindAndReportModuleImageInfo (4);

 

-    EnableInterrupts ();

+    break;

 

+  case DEBUG_AGENT_INIT_THUNK_PEI_IA32TOX64:

+    if (Context == NULL) {

+      DEBUG ((EFI_D_ERROR, "DebugAgent: Input parameter Context cannot be NULL!\n"));

+      CpuDeadLoop ();

+    } else {

+      Ia32Idtr =  (IA32_DESCRIPTOR *) Context;

+      Ia32IdtEntry = (IA32_IDT_ENTRY *)(Ia32Idtr->Base);

+      MailboxLocationPointer = (UINT64 *) (UINTN) (Ia32IdtEntry[DEBUG_MAILBOX_VECTOR].Bits.OffsetLow +

+                                                (Ia32IdtEntry[DEBUG_MAILBOX_VECTOR].Bits.OffsetHigh << 16));

+      Mailbox = (DEBUG_AGENT_MAILBOX *) (UINTN)(*MailboxLocationPointer);

+      VerifyMailboxChecksum (Mailbox);

+

+      DebugPortHandle = (UINT64) (UINTN)DebugPortInitialize ((VOID *)(UINTN)Mailbox->DebugPortHandle, NULL);

+      UpdateMailboxContent (Mailbox, DEBUG_MAILBOX_DEBUG_PORT_HANDLE_INDEX, DebugPortHandle);

+      //

+      // Set up IDT entries

+      //

+      InitializeDebugIdt ();

+      //

+      // Update IDT entry to save location pointer saved the mailbox pointer

+      //

+      SetLocationSavedMailboxPointerInIdtEntry (MailboxLocationPointer);

+

+      FindAndReportModuleImageInfo (4);

+    }

     break;

 

   default:

-

     //

     // Only DEBUG_AGENT_INIT_PREMEM_SEC and DEBUG_AGENT_INIT_POSTMEM_SEC are allowed for this 

     // Debug Agent library instance.

@@ -294,6 +483,8 @@ InitializeDebugAgent (
 

   }

 

+  EnableInterrupts ();

+

   //

   // If Function is not NULL, invoke it always whatever debug agent was initialized sucesssfully or not.

   //

@@ -319,11 +510,22 @@ InitializeDebugAgentPhase2 (
   )

 {

   DEBUG_AGENT_PHASE2_CONTEXT *Phase2Context;

+  UINT64                     *MailboxLocation;

   DEBUG_AGENT_MAILBOX        *Mailbox;

   EFI_SEC_PEI_HAND_OFF       *SecCoreData;

+  UINT16                     BufferSize;

+  UINT64                     NewDebugPortHandle;

 

-  Mailbox = GetMailboxPointerInIdtEntry ();

-  Mailbox->DebugPortHandle = (UINT64) (UINTN)DebugPortHandle;

+  Phase2Context = (DEBUG_AGENT_PHASE2_CONTEXT *) Context;

+  MailboxLocation = GetLocationSavedMailboxPointerInIdtEntry ();

+  Mailbox = (DEBUG_AGENT_MAILBOX *)(UINTN)(*MailboxLocation);

+  BufferSize = PcdGet16(PcdDebugPortHandleBufferSize);

+  if (Phase2Context->Function == NULL && DebugPortHandle != NULL && BufferSize != 0) {

+    NewDebugPortHandle = (UINT64)(UINTN)AllocateCopyPool (BufferSize, DebugPortHandle);

+  } else {

+    NewDebugPortHandle = (UINT64)(UINTN)DebugPortHandle;

+  }

+  UpdateMailboxContent (Mailbox, DEBUG_MAILBOX_DEBUG_PORT_HANDLE_INDEX, NewDebugPortHandle);

 

   //

   // Trigger one software interrupt to inform HOST

@@ -334,9 +536,9 @@ InitializeDebugAgentPhase2 (
   // If Temporary RAM region is below 128 MB, then send message to 

   // host to disable low memory filtering.

   //

-  Phase2Context = (DEBUG_AGENT_PHASE2_CONTEXT *) Context;

   SecCoreData = (EFI_SEC_PEI_HAND_OFF *)Phase2Context->Context;

   if ((UINTN)SecCoreData->TemporaryRamBase < BASE_128MB && IsHostAttached ()) {

+    SetDebugFlag (DEBUG_AGENT_FLAG_MEMORY_READY, 1);

     TriggerSoftInterrupt (MEMORY_READY_SIGNATURE);

   }

 

diff --git a/SourceLevelDebugPkg/Library/DebugAgent/SecPeiDebugAgent/SecPeiDebugAgentLib.h b/SourceLevelDebugPkg/Library/DebugAgent/SecPeiDebugAgent/SecPeiDebugAgentLib.h
index 9ca5e87f..68bfbf7c 100644
--- a/SourceLevelDebugPkg/Library/DebugAgent/SecPeiDebugAgent/SecPeiDebugAgentLib.h
+++ b/SourceLevelDebugPkg/Library/DebugAgent/SecPeiDebugAgent/SecPeiDebugAgentLib.h
@@ -1,7 +1,7 @@
 /** @file

   Header file for Sec Core Debug Agent Library instance.

 

-  Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -16,7 +16,9 @@
 #define _SEC_CORE_DEBUG_AGENT_LIB_H_

 

 #include <PiPei.h>

-

+#include <Ppi/MemoryDiscovered.h>

+#include <Library/PeiServicesLib.h>

+#include <Library/MemoryAllocationLib.h>

 #include "DebugAgent.h"

 

 typedef struct {

@@ -24,5 +26,39 @@ typedef struct {
   DEBUG_AGENT_CONTINUE    Function;

 } DEBUG_AGENT_PHASE2_CONTEXT;

 

+/**

+  Caller provided function to be invoked at the end of DebugPortInitialize().

+

+  Refer to the descrption for DebugPortInitialize() for more details.

+

+  @param[in] Context           The first input argument of DebugPortInitialize().

+  @param[in] DebugPortHandle   Debug port handle created by Debug Communication Libary.

+

+**/

+VOID

+EFIAPI

+InitializeDebugAgentPhase2 (

+  IN VOID                  *Context,

+  IN DEBUG_PORT_HANDLE     DebugPortHandle

+  );

+

+/**

+  Debug Agent provided notify callback function on Memory Discovered PPI.

+

+  @param[in] PeiServices      Indirect reference to the PEI Services Table.

+  @param[in] NotifyDescriptor Address of the notification descriptor data structure.

+  @param[in] Ppi              Address of the PPI that was installed.

+

+  @retval EFI_SUCCESS If the function completed successfully.

+

+**/

+EFI_STATUS

+EFIAPI

+DebugAgentCallbackMemoryDiscoveredPpi (

+  IN EFI_PEI_SERVICES                     **PeiServices,

+  IN EFI_PEI_NOTIFY_DESCRIPTOR            *NotifyDescriptor,

+  IN VOID                                 *Ppi

+  );

+

 #endif

 

diff --git a/SourceLevelDebugPkg/Library/DebugAgent/SecPeiDebugAgentLib.inf b/SourceLevelDebugPkg/Library/DebugAgent/SecPeiDebugAgentLib.inf
index 577a635a..b81fc16d 100644
--- a/SourceLevelDebugPkg/Library/DebugAgent/SecPeiDebugAgentLib.inf
+++ b/SourceLevelDebugPkg/Library/DebugAgent/SecPeiDebugAgentLib.inf
@@ -1,7 +1,7 @@
 ## @file

 #  Debug Agent library instance for SEC Core and PEI modules.

 #

-#  Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>

+#  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

 #

 #  This program and the accompanying materials

 #  are licensed and made available under the terms and conditions of the BSD License

@@ -70,6 +70,13 @@
   DebugLib

   TimerLib

   PrintLib

+  PeiServicesLib

+  MemoryAllocationLib

+  PeCoffGetEntryPointLib

+  PeCoffExtraActionLib

+

+[Ppis]

+  gEfiPeiMemoryDiscoveredPpiGuid

 

 [Guids]

   gEfiDebugAgentGuid                            ## PRODUCES ## HOB

@@ -77,4 +84,5 @@
 [Pcd]

   gEfiMdePkgTokenSpaceGuid.PcdFSBClock                                  ## CONSUMES

   gEfiSourceLevelDebugPkgTokenSpaceGuid.PcdExceptionsIgnoredByDebugger  ## CONSUMES

+  gEfiSourceLevelDebugPkgTokenSpaceGuid.PcdDebugPortHandleBufferSize    ## CONSUMES

 

diff --git a/SourceLevelDebugPkg/Library/DebugAgent/SmmDebugAgent/SmmDebugAgentLib.c b/SourceLevelDebugPkg/Library/DebugAgent/SmmDebugAgent/SmmDebugAgentLib.c
index 3326c0a0..145fee0f 100644
--- a/SourceLevelDebugPkg/Library/DebugAgent/SmmDebugAgent/SmmDebugAgentLib.c
+++ b/SourceLevelDebugPkg/Library/DebugAgent/SmmDebugAgent/SmmDebugAgentLib.c
@@ -1,7 +1,7 @@
 /** @file

   Debug Agent library implementition.

 

-  Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -17,7 +17,25 @@
 DEBUG_AGENT_MAILBOX         *mMailboxPointer = NULL;

 DEBUG_AGENT_MAILBOX         mLocalMailbox;

 UINTN                       mSavedDebugRegisters[6];

-CONST BOOLEAN               MultiProcessorDebugSupport = FALSE;

+IA32_IDT_GATE_DESCRIPTOR    mIdtEntryTable[33];

+BOOLEAN                     mSkipBreakpoint = FALSE;

+

+CHAR8 mWarningMsgIgnoreSmmEntryBreak[] = "Ignore smmentrybreak setting for SMI issued during DXE debugging!\r\n";

+

+/**

+  Check if debug agent support multi-processor.

+

+  @retval TRUE    Multi-processor is supported.

+  @retval FALSE   Multi-processor is not supported.

+

+**/

+BOOLEAN

+MultiProcessorDebugSupport (

+  VOID

+  )

+{

+  return FALSE;

+}

 

 /**

   Read the Attach/Break-in symbols from the debug port.

@@ -42,6 +60,32 @@ DebugReadBreakSymbol (
 }

 

 /**

+  Get the pointer to Mailbox from the GUIDed HOB.

+

+  @return Pointer to Mailbox.

+

+**/

+DEBUG_AGENT_MAILBOX *

+GetMailboxFromHob (

+  VOID

+  )

+{

+  EFI_HOB_GUID_TYPE        *GuidHob;

+  UINT64                   *MailboxLocation;  

+  DEBUG_AGENT_MAILBOX      *Mailbox;

+

+  GuidHob = GetFirstGuidHob (&gEfiDebugAgentGuid);

+  if (GuidHob == NULL) {

+    return NULL;

+  }

+  MailboxLocation = (UINT64 *) (GET_GUID_HOB_DATA(GuidHob));

+  Mailbox = (DEBUG_AGENT_MAILBOX *)(UINTN)(*MailboxLocation);

+  VerifyMailboxChecksum (Mailbox);

+  

+  return Mailbox;

+}

+

+/**

   Get Debug Agent Mailbox pointer.

 

   @return Mailbox pointer.

@@ -52,6 +96,7 @@ GetMailboxPointer (
   VOID

   )

 {

+  VerifyMailboxChecksum (mMailboxPointer);

   return mMailboxPointer;

 }

 

@@ -66,7 +111,7 @@ GetDebugPortHandle (
   VOID

   )

 {

-  return (DEBUG_PORT_HANDLE) (UINTN)(mMailboxPointer->DebugPortHandle);

+  return (DEBUG_PORT_HANDLE) (UINTN)(GetMailboxPointer()->DebugPortHandle);

 }

 

 /**

@@ -134,16 +179,76 @@ InitializeDebugAgent (
   IN DEBUG_AGENT_CONTINUE  Function  OPTIONAL

   )

 {

-  EFI_STATUS               Status;

-  UINT64                   DebugPortHandle;

+  EFI_STATUS                    Status;

+  UINT64                        DebugPortHandle;

+  IA32_IDT_GATE_DESCRIPTOR      IdtEntry[33];

+  IA32_DESCRIPTOR               IdtDescriptor;

+  IA32_DESCRIPTOR               *Ia32Idtr;

+  IA32_IDT_ENTRY                *Ia32IdtEntry;

+  IA32_DESCRIPTOR               Idtr;

+  UINT16                        IdtEntryCount;

+  DEBUG_AGENT_MAILBOX           *Mailbox;

+  UINT64                        *MailboxLocation;

 

   switch (InitFlag) {

   case DEBUG_AGENT_INIT_SMM:

-    Status = EfiGetSystemConfigurationTable (&gEfiDebugAgentGuid, (VOID **) &mMailboxPointer);

-    if (EFI_ERROR (Status) || mMailboxPointer == NULL) {

-      ZeroMem (&mLocalMailbox, sizeof (DEBUG_AGENT_MAILBOX));

-      mMailboxPointer = &mLocalMailbox;

+    //

+    // Check if Debug Agent initialized in DXE phase

+    //

+    Status = EfiGetSystemConfigurationTable (&gEfiDebugAgentGuid, (VOID **) &Mailbox);

+    if (Status == EFI_SUCCESS && Mailbox != NULL) {

+      VerifyMailboxChecksum (Mailbox);

+      mMailboxPointer = Mailbox;

+      break;

     }

+    //

+    // Check if Debug Agent initialized in SEC/PEI phase

+    //

+    Mailbox = GetMailboxFromHob (); 

+    if (Mailbox != NULL) {

+      mMailboxPointer = Mailbox;

+      break;

+    }

+    //

+    // Debug Agent was not initialized before, uset the local mailbox.

+    //

+    ZeroMem (&mLocalMailbox, sizeof (DEBUG_AGENT_MAILBOX));

+    Mailbox = &mLocalMailbox;

+    //

+    // Save original IDT entries

+    //

+    AsmReadIdtr (&IdtDescriptor);      

+    CopyMem (&IdtEntry, (VOID *)IdtDescriptor.Base, 33 * sizeof(IA32_IDT_GATE_DESCRIPTOR));

+    //

+    // Initialized Debug Agent

+    //

+    InitializeDebugIdt ();

+    DebugPortHandle = (UINT64) (UINTN)DebugPortInitialize ((DEBUG_PORT_HANDLE) (UINTN)Mailbox->DebugPortHandle, NULL);

+    UpdateMailboxContent (Mailbox, DEBUG_MAILBOX_DEBUG_PORT_HANDLE_INDEX, DebugPortHandle);

+    mMailboxPointer = Mailbox;

+    //

+    // Trigger one software interrupt to inform HOST

+    //

+    TriggerSoftInterrupt (SYSTEM_RESET_SIGNATURE);

+

+    SetDebugFlag (DEBUG_AGENT_FLAG_MEMORY_READY, 1);

+    //

+    // Memory has been ready

+    //

+    if (IsHostAttached ()) {

+      //

+      // Trigger one software interrupt to inform HOST

+      //

+      TriggerSoftInterrupt (MEMORY_READY_SIGNATURE);

+    }

+    //

+    // Find and report PE/COFF image info to HOST

+    //  

+    FindAndReportModuleImageInfo (SIZE_4KB);

+    //

+    // Restore saved IDT entries

+    //     

+    CopyMem ((VOID *)IdtDescriptor.Base, &IdtEntry, 33 * sizeof(IA32_IDT_GATE_DESCRIPTOR));

 

     break;

 

@@ -151,14 +256,24 @@ InitializeDebugAgent (
     SaveDebugRegister ();

     InitializeDebugIdt ();

 

-    if (mMailboxPointer != NULL) {

+    Mailbox = GetMailboxPointer ();

+    if (GetDebugFlag (DEBUG_AGENT_FLAG_AGENT_IN_PROGRESS) == 1) {

       //

-      // Initialize debug communication port

+      // If Debug Agent has been communicaton state with HOST, we need skip

+      // any break points set in SMM, set Skip Breakpoint flag

       //

-      DebugPortHandle = (UINT64) (UINTN)DebugPortInitialize ((DEBUG_PORT_HANDLE) (UINTN)mMailboxPointer->DebugPortHandle, NULL);

-      mMailboxPointer->DebugPortHandle = DebugPortHandle;

-

-      if (mMailboxPointer->DebugFlag.BreakOnNextSmi == 1) {

+      mSkipBreakpoint = TRUE;

+    }

+    if (GetDebugFlag (DEBUG_AGENT_FLAG_BREAK_ON_NEXT_SMI) == 1) {

+      if (mSkipBreakpoint) {

+        //

+        // Print warning message if ignore smm entry break

+        //

+        DebugPortWriteBuffer ((DEBUG_PORT_HANDLE) (UINTN)Mailbox->DebugPortHandle,

+                               (UINT8 *)mWarningMsgIgnoreSmmEntryBreak,

+                               AsciiStrLen (mWarningMsgIgnoreSmmEntryBreak)

+                               );

+      } else {

         //

         // If SMM entry break is set, SMM code will be break at here.

         //

@@ -168,8 +283,56 @@ InitializeDebugAgent (
     break;

 

   case DEBUG_AGENT_INIT_EXIT_SMI:

+    Mailbox = GetMailboxPointer ();

+    //

+    // Clear Skip Breakpoint flag

+    //

+    mSkipBreakpoint = FALSE;

     RestoreDebugRegister ();

     break;

+

+  case DEBUG_AGENT_INIT_THUNK_PEI_IA32TOX64:

+    if (Context == NULL) {

+      DEBUG ((EFI_D_ERROR, "DebugAgent: Input parameter Context cannot be NULL!\n"));

+      CpuDeadLoop ();

+    } else {

+      Ia32Idtr =  (IA32_DESCRIPTOR *) Context;

+      Ia32IdtEntry = (IA32_IDT_ENTRY *)(Ia32Idtr->Base);

+      MailboxLocation = (UINT64 *) (UINTN) (Ia32IdtEntry[DEBUG_MAILBOX_VECTOR].Bits.OffsetLow + 

+                                           (Ia32IdtEntry[DEBUG_MAILBOX_VECTOR].Bits.OffsetHigh << 16));

+      mMailboxPointer = (DEBUG_AGENT_MAILBOX *)(UINTN)(*MailboxLocation);

+      VerifyMailboxChecksum (mMailboxPointer);

+      //

+      // Get original IDT address and size.

+      //

+      AsmReadIdtr ((IA32_DESCRIPTOR *) &Idtr);

+      IdtEntryCount = (UINT16) ((Idtr.Limit + 1) / sizeof (IA32_IDT_GATE_DESCRIPTOR));

+      if (IdtEntryCount < 33) {

+        Idtr.Limit = (UINT16) (sizeof (IA32_IDT_GATE_DESCRIPTOR) * 33 - 1);

+        Idtr.Base  = (UINTN) &mIdtEntryTable;

+        ZeroMem (&mIdtEntryTable, Idtr.Limit + 1);

+        AsmWriteIdtr ((IA32_DESCRIPTOR *) &Idtr);

+      }

+

+      InitializeDebugIdt ();

+      //

+      // Initialize Debug Timer hardware and enable interrupt.

+      //

+      InitializeDebugTimer ();

+      EnableInterrupts ();

+

+      FindAndReportModuleImageInfo (SIZE_4KB);

+    }

+    break;

+

+  default:

+    //

+    // Only DEBUG_AGENT_INIT_PREMEM_SEC and DEBUG_AGENT_INIT_POSTMEM_SEC are allowed for this 

+    // Debug Agent library instance.

+    //

+    DEBUG ((EFI_D_ERROR, "Debug Agent: The InitFlag value is not allowed!\n"));

+    CpuDeadLoop ();

+    break;    

   }

 }

 

diff --git a/SourceLevelDebugPkg/Library/DebugAgent/SmmDebugAgentLib.inf b/SourceLevelDebugPkg/Library/DebugAgent/SmmDebugAgentLib.inf
index f62d9975..9ed314d4 100644
--- a/SourceLevelDebugPkg/Library/DebugAgent/SmmDebugAgentLib.inf
+++ b/SourceLevelDebugPkg/Library/DebugAgent/SmmDebugAgentLib.inf
@@ -1,7 +1,7 @@
 ## @file

 #  Debug Agent library instance for SMM modules.

 #

-#  Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>

+#  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

 #

 #  This program and the accompanying materials

 #  are licensed and made available under the terms and conditions of the BSD License

@@ -15,7 +15,7 @@
 

 [Defines]

   INF_VERSION                    = 0x00010005

-  BASE_NAME                      = SecDebugAgentLib

+  BASE_NAME                      = SmmDebugAgentLib

   FILE_GUID                      = CB07D74C-598F-4268-A5D1-644FB4A481E8

   MODULE_TYPE                    = DXE_SMM_DRIVER

   VERSION_STRING                 = 0.7

@@ -69,11 +69,14 @@
   LocalApicLib

   TimerLib

   PrintLib

+  PeCoffExtraActionLib

+  PeCoffGetEntryPointLib

 

 [Guids]

   gEfiDebugAgentGuid                            ## CONSUMES ## Configuration Table

 

 [Pcd]

-  gEfiMdePkgTokenSpaceGuid.PcdFSBClock                                  ## CONSUMES

-  gEfiSourceLevelDebugPkgTokenSpaceGuid.PcdExceptionsIgnoredByDebugger  ## CONSUMES

+  gEfiMdePkgTokenSpaceGuid.PcdFSBClock                                             ## CONSUMES

+  ## Skip Page Fault exception (14) by default in SMM

+  gEfiSourceLevelDebugPkgTokenSpaceGuid.PcdExceptionsIgnoredByDebugger|0x00004000  ## CONSUMES

 

diff --git a/SourceLevelDebugPkg/Library/DebugCommunicationLibSerialPort/DebugCommunicationLibSerialPort.c b/SourceLevelDebugPkg/Library/DebugCommunicationLibSerialPort/DebugCommunicationLibSerialPort.c
index dd88e7d6..95232165 100644
--- a/SourceLevelDebugPkg/Library/DebugCommunicationLibSerialPort/DebugCommunicationLibSerialPort.c
+++ b/SourceLevelDebugPkg/Library/DebugCommunicationLibSerialPort/DebugCommunicationLibSerialPort.c
@@ -1,7 +1,7 @@
 /** @file

   Debug Port Library implementation based on serial port.

 

-  Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -18,6 +18,80 @@
 #include <Library/SerialPortLib.h>

 #include <Library/TimerLib.h>

 #include <Library/DebugLib.h>

+#include <Library/BaseLib.h>

+#include <Library/BaseMemoryLib.h>

+

+#pragma pack(1)

+//

+// The internal data structure of DEBUG_PORT_HANDLE, which stores some

+// important datum which are used across various phases.

+//

+typedef struct _SERIAL_DEBUG_PORT_HANDLE{

+  //

+  // Timter settings

+  //

+  UINT64       TimerFrequency;

+  UINT64       TimerCycle;

+  BOOLEAN      TimerCountDown;

+} SERIAL_DEBUG_PORT_HANDLE;

+#pragma pack()

+

+//

+// The global variable which can be used after memory is ready.

+//

+SERIAL_DEBUG_PORT_HANDLE     mSerialDebugPortHandle;

+

+/**

+  Check if the timer is timeout.

+  

+  @param[in] SerialDebugPortHandle  Pointer to Serial Debug port handle

+  @param[in] Timer                  The start timer from the begin.

+  @param[in] TimeoutTicker          Ticker number need time out.

+

+  @return TRUE  Timer time out occurs.

+  @retval FALSE Timer does not time out.

+

+**/

+BOOLEAN

+IsTimerTimeout (

+  IN SERIAL_DEBUG_PORT_HANDLE   *SerialDebugPortHandle,

+  IN UINT64                     Timer,

+  IN UINT64                     TimeoutTicker

+  )

+{

+  UINT64  CurrentTimer;

+  UINT64  Delta;

+

+  CurrentTimer = GetPerformanceCounter ();

+

+  if (SerialDebugPortHandle->TimerCountDown) {

+    //

+    // The timer counter counts down.  Check for roll over condition.

+    //

+    if (CurrentTimer < Timer) {

+      Delta = Timer - CurrentTimer;

+    } else {

+      //

+      // Handle one roll-over. 

+      //

+      Delta = SerialDebugPortHandle->TimerCycle - (CurrentTimer - Timer);

+    }

+  } else {

+    //

+    // The timer counter counts up.  Check for roll over condition.

+    //

+    if (CurrentTimer > Timer) {

+      Delta = CurrentTimer - Timer;

+    } else {

+      //

+      // Handle one roll-over. 

+      //

+      Delta = SerialDebugPortHandle->TimerCycle - (Timer - CurrentTimer);

+    }

+  }

+ 

+  return (BOOLEAN) (Delta >= TimeoutTicker);

+}

 

 /**

   Initialize the debug port.

@@ -62,7 +136,42 @@ DebugPortInitialize (
   IN DEBUG_PORT_CONTINUE  Function

   )

 {

-  RETURN_STATUS      Status;

+  RETURN_STATUS              Status;

+  SERIAL_DEBUG_PORT_HANDLE   Handle;

+  SERIAL_DEBUG_PORT_HANDLE   *SerialDebugPortHandle;

+  UINT64                     TimerStartValue;

+  UINT64                     TimerEndValue;

+

+  //

+  // Validate the PCD PcdDebugPortHandleBufferSize value 

+  //

+  ASSERT (PcdGet16 (PcdDebugPortHandleBufferSize) == sizeof (SERIAL_DEBUG_PORT_HANDLE));

+

+  if (Context != NULL && Function == NULL) {

+    SerialDebugPortHandle = (SERIAL_DEBUG_PORT_HANDLE *)Context;

+  } else {

+    ZeroMem (&Handle, sizeof (SERIAL_DEBUG_PORT_HANDLE));

+    SerialDebugPortHandle = &Handle;

+  }

+  SerialDebugPortHandle->TimerFrequency = GetPerformanceCounterProperties (

+                                            &TimerStartValue,

+                                            &TimerEndValue

+                                            );

+  DEBUG ((EFI_D_INFO, "Serial Debug Port: TimerFrequency  = 0x%lx\n", SerialDebugPortHandle->TimerFrequency)); 

+  DEBUG ((EFI_D_INFO, "Serial Debug Port: TimerStartValue = 0x%lx\n", TimerStartValue)); 

+  DEBUG ((EFI_D_INFO, "Serial Debug Port: TimerEndValue   = 0x%lx\n", TimerEndValue)); 

+

+  if (TimerEndValue < TimerStartValue) {

+    SerialDebugPortHandle->TimerCountDown = TRUE;

+    SerialDebugPortHandle->TimerCycle     = TimerStartValue - TimerEndValue;

+  } else {

+    SerialDebugPortHandle->TimerCountDown = FALSE;

+    SerialDebugPortHandle->TimerCycle     = TimerEndValue - TimerStartValue;

+  }  

+

+  if (Function == NULL && Context != NULL) {

+    return (DEBUG_PORT_HANDLE *) Context;

+  }

 

   Status = SerialPortInitialize ();

   if (RETURN_ERROR(Status)) {

@@ -70,10 +179,12 @@ DebugPortInitialize (
   }

 

   if (Function != NULL) {

-    Function (Context, NULL);

+    Function (Context, SerialDebugPortHandle);

+  } else {

+    CopyMem(&mSerialDebugPortHandle, SerialDebugPortHandle, sizeof (SERIAL_DEBUG_PORT_HANDLE));

   }

 

-  return NULL;

+  return (DEBUG_PORT_HANDLE)(UINTN)&mSerialDebugPortHandle;

 }

 

 /**

@@ -102,25 +213,62 @@ DebugPortReadBuffer (
   IN UINTN                 Timeout

   )

 {

-  UINTN                Index;

-  INTN                 Elapsed;

-

-  for (Index = 0; Index < NumberOfBytes; Index ++) {

-    Elapsed = (INTN) Timeout;

-    while (TRUE) {

-      if (SerialPortPoll () || Timeout == 0) {

-        SerialPortRead (Buffer + Index, 1);

-        break;

-      }

-      MicroSecondDelay (1000);

-      Elapsed -= 1000;

-      if (Elapsed < 0) {

+  SERIAL_DEBUG_PORT_HANDLE *SerialDebugPortHandle;

+  UINTN                    Index;

+  UINT64                   Begin;

+  UINT64                   TimeoutTicker;

+  UINT64                   TimerRound;

+  

+  //

+  // If Handle is NULL, it means memory is ready for use.

+  // Use global variable to store handle value.

+  //

+  if (Handle == NULL) {

+    SerialDebugPortHandle = &mSerialDebugPortHandle;

+  } else {

+    SerialDebugPortHandle = (SERIAL_DEBUG_PORT_HANDLE *)Handle;

+  }

+

+  Begin         = 0;

+  TimeoutTicker = 0;  

+  TimerRound    = 0;

+  if (Timeout != 0) {

+    Begin = GetPerformanceCounter ();

+    TimeoutTicker = DivU64x32 (

+                      MultU64x64 (

+                        SerialDebugPortHandle->TimerFrequency,

+                        Timeout

+                        ),

+                      1000000u

+                      );

+    TimerRound = DivU64x64Remainder (

+                   TimeoutTicker,

+                   DivU64x32 (SerialDebugPortHandle->TimerCycle, 2),

+                   &TimeoutTicker

+                   );

+  }

+  Index = 0;

+  while (Index < NumberOfBytes) {

+    if (SerialPortPoll () || Timeout == 0) {

+      SerialPortRead (Buffer + Index, 1);

+      Index ++; 

+      continue;

+    }

+    if (TimerRound == 0) {

+      if (IsTimerTimeout (SerialDebugPortHandle, Begin, TimeoutTicker)) {

+        //

+        // If time out occurs.

+        //

         return 0;

       }

+    } else {

+      if (IsTimerTimeout (SerialDebugPortHandle, Begin, DivU64x32 (SerialDebugPortHandle->TimerCycle, 2))) {

+        TimerRound --;

+      }

     }

   }

 

-  return NumberOfBytes;

+  return Index;

 }

 

 /**

diff --git a/SourceLevelDebugPkg/Library/DebugCommunicationLibSerialPort/DebugCommunicationLibSerialPort.inf b/SourceLevelDebugPkg/Library/DebugCommunicationLibSerialPort/DebugCommunicationLibSerialPort.inf
index 6d36cefd..6ee5ddcc 100644
--- a/SourceLevelDebugPkg/Library/DebugCommunicationLibSerialPort/DebugCommunicationLibSerialPort.inf
+++ b/SourceLevelDebugPkg/Library/DebugCommunicationLibSerialPort/DebugCommunicationLibSerialPort.inf
@@ -1,7 +1,7 @@
 ## @file

 #  Debug Communication Library instance based on serila port.

 #

-#  Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>

+#  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

 #

 #  This program and the accompanying materials

 #  are licensed and made available under the terms and conditions of the BSD License

@@ -36,4 +36,10 @@
   SerialPortLib

   TimerLib

   DebugLib

-  

+  BaseMemoryLib

+  BaseLib

+

+[PCD]

+  ## The value of data buffer size used for Serial debug port handle.

+  ## It should be equal to sizeof (SERIAL_DEBUG_PORT_HANDLE).

+  gEfiSourceLevelDebugPkgTokenSpaceGuid.PcdDebugPortHandleBufferSize|17

diff --git a/SourceLevelDebugPkg/Library/DebugCommunicationLibUsb/DebugCommunicationLibUsb.c b/SourceLevelDebugPkg/Library/DebugCommunicationLibUsb/DebugCommunicationLibUsb.c
index aafd52d3..c08d45b7 100644
--- a/SourceLevelDebugPkg/Library/DebugCommunicationLibUsb/DebugCommunicationLibUsb.c
+++ b/SourceLevelDebugPkg/Library/DebugCommunicationLibUsb/DebugCommunicationLibUsb.c
@@ -1,7 +1,7 @@
 /** @file

   Debug Port Library implementation based on usb debug port.

 

-  Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -147,6 +147,12 @@ typedef struct _USB_DEBUG_PORT_HANDLE{
   // The data buffer. Maximum length is 8 bytes.

   //

   UINT8        Data[8];

+  //

+  // Timter settings

+  //

+  UINT64       TimerFrequency;

+  UINT64       TimerCycle;

+  BOOLEAN      TimerCountDown;

 } USB_DEBUG_PORT_HANDLE;

 #pragma pack()

 

@@ -156,6 +162,58 @@ typedef struct _USB_DEBUG_PORT_HANDLE{
 USB_DEBUG_PORT_HANDLE     mUsbDebugPortHandle;

 

 /**

+  Check if the timer is timeout.

+  

+  @param[in] UsbDebugPortHandle  Pointer to USB Debug port handle

+  @param[in] Timer               The start timer from the begin.

+  @param[in] TimeoutTicker       Ticker number need time out.

+

+  @return TRUE  Timer time out occurs.

+  @retval FALSE Timer does not time out.

+

+**/

+BOOLEAN

+IsTimerTimeout (

+  IN USB_DEBUG_PORT_HANDLE   *UsbDebugPortHandle,

+  IN UINT64                  Timer,

+  IN UINT64                  TimeoutTicker

+  )

+{

+  UINT64  CurrentTimer;

+  UINT64  Delta;

+

+  CurrentTimer = GetPerformanceCounter ();

+

+  if (UsbDebugPortHandle->TimerCountDown) {

+    //

+    // The timer counter counts down.  Check for roll over condition.

+    //

+    if (CurrentTimer < Timer) {

+      Delta = Timer - CurrentTimer;

+    } else {

+      //

+      // Handle one roll-over. 

+      //

+      Delta = UsbDebugPortHandle->TimerCycle - (CurrentTimer - Timer);

+    }

+  } else {

+    //

+    // The timer counter counts up.  Check for roll over condition.

+    //

+    if (CurrentTimer > Timer) {

+      Delta = CurrentTimer - Timer;

+    } else {

+      //

+      // Handle one roll-over. 

+      //

+      Delta = UsbDebugPortHandle->TimerCycle - (Timer - CurrentTimer);

+    }

+  }

+ 

+  return (BOOLEAN) (Delta >= TimeoutTicker);

+}

+

+/**

   Calculate the usb debug port bar address.

 

   @param  DebugPortOffset    Get usb debug port offset in the usb debug port memory space.

@@ -617,28 +675,21 @@ InitializeUsbDebugHardware (
   if (((MmioRead32((UINTN)&UsbDebugPortRegister->ControlStatus) & (USB_DEBUG_PORT_OWNER | USB_DEBUG_PORT_IN_USE))

        != (USB_DEBUG_PORT_OWNER | USB_DEBUG_PORT_IN_USE)) || (Handle->Initialized == USBDBG_RESET)) {

     //

-    // If the host controller is not halted, then halt it.

-    //

-    if ((MmioRead32((UINTN)UsbStatus) & BIT12) == 0) {

-      MmioAnd32((UINTN)UsbCmd, (UINT32)~BIT0);

-      while ((MmioRead32((UINTN)UsbStatus) & BIT12) == 0);

-    }

-    //

-    // reset the host controller.

-    //

-    MmioOr32((UINTN)UsbCmd, BIT1);

+    // If the host controller is halted, then reset and restart it.

     //

-    // ensure that the host controller is reset.

-    //

-    while (MmioRead32((UINTN)UsbCmd) & BIT1);

+    if ((MmioRead32((UINTN)UsbStatus) & BIT12) != 0) {

+      //

+      // reset the host controller.

+      //

+      MmioOr32((UINTN)UsbCmd, BIT1);

+      //

+      // ensure that the host controller is reset.

+      //

+      while ((MmioRead32((UINTN)UsbCmd) & BIT1) != 0);

 

-    //

-    // Start the host controller if it's not running

-    //

-    if (MmioRead32((UINTN)UsbStatus) & BIT12) {

       MmioOr32((UINTN)UsbCmd, BIT0);

       // ensure that the host controller is started (HALTED bit must be cleared)

-      while (MmioRead32((UINTN)UsbStatus) & BIT12);

+      while ((MmioRead32((UINTN)UsbStatus) & BIT12) != 0);

     }

 

     //

@@ -780,6 +831,9 @@ DebugPortReadBuffer (
   UINTN                     Remaining;

   UINT8                     Index;

   UINT8                     Length;

+  UINT64                    Begin;

+  UINT64                    TimeoutTicker;

+  UINT64                    TimerRound;

 

   if (NumberOfBytes == 0 || Buffer == NULL) {

     return 0;

@@ -834,14 +888,43 @@ DebugPortReadBuffer (
   //

   // If Timeout is equal to 0, then it means it should always wait until all datum required are received.

   //

-  if (Timeout == 0) {

-    Timeout = 0xFFFFFFFF;

+  Begin         = 0;

+  TimeoutTicker = 0;  

+  TimerRound    = 0;

+  if (Timeout != 0) {

+    Begin = GetPerformanceCounter ();

+    TimeoutTicker = DivU64x32 (

+                      MultU64x64 (

+                        UsbDebugPortHandle->TimerFrequency,

+                        Timeout

+                        ),

+                      1000000u

+                      );

+    TimerRound = DivU64x64Remainder (

+                   TimeoutTicker,

+                   DivU64x32 (UsbDebugPortHandle->TimerCycle, 2),

+                   &TimeoutTicker

+                   );

   }

 

   //

   // Read remaining data by executing one or more usb debug transfer transactions at usb debug port hw.

   //

-  while ((Total < NumberOfBytes) && (Timeout != 0)) {

+  while (Total < NumberOfBytes) {

+    if (Timeout != 0) {

+      if (TimerRound == 0) {

+        if (IsTimerTimeout (UsbDebugPortHandle, Begin, TimeoutTicker)) {

+          //

+          // If time out occurs.

+          //

+          return 0;

+        }

+      } else {

+        if (IsTimerTimeout (UsbDebugPortHandle, Begin, DivU64x32 (UsbDebugPortHandle->TimerCycle, 2))) {

+          TimerRound --;

+        }

+      }

+    }

     Remaining = NumberOfBytes - Total;

     if (Remaining >= USB_DEBUG_PORT_MAX_PACKET_SIZE) {

       Status = UsbDebugPortIn(UsbDebugPortRegister, Buffer + Total, &Received, INPUT_PID, 0x7f, 0x82, UsbDebugPortHandle->BulkInToggle);

@@ -850,46 +933,44 @@ DebugPortReadBuffer (
         return Total;

       }

     } else {

-        Status = UsbDebugPortIn(UsbDebugPortRegister, &UsbDebugPortHandle->Data[0], &Received, INPUT_PID, 0x7f, 0x82, UsbDebugPortHandle->BulkInToggle);

+      Status = UsbDebugPortIn(UsbDebugPortRegister, &UsbDebugPortHandle->Data[0], &Received, INPUT_PID, 0x7f, 0x82, UsbDebugPortHandle->BulkInToggle);

 

-        if (RETURN_ERROR(Status)) {

-          return Total;

-        }

+      if (RETURN_ERROR(Status)) {

+        return Total;

+      }

 

-        UsbDebugPortHandle->DataCount = Received;

+      UsbDebugPortHandle->DataCount = Received;

 

-        if (Remaining <= Received) {

-          Length = (UINT8)Remaining;

-        } else {

-          Length = (UINT8)Received;

-        }

+      if (Remaining <= Received) {

+        Length = (UINT8)Remaining;

+      } else {

+        Length = (UINT8)Received;

+      }

 

-        //

-        // Copy required data from the data buffer to user buffer.

-        //

-        for (Index = 0; Index < Length; Index++) {

-          (Buffer + Total)[Index] = UsbDebugPortHandle->Data[Index];

-          UsbDebugPortHandle->DataCount--;

-        }

+      //

+      // Copy required data from the data buffer to user buffer.

+      //

+      for (Index = 0; Index < Length; Index++) {

+        (Buffer + Total)[Index] = UsbDebugPortHandle->Data[Index];

+        UsbDebugPortHandle->DataCount--;

+      }

 

-        //

-        // reorder the data buffer to make available data arranged from the beginning of the data buffer.

-        //

-        for (Index = 0; Index < Received - Length; Index++) {

-          if (Length + Index >= 8) {

-            return 0;

-          }

-          UsbDebugPortHandle->Data[Index] = UsbDebugPortHandle->Data[Length + Index];

+      //

+      // reorder the data buffer to make available data arranged from the beginning of the data buffer.

+      //

+      for (Index = 0; Index < Received - Length; Index++) {

+        if (Length + Index >= 8) {

+          return 0;

         }

-        //

-        // fixup the real received length in Buffer.

-        //

-        Received = Length;

+        UsbDebugPortHandle->Data[Index] = UsbDebugPortHandle->Data[Length + Index];

       }

-      UsbDebugPortHandle->BulkInToggle ^= 1;

-

-      Total += Received;

-      Timeout -= 100;

+      //

+      // fixup the real received length in Buffer.

+      //

+      Received = Length;

+    }

+    UsbDebugPortHandle->BulkInToggle ^= 1;

+    Total += Received;

   }

 

   return Total;

@@ -1118,11 +1199,40 @@ DebugPortInitialize (
 {

   RETURN_STATUS             Status;

   USB_DEBUG_PORT_HANDLE     Handle;

-
  if (Function == NULL && Context != NULL) {

-    return (DEBUG_PORT_HANDLE *) Context;

+  USB_DEBUG_PORT_HANDLE     *UsbDebugPortHandle;

+  UINT64                    TimerStartValue;

+  UINT64                    TimerEndValue;

+
  //

+  // Validate the PCD PcdDebugPortHandleBufferSize value 

+  //

+  ASSERT (PcdGet16 (PcdDebugPortHandleBufferSize) == sizeof (USB_DEBUG_PORT_HANDLE));

+

+  if (Function == NULL && Context != NULL) {

+    UsbDebugPortHandle = (USB_DEBUG_PORT_HANDLE *)Context;

+  } else {

+    ZeroMem(&Handle, sizeof (USB_DEBUG_PORT_HANDLE));

+    UsbDebugPortHandle = &Handle;

   }

 

-  ZeroMem(&Handle, sizeof (USB_DEBUG_PORT_HANDLE));

+  UsbDebugPortHandle->TimerFrequency = GetPerformanceCounterProperties (

+                                         &TimerStartValue,

+                                         &TimerEndValue

+                                         );

+  DEBUG ((EFI_D_INFO, "USB Debug Port: TimerFrequency  = 0x%lx\n", UsbDebugPortHandle->TimerFrequency)); 

+  DEBUG ((EFI_D_INFO, "USB Debug Port: TimerStartValue = 0x%lx\n", TimerStartValue)); 

+  DEBUG ((EFI_D_INFO, "USB Debug Port: TimerEndValue   = 0x%lx\n", TimerEndValue)); 

+

+  if (TimerEndValue < TimerStartValue) {

+    UsbDebugPortHandle->TimerCountDown = TRUE;

+    UsbDebugPortHandle->TimerCycle     = TimerStartValue - TimerEndValue;

+  } else {

+    UsbDebugPortHandle->TimerCountDown = FALSE;

+    UsbDebugPortHandle->TimerCycle     = TimerEndValue - TimerStartValue;

+  }   

+

+  if (Function == NULL && Context != NULL) {

+    return (DEBUG_PORT_HANDLE *) Context;

+  }

 

   Status = CalculateUsbDebugPortBar(&Handle.DebugPortOffset, &Handle.DebugPortBarNumber);

   if (RETURN_ERROR (Status)) {

@@ -1156,7 +1266,7 @@ DebugPortInitialize (
     DEBUG ((EFI_D_ERROR, "UsbDbg: Start EHCI debug port initialization!\n"));

     Status = InitializeUsbDebugHardware (&Handle);

     if (RETURN_ERROR(Status)) {

-      DEBUG ((EFI_D_ERROR, "UsbDbg: Initialization failed, please check if USB debug cable is plugged into EHCI debug port correctly!\n"));

+      DEBUG ((EFI_D_ERROR, "UsbDbg: Failed, please check if USB debug cable is plugged into EHCI debug port correctly!\n"));

       goto Exit;

     }

   }

diff --git a/SourceLevelDebugPkg/Library/DebugCommunicationLibUsb/DebugCommunicationLibUsb.inf b/SourceLevelDebugPkg/Library/DebugCommunicationLibUsb/DebugCommunicationLibUsb.inf
index 61e8a7f1..37e365a7 100644
--- a/SourceLevelDebugPkg/Library/DebugCommunicationLibUsb/DebugCommunicationLibUsb.inf
+++ b/SourceLevelDebugPkg/Library/DebugCommunicationLibUsb/DebugCommunicationLibUsb.inf
@@ -1,7 +1,7 @@
 ## @file

 #  Debug Communication Library instance based on usb debug port.

 #

-#  Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>

+#  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

 #

 #  This program and the accompanying materials

 #  are licensed and made available under the terms and conditions of the BSD License

@@ -44,6 +44,9 @@
   ## The pci address of ehci host controller, in which usb debug feature is enabled.

   ## The format of pci address please refer to SourceLevelDebugPkg.dec

   gEfiSourceLevelDebugPkgTokenSpaceGuid.PcdUsbEhciPciAddress

+  ## The value of data buffer size used for USB debug port handle.

+  ## It should be equal to sizeof (USB_DEBUG_PORT_HANDLE).

+  gEfiSourceLevelDebugPkgTokenSpaceGuid.PcdDebugPortHandleBufferSize|40

 

 [LibraryClasses]

   TimerLib

diff --git a/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/Ia32/IntHandler.S b/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/Ia32/IntHandler.S
new file mode 100644
index 00000000..69c90378
--- /dev/null
+++ b/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/Ia32/IntHandler.S
@@ -0,0 +1,28 @@
+#------------------------------------------------------------------------------

+#

+# Copyright (c) 2013, Intel Corporation. All rights reserved.<BR>

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php.

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+# Module Name:

+#

+#   IntHandler.S

+#

+# Abstract:

+#

+#   Assembly interrupt handler function.

+#

+#------------------------------------------------------------------------------

+

+ASM_GLOBAL ASM_PFX(AsmInterruptHandle)

+

+.text

+ASM_PFX(AsmInterruptHandle):

+   cli

+   movb   $1, %al

+   iretl

diff --git a/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/Ia32/IntHandler.asm b/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/Ia32/IntHandler.asm
new file mode 100644
index 00000000..ce9c03b4
--- /dev/null
+++ b/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/Ia32/IntHandler.asm
@@ -0,0 +1,33 @@
+;------------------------------------------------------------------------------

+;

+; Copyright (c) 2013, Intel Corporation. All rights reserved.<BR>

+; This program and the accompanying materials

+; are licensed and made available under the terms and conditions of the BSD License

+; which accompanies this distribution.  The full text of the license may be found at

+; http://opensource.org/licenses/bsd-license.php.

+;

+; THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+; WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+;

+; Module Name:

+;

+;   IntHandler.asm

+;

+; Abstract:

+;

+;   Assembly interrupt handler function.

+;

+;------------------------------------------------------------------------------

+

+

+.686p

+.model  flat,c

+

+public AsmInterruptHandle

+

+.code

+AsmInterruptHandle:

+    cli

+    mov   al, 1

+    iretd

+END

diff --git a/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/Ia32/IntHandlerFuncs.c b/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/Ia32/IntHandlerFuncs.c
new file mode 100644
index 00000000..b2d4c37a
--- /dev/null
+++ b/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/Ia32/IntHandlerFuncs.c
@@ -0,0 +1,96 @@
+/** @file

+  Ia32 arch functions to access IDT vector.

+

+  Copyright (c) 2013, Intel Corporation. All rights reserved.<BR>

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php.

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include <PeCoffExtraActionLib.h>

+

+/**

+  Read IDT entry to check if IDT entries are setup by Debug Agent.

+

+  @param[in]  IdtDescriptor      Pointer to IDT Descriptor.

+

+  @retval  TRUE     IDT entries were setup by Debug Agent.

+  @retval  FALSE    IDT entries were not setuo by Debug Agent.

+

+**/

+BOOLEAN 

+CheckDebugAgentHandler (

+  IN  IA32_DESCRIPTOR            *IdtDescriptor

+  )

+{

+  IA32_IDT_GATE_DESCRIPTOR   *IdtEntry;

+  UINTN                      InterruptHandler;

+

+  IdtEntry = (IA32_IDT_GATE_DESCRIPTOR *) IdtDescriptor->Base;

+  if (IdtEntry == NULL) {

+    return FALSE;

+  }

+

+  InterruptHandler = IdtEntry[0].Bits.OffsetLow + (IdtEntry[0].Bits.OffsetHigh << 16);

+  if (InterruptHandler >= 4 &&  *(UINT32 *)(InterruptHandler - 4) == AGENT_HANDLER_SIGNATURE) {

+    return TRUE;

+  } else {

+    return FALSE;

+  }

+}

+

+/**

+  Save IDT entry for INT1 and update it. 

+

+  @param[in]  IdtDescriptor      Pointer to IDT Descriptor.

+  @param[out] SavedIdtEntry      Original IDT entry returned.

+

+**/

+VOID

+SaveAndUpdateIdtEntry1 (

+  IN  IA32_DESCRIPTOR            *IdtDescriptor,

+  OUT IA32_IDT_GATE_DESCRIPTOR   *SavedIdtEntry

+  )

+{

+  IA32_IDT_GATE_DESCRIPTOR   *IdtEntry;

+  UINT16                     CodeSegment;

+  UINTN                      InterruptHandler;

+  

+  IdtEntry = (IA32_IDT_GATE_DESCRIPTOR *) IdtDescriptor->Base;

+  CopyMem (SavedIdtEntry, &IdtEntry[1], sizeof (IA32_IDT_GATE_DESCRIPTOR));

+

+    //

+  // Use current CS as the segment selector of interrupt gate in IDT

+  //

+  CodeSegment = AsmReadCs ();

+

+  InterruptHandler = (UINTN) &AsmInterruptHandle;

+  IdtEntry[1].Bits.OffsetLow  = (UINT16)(UINTN)InterruptHandler;

+  IdtEntry[1].Bits.OffsetHigh = (UINT16)((UINTN)InterruptHandler >> 16);

+  IdtEntry[1].Bits.Selector   = CodeSegment;

+  IdtEntry[1].Bits.GateType   = IA32_IDT_GATE_TYPE_INTERRUPT_32;

+}

+

+/**

+  Restore IDT entry for INT1. 

+

+  @param[in]  IdtDescriptor      Pointer to IDT Descriptor.

+  @param[in]  RestoredIdtEntry   IDT entry to be restored.

+

+**/

+VOID

+RestoreIdtEntry1 (

+  IN  IA32_DESCRIPTOR            *IdtDescriptor,

+  IN  IA32_IDT_GATE_DESCRIPTOR   *RestoredIdtEntry

+  )

+{

+  IA32_IDT_GATE_DESCRIPTOR   *IdtEntry;

+  

+  IdtEntry = (IA32_IDT_GATE_DESCRIPTOR *) IdtDescriptor->Base;

+  CopyMem (&IdtEntry[1], RestoredIdtEntry, sizeof (IA32_IDT_GATE_DESCRIPTOR));

+}

diff --git a/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/PeCoffExtraActionLib.c b/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/PeCoffExtraActionLib.c
index 7b551f20..c28d7930 100644
--- a/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/PeCoffExtraActionLib.c
+++ b/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/PeCoffExtraActionLib.c
@@ -1,7 +1,7 @@
 /** @file

   PE/Coff Extra Action library instances.

 

-  Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

   This program and the accompanying materials

   are licensed and made available under the terms and conditions of the BSD License

   which accompanies this distribution.  The full text of the license may be found at

@@ -12,17 +12,7 @@
 

 **/

 

-#include <Base.h>

-#include <Library/PeCoffExtraActionLib.h>

-#include <Library/DebugLib.h>

-#include <Library/BaseLib.h>

-#include <Library/IoLib.h>

-#include <Library/PcdLib.h>

-

-#include <ImageDebugSupport.h>

-

-#define DEBUG_LOAD_IMAGE_METHOD_IO_HW_BREAKPOINT    1

-#define DEBUG_LOAD_IMAGE_METHOD_SOFT_INT3           2

+#include <PeCoffExtraActionLib.h>

 

 /**

   Check if the hardware breakpoint in Drx is enabled by checking the Lx and Gx bit in Dr7.

@@ -62,16 +52,19 @@ PeCoffLoaderExtraActionCommon (
   IN     UINTN                         Signature

   )

 {

-  BOOLEAN  InterruptState;

-  UINTN    Dr0;

-  UINTN    Dr1;

-  UINTN    Dr2;

-  UINTN    Dr3;

-  UINTN    Dr7;

-  UINTN    Cr4;

-  UINTN    NewDr7;

-  UINT8    LoadImageMethod;

-  UINT8    DebugAgentStatus;

+  BOOLEAN                    InterruptState;

+  UINTN                      Dr0;

+  UINTN                      Dr1;

+  UINTN                      Dr2;

+  UINTN                      Dr3;

+  UINTN                      Dr7;

+  UINTN                      Cr4;

+  UINTN                      NewDr7;

+  UINT8                      LoadImageMethod;

+  UINT8                      DebugAgentStatus;

+  IA32_DESCRIPTOR            IdtDescriptor;

+  IA32_IDT_GATE_DESCRIPTOR   OriginalIdtEntry;

+  BOOLEAN                    IdtEntryHooked;

 

   ASSERT (ImageContext != NULL);

 

@@ -84,6 +77,23 @@ PeCoffLoaderExtraActionCommon (
   //

   InterruptState = SaveAndDisableInterrupts ();

 

+  IdtEntryHooked  = FALSE;

+  LoadImageMethod = PcdGet8 (PcdDebugLoadImageMethod);

+  AsmReadIdtr (&IdtDescriptor);

+  if (!CheckDebugAgentHandler (&IdtDescriptor)) {

+    if (LoadImageMethod == DEBUG_LOAD_IMAGE_METHOD_SOFT_INT3) {

+      //

+      // Do not trigger INT3 if Debug Agent did not setup IDT entries.

+      //

+      return;

+    }

+    //

+    // Save and update IDT entry for INT1

+    //

+    SaveAndUpdateIdtEntry1 (&IdtDescriptor, &OriginalIdtEntry);

+    IdtEntryHooked = TRUE;

+  }

+  

   //

   // Save Debug Register State

   //

@@ -108,7 +118,6 @@ PeCoffLoaderExtraActionCommon (
   AsmWriteDr2 ((UINTN) ImageContext);

   AsmWriteDr3 (IO_PORT_BREAKPOINT_ADDRESS);

 

-  LoadImageMethod = PcdGet8 (PcdDebugLoadImageMethod);

   if (LoadImageMethod == DEBUG_LOAD_IMAGE_METHOD_IO_HW_BREAKPOINT) {

     AsmWriteDr7 (0x20000480);

     AsmWriteCr4 (Cr4 | BIT3);

@@ -156,6 +165,12 @@ PeCoffLoaderExtraActionCommon (
     AsmWriteDr7 (Dr7);

   }

   //

+  // Restore original IDT entry for INT1 if it was hooked.

+  //

+  if (IdtEntryHooked) {

+    RestoreIdtEntry1 (&IdtDescriptor, &OriginalIdtEntry);

+  }

+  //

   // Restore the interrupt state

   //

   SetInterruptState (InterruptState);

diff --git a/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/PeCoffExtraActionLib.h b/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/PeCoffExtraActionLib.h
new file mode 100644
index 00000000..36aebf16
--- /dev/null
+++ b/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/PeCoffExtraActionLib.h
@@ -0,0 +1,74 @@
+/** @file

+  PE/Coff Extra Action library instances, it will report image debug info.

+

+  Copyright (c) 2013, Intel Corporation. All rights reserved.<BR>

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php.

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef _PE_COFF_EXTRA_ACTION_LIB_H_

+#define _PE_COFF_EXTRA_ACTION_LIB_H_

+

+#include <Base.h>

+#include <Library/PeCoffExtraActionLib.h>

+#include <Library/DebugLib.h>

+#include <Library/BaseLib.h>

+#include <Library/IoLib.h>

+#include <Library/PcdLib.h>

+#include <Library/BaseMemoryLib.h>

+

+#include <ImageDebugSupport.h>

+

+#define DEBUG_LOAD_IMAGE_METHOD_IO_HW_BREAKPOINT    1

+#define DEBUG_LOAD_IMAGE_METHOD_SOFT_INT3           2

+

+extern UINTN  AsmInterruptHandle;

+

+/**

+  Read IDT entry to check if IDT entries are setup by Debug Agent.

+

+  @param[in]  IdtDescriptor      Pointer to IDT Descriptor.

+

+  @retval  TRUE     IDT entries were setup by Debug Agent.

+  @retval  FALSE    IDT entries were not setuo by Debug Agent.

+

+**/

+BOOLEAN 

+CheckDebugAgentHandler (

+  IN  IA32_DESCRIPTOR            *IdtDescriptor

+  );

+

+/**

+  Save IDT entry for INT1 and update it. 

+

+  @param[in]  IdtDescriptor      Pointer to IDT Descriptor.

+  @param[out] SavedIdtEntry      Original IDT entry returned.

+

+**/

+VOID

+SaveAndUpdateIdtEntry1 (

+  IN  IA32_DESCRIPTOR            *IdtDescriptor,

+  OUT IA32_IDT_GATE_DESCRIPTOR   *SavedIdtEntry

+  );

+

+/**

+  Restore IDT entry for INT1. 

+

+  @param[in]  IdtDescriptor      Pointer to IDT Descriptor.

+  @param[in]  RestoredIdtEntry   IDT entry to be restored.

+

+**/

+VOID

+RestoreIdtEntry1 (

+  IN  IA32_DESCRIPTOR            *IdtDescriptor,

+  IN  IA32_IDT_GATE_DESCRIPTOR   *RestoredIdtEntry

+  );

+

+#endif

+

diff --git a/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/PeCoffExtraActionLibDebug.inf b/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/PeCoffExtraActionLibDebug.inf
index e3712afa..fa485bcf 100644
--- a/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/PeCoffExtraActionLibDebug.inf
+++ b/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/PeCoffExtraActionLibDebug.inf
@@ -1,7 +1,7 @@
 ## @file

 #  PeCoffExtraAction Library to support source level debug.

 #

-#  Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>

+#  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

 #

 #  This program and the accompanying materials

 #  are licensed and made available under the terms and conditions of the BSD License

@@ -28,8 +28,19 @@
 #

 

 [Sources.common]

+  PeCoffExtraActionLib.h

   PeCoffExtraActionLib.c

 

+[Sources.IA32]

+  Ia32/IntHandlerFuncs.c

+  Ia32/IntHandler.asm     | MSFT

+  Ia32/IntHandler.S       | GCC

+

+[Sources.X64]

+  X64/IntHandlerFuncs.c

+  X64/IntHandler.asm      | MSFT

+  X64/IntHandler.S        | GCC

+

 [Packages]

   MdePkg/MdePkg.dec

   SourceLevelDebugPkg/SourceLevelDebugPkg.dec

diff --git a/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/X64/IntHandler.S b/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/X64/IntHandler.S
new file mode 100644
index 00000000..108b40cf
--- /dev/null
+++ b/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/X64/IntHandler.S
@@ -0,0 +1,28 @@
+#------------------------------------------------------------------------------

+#

+# Copyright (c) 2013, Intel Corporation. All rights reserved.<BR>

+# This program and the accompanying materials

+# are licensed and made available under the terms and conditions of the BSD License

+# which accompanies this distribution.  The full text of the license may be found at

+# http://opensource.org/licenses/bsd-license.php.

+#

+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+# Module Name:

+#

+#   IntHandler.S

+#

+# Abstract:

+#

+#   Assembly interrupt handler function.

+#

+#------------------------------------------------------------------------------

+

+ASM_GLOBAL ASM_PFX(AsmInterruptHandle)

+

+.text

+ASM_PFX(AsmInterruptHandle):

+   cli

+   movb   $1, %al

+   iretq

diff --git a/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/X64/IntHandler.asm b/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/X64/IntHandler.asm
new file mode 100644
index 00000000..93f4d6f1
--- /dev/null
+++ b/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/X64/IntHandler.asm
@@ -0,0 +1,29 @@
+;------------------------------------------------------------------------------

+;

+; Copyright (c) 2013, Intel Corporation. All rights reserved.<BR>

+; This program and the accompanying materials

+; are licensed and made available under the terms and conditions of the BSD License

+; which accompanies this distribution.  The full text of the license may be found at

+; http://opensource.org/licenses/bsd-license.php.

+;

+; THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+; WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+;

+; Module Name:

+;

+;   IntHandler.asm

+;

+; Abstract:

+;

+;   Assembly interrupt handler function.

+;

+;------------------------------------------------------------------------------

+

+public AsmInterruptHandle

+

+.code

+AsmInterruptHandle:

+    cli

+    mov   al, 1

+    iretq

+END

diff --git a/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/X64/IntHandlerFuncs.c b/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/X64/IntHandlerFuncs.c
new file mode 100644
index 00000000..c9041de7
--- /dev/null
+++ b/SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/X64/IntHandlerFuncs.c
@@ -0,0 +1,98 @@
+/** @file

+  X64 arch function to access IDT vector.

+

+  Copyright (c) 2013, Intel Corporation. All rights reserved.<BR>

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php.

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include <PeCoffExtraActionLib.h>

+

+/**

+  Read IDT entry to check if IDT entries are setup by Debug Agent.

+

+  @param[in]  IdtDescriptor      Pointer to IDT Descriptor.

+

+  @retval  TRUE     IDT entries were setup by Debug Agent.

+  @retval  FALSE    IDT entries were not setuo by Debug Agent.

+

+**/

+BOOLEAN 

+CheckDebugAgentHandler (

+  IN  IA32_DESCRIPTOR            *IdtDescriptor

+  )

+{

+  IA32_IDT_GATE_DESCRIPTOR   *IdtEntry;

+  UINTN                      InterruptHandler;

+

+  IdtEntry = (IA32_IDT_GATE_DESCRIPTOR *) IdtDescriptor->Base;

+  if (IdtEntry == NULL) {

+    return FALSE;

+  }

+

+  InterruptHandler = IdtEntry[0].Bits.OffsetLow + (((UINTN)IdtEntry[0].Bits.OffsetHigh) << 16) + 

+                     (((UINTN)IdtEntry[0].Bits.OffsetUpper) << 32);

+  if (InterruptHandler >= 4 &&  *(UINT32 *)(InterruptHandler - 4) == AGENT_HANDLER_SIGNATURE) {

+    return TRUE;

+  } else {

+    return FALSE;

+  }

+}

+

+/**

+  Save IDT entry for INT1 and update it. 

+

+  @param[in]  IdtDescriptor      Pointer to IDT Descriptor.

+  @param[out] SavedIdtEntry      Original IDT entry returned.

+

+**/

+VOID

+SaveAndUpdateIdtEntry1 (

+  IN  IA32_DESCRIPTOR            *IdtDescriptor,

+  OUT IA32_IDT_GATE_DESCRIPTOR   *SavedIdtEntry

+  )

+{

+  IA32_IDT_GATE_DESCRIPTOR   *IdtEntry;

+  UINT16                     CodeSegment;

+  UINTN                      InterruptHandler;

+  

+  IdtEntry = (IA32_IDT_GATE_DESCRIPTOR *) IdtDescriptor->Base;

+  CopyMem (SavedIdtEntry, &IdtEntry[1], sizeof (IA32_IDT_GATE_DESCRIPTOR));

+

+    //

+  // Use current CS as the segment selector of interrupt gate in IDT

+  //

+  CodeSegment = AsmReadCs ();

+

+  InterruptHandler = (UINTN) &AsmInterruptHandle;

+  IdtEntry[1].Bits.OffsetLow       = (UINT16)(UINTN)InterruptHandler;

+  IdtEntry[1].Bits.OffsetHigh      = (UINT16)((UINTN)InterruptHandler >> 16);

+  IdtEntry[1].Bits.OffsetUpper     = (UINT32)((UINTN)InterruptHandler >> 32);

+  IdtEntry[1].Bits.Selector        = CodeSegment;

+  IdtEntry[1].Bits.GateType        = IA32_IDT_GATE_TYPE_INTERRUPT_32;

+}

+

+/**

+  Restore IDT entry for INT1. 

+

+  @param[in]  IdtDescriptor      Pointer to IDT Descriptor.

+  @param[in]  RestoredIdtEntry   IDT entry to be restored.

+

+**/

+VOID

+RestoreIdtEntry1 (

+  IN  IA32_DESCRIPTOR            *IdtDescriptor,

+  IN  IA32_IDT_GATE_DESCRIPTOR   *RestoredIdtEntry

+  )

+{

+  IA32_IDT_GATE_DESCRIPTOR   *IdtEntry;

+  

+  IdtEntry = (IA32_IDT_GATE_DESCRIPTOR *) IdtDescriptor->Base;

+  CopyMem (&IdtEntry[1], RestoredIdtEntry, sizeof (IA32_IDT_GATE_DESCRIPTOR));

+}

diff --git a/SourceLevelDebugPkg/Readme.txt b/SourceLevelDebugPkg/Readme.txt
index 70ab31d0..cb5d976d 100644
--- a/SourceLevelDebugPkg/Readme.txt
+++ b/SourceLevelDebugPkg/Readme.txt
@@ -3,4 +3,4 @@ SourceLevelDebugPkg in conjunction with Intel(R) UEFI Development Kit Debugger
 Tool (Intel (R) UDK Debugger Tool).

 

 The Intel(R) UDK Debugger Tool and its detailed user manual can be obtained

-from: http://www.intel.com/technology/efi.

+from: http://www.uefidk.com/develop.

diff --git a/SourceLevelDebugPkg/SourceLevelDebugPkg.dec b/SourceLevelDebugPkg/SourceLevelDebugPkg.dec
index 34d70065..5146b9e2 100644
--- a/SourceLevelDebugPkg/SourceLevelDebugPkg.dec
+++ b/SourceLevelDebugPkg/SourceLevelDebugPkg.dec
@@ -7,7 +7,7 @@
 # and host, PeCoffExtraActionLib instance to report symbol path information,

 # etc.

 #

-# Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>

+# Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

 # This program and the accompanying materials are licensed and made available under 

 # the terms and conditions of the BSD License that accompanies this distribution.  

 # The full text of the license may be found at

@@ -22,7 +22,7 @@
   DEC_SPECIFICATION              = 0x00010005

   PACKAGE_NAME                   = SourceLevelDebugPkg

   PACKAGE_GUID                   = DBF00C27-D8D7-443d-918B-4E85CDA1373B

-  PACKAGE_VERSION                = 0.80

+  PACKAGE_VERSION                = 0.85

 

 [Includes]

   Include

@@ -72,3 +72,7 @@
   ## 1: Use I/O Port 84 to issue hardware break point

   ## 2: Use INT3 to issue software break point

   gEfiSourceLevelDebugPkgTokenSpaceGuid.PcdDebugLoadImageMethod|0x1|UINT8|0x00000005

+

+  ## The data buffer size used by debug port in debug communication library.

+  gEfiSourceLevelDebugPkgTokenSpaceGuid.PcdDebugPortHandleBufferSize|0x0|UINT16|0x00000006

+

diff --git a/SourceLevelDebugPkg/SourceLevelDebugPkg.dsc b/SourceLevelDebugPkg/SourceLevelDebugPkg.dsc
index 461cbf88..c029c439 100644
--- a/SourceLevelDebugPkg/SourceLevelDebugPkg.dsc
+++ b/SourceLevelDebugPkg/SourceLevelDebugPkg.dsc
@@ -2,7 +2,7 @@
 #

 # Source Level Debug Package.

 #

-# Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>

+# Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>

 #

 #    This program and the accompanying materials

 #    are licensed and made available under the terms and conditions of the BSD License

@@ -22,7 +22,7 @@
 [Defines]

   PLATFORM_NAME                  = SourceLevelDebugPkg

   PLATFORM_GUID                  = 38C85805-883F-4ee8-A854-95B966ED73AA

-  PLATFORM_VERSION               = 0.80

+  PLATFORM_VERSION               = 0.85

   DSC_SPECIFICATION              = 0x00010005

   OUTPUT_DIRECTORY               = Build/SourceLevelDebugPkg

   SUPPORTED_ARCHITECTURES        = IA32|X64

@@ -30,13 +30,47 @@
   SKUID_IDENTIFIER               = DEFAULT

 

 [LibraryClasses.common]

-  DebugLib|MdePkg/Library/UefiDebugLibStdErr/UefiDebugLibStdErr.inf

+  DebugLib|MdePkg/Library/BaseDebugLibSerialPort/BaseDebugLibSerialPort.inf

   DebugPrintErrorLevelLib|MdePkg/Library/BaseDebugPrintErrorLevelLib/BaseDebugPrintErrorLevelLib.inf  

   BaseLib|MdePkg/Library/BaseLib/BaseLib.inf

   BaseMemoryLib|MdePkg/Library/BaseMemoryLib/BaseMemoryLib.inf

-  TimerLib|MdePkg/Library/BaseTimerLibNullTemplate/BaseTimerLibNullTemplate.inf

   PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf

+  PrintLib|MdePkg/Library/BasePrintLib/BasePrintLib.inf

+  IoLib|MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.inf

+  SynchronizationLib|MdePkg/Library/BaseSynchronizationLib/BaseSynchronizationLib.inf

+  LocalApicLib|UefiCpuPkg/Library/BaseXApicLib/BaseXApicLib.inf

+  PeCoffGetEntryPointLib|MdePkg/Library/BasePeCoffGetEntryPointLib/BasePeCoffGetEntryPointLib.inf

+  SerialPortLib|MdeModulePkg/Library/BaseSerialPortLib16550/BaseSerialPortLib16550.inf

+  PeCoffExtraActionLib|SourceLevelDebugPkg/Library/PeCoffExtraActionLibDebug/PeCoffExtraActionLibDebug.inf

+  TimerLib|UefiCpuPkg/Library/SecPeiDxeTimerLibUefiCpu/SecPeiDxeTimerLibUefiCpu.inf

+  ResetSystemLib|MdeModulePkg/Library/BaseResetSystemLibNull/BaseResetSystemLibNull.inf

+  PciLib|MdePkg/Library/BasePciLibCf8/BasePciLibCf8.inf

+  PciCf8Lib|MdePkg/Library/BasePciCf8Lib/BasePciCf8Lib.inf

+  PlatformHookLib|MdeModulePkg/Library/BasePlatformHookLibNull/BasePlatformHookLibNull.inf

+

+!ifdef $(SOURCE_DEBUG_USE_USB)

+  DebugCommunicationLib|SourceLevelDebugPkg/Library/DebugCommunicationLibUsb/DebugCommunicationLibUsb.inf

+!else

   DebugCommunicationLib|SourceLevelDebugPkg/Library/DebugCommunicationLibSerialPort/DebugCommunicationLibSerialPort.inf

+!endif

+

+[LibraryClasses.common.PEIM]

+  PeimEntryPoint|MdePkg/Library/PeimEntryPoint/PeimEntryPoint.inf

+  PeiServicesLib|MdePkg/Library/PeiServicesLib/PeiServicesLib.inf

+  PeiServicesTablePointerLib|MdePkg/Library/PeiServicesTablePointerLibIdt/PeiServicesTablePointerLibIdt.inf

+  HobLib|MdePkg/Library/PeiHobLib/PeiHobLib.inf

+  MemoryAllocationLib|MdePkg/Library/PeiMemoryAllocationLib/PeiMemoryAllocationLib.inf

+  DebugAgentLib|SourceLevelDebugPkg/Library/DebugAgent/SecPeiDebugAgentLib.inf

+

+[LibraryClasses.common.DXE_DRIVER]

+  UefiDriverEntryPoint|MdePkg/Library/UefiDriverEntryPoint/UefiDriverEntryPoint.inf

+  UefiBootServicesTableLib|MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.inf

+  UefiRuntimeServicesTableLib|MdePkg/Library/UefiRuntimeServicesTableLib/UefiRuntimeServicesTableLib.inf

+  UefiLib|MdePkg/Library/UefiLib/UefiLib.inf

+  DevicePathLib|MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.inf

+  HobLib|MdePkg/Library/DxeHobLib/DxeHobLib.inf

+  MemoryAllocationLib|MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf

+  DebugAgentLib|SourceLevelDebugPkg/Library/DebugAgent/DxeDebugAgentLib.inf

 

 ###################################################################################################

 #

@@ -64,4 +98,5 @@
   SourceLevelDebugPkg/Library/DebugAgent/SecPeiDebugAgentLib.inf

   SourceLevelDebugPkg/Library/DebugAgent/DxeDebugAgentLib.inf

   SourceLevelDebugPkg/Library/DebugAgent/SmmDebugAgentLib.inf

-

+  SourceLevelDebugPkg/DebugAgentPei/DebugAgentPei.inf

+  SourceLevelDebugPkg/DebugAgentDxe/DebugAgentDxe.inf

diff --git a/StdLib/BsdSocketLib/socket.c b/StdLib/BsdSocketLib/socket.c
index 4f49777b..6b00f41f 100644
--- a/StdLib/BsdSocketLib/socket.c
+++ b/StdLib/BsdSocketLib/socket.c
@@ -146,7 +146,7 @@ BslSocketProtocolToFd (
     pDescriptor->f_flag = 0;

     pDescriptor->f_iflags = DTYPE_SOCKET;

     pDescriptor->MyFD = (UINT16)FileDescriptor;

-    pDescriptor->Oflags = 0;

+    pDescriptor->Oflags = O_RDWR;

     pDescriptor->Omode = S_ACC_READ | S_ACC_WRITE;

     pDescriptor->RefCount = 1;

     FILE_SET_MATURE ( pDescriptor );

diff --git a/StdLib/EfiSocketLib/Socket.h b/StdLib/EfiSocketLib/Socket.h
index 43a7084f..b38bec6b 100644
--- a/StdLib/EfiSocketLib/Socket.h
+++ b/StdLib/EfiSocketLib/Socket.h
@@ -33,9 +33,9 @@
 #define DEBUG_OPTION        0x00080000  ///<  Display option messages

 

 #define MAX_PENDING_CONNECTIONS     1   ///<  Maximum connection FIFO depth

-#define MAX_RX_DATA         65536       ///<  Maximum receive data size

+#define MAX_RX_DATA         0x01000000  ///<  Maximum receive data size

 #define MAX_TX_DATA         ( MAX_RX_DATA * 2 ) ///<  Maximum buffered transmit data in bytes

-#define RX_PACKET_DATA      16384       ///<  Maximum number of bytes in a RX packet

+#define RX_PACKET_DATA      0x00100000  ///<  Maximum number of bytes in a RX packet

 #define MAX_UDP_RETRANSMIT  16          ///<  UDP retransmit attempts to handle address not mapped

 

 #define ESL_STRUCTURE_ALIGNMENT_BYTES   15  ///<  Number of bytes for structure alignment

@@ -362,7 +362,7 @@ typedef struct {
 **/

 typedef

 EFI_STATUS

-(* PFN_NET_CONFIGURE) (

+(EFIAPI * PFN_NET_CONFIGURE) (

   IN VOID * pProtocol,

   IN VOID * pConfigData

   );

@@ -378,7 +378,7 @@ EFI_STATUS
 **/

 typedef

 EFI_STATUS

-(* PFN_NET_IO_START) (

+(EFIAPI * PFN_NET_IO_START) (

   IN VOID * pProtocol,

   IN VOID * pToken

   );

@@ -394,7 +394,7 @@ EFI_STATUS
 **/

 typedef

 EFI_STATUS

-(* PFN_NET_POLL) (

+(EFIAPI * PFN_NET_POLL) (

   IN VOID * pProtocol

   );

 

diff --git a/StdLib/EfiSocketLib/Udp4.c b/StdLib/EfiSocketLib/Udp4.c
index 414e3fe3..11b7db76 100644
--- a/StdLib/EfiSocketLib/Udp4.c
+++ b/StdLib/EfiSocketLib/Udp4.c
@@ -266,7 +266,7 @@ EslUdp4PortAllocate (
   pConfig->AcceptBroadcast = FALSE;

   pConfig->AcceptPromiscuous = FALSE;

   pConfig->AllowDuplicatePort = TRUE;

-  pConfig->DoNotFragment = TRUE;

+  pConfig->DoNotFragment = FALSE;

   Status = EFI_SUCCESS;

 

   //

diff --git a/StdLib/ISSUES.txt b/StdLib/ISSUES.txt
new file mode 100644
index 00000000..25317f7a
--- /dev/null
+++ b/StdLib/ISSUES.txt
@@ -0,0 +1,58 @@
+  Status Key:

+    Open          Problem is unresolved and final disposition unknown.

+    Verified      Problem has been reproduced.

+    Understood    Root cause of problem is understood.

+    Document      Problem is to be fixed through improved documentation.

+    Fixed         Problem has been resolved and changes committed.

+

+SocketLib

+=============

+      Category                             TOOLs       Reported       Status

+    ------------------------              --------  --------------  -----------

+

+StdLib Issues

+=============

+      Category                             TOOLs       Reported       Status

+    ------------------------              --------  --------------  -----------

+1:  Compilation Error                      vs2010             2012  Fixed 3/2013

+    stdlib\libc\gdtoa\strtod.c(825) : warning C4789: destination of memory copy is too small

+    runtime crashes when using floating-point formats with printf

+

+2:  Compilation Error                       ALL               2012  Fixed 1/2012

+    StdLib/LibC/Uefi/SysCalls.c: In function 'utimes': error: 'va_start' used in function with fixed args

+

+3:  Usage Clarification                                       2012  Document

+    Clarify that the current StdLib may not be used for developing drivers.

+

+4:  Execution/Compile errors                                  2012  Fixed 1/2013

+    Mismatch in use of EFIAPI between declaration and definition of some functions.

+

+5:  Error message Quality during execution                    2012  Verified

+    Performing filesystem operations when a filesystem driver has not been

+    linked into the application results in hangs or error messages that are

+    misleading or unclear as to the cause.

+

+6:  Application error return                                  2012  Verified

+    On error, applications will sometimes return large positive numbers.

+

+7:  Compilation Error                       GCC46        Jan, 2013  Fixed 1/2013

+    StdLib/LibC/Containers/Queues/Fifo.c:508:27: error: assignment from incompatible pointer type

+

+8:  Compilation Error

+    StdLib\LibC\Uefi\InteractiveIO\IIOutilities.c        Jan. 2013  Fixed 1/2013

+    IIO_CursorDelta: Declaration return type differs from definition return type.

+

+9:  chdir/cwd not in EFI Shell                                2012  Understood

+    The chdir and getcwd functions only work if one is using the UEFI Shell.

+

+10: No current volume/directory at app. startup.              2012  Understood

+    If the Shell does not have a current volume or directory, file operations

+    may hang or fail.

+

+11: printf("-%ls-", L"test") will only print "--"             2013  Fixed 3/2013

+

+

+PosixLib

+=============

+      Category                             TOOLs       Reported       Status

+    ------------------------              --------  --------------  -----------

diff --git a/StdLib/Include/Containers/Fifo.h b/StdLib/Include/Containers/Fifo.h
index 3b232fec..69dd55b0 100644
--- a/StdLib/Include/Containers/Fifo.h
+++ b/StdLib/Include/Containers/Fifo.h
@@ -151,8 +151,10 @@ typedef size_t     (EFIAPI *cFIFO_Flush)   (cFIFO *Self, size_t NumToFlush);
 /** Remove the most recent element from the FIFO.

 

     @param[in]    Self              Pointer to the FIFO instance.

+

+    @return     Returns the number of elements remaining in the FIFO.

 **/

-typedef void        (EFIAPI *cFIFO_Truncate)  (cFIFO *Self);

+typedef size_t        (EFIAPI *cFIFO_Truncate)  (cFIFO *Self);

 

 /** Cleanly delete a FIFO instance.

 

diff --git a/StdLib/LibC/Locale/_wcstod.h b/StdLib/LibC/Locale/_wcstod.h
index 1e7c47f2..4b0a8337 100644
--- a/StdLib/LibC/Locale/_wcstod.h
+++ b/StdLib/LibC/Locale/_wcstod.h
@@ -34,9 +34,9 @@
  * function template for wcstof, wcstod, wcstold.

  *

  * parameters:

- *	_FUNCNAME    : function name

- *	_RETURN_TYPE : return type

- *	_STRTOD_FUNC : real conversion function

+ *  _FUNCNAME    : function name

+ *  _RETURN_TYPE : return type

+ *  _STRTOD_FUNC : real conversion function

  */

 #ifndef __WCSTOD_H_

 #define __WCSTOD_H_

@@ -54,73 +54,73 @@
 _RETURN_TYPE

 _FUNCNAME(const wchar_t * __restrict nptr, wchar_t ** __restrict endptr)

 {

-	const wchar_t *src, *start;

-	_RETURN_TYPE val;

-	char *buf, *end;

-	size_t bufsiz, len;

+  const wchar_t *src, *start;

+  _RETURN_TYPE val;

+  char *buf, *end;

+  size_t bufsiz, len;

 

-	_DIAGASSERT(nptr != NULL);

-	/* endptr may be null */

+  _DIAGASSERT(nptr != NULL);

+  /* endptr may be null */

 

-	src = nptr;

-	while (iswspace((wint_t)*src) != 0)

-		++src;

-	if (*src == L'\0')

-		goto no_convert;

+  src = nptr;

+  while (iswspace((wint_t)*src) != 0)

+    ++src;

+  if (*src == L'\0')

+    goto no_convert;

 

-	/*

-	 * Convert the supplied numeric wide char. string to multibyte.

-	 *

-	 * We could attempt to find the end of the numeric portion of the

-	 * wide char. string to avoid converting unneeded characters but

-	 * choose not to bother; optimising the uncommon case where

-	 * the input string contains a lot of text after the number

-	 * duplicates a lot of strto{f,d,ld}()'s functionality and

-	 * slows down the most common cases.

-	 */

-	start = src;

-	len = wcstombs(NULL, src, 0);

-	if (len == (size_t)-1)

-		/* errno = EILSEQ */

-		goto no_convert;

+  /*

+   * Convert the supplied numeric wide char. string to multibyte.

+   *

+   * We could attempt to find the end of the numeric portion of the

+   * wide char. string to avoid converting unneeded characters but

+   * choose not to bother; optimising the uncommon case where

+   * the input string contains a lot of text after the number

+   * duplicates a lot of strto{f,d,ld}()'s functionality and

+   * slows down the most common cases.

+   */

+  start = src;

+  len = wcstombs(NULL, src, 0);

+  if (len == (size_t)-1)

+    /* errno = EILSEQ */

+    goto no_convert;

 

-	_DIAGASSERT(len > 0);

+  _DIAGASSERT(len > 0);

 

-	bufsiz = len;

-	buf = (void *)malloc(bufsiz + 1);

-	if (buf == NULL)

-		/* errno = ENOMEM */

-		goto no_convert;

+  bufsiz = len;

+  buf = (void *)malloc(bufsiz + 1);

+  if (buf == NULL)

+    /* errno = ENOMEM */

+    goto no_convert;

 

-	len = wcstombs(buf, src, bufsiz + 1);

+  len = wcstombs(buf, src, bufsiz + 1);

 

-	_DIAGASSERT(len == bufsiz);

-	_DIAGASSERT(buf[len] == '\0');

+  _DIAGASSERT(len == bufsiz);

+  _DIAGASSERT(buf[len] == '\0');

 

-	/* Let strto{f,d,ld}() do most of the work for us. */

-	val = _STRTOD_FUNC(buf, &end);

-	if (buf == end) {

-		free(buf);

-		goto no_convert;

-	}

+  /* Let strto{f,d,ld}() do most of the work for us. */

+  val = _STRTOD_FUNC(buf, &end);

+  if (buf == end) {

+    free(buf);

+    goto no_convert;

+  }

 

-	/*

-	 * We only know where the number ended in the _multibyte_

-	 * representation of the string. If the caller wants to know

-	 * where it ended, count multibyte characters to find the

-	 * corresponding position in the wide char string.

-	 */

-	if (endptr != NULL)

-		/* XXX Assume each wide char is one byte. */

-		*endptr = __UNCONST(start + (size_t)(end - buf));

+  /*

+   * We only know where the number ended in the _multibyte_

+   * representation of the string. If the caller wants to know

+   * where it ended, count multibyte characters to find the

+   * corresponding position in the wide char string.

+   */

+  if (endptr != NULL)

+    /* XXX Assume each wide char is one byte. */

+    *endptr = __UNCONST(start + (size_t)(end - buf));

 

-	free(buf);

+  free(buf);

 

-	return val;

+  return val;

 

 no_convert:

-	if (endptr != NULL)

-		*endptr = __UNCONST(nptr);

-	return 0;

+  if (endptr != NULL)

+    *endptr = __UNCONST(nptr);

+  return 0.0;

 }

 #endif /*__WCSTOD_H_*/

diff --git a/StdLib/LibC/Locale/multibyte_Utf8.c b/StdLib/LibC/Locale/multibyte_Utf8.c
index 36e2cb37..ec9b0126 100644
--- a/StdLib/LibC/Locale/multibyte_Utf8.c
+++ b/StdLib/LibC/Locale/multibyte_Utf8.c
@@ -14,6 +14,7 @@
 #include  <stdlib.h>

 #include  <wchar.h>

 #include  <sys/types.h>

+#include  <limits.h>

 

 typedef      int      ch_UCS4;

 

@@ -913,6 +914,9 @@ wcsrtombs(
     return (0);

 

   if (Dest == NULL) {

+    if(MaxBytes <= 0) {

+      MaxBytes = ASCII_STRING_MAX;

+    }

     NumStored = EstimateWtoM(*Src, MaxBytes, NULL);

   }

   else {

diff --git a/StdLib/LibC/Uefi/InteractiveIO/IIOutilities.c b/StdLib/LibC/Uefi/InteractiveIO/IIOutilities.c
index 2da06288..1c978eae 100644
--- a/StdLib/LibC/Uefi/InteractiveIO/IIOutilities.c
+++ b/StdLib/LibC/Uefi/InteractiveIO/IIOutilities.c
@@ -263,8 +263,10 @@ IIO_GetOutputSize (
     @param[in]      EndXY     Pointer to the ending coordinate pair.

 

     @return   Returns the difference between the starting and ending coordinates.

+              The return value is positive if the coordinates contained in EndXY

+              are larger than StartXY, otherwise the return value is negative.

 **/

-UINT32

+int

 EFIAPI

 IIO_CursorDelta (

   cIIO         *This,

@@ -272,17 +274,15 @@ IIO_CursorDelta (
   CURSOR_XY    *EndXY

 )

 {

-  INT32    ColumnDelta;

-  INT32    RowDelta;

+  int    ColumnDelta;

+  int    RowDelta;

 

   RowDelta = (int)EndXY->Row - (int)StartXY->Row;

 

   assert(RowDelta >= 0);    // assert if EndXY is NOT after StartXY

 

-  ColumnDelta = (INT32)((This->MaxColumn * RowDelta) + EndXY->Column);

-  ColumnDelta -= (INT32)StartXY->Column;

-

-  assert(ColumnDelta >= 0); // assert if EndXY is NOT after StartXY

+  ColumnDelta = (int)((This->MaxColumn * RowDelta) + EndXY->Column);

+  ColumnDelta -= (int)StartXY->Column;

 

-  return (UINT32)ColumnDelta;

+  return ColumnDelta;

 }

diff --git a/StdLib/LibC/gdtoa/gdtoaimp.h b/StdLib/LibC/gdtoa/gdtoaimp.h
index 635a1775..3ba2cf8f 100644
--- a/StdLib/LibC/gdtoa/gdtoaimp.h
+++ b/StdLib/LibC/gdtoa/gdtoaimp.h
@@ -283,8 +283,7 @@ extern "C" {
 Exactly one of IEEE_LITTLE_ENDIAN, IEEE_BIG_ENDIAN, VAX, or IBM should be defined.

 #endif

 

-typedef union { double d; ULong L[2]; } U;

-//typedef union { double d; UINT32 L[2]; } U;

+typedef union { double d; UINT32 L[2]; } U;

 

 #ifdef YES_ALIAS

 #define dval(x) x

diff --git a/UefiCpuPkg/Library/CpuExceptionHandlerLib/X64/ExceptionHandlerAsm.asm b/UefiCpuPkg/Library/CpuExceptionHandlerLib/X64/ExceptionHandlerAsm.asm
index 1fa7cb87..2cc78db3 100644
--- a/UefiCpuPkg/Library/CpuExceptionHandlerLib/X64/ExceptionHandlerAsm.asm
+++ b/UefiCpuPkg/Library/CpuExceptionHandlerLib/X64/ExceptionHandlerAsm.asm
@@ -1,5 +1,5 @@
 ;------------------------------------------------------------------------------ ;

-; Copyright (c) 2012, Intel Corporation. All rights reserved.<BR>

+; Copyright (c) 2012 - 2013, Intel Corporation. All rights reserved.<BR>

 ; This program and the accompanying materials

 ; are licensed and made available under the terms and conditions of the BSD License

 ; which accompanies this distribution.  The full text of the license may be found at

@@ -23,7 +23,7 @@
 ;

 ; CommonExceptionHandler()

 ;

-CommonExceptionHandler             PROTO   C

+externdef CommonExceptionHandler:near

 

 EXTRN mErrorCodeFlag:DWORD ; Error code flags for exceptions