← Back to branch summary

~vojtech-horky/helenos/numa

« back to all changes in this revision

Viewing changes to boot/arch/ia64/loader/gefi/inc/efiprot.h

  • Committer: Martin Decky
  • Date: 2009-08-04 11:19:19 UTC
  • Revision ID: martin@uranus.dsrg.hide.ms.mff.cuni.cz-20090804111919-evyclddlr3v5lhmp
Initial import

Show diffs side-by-side

added added

removed removed

Lines of Context:
boot/arch/ia64/loader/gefi/inc/efiprot.h
 
1
#ifndef _EFI_PROT_H
 
2
#define _EFI_PROT_H
 
3
 
 
4
/*++
 
5
 
 
6
Copyright (c) 1998  Intel Corporation
 
7
 
 
8
Module Name:
 
9
 
 
10
    efiprot.h
 
11
 
 
12
Abstract:
 
13
 
 
14
    EFI Protocols
 
15
 
 
16
 
 
17
 
 
18
Revision History
 
19
 
 
20
--*/
 
21
 
 
22
//
 
23
//  FPSWA library protocol
 
24
//
 
25
#define FPSWA_PROTOCOL          \
 
26
    { 0xc41b6531, 0x97b9, 0x11d3, {0x9a, 0x29, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} }
 
27
 
 
28
//
 
29
// Device Path protocol
 
30
//
 
31
 
 
32
#define DEVICE_PATH_PROTOCOL    \
 
33
    { 0x9576e91, 0x6d3f, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} }
 
34
 
 
35
 
 
36
//
 
37
// Block IO protocol
 
38
//
 
39
 
 
40
#define BLOCK_IO_PROTOCOL \
 
41
    { 0x964e5b21, 0x6459, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} }
 
42
#define EFI_BLOCK_IO_INTERFACE_REVISION   0x00010000
 
43
 
 
44
INTERFACE_DECL(_EFI_BLOCK_IO);
 
45
 
 
46
typedef
 
47
EFI_STATUS
 
48
(EFIAPI *EFI_BLOCK_RESET) (
 
49
    IN struct _EFI_BLOCK_IO     *This,
 
50
    IN BOOLEAN                  ExtendedVerification
 
51
    );
 
52
 
 
53
typedef
 
54
EFI_STATUS
 
55
(EFIAPI *EFI_BLOCK_READ) (
 
56
    IN struct _EFI_BLOCK_IO     *This,
 
57
    IN UINT32                   MediaId,
 
58
    IN EFI_LBA                  LBA,
 
59
    IN UINTN                    BufferSize,
 
60
    OUT VOID                    *Buffer
 
61
    );
 
62
 
 
63
 
 
64
typedef
 
65
EFI_STATUS
 
66
(EFIAPI *EFI_BLOCK_WRITE) (
 
67
    IN struct _EFI_BLOCK_IO     *This,
 
68
    IN UINT32                   MediaId,
 
69
    IN EFI_LBA                  LBA,
 
70
    IN UINTN                    BufferSize,
 
71
    IN VOID                     *Buffer
 
72
    );
 
73
 
 
74
 
 
75
typedef
 
76
EFI_STATUS
 
77
(EFIAPI *EFI_BLOCK_FLUSH) (
 
78
    IN struct _EFI_BLOCK_IO     *This
 
79
    );
 
80
 
 
81
 
 
82
 
 
83
typedef struct {
 
84
    UINT32              MediaId;
 
85
    BOOLEAN             RemovableMedia;
 
86
    BOOLEAN             MediaPresent;
 
87
 
 
88
    BOOLEAN             LogicalPartition;
 
89
    BOOLEAN             ReadOnly;
 
90
    BOOLEAN             WriteCaching;
 
91
 
 
92
    UINT32              BlockSize;
 
93
    UINT32              IoAlign;
 
94
 
 
95
    EFI_LBA             LastBlock;
 
96
} EFI_BLOCK_IO_MEDIA;
 
