Følgende brugte jeg da jeg skulle finde ud af hvordan man skriver til skærmen, der står også noget om hvordan man skal læse fra skærmen, men jeg kan ikke fatte det. Måske kan nogen af jer:
There are 4 bitplanes, each holding a bit of the color number. Each bit in a plane is a pixel. The pixel at (0,0) is at offset 0, bit 7. Éach line is 640 pixel=640 bits=80 bytes. So (0,1) is at offset 80, bit 7.
If you have a line from (2,0)-(6,0) (bits 00111110) in color 10, (1010), the first byte of the bitplanes would look like this:
Plane 0: 00000000
Plane 1: 00111110
Plane 2: 00000000
Plane 3: 00111110
Now, what would happen if we put a white pixel at (0,0)?
Exactly. Bit 7 of all the planes becomes 1.
Now how to access the bitplanes. The VGA card has a 64k window at 0xA000:0, so not enough for each (64k) plane. Here the ports come in use. alle ports we need are in the VGA card a sort of array. To access an element, you first send the index, then the data, or send the index and read the data. For most ports the data port is at the address of the index port +1.
Example:
The index port of the Graphics Controller (part of the VGA interface) is at 0x3CE. The data port is at (index+1), so 0x3CF. If we want to write a 4 to index 2, we do: outportb(0x3CE, 2); /*index*/ outportb(0x3CF, 4); /* data */
But there is a way to do it with one port command. There's also a outport() 'array', and if the addressed port isn't a 16-bit one, it sends the lo byte to <address>, and the hight byte to <address>+1. Just what we need. The example becomes: outport(0x3CE, 0x0402); /* index in low byte, data in high byte */
Back to the bitplanes. To select which bitplanes are accessed by memory writes (not reads!), you can write to index 2 of the sequencer (at 0x3C4). If we want to put the line in the first example (from (2,0)-(6,0), color 10), we can do:
outport(0x3C4, 0x0A02); /* index 2 of the sequencer: select bitplanes 1,3 */
mem(0xA000:0) = 0x3E;
But everything at (0,0), (1,0) and (7,0) will be destroied, and worse, if there was already something at, say (2,0), in bitplane 0 or 2 (the ones we didn't select), the values remain there, creating some ugly color or so.
the VGA card has 4 internal 8 bit latches, one for each plane. If you do a read, no matter what will be returned to the processor, these latches are loaded with the bits from all planes, from the selected address.
Also there're so called write modes. These are the way the VGA card interprets the byte written to the VGA memory. You set the write mode with the mode register, index 5 from the Graphics Controller (0x3C#).
there are four modes:
Write mode 0
This is the default mode. With the bitmask register, index 8 from the Graphics Controller (0x3CE), you can select the bits used from the byte, the other bits are from the registers. Each byte you write will go to all bitplanes, unless you put a 1 in the corresponding bit in the Enable Set/Reset register, index 1 at the Graphics Controller (0x3CE). If you've put a 1 in that register, that plane will have the bit of the corresponing bit in Set/Reset register, index 0 at 0x3CE, and the CPU byte doesn't matter. So if you put 0x0F (all planes) in the Enable Set/Reset register, the desired color in the Set/Reset register, and the desired bits in the bitmask register, you can put pixel in that color, preserving other pixels in that byte. Example (againt the same line):
outport(0x3CE, 0x0005); /* Index 5 of the Grah Contr., set write mode 0 */
outport(0x3CE, 0x0F01); /* Index 1 of the Graph Contr., Enable Set/Reset for all planes */
outport(0x3CE, 0xA00); /* Index 0 of the Graph Contr., set with color 10 */
outport(0x3CE, 0x3E08); /* index 8 of the Graph Contr., set only bits 2-6 */
dummy = mem(0xA000:0); /* load latches */
mem(0xA000:0) := dummy; /* Byte doesn't matter */
Write mode 1
Nothing is done with the register or the CPU byte. All the latches are directly copied to the addressed byte. Usefull for screen to screen copy (e.g. scrolling)
Example to copy (0,0-7-0) to (8,0)-(15,0):
outport(0x3CE, 0x0105); /* Set write mode 1 */
Dummy = mem(0xA000:0); /* Load latches with pixels (0,0)-(7,0) */
mem(0xA000:1) = Dummy; /* Write latches to pixel (8,0)-(15,0) */
Write mode 2
The lower 4 bits of the CPU byte are the bits for each plane. If set for a plane, all bits selected with the Bitmask register are set, if clear, they're cleared. So you can do the same as in the example from mode 0, but with fewer instructions:
outport(0x3CE, 0x0205); /* Set write mode 2*/
outport(0x3CE, 0x3E08); /* Set color 10 */
mem(0xA000:0) = 0x3E; /* Set bits 2-6 */
There's also a Function select register (index 3, 0x3CE).
bits 3,4 indicate the way the bits that you want to change (selected by Bitmask register (write mode 0,2) or CPU byte (write mode 3)) are modified.
00 Not modified
01 ANDed with latches
02 ORed with latches
03 XOR with latches
For write mode 0 and 3 bits 0-2 indicate how many times the bits you want to change are shifted to right. Bits rolling out the byte appear on the left.
there are two read modes, for the byte returned to the CPU on a memory read. You select them with the same register as the write modes (index 5, 0x3CE), but in bit 3.
Read mode 0:
The byte from the planes selected with te Read Map Select register (index 4, 0x3CE) is returned.
Read mode 1:
Each bit in the CPU byte is set if the color in the Color Compare register (index 2, 0x3CE) is equal to the color of the corresponding bit. To exclude a bit of the color value, clear that bit the in Color Don't care register (index 7, 0x3CE), if set that bit from the color will be used.
Jeg håber at i kan forstå det, for jeg kan ikk.
