- Bless halxbox too.
[reactos.git] / reactos / hal / halx86 / xbox / display_xbox.c
1 /* $Id$
2 *
3 * COPYRIGHT: See COPYING in the top level directory
4 * PROJECT: ReactOS kernel
5 * FILE: hal/halx86/xbox/display_xbox.c
6 * PURPOSE: Blue screen display
7 * PROGRAMMER: Eric Kohl (ekohl@rz-online.de)
8 * UPDATE HISTORY:
9 * Created 08/10/99
10 * Modified for Xbox 2004/12/02 GvG
11 */
12
13 /* For an explanation about display ownership see generic/display.c */
14
15 #include <halxbox.h>
16
17 #define NDEBUG
18 #include <debug.h>
19
20 #define I2C_IO_BASE 0xc000
21
22 #define CONTROL_FRAMEBUFFER_ADDRESS_OFFSET 0x600800
23
24 #define MAKE_COLOR(Red, Green, Blue) (0xff000000 | (((Red) & 0xff) << 16) | (((Green) & 0xff) << 8) | ((Blue) & 0xff))
25
26 /* Default to grey on blue */
27 #define DEFAULT_FG_COLOR MAKE_COLOR(127, 127, 127)
28 #define DEFAULT_BG_COLOR MAKE_COLOR(0, 0, 127)
29
30 #define TAG_HALX TAG('H', 'A', 'L', 'X')
31
32 /* VARIABLES ****************************************************************/
33
34 static ULONG CursorX = 0; /* Cursor Position */
35 static ULONG CursorY = 0;
36 static ULONG SizeX; /* Display size (characters) */
37 static ULONG SizeY;
38
39 static BOOLEAN DisplayInitialized = FALSE;
40 static BOOLEAN HalOwnsDisplay = TRUE;
41
42 static PHAL_RESET_DISPLAY_PARAMETERS HalResetDisplayParameters = NULL;
43
44 #define CHAR_WIDTH 8
45 #define CHAR_HEIGHT 16
46
47 static PVOID FrameBuffer;
48 static ULONG BytesPerPixel;
49 static ULONG Delta;
50
51 /*
52 * It turns out that reading from the frame buffer is a pretty expensive
53 * operation. So, we're keeping shadow arrays of the contents and use
54 * those when needed (only for scrolling) instead of reading from the fb.
55 * This cuts down boot time from about 45 sec to about 6 sec.
56 */
57 static PUCHAR CellContents;
58 static PULONG CellFgColor;
59 static PULONG CellBgColor;
60
61 /* PRIVATE FUNCTIONS *********************************************************/
62
63 static VOID FASTCALL
64 HalpXboxOutputChar(UCHAR Char, unsigned X, unsigned Y, ULONG FgColor, ULONG BgColor)
65 {
66 PUCHAR FontPtr;
67 PULONG Pixel;
68 UCHAR Mask;
69 unsigned Line;
70 unsigned Col;
71
72 FontPtr = XboxFont8x16 + Char * 16;
73 Pixel = (PULONG) ((char *) FrameBuffer + Y * CHAR_HEIGHT * Delta
74 + X * CHAR_WIDTH * BytesPerPixel);
75 for (Line = 0; Line < CHAR_HEIGHT; Line++)
76 {
77 Mask = 0x80;
78 for (Col = 0; Col < CHAR_WIDTH; Col++)
79 {
80 Pixel[Col] = (0 != (FontPtr[Line] & Mask) ? FgColor : BgColor);
81 Mask = Mask >> 1;
82 }
83 Pixel = (PULONG) ((char *) Pixel + Delta);
84 }
85
86 if (NULL != CellContents)
87 {
88 CellContents[Y * SizeX + X] = Char;
89 CellFgColor[Y * SizeX + X] = FgColor;
90 CellBgColor[Y * SizeX + X] = BgColor;
91 }
92 }
93
94 static ULONG FASTCALL
95 HalpXboxAttrToSingleColor(UCHAR Attr)
96 {
97 UCHAR Intensity;
98
99 Intensity = (0 == (Attr & 0x08) ? 127 : 255);
100
101 return 0xff000000 |
102 (0 == (Attr & 0x04) ? 0 : (Intensity << 16)) |
103 (0 == (Attr & 0x02) ? 0 : (Intensity << 8)) |
104 (0 == (Attr & 0x01) ? 0 : Intensity);
105 }
106
107 static VOID FASTCALL
108 HalpXboxAttrToColors(UCHAR Attr, ULONG *FgColor, ULONG *BgColor)
109 {
110 *FgColor = HalpXboxAttrToSingleColor(Attr & 0xf);
111 *BgColor = HalpXboxAttrToSingleColor((Attr >> 4) & 0xf);
112 }
113
114 static VOID FASTCALL
115 HalpXboxClearScreenColor(ULONG Color)
116 {
117 ULONG Line, Col;
118 PULONG p;
119
120 for (Line = 0; Line < SizeY * CHAR_HEIGHT; Line++)
121 {
122 p = (PULONG) ((char *) FrameBuffer + Line * Delta);
123 for (Col = 0; Col < SizeX * CHAR_WIDTH; Col++)
124 {
125 *p++ = Color;
126 }
127 }
128
129 if (NULL != CellContents)
130 {
131 for (Line = 0; Line < SizeY; Line++)
132 {
133 for (Col = 0; Col < SizeX; Col++)
134 {
135 CellContents[Line * SizeX + Col] = ' ';
136 CellFgColor[Line * SizeX + Col] = Color;
137 CellBgColor[Line * SizeX + Col] = Color;
138 }
139 }
140 }
141 }
142
143 VOID FASTCALL
144 HalClearDisplay(UCHAR CharAttribute)
145 {
146 ULONG FgColor, BgColor;
147
148 HalpXboxAttrToColors(CharAttribute, &FgColor, &BgColor);
149
150 HalpXboxClearScreenColor(BgColor);
151
152 CursorX = 0;
153 CursorY = 0;
154 }
155
156 VOID static
157 HalScrollDisplay (VOID)
158 {
159 ULONG Line, Col;
160 PULONG p;
161
162 if (NULL == CellContents)
163 {
164 p = (PULONG) ((char *) FrameBuffer + (Delta * CHAR_HEIGHT));
165 RtlMoveMemory(FrameBuffer,
166 p,
167 (Delta * CHAR_HEIGHT) * (SizeY - 1));
168
169 for (Line = 0; Line < CHAR_HEIGHT; Line++)
170 {
171 p = (PULONG) ((char *) FrameBuffer + (CHAR_HEIGHT * (SizeY - 1 ) + Line) * Delta);
172 for (Col = 0; Col < SizeX * CHAR_WIDTH; Col++)
173 {
174 *p++ = DEFAULT_BG_COLOR;
175 }
176 }
177 }
178 else
179 {
180 for (Line = 0; Line < SizeY - 1; Line++)
181 {
182 for (Col = 0; Col < SizeX; Col++)
183 {
184 HalpXboxOutputChar(CellContents[(Line + 1) * SizeX + Col], Col, Line,
185 CellFgColor[(Line + 1) * SizeX + Col],
186 CellBgColor[(Line + 1) * SizeX + Col]);
187 }
188 }
189 for (Col = 0; Col < SizeX; Col++)
190 {
191 HalpXboxOutputChar(' ', Col, SizeY - 1, DEFAULT_FG_COLOR, DEFAULT_BG_COLOR);
192 }
193 }
194 }
195
196 static VOID FASTCALL
197 HalPutCharacter(UCHAR Character)
198 {
199 HalpXboxOutputChar(Character, CursorX, CursorY, DEFAULT_FG_COLOR, DEFAULT_BG_COLOR);
200 }
201
202 static BOOLEAN
203 ReadfromSMBus(UCHAR Address, UCHAR bRegister, UCHAR Size, ULONG *Data_to_smbus)
204 {
205 int nRetriesToLive=50;
206
207 while (0 != (READ_PORT_USHORT((PUSHORT) (I2C_IO_BASE + 0)) & 0x0800))
208 {
209 ; /* Franz's spin while bus busy with any master traffic */
210 }
211
212 while (0 != nRetriesToLive--)
213 {
214 UCHAR b;
215 int temp;
216
217 WRITE_PORT_UCHAR((PUCHAR) (I2C_IO_BASE + 4), (Address << 1) | 1);
218 WRITE_PORT_UCHAR((PUCHAR) (I2C_IO_BASE + 8), bRegister);
219
220 temp = READ_PORT_USHORT((PUSHORT) (I2C_IO_BASE + 0));
221 WRITE_PORT_USHORT((PUSHORT) (I2C_IO_BASE + 0), temp); /* clear down all preexisting errors */
222
223 switch (Size)
224 {
225 case 4:
226 WRITE_PORT_UCHAR((PUCHAR) (I2C_IO_BASE + 2), 0x0d); /* DWORD modus ? */
227 break;
228 case 2:
229 WRITE_PORT_UCHAR((PUCHAR) (I2C_IO_BASE + 2), 0x0b); /* WORD modus */
230 break;
231 default:
232 WRITE_PORT_UCHAR((PUCHAR) (I2C_IO_BASE + 2), 0x0a); // BYTE
233 break;
234 }
235
236 b = 0;
237
238 while (0 == (b & 0x36))
239 {
240 b = READ_PORT_UCHAR((PUCHAR) (I2C_IO_BASE + 0));
241 }
242
243 if (0 != (b & 0x24))
244 {
245 /* printf("I2CTransmitByteGetReturn error %x\n", b); */
246 }
247
248 if(0 == (b & 0x10))
249 {
250 /* printf("I2CTransmitByteGetReturn no complete, retry\n"); */
251 }
252 else
253 {
254 switch (Size)
255 {
256 case 4:
257 READ_PORT_UCHAR((PUCHAR) (I2C_IO_BASE + 6));
258 READ_PORT_UCHAR((PUCHAR) (I2C_IO_BASE + 9));
259 READ_PORT_UCHAR((PUCHAR) (I2C_IO_BASE + 9));
260 READ_PORT_UCHAR((PUCHAR) (I2C_IO_BASE + 9));
261 READ_PORT_UCHAR((PUCHAR) (I2C_IO_BASE + 9));
262 break;
263 case 2:
264 *Data_to_smbus = READ_PORT_USHORT((PUSHORT) (I2C_IO_BASE + 6));
265 break;
266 default:
267 *Data_to_smbus = READ_PORT_UCHAR((PUCHAR) (I2C_IO_BASE + 6));
268 break;
269 }
270
271
272 return TRUE;
273 }
274 }
275
276 return FALSE;
277 }
278
279
280 static BOOLEAN
281 I2CTransmitByteGetReturn(UCHAR bPicAddressI2cFormat, UCHAR bDataToWrite, ULONG *Return)
282 {
283 return ReadfromSMBus(bPicAddressI2cFormat, bDataToWrite, 1, Return);
284 }
285
286 VOID FASTCALL
287 HalInitializeDisplay (PLOADER_PARAMETER_BLOCK LoaderBlock)
288 /*
289 * FUNCTION: Initalize the display
290 * ARGUMENTS:
291 * InitParameters = Parameters setup by the boot loader
292 */
293 {
294 ULONG ScreenWidthPixels;
295 ULONG ScreenHeightPixels;
296 PHYSICAL_ADDRESS PhysControl;
297 PHYSICAL_ADDRESS PhysBuffer;
298 ULONG AvMode;
299 PVOID ControlBuffer;
300
301 if (! DisplayInitialized)
302 {
303 PhysBuffer.u.HighPart = 0;
304 if (0 != (LoaderBlock->Flags & MB_FLAGS_MEM_INFO))
305 {
306 PhysBuffer.u.LowPart = (LoaderBlock->MemHigher + 1024) * 1024;
307 }
308 else
309 {
310 /* Assume a 64Mb Xbox, last 4MB for video buf */
311 PhysBuffer.u.LowPart = 60 * 1024 * 1024;
312 }
313 PhysBuffer.u.LowPart |= 0xf0000000;
314
315 /* Tell the nVidia controller about the framebuffer */
316 PhysControl.u.HighPart = 0;
317 PhysControl.u.LowPart = 0xfd000000;
318 ControlBuffer = MmMapIoSpace(PhysControl, 0x1000000, MmNonCached);
319 if (NULL == ControlBuffer)
320 {
321 return;
322 }
323 *((PULONG) ((char *) ControlBuffer + CONTROL_FRAMEBUFFER_ADDRESS_OFFSET)) = (ULONG) PhysBuffer.u.LowPart;
324 MmUnmapIoSpace(ControlBuffer, 0x1000000);
325
326 FrameBuffer = MmMapIoSpace(PhysBuffer, 4 * 1024 * 1024, MmNonCached);
327 if (NULL == FrameBuffer)
328 {
329 return;
330 }
331
332 if (I2CTransmitByteGetReturn(0x10, 0x04, &AvMode))
333 {
334 if (1 == AvMode) /* HDTV */
335 {
336 ScreenWidthPixels = 720;
337 }
338 else
339 {
340 /* FIXME Other possible values of AvMode:
341 * 0 - AV_SCART_RGB
342 * 2 - AV_VGA_SOG
343 * 4 - AV_SVIDEO
344 * 6 - AV_COMPOSITE
345 * 7 - AV_VGA
346 * other AV_COMPOSITE
347 */
348 ScreenWidthPixels = 640;
349 }
350 }
351 else
352 {
353 ScreenWidthPixels = 640;
354 }
355 ScreenHeightPixels = 480;
356 BytesPerPixel = 4;
357
358 SizeX = ScreenWidthPixels / CHAR_WIDTH;
359 SizeY = ScreenHeightPixels / CHAR_HEIGHT;
360 Delta = (ScreenWidthPixels * BytesPerPixel + 3) & ~ 0x3;
361
362 CellFgColor = (PULONG) ExAllocatePoolWithTag(PagedPool,
363 SizeX * SizeY * (sizeof(ULONG) + sizeof(ULONG) + sizeof(UCHAR)),
364 TAG_HALX);
365 if (NULL != CellFgColor)
366 {
367 CellBgColor = CellFgColor + SizeX * SizeY;
368 CellContents = (PUCHAR) (CellBgColor + SizeX * SizeY);
369 }
370 else
371 {
372 CellBgColor = NULL;
373 CellContents = NULL;
374 }
375
376 HalpXboxClearScreenColor(MAKE_COLOR(0, 0, 0));
377
378 DisplayInitialized = TRUE;
379 }
380 }
381
382
383 /* PUBLIC FUNCTIONS *********************************************************/
384
385 VOID STDCALL
386 HalReleaseDisplayOwnership(VOID)
387 /*
388 * FUNCTION: Release ownership of display back to HAL
389 */
390 {
391 if (HalOwnsDisplay || NULL == HalResetDisplayParameters)
392 {
393 return;
394 }
395
396 HalResetDisplayParameters(SizeX, SizeY);
397
398 HalOwnsDisplay = TRUE;
399 HalpXboxClearScreenColor(DEFAULT_BG_COLOR);
400
401 CursorX = 0;
402 CursorY = 0;
403 }
404
405
406 VOID STDCALL
407 HalAcquireDisplayOwnership(IN PHAL_RESET_DISPLAY_PARAMETERS ResetDisplayParameters)
408 /*
409 * FUNCTION:
410 * ARGUMENTS:
411 * ResetDisplayParameters = Pointer to a driver specific
412 * reset routine.
413 */
414 {
415 HalOwnsDisplay = FALSE;
416 HalResetDisplayParameters = ResetDisplayParameters;
417 }
418
419 VOID STDCALL
420 HalDisplayString(IN PCH String)
421 /*
422 * FUNCTION: Switches the screen to HAL console mode (BSOD) if not there
423 * already and displays a string
424 * ARGUMENT:
425 * string = ASCII string to display
426 * NOTE: Use with care because there is no support for returning from BSOD
427 * mode
428 */
429 {
430 PCH pch;
431 static KSPIN_LOCK Lock;
432 KIRQL OldIrql;
433 ULONG Flags;
434
435 if (! HalOwnsDisplay || ! DisplayInitialized)
436 {
437 return;
438 }
439
440 pch = String;
441
442 OldIrql = KfRaiseIrql(HIGH_LEVEL);
443 KiAcquireSpinLock(&Lock);
444
445 Ki386SaveFlags(Flags);
446 Ki386DisableInterrupts();
447
448 while (*pch != 0)
449 {
450 if (*pch == '\n')
451 {
452 CursorY++;
453 CursorX = 0;
454 }
455 else if (*pch == '\b')
456 {
457 if (CursorX > 0)
458 {
459 CursorX--;
460 }
461 }
462 else if (*pch != '\r')
463 {
464 HalPutCharacter(*pch);
465 CursorX++;
466
467 if (SizeX <= CursorX)
468 {
469 CursorY++;
470 CursorX = 0;
471 }
472 }
473
474 if (SizeY <= CursorY)
475 {
476 HalScrollDisplay ();
477 CursorY = SizeY - 1;
478 }
479
480 pch++;
481 }
482
483 Ki386RestoreFlags(Flags);
484
485 KiReleaseSpinLock(&Lock);
486 KfLowerIrql(OldIrql);
487 }
488
489 VOID STDCALL
490 HalQueryDisplayParameters(OUT PULONG DispSizeX,
491 OUT PULONG DispSizeY,
492 OUT PULONG CursorPosX,
493 OUT PULONG CursorPosY)
494 {
495 if (DispSizeX)
496 *DispSizeX = SizeX;
497 if (DispSizeY)
498 *DispSizeY = SizeY;
499 if (CursorPosX)
500 *CursorPosX = CursorX;
501 if (CursorPosY)
502 *CursorPosY = CursorY;
503 }
504
505
506 VOID STDCALL
507 HalSetDisplayParameters(IN ULONG CursorPosX,
508 IN ULONG CursorPosY)
509 {
510 CursorX = (CursorPosX < SizeX) ? CursorPosX : SizeX - 1;
511 CursorY = (CursorPosY < SizeY) ? CursorPosY : SizeY - 1;
512 }
513
514
515 BOOLEAN STDCALL
516 HalQueryDisplayOwnership(VOID)
517 {
518 return ! HalOwnsDisplay;
519 }
520
521 /* EOF */