Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 89c78134 authored by Alan Cox's avatar Alan Cox Committed by Dave Airlie
Browse files

gma500: Add Poulsbo support 



This provides the specific code for Poulsbo, some of which is also used for
the later chipsets. We support the GTT, the 2D engine (for console), and
the display setup/management. We do not support 3D or the video overlays.

In theory enough public info is available to do the video overlay work
but that represents a large task.

Framebuffer X will run nicely with this but do *NOT* use the VESA X
server at the same time as KMS. With a Dell mini 10 things like Xfce4 are
nice and usable even when compositing as the CPU has a good path to the
memory.

Signed-off-by: default avatarAlan Cox <alan@linux.intel.com>
Signed-off-by: default avatarDave Airlie <airlied@redhat.com>
parent 5c49fd3a

drivers/gpu/drm/gma500/psb_device.c

0 → 100644
+353 −0
Original line number Diff line number Diff line 
/**************************************************************************

 * Copyright (c) 2011, Intel Corporation.

 * All Rights Reserved.

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms and conditions of the GNU General Public License,

 * version 2, as published by the Free Software Foundation.

 *

 * This program is distributed in the hope it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for

 * more details.

 *

 * You should have received a copy of the GNU General Public License along with

 * this program; if not, write to the Free Software Foundation, Inc.,

 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.

 *

 **************************************************************************/



#include <linux/backlight.h>

#include <drm/drmP.h>

#include <drm/drm.h>

#include "psb_drm.h"

#include "psb_drv.h"

#include "psb_reg.h"

#include "psb_intel_reg.h"

#include "intel_bios.h"





static int psb_output_init(struct drm_device *dev)

{

	struct drm_psb_private *dev_priv = dev->dev_private;

	psb_intel_lvds_init(dev, &dev_priv->mode_dev);

	psb_intel_sdvo_init(dev, SDVOB);

	return 0;

}



#ifdef CONFIG_BACKLIGHT_CLASS_DEVICE



/*

 *	Poulsbo Backlight Interfaces

 */



#define BLC_PWM_PRECISION_FACTOR 100	/* 10000000 */

#define BLC_PWM_FREQ_CALC_CONSTANT 32

#define MHz 1000000



#define PSB_BLC_PWM_PRECISION_FACTOR    10

#define PSB_BLC_MAX_PWM_REG_FREQ        0xFFFE

#define PSB_BLC_MIN_PWM_REG_FREQ        0x2



#define PSB_BACKLIGHT_PWM_POLARITY_BIT_CLEAR (0xFFFE)

#define PSB_BACKLIGHT_PWM_CTL_SHIFT	(16)



static int psb_brightness;

static struct backlight_device *psb_backlight_device;



static int psb_get_brightness(struct backlight_device *bd)

{

	/* return locally cached var instead of HW read (due to DPST etc.) */

	/* FIXME: ideally return actual value in case firmware fiddled with

	   it */

	return psb_brightness;

}





static int psb_backlight_setup(struct drm_device *dev)

{

	struct drm_psb_private *dev_priv = dev->dev_private;

	unsigned long core_clock;

	/* u32 bl_max_freq; */

	/* unsigned long value; */

	u16 bl_max_freq;

	uint32_t value;

	uint32_t blc_pwm_precision_factor;



	/* get bl_max_freq and pol from dev_priv*/

	if (!dev_priv->lvds_bl) {

		dev_err(dev->dev, "Has no valid LVDS backlight info\n");

		return -ENOENT;

	}

	bl_max_freq = dev_priv->lvds_bl->freq;

	blc_pwm_precision_factor = PSB_BLC_PWM_PRECISION_FACTOR;



	core_clock = dev_priv->core_freq;



	value = (core_clock * MHz) / BLC_PWM_FREQ_CALC_CONSTANT;

	value *= blc_pwm_precision_factor;

	value /= bl_max_freq;

	value /= blc_pwm_precision_factor;



	if (value > (unsigned long long)PSB_BLC_MAX_PWM_REG_FREQ ||

		 value < (unsigned long long)PSB_BLC_MIN_PWM_REG_FREQ)

				return -ERANGE;

	else {

		value &= PSB_BACKLIGHT_PWM_POLARITY_BIT_CLEAR;

		REG_WRITE(BLC_PWM_CTL,

			(value << PSB_BACKLIGHT_PWM_CTL_SHIFT) | (value));

	}

	return 0;

}



static int psb_set_brightness(struct backlight_device *bd)

