Estoy describiendo un sistema en VHDL. Este sistema ya contiene un procesador, un controlador DDR SDRAM y un controlador VGA. VGA lee píxeles de SDRAM (ya validado y probado en FPGA).
Aunque VGA y SDRAM ya se están comunicando entre sí, todavía necesito implementar la conexión entre el procesador y SDRAM. Al final, lo que pretendo tener es un procesador que utilice el framebuffer almacenado en la SDRAM. Luego, ocurre un cambio de página y VGA comienza a buscar la nueva imagen que dibujó el procesador.
Para indicarle al VGA que busque desde la nueva ubicación, me gustaría informar al controlador VGA (usando io asignado a la memoria) la nueva dirección de la nueva imagen. Una estrategia simple que pensé fue poner un mux y verificar si el rango de direcciones cae en los registros del controlador VGA o en el rango de direcciones del caché. Además, ¿debería preocuparme por diferentes dominios de reloj? En caso afirmativo, ¿qué posibles problemas deberían preocuparme?
Por ejemplo, en algún momento en el pasado vi un código de x86 que escribe (usando la instrucción outb) y la siguiente instrucción era un inb en la misma ubicación y/o en una ubicación relacionada. En este caso, ¿tendría que modificar la lógica del procesador para detener tales operaciones? En caso afirmativo, ¿cuántos casos implementar? ¿Cuántas interfaces hay que preocuparse?
Además, en el arranque, ¿cómo se usa el caché si se invalidan todas las entradas? Creo que hay una imagen de ROM con el código de inicio. ¿Podría existir también una RAM local temporal para escrituras realizadas por código almacenado en ROM (instrucciones sw)?
Resumen: Necesito información sobre cómo implementar circuitos de jerarquía de memoria: cachés, memoria mapeada io, TLB, memoria virtual, etc. Y cómo todo esto se comunica entre sí. Sé cómo implementar cachés y TLB, por ejemplo. Pero no estoy seguro de cómo conectarlos entre sí. Podría usar algo que funcione (como la idea mux). Pero quiero seguir los diseños establecidos en la industria.
Lo que ya he estudiado: - cómo ejecutar mips - arquitectura de computadoras (Patterson) - manuales de MIPS - manuales de ARM - manuales de Intel
Pero ninguno explica en detalle.
Si hay muchas formas de implementar, solo muéstrame una que conozcas, por favor. Incluso si es código fuente o un diagrama de bloques. Nuevamente, no necesito la explicación de cómo funciona internamente. Solo necesito saber las interfaces entre los módulos.
Gracias a todos
Aquí hay un enlace a una breve explicación de cómo funciona la E/S mapeada en memoria en un sistema informático de estilo antiguo. Tal vez esto pueda responder algunas de sus preguntas:
http://www.cs.umd.edu/class/sum2003/cmsc311/Notes/IO/mapped.html
Después de todo este tiempo, no he encontrado nada detallado sobre el tema. Decidí codificar algo que funcionara y olvidarme de cómo funciona la industria. Esto fue después de leer cierta documentación sobre el proyecto de bus Wishbone que dice que en FPGA usan un montón de multiplexores para crear las rutas entre los módulos.
Mi consejo para aquellos que están intentando algo similar en FPGA: simplemente hagan algo que funcione. Puede que me equivoque, pero simplemente no hay información detallada sobre cómo hacer este tipo de cosas.
En primer lugar, he aceptado mi realidad: soy un tipo de FPGA, generalmente limitado por relojes de 50MHz. Tampoco estoy proyectando un sistema para interactuar con una placa base o PCI o lo que sea. Es un SoC simple y todas las interfaces físicas que necesito (teclado, mouse, VGA, SDRAM, etc.) están listas para usar a través de asignaciones de pines (por supuesto, todavía tengo que implementar la lógica en VHDL).
En otras palabras: solo necesito preocuparme por VHDL porque las cosas físicas ya están hechas por los muchachos de Altera/Xilinx/YourVendorHere.
Te explico brevemente como lo hice:
No implementé un autobús. Al principio quería usar un autobús porque es como se hace en general. Pero la verdad es que un bus solo sirve si vas a conectar módulos y este no fue mi caso (corrígeme si me equivoco). Entonces, al final, solo usé un montón de multiplexores para mapear las direcciones.
Para los registros de estado/control/datos dentro de los módulos, decidí usar un 'protocolo' simple que puede pensarse como un apretón de manos/sondeo: en un bucle sigo leyendo el registro hasta que entrega el valor que espero, luego realizo la operación Quiero.
No tengo idea de cómo los chicos de ARM e Intel hacen sus cosas, pero aquí simplemente agregué una ROM y una RAM (ambas en bloque) para el código de arranque. Es simple y funciona.
La interfaz entre el procesador y cache/tlb/mmu es la siguiente: cache, tlb y mmu no actúan por sí mismos. Si hay un error, es el procesador el que debe indicarles que obtengan los datos necesarios.
Hay tantos detalles que no sé qué explicar o no. Si alguno de ustedes necesita información detallada sobre cómo hice las cosas, solo envíeme un correo electrónico: hdhzero@gmail.com. Estaré encantado de anunciar cualquier cosa aquí en la pila o en mi correo electrónico.
También dejaré aquí algunos enlaces que me ayudaron: http://www.st.ewi.tudelft.nl/~gemund/Publications/michel_bsc.pdf http://amir-shenodua.blogspot.com.br/2012/ 06/administración-de-memoria-simple-con-vhdl.html
También recomiendo el siguiente libro, que tiene algunos capítulos que describen cómo se puede conectar un procesador con módulos IO: http://www.amazon.com/FPGA-Prototyping-VHDL-Examples-Spartan-3/dp/0470185317
Dzarda
hdhzero
hdhzero
hdhzero
lm317