Attachment #107350 for bug #162628

View | Details | Raw Unified | Return to bug 162628
Collapse All | Expand All

Lines 31-36 Link Here

(-)aty-2.6.18/ati_ids.h (+32 lines)
31	#define PCI_CHIP_RV360_AR 0x4152	31	#define PCI_CHIP_RV360_AR 0x4152
32	#define PCI_CHIP_RV350_AS 0x4153	32	#define PCI_CHIP_RV350_AS 0x4153
33	#define PCI_CHIP_RV350_AT 0x4154	33	#define PCI_CHIP_RV350_AT 0x4154
		34	#define PCI_CHIP_RV350_AU 0x4155
34	#define PCI_CHIP_RV350_AV 0x4156	35	#define PCI_CHIP_RV350_AV 0x4156
35	#define PCI_CHIP_MACH32 0x4158	36	#define PCI_CHIP_MACH32 0x4158
36	#define PCI_CHIP_RS250_4237 0x4237	37	#define PCI_CHIP_RS250_4237 0x4237
Lines 71-77 Link Here
71	#define PCI_CHIP_R420_JL 0x4A4C	72	#define PCI_CHIP_R420_JL 0x4A4C
72	#define PCI_CHIP_R420_JM 0x4A4D	73	#define PCI_CHIP_R420_JM 0x4A4D
73	#define PCI_CHIP_R420_JN 0x4A4E	74	#define PCI_CHIP_R420_JN 0x4A4E
		75	#define PCI_CHIP_R420_JO 0x4A4F
74	#define PCI_CHIP_R420_JP 0x4A50	76	#define PCI_CHIP_R420_JP 0x4A50
		77	#define PCI_CHIP_R420_JT 0x4A54
		78	#define PCI_CHIP_R480_KI 0x4B49
		79	#define PCI_CHIP_R480_KJ 0x4B4A
		80	#define PCI_CHIP_R480_KK 0x4B4B
		81	#define PCI_CHIP_R480_KL 0x4B4C
75	#define PCI_CHIP_MACH64LB 0x4C42	82	#define PCI_CHIP_MACH64LB 0x4C42
76	#define PCI_CHIP_MACH64LD 0x4C44	83	#define PCI_CHIP_MACH64LD 0x4C44
77	#define PCI_CHIP_RAGE128LE 0x4C45	84	#define PCI_CHIP_RAGE128LE 0x4C45
Lines 182-190 Link Here
182	#define PCI_CHIP_R423_UI 0x5549	189	#define PCI_CHIP_R423_UI 0x5549
183	#define PCI_CHIP_R423_UJ 0x554A	190	#define PCI_CHIP_R423_UJ 0x554A
184	#define PCI_CHIP_R423_UK 0x554B	191	#define PCI_CHIP_R423_UK 0x554B
		192	#define PCI_CHIP_R423_UL 0x554C
		193	#define PCI_CHIP_R423_UM 0x554D
		194	#define PCI_CHIP_R423_UN 0x554E
		195	#define PCI_CHIP_R423_UO 0x554F
		196	#define PCI_CHIP_R423_UP 0x5550
185	#define PCI_CHIP_R423_UQ 0x5551	197	#define PCI_CHIP_R423_UQ 0x5551
186	#define PCI_CHIP_R423_UR 0x5552	198	#define PCI_CHIP_R423_UR 0x5552
187	#define PCI_CHIP_R423_UT 0x5554	199	#define PCI_CHIP_R423_UT 0x5554
		200	#define PCI_CHIP_RV410_VJ 0x564A
		201	#define PCI_CHIP_RV410_VK 0x564B
		202	#define PCI_CHIP_RV410_VO 0x564F
		203	#define PCI_CHIP_RV410_VR 0x5652
		204	#define PCI_CHIP_RV410_VS 0x5653
188	#define PCI_CHIP_MACH64VT 0x5654	205	#define PCI_CHIP_MACH64VT 0x5654
189	#define PCI_CHIP_MACH64VU 0x5655	206	#define PCI_CHIP_MACH64VU 0x5655
190	#define PCI_CHIP_MACH64VV 0x5656	207	#define PCI_CHIP_MACH64VV 0x5656
Lines 206-212 Link Here
206	#define PCI_CHIP_RV280_5964 0x5964	223	#define PCI_CHIP_RV280_5964 0x5964
207	#define PCI_CHIP_RV280_5C61 0x5C61	224	#define PCI_CHIP_RV280_5C61 0x5C61
208	#define PCI_CHIP_RV280_5C63 0x5C63	225	#define PCI_CHIP_RV280_5C63 0x5C63
		226	#define PCI_CHIP_R423_5D48 0x5D48
		227	#define PCI_CHIP_R423_5D49 0x5D49
		228	#define PCI_CHIP_R423_5D4A 0x5D4A
		229	#define PCI_CHIP_R480_5D4C 0x5D4C
		230	#define PCI_CHIP_R480_5D4D 0x5D4D
		231	#define PCI_CHIP_R480_5D4E 0x5D4E
		232	#define PCI_CHIP_R480_5D4F 0x5D4F
		233	#define PCI_CHIP_R480_5D50 0x5D50
		234	#define PCI_CHIP_R480_5D52 0x5D52
209	#define PCI_CHIP_R423_5D57 0x5D57	235	#define PCI_CHIP_R423_5D57 0x5D57
		236	#define PCI_CHIP_RV410_5E48 0x5E48
		237	#define PCI_CHIP_RV410_5E4A 0x5E4A
		238	#define PCI_CHIP_RV410_5E4B 0x5E4B
		239	#define PCI_CHIP_RV410_5E4C 0x5E4C
		240	#define PCI_CHIP_RV410_5E4D 0x5E4D
		241	#define PCI_CHIP_RV410_5E4F 0x5E4F
