I think they design the central GPU using Verilog/VHDL.
Yes.
They program it using FPGAs like Xilinx, Altera, Atmel, Actel or Lattice.
Probably not.
They create a reference model, probably in C or SystemC and an RTL model in Verilog (or VHDL, but not likely if they're on the West Coast) and probably also an additional verification model in Vera or Specman.
Then they throw massive simulation time at it. Emulators (whether FPGA based or not) are usually too labor intensive at the start of a project and turn-around time is too long, so it can take months into a project before they are used.
I suggest you do the same: first make a Verilog model and a testbench and make sure it works in simulation. Not sure if the Spartan starter kit has a good simulator, but the
Icarus Verilog simulator is of suprisingly good quality.
Start with something really simple: a clock input and an output that simply toggles on and off. If that works in simulation, try to get that to the FPGA. Getting the whole flow down with a simple example is crucial since you can much easier pinpoint problems.
Then they join the netlists ( because these FPGAs can only manage around 3M transistors and the G70 is like 280M... ) into a collosal one.
No, they probably don't.
The final design will be simulated on giant multi-million dollar emulators like
these. FPGA's are way to small and too clumsy to handle.
Then call TSMC or other and synthetize the final ASIC.
They'll go through tens of synthesis iterations to get timing right. Then they'll go through a few months of place and route. And then they'll send the final design to TSMC.
Finally the GPU is integrated in a PCB using a program like Altium Designer 6, P-Cad, Or-CAD???
Yes.
But... how can you test the final card? Using an osciloscope?
There's a whole bunch of tools: logical analyzers, oscilloscopes, debug logic instrumentation inside the chip (that costs area, but is essential to debug million gate chips), JTAG control to dump internal state etc. Typically, a chip that comes back from fab should be good enough to get its interfaces to work and access it via PCI/PCIe or whatever interface is generally used, so external measurement equipment is not that crucial to get something to work initially. It's mainly use for later spec conformance qualification (voltage levels, noise levels etc.)
Your case will be different: I've never seen a hobby project PCB that's first time right: shorts, wrong connections, forgotten decoupling etc etc. It's very painful to debug without at least an oscilloscope. Start again with the Spartan board and don't build your own PCB at first. It will take you months before you're ready to take the next step.
But suppose I am a student with a limited buget of 500$. How can I develop a very simple VGA card with some HW-rasterization support like a RivaTNT pls? How can I integrate the VRAM , FPGA and RAMDAC into the PCB and debug it? What the professionals use to make and test a graphics card?
Your plan is very ambitious. First learn to walk before to run!
- the Spartan board is a good start. Don't buy anything else yet. Read the manuals. Try to make a design that allows you to toggle one of the LEDs at variable speeds. If you've never done this before the learning curve will be steep and you'll need a lot of patience and perseverance.
- Move on to something more challenging. Counters, small statemachines, ... Try to control the LCD display on the Spartan board
- If all this was too easy, try to create video generator: something that displays alternate white and black bars on your screen. Don't think about a memory interface yet. Just getting the video timings right is *hard*. Look
here for VGA controller to get some ideas. No need to use DAC's for the video: play around with resistor ladders at first. Quality will suck, but who cares?
Still not disillusioned? Congratulations! You've gone farther than anyone would have expected!
- Now try to make something that reads the display contents from memory and show it on the screen. Use the DDR of the Spartan board. This increases complexity by another factor. Memory controller are notoriously difficult to get right! Look again on
www.opencores.org for a DDR controller. Maybe Xilinx has a free one in their IP library?
- You still haven't used PCI or anything else. If all the previous worked, maybe you can start thinking about throwing more money at it. Desiging a PCI PCB can be done. It's possible with 2 layers (but you need 4 layers to meet official impedance specs. Ignore and hope it will work.) The length of PCI traces on the PCB is quite critical and timings inside the FPGA are critical too. Very very hard to debug if you do this wrong (and you will) and don't have a PCI bus analyzer (=$10K).
(If you ever get to this step, feel free to come back and ask more questions.) Have you thought about your PCI driver? Probably try this in Linux as there are a lot of examples.
This may get you started. There was once a website that described the development of a self-made PCI adapter with video drivers for Linux and everything at some European university (Slovenia?), but I can find it back.
As said in the beginning: it'd be really a bad idea to program something and put it on the FPGA right away: simulate until you're sure it works otherwise you'll waste days and days debugging problems that would take a few minutes in simulation.
Where can I find information about the electric ( and pcb ) design of memories like Samsung
It's too early for that, but they're on the Samsung website.
dimensions and protocol of the PCI, AGP, PCI-X, etc?
Forget about AGP or PCI-X. Way too hard. PCI specs are for sale on
www.pcisig.com for $100. opencores.com has a PCI core that should be useful.
Some random points:
- forget about the MOSIS option. Not practical for a hobbyist since you'll still need all the backend tools of a standard ASIC flow. ($$$$$)
- once again: don't spend any money other than the Spartan board and learn how it works and hit its limits. Only then you'll understand better what you're up against.
- The xess board would be a very good alternative to the Spartan board, but you probably won't get the necessary software. But just the same, even without PCI interface it will still take a long time before this board will be the limiting factor in what you need to learn.
- CPLD are very fast for combitional logic, but don't have a lot of FFs. FPGA's are typically slower but have more FFs. For your kind of design, an FPGA is probably better.
- You program FPGA's with a cable that comes with the Spartan board. Some FPGA's require an external PROM with the configuration image. Other have this onboard.
Good luck!
