1 /**************************************************************************
3 * Copyright © 2009 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"
32 struct svga_3d_compat_cap
{
33 SVGA3dCapsRecordHeader header
;
34 SVGA3dCapPair pairs
[SVGA3D_DEVCAP_MAX
];
37 int vmw_getparam_ioctl(struct drm_device
*dev
, void *data
,
38 struct drm_file
*file_priv
)
40 struct vmw_private
*dev_priv
= vmw_priv(dev
);
41 struct drm_vmw_getparam_arg
*param
=
42 (struct drm_vmw_getparam_arg
*)data
;
43 struct vmw_fpriv
*vmw_fp
= vmw_fpriv(file_priv
);
45 switch (param
->param
) {
46 case DRM_VMW_PARAM_NUM_STREAMS
:
47 param
->value
= vmw_overlay_num_overlays(dev_priv
);
49 case DRM_VMW_PARAM_NUM_FREE_STREAMS
:
50 param
->value
= vmw_overlay_num_free_overlays(dev_priv
);
52 case DRM_VMW_PARAM_3D
:
53 param
->value
= vmw_fifo_have_3d(dev_priv
) ? 1 : 0;
55 case DRM_VMW_PARAM_HW_CAPS
:
56 param
->value
= dev_priv
->capabilities
;
58 case DRM_VMW_PARAM_FIFO_CAPS
:
59 param
->value
= dev_priv
->fifo
.capabilities
;
61 case DRM_VMW_PARAM_MAX_FB_SIZE
:
62 param
->value
= dev_priv
->prim_bb_mem
;
64 case DRM_VMW_PARAM_FIFO_HW_VERSION
:
66 __le32 __iomem
*fifo_mem
= dev_priv
->mmio_virt
;
67 const struct vmw_fifo_state
*fifo
= &dev_priv
->fifo
;
69 if ((dev_priv
->capabilities
& SVGA_CAP_GBOBJECTS
)) {
70 param
->value
= SVGA3D_HWVERSION_WS8_B1
;
76 ((fifo
->capabilities
&
77 SVGA_FIFO_CAP_3D_HWVERSION_REVISED
) ?
78 SVGA_FIFO_3D_HWVERSION_REVISED
:
79 SVGA_FIFO_3D_HWVERSION
));
82 case DRM_VMW_PARAM_MAX_SURF_MEMORY
:
83 if ((dev_priv
->capabilities
& SVGA_CAP_GBOBJECTS
) &&
85 param
->value
= dev_priv
->max_mob_pages
* PAGE_SIZE
/ 2;
87 param
->value
= dev_priv
->memory_size
;
89 case DRM_VMW_PARAM_3D_CAPS_SIZE
:
90 if ((dev_priv
->capabilities
& SVGA_CAP_GBOBJECTS
) &&
92 param
->value
= SVGA3D_DEVCAP_MAX
* sizeof(uint32_t);
93 else if (dev_priv
->capabilities
& SVGA_CAP_GBOBJECTS
)
94 param
->value
= sizeof(struct svga_3d_compat_cap
) +
97 param
->value
= (SVGA_FIFO_3D_CAPS_LAST
-
98 SVGA_FIFO_3D_CAPS
+ 1) *
101 case DRM_VMW_PARAM_MAX_MOB_MEMORY
:
102 vmw_fp
->gb_aware
= true;
103 param
->value
= dev_priv
->max_mob_pages
* PAGE_SIZE
;
105 case DRM_VMW_PARAM_MAX_MOB_SIZE
:
106 param
->value
= dev_priv
->max_mob_size
;
109 DRM_ERROR("Illegal vmwgfx get param request: %d\n",
117 static int vmw_fill_compat_cap(struct vmw_private
*dev_priv
, void *bounce
,
120 struct svga_3d_compat_cap
*compat_cap
=
121 (struct svga_3d_compat_cap
*) bounce
;
123 size_t pair_offset
= offsetof(struct svga_3d_compat_cap
, pairs
);
124 unsigned int max_size
;
126 if (size
< pair_offset
)
129 max_size
= (size
- pair_offset
) / sizeof(SVGA3dCapPair
);
131 if (max_size
> SVGA3D_DEVCAP_MAX
)
132 max_size
= SVGA3D_DEVCAP_MAX
;
134 compat_cap
->header
.length
=
135 (pair_offset
+ max_size
* sizeof(SVGA3dCapPair
)) / sizeof(u32
);
136 compat_cap
->header
.type
= SVGA3DCAPS_RECORD_DEVCAPS
;
138 spin_lock(&dev_priv
->cap_lock
);
139 for (i
= 0; i
< max_size
; ++i
) {
140 vmw_write(dev_priv
, SVGA_REG_DEV_CAP
, i
);
141 compat_cap
->pairs
[i
][0] = i
;
142 compat_cap
->pairs
[i
][1] = vmw_read(dev_priv
, SVGA_REG_DEV_CAP
);
144 spin_unlock(&dev_priv
->cap_lock
);
150 int vmw_get_cap_3d_ioctl(struct drm_device
*dev
, void *data
,
151 struct drm_file
*file_priv
)
153 struct drm_vmw_get_3d_cap_arg
*arg
=
154 (struct drm_vmw_get_3d_cap_arg
*) data
;
155 struct vmw_private
*dev_priv
= vmw_priv(dev
);
157 __le32 __iomem
*fifo_mem
;
158 void __user
*buffer
= (void __user
*)((unsigned long)(arg
->buffer
));
161 bool gb_objects
= !!(dev_priv
->capabilities
& SVGA_CAP_GBOBJECTS
);
162 struct vmw_fpriv
*vmw_fp
= vmw_fpriv(file_priv
);
164 if (unlikely(arg
->pad64
!= 0)) {
165 DRM_ERROR("Illegal GET_3D_CAP argument.\n");
169 if (gb_objects
&& vmw_fp
->gb_aware
)
170 size
= SVGA3D_DEVCAP_MAX
* sizeof(uint32_t);
172 size
= sizeof(struct svga_3d_compat_cap
) + sizeof(uint32_t);
174 size
= (SVGA_FIFO_3D_CAPS_LAST
- SVGA_FIFO_3D_CAPS
+ 1) *
177 if (arg
->max_size
< size
)
178 size
= arg
->max_size
;
180 bounce
= vzalloc(size
);
181 if (unlikely(bounce
== NULL
)) {
182 DRM_ERROR("Failed to allocate bounce buffer for 3D caps.\n");
186 if (gb_objects
&& vmw_fp
->gb_aware
) {
188 uint32_t *bounce32
= (uint32_t *) bounce
;
190 num
= size
/ sizeof(uint32_t);
191 if (num
> SVGA3D_DEVCAP_MAX
)
192 num
= SVGA3D_DEVCAP_MAX
;
194 spin_lock(&dev_priv
->cap_lock
);
195 for (i
= 0; i
< num
; ++i
) {
196 vmw_write(dev_priv
, SVGA_REG_DEV_CAP
, i
);
197 *bounce32
++ = vmw_read(dev_priv
, SVGA_REG_DEV_CAP
);
199 spin_unlock(&dev_priv
->cap_lock
);
200 } else if (gb_objects
) {
201 ret
= vmw_fill_compat_cap(dev_priv
, bounce
, size
);
202 if (unlikely(ret
!= 0))
205 fifo_mem
= dev_priv
->mmio_virt
;
206 memcpy_fromio(bounce
, &fifo_mem
[SVGA_FIFO_3D_CAPS
], size
);
209 ret
= copy_to_user(buffer
, bounce
, size
);
215 if (unlikely(ret
!= 0))
216 DRM_ERROR("Failed to report 3D caps info.\n");
221 int vmw_present_ioctl(struct drm_device
*dev
, void *data
,
222 struct drm_file
*file_priv
)
224 struct ttm_object_file
*tfile
= vmw_fpriv(file_priv
)->tfile
;
225 struct vmw_private
*dev_priv
= vmw_priv(dev
);
226 struct drm_vmw_present_arg
*arg
=
227 (struct drm_vmw_present_arg
*)data
;
228 struct vmw_surface
*surface
;
229 struct drm_vmw_rect __user
*clips_ptr
;
230 struct drm_vmw_rect
*clips
= NULL
;
231 struct drm_framebuffer
*fb
;
232 struct vmw_framebuffer
*vfb
;
233 struct vmw_resource
*res
;
237 num_clips
= arg
->num_clips
;
238 clips_ptr
= (struct drm_vmw_rect
*)(unsigned long)arg
->clips_ptr
;
240 if (unlikely(num_clips
== 0))
243 if (clips_ptr
== NULL
) {
244 DRM_ERROR("Variable clips_ptr must be specified.\n");
249 clips
= kcalloc(num_clips
, sizeof(*clips
), GFP_KERNEL
);
251 DRM_ERROR("Failed to allocate clip rect list.\n");
256 ret
= copy_from_user(clips
, clips_ptr
, num_clips
* sizeof(*clips
));
258 DRM_ERROR("Failed to copy clip rects from userspace.\n");
263 drm_modeset_lock_all(dev
);
265 fb
= drm_framebuffer_lookup(dev
, arg
->fb_id
);
267 DRM_ERROR("Invalid framebuffer id.\n");
271 vfb
= vmw_framebuffer_to_vfb(fb
);
273 ret
= ttm_read_lock(&dev_priv
->reservation_sem
, true);
274 if (unlikely(ret
!= 0))
275 goto out_no_ttm_lock
;
277 ret
= vmw_user_resource_lookup_handle(dev_priv
, tfile
, arg
->sid
,
278 user_surface_converter
,
283 surface
= vmw_res_to_srf(res
);
284 ret
= vmw_kms_present(dev_priv
, file_priv
,
285 vfb
, surface
, arg
->sid
,
286 arg
->dest_x
, arg
->dest_y
,
289 /* vmw_user_surface_lookup takes one ref so does new_fb */
290 vmw_surface_unreference(&surface
);
293 ttm_read_unlock(&dev_priv
->reservation_sem
);
295 drm_framebuffer_unreference(fb
);
297 drm_modeset_unlock_all(dev
);
304 int vmw_present_readback_ioctl(struct drm_device
*dev
, void *data
,
305 struct drm_file
*file_priv
)
307 struct vmw_private
*dev_priv
= vmw_priv(dev
);
308 struct drm_vmw_present_readback_arg
*arg
=
309 (struct drm_vmw_present_readback_arg
*)data
;
310 struct drm_vmw_fence_rep __user
*user_fence_rep
=
311 (struct drm_vmw_fence_rep __user
*)
312 (unsigned long)arg
->fence_rep
;
313 struct drm_vmw_rect __user
*clips_ptr
;
314 struct drm_vmw_rect
*clips
= NULL
;
315 struct drm_framebuffer
*fb
;
316 struct vmw_framebuffer
*vfb
;
320 num_clips
= arg
->num_clips
;
321 clips_ptr
= (struct drm_vmw_rect
*)(unsigned long)arg
->clips_ptr
;
323 if (unlikely(num_clips
== 0))
326 if (clips_ptr
== NULL
) {
327 DRM_ERROR("Argument clips_ptr must be specified.\n");
332 clips
= kcalloc(num_clips
, sizeof(*clips
), GFP_KERNEL
);
334 DRM_ERROR("Failed to allocate clip rect list.\n");
339 ret
= copy_from_user(clips
, clips_ptr
, num_clips
* sizeof(*clips
));
341 DRM_ERROR("Failed to copy clip rects from userspace.\n");
346 drm_modeset_lock_all(dev
);
348 fb
= drm_framebuffer_lookup(dev
, arg
->fb_id
);
350 DRM_ERROR("Invalid framebuffer id.\n");
355 vfb
= vmw_framebuffer_to_vfb(fb
);
357 DRM_ERROR("Framebuffer not dmabuf backed.\n");
359 goto out_no_ttm_lock
;
362 ret
= ttm_read_lock(&dev_priv
->reservation_sem
, true);
363 if (unlikely(ret
!= 0))
364 goto out_no_ttm_lock
;
366 ret
= vmw_kms_readback(dev_priv
, file_priv
,
370 ttm_read_unlock(&dev_priv
->reservation_sem
);
372 drm_framebuffer_unreference(fb
);
374 drm_modeset_unlock_all(dev
);
383 * vmw_fops_poll - wrapper around the drm_poll function
385 * @filp: See the linux fops poll documentation.
386 * @wait: See the linux fops poll documentation.
388 * Wrapper around the drm_poll function that makes sure the device is
389 * processing the fifo if drm_poll decides to wait.
391 unsigned int vmw_fops_poll(struct file
*filp
, struct poll_table_struct
*wait
)
393 struct drm_file
*file_priv
= filp
->private_data
;
394 struct vmw_private
*dev_priv
=
395 vmw_priv(file_priv
->minor
->dev
);
397 vmw_fifo_ping_host(dev_priv
, SVGA_SYNC_GENERIC
);
398 return drm_poll(filp
, wait
);
403 * vmw_fops_read - wrapper around the drm_read function
405 * @filp: See the linux fops read documentation.
406 * @buffer: See the linux fops read documentation.
407 * @count: See the linux fops read documentation.
408 * offset: See the linux fops read documentation.
410 * Wrapper around the drm_read function that makes sure the device is
411 * processing the fifo if drm_read decides to wait.
413 ssize_t
vmw_fops_read(struct file
*filp
, char __user
*buffer
,
414 size_t count
, loff_t
*offset
)
416 struct drm_file
*file_priv
= filp
->private_data
;
417 struct vmw_private
*dev_priv
=
418 vmw_priv(file_priv
->minor
->dev
);
420 vmw_fifo_ping_host(dev_priv
, SVGA_SYNC_GENERIC
);
421 return drm_read(filp
, buffer
, count
, offset
);