/* Authors:
   Mark Watson 12/1999,
   Apsed,
   Rudolf Cornelissen 10/2002-2/2016
*/

#define MODULE_BIT 0x00008000

#include "std.h"

static status_t test_ram(void);
static status_t engxx_general_powerup (void);
static status_t eng_general_bios_to_powergraphics(void);

static void eng_dump_configuration_space (void)
{
#define DUMP_CFG(reg, type) if (si->ps.card_type >= type) do { \
        uint32 value = CFGR(reg); \
        MSG(("configuration_space 0x%02x %20s 0x%08x\n", \
                ENCFG_##reg, #reg, value)); \
} while (0)
        DUMP_CFG (DEVID,        0);
        DUMP_CFG (DEVCTRL,      0);
        DUMP_CFG (CLASS,        0);
        DUMP_CFG (HEADER,       0);
        DUMP_CFG (BASE1REGS,0);
        DUMP_CFG (BASE2FB,      0);
        DUMP_CFG (BASE3,        0);
        DUMP_CFG (BASE4,        0);
        DUMP_CFG (BASE5,        0);
        DUMP_CFG (BASE6,        0);
        DUMP_CFG (BASE7,        0);
        DUMP_CFG (SUBSYSID1,0);
        DUMP_CFG (ROMBASE,      0);
        DUMP_CFG (CAPPTR,       0);
        DUMP_CFG (CFG_1,        0);
        DUMP_CFG (INTERRUPT,0);
        DUMP_CFG (SUBSYSID2,0);
        DUMP_CFG (AGPREF,       0);
        DUMP_CFG (AGPSTAT,      0);
        DUMP_CFG (AGPCMD,       0);
        DUMP_CFG (ROMSHADOW,0);
        DUMP_CFG (VGA,          0);
        DUMP_CFG (SCHRATCH,     0);
        DUMP_CFG (CFG_10,       0);
        DUMP_CFG (CFG_11,       0);
        DUMP_CFG (CFG_12,       0);
        DUMP_CFG (CFG_13,       0);
        DUMP_CFG (CFG_14,       0);
        DUMP_CFG (CFG_15,       0);
        DUMP_CFG (CFG_16,       0);
        DUMP_CFG (CFG_17,       0);
        DUMP_CFG (CFG_18,       0);
        DUMP_CFG (CFG_19,       0);
        DUMP_CFG (CFG_20,       0);
        DUMP_CFG (CFG_21,       0);
        DUMP_CFG (CFG_22,       0);
        DUMP_CFG (CFG_23,       0);
        DUMP_CFG (CFG_24,       0);
        DUMP_CFG (CFG_25,       0);
        DUMP_CFG (CFG_26,       0);
        DUMP_CFG (CFG_27,       0);
        DUMP_CFG (CFG_28,       0);
        DUMP_CFG (CFG_29,       0);
        DUMP_CFG (CFG_30,       0);
        DUMP_CFG (CFG_31,       0);
        DUMP_CFG (CFG_32,       0);
        DUMP_CFG (CFG_33,       0);
        DUMP_CFG (CFG_34,       0);
        DUMP_CFG (CFG_35,       0);
        DUMP_CFG (CFG_36,       0);
        DUMP_CFG (CFG_37,       0);
        DUMP_CFG (CFG_38,       0);
        DUMP_CFG (CFG_39,       0);
        DUMP_CFG (CFG_40,       0);
        DUMP_CFG (CFG_41,       0);
        DUMP_CFG (CFG_42,       0);
        DUMP_CFG (CFG_43,       0);
        DUMP_CFG (CFG_44,       0);
        DUMP_CFG (CFG_45,       0);
        DUMP_CFG (CFG_46,       0);
        DUMP_CFG (CFG_47,       0);
        DUMP_CFG (CFG_48,       0);
        DUMP_CFG (CFG_49,       0);
        DUMP_CFG (CFG_50,       0);
#undef DUMP_CFG
}

status_t eng_general_powerup()
{
        status_t status;

        LOG(1,("POWERUP: Haiku VIA Accelerant 0.19 running.\n"));

        /* preset no laptop */
        si->ps.laptop = false;

        /* detect card type and power it up */
        switch(CFGR(DEVID))
        {
        /* Vendor Via */
        case 0x30221106:
                si->ps.card_type = VT3022;
                si->ps.card_arch = CLE266;
                LOG(4,("POWERUP: Detected VIA CLE266 Unichrome Pro (VT3022)\n"));
                status = engxx_general_powerup();
                break;
        case 0x31081106:
                si->ps.card_type = VT3108;
                si->ps.card_arch = K8M800;
                LOG(4,("POWERUP: Detected VIA K8M800 Unichrome Pro (VT3108)\n"));
                status = engxx_general_powerup();
                break;
        case 0x31221106:
                si->ps.card_type = VT3122;
                si->ps.card_arch = CLE266;
                LOG(4,("POWERUP: Detected VIA CLE266 Unichrome Pro (VT3122)\n"));
                status = engxx_general_powerup();
                break;
        case 0x32051106:
                si->ps.card_type = VT3205;
                si->ps.card_arch = KM400;
                LOG(4,("POWERUP: Detected VIA KM400 Unichrome (VT3205)\n"));
                status = engxx_general_powerup();
                break;
        case 0x72051106:
                si->ps.card_type = VT7205;
                si->ps.card_arch = KM400;
                LOG(4,("POWERUP: Detected VIA KM400 Unichrome (VT7205)\n"));
                status = engxx_general_powerup();
                break;
        default:
                LOG(8,("POWERUP: Failed to detect valid card 0x%08x\n",CFGR(DEVID)));
                return B_ERROR;
        }

        return status;
}

static status_t test_ram()
{
        uint32 value, offset;
        status_t result = B_OK;

        /* make sure we don't corrupt the hardware cursor by using fbc.frame_buffer. */
        if (si->fbc.frame_buffer == NULL)
        {
                LOG(8,("INIT: test_ram detected NULL pointer.\n"));
                return B_ERROR;
        }

        for (offset = 0, value = 0x55aa55aa; offset < 256; offset++)
        {
                /* write testpattern to cardRAM */
                ((uint32 *)si->fbc.frame_buffer)[offset] = value;
                /* toggle testpattern */
                value = 0xffffffff - value;
        }

        for (offset = 0, value = 0x55aa55aa; offset < 256; offset++)
        {
                /* readback and verify testpattern from cardRAM */
                if (((uint32 *)si->fbc.frame_buffer)[offset] != value) result = B_ERROR;
                /* toggle testpattern */
                value = 0xffffffff - value;
        }
        return result;
}

/* NOTE:
 * This routine *has* to be done *after* SetDispplayMode has been executed,
 * or test results will not be representative!
 * (CAS latency is dependant on NV setup on some (DRAM) boards) */
status_t eng_set_cas_latency()
{
        status_t result = B_ERROR;
        uint8 latency = 0;

        /* check current RAM access to see if we need to change anything */
        if (test_ram() == B_OK)
        {
                LOG(4,("INIT: RAM access OK.\n"));
                return B_OK;
        }

        /* check if we read PINS at starttime so we have valid registersettings at our disposal */
        if (si->ps.pins_status != B_OK)
        {
                LOG(4,("INIT: RAM access errors; not fixable: PINS was not read from cardBIOS.\n"));
                return B_ERROR;
        }

        /* OK. We might have a problem, try to fix it now.. */
        LOG(4,("INIT: RAM access errors; tuning CAS latency if prudent...\n"));

        switch(si->ps.card_type)
        {
        default:
                        LOG(4,("INIT: RAM CAS tuning not implemented for this card, aborting.\n"));
                        return B_OK;
                        break;
        }
        if (result == B_OK)
                LOG(4,("INIT: RAM access OK. CAS latency set to %d cycles.\n", latency));
        else
                LOG(4,("INIT: RAM access not fixable. CAS latency set to %d cycles.\n", latency));

        return result;
}

void setup_virtualized_heads(bool cross)
{
        if (cross)
        {
                head1_validate_timing   = (crtc_validate_timing)        eng_crtc2_validate_timing;
                head1_set_timing                = (crtc_set_timing)                     eng_crtc2_set_timing;
                head1_depth                             = (crtc_depth)                          eng_crtc2_depth;
                head1_dpms                              = (crtc_dpms)                           eng_crtc2_dpms;
                head1_dpms_fetch                = (crtc_dpms_fetch)                     eng_crtc2_dpms_fetch;
                head1_set_display_pitch = (crtc_set_display_pitch)      eng_crtc2_set_display_pitch;
                head1_set_display_start = (crtc_set_display_start)      eng_crtc2_set_display_start;
                head1_cursor_init               = (crtc_cursor_init)            eng_crtc2_cursor_init;
                head1_cursor_show               = (crtc_cursor_show)            eng_crtc2_cursor_show;
                head1_cursor_hide               = (crtc_cursor_hide)            eng_crtc2_cursor_hide;
                head1_cursor_define             = (crtc_cursor_define)          eng_crtc2_cursor_define;
                head1_cursor_position   = (crtc_cursor_position)        eng_crtc2_cursor_position;

                head1_mode                              = (dac_mode)                            eng_dac2_mode;
                head1_palette                   = (dac_palette)                         eng_dac2_palette;
                head1_set_pix_pll               = (dac_set_pix_pll)                     eng_dac2_set_pix_pll;
                head1_pix_pll_find              = (dac_pix_pll_find)            eng_dac2_pix_pll_find;

                head2_validate_timing   = (crtc_validate_timing)        eng_crtc_validate_timing;
                head2_set_timing                = (crtc_set_timing)                     eng_crtc_set_timing;
                head2_depth                             = (crtc_depth)                          eng_crtc_depth;
                head2_dpms                              = (crtc_dpms)                           eng_crtc_dpms;
                head2_dpms_fetch                = (crtc_dpms_fetch)                     eng_crtc_dpms_fetch;
                head2_set_display_pitch = (crtc_set_display_pitch)      eng_crtc_set_display_pitch;
                head2_set_display_start = (crtc_set_display_start)      eng_crtc_set_display_start;
                head2_cursor_init               = (crtc_cursor_init)            eng_crtc_cursor_init;
                head2_cursor_show               = (crtc_cursor_show)            eng_crtc_cursor_show;
                head2_cursor_hide               = (crtc_cursor_hide)            eng_crtc_cursor_hide;
                head2_cursor_define             = (crtc_cursor_define)          eng_crtc_cursor_define;
                head2_cursor_position   = (crtc_cursor_position)        eng_crtc_cursor_position;

                head2_mode                              = (dac_mode)                            eng_dac_mode;
                head2_palette                   = (dac_palette)                         eng_dac_palette;
                head2_set_pix_pll               = (dac_set_pix_pll)                     eng_dac_set_pix_pll;
                head2_pix_pll_find              = (dac_pix_pll_find)            eng_dac_pix_pll_find;
        }
        else
        {
                head1_validate_timing   = (crtc_validate_timing)        eng_crtc_validate_timing;
                head1_set_timing                = (crtc_set_timing)                     eng_crtc_set_timing;
                head1_depth                             = (crtc_depth)                          eng_crtc_depth;
                head1_dpms                              = (crtc_dpms)                           eng_crtc_dpms;
                head1_dpms_fetch                = (crtc_dpms_fetch)                     eng_crtc_dpms_fetch;
                head1_set_display_pitch = (crtc_set_display_pitch)      eng_crtc_set_display_pitch;
                head1_set_display_start = (crtc_set_display_start)      eng_crtc_set_display_start;
                head1_cursor_init               = (crtc_cursor_init)            eng_crtc_cursor_init;
                head1_cursor_show               = (crtc_cursor_show)            eng_crtc_cursor_show;
                head1_cursor_hide               = (crtc_cursor_hide)            eng_crtc_cursor_hide;
                head1_cursor_define             = (crtc_cursor_define)          eng_crtc_cursor_define;
                head1_cursor_position   = (crtc_cursor_position)        eng_crtc_cursor_position;

                head1_mode                              = (dac_mode)                            eng_dac_mode;
                head1_palette                   = (dac_palette)                         eng_dac_palette;
                head1_set_pix_pll               = (dac_set_pix_pll)                     eng_dac_set_pix_pll;
                head1_pix_pll_find              = (dac_pix_pll_find)            eng_dac_pix_pll_find;

                head2_validate_timing   = (crtc_validate_timing)        eng_crtc2_validate_timing;
                head2_set_timing                = (crtc_set_timing)                     eng_crtc2_set_timing;
                head2_depth                             = (crtc_depth)                          eng_crtc2_depth;
                head2_dpms                              = (crtc_dpms)                           eng_crtc2_dpms;
                head2_dpms_fetch                = (crtc_dpms_fetch)                     eng_crtc2_dpms_fetch;
                head2_set_display_pitch = (crtc_set_display_pitch)      eng_crtc2_set_display_pitch;
                head2_set_display_start = (crtc_set_display_start)      eng_crtc2_set_display_start;
                head2_cursor_init               = (crtc_cursor_init)            eng_crtc2_cursor_init;
                head2_cursor_show               = (crtc_cursor_show)            eng_crtc2_cursor_show;
                head2_cursor_hide               = (crtc_cursor_hide)            eng_crtc2_cursor_hide;
                head2_cursor_define             = (crtc_cursor_define)          eng_crtc2_cursor_define;
                head2_cursor_position   = (crtc_cursor_position)        eng_crtc2_cursor_position;

                head2_mode                              = (dac_mode)                            eng_dac2_mode;
                head2_palette                   = (dac_palette)                         eng_dac2_palette;
                head2_set_pix_pll               = (dac_set_pix_pll)                     eng_dac2_set_pix_pll;
                head2_pix_pll_find              = (dac_pix_pll_find)            eng_dac2_pix_pll_find;
        }
}

void set_crtc_owner(bool head)
{
        if (si->ps.secondary_head)
        {
                if (!head)
                {
                        /* note: 'OWNER' is a non-standard register in behaviour(!) on NV11's,
                         * while non-NV11 cards behave normally.
                         *
                         * Double-write action needed on those strange NV11 cards: */
                        /* RESET: needed on NV11 */
                        CRTCW(OWNER, 0xff);
                        /* enable access to CRTC1, SEQ1, GRPH1, ATB1, ??? */
                        CRTCW(OWNER, 0x00);
                }
                else
                {
                        /* note: 'OWNER' is a non-standard register in behaviour(!) on NV11's,
                         * while non-NV11 cards behave normally.
                         *
                         * Double-write action needed on those strange NV11 cards: */
                        /* RESET: needed on NV11 */
                        CRTC2W(OWNER, 0xff);
                        /* enable access to CRTC2, SEQ2, GRPH2, ATB2, ??? */
                        CRTC2W(OWNER, 0x03);
                }
        }
}

static status_t engxx_general_powerup()
{
        LOG(4,("POWERUP: Chip revision is $%02x\n", si->ps.chip_rev));
        LOG(4, ("INIT: card powerup\n"));

        /* setup cardspecs */
        /* note:
         * this MUST be done before the driver attempts a card coldstart */
        set_specs();

        /* only process BIOS for finetuning specs and coldstarting card if requested
         * by the user;
         * note:
         * this in fact frees the driver from relying on the BIOS to be executed
         * at system power-up POST time. */
        if (!si->settings.usebios)
        {
                LOG(2, ("INIT: Attempting card coldstart!\n"));
                /* update the cardspecs in the shared_info PINS struct according to reported
                 * specs as much as is possible;
                 * this also coldstarts the card if possible (executes BIOS CMD script(s)) */
//              parse_pins();
        }
        else
        {
                LOG(2, ("INIT: Skipping card coldstart!\n"));
        }

        /* get RAM size and fake panel startup (panel init code is still missing) */
        fake_panel_start();

        /* log the final card specifications */
        dump_pins();

        /* dump config space as it is after a possible coldstart attempt */
        if (si->settings.logmask & 0x80000000) eng_dump_configuration_space();

        /* setup CRTC and DAC functions access: determined in fake_panel_start */
        setup_virtualized_heads(si->ps.crtc2_prim);

        /* do powerup needed from pre-inited card state as done by system POST cardBIOS
         * execution or driver coldstart above */
        return eng_general_bios_to_powergraphics();
}

/* this routine switches the CRTC/DAC sets to 'connectors', but only for analog
 * outputs. We need this to make sure the analog 'switch' is set in the same way the
 * digital 'switch' is set by the BIOS or we might not be able to use dualhead. */
status_t eng_general_output_select(bool cross)
{
        /* make sure this call is warranted */
        if (si->ps.secondary_head)
        {
                /* NV11 cards can't switch heads (confirmed) */
                if (si->ps.card_type != NV11)
                {
                        if (cross)
                        {
                                LOG(4,("INIT: switching analog outputs to be cross-connected\n"));

                                /* enable head 2 on connector 1 */
                                /* (b8 = select CRTC (head) for output,
                                 *  b4 = ??? (confirmed not to be a FP switch),
                                 *  b0 = enable CRT) */
                                DACW(OUTPUT, 0x00000101);
                                /* enable head 1 on connector 2 */
                                DAC2W(OUTPUT, 0x00000001);
                        }
                        else
                        {
                                LOG(4,("INIT: switching analog outputs to be straight-through\n"));

                                /* enable head 1 on connector 1 */
                                DACW(OUTPUT, 0x00000001);
                                /* enable head 2 on connector 2 */
                                DAC2W(OUTPUT, 0x00000101);
                        }
                }
                else
                {
                        LOG(4,("INIT: NV11 analog outputs are hardwired to be straight-through\n"));
                }
                return B_OK;
        }
        else
        {
                return B_ERROR;
        }
}

/* this routine switches CRTC/DAC set use. We need this because it's unknown howto
 * switch digital panels to/from a specific CRTC/DAC set. */
status_t eng_general_head_select(bool cross)
{
        /* make sure this call is warranted */
        if (si->ps.secondary_head)
        {
                /* invert CRTC/DAC use to do switching */
                if (cross)
                {
                        LOG(4,("INIT: switching CRTC/DAC use to be cross-connected\n"));
                        si->crtc_switch_mode = !si->ps.crtc2_prim;
                }
                else
                {
                        LOG(4,("INIT: switching CRTC/DAC use to be straight-through\n"));
                        si->crtc_switch_mode = si->ps.crtc2_prim;
                }
                /* update CRTC and DAC functions access */
                setup_virtualized_heads(si->crtc_switch_mode);

                return B_OK;
        }
        else
        {
                return B_ERROR;
        }
}

/* basic change of card state from VGA to enhanced mode:
 * Should work from VGA BIOS POST init state. */
static status_t eng_general_bios_to_powergraphics()
{
        /* let acc engine make power off/power on cycle to start 'fresh' */
//      ENG_REG32(RG32_PWRUPCTRL) = 0x13110011;
        snooze(1000);

        /* power-up all hardware function blocks */
//      ENG_REG32(RG32_PWRUPCTRL) = 0x13111111;

        /* select colormode CRTC registers base adresses,
         * but don't touch the current selected pixelclock source yet */
        ENG_REG8(RG8_MISCW) = (((ENG_REG8(RG8_MISCR)) & 0x0c) | 0xc3);

        /* unlock (extended) registers for R/W access */
        SEQW(LOCK, 0x01);
        CRTCW(VSYNCE ,(CRTCR(VSYNCE) & 0x7f));

        /* turn off both displays and the hardcursors (also disables transfers) */
        head1_dpms(false, false, false);
        head1_cursor_hide();
        if (si->ps.secondary_head)
        {
//              head2_dpms(false, false, false);
//              head2_cursor_hide();
        }

//      if (si->ps.secondary_head)
        if (0)
        {
                /* switch overlay engine to CRTC1 */
                /* bit 17: GPU FP port #1       (confirmed NV25, NV28, confirmed not on NV34),
                 * bit 16: GPU FP port #2       (confirmed NV25, NV28, NV34),
                 * bit 12: overlay engine       (all cards),
                 * bit  9: TVout chip #2        (confirmed on NV18, NV25, NV28),
                 * bit  8: TVout chip #1        (all cards),
                 * bit  4: both I2C busses      (all cards) */
                ENG_REG32(RG32_2FUNCSEL) &= ~0x00001000;
                ENG_REG32(RG32_FUNCSEL) |= 0x00001000;
        }
        si->overlay.crtc = false;

        /* set card to 'enhanced' mode: (only VGA standard registers used here) */
        /* (keep) card enabled, set plain normal memory usage, no old VGA 'tricks' ... */
        CRTCW(MODECTL, 0xc3);
        /* ... plain sequential memory use, more than 64Kb RAM installed,
         * switch to graphics mode ... */
        SEQW(MEMMODE, 0x0e);
        /* ... disable bitplane tweaking ... */
        GRPHW(ENSETRESET, 0x00);
        /* ... no logical function tweaking with display data, no data rotation ... */
        GRPHW(DATAROTATE, 0x00);
        /* ... reset read map select to plane 0 ... */
        GRPHW(READMAPSEL, 0x00);
        /* ... set standard mode ... */
        GRPHW(MODE, 0x00);
        /* ... ISA framebuffer mapping is 64Kb window, switch to graphics mode (again),
         * select standard adressing ... */
        GRPHW(MISC, 0x05);
        /* ... disable bit masking ... */
        GRPHW(BITMASK, 0xff);
        /* ... attributes are in color, switch to graphics mode (again) ... */
        ATBW(MODECTL, 0x01);
        /* ... set overscan color to black ... */
        ATBW(OSCANCOLOR, 0x00);
        /* ... enable all color planes ... */
        ATBW(COLPLANE_EN, 0x0f);
        /* ... reset horizontal pixelpanning ... */
        ATBW(HORPIXPAN, 0x00);
        /* ...  reset colorpalette groupselect bits ... */
        ATBW(COLSEL, 0x00);
        /* ... do unknown standard VGA register ... */
        ATBW(0x16, 0x01);
        /* ... and enable all four byteplanes. */
        SEQW(MAPMASK, 0x0f);
        /* setup sequencer clocking mode */
        SEQW(CLKMODE, 0x21);

        /* setup AGP:
         * Note:
         * This may only be done when no transfers are in progress on the bus, so now
         * is probably a good time.. */
        eng_agp_setup();

        /* turn screen one on */
        head1_dpms(true, true, true);

        return B_OK;
}

/* Check if mode virtual_size adheres to the cards _maximum_ contraints, and modify
 * virtual_size to the nearest valid maximum for the mode on the card if not so.
 * Also: check if virtual_width adheres to the cards granularity constraints, and
 * create mode slopspace if not so.
 * We use acc or crtc granularity constraints based on the 'worst case' scenario.
 *
 * Mode slopspace is reflected in fbc->bytes_per_row BTW. */
status_t eng_general_validate_pic_size (display_mode *target, uint32 *bytes_per_row, bool *acc_mode)
{
        uint32 video_pitch;
        uint32 acc_mask, crtc_mask;
        uint32 max_crtc_width, max_acc_width;
        uint8 depth = 8;

        /* determine pixel multiple based on 2D/3D engine constraints */
//via fixme.
        switch (si->ps.card_arch)
        {
        default:
                /* confirmed for:
                 * TNT1, TNT2, TNT2-M64, GeForce2 MX400, GeForce4 MX440, GeForceFX 5200 */
                switch (target->space)
                {
                        case B_CMAP8: acc_mask = 0x0f; depth =  8; break;
                        case B_RGB15: acc_mask = 0x07; depth = 16; break;
                        case B_RGB16: acc_mask = 0x07; depth = 16; break;
                        case B_RGB24: acc_mask = 0x0f; depth = 24; break;
                        case B_RGB32: acc_mask = 0x03; depth = 32; break;
                        default:
                                LOG(8,("INIT: unknown color space: 0x%08x\n", target->space));
                                return B_ERROR;
                }
                break;
        }

//via ok:
        /* determine pixel multiple based on CRTC memory pitch constraints.
         * (Note: Don't mix this up with CRTC timing contraints! Those are
         *        multiples of 8 for horizontal, 1 for vertical timing.) */
        switch (si->ps.card_type)
        {
        default:
                switch (target->space)
                {
                        case B_CMAP8: crtc_mask = 0x07; break;
                        case B_RGB15: crtc_mask = 0x03; break;
                        case B_RGB16: crtc_mask = 0x03; break;
                        case B_RGB24: crtc_mask = 0x07; break;
                        case B_RGB32: crtc_mask = 0x01; break;
                        default:
                                LOG(8,("INIT: unknown color space: 0x%08x\n", target->space));
                                return B_ERROR;
                }
                break;
        }

        /* set virtual_width limit for accelerated modes */
//via fixme:
        switch (si->ps.card_arch)
        {
        case NV04A:
                /* confirmed for:
                 * TNT1, TNT2, TNT2-M64 */
                switch(target->space)
                {
                        case B_CMAP8: max_acc_width = 8176; break;
                        case B_RGB15: max_acc_width = 4088; break;
                        case B_RGB16: max_acc_width = 4088; break;
                        case B_RGB24: max_acc_width = 2720; break;
                        case B_RGB32: max_acc_width = 2044; break;
                        default:
                                LOG(8,("INIT: unknown color space: 0x%08x\n", target->space));
                                return B_ERROR;
                }
                break;
        default:
                /* confirmed for:
                 * GeForce2 MX400, GeForce4 MX440, GeForceFX 5200 */
                switch(target->space)
                {
                        case B_CMAP8: max_acc_width = 16368; break;
                        case B_RGB15: max_acc_width =  8184; break;
                        case B_RGB16: max_acc_width =  8184; break;
                        case B_RGB24: max_acc_width =  5456; break;
                        case B_RGB32: max_acc_width =  4092; break;
                        default:
                                LOG(8,("INIT: unknown color space: 0x%08x\n", target->space));
                                return B_ERROR;
                }
                /* NV31 (confirmed GeForceFX 5600) has NV20A granularity!
                 * So let it fall through... */
                if (si->ps.card_type != NV31) break;
        case NV20A:
                /* confirmed for:
                 * GeForce4 Ti4200 */
                switch(target->space)
                {
                        case B_CMAP8: max_acc_width = 16320; break;
                        case B_RGB15: max_acc_width =  8160; break;
                        case B_RGB16: max_acc_width =  8160; break;
                        case B_RGB24: max_acc_width =  5440; break;
                        case B_RGB32: max_acc_width =  4080; break;
                        default:
                                LOG(8,("INIT: unknown color space: 0x%08x\n", target->space));
                                return B_ERROR;
                }
                break;
        }

//via ok:
        /* set virtual_width limit for unaccelerated modes */
        switch (si->ps.card_type)
        {
        default:
                switch(target->space)
                {
                        case B_CMAP8: max_crtc_width = 16376; break;
                        case B_RGB15: max_crtc_width =  8188; break;
                        case B_RGB16: max_crtc_width =  8188; break;
                        case B_RGB24: max_crtc_width =  5456; break;
                        case B_RGB32: max_crtc_width =  4094; break;
                        default:
                                LOG(8,("INIT: unknown color space: 0x%08x\n", target->space));
                                return B_ERROR;
                }
                break;
        }

        /* check for acc capability, and adjust mode to adhere to hardware constraints */
        if (max_acc_width <= max_crtc_width)
        {
                /* check if we can setup this mode with acceleration */
//              *acc_mode = true;
//blocking acc totally:
*acc_mode = false;
                /* virtual_width */
                if (target->virtual_width > max_acc_width) *acc_mode = false;
                /* virtual_height */
                /* (NV cards can even do more than this(?)...
                 *  but 4096 is confirmed on all cards at max. accelerated width.) */
                if (target->virtual_height > 4096) *acc_mode = false;

                /* now check virtual_size based on CRTC constraints */
                if (target->virtual_width > max_crtc_width) target->virtual_width = max_crtc_width;
                /* virtual_height: The only constraint here is the cards memory size which is
                 * checked later on in ProposeMode: virtual_height is adjusted then if needed.
                 * 'Limiting here' to the variable size that's at least available (uint16). */
                if (target->virtual_height > 65535) target->virtual_height = 65535;

                /* OK, now we know that virtual_width is valid, and it's needing no slopspace if
                 * it was confined above, so we can finally calculate safely if we need slopspace
                 * for this mode... */
                if (*acc_mode)
                {
                        /* the mode needs to adhere to the largest granularity imposed... */
                        if (acc_mask < crtc_mask)
                                video_pitch = ((target->virtual_width + crtc_mask) & ~crtc_mask);
                        else
                                video_pitch = ((target->virtual_width + acc_mask) & ~acc_mask);
                }
                else /* unaccelerated mode */
                        video_pitch = ((target->virtual_width + crtc_mask) & ~crtc_mask);
        }
        else /* max_acc_width > max_crtc_width */
        {
                /* check if we can setup this mode with acceleration */
//              *acc_mode = true;
//blocking acc totally:
*acc_mode = false;
                /* (we already know virtual_width will be no problem) */
                /* virtual_height */
                /* (NV cards can even do more than this(?)...
                 *  but 4096 is confirmed on all cards at max. accelerated width.) */
                if (target->virtual_height > 4096) *acc_mode = false;

                /* now check virtual_size based on CRTC constraints */
                if (*acc_mode)
                {
                        /* note that max_crtc_width already adheres to crtc_mask */
                        if (target->virtual_width > (max_crtc_width & ~acc_mask))
                                        target->virtual_width = (max_crtc_width & ~acc_mask);
                }
                else /* unaccelerated mode */
                {
                        if (target->virtual_width > max_crtc_width)
                                        target->virtual_width = max_crtc_width;
                }
                /* virtual_height: The only constraint here is the cards memory size which is
                 * checked later on in ProposeMode: virtual_height is adjusted then if needed.
                 * 'Limiting here' to the variable size that's at least available (uint16). */
                if (target->virtual_height > 65535) target->virtual_height = 65535;

                /* OK, now we know that virtual_width is valid, and it's needing no slopspace if
                 * it was confined above, so we can finally calculate safely if we need slopspace
                 * for this mode... */
                if (*acc_mode)
                {
                        /* the mode needs to adhere to the largest granularity imposed... */
                        if (acc_mask < crtc_mask)
                                video_pitch = ((target->virtual_width + crtc_mask) & ~crtc_mask);
                        else
                                video_pitch = ((target->virtual_width + acc_mask) & ~acc_mask);
                }
                else /* unaccelerated mode */
                        video_pitch = ((target->virtual_width + crtc_mask) & ~crtc_mask);
        }

        LOG(2,("INIT: memory pitch will be set to %d pixels for colorspace 0x%08x\n",
                                                                                                                video_pitch, target->space)); 
        if (target->virtual_width != video_pitch)
                LOG(2,("INIT: effective mode slopspace is %d pixels\n", 
                                                                                        (video_pitch - target->virtual_width)));

        /* now calculate bytes_per_row for this mode */
        *bytes_per_row = video_pitch * (depth >> 3);

        return B_OK;
}