modify the corresponding file path about Ps2MouseAbsolutePointerDxe driver & rename...
[mirror_edk2.git] / OptionRomPkg / CirrusLogic5430Dxe / CirrusLogic5430.c
1 /** @file
2 Cirrus Logic 5430 Controller Driver.
3 This driver is a sample implementation of the UGA Draw and Graphics Output
4 Protocols for the Cirrus Logic 5430 family of PCI video controllers.
5 This driver is only usable in the EFI pre-boot environment.
6 This sample is intended to show how the UGA Draw and Graphics output Protocol
7 is able to function.
8 The UGA I/O Protocol is not implemented in this sample.
9 A fully compliant EFI UGA driver requires both
10 the UGA Draw and the UGA I/O Protocol. Please refer to Microsoft's
11 documentation on UGA for details on how to write a UGA driver that is able
12 to function both in the EFI pre-boot environment and from the OS runtime.
13
14 Copyright (c) 2006, Intel Corporation
15 All rights reserved. This program and the accompanying materials
16 are licensed and made available under the terms and conditions of the BSD License
17 which accompanies this distribution. The full text of the license may be found at
18 http://opensource.org/licenses/bsd-license.php
19
20 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
21 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
22
23 **/
24
25 //
26 // Cirrus Logic 5430 Controller Driver
27 //
28 #include "CirrusLogic5430.h"
29
30 EFI_DRIVER_BINDING_PROTOCOL gCirrusLogic5430DriverBinding = {
31 CirrusLogic5430ControllerDriverSupported,
32 CirrusLogic5430ControllerDriverStart,
33 CirrusLogic5430ControllerDriverStop,
34 0x10,
35 NULL,
36 NULL
37 };
38
39 ///
40 /// Generic Attribute Controller Register Settings
41 ///
42 UINT8 AttributeController[21] = {
43 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
44 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
45 0x41, 0x00, 0x0F, 0x00, 0x00
46 };
47
48 ///
49 /// Generic Graphics Controller Register Settings
50 ///
51 UINT8 GraphicsController[9] = {
52 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, 0xFF
53 };
54
55 //
56 // 640 x 480 x 256 color @ 60 Hertz
57 //
58 UINT8 Crtc_640_480_256_60[28] = {
59 0x5d, 0x4f, 0x50, 0x82, 0x53, 0x9f, 0x00, 0x3e,
60 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
61 0xe1, 0x83, 0xdf, 0x50, 0x00, 0xe7, 0x04, 0xe3,
62 0xff, 0x00, 0x00, 0x22
63 };
64
65 UINT16 Seq_640_480_256_60[15] = {
66 0x0100, 0x0101, 0x0f02, 0x0003, 0x0e04, 0x1107, 0x0008, 0x4a0b,
67 0x5b0c, 0x450d, 0x7e0e, 0x2b1b, 0x2f1c, 0x301d, 0x331e
68 };
69
70 //
71 // 800 x 600 x 256 color @ 60 Hertz
72 //
73 UINT8 Crtc_800_600_256_60[28] = {
74 0x7F, 0x63, 0x64, 0x80, 0x6B, 0x1B, 0x72, 0xF0,
75 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
76 0x58, 0x8C, 0x57, 0x64, 0x00, 0x5F, 0x91, 0xE3,
77 0xFF, 0x00, 0x00, 0x22
78 };
79
80 UINT16 Seq_800_600_256_60[15] = {
81 0x0100, 0x0101, 0x0f02, 0x0003, 0x0e04, 0x1107, 0x0008, 0x4a0b,
82 0x5b0c, 0x450d, 0x510e, 0x2b1b, 0x2f1c, 0x301d, 0x3a1e
83 };
84
85 //
86 // 1024 x 768 x 256 color @ 60 Hertz
87 //
88 UINT8 Crtc_1024_768_256_60[28] = {
89 0xA3, 0x7F, 0x80, 0x86, 0x85, 0x96, 0x24, 0xFD,
90 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
91 0x02, 0x88, 0xFF, 0x80, 0x00, 0x00, 0x24, 0xE3,
92 0xFF, 0x4A, 0x00, 0x22
93 };
94
95 UINT16 Seq_1024_768_256_60[15] = {
96 0x0100, 0x0101, 0x0f02, 0x0003, 0x0e04, 0x1107, 0x0008, 0x4a0b,
97 0x5b0c, 0x450d, 0x760e, 0x2b1b, 0x2f1c, 0x301d, 0x341e
98 };
99
100 ///
101 /// Table of supported video modes
102 ///
103 CIRRUS_LOGIC_5430_VIDEO_MODES CirrusLogic5430VideoModes[] = {
104 { 640, 480, 8, 60, Crtc_640_480_256_60, Seq_640_480_256_60, 0xe3 },
105 { 800, 600, 8, 60, Crtc_800_600_256_60, Seq_800_600_256_60, 0xef },
106 { 1024, 768, 8, 60, Crtc_1024_768_256_60, Seq_1024_768_256_60, 0xef }
107 };
108
109 /**
110 CirrusLogic5430ControllerDriverSupported
111
112 TODO: This - add argument and description to function comment
113 TODO: Controller - add argument and description to function comment
114 TODO: RemainingDevicePath - add argument and description to function comment
115 **/
116 EFI_STATUS
117 EFIAPI
118 CirrusLogic5430ControllerDriverSupported (
119 IN EFI_DRIVER_BINDING_PROTOCOL *This,
120 IN EFI_HANDLE Controller,
121 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
122 )
123 {
124 EFI_STATUS Status;
125 EFI_PCI_IO_PROTOCOL *PciIo;
126 PCI_TYPE00 Pci;
127
128 //
129 // Open the PCI I/O Protocol
130 //
131 Status = gBS->OpenProtocol (
132 Controller,
133 &gEfiPciIoProtocolGuid,
134 (VOID **) &PciIo,
135 This->DriverBindingHandle,
136 Controller,
137 EFI_OPEN_PROTOCOL_BY_DRIVER
138 );
139 if (EFI_ERROR (Status)) {
140 return Status;
141 }
142
143 //
144 // Read the PCI Configuration Header from the PCI Device
145 //
146 Status = PciIo->Pci.Read (
147 PciIo,
148 EfiPciIoWidthUint32,
149 0,
150 sizeof (Pci) / sizeof (UINT32),
151 &Pci
152 );
153 if (EFI_ERROR (Status)) {
154 goto Done;
155 }
156
157 Status = EFI_UNSUPPORTED;
158 //
159 // See if the I/O enable is on. Most systems only allow one VGA device to be turned on
160 // at a time, so see if this is one that is turned on.
161 //
162 // if (((Pci.Hdr.Command & 0x01) == 0x01)) {
163 //
164 // See if this is a Cirrus Logic PCI controller
165 //
166 if (Pci.Hdr.VendorId == CIRRUS_LOGIC_VENDOR_ID) {
167 //
168 // See if this is a 5430 or a 5446 PCI controller
169 //
170 if (Pci.Hdr.DeviceId == CIRRUS_LOGIC_5430_DEVICE_ID) {
171 Status = EFI_SUCCESS;
172 }
173
174 if (Pci.Hdr.DeviceId == CIRRUS_LOGIC_5430_ALTERNATE_DEVICE_ID) {
175 Status = EFI_SUCCESS;
176 }
177
178 if (Pci.Hdr.DeviceId == CIRRUS_LOGIC_5446_DEVICE_ID) {
179 Status = EFI_SUCCESS;
180 }
181 }
182
183 Done:
184 //
185 // Close the PCI I/O Protocol
186 //
187 gBS->CloseProtocol (
188 Controller,
189 &gEfiPciIoProtocolGuid,
190 This->DriverBindingHandle,
191 Controller
192 );
193
194 return Status;
195 }
196
197 /**
198 CirrusLogic5430ControllerDriverStart
199
200 TODO: This - add argument and description to function comment
201 TODO: Controller - add argument and description to function comment
202 TODO: RemainingDevicePath - add argument and description to function comment
203 **/
204 EFI_STATUS
205 EFIAPI
206 CirrusLogic5430ControllerDriverStart (
207 IN EFI_DRIVER_BINDING_PROTOCOL *This,
208 IN EFI_HANDLE Controller,
209 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
210 )
211 {
212 EFI_STATUS Status;
213 CIRRUS_LOGIC_5430_PRIVATE_DATA *Private;
214
215 //
216 // Allocate Private context data for UGA Draw inteface.
217 //
218 Private = AllocateZeroPool (sizeof (CIRRUS_LOGIC_5430_PRIVATE_DATA));
219 if (Private == NULL) {
220 Status = EFI_OUT_OF_RESOURCES;
221 goto Error;
222 }
223
224 //
225 // Set up context record
226 //
227 Private->Signature = CIRRUS_LOGIC_5430_PRIVATE_DATA_SIGNATURE;
228 Private->Handle = Controller;
229
230 //
231 // Open PCI I/O Protocol
232 //
233 Status = gBS->OpenProtocol (
234 Private->Handle,
235 &gEfiPciIoProtocolGuid,
236 (VOID **) &Private->PciIo,
237 This->DriverBindingHandle,
238 Private->Handle,
239 EFI_OPEN_PROTOCOL_BY_DRIVER
240 );
241 if (EFI_ERROR (Status)) {
242 goto Error;
243 }
244
245 //
246 // Save original PCI attributes
247 //
248 Status = Private->PciIo->Attributes (
249 Private->PciIo,
250 EfiPciIoAttributeOperationGet,
251 0,
252 &Private->OriginalPciAttributes
253 );
254
255 if (EFI_ERROR (Status)) {
256 goto Error;
257 }
258
259 Status = Private->PciIo->Attributes (
260 Private->PciIo,
261 EfiPciIoAttributeOperationEnable,
262 EFI_PCI_DEVICE_ENABLE | EFI_PCI_IO_ATTRIBUTE_VGA_MEMORY | EFI_PCI_IO_ATTRIBUTE_VGA_IO,
263 NULL
264 );
265 if (EFI_ERROR (Status)) {
266 goto Error;
267 }
268
269 if (FeaturePcdGet (PcdSupportUga)) {
270 //
271 // Start the UGA Draw software stack.
272 //
273 Status = CirrusLogic5430UgaDrawConstructor (Private);
274 ASSERT_EFI_ERROR (Status);
275 if (FeaturePcdGet (PcdSupportGop)) {
276 Status = CirrusLogic5430GraphicsOutputConstructor (Private);
277 ASSERT_EFI_ERROR (Status);
278
279 Status = gBS->InstallMultipleProtocolInterfaces (
280 &Private->Handle,
281 &gEfiUgaDrawProtocolGuid,
282 &Private->UgaDraw,
283 &gEfiGraphicsOutputProtocolGuid,
284 &Private->GraphicsOutput,
285 NULL
286 );
287 } else {
288 Status = gBS->InstallMultipleProtocolInterfaces (
289 &Private->Handle,
290 &gEfiUgaDrawProtocolGuid,
291 &Private->UgaDraw,
292 NULL
293 );
294
295 }
296 } else {
297 if (FeaturePcdGet (PcdSupportGop)) {
298 Status = CirrusLogic5430GraphicsOutputConstructor (Private);
299 ASSERT_EFI_ERROR (Status);
300
301 Status = gBS->InstallMultipleProtocolInterfaces (
302 &Private->Handle,
303 &gEfiGraphicsOutputProtocolGuid,
304 &Private->GraphicsOutput,
305 NULL
306 );
307
308 } else {
309 //
310 // This driver must support eithor GOP or UGA or both.
311 //
312 ASSERT (FALSE);
313 Status = EFI_UNSUPPORTED;
314 }
315 }
316
317
318 Error:
319 if (EFI_ERROR (Status)) {
320 if (Private) {
321 if (Private->PciIo) {
322 //
323 // Restore original PCI attributes
324 //
325 Private->PciIo->Attributes (
326 Private->PciIo,
327 EfiPciIoAttributeOperationSet,
328 Private->OriginalPciAttributes,
329 NULL
330 );
331
332 //
333 // Close the PCI I/O Protocol
334 //
335 gBS->CloseProtocol (
336 Private->Handle,
337 &gEfiPciIoProtocolGuid,
338 This->DriverBindingHandle,
339 Private->Handle
340 );
341 }
342
343 gBS->FreePool (Private);
344 }
345 }
346
347 return Status;
348 }
349
350 /**
351 CirrusLogic5430ControllerDriverStop
352
353 TODO: This - add argument and description to function comment
354 TODO: Controller - add argument and description to function comment
355 TODO: NumberOfChildren - add argument and description to function comment
356 TODO: ChildHandleBuffer - add argument and description to function comment
357 TODO: EFI_SUCCESS - add return value to function comment
358 **/
359 EFI_STATUS
360 EFIAPI
361 CirrusLogic5430ControllerDriverStop (
362 IN EFI_DRIVER_BINDING_PROTOCOL *This,
363 IN EFI_HANDLE Controller,
364 IN UINTN NumberOfChildren,
365 IN EFI_HANDLE *ChildHandleBuffer
366 )
367 {
368 EFI_UGA_DRAW_PROTOCOL *UgaDraw;
369 EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
370
371 EFI_STATUS Status;
372 CIRRUS_LOGIC_5430_PRIVATE_DATA *Private;
373
374 if (FeaturePcdGet (PcdSupportUga)) {
375 Status = gBS->OpenProtocol (
376 Controller,
377 &gEfiUgaDrawProtocolGuid,
378 (VOID **) &UgaDraw,
379 This->DriverBindingHandle,
380 Controller,
381 EFI_OPEN_PROTOCOL_GET_PROTOCOL
382 );
383 if (EFI_ERROR (Status)) {
384 return Status;
385 }
386 //
387 // Get our private context information
388 //
389 Private = CIRRUS_LOGIC_5430_PRIVATE_DATA_FROM_UGA_DRAW_THIS (UgaDraw);
390 CirrusLogic5430UgaDrawDestructor (Private);
391
392 if (FeaturePcdGet (PcdSupportGop)) {
393 CirrusLogic5430GraphicsOutputDestructor (Private);
394 //
395 // Remove the UGA and GOP protocol interface from the system
396 //
397 Status = gBS->UninstallMultipleProtocolInterfaces (
398 Private->Handle,
399 &gEfiUgaDrawProtocolGuid,
400 &Private->UgaDraw,
401 &gEfiGraphicsOutputProtocolGuid,
402 &Private->GraphicsOutput,
403 NULL
404 );
405 } else {
406 //
407 // Remove the UGA Draw interface from the system
408 //
409 Status = gBS->UninstallMultipleProtocolInterfaces (
410 Private->Handle,
411 &gEfiUgaDrawProtocolGuid,
412 &Private->UgaDraw,
413 NULL
414 );
415 }
416 } else {
417 Status = gBS->OpenProtocol (
418 Controller,
419 &gEfiGraphicsOutputProtocolGuid,
420 (VOID **) &GraphicsOutput,
421 This->DriverBindingHandle,
422 Controller,
423 EFI_OPEN_PROTOCOL_GET_PROTOCOL
424 );
425 if (EFI_ERROR (Status)) {
426 return Status;
427 }
428
429 //
430 // Get our private context information
431 //
432 Private = CIRRUS_LOGIC_5430_PRIVATE_DATA_FROM_GRAPHICS_OUTPUT_THIS (GraphicsOutput);
433
434 CirrusLogic5430GraphicsOutputDestructor (Private);
435 //
436 // Remove the GOP protocol interface from the system
437 //
438 Status = gBS->UninstallMultipleProtocolInterfaces (
439 Private->Handle,
440 &gEfiUgaDrawProtocolGuid,
441 &Private->UgaDraw,
442 &gEfiGraphicsOutputProtocolGuid,
443 &Private->GraphicsOutput,
444 NULL
445 );
446 }
447
448 if (EFI_ERROR (Status)) {
449 return Status;
450 }
451
452 //
453 // Restore original PCI attributes
454 //
455 Private->PciIo->Attributes (
456 Private->PciIo,
457 EfiPciIoAttributeOperationSet,
458 Private->OriginalPciAttributes,
459 NULL
460 );
461
462 //
463 // Close the PCI I/O Protocol
464 //
465 gBS->CloseProtocol (
466 Controller,
467 &gEfiPciIoProtocolGuid,
468 This->DriverBindingHandle,
469 Controller
470 );
471
472 //
473 // Free our instance data
474 //
475 gBS->FreePool (Private);
476
477 return EFI_SUCCESS;
478 }
479
480 /**
481 CirrusLogic5430UgaDrawDestructor
482
483 TODO: Private - add argument and description to function comment
484 TODO: EFI_SUCCESS - add return value to function comment
485 **/
486 EFI_STATUS
487 CirrusLogic5430UgaDrawDestructor (
488 CIRRUS_LOGIC_5430_PRIVATE_DATA *Private
489 )
490 {
491 return EFI_SUCCESS;
492 }
493
494 /**
495 TODO: Add function description
496
497 @param Private TODO: add argument description
498 @param Address TODO: add argument description
499 @param Data TODO: add argument description
500
501 TODO: add return values
502
503 **/
504 VOID
505 outb (
506 CIRRUS_LOGIC_5430_PRIVATE_DATA *Private,
507 UINTN Address,
508 UINT8 Data
509 )
510 {
511 Private->PciIo->Io.Write (
512 Private->PciIo,
513 EfiPciIoWidthUint8,
514 EFI_PCI_IO_PASS_THROUGH_BAR,
515 Address,
516 1,
517 &Data
518 );
519 }
520
521 /**
522 TODO: Add function description
523
524 @param Private TODO: add argument description
525 @param Address TODO: add argument description
526 @param Data TODO: add argument description
527
528 TODO: add return values
529
530 **/
531 VOID
532 outw (
533 CIRRUS_LOGIC_5430_PRIVATE_DATA *Private,
534 UINTN Address,
535 UINT16 Data
536 )
537 {
538 Private->PciIo->Io.Write (
539 Private->PciIo,
540 EfiPciIoWidthUint16,
541 EFI_PCI_IO_PASS_THROUGH_BAR,
542 Address,
543 1,
544 &Data
545 );
546 }
547
548 /**
549 TODO: Add function description
550
551 @param Private TODO: add argument description
552 @param Address TODO: add argument description
553
554 TODO: add return values
555
556 **/
557 UINT8
558 inb (
559 CIRRUS_LOGIC_5430_PRIVATE_DATA *Private,
560 UINTN Address
561 )
562 {
563 UINT8 Data;
564
565 Private->PciIo->Io.Read (
566 Private->PciIo,
567 EfiPciIoWidthUint8,
568 EFI_PCI_IO_PASS_THROUGH_BAR,
569 Address,
570 1,
571 &Data
572 );
573 return Data;
574 }
575
576 /**
577 TODO: Add function description
578
579 @param Private TODO: add argument description
580 @param Address TODO: add argument description
581
582 TODO: add return values
583
584 **/
585 UINT16
586 inw (
587 CIRRUS_LOGIC_5430_PRIVATE_DATA *Private,
588 UINTN Address
589 )
590 {
591 UINT16 Data;
592
593 Private->PciIo->Io.Read (
594 Private->PciIo,
595 EfiPciIoWidthUint16,
596 EFI_PCI_IO_PASS_THROUGH_BAR,
597 Address,
598 1,
599 &Data
600 );
601 return Data;
602 }
603
604 /**
605 TODO: Add function description
606
607 @param Private TODO: add argument description
608 @param Index TODO: add argument description
609 @param Red TODO: add argument description
610 @param Green TODO: add argument description
611 @param Blue TODO: add argument description
612
613 TODO: add return values
614
615 **/
616 VOID
617 SetPaletteColor (
618 CIRRUS_LOGIC_5430_PRIVATE_DATA *Private,
619 UINTN Index,
620 UINT8 Red,
621 UINT8 Green,
622 UINT8 Blue
623 )
624 {
625 outb (Private, PALETTE_INDEX_REGISTER, (UINT8) Index);
626 outb (Private, PALETTE_DATA_REGISTER, (UINT8) (Red >> 2));
627 outb (Private, PALETTE_DATA_REGISTER, (UINT8) (Green >> 2));
628 outb (Private, PALETTE_DATA_REGISTER, (UINT8) (Blue >> 2));
629 }
630
631 /**
632 TODO: Add function description
633
634 @param Private TODO: add argument description
635
636 TODO: add return values
637
638 **/
639 VOID
640 SetDefaultPalette (
641 CIRRUS_LOGIC_5430_PRIVATE_DATA *Private
642 )
643 {
644 UINTN Index;
645 UINTN RedIndex;
646 UINTN GreenIndex;
647 UINTN BlueIndex;
648
649 Index = 0;
650 for (RedIndex = 0; RedIndex < 8; RedIndex++) {
651 for (GreenIndex = 0; GreenIndex < 8; GreenIndex++) {
652 for (BlueIndex = 0; BlueIndex < 4; BlueIndex++) {
653 SetPaletteColor (Private, Index, (UINT8) (RedIndex << 5), (UINT8) (GreenIndex << 5), (UINT8) (BlueIndex << 6));
654 Index++;
655 }
656 }
657 }
658 }
659
660 /**
661 TODO: Add function description
662
663 @param Private TODO: add argument description
664
665 TODO: add return values
666
667 **/
668 STATIC
669 VOID
670 ClearScreen (
671 CIRRUS_LOGIC_5430_PRIVATE_DATA *Private
672 )
673 {
674 UINT32 Color;
675
676 Color = 0;
677 Private->PciIo->Mem.Write (
678 Private->PciIo,
679 EfiPciIoWidthFillUint32,
680 0,
681 0,
682 0x100000 >> 2,
683 &Color
684 );
685 }
686
687 /**
688 TODO: Add function description
689
690 @param Private TODO: add argument description
691
692 TODO: add return values
693
694 **/
695 VOID
696 DrawLogo (
697 CIRRUS_LOGIC_5430_PRIVATE_DATA *Private,
698 UINTN ScreenWidth,
699 UINTN ScreenHeight
700 )
701 {
702 UINTN Offset;
703 UINTN X;
704 UINTN Y;
705 UINT8 Color;
706
707 Offset = 0;
708 for (Y = 0; Y < ScreenHeight; Y++) {
709 for (X = 0; X < ScreenWidth; X++) {
710 Color = (UINT8) (256 * (X + Y) / (ScreenWidth + ScreenHeight));
711 Private->LineBuffer[X] = Color;
712 }
713
714 Private->PciIo->Mem.Write (
715 Private->PciIo,
716 EfiPciIoWidthUint32,
717 0,
718 Offset + (Y * ScreenWidth),
719 ScreenWidth >> 2,
720 Private->LineBuffer
721 );
722 }
723 }
724
725 /**
726 TODO: Add function description
727
728 @param Private TODO: add argument description
729 @param ModeData TODO: add argument description
730
731 TODO: add return values
732
733 **/
734 VOID
735 InitializeGraphicsMode (
736 CIRRUS_LOGIC_5430_PRIVATE_DATA *Private,
737 CIRRUS_LOGIC_5430_VIDEO_MODES *ModeData
738 )
739 {
740 UINT8 Byte;
741 UINTN Index;
742
743 outw (Private, SEQ_ADDRESS_REGISTER, 0x1206);
744 outw (Private, SEQ_ADDRESS_REGISTER, 0x0012);
745
746 for (Index = 0; Index < 15; Index++) {
747 outw (Private, SEQ_ADDRESS_REGISTER, ModeData->SeqSettings[Index]);
748 }
749
750 outb (Private, SEQ_ADDRESS_REGISTER, 0x0f);
751 Byte = (UINT8) ((inb (Private, SEQ_DATA_REGISTER) & 0xc7) ^ 0x30);
752 outb (Private, SEQ_DATA_REGISTER, Byte);
753
754 outb (Private, MISC_OUTPUT_REGISTER, ModeData->MiscSetting);
755 outw (Private, GRAPH_ADDRESS_REGISTER, 0x0506);
756 outw (Private, SEQ_ADDRESS_REGISTER, 0x0300);
757 outw (Private, CRTC_ADDRESS_REGISTER, 0x2011);
758
759 for (Index = 0; Index < 28; Index++) {
760 outw (Private, CRTC_ADDRESS_REGISTER, (UINT16) ((ModeData->CrtcSettings[Index] << 8) | Index));
761 }
762
763 for (Index = 0; Index < 9; Index++) {
764 outw (Private, GRAPH_ADDRESS_REGISTER, (UINT16) ((GraphicsController[Index] << 8) | Index));
765 }
766
767 inb (Private, INPUT_STATUS_1_REGISTER);
768
769 for (Index = 0; Index < 21; Index++) {
770 outb (Private, ATT_ADDRESS_REGISTER, (UINT8) Index);
771 outb (Private, ATT_ADDRESS_REGISTER, AttributeController[Index]);
772 }
773
774 outb (Private, ATT_ADDRESS_REGISTER, 0x20);
775
776 outw (Private, GRAPH_ADDRESS_REGISTER, 0x0009);
777 outw (Private, GRAPH_ADDRESS_REGISTER, 0x000a);
778 outw (Private, GRAPH_ADDRESS_REGISTER, 0x000b);
779 outb (Private, DAC_PIXEL_MASK_REGISTER, 0xff);
780
781 SetDefaultPalette (Private);
782 ClearScreen (Private);
783 }
784
785 EFI_STATUS
786 EFIAPI
787 InitializeCirrusLogic5430 (
788 IN EFI_HANDLE ImageHandle,
789 IN EFI_SYSTEM_TABLE *SystemTable
790 )
791 {
792 EFI_STATUS Status;
793
794 Status = EfiLibInstallDriverBindingComponentName2 (
795 ImageHandle,
796 SystemTable,
797 &gCirrusLogic5430DriverBinding,
798 ImageHandle,
799 &gCirrusLogic5430ComponentName,
800 &gCirrusLogic5430ComponentName2
801 );
802 ASSERT_EFI_ERROR (Status);
803
804 //
805 // Install EFI Driver Supported EFI Version Protocol required for
806 // EFI drivers that are on PCI and other plug in cards.
807 //
808 gCirrusLogic5430DriverSupportedEfiVersion.FirmwareVersion = PcdGet32 (PcdDriverSupportedEfiVersion);
809 Status = gBS->InstallMultipleProtocolInterfaces (
810 &ImageHandle,
811 &gEfiDriverSupportedEfiVersionProtocolGuid,
812 &gCirrusLogic5430DriverSupportedEfiVersion,
813 NULL
814 );
815 ASSERT_EFI_ERROR (Status);
816
817 return Status;
818 }