2 * Copyright 2011 Joakim Sindholt <opensource@zhasha.com>
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * on the rights to use, copy, modify, merge, publish, distribute, sub
8 * license, and/or sell copies of the Software, and to permit persons to whom
9 * the Software is furnished to do so, subject to the following conditions:
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
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
19 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
20 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
21 * USE OR OTHER DEALINGS IN THE SOFTWARE. */
27 #include "pipe-loader/pipe_loader.h"
29 #include "pipe/p_screen.h"
30 #include "pipe/p_state.h"
32 #include "target-helpers/inline_drm_helper.h"
33 #include "target-helpers/inline_sw_helper.h"
34 #include "state_tracker/drm_driver.h"
36 #include "d3dadapter/d3dadapter9.h"
37 #include "d3dadapter/drm.h"
39 #include "xmlconfig.h"
43 #include <sys/ioctl.h>
47 #define DBG_CHANNEL DBG_ADAPTER
49 #define VERSION_DWORD(hi, lo) \
51 ((DWORD)((hi) & 0xFFFF) << 16) | \
52 (DWORD)((lo) & 0xFFFF) \
55 const char __driConfigOptionsNine
[] =
57 DRI_CONF_SECTION_PERFORMANCE
58 DRI_CONF_VBLANK_MODE(DRI_CONF_VBLANK_DEF_INTERVAL_1
)
61 DRI_CONF_NINE_THROTTLE(-2)
62 DRI_CONF_NINE_THREADSUBMIT("false")
66 /* Regarding os versions, we should not define our own as that would simply be
67 * weird. Defaulting to Win2k/XP seems sane considering the origin of D3D9. The
68 * driver also defaults to being a generic D3D9 driver, which of course only
69 * matters if you're actually using the DDI. */
70 #define VERSION_HIGH VERSION_DWORD(0x0006, 0x000E) /* winxp, d3d9 */
71 #define VERSION_LOW VERSION_DWORD(0x0000, 0x0001) /* version, build */
73 struct d3dadapter9drm_context
75 struct d3dadapter9_context base
;
76 struct pipe_loader_device
*dev
, *swdev
;
81 drm_destroy( struct d3dadapter9_context
*ctx
)
83 struct d3dadapter9drm_context
*drm
= (struct d3dadapter9drm_context
*)ctx
;
86 ctx
->ref
->destroy(ctx
->ref
);
87 /* because ref is a wrapper around hal, freeing ref frees hal too. */
89 ctx
->hal
->destroy(ctx
->hal
);
91 #if !GALLIUM_STATIC_TARGETS
93 pipe_loader_release(&drm
->swdev
, 1);
95 pipe_loader_release(&drm
->dev
, 1);
102 /* read a DWORD in the form 0xnnnnnnnn, which is how sysfs pci id stuff is
105 read_file_dword( const char *name
)
110 fd
= open(name
, O_RDONLY
);
112 DBG("Unable to get PCI information from `%s'\n", name
);
116 r
= read(fd
, buf
, 32);
119 return (r
> 0) ? (DWORD
)strtol(buf
, NULL
, 0) : 0;
122 /* sysfs doesn't expose the revision as its own file, so this function grabs a
123 * dword at an offset in the raw PCI header. The reason this isn't used for all
124 * data is that the kernel will make corrections but not expose them in the raw
127 read_config_dword( int fd
,
132 if (lseek(fd
, offset
, SEEK_SET
) != offset
) { return 0; }
133 if (read(fd
, &r
, 4) != 4) { return 0; }
139 get_bus_info( int fd
,
147 if (loader_get_pci_id_for_fd(fd
, &vid
, &did
)) {
148 DBG("PCI info: vendor=0x%04x, device=0x%04x\n",
155 DBG("Unable to detect card. Fake GTX 680.\n");
156 *vendorid
= 0x10de; /* NV GTX 680 */
164 read_descriptor( struct d3dadapter9_context
*ctx
,
167 D3DADAPTER_IDENTIFIER9
*drvid
= &ctx
->identifier
;
169 memset(drvid
, 0, sizeof(*drvid
));
170 get_bus_info(fd
, &drvid
->VendorId
, &drvid
->DeviceId
,
171 &drvid
->SubSysId
, &drvid
->Revision
);
173 strncpy(drvid
->Driver
, "libd3dadapter9.so", sizeof(drvid
->Driver
));
174 strncpy(drvid
->DeviceName
, ctx
->hal
->get_name(ctx
->hal
), 32);
175 snprintf(drvid
->Description
, sizeof(drvid
->Description
),
176 "Gallium 0.4 with %s", ctx
->hal
->get_vendor(ctx
->hal
));
178 drvid
->DriverVersionLowPart
= VERSION_LOW
;
179 drvid
->DriverVersionHighPart
= VERSION_HIGH
;
181 /* To make a pseudo-real GUID we use the PCI bus data and some string */
182 drvid
->DeviceIdentifier
.Data1
= drvid
->VendorId
;
183 drvid
->DeviceIdentifier
.Data2
= drvid
->DeviceId
;
184 drvid
->DeviceIdentifier
.Data3
= drvid
->SubSysId
;
185 memcpy(drvid
->DeviceIdentifier
.Data4
, "Gallium3D", 8);
187 drvid
->WHQLLevel
= 1; /* This fakes WHQL validaion */
189 /* XXX Fake NVIDIA binary driver on Windows.
191 * OS version: 4=95/98/NT4, 5=2000, 6=2000/XP, 7=Vista, 8=Win7
193 strncpy(drvid
->Driver
, "nvd3dum.dll", sizeof(drvid
->Driver
));
194 strncpy(drvid
->Description
, "NVIDIA GeForce GTX 680", sizeof(drvid
->Description
));
195 drvid
->DriverVersionLowPart
= VERSION_DWORD(12, 6658); /* minor, build */
196 drvid
->DriverVersionHighPart
= VERSION_DWORD(6, 15); /* OS, major */
199 drvid
->DeviceIdentifier
.Data1
= 0xaeb2cdd4;
200 drvid
->DeviceIdentifier
.Data2
= 0x6e41;
201 drvid
->DeviceIdentifier
.Data3
= 0x43ea;
202 drvid
->DeviceIdentifier
.Data4
[0] = 0x94;
203 drvid
->DeviceIdentifier
.Data4
[1] = 0x1c;
204 drvid
->DeviceIdentifier
.Data4
[2] = 0x83;
205 drvid
->DeviceIdentifier
.Data4
[3] = 0x61;
206 drvid
->DeviceIdentifier
.Data4
[4] = 0xcc;
207 drvid
->DeviceIdentifier
.Data4
[5] = 0x76;
208 drvid
->DeviceIdentifier
.Data4
[6] = 0x07;
209 drvid
->DeviceIdentifier
.Data4
[7] = 0x81;
210 drvid
->WHQLLevel
= 0;
213 static HRESULT WINAPI
214 drm_create_adapter( int fd
,
215 ID3DAdapter9
**ppAdapter
)
217 struct d3dadapter9drm_context
*ctx
= CALLOC_STRUCT(d3dadapter9drm_context
);
219 int different_device
;
220 const struct drm_conf_ret
*throttle_ret
= NULL
;
221 const struct drm_conf_ret
*dmabuf_ret
= NULL
;
222 driOptionCache defaultInitOptions
;
223 driOptionCache userInitOptions
;
224 int throttling_value_user
= -2;
226 #if !GALLIUM_STATIC_TARGETS
227 const char *paths
[] = {
228 getenv("D3D9_DRIVERS_PATH"),
229 getenv("D3D9_DRIVERS_DIR"),
234 if (!ctx
) { return E_OUTOFMEMORY
; }
236 ctx
->base
.destroy
= drm_destroy
;
238 fd
= loader_get_user_preferred_fd(fd
, &different_device
);
240 ctx
->base
.linear_framebuffer
= !!different_device
;
242 #if GALLIUM_STATIC_TARGETS
243 ctx
->base
.hal
= dd_create_screen(fd
);
245 /* use pipe-loader to dlopen appropriate drm driver */
246 if (!pipe_loader_drm_probe_fd(&ctx
->dev
, fd
, FALSE
)) {
247 ERR("Failed to probe drm fd %d.\n", fd
);
250 return D3DERR_DRIVERINTERNALERROR
;
253 /* use pipe-loader to create a drm screen (hal) */
254 ctx
->base
.hal
= NULL
;
255 for (i
= 0; !ctx
->base
.hal
&& i
< Elements(paths
); ++i
) {
256 if (!paths
[i
]) { continue; }
257 ctx
->base
.hal
= pipe_loader_create_screen(ctx
->dev
, paths
[i
]);
260 if (!ctx
->base
.hal
) {
261 ERR("Unable to load requested driver.\n");
262 drm_destroy(&ctx
->base
);
263 return D3DERR_DRIVERINTERNALERROR
;
266 #if GALLIUM_STATIC_TARGETS
267 dmabuf_ret
= dd_configuration(DRM_CONF_SHARE_FD
);
268 throttle_ret
= dd_configuration(DRM_CONF_THROTTLE
);
270 dmabuf_ret
= pipe_loader_configuration(ctx
->dev
, DRM_CONF_SHARE_FD
);
271 throttle_ret
= pipe_loader_configuration(ctx
->dev
, DRM_CONF_THROTTLE
);
272 #endif // GALLIUM_STATIC_TARGETS
273 if (!dmabuf_ret
|| !dmabuf_ret
->val
.val_bool
) {
274 ERR("The driver is not capable of dma-buf sharing."
275 "Abandon to load nine state tracker\n");
276 drm_destroy(&ctx
->base
);
277 return D3DERR_DRIVERINTERNALERROR
;
280 if (throttle_ret
&& throttle_ret
->val
.val_int
!= -1) {
281 ctx
->base
.throttling
= TRUE
;
282 ctx
->base
.throttling_value
= throttle_ret
->val
.val_int
;
284 ctx
->base
.throttling
= FALSE
;
286 driParseOptionInfo(&defaultInitOptions
, __driConfigOptionsNine
);
287 driParseConfigFiles(&userInitOptions
, &defaultInitOptions
, 0, "nine");
288 if (driCheckOption(&userInitOptions
, "throttle_value", DRI_INT
)) {
289 throttling_value_user
= driQueryOptioni(&userInitOptions
, "throttle_value");
290 if (throttling_value_user
== -1)
291 ctx
->base
.throttling
= FALSE
;
292 else if (throttling_value_user
>= 0) {
293 ctx
->base
.throttling
= TRUE
;
294 ctx
->base
.throttling_value
= throttling_value_user
;
298 if (driCheckOption(&userInitOptions
, "vblank_mode", DRI_ENUM
))
299 ctx
->base
.vblank_mode
= driQueryOptioni(&userInitOptions
, "vblank_mode");
301 ctx
->base
.vblank_mode
= 1;
303 if (driCheckOption(&userInitOptions
, "thread_submit", DRI_BOOL
)) {
304 ctx
->base
.thread_submit
= driQueryOptionb(&userInitOptions
, "thread_submit");
305 if (ctx
->base
.thread_submit
&& (throttling_value_user
== -2 || throttling_value_user
== 0)) {
306 ctx
->base
.throttling_value
= 0;
307 } else if (ctx
->base
.thread_submit
) {
308 DBG("You have set a non standard throttling value in combination with thread_submit."
309 "We advise to use a throttling value of -2/0");
311 if (ctx
->base
.thread_submit
&& !different_device
)
312 DBG("You have set thread_submit but do not use a different device than the server."
313 "You should not expect any benefit.");
316 driDestroyOptionCache(&userInitOptions
);
317 driDestroyOptionInfo(&defaultInitOptions
);
319 #if GALLIUM_STATIC_TARGETS
320 ctx
->base
.ref
= ninesw_create_screen(ctx
->base
.hal
);
322 /* wrap it to create a software screen that can share resources */
323 if (pipe_loader_sw_probe_wrapped(&ctx
->swdev
, ctx
->base
.hal
)) {
324 ctx
->base
.ref
= NULL
;
325 for (i
= 0; !ctx
->base
.ref
&& i
< Elements(paths
); ++i
) {
326 if (!paths
[i
]) { continue; }
327 ctx
->base
.ref
= pipe_loader_create_screen(ctx
->swdev
, paths
[i
]);
331 if (!ctx
->base
.ref
) {
332 ERR("Couldn't wrap drm screen to swrast screen. Software devices "
333 "will be unavailable.\n");
336 /* read out PCI info */
337 read_descriptor(&ctx
->base
, fd
);
339 /* create and return new ID3DAdapter9 */
340 hr
= NineAdapter9_new(&ctx
->base
, (struct NineAdapter9
**)ppAdapter
);
342 drm_destroy(&ctx
->base
);
349 const struct D3DAdapter9DRM drm9_desc
= {
350 .major_version
= D3DADAPTER9DRM_MAJOR
,
351 .minor_version
= D3DADAPTER9DRM_MINOR
,
352 .create_adapter
= drm_create_adapter