Fecha actual Lun Ago 19, 2019 12:38 am

Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Programación de los componentes de hardware más específicos de la plataforma PC.


Usuarios leyendo este tema: Ninguno

Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Mié Abr 24, 2013 6:28 pm

En este momento comienzo este tema para resolver todos los pasos a ejecutar para lograr implementar la funcionalidad de la VGA en modo texto 80x25x16 colores inicialmente, de manera formal.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Mié Abr 24, 2013 6:30 pm

Lo primero que debo tomar en cuenta es el hecho de que todos los puertos emulados, rangos de memoria capturados y funcionalidad asociada deben existir inicializados a valores realmente válidos en el mundo real, antes de comenzar a ejecutar el CPU. Igualmente, esto debe ser así para el resto de periféricos emulados (deben estar correctamente inicializados a valores "predeterminados" antes de comenzar la ejecución del CPU).
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Mié Abr 24, 2013 6:33 pm

Actualmente tengo los siguientes archivos que conforman el estado actual de la tarjeta VGA emulada:
Código: Seleccionar todo
VGA/Screen_Creation.js

VGA/Attribute_Controller/
 VGA/Attribute_Controller/Attribute_Controller_Registers.js

VGA/CRTC/
 VGA/CRTC/CRTC_Registers.js
 VGA/CRTC/Hardware_Text_Cursor.js

VGA/Graphics_Controller/
 VGA/Graphics_Controller/Graphics_Controller_Registers.js

VGA/Palette/
 VGA/Palette/VGA_Palette_Registers.js

VGA/Sequencer_Controller/
 VGA/Sequencer_Controller/Sequencer_Registers.js




En el archivo Memory/Memory_Controller/Memory_Regions.js también tenemos un mapeo para la memoria de video de la VGA estándar:
Código: Seleccionar todo
var _VRAM0=new ArrayBuffer(1024*256);
var VRAM0=new DataView(_VRAM0);

function VRAM0_Memory_Access()
{
 alert("VRAM0_Memory_Access");
}

    MemCtrl_MappedAreas[MemCtrl_Ctr]=new Object();
    MemCtrl_MappedAreas[MemCtrl_Ctr].name="VGA0";
    MemCtrl_MappedAreas[MemCtrl_Ctr].memBuff=VRAM0;
    MemCtrl_MappedAreas[MemCtrl_Ctr].baseAddr=0xA0000;
    MemCtrl_MappedAreas[MemCtrl_Ctr].baseAddrHI=0x0000;
    MemCtrl_MappedAreas[MemCtrl_Ctr].endAddr=0xBFFFF;
    MemCtrl_MappedAreas[MemCtrl_Ctr].endAddrHI=0x0000;
    MemCtrl_MappedAreas[MemCtrl_Ctr++].callback=VRAM0_Memory_Access;

Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Mié Abr 24, 2013 7:05 pm

Con todo lo anterior, tenemos todo lo necesario para capturar el acceso a la memoria de video y a los puertos I/O correspondientes a la tarjeta VGA (por ahora inicialmente en modo de color), y todo esto siendo capturado a nivel raíz.

Desde aquí, necesitamos ser capaces de comenzar a agregar la funcionalidad en cuestión de los puertos, aplicada cada vez que estos son accedidos (normalmente leídos, pero también devolviendo iteligente valores emulados al leerlos), y los efectos tanto en los planos de la memoria de video, como lo mostrado de hecho en la pantalla.

Lo primero concreto que necesitamos es, teniendo los valores de los registros VGA para el modo texto 80x25x16 colores, agregarlos manualmente uno por uno, pero no sin antes determinar qué funciones corresponden a estas, y si corresponden tablas, funciones directas, o simples valores de bits a leer entre funcionalidades.

Agregaremos todos estos registros y su funcionalidad en el orden del búfer de registros en el archivo de código fuente, e igualmente haremos lo mismo para inicializar los registros de la paleta de 768 colores.


Esta tarea puede que nos lleve varios días, pero la documentaremos aquí paso a paso, a medida que la vayamos resolviendo, desde este momento.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Mié Abr 24, 2013 7:09 pm

Comenzaremos usando la ya conocida configuración de todos los registros de la VGA, provenientes del siguiente archivo:

config_regs_EGA_t80x25x16.asm
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Mié Abr 24, 2013 7:13 pm

Es conveniente tener la referencia más básica sobre los registros VGA aquí:

Índice Principal de Registros VGA


Índice General de Registros VGA



Lo primero que debemos interpretar es el Registro de Salida Miscelánea, que aparentemente maneja, entre otras cosas, las direcciones de los puertos de Entrada/Salida, la resolución vertical, el acceso a la memoria de video, la selección de frecuencia de operación en MHz, el bit de página par/impar (estudiar) y la polaridad de sincronía horizontal y vertical (positiva o negativa, pero que es algo que no sé cómo implementar o lo que significa, y que deberé estudiar).
Código: Seleccionar todo
EGA_Text_80x25x16Gen__MiscOutputReg:
;General Register, Miscellaneous Output (W; 0x3C2):
;;
 ;
 ;  Bits:
 ;      0 -- I/O Address select
 ;           Color Emulation  (1) or Monochrome Emulation   (0)
 ;
 ;      1 -- Enable RAM
 ;           Enable video RAM (1) or Disable address decode (0)
 ;
 ;    2,3 -- Clock Select - ??? - I currently don't know where is the CS2 bit
 ;                                so I don't know what configuration is selected here
 ;           CS2  CS1  CS0  Clock
 ;           ---  ---  ---  -----
 ;            0    0    0   25.175 MHz    ;<--this one!!!!!!!
 ;            0    0    1   28.322 MHz
 ;         -------------------------------Below this line, consider Oak-specific values
 ;            0    1    0   65 MHz (external clock per true VGA standard)
 ;            0    1    1   44.9 MHz (undefined per true VGA standard)
 ;            1    0    0   14.161 MHz (derived from 28.322 MHz)
 ;            1    0    1   18 MHz (derived from 36 MHz)
 ;            1    1    0   40 MHz
 ;            1    1    1   36 MHz
 ;
 ;      4 -- Reserved
 ;            (0)
 ;
 ;      5 -- Page bit for odd/even
 ;           High 64K         (1) or Low 64K                (0) page of memory
 ;
 ;      6 -- Horizontal Sync Polarity
 ;           Negative         (1) or Posite Vertic. Retrace (0)
 ;
 ;      7 -- Vertical Sync Polarity
 ;           Positive         (0) or Negative Vert. Retrace (0)
 ;
 ;      Bits 7-6
 ;      --------
 ;            00 -- reserved
 ;            01 -- 400 lines     ;<-- This one!
 ;            10 -- 350 lines
 ;            11 -- 480 lines
 ;
 ;
 ;
 ;
 ;
 ;;
;  db 01100111b       ;0x67
db 0x67

Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Mié Abr 24, 2013 7:24 pm

Para escribir el Registro de Salida Miscelánea, simplemente hacemos esto:
Código: Seleccionar todo
 ;Escribir el Registro de Salida Miscelánea:
 ;;
  mov dx,0x3C2    ;Apuntar al registro
  lodsb           ;Cargar el valor desde la memoria
  out dx,al       ;Establecer el Registro con ese valor



Este puerto tiene el mismo puerto de escritura tanto para Mono como para Color. Nuestra configuración inicial asume modo Color.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Mié Abr 24, 2013 7:26 pm

Al escribir el Puerto de Salida Miscelánea, se desencadenarán varios efectos, que debemos especificar concretamente como puntos a recorrer, a continuación.

  • Seleccionar puertos VGA Mono o Color.

  • Activar o desactivar el acceso a la memoria de video.

  • Selección de la frecuencia del reloj.

  • Seleccionar página par/impar.

  • Indicar Polaridad de sincronía positiva y negativa.

  • Establecer la Resolución Vertical
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Mié Abr 24, 2013 7:34 pm

Dado que solamente tenemos un Registro de Salida Miscelánea, lo más conveniente de hacer será una función raíz de emulación de escritura del puerto 0x3C2, que primero cacheará el valor que se escriba en una variable de tipo BYTE interna, y después llame las funcionalidades anteriormente listadas, en forma de subrutinas encargadas de cachear valores de configuración en forma de banderas listas a ser usadas, como también efectos en el tamaño visible de la pantalla emulada.

De las cosas más inmediatamente utlilzables/relevantes, lo que no sé cómo manejar por ahora es la selección de página par/impar.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Mié Abr 24, 2013 7:39 pm

Así que para comenzar, crearemos el archivo:

VGA/MiscOutput/Miscellaneous_Output_Register.js

Para capturar el puerto 0x3C2 en modo escritura (de 8 bits):
Código: Seleccionar todo
var VGA_MiscOutput_Reg=new Uint8Array(1);

function VGA_Write_Miscellaneous_Output_Register(portNum, portSize, portMode, writeData)
{

}

IOPort_W_Fn_Ptr[0x3C2]=VGA_Write_Miscellaneous_Output_Register;

Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Jue Abr 25, 2013 2:43 pm

Dada la interconexión entre muchas de las configuraciones, y dado el hecho de que en este momento no tengo una idea 100% completa de dichas interconexiones, tendré que implementar el esqueleto de todos los registros y funciones que logre distinguir en varias pasadas.

La primera pasada, o primera capa, es simplemente recorrer todos los registros incluidos en el búfer de configuración de código fuente para los registros VGA (y más adelante implementar registros de solo lectura, de estado, y similares).

