]>
Commit | Line | Data |
---|---|---|
3d15d6c4 | 1 | /** @file |
2 | ||
3 | Copyright (c) 2011, ARM Ltd. All rights reserved.<BR> | |
4 | This program and the accompanying materials | |
5 | are licensed and made available under the terms and conditions of the BSD License | |
6 | which accompanies this distribution. The full text of the license may be found at | |
7 | http://opensource.org/licenses/bsd-license.php | |
8 | ||
9 | THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, | |
10 | WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. | |
11 | ||
12 | **/ | |
13 | ||
14 | #include "LcdGraphicsOutputDxe.h" | |
15 | ||
16 | BOOLEAN mDisplayInitialized = FALSE; | |
17 | ||
18 | LCD_MODE LcdModes[] = { | |
19 | { | |
20 | 0, 640, 480, | |
21 | 9, 4, | |
22 | 96, 16, 48, | |
23 | 2, 10, 33 | |
24 | }, | |
25 | { | |
26 | 1, 800, 600, | |
27 | 11, 2, | |
28 | 120, 56, 64, | |
29 | 5, 37, 22 | |
30 | }, | |
31 | { | |
32 | 2, 1024, 768, | |
33 | 6, 2, | |
34 | 96, 16, 48, | |
35 | 2, 10, 33 | |
36 | }, | |
37 | }; | |
38 | ||
39 | LCD_INSTANCE mLcdTemplate = { | |
40 | LCD_INSTANCE_SIGNATURE, | |
41 | NULL, // Handle | |
42 | { // ModeInfo | |
43 | 0, // Version | |
44 | 0, // HorizontalResolution | |
45 | 0, // VerticalResolution | |
46 | PixelBltOnly, // PixelFormat | |
47 | { | |
48 | 0xF800, //RedMask; | |
49 | 0x7E0, //GreenMask; | |
50 | 0x1F, //BlueMask; | |
51 | 0x0//ReservedMask | |
52 | }, // PixelInformation | |
53 | 0, // PixelsPerScanLine | |
54 | }, | |
55 | { // Mode | |
56 | 3, // MaxMode; | |
57 | 0, // Mode; | |
58 | NULL, // Info; | |
59 | 0, // SizeOfInfo; | |
60 | 0, // FrameBufferBase; | |
61 | 0 // FrameBufferSize; | |
62 | }, | |
63 | { // Gop | |
64 | LcdGraphicsQueryMode, // QueryMode | |
65 | LcdGraphicsSetMode, // SetMode | |
66 | LcdGraphicsBlt, // Blt | |
67 | NULL // *Mode | |
68 | }, | |
69 | { // DevicePath | |
70 | { | |
71 | { | |
72 | HARDWARE_DEVICE_PATH, HW_VENDOR_DP, | |
73 | (UINT8) (sizeof(VENDOR_DEVICE_PATH)), | |
74 | (UINT8) ((sizeof(VENDOR_DEVICE_PATH)) >> 8), | |
75 | }, | |
76 | // Hardware Device Path for Lcd | |
77 | EFI_CALLER_ID_GUID // Use the driver's GUID | |
78 | }, | |
79 | ||
80 | { | |
81 | END_DEVICE_PATH_TYPE, | |
82 | END_ENTIRE_DEVICE_PATH_SUBTYPE, | |
83 | sizeof(EFI_DEVICE_PATH_PROTOCOL), | |
84 | 0 | |
85 | } | |
86 | } | |
87 | }; | |
88 | ||
89 | EFI_STATUS | |
90 | LcdInstanceContructor ( | |
91 | OUT LCD_INSTANCE** NewInstance | |
92 | ) | |
93 | { | |
94 | LCD_INSTANCE* Instance; | |
95 | ||
96 | Instance = AllocateCopyPool (sizeof(LCD_INSTANCE), &mLcdTemplate); | |
97 | if (Instance == NULL) { | |
98 | return EFI_OUT_OF_RESOURCES; | |
99 | } | |
100 | ||
101 | Instance->Gop.Mode = &Instance->Mode; | |
102 | Instance->Mode.Info = &Instance->ModeInfo; | |
103 | ||
104 | *NewInstance = Instance; | |
105 | return EFI_SUCCESS; | |
106 | } | |
107 | ||
108 | EFI_STATUS | |
109 | LcdPlatformGetVram ( | |
110 | OUT EFI_PHYSICAL_ADDRESS* VramBaseAddress, | |
111 | OUT UINTN* VramSize | |
112 | ) | |
113 | { | |
114 | EFI_STATUS Status; | |
115 | EFI_CPU_ARCH_PROTOCOL *Cpu; | |
116 | UINTN MaxSize; | |
117 | ||
118 | MaxSize = 0x500000; | |
119 | *VramSize = MaxSize; | |
120 | ||
121 | // Allocate VRAM from DRAM | |
122 | Status = gBS->AllocatePages (AllocateAnyPages, EfiBootServicesData, EFI_SIZE_TO_PAGES((MaxSize)), VramBaseAddress); | |
123 | if (EFI_ERROR(Status)) { | |
124 | return Status; | |
125 | } | |
126 | ||
127 | // Ensure the Cpu architectural protocol is already installed | |
128 | Status = gBS->LocateProtocol (&gEfiCpuArchProtocolGuid, NULL, (VOID **)&Cpu); | |
129 | ASSERT_EFI_ERROR(Status); | |
130 | ||
131 | // Mark the VRAM as un-cacheable. The VRAM is inside the DRAM, which is cacheable. | |
132 | Status = Cpu->SetMemoryAttributes (Cpu, *VramBaseAddress, *VramSize, EFI_MEMORY_UC); | |
133 | if (EFI_ERROR(Status)) { | |
134 | gBS->FreePool (VramBaseAddress); | |
135 | return Status; | |
136 | } | |
137 | ||
138 | return EFI_SUCCESS; | |
139 | } | |
140 | ||
141 | EFI_STATUS | |
142 | DssSetMode ( | |
143 | UINT32 VramBaseAddress, | |
144 | UINTN ModeNumber | |
145 | ) | |
146 | { | |
147 | // Make sure the interface clock is running | |
148 | MmioWrite32 (CM_ICLKEN_DSS, EN_DSS); | |
149 | ||
150 | // Stop the functional clocks | |
151 | MmioAnd32 (CM_FCLKEN_DSS, ~(EN_DSS1 | EN_DSS2 | EN_TV)); | |
152 | ||
153 | // Program the DSS clock divisor | |
154 | MmioWrite32 (CM_CLKSEL_DSS, 0x1000 | (LcdModes[ModeNumber].DssDivisor)); | |
155 | ||
156 | // Start the functional clocks | |
157 | MmioOr32 (CM_FCLKEN_DSS, (EN_DSS1 | EN_DSS2 | EN_TV)); | |
158 | ||
159 | // Wait for DSS to stabilize | |
160 | gBS->Stall(1); | |
161 | ||
162 | // Reset the subsystem | |
163 | MmioWrite32(DSS_SYSCONFIG, DSS_SOFTRESET); | |
164 | while (!(MmioRead32 (DSS_SYSSTATUS) & DSS_RESETDONE)); | |
165 | ||
166 | // Configure LCD parameters | |
167 | MmioWrite32 (DISPC_SIZE_LCD, | |
168 | ((LcdModes[ModeNumber].HorizontalResolution - 1) | |
169 | | ((LcdModes[ModeNumber].VerticalResolution - 1) << 16)) | |
170 | ); | |
171 | MmioWrite32 (DISPC_TIMING_H, | |
172 | ( (LcdModes[ModeNumber].HSync - 1) | |
173 | | ((LcdModes[ModeNumber].HFrontPorch - 1) << 8) | |
174 | | ((LcdModes[ModeNumber].HBackPorch - 1) << 20)) | |
175 | ); | |
176 | MmioWrite32 (DISPC_TIMING_V, | |
177 | ( (LcdModes[ModeNumber].VSync - 1) | |
178 | | ((LcdModes[ModeNumber].VFrontPorch - 1) << 8) | |
179 | | ((LcdModes[ModeNumber].VBackPorch - 1) << 20)) | |
180 | ); | |
181 | ||
182 | // Set the framebuffer to only load frames (no gamma tables) | |
183 | MmioAnd32 (DISPC_CONFIG, CLEARLOADMODE); | |
184 | MmioOr32 (DISPC_CONFIG, LOAD_FRAME_ONLY); | |
185 | ||
186 | // Divisor for the pixel clock | |
187 | MmioWrite32(DISPC_DIVISOR, ((1 << 16) | LcdModes[ModeNumber].DispcDivisor) ); | |
188 | ||
189 | // Set up the graphics layer | |
190 | MmioWrite32 (DISPC_GFX_PRELD, 0x2D8); | |
191 | MmioWrite32 (DISPC_GFX_BA0, VramBaseAddress); | |
192 | MmioWrite32 (DISPC_GFX_SIZE, | |
193 | ((LcdModes[ModeNumber].HorizontalResolution - 1) | |
194 | | ((LcdModes[ModeNumber].VerticalResolution - 1) << 16)) | |
195 | ); | |
196 | ||
197 | MmioWrite32(DISPC_GFX_ATTR, (GFXENABLE | RGB16 | BURSTSIZE16)); | |
198 | ||
199 | // Start it all | |
200 | MmioOr32 (DISPC_CONTROL, (LCDENABLE | ACTIVEMATRIX | DATALINES24 | BYPASS_MODE | LCDENABLESIGNAL)); | |
201 | MmioOr32 (DISPC_CONTROL, GOLCD); | |
202 | ||
203 | return EFI_SUCCESS; | |
204 | } | |
205 | ||
206 | EFI_STATUS | |
207 | HwInitializeDisplay ( | |
208 | UINTN VramBaseAddress, | |
209 | UINTN VramSize | |
210 | ) | |
211 | { | |
212 | EFI_STATUS Status; | |
213 | UINT8 Data; | |
214 | EFI_TPL OldTpl; | |
215 | EMBEDDED_EXTERNAL_DEVICE *gTPS65950; | |
216 | ||
217 | // Enable power lines used by TFP410 | |
218 | Status = gBS->LocateProtocol (&gEmbeddedExternalDeviceProtocolGuid, NULL, (VOID **)&gTPS65950); | |
219 | ASSERT_EFI_ERROR (Status); | |
220 | ||
221 | OldTpl = gBS->RaiseTPL(TPL_NOTIFY); | |
222 | Data = VAUX_DEV_GRP_P1; | |
223 | Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VPLL2_DEV_GRP), 1, &Data); | |
224 | ASSERT_EFI_ERROR(Status); | |
225 | ||
226 | Data = VAUX_DEDICATED_18V; | |
227 | Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VPLL2_DEDICATED), 1, &Data); | |
228 | ASSERT_EFI_ERROR (Status); | |
229 | ||
230 | // Power up TFP410 (set GPIO2 on TPS - for BeagleBoard-xM) | |
231 | Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, GPIODATADIR1), 1, &Data); | |
232 | ASSERT_EFI_ERROR (Status); | |
233 | Data |= BIT2; | |
234 | Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, GPIODATADIR1), 1, &Data); | |
235 | ASSERT_EFI_ERROR (Status); | |
236 | ||
237 | Data = BIT2; | |
238 | Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, SETGPIODATAOUT1), 1, &Data); | |
239 | ASSERT_EFI_ERROR (Status); | |
240 | ||
241 | gBS->RestoreTPL(OldTpl); | |
242 | ||
243 | // Power up TFP410 (set GPIO 170 - for older BeagleBoards) | |
244 | MmioAnd32 (GPIO6_BASE + GPIO_OE, ~BIT10); | |
245 | MmioOr32 (GPIO6_BASE + GPIO_SETDATAOUT, BIT10); | |
246 | ||
247 | return EFI_SUCCESS; | |
248 | } | |
249 | ||
250 | EFI_STATUS | |
251 | InitializeDisplay ( | |
252 | IN LCD_INSTANCE* Instance | |
253 | ) | |
254 | { | |
255 | EFI_STATUS Status; | |
256 | UINTN VramSize; | |
257 | EFI_PHYSICAL_ADDRESS VramBaseAddress; | |
258 | ||
259 | Status = LcdPlatformGetVram (&VramBaseAddress, &VramSize); | |
260 | if (EFI_ERROR (Status)) { | |
261 | return Status; | |
262 | } | |
263 | ||
264 | Instance->Mode.FrameBufferBase = VramBaseAddress; | |
265 | Instance->Mode.FrameBufferSize = VramSize; | |
266 | ||
267 | Status = HwInitializeDisplay((UINTN)VramBaseAddress, VramSize); | |
268 | if (!EFI_ERROR (Status)) { | |
269 | mDisplayInitialized = TRUE; | |
270 | } | |
271 | ||
272 | return Status; | |
273 | } | |
274 | ||
275 | EFI_STATUS | |
276 | EFIAPI | |
277 | LcdGraphicsQueryMode ( | |
278 | IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This, | |
279 | IN UINT32 ModeNumber, | |
280 | OUT UINTN *SizeOfInfo, | |
281 | OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION **Info | |
282 | ) | |
283 | { | |
284 | LCD_INSTANCE *Instance; | |
285 | ||
286 | Instance = LCD_INSTANCE_FROM_GOP_THIS(This); | |
287 | ||
288 | if (!mDisplayInitialized) { | |
289 | InitializeDisplay (Instance); | |
290 | } | |
291 | ||
292 | // Error checking | |
293 | if ( (This == NULL) || (Info == NULL) || (SizeOfInfo == NULL) || (ModeNumber >= This->Mode->MaxMode) ) { | |
294 | DEBUG((DEBUG_ERROR, "LcdGraphicsQueryMode: ERROR - For mode number %d : Invalid Parameter.\n", ModeNumber )); | |
295 | return EFI_INVALID_PARAMETER; | |
296 | } | |
297 | ||
298 | *Info = AllocateCopyPool(sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION), &Instance->ModeInfo); | |
299 | if (*Info == NULL) { | |
300 | return EFI_OUT_OF_RESOURCES; | |
301 | } | |
302 | ||
303 | *SizeOfInfo = sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION); | |
304 | ||
305 | (*Info)->Version = 0; | |
306 | (*Info)->HorizontalResolution = LcdModes[ModeNumber].HorizontalResolution; | |
307 | (*Info)->VerticalResolution = LcdModes[ModeNumber].VerticalResolution; | |
308 | (*Info)->PixelFormat = PixelBltOnly; | |
309 | ||
310 | return EFI_SUCCESS; | |
311 | } | |
312 | ||
313 | EFI_STATUS | |
314 | EFIAPI | |
315 | LcdGraphicsSetMode ( | |
316 | IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This, | |
317 | IN UINT32 ModeNumber | |
318 | ) | |
319 | { | |
320 | LCD_INSTANCE *Instance; | |
321 | ||
322 | Instance = LCD_INSTANCE_FROM_GOP_THIS(This); | |
323 | ||
324 | if (ModeNumber >= Instance->Mode.MaxMode) { | |
325 | return EFI_UNSUPPORTED; | |
326 | } | |
327 | ||
328 | if (!mDisplayInitialized) { | |
329 | InitializeDisplay (Instance); | |
330 | } | |
331 | ||
332 | DssSetMode((UINT32)Instance->Mode.FrameBufferBase, ModeNumber); | |
333 | ||
334 | Instance->Mode.Mode = ModeNumber; | |
335 | Instance->ModeInfo.HorizontalResolution = LcdModes[ModeNumber].HorizontalResolution; | |
336 | Instance->ModeInfo.VerticalResolution = LcdModes[ModeNumber].VerticalResolution; | |
337 | ||
338 | return EFI_SUCCESS; | |
339 | } | |
340 | ||
341 | EFI_STATUS | |
342 | EFIAPI | |
343 | LcdGraphicsOutputDxeInitialize ( | |
344 | IN EFI_HANDLE ImageHandle, | |
345 | IN EFI_SYSTEM_TABLE *SystemTable | |
346 | ) | |
347 | { | |
348 | EFI_STATUS Status = EFI_SUCCESS; | |
349 | LCD_INSTANCE* Instance; | |
350 | ||
351 | Status = LcdInstanceContructor (&Instance); | |
352 | if (EFI_ERROR(Status)) { | |
353 | goto EXIT; | |
354 | } | |
355 | ||
356 | // Install the Graphics Output Protocol and the Device Path | |
357 | Status = gBS->InstallMultipleProtocolInterfaces( | |
358 | &Instance->Handle, | |
359 | &gEfiGraphicsOutputProtocolGuid, &Instance->Gop, | |
360 | &gEfiDevicePathProtocolGuid, &Instance->DevicePath, | |
361 | NULL | |
362 | ); | |
363 | ||
364 | if (EFI_ERROR(Status)) { | |
365 | DEBUG((DEBUG_ERROR, "GraphicsOutputDxeInitialize: Can not install the protocol. Exit Status=%r\n", Status)); | |
366 | goto EXIT; | |
367 | } | |
368 | ||
369 | // Register for an ExitBootServicesEvent | |
370 | // When ExitBootServices starts, this function here will make sure that the graphics driver will shut down properly, | |
371 | // i.e. it will free up all allocated memory and perform any necessary hardware re-configuration. | |
372 | /*Status = gBS->CreateEvent ( | |
373 | EVT_SIGNAL_EXIT_BOOT_SERVICES, | |
374 | TPL_NOTIFY, | |
375 | LcdGraphicsExitBootServicesEvent, NULL, | |
376 | &Instance->ExitBootServicesEvent | |
377 | ); | |
378 | ||
379 | if (EFI_ERROR(Status)) { | |
380 | DEBUG((DEBUG_ERROR, "GraphicsOutputDxeInitialize: Can not install the ExitBootServicesEvent handler. Exit Status=%r\n", Status)); | |
381 | goto EXIT_ERROR_UNINSTALL_PROTOCOL; | |
382 | }*/ | |
383 | ||
384 | // To get here, everything must be fine, so just exit | |
385 | goto EXIT; | |
386 | ||
387 | //EXIT_ERROR_UNINSTALL_PROTOCOL: | |
388 | /* The following function could return an error message, | |
389 | * however, to get here something must have gone wrong already, | |
390 | * so preserve the original error, i.e. don't change | |
391 | * the Status variable, even it fails to uninstall the protocol. | |
392 | */ | |
393 | /* gBS->UninstallMultipleProtocolInterfaces ( | |
394 | Instance->Handle, | |
395 | &gEfiGraphicsOutputProtocolGuid, &Instance->Gop, // Uninstall Graphics Output protocol | |
396 | &gEfiDevicePathProtocolGuid, &Instance->DevicePath, // Uninstall device path | |
397 | NULL | |
398 | );*/ | |
399 | ||
400 | EXIT: | |
401 | return Status; | |
402 | ||
403 | } |