i810_driver.c

来自「是由intel提供的针对intel显卡915以上系列的linux驱动」· C语言 代码 · 共 2,368 行 · 第 1/5 页

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

Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
All Rights Reserved.

Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sub license, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice (including the
next paragraph) shall be included in all copies or substantial portions
of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

**************************************************************************/
/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/i810/i810_driver.c,v 1.101 2004/01/02 20:15:47 dawes Exp $ */

/*
 * Reformatted with GNU indent (2.2.8), using the following options:
 *
 *    -bad -bap -c41 -cd0 -ncdb -ci6 -cli0 -cp0 -ncs -d0 -di3 -i3 -ip3 -l78
 *    -lp -npcs -psl -sob -ss -br -ce -sc -hnl
 *
 * This provides a good match with the original i810 code and preferred
 * XFree86 formatting conventions.
 *
 * When editing this driver, please follow the existing formatting, and edit
 * with <TAB> characters expanded at 8-column intervals.
 */

/*
 * Authors:
 *   Keith Whitwell <[e-mail]>
 *
 * Add ARGB HW cursor support:
 *   Alan Hourihane <[e-mail]>
 *
 */

/*
 * This server does not support these XFree86 4.0 features yet
 * shadowFb (if requested or acceleration is off)
 * Overlay planes
 * DGA
 */

/*
 * These are X and server generic header files.
 */
#include "xf86.h"
#include "xf86_ansic.h"
#include "xf86_OSproc.h"
#include "xf86Resources.h"
#include "xf86RAC.h"
#include "xf86cmap.h"
#include "compiler.h"
#include "mibstore.h"
#include "vgaHW.h"
#include "mipointer.h"
#include "micmap.h"

#include "fb.h"
#include "miscstruct.h"
#include "xf86xv.h"
#include <X11/extensions/Xv.h>
#include "vbe.h"

#include "i810.h"
#include "i830.h"

#ifdef XF86DRI
#include "dri.h"
#endif

/* Required Functions: */

static void I810Identify(int flags);
static Bool I810Probe(DriverPtr drv, int flags);
#ifndef I830_ONLY
static Bool I810PreInit(ScrnInfoPtr pScrn, int flags);
static Bool I810ScreenInit(int Index, ScreenPtr pScreen, int argc,
			   char **argv);
static Bool I810EnterVT(int scrnIndex, int flags);
static void I810LeaveVT(int scrnIndex, int flags);
static Bool I810CloseScreen(int scrnIndex, ScreenPtr pScreen);
static Bool I810SaveScreen(ScreenPtr pScreen, Bool unblank);
static void I810FreeScreen(int scrnIndex, int flags);
static void I810DisplayPowerManagementSet(ScrnInfoPtr pScrn,
					  int PowerManagermentMode,
					  int flags);
static ModeStatus I810ValidMode(int scrnIndex, DisplayModePtr mode,
				Bool verbose, int flags);
#endif /* I830_ONLY */


DriverRec I810 = {
   I810_VERSION,
   I810_DRIVER_NAME,
   I810Identify,
   I810Probe,
   I810AvailableOptions,
   NULL,
   0
};

/* *INDENT-OFF* */
/* Chipsets */
static SymTabRec I810Chipsets[] = {
#ifndef I830_ONLY
   {PCI_CHIP_I810,		"i810"},
   {PCI_CHIP_I810_DC100,	"i810-dc100"},
   {PCI_CHIP_I810_E,		"i810e"},
   {PCI_CHIP_I815,		"i815"},
#endif
   {PCI_CHIP_I830_M,		"i830M"},
   {PCI_CHIP_845_G,		"845G"},
   {PCI_CHIP_I855_GM,		"852GM/855GM"},
   {PCI_CHIP_I865_G,		"865G"},
   {PCI_CHIP_I915_G,		"915G"},
   {PCI_CHIP_E7221_G,		"E7221 (i915)"},
   {PCI_CHIP_I915_GM,		"915GM"},
   {PCI_CHIP_I945_G,		"945G"},
   {PCI_CHIP_I945_GM,		"945GM"},
   {-1,				NULL}
};

static PciChipsets I810PciChipsets[] = {
#ifndef I830_ONLY
   {PCI_CHIP_I810,		PCI_CHIP_I810,		RES_SHARED_VGA},
   {PCI_CHIP_I810_DC100,	PCI_CHIP_I810_DC100,	RES_SHARED_VGA},
   {PCI_CHIP_I810_E,		PCI_CHIP_I810_E,	RES_SHARED_VGA},
   {PCI_CHIP_I815,		PCI_CHIP_I815,		RES_SHARED_VGA},
#endif
   {PCI_CHIP_I830_M,		PCI_CHIP_I830_M,	RES_SHARED_VGA},
   {PCI_CHIP_845_G,		PCI_CHIP_845_G,		RES_SHARED_VGA},
   {PCI_CHIP_I855_GM,		PCI_CHIP_I855_GM,	RES_SHARED_VGA},
   {PCI_CHIP_I865_G,		PCI_CHIP_I865_G,	RES_SHARED_VGA},
   {PCI_CHIP_I915_G,		PCI_CHIP_I915_G,	RES_SHARED_VGA},
   {PCI_CHIP_E7221_G,		PCI_CHIP_E7221_G,	RES_SHARED_VGA},
   {PCI_CHIP_I915_GM,		PCI_CHIP_I915_GM,	RES_SHARED_VGA},
   {PCI_CHIP_I945_G,		PCI_CHIP_I945_G,	RES_SHARED_VGA},
   {PCI_CHIP_I945_GM,		PCI_CHIP_I945_GM,	RES_SHARED_VGA},
   {-1,				-1, RES_UNDEFINED }
};

