]> git.proxmox.com Git - mirror_edk2.git/blob - EdkCompatibilityPkg/Compatibility/DataHubSmBiosRecordsOnPiSmBiosThunk/MemoryConv.c
projects / mirror_edk2.git / blob
? search:


20cd71a42e3dee61ee278196d885903c30bcc36d
[mirror_edk2.git] / EdkCompatibilityPkg / Compatibility / DataHubSmBiosRecordsOnPiSmBiosThunk / MemoryConv.c
1 /** @file
2 Routines that support Memory SubClass data records translation.
3
4 Copyright (c) 2009, Intel Corporation
5 All rights reserved. This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 **/
14
15 #include "Thunk.h"
16
17 /**
18 Field Filling Function for Memory SubClass record type 2 -- Physical Memory
19 Array.
20
21 @param StructureNode Pointer to SMBIOS_STRUCTURE_NODE which is current processed.
22 @param Offset Offset of SMBIOS record which RecordData will be filled.
23 @param RecordData RecordData buffer will be filled.
24 @param RecordDataSize The size of RecordData buffer.
25
26 @retval EFI_SUCCESS Success fill RecordData into SMBIOS's record buffer.
27 **/
28 EFI_STATUS
29 SmbiosFldMemoryType2 (
30 IN OUT SMBIOS_STRUCTURE_NODE *StructureNode,
31 IN UINT32 Offset,
32 IN VOID *RecordData,
33 IN UINT32 RecordDataSize
34 )
35 {
36 EFI_STATUS Status;
37 EFI_MEMORY_ARRAY_LOCATION_DATA *PhyMemArray;
38 FRAMEWORK_MEMORY_ARRAY_LOCATION_DATA *FrameworkPhyMemArray;
39 UINT32 MemoryCapacity;
40 UINT16 NumberMemoryDevices;
41 UINT16 Test16;
42
43 Status = EFI_SUCCESS;
44 PhyMemArray = (EFI_MEMORY_ARRAY_LOCATION_DATA *) RecordData;
45 FrameworkPhyMemArray = (FRAMEWORK_MEMORY_ARRAY_LOCATION_DATA *) RecordData;
46
47 *(UINT8 *) ((UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE16, Location)) = (UINT8) (PhyMemArray->MemoryArrayLocation);
48 *(UINT8 *) ((UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE16, Use)) = (UINT8) (PhyMemArray->MemoryArrayUse);
49 *(UINT8 *) ((UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE16, MemoryErrorCorrection)) = (UINT8) (PhyMemArray->MemoryErrorCorrection);
50
51 if (!FeaturePcdGet(PcdFrameworkCompatibilitySupport)) {
52 MemoryCapacity = (UINT32) (((UINTN) PhyMemArray->MaximumMemoryCapacity.Value) << PhyMemArray->MaximumMemoryCapacity.Exponent);
53 NumberMemoryDevices = PhyMemArray->NumberMemoryDevices;
54 } else {
55 //
56 // Support EDk/Framework defined Data strucutre.
57 //
58 MemoryCapacity = FrameworkPhyMemArray->MaximumMemoryCapacity;
59 NumberMemoryDevices = FrameworkPhyMemArray->NumberMemoryDevices;
60 }
61
62 CopyMem (
63 (UINT8 *) StructureNode->Structure + OFFSET_OF (SMBIOS_TABLE_TYPE16, MaximumCapacity),
64 &MemoryCapacity,
65 4
66 );
67
68 Test16 = 0xfffe;
69 CopyMem (
70 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE16, MemoryErrorInformationHandle),
71 &Test16,
72 2
73 );
74
75 CopyMem (
76 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE16, NumberOfMemoryDevices),
77 &NumberMemoryDevices,
78 2
79 );
80
81 return Status;
82 }
83
84 /**
85 Field Filling Function for Memory SubClass record type 3 -
86 - Memory Device: SMBIOS Type 17
87
88 @param StructureNode Pointer to SMBIOS_STRUCTURE_NODE which is current processed.
89 @param Offset Offset of SMBIOS record which RecordData will be filled.
90 @param RecordData RecordData buffer will be filled.
91 @param RecordDataSize The size of RecordData buffer.
92
93 @retval EFI_SUCCESS Success fill RecordData into SMBIOS's record buffer.
94 **/
95 EFI_STATUS
96 SmbiosFldMemoryType3 (
97 IN OUT SMBIOS_STRUCTURE_NODE *StructureNode,
98 IN UINT32 Offset,
99 IN VOID *RecordData,
100 IN UINT32 RecordDataSize
101 )
102 {
103 EFI_MEMORY_ARRAY_LINK_DATA *MemDevice;
104 FRAMEWORK_MEMORY_ARRAY_LINK_DATA *FrameworkMemDevice;
105 UINT64 MemoryDeviceSize;
106 BOOLEAN MemoryDeviceSizeUnitMega;
107 UINT16 MemoryDeviceSpeed;
108 UINT16 MemoryDeviceExponent;
109 UINT16 Test16;
110
111 MemDevice = (EFI_MEMORY_ARRAY_LINK_DATA *) RecordData;
112 FrameworkMemDevice = (FRAMEWORK_MEMORY_ARRAY_LINK_DATA *) RecordData;
113 MemoryDeviceSpeed = 0;
114 MemoryDeviceExponent = 0;
115
116 //
117 // Memory Device Locator
118 //
119 SmbiosFldString (
120 StructureNode,
121 OFFSET_OF (SMBIOS_TABLE_TYPE17, DeviceLocator),
122 &(MemDevice->MemoryDeviceLocator),
123 sizeof (STRING_REF)
124 );
125
126 //
127 // Memory Bank Locator
128 //
129 SmbiosFldString (
130 StructureNode,
131 OFFSET_OF (SMBIOS_TABLE_TYPE17, BankLocator),
132 &(MemDevice->MemoryBankLocator),
133 sizeof (STRING_REF)
134 );
135
136 //
137 // Memory Manufacturer
138 //
139 SmbiosFldString (
140 StructureNode,
141 OFFSET_OF (SMBIOS_TABLE_TYPE17, Manufacturer),
142 &(MemDevice->MemoryManufacturer),
143 sizeof (STRING_REF)
144 );
145
146 //
147 // Memory Serial Number
148 //
149 SmbiosFldString (
150 StructureNode,
151 OFFSET_OF (SMBIOS_TABLE_TYPE17, SerialNumber),
152 &(MemDevice->MemorySerialNumber),
153 sizeof (STRING_REF)
154 );
155
156 //
157 // Memory Asset Tag
158 //
159 SmbiosFldString (
160 StructureNode,
161 OFFSET_OF (SMBIOS_TABLE_TYPE17, AssetTag),
162 &(MemDevice->MemoryAssetTag),
163 sizeof (STRING_REF)
164 );
165
166 //
167 // Memory Part Number
168 //
169 SmbiosFldString (
170 StructureNode,
171 OFFSET_OF (SMBIOS_TABLE_TYPE17, PartNumber),
172 &(MemDevice->MemoryPartNumber),
173 sizeof (STRING_REF)
174 );
175
176 //
177 // Memory Array Link
178 //
179 SmbiosFldInterLink (
180 StructureNode,
181 (UINT16) OFFSET_OF (SMBIOS_TABLE_TYPE17, MemoryArrayHandle),
182 16, // SMBIOS type 16
183 &MemDevice->MemoryArrayLink,
184 &gEfiMemorySubClassGuid
185 );
186
187 //
188 // Set Memory Error Information Handle to Not supported
189 //
190 Test16 = 0xfffe;
191 CopyMem (
192 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE17, MemoryErrorInformationHandle),
193 &Test16,
194 sizeof (EFI_SMBIOS_HANDLE)
195 );
196
197 //
198 // Total width
199 //
200 CopyMem (
201 (UINT8 *) StructureNode->Structure + OFFSET_OF (SMBIOS_TABLE_TYPE17, TotalWidth),
202 &MemDevice->MemoryTotalWidth,
203 2
204 );
205
206 //
207 // Data Width
208 //
209 CopyMem (
210 (UINT8 *) StructureNode->Structure + OFFSET_OF (SMBIOS_TABLE_TYPE17, DataWidth),
211 &MemDevice->MemoryDataWidth,
212 2
213 );
214
215 //
216 // Device Size
217 //
218 if (!FeaturePcdGet(PcdFrameworkCompatibilitySupport)) {
219 //
220 // Form Factor
221 //
222 CopyMem (
223 (UINT8 *) StructureNode->Structure + OFFSET_OF (SMBIOS_TABLE_TYPE17, FormFactor),
224 &MemDevice->MemoryFormFactor,
225 1
226 );
227
228 //
229 // Device Set
230 //
231 CopyMem (
232 (UINT8 *) StructureNode->Structure + OFFSET_OF (SMBIOS_TABLE_TYPE17, DeviceSet),
233 &MemDevice->MemoryDeviceSet,
234 1
235 );
236
237 //
238 // Type
239 //
240 CopyMem (
241 (UINT8 *) StructureNode->Structure + OFFSET_OF (SMBIOS_TABLE_TYPE17, MemoryType),
242 &MemDevice->MemoryType,
243 1
244 );
245
246 //
247 // Type Detail
248 //
249 CopyMem (
250 (UINT8 *) StructureNode->Structure + OFFSET_OF (SMBIOS_TABLE_TYPE17, TypeDetail),
251 &MemDevice->MemoryTypeDetail,
252 2
253 );
254
255 //
256 // Speed
257 //
258 MemoryDeviceSpeed = MemDevice->MemorySpeed.Value;
259 MemoryDeviceExponent = MemDevice->MemorySpeed.Exponent;
260 while (MemoryDeviceExponent-- > 0) {
261 MemoryDeviceSpeed = (UINT16) (MemoryDeviceSpeed * 10);
262 }
263
264 CopyMem (
265 (UINT8 *) StructureNode->Structure + OFFSET_OF (SMBIOS_TABLE_TYPE17, Speed),
266 &MemoryDeviceSpeed,
267 2
268 );
269
270 MemoryDeviceSize = (UINT64) (((UINTN) MemDevice->MemoryDeviceSize.Value) << MemDevice->MemoryDeviceSize.Exponent);
271 } else {
272 //
273 // Form Factor
274 //
275 CopyMem (
276 (UINT8 *) StructureNode->Structure + OFFSET_OF (SMBIOS_TABLE_TYPE17, FormFactor),
277 &FrameworkMemDevice->MemoryFormFactor,
278 1
279 );
280
281 //
282 // Device Set
283 //
284 CopyMem (
285 (UINT8 *) StructureNode->Structure + OFFSET_OF (SMBIOS_TABLE_TYPE17, DeviceSet),
286 &FrameworkMemDevice->MemoryDeviceSet,
287 1
288 );
289
290 //
291 // Type
292 //
293 CopyMem (
294 (UINT8 *) StructureNode->Structure + OFFSET_OF (SMBIOS_TABLE_TYPE17, MemoryType),
295 &FrameworkMemDevice->MemoryType,
296 1
297 );
298
299 //
300 // Type Detail
301 //
302 CopyMem (
303 (UINT8 *) StructureNode->Structure + OFFSET_OF (SMBIOS_TABLE_TYPE17, TypeDetail),
304 &FrameworkMemDevice->MemoryTypeDetail,
305 2
306 );
307
308 //
309 // Speed
310 //
311 CopyMem (
312 (UINT8 *) StructureNode->Structure + OFFSET_OF (SMBIOS_TABLE_TYPE17, Speed),
313 &FrameworkMemDevice->MemorySpeed,
314 2
315 );
316
317 MemoryDeviceSize = FrameworkMemDevice->MemoryDeviceSize;
318 }
319
320 MemoryDeviceSizeUnitMega = FALSE;
321 MemoryDeviceSize = RShiftU64 (MemoryDeviceSize, 10);
322 //
323 // kilo as unit
324 //
325 if (MemoryDeviceSize > 0xffff) {
326 MemoryDeviceSize = RShiftU64 (MemoryDeviceSize, 10);
327 //
328 // Mega as unit
329 //
330 MemoryDeviceSizeUnitMega = TRUE;
331 }
332
333 MemoryDeviceSize = MemoryDeviceSize & 0x7fff;
334 if (MemoryDeviceSize != 0 && MemoryDeviceSizeUnitMega == FALSE) {
335 MemoryDeviceSize |= 0x8000;
336 }
337
338 CopyMem (
339 (UINT8 *) StructureNode->Structure + OFFSET_OF (SMBIOS_TABLE_TYPE17, Size),
340 &MemoryDeviceSize,
341 2
342 );
343
344 return EFI_SUCCESS;
345 }
346
347 /**
348 Field Filling Function for Memory SubClass record type 3 -
349 - Memory Device: SMBIOS Type 6
350
351 @param StructureNode Pointer to SMBIOS_STRUCTURE_NODE which is current processed.
352 @param Offset Offset of SMBIOS record which RecordData will be filled.
353 @param RecordData RecordData buffer will be filled.
354 @param RecordDataSize The size of RecordData buffer.
355
356 @retval EFI_SUCCESS Success fill RecordData into SMBIOS's record buffer.
357 **/
358 EFI_STATUS
359 SmbiosFldSMBIOSType6 (
360 IN OUT SMBIOS_STRUCTURE_NODE *StructureNode,
361 IN UINT32 Offset,
362 IN VOID *RecordData,
363 IN UINT32 RecordDataSize
364 )
365 {
366 EFI_MEMORY_ARRAY_LINK_DATA *MemDevice;
367 UINT64 MemoryDeviceSize;
368 UINT8 MemSize;
369 UINT16 MemType;
370 UINT8 MemSpeed;
371 FRAMEWORK_MEMORY_ARRAY_LINK_DATA *FrameworkMemDevice;
372 UINT16 MemoryDeviceSpeed;
373 UINT16 MemoryDeviceExponent;
374
375 MemDevice = (EFI_MEMORY_ARRAY_LINK_DATA *) RecordData;
376 FrameworkMemDevice = (FRAMEWORK_MEMORY_ARRAY_LINK_DATA *) RecordData;
377 MemoryDeviceExponent = 0;
378
379 //
380 // Memory Device Locator
381 //
382 SmbiosFldString (
383 StructureNode,
384 OFFSET_OF (SMBIOS_TABLE_TYPE6, SocketDesignation),
385 &(MemDevice->MemoryDeviceLocator),
386 2
387 );
388
389 if (!FeaturePcdGet(PcdFrameworkCompatibilitySupport)) {
390 MemoryDeviceSpeed = MemDevice->MemorySpeed.Value;
391 MemoryDeviceExponent = MemDevice->MemorySpeed.Exponent;
392 while (MemoryDeviceExponent-- > 0) {
393 MemoryDeviceSpeed = (UINT16) (MemoryDeviceSpeed * 10);
394 }
395 MemoryDeviceSize = (UINT64) (((UINTN) MemDevice->MemoryDeviceSize.Value) << MemDevice->MemoryDeviceSize.Exponent);
396 } else {
397 //
398 // Support EDk/Framework defined Data strucutre.
399 //
400 MemoryDeviceSpeed = FrameworkMemDevice->MemorySpeed;
401 MemoryDeviceSize = FrameworkMemDevice->MemoryDeviceSize;
402 }
403
404 if (MemoryDeviceSpeed == 0) {
405 MemSpeed = 0;
406 } else {
407 //
408 // Memory speed is in ns unit
409 //
410 MemSpeed = (UINT8)(1000 / MemoryDeviceSpeed);
411 }
412
413 CopyMem (
414 (UINT8*)StructureNode->Structure + OFFSET_OF (SMBIOS_TABLE_TYPE6, CurrentSpeed),
415 &MemSpeed,
416 1
417 );
418
419
420 //
421 // Device Size
422 //
423 MemSize = 0;
424 if (MemoryDeviceSize == 0) {
425 MemSize = 0x7F;
426 } else {
427 MemoryDeviceSize = RShiftU64 (MemoryDeviceSize, 21);
428 while (MemoryDeviceSize != 0) {
429 MemSize++;
430 MemoryDeviceSize = RShiftU64(MemoryDeviceSize,1);
431 }
432 }
433
434 CopyMem (
435 (UINT8*)StructureNode->Structure + OFFSET_OF (SMBIOS_TABLE_TYPE6, InstalledSize),
436 &MemSize,
437 1
438 );
439
440 CopyMem (
441 (UINT8*)StructureNode->Structure + OFFSET_OF (SMBIOS_TABLE_TYPE6, EnabledSize),
442 &MemSize,
443 1
444 );
445
446 //
447 // According SMBIOS SPEC Type 6 definition
448 //
449 MemType = 0;
450 if (!FeaturePcdGet(PcdFrameworkCompatibilitySupport)) {
451 if (MemDevice->MemoryFormFactor == EfiMemoryFormFactorDimm ||
452 MemDevice->MemoryFormFactor == EfiMemoryFormFactorFbDimm) {
453 MemType |= 1<<8;
454 }
455
456 if (MemDevice->MemoryFormFactor == EfiMemoryFormFactorSimm) {
457 MemType |= 1<<7;
458 }
459
460 if (MemDevice->MemoryType == EfiMemoryTypeSdram) {
461 MemType |= 1<<10;
462 }
463
464 if (MemDevice->MemoryTypeDetail.Edo == 1) {
465 MemType |= 1<<4;
466 }
467
468 if (MemDevice->MemoryTypeDetail.FastPaged == 1) {
469 MemType |= 1<<3;
470 }
471 } else {
472 //
473 // Support EDk/Framework defined Data strucutre.
474 //
475 if (FrameworkMemDevice->MemoryFormFactor == EfiMemoryFormFactorDimm ||
476 FrameworkMemDevice->MemoryFormFactor == EfiMemoryFormFactorFbDimm) {
477 MemType |= 1<<8;
478 }
479
480 if (FrameworkMemDevice->MemoryFormFactor == EfiMemoryFormFactorSimm) {
481 MemType |= 1<<7;
482 }
483
484 if (FrameworkMemDevice->MemoryType == EfiMemoryTypeSdram) {
485 MemType |= 1<<10;
486 }
487
488 if (FrameworkMemDevice->MemoryTypeDetail.Edo == 1) {
489 MemType |= 1<<4;
490 }
491
492 if (FrameworkMemDevice->MemoryTypeDetail.FastPaged == 1) {
493 MemType |= 1<<3;
494 }
495 }
496 //
497 // Form Factor
498 //
499 CopyMem (
500 (UINT8*)StructureNode->Structure + OFFSET_OF (SMBIOS_TABLE_TYPE6, CurrentMemoryType),
501 &MemType,
502 2
503 );
504
505
506 return EFI_SUCCESS;
507 }
508
509 /**
510 Field Filling Function for Memory SubClass record type 4
511 -- Memory Array Mapped Address: SMBIOS Type 19
512
513 @param StructureNode Pointer to SMBIOS_STRUCTURE_NODE which is current processed.
514 @param Offset Offset of SMBIOS record which RecordData will be filled.
515 @param RecordData RecordData buffer will be filled.
516 @param RecordDataSize The size of RecordData buffer.
517
518 @retval EFI_SUCCESS Success fill RecordData into SMBIOS's record buffer.
519 **/
520 EFI_STATUS
521 SmbiosFldMemoryType4 (
522 IN OUT SMBIOS_STRUCTURE_NODE *StructureNode,
523 IN UINT32 Offset,
524 IN VOID *RecordData,
525 IN UINT32 RecordDataSize
526 )
527 {
528 EFI_MEMORY_ARRAY_START_ADDRESS_DATA *Masa;
529 EFI_PHYSICAL_ADDRESS TempData;
530
531 Masa = (EFI_MEMORY_ARRAY_START_ADDRESS_DATA *) RecordData;
532
533 //
534 // Starting Address
535 //
536 TempData = RShiftU64 (Masa->MemoryArrayStartAddress, 10);
537 CopyMem (
538 (UINT8 *) StructureNode->Structure + OFFSET_OF (SMBIOS_TABLE_TYPE19, StartingAddress),
539 &TempData,
540 4
541 );
542
543 //
544 // Ending Address
545 //
546 TempData = RShiftU64 (Masa->MemoryArrayEndAddress, 10);
547 CopyMem (
548 (UINT8 *) StructureNode->Structure + OFFSET_OF (SMBIOS_TABLE_TYPE19, EndingAddress),
549 &TempData,
550 4
551 );
552
553 //
554 // Partition Width
555 //
556 CopyMem (
557 (UINT8 *) StructureNode->Structure + OFFSET_OF (SMBIOS_TABLE_TYPE19, PartitionWidth),
558 &Masa->MemoryArrayPartitionWidth,
559 1
560 );
561
562 //
563 // Physical Memory Array Link
564 //
565 return SmbiosFldInterLink (
566 StructureNode,
567 (UINT16) OFFSET_OF (SMBIOS_TABLE_TYPE19, MemoryArrayHandle),
568 16, // SMBIOS type 16
569 &Masa->PhysicalMemoryArrayLink,
570 &gEfiMemorySubClassGuid
571 );
572
573 }
574
575 /**
576 Field Filling Function for Memory SubClass record type 5
577 -- Memory Device Mapped Address: SMBIOS Type 20
578
579 @param StructureNode Pointer to SMBIOS_STRUCTURE_NODE which is current processed.
580 @param Offset Offset of SMBIOS record which RecordData will be filled.
581 @param RecordData RecordData buffer will be filled.
582 @param RecordDataSize The size of RecordData buffer.
583
584 @retval EFI_SUCCESS Success fill RecordData into SMBIOS's record buffer.
585 **/
586 EFI_STATUS
587 SmbiosFldMemoryType5 (
588 IN OUT SMBIOS_STRUCTURE_NODE *StructureNode,
589 IN UINT32 Offset,
590 IN VOID *RecordData,
591 IN UINT32 RecordDataSize
592 )
593 {
594 EFI_MEMORY_DEVICE_START_ADDRESS_DATA *Mdsa;
595 EFI_PHYSICAL_ADDRESS TempData;
596
597 Mdsa = (EFI_MEMORY_DEVICE_START_ADDRESS_DATA *) RecordData;
598
599 //
600 // Starting Address
601 //
602 TempData = RShiftU64 (Mdsa->MemoryDeviceStartAddress, 10);
603 CopyMem (
604 (UINT8 *) StructureNode->Structure + OFFSET_OF (SMBIOS_TABLE_TYPE20, StartingAddress),
605 &TempData,
606 4
607 );
608
609 //
610 // Ending Address
611 //
612 TempData = RShiftU64 (Mdsa->MemoryDeviceEndAddress, 10);
613 CopyMem (
614 (UINT8 *) StructureNode->Structure + OFFSET_OF (SMBIOS_TABLE_TYPE20, EndingAddress),
615 &TempData,
616 4
617 );
618
619 //
620 // Memory Device Link
621 //
622 SmbiosFldInterLink (
623 StructureNode,
624 (UINT16) OFFSET_OF (SMBIOS_TABLE_TYPE20, MemoryDeviceHandle),
625 17, // SMBIOS type 17
626 &Mdsa->PhysicalMemoryDeviceLink,
627 &gEfiMemorySubClassGuid
628 );
629
630 //
631 // Memory Array Mapped Address Link
632 //
633 SmbiosFldInterLink (
634 StructureNode,
635 (UINT16) OFFSET_OF (SMBIOS_TABLE_TYPE20, MemoryArrayMappedAddressHandle),
636 19, // SMBIOS type 19
637 &Mdsa->PhysicalMemoryArrayLink,
638 &gEfiMemorySubClassGuid
639 );
640
641 //
642 // Memory Device Partition Row Position
643 //
644 *(UINT8 *) ((UINT8 *) StructureNode->Structure + OFFSET_OF (SMBIOS_TABLE_TYPE20, PartitionRowPosition)) = (UINT8) Mdsa->MemoryDevicePartitionRowPosition;
645
646 //
647 // Memory Device Interleave Position
648 //
649 *(UINT8 *) ((UINT8 *) StructureNode->Structure + OFFSET_OF (SMBIOS_TABLE_TYPE20, InterleavePosition)) = (UINT8) Mdsa->MemoryDeviceInterleavePosition;
650
651 //
652 // Memory Device Interleave Data Depth
653 //
654 *(UINT8 *) ((UINT8 *) StructureNode->Structure + OFFSET_OF (SMBIOS_TABLE_TYPE20, InterleavedDataDepth)) = (UINT8) Mdsa->MemoryDeviceInterleaveDataDepth;
655
656 return EFI_SUCCESS;
657 }
658
659 /**
660 Field Filling Function for Memory SubClass record type 6
661 -- Memory Channel Type: SMBIOS Type 37
662
663 @param StructureNode Pointer to SMBIOS_STRUCTURE_NODE which is current processed.
664 @param Offset Offset of SMBIOS record which RecordData will be filled.
665 @param RecordData RecordData buffer will be filled.
666 @param RecordDataSize The size of RecordData buffer.
667
668 @retval EFI_SUCCESS Success fill RecordData into SMBIOS's record buffer.
669 **/
670 EFI_STATUS
671 SmbiosFldMemoryType6 (
672 IN OUT SMBIOS_STRUCTURE_NODE *StructureNode,
673 IN UINT32 Offset,
674 IN VOID *RecordData,
675 IN UINT32 RecordDataSize
676 )
677 {
678 EFI_MEMORY_CHANNEL_TYPE_DATA *McTa;
679 EFI_STATUS Status;
680
681 McTa = (EFI_MEMORY_CHANNEL_TYPE_DATA *) RecordData;
682
683 *(UINT8 *) ((UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE37, ChannelType)) = (UINT8) (McTa->MemoryChannelType);
684
685 *(UINT8 *) ((UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE37, MaximumChannelLoad)) = (UINT8) (McTa->MemoryChannelMaximumLoad);
686
687 *(UINT8 *) ((UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE37, MemoryDeviceCount)) = (UINT8) (McTa->MemoryChannelDeviceCount);
688
689 //
690 // Update the length field
691 // Multiple device loads are filled through SmbiosFldMemoryType7
692 //
693 StructureNode->Structure->Length = (UINT8)(StructureNode->Structure->Length +
694 sizeof(MEMORY_DEVICE) * McTa->MemoryChannelDeviceCount);
695 Status = SmbiosEnlargeStructureBuffer(
696 StructureNode,
697 StructureNode->Structure->Length,
698 StructureNode->StructureSize,
699 StructureNode->StructureSize + sizeof(MEMORY_DEVICE) * McTa->MemoryChannelDeviceCount
700 );
701 return Status;
702 }
703
704 /**
705 Field Filling Function for Memory SubClass record type 7
706 -- Memory Channel Device: SMBIOS Type 37
707
708 @param StructureNode Pointer to SMBIOS_STRUCTURE_NODE which is current processed.
709 @param Offset Offset of SMBIOS record which RecordData will be filled.
710 @param RecordData RecordData buffer will be filled.
711 @param RecordDataSize The size of RecordData buffer.
712
713 @retval EFI_SUCCESS Success fill RecordData into SMBIOS's record buffer.
714 **/
715 EFI_STATUS
716 SmbiosFldMemoryType7 (
717 IN OUT SMBIOS_STRUCTURE_NODE *StructureNode,
718 IN UINT32 Offset,
719 IN VOID *RecordData,
720 IN UINT32 RecordDataSize
721 )
722 {
723 EFI_MEMORY_CHANNEL_DEVICE_DATA *Mcdd;
724 UINTN DeviceLoadOffset;
725 UINTN DeviceLoadHandleOffset;
726
727 Mcdd = (EFI_MEMORY_CHANNEL_DEVICE_DATA *) RecordData;
728
729 if (Mcdd->DeviceId < 1) {
730 return EFI_INVALID_PARAMETER;
731 }
732
733 DeviceLoadOffset = OFFSET_OF (SMBIOS_TABLE_TYPE37, MemoryDevice[0]) + 3 * (Mcdd->DeviceId - 1);
734 DeviceLoadHandleOffset = OFFSET_OF (SMBIOS_TABLE_TYPE37, MemoryDevice[1]) + 3 * (Mcdd->DeviceId - 1);
735
736 *(UINT8 *) ((UINT8 *) (StructureNode->Structure) + DeviceLoadOffset) = (UINT8) (Mcdd->MemoryChannelDeviceLoad);
737
738 //
739 // Memory Device Handle Link
740 //
741 return SmbiosFldInterLink (
742 StructureNode,
743 (UINT16) DeviceLoadHandleOffset,
744 17, // Smbios type 17 -- Physical Memory Device
745 &Mcdd->DeviceLink,
746 &gEfiMemorySubClassGuid
747 );
748
749 }
750
751 /**
752 Field Filling Function for Memory SubClass record type 8
753 -- Memory Controller information: SMBIOS Type 5
754
755 @param StructureNode Pointer to SMBIOS_STRUCTURE_NODE which is current processed.
756 @param Offset Offset of SMBIOS record which RecordData will be filled.
757 @param RecordData RecordData buffer will be filled.
758 @param RecordDataSize The size of RecordData buffer.
759
760 @retval EFI_SUCCESS Success fill RecordData into SMBIOS's record buffer.
761 **/
762 EFI_STATUS
763 SmbiosFldMemoryType8 (
764 IN OUT SMBIOS_STRUCTURE_NODE *StructureNode,
765 IN UINT32 Offset,
766 IN VOID *RecordData,
767 IN UINT32 RecordDataSize
768 )
769 {
770 EFI_MEMORY_CONTROLLER_INFORMATION_DATA *MemoryController;
771 UINT32 NewMinimalSize;
772 UINT16 Count;
773 EFI_INTER_LINK_DATA *Link;
774 EFI_STATUS Status;
775
776 NewMinimalSize = 0;
777
778 //
779 // There is an update from EFI_MEMORY_CONTROLLER_INFORMATION to
780 // EFI_MEMORY_CONTROLLER_INFORMATION_DATA. Multiple MemoryModuleConfig
781 // handles are filled.
782 //
783 MemoryController = (EFI_MEMORY_CONTROLLER_INFORMATION_DATA *)RecordData;
784
785 //
786 // ErrorDetectingMethod
787 //
788 CopyMem (
789 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE5, ErrDetectMethod),
790 &MemoryController->ErrorDetectingMethod,
791 1
792 );
793
794 //
795 // ErrorCorrectingCapability
796 //
797 CopyMem (
798 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE5, ErrCorrectCapability),
799 &MemoryController->ErrorCorrectingCapability,
800 1
801 );
802
803 //
804 // MemorySupportedInterleave
805 //
806 CopyMem (
807 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE5, SupportInterleave),
808 &MemoryController->MemorySupportedInterleave,
809 1
810 );
811
812 //
813 // MemoryCurrentInterleave
814 //
815 CopyMem (
816 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE5, CurrentInterleave),
817 &MemoryController->MemoryCurrentInterleave,
818 1
819 );
820
821 //
822 // MaxMemoryModuleSize
823 //
824 CopyMem (
825 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE5, MaxMemoryModuleSize),
826 &MemoryController->MaxMemoryModuleSize,
827 1
828 );
829
830 //
831 // MemorySpeedType
832 //
833 CopyMem (
834 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE5, SupportSpeed),
835 &MemoryController->MemorySpeedType,
836 2
837 );
838
839 //
840 // MemorySupportedType
841 //
842 CopyMem (
843 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE5, SupportMemoryType),
844 &MemoryController->MemorySupportedType,
845 2
846 );
847
848 //
849 // MemoryModuleVoltage
850 //
851 CopyMem (
852 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE5, MemoryModuleVoltage),
853 &MemoryController->MemoryModuleVoltage,
854 1
855 );
856
857 //
858 // NumberofMemorySlot
859 //
860 CopyMem (
861 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE5, AssociatedMemorySlotNum),
862 &MemoryController->NumberofMemorySlot,
863 1
864 );
865
866 if (MemoryController->NumberofMemorySlot == 0) {
867 //
868 // EnabledCorrectingCapability
869 //
870 CopyMem (
871 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE5, MemoryModuleConfigHandles),
872 &MemoryController->EnabledCorrectingCapability,
873 1
874 );
875 } else {
876 //
877 // Memory module configuration handles exist
878 // we should enlarge smbios entry buffer from minimal size
879 //
880 NewMinimalSize = (MemoryController->NumberofMemorySlot) * sizeof(UINT16) + StructureNode->StructureSize;
881 StructureNode->Structure->Length = (UINT8) (NewMinimalSize - 2);
882 Status = SmbiosEnlargeStructureBuffer (StructureNode, StructureNode->Structure->Length, StructureNode->StructureSize, NewMinimalSize);
883 ASSERT_EFI_ERROR (Status);
884
885 //
886 // MemoryModuleConfigHandles
887 //
888 for (Count = 0, Link = MemoryController->MemoryModuleConfig;
889 Count < MemoryController->NumberofMemorySlot;
890 Count++, Link++) {
891 SmbiosFldInterLink (
892 StructureNode,
893 (UINT16) (OFFSET_OF (SMBIOS_TABLE_TYPE5, MemoryModuleConfigHandles) + Count * sizeof(UINT16)),
894 6, // SMBIOS type 6
895 Link,
896 &gEfiMemorySubClassGuid
897 );
898 }
899
900 //
901 // EnabledCorrectingCapability
902 //
903 CopyMem (
904 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE5, MemoryModuleConfigHandles) + (MemoryController->NumberofMemorySlot) * sizeof(UINT16),
905 &MemoryController->EnabledCorrectingCapability,
906 1
907 );
908 }
909
910 return EFI_SUCCESS;
911 }
912
913 /**
914 Field Filling Function for Memory SubClass record type
915 -- Memory 32 Bit Error Information: SMBIOS Type 18
916
917 @param StructureNode Pointer to SMBIOS_STRUCTURE_NODE which is current processed.
918 @param Offset Offset of SMBIOS record which RecordData will be filled.
919 @param RecordData RecordData buffer will be filled.
920 @param RecordDataSize The size of RecordData buffer.
921
922 @retval EFI_SUCCESS Success fill RecordData into SMBIOS's record buffer.
923 **/
924 EFI_STATUS
925 SmbiosFldMemoryType9 (
926 IN OUT SMBIOS_STRUCTURE_NODE *StructureNode,
927 IN UINT32 Offset,
928 IN VOID *RecordData,
929 IN UINT32 RecordDataSize
930 )
931 {
932 EFI_MEMORY_32BIT_ERROR_INFORMATION *MemoryInfo;
933
934 MemoryInfo = (EFI_MEMORY_32BIT_ERROR_INFORMATION *)RecordData;
935
936 //
937 // MemoryErrorType
938 //
939 CopyMem (
940 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE18, ErrorType),
941 &MemoryInfo->MemoryErrorType,
942 1
943 );
944
945 //
946 // MemoryErrorGranularity
947 //
948 CopyMem (
949 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE18, ErrorGranularity),
950 &MemoryInfo->MemoryErrorGranularity,
951 1
952 );
953
954 //
955 // MemoryErrorOperation
956 //
957 CopyMem (
958 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE18, ErrorOperation),
959 &MemoryInfo->MemoryErrorOperation,
960 1
961 );
962
963 //
964 // VendorSyndrome
965 //
966 CopyMem (
967 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE18, VendorSyndrome),
968 &MemoryInfo->VendorSyndrome,
969 4
970 );
971
972 //
973 // MemoryArrayErrorAddress
974 //
975 CopyMem (
976 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE18, MemoryArrayErrorAddress),
977 &MemoryInfo->MemoryArrayErrorAddress,
978 4
979 );
980
981 //
982 // DeviceErrorAddress
983 //
984 CopyMem (
985 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE18, DeviceErrorAddress),
986 &MemoryInfo->DeviceErrorAddress,
987 4
988 );
989
990 //
991 // DeviceErrorResolution
992 //
993 CopyMem (
994 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE18, ErrorResolution),
995 &MemoryInfo->DeviceErrorResolution,
996 4
997 );
998
999 return EFI_SUCCESS;
1000 }
1001
1002 /**
1003 Field Filling Function for Memory SubClass record type
1004 -- Memory 64 Bit Error Information: SMBIOS Type 33
1005
1006 @param StructureNode Pointer to SMBIOS_STRUCTURE_NODE which is current processed.
1007 @param Offset Offset of SMBIOS record which RecordData will be filled.
1008 @param RecordData RecordData buffer will be filled.
1009 @param RecordDataSize The size of RecordData buffer.
1010
1011 @retval EFI_SUCCESS Success fill RecordData into SMBIOS's record buffer.
1012 **/
1013 EFI_STATUS
1014 SmbiosFldMemoryType10 (
1015 IN OUT SMBIOS_STRUCTURE_NODE *StructureNode,
1016 IN UINT32 Offset,
1017 IN VOID *RecordData,
1018 IN UINT32 RecordDataSize
1019 )
1020 {
1021 EFI_MEMORY_64BIT_ERROR_INFORMATION *MemoryInfo;
1022
1023 MemoryInfo = (EFI_MEMORY_64BIT_ERROR_INFORMATION *)RecordData;
1024
1025 //
1026 // MemoryErrorType
1027 //
1028 CopyMem (
1029 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE33, ErrorType),
1030 &MemoryInfo->MemoryErrorType,
1031 1
1032 );
1033
1034 //
1035 // MemoryErrorGranularity
1036 //
1037 CopyMem (
1038 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE33, ErrorGranularity),
1039 &MemoryInfo->MemoryErrorGranularity,
1040 1
1041 );
1042
1043 //
1044 // MemoryErrorOperation
1045 //
1046 CopyMem (
1047 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE33, ErrorOperation),
1048 &MemoryInfo->MemoryErrorOperation,
1049 1
1050 );
1051
1052 //
1053 // VendorSyndrome
1054 //
1055 CopyMem (
1056 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE33, VendorSyndrome),
1057 &MemoryInfo->VendorSyndrome,
1058 4
1059 );
1060
1061 //
1062 // MemoryArrayErrorAddress
1063 //
1064 CopyMem (
1065 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE33, MemoryArrayErrorAddress),
1066 &MemoryInfo->MemoryArrayErrorAddress,
1067 8
1068 );
1069
1070 //
1071 // DeviceErrorAddress
1072 //
1073 CopyMem (
1074 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE33, DeviceErrorAddress),
1075 &MemoryInfo->DeviceErrorAddress,
1076 8
1077 );
1078
1079 //
1080 // DeviceErrorResolution
1081 //
1082 CopyMem (
1083 (UINT8 *) (StructureNode->Structure) + OFFSET_OF (SMBIOS_TABLE_TYPE33, ErrorResolution),
1084 &MemoryInfo->DeviceErrorResolution,
1085 4
1086 );
1087
1088 return EFI_SUCCESS;
1089 }
EFI Development Kit II mirror for PVE