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"
42 #include <libdrm/drm.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)
65 /* Regarding os versions, we should not define our own as that would simply be
66 * weird. Defaulting to Win2k/XP seems sane considering the origin of D3D9. The
67 * driver also defaults to being a generic D3D9 driver, which of course only
68 * matters if you're actually using the DDI. */
69 #define VERSION_HIGH VERSION_DWORD(0x0006, 0x000E) /* winxp, d3d9 */
70 #define VERSION_LOW VERSION_DWORD(0x0000, 0x0001) /* version, build */
72 struct d3dadapter9drm_context
74 struct d3dadapter9_context base
;
75 struct pipe_loader_device
*dev
, *swdev
;
79 drm_destroy( struct d3dadapter9_context
*ctx
)
81 #if !GALLIUM_STATIC_TARGETS
82 struct d3dadapter9drm_context
*drm
= (struct d3dadapter9drm_context
*)ctx
;
84 /* pipe_loader_sw destroys the context */
86 pipe_loader_release(&drm
->swdev
, 1);
88 pipe_loader_release(&drm
->dev
, 1);
94 /* read a DWORD in the form 0xnnnnnnnn, which is how sysfs pci id stuff is
97 read_file_dword( const char *name
)
102 fd
= open(name
, O_RDONLY
);
104 DBG("Unable to get PCI information from `%s'\n", name
);
108 r
= read(fd
, buf
, 32);
111 return (r
> 0) ? (DWORD
)strtol(buf
, NULL
, 0) : 0;
114 /* sysfs doesn't expose the revision as its own file, so this function grabs a
115 * dword at an offset in the raw PCI header. The reason this isn't used for all
116 * data is that the kernel will make corrections but not expose them in the raw
119 read_config_dword( int fd
,
124 if (lseek(fd
, offset
, SEEK_SET
) != offset
) { return 0; }
125 if (read(fd
, &r
, 4) != 4) { return 0; }
131 get_bus_info( int fd
,
142 if (ioctl(fd
, DRM_IOCTL_GET_UNIQUE
, &u
)) { return; }
143 u
.unique
= CALLOC(u
.unique_len
+1, 1);
145 if (ioctl(fd
, DRM_IOCTL_GET_UNIQUE
, &u
)) { return; }
146 u
.unique
[u
.unique_len
] = '\0';
148 DBG("DRM Device BusID: %s\n", u
.unique
);
149 if (strncmp("pci:", u
.unique
, 4) == 0) {
150 char fname
[512]; /* this ought to be enough */
151 int l
= snprintf(fname
, 512, "/sys/bus/pci/devices/%s/", u
.unique
+4);
154 snprintf(fname
+l
, 512-l
, "vendor");
155 *vendorid
= read_file_dword(fname
);
157 snprintf(fname
+l
, 512-l
, "device");
158 *deviceid
= read_file_dword(fname
);
160 snprintf(fname
+l
, 512-l
, "subsystem_device");
161 *subsysid
= (read_file_dword(fname
) << 16) & 0xFFFF0000;
162 snprintf(fname
+l
, 512-l
, "subsystem_vendor");
163 *subsysid
|= read_file_dword(fname
) & 0x0000FFFF;
168 snprintf(fname
+l
, 512-l
, "config");
169 cfgfd
= open(fname
, O_RDONLY
);
171 *revision
= read_config_dword(cfgfd
, 0x8) & 0x000000FF;
174 DBG("Unable to get raw PCI information from `%s'\n", fname
);
177 DBG("PCI info: vendor=0x%04x, device=0x%04x, subsys=0x%08x, rev=%d\n",
178 *vendorid
, *deviceid
, *subsysid
, *revision
);
180 DBG("Unsupported BusID type.\n");
187 read_descriptor( struct d3dadapter9_context
*ctx
,
190 D3DADAPTER_IDENTIFIER9
*drvid
= &ctx
->identifier
;
192 memset(drvid
, 0, sizeof(*drvid
));
193 get_bus_info(fd
, &drvid
->VendorId
, &drvid
->DeviceId
,
194 &drvid
->SubSysId
, &drvid
->Revision
);
196 strncpy(drvid
->Driver
, "libd3dadapter9.so", sizeof(drvid
->Driver
));
197 strncpy(drvid
->DeviceName
, ctx
->hal
->get_name(ctx
->hal
), 32);
198 snprintf(drvid
->Description
, sizeof(drvid
->Description
),
199 "Gallium 0.4 with %s", ctx
->hal
->get_vendor(ctx
->hal
));
201 drvid
->DriverVersionLowPart
= VERSION_LOW
;
202 drvid
->DriverVersionHighPart
= VERSION_HIGH
;
204 /* To make a pseudo-real GUID we use the PCI bus data and some string */
205 drvid
->DeviceIdentifier
.Data1
= drvid
->VendorId
;
206 drvid
->DeviceIdentifier
.Data2
= drvid
->DeviceId
;
207 drvid
->DeviceIdentifier
.Data3
= drvid
->SubSysId
;
208 memcpy(drvid
->DeviceIdentifier
.Data4
, "Gallium3D", 8);
210 drvid
->WHQLLevel
= 1; /* This fakes WHQL validaion */
212 /* XXX Fake NVIDIA binary driver on Windows.
214 * OS version: 4=95/98/NT4, 5=2000, 6=2000/XP, 7=Vista, 8=Win7
216 strncpy(drvid
->Driver
, "nvd3dum.dll", sizeof(drvid
->Driver
));
217 strncpy(drvid
->Description
, "NVIDIA GeForce GTX 680", sizeof(drvid
->Description
));
218 drvid
->DriverVersionLowPart
= VERSION_DWORD(12, 6658); /* minor, build */
219 drvid
->DriverVersionHighPart
= VERSION_DWORD(6, 15); /* OS, major */
222 drvid
->DeviceIdentifier
.Data1
= 0xaeb2cdd4;
223 drvid
->DeviceIdentifier
.Data2
= 0x6e41;
224 drvid
->DeviceIdentifier
.Data3
= 0x43ea;
225 drvid
->DeviceIdentifier
.Data4
[0] = 0x94;
226 drvid
->DeviceIdentifier
.Data4
[1] = 0x1c;
227 drvid
->DeviceIdentifier
.Data4
[2] = 0x83;
228 drvid
->DeviceIdentifier
.Data4
[3] = 0x61;
229 drvid
->DeviceIdentifier
.Data4
[4] = 0xcc;
230 drvid
->DeviceIdentifier
.Data4
[5] = 0x76;
231 drvid
->DeviceIdentifier
.Data4
[6] = 0x07;
232 drvid
->DeviceIdentifier
.Data4
[7] = 0x81;
233 drvid
->WHQLLevel
= 0;
236 static HRESULT WINAPI
237 drm_create_adapter( int fd
,
238 ID3DAdapter9
**ppAdapter
)
240 struct d3dadapter9drm_context
*ctx
= CALLOC_STRUCT(d3dadapter9drm_context
);
242 int i
, different_device
;
243 const struct drm_conf_ret
*throttle_ret
= NULL
;
244 const struct drm_conf_ret
*dmabuf_ret
= NULL
;
245 driOptionCache defaultInitOptions
;
246 driOptionCache userInitOptions
;
247 int throttling_value_user
;
249 #if !GALLIUM_STATIC_TARGETS
250 const char *paths
[] = {
251 getenv("D3D9_DRIVERS_PATH"),
252 getenv("D3D9_DRIVERS_DIR"),
257 if (!ctx
) { return E_OUTOFMEMORY
; }
259 ctx
->base
.destroy
= drm_destroy
;
261 fd
= loader_get_user_preferred_fd(fd
, &different_device
);
262 ctx
->base
.linear_framebuffer
= !!different_device
;
264 #if GALLIUM_STATIC_TARGETS
265 ctx
->base
.hal
= dd_create_screen(fd
);
267 /* use pipe-loader to dlopen appropriate drm driver */
268 if (!pipe_loader_drm_probe_fd(&ctx
->dev
, fd
, FALSE
)) {
269 ERR("Failed to probe drm fd %d.\n", fd
);
272 return D3DERR_DRIVERINTERNALERROR
;
275 /* use pipe-loader to create a drm screen (hal) */
276 ctx
->base
.hal
= NULL
;
277 for (i
= 0; !ctx
->base
.hal
&& i
< Elements(paths
); ++i
) {
278 if (!paths
[i
]) { continue; }
279 ctx
->base
.hal
= pipe_loader_create_screen(ctx
->dev
, paths
[i
]);
282 if (!ctx
->base
.hal
) {
283 ERR("Unable to load requested driver.\n");
284 drm_destroy(&ctx
->base
);
285 return D3DERR_DRIVERINTERNALERROR
;
288 #if GALLIUM_STATIC_TARGETS
289 dmabuf_ret
= dd_configuration(DRM_CONF_SHARE_FD
);
290 throttle_ret
= dd_configuration(DRM_CONF_THROTTLE
);
292 dmabuf_ret
= pipe_loader_configuration(ctx
->dev
, DRM_CONF_SHARE_FD
);
293 throttle_ret
= pipe_loader_configuration(ctx
->dev
, DRM_CONF_THROTTLE
);
294 #endif // GALLIUM_STATIC_TARGETS
295 if (!dmabuf_ret
|| !dmabuf_ret
->val
.val_bool
) {
296 ERR("The driver is not capable of dma-buf sharing."
297 "Abandon to load nine state tracker\n");
298 drm_destroy(&ctx
->base
);
299 return D3DERR_DRIVERINTERNALERROR
;
302 if (throttle_ret
&& throttle_ret
->val
.val_int
!= -1) {
303 ctx
->base
.throttling
= TRUE
;
304 ctx
->base
.throttling_value
= throttle_ret
->val
.val_int
;
306 ctx
->base
.throttling
= FALSE
;
308 driParseOptionInfo(&defaultInitOptions
, __driConfigOptionsNine
);
309 driParseConfigFiles(&userInitOptions
, &defaultInitOptions
, 0, "nine");
310 if (driCheckOption(&userInitOptions
, "throttle_value", DRI_INT
)) {
311 throttling_value_user
= driQueryOptioni(&userInitOptions
, "throttle_value");
312 if (throttling_value_user
== -1)
313 ctx
->base
.throttling
= FALSE
;
314 else if (throttling_value_user
>= 0) {
315 ctx
->base
.throttling
= TRUE
;
316 ctx
->base
.throttling_value
= throttling_value_user
;
320 if (driCheckOption(&userInitOptions
, "vblank_mode", DRI_ENUM
))
321 ctx
->base
.vblank_mode
= driQueryOptioni(&userInitOptions
, "vblank_mode");
323 ctx
->base
.vblank_mode
= 1;
325 driDestroyOptionCache(&userInitOptions
);
326 driDestroyOptionInfo(&defaultInitOptions
);
328 #if GALLIUM_STATIC_TARGETS
329 ctx
->base
.ref
= ninesw_create_screen(ctx
->base
.hal
);
331 /* wrap it to create a software screen that can share resources */
332 if (pipe_loader_sw_probe_wrapped(&ctx
->swdev
, ctx
->base
.hal
)) {
333 ctx
->base
.ref
= NULL
;
334 for (i
= 0; !ctx
->base
.ref
&& i
< Elements(paths
); ++i
) {
335 if (!paths
[i
]) { continue; }
336 ctx
->base
.ref
= pipe_loader_create_screen(ctx
->swdev
, paths
[i
]);
340 if (!ctx
->base
.ref
) {
341 ERR("Couldn't wrap drm screen to swrast screen. Software devices "
342 "will be unavailable.\n");
345 /* read out PCI info */
346 read_descriptor(&ctx
->base
, fd
);
348 /* create and return new ID3DAdapter9 */
349 hr
= NineAdapter9_new(&ctx
->base
, (struct NineAdapter9
**)ppAdapter
);
351 drm_destroy(&ctx
->base
);
358 const struct D3DAdapter9DRM drm9_desc
= {
359 .major_version
= D3DADAPTER9DRM_MAJOR
,
360 .minor_version
= D3DADAPTER9DRM_MINOR
,
361 .create_adapter
= drm_create_adapter