1 /*
2 * Copyright 2011 Joakim Sindholt <opensource@zhasha.com>
3 *
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:
10 *
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
13 * Software.
14 *
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. */
22
23 /* XXX: header order is slightly screwy here */
24 #include "loader.h"
25
26 #include "adapter9.h"
27
28 #include "pipe-loader/pipe_loader.h"
29
30 #include "pipe/p_screen.h"
31 #include "pipe/p_state.h"
32
33 #include "target-helpers/drm_helper.h"
34 #include "target-helpers/sw_helper.h"
35 #include "state_tracker/drm_driver.h"
36
37 #include "d3dadapter/d3dadapter9.h"
38 #include "d3dadapter/drm.h"
39
40 #include "util/xmlconfig.h"
41 #include "util/xmlpool.h"
42
43 #include <drm.h>
44 #include <sys/ioctl.h>
45 #include <fcntl.h>
46 #include <stdio.h>
47
48 #define DBG_CHANNEL DBG_ADAPTER
49
50 const char __driConfigOptionsNine[] =
51 DRI_CONF_BEGIN
52 DRI_CONF_SECTION_PERFORMANCE
53 DRI_CONF_VBLANK_MODE(DRI_CONF_VBLANK_DEF_INTERVAL_1)
54 DRI_CONF_SECTION_END
55 DRI_CONF_SECTION_NINE
56 DRI_CONF_NINE_OVERRIDEVENDOR(-1)
57 DRI_CONF_NINE_THROTTLE(-2)
58 DRI_CONF_NINE_THREADSUBMIT("false")
59 DRI_CONF_NINE_ALLOWDISCARDDELAYEDRELEASE("true")
60 DRI_CONF_NINE_TEARFREEDISCARD("false")
61 DRI_CONF_NINE_CSMT(-1)
62 DRI_CONF_SECTION_END
63 DRI_CONF_END;
64
65 struct fallback_card_config {
66 const char *name;
67 unsigned vendor_id;
68 unsigned device_id;
69 } fallback_cards[] = {
70 {"NV124", 0x10de, 0x13C2}, /* NVIDIA GeForce GTX 970 */
71 {"HAWAII", 0x1002, 0x67b1}, /* AMD Radeon R9 290 */
72 {"Haswell Mobile", 0x8086, 0x13C2}, /* Intel Haswell Mobile */
73 {"SVGA3D", 0x15ad, 0x0405}, /* VMware SVGA 3D */
74 };
75
76 /* prototypes */
77 void
78 d3d_match_vendor_id( D3DADAPTER_IDENTIFIER9* drvid,
79 unsigned fallback_ven,
80 unsigned fallback_dev,
81 const char* fallback_name );
82
83 void d3d_fill_driver_version(D3DADAPTER_IDENTIFIER9* drvid);
84
85 void d3d_fill_cardname(D3DADAPTER_IDENTIFIER9* drvid);
86
87 struct d3dadapter9drm_context
88 {
89 struct d3dadapter9_context base;
90 struct pipe_loader_device *dev, *swdev;
91 int fd;
92 };
93
94 static void
drm_destroy(struct d3dadapter9_context * ctx)95 drm_destroy( struct d3dadapter9_context *ctx )
96 {
97 struct d3dadapter9drm_context *drm = (struct d3dadapter9drm_context *)ctx;
98
99 if (ctx->ref)
100 ctx->ref->destroy(ctx->ref);
101 /* because ref is a wrapper around hal, freeing ref frees hal too. */
102 else if (ctx->hal)
103 ctx->hal->destroy(ctx->hal);
104
105 if (drm->swdev)
106 pipe_loader_release(&drm->swdev, 1);
107 if (drm->dev)
108 pipe_loader_release(&drm->dev, 1);
109
110 close(drm->fd);
111 FREE(ctx);
112 }
113
114 static inline void
get_bus_info(int fd,DWORD * vendorid,DWORD * deviceid,DWORD * subsysid,DWORD * revision)115 get_bus_info( int fd,
116 DWORD *vendorid,
117 DWORD *deviceid,
118 DWORD *subsysid,
119 DWORD *revision )
120 {
121 int vid, did;
122
123 if (loader_get_pci_id_for_fd(fd, &vid, &did)) {
124 DBG("PCI info: vendor=0x%04x, device=0x%04x\n",
125 vid, did);
126 *vendorid = vid;
127 *deviceid = did;
128 *subsysid = 0;
129 *revision = 0;
130 } else {
131 DBG("Unable to detect card. Faking %s\n", fallback_cards[0].name);
132 *vendorid = fallback_cards[0].vendor_id;
133 *deviceid = fallback_cards[0].device_id;
134 *subsysid = 0;
135 *revision = 0;
136 }
137 }
138
139 static inline void
read_descriptor(struct d3dadapter9_context * ctx,int fd,int override_vendorid)140 read_descriptor( struct d3dadapter9_context *ctx,
141 int fd, int override_vendorid )
142 {
143 unsigned i;
144 BOOL found;
145 D3DADAPTER_IDENTIFIER9 *drvid = &ctx->identifier;
146
147 memset(drvid, 0, sizeof(*drvid));
148 get_bus_info(fd, &drvid->VendorId, &drvid->DeviceId,
149 &drvid->SubSysId, &drvid->Revision);
150 snprintf(drvid->DeviceName, sizeof(drvid->DeviceName),
151 "Gallium 0.4 with %s", ctx->hal->get_vendor(ctx->hal));
152 strncpy(drvid->Description, ctx->hal->get_name(ctx->hal),
153 sizeof(drvid->Description));
154
155 if (override_vendorid > 0) {
156 found = FALSE;
157 /* fill in device_id and card name for fake vendor */
158 for (i = 0; i < sizeof(fallback_cards)/sizeof(fallback_cards[0]); i++) {
159 if (fallback_cards[i].vendor_id == override_vendorid) {
160 DBG("Faking card '%s' vendor 0x%04x, device 0x%04x\n",
161 fallback_cards[i].name,
162 fallback_cards[i].vendor_id,
163 fallback_cards[i].device_id);
164 drvid->VendorId = fallback_cards[i].vendor_id;
165 drvid->DeviceId = fallback_cards[i].device_id;
166 strncpy(drvid->Description, fallback_cards[i].name,
167 sizeof(drvid->Description));
168 found = TRUE;
169 break;
170 }
171 }
172 if (!found) {
173 DBG("Unknown fake vendor 0x%04x! Using detected vendor !\n", override_vendorid);
174 }
175 }
176 /* choose fall-back vendor if necessary to allow
177 * the following functions to return sane results */
178 d3d_match_vendor_id(drvid, fallback_cards[0].vendor_id, fallback_cards[0].device_id, fallback_cards[0].name);
179 /* fill in driver name and version info */
180 d3d_fill_driver_version(drvid);
181 /* override Description field with Windows like names */
182 d3d_fill_cardname(drvid);
183
184 /* this driver isn't WHQL certified */
185 drvid->WHQLLevel = 0;
186
187 /* this value is fixed */
188 drvid->DeviceIdentifier.Data1 = 0xaeb2cdd4;
189 drvid->DeviceIdentifier.Data2 = 0x6e41;
190 drvid->DeviceIdentifier.Data3 = 0x43ea;
191 drvid->DeviceIdentifier.Data4[0] = 0x94;
192 drvid->DeviceIdentifier.Data4[1] = 0x1c;
193 drvid->DeviceIdentifier.Data4[2] = 0x83;
194 drvid->DeviceIdentifier.Data4[3] = 0x61;
195 drvid->DeviceIdentifier.Data4[4] = 0xcc;
196 drvid->DeviceIdentifier.Data4[5] = 0x76;
197 drvid->DeviceIdentifier.Data4[6] = 0x07;
198 drvid->DeviceIdentifier.Data4[7] = 0x81;
199 }
200
201 static HRESULT WINAPI
drm_create_adapter(int fd,ID3DAdapter9 ** ppAdapter)202 drm_create_adapter( int fd,
203 ID3DAdapter9 **ppAdapter )
204 {
205 struct d3dadapter9drm_context *ctx = CALLOC_STRUCT(d3dadapter9drm_context);
206 HRESULT hr;
207 bool different_device;
208 const struct drm_conf_ret *throttle_ret = NULL;
209 const struct drm_conf_ret *dmabuf_ret = NULL;
210 driOptionCache defaultInitOptions;
211 driOptionCache userInitOptions;
212 int throttling_value_user = -2;
213 int override_vendorid = -1;
214
215 if (!ctx) { return E_OUTOFMEMORY; }
216
217 ctx->base.destroy = drm_destroy;
218
219 /* Although the fd is provided from external source, mesa/nine
220 * takes ownership of it. */
221 fd = loader_get_user_preferred_fd(fd, &different_device);
222 ctx->fd = fd;
223 ctx->base.linear_framebuffer = different_device;
224
225 if (!pipe_loader_drm_probe_fd(&ctx->dev, fd)) {
226 ERR("Failed to probe drm fd %d.\n", fd);
227 FREE(ctx);
228 close(fd);
229 return D3DERR_DRIVERINTERNALERROR;
230 }
231
232 ctx->base.hal = pipe_loader_create_screen(ctx->dev);
233 if (!ctx->base.hal) {
234 ERR("Unable to load requested driver.\n");
235 drm_destroy(&ctx->base);
236 return D3DERR_DRIVERINTERNALERROR;
237 }
238
239 dmabuf_ret = pipe_loader_configuration(ctx->dev, DRM_CONF_SHARE_FD);
240 throttle_ret = pipe_loader_configuration(ctx->dev, DRM_CONF_THROTTLE);
241 if (!dmabuf_ret || !dmabuf_ret->val.val_bool) {
242 ERR("The driver is not capable of dma-buf sharing."
243 "Abandon to load nine state tracker\n");
244 drm_destroy(&ctx->base);
245 return D3DERR_DRIVERINTERNALERROR;
246 }
247
248 if (throttle_ret && throttle_ret->val.val_int != -1) {
249 ctx->base.throttling = TRUE;
250 ctx->base.throttling_value = throttle_ret->val.val_int;
251 } else
252 ctx->base.throttling = FALSE;
253
254 driParseOptionInfo(&defaultInitOptions, __driConfigOptionsNine);
255 driParseConfigFiles(&userInitOptions, &defaultInitOptions, 0, "nine");
256 if (driCheckOption(&userInitOptions, "throttle_value", DRI_INT)) {
257 throttling_value_user = driQueryOptioni(&userInitOptions, "throttle_value");
258 if (throttling_value_user == -1)
259 ctx->base.throttling = FALSE;
260 else if (throttling_value_user >= 0) {
261 ctx->base.throttling = TRUE;
262 ctx->base.throttling_value = throttling_value_user;
263 }
264 }
265
266 if (driCheckOption(&userInitOptions, "vblank_mode", DRI_ENUM))
267 ctx->base.vblank_mode = driQueryOptioni(&userInitOptions, "vblank_mode");
268 else
269 ctx->base.vblank_mode = 1;
270
271 if (driCheckOption(&userInitOptions, "thread_submit", DRI_BOOL))
272 ctx->base.thread_submit = driQueryOptionb(&userInitOptions, "thread_submit");
273 else
274 ctx->base.thread_submit = different_device;
275
276 if (ctx->base.thread_submit && (throttling_value_user == -2 || throttling_value_user == 0)) {
277 ctx->base.throttling_value = 0;
278 } else if (ctx->base.thread_submit) {
279 DBG("You have set a non standard throttling value in combination with thread_submit."
280 "We advise to use a throttling value of -2/0");
281 }
282 if (ctx->base.thread_submit && !different_device)
283 DBG("You have set thread_submit but do not use a different device than the server."
284 "You should not expect any benefit.");
285
286 if (driCheckOption(&userInitOptions, "override_vendorid", DRI_INT)) {
287 override_vendorid = driQueryOptioni(&userInitOptions, "override_vendorid");
288 }
289
290 if (driCheckOption(&userInitOptions, "discard_delayed_release", DRI_BOOL))
291 ctx->base.discard_delayed_release = driQueryOptionb(&userInitOptions, "discard_delayed_release");
292 else
293 ctx->base.discard_delayed_release = TRUE;
294
295 if (driCheckOption(&userInitOptions, "tearfree_discard", DRI_BOOL))
296 ctx->base.tearfree_discard = driQueryOptionb(&userInitOptions, "tearfree_discard");
297 else
298 ctx->base.tearfree_discard = FALSE;
299
300 if (ctx->base.tearfree_discard && !ctx->base.discard_delayed_release) {
301 ERR("tearfree_discard requires discard_delayed_release\n");
302 ctx->base.tearfree_discard = FALSE;
303 }
304
305 if (driCheckOption(&userInitOptions, "csmt_force", DRI_INT))
306 ctx->base.csmt_force = driQueryOptioni(&userInitOptions, "csmt_force");
307 else
308 ctx->base.csmt_force = -1;
309
310 driDestroyOptionCache(&userInitOptions);
311 driDestroyOptionInfo(&defaultInitOptions);
312
313 /* wrap it to create a software screen that can share resources */
314 if (pipe_loader_sw_probe_wrapped(&ctx->swdev, ctx->base.hal))
315 ctx->base.ref = pipe_loader_create_screen(ctx->swdev);
316
317 if (!ctx->base.ref) {
318 ERR("Couldn't wrap drm screen to swrast screen. Software devices "
319 "will be unavailable.\n");
320 }
321
322 /* read out PCI info */
323 read_descriptor(&ctx->base, fd, override_vendorid);
324
325 /* create and return new ID3DAdapter9 */
326 hr = NineAdapter9_new(&ctx->base, (struct NineAdapter9 **)ppAdapter);
327 if (FAILED(hr)) {
328 drm_destroy(&ctx->base);
329 return hr;
330 }
331
332 return D3D_OK;
333 }
334
335 const struct D3DAdapter9DRM drm9_desc = {
336 .major_version = D3DADAPTER9DRM_MAJOR,
337 .minor_version = D3DADAPTER9DRM_MINOR,
338 .create_adapter = drm_create_adapter
339 };
340