97
 
 
98
typedef struct _EFI_BLOCK_IO {
 
99
    UINT64                  Revision;
 
100
 
 
101
    EFI_BLOCK_IO_MEDIA      *Media;
 
102
 
 
103
    EFI_BLOCK_RESET         Reset;
 
104
    EFI_BLOCK_READ          ReadBlocks;
 
105
    EFI_BLOCK_WRITE         WriteBlocks;
 
106
    EFI_BLOCK_FLUSH         FlushBlocks;
 
107
 
 
108
} EFI_BLOCK_IO;
 
109
 
 
110
 
 
111
 
 
112
//
 
113
// Disk Block IO protocol
 
114
//
 
115
 
 
116
#define DISK_IO_PROTOCOL \
 
117
    { 0xce345171, 0xba0b, 0x11d2,  {0x8e, 0x4f, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} }
 
118
#define EFI_DISK_IO_INTERFACE_REVISION   0x00010000
 
119
 
 
120
INTERFACE_DECL(_EFI_DISK_IO);
 
121
 
 
122
typedef
 
123
EFI_STATUS
 
124
(EFIAPI *EFI_DISK_READ) (
 
125
    IN struct _EFI_DISK_IO      *This,
 
126
    IN UINT32                   MediaId,
 
127
    IN UINT64                   Offset,
 
128
    IN UINTN                    BufferSize,
 
129
    OUT VOID                    *Buffer
 
130
    );
 
131
 
 
132
 
 
133
typedef
 
134
EFI_STATUS
 
135
(EFIAPI *EFI_DISK_WRITE) (
 
136
    IN struct _EFI_DISK_IO      *This,
 
137
    IN UINT32                   MediaId,
 
138
    IN UINT64                   Offset,
 
139
    IN UINTN                    BufferSize,
 
140
    IN VOID                     *Buffer
 
141
    );
 
142
 
 
143
 
 
144
typedef struct _EFI_DISK_IO {
 
145
    UINT64              Revision;
 
146
    EFI_DISK_READ       ReadDisk;
 
147
    EFI_DISK_WRITE      WriteDisk;
 
148
} EFI_DISK_IO;
 
149
 
 
150
 
 
151
//
 
152
// Simple file system protocol
 
153
//
 
154
 
 
155
#define SIMPLE_FILE_SYSTEM_PROTOCOL \
 
156
    { 0x964e5b22, 0x6459, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} }
 
157
 
 
158
INTERFACE_DECL(_EFI_FILE_IO_INTERFACE);
 
159
INTERFACE_DECL(_EFI_FILE_HANDLE);
 
160
 
 
161
typedef
 
162
EFI_STATUS
 
163
(EFIAPI *EFI_VOLUME_OPEN) (
 
164
    IN struct _EFI_FILE_IO_INTERFACE    *This,
 
165
    OUT struct _EFI_FILE_HANDLE         **Root
 
166
    );
 
167
 
 
168
#define EFI_FILE_IO_INTERFACE_REVISION   0x00010000
 
169
 
 
170
typedef struct _EFI_FILE_IO_INTERFACE {
 
171
    UINT64                  Revision;
 
172
    EFI_VOLUME_OPEN         OpenVolume;
 
173
} EFI_FILE_IO_INTERFACE;
 
174
 
 
175
//
 
176
//
 
177
//
 
178
 
 
179
typedef
 
180
EFI_STATUS
 
181
(EFIAPI *EFI_FILE_OPEN) (
 
182
    IN struct _EFI_FILE_HANDLE  *File,
 
183
    OUT struct _EFI_FILE_HANDLE **NewHandle,
 
184
    IN CHAR16                   *FileName,
 
185
    IN UINT64                   OpenMode,
 
186
    IN UINT64                   Attributes
 
187
    );
 
188
 
 
189
// Open modes
 
190
#define EFI_FILE_MODE_READ      0x0000000000000001
 
191
#define EFI_FILE_MODE_WRITE     0x0000000000000002
 
192
#define EFI_FILE_MODE_CREATE    0x8000000000000000
 
193
 
 
194
// File attributes
 
195
#define EFI_FILE_READ_ONLY      0x0000000000000001
 
196
#define EFI_FILE_HIDDEN         0x0000000000000002
 
197
#define EFI_FILE_SYSTEM         0x0000000000000004
 
198
#define EFI_FILE_RESERVIED      0x0000000000000008
 
199
#define EFI_FILE_DIRECTORY      0x0000000000000010
 
