BootScriptExecute.c@ 61103

Last change on this file since 61103 was 58466, checked in by vboxsync, 9 years ago
EFI/Firmware: Merged in the svn:eol-style, svn:mime-type and trailing whitespace cleanup that was done after the initial UDK2014.SP1 import: svn merge ^{/vendor/edk2/UDK2014.SP1}/vendor/edk2/current .
Property svn:eol-style set to `native`
File size: 61.0 KB

Line
1	/** @file
2	Interpret and execute the S3 data in S3 boot script.
3
4	Copyright (c) 2006 - 2014, 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.TableLength - 0x%08x\n", (UINTN)TableLength));
1647
1648	while ((UINTN) Script < (UINTN) (StartAddress + TableLength)) {
1649	DEBUG ((EFI_D_INFO, "ExecuteBootScript - %08x\n", (UINTN)Script));
1650
1651	CopyMem ((VOID*)&ScriptHeader, Script, sizeof(EFI_BOOT_SCRIPT_COMMON_HEADER));
1652	switch (ScriptHeader.OpCode) {
1653
1654	case EFI_BOOT_SCRIPT_MEM_WRITE_OPCODE:
1655	DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_MEM_WRITE_OPCODE\n"));
1656	Status = BootScriptExecuteMemoryWrite (Script);
1657	break;
1658
1659	case EFI_BOOT_SCRIPT_MEM_READ_WRITE_OPCODE:
1660	DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_MEM_READ_WRITE_OPCODE\n"));
1661	CheckAndOrMask (&ScriptHeader, &AndMask, &OrMask, Script);
1662	Status = BootScriptExecuteMemoryReadWrite (
1663	Script,
1664	AndMask,
1665	OrMask
1666	);
1667	break;
1668
1669	case EFI_BOOT_SCRIPT_IO_WRITE_OPCODE:
1670	DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_IO_WRITE_OPCODE\n"));
1671	Status = BootScriptExecuteIoWrite (Script);
1672	break;
1673
1674	case EFI_BOOT_SCRIPT_PCI_CONFIG_WRITE_OPCODE:
1675	DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_PCI_CONFIG_WRITE_OPCODE\n"));
1676	Status = BootScriptExecutePciCfgWrite (Script);
1677	break;
1678
1679	case EFI_BOOT_SCRIPT_PCI_CONFIG_READ_WRITE_OPCODE:
1680	DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_PCI_CONFIG_READ_WRITE_OPCODE\n"));
1681	CheckAndOrMask (&ScriptHeader, &AndMask, &OrMask, Script);
1682	Status = BootScriptExecutePciCfgReadWrite (
1683	Script,
1684	AndMask,
1685	OrMask
1686	);
1687	break;
1688	case EFI_BOOT_SCRIPT_PCI_CONFIG2_WRITE_OPCODE:
1689	DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_PCI_CONFIG2_WRITE_OPCODE\n"));
1690	Status = BootScriptExecutePciCfg2Write (Script);
1691	break;
1692
1693	case EFI_BOOT_SCRIPT_PCI_CONFIG2_READ_WRITE_OPCODE:
1694	DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_PCI_CONFIG2_READ_WRITE_OPCODE\n"));
1695	CheckAndOrMask (&ScriptHeader, &AndMask, &OrMask, Script);
1696	Status = BootScriptExecutePciCfg2ReadWrite (
1697	Script,
1698	AndMask,
1699	OrMask
1700	);
1701	break;
1702	case EFI_BOOT_SCRIPT_DISPATCH_OPCODE:
1703	DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_DISPATCH_OPCODE\n"));
1704	Status = BootScriptExecuteDispatch (Script);
1705	break;
1706
1707	case EFI_BOOT_SCRIPT_DISPATCH_2_OPCODE:
1708	DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_DISPATCH_2_OPCODE\n"));
1709	Status = BootScriptExecuteDispatch2 (Script);
1710	break;
1711
1712	case EFI_BOOT_SCRIPT_INFORMATION_OPCODE:
1713	DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_INFORMATION_OPCODE\n"));
1714	BootScriptExecuteInformation (Script);
1715	break;
1716
1717	case S3_BOOT_SCRIPT_LIB_TERMINATE_OPCODE:
1718	DEBUG ((EFI_D_INFO, "S3_BOOT_SCRIPT_LIB_TERMINATE_OPCODE\n"));
1719	DEBUG ((EFI_D_INFO, "S3BootScriptDone - %r\n", EFI_SUCCESS));
1720	return EFI_SUCCESS;
1721
1722	case EFI_BOOT_SCRIPT_IO_READ_WRITE_OPCODE:
1723	DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_IO_READ_WRITE_OPCODE\n"));
1724	CheckAndOrMask (&ScriptHeader, &AndMask, &OrMask, Script);
1725	Status = BootScriptExecuteIoReadWrite (
1726	Script,
1727	AndMask,
1728	OrMask
1729	);
1730	break;
1731
1732	case EFI_BOOT_SCRIPT_SMBUS_EXECUTE_OPCODE:
1733	DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_SMBUS_EXECUTE_OPCODE\n"));
1734	Status = BootScriptExecuteSmbusExecute (Script);
1735	break;
1736
1737	case EFI_BOOT_SCRIPT_STALL_OPCODE:
1738	DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_STALL_OPCODE\n"));
1739	Status = BootScriptExecuteStall (Script);
1740	break;
1741
1742	case EFI_BOOT_SCRIPT_MEM_POLL_OPCODE:
1743	DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_MEM_POLL_OPCODE\n"));
1744	CheckAndOrMask (&ScriptHeader, &AndMask, &OrMask, Script);
1745	Status = BootScriptExecuteMemPoll (Script, AndMask, OrMask);
1746
1747	break;
1748
1749	case EFI_BOOT_SCRIPT_IO_POLL_OPCODE:
1750	DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_IO_POLL_OPCODE\n"));
1751	CheckAndOrMask (&ScriptHeader, &AndMask, &OrMask, Script);
1752	Status = BootScriptExecuteIoPoll (Script, AndMask, OrMask);
1753	break;
1754
1755	case EFI_BOOT_SCRIPT_PCI_CONFIG_POLL_OPCODE:
1756	DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_PCI_CONFIG_POLL_OPCODE\n"));
1757	CheckAndOrMask (&ScriptHeader, &AndMask, &OrMask, Script);
1758	Status = BootScriptPciCfgPoll (Script, AndMask, OrMask);
1759	break;
1760
1761	case EFI_BOOT_SCRIPT_PCI_CONFIG2_POLL_OPCODE:
1762	DEBUG ((EFI_D_INFO, "EFI_BOOT_SCRIPT_PCI_CONFIG2_POLL_OPCODE\n"));
1763	CheckAndOrMask (&ScriptHeader, &AndMask, &OrMask, Script);
1764	Status = BootScriptPciCfg2Poll (Script, AndMask, OrMask);
1765	break;
1766
1767	case S3_BOOT_SCRIPT_LIB_LABEL_OPCODE:
1768	//
1769	// For label
1770	//
1771	DEBUG ((EFI_D_INFO, "S3_BOOT_SCRIPT_LIB_LABEL_OPCODE\n"));
1772	BootScriptExecuteLabel (Script);
1773	break;
1774	default:
1775	DEBUG ((EFI_D_INFO, "S3BootScriptDone - %r\n", EFI_UNSUPPORTED));
1776	return EFI_UNSUPPORTED;
1777	}
1778
1779	if (EFI_ERROR (Status)) {
1780	DEBUG ((EFI_D_INFO, "S3BootScriptDone - %r\n", Status));
1781	return Status;
1782	}
1783
1784	Script = Script + ScriptHeader.Length;
1785	}
1786
1787	DEBUG ((EFI_D_INFO, "S3BootScriptDone - %r\n", Status));
1788
1789	return Status;
1790	}
1791

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/PiDxeS3BootScriptLib/BootScriptExecute.c@ 61103

Download in other formats: