NVidiaCore.java

/*
 * $Id$
 *
 * Copyright (C) 2003-2015 JNode.org
 *
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public 
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; If not, write to the Free Software Foundation, Inc., 
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
package org.jnode.driver.video.nvidia;

import java.awt.Color;
import java.awt.Rectangle;
import java.awt.geom.AffineTransform;
import java.awt.image.ColorModel;
import java.awt.image.Raster;

import javax.naming.NameNotFoundException;

import org.apache.log4j.Logger;
import org.jnode.awt.util.BitmapGraphics;
import org.jnode.driver.DriverException;
import org.jnode.driver.bus.pci.PCIBaseAddress;
import org.jnode.driver.bus.pci.PCIDevice;
import org.jnode.driver.bus.pci.PCIHeaderType0;
import org.jnode.driver.video.FrameBufferConfiguration;
import org.jnode.driver.video.ddc.DisplayDataChannelAPI;
import org.jnode.driver.video.spi.DpmsState;
import org.jnode.driver.video.util.AbstractSurface;
import org.jnode.driver.video.vgahw.DisplayMode;
import org.jnode.naming.InitialNaming;
import org.jnode.system.resource.MemoryResource;
import org.jnode.system.resource.ResourceManager;
import org.jnode.system.resource.ResourceNotFreeException;
import org.jnode.util.NumberUtils;
import org.vmmagic.unboxed.Address;

/**
 * @author Ewout Prangsma (epr@users.sourceforge.net)
 */
public class NVidiaCore extends AbstractSurface implements NVidiaConstants, DisplayDataChannelAPI {
    /** Acceleration functions */
    private final NVidiaAcceleration acc;
    private final int architecture;
    private BitmapGraphics bitmapGraphics;
    private int bitsPerPixel = 32;
    private int bytesPerLine;
    private FrameBufferConfiguration config;
    private final int CrystalFreqKHz;
    private final int DDCBase = 0x3e;
    private final NVidiaDriver driver;
    /** Hardware cursor implementation */
    private final NVidiaHardwareCursor hwCursor;
    /** My logger */
    private static final Logger log = Logger.getLogger(NVidiaCore.class);
    private final int MaxVClockFreqKHz;
    /** Size of card memory in MB */
    private final int memSize;
    private final MemoryResource mmio;
    private final NVidiaVgaState oldVgaState = new NVidiaVgaState();
    /** Should acceleration be used */
    private final boolean useAcc = true;
    private final NVidiaVgaIO vgaIO;
    private final MemoryResource videoRam;

    /**
     * @param driver
     * @param architecture
     * @param model
     * @param device
     */
    public NVidiaCore(NVidiaDriver driver, int architecture, String model, PCIDevice device)
        throws ResourceNotFreeException, DriverException {
        super(640, 480);
        this.driver = driver;
        this.architecture = architecture;
        final PCIHeaderType0 pciCfg = device.getConfig().asHeaderType0();
        final PCIBaseAddress ioAddr = pciCfg.getBaseAddresses()[0];
        final PCIBaseAddress fbAddr = pciCfg.getBaseAddresses()[1];
        log.info("Found NVidia " + model + ", chipset 0x" + NumberUtils.hex(pciCfg.getRevision()));
        try {
            final ResourceManager rm = InitialNaming.lookup(ResourceManager.NAME);
            final int ioBase = (int) ioAddr.getMemoryBase() & 0xFF800000;
            final int ioSize = ioAddr.getSize();
            final int fbBase = (int) fbAddr.getMemoryBase() & 0xFF800000;
            final int fbSize = fbAddr.getSize();

            log.debug("Found NVidia, FB at 0x" + NumberUtils.hex(fbBase) + "s0x" +
                    NumberUtils.hex(fbSize) + ", MMIO at 0x" + NumberUtils.hex(ioBase));

            this.mmio =
                    rm.claimMemoryResource(device, Address.fromIntZeroExtend(ioBase), ioSize,
                            ResourceManager.MEMMODE_NORMAL);
            this.videoRam =
                    rm.claimMemoryResource(device, Address.fromIntZeroExtend(fbBase), fbSize,
                            ResourceManager.MEMMODE_NORMAL);
            this.vgaIO = new NVidiaVgaIO(mmio, videoRam);

        } catch (NameNotFoundException ex) {
            throw new ResourceNotFreeException(ex);
        }
        this.hwCursor = new NVidiaHardwareCursor(vgaIO, architecture);
        this.acc = new NVidiaAcceleration(vgaIO, architecture);
        this.memSize = getMemorySize();
        int bootInfo;
        
        switch (architecture) {
            case NV04A:
                bootInfo = vgaIO.getReg32(NV32_NVSTRAPINFO2);
                CrystalFreqKHz = ((bootInfo & 0x00000040) != 0) ? 14318 : 13500;
                MaxVClockFreqKHz = 250000;
                break;
            case NV10A:
                bootInfo = vgaIO.getReg32(NV32_NVSTRAPINFO2);
                CrystalFreqKHz = ((bootInfo & 0x00000040) != 0) ? 14318 : 13500;
                MaxVClockFreqKHz = 350000;
                break;
            case NV28M:
                bootInfo = vgaIO.getReg32(NV32_NVSTRAPINFO2);
                CrystalFreqKHz = ((bootInfo & 0x00000040) != 0) ? 14318 : 13500;
                MaxVClockFreqKHz = 200000;
                break;
            default:
                throw new DriverException("Unknown architecture " + architecture);
        }
        log.debug("Memory size     =" + memSize + "MB");
        log.debug("CrystalFreqKHz  =" + CrystalFreqKHz);
        log.debug("MaxVClockFreqKHz=" + MaxVClockFreqKHz);
    }

    /**
     * Calculate the best VClock settings
     * 
     * @param clockIn
     * @return The best values in the form of { M, N, P, clock }
     */
    private int[] calcVCLock(int clockIn) {
        int DeltaOld = Integer.MAX_VALUE;
        final int VClk = clockIn;
        final int lowM;
        final int highM;
        final boolean isNV3 = (architecture < NV04A);
        if (CrystalFreqKHz == 14318) {
            lowM = 8;
            highM = 14 - (isNV3 ? 1 : 0);
        } else {
            lowM = 7;
            highM = 13 - (isNV3 ? 1 : 0);
        }
        final int highP = 4 - (isNV3 ? 1 : 0);
        final int best[] = new int[4];
        for (int P = 0; P <= highP; P++) {
            int Freq = VClk << P;
            if ((Freq >= 128000) && (Freq <= MaxVClockFreqKHz)) {
                for (int M = lowM; M <= highM; M++) {
                    final int N = (VClk * M / CrystalFreqKHz) << P;
                    final int DeltaNew;
                    Freq = (CrystalFreqKHz * N / M) >> P;
                    if (Freq > VClk) {
                        DeltaNew = Freq - VClk;
                    } else {
                        DeltaNew = VClk - Freq;
                    }
                    if (DeltaNew < DeltaOld) {
                        best[0] = M;
                        best[1] = N;
                        best[2] = P;
                        best[3] = Freq;
                        DeltaOld = DeltaNew;
                    }
                }
            }
        }
        if (DeltaOld == Integer.MAX_VALUE) {
            throw new RuntimeException("Cannot find a suitable VClock");
        } else {
            return best;
        }
    }

    /**
     * Close the SVGA screen
     * 
     * @see org.jnode.driver.video.Surface#close()
     */
    public synchronized void close() {
        log.debug("close");
        hwCursor.closeCursor();
        final DpmsState dpmsState = getDpms();
        log.debug("Old DPMS state: " + dpmsState);
        setDpms(DpmsState.OFF);
        vgaIO.unlock();
        log.debug("restore old VGA state");
        oldVgaState.restoreToVGA(vgaIO);
        log.debug("restore DPMS state");
        setDpms(dpmsState);

        // For debugging purposes
        // final NVidiaVgaState debugState = new NVidiaVgaState();
        // debugState.saveFromVGA(vgaIO);
        // log.debug("Restored state: " + debugState);
        // End of debugging purposes

        driver.close(this);
        super.close();
        log.debug("End of close");
    }

    /**
     * Terminate a DDC1 readout
     */
    public void closeDDC1() {
        // Disable access to extended registers
        // vgaIO.lock();
    }

    /**
     * @see org.jnode.driver.video.util.AbstractSurface#convertColor(java.awt.Color)
     */
    protected int convertColor(Color color) {
        return color.getRGB();
    }

    /**
     * @see org.jnode.driver.video.Surface#copyArea(int, int, int, int, int,
     *      int)
     */
    public void copyArea(int x, int y, int width, int height, int dx, int dy) {
        bitmapGraphics.copyArea(x, y, width, height, dx, dy);
    }

    /**
     * @see org.jnode.driver.video.Surface#drawCompatibleRaster(java.awt.image.Raster,
     *      int, int, int, int, int, int, java.awt.Color)
     */
    public final void drawCompatibleRaster(Raster raster, int srcX, int srcY, int dstX, int dstY,
            int width, int height, Color bgColor) {
        if (bgColor == null) {
            bitmapGraphics.drawImage(raster, srcX, srcY, dstX, dstY, width, height);
        } else {
            bitmapGraphics.drawImage(raster, srcX, srcY, dstX, dstY, width, height,
                    convertColor(bgColor));
        }
    }

    /**
     * @see org.jnode.driver.video.util.AbstractSurface#drawPixel(int, int, int,
     *      int)
     */
    public final void drawPixel(int x, int y, int color, int mode) {
        bitmapGraphics.drawPixels(x, y, 1, color, mode);
    }

    /**
     * @see org.jnode.driver.video.util.AbstractSurface#fillRect(int, int, int,
     *      int, int, int)
     */
    public void fillRect(int x, int y, int w, int h, int color, int mode) {
        final int screenWidth = config.getScreenWidth();
        if (x + w >= screenWidth) {
            w = screenWidth - x;
        }
        if (useAcc && (mode == PAINT_MODE)) {
            acc.setupRectangle(color);
            acc.fillRectangle(x, y, w, h);
        } else {
            if ((x == 0) && (w == screenWidth)) {
                bitmapGraphics.drawPixels(0, y, screenWidth * height, color, mode);
            } else {
                super.fillRect(x, y, w, h, color, mode);
            }
        }
    }

    /**
     * @see org.jnode.driver.video.Surface#getColorModel()
     */
    public ColorModel getColorModel() {
        return config.getColorModel();
    }

    /**
     * @see org.jnode.driver.video.ddc.DisplayDataChannelAPI#getDDC1Bit()
     */
    public boolean getDDC1Bit() {
        /* wait for Vsync */
        while ((vgaIO.getSTAT() & 0x08) != 0) { /* wait */
        }
        while ((vgaIO.getSTAT() & 0x08) == 0) { /* wait */
        }

        /* Get the result */
        final int val = vgaIO.getCRT(DDCBase);
        // log.debug("getDDC1Bit: val=0x" + NumberUtils.hex(val, 2));
        return ((val & DDC_SDA_READ_MASK) != 0);
    }

    /**
     * Gets the current DPMS state
     * 
     * @return
     */
    private DpmsState getDpms() {
        final boolean display = ((vgaIO.getSEQ(NVSEQX_CLKMODE) & 0x20) == 0);
        final int repaint1 = vgaIO.getCRT(NVCRTCX_REPAINT1);
        final boolean hsync = ((repaint1 & 0x80) == 0);
        final boolean vsync = ((repaint1 & 0x40) == 0);
        return new DpmsState(display, hsync, vsync);
    }

    /**
     * Gets the hardware cursor implementation
     */
    public NVidiaHardwareCursor getHardwareCursor() {
        return hwCursor;
    }

    /**
     * Detect the size of installed memory.
     * 
     * @return Size in MB.
     */
    private final int getMemorySize() {
        final int size;
        if (architecture == NV04A) {
            final int strapinfo = vgaIO.getReg32(NV32_NV4STRAPINFO);

            if ((strapinfo & 0x00000100) != 0) {
                /* Unified memory architecture used */
                log.debug("INFO: NV4 architecture chip with UMA detected");
                size = ((((strapinfo & 0x0000f000) >> 12) * 2) + 2);

            } else {
                /* private memory architecture used */
                switch (strapinfo & 0x00000003) {
                    case 0:
                        size = 32;
                        break;
                    case 1:
                        size = 4;
                        break;
                    case 2:
                        size = 8;
                        break;
                    case 3:
                        size = 16;
                        break;
                    default:
                        // Cannot get here, but just to keep the compiler
                        // silent.
                        size = 8;
                }
            }
        } else {
            // NV10, NV20
            // final int dev_manID = CFGR(DEVID);
            final int strapinfo = vgaIO.getReg32(NV32_NV10STRAPINFO);

            // case 0x01a010de: /* Nvidia GeForce2 Integrated GPU */
            // size = (((CFGR(GF2IGPU) & 0x000007c0) >> 6) + 1);
            // break;
            // case 0x01f010de: /* Nvidia GeForce4 MX Integrated GPU */
            // size = (((CFGR(GF4MXIGPU) & 0x000007f0) >> 4) + 1);
            // remove this line if det. is OK: int amt = pciReadLong(pciTag(0,
            // 0, 1), 0x84);
            // break;
            log.info("strapinfo " + strapinfo);
            switch ((strapinfo & 0x0ff00000) >> 20) {
                case 2:
                    size = 2;
                    break;
                case 4:
                    size = 4;
                    break;
                case 8:
                    size = 8;
                    break;
                case 16:
                    size = 16;
                    break;
                case 32:
                    size = 32;
                    break;
                case 64:
                    size = 64;
                    break;
                case 128:
                    size = 128;
                    break;
                default:
                    size = 16;
                    log
                            .info("NV10/20 architecture chip with unknown RAM amount detected, setting 16Mb");
                    break;
            }
        }
        return size;
    }

    /**
     * Gets the start address of the video memory
     */
    final int getVideoStartAddress() {
        int startadd = 0;
        if (architecture < NV10A) {
            /* upto 32Mb RAM adressing: must be used this way on pre-NV10! */

            /* set standard registers */
            /* (NVidia: startadress in 32bit words (b2 - b17) */
            startadd |= ((vgaIO.getCRT(NVCRTCX_FBSTADDL) & 0xFF) << 2);
            startadd |= ((vgaIO.getCRT(NVCRTCX_FBSTADDH) & 0xFF) << 10);

            /* set extended registers */
            /* NV4 extended bits: (b18-22) */
            int temp = vgaIO.getCRT(NVCRTCX_REPAINT0) & 0x1f;
            startadd |= (temp << 18);
            /* NV4 extended bits: (b23-24) */
            temp = vgaIO.getCRT(NVCRTCX_HEB) & 0x60;
            startadd |= (temp << 18);
        } else {
            /* upto 4Gb RAM adressing: must be used on NV10 and later! */
            /*
             * NOTE: While this register also exists on pre-NV10 cards, it will
             * wrap-around at 16Mb boundaries!!
             */

            /* 30bit adress in 32bit words */
            startadd = vgaIO.getReg32(NV32_NV10FBSTADD32) & 0xfffffffc;
        }
        return startadd;
    }

