WebSVN – Kolibri OS – Diff – /contrib/sdk/sources/Mesa/src/gbm/main/backend.c


/*
 * Copyright © 2011 Intel Corporation
 *
 * 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, sublicense,
 * 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
 * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS 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.
 *
 * Authors:
 *    Benjamin Franzke 
 */
 
#include 
#include 
#include 
#include 
#include 
//#include 
 
#include "backend.h"
 
#define ARRAY_SIZE(a) (sizeof(a)/sizeof((a)[0]))
 
extern const struct gbm_backend gbm_dri_backend;
 
struct backend_desc {
   const char *name;
   const struct gbm_backend *builtin;
};
 
static const struct backend_desc backends[] = {
   { "gbm_dri.dll", &gbm_dri_backend },
   { "gbm_gallium_drm.dll", NULL },
};
 
#if 0
static const void *
load_backend(const struct backend_desc *backend)
{
   char path[PATH_MAX];
   const void *init = NULL;
   void *module;
   const char *name;
   const char *entrypoint = "gbm_backend";
 
   if (backend == NULL)
      return NULL;
 
   name = backend->name;
 
   if (backend->builtin) {
      init = backend->builtin;
   } else {
#if 0
      if (name[0] != '/')
         snprintf(path, sizeof path, MODULEDIR "/%s", name);
      else
         snprintf(path, sizeof path, "%s", name);
 
      module = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
      if (!module) {
         fprintf(stderr,
                 "failed to load module: %s\n", dlerror());
         return NULL;
      }
 
      init = dlsym(module, entrypoint);
      if (!init)
#endif
         return NULL;
   }
 
   return init;
}
 
static const struct backend_desc *
find_backend(const char *name)
{
   const struct backend_desc *backend = NULL;
   int i;
 
   for (i = 0; i < ARRAY_SIZE(backends); ++i) {
      if (strcmp(backends[i].name, name) == 0) {
         backend = &backends[i];
         break;
      }
   }
 
   return backend;
}
#endif
 
struct gbm_device *
_gbm_create_device(int fd)
{
   const struct gbm_backend *backend = NULL;
   struct gbm_device *dev = NULL;
 
#if 0
   int i;
   const char *b;
 
   b = getenv("GBM_BACKEND");
   if (b)
      backend = load_backend(find_backend(b));
 
   if (backend)
      dev = backend->create_device(fd);
 
   for (i = 0; i < ARRAY_SIZE(backends) && dev == NULL; ++i) {
      backend = load_backend(&backends[i]);
      if (backend == NULL)
         continue;
 
      dev = backend->create_device(fd);
   }
#endif
 
   backend = &gbm_dri_backend;
   dev = backend->create_device(fd);
 
   return dev;
}