{

	struct drm_device *dev = bl_get_data(psb_backlight_device);

	int level = bd->props.brightness;



	/* Percentage 1-100% being valid */

	if (level < 1)

		level = 1;



	psb_intel_lvds_set_brightness(dev, level);

	psb_brightness = level;

	return 0;

}



static const struct backlight_ops psb_ops = {

	.get_brightness = psb_get_brightness,

	.update_status  = psb_set_brightness,

};



static int psb_backlight_init(struct drm_device *dev)

{

	struct drm_psb_private *dev_priv = dev->dev_private;

	int ret;

	struct backlight_properties props;



	memset(&props, 0, sizeof(struct backlight_properties));

	props.max_brightness = 100;

	props.type = BACKLIGHT_PLATFORM;



	psb_backlight_device = backlight_device_register("psb-bl",

					NULL, (void *)dev, &psb_ops, &props);

	if (IS_ERR(psb_backlight_device))

		return PTR_ERR(psb_backlight_device);



	ret = psb_backlight_setup(dev);

	if (ret < 0) {

		backlight_device_unregister(psb_backlight_device);

		psb_backlight_device = NULL;

		return ret;

	}

	psb_backlight_device->props.brightness = 100;

	psb_backlight_device->props.max_brightness = 100;

	backlight_update_status(psb_backlight_device);

	dev_priv->backlight_device = psb_backlight_device;

	return 0;

}



#endif



/*

 *	Provide the Poulsbo specific chip logic and low level methods

 *	for power management

 */



static void psb_init_pm(struct drm_device *dev)

{

	struct drm_psb_private *dev_priv = dev->dev_private;



	u32 gating = PSB_RSGX32(PSB_CR_CLKGATECTL);

	gating &= ~3;	/* Disable 2D clock gating */

	gating |= 1;

	PSB_WSGX32(gating, PSB_CR_CLKGATECTL);

	PSB_RSGX32(PSB_CR_CLKGATECTL);

}



/**

 *	psb_save_display_registers	-	save registers lost on suspend

 *	@dev: our DRM device

 *

 *	Save the state we need in order to be able to restore the interface

 *	upon resume from suspend

 */

static int psb_save_display_registers(struct drm_device *dev)

{

	struct drm_psb_private *dev_priv = dev->dev_private;

	struct drm_crtc *crtc;

	struct drm_connector *connector;



	/* Display arbitration control + watermarks */

	dev_priv->saveDSPARB = PSB_RVDC32(DSPARB);

	dev_priv->saveDSPFW1 = PSB_RVDC32(DSPFW1);

	dev_priv->saveDSPFW2 = PSB_RVDC32(DSPFW2);

	dev_priv->saveDSPFW3 = PSB_RVDC32(DSPFW3);

	dev_priv->saveDSPFW4 = PSB_RVDC32(DSPFW4);

	dev_priv->saveDSPFW5 = PSB_RVDC32(DSPFW5);

	dev_priv->saveDSPFW6 = PSB_RVDC32(DSPFW6);

	dev_priv->saveCHICKENBIT = PSB_RVDC32(DSPCHICKENBIT);



	/* Save crtc and output state */

	mutex_lock(&dev->mode_config.mutex);

	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {

		if (drm_helper_crtc_in_use(crtc))

			crtc->funcs->save(crtc);

	}



	list_for_each_entry(connector, &dev->mode_config.connector_list, head)

		connector->funcs->save(connector);



	mutex_unlock(&dev->mode_config.mutex);

	return 0;

}



/**

 *	psb_restore_display_registers	-	restore lost register state

 *	@dev: our DRM device

 *

 *	Restore register state that was lost during suspend and resume.

 */

static int psb_restore_display_registers(struct drm_device *dev)