210	#define PCI_CHIP_RS350_7834 0x7834	242	#define PCI_CHIP_RS350_7834 0x7834
211	#define PCI_CHIP_RS350_7835 0x7835	243	#define PCI_CHIP_RS350_7835 0x7835
212		244




	host_path_cntl = INREG(HOST_PATH_CNTL);
	rbbm_soft_reset = INREG(RBBM_SOFT_RESET);

	if (IS_R300_VARIANT(rinfo)) {
	    rinfo->family == CHIP_FAMILY_R350 ||
	    rinfo->family == CHIP_FAMILY_RV350) {
		u32 tmp;

		OUTREG(RBBM_SOFT_RESET, (rbbm_soft_reset |

	INREG(HOST_PATH_CNTL);
	OUTREG(HOST_PATH_CNTL, host_path_cntl);

	if (IS_R300_VARIANT(rinfo))
	    rinfo->family != CHIP_FAMILY_R350 ||
	    rinfo->family != CHIP_FAMILY_RV350)
		OUTREG(RBBM_SOFT_RESET, rbbm_soft_reset);

	OUTREG(CLOCK_CNTL_INDEX, clock_cntl_index);

{
	unsigned long temp;

	/* disable 3D engine */
	OUTREG(RB3D_CNTL, 0);

	radeonfb_engine_reset(rinfo);

	radeon_fifo_wait (1);
	if (IS_R300_VARIANT(rinfo)) {
		temp = INREG(RB2D_DSTCACHE_MODE);
		OUTREG(RB2D_DSTCACHE_MODE, temp | (1<<17)); /* FIXME */
	} else {
		OUTREG(RB2D_DSTCACHE_MODE, 0);
	}

	radeon_fifo_wait (3);
	/* We re-read MC_FB_LOCATION from card as it can have been

Lines 58-64 Link Here

(-)aty-2.6.18/radeon_backlight.c (-2 / +2 lines)
58	u32 lvds_gen_cntl, tmpPixclksCntl;	58	u32 lvds_gen_cntl, tmpPixclksCntl;
59	int level;	59	int level;
60		60
61	if (rinfo->mon1_type != MT_LCD)	61	if (PRIMARY_MONITOR(rinfo) != MT_LCD)
62	return 0;	62	return 0;
63		63
64	/* We turn off the LCD completely instead of just dimming the	64	/* We turn off the LCD completely instead of just dimming the
Lines 146-152 Link Here
146	struct radeon_bl_privdata *pdata;	146	struct radeon_bl_privdata *pdata;
147	char name[12];	147	char name[12];
148		148
149	if (rinfo->mon1_type != MT_LCD)	149	if (PRIMARY_MONITOR(rinfo) == MT_LCD) {
150	return;	150	return;
151		151
152	#ifdef CONFIG_PMAC_BACKLIGHT	152	#ifdef CONFIG_PMAC_BACKLIGHT




 *
 *	framebuffer driver for ATI Radeon chipset video boards
 *
 *	Copyright 2006	Solomon Peachy <pizza@shaftnet.org>
 *	Copyright 2003	Ben. Herrenschmidt <benh@kernel.crashing.org>
 *	Copyright 2000	Ani Joshi <ajoshi@kernel.crashing.org>
 *

 */


#define RADEON_VERSION	"0.3.0"

#include <linux/module.h>
#include <linux/moduleparam.h>

	CHIP_DEF(PCI_CHIP_RV360_AR,	RV350,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_RV350_AS,	RV350,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_RV350_AT,	RV350,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_RV350_AU, 	RV350,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_RV350_AV,	RV350,	CHIP_HAS_CRTC2),
	/* 9800/Pro/FileGL X2 */
	CHIP_DEF(PCI_CHIP_R350_AH,	R350,	CHIP_HAS_CRTC2),

	CHIP_DEF(PCI_CHIP_R350_NI,	R350,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R360_NJ,	R350,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R350_NK,	R350,	CHIP_HAS_CRTC2),
	/* X300/X600 */
	CHIP_DEF(PCI_CHIP_RV380_3E50,	RV380,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_RV380_3E54,	RV380,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_RV380_3150,	RV380,	CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),

	CHIP_DEF(PCI_CHIP_RV370_5B65,	RV380,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_RV370_5460,	RV380,	CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
	CHIP_DEF(PCI_CHIP_RV370_5464,	RV380,	CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
	/* X700 */
	CHIP_DEF(PCI_CHIP_RV410_VJ, 	RV410,	CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
	CHIP_DEF(PCI_CHIP_RV410_VK, 	RV410,	CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
	CHIP_DEF(PCI_CHIP_RV410_VO, 	RV410,	CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
	CHIP_DEF(PCI_CHIP_RV410_VR, 	RV410,	CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
	CHIP_DEF(PCI_CHIP_RV410_VS, 	RV410,	CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
	CHIP_DEF(PCI_CHIP_RV410_5E48,	RV410,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_RV410_5E4A,	RV410,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_RV410_5E4B,	RV410,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_RV410_5E4C,	RV410,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_RV410_5E4D,	RV410,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_RV410_5E4F,	RV410,	CHIP_HAS_CRTC2),
	/* X800/X850 */
	CHIP_DEF(PCI_CHIP_R420_JH,	R420,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R420_JI,	R420,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R420_JJ,	R420,	CHIP_HAS_CRTC2),

	CHIP_DEF(PCI_CHIP_R420_JL,	R420,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R420_JM,	R420,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R420_JN,	R420,	CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
	CHIP_DEF(PCI_CHIP_R420_JO, 	R420,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R420_JP,	R420,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R420_JT, 	R420,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R423_UH,	R420,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R423_UI,	R420,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R423_UJ,	R420,	CHIP_HAS_CRTC2),

	CHIP_DEF(PCI_CHIP_R423_UR,	R420,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R423_UT,	R420,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R423_5D57,	R420,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R423_UP, 	R420,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R423_5D49, 	R420,	CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
	CHIP_DEF(PCI_CHIP_R423_5D4A, 	R420,	CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
	CHIP_DEF(PCI_CHIP_R423_5D48, 	R420,	CHIP_HAS_CRTC2 | CHIP_IS_MOBILITY),
	CHIP_DEF(PCI_CHIP_R423_UO, 	R420,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R423_UM, 	R420,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R423_UN, 	R420,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R423_UL, 	R420,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R480_5D4C, 	R420,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R480_5D50, 	R420,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R480_5D4E, 	R420,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R480_5D4F, 	R420,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R480_5D52, 	R420,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R480_5D4D, 	R420,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R480_KJ, 	R420,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R480_KK,    R420,     CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R480_KI, 	R420,	CHIP_HAS_CRTC2),
	CHIP_DEF(PCI_CHIP_R480_KL, 	R420,	CHIP_HAS_CRTC2),
	/* Original Radeon/7200 */
	CHIP_DEF(PCI_CHIP_RADEON_QD,	RADEON,	0),
	CHIP_DEF(PCI_CHIP_RADEON_QE,	RADEON,	0),

static int default_dynclk = -2;
static int nomodeset = 0;
static int ignore_edid = 0;
static int ignore_conntable = 0;
static int mirror = 0;
static int panel_yres = 0;
static int force_dfp = 0;

static int force_sleep;
static int ignore_devlist;

#ifdef CONFIG_FB_RADEON_DEBUG
int radeonfb_debug = 1;
#else
int radeonfb_debug = 0;
#endif

/*
 * prototypes
 */

	 * to phase out Open Firmware images.
	 *
	 * Currently, we only look at the first PCI data, we could iteratre and deal with
	 * them all, and we should use fp_bios_start relative to start of image and not
	 * relative start of ROM, but so far, I never found a dual-image ATI card
	 *
	 * typedef struct {

 * Read XTAL (ref clock), SCLK and MCLK from Open Firmware device
 * tree. Hopefully, ATI OF driver is kind enough to fill these
 */
static int __devinit radeon_get_pll_info_openfirmware (struct radeonfb_info *rinfo)
{
	struct device_node *dp = rinfo->of_node;
	u32 *val;

	if (val && *val)
		rinfo->pll.mclk = (*val) / 10;

	RTRACE("Retrieved PLL infos from Open Firmware\n");
       	return 0;
}
#endif /* CONFIG_PPC_OF */

	return 0;
}

static int __devinit radeon_get_pll_info_legacy(struct radeonfb_info *rinfo)
{
	u16 pll_info_block;

	if (!rinfo->bios_seg)
		return -EINVAL;

	pll_info_block = BIOS_IN16(rinfo->fp_bios_start + 0x30);
	
	rinfo->pll.sclk		= BIOS_IN16(pll_info_block + 0x08);
	rinfo->pll.mclk		= BIOS_IN16(pll_info_block + 0x0a);
	rinfo->pll.ref_clk	= BIOS_IN16(pll_info_block + 0x0e);
	rinfo->pll.ref_div	= BIOS_IN16(pll_info_block + 0x10);
	rinfo->pll.ppll_min	= BIOS_IN32(pll_info_block + 0x12);
	rinfo->pll.ppll_max	= BIOS_IN32(pll_info_block + 0x16);

	RTRACE("Retrieved PLL infos from Legacy BIOS\n");
	return 0;
}


static int __devinit radeon_get_pll_info_atom(struct radeonfb_info *rinfo)
{
	u16 pll_info_block;

	if (!rinfo->bios_seg)
		return -EINVAL;

	pll_info_block = BIOS_IN16(rinfo->atom_data_start + 12);
	
	rinfo->pll.sclk = BIOS_IN32(pll_info_block + 8);
	rinfo->pll.mclk = BIOS_IN32(pll_info_block + 12);
	rinfo->pll.ref_clk = BIOS_IN16(pll_info_block + 82);
	rinfo->pll.ref_div = 0; /* Have to get it elsewhere */
	rinfo->pll.ppll_min = BIOS_IN16(pll_info_block + 78);
	rinfo->pll.ppll_max = BIOS_IN32(pll_info_block + 32);

	RTRACE("Retrieved PLL infos from ATOM BIOS\n");
	return 0;
}

static void radeon_detect_bios_type(struct radeonfb_info *rinfo)
{
#ifdef CONFIG_PPC_OF
	  rinfo->is_atom_bios = 0;
	  rinfo->get_pll_info = radeon_get_pll_info_openfirmware;
	  rinfo->get_lvds_info = radeon_get_lvds_info_openfirmware;
	  rinfo->radeon_get_tmds_info = NULL;
	  rinfo->get_conn_info = radeon_get_conn_info_openfirmware;
#else
	  int tmp = rinfo->fp_bios_start + 4;

	  if ((BIOS_IN8(tmp) == 'A' &&
	       BIOS_IN8(tmp+1) == 'T' &&
	       BIOS_IN8(tmp+2) == 'O' &&
	       BIOS_IN8(tmp+3) == 'M') ||
	      (BIOS_IN8(tmp) == 'M' &&
	       BIOS_IN8(tmp+1) == 'O' &&
	       BIOS_IN8(tmp+2) == 'T' &&
	       BIOS_IN8(tmp+3) == 'A')) {
		  rinfo->is_atom_bios = 1;

		  rinfo->atom_data_start = BIOS_IN16(rinfo->fp_bios_start + 32);
		  rinfo->radeon_get_pll_info = radeon_get_pll_info_atom;
		  rinfo->radeon_get_lvds_info = radeon_get_lvds_info_atom;
		  rinfo->radeon_get_conn_info = radeon_get_conn_info_atom;
		  rinfo->radeon_get_tmds_info = radeon_get_tmds_info_atom;
	  } else {
		  rinfo->is_atom_bios = 0;
		  rinfo->radeon_get_pll_info = radeon_get_pll_info_legacy;
		  rinfo->radeon_get_lvds_info = radeon_get_lvds_info_legacy;
		  rinfo->radeon_get_conn_info = radeon_get_conn_info_legacy;
		  rinfo->radeon_get_tmds_info = radeon_get_tmds_info_legacy;
	  }
#endif  /* CONFIG_PPC_OF */

}

/*
 * Retrieve PLL infos by different means (BIOS, Open Firmware, register probing...)
 */
static void __devinit radeon_get_pll_info(struct radeonfb_info *rinfo)
{
	/*
	 * In the case nothing works, these are defaults; they are mostly

	case PCI_DEVICE_ID_ATI_RADEON_QF:
	case PCI_DEVICE_ID_ATI_RADEON_QG:
	default:
		if (rinfo->family == CHIP_FAMILY_R420) {
			rinfo->pll.ppll_max = 50000;
			rinfo->pll.ppll_min = 20000;
		} else {
			rinfo->pll.ppll_max = 35000;
			rinfo->pll.ppll_min = 12000;
		}
		rinfo->pll.mclk = 16600;
		rinfo->pll.sclk = 16600;
		rinfo->pll.ref_clk = 2700;
		break;
	}
	rinfo->pll.ref_div = INPLL(PPLL_REF_DIV) & PPLL_REF_DIV_MASK;


#ifdef CONFIG_PPC_OF
	/*
	 * If we have a way to retrieve the PLL information, do so.
	 */
	if (!force_measure_pll && rinfo->radeon_get_pll_info) {
		if (!rinfo->radeon_get_pll_info(rinfo)) {
			goto found;
		}
#endif /* CONFIG_PPC_OF */

	/*
	 * Check out if we have an X86 which gave us some PLL informations
	 * and if yes, retrieve them
	 */
	if (!force_measure_pll && rinfo->bios_seg) {
		u16 pll_info_block = BIOS_IN16(rinfo->fp_bios_start + 0x30);

		rinfo->pll.sclk		= BIOS_IN16(pll_info_block + 0x08);
		rinfo->pll.mclk		= BIOS_IN16(pll_info_block + 0x0a);
		rinfo->pll.ref_clk	= BIOS_IN16(pll_info_block + 0x0e);
		rinfo->pll.ref_div	= BIOS_IN16(pll_info_block + 0x10);
		rinfo->pll.ppll_min	= BIOS_IN32(pll_info_block + 0x12);
		rinfo->pll.ppll_max	= BIOS_IN32(pll_info_block + 0x16);

		printk(KERN_INFO "radeonfb: Retrieved PLL infos from BIOS\n");
		goto found;
	}

	/*
	 * If we don't get the PLL parameters handed to us, we try to
	 * probe them
	 */
	if (radeon_probe_pll_params(rinfo) == 0) {

       	printk(KERN_INFO "radeonfb: Used default PLL infos\n");

found:

	/* Check and fix-up the PLL divisor if necessary */
	if (rinfo->pll.ref_div < 2) {
		int tmp = INPLL(PPLL_REF_DIV);
		if (rinfo->family == CHIP_FAMILY_RS300) {
			rinfo->pll.ref_div = (tmp & R300_PPLL_REF_DIV_ACC_MASK) >> R300_PPLL_REF_DIV_ACC_SHIFT;
		} else {
			rinfo->pll.ref_div = tmp & PPLL_REF_DIV_MASK;
		}
		
		/* Sane default */
		if (rinfo->pll.ref_div < 2) {		
			rinfo->pll.ref_div = 12;
		}
	}		

	/*
	 * Some methods fail to retrieve SCLK and MCLK values, we apply default
	 * settings in this case (200Mhz). If that really happne often, we could

	       rinfo->pll.ref_div,
	       rinfo->pll.mclk / 100, rinfo->pll.mclk % 100,
	       rinfo->pll.sclk / 100, rinfo->pll.sclk % 100);
	RTRACE("PLL min %d max %d\n", rinfo->pll.ppll_min, rinfo->pll.ppll_max);
}

static int radeonfb_check_var (struct fb_var_screeninfo *var, struct fb_info *info)

        if (rinfo->asleep)
        	return 0;

	radeon_engine_idle();
        OUTREG(CRTC_OFFSET, ((var->yoffset * var->xres_virtual + var->xoffset)
			     * var->bits_per_pixel / 8) & ~7);
        return 0;

        u32 val;
	u32 tmp_pix_clks;
	int unblank = 0;
	int i;

	if (rinfo->lock_blank)
		return 0;

        }
	OUTREG(CRTC_EXT_CNTL, val);

	for (i = 0 ; i < RADEON_MAX_CONNECTORS ; i++) {
		if (i == -1) continue;

		switch (rinfo->connectors[rinfo->heads[i]].mon_type) {
		case MT_DFP:
			if (unblank)
				OUTREGP(FP_GEN_CNTL, (FP_FPON | FP_TMDS_EN),
					~(FP_FPON | FP_TMDS_EN));
			else {
				if (mode_switch || blank == FB_BLANK_NORMAL)
					break;
				OUTREGP(FP_GEN_CNTL, 0, ~(FP_FPON | FP_TMDS_EN));
			}
		break;
		case MT_LCD:
			del_timer_sync(&rinfo->lvds_timer);
			val = INREG(LVDS_GEN_CNTL);
			if (unblank) {
				u32 target_val = (val & ~LVDS_DISPLAY_DIS) | LVDS_BLON | LVDS_ON
					| LVDS_EN | (rinfo->init_state.lvds_gen_cntl
						     & (LVDS_DIGON | LVDS_BL_MOD_EN));
				if ((val ^ target_val) == LVDS_DISPLAY_DIS)
				OUTREG(LVDS_GEN_CNTL, target_val);
			else if ((val ^ target_val) != 0) {
				OUTREG(LVDS_GEN_CNTL, target_val
				       & ~(LVDS_ON | LVDS_BL_MOD_EN));
				rinfo->init_state.lvds_gen_cntl &= ~LVDS_STATE_MASK;
				rinfo->init_state.lvds_gen_cntl |=
					target_val & LVDS_STATE_MASK;
				if (mode_switch) {
					radeon_msleep(rinfo->panel_info.pwr_delay);
					OUTREG(LVDS_GEN_CNTL, target_val);
				else if ((val ^ target_val) != 0) {
					OUTREG(LVDS_GEN_CNTL, target_val
					       & ~(LVDS_ON | LVDS_BL_MOD_EN));
					rinfo->init_state.lvds_gen_cntl &= ~LVDS_STATE_MASK;
					rinfo->init_state.lvds_gen_cntl |=
						target_val & LVDS_STATE_MASK;
					if (mode_switch) {
						radeon_msleep(rinfo->panel_info.pwr_delay);
						OUTREG(LVDS_GEN_CNTL, target_val);
					} else {
						rinfo->pending_lvds_gen_cntl = target_val;
						mod_timer(&rinfo->lvds_timer,
							  jiffies +
							  msecs_to_jiffies(rinfo->panel_info.pwr_delay));
					}
				}
			} else {
				val |= LVDS_DISPLAY_DIS;
				OUTREG(LVDS_GEN_CNTL, val);
				
				/* We don't do a full switch-off on a simple mode switch */
				if (mode_switch || blank == FB_BLANK_NORMAL)
					break;
				
				/* Asic bug, when turning off LVDS_ON, we have to make sure
				 * RADEON_PIXCLK_LVDS_ALWAYS_ON bit is off
				 */
				tmp_pix_clks = INPLL(PIXCLKS_CNTL);
				if (rinfo->is_mobility || rinfo->is_IGP)
					OUTPLLP(PIXCLKS_CNTL, 0, ~PIXCLK_LVDS_ALWAYS_ONb);
				val &= ~(LVDS_BL_MOD_EN);
				OUTREG(LVDS_GEN_CNTL, val);
				udelay(100);
				val &= ~(LVDS_ON | LVDS_EN);
				OUTREG(LVDS_GEN_CNTL, val);
				val &= ~LVDS_DIGON;
				rinfo->pending_lvds_gen_cntl = val;
				mod_timer(&rinfo->lvds_timer,
					  jiffies +
					  msecs_to_jiffies(rinfo->panel_info.pwr_delay));
				rinfo->init_state.lvds_gen_cntl &= ~LVDS_STATE_MASK;
				rinfo->init_state.lvds_gen_cntl |= val & LVDS_STATE_MASK;
				if (rinfo->is_mobility || rinfo->is_IGP)
					OUTPLL(PIXCLKS_CNTL, tmp_pix_clks);
			}
			break;
		case MT_CRT:
			// todo: powerdown DAC
		default:
			break;
			if (mode_switch || blank == FB_BLANK_NORMAL)
				break;

			/* Asic bug, when turning off LVDS_ON, we have to make sure
			 * RADEON_PIXCLK_LVDS_ALWAYS_ON bit is off
			 */
			tmp_pix_clks = INPLL(PIXCLKS_CNTL);
			if (rinfo->is_mobility || rinfo->is_IGP)
				OUTPLLP(PIXCLKS_CNTL, 0, ~PIXCLK_LVDS_ALWAYS_ONb);
			val &= ~(LVDS_BL_MOD_EN);
			OUTREG(LVDS_GEN_CNTL, val);
			udelay(100);
			val &= ~(LVDS_ON | LVDS_EN);
			OUTREG(LVDS_GEN_CNTL, val);
			val &= ~LVDS_DIGON;
			rinfo->pending_lvds_gen_cntl = val;
			mod_timer(&rinfo->lvds_timer,
				  jiffies +
				  msecs_to_jiffies(rinfo->panel_info.pwr_delay));
			rinfo->init_state.lvds_gen_cntl &= ~LVDS_STATE_MASK;
			rinfo->init_state.lvds_gen_cntl |= val & LVDS_STATE_MASK;
			if (rinfo->is_mobility || rinfo->is_IGP)
				OUTPLL(PIXCLKS_CNTL, tmp_pix_clks);
		}
		break;
	case MT_CRT:
		// todo: powerdown DAC
	default:
		break;
	}

	/* let fbcon do a soft blank for us */

	radeon_pll_errata_after_data(rinfo);

	/* Set PPLL ref. div */
	if (IS_R300_VARIANT(rinfo) || (rinfo->family == CHIP_FAMILY_RS300)) {
	    rinfo->family == CHIP_FAMILY_RS300 ||
	    rinfo->family == CHIP_FAMILY_R350 ||
	    rinfo->family == CHIP_FAMILY_RV350) {
		if (mode->ppll_ref_div & R300_PPLL_REF_DIV_ACC_MASK) {
			/* When restoring console mode, use saved PPLL_REF_DIV
			 * setting.

	OUTREG(CRTC_OFFSET_CNTL, 0);
	OUTREG(CRTC_PITCH, mode->crtc_pitch);
	OUTREG(SURFACE_CNTL, mode->surface_cntl);
	OUTREG(DISP_MERGE_CNTL, 0xffff0000);

	radeon_write_pll_regs(rinfo, mode);


        info->fix.ywrapstep = 0;
        info->fix.type_aux = 0;
        info->fix.mmio_start = rinfo->mmio_base_phys;
        info->fix.mmio_len = pci_resource_len(rinfo->pdev, 2);
	info->fix.accel = FB_ACCEL_ATI_RADEON;

	fb_alloc_cmap(&info->cmap, 256, 0);

	u32 tmp;

	/* framebuffer size */
        if (rinfo->is_IGP) {
            (rinfo->family == CHIP_FAMILY_RS200) ||
            (rinfo->family == CHIP_FAMILY_RS300)) {
          u32 tom = INREG(NB_TOM);
          tmp = ((((tom >> 16) - (tom & 0xffff) + 1) << 6) * 1024);


	/* mem size is bits [28:0], mask off the rest */
	rinfo->video_ram = tmp & CONFIG_MEMSIZE_MASK;

	/* Limit memory to 128 megs for now */
	if (rinfo->video_ram > MAX_VRAM)
		rinfo->video_ram = MAX_VRAM;

	/*
	 * Hack to get around some busted production M6's
	 * reporting no ram

        struct fb_info *info = pci_get_drvdata(pdev);
        struct radeonfb_info *rinfo = info->par;

	return radeon_show_one_edid(buf, off, count, rinfo->connectors[rinfo->heads[0]].edid);
}



        struct fb_info *info = pci_get_drvdata(pdev);
        struct radeonfb_info *rinfo = info->par;

	return radeon_show_one_edid(buf, off, count, rinfo->connectors[rinfo->heads[1]].edid);
}

static ssize_t radeon_show_edid3(struct kobject *kobj, char *buf, loff_t off, size_t count)
{
	struct device *dev = container_of(kobj, struct device, kobj);
	struct pci_dev *pdev = to_pci_dev(dev);
        struct fb_info *info = pci_get_drvdata(pdev);
        struct radeonfb_info *rinfo = info->par;

	return radeon_show_one_edid(buf, off, count, rinfo->connectors[rinfo->heads[2]].edid);
}

static ssize_t radeon_show_edid4(struct kobject *kobj, char *buf, loff_t off, size_t count)
{
	struct device *dev = container_of(kobj, struct device, kobj);
	struct pci_dev *pdev = to_pci_dev(dev);
        struct fb_info *info = pci_get_drvdata(pdev);
        struct radeonfb_info *rinfo = info->par;

	return radeon_show_one_edid(buf, off, count, rinfo->connectors[rinfo->heads[3]].edid);
}

static struct bin_attribute edid1_attr = {

	.read	= radeon_show_edid2,
};

static struct bin_attribute edid3_attr = {
	.attr   = {
		.name	= "edid3",
		.owner	= THIS_MODULE,
		.mode	= 0444,
	},
	.size	= EDID_LENGTH,
	.read	= radeon_show_edid3,
};

static struct bin_attribute edid4_attr = {
	.attr   = {
		.name	= "edid4",
		.owner	= THIS_MODULE,
		.mode	= 0444,
	},
	.size	= EDID_LENGTH,
	.read	= radeon_show_edid4,
};

static int __devinit radeonfb_pci_register (struct pci_dev *pdev,
				  const struct pci_device_id *ent)

	struct fb_info *info;
	struct radeonfb_info *rinfo;
	int ret;
	int i;

	RTRACE("radeonfb_pci_register BEGIN\n");
	

	}

	/* map the regions */
	rinfo->mmio_base = ioremap(rinfo->mmio_base_phys, 
				   pci_resource_len(rinfo->pdev, 2));
	if (!rinfo->mmio_base) {
		printk(KERN_ERR "radeonfb (%s): cannot map MMIO\n",
		       pci_name(rinfo->pdev));

	 * We probably need to make sure this is the primary display,
	 * but that is difficult without some arch support.
	 */

#ifdef CONFIG_X86
	if (rinfo->bios_seg == NULL)
		radeon_find_mem_vbios(rinfo);

	if (rinfo->bios_seg == NULL && rinfo->is_mobility)
		radeon_map_ROM(rinfo, pdev);

	/* Check BIOS Type */
	radeon_detect_bios_type(rinfo);
	
	/* Get informations about the board's PLL */
	radeon_get_pll_info(rinfo);

	/* Get informations about internal TMDS controller if any */
	radeon_get_tmds_info(rinfo);

#ifdef CONFIG_FB_RADEON_I2C
	/* Register I2C bus */
	radeon_create_i2c_busses(rinfo);
#endif

	/* Get infos about connectors -- need I2C here! */
	radeon_get_conn_info(rinfo, ignore_conntable);

	/* set all the vital stuff */
	radeon_set_fbinfo (rinfo);


	radeon_check_modes(rinfo, mode_option);

	/* Register some sysfs stuff (should be done better) */
	
	if ((rinfo->heads[0] != -1) && rinfo->connectors[rinfo->heads[0]].edid)
		sysfs_create_bin_file(&rinfo->pdev->dev.kobj, &edid1_attr);
	if ((rinfo->heads[1] != -1) && rinfo->connectors[rinfo->heads[1]].edid)
		sysfs_create_bin_file(&rinfo->pdev->dev.kobj, &edid2_attr);
	if ((rinfo->heads[2] != -1) && rinfo->connectors[rinfo->heads[2]].edid)
		sysfs_create_bin_file(&rinfo->pdev->dev.kobj, &edid3_attr);
	if ((rinfo->heads[3] != -1) && rinfo->connectors[rinfo->heads[3]].edid)
		sysfs_create_bin_file(&rinfo->pdev->dev.kobj, &edid4_attr);

	/* save current mode regs before we switch into the new one
	 * so we can restore this upon __exit

err_unmap_fb:
	iounmap(rinfo->fb_base);
err_unmap_rom:
	for (i = 0 ; i < RADEON_MAX_CONNECTORS ; i++) {
		kfree(rinfo->connectors[i].edid);
		if (rinfo->connectors[i].modedb)
			fb_destroy_modedb(rinfo->connectors[i].modedb);
	}

	fb_dealloc_cmap(&info->cmap);
#ifdef CONFIG_FB_RADEON_I2C
	radeon_delete_i2c_busses(rinfo);

{
        struct fb_info *info = pci_get_drvdata(pdev);
        struct radeonfb_info *rinfo = info->par;

	int i;

        if (!rinfo)
                return;

	radeonfb_bl_exit(rinfo);
	radeonfb_pm_exit(rinfo);

	if ((rinfo->heads[0] != -1) && rinfo->connectors[rinfo->heads[0]].edid)
		sysfs_remove_bin_file(&rinfo->pdev->dev.kobj, &edid1_attr);
	if ((rinfo->heads[1] != -1) && rinfo->connectors[rinfo->heads[1]].edid)
		sysfs_remove_bin_file(&rinfo->pdev->dev.kobj, &edid2_attr);
	if ((rinfo->heads[2] != -1) && rinfo->connectors[rinfo->heads[2]].edid)
		sysfs_remove_bin_file(&rinfo->pdev->dev.kobj, &edid3_attr);
	if ((rinfo->heads[3] != -1) && rinfo->connectors[rinfo->heads[3]].edid)
		sysfs_remove_bin_file(&rinfo->pdev->dev.kobj, &edid4_attr);
 
#if 0
	/* restore original state
	 * 

	pci_release_region(pdev, 2);
	pci_release_region(pdev, 0);

	for (i = 0 ; i < RADEON_MAX_CONNECTORS ; i++) {
		kfree(rinfo->connectors[i].edid);
		if (rinfo->connectors[i].modedb)
			fb_destroy_modedb(rinfo->connectors[i].modedb);
	}
#ifdef CONFIG_FB_RADEON_I2C
	radeon_delete_i2c_busses(rinfo);
#endif        

			force_measure_pll = 1;
		} else if (!strncmp(this_opt, "ignore_edid", 11)) {
			ignore_edid = 1;
		} else if (!strncmp(this_opt, "ignore_conntable", 16)) {
			ignore_conntable = 1;
		} else if (!strncmp( this_opt, "default_dynclk:", 15)) {
			default_dynclk = simple_strtoul((this_opt+15), NULL, 10);
#if defined(CONFIG_PM) && defined(CONFIG_X86)
	 	} else if (!strncmp(this_opt, "force_sleep", 11)) {
			force_sleep = 1;
		} else if (!strncmp(this_opt, "ignore_devlist", 14)) {
			ignore_devlist = 1;
#endif
		} else if (!strncmp(this_opt, "debug", 5)) {
			radeonfb_debug = 1;
		} else
			mode_option = this_opt;
	}

MODULE_PARM_DESC(force_dfp, "bool: force display to dfp");
module_param(ignore_edid, bool, 0);
MODULE_PARM_DESC(ignore_edid, "bool: Ignore EDID data when doing DDC probe");
module_param(ignore_conntable, bool, 0);
MODULE_PARM_DESC(ignore_conntable, "bool: Ignore BIOS Connector table");
module_param(monitor_layout, charp, 0);
MODULE_PARM_DESC(monitor_layout, "Specify monitor mapping (like XFree86)");
module_param(force_measure_pll, bool, 0);

module_param(ignore_devlist, bool, 0);
MODULE_PARM_DESC(ignore_devlist, "bool: ignore workarounds for bugs in specific laptops");
#endif
module_param(radeonfb_debug, int, 0);
MODULE_PARM_DESC(radeonfb_debug, "Enable full debugging text");




	return NULL;
}

/* Returns 1 if probe unsuccessful. */
int radeon_probe_i2c_connector(struct radeonfb_info *rinfo, struct radeon_connector *conn)
{
	u32 reg;
	u8 *edid = NULL;
	int mon_type = MT_NONE;

	int i, j;

	if (!conn)
		return 1;

	if (rinfo->is_mobility && (conn->ddc_type == ddc_none) &&
	    (INREG(LVDS_GEN_CNTL) & (LVDS_ON|LVDS_EN))) {
			RTRACE("radeonfb: I2C (port %d) ... found LVDS panel\n", conn->ddc_type);
			mon_type = MT_LCD;
			goto done;
	}

	reg = rinfo->i2c[conn->ddc_type].ddc_reg;

	OUTREG(reg, INREG(reg) & 
			~(VGA_DDC_DATA_OUTPUT | VGA_DDC_CLK_OUTPUT));


		msleep(15);

		/* Do the real work */
		edid = radeon_do_probe_i2c_edid(&rinfo->i2c[conn->ddc_type]);

		OUTREG(reg, INREG(reg) | 
				(VGA_DDC_DATA_OUT_EN | VGA_DDC_CLK_OUT_EN));

		if (edid)
			break;
	}

	/* Release the DDC lines when done or the Apple Cinema HD display
	 * will switch off
	 */
	OUTREG(reg, INREG(reg) & ~(VGA_DDC_CLK_OUT_EN | VGA_DDC_DATA_OUT_EN));
	(void)INREG(reg);

	if (out_edid)
		*out_edid = edid;
	if (!edid) {
	  // what about the special case where we are a DFP/LVDS, but have a DDC connection..
	  // but no EDID? We should fall back to MT_LCD...?  XXXX
		RTRACE("radeonfb: I2C (port %d) ... not found\n", conn->ddc_type);
		mon_type = MT_NONE;
		goto done;
	}

	if ((edid[EDID_STRUCT_DISPLAY] & 0x80) && (conn->ddc_type == ddc_dvi)) {
		RTRACE("radeonfb: I2C (port %d) ... found TMDS panel\n", conn->ddc_type);
		mon_type = MT_DFP;
		goto done;
	}

	if (rinfo->is_mobility && 
	    (conn->conn_type == conn_lvds) &&
	    (edid[EDID_STRUCT_DISPLAY] & 0x80) &&  // ie EDID valid and marks us as a DFP... 
	    (INREG(LVDS_GEN_CNTL) & (LVDS_ON|LVDS_EN))) {
		RTRACE("radeonfb: I2C (port %d) ... found LVDS panel\n", conn->ddc_type);
		mon_type = MT_LCD;
		goto done;
	}

       	RTRACE("radeonfb: I2C (port %d) ... found CRT display\n", conn->ddc_type);
	mon_type = MT_CRT;

 done:
	conn->edid = edid;
	conn->mon_type = mon_type;

	return (mon_type == MT_NONE);
}





#include "radeonfb.h"
#include "../edid.h"

/*
 * TMDS PLL configuration table, taken from X.org
 */
static const struct radeon_tmds_pll_info default_tmds_pll[CHIP_FAMILY_LAST][4] =
{
    {{0, 0}, {0, 0}, {0, 0}, {0, 0}},				/*CHIP_FAMILY_UNKNOW*/
    {{0, 0}, {0, 0}, {0, 0}, {0, 0}},				/*CHIP_FAMILY_LEGACY*/
    {{12000, 0xa1b}, {0xffffffff, 0xa3f}, {0, 0}, {0, 0}},	/*CHIP_FAMILY_RADEON*/
    {{12000, 0xa1b}, {0xffffffff, 0xa3f}, {0, 0}, {0, 0}},	/*CHIP_FAMILY_RV100*/
    {{0, 0}, {0, 0}, {0, 0}, {0, 0}},				/*CHIP_FAMILY_RS100*/
    {{15000, 0xa1b}, {0xffffffff, 0xa3f}, {0, 0}, {0, 0}},	/*CHIP_FAMILY_RV200*/
    {{12000, 0xa1b}, {0xffffffff, 0xa3f}, {0, 0}, {0, 0}},	/*CHIP_FAMILY_RS200*/
    {{15000, 0xa1b}, {0xffffffff, 0xa3f}, {0, 0}, {0, 0}},	/*CHIP_FAMILY_R200*/
    {{15500, 0x81b}, {0xffffffff, 0x83f}, {0, 0}, {0, 0}},	/*CHIP_FAMILY_RV250*/
    {{0, 0}, {0, 0}, {0, 0}, {0, 0}},				/*CHIP_FAMILY_RS300*/
    {{13000, 0x400f4}, {15000, 0x400f7}, {0xffffffff, 0x400f7/*0x40111*/}, {0, 0}},	/*CHIP_FAMILY_RV280*/
    {{0xffffffff, 0xb01cb}, {0, 0}, {0, 0}, {0, 0}},		/*CHIP_FAMILY_R300*/
    {{0xffffffff, 0xb01cb}, {0, 0}, {0, 0}, {0, 0}},		/*CHIP_FAMILY_R350*/
    {{15000, 0xb0155}, {0xffffffff, 0xb01cb}, {0, 0}, {0, 0}},	/*CHIP_FAMILY_RV350*/
    {{15000, 0xb0155}, {0xffffffff, 0xb01cb}, {0, 0}, {0, 0}},	/*CHIP_FAMILY_RV380*/
    {{0xffffffff, 0xb01cb}, {0, 0}, {0, 0}, {0, 0}},		/*CHIP_FAMILY_R420*/
};

static struct fb_var_screeninfo radeonfb_default_var = {
	.xres		= 640,
	.yres		= 480,

	.vmode		= FB_VMODE_NONINTERLACED
};

static char *radeon_get_mon_name(int type)
{
	char *pret = NULL;

	switch (type) {
		case MT_NONE:
			pret = "no";
			break;
		case MT_CRT:
			pret = "CRT";
			break;
		case MT_DFP:
			pret = "DFP";
			break;
		case MT_LCD:
			pret = "LCD";
			break;
		case MT_CTV:
			pret = "CTV";
			break;
		case MT_STV:
			pret = "STV";
			break;
	}

	return pret;
}


#ifdef CONFIG_PPC_OF
/*
 * Try to find monitor informations & EDID data out of the Open Firmware

 * models with broken OF probing by hard-coding known EDIDs for some Mac
 * laptops internal LVDS panel. (XXX: not done yet)
 */
static int __devinit radeon_parse_montype_prop(struct device_node *dp,
					       struct radeon_connector *conn, 
					       int hdno)
{
        static char *propnames[] = { "DFP,EDID", "LCD,EDID", "EDID",

	u8 *pedid = NULL;
	u8 *pmt = NULL;
	u8 *tmp;
        int i;  
	
	RTRACE("analyzing OF properties...\n");
	pmt = (u8 *)get_property(dp, "display-type", NULL);
	if (!pmt)
		return 1;
	RTRACE("display-type: %s\n", pmt);
	if (!strcmp(pmt, "LCD") || !strcmp(pmt, "DFP")) {
		/* OF says "LCD" for DFP as well.*/
		if (rinfo->is_mobility) {
			conn->mon_type = MT_LCD;
			/* Maybe check for LVDS_GEN_CNTL here ? I need to check out
			 * what OF does when booting with lid closed
			 */
		} else{
			conn->mon_type = MT_DFP;
		}
	} else if (!strcmp(pmt, "CRT")) {
		conn->mon_type = MT_CRT;
	} else {
		if (strcmp(pmt, "NONE") != 0)
			printk(KERN_WARNING "radeonfb: Unknown OF display-type: %s\n",
			       pmt);
		return 1;
	}

	for (i = 0; propnames[i] != NULL; ++i) {

	if (pedid == NULL && dp->parent && (hdno == 0))
		pedid = get_property(dp->parent, "EDID", NULL);
	if (pedid == NULL)
		return 1;

	tmp = (u8 *)kmalloc(EDID_LENGTH, GFP_KERNEL);
	if (tmp) {
		memcpy(tmp, pedid, EDID_LENGTH);
	}

	conn->edid = tmp;

	{
		int found_tmds = 0;
		int found_crt = 0;
		int ddc_type = ddc_none;
		// XXX what about reversed DAC/TMDS??
		radeon_fill_conn(conn, conn->mon_type, ddc_type, &found_crt, &found_tmds);
	}

	return 0;
}

/* return a 1 on error */
static int __devinit radeon_probe_OF_head(struct radeonfb_info *rinfo, int head_no)

{
	struct radeon_connector *conn;
        struct device_node *dp;
	u8 *out_EDID;

	RTRACE("radeon_probe_OF_head\n");

	conn = rinfo->connectors[head_no];

        dp = rinfo->of_node;
        if (dp == NULL) 
		return 1;

	if (rinfo->has_CRTC2) {
		char *pname;


		dp = dp->child;
		do {
			if (!dp) 
				return 1;

			pname = (char *)get_property(dp, "name", NULL);
			if (!pname) 
				return 1;

			len = strlen(pname);
			RTRACE("head: %s (letter: %c, head_no: %d)\n",
			       pname, pname[len-1], head_no);
			if (pname[len-1] == 'A' && head_no == 0) {
				return radeon_parse_montype_prop(dp, conn, 0);
			} else if (pname[len-1] == 'B' && head_no == 1) {
				return radeon_parse_montype_prop(dp, conn, 1);
			}
				if (mt == MT_DFP && rinfo->is_mobility)
					mt = MT_LCD;
				return mt;
			} else if (pname[len-1] == 'B' && head_no == 1)
				return radeon_parse_montype_prop(dp, out_EDID, 1);
			second = 1;
			dp = dp->sibling;
		} while(!second);
	} else {
		if (head_no > 0) {
			return 1;
		}
		return radeon_parse_montype_prop(dp, conn, -1);
	}
	return 1;
}
#endif /* CONFIG_PPC_OF */


int __devinit radeon_get_lvds_info_atom(struct radeonfb_info *rinfo)
{
	unsigned long tmp;

	if (!rinfo->bios_seg)
		return -ENODEV;

	tmp = BIOS_IN16(rinfo->atom_data_start + 16);
	if (!tmp) {
		RTRACE("No LVDS panel info in ATOM BIOS\n");
		rinfo->panel_info.pwr_delay = 200;
		return -ENODEV;
	}
	
	rinfo->panel_info.xres = BIOS_IN16(tmp+6);
	rinfo->panel_info.yres = BIOS_IN16(tmp+10);
	printk("radeonfb: detected LVDS panel size from BIOS: %dx%d\n",
	       rinfo->panel_info.xres, rinfo->panel_info.yres);
	rinfo->panel_info.pwr_delay = BIOS_IN16(tmp+40);
	RTRACE("BIOS provided panel power delay: %d\n", rinfo->panel_info.pwr_delay);
	if (rinfo->panel_info.pwr_delay > 2000 || rinfo->panel_info.pwr_delay <= 0)
		rinfo->panel_info.pwr_delay = 2000;
	
	/* No special divider combinations? */
	
	rinfo->panel_info.hblank = BIOS_IN16(tmp+8);
	rinfo->panel_info.hOver_plus = BIOS_IN16(tmp+14);
	rinfo->panel_info.hSync_width = BIOS_IN16(tmp+16);
	rinfo->panel_info.vblank = BIOS_IN16(tmp+12);
	rinfo->panel_info.vOver_plus = BIOS_IN16(tmp+18);
	rinfo->panel_info.vSync_width = BIOS_IN16(tmp+20);
	rinfo->panel_info.clock = BIOS_IN16(tmp+4);
	
	/* Assume high active syncs for now until ATI tells me more... maybe we
	 * can probe register values here ?
	 */
	rinfo->panel_info.hAct_high = 1;
	rinfo->panel_info.vAct_high = 1;
	/* Mark panel infos valid */
	rinfo->panel_info.valid = 1;
	
	return 0;
}

int __devinit radeon_get_lvds_info_legacy(struct radeonfb_info *rinfo)
{
	unsigned long tmp, tmp0;
	char stmp[30];
	int i;

	if (!rinfo->bios_seg)
		return -ENODEV;

	if (!(tmp = BIOS_IN16(rinfo->fp_bios_start + 0x40))) {
		RTRACE("No LVDS panel info in Legacy BIOS\n");
		rinfo->panel_info.pwr_delay = 200;
		return -ENODEV;
	}
	
	for(i=0; i<24; i++)
		stmp[i] = BIOS_IN8(tmp+i+1);
	stmp[24] = 0;

	rinfo->panel_info.xres = BIOS_IN16(tmp + 25);
	rinfo->panel_info.yres = BIOS_IN16(tmp + 27);
	printk("radeonfb: detected LVDS panel size from BIOS: %dx%d\n",
	       rinfo->panel_info.xres, rinfo->panel_info.yres);
	
	rinfo->panel_info.pwr_delay = BIOS_IN16(tmp + 44);
	RTRACE("BIOS provided panel power delay: %d\n", rinfo->panel_info.pwr_delay);
	if (rinfo->panel_info.pwr_delay > 2000 || rinfo->panel_info.pwr_delay <= 0)
		rinfo->panel_info.pwr_delay = 2000;
	
	/*
	 * Some panels only work properly with some divider combinations
	 */

		RTRACE("post_divider = %x\n", rinfo->panel_info.post_divider);
		RTRACE("fbk_divider = %x\n", rinfo->panel_info.fbk_divider);
	}
	
	RTRACE("Scanning BIOS table ...\n");
	for(i=0; i<32; i++) {
		tmp0 = BIOS_IN16(tmp+64+i*2);

			rinfo->panel_info.vAct_high = 1;
			/* Mark panel infos valid */
			rinfo->panel_info.valid = 1;
			
			RTRACE("Found panel in BIOS table:\n");
			RTRACE("  hblank: %d\n", rinfo->panel_info.hblank);
			RTRACE("  hOver_plus: %d\n", rinfo->panel_info.hOver_plus);

			RTRACE("  vOver_plus: %d\n", rinfo->panel_info.vOver_plus);
			RTRACE("  vSync_width: %d\n", rinfo->panel_info.vSync_width);
			RTRACE("  clock: %d\n", rinfo->panel_info.clock);
			
			return 0;
		}
	}

	RTRACE("Didn't find panel in BIOS table !\n");

	return -ENODEV;
}

/*
 * Get informations about TMDS controllers and their setup at
 * different operating frequencies
 */
void __devinit radeon_get_tmds_info(struct radeonfb_info *rinfo)
{
	int i;

	/* Get default TMDS infos for this chip */
	for (i=0; i<4; i++) {
		rinfo->tmds_pll[i].value =
			default_tmds_pll[rinfo->family][i].value;
		rinfo->tmds_pll[i].freq =
			default_tmds_pll[rinfo->family][i].freq;
	}

	/* Get whatever the firmware provides */
	if (rinfo->radeon_get_tmds_info) {
		rinfo->radeon_get_tmds_info(rinfo);
		// XXX Do we care about the return value?
	}
}

int __devinit radeon_get_tmds_info_legacy(struct radeonfb_info *rinfo)
{
	int offset, i, n, rev;

	offset = BIOS_IN16(rinfo->fp_bios_start + 0x34);
	if (offset == 0)
		return -ENODEV;

	rev = BIOS_IN8(offset);
	RTRACE("DFP table revision: %d\n", rev);

	switch(rev) {
	case 3:
		n = BIOS_IN8(offset + 5) + 1;
		if (n > 4)
			n = 4;
		for (i = 0; i < n; i++) {
			/* Looks bogus ... but that's what is in X.org */
			rinfo->tmds_pll[i].value =
				BIOS_IN32(offset+i*10+0x08);
			rinfo->tmds_pll[i].freq =
				BIOS_IN16(offset+i*10+0x10);
		}
		return 0;

	/* revision 4 has some problem as it appears in RV280,
	 * comment it off for now, use default instead
	 */
#if 0
	case 4:
		stride = 0;
		n = BIOS_IN8(offset  5) + 1;
		if (n > 4)
			n = 4;
		for (i = 0; i < n; i++) {
			rinfo->tmds_pll[i].value =
				BIOS_IN32(tmp+stride+0x08);
			rinfo->tmds_pll[i].freq =
				BIOS_IN16(tmp+stride+0x10);
			if (i == 0)
				stride += 10;
			else
				stride += 6;
		}
		return 0;
#endif
	}
	return -ENODEV;
}

int __devinit radeon_get_tmds_info_atom(struct radeonfb_info *rinfo)
{
	int offset, i, maxfreq;

	offset = BIOS_IN16(rinfo->atom_data_start + 18);
	if (offset == 0)
		return -ENODEV;

	maxfreq = BIOS_IN16(offset + 4);

	for (i = 0; i < 4; i++) {
		rinfo->tmds_pll[i].freq = BIOS_IN16(offset+i*6+6);
		/* This assumes each field in TMDS_PLL has 6 bit as
		 * in R300/R420
		 */
		rinfo->tmds_pll[i].value =
			((BIOS_IN8(offset+i*6+8) & 0x3f) |
			 ((BIOS_IN8(offset+i*6+10) & 0x3f)<<6) |
			 ((BIOS_IN8(offset+i*6+9) & 0xf)<<12) |
			 ((BIOS_IN8(offset+i*6+11) & 0xf)<<16));
		RTRACE("TMDS PLL from BIOS: %ld %x\n",
		       rinfo->tmds_pll[i].freq, rinfo->tmds_pll[i].value);

		if (maxfreq == rinfo->tmds_pll[i].freq) {
		    rinfo->tmds_pll[i].freq = 0xffffffff;
		    break;
		}
	}
	return 0;
}


static const char *conn_type_name[] = {
	"NONE", "VGA", "DVI-I", "DVI-D", "DVI-A", "S-Video",
	"Composite Video", "Internal Panel", "Digital",
	"Unsupported", "Proprietary"
};

static const char *mon_type_name[] = {
	"None", "CRT", "LVDS Flat panel",
	"DVI Flat panel", "Composite TV", "S-Video TV"
};

static void __devinit radeon_fill_conn(struct radeon_connector *conn, int mon_type, int ddc_type, int *found_tmds, int *found_crt) 
{
	conn->mon_type = mon_type;
	conn->ddc_type = ddc_type;

	// XXX what about reversed DAC/TMDS??

	switch(mon_type) {
	case MT_CRT:
		conn->conn_type = conn_vga;
		conn->tmds_type = tmds_unknown;
		conn->dac_type = (*found_crt) ? dac_tvdac: dac_primary;
		if (ddc_type == ddc_none) conn->ddc_type = (*found_crt) ? ddc_crt2 : ddc_vga;
		*found_crt = 1;
		break;
	case MT_DFP:
		conn->conn_type = conn_dvi_i;
		conn->tmds_type = (*found_tmds) ? tmds_external: tmds_internal;
		conn->dac_type = dac_unknown;
		if (ddc_type == ddc_none) conn->ddc_type = ddc_dvi;
		*found_tmds = 1;
		break;
	case MT_LCD:
		conn->conn_type = conn_lvds;
		conn->tmds_type = tmds_unknown;
		conn->dac_type = dac_unknown;
		if (ddc_type == ddc_none) conn->ddc_type = ddc_none; //heh
		break;
	case MT_CTV:
		conn->conn_type = conn_ctv;
		conn->tmds_type = tmds_unknown;
		conn->dac_type = dac_tvdac;
		if (ddc_type == ddc_none) conn->ddc_type = ddc_vga; // XXX ddc_crt2?
		break;
	case MT_STV:
		conn->conn_type = conn_stv;
		conn->tmds_type = tmds_unknown;
		conn->dac_type = dac_tvdac;
		if (ddc_type == ddc_none) conn->ddc_type = ddc_vga; // XXX ddc_crt2?
		break;
	case MT_UNKNOWN:
	case MT_NONE:
		conn->conn_type = conn_none;
		conn->tmds_type = tmds_unknown;
		conn->mon_type = MT_NONE;
		conn->ddc_type = ddc_none;
		conn->dac_type = dac_unknown;
		break;
	default:
		break;
	}
	// leaves conn_digital, conn_unsupported, conn_propritetary
}

/*
 * Get informations about the various connectors on this card. This is
 * the most prone to fail function as various firmwares tend to say
 * crap or not give any info at all. The Open Firmware version is just
 * a table of known cards for now for example. We'll probably need some
 * additional module params to force different settings in case of
 * misdetection here.
 *
 * This doesn _not_ try actual probing of whatever is plugged on those
 * various connectors. This will be done later. We do store whatever
 * probing info the firmware gives us though
 */
void __devinit radeon_get_conn_info(struct radeonfb_info *rinfo, int ignore_conntable)
{
	int i;

	/* Clear table */
	for (i = 0; i < RADEON_MAX_CONNECTORS; i++) {
		rinfo->connectors[i].conn_type	= conn_none;
		rinfo->connectors[i].ddc_type	= ddc_none;
		rinfo->connectors[i].dac_type	= dac_unknown;
		rinfo->connectors[i].tmds_type	= tmds_unknown;
		rinfo->connectors[i].mon_type	= MT_UNKNOWN;
		rinfo->connectors[i].head       = -1;
		rinfo->heads[i] = -1;
	}
	rinfo->num_heads = 0;

	if (ignore_conntable) {	
#if defined(CONFIG_FB_RADEON_I2C)
		struct radeon_connector conn;
		int idx = 0;
		int found_tmds = 0;
		int found_crt = 0;

		// XXX what about reversed DAC/TMDS??

		for (i = 0; i < 4; i++) {
			conn.ddc_type = i;
			if (!radeon_probe_i2c_connector(rinfo, &conn)) {

				radeon_fill_conn(&rinfo->connectors[idx++], conn.mon_type, conn.ddc_type, &found_tmds, &found_crt); 
			}
		}

		/* If we failed to probe something.. */
		if (idx) 
			goto found;
#endif /* CONFIG_FB_RADEON_I2C */
	} else {
		/* Try to obtain infos from firmware */
		if (rinfo->radeon_get_conn_info) {
			if (!rinfo->radeon_get_conn_info(rinfo)) {
				goto found;
			}
		}
	}

	printk(KERN_INFO "radeonfb: No connector infos, using defaults...\n");

	/* Here, we use defaults that are common enough ... we hope
	 * For a mobility chip, we assume LVDS is on primary
	 */
	if (rinfo->is_mobility) {
		rinfo->connectors[0].conn_type	= conn_lvds;
		rinfo->connectors[0].ddc_type	= ddc_dvi;
		rinfo->connectors[0].dac_type	= dac_primary;
		rinfo->connectors[0].tmds_type	= tmds_unknown;
		rinfo->connectors[0].mon_type	= MT_UNKNOWN;

		rinfo->connectors[1].conn_type	= conn_dvi_d;
		rinfo->connectors[1].ddc_type	= ddc_vga;
		rinfo->connectors[1].dac_type	= dac_primary;
		rinfo->connectors[1].tmds_type	= tmds_internal;
		rinfo->connectors[1].mon_type	= MT_UNKNOWN;

		rinfo->connectors[2].conn_type	= conn_stv;
		rinfo->connectors[2].ddc_type	= ddc_none;
		rinfo->connectors[2].dac_type	= dac_tvdac;
		rinfo->connectors[2].tmds_type	= tmds_unknown;
		rinfo->connectors[2].mon_type	= MT_UNKNOWN;
	} else {
		rinfo->connectors[0].conn_type	= conn_dvi_d;
		rinfo->connectors[0].ddc_type	= ddc_dvi;
		rinfo->connectors[0].dac_type	= dac_tvdac;
		rinfo->connectors[0].tmds_type	= tmds_internal;
		rinfo->connectors[0].mon_type	= MT_UNKNOWN;

		rinfo->connectors[1].conn_type	= conn_vga;
		rinfo->connectors[1].ddc_type	= ddc_vga;
		rinfo->connectors[1].dac_type	= dac_primary;
		rinfo->connectors[1].tmds_type	= tmds_unknown;
		rinfo->connectors[1].mon_type	= MT_UNKNOWN;
		
		if (rinfo->has_CRTC2) {
			rinfo->connectors[1].conn_type	= conn_vga;
			rinfo->connectors[1].ddc_type	= ddc_crt2;
			rinfo->connectors[1].dac_type	= dac_tvdac;
			rinfo->connectors[1].tmds_type	= tmds_unknown;
			rinfo->connectors[1].mon_type	= MT_UNKNOWN;
		}
	}

 found:
	/* Now, we do additional fixups */

	/* RS300 has only one DAC, force TV-DAC on VGA port */
	if (rinfo->family == CHIP_FAMILY_RS300) {
		for (i = 0; i < RADEON_MAX_CONNECTORS; i++) {
			if (rinfo->connectors[i].conn_type == conn_vga)
				rinfo->connectors[i].dac_type = dac_tvdac;
			else if (rinfo->connectors[i].dac_type != dac_unknown)
				rinfo->connectors[i].dac_type = dac_primary;
		}
	}

	/* Single head chips all use primary DAC */
	if (!rinfo->has_CRTC2)
		rinfo->connectors[0].dac_type = dac_primary;

	return;
 }

#ifdef CONFIG_PPC_OF
int __devinit radeon_get_conn_info_openfirmware(struct radeonfb_info *rinfo)
{
	int i;
	int not_found = 1;

	for(i = 0 ; < 2 ; i++) {  /* Only two heads for OF! */
		if (!radeon_probe_OF_head(rinfo, i)) found = 0;
	}
	return found;
}
#endif /* CONFIG_PPC_OF */

int __devinit radeon_get_conn_info_atom(struct radeonfb_info *rinfo)
{
	int i, j, offset, valids;
	int ids[RADEON_MAX_CONNECTORS];
	u16 portinfo, tmp0;
	int conn_index = 0;
	int conn_add = 2;
	int idx = 0;
	int ddc_type, dac_type, conn_type, tmds_type, port_id;
	int connector_found = 0;
	
	offset = BIOS_IN16(rinfo->atom_data_start + 22);
	if (offset == 0)
		return -ENODEV;

	/* Again, I slightly modified X.org algorithm. I assign "primary" outputs
	 * to entries 0 and 1, and anything else goes after 2.
	 *
	 * Also, I keep an array of all port IDs matching connectors[] array,
	 * unlike X which limits itself to "crtc"'s
	 */
	for (i = 0; i < RADEON_MAX_CONNECTORS; i++)
		ids[i] = -1;

	valids = BIOS_IN16(offset + 4);
	for (i = 0; i < 8; i++) {
		if (!(valids & (1 << i)))
			continue;
		portinfo = BIOS_IN16(offset + 6 + i*2);

		conn_type = (portinfo >> 4) & 0xf;
		dac_type = (portinfo & 0xf) - 1;
		port_id = (portinfo >> 8) & 0xf;
		ddc_type = ddc_none;

		if ((tmp0 = BIOS_IN16(rinfo->atom_data_start + 24))) {
			switch(BIOS_IN16(tmp0 + 4 + (27 * port_id)) * 4) {
			case GPIO_MONID:
				ddc_type = ddc_monid;
				break;
			case GPIO_DVI_DDC:
				ddc_type = ddc_dvi;
				break;
			case GPIO_VGA_DDC:
				ddc_type = ddc_vga;
				break;
			case GPIO_CRT2_DDC:
				ddc_type = ddc_crt2;
				break;
			default:
				ddc_type = ddc_none;
				break;
			}
		}

		if (i == 3)
			tmds_type = tmds_internal;
		else if (i == 7)
			tmds_type = tmds_external;
		else
			tmds_type = tmds_unknown;

		RTRACE("index %d port %d conn %d dac %d ddc %d tmds %d\n", i, port_id, conn_type, dac_type, ddc_type, tmds_type);
		
		/* Ok, now we have the port ID, look for an existing port
		 * already using this ID
		 */
		for (j = 0; j < RADEON_MAX_CONNECTORS; j++) {
			if (port_id != ids[j])
				continue;
			/* Gotcha, just "update" values */
			if (tmds_type != tmds_unknown)
				rinfo->connectors[j].tmds_type = tmds_type;
			if (rinfo->connectors[j].dac_type == dac_unknown)
				rinfo->connectors[j].dac_type = dac_type;
			if (rinfo->connectors[j].ddc_type == dac_unknown)
				rinfo->connectors[j].ddc_type = dac_type;
			continue;
		}

		conn_index = (ddc_type == ddc_dvi || conn_index == 1) ? 0 : 1;

		/* if the port is a TV port, or both connectors are already
		 * assigned, assign it after further in the table
		 */
		if (conn_type == conn_ctv || conn_type == conn_stv ||
		    (rinfo->connectors[0].conn_type != conn_none &&
		     rinfo->connectors[1].conn_type))
			idx = conn_add++;
		else
			idx = conn_index;

		rinfo->connectors[idx].tmds_type = tmds_type;
		rinfo->connectors[idx].dac_type = dac_type;
		rinfo->connectors[idx].ddc_type = ddc_type;
		rinfo->connectors[idx].conn_type = conn_type;

		/* increment connector_found for primary connectors only */
		if (idx < 2)
			connector_found += (idx + 1);
	}

	if (connector_found == 0)
		return -ENODEV;

	return 0;
}


 * doesn't quite work yet, but it's output is still useful for
 * debugging
 */
int __devinit radeon_get_conn_info_legacy(struct radeonfb_info *rinfo)
{
	int offset, i, entry, tmp;
	int ddc_type, dac_type, conn_type, tmds_type;
	int conn_index = 0;
	int conn_add = 2;
	int idx = 0;

	/* Convert legacy to real connector types */
	const enum radeon_conn_type legacy_conn_to_type[] = {
		conn_none,
		conn_proprietary,
		conn_vga,
		conn_dvi_i,
		conn_dvi_d,
		conn_ctv,
		conn_stv,
		conn_unsupported,
	};

	/* Some laptops only have one connector (VGA) listed in the connector
	 * table, we need to add LVDS in as a non-DDC display.
	 * Note, we can't assume the listed VGA will be filled in PortInfo[0],
	 * when walking through connector table. connector_found has following
	 * meaning:
	 * 0 -- nothing found,
	 * 1 -- only connectors[0] filled,
	 * 2 -- only connectors[1] filled,
	 * 3 -- both are filled.
	 *
	 * Note: I modified X.org algorithm to add additional entries if any
	 * after the second table slot. Those entries do not affect the value
	 * of connector_found. --BenH.
	 */
	int connector_found = 0;

	offset = BIOS_IN16(rinfo->fp_bios_start + 0x50);
	if (offset == 0)
		return -ENODEV;

	for (i = 1; i < 4; i++) {
		entry = offset + i*2;

		/* End of table */
		if (!BIOS_IN8(entry) && i > 1)
			break;

		/* Read table entry, check connector type */
		tmp = BIOS_IN16(entry);
		conn_type = (tmp >> 12) & 0xf;
		if (conn_type == legacy_conn_none)
			continue;
		ddc_type = (tmp >> 8) & 0xf;
		dac_type = (tmp & 0x01) ? dac_tvdac : dac_primary;
		tmds_type = (tmp & 0x10) ? tmds_external : tmds_internal;

		/* same connector */
		if (connector_found > 0) {
			if (rinfo->connectors[conn_index].ddc_type == ddc_type)
				continue;
		}

		/* sanity checks */
		if (ddc_type > ddc_crt2)
			ddc_type = ddc_none;
		if (conn_type > legacy_conn_unsupported)
			conn_type = legacy_conn_unsupported;
		if (conn_type != legacy_conn_dvi_d &&
		    conn_type != legacy_conn_dvi_i &&
		    tmds_type == tmds_internal)
			tmds_type= tmds_unknown;

		/* convert connector type */
		conn_type = legacy_conn_to_type[conn_type];

		/* internal DDC_DVI port will get assigned to connector[0], or
		 * if there is no DDC_DVI (like in some IGPs).
		 */
		conn_index = (ddc_type == ddc_dvi || conn_index == 1) ? 0 : 1;

		/* if the port is a TV port, or both connectors are already
		 * assigned, assign it after further in the table
		 */
		if (conn_type == conn_ctv || conn_type == conn_stv ||
		    (rinfo->connectors[0].conn_type != conn_none &&
		     rinfo->connectors[1].conn_type))
			idx = conn_add++;
		else
			idx = conn_index;

		/* if table full, exit */
		if (idx >= RADEON_MAX_CONNECTORS) {
			printk(KERN_WARNING "radeonfb: Connector table full !\n");
			break;
		}
		rinfo->connectors[idx].conn_type	= conn_type;
		rinfo->connectors[idx].ddc_type		= ddc_type;
		rinfo->connectors[idx].dac_type		= dac_type;
		rinfo->connectors[idx].tmds_type	= tmds_type;

		/* increment connector_found for primary connectors only */
		if (idx < 2)
			connector_found += (idx + 1);
	}

	if (rinfo->is_mobility) {
	    /* For the cases where only one VGA connector is found,
	     * we assume LVDS is not listed in the connector table,
	     * add it in here as the first port.
	     *
	     * TODO: Check what's up with laptops that have a DVI output
	     * and no LVDS entry in the table. I suspect some thinkpads
	     * may play trick with us here... We may want to check the
	     * presence of a panel via LVDS_GEN_CNTL to be sure...
	     */
	    if ((connector_found < 3) &&
		(rinfo->connectors[idx].conn_type == conn_vga)) {
		    if (connector_found == 1) {
			    memcpy(&rinfo->connectors[1],
				   &rinfo->connectors[0],
				   sizeof(struct radeon_connector));
		    }
		    /* Fixme: TV DAC is probably elsewhere ... */
		    rinfo->connectors[0].dac_type = dac_tvdac;
		    rinfo->connectors[0].tmds_type = tmds_unknown;
		    rinfo->connectors[0].ddc_type = ddc_none;
		    rinfo->connectors[0].conn_type = conn_proprietary;

		    printk(KERN_WARNING "radeonfb: LVDS port is not in connector table, added in.\n");
		    if (connector_found == 0)
			    connector_found = 1;
		    else
			    connector_found = 3;
	    }

	    /* Check for LCD DDC info table */
	    if ((offset = BIOS_IN16(rinfo->fp_bios_start + 0x42))) {
		    if ((tmp = BIOS_IN16(offset + 0x15))) {
			    if ((ddc_type = BIOS_IN8(tmp+2) & 0x07)) {
				    rinfo->connectors[0].ddc_type = ddc_type;
				    printk(KERN_WARNING "radeonfb: LCD DDC Info Table found, "
						"forcing primary port to %d\n",
						ddc_type);
			    }
		    }
	    }
	} else if (connector_found == 2) {
		memcpy(&rinfo->connectors[0], &rinfo->connectors[1],
			sizeof (struct radeon_connector));
		rinfo->connectors[1].dac_type = dac_unknown;
		rinfo->connectors[1].tmds_type = tmds_unknown;
		rinfo->connectors[1].ddc_type = ddc_none;
		rinfo->connectors[1].conn_type = conn_none;
		connector_found = 1;
	}

	if (connector_found == 0)
		return -ENODEV;

	/* External TMDS Table, not used now */
	return 0;
}



    return connected ? MT_CRT : MT_NONE;
}

/* Find if the desired connector and monitor are compatible */
static int __devinit radeon_conn_monitor_compatible(int mon_type, int conn_type) 
{
	switch(mon_type) {
	case MT_CRT:
		return ((conn_type == conn_vga) || (conn_type == conn_dvi_a));
	case MT_DFP:
		return ((conn_type == conn_dvi_i) || (conn_type == conn_dvi_d));
	case MT_LCD:
		return (conn_type == conn_lvds);
	case MT_CTV:
		return (conn_type == conn_ctv);
	case MT_STV:
		return (conn_type == conn_stv);
	case MT_UNKNOWN:
	case MT_NONE:
	default:
		return 0;
	}
	// leaves conn_digital, conn_unsupported, conn_propritetary
}

/* Find a suitable connector for this display type */
static int __devinit radeon_find_connector_for_mon(struct radeonfb_info *rinfo, int mon_type)
{
	int i;
	
	if (mon_type <= MT_NONE) return 0;
	
	for (i = 0; i < RADEON_MAX_CONNECTORS ; i++) {
		if (radeon_conn_monitor_compatible(mon_type, rinfo->connectors[i].conn_type) && 
		    (rinfo->connectors[i].mon_type <= MT_NONE)) {
			rinfo->connectors[i].mon_type = mon_type;
			rinfo->connectors[i].head = rinfo->num_heads;
			rinfo->heads[rinfo->num_heads] = i;
			rinfo->num_heads++;
			return 0;
		}
	}

	printk(KERN_INFO "radeonfb: couldn't find a connector for monitor %d\n", mon_type);
	return -1;
}

/*
 * Parse the "monitor_layout" string if any. This code is mostly
 * copied from XFree's radeon driver

		s1[i] = 0;
		s2[0] = 0;
	}

	if (strcmp(s1, "CRT") == 0)
		radeon_find_connector_for_mon(rinfo, MT_CRT);
	else if (strcmp(s1, "TMDS") == 0)
		radeon_find_connector_for_mon(rinfo, MT_DFP);
	else if (strcmp(s1, "LVDS") == 0)
		radeon_find_connector_for_mon(rinfo, MT_LCD);

	if (strcmp(s2, "CRT") == 0)
		radeon_find_connector_for_mon(rinfo, MT_CRT);
	else if (strcmp(s2, "TMDS") == 0)
		radeon_find_connector_for_mon(rinfo, MT_DFP);
	else if (strcmp(s2, "LVDS") == 0)
		radeon_find_connector_for_mon(rinfo, MT_LCD);

	return 1;
}

void __devinit radeon_probe_screens(struct radeonfb_info *rinfo,
				    const char *monitor_layout, int ignore_edid)
{
	int i;
	int ddc_crt2_used = 0;	
#endif
	int tmp, i;

	radeon_parse_connector_info(rinfo);

	if (radeon_parse_monitor_layout(rinfo, monitor_layout)) {


		 * a layout for each card ?
		 */

		RTRACE("Using specified monitor layout: %s\n", monitor_layout);
#ifdef CONFIG_FB_RADEON_I2C
		if (!ignore_edid) {
			int mon_type;

			/* If the DDC detection fails, 
			   we still want to use the user's specified layout! */
			mon_type = PRIMARY_MONITOR(rinfo);

			if (PRIMARY_MONITOR(rinfo) > MT_NONE)
				if (radeon_probe_i2c_connector(rinfo, &PRIMARY_HEAD(rinfo)))
					PRIMARY_MONITOR(rinfo) = mon_type;
			if (SECONDARY_HEAD_PRESENT(rinfo)) {
				mon_type = SECONDARY_MONITOR(rinfo);
				if (SECONDARY_MONITOR(rinfo) > MT_NONE) {
					if (radeon_probe_i2c_connector(rinfo, &SECONDARY_HEAD(rinfo))) {
						rinfo->connectors[rinfo->heads[1]].mon_type = mon_type;
					}
				}
			}
				if (!radeon_probe_i2c_connector(rinfo, ddc_vga, &rinfo->mon2_EDID) &&
				    !ddc_crt2_used)
					radeon_probe_i2c_connector(rinfo, ddc_crt2, &rinfo->mon2_EDID);
		}
#endif /* CONFIG_FB_RADEON_I2C */
		
		/* If the user specified a bogus monitor layout... */
		if (PRIMARY_MONITOR(rinfo) <= MT_NONE) {
			radeon_find_connector_for_mon(rinfo, MT_CRT);
			printk(KERN_INFO "radeonfb: No valid monitor, assuming CRT on first port\n");
				rinfo->mon1_type = MT_CRT;
				printk(KERN_INFO "radeonfb: No valid monitor, assuming CRT on first port\n");
			}
			rinfo->mon2_type = MT_NONE;
			rinfo->mon2_EDID = NULL;
		}
	} else {
		/*

		
		RTRACE("Starting monitor auto detection...\n");

#if DEBUG && defined(CONFIG_FB_RADEON_I2C)
		{
			u8 *EDIDs[4] = { NULL, NULL, NULL, NULL };
			int mon_types[4] = {MT_NONE, MT_NONE, MT_NONE, MT_NONE};
			int i;

			for (i = 0; i < 4; i++)
				mon_types[i] = radeon_probe_i2c_connector(rinfo,
									  i+1, &EDIDs[i]);
		}
#endif /* DEBUG */
		/*
		 * Old single head cards
		 */
		if (!rinfo->has_CRTC2) {
#ifdef CONFIG_PPC_OF
			if (rinfo->mon1_type == MT_NONE)
				rinfo->mon1_type = radeon_probe_OF_head(rinfo, 0,
									&rinfo->mon1_EDID);
#endif /* CONFIG_PPC_OF */
#ifdef CONFIG_FB_RADEON_I2C
			/* Probe each connector */
			for(i = 0 ; i < RADEON_MAX_CONNECTORS ; i++) {
				if (PRIMARY_MONITOR(rinfo) > MT_NONE) break;  /* only one head */
				if (!radeon_probe_i2c_connector(rinfo, &rinfo->connectors[i])) {
					rinfo->heads[rinfo->num_heads] = i;
					rinfo->connectors[i].head = rinfo->num_heads++;
				}
			}
			if (rinfo->mon1_type == MT_NONE)
				rinfo->mon1_type =
					radeon_probe_i2c_connector(rinfo, ddc_crt2,
								   &rinfo->mon1_EDID);	
#endif /* CONFIG_FB_RADEON_I2C */
			if (PRIMARY_MONITOR(rinfo) <= MT_NONE) {
				radeon_find_connector_for_mon(rinfo, MT_CRT);
			}
			goto bail;
		}

		/* Probe heads */
#ifdef CONFIG_FB_RADEON_I2C
		/* Probe each connector in turn. */
		for(i = 0 ; i < RADEON_MAX_CONNECTORS ; i++) {
			if (rinfo->connectors[i].mon_type > MT_NONE) continue; /* Don't probe "detected" stuff again */
			if (!radeon_probe_i2c_connector(rinfo, &rinfo->connectors[i])) {
				rinfo->heads[rinfo->num_heads] = i;
				rinfo->connectors[i].head = rinfo->num_heads++;
				if (!BIOS_IN8(tmp + i*2) && i > 1)
					break;
				tmp0 = BIOS_IN16(tmp + i*2);
				if ((!(tmp0 & 0x01)) && (((tmp0 >> 8) & 0x0f) == ddc_dvi)) {
					rinfo->reversed_DAC = 1;
					printk(KERN_INFO "radeonfb: Reversed DACs detected\n");
				}
				if ((((tmp0 >> 8) & 0x0f) == ddc_dvi) && ((tmp0 >> 4) & 0x01)) {
					rinfo->reversed_TMDS = 1;
					printk(KERN_INFO "radeonfb: Reversed TMDS detected\n");
				}
			}
		}
	
#endif /* CONFIG_FB_RADEON_I2C */

		/* Mobility chips usually have LCDs... */
		if ((PRIMARY_MONITOR(rinfo) <= MT_NONE) && 
		    rinfo->is_mobility &&
		    ((rinfo->bios_seg && (INREG(BIOS_4_SCRATCH) & 4)) ||
		     (INREG(LVDS_GEN_CNTL) & (LVDS_EN|LVDS_ON)))) {
			printk(KERN_INFO "radeonfb: Non-DDC laptop panel detected\n");
			radeon_find_connector_for_mon(rinfo, MT_LCD);
			if (rinfo->radeon_get_lvds_info) {
				rinfo->radeon_get_lvds_info(rinfo);
			}
			rinfo->mon1_type = radeon_probe_i2c_connector(rinfo, ddc_dvi,
								      &rinfo->mon1_EDID);
		if (rinfo->mon1_type == MT_NONE) {
			rinfo->mon1_type = radeon_probe_i2c_connector(rinfo, ddc_crt2,
								      &rinfo->mon1_EDID);
			if (rinfo->mon1_type != MT_NONE)
				ddc_crt2_used = 1;
		}

		/* Probe for monitors on the primary and secondary crtc heads */
		if (PRIMARY_MONITOR(rinfo) <= MT_NONE) {
			radeon_find_connector_for_mon(rinfo, radeon_crt_is_connected(rinfo, 1));
			rinfo->mon1_type = MT_LCD;
			printk("Non-DDC laptop panel detected\n");
		}
		if (rinfo->mon1_type == MT_NONE)
			rinfo->mon1_type = radeon_crt_is_connected(rinfo, rinfo->reversed_DAC);

		/* If we still haven't found anything, just force it to be on the CRT.. */
		if (PRIMARY_MONITOR(rinfo) <= MT_NONE) {
			radeon_find_connector_for_mon(rinfo, MT_CRT);
		}
		if (rinfo->mon2_type == MT_NONE)
			rinfo->mon2_type = radeon_probe_OF_head(rinfo, 1,
								&rinfo->mon2_EDID);
#endif /* CONFIG_PPC_OF */
#ifdef CONFIG_FB_RADEON_I2C
		if (rinfo->mon2_type == MT_NONE)
			rinfo->mon2_type = radeon_probe_i2c_connector(rinfo, ddc_vga,
								      &rinfo->mon2_EDID);
		if (rinfo->mon2_type == MT_NONE && !ddc_crt2_used)
			rinfo->mon2_type = radeon_probe_i2c_connector(rinfo, ddc_crt2,
								      &rinfo->mon2_EDID);
#endif /* CONFIG_FB_RADEON_I2C */
		if (rinfo->mon2_type == MT_NONE)
			rinfo->mon2_type = radeon_crt_is_connected(rinfo, !rinfo->reversed_DAC);

		/* Always keep internal TMDS as primary head */
		if (SECONDARY_HEAD_PRESENT(rinfo) && (SECONDARY_HEAD(rinfo).tmds_type == tmds_internal) && (SECONDARY_MONITOR(rinfo) == MT_DFP)) {
			int head = rinfo->heads[0];
			rinfo->heads[0] = rinfo->heads[1];
			rinfo->heads[1] = head;
		if (rinfo->mon1_type == MT_NONE) {
			if (rinfo->mon2_type != MT_NONE) {
				rinfo->mon1_type = rinfo->mon2_type;
				rinfo->mon1_EDID = rinfo->mon2_EDID;
			} else
				rinfo->mon1_type = MT_CRT;
			rinfo->mon2_type = MT_NONE;
			rinfo->mon2_EDID = NULL;
		}
	}
bail:

	/* Dump out the heads we've found so far */
	for (i = 0; i < RADEON_MAX_CONNECTORS; i++) {
		
		if (rinfo->connectors[i].conn_type == conn_none)
			continue;
		printk(KERN_INFO " * Connector %d is %s. Head %d, Monitor: %s ", i+1,
		       conn_type_name[rinfo->connectors[i].conn_type],
		       rinfo->connectors[i].head,
		       rinfo->connectors[i].mon_type == MT_UNKNOWN  ?
		         "Not Probed Yet" : 
		         mon_type_name[rinfo->connectors[i].mon_type]);
		if (rinfo->connectors[i].edid) {
			printk("(EDID probed)\n");
		} else {
			printk("\n");
		}
		printk(KERN_INFO "   ddc port: %d, dac: %d, tmds: %d\n",
		       rinfo->connectors[i].ddc_type,
		       rinfo->connectors[i].dac_type,
		       rinfo->connectors[i].tmds_type);
	}
	if (ignore_edid) {
		kfree(rinfo->mon1_EDID);
		rinfo->mon1_EDID = NULL;
		kfree(rinfo->mon2_EDID);
		rinfo->mon2_EDID = NULL;
	}

 bail:
	printk(KERN_INFO "radeonfb: Monitor 1 type %s found\n",
	       radeon_get_mon_name(rinfo->mon1_type));
	if (rinfo->mon1_EDID)
		printk(KERN_INFO "radeonfb: EDID probed\n");
	if (!rinfo->has_CRTC2)
		return;
	printk(KERN_INFO "radeonfb: Monitor 2 type %s found\n",
	       radeon_get_mon_name(rinfo->mon2_type));
	if (rinfo->mon2_EDID)
		printk(KERN_INFO "radeonfb: EDID probed\n");
}


/*
 * This functions applyes any arch/model/machine specific fixups
 * to the panel info. It may eventually alter EDID block as
 * well or whatever is specific to a given model and not probed
 * properly by the default code
 */
static void radeon_fixup_panel_info(struct radeonfb_info *rinfo)
{
#ifdef CONFIG_PPC_OF
int __devinit radeon_get_lvds_info_openfirmware(struct radeonfb_info *rinfo)
{

	/*
	 * LCD Flat panels should use fixed dividers, we enfore that on
	 * PPC only for now...
	 */
	If (!rinfo->panel_info.use_bios_dividers && (PRIMARY_MONITOR(rinfo) == MT_LCD) &&
	    rinfo->is_mobility) {
		int ppll_div_sel;
		u32 ppll_divn;
		ppll_div_sel = INREG8(CLOCK_CNTL_INDEX + 1) & 0x3;

		rinfo->panel_info.post_divider = (ppll_divn >> 16) & 0x7;
		rinfo->panel_info.use_bios_dividers = 1;

		printk(KERN_INFO "Using Firmware dividers 0x%08x "
		       "from PPLL %d\n",
		       rinfo->panel_info.fbk_divider |
		       (rinfo->panel_info.post_divider << 16),
		       ppll_div_sel);
		return 0;
	}
	return 1;
}
#endif /* CONFIG_PPC_OF */

/*
 * Fill up panel infos from a mode definition, either returned by the EDID

	info->var = radeonfb_default_var;
	INIT_LIST_HEAD(&info->modelist);

	/* If we're an LCD and don't have a valid setup... */
	if ((PRIMARY_MONITOR(rinfo) == MT_LCD) &&
	    !rinfo->panel_info.valid && 
	    rinfo->radeon_get_lvds_info) {
		rinfo->radeon_get_lvds_info(rinfo);
	}

#if 0
	/* If we're a mobility and still haven't detected a screen..? */
	if ((PRIMARY_MONITOR(rinfo) <= MT_NONE) &&
	    rinfo->is_mobility && 
	    rinfo->radeon_get_lvds_info) {
		if (! rinfo->radeon_get_lvds_info(rinfo)) {
			radeon_find_connector_for_mon(rinfo, MT_LCD);
		}
	}
#endif

	/*
	 * Parse EDID detailed timings and deduce panel infos if any. Right now
	 * we only deal with first entry returned by parse_EDID, we may do better
	 * some day...
	 */
	if (!rinfo->panel_info.use_bios_dividers && 
	    (PRIMARY_MONITOR(rinfo) != MT_CRT) &&
	    PRIMARY_HEAD(rinfo).edid) {
		struct fb_var_screeninfo var;
		RTRACE("Parsing EDID data for panel info\n");
		if (fb_parse_edid(PRIMARY_HEAD(rinfo).edid, &var) == 0) {
			if (var.xres >= rinfo->panel_info.xres &&
			    var.yres >= rinfo->panel_info.yres)
				radeon_var_to_panel_info(rinfo, &var);

	}

	/*
	 * Do any additional platform/arch fixups to the panel infos
	 */
	radeon_fixup_panel_info(rinfo);

	/*
	 * If we have some valid panel infos, we setup the default mode based on
	 * those
	 */
	if ((PRIMARY_MONITOR(rinfo) != MT_CRT) && rinfo->panel_info.valid) {
		struct fb_var_screeninfo *var = &info->var;

		RTRACE("Setting up default mode based on panel info\n");

	/*
	 * Now build modedb from EDID
	 */
	if (PRIMARY_HEAD(rinfo).edid) {
		fb_edid_to_monspecs(PRIMARY_HEAD(rinfo).edid, &info->monspecs);
		fb_videomode_to_modelist(info->monspecs.modedb,
					 info->monspecs.modedb_len,
					 &info->modelist);
		PRIMARY_HEAD(rinfo).modedb = info->monspecs.modedb;
		PRIMARY_HEAD(rinfo).modedb_size = info->monspecs.modedb_len;
	}

	

	 * we try to read it from card), we try to pick a default mode
	 * and create some panel infos. Whatever...
	 */
	if ((PRIMARY_MONITOR(rinfo) != MT_CRT) && !rinfo->panel_info.valid) {
		struct fb_videomode	*modedb;
		int			dbsize;
		char			modename[32];

		}
		if (rinfo->panel_info.xres == 0 || rinfo->panel_info.yres == 0) {
			printk(KERN_WARNING "radeonfb: Can't find panel size, going back to CRT\n");
			radeon_find_connector_for_mon(rinfo, MT_CRT);
			goto pickup_default;
		}
		printk(KERN_WARNING "radeonfb: Assuming panel size %dx%d\n",
		       rinfo->panel_info.xres, rinfo->panel_info.yres);
		modedb = PRIMARY_HEAD(rinfo).modedb;
		dbsize = PRIMARY_HEAD(rinfo).modedb_size;
		snprintf(modename, 31, "%dx%d", rinfo->panel_info.xres, rinfo->panel_info.yres);
		if (fb_find_mode(&info->var, info, modename,
				 modedb, dbsize, NULL, 8) == 0) {
			printk(KERN_WARNING "radeonfb: Can't find mode for panel size, going back to CRT\n");
			radeon_find_connector_for_mon(rinfo, MT_CRT);
			goto pickup_default;
		}
		has_default_mode = 1;
		radeon_find_connector_for_mon(rinfo, MT_LCD);
		radeon_var_to_panel_info(rinfo, &info->var);
	}


	memcpy(dest, src, sizeof(struct fb_var_screeninfo));

	/* Check if we have a modedb built from EDID */
	if (PRIMARY_HEAD(rinfo).modedb) {
		db = PRIMARY_HEAD(rinfo).modedb;
		dbsize = PRIMARY_HEAD(rinfo).modedb_size;
		native_db = 1;
	}

	/* Check if we have a scaler allowing any fancy mode */
	has_rmx = (PRIMARY_MONITOR(rinfo) == MT_LCD) || (PRIMARY_MONITOR(rinfo) == MT_DFP);

	/* If we have a scaler and are passed FB_ACTIVATE_TEST or
	 * FB_ACTIVATE_NOW, just do basic checking and return if the

		 * 640x480-60, but I assume userland knows what it's doing here
		 * (though I may be proven wrong...)
		 */
		if (has_rmx == 0 && PRIMARY_HEAD(rinfo).modedb)
			if (fb_validate_mode((struct fb_var_screeninfo *)src, rinfo->info))
				return -EINVAL;
		return 0;

Lines 26-31 Link Here

(-)aty-2.6.18/radeonfb.h (-39 / +124 lines)
26	* Most of the definitions here are adapted right from XFree86 *	26	* Most of the definitions here are adapted right from XFree86 *
27	***************************************************************/	27	***************************************************************/
28		28
		29	/* Sorry, we have to limit video ram to 128M */
		30	#define MAX_VRAM (12810241024)
29		31
30	/*	32	/*
31	* Chip families. Must fit in the low 16 bits of a long word	33	* Chip families. Must fit in the low 16 bits of a long word
Lines 47-53 Link Here
47	CHIP_FAMILY_R350,	49	CHIP_FAMILY_R350,
48	CHIP_FAMILY_RV350,	50	CHIP_FAMILY_RV350,
49	CHIP_FAMILY_RV380, /* RV370/RV380/M22/M24 */	51	CHIP_FAMILY_RV380, /* RV370/RV380/M22/M24 */
50	CHIP_FAMILY_R420, /* R420/R423/M18 */	52	CHIP_FAMILY_RV410, /* RV410/M26 */
		53	CHIP_FAMILY_R420, /* R420/R423/R480/M18 */
51	CHIP_FAMILY_LAST,	54	CHIP_FAMILY_LAST,
52	};	55	};
53		56
Lines 64-69 Link Here
64	((rinfo)->family == CHIP_FAMILY_RV350) \|\| \	67	((rinfo)->family == CHIP_FAMILY_RV350) \|\| \
65	((rinfo)->family == CHIP_FAMILY_R350) \|\| \	68	((rinfo)->family == CHIP_FAMILY_R350) \|\| \
66	((rinfo)->family == CHIP_FAMILY_RV380) \|\| \	69	((rinfo)->family == CHIP_FAMILY_RV380) \|\| \
		70	((rinfo)->family == CHIP_FAMILY_RV410) \|\| \
67	((rinfo)->family == CHIP_FAMILY_R420))	71	((rinfo)->family == CHIP_FAMILY_R420))
68		72
69	/*	73	/*
Lines 86-96 Link Here
86	CHIP_ERRATA_PLL_DELAY = 0x00000004,	90	CHIP_ERRATA_PLL_DELAY = 0x00000004,
87	};	91	};
88		92
		93	/*
		94	* DDC i2c ports
		95	*/
		96	enum radeon_ddc_type {
		97	ddc_none = -1,
		98	ddc_monid = 0,
		99	ddc_dvi,
		100	ddc_vga,
		101	ddc_crt2,
		102	};
		103
		104	/*
		105	* Connector types
		106	*/
		107	enum radeon_legacy_conn_type {
		108	legacy_conn_none = 0,
		109	legacy_conn_proprietary,
		110	legacy_conn_crt,
		111	legacy_conn_dvi_i,
		112	legacy_conn_dvi_d,
		113	legacy_conn_ctv,
		114	legacy_conn_stv,
		115	legacy_conn_unsupported,
		116	};
		117
		118	enum radeon_conn_type {
		119	conn_none = 0,
		120	conn_vga,
		121	conn_dvi_i,
		122	conn_dvi_d,
		123	conn_dvi_a,
		124	conn_stv,
		125	conn_ctv,
		126	conn_lvds,
		127	conn_digital,
		128	conn_unsupported,
		129	conn_proprietary,
		130	};
89		131
90	/*	132	/*
91	* Monitor types	133	* Monitor types
92	*/	134	*/
93	enum radeon_montype {	135	enum radeon_mon_type {
		136	MT_UNKNOWN = -1,
94	MT_NONE = 0,	137	MT_NONE = 0,
95	MT_CRT, /* CRT */	138	MT_CRT, /* CRT */
96	MT_LCD, /* LCD */	139	MT_LCD, /* LCD */
Lines 100-126 Link Here
100	};	143	};
101		144
102	/*	145	/*
103	* DDC i2c ports	146	* DAC types
104	*/	147	*/
105	enum ddc_type {	148	enum radeon_dac_type {
106	ddc_none,	149	dac_unknown = -1,
107	ddc_monid,	150	dac_primary = 0,
108	ddc_dvi,	151	dac_tvdac = 1,
109	ddc_vga,
110	ddc_crt2,
111	};	152	};
112		153
113	/*	154	/*
114	* Connector types	155	* TMDS types
115	*/	156	*/
116	enum conn_type {	157	enum radeon_tmds_type {
117	conn_none,	158	tmds_unknown = -1,
118	conn_proprietary,	159	tmds_internal = 0,
119	conn_crt,	160	tmds_external = 1,
120	conn_DVI_I,
121	conn_DVI_D,
122	};	161	};
123		162
		163	/*
		164	* Each connector gets this structure associated with it,
		165	* containing infos about the connector wiring and about
		166	* whatever has been detected on it
		167	*/
		168	struct radeon_connector {
		169	enum radeon_conn_type conn_type;
		170	enum radeon_ddc_type ddc_type;
		171	enum radeon_dac_type dac_type;
		172	enum radeon_tmds_type tmds_type;
		173	enum radeon_mon_type mon_type;
		174	u8 *edid;
		175	struct fb_videomode *modedb;
		176	unsigned int modedb_size;
		177
		178	int head;
		179	};
		180
		181	/*
		182	* Currently, the driver deals with at most 4 connectors
		183	*/
		184	#define RADEON_MAX_CONNECTORS 4
124		185
125	/*	186	/*
126	* PLL infos	187	* PLL infos
Lines 128-138 Link Here
128	struct pll_info {	189	struct pll_info {
129	int ppll_max;	190	int ppll_max;
130	int ppll_min;	191	int ppll_min;
131	int sclk, mclk;	192	int sclk;
		193	int mclk;
132	int ref_div;	194	int ref_div;
133	int ref_clk;	195	int ref_clk;
134	};	196	};
135		197
		198	/*
		199	* TMDS PLL infos
		200	*/
		201	struct radeon_tmds_pll_info {
		202	long freq;
		203	u32 value;
		204	};
136		205
137	/*	206	/*
138	* This structure contains the various registers manipulated by this	207	* This structure contains the various registers manipulated by this
Lines 299-304 Link Here
299	void __iomem *bios_seg;	368	void __iomem *bios_seg;
300	int fp_bios_start;	369	int fp_bios_start;
301		370
		371	int is_atom_bios;
		372	int atom_data_start;
		373
		374	/* BIOS Functions */
		375	int (radeon_get_pll_info)(struct radeonfb_info rinfo);
		376	int (radeon_get_lvds_info)(struct radeonfb_info rinfo);
		377	int (radeon_get_conn_info)(struct radeonfb_info rinfo);
		378	int (radeon_get_tmds_info)(struct radeonfb_info rinfo);
		379
		380	/* Connector infos */
		381	struct radeon_connector connectors[RADEON_MAX_CONNECTORS];
		382	int heads[RADEON_MAX_CONNECTORS]; // index into connectors.
		383	int num_heads; // number of heads.
		384
302	u32 pseudo_palette[17];	385	u32 pseudo_palette[17];
303	struct { u8 red, green, blue, pad; }	386	struct { u8 red, green, blue, pad; }
304	palette[256];	387	palette[256];
Lines 317-331 Link Here
317	int has_CRTC2;	400	int has_CRTC2;
318	int is_mobility;	401	int is_mobility;
319	int is_IGP;	402	int is_IGP;
320	int reversed_DAC;
321	int reversed_TMDS;
322	struct panel_info panel_info;	403	struct panel_info panel_info;
323	int mon1_type;	404	struct radeon_tmds_pll_info tmds_pll[4];
324	u8 *mon1_EDID;
325	struct fb_videomode *mon1_modedb;
326	int mon1_dbsize;
327	int mon2_type;
328	u8 *mon2_EDID;
329		405
330	u32 dp_gui_master_cntl;	406	u32 dp_gui_master_cntl;
331		407
Lines 357-380 Link Here
357	};	433	};
358		434
359		435
360	#define PRIMARY_MONITOR(rinfo) (rinfo->mon1_type)	436	#define PRIMARY_HEAD(rinfo) (rinfo->connectors[rinfo->heads[0]])
		437	#define SECONDARY_HEAD(rinfo) (rinfo->connectors[rinfo->heads[1]])
361		438
		439	#define SECONDARY_HEAD_PRESENT(rinfo) (rinfo->heads[1] != -1)
		440
		441	#define PRIMARY_MONITOR(rinfo) (rinfo->connectors[rinfo->heads[0]].mon_type)
		442	#define SECONDARY_MONITOR(rinfo) ((SECONDARY_HEAD_PRESENT(rinfo) ? (rinfo->connectors[rinfo->heads[1]].mon_type) : MT_NONE))
362		443
363	/*	444	/*
364	* Debugging stuffs	445	* Debugging stuffs
365	*/	446	*/
366	#ifdef CONFIG_FB_RADEON_DEBUG	447	extern int radeonfb_debug;
367	#define DEBUG 1	448	#define RTRACE if(radeonfb_debug) printk
368	#else
369	#define DEBUG 0
370	#endif
371
372	#if DEBUG
373	#define RTRACE printk
374	#else
375	#define RTRACE if(0) printk
376	#endif
377
378		449
379	/*	450	/*
380	* IO macros	451	* IO macros
Lines 597-603 Link Here
597	/* I2C Functions */	668	/* I2C Functions */
598	extern void radeon_create_i2c_busses(struct radeonfb_info *rinfo);	669	extern void radeon_create_i2c_busses(struct radeonfb_info *rinfo);
599	extern void radeon_delete_i2c_busses(struct radeonfb_info *rinfo);	670	extern void radeon_delete_i2c_busses(struct radeonfb_info *rinfo);
600	extern int radeon_probe_i2c_connector(struct radeonfb_info rinfo, int conn, u8 *out_edid);	671	extern int radeon_probe_i2c_connector(struct radeonfb_info rinfo, struct radeon_connector conn);
601		672
602	/* PM Functions */	673	/* PM Functions */
603	extern int radeonfb_pci_suspend(struct pci_dev *pdev, pm_message_t state);	674	extern int radeonfb_pci_suspend(struct pci_dev *pdev, pm_message_t state);
Lines 635-638 Link Here
635	static inline void radeonfb_bl_exit(struct radeonfb_info *rinfo) {}	706	static inline void radeonfb_bl_exit(struct radeonfb_info *rinfo) {}
636	#endif	707	#endif
637		708
		709	/* Bios functions. Fix this. */
		710	extern void __devinit radeon_get_conn_info(struct radeonfb_info *rinfo, int ignore_conntable);
		711	extern void __devinit radeon_get_tmds_info(struct radeonfb_info *rinfo);
		712
		713	extern int __devinit radeon_get_lvds_info_atom(struct radeonfb_info *rinfo);
		714	extern int __devinit radeon_get_lvds_info_legacy(struct radeonfb_info *rinfo);
		715	extern int __devinit radeon_get_conn_info_atom(struct radeonfb_info *rinfo);
		716	extern int __devinit radeon_get_conn_info_legacy(struct radeonfb_info *rinfo);
		717	extern int __devinit radeon_get_tmds_info_legacy(struct radeonfb_info *rinfo);
		718	extern int __devinit radeon_get_tmds_info_atom(struct radeonfb_info *rinfo);
		719	#ifdef CONFIG_PPC_OF
		720	extern int __devinit radeon_get_lvds_info_openfirmware(struct radeonfb_info *rinfo);
		721	extern int __devinit radeon_get_conn_info_openfirmware(struct radeonfb_info *rinfo);
		722	#endif
638	#endif /* __RADEONFB_H__ */	723	#endif /* __RADEONFB_H__ */

Return to bug 162628

Lines 203-211 Link Here

(-)aty-2.6.18/radeon_accel.c (-12 / +7 lines)
203	host_path_cntl = INREG(HOST_PATH_CNTL);	203	host_path_cntl = INREG(HOST_PATH_CNTL);
204	rbbm_soft_reset = INREG(RBBM_SOFT_RESET);	204	rbbm_soft_reset = INREG(RBBM_SOFT_RESET);
205		205
206	if (rinfo->family == CHIP_FAMILY_R300 \|\|	206	if (IS_R300_VARIANT(rinfo)) {
207	rinfo->family == CHIP_FAMILY_R350 \|\|
208	rinfo->family == CHIP_FAMILY_RV350) {
209	u32 tmp;	207	u32 tmp;
210		208
211	OUTREG(RBBM_SOFT_RESET, (rbbm_soft_reset \|	209	OUTREG(RBBM_SOFT_RESET, (rbbm_soft_reset \|
Lines 241-249 Link Here
241	INREG(HOST_PATH_CNTL);	239	INREG(HOST_PATH_CNTL);
242	OUTREG(HOST_PATH_CNTL, host_path_cntl);	240	OUTREG(HOST_PATH_CNTL, host_path_cntl);
243		241
244	if (rinfo->family != CHIP_FAMILY_R300 \|\|	242	if (IS_R300_VARIANT(rinfo))
245	rinfo->family != CHIP_FAMILY_R350 \|\|
246	rinfo->family != CHIP_FAMILY_RV350)
247	OUTREG(RBBM_SOFT_RESET, rbbm_soft_reset);	243	OUTREG(RBBM_SOFT_RESET, rbbm_soft_reset);
248		244
249	OUTREG(CLOCK_CNTL_INDEX, clock_cntl_index);	245	OUTREG(CLOCK_CNTL_INDEX, clock_cntl_index);
Lines 254-269 Link Here
254	{	250	{
255	unsigned long temp;	251	unsigned long temp;
256		252
257	/* disable 3D engine */
258	OUTREG(RB3D_CNTL, 0);
259
260	radeonfb_engine_reset(rinfo);	253	radeonfb_engine_reset(rinfo);
261		254
262	radeon_fifo_wait (1);	255	radeon_fifo_wait (1);
263	if ((rinfo->family != CHIP_FAMILY_R300) &&	256	if (IS_R300_VARIANT(rinfo)) {
264	(rinfo->family != CHIP_FAMILY_R350) &&	257	temp = INREG(RB2D_DSTCACHE_MODE);
265	(rinfo->family != CHIP_FAMILY_RV350))	258	OUTREG(RB2D_DSTCACHE_MODE, temp \| (1<<17)); /* FIXME */
		259	} else {
266	OUTREG(RB2D_DSTCACHE_MODE, 0);	260	OUTREG(RB2D_DSTCACHE_MODE, 0);
		261	}
267		262
268	radeon_fifo_wait (3);	263	radeon_fifo_wait (3);
269	/* We re-read MC_FB_LOCATION from card as it can have been	264	/* We re-read MC_FB_LOCATION from card as it can have been

Lines 169-181 Link Here

(-)aty-2.6.18/radeon_i2c.c (-20 / +47 lines)
169	return NULL;	169	return NULL;
170	}	170	}
171		171
172		172	/* Returns 1 if probe unsuccessful. */
173	int radeon_probe_i2c_connector(struct radeonfb_info rinfo, int conn, u8 *out_edid)	173	int radeon_probe_i2c_connector(struct radeonfb_info rinfo, struct radeon_connector conn)
174	{	174	{
175	u32 reg = rinfo->i2c[conn-1].ddc_reg;	175	u32 reg;
176	u8 *edid = NULL;	176	u8 *edid = NULL;
		177	int mon_type = MT_NONE;
		178
177	int i, j;	179	int i, j;
178		180
		181	if (!conn)
		182	return 1;
		183
		184	if (rinfo->is_mobility && (conn->ddc_type == ddc_none) &&
		185	(INREG(LVDS_GEN_CNTL) & (LVDS_ON\|LVDS_EN))) {
		186	RTRACE("radeonfb: I2C (port %d) ... found LVDS panel\n", conn->ddc_type);
		187	mon_type = MT_LCD;
		188	goto done;
		189	}
		190
		191	reg = rinfo->i2c[conn->ddc_type].ddc_reg;
		192
179	OUTREG(reg, INREG(reg) &	193	OUTREG(reg, INREG(reg) &
180	~(VGA_DDC_DATA_OUTPUT \| VGA_DDC_CLK_OUTPUT));	194	~(VGA_DDC_DATA_OUTPUT \| VGA_DDC_CLK_OUTPUT));
181		195
Lines 211-217 Link Here
211	msleep(15);	225	msleep(15);
212		226
213	/* Do the real work */	227	/* Do the real work */
214	edid = radeon_do_probe_i2c_edid(&rinfo->i2c[conn-1]);	228	edid = radeon_do_probe_i2c_edid(&rinfo->i2c[conn->ddc_type]);
215		229
216	OUTREG(reg, INREG(reg) \|	230	OUTREG(reg, INREG(reg) \|
217	(VGA_DDC_DATA_OUT_EN \| VGA_DDC_CLK_OUT_EN));	231	(VGA_DDC_DATA_OUT_EN \| VGA_DDC_CLK_OUT_EN));
Lines 235-264 Link Here
235	if (edid)	249	if (edid)
236	break;	250	break;
237	}	251	}
		252
238	/* Release the DDC lines when done or the Apple Cinema HD display	253	/* Release the DDC lines when done or the Apple Cinema HD display
239	* will switch off	254	* will switch off
240	*/	255	*/
241	OUTREG(reg, INREG(reg) & ~(VGA_DDC_CLK_OUT_EN \| VGA_DDC_DATA_OUT_EN));	256	OUTREG(reg, INREG(reg) & ~(VGA_DDC_CLK_OUT_EN \| VGA_DDC_DATA_OUT_EN));
242	(void)INREG(reg);	257	(void)INREG(reg);
243		258
244	if (out_edid)
245	*out_edid = edid;
246	if (!edid) {	259	if (!edid) {
247	RTRACE("radeonfb: I2C (port %d) ... not found\n", conn);	260	// what about the special case where we are a DFP/LVDS, but have a DDC connection..
248	return MT_NONE;	261	// but no EDID? We should fall back to MT_LCD...? XXXX
		262	RTRACE("radeonfb: I2C (port %d) ... not found\n", conn->ddc_type);
		263	mon_type = MT_NONE;
		264	goto done;
249	}	265	}
250	if (edid[0x14] & 0x80) {	266
251	/* Fix detection using BIOS tables */	267	if ((edid[EDID_STRUCT_DISPLAY] & 0x80) && (conn->ddc_type == ddc_dvi)) {
252	if (rinfo->is_mobility /&& conn == ddc_dvi/ &&	268	RTRACE("radeonfb: I2C (port %d) ... found TMDS panel\n", conn->ddc_type);
253	(INREG(LVDS_GEN_CNTL) & LVDS_ON)) {	269	mon_type = MT_DFP;
254	RTRACE("radeonfb: I2C (port %d) ... found LVDS panel\n", conn);	270	goto done;
255	return MT_LCD;	271	}
256	} else {	272
257	RTRACE("radeonfb: I2C (port %d) ... found TMDS panel\n", conn);	273	if (rinfo->is_mobility &&
258	return MT_DFP;	274	(conn->conn_type == conn_lvds) &&
259	}	275	(edid[EDID_STRUCT_DISPLAY] & 0x80) && // ie EDID valid and marks us as a DFP...
		276	(INREG(LVDS_GEN_CNTL) & (LVDS_ON\|LVDS_EN))) {
		277	RTRACE("radeonfb: I2C (port %d) ... found LVDS panel\n", conn->ddc_type);
		278	mon_type = MT_LCD;
		279	goto done;
260	}	280	}
261	RTRACE("radeonfb: I2C (port %d) ... found CRT display\n", conn);	281
262	return MT_CRT;	282	RTRACE("radeonfb: I2C (port %d) ... found CRT display\n", conn->ddc_type);
		283	mon_type = MT_CRT;
		284
		285	done:
		286	conn->edid = edid;
		287	conn->mon_type = mon_type;
		288
		289	return (mon_type == MT_NONE);
263	}	290	}
264		291