200
#define EFI_FILE_ARCHIVE        0x0000000000000020
 
201
#define EFI_FILE_VALID_ATTR     0x0000000000000037
 
202
 
 
203
typedef
 
204
EFI_STATUS
 
205
(EFIAPI *EFI_FILE_CLOSE) (
 
206
    IN struct _EFI_FILE_HANDLE  *File
 
207
    );
 
208
 
 
209
typedef
 
210
EFI_STATUS
 
211
(EFIAPI *EFI_FILE_DELETE) (
 
212
    IN struct _EFI_FILE_HANDLE  *File
 
213
    );
 
214
 
 
215
typedef
 
216
EFI_STATUS
 
217
(EFIAPI *EFI_FILE_READ) (
 
218
    IN struct _EFI_FILE_HANDLE  *File,
 
219
    IN OUT UINTN                *BufferSize,
 
220
    OUT VOID                    *Buffer
 
221
    );
 
222
 
 
223
typedef
 
224
EFI_STATUS
 
225
(EFIAPI *EFI_FILE_WRITE) (
 
226
    IN struct _EFI_FILE_HANDLE  *File,
 
227
    IN OUT UINTN                *BufferSize,
 
228
    IN VOID                     *Buffer
 
229
    );
 
230
 
 
231
typedef
 
232
EFI_STATUS
 
233
(EFIAPI *EFI_FILE_SET_POSITION) (
 
234
    IN struct _EFI_FILE_HANDLE  *File,
 
235
    IN UINT64                   Position
 
236
    );
 
237
 
 
238
typedef
 
239
EFI_STATUS
 
240
(EFIAPI *EFI_FILE_GET_POSITION) (
 
241
    IN struct _EFI_FILE_HANDLE  *File,
 
242
    OUT UINT64                  *Position
 
243
    );
 
244
 
 
245
typedef
 
246
EFI_STATUS
 
247
(EFIAPI *EFI_FILE_GET_INFO) (
 
248
    IN struct _EFI_FILE_HANDLE  *File,
 
249
    IN EFI_GUID                 *InformationType,
 
250
    IN OUT UINTN                *BufferSize,
 
251
    OUT VOID                    *Buffer
 
252
    );
 
253
 
 
254
typedef
 
255
EFI_STATUS
 
256
(EFIAPI *EFI_FILE_SET_INFO) (
 
257
    IN struct _EFI_FILE_HANDLE  *File,
 
258
    IN EFI_GUID                 *InformationType,
 
259
    IN UINTN                    BufferSize,
 
260
    IN VOID                     *Buffer
 
261
    );
 
262
 
 
263
typedef
 
264
EFI_STATUS
 
265
(EFIAPI *EFI_FILE_FLUSH) (
 
266
    IN struct _EFI_FILE_HANDLE  *File
 
267
    );
 
268
 
 
269
 
 
270
 
 
271
#define EFI_FILE_HANDLE_REVISION         0x00010000
 
272
typedef struct _EFI_FILE_HANDLE {
 
273
    UINT64                  Revision;
 
274
    EFI_FILE_OPEN           Open;
 
275
    EFI_FILE_CLOSE          Close;
 
276
    EFI_FILE_DELETE         Delete;
 
277
    EFI_FILE_READ           Read;
 
278
    EFI_FILE_WRITE          Write;
 
279
    EFI_FILE_GET_POSITION   GetPosition;
 
280
    EFI_FILE_SET_POSITION   SetPosition;
 
281
    EFI_FILE_GET_INFO       GetInfo;
 
282
    EFI_FILE_SET_INFO       SetInfo;
 
283
    EFI_FILE_FLUSH          Flush;
 
284
} EFI_FILE, *EFI_FILE_HANDLE;
 
285
 
 
286
 
 
287
//
 
288
// File information types
 
289
//
 
290
 
 
291
#define EFI_FILE_INFO_ID   \
 
292
    { 0x9576e92, 0x6d3f, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} }
 
293
 
 
294
typedef struct {
 
295
    UINT64                  Size;
 
296
    UINT64                  FileSize;
 
297
    UINT64                  PhysicalSize;
 
298
    EFI_TIME                CreateTime;
 
299
    EFI_TIME                LastAccessTime;
 
300
    EFI_TIME                ModificationTime;
 
301
    UINT64                  Attribute;
 
302
    CHAR16                  FileName[1];
 
303
} EFI_FILE_INFO;
 
