2003-11-14 17:48:57 +01:00
|
|
|
/*
|
|
|
|
* Copyright 2000-2002 by Alan Hourihane, Flint Mountain, North Wales.
|
|
|
|
*
|
|
|
|
* Permission to use, copy, modify, distribute, and sell this software and its
|
|
|
|
* documentation for any purpose is hereby granted without fee, provided that
|
|
|
|
* the above copyright notice appear in all copies and that both that
|
|
|
|
* copyright notice and this permission notice appear in supporting
|
|
|
|
* documentation, and that the name of Alan Hourihane not be used in
|
|
|
|
* advertising or publicity pertaining to distribution of the software without
|
|
|
|
* specific, written prior permission. Alan Hourihane makes no representations
|
|
|
|
* about the suitability of this software for any purpose. It is provided
|
|
|
|
* "as is" without express or implied warranty.
|
|
|
|
*
|
|
|
|
* ALAN HOURIHANE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
|
|
|
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
|
|
|
* EVENT SHALL ALAN HOURIHANE BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
|
|
|
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
|
|
|
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
|
|
|
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
|
|
* PERFORMANCE OF THIS SOFTWARE.
|
|
|
|
*
|
|
|
|
* Author: Alan Hourihane, alanh@fairlite.demon.co.uk
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2005-07-03 09:02:09 +02:00
|
|
|
#ifdef HAVE_XORG_CONFIG_H
|
|
|
|
#include <xorg-config.h>
|
|
|
|
#endif
|
|
|
|
|
2003-11-14 17:48:57 +01:00
|
|
|
#include "xf86.h"
|
|
|
|
#include "xf86Config.h"
|
2005-01-28 17:13:00 +01:00
|
|
|
#include "xf86_OSlib.h"
|
2003-11-14 17:48:57 +01:00
|
|
|
#include "xf86Priv.h"
|
|
|
|
#define IN_XSERVER
|
|
|
|
#include "Configint.h"
|
|
|
|
#include "xf86DDC.h"
|
2010-09-10 18:16:30 +02:00
|
|
|
#include "xf86pciBus.h"
|
2006-12-04 22:36:30 +01:00
|
|
|
#if (defined(__sparc__) || defined(__sparc)) && !defined(__OpenBSD__)
|
2003-11-14 17:48:57 +01:00
|
|
|
#include "xf86Bus.h"
|
|
|
|
#include "xf86Sbus.h"
|
|
|
|
#endif
|
2011-03-09 01:17:27 +01:00
|
|
|
#include "misc.h"
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
typedef struct _DevToConfig {
|
|
|
|
GDevRec GDev;
|
2012-03-21 20:55:09 +01:00
|
|
|
struct pci_device *pVideo;
|
2006-12-04 22:36:30 +01:00
|
|
|
#if (defined(__sparc__) || defined(__sparc)) && !defined(__OpenBSD__)
|
2003-11-14 17:48:57 +01:00
|
|
|
sbusDevicePtr sVideo;
|
|
|
|
#endif
|
|
|
|
int iDriver;
|
|
|
|
} DevToConfigRec, *DevToConfigPtr;
|
|
|
|
|
|
|
|
static DevToConfigPtr DevToConfig = NULL;
|
|
|
|
static int nDevToConfig = 0, CurrentDriver;
|
|
|
|
|
Rework symbol visibility for easier maintenance
Save in a few special cases, _X_EXPORT should not be used in C source
files. Instead, it should be used in headers, and the proper C source
include that header. Some special cases are symbols that need to be
shared between modules, but not expected to be used by external drivers,
and symbols that are accessible via LoaderSymbol/dlopen.
This patch also adds conditionally some new sdk header files, depending
on extensions enabled. These files were added to match pattern for
other extensions/modules, that is, have the headers "deciding" symbol
visibility in the sdk. These headers are:
o Xext/panoramiXsrv.h, Xext/panoramiX.h
o fbpict.h (unconditionally)
o vidmodeproc.h
o mioverlay.h (unconditionally, used only by xaa)
o xfixes.h (unconditionally, symbols required by dri2)
LoaderSymbol and similar functions now don't have different prototypes,
in loaderProcs.h and xf86Module.h, so that both headers can be included,
without the need of defining IN_LOADER.
xf86NewInputDevice() device prototype readded to xf86Xinput.h, but
not exported (and with a comment about it).
2008-12-03 08:43:34 +01:00
|
|
|
xf86MonPtr ConfiguredMonitor;
|
|
|
|
Bool xf86DoConfigurePass1 = TRUE;
|
2007-03-25 18:27:01 +02:00
|
|
|
static Bool foundMouse = FALSE;
|
2003-11-14 17:48:57 +01:00
|
|
|
|
2010-12-16 19:13:54 +01:00
|
|
|
#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
|
2011-11-08 04:19:47 +01:00
|
|
|
static const char *DFLT_MOUSE_DEV = "/dev/sysmouse";
|
|
|
|
static const char *DFLT_MOUSE_PROTO = "auto";
|
2006-08-17 22:22:07 +02:00
|
|
|
#elif defined(linux)
|
2011-11-08 04:19:47 +01:00
|
|
|
static const char *DFLT_MOUSE_DEV = "/dev/input/mice";
|
|
|
|
static const char *DFLT_MOUSE_PROTO = "auto";
|
2011-04-09 13:45:10 +02:00
|
|
|
#elif defined(WSCONS_SUPPORT)
|
2011-11-08 04:19:47 +01:00
|
|
|
static const char *DFLT_MOUSE_DEV = "/dev/wsmouse";
|
|
|
|
static const char *DFLT_MOUSE_PROTO = "wsmouse";
|
2003-11-14 17:48:57 +01:00
|
|
|
#else
|
2011-11-08 04:19:47 +01:00
|
|
|
static const char *DFLT_MOUSE_DEV = "/dev/mouse";
|
|
|
|
static const char *DFLT_MOUSE_PROTO = "auto";
|
2003-11-14 17:48:57 +01:00
|
|
|
#endif
|
|
|
|
|
2009-08-18 11:14:27 +02:00
|
|
|
/*
|
|
|
|
* This is called by the driver, either through xf86Match???Instances() or
|
|
|
|
* directly. We allocate a GDevRec and fill it in as much as we can, letting
|
|
|
|
* the caller fill in the rest and/or change it as it sees fit.
|
|
|
|
*/
|
|
|
|
GDevPtr
|
2012-03-21 20:55:09 +01:00
|
|
|
xf86AddBusDeviceToConfigure(const char *driver, BusType bus, void *busData,
|
|
|
|
int chipset)
|
2009-08-18 11:14:27 +02:00
|
|
|
{
|
|
|
|
int ret, i, j;
|
|
|
|
|
|
|
|
if (!xf86DoConfigure || !xf86DoConfigurePass1)
|
2012-03-21 20:55:09 +01:00
|
|
|
return NULL;
|
2009-08-18 11:14:27 +02:00
|
|
|
|
|
|
|
/* Check for duplicates */
|
2012-03-21 20:55:09 +01:00
|
|
|
for (i = 0; i < nDevToConfig; i++) {
|
2010-09-10 18:16:30 +02:00
|
|
|
switch (bus) {
|
2010-06-01 12:05:47 +02:00
|
|
|
#ifdef XSERVER_LIBPCIACCESS
|
2012-03-21 20:55:09 +01:00
|
|
|
case BUS_PCI:
|
|
|
|
ret = xf86PciConfigure(busData, DevToConfig[i].pVideo);
|
|
|
|
break;
|
2010-06-01 12:05:47 +02:00
|
|
|
#endif
|
2010-09-10 18:16:30 +02:00
|
|
|
#if (defined(__sparc__) || defined(__sparc)) && !defined(__OpenBSD__)
|
2012-03-21 20:55:09 +01:00
|
|
|
case BUS_SBUS:
|
|
|
|
ret = xf86SbusConfigure(busData, DevToConfig[i].sVideo);
|
|
|
|
break;
|
2010-09-10 18:16:30 +02:00
|
|
|
#endif
|
2012-03-21 20:55:09 +01:00
|
|
|
default:
|
|
|
|
return NULL;
|
2010-09-10 18:16:30 +02:00
|
|
|
}
|
|
|
|
if (ret == 0)
|
|
|
|
goto out;
|
2009-08-18 11:14:27 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate new structure occurrence */
|
|
|
|
i = nDevToConfig++;
|
|
|
|
DevToConfig =
|
2012-03-21 20:55:09 +01:00
|
|
|
xnfrealloc(DevToConfig, nDevToConfig * sizeof(DevToConfigRec));
|
2009-08-18 11:14:27 +02:00
|
|
|
memset(DevToConfig + i, 0, sizeof(DevToConfigRec));
|
|
|
|
|
2009-08-18 11:53:47 +02:00
|
|
|
DevToConfig[i].GDev.chipID =
|
2012-03-21 20:55:09 +01:00
|
|
|
DevToConfig[i].GDev.chipRev = DevToConfig[i].GDev.irq = -1;
|
2009-08-18 11:14:27 +02:00
|
|
|
|
2009-08-18 11:53:47 +02:00
|
|
|
DevToConfig[i].iDriver = CurrentDriver;
|
2009-08-18 11:14:27 +02:00
|
|
|
|
|
|
|
/* Fill in what we know, converting the driver name to lower case */
|
2009-08-18 11:53:47 +02:00
|
|
|
DevToConfig[i].GDev.driver = xnfalloc(strlen(driver) + 1);
|
2012-03-21 20:55:09 +01:00
|
|
|
for (j = 0; (DevToConfig[i].GDev.driver[j] = tolower(driver[j])); j++);
|
2009-08-18 11:14:27 +02:00
|
|
|
|
|
|
|
switch (bus) {
|
2010-06-01 12:05:47 +02:00
|
|
|
#ifdef XSERVER_LIBPCIACCESS
|
2012-03-21 20:55:09 +01:00
|
|
|
case BUS_PCI:
|
|
|
|
xf86PciConfigureNewDev(busData, DevToConfig[i].pVideo,
|
|
|
|
&DevToConfig[i].GDev, &chipset);
|
|
|
|
break;
|
2010-06-01 12:05:47 +02:00
|
|
|
#endif
|
2010-09-10 18:16:30 +02:00
|
|
|
#if (defined(__sparc__) || defined(__sparc)) && !defined(__OpenBSD__)
|
2012-03-21 20:55:09 +01:00
|
|
|
case BUS_SBUS:
|
|
|
|
xf86SbusConfigureNewDev(busData, DevToConfig[i].sVideo,
|
|
|
|
&DevToConfig[i].GDev);
|
|
|
|
break;
|
2010-09-10 18:16:30 +02:00
|
|
|
#endif
|
2012-03-21 20:55:09 +01:00
|
|
|
default:
|
|
|
|
break;
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Get driver's available options */
|
|
|
|
if (xf86DriverList[CurrentDriver]->AvailableOptions)
|
2012-03-21 20:55:09 +01:00
|
|
|
DevToConfig[i].GDev.options = (OptionInfoPtr)
|
|
|
|
(*xf86DriverList[CurrentDriver]->AvailableOptions) (chipset, bus);
|
2003-11-14 17:48:57 +01:00
|
|
|
|
2009-08-18 11:53:47 +02:00
|
|
|
return &DevToConfig[i].GDev;
|
2003-11-14 17:48:57 +01:00
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
out:
|
2009-08-18 11:14:27 +02:00
|
|
|
return NULL;
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static XF86ConfInputPtr
|
2012-03-21 20:55:09 +01:00
|
|
|
configureInputSection(void)
|
2003-11-14 17:48:57 +01:00
|
|
|
{
|
|
|
|
XF86ConfInputPtr mouse = NULL;
|
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
parsePrologue(XF86ConfInputPtr, XF86ConfInputRec)
|
|
|
|
|
|
|
|
ptr->inp_identifier = "Keyboard0";
|
2004-08-15 01:59:52 +02:00
|
|
|
ptr->inp_driver = "kbd";
|
2003-11-14 17:48:57 +01:00
|
|
|
ptr->list.next = NULL;
|
|
|
|
|
|
|
|
/* Crude mechanism to auto-detect mouse (os dependent) */
|
2012-03-21 20:55:09 +01:00
|
|
|
{
|
|
|
|
int fd;
|
2003-11-14 17:48:57 +01:00
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
fd = open(DFLT_MOUSE_DEV, 0);
|
|
|
|
if (fd != -1) {
|
|
|
|
foundMouse = TRUE;
|
|
|
|
close(fd);
|
|
|
|
}
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
|
2009-04-06 23:56:49 +02:00
|
|
|
mouse = calloc(1, sizeof(XF86ConfInputRec));
|
2003-11-14 17:48:57 +01:00
|
|
|
mouse->inp_identifier = "Mouse0";
|
|
|
|
mouse->inp_driver = "mouse";
|
2012-03-21 20:55:09 +01:00
|
|
|
mouse->inp_option_lst =
|
|
|
|
xf86addNewOption(mouse->inp_option_lst, strdup("Protocol"),
|
|
|
|
strdup(DFLT_MOUSE_PROTO));
|
|
|
|
mouse->inp_option_lst =
|
|
|
|
xf86addNewOption(mouse->inp_option_lst, strdup("Device"),
|
|
|
|
strdup(DFLT_MOUSE_DEV));
|
|
|
|
mouse->inp_option_lst =
|
|
|
|
xf86addNewOption(mouse->inp_option_lst, strdup("ZAxisMapping"),
|
|
|
|
strdup("4 5 6 7"));
|
|
|
|
ptr = (XF86ConfInputPtr) xf86addListItem((glp) ptr, (glp) mouse);
|
2003-11-14 17:48:57 +01:00
|
|
|
return ptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static XF86ConfScreenPtr
|
2012-03-21 20:55:09 +01:00
|
|
|
configureScreenSection(int screennum)
|
2003-11-14 17:48:57 +01:00
|
|
|
{
|
|
|
|
int i;
|
2012-03-21 20:55:09 +01:00
|
|
|
int depths[] = { 1, 4, 8, 15, 16, 24 /*, 32 */ };
|
|
|
|
parsePrologue(XF86ConfScreenPtr, XF86ConfScreenRec)
|
2003-11-14 17:48:57 +01:00
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
XNFasprintf(&ptr->scrn_identifier, "Screen%d", screennum);
|
2010-11-28 07:38:27 +01:00
|
|
|
XNFasprintf(&ptr->scrn_monitor_str, "Monitor%d", screennum);
|
|
|
|
XNFasprintf(&ptr->scrn_device_str, "Card%d", screennum);
|
2003-11-14 17:48:57 +01:00
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
for (i = 0; i < sizeof(depths) / sizeof(depths[0]); i++) {
|
|
|
|
XF86ConfDisplayPtr display;
|
|
|
|
|
|
|
|
display = calloc(1, sizeof(XF86ConfDisplayRec));
|
|
|
|
display->disp_depth = depths[i];
|
|
|
|
display->disp_black.red = display->disp_white.red = -1;
|
|
|
|
display->disp_black.green = display->disp_white.green = -1;
|
|
|
|
display->disp_black.blue = display->disp_white.blue = -1;
|
|
|
|
ptr->scrn_display_lst = (XF86ConfDisplayPtr) xf86addListItem((glp) ptr->
|
|
|
|
scrn_display_lst,
|
|
|
|
(glp)
|
|
|
|
display);
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return ptr;
|
|
|
|
}
|
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
static const char *
|
2010-05-20 02:26:56 +02:00
|
|
|
optionTypeToString(OptionValueType type)
|
2003-11-14 17:48:57 +01:00
|
|
|
{
|
|
|
|
switch (type) {
|
|
|
|
case OPTV_NONE:
|
|
|
|
return "";
|
|
|
|
case OPTV_INTEGER:
|
|
|
|
return "<i>";
|
|
|
|
case OPTV_STRING:
|
|
|
|
return "<str>";
|
|
|
|
case OPTV_ANYSTR:
|
2012-03-21 20:55:09 +01:00
|
|
|
return "[<str>]";
|
2003-11-14 17:48:57 +01:00
|
|
|
case OPTV_REAL:
|
|
|
|
return "<f>";
|
|
|
|
case OPTV_BOOLEAN:
|
|
|
|
return "[<bool>]";
|
|
|
|
case OPTV_FREQ:
|
|
|
|
return "<freq>";
|
2010-05-18 03:12:49 +02:00
|
|
|
case OPTV_PERCENT:
|
|
|
|
return "<percent>";
|
2003-11-14 17:48:57 +01:00
|
|
|
default:
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static XF86ConfDevicePtr
|
2012-03-21 20:55:09 +01:00
|
|
|
configureDeviceSection(int screennum)
|
2003-11-14 17:48:57 +01:00
|
|
|
{
|
|
|
|
OptionInfoPtr p;
|
|
|
|
int i = 0;
|
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
parsePrologue(XF86ConfDevicePtr, XF86ConfDeviceRec)
|
|
|
|
|
|
|
|
/* Move device info to parser structure */
|
|
|
|
if (asprintf(&ptr->dev_identifier, "Card%d", screennum) == -1)
|
2010-11-28 07:38:27 +01:00
|
|
|
ptr->dev_identifier = NULL;
|
2003-11-14 17:48:57 +01:00
|
|
|
ptr->dev_chipset = DevToConfig[screennum].GDev.chipset;
|
|
|
|
ptr->dev_busid = DevToConfig[screennum].GDev.busID;
|
|
|
|
ptr->dev_driver = DevToConfig[screennum].GDev.driver;
|
|
|
|
ptr->dev_ramdac = DevToConfig[screennum].GDev.ramdac;
|
2012-03-21 20:55:09 +01:00
|
|
|
for (i = 0; (i < MAXDACSPEEDS) && (i < CONF_MAXDACSPEEDS); i++)
|
2003-11-14 17:48:57 +01:00
|
|
|
ptr->dev_dacSpeeds[i] = DevToConfig[screennum].GDev.dacSpeeds[i];
|
|
|
|
ptr->dev_videoram = DevToConfig[screennum].GDev.videoRam;
|
|
|
|
ptr->dev_textclockfreq = DevToConfig[screennum].GDev.textClockFreq;
|
|
|
|
ptr->dev_bios_base = DevToConfig[screennum].GDev.BiosBase;
|
|
|
|
ptr->dev_mem_base = DevToConfig[screennum].GDev.MemBase;
|
|
|
|
ptr->dev_io_base = DevToConfig[screennum].GDev.IOBase;
|
|
|
|
ptr->dev_clockchip = DevToConfig[screennum].GDev.clockchip;
|
2012-03-21 20:55:09 +01:00
|
|
|
for (i = 0; (i < MAXCLOCKS) && (i < DevToConfig[screennum].GDev.numclocks);
|
|
|
|
i++)
|
2003-11-14 17:48:57 +01:00
|
|
|
ptr->dev_clock[i] = DevToConfig[screennum].GDev.clock[i];
|
|
|
|
ptr->dev_clocks = i;
|
|
|
|
ptr->dev_chipid = DevToConfig[screennum].GDev.chipID;
|
|
|
|
ptr->dev_chiprev = DevToConfig[screennum].GDev.chipRev;
|
|
|
|
ptr->dev_irq = DevToConfig[screennum].GDev.irq;
|
|
|
|
|
|
|
|
/* Make sure older drivers don't segv */
|
|
|
|
if (DevToConfig[screennum].GDev.options) {
|
2012-03-21 20:55:09 +01:00
|
|
|
/* Fill in the available driver options for people to use */
|
|
|
|
const char *descrip =
|
|
|
|
" ### Available Driver options are:-\n"
|
|
|
|
" ### Values: <i>: integer, <f>: float, "
|
|
|
|
"<bool>: \"True\"/\"False\",\n"
|
|
|
|
" ### <string>: \"String\", <freq>: \"<f> Hz/kHz/MHz\",\n"
|
|
|
|
" ### <percent>: \"<f>%\"\n"
|
|
|
|
" ### [arg]: arg optional\n";
|
|
|
|
ptr->dev_comment = strdup(descrip);
|
|
|
|
if (ptr->dev_comment) {
|
|
|
|
for (p = DevToConfig[screennum].GDev.options; p->name != NULL; p++) {
|
|
|
|
char *p_e;
|
|
|
|
const char *prefix = " #Option ";
|
|
|
|
const char *middle = " \t# ";
|
|
|
|
const char *suffix = "\n";
|
|
|
|
const char *opttype = optionTypeToString(p->type);
|
|
|
|
char *optname;
|
|
|
|
int len = strlen(ptr->dev_comment) + strlen(prefix) +
|
|
|
|
strlen(middle) + strlen(suffix) + 1;
|
|
|
|
|
|
|
|
if (asprintf(&optname, "\"%s\"", p->name) == -1)
|
|
|
|
break;
|
|
|
|
|
|
|
|
len += max(20, strlen(optname));
|
|
|
|
len += strlen(opttype);
|
|
|
|
|
|
|
|
ptr->dev_comment = realloc(ptr->dev_comment, len);
|
|
|
|
if (!ptr->dev_comment)
|
|
|
|
break;
|
|
|
|
p_e = ptr->dev_comment + strlen(ptr->dev_comment);
|
|
|
|
sprintf(p_e, "%s%-20s%s%s%s", prefix, optname, middle,
|
|
|
|
opttype, suffix);
|
|
|
|
free(optname);
|
|
|
|
}
|
|
|
|
}
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return ptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static XF86ConfLayoutPtr
|
2012-03-21 20:55:09 +01:00
|
|
|
configureLayoutSection(void)
|
2003-11-14 17:48:57 +01:00
|
|
|
{
|
|
|
|
int scrnum = 0;
|
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
parsePrologue(XF86ConfLayoutPtr, XF86ConfLayoutRec)
|
2003-11-14 17:48:57 +01:00
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
ptr->lay_identifier = "X.org Configured";
|
2003-11-14 17:48:57 +01:00
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
{
|
|
|
|
XF86ConfInputrefPtr iptr;
|
|
|
|
|
|
|
|
iptr = malloc(sizeof(XF86ConfInputrefRec));
|
|
|
|
iptr->list.next = NULL;
|
|
|
|
iptr->iref_option_lst = NULL;
|
|
|
|
iptr->iref_inputdev_str = "Mouse0";
|
|
|
|
iptr->iref_option_lst =
|
|
|
|
xf86addNewOption(iptr->iref_option_lst, strdup("CorePointer"),
|
|
|
|
NULL);
|
|
|
|
ptr->lay_input_lst = (XF86ConfInputrefPtr)
|
|
|
|
xf86addListItem((glp) ptr->lay_input_lst, (glp) iptr);
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2012-03-21 20:55:09 +01:00
|
|
|
XF86ConfInputrefPtr iptr;
|
|
|
|
|
|
|
|
iptr = malloc(sizeof(XF86ConfInputrefRec));
|
|
|
|
iptr->list.next = NULL;
|
|
|
|
iptr->iref_option_lst = NULL;
|
|
|
|
iptr->iref_inputdev_str = "Keyboard0";
|
|
|
|
iptr->iref_option_lst =
|
|
|
|
xf86addNewOption(iptr->iref_option_lst, strdup("CoreKeyboard"),
|
|
|
|
NULL);
|
|
|
|
ptr->lay_input_lst = (XF86ConfInputrefPtr)
|
|
|
|
xf86addListItem((glp) ptr->lay_input_lst, (glp) iptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (scrnum = 0; scrnum < nDevToConfig; scrnum++) {
|
|
|
|
XF86ConfAdjacencyPtr aptr;
|
|
|
|
|
|
|
|
aptr = malloc(sizeof(XF86ConfAdjacencyRec));
|
|
|
|
aptr->list.next = NULL;
|
|
|
|
aptr->adj_x = 0;
|
|
|
|
aptr->adj_y = 0;
|
|
|
|
aptr->adj_scrnum = scrnum;
|
|
|
|
XNFasprintf(&aptr->adj_screen_str, "Screen%d", scrnum);
|
|
|
|
if (scrnum == 0) {
|
|
|
|
aptr->adj_where = CONF_ADJ_ABSOLUTE;
|
|
|
|
aptr->adj_refscreen = NULL;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
aptr->adj_where = CONF_ADJ_RIGHTOF;
|
|
|
|
XNFasprintf(&aptr->adj_refscreen, "Screen%d", scrnum - 1);
|
|
|
|
}
|
|
|
|
ptr->lay_adjacency_lst =
|
|
|
|
(XF86ConfAdjacencyPtr) xf86addListItem((glp) ptr->lay_adjacency_lst,
|
|
|
|
(glp) aptr);
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return ptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static XF86ConfFlagsPtr
|
2012-03-21 20:55:09 +01:00
|
|
|
configureFlagsSection(void)
|
2003-11-14 17:48:57 +01:00
|
|
|
{
|
2012-03-21 20:55:09 +01:00
|
|
|
parsePrologue(XF86ConfFlagsPtr, XF86ConfFlagsRec)
|
2003-11-14 17:48:57 +01:00
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
return ptr;
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static XF86ConfModulePtr
|
2012-03-21 20:55:09 +01:00
|
|
|
configureModuleSection(void)
|
2003-11-14 17:48:57 +01:00
|
|
|
{
|
|
|
|
char **elist, **el;
|
2012-03-21 20:55:09 +01:00
|
|
|
|
2008-12-02 01:08:55 +01:00
|
|
|
/* Find the list of extension & font modules. */
|
2003-11-14 17:48:57 +01:00
|
|
|
const char *esubdirs[] = {
|
2012-03-21 20:55:09 +01:00
|
|
|
"extensions",
|
|
|
|
"fonts",
|
|
|
|
NULL
|
2003-11-14 17:48:57 +01:00
|
|
|
};
|
2012-03-21 20:55:09 +01:00
|
|
|
parsePrologue(XF86ConfModulePtr, XF86ConfModuleRec)
|
2003-11-14 17:48:57 +01:00
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
elist = LoaderListDirs(esubdirs, NULL);
|
2003-11-14 17:48:57 +01:00
|
|
|
if (elist) {
|
2012-03-21 20:55:09 +01:00
|
|
|
for (el = elist; *el; el++) {
|
|
|
|
XF86LoadPtr module;
|
|
|
|
|
|
|
|
module = calloc(1, sizeof(XF86LoadRec));
|
|
|
|
module->load_name = *el;
|
|
|
|
ptr->mod_load_lst = (XF86LoadPtr) xf86addListItem((glp) ptr->
|
|
|
|
mod_load_lst,
|
|
|
|
(glp) module);
|
|
|
|
}
|
|
|
|
free(elist);
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return ptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static XF86ConfFilesPtr
|
2012-03-21 20:55:09 +01:00
|
|
|
configureFilesSection(void)
|
2003-11-14 17:48:57 +01:00
|
|
|
{
|
2012-03-21 20:55:09 +01:00
|
|
|
parsePrologue(XF86ConfFilesPtr, XF86ConfFilesRec)
|
|
|
|
|
|
|
|
if (xf86ModulePath)
|
|
|
|
ptr->file_modulepath = strdup(xf86ModulePath);
|
|
|
|
if (defaultFontPath)
|
|
|
|
ptr->file_fontpath = strdup(defaultFontPath);
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
return ptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static XF86ConfMonitorPtr
|
2012-03-21 20:55:09 +01:00
|
|
|
configureMonitorSection(int screennum)
|
2003-11-14 17:48:57 +01:00
|
|
|
{
|
2012-03-21 20:55:09 +01:00
|
|
|
parsePrologue(XF86ConfMonitorPtr, XF86ConfMonitorRec)
|
2003-11-14 17:48:57 +01:00
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
XNFasprintf(&ptr->mon_identifier, "Monitor%d", screennum);
|
2003-11-14 17:48:57 +01:00
|
|
|
ptr->mon_vendor = strdup("Monitor Vendor");
|
|
|
|
ptr->mon_modelname = strdup("Monitor Model");
|
|
|
|
|
|
|
|
return ptr;
|
|
|
|
}
|
|
|
|
|
2009-02-18 10:41:26 +01:00
|
|
|
/* Initialize Configure Monitor from Detailed Timing Block */
|
2012-03-21 20:55:09 +01:00
|
|
|
static void
|
|
|
|
handle_detailed_input(struct detailed_monitor_section *det_mon, void *data)
|
2009-02-18 10:41:26 +01:00
|
|
|
{
|
|
|
|
XF86ConfMonitorPtr ptr = (XF86ConfMonitorPtr) data;
|
|
|
|
|
|
|
|
switch (det_mon->type) {
|
|
|
|
case DS_NAME:
|
|
|
|
ptr->mon_modelname = realloc(ptr->mon_modelname,
|
2012-03-21 20:55:09 +01:00
|
|
|
strlen((char *) (det_mon->section.name)) +
|
2009-02-18 10:41:26 +01:00
|
|
|
1);
|
2012-03-21 20:55:09 +01:00
|
|
|
strcpy(ptr->mon_modelname, (char *) (det_mon->section.name));
|
2009-02-18 10:41:26 +01:00
|
|
|
break;
|
|
|
|
case DS_RANGES:
|
2012-03-21 20:55:09 +01:00
|
|
|
ptr->mon_hsync[ptr->mon_n_hsync].lo = det_mon->section.ranges.min_h;
|
|
|
|
ptr->mon_hsync[ptr->mon_n_hsync].hi = det_mon->section.ranges.max_h;
|
2009-02-18 10:41:26 +01:00
|
|
|
ptr->mon_n_vrefresh = 1;
|
2012-03-21 20:55:09 +01:00
|
|
|
ptr->mon_vrefresh[ptr->mon_n_hsync].lo = det_mon->section.ranges.min_v;
|
|
|
|
ptr->mon_vrefresh[ptr->mon_n_hsync].hi = det_mon->section.ranges.max_v;
|
2009-02-18 10:41:26 +01:00
|
|
|
ptr->mon_n_hsync++;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-11-14 17:48:57 +01:00
|
|
|
static XF86ConfMonitorPtr
|
2012-03-21 20:55:09 +01:00
|
|
|
configureDDCMonitorSection(int screennum)
|
2003-11-14 17:48:57 +01:00
|
|
|
{
|
|
|
|
int len, mon_width, mon_height;
|
2012-03-21 20:55:09 +01:00
|
|
|
|
2003-11-14 17:48:57 +01:00
|
|
|
#define displaySizeMaxLen 80
|
|
|
|
char displaySize_string[displaySizeMaxLen];
|
|
|
|
int displaySizeLen;
|
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
parsePrologue(XF86ConfMonitorPtr, XF86ConfMonitorRec)
|
2003-11-14 17:48:57 +01:00
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
XNFasprintf(&ptr->mon_identifier, "Monitor%d", screennum);
|
2003-11-14 17:48:57 +01:00
|
|
|
ptr->mon_vendor = strdup(ConfiguredMonitor->vendor.name);
|
2010-11-28 07:38:27 +01:00
|
|
|
XNFasprintf(&ptr->mon_modelname, "%x", ConfiguredMonitor->vendor.prod_id);
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
/* features in centimetres, we want millimetres */
|
2012-03-21 20:55:09 +01:00
|
|
|
mon_width = 10 * ConfiguredMonitor->features.hsize;
|
|
|
|
mon_height = 10 * ConfiguredMonitor->features.vsize;
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
#ifdef CONFIGURE_DISPLAYSIZE
|
2012-03-21 20:55:09 +01:00
|
|
|
ptr->mon_width = mon_width;
|
2003-11-14 17:48:57 +01:00
|
|
|
ptr->mon_height = mon_height;
|
|
|
|
#else
|
|
|
|
if (mon_width && mon_height) {
|
2012-03-21 20:55:09 +01:00
|
|
|
/* when values available add DisplaySize option AS A COMMENT */
|
|
|
|
|
|
|
|
displaySizeLen = snprintf(displaySize_string, displaySizeMaxLen,
|
|
|
|
"\t#DisplaySize\t%5d %5d\t# mm\n",
|
|
|
|
mon_width, mon_height);
|
|
|
|
|
|
|
|
if (displaySizeLen > 0 && displaySizeLen < displaySizeMaxLen) {
|
|
|
|
if (ptr->mon_comment) {
|
|
|
|
len = strlen(ptr->mon_comment);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
len = 0;
|
|
|
|
}
|
|
|
|
if ((ptr->mon_comment =
|
|
|
|
realloc(ptr->mon_comment,
|
|
|
|
len + strlen(displaySize_string) + 1))) {
|
|
|
|
strcpy(ptr->mon_comment + len, displaySize_string);
|
|
|
|
}
|
|
|
|
}
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
2012-03-21 20:55:09 +01:00
|
|
|
#endif /* def CONFIGURE_DISPLAYSIZE */
|
2003-11-14 17:48:57 +01:00
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
xf86ForEachDetailedBlock(ConfiguredMonitor, handle_detailed_input, ptr);
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
if (ConfiguredMonitor->features.dpms) {
|
2012-03-21 20:55:09 +01:00
|
|
|
ptr->mon_option_lst =
|
|
|
|
xf86addNewOption(ptr->mon_option_lst, strdup("DPMS"), NULL);
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return ptr;
|
|
|
|
}
|
|
|
|
|
Rework symbol visibility for easier maintenance
Save in a few special cases, _X_EXPORT should not be used in C source
files. Instead, it should be used in headers, and the proper C source
include that header. Some special cases are symbols that need to be
shared between modules, but not expected to be used by external drivers,
and symbols that are accessible via LoaderSymbol/dlopen.
This patch also adds conditionally some new sdk header files, depending
on extensions enabled. These files were added to match pattern for
other extensions/modules, that is, have the headers "deciding" symbol
visibility in the sdk. These headers are:
o Xext/panoramiXsrv.h, Xext/panoramiX.h
o fbpict.h (unconditionally)
o vidmodeproc.h
o mioverlay.h (unconditionally, used only by xaa)
o xfixes.h (unconditionally, symbols required by dri2)
LoaderSymbol and similar functions now don't have different prototypes,
in loaderProcs.h and xf86Module.h, so that both headers can be included,
without the need of defining IN_LOADER.
xf86NewInputDevice() device prototype readded to xf86Xinput.h, but
not exported (and with a comment about it).
2008-12-03 08:43:34 +01:00
|
|
|
void
|
2008-11-25 05:34:46 +01:00
|
|
|
DoConfigure(void)
|
2003-11-14 17:48:57 +01:00
|
|
|
{
|
2012-03-21 20:55:09 +01:00
|
|
|
int i, j, screennum = -1;
|
2011-11-08 04:19:47 +01:00
|
|
|
const char *home = NULL;
|
2008-11-25 05:34:46 +01:00
|
|
|
char filename[PATH_MAX];
|
2011-11-08 04:19:47 +01:00
|
|
|
const char *addslash = "";
|
2003-11-14 17:48:57 +01:00
|
|
|
XF86ConfigPtr xf86config = NULL;
|
|
|
|
char **vlist, **vl;
|
|
|
|
int *dev2screen;
|
|
|
|
|
|
|
|
vlist = xf86DriverlistFromCompile();
|
|
|
|
|
|
|
|
if (!vlist) {
|
2012-03-21 20:55:09 +01:00
|
|
|
ErrorF("Missing output drivers. Configuration failed.\n");
|
|
|
|
goto bail;
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
ErrorF("List of video drivers:\n");
|
|
|
|
for (vl = vlist; *vl; vl++)
|
2012-03-21 20:55:09 +01:00
|
|
|
ErrorF("\t%s\n", *vl);
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
/* Load all the drivers that were found. */
|
|
|
|
xf86LoadModules(vlist, NULL);
|
|
|
|
|
2010-05-05 20:44:06 +02:00
|
|
|
free(vlist);
|
2003-11-14 17:48:57 +01:00
|
|
|
|
2012-06-26 20:32:31 +02:00
|
|
|
xorgHWAccess = xf86EnableIO();
|
2005-01-28 17:13:00 +01:00
|
|
|
|
2003-11-14 17:48:57 +01:00
|
|
|
/* Create XF86Config file structure */
|
2008-10-06 21:36:51 +02:00
|
|
|
xf86config = calloc(1, sizeof(XF86ConfigRec));
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
/* Call all of the probe functions, reporting the results. */
|
2012-03-21 20:55:09 +01:00
|
|
|
for (CurrentDriver = 0; CurrentDriver < xf86NumDrivers; CurrentDriver++) {
|
|
|
|
Bool found_screen;
|
|
|
|
DriverRec *const drv = xf86DriverList[CurrentDriver];
|
|
|
|
|
|
|
|
found_screen = xf86CallDriverProbe(drv, TRUE);
|
|
|
|
if (found_screen && drv->Identify) {
|
|
|
|
(*drv->Identify) (0);
|
|
|
|
}
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (nDevToConfig <= 0) {
|
2012-03-21 20:55:09 +01:00
|
|
|
ErrorF("No devices to configure. Configuration failed.\n");
|
|
|
|
goto bail;
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Add device, monitor and screen sections for detected devices */
|
2012-03-21 20:55:09 +01:00
|
|
|
for (screennum = 0; screennum < nDevToConfig; screennum++) {
|
|
|
|
XF86ConfDevicePtr DevicePtr;
|
|
|
|
XF86ConfMonitorPtr MonitorPtr;
|
|
|
|
XF86ConfScreenPtr ScreenPtr;
|
|
|
|
|
|
|
|
DevicePtr = configureDeviceSection(screennum);
|
|
|
|
xf86config->conf_device_lst = (XF86ConfDevicePtr) xf86addListItem((glp)
|
|
|
|
xf86config->
|
|
|
|
conf_device_lst,
|
|
|
|
(glp)
|
|
|
|
DevicePtr);
|
|
|
|
MonitorPtr = configureMonitorSection(screennum);
|
|
|
|
xf86config->conf_monitor_lst = (XF86ConfMonitorPtr) xf86addListItem((glp) xf86config->conf_monitor_lst, (glp) MonitorPtr);
|
|
|
|
ScreenPtr = configureScreenSection(screennum);
|
|
|
|
xf86config->conf_screen_lst = (XF86ConfScreenPtr) xf86addListItem((glp)
|
|
|
|
xf86config->
|
|
|
|
conf_screen_lst,
|
|
|
|
(glp)
|
|
|
|
ScreenPtr);
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
xf86config->conf_files = configureFilesSection();
|
|
|
|
xf86config->conf_modules = configureModuleSection();
|
|
|
|
xf86config->conf_flags = configureFlagsSection();
|
2007-02-07 02:44:34 +01:00
|
|
|
xf86config->conf_videoadaptor_lst = NULL;
|
|
|
|
xf86config->conf_modes_lst = NULL;
|
|
|
|
xf86config->conf_vendor_lst = NULL;
|
|
|
|
xf86config->conf_dri = NULL;
|
2003-11-14 17:48:57 +01:00
|
|
|
xf86config->conf_input_lst = configureInputSection();
|
|
|
|
xf86config->conf_layout_lst = configureLayoutSection();
|
|
|
|
|
2008-11-25 05:34:46 +01:00
|
|
|
home = getenv("HOME");
|
2008-11-25 05:37:58 +01:00
|
|
|
if ((home == NULL) || (home[0] == '\0')) {
|
2012-03-21 20:55:09 +01:00
|
|
|
home = "/";
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* Determine if trailing slash is present or needed */
|
|
|
|
int l = strlen(home);
|
2008-11-25 05:34:46 +01:00
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
if (home[l - 1] != '/') {
|
|
|
|
addslash = "/";
|
|
|
|
}
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
|
2008-11-25 05:34:46 +01:00
|
|
|
snprintf(filename, sizeof(filename), "%s%s" XF86CONFIGFILE ".new",
|
2012-03-21 20:55:09 +01:00
|
|
|
home, addslash);
|
2008-11-25 05:34:46 +01:00
|
|
|
|
2009-02-13 03:34:22 +01:00
|
|
|
if (xf86writeConfigFile(filename, xf86config) == 0) {
|
2012-03-21 20:55:09 +01:00
|
|
|
xf86Msg(X_ERROR, "Unable to write config file: \"%s\": %s\n",
|
|
|
|
filename, strerror(errno));
|
|
|
|
goto bail;
|
2009-02-13 03:34:22 +01:00
|
|
|
}
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
xf86DoConfigurePass1 = FALSE;
|
|
|
|
/* Try to get DDC information filled in */
|
|
|
|
xf86ConfigFile = filename;
|
2003-11-25 20:29:01 +01:00
|
|
|
if (xf86HandleConfigFile(FALSE) != CONFIG_OK) {
|
2012-03-21 20:55:09 +01:00
|
|
|
goto bail;
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
xf86DoConfigurePass1 = FALSE;
|
2012-03-21 20:55:09 +01:00
|
|
|
|
|
|
|
dev2screen = xnfcalloc(1, xf86NumDrivers * sizeof(int));
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
{
|
2012-03-21 20:55:09 +01:00
|
|
|
Bool *driverProbed = xnfcalloc(1, xf86NumDrivers * sizeof(Bool));
|
|
|
|
|
|
|
|
for (screennum = 0; screennum < nDevToConfig; screennum++) {
|
|
|
|
int k, l, n, oldNumScreens;
|
|
|
|
|
|
|
|
i = DevToConfig[screennum].iDriver;
|
|
|
|
|
|
|
|
if (driverProbed[i])
|
|
|
|
continue;
|
|
|
|
driverProbed[i] = TRUE;
|
|
|
|
|
|
|
|
oldNumScreens = xf86NumScreens;
|
|
|
|
|
|
|
|
xf86CallDriverProbe(xf86DriverList[i], FALSE);
|
|
|
|
|
|
|
|
/* reorder */
|
|
|
|
k = screennum > 0 ? screennum : 1;
|
|
|
|
for (l = oldNumScreens; l < xf86NumScreens; l++) {
|
|
|
|
/* is screen primary? */
|
|
|
|
Bool primary = FALSE;
|
|
|
|
|
|
|
|
for (n = 0; n < xf86Screens[l]->numEntities; n++) {
|
|
|
|
if (xf86IsEntityPrimary(xf86Screens[l]->entityList[n])) {
|
|
|
|
dev2screen[0] = l;
|
|
|
|
primary = TRUE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (primary)
|
|
|
|
continue;
|
|
|
|
/* not primary: assign it to next device of same driver */
|
|
|
|
/*
|
|
|
|
* NOTE: we assume that devices in DevToConfig
|
|
|
|
* and xf86Screens[] have the same order except
|
|
|
|
* for the primary device which always comes first.
|
|
|
|
*/
|
|
|
|
for (; k < nDevToConfig; k++) {
|
|
|
|
if (DevToConfig[k].iDriver == i) {
|
|
|
|
dev2screen[k++] = l;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free(driverProbed);
|
|
|
|
}
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
if (nDevToConfig != xf86NumScreens) {
|
2012-03-21 20:55:09 +01:00
|
|
|
ErrorF("Number of created screens does not match number of detected"
|
|
|
|
" devices.\n Configuration failed.\n");
|
|
|
|
goto bail;
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
xf86PostProbe();
|
|
|
|
|
|
|
|
for (j = 0; j < xf86NumScreens; j++) {
|
2012-03-21 20:55:09 +01:00
|
|
|
xf86Screens[j]->scrnIndex = j;
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
xf86freeMonitorList(xf86config->conf_monitor_lst);
|
|
|
|
xf86config->conf_monitor_lst = NULL;
|
|
|
|
xf86freeScreenList(xf86config->conf_screen_lst);
|
|
|
|
xf86config->conf_screen_lst = NULL;
|
|
|
|
for (j = 0; j < xf86NumScreens; j++) {
|
2012-03-21 20:55:09 +01:00
|
|
|
XF86ConfMonitorPtr MonitorPtr;
|
|
|
|
XF86ConfScreenPtr ScreenPtr;
|
2003-11-14 17:48:57 +01:00
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
ConfiguredMonitor = NULL;
|
2003-11-14 17:48:57 +01:00
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
if ((*xf86Screens[dev2screen[j]]->PreInit) (xf86Screens[dev2screen[j]],
|
|
|
|
PROBE_DETECT) &&
|
|
|
|
ConfiguredMonitor) {
|
|
|
|
MonitorPtr = configureDDCMonitorSection(j);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
MonitorPtr = configureMonitorSection(j);
|
|
|
|
}
|
|
|
|
ScreenPtr = configureScreenSection(j);
|
|
|
|
|
|
|
|
xf86config->conf_monitor_lst = (XF86ConfMonitorPtr) xf86addListItem((glp) xf86config->conf_monitor_lst, (glp) MonitorPtr);
|
|
|
|
xf86config->conf_screen_lst = (XF86ConfScreenPtr) xf86addListItem((glp)
|
|
|
|
xf86config->
|
|
|
|
conf_screen_lst,
|
|
|
|
(glp)
|
|
|
|
ScreenPtr);
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
|
2009-02-13 03:34:22 +01:00
|
|
|
if (xf86writeConfigFile(filename, xf86config) == 0) {
|
2012-03-21 20:55:09 +01:00
|
|
|
xf86Msg(X_ERROR, "Unable to write config file: \"%s\": %s\n",
|
|
|
|
filename, strerror(errno));
|
|
|
|
goto bail;
|
2009-02-13 03:34:22 +01:00
|
|
|
}
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
ErrorF("\n");
|
|
|
|
|
|
|
|
if (!foundMouse) {
|
2012-03-21 20:55:09 +01:00
|
|
|
ErrorF("\n" __XSERVERNAME__ " is not able to detect your mouse.\n"
|
|
|
|
"Edit the file and correct the Device.\n");
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
ErrorF("\n" __XSERVERNAME__ " detected your mouse at device %s.\n"
|
|
|
|
"Please check your config if the mouse is still not\n"
|
|
|
|
"operational, as by default " __XSERVERNAME__
|
|
|
|
" tries to autodetect\n" "the protocol.\n", DFLT_MOUSE_DEV);
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (xf86NumScreens > 1) {
|
2012-03-21 20:55:09 +01:00
|
|
|
ErrorF("\n" __XSERVERNAME__
|
|
|
|
" has configured a multihead system, please check your config.\n");
|
2003-11-14 17:48:57 +01:00
|
|
|
}
|
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
ErrorF("\nYour %s file is %s\n\n", XF86CONFIGFILE, filename);
|
2004-05-24 21:05:01 +02:00
|
|
|
ErrorF("To test the server, run 'X -config %s'\n\n", filename);
|
2003-11-14 17:48:57 +01:00
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
bail:
|
2003-11-25 20:29:01 +01:00
|
|
|
OsCleanup(TRUE);
|
2011-07-20 05:09:05 +02:00
|
|
|
AbortDDX(EXIT_ERR_CONFIGURE);
|
2003-11-14 17:48:57 +01:00
|
|
|
fflush(stderr);
|
|
|
|
exit(0);
|
|
|
|
}
|
2011-11-04 06:13:05 +01:00
|
|
|
|
|
|
|
/* Xorg -showopts:
|
|
|
|
* For each driver module installed, print out the list
|
|
|
|
* of options and their argument types, then exit
|
|
|
|
*
|
|
|
|
* Author: Marcus Schaefer, ms@suse.de
|
|
|
|
*/
|
|
|
|
|
2012-03-21 20:55:09 +01:00
|
|
|
void
|
|
|
|
DoShowOptions(void)
|
|
|
|
{
|
|
|
|
int i = 0;
|
|
|
|
char **vlist = 0;
|
|
|
|
char *pSymbol = 0;
|
|
|
|
XF86ModuleData *initData = 0;
|
|
|
|
|
|
|
|
if (!(vlist = xf86DriverlistFromCompile())) {
|
|
|
|
ErrorF("Missing output drivers\n");
|
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
xf86LoadModules(vlist, 0);
|
|
|
|
free(vlist);
|
|
|
|
for (i = 0; i < xf86NumDrivers; i++) {
|
|
|
|
if (xf86DriverList[i]->AvailableOptions) {
|
|
|
|
const OptionInfoRec *pOption =
|
|
|
|
(*xf86DriverList[i]->AvailableOptions) (0, 0);
|
|
|
|
if (!pOption) {
|
|
|
|
ErrorF("(EE) Couldn't read option table for %s driver\n",
|
|
|
|
xf86DriverList[i]->driverName);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
XNFasprintf(&pSymbol, "%sModuleData",
|
|
|
|
xf86DriverList[i]->driverName);
|
|
|
|
initData = LoaderSymbol(pSymbol);
|
|
|
|
if (initData) {
|
|
|
|
XF86ModuleVersionInfo *vers = initData->vers;
|
|
|
|
const OptionInfoRec *p;
|
|
|
|
|
|
|
|
ErrorF("Driver[%d]:%s[%s] {\n",
|
|
|
|
i, xf86DriverList[i]->driverName, vers->vendor);
|
|
|
|
for (p = pOption; p->name != NULL; p++) {
|
|
|
|
ErrorF("\t%s:%s\n", p->name, optionTypeToString(p->type));
|
|
|
|
}
|
|
|
|
ErrorF("}\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
bail:
|
|
|
|
OsCleanup(TRUE);
|
|
|
|
AbortDDX(EXIT_ERR_DRIVERS);
|
|
|
|
fflush(stderr);
|
|
|
|
exit(0);
|
2011-11-04 06:13:05 +01:00
|
|
|
}
|