#ifndef I830_ONLY
typedef enum {
   OPTION_NOACCEL,
   OPTION_SW_CURSOR,
   OPTION_COLOR_KEY,
   OPTION_CACHE_LINES,
   OPTION_DAC_6BIT,
   OPTION_DRI,
   OPTION_NO_DDC,
   OPTION_SHOW_CACHE,
   OPTION_XVMC_SURFACES,
   OPTION_PAGEFLIP
} I810Opts;
 
static const OptionInfoRec I810Options[] = {
   {OPTION_NOACCEL,		"NoAccel",	OPTV_BOOLEAN,	{0}, FALSE},
   {OPTION_SW_CURSOR,		"SWcursor",	OPTV_BOOLEAN,	{0}, FALSE},
   {OPTION_COLOR_KEY,		"ColorKey",	OPTV_INTEGER,	{0}, FALSE},
   {OPTION_CACHE_LINES,		"CacheLines",	OPTV_INTEGER,	{0}, FALSE},
   {OPTION_DAC_6BIT,		"Dac6Bit",	OPTV_BOOLEAN,	{0}, FALSE},
   {OPTION_DRI,			"DRI",		OPTV_BOOLEAN,	{0}, FALSE},
   {OPTION_NO_DDC,		"NoDDC",	OPTV_BOOLEAN,	{0}, FALSE},
   {OPTION_SHOW_CACHE,		"ShowCache",	OPTV_BOOLEAN,	{0}, FALSE},
   {OPTION_XVMC_SURFACES,	"XvMCSurfaces",	OPTV_INTEGER,	{0}, FALSE},
   {OPTION_PAGEFLIP,            "PageFlip",     OPTV_BOOLEAN, {0},   FALSE},
   {-1,				NULL,		OPTV_NONE,	{0}, FALSE}
};
/* *INDENT-ON* */
#endif

const char *I810vgahwSymbols[] = {
   "vgaHWFreeHWRec",
   "vgaHWGetHWRec",
   "vgaHWGetIOBase",
   "vgaHWGetIndex",
   "vgaHWInit",
   "vgaHWLock",
   "vgaHWMapMem",
   "vgaHWProtect",
   "vgaHWRestore",
   "vgaHWSave",
   "vgaHWSaveScreen",
   "vgaHWSetMmioFuncs",
   "vgaHWUnlock",
   "vgaHWUnmapMem",
   NULL
};

const char *I810fbSymbols[] = {
   "fbPictureInit",
   "fbScreenInit",
   NULL
};

const char *I810vbeSymbols[] = {
   "VBEFreeModeInfo",
   "VBEFreeVBEInfo",
   "VBEGetModeInfo",
   "VBEGetModePool",
   "VBEGetVBEInfo",
   "VBEGetVBEMode",
   "VBEInit",
   "VBEPrintModes",
   "VBESaveRestore",
   "VBESetDisplayStart",
   "VBESetGetDACPaletteFormat",
   "VBESetGetLogicalScanlineLength",
   "VBESetGetPaletteData",
   "VBESetModeNames",
   "VBESetModeParameters",
   "VBESetVBEMode",
   "VBEValidateModes",
   "vbeDoEDID",
   "vbeFree",
   NULL
};

#ifdef XFree86LOADER
static const char *vbeOptionalSymbols[] = {
   "VBEDPMSSet",
   "VBEGetPixelClock",
   NULL
};
#endif

const char *I810ddcSymbols[] = {
   "xf86PrintEDID",
   "xf86SetDDCproperties",
   NULL
};

const char *I810int10Symbols[] = {
   "xf86ExecX86int10",
   "xf86InitInt10",
   "xf86Int10AllocPages",
   "xf86int10Addr",
   NULL
};

const char *I810xaaSymbols[] = {
   "XAACreateInfoRec",
   "XAADestroyInfoRec",
   "XAAInit",
   "XAAGetCopyROP",
   "XAAGetPatternROP",
   NULL
};

const char *I810ramdacSymbols[] = {
   "xf86CreateCursorInfoRec",
   "xf86DestroyCursorInfoRec",
   "xf86InitCursor",
   NULL
};

