text: /* Authors:
     Mark Watson 2000,
     Rudolf Cornelissen 1/2003-5/2006
  
     Thanx to Petr Vandrovec for writing matroxfb.
  */
  
  #define MODULE_BIT 0x00100000
  
  #include "mga_std.h"
  
  typedef struct {
  	uint32 h_total;
  	uint32 h_display;
  	uint32 h_sync_length;
  	uint32 front_porch;
  	uint32 back_porch;
  	uint32 color_burst;
  	uint32 v_total;
  	float chroma_subcarrier;
  } gx50_maven_timing;
  
  
  // FIXME: try to implement 'fast' and 'slow' settings for all modes, so buffer
  // duplication or skipping won't be neccesary for realtime video.
  // FIXME: try to setup the CRTC2 in interlaced mode for the video modes
  // on <= G400MAX cards.
  
  /* find 'exact' valid video PLL setting */
  status_t g100_g400max_maventv_vid_pll_find(
  	display_mode target, unsigned int * ht_new, unsigned int * ht_last_line,
  	uint8 * m_result, uint8 * n_result, uint8 * p_result)
  {
  	int m = 0, n = 0, p = 0, m_max;
  	float diff, diff_smallest = INFINITY;
  	int best[5] = {0, 0, 0, 0, 0};
  	int h_total_mod;
  	float fields_sec, f_vco;
  	/* We need to be exact, so work with clockperiods per field instead of with frequency.
  	 * Make sure however we truncate these clocks to be integers!
  	 * (The NTSC field frequency would otherwise prevent the 'whole number of clocks per field'
  	 *  check done in this routine later on...) */
  	uint32 vco_clks_field, max_pclks_field, req_pclks_field;
  	/* We need this variable to be a float, because we need to be able to verify if this 
  	 * represents a whole number of clocks per field later on! */
  	float calc_pclks_field;
  
  	LOG(2, ("MAVENTV: searching for EXACT videoclock match\n"));
  
  	/* determine the max. reference-frequency postscaler setting for the current card */
  	//fixme: check G100 and G200 m_max if exist and possible...
  	switch (si->ps.card_type)
  	{
  	case G100:
  		LOG(2, ("MAVENTV: G100 restrictions apply\n"));
  		m_max = 32;
  		break;
  	case G200:
  		LOG(2, ("MAVENTV: G200 restrictions apply\n"));
  		m_max = 32;
  		break;
  	default:
  		LOG(2, ("MAVENTV: G400/G400MAX restrictions apply\n"));
  		m_max = 32;
  		break;
  	}
  
  	/* set number of fields per second to generate */
  	if ((target.flags & TV_BITS) == TV_PAL)
  		fields_sec = 50.0;
  	else
  		fields_sec = 59.94;
  
  	/* determine the max. pixelclock for the current videomode */
  	switch (target.space)
  	{
  		case B_RGB16_LITTLE:
  			max_pclks_field = (si->ps.max_dac2_clock_16 * 1000000) / fields_sec;
  			break;
  		case B_RGB32_LITTLE:
  			max_pclks_field = (si->ps.max_dac2_clock_32 * 1000000) / fields_sec;
  			break;
  		default:
  			/* use fail-safe value */
  			max_pclks_field = (si->ps.max_dac2_clock_32 * 1000000) / fields_sec;
  			break;
  	}
  	/* if some dualhead mode is active, an extra restriction might apply */
  	if ((target.flags & DUALHEAD_BITS) && (target.space == B_RGB32_LITTLE))
  		max_pclks_field = (si->ps.max_dac2_clock_32dh * 1000000) / fields_sec;
  
  	/* Checkout all possible Htotal settings within the current granularity step
  	 * of CRTC2 to get a real close videoclock match!
  	 * (The MAVEN apparantly has a granularity of 1 pixel, while CRTC2 has 8 pixels) */
  	for (h_total_mod = 0; h_total_mod < 8; h_total_mod++)
  	{
  		LOG(2, ("MAVENTV: trying h_total modification of +%d...\n", h_total_mod));
  
  		/* Calculate videoclock to be a bit to high so we can compensate for an exact
  		 * match via h_total_lastline.. */
  		*ht_new = target.timing.h_total + h_total_mod + 2;
  
  		/* Make sure the requested pixelclock is within the PLL's operational limits */
  		/* lower limit is min_video_vco divided by highest postscaler-factor */
  		req_pclks_field = *ht_new * target.timing.v_total;
  		if (req_pclks_field < (((si->ps.min_video_vco * 1000000) / fields_sec) / 8.0))
  		{
  			req_pclks_field = (((si->ps.min_video_vco * 1000000) / fields_sec) / 8.0);
  			LOG(4, ("MAVENTV: WARNING, clamping at lowest possible videoclock\n"));
  		}
  		/* upper limit is given by pins in combination with current active mode */
  		if (req_pclks_field > max_pclks_field)
  		{
  			req_pclks_field = max_pclks_field;
  			LOG(4, ("MAVENTV: WARNING, clamping at highest possible videoclock\n"));
  		}
  
  		/* iterate through all valid PLL postscaler settings */
  		for (p=0x01; p < 0x10; p = p<<1)
  		{
  			/* calc the needed number of VCO clocks per field for this postscaler setting */
  			vco_clks_field = req_pclks_field * p;
  
  			/* check if this is within range of the VCO specs */
  			if ((vco_clks_field >= ((si->ps.min_video_vco * 1000000) / fields_sec)) &&
  				(vco_clks_field <= ((si->ps.max_video_vco * 1000000) / fields_sec)))
  			{
  				/* iterate trough all valid reference-frequency postscaler settings */
  				for (m = 2; m <= m_max; m++)
  				{
  					/* calculate VCO postscaler setting for current setup.. */
  					n = (int)(((vco_clks_field * m) / ((si->ps.f_ref * 1000000) / fields_sec)) + 0.5);
  					/* ..and check for validity */
  					if ((n < 8) || (n > 128))	continue;
  
  					/* special TVmode stuff starts here (rest is in fact standard): */
  					/* calculate number of videoclocks per field */
  					calc_pclks_field =
  						(((uint32)((si->ps.f_ref * 1000000) / fields_sec)) * n) / ((float)(m * p));
  
  					/* we need a whole number of clocks per field, otherwise it won't work correctly.
  					 * (TVout will flicker, green fields will occur) */
  					if (calc_pclks_field != (uint32)calc_pclks_field) continue; 
  
  					/* check if we have the min. needed number of clocks per field for a sync lock */
  					if (calc_pclks_field < ((*ht_new * (target.timing.v_total - 1)) + 2)) continue;
  
  					/* calc number of clocks we have for the last field line */
  					*ht_last_line = calc_pclks_field - (*ht_new * (target.timing.v_total - 1));
  
  					/* check if we haven't got too much clocks in the last field line for a sync lock */
  					if (*ht_last_line > *ht_new) continue;
  
  					/* we have a match! */
  					/* calculate the difference between a full line and the last line */
  					diff = *ht_new - *ht_last_line;
  
  					/* if this last_line comes closer to a full line than earlier 'hits' then use it */
  					if (diff < diff_smallest)
  					{
  						/* log results */
  						if (diff_smallest == 999999999)
  							LOG(2, ("MAVENTV: MATCH, "));
  						else
  							LOG(2, ("MAVENTV: better MATCH,"));
  						f_vco = (si->ps.f_ref / m) * n;
  						LOG(2, ("found vid VCO freq %fMhz, pixclk %fMhz\n", f_vco, (f_vco / p)));
  						LOG(2, ("MAVENTV: mnp(ex. filter) 0x%02x 0x%02x 0x%02x, h_total %d, ht_lastline %d\n",
  							(m - 1), (n - 1), (p - 1), (*ht_new - 2), (*ht_last_line - 2)));
  
  						/* remember this best match */
  						diff_smallest = diff;
  						best[0] = m;
  						best[1] = n;
  						best[2] = p;
  						/* h_total to use for this setting:
  						 * exclude the 'calculate clock a bit too high' trick */
  						best[3] = *ht_new - 2;
  						/* ht_last_line to use for this setting:
  						 * exclude the 'calculate clock a bit too high' trick */
  						best[4] = *ht_last_line - 2;
  					}
  				}
  			}
  		}
  	}
  	LOG(2, ("MAVENTV: search completed.\n"));
  
  	/* setup the scalers programming values for found optimum setting */
  	m = best[0] - 1;
  	n = best[1] - 1;
  	p = best[2] - 1;
  
  	/* if no match was found set fixed PLL frequency so we have something valid at least */
  	if (diff_smallest == 999999999)
  	{
  		LOG(4, ("MAVENTV: WARNING, no MATCH found!\n"));
  
  		if (si->ps.f_ref == 27.000)
  		{
  			/* set 13.5Mhz */
  			m = 0x03;
  			n = 0x07;
  			p = 0x03;
  		} else {
  			/* set 14.31818Mhz */
  			m = 0x01;
  			n = 0x07;
  			p = 0x03;
  		}
  		best[3] = target.timing.h_total;
  		best[4] = target.timing.h_total;
  	}
  
  	/* calc the needed PLL loopbackfilter setting belonging to current VCO speed */
  	f_vco = (si->ps.f_ref / (m + 1)) * (n + 1);
  	LOG(2, ("MAVENTV: using vid VCO frequency %fMhz\n", f_vco));
  
  	switch (si->ps.card_type)
  	{
  	case G100:
  	case G200:
  		for (;;)
  		{
  			if (f_vco >= 180) {p |= (0x03 << 3); break;};
  			if (f_vco >= 140) {p |= (0x02 << 3); break;};
  			if (f_vco >= 100) {p |= (0x01 << 3); break;};
  			break;
  		}
  		break;
  	default:
  		for (;;)
  		{
  			if (f_vco >= 240) {p |= (0x03 << 3); break;};
  			if (f_vco >= 170) {p |= (0x02 << 3); break;};
  			if (f_vco >= 110) {p |= (0x01 << 3); break;};
  			break;
  		}
  		break;
  	}
  
  	/* return results */
  	*m_result = m;
  	*n_result = n;
  	*p_result = p;
  	*ht_new = best[3];
  	*ht_last_line = best[4];
  
  	/* display the found pixelclock values */
  	LOG(2, ("MAVENTV: vid PLL check: got %fMHz, mnp 0x%02x 0x%02x 0x%02x\n",
  		(f_vco / ((p & 0x07) + 1)), m, n, p));
  	LOG(2, ("MAVENTV: new h_total %d, ht_lastline %d\n", *ht_new, *ht_last_line));
  
  	/* return status */
  	if (diff_smallest == 999999999) return B_ERROR;
  	return B_OK;
  }
  
  	/* Notes about timing:
  	 * Note:
  	 * all horizontal timing is measured in pixelclock periods;
  	 * all? vertical timing is measured in field? lines.  */
  
  	/* Note:
  	 * <= G400MAX cards have a fixed 27Mhz(?) clock for TV timing register values,
  	 * while on G450/G550 these need to be calculated based on the video pixelclock. */
  
  
  	/* Notes about signal strengths:
  	 * Note:
  	 * G400 and earlier cards have a fixed reference voltage of +2.6 Volt;
  	 * G450 and G550 cards MAVEN DACs have a switchable ref voltage of +1.5/+2.0 Volt.
  	 *
  	 * This voltage is used to feed the videosignals:
  	 * - Hsync pulse level;
  	 * - Lowest active video output level;
  	 * - Highest active video output level.
  	 * These actual voltages are set via 10bit DACs.
  	 *
  	 * G450/G550:
  	 * The color burst amplitude videosignal is fed by 80% of the above mentioned
  	 * ref. voltage, and is set via an 8bit DAC.
  	 * On G400 and earlier cards the ref. voltage is different, and also differs
  	 * for PAL and NTSC mode. */
  
  	/* Note:
  	 * Increasing the distance between the highest and lowest active video output
  	 * level increases contrast; decreasing it decreases contrast. */
  
  	/* Note:
  	 * Increasing both the highest and lowest active video output level with the
  	 * same amount increases brightness; decreasing it decreases brightness. */
  
  	/* Note:
  	 * Increasing the Hsync pulse level increases the black level, so decreases
  	 * brightness and contrast. */
  
  /* Preset maven PAL output (625lines, 50Hz mode) */
  static void gxx0_maventv_PAL_init(uint8* buffer) 
  {
  	uint16 value;
  
  	/* Chroma subcarrier divider */
  	buffer[0x00] = 0x2A;
  	buffer[0x01] = 0x09;
  	buffer[0x02] = 0x8A;
  	buffer[0x03] = 0xCB; 
  
  	buffer[0x04] = 0x00;
  	buffer[0x05] = 0x00;
  	buffer[0x06] = 0xF9;
  	buffer[0x07] = 0x00;
  	/* Hsync pulse length */
  	buffer[0x08] = 0x7E;
  	/* color burst length */
  	buffer[0x09] = 0x44;
  	/* back porch length */
  	buffer[0x0a] = 0x9C;
  
  	/* color burst amplitude */
  	if (si->ps.card_type <= G400MAX)
  	{
  		buffer[0x0b] = 0x3e;
  	}
  	else
  	{
  		buffer[0x0b] = 0x48;
  	}
  
  	buffer[0x0c] = 0x21;
  	buffer[0x0d] = 0x00;
  
  	if (si->ps.card_type <= G400MAX)
  	{
  		/* Lowest active video output level.
  		 * Warning: make sure this stays above (or equals) the sync pulse level! */
  		value = 0x0ea;
  		buffer[0x0e] = ((value >> 2) & 0xff);
  		buffer[0x0f] = (value & 0x03);
  		/* horizontal sync pulse level */
  		buffer[0x10] = ((value >> 2) & 0xff);
  		buffer[0x11] = (value & 0x03);
  	}
  	else
  	{
  		/* Lowest active video output level.
  		 * Warning: make sure this stays above (or equals) the sync pulse level! */
  		value = 0x130;
  		buffer[0x0e] = ((value >> 2) & 0xff);
  		buffer[0x0f] = (value & 0x03);
  		/* horizontal sync pulse level */
  		buffer[0x10] = ((value >> 2) & 0xff);
  		buffer[0x11] = (value & 0x03);
  	}
  
  	buffer[0x12] = 0x1A;
  	buffer[0x13] = 0x2A;
  	
  	/* functional unit */
  	buffer[0x14] = 0x1C;
  	buffer[0x15] = 0x3D;
  	buffer[0x16] = 0x14;
  	
  	/* vertical total */ //(=625)
  	/* b9-2 */
  	buffer[0x17] = 0x9C;
  	/* b1-0 in b1-0 */
  	buffer[0x18] = 0x01;
  
  	buffer[0x19] = 0x00;
  	buffer[0x1a] = 0xFE;
  	buffer[0x1b] = 0x7E;
  	buffer[0x1c] = 0x60;
  	buffer[0x1d] = 0x05;
  
  	/* Highest active video output level.
  	 * Warning: make sure this stays above the lowest active video output level! */
  	if (si->ps.card_type <= G400MAX)
  	{
  		value = 0x24f;
  		buffer[0x1e] = ((value >> 2) & 0xff);
  		buffer[0x1f] = (value & 0x03);
  	}
  	else
  	{
  		value = 0x300;
  		buffer[0x1e] = ((value >> 2) & 0xff);
  		buffer[0x1f] = (value & 0x03);
  	}
  
  	/* saturation (field?) #1 */
  	if (si->ps.card_type <= G400MAX)
  		buffer[0x20] = 0x72;
  	else
  		buffer[0x20] = 0xA5;
  
  	buffer[0x21] = 0x07;
  
  	/* saturation (field?) #2 */
  	if (si->ps.card_type <= G400MAX)
  		buffer[0x22] = 0x72;
  	else
  		buffer[0x22] = 0xA5;
  
  	buffer[0x23] = 0x00;
  	buffer[0x24] = 0x00;
  	/* hue? */
  	buffer[0x25] = 0x00;
  
  	buffer[0x26] = 0x08;
  	buffer[0x27] = 0x04;
  	buffer[0x28] = 0x00;
  	buffer[0x29] = 0x1A;
  
  	/* functional unit */
  	buffer[0x2a] = 0x55;
  	buffer[0x2b] = 0x01;
  
  	/* front porch length */
  	buffer[0x2c] = 0x26;
  
  	/* functional unit */
  	buffer[0x2d] = 0x07;
  	buffer[0x2e] = 0x7E;
  
  	/* functional unit */
  	buffer[0x2f] = 0x02;
  	buffer[0x30] = 0x54;
  
  	/* horizontal visible */
  	value = 0x580;
  	buffer[0x31] = ((value >> 3) & 0xff);
  	buffer[0x32] = (value & 0x07);
  
  	/* upper blanking (in field lines) */
  	buffer[0x33] = 0x14; //=((v_total - v_sync_end)/2) -1
  
  	buffer[0x34] = 0x49;
  	buffer[0x35] = 0x00;
  	buffer[0x36] = 0x00;
  	buffer[0x37] = 0xA3;
  	buffer[0x38] = 0xC8;
  	buffer[0x39] = 0x22;
  	buffer[0x3a] = 0x02;
  	buffer[0x3b] = 0x22;
  
  	/* functional unit */
  	buffer[0x3c] = 0x3F;
  	buffer[0x3d] = 0x03;
  }
  
  /* Preset maven NTSC output (525lines, 59.94Hz mode) */
  static void gxx0_maventv_NTSC_init(uint8* buffer) 
  {
  	uint16 value;
  
  	/* Chroma subcarrier frequency */
  	buffer[0x00] = 0x21;
  	buffer[0x01] = 0xF0;
  	buffer[0x02] = 0x7C;
  	buffer[0x03] = 0x1F;
  
  	buffer[0x04] = 0x00;
  	buffer[0x05] = 0x00;//b1 = ON enables colorbar testimage
  	buffer[0x06] = 0xF9;//b0 = ON enables MAVEN TV output
  	buffer[0x07] = 0x00;//influences the colorburst signal amplitude somehow
  
  	/* Hsync pulse length */
  	buffer[0x08] = 0x7E;
  	/* color burst length */
  	buffer[0x09] = 0x43;
  	/* back porch length */
  	buffer[0x0a] = 0x7E;
  
  	/* color burst amplitude */
  	if (si->ps.card_type <= G400MAX)
  	{
  		buffer[0x0b] = 0x46;
  	}
  	else
  	{
  		buffer[0x0b] = 0x48;
  	}
  
  	buffer[0x0c] = 0x00;
  	buffer[0x0d] = 0x00;
  
  	if (si->ps.card_type <= G400MAX)
  	{
  		/* Lowest active video output level.
  		 * Warning: make sure this stays above (or equals) the sync pulse level! */
  		value = 0x0ea;
  		buffer[0x0e] = ((value >> 2) & 0xff);
  		buffer[0x0f] = (value & 0x03);
  		/* horizontal sync pulse level */
  		buffer[0x10] = ((value >> 2) & 0xff);
  		buffer[0x11] = (value & 0x03);
  	}
  	else
  	{
  		/* Lowest active video output level.
  		 * Warning: make sure this stays above (or equals) the sync pulse level! */
  		value = 0x130;
  		buffer[0x0e] = ((value >> 2) & 0xff);
  		buffer[0x0f] = (value & 0x03);
  		/* horizontal sync pulse level */
  		buffer[0x10] = ((value >> 2) & 0xff);
  		buffer[0x11] = (value & 0x03);
  	}
  
  	buffer[0x12] = 0x17;
  	buffer[0x13] = 0x21;
  
  	/* functional unit */
  	buffer[0x14] = 0x1B;
  	buffer[0x15] = 0x1B;
  	buffer[0x16] = 0x24;
  
  	/* vertical total */
  	/* b9-2 */
  	buffer[0x17] = 0x83;
  	/* b1-0 in b1-0 */
  	buffer[0x18] = 0x01;
  
  	buffer[0x19] = 0x00;//mv register?
  	buffer[0x1a] = 0x0F;
  	buffer[0x1b] = 0x0F;
  	buffer[0x1c] = 0x60;
  	buffer[0x1d] = 0x05;
  
  	/* Highest active video output level.
  	 * Warning: make sure this stays above the lowest active video output level! */
  	if (si->ps.card_type <= G400MAX)
  	{
  		value = 0x24f;
  		buffer[0x1e] = ((value >> 2) & 0xff);
  		buffer[0x1f] = (value & 0x03);
  	}
  	else
  	{
  		value = 0x300;
  		buffer[0x1e] = ((value >> 2) & 0xff);
  		buffer[0x1f] = (value & 0x03);
  	}
  
  	/* color saturation #1 (Y-B ?) */
  	if (si->ps.card_type <= G400MAX)
  		buffer[0x20] = 0x5F;
  	else
  		buffer[0x20] = 0x9C;
  
  	buffer[0x21] = 0x04;
  
  	/* color saturation #2 (Y-R ?) */
  	if (si->ps.card_type <= G400MAX)
  		buffer[0x22] = 0x5F;
  	else
  		buffer[0x22] = 0x9C;
  
  	buffer[0x23] = 0x01;
  	buffer[0x24] = 0x02;
  
  	/* hue: preset at 0 degrees */
  	buffer[0x25] = 0x00;
  
  	buffer[0x26] = 0x0A;
  	buffer[0x27] = 0x05;//sync stuff
  	buffer[0x28] = 0x00;
  	buffer[0x29] = 0x10;//field line-length stuff
  
  	/* functional unit */
  	buffer[0x2a] = 0xFF;
  	buffer[0x2b] = 0x03;
  
  	/* front porch length */
  	buffer[0x2c] = 0x24;
  
  	/* functional unit */
  	buffer[0x2d] = 0x0F;
  	buffer[0x2e] = 0x78;
  
  	/* functional unit */
  	buffer[0x2f] = 0x00;
  	buffer[0x30] = 0x00;
  
  	/* horizontal visible */
  	/* b10-3 */
  	buffer[0x31] = 0xB2;
  	/* b2-0 in b2-0 */
  	buffer[0x32] = 0x04;
  
  	/* upper blanking (in field lines) */
  	buffer[0x33] = 0x14;
  
  	buffer[0x34] = 0x02;//colorphase or so stuff.
  	buffer[0x35] = 0x00;
  	buffer[0x36] = 0x00;
  	buffer[0x37] = 0xA3;
  	buffer[0x38] = 0xC8;
  	buffer[0x39] = 0x15;
  	buffer[0x3a] = 0x05;
  	buffer[0x3b] = 0x3B;
  
  	/* functional unit */
  	buffer[0x3c] = 0x3C;
  	buffer[0x3d] = 0x00;
  }
  
  static void gx50_maventv_PAL_timing(gx50_maven_timing *m_timing)
  {
  	/* values are given in picoseconds */
  	m_timing->h_total = 64000000;
  	/* the sum of the signal duration below should match h_total! */
  	m_timing->h_display = 52148148;
  	m_timing->h_sync_length = 4666667;
  	m_timing->front_porch = 1407407;
  	m_timing->back_porch = 5777778;
  	/* colorburst is 'superimposed' on the above timing */
  	m_timing->color_burst = 2518518;
  	/* number of lines per frame */
  	m_timing->v_total = 625;
  	/* color carrier frequency in Mhz */
  	m_timing->chroma_subcarrier = 4.43361875;
  }
  
  static void gx50_maventv_NTSC_timing(gx50_maven_timing *m_timing)
  {
  	/* values are given in picoseconds */
  	m_timing->h_total = 63555556;
  	/* the sum of the signal duration below should match h_total! */
  	m_timing->h_display = 52888889;
  	m_timing->h_sync_length = 4666667;
  	m_timing->front_porch = 1333333;
  	m_timing->back_porch = 4666667;
  	/* colorburst is 'superimposed' on the above timing */
  	m_timing->color_burst = 2418418;
  	/* number of lines per frame */
  	m_timing->v_total = 525;
  	/* color carrier frequency in Mhz */
  	m_timing->chroma_subcarrier = 3.579545454;
  }
  
  int maventv_init(display_mode target) 
  {
  	uint8 val;
  	uint8 m_result, n_result, p_result;
  	unsigned int ht_new, ht_last_line;
  	float calc_pclk;
  	/* use a display_mode copy because we might tune it for TVout compatibility */
  	display_mode tv_target = target;
  	/* used as buffer for TVout signal to generate */
  	uint8 maventv_regs[64];
  	/* used in G450/G550 to calculate TVout signal timing dependant on pixelclock;
  	 * <= G400MAX use fixed settings because base-clock here is the fixed crystal
  	 * frequency. */
  	//fixme:
  	//if <=G400 cards with MAVEN and crystal of 14.31818Mhz exist, modify!?!
  	//only saw 27Mhz versions of G100 and G200 that (can) hold a MAVEN upto now...
  	gx50_maven_timing m_timing;
  
  	/* preset new TVout mode */
  	if ((tv_target.flags & TV_BITS) == TV_PAL)
  	{
  		LOG(4, ("MAVENTV: PAL TVout\n"));
  		gxx0_maventv_PAL_init(maventv_regs);
  		gx50_maventv_PAL_timing(&m_timing);
  	}
  	else
  	{
  		LOG(4, ("MAVENTV: NTSC TVout\n"));
  		gxx0_maventv_NTSC_init(maventv_regs);
  		gx50_maventv_NTSC_timing(&m_timing);
  	}
  
  	/* enter mode-program mode */
  	if (si->ps.card_type <= G400MAX) MAVW(PGM, 0x01);
  	else
  	{
  		DXIW(TVO_IDX, MGAMAV_PGM);
  		DXIW(TVO_DATA, 0x01);
  	}
  
  	/* tune new TVout mode */
  	if (si->ps.card_type <= G400MAX)
  	{
  		/* setup TV-mode 'copy' of CRTC2, setup PLL, inputs, outputs and sync-locks */
  		MAVW(MONSET, 0x00);
  		MAVW(MONEN, 0xA2);
  
  		/* xmiscctrl */
  		//unknown regs:
  		MAVWW(WREG_0X8E_L, 0x1EFF); 
  		MAVW(BREG_0XC6, 0x01);
  
  		MAVW(LOCK, 0x01);
  		MAVW(OUTMODE, 0x08);
  
  		/* set high contrast/brightness range for TVout */
  		/* Note:
  		 * b4-5 have contrast/brightness function during TVout, while these bits
  		 * are used to set sync polarity in a serial fashion during monitor modes.
  		 * Setting both these bits here will 'increase' the sync polarity offset
  		 * by one! */
  		MAVW(LUMA, 0x78);
  		/* We just made a sync polarity programming step for monitor modes, so:
  		 * note the offset from 'reset position' we will have now.
  		 * Note:
  		 * Not applicable for singlehead cards with a MAVEN, since it's only used
  		 * for TVout there. */
  		si->maven_syncpol_offset += 1;
  		if (si->maven_syncpol_offset > 3) si->maven_syncpol_offset = 0;
  
  		//unknown regs:
  		MAVW(STABLE, 0x02);
  		MAVW(MONEN, 0xB3);
  
  		/* modify mode to center and size correctly on TV */
  		{
  			int diff;
  			float uscan_fact;
  			bool tweak = false; /* needed for NTSC VCD mode */
  
  			if (!(tv_target.flags & TV_VIDEO)) /* Desktop modes */
  			{
  				LOG(4,("MAVENTV: setting underscanning ('downscaled') desktop mode\n"));
  
  				/* adapt mode to underscan correctly */
  				if ((tv_target.timing.h_display < 704) && ((tv_target.flags & TV_BITS) == TV_PAL))
  				{
  					/* can't be higher because of scaling limitations in MAVEN! */
  					uscan_fact = 0.76;
  				}
  				else
  				{
  					/* optimal setting for desktop modes.. */
  					uscan_fact = 0.80;
  				}
  				/* horizontal */
  				tv_target.timing.h_total = (tv_target.timing.h_display / uscan_fact);
  				/* adhere to CRTC constraints */
  				tv_target.timing.h_total &= ~0x0007;
  				/* vertical */
  				tv_target.timing.v_total = (tv_target.timing.v_display / uscan_fact);
  
  				/* now do vertical centering */
  				if ((tv_target.flags & TV_BITS) == TV_PAL)
  				{
  					diff = tv_target.timing.v_total - tv_target.timing.v_display;
  					tv_target.timing.v_sync_start = tv_target.timing.v_display + ((diff * 7) / 20);
  					/* sync all the way 'to the end' to prevent vertical overscanning
  					 * rubbish on top of screen due to MAVEN hardware design fault */
  					tv_target.timing.v_sync_end = tv_target.timing.v_total;
  				}
  				else
  				{
  					diff = tv_target.timing.v_total - tv_target.timing.v_display;
  					tv_target.timing.v_sync_start = tv_target.timing.v_display + ((diff * 5) / 20);
  					/* sync all the way 'to the end' to prevent vertical overscanning
  					 * rubbish on top of screen due to MAVEN hardware design fault */
  					tv_target.timing.v_sync_end = tv_target.timing.v_total;
  				}
  			}
  			else /* Video modes */
  			{
  				uint16 mode =
  					(((tv_target.flags & TV_BITS) << (14 - 9)) | tv_target.timing.h_display);
  
  				LOG(4,("MAVENTV: setting overscanning ('unscaled') video mode\n"));
  
  				/* adapt standard modes to be displayed 1:1 */
  				switch (mode)
  				{
  				case ((TV_NTSC << (14 - 9)) | 640): /* NTSC VCD mode */
  					/* horizontal: adhere to CRTC granularity (8) */
  					/* Note: h_total = 704 has no PLL match! */
  					tv_target.timing.h_total = 696;
  					/* because this 'low' horizontal resolution cannot be scaled up
  					 * for overscanning use (MAVEN restriction) we need to do some
  					 * tweaking to get a mode we can work with that still has the
  					 * correct aspect ratio.
  					 * This mode has just a little bit horizontal overscanning. */
  					tweak = true;
  					break;
  				case ((TV_NTSC << (14 - 9)) | 720): /* NTSC DVD mode */
  					/* horizontal: adhere to CRTC granularity (8) */
  					tv_target.timing.h_total = 784;
  					/* MGA_TVOs need additional tweaking */
  					if (!si->ps.secondary_head) si->crtc_delay += 12;
  					break;
  				case ((TV_PAL << (14 - 9)) | 768): /* PAL VCD mode */
  					/* horizontal: adhere to CRTC granularity (8) */
  					tv_target.timing.h_total = 832;
  					break;
  				case ((TV_PAL << (14 - 9)) | 720): /* PAL DVD mode */
  					/* horizontal: adhere to CRTC granularity (8) */
  					tv_target.timing.h_total = 784;
  					break;
  				default:
  					/* non-standard mode: just hope for he best. */
  					break;
  				}
  
  				/* now do vertical centering and clipping */
  				if ((tv_target.flags & TV_BITS) == TV_PAL)
  				{
  					/* defined by the PAL standard */
  					tv_target.timing.v_total = m_timing.v_total;
  					/* we need to center the image on TV vertically.
  					 * note that 576 is the maximum supported resolution for the PAL standard,
  					 * this is already overscanning by approx 8-10% */
  					diff = 576 - tv_target.timing.v_display;
  					/* if we cannot display the current vertical resolution fully, clip it */
  					if (diff < 0)
  					{
  						tv_target.timing.v_display = 576;
  						diff = 0;
  					}
  					/* now center the image on TV */
  					tv_target.timing.v_sync_start = tv_target.timing.v_display + (diff / 2);
  					/* sync all the way 'to the end' to prevent vertical overscanning
  					 * rubbish on top of screen due to MAVEN hardware design fault */
  					/* note: probably invisible in these Video modes */
  					tv_target.timing.v_sync_end = tv_target.timing.v_total;
  				}
  				else
  				{
  					/* defined by the NTSC standard */
  					tv_target.timing.v_total = m_timing.v_total;
  					/* NTSC VCD mode needs to be scaled down vertically to get correct
  					 * aspect ratio... */
  					if (tweak) tv_target.timing.v_total += 32;
  					/* we need to center the image on TV vertically.
  					 * note that 480 is the maximum supported resolution for the NTSC standard,
  					 * this is already overscanning by approx 8-10% */
  					diff = 480 - tv_target.timing.v_display;
  					/* if we cannot display the current vertical resolution fully, clip it */
  					if (diff < 0)
  					{
  						tv_target.timing.v_display = 480;
  						diff = 0;
  					}
  					/* now center the image on TV */
  					tv_target.timing.v_sync_start = tv_target.timing.v_display + (diff / 2);
  					/* ...NTSC VCD mode needs to be moved up to center the tweaked mode
  					 * correcty... */
  					if (tweak) tv_target.timing.v_sync_start += 9;
  					/* sync all the way 'to the end' to prevent vertical overscanning
  					 * rubbish on top of screen due to MAVEN hardware design fault */
  					/* note: might be visible in the NTSC VCD Video mode */
  					tv_target.timing.v_sync_end = tv_target.timing.v_total;
  				}
  			}
  
  			/* finally do horizontal centering */
  			if ((tv_target.flags & TV_BITS) == TV_PAL)
  			{
  				diff = tv_target.timing.h_total - tv_target.timing.h_display;
  				if (!si->ps.secondary_head)
  				{
  					tv_target.timing.h_sync_start = tv_target.timing.h_display - 16 + (diff / 2);
  					/* keep adhering to CRTC constraints */
  					tv_target.timing.h_sync_start &= ~0x0007;
  					tv_target.timing.h_sync_end = tv_target.timing.h_sync_start + 32;
  				}
  				else
  				{
  					tv_target.timing.h_sync_start = tv_target.timing.h_display - 0 + (diff / 2);
  					/* keep adhering to CRTC constraints */
  					tv_target.timing.h_sync_start &= ~0x0007;
  					tv_target.timing.h_sync_end = tv_target.timing.h_sync_start + 16;
  				}
  			}
  			else
  			{
  				diff = tv_target.timing.h_total - tv_target.timing.h_display;
  				tv_target.timing.h_sync_start = tv_target.timing.h_display - 16 + (diff / 2);
  				/* ...and finally the NTSC VCD mode needs to be moved to the right to
  				 * center the tweaked mode correctly. */
  				if (tweak) tv_target.timing.h_sync_start -= 16;
  				/* keep adhering to CRTC constraints */
  				tv_target.timing.h_sync_start &= ~0x0007;
  				tv_target.timing.h_sync_end = tv_target.timing.h_sync_start + 16;
  			}
  		}
  
  		/* tune crtc delay */
  		if ((tv_target.timing.h_display >= 1000) && (((tv_target.flags & TV_BITS) != TV_PAL)))
  		{
  			si->crtc_delay += 1;
  		}
  		else
  		{
  			si->crtc_delay -= 3;
  		}
  
  		/* setup video PLL */
  		g100_g400max_maventv_vid_pll_find(
  			tv_target, &ht_new, &ht_last_line, &m_result, &n_result, &p_result);
  		MAVW(PIXPLLM, m_result);
  		MAVW(PIXPLLN, n_result);
  		MAVW(PIXPLLP, (p_result | 0x80));
  
  		MAVW(MONSET, 0x20);
  
  		MAVW(TEST, 0x10);
  
  		/* htotal - 2 */
  		MAVWW(HTOTALL, ht_new);
  
  		/* last line in field can have different length */
  		/* hlen - 2 */
  		MAVWW(LASTLINEL, ht_last_line);
  
  		/* horizontal vidrst pos: 0 <= vidrst pos <= htotal - 2 */
  		MAVWW(HVIDRSTL, (ht_last_line - si->crtc_delay - 
  						(tv_target.timing.h_sync_end - tv_target.timing.h_sync_start)));
  		//ORG (does the same but with limit checks but these limits should never occur!):
  //		slen = tv_target.timing.h_sync_end - tv_target.timing.h_sync_start;
  //		hcrt = tv_target.timing.h_total - slen - si->crtc_delay;
  //		if (ht_last_line < tv_target.timing.h_total) hcrt += ht_last_line;
  //		if (hcrt > tv_target.timing.h_total) hcrt -= tv_target.timing.h_total;
  //		if (hcrt + 2 > tv_target.timing.h_total) hcrt = 0;	/* or issue warning? */
  //		MAVWW(HVIDRSTL, hcrt);
  
  		/* who knows */
  		MAVWW(HSYNCSTRL, 0x0004);//must be 4!!
  
  		/* hblanking end: 100% */
  		MAVWW(HSYNCLENL, (tv_target.timing.h_total - tv_target.timing.h_sync_end));
  
  		/* vertical line count - 1 */
  		MAVWW(VTOTALL, (tv_target.timing.v_total - 1));
  
  		/* vertical vidrst pos */
  		MAVWW(VVIDRSTL, (tv_target.timing.v_total - 2));
  
  		/* something end... [A6]+1..[A8] */
  		MAVWW(VSYNCSTRL, 0x0001);
  
  		/* vblanking end: stop vblanking */
  		MAVWW(VSYNCLENL, (tv_target.timing.v_sync_end - tv_target.timing.v_sync_start - 1));
  		//org: no visible diff:
  		//MAVWW(VSYNCLENL, (tv_target.timing.v_total - tv_target.timing.v_sync_start - 1));
  
  		/* something start... 0..[A4]-1 */
  		MAVWW(VDISPLAYL, 0x0000);
  		//std setmode (no visible difference)
  		//MAVWW(VDISPLAYL, (tv_target.timing.v_total - 1));
  
  		/* ... */
  		MAVWW(WREG_0X98_L, 0x0000);
  
  		/* moves picture up/down and so on... */
  		MAVWW(VSOMETHINGL, 0x0001); /* Fix this... 0..VTotal */
  
  		{
  			uint32 h_display_tv;
  			uint8 h_scale_tv;
  
  			unsigned int ib_min_length;
  			unsigned int ib_length;
  			int index;
  
  			/* calc hor scale-back factor from input to output picture (in 1.7 format)
  			 * the MAVEN has 736 pixels fixed total outputline length for TVout */ 
  			h_scale_tv = (736 << 7) / tv_target.timing.h_total;//should be PLL corrected
  			LOG(4,("MAVENTV: horizontal scale-back factor is: %f\n", (h_scale_tv / 128.0)));
  
  			/* limit values to MAVEN capabilities (scale-back factor is 0.5-1.0) */
  			if (h_scale_tv > 0x80)
  			{
  				h_scale_tv = 0x80;
  				LOG(4,("MAVENTV: limiting horizontal scale-back factor to: %f\n", (h_scale_tv / 128.0)));
  			}
  			if (h_scale_tv < 0x40)
  			{
  				h_scale_tv = 0x40;
  				LOG(4,("MAVENTV: limiting horizontal scale-back factor to: %f\n", (h_scale_tv / 128.0)));
  			}
  			/* make sure we get no round-off error artifacts on screen */
  			h_scale_tv--;
  
  			/* calc difference in (wanted output picture width (excl. hsync_length)) and
  			 * (fixed total output line length (=768)),
  			 * based on input picture and scaling factor */
  			/* (MAVEN trick (part 1) to get output picture width to fit into just 8 bits) */
  			h_display_tv = ((768 - 1) << 7) -
  				(((tv_target.timing.h_total - tv_target.timing.h_sync_end)	/* is left margin */
  				 + tv_target.timing.h_display - 8)
  				 * h_scale_tv);
  			/* convert result from 25.7 to 32.0 format */
  			h_display_tv = h_display_tv >> 7;
  			LOG(4,("MAVENTV: displaying output on %d picture pixels\n",
  				((768 - 1) - h_display_tv)));
  
  			/* half result: MAVEN trick (part 2)
  			 * (258 - 768 pixels, only even number per line is possible) */
  			h_display_tv = h_display_tv >> 1;
  			/* limit value to register contraints */
  			if (h_display_tv > 0xFF) h_display_tv = 0xFF;
  			MAVW(HSCALETV, h_scale_tv);
  			MAVW(HDISPLAYTV, h_display_tv);
  
  
  			/* calculate line inputbuffer length */
  			/* It must be between (including):
  			 * ((input picture left margin) + (input picture hor. resolution) + 4)
  			 * AND
  			 * (input picture total line length) (PLL corrected) */
  
  			/* calculate minimal line input buffer length */
  			ib_min_length = ((tv_target.timing.h_total - tv_target.timing.h_sync_end) +
  				 			  tv_target.timing.h_display + 4);
  
  			/* calculate optimal line input buffer length (so top of picture is OK too) */
  			/* The following formula applies:
  			 * optimal buffer length = ((((0x78 * i) - R) / hor. scaling factor) + Q)
  			 *
  			 * where (in 4.8 format!)
  		     * R      Qmin  Qmax
  			 * 0x0E0  0x5AE 0x5BF
  			 * 0x100  0x5CF 0x5FF	
  			 * 0x180  0x653 0x67F
  			 * 0x200  0x6F8 0x6FF
  			 */
  			index = 1;
  			do
  			{
  				ib_length = ((((((0x7800 << 7) * index) - (0x100 << 7)) / h_scale_tv) + 0x05E7) >> 8);
  				index++;
  			} while (ib_length < ib_min_length);
  			LOG(4,("MAVENTV: optimal line inputbuffer length: %d\n", ib_length));
  
  			if (ib_length >= ht_new + 2)
  			{
  				ib_length = ib_min_length;
  				LOG(4,("MAVENTV: limiting line inputbuffer length, setting minimal usable: %d\n", ib_length));
  			}
  			MAVWW(HDISPLAYL, ib_length);
  		}
  
  		{
  			uint16 t_scale_tv;
  			uint32 v_display_tv;
  
  			/* calc total scale-back factor from input to output picture */
  			{
  				uint32 out_clocks;
  				uint32 in_clocks;
  
  				//takes care of green stripes:
  				/* calc output clocks per frame */
  				out_clocks = m_timing.v_total * (ht_new + 2);
  
  				/* calc input clocks per frame */
  				in_clocks = (tv_target.timing.v_total - 1) * (ht_new + 2) +	ht_last_line + 2;
  
  				/* calc total scale-back factor from input to output picture in 1.15 format */
  				t_scale_tv = ((((uint64)out_clocks) << 15) / in_clocks); 
  				LOG(4,("MAVENTV: total scale-back factor is: %f\n", (t_scale_tv / 32768.0)));
  
  				/* min. scale-back factor is 1.0 for 1:1 output */
  				if (t_scale_tv > 0x8000)
  				{
  					t_scale_tv = 0x8000;
  					LOG(4,("MAVENTV: limiting total scale-back factor to: %f\n", (t_scale_tv / 32768.0)));
  				}
  			}
  
  			/*calc output picture height based on input picture and scaling factor */
  			//warning: v_display was 'one' lower originally!
  			v_display_tv = 
  				((tv_target.timing.v_sync_end - tv_target.timing.v_sync_start) 	/* is sync length */
  				 + (tv_target.timing.v_total - tv_target.timing.v_sync_end) 	/* is upper margin */
  				 + tv_target.timing.v_display)
  				 * t_scale_tv;
  			/* convert result from 17.15 to 32.0 format */
  			v_display_tv = (v_display_tv >> 15);
  			LOG(4,("MAVENTV: displaying output on %d picture frame-lines\n", v_display_tv));
  
  			/* half result, and compensate for internal register offset
  			 * (MAVEN trick to get it to fit into just 8 bits).
  			 * (allowed output frame height is 292 - 802 lines, only even numbers) */
  			v_display_tv = (v_display_tv >> 1) - 146;
  			/* limit value to register contraints */
  			if (v_display_tv > 0xFF) v_display_tv = 0xFF;
  			/* make sure we get no round-off error artifacts on screen */
  			t_scale_tv--;
  
  			MAVWW(TSCALETVL, t_scale_tv);
  			MAVW(VDISPLAYTV, v_display_tv);
  		}
  
  		MAVW(TEST, 0x00);
  
  		/* gamma correction registers */
  		MAVW(GAMMA1, 0x00);
  		MAVW(GAMMA2, 0x00);
  		MAVW(GAMMA3, 0x00);
  		MAVW(GAMMA4, 0x1F);
  		MAVW(GAMMA5, 0x10);
  		MAVW(GAMMA6, 0x10);
  		MAVW(GAMMA7, 0x10);
  		MAVW(GAMMA8, 0x64);	/* 100 */
  		MAVW(GAMMA9, 0xC8);	/* 200 */
  
  		/* set flickerfilter */
  		if (!(tv_target.flags & TV_VIDEO))
  		{
  			/* Desktop modes (those are scaled): filter on to prevent artifacts */
  			MAVW(FFILTER, 0xa2);
  			LOG(4,("MAVENTV: enabling flicker filter\n"));
  		}
  		else
  		{
  			/* Video modes (those are unscaled): filter off to increase sharpness */
  			//fixme? OFF is dependant on MAVEN version(?): MGA_TVO_B = $40, else $00.
  			MAVW(FFILTER, 0x00);
  			LOG(4,("MAVENTV: disabling flicker filter\n"));
  		}
  
  		/* 0x10 or anything ored with it */
  		//fixme? linux uses 0x14...
  		MAVW(TEST, (MAVR(TEST) & 0x10));
  
  		/* output: SVideo/Composite */
  		MAVW(OUTMODE, 0x08);
  	}
  	else /* card_type is >= G450 */
  	{
  		//fixme: setup an intermediate buffer if vertical res is different than settings below!
  		//fixme: setup 2D or 3D engine to do screen_to_screen_scaled_filtered_blit between the buffers
  		//       during vertical retrace!
  		if ((tv_target.flags & TV_BITS) == TV_PAL)
  		{
  			int diff;
  
  			/* defined by the PAL standard */
  			tv_target.timing.v_total = m_timing.v_total;
  			/* we need to center the image on TV vertically.
  			 * note that 576 is the maximum supported resolution for the PAL standard,
  			 * this is already overscanning by approx 8-10% */
  			diff = 576 - tv_target.timing.v_display;
  			/* if we cannot display the current vertical resolution fully, clip it */
  			if (diff < 0)
  			{
  				tv_target.timing.v_display = 576;
  				diff = 0;
  			}
  			/* now center the image on TV by centering the vertical sync pulse */
  			tv_target.timing.v_sync_start = tv_target.timing.v_display + 1 + (diff / 2);
  			tv_target.timing.v_sync_end = tv_target.timing.v_sync_start + 1;
  		}
  		else
  		{
  			int diff;
  
  			/* defined by the NTSC standard */
  			tv_target.timing.v_total = m_timing.v_total;
  			/* we need to center the image on TV vertically.
  			 * note that 480 is the maximum supported resolution for the NTSC standard,
  			 * this is already overscanning by approx 8-10% */
  			diff = 480 - tv_target.timing.v_display;
  			/* if we cannot display the current vertical resolution fully, clip it */
  			if (diff < 0)
  			{
  				tv_target.timing.v_display = 480;
  				diff = 0;
  			}
  			/* now center the image on TV by centering the vertical sync pulse */
  			tv_target.timing.v_sync_start = tv_target.timing.v_display + 1 + (diff / 2);
  			tv_target.timing.v_sync_end = tv_target.timing.v_sync_start + 1;
  		}
  
  		/* setup video PLL for G450/G550:
  		 * this can be done in the normal way because the MAVEN works in slave mode!
  		 * NOTE: must be done before programming CRTC2, or interlaced startup may fail. */
  
  		//fixme: make sure videoPLL is powered up: XPWRCTRL b1=1
  		{
  			uint16 front_porch, back_porch, h_sync_length, burst_length, h_total, h_display;
  			uint32 chromasc;
  			uint64 pix_period;
  			uint16 h_total_wanted, leftover;
  
  			/* calculate tv_h_display in 'half pixelclocks' and adhere to MAVEN restrictions.
  			 * ('half pixelclocks' exist because the MAVEN uses them...) */
  			h_display = (((tv_target.timing.h_display << 1) + 3) & ~0x03);
  			if (h_display > 2044) h_display = 2044;
  			/* copy result to MAVEN TV mode */
  			maventv_regs[0x31] = (h_display >> 3);
  			maventv_regs[0x32] = (h_display & 0x07);
  
  			/* calculate needed video pixelclock in kHz.
  			 * NOTE:
  			 * The clock calculated is based on MAVEN output, so each pixelclock period
  			 * is in fact a 'half pixelclock' period compared to monitor mode use. */
  			tv_target.timing.pixel_clock =
  				((((uint64)h_display) * 1000000000) / m_timing.h_display);
  
  			/* tune display_mode adhering to CRTC2 restrictions */
  			/* (truncate h_display to 'whole pixelclocks') */
  			tv_target.timing.h_display = ((h_display >> 1) & ~0x07);
  			tv_target.timing.h_sync_start = tv_target.timing.h_display + 8;
  
  			g450_g550_maven_vid_pll_find(tv_target, &calc_pclk, &m_result, &n_result, &p_result, 1);
  			/* adjust mode to actually used pixelclock */
  			tv_target.timing.pixel_clock = (calc_pclk * 1000);
  
  			/* program videoPLL */
  			DXIW(VIDPLLM, m_result);
  			DXIW(VIDPLLN, n_result);
  			DXIW(VIDPLLP, p_result);
  
  			/* calculate videoclock 'half' period duration in picoseconds */
  			pix_period = (1000000000 / ((float)tv_target.timing.pixel_clock)) + 0.5;
  			LOG(4,("MAVENTV: TV videoclock period is %d picoseconds\n", pix_period));
  
  			/* calculate number of 'half' clocks per line according to pixelclock set */
  			/* fixme: try to setup the modes in such a way that
  			 * (h_total_clk % 16) == 0 because of the CRTC2 restrictions:
  			 * we want to loose the truncating h_total trick below if possible! */
  			/* Note:
  			 * This is here so we can see the wanted and calc'd timing difference. */
  			h_total_wanted = ((m_timing.h_total / ((float)pix_period)) + 0.5);
  			LOG(4,("MAVENTV: TV h_total should be %d units\n", h_total_wanted));
  
  			/* calculate chroma subcarrier value to setup:
  			 * do this as exact as possible because this signal is very sensitive.. */
  			chromasc =
  				((((uint64)0x100000000) * (m_timing.chroma_subcarrier / calc_pclk)) + 0.5);
  			/* copy result to MAVEN TV mode */
  			maventv_regs[0] = ((chromasc >> 24) & 0xff);
  			maventv_regs[1] = ((chromasc >> 16) & 0xff);
  			maventv_regs[2] = ((chromasc >>  8) & 0xff);
  			maventv_regs[3] = ((chromasc >>  0) & 0xff);
  			LOG(4,("MAVENTV: TV chroma subcarrier divider set is $%08x\n", chromasc));
  
  			/* calculate front porch in 'half pixelclocks' */
  			/* we always round up because of the h_total truncating 'trick' below,
  			 * which works in combination with the existing difference between
  			 * h_total_clk and h_total */
  			//fixme: prevent this if possible!
  			front_porch = ((m_timing.front_porch / ((float)pix_period)) + 1);
  			/* value must be even */
  			front_porch &= ~0x01;
  
  			/* calculate back porch in 'half pixelclocks' */
  			/* we always round up because of the h_total truncating 'trick' below,
  			 * which works in combination with the existing difference between
  			 * h_total_clk and h_total */
  			//fixme: prevent this if possible!
  			back_porch = ((m_timing.back_porch / ((float)pix_period)) + 1);
  			/* value must be even */
  			back_porch &= ~0x01;
  
  			/* calculate h_sync length in 'half pixelclocks' */
  			/* we always round up because of the h_total truncating 'trick' below,
  			 * which works in combination with the existing difference between
  			 * h_total_clk and h_total */
  			//fixme: prevent this if possible!
  			h_sync_length = ((m_timing.h_sync_length / ((float)pix_period)) + 1);
  			/* value must be even */
  			h_sync_length &= ~0x01;
  
  			/* calculate h_total in 'half pixelclocks' */
  			h_total = h_display + front_porch + back_porch + h_sync_length;
  
  			LOG(4,("MAVENTV: TV front_porch is %d clocks\n", front_porch));
  			LOG(4,("MAVENTV: TV back_porch is %d clocks\n", back_porch));
  			LOG(4,("MAVENTV: TV h_sync_length is %d clocks\n", h_sync_length));
  			LOG(4,("MAVENTV: TV h_display is %d clocks \n", h_display));
  			LOG(4,("MAVENTV: TV h_total is %d clocks\n", h_total));
  
  			/* calculate color_burst length in 'half pixelclocks' */
  			burst_length = (((m_timing.color_burst /*- 1*/) / ((float)pix_period)) + 0.5);
  			LOG(4,("MAVENTV: TV color_burst is %d clocks.\n", burst_length));
  
  			/* copy result to MAVEN TV mode */
  			maventv_regs[0x09] = burst_length;
  
  			/* Calculate line length 'rest' that remains after truncating
  			 * h_total to adhere to the CRTC2 timing restrictions. */
  			leftover = h_total & 0x0F;
  			/* if some 'rest' exists, we need to compensate for it... */ 
  			/* Note:
  			 * It's much better to prevent this from happening because this
  			 * 'trick' will decay TVout timing! (timing is nolonger official) */
  			if (leftover)
  			{
  				/* truncate line length to adhere to CRTC2 restrictions */
  				front_porch -= leftover;
  				h_total -= leftover;
  
  				/* now set line length to closest CRTC2 valid match */
  				if (leftover < 3)
  				{
  					/* 1 <= old rest <= 2:
  					 * Truncated line length is closest match. */
  					LOG(4,("MAVENTV: CRTC2 h_total leftover discarded (< 3)\n"));
  				}
  				else
  				{
  					if (leftover < 10)
  					{
  						/* 3 <= old rest <= 9:
  						 * We use the NTSC killer circuitry to get closest match.
  						 * (The 'g400_crtc2_set_timing' routine will enable it
  						 *  because of the illegal h_total timing we create here.) */
  						front_porch += 4;
  						h_total += 4;
  						LOG(4,("MAVENTV: CRTC2 h_total leftover corrected via killer (> 2, < 10)\n"));
  					}
  					else
  					{
  						/* 10 <= old rest <= 15:
  						 * Set closest valid CRTC2 match. */
  						front_porch += 16;
  						h_total += 16;
  						LOG(4,("MAVENTV: CRTC2 h_total leftover corrected via increase (> 9, < 16)\n"));
  					}
  				}
  			}
  
  			/* (linux) fixme: maybe MAVEN has requirement 800 < h_total < 1184 */
  			maventv_regs[0x2C] = front_porch;
  			maventv_regs[0x0A] = back_porch;
  			maventv_regs[0x08] = h_sync_length;
  
  			/* change h_total to represent 'whole pixelclocks' */
  			h_total = h_total >> 1;
  
  			/* tune display_mode adhering to CRTC2 restrictions */
  			tv_target.timing.h_sync_end = (h_total & ~0x07) - 8;
  			/* h_total is checked before being programmed! (NTSC killer circuitry) */
  			tv_target.timing.h_total = h_total;
  		}
  
  		/* output Y/C and CVBS signals (| $40 needed for SCART) */
  		DXIW(TVO_IDX, 0x80);
  		DXIW(TVO_DATA, 0x03);
  
  		/* select input colorspace */
  		//fixme?: has no effect on output picture on monitor or TV...
  		//DXIW(TVO_IDX, 0x81);
  		//DXIW(TVO_DATA, 0x00);
  
  		/* calculate vertical sync point */
  		{
  			int upper;
  		
  			/* set 625 lines for PAL or 525 lines for NTSC */
  			maventv_regs[0x17] = m_timing.v_total / 4;
  			maventv_regs[0x18] = m_timing.v_total & 3;
  
  			/* calculate upper blanking range in field lines */
  			upper = (m_timing.v_total - tv_target.timing.v_sync_end) >> 1;
  
  			/* blank TVout above the line number calculated */
  			maventv_regs[0x33] = upper - 1;
  
  			/* set calculated vertical sync point */
  			DXIW(TVO_IDX, 0x82);
  			DXIW(TVO_DATA, (upper & 0xff));
  			DXIW(TVO_IDX, 0x83);
  			DXIW(TVO_DATA, ((upper >> 8) & 0xff));
  			LOG(4,("MAVENTV: TV upper blanking range set is %d\n", upper));
  		}
  
  		/* set fized horizontal sync point */
  		DXIW(TVO_IDX, 0x84);
  		DXIW(TVO_DATA, 0x01);
  		DXIW(TVO_IDX, 0x85);
  		DXIW(TVO_DATA, 0x00);
  
  		/* connect DAC1 to CON1, CRTC2/'DAC2' to CON2 (TVout mode) */
  		DXIW(OUTPUTCONN,0x0d); 
  	}
  
  	/* program new TVout mode */
  	for (val = 0x00; val <= 0x3D; val++)
  	{
  		if (si->ps.card_type <= G400MAX)
  		{
  			i2c_maven_write(val, maventv_regs[val]);
  		}
  		else
  		{
  			DXIW(TVO_IDX, val);
  			DXIW(TVO_DATA, maventv_regs[val]);
  		}
  	}
  
  	/* leave mode-program mode */
  	if (si->ps.card_type <= G400MAX) MAVW(PGM, 0x00);
  	else
  	{
  		DXIW(TVO_IDX, MGAMAV_PGM);
  		DXIW(TVO_DATA, 0x00);
  
  		/* Select 2.0 Volt MAVEN DAC ref. so we have enough contrast/brightness range */
  		DXIW(GENIOCTRL, DXIR(GENIOCTRL) | 0x40);
  		DXIW(GENIODATA, 0x00);
  	}
  
  	/* setup CRTC timing */
  	if (si->ps.secondary_head)
  	{
  		/* on dualhead cards TVout is always used on CRTC2 */
  		g400_crtc2_set_timing(tv_target);
  	}
  	else
  	{
  		/* on singlehead cards TVout is always used on CRTC1 */
  		gx00_crtc_set_timing(tv_target);
  	}
  
  	/* start whole thing if needed */
  	if (si->ps.card_type <= G400MAX) MAVW(RESYNC, 0x20);
  
  	return 0;
  }
  