1 /**************************************************************************
3 * Copyright © 2009-2015 VMware, Inc., Palo Alto, CA., USA
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
21 * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
22 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
23 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
24 * USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **************************************************************************/
28 #include "vmwgfx_drv.h"
29 #include <drm/vmwgfx_drm.h>
30 #include "vmwgfx_kms.h"
31 #include "device_include/svga3d_caps.h"
33 struct svga_3d_compat_cap
{
34 SVGA3dCapsRecordHeader header
;
35 SVGA3dCapPair pairs
[SVGA3D_DEVCAP_MAX
];
38 int vmw_getparam_ioctl(struct drm_device
*dev
, void *data
,
39 struct drm_file
*file_priv
)
41 struct vmw_private
*dev_priv
= vmw_priv(dev
);
42 struct drm_vmw_getparam_arg
*param
=
43 (struct drm_vmw_getparam_arg
*)data
;
44 struct vmw_fpriv
*vmw_fp
= vmw_fpriv(file_priv
);
46 switch (param
->param
) {
47 case DRM_VMW_PARAM_NUM_STREAMS
:
48 param
->value
= vmw_overlay_num_overlays(dev_priv
);
50 case DRM_VMW_PARAM_NUM_FREE_STREAMS
:
51 param
->value
= vmw_overlay_num_free_overlays(dev_priv
);
53 case DRM_VMW_PARAM_3D
:
54 param
->value
= vmw_fifo_have_3d(dev_priv
) ? 1 : 0;
56 case DRM_VMW_PARAM_HW_CAPS
:
57 param
->value
= dev_priv
->capabilities
;
59 case DRM_VMW_PARAM_FIFO_CAPS
:
60 param
->value
= dev_priv
->fifo
.capabilities
;
62 case DRM_VMW_PARAM_MAX_FB_SIZE
:
63 param
->value
= dev_priv
->prim_bb_mem
;
65 case DRM_VMW_PARAM_FIFO_HW_VERSION
:
67 u32 __iomem
*fifo_mem
= dev_priv
->mmio_virt
;
68 const struct vmw_fifo_state
*fifo
= &dev_priv
->fifo
;
70 if ((dev_priv
->capabilities
& SVGA_CAP_GBOBJECTS
)) {
71 param
->value
= SVGA3D_HWVERSION_WS8_B1
;
77 ((fifo
->capabilities
&
78 SVGA_FIFO_CAP_3D_HWVERSION_REVISED
) ?
79 SVGA_FIFO_3D_HWVERSION_REVISED
:
80 SVGA_FIFO_3D_HWVERSION
));
83 case DRM_VMW_PARAM_MAX_SURF_MEMORY
:
84 if ((dev_priv
->capabilities
& SVGA_CAP_GBOBJECTS
) &&
86 param
->value
= dev_priv
->max_mob_pages
* PAGE_SIZE
/ 2;
88 param
->value
= dev_priv
->memory_size
;
90 case DRM_VMW_PARAM_3D_CAPS_SIZE
:
91 if ((dev_priv
->capabilities
& SVGA_CAP_GBOBJECTS
) &&
93 param
->value
= SVGA3D_DEVCAP_MAX
* sizeof(uint32_t);
94 else if (dev_priv
->capabilities
& SVGA_CAP_GBOBJECTS
)
95 param
->value
= sizeof(struct svga_3d_compat_cap
) +
98 param
->value
= (SVGA_FIFO_3D_CAPS_LAST
-
99 SVGA_FIFO_3D_CAPS
+ 1) *
102 case DRM_VMW_PARAM_MAX_MOB_MEMORY
:
103 vmw_fp
->gb_aware
= true;
104 param
->value
= dev_priv
->max_mob_pages
* PAGE_SIZE
;
106 case DRM_VMW_PARAM_MAX_MOB_SIZE
:
107 param
->value
= dev_priv
->max_mob_size
;
109 case DRM_VMW_PARAM_SCREEN_TARGET
:
111 (dev_priv
->active_display_unit
== vmw_du_screen_target
);
113 case DRM_VMW_PARAM_DX
:
114 param
->value
= dev_priv
->has_dx
;
117 DRM_ERROR("Illegal vmwgfx get param request: %d\n",
125 static int vmw_fill_compat_cap(struct vmw_private
*dev_priv
, void *bounce
,
128 struct svga_3d_compat_cap
*compat_cap
=
129 (struct svga_3d_compat_cap
*) bounce
;
131 size_t pair_offset
= offsetof(struct svga_3d_compat_cap
, pairs
);
132 unsigned int max_size
;
134 if (size
< pair_offset
)
137 max_size
= (size
- pair_offset
) / sizeof(SVGA3dCapPair
);
139 if (max_size
> SVGA3D_DEVCAP_MAX
)
140 max_size
= SVGA3D_DEVCAP_MAX
;
142 compat_cap
->header
.length
=
143 (pair_offset
+ max_size
* sizeof(SVGA3dCapPair
)) / sizeof(u32
);
144 compat_cap
->header
.type
= SVGA3DCAPS_RECORD_DEVCAPS
;
146 spin_lock(&dev_priv
->cap_lock
);
147 for (i
= 0; i
< max_size
; ++i
) {
148 vmw_write(dev_priv
, SVGA_REG_DEV_CAP
, i
);
149 compat_cap
->pairs
[i
][0] = i
;
150 compat_cap
->pairs
[i
][1] = vmw_read(dev_priv
, SVGA_REG_DEV_CAP
);
152 spin_unlock(&dev_priv
->cap_lock
);
158 int vmw_get_cap_3d_ioctl(struct drm_device
*dev
, void *data
,
159 struct drm_file
*file_priv
)
161 struct drm_vmw_get_3d_cap_arg
*arg
=
162 (struct drm_vmw_get_3d_cap_arg
*) data
;
163 struct vmw_private
*dev_priv
= vmw_priv(dev
);
165 u32 __iomem
*fifo_mem
;
166 void __user
*buffer
= (void __user
*)((unsigned long)(arg
->buffer
));
169 bool gb_objects
= !!(dev_priv
->capabilities
& SVGA_CAP_GBOBJECTS
);
170 struct vmw_fpriv
*vmw_fp
= vmw_fpriv(file_priv
);
172 if (unlikely(arg
->pad64
!= 0)) {
173 DRM_ERROR("Illegal GET_3D_CAP argument.\n");
177 if (gb_objects
&& vmw_fp
->gb_aware
)
178 size
= SVGA3D_DEVCAP_MAX
* sizeof(uint32_t);
180 size
= sizeof(struct svga_3d_compat_cap
) + sizeof(uint32_t);
182 size
= (SVGA_FIFO_3D_CAPS_LAST
- SVGA_FIFO_3D_CAPS
+ 1) *
185 if (arg
->max_size
< size
)
186 size
= arg
->max_size
;
188 bounce
= vzalloc(size
);
189 if (unlikely(bounce
== NULL
)) {
190 DRM_ERROR("Failed to allocate bounce buffer for 3D caps.\n");
194 if (gb_objects
&& vmw_fp
->gb_aware
) {
196 uint32_t *bounce32
= (uint32_t *) bounce
;
198 num
= size
/ sizeof(uint32_t);
199 if (num
> SVGA3D_DEVCAP_MAX
)
200 num
= SVGA3D_DEVCAP_MAX
;
202 spin_lock(&dev_priv
->cap_lock
);
203 for (i
= 0; i
< num
; ++i
) {
204 vmw_write(dev_priv
, SVGA_REG_DEV_CAP
, i
);
205 *bounce32
++ = vmw_read(dev_priv
, SVGA_REG_DEV_CAP
);
207 spin_unlock(&dev_priv
->cap_lock
);
208 } else if (gb_objects
) {
209 ret
= vmw_fill_compat_cap(dev_priv
, bounce
, size
);
210 if (unlikely(ret
!= 0))
213 fifo_mem
= dev_priv
->mmio_virt
;
214 memcpy_fromio(bounce
, &fifo_mem
[SVGA_FIFO_3D_CAPS
], size
);
217 ret
= copy_to_user(buffer
, bounce
, size
);
223 if (unlikely(ret
!= 0))
224 DRM_ERROR("Failed to report 3D caps info.\n");
229 int vmw_present_ioctl(struct drm_device
*dev
, void *data
,
230 struct drm_file
*file_priv
)
232 struct ttm_object_file
*tfile
= vmw_fpriv(file_priv
)->tfile
;
233 struct vmw_private
*dev_priv
= vmw_priv(dev
);
234 struct drm_vmw_present_arg
*arg
=
235 (struct drm_vmw_present_arg
*)data
;
236 struct vmw_surface
*surface
;
237 struct drm_vmw_rect __user
*clips_ptr
;
238 struct drm_vmw_rect
*clips
= NULL
;
239 struct drm_framebuffer
*fb
;
240 struct vmw_framebuffer
*vfb
;
241 struct vmw_resource
*res
;
245 num_clips
= arg
->num_clips
;
246 clips_ptr
= (struct drm_vmw_rect __user
*)(unsigned long)arg
->clips_ptr
;
248 if (unlikely(num_clips
== 0))
251 if (clips_ptr
== NULL
) {
252 DRM_ERROR("Variable clips_ptr must be specified.\n");
257 clips
= kcalloc(num_clips
, sizeof(*clips
), GFP_KERNEL
);
259 DRM_ERROR("Failed to allocate clip rect list.\n");
264 ret
= copy_from_user(clips
, clips_ptr
, num_clips
* sizeof(*clips
));
266 DRM_ERROR("Failed to copy clip rects from userspace.\n");
271 drm_modeset_lock_all(dev
);
273 fb
= drm_framebuffer_lookup(dev
, arg
->fb_id
);
275 DRM_ERROR("Invalid framebuffer id.\n");
279 vfb
= vmw_framebuffer_to_vfb(fb
);
281 ret
= ttm_read_lock(&dev_priv
->reservation_sem
, true);
282 if (unlikely(ret
!= 0))
283 goto out_no_ttm_lock
;
285 ret
= vmw_user_resource_lookup_handle(dev_priv
, tfile
, arg
->sid
,
286 user_surface_converter
,
291 surface
= vmw_res_to_srf(res
);
292 ret
= vmw_kms_present(dev_priv
, file_priv
,
293 vfb
, surface
, arg
->sid
,
294 arg
->dest_x
, arg
->dest_y
,
297 /* vmw_user_surface_lookup takes one ref so does new_fb */
298 vmw_surface_unreference(&surface
);
301 ttm_read_unlock(&dev_priv
->reservation_sem
);
303 drm_framebuffer_unreference(fb
);
305 drm_modeset_unlock_all(dev
);
312 int vmw_present_readback_ioctl(struct drm_device
*dev
, void *data
,
313 struct drm_file
*file_priv
)
315 struct vmw_private
*dev_priv
= vmw_priv(dev
);
316 struct drm_vmw_present_readback_arg
*arg
=
317 (struct drm_vmw_present_readback_arg
*)data
;
318 struct drm_vmw_fence_rep __user
*user_fence_rep
=
319 (struct drm_vmw_fence_rep __user
*)
320 (unsigned long)arg
->fence_rep
;
321 struct drm_vmw_rect __user
*clips_ptr
;
322 struct drm_vmw_rect
*clips
= NULL
;
323 struct drm_framebuffer
*fb
;
324 struct vmw_framebuffer
*vfb
;
328 num_clips
= arg
->num_clips
;
329 clips_ptr
= (struct drm_vmw_rect __user
*)(unsigned long)arg
->clips_ptr
;
331 if (unlikely(num_clips
== 0))
334 if (clips_ptr
== NULL
) {
335 DRM_ERROR("Argument clips_ptr must be specified.\n");
340 clips
= kcalloc(num_clips
, sizeof(*clips
), GFP_KERNEL
);
342 DRM_ERROR("Failed to allocate clip rect list.\n");
347 ret
= copy_from_user(clips
, clips_ptr
, num_clips
* sizeof(*clips
));
349 DRM_ERROR("Failed to copy clip rects from userspace.\n");
354 drm_modeset_lock_all(dev
);
356 fb
= drm_framebuffer_lookup(dev
, arg
->fb_id
);
358 DRM_ERROR("Invalid framebuffer id.\n");
363 vfb
= vmw_framebuffer_to_vfb(fb
);
365 DRM_ERROR("Framebuffer not dmabuf backed.\n");
367 goto out_no_ttm_lock
;
370 ret
= ttm_read_lock(&dev_priv
->reservation_sem
, true);
371 if (unlikely(ret
!= 0))
372 goto out_no_ttm_lock
;
374 ret
= vmw_kms_readback(dev_priv
, file_priv
,
378 ttm_read_unlock(&dev_priv
->reservation_sem
);
380 drm_framebuffer_unreference(fb
);
382 drm_modeset_unlock_all(dev
);
391 * vmw_fops_poll - wrapper around the drm_poll function
393 * @filp: See the linux fops poll documentation.
394 * @wait: See the linux fops poll documentation.
396 * Wrapper around the drm_poll function that makes sure the device is
397 * processing the fifo if drm_poll decides to wait.
399 unsigned int vmw_fops_poll(struct file
*filp
, struct poll_table_struct
*wait
)
401 struct drm_file
*file_priv
= filp
->private_data
;
402 struct vmw_private
*dev_priv
=
403 vmw_priv(file_priv
->minor
->dev
);
405 vmw_fifo_ping_host(dev_priv
, SVGA_SYNC_GENERIC
);
406 return drm_poll(filp
, wait
);
411 * vmw_fops_read - wrapper around the drm_read function
413 * @filp: See the linux fops read documentation.
414 * @buffer: See the linux fops read documentation.
415 * @count: See the linux fops read documentation.
416 * offset: See the linux fops read documentation.
418 * Wrapper around the drm_read function that makes sure the device is
419 * processing the fifo if drm_read decides to wait.
421 ssize_t
vmw_fops_read(struct file
*filp
, char __user
*buffer
,
422 size_t count
, loff_t
*offset
)
424 struct drm_file
*file_priv
= filp
->private_data
;
425 struct vmw_private
*dev_priv
=
426 vmw_priv(file_priv
->minor
->dev
);
428 vmw_fifo_ping_host(dev_priv
, SVGA_SYNC_GENERIC
);
429 return drm_read(filp
, buffer
, count
, offset
);