{

	struct drm_psb_private *dev_priv = dev->dev_private;

	struct drm_crtc *crtc;

	struct drm_connector *connector;

	int pp_stat;



	/* Display arbitration + watermarks */

	PSB_WVDC32(dev_priv->saveDSPARB, DSPARB);

	PSB_WVDC32(dev_priv->saveDSPFW1, DSPFW1);

	PSB_WVDC32(dev_priv->saveDSPFW2, DSPFW2);

	PSB_WVDC32(dev_priv->saveDSPFW3, DSPFW3);

	PSB_WVDC32(dev_priv->saveDSPFW4, DSPFW4);

	PSB_WVDC32(dev_priv->saveDSPFW5, DSPFW5);

	PSB_WVDC32(dev_priv->saveDSPFW6, DSPFW6);

	PSB_WVDC32(dev_priv->saveCHICKENBIT, DSPCHICKENBIT);



	/*make sure VGA plane is off. it initializes to on after reset!*/

	PSB_WVDC32(0x80000000, VGACNTRL);



	mutex_lock(&dev->mode_config.mutex);

	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)

		if (drm_helper_crtc_in_use(crtc))

			crtc->funcs->restore(crtc);



	list_for_each_entry(connector, &dev->mode_config.connector_list, head)

		connector->funcs->restore(connector);



	mutex_unlock(&dev->mode_config.mutex);



	if (dev_priv->iLVDS_enable) {

		/*shutdown the panel*/

		PSB_WVDC32(0, PP_CONTROL);

		do {

			pp_stat = PSB_RVDC32(PP_STATUS);

		} while (pp_stat & 0x80000000);



		/* Turn off the plane */

		PSB_WVDC32(0x58000000, DSPACNTR);

		PSB_WVDC32(0, DSPASURF);/*trigger the plane disable*/

		/* Wait ~4 ticks */

		msleep(4);

		/* Turn off pipe */

		PSB_WVDC32(0x0, PIPEACONF);

		/* Wait ~8 ticks */

		msleep(8);



		/* Turn off PLLs */

		PSB_WVDC32(0, MRST_DPLL_A);

	} else {

		PSB_WVDC32(DPI_SHUT_DOWN, DPI_CONTROL_REG);

		PSB_WVDC32(0x0, PIPEACONF);

		PSB_WVDC32(0x2faf0000, BLC_PWM_CTL);

		while (REG_READ(0x70008) & 0x40000000)

			cpu_relax();

		while ((PSB_RVDC32(GEN_FIFO_STAT_REG) & DPI_FIFO_EMPTY)

			!= DPI_FIFO_EMPTY)

			cpu_relax();

		PSB_WVDC32(0, DEVICE_READY_REG);

	}

	return 0;

}



static int psb_power_down(struct drm_device *dev)

{

	return 0;

}



static int psb_power_up(struct drm_device *dev)

{

	return 0;

}



static void psb_get_core_freq(struct drm_device *dev)

{

	uint32_t clock;

	struct pci_dev *pci_root = pci_get_bus_and_slot(0, 0);

	struct drm_psb_private *dev_priv = dev->dev_private;



	/*pci_write_config_dword(pci_root, 0xD4, 0x00C32004);*/

	/*pci_write_config_dword(pci_root, 0xD0, 0xE0033000);*/



	pci_write_config_dword(pci_root, 0xD0, 0xD0050300);

	pci_read_config_dword(pci_root, 0xD4, &clock);

	pci_dev_put(pci_root);



	switch (clock & 0x07) {

	case 0:

		dev_priv->core_freq = 100;

		break;

	case 1:

		dev_priv->core_freq = 133;

		break;

	case 2:

		dev_priv->core_freq = 150;

		break;

	case 3:

		dev_priv->core_freq = 178;

		break;

	case 4:

		dev_priv->core_freq = 200;

		break;

	case 5:

	case 6:

	case 7:

		dev_priv->core_freq = 266;

	default:

		dev_priv->core_freq = 0;

	}

}



static int psb_chip_setup(struct drm_device *dev)

{

	psb_get_core_freq(dev);

	gma_intel_opregion_init(dev);

	psb_intel_init_bios(dev);

	return 0;

}



const struct psb_ops psb_chip_ops = {

	.name = "Poulsbo",

	.accel_2d = 1,

	.pipes = 2,

	.crtcs = 2,

	.sgx_offset = PSB_SGX_OFFSET,

	.chip_setup = psb_chip_setup,



	.crtc_helper = &psb_intel_helper_funcs,

	.crtc_funcs = &psb_intel_crtc_funcs,



	.output_init = psb_output_init,



#ifdef CONFIG_BACKLIGHT_CLASS_DEVICE

	.backlight_init = psb_backlight_init,

#endif



	.init_pm = psb_init_pm,

	.save_regs = psb_save_display_registers,

	.restore_regs = psb_restore_display_registers,

	.power_down = psb_power_down,

	.power_up = psb_power_up,

};

drivers/gpu/drm/gma500/psb_gfx.mod.c

0 → 100644
+51 −0
Original line number Diff line number Diff line 
#include <linux/module.h>

