summaryrefslogtreecommitdiff
path: root/IntelFrameworkPkg/Library/FrameworkHiiLib/HiiLib.c
blob: 1b4c0dd79a2f33e42e7596640ac0bb69c989a3cc (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
/** @file
  HII Library implementation that uses DXE protocols and services.

  Copyright (c) 2006, Intel Corporation<BR>
  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.

  Module Name:  HiiLib.c

**/


#include <FrameworkDxe.h>

#include <Protocol/FrameworkHii.h>


#include <Library/FrameworkHiiLib.h>
#include <Library/DebugLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/BaseMemoryLib.h>

EFI_HII_PROTOCOL *mHii = NULL;

EFI_STATUS
EFIAPI
FrameworkHiiLibConstructor (
  IN EFI_HANDLE           ImageHandle,
  IN EFI_SYSTEM_TABLE     *SystemTable
  )
{
  EFI_STATUS Status;
  
  Status = gBS->LocateProtocol (
      &gEfiHiiProtocolGuid,
      NULL,
      (VOID **) &mHii
    );
  ASSERT_EFI_ERROR (Status);
  ASSERT (mHii != NULL);

  return EFI_SUCCESS;
}


EFI_HII_PACKAGES *
InternalPreparePackages (
  IN UINTN           NumberOfPackages,
  IN CONST EFI_GUID  *Guid OPTIONAL,
  VA_LIST            Marker
  )
{
  EFI_HII_PACKAGES  *HiiPackages;
  VOID              **Package;
  UINTN             Index;

  ASSERT (NumberOfPackages > 0);

  HiiPackages                   = AllocateZeroPool (sizeof (EFI_HII_PACKAGES) + NumberOfPackages * sizeof (VOID *));
  ASSERT (HiiPackages != NULL);

  HiiPackages->GuidId           = (EFI_GUID *) Guid;
  HiiPackages->NumberOfPackages = NumberOfPackages;
  Package                       = (VOID **) (((UINT8 *) HiiPackages) + sizeof (EFI_HII_PACKAGES));

  for (Index = 0; Index < NumberOfPackages; Index++) {
    *Package = VA_ARG (Marker, VOID *);
    Package++;
  }

  return HiiPackages;

}


/**
  This function allocates pool for an EFI_HII_PACKAGES structure
  with enough space for the variable argument list of package pointers.
  The allocated structure is initialized using NumberOfPackages, Guid,
  and the variable length argument list of package pointers.

  @param  NumberOfPackages The number of HII packages to prepare.
  @param  Guid Package GUID.

  @return The allocated and initialized packages.

**/
EFI_HII_PACKAGES *
EFIAPI
PreparePackages (
  IN UINTN           NumberOfPackages,
  IN CONST EFI_GUID  *Guid OPTIONAL,
  ...
  )
{
  VA_LIST           Args;

  VA_START (Args, Guid);

  return InternalPreparePackages (NumberOfPackages, Guid, Args);
}


/**
  This function allocates pool for an EFI_HII_PACKAGE_LIST structure
  with additional space that is big enough to host all packages described by the variable 
  argument list of package pointers.  The allocated structure is initialized using NumberOfPackages, 
  GuidId,  and the variable length argument list of package pointers.

  Then, EFI_HII_PACKAGE_LIST will be register to the default System HII Database. The
  Handle to the newly registered Package List is returned throught HiiHandle.

  @param  NumberOfPackages  The number of HII packages to register.
  @param  GuidId                    Package List GUID ID.
  @param  HiiHandle                The ID used to retrieve the Package List later.
  @param  ...                          The variable argument list describing all HII Package.

  @return
  The allocated and initialized packages.

**/

EFI_STATUS
EFIAPI
HiiLibAddPackagesToHiiDatabase (
  IN       UINTN               NumberOfPackages,
  IN CONST EFI_GUID            *GuidId,
  IN       EFI_HANDLE          DriverHandle, OPTIONAL
  OUT      EFI_HII_HANDLE      *HiiHandle, OPTIONAL
  ...
  )
{
  VA_LIST                   Args;
  EFI_HII_PACKAGES          *FrameworkHiiPacages;
  FRAMEWORK_EFI_HII_HANDLE  FrameworkHiiHandle;
  EFI_STATUS                Status;


  VA_START (Args, HiiHandle);
  FrameworkHiiPacages = InternalPreparePackages (NumberOfPackages, GuidId, Args);

  Status      = mHii->NewPack (mHii, FrameworkHiiPacages, &FrameworkHiiHandle);
  if (HiiHandle != NULL) {
    if (EFI_ERROR (Status)) {
      *HiiHandle = NULL;
    } else {
      *HiiHandle = (EFI_HII_HANDLE) (UINTN) FrameworkHiiHandle;
    }
  }

  FreePool (FrameworkHiiPacages);
  
  return Status;
}

EFI_STATUS
EFIAPI
HiiLibAddFontPackageToHiiDatabase (
  IN       UINTN               FontSize,
  IN CONST UINT8               *FontBinary,
  IN CONST EFI_GUID            *GuidId,
  OUT      EFI_HII_HANDLE      *HiiHandle OPTIONAL
  )
{
  EFI_STATUS            Status;
  EFI_HII_FONT_PACK     *FontPack;
  UINT8                 *Location;

  FontPack        = AllocateZeroPool (sizeof (EFI_HII_FONT_PACK) + FontSize);
  ASSERT (FontPack != NULL);

  FontPack->Header.Length         = (UINT32) (sizeof (EFI_HII_FONT_PACK) + FontSize);
  FontPack->Header.Type           = EFI_HII_FONT;
  FontPack->NumberOfNarrowGlyphs  = (UINT16) (FontSize / sizeof (EFI_NARROW_GLYPH));

  Location                        = (UINT8 *) (&FontPack->NumberOfWideGlyphs + sizeof (UINT8));
  CopyMem (Location, FontBinary, FontSize);


  //
  // Register our Fonts into the global database
  //
  Status = HiiLibAddPackagesToHiiDatabase (1, NULL, HiiHandle, NULL, FontPack);
  //
  // Free the font database
  //
  FreePool (FontPack);

  return Status;  
}

EFI_STATUS
EFIAPI
HiiLibRemovePackagesFromHiiDatabase (
  IN      EFI_HII_HANDLE      HiiHandle
  )
{
  return mHii->RemovePack (mHii, (FRAMEWORK_EFI_HII_HANDLE) (UINTN) HiiHandle);
}


/**
  This function adds the string into String Package of each language.

  @param  PackageList            Handle of the package list where this string will
                                 be added.
  @param  StringId               On return, contains the new strings id, which is
                                 unique within PackageList.
  @param  String                 Points to the new null-terminated string.

  @retval EFI_SUCCESS            The new string was added successfully.
  @retval EFI_NOT_FOUND          The specified PackageList could not be found in
                                 database.
  @retval EFI_OUT_OF_RESOURCES   Could not add the string due to lack of resources.
  @retval EFI_INVALID_PARAMETER  String is NULL or StringId is NULL is NULL.

**/
EFI_STATUS
EFIAPI
HiiLibCreateString (
  IN  EFI_HII_HANDLE                  PackageList,
  OUT EFI_STRING_ID                   *StringId,
  IN  CONST EFI_STRING                String
  )
{
  FRAMEWORK_EFI_HII_HANDLE  FrameworkHiiHandle;
  EFI_STATUS                Status;

  FrameworkHiiHandle = (FRAMEWORK_EFI_HII_HANDLE) (UINTN) PackageList;
  Status = mHii->NewString (
            mHii,
            NULL,
            FrameworkHiiHandle,
            StringId,
            String
          );

  return Status;
}


EFI_STATUS
EFIAPI
HiiLibUpdateString (
  IN  EFI_HII_HANDLE                  PackageList,
  IN  EFI_STRING_ID                   StringId,
  IN  CONST EFI_STRING                String
  )
{
  FRAMEWORK_EFI_HII_HANDLE  FrameworkHiiHandle;
  EFI_STATUS                Status;

  FrameworkHiiHandle = (FRAMEWORK_EFI_HII_HANDLE) (UINTN) PackageList;
  Status = mHii->NewString (
            mHii,
            NULL,
            FrameworkHiiHandle,
            &StringId,
            String
          );

  return Status;
}

//
// Just use the UEFI prototype
//
EFI_STATUS
EFIAPI
HiiLibGetStringFromGuidId (
  IN  EFI_GUID                        *ProducerGuid,
  IN  EFI_STRING_ID                   StringId,
  OUT EFI_STRING                      *String
  )
{
  return EFI_SUCCESS;  
}

//
// Just use the UEFI prototype
//
EFI_STATUS
EFIAPI
HiiLibGetStringFromHandle (
  IN  EFI_HII_HANDLE                  PackageList,
  IN  EFI_STRING_ID                   StringId,
  OUT EFI_STRING                      *String
  )
{
  return EFI_SUCCESS;
}

//
// Just use the UEFI prototype
//
EFI_STATUS
EFIAPI
HiiLibCreateHiiDriverHandle (
  OUT EFI_HANDLE               *DriverHandle
  )
{
  //
  // Driver
  // This implementation does nothing as DriverHandle concept only
  // applies to UEFI HII specification.
  //
  
  *DriverHandle = NULL;
  
  return EFI_SUCCESS;
}