304
 
 
305
//
 
306
// The FileName field of the EFI_FILE_INFO data structure is variable length.
 
307
// Whenever code needs to know the size of the EFI_FILE_INFO data structure, it needs to
 
308
// be the size of the data structure without the FileName field.  The following macro 
 
309
// computes this size correctly no matter how big the FileName array is declared.
 
310
// This is required to make the EFI_FILE_INFO data structure ANSI compilant. 
 
311
//
 
312
 
 
313
#define SIZE_OF_EFI_FILE_INFO EFI_FIELD_OFFSET(EFI_FILE_INFO,FileName)
 
314
 
 
315
#define EFI_FILE_SYSTEM_INFO_ID    \
 
316
    { 0x9576e93, 0x6d3f, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} }
 
317
 
 
318
typedef struct {
 
319
    UINT64                  Size;
 
320
    BOOLEAN                 ReadOnly;
 
321
    UINT64                  VolumeSize;
 
322
    UINT64                  FreeSpace;
 
323
    UINT32                  BlockSize;
 
324
    CHAR16                  VolumeLabel[1];
 
325
} EFI_FILE_SYSTEM_INFO;
 
326
 
 
327
//
 
328
// The VolumeLabel field of the EFI_FILE_SYSTEM_INFO data structure is variable length.
 
329
// Whenever code needs to know the size of the EFI_FILE_SYSTEM_INFO data structure, it needs
 
330
// to be the size of the data structure without the VolumeLable field.  The following macro 
 
331
// computes this size correctly no matter how big the VolumeLable array is declared.
 
332
// This is required to make the EFI_FILE_SYSTEM_INFO data structure ANSI compilant. 
 
333
//
 
334
 
 
335
#define SIZE_OF_EFI_FILE_SYSTEM_INFO EFI_FIELD_OFFSET(EFI_FILE_SYSTEM_INFO,VolumeLabel)
 
336
 
 
337
#define EFI_FILE_SYSTEM_VOLUME_LABEL_INFO_ID    \
 
338
    { 0xDB47D7D3,0xFE81, 0x11d3, {0x9A, 0x35, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D} }
 
339
 
 
340
typedef struct {
 
341
    CHAR16                  VolumeLabel[1];
 
342
} EFI_FILE_SYSTEM_VOLUME_LABEL_INFO;
 
343
 
 
344
#define SIZE_OF_EFI_FILE_SYSTEM_VOLUME_LABEL_INFO EFI_FIELD_OFFSET(EFI_FILE_SYSTEM_VOLUME_LABEL_INFO,VolumeLabel)
 
345
 
 
346
//
 
347
// Load file protocol
 
348
//
 
349
 
 
350
 
 
351
#define LOAD_FILE_PROTOCOL \
 
352
    { 0x56EC3091, 0x954C, 0x11d2, {0x8E, 0x3F, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B} }
 
353
 
 
354
INTERFACE_DECL(_EFI_LOAD_FILE_INTERFACE);
 
355
 
 
356
typedef
 
357
EFI_STATUS
 
358
(EFIAPI *EFI_LOAD_FILE) (
 
359
    IN struct _EFI_LOAD_FILE_INTERFACE  *This,
 
360
    IN EFI_DEVICE_PATH                  *FilePath,
 
361
    IN BOOLEAN                          BootPolicy,
 
362
    IN OUT UINTN                        *BufferSize,
 
363
    IN VOID                             *Buffer OPTIONAL
 
364
    );
 
365
 
 
366
typedef struct _EFI_LOAD_FILE_INTERFACE {
 
367
    EFI_LOAD_FILE                       LoadFile;
 
368
} EFI_LOAD_FILE_INTERFACE;
 
369
 
 
370
 
 
371
//
 
372
// Device IO protocol
 
373
//
 
374
 
 
375
#define DEVICE_IO_PROTOCOL \
 
376
    { 0xaf6ac311, 0x84c3, 0x11d2, {0x8e, 0x3c, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b} }
 
377
 
 
378
INTERFACE_DECL(_EFI_DEVICE_IO_INTERFACE);
 