#include <linux/vermagic.h>

#include <linux/compiler.h>



MODULE_INFO(vermagic, VERMAGIC_STRING);



struct module __this_module

__attribute__((section(".gnu.linkonce.this_module"))) = {

 .name = KBUILD_MODNAME,

 .init = init_module,

#ifdef CONFIG_MODULE_UNLOAD

 .exit = cleanup_module,

#endif

 .arch = MODULE_ARCH_INIT,

};



MODULE_INFO(staging, "Y");



static const char __module_depends[]

__used

__attribute__((section(".modinfo"))) =

"depends=drm,drm_kms_helper,video,i2c-algo-bit";



MODULE_ALIAS("pci:v00008086d00008108sv*sd*bc*sc*i*");

MODULE_ALIAS("pci:v00008086d00008109sv*sd*bc*sc*i*");

MODULE_ALIAS("pci:v00008086d00004100sv*sd*bc*sc*i*");

MODULE_ALIAS("pci:v00008086d00004101sv*sd*bc*sc*i*");

MODULE_ALIAS("pci:v00008086d00004102sv*sd*bc*sc*i*");

MODULE_ALIAS("pci:v00008086d00004103sv*sd*bc*sc*i*");

MODULE_ALIAS("pci:v00008086d00004104sv*sd*bc*sc*i*");

MODULE_ALIAS("pci:v00008086d00004105sv*sd*bc*sc*i*");

MODULE_ALIAS("pci:v00008086d00004106sv*sd*bc*sc*i*");

MODULE_ALIAS("pci:v00008086d00004107sv*sd*bc*sc*i*");

MODULE_ALIAS("pci:v00008086d00000130sv*sd*bc*sc*i*");

MODULE_ALIAS("pci:v00008086d00000131sv*sd*bc*sc*i*");

MODULE_ALIAS("pci:v00008086d00000132sv*sd*bc*sc*i*");

MODULE_ALIAS("pci:v00008086d00000133sv*sd*bc*sc*i*");

MODULE_ALIAS("pci:v00008086d00000134sv*sd*bc*sc*i*");

MODULE_ALIAS("pci:v00008086d00000135sv*sd*bc*sc*i*");

MODULE_ALIAS("pci:v00008086d00000136sv*sd*bc*sc*i*");

MODULE_ALIAS("pci:v00008086d00000137sv*sd*bc*sc*i*");

MODULE_ALIAS("pci:v00008086d00000BE0sv*sd*bc*sc*i*");

MODULE_ALIAS("pci:v00008086d00000BE1sv*sd*bc*sc*i*");

MODULE_ALIAS("pci:v00008086d00000BE2sv*sd*bc*sc*i*");

MODULE_ALIAS("pci:v00008086d00000BE3sv*sd*bc*sc*i*");

MODULE_ALIAS("pci:v00008086d00000BE4sv*sd*bc*sc*i*");

MODULE_ALIAS("pci:v00008086d00000BE5sv*sd*bc*sc*i*");

MODULE_ALIAS("pci:v00008086d00000BE6sv*sd*bc*sc*i*");

MODULE_ALIAS("pci:v00008086d00000BE7sv*sd*bc*sc*i*");



MODULE_INFO(srcversion, "51B3334F342F5EEAC93AF22");

drivers/gpu/drm/gma500/psb_intel_display.c

0 → 100644
+1431 −0

File added.

Preview size limit exceeded, changes collapsed.

drivers/gpu/drm/gma500/psb_intel_display.h

0 → 100644
+28 −0
Original line number Diff line number Diff line 
/* copyright (c) 2008, Intel Corporation

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms and conditions of the GNU General Public License,

 * version 2, as published by the Free Software Foundation.

 *

 * This program is distributed in the hope it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for

 * more details.

 *

 * You should have received a copy of the GNU General Public License along with

 * this program; if not, write to the Free Software Foundation, Inc.,

 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Authors:

 * Eric Anholt <eric@anholt.net>

 */



#ifndef _INTEL_DISPLAY_H_

#define _INTEL_DISPLAY_H_



bool psb_intel_pipe_has_type(struct drm_crtc *crtc, int type);

void psb_intel_crtc_gamma_set(struct drm_crtc *crtc, u16 *red,

			 u16 *green, u16 *blue, uint32_t type, uint32_t size);

void psb_intel_crtc_destroy(struct drm_crtc *crtc);



#endif

drivers/gpu/drm/gma500/psb_intel_drv.h

