This file is NOT up to date for the New Design! ============== old (pre-ND) contents below ============== "I just thought it would be usefull if we had some kind of TODO and BUGS files in the distribution as it would make it easier to see what is needed to be done and what could be done better, instead of browsing through the sourcecode. And we whould be able to se the progress literally by the ever decreasing TODO file :-)" ## BUGS: All Tseng cards: * We definitely NEED to fix that color-expansion problem. See Appendix A below for a detailed explanation. * There are still some problems with the HW-cursor. The error message about "wrong color selected" is disabled, and the limitation documented. Better would be to have a way to dynamically switch to software-cursor mode if the color can not be made. HW cursor doesn't work in DoubleScan modes yet (only half of the cursor displayed) * text font sometimes corrupted when going back to text mode. This may be related to the order in which registers are restored: the ARK driver first restores extended registers before restoring the standard registers for excactly this reason. * The code needs to be heavily reworked to fix all sorts of data type problems. The current code will certainly not run on an Alpha. The first step is to replace all hardware related variables by CARD8/CARD16/CARD32 types. ET6000: * The trapezoid code is disabled because it doesn't comply with the way the non-accelerated ("cfb") code does things. This needs to be fixed. ET-4000(W32): * Hardware cursor support for the W32 is still lacking color support. We need to reserve color cells #0 and #255 to make this work. From discussions on the development list, it seems the best solution is to allocate these cells read-write, and then use them for the HW cursor. We MUST however document that this will break some clients which depend on a fixed color in cell #0, and some others that rely on the presence of 256 color cells. It will also cause cursor color problems when someone uses a local color map. ## TODO: All cards: * The accelerator on the Tseng devices is capable of much more. Especially the pattern support is not used most of the time: It can render a pattern in just about every accelerated operation. This means patterned lines, bitblts, screencopies, etc. are possible. However, operations like these are very uncommon in normal server use, so the speed benefit would go largely unnoticed. ET4000: * support needs to be added for several clockchips and RAMDACs: - 8-bit RAMDAC support for >8bpp modes: Sierra DACs and possibly others - AT&T 20C49x RAMDAC support is not correct. * SuperProbe could use an update. It doesn't detect some of the RAMDACs that are detected by the driver. * Several of the color expansion-related accelerations are still only 8bpp. It should be easy to use the same trick on those as on the standard color expand code (use intermediate buffer, expand data before blitting). * many of the operations that the W32 family can't support natively (e.g. FillRectSolid for 24bpp) can be performed using CPU-to-screen operations, feeding the correct (color) information through the ACL aperture. ET6000: * someone might want to look at how the bitBLT engine of the ET6000 is constructed, and come up with some fancy ways of abusing it. We're still only using a small part of it (I'm thinking about the compare map and the extensions to the MIX hardware compared to the ET4000). * Mclk support is still lacking (that would also allow MClk-dependent maximum bandwidth). * Apart from the things mentionned above, I think the ET6000 server is pretty complete. Some optimisations could possibly be added. Like for example some assembler code for calculating a framebuffer address from X/Y coordinates. That would help to speed up small blits. ======================================================================= APPENDIX A: the color expansion problem ---------------------------------------- As suggested in the data book, we're doing font rendering using the color-expansion (MIX map) capabilities of the Tseng accelerator. We're using a ping-pong buffer scheme (triple buffering actually) in off-screen memory to store one scanline worth of font data at a time. each of these scanlines is "blitted" to on-screen memory using the accelerator. The scanline is the MIX map, and there's also a 4x1 solid foreground color (SRC map), and a 4x1 solid background color (PAT map). Basically, the flow is as follows: - setup accelerator for font-expansion - store scanline 1 in off-screen memory buffer 1 - start operation - store scanline 2 in off-screen memory buffer 2 - start operation - store scanline 3 in off-screen memory buffer 3 - start operation - store scanline 4 in off-screen memory buffer 1 - start operation ... etc, until the whole line of text is drawn. There is no explicit "waiting" for the accelerator to finish an operation before starting a new one, because it has been set up to add "wait-states" when the queue is full. We're aiming to use concurrency between the accelerator and the storing of scanlines in the buffers. Anyway, waiting after each operation doesn't help. Now, in 99% of all cases, text is rendered OK. But in some cases, we're seeing severe font corruption. What we're seeing is this: sometimes, exactly 32 pixels of a scanline are rendered with the scanline data that was there BEFORE, instead of the one that was just written into the scanline buffer. In other words, 32 pixels of line 2 (for example) are rendered at line 5. The rest of the scanline can be OK (i.e. data from scanline 5 is actually written there). Here's an attempt at showing you what _should_ have been rendered: 1 2 ##################################################################### 3 4 5 6 ##################################################################### 7 8 9 10 ##################################################################### 11 12 13 14 ##################################################################### 15 and what _is_ rendered sometimes (only an example): 1 2 ##################################################################### 3 4 5 6 ######################## ############# 7 8 9 10 ##################################################################### 11 12 13 ######################## 14 ##################################################################### 15 At line 6, 32 pixels of the "black" scanline data from line 3 is rendered instead of the actual full-white that would normally have to be there. At line 13, the opposite happened (data from line 10 rendered at line 13). This 32-pixel width of the "bug" is independent of the color depth: we're seeing this at 8bpp as well as at 16bpp, 24bpp and 32bpp. 32 pixels each time. Remember, we're talking triple-buffering here, so the "wrongly" rendered data is in fact the data that was in the scanline-buffer from the PREVIOUS operation that used that buffer. In fact, my best explanation is that sometimes, a whole DWORD (32 bits) of data isn't in the video memory yet by the time the accelerator starts rendering with it. But the data _is_ being written to there by the driver software, because if you restart the scanline-operation again, without writing any more data to the scanline buffers (only the MIX address and the destination address are reprogrammed to restart the scanline color expansion operation -- see code in tseng_acl.c), data _is_ rendered correctly. I have investigated this as far as I possibly can. I checked if the data was actually written in video memory. It was. I checked all kinds of PCI-related things, like write-gathering or write-reordering of the PCI chipset, etc. I disabled all possible enhanced features, both on the PCI chipset, inside the CPU, and on the ET6000. What strikes me, is that the exact same problems are seen on ET4000W32p as on the ET6000. This immediately rules out any special features that were only added with the ET6000, like problems with the MDRAM cache buffers, etc. It seems to be a generic problem to all Tseng accelerators. The exact same higher-level code is being used for other chipsets as well (i.e. the system of writing scanlines of data to off-screen memory and making the accelerator expand it into on-screen memory), and there are no problems on these other chipsets. The acceleration architecture we're using is completely device-independent up to the point where each chip needs to provide a SetupForScanlineScreenToScreenColorExpand() and a SubsequentScanlineScreenToScreenColorExpand() function. Since the higher-level code is being used by other chip drivers as well, it seems to be OK. So the problem is either in those device-dependent functions, or in the hardware itself. I have found one kludge to work around this problem, and it should (?) tell you a lot about the problem: if I start each scanline-colorexpand operation TWICE, rendering is suddenly perfect (at least there are so little rendering errors that I haven't seen any yet). I am including the two device-depending functions so that you may be able to follow what I'm saying here: One entire line of text is drawn by calling the Setup() function ONCE. All scanlines of text (16 of them in case of a 8x16 font) are drawn by filling the off-screen scanline buffers and calling the Subsequent() function. $XFree86: xc/programs/Xserver/hw/xfree86/drivers/tseng/README,v 1.12 2000/08/08 08:58:06 eich Exp $