1 /********************************************************** 2 * Copyright 2009-2015 VMware, Inc. All rights reserved. 3 * 4 * Permission is hereby granted, free of charge, to any person 5 * obtaining a copy of this software and associated documentation 6 * files (the "Software"), to deal in the Software without 7 * restriction, including without limitation the rights to use, copy, 8 * modify, merge, publish, distribute, sublicense, and/or sell copies 9 * of the Software, and to permit persons to whom the Software is 10 * furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice shall be 13 * included in all copies or substantial portions of the Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 16 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 18 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 19 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 20 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 21 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 22 * SOFTWARE. 23 * 24 **********************************************************/ 25 26 27 #include "pipe/p_compiler.h" 28 #include "util/u_inlines.h" 29 #include "util/u_memory.h" 30 #include "util/u_format.h" 31 32 #include "vmw_context.h" 33 #include "vmw_screen.h" 34 #include "vmw_surface.h" 35 #include "vmw_buffer.h" 36 #include "svga_drm_public.h" 37 #include "svga3d_surfacedefs.h" 38 39 #include "state_tracker/drm_driver.h" 40 41 #include "vmwgfx_drm.h" 42 #include <xf86drm.h> 43 44 #include <stdio.h> 45 #include <fcntl.h> 46 47 struct dri1_api_version { 48 int major; 49 int minor; 50 int patch_level; 51 }; 52 53 static struct svga_winsys_surface * 54 vmw_drm_surface_from_handle(struct svga_winsys_screen *sws, 55 struct winsys_handle *whandle, 56 SVGA3dSurfaceFormat *format); 57 58 static struct svga_winsys_surface * 59 vmw_drm_gb_surface_from_handle(struct svga_winsys_screen *sws, 60 struct winsys_handle *whandle, 61 SVGA3dSurfaceFormat *format); 62 static boolean 63 vmw_drm_surface_get_handle(struct svga_winsys_screen *sws, 64 struct svga_winsys_surface *surface, 65 unsigned stride, 66 struct winsys_handle *whandle); 67 68 static struct dri1_api_version drm_required = { 2, 1, 0 }; 69 static struct dri1_api_version drm_compat = { 2, 0, 0 }; 70 71 static boolean 72 vmw_dri1_check_version(const struct dri1_api_version *cur, 73 const struct dri1_api_version *required, 74 const struct dri1_api_version *compat, 75 const char component[]) 76 { 77 if (cur->major > required->major && cur->major <= compat->major) 78 return TRUE; 79 if (cur->major == required->major && cur->minor >= required->minor) 80 return TRUE; 81 82 vmw_error("%s version failure.\n", component); 83 vmw_error("%s version is %d.%d.%d and this driver can only work\n" 84 "with versions %d.%d.x through %d.x.x.\n", 85 component, 86 cur->major, cur->minor, cur->patch_level, 87 required->major, required->minor, compat->major); 88 return FALSE; 89 } 90 91 /* This is actually the entrypoint to the entire driver, 92 * called by the target bootstrap code. 93 */ 94 struct svga_winsys_screen * 95 svga_drm_winsys_screen_create(int fd) 96 { 97 struct vmw_winsys_screen *vws; 98 struct dri1_api_version drm_ver; 99 drmVersionPtr ver; 100 101 ver = drmGetVersion(fd); 102 if (ver == NULL) 103 return NULL; 104 105 drm_ver.major = ver->version_major; 106 drm_ver.minor = ver->version_minor; 107 drm_ver.patch_level = 0; /* ??? */ 108 109 drmFreeVersion(ver); 110 if (!vmw_dri1_check_version(&drm_ver, &drm_required, 111 &drm_compat, "vmwgfx drm driver")) 112 return NULL; 113 114 vws = vmw_winsys_create(fd); 115 if (!vws) 116 goto out_no_vws; 117 118 /* XXX do this properly */ 119 vws->base.surface_from_handle = vws->base.have_gb_objects ? 120 vmw_drm_gb_surface_from_handle : vmw_drm_surface_from_handle; 121 vws->base.surface_get_handle = vmw_drm_surface_get_handle; 122 123 return &vws->base; 124 125 out_no_vws: 126 return NULL; 127 } 128 129 static inline boolean 130 vmw_dri1_intersect_src_bbox(struct drm_clip_rect *dst, 131 int dst_x, 132 int dst_y, 133 const struct drm_clip_rect *src, 134 const struct drm_clip_rect *bbox) 135 { 136 int xy1; 137 int xy2; 138 139 xy1 = ((int)src->x1 > (int)bbox->x1 + dst_x) ? src->x1 : 140 (int)bbox->x1 + dst_x; 141 xy2 = ((int)src->x2 < (int)bbox->x2 + dst_x) ? src->x2 : 142 (int)bbox->x2 + dst_x; 143 if (xy1 >= xy2 || xy1 < 0) 144 return FALSE; 145 146 dst->x1 = xy1; 147 dst->x2 = xy2; 148 149 xy1 = ((int)src->y1 > (int)bbox->y1 + dst_y) ? src->y1 : 150 (int)bbox->y1 + dst_y; 151 xy2 = ((int)src->y2 < (int)bbox->y2 + dst_y) ? src->y2 : 152 (int)bbox->y2 + dst_y; 153 if (xy1 >= xy2 || xy1 < 0) 154 return FALSE; 155 156 dst->y1 = xy1; 157 dst->y2 = xy2; 158 return TRUE; 159 } 160 161 /** 162 * vmw_drm_gb_surface_from_handle - Create a shared surface 163 * 164 * @sws: Screen to register the surface with. 165 * @whandle: struct winsys_handle identifying the kernel surface object 166 * @format: On successful return points to a value describing the 167 * surface format. 168 * 169 * Returns a refcounted pointer to a struct svga_winsys_surface 170 * embedded in a struct vmw_svga_winsys_surface on success or NULL 171 * on failure. 172 */ 173 static struct svga_winsys_surface * 174 vmw_drm_gb_surface_from_handle(struct svga_winsys_screen *sws, 175 struct winsys_handle *whandle, 176 SVGA3dSurfaceFormat *format) 177 { 178 struct vmw_svga_winsys_surface *vsrf; 179 struct svga_winsys_surface *ssrf; 180 struct vmw_winsys_screen *vws = vmw_winsys_screen(sws); 181 SVGA3dSurfaceFlags flags; 182 uint32_t mip_levels; 183 struct vmw_buffer_desc desc; 184 struct pb_manager *provider = vws->pools.gmr; 185 struct pb_buffer *pb_buf; 186 uint32_t handle; 187 int ret; 188 189 if (whandle->offset != 0) { 190 fprintf(stderr, "Attempt to import unsupported winsys offset %u\n", 191 whandle->offset); 192 return NULL; 193 } 194 195 ret = vmw_ioctl_gb_surface_ref(vws, whandle, &flags, format, 196 &mip_levels, &handle, &desc.region); 197 198 if (ret) { 199 fprintf(stderr, "Failed referencing shared surface. SID %d.\n" 200 "Error %d (%s).\n", 201 whandle->handle, ret, strerror(-ret)); 202 return NULL; 203 } 204 205 if (mip_levels != 1) { 206 fprintf(stderr, "Incorrect number of mipmap levels on shared surface." 207 " SID %d, levels %d\n", 208 whandle->handle, mip_levels); 209 goto out_mip; 210 } 211 212 vsrf = CALLOC_STRUCT(vmw_svga_winsys_surface); 213 if (!vsrf) 214 goto out_mip; 215 216 pipe_reference_init(&vsrf->refcnt, 1); 217 p_atomic_set(&vsrf->validated, 0); 218 vsrf->screen = vws; 219 vsrf->sid = handle; 220 vsrf->size = vmw_region_size(desc.region); 221 222 /* 223 * Synchronize backing buffers of shared surfaces using the 224 * kernel, since we don't pass fence objects around between 225 * processes. 226 */ 227 desc.pb_desc.alignment = 4096; 228 desc.pb_desc.usage = VMW_BUFFER_USAGE_SHARED | VMW_BUFFER_USAGE_SYNC; 229 pb_buf = provider->create_buffer(provider, vsrf->size, &desc.pb_desc); 230 vsrf->buf = vmw_svga_winsys_buffer_wrap(pb_buf); 231 if (!vsrf->buf) 232 goto out_no_buf; 233 ssrf = svga_winsys_surface(vsrf); 234 235 return ssrf; 236 237 out_no_buf: 238 FREE(vsrf); 239 out_mip: 240 vmw_ioctl_region_destroy(desc.region); 241 vmw_ioctl_surface_destroy(vws, whandle->handle); 242 return NULL; 243 } 244 245 static struct svga_winsys_surface * 246 vmw_drm_surface_from_handle(struct svga_winsys_screen *sws, 247 struct winsys_handle *whandle, 248 SVGA3dSurfaceFormat *format) 249 { 250 struct vmw_svga_winsys_surface *vsrf; 251 struct svga_winsys_surface *ssrf; 252 struct vmw_winsys_screen *vws = vmw_winsys_screen(sws); 253 union drm_vmw_surface_reference_arg arg; 254 struct drm_vmw_surface_arg *req = &arg.req; 255 struct drm_vmw_surface_create_req *rep = &arg.rep; 256 uint32_t handle = 0; 257 struct drm_vmw_size size; 258 SVGA3dSize base_size; 259 int ret; 260 int i; 261 262 if (whandle->offset != 0) { 263 fprintf(stderr, "Attempt to import unsupported winsys offset %u\n", 264 whandle->offset); 265 return NULL; 266 } 267 268 switch (whandle->type) { 269 case DRM_API_HANDLE_TYPE_SHARED: 270 case DRM_API_HANDLE_TYPE_KMS: 271 handle = whandle->handle; 272 break; 273 case DRM_API_HANDLE_TYPE_FD: 274 ret = drmPrimeFDToHandle(vws->ioctl.drm_fd, whandle->handle, 275 &handle); 276 if (ret) { 277 vmw_error("Failed to get handle from prime fd %d.\n", 278 (int) whandle->handle); 279 return NULL; 280 } 281 break; 282 default: 283 vmw_error("Attempt to import unsupported handle type %d.\n", 284 whandle->type); 285 return NULL; 286 } 287 288 memset(&arg, 0, sizeof(arg)); 289 req->sid = handle; 290 rep->size_addr = (unsigned long)&size; 291 292 ret = drmCommandWriteRead(vws->ioctl.drm_fd, DRM_VMW_REF_SURFACE, 293 &arg, sizeof(arg)); 294 295 /* 296 * Need to close the handle we got from prime. 297 */ 298 if (whandle->type == DRM_API_HANDLE_TYPE_FD) 299 vmw_ioctl_surface_destroy(vws, handle); 300 301 if (ret) { 302 /* 303 * Any attempt to share something other than a surface, like a dumb 304 * kms buffer, should fail here. 305 */ 306 vmw_error("Failed referencing shared surface. SID %d.\n" 307 "Error %d (%s).\n", 308 handle, ret, strerror(-ret)); 309 return NULL; 310 } 311 312 if (rep->mip_levels[0] != 1) { 313 vmw_error("Incorrect number of mipmap levels on shared surface." 314 " SID %d, levels %d\n", 315 handle, rep->mip_levels[0]); 316 goto out_mip; 317 } 318 319 for (i=1; i < DRM_VMW_MAX_SURFACE_FACES; ++i) { 320 if (rep->mip_levels[i] != 0) { 321 vmw_error("Incorrect number of faces levels on shared surface." 322 " SID %d, face %d present.\n", 323 handle, i); 324 goto out_mip; 325 } 326 } 327 328 vsrf = CALLOC_STRUCT(vmw_svga_winsys_surface); 329 if (!vsrf) 330 goto out_mip; 331 332 pipe_reference_init(&vsrf->refcnt, 1); 333 p_atomic_set(&vsrf->validated, 0); 334 vsrf->screen = vws; 335 vsrf->sid = handle; 336 ssrf = svga_winsys_surface(vsrf); 337 *format = rep->format; 338 339 /* Estimate usage, for early flushing. */ 340 341 base_size.width = size.width; 342 base_size.height = size.height; 343 base_size.depth = size.depth; 344 vsrf->size = svga3dsurface_get_serialized_size(rep->format, base_size, 345 rep->mip_levels[0], 346 FALSE); 347 348 return ssrf; 349 350 out_mip: 351 vmw_ioctl_surface_destroy(vws, handle); 352 353 return NULL; 354 } 355 356 static boolean 357 vmw_drm_surface_get_handle(struct svga_winsys_screen *sws, 358 struct svga_winsys_surface *surface, 359 unsigned stride, 360 struct winsys_handle *whandle) 361 { 362 struct vmw_winsys_screen *vws = vmw_winsys_screen(sws); 363 struct vmw_svga_winsys_surface *vsrf; 364 int ret; 365 366 if (!surface) 367 return FALSE; 368 369 vsrf = vmw_svga_winsys_surface(surface); 370 whandle->handle = vsrf->sid; 371 whandle->stride = stride; 372 whandle->offset = 0; 373 374 switch (whandle->type) { 375 case DRM_API_HANDLE_TYPE_SHARED: 376 case DRM_API_HANDLE_TYPE_KMS: 377 whandle->handle = vsrf->sid; 378 break; 379 case DRM_API_HANDLE_TYPE_FD: 380 ret = drmPrimeHandleToFD(vws->ioctl.drm_fd, vsrf->sid, DRM_CLOEXEC, 381 (int *)&whandle->handle); 382 if (ret) { 383 vmw_error("Failed to get file descriptor from prime.\n"); 384 return FALSE; 385 } 386 break; 387 default: 388 vmw_error("Attempt to export unsupported handle type %d.\n", 389 whandle->type); 390 return FALSE; 391 } 392 393 return TRUE; 394 } 395
