1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28#ifndef _VMWGFX_DRV_H_
29#define _VMWGFX_DRV_H_
30
31#include <linux/suspend.h>
32#include <linux/sync_file.h>
33
34#include <drm/drm_auth.h>
35#include <drm/drm_device.h>
36#include <drm/drm_file.h>
37#include <drm/drm_hashtab.h>
38#include <drm/drm_rect.h>
39
40#include <drm/ttm/ttm_bo_driver.h>
41#include <drm/ttm/ttm_execbuf_util.h>
42#include <drm/ttm/ttm_module.h>
43
44#include "ttm_lock.h"
45#include "ttm_object.h"
46
47#include "vmwgfx_fence.h"
48#include "vmwgfx_reg.h"
49#include "vmwgfx_validation.h"
50
51
52
53
54
55#include <drm/vmwgfx_drm.h>
56
57
58#define VMWGFX_DRIVER_NAME "vmwgfx"
59#define VMWGFX_DRIVER_DATE "20200114"
60#define VMWGFX_DRIVER_MAJOR 2
61#define VMWGFX_DRIVER_MINOR 18
62#define VMWGFX_DRIVER_PATCHLEVEL 0
63#define VMWGFX_FIFO_STATIC_SIZE (1024*1024)
64#define VMWGFX_MAX_RELOCATIONS 2048
65#define VMWGFX_MAX_VALIDATIONS 2048
66#define VMWGFX_MAX_DISPLAYS 16
67#define VMWGFX_CMD_BOUNCE_INIT_SIZE 32768
68#define VMWGFX_ENABLE_SCREEN_TARGET_OTABLE 1
69
70
71
72
73#define VMWGFX_NUM_GB_CONTEXT 256
74#define VMWGFX_NUM_GB_SHADER 20000
75#define VMWGFX_NUM_GB_SURFACE 32768
76#define VMWGFX_NUM_GB_SCREEN_TARGET VMWGFX_MAX_DISPLAYS
77#define VMWGFX_NUM_DXCONTEXT 256
78#define VMWGFX_NUM_DXQUERY 512
79#define VMWGFX_NUM_MOB (VMWGFX_NUM_GB_CONTEXT +\
80 VMWGFX_NUM_GB_SHADER +\
81 VMWGFX_NUM_GB_SURFACE +\
82 VMWGFX_NUM_GB_SCREEN_TARGET)
83
84#define VMW_PL_GMR (TTM_PL_PRIV + 0)
85#define VMW_PL_FLAG_GMR (TTM_PL_FLAG_PRIV << 0)
86#define VMW_PL_MOB (TTM_PL_PRIV + 1)
87#define VMW_PL_FLAG_MOB (TTM_PL_FLAG_PRIV << 1)
88
89#define VMW_RES_CONTEXT ttm_driver_type0
90#define VMW_RES_SURFACE ttm_driver_type1
91#define VMW_RES_STREAM ttm_driver_type2
92#define VMW_RES_FENCE ttm_driver_type3
93#define VMW_RES_SHADER ttm_driver_type4
94
95struct vmw_fpriv {
96 struct ttm_object_file *tfile;
97 bool gb_aware;
98};
99
100
101
102
103
104
105
106
107
108
109
110
111
112struct vmw_buffer_object {
113 struct ttm_buffer_object base;
114 struct rb_root res_tree;
115 s32 pin_count;
116 atomic_t cpu_writers;
117
118 struct vmw_resource *dx_query_ctx;
119
120 struct ttm_bo_kmap_obj map;
121 u32 res_prios[TTM_MAX_BO_PRIORITY];
122 struct vmw_bo_dirty *dirty;
123};
124
125
126
127
128
129
130
131
132
133
134struct vmw_validate_buffer {
135 struct ttm_validate_buffer base;
136 struct drm_hash_item hash;
137 bool validate_as_mob;
138};
139
140struct vmw_res_func;
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171struct vmw_resource_dirty;
172struct vmw_resource {
173 struct kref kref;
174 struct vmw_private *dev_priv;
175 int id;
176 u32 used_prio;
177 unsigned long backup_size;
178 u32 res_dirty : 1;
179 u32 backup_dirty : 1;
180 u32 coherent : 1;
181 struct vmw_buffer_object *backup;
182 unsigned long backup_offset;
183 unsigned long pin_count;
184 const struct vmw_res_func *func;
185 struct rb_node mob_node;
186 struct list_head lru_head;
187 struct list_head binding_head;
188 struct vmw_resource_dirty *dirty;
189 void (*res_free) (struct vmw_resource *res);
190 void (*hw_destroy) (struct vmw_resource *res);
191};
192
193
194
195
196
197enum vmw_res_type {
198 vmw_res_context,
199 vmw_res_surface,
200 vmw_res_stream,
201 vmw_res_shader,
202 vmw_res_dx_context,
203 vmw_res_cotable,
204 vmw_res_view,
205 vmw_res_streamoutput,
206 vmw_res_max
207};
208
209
210
211
212enum vmw_cmdbuf_res_type {
213 vmw_cmdbuf_res_shader,
214 vmw_cmdbuf_res_view,
215 vmw_cmdbuf_res_streamoutput
216};
217
218struct vmw_cmdbuf_res_manager;
219
220struct vmw_cursor_snooper {
221 size_t age;
222 uint32_t *image;
223};
224
225struct vmw_framebuffer;
226struct vmw_surface_offset;
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249struct vmw_surface_metadata {
250 u64 flags;
251 u32 format;
252 u32 mip_levels[DRM_VMW_MAX_SURFACE_FACES];
253 u32 multisample_count;
254 u32 multisample_pattern;
255 u32 quality_level;
256 u32 autogen_filter;
257 u32 array_size;
258 u32 num_sizes;
259 u32 buffer_byte_stride;
260 struct drm_vmw_size base_size;
261 struct drm_vmw_size *sizes;
262 bool scanout;
263};
264
265
266
267
268
269
270
271
272
273
274struct vmw_surface {
275 struct vmw_resource res;
276 struct vmw_surface_metadata metadata;
277 struct vmw_cursor_snooper snooper;
278 struct vmw_surface_offset *offsets;
279 struct list_head view_list;
280};
281
282struct vmw_marker_queue {
283 struct list_head head;
284 u64 lag;
285 u64 lag_time;
286 spinlock_t lock;
287};
288
289struct vmw_fifo_state {
290 unsigned long reserved_size;
291 u32 *dynamic_buffer;
292 u32 *static_buffer;
293 unsigned long static_buffer_size;
294 bool using_bounce_buffer;
295 uint32_t capabilities;
296 struct mutex fifo_mutex;
297 struct rw_semaphore rwsem;
298 struct vmw_marker_queue marker_queue;
299 bool dx;
300};
301
302
303
304
305
306
307
308
309
310
311
312
313
314struct vmw_res_cache_entry {
315 uint32_t handle;
316 struct vmw_resource *res;
317 void *private;
318 unsigned short valid_handle;
319 unsigned short valid;
320};
321
322
323
324
325enum vmw_dma_map_mode {
326 vmw_dma_phys,
327 vmw_dma_alloc_coherent,
328 vmw_dma_map_populate,
329 vmw_dma_map_bind,
330 vmw_dma_map_max
331};
332
333
334
335
336
337
338
339
340struct vmw_sg_table {
341 enum vmw_dma_map_mode mode;
342 struct page **pages;
343 const dma_addr_t *addrs;
344 struct sg_table *sgt;
345 unsigned long num_regions;
346 unsigned long num_pages;
347};
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363struct vmw_piter {
364 struct page **pages;
365 const dma_addr_t *addrs;
366 struct sg_dma_page_iter iter;
367 unsigned long i;
368 unsigned long num_pages;
369 bool (*next)(struct vmw_piter *);
370 dma_addr_t (*dma_address)(struct vmw_piter *);
371 struct page *(*page)(struct vmw_piter *);
372};
373
374
375
376
377enum vmw_display_unit_type {
378 vmw_du_invalid = 0,
379 vmw_du_legacy,
380 vmw_du_screen_object,
381 vmw_du_screen_target
382};
383
384struct vmw_validation_context;
385struct vmw_ctx_validation_info;
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418struct vmw_sw_context{
419 struct drm_open_hash res_ht;
420 bool res_ht_initialized;
421 bool kernel;
422 struct vmw_fpriv *fp;
423 uint32_t *cmd_bounce;
424 uint32_t cmd_bounce_size;
425 struct vmw_buffer_object *cur_query_bo;
426 struct list_head bo_relocations;
427 struct list_head res_relocations;
428 uint32_t *buf_start;
429 struct vmw_res_cache_entry res_cache[vmw_res_max];
430 struct vmw_resource *last_query_ctx;
431 bool needs_post_query_barrier;
432 struct vmw_ctx_binding_state *staged_bindings;
433 bool staged_bindings_inuse;
434 struct list_head staged_cmd_res;
435 struct list_head ctx_list;
436 struct vmw_ctx_validation_info *dx_ctx_node;
437 struct vmw_buffer_object *dx_query_mob;
438 struct vmw_resource *dx_query_ctx;
439 struct vmw_cmdbuf_res_manager *man;
440 struct vmw_validation_context *ctx;
441};
442
443struct vmw_legacy_display;
444struct vmw_overlay;
445
446struct vmw_vga_topology_state {
447 uint32_t width;
448 uint32_t height;
449 uint32_t primary;
450 uint32_t pos_x;
451 uint32_t pos_y;
452};
453
454
455
456
457
458
459
460
461struct vmw_otable {
462 unsigned long size;
463 struct vmw_mob *page_table;
464 bool enabled;
465};
466
467struct vmw_otable_batch {
468 unsigned num_otables;
469 struct vmw_otable *otables;
470 struct vmw_resource *context;
471 struct ttm_buffer_object *otable_bo;
472};
473
474enum {
475 VMW_IRQTHREAD_FENCE,
476 VMW_IRQTHREAD_CMDBUF,
477 VMW_IRQTHREAD_MAX
478};
479
480
481
482
483
484
485
486
487
488enum vmw_sm_type {
489 VMW_SM_LEGACY = 0,
490 VMW_SM_4,
491 VMW_SM_4_1,
492 VMW_SM_5,
493 VMW_SM_MAX
494};
495
496struct vmw_private {
497 struct ttm_bo_device bdev;
498
499 struct vmw_fifo_state fifo;
500
501 struct drm_device *dev;
502 struct drm_vma_offset_manager vma_manager;
503 unsigned long vmw_chipset;
504 unsigned int io_start;
505 uint32_t vram_start;
506 uint32_t vram_size;
507 uint32_t prim_bb_mem;
508 uint32_t mmio_start;
509 uint32_t mmio_size;
510 uint32_t fb_max_width;
511 uint32_t fb_max_height;
512 uint32_t texture_max_width;
513 uint32_t texture_max_height;
514 uint32_t stdu_max_width;
515 uint32_t stdu_max_height;
516 uint32_t initial_width;
517 uint32_t initial_height;
518 u32 *mmio_virt;
519 uint32_t capabilities;
520 uint32_t capabilities2;
521 uint32_t max_gmr_ids;
522 uint32_t max_gmr_pages;
523 uint32_t max_mob_pages;
524 uint32_t max_mob_size;
525 uint32_t memory_size;
526 bool has_gmr;
527 bool has_mob;
528 spinlock_t hw_lock;
529 spinlock_t cap_lock;
530 bool assume_16bpp;
531
532 enum vmw_sm_type sm_type;
533
534
535
536
537
538 void *fb_info;
539 enum vmw_display_unit_type active_display_unit;
540 struct vmw_legacy_display *ldu_priv;
541 struct vmw_overlay *overlay_priv;
542 struct drm_property *hotplug_mode_update_property;
543 struct drm_property *implicit_placement_property;
544 struct mutex global_kms_state_mutex;
545 spinlock_t cursor_lock;
546 struct drm_atomic_state *suspend_state;
547
548
549
550
551
552 spinlock_t resource_lock;
553 struct idr res_idr[vmw_res_max];
554
555
556
557
558
559
560 struct ttm_object_device *tdev;
561
562
563
564
565
566 atomic_t marker_seq;
567 wait_queue_head_t fence_queue;
568 wait_queue_head_t fifo_queue;
569 spinlock_t waiter_lock;
570 int fence_queue_waiters;
571 int goal_queue_waiters;
572 int cmdbuf_waiters;
573 int error_waiters;
574 int fifo_queue_waiters;
575 uint32_t last_read_seqno;
576 struct vmw_fence_manager *fman;
577 uint32_t irq_mask;
578
579
580
581
582
583 uint32_t traces_state;
584 uint32_t enable_state;
585 uint32_t config_done_state;
586
587
588
589
590
591
592
593
594 struct vmw_sw_context ctx;
595 struct mutex cmdbuf_mutex;
596 struct mutex binding_mutex;
597
598
599
600
601
602 bool stealth;
603 bool enable_fb;
604 spinlock_t svga_lock;
605
606
607
608
609 struct notifier_block pm_nb;
610 bool refuse_hibernation;
611 bool suspend_locked;
612
613 struct mutex release_mutex;
614 atomic_t num_fifo_resources;
615
616
617
618
619 struct ttm_lock reservation_sem;
620
621
622
623
624
625
626 struct vmw_buffer_object *dummy_query_bo;
627 struct vmw_buffer_object *pinned_bo;
628 uint32_t query_cid;
629 uint32_t query_cid_valid;
630 bool dummy_query_bo_pinned;
631
632
633
634
635
636
637
638
639 struct list_head res_lru[vmw_res_max];
640 uint32_t used_memory_size;
641
642
643
644
645 enum vmw_dma_map_mode map_mode;
646
647
648
649
650 struct vmw_otable_batch otable_batch;
651
652 struct vmw_cmdbuf_man *cman;
653 DECLARE_BITMAP(irqthread_pending, VMW_IRQTHREAD_MAX);
654
655
656 struct vmw_validation_mem vvm;
657};
658
659static inline struct vmw_surface *vmw_res_to_srf(struct vmw_resource *res)
660{
661 return container_of(res, struct vmw_surface, res);
662}
663
664static inline struct vmw_private *vmw_priv(struct drm_device *dev)
665{
666 return (struct vmw_private *)dev->dev_private;
667}
668
669static inline struct vmw_fpriv *vmw_fpriv(struct drm_file *file_priv)
670{
671 return (struct vmw_fpriv *)file_priv->driver_priv;
672}
673
674
675
676
677
678
679
680
681static inline void vmw_write(struct vmw_private *dev_priv,
682 unsigned int offset, uint32_t value)
683{
684 spin_lock(&dev_priv->hw_lock);
685 outl(offset, dev_priv->io_start + VMWGFX_INDEX_PORT);
686 outl(value, dev_priv->io_start + VMWGFX_VALUE_PORT);
687 spin_unlock(&dev_priv->hw_lock);
688}
689
690static inline uint32_t vmw_read(struct vmw_private *dev_priv,
691 unsigned int offset)
692{
693 u32 val;
694
695 spin_lock(&dev_priv->hw_lock);
696 outl(offset, dev_priv->io_start + VMWGFX_INDEX_PORT);
697 val = inl(dev_priv->io_start + VMWGFX_VALUE_PORT);
698 spin_unlock(&dev_priv->hw_lock);
699
700 return val;
701}
702
703
704
705
706
707
708
709static inline bool has_sm4_context(const struct vmw_private *dev_priv)
710{
711 return (dev_priv->sm_type >= VMW_SM_4);
712}
713
714
715
716
717
718
719
720static inline bool has_sm4_1_context(const struct vmw_private *dev_priv)
721{
722 return (dev_priv->sm_type >= VMW_SM_4_1);
723}
724
725
726
727
728
729
730
731static inline bool has_sm5_context(const struct vmw_private *dev_priv)
732{
733 return (dev_priv->sm_type >= VMW_SM_5);
734}
735
736extern void vmw_svga_enable(struct vmw_private *dev_priv);
737extern void vmw_svga_disable(struct vmw_private *dev_priv);
738
739
740
741
742
743
744extern int vmw_gmr_bind(struct vmw_private *dev_priv,
745 const struct vmw_sg_table *vsgt,
746 unsigned long num_pages,
747 int gmr_id);
748extern void vmw_gmr_unbind(struct vmw_private *dev_priv, int gmr_id);
749
750
751
752
753struct vmw_user_resource_conv;
754
755extern void vmw_resource_unreference(struct vmw_resource **p_res);
756extern struct vmw_resource *vmw_resource_reference(struct vmw_resource *res);
757extern struct vmw_resource *
758vmw_resource_reference_unless_doomed(struct vmw_resource *res);
759extern int vmw_resource_validate(struct vmw_resource *res, bool intr,
760 bool dirtying);
761extern int vmw_resource_reserve(struct vmw_resource *res, bool interruptible,
762 bool no_backup);
763extern bool vmw_resource_needs_backup(const struct vmw_resource *res);
764extern int vmw_user_lookup_handle(struct vmw_private *dev_priv,
765 struct ttm_object_file *tfile,
766 uint32_t handle,
767 struct vmw_surface **out_surf,
768 struct vmw_buffer_object **out_buf);
769extern int vmw_user_resource_lookup_handle(
770 struct vmw_private *dev_priv,
771 struct ttm_object_file *tfile,
772 uint32_t handle,
773 const struct vmw_user_resource_conv *converter,
774 struct vmw_resource **p_res);
775extern struct vmw_resource *
776vmw_user_resource_noref_lookup_handle(struct vmw_private *dev_priv,
777 struct ttm_object_file *tfile,
778 uint32_t handle,
779 const struct vmw_user_resource_conv *
780 converter);
781extern int vmw_stream_claim_ioctl(struct drm_device *dev, void *data,
782 struct drm_file *file_priv);
783extern int vmw_stream_unref_ioctl(struct drm_device *dev, void *data,
784 struct drm_file *file_priv);
785extern int vmw_user_stream_lookup(struct vmw_private *dev_priv,
786 struct ttm_object_file *tfile,
787 uint32_t *inout_id,
788 struct vmw_resource **out);
789extern void vmw_resource_unreserve(struct vmw_resource *res,
790 bool dirty_set,
791 bool dirty,
792 bool switch_backup,
793 struct vmw_buffer_object *new_backup,
794 unsigned long new_backup_offset);
795extern void vmw_query_move_notify(struct ttm_buffer_object *bo,
796 struct ttm_mem_reg *mem);
797extern int vmw_query_readback_all(struct vmw_buffer_object *dx_query_mob);
798extern void vmw_resource_evict_all(struct vmw_private *dev_priv);
799extern void vmw_resource_unbind_list(struct vmw_buffer_object *vbo);
800void vmw_resource_mob_attach(struct vmw_resource *res);
801void vmw_resource_mob_detach(struct vmw_resource *res);
802void vmw_resource_dirty_update(struct vmw_resource *res, pgoff_t start,
803 pgoff_t end);
804int vmw_resources_clean(struct vmw_buffer_object *vbo, pgoff_t start,
805 pgoff_t end, pgoff_t *num_prefault);
806
807
808
809
810
811
812
813static inline bool vmw_resource_mob_attached(const struct vmw_resource *res)
814{
815 return !RB_EMPTY_NODE(&res->mob_node);
816}
817
818
819
820
821
822static inline void vmw_user_resource_noref_release(void)
823{
824 ttm_base_object_noref_release();
825}
826
827
828
829
830extern int vmw_bo_pin_in_placement(struct vmw_private *vmw_priv,
831 struct vmw_buffer_object *bo,
832 struct ttm_placement *placement,
833 bool interruptible);
834extern int vmw_bo_pin_in_vram(struct vmw_private *dev_priv,
835 struct vmw_buffer_object *buf,
836 bool interruptible);
837extern int vmw_bo_pin_in_vram_or_gmr(struct vmw_private *dev_priv,
838 struct vmw_buffer_object *buf,
839 bool interruptible);
840extern int vmw_bo_pin_in_start_of_vram(struct vmw_private *vmw_priv,
841 struct vmw_buffer_object *bo,
842 bool interruptible);
843extern int vmw_bo_unpin(struct vmw_private *vmw_priv,
844 struct vmw_buffer_object *bo,
845 bool interruptible);
846extern void vmw_bo_get_guest_ptr(const struct ttm_buffer_object *buf,
847 SVGAGuestPtr *ptr);
848extern void vmw_bo_pin_reserved(struct vmw_buffer_object *bo, bool pin);
849extern void vmw_bo_bo_free(struct ttm_buffer_object *bo);
850extern int vmw_bo_init(struct vmw_private *dev_priv,
851 struct vmw_buffer_object *vmw_bo,
852 size_t size, struct ttm_placement *placement,
853 bool interruptible,
854 void (*bo_free)(struct ttm_buffer_object *bo));
855extern int vmw_user_bo_verify_access(struct ttm_buffer_object *bo,
856 struct ttm_object_file *tfile);
857extern int vmw_user_bo_alloc(struct vmw_private *dev_priv,
858 struct ttm_object_file *tfile,
859 uint32_t size,
860 bool shareable,
861 uint32_t *handle,
862 struct vmw_buffer_object **p_dma_buf,
863 struct ttm_base_object **p_base);
864extern int vmw_user_bo_reference(struct ttm_object_file *tfile,
865 struct vmw_buffer_object *dma_buf,
866 uint32_t *handle);
867extern int vmw_bo_alloc_ioctl(struct drm_device *dev, void *data,
868 struct drm_file *file_priv);
869extern int vmw_bo_unref_ioctl(struct drm_device *dev, void *data,
870 struct drm_file *file_priv);
871extern int vmw_user_bo_synccpu_ioctl(struct drm_device *dev, void *data,
872 struct drm_file *file_priv);
873extern int vmw_user_bo_lookup(struct ttm_object_file *tfile,
874 uint32_t id, struct vmw_buffer_object **out,
875 struct ttm_base_object **base);
876extern void vmw_bo_fence_single(struct ttm_buffer_object *bo,
877 struct vmw_fence_obj *fence);
878extern void *vmw_bo_map_and_cache(struct vmw_buffer_object *vbo);
879extern void vmw_bo_unmap(struct vmw_buffer_object *vbo);
880extern void vmw_bo_move_notify(struct ttm_buffer_object *bo,
881 struct ttm_mem_reg *mem);
882extern void vmw_bo_swap_notify(struct ttm_buffer_object *bo);
883extern struct vmw_buffer_object *
884vmw_user_bo_noref_lookup(struct ttm_object_file *tfile, u32 handle);
885
886
887
888
889
890static inline void vmw_user_bo_noref_release(void)
891{
892 ttm_base_object_noref_release();
893}
894
895
896
897
898
899
900static inline void vmw_bo_prio_adjust(struct vmw_buffer_object *vbo)
901{
902 int i = ARRAY_SIZE(vbo->res_prios);
903
904 while (i--) {
905 if (vbo->res_prios[i]) {
906 vbo->base.priority = i;
907 return;
908 }
909 }
910
911 vbo->base.priority = 3;
912}
913
914
915
916
917
918
919
920
921
922
923static inline void vmw_bo_prio_add(struct vmw_buffer_object *vbo, int prio)
924{
925 if (vbo->res_prios[prio]++ == 0)
926 vmw_bo_prio_adjust(vbo);
927}
928
929
930
931
932
933
934
935
936
937
938static inline void vmw_bo_prio_del(struct vmw_buffer_object *vbo, int prio)
939{
940 if (--vbo->res_prios[prio] == 0)
941 vmw_bo_prio_adjust(vbo);
942}
943
944
945
946
947
948extern int vmw_getparam_ioctl(struct drm_device *dev, void *data,
949 struct drm_file *file_priv);
950extern int vmw_get_cap_3d_ioctl(struct drm_device *dev, void *data,
951 struct drm_file *file_priv);
952extern int vmw_present_ioctl(struct drm_device *dev, void *data,
953 struct drm_file *file_priv);
954extern int vmw_present_readback_ioctl(struct drm_device *dev, void *data,
955 struct drm_file *file_priv);
956extern __poll_t vmw_fops_poll(struct file *filp,
957 struct poll_table_struct *wait);
958extern ssize_t vmw_fops_read(struct file *filp, char __user *buffer,
959 size_t count, loff_t *offset);
960
961
962
963
964
965extern int vmw_fifo_init(struct vmw_private *dev_priv,
966 struct vmw_fifo_state *fifo);
967extern void vmw_fifo_release(struct vmw_private *dev_priv,
968 struct vmw_fifo_state *fifo);
969extern void *
970vmw_fifo_reserve_dx(struct vmw_private *dev_priv, uint32_t bytes, int ctx_id);
971extern void vmw_fifo_commit(struct vmw_private *dev_priv, uint32_t bytes);
972extern void vmw_fifo_commit_flush(struct vmw_private *dev_priv, uint32_t bytes);
973extern int vmw_fifo_send_fence(struct vmw_private *dev_priv,
974 uint32_t *seqno);
975extern void vmw_fifo_ping_host(struct vmw_private *dev_priv, uint32_t reason);
976extern bool vmw_fifo_have_3d(struct vmw_private *dev_priv);
977extern bool vmw_fifo_have_pitchlock(struct vmw_private *dev_priv);
978extern int vmw_fifo_emit_dummy_query(struct vmw_private *dev_priv,
979 uint32_t cid);
980extern int vmw_fifo_flush(struct vmw_private *dev_priv,
981 bool interruptible);
982
983#define VMW_FIFO_RESERVE_DX(__priv, __bytes, __ctx_id) \
984({ \
985 vmw_fifo_reserve_dx(__priv, __bytes, __ctx_id) ? : ({ \
986 DRM_ERROR("FIFO reserve failed at %s for %u bytes\n", \
987 __func__, (unsigned int) __bytes); \
988 NULL; \
989 }); \
990})
991
992#define VMW_FIFO_RESERVE(__priv, __bytes) \
993 VMW_FIFO_RESERVE_DX(__priv, __bytes, SVGA3D_INVALID_ID)
994
995
996
997
998
999extern int vmw_mmap(struct file *filp, struct vm_area_struct *vma);
1000
1001extern void vmw_validation_mem_init_ttm(struct vmw_private *dev_priv,
1002 size_t gran);
1003
1004
1005
1006
1007
1008extern const size_t vmw_tt_size;
1009extern struct ttm_placement vmw_vram_placement;
1010extern struct ttm_placement vmw_vram_ne_placement;
1011extern struct ttm_placement vmw_vram_sys_placement;
1012extern struct ttm_placement vmw_vram_gmr_placement;
1013extern struct ttm_placement vmw_vram_gmr_ne_placement;
1014extern struct ttm_placement vmw_sys_placement;
1015extern struct ttm_placement vmw_sys_ne_placement;
1016extern struct ttm_placement vmw_evictable_placement;
1017extern struct ttm_placement vmw_srf_placement;
1018extern struct ttm_placement vmw_mob_placement;
1019extern struct ttm_placement vmw_mob_ne_placement;
1020extern struct ttm_placement vmw_nonfixed_placement;
1021extern struct ttm_bo_driver vmw_bo_driver;
1022extern int vmw_bo_map_dma(struct ttm_buffer_object *bo);
1023extern void vmw_bo_unmap_dma(struct ttm_buffer_object *bo);
1024extern const struct vmw_sg_table *
1025vmw_bo_sg_table(struct ttm_buffer_object *bo);
1026extern void vmw_piter_start(struct vmw_piter *viter,
1027 const struct vmw_sg_table *vsgt,
1028 unsigned long p_offs);
1029
1030
1031
1032
1033
1034
1035
1036
1037static inline bool vmw_piter_next(struct vmw_piter *viter)
1038{
1039 return viter->next(viter);
1040}
1041
1042
1043
1044
1045
1046
1047
1048
1049static inline dma_addr_t vmw_piter_dma_addr(struct vmw_piter *viter)
1050{
1051 return viter->dma_address(viter);
1052}
1053
1054
1055
1056
1057
1058
1059
1060
1061static inline struct page *vmw_piter_page(struct vmw_piter *viter)
1062{
1063 return viter->page(viter);
1064}
1065
1066
1067
1068
1069
1070extern int vmw_execbuf_ioctl(struct drm_device *dev, void *data,
1071 struct drm_file *file_priv);
1072extern int vmw_execbuf_process(struct drm_file *file_priv,
1073 struct vmw_private *dev_priv,
1074 void __user *user_commands,
1075 void *kernel_commands,
1076 uint32_t command_size,
1077 uint64_t throttle_us,
1078 uint32_t dx_context_handle,
1079 struct drm_vmw_fence_rep __user
1080 *user_fence_rep,
1081 struct vmw_fence_obj **out_fence,
1082 uint32_t flags);
1083extern void __vmw_execbuf_release_pinned_bo(struct vmw_private *dev_priv,
1084 struct vmw_fence_obj *fence);
1085extern void vmw_execbuf_release_pinned_bo(struct vmw_private *dev_priv);
1086
1087extern int vmw_execbuf_fence_commands(struct drm_file *file_priv,
1088 struct vmw_private *dev_priv,
1089 struct vmw_fence_obj **p_fence,
1090 uint32_t *p_handle);
1091extern void vmw_execbuf_copy_fence_user(struct vmw_private *dev_priv,
1092 struct vmw_fpriv *vmw_fp,
1093 int ret,
1094 struct drm_vmw_fence_rep __user
1095 *user_fence_rep,
1096 struct vmw_fence_obj *fence,
1097 uint32_t fence_handle,
1098 int32_t out_fence_fd,
1099 struct sync_file *sync_file);
1100bool vmw_cmd_describe(const void *buf, u32 *size, char const **cmd);
1101
1102
1103
1104
1105
1106extern int vmw_wait_seqno(struct vmw_private *dev_priv, bool lazy,
1107 uint32_t seqno, bool interruptible,
1108 unsigned long timeout);
1109extern int vmw_irq_install(struct drm_device *dev, int irq);
1110extern void vmw_irq_uninstall(struct drm_device *dev);
1111extern bool vmw_seqno_passed(struct vmw_private *dev_priv,
1112 uint32_t seqno);
1113extern int vmw_fallback_wait(struct vmw_private *dev_priv,
1114 bool lazy,
1115 bool fifo_idle,
1116 uint32_t seqno,
1117 bool interruptible,
1118 unsigned long timeout);
1119extern void vmw_update_seqno(struct vmw_private *dev_priv,
1120 struct vmw_fifo_state *fifo_state);
1121extern void vmw_seqno_waiter_add(struct vmw_private *dev_priv);
1122extern void vmw_seqno_waiter_remove(struct vmw_private *dev_priv);
1123extern void vmw_goal_waiter_add(struct vmw_private *dev_priv);
1124extern void vmw_goal_waiter_remove(struct vmw_private *dev_priv);
1125extern void vmw_generic_waiter_add(struct vmw_private *dev_priv, u32 flag,
1126 int *waiter_count);
1127extern void vmw_generic_waiter_remove(struct vmw_private *dev_priv,
1128 u32 flag, int *waiter_count);
1129
1130
1131
1132
1133
1134
1135extern void vmw_marker_queue_init(struct vmw_marker_queue *queue);
1136extern void vmw_marker_queue_takedown(struct vmw_marker_queue *queue);
1137extern int vmw_marker_push(struct vmw_marker_queue *queue,
1138 uint32_t seqno);
1139extern int vmw_marker_pull(struct vmw_marker_queue *queue,
1140 uint32_t signaled_seqno);
1141extern int vmw_wait_lag(struct vmw_private *dev_priv,
1142 struct vmw_marker_queue *queue, uint32_t us);
1143
1144
1145
1146
1147
1148int vmw_fb_init(struct vmw_private *vmw_priv);
1149int vmw_fb_close(struct vmw_private *dev_priv);
1150int vmw_fb_off(struct vmw_private *vmw_priv);
1151int vmw_fb_on(struct vmw_private *vmw_priv);
1152
1153
1154
1155
1156
1157int vmw_kms_init(struct vmw_private *dev_priv);
1158int vmw_kms_close(struct vmw_private *dev_priv);
1159int vmw_kms_cursor_bypass_ioctl(struct drm_device *dev, void *data,
1160 struct drm_file *file_priv);
1161void vmw_kms_cursor_post_execbuf(struct vmw_private *dev_priv);
1162void vmw_kms_cursor_snoop(struct vmw_surface *srf,
1163 struct ttm_object_file *tfile,
1164 struct ttm_buffer_object *bo,
1165 SVGA3dCmdHeader *header);
1166int vmw_kms_write_svga(struct vmw_private *vmw_priv,
1167 unsigned width, unsigned height, unsigned pitch,
1168 unsigned bpp, unsigned depth);
1169bool vmw_kms_validate_mode_vram(struct vmw_private *dev_priv,
1170 uint32_t pitch,
1171 uint32_t height);
1172u32 vmw_get_vblank_counter(struct drm_crtc *crtc);
1173int vmw_enable_vblank(struct drm_crtc *crtc);
1174void vmw_disable_vblank(struct drm_crtc *crtc);
1175int vmw_kms_present(struct vmw_private *dev_priv,
1176 struct drm_file *file_priv,
1177 struct vmw_framebuffer *vfb,
1178 struct vmw_surface *surface,
1179 uint32_t sid, int32_t destX, int32_t destY,
1180 struct drm_vmw_rect *clips,
1181 uint32_t num_clips);
1182int vmw_kms_update_layout_ioctl(struct drm_device *dev, void *data,
1183 struct drm_file *file_priv);
1184void vmw_kms_legacy_hotspot_clear(struct vmw_private *dev_priv);
1185int vmw_kms_suspend(struct drm_device *dev);
1186int vmw_kms_resume(struct drm_device *dev);
1187void vmw_kms_lost_device(struct drm_device *dev);
1188
1189int vmw_dumb_create(struct drm_file *file_priv,
1190 struct drm_device *dev,
1191 struct drm_mode_create_dumb *args);
1192
1193int vmw_dumb_map_offset(struct drm_file *file_priv,
1194 struct drm_device *dev, uint32_t handle,
1195 uint64_t *offset);
1196int vmw_dumb_destroy(struct drm_file *file_priv,
1197 struct drm_device *dev,
1198 uint32_t handle);
1199extern int vmw_resource_pin(struct vmw_resource *res, bool interruptible);
1200extern void vmw_resource_unpin(struct vmw_resource *res);
1201extern enum vmw_res_type vmw_res_type(const struct vmw_resource *res);
1202
1203
1204
1205
1206
1207int vmw_overlay_init(struct vmw_private *dev_priv);
1208int vmw_overlay_close(struct vmw_private *dev_priv);
1209int vmw_overlay_ioctl(struct drm_device *dev, void *data,
1210 struct drm_file *file_priv);
1211int vmw_overlay_resume_all(struct vmw_private *dev_priv);
1212int vmw_overlay_pause_all(struct vmw_private *dev_priv);
1213int vmw_overlay_claim(struct vmw_private *dev_priv, uint32_t *out);
1214int vmw_overlay_unref(struct vmw_private *dev_priv, uint32_t stream_id);
1215int vmw_overlay_num_overlays(struct vmw_private *dev_priv);
1216int vmw_overlay_num_free_overlays(struct vmw_private *dev_priv);
1217
1218
1219
1220
1221
1222extern const struct ttm_mem_type_manager_func vmw_gmrid_manager_func;
1223
1224
1225
1226
1227
1228extern const struct dma_buf_ops vmw_prime_dmabuf_ops;
1229extern int vmw_prime_fd_to_handle(struct drm_device *dev,
1230 struct drm_file *file_priv,
1231 int fd, u32 *handle);
1232extern int vmw_prime_handle_to_fd(struct drm_device *dev,
1233 struct drm_file *file_priv,
1234 uint32_t handle, uint32_t flags,
1235 int *prime_fd);
1236
1237
1238
1239
1240struct vmw_mob;
1241extern int vmw_mob_bind(struct vmw_private *dev_priv, struct vmw_mob *mob,
1242 const struct vmw_sg_table *vsgt,
1243 unsigned long num_data_pages, int32_t mob_id);
1244extern void vmw_mob_unbind(struct vmw_private *dev_priv,
1245 struct vmw_mob *mob);
1246extern void vmw_mob_destroy(struct vmw_mob *mob);
1247extern struct vmw_mob *vmw_mob_create(unsigned long data_pages);
1248extern int vmw_otables_setup(struct vmw_private *dev_priv);
1249extern void vmw_otables_takedown(struct vmw_private *dev_priv);
1250
1251
1252
1253
1254
1255extern const struct vmw_user_resource_conv *user_context_converter;
1256
1257extern int vmw_context_define_ioctl(struct drm_device *dev, void *data,
1258 struct drm_file *file_priv);
1259extern int vmw_extended_context_define_ioctl(struct drm_device *dev, void *data,
1260 struct drm_file *file_priv);
1261extern int vmw_context_destroy_ioctl(struct drm_device *dev, void *data,
1262 struct drm_file *file_priv);
1263extern struct list_head *vmw_context_binding_list(struct vmw_resource *ctx);
1264extern struct vmw_cmdbuf_res_manager *
1265vmw_context_res_man(struct vmw_resource *ctx);
1266extern struct vmw_resource *vmw_context_cotable(struct vmw_resource *ctx,
1267 SVGACOTableType cotable_type);
1268extern struct list_head *vmw_context_binding_list(struct vmw_resource *ctx);
1269struct vmw_ctx_binding_state;
1270extern struct vmw_ctx_binding_state *
1271vmw_context_binding_state(struct vmw_resource *ctx);
1272extern void vmw_dx_context_scrub_cotables(struct vmw_resource *ctx,
1273 bool readback);
1274extern int vmw_context_bind_dx_query(struct vmw_resource *ctx_res,
1275 struct vmw_buffer_object *mob);
1276extern struct vmw_buffer_object *
1277vmw_context_get_dx_query_mob(struct vmw_resource *ctx_res);
1278
1279
1280
1281
1282
1283
1284extern const struct vmw_user_resource_conv *user_surface_converter;
1285
1286extern int vmw_surface_destroy_ioctl(struct drm_device *dev, void *data,
1287 struct drm_file *file_priv);
1288extern int vmw_surface_define_ioctl(struct drm_device *dev, void *data,
1289 struct drm_file *file_priv);
1290extern int vmw_surface_reference_ioctl(struct drm_device *dev, void *data,
1291 struct drm_file *file_priv);
1292extern int vmw_gb_surface_define_ioctl(struct drm_device *dev, void *data,
1293 struct drm_file *file_priv);
1294extern int vmw_gb_surface_reference_ioctl(struct drm_device *dev, void *data,
1295 struct drm_file *file_priv);
1296int vmw_surface_gb_priv_define(struct drm_device *dev,
1297 uint32_t user_accounting_size,
1298 SVGA3dSurfaceAllFlags svga3d_flags,
1299 SVGA3dSurfaceFormat format,
1300 bool for_scanout,
1301 uint32_t num_mip_levels,
1302 uint32_t multisample_count,
1303 uint32_t array_size,
1304 struct drm_vmw_size size,
1305 SVGA3dMSPattern multisample_pattern,
1306 SVGA3dMSQualityLevel quality_level,
1307 struct vmw_surface **srf_out);
1308extern int vmw_gb_surface_define_ext_ioctl(struct drm_device *dev,
1309 void *data,
1310 struct drm_file *file_priv);
1311extern int vmw_gb_surface_reference_ext_ioctl(struct drm_device *dev,
1312 void *data,
1313 struct drm_file *file_priv);
1314
1315int vmw_gb_surface_define(struct vmw_private *dev_priv,
1316 uint32_t user_accounting_size,
1317 const struct vmw_surface_metadata *req,
1318 struct vmw_surface **srf_out);
1319
1320
1321
1322
1323
1324extern const struct vmw_user_resource_conv *user_shader_converter;
1325
1326extern int vmw_shader_define_ioctl(struct drm_device *dev, void *data,
1327 struct drm_file *file_priv);
1328extern int vmw_shader_destroy_ioctl(struct drm_device *dev, void *data,
1329 struct drm_file *file_priv);
1330extern int vmw_compat_shader_add(struct vmw_private *dev_priv,
1331 struct vmw_cmdbuf_res_manager *man,
1332 u32 user_key, const void *bytecode,
1333 SVGA3dShaderType shader_type,
1334 size_t size,
1335 struct list_head *list);
1336extern int vmw_shader_remove(struct vmw_cmdbuf_res_manager *man,
1337 u32 user_key, SVGA3dShaderType shader_type,
1338 struct list_head *list);
1339extern int vmw_dx_shader_add(struct vmw_cmdbuf_res_manager *man,
1340 struct vmw_resource *ctx,
1341 u32 user_key,
1342 SVGA3dShaderType shader_type,
1343 struct list_head *list);
1344extern void vmw_dx_shader_cotable_list_scrub(struct vmw_private *dev_priv,
1345 struct list_head *list,
1346 bool readback);
1347
1348extern struct vmw_resource *
1349vmw_shader_lookup(struct vmw_cmdbuf_res_manager *man,
1350 u32 user_key, SVGA3dShaderType shader_type);
1351
1352
1353
1354
1355struct vmw_resource *
1356vmw_dx_streamoutput_lookup(struct vmw_cmdbuf_res_manager *man,
1357 u32 user_key);
1358int vmw_dx_streamoutput_add(struct vmw_cmdbuf_res_manager *man,
1359 struct vmw_resource *ctx,
1360 SVGA3dStreamOutputId user_key,
1361 struct list_head *list);
1362void vmw_dx_streamoutput_set_size(struct vmw_resource *res, u32 size);
1363int vmw_dx_streamoutput_remove(struct vmw_cmdbuf_res_manager *man,
1364 SVGA3dStreamOutputId user_key,
1365 struct list_head *list);
1366void vmw_dx_streamoutput_cotable_list_scrub(struct vmw_private *dev_priv,
1367 struct list_head *list,
1368 bool readback);
1369
1370
1371
1372
1373
1374extern struct vmw_cmdbuf_res_manager *
1375vmw_cmdbuf_res_man_create(struct vmw_private *dev_priv);
1376extern void vmw_cmdbuf_res_man_destroy(struct vmw_cmdbuf_res_manager *man);
1377extern size_t vmw_cmdbuf_res_man_size(void);
1378extern struct vmw_resource *
1379vmw_cmdbuf_res_lookup(struct vmw_cmdbuf_res_manager *man,
1380 enum vmw_cmdbuf_res_type res_type,
1381 u32 user_key);
1382extern void vmw_cmdbuf_res_revert(struct list_head *list);
1383extern void vmw_cmdbuf_res_commit(struct list_head *list);
1384extern int vmw_cmdbuf_res_add(struct vmw_cmdbuf_res_manager *man,
1385 enum vmw_cmdbuf_res_type res_type,
1386 u32 user_key,
1387 struct vmw_resource *res,
1388 struct list_head *list);
1389extern int vmw_cmdbuf_res_remove(struct vmw_cmdbuf_res_manager *man,
1390 enum vmw_cmdbuf_res_type res_type,
1391 u32 user_key,
1392 struct list_head *list,
1393 struct vmw_resource **res);
1394
1395
1396
1397
1398extern const SVGACOTableType vmw_cotable_scrub_order[];
1399extern struct vmw_resource *vmw_cotable_alloc(struct vmw_private *dev_priv,
1400 struct vmw_resource *ctx,
1401 u32 type);
1402extern int vmw_cotable_notify(struct vmw_resource *res, int id);
1403extern int vmw_cotable_scrub(struct vmw_resource *res, bool readback);
1404extern void vmw_cotable_add_resource(struct vmw_resource *ctx,
1405 struct list_head *head);
1406
1407
1408
1409
1410struct vmw_cmdbuf_man;
1411struct vmw_cmdbuf_header;
1412
1413extern struct vmw_cmdbuf_man *
1414vmw_cmdbuf_man_create(struct vmw_private *dev_priv);
1415extern int vmw_cmdbuf_set_pool_size(struct vmw_cmdbuf_man *man,
1416 size_t size, size_t default_size);
1417extern void vmw_cmdbuf_remove_pool(struct vmw_cmdbuf_man *man);
1418extern void vmw_cmdbuf_man_destroy(struct vmw_cmdbuf_man *man);
1419extern int vmw_cmdbuf_idle(struct vmw_cmdbuf_man *man, bool interruptible,
1420 unsigned long timeout);
1421extern void *vmw_cmdbuf_reserve(struct vmw_cmdbuf_man *man, size_t size,
1422 int ctx_id, bool interruptible,
1423 struct vmw_cmdbuf_header *header);
1424extern void vmw_cmdbuf_commit(struct vmw_cmdbuf_man *man, size_t size,
1425 struct vmw_cmdbuf_header *header,
1426 bool flush);
1427extern void *vmw_cmdbuf_alloc(struct vmw_cmdbuf_man *man,
1428 size_t size, bool interruptible,
1429 struct vmw_cmdbuf_header **p_header);
1430extern void vmw_cmdbuf_header_free(struct vmw_cmdbuf_header *header);
1431extern int vmw_cmdbuf_cur_flush(struct vmw_cmdbuf_man *man,
1432 bool interruptible);
1433extern void vmw_cmdbuf_irqthread(struct vmw_cmdbuf_man *man);
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446struct vmw_diff_cpy {
1447 struct drm_rect rect;
1448 size_t line;
1449 size_t line_offset;
1450 int cpp;
1451 void (*do_cpy)(struct vmw_diff_cpy *diff, u8 *dest, const u8 *src,
1452 size_t n);
1453};
1454
1455#define VMW_CPU_BLIT_INITIALIZER { \
1456 .do_cpy = vmw_memcpy, \
1457}
1458
1459#define VMW_CPU_BLIT_DIFF_INITIALIZER(_cpp) { \
1460 .line = 0, \
1461 .line_offset = 0, \
1462 .rect = { .x1 = INT_MAX/2, \
1463 .y1 = INT_MAX/2, \
1464 .x2 = INT_MIN/2, \
1465 .y2 = INT_MIN/2 \
1466 }, \
1467 .cpp = _cpp, \
1468 .do_cpy = vmw_diff_memcpy, \
1469}
1470
1471void vmw_diff_memcpy(struct vmw_diff_cpy *diff, u8 *dest, const u8 *src,
1472 size_t n);
1473
1474void vmw_memcpy(struct vmw_diff_cpy *diff, u8 *dest, const u8 *src, size_t n);
1475
1476int vmw_bo_cpu_blit(struct ttm_buffer_object *dst,
1477 u32 dst_offset, u32 dst_stride,
1478 struct ttm_buffer_object *src,
1479 u32 src_offset, u32 src_stride,
1480 u32 w, u32 h,
1481 struct vmw_diff_cpy *diff);
1482
1483
1484int vmw_host_get_guestinfo(const char *guest_info_param,
1485 char *buffer, size_t *length);
1486int vmw_host_log(const char *log);
1487int vmw_msg_ioctl(struct drm_device *dev, void *data,
1488 struct drm_file *file_priv);
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501#define VMW_DEBUG_USER(fmt, ...) \
1502 DRM_DEBUG_DRIVER(fmt, ##__VA_ARGS__)
1503
1504
1505void vmw_bo_dirty_scan(struct vmw_buffer_object *vbo);
1506int vmw_bo_dirty_add(struct vmw_buffer_object *vbo);
1507void vmw_bo_dirty_transfer_to_res(struct vmw_resource *res);
1508void vmw_bo_dirty_clear_res(struct vmw_resource *res);
1509void vmw_bo_dirty_release(struct vmw_buffer_object *vbo);
1510void vmw_bo_dirty_unmap(struct vmw_buffer_object *vbo,
1511 pgoff_t start, pgoff_t end);
1512vm_fault_t vmw_bo_vm_fault(struct vm_fault *vmf);
1513vm_fault_t vmw_bo_vm_mkwrite(struct vm_fault *vmf);
1514#ifdef CONFIG_TRANSPARENT_HUGEPAGE
1515vm_fault_t vmw_bo_vm_huge_fault(struct vm_fault *vmf,
1516 enum page_entry_size pe_size);
1517#endif
1518
1519
1520#ifdef CONFIG_TRANSPARENT_HUGEPAGE
1521extern const struct ttm_mem_type_manager_func vmw_thp_func;
1522#else
1523#define vmw_thp_func ttm_bo_manager_func
1524#endif
1525
1526
1527
1528
1529
1530
1531#define VMW_DEBUG_KMS(fmt, ...) \
1532 DRM_DEBUG_DRIVER(fmt, ##__VA_ARGS__)
1533
1534
1535
1536
1537
1538static inline void vmw_surface_unreference(struct vmw_surface **srf)
1539{
1540 struct vmw_surface *tmp_srf = *srf;
1541 struct vmw_resource *res = &tmp_srf->res;
1542 *srf = NULL;
1543
1544 vmw_resource_unreference(&res);
1545}
1546
1547static inline struct vmw_surface *vmw_surface_reference(struct vmw_surface *srf)
1548{
1549 (void) vmw_resource_reference(&srf->res);
1550 return srf;
1551}
1552
1553static inline void vmw_bo_unreference(struct vmw_buffer_object **buf)
1554{
1555 struct vmw_buffer_object *tmp_buf = *buf;
1556
1557 *buf = NULL;
1558 if (tmp_buf != NULL) {
1559 ttm_bo_put(&tmp_buf->base);
1560 }
1561}
1562
1563static inline struct vmw_buffer_object *
1564vmw_bo_reference(struct vmw_buffer_object *buf)
1565{
1566 ttm_bo_get(&buf->base);
1567 return buf;
1568}
1569
1570static inline struct ttm_mem_global *vmw_mem_glob(struct vmw_private *dev_priv)
1571{
1572 return &ttm_mem_glob;
1573}
1574
1575static inline void vmw_fifo_resource_inc(struct vmw_private *dev_priv)
1576{
1577 atomic_inc(&dev_priv->num_fifo_resources);
1578}
1579
1580static inline void vmw_fifo_resource_dec(struct vmw_private *dev_priv)
1581{
1582 atomic_dec(&dev_priv->num_fifo_resources);
1583}
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593static inline u32 vmw_mmio_read(u32 *addr)
1594{
1595 return READ_ONCE(*addr);
1596}
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606static inline void vmw_mmio_write(u32 value, u32 *addr)
1607{
1608 WRITE_ONCE(*addr, value);
1609}
1610#endif
1611