Rev 4358	Rev 5080
1	/*	1	/*
2	* Copyright © 2011 Intel Corporation	2	* Copyright © 2011 Intel Corporation
3	*	3	*
4	* Permission is hereby granted, free of charge, to any person obtaining a	4	* Permission is hereby granted, free of charge, to any person obtaining a
5	* copy of this software and associated documentation files (the "Software"),	5	* copy of this software and associated documentation files (the "Software"),
6	* to deal in the Software without restriction, including without limitation	6	* to deal in the Software without restriction, including without limitation
7	* the rights to use, copy, modify, merge, publish, distribute, sublicense,	7	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
8	* and/or sell copies of the Software, and to permit persons to whom the	8	* and/or sell copies of the Software, and to permit persons to whom the
9	* Software is furnished to do so, subject to the following conditions:	9	* Software is furnished to do so, subject to the following conditions:
10	*	10	*
11	* The above copyright notice and this permission notice (including the next	11	* The above copyright notice and this permission notice (including the next
12	* paragraph) shall be included in all copies or substantial portions of the	12	* paragraph) shall be included in all copies or substantial portions of the
13	* Software.	13	* Software.
14	*	14	*
15	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,	15	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF	16	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND	17	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT	18	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
19	* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,	19	* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
20	* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,	20	* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER	21	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22	* DEALINGS IN THE SOFTWARE.	22	* DEALINGS IN THE SOFTWARE.
23	*	23	*
24	* Authors:	24	* Authors:
25	* Benjamin Franzke	25	* Benjamin Franzke
26	*/	26	*/
27		27
28	#include	28	#include
29	#include	29	#include
30	#include	30	#include
31	#include	31	#include
32	#include	32	#include
33	//#include	33	//#include
34		34
35	#include "backend.h"	35	#include "backend.h"
36		36
37	#define ARRAY_SIZE(a) (sizeof(a)/sizeof((a)[0]))	37	#define ARRAY_SIZE(a) (sizeof(a)/sizeof((a)[0]))
38		38
39	extern const struct gbm_backend gbm_dri_backend;	39	extern const struct gbm_backend gbm_dri_backend;
40		40
41	struct backend_desc {	41	struct backend_desc {
42	const char *name;	42	const char *name;
43	const struct gbm_backend *builtin;	43	const struct gbm_backend *builtin;
44	};	44	};
45		45
46	static const struct backend_desc backends[] = {	46	static const struct backend_desc backends[] = {
47	{ "gbm_dri.so", &gbm_dri_backend }	47	{ "gbm_dri.dll", &gbm_dri_backend },
48	// { "gbm_gallium_drm.so", NULL },	48	{ "gbm_gallium_drm.dll", NULL },
49	};	49	};
50		50
51	#if 0	51	#if 0
52	static const void *	52	static const void *
53	load_backend(const struct backend_desc *backend)	53	load_backend(const struct backend_desc *backend)
54	{	54	{
55	char path[PATH_MAX];	55	char path[PATH_MAX];
56	const void *init = NULL;	56	const void *init = NULL;
57	void *module;	57	void *module;
58	const char *name;	58	const char *name;
59	const char *entrypoint = "gbm_backend";	59	const char *entrypoint = "gbm_backend";
60		60
61	if (backend == NULL)	61	if (backend == NULL)
62	return NULL;	62	return NULL;
63		63
64	name = backend->name;	64	name = backend->name;
65		65
66	if (backend->builtin) {	66	if (backend->builtin) {
67	init = backend->builtin;	67	init = backend->builtin;
68	} else {	68	} else {
69	#if 0	69	#if 0
70	if (name[0] != '/')	70	if (name[0] != '/')
71	snprintf(path, sizeof path, MODULEDIR "/%s", name);	71	snprintf(path, sizeof path, MODULEDIR "/%s", name);
72	else	72	else
73	snprintf(path, sizeof path, "%s", name);	73	snprintf(path, sizeof path, "%s", name);
74		74
75	module = dlopen(path, RTLD_NOW \| RTLD_GLOBAL);	75	module = dlopen(path, RTLD_NOW \| RTLD_GLOBAL);
76	if (!module) {	76	if (!module) {
77	fprintf(stderr,	77	fprintf(stderr,
78	"failed to load module: %s\n", dlerror());	78	"failed to load module: %s\n", dlerror());
79	return NULL;	79	return NULL;
80	}	80	}
81		81
82	init = dlsym(module, entrypoint);	82	init = dlsym(module, entrypoint);
83	if (!init)	83	if (!init)
84	#endif	84	#endif
85	return NULL;	85	return NULL;
86	}	86	}
87		87
88	return init;	88	return init;
89	}	89	}
90		90
91	static const struct backend_desc *	91	static const struct backend_desc *
92	find_backend(const char *name)	92	find_backend(const char *name)
93	{	93	{
94	const struct backend_desc *backend = NULL;	94	const struct backend_desc *backend = NULL;
95	int i;	95	int i;
96		96
97	for (i = 0; i < ARRAY_SIZE(backends); ++i) {	97	for (i = 0; i < ARRAY_SIZE(backends); ++i) {
98	if (strcmp(backends[i].name, name) == 0) {	98	if (strcmp(backends[i].name, name) == 0) {
99	backend = &backends[i];	99	backend = &backends[i];
100	break;	100	break;
101	}	101	}
102	}	102	}
103		103
104	return backend;	104	return backend;
105	}	105	}
106	#endif	106	#endif
107		107
108	struct gbm_device *	108	struct gbm_device *
109	_gbm_create_device(int fd)	109	_gbm_create_device(int fd)
110	{	110	{
111	const struct gbm_backend *backend = NULL;	111	const struct gbm_backend *backend = NULL;
112	struct gbm_device *dev = NULL;	112	struct gbm_device *dev = NULL;
113		113
114	#if 0	114	#if 0
115	int i;	115	int i;
116	const char *b;	116	const char *b;
117		117
118	b = getenv("GBM_BACKEND");	118	b = getenv("GBM_BACKEND");
119	if (b)	119	if (b)
120	backend = load_backend(find_backend(b));	120	backend = load_backend(find_backend(b));
121		121
122	if (backend)	122	if (backend)
123	dev = backend->create_device(fd);	123	dev = backend->create_device(fd);
124		124
125	for (i = 0; i < ARRAY_SIZE(backends) && dev == NULL; ++i) {	125	for (i = 0; i < ARRAY_SIZE(backends) && dev == NULL; ++i) {
126	backend = load_backend(&backends[i]);	126	backend = load_backend(&backends[i]);
127	if (backend == NULL)	127	if (backend == NULL)
128	continue;	128	continue;
129		129
130	dev = backend->create_device(fd);	130	dev = backend->create_device(fd);
131	}	131	}
132	#endif	132	#endif
133		133
134	backend = &gbm_dri_backend;	134	backend = &gbm_dri_backend;
135	dev = backend->create_device(fd);	135	dev = backend->create_device(fd);
136		136
137	return dev;	137	return dev;
138	}	138	}

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/Mesa/src/gbm/main/backend.c – Rev 4358 → 5080