Hasta ahora he llegado hasta el Registro de Control de Características:
Código: Seleccionar todo
EGA_Text_80x25x16Gen__FeatureControlReg:
;General Register, Feature Control (RW; 0x3DA color; 0x3BA mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      3 -- Vertical Sync Select
 ;           Normal (0) or Logical OR of Vertical Sync End/Vertical Display Enable (1)
 ;
 ;      All other bits are Reserved
 ;
 ;;
;  db 00000000b       ;0x00
db 4h



Código: Seleccionar todo
var VGA_FeatureControl_Reg=new Uint8Array(1);
    VGA_FeatureControl_Reg[0]=parseInt("00000100b",2);  //4h; Check for validity




function VGA_Read_Feature_Control_Register(portNum, portSize, portMode, writeData)
{
 return VGA_FeatureControl_Reg[0];
}




function VGA_Write_Feature_Control_Register(portNum, portSize, portMode, writeData)
{
 //Save the value:
 ///
  VGA_FeatureControl_Reg[0]=writeData;

}






IOPort_R_Fn_Ptr[0x3CDA]=VGA_Read_Feature_Control_Register;
IOPort_W_Fn_Ptr[0x3DA]=VGA_Write_Feature_Control_Register;
IOPort_W_Fn_Ptr[0x3BA]=VGA_Write_Feature_Control_Register;

Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Jue Abr 25, 2013 3:09 pm

Ahora he llegado a incluir los valores de los 5 valores del Secuenciador:
Código: Seleccionar todo
EGA_Text_80x25x16SequencerRegs:
;Sequencer Register, Index 0, Reset Register (RW; 0x3C4=0; 0x3C5):
;;
 ;
 ;  Bits:
 ;      0 -- Asynchronous Reset
 ;           Operating  (1) or Reset   (0)
 ;
 ;      1 -- Synchronous Reset
 ;           Operating  (1) or Reset   (0)
 ;
 ;      All other bits are reserved
 ;;
  db 00000011b       ;0x03










;Sequencer Register, Index 1, Clocking Mode Register (RW; 0x3C4=1; 0x3C5):
;;
 ;
 ;  Bits:
 ;      0 -- 8/9 dot clocks
 ;           Eight dots (1) or Nine Clocks (0)
 ;
 ;      1 -- Reserved
 ;
 ;      2 -- Shift Load
 ;           If bit 4 is 0:
 ;           Reload serializers each char clock (0) or on every other (1)
 ;
 ;      3 -- Dot clock
 ;           Normal clock (0) or divide clock by 2 (1)
 ;
 ;      4 -- Shift 4
 ;           Reload serializers each char clock (0) or on each fourth (1)
 ;
 ;      5 -- Screen off
 ;           Video screen off and max mem bandwidth to CPU (1) or Normal operation (0)
 ;
 ;    6-7 -- Reserved
 ;;
  db 00000000b       ;0x00










;Sequencer Register, Index 2, Map Mask Register (RW; 0x3C4=2; 0x3C5):
;;
 ;
 ;  Bits:
 ;    0-3 -- Map mask
 ;           Enable (1) or disable writes (0) to the corresponding map, 0-3, with bits 0-3
 ;
 ;    All other bits are reserved.
 ;;
  db 00000011b       ;0x03










;Sequencer Register, Index 3, Character Map Select Register (RW; 0x3C4=3; 0x3C5):
;;
 ;
 ;  Bits:
 ;    4,1,0 -- Character Map Select B
 ;             000
 ;             1st 8K of Map 2
 ;
 ;    5,3,0 -- Character Map Select A
 ;             000
 ;             1st 8K of Map 2
 ;             NOTE: The value of Character Map Select A == Character Map Select B,
 ;                   so we will ignore Character Map Select A and use
 ;                   Character Map Select B configuration.
 ;
 ;    All other bits are reserved.
 ;;
  db 00000000b       ;0x00










;Sequencer Register, Index 4, Memory Mode Register (RW; 0x3C4=4; 0x3C5):
;;
 ;
 ;  Bits:
 ;      0 -- Reserved
 ;
 ;      1 -- Extended Memory (1)
 ;           0 -- No extended memory present (less than 64K)
 ;           1 -- Extended memory present (more than 64K; use 256K;
 ;                also enables the Character Map Select feature)
 ;
 ;      2 -- Odd/Even (1)
 ;           0 -- Direct even addresses to maps 0 and 2 and odd addresses
 ;                to maps 1 and 3.
 ;           1 -- If bit 3 is 0: make the CPU access data sequentially
 ;                within a bit map.
 ;
 ;      3 -- Chain-4 (1)
 ;           0 -- If bit 2 is 1, make the CPU access data sequentially within
 ;                a bit map by the Map Mask Register.
 ;           1 -- Make the two lower address bits to select the map that will
 ;                be accessed.
 ;
 ;
 ;    4-7 -- Reserved
 ;;
;  db 00000010b       ;0x02
;db 7   ;in text mode causes planes to be badly selected and all
        ;letters have a different color.
db 2



Código: Seleccionar todo
var VGA_Sequencer_DataReg=new Uint8Array(5);
    VGA_Sequencer_DataReg[0]=parseInt("00000011b",2); //0x03; Reset Register
    VGA_Sequencer_DataReg[1]=parseInt("00000000b",2); //0x00; Clocking Mode
    VGA_Sequencer_DataReg[2]=parseInt("00000011b",2); //0x03; Map Mask
    VGA_Sequencer_DataReg[3]=parseInt("00000000b",2); //0x00; Character Map Select
    VGA_Sequencer_DataReg[4]=parseInt("00000010b",2); //0x02; Memory Mode

var VGA_Sequencer_DataReg_OnWriteFunctions=new Array();
    VGA_Sequencer_DataReg_OnWriteFunctions[0]=VGA_Sequencer_DataReg_0x00_ManageResetRegister;
    VGA_Sequencer_DataReg_OnWriteFunctions[1]=VGA_Sequencer_DataReg_0x01_ManageClockingMode;
    VGA_Sequencer_DataReg_OnWriteFunctions[2]=VGA_Sequencer_DataReg_0x02_ManageMapMask;
    VGA_Sequencer_DataReg_OnWriteFunctions[3]=VGA_Sequencer_DataReg_0x03_ManageCharacterMapSelect;
    VGA_Sequencer_DataReg_OnWriteFunctions[4]=VGA_Sequencer_DataReg_0x04_ManageMemoryMode;




var VGA_Sequencer_IdxReg=new Uint8Array(1);

function VGA_Sequencer_ReadIdxReg(portNum, portSize, portMode, writeData)
{
 return VGA_Sequencer_IdxReg[0];
}



function VGA_Sequencer_WriteIdxReg(portNum, portSize, portMode, writeData)
{
 VGA_Sequencer_IdxReg[0]=writeData;
}



function VGA_Sequencer_ReadDataReg(portNum, portSize, portMode, writeData)
{
 //Do not address indexed registers beyond the standard
 //known limit:
 ///
  if(VGA_Sequencer_IdxReg[0]>=VGA_Sequencer_DataReg.byteLength)return 0;


 //If we got a valid index number,
 //then return the value in the emulated
 //register set at that index:
 ///
  return VGA_Sequencer_DataReg[VGA_Sequencer_IdxReg[0]];
}



function VGA_Sequencer_WriteDataReg(portNum, portSize, portMode, writeData)
{
 //Do not address indexed registers beyond the standard
 //known limit:
 ///
  if(VGA_Sequencer_IdxReg[0]>=VGA_Sequencer_DataReg.byteLength)return;


 //If we got a valid index number,
 //then cache the value in the emulated
 //register set at that index:
 ///
  VGA_Sequencer_DataReg[VGA_Sequencer_IdxReg[0]]=writeData;


 //Finally, call the associated function to actually
 //apply the effects represented in the bit set we
 //received:
 ///
  VGA_Sequencer_DataReg_OnWriteFunctions[VGA_Sequencer_IdxReg[0]](writeData);
}




IOPort_R_Fn_Ptr[0x3C4]=VGA_Sequencer_ReadIdxReg;
IOPort_R_Fn_Ptr[0x3C5]=VGA_Sequencer_ReadDataReg;

IOPort_W_Fn_Ptr[0x3C4]=VGA_Sequencer_WriteIdxReg;
IOPort_W_Fn_Ptr[0x3C5]=VGA_Sequencer_WriteDataReg;

Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Jue Abr 25, 2013 3:15 pm

En este momento he llegado a pensar que una vez que domine todos los registros VGA y sus efectos, lo correcto será poner los valores de todos esos registros a valores que representen un estado de desactivación.

Sería bueno preguntar cuál es el estado inicial de todos los registros VGA, o si simplemente está desactivado el acceso a la memoria y en un estado de reseteo sincrónico y asincrónico.

Debo preguntar (por ejemplo en Stack Overflow) si ese es el estado predeterminado de esos registros y si estando en reseteo sincrónico y asincrónico y con el acceso a la memoria de video desactivada, y con la pantalla apagada con los registros, es posible configurar el resto de registros de forma ordenada para su inicialización.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Jue Abr 25, 2013 3:33 pm

Ahora me preparo para implementar los registros CRTC (25), Gráficos (9) y de Atributos (21).

Primero los registros CRTC, para lo que necesito descansar un poco.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Jue Abr 25, 2013 4:55 pm

Esta es mi implementación inicial de los registros CRTC:
Código: Seleccionar todo
var VGA_CRTC_DataReg=new Uint8Array(25);
    VGA_CRTC_DataReg[0] =parseInt("01011111b",2); //0x5F; Horizontal Total
    VGA_CRTC_DataReg[1] =parseInt("01001111b",2); //0x4F; Horizontal Display Enable End
    VGA_CRTC_DataReg[2] =parseInt("01010000b",2); //0x50; Start Horizontal Blanking
    VGA_CRTC_DataReg[3] =parseInt("10000010b",2); //0x82; End Horizontal Blanking
    VGA_CRTC_DataReg[4] =parseInt("01010100b",2); //0x54; Start Horizontal Retrace Pulse
    VGA_CRTC_DataReg[5] =parseInt("10000000b",2); //0x80; End Horizontal Retrace Pulse
    VGA_CRTC_DataReg[6] =parseInt("10111111b",2); //0xBF; Vertical Total
    VGA_CRTC_DataReg[7] =parseInt("00001111b",2); //0x1F; Overflow
    VGA_CRTC_DataReg[8] =parseInt("00000000b",2); //0x00; Preset Row Scan
    VGA_CRTC_DataReg[9] =parseInt("01001111b",2); //0x4F; Maximum Scan Line
    VGA_CRTC_DataReg[10]=parseInt("00001110b",2); //0x0E; Cursor Start
    VGA_CRTC_DataReg[11]=parseInt("00001111b",2); //0x0F; Cursor End
    VGA_CRTC_DataReg[12]=parseInt("00000000b",2); //0x00; Start Address High
    VGA_CRTC_DataReg[13]=parseInt("00000000b",2); //0x00; Start Address Low
    VGA_CRTC_DataReg[14]=parseInt("00000000b",2); //0x00; Cursor Location High
    VGA_CRTC_DataReg[15]=parseInt("00000000b",2); //0x00; Cursor Location Low
    VGA_CRTC_DataReg[16]=parseInt("10011100b",2); //0x9C; Vertical Retrace Start
    VGA_CRTC_DataReg[17]=parseInt("00001110b",2); //0x0E; Vertical Retrace End
    VGA_CRTC_DataReg[18]=parseInt("10001111b",2); //0x8F; Vertical Display Enable End
    VGA_CRTC_DataReg[19]=parseInt("00101000b",2); //0x28; Offset
    VGA_CRTC_DataReg[20]=parseInt("00011111b",2); //0x1F; Underline Location
    VGA_CRTC_DataReg[21]=parseInt("10010110b",2); //0x96; Start Vertical Blanking
    VGA_CRTC_DataReg[22]=parseInt("10111001b",2); //0xB9; End Vertical Blanking
    VGA_CRTC_DataReg[23]=parseInt("10100011b",2); //0xA3; CRTC Mode Control
    VGA_CRTC_DataReg[24]=parseInt("11111111b",2); //0xFF; Line Compare

var VGA_CRTC_DataReg_OnWriteFunctions=new Array();
    VGA_CRTC_DataReg_OnWriteFunctions[0] =VGA_CRTC_DataReg_0x00_ManageHorizontalTotal;
    VGA_CRTC_DataReg_OnWriteFunctions[1] =VGA_CRTC_DataReg_0x01_ManageHorizontalDisplayEnable;
    VGA_CRTC_DataReg_OnWriteFunctions[2] =VGA_CRTC_DataReg_0x02_ManageStartHorizontalBlanking;
    VGA_CRTC_DataReg_OnWriteFunctions[3] =VGA_CRTC_DataReg_0x03_ManageEndHorizontalBlanking;
    VGA_CRTC_DataReg_OnWriteFunctions[4] =VGA_CRTC_DataReg_0x04_ManageHorizontalRetracePulse;
    VGA_CRTC_DataReg_OnWriteFunctions[5] =VGA_CRTC_DataReg_0x05_ManageEndHorizontalRetracePulse;
    VGA_CRTC_DataReg_OnWriteFunctions[6] =VGA_CRTC_DataReg_0x06_ManageVerticalTotal;
    VGA_CRTC_DataReg_OnWriteFunctions[7] =VGA_CRTC_DataReg_0x07_ManageOverflow;
    VGA_CRTC_DataReg_OnWriteFunctions[8] =VGA_CRTC_DataReg_0x08_ManagePresetRowScan;
    VGA_CRTC_DataReg_OnWriteFunctions[9] =VGA_CRTC_DataReg_0x09_ManageMaximumScanLine;
    VGA_CRTC_DataReg_OnWriteFunctions[10]=VGA_CRTC_DataReg_0x0A_ManageCursorStart;
    VGA_CRTC_DataReg_OnWriteFunctions[11]=VGA_CRTC_DataReg_0x0B_ManageCursorEnd;
    VGA_CRTC_DataReg_OnWriteFunctions[12]=VGA_CRTC_DataReg_0x0C_ManageStartAddressHigh;
    VGA_CRTC_DataReg_OnWriteFunctions[13]=VGA_CRTC_DataReg_0x0D_ManageStartAddressLow;
    VGA_CRTC_DataReg_OnWriteFunctions[14]=VGA_CRTC_DataReg_0x0E_ManageCursorLocationHigh;
    VGA_CRTC_DataReg_OnWriteFunctions[15]=VGA_CRTC_DataReg_0x0F_ManageCursorLocationLow;
    VGA_CRTC_DataReg_OnWriteFunctions[16]=VGA_CRTC_DataReg_0x10_ManageVerticalRetraceStart;
    VGA_CRTC_DataReg_OnWriteFunctions[17]=VGA_CRTC_DataReg_0x11_ManageVerticalRetraceEnd;
    VGA_CRTC_DataReg_OnWriteFunctions[18]=VGA_CRTC_DataReg_0x12_ManageVerticalDisplayEnableEnd;
    VGA_CRTC_DataReg_OnWriteFunctions[19]=VGA_CRTC_DataReg_0x13_ManageOffset;
    VGA_CRTC_DataReg_OnWriteFunctions[20]=VGA_CRTC_DataReg_0x14_ManageUnderlineLocation;
    VGA_CRTC_DataReg_OnWriteFunctions[21]=VGA_CRTC_DataReg_0x15_ManageStartVerticalBlanking;
    VGA_CRTC_DataReg_OnWriteFunctions[22]=VGA_CRTC_DataReg_0x16_ManageEndVerticalBlanking;
    VGA_CRTC_DataReg_OnWriteFunctions[23]=VGA_CRTC_DataReg_0x17_ManageCRTCModeControl;
    VGA_CRTC_DataReg_OnWriteFunctions[24]=VGA_CRTC_DataReg_0x18_ManageLineCompare;

var VGA_CRTC_IdxReg=new Uint8Array(1);

function VGA_CRTC_ReadIdxReg(portNum, portSize, portMode, writeData)
{
 return VGA_CRTC_IdxReg[0];
}

function VGA_CRTC_WriteIdxReg(portNum, portSize, portMode, writeData)
{
 VGA_CRTC_IdxReg[0]=writeData;
}



function VGA_CRTC_ReadDataReg(portNum, portSize, portMode, writeData)
{
 //Do not address indexed registers beyond the standard
 //known limit:
 ///
  if(VGA_CRTC_IdxReg[0]>=VGA_CRTC_DataReg.byteLength)return 0;


 //If we got a valid index number,
 //then return the value in the emulated
 //register set at that index:
 ///
  return VGA_CRTC_DataReg[VGA_CRTC_IdxReg[0]];
}

function VGA_CRTC_WriteDataReg(portNum, portSize, portMode, writeData)
{
 //Do not address indexed registers beyond the standard
 //known limit:
 ///
  if(VGA_CRTC_IdxReg[0]>=VGA_CRTC_DataReg.byteLength)return;


 //If we got a valid index number,
 //then cache the value in the emulated
 //register set at that index:
 ///
  VGA_CRTC_DataReg[VGA_CRTC_IdxReg[0]]=writeData;


 //Finally, call the associated function to actually
 //apply the effects represented in the bit set we
 //received:
 ///
  VGA_CRTC_DataReg_OnWriteFunctions[VGA_CRTC_IdxReg[0]](writeData);
}




IOPort_R_Fn_Ptr[0x3B4]=VGA_CRTC_ReadIdxReg;
IOPort_R_Fn_Ptr[0x3B5]=VGA_CRTC_ReadDataReg;

IOPort_W_Fn_Ptr[0x3B4]=VGA_CRTC_WriteIdxReg;
IOPort_W_Fn_Ptr[0x3B5]=VGA_CRTC_WriteDataReg;




IOPort_R_Fn_Ptr[0x3D4]=VGA_CRTC_ReadIdxReg;
IOPort_R_Fn_Ptr[0x3D5]=VGA_CRTC_ReadDataReg;

IOPort_W_Fn_Ptr[0x3D4]=VGA_CRTC_WriteIdxReg;
IOPort_W_Fn_Ptr[0x3D5]=VGA_CRTC_WriteDataReg;



Código: Seleccionar todo
EGA_Text_80x25x16CRTCRegs:
;CRTC Controller, Index 0, Horizontal Total (RW; 0x3D4=0 color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-7 -- Number of horizontal characters MINUS 5
 ;;
;  db 95              ;0x5F
db 0x5F


;from 0x5F to 61h??????






;CRTC Controller, Index 1, Horizontal Display-Enable End (RW; 0x3D4=1 color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-7 -- Number of total displayed characters MINUS 1
 ;;
;  db 79              ;0x4F
db 0x4F

;from 4fh???? to 50h?????







;CRTC Controller, Index 2, Start Horizontal Blanking Register (RW; 0x3D4=2 color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-7 -- Number of total displayed characters MINUS 1
 ;;
;  db 01010000b       ;0x50
db 0x50









;CRTC Controller, Index 3, End Horizontal Blanking Register (RW; 0x3D4=3 color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-4 -- End Horizontal Blanking (2 here)
 ;
 ;      5,6 -- Display Enable Skew Control (0 here)
 ;
 ;        7 -- Test bit; must be 1
 ;;
;  db 10000010b       ;0x82
db 0x82









;CRTC Controller, Index 4, Start Horizontal Retrace Pulse (RW; 0x3D4=4 color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-7 -- Start Horizontal Retrace Pulse (84 here)
 ;;
;  db 01010101b       ;0x55
;db 0x55
db 0x54
;From 47h to 5h???







;CRTC Controller, Index 5, End Horizontal Retrace Pulse (RW; 0x3D4=5 color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-4 -- End Horizontal Retrace
 ;      5-6 -- Horizontal Retrace Delay
 ;        7 -- End Horizontal Blanking, Bit 5
 ;;
;  db 10000001b       ;0x81
;db 0x81
db 0x80








;CRTC Controller, Index 6, Vertical Total (RW; 0x3D4=6 color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-7 -- 8 lower bits of number of horizontal raster scans MINUS 2
 ;;
;  db 10111111b       ;0xBF
db 0xBF









;CRTC Controller, Index 7, Overflow (RW; 0x3D4=7 color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0 -- bit 8 of vertical total, reg idx 0x06
 ;      1 -- bit 8 of vertical total, reg idx 0x12
 ;      2 -- bit 8 of vertical total, reg idx 0x10
 ;      3 -- bit 8 of vertical total, reg idx 0x15
 ;      4 -- bit 8 of vertical total, reg idx 0x18
 ;      5 -- bit 9 of vertical total, reg idx 0x06
 ;      6 -- bit 9 of vertical total, reg idx 0x12
 ;      7 -- bit 9 of vertical total, reg idx 0x10
 ;;
;  db 00011111b       ;0x1F
db 0x1F









;CRTC Controller, Index 8, Preset Row Scan (RW; 0x3D4=8 color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-4 -- preset row scan
 ;      5-6 -- byte panning control
 ;      7 -- reserved
 ;;
  db 00000000b       ;0x00










;CRTC Controller, Index 9, Maximum Scan Line (RW; 0x3D4=9 color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-4 -- maximum scan line
 ;        5 -- start vertical blank
 ;        6 -- line compare
 ;        7 -- 200 to 400 line conversion
 ;;
;  db 01001111b       ;0x4F
;db 0xC7
db 0x4F

;NOTE: This can duplicate the size of the font,
;      and the maximum scan line field could be
;      useful for instance for 8x8 modes and to be
;      able to use up to 32-line-height fonts, thus
;      the bit range 0-4, for 00000b (0) to 11111b (31).






;CRTC Controller, Index 10, Cursor Start (RW; 0x3D4=0x0A color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-4 -- cursor start
 ;        5 -- cursor off
 ;      6-7 -- reserved
 ;;
;  db 00001110b       ;0x0E
;db 6
;db 0xD
db 0xE







;CRTC Controller, Index 11, Cursor End (RW; 0x3D4=0x0B color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-4 -- cursor end
 ;      5-6 -- cursor skew
 ;        7 -- reserved
 ;;
;  db 00001111b       ;0x0F
;db 7
;db 0xE
db 0xF








;CRTC Controller, Index 12, Start Address High (RW; 0x3D4=0x0C color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-7 -- start address high
 ;;
  db 00000000b       ;0x00







;seems to affect horizontally, but has to do with vertical retrace



;CRTC Controller, Index 13, Start Address Low (RW; 0x3D4=0x0D color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-7 -- start address low
 ;;
  db 00000000b       ;0x00


;seems to affect horizontally, but has to do with vertical retrace







;CRTC Controller, Index 14, Cursor Location High (RW; 0x3D4=0x0E color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-7 -- cursor high
 ;;
  db 00000000b       ;0x00










;CRTC Controller, Index 15, Cursor Location Low (RW; 0x3D4=0x0F color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-7 -- cursor low
 ;;
  db 00000000b       ;0x00









;CRTC Controller, Index 16, Vertical Retrace Start (W; 0x3D4=0x10 color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-7 - lower 8 bits of vertical retrace pulse start position
 ;;
;  db 156             ;0x9C
db 0x9C


;From???? 0x90?? to 0xBF?






;CRTC Controller, Index 17, Vertical Retrace End (W; 0x3D4=0x11 color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-3 -- vertical retrace end
 ;        4 -- clear vertical interrupt
 ;        5 -- enable vertical interrupt
 ;        6 -- select 5 refresh cycles
 ;        7 -- protect registers 0 to 7: True (1) or False (0)
 ;;
;  db 00001110b       ;0x0E
db 0x0E


;affects visually more the upper line of the screen (bits 0-3)






;CRTC Controller, Index 18, Vertical Display Enable End (RW; 0x3D4=0x12 color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-7 -- vertical display enable end
 ;;
;  db 143             ;0x8F
db 0x8F

;from 8fh?? or even 0, to ffh (c0h is funny) -- see below.

;lower 8 bits of 10 bits that indicate the number of lines to show
;vertically before showing nothing.
;Bits 8 and 9 are in the overflow register bits 1 and 6 respectively,
;so here we have an overal value of 399 (as in 400 for 640x400 mode :) ).
;
;FROM HERE WE ARE FIRST STARTING TO UNDERSTAND HOW TO CONTROL
;SOME ASPECTS OF RESOLUTION AND OF SHOWING IT.
;
;And if we try to show more lines than existing, for instance
;FFh here for 80x25 text mode, the screen could scroll with a
;bad aspect.....







;CRTC Controller, Index 19, Offset (RW; 0x3D4=0x13 color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-7 -- offset
 ;;
;  db 40              ;0x28
db 0x28









;CRTC Controller, Index 20, Underline Location (RW; 0x3D4=0x14 color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-4 -- underline location
 ;        5 -- count by 4
 ;        6 -- double word mode
 ;        7 -- reserved
 ;;
;  db 00011111b       ;0x1F
db 0x1F


;NOTE: bits 0-4 could be associated with the maximum scan line field
;      in other register (I changed this alone, to 0, and didn't seem
;      to have any visual effect).

;      Bit 5 used alone (count by 4) is very interesting in text mode.
;      When enabled, it causes every character cell to be repeated
;      4 times (except the first character leftmost, repeated 3 times).
;      It also repeats the cursor, in 3 or 4 consecutive character cells.
;
;      Bit 6, double word mode, seems to use 4 bytes for a single
;      character in screen, and it also alters its display, in text mode,
;      to an almost unintelligible form, and also seems to duplicate
;      some content in the screen in 2 halves.




;CRTC Controller, Index 21, Start Vertical Blanking (RW; 0x3D4=0x15 color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-7 -- start vertical blank -- lower 8 bits of 10-bit register
 ;;
;  db 150             ;0x96
db 0x96


;NOTE: This field accepted 0 without trouble, without
;taking bits 8 and 9 in the overflow reg.
;
;Just caused a hole in some text lines past half the screen.






;CRTC Controller, Index 22, End Vertical Blanking (RW; 0x3D4=0x16 color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-7 -- end vertical blank
 ;;
;  db 185             ;0xB9
db 0xB9









;CRTC Controller, Index 23, CRTC Mode Control (RW; 0x3D4=0x17 color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0 -- compatibility mode support
 ;      1 -- select row scan counter
 ;      2 -- horizontal retrace select
 ;      3 -- count by two
 ;      4 -- reserved
 ;      5 -- address wrap
 ;      6 -- word mode (0) or byte mode (1)
 ;      7 -- hardware reset
 ;;
;  db 10100011b       ;0xA3
db 0xA3

;This is another interesting register,
;specially bit 6 and bit 3, the most visual ones.

;The count by 2 field is like the count by 4, only that
;a character is shown 2 times consecutively instead of 4.
;The leftmost screen characters are only shown once.

;NOTE: This count by 2 bit has precedence over the count by 4
;      bit in other register. If count by 2 is enabled,
;      then count by 4 has no visual effect.






;CRTC Controller, Index 24, Line Compare (RW; 0x3D4=0x18 color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-7 -- lower 8 bits of compare target.
 ;             Bit 8 is in Overflow register index 7.
 ;             Bit 9 is in Maximum Scan Line register index 9.
 ;;
  db 11111111b       ;0xFF


;NOTE: Changing this very register to 0 didn't seem to have any effect.

Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Jue Abr 25, 2013 5:23 pm

He implementado el esqueleto de los registros gráficos:
Código: Seleccionar todo
var VGA_GraphCtrl_DataReg=new Uint8Array(9);
    VGA_GraphCtrl_DataReg[0] =parseInt("00000000b",2); //0x00; Set/Reset
    VGA_GraphCtrl_DataReg[1] =parseInt("00000000b",2); //0x00; Enable Set/Reset
    VGA_GraphCtrl_DataReg[2] =parseInt("00000000b",2); //0x00; Color Compare
    VGA_GraphCtrl_DataReg[3] =parseInt("00000000b",2); //0x00; Data Rotate
    VGA_GraphCtrl_DataReg[4] =parseInt("00000000b",2); //0x00; Read Map Select
    VGA_GraphCtrl_DataReg[5] =parseInt("00010000b",2); //0x10; Graphics Mode
    VGA_GraphCtrl_DataReg[6] =parseInt("00001110b",2); //0x0E; Miscellaneous
    VGA_GraphCtrl_DataReg[7] =parseInt("00000000b",2); //0x00; Color Don't Care
    VGA_GraphCtrl_DataReg[8] =parseInt("11111111b",2); //0xFF; Bit Mask

var VGA_GraphCtrl_DataReg_OnWriteFunctions=new Array();
    VGA_GraphCtrl_DataReg_OnWriteFunctions[0]=VGA_GraphCtrl_DataReg_0x00_ManageSetReset;
    VGA_GraphCtrl_DataReg_OnWriteFunctions[1]=VGA_GraphCtrl_DataReg_0x01_ManageEnableSetReset;
    VGA_GraphCtrl_DataReg_OnWriteFunctions[2]=VGA_GraphCtrl_DataReg_0x02_ManageColorCompare;
    VGA_GraphCtrl_DataReg_OnWriteFunctions[3]=VGA_GraphCtrl_DataReg_0x03_ManageDataRotate;
    VGA_GraphCtrl_DataReg_OnWriteFunctions[4]=VGA_GraphCtrl_DataReg_0x04_ManageReadMapSelect;
    VGA_GraphCtrl_DataReg_OnWriteFunctions[5]=VGA_GraphCtrl_DataReg_0x05_ManageGraphicsMode;
    VGA_GraphCtrl_DataReg_OnWriteFunctions[6]=VGA_GraphCtrl_DataReg_0x06_ManageMiscellaneous;
    VGA_GraphCtrl_DataReg_OnWriteFunctions[7]=VGA_GraphCtrl_DataReg_0x07_ManageColorDontCare;
    VGA_GraphCtrl_DataReg_OnWriteFunctions[8]=VGA_GraphCtrl_DataReg_0x08_ManageBitMask;

var VGA_GraphCtrl_IdxReg=new Uint8Array(1);

function VGA_GraphCtrl_ReadIdxReg(portNum, portSize, portMode, writeData)
{
 return VGA_GraphCtrl_IdxReg[0];
}

function VGA_GraphCtrl_WriteIdxReg(portNum, portSize, portMode, writeData)
{
 VGA_GraphCtrl_IdxReg[0]=writeData;
}



function VGA_GraphCtrl_ReadDataReg(portNum, portSize, portMode, writeData)
{
 //Do not address indexed registers beyond the standard
 //known limit:
 ///
  if(VGA_GraphCtrl_IdxReg[0]>=VGA_GraphCtrl_DataReg.byteLength)return 0;


 //If we got a valid index number,
 //then return the value in the emulated
 //register set at that index:
 ///
  return VGA_GraphCtrl_DataReg[VGA_GraphCtrl_IdxReg[0]];
}

function VGA_GraphCtrl_WriteDataReg(portNum, portSize, portMode, writeData)
{
 //Do not address indexed registers beyond the standard
 //known limit:
 ///
  if(VGA_GraphCtrl_IdxReg[0]>=VGA_GraphCtrl_DataReg.byteLength)return;


 //If we got a valid index number,
 //then cache the value in the emulated
 //register set at that index:
 ///
  VGA_GraphCtrl_DataReg[VGA_GraphCtrl_IdxReg[0]]=writeData;


 //Finally, call the associated function to actually
 //apply the effects represented in the bit set we
 //received:
 ///
  VGA_GraphCtrl_DataReg_OnWriteFunctions[VGA_GraphCtrl_IdxReg[0]](writeData);
}




IOPort_R_Fn_Ptr[0x3CE]=VGA_GraphCtrl_ReadIdxReg;
IOPort_R_Fn_Ptr[0x3CF]=VGA_GraphCtrl_ReadDataReg;

IOPort_W_Fn_Ptr[0x3CE]=VGA_GraphCtrl_WriteIdxReg;
IOPort_W_Fn_Ptr[0x3CF]=VGA_GraphCtrl_WriteDataReg;



Código: Seleccionar todo
EGA_Text_80x25x16GraphicsRegs:
;Graphics Controller Register, Index 0, Set/Reset (RW; 0x3CE=0; 0x3CF):
;;
 ;
 ;  Bits:
 ;      0-3 -- Set/Reset
 ;
 ;      All other bits are reserved. Set to 0; undefined on read.
 ;;
  db 00000000b       ;0x00










;Graphics Controller Register, Index 1, Enable Set/Reset (RW; 0x3CE=1; 0x3CF):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-3 -- Enable Set/Reset
 ;             1 -- If write mode is 0, and the bit for the map is 1 here,
 ;                  write memory address with the value of the Set/Reset register.
 ;
 ;             0 -- If write mode is 0, and the bit for the map is 0 here,
 ;                  write memory address with the value of system CPU.
 ;
 ;      All other bits are reserved. Set to 0; undefined on read.
 ;;
  db 00000000b       ;0x00










;Graphics Controller Register, Index 2, Color Compare (RW; 0x3CE=2; 0x3CF):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-3 -- Color compare
 ;             Color Compare Map n, where n is the bit position
 ;
 ;      All other bits are reserved. Set to 0; undefined on read.
 ;;
  db 00000000b       ;0x00










;Graphics Controller Register, Index 3, Data Rotate (RW; 0x3CE=3; 0x3CF):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-2 -- Data rotate
 ;             Number of bits to right-rotate CPU data (0 here)
 ;
 ;      3,4 -- Function select
 ;             00 -- unmodified   <-- this one!!!!!!
 ;             01 -- AND data with latch
 ;             10 -- OR data with latch
 ;             11 -- XOR data with latch
 ;
 ;      All other bits are reserved. Set to 0; undefined on read.
 ;;
  db 00000000b       ;0x0










;Graphics Controller Register, Index 4, Read Map Select (RW; 0x3CE=4; 0x3CF):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-1 -- Read Map Select
 ;             Select maps 0 to 3 for system read operations (map 0 here)
 ;
 ;
 ;      All other bits are reserved. Set to 0; undefined on read.
 ;;
  db 00000000b       ;0x00










;Graphics Controller Register, Index 5, Graphics Mode (RW; 0x3CE=5; 0x3CF):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-1 -- Write Mode
 ;             Select write mode 0 to 3 (0 here)
 ;
 ;        2 -- Reserved, undefined on read
 ;
 ;        3 -- Read Type
 ;
 ;        4 -- Odd/Even
 ;
 ;        5 -- Shift Register
 ;
 ;        6 -- 256 Color Mode
 ;
 ;        7 -- Reserved
 ;;
;  db 00010000b       ;0x10
db 0x10










;Graphics Controller Register, Index 6, Miscellaneous (RW; 0x3CE=6; 0x3CF):
;;
 ;
 ;
 ;
 ;  Bits:
 ;        0 -- Graphics Mode
 ;             Graphics Mode (1) or Text Mode (0)
 ;
 ;        1 -- Odd/Even
 ;
 ;      2,3 -- Memory Map (3 here)
 ;                    Map 0 -- 0xA0000-0xBFFFF
 ;                    Map 1 -- 0xA0000-0xAFFFF
 ;                    Map 2 -- 0xB0000-0xBFFFF
 ;                    Map 3 -- 0xB8000-0xBFFFF
 ;
 ;      4-7 -- Reserved
 ;;
;  db 00001110b       ;0x0E
db 0x0E









;Graphics Controller Register, Index 7, Color Don't Care (RW; 0x3CE=7; 0x3CF):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-3 -- For each bit, if 0, don't participate in color
 ;             compare cycle; if 1 participate in it for that map.
 ;;
;  db 00000000b       ;0x00


db 0x00







;Graphics Controller Register, Index 8, Bit Mask (RW; 0x3CE=8; 0x3CF):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-7 -- Bit mask
 ;;
;  db 11111111b       ;0xFF

db 0xFF

Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Jue Abr 25, 2013 6:04 pm

Este es el esqueleto de los Registros del Controlador de Atributos:
Código: Seleccionar todo
var VGA_AttribCtrl_nDataRegs=21;
var VGA_AttribCtrl_DataReg=new Uint8Array(VGA_AttribCtrl_nDataRegs);
    VGA_AttribCtrl_DataReg[0] =0x00; //0x00; Palette 0
    VGA_AttribCtrl_DataReg[1] =0x01; //0x01; Palette 1
    VGA_AttribCtrl_DataReg[2] =0x02; //0x02; Palette 2
    VGA_AttribCtrl_DataReg[3] =0x03; //0x03; Palette 3
    VGA_AttribCtrl_DataReg[4] =0x04; //0x04; Palette 4
    VGA_AttribCtrl_DataReg[5] =0x05; //0x05; Palette 5
    VGA_AttribCtrl_DataReg[6] =0x14; //0x14; Palette 6
    VGA_AttribCtrl_DataReg[7] =0x07; //0x07; Palette 7
    VGA_AttribCtrl_DataReg[8] =0x38; //0x38; Palette 8
    VGA_AttribCtrl_DataReg[9] =0x39; //0x39; Palette 9
    VGA_AttribCtrl_DataReg[10]=0x3A; //0x3A; Palette 10
    VGA_AttribCtrl_DataReg[11]=0x3B; //0x3B; Palette 11
    VGA_AttribCtrl_DataReg[12]=0x3C; //0x3C; Palette 12
    VGA_AttribCtrl_DataReg[13]=0x3D; //0x3D; Palette 13
    VGA_AttribCtrl_DataReg[14]=0x3E; //0x3E; Palette 14
    VGA_AttribCtrl_DataReg[15]=0x3F; //0x3F; Palette 15
    VGA_AttribCtrl_DataReg[16]=parseInt("00001100b",2); //0x0C; Attribute Mode Control
    VGA_AttribCtrl_DataReg[17]=parseInt("00000000b",2); //0x00; Overscan Color
    VGA_AttribCtrl_DataReg[18]=parseInt("00001111b",2); //0x0F; Color Plane Enable
    VGA_AttribCtrl_DataReg[19]=parseInt("00001000b",2); //0x08; Horizontal PEL Panning
    VGA_AttribCtrl_DataReg[20]=parseInt("00000000b",2); //0x00; Color Select

var VGA_AttribCtrl_DataReg_OnWriteFunctions=new Array();
    VGA_AttribCtrl_DataReg_OnWriteFunctions[0] =VGA_AttribCtrl_DataReg_0x00_ManagePalette;
    VGA_AttribCtrl_DataReg_OnWriteFunctions[1] =VGA_AttribCtrl_DataReg_0x01_ManagePalette;
    VGA_AttribCtrl_DataReg_OnWriteFunctions[2] =VGA_AttribCtrl_DataReg_0x02_ManagePalette;
    VGA_AttribCtrl_DataReg_OnWriteFunctions[3] =VGA_AttribCtrl_DataReg_0x03_ManagePalette;
    VGA_AttribCtrl_DataReg_OnWriteFunctions[4] =VGA_AttribCtrl_DataReg_0x04_ManagePalette;
    VGA_AttribCtrl_DataReg_OnWriteFunctions[5] =VGA_AttribCtrl_DataReg_0x05_ManagePalette;
    VGA_AttribCtrl_DataReg_OnWriteFunctions[6] =VGA_AttribCtrl_DataReg_0x06_ManagePalette;
    VGA_AttribCtrl_DataReg_OnWriteFunctions[7] =VGA_AttribCtrl_DataReg_0x07_ManagePalette;
    VGA_AttribCtrl_DataReg_OnWriteFunctions[8] =VGA_AttribCtrl_DataReg_0x08_ManagePalette;
    VGA_AttribCtrl_DataReg_OnWriteFunctions[9] =VGA_AttribCtrl_DataReg_0x09_ManagePalette;
    VGA_AttribCtrl_DataReg_OnWriteFunctions[10]=VGA_AttribCtrl_DataReg_0x0A_ManagePalette;
    VGA_AttribCtrl_DataReg_OnWriteFunctions[11]=VGA_AttribCtrl_DataReg_0x0B_ManagePalette;
    VGA_AttribCtrl_DataReg_OnWriteFunctions[12]=VGA_AttribCtrl_DataReg_0x0C_ManagePalette;
    VGA_AttribCtrl_DataReg_OnWriteFunctions[13]=VGA_AttribCtrl_DataReg_0x0D_ManagePalette;
    VGA_AttribCtrl_DataReg_OnWriteFunctions[14]=VGA_AttribCtrl_DataReg_0x0E_ManagePalette;
    VGA_AttribCtrl_DataReg_OnWriteFunctions[15]=VGA_AttribCtrl_DataReg_0x0F_ManagePalette;
    VGA_AttribCtrl_DataReg_OnWriteFunctions[16]=VGA_AttribCtrl_DataReg_0x10_ManageAttributeModeControl;
    VGA_AttribCtrl_DataReg_OnWriteFunctions[17]=VGA_AttribCtrl_DataReg_0x11_ManageOverscanColor;
    VGA_AttribCtrl_DataReg_OnWriteFunctions[18]=VGA_AttribCtrl_DataReg_0x12_ManageColorPlaneEnable;
    VGA_AttribCtrl_DataReg_OnWriteFunctions[19]=VGA_AttribCtrl_DataReg_0x13_ManageHorizontalPELPanning;
    VGA_AttribCtrl_DataReg_OnWriteFunctions[20]=VGA_AttribCtrl_DataReg_0x14_ManageColorSelect;

var VGA_AttribCtrl_FlipFlop=new Uint8Array(2);
    VGA_AttribCtrl_FlipFlop[0]=5;  //value
    VGA_AttribCtrl_FlipFlop[1]=0;  //stage

var VGA_AttribCtrl_IdxReg=new Uint8Array(1);

function VGA_AttribCtrl_ReadReg(portNum, portSize, portMode, writeData)
{
 //Do not address indexed registers beyond the standard
 //known limit:
 ///
  if(VGA_AttribCtrl_IdxReg[0]>=VGA_AttribCtrl_DataReg.byteLength)return 0;


 //If we got a valid index number,
 //then return the value in the emulated
 //register set at that index:
 ///
  return VGA_AttribCtrl_DataReg[VGA_AttribCtrl_IdxReg[0]];
}

function VGA_AttribCtrl_ToggleFlipFlop()
{
 VGA_AttribCtrl_FlipFlop[1]++;
 VGA_AttribCtrl_FlipFlop[1]&=1;
}


function VGA_AttribCtrl_WriteReg(portNum, portSize, portMode, writeData)
{
   //INIT: Handle Index Register of Attribute Controller
   //INIT: Handle Index Register of Attribute Controller
   //INIT: Handle Index Register of Attribute Controller
   //INIT: Handle Index Register of Attribute Controller
   //INIT: Handle Index Register of Attribute Controller
   //INIT: Handle Index Register of Attribute Controller
   //INIT: Handle Index Register of Attribute Controller
   //INIT: Handle Index Register of Attribute Controller

     //If the Flip/Flop is in the first phase,
     //we must access the Attribute Controller's Index:
     ///
     if(VGA_AttribCtrl_FlipFlop[1]==0)
     {
      VGA_AttribCtrl_IdxReg[0]=writeData;
      VGA_AttribCtrl_ToggleFlipFlop();

      //INIT: Handle bit 5 of Attribute Controller's Index
      //INIT: Handle bit 5 of Attribute Controller's Index
      //INIT: Handle bit 5 of Attribute Controller's Index
      //INIT: Handle bit 5 of Attribute Controller's Index

       //This is the VERY FIRST real effect I am
       //formally implementing here in the VGA emulation,
       //and this is what I mean with applying and
       //caching the effects as soon as we finish
       //storing the emulated VGA registers' values:
       ///
        if((writeData&0x20)==0)
        {
         Screen.style.display="none";
        }
         else if((writeData&0x20)==0x20)
         {
          Screen.style.display="";
         }

      //END:  Handle bit 5 of Attribute Controller's Index
      //END:  Handle bit 5 of Attribute Controller's Index
      //END:  Handle bit 5 of Attribute Controller's Index
      //END:  Handle bit 5 of Attribute Controller's Index

      return;
     }

   //END:  Handle Index Register of Attribute Controller
   //END:  Handle Index Register of Attribute Controller
   //END:  Handle Index Register of Attribute Controller
   //END:  Handle Index Register of Attribute Controller
   //END:  Handle Index Register of Attribute Controller
   //END:  Handle Index Register of Attribute Controller
   //END:  Handle Index Register of Attribute Controller
   //END:  Handle Index Register of Attribute Controller






   //INIT: Handle Data Registers of Attribute Controller
   //INIT: Handle Data Registers of Attribute Controller
   //INIT: Handle Data Registers of Attribute Controller
   //INIT: Handle Data Registers of Attribute Controller
   //INIT: Handle Data Registers of Attribute Controller
   //INIT: Handle Data Registers of Attribute Controller
   //INIT: Handle Data Registers of Attribute Controller
   //INIT: Handle Data Registers of Attribute Controller

     if(VGA_AttribCtrl_FlipFlop[1]==1)
     {
      //Toggle the flip-flop state again:
      ///
       VGA_AttribCtrl_ToggleFlipFlop();

     //If we ar asked a registe beyond the emulated buffer,
     //just return with doing nothing:
     ///
      if(VGA_AttribCtrl_IdxReg[0]>=VGA_AttribCtrl_nDataRegs)return;

     //Put the specified value in the
     //specified indexed register
     //and also apply its expected effects:
     ///
       VGA_AttribCtrl_DataReg[VGA_AttribCtrl_IdxReg[0]]=writeData;
       VGA_AttribCtrl_DataReg_OnWriteFunctions[VGA_AttribCtrl_IdxReg[0]](writeData);

      return;
     }


   //END:  Handle Data Registers of Attribute Controller
   //END:  Handle Data Registers of Attribute Controller
   //END:  Handle Data Registers of Attribute Controller
   //END:  Handle Data Registers of Attribute Controller
   //END:  Handle Data Registers of Attribute Controller
   //END:  Handle Data Registers of Attribute Controller
   //END:  Handle Data Registers of Attribute Controller
   //END:  Handle Data Registers of Attribute Controller
}


function VGA_AttribCtrl_ResetFlipFlop(portNum, portSize, portMode, writeData)
{
 //Reset Flip/Flop to its initial
 //state:
 ///
  VGA_AttribCtrl_FlipFlop[1]=0;
 return VGA_AttribCtrl_FlipFlop[0];
}



IOPort_R_Fn_Ptr[0x3C1]=VGA_AttribCtrl_ReadReg;
IOPort_W_Fn_Ptr[0x3C0]=VGA_AttribCtrl_WriteReg;


IOPort_R_Fn_Ptr[0x3BA]=VGA_AttribCtrl_ResetFlipFlop;
IOPort_W_Fn_Ptr[0x3BA]=VGA_AttribCtrl_ResetFlipFlop;

IOPort_R_Fn_Ptr[0x3DA]=VGA_AttribCtrl_ResetFlipFlop;
IOPort_W_Fn_Ptr[0x3DA]=VGA_AttribCtrl_ResetFlipFlop;



Código: Seleccionar todo
EGA_Text_80x25x16AttributeRegs:
;Attribute Controller Register, Index 0, Palette 0 (RW; 0x3C0=0; write 0x3C0; read 0x3C1):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-5 -- 0 to 63 color value
 ;
 ;      All other bits are reserved
 ;;
  db 0               ;0x00










;Attribute Controller Register, Index 1, Palette 1 (RW; 0x3C0=1; write 0x3C0; read 0x3C1):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-5 -- 0 to 63 color value
 ;
 ;      All other bits are reserved
 ;;
  db 1               ;0x01










;Attribute Controller Register, Index 2, Palette 2 (RW; 0x3C0=2; write 0x3C0; read 0x3C1):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-5 -- 0 to 63 color value
 ;
 ;      All other bits are reserved
 ;;
  db 2               ;0x02










;Attribute Controller Register, Index 3, Palette 3 (RW; 0x3C0=3; write 0x3C0; read 0x3C1):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-5 -- 0 to 63 color value
 ;
 ;      All other bits are reserved
 ;;
  db 3               ;0x03










;Attribute Controller Register, Index 4, Palette 4 (RW; 0x3C0=4; write 0x3C0; read 0x3C1):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-5 -- 0 to 63 color value
 ;
 ;      All other bits are reserved
 ;;
  db 4               ;0x04










;Attribute Controller Register, Index 5, Palette 5 (RW; 0x3C0=5; write 0x3C0; read 0x3C1):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-5 -- 0 to 63 color value
 ;
 ;      All other bits are reserved
 ;;
  db 5               ;0x05










;Attribute Controller Register, Index 6, Palette 6 (RW; 0x3C0=6; write 0x3C0; read 0x3C1):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-5 -- 0 to 63 color value
 ;
 ;      All other bits are reserved
 ;;
  db 20              ;0x14










;Attribute Controller Register, Index 7, Palette 7 (RW; 0x3C0=7; write 0x3C0; read 0x3C1):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-5 -- 0 to 63 color value
 ;
 ;      All other bits are reserved
 ;;
  db 7               ;0x07










;Attribute Controller Register, Index 8, Palette 8 (RW; 0x3C0=8; write 0x3C0; read 0x3C1):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-5 -- 0 to 63 color value
 ;
 ;      All other bits are reserved
 ;;
  db 56              ;0x38










;Attribute Controller Register, Index 9, Palette 9 (RW; 0x3C0=9; write 0x3C0; read 0x3C1):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-5 -- 0 to 63 color value
 ;
 ;      All other bits are reserved
 ;;
  db 57              ;0x39










;Attribute Controller Register, Index 10, Palette 10 (RW; 0x3C0=0x0A; write 0x3C0; read 0x3C1):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-5 -- 0 to 63 color value
 ;
 ;      All other bits are reserved
 ;;
  db 58              ;0x3A










;Attribute Controller Register, Index 11, Palette 11 (RW; 0x3C0=0x0B; write 0x3C0; read 0x3C1):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-5 -- 0 to 63 color value
 ;
 ;      All other bits are reserved
 ;;
  db 59              ;0x3B










;Attribute Controller Register, Index 12, Palette 12 (RW; 0x3C0=0x0C; write 0x3C0; read 0x3C1):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-5 -- 0 to 63 color value
 ;
 ;      All other bits are reserved
 ;;
  db 60              ;0x3C










;Attribute Controller Register, Index 13, Palette 13 (RW; 0x3C0=0x0D; write 0x3C0; read 0x3C1):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-5 -- 0 to 63 color value
 ;
 ;      All other bits are reserved
 ;;
  db 61              ;0x3D










;Attribute Controller Register, Index 14, Palette 14 (RW; 0x3C0=0x0E; write 0x3C0; read 0x3C1):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-5 -- 0 to 63 color value
 ;
 ;      All other bits are reserved
 ;;
  db 62              ;0x3E










;Attribute Controller Register, Index 15, Palette 15 (RW; 0x3C0=0x0F; write 0x3C0; read 0x3C1):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-5 -- 0 to 63 color value
 ;
 ;      All other bits are reserved
 ;;
  db 63              ;0x3F










;Attribute Controller, Index 16, Attribute Mode Control (RW; 0x3C0=0x10; write 0x3C0; read 0x3C1):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0 -- graphics/alphanumeric
 ;      1 -- mono emulation
 ;      2 -- enable line graphics character codes
 ;      3 -- enable blink/select background intensity
 ;      4 -- reserved
 ;      5 -- PEL panning compatibility
 ;      6 -- PEL width
 ;      7 -- P5, P4 select
 ;
 ;;
  db 00001100b       ;0x0C










;Attribute Controller, Index 17, Overscan Color (RW; 0x3C0=0x11; write 0x3C0; read 0x3C1):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-7 -- overscan color
 ;
 ;;
  db 00000000b       ;0x00 or black



;If we disable the palette, everything seems to turn into
;the overscan color, if it isn't black.

;IMPORTANT NOTE: The Attribute controller expects
;                to first write the index and then the value
;                or to write those 2 bytes with a word IO instruction.
;                Otherwise, it behaves as a flip-flop.
;
;                Probably, or probably not, the other controllers
;                behave like this, so let's find that out too.





;Attribute Controller, Index 18, Color Plane Enable (RW; 0x3C0=0x12; write 0x3C0; read 0x3C1):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-3 -- enable color plane
 ;      4-5 -- video status MUX
 ;      6-7 -- reserved
 ;
 ;;
  db 00001111b       ;0x0F










;Attribute Controller, Index 19, Horizontal PEL Panning (RW; 0x3C0=0x13; write 0x3C0; read 0x3C1):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-3 -- horizontal PEL panning
 ;      4-7 -- reserved
 ;
 ;;
;  db 00000100b       ;0x08      <---- very interesting error'
;  db 00001000b       ;0x08
;db 0
db 8



;'If we use a loop to slowly change this value increasingly/decreasingly,
; we can learn something.
;
; The effect of using 4 instead of 8 was that the screen was "wrapped",
; and some pixels at the leftmost of the screen were shown at the rightmost
; of the screen........





;Attribute Controller, Index 20, Color Select (RW; 0x3C0=0x14; write 0x3C0; read 0x3C1):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-1 -- SC5,SC4
 ;      2-3 -- SC6,SC7
 ;      4-7 -- Reserved
 ;
 ;;
  db 00000000b       ;0x00

Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Jue Abr 25, 2013 6:13 pm

Ahora que he implementado los esqueletos de todos los registros configurables, lo que queda es comenzar a implementar el acceso a la memoria de video de acuerdo a la manera de lograrlo en una VGA.

Para esto también necesito implementar la lógica necesaria para cargar fuentes de texto, para desplegarlas; y también necesito implementar la carga y el uso de los colores de las paletas, tanto la de 256 colores como la de 16 colores (esta última en el Controlador de Atributos), que depende de esta.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Jue Abr 25, 2013 6:26 pm

Debemos pensar en los efectos que provoca escribir un byte de carácter, y también un byte de atributo, y cómo manejar eficientemente todas las combinaciones de escritura de 8 y 16 bits, y más adelante, de 32 y 64 bits.





Debemos pensar en la cadena de efectos que tiene escribir el primer byte de carácter en la memoria de video, y hacer un recuento de las cosas involucradas, como configuración en general, el glyph de la fuente de texto, el color aplicado a partir del byt de atributo, entre otras cosas (como la rotación de los datos y otras operaciones).

De esta forma debemos implementar el camino completo de la funcionalidad, que cambiará entre los diferentes modos de texto y los diferentes modos gráficos, efectivamente usando rutinas diferentes de renderización de caracteres alfanuméricos o de pixeles cuadrados o simples, etc.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Vie Abr 26, 2013 1:52 am

Pensando a profundidad, son muchas las combinaciones de lectura y escritura hacia planos o páginas de memoria de video VGA (hasta 4 de 64 KB, lo que hace totaliza los 256 KB de la memoria de la VGA estándar).

Pero escribir al modo de texto 80x25x16 implica recibir la dirección a escribir y determinar si es un carácter o un atributo, y también implica leer la altura de los caracteres, de 16 a 32 bytes, a partir de un simple registro VGA (que ya he averiguado cómo usar con LowEST).

Los caracteres siempre parecen tener 8 bits (8 pixeles) de anchura siempre, y típicamente 8, 16, o hasta 32 pixeles (32 bytes) de altura, con todos los valores de por medio.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Vie Abr 26, 2013 5:09 pm

Veo que lo primero que involucra emular el acceso a la memoria VGA estándar es el hecho de que esta tiene 18 líneas de direcciones (¿la memoria es un multiplexador masivo?).

Estas van desde la línea MA0 hasta la línea MA17.

Con 18 líneas de memoria podemos acceder hasta los 256 Kilobytes de memoria de la VGA estándar. Este punto básico parece estar más que claro.





Es posible acceder los 256 KB al mismo tiempo (como lo demuestra el Modo X), pero también es posible hacer que la línea MA0 se mapee al bit 0 de la dirección del host, o que esta se mapee a los bits A14 o A16 del host.

Esto nos daría el indicio de que solamente podríamos acceder 128 KB a la vez, provenientes de planos de 64 KB pares o impares. Y este punto es el que necesitamos profundizar.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Vie Abr 26, 2013 5:23 pm

Vemos también que la dirección 0xB8000 es la dirección de 20 bits 10111000000000000000b en binario.

Vemos también que la dirección 0xA0000 es la dirección de 20 bits 10100000000000000000b en binario.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Vie Abr 26, 2013 6:00 pm

Así que en primera instancia parecería que escribir un carácter a la dirección 0xB8000 en el modo de texto estándar 3h (80x25x16) nos daría la dirección 0x38000 o 0x38001, automáticamente.

Esto nos da la pregunta: En modos de video en los que la memoria está mapeada más allá de 0xA0000, ¿qué pasa al escribir en la parte baja de memoria de video ya no mapeada? ¿Sigue respondiendo igual internamente, escribiendo automáticamente a diferentes planos, o se comporta como memoria RAM normal (esto último dudoso)?

Pero dado que el bit de menor peso selecciona entre planos pares o impares, aparentemente estaríamos accediendo el mismo offset, pero en dos diferentes planos de 64 KB.

La cuestión ahora es determinar qué direcciones físicas serían esas realmente dentro de la memoria de video en cuestión, tomando 0 como dirección base.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Vie Abr 26, 2013 6:04 pm

Otra cosa interesante que vemos es que si restamos 0x40000-0x38000, obtenemos 0x8000, que son 32 KB disponibles, y esto concuerda con la documentación sobre los modos qude comienzan en 0xB8000. Y 0x40000 es el tamaño total de la memoria de video, que son 256 KB.

Parece que vamos desenredando lentamente este asunto.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Vie Abr 26, 2013 6:22 pm

En este respecto, los 32 KB de memoria con los que contamos se dividen a la mitad.

Y no es que nos deshagamos del bit de menor peso moviéndolo a la derecha, sino que este controla el mismo offset para dos páginas diferentes como si estuviera a 0.

Por ejemplo si usamos la dirección 0x38000, accedemos el primer byte en el plano 0 (byte de carácter), para el modo de texto 3h (80x25x16); y si usamos la dirección 0x38001, también accedemos el primer byte pero en el plano 1 (byte de atributo).

Pero dado que controla 2 páginas diferentes, tenemos 16 KB repartidos en 2 planos, y esto significa que contamos con 32 KB repartidos entre 2 planos accesibles hasta en 16 KB.

Ahora esto está considerablemente más claro. Lo siguiente que necesitamos es determinar exactamente la lógica a implementar para configurar el bit MA0 correctamente en modo palabra (word mode) o modo byte (byte mode), y cómo relacionar esto con el campo Address Wrap en el Registro de Control de Modo (Mode Control) del CRTC.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Vie Abr 26, 2013 8:29 pm

Para el modo de texto 3h (80x25x16) el registro de Control de Modo (CRTC índice 17h) tiene un valor de 10100011b.

Esto significa que los bits 13 y 14 (configurados en los bits 0 y 1 puestos a 1) de las líneas de direcciones serán bits directos, no reemplazados por "cuentas de línea".

El bit 3 está a 0 así que no dividiremos el reloj horizontal entre 2.

El bit 5 está a 0, así que eso nos dice que dividamos el reloj de memoria entre 2, lo que significa que el contador de direcciones de memoria se temporizan un reloj de carácter sí, un reloj de caracter no.

El bit 6 está a 0, así que eso significa que hemos seleccionado el modo palabra (word mode).

El bit 7 está a 1, así que eso significa que se deben generar señales de sincronía horizontal y vertical, señales de activación de pantalla y señales de "blanqueo" o "supresión" (blanking).
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Vie Abr 26, 2013 8:33 pm

El registro Gráfico 5h tiene un valor de 00010000b.

Los bits 0-1 están a 0, así que usaremos el modo de escritura 0 (escritura directa de datos).

El bit 3 está a 0 para "tipo de lectura".

El bit 4 está a 1, así que tenemos activado el modo par/impar.

El bit 5 está a 0, lo que significa que el registro de rotación está desactivado.

El bit 6 está a 0, lo que significa que este no es un modo de 256 colores.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Sab Abr 27, 2013 3:56 pm

Parece que tendremos que comenzar a agregar todo tipo de funcionalidad, comenzando por la de escritura en la memoria de video según una VGA y el despliegue en pantalla de esos datos.

Deberemos comenzar a agregar funcionalidad en funciones tan pequeñas que después nos resulte fácil asociar dicha funcionalidad con la configuración en cuestión de la VGA emulada.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Mar Abr 30, 2013 4:41 am

He estado reflexionando en el campo "Underline Location" de este registro del CRTC:
Código: Seleccionar todo
;CRTC Controller, Index 20, Underline Location (RW; 0x3D4=0x14 color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-4 -- underline location
 ;        5 -- count by 4
 ;        6 -- double word mode
 ;        7 -- reserved
 ;;
;  db 00011111b       ;0x1F
db 0x1F



Vemos que tiene el valor 0x1F, o 31. Sabemos que en modo 80x25 solo tenemos 16 scan lines por cada glyph (carácter de texto), y en las referencias que he leído dice qu si este campo "Underline Location" está más allá del scan line máximo del modo de texto actual, su efecto de subrayado efectivamente se desactiva.

También he visto que es necesario darle el valor de 1 al atributo de color de foreground (frente) para activar el subrayado (esto tengo que comprobarlo en varios modos de video diferentes al 7h para saber si es cierto).
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Mar Abr 30, 2013 4:41 am

He estado reflexionando en el campo "Underline Location" de este registro del CRTC:
Código: Seleccionar todo
;CRTC Controller, Index 20, Underline Location (RW; 0x3D4=0x14 color; 0x3B4 mono; 0x3D5 color; 0x3B5 mono):
;;
 ;
 ;
 ;
 ;  Bits:
 ;      0-4 -- underline location
 ;        5 -- count by 4
 ;        6 -- double word mode
 ;        7 -- reserved
 ;;
;  db 00011111b       ;0x1F
db 0x1F



Vemos que tiene el valor 0x1F, o 31. Sabemos que en modo 80x25 solo tenemos 16 scan lines por cada glyph (carácter de texto), y en las referencias que he leído dice qu si este campo "Underline Location" está más allá del scan line máximo del modo de texto actual, su efecto de subrayado efectivamente se desactiva.

También he visto que es necesario darle el valor de 1 al atributo de color de foreground (frente) para activar el subrayado (esto tengo que comprobarlo en varios modos de video diferentes al 7h para saber si es cierto).
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Mar Abr 30, 2013 4:59 am

He visto que hay 2 bits, uno en el controlador de Atributos y otro en el controlador Gráfico, que seleccionan entre modo texto y gráfico. Ambos deberían concordar (deberían tener ambos un 1 o un 0) o se debería emular una condición de error de video.





Veo también que los modos de texto únicamente pueden ser monocromáticos/blanco y negro o de 16 colores. Necesito saber qué controla esto exactamente.

Veo que todos los modos de texto están hechos de un par de carácter/atributo a la hora de escribir el texto, y dependiendo del modo el atributo se interpreta de diferentes formas. Necesito saber exactamente qué registros controlan el comportamiento del atributo.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Mar Abr 30, 2013 5:04 am

Creo que el libro de Graphics Programming Black Book de Michael Abrash debería leerlo especialmente para implementar los gráficos, porque dice esto:

All four linear planes are addressed in the same 64K memory space starting at A000:0000. Consequently, there are four bytes at any given address in VGA memory. The VGA provides special hardware to assist the CPU in manipulating all four planes, in parallel, with a single memory access, so that the programmer doesn’t have to spend a great deal of time switching between planes. Astute use of this VGA hardware allows VGA software to as much as quadruple performance by processing the data for all the planes in parallel.

Each memory plane provides one bit of data for each pixel. The bits for a given pixel from each of the four planes are combined into a nibble that serves as an address into the VGA’s palette RAM, which maps the one of 16 colors selected by display memory into any one of 64 colors, as shown in Figure 23.1. All sixty-four mappings for all 16 colors are independently programmable. (We’ll discuss the VGA’s color capabilities in detail starting in Chapter 33.)


Y también dice esto:

The VGA BIOS supports several graphics modes (modes 4, 5, and 6) in which VGA memory appears not to be organized as four linear planes. These modes exist for CGA compatibility only, and are not true VGA graphics modes; use them when you need CGA-type operation and ignore them the rest of the time. The VGA’s special features are most powerful in true VGA modes, and it is on the 16-color true-VGA modes (modes 0DH (320×200), 0EH (640×200), 10H (640×350), and 12H (640×480)) that I will concentrate in this part of the book. There is also a 256-color mode, mode 13H, that appears to be a single linear plane, but, as we will see in Chapters 31–34 and 47–49 of this book, that’s a polite fiction—and discarding that fiction gives us an opportunity to unleash the power of the VGA’s hardware for vastly better performance. VGA text modes, which feature soft fonts, are another matter entirely, upon which we’ll touch from time to time.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Mar Abr 30, 2013 5:12 am

Nuevamente sobre los modos de texto, vemos que la jerarquía de la lógica en la VGA y por ende en nuestro emulador es el hecho de entrar en modo texto si los bits de los que hablamos están a 0 (o entrar a modo gráfico si ambos están a 1, comprobándose entre sí cada vez que escribimos uno u otro, y probablemente todos los demás registros relacionados en bloque operativo).

Una vez que determinamos que debemos estar en modo texto, esto nos proveerá la función raíz para una función que recupere la fuente del plano 3, que use el plano 0 para los caracteres, y el plano 1 para los atributos.

El siguiente paso en la jerarquía es determinar cómo usar los bits pares/impares y relacionados para determinar la dirección de memoria gráfica a leer o escribir.

El otro paso relevante en la jerarquía son las funciones lógicas de la VGA, pero después las funciones específicas de underline, y de cómo interpretar los atributos.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Flujo de Instrucciones Humanas para Implementar la Funcionalidad Incial de la VGA (Modo Texto 80x25x16 Colores y Finalmente Modos de Video)

Notapor ~ » Mar Abr 30, 2013 5:15 am

Nuevamente sobre los modos de texto, vemos que la jerarquía de la lógica en la VGA y por ende en nuestro emulador es el hecho de entrar en modo texto si los bits de los que hablamos están a 0 (o entrar a modo gráfico si ambos están a 1, comprobándose entre sí cada vez que escribimos uno u otro, y probablemente todos los demás registros relacionados en bloque operativo).

Una vez que determinamos que debemos estar en modo texto, esto nos proveerá la función raíz para una función que recupere la fuente del plano 3, que use el plano 0 para los caracteres, y el plano 1 para los atributos.

El siguiente paso en la jerarquía es determinar cómo usar los bits pares/impares y relacionados para determinar la dirección de memoria gráfica a leer o escribir.

El otro paso relevante en la jerarquía son las funciones lógicas de la VGA, pero después las funciones específicas de underline, y de cómo interpretar los atributos.
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2958
Registrado: Sab Nov 10, 2012 1:04 pm


Volver a IBM PC y Compatibles

¿Quién está conectado?

Usuarios navegando por este Foro: No hay usuarios registrados visitando el Foro y 28 invitados


cron