379
 
 
380
typedef enum {
 
381
    IO_UINT8,
 
382
    IO_UINT16,
 
383
    IO_UINT32,
 
384
    IO_UINT64,
 
385
//
 
386
// Specification Change: Copy from MMIO to MMIO vs. MMIO to buffer, buffer to MMIO
 
387
//
 
388
    MMIO_COPY_UINT8,
 
389
    MMIO_COPY_UINT16,
 
390
    MMIO_COPY_UINT32,
 
391
    MMIO_COPY_UINT64
 
392
} EFI_IO_WIDTH;
 
393
 
 
394
#define EFI_PCI_ADDRESS(_bus,_dev,_func) \
 
395
    ( (UINT64) ( (((UINTN)_bus) << 24) + (((UINTN)_dev) << 16) + (((UINTN)_func) << 8) ) )
 
396
 
 
397
 
 
398
typedef
 
399
EFI_STATUS
 
400
(EFIAPI *EFI_DEVICE_IO) (
 
401
    IN struct _EFI_DEVICE_IO_INTERFACE *This,
 
402
    IN EFI_IO_WIDTH                 Width,
 
403
    IN UINT64                       Address,
 
404
    IN UINTN                        Count,
 
405
    IN OUT VOID                     *Buffer
 
406
    );
 
407
 
 
408
typedef struct {
 
409
    EFI_DEVICE_IO                   Read;
 
410
    EFI_DEVICE_IO                   Write;
 
411
} EFI_IO_ACCESS;
 
412
 
 
413
typedef 
 
414
EFI_STATUS
 
415
(EFIAPI *EFI_PCI_DEVICE_PATH) (
 
416
    IN struct _EFI_DEVICE_IO_INTERFACE  *This,
 
417
    IN UINT64                           Address,
 
418
    IN OUT EFI_DEVICE_PATH              **PciDevicePath
 
419
    );
 
420
 
 
421
typedef enum {
 
422
    EfiBusMasterRead,
 
423
    EfiBusMasterWrite,
 
424
    EfiBusMasterCommonBuffer
 
425
} EFI_IO_OPERATION_TYPE;
 
426
 
 
427
typedef
 
428
EFI_STATUS
 
429
(EFIAPI *EFI_IO_MAP) (
 
430
    IN struct _EFI_DEVICE_IO_INTERFACE  *This,
 
431
    IN EFI_IO_OPERATION_TYPE            Operation,
 
432
    IN EFI_PHYSICAL_ADDRESS             *HostAddress,
 
433
    IN OUT UINTN                        *NumberOfBytes,
 
434
    OUT EFI_PHYSICAL_ADDRESS            *DeviceAddress,
 
435
    OUT VOID                            **Mapping
 
436
    );
 
437
 
 
438
typedef
 
439
EFI_STATUS
 
440
(EFIAPI *EFI_IO_UNMAP) (
 
441
    IN struct _EFI_DEVICE_IO_INTERFACE  *This,
 
442
    IN VOID                             *Mapping
 
443
    );
 
444
 
 
445
typedef
 
446
EFI_STATUS
 
447
(EFIAPI *EFI_IO_ALLOCATE_BUFFER) (
 
448
    IN struct _EFI_DEVICE_IO_INTERFACE  *This,
 
449
    IN EFI_ALLOCATE_TYPE                Type,
 
450
    IN EFI_MEMORY_TYPE                  MemoryType,
 
451
    IN UINTN                            Pages,
 
452
    IN OUT EFI_PHYSICAL_ADDRESS         *HostAddress
 
453
    );
 
454
 
 
455
typedef
 
456
EFI_STATUS
 
457
(EFIAPI *EFI_IO_FLUSH) (
 
458
    IN struct _EFI_DEVICE_IO_INTERFACE  *This
 
459
    );
 
460
 
 
461
typedef
 
462
EFI_STATUS
 
463
(EFIAPI *EFI_IO_FREE_BUFFER) (
 
464
    IN struct _EFI_DEVICE_IO_INTERFACE  *This,
 
465
    IN UINTN                            Pages,
 
466
    IN EFI_PHYSICAL_ADDRESS             HostAddress
 
467
    );
 
