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