1 /** @file
2 This file contains specific GPIO information
3
4 Copyright (c) 2019 Intel Corporation. All rights reserved. <BR>
5
6 SPDX-License-Identifier: BSD-2-Clause-Patent
7 **/
8
9 #include <Base.h>
10 #include <Uefi/UefiBaseType.h>
11 #include <Library/IoLib.h>
12 #include <Library/DebugLib.h>
13 #include <Library/BaseMemoryLib.h>
14 #include <SaAccess.h>
15 #include <Library/GpioLib.h>
16 #include <Library/GpioNativeLib.h>
17 #include <Library/PchInfoLib.h>
18 #include <Library/SataLib.h>
19 #include <Private/Library/GpioPrivateLib.h>
20 #include <GpioPinsCnlLp.h>
21 #include <GpioPinsCnlH.h>
22 #include <Register/PchRegsGpio.h>
23 #include <Register/PchRegsGpioCnl.h>
24 #include <Register/PchRegsSerialIo.h>
25 #include <Register/PchRegsIsh.h>
26 #include <Register/PchRegsScs.h>
27 #include <Register/PchRegsLpcCnl.h>
28
29 #include "GpioNativePrivateLibInternal.h"
30
31 //
32 // I2C controller pins
33 // I2C[controller number][pin: SDA/SCL]
34 //
35 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpI2cGpio [][PCH_SERIAL_IO_PINS_PER_I2C_CONTROLLER]=
36 {
37 {{GPIO_CNL_LP_GPP_C16, GpioPadModeNative1}, {GPIO_CNL_LP_GPP_C17, GpioPadModeNative1}},
38 {{GPIO_CNL_LP_GPP_C18, GpioPadModeNative1}, {GPIO_CNL_LP_GPP_C19, GpioPadModeNative1}},
39 {{GPIO_CNL_LP_GPP_H4, GpioPadModeNative1}, {GPIO_CNL_LP_GPP_H5 , GpioPadModeNative1}},
40 {{GPIO_CNL_LP_GPP_H6, GpioPadModeNative1}, {GPIO_CNL_LP_GPP_H7 , GpioPadModeNative1}},
41 {{GPIO_CNL_LP_GPP_H8, GpioPadModeNative1}, {GPIO_CNL_LP_GPP_H9 , GpioPadModeNative1}},
42 {{GPIO_CNL_LP_GPP_H10, GpioPadModeNative1}, {GPIO_CNL_LP_GPP_H11, GpioPadModeNative1}}
43 };
44
45 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHI2cGpio [][PCH_SERIAL_IO_PINS_PER_I2C_CONTROLLER]=
46 {
47 {{GPIO_CNL_H_GPP_C16, GpioPadModeNative1}, {GPIO_CNL_H_GPP_C17, GpioPadModeNative1}}, // I2C0
48 {{GPIO_CNL_H_GPP_C18, GpioPadModeNative1}, {GPIO_CNL_H_GPP_C19, GpioPadModeNative1}}, // I2C1
49 {{GPIO_CNL_H_GPP_D13, GpioPadModeNative3}, {GPIO_CNL_H_GPP_D14, GpioPadModeNative3}}, // I2C2
50 {{GPIO_CNL_H_GPP_D4, GpioPadModeNative2}, {GPIO_CNL_H_GPP_D23, GpioPadModeNative2}} // I2C3
51 };
52
53
54 /**
55 This function provides SerialIo I2C controller pins
56
57 @param[in] SerialIoI2cControllerNumber I2C controller
58
59 @param[out] NativePinsTable Table with pins
60 @param[out] NoOfNativePins Number of pins
61 **/
62 VOID
GpioGetSerialIoI2cPins(IN UINT32 SerialIoI2cControllerNumber,OUT GPIO_PAD_NATIVE_FUNCTION ** NativePinsTable)63 GpioGetSerialIoI2cPins (
64 IN UINT32 SerialIoI2cControllerNumber,
65 OUT GPIO_PAD_NATIVE_FUNCTION **NativePinsTable
66 )
67 {
68 if (IsPchLp ()) {
69 if (SerialIoI2cControllerNumber < ARRAY_SIZE (mPchLpI2cGpio)) {
70 *NativePinsTable = mPchLpI2cGpio[SerialIoI2cControllerNumber];
71 return;
72 }
73 } else {
74 if (SerialIoI2cControllerNumber < ARRAY_SIZE (mPchHI2cGpio)) {
75 *NativePinsTable = mPchHI2cGpio[SerialIoI2cControllerNumber];
76 return;
77 }
78 }
79 *NativePinsTable = NULL;
80 ASSERT (FALSE);
81 }
82 //
83 // UART controller pins
84 // UART[controller number][pin: RXD/TXD/RTSB/CTSB]
85 //
86 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpUartGpio [][PCH_SERIAL_IO_PINS_PER_UART_CONTROLLER]=
87 {
88 { // UART0
89 {GPIO_CNL_LP_GPP_C8, GpioPadModeNative1},
90 {GPIO_CNL_LP_GPP_C9, GpioPadModeNative1},
91 {GPIO_CNL_LP_GPP_C10, GpioPadModeNative1},
92 {GPIO_CNL_LP_GPP_C11, GpioPadModeNative1}
93 },
94 { // UART1
95 {GPIO_CNL_LP_GPP_C12, GpioPadModeNative1},
96 {GPIO_CNL_LP_GPP_C13, GpioPadModeNative1},
97 {GPIO_CNL_LP_GPP_C14, GpioPadModeNative1},
98 {GPIO_CNL_LP_GPP_C15, GpioPadModeNative1}
99 },
100 { // UART2
101 {GPIO_CNL_LP_GPP_C20, GpioPadModeNative1},
102 {GPIO_CNL_LP_GPP_C21, GpioPadModeNative1},
103 {GPIO_CNL_LP_GPP_C22, GpioPadModeNative1},
104 {GPIO_CNL_LP_GPP_C23, GpioPadModeNative1},
105 },
106 { // UART0 (2nd pin set)
107 {GPIO_CNL_LP_GPP_F5, GpioPadModeNative2},
108 {GPIO_CNL_LP_GPP_F6, GpioPadModeNative2},
109 {GPIO_CNL_LP_GPP_F4, GpioPadModeNative2},
110 {GPIO_CNL_LP_GPP_F7, GpioPadModeNative2}
111 }
112 };
113
114 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHUartGpio [][PCH_SERIAL_IO_PINS_PER_UART_CONTROLLER]=
115 {
116 { // UART0
117 {GPIO_CNL_H_GPP_C8, GpioPadModeNative1},
118 {GPIO_CNL_H_GPP_C9, GpioPadModeNative1},
119 {GPIO_CNL_H_GPP_C10, GpioPadModeNative1},
120 {GPIO_CNL_H_GPP_C11, GpioPadModeNative1}
121 },
122 { // UART1
123 {GPIO_CNL_H_GPP_C12, GpioPadModeNative1},
124 {GPIO_CNL_H_GPP_C13, GpioPadModeNative1},
125 {GPIO_CNL_H_GPP_C14, GpioPadModeNative1},
126 {GPIO_CNL_H_GPP_C15, GpioPadModeNative1}
127 },
128 { // UART2
129 {GPIO_CNL_H_GPP_C20, GpioPadModeNative1},
130 {GPIO_CNL_H_GPP_C21, GpioPadModeNative1},
131 {GPIO_CNL_H_GPP_C22, GpioPadModeNative1},
132 {GPIO_CNL_H_GPP_C23, GpioPadModeNative1}
133 },
134 { // UART0 (2nd pin set)
135 {GPIO_CNL_H_GPP_J5, GpioPadModeNative2},
136 {GPIO_CNL_H_GPP_J6, GpioPadModeNative2},
137 {GPIO_CNL_H_GPP_J4, GpioPadModeNative2},
138 {GPIO_CNL_H_GPP_J7, GpioPadModeNative2}
139 }
140 };
141
142 /**
143 This function provides SerialIo UART controller pins
144
145 @param[in] SerialIoUartControllerNumber UART controller
146 @param[in] HardwareFlowControl Hardware Flow control
147 @param[in] PinMuxing UART controller pin muxing
148 @param[out] NativePinsTable Table with pins
149 @param[out] NoOfNativePins Number of pins
150 **/
151 VOID
GpioGetSerialIoUartPins(IN UINT32 SerialIoUartControllerNumber,IN BOOLEAN HardwareFlowControl,IN UINT32 PinMuxing,OUT GPIO_PAD_NATIVE_FUNCTION ** NativePinsTable,OUT UINT32 * NoOfNativePins)152 GpioGetSerialIoUartPins (
153 IN UINT32 SerialIoUartControllerNumber,
154 IN BOOLEAN HardwareFlowControl,
155 IN UINT32 PinMuxing,
156 OUT GPIO_PAD_NATIVE_FUNCTION **NativePinsTable,
157 OUT UINT32 *NoOfNativePins
158 )
159 {
160 UINTN UartGpioIndex;
161
162 UartGpioIndex = SerialIoUartControllerNumber;
163
164 if ((SerialIoUartControllerNumber == 0) && (PinMuxing == 1)) {
165 // Last record is for UART0 second pin set
166 if (IsPchLp ()) {
167 UartGpioIndex = ARRAY_SIZE (mPchLpUartGpio) - 1;
168 } else {
169 UartGpioIndex = ARRAY_SIZE (mPchHUartGpio) - 1;
170 }
171 }
172
173 if (HardwareFlowControl) {
174 *NoOfNativePins = PCH_SERIAL_IO_PINS_PER_UART_CONTROLLER;
175 } else {
176 *NoOfNativePins = PCH_SERIAL_IO_PINS_PER_UART_CONTROLLER_NO_FLOW_CTRL;
177 }
178
179 if (IsPchLp ()) {
180 if (UartGpioIndex < ARRAY_SIZE (mPchLpUartGpio)) {
181 *NativePinsTable = mPchLpUartGpio[UartGpioIndex];
182 return;
183 }
184 } else {
185 if (UartGpioIndex < ARRAY_SIZE (mPchHUartGpio)) {
186 *NativePinsTable = mPchHUartGpio[UartGpioIndex];
187 return;
188 }
189 }
190
191 *NativePinsTable = NULL;
192 *NoOfNativePins = 0;
193 ASSERT (FALSE);
194 }
195
196 //
197 // SPI controller pins
198 // SPI[controller number][pin: CSB/CLK/MISO/MOSI]
199 //
200 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpSpiGpio [][PCH_SERIAL_IO_PINS_PER_SPI_CONTROLLER]=
201 {
202 { // SPI0
203 {GPIO_CNL_LP_GPP_B15, GpioPadModeNative1},
204 {GPIO_CNL_LP_GPP_B16, GpioPadModeNative1},
205 {GPIO_CNL_LP_GPP_B17, GpioPadModeNative1},
206 {GPIO_CNL_LP_GPP_B18, GpioPadModeNative1}
207 },
208 { // SPI1
209 {GPIO_CNL_LP_GPP_B19, GpioPadModeNative1},
210 {GPIO_CNL_LP_GPP_B20, GpioPadModeNative1},
211 {GPIO_CNL_LP_GPP_B21, GpioPadModeNative1},
212 {GPIO_CNL_LP_GPP_B22, GpioPadModeNative1}
213 },
214 { // SPI2
215 {GPIO_CNL_LP_GPP_D9, GpioPadModeNative3},
216 {GPIO_CNL_LP_GPP_D10, GpioPadModeNative3},
217 {GPIO_CNL_LP_GPP_D11, GpioPadModeNative3},
218 {GPIO_CNL_LP_GPP_D12, GpioPadModeNative3}
219 }
220 };
221
222 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHSpiGpio [][PCH_SERIAL_IO_PINS_PER_SPI_CONTROLLER]=
223 {
224 { // SPI0
225 {GPIO_CNL_H_GPP_B15, GpioPadModeNative1},
226 {GPIO_CNL_H_GPP_B16, GpioPadModeNative1},
227 {GPIO_CNL_H_GPP_B17, GpioPadModeNative1},
228 {GPIO_CNL_H_GPP_B18, GpioPadModeNative1}
229 },
230 { // SPI1
231 {GPIO_CNL_H_GPP_B19, GpioPadModeNative1},
232 {GPIO_CNL_H_GPP_B20, GpioPadModeNative1},
233 {GPIO_CNL_H_GPP_B21, GpioPadModeNative1},
234 {GPIO_CNL_H_GPP_B22, GpioPadModeNative1}
235 },
236 { // SPI2
237 {GPIO_CNL_H_GPP_D9, GpioPadModeNative3},
238 {GPIO_CNL_H_GPP_D10, GpioPadModeNative3},
239 {GPIO_CNL_H_GPP_D11, GpioPadModeNative3},
240 {GPIO_CNL_H_GPP_D12, GpioPadModeNative3}
241 }
242 };
243
244 /**
245 This function provides SerialIo SPI controller pins
246
247 @param[in] SerialIoSpiControllerNumber SPI controller
248
249 @param[out] NativePinsTable Table with pins
250 @param[out] NoOfNativePins Number of pins
251 **/
252 VOID
GpioGetSerialIoSpiPins(IN UINT32 SerialIoSpiControllerNumber,OUT GPIO_PAD_NATIVE_FUNCTION ** NativePinsTable,OUT UINT32 * NoOfNativePins)253 GpioGetSerialIoSpiPins (
254 IN UINT32 SerialIoSpiControllerNumber,
255 OUT GPIO_PAD_NATIVE_FUNCTION **NativePinsTable,
256 OUT UINT32 *NoOfNativePins
257 )
258 {
259 if (IsPchLp ()) {
260 if (SerialIoSpiControllerNumber < ARRAY_SIZE (mPchLpSpiGpio)) {
261 *NativePinsTable = mPchLpSpiGpio[SerialIoSpiControllerNumber];
262 *NoOfNativePins = ARRAY_SIZE (mPchLpSpiGpio[SerialIoSpiControllerNumber]);
263 return;
264 }
265 } else {
266 if (SerialIoSpiControllerNumber < ARRAY_SIZE (mPchHSpiGpio)) {
267 *NativePinsTable = mPchHSpiGpio[SerialIoSpiControllerNumber];
268 *NoOfNativePins = ARRAY_SIZE (mPchHSpiGpio[SerialIoSpiControllerNumber]);
269 return;
270 }
271 }
272 *NativePinsTable = NULL;
273 *NoOfNativePins = 0;
274 ASSERT (FALSE);
275 }
276
277 //
278 // ISH GP pin
279 //
280 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpIshGPGpio[] =
281 {
282 {GPIO_CNL_LP_GPP_A18, GpioPadModeNative1},// ISH_GP_0
283 {GPIO_CNL_LP_GPP_A19, GpioPadModeNative1},// ISH_GP_1
284 {GPIO_CNL_LP_GPP_A20, GpioPadModeNative1},// ISH_GP_2
285 {GPIO_CNL_LP_GPP_A21, GpioPadModeNative1},// ISH_GP_3
286 {GPIO_CNL_LP_GPP_A22, GpioPadModeNative1},// ISH_GP_4
287 {GPIO_CNL_LP_GPP_A23, GpioPadModeNative1},// ISH_GP_5
288 {GPIO_CNL_LP_GPP_A12, GpioPadModeNative2},// ISH_GP_6
289 {GPIO_CNL_LP_GPP_A17, GpioPadModeNative2} // ISH_GP_7
290 };
291
292 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHIshGPGpio[] =
293 {
294 {GPIO_CNL_H_GPP_A18, GpioPadModeNative1},// ISH_GP_0
295 {GPIO_CNL_H_GPP_A19, GpioPadModeNative1},// ISH_GP_1
296 {GPIO_CNL_H_GPP_A20, GpioPadModeNative1},// ISH_GP_2
297 {GPIO_CNL_H_GPP_A21, GpioPadModeNative1},// ISH_GP_3
298 {GPIO_CNL_H_GPP_A22, GpioPadModeNative1},// ISH_GP_4
299 {GPIO_CNL_H_GPP_A23, GpioPadModeNative1},// ISH_GP_5
300 {GPIO_CNL_H_GPP_A12, GpioPadModeNative2},// ISH_GP_6
301 {GPIO_CNL_H_GPP_A17, GpioPadModeNative2} // ISH_GP_7
302 };
303
304 /**
305 This function provides ISH GP pin data
306
307 @param[in] IshGpPinNumber ISH GP pin number
308 @param[out] NativePin ISH GP pin
309 **/
310 VOID
GpioGetIshGpPin(IN UINT32 IshGpPinNumber,OUT GPIO_PAD_NATIVE_FUNCTION * NativePin)311 GpioGetIshGpPin (
312 IN UINT32 IshGpPinNumber,
313 OUT GPIO_PAD_NATIVE_FUNCTION *NativePin
314 )
315 {
316 if (IsPchLp ()) {
317 if (IshGpPinNumber < ARRAY_SIZE (mPchLpIshGPGpio)) {
318 *NativePin = mPchLpIshGPGpio[IshGpPinNumber];
319 return;
320 }
321 } else {
322 if (IshGpPinNumber < ARRAY_SIZE (mPchHIshGPGpio)) {
323 *NativePin = mPchHIshGPGpio[IshGpPinNumber];
324 return;
325 }
326 }
327 *NativePin = (GPIO_PAD_NATIVE_FUNCTION){0};
328 ASSERT (FALSE);
329 }
330
331 //
332 // ISH UART controller pins
333 // ISH UART[controller number][pin: RXD/TXD/RTSB/CTSB]
334 //
335 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpIshUartGpio[][PCH_ISH_PINS_PER_UART_CONTROLLER] =
336 {
337 { // UART0
338 {GPIO_CNL_LP_GPP_D13, GpioPadModeNative1},// ISH_UART0_RXD
339 {GPIO_CNL_LP_GPP_D14, GpioPadModeNative1},// ISH_UART0_TXD
340 {GPIO_CNL_LP_GPP_D15, GpioPadModeNative1},// ISH_UART0_RTS
341 {GPIO_CNL_LP_GPP_D16, GpioPadModeNative1} // ISH_UART0_CTS
342 },
343 { // UART1
344 {GPIO_CNL_LP_GPP_C12, GpioPadModeNative2},// ISH_UART1_RXD
345 {GPIO_CNL_LP_GPP_C13, GpioPadModeNative2},// ISH_UART1_TXD
346 {GPIO_CNL_LP_GPP_C14, GpioPadModeNative2},// ISH_UART1_RTSB
347 {GPIO_CNL_LP_GPP_C15, GpioPadModeNative2} // ISH_UART1_CTSB
348 }
349 };
350
351 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHIshUartGpio[][PCH_ISH_PINS_PER_UART_CONTROLLER] =
352 {
353 { // UART0
354 {GPIO_CNL_H_GPP_D13, GpioPadModeNative1},// ISH_UART0_RXD
355 {GPIO_CNL_H_GPP_D14, GpioPadModeNative1},// ISH_UART0_TXD
356 {GPIO_CNL_H_GPP_D15, GpioPadModeNative1},// ISH_UART0_RTS
357 {GPIO_CNL_H_GPP_D16, GpioPadModeNative1} // ISH_UART0_CTS
358 },
359 { // UART1
360 {GPIO_CNL_H_GPP_C12, GpioPadModeNative2},// ISH_UART1_RXD
361 {GPIO_CNL_H_GPP_C13, GpioPadModeNative2},// ISH_UART1_TXD
362 {GPIO_CNL_H_GPP_C14, GpioPadModeNative2},// ISH_UART1_RTS
363 {GPIO_CNL_H_GPP_C15, GpioPadModeNative2} // ISH_UART1_CTS
364 }
365 };
366
367 /**
368 This function provides ISH UART controller pins
369
370 @param[in] IshUartControllerNumber ISH UART controller
371
372 @param[out] NativePinsTable Table with pins
373 **/
374 VOID
GpioGetIshUartPins(IN UINT32 IshUartControllerNumber,OUT GPIO_PAD_NATIVE_FUNCTION ** NativePinsTable)375 GpioGetIshUartPins (
376 IN UINT32 IshUartControllerNumber,
377 OUT GPIO_PAD_NATIVE_FUNCTION **NativePinsTable
378 )
379 {
380 if (IsPchLp ()) {
381 if (IshUartControllerNumber < ARRAY_SIZE (mPchLpIshUartGpio)) {
382 *NativePinsTable = mPchLpIshUartGpio[IshUartControllerNumber];
383 return;
384 }
385 } else {
386 if (IshUartControllerNumber < ARRAY_SIZE (mPchHIshUartGpio)) {
387 *NativePinsTable = mPchHIshUartGpio[IshUartControllerNumber];
388 return;
389 }
390 }
391 *NativePinsTable = NULL;
392 ASSERT (FALSE);
393 }
394
395 //
396 // ISH I2C controller pins
397 // ISH I2C[controller number][pin: SDA/SCL]
398 //
399 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpIshI2cGpio[][PCH_ISH_PINS_PER_I2C_CONTROLLER] =
400 {
401 { // I2C0
402 {GPIO_CNL_LP_GPP_D5, GpioPadModeNative1},// ISH_I2C0_SDA
403 {GPIO_CNL_LP_GPP_D6, GpioPadModeNative1} // ISH_I2C0_SCL
404 },
405 { // I2C1
406 {GPIO_CNL_LP_GPP_D7, GpioPadModeNative1},// ISH_I2C1_SDA
407 {GPIO_CNL_LP_GPP_D8, GpioPadModeNative1} // ISH_I2C1_SCL
408 },
409 { // I2C2
410 {GPIO_CNL_LP_GPP_H10, GpioPadModeNative2},// ISH_I2C2_SDA
411 {GPIO_CNL_LP_GPP_H11, GpioPadModeNative2} // ISH_I2C2_SCL
412 },
413 { // I2C3
414 {GPIO_CNL_LP_GPP_H4, GpioPadModeNative2},// ISH_I2C3_SDA
415 {GPIO_CNL_LP_GPP_H5, GpioPadModeNative2} // ISH_I2C3_SCL
416 },
417 { // I2C4
418 {GPIO_CNL_LP_GPP_H6, GpioPadModeNative2},// ISH_I2C4_SDA
419 {GPIO_CNL_LP_GPP_H7, GpioPadModeNative2} // ISH_I2C4_SCL
420 },
421 { // I2C5
422 {GPIO_CNL_LP_GPP_H8, GpioPadModeNative2},// ISH_I2C5_SDA
423 {GPIO_CNL_LP_GPP_H9, GpioPadModeNative2} // ISH_I2C5_SCL
424 }
425 };
426
427 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHIshI2cGpio[][PCH_ISH_PINS_PER_I2C_CONTROLLER] =
428 {
429 { // I2C0
430 {GPIO_CNL_H_GPP_H19, GpioPadModeNative1},// ISH_I2C0_SDA
431 {GPIO_CNL_H_GPP_H20, GpioPadModeNative1} // ISH_I2C0_SCL
432 },
433 { // I2C1
434 {GPIO_CNL_H_GPP_H21, GpioPadModeNative1},// ISH_I2C1_SDA
435 {GPIO_CNL_H_GPP_H22, GpioPadModeNative1} // ISH_I2C1_SCL
436 },
437 { // I2C2
438 {GPIO_CNL_H_GPP_D4, GpioPadModeNative1},// ISH_I2C2_SDA
439 {GPIO_CNL_H_GPP_D23, GpioPadModeNative1} // ISH_I2C2_SCL
440 }
441 };
442
443 /**
444 This function provides ISH I2C controller pins
445
446 @param[in] IshI2cControllerNumber ISH I2C controller
447
448 @param[out] NativePinsTable Table with pins
449 **/
450 VOID
GpioGetIshI2cPins(IN UINT32 IshI2cControllerNumber,OUT GPIO_PAD_NATIVE_FUNCTION ** NativePinsTable)451 GpioGetIshI2cPins (
452 IN UINT32 IshI2cControllerNumber,
453 OUT GPIO_PAD_NATIVE_FUNCTION **NativePinsTable
454 )
455 {
456 if (IsPchLp ()) {
457 if (IshI2cControllerNumber < ARRAY_SIZE (mPchLpIshI2cGpio)) {
458 *NativePinsTable = mPchLpIshI2cGpio[IshI2cControllerNumber];
459 return;
460 }
461 } else {
462 if (IshI2cControllerNumber < ARRAY_SIZE (mPchHIshI2cGpio)) {
463 *NativePinsTable = mPchHIshI2cGpio[IshI2cControllerNumber];
464 return;
465 }
466 }
467 *NativePinsTable = NULL;
468 ASSERT (FALSE);
469 }
470
471 //
472 // ISH SPI controller pins
473 // ISH SPI[pin: CSB/CLK/MISO/MOSI]
474 //
475 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpIshSpiGpio[PCH_ISH_PINS_PER_SPI_CONTROLLER] =
476 {
477 {GPIO_CNL_LP_GPP_D9, GpioPadModeNative1},// ISH_SPI_CSB
478 {GPIO_CNL_LP_GPP_D10, GpioPadModeNative1},// ISH_SPI_CLK
479 {GPIO_CNL_LP_GPP_D11, GpioPadModeNative1},// ISH_SPI_MISO
480 {GPIO_CNL_LP_GPP_D12, GpioPadModeNative1} // ISH_SPI_MOSI
481 };
482
483 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHIshSpiGpio[PCH_ISH_PINS_PER_SPI_CONTROLLER] =
484 {
485 {GPIO_CNL_H_GPP_D9, GpioPadModeNative1},// ISH_SPI_CSB
486 {GPIO_CNL_H_GPP_D10, GpioPadModeNative1},// ISH_SPI_CLK
487 {GPIO_CNL_H_GPP_D11, GpioPadModeNative1},// ISH_SPI_MISO
488 {GPIO_CNL_H_GPP_D12, GpioPadModeNative1} // ISH_SPI_MOSI
489 };
490
491 /**
492 This function provides ISH SPI controller pins
493
494 @param[in] IshSpiControllerNumber SPI controller
495 @param[out] NativePinsTable Table with pins
496 @param[out] NoOfNativePins Number of pins
497 **/
498 VOID
GpioGetIshSpiPins(IN UINT32 IshSpiControllerNumber,OUT GPIO_PAD_NATIVE_FUNCTION ** NativePinsTable,OUT UINT32 * NoOfNativePins)499 GpioGetIshSpiPins (
500 IN UINT32 IshSpiControllerNumber,
501 OUT GPIO_PAD_NATIVE_FUNCTION **NativePinsTable,
502 OUT UINT32 *NoOfNativePins
503 )
504 {
505 if (IsPchLp ()) {
506 if (IshSpiControllerNumber < ARRAY_SIZE (mPchLpIshSpiGpio)) {
507 *NativePinsTable = mPchLpIshSpiGpio;
508 *NoOfNativePins = ARRAY_SIZE (mPchLpIshSpiGpio);
509 return;
510 }
511 } else {
512 if (IshSpiControllerNumber < ARRAY_SIZE (mPchHIshSpiGpio)) {
513 *NativePinsTable = mPchHIshSpiGpio;
514 *NoOfNativePins = ARRAY_SIZE (mPchHIshSpiGpio);
515 return;
516 }
517 }
518
519 *NoOfNativePins = 0;
520 *NativePinsTable = NULL;
521 ASSERT (FALSE);
522 }
523
524 //
525 // GPIO pins for SD controller
526 //
527 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpScsSdCardGpio[9] =
528 {
529 {GPIO_CNL_LP_GPP_A17, GpioPadModeNative1},// SD_PWR_EN_B
530 {GPIO_CNL_LP_GPP_G0, GpioPadModeNative1},// SD_CMD
531 {GPIO_CNL_LP_GPP_G1, GpioPadModeNative1},// SD_DATA_0
532 {GPIO_CNL_LP_GPP_G2, GpioPadModeNative1},// SD_DATA_1
533 {GPIO_CNL_LP_GPP_G3, GpioPadModeNative1},// SD_DATA_2
534 {GPIO_CNL_LP_GPP_G4, GpioPadModeNative1},// SD_DATA_3
535 {GPIO_CNL_LP_GPP_G5, GpioPadModeNative1},// SD_CDB
536 {GPIO_CNL_LP_GPP_G6, GpioPadModeNative1},// SD_CLK
537 {GPIO_CNL_LP_GPP_G7, GpioPadModeNative1} // SD_WP
538 };
539
540 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHScsSdCardGpio[9] =
541 {
542 {GPIO_CNL_H_GPP_A17, GpioPadModeNative1},// SD_PWR_EN_B
543 {GPIO_CNL_H_GPP_G0, GpioPadModeNative1},// SD_CMD
544 {GPIO_CNL_H_GPP_G1, GpioPadModeNative1},// SD_DATA_0
545 {GPIO_CNL_H_GPP_G2, GpioPadModeNative1},// SD_DATA_1
546 {GPIO_CNL_H_GPP_G3, GpioPadModeNative1},// SD_DATA_2
547 {GPIO_CNL_H_GPP_G4, GpioPadModeNative1},// SD_DATA_3
548 {GPIO_CNL_H_GPP_G5, GpioPadModeNative1},// SD_CDB
549 {GPIO_CNL_H_GPP_G6, GpioPadModeNative1},// SD_CLK
550 {GPIO_CNL_H_GPP_G7, GpioPadModeNative1} // SD_WP
551 };
552
553 /**
554 This function provides SCS SD CARD controller pins
555
556 @param[out] NativePinsTable Table with pins
557 @param[out] NoOfNativePins Number of pins
558 **/
559 VOID
GpioGetScsSdCardPins(OUT GPIO_PAD_NATIVE_FUNCTION ** NativePinsTable,OUT UINT32 * NoOfNativePins)560 GpioGetScsSdCardPins (
561 OUT GPIO_PAD_NATIVE_FUNCTION **NativePinsTable,
562 OUT UINT32 *NoOfNativePins
563 )
564 {
565 if (IsPchLp ()) {
566 *NativePinsTable = mPchLpScsSdCardGpio;
567 *NoOfNativePins = ARRAY_SIZE (mPchLpScsSdCardGpio);
568 } else {
569 *NativePinsTable = mPchHScsSdCardGpio;
570 *NoOfNativePins = ARRAY_SIZE (mPchHScsSdCardGpio);
571 }
572 }
573
574 /**
575 This function provides SCS SD CARD detect pin
576
577 @retval GpioPin SD CARD Detect pin
578 **/
579 GPIO_PAD
GpioGetScsSdCardDetectPin(VOID)580 GpioGetScsSdCardDetectPin (
581 VOID
582 )
583 {
584 if (IsPchLp ()) {
585 return GPIO_CNL_LP_VGPIO39;
586 } else {
587 return GPIO_CNL_H_VGPIO6;
588 }
589 }
590
591 //
592 // GPIO pins for eMMC controller
593 //
594 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpScsEmmcGpio[12] =
595 {
596 {GPIO_CNL_LP_GPP_F11, GpioPadModeNative1},// EMMC_CMD
597 {GPIO_CNL_LP_GPP_F12, GpioPadModeNative1},// EMMC_DATA_0
598 {GPIO_CNL_LP_GPP_F13, GpioPadModeNative1},// EMMC_DATA_1
599 {GPIO_CNL_LP_GPP_F14, GpioPadModeNative1},// EMMC_DATA_2
600 {GPIO_CNL_LP_GPP_F15, GpioPadModeNative1},// EMMC_DATA_3
601 {GPIO_CNL_LP_GPP_F16, GpioPadModeNative1},// EMMC_DATA_4
602 {GPIO_CNL_LP_GPP_F17, GpioPadModeNative1},// EMMC_DATA_5
603 {GPIO_CNL_LP_GPP_F18, GpioPadModeNative1},// EMMC_DATA_6
604 {GPIO_CNL_LP_GPP_F19, GpioPadModeNative1},// EMMC_DATA_7
605 {GPIO_CNL_LP_GPP_F20, GpioPadModeNative1},// EMMC_RCLK
606 {GPIO_CNL_LP_GPP_F21, GpioPadModeNative1},// EMMC_CLK
607 {GPIO_CNL_LP_GPP_F22, GpioPadModeNative1} // EMMC_RESETB
608 };
609
610 /**
611 This function provides SCS eMMC controller pins
612
613 @param[out] NativePinsTable Table with pins
614 @param[out] NoOfNativePins Number of pins
615 **/
616 VOID
GpioGetScsEmmcPins(OUT GPIO_PAD_NATIVE_FUNCTION ** NativePinsTable,OUT UINT32 * NoOfNativePins)617 GpioGetScsEmmcPins (
618 OUT GPIO_PAD_NATIVE_FUNCTION **NativePinsTable,
619 OUT UINT32 *NoOfNativePins
620 )
621 {
622 if (IsPchLp ()) {
623 *NativePinsTable = mPchLpScsEmmcGpio;
624 *NoOfNativePins = ARRAY_SIZE (mPchLpScsEmmcGpio);
625 } else {
626 ASSERT (FALSE);
627 return;
628 }
629 }
630
631 //
632 // GPIO pins for HD Audio Link [pin: BCLK/RSTB/SYNC/SDO/SDIx]
633 //
634 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpHdaLinkGpio[PCH_GPIO_HDA_LINK_NUMBER_OF_PINS] =
635 {
636 {GPIO_CNL_LP_HDA_BCLK, GpioPadModeNative1},// HDA_BCLK
637 {GPIO_CNL_LP_HDA_RSTB, GpioPadModeNative1},// HDA_RSTB
638 {GPIO_CNL_LP_HDA_SYNC, GpioPadModeNative1},// HDA_SYNC
639 {GPIO_CNL_LP_HDA_SDO, GpioPadModeNative1},// HDA_SDO
640 {GPIO_CNL_LP_HDA_SDI_0, GpioPadModeNative1},// HDA_SDI_0
641 {GPIO_CNL_LP_HDA_SDI_1, GpioPadModeNative1} // HDA_SDI_1
642 };
643
644 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHHdaLinkGpio[PCH_GPIO_HDA_LINK_NUMBER_OF_PINS] =
645 {
646 {GPIO_CNL_H_HDA_BCLK, GpioPadModeNative1},// HDA_BCLK
647 {GPIO_CNL_H_HDA_RSTB, GpioPadModeNative1},// HDA_RSTB
648 {GPIO_CNL_H_HDA_SYNC, GpioPadModeNative1},// HDA_SYNC
649 {GPIO_CNL_H_HDA_SDO, GpioPadModeNative1},// HDA_SDO
650 {GPIO_CNL_H_HDA_SDI_0, GpioPadModeNative1},// HDA_SDI_0
651 {GPIO_CNL_H_HDA_SDI_1, GpioPadModeNative1} // HDA_SDI_1
652 };
653
654 /**
655 This function provides HD Audio Link pins
656
657 @param[out] NativePinsTable Table with pins
658 @param[out] NoOfNativePins Number of pins
659 **/
660 VOID
GpioGetHdAudioLinkPins(OUT GPIO_PAD_NATIVE_FUNCTION ** NativePinsTable,OUT UINT32 * NoOfNativePins)661 GpioGetHdAudioLinkPins (
662 OUT GPIO_PAD_NATIVE_FUNCTION **NativePinsTable,
663 OUT UINT32 *NoOfNativePins
664 )
665 {
666 if (IsPchLp ()) {
667 *NativePinsTable = mPchLpHdaLinkGpio;
668 *NoOfNativePins = ARRAY_SIZE (mPchLpHdaLinkGpio);
669 } else {
670 *NativePinsTable = mPchHHdaLinkGpio;
671 *NoOfNativePins = ARRAY_SIZE (mPchHHdaLinkGpio);
672 }
673 }
674
675 //
676 // GPIO pins for HD Audio DMIC [DMIC number][pin: CLK/DATA]
677 //
678 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpHdaDmicGpio[][PCH_GPIO_HDA_DMIC_NUMBER_OF_PINS] =
679 {
680 { // DMIC0
681 {GPIO_CNL_LP_GPP_D19, GpioPadModeNative1},// DMIC_CLK_0
682 {GPIO_CNL_LP_GPP_D20, GpioPadModeNative1} // DMIC_DATA_0
683 },
684 { // DMIC1
685 {GPIO_CNL_LP_GPP_D17, GpioPadModeNative1},// DMIC_CLK_1
686 {GPIO_CNL_LP_GPP_D18, GpioPadModeNative1} // DMIC_DATA_1
687 }
688 };
689
690 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHHdaDmicGpio[][PCH_GPIO_HDA_DMIC_NUMBER_OF_PINS] =
691 {
692 { // DMIC0
693 {GPIO_CNL_H_GPP_D19, GpioPadModeNative1},// DMIC_CLK_0
694 {GPIO_CNL_H_GPP_D20, GpioPadModeNative1} // DMIC_DATA_0
695 },
696 { // DMIC1
697 {GPIO_CNL_H_GPP_D17, GpioPadModeNative1},// DMIC_CLK_1
698 {GPIO_CNL_H_GPP_D18, GpioPadModeNative1} // DMIC_DATA_1
699 }
700 };
701
702 /**
703 This function provides DMIC interface pins
704
705 @param[in] DmicNumber DMIC interface
706
707 @param[out] NativePinsTable Table with pins
708 **/
709 VOID
GpioGetHdaDmicPins(IN UINT32 DmicNumber,OUT GPIO_PAD_NATIVE_FUNCTION ** NativePinsTable)710 GpioGetHdaDmicPins (
711 IN UINT32 DmicNumber,
712 OUT GPIO_PAD_NATIVE_FUNCTION **NativePinsTable
713 )
714 {
715 if (IsPchLp ()) {
716 if (DmicNumber < ARRAY_SIZE (mPchLpHdaDmicGpio)) {
717 *NativePinsTable = mPchLpHdaDmicGpio[DmicNumber];
718 return;
719 }
720 } else {
721 if (DmicNumber < ARRAY_SIZE (mPchHHdaDmicGpio)) {
722 *NativePinsTable = mPchHHdaDmicGpio[DmicNumber];
723 return;
724 }
725 }
726 *NativePinsTable = NULL;
727 ASSERT (FALSE);
728 }
729
730 //
731 // GPIO pins for HD Audio SSPx/I2Sx interface [SSP number][pin: SCLK/SFRM/TXD/RXD]
732 //
733 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpHdaSspInterfaceGpio[][PCH_GPIO_HDA_SSP_NUMBER_OF_PINS] =
734 {
735 { // SSP0/I2S0
736 {GPIO_CNL_LP_HDA_BCLK, GpioPadModeNative2},// SSP0_SCLK
737 {GPIO_CNL_LP_HDA_SYNC, GpioPadModeNative2},// SSP0_SFRM
738 {GPIO_CNL_LP_HDA_SDO, GpioPadModeNative2},// SSP0_TXD
739 {GPIO_CNL_LP_HDA_SDI_0, GpioPadModeNative2} // SSP0_RXD
740 },
741 { // SSP1/I2S1
742 {GPIO_CNL_LP_HDA_RSTB, GpioPadModeNative2},// SSP1_SCLK
743 {GPIO_CNL_LP_SSP1_SFRM, GpioPadModeNative1},// SSP1_SFRM
744 {GPIO_CNL_LP_SSP1_TXD, GpioPadModeNative1},// SSP1_TXD
745 {GPIO_CNL_LP_HDA_SDI_1, GpioPadModeNative2} // SSP1_RXD
746 },
747 { // SSP2/I2S2
748 {GPIO_CNL_LP_GPP_H0, GpioPadModeNative1},// SSP2_SCLK
749 {GPIO_CNL_LP_GPP_H1, GpioPadModeNative1},// SSP2_SFRM
750 {GPIO_CNL_LP_GPP_H2, GpioPadModeNative1},// SSP2_TXD
751 {GPIO_CNL_LP_GPP_H3, GpioPadModeNative1} // SSP2_RXD
752 }
753 };
754
755 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHHdaSspInterfaceGpio[][PCH_GPIO_HDA_SSP_NUMBER_OF_PINS] =
756 {
757 { // SSP0/I2S0
758 {GPIO_CNL_H_HDA_BCLK, GpioPadModeNative2},// SSP0_SCLK
759 {GPIO_CNL_H_HDA_SYNC, GpioPadModeNative2},// SSP0_SFRM
760 {GPIO_CNL_H_HDA_SDO, GpioPadModeNative2},// SSP0_TXD
761 {GPIO_CNL_H_HDA_SDI_0, GpioPadModeNative2} // SSP0_RXD
762 },
763 { // SSP1/I2S1
764 {GPIO_CNL_H_HDA_RSTB, GpioPadModeNative2},// SSP1_SCLK
765 {GPIO_CNL_H_SSP1_SFRM, GpioPadModeNative1},// SSP1_SFRM
766 {GPIO_CNL_H_SSP1_TXD, GpioPadModeNative1},// SSP1_TXD
767 {GPIO_CNL_H_HDA_SDI_1, GpioPadModeNative2} // SSP1_RXD
768 },
769 { // SSP2/I2S2
770 {GPIO_CNL_H_GPP_D5, GpioPadModeNative1}, // SSP2_SFRM
771 {GPIO_CNL_H_GPP_D6, GpioPadModeNative1}, // SSP2_TXD
772 {GPIO_CNL_H_GPP_D7, GpioPadModeNative1}, // SSP2_RXD
773 {GPIO_CNL_H_GPP_D8, GpioPadModeNative1} // SSP2_SCLK
774 }
775 };
776
777 /**
778 This function provides SSP/I2S interface pins
779
780 @param[in] SspInterfaceNumber SSP/I2S interface
781
782 @param[out] NativePinsTable Table with pins
783 **/
784 VOID
GpioGetHdaSspPins(IN UINT32 SspInterfaceNumber,OUT GPIO_PAD_NATIVE_FUNCTION ** NativePinsTable)785 GpioGetHdaSspPins (
786 IN UINT32 SspInterfaceNumber,
787 OUT GPIO_PAD_NATIVE_FUNCTION **NativePinsTable
788 )
789 {
790 if (IsPchLp ()) {
791 if (SspInterfaceNumber < ARRAY_SIZE (mPchLpHdaSspInterfaceGpio)) {
792 *NativePinsTable = mPchLpHdaSspInterfaceGpio[SspInterfaceNumber];
793 return;
794 }
795 } else {
796 if (SspInterfaceNumber < ARRAY_SIZE (mPchHHdaSspInterfaceGpio)) {
797 *NativePinsTable = mPchHHdaSspInterfaceGpio[SspInterfaceNumber];
798 return;
799 }
800 }
801 *NativePinsTable = NULL;
802 ASSERT (FALSE);
803 }
804
805 //
806 // GPIO Pin for HD Audio SSP_MCLK/I2S_MCLK
807 //
808 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpHdaSspMasterClockGpio = {GPIO_CNL_LP_GPP_D23, GpioPadModeNative1};
809 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHHdaSspMasterClockGpio = {GPIO_CNL_H_GPP_B11, GpioPadModeNative1};
810
811 /**
812 This function sets HDA SSP Master Clock into native mode
813
814 @param[in] none
815
816 @retval Status
817 **/
818 EFI_STATUS
GpioEnableHdaSspMasterClock(VOID)819 GpioEnableHdaSspMasterClock (
820 VOID
821 )
822 {
823 if (IsPchLp ()) {
824 return GpioSetPadMode (mPchLpHdaSspMasterClockGpio.Pad, mPchLpHdaSspMasterClockGpio.Mode);
825 } else {
826 return GpioSetPadMode (mPchHHdaSspMasterClockGpio.Pad, mPchHHdaSspMasterClockGpio.Mode);
827 }
828 }
829
830 //
831 // GPIO pins for HD Audio SoundWire interface [SNDW number][pin: CLK/DATA]
832 //
833 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpHdaSndwGpio[][PCH_GPIO_HDA_SNDW_NUMBER_OF_PINS] =
834 {
835 { // SNDW1
836 {GPIO_CNL_LP_HDA_RSTB, GpioPadModeNative3},// SNDW1_CLK
837 {GPIO_CNL_LP_HDA_SDI_1, GpioPadModeNative3} // SNDW1_DATA
838 },
839 { // SNDW2
840 {GPIO_CNL_LP_SSP1_SFRM, GpioPadModeNative2},// SNDW2_CLK
841 {GPIO_CNL_LP_SSP1_TXD, GpioPadModeNative2} // SNDW2_DATA
842 },
843 { // SNDW3
844 {GPIO_CNL_LP_GPP_D17, GpioPadModeNative2},// SNDW3_CLK
845 {GPIO_CNL_LP_GPP_D18, GpioPadModeNative2} // SNDW3_DATA
846 },
847 { // SNDW4
848 {GPIO_CNL_LP_GPP_D19, GpioPadModeNative2},// SNDW4_CLK
849 {GPIO_CNL_LP_GPP_D20, GpioPadModeNative2} // SNDW4_DATA
850 }
851 };
852
853 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHHdaSndwGpio[][PCH_GPIO_HDA_SNDW_NUMBER_OF_PINS] =
854 {
855 { // SNDW1
856 {GPIO_CNL_H_HDA_RSTB, GpioPadModeNative3},// SNDW1_CLK
857 {GPIO_CNL_H_HDA_SDI_1, GpioPadModeNative3} // SNDW1_DATA
858 },
859 { // SNDW2
860 {GPIO_CNL_H_SSP1_SFRM, GpioPadModeNative2},// SNDW2_CLK
861 {GPIO_CNL_H_SSP1_TXD, GpioPadModeNative2} // SNDW2_DATA
862 },
863 { // SNDW3
864 {GPIO_CNL_H_GPP_D17, GpioPadModeNative2},// SNDW3_CLK
865 {GPIO_CNL_H_GPP_D18, GpioPadModeNative2} // SNDW3_DATA
866 },
867 { // SNDW4
868 {GPIO_CNL_H_GPP_D19, GpioPadModeNative2},// SNDW4_CLK
869 {GPIO_CNL_H_GPP_D20, GpioPadModeNative2} // SNDW4_DATA
870 }
871 };
872
873 /**
874 This function provides SNDW interface pins
875
876 @param[in] SndwInterfaceNumber SNDWx interface number
877
878 @param[out] NativePinsTable Table with pins
879 **/
880 VOID
GpioGetHdaSndwPins(IN UINT32 SndwInterfaceNumber,OUT GPIO_PAD_NATIVE_FUNCTION ** NativePinsTable)881 GpioGetHdaSndwPins (
882 IN UINT32 SndwInterfaceNumber,
883 OUT GPIO_PAD_NATIVE_FUNCTION **NativePinsTable
884 )
885 {
886 if (IsPchLp ()) {
887 if (SndwInterfaceNumber < ARRAY_SIZE (mPchLpHdaSndwGpio)) {
888 *NativePinsTable = mPchLpHdaSndwGpio[SndwInterfaceNumber];
889 return;
890 }
891 } else {
892 if (SndwInterfaceNumber < ARRAY_SIZE (mPchHHdaSndwGpio)) {
893 *NativePinsTable = mPchHHdaSndwGpio[SndwInterfaceNumber];
894 return;
895 }
896 }
897 *NativePinsTable = NULL;
898 ASSERT (FALSE);
899 }
900
901 //
902 // GPIO pins for SMBUS
903 //
904 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpSmbusGpio[PCH_GPIO_SMBUS_NUMBER_OF_PINS] =
905 {
906 {GPIO_CNL_LP_GPP_C0, GpioPadModeNative1},// SMB_CLK
907 {GPIO_CNL_LP_GPP_C1, GpioPadModeNative1} // SMB_DATA
908 };
909
910 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHSmbusGpio[PCH_GPIO_SMBUS_NUMBER_OF_PINS] =
911 {
912 {GPIO_CNL_H_GPP_C0, GpioPadModeNative1}, // SMB_CLK
913 {GPIO_CNL_H_GPP_C1, GpioPadModeNative1} // SMB_DATA
914 };
915
916 /**
917 This function provides SMBUS interface pins
918
919 @param[out] NativePinsTable Table with pins
920 **/
921 VOID
GpioGetSmbusPins(OUT GPIO_PAD_NATIVE_FUNCTION ** NativePinsTable)922 GpioGetSmbusPins (
923 OUT GPIO_PAD_NATIVE_FUNCTION **NativePinsTable
924 )
925 {
926 if (IsPchLp ()) {
927 *NativePinsTable = mPchLpSmbusGpio;
928 } else {
929 *NativePinsTable = mPchHSmbusGpio;
930 }
931 }
932
933 //
934 // SMBUS Alert pin
935 //
936 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpSmbusAlertGpio = {GPIO_CNL_LP_GPP_C2, GpioPadModeNative1};
937 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHSmbusAlertGpio = {GPIO_CNL_H_GPP_C2, GpioPadModeNative1};
938
939 /**
940 This function sets SMBUS ALERT pin into native mode
941
942 @param[in] none
943
944 @retval Status
945 **/
946 EFI_STATUS
GpioEnableSmbusAlert(VOID)947 GpioEnableSmbusAlert (
948 VOID
949 )
950 {
951 GPIO_PAD_NATIVE_FUNCTION SmbusAlertGpio;
952
953 if (IsPchLp ()) {
954 SmbusAlertGpio = mPchLpSmbusAlertGpio;
955 } else {
956 SmbusAlertGpio = mPchHSmbusAlertGpio;
957 }
958
959 return GpioSetPadMode (SmbusAlertGpio.Pad, SmbusAlertGpio.Mode);
960 }
961
962 //
963 // SATADevSlpPin to GPIO pin mapping
964 // SATA_DEVSLP_x -> GPIO pin y
965 //
966 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpSataDevSlpPinToGpioMap[] =
967 {
968 {GPIO_CNL_LP_GPP_E4, GpioPadModeNative1},
969 {GPIO_CNL_LP_GPP_E5, GpioPadModeNative1},
970 {GPIO_CNL_LP_GPP_E6, GpioPadModeNative1}
971 };
972
973 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHSataDevSlpPinToGpioMap[] =
974 {
975 {GPIO_CNL_H_GPP_E4, GpioPadModeNative1},
976 {GPIO_CNL_H_GPP_E5, GpioPadModeNative1},
977 {GPIO_CNL_H_GPP_E6, GpioPadModeNative1},
978 {GPIO_CNL_H_GPP_F5, GpioPadModeNative1},
979 {GPIO_CNL_H_GPP_F6, GpioPadModeNative1},
980 {GPIO_CNL_H_GPP_F7, GpioPadModeNative1},
981 {GPIO_CNL_H_GPP_F8, GpioPadModeNative1},
982 {GPIO_CNL_H_GPP_F9, GpioPadModeNative1}
983 };
984
985 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mCdfPchSata1DevSlpPinToGpioMap[] =
986 {
987 /// @todo SERVER- update for SATA 1
988 {GPIO_CNL_H_GPP_E4, GpioPadModeNative1},
989 {GPIO_CNL_H_GPP_E5, GpioPadModeNative1},
990 {GPIO_CNL_H_GPP_E6, GpioPadModeNative1},
991 {GPIO_CNL_H_GPP_F5, GpioPadModeNative1},
992 {GPIO_CNL_H_GPP_F6, GpioPadModeNative1},
993 {GPIO_CNL_H_GPP_F7, GpioPadModeNative1}
994 };
995
996 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mCdfPchSata2DevSlpPinToGpioMap[] =
997 {
998 /// @todo SERVER- update for SATA 2
999 {GPIO_CNL_H_GPP_E4, GpioPadModeNative1},
1000 {GPIO_CNL_H_GPP_E5, GpioPadModeNative1},
1001 {GPIO_CNL_H_GPP_E6, GpioPadModeNative1},
1002 {GPIO_CNL_H_GPP_F5, GpioPadModeNative1},
1003 {GPIO_CNL_H_GPP_F6, GpioPadModeNative1},
1004 {GPIO_CNL_H_GPP_F7, GpioPadModeNative1}
1005 };
1006
1007 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mCdfPchSata3DevSlpPinToGpioMap[] =
1008 {
1009 /// @todo SERVER- update for SATA 3
1010 {GPIO_CNL_H_GPP_E4, GpioPadModeNative1},
1011 {GPIO_CNL_H_GPP_E5, GpioPadModeNative1},
1012 {GPIO_CNL_H_GPP_E6, GpioPadModeNative1},
1013 {GPIO_CNL_H_GPP_F5, GpioPadModeNative1},
1014 {GPIO_CNL_H_GPP_F6, GpioPadModeNative1},
1015 {GPIO_CNL_H_GPP_F7, GpioPadModeNative1}
1016 };
1017
1018 /**
1019 This function provides SATA DevSlp pin data
1020
1021 @param[in] SataCtrlIndex SATA controller index
1022 @param[in] SataPort SATA port number
1023 @param[out] NativePin SATA DevSlp pin
1024 **/
1025 VOID
GpioGetSataDevSlpPin(IN UINT32 SataCtrlIndex,IN UINTN SataPort,OUT GPIO_PAD_NATIVE_FUNCTION * NativePin)1026 GpioGetSataDevSlpPin (
1027 IN UINT32 SataCtrlIndex,
1028 IN UINTN SataPort,
1029 OUT GPIO_PAD_NATIVE_FUNCTION *NativePin
1030 )
1031 {
1032 if (IsCdfPch ()) {
1033 if (SataCtrlIndex == SATA_1_CONTROLLER_INDEX) {
1034 if (SataPort < ARRAY_SIZE (mCdfPchSata1DevSlpPinToGpioMap)) {
1035 *NativePin = mCdfPchSata1DevSlpPinToGpioMap[SataPort];
1036 return;
1037 }
1038 } else if (SataCtrlIndex == SATA_2_CONTROLLER_INDEX) {
1039 if (SataPort < ARRAY_SIZE (mCdfPchSata2DevSlpPinToGpioMap)) {
1040 *NativePin = mCdfPchSata2DevSlpPinToGpioMap[SataPort];
1041 return;
1042 }
1043 } else if (SataCtrlIndex == SATA_3_CONTROLLER_INDEX) {
1044 if (SataPort < ARRAY_SIZE (mCdfPchSata3DevSlpPinToGpioMap)) {
1045 *NativePin = mCdfPchSata3DevSlpPinToGpioMap[SataPort];
1046 return;
1047 }
1048 }
1049 } else {
1050 if (IsPchLp ()) {
1051 if (SataPort < ARRAY_SIZE (mPchLpSataDevSlpPinToGpioMap)) {
1052 *NativePin = mPchLpSataDevSlpPinToGpioMap[SataPort];
1053 return;
1054 }
1055 } else {
1056 if (SataPort < ARRAY_SIZE (mPchHSataDevSlpPinToGpioMap)) {
1057 *NativePin = mPchHSataDevSlpPinToGpioMap[SataPort];
1058 return;
1059 }
1060 }
1061 }
1062 *NativePin = (GPIO_PAD_NATIVE_FUNCTION){0};
1063 ASSERT (FALSE);
1064 }
1065
1066 //
1067 // SATA reset port to GPIO pin mapping
1068 // SATAGP_x -> GPIO pin y
1069 //
1070 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpSataGpToGpioMap[] =
1071 {
1072 {GPIO_CNL_LP_GPP_E0, GpioPadModeNative2},
1073 {GPIO_CNL_LP_GPP_E1, GpioPadModeNative2},
1074 {GPIO_CNL_LP_GPP_E2, GpioPadModeNative2}
1075 };
1076
1077 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHSataGpToGpioMap[] =
1078 {
1079 {GPIO_CNL_H_GPP_E0, GpioPadModeNative2},
1080 {GPIO_CNL_H_GPP_E1, GpioPadModeNative2},
1081 {GPIO_CNL_H_GPP_E2, GpioPadModeNative2},
1082 {GPIO_CNL_H_GPP_F0, GpioPadModeNative2},
1083 {GPIO_CNL_H_GPP_F1, GpioPadModeNative2},
1084 {GPIO_CNL_H_GPP_F2, GpioPadModeNative2},
1085 {GPIO_CNL_H_GPP_F3, GpioPadModeNative2},
1086 {GPIO_CNL_H_GPP_F4, GpioPadModeNative2}
1087 };
1088
1089 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mCdfPchSata1GpToGpioMap[] =
1090 {
1091 /// @todo SERVER- update for SATA 1
1092 {GPIO_CNL_H_GPP_E0, GpioPadModeNative2},
1093 {GPIO_CNL_H_GPP_E1, GpioPadModeNative2},
1094 {GPIO_CNL_H_GPP_E2, GpioPadModeNative2},
1095 {GPIO_CNL_H_GPP_F0, GpioPadModeNative2},
1096 {GPIO_CNL_H_GPP_F1, GpioPadModeNative2},
1097 {GPIO_CNL_H_GPP_F2, GpioPadModeNative2}
1098 };
1099
1100 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mCdfPchSata2GpToGpioMap[] =
1101 {
1102 /// @todo SERVER- update for SATA 2
1103 {GPIO_CNL_H_GPP_E0, GpioPadModeNative2},
1104 {GPIO_CNL_H_GPP_E1, GpioPadModeNative2},
1105 {GPIO_CNL_H_GPP_E2, GpioPadModeNative2},
1106 {GPIO_CNL_H_GPP_F0, GpioPadModeNative2},
1107 {GPIO_CNL_H_GPP_F1, GpioPadModeNative2},
1108 {GPIO_CNL_H_GPP_F2, GpioPadModeNative2}
1109 };
1110
1111 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mCdfPchSata3GpToGpioMap[] =
1112 {
1113 /// @todo SERVER- update for SATA 3
1114 {GPIO_CNL_H_GPP_E0, GpioPadModeNative2},
1115 {GPIO_CNL_H_GPP_E1, GpioPadModeNative2},
1116 {GPIO_CNL_H_GPP_E2, GpioPadModeNative2},
1117 {GPIO_CNL_H_GPP_F0, GpioPadModeNative2},
1118 {GPIO_CNL_H_GPP_F1, GpioPadModeNative2},
1119 {GPIO_CNL_H_GPP_F2, GpioPadModeNative2}
1120 };
1121
1122 /**
1123 This function provides SATA GP pin data
1124
1125 @param[in] SataCtrlIndex SATA controller index
1126 @param[in] SataPort SATA port number
1127 @param[out] NativePin SATA GP pin
1128 **/
1129 VOID
GpioGetSataGpPin(IN UINT32 SataCtrlIndex,IN UINTN SataPort,OUT GPIO_PAD_NATIVE_FUNCTION * NativePin)1130 GpioGetSataGpPin (
1131 IN UINT32 SataCtrlIndex,
1132 IN UINTN SataPort,
1133 OUT GPIO_PAD_NATIVE_FUNCTION *NativePin
1134 )
1135 {
1136 if (IsCdfPch ()) {
1137 if (SataCtrlIndex == SATA_1_CONTROLLER_INDEX) {
1138 if (SataPort < ARRAY_SIZE (mCdfPchSata1GpToGpioMap)) {
1139 *NativePin = mCdfPchSata1GpToGpioMap[SataPort];
1140 return;
1141 }
1142 } else if (SataCtrlIndex == SATA_2_CONTROLLER_INDEX) {
1143 if (SataPort < ARRAY_SIZE (mCdfPchSata2GpToGpioMap)) {
1144 *NativePin = mCdfPchSata2GpToGpioMap[SataPort];
1145 return;
1146 }
1147 } else if (SataCtrlIndex == SATA_3_CONTROLLER_INDEX) {
1148 if (SataPort < ARRAY_SIZE (mCdfPchSata3GpToGpioMap)) {
1149 *NativePin = mCdfPchSata3GpToGpioMap[SataPort];
1150 return;
1151 }
1152 }
1153 } else {
1154 if (IsPchLp ()) {
1155 if (SataPort < ARRAY_SIZE (mPchLpSataGpToGpioMap)) {
1156 *NativePin = mPchLpSataGpToGpioMap[SataPort];
1157 return;
1158 }
1159 } else {
1160 if (SataPort < ARRAY_SIZE (mPchHSataGpToGpioMap)) {
1161 *NativePin = mPchHSataGpToGpioMap[SataPort];
1162 return;
1163 }
1164 }
1165 }
1166 *NativePin = (GPIO_PAD_NATIVE_FUNCTION){0};
1167 ASSERT (FALSE);
1168 }
1169
1170 //
1171 // SATA LED pin
1172 //
1173 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpSataLedGpio = {GPIO_CNL_LP_GPP_E8, GpioPadModeNative1};
1174 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHSataLedGpio = {GPIO_CNL_H_GPP_E8, GpioPadModeNative1};
1175
1176 /**
1177 This function sets SATA LED pin into native mode. SATA LED indicates
1178 SATA controller activity
1179
1180 @param[in] none
1181
1182 @retval Status
1183 **/
1184 EFI_STATUS
GpioEnableSataLed(VOID)1185 GpioEnableSataLed (
1186 VOID
1187 )
1188 {
1189 GPIO_PAD_NATIVE_FUNCTION SataLedGpio;
1190
1191 if (IsPchLp ()) {
1192 SataLedGpio = mPchLpSataLedGpio;
1193 } else {
1194 SataLedGpio = mPchHSataLedGpio;
1195 }
1196
1197 return GpioSetPadMode (SataLedGpio.Pad, SataLedGpio.Mode);
1198 }
1199
1200 //
1201 // USB2 OC pins
1202 //
1203 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpUsbOcGpioPins[] =
1204 {
1205 {GPIO_CNL_LP_GPP_E9, GpioPadModeNative1},// USB_OC_0
1206 {GPIO_CNL_LP_GPP_E10, GpioPadModeNative1},// USB_OC_1
1207 {GPIO_CNL_LP_GPP_E11, GpioPadModeNative1},// USB_OC_2
1208 {GPIO_CNL_LP_GPP_E12, GpioPadModeNative1} // USB_OC_3
1209 };
1210
1211 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHUsbOcGpioPins[] =
1212 {
1213 {GPIO_CNL_H_GPP_E9, GpioPadModeNative1},// USB_OC_0
1214 {GPIO_CNL_H_GPP_E10, GpioPadModeNative1},// USB_OC_1
1215 {GPIO_CNL_H_GPP_E11, GpioPadModeNative1},// USB_OC_2
1216 {GPIO_CNL_H_GPP_E12, GpioPadModeNative1},// USB_OC_3
1217 {GPIO_CNL_H_GPP_F15, GpioPadModeNative1},// USB_OC_4
1218 {GPIO_CNL_H_GPP_F16, GpioPadModeNative1},// USB_OC_5
1219 {GPIO_CNL_H_GPP_F17, GpioPadModeNative1},// USB_OC_6
1220 {GPIO_CNL_H_GPP_F18, GpioPadModeNative1} // USB_OC_7
1221 };
1222
1223 /**
1224 This function enables USB OverCurrent pins by setting
1225 USB2 OCB pins into native mode
1226
1227 @param[in] OcPinNumber USB OC pin number
1228
1229 @retval Status
1230 **/
1231 EFI_STATUS
GpioEnableUsbOverCurrent(IN UINTN OcPinNumber)1232 GpioEnableUsbOverCurrent (
1233 IN UINTN OcPinNumber
1234 )
1235 {
1236 GPIO_PAD_NATIVE_FUNCTION OcGpio;
1237
1238 if (IsPchLp ()) {
1239 if (OcPinNumber >= ARRAY_SIZE (mPchLpUsbOcGpioPins)) {
1240 ASSERT(FALSE);
1241 return EFI_UNSUPPORTED;
1242 }
1243 OcGpio = mPchLpUsbOcGpioPins[OcPinNumber];
1244 } else {
1245 if (OcPinNumber >= ARRAY_SIZE (mPchHUsbOcGpioPins)) {
1246 ASSERT (FALSE);
1247 return EFI_UNSUPPORTED;
1248 }
1249 OcGpio = mPchHUsbOcGpioPins[OcPinNumber];
1250 }
1251
1252 return GpioSetPadMode (OcGpio.Pad, OcGpio.Mode);
1253 }
1254
1255 //
1256 // GPIO pin for PCIE SCRCLKREQB
1257 // SCRCLKREQB_x -> GPIO pin y
1258 //
1259 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpPcieSrcClkReqbPinToGpioMap[] =
1260 {
1261 {GPIO_CNL_LP_GPP_B5, GpioPadModeNative1},
1262 {GPIO_CNL_LP_GPP_B6, GpioPadModeNative1},
1263 {GPIO_CNL_LP_GPP_B7, GpioPadModeNative1},
1264 {GPIO_CNL_LP_GPP_B8, GpioPadModeNative1},
1265 {GPIO_CNL_LP_GPP_B9, GpioPadModeNative1},
1266 {GPIO_CNL_LP_GPP_B10, GpioPadModeNative1}
1267 };
1268
1269 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHPcieSrcClkReqbPinToGpioMap[] =
1270 {
1271 {GPIO_CNL_H_GPP_B5, GpioPadModeNative1},
1272 {GPIO_CNL_H_GPP_B6, GpioPadModeNative1},
1273 {GPIO_CNL_H_GPP_B7, GpioPadModeNative1},
1274 {GPIO_CNL_H_GPP_B8, GpioPadModeNative1},
1275 {GPIO_CNL_H_GPP_B9, GpioPadModeNative1},
1276 {GPIO_CNL_H_GPP_B10, GpioPadModeNative1},
1277 {GPIO_CNL_H_GPP_H0, GpioPadModeNative1},
1278 {GPIO_CNL_H_GPP_H1, GpioPadModeNative1},
1279 {GPIO_CNL_H_GPP_H2, GpioPadModeNative1},
1280 {GPIO_CNL_H_GPP_H3, GpioPadModeNative1},
1281 {GPIO_CNL_H_GPP_H4, GpioPadModeNative1},
1282 {GPIO_CNL_H_GPP_H5, GpioPadModeNative1},
1283 {GPIO_CNL_H_GPP_H6, GpioPadModeNative1},
1284 {GPIO_CNL_H_GPP_H7, GpioPadModeNative1},
1285 {GPIO_CNL_H_GPP_H8, GpioPadModeNative1},
1286 {GPIO_CNL_H_GPP_H9, GpioPadModeNative1}
1287 };
1288
1289 /**
1290 This function provides PCIe CLKREQ pin data
1291
1292 @param[in] ClkreqIndex CLKREQ# number
1293 @param[out] NativePin Native pin data
1294 **/
1295 VOID
GpioGetPcieClkReqPin(IN UINT32 ClkreqIndex,OUT GPIO_PAD_NATIVE_FUNCTION * NativePin)1296 GpioGetPcieClkReqPin (
1297 IN UINT32 ClkreqIndex,
1298 OUT GPIO_PAD_NATIVE_FUNCTION *NativePin
1299 )
1300 {
1301 if (IsPchLp ()) {
1302 if (ClkreqIndex < ARRAY_SIZE (mPchLpPcieSrcClkReqbPinToGpioMap)) {
1303 *NativePin = mPchLpPcieSrcClkReqbPinToGpioMap[ClkreqIndex];
1304 return;
1305 }
1306 } else {
1307 if (ClkreqIndex < ARRAY_SIZE (mPchHPcieSrcClkReqbPinToGpioMap)) {
1308 *NativePin = mPchHPcieSrcClkReqbPinToGpioMap[ClkreqIndex];
1309 return;
1310 }
1311 }
1312 *NativePin = (GPIO_PAD_NATIVE_FUNCTION){0};
1313 ASSERT (FALSE);
1314 }
1315
1316 //
1317 // PCHHOTB pin
1318 //
1319 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpPchHotbPin = {GPIO_CNL_LP_GPP_B23, GpioPadModeNative2};
1320 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHPchHotbPin = {GPIO_CNL_H_GPP_B23, GpioPadModeNative2};
1321
1322 /**
1323 This function sets PCHHOT pin into native mode
1324
1325 @param[in] none
1326
1327 @retval Status
1328 **/
1329 EFI_STATUS
GpioEnablePchHot(VOID)1330 GpioEnablePchHot (
1331 VOID
1332 )
1333 {
1334 GPIO_PAD_NATIVE_FUNCTION PchHotbPin;
1335
1336 if (IsPchLp ()) {
1337 PchHotbPin = mPchLpPchHotbPin;
1338 } else {
1339 PchHotbPin = mPchHPchHotbPin;
1340 }
1341
1342 return GpioSetPadMode (PchHotbPin.Pad, PchHotbPin.Mode);
1343 }
1344
1345 //
1346 // VRALERTB pin
1347 //
1348 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpVrAlertbPin = {GPIO_CNL_LP_GPP_B2, GpioPadModeNative1};
1349 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHVrAlertbPin = {GPIO_CNL_H_GPP_B2, GpioPadModeNative1};
1350
1351 //
1352 // CPU_C10_GATE pin
1353 //
1354 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpCpuC10GatePin = {GPIO_CNL_LP_GPP_H18, GpioPadModeNative1};
1355 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHCpuC10GatePin = {GPIO_CNL_H_GPP_J1, GpioPadModeNative2};
1356
1357 /**
1358 This function sets VRALERTB pin into native mode
1359
1360 @param[in] none
1361
1362 @retval Status
1363 **/
1364 EFI_STATUS
GpioEnableVrAlert(VOID)1365 GpioEnableVrAlert (
1366 VOID
1367 )
1368 {
1369 GPIO_PAD_NATIVE_FUNCTION VrAlertGpio;
1370
1371 if (IsPchLp ()) {
1372 VrAlertGpio = mPchLpVrAlertbPin;
1373 } else {
1374 VrAlertGpio = mPchHVrAlertbPin;
1375 }
1376
1377 return GpioSetPadMode (VrAlertGpio.Pad, VrAlertGpio.Mode);
1378 }
1379
1380 /**
1381 This function sets CPU C10 Gate pins into native mode
1382
1383 @retval Status
1384 **/
1385 EFI_STATUS
GpioEnableCpuC10GatePin(VOID)1386 GpioEnableCpuC10GatePin (
1387 VOID
1388 )
1389 {
1390 GPIO_PAD_NATIVE_FUNCTION CpuC10GateGpio;
1391
1392 if (IsPchLp ()) {
1393 CpuC10GateGpio = mPchLpCpuC10GatePin;
1394 } else {
1395 CpuC10GateGpio = mPchHCpuC10GatePin;
1396 }
1397
1398 return GpioSetPadMode (CpuC10GateGpio.Pad, CpuC10GateGpio.Mode);
1399 }
1400
1401 //
1402 // CPU GP pins
1403 //
1404 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpCpuGpPinMap[PCH_GPIO_CPU_GP_NUMBER_OF_PINS] =
1405 {
1406 {GPIO_CNL_LP_GPP_E3, GpioPadModeNative1}, // CPU_GP_0
1407 {GPIO_CNL_LP_GPP_E7, GpioPadModeNative1}, // CPU_GP_1
1408 {GPIO_CNL_LP_GPP_B3, GpioPadModeNative1}, // CPU_GP_2
1409 {GPIO_CNL_LP_GPP_B4, GpioPadModeNative1}, // CPU_GP_3
1410 };
1411 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHCpuGpPinMap[PCH_GPIO_CPU_GP_NUMBER_OF_PINS] =
1412 {
1413 {GPIO_CNL_H_GPP_E3, GpioPadModeNative1}, // CPU_GP_0
1414 {GPIO_CNL_H_GPP_E7, GpioPadModeNative1}, // CPU_GP_1
1415 {GPIO_CNL_H_GPP_B3, GpioPadModeNative1}, // CPU_GP_2
1416 {GPIO_CNL_H_GPP_B4, GpioPadModeNative1}, // CPU_GP_3
1417 };
1418
1419 /**
1420 This function sets CPU GP pins into native mode
1421
1422 @param[in] CpuGpPinNum CPU GP pin number
1423
1424 @retval Status
1425 **/
1426 EFI_STATUS
GpioEnableCpuGpPin(IN UINT32 CpuGpPinNum)1427 GpioEnableCpuGpPin (
1428 IN UINT32 CpuGpPinNum
1429 )
1430 {
1431 GPIO_PAD_NATIVE_FUNCTION CpuGpPin;
1432
1433 if (IsPchLp ()) {
1434 if (CpuGpPinNum >= ARRAY_SIZE (mPchLpCpuGpPinMap)) {
1435 ASSERT (FALSE);
1436 return EFI_UNSUPPORTED;
1437 }
1438 CpuGpPin = mPchLpCpuGpPinMap[CpuGpPinNum];
1439 } else {
1440 if (CpuGpPinNum >= ARRAY_SIZE (mPchHCpuGpPinMap)) {
1441 ASSERT(FALSE);
1442 return EFI_UNSUPPORTED;
1443 }
1444 CpuGpPin = mPchHCpuGpPinMap[CpuGpPinNum];
1445 }
1446
1447 return GpioSetPadMode (CpuGpPin.Pad, CpuGpPin.Mode);
1448 }
1449
1450 //
1451 // DDSP_HPD pins
1452 //
1453 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpDdspHpdPins[] =
1454 {
1455 {GPIO_CNL_LP_GPP_E13, GpioPadModeNative1},// DDSP_HPD_0
1456 {GPIO_CNL_LP_GPP_E14, GpioPadModeNative1},// DDSP_HPD_1
1457 {GPIO_CNL_LP_GPP_E15, GpioPadModeNative1},// DDSP_HPD_2
1458 {GPIO_CNL_LP_GPP_E16, GpioPadModeNative1} // DDSP_HPD_3
1459 };
1460
1461 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHDdspHpdPins[] =
1462 {
1463 {GPIO_CNL_H_GPP_I0, GpioPadModeNative1},// DDSP_HPD_0
1464 {GPIO_CNL_H_GPP_I1, GpioPadModeNative1},// DDSP_HPD_1
1465 {GPIO_CNL_H_GPP_I2, GpioPadModeNative1},// DDSP_HPD_2
1466 {GPIO_CNL_H_GPP_I3, GpioPadModeNative1} // DDSP_HPD_3
1467 };
1468
1469 /**
1470 This function sets DDSP_HPDx pin into native mode
1471
1472 @param[in] DdspHpdPin DDSP_HPDx pin
1473
1474 @retval Status
1475 **/
1476 EFI_STATUS
GpioEnableDpHotPlugDetect(IN GPIO_DDSP_HPD DdspHpdPin)1477 GpioEnableDpHotPlugDetect (
1478 IN GPIO_DDSP_HPD DdspHpdPin
1479 )
1480 {
1481 GPIO_PAD_NATIVE_FUNCTION DdspHpdGpio;
1482 UINT32 DdspHpdPinIndex;
1483
1484 if (DdspHpdPin > GpioDdspHpd3) {
1485 return EFI_UNSUPPORTED;
1486 }
1487
1488 DdspHpdPinIndex = DdspHpdPin - GpioDdspHpd0;
1489
1490 if (IsPchLp ()) {
1491 if (DdspHpdPinIndex >= ARRAY_SIZE (mPchLpDdspHpdPins)) {
1492 goto Error;
1493 }
1494 DdspHpdGpio = mPchLpDdspHpdPins[DdspHpdPinIndex];
1495 } else {
1496 if (DdspHpdPinIndex >= ARRAY_SIZE (mPchHDdspHpdPins)) {
1497 goto Error;
1498 }
1499 DdspHpdGpio = mPchHDdspHpdPins[DdspHpdPinIndex];
1500 }
1501
1502 return GpioSetPadMode (DdspHpdGpio.Pad, DdspHpdGpio.Mode);
1503 Error:
1504 ASSERT (FALSE);
1505 return EFI_UNSUPPORTED;
1506 }
1507
1508 //
1509 // EDP HPD, VDD and BKLT pins
1510 //
1511 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpEdpPins[PCH_GPIO_EDP_NUMBER_OF_PINS] =
1512 {
1513 {GPIO_CNL_LP_GPP_E17, GpioPadModeNative1},// EDP_HPD
1514 {GPIO_CNL_LP_HVMOS_L_VDDEN, GpioPadModeNative1},// VDDEN
1515 {GPIO_CNL_LP_HVMOS_L_BKLTEN, GpioPadModeNative1},// BKLTEN
1516 {GPIO_CNL_LP_HVMOS_L_BKLTCTL, GpioPadModeNative1} // BKLTCTL
1517 };
1518
1519 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHEdpPins[PCH_GPIO_EDP_NUMBER_OF_PINS] =
1520 {
1521 {GPIO_CNL_H_GPP_I4, GpioPadModeNative1},// EDP_HPD
1522 {GPIO_CNL_H_GPP_F19, GpioPadModeNative1},// VDDEN
1523 {GPIO_CNL_H_GPP_F20, GpioPadModeNative1},// BKLTEN
1524 {GPIO_CNL_H_GPP_F21, GpioPadModeNative1} // BKLTCTL
1525 };
1526
1527 /**
1528 This function provides eDP pins
1529
1530 @param[out] NativePinsTable Table with pins
1531 @param[out] NoOfNativePins Number of pins
1532 **/
1533 VOID
GpioGetEdpPins(OUT GPIO_PAD_NATIVE_FUNCTION ** NativePinsTable,OUT UINT32 * NoOfNativePins)1534 GpioGetEdpPins (
1535 OUT GPIO_PAD_NATIVE_FUNCTION **NativePinsTable,
1536 OUT UINT32 *NoOfNativePins
1537 )
1538 {
1539 if (IsPchLp ()) {
1540 *NativePinsTable = mPchLpEdpPins;
1541 *NoOfNativePins = ARRAY_SIZE (mPchLpEdpPins);
1542 } else {
1543 *NativePinsTable = mPchHEdpPins;
1544 *NoOfNativePins = ARRAY_SIZE (mPchHEdpPins);
1545 }
1546 }
1547
1548 //
1549 // DDPB/C/D/F CTRLCLK and CTRLDATA pins
1550 //
1551 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpDdpInterfacePins[PCH_GPIO_DDP_NUMBER_OF_INTERFACES][PCH_GPIO_DDP_NUMBER_OF_PINS] =
1552 {
1553 {// DDPB
1554 {GPIO_CNL_LP_GPP_E18, GpioPadModeNative1},// DDPB_CTRLCLK
1555 {GPIO_CNL_LP_GPP_E19, GpioPadModeNative1} // DDPB_CTRLDATA
1556 },
1557 {// DDPC
1558 {GPIO_CNL_LP_GPP_E20, GpioPadModeNative1},// DDPC_CTRLCLK
1559 {GPIO_CNL_LP_GPP_E21, GpioPadModeNative1} // DDPC_CTRLDATA
1560 },
1561 {// DDPD
1562 {GPIO_CNL_LP_GPP_E22, GpioPadModeNative1},// DDPD_CTRLCLK
1563 {GPIO_CNL_LP_GPP_E23, GpioPadModeNative1} // DDPD_CTRLDATA
1564 },
1565 {// DDPF
1566 {GPIO_CNL_LP_GPP_H16, GpioPadModeNative1},// DDPF_CTRLCLK
1567 {GPIO_CNL_LP_GPP_H17, GpioPadModeNative1} // DDPF_CTRLDATA
1568 }
1569 };
1570
1571 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHDdpInterfacePins[PCH_GPIO_DDP_NUMBER_OF_INTERFACES][PCH_GPIO_DDP_NUMBER_OF_PINS] =
1572 {
1573 {// DDPB
1574 {GPIO_CNL_H_GPP_I5, GpioPadModeNative1}, // DDPB_CTRLCLK
1575 {GPIO_CNL_H_GPP_I6, GpioPadModeNative1}, // DDPB_CTRLDATA
1576 },
1577 {// DDPC
1578 {GPIO_CNL_H_GPP_I7, GpioPadModeNative1}, // DDPC_CTRLCLK
1579 {GPIO_CNL_H_GPP_I8, GpioPadModeNative1}, // DDPC_CTRLDATA
1580 },
1581 {// DDPD
1582 {GPIO_CNL_H_GPP_I9, GpioPadModeNative1}, // DDPD_CTRLCLK
1583 {GPIO_CNL_H_GPP_I10, GpioPadModeNative1}, // DDPD_CTRLDATA
1584 },
1585 {// DDPF
1586 {GPIO_CNL_H_GPP_F22, GpioPadModeNative1}, // DDPF_CTRLCLK
1587 {GPIO_CNL_H_GPP_F23, GpioPadModeNative1}, // DDPF_CTRLDATA
1588 }
1589 };
1590
1591 /**
1592 This function provides DDPx interface pins
1593
1594 @param[in] DdpInterface DDPx interface
1595
1596 @param[out] NativePinsTable Table with pins
1597 **/
1598 VOID
GpioGetDdpPins(IN GPIO_DDP DdpInterface,OUT GPIO_PAD_NATIVE_FUNCTION ** NativePinsTable)1599 GpioGetDdpPins (
1600 IN GPIO_DDP DdpInterface,
1601 OUT GPIO_PAD_NATIVE_FUNCTION **NativePinsTable
1602 )
1603 {
1604 UINT32 DdpInterfaceIndex;
1605
1606 switch (DdpInterface) {
1607 case GpioDdpB:
1608 case GpioDdpC:
1609 case GpioDdpD:
1610 DdpInterfaceIndex = DdpInterface - GpioDdpB;
1611 break;
1612 case GpioDdpF:
1613 DdpInterfaceIndex = 3;
1614 break;
1615 default:
1616 goto Error;
1617 }
1618
1619 if (IsPchLp ()) {
1620 if (DdpInterfaceIndex < ARRAY_SIZE (mPchLpDdpInterfacePins)) {
1621 *NativePinsTable = mPchLpDdpInterfacePins[DdpInterfaceIndex];
1622 return;
1623 }
1624 } else {
1625 if (DdpInterfaceIndex < ARRAY_SIZE (mPchHDdpInterfacePins)) {
1626 *NativePinsTable = mPchHDdpInterfacePins[DdpInterfaceIndex];
1627 return;
1628 }
1629 }
1630 Error:
1631 *NativePinsTable = NULL;
1632 ASSERT(FALSE);
1633 }
1634
1635 /**
1636 This function enables CNVi RF Reset pin
1637 **/
1638 VOID
GpioEnableCnviRfResetPin(VOID)1639 GpioEnableCnviRfResetPin (
1640 VOID
1641 )
1642 {
1643 EFI_STATUS Status;
1644 GPIO_PAD GpioPad;
1645 GPIO_PAD_MODE PadMode;
1646
1647 if (IsPchLp ()) {
1648 GpioPad = GPIO_CNL_LP_GPP_H1;
1649 PadMode = GpioPadModeNative3;
1650 } else {
1651 GpioPad = GPIO_CNL_H_GPP_D5;
1652 PadMode = GpioPadModeNative3;
1653 }
1654
1655 Status = GpioSetPadMode (GpioPad, PadMode);
1656 ASSERT_EFI_ERROR (Status);
1657 }
1658
1659 /**
1660 This function enables CNVi MODEM CLKREQ pin
1661 **/
1662 VOID
GpioEnableCnviModemClkReqPin(VOID)1663 GpioEnableCnviModemClkReqPin (
1664 VOID
1665 )
1666 {
1667 EFI_STATUS Status;
1668 GPIO_PAD GpioPad;
1669 GPIO_PAD_MODE PadMode;
1670
1671 if (IsPchLp ()) {
1672 GpioPad = GPIO_CNL_LP_GPP_H2;
1673 PadMode = GpioPadModeNative3;
1674 } else {
1675 GpioPad = GPIO_CNL_H_GPP_D6;
1676 PadMode = GpioPadModeNative3;
1677 }
1678
1679 Status = GpioSetPadMode (GpioPad, PadMode);
1680 ASSERT_EFI_ERROR (Status);
1681 }
1682
1683
1684 /**
1685 This function provides CNVi BT interface select pin
1686
1687 @retval GpioPad GPIO pad for CNVi BT interface select
1688 **/
1689 GPIO_PAD
GpioGetCnviBtIfSelectPin(VOID)1690 GpioGetCnviBtIfSelectPin (
1691 VOID
1692 )
1693 {
1694 if (IsPchLp ()) {
1695 return GPIO_CNL_LP_VGPIO5;
1696 } else {
1697 return GPIO_CNL_H_VGPIO7;
1698 }
1699 }
1700
1701 /**
1702 This function provides CNVi BT Charging pin
1703
1704 @retval GpioPad GPIO pad for CNVi BT Charging select
1705 **/
1706 GPIO_PAD
GpioGetCnviBtChargingPin(VOID)1707 GpioGetCnviBtChargingPin (
1708 VOID
1709 )
1710 {
1711 if (IsPchLp ()) {
1712 return GPIO_CNL_LP_VGPIO3;
1713 } else {
1714 return GPIO_CNL_H_VGPIO3;
1715 }
1716 }
1717
1718 /**
1719 This function provides CNVi A4WP pin
1720
1721 @param[out] GpioNativePad GPIO native pad for CNVi A4WP
1722 **/
1723 VOID
GpioGetCnviA4WpPin(OUT GPIO_PAD_NATIVE_FUNCTION * GpioNativePad)1724 GpioGetCnviA4WpPin (
1725 OUT GPIO_PAD_NATIVE_FUNCTION *GpioNativePad
1726 )
1727 {
1728 GpioNativePad->Mode = GpioPadModeNative1;
1729 if (IsPchLp ()) {
1730 GpioNativePad->Pad = GPIO_CNL_LP_GPP_F23;
1731 } else {
1732 GpioNativePad->Pad = GPIO_CNL_H_GPP_J11;
1733 }
1734 }
1735
1736 /**
1737 This function provides CNVi BT host wake int pin
1738
1739 @retval GpioPad GPIO pad BT host wake int
1740 **/
1741 GPIO_PAD
GpioGetCnviBtHostWakeIntPin(VOID)1742 GpioGetCnviBtHostWakeIntPin (
1743 VOID
1744 )
1745 {
1746 if (IsPchLp ()) {
1747 return GPIO_CNL_LP_VGPIO4;
1748 } else {
1749 return GPIO_CNL_H_VGPIO4;
1750 }
1751 }
1752
1753 //
1754 // CNVi Bluetooth UART pads
1755 //
1756 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD mPchLpVCnviBtUartGpioPad[PCH_GPIO_CNVI_UART_NUMBER_OF_PINS] =
1757 {
1758 GPIO_CNL_LP_VGPIO6, // vCNV_BT_UART_TXD
1759 GPIO_CNL_LP_VGPIO7, // vCNV_BT_UART_RXD
1760 GPIO_CNL_LP_VGPIO8, // vCNV_BT_UART_CTS_B
1761 GPIO_CNL_LP_VGPIO9 // vCNV_BT_UART_RTS_B
1762 };
1763
1764 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD mPchHVCnviBtUartGpioPad[PCH_GPIO_CNVI_UART_NUMBER_OF_PINS] =
1765 {
1766 GPIO_CNL_H_VGPIO8, // vCNV_BT_UART_TXD
1767 GPIO_CNL_H_VGPIO9, // vCNV_BT_UART_RXD
1768 GPIO_CNL_H_VGPIO10,// vCNV_BT_UART_CTS_B
1769 GPIO_CNL_H_VGPIO11 // vCNV_BT_UART_RTS_B
1770 };
1771
1772 //
1773 // vUART for Bluetooth
1774 //
1775 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD mPchLpVUartForCnviBtGpioPad[PCH_GPIO_CNVI_UART_NUMBER_OF_PINS] =
1776 {
1777 GPIO_CNL_LP_VGPIO18, // vUART0_TXD
1778 GPIO_CNL_LP_VGPIO19, // vUART0_RXD
1779 GPIO_CNL_LP_VGPIO20, // vUART0_CTS_B
1780 GPIO_CNL_LP_VGPIO21 // vUART0_RTS_B
1781 };
1782
1783 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD mPchHVUartForCnviBtGpioPad[PCH_GPIO_CNVI_UART_NUMBER_OF_PINS] =
1784 {
1785 GPIO_CNL_H_VGPIO20, // vUART0_TXD
1786 GPIO_CNL_H_VGPIO21, // vUART0_RXD
1787 GPIO_CNL_H_VGPIO22, // vUART0_CTS_B
1788 GPIO_CNL_H_VGPIO23 // vUART0_RTS_B
1789 };
1790
1791 /**
1792 This function provides CNVi BT UART pins
1793
1794 @param[in] ConnectionType CNVi BT UART connection type
1795 @param[out] VCnviBtUartPad Table with vCNV_BT_UARTx pads
1796 @param[out] VCnviBtUartPadMode vCNV_BT_UARTx pad mode
1797 @param[out] VUartForCnviBtPad Table with vUART0 pads
1798 @param[out] VUartForCnviBtPadMode vUART0 pad mode
1799 **/
1800 VOID
GpioGetCnviBtUartPins(IN VGPIO_CNVI_BT_UART_CONNECTION_TYPE ConnectionType,OUT GPIO_PAD ** VCnviBtUartPad,OUT GPIO_PAD_MODE * VCnviBtUartPadMode,OUT GPIO_PAD ** VUartForCnviBtPad,OUT GPIO_PAD_MODE * VUartForCnviBtPadMode)1801 GpioGetCnviBtUartPins (
1802 IN VGPIO_CNVI_BT_UART_CONNECTION_TYPE ConnectionType,
1803 OUT GPIO_PAD **VCnviBtUartPad,
1804 OUT GPIO_PAD_MODE *VCnviBtUartPadMode,
1805 OUT GPIO_PAD **VUartForCnviBtPad,
1806 OUT GPIO_PAD_MODE *VUartForCnviBtPadMode
1807 )
1808 {
1809 if (IsPchLp ()) {
1810 *VCnviBtUartPad = mPchLpVCnviBtUartGpioPad;
1811 *VUartForCnviBtPad = mPchLpVUartForCnviBtGpioPad;
1812 } else {
1813 *VCnviBtUartPad = mPchHVCnviBtUartGpioPad;
1814 *VUartForCnviBtPad = mPchHVUartForCnviBtGpioPad;
1815 }
1816
1817 switch (ConnectionType) {
1818 case GpioCnviBtUartToSerialIoUart0:
1819 *VCnviBtUartPadMode = GpioPadModeNative1;
1820 *VUartForCnviBtPadMode = GpioPadModeNative1;
1821 break;
1822 case GpioCnviBtUartToIshUart0:
1823 *VCnviBtUartPadMode = GpioPadModeNative2;
1824 *VUartForCnviBtPadMode = GpioPadModeNative1;
1825 break;
1826 case GpioCnviBtUartNotConnected:
1827 case GpioCnviBtUartToExternalPads:
1828 *VCnviBtUartPadMode = GpioPadModeGpio;
1829 *VUartForCnviBtPadMode = GpioPadModeGpio;
1830 break;
1831 default:
1832 ASSERT (FALSE);
1833 return;
1834 }
1835 }
1836
1837 //
1838 // CNVi Bluetooth UART external pads
1839 //
1840 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpCnviBtUartExternalPads[PCH_GPIO_CNVI_UART_NUMBER_OF_PINS] =
1841 {
1842 {GPIO_CNL_LP_GPP_C8, GpioPadModeNative2}, // CNV_BT_UART_0_RXD
1843 {GPIO_CNL_LP_GPP_C9, GpioPadModeNative2}, // CNV_BT_UART_0_TXD
1844 {GPIO_CNL_LP_GPP_C10, GpioPadModeNative2}, // CNV_BT_UART_0_RTS
1845 {GPIO_CNL_LP_GPP_C11, GpioPadModeNative2} // CNV_BT_UART_0_CTS
1846 };
1847
1848 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHCnviBtUartExternalPads[PCH_GPIO_CNVI_UART_NUMBER_OF_PINS] =
1849 {
1850 {GPIO_CNL_H_GPP_C8, GpioPadModeNative2}, // CNV_BT_UART_0_RXD
1851 {GPIO_CNL_H_GPP_C9, GpioPadModeNative2}, // CNV_BT_UART_0_TXD
1852 {GPIO_CNL_H_GPP_C10, GpioPadModeNative2}, // CNV_BT_UART_0_RTS
1853 {GPIO_CNL_H_GPP_C11, GpioPadModeNative2} // CNV_BT_UART_0_CTS
1854 };
1855
1856 /**
1857 This function provides CNVi BT UART external pads
1858
1859 @param[out] NativePinsTable Table with pins
1860 **/
1861 VOID
GpioGetCnviBtUartExternalPins(OUT GPIO_PAD_NATIVE_FUNCTION ** NativePinsTable)1862 GpioGetCnviBtUartExternalPins (
1863 OUT GPIO_PAD_NATIVE_FUNCTION **NativePinsTable
1864 )
1865 {
1866 if (IsPchLp ()) {
1867 *NativePinsTable = mPchLpCnviBtUartExternalPads;
1868 } else {
1869 *NativePinsTable = mPchHCnviBtUartExternalPads;
1870 }
1871 }
1872
1873 //
1874 // CNVi Bluetooth I2S pads
1875 //
1876 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD mPchLpVCnviBtI2sGpioPad[PCH_GPIO_CNVI_SSP_NUMBER_OF_PINS] =
1877 {
1878 GPIO_CNL_LP_VGPIO30, // vCNV_BT_I2S_BCLK
1879 GPIO_CNL_LP_VGPIO31, // vCNV_BT_I2S_WS_SYNC
1880 GPIO_CNL_LP_VGPIO32, // vCNV_BT_I2S_SDO
1881 GPIO_CNL_LP_VGPIO33 // vCNV_BT_I2S_SDI
1882 };
1883
1884 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD mPchHVCnviBtI2sGpioPad[PCH_GPIO_CNVI_SSP_NUMBER_OF_PINS] =
1885 {
1886 GPIO_CNL_H_VGPIO32, // vCNV_BT_I2S_BCLK
1887 GPIO_CNL_H_VGPIO33, // vCNV_BT_I2S_WS_SYNC
1888 GPIO_CNL_H_VGPIO34, // vCNV_BT_I2S_SDO
1889 GPIO_CNL_H_VGPIO35 // vCNV_BT_I2S_SDI
1890 };
1891
1892 //
1893 // vSSP for Bluetooth
1894 //
1895 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD mPchLpVSspForCnviBtGpioPad[PCH_GPIO_CNVI_SSP_NUMBER_OF_PINS] =
1896 {
1897 GPIO_CNL_LP_VGPIO34, // vSSP2_SCLK
1898 GPIO_CNL_LP_VGPIO35, // vSSP2_SFRM
1899 GPIO_CNL_LP_VGPIO36, // vSSP2_TXD
1900 GPIO_CNL_LP_VGPIO37 // vSSP2_RXD
1901 };
1902
1903 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD mPchHVSspForCnviBtGpioPad[PCH_GPIO_CNVI_SSP_NUMBER_OF_PINS] =
1904 {
1905 GPIO_CNL_H_VGPIO36, // vSSP2_SCLK
1906 GPIO_CNL_H_VGPIO37, // vSSP2_SFRM
1907 GPIO_CNL_H_VGPIO38, // vSSP2_TXD
1908 GPIO_CNL_H_VGPIO39 // vSSP2_RXD
1909 };
1910
1911 /**
1912 This function provides CNVi BT I2S pins
1913
1914 @param[in] ConnectionType CNVi BT I2S connection type
1915 @param[out] VCnviBtI2sPad Table with vCNV_BT_I2Sx pads
1916 @param[out] VCnviBtI2sPadMode vCNV_BT_I2Sx pad mode
1917 @param[out] VSspForCnviBtPad Table with vSSP2 pads
1918 @param[out] VSspForCnviBtPadMode vSSP2 pad mode
1919 **/
1920 VOID
GpioGetCnviBtI2sPins(IN VGPIO_CNVI_BT_I2S_CONNECTION_TYPE ConnectionType,OUT GPIO_PAD ** VCnviBtI2sPad,OUT GPIO_PAD_MODE * VCnviBtI2sPadMode,OUT GPIO_PAD ** VSspForCnviBtPad,OUT GPIO_PAD_MODE * VSspForCnviBtPadMode)1921 GpioGetCnviBtI2sPins (
1922 IN VGPIO_CNVI_BT_I2S_CONNECTION_TYPE ConnectionType,
1923 OUT GPIO_PAD **VCnviBtI2sPad,
1924 OUT GPIO_PAD_MODE *VCnviBtI2sPadMode,
1925 OUT GPIO_PAD **VSspForCnviBtPad,
1926 OUT GPIO_PAD_MODE *VSspForCnviBtPadMode
1927 )
1928 {
1929 if (IsPchLp ()) {
1930 *VCnviBtI2sPad = mPchLpVCnviBtI2sGpioPad;
1931 *VSspForCnviBtPad = mPchLpVSspForCnviBtGpioPad;
1932 } else {
1933 *VCnviBtI2sPad = mPchHVCnviBtI2sGpioPad;
1934 *VSspForCnviBtPad = mPchHVSspForCnviBtGpioPad;
1935 }
1936
1937 switch (ConnectionType) {
1938 case GpioCnviBtI2sToSsp0:
1939 *VCnviBtI2sPadMode = GpioPadModeNative1;
1940 *VSspForCnviBtPadMode = GpioPadModeNative1;
1941 break;
1942 case GpioCnviBtI2sToSsp1:
1943 *VCnviBtI2sPadMode = GpioPadModeNative2;
1944 *VSspForCnviBtPadMode = GpioPadModeNative1;
1945 break;
1946 case GpioCnviBtI2sToSsp2:
1947 *VCnviBtI2sPadMode = GpioPadModeNative3;
1948 *VSspForCnviBtPadMode = GpioPadModeNative1;
1949 break;
1950 case GpioCnviBtI2sNotConnected:
1951 case GpioCnviBtI2sToExternalPads:
1952 *VCnviBtI2sPadMode = GpioPadModeGpio;
1953 *VSspForCnviBtPadMode = GpioPadModeGpio;
1954 break;
1955 default:
1956 ASSERT (FALSE);
1957 return;
1958 }
1959 }
1960
1961 //
1962 // CNVi Bluetooth I2S external pads
1963 //
1964 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpCnviBtI2sExternalPads[PCH_GPIO_CNVI_SSP_NUMBER_OF_PINS] =
1965 {
1966 {GPIO_CNL_LP_GPP_H0, GpioPadModeNative2}, // CNV_BT_I2S_WS_SYNC
1967 {GPIO_CNL_LP_GPP_H1, GpioPadModeNative2}, // CNV_BT_I2S_BCLK
1968 {GPIO_CNL_LP_GPP_H2, GpioPadModeNative2}, // CNV_BT_I2S_SDI
1969 {GPIO_CNL_LP_GPP_H3, GpioPadModeNative2} // CNV_BT_I2S_SDO
1970 };
1971
1972 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHCnviBtI2sExternalPads[PCH_GPIO_CNVI_SSP_NUMBER_OF_PINS] =
1973 {
1974 {GPIO_CNL_H_GPP_D8, GpioPadModeNative2}, // CNV_BT_I2S_WS_SYNC
1975 {GPIO_CNL_H_GPP_D5, GpioPadModeNative2}, // CNV_BT_I2S_BCLK
1976 {GPIO_CNL_H_GPP_D6, GpioPadModeNative2}, // CNV_BT_I2S_SDI
1977 {GPIO_CNL_H_GPP_D7, GpioPadModeNative2} // CNV_BT_I2S_SDO
1978 };
1979
1980 /**
1981 This function provides CNVi BT I2S external pads
1982
1983 @param[out] NativePinsTable Table with pins
1984 **/
1985 VOID
GpioGetCnviBtI2sExternalPins(OUT GPIO_PAD_NATIVE_FUNCTION ** NativePinsTable)1986 GpioGetCnviBtI2sExternalPins (
1987 OUT GPIO_PAD_NATIVE_FUNCTION **NativePinsTable
1988 )
1989 {
1990 if (IsPchLp ()) {
1991 *NativePinsTable = mPchLpCnviBtI2sExternalPads;
1992 } else {
1993 *NativePinsTable = mPchHCnviBtI2sExternalPads;
1994 }
1995 }
1996
1997 //
1998 // CNVi MFUART1 pads
1999 //
2000 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD mPchLpVCnviMfUart1GpioPad[PCH_GPIO_CNVI_UART_NUMBER_OF_PINS] =
2001 {
2002 GPIO_CNL_LP_VGPIO10, // vCNV_MFUART1_TXD
2003 GPIO_CNL_LP_VGPIO11, // vCNV_MFUART1_RXD
2004 GPIO_CNL_LP_VGPIO12, // vCNV_MFUART1_CTS_B
2005 GPIO_CNL_LP_VGPIO13 // vCNV_MFUART1_RTS_B
2006 };
2007
2008 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD mPchHVCnviMfUart1GpioPad[PCH_GPIO_CNVI_UART_NUMBER_OF_PINS] =
2009 {
2010 GPIO_CNL_H_VGPIO12, // vCNV_MFUART1_TXD
2011 GPIO_CNL_H_VGPIO13, // vCNV_MFUART1_RXD
2012 GPIO_CNL_H_VGPIO14, // vCNV_MFUART1_CTS_B
2013 GPIO_CNL_H_VGPIO15 // vCNV_MFUART1_RTS_B
2014 };
2015
2016 //
2017 // vUART for MFUART1
2018 //
2019 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD mPchLpVUartForCnviMfUart1GpioPad[PCH_GPIO_CNVI_UART_NUMBER_OF_PINS] =
2020 {
2021 GPIO_CNL_LP_VGPIO22, // vISH_UART0_TXD
2022 GPIO_CNL_LP_VGPIO23, // vISH_UART0_RXD
2023 GPIO_CNL_LP_VGPIO24, // vISH_UART0_CTS_B
2024 GPIO_CNL_LP_VGPIO25 // vISH_UART0_RTS_B
2025 };
2026
2027 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD mPchHVUartForCnviMfUart1GpioPad[PCH_GPIO_CNVI_UART_NUMBER_OF_PINS] =
2028 {
2029 GPIO_CNL_H_VGPIO24, // vISH_UART0_TXD
2030 GPIO_CNL_H_VGPIO25, // vISH_UART0_RXD
2031 GPIO_CNL_H_VGPIO26, // vISH_UART0_CTS_B
2032 GPIO_CNL_H_VGPIO27 // vISH_UART0_RTS_B
2033 };
2034
2035 /**
2036 This function provides CNVi MFUART1 pins
2037
2038 @param[in] ConnectionType CNVi MFUART1 connection type
2039 @param[out] VCnviBtI2sPad Table with vCNV_MFUART1x pads
2040 @param[out] VCnviBtI2sPadMode vCNV_MFUART1x pad mode
2041 @param[out] VSspForCnviBtPad Table with vISH_UART0 pads
2042 @param[out] VSspForCnviBtPadMode vISH_UART0 pad mode
2043 **/
2044 VOID
GpioGetCnviMfUart1Pins(IN VGPIO_CNVI_MF_UART1_CONNECTION_TYPE ConnectionType,OUT GPIO_PAD ** VCnviMfUart1Pad,OUT GPIO_PAD_MODE * VCnviMfUart1PadMode,OUT GPIO_PAD ** VUartForCnviMfUart1Pad,OUT GPIO_PAD_MODE * VUartForCnviMfUart1PadMode)2045 GpioGetCnviMfUart1Pins (
2046 IN VGPIO_CNVI_MF_UART1_CONNECTION_TYPE ConnectionType,
2047 OUT GPIO_PAD **VCnviMfUart1Pad,
2048 OUT GPIO_PAD_MODE *VCnviMfUart1PadMode,
2049 OUT GPIO_PAD **VUartForCnviMfUart1Pad,
2050 OUT GPIO_PAD_MODE *VUartForCnviMfUart1PadMode
2051 )
2052 {
2053 if (IsPchLp ()) {
2054 *VCnviMfUart1Pad = mPchLpVCnviMfUart1GpioPad;
2055 *VUartForCnviMfUart1Pad = mPchLpVUartForCnviMfUart1GpioPad;
2056 } else {
2057 *VCnviMfUart1Pad = mPchHVCnviMfUart1GpioPad;
2058 *VUartForCnviMfUart1Pad = mPchHVUartForCnviMfUart1GpioPad;
2059 }
2060
2061 switch (ConnectionType) {
2062 case GpioCnviMfUart1ToSerialIoUart2:
2063 *VCnviMfUart1PadMode = GpioPadModeNative2;
2064 *VUartForCnviMfUart1PadMode = GpioPadModeNative1;
2065 break;
2066 case GpioCnviMfUart1ToIshUart0:
2067 *VCnviMfUart1PadMode = GpioPadModeNative1;
2068 *VUartForCnviMfUart1PadMode = GpioPadModeNative1;
2069 break;
2070 case GpioCnviMfUart1NotConnected:
2071 case GpioCnviMfUart1ToExternalPads:
2072 *VCnviMfUart1PadMode = GpioPadModeGpio;
2073 *VUartForCnviMfUart1PadMode = GpioPadModeGpio;
2074 break;
2075 default:
2076 ASSERT (FALSE);
2077 return;
2078 }
2079 }
2080
2081 //
2082 // CNVi MFUART1 external pads
2083 //
2084 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpCnviMfUart1ExternalPads[PCH_GPIO_CNVI_UART_NUMBER_OF_PINS] =
2085 {
2086 {GPIO_CNL_LP_GPP_C12, GpioPadModeNative3}, // CNV_MFUART1_RXD
2087 {GPIO_CNL_LP_GPP_C13, GpioPadModeNative3}, // CNV_MFUART1_TXD
2088 {GPIO_CNL_LP_GPP_C14, GpioPadModeNative3}, // CNV_MFUART1_RTS
2089 {GPIO_CNL_LP_GPP_C15, GpioPadModeNative3} // CNV_MFUART1_CTS
2090 };
2091
2092 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHCnviMfUart1ExternalPads[PCH_GPIO_CNVI_UART_NUMBER_OF_PINS] =
2093 {
2094 {GPIO_CNL_H_GPP_C12, GpioPadModeNative3}, // CNV_MFUART1_RXD
2095 {GPIO_CNL_H_GPP_C13, GpioPadModeNative3}, // CNV_MFUART1_TXD
2096 {GPIO_CNL_H_GPP_C14, GpioPadModeNative3}, // CNV_MFUART1_RTS
2097 {GPIO_CNL_H_GPP_C15, GpioPadModeNative3} // CNV_MFUART1_CTS
2098 };
2099
2100 /**
2101 This function provides CNVi MFUART1 external pads
2102
2103 @param[out] NativePinsTable Table with pins
2104 **/
2105 VOID
GpioGetCnviMfUart1ExternalPins(OUT GPIO_PAD_NATIVE_FUNCTION ** NativePinsTable)2106 GpioGetCnviMfUart1ExternalPins (
2107 OUT GPIO_PAD_NATIVE_FUNCTION **NativePinsTable
2108 )
2109 {
2110 if (IsPchLp ()) {
2111 *NativePinsTable = mPchLpCnviMfUart1ExternalPads;
2112 } else {
2113 *NativePinsTable = mPchHCnviMfUart1ExternalPads;
2114 }
2115 }
2116
2117 /**
2118 This function provides CNVi Bluetooth Enable pad
2119
2120 @retval GpioPad CNVi Bluetooth Enable pad
2121 **/
2122 GPIO_PAD
GpioGetCnviBtEnablePin(VOID)2123 GpioGetCnviBtEnablePin (
2124 VOID
2125 )
2126 {
2127 if (IsPchLp ()) {
2128 return GPIO_CNL_LP_VGPIO0;
2129 } else {
2130 return GPIO_CNL_H_VGPIO0;
2131 }
2132 }
2133
2134 //
2135 // CNVi BRI (Bluetooth Radio Interface) and RGI (Radio Generic Interface) buses from Pulsar to CRF (Companion RF)
2136 //
2137 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpCnviBriRgiGpioPad[PCH_GPIO_CNVI_BRI_RGI_NUMBER_OF_PINS] =
2138 {
2139 {GPIO_CNL_LP_GPP_F4, GpioPadModeNative1}, // CNV_BRI_DT
2140 {GPIO_CNL_LP_GPP_F5, GpioPadModeNative1}, // CNV_BRI_RSP
2141 {GPIO_CNL_LP_GPP_F6, GpioPadModeNative1}, // CNV_RGI_DT
2142 {GPIO_CNL_LP_GPP_F7, GpioPadModeNative1} // CNV_RGI_RSP
2143 };
2144
2145 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHCnviBriRgiGpioPad[PCH_GPIO_CNVI_BRI_RGI_NUMBER_OF_PINS] =
2146 {
2147 {GPIO_CNL_H_GPP_J4, GpioPadModeNative1}, // CNV_BRI_DT
2148 {GPIO_CNL_H_GPP_J5, GpioPadModeNative1}, // CNV_BRI_RSP
2149 {GPIO_CNL_H_GPP_J6, GpioPadModeNative1}, // CNV_RGI_DT
2150 {GPIO_CNL_H_GPP_J7, GpioPadModeNative1} // CNV_RGI_RSP
2151 };
2152
2153 /**
2154 This function provides CNVi BRI RGI GPIO pads
2155
2156 @param[out] NativePinsTable Table with pins
2157 **/
2158 VOID
GpioGetCnvBriRgiPins(OUT GPIO_PAD_NATIVE_FUNCTION ** NativePinsTable)2159 GpioGetCnvBriRgiPins (
2160 OUT GPIO_PAD_NATIVE_FUNCTION **NativePinsTable
2161 )
2162 {
2163 if (IsPchLp ()) {
2164 *NativePinsTable = mPchLpCnviBriRgiGpioPad;
2165 } else {
2166 *NativePinsTable = mPchHCnviBriRgiGpioPad;
2167 }
2168 }
2169
2170
2171 /**
2172 This function sets CNVi WiFi mode
2173
2174 @param[in] Value CNVi WiFi Mode value
2175 GpioCnviWiFiAuto: WiFi is automatically enabled/disabled by WiFi core
2176 GpioCnviWiFiEnabled: WiFi is enabled regardless of WiFi core decision
2177 @retval Status
2178 **/
2179 EFI_STATUS
GpioSetCnviWifiMode(IN VGPIO_CNVI_WIFI_MODE WiFiMode)2180 GpioSetCnviWifiMode (
2181 IN VGPIO_CNVI_WIFI_MODE WiFiMode
2182 )
2183 {
2184 EFI_STATUS Status;
2185 GPIO_PAD CnviWifiModePad;
2186 GPIO_CONFIG PadConfig;
2187
2188 ZeroMem (&PadConfig, sizeof (PadConfig));
2189
2190 PadConfig.PadMode = GpioPadModeGpio;
2191 PadConfig.Direction = GpioDirOut;
2192 if (WiFiMode == GpioCnviWiFiEnabled) {
2193 PadConfig.OutputState = GpioOutHigh;
2194 } else {
2195 PadConfig.OutputState = GpioOutLow;
2196 }
2197
2198 if (IsPchLp ()) {
2199 CnviWifiModePad = GPIO_CNL_LP_VGPIO2;
2200 } else {
2201 CnviWifiModePad = GPIO_CNL_H_VGPIO2;
2202 }
2203
2204 Status = GpioSetPadConfig (CnviWifiModePad, &PadConfig);
2205 ASSERT_EFI_ERROR (Status);
2206
2207 return EFI_SUCCESS;
2208 }
2209
2210 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchLpImguClkOutGpioPad[SA_GPIO_IMGUCLK_NUMBER_OF_PINS] =
2211 {
2212 {GPIO_CNL_LP_GPP_D4, GpioPadModeNative1}, // IMGCLKOUT_0
2213 {GPIO_CNL_LP_GPP_H20, GpioPadModeNative1}, // IMGCLKOUT_1
2214 };
2215
2216 GLOBAL_REMOVE_IF_UNREFERENCED GPIO_PAD_NATIVE_FUNCTION mPchHImguClkOutGpioPad[SA_GPIO_IMGUCLK_NUMBER_OF_PINS] =
2217 {
2218 {GPIO_CNL_H_GPP_K22, GpioPadModeNative1}, // IMGCLKOUT_0
2219 {GPIO_CNL_H_GPP_K23, GpioPadModeNative1}, // IMGCLKOUT_1
2220 };
2221
2222 /**
2223 This function provides IMGCLKOUT pins
2224
2225 @param[out] NativePinsTable Table with pins
2226 @param[out] NoOfNativePins Number of pins
2227 **/
2228 VOID
GpioGetImgClkOutPins(OUT GPIO_PAD_NATIVE_FUNCTION ** NativePinsTable,OUT UINT32 * NoOfNativePins)2229 GpioGetImgClkOutPins (
2230 OUT GPIO_PAD_NATIVE_FUNCTION **NativePinsTable,
2231 OUT UINT32 *NoOfNativePins
2232 )
2233 {
2234 if (IsPchLp ()) {
2235 *NativePinsTable = mPchLpImguClkOutGpioPad;
2236 *NoOfNativePins = ARRAY_SIZE (mPchLpImguClkOutGpioPad);
2237 } else {
2238 *NativePinsTable = mPchHImguClkOutGpioPad;
2239 *NoOfNativePins = ARRAY_SIZE (mPchHImguClkOutGpioPad);
2240 }
2241 }
2242
2243 /**
2244 This function provides PWRBTN pin
2245
2246 @retval GpioPad PWRTBTN pin
2247 **/
2248 GPIO_PAD
GpioGetPwrBtnPin(VOID)2249 GpioGetPwrBtnPin (
2250 VOID
2251 )
2252 {
2253 if (IsPchLp ()) {
2254 return GPIO_CNL_LP_GPD3;
2255 } else {
2256 return GPIO_CNL_H_GPD3;
2257 }
2258 }
2259
2260 /**
2261 This function provides LPC pin
2262
2263 @retval GpioPad LPC pin
2264 **/
2265 GPIO_PAD
GpioGetLpcPin(VOID)2266 GpioGetLpcPin (
2267 VOID
2268 )
2269 {
2270 if (PchGetLpcDid () == V_CNL_PCH_H_LPC_CFG_DEVICE_ID_A305_SKU) {
2271 return GPIO_CNL_H_GPP_A8;
2272 } else {
2273 return 0;
2274 }
2275 }
2276