]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Library/PiDxeS3BootScriptLib/BootScriptExecute.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
MdeModulePkg PiDxeS3BootScriptLib: Remove the trailing white spaces
[mirror_edk2.git] / MdeModulePkg / Library / PiDxeS3BootScriptLib / BootScriptExecute.c
1 /** @file
2 Interpret and execute the S3 data in S3 boot script.
3
4 Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR>
5
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions
8 of the BSD License which accompanies this distribution. The
9 full text of the license may be found at
10 http://opensource.org/licenses/bsd-license.php
11
12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
14
15 **/
16 #include "InternalBootScriptLib.h"
17
18 /**
19 Executes an SMBus operation to an SMBus controller. Returns when either the command has been
20 executed or an error is encountered in doing the operation.
21
22 The SmbusExecute() function provides a standard way to execute an operation as defined in the System
23 Management Bus (SMBus) Specification. The resulting transaction will be either that the SMBus
24 slave devices accept this transaction or that this function returns with error.
25
26 @param SmbusAddress Address that encodes the SMBUS Slave Address, SMBUS Command, SMBUS Data Length,
27 and PEC.
28 @param Operation Signifies which particular SMBus hardware protocol instance that
29 it will use to execute the SMBus transactions. This SMBus
30 hardware protocol is defined by the SMBus Specification and is
31 not related to EFI.
32 @param Length Signifies the number of bytes that this operation will do. The
33 maximum number of bytes can be revision specific and operation
34 specific. This field will contain the actual number of bytes that
35 are executed for this operation. Not all operations require this
36 argument.
37 @param Buffer Contains the value of data to execute to the SMBus slave device.
38 Not all operations require this argument. The length of this
39 buffer is identified by Length.
40
41 @retval EFI_SUCCESS The last data that was returned from the access matched the poll
42 exit criteria.
43 @retval EFI_CRC_ERROR Checksum is not correct (PEC is incorrect).
44 @retval EFI_TIMEOUT Timeout expired before the operation was completed. Timeout is
45 determined by the SMBus host controller device.
46 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources.
47 @retval EFI_DEVICE_ERROR The request was not completed because a failure that was
48 reflected in the Host Status Register bit. Device errors are a
49 result of a transaction collision, illegal command field,
50 unclaimed cycle (host initiated), or bus errors (collisions).
51 @retval EFI_INVALID_PARAMETER Operation is not defined in EFI_SMBUS_OPERATION.
52 @retval EFI_INVALID_PARAMETER Length/Buffer is NULL for operations except for EfiSmbusQuickRead
53 and EfiSmbusQuickWrite. Length is outside the range of valid
54 values.
55 @retval EFI_UNSUPPORTED The SMBus operation or PEC is not supported.
56 @retval EFI_BUFFER_TOO_SMALL Buffer is not sufficient for this operation.
57
58 **/
59 EFI_STATUS
60 SmbusExecute (
61 IN UINTN SmbusAddress,
62 IN EFI_SMBUS_OPERATION Operation,
63 IN OUT UINTN *Length,
64 IN OUT VOID *Buffer
65 )
66 {
67 EFI_STATUS Status;
68 UINT8 WorkBuffer[MAX_SMBUS_BLOCK_LEN];
69
70 switch (Operation) {
71 case EfiSmbusQuickRead:
72 DEBUG ((EFI_D_INFO, "EfiSmbusQuickRead - 0x%08x\n", SmbusAddress));
73 SmBusQuickRead (SmbusAddress, &Status);
74 break;
75 case EfiSmbusQuickWrite:
76 DEBUG ((EFI_D_INFO, "EfiSmbusQuickWrite - 0x%08x\n", SmbusAddress));
77 SmBusQuickWrite (SmbusAddress, &Status);
78 break;
79 case EfiSmbusReceiveByte:
80 DEBUG ((EFI_D_INFO, "EfiSmbusReceiveByte - 0x%08x\n", SmbusAddress));
81 SmBusReceiveByte (SmbusAddress, &Status);
82 break;
83 case EfiSmbusSendByte:
84 DEBUG ((EFI_D_INFO, "EfiSmbusSendByte - 0x%08x (0x%02x)\n", SmbusAddress, (UINTN)*(UINT8 *) Buffer));
85 SmBusSendByte (SmbusAddress, *(UINT8 *) Buffer, &Status);
86 break;
87 case EfiSmbusReadByte:
88 DEBUG ((EFI_D_INFO, "EfiSmbusReadByte - 0x%08x\n", SmbusAddress));
89 SmBusReadDataByte (SmbusAddress, &Status);
90 break;
91 case EfiSmbusWriteByte:
92 DEBUG ((EFI_D_INFO, "EfiSmbusWriteByte - 0x%08x (0x%02x)\n", SmbusAddress, (UINTN)*(UINT8 *) Buffer));
93 SmBusWriteDataByte (SmbusAddress, *(UINT8 *) Buffer, &Status);
94 break;
95 case EfiSmbusReadWord:
96 DEBUG ((EFI_D_INFO, "EfiSmbusReadWord - 0x%08x\n", SmbusAddress));
97 SmBusReadDataWord (SmbusAddress, &Status);
98 break;
99 case EfiSmbusWriteWord:
100 DEBUG ((EFI_D_INFO, "EfiSmbusWriteWord - 0x%08x (0x%04x)\n", SmbusAddress, (UINTN)*(UINT16 *) Buffer));
101 SmBusWriteDataWord (SmbusAddress, *(UINT16 *) Buffer, &Status);
102 break;
103 case EfiSmbusProcessCall:
104 DEBUG ((EFI_D_INFO, "EfiSmbusProcessCall - 0x%08x (0x%04x)\n", SmbusAddress, (UINTN)*(UINT16 *) Buffer));
105 SmBusProcessCall (SmbusAddress, *(UINT16 *) Buffer, &Status);
106 break;
107 case EfiSmbusReadBlock:
108 DEBUG ((EFI_D_INFO, "EfiSmbusReadBlock - 0x%08x\n", SmbusAddress));
109 SmBusReadBlock (SmbusAddress, WorkBuffer, &Status);
110 break;
111 case EfiSmbusWriteBlock:
112 DEBUG ((EFI_D_INFO, "EfiSmbusWriteBlock - 0x%08x\n", SmbusAddress));
113 SmBusWriteBlock ((SmbusAddress + SMBUS_LIB_ADDRESS (0, 0, (*Length), FALSE)), Buffer, &Status);
114 break;
115 case EfiSmbusBWBRProcessCall:
116 DEBUG ((EFI_D_INFO, "EfiSmbusBWBRProcessCall - 0x%08x\n", SmbusAddress));
117 SmBusBlockProcessCall ((SmbusAddress + SMBUS_LIB_ADDRESS (0, 0, (*Length), FALSE)), Buffer, WorkBuffer, &Status);
118 break;
119 default:
120 return EFI_INVALID_PARAMETER;
121 }
122
123 return Status;
124 }
125
126 /**
127 Translates boot script width and address stride to MDE library interface.
128
129
130 @param Width Width of the operation.
131 @param Address Address of the operation.
132 @param AddressStride Instride for stepping input buffer.
133 @param BufferStride Outstride for stepping output buffer.
134
135 @retval EFI_SUCCESS Successful translation.
136 @retval EFI_INVALID_PARAMETER Width or Address is invalid.
137 **/
138 EFI_STATUS
139 BuildLoopData (
140 IN S3_BOOT_SCRIPT_LIB_WIDTH Width,
141 IN UINT64 Address,
142 OUT UINTN *AddressStride,
143 OUT UINTN *BufferStride
144 )
145 {
146 UINTN AlignMask;
147
148 if (Width >= S3BootScriptWidthMaximum) {
149 return EFI_INVALID_PARAMETER;
150 }
151
152 *AddressStride = (UINT32)(1 << (Width & 0x03));
153 *BufferStride = *AddressStride;
154
155 AlignMask = *AddressStride - 1;
156 if ((Address & AlignMask) != 0) {
157 return EFI_INVALID_PARAMETER;
158 }
159
160 if (Width >= S3BootScriptWidthFifoUint8 && Width <= S3BootScriptWidthFifoUint64) {
161 *AddressStride = 0;
162 }
163
164 if (Width >= S3BootScriptWidthFillUint8 && Width <= S3BootScriptWidthFillUint64) {
165 *BufferStride = 0;
166 }
167
168 return EFI_SUCCESS;
169 }
170
171 /**
172 Perform IO read operation
173
174 @param[in] Width Width of the operation.
175 @param[in] Address Address of the operation.
176 @param[in] Count Count of the number of accesses to perform.
177 @param[out] Buffer Pointer to the buffer to read from I/O space.
178
179 @retval EFI_SUCCESS The data was written to the EFI System.
180 @retval EFI_INVALID_PARAMETER Width is invalid for this EFI System.
181 Buffer is NULL.
182 The Buffer is not aligned for the given Width.
183 Address is outside the legal range of I/O ports.
184
185 **/
186 EFI_STATUS
187 ScriptIoRead (
188 IN S3_BOOT_SCRIPT_LIB_WIDTH Width,
189 IN UINT64 Address,
190 IN UINTN Count,
191 OUT VOID *Buffer
192 )
193 {
194 EFI_STATUS Status;
195 UINTN AddressStride;
196 UINTN BufferStride;
197 PTR Out;
198
199 Out.Buf = (UINT8 *) Buffer;
200
201 if (Address > MAX_IO_ADDRESS) {
202 return EFI_INVALID_PARAMETER;
203 }
204
205 Status = BuildLoopData (Width, Address, &AddressStride, &BufferStride);
206 if (EFI_ERROR (Status)) {
207 return Status;
208 }
209 //
210 // Loop for each iteration and move the data
211 //
212 for (; Count > 0; Count--, Address += AddressStride, Out.Buf += BufferStride) {
213 switch (Width) {
214
215 case S3BootScriptWidthUint8:
216 DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint8 - 0x%08x\n", (UINTN) Address));
217 *Out.Uint8 = IoRead8 ((UINTN) Address);
218 break;
219 case S3BootScriptWidthFifoUint8:
220 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint8 - 0x%08x\n", (UINTN) Address));
221 *Out.Uint8 = IoRead8 ((UINTN) Address);
222 break;
223 case S3BootScriptWidthFillUint8:
224 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint8 - 0x%08x\n", (UINTN) Address));
225 *Out.Uint8 = IoRead8 ((UINTN) Address);
226 break;
227
228 case S3BootScriptWidthUint16:
229 DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint16 - 0x%08x\n", (UINTN) Address));
230 *Out.Uint16 = IoRead16 ((UINTN) Address);
231 break;
232 case S3BootScriptWidthFifoUint16:
233 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint16 - 0x%08x\n", (UINTN) Address));
234 *Out.Uint16 = IoRead16 ((UINTN) Address);
235 break;
236 case S3BootScriptWidthFillUint16:
237 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint16 - 0x%08x\n", (UINTN) Address));
238 *Out.Uint16 = IoRead16 ((UINTN) Address);
239 break;
240
241 case S3BootScriptWidthUint32:
242 DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint32 - 0x%08x\n", (UINTN) Address));
243 *Out.Uint32 = IoRead32 ((UINTN) Address);
244 break;
245 case S3BootScriptWidthFifoUint32:
246 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint32 - 0x%08x\n", (UINTN) Address));
247 *Out.Uint32 = IoRead32 ((UINTN) Address);
248 break;
249 case S3BootScriptWidthFillUint32:
250 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint32 - 0x%08x\n", (UINTN) Address));
251 *Out.Uint32 = IoRead32 ((UINTN) Address);
252 break;
253
254 case S3BootScriptWidthUint64:
255 DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint64 - 0x%08x\n", (UINTN) Address));
256 *Out.Uint64 = IoRead64 ((UINTN) Address);
257 break;
258 case S3BootScriptWidthFifoUint64:
259 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint64 - 0x%08x\n", (UINTN) Address));
260 *Out.Uint64 = IoRead64 ((UINTN) Address);
261 break;
262 case S3BootScriptWidthFillUint64:
263 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint64 - 0x%08x\n", (UINTN) Address));
264 *Out.Uint64 = IoRead64 ((UINTN) Address);
265 break;
266
267 default:
268 return EFI_INVALID_PARAMETER;
269 }
270 }
271
272 return EFI_SUCCESS;
273 }
274
275 /**
276 Perform IO write operation
277
278 @param[in] Width Width of the operation.
279 @param[in] Address Address of the operation.
280 @param[in] Count Count of the number of accesses to perform.
281 @param[in] Buffer Pointer to the buffer to write to I/O space.
282
283 @retval EFI_SUCCESS The data was written to the EFI System.
284 @retval EFI_INVALID_PARAMETER Width is invalid for this EFI System.
285 Buffer is NULL.
286 The Buffer is not aligned for the given Width.
287 Address is outside the legal range of I/O ports.
288
289 **/
290 EFI_STATUS
291 ScriptIoWrite (
292 IN S3_BOOT_SCRIPT_LIB_WIDTH Width,
293 IN UINT64 Address,
294 IN UINTN Count,
295 IN VOID *Buffer
296 )
297 {
298 EFI_STATUS Status;
299 UINTN AddressStride;
300 UINTN BufferStride;
301 UINT64 OriginalAddress;
302 PTR In;
303 PTR OriginalIn;
304
305 In.Buf = (UINT8 *) Buffer;
306
307 if (Address > MAX_IO_ADDRESS) {
308 return EFI_INVALID_PARAMETER;
309 }
310
311 Status = BuildLoopData (Width, Address, &AddressStride, &BufferStride);
312 if (EFI_ERROR (Status)) {
313 return Status;
314 }
315 //
316 // Loop for each iteration and move the data
317 //
318 OriginalAddress = Address;
319 OriginalIn.Buf = In.Buf;
320 for (; Count > 0; Count--, Address += AddressStride, In.Buf += BufferStride) {
321 switch (Width) {
322 case S3BootScriptWidthUint8:
323 DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint8 - 0x%08x (0x%02x)\n", (UINTN)Address, (UINTN)*In.Uint8));
324 IoWrite8 ((UINTN) Address, *In.Uint8);
325 break;
326 case S3BootScriptWidthFifoUint8:
327 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint8 - 0x%08x (0x%02x)\n", (UINTN)OriginalAddress, (UINTN)*In.Uint8));
328 IoWrite8 ((UINTN) OriginalAddress, *In.Uint8);
329 break;
330 case S3BootScriptWidthFillUint8:
331 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint8 - 0x%08x (0x%02x)\n", (UINTN)Address, (UINTN)*OriginalIn.Uint8));
332 IoWrite8 ((UINTN) Address, *OriginalIn.Uint8);
333 break;
334 case S3BootScriptWidthUint16:
335 DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint16 - 0x%08x (0x%04x)\n", (UINTN)Address, (UINTN)*In.Uint16));
336 IoWrite16 ((UINTN) Address, *In.Uint16);
337 break;
338 case S3BootScriptWidthFifoUint16:
339 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint16 - 0x%08x (0x%04x)\n", (UINTN)OriginalAddress, (UINTN)*In.Uint16));
340 IoWrite16 ((UINTN) OriginalAddress, *In.Uint16);
341 break;
342 case S3BootScriptWidthFillUint16:
343 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint16 - 0x%08x (0x%04x)\n", (UINTN)Address, (UINTN)*OriginalIn.Uint16));
344 IoWrite16 ((UINTN) Address, *OriginalIn.Uint16);
345 break;
346 case S3BootScriptWidthUint32:
347 DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint32 - 0x%08x (0x%08x)\n", (UINTN)Address, (UINTN)*In.Uint32));
348 IoWrite32 ((UINTN) Address, *In.Uint32);
349 break;
350 case S3BootScriptWidthFifoUint32:
351 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint32 - 0x%08x (0x%08x)\n", (UINTN)OriginalAddress, (UINTN)*In.Uint32));
352 IoWrite32 ((UINTN) OriginalAddress, *In.Uint32);
353 break;
354 case S3BootScriptWidthFillUint32:
355 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint32 - 0x%08x (0x%08x)\n", (UINTN)Address, (UINTN)*OriginalIn.Uint32));
356 IoWrite32 ((UINTN) Address, *OriginalIn.Uint32);
357 break;
358 case S3BootScriptWidthUint64:
359 DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint64 - 0x%08x (0x%016lx)\n", (UINTN)Address, *In.Uint64));
360 IoWrite64 ((UINTN) Address, *In.Uint64);
361 break;
362 case S3BootScriptWidthFifoUint64:
363 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint64 - 0x%08x (0x%016lx)\n", (UINTN)OriginalAddress, *In.Uint64));
364 IoWrite64 ((UINTN) OriginalAddress, *In.Uint64);
365 break;
366 case S3BootScriptWidthFillUint64:
367 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint64 - 0x%08x (0x%016lx)\n", (UINTN)Address, *OriginalIn.Uint64));
368 IoWrite64 ((UINTN) Address, *OriginalIn.Uint64);
369 break;
370 default:
371 return EFI_INVALID_PARAMETER;
372 }
373 }
374
375
376 return EFI_SUCCESS;
377 }
378 /**
379 Interprete the boot script node with EFI_BOOT_SCRIPT_IO_WRITE OP code.
380
381 @param Script Pointer to the node which is to be interpreted.
382
383 @retval EFI_SUCCESS The data was written to the EFI System.
384 @retval EFI_INVALID_PARAMETER Width is invalid for this EFI System.
385 Buffer is NULL.
386 The Buffer is not aligned for the given Width.
387 Address is outside the legal range of I/O ports.
388
389 **/
390 EFI_STATUS
391 BootScriptExecuteIoWrite (
392 IN UINT8 *Script
393 )
394 {
395 S3_BOOT_SCRIPT_LIB_WIDTH Width;
396 UINT64 Address;
397 UINTN Count;
398 VOID *Buffer;
399 EFI_BOOT_SCRIPT_IO_WRITE IoWrite;
400
401 CopyMem ((VOID*)&IoWrite, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_IO_WRITE));
402 Width = (S3_BOOT_SCRIPT_LIB_WIDTH) IoWrite.Width;
403 Address = IoWrite.Address;
404 Count = IoWrite.Count;
405 Buffer = Script + sizeof (EFI_BOOT_SCRIPT_IO_WRITE);
406
407 DEBUG ((EFI_D_INFO, "BootScriptExecuteIoWrite - 0x%08x, 0x%08x, 0x%08x\n", (UINTN)Address, Count, (UINTN)Width));
408 return ScriptIoWrite(Width, Address, Count, Buffer);
409 }
410 /**
411 Perform memory read operation
412
413 @param Width Width of the operation.
414 @param Address Address of the operation.
415 @param Count Count of the number of accesses to perform.
416 @param Buffer Pointer to the buffer read from memory.
417
418 @retval EFI_SUCCESS The data was written to the EFI System.
419 @retval EFI_INVALID_PARAMETER Width is invalid for this EFI System.
420 Buffer is NULL.
421 The Buffer is not aligned for the given Width.
422 @retval EFI_UNSUPPORTED The address range specified by Address, Width, and Count
423 is not valid for this EFI System.
424
425 **/
426 EFI_STATUS
427 ScriptMemoryRead (
428 IN S3_BOOT_SCRIPT_LIB_WIDTH Width,
429 IN UINT64 Address,
430 IN UINTN Count,
431 IN OUT VOID *Buffer
432 )
433 {
434 EFI_STATUS Status;
435 UINTN AddressStride;
436 UINTN BufferStride;
437 PTR Out;
438
439 Out.Buf = Buffer;
440
441 Status = BuildLoopData (Width, Address, &AddressStride, &BufferStride);
442 if (EFI_ERROR (Status)) {
443 return Status;
444 }
445 //
446 // Loop for each iteration and move the data
447 //
448 for (; Count > 0; Count--, Address += AddressStride, Out.Buf += BufferStride) {
449 switch (Width) {
450 case S3BootScriptWidthUint8:
451 DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint8 - 0x%08x\n", (UINTN)Address));
452 *Out.Uint8 = MmioRead8 ((UINTN) Address);
453 break;
454 case S3BootScriptWidthFifoUint8:
455 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint8 - 0x%08x\n", (UINTN)Address));
456 *Out.Uint8 = MmioRead8 ((UINTN) Address);
457 break;
458 case S3BootScriptWidthFillUint8:
459 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint8 - 0x%08x\n", (UINTN)Address));
460 *Out.Uint8 = MmioRead8 ((UINTN) Address);
461 break;
462
463 case S3BootScriptWidthUint16:
464 DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint16 - 0x%08x\n", (UINTN)Address));
465 *Out.Uint16 = MmioRead16 ((UINTN) Address);
466 break;
467 case S3BootScriptWidthFifoUint16:
468 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint16 - 0x%08x\n", (UINTN)Address));
469 *Out.Uint16 = MmioRead16 ((UINTN) Address);
470 break;
471 case S3BootScriptWidthFillUint16:
472 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint16 - 0x%08x\n", (UINTN)Address));
473 *Out.Uint16 = MmioRead16 ((UINTN) Address);
474 break;
475
476 case S3BootScriptWidthUint32:
477 DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint32 - 0x%08x\n", (UINTN)Address));
478 *Out.Uint32 = MmioRead32 ((UINTN) Address);
479 break;
480 case S3BootScriptWidthFifoUint32:
481 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint32 - 0x%08x\n", (UINTN)Address));
482 *Out.Uint32 = MmioRead32 ((UINTN) Address);
483 break;
484 case S3BootScriptWidthFillUint32:
485 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint32 - 0x%08x\n", (UINTN)Address));
486 *Out.Uint32 = MmioRead32 ((UINTN) Address);
487 break;
488
489 case S3BootScriptWidthUint64:
490 DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint64 - 0x%08x\n", (UINTN)Address));
491 *Out.Uint64 = MmioRead64 ((UINTN) Address);
492 break;
493 case S3BootScriptWidthFifoUint64:
494 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint64 - 0x%08x\n", (UINTN)Address));
495 *Out.Uint64 = MmioRead64 ((UINTN) Address);
496 break;
497 case S3BootScriptWidthFillUint64:
498 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint64 - 0x%08x\n", (UINTN)Address));
499 *Out.Uint64 = MmioRead64 ((UINTN) Address);
500 break;
501
502 default:
503 return EFI_UNSUPPORTED;
504 }
505 }
506
507 return EFI_SUCCESS;
508 }
509 /**
510 Perform memory write operation
511
512 @param Width Width of the operation.
513 @param Address Address of the operation.
514 @param Count Count of the number of accesses to perform.
515 @param Buffer Pointer to the buffer write to memory.
516
517 @retval EFI_SUCCESS The data was written to the EFI System.
518 @retval EFI_INVALID_PARAMETER Width is invalid for this EFI System.
519 Buffer is NULL.
520 The Buffer is not aligned for the given Width.
521 @retval EFI_UNSUPPORTED The address range specified by Address, Width, and Count
522 is not valid for this EFI System.
523
524 **/
525 EFI_STATUS
526 ScriptMemoryWrite (
527 IN S3_BOOT_SCRIPT_LIB_WIDTH Width,
528 IN UINT64 Address,
529 IN UINTN Count,
530 IN OUT VOID *Buffer
531 )
532 {
533 EFI_STATUS Status;
534 UINTN AddressStride;
535 UINT64 OriginalAddress;
536 UINTN BufferStride;
537 PTR In;
538 PTR OriginalIn;
539
540 In.Buf = Buffer;
541
542 Status = BuildLoopData (Width, Address, &AddressStride, &BufferStride);
543 if (EFI_ERROR (Status)) {
544 return Status;
545 }
546 //
547 // Loop for each iteration and move the data
548 //
549 OriginalAddress = Address;
550 OriginalIn.Buf = In.Buf;
551 for (; Count > 0; Count--, Address += AddressStride, In.Buf += BufferStride) {
552 switch (Width) {
553 case S3BootScriptWidthUint8:
554 DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint8 - 0x%08x (0x%02x)\n", (UINTN)Address, (UINTN)*In.Uint8));
555 MmioWrite8 ((UINTN) Address, *In.Uint8);
556 break;
557 case S3BootScriptWidthFifoUint8:
558 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint8 - 0x%08x (0x%02x)\n", (UINTN)OriginalAddress, (UINTN)*In.Uint8));
559 MmioWrite8 ((UINTN) OriginalAddress, *In.Uint8);
560 break;
561 case S3BootScriptWidthFillUint8:
562 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint8 - 0x%08x (0x%02x)\n", (UINTN)Address, (UINTN)*OriginalIn.Uint8));
563 MmioWrite8 ((UINTN) Address, *OriginalIn.Uint8);
564 break;
565 case S3BootScriptWidthUint16:
566 DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint16 - 0x%08x (0x%04x)\n", (UINTN)Address, (UINTN)*In.Uint16));
567 MmioWrite16 ((UINTN) Address, *In.Uint16);
568 break;
569 case S3BootScriptWidthFifoUint16:
570 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint16 - 0x%08x (0x%04x)\n", (UINTN)OriginalAddress, (UINTN)*In.Uint16));
571 MmioWrite16 ((UINTN) OriginalAddress, *In.Uint16);
572 break;
573 case S3BootScriptWidthFillUint16:
574 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint16 - 0x%08x (0x%04x)\n", (UINTN)Address, (UINTN)*OriginalIn.Uint16));
575 MmioWrite16 ((UINTN) Address, *OriginalIn.Uint16);
576 break;
577 case S3BootScriptWidthUint32:
578 DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint32 - 0x%08x (0x%08x)\n", (UINTN)Address, (UINTN)*In.Uint32));
579 MmioWrite32 ((UINTN) Address, *In.Uint32);
580 break;
581 case S3BootScriptWidthFifoUint32:
582 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint32 - 0x%08x (0x%08x)\n", (UINTN)OriginalAddress, (UINTN)*In.Uint32));
583 MmioWrite32 ((UINTN) OriginalAddress, *In.Uint32);
584 break;
585 case S3BootScriptWidthFillUint32:
586 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint32 - 0x%08x (0x%08x)\n", (UINTN)Address, (UINTN)*OriginalIn.Uint32));
587 MmioWrite32 ((UINTN) Address, *OriginalIn.Uint32);
588 break;
589 case S3BootScriptWidthUint64:
590 DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint64 - 0x%08x (0x%016lx)\n", (UINTN)Address, *In.Uint64));
591 MmioWrite64 ((UINTN) Address, *In.Uint64);
592 break;
593 case S3BootScriptWidthFifoUint64:
594 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint64 - 0x%08x (0x%016lx)\n", (UINTN)OriginalAddress, *In.Uint64));
595 MmioWrite64 ((UINTN) OriginalAddress, *In.Uint64);
596 break;
597 case S3BootScriptWidthFillUint64:
598 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint64 - 0x%08x (0x%016lx)\n", (UINTN)Address, *OriginalIn.Uint64));
599 MmioWrite64 ((UINTN) Address, *OriginalIn.Uint64);
600 break;
601 default:
602 return EFI_UNSUPPORTED;
603 }
604 }
605 return EFI_SUCCESS;
606 }
607 /**
608 Interprete the boot script node with EFI_BOOT_SCRIPT_MEM_WRITE OP code.
609
610 @param[in] Script Pointer to the node which is to be interpreted.
611
612 @retval EFI_SUCCESS The data was written to the EFI System.
613 @retval EFI_INVALID_PARAMETER Width is invalid for this EFI System.
614 Buffer is NULL.
615 The Buffer is not aligned for the given Width.
616 @retval EFI_UNSUPPORTED The address range specified by Address, Width, and Count
617 is not valid for this EFI System.
618
619 **/
620 EFI_STATUS
621 BootScriptExecuteMemoryWrite (
622 IN UINT8 *Script
623 )
624 {
625 VOID *Buffer;
626 S3_BOOT_SCRIPT_LIB_WIDTH Width;
627 UINT64 Address;
628 UINTN Count;
629 EFI_BOOT_SCRIPT_MEM_WRITE MemWrite;
630
631 CopyMem((VOID*)&MemWrite, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_MEM_WRITE));
632 Width = (S3_BOOT_SCRIPT_LIB_WIDTH)MemWrite.Width;
633 Address = MemWrite.Address;
634 Count = MemWrite.Count;
635 Buffer = Script + sizeof(EFI_BOOT_SCRIPT_MEM_WRITE);
636
637 DEBUG ((EFI_D_INFO, "BootScriptExecuteMemoryWrite - 0x%08x, 0x%08x, 0x%08x\n", (UINTN)Address, Count, (UINTN)Width));
638 return ScriptMemoryWrite (Width,Address, Count, Buffer);
639
640 }
641 /**
642 Performance PCI configuration read operation
643
644 @param Width Width of the operation.
645 @param Address Address of the operation.
646 @param Count Count of the number of accesses to perform.
647 @param Buffer Pointer to the buffer read from PCI config space
648
649 @retval EFI_SUCCESS The read succeed.
650 @retval EFI_INVALID_PARAMETER if Width is not defined
651 @note A known Limitations in the implementation which is 64bits operations are not supported.
652
653 **/
654 EFI_STATUS
655 ScriptPciCfgRead (
656 IN S3_BOOT_SCRIPT_LIB_WIDTH Width,
657 IN UINT64 Address,
658 IN UINTN Count,
659 OUT VOID *Buffer
660 )
661 {
662 EFI_STATUS Status;
663 UINTN AddressStride;
664 UINTN BufferStride;
665 PTR Out;
666 UINTN PciAddress;
667
668 Out.Buf = (UINT8 *) Buffer;
669
670 PciAddress = PCI_ADDRESS_ENCODE (Address);
671
672 Status = BuildLoopData (Width, PciAddress, &AddressStride, &BufferStride);
673 if (EFI_ERROR (Status)) {
674 return Status;
675 }
676 //
677 // Loop for each iteration and move the data
678 //
679 for (; Count > 0; Count--, PciAddress += AddressStride, Out.Buf += BufferStride) {
680 switch (Width) {
681 case S3BootScriptWidthUint8:
682 DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint8 - 0x%08x\n", PciAddress));
683 *Out.Uint8 = PciRead8 (PciAddress);
684 break;
685 case S3BootScriptWidthFifoUint8:
686 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint8 - 0x%08x\n", PciAddress));
687 *Out.Uint8 = PciRead8 (PciAddress);
688 break;
689 case S3BootScriptWidthFillUint8:
690 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint8 - 0x%08x\n", PciAddress));
691 *Out.Uint8 = PciRead8 (PciAddress);
692 break;
693
694 case S3BootScriptWidthUint16:
695 DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint16 - 0x%08x\n", PciAddress));
696 *Out.Uint16 = PciRead16 (PciAddress);
697 break;
698 case S3BootScriptWidthFifoUint16:
699 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint16 - 0x%08x\n", PciAddress));
700 *Out.Uint16 = PciRead16 (PciAddress);
701 break;
702 case S3BootScriptWidthFillUint16:
703 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint16 - 0x%08x\n", PciAddress));
704 *Out.Uint16 = PciRead16 (PciAddress);
705 break;
706
707 case S3BootScriptWidthUint32:
708 DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint32 - 0x%08x\n", PciAddress));
709 *Out.Uint32 = PciRead32 (PciAddress);
710 break;
711 case S3BootScriptWidthFifoUint32:
712 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint32 - 0x%08x\n", PciAddress));
713 *Out.Uint32 = PciRead32 (PciAddress);
714 break;
715 case S3BootScriptWidthFillUint32:
716 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint32 - 0x%08x\n", PciAddress));
717 *Out.Uint32 = PciRead32 (PciAddress);
718 break;
719
720 default:
721 return EFI_INVALID_PARAMETER;
722 }
723 }
724 return EFI_SUCCESS;
725 }
726
727 /**
728 Performance PCI configuration write operation
729
730 @param Width Width of the operation.
731 @param Address Address of the operation.
732 @param Count Count of the number of accesses to perform.
733 @param Buffer Pointer to the buffer write to PCI config space
734
735 @retval EFI_SUCCESS The write succeed.
736 @retval EFI_INVALID_PARAMETER if Width is not defined
737 @note A known Limitations in the implementation which is 64bits operations are not supported.
738
739 **/
740 EFI_STATUS
741 ScriptPciCfgWrite (
742 IN S3_BOOT_SCRIPT_LIB_WIDTH Width,
743 IN UINT64 Address,
744 IN UINTN Count,
745 IN VOID *Buffer
746 )
747 {
748 EFI_STATUS Status;
749 UINTN AddressStride;
750 UINTN BufferStride;
751 UINTN OriginalPciAddress;
752 PTR In;
753 PTR OriginalIn;
754 UINTN PciAddress;
755
756 In.Buf = (UINT8 *) Buffer;
757
758 PciAddress = PCI_ADDRESS_ENCODE (Address);
759
760 Status = BuildLoopData (Width, PciAddress, &AddressStride, &BufferStride);
761 if (EFI_ERROR (Status)) {
762 return Status;
763 }
764 //
765 // Loop for each iteration and move the data
766 //
767 OriginalPciAddress = PciAddress;
768 OriginalIn.Buf = In.Buf;
769 for (; Count > 0; Count--, PciAddress += AddressStride, In.Buf += BufferStride) {
770 switch (Width) {
771 case S3BootScriptWidthUint8:
772 DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint8 - 0x%08x (0x%02x)\n", PciAddress, (UINTN)*In.Uint8));
773 PciWrite8 (PciAddress, *In.Uint8);
774 break;
775 case S3BootScriptWidthFifoUint8:
776 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint8 - 0x%08x (0x%02x)\n", OriginalPciAddress, (UINTN)*In.Uint8));
777 PciWrite8 (OriginalPciAddress, *In.Uint8);
778 break;
779 case S3BootScriptWidthFillUint8:
780 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint8 - 0x%08x (0x%02x)\n", PciAddress, (UINTN)*OriginalIn.Uint8));
781 PciWrite8 (PciAddress, *OriginalIn.Uint8);
782 break;
783 case S3BootScriptWidthUint16:
784 DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint16 - 0x%08x (0x%04x)\n", PciAddress, (UINTN)*In.Uint16));
785 PciWrite16 (PciAddress, *In.Uint16);
786 break;
787 case S3BootScriptWidthFifoUint16:
788 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint16 - 0x%08x (0x%04x)\n", OriginalPciAddress, (UINTN)*In.Uint16));
789 PciWrite16 (OriginalPciAddress, *In.Uint16);
790 break;
791 case S3BootScriptWidthFillUint16:
792 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint16 - 0x%08x (0x%04x)\n", PciAddress, (UINTN)*OriginalIn.Uint16));
793 PciWrite16 (PciAddress, *OriginalIn.Uint16);
794 break;
795 case S3BootScriptWidthUint32:
796 DEBUG ((EFI_D_INFO, "S3BootScriptWidthUint32 - 0x%08x (0x%08x)\n", PciAddress, (UINTN)*In.Uint32));
797 PciWrite32 (PciAddress, *In.Uint32);
798 break;
799 case S3BootScriptWidthFifoUint32:
800 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFifoUint32 - 0x%08x (0x%08x)\n", OriginalPciAddress, (UINTN)*In.Uint32));
801 PciWrite32 (OriginalPciAddress, *In.Uint32);
802 break;
803 case S3BootScriptWidthFillUint32:
804 DEBUG ((EFI_D_INFO, "S3BootScriptWidthFillUint32 - 0x%08x (0x%08x)\n", (UINTN)PciAddress, (UINTN)*OriginalIn.Uint32));
805 PciWrite32 (PciAddress, *OriginalIn.Uint32);
806 break;
807 default:
808 return EFI_INVALID_PARAMETER;
809 }
810 }
811 return EFI_SUCCESS;
812 }
813 /**
814 Performance PCI configuration 2 read operation
815
816 @param Width Width of the operation.
817 @param Segment Pci segment number
818 @param Address Address of the operation.
819 @param Count Count of the number of accesses to perform.
820 @param Buffer Pointer to the buffer to read from PCI config space.
821
822 @retval EFI_SUCCESS The data was written to the EFI System.
823 @retval EFI_INVALID_PARAMETER Width is invalid for this EFI System.
824 Buffer is NULL.
825 The Buffer is not aligned for the given Width.
826 Address is outside the legal range of I/O ports.
827 @note A known Limitations in the implementation which is the 'Segment' parameter is assumed as
828 Zero, or else, assert.
829 **/
830 EFI_STATUS
831 ScriptPciCfg2Read (
832 IN S3_BOOT_SCRIPT_LIB_WIDTH Width,
833 IN UINT16 Segment,
834 IN UINT64 Address,
835 IN UINTN Count,
836 OUT VOID *Buffer
837 )
838 {
839 ASSERT (Segment==0);
840
841 return ScriptPciCfgRead (Width, Address, Count, Buffer);
842 }
843 /**
844 Performance PCI configuration 2 write operation
845
846 @param Width Width of the operation.
847 @param Segment Pci segment number
848 @param Address Address of the operation.
849 @param Count Count of the number of accesses to perform.
850 @param Buffer Pointer to the buffer to write to PCI config space.
851
852 @retval EFI_SUCCESS The data was written to the EFI System.
853 @retval EFI_INVALID_PARAMETER Width is invalid for this EFI System.
854 Buffer is NULL.
855 The Buffer is not aligned for the given Width.
856 Address is outside the legal range of I/O ports.
857 @note A known Limitations in the implementation which is the 'Segment' parameter is assumed as
858 Zero, or else, assert.
859
860 **/
861 EFI_STATUS
862 EFIAPI
863 ScriptPciCfg2Write (
864 IN S3_BOOT_SCRIPT_LIB_WIDTH Width,
865 IN UINT16 Segment,
866 IN UINT64 Address,
867 IN UINTN Count,
868 IN VOID *Buffer
869 )
870 {
871 ASSERT (Segment==0);
872 return ScriptPciCfgWrite (Width, Address, Count, Buffer);
873 }
874 /**
875 Interprete the boot script node with EFI_BOOT_SCRIPT_PCI_CONFIG_WRITE OP code.
876
877 @param Script The pointer of typed node in boot script table
878
879 @retval EFI_SUCCESS The operation was executed successfully
880 **/
881 EFI_STATUS
882 BootScriptExecutePciCfgWrite (
883 IN UINT8 *Script
884 )
885 {
886 VOID *Buffer;
887 S3_BOOT_SCRIPT_LIB_WIDTH Width;
888 UINT64 Address;
889 UINTN Count;
890 EFI_BOOT_SCRIPT_PCI_CONFIG_WRITE PciCfgWrite;
891
892 CopyMem ((VOID*)&PciCfgWrite, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_PCI_CONFIG_WRITE));
893
894 Width = (S3_BOOT_SCRIPT_LIB_WIDTH)PciCfgWrite.Width;
895 Address = PciCfgWrite.Address;
896 Count = PciCfgWrite.Count;
897 Buffer = Script + sizeof(EFI_BOOT_SCRIPT_PCI_CONFIG_WRITE);
898
899 DEBUG ((EFI_D_INFO, "BootScriptExecutePciCfgWrite - 0x%08x, 0x%08x, 0x%08x\n", PCI_ADDRESS_ENCODE (Address), Count, (UINTN)Width));
900 return ScriptPciCfgWrite (Width, Address, Count, Buffer);
901 }
902 /**
903 Interprete the boot script node with EFI_BOOT_SCRIPT_IO_READ_WRITE OP code.
904
905 @param Script The pointer of typed node in boot script table
906 @param AndMask Mask value for 'and' operation
907 @param OrMask Mask value for 'or' operation
908
909 @retval EFI_SUCCESS The operation was executed successfully
910 **/
911 EFI_STATUS
912 BootScriptExecuteIoReadWrite (
913 IN UINT8 *Script,
914 IN UINT64 AndMask,
915 IN UINT64 OrMask
916 )
917
918 {
919 EFI_STATUS Status;
920 UINT64 Data;
921 EFI_BOOT_SCRIPT_IO_READ_WRITE IoReadWrite;
922
923 Data = 0;
924
925 CopyMem((VOID*)&IoReadWrite, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_IO_READ_WRITE));
926
927 DEBUG ((EFI_D_INFO, "BootScriptExecuteIoReadWrite - 0x%08x, 0x%016lx, 0x%016lx\n", (UINTN)IoReadWrite.Address, AndMask, OrMask));
928
929 Status = ScriptIoRead (
930 (S3_BOOT_SCRIPT_LIB_WIDTH) IoReadWrite.Width,
931 IoReadWrite.Address,
932 1,
933 &Data
934 );
935 if (!EFI_ERROR (Status)) {
936 Data = (Data & AndMask) | OrMask;
937 Status = ScriptIoWrite (
938 (S3_BOOT_SCRIPT_LIB_WIDTH) IoReadWrite.Width,
939 IoReadWrite.Address,
940 1,
941 &Data
942 );
943 }
944 return Status;
945 }
946 /**
947 Interprete the boot script node with EFI_BOOT_SCRIPT_MEM_READ_WRITE OP code.
948
949 @param Script The pointer of typed node in boot script table
950 @param AndMask Mask value for 'and' operation
951 @param OrMask Mask value for 'or' operation
952
953 @retval EFI_SUCCESS The operation was executed successfully
954 **/
955 EFI_STATUS
956 BootScriptExecuteMemoryReadWrite (
957 IN UINT8 *Script,
958 IN UINT64 AndMask,
959 IN UINT64 OrMask
960 )
961
962 {
963 EFI_STATUS Status;
964 UINT64 Data;
965 EFI_BOOT_SCRIPT_MEM_READ_WRITE MemReadWrite;
966
967 Data = 0;
968
969 CopyMem((VOID*)&MemReadWrite, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_MEM_READ_WRITE));
970
971 DEBUG ((EFI_D_INFO, "BootScriptExecuteMemoryReadWrite - 0x%08x, 0x%016lx, 0x%016lx\n", (UINTN)MemReadWrite.Address, AndMask, OrMask));
972
973 Status = ScriptMemoryRead (
974 (S3_BOOT_SCRIPT_LIB_WIDTH) MemReadWrite.Width,
975 MemReadWrite.Address,
976 1,
977 &Data
978 );
979 if (!EFI_ERROR (Status)) {
980 Data = (Data & AndMask) | OrMask;
981 Status = ScriptMemoryWrite (
982 (S3_BOOT_SCRIPT_LIB_WIDTH) MemReadWrite.Width,
983 MemReadWrite.Address,
984 1,
985 &Data
986 );
987 }
988 return Status;
989 }
990 /**
991 Interprete the boot script node with EFI_BOOT_SCRIPT_PCI_CFG_READ_WRITE OP code.
992
993 @param Script The pointer of typed node in boot script table
994 @param AndMask Mask value for 'and' operation
995 @param OrMask Mask value for 'or' operation
996
997 @retval EFI_SUCCESS The operation was executed successfully
998 **/
999 EFI_STATUS
1000 BootScriptExecutePciCfgReadWrite (
1001 IN UINT8 *Script,
1002 IN UINT64 AndMask,
1003 IN UINT64 OrMask
1004 )
1005
1006 {
1007 EFI_STATUS Status;
1008 UINT64 Data;
1009 EFI_BOOT_SCRIPT_PCI_CONFIG_READ_WRITE PciCfgReadWrite;
1010
1011 Data = 0;
1012
1013 CopyMem((VOID*)&PciCfgReadWrite, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_PCI_CONFIG_READ_WRITE));
1014
1015 DEBUG ((EFI_D_INFO, "BootScriptExecutePciCfgReadWrite - 0x%08x, 0x%016lx, 0x%016lx\n", PCI_ADDRESS_ENCODE (PciCfgReadWrite.Address), AndMask, OrMask));
1016
1017 Status = ScriptPciCfgRead (
1018 (S3_BOOT_SCRIPT_LIB_WIDTH) PciCfgReadWrite.Width,
1019 PciCfgReadWrite.Address,
1020 1,
1021 &Data
1022 );
1023 if (EFI_ERROR (Status)) {
1024 return Status;
1025 }
1026
1027 Data = (Data & AndMask) | OrMask;
1028
1029 Status = ScriptPciCfgWrite (
1030 (S3_BOOT_SCRIPT_LIB_WIDTH) PciCfgReadWrite.Width,
1031 PciCfgReadWrite.Address,
1032 1,
1033 &Data
1034 );
1035
1036 return Status;
1037 }
1038 /**
1039 Interprete the boot script node with EFI_BOOT_SCRIPT_SMBUS_EXECUTE OP code.
1040
1041 @param Script The pointer of typed node in boot script table
1042
1043 @retval EFI_SUCCESS The operation was executed successfully
1044 @retval EFI_UNSUPPORTED Cannot locate smbus ppi or occur error of script execution
1045 @retval Others Result of script execution
1046 **/
1047 EFI_STATUS
1048 BootScriptExecuteSmbusExecute (
1049 IN UINT8 *Script
1050 )
1051 {
1052 UINTN SmBusAddress;
1053 UINTN DataSize;
1054 EFI_BOOT_SCRIPT_SMBUS_EXECUTE SmbusExecuteEntry;
1055
1056 CopyMem ((VOID*)&SmbusExecuteEntry, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_SMBUS_EXECUTE ));
1057
1058 DEBUG ((EFI_D_INFO, "BootScriptExecuteSmbusExecute - 0x%08x, 0x%08x\n", (UINTN)SmbusExecuteEntry.SmBusAddress, (UINTN)SmbusExecuteEntry.Operation));
1059
1060 SmBusAddress = (UINTN)SmbusExecuteEntry.SmBusAddress;
1061 DataSize = (UINTN) SmbusExecuteEntry.DataSize;
1062 return SmbusExecute (
1063 SmBusAddress,
1064 (EFI_SMBUS_OPERATION) SmbusExecuteEntry.Operation,
1065 &DataSize,
1066 Script + sizeof (EFI_BOOT_SCRIPT_SMBUS_EXECUTE)
1067 );
1068 }
1069 /**
1070 Interprete the boot script node with EFI_BOOT_SCRIPT_STALL OP code.
1071
1072 @param Script The pointer of typed node in boot script table
1073
1074 @retval EFI_SUCCESS The operation was executed successfully
1075 **/
1076 EFI_STATUS
1077 BootScriptExecuteStall (
1078 IN UINT8 *Script
1079 )
1080 {
1081 EFI_BOOT_SCRIPT_STALL Stall;
1082
1083 CopyMem ((VOID*)&Stall, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_STALL));
1084
1085 DEBUG ((EFI_D_INFO, "BootScriptExecuteStall - 0x%08x\n", (UINTN)Stall.Duration));
1086
1087 MicroSecondDelay ((UINTN) Stall.Duration);
1088 return EFI_SUCCESS;
1089 }
1090 /**
1091 Interprete the boot script node with EFI_BOOT_SCRIPT_DISPATCH OP code.
1092
1093 @param Script The pointer of typed node in boot script table
1094 @retval EFI_SUCCESS The operation was executed successfully
1095 **/
1096 EFI_STATUS
1097 BootScriptExecuteDispatch (
1098 IN UINT8 *Script
1099 )
1100 {
1101 EFI_STATUS Status;
1102 DISPATCH_ENTRYPOINT_FUNC EntryFunc;
1103 EFI_BOOT_SCRIPT_DISPATCH ScriptDispatch;
1104
1105 CopyMem ((VOID*)&ScriptDispatch, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_DISPATCH));
1106 EntryFunc = (DISPATCH_ENTRYPOINT_FUNC) (UINTN) (ScriptDispatch.EntryPoint);
1107
1108 DEBUG ((EFI_D_INFO, "BootScriptExecuteDispatch - 0x%08x\n", (UINTN)ScriptDispatch.EntryPoint));
1109
1110 Status = EntryFunc (NULL, NULL);
1111
1112 return Status;
1113 }
1114 /**
1115 Interprete the boot script node with EFI_BOOT_SCRIPT_DISPATCH_2 OP code.
1116
1117 @param Script The pointer of typed node in boot script table
1118 @retval EFI_SUCCESS The operation was executed successfully
1119 **/
1120 EFI_STATUS
1121 BootScriptExecuteDispatch2 (
1122 IN UINT8 *Script
1123 )
1124 {
1125 EFI_STATUS Status;
1126 DISPATCH_ENTRYPOINT_FUNC EntryFunc;
1127 EFI_BOOT_SCRIPT_DISPATCH_2 ScriptDispatch2;
1128
1129 CopyMem ((VOID*)&ScriptDispatch2, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_DISPATCH_2));
1130
1131 DEBUG ((EFI_D_INFO, "BootScriptExecuteDispatch2 - 0x%08x(0x%08x)\n", (UINTN)ScriptDispatch2.EntryPoint, (UINTN)ScriptDispatch2.Context));
1132
1133 EntryFunc = (DISPATCH_ENTRYPOINT_FUNC) (UINTN) (ScriptDispatch2.EntryPoint);
1134
1135 Status = EntryFunc (NULL, (VOID *) (UINTN) ScriptDispatch2.Context);
1136
1137 return Status;
1138 }
1139 /**
1140 Interprete the boot script node with EFI_BOOT_SCRIPT_MEM_POLL OP code.
1141
1142 @param Script The pointer of typed node in boot script table
1143 @param AndMask Mask value for 'and' operation
1144 @param OrMask Mask value for 'or' operation
1145
1146 @retval EFI_DEVICE_ERROR Data polled from memory does not equal to
1147 the epecting data within the Loop Times.
1148 @retval EFI_SUCCESS The operation was executed successfully
1149 **/
1150 EFI_STATUS
1151 BootScriptExecuteMemPoll (
1152 IN UINT8 *Script,
1153 IN UINT64 AndMask,
1154 IN UINT64 OrMask
1155 )
1156 {
1157
1158 UINT64 Data;
1159 UINT64 LoopTimes;
1160 EFI_STATUS Status;
1161 EFI_BOOT_SCRIPT_MEM_POLL MemPoll;
1162
1163 CopyMem ((VOID*)&MemPoll, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_MEM_POLL));
1164
1165 DEBUG ((EFI_D_INFO, "BootScriptExecuteMemPoll - 0x%08x, 0x%016lx, 0x%016lx\n", (UINTN)MemPoll.Address, AndMask, OrMask));
1166
1167 Data = 0;
1168 Status = ScriptMemoryRead (
1169 (S3_BOOT_SCRIPT_LIB_WIDTH) MemPoll.Width,
1170 MemPoll.Address,
1171 1,
1172 &Data
1173 );
1174 if ((!EFI_ERROR (Status)) && (Data & AndMask) == OrMask) {
1175 return EFI_SUCCESS;
1176 }
1177
1178 for (LoopTimes = 0; LoopTimes < MemPoll.LoopTimes; LoopTimes++) {
1179 MicroSecondDelay ((UINTN)MemPoll.Duration);
1180
1181 Data = 0;
1182 Status = ScriptMemoryRead (
1183 (S3_BOOT_SCRIPT_LIB_WIDTH) MemPoll.Width,
1184 MemPoll.Address,
1185 1,
1186 &Data
1187 );
1188 if ((!EFI_ERROR (Status)) && (Data & AndMask) == OrMask) {
1189 return EFI_SUCCESS;
1190 }
1191 }
1192
1193 if (LoopTimes < MemPoll.LoopTimes) {
1194 return EFI_SUCCESS;
1195 } else {
1196 return EFI_DEVICE_ERROR;
1197 }
1198 }
1199 /**
1200 Execute the boot script to interpret the Store arbitrary information.
1201 This opcode is a no-op on dispatch and is only used for debugging script issues.
1202
1203 @param Script The pointer of node in boot script table
1204
1205 **/
1206 VOID
1207 BootScriptExecuteInformation (
1208 IN UINT8 *Script
1209 )
1210
1211 {
1212 UINT32 Index;
1213 EFI_BOOT_SCRIPT_INFORMATION Information;
1214 UINT8 *InformationData;
1215
1216 CopyMem ((VOID*)&Information, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_INFORMATION));
1217
1218 InformationData = Script + sizeof (EFI_BOOT_SCRIPT_INFORMATION);
1219 DEBUG ((EFI_D_INFO, "BootScriptExecuteInformation - 0x%08x\n", (UINTN) InformationData));
1220
1221 DEBUG ((EFI_D_INFO, "BootScriptInformation: "));
1222 for (Index = 0; Index < Information.InformationLength; Index++) {
1223 DEBUG ((EFI_D_INFO, "%02x ", InformationData[Index]));
1224 }
1225 DEBUG ((EFI_D_INFO, "\n"));
1226 }
1227
1228 /**
1229 Execute the boot script to interpret the Label information.
1230
1231 @param Script The pointer of node in boot script table
1232
1233 **/
1234 VOID
1235 BootScriptExecuteLabel (
1236 IN UINT8 *Script
1237 )
1238
1239 {
1240 UINT32 Index;
1241 EFI_BOOT_SCRIPT_INFORMATION Information;
1242 UINT8 *InformationData;
1243
1244 CopyMem ((VOID*)&Information, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_INFORMATION));
1245
1246 InformationData = Script + sizeof (EFI_BOOT_SCRIPT_INFORMATION);
1247 DEBUG ((EFI_D_INFO, "BootScriptExecuteLabel - 0x%08x\n", (UINTN) InformationData));
1248
1249 DEBUG ((EFI_D_INFO, "BootScriptLabel: "));
1250 for (Index = 0; Index < Information.InformationLength; Index++) {
1251 DEBUG ((EFI_D_INFO, "%02x ", InformationData[Index]));
1252 }
1253 DEBUG ((EFI_D_INFO, "\n"));
1254 }
1255
1256 /**
1257 calculate the mask value for 'and' and 'or' operation
1258 @param ScriptHeader The pointer of header of node in boot script table
1259 @param AndMask The Mask value for 'and' operation
1260 @param OrMask The Mask value for 'or' operation
1261 @param Script Pointer to the entry.
1262
1263 **/
1264 VOID
1265 CheckAndOrMask (
1266 IN EFI_BOOT_SCRIPT_COMMON_HEADER *ScriptHeader,
1267 OUT UINT64 *AndMask,
1268 OUT UINT64 *OrMask,
1269 IN UINT8 *Script
1270 )
1271 {
1272 UINT8 *DataPtr;
1273 UINTN Size;
1274
1275 switch (ScriptHeader->OpCode) {
1276 case EFI_BOOT_SCRIPT_IO_READ_WRITE_OPCODE:
1277 Size = sizeof (EFI_BOOT_SCRIPT_IO_READ_WRITE);
1278 break;
1279
1280 case EFI_BOOT_SCRIPT_MEM_READ_WRITE_OPCODE:
1281 Size = sizeof (EFI_BOOT_SCRIPT_MEM_READ_WRITE);
1282 break;
1283
1284 case EFI_BOOT_SCRIPT_PCI_CONFIG_READ_WRITE_OPCODE:
1285 Size = sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG_READ_WRITE);
1286 break;
1287 case EFI_BOOT_SCRIPT_MEM_POLL_OPCODE:
1288 Size = sizeof (EFI_BOOT_SCRIPT_MEM_POLL);
1289 break;
1290
1291 case EFI_BOOT_SCRIPT_IO_POLL_OPCODE:
1292 Size = sizeof (EFI_BOOT_SCRIPT_IO_POLL);
1293 break;
1294
1295 case EFI_BOOT_SCRIPT_PCI_CONFIG2_READ_WRITE_OPCODE:
1296 Size = sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG2_READ_WRITE);
1297 break;
1298
1299 case EFI_BOOT_SCRIPT_PCI_CONFIG2_POLL_OPCODE:
1300 Size = sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG2_POLL);
1301 break;
1302
1303 case EFI_BOOT_SCRIPT_PCI_CONFIG_POLL_OPCODE:
1304 Size = sizeof (EFI_BOOT_SCRIPT_PCI_CONFIG_POLL);
1305 break;
1306
1307 default:
1308 return;
1309 }
1310
1311 DataPtr = Script + Size;
1312
1313 switch (ScriptHeader->Width) {
1314 case S3BootScriptWidthUint8:
1315 *AndMask = (UINT64) (*(UINT8*) (DataPtr + 1));
1316 *OrMask = (UINT64) (*DataPtr);
1317 break;
1318
1319 case S3BootScriptWidthUint16:
1320 *AndMask = (UINT64) (*(UINT16 *) (DataPtr + 2));
1321 *OrMask = (UINT64) (*(UINT16 *) DataPtr);
1322 break;
1323
1324 case S3BootScriptWidthUint32:
1325 *AndMask = (UINT64) (*(UINT32 *) (DataPtr + 4));
1326 *OrMask = (UINT64) (*(UINT32 *) DataPtr);
1327 break;
1328
1329 case S3BootScriptWidthUint64:
1330 *AndMask = (UINT64) (*(UINT64 *) (DataPtr + 8));
1331 *OrMask = (UINT64) (*(UINT64 *) DataPtr);
1332 break;
1333
1334 default:
1335 break;
1336 }
1337
1338 return;
1339 }
1340 /**
1341 Interprete the boot script node with EFI_BOOT_SCRIPT_IO_POLL OP code.
1342
1343 @param Script The pointer of typed node in boot script table
1344 @param AndMask Mask value for 'and' operation
1345 @param OrMask Mask value for 'or' operation
1346
1347 @retval EFI_DEVICE_ERROR Data polled from memory does not equal to
1348 the epecting data within the Loop Times.
1349 @retval EFI_SUCCESS The operation was executed successfully
1350 **/
1351 EFI_STATUS
1352 BootScriptExecuteIoPoll (
1353 IN UINT8 *Script,
1354 IN UINT64 AndMask,
1355 IN UINT64 OrMask
1356 )
1357 {
1358 EFI_STATUS Status;
1359 UINT64 Data;
1360 UINT64 LoopTimes;
1361 EFI_BOOT_SCRIPT_IO_POLL IoPoll;
1362
1363 CopyMem ((VOID*)&IoPoll, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_IO_POLL));
1364
1365 DEBUG ((EFI_D_INFO, "BootScriptExecuteIoPoll - 0x%08x, 0x%016lx, 0x%016lx\n", (UINTN)IoPoll.Address, AndMask, OrMask));
1366
1367 Data = 0;
1368 Status = ScriptIoRead (
1369 (S3_BOOT_SCRIPT_LIB_WIDTH) IoPoll.Width,
1370 IoPoll.Address,
1371 1,
1372 &Data
1373 );
1374 if ((!EFI_ERROR (Status)) && (Data & AndMask) == OrMask) {
1375 return EFI_SUCCESS;
1376 }
1377 for (LoopTimes = 0; LoopTimes < IoPoll.Delay; LoopTimes++) {
1378 NanoSecondDelay (100);
1379 Data = 0;
1380 Status = ScriptIoRead (
1381 (S3_BOOT_SCRIPT_LIB_WIDTH) IoPoll.Width,
1382 IoPoll.Address,
1383 1,
1384 &Data
1385 );
1386 if ((!EFI_ERROR (Status)) &&(Data & AndMask) == OrMask) {
1387 return EFI_SUCCESS;
1388 }
1389 }
1390
1391 if (LoopTimes < IoPoll.Delay) {
1392 return EFI_SUCCESS;
1393 } else {
1394 return EFI_DEVICE_ERROR;
1395 }
1396 }
1397 /**
1398 Interprete the boot script node with EFI_BOOT_SCRIPT_PCI_CONFIG2_WRITE OP code.
1399
1400 @param Script The pointer of S3 boot script
1401
1402 @retval EFI_SUCCESS The operation was executed successfully
1403
1404 **/
1405 EFI_STATUS
1406 BootScriptExecutePciCfg2Write (
1407 IN UINT8 *Script
1408 )
1409 {
1410 VOID *Buffer;
1411 S3_BOOT_SCRIPT_LIB_WIDTH Width;
1412 UINT16 Segment;
1413 UINT64 Address;
1414 UINTN Count;
1415 EFI_BOOT_SCRIPT_PCI_CONFIG2_WRITE PciCfg2Write;
1416
1417 CopyMem ((VOID*)&PciCfg2Write, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_PCI_CONFIG2_WRITE));
1418
1419 Width = (S3_BOOT_SCRIPT_LIB_WIDTH)PciCfg2Write.Width;
1420 Segment = PciCfg2Write.Segment;
1421 Address = PciCfg2Write.Address;
1422 Count = PciCfg2Write.Count;
1423 Buffer = Script + sizeof(EFI_BOOT_SCRIPT_PCI_CONFIG2_WRITE);
1424
1425 DEBUG ((EFI_D_INFO, "BootScriptExecutePciCfg2Write - 0x%04x, 0x%08x, 0x%08x, 0x%08x\n", Segment, PCI_ADDRESS_ENCODE (Address), Count, (UINTN)Width));
1426 return ScriptPciCfg2Write (Width, Segment, Address, Count, Buffer);
1427 }
1428
1429
1430 /**
1431 Interprete the boot script node with EFI_BOOT_SCRIPT_PCI_CONFIG2_READ_WRITE OP code.
1432
1433 @param Script The pointer of S3 boot script
1434 @param AndMask Mask value for 'and' operation
1435 @param OrMask Mask value for 'or' operation
1436
1437 @retval EFI_SUCCESS The operation was executed successfully
1438
1439 **/
1440 EFI_STATUS
1441 BootScriptExecutePciCfg2ReadWrite (
1442 IN UINT8 *Script,
1443 IN UINT64 AndMask,
1444 IN UINT64 OrMask
1445 )
1446 {
1447 UINT64 Data;
1448 EFI_STATUS Status;
1449 EFI_BOOT_SCRIPT_PCI_CONFIG2_READ_WRITE PciCfg2ReadWrite;
1450
1451 Data = 0;
1452
1453 CopyMem ((VOID*)&PciCfg2ReadWrite, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_PCI_CONFIG2_READ_WRITE));
1454
1455 DEBUG ((EFI_D_INFO, "BootScriptExecutePciCfg2ReadWrite - 0x%04x, 0x%08x, 0x%016lx, 0x%016lx\n", PciCfg2ReadWrite.Segment, PCI_ADDRESS_ENCODE (PciCfg2ReadWrite.Address), AndMask, OrMask));
1456
1457 Status = ScriptPciCfg2Read (
1458 (S3_BOOT_SCRIPT_LIB_WIDTH) PciCfg2ReadWrite.Width,
1459 PciCfg2ReadWrite.Segment,
1460 PciCfg2ReadWrite.Address,
1461 1,
1462 &Data
1463 );
1464 if (EFI_ERROR (Status)) {
1465 return Status;
1466 }
1467
1468 Data = (Data & AndMask) | OrMask;
1469 Status = ScriptPciCfg2Write (
1470 (S3_BOOT_SCRIPT_LIB_WIDTH) PciCfg2ReadWrite.Width,
1471 PciCfg2ReadWrite.Segment,
1472 PciCfg2ReadWrite.Address,
1473 1,
1474 &Data
1475 );
1476 return Status;
1477 }
1478 /**
1479 Interprete the boot script node with EFI_BOOT_SCRIPT_PCI_CONFIG_POLL OP code.
1480
1481 @param Script The pointer of S3 boot script
1482 @param AndMask Mask value for 'and' operation
1483 @param OrMask Mask value for 'or' operation
1484
1485 @retval EFI_SUCCESS The operation was executed successfully
1486 @retval EFI_DEVICE_ERROR Data polled from Pci configuration space does not equal to
1487 epecting data within the Loop Times.
1488 **/
1489 EFI_STATUS
1490 BootScriptPciCfgPoll (
1491 IN UINT8 *Script,
1492 IN UINT64 AndMask,
1493 IN UINT64 OrMask
1494 )
1495 {
1496 UINT64 Data;
1497 UINT64 LoopTimes;
1498 EFI_STATUS Status;
1499 EFI_BOOT_SCRIPT_PCI_CONFIG_POLL PciCfgPoll;
1500 CopyMem ((VOID*)&PciCfgPoll, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_PCI_CONFIG_POLL));
1501
1502 DEBUG ((EFI_D_INFO, "BootScriptPciCfgPoll - 0x%08x, 0x%016lx, 0x%016lx\n", PCI_ADDRESS_ENCODE (PciCfgPoll.Address), AndMask, OrMask));
1503
1504 Data = 0;
1505 Status = ScriptPciCfgRead (
1506 (S3_BOOT_SCRIPT_LIB_WIDTH) PciCfgPoll.Width,
1507 PciCfgPoll.Address,
1508 1,
1509 &Data
1510 );
1511 if ((!EFI_ERROR (Status)) &&(Data & AndMask) == OrMask) {
1512 return EFI_SUCCESS;
1513 }
1514
1515 for (LoopTimes = 0; LoopTimes < PciCfgPoll.Delay; LoopTimes++) {
1516 NanoSecondDelay (100);
1517 Data = 0;
1518 Status = ScriptPciCfgRead (
1519 (S3_BOOT_SCRIPT_LIB_WIDTH) PciCfgPoll.Width,
1520 PciCfgPoll.Address,
1521 1,
1522 &Data
1523 );
1524 if ((!EFI_ERROR (Status)) &&
1525 (Data & AndMask) == OrMask) {
1526 return EFI_SUCCESS;
1527 }
1528 }
1529
1530 if (LoopTimes < PciCfgPoll.Delay) {
1531 return EFI_SUCCESS;
1532 } else {
1533 return EFI_DEVICE_ERROR;
1534 }
1535 }
1536
1537 /**
1538 Interprete the boot script node with EFI_BOOT_SCRIPT_PCI_CONFIG2_POLL OP code.
1539
1540 @param Script The pointer of S3 Boot Script
1541 @param AndMask Mask value for 'and' operation
1542 @param OrMask Mask value for 'or' operation
1543
1544 @retval EFI_SUCCESS The operation was executed successfully
1545 @retval EFI_DEVICE_ERROR Data polled from Pci configuration space does not equal to
1546 epecting data within the Loop Times.
1547
1548 **/
1549 EFI_STATUS
1550 BootScriptPciCfg2Poll (
1551 IN UINT8 *Script,
1552 IN UINT64 AndMask,
1553 IN UINT64 OrMask
1554 )
1555 {
1556 EFI_STATUS Status;
1557 UINT64 Data;
1558 UINT64 LoopTimes;
1559 EFI_BOOT_SCRIPT_PCI_CONFIG2_POLL PciCfg2Poll;
1560
1561 Data = 0;
1562 CopyMem ((VOID*)&PciCfg2Poll, (VOID*)Script, sizeof(EFI_BOOT_SCRIPT_PCI_CONFIG2_POLL));
1563
1564 DEBUG ((EFI_D_INFO, "BootScriptPciCfg2Poll - 0x%04x, 0x%08x, 0x%016lx, 0x%016lx\n", PciCfg2Poll.Segment, PCI_ADDRESS_ENCODE (PciCfg2Poll.Address), AndMask, OrMask));
1565
1566 Status = ScriptPciCfg2Read (
1567 (S3_BOOT_SCRIPT_LIB_WIDTH) PciCfg2Poll.Width,
1568 PciCfg2Poll.Segment,
1569 PciCfg2Poll.Address,
1570 1,
1571 &Data
1572 );
1573 if ((!EFI_ERROR (Status)) && (Data & AndMask) == OrMask) {
1574 return EFI_SUCCESS;
1575 }
1576
1577 for (LoopTimes = 0; LoopTimes < PciCfg2Poll.Delay; LoopTimes++) {
1578 NanoSecondDelay (100);
1579
1580 Data = 0;
1581 Status = ScriptPciCfg2Read (
1582 (S3_BOOT_SCRIPT_LIB_WIDTH) PciCfg2Poll.Width,
1583 PciCfg2Poll.Segment,
1584 PciCfg2Poll.Address,
1585 1,
1586 &Data
1587 );
1588 if ((!EFI_ERROR (Status)) && (Data & AndMask) == OrMask) {
1589 return EFI_SUCCESS;
1590 }
1591 }
1592
1593 if (LoopTimes < PciCfg2Poll.Delay) {
1594 return EFI_SUCCESS;
1595 } else {
1596 return EFI_DEVICE_ERROR;
1597 }
1598
1599 }
1600
1601 /**
1602 Executes the S3 boot script table.
1603
1604 @retval RETURN_SUCCESS The boot script table was executed successfully.
1605 @retval RETURN_UNSUPPORTED Invalid script table or opcode.
1606
1607 @note A known Limitations in the implementation: When interpreting the opcode EFI_BOOT_SCRIPT_PCI_CONFIG2_WRITE_OPCODE
1608 EFI_BOOT_SCRIPT_PCI_CONFIG2_READ_WRITE_OPCODE and EFI_BOOT_SCRIPT_PCI_CONFIG2_POLL_OPCODE, the 'Segment' parameter is assumed as
1609 Zero, or else, assert.
1610 **/
1611 RETURN_STATUS
1612 EFIAPI
1613 S3BootScriptExecute (
1614 VOID
1615 )
1616 {
1617 EFI_STATUS Status;
1618 UINT8* Script;
1619 UINTN StartAddress;
1620 UINT32 TableLength;
1621 UINT64 AndMask;
1622 UINT64 OrMask;
1623 EFI_BOOT_SCRIPT_COMMON_HEADER ScriptHeader;
1624 EFI_BOOT_SCRIPT_TABLE_HEADER TableHeader;
1625 Script = mS3BootScriptTablePtr->TableBase;
1626 if (Script != 0) {
1627 CopyMem ((VOID*)&TableHeader, Script, sizeof(EFI_BOOT_SCRIPT_TABLE_HEADER));
1628 } else {
1629 return EFI_INVALID_PARAMETER;
1630 }
1631
1632 DEBUG ((EFI_D_INFO, "S3BootScriptExecute:\n"));
1633 if (TableHeader.OpCode != S3_BOOT_SCRIPT_LIB_TABLE_OPCODE) {
1634 return EFI_UNSUPPORTED;
1635 }
1636
1637 DEBUG ((EFI_D_INFO, "TableHeader - 0x%08x\n", Script));
1638
1639 StartAddress = (UINTN) Script;
1640 TableLength = TableHeader.TableLength;
1641 Script = Script + TableHeader.Length;
1642 Status = EFI_SUCCESS;
1643 AndMask = 0;
1644 OrMask = 0;
1645
1646 DEBUG ((EFI_D_INFO, "TableHeader.Version - 0x%04x\n", (UINTN)TableHeader.Version));
1647 DEBUG ((EFI_D_INFO, "TableHeader.TableLength - 0x%08x\n", (UINTN)TableLength));
1648
1649 while ((UINTN) Script < (UINTN) (StartAddress + TableLength)) {
1650 DEBUG ((EFI_D_INFO, "ExecuteBootScript - %08x\n", (UINTN)Script));
1651
1652 CopyMem ((VOID*)&ScriptHeader, Script, sizeof(EFI_BOOT_SCRIPT_COMMON_HEADER));
1653 switch (ScriptHeader.OpCode) {
1654
1655 case EFI_BOOT_SCRIPT_MEM_WRITE_OPCODE:
1656 DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_MEM_WRITE_OPCODE\n"));
1657 Status = BootScriptExecuteMemoryWrite (Script);
1658 break;
1659
1660 case EFI_BOOT_SCRIPT_MEM_READ_WRITE_OPCODE:
1661 DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_MEM_READ_WRITE_OPCODE\n"));
1662 CheckAndOrMask (&ScriptHeader, &AndMask, &OrMask, Script);
1663 Status = BootScriptExecuteMemoryReadWrite (
1664 Script,
1665 AndMask,
1666 OrMask
1667 );
1668 break;
1669
1670 case EFI_BOOT_SCRIPT_IO_WRITE_OPCODE:
1671 DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_IO_WRITE_OPCODE\n"));
1672 Status = BootScriptExecuteIoWrite (Script);
1673 break;
1674
1675 case EFI_BOOT_SCRIPT_PCI_CONFIG_WRITE_OPCODE:
1676 DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_PCI_CONFIG_WRITE_OPCODE\n"));
1677 Status = BootScriptExecutePciCfgWrite (Script);
1678 break;
1679
1680 case EFI_BOOT_SCRIPT_PCI_CONFIG_READ_WRITE_OPCODE:
1681 DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_PCI_CONFIG_READ_WRITE_OPCODE\n"));
1682 CheckAndOrMask (&ScriptHeader, &AndMask, &OrMask, Script);
1683 Status = BootScriptExecutePciCfgReadWrite (
1684 Script,
1685 AndMask,
1686 OrMask
1687 );
1688 break;
1689 case EFI_BOOT_SCRIPT_PCI_CONFIG2_WRITE_OPCODE:
1690 DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_PCI_CONFIG2_WRITE_OPCODE\n"));
1691 Status = BootScriptExecutePciCfg2Write (Script);
1692 break;
1693
1694 case EFI_BOOT_SCRIPT_PCI_CONFIG2_READ_WRITE_OPCODE:
1695 DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_PCI_CONFIG2_READ_WRITE_OPCODE\n"));
1696 CheckAndOrMask (&ScriptHeader, &AndMask, &OrMask, Script);
1697 Status = BootScriptExecutePciCfg2ReadWrite (
1698 Script,
1699 AndMask,
1700 OrMask
1701 );
1702 break;
1703 case EFI_BOOT_SCRIPT_DISPATCH_OPCODE:
1704 DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_DISPATCH_OPCODE\n"));
1705 Status = BootScriptExecuteDispatch (Script);
1706 break;
1707
1708 case EFI_BOOT_SCRIPT_DISPATCH_2_OPCODE:
1709 DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_DISPATCH_2_OPCODE\n"));
1710 Status = BootScriptExecuteDispatch2 (Script);
1711 break;
1712
1713 case EFI_BOOT_SCRIPT_INFORMATION_OPCODE:
1714 DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_INFORMATION_OPCODE\n"));
1715 BootScriptExecuteInformation (Script);
1716 break;
1717
1718 case S3_BOOT_SCRIPT_LIB_TERMINATE_OPCODE:
1719 DEBUG ((EFI_D_INFO, "S3_BOOT_SCRIPT_LIB_TERMINATE_OPCODE\n"));
1720 DEBUG ((EFI_D_INFO, "S3BootScriptDone - %r\n", EFI_SUCCESS));
1721 return EFI_SUCCESS;
1722
1723 case EFI_BOOT_SCRIPT_IO_READ_WRITE_OPCODE:
1724 DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_IO_READ_WRITE_OPCODE\n"));
1725 CheckAndOrMask (&ScriptHeader, &AndMask, &OrMask, Script);
1726 Status = BootScriptExecuteIoReadWrite (
1727 Script,
1728 AndMask,
1729 OrMask
1730 );
1731 break;
1732
1733 case EFI_BOOT_SCRIPT_SMBUS_EXECUTE_OPCODE:
1734 DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_SMBUS_EXECUTE_OPCODE\n"));
1735 Status = BootScriptExecuteSmbusExecute (Script);
1736 break;
1737
1738 case EFI_BOOT_SCRIPT_STALL_OPCODE:
1739 DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_STALL_OPCODE\n"));
1740 Status = BootScriptExecuteStall (Script);
1741 break;
1742
1743 case EFI_BOOT_SCRIPT_MEM_POLL_OPCODE:
1744 DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_MEM_POLL_OPCODE\n"));
1745 CheckAndOrMask (&ScriptHeader, &AndMask, &OrMask, Script);
1746 Status = BootScriptExecuteMemPoll (Script, AndMask, OrMask);
1747
1748 break;
1749
1750 case EFI_BOOT_SCRIPT_IO_POLL_OPCODE:
1751 DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_IO_POLL_OPCODE\n"));
1752 CheckAndOrMask (&ScriptHeader, &AndMask, &OrMask, Script);
1753 Status = BootScriptExecuteIoPoll (Script, AndMask, OrMask);
1754 break;
1755
1756 case EFI_BOOT_SCRIPT_PCI_CONFIG_POLL_OPCODE:
1757 DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_PCI_CONFIG_POLL_OPCODE\n"));
1758 CheckAndOrMask (&ScriptHeader, &AndMask, &OrMask, Script);
1759 Status = BootScriptPciCfgPoll (Script, AndMask, OrMask);
1760 break;
1761
1762 case EFI_BOOT_SCRIPT_PCI_CONFIG2_POLL_OPCODE:
1763 DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_PCI_CONFIG2_POLL_OPCODE\n"));
1764 CheckAndOrMask (&ScriptHeader, &AndMask, &OrMask, Script);
1765 Status = BootScriptPciCfg2Poll (Script, AndMask, OrMask);
1766 break;
1767
1768 case S3_BOOT_SCRIPT_LIB_LABEL_OPCODE:
1769 //
1770 // For label
1771 //
1772 DEBUG ((EFI_D_INFO, "S3_BOOT_SCRIPT_LIB_LABEL_OPCODE\n"));
1773 BootScriptExecuteLabel (Script);
1774 break;
1775 default:
1776 DEBUG ((EFI_D_INFO, "S3BootScriptDone - %r\n", EFI_UNSUPPORTED));
1777 return EFI_UNSUPPORTED;
1778 }
1779
1780 if (EFI_ERROR (Status)) {
1781 DEBUG ((EFI_D_INFO, "S3BootScriptDone - %r\n", Status));
1782 return Status;
1783 }
1784
1785 Script = Script + ScriptHeader.Length;
1786 }
1787
1788 DEBUG ((EFI_D_INFO, "S3BootScriptDone - %r\n", Status));
1789
1790 return Status;
1791 }
1792
EFI Development Kit II mirror for PVE