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 "20210722"
58#define VMWGFX_DRIVER_MAJOR 2
59#define VMWGFX_DRIVER_MINOR 19
60#define VMWGFX_DRIVER_PATCHLEVEL 0
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
94#define MKSSTAT_CAPACITY_LOG2 5U
95#define MKSSTAT_CAPACITY (1U << MKSSTAT_CAPACITY_LOG2)
96
97struct vmw_fpriv {
98 struct ttm_object_file *tfile;
99 bool gb_aware;
100};
101
102
103
104
105
106
107
108
109
110
111
112
113struct vmw_buffer_object {
114 struct ttm_buffer_object base;
115 struct rb_root res_tree;
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_fifo_state {
283 unsigned long reserved_size;
284 u32 *dynamic_buffer;
285 u32 *static_buffer;
286 unsigned long static_buffer_size;
287 bool using_bounce_buffer;
288 uint32_t capabilities;
289 struct mutex fifo_mutex;
290 struct rw_semaphore rwsem;
291};
292
293
294
295
296
297
298
299
300
301
302
303
304
305struct vmw_res_cache_entry {
306 uint32_t handle;
307 struct vmw_resource *res;
308 void *private;
309 unsigned short valid_handle;
310 unsigned short valid;
311};
312
313
314
315
316enum vmw_dma_map_mode {
317 vmw_dma_alloc_coherent,
318 vmw_dma_map_populate,
319 vmw_dma_map_bind,
320 vmw_dma_map_max
321};
322
323
324
325
326
327
328
329
330struct vmw_sg_table {
331 enum vmw_dma_map_mode mode;
332 struct page **pages;
333 const dma_addr_t *addrs;
334 struct sg_table *sgt;
335 unsigned long num_regions;
336 unsigned long num_pages;
337};
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353struct vmw_piter {
354 struct page **pages;
355 const dma_addr_t *addrs;
356 struct sg_dma_page_iter iter;
357 unsigned long i;
358 unsigned long num_pages;
359 bool (*next)(struct vmw_piter *);
360 dma_addr_t (*dma_address)(struct vmw_piter *);
361};
362
363
364
365
366enum vmw_display_unit_type {
367 vmw_du_invalid = 0,
368 vmw_du_legacy,
369 vmw_du_screen_object,
370 vmw_du_screen_target,
371 vmw_du_max
372};
373
374struct vmw_validation_context;
375struct vmw_ctx_validation_info;
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
406
407
408struct vmw_sw_context{
409 struct drm_open_hash res_ht;
410 bool res_ht_initialized;
411 bool kernel;
412 struct vmw_fpriv *fp;
413 uint32_t *cmd_bounce;
414 uint32_t cmd_bounce_size;
415 struct vmw_buffer_object *cur_query_bo;
416 struct list_head bo_relocations;
417 struct list_head res_relocations;
418 uint32_t *buf_start;
419 struct vmw_res_cache_entry res_cache[vmw_res_max];
420 struct vmw_resource *last_query_ctx;
421 bool needs_post_query_barrier;
422 struct vmw_ctx_binding_state *staged_bindings;
423 bool staged_bindings_inuse;
424 struct list_head staged_cmd_res;
425 struct list_head ctx_list;
426 struct vmw_ctx_validation_info *dx_ctx_node;
427 struct vmw_buffer_object *dx_query_mob;
428 struct vmw_resource *dx_query_ctx;
429 struct vmw_cmdbuf_res_manager *man;
430 struct vmw_validation_context *ctx;
431};
432
433struct vmw_legacy_display;
434struct vmw_overlay;
435
436struct vmw_vga_topology_state {
437 uint32_t width;
438 uint32_t height;
439 uint32_t primary;
440 uint32_t pos_x;
441 uint32_t pos_y;
442};
443
444
445
446
447
448
449
450
451struct vmw_otable {
452 unsigned long size;
453 struct vmw_mob *page_table;
454 bool enabled;
455};
456
457struct vmw_otable_batch {
458 unsigned num_otables;
459 struct vmw_otable *otables;
460 struct vmw_resource *context;
461 struct ttm_buffer_object *otable_bo;
462};
463
464enum {
465 VMW_IRQTHREAD_FENCE,
466 VMW_IRQTHREAD_CMDBUF,
467 VMW_IRQTHREAD_MAX
468};
469
470
471
472
473
474
475
476
477
478enum vmw_sm_type {
479 VMW_SM_LEGACY = 0,
480 VMW_SM_4,
481 VMW_SM_4_1,
482 VMW_SM_5,
483 VMW_SM_MAX
484};
485
486struct vmw_private {
487 struct drm_device drm;
488 struct ttm_device bdev;
489
490 struct drm_vma_offset_manager vma_manager;
491 u32 pci_id;
492 resource_size_t io_start;
493 resource_size_t vram_start;
494 resource_size_t vram_size;
495 resource_size_t max_primary_mem;
496 u32 __iomem *rmmio;
497 u32 *fifo_mem;
498 resource_size_t fifo_mem_size;
499 uint32_t fb_max_width;
500 uint32_t fb_max_height;
501 uint32_t texture_max_width;
502 uint32_t texture_max_height;
503 uint32_t stdu_max_width;
504 uint32_t stdu_max_height;
505 uint32_t initial_width;
506 uint32_t initial_height;
507 uint32_t capabilities;
508 uint32_t capabilities2;
509 uint32_t max_gmr_ids;
510 uint32_t max_gmr_pages;
511 uint32_t max_mob_pages;
512 uint32_t max_mob_size;
513 uint32_t memory_size;
514 bool has_gmr;
515 bool has_mob;
516 spinlock_t hw_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 uint32 *devcaps;
634
635
636
637
638 struct page *mksstat_user_pages[MKSSTAT_CAPACITY];
639 atomic_t mksstat_user_pids[MKSSTAT_CAPACITY];
640
641#if IS_ENABLED(CONFIG_DRM_VMWGFX_MKSSTATS)
642 struct page *mksstat_kern_pages[MKSSTAT_CAPACITY];
643 u8 mksstat_kern_top_timer[MKSSTAT_CAPACITY];
644 atomic_t mksstat_kern_pids[MKSSTAT_CAPACITY];
645#endif
646};
647
648static inline struct vmw_surface *vmw_res_to_srf(struct vmw_resource *res)
649{
650 return container_of(res, struct vmw_surface, res);
651}
652
653static inline struct vmw_private *vmw_priv(struct drm_device *dev)
654{
655 return (struct vmw_private *)dev->dev_private;
656}
657
658static inline struct vmw_fpriv *vmw_fpriv(struct drm_file *file_priv)
659{
660 return (struct vmw_fpriv *)file_priv->driver_priv;
661}
662
663
664
665
666static inline bool vmw_is_svga_v3(const struct vmw_private *dev)
667{
668 return dev->pci_id == VMWGFX_PCI_ID_SVGA3;
669}
670
671
672
673
674
675
676
677
678static inline void vmw_write(struct vmw_private *dev_priv,
679 unsigned int offset, uint32_t value)
680{
681 if (vmw_is_svga_v3(dev_priv)) {
682 iowrite32(value, dev_priv->rmmio + offset);
683 } else {
684 spin_lock(&dev_priv->hw_lock);
685 outl(offset, dev_priv->io_start + SVGA_INDEX_PORT);
686 outl(value, dev_priv->io_start + SVGA_VALUE_PORT);
687 spin_unlock(&dev_priv->hw_lock);
688 }
689}
690
691static inline uint32_t vmw_read(struct vmw_private *dev_priv,
692 unsigned int offset)
693{
694 u32 val;
695
696 if (vmw_is_svga_v3(dev_priv)) {
697 val = ioread32(dev_priv->rmmio + offset);
698 } else {
699 spin_lock(&dev_priv->hw_lock);
700 outl(offset, dev_priv->io_start + SVGA_INDEX_PORT);
701 val = inl(dev_priv->io_start + SVGA_VALUE_PORT);
702 spin_unlock(&dev_priv->hw_lock);
703 }
704
705 return val;
706}
707
708
709
710
711
712
713
714static inline bool has_sm4_context(const struct vmw_private *dev_priv)
715{
716 return (dev_priv->sm_type >= VMW_SM_4);
717}
718
719
720
721
722
723
724
725static inline bool has_sm4_1_context(const struct vmw_private *dev_priv)
726{
727 return (dev_priv->sm_type >= VMW_SM_4_1);
728}
729
730
731
732
733
734
735
736static inline bool has_sm5_context(const struct vmw_private *dev_priv)
737{
738 return (dev_priv->sm_type >= VMW_SM_5);
739}
740
741extern void vmw_svga_enable(struct vmw_private *dev_priv);
742extern void vmw_svga_disable(struct vmw_private *dev_priv);
743
744
745
746
747
748
749extern int vmw_gmr_bind(struct vmw_private *dev_priv,
750 const struct vmw_sg_table *vsgt,
751 unsigned long num_pages,
752 int gmr_id);
753extern void vmw_gmr_unbind(struct vmw_private *dev_priv, int gmr_id);
754
755
756
757
758struct vmw_user_resource_conv;
759
760extern void vmw_resource_unreference(struct vmw_resource **p_res);
761extern struct vmw_resource *vmw_resource_reference(struct vmw_resource *res);
762extern struct vmw_resource *
763vmw_resource_reference_unless_doomed(struct vmw_resource *res);
764extern int vmw_resource_validate(struct vmw_resource *res, bool intr,
765 bool dirtying);
766extern int vmw_resource_reserve(struct vmw_resource *res, bool interruptible,
767 bool no_backup);
768extern bool vmw_resource_needs_backup(const struct vmw_resource *res);
769extern int vmw_user_lookup_handle(struct vmw_private *dev_priv,
770 struct ttm_object_file *tfile,
771 uint32_t handle,
772 struct vmw_surface **out_surf,
773 struct vmw_buffer_object **out_buf);
774extern int vmw_user_resource_lookup_handle(
775 struct vmw_private *dev_priv,
776 struct ttm_object_file *tfile,
777 uint32_t handle,
778 const struct vmw_user_resource_conv *converter,
779 struct vmw_resource **p_res);
780extern struct vmw_resource *
781vmw_user_resource_noref_lookup_handle(struct vmw_private *dev_priv,
782 struct ttm_object_file *tfile,
783 uint32_t handle,
784 const struct vmw_user_resource_conv *
785 converter);
786extern int vmw_stream_claim_ioctl(struct drm_device *dev, void *data,
787 struct drm_file *file_priv);
788extern int vmw_stream_unref_ioctl(struct drm_device *dev, void *data,
789 struct drm_file *file_priv);
790extern int vmw_user_stream_lookup(struct vmw_private *dev_priv,
791 struct ttm_object_file *tfile,
792 uint32_t *inout_id,
793 struct vmw_resource **out);
794extern void vmw_resource_unreserve(struct vmw_resource *res,
795 bool dirty_set,
796 bool dirty,
797 bool switch_backup,
798 struct vmw_buffer_object *new_backup,
799 unsigned long new_backup_offset);
800extern void vmw_query_move_notify(struct ttm_buffer_object *bo,
801 struct ttm_resource *old_mem,
802 struct ttm_resource *new_mem);
803extern int vmw_query_readback_all(struct vmw_buffer_object *dx_query_mob);
804extern void vmw_resource_evict_all(struct vmw_private *dev_priv);
805extern void vmw_resource_unbind_list(struct vmw_buffer_object *vbo);
806void vmw_resource_mob_attach(struct vmw_resource *res);
807void vmw_resource_mob_detach(struct vmw_resource *res);
808void vmw_resource_dirty_update(struct vmw_resource *res, pgoff_t start,
809 pgoff_t end);
810int vmw_resources_clean(struct vmw_buffer_object *vbo, pgoff_t start,
811 pgoff_t end, pgoff_t *num_prefault);
812
813
814
815
816
817
818
819static inline bool vmw_resource_mob_attached(const struct vmw_resource *res)
820{
821 return !RB_EMPTY_NODE(&res->mob_node);
822}
823
824
825
826
827
828static inline void vmw_user_resource_noref_release(void)
829{
830 ttm_base_object_noref_release();
831}
832
833
834
835
836extern int vmw_bo_pin_in_placement(struct vmw_private *vmw_priv,
837 struct vmw_buffer_object *bo,
838 struct ttm_placement *placement,
839 bool interruptible);
840extern int vmw_bo_pin_in_vram(struct vmw_private *dev_priv,
841 struct vmw_buffer_object *buf,
842 bool interruptible);
843extern int vmw_bo_pin_in_vram_or_gmr(struct vmw_private *dev_priv,
844 struct vmw_buffer_object *buf,
845 bool interruptible);
846extern int vmw_bo_pin_in_start_of_vram(struct vmw_private *vmw_priv,
847 struct vmw_buffer_object *bo,
848 bool interruptible);
849extern int vmw_bo_unpin(struct vmw_private *vmw_priv,
850 struct vmw_buffer_object *bo,
851 bool interruptible);
852extern void vmw_bo_get_guest_ptr(const struct ttm_buffer_object *buf,
853 SVGAGuestPtr *ptr);
854extern void vmw_bo_pin_reserved(struct vmw_buffer_object *bo, bool pin);
855extern void vmw_bo_bo_free(struct ttm_buffer_object *bo);
856extern int vmw_bo_create_kernel(struct vmw_private *dev_priv,
857 unsigned long size,
858 struct ttm_placement *placement,
859 struct ttm_buffer_object **p_bo);
860extern int vmw_bo_init(struct vmw_private *dev_priv,
861 struct vmw_buffer_object *vmw_bo,
862 size_t size, struct ttm_placement *placement,
863 bool interruptible, bool pin,
864 void (*bo_free)(struct ttm_buffer_object *bo));
865extern int vmw_user_bo_verify_access(struct ttm_buffer_object *bo,
866 struct ttm_object_file *tfile);
867extern int vmw_user_bo_alloc(struct vmw_private *dev_priv,
868 struct ttm_object_file *tfile,
869 uint32_t size,
870 bool shareable,
871 uint32_t *handle,
872 struct vmw_buffer_object **p_dma_buf,
873 struct ttm_base_object **p_base);
874extern int vmw_user_bo_reference(struct ttm_object_file *tfile,
875 struct vmw_buffer_object *dma_buf,
876 uint32_t *handle);
877extern int vmw_bo_alloc_ioctl(struct drm_device *dev, void *data,
878 struct drm_file *file_priv);
879extern int vmw_bo_unref_ioctl(struct drm_device *dev, void *data,
880 struct drm_file *file_priv);
881extern int vmw_user_bo_synccpu_ioctl(struct drm_device *dev, void *data,
882 struct drm_file *file_priv);
883extern int vmw_user_bo_lookup(struct ttm_object_file *tfile,
884 uint32_t id, struct vmw_buffer_object **out,
885 struct ttm_base_object **base);
886extern void vmw_bo_fence_single(struct ttm_buffer_object *bo,
887 struct vmw_fence_obj *fence);
888extern void *vmw_bo_map_and_cache(struct vmw_buffer_object *vbo);
889extern void vmw_bo_unmap(struct vmw_buffer_object *vbo);
890extern void vmw_bo_move_notify(struct ttm_buffer_object *bo,
891 struct ttm_resource *mem);
892extern void vmw_bo_swap_notify(struct ttm_buffer_object *bo);
893extern struct vmw_buffer_object *
894vmw_user_bo_noref_lookup(struct ttm_object_file *tfile, u32 handle);
895
896
897
898
899
900static inline void vmw_user_bo_noref_release(void)
901{
902 ttm_base_object_noref_release();
903}
904
905
906
907
908
909
910static inline void vmw_bo_prio_adjust(struct vmw_buffer_object *vbo)
911{
912 int i = ARRAY_SIZE(vbo->res_prios);
913
914 while (i--) {
915 if (vbo->res_prios[i]) {
916 vbo->base.priority = i;
917 return;
918 }
919 }
920
921 vbo->base.priority = 3;
922}
923
924
925
926
927
928
929
930
931
932
933static inline void vmw_bo_prio_add(struct vmw_buffer_object *vbo, int prio)
934{
935 if (vbo->res_prios[prio]++ == 0)
936 vmw_bo_prio_adjust(vbo);
937}
938
939
940
941
942
943
944
945
946
947
948static inline void vmw_bo_prio_del(struct vmw_buffer_object *vbo, int prio)
949{
950 if (--vbo->res_prios[prio] == 0)
951 vmw_bo_prio_adjust(vbo);
952}
953
954
955
956
957
958extern int vmw_getparam_ioctl(struct drm_device *dev, void *data,
959 struct drm_file *file_priv);
960extern int vmw_get_cap_3d_ioctl(struct drm_device *dev, void *data,
961 struct drm_file *file_priv);
962extern int vmw_present_ioctl(struct drm_device *dev, void *data,
963 struct drm_file *file_priv);
964extern int vmw_present_readback_ioctl(struct drm_device *dev, void *data,
965 struct drm_file *file_priv);
966
967
968
969
970
971extern struct vmw_fifo_state *vmw_fifo_create(struct vmw_private *dev_priv);
972extern void vmw_fifo_destroy(struct vmw_private *dev_priv);
973extern bool vmw_cmd_supported(struct vmw_private *vmw);
974extern void *
975vmw_cmd_ctx_reserve(struct vmw_private *dev_priv, uint32_t bytes, int ctx_id);
976extern void vmw_cmd_commit(struct vmw_private *dev_priv, uint32_t bytes);
977extern void vmw_cmd_commit_flush(struct vmw_private *dev_priv, uint32_t bytes);
978extern int vmw_cmd_send_fence(struct vmw_private *dev_priv, uint32_t *seqno);
979extern bool vmw_supports_3d(struct vmw_private *dev_priv);
980extern void vmw_fifo_ping_host(struct vmw_private *dev_priv, uint32_t reason);
981extern bool vmw_fifo_have_pitchlock(struct vmw_private *dev_priv);
982extern int vmw_cmd_emit_dummy_query(struct vmw_private *dev_priv,
983 uint32_t cid);
984extern int vmw_cmd_flush(struct vmw_private *dev_priv,
985 bool interruptible);
986
987#define VMW_CMD_CTX_RESERVE(__priv, __bytes, __ctx_id) \
988({ \
989 vmw_cmd_ctx_reserve(__priv, __bytes, __ctx_id) ? : ({ \
990 DRM_ERROR("FIFO reserve failed at %s for %u bytes\n", \
991 __func__, (unsigned int) __bytes); \
992 NULL; \
993 }); \
994})
995
996#define VMW_CMD_RESERVE(__priv, __bytes) \
997 VMW_CMD_CTX_RESERVE(__priv, __bytes, SVGA3D_INVALID_ID)
998
999
1000
1001
1002
1003
1004
1005static inline uint32_t vmw_fifo_caps(const struct vmw_private *dev_priv)
1006{
1007 if (!dev_priv->fifo_mem || !dev_priv->fifo)
1008 return 0;
1009 return dev_priv->fifo->capabilities;
1010}
1011
1012
1013
1014
1015
1016
1017
1018static inline bool
1019vmw_is_cursor_bypass3_enabled(const struct vmw_private *dev_priv)
1020{
1021 return (vmw_fifo_caps(dev_priv) & SVGA_FIFO_CAP_CURSOR_BYPASS_3) != 0;
1022}
1023
1024
1025
1026
1027
1028extern int vmw_mmap(struct file *filp, struct vm_area_struct *vma);
1029
1030extern void vmw_validation_mem_init_ttm(struct vmw_private *dev_priv,
1031 size_t gran);
1032
1033
1034
1035
1036
1037extern const size_t vmw_tt_size;
1038extern struct ttm_placement vmw_vram_placement;
1039extern struct ttm_placement vmw_vram_sys_placement;
1040extern struct ttm_placement vmw_vram_gmr_placement;
1041extern struct ttm_placement vmw_sys_placement;
1042extern struct ttm_placement vmw_evictable_placement;
1043extern struct ttm_placement vmw_srf_placement;
1044extern struct ttm_placement vmw_mob_placement;
1045extern struct ttm_placement vmw_nonfixed_placement;
1046extern struct ttm_device_funcs vmw_bo_driver;
1047extern const struct vmw_sg_table *
1048vmw_bo_sg_table(struct ttm_buffer_object *bo);
1049extern int vmw_bo_create_and_populate(struct vmw_private *dev_priv,
1050 unsigned long bo_size,
1051 struct ttm_buffer_object **bo_p);
1052
1053extern void vmw_piter_start(struct vmw_piter *viter,
1054 const struct vmw_sg_table *vsgt,
1055 unsigned long p_offs);
1056
1057
1058
1059
1060
1061
1062
1063
1064static inline bool vmw_piter_next(struct vmw_piter *viter)
1065{
1066 return viter->next(viter);
1067}
1068
1069
1070
1071
1072
1073
1074
1075
1076static inline dma_addr_t vmw_piter_dma_addr(struct vmw_piter *viter)
1077{
1078 return viter->dma_address(viter);
1079}
1080
1081
1082
1083
1084
1085
1086
1087
1088static inline struct page *vmw_piter_page(struct vmw_piter *viter)
1089{
1090 return viter->pages[viter->i];
1091}
1092
1093
1094
1095
1096
1097extern int vmw_execbuf_ioctl(struct drm_device *dev, void *data,
1098 struct drm_file *file_priv);
1099extern int vmw_execbuf_process(struct drm_file *file_priv,
1100 struct vmw_private *dev_priv,
1101 void __user *user_commands,
1102 void *kernel_commands,
1103 uint32_t command_size,
1104 uint64_t throttle_us,
1105 uint32_t dx_context_handle,
1106 struct drm_vmw_fence_rep __user
1107 *user_fence_rep,
1108 struct vmw_fence_obj **out_fence,
1109 uint32_t flags);
1110extern void __vmw_execbuf_release_pinned_bo(struct vmw_private *dev_priv,
1111 struct vmw_fence_obj *fence);
1112extern void vmw_execbuf_release_pinned_bo(struct vmw_private *dev_priv);
1113
1114extern int vmw_execbuf_fence_commands(struct drm_file *file_priv,
1115 struct vmw_private *dev_priv,
1116 struct vmw_fence_obj **p_fence,
1117 uint32_t *p_handle);
1118extern void vmw_execbuf_copy_fence_user(struct vmw_private *dev_priv,
1119 struct vmw_fpriv *vmw_fp,
1120 int ret,
1121 struct drm_vmw_fence_rep __user
1122 *user_fence_rep,
1123 struct vmw_fence_obj *fence,
1124 uint32_t fence_handle,
1125 int32_t out_fence_fd,
1126 struct sync_file *sync_file);
1127bool vmw_cmd_describe(const void *buf, u32 *size, char const **cmd);
1128
1129
1130
1131
1132
1133extern int vmw_irq_install(struct drm_device *dev, int irq);
1134extern void vmw_irq_uninstall(struct drm_device *dev);
1135extern bool vmw_seqno_passed(struct vmw_private *dev_priv,
1136 uint32_t seqno);
1137extern int vmw_fallback_wait(struct vmw_private *dev_priv,
1138 bool lazy,
1139 bool fifo_idle,
1140 uint32_t seqno,
1141 bool interruptible,
1142 unsigned long timeout);
1143extern void vmw_update_seqno(struct vmw_private *dev_priv);
1144extern void vmw_seqno_waiter_add(struct vmw_private *dev_priv);
1145extern void vmw_seqno_waiter_remove(struct vmw_private *dev_priv);
1146extern void vmw_goal_waiter_add(struct vmw_private *dev_priv);
1147extern void vmw_goal_waiter_remove(struct vmw_private *dev_priv);
1148extern void vmw_generic_waiter_add(struct vmw_private *dev_priv, u32 flag,
1149 int *waiter_count);
1150extern void vmw_generic_waiter_remove(struct vmw_private *dev_priv,
1151 u32 flag, int *waiter_count);
1152
1153
1154
1155
1156
1157
1158#ifdef CONFIG_DRM_FBDEV_EMULATION
1159int vmw_fb_init(struct vmw_private *vmw_priv);
1160int vmw_fb_close(struct vmw_private *dev_priv);
1161int vmw_fb_off(struct vmw_private *vmw_priv);
1162int vmw_fb_on(struct vmw_private *vmw_priv);
1163#else
1164static inline int vmw_fb_init(struct vmw_private *vmw_priv)
1165{
1166 return 0;
1167}
1168static inline int vmw_fb_close(struct vmw_private *dev_priv)
1169{
1170 return 0;
1171}
1172static inline int vmw_fb_off(struct vmw_private *vmw_priv)
1173{
1174 return 0;
1175}
1176static inline int vmw_fb_on(struct vmw_private *vmw_priv)
1177{
1178 return 0;
1179}
1180#endif
1181
1182
1183
1184
1185
1186int vmw_kms_init(struct vmw_private *dev_priv);
1187int vmw_kms_close(struct vmw_private *dev_priv);
1188int vmw_kms_cursor_bypass_ioctl(struct drm_device *dev, void *data,
1189 struct drm_file *file_priv);
1190void vmw_kms_cursor_post_execbuf(struct vmw_private *dev_priv);
1191void vmw_kms_cursor_snoop(struct vmw_surface *srf,
1192 struct ttm_object_file *tfile,
1193 struct ttm_buffer_object *bo,
1194 SVGA3dCmdHeader *header);
1195int vmw_kms_write_svga(struct vmw_private *vmw_priv,
1196 unsigned width, unsigned height, unsigned pitch,
1197 unsigned bpp, unsigned depth);
1198bool vmw_kms_validate_mode_vram(struct vmw_private *dev_priv,
1199 uint32_t pitch,
1200 uint32_t height);
1201u32 vmw_get_vblank_counter(struct drm_crtc *crtc);
1202int vmw_enable_vblank(struct drm_crtc *crtc);
1203void vmw_disable_vblank(struct drm_crtc *crtc);
1204int vmw_kms_present(struct vmw_private *dev_priv,
1205 struct drm_file *file_priv,
1206 struct vmw_framebuffer *vfb,
1207 struct vmw_surface *surface,
1208 uint32_t sid, int32_t destX, int32_t destY,
1209 struct drm_vmw_rect *clips,
1210 uint32_t num_clips);
1211int vmw_kms_update_layout_ioctl(struct drm_device *dev, void *data,
1212 struct drm_file *file_priv);
1213void vmw_kms_legacy_hotspot_clear(struct vmw_private *dev_priv);
1214int vmw_kms_suspend(struct drm_device *dev);
1215int vmw_kms_resume(struct drm_device *dev);
1216void vmw_kms_lost_device(struct drm_device *dev);
1217
1218int vmw_dumb_create(struct drm_file *file_priv,
1219 struct drm_device *dev,
1220 struct drm_mode_create_dumb *args);
1221
1222int vmw_dumb_map_offset(struct drm_file *file_priv,
1223 struct drm_device *dev, uint32_t handle,
1224 uint64_t *offset);
1225int vmw_dumb_destroy(struct drm_file *file_priv,
1226 struct drm_device *dev,
1227 uint32_t handle);
1228extern int vmw_resource_pin(struct vmw_resource *res, bool interruptible);
1229extern void vmw_resource_unpin(struct vmw_resource *res);
1230extern enum vmw_res_type vmw_res_type(const struct vmw_resource *res);
1231
1232
1233
1234
1235
1236int vmw_overlay_init(struct vmw_private *dev_priv);
1237int vmw_overlay_close(struct vmw_private *dev_priv);
1238int vmw_overlay_ioctl(struct drm_device *dev, void *data,
1239 struct drm_file *file_priv);
1240int vmw_overlay_resume_all(struct vmw_private *dev_priv);
1241int vmw_overlay_pause_all(struct vmw_private *dev_priv);
1242int vmw_overlay_claim(struct vmw_private *dev_priv, uint32_t *out);
1243int vmw_overlay_unref(struct vmw_private *dev_priv, uint32_t stream_id);
1244int vmw_overlay_num_overlays(struct vmw_private *dev_priv);
1245int vmw_overlay_num_free_overlays(struct vmw_private *dev_priv);
1246
1247
1248
1249
1250
1251int vmw_gmrid_man_init(struct vmw_private *dev_priv, int type);
1252void vmw_gmrid_man_fini(struct vmw_private *dev_priv, int type);
1253
1254
1255
1256
1257
1258extern const struct dma_buf_ops vmw_prime_dmabuf_ops;
1259extern int vmw_prime_fd_to_handle(struct drm_device *dev,
1260 struct drm_file *file_priv,
1261 int fd, u32 *handle);
1262extern int vmw_prime_handle_to_fd(struct drm_device *dev,
1263 struct drm_file *file_priv,
1264 uint32_t handle, uint32_t flags,
1265 int *prime_fd);
1266
1267
1268
1269
1270struct vmw_mob;
1271extern int vmw_mob_bind(struct vmw_private *dev_priv, struct vmw_mob *mob,
1272 const struct vmw_sg_table *vsgt,
1273 unsigned long num_data_pages, int32_t mob_id);
1274extern void vmw_mob_unbind(struct vmw_private *dev_priv,
1275 struct vmw_mob *mob);
1276extern void vmw_mob_destroy(struct vmw_mob *mob);
1277extern struct vmw_mob *vmw_mob_create(unsigned long data_pages);
1278extern int vmw_otables_setup(struct vmw_private *dev_priv);
1279extern void vmw_otables_takedown(struct vmw_private *dev_priv);
1280
1281
1282
1283
1284
1285extern const struct vmw_user_resource_conv *user_context_converter;
1286
1287extern int vmw_context_define_ioctl(struct drm_device *dev, void *data,
1288 struct drm_file *file_priv);
1289extern int vmw_extended_context_define_ioctl(struct drm_device *dev, void *data,
1290 struct drm_file *file_priv);
1291extern int vmw_context_destroy_ioctl(struct drm_device *dev, void *data,
1292 struct drm_file *file_priv);
1293extern struct list_head *vmw_context_binding_list(struct vmw_resource *ctx);
1294extern struct vmw_cmdbuf_res_manager *
1295vmw_context_res_man(struct vmw_resource *ctx);
1296extern struct vmw_resource *vmw_context_cotable(struct vmw_resource *ctx,
1297 SVGACOTableType cotable_type);
1298struct vmw_ctx_binding_state;
1299extern struct vmw_ctx_binding_state *
1300vmw_context_binding_state(struct vmw_resource *ctx);
1301extern void vmw_dx_context_scrub_cotables(struct vmw_resource *ctx,
1302 bool readback);
1303extern int vmw_context_bind_dx_query(struct vmw_resource *ctx_res,
1304 struct vmw_buffer_object *mob);
1305extern struct vmw_buffer_object *
1306vmw_context_get_dx_query_mob(struct vmw_resource *ctx_res);
1307
1308
1309
1310
1311
1312
1313extern const struct vmw_user_resource_conv *user_surface_converter;
1314
1315extern int vmw_surface_destroy_ioctl(struct drm_device *dev, void *data,
1316 struct drm_file *file_priv);
1317extern int vmw_surface_define_ioctl(struct drm_device *dev, void *data,
1318 struct drm_file *file_priv);
1319extern int vmw_surface_reference_ioctl(struct drm_device *dev, void *data,
1320 struct drm_file *file_priv);
1321extern int vmw_gb_surface_define_ioctl(struct drm_device *dev, void *data,
1322 struct drm_file *file_priv);
1323extern int vmw_gb_surface_reference_ioctl(struct drm_device *dev, void *data,
1324 struct drm_file *file_priv);
1325int vmw_surface_gb_priv_define(struct drm_device *dev,
1326 uint32_t user_accounting_size,
1327 SVGA3dSurfaceAllFlags svga3d_flags,
1328 SVGA3dSurfaceFormat format,
1329 bool for_scanout,
1330 uint32_t num_mip_levels,
1331 uint32_t multisample_count,
1332 uint32_t array_size,
1333 struct drm_vmw_size size,
1334 SVGA3dMSPattern multisample_pattern,
1335 SVGA3dMSQualityLevel quality_level,
1336 struct vmw_surface **srf_out);
1337extern int vmw_gb_surface_define_ext_ioctl(struct drm_device *dev,
1338 void *data,
1339 struct drm_file *file_priv);
1340extern int vmw_gb_surface_reference_ext_ioctl(struct drm_device *dev,
1341 void *data,
1342 struct drm_file *file_priv);
1343
1344int vmw_gb_surface_define(struct vmw_private *dev_priv,
1345 uint32_t user_accounting_size,
1346 const struct vmw_surface_metadata *req,
1347 struct vmw_surface **srf_out);
1348
1349
1350
1351
1352
1353extern const struct vmw_user_resource_conv *user_shader_converter;
1354
1355extern int vmw_shader_define_ioctl(struct drm_device *dev, void *data,
1356 struct drm_file *file_priv);
1357extern int vmw_shader_destroy_ioctl(struct drm_device *dev, void *data,
1358 struct drm_file *file_priv);
1359extern int vmw_compat_shader_add(struct vmw_private *dev_priv,
1360 struct vmw_cmdbuf_res_manager *man,
1361 u32 user_key, const void *bytecode,
1362 SVGA3dShaderType shader_type,
1363 size_t size,
1364 struct list_head *list);
1365extern int vmw_shader_remove(struct vmw_cmdbuf_res_manager *man,
1366 u32 user_key, SVGA3dShaderType shader_type,
1367 struct list_head *list);
1368extern int vmw_dx_shader_add(struct vmw_cmdbuf_res_manager *man,
1369 struct vmw_resource *ctx,
1370 u32 user_key,
1371 SVGA3dShaderType shader_type,
1372 struct list_head *list);
1373extern void vmw_dx_shader_cotable_list_scrub(struct vmw_private *dev_priv,
1374 struct list_head *list,
1375 bool readback);
1376
1377extern struct vmw_resource *
1378vmw_shader_lookup(struct vmw_cmdbuf_res_manager *man,
1379 u32 user_key, SVGA3dShaderType shader_type);
1380
1381
1382
1383
1384struct vmw_resource *
1385vmw_dx_streamoutput_lookup(struct vmw_cmdbuf_res_manager *man,
1386 u32 user_key);
1387int vmw_dx_streamoutput_add(struct vmw_cmdbuf_res_manager *man,
1388 struct vmw_resource *ctx,
1389 SVGA3dStreamOutputId user_key,
1390 struct list_head *list);
1391void vmw_dx_streamoutput_set_size(struct vmw_resource *res, u32 size);
1392int vmw_dx_streamoutput_remove(struct vmw_cmdbuf_res_manager *man,
1393 SVGA3dStreamOutputId user_key,
1394 struct list_head *list);
1395void vmw_dx_streamoutput_cotable_list_scrub(struct vmw_private *dev_priv,
1396 struct list_head *list,
1397 bool readback);
1398
1399
1400
1401
1402
1403extern struct vmw_cmdbuf_res_manager *
1404vmw_cmdbuf_res_man_create(struct vmw_private *dev_priv);
1405extern void vmw_cmdbuf_res_man_destroy(struct vmw_cmdbuf_res_manager *man);
1406extern size_t vmw_cmdbuf_res_man_size(void);
1407extern struct vmw_resource *
1408vmw_cmdbuf_res_lookup(struct vmw_cmdbuf_res_manager *man,
1409 enum vmw_cmdbuf_res_type res_type,
1410 u32 user_key);
1411extern void vmw_cmdbuf_res_revert(struct list_head *list);
1412extern void vmw_cmdbuf_res_commit(struct list_head *list);
1413extern int vmw_cmdbuf_res_add(struct vmw_cmdbuf_res_manager *man,
1414 enum vmw_cmdbuf_res_type res_type,
1415 u32 user_key,
1416 struct vmw_resource *res,
1417 struct list_head *list);
1418extern int vmw_cmdbuf_res_remove(struct vmw_cmdbuf_res_manager *man,
1419 enum vmw_cmdbuf_res_type res_type,
1420 u32 user_key,
1421 struct list_head *list,
1422 struct vmw_resource **res);
1423
1424
1425
1426
1427extern const SVGACOTableType vmw_cotable_scrub_order[];
1428extern struct vmw_resource *vmw_cotable_alloc(struct vmw_private *dev_priv,
1429 struct vmw_resource *ctx,
1430 u32 type);
1431extern int vmw_cotable_notify(struct vmw_resource *res, int id);
1432extern int vmw_cotable_scrub(struct vmw_resource *res, bool readback);
1433extern void vmw_cotable_add_resource(struct vmw_resource *ctx,
1434 struct list_head *head);
1435
1436
1437
1438
1439struct vmw_cmdbuf_man;
1440struct vmw_cmdbuf_header;
1441
1442extern struct vmw_cmdbuf_man *
1443vmw_cmdbuf_man_create(struct vmw_private *dev_priv);
1444extern int vmw_cmdbuf_set_pool_size(struct vmw_cmdbuf_man *man, size_t size);
1445extern void vmw_cmdbuf_remove_pool(struct vmw_cmdbuf_man *man);
1446extern void vmw_cmdbuf_man_destroy(struct vmw_cmdbuf_man *man);
1447extern int vmw_cmdbuf_idle(struct vmw_cmdbuf_man *man, bool interruptible,
1448 unsigned long timeout);
1449extern void *vmw_cmdbuf_reserve(struct vmw_cmdbuf_man *man, size_t size,
1450 int ctx_id, bool interruptible,
1451 struct vmw_cmdbuf_header *header);
1452extern void vmw_cmdbuf_commit(struct vmw_cmdbuf_man *man, size_t size,
1453 struct vmw_cmdbuf_header *header,
1454 bool flush);
1455extern void *vmw_cmdbuf_alloc(struct vmw_cmdbuf_man *man,
1456 size_t size, bool interruptible,
1457 struct vmw_cmdbuf_header **p_header);
1458extern void vmw_cmdbuf_header_free(struct vmw_cmdbuf_header *header);
1459extern int vmw_cmdbuf_cur_flush(struct vmw_cmdbuf_man *man,
1460 bool interruptible);
1461extern void vmw_cmdbuf_irqthread(struct vmw_cmdbuf_man *man);
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474struct vmw_diff_cpy {
1475 struct drm_rect rect;
1476 size_t line;
1477 size_t line_offset;
1478 int cpp;
1479 void (*do_cpy)(struct vmw_diff_cpy *diff, u8 *dest, const u8 *src,
1480 size_t n);
1481};
1482
1483#define VMW_CPU_BLIT_INITIALIZER { \
1484 .do_cpy = vmw_memcpy, \
1485}
1486
1487#define VMW_CPU_BLIT_DIFF_INITIALIZER(_cpp) { \
1488 .line = 0, \
1489 .line_offset = 0, \
1490 .rect = { .x1 = INT_MAX/2, \
1491 .y1 = INT_MAX/2, \
1492 .x2 = INT_MIN/2, \
1493 .y2 = INT_MIN/2 \
1494 }, \
1495 .cpp = _cpp, \
1496 .do_cpy = vmw_diff_memcpy, \
1497}
1498
1499void vmw_diff_memcpy(struct vmw_diff_cpy *diff, u8 *dest, const u8 *src,
1500 size_t n);
1501
1502void vmw_memcpy(struct vmw_diff_cpy *diff, u8 *dest, const u8 *src, size_t n);
1503
1504int vmw_bo_cpu_blit(struct ttm_buffer_object *dst,
1505 u32 dst_offset, u32 dst_stride,
1506 struct ttm_buffer_object *src,
1507 u32 src_offset, u32 src_stride,
1508 u32 w, u32 h,
1509 struct vmw_diff_cpy *diff);
1510
1511
1512int vmw_host_get_guestinfo(const char *guest_info_param,
1513 char *buffer, size_t *length);
1514__printf(1, 2) int vmw_host_printf(const char *fmt, ...);
1515int vmw_msg_ioctl(struct drm_device *dev, void *data,
1516 struct drm_file *file_priv);
1517
1518
1519int vmw_mksstat_get_kern_slot(pid_t pid, struct vmw_private *dev_priv);
1520
1521int vmw_mksstat_reset_ioctl(struct drm_device *dev, void *data,
1522 struct drm_file *file_priv);
1523int vmw_mksstat_add_ioctl(struct drm_device *dev, void *data,
1524 struct drm_file *file_priv);
1525int vmw_mksstat_remove_ioctl(struct drm_device *dev, void *data,
1526 struct drm_file *file_priv);
1527int vmw_mksstat_remove_all(struct vmw_private *dev_priv);
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540#define VMW_DEBUG_USER(fmt, ...) \
1541 DRM_DEBUG_DRIVER(fmt, ##__VA_ARGS__)
1542
1543
1544void vmw_bo_dirty_scan(struct vmw_buffer_object *vbo);
1545int vmw_bo_dirty_add(struct vmw_buffer_object *vbo);
1546void vmw_bo_dirty_transfer_to_res(struct vmw_resource *res);
1547void vmw_bo_dirty_clear_res(struct vmw_resource *res);
1548void vmw_bo_dirty_release(struct vmw_buffer_object *vbo);
1549void vmw_bo_dirty_unmap(struct vmw_buffer_object *vbo,
1550 pgoff_t start, pgoff_t end);
1551vm_fault_t vmw_bo_vm_fault(struct vm_fault *vmf);
1552vm_fault_t vmw_bo_vm_mkwrite(struct vm_fault *vmf);
1553#ifdef CONFIG_TRANSPARENT_HUGEPAGE
1554vm_fault_t vmw_bo_vm_huge_fault(struct vm_fault *vmf,
1555 enum page_entry_size pe_size);
1556#endif
1557
1558
1559#ifdef CONFIG_TRANSPARENT_HUGEPAGE
1560extern int vmw_thp_init(struct vmw_private *dev_priv);
1561void vmw_thp_fini(struct vmw_private *dev_priv);
1562#endif
1563
1564
1565
1566
1567
1568
1569#define VMW_DEBUG_KMS(fmt, ...) \
1570 DRM_DEBUG_DRIVER(fmt, ##__VA_ARGS__)
1571
1572
1573
1574
1575
1576static inline void vmw_surface_unreference(struct vmw_surface **srf)
1577{
1578 struct vmw_surface *tmp_srf = *srf;
1579 struct vmw_resource *res = &tmp_srf->res;
1580 *srf = NULL;
1581
1582 vmw_resource_unreference(&res);
1583}
1584
1585static inline struct vmw_surface *vmw_surface_reference(struct vmw_surface *srf)
1586{
1587 (void) vmw_resource_reference(&srf->res);
1588 return srf;
1589}
1590
1591static inline void vmw_bo_unreference(struct vmw_buffer_object **buf)
1592{
1593 struct vmw_buffer_object *tmp_buf = *buf;
1594
1595 *buf = NULL;
1596 if (tmp_buf != NULL)
1597 ttm_bo_put(&tmp_buf->base);
1598}
1599
1600static inline struct vmw_buffer_object *
1601vmw_bo_reference(struct vmw_buffer_object *buf)
1602{
1603 ttm_bo_get(&buf->base);
1604 return buf;
1605}
1606
1607static inline struct ttm_mem_global *vmw_mem_glob(struct vmw_private *dev_priv)
1608{
1609 return &ttm_mem_glob;
1610}
1611
1612static inline void vmw_fifo_resource_inc(struct vmw_private *dev_priv)
1613{
1614 atomic_inc(&dev_priv->num_fifo_resources);
1615}
1616
1617static inline void vmw_fifo_resource_dec(struct vmw_private *dev_priv)
1618{
1619 atomic_dec(&dev_priv->num_fifo_resources);
1620}
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630static inline u32 vmw_fifo_mem_read(struct vmw_private *vmw, uint32 fifo_reg)
1631{
1632 BUG_ON(vmw_is_svga_v3(vmw));
1633 return READ_ONCE(*(vmw->fifo_mem + fifo_reg));
1634}
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644static inline void vmw_fifo_mem_write(struct vmw_private *vmw, u32 fifo_reg,
1645 u32 value)
1646{
1647 BUG_ON(vmw_is_svga_v3(vmw));
1648 WRITE_ONCE(*(vmw->fifo_mem + fifo_reg), value);
1649}
1650
1651static inline u32 vmw_fence_read(struct vmw_private *dev_priv)
1652{
1653 u32 fence;
1654 if (vmw_is_svga_v3(dev_priv))
1655 fence = vmw_read(dev_priv, SVGA_REG_FENCE);
1656 else
1657 fence = vmw_fifo_mem_read(dev_priv, SVGA_FIFO_FENCE);
1658 return fence;
1659}
1660
1661static inline void vmw_fence_write(struct vmw_private *dev_priv,
1662 u32 fence)
1663{
1664 BUG_ON(vmw_is_svga_v3(dev_priv));
1665 vmw_fifo_mem_write(dev_priv, SVGA_FIFO_FENCE, fence);
1666}
1667
1668static inline u32 vmw_irq_status_read(struct vmw_private *vmw)
1669{
1670 u32 status;
1671 if (vmw_is_svga_v3(vmw))
1672 status = vmw_read(vmw, SVGA_REG_IRQ_STATUS);
1673 else
1674 status = inl(vmw->io_start + SVGA_IRQSTATUS_PORT);
1675 return status;
1676}
1677
1678static inline void vmw_irq_status_write(struct vmw_private *vmw,
1679 uint32 status)
1680{
1681 if (vmw_is_svga_v3(vmw))
1682 vmw_write(vmw, SVGA_REG_IRQ_STATUS, status);
1683 else
1684 outl(status, vmw->io_start + SVGA_IRQSTATUS_PORT);
1685}
1686
1687#endif
1688