#ifdef XF86DRI
const char *I810drmSymbols[] = {
   "drmAddBufs",
   "drmAddMap",
   "drmRmMap",
   "drmAgpAcquire",
   "drmAgpAlloc",
   "drmAgpBind",
   "drmAgpEnable",
   "drmAgpFree",
   "drmAgpRelease",
   "drmAgpUnbind",
   "drmAuthMagic",
   "drmCommandNone",
   "drmCommandWrite",
   "drmCreateContext",
   "drmCtlInstHandler",
   "drmCtlUninstHandler",
   "drmDestroyContext",
   "drmFreeVersion",
   "drmGetInterruptFromBusID",
   "drmGetLibVersion",
   "drmGetVersion",
   NULL
};


const char *I810driSymbols[] = {
   "DRICloseScreen",
   "DRICreateInfoRec",
   "DRIGetContext",
   "DRIDestroyInfoRec",
   "DRIFinishScreenInit",
   "DRIGetSAREAPrivate",
   "DRILock",
   "DRIQueryVersion",
   "DRIScreenInit",
   "DRIUnlock",
   "GlxSetVisualConfigs",
   "DRICreatePCIBusID",
   NULL
};

#ifdef XF86DRI

const char *I810shadowFBSymbols[] = {
    "ShadowFBInit",
    NULL
};

const char *I810shadowSymbols[] = {
    "shadowInit",
    "shadowSetup",
    "shadowAdd",
    NULL
};

#endif

#endif /* I830_ONLY */

#ifndef I810_DEBUG
int I810_DEBUG = (0
/*     		  | DEBUG_ALWAYS_SYNC  */
/*    		  | DEBUG_VERBOSE_ACCEL */
/*  		  | DEBUG_VERBOSE_SYNC */
/*  		  | DEBUG_VERBOSE_VGA */
/*  		  | DEBUG_VERBOSE_RING */
/*  		  | DEBUG_VERBOSE_OUTREG */
/*  		  | DEBUG_VERBOSE_MEMORY */
/*  		  | DEBUG_VERBOSE_CURSOR */
      );
#endif

#ifndef I830_ONLY
#ifdef XF86DRI
static int i810_pitches[] = {
   512,
   1024,
   2048,
   4096,
   0
};
#endif
#endif

int I830EntityIndex = -1;

#ifdef XFree86LOADER

static MODULESETUPPROTO(i810Setup);

static XF86ModuleVersionInfo i810VersRec = {
   "i810",
   "Tungsten Graphics, Inc.",
   MODINFOSTRING1,
   MODINFOSTRING2,
   XF86_VERSION_CURRENT,
   INTEL_MAJOR_VERSION, INTEL_MINOR_VERSION, INTEL_PATCHLEVEL,
   ABI_CLASS_VIDEODRV,
   ABI_VIDEODRV_VERSION,
   MOD_CLASS_VIDEODRV,
   {0, 0, 0, 0}
};

XF86ModuleData i810ModuleData = { &i810VersRec, i810Setup, 0 };

static pointer
i810Setup(pointer module, pointer opts, int *errmaj, int *errmin)
{
   static Bool setupDone = 0;

   /* This module should be loaded only once, but check to be sure.
    */
   if (!setupDone) {
      setupDone = 1;
      xf86AddDriver(&I810, module, 0);

      /*
       * Tell the loader about symbols from other modules that this module
       * might refer to.
       */
      LoaderRefSymLists(I810vgahwSymbols,
			I810fbSymbols, I810xaaSymbols, I810ramdacSymbols,
#ifdef XF86DRI
			I810drmSymbols,
			I810driSymbols,
			I810shadowSymbols,
			I810shadowFBSymbols,
#endif
			I810vbeSymbols, vbeOptionalSymbols,
			I810ddcSymbols, I810int10Symbols, NULL);

      /*
       * The return value must be non-NULL on success even though there
       * is no TearDownProc.
       */
      return (pointer) 1;
   } else {
      if (errmaj)
	 *errmaj = LDR_ONCEONLY;
      return NULL;
   }
}

#endif

#ifndef I830_ONLY
/*
 * I810GetRec and I810FreeRec --
 *
 * Private data for the driver is stored in the screen structure.
 * These two functions create and destroy that private data.
 *
 */
static Bool
I810GetRec(ScrnInfoPtr pScrn)
{
   if (pScrn->driverPrivate)
      return TRUE;

   pScrn->driverPrivate = xnfcalloc(sizeof(I810Rec), 1);
   return TRUE;
}

static void
I810FreeRec(ScrnInfoPtr pScrn)
{
   if (!pScrn)
      return;
   if (!pScrn->driverPrivate)
      return;
   xfree(pScrn->driverPrivate);
   pScrn->driverPrivate = 0;
}
#endif

/*
 * I810Identify --
 *
 * Returns the string name for the driver based on the chipset. In this
 * case it will always be an I810, so we can return a static string.
 *
 */
static void
I810Identify(int flags)
{
   xf86PrintChipsets(I810_NAME, "Driver for Intel Integrated Graphics Chipsets",
		     I810Chipsets);
}

const OptionInfoRec *
I810AvailableOptions(int chipid, int busid)
{
#ifndef I830_ONLY
   const OptionInfoRec *pOptions;

   if ((pOptions = I830BIOSAvailableOptions(chipid, busid)))
      return pOptions;
   return I810Options;
#else
   return I830BIOSAvailableOptions(chipid, busid);