468
 
 
469
typedef struct _EFI_DEVICE_IO_INTERFACE {
 
470
    EFI_IO_ACCESS                       Mem;
 
471
    EFI_IO_ACCESS                       Io;
 
472
    EFI_IO_ACCESS                       Pci;
 
473
    EFI_IO_MAP                          Map;
 
474
    EFI_PCI_DEVICE_PATH                 PciDevicePath;
 
475
    EFI_IO_UNMAP                        Unmap;
 
476
    EFI_IO_ALLOCATE_BUFFER              AllocateBuffer;
 
477
    EFI_IO_FLUSH                        Flush;
 
478
    EFI_IO_FREE_BUFFER                  FreeBuffer;
 
479
} EFI_DEVICE_IO_INTERFACE;
 
480
 
 
481
 
 
482
//
 
483
// Unicode Collation protocol
 
484
//
 
485
 
 
486
#define UNICODE_COLLATION_PROTOCOL \
 
487
    { 0x1d85cd7f, 0xf43d, 0x11d2, {0x9a, 0xc,  0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} }
 
488
 
 
489
#define UNICODE_BYTE_ORDER_MARK       (CHAR16)(0xfeff)
 
490
 
 
491
INTERFACE_DECL(_EFI_UNICODE_COLLATION_INTERFACE);
 
492
 
 
493
typedef
 
494
INTN
 
495
(EFIAPI *EFI_UNICODE_STRICOLL) (
 
496
    IN struct _EFI_UNICODE_COLLATION_INTERFACE  *This,
 
497
    IN CHAR16                         *s1,
 
498
    IN CHAR16                         *s2
 
499
    );
 
500
 
 
501
typedef
 
502
BOOLEAN
 
503
(EFIAPI *EFI_UNICODE_METAIMATCH) (
 
504
    IN struct _EFI_UNICODE_COLLATION_INTERFACE  *This,
 
505
    IN CHAR16                         *String,
 
506
    IN CHAR16                         *Pattern
 
507
    );
 
508
 
 
509
typedef
 
510
VOID
 
511
(EFIAPI *EFI_UNICODE_STRLWR) (
 
512
    IN struct _EFI_UNICODE_COLLATION_INTERFACE  *This,
 
513
    IN OUT CHAR16                       *Str
 
514
    );
 
515
 
 
516
typedef
 
517
VOID
 
518
(EFIAPI *EFI_UNICODE_STRUPR) (
 
519
    IN struct _EFI_UNICODE_COLLATION_INTERFACE  *This,
 
520
    IN OUT CHAR16                       *Str
 
521
    );
 
522
 
 
523
typedef
 
524
VOID
 
525
(EFIAPI *EFI_UNICODE_FATTOSTR) (
 
526
    IN struct _EFI_UNICODE_COLLATION_INTERFACE  *This,
 
527
    IN UINTN                            FatSize,
 
528
    IN CHAR8                            *Fat,
 
529
    OUT CHAR16                          *String
 
530
    );
 
531
 
 
532
typedef
 
533
BOOLEAN
 
534
(EFIAPI *EFI_UNICODE_STRTOFAT) (
 
535
    IN struct _EFI_UNICODE_COLLATION_INTERFACE  *This,
 
536
    IN CHAR16                           *String,
 
537
    IN UINTN                            FatSize,
 
538
    OUT CHAR8                           *Fat
 
539
    );
 
540
 
 
541
 
 
542
typedef struct _EFI_UNICODE_COLLATION_INTERFACE {
 
543
 
 
544
    // general
 
545
    EFI_UNICODE_STRICOLL                StriColl;
 
546
    EFI_UNICODE_METAIMATCH              MetaiMatch;
 
547
    EFI_UNICODE_STRLWR                  StrLwr;
 
548
    EFI_UNICODE_STRUPR                  StrUpr;
 
549
 
 
550
    // for supporting fat volumes
 
551
    EFI_UNICODE_FATTOSTR                FatToStr;
 
552
    EFI_UNICODE_STRTOFAT                StrToFat;
 
553
 
 
554
    CHAR8                               *SupportedLanguages;
 
555
} EFI_UNICODE_COLLATION_INTERFACE;
 
556
 
 
557
#endif
 
558