    /**
     * Open the given configuration
     * 
     * @param config
     */
    final void open(NVidiaConfiguration config) {
        this.config = config;
        // Save the current state
        oldVgaState.saveFromVGA(vgaIO);
        // log.debug("Old VGA State: " + oldVgaState);
        // log.debug("Old start address:0x" +
        // NumberUtils.hex(getVideoStartAddress()));

        // Enabled access to extended registers
        vgaIO.unlock();

        // Turn off the screen
        final DpmsState dpmsState = getDpms();
        // log.debug("Old DPMS state: " + dpmsState);
        setDpms(DpmsState.OFF);

        /* power-up all nvidia hardware function blocks */
        /*
         * bit 28: OVERLAY ENGINE (BES), bit 25: CRTC2, (> NV04A) bit 24: CRTC1,
         * bit 20: framebuffer, bit 16: PPMI, bit 12: PGRAPH, bit 8: PFIFO, bit
         * 4: PMEDIA, bit 0: TVOUT. (> NV04A)
         */
        // log.debug("PWRUPCTRL=0x" +
        // NumberUtils.hex(mmio.getInt(NV32_PWRUPCTRL)));
        mmio.setInt(NV32_PWRUPCTRL, 0x13111111);

        // Set the new configuration
        this.bitsPerPixel = config.getBitsPerPixel();
        this.width = config.getScreenWidth();
        this.height = config.getScreenHeight();
        final int pixelDepth = (this.bitsPerPixel + 1) / 8;
        this.bytesPerLine = width * pixelDepth;
        final int startAddress = 2048;
        try {
            final NVidiaVgaState newState = config.getVgaState();
            newState.calcForConfiguration(config, architecture, vgaIO);
            newState.restoreToVGA(vgaIO);
            setPLL(config.getMode());
            // setColourDepth
            setPalette(1.0f);
            // setDacMode
            setPitch(bytesPerLine);
            setVideoStartAddress(startAddress);
            setTiming(config.getMode());
            hwCursor.initCursor();
            // Setup accelration
            acc.accInit(startAddress, bytesPerLine, memSize, bitsPerPixel);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        // Create the graphics helper & clear the screen
        final int pixels = width * height;
        switch (bitsPerPixel) {
            case 8:
                bitmapGraphics =
                        BitmapGraphics.create8bppInstance(videoRam, width, height, bytesPerLine,
                                startAddress);
                videoRam.setByte(startAddress, (byte) 0, pixels);
                break;
            case 16:
                bitmapGraphics =
                        BitmapGraphics.create16bppInstance(videoRam, width, height, bytesPerLine,
                                startAddress);
                videoRam.setShort(startAddress, (byte) 0, pixels);
                break;
            case 24:
                bitmapGraphics =
                        BitmapGraphics.create24bppInstance(videoRam, width, height, bytesPerLine,
                                startAddress);
                videoRam.setInt24(startAddress, 0, pixels);
                break;
            case 32:
                bitmapGraphics =
                        BitmapGraphics.create32bppInstance(videoRam, width, height, bytesPerLine,
                                startAddress);
                videoRam.setInt(startAddress, 0, pixels);
                break;
        }

        // Turn the screen back on
        setDpms(dpmsState);

    }

    /**
     * Release all resources
     */
    final void release() {
        mmio.release();
        videoRam.release();
    }

    private void setDpms(DpmsState state) {
        // log.debug("Setting DPMS to " + state);
        /* start synchronous reset: required before turning screen off! */
        vgaIO.setSEQ(NVSEQX_RESET, 0x01);

        /* turn screen off */
        int clkmode = vgaIO.getSEQ(NVSEQX_CLKMODE);
        if (state.isDisplay()) {
            vgaIO.setSEQ(NVSEQX_CLKMODE, clkmode & ~0x20);
            /* end synchronous reset if display should be enabled */
            vgaIO.setSEQ(NVSEQX_RESET, 0x03);
        } else {
            vgaIO.setSEQ(NVSEQX_CLKMODE, clkmode | 0x20);
        }

        int repaint1 = vgaIO.getCRT(NVCRTCX_REPAINT1);
        if (state.isHsync()) {
            repaint1 &= 0x7f;
        } else {
            repaint1 |= 0x80;
        }
        if (state.isVsync()) {
            repaint1 &= 0xbf;
        } else {
            repaint1 |= 0x40;
        }
        vgaIO.setCRT(NVCRTCX_REPAINT1, repaint1);
    }

    private final void setPalette(float brightness) {
        vgaIO.setReg8(NV8_PALMASK, 0xff);
        for (int i = 0; i < 256; i++) {
            int v = (int) (i * brightness);
            if (v > 255) {
                v = 255;
            }
            vgaIO.setDACWriteIndex(i);
            vgaIO.setDACData(v); // r
            vgaIO.setDACData(v); // g
            vgaIO.setDACData(v); // b
        }
    }

    private void setPitch(int bytesPerLine) {
        final int offset = bytesPerLine / 8;
        // log.info("setPitch: offset 0x" + NumberUtils.hex(offset) + "
        // bytesPerLine 0x" + NumberUtils.hex(bytesPerLine));
        // program the card!
        vgaIO.setCRT(NVCRTCX_PITCHL, offset & 0x00ff);
        final int temp = vgaIO.getCRT(NVCRTCX_REPAINT0);
        vgaIO.setCRT(NVCRTCX_REPAINT0, (temp & 0x1f) | ((offset & 0x0700) >> 3));
    }

    private void setPLL(DisplayMode mode) {
        final int[] best = calcVCLock(mode.getFreq());
        final int m = best[0];
        final int n = best[1];
        final int p = best[2];
        final int freq = best[3];
        log.debug("Programming PLL to M" + NumberUtils.hex(m, 2) + " N" + NumberUtils.hex(n, 2) +
                " P" + NumberUtils.hex(p, 2) + " at " + freq + "KHz");

        // select pixelPLL registerset C
        vgaIO.setReg32(NVDAC_PLLSEL, 0x10000700);

        // program new frequency
        vgaIO.setReg32(NVDAC_PIXPLLC, ((p << 16) | (n << 8) | m));
    }

    private void setTiming(DisplayMode mode) {
        log.debug("Setting timing to " + mode);
        // Modify parameters as required by standard VGA
        final int htotal = ((mode.getHTotal() >> 3) - 5);
        final int hdisp_e = ((mode.getWidth() >> 3) - 1);
        final int hblnk_s = hdisp_e;
        final int hblnk_e = (htotal + 4); // 0;
        final int hsync_s = (mode.getHsyncStart() >> 3);
        final int hsync_e = (mode.getHsyncEnd() >> 3);

        final int vtotal = mode.getVTotal() - 2;
        final int vdisp_e = mode.getHeight() - 1;
        final int vblnk_s = vdisp_e;
        final int vblnk_e = (vtotal + 1);
        final int vsync_s = mode.getVsyncStart(); // -1;
        final int vsync_e = mode.getVsyncEnd(); // -1;

        log.debug("HOR:" + htotal + " " + hdisp_e + " " + hblnk_s + " " + hblnk_e + " " + hsync_s +
                " " + hsync_e);
        log.debug("VER:" + vtotal + " " + vdisp_e + " " + vblnk_s + " " + vblnk_e + " " + vsync_s +
                " " + vsync_e);

        /*
         * prevent memory adress counter from being reset (linecomp may not
         * occur)
         */
        final int linecomp = 0x3ff; // mode.getHeight();

        // fixme: flatpanel 'don't touch' update needed for 'Go' cards!?!
        if (true) {
            /* actually program the card! */
            /* unlock CRTC registers at index 0-7 */
            // vgaIO.setCRT(NVCRTCX_LOCK, 0x57);
            vgaIO.unlock();
            /* horizontal standard VGA regs */
            vgaIO.setCRT(NVCRTCX_HTOTAL, (htotal & 0xff));
            vgaIO.setCRT(NVCRTCX_HDISPE, (hdisp_e & 0xff));
            vgaIO.setCRT(NVCRTCX_HBLANKS, (hblnk_s & 0xff));
            /* also unlock vertical retrace registers in advance */
            vgaIO.setCRT(NVCRTCX_HBLANKE, ((hblnk_e & 0x1f) | 0x80));
            vgaIO.setCRT(NVCRTCX_HSYNCS, (hsync_s & 0xff));
            vgaIO.setCRT(NVCRTCX_HSYNCE, ((hsync_e & 0x1f) | ((hblnk_e & 0x20) << 2)));

            /* vertical standard VGA regs */
            vgaIO.setCRT(NVCRTCX_VTOTAL, (vtotal & 0xff));
            int overflow = 0;
            overflow |= ((vtotal & 0x100) >> (8 - 0)); // VDT_8
            overflow |= ((vdisp_e & 0x100) >> (8 - 1)); // VDE_8
            overflow |= ((vsync_s & 0x100) >> (8 - 2)); // VRS_8
            overflow |= ((vblnk_s & 0x100) >> (8 - 3)); // VBS_8
            overflow |= ((vtotal & 0x200) >> (9 - 5)); // VDT_9
            overflow |= ((vdisp_e & 0x200) >> (9 - 6)); // VDE_9
            overflow |= ((vsync_s & 0x200) >> (9 - 7)); // VRS_9
            vgaIO.setCRT(NVCRTCX_OVERFLOW, overflow);
            vgaIO.setCRT(NVCRTCX_PRROWSCN, 0x00); /* not used */

            int maxsclin = 0;
            maxsclin |= ((vblnk_s & 0x200) >> (9 - 5)); // VBS_9
            maxsclin |= ((linecomp & 0x200) >> (9 - 6)); // LC_9
            vgaIO.setCRT(NVCRTCX_MAXSCLIN, maxsclin);
            vgaIO.setCRT(NVCRTCX_VSYNCS, (vsync_s & 0xff));
            vgaIO
                    .setCRT(NVCRTCX_VSYNCE,
                            ((vgaIO.getCRT(NVCRTCX_VSYNCE) & 0x70) | (vsync_e & 0x0f)));
            vgaIO.setCRT(NVCRTCX_VDISPE, (vdisp_e & 0xff));
            vgaIO.setCRT(NVCRTCX_VBLANKS, (vblnk_s & 0xff));
            vgaIO.setCRT(NVCRTCX_VBLANKE, (vblnk_e & 0xff));
            vgaIO.setCRT(NVCRTCX_LINECOMP, (linecomp & 0xff));

            /* horizontal extended regs */
            int heb = vgaIO.getCRT(NVCRTCX_HEB) & 0xe0;
            heb |= ((htotal & 0x100) >> (8 - 0)); // HDT_8
            heb |= ((hdisp_e & 0x100) >> (8 - 1)); // HDE_8
            heb |= ((hblnk_s & 0x100) >> (8 - 2)); // HBS_8
            heb |= ((hsync_s & 0x100) >> (8 - 3)); // HRS_8
            heb |= ((linecomp & 0x100) >> (8 - 4)); // ILC_8
            vgaIO.setCRT(NVCRTCX_HEB, heb);

            /* (mostly) vertical extended regs */
            int lsr = vgaIO.getCRT(NVCRTCX_LSR) & 0xc0;
            lsr |= ((vtotal & 0x400) >> (10 - 0)); // VDT_10
            lsr |= ((vdisp_e & 0x400) >> (10 - 1)); // VDE_10
            lsr |= ((vsync_s & 0x400) >> (10 - 2)); // VRS_10
            lsr |= ((vblnk_s & 0x400) >> (10 - 3)); // VRBS_10
            lsr |= ((hblnk_e & 0x040) >> (6 - 4)); // HBE_6
            vgaIO.setCRT(NVCRTCX_LSR, lsr);

            // extra
            int ebr = 0;
            ebr |= ((vtotal & 0x800) >> (11 - 0)); // VDT_11
            ebr |= ((vdisp_e & 0x800) >> (11 - 2)); // VDE_11
            ebr |= ((vsync_s & 0x800) >> (11 - 4)); // VRS_11
            ebr |= ((vblnk_s & 0x800) >> (11 - 8)); // VBS_11
            vgaIO.setCRT(NVCRTCX_EBR, ebr);

            /* setup 'large screen' mode */
            final int repaint1 = vgaIO.getCRT(NVCRTCX_REPAINT1);
            if (mode.getWidth() >= 1280) {
                vgaIO.setCRT(NVCRTCX_REPAINT1, (repaint1 & 0xfb));
            } else {
                vgaIO.setCRT(NVCRTCX_REPAINT1, (repaint1 | 0x04));
            }

            /* setup HSYNC & VSYNC polarity */
            /*
             * LOG(2, ("CRTC: sync polarity: ")); int temp =
             * vgaIO.getReg8(NV8_MISCR); if (target.timing.flags &
             * B_POSITIVE_HSYNC) { LOG(2, ("H:pos ")); temp &= ~0x40; } else {
             * LOG(2, ("H:neg ")); temp |= 0x40; } if (target.timing.flags &
             * B_POSITIVE_VSYNC) { LOG(2, ("V:pos ")); temp &= ~0x80; } else {
             * LOG(2, ("V:neg ")); temp |= 0x80; }
             */
        }
    }

    /**
     * Start a DDC1 readout
     */
    public void setupDDC1() {
        // Enable access to extended registers
        // vgaIO.unlock();
        vgaIO.setCRT(NVCRTCX_LOCK, 0x57);
    }

    /**
     * Sets the start address of the video memory
     * 
     * @param startadd
     */
    private void setVideoStartAddress(int startadd) {
        if (architecture < NV10A) {
            /* upto 32Mb RAM adressing: must be used this way on pre-NV10! */

            /* set standard registers */
            /* (NVidia: startadress in 32bit words (b2 - b17) */
            vgaIO.setCRT(NVCRTCX_FBSTADDL, (startadd >> 2) & 0xFF);
            vgaIO.setCRT(NVCRTCX_FBSTADDH, (startadd >> 10) & 0xFF);

            /* set extended registers */
            /* NV4 extended bits: (b18-22) */
            int temp = vgaIO.getCRT(NVCRTCX_REPAINT0) & 0xE0;
            vgaIO.setCRT(NVCRTCX_REPAINT0, temp | ((startadd >> 18) & 0x1f));
            /* NV4 extended bits: (b23-24) */
            temp = vgaIO.getCRT(NVCRTCX_HEB) & 0xdf;
            vgaIO.setCRT(NVCRTCX_HEB, temp | ((startadd >> 18) & 0x20));
            // temp = (CRTCR(HEB) & 0x9f);
            // CRTCW(HEB, (temp | ((startadd & 0x01800000) >> 18)));
        } else {
            /* upto 4Gb RAM adressing: must be used on NV10 and later! */
            /*
             * NOTE: While this register also exists on pre-NV10 cards, it will
             * wrap-around at 16Mb boundaries!!
             */

            /* 30bit adress in 32bit words */
            vgaIO.setReg32(NV32_NV10FBSTADD32, startadd & 0xfffffffc);
        }

        int temp = vgaIO.getATT(NVATBX_HORPIXPAN) & 0xf9;
        vgaIO.setATT(NVATBX_HORPIXPAN, temp | ((startadd & 3) << 1));
    }

    /**
     * @see org.jnode.driver.video.Surface#drawAlphaRaster(java.awt.image.Raster,
     *      java.awt.geom.AffineTransform, int, int, int, int, int, int,
     *      java.awt.Color)
     */
    public void drawAlphaRaster(Raster raster, AffineTransform tx, int srcX, int srcY, int dstX,
            int dstY, int width, int height, Color color) {
        bitmapGraphics.drawAlphaRaster(raster, tx, srcX, srcY, dstX, dstY, width, height,
                convertColor(color));
    }

    @Override
    public int getRGBPixel(int x, int y) {
        return bitmapGraphics.doGetPixel(x, y);
    }

    @Override
    public int[] getRGBPixels(Rectangle region) {
        return bitmapGraphics.doGetPixels(region);
    }
}