0 → 100644
+228 −0
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2009-2011, Intel Corporation.

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms and conditions of the GNU General Public License,

 * version 2, as published by the Free Software Foundation.

 *

 * This program is distributed in the hope it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for

 * more details.

 *

 * You should have received a copy of the GNU General Public License along with

 * this program; if not, write to the Free Software Foundation, Inc.,

 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.

 *

 */



#ifndef __INTEL_DRV_H__

#define __INTEL_DRV_H__



#include <linux/i2c.h>

#include <linux/i2c-algo-bit.h>

#include <drm/drm_crtc.h>

#include <drm/drm_crtc_helper.h>

#include <linux/gpio.h>



/*

 * Display related stuff

 */



/* store information about an Ixxx DVO */

/* The i830->i865 use multiple DVOs with multiple i2cs */

/* the i915, i945 have a single sDVO i2c bus - which is different */

#define MAX_OUTPUTS 6

/* maximum connectors per crtcs in the mode set */

#define INTELFB_CONN_LIMIT 4



#define INTEL_I2C_BUS_DVO 1

#define INTEL_I2C_BUS_SDVO 2



/* these are outputs from the chip - integrated only

 * external chips are via DVO or SDVO output */

#define INTEL_OUTPUT_UNUSED 0

#define INTEL_OUTPUT_ANALOG 1

#define INTEL_OUTPUT_DVO 2

#define INTEL_OUTPUT_SDVO 3

#define INTEL_OUTPUT_LVDS 4

#define INTEL_OUTPUT_TVOUT 5

#define INTEL_OUTPUT_HDMI 6

#define INTEL_OUTPUT_MIPI 7

#define INTEL_OUTPUT_MIPI2 8



#define INTEL_DVO_CHIP_NONE 0

#define INTEL_DVO_CHIP_LVDS 1

#define INTEL_DVO_CHIP_TMDS 2

#define INTEL_DVO_CHIP_TVOUT 4



/*

 * Hold information useally put on the device driver privates here,

 * since it needs to be shared across multiple of devices drivers privates.

 */

struct psb_intel_mode_device {



	/*

	 * Abstracted memory manager operations

	 */

	 size_t(*bo_offset) (struct drm_device *dev, void *bo);



	/*

	 * Cursor (Can go ?)

	 */

	int cursor_needs_physical;



	/*

	 * LVDS info

	 */

	int backlight_duty_cycle;	/* restore backlight to this value */

	bool panel_wants_dither;

	struct drm_display_mode *panel_fixed_mode;

	struct drm_display_mode *panel_fixed_mode2;

	struct drm_display_mode *vbt_mode;	/* if any */



	uint32_t saveBLC_PWM_CTL;

};



struct psb_intel_i2c_chan {

	/* for getting at dev. private (mmio etc.) */

	struct drm_device *drm_dev;

	u32 reg;		/* GPIO reg */

	struct i2c_adapter adapter;

	struct i2c_algo_bit_data algo;

	u8 slave_addr;

};



struct psb_intel_output {

	struct drm_connector base;



	struct drm_encoder enc;

	int type;



	struct psb_intel_i2c_chan *i2c_bus;	/* for control functions */

	struct psb_intel_i2c_chan *ddc_bus;	/* for DDC only stuff */

	bool load_detect_temp;

	void *dev_priv;



	struct psb_intel_mode_device *mode_dev;

	struct i2c_adapter *hdmi_i2c_adapter;	/* for control functions */

};



struct psb_intel_crtc_state {

	uint32_t saveDSPCNTR;

	uint32_t savePIPECONF;

	uint32_t savePIPESRC;

	uint32_t saveDPLL;

	uint32_t saveFP0;

	uint32_t saveFP1;

	uint32_t saveHTOTAL;

	uint32_t saveHBLANK;

	uint32_t saveHSYNC;

	uint32_t saveVTOTAL;

	uint32_t saveVBLANK;

	uint32_t saveVSYNC;

	uint32_t saveDSPSTRIDE;

	uint32_t saveDSPSIZE;

	uint32_t saveDSPPOS;

	uint32_t saveDSPBASE;

	uint32_t savePalette[256];

};



struct psb_intel_crtc {

	struct drm_crtc base;

	int pipe;

	int plane;

	uint32_t cursor_addr;

	u8 lut_r[256], lut_g[256], lut_b[256];

	u8 lut_adj[256];

	struct psb_intel_framebuffer *fbdev_fb;

