[BLUE][CDFS]
[reactos.git] / reactos / drivers / setup / blue / blue.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * FILE: services/dd/blue/blue.c
5 * PURPOSE: Console (blue screen) device driver
6 * PROGRAMMER: Eric Kohl
7 * UPDATE HISTORY:
8 * ??? Created
9 */
10
11 /* INCLUDES ******************************************************************/
12
13 #include "blue.h"
14
15 #define NDEBUG
16 #include <debug.h>
17
18 // ROS Internal. Please deprecate.
19 NTHALAPI
20 BOOLEAN
21 NTAPI
22 HalQueryDisplayOwnership(
23 VOID
24 );
25
26 /* NOTES ******************************************************************/
27 /*
28 * [[character][attribute]][[character][attribute]]....
29 */
30
31
32 /* TYPEDEFS ***************************************************************/
33
34 typedef struct _DEVICE_EXTENSION
35 {
36 PUCHAR VideoMemory; /* Pointer to video memory */
37 ULONG CursorSize;
38 INT CursorVisible;
39 USHORT CharAttribute;
40 ULONG Mode;
41 UCHAR ScanLines; /* Height of a text line */
42 USHORT Rows; /* Number of rows */
43 USHORT Columns; /* Number of columns */
44 } DEVICE_EXTENSION, *PDEVICE_EXTENSION;
45
46 typedef struct _VGA_REGISTERS
47 {
48 UCHAR CRT[24];
49 UCHAR Attribute[21];
50 UCHAR Graphics[9];
51 UCHAR Sequencer[5];
52 UCHAR Misc;
53 } VGA_REGISTERS, *PVGA_REGISTERS;
54
55 static const VGA_REGISTERS VidpMode3Regs =
56 {
57 /* CRT Controller Registers */
58 {0x5F, 0x4F, 0x50, 0x82, 0x55, 0x81, 0xBF, 0x1F, 0x00, 0x47, 0x1E, 0x00,
59 0x00, 0x00, 0x05, 0xF0, 0x9C, 0x8E, 0x8F, 0x28, 0x1F, 0x96, 0xB9, 0xA3},
60 /* Attribute Controller Registers */
61 {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07, 0x38, 0x39, 0x3A, 0x3B,
62 0x3C, 0x3D, 0x3E, 0x3F, 0x0C, 0x00, 0x0F, 0x08, 0x00},
63 /* Graphics Controller Registers */
64 {0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x0E, 0x00, 0xFF},
65 /* Sequencer Registers */
66 {0x03, 0x00, 0x03, 0x00, 0x02},
67 /* Misc Output Register */
68 0x67
69 };
70
71 static const UCHAR DefaultPalette[] =
72 {
73 0, 0, 0,
74 0, 0, 0xC0,
75 0, 0xC0, 0,
76 0, 0xC0, 0xC0,
77 0xC0, 0, 0,
78 0xC0, 0, 0xC0,
79 0xC0, 0xC0, 0,
80 0xC0, 0xC0, 0xC0,
81 0x80, 0x80, 0x80,
82 0, 0, 0xFF,
83 0, 0xFF, 0,
84 0, 0xFF, 0xFF,
85 0xFF, 0, 0,
86 0xFF, 0, 0xFF,
87 0xFF, 0xFF, 0,
88 0xFF, 0xFF, 0xFF
89 };
90
91 /* FUNCTIONS **************************************************************/
92
93 static VOID FASTCALL
94 ScrSetRegisters(const VGA_REGISTERS *Registers)
95 {
96 UINT32 i;
97
98 /* Update misc output register */
99 WRITE_PORT_UCHAR(MISC, Registers->Misc);
100
101 /* Synchronous reset on */
102 WRITE_PORT_UCHAR(SEQ, 0x00);
103 WRITE_PORT_UCHAR(SEQDATA, 0x01);
104
105 /* Write sequencer registers */
106 for (i = 1; i < sizeof(Registers->Sequencer); i++)
107 {
108 WRITE_PORT_UCHAR(SEQ, i);
109 WRITE_PORT_UCHAR(SEQDATA, Registers->Sequencer[i]);
110 }
111
112 /* Synchronous reset off */
113 WRITE_PORT_UCHAR(SEQ, 0x00);
114 WRITE_PORT_UCHAR(SEQDATA, 0x03);
115
116 /* Deprotect CRT registers 0-7 */
117 WRITE_PORT_UCHAR(CRTC, 0x11);
118 WRITE_PORT_UCHAR(CRTCDATA, Registers->CRT[0x11] & 0x7f);
119
120 /* Write CRT registers */
121 for (i = 0; i < sizeof(Registers->CRT); i++)
122 {
123 WRITE_PORT_UCHAR(CRTC, i);
124 WRITE_PORT_UCHAR(CRTCDATA, Registers->CRT[i]);
125 }
126
127 /* Write graphics controller registers */
128 for (i = 0; i < sizeof(Registers->Graphics); i++)
129 {
130 WRITE_PORT_UCHAR(GRAPHICS, i);
131 WRITE_PORT_UCHAR(GRAPHICSDATA, Registers->Graphics[i]);
132 }
133
134 /* Write attribute controller registers */
135 for (i = 0; i < sizeof(Registers->Attribute); i++)
136 {
137 READ_PORT_UCHAR(STATUS);
138 WRITE_PORT_UCHAR(ATTRIB, i);
139 WRITE_PORT_UCHAR(ATTRIB, Registers->Attribute[i]);
140 }
141
142 /* Set the PEL mask. */
143 WRITE_PORT_UCHAR(PELMASK, 0xff);
144 }
145
146 static VOID FASTCALL
147 ScrAcquireOwnership(PDEVICE_EXTENSION DeviceExtension)
148 {
149 unsigned int offset;
150 UCHAR data, value;
151 ULONG Index;
152
153 ScrSetRegisters(&VidpMode3Regs);
154
155 /* Disable screen and enable palette access. */
156 READ_PORT_UCHAR(STATUS);
157 WRITE_PORT_UCHAR(ATTRIB, 0x00);
158
159 for (Index = 0; Index < sizeof(DefaultPalette) / 3; Index++)
160 {
161 WRITE_PORT_UCHAR(PELINDEX, Index);
162 WRITE_PORT_UCHAR(PELDATA, DefaultPalette[Index * 3] >> 2);
163 WRITE_PORT_UCHAR(PELDATA, DefaultPalette[Index * 3 + 1] >> 2);
164 WRITE_PORT_UCHAR(PELDATA, DefaultPalette[Index * 3 + 2] >> 2);
165 }
166
167 /* Enable screen and disable palette access. */
168 READ_PORT_UCHAR(STATUS);
169 WRITE_PORT_UCHAR(ATTRIB, 0x20);
170
171 /* get current output position */
172 WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSLO);
173 offset = READ_PORT_UCHAR (CRTC_DATA);
174 WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSHI);
175 offset += (READ_PORT_UCHAR (CRTC_DATA) << 8);
176
177 /* switch blinking characters off */
178 READ_PORT_UCHAR (ATTRC_INPST1);
179 value = READ_PORT_UCHAR (ATTRC_WRITEREG);
180 WRITE_PORT_UCHAR (ATTRC_WRITEREG, 0x10);
181 data = READ_PORT_UCHAR (ATTRC_READREG);
182 data = data & ~0x08;
183 WRITE_PORT_UCHAR (ATTRC_WRITEREG, data);
184 WRITE_PORT_UCHAR (ATTRC_WRITEREG, value);
185 READ_PORT_UCHAR (ATTRC_INPST1);
186
187 /* read screen information from crt controller */
188 WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_COLUMNS);
189 DeviceExtension->Columns = READ_PORT_UCHAR (CRTC_DATA) + 1;
190 WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_ROWS);
191 DeviceExtension->Rows = READ_PORT_UCHAR (CRTC_DATA);
192 WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_OVERFLOW);
193 data = READ_PORT_UCHAR (CRTC_DATA);
194 DeviceExtension->Rows |= (((data & 0x02) << 7) | ((data & 0x40) << 3));
195 DeviceExtension->Rows++;
196 WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_SCANLINES);
197 DeviceExtension->ScanLines = (READ_PORT_UCHAR (CRTC_DATA) & 0x1F) + 1;
198
199 /* show blinking cursor */
200 WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORSTART);
201 WRITE_PORT_UCHAR (CRTC_DATA, (DeviceExtension->ScanLines - 1) & 0x1F);
202 WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSOREND);
203 data = READ_PORT_UCHAR (CRTC_DATA) & 0xE0;
204 WRITE_PORT_UCHAR (CRTC_DATA,
205 data | ((DeviceExtension->ScanLines - 1) & 0x1F));
206
207 /* calculate number of text rows */
208 DeviceExtension->Rows =
209 DeviceExtension->Rows / DeviceExtension->ScanLines;
210 #ifdef BOCHS_30ROWS
211 DeviceExtension->Rows = 30;
212 #endif
213
214 DPRINT ("%d Columns %d Rows %d Scanlines\n",
215 DeviceExtension->Columns,
216 DeviceExtension->Rows,
217 DeviceExtension->ScanLines);
218 }
219
220 NTSTATUS NTAPI
221 DriverEntry (PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath);
222
223 static DRIVER_DISPATCH ScrCreate;
224 static NTSTATUS NTAPI
225 ScrCreate(PDEVICE_OBJECT DeviceObject,
226 PIRP Irp)
227 {
228 PDEVICE_EXTENSION DeviceExtension;
229 PHYSICAL_ADDRESS BaseAddress;
230 NTSTATUS Status;
231
232 DeviceExtension = DeviceObject->DeviceExtension;
233
234 if (!InbvCheckDisplayOwnership())
235 {
236 ScrAcquireOwnership(DeviceExtension);
237
238 /* get pointer to video memory */
239 BaseAddress.QuadPart = VIDMEM_BASE;
240 DeviceExtension->VideoMemory =
241 (PUCHAR)MmMapIoSpace (BaseAddress, DeviceExtension->Rows * DeviceExtension->Columns * 2, MmNonCached);
242 }
243 else
244 {
245 /* store dummy values here */
246 DeviceExtension->Columns = 1;
247 DeviceExtension->Rows = 1;
248 DeviceExtension->ScanLines = 1;
249 }
250
251 DeviceExtension->CursorSize = 5; /* FIXME: value correct?? */
252 DeviceExtension->CursorVisible = TRUE;
253
254 /* more initialization */
255 DeviceExtension->CharAttribute = 0x17; /* light grey on blue */
256 DeviceExtension->Mode = ENABLE_PROCESSED_OUTPUT |
257 ENABLE_WRAP_AT_EOL_OUTPUT;
258
259 Status = STATUS_SUCCESS;
260
261 Irp->IoStatus.Status = Status;
262 IoCompleteRequest (Irp, IO_NO_INCREMENT);
263
264 return (Status);
265 }
266
267 static DRIVER_DISPATCH ScrWrite;
268 static NTSTATUS NTAPI
269 ScrWrite(PDEVICE_OBJECT DeviceObject,
270 PIRP Irp)
271 {
272 PIO_STACK_LOCATION stk = IoGetCurrentIrpStackLocation (Irp);
273 PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
274 NTSTATUS Status;
275 char *pch = Irp->UserBuffer;
276 PUCHAR vidmem;
277 unsigned int i;
278 int j, offset;
279 int cursorx, cursory;
280 int rows, columns;
281 int processed = DeviceExtension->Mode & ENABLE_PROCESSED_OUTPUT;
282
283 if (InbvCheckDisplayOwnership())
284 {
285 /* Display is in graphics mode, we're not allowed to touch it */
286 Status = STATUS_SUCCESS;
287
288 Irp->IoStatus.Status = Status;
289 IoCompleteRequest (Irp, IO_NO_INCREMENT);
290
291 return Status;
292 }
293
294 vidmem = DeviceExtension->VideoMemory;
295 rows = DeviceExtension->Rows;
296 columns = DeviceExtension->Columns;
297
298 _disable();
299 WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSHI);
300 offset = READ_PORT_UCHAR (CRTC_DATA)<<8;
301 WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSLO);
302 offset += READ_PORT_UCHAR (CRTC_DATA);
303 _enable();
304
305 cursory = offset / columns;
306 cursorx = offset % columns;
307 if( processed == 0 )
308 {
309 /* raw output mode */
310 memcpy( &vidmem[(cursorx * 2) + (cursory * columns * 2)], pch, stk->Parameters.Write.Length );
311 offset += (stk->Parameters.Write.Length / 2);
312 }
313 else {
314 for (i = 0; i < stk->Parameters.Write.Length; i++, pch++)
315 {
316 switch (*pch)
317 {
318 case '\b':
319 if (cursorx > 0)
320 {
321 cursorx--;
322 }
323 else if (cursory > 0)
324 {
325 cursorx = columns - 1;
326 cursory--;
327 }
328 vidmem[(cursorx * 2) + (cursory * columns * 2)] = ' ';
329 vidmem[(cursorx * 2) + (cursory * columns * 2) + 1] = (char) DeviceExtension->CharAttribute;
330 break;
331
332 case '\n':
333 cursory++;
334 cursorx = 0;
335 break;
336
337 case '\r':
338 cursorx = 0;
339 break;
340
341 case '\t':
342 offset = TAB_WIDTH - (cursorx % TAB_WIDTH);
343 for (j = 0; j < offset; j++)
344 {
345 vidmem[(cursorx * 2) + (cursory * columns * 2)] = ' ';
346 cursorx++;
347
348 if (cursorx >= columns)
349 {
350 cursory++;
351 cursorx = 0;
352 }
353 }
354 break;
355
356 default:
357 vidmem[(cursorx * 2) + (cursory * columns * 2)] = *pch;
358 vidmem[(cursorx * 2) + (cursory * columns * 2) + 1] = (char) DeviceExtension->CharAttribute;
359 cursorx++;
360 if (cursorx >= columns)
361 {
362 cursory++;
363 cursorx = 0;
364 }
365 break;
366 }
367 if (cursory >= rows)
368 {
369 unsigned short *LinePtr;
370
371 memcpy (vidmem,
372 &vidmem[columns * 2],
373 columns * (rows - 1) * 2);
374
375 LinePtr = (unsigned short *) &vidmem[columns * (rows - 1) * 2];
376
377 for (j = 0; j < columns; j++)
378 {
379 LinePtr[j] = DeviceExtension->CharAttribute << 8;
380 }
381 cursory = rows - 1;
382 for (j = 0; j < columns; j++)
383 {
384 vidmem[(j * 2) + (cursory * columns * 2)] = ' ';
385 vidmem[(j * 2) + (cursory * columns * 2) + 1] = (char)DeviceExtension->CharAttribute;
386 }
387 }
388 }
389
390 /* Set the cursor position */
391 offset = (cursory * columns) + cursorx;
392 }
393 _disable();
394 WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSLO);
395 WRITE_PORT_UCHAR (CRTC_DATA, offset);
396 WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSHI);
397 offset >>= 8;
398 WRITE_PORT_UCHAR (CRTC_DATA, offset);
399 _enable();
400
401 Status = STATUS_SUCCESS;
402
403 Irp->IoStatus.Status = Status;
404 IoCompleteRequest (Irp, IO_NO_INCREMENT);
405
406 return (Status);
407 }
408
409 static DRIVER_DISPATCH ScrIoControl;
410 static NTSTATUS NTAPI
411 ScrIoControl(PDEVICE_OBJECT DeviceObject,
412 PIRP Irp)
413 {
414 PIO_STACK_LOCATION stk = IoGetCurrentIrpStackLocation (Irp);
415 PDEVICE_EXTENSION DeviceExtension;
416 NTSTATUS Status;
417
418 DeviceExtension = DeviceObject->DeviceExtension;
419 switch (stk->Parameters.DeviceIoControl.IoControlCode)
420 {
421 case IOCTL_CONSOLE_GET_SCREEN_BUFFER_INFO:
422 {
423 PCONSOLE_SCREEN_BUFFER_INFO pcsbi = (PCONSOLE_SCREEN_BUFFER_INFO)Irp->AssociatedIrp.SystemBuffer;
424 int rows = DeviceExtension->Rows;
425 int columns = DeviceExtension->Columns;
426 unsigned int offset;
427
428 if (!InbvCheckDisplayOwnership())
429 {
430 /* read cursor position from crtc */
431 _disable();
432 WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSLO);
433 offset = READ_PORT_UCHAR (CRTC_DATA);
434 WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSHI);
435 offset += (READ_PORT_UCHAR (CRTC_DATA) << 8);
436 _enable();
437 }
438 else
439 {
440 offset = 0;
441 }
442
443 pcsbi->dwSize.X = columns;
444 pcsbi->dwSize.Y = rows;
445
446 pcsbi->dwCursorPosition.X = (SHORT)(offset % columns);
447 pcsbi->dwCursorPosition.Y = (SHORT)(offset / columns);
448
449 pcsbi->wAttributes = DeviceExtension->CharAttribute;
450
451 pcsbi->srWindow.Left = 0;
452 pcsbi->srWindow.Right = columns - 1;
453 pcsbi->srWindow.Top = 0;
454 pcsbi->srWindow.Bottom = rows - 1;
455
456 pcsbi->dwMaximumWindowSize.X = columns;
457 pcsbi->dwMaximumWindowSize.Y = rows;
458
459 Irp->IoStatus.Information = sizeof (CONSOLE_SCREEN_BUFFER_INFO);
460 Status = STATUS_SUCCESS;
461 }
462 break;
463
464 case IOCTL_CONSOLE_SET_SCREEN_BUFFER_INFO:
465 {
466 PCONSOLE_SCREEN_BUFFER_INFO pcsbi = (PCONSOLE_SCREEN_BUFFER_INFO)Irp->AssociatedIrp.SystemBuffer;
467 unsigned int offset;
468
469 DeviceExtension->CharAttribute = pcsbi->wAttributes;
470 offset = (pcsbi->dwCursorPosition.Y * DeviceExtension->Columns) +
471 pcsbi->dwCursorPosition.X;
472
473 if (!InbvCheckDisplayOwnership())
474 {
475 _disable();
476 WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSLO);
477 WRITE_PORT_UCHAR (CRTC_DATA, offset);
478 WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSHI);
479 WRITE_PORT_UCHAR (CRTC_DATA, offset>>8);
480 _enable();
481 }
482
483 Irp->IoStatus.Information = 0;
484 Status = STATUS_SUCCESS;
485 }
486 break;
487
488 case IOCTL_CONSOLE_GET_CURSOR_INFO:
489 {
490 PCONSOLE_CURSOR_INFO pcci = (PCONSOLE_CURSOR_INFO)Irp->AssociatedIrp.SystemBuffer;
491
492 pcci->dwSize = DeviceExtension->CursorSize;
493 pcci->bVisible = DeviceExtension->CursorVisible;
494
495 Irp->IoStatus.Information = sizeof (CONSOLE_CURSOR_INFO);
496 Status = STATUS_SUCCESS;
497 }
498 break;
499
500 case IOCTL_CONSOLE_SET_CURSOR_INFO:
501 {
502 PCONSOLE_CURSOR_INFO pcci = (PCONSOLE_CURSOR_INFO)Irp->AssociatedIrp.SystemBuffer;
503 UCHAR data, value;
504 ULONG size, height;
505
506 DeviceExtension->CursorSize = pcci->dwSize;
507 DeviceExtension->CursorVisible = pcci->bVisible;
508
509 if (!InbvCheckDisplayOwnership())
510 {
511 height = DeviceExtension->ScanLines;
512 data = (pcci->bVisible) ? 0x00 : 0x20;
513
514 size = (pcci->dwSize * height) / 100;
515 if (size < 1)
516 {
517 size = 1;
518 }
519
520 data |= (UCHAR)(height - size);
521
522 _disable();
523 WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORSTART);
524 WRITE_PORT_UCHAR (CRTC_DATA, data);
525 WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSOREND);
526 value = READ_PORT_UCHAR (CRTC_DATA) & 0xE0;
527 WRITE_PORT_UCHAR (CRTC_DATA, value | (height - 1));
528
529 _enable();
530 }
531
532 Irp->IoStatus.Information = 0;
533 Status = STATUS_SUCCESS;
534 }
535 break;
536
537 case IOCTL_CONSOLE_GET_MODE:
538 {
539 PCONSOLE_MODE pcm = (PCONSOLE_MODE)Irp->AssociatedIrp.SystemBuffer;
540
541 pcm->dwMode = DeviceExtension->Mode;
542
543 Irp->IoStatus.Information = sizeof(CONSOLE_MODE);
544 Status = STATUS_SUCCESS;
545 }
546 break;
547
548 case IOCTL_CONSOLE_SET_MODE:
549 {
550 PCONSOLE_MODE pcm = (PCONSOLE_MODE)Irp->AssociatedIrp.SystemBuffer;
551
552 DeviceExtension->Mode = pcm->dwMode;
553
554 Irp->IoStatus.Information = 0;
555 Status = STATUS_SUCCESS;
556 }
557 break;
558
559 case IOCTL_CONSOLE_FILL_OUTPUT_ATTRIBUTE:
560 {
561 POUTPUT_ATTRIBUTE Buf = (POUTPUT_ATTRIBUTE)Irp->AssociatedIrp.SystemBuffer;
562 PUCHAR vidmem;
563 int offset;
564 ULONG dwCount;
565
566 if (!InbvCheckDisplayOwnership())
567 {
568 vidmem = DeviceExtension->VideoMemory;
569 offset = (Buf->dwCoord.Y * DeviceExtension->Columns * 2) +
570 (Buf->dwCoord.X * 2) + 1;
571
572 for (dwCount = 0; dwCount < Buf->nLength; dwCount++)
573 {
574 vidmem[offset + (dwCount * 2)] = (char) Buf->wAttribute;
575 }
576 }
577
578 Buf->dwTransfered = Buf->nLength;
579
580 Irp->IoStatus.Information = 0;
581 Status = STATUS_SUCCESS;
582 }
583 break;
584
585 case IOCTL_CONSOLE_READ_OUTPUT_ATTRIBUTE:
586 {
587 POUTPUT_ATTRIBUTE Buf = (POUTPUT_ATTRIBUTE)Irp->AssociatedIrp.SystemBuffer;
588 PUSHORT pAttr = (PUSHORT)MmGetSystemAddressForMdl(Irp->MdlAddress);
589 PUCHAR vidmem;
590 int offset;
591 ULONG dwCount;
592
593 if (!InbvCheckDisplayOwnership())
594 {
595 vidmem = DeviceExtension->VideoMemory;
596 offset = (Buf->dwCoord.Y * DeviceExtension->Columns * 2) +
597 (Buf->dwCoord.X * 2) + 1;
598
599 for (dwCount = 0; dwCount < stk->Parameters.DeviceIoControl.OutputBufferLength; dwCount++, pAttr++)
600 {
601 *((char *) pAttr) = vidmem[offset + (dwCount * 2)];
602 }
603
604 Buf->dwTransfered = dwCount;
605 }
606 else
607 {
608 Buf->dwTransfered = 0;
609 }
610
611 Irp->IoStatus.Information = sizeof(OUTPUT_ATTRIBUTE);
612 Status = STATUS_SUCCESS;
613 }
614 break;
615
616 case IOCTL_CONSOLE_WRITE_OUTPUT_ATTRIBUTE:
617 {
618 COORD *pCoord = (COORD *)MmGetSystemAddressForMdl(Irp->MdlAddress);
619 CHAR *pAttr = (CHAR *)(pCoord + 1);
620 PUCHAR vidmem;
621 int offset;
622 ULONG dwCount;
623
624 if (!InbvCheckDisplayOwnership())
625 {
626 vidmem = DeviceExtension->VideoMemory;
627 offset = (pCoord->Y * DeviceExtension->Columns * 2) +
628 (pCoord->X * 2) + 1;
629
630 for (dwCount = 0; dwCount < (stk->Parameters.DeviceIoControl.OutputBufferLength - sizeof( COORD )); dwCount++, pAttr++)
631 {
632 vidmem[offset + (dwCount * 2)] = *pAttr;
633 }
634 }
635
636 Irp->IoStatus.Information = 0;
637 Status = STATUS_SUCCESS;
638 }
639 break;
640
641 case IOCTL_CONSOLE_SET_TEXT_ATTRIBUTE:
642 DeviceExtension->CharAttribute = (USHORT)*(PUSHORT)Irp->AssociatedIrp.SystemBuffer;
643 Irp->IoStatus.Information = 0;
644 Status = STATUS_SUCCESS;
645 break;
646
647 case IOCTL_CONSOLE_FILL_OUTPUT_CHARACTER:
648 {
649 POUTPUT_CHARACTER Buf = (POUTPUT_CHARACTER)Irp->AssociatedIrp.SystemBuffer;
650 PUCHAR vidmem;
651 int offset;
652 ULONG dwCount;
653
654 if (!InbvCheckDisplayOwnership())
655 {
656 vidmem = DeviceExtension->VideoMemory;
657 offset = (Buf->dwCoord.Y * DeviceExtension->Columns * 2) +
658 (Buf->dwCoord.X * 2);
659
660
661 for (dwCount = 0; dwCount < Buf->nLength; dwCount++)
662 {
663 vidmem[offset + (dwCount * 2)] = (char) Buf->cCharacter;
664 }
665 }
666
667 Buf->dwTransfered = Buf->nLength;
668
669 Irp->IoStatus.Information = 0;
670 Status = STATUS_SUCCESS;
671 }
672 break;
673
674 case IOCTL_CONSOLE_READ_OUTPUT_CHARACTER:
675 {
676 POUTPUT_CHARACTER Buf = (POUTPUT_CHARACTER)Irp->AssociatedIrp.SystemBuffer;
677 LPSTR pChar = (LPSTR)MmGetSystemAddressForMdl(Irp->MdlAddress);
678 PUCHAR vidmem;
679 int offset;
680 ULONG dwCount;
681
682 if (!InbvCheckDisplayOwnership())
683 {
684 vidmem = DeviceExtension->VideoMemory;
685 offset = (Buf->dwCoord.Y * DeviceExtension->Columns * 2) +
686 (Buf->dwCoord.X * 2);
687
688 for (dwCount = 0; dwCount < stk->Parameters.DeviceIoControl.OutputBufferLength; dwCount++, pChar++)
689 {
690 *pChar = vidmem[offset + (dwCount * 2)];
691 }
692
693 Buf->dwTransfered = dwCount;
694 }
695 else
696 {
697 Buf->dwTransfered = 0;
698 }
699
700 Irp->IoStatus.Information = sizeof(OUTPUT_ATTRIBUTE);
701 Status = STATUS_SUCCESS;
702 }
703 break;
704
705 case IOCTL_CONSOLE_WRITE_OUTPUT_CHARACTER:
706 {
707 COORD *pCoord;
708 LPSTR pChar;
709 PUCHAR vidmem;
710 int offset;
711 ULONG dwCount;
712
713 if (!InbvCheckDisplayOwnership())
714 {
715 pCoord = (COORD *)MmGetSystemAddressForMdl(Irp->MdlAddress);
716 pChar = (CHAR *)(pCoord + 1);
717 vidmem = DeviceExtension->VideoMemory;
718 offset = (pCoord->Y * DeviceExtension->Columns * 2) +
719 (pCoord->X * 2);
720
721 for (dwCount = 0; dwCount < (stk->Parameters.DeviceIoControl.OutputBufferLength - sizeof( COORD )); dwCount++, pChar++)
722 {
723 vidmem[offset + (dwCount * 2)] = *pChar;
724 }
725 }
726
727 Irp->IoStatus.Information = 0;
728 Status = STATUS_SUCCESS;
729 }
730 break;
731
732 case IOCTL_CONSOLE_DRAW:
733 {
734 PCONSOLE_DRAW ConsoleDraw;
735 PUCHAR Src, Dest;
736 UINT32 SrcDelta, DestDelta, i, Offset;
737
738 if (!InbvCheckDisplayOwnership())
739 {
740 ConsoleDraw = (PCONSOLE_DRAW) MmGetSystemAddressForMdl(Irp->MdlAddress);
741 Src = (PUCHAR) (ConsoleDraw + 1);
742 SrcDelta = ConsoleDraw->SizeX * 2;
743 Dest = DeviceExtension->VideoMemory +
744 (ConsoleDraw->Y * DeviceExtension->Columns + ConsoleDraw->X) * 2;
745 DestDelta = DeviceExtension->Columns * 2;
746
747 for (i = 0; i < ConsoleDraw->SizeY; i++)
748 {
749 RtlCopyMemory(Dest, Src, SrcDelta);
750 Src += SrcDelta;
751 Dest += DestDelta;
752 }
753
754 Offset = (ConsoleDraw->CursorY * DeviceExtension->Columns) +
755 ConsoleDraw->CursorX;
756
757 _disable();
758 WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSLO);
759 WRITE_PORT_UCHAR (CRTC_DATA, Offset);
760 WRITE_PORT_UCHAR (CRTC_COMMAND, CRTC_CURSORPOSHI);
761 WRITE_PORT_UCHAR (CRTC_DATA, Offset >> 8);
762 _enable();
763 }
764
765 Irp->IoStatus.Information = 0;
766 Status = STATUS_SUCCESS;
767 }
768 break;
769
770 case IOCTL_CONSOLE_LOADFONT:
771 {
772 UINT32 CodePage = (UINT32)*(PULONG)Irp->AssociatedIrp.SystemBuffer;
773
774 if (!InbvCheckDisplayOwnership())
775 {
776 // Upload a font for the codepage if needed
777 ScrLoadFontTable(CodePage);
778 }
779
780 Irp->IoStatus.Information = 0;
781 Status = STATUS_SUCCESS;
782 }
783 break;
784
785 default:
786 Status = STATUS_NOT_IMPLEMENTED;
787 }
788
789 Irp->IoStatus.Status = Status;
790 IoCompleteRequest (Irp, IO_NO_INCREMENT);
791
792 return Status;
793 }
794
795 /*
796 * Module entry point
797 */
798 NTSTATUS NTAPI
799 DriverEntry (PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
800 {
801 PDEVICE_OBJECT DeviceObject;
802 NTSTATUS Status;
803 UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(L"\\Device\\BlueScreen");
804 UNICODE_STRING SymlinkName = RTL_CONSTANT_STRING(L"\\??\\BlueScreen");
805
806 DPRINT ("Screen Driver 0.0.6\n");
807
808 DriverObject->MajorFunction[IRP_MJ_CREATE] = ScrCreate;
809 DriverObject->MajorFunction[IRP_MJ_CLOSE] = ScrDispatch;
810 DriverObject->MajorFunction[IRP_MJ_READ] = ScrDispatch;
811 DriverObject->MajorFunction[IRP_MJ_WRITE] = ScrWrite;
812 DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL ] = ScrIoControl;
813
814 Status = IoCreateDevice (DriverObject,
815 sizeof(DEVICE_EXTENSION),
816 &DeviceName,
817 FILE_DEVICE_SCREEN,
818 FILE_DEVICE_SECURE_OPEN,
819 TRUE,
820 &DeviceObject);
821
822 if (!NT_SUCCESS(Status))
823 {
824 return Status;
825 }
826
827 Status = IoCreateSymbolicLink (&SymlinkName, &DeviceName);
828 if (NT_SUCCESS(Status))
829 DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
830 else
831 IoDeleteDevice (DeviceObject);
832 return Status;
833 }
834
835 /* EOF */