[fireglload.git] / main.c

/*
 * fireglload
 * (C) notaz, 2014
 *
 * This work is licensed under the terms of 3-clause BSD license.
 * See COPYING file in the top-level directory.
 */

#include <stdio.h>
#include <dlfcn.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <time.h>

#include <pciaccess.h>

#include <xorg/xf86.h>
#include <xorg/xf86Module.h>
#include <xorg/xf86str.h>

#if 0
#define TRACE(f, ...) \
	fprintf(stderr, ". %s " f, __FUNCTION__, ##__VA_ARGS__)
#define NI() \
	fprintf(stderr, "NI: %s\n", __FUNCTION__)
#else
#define TRACE(...)
#define NI()
#endif

#ifndef _X_EXPORT
#define _X_EXPORT      __attribute__((visibility("default")))
#endif

static GDevRec drec;

#ifdef DIX_H
_X_EXPORT ClientPtr clients[MAXCLIENTS];
_X_EXPORT ScreenInfo screenInfo;
_X_EXPORT ClientPtr serverClient;
#else
#define MAXCLIENTS      256
_X_EXPORT void *clients[MAXCLIENTS];
_X_EXPORT long screenInfo[16]; // ScreenInfo
_X_EXPORT void *serverClient;
#endif
#ifdef _XF86_H
_X_EXPORT ScrnInfoPtr *xf86Screens;
_X_EXPORT confDRIRec xf86ConfigDRI;
#else
_X_EXPORT void *xf86Screens;
_X_EXPORT long xf86ConfigDRI[4]; // confDRIRec
#endif
_X_EXPORT int PanoramiXNumScreens;
_X_EXPORT long inputInfo[16]; // InputInfo
_X_EXPORT unsigned long globalSerialNumber = 0;
_X_EXPORT unsigned long serverGeneration = 0;
_X_EXPORT int noPanoramiXExtension;
_X_EXPORT int noRRExtension;
_X_EXPORT int noCompositeExtension;
_X_EXPORT int noRenderExtension;
_X_EXPORT char dispatchException;
_X_EXPORT void *xf86DriverList;
_X_EXPORT int xf86NumDrivers;
_X_EXPORT void *xf86configptr;
_X_EXPORT int xf86DefaultModes[1024]; // DisplayModeRec[]
_X_EXPORT int xf86Info[64]; // xf86InfoRec
_X_EXPORT int xf86Initialising;
_X_EXPORT int XRT_WINDOW;
_X_EXPORT int monitorResolution;
_X_EXPORT int DPMSEnabled;
#define SCREEN_SAVER_OFF  1
_X_EXPORT int screenIsSaved = SCREEN_SAVER_OFF;

#ifndef _XF86_H
_X_EXPORT void xf86DrvMsg(int scrnIndex, MessageType type, const char *format, ...);
_X_EXPORT Bool xf86LoaderCheckSymbol(const char *name);
_X_EXPORT void xf86AddDriver(DriverPtr driver, pointer module, int flags);
#endif
_X_EXPORT void GetSpritePosition(struct _DeviceIntRec*, int *, int *);
_X_EXPORT int xf86LoadKernelModule(const char *pathname);

// don't delete my globals..
extern void ddmg(void *g);

static void __attribute__((constructor)) ddmg_hack(void)
{
	ddmg(&clients);
	ddmg(&PanoramiXNumScreens);
	ddmg(&inputInfo);
	ddmg(&screenInfo);
	ddmg(&globalSerialNumber);
	ddmg(&serverGeneration);
	ddmg(&noPanoramiXExtension);
	ddmg(&noRRExtension);
	ddmg(&noCompositeExtension);
	ddmg(&noRenderExtension);
	ddmg(&dispatchException);
	ddmg(&xf86Screens);
	ddmg(&xf86DriverList);
	ddmg(&xf86NumDrivers);
	ddmg(&xf86configptr);
	ddmg(&xf86DefaultModes);
	ddmg(&xf86Info);
	ddmg(&xf86ConfigDRI);
	ddmg(&xf86Initialising);
	ddmg(&serverClient);
	ddmg(&XRT_WINDOW);
	ddmg(&monitorResolution);
	ddmg(&DPMSEnabled);
	ddmg(&screenIsSaved);

	ddmg(&LoadSubModule);
	ddmg(&LoaderSymbol);
	ddmg(&xf86LoaderCheckSymbol);
	ddmg(&xf86DrvMsg);
	ddmg(&xf86VDrvMsgVerb);
	ddmg(&xf86Msg);
	ddmg(&xf86MsgVerb);
	ddmg(&xf86AddDriver);
	ddmg(&GetSpritePosition);
	ddmg(&XNFalloc);
	ddmg(&XNFcalloc);
	ddmg(&XNFrealloc);
	ddmg(&xf86MatchDevice);
	ddmg(&xf86LoadKernelModule);
	ddmg(&xf86MatchPciInstances);
	ddmg(&xf86CheckPciSlot);
	ddmg(&xf86ConfigPciEntity);
	ddmg(&xf86ComparePciBusString);
	ddmg(&xf86ClaimPciSlot);
	ddmg(&xf86GetPciInfoForEntity);
	ddmg(&xf86GetEntityInfo);
	ddmg(&xf86AllocateEntityPrivateIndex);
	ddmg(&xf86GetEntityPrivate);
	ddmg(&xf86SetEntitySharable);
	ddmg(&xf86GetNumEntityInstances);
	ddmg(&xf86GetDevFromEntity);
	ddmg(&xf86AddBusDeviceToConfigure);
	ddmg(&GetTimeInMillis);
	ddmg(&xf86GetOptValBool);
}

#define MAKE_FUNC(name) \
int _X_EXPORT name() \
{ \
	NI(); \
	return 0; \
} \
static void __attribute__((constructor)) c_##name(void) \
{ \
	ddmg(&name); \
}

MAKE_FUNC(xf86SetDGAMode)
MAKE_FUNC(GetSpriteCursor)
MAKE_FUNC(StandardMinorOpcode)

void
GetSpritePosition(struct _DeviceIntRec *pDev, int *px, int *py)
{
	NI();
}

pointer
LoadSubModule(pointer _parent, const char *module,
              const char **subdirlist, const char **patternlist,
              pointer options, const XF86ModReqInfo * modreq,
              int *errmaj, int *errmin)
{
	void *ret;

	printf("LoadSubModule '%s'\n", module);

	if (module && strstr(module, "fglrxdrm"))
		module = "/usr/lib/xorg/modules/linux/libfglrxdrm.so";
	ret = dlopen(module, RTLD_LAZY | RTLD_GLOBAL);
	if (ret == NULL)
		fprintf(stderr, "LoadSubModule dlopen: %s\n", dlerror());

	return ret;
}

void *
LoaderSymbol(const char *name)
{
	void *ret = dlsym(NULL, name);
	TRACE("'%s' %p\n", name, ret);
	return ret;
}

Bool
xf86LoaderCheckSymbol(const char *name)
{
	Bool ret;

	ret = (dlsym(NULL, name) != NULL);
	TRACE("'%s' %d\n", name, ret);
	return ret;
}

int
xf86MatchDevice(const char *drivername, GDevPtr **sectlist)
{
	GDevRec **list;

	TRACE("'%s' %p\n", drivername, sectlist);

	if (sectlist == NULL)
		goto out;

	*sectlist = NULL;
	list = malloc(2 * sizeof(list[0]));
	if (list == NULL)
		return 0;
	list[0] = &drec;
	list[1] = NULL;
	*sectlist = list;

out:
	return 1;
}

int
xf86MatchPciInstances(const char *driverName, int vendorID,
                      SymTabPtr chipsets, PciChipsets *PCIchipsets,
                      GDevPtr *devList, int numDevs, DriverPtr drvp,
                      int **foundEntities)
{
	TRACE("'%s' %04x %p %p %p %d %p %p\n",
		driverName, vendorID, chipsets, PCIchipsets, devList, numDevs,
		drvp, foundEntities);

	*foundEntities = malloc(sizeof(int));
	if (*foundEntities == NULL)
		return 0;

	(*foundEntities)[0] = 0;
	return 1;
}

GDevPtr
xf86AddBusDeviceToConfigure(const char *driver, BusType bus, void *busData, int chipset)
{
	struct pci_device *pci = busData;

	TRACE("'%s' %d %p %d\n", driver, bus, busData, chipset);

	drec.driver = strdup(driver);
	drec.identifier = strdup("fake_dev");
	drec.busID = malloc(64);
	snprintf(drec.busID, 64, "PCI:%d:%d:%d", pci->bus, pci->dev, pci->func);
	drec.chipID = pci->device_id;
	drec.chipRev = pci->revision;
	drec.irq = -1;

	drec.myScreenSection = calloc(1, sizeof(*drec.myScreenSection));

	TRACE("ret busID '%s'\n", drec.busID);
	return &drec;
}

Bool
xf86CheckPciSlot(const struct pci_device *d)
{
	TRACE("%p\n", d);
	return TRUE;
}

ScrnInfoPtr
xf86ConfigPciEntity(ScrnInfoPtr pScrn, int scrnFlag, int entityIndex,
                          PciChipsets *p_chip, void *dummy, EntityProc init,
                          EntityProc enter, EntityProc leave, pointer private)
{
	ScrnInfoPtr screen;

	TRACE("%p %x %d %p %p %p %p %p %p\n",
		pScrn, scrnFlag, entityIndex, p_chip, dummy, init,
		enter, leave, private);

	screen = calloc(1, sizeof(*screen));
	screen->entityList = calloc(1, sizeof(screen->entityList[0]));
	screen->numEntities = 1;
	// used by atiddxIsCrossDisplay_3
	screen->confScreen = calloc(1, sizeof(*screen->confScreen));

	xf86Screens = calloc(2, sizeof(xf86Screens[0]));
	return (xf86Screens[0] = screen);
}

Bool
xf86ComparePciBusString(const char *busID, int bus, int device, int func)
{
	TRACE("'%s' %d:%d:%d\n", busID, bus, device, func);
	return TRUE;
}

static struct pci_device *cur_pci_dev;

int
xf86ClaimPciSlot(struct pci_device *d, DriverPtr drvp,
                 int chipset, GDevPtr dev, Bool active)
{
	TRACE("%p %p %d %p %d\n", d, drvp, chipset, dev, active);
	cur_pci_dev = d;

	return 0;
}

struct pci_device *
xf86GetPciInfoForEntity(int entityIndex)
{
	TRACE("%d\n", entityIndex);

	return cur_pci_dev;
}

EntityInfoPtr
xf86GetEntityInfo(int entityIndex)
{
	EntityInfoRec *ret;

	TRACE("%d\n", entityIndex);

	ret = calloc(1, sizeof(*ret));
	ret->device = &drec;
	ret->location.id.pci = cur_pci_dev;

	return ret;
}

static int numprivs;
static DevUnion *privs;

int
xf86AllocateEntityPrivateIndex(void)
{
	int ret;

	ret = numprivs++;
	TRACE("numprivs=%d\n", numprivs);

	privs = realloc(privs, numprivs * sizeof(DevUnion));
	return ret;
}

DevUnion *
xf86GetEntityPrivate(int entityIndex, int privIndex)
{
	DevUnion *ret = NULL;

	if (entityIndex != 0 || (unsigned int)privIndex > (unsigned int)numprivs)
		ret = NULL;
	else
		ret = &privs[privIndex];

	TRACE("%d %d; ret=%p\n", entityIndex, privIndex, ret);
	return ret;
}

void
xf86SetEntitySharable(int entityIndex)
{
	TRACE("%d\n", entityIndex);
}

int
xf86GetNumEntityInstances(int entityIndex)
{
	TRACE("%d\n", entityIndex);
	return 1;
}

GDevPtr
xf86GetDevFromEntity(int entityIndex, int instance)
{
	TRACE("%d %d\n", entityIndex, instance);
	return &drec;
}

int
xf86LoadKernelModule(const char *modName)
{
	TRACE("'%s'\n", modName);
	return 1;
}

pointer
XNFalloc(unsigned long n)
{
	return malloc(n);
}

pointer
XNFcalloc(unsigned long n)
{
	return calloc(1, n);
}

void *
XNFrealloc(void *ptr, unsigned long amount)
{
	return realloc(ptr, amount);
}

void
xf86DrvMsg(int scrnIndex, MessageType type, const char *format, ...)
{   
	va_list ap;

	printf("xf86DrvMsg: ");             
	va_start(ap, format);                                        
	vprintf(format, ap);             
	va_end(ap);
	fflush(stdout);
}   

void
xf86VDrvMsgVerb(int scrnIndex, MessageType type, int verb, const char *format,
                va_list args)
{
	printf("xf86VDrvMsgVerb: ");             
	vprintf(format, args);             
	fflush(stdout);
}

void xf86Msg(MessageType type, const char *format, ...)
{
	va_list ap;

	printf("xf86Msg: ");             
	va_start(ap, format);                                        
	vprintf(format, ap);             
	va_end(ap);
	fflush(stdout);
}

void xf86MsgVerb(MessageType type, int verb, const char *format, ...)
{
	va_list ap;

	printf("xf86MsgVerb: ");             
	va_start(ap, format);                                        
	vprintf(format, ap);             
	va_end(ap);
	fflush(stdout);
}

CARD32
GetTimeInMillis(void)
{
	struct timespec tp;
	clock_gettime(CLOCK_MONOTONIC, &tp);
	return tp.tv_sec * 1000 + tp.tv_nsec / 1000000;
}

Bool
xf86GetOptValBool(const OptionInfoRec *table, int token, Bool *value)
{
	TRACE("%p/%s %d %p\n", table, table ? table->name : NULL, token, value);
	return FALSE;
}

static DriverPtr g_driver;

void
xf86AddDriver(DriverPtr driver, pointer module, int flags)
{
	TRACE("%p %p %x\n", driver, module, flags);             
	g_driver = driver;
}

static void scan_pci(void)
{
	static struct pci_slot_match match = {
		PCI_MATCH_ANY, PCI_MATCH_ANY, PCI_MATCH_ANY, PCI_MATCH_ANY, 0
	};
	struct pci_device_iterator *iter;
	struct pci_device *info;
	int ret;

	ret = pci_system_init();
	if (ret != 0) {
		fprintf(stderr, "pci_system_init failed\n");
		return;
	}

	iter = pci_slot_match_iterator_create(&match);
	while ((info = pci_device_next(iter)) != NULL) {
		if ((info->device_class & 0xff0000) != 0x30000)
			// not display
			continue;

		pci_device_probe(info);
		if (pci_device_is_boot_vga(info))
			break;
	}
	pci_iterator_destroy(iter);

	if (info == NULL) {
		fprintf(stderr, "no display devices?\n");
		return;
	}

	if (info->vendor_id != 0x1002) {
		fprintf(stderr, "not AMD display? (%04x)\n",
			info->vendor_id);
		return;
	}

	//exit(1);
}

static int module_desc[64];

int main(int argc, char *argv[])
{
	XF86ModuleData *mod_data;
	ScrnInfoPtr screen = NULL;
	pthread_mutex_t mutex;
	int errmaj = 0, errmin = 0;
	int retval = 1;
	void *setup_ret;
	void *mod;
	int fd, ret;

	// init pthreads
	pthread_mutex_init(&mutex, NULL);

#if 0
	// preload libpciaccess as it's not in fglrx's deps
	mod = dlopen("libpciaccess.so", RTLD_LAZY | RTLD_GLOBAL);
	if (mod == NULL)
		fprintf(stderr, "preload pciaccess: %s\n", dlerror());
#endif
	// fglrx relies on pci_system_init() being called too
	scan_pci();

	mod = dlopen("/usr/lib/xorg/modules/drivers/fglrx_drv.so",
		RTLD_LAZY | RTLD_GLOBAL);
	if (mod == NULL) {
		fprintf(stderr, "open module: %s\n", dlerror());
		return 1;
	}

	mod_data = dlsym(mod, "fglrxModuleData");
	if (mod_data == NULL) {
		fprintf(stderr, "dlsym fglrxModuleData: %s\n", dlerror());
		goto out;
	}

	if (mod_data->vers == NULL) {
		fprintf(stderr, "mod_data->vers is NULL\n");
		goto out;
	}

	printf("name: %s\n", mod_data->vers->modname);
	printf("vendor: %s\n", mod_data->vers->vendor);
	printf("abiclass: %s\n", mod_data->vers->abiclass);
	printf("moduleclass: %s\n", mod_data->vers->moduleclass);
	printf("version: %u.%u.%u\n", mod_data->vers->majorversion,
		mod_data->vers->minorversion, mod_data->vers->patchlevel);
	fflush(stdout);

	// fglrx assumes descriptor 0 to be Xorg.log
	fd = open("/var/log/Xorg.0.log", O_RDONLY);
	if (fd == -1) {
		perror("open Xorg.0.log");
		goto out;
	}
	ret = dup2(fd, 0);
	if (ret == -1) {
		perror("dup2");
		goto out;
	}

	if (mod_data->setup == NULL) {
		fprintf(stderr, "mod_data->setup is NULL\n");
		goto out;
	}

	setup_ret = mod_data->setup(module_desc, NULL, &errmaj, &errmin);
	printf("setup: %p, errmaj %u, errmin %u\n", setup_ret, errmaj, errmin);
	if (setup_ret == NULL) {
		fprintf(stderr, "setup() returned NULL\n");
		goto out;
	}

	if (g_driver == NULL) {
		fprintf(stderr, "setup() did not provide driver ptr\n");
		goto out;
	}

	printf("driverName: %s\n", g_driver->driverName);
	if (g_driver->Probe == NULL) {
		fprintf(stderr, "Probe is NULL\n");
		goto out;
	}

	// #0  in xdl_xs111_atiddxPxEarlyCheck ()
	// #1  in xdl_xs111_atiddxProbe ()
	// #2  in atiddxProbe ()
	ret = g_driver->Probe(g_driver, PROBE_DETECT);
	printf("Probe(PROBE_DETECT): %d\n", ret);
	if (!ret)
		goto out;

	ret = g_driver->Probe(g_driver, PROBE_DEFAULT);
	printf("Probe(PROBE_DEFAULT): %d\n", ret);
	if (!ret)
		goto out;

#if 0
	if (xf86Screens == NULL || xf86Screens[0] == NULL) {
		fprintf(stderr, "xf86Screens[0] did not get set\n");
		goto out;
	}
	screen = xf86Screens[0];
	if (screen->PreInit == NULL) {
		fprintf(stderr, "screen->PreInit did not get set\n");
		goto out;
	}
	ret = screen->PreInit(screen, 0);
	printf("PreInit: %d\n", ret);
#endif

	retval = !ret;

out:
	(void)screen;
	dlclose(mod);
	return retval;
}
Commit	Line	Data
4c793154	1	/*
	2	* fireglload
	3	* (C) notaz, 2014
	4	*
	5	* This work is licensed under the terms of 3-clause BSD license.
	6	* See COPYING file in the top-level directory.
	7	*/
	8
	9	#include <stdio.h>
	10	#include <dlfcn.h>
	11	#include <pthread.h>
	12	#include <sys/types.h>
	13	#include <sys/stat.h>
	14	#include <fcntl.h>
	15	#include <unistd.h>
	16	#include <time.h>
	17
	18	#include <pciaccess.h>
	19
	20	#include <xorg/xf86.h>
	21	#include <xorg/xf86Module.h>
	22	#include <xorg/xf86str.h>
	23
	24	#if 0
	25	#define TRACE(f, ...) \
	26	fprintf(stderr, ". %s " f, __FUNCTION__, ##__VA_ARGS__)
	27	#define NI() \
	28	fprintf(stderr, "NI: %s\n", __FUNCTION__)
	29	#else
	30	#define TRACE(...)
	31	#define NI()
	32	#endif
	33
	34	#ifndef _X_EXPORT
	35	#define _X_EXPORT __attribute__((visibility("default")))
	36	#endif
	37
	38	static GDevRec drec;
	39
	40	#ifdef DIX_H
	41	_X_EXPORT ClientPtr clients[MAXCLIENTS];
	42	_X_EXPORT ScreenInfo screenInfo;
	43	_X_EXPORT ClientPtr serverClient;
	44	#else
	45	#define MAXCLIENTS 256
	46	_X_EXPORT void *clients[MAXCLIENTS];
	47	_X_EXPORT long screenInfo[16]; // ScreenInfo
	48	_X_EXPORT void *serverClient;
	49	#endif
	50	#ifdef _XF86_H
	51	_X_EXPORT ScrnInfoPtr *xf86Screens;
	52	_X_EXPORT confDRIRec xf86ConfigDRI;
	53	#else
	54	_X_EXPORT void *xf86Screens;
	55	_X_EXPORT long xf86ConfigDRI[4]; // confDRIRec
	56	#endif
	57	_X_EXPORT int PanoramiXNumScreens;
	58	_X_EXPORT long inputInfo[16]; // InputInfo
	59	_X_EXPORT unsigned long globalSerialNumber = 0;
	60	_X_EXPORT unsigned long serverGeneration = 0;
	61	_X_EXPORT int noPanoramiXExtension;
	62	_X_EXPORT int noRRExtension;
	63	_X_EXPORT int noCompositeExtension;
	64	_X_EXPORT int noRenderExtension;
65	_X_EXPORT char dispatchException;
66	_X_EXPORT void *xf86DriverList;
67	_X_EXPORT int xf86NumDrivers;
68	_X_EXPORT void *xf86configptr;
69	_X_EXPORT int xf86DefaultModes[1024]; // DisplayModeRec[]
70	_X_EXPORT int xf86Info[64]; // xf86InfoRec
71	_X_EXPORT int xf86Initialising;
72	_X_EXPORT int XRT_WINDOW;
73	_X_EXPORT int monitorResolution;
74	_X_EXPORT int DPMSEnabled;
75	#define SCREEN_SAVER_OFF 1
76	_X_EXPORT int screenIsSaved = SCREEN_SAVER_OFF;
77
78	#ifndef _XF86_H
79	_X_EXPORT void xf86DrvMsg(int scrnIndex, MessageType type, const char *format, ...);
80	_X_EXPORT Bool xf86LoaderCheckSymbol(const char *name);
81	_X_EXPORT void xf86AddDriver(DriverPtr driver, pointer module, int flags);
82	#endif
83	_X_EXPORT void GetSpritePosition(struct _DeviceIntRec, int , int *);
84	_X_EXPORT int xf86LoadKernelModule(const char *pathname);
85
86	// don't delete my globals..
87	extern void ddmg(void *g);
88
89	static void __attribute__((constructor)) ddmg_hack(void)
90	{
91	ddmg(&clients);
92	ddmg(&PanoramiXNumScreens);
93	ddmg(&inputInfo);
94	ddmg(&screenInfo);
95	ddmg(&globalSerialNumber);
96	ddmg(&serverGeneration);
97	ddmg(&noPanoramiXExtension);
98	ddmg(&noRRExtension);
99	ddmg(&noCompositeExtension);
100	ddmg(&noRenderExtension);
101	ddmg(&dispatchException);
102	ddmg(&xf86Screens);
103	ddmg(&xf86DriverList);
104	ddmg(&xf86NumDrivers);
105	ddmg(&xf86configptr);
106	ddmg(&xf86DefaultModes);
107	ddmg(&xf86Info);
108	ddmg(&xf86ConfigDRI);
109	ddmg(&xf86Initialising);
110	ddmg(&serverClient);
111	ddmg(&XRT_WINDOW);
112	ddmg(&monitorResolution);
113	ddmg(&DPMSEnabled);
114	ddmg(&screenIsSaved);
115
116	ddmg(&LoadSubModule);
117	ddmg(&LoaderSymbol);
118	ddmg(&xf86LoaderCheckSymbol);
119	ddmg(&xf86DrvMsg);
120	ddmg(&xf86VDrvMsgVerb);
121	ddmg(&xf86Msg);
122	ddmg(&xf86MsgVerb);
123	ddmg(&xf86AddDriver);
124	ddmg(&GetSpritePosition);
125	ddmg(&XNFalloc);
126	ddmg(&XNFcalloc);
127	ddmg(&XNFrealloc);
128	ddmg(&xf86MatchDevice);
129	ddmg(&xf86LoadKernelModule);
130	ddmg(&xf86MatchPciInstances);
131	ddmg(&xf86CheckPciSlot);
132	ddmg(&xf86ConfigPciEntity);
133	ddmg(&xf86ComparePciBusString);
134	ddmg(&xf86ClaimPciSlot);
135	ddmg(&xf86GetPciInfoForEntity);
136	ddmg(&xf86GetEntityInfo);
137	ddmg(&xf86AllocateEntityPrivateIndex);
138	ddmg(&xf86GetEntityPrivate);
139	ddmg(&xf86SetEntitySharable);
140	ddmg(&xf86GetNumEntityInstances);
141	ddmg(&xf86GetDevFromEntity);
142	ddmg(&xf86AddBusDeviceToConfigure);
143	ddmg(&GetTimeInMillis);
144	ddmg(&xf86GetOptValBool);
145	}
146
147	#define MAKE_FUNC(name) \
148	int _X_EXPORT name() \
149	{ \
150	NI(); \
151	return 0; \
152	} \
153	static void __attribute__((constructor)) c_##name(void) \
154	{ \
155	ddmg(&name); \
156	}
157
158	MAKE_FUNC(xf86SetDGAMode)
159	MAKE_FUNC(GetSpriteCursor)
160	MAKE_FUNC(StandardMinorOpcode)
161
162	void
163	GetSpritePosition(struct _DeviceIntRec pDev, int px, int *py)
164	{
165	NI();
166	}
167
168	pointer
169	LoadSubModule(pointer _parent, const char *module,
170	const char subdirlist, const char patternlist,
171	pointer options, const XF86ModReqInfo * modreq,
172	int errmaj, int errmin)
173	{
174	void *ret;
175
176	printf("LoadSubModule '%s'\n", module);
177
178	if (module && strstr(module, "fglrxdrm"))
179	module = "/usr/lib/xorg/modules/linux/libfglrxdrm.so";
180	ret = dlopen(module, RTLD_LAZY \| RTLD_GLOBAL);
181	if (ret == NULL)
182	fprintf(stderr, "LoadSubModule dlopen: %s\n", dlerror());
183
184	return ret;
185	}
186
187	void *
188	LoaderSymbol(const char *name)
189	{
190	void *ret = dlsym(NULL, name);
191	TRACE("'%s' %p\n", name, ret);
192	return ret;
193	}
194
195	Bool
196	xf86LoaderCheckSymbol(const char *name)
197	{
198	Bool ret;
199
200	ret = (dlsym(NULL, name) != NULL);
201	TRACE("'%s' %d\n", name, ret);
202	return ret;
203	}
204
205	int
206	xf86MatchDevice(const char drivername, GDevPtr *sectlist)
207	{
208	GDevRec **list;
209
210	TRACE("'%s' %p\n", drivername, sectlist);
211
212	if (sectlist == NULL)
213	goto out;
214
215	*sectlist = NULL;
216	list = malloc(2 * sizeof(list[0]));
217	if (list == NULL)
218	return 0;
219	list[0] = &drec;
220	list[1] = NULL;
221	*sectlist = list;
222
223	out:
224	return 1;
225	}
226
227	int
228	xf86MatchPciInstances(const char *driverName, int vendorID,
229	SymTabPtr chipsets, PciChipsets *PCIchipsets,
230	GDevPtr *devList, int numDevs, DriverPtr drvp,
231	int **foundEntities)
232	{
233	TRACE("'%s' %04x %p %p %p %d %p %p\n",
234	driverName, vendorID, chipsets, PCIchipsets, devList, numDevs,
235	drvp, foundEntities);
236
237	*foundEntities = malloc(sizeof(int));
238	if (*foundEntities == NULL)
239	return 0;
240
241	(*foundEntities)[0] = 0;
242	return 1;
243	}
244
245	GDevPtr
246	xf86AddBusDeviceToConfigure(const char driver, BusType bus, void busData, int chipset)
247	{
248	struct pci_device *pci = busData;
249
250	TRACE("'%s' %d %p %d\n", driver, bus, busData, chipset);
251
252	drec.driver = strdup(driver);
253	drec.identifier = strdup("fake_dev");
254	drec.busID = malloc(64);
255	snprintf(drec.busID, 64, "PCI:%d:%d:%d", pci->bus, pci->dev, pci->func);
256	drec.chipID = pci->device_id;
257	drec.chipRev = pci->revision;
258	drec.irq = -1;
259
260	drec.myScreenSection = calloc(1, sizeof(*drec.myScreenSection));
261
262	TRACE("ret busID '%s'\n", drec.busID);
263	return &drec;
264	}
265
266	Bool
267	xf86CheckPciSlot(const struct pci_device *d)
268	{
269	TRACE("%p\n", d);
270	return TRUE;
271	}
272
273	ScrnInfoPtr
274	xf86ConfigPciEntity(ScrnInfoPtr pScrn, int scrnFlag, int entityIndex,
275	PciChipsets p_chip, void dummy, EntityProc init,
276	EntityProc enter, EntityProc leave, pointer private)
277	{
278	ScrnInfoPtr screen;
279
280	TRACE("%p %x %d %p %p %p %p %p %p\n",
281	pScrn, scrnFlag, entityIndex, p_chip, dummy, init,
282	enter, leave, private);
283
284	screen = calloc(1, sizeof(*screen));
285	screen->entityList = calloc(1, sizeof(screen->entityList[0]));
286	screen->numEntities = 1;
287	// used by atiddxIsCrossDisplay_3
288	screen->confScreen = calloc(1, sizeof(*screen->confScreen));
289
290	xf86Screens = calloc(2, sizeof(xf86Screens[0]));
291	return (xf86Screens[0] = screen);
292	}
293
294	Bool
295	xf86ComparePciBusString(const char *busID, int bus, int device, int func)
296	{
297	TRACE("'%s' %d:%d:%d\n", busID, bus, device, func);
298	return TRUE;
299	}
300
301	static struct pci_device *cur_pci_dev;
302
303	int
304	xf86ClaimPciSlot(struct pci_device *d, DriverPtr drvp,
305	int chipset, GDevPtr dev, Bool active)
306	{
307	TRACE("%p %p %d %p %d\n", d, drvp, chipset, dev, active);
308	cur_pci_dev = d;
309
310	return 0;
311	}
312
313	struct pci_device *
314	xf86GetPciInfoForEntity(int entityIndex)
315	{
316	TRACE("%d\n", entityIndex);
317
318	return cur_pci_dev;
319	}
320
321	EntityInfoPtr
322	xf86GetEntityInfo(int entityIndex)
323	{
324	EntityInfoRec *ret;
325
326	TRACE("%d\n", entityIndex);
327
328	ret = calloc(1, sizeof(*ret));
329	ret->device = &drec;
330	ret->location.id.pci = cur_pci_dev;
331
332	return ret;
333	}
334
335	static int numprivs;
336	static DevUnion *privs;
337
338	int
339	xf86AllocateEntityPrivateIndex(void)
340	{
341	int ret;
342
343	ret = numprivs++;
344	TRACE("numprivs=%d\n", numprivs);
345
346	privs = realloc(privs, numprivs * sizeof(DevUnion));
347	return ret;
348	}
349
350	DevUnion *
351	xf86GetEntityPrivate(int entityIndex, int privIndex)
352	{
353	DevUnion *ret = NULL;
354
355	if (entityIndex != 0 \|\| (unsigned int)privIndex > (unsigned int)numprivs)
356	ret = NULL;
357	else
358	ret = &privs[privIndex];
359
360	TRACE("%d %d; ret=%p\n", entityIndex, privIndex, ret);
361	return ret;
362	}
363
364	void
365	xf86SetEntitySharable(int entityIndex)
366	{
367	TRACE("%d\n", entityIndex);
368	}
369
370	int
371	xf86GetNumEntityInstances(int entityIndex)
372	{
373	TRACE("%d\n", entityIndex);
374	return 1;
375	}
376
377	GDevPtr
378	xf86GetDevFromEntity(int entityIndex, int instance)
379	{
380	TRACE("%d %d\n", entityIndex, instance);
381	return &drec;
382	}
383
384	int
385	xf86LoadKernelModule(const char *modName)
386	{
387	TRACE("'%s'\n", modName);
388	return 1;
389	}
390
391	pointer
392	XNFalloc(unsigned long n)
393	{
394	return malloc(n);
395	}
396
397	pointer
398	XNFcalloc(unsigned long n)
399	{
400	return calloc(1, n);
401	}
402
403	void *
404	XNFrealloc(void *ptr, unsigned long amount)
405	{
406	return realloc(ptr, amount);
407	}
408
409	void
410	xf86DrvMsg(int scrnIndex, MessageType type, const char *format, ...)
411	{
412	va_list ap;
413
414	printf("xf86DrvMsg: ");
415	va_start(ap, format);
416	vprintf(format, ap);
417	va_end(ap);
418	fflush(stdout);
419	}
420
421	void
422	xf86VDrvMsgVerb(int scrnIndex, MessageType type, int verb, const char *format,
423	va_list args)
424	{
425	printf("xf86VDrvMsgVerb: ");
426	vprintf(format, args);
427	fflush(stdout);
428	}
429
430	void xf86Msg(MessageType type, const char *format, ...)
431	{
432	va_list ap;
433
434	printf("xf86Msg: ");
435	va_start(ap, format);
436	vprintf(format, ap);
437	va_end(ap);
438	fflush(stdout);
439	}
440
441	void xf86MsgVerb(MessageType type, int verb, const char *format, ...)
442	{
443	va_list ap;
444
445	printf("xf86MsgVerb: ");
446	va_start(ap, format);
447	vprintf(format, ap);
448	va_end(ap);
449	fflush(stdout);
450	}
451
452	CARD32
453	GetTimeInMillis(void)
454	{
455	struct timespec tp;
456	clock_gettime(CLOCK_MONOTONIC, &tp);
457	return tp.tv_sec * 1000 + tp.tv_nsec / 1000000;
458	}
459
460	Bool
461	xf86GetOptValBool(const OptionInfoRec table, int token, Bool value)
462	{
463	TRACE("%p/%s %d %p\n", table, table ? table->name : NULL, token, value);
464	return FALSE;
465	}
466
467	static DriverPtr g_driver;
468
469	void
470	xf86AddDriver(DriverPtr driver, pointer module, int flags)
471	{
472	TRACE("%p %p %x\n", driver, module, flags);
473	g_driver = driver;
474	}
475
476	static void scan_pci(void)
477	{
478	static struct pci_slot_match match = {
479	PCI_MATCH_ANY, PCI_MATCH_ANY, PCI_MATCH_ANY, PCI_MATCH_ANY, 0
480	};
481	struct pci_device_iterator *iter;
482	struct pci_device *info;
483	int ret;
484
485	ret = pci_system_init();
486	if (ret != 0) {
487	fprintf(stderr, "pci_system_init failed\n");
488	return;
489	}
490
491	iter = pci_slot_match_iterator_create(&match);
492	while ((info = pci_device_next(iter)) != NULL) {
493	if ((info->device_class & 0xff0000) != 0x30000)
494	// not display
495	continue;
496
497	pci_device_probe(info);
498	if (pci_device_is_boot_vga(info))
499	break;
500	}
501	pci_iterator_destroy(iter);
502
503	if (info == NULL) {
504	fprintf(stderr, "no display devices?\n");
505	return;
506	}
507
508	if (info->vendor_id != 0x1002) {
509	fprintf(stderr, "not AMD display? (%04x)\n",
510	info->vendor_id);
511	return;
512	}
513
514	//exit(1);
515	}
516
517	static int module_desc[64];
518
519	int main(int argc, char *argv[])
520	{
521	XF86ModuleData *mod_data;
522	ScrnInfoPtr screen = NULL;
523	pthread_mutex_t mutex;
524	int errmaj = 0, errmin = 0;
525	int retval = 1;
526	void *setup_ret;
527	void *mod;
528	int fd, ret;
529
530	// init pthreads
531	pthread_mutex_init(&mutex, NULL);
532
533	#if 0
534	// preload libpciaccess as it's not in fglrx's deps
535	mod = dlopen("libpciaccess.so", RTLD_LAZY \| RTLD_GLOBAL);
536	if (mod == NULL)
537	fprintf(stderr, "preload pciaccess: %s\n", dlerror());
538	#endif
539	// fglrx relies on pci_system_init() being called too
540	scan_pci();
541
542	mod = dlopen("/usr/lib/xorg/modules/drivers/fglrx_drv.so",
543	RTLD_LAZY \| RTLD_GLOBAL);
544	if (mod == NULL) {
545	fprintf(stderr, "open module: %s\n", dlerror());
546	return 1;
547	}
548
549	mod_data = dlsym(mod, "fglrxModuleData");
550	if (mod_data == NULL) {
551	fprintf(stderr, "dlsym fglrxModuleData: %s\n", dlerror());
552	goto out;
553	}
554
555	if (mod_data->vers == NULL) {
556	fprintf(stderr, "mod_data->vers is NULL\n");
557	goto out;
558	}
559
560	printf("name: %s\n", mod_data->vers->modname);
561	printf("vendor: %s\n", mod_data->vers->vendor);
562	printf("abiclass: %s\n", mod_data->vers->abiclass);
563	printf("moduleclass: %s\n", mod_data->vers->moduleclass);
564	printf("version: %u.%u.%u\n", mod_data->vers->majorversion,
565	mod_data->vers->minorversion, mod_data->vers->patchlevel);
566	fflush(stdout);
567
568	// fglrx assumes descriptor 0 to be Xorg.log
569	fd = open("/var/log/Xorg.0.log", O_RDONLY);
570	if (fd == -1) {
571	perror("open Xorg.0.log");
572	goto out;
573	}
574	ret = dup2(fd, 0);
575	if (ret == -1) {
576	perror("dup2");
577	goto out;
578	}
579
580	if (mod_data->setup == NULL) {
581	fprintf(stderr, "mod_data->setup is NULL\n");
582	goto out;
583	}
584
585	setup_ret = mod_data->setup(module_desc, NULL, &errmaj, &errmin);
586	printf("setup: %p, errmaj %u, errmin %u\n", setup_ret, errmaj, errmin);
587	if (setup_ret == NULL) {
588	fprintf(stderr, "setup() returned NULL\n");
589	goto out;
590	}
591
592	if (g_driver == NULL) {
593	fprintf(stderr, "setup() did not provide driver ptr\n");
594	goto out;
595	}
596
597	printf("driverName: %s\n", g_driver->driverName);
598	if (g_driver->Probe == NULL) {
599	fprintf(stderr, "Probe is NULL\n");
600	goto out;
601	}
602
603	// #0 in xdl_xs111_atiddxPxEarlyCheck ()
604	// #1 in xdl_xs111_atiddxProbe ()
605	// #2 in atiddxProbe ()
606	ret = g_driver->Probe(g_driver, PROBE_DETECT);
607	printf("Probe(PROBE_DETECT): %d\n", ret);
608	if (!ret)
609	goto out;
610
611	ret = g_driver->Probe(g_driver, PROBE_DEFAULT);
612	printf("Probe(PROBE_DEFAULT): %d\n", ret);
613	if (!ret)
614	goto out;
615
616	#if 0
617	if (xf86Screens == NULL \|\| xf86Screens[0] == NULL) {
618	fprintf(stderr, "xf86Screens[0] did not get set\n");
619	goto out;
620	}
621	screen = xf86Screens[0];
622	if (screen->PreInit == NULL) {
623	fprintf(stderr, "screen->PreInit did not get set\n");
624	goto out;
625	}
626	ret = screen->PreInit(screen, 0);
627	printf("PreInit: %d\n", ret);
628	#endif
629
630	retval = !ret;
631
632	out:
633	(void)screen;
634	dlclose(mod);
635	return retval;
636	}