	/* a mode_set for fbdev users on this crtc */

	struct drm_mode_set mode_set;



	/* GEM object that holds our cursor */

	struct drm_gem_object *cursor_obj;



	struct drm_display_mode saved_mode;

	struct drm_display_mode saved_adjusted_mode;



	struct psb_intel_mode_device *mode_dev;



	/*crtc mode setting flags*/

	u32 mode_flags;



	/* Saved Crtc HW states */

	struct psb_intel_crtc_state *crtc_state;

};



#define to_psb_intel_crtc(x)	\

		container_of(x, struct psb_intel_crtc, base)

#define to_psb_intel_output(x)	\

		container_of(x, struct psb_intel_output, base)

#define enc_to_psb_intel_output(x)	\

		container_of(x, struct psb_intel_output, enc)

#define to_psb_intel_framebuffer(x)	\

		container_of(x, struct psb_intel_framebuffer, base)



struct psb_intel_i2c_chan *psb_intel_i2c_create(struct drm_device *dev,

					const u32 reg, const char *name);

void psb_intel_i2c_destroy(struct psb_intel_i2c_chan *chan);

int psb_intel_ddc_get_modes(struct psb_intel_output *psb_intel_output);

extern bool psb_intel_ddc_probe(struct psb_intel_output *psb_intel_output);



extern void psb_intel_crtc_init(struct drm_device *dev, int pipe,

			    struct psb_intel_mode_device *mode_dev);

extern void psb_intel_crt_init(struct drm_device *dev);

extern void psb_intel_sdvo_init(struct drm_device *dev, int output_device);

extern void psb_intel_dvo_init(struct drm_device *dev);

extern void psb_intel_tv_init(struct drm_device *dev);

extern void psb_intel_lvds_init(struct drm_device *dev,

			    struct psb_intel_mode_device *mode_dev);

extern void psb_intel_lvds_set_brightness(struct drm_device *dev, int level);

extern void oaktrail_lvds_init(struct drm_device *dev,

			   struct psb_intel_mode_device *mode_dev);

extern void oaktrail_wait_for_INTR_PKT_SENT(struct drm_device *dev);

extern void oaktrail_dsi_init(struct drm_device *dev,

			   struct psb_intel_mode_device *mode_dev);

extern void mid_dsi_init(struct drm_device *dev,

		    struct psb_intel_mode_device *mode_dev, int dsi_num);



extern void psb_intel_crtc_load_lut(struct drm_crtc *crtc);

extern void psb_intel_encoder_prepare(struct drm_encoder *encoder);

extern void psb_intel_encoder_commit(struct drm_encoder *encoder);



extern struct drm_encoder *psb_intel_best_encoder(struct drm_connector

					      *connector);



extern struct drm_display_mode *psb_intel_crtc_mode_get(struct drm_device *dev,

						    struct drm_crtc *crtc);

extern void psb_intel_wait_for_vblank(struct drm_device *dev);

extern int psb_intel_get_pipe_from_crtc_id(struct drm_device *dev, void *data,

				struct drm_file *file_priv);

extern struct drm_crtc *psb_intel_get_crtc_from_pipe(struct drm_device *dev,

						 int pipe);

extern struct drm_connector *psb_intel_sdvo_find(struct drm_device *dev,

					     int sdvoB);

extern int psb_intel_sdvo_supports_hotplug(struct drm_connector *connector);

extern void psb_intel_sdvo_set_hotplug(struct drm_connector *connector,

				   int enable);

extern int intelfb_probe(struct drm_device *dev);

extern int intelfb_remove(struct drm_device *dev,

			  struct drm_framebuffer *fb);

extern struct drm_framebuffer *psb_intel_framebuffer_create(struct drm_device

							*dev, struct

							drm_mode_fb_cmd

							*mode_cmd,

							void *mm_private);

extern bool psb_intel_lvds_mode_fixup(struct drm_encoder *encoder,

				      struct drm_display_mode *mode,

				      struct drm_display_mode *adjusted_mode);

extern int psb_intel_lvds_mode_valid(struct drm_connector *connector,

				     struct drm_display_mode *mode);

extern int psb_intel_lvds_set_property(struct drm_connector *connector,

					struct drm_property *property,

					uint64_t value);

extern void psb_intel_lvds_destroy(struct drm_connector *connector);

extern const struct drm_encoder_funcs psb_intel_lvds_enc_funcs;





#endif				/* __